@bayonai/offline 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,6 +1,27 @@
 # Changelog
 
-## 0.7.0 - Unreleased
+## 0.8.0 - Unreleased
+
+- Added authoritative-result reconciliation to `createDurableCommandStore`,
+  including rebasing remaining optimistic commands without a transient revert.
+- Exposed stable durable operation IDs to remote executors for idempotent
+  command handling and prevented older refreshes from replacing confirmations.
+- Propagated injected clocks through ordered replay so deferred-command timing
+  stays deterministic in hosts and tests.
+- Added a host-owned retry policy so terminal failures remain inspectable
+  without replaying or blocking later commands, while connectivity failures
+  retain their optimistic projection and continue through ordered recovery.
+- Made IndexedDB mutation failures truthful: unavailable, rejected, and
+  cancelled timed-out writes now reject with `OfflineStorageError` instead of
+  reporting false durability.
+- Prevented delayed database opens from mutating after timeout, stale store
+  listings from replacing newer command state, and listener failures from
+  interrupting command dispatch.
+- Preserved retryable optimistic projections while later commands enter the
+  queue, added collision-resistant fallback IDs where Web Crypto UUIDs are
+  unavailable, and restored the package's 100% coverage release gate.
+
+## 0.7.0 - 2026-09-16
 
 - Added `createDurableCommandStore`, a framework-neutral store that projects
   accepted commands immediately while persisting them before remote execution.

package/README.md

@@ -202,8 +202,12 @@ package never imports an application model, database SDK, or framework.
 const commands = createDurableCommandStore({
   initialState: workspace,
   load: (scope) => workspaceApi.load(scope),
-  execute: (command) => workspaceApi.execute(command),
+  execute: (command, { operationId }) =>
+    workspaceApi.execute(command, { operationId }),
   project: (state, pending) => projectWorkspace(state, pending),
+  reconcile: (state, command, result) =>
+    reconcileWorkspace(state, command, result),
+  shouldRetry: (category) => category === "connectivity",
   store,
 });
 
@@ -221,6 +225,31 @@ commands in order, and `close` releases the local subscription and delayed
 deadline timer. Local-storage failure rejects `accepted`; hosts must show that
 failure instead of claiming the command will recover.
 
