@anfenn/dync 1.1.3 → 1.2.1

package/dist/node.d.cts

@@ -1,5 +1,5 @@
 import * as better_sqlite3 from 'better-sqlite3';
-import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-6-NyRQ0D.cjs';
+import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-DcEg2pvl.cjs';
 
 /**
  * Options for configuring the BetterSQLite3Driver.

package/dist/node.d.ts

@@ -1,5 +1,5 @@
 import * as better_sqlite3 from 'better-sqlite3';
-import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-6-NyRQ0D.js';
+import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-DcEg2pvl.js';
 
 /**
  * Options for configuring the BetterSQLite3Driver.

package/dist/react/index.d.cts

@@ -1,7 +1,7 @@
-import { a as SyncApi, k as SyncState } from '../types-Di82FTAL.cjs';
-import '../dexie-BRWUYM02.cjs';
+import { a as SyncApi, k as SyncState } from '../types-Da3ZhO9Y.cjs';
+import '../dexie-D8u9cGSy.cjs';
 import 'dexie';
-import '../types-6-NyRQ0D.cjs';
+import '../types-DcEg2pvl.cjs';
 
 /** Minimal database interface for React hooks */
 interface DyncLike {

package/dist/react/index.d.ts

@@ -1,7 +1,7 @@
-import { a as SyncApi, k as SyncState } from '../types-DhlgTu1o.js';
-import '../dexie-B3Ihrrxi.js';
+import { a as SyncApi, k as SyncState } from '../types-DnHiaBZV.js';
+import '../dexie-Cxn4kUoF.js';
 import 'dexie';
-import '../types-6-NyRQ0D.js';
+import '../types-DcEg2pvl.js';
 
 /** Minimal database interface for React hooks */
 interface DyncLike {

package/dist/{types-DhlgTu1o.d.ts → types-Da3ZhO9Y.d.cts}

@@ -1,4 +1,4 @@
-import { d as StorageAdapter, a as StorageTable } from './dexie-B3Ihrrxi.js';
+import { d as StorageAdapter, a as StorageTable } from './dexie-D8u9cGSy.cjs';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -23,7 +23,7 @@ interface CrudSyncApi {
     add: (item: any) => Promise<any | undefined>;
     update: (id: any, changes: any, item: any) => Promise<boolean>;
     remove: (id: any) => Promise<void>;
-    list: (lastUpdatedAt: Date) => Promise<any[]>;
+    list: (newestUpdatedAt: Date) => Promise<any[]>;
     listExtraIntervalMs?: number;
     firstLoad?: (lastId: any) => Promise<any[]>;
 }
@@ -117,7 +117,7 @@ type SyncApi = {
     onMutation: (fn: (event: MutationEvent) => void) => () => void;
 };
 interface MutationEvent {
-    type: 'add' | 'update' | 'delete' | 'bulkAdd' | 'bulkPut' | 'bulkDelete' | 'clear' | 'put' | 'modify' | 'pull';
+    type: 'add' | 'update' | 'delete' | 'pull';
     tableName: string;
     keys?: unknown[];
 }

package/dist/{types-6-NyRQ0D.d.cts → types-DcEg2pvl.d.cts}

@@ -1,5 +1,5 @@
 interface SQLiteAdapterOptions {
-    debug?: boolean | ((statement: string, parameters?: any[]) => void);
+    debug?: boolean;
 }
 interface SQLiteRunResult {
     changes?: number;

package/dist/{types-6-NyRQ0D.d.ts → types-DcEg2pvl.d.ts}

@@ -1,5 +1,5 @@
 interface SQLiteAdapterOptions {
-    debug?: boolean | ((statement: string, parameters?: any[]) => void);
+    debug?: boolean;
 }
 interface SQLiteRunResult {
     changes?: number;

package/dist/{types-Di82FTAL.d.cts → types-DnHiaBZV.d.ts}

@@ -1,4 +1,4 @@
-import { d as StorageAdapter, a as StorageTable } from './dexie-BRWUYM02.cjs';
+import { d as StorageAdapter, a as StorageTable } from './dexie-Cxn4kUoF.js';
 
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 interface Logger {
@@ -23,7 +23,7 @@ interface CrudSyncApi {
     add: (item: any) => Promise<any | undefined>;
     update: (id: any, changes: any, item: any) => Promise<boolean>;
     remove: (id: any) => Promise<void>;
-    list: (lastUpdatedAt: Date) => Promise<any[]>;
+    list: (newestUpdatedAt: Date) => Promise<any[]>;
     listExtraIntervalMs?: number;
     firstLoad?: (lastId: any) => Promise<any[]>;
 }
@@ -117,7 +117,7 @@ type SyncApi = {
     onMutation: (fn: (event: MutationEvent) => void) => () => void;
 };
 interface MutationEvent {
-    type: 'add' | 'update' | 'delete' | 'bulkAdd' | 'bulkPut' | 'bulkDelete' | 'clear' | 'put' | 'modify' | 'pull';
+    type: 'add' | 'update' | 'delete' | 'pull';
     tableName: string;
     keys?: unknown[];
 }

package/dist/wa-sqlite.d.cts

@@ -1,4 +1,4 @@
-import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-6-NyRQ0D.cjs';
+import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-DcEg2pvl.cjs';
 
 /**
  * Virtual File System (VFS) options for wa-sqlite.

package/dist/wa-sqlite.d.ts

@@ -1,4 +1,4 @@
-import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-6-NyRQ0D.js';
+import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-DcEg2pvl.js';
 
 /**
  * Virtual File System (VFS) options for wa-sqlite.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anfenn/dync",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "private": false,
   "description": "Write once, run IndexedDB & SQLite with sync anywhere - React, React Native, Expo, Capacitor, Electron & Node.js",
   "keywords": [
@@ -144,7 +144,7 @@
     "test:browser:full": "pnpm --filter tests test:browser:full",
     "reinstall": "find . -name node_modules -type d -prune -exec rm -rf {} + && pnpm install",
     "smoke": "pnpm build:all && pnpm test",
-    "hascommits": "[ -n \"$(git log @{u}.. --oneline)\" ] || { echo \"No unpushed commits, aborting.\"; exit 1; }",
+    "hascommits": "[ -n \"$(git log @{u}.. --oneline)\" ] || { echo \"No un-pushed commits, aborting.\"; exit 1; }",
     "prepush": "pnpm hascommits && pnpm build:all && pnpm test:all && pnpm test:browser:full",
     "release": "bash -c 'pnpm prepush && { [ \"$1\" = \"--no-patch\" ] || npm version patch --no-tag --force; } && git push && npm login && npm publish' --"
   },

package/src/core/SyncAwareCollection.ts

@@ -0,0 +1,124 @@
+import type { StorageCollection, StorageTable, StorageWhereClause } from '../storage/types';
+import { SyncAwareWhereClause } from './SyncAwareWhereClause';
+
+/**
+ * Wraps a StorageCollection so that modify() and delete() create pending sync
+ * changes by delegating to the already-wrapped table.bulkUpdate / bulkDelete.
+ * All read and chaining operations delegate transparently to the inner collection.
+ */
+export class SyncAwareCollection<T> implements StorageCollection<T> {
+    constructor(
+        private readonly inner: StorageCollection<T>,
+        private readonly tableRef: StorageTable<any>,
+    ) {}
+
+    private wrap(col: StorageCollection<T>): SyncAwareCollection<T> {
+        return new SyncAwareCollection(col, this.tableRef);
+    }
+
+    // ---- read-only / pass-through ----
+    first() {
+        return this.inner.first();
+    }
+    last() {
+        return this.inner.last();
+    }
+    each(cb: (item: T, idx: number) => void | Promise<void>) {
+        return this.inner.each(cb);
+    }
+    eachKey(cb: (key: unknown, idx: number) => void | Promise<void>) {
+        return this.inner.eachKey(cb);
+    }
+    eachPrimaryKey(cb: (key: unknown, idx: number) => void | Promise<void>) {
+        return this.inner.eachPrimaryKey(cb);
+    }
+    eachUniqueKey(cb: (key: unknown, idx: number) => void | Promise<void>) {
+        return this.inner.eachUniqueKey(cb);
+    }
+    keys() {
+        return this.inner.keys();
+    }
+    primaryKeys() {
+        return this.inner.primaryKeys();
+    }
+    uniqueKeys() {
+        return this.inner.uniqueKeys();
+    }
+    count() {
+        return this.inner.count();
+    }
+    sortBy(key: string) {
+        return this.inner.sortBy(key);
+    }
+    toArray() {
+        return this.inner.toArray();
+    }
+
+    // ---- chaining — preserve sync-awareness ----
+    distinct() {
+        return this.wrap(this.inner.distinct());
+    }
+    clone(props?: Record<string, unknown>) {
+        return this.wrap(this.inner.clone(props));
+    }
+    reverse() {
+        return this.wrap(this.inner.reverse());
+    }
+    offset(n: number) {
+        return this.wrap(this.inner.offset(n));
+    }
+    limit(n: number) {
+        return this.wrap(this.inner.limit(n));
+    }
+    toCollection() {
+        return this.wrap(this.inner.toCollection());
+    }
+    jsFilter(predicate: (item: T) => boolean) {
+        return this.wrap(this.inner.jsFilter(predicate));
+    }
+    or(index: string): StorageWhereClause<T> {
+        return new SyncAwareWhereClause(this.inner.or(index), this.tableRef);
+    }
+
+    // ---- sync-aware mutations ----
+
+    async delete(): Promise<number> {
+        const records = await this.inner.toArray();
+        if (records.length === 0) return 0;
+        const keys = records.map((r: any) => r._localId as string);
+        await this.tableRef.bulkDelete(keys);
+        return records.length;
+    }
+
+    async modify(changes: Partial<T> | ((item: T) => void | Promise<void>)): Promise<number> {
+        const records = await this.inner.toArray();
+        if (records.length === 0) return 0;
+
+        if (typeof changes === 'function') {
+            const keysAndChanges: Array<{ key: string; changes: Partial<T> }> = [];
+            for (const record of records) {
+                const draft = { ...record } as T;
+                await (changes as (item: T) => void | Promise<void>)(draft);
+                // Compute shallow delta
+                const delta: Partial<T> = {};
+                const allKeys = new Set([...Object.keys(record as object), ...Object.keys(draft as object)]) as Set<keyof T>;
+                for (const key of allKeys) {
+                    if ((draft as any)[key] !== (record as any)[key]) {
+                        (delta as any)[key] = (draft as any)[key];
+                    }
+                }
+                if (Object.keys(delta).length > 0) {
+                    keysAndChanges.push({ key: (record as any)._localId, changes: delta });
+                }
+            }
+            if (keysAndChanges.length > 0) {
+                await this.tableRef.bulkUpdate(keysAndChanges as any);
+            }
+        } else {
+            const keysAndChanges = records.map((r: any) => ({ key: r._localId as string, changes }));
+            await this.tableRef.bulkUpdate(keysAndChanges as any);
+        }
+
+        return records.length;
+    }
+}

package/src/core/SyncAwareWhereClause.ts

@@ -0,0 +1,66 @@
+import type { StorageCollection, StorageTable, StorageWhereClause } from '../storage/types';
+import { SyncAwareCollection } from './SyncAwareCollection';
+
+/**
+ * Wraps a StorageWhereClause so that every collection it produces is a
+ * SyncAwareCollection.
+ */
+export class SyncAwareWhereClause<T> implements StorageWhereClause<T> {
+    constructor(
+        private readonly inner: StorageWhereClause<T>,
+        private readonly tableRef: StorageTable<any>,
+    ) {}
+
+    private wrap(col: StorageCollection<T>): SyncAwareCollection<T> {
+        return new SyncAwareCollection(col, this.tableRef);
+    }
+
+    equals(value: any) {
+        return this.wrap(this.inner.equals(value));
+    }
+    above(value: any) {
+        return this.wrap(this.inner.above(value));
+    }
+    aboveOrEqual(value: any) {
+        return this.wrap(this.inner.aboveOrEqual(value));
+    }
+    below(value: any) {
+        return this.wrap(this.inner.below(value));
+    }
+    belowOrEqual(value: any) {
+        return this.wrap(this.inner.belowOrEqual(value));
+    }
+    between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean) {
+        return this.wrap(this.inner.between(lower, upper, includeLower, includeUpper));
+    }
+    inAnyRange(ranges: Array<[any, any]>, options?: { includeLower?: boolean; includeUpper?: boolean }) {
+        return this.wrap(this.inner.inAnyRange(ranges, options));
+    }
+    startsWith(prefix: string) {
+        return this.wrap(this.inner.startsWith(prefix));
+    }
+    startsWithIgnoreCase(prefix: string) {
+        return this.wrap(this.inner.startsWithIgnoreCase(prefix));
+    }
+    startsWithAnyOf(...args: any[]) {
+        return this.wrap((this.inner.startsWithAnyOf as any)(...args));
+    }
+    startsWithAnyOfIgnoreCase(...args: any[]) {
+        return this.wrap((this.inner.startsWithAnyOfIgnoreCase as any)(...args));
+    }
+    equalsIgnoreCase(value: string) {
+        return this.wrap(this.inner.equalsIgnoreCase(value));
+    }
+    anyOf(...args: any[]) {
+        return this.wrap((this.inner.anyOf as any)(...args));
+    }
+    anyOfIgnoreCase(...args: any[]) {
+        return this.wrap((this.inner.anyOfIgnoreCase as any)(...args));
+    }
+    noneOf(...args: any[]) {
+        return this.wrap((this.inner.noneOf as any)(...args));
+    }
+    notEqual(value: any) {
+        return this.wrap(this.inner.notEqual(value));
+    }
+}

package/src/core/pushOperations.ts

@@ -1,6 +1,6 @@
 import { createLocalId, orderFor } from '../helpers';
 import type { Logger } from '../logger';
-import type { CrudSyncApi, BatchPushPayload, BatchPushResult, BatchSync, PendingChange, SyncOptions } from '../types';
+import type { CrudSyncApi, BatchPushPayload, BatchPushResult, BatchSync, PendingChange, ResolvedSyncOptions } from '../types';
 import { SyncAction } from '../types';
 import type { StorageTable } from '../storage/types';
 import { DYNC_STATE_TABLE, type StateHelpers } from './StateManager';
@@ -11,7 +11,7 @@ export interface PushContext {
     state: StateHelpers;
     table: <T>(name: string) => StorageTable<T>;
     withTransaction: WithTransaction;
-    syncOptions: SyncOptions;
+    syncOptions: ResolvedSyncOptions;
 }
 
 export interface PushAllContext extends PushContext {
@@ -125,7 +125,7 @@ async function pushOne(change: PendingChange, ctx: PushAllContext): Promise<void
 
 async function handleMissingRemoteRecord(change: PendingChange, ctx: PushContext): Promise<void> {
     const { tableName, localId } = change;
-    const strategy = ctx.syncOptions.missingRemoteRecordDuringUpdateStrategy!;
+    const strategy = ctx.syncOptions.missingRemoteRecordDuringUpdateStrategy;
 
     let localItem: any;
 
@@ -261,8 +261,15 @@ async function processBatchPushResult(change: PendingChange, result: BatchPushRe
 
     if (!result.success) {
         if (action === SyncAction.Update) {
-            // Update failed - might be missing remote record
-            await handleMissingRemoteRecord(change, ctx);
+            if (!result.error) {
+                // Explicit "not found" from the server (api.update returned false, no error message).
+                // Matches per-table behaviour where api.update() returning false triggers this path.
+                await handleMissingRemoteRecord(change, ctx);
+            } else {
+                // Transient error on the server — leave the pending change in place so the next sync cycle retries,
+                // matching per-table behaviour.
+                ctx.logger.warn(`[dync] push:batch:update-failed tableName=${tableName} localId=${localId} error=${result.error}`);
+            }
         } else {
             ctx.logger.warn(`[dync] push:batch:failed tableName=${tableName} localId=${localId} error=${result.error}`);
         }
@@ -271,11 +278,11 @@ async function processBatchPushResult(change: PendingChange, result: BatchPushRe
 
     switch (action) {
         case SyncAction.Remove:
-            handleRemoveSuccess(change, ctx);
+            await handleRemoveSuccess(change, ctx);
             break;
 
         case SyncAction.Update:
-            handleUpdateSuccess(change, ctx);
+            await handleUpdateSuccess(change, ctx);
             break;
 
         case SyncAction.Create: {

package/src/core/tableEnhancers.ts

@@ -3,6 +3,8 @@ import { SyncAction, type MutationEvent, type SyncedRecord } from '../types';
 import type { AddItem, StorageTable } from '../storage/types';
 import { DYNC_STATE_TABLE, type StateHelpers } from './StateManager';
 import type { WithTransaction } from './types';
+import { SyncAwareCollection } from './SyncAwareCollection';
+import { SyncAwareWhereClause } from './SyncAwareWhereClause';
 export type EmitMutation = (event: MutationEvent) => void;
 
 /**
@@ -463,5 +465,21 @@ export function enhanceSyncTable<T>({ table, tableName, withTransaction, state,
     table.bulkDelete = wrappedBulkDelete;
     table.clear = wrappedClear;
 
+    // Wrap collection-returning methods so that modify() and delete() on
+    // any derived collection are also sync-aware.
+    const originalWhere = table.where.bind(table);
+    const originalOrderBy = table.orderBy.bind(table);
+    const originalReverse = table.reverse.bind(table);
+    const originalOffset = table.offset.bind(table);
+    const originalLimit = table.limit.bind(table);
+    const originalJsFilter = table.jsFilter.bind(table);
+
+    table.where = (index: string) => new SyncAwareWhereClause(originalWhere(index), table);
+    table.orderBy = (index: string | string[]) => new SyncAwareCollection(originalOrderBy(index), table);
+    table.reverse = () => new SyncAwareCollection(originalReverse(), table);
+    table.offset = (n: number) => new SyncAwareCollection(originalOffset(n), table);
+    table.limit = (n: number) => new SyncAwareCollection(originalLimit(n), table);
+    table.jsFilter = (predicate: (item: T & SyncedRecord) => boolean) => new SyncAwareCollection(originalJsFilter(predicate), table);
+
     enhancedTables.add(tableName);
 }

package/src/index.shared.ts

@@ -4,7 +4,7 @@ import {
     type CrudSyncApi,
     type BatchSync,
     type DyncOptions,
-    type SyncOptions,
+    type ResolvedSyncOptions,
     type SyncState,
     type SyncedRecord,
     type MissingRemoteRecordStrategy,
@@ -54,7 +54,7 @@ class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
     // Batch sync mode
     private batchSync?: BatchSync;
     private syncedTables: Set<string> = new Set();
-    private syncOptions: SyncOptions;
+    private syncOptions: ResolvedSyncOptions;
     private logger: Logger;
     private syncTimerStarted = false;
     private mutationsDuringSync = false;
@@ -109,7 +109,7 @@ class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
             ...(options ?? {}),
         };
 
-        this.logger = newLogger(this.syncOptions.logger!, this.syncOptions.minLogLevel!);
+        this.logger = newLogger(this.syncOptions.logger, this.syncOptions.minLogLevel);
         this.state = new StateManager({
             storageAdapter: this.adapter,
         });
@@ -395,7 +395,7 @@ class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
         const pullResult = await this.pullAll();
         const firstPushSyncError = await this.pushAll();
 
-        // Emit pull mutation only for tables that had changes
+        // Emit pull mutation only for tables that had changes to trigger live query updates
         for (const tableName of pullResult.changedTables) {
             this.emitMutation({ type: 'pull', tableName });
         }
@@ -417,7 +417,7 @@ class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
             state: this.state,
             table: this.table.bind(this),
             withTransaction: this.withTransaction.bind(this),
-            conflictResolutionStrategy: this.syncOptions.conflictResolutionStrategy!,
+            conflictResolutionStrategy: this.syncOptions.conflictResolutionStrategy,
         };
 
         if (this.batchSync) {
@@ -430,7 +430,7 @@ class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
         return runPullAll({
             ...baseContext,
             syncApis: this.syncApis,
-            syncIntervalMs: this.syncOptions.syncIntervalMs!,
+            syncIntervalMs: this.syncOptions.syncIntervalMs,
         });
     }
 
@@ -471,7 +471,7 @@ class DyncBase<_TStoreMap extends Record<string, any> = Record<string, any>> {
         while (this.syncTimerStarted) {
             this.sleepAbortController = new AbortController();
             await this.syncOnce();
-            await sleep(this.syncOptions.syncIntervalMs!, this.sleepAbortController.signal);
+            await sleep(this.syncOptions.syncIntervalMs, this.sleepAbortController.signal);
         }
 
         this.syncStatus = 'disabled';

package/src/storage/dexie/DexieAdapter.ts

@@ -17,8 +17,8 @@ export class DexieAdapter implements StorageAdapter {
     }
 
     async open(): Promise<void> {
-        // Dexie auto-opens on first operation, so this is typically a no-op.
-        // However, after delete() we explicitly re-open to ensure continued usability.
+        // Dexie will auto-open on first operation
+        await requestPersistentStorage();
     }
 
     async close(): Promise<void> {
@@ -70,3 +70,14 @@ export class DexieAdapter implements StorageAdapter {
         });
     }
 }
+
+async function requestPersistentStorage(): Promise<void> {
+    if (navigator.storage && navigator.storage.persist) {
+        const granted = await navigator.storage.persist();
+        if (granted) {
+            console.log('[dync] IndexedDB storage persistence granted');
+        } else {
+            console.warn('[dync] IndexedDB storage may be cleared under storage pressure');
+        }
+    }
+}

package/src/storage/sqlite/SQLiteAdapter.ts

@@ -290,12 +290,8 @@ export class SQLiteAdapter implements StorageAdapter {
         if (!debug) {
             return;
         }
-        const hasParams = parameters && parameters.length;
-        if (typeof debug === 'function') {
-            debug(statement, hasParams ? parameters : undefined);
-            return;
-        }
         if (debug === true) {
+            const hasParams = parameters && parameters.length;
             if (hasParams) {
                 console.debug('[dync][sqlite]', statement, parameters);
             } else {

package/src/storage/sqlite/types.ts

@@ -1,7 +1,7 @@
 import type { SQLiteColumnDefinition, SQLiteTableDefinition } from './schema';
 
 export interface SQLiteAdapterOptions {
-    debug?: boolean | ((statement: string, parameters?: any[]) => void);
+    debug?: boolean;
 }
 
 export interface SQLiteColumnSchema extends SQLiteColumnDefinition {

package/src/types.ts

@@ -28,8 +28,8 @@ export interface CrudSyncApi {
     add: (item: any) => Promise<any | undefined>;
     update: (id: any, changes: any, item: any) => Promise<boolean>;
     remove: (id: any) => Promise<void>;
-    list: (lastUpdatedAt: Date) => Promise<any[]>;
-    // Optional: Extend `SyncOptions.syncIntervalMs` for this table's pull sync
+    list: (newestUpdatedAt: Date) => Promise<any[]>;
+    // Optional: Add `listExtraIntervalMs` to `SyncOptions.syncIntervalMs` for when this table is pulled during sync
     listExtraIntervalMs?: number;
     firstLoad?: (lastId: any) => Promise<any[]>;
 }
@@ -62,6 +62,7 @@ export interface BatchPushResult {
     id?: any;
     // Server-assigned updated_at (for successful adds/updates)
     updated_at?: string;
+    // Server-assigned transient error - client will retry push
     error?: string;
 }
 
@@ -124,6 +125,9 @@ export interface SyncOptions {
     conflictResolutionStrategy?: ConflictResolutionStrategy;
 }
 
+export type ResolvedSyncOptions = SyncOptions &
+    Required<Pick<SyncOptions, 'syncIntervalMs' | 'logger' | 'minLogLevel' | 'missingRemoteRecordDuringUpdateStrategy' | 'conflictResolutionStrategy'>>;
+
 export interface DyncOptions<TStoreMap extends Record<string, any> = Record<string, any>> {
     databaseName: string;
     storageAdapter: StorageAdapter;
@@ -151,7 +155,9 @@ export type SyncApi = {
 };
 
 export interface MutationEvent {
-    type: 'add' | 'update' | 'delete' | 'bulkAdd' | 'bulkPut' | 'bulkDelete' | 'clear' | 'put' | 'modify' | 'pull';
+    // 'pull' as a mutation type indicates that changes have been pulled from the server,
+    // therefore trigger live query updates for them
+    type: 'add' | 'update' | 'delete' | 'pull';
     tableName: string;
     keys?: unknown[];
 }