@bayonai/offline 0.7.0 → 0.8.0

package/dist/pendingWrites.js

@@ -1,4 +1,4 @@
-import { createIdbKeyValueDriver, } from "./idbDriver.js";
+import { createIdbKeyValueDriver, OfflineStorageError, } from "./idbDriver.js";
 export const pendingWriteSchemaVersion = 1;
 export const pendingWriteOperationTimeoutMs = 2_000;
 export const pendingWriteSyncLeaseTimeoutMs = 60_000;
@@ -148,14 +148,24 @@ export function createBrowserPendingWriteStore({ databaseName, databaseVersion,
         operationTimeoutMs,
         storeName,
     });
-    return createPendingWriteStore(driver ?? createNoopPendingWriteDriver(), { keyPrefix, normalizeLegacyRecord, normalizePayload, schemaVersion });
+    return createPendingWriteStore(driver ?? createUnavailablePendingWriteDriver(), { keyPrefix, normalizeLegacyRecord, normalizePayload, schemaVersion });
 }
 export function createPendingWriteKey({ id, prefix }) {
     return `${prefix}:${encodeURIComponent(id)}`;
 }
 export function createPendingWriteSnapshotId() {
-    return globalThis.crypto.randomUUID();
+    const randomId = globalThis.crypto?.randomUUID?.();
+    if (randomId)
+        return randomId;
+    pendingWriteSnapshotSequence += 1;
+    return [
+        "snapshot",
+        Date.now().toString(36),
+        pendingWriteSnapshotSequence.toString(36),
+        Math.random().toString(36).slice(2),
+    ].join("-");
 }
