@anfenn/dync 1.0.0 → 1.0.2

package/dist/react/index.d.cts

@@ -1,4 +1,4 @@
-import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-YSn6c01d.cjs';
+import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-BGwvMH8f.cjs';
 import { c as StorageAdapter } from '../dexie-Bv-fV10P.cjs';
 import '../types-CSbIAfu2.cjs';
 import 'dexie';

package/dist/react/index.d.ts

@@ -1,4 +1,4 @@
-import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-CPIge2ZM.js';
+import { a as ApiFunctions, h as SyncOptions, B as BatchSync, D as Dync, i as SyncState } from '../index.shared-CkYsQYyn.js';
 import { c as StorageAdapter } from '../dexie-DJFApKsM.js';
 import '../types-CSbIAfu2.js';
 import 'dexie';

package/dist/react/index.js

@@ -1,6 +1,6 @@
 import {
   Dync
-} from "../chunk-LGHOZECP.js";
+} from "../chunk-66PSQW4D.js";
 import "../chunk-SQB6E7V2.js";
 
 // src/react/useDync.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anfenn/dync",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "private": false,
   "description": "Write once, run IndexedDB & SQLite with sync anywhere - React, React Native, Expo, Capacitor, Electron & Node.js",
   "keywords": [],
@@ -96,9 +96,6 @@
     "build": "pnpm run format && pnpm run lint && pnpm exec tsc --noEmit && tsup",
     "build:all": "pnpm run build && pnpm --filter react-capacitor build",
     "dev": "tsup --watch",
-    "dev:capacitor": "pnpm --filter react-capacitor run dev",
-    "dev:expo:web": "pnpm --filter react-native-expo-sqlite web --clear",
-    "dev:expo:start": "pnpm --filter react-native-expo-sqlite start --clear",
     "lint": "eslint . --fix \"src/**/*.{js,jsx,ts,tsx,json}\"",
     "format": "prettier --write \"**/*.{ts,tsx,md}\"",
     "size": "pnpm --filter size size",
@@ -167,5 +164,10 @@
       "esbuild",
       "unrs-resolver"
     ]
+  },
+  "dependencies": {
+    "expo": "~54.0.29",
+    "react": "19.1.0",
+    "react-native": "0.81.5"
   }
 }

package/src/core/StateManager.ts

