@bayonai/offline 0.1.0 → 0.3.0

package/dist-cjs/pendingWrites.js

@@ -6,45 +6,89 @@ exports.createMemoryPendingWriteDriver = createMemoryPendingWriteDriver;
 exports.createBrowserPendingWriteDriver = createBrowserPendingWriteDriver;
 exports.createBrowserPendingWriteStore = createBrowserPendingWriteStore;
 exports.createPendingWriteKey = createPendingWriteKey;
+exports.createPendingWriteSnapshotId = createPendingWriteSnapshotId;
 exports.syncPendingWrite = syncPendingWrite;
+exports.syncPendingWrites = syncPendingWrites;
+exports.runPendingWrite = runPendingWrite;
+exports.summarizePendingWrites = summarizePendingWrites;
 const idbDriver_1 = require("./idbDriver");
 exports.pendingWriteSchemaVersion = 1;
 exports.pendingWriteOperationTimeoutMs = 2_000;
-function createPendingWriteStore(driver, { keyPrefix, normalizePayload, schemaVersion = exports.pendingWriteSchemaVersion, }) {
+function createPendingWriteStore(driver, { keyPrefix, normalizeLegacyRecord, normalizePayload, schemaVersion = exports.pendingWriteSchemaVersion, }) {
+    const listeners = new Set();
+    const notify = (change) => {
+        for (const listener of listeners) {
+            try {
+                listener(change);
+            }
+            catch (error) {
+                console.error("[Bayon offline] Pending-write store listener failed.", {
+                    error,
+                    type: change.type,
+                });
+            }
+        }
+    };
     return {
         async clear(id) {
             await driver.clear(createPendingWriteKey({ id, prefix: keyPrefix }));
+            notify({ id, type: "clear" });
         },
         async clearAll() {
             await driver.clearAll();
+            notify({ type: "clearAll" });
         },
-        async clearIfSavedAt(id, savedAt) {
-            const current = await this.get(id);
-            if (!current || current.savedAt !== savedAt) {
-                return false;
+        async clearIfSnapshotId(id, snapshotId) {
+            const cleared = await driver.clearIf(createPendingWriteKey({ id, prefix: keyPrefix }), (value) => toPendingWriteEnvelope(value, schemaVersion, {
+                normalizeLegacyRecord,
+                normalizePayload,
+            })?.record.snapshotId === snapshotId);
+            if (cleared) {
+                notify({ id, type: "clear" });
             }
-            await this.clear(id);
-            return true;
+            return cleared;
         },
         async close() {
             await driver.close?.();
         },
         async get(id) {
-            return (toPendingWriteEnvelope(await driver.get(createPendingWriteKey({ id, prefix: keyPrefix })), schemaVersion, { normalizePayload })?.record ?? null);
+            return (toPendingWriteEnvelope(await driver.get(createPendingWriteKey({ id, prefix: keyPrefix })), schemaVersion, { normalizeLegacyRecord, normalizePayload })?.record ?? null);
         },
         async list() {
             return (await driver.list())
                 .map((value) => toPendingWriteEnvelope(value, schemaVersion, {
+                normalizeLegacyRecord,
                 normalizePayload,
             })?.record)
                 .filter((record) => Boolean(record))
-                .sort((left, right) => left.savedAt.localeCompare(right.savedAt));
+                .sort((left, right) => left.savedAt.localeCompare(right.savedAt) ||
+                left.id.localeCompare(right.id));
+        },
+        async replaceIfSnapshotId(id, snapshotId, record) {
+            const replaced = await driver.setIf(createPendingWriteKey({ id, prefix: keyPrefix }), { record, schemaVersion }, (value) => toPendingWriteEnvelope(value, schemaVersion, {
+                normalizeLegacyRecord,
+                normalizePayload,
+            })?.record.snapshotId === snapshotId);
+            if (replaced) {
+                notify({ record, type: "replace" });
+            }
+            return replaced;
         },
         async set(record) {
+            const storedRecord = {
+                ...record,
+                snapshotId: record.snapshotId ?? createPendingWriteSnapshotId(),
+            };
             await driver.set(createPendingWriteKey({ id: record.id, prefix: keyPrefix }), {
-                record,
+                record: storedRecord,
                 schemaVersion,
             });
+            notify({ record: storedRecord, type: "set" });
+            return storedRecord;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
         },
     };
 }
@@ -54,6 +98,14 @@ function createMemoryPendingWriteDriver() {
         async clear(key) {
             records.delete(key);
         },
+        async clearIf(key, predicate) {
+            const current = records.get(key) ?? null;
+            if (!predicate(current)) {
+                return false;
+            }
+            records.delete(key);
+            return true;
+        },
         async clearAll() {
             records.clear();
         },
@@ -67,6 +119,13 @@ function createMemoryPendingWriteDriver() {
         async set(key, value) {
             records.set(key, value);
         },
+        async setIf(key, value, predicate) {
+            if (!predicate(records.get(key) ?? null)) {
+                return false;
+            }
+            records.set(key, value);
+            return true;
+        },
     };
 }
 function createBrowserPendingWriteDriver({ databaseName, databaseVersion, indexedDB = globalThis.indexedDB, operationTimeoutMs = exports.pendingWriteOperationTimeoutMs, storeName, }) {
@@ -79,7 +138,7 @@ function createBrowserPendingWriteDriver({ databaseName, databaseVersion, indexe
     });
     return driver ? toPendingWriteDriver(driver) : null;
 }
-function createBrowserPendingWriteStore({ databaseName, databaseVersion, indexedDB = globalThis.indexedDB, keyPrefix, normalizePayload, operationTimeoutMs = exports.pendingWriteOperationTimeoutMs, schemaVersion = exports.pendingWriteSchemaVersion, storeName, }) {
+function createBrowserPendingWriteStore({ databaseName, databaseVersion, indexedDB = globalThis.indexedDB, keyPrefix, normalizeLegacyRecord, normalizePayload, operationTimeoutMs = exports.pendingWriteOperationTimeoutMs, schemaVersion = exports.pendingWriteSchemaVersion, storeName, }) {
     const driver = createBrowserPendingWriteDriver({
         databaseName,
         databaseVersion,
@@ -87,11 +146,14 @@ function createBrowserPendingWriteStore({ databaseName, databaseVersion, indexed
         operationTimeoutMs,
         storeName,
     });
-    return createPendingWriteStore(driver ?? createNoopPendingWriteDriver(), { keyPrefix, normalizePayload, schemaVersion });
+    return createPendingWriteStore(driver ?? createNoopPendingWriteDriver(), { keyPrefix, normalizeLegacyRecord, normalizePayload, schemaVersion });
 }
 function createPendingWriteKey({ id, prefix }) {
     return `${prefix}:${encodeURIComponent(id)}`;
 }
+function createPendingWriteSnapshotId() {
+    return globalThis.crypto.randomUUID();
+}
 async function syncPendingWrite({ id, store, sync, }) {
     const pending = await store.get(id);
     if (!pending) {
@@ -100,7 +162,7 @@ async function syncPendingWrite({ id, store, sync, }) {
     await markPendingSnapshot({
         id,
         nextRecord: { ...pending, error: undefined, syncStatus: "syncing" },
-        savedAt: pending.savedAt,
+        snapshotId: pending.snapshotId,
         store,
     });
     try {
@@ -111,18 +173,100 @@ async function syncPendingWrite({ id, store, sync, }) {
         await markPendingSnapshot({
             id,
             nextRecord: { ...pending, error: message, syncStatus: "failed" },
-            savedAt: pending.savedAt,
+            snapshotId: pending.snapshotId,
             store,
         });
         return { error: message, status: "failed" };
     }
-    return (await store.clearIfSavedAt(id, pending.savedAt))
+    return (await store.clearIfSnapshotId(id, pending.snapshotId))
         ? { status: "synced" }
         : { status: "superseded" };
 }
+/**
+ * Replays selected writes oldest first and coalesces overlapping runs for the
+ * same store/scope. Callers own the selection predicate and idempotent remote
+ * mutation semantics.
+ */
+function syncPendingWrites({ scopeKey = "all", select = () => true, store, sync, }) {
+    let inFlightByScope = pendingWriteSyncs.get(store);
+    if (!inFlightByScope) {
+        inFlightByScope = new Map();
+        pendingWriteSyncs.set(store, inFlightByScope);
+    }
+    const existing = inFlightByScope.get(scopeKey);
+    if (existing) {
+        return existing;
+    }
+    const syncRun = performPendingWriteSync({ select, store, sync });
+    inFlightByScope.set(scopeKey, syncRun);
+    const clearInFlight = () => {
+        inFlightByScope.delete(scopeKey);
+    };
+    void syncRun.then(clearInFlight, clearInFlight);
+    return syncRun;
+}
+/**
+ * Attempts a remote write now and persists a caller-created durable fallback
+ * only when offline or when the supplied retry classifier accepts the error.
+ */
+async function runPendingWrite({ enqueue, isOnline, shouldQueue, write, }) {
+    if (!isOnline()) {
+        return { queued: await enqueue(), status: "queued" };
+    }
+    try {
+        return { result: await write(), status: "synced" };
+    }
+    catch (error) {
+        if (!shouldQueue(error)) {
+            throw error;
+        }
+        return { queued: await enqueue(), status: "queued" };
+    }
+}
+function summarizePendingWrites(records) {
+    return records.reduce((summary, record) => {
+        summary.totalCount += 1;
+        if (record.syncStatus === "failed") {
+            summary.failedCount += 1;
+        }
+        else if (record.syncStatus === "syncing") {
+            summary.syncingCount += 1;
+        }
+        else {
+            summary.pendingCount += 1;
+        }
+        return summary;
+    }, { failedCount: 0, pendingCount: 0, syncingCount: 0, totalCount: 0 });
+}
+const pendingWriteSyncs = new WeakMap();
+async function performPendingWriteSync({ select, store, sync, }) {
+    const summary = {
+        attempted: 0,
+        failed: 0,
+        idle: 0,
+        remaining: 0,
+        superseded: 0,
+        synced: 0,
+    };
+    const records = (await store.list()).filter(select);
+    for (const record of records) {
+        const result = await syncPendingWrite({
+            id: record.id,
+            store,
+            sync,
+        });
+        summary.attempted += 1;
+        summary[result.status] += 1;
+    }
+    summary.remaining = (await store.list()).filter(select).length;
+    return summary;
+}
 function createNoopPendingWriteDriver() {
     return {
         async clear() { },
+        async clearIf() {
+            return false;
+        },
         async clearAll() { },
         async close() { },
         async get() {
@@ -132,43 +276,41 @@ function createNoopPendingWriteDriver() {
             return [];
         },
         async set() { },
+        async setIf() {
+            return false;
+        },
     };
 }
 function toPendingWriteDriver(driver) {
     return {
         clear: driver.delete,
+        clearIf: driver.deleteIf,
         clearAll: driver.clear,
         close: driver.close,
         get: driver.get,
         list: driver.list,
         set: driver.set,
+        setIf: driver.setIf,
     };
 }
-async function markPendingSnapshot({ id, nextRecord, savedAt, store, }) {
-    const current = await store.get(id);
-    if (current?.savedAt !== savedAt) {
-        return false;
-    }
-    await store.set(nextRecord);
-    return true;
+async function markPendingSnapshot({ id, nextRecord, snapshotId, store, }) {
+    return store.replaceIfSnapshotId(id, snapshotId, nextRecord);
 }
-function toPendingWriteEnvelope(value, schemaVersion, { normalizePayload }) {
-    if (!value ||
-        typeof value !== "object" ||
-        !("schemaVersion" in value) ||
-        value.schemaVersion !== schemaVersion ||
-        !("record" in value) ||
-        !isPendingWriteRecord(value.record)) {
-        return null;
-    }
-    const record = normalizePendingWriteRecord(value.record, normalizePayload);
+function toPendingWriteEnvelope(value, schemaVersion, { normalizeLegacyRecord, normalizePayload }) {
+    const envelopeRecord = readPendingWriteEnvelopeRecord(value, schemaVersion);
+    const legacyRecord = envelopeRecord
+        ? null
+        : (normalizeLegacyRecord?.(value) ?? null);
+    const record = normalizePendingWriteRecord(envelopeRecord ?? legacyRecord, normalizePayload);
     return record ? { record, schemaVersion } : null;
 }
 function normalizePendingWriteRecord(record, normalizePayload) {
-    if (!normalizePayload) {
-        return record;
+    if (!record) {
+        return null;
     }
-    const payload = normalizePayload(record.payload);
+    const payload = normalizePayload
+        ? normalizePayload(record.payload)
+        : record.payload;
     if (payload === null) {
         return null;
     }
@@ -177,9 +319,24 @@ function normalizePendingWriteRecord(record, normalizePayload) {
         id: record.id,
         payload,
         savedAt: record.savedAt,
+        snapshotId: record.snapshotId ?? createLegacyPendingWriteSnapshotId(record),
         syncStatus: record.syncStatus,
     };
 }
+function readPendingWriteEnvelopeRecord(value, schemaVersion) {
+    if (!value ||
+        typeof value !== "object" ||
+        !("schemaVersion" in value) ||
+        value.schemaVersion !== schemaVersion ||
+        !("record" in value) ||
+        !isPendingWriteRecord(value.record)) {
+        return null;
+    }
+    return value.record;
+}
+function createLegacyPendingWriteSnapshotId(record) {
+    return `legacy:${encodeURIComponent(record.id)}:${encodeURIComponent(record.savedAt)}`;
+}
 function isPendingWriteRecord(value) {
     return (value !== null &&
         typeof value === "object" &&
@@ -187,6 +344,7 @@ function isPendingWriteRecord(value) {
         typeof value.id === "string" &&
         "savedAt" in value &&
         typeof value.savedAt === "string" &&
+        (!("snapshotId" in value) || typeof value.snapshotId === "string") &&
         "syncStatus" in value &&
         (value.syncStatus === "pending" ||
             value.syncStatus === "syncing" ||

package/dist-cjs/readCache.js

@@ -1,25 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.browserReadCacheOperationTimeoutMs = exports.readCacheFreshnessMaxAgeMs = exports.readCacheSchemaVersion = void 0;
+exports.browserReadCacheOperationTimeoutMs = exports.identityReadCacheFreshnessMaxAgeMs = exports.durableReadCacheFreshnessMaxAgeMs = exports.readCacheFreshnessMaxAgeMs = exports.readCacheSchemaVersion = void 0;
 exports.createReadCache = createReadCache;
 exports.createMemoryReadCacheDriver = createMemoryReadCacheDriver;
 exports.createBrowserReadCache = createBrowserReadCache;
+exports.pruneReadCache = pruneReadCache;
 exports.createReadCacheKey = createReadCacheKey;
 exports.readThroughCache = readThroughCache;
 exports.loadReadCacheResource = loadReadCacheResource;
 const idbDriver_1 = require("./idbDriver");
 exports.readCacheSchemaVersion = 1;
 exports.readCacheFreshnessMaxAgeMs = 30_000;
+exports.durableReadCacheFreshnessMaxAgeMs = 60 * 60_000;
+exports.identityReadCacheFreshnessMaxAgeMs = 24 * 60 * 60_000;
 exports.browserReadCacheOperationTimeoutMs = 2_000;
-const pendingFreshLoads = new Map();
+const pendingFreshLoads = new WeakMap();
+const cachePruners = new WeakMap();
 function createReadCache(driver) {
-    return {
+    let globalVersion = 0;
+    const keyVersions = new Map();
+    let operationQueue = Promise.resolve();
+    const pendingLoads = new Map();
+    function getVersion(key) {
+        return `${globalVersion}:${keyVersions.get(key) ?? 0}`;
+    }
+    function enqueue(operation) {
+        const next = operationQueue.then(operation, operation);
+        operationQueue = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    const cache = {
         async clear() {
-            pendingFreshLoads.clear();
-            await driver.clear();
+            pendingLoads.clear();
+            globalVersion += 1;
+            keyVersions.clear();
+            await enqueue(() => driver.clear());
         },
         async close() {
-            await driver.close?.();
+            await enqueue(async () => driver.close?.());
+        },
+        async delete(key) {
+            pendingLoads.delete(key);
+            keyVersions.set(key, (keyVersions.get(key) ?? 0) + 1);
+            await enqueue(() => driver.delete(key));
         },
         async get(key) {
             const envelope = toReadCacheEnvelope(await driver.get(key));
@@ -31,14 +54,48 @@ function createReadCache(driver) {
                 }
                 : null;
         },
+        getVersion,
         async set(key, value) {
-            await driver.set(key, {
+            await enqueue(() => driver.set(key, {
                 savedAt: new Date().toISOString(),
                 schemaVersion: exports.readCacheSchemaVersion,
                 value,
+            }));
+        },
+        async setIfVersion(key, value, version) {
+            if (getVersion(key) !== version) {
+                return false;
+            }
+            return enqueue(async () => {
+                if (getVersion(key) !== version) {
+                    return false;
+                }
+                await driver.set(key, {
+                    savedAt: new Date().toISOString(),
+                    schemaVersion: exports.readCacheSchemaVersion,
+                    value,
+                });
+                return true;
             });
         },
     };
+    pendingFreshLoads.set(cache, pendingLoads);
+    cachePruners.set(cache, async ({ maxAgeMs, now }) => {
+        if (!driver.listEntries || maxAgeMs < 0) {
+            return 0;
+        }
+        const cutoff = now() - maxAgeMs;
+        const expiredKeys = (await driver.listEntries())
+            .filter(({ value }) => {
+            const envelope = toReadCacheEnvelope(value);
+            const savedAt = envelope ? Date.parse(envelope.savedAt) : Number.NaN;
+            return Number.isFinite(savedAt) && savedAt < cutoff;
+        })
+            .map(({ key }) => key);
+        await Promise.all(expiredKeys.map((key) => cache.delete(key)));
+        return expiredKeys.length;
+    });
+    return cache;
 }
 function createMemoryReadCacheDriver() {
     const records = new Map();
@@ -47,9 +104,15 @@ function createMemoryReadCacheDriver() {
             records.clear();
         },
         async close() { },
+        async delete(key) {
+            records.delete(key);
+        },
         async get(key) {
             return records.get(key) ?? null;
         },
+        async listEntries() {
+            return [...records.entries()].map(([key, value]) => ({ key, value }));
+        },
         async set(key, value) {
             records.set(key, value);
         },
@@ -63,7 +126,25 @@ function createBrowserReadCache({ databaseName, databaseVersion, indexedDB = glo
         operationTimeoutMs,
         storeName,
     });
-    return createReadCache(driver ?? createNoopReadCacheDriver());
+    return createReadCache(driver
+        ? {
+            clear: driver.clear,
+            close: driver.close,
+            delete: driver.delete,
+            get: driver.get,
+            listEntries: driver.listEntries,
+            set: driver.set,
+        }
+        : createNoopReadCacheDriver());
+}
+/**
+ * Deletes only valid read-cache envelopes older than the supplied age. It is
+ * opt-in and returns zero for custom cache adapters that cannot enumerate keys.
+ */
+function pruneReadCache({ cache, maxAgeMs, now = () => Date.now(), }) {
+    const resourceCache = cache.capture?.() ?? cache;
+    return cachePruners.get(resourceCache)?.({ maxAgeMs, now }) ??
+        Promise.resolve(0);
 }
 function createReadCacheKey({ namespace, params = {}, prefix, scope, }) {
     const serializedParams = Object.entries(params)
@@ -80,11 +161,26 @@ function createReadCacheKey({ namespace, params = {}, prefix, scope, }) {
         .filter(Boolean)
         .join(":");
 }
-async function readThroughCache({ cache, key, loadFresh, }) {
-    const cached = await cache.get(key);
+async function readThroughCache({ cache, forceFresh = false, key, loadFresh, maxAgeMs, }) {
+    const resourceCache = cache.capture?.() ?? cache;
+    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);
+    }
+    const version = resourceCache.getVersion(key);
+    const cached = await resourceCache.get(key);
+    if (cached && isCacheFresh(cached.savedAt, maxAgeMs)) {
+        return {
+            data: cached.value,
+            error: null,
+            fromCache: true,
+            stale: false,
+        };
+    }
     try {
-        const fresh = await loadFresh();
-        await cache.set(key, fresh);
+        const fresh = await loadSharedFreshResource(resourceCache, key, loadFresh);
+        await resourceCache.setIfVersion(key, fresh, version);
         return {
             data: fresh,
             error: null,
@@ -104,8 +200,10 @@ async function readThroughCache({ cache, key, loadFresh, }) {
         throw error;
     }
 }
-async function loadReadCacheResource({ cache, key, loadFresh, maxAgeMs, onUpdate, }) {
-    const cached = await cache.get(key);
+async function loadReadCacheResource({ cache, key, loadFresh, maxAgeMs, onCacheWriteError, onUpdate, skipCache = false, }) {
+    const resourceCache = cache.capture?.() ?? cache;
+    const version = resourceCache.getVersion(key);
+    const cached = skipCache ? null : await resourceCache.get(key);
     if (cached) {
         onUpdate({ data: cached.value, fromCache: true });
         if (isCacheFresh(cached.savedAt, maxAgeMs)) {
@@ -113,9 +211,16 @@ async function loadReadCacheResource({ cache, key, loadFresh, maxAgeMs, onUpdate
         }
     }
     try {
-        const fresh = await loadSharedFreshResource(key, loadFresh);
+        const fresh = await loadSharedFreshResource(resourceCache, key, loadFresh);
         onUpdate({ data: fresh, fromCache: false });
-        void cache.set(key, fresh).catch(() => undefined);
+        void resourceCache.setIfVersion(key, fresh, version).catch((error) => {
+            const normalizedError = normalizeError(error);
+            console.error("[Bayon offline] Unable to refresh the read cache.", {
+                error: normalizedError,
+                key,
+            });
+            onCacheWriteError?.(normalizedError);
+        });
         return fresh;
     }
     catch (error) {
@@ -134,9 +239,13 @@ function createNoopReadCacheDriver() {
     return {
         async clear() { },
         async close() { },
+        async delete() { },
         async get() {
             return null;
         },
+        async listEntries() {
+            return [];
+        },
         async set() { },
     };
 }
@@ -147,22 +256,32 @@ function isCacheFresh(savedAt, maxAgeMs) {
     const savedTime = Date.parse(savedAt);
     return Number.isFinite(savedTime) && Date.now() - savedTime <= maxAgeMs;
 }
-async function loadSharedFreshResource(key, loadFresh) {
-    const pendingLoad = pendingFreshLoads.get(key);
+async function loadSharedFreshResource(cache, key, loadFresh) {
+    const pendingLoads = getPendingFreshLoads(cache);
+    const pendingLoad = pendingLoads.get(key);
     if (pendingLoad) {
         return (await pendingLoad);
     }
     const nextLoad = loadFresh();
-    pendingFreshLoads.set(key, nextLoad);
+    pendingLoads.set(key, nextLoad);
     try {
         return await nextLoad;
     }
     finally {
-        if (pendingFreshLoads.get(key) === nextLoad) {
-            pendingFreshLoads.delete(key);
+        if (pendingLoads.get(key) === nextLoad) {
+            pendingLoads.delete(key);
         }
     }
 }
+function getPendingFreshLoads(cache) {
+    const existing = pendingFreshLoads.get(cache);
+    if (existing) {
+        return existing;
+    }
+    const next = new Map();
+    pendingFreshLoads.set(cache, next);
+    return next;
+}
 function toReadCacheEnvelope(value) {
     if (!value || typeof value !== "object") {
         return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bayonai/offline",
-  "version": "0.1.0",
-  "description": "Reusable offline read-cache and pending-write primitives.",
+  "version": "0.3.0",
+  "description": "Reusable offline read-cache, pending-write, and silent recovery primitives.",
   "license": "MIT",
   "author": "Bayon AI",
   "homepage": "https://github.com/toledoroy/bounded/tree/main/packages/offline#readme",
@@ -46,8 +46,10 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/write-esm-extensions.mjs && tsc -p tsconfig.cjs.json && node scripts/write-cjs.mjs",
     "lint": "tsc --noEmit -p tsconfig.json",
-    "prepack": "pnpm run build",
-    "test": "vitest run"
+    "pack:smoke": "corepack pnpm run build && npm pack --dry-run --access public",
+    "prepack": "corepack pnpm run build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "idb": "^8.0.3"