@bayonai/offline 0.7.0 → 0.9.0

package/dist-cjs/pendingWrites.js

@@ -31,6 +31,29 @@ function createPendingWriteStore(driver, { keyPrefix, normalizeLegacyRecord, nor
             }
         }
     };
+    async function listScopedRecords() {
+        const readOptions = { normalizeLegacyRecord, normalizePayload };
+        const entries = await driver.listEntries?.();
+        if (entries) {
+            const keyPrefixBoundary = `${keyPrefix}:`;
+            return entries
+                .filter(({ key }) => key.startsWith(keyPrefixBoundary))
+                .map(({ value }) => toPendingWriteEnvelope(value, schemaVersion, readOptions)
+                ?.record)
+                .filter((record) => Boolean(record));
+        }
+        // Compatibility path for custom drivers created before listEntries was
+        // available. Point reads prove that each candidate belongs to this prefix.
+        const candidateIds = new Set((await driver.list())
+            .map((value) => toPendingWriteEnvelope(value, schemaVersion, readOptions)
+            ?.record.id)
+            .filter((id) => Boolean(id)));
+        const records = await Promise.all([...candidateIds].map(async (id) => {
+            const value = await driver.get(createPendingWriteKey({ id, prefix: keyPrefix }));
+            return toPendingWriteEnvelope(value, schemaVersion, readOptions)?.record;
+        }));
+        return records.filter((record) => Boolean(record));
+    }
     return {
         async claimIfSnapshotId(id, snapshotId, record, now) {
             const claimed = await driver.setIf(createPendingWriteKey({ id, prefix: keyPrefix }), { record, schemaVersion }, (value) => {
@@ -51,7 +74,20 @@ function createPendingWriteStore(driver, { keyPrefix, normalizeLegacyRecord, nor
             notify({ id, type: "clear" });
         },
         async clearAll() {
-            await driver.clearAll();
+            const entries = await driver.listEntries?.();
+            if (entries) {
+                const keyPrefixBoundary = `${keyPrefix}:`;
+                await Promise.all(entries
+                    .filter(({ key }) => key.startsWith(keyPrefixBoundary))
+                    .map(({ key }) => driver.clear(key)));
+            }
+            else {
+                const records = await listScopedRecords();
+                await Promise.all(records.map((record) => driver.clearIf(createPendingWriteKey({ id: record.id, prefix: keyPrefix }), (value) => toPendingWriteEnvelope(value, schemaVersion, {
+                    normalizeLegacyRecord,
+                    normalizePayload,
+                })?.record.snapshotId === record.snapshotId)));
+            }
             notify({ type: "clearAll" });
         },
         async clearIfSnapshotId(id, snapshotId) {
@@ -71,13 +107,7 @@ function createPendingWriteStore(driver, { keyPrefix, normalizeLegacyRecord, nor
             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) ||
+            return (await listScopedRecords()).sort((left, right) => left.savedAt.localeCompare(right.savedAt) ||
                 left.id.localeCompare(right.id));
         },
         async replaceIfSnapshotId(id, snapshotId, record) {
@@ -132,6 +162,9 @@ function createMemoryPendingWriteDriver() {
         async list() {
             return [...records.values()];
         },
+        async listEntries() {
+            return [...records].map(([key, value]) => ({ key, value }));
+        },
         async set(key, value) {
             records.set(key, value);
         },
@@ -162,14 +195,24 @@ function createBrowserPendingWriteStore({ databaseName, databaseVersion, indexed
         operationTimeoutMs,
         storeName,
     });
-    return createPendingWriteStore(driver ?? createNoopPendingWriteDriver(), { keyPrefix, normalizeLegacyRecord, normalizePayload, schemaVersion });
+    return createPendingWriteStore(driver ?? createUnavailablePendingWriteDriver(), { keyPrefix, normalizeLegacyRecord, normalizePayload, schemaVersion });
 }
 function createPendingWriteKey({ id, prefix }) {
     return `${prefix}:${encodeURIComponent(id)}`;
 }
 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;
 async function syncPendingWrite({ id, now = () => new Date().toISOString(), store, sync, }) {
     const pending = await store.get(id);
     if (!pending) {
@@ -177,8 +220,7 @@ async function syncPendingWrite({ id, now = () => new Date().toISOString(), stor
     }
     // 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();
@@ -193,7 +235,7 @@ async function syncPendingWrite({ id, now = () => new Date().toISOString(), stor
         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.";
@@ -222,7 +264,7 @@ async function syncPendingWrite({ id, now = () => new Date().toISOString(), stor
  * same store/scope. Callers own the selection predicate and idempotent remote
  * mutation semantics.
  */
-function syncPendingWrites({ scopeKey = "all", select = () => true, stopOnFailure = false, store, sync, }) {
+function syncPendingWrites({ now, scopeKey = "all", select = () => true, stopOnFailure = false, store, sync, }) {
     let inFlightByScope = pendingWriteSyncs.get(store);
     if (!inFlightByScope) {
         inFlightByScope = new Map();
@@ -233,6 +275,7 @@ function syncPendingWrites({ scopeKey = "all", select = () => true, stopOnFailur
         return existing;
     }
     const syncRun = performPendingWriteSync({
+        now,
         select,
         stopOnFailure,
         store,
@@ -279,7 +322,7 @@ 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,
@@ -292,6 +335,7 @@ async function performPendingWriteSync({ select, stopOnFailure, store, sync, })
     for (const record of records) {
         const result = await syncPendingWrite({
             id: record.id,
+            now,
             store,
             sync,
         });
@@ -327,7 +371,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.
  */
-function createOrderedPendingWriteExecutor({ scopeKey = "all", select = () => true, store, sync, }) {
+function createOrderedPendingWriteExecutor({ now, scopeKey = "all", select = () => true, store, sync, }) {
     let execution = Promise.resolve();
     function inOrder(operation) {
         const result = execution.then(operation, operation);
@@ -336,6 +380,7 @@ function createOrderedPendingWriteExecutor({ scopeKey = "all", select = () => tr
     }
     function recover() {
         return inOrder(() => syncPendingWrites({
+            now,
             scopeKey,
             select,
             stopOnFailure: true,
@@ -351,6 +396,7 @@ function createOrderedPendingWriteExecutor({ scopeKey = "all", select = () => tr
                     return runPendingWrite(options);
                 }
                 const replay = await syncPendingWrites({
+                    now,
                     scopeKey,
                     select,
                     stopOnFailure: true,
@@ -368,13 +414,13 @@ function createOrderedPendingWriteExecutor({ scopeKey = "all", select = () => tr
         },
     };
 }
-function createNoopPendingWriteDriver() {
+function createUnavailablePendingWriteDriver() {
+    const unavailable = () => new idbDriver_1.OfflineStorageError("IndexedDB is unavailable; the pending write was not stored.");
     return {
         async clear() { },
         async clearIf() {
             return false;
         },
-        async clearAll() { },
         async close() { },
         async get() {
             return null;
@@ -382,9 +428,11 @@ function createNoopPendingWriteDriver() {
         async list() {
             return [];
         },
-        async set() { },
+        async set() {
+            throw unavailable();
+        },
         async setIf() {
-            return false;
+            throw unavailable();
         },
     };
 }
@@ -396,6 +444,7 @@ function toPendingWriteDriver(driver) {
         close: driver.close,
         get: driver.get,
         list: driver.list,
+        listEntries: driver.listEntries,
         set: driver.set,
         setIf: driver.setIf,
     };

package/dist-cjs/readCache.d.ts

@@ -0,0 +1,112 @@
+import { type BrowserKeyValueDriverOptions } from "./idbDriver.js";
+export declare const readCacheSchemaVersion = 1;
+export declare const readCacheFreshnessMaxAgeMs = 30000;
+export declare const durableReadCacheFreshnessMaxAgeMs: number;
+export declare const identityReadCacheFreshnessMaxAgeMs: number;
+export declare const browserReadCacheOperationTimeoutMs = 1000;
+export type ReadCacheHit<T> = {
+    fromCache: true;
+    savedAt: string;
+    value: T;
+};
+export type ReadCacheDriver = {
+    clear: () => Promise<void>;
+    close?: () => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    get: (key: string) => Promise<unknown | null>;
+    listEntries?: () => Promise<Array<{
+        key: string;
+        value: unknown;
+    }>>;
+    set: (key: string, value: unknown) => Promise<void>;
+};
+export type ReadCache = {
+    /**
+     * Resolves a stable cache for the duration of a resource load. Dynamic
+     * adapters use this to pin the active account before asynchronous work.
+     */
+    capture?: () => ReadCache;
+    clear: () => Promise<void>;
+    close: () => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    /** Advances a key's generation without deleting its retained value. */
+    invalidate?: (key: string) => void;
+    get: <T>(key: string) => Promise<ReadCacheHit<T> | null>;
+    getVersion: (key: string) => string;
+    set: <T>(key: string, value: T) => Promise<void>;
+    setIfVersion: <T>(key: string, value: T, version: string) => Promise<boolean>;
+};
+export type ReadCachePolicy = {
+    /** Time that a cached value can suppress a remote read. */
+    freshForMs: number;
+    /** Maximum age at which cached data remains eligible as an offline fallback. */
+    retainForMs: number;
+    /** Behavior when revalidation fails while retained data is available. */
+    refreshFailure: "use-retained" | "throw";
+};
+export type ReadCacheStatus = "fresh" | "stale" | "miss";
+/** Payload-free cache lifecycle events suitable for host-owned telemetry. */
+export type ReadCacheOutcome = "fresh-hit" | "stale-hit" | "cache-miss" | "forced-refresh" | "loader-success" | "loader-failure";
+export type ReadThroughCacheResult<T> = {
+    data: T;
+    error: Error | null;
+    fromCache: boolean;
+    stale: boolean;
+    status: ReadCacheStatus;
+};
+export type ReadCacheResourceUpdate<T> = {
+    data: T;
+    error?: Error;
+    fromCache: boolean;
+    status: ReadCacheStatus;
+};
+export type BrowserReadCacheOptions = Partial<Pick<BrowserKeyValueDriverOptions, "databaseVersion" | "indexedDB">> & {
+    databaseName: string;
+    operationTimeoutMs?: number;
+    storeName: string;
+};
+export type ReadCacheKeyOptions = {
+    namespace: string;
+    params?: Record<string, string | number | boolean | null | undefined>;
+    prefix: string;
+    scope: string;
+};
+export declare function createReadCache(driver: ReadCacheDriver): ReadCache;
+export declare function createMemoryReadCacheDriver(): ReadCacheDriver;
+export declare function createBrowserReadCache({ databaseName, databaseVersion, indexedDB, operationTimeoutMs, storeName, }: BrowserReadCacheOptions): ReadCache;
+/**
+ * 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.
+ */
+export declare function pruneReadCache({ cache, maxAgeMs, now, }: {
+    cache: ReadCache;
+    maxAgeMs: number;
+    now?: () => number;
+}): Promise<number>;
+export declare function createReadCacheKey({ namespace, params, prefix, scope, }: ReadCacheKeyOptions): string;
+export declare function readThroughCache<T>({ cache, forceFresh, key, loadFresh, maxAgeMs, onOutcome, policy, }: {
+    cache: ReadCache;
+    /**
+     * Revalidates after advancing the key generation, retaining the prior value
+     * as a possible fallback if refresh fails.
+     */
+    forceFresh?: boolean;
+    key: string;
+    loadFresh: () => Promise<T>;
+    maxAgeMs?: number;
+    onOutcome?: (outcome: ReadCacheOutcome) => void;
+    policy?: ReadCachePolicy;
+}): Promise<ReadThroughCacheResult<T>>;
+export declare function loadReadCacheResource<T>({ cache, forceFresh, key, loadFresh, maxAgeMs, onOutcome, policy, onCacheWriteError, onUpdate, skipCache, }: {
+    cache: ReadCache;
+    /** Revalidate while retaining eligible data as fallback on loader failure. */
+    forceFresh?: boolean;
+    key: string;
+    loadFresh: () => Promise<T>;
+    maxAgeMs?: number;
+    onOutcome?: (outcome: ReadCacheOutcome) => void;
+    policy?: ReadCachePolicy;
+    onCacheWriteError?: (error: Error) => void;
+    onUpdate: (update: ReadCacheResourceUpdate<T>) => void;
+    skipCache?: boolean;
+}): Promise<T>;

package/dist-cjs/readCache.js

@@ -13,7 +13,9 @@ exports.readCacheSchemaVersion = 1;
 exports.readCacheFreshnessMaxAgeMs = 30_000;
 exports.durableReadCacheFreshnessMaxAgeMs = 60 * 60_000;
 exports.identityReadCacheFreshnessMaxAgeMs = 24 * 60 * 60_000;
-exports.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.
+exports.browserReadCacheOperationTimeoutMs = 1_000;
 const pendingFreshLoads = new WeakMap();
 const cachePruners = new WeakMap();
 function createReadCache(driver) {
@@ -24,6 +26,10 @@ function createReadCache(driver) {
     function getVersion(key) {
         return `${globalVersion}:${keyVersions.get(key) ?? 0}`;
     }
+    function invalidate(key) {
+        pendingLoads.delete(key);
+        keyVersions.set(key, (keyVersions.get(key) ?? 0) + 1);
+    }
     function enqueue(operation) {
         const next = operationQueue.then(operation, operation);
         operationQueue = next.then(() => undefined, () => undefined);
@@ -40,10 +46,10 @@ function createReadCache(driver) {
             await enqueue(async () => driver.close?.());
         },
         async delete(key) {
-            pendingLoads.delete(key);
-            keyVersions.set(key, (keyVersions.get(key) ?? 0) + 1);
+            invalidate(key);
             await enqueue(() => driver.delete(key));
         },
+        invalidate,
         async get(key) {
             const envelope = toReadCacheEnvelope(await driver.get(key));
             return envelope
@@ -143,8 +149,7 @@ function createBrowserReadCache({ databaseName, databaseVersion, indexedDB = glo
  */
 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));
 }
 function createReadCacheKey({ namespace, params = {}, prefix, scope, }) {
     const serializedParams = Object.entries(params)
@@ -161,58 +166,128 @@ function createReadCacheKey({ namespace, params = {}, prefix, scope, }) {
         .filter(Boolean)
         .join(":");
 }
-async function readThroughCache({ cache, forceFresh = false, key, loadFresh, maxAgeMs, }) {
+async function readThroughCache({ cache, forceFresh = false, key, loadFresh, maxAgeMs, onOutcome, policy, }) {
     const resourceCache = cache.capture?.() ?? cache;
+    const resolvedPolicy = resolvePolicy(policy, maxAgeMs);
+    const forcedFallback = forceFresh ? await resourceCache.get(key) : null;
     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);
+        reportReadCacheOutcome(onOutcome, "forced-refresh");
+        // Built-in caches advance generation without deleting fallback data.
+        // Legacy custom adapters retain their old delete behavior.
+        try {
+            if (resourceCache.invalidate) {
+                resourceCache.invalidate(key);
+            }
+            else {
+                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);
-    if (cached && isCacheFresh(cached.savedAt, maxAgeMs)) {
+    const cached = forcedFallback ?? (await resourceCache.get(key));
+    const retained = cached && isCacheRetained(cached.savedAt, resolvedPolicy);
+    if (!forceFresh && retained && isCacheFresh(cached.savedAt, resolvedPolicy)) {
+        reportReadCacheOutcome(onOutcome, "fresh-hit");
         return {
             data: cached.value,
             error: null,
             fromCache: true,
             stale: false,
+            status: "fresh",
         };
     }
+    reportReadCacheOutcome(onOutcome, retained ? "stale-hit" : "cache-miss");
     try {
         const fresh = await loadSharedFreshResource(resourceCache, key, loadFresh);
-        await resourceCache.setIfVersion(key, fresh, version);
+        reportReadCacheOutcome(onOutcome, "loader-success");
+        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,
             fromCache: false,
             stale: false,
+            status: retained ? "fresh" : "miss",
         };
     }
     catch (error) {
-        if (cached) {
+        reportReadCacheOutcome(onOutcome, "loader-failure");
+        if (retained && resolvedPolicy.refreshFailure === "use-retained") {
             return {
                 data: cached.value,
                 error: normalizeError(error),
                 fromCache: true,
                 stale: true,
+                status: "stale",
             };
         }
         throw error;
     }
 }
-async function loadReadCacheResource({ cache, key, loadFresh, maxAgeMs, onCacheWriteError, onUpdate, skipCache = false, }) {
+async function loadReadCacheResource({ cache, forceFresh = false, key, loadFresh, maxAgeMs, onOutcome, policy, onCacheWriteError, onUpdate, skipCache = false, }) {
     const resourceCache = cache.capture?.() ?? cache;
+    const resolvedPolicy = resolvePolicy(policy, maxAgeMs);
+    const forcedFallback = forceFresh ? await resourceCache.get(key) : null;
+    if (forceFresh) {
+        reportReadCacheOutcome(onOutcome, "forced-refresh");
+        try {
+            if (resourceCache.invalidate) {
+                resourceCache.invalidate(key);
+            }
+            else {
+                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 = skipCache ? null : await resourceCache.get(key);
-    if (cached) {
-        onUpdate({ data: cached.value, fromCache: true });
-        if (isCacheFresh(cached.savedAt, maxAgeMs)) {
+    const cached = skipCache
+        ? null
+        : (forcedFallback ?? (await resourceCache.get(key)));
+    const retained = cached && isCacheRetained(cached.savedAt, resolvedPolicy);
+    if (retained) {
+        const fresh = isCacheFresh(cached.savedAt, resolvedPolicy);
+        reportReadCacheOutcome(onOutcome, fresh && !forceFresh ? "fresh-hit" : "stale-hit");
+        onUpdate({
+            data: cached.value,
+            fromCache: true,
+            status: fresh && !forceFresh ? "fresh" : "stale",
+        });
+        if (fresh && !forceFresh) {
             return cached.value;
         }
     }
+    else {
+        reportReadCacheOutcome(onOutcome, "cache-miss");
+    }
     try {
         const fresh = await loadSharedFreshResource(resourceCache, key, loadFresh);
-        onUpdate({ data: fresh, fromCache: false });
+        reportReadCacheOutcome(onOutcome, "loader-success");
+        if (resourceCache.getVersion(key) === version) {
+            onUpdate({
+                data: fresh,
+                fromCache: false,
+                status: retained ? "fresh" : "miss",
+            });
+        }
         void resourceCache.setIfVersion(key, fresh, version).catch((error) => {
             const normalizedError = normalizeError(error);
             console.error("[Bayon offline] Unable to refresh the read cache.", {
@@ -224,17 +299,32 @@ async function loadReadCacheResource({ cache, key, loadFresh, maxAgeMs, onCacheW
         return fresh;
     }
     catch (error) {
-        if (!cached) {
+        reportReadCacheOutcome(onOutcome, "loader-failure");
+        if (!retained || resolvedPolicy.refreshFailure === "throw") {
             throw error;
         }
         onUpdate({
             data: cached.value,
             error: normalizeError(error),
             fromCache: true,
+            status: "stale",
         });
         return cached.value;
     }
 }
+function reportReadCacheOutcome(onOutcome, outcome) {
+    if (!onOutcome)
+        return;
+    try {
+        onOutcome(outcome);
+    }
+    catch (error) {
+        console.error("[Bayon offline] Read-cache outcome callback failed.", {
+            error: normalizeError(error),
+            outcome,
+        });
+    }
+}
 function createNoopReadCacheDriver() {
     return {
         async clear() { },
@@ -249,12 +339,33 @@ function createNoopReadCacheDriver() {
         async set() { },
     };
 }
-function isCacheFresh(savedAt, maxAgeMs) {
-    if (!maxAgeMs || maxAgeMs <= 0) {
+function isCacheFresh(savedAt, policy) {
+    if (policy.freshForMs <= 0) {
         return false;
     }
     const savedTime = Date.parse(savedAt);
-    return Number.isFinite(savedTime) && Date.now() - savedTime <= maxAgeMs;
+    return (Number.isFinite(savedTime) && Date.now() - savedTime <= policy.freshForMs);
+}
+function resolvePolicy(policy, maxAgeMs) {
+    if (policy) {
+        if (!Number.isFinite(policy.freshForMs) ||
+            policy.freshForMs < 0 ||
+            !Number.isFinite(policy.retainForMs) ||
+            policy.retainForMs < policy.freshForMs ||
+            !["use-retained", "throw"].includes(policy.refreshFailure)) {
+            throw new RangeError("[Bayon offline] Invalid read-cache policy: require finite non-negative durations, retainForMs >= freshForMs, and a supported refreshFailure mode.");
+        }
+        return policy;
+    }
+    return {
+        freshForMs: maxAgeMs ?? 0,
+        retainForMs: Number.POSITIVE_INFINITY,
+        refreshFailure: "use-retained",
+    };
+}
+function isCacheRetained(savedAt, policy) {
+    const savedTime = Date.parse(savedAt);
+    return (Number.isFinite(savedTime) && Date.now() - savedTime <= policy.retainForMs);
 }
 async function loadSharedFreshResource(cache, key, loadFresh) {
     const pendingLoads = getPendingFreshLoads(cache);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bayonai/offline",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Reusable offline read-cache, pending-write, and silent recovery primitives.",
   "license": "MIT",
   "author": "Bayon AI",
@@ -21,6 +21,9 @@
     "idb",
     "typescript"
   ],
+  "engines": {
+    "node": ">=22"
+  },
   "sideEffects": false,
   "type": "module",
   "main": "./dist-cjs/index.js",
@@ -28,9 +31,14 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist-cjs/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist-cjs/index.d.ts",
+        "default": "./dist-cjs/index.js"
+      }
     }
   },
   "files": [
@@ -44,7 +52,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/write-esm-extensions.mjs && tsc -p tsconfig.cjs.json && node scripts/write-cjs.mjs",
+    "build": "tsc -p tsconfig.json && node scripts/write-esm-extensions.mjs && tsc -p tsconfig.cjs.json && node scripts/write-cjs.mjs && node scripts/verify-dist.mjs",
     "lint": "tsc --noEmit -p tsconfig.json",
     "pack:smoke": "corepack pnpm run build && npm pack --dry-run --access public",
     "prepack": "corepack pnpm run build",
@@ -56,7 +64,7 @@
   },
   "devDependencies": {
     "fake-indexeddb": "^6.2.5",
-    "typescript": "^5",
-    "vitest": "^4.1.6"
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.1"
   }
 }