@@ -30,10 +30,10 @@ export interface StateHelpers {
     setState(setterOrState: PersistedSyncState | ((state: PersistedSyncState) => Partial<PersistedSyncState>)): Promise<void>;
     setErrorInMemory(error: Error): void;
     addPendingChange(change: Omit<PendingChange, 'version'>): Promise<void>;
-    samePendingVersion(stateKey: string, localId: string, version: number): boolean;
-    removePendingChange(localId: string, stateKey: string): Promise<void>;
-    updatePendingChange(stateKey: string, localId: string, action: SyncAction, id?: any): Promise<void>;
-    setPendingChangeBefore(stateKey: string, localId: string, before: any): Promise<void>;
+    samePendingVersion(tableName: string, localId: string, version: number): boolean;
+    removePendingChange(localId: string, tableName: string): Promise<void>;
+    updatePendingChange(tableName: string, localId: string, action: SyncAction, id?: any): Promise<void>;
+    setPendingChangeBefore(tableName: string, localId: string, before: any): Promise<void>;
     hasConflicts(localId: string): boolean;
     getSyncStatus(): SyncStatus;
     setSyncStatus(status: SyncStatus): void;
@@ -111,7 +111,7 @@ export class StateManager implements StateHelpers {
 
     addPendingChange(change: Omit<PendingChange, 'version'>): Promise<void> {
         const next = clonePersistedState(this.persistedState);
-        const queueItem = next.pendingChanges.find((p) => p.localId === change.localId && p.stateKey === change.stateKey);
+        const queueItem = next.pendingChanges.find((p) => p.localId === change.localId && p.tableName === change.tableName);
 
         const omittedChanges = omitFields(change.changes, LOCAL_ONLY_SYNC_FIELDS);
         const omittedBefore = omitFields(change.before, LOCAL_ONLY_SYNC_FIELDS);
@@ -136,7 +136,7 @@ export class StateManager implements StateHelpers {
             next.pendingChanges = [...next.pendingChanges];
             next.pendingChanges.push({
                 action,
-                stateKey: change.stateKey,
+                tableName: change.tableName,
                 localId: change.localId,
                 id: change.id,
                 version: 1,
@@ -150,20 +150,20 @@ export class StateManager implements StateHelpers {
         return this.persist();
     }
 
-    samePendingVersion(stateKey: string, localId: string, version: number): boolean {
-        return this.persistedState.pendingChanges.find((p) => p.localId === localId && p.stateKey === stateKey)?.version === version;
+    samePendingVersion(tableName: string, localId: string, version: number): boolean {
+        return this.persistedState.pendingChanges.find((p) => p.localId === localId && p.tableName === tableName)?.version === version;
     }
 
-    removePendingChange(localId: string, stateKey: string): Promise<void> {
+    removePendingChange(localId: string, tableName: string): Promise<void> {
         const next = clonePersistedState(this.persistedState);
-        next.pendingChanges = next.pendingChanges.filter((p) => !(p.localId === localId && p.stateKey === stateKey));
+        next.pendingChanges = next.pendingChanges.filter((p) => !(p.localId === localId && p.tableName === tableName));
         this.persistedState = next;
         return this.persist();
     }
 
-    updatePendingChange(stateKey: string, localId: string, action: SyncAction, id?: any): Promise<void> {
+    updatePendingChange(tableName: string, localId: string, action: SyncAction, id?: any): Promise<void> {
         const next = clonePersistedState(this.persistedState);
-        const changeItem = next.pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localId);
+        const changeItem = next.pendingChanges.find((p) => p.tableName === tableName && p.localId === localId);
         if (changeItem) {
             changeItem.action = action;
             if (id) changeItem.id = id;
@@ -173,9 +173,9 @@ export class StateManager implements StateHelpers {
         return Promise.resolve();
     }
 
-    setPendingChangeBefore(stateKey: string, localId: string, before: any): Promise<void> {
+    setPendingChangeBefore(tableName: string, localId: string, before: any): Promise<void> {
         const next = clonePersistedState(this.persistedState);
-        const changeItem = next.pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localId);
+        const changeItem = next.pendingChanges.find((p) => p.tableName === tableName && p.localId === localId);
         if (changeItem) {
             changeItem.before = { ...(changeItem.before ?? {}), ...before };
             this.persistedState = next;
@@ -259,7 +259,7 @@ function cloneConflicts(conflicts: SyncState['conflicts'] | undefined): SyncStat
     const next: NonNullable<SyncState['conflicts']> = {};
     for (const [key, value] of Object.entries(conflicts)) {
         next[key] = {
-            stateKey: value.stateKey,
+            tableName: value.tableName,
             fields: value.fields.map((field) => ({ ...field })),
         };
     }

package/src/core/firstLoad.ts

@@ -44,14 +44,14 @@ export async function startFirstLoad(ctx: FirstLoadContext): Promise<void> {
 
     let error: Error | undefined;
 
-    for (const [stateKey, api] of Object.entries(ctx.syncApis)) {
+    for (const [tableName, api] of Object.entries(ctx.syncApis)) {
         if (!api.firstLoad) {
-            ctx.logger.error(`[dync] firstLoad:no-api-function stateKey=${stateKey}`);
+            ctx.logger.error(`[dync] firstLoad:no-api-function tableName=${tableName}`);
             continue;
         }
 
         try {
-            ctx.logger.info(`[dync] firstLoad:start stateKey=${stateKey}`);
+            ctx.logger.info(`[dync] firstLoad:start tableName=${tableName}`);
 
             let lastId: unknown;
             let isEmptyTable = true;
@@ -66,14 +66,14 @@ export async function startFirstLoad(ctx: FirstLoadContext): Promise<void> {
                 batchCount++;
 
                 // Process batch in smaller chunks to manage memory and allow UI updates
-                const { inserted, updated } = await processBatchInChunks(ctx, stateKey, batch, isEmptyTable, lastId === undefined);
+                const { inserted, updated } = await processBatchInChunks(ctx, tableName, batch, isEmptyTable, lastId === undefined);
                 totalInserted += inserted;
                 totalUpdated += updated;
 
                 // Report progress if callback provided
                 if (ctx.onProgress) {
                     ctx.onProgress({
-                        table: stateKey,
+                        table: tableName,
                         inserted: totalInserted,
                         updated: totalUpdated,
                         total: totalInserted + totalUpdated,
@@ -82,7 +82,7 @@ export async function startFirstLoad(ctx: FirstLoadContext): Promise<void> {
 
                 // After first batch, we know if table was empty
                 if (lastId === undefined) {
-                    isEmptyTable = (await ctx.table(stateKey).count()) === batch.length;
+                    isEmptyTable = (await ctx.table(tableName).count()) === batch.length;
                 }
 
                 if (lastId !== undefined && lastId === batch[batch.length - 1].id) {
@@ -97,10 +97,10 @@ export async function startFirstLoad(ctx: FirstLoadContext): Promise<void> {
                 }
             }
 
-            ctx.logger.info(`[dync] firstLoad:done stateKey=${stateKey} inserted=${totalInserted} updated=${totalUpdated}`);
+            ctx.logger.info(`[dync] firstLoad:done tableName=${tableName} inserted=${totalInserted} updated=${totalUpdated}`);
         } catch (err) {
             error = error ?? (err as Error);
-            ctx.logger.error(`[dync] firstLoad:error stateKey=${stateKey}`, err);
+            ctx.logger.error(`[dync] firstLoad:error tableName=${tableName}`, err);
         }
     }
 
@@ -120,15 +120,15 @@ interface BatchResult {
 
 async function processBatchInChunks(
     ctx: FirstLoadBaseContext,
-    stateKey: string,
+    tableName: string,
     batch: RemoteRecord[],
     isEmptyTable: boolean,
     isFirstBatch: boolean,
 ): Promise<BatchResult> {
-    let newest = new Date(ctx.state.getState().lastPulled[stateKey] || 0);
+    let newest = new Date(ctx.state.getState().lastPulled[tableName] || 0);
 
-    return ctx.withTransaction('rw', [stateKey, DYNC_STATE_TABLE], async (tables) => {
-        const txTable = tables[stateKey]!;
+    return ctx.withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+        const txTable = tables[tableName]!;
 
         // Check if table is empty on first batch
         let tableIsEmpty = isEmptyTable;
@@ -176,7 +176,7 @@ async function processBatchInChunks(
             ...syncState,
             lastPulled: {
                 ...syncState.lastPulled,
-                [stateKey]: newest.toISOString(),
+                [tableName]: newest.toISOString(),
             },
         }));
 
@@ -274,28 +274,28 @@ export async function startFirstLoadBatch(ctx: FirstLoadBatchContext): Promise<v
             batchCount++;
 
             // Process each table's data
-            for (const [stateKey, batch] of Object.entries(result.data)) {
-                if (!ctx.batchSync.syncTables.includes(stateKey)) {
-                    ctx.logger.warn(`[dync] firstLoad:batch:unknown-table stateKey=${stateKey}`);
+            for (const [tableName, batch] of Object.entries(result.data)) {
+                if (!ctx.batchSync.syncTables.includes(tableName)) {
+                    ctx.logger.warn(`[dync] firstLoad:batch:unknown-table tableName=${tableName}`);
                     continue;
                 }
 
                 if (!batch?.length) continue;
 
-                const isFirstBatch = progress[stateKey]!.inserted === 0 && progress[stateKey]!.updated === 0;
-                const isEmptyTable = isFirstBatch && (await ctx.table(stateKey).count()) === 0;
+                const isFirstBatch = progress[tableName]!.inserted === 0 && progress[tableName]!.updated === 0;
+                const isEmptyTable = isFirstBatch && (await ctx.table(tableName).count()) === 0;
 
-                const { inserted, updated } = await processBatchInChunks(ctx, stateKey, batch, isEmptyTable, isFirstBatch);
-                progress[stateKey]!.inserted += inserted;
-                progress[stateKey]!.updated += updated;
+                const { inserted, updated } = await processBatchInChunks(ctx, tableName, batch, isEmptyTable, isFirstBatch);
+                progress[tableName]!.inserted += inserted;
+                progress[tableName]!.updated += updated;
 
                 // Report progress if callback provided
                 if (ctx.onProgress) {
                     ctx.onProgress({
-                        table: stateKey,
-                        inserted: progress[stateKey]!.inserted,
-                        updated: progress[stateKey]!.updated,
-                        total: progress[stateKey]!.inserted + progress[stateKey]!.updated,
+                        table: tableName,
+                        inserted: progress[tableName]!.inserted,
+                        updated: progress[tableName]!.updated,
+                        total: progress[tableName]!.inserted + progress[tableName]!.updated,
                     });
                 }
             }
@@ -314,8 +314,8 @@ export async function startFirstLoadBatch(ctx: FirstLoadBatchContext): Promise<v
         }
 
         // Log completion for each table
-        for (const [stateKey, p] of Object.entries(progress)) {
-            ctx.logger.info(`[dync] firstLoad:batch:done stateKey=${stateKey} inserted=${p.inserted} updated=${p.updated}`);
+        for (const [tableName, p] of Object.entries(progress)) {
+            ctx.logger.info(`[dync] firstLoad:batch:done tableName=${tableName} inserted=${p.inserted} updated=${p.updated}`);
         }
     } catch (err) {
         error = err as Error;

package/src/core/pullOperations.ts

@@ -25,30 +25,30 @@ export interface PullAllBatchContext extends PullContext {
 export async function pullAll(ctx: PullAllContext): Promise<{ error?: Error; changedTables: string[] }> {
     let firstSyncError: Error | undefined;
     const changedTables: string[] = [];
-    for (const [stateKey, api] of Object.entries(ctx.syncApis)) {
+    for (const [tableName, api] of Object.entries(ctx.syncApis)) {
         try {
-            const lastPulled = ctx.state.getState().lastPulled[stateKey];
+            const lastPulled = ctx.state.getState().lastPulled[tableName];
             const since = lastPulled ? new Date(lastPulled) : new Date(0);
 
-            ctx.logger.debug(`[dync] pull:start stateKey=${stateKey} since=${since.toISOString()}`);
+            ctx.logger.debug(`[dync] pull:start tableName=${tableName} since=${since.toISOString()}`);
 
             const serverData = (await api.list(since)) as SyncedRecord[];
-            const changed = await processPullData(stateKey, serverData, since, ctx);
-            if (changed) changedTables.push(stateKey);
+            const changed = await processPullData(tableName, serverData, since, ctx);
+            if (changed) changedTables.push(tableName);
         } catch (err) {
             firstSyncError = firstSyncError ?? (err as Error);
-            ctx.logger.error(`[dync] pull:error stateKey=${stateKey}`, err);
+            ctx.logger.error(`[dync] pull:error tableName=${tableName}`, err);
         }
     }
     return { error: firstSyncError, changedTables };
 }
 
-async function handleRemoteItemUpdate(table: StorageTable<any>, stateKey: string, localItem: any, remote: any, ctx: PullContext): Promise<void> {
-    const pendingChange = ctx.state.getState().pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localItem._localId);
+async function handleRemoteItemUpdate(table: StorageTable<any>, tableName: string, localItem: any, remote: any, ctx: PullContext): Promise<void> {
+    const pendingChange = ctx.state.getState().pendingChanges.find((p) => p.tableName === tableName && p.localId === localItem._localId);
     const conflictStrategy = ctx.conflictResolutionStrategy;
 
     if (pendingChange) {
-        ctx.logger.debug(`[dync] pull:conflict-strategy:${conflictStrategy} stateKey=${stateKey} id=${remote.id}`);
+        ctx.logger.debug(`[dync] pull:conflict-strategy:${conflictStrategy} tableName=${tableName} id=${remote.id}`);
 
         switch (conflictStrategy) {
             case 'local-wins':
@@ -57,7 +57,7 @@ async function handleRemoteItemUpdate(table: StorageTable<any>, stateKey: string
             case 'remote-wins': {
                 const merged = { ...remote, _localId: localItem._localId };
                 await table.raw.update(localItem._localId, merged);
-                await ctx.state.removePendingChange(localItem._localId, stateKey);
+                await ctx.state.removePendingChange(localItem._localId, tableName);
                 break;
             }
 
@@ -75,7 +75,7 @@ async function handleRemoteItemUpdate(table: StorageTable<any>, stateKey: string
                         ...syncState,
                         conflicts: {
                             ...(syncState.conflicts || {}),
-                            [localItem._localId]: { stateKey, fields },
+                            [localItem._localId]: { tableName, fields },
                         },
                     }));
                 } else {
@@ -101,7 +101,7 @@ async function handleRemoteItemUpdate(table: StorageTable<any>, stateKey: string
     } else {
         const merged = { ...localItem, ...remote };
         await table.raw.update(localItem._localId, merged);
-        ctx.logger.debug(`[dync] pull:merge-remote stateKey=${stateKey} id=${remote.id}`);
+        ctx.logger.debug(`[dync] pull:merge-remote tableName=${tableName} id=${remote.id}`);
     }
 }
 
@@ -127,18 +127,18 @@ export async function pullAllBatch(ctx: PullAllBatchContext): Promise<{ error?:
         const serverDataByTable = await ctx.batchSync.pull(sinceMap);
 
         // Process each table's data
-        for (const [stateKey, serverData] of Object.entries(serverDataByTable)) {
-            if (!ctx.batchSync.syncTables.includes(stateKey)) {
-                ctx.logger.warn(`[dync] pull:batch:unknown-table stateKey=${stateKey}`);
+        for (const [tableName, serverData] of Object.entries(serverDataByTable)) {
+            if (!ctx.batchSync.syncTables.includes(tableName)) {
+                ctx.logger.warn(`[dync] pull:batch:unknown-table tableName=${tableName}`);
                 continue;
             }
 
             try {
-                const changed = await processPullData(stateKey, serverData as SyncedRecord[], sinceMap[stateKey]!, ctx);
-                if (changed) changedTables.push(stateKey);
+                const changed = await processPullData(tableName, serverData as SyncedRecord[], sinceMap[tableName]!, ctx);
+                if (changed) changedTables.push(tableName);
             } catch (err) {
                 firstSyncError = firstSyncError ?? (err as Error);
-                ctx.logger.error(`[dync] pull:batch:error stateKey=${stateKey}`, err);
+                ctx.logger.error(`[dync] pull:batch:error tableName=${tableName}`, err);
             }
         }
     } catch (err) {
@@ -149,20 +149,20 @@ export async function pullAllBatch(ctx: PullAllBatchContext): Promise<{ error?:
     return { error: firstSyncError, changedTables };
 }
 
-async function processPullData(stateKey: string, serverData: SyncedRecord[], since: Date, ctx: PullContext): Promise<boolean> {
+async function processPullData(tableName: string, serverData: SyncedRecord[], since: Date, ctx: PullContext): Promise<boolean> {
     if (!serverData?.length) return false;
 
-    ctx.logger.debug(`[dync] pull:process stateKey=${stateKey} count=${serverData.length}`);
+    ctx.logger.debug(`[dync] pull:process tableName=${tableName} count=${serverData.length}`);
 
     let newest = since;
     let hasChanges = false;
 
-    await ctx.withTransaction('rw', [stateKey, DYNC_STATE_TABLE], async (tables) => {
-        const txTable = tables[stateKey]!;
+    await ctx.withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+        const txTable = tables[tableName]!;
         const pendingRemovalById = new Set(
             ctx.state
                 .getState()
-                .pendingChanges.filter((p) => p.stateKey === stateKey && p.action === SyncAction.Remove)
+                .pendingChanges.filter((p) => p.tableName === tableName && p.action === SyncAction.Remove)
                 .map((p) => p.id),
         );
 
@@ -171,7 +171,7 @@ async function processPullData(stateKey: string, serverData: SyncedRecord[], sin
             if (remoteUpdated > newest) newest = remoteUpdated;
 
             if (pendingRemovalById.has(remote.id)) {
-                ctx.logger.debug(`[dync] pull:skip-pending-remove stateKey=${stateKey} id=${remote.id}`);
+                ctx.logger.debug(`[dync] pull:skip-pending-remove tableName=${tableName} id=${remote.id}`);
                 continue;
             }
 
@@ -180,7 +180,7 @@ async function processPullData(stateKey: string, serverData: SyncedRecord[], sin
             if (remote.deleted) {
                 if (localItem) {
                     await txTable.raw.delete(localItem._localId);
-                    ctx.logger.debug(`[dync] pull:remove stateKey=${stateKey} id=${remote.id}`);
+                    ctx.logger.debug(`[dync] pull:remove tableName=${tableName} id=${remote.id}`);
                     hasChanges = true;
                 }
                 continue;
@@ -189,12 +189,12 @@ async function processPullData(stateKey: string, serverData: SyncedRecord[], sin
             delete remote.deleted;
 
             if (localItem) {
-                await handleRemoteItemUpdate(txTable, stateKey, localItem, remote, ctx);
+                await handleRemoteItemUpdate(txTable, tableName, localItem, remote, ctx);
                 hasChanges = true;
             } else {
                 const newLocalItem = { ...remote, _localId: createLocalId() };
                 await txTable.raw.add(newLocalItem);
-                ctx.logger.debug(`[dync] pull:add stateKey=${stateKey} id=${remote.id}`);
+                ctx.logger.debug(`[dync] pull:add tableName=${tableName} id=${remote.id}`);
                 hasChanges = true;
             }
         }
@@ -203,7 +203,7 @@ async function processPullData(stateKey: string, serverData: SyncedRecord[], sin
             ...syncState,
             lastPulled: {
                 ...syncState.lastPulled,
-                [stateKey]: newest.toISOString(),
+                [tableName]: newest.toISOString(),
             },
         }));
     });

package/src/core/pushOperations.ts

@@ -23,40 +23,40 @@ export interface PushAllBatchContext extends PushContext {
 }
 
 async function handleRemoveSuccess(change: PendingChange, ctx: PushContext): Promise<void> {
-    const { stateKey, localId, id } = change;
-    ctx.logger.debug(`[dync] push:remove:success stateKey=${stateKey} localId=${localId} id=${id}`);
-    await ctx.state.removePendingChange(localId, stateKey);
+    const { tableName, localId, id } = change;
+    ctx.logger.debug(`[dync] push:remove:success tableName=${tableName} localId=${localId} id=${id}`);
+    await ctx.state.removePendingChange(localId, tableName);
 }
 
 async function handleUpdateSuccess(change: PendingChange, ctx: PushContext): Promise<void> {
-    const { stateKey, localId, version, changes } = change;
-    ctx.logger.debug(`[dync] push:update:success stateKey=${stateKey} localId=${localId} id=${change.id}`);
-    if (ctx.state.samePendingVersion(stateKey, localId, version)) {
-        await ctx.state.removePendingChange(localId, stateKey);
+    const { tableName, localId, version, changes } = change;
+    ctx.logger.debug(`[dync] push:update:success tableName=${tableName} localId=${localId} id=${change.id}`);
+    if (ctx.state.samePendingVersion(tableName, localId, version)) {
+        await ctx.state.removePendingChange(localId, tableName);
     } else {
-        await ctx.state.setPendingChangeBefore(stateKey, localId, changes);
+        await ctx.state.setPendingChangeBefore(tableName, localId, changes);
     }
 }
 
 async function handleCreateSuccess(change: PendingChange, serverResult: { id: unknown; updated_at?: string }, ctx: PushContext): Promise<void> {
-    const { stateKey, localId, version, changes, id } = change;
-    ctx.logger.debug(`[dync] push:create:success stateKey=${stateKey} localId=${localId} id=${id ?? serverResult.id}`);
+    const { tableName, localId, version, changes, id } = change;
+    ctx.logger.debug(`[dync] push:create:success tableName=${tableName} localId=${localId} id=${id ?? serverResult.id}`);
 
-    await ctx.withTransaction('rw', [stateKey, DYNC_STATE_TABLE], async (tables) => {
-        const txTable = tables[stateKey]!;
+    await ctx.withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+        const txTable = tables[tableName]!;
         const wasChanged = (await txTable.raw.update(localId, serverResult)) ?? 0;
 
-        if (wasChanged && ctx.state.samePendingVersion(stateKey, localId, version)) {
-            await ctx.state.removePendingChange(localId, stateKey);
+        if (wasChanged && ctx.state.samePendingVersion(tableName, localId, version)) {
+            await ctx.state.removePendingChange(localId, tableName);
         } else {
             const nextAction = wasChanged ? SyncAction.Update : SyncAction.Remove;
-            await ctx.state.updatePendingChange(stateKey, localId, nextAction, serverResult.id);
+            await ctx.state.updatePendingChange(tableName, localId, nextAction, serverResult.id);
             if (nextAction === SyncAction.Remove) return;
         }
     });
 
     const finalItem = { ...changes, ...serverResult, _localId: localId };
-    ctx.syncOptions.onAfterRemoteAdd?.(stateKey, finalItem);
+    ctx.syncOptions.onAfterRemoteAdd?.(tableName, finalItem);
 }
 
 export async function pushAll(ctx: PushAllContext): Promise<Error | undefined> {
@@ -75,18 +75,18 @@ export async function pushAll(ctx: PushAllContext): Promise<Error | undefined> {
 }
 
 async function pushOne(change: PendingChange, ctx: PushAllContext): Promise<void> {
-    const api = ctx.syncApis[change.stateKey];
+    const api = ctx.syncApis[change.tableName];
     if (!api) return;
 
-    ctx.logger.debug(`[dync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
+    ctx.logger.debug(`[dync] push:attempt action=${change.action} tableName=${change.tableName} localId=${change.localId}`);
 
-    const { action, stateKey, localId, id, changes, after } = change;
+    const { action, tableName, localId, id, changes, after } = change;
 
     switch (action) {
         case SyncAction.Remove:
             if (!id) {
-                ctx.logger.warn(`[dync] push:remove:no-id stateKey=${stateKey} localId=${localId}`);
-                await ctx.state.removePendingChange(localId, stateKey);
+                ctx.logger.warn(`[dync] push:remove:no-id tableName=${tableName} localId=${localId}`);
+                await ctx.state.removePendingChange(localId, tableName);
                 return;
             }
             await api.remove(id);
@@ -95,7 +95,7 @@ async function pushOne(change: PendingChange, ctx: PushAllContext): Promise<void
 
         case SyncAction.Update: {
             if (ctx.state.hasConflicts(localId)) {
-                ctx.logger.warn(`[dync] push:update:skipping-with-conflicts stateKey=${stateKey} localId=${localId} id=${id}`);
+                ctx.logger.warn(`[dync] push:update:skipping-with-conflicts tableName=${tableName} localId=${localId} id=${id}`);
                 return;
             }
 
@@ -113,9 +113,9 @@ async function pushOne(change: PendingChange, ctx: PushAllContext): Promise<void
             if (result) {
                 await handleCreateSuccess(change, result, ctx);
             } else {
-                ctx.logger.warn(`[dync] push:create:no-result stateKey=${stateKey} localId=${localId} id=${id}`);
-                if (ctx.state.samePendingVersion(stateKey, localId, change.version)) {
-                    await ctx.state.removePendingChange(localId, stateKey);
+                ctx.logger.warn(`[dync] push:create:no-result tableName=${tableName} localId=${localId} id=${id}`);
+                if (ctx.state.samePendingVersion(tableName, localId, change.version)) {
+                    await ctx.state.removePendingChange(localId, tableName);
                 }
             }
             break;
@@ -124,25 +124,25 @@ async function pushOne(change: PendingChange, ctx: PushAllContext): Promise<void
 }
 
 async function handleMissingRemoteRecord(change: PendingChange, ctx: PushContext): Promise<void> {
-    const { stateKey, localId } = change;
+    const { tableName, localId } = change;
     const strategy = ctx.syncOptions.missingRemoteRecordDuringUpdateStrategy!;
 
     let localItem: any;
 
-    await ctx.withTransaction('rw', [stateKey, DYNC_STATE_TABLE], async (tables) => {
-        const txTable = tables[stateKey]!;
+    await ctx.withTransaction('rw', [tableName, DYNC_STATE_TABLE], async (tables) => {
+        const txTable = tables[tableName]!;
         localItem = await txTable.get(localId);
 
         if (!localItem) {
-            ctx.logger.warn(`[dync] push:missing-remote:no-local-item stateKey=${stateKey} localId=${localId}`);
-            await ctx.state.removePendingChange(localId, stateKey);
+            ctx.logger.warn(`[dync] push:missing-remote:no-local-item tableName=${tableName} localId=${localId}`);
+            await ctx.state.removePendingChange(localId, tableName);
             return;
         }
 
         switch (strategy) {
             case 'delete-local-record':
                 await txTable.raw.delete(localId);
-                ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${localItem.id}`);
+                ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${localItem.id}`);
                 break;
 
             case 'insert-remote-record': {
@@ -157,26 +157,26 @@ async function handleMissingRemoteRecord(change: PendingChange, ctx: PushContext
 
                 await ctx.state.addPendingChange({
                     action: SyncAction.Create,
-                    stateKey,
+                    tableName,
                     localId: newItem._localId,
                     changes: newItem,
                     before: null,
                 });
 
-                ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${newItem.id}`);
+                ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${newItem.id}`);
                 break;
             }
 
             case 'ignore':
-                ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${localItem.id}`);
+                ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${localItem.id}`);
                 break;
 
             default:
-                ctx.logger.error(`[dync] push:missing-remote:unknown-strategy stateKey=${stateKey} id=${localItem.id} strategy=${strategy}`);
+                ctx.logger.error(`[dync] push:missing-remote:unknown-strategy tableName=${tableName} id=${localItem.id} strategy=${strategy}`);
                 break;
         }
 
-        await ctx.state.removePendingChange(localId, stateKey);
+        await ctx.state.removePendingChange(localId, tableName);
     });
 
     ctx.syncOptions.onAfterMissingRemoteRecordDuringUpdate?.(strategy, localItem);
@@ -191,7 +191,7 @@ export async function pushAllBatch(ctx: PushAllBatchContext): Promise<Error | un
 
     try {
         const changesSnapshot = [...ctx.state.getState().pendingChanges]
-            .filter((change) => ctx.batchSync.syncTables.includes(change.stateKey))
+            .filter((change) => ctx.batchSync.syncTables.includes(change.tableName))
             .sort((a, b) => orderFor(a.action) - orderFor(b.action));
 
         if (changesSnapshot.length === 0) {
@@ -202,7 +202,7 @@ export async function pushAllBatch(ctx: PushAllBatchContext): Promise<Error | un
         // Filter out changes with conflicts
         const changesToPush = changesSnapshot.filter((change) => {
             if (change.action === SyncAction.Update && ctx.state.hasConflicts(change.localId)) {
-                ctx.logger.warn(`[dync] push:batch:skipping-with-conflicts stateKey=${change.stateKey} localId=${change.localId}`);
+                ctx.logger.warn(`[dync] push:batch:skipping-with-conflicts tableName=${change.tableName} localId=${change.localId}`);
                 return false;
             }
             return true;
@@ -215,7 +215,7 @@ export async function pushAllBatch(ctx: PushAllBatchContext): Promise<Error | un
 
         // Build batch payload
         const payloads: BatchPushPayload[] = changesToPush.map((change) => ({
-            table: change.stateKey,
+            table: change.tableName,
             action: change.action === SyncAction.Create ? 'add' : change.action === SyncAction.Update ? 'update' : 'remove',
             localId: change.localId,
             id: change.id,
@@ -257,14 +257,14 @@ export async function pushAllBatch(ctx: PushAllBatchContext): Promise<Error | un
 }
 
 async function processBatchPushResult(change: PendingChange, result: BatchPushResult, ctx: PushAllBatchContext): Promise<void> {
-    const { action, stateKey, localId } = change;
+    const { action, tableName, localId } = change;
 
     if (!result.success) {
         if (action === SyncAction.Update) {
             // Update failed - might be missing remote record
             await handleMissingRemoteRecord(change, ctx);
         } else {
-            ctx.logger.warn(`[dync] push:batch:failed stateKey=${stateKey} localId=${localId} error=${result.error}`);
+            ctx.logger.warn(`[dync] push:batch:failed tableName=${tableName} localId=${localId} error=${result.error}`);
         }
         return;
     }