+Browser pending-write mutations reject with `OfflineStorageError` when
+IndexedDB is unavailable, rejects an operation, or cancels a timed-out
+transaction. This is intentional: successful queue acceptance always means
+the command was durably stored. Read-cache access remains best-effort, and a
+fresh remote result is still returned when optional cache invalidation or
+persistence fails.
+
+The executor receives the durable `operationId` on every attempt so the remote
+handler can use it as an idempotency key. When execution succeeds, `reconcile`
+folds the authoritative result into base state before the command is removed;
+any later optimistic commands are projected over that confirmed state. A read
+that started before this confirmation cannot replace it when it finishes.
+Reconciliation is deliberately a host-owned, synchronous state transformation.
+If it throws, the package logs the local bug and removes the already-confirmed
+command rather than risking a duplicate remote effect.
+
+`classifyError` and `shouldRetry` let a host distinguish recoverable failures
+from terminal validation, authentication, permission, or conflict outcomes.
+Retryable failures retain their optimistic projection while awaiting recovery.
+Terminal failures roll back, stay available in `operations` for host feedback
+or dismissal, and are excluded from later recovery lanes, so they neither retry
+nor block a newer command. Because recovery survives restart, classification
+must work from the package's persisted safe error message rather than relying
+only on a non-serializable error object.
+
 Use generic record summaries when an app needs to render its own status:
 
 ```ts
@@ -284,10 +313,13 @@ pnpm --filter @bayonai/offline pack --dry-run
 ## Publish Checklist
 
 1. Run the package tests and build.
-2. Run `pnpm --filter @bayonai/offline pack --dry-run` and confirm the tarball
+2. Run the 100% coverage gate and production dependency audit.
+3. Run `pnpm --filter @bayonai/offline pack --dry-run` and confirm the tarball
    includes only `package.json`, `dist`, `dist-cjs`, `README.md`,
    `CHANGELOG.md`, and `LICENSE`.
-3. Confirm `package.json` metadata, version, repository, license, and
+4. Install the generated tarball into an isolated consumer and verify ESM,
+   CommonJS, and TypeScript declaration imports.
+5. Confirm `package.json` metadata, version, repository, license, and
    `publishConfig.access` are correct.
-4. Publish from the package directory or with the package filter after the
+6. Publish from the package directory or with the package filter after the
    workspace lockfile is current.

package/dist/browserFallbackRecovery.js

@@ -8,6 +8,7 @@ export function createBrowserOfflineFallbackRecovery({ control, environment = cr
     let active = false;
     let retrying = false;
     let pullStartY = null;
+    const touchThreshold = pullThreshold === null ? Number.POSITIVE_INFINITY : pullThreshold;
     function retry() {
         if (retrying)
             return;
@@ -19,7 +20,9 @@ export function createBrowserOfflineFallbackRecovery({ control, environment = cr
         }
         catch (error) {
             // A failed navigation must leave the recovery action visible and usable.
-            console.error("[Bayon offline] Offline fallback reload failed.", { error });
+            console.error("[Bayon offline] Offline fallback reload failed.", {
+                error,
+            });
             retrying = false;
             control.disabled = false;
         }
@@ -32,7 +35,7 @@ export function createBrowserOfflineFallbackRecovery({ control, environment = cr
         const touchY = getSingleTouchY(event, "changedTouches");
         if (pullStartY !== null &&
             touchY !== null &&
-            touchY - pullStartY >= (pullThreshold ?? Number.POSITIVE_INFINITY)) {
+            touchY - pullStartY >= touchThreshold) {
             retry();
         }
         pullStartY = null;

package/dist/durableCommandStore.d.ts

@@ -14,6 +14,10 @@ export type DurableCommandDispatch = {
     accepted: Promise<void>;
     operationId: string;
 };
+export type DurableCommandExecutionContext = {
+    /** Stable across retries so the remote command can be idempotent. */
+    operationId: string;
+};
 export type DurableCommandStore<State, Command, Scope> = {
     cancel: (operationId: string) => Promise<boolean>;
     close: () => void;
@@ -30,14 +34,16 @@ export type DurableCommandStore<State, Command, Scope> = {
  * durable command lifecycle. A command becomes visible immediately, but is
  * never sent remotely until IndexedDB has accepted it.
  */
-export declare function createDurableCommandStore<State, Command, Scope>({ canCancel, classifyError, createId, execute, initialState, load, now, project, store, }: {
+export declare function createDurableCommandStore<State, Command, Scope, Result = unknown>({ canCancel, classifyError, createId, execute, initialState, load, now, project, reconcile, shouldRetry, store, }: {
     canCancel?: (command: Command, now: string) => boolean;
     classifyError?: (error: unknown) => DurableCommandErrorCategory;
     createId?: () => string;
-    execute: (command: Command) => Promise<unknown>;
+    execute: (command: Command, context: DurableCommandExecutionContext) => Promise<Result>;
     initialState: State;
     load: (scope: Scope) => Promise<State>;
     now?: () => string;
     project: (state: State, commands: readonly PendingWriteRecord<Command>[]) => State;
+    reconcile?: (state: State, command: Command, result: Result) => State;
+    shouldRetry?: (category: DurableCommandErrorCategory, command: Command) => boolean;
     store: PendingWriteStore<Command>;
 }): DurableCommandStore<State, Command, Scope>;

package/dist/durableCommandStore.js

@@ -4,24 +4,59 @@ import { createOrderedPendingWriteExecutor, } from "./pendingWrites.js";
  * durable command lifecycle. A command becomes visible immediately, but is
  * never sent remotely until IndexedDB has accepted it.
  */
-export function createDurableCommandStore({ canCancel = () => true, classifyError = () => "unexpected", createId = createDurableCommandId, execute, initialState, load, now = () => new Date().toISOString(), project, store, }) {
+export function createDurableCommandStore({ canCancel = () => true, classifyError = () => "unexpected", createId = createDurableCommandId, execute, initialState, load, now = () => new Date().toISOString(), project, reconcile, shouldRetry = () => true, store, }) {
     let baseState = initialState;
-    let refreshGeneration = 0;
+    let baseStateGeneration = 0;
     let savedAtMillis = 0;
+    let publishGeneration = 0;
+    let storedRecords = [];
     let deferredRecoveryTimer = null;
+    const provisionalRecords = new Map();
+    const localStorageFailures = new Map();
     let snapshot = {
         operations: [],
         state: initialState,
     };
     const listeners = new Set();
     const executor = createOrderedPendingWriteExecutor({
+        now,
         scopeKey: "durable-command-store",
+        select: isActiveCommand,
         store,
-        sync: execute,
+        sync: async (command, { recordId }) => {
+            const result = await execute(command, { operationId: recordId });
+            // A completed remote write is newer than any read already in flight.
+            // Reconciliation is local-only: a projector bug must never retry a
+            // command whose remote effect may already have committed.
+            baseStateGeneration += 1;
+            if (reconcile) {
+                try {
+                    baseState = reconcile(baseState, command, result);
+                }
+                catch (error) {
+                    console.error("[Bayon offline] Unable to reconcile a confirmed durable command.", { error, operationId: recordId });
+                }
+            }
+        },
     });
     function notify() {
-        for (const listener of listeners)
-            listener();
+        for (const listener of listeners) {
+            try {
+                listener();
+            }
+            catch (error) {
+                console.error("[Bayon offline] Durable-command listener failed.", {
+                    error,
+                });
+            }
+        }
+    }
+    function classifyStoredError(error) {
+        return classifyError(new Error(error ?? "Unable to sync durable command."));
+    }
+    function isActiveCommand(record) {
+        return (record.syncStatus !== "failed" ||
+            shouldRetry(classifyStoredError(record.error), record.payload));
     }
     function scheduleDeferredRecovery(records) {
         if (deferredRecoveryTimer) {
@@ -37,32 +72,62 @@ export function createDurableCommandStore({ canCancel = () => true, classifyErro
         }, null);
         if (nextDeadline === null)
             return;
-        deferredRecoveryTimer = setTimeout(() => void recover(), Math.max(0, nextDeadline - currentTime));
+        deferredRecoveryTimer = setTimeout(recoverInBackground, Math.max(0, nextDeadline - currentTime));
     }
-    async function publish() {
-        const records = await store.list();
+    function currentRecords() {
+        const records = new Map(storedRecords.map((record) => [record.id, record]));
+        for (const record of provisionalRecords.values()) {
+            records.set(record.id, record);
+        }
+        return [...records.values()].sort((left, right) => left.savedAt.localeCompare(right.savedAt) ||
+            left.id.localeCompare(right.id));
+    }
+    function applySnapshot(records) {
         snapshot = {
-            operations: records.map((record) => ({
-                command: record.payload,
-                ...(record.error
-                    ? { error: classifyError(new Error(record.error)) }
-                    : {}),
-                id: record.id,
-                status: record.syncStatus === "failed"
-                    ? "failed"
-                    : record.syncStatus === "syncing"
-                        ? "syncing"
-                        : "accepted",
-            })),
-            state: project(baseState, records.filter((record) => record.syncStatus !== "failed")),
+            operations: [
+                ...records.map((record) => ({
+                    command: record.payload,
+                    ...(record.syncStatus === "failed"
+                        ? { error: classifyStoredError(record.error) }
+                        : {}),
+                    id: record.id,
+                    status: record.syncStatus === "failed"
+                        ? "failed"
+                        : record.syncStatus === "syncing"
+                            ? "syncing"
+                            : "accepted",
+                })),
+                ...[...localStorageFailures].map(([id, command]) => ({
+                    command,
+                    error: "local-storage",
+                    id,
+                    status: "failed",
+                })),
+            ],
+            state: project(baseState, records.filter(isActiveCommand)),
         };
         scheduleDeferredRecovery(records);
+    }
+    async function publish() {
+        const generation = ++publishGeneration;
+        const records = await store.list();
+        if (generation !== publishGeneration)
+            return;
+        storedRecords = records;
+        applySnapshot(currentRecords());
         notify();
     }
     async function recover() {
         await executor.recover();
         await publish();
     }
+    function recoverInBackground() {
+        void recover().catch((error) => {
+            console.error("[Bayon offline] Unable to recover durable commands.", {
+                error,
+            });
+        });
+    }
     const unsubscribe = store.subscribe(() => {
         void publish().catch((error) => {
             console.error("[Bayon offline] Unable to publish durable commands.", {
@@ -72,6 +137,11 @@ export function createDurableCommandStore({ canCancel = () => true, classifyErro
     });
     return {
         async cancel(operationId) {
+            if (localStorageFailures.delete(operationId)) {
+                applySnapshot(currentRecords());
+                notify();
+                return true;
+            }
             const record = await store.get(operationId);
             if (!record ||
                 record.syncStatus === "syncing" ||
@@ -86,6 +156,7 @@ export function createDurableCommandStore({ canCancel = () => true, classifyErro
         close() {
             if (deferredRecoveryTimer)
                 clearTimeout(deferredRecoveryTimer);
+            publishGeneration += 1;
             unsubscribe();
         },
         dispatch(command, options = {}) {
@@ -100,36 +171,20 @@ export function createDurableCommandStore({ canCancel = () => true, classifyErro
                 snapshotId: operationId,
                 syncStatus: "pending",
             };
-            // Project before storage settles so controls never wait on storage I/O.
-            snapshot = {
-                operations: [
-                    ...snapshot.operations,
-                    { command, id: operationId, status: "accepted" },
-                ],
-                state: project(baseState, [
-                    ...snapshot.operations
-                        .filter((operation) => operation.status !== "failed")
-                        .map((operation) => ({
-                        id: operation.id,
-                        payload: operation.command,
-                        savedAt: record.savedAt,
-                        snapshotId: operation.id,
-                        syncStatus: "pending",
-                    })),
-                    record,
-                ]),
-            };
+            // Product decision: provisional records remain part of the same ordered
+            // projection as persisted retryable failures while storage settles.
+            provisionalRecords.set(operationId, record);
+            localStorageFailures.delete(operationId);
+            applySnapshot(currentRecords());
             notify();
             const accepted = store.set(record).then(async () => {
+                provisionalRecords.delete(operationId);
                 await publish();
-                void recover();
+                recoverInBackground();
             }, async (error) => {
-                snapshot = {
-                    operations: snapshot.operations.map((operation) => operation.id === operationId
-                        ? { ...operation, error: "local-storage", status: "failed" }
-                        : operation),
-                    state: baseState,
-                };
+                provisionalRecords.delete(operationId);
+                localStorageFailures.set(operationId, command);
+                applySnapshot(currentRecords());
                 notify();
                 throw error;
             });
@@ -140,9 +195,9 @@ export function createDurableCommandStore({ canCancel = () => true, classifyErro
             await recover();
         },
         async refresh(scope) {
-            const generation = ++refreshGeneration;
+            const generation = ++baseStateGeneration;
             const loaded = await load(scope);
-            if (generation !== refreshGeneration)
+            if (generation !== baseStateGeneration)
                 return;
             baseState = loaded;
             await publish();
@@ -154,5 +209,15 @@ export function createDurableCommandStore({ canCancel = () => true, classifyErro
     };
 }
 function createDurableCommandId() {
-    return globalThis.crypto?.randomUUID?.() ?? `command-${Date.now()}`;
+    return globalThis.crypto?.randomUUID?.() ?? createFallbackDurableCommandId();
+}
+let fallbackDurableCommandSequence = 0;
+function createFallbackDurableCommandId() {
+    fallbackDurableCommandSequence += 1;
+    return [
+        "command",
+        Date.now().toString(36),
+        fallbackDurableCommandSequence.toString(36),
+        Math.random().toString(36).slice(2),
+    ].join("-");
 }

package/dist/idbDriver.d.ts

@@ -20,4 +20,7 @@ export type BrowserKeyValueDriverOptions = {
     operationTimeoutMs: number;
     storeName: string;
 };
+export declare class OfflineStorageError extends Error {
+    name: string;
+}
 export declare function createIdbKeyValueDriver({ databaseName, databaseVersion, indexedDB, operationTimeoutMs, storeName, }: BrowserKeyValueDriverOptions): BrowserKeyValueDriver | null;

package/dist/idbDriver.js

@@ -1,4 +1,7 @@
 import { wrap, } from "idb";
+export class OfflineStorageError extends Error {
+    name = "OfflineStorageError";
+}
 export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB = globalThis.indexedDB, operationTimeoutMs, storeName, }) {
     if (!indexedDB) {
         return null;
@@ -9,25 +12,33 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
         indexedDB,
         storeName,
     });
+    function runMutation(operationName, mutate) {
+        return runTransactionalStorageOperation({
+            failureMode: "throw",
+            fallback: undefined,
+            operationName,
+            storeName,
+            operation: async (setTransaction, isCancelled) => {
+                const database = await databasePromise;
+                if (isCancelled())
+                    return;
+                const transaction = database.transaction(storeName, "readwrite");
+                setTransaction(transaction);
+                await mutate(transaction.objectStore(storeName));
+                await transaction.done;
+            },
+            timeoutMs: operationTimeoutMs,
+        });
+    }
     return {
         async clear() {
-            await runTransactionalStorageOperation({
-                fallback: undefined,
-                operationName: "clear object store",
-                operation: async (setTransaction) => {
-                    const database = await databasePromise;
-                    const transaction = database.transaction(storeName, "readwrite");
-                    setTransaction(transaction);
-                    await transaction.objectStore(storeName).clear();
-                    await transaction.done;
-                },
-                timeoutMs: operationTimeoutMs,
-            });
+            await runMutation("clear object store", (objectStore) => objectStore.clear());
         },
         async close() {
             await runBrowserStorageOperation({
                 fallback: undefined,
                 operationName: "close database",
+                storeName,
                 operation: async () => {
                     const database = await databasePromise;
                     database.close();
@@ -36,18 +47,7 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
             });
         },
         async delete(key) {
-            await runTransactionalStorageOperation({
-                fallback: undefined,
-                operationName: "delete key",
-                operation: async (setTransaction) => {
-                    const database = await databasePromise;
-                    const transaction = database.transaction(storeName, "readwrite");
-                    setTransaction(transaction);
-                    await transaction.objectStore(storeName).delete(key);
-                    await transaction.done;
-                },
-                timeoutMs: operationTimeoutMs,
-            });
+            await runMutation("delete key", (objectStore) => objectStore.delete(key));
         },
         async deleteIf(key, predicate) {
             return runConditionalStorageOperation({
@@ -68,6 +68,7 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
             return runBrowserStorageOperation({
                 fallback: null,
                 operationName: "read key",
+                storeName,
                 operation: async () => {
                     const database = await databasePromise;
                     return (await database.get(storeName, key)) ?? null;
@@ -79,6 +80,7 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
             return runBrowserStorageOperation({
                 fallback: [],
                 operationName: "list object store",
+                storeName,
                 operation: async () => {
                     const database = await databasePromise;
                     return database.getAll(storeName);
@@ -90,6 +92,7 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
             return runBrowserStorageOperation({
                 fallback: [],
                 operationName: "list object-store entries",
+                storeName,
                 operation: async () => {
                     const database = await databasePromise;
                     // Keys and values must come from one transaction. Separate database
@@ -111,18 +114,7 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
             });
         },
         async set(key, value) {
-            await runTransactionalStorageOperation({
-                fallback: undefined,
-                operationName: "write key",
-                operation: async (setTransaction) => {
-                    const database = await databasePromise;
-                    const transaction = database.transaction(storeName, "readwrite");
-                    setTransaction(transaction);
-                    await transaction.objectStore(storeName).put(value, key);
-                    await transaction.done;
-                },
-                timeoutMs: operationTimeoutMs,
-            });
+            await runMutation("write key", (objectStore) => objectStore.put(value, key));
         },
         async setIf(key, value, predicate) {
             return runConditionalStorageOperation({
@@ -155,18 +147,27 @@ async function openKeyValueDatabase({ databaseName, databaseVersion, indexedDB,
     }
     return database;
 }
-async function runBrowserStorageOperation({ cancelOnTimeout, fallback, operation, operationName, timeoutMs, }) {
+async function runBrowserStorageOperation({ cancelOnTimeout, failureMode = "fallback", fallback, operation, operationName, storeName, timeoutMs, }) {
     let timeoutId = null;
+    const startedAt = Date.now();
     try {
         return await Promise.race([
             operation(),
-            new Promise((resolve) => {
+            new Promise((resolve, reject) => {
                 timeoutId = setTimeout(() => {
-                    console.error(`IndexedDB timed out while trying to ${operationName}.`, {
+                    console.warn("[Bayon offline] IndexedDB operation timed out.", {
+                        elapsedMs: Date.now() - startedAt,
+                        operationName,
+                        storeName,
                         timeoutMs,
                     });
                     if (!cancelOnTimeout || cancelOnTimeout()) {
-                        resolve(fallback);
+                        if (failureMode === "throw") {
+                            reject(new OfflineStorageError(`IndexedDB timed out while attempting to ${operationName} in ${storeName}.`));
+                        }
+                        else {
+                            resolve(fallback);
+                        }
                     }
                 }, timeoutMs);
             }),
@@ -174,6 +175,11 @@ async function runBrowserStorageOperation({ cancelOnTimeout, fallback, operation
     }
     catch (error) {
         console.error(`IndexedDB failed to ${operationName}.`, { error });
+        if (failureMode === "throw") {
+            if (error instanceof OfflineStorageError)
+                throw error;
+            throw new OfflineStorageError(`IndexedDB failed to ${operationName} in ${storeName}.`, { cause: error });
+        }
         return fallback;
     }
     finally {
@@ -182,12 +188,14 @@ async function runBrowserStorageOperation({ cancelOnTimeout, fallback, operation
         }
     }
 }
-async function runTransactionalStorageOperation({ fallback, operation, operationName, timeoutMs, }) {
+async function runTransactionalStorageOperation({ failureMode, fallback, operation, operationName, storeName, timeoutMs, }) {
     let transaction;
     let cancelled = false;
     return runBrowserStorageOperation({
+        failureMode,
         fallback,
         operationName,
+        storeName,
         timeoutMs,
         cancelOnTimeout() {
             cancelled = true;
@@ -203,14 +211,12 @@ async function runTransactionalStorageOperation({ fallback, operation, operation
             }
         },
         operation: async () => {
-            if (cancelled)
-                return fallback;
             return operation((nextTransaction) => {
                 transaction = nextTransaction;
                 // Aborting can reject transaction.done. The operation also awaits it,
                 // but observing it here prevents a race from becoming unhandled.
                 void transaction.done.catch(() => undefined);
-            });
+            }, () => cancelled);
         },
     });
 }
@@ -218,8 +224,10 @@ async function runConditionalStorageOperation({ apply, databasePromise, operatio
     let transaction;
     let cancelled = false;
     return runBrowserStorageOperation({
+        failureMode: "throw",
         fallback: false,
         operationName,
+        storeName,
         timeoutMs,
         cancelOnTimeout() {
             cancelled = true;

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from "./browserRecovery";
 export * from "./browserCoordination";
 export * from "./browserFallbackRecovery";
 export * from "./durableCommandStore";
+export { OfflineStorageError } from "./idbDriver";

package/dist/index.js

@@ -4,3 +4,4 @@ export * from "./browserRecovery.js";
 export * from "./browserCoordination.js";
 export * from "./browserFallbackRecovery.js";
 export * from "./durableCommandStore.js";
+export { OfflineStorageError } from "./idbDriver.js";

package/dist/pendingWrites.d.ts

@@ -94,7 +94,11 @@ export type SyncPendingWritesResult = {
     superseded: number;
     synced: number;
 };
-export type PendingWriteSync<Payload> = (payload: Payload) => Promise<unknown>;
+export type PendingWriteSyncContext = {
+    /** Stable durable-record identity; safe to use as a remote idempotency key. */
+    recordId: string;
+};
+export type PendingWriteSync<Payload, Result = unknown> = (payload: Payload, context: PendingWriteSyncContext) => Promise<Result>;
 export type RunPendingWriteResult<TResult, TQueued> = {
     result: TResult;
     status: "synced";
@@ -130,7 +134,7 @@ export declare function createMemoryPendingWriteDriver(): PendingWriteDriver;
 export declare function createBrowserPendingWriteDriver({ databaseName, databaseVersion, indexedDB, operationTimeoutMs, storeName, }: Omit<BrowserPendingWriteStoreOptions, "keyPrefix" | "normalizePayload" | "schemaVersion">): PendingWriteDriver | null;
 export declare function createBrowserPendingWriteStore<Payload = unknown>({ databaseName, databaseVersion, indexedDB, keyPrefix, normalizeLegacyRecord, normalizePayload, operationTimeoutMs, schemaVersion, storeName, }: BrowserPendingWriteStoreOptions<Payload>): PendingWriteStore<Payload>;
 export declare function createPendingWriteKey({ id, prefix }: PendingWriteKeyOptions): string;
-export declare function createPendingWriteSnapshotId(): `${string}-${string}-${string}-${string}-${string}`;
+export declare function createPendingWriteSnapshotId(): string;
 export declare function syncPendingWrite<Payload>({ id, now, store, sync, }: {
     id: string;
     now?: () => string;
@@ -142,7 +146,8 @@ export declare function syncPendingWrite<Payload>({ id, now, store, sync, }: {
  * same store/scope. Callers own the selection predicate and idempotent remote
  * mutation semantics.
  */
-export declare function syncPendingWrites<Payload>({ scopeKey, select, stopOnFailure, store, sync, }: {
+export declare function syncPendingWrites<Payload>({ now, scopeKey, select, stopOnFailure, store, sync, }: {
+    now?: () => string;
     scopeKey?: string;
     select?: (record: PendingWriteRecord<Payload>) => boolean;
     /** Preserve caller ordering by leaving later records for a future retry. */
@@ -161,7 +166,8 @@ export declare function summarizePendingWrites<Payload>(records: Array<PendingWr
  * workspace. Use its `recover` method for background replay and `run` for new
  * writes so a newer remote mutation cannot overtake an older queued mutation.
  */
-export declare function createOrderedPendingWriteExecutor<Payload>({ scopeKey, select, store, sync, }: {
+export declare function createOrderedPendingWriteExecutor<Payload>({ now, scopeKey, select, store, sync, }: {
+    now?: () => string;
     scopeKey?: string;
     select?: (record: PendingWriteRecord<Payload>) => boolean;
     store: PendingWriteStore<Payload>;