@bayonai/offline 0.5.1 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 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.
+- Added durable `notBefore` deadlines to pending writes, preserving ordered
+  deferred commands across navigation and restart.
+
+## 0.6.0 - 2026-09-14
+
+- Preserved the original, non-persisted failure value on failed pending-write
+  sync results so host applications can classify errors without losing stack
+  traces or structured conflict details.
+
 ## 0.5.1 - 2026-09-12
 
 - Prevented timed-out conditional IndexedDB replacements and deletions from

package/README.md

@@ -98,6 +98,10 @@ await syncPendingWrite({
 });
 ```
 
+Failed sync results include a safe persisted `error` string and the original
+non-persisted `failure` value. Hosts may use `failure` for structured logging or
+domain error classification; it is never written into the pending-write store.
+
 For a browser application that wants durable, silent recovery, mount the
 headless controller once for the active account or workspace:
 
@@ -187,6 +191,65 @@ the later write queued until the predecessor is delivered. This protects remote
 write order; it does not replace idempotent server-side mutation handling for
 ambiguous request outcomes.
 
+## Durable Command Store
+
+Use `createDurableCommandStore` when a host needs one client-side owner for
+base data, optimistic projection, durable commands, and remote reconciliation.
+The host supplies its domain projection and authenticated transport; this
+package never imports an application model, database SDK, or framework.
+
+```ts
+const commands = createDurableCommandStore({
+  initialState: workspace,
+  load: (scope) => workspaceApi.load(scope),
+  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,
+});
+
+const { accepted, operationId } = commands.dispatch(command);
+await accepted; // locally durable; remote confirmation continues in background
+
+// A delayed command stays ordered and can be cancelled before its deadline.
+const deferred = commands.dispatch(deleteCommand, { notBefore: deadline });
+await commands.cancel(deferred.operationId);
+```
+
+`getSnapshot` and `subscribe` expose projected state and command status to any
+UI framework. `refresh` ignores older read results, `recover` replays durable
+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
@@ -250,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

@@ -0,0 +1,49 @@
+import { type PendingWriteRecord, type PendingWriteStore } from "./pendingWrites";
+export type DurableCommandErrorCategory = "auth" | "conflict" | "connectivity" | "local-storage" | "permission" | "unexpected" | "validation";
+export type DurableCommandOperation<Command> = {
+    command: Command;
+    error?: DurableCommandErrorCategory;
+    id: string;
+    status: "accepted" | "failed" | "syncing";
+};
+export type DurableCommandSnapshot<State, Command> = {
+    operations: DurableCommandOperation<Command>[];
+    state: State;
+};
+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;
+    dispatch: (command: Command, options?: {
+        notBefore?: string;
+    }) => DurableCommandDispatch;
+    getSnapshot: () => DurableCommandSnapshot<State, Command>;
+    recover: () => Promise<void>;
+    refresh: (scope: Scope) => Promise<void>;
+    subscribe: (listener: () => void) => () => void;
+};
+/**
+ * Hosts provide domain projection and transport; this package only owns the
+ * 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, 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, 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

@@ -0,0 +1,223 @@
+import { createOrderedPendingWriteExecutor, } from "./pendingWrites.js";
+/**
+ * Hosts provide domain projection and transport; this package only owns the
+ * 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, reconcile, shouldRetry = () => true, store, }) {
+    let baseState = initialState;
+    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: 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) {
+            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) {
+            clearTimeout(deferredRecoveryTimer);
+            deferredRecoveryTimer = null;
+        }
+        const currentTime = Date.parse(now());
+        const nextDeadline = records.reduce((earliest, record) => {
+            const deadline = record.notBefore ? Date.parse(record.notBefore) : NaN;
+            if (!Number.isFinite(deadline) || deadline <= currentTime)
+                return earliest;
+            return earliest === null ? deadline : Math.min(earliest, deadline);
+        }, null);
+        if (nextDeadline === null)
+            return;
+        deferredRecoveryTimer = setTimeout(recoverInBackground, Math.max(0, nextDeadline - currentTime));
+    }
+    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.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.", {
+                error,
+            });
+        });
+    });
+    return {
+        async cancel(operationId) {
+            if (localStorageFailures.delete(operationId)) {
+                applySnapshot(currentRecords());
+                notify();
+                return true;
+            }
+            const record = await store.get(operationId);
+            if (!record ||
+                record.syncStatus === "syncing" ||
+                !canCancel(record.payload, now())) {
+                return false;
+            }
+            const cancelled = await store.clearIfSnapshotId(record.id, record.snapshotId);
+            if (cancelled)
+                await publish();
+            return cancelled;
+        },
+        close() {
+            if (deferredRecoveryTimer)
+                clearTimeout(deferredRecoveryTimer);
+            publishGeneration += 1;
+            unsubscribe();
+        },
+        dispatch(command, options = {}) {
+            const operationId = createId();
+            const timestamp = Math.max(Date.parse(now()), savedAtMillis + 1);
+            savedAtMillis = timestamp;
+            const record = {
+                id: operationId,
+                ...(options.notBefore ? { notBefore: options.notBefore } : {}),
+                payload: command,
+                savedAt: new Date(timestamp).toISOString(),
+                snapshotId: operationId,
+                syncStatus: "pending",
+            };
+            // 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();
+                recoverInBackground();
+            }, async (error) => {
+                provisionalRecords.delete(operationId);
+                localStorageFailures.set(operationId, command);
+                applySnapshot(currentRecords());
+                notify();
+                throw error;
+            });
+            return { accepted, operationId };
+        },
+        getSnapshot: () => snapshot,
+        async recover() {
+            await recover();
+        },
+        async refresh(scope) {
+            const generation = ++baseStateGeneration;
+            const loaded = await load(scope);
+            if (generation !== baseStateGeneration)
+                return;
+            baseState = loaded;
+            await publish();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+function createDurableCommandId() {
+    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,22 +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 runBrowserStorageOperation({
-                fallback: undefined,
-                operationName: "clear object store",
-                operation: async () => {
-                    const database = await databasePromise;
-                    await database.clear(storeName);
-                },
-                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();
@@ -33,15 +47,7 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
             });
         },
         async delete(key) {
-            await runBrowserStorageOperation({
-                fallback: undefined,
-                operationName: "delete key",
-                operation: async () => {
-                    const database = await databasePromise;
-                    await database.delete(storeName, key);
-                },
-                timeoutMs: operationTimeoutMs,
-            });
+            await runMutation("delete key", (objectStore) => objectStore.delete(key));
         },
         async deleteIf(key, predicate) {
             return runConditionalStorageOperation({
@@ -62,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;
@@ -73,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);
@@ -84,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
@@ -105,15 +114,7 @@ export function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, ind
             });
         },
         async set(key, value) {
-            await runBrowserStorageOperation({
-                fallback: undefined,
-                operationName: "write key",
-                operation: async () => {
-                    const database = await databasePromise;
-                    await database.put(storeName, value, key);
-                },
-                timeoutMs: operationTimeoutMs,
-            });
+            await runMutation("write key", (objectStore) => objectStore.put(value, key));
         },
         async setIf(key, value, predicate) {
             return runConditionalStorageOperation({
@@ -146,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);
             }),
@@ -165,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 {
@@ -173,12 +188,46 @@ async function runBrowserStorageOperation({ cancelOnTimeout, fallback, operation
         }
     }
 }
+async function runTransactionalStorageOperation({ failureMode, fallback, operation, operationName, storeName, timeoutMs, }) {
+    let transaction;
+    let cancelled = false;
+    return runBrowserStorageOperation({
+        failureMode,
+        fallback,
+        operationName,
+        storeName,
+        timeoutMs,
+        cancelOnTimeout() {
+            cancelled = true;
+            if (!transaction)
+                return true;
+            try {
+                transaction.abort();
+                return true;
+            }
+            catch (error) {
+                console.warn("[Bayon offline] IndexedDB transaction already settling at timeout.", { error, operationName });
+                return false;
+            }
+        },
+        operation: async () => {
+            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);
+        },
+    });
+}
 async function runConditionalStorageOperation({ apply, databasePromise, operationName, storeName, timeoutMs, }) {
     let transaction;
     let cancelled = false;
     return runBrowserStorageOperation({
+        failureMode: "throw",
         fallback: false,
         operationName,
+        storeName,
         timeoutMs,
         cancelOnTimeout() {
             cancelled = true;

package/dist/index.d.ts

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

package/dist/index.js

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