SQLite Sequence Error on Update/Delete Mutations: 'SQLite Sequence should not be empty'

[mikecfisher]

Bug Report

Environment

• Package: `@powersync/web` v1.29.0
• Database: SQLite WASM (`WASQLiteOpenFactory`)
• Framework: Next.js 16, React 19
• Integration: TanStack DB (`@tanstack/react-db`)

Problem

UPDATE/DELETE mutations randomly fail with:

Error: SQLite Sequence should not be empty

Error occurs in PowerSync worker at line ~16931:

const rs = await tx.execute("SELECT seq FROM sqlite_sequence WHERE name = 'ps_crud'");
if (!rs.rows?.length) {
    throw new Error('SQLite Sequence should not be empty');
}

Root Cause

PowerSync's internal ps_crud table uses INTEGER PRIMARY KEY AUTOINCREMENT, which requires a sqlite_sequence entry. The worker checks for
the sequence entry BEFORE inserting, but the entry doesn't exist on a fresh database until the first INSERT.

Race condition:

1. Fresh page load → PowerSync initializes → ps_crud is empty
2. User triggers update/delete mutation immediately
3. PowerSync checks sqlite_sequence for ps_crud entry
4. Entry doesn't exist (never inserted yet) → Error thrown
5. INSERT never happens → sequence never auto-created

Why It's Intermittent

Scenario 1 (ERROR):

• Fresh load → immediate update/delete
• No prior writes to ps_crud → no sequence entry
• ❌ Error

Scenario 2 (WORKS):

• Fresh load → background sync runs first
• Sync writes to ps_crud → SQLite auto-creates sequence entry
• User triggers mutation
• ✅ Works (sequence exists)

INSERT operations work fine because they're usually slower (user fills form). UPDATE/DELETE happen immediately (single button click),
so they race the background sync.

Reproduction

import { PowerSyncDatabase } from '@powersync/web';
import { powerSyncCollectionOptions } from '@tanstack/react-db';

// 1. Initialize PowerSync (fresh IndexedDB)
const db = new PowerSyncDatabase({ schema, database: factory });
await db.init();

// 2. Create TanStack collection
const collection = createCollection(
  powerSyncCollectionOptions({
    db,
    table: schema.tables.items
  })
);

// 3. Immediately trigger update/delete (before any inserts)
const tx = collection.update('item-1', (draft) => {
  draft.name = 'Updated';
});

await tx.isPersisted.promise;  // ❌ Error: SQLite Sequence should not be empty

My Workaround

I pre-seed the sqlite_sequence table before mutations:

// Utility with WeakSet caching
const seededDatabases = new WeakSet<PowerSyncDatabase>();

export async function ensurePsCrudSequence(db: PowerSyncDatabase) {
  if (seededDatabases.has(db)) return;

  await db.database.execute(
    "INSERT OR IGNORE INTO sqlite_sequence(name, seq) VALUES('ps_crud', 0)"
  );

  seededDatabases.add(db);
}

// Before every update/delete mutation:
await ensurePsCrudSequence(db);
collection.update(id, (draft) => { ... });

This works, but I'm unsure if:

1. Is this expected behavior? Should we manually seed the sequence?
2. Should PowerSync handle this internally? Either:
   • Don't check sequence before first write (let SQLite auto-create)
   • OR seed sequence during db.init()
3. Is there a better approach? Are we missing a configuration option?

Expected Behavior

Update/delete mutations should work immediately after initialization without manual sequence seeding, just like INSERT operations do.

Additional Context

• Sequence seeding in `db.init()` didn't work (timing issue)
• Lazy seeding before mutations is reliable but feels like a workaround
• Issue affects all TanStack DB PowerSync collections
• Error only happens with WASM workers (manual loading for Turbopack)

Question

Is my workaround correct, or is there a proper way to initialize the ps_crud sequence during PowerSync setup?

Thank you!

[stevensJourney]

Thanks for the report! This does seem like a race condition in our SDK logic.

Is my workaround correct, or is there a proper way to initialize the ps_crud sequence during PowerSync setup?

I think your workaround should work for now. However you should not need to do that.

We'll investigate and debug this on our end.

[mikecfisher]

@stevensJourney hey, thanks for the quick response! i've been digging into this and wanted to share what i found, might help with the debugging.

so the issue is happening at SqliteBucketStorage.ts:279 in the powersync source where it does this check:

const rs = await tx.execute("SELECT seq FROM sqlite_sequence WHERE name = 'ps_crud'");
if (!rs.rows?.length) {
    throw new Error('SQLite Sequence should not be empty');
}

what's going on is that powersync's internal ps_crud table uses AUTOINCREMENT and needs a sequence entry before any write operation. the problem is that UPDATE/DELETE can fire immediately after init, before any INSERT happens to auto-create the sequence.

most apps do INSERT first (like creating a record in a form) which naturally creates the sequence. but in my guest check-in app, users can hit "check in" immediately on page load, so it's UPDATE-first and races the background sync.

i searched through the tanstack db codebase and they basically expect powersync to handle this - there's no built-in sequence management. all mutations go through the same ps_crud path.

my workaround is actually the right approach:

export async function ensurePsCrudSequence(db: PowerSyncDatabase) {
  if (seededDatabases.has(db)) return;
  
  await db.database.execute(
    "INSERT OR IGNORE INTO sqlite_sequence(name, seq) VALUES('ps_crud', 0)"
  );
  
  seededDatabases.add(db);
}

it's idempotent, fast with the WeakSet cache, and matches what powersync expects internally.

Claude Suggested this for a fix 😄

1. lazy sequence creation (cleanest) - seed the sequence right before the check in SqliteBucketStorage.ts
2. init seeding - do it during db.init() but make sure it's after the worker is ready
3. document it - add a note that UPDATE/DELETE-first apps need to seed manually

happy to test any fixes or dig deeper if you need more details!

repro case for testing:

const db = new PowerSyncDatabase({ schema, database: factory });
await db.init();

// immediate UPDATE without any prior INSERT
const collection = createCollection(powerSyncCollectionOptions({ db, table: schema.tables.items }));
const tx = collection.update('item-1', (draft) => {
  draft.name = 'Updated';
});
await tx.isPersisted.promise; // should not throw

[stevensJourney]

The root cause of this was the use of temporary SQLite tables in the Trigger based diff tracking used by the TanStackDB integration. A fix for this issue has been released for the various PowerSync SDKs in #782