+let pendingWriteSnapshotSequence = 0;
 export async function syncPendingWrite({ id, now = () => new Date().toISOString(), store, sync, }) {
     const pending = await store.get(id);
     if (!pending) {
@@ -163,8 +173,7 @@ export async function syncPendingWrite({ id, now = () => new Date().toISOString(
     }
     // A delayed command remains in its ordered lane until its grace period has
     // elapsed. This makes cancellation survive UI unmounts and app restarts.
-    if (pending.notBefore &&
-        Date.parse(pending.notBefore) > Date.parse(now())) {
+    if (pending.notBefore && Date.parse(pending.notBefore) > Date.parse(now())) {
         return { status: "idle" };
     }
     const claimedSnapshotId = createPendingWriteSnapshotId();
@@ -179,7 +188,7 @@ export async function syncPendingWrite({ id, now = () => new Date().toISOString(
         return { status: "superseded" };
     }
     try {
-        await sync(pending.payload);
+        await sync(pending.payload, { recordId: pending.id });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "Unable to sync pending write.";
@@ -208,7 +217,7 @@ export async function syncPendingWrite({ id, now = () => new Date().toISOString(
  * same store/scope. Callers own the selection predicate and idempotent remote
  * mutation semantics.
  */
-export function syncPendingWrites({ scopeKey = "all", select = () => true, stopOnFailure = false, store, sync, }) {
+export function syncPendingWrites({ now, scopeKey = "all", select = () => true, stopOnFailure = false, store, sync, }) {
     let inFlightByScope = pendingWriteSyncs.get(store);
     if (!inFlightByScope) {
         inFlightByScope = new Map();
@@ -219,6 +228,7 @@ export function syncPendingWrites({ scopeKey = "all", select = () => true, stopO
         return existing;
     }
     const syncRun = performPendingWriteSync({
+        now,
         select,
         stopOnFailure,
         store,
@@ -265,7 +275,7 @@ export function summarizePendingWrites(records) {
     }, { failedCount: 0, pendingCount: 0, syncingCount: 0, totalCount: 0 });
 }
 const pendingWriteSyncs = new WeakMap();
-async function performPendingWriteSync({ select, stopOnFailure, store, sync, }) {
+async function performPendingWriteSync({ now, select, stopOnFailure, store, sync, }) {
     const summary = {
         attempted: 0,
         failed: 0,
@@ -278,6 +288,7 @@ async function performPendingWriteSync({ select, stopOnFailure, store, sync, })
     for (const record of records) {
         const result = await syncPendingWrite({
             id: record.id,
+            now,
             store,
             sync,
         });
@@ -313,7 +324,7 @@ function isPendingWriteSyncClaimAvailable(record, now) {
  * 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 function createOrderedPendingWriteExecutor({ scopeKey = "all", select = () => true, store, sync, }) {
+export function createOrderedPendingWriteExecutor({ now, scopeKey = "all", select = () => true, store, sync, }) {
     let execution = Promise.resolve();
     function inOrder(operation) {
         const result = execution.then(operation, operation);
@@ -322,6 +333,7 @@ export function createOrderedPendingWriteExecutor({ scopeKey = "all", select = (
     }
     function recover() {
         return inOrder(() => syncPendingWrites({
+            now,
             scopeKey,
             select,
             stopOnFailure: true,
@@ -337,6 +349,7 @@ export function createOrderedPendingWriteExecutor({ scopeKey = "all", select = (
                     return runPendingWrite(options);
                 }
                 const replay = await syncPendingWrites({
+                    now,
                     scopeKey,
                     select,
                     stopOnFailure: true,
@@ -354,7 +367,8 @@ export function createOrderedPendingWriteExecutor({ scopeKey = "all", select = (
         },
     };
 }
-function createNoopPendingWriteDriver() {
+function createUnavailablePendingWriteDriver() {
+    const unavailable = () => new OfflineStorageError("IndexedDB is unavailable; the pending write was not stored.");
     return {
         async clear() { },
         async clearIf() {
@@ -368,9 +382,11 @@ function createNoopPendingWriteDriver() {
         async list() {
             return [];
         },
-        async set() { },
+        async set() {
+            throw unavailable();
+        },
         async setIf() {
-            return false;
+            throw unavailable();
         },
     };
 }

package/dist/readCache.d.ts

@@ -3,7 +3,7 @@ export declare const readCacheSchemaVersion = 1;
 export declare const readCacheFreshnessMaxAgeMs = 30000;
 export declare const durableReadCacheFreshnessMaxAgeMs: number;
 export declare const identityReadCacheFreshnessMaxAgeMs: number;
-export declare const browserReadCacheOperationTimeoutMs = 2000;
+export declare const browserReadCacheOperationTimeoutMs = 1000;
 export type ReadCacheHit<T> = {
     fromCache: true;
     savedAt: string;

package/dist/readCache.js

@@ -3,7 +3,9 @@ export const readCacheSchemaVersion = 1;
 export const readCacheFreshnessMaxAgeMs = 30_000;
 export const durableReadCacheFreshnessMaxAgeMs = 60 * 60_000;
 export const identityReadCacheFreshnessMaxAgeMs = 24 * 60 * 60_000;
-export const browserReadCacheOperationTimeoutMs = 2_000;
+// Cache reads are optional and should yield to the fresh loader quickly when
+// IndexedDB is blocked by a browser/WebView lifecycle or another tab.
+export const browserReadCacheOperationTimeoutMs = 1_000;
 const pendingFreshLoads = new WeakMap();
 const cachePruners = new WeakMap();
 export function createReadCache(driver) {
@@ -133,8 +135,7 @@ export function createBrowserReadCache({ databaseName, databaseVersion, indexedD
  */
 export function pruneReadCache({ cache, maxAgeMs, now = () => Date.now(), }) {
     const resourceCache = cache.capture?.() ?? cache;
-    return cachePruners.get(resourceCache)?.({ maxAgeMs, now }) ??
-        Promise.resolve(0);
+    return (cachePruners.get(resourceCache)?.({ maxAgeMs, now }) ?? Promise.resolve(0));
 }
 export function createReadCacheKey({ namespace, params = {}, prefix, scope, }) {
     const serializedParams = Object.entries(params)
@@ -156,7 +157,15 @@ export async function readThroughCache({ cache, forceFresh = false, key, loadFre
     if (forceFresh) {
         // Deletion advances the cache version, so a request started before this
         // post-write refresh cannot restore stale data after it finishes.
-        await resourceCache.delete(key);
+        try {
+            await resourceCache.delete(key);
+        }
+        catch (error) {
+            console.error("[Bayon offline] Unable to invalidate the read cache.", {
+                error: normalizeError(error),
+                key,
+            });
+        }
     }
     const version = resourceCache.getVersion(key);
     const cached = await resourceCache.get(key);
@@ -170,7 +179,15 @@ export async function readThroughCache({ cache, forceFresh = false, key, loadFre
     }
     try {
         const fresh = await loadSharedFreshResource(resourceCache, key, loadFresh);
-        await resourceCache.setIfVersion(key, fresh, version);
+        try {
+            await resourceCache.setIfVersion(key, fresh, version);
+        }
+        catch (error) {
+            console.error("[Bayon offline] Unable to refresh the read cache.", {
+                error: normalizeError(error),
+                key,
+            });
+        }
         return {
             data: fresh,
             error: null,

package/dist-cjs/browserFallbackRecovery.js

@@ -12,6 +12,7 @@ function createBrowserOfflineFallbackRecovery({ control, environment = createDef
     let active = false;
     let retrying = false;
     let pullStartY = null;
+    const touchThreshold = pullThreshold === null ? Number.POSITIVE_INFINITY : pullThreshold;
     function retry() {
         if (retrying)
             return;
@@ -23,7 +24,9 @@ function createBrowserOfflineFallbackRecovery({ control, environment = createDef
         }
         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;
         }
@@ -36,7 +39,7 @@ function createBrowserOfflineFallbackRecovery({ control, environment = createDef
         const touchY = getSingleTouchY(event, "changedTouches");
         if (pullStartY !== null &&
             touchY !== null &&
-            touchY - pullStartY >= (pullThreshold ?? Number.POSITIVE_INFINITY)) {
+            touchY - pullStartY >= touchThreshold) {
             retry();
         }
         pullStartY = null;

package/dist-cjs/durableCommandStore.js

@@ -7,24 +7,59 @@ const pendingWrites_1 = require("./pendingWrites");
  * durable command lifecycle. A command becomes visible immediately, but is
  * never sent remotely until IndexedDB has accepted it.
  */
-function createDurableCommandStore({ canCancel = () => true, classifyError = () => "unexpected", createId = createDurableCommandId, execute, initialState, load, now = () => new Date().toISOString(), project, store, }) {
+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 = (0, pendingWrites_1.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) {
@@ -40,32 +75,62 @@ function createDurableCommandStore({ canCancel = () => true, classifyError = ()
         }, 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.", {
@@ -75,6 +140,11 @@ function createDurableCommandStore({ canCancel = () => true, classifyError = ()
     });
     return {
         async cancel(operationId) {
+            if (localStorageFailures.delete(operationId)) {
+                applySnapshot(currentRecords());
+                notify();
+                return true;
+            }
             const record = await store.get(operationId);
             if (!record ||
                 record.syncStatus === "syncing" ||
@@ -89,6 +159,7 @@ function createDurableCommandStore({ canCancel = () => true, classifyError = ()
         close() {
             if (deferredRecoveryTimer)
                 clearTimeout(deferredRecoveryTimer);
+            publishGeneration += 1;
             unsubscribe();
         },
         dispatch(command, options = {}) {
@@ -103,36 +174,20 @@ function createDurableCommandStore({ canCancel = () => true, classifyError = ()
                 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;
             });
@@ -143,9 +198,9 @@ function createDurableCommandStore({ canCancel = () => true, classifyError = ()
             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();
@@ -157,5 +212,15 @@ function createDurableCommandStore({ canCancel = () => true, classifyError = ()
     };
 }
 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-cjs/idbDriver.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineStorageError = void 0;
 exports.createIdbKeyValueDriver = createIdbKeyValueDriver;
 const idb_1 = require("idb");
+class OfflineStorageError extends Error {
+    name = "OfflineStorageError";
+}
+exports.OfflineStorageError = OfflineStorageError;
 function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB = globalThis.indexedDB, operationTimeoutMs, storeName, }) {
     if (!indexedDB) {
         return null;
@@ -12,25 +17,33 @@ function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB
         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();
@@ -39,18 +52,7 @@ function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB
             });
         },
         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({
@@ -71,6 +73,7 @@ function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB
             return runBrowserStorageOperation({
                 fallback: null,
                 operationName: "read key",
+                storeName,
                 operation: async () => {
                     const database = await databasePromise;
                     return (await database.get(storeName, key)) ?? null;
@@ -82,6 +85,7 @@ function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB
             return runBrowserStorageOperation({
                 fallback: [],
                 operationName: "list object store",
+                storeName,
                 operation: async () => {
                     const database = await databasePromise;
                     return database.getAll(storeName);
@@ -93,6 +97,7 @@ function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB
             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
@@ -114,18 +119,7 @@ function createIdbKeyValueDriver({ databaseName, databaseVersion = 1, indexedDB
             });
         },
         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({
@@ -158,18 +152,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);
             }),
@@ -177,6 +180,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 {
@@ -185,12 +193,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;
@@ -206,14 +216,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);
         },
     });
 }
@@ -221,8 +229,10 @@ async function runConditionalStorageOperation({ apply, databasePromise, operatio
     let transaction;
     let cancelled = false;
     return runBrowserStorageOperation({
+        failureMode: "throw",
         fallback: false,
         operationName,
+        storeName,
         timeoutMs,
         cancelOnTimeout() {
             cancelled = true;