@sweidos/eidos 2.0.0 → 2.2.0

package/dist/index.d.ts

@@ -158,10 +158,21 @@ export declare class AsyncStorageQueueStorage implements QueueStorage {
 
 export declare type CacheStrategy = 'cache-first' | 'stale-while-revalidate' | 'network-first';
 
+/**
+ * Cancel an invocation by its `idempotencyKey` (from `ActionContext` /
+ * `onOptimistic`). Aborts the in-flight call if `cancellable: true` and
+ * still running, otherwise removes a not-yet-replayed queued item.
+ * Returns `true` if something was cancelled/removed.
+ *
+ * Shared by every `ActionHandle.cancel()` and by devtools, which can't
+ * address a specific handle from a queue item alone.
+ */
+export declare function cancelByIdempotencyKey(idempotencyKey: string): Promise<boolean>;
+
 /** Remove all items from the action queue (storage + in-memory store). */
 export declare function clearQueue(): Promise<void>;
 
-declare interface ConflictConfig {
+export declare interface ConflictConfig {
     /**
      * - `'serverWins'`: drop the queued item, keeping the server's state.
      * - `'clientWins'`: keep retrying — the client's write should eventually
@@ -177,7 +188,7 @@ declare interface ConflictConfig {
  * Passed to `ConflictConfig.resolve` (for `'merge'`/`'custom'` strategies)
  * when a queued action's replay receives a 4xx response.
  */
-declare interface ConflictContext {
+export declare interface ConflictContext {
     /** Whatever `fn` threw — typically a `Response` or an error with `.status`. */
     error: unknown;
     /** The original arguments the action was queued with. */
@@ -194,7 +205,7 @@ declare interface ConflictContext {
  * - `{ resolved: args }`: replace the queued args and retry immediately
  *   on the next replay pass.
  */
-declare type ConflictResolution = 'retry' | 'skip' | {
+export declare type ConflictResolution = 'retry' | 'skip' | {
     resolved: any[];
 };
 
@@ -213,6 +224,15 @@ export declare interface EidosConfig {
     swPath?: string;
     /** Automatically replay the action queue on reconnect. Default: true. */
     autoReplay?: boolean;
+    /**
+     * Opt-in reliability telemetry. Called with a snapshot of cumulative
+     * `neverLose` queue outcome counters (`ReliabilityStats`) every
+     * `reliabilityReportInterval` ms — wire this up to your analytics backend.
+     * Not called if omitted.
+     */
+    onReliabilityReport?: (stats: ReliabilityStats) => void;
+    /** Interval (ms) between `onReliabilityReport` calls. Default: 60000. */
+    reliabilityReportInterval?: number;
 }
 
 /**
@@ -251,6 +271,13 @@ export declare interface EidosReadable<T> {
     getState(): T;
 }
 
+/**
+ * Cumulative, session-scoped `neverLose` queue outcome counters — opt-in
+ * reliability telemetry. Re-emits only when a counter changes. See
+ * `EidosConfig.onReliabilityReport` to forward these to an analytics backend.
+ */
+export declare const eidosReliabilityStats: EidosReadable<ReliabilityStats>;
+
 /**
  * Live cache state for a single registered resource URL.
  * @example
@@ -266,6 +293,7 @@ export declare interface EidosState {
     swError?: string;
     resources: Record<string, ResourceEntry>;
     queue: ActionQueueItem[];
+    reliability: ReliabilityStats;
 }
 
 /**
@@ -278,7 +306,7 @@ export declare const eidosStatus: EidosReadable<{
     swError: string | undefined;
 }>;
 
-export declare interface EidosStore extends EidosState, ResourceActions, QueueActions {
+export declare interface EidosStore extends EidosState, ResourceActions, QueueActions, ReliabilityActions {
     setOnline: (online: boolean) => void;
     setSwStatus: (status: EidosState['swStatus'], error?: string) => void;
 }
@@ -310,6 +338,17 @@ export declare function isBgSyncSupported(): boolean;
 
 declare type Listener = () => void;
 
+/**
+ * Calls `callback` once each time the action queue drains from non-empty → 0.
+ * Framework-agnostic equivalent of `useEidosOnDrain` for Svelte/Vue/vanilla.
+ * Returns an unsubscribe function.
+ *
+ * @example
+ *   // Svelte
+ *   onMount(() => onQueueDrain(() => toast.success('All offline actions synced!')))
+ */
+export declare function onQueueDrain(callback: () => void): () => void;
+
 /**
  * Handle for a URL pattern (`/api/products/*`, `/api/users/:id`, `**`).
  * The SW intercepts all matching requests automatically — there is no single
@@ -361,6 +400,32 @@ export declare interface QueueStorage {
 
 export declare function registerPushCallbacks(handlers: PushHandlers): void;
 
+declare interface ReliabilityActions {
+    recordReliabilityEvent: (event: keyof ReliabilityStats) => void;
+    resetReliabilityStats: () => void;
+}
+
+/**
+ * Cumulative, session-scoped counters for `neverLose` queue outcomes — opt-in
+ * telemetry surfaced via `eidosReliabilityStats` / `useEidosReliabilityStats()`
+ * and `EidosConfig.onReliabilityReport`. Reset on page reload (not persisted).
+ */
+export declare interface ReliabilityStats {
+    [key: string]: number;
+    /** Actions persisted to the queue (offline, or online call that threw). */
+    queued: number;
+    /** Queue items that executed successfully (first attempt or a retry). */
+    succeeded: number;
+    /** Queue items that exhausted `maxRetries` and moved to `'failed'`. */
+    failed: number;
+    /** Replay attempts that failed but will retry (haven't exhausted `maxRetries`). */
+    retried: number;
+    /** Queue items dropped by a `serverWins`/`merge`/`custom` conflict resolution. */
+    conflicted: number;
+    /** Queue items removed via `handle.cancel(idempotencyKey)` before replay completed. */
+    cancelled: number;
+}
+
 export declare function replayQueue(): Promise<ReplayResult>;
 
 /** Summary returned by replayQueue(). */
@@ -381,6 +446,14 @@ export declare interface ReplayResult {
     cancelled: number;
 }
 
+/**
+ * Reset a `'failed'` queue item back to `'pending'` so the next
+ * `replayQueue()` retries it — clears `error`/`nextRetryAt` and resets
+ * `retryCount` to 0. Returns `true` if the item existed and was failed.
+ * Used by devtools' per-item "Retry" action.
+ */
+export declare function requeueItem(id: string): Promise<boolean>;
+
 export declare function _resetEidos(): void;
 
 /**
@@ -402,6 +475,14 @@ export declare interface ResourceConfig {
     strategy?: CacheStrategy;
     /** Custom cache bucket name. Defaults to 'eidos-resources-v1'. */
     cacheName?: string;
+    /**
+     * Cache schema version. Bump when the response shape changes so old
+     * cached entries (a different shape) aren't served from a stale bucket.
+     * Appended to `cacheName` as a suffix (e.g. `eidos-resources-v1-v2`).
+     * Old-versioned buckets are left in Cache Storage — clear them via
+     * `caches.delete()` if needed.
+     */
+    version?: string | number;
     /** Max age of cached response in milliseconds. Expired entries trigger a network fetch. */
     maxAge?: number;
 }
@@ -480,14 +561,6 @@ export declare function useEidos(): EidosStore;
  */
 export declare function useEidosAction(id: string): ActionQueueItem | undefined;
 
-/**
- * Calls `callback` once each time the action queue drains from non-empty → 0.
- * Stable callback reference not required — always calls the latest version.
- * Use for "all offline actions synced!" toasts.
- *
- * @example
- * useEidosOnDrain(() => toast.success('All offline actions synced!'))
- */
 export declare function useEidosOnDrain(callback: () => void): void;
 
 /** The current action queue. */
@@ -505,6 +578,21 @@ export declare function useEidosQueueStats(): {
     total: number;
 };
 
+/**
+ * Calls `callback` once each time the action queue drains from non-empty → 0.
+ * Stable callback reference not required — always calls the latest version.
+ * Use for "all offline actions synced!" toasts.
+ *
+ * @example
+ * useEidosOnDrain(() => toast.success('All offline actions synced!'))
+ */
+/**
+ * Cumulative, session-scoped `neverLose` queue outcome counters — opt-in
+ * reliability telemetry for dashboards/devtools. Re-renders only when a
+ * counter changes.
+ */
+export declare function useEidosReliabilityStats(): ReliabilityStats;
+
 /** Live state for a single registered resource URL. */
 export declare function useEidosResource(url: string): ResourceEntry;
 
@@ -528,7 +616,7 @@ export declare const useEidosStore: {
     setState: (partial: Partial<EidosStore> | ((s: EidosStore) => Partial<EidosStore>)) => void;
 };
 
-export declare const VERSION = "2.0.0";
+export declare const VERSION = "2.2.0";
 
 /**
  * Bulk-prefetch an array of resource handles concurrently, warming the cache

package/dist/index.js

@@ -1,49 +1,54 @@
 import { useEidosStore as o } from "./store.js";
-import { getSwRegistration as s, isBgSyncSupported as i, registerPushCallbacks as t, sendToWorker as u, setOfflineSimulation as m } from "./sw-bridge.js";
-import { resource as d, resourcePattern as n, setQueryInvalidator as p, warmCache as c } from "./resource.js";
+import { getSwRegistration as i, isBgSyncSupported as s, registerPushCallbacks as t, sendToWorker as u, setOfflineSimulation as a } from "./sw-bridge.js";
+import { resource as d, resourcePattern as n, setQueryInvalidator as c, warmCache as p } from "./resource.js";
 import { _getQueueStorage as f, setQueueStorage as E } from "./queue-storage.js";
-import { action as g, clearQueue as l, replayQueue as R } from "./action.js";
+import { action as Q, cancelByIdempotencyKey as y, clearQueue as g, replayQueue as R, requeueItem as b } from "./action.js";
 import { subscribeReplayOnReconnect as O } from "./replay.js";
-import { _resetEidos as A, initEidos as P } from "./runtime.js";
-import { AsyncStorageQueueStorage as k } from "./async-storage-adapter.js";
-import { EidosProvider as w } from "./react/Provider.js";
-import { useEidos as I, useEidosAction as _, useEidosOnDrain as x, useEidosQueue as B, useEidosQueueStats as D, useEidosResource as N, useEidosResources as T, useEidosStatus as V } from "./react/hooks.js";
-import { VERSION as j } from "./version.js";
-import { eidosAction as z, eidosQueue as F, eidosQueueStats as G, eidosResource as H, eidosStatus as J, eidosStore as K } from "./stores.js";
+import { _resetEidos as P, initEidos as h } from "./runtime.js";
+import { AsyncStorageQueueStorage as v } from "./async-storage-adapter.js";
+import { EidosProvider as B } from "./react/Provider.js";
+import { eidosAction as D, eidosQueue as _, eidosQueueStats as q, eidosReliabilityStats as x, eidosResource as K, eidosStatus as N, eidosStore as T, onQueueDrain as V } from "./stores.js";
+import { useEidos as j, useEidosAction as z, useEidosOnDrain as F, useEidosQueue as G, useEidosQueueStats as H, useEidosReliabilityStats as J, useEidosResource as L, useEidosResources as M, useEidosStatus as U } from "./react/hooks.js";
+import { VERSION as Y } from "./version.js";
 export {
-  k as AsyncStorageQueueStorage,
-  w as EidosProvider,
-  j as VERSION,
+  v as AsyncStorageQueueStorage,
+  B as EidosProvider,
+  Y as VERSION,
   f as _getQueueStorage,
-  A as _resetEidos,
-  g as action,
-  l as clearQueue,
-  z as eidosAction,
-  F as eidosQueue,
-  G as eidosQueueStats,
-  H as eidosResource,
-  J as eidosStatus,
-  K as eidosStore,
-  s as getSwRegistration,
-  P as initEidos,
-  i as isBgSyncSupported,
+  P as _resetEidos,
+  Q as action,
+  y as cancelByIdempotencyKey,
+  g as clearQueue,
+  D as eidosAction,
+  _ as eidosQueue,
+  q as eidosQueueStats,
+  x as eidosReliabilityStats,
+  K as eidosResource,
+  N as eidosStatus,
+  T as eidosStore,
+  i as getSwRegistration,
+  h as initEidos,
+  s as isBgSyncSupported,
+  V as onQueueDrain,
   t as registerPushCallbacks,
   R as replayQueue,
+  b as requeueItem,
   d as resource,
   n as resourcePattern,
   u as sendToWorker,
-  m as setOfflineSimulation,
-  p as setQueryInvalidator,
+  a as setOfflineSimulation,
+  c as setQueryInvalidator,
   E as setQueueStorage,
   O as subscribeReplayOnReconnect,
-  I as useEidos,
-  _ as useEidosAction,
-  x as useEidosOnDrain,
-  B as useEidosQueue,
-  D as useEidosQueueStats,
-  N as useEidosResource,
-  T as useEidosResources,
-  V as useEidosStatus,
+  j as useEidos,
+  z as useEidosAction,
+  F as useEidosOnDrain,
+  G as useEidosQueue,
+  H as useEidosQueueStats,
+  J as useEidosReliabilityStats,
+  L as useEidosResource,
+  M as useEidosResources,
+  U as useEidosStatus,
   o as useEidosStore,
-  c as warmCache
+  p as warmCache
 };

package/dist/react/hooks.js

@@ -1,23 +1,24 @@
-import { useEidosStore as o } from "../store.js";
 import { countQueueByStatus as l } from "../types.js";
-import { useEffect as i, useRef as c, useSyncExternalStore as p } from "react";
+import { useEidosStore as r } from "../store.js";
+import { onQueueDrain as E } from "../stores.js";
+import { useEffect as s, useRef as p, useSyncExternalStore as S } from "react";
 function u(e) {
   const t = e ?? ((n) => n);
-  return p(o.subscribe, () => t(o.getState()));
+  return S(r.subscribe, () => t(r.getState()));
 }
-function R() {
+function b() {
   return u();
 }
-function q() {
+function w() {
   return u((e) => e.resources);
 }
-function w(e) {
+function Q(e) {
   return u((t) => t.resources[e]);
 }
-function y() {
+function $() {
   return u((e) => e.queue);
 }
-function $(e) {
+function q(e) {
   return u((t) => t.queue.find((n) => n.id === e));
 }
 function O() {
@@ -27,34 +28,36 @@ function O() {
     swError: u((e) => e.swError)
   };
 }
-function Q() {
-  const [e, t, n, r] = u((s) => {
-    const { pending: f, failed: a, replaying: d, total: E } = l(s.queue);
-    return `${f},${a},${d},${E}`;
+function x() {
+  const [e, t, n, i] = u((o) => {
+    const { pending: c, failed: f, replaying: a, total: d } = l(o.queue);
+    return `${c},${f},${a},${d}`;
   }).split(",");
   return {
     pending: +e,
     failed: +t,
     replaying: +n,
-    total: +r
+    total: +i
   };
 }
-function b(e) {
-  const t = u((s) => s.queue.length), n = c(0), r = c(e);
-  i(() => {
-    r.current = e;
-  }), i(() => {
-    n.current > 0 && t === 0 && r.current(), n.current = t;
-  }, [t]);
+function D() {
+  return u((e) => e.reliability);
+}
+function A(e) {
+  const t = p(e);
+  s(() => {
+    t.current = e;
+  }), s(() => E(() => t.current()), []);
 }
 export {
-  R as useEidos,
-  $ as useEidosAction,
-  b as useEidosOnDrain,
-  y as useEidosQueue,
-  Q as useEidosQueueStats,
-  w as useEidosResource,
-  q as useEidosResources,
+  b as useEidos,
+  q as useEidosAction,
+  A as useEidosOnDrain,
+  $ as useEidosQueue,
+  x as useEidosQueueStats,
+  D as useEidosReliabilityStats,
+  Q as useEidosResource,
+  w as useEidosResources,
   O as useEidosStatus
 };
 

package/dist/react/hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.js","names":[],"sources":["../../src/react/hooks.ts"],"sourcesContent":["import { useEffect, useRef, useSyncExternalStore } from 'react';\nimport { useEidosStore } from '../store';\nimport type { EidosStore } from '../store';\nimport { countQueueByStatus } from '../types';\n\nfunction useStore(): EidosStore;\nfunction useStore<T>(selector: (state: EidosStore) => T): T;\nfunction useStore<T = EidosStore>(selector?: (state: EidosStore) => T): T {\n  const fn = selector ?? ((s: EidosStore) => s as unknown as T);\n  return useSyncExternalStore(useEidosStore.subscribe, () => fn(useEidosStore.getState()));\n}\n\n/** Full Eidos store — prefer the narrower hooks below for performance. */\nexport function useEidos() {\n  return useStore();\n}\n\n/** All registered resources — only re-renders when the resources map changes, not on queue mutations. */\nexport function useEidosResources() {\n  return useStore((s) => s.resources);\n}\n\n/** Live state for a single registered resource URL. */\nexport function useEidosResource(url: string) {\n  return useStore((s) => s.resources[url]);\n}\n\n/** The current action queue. */\nexport function useEidosQueue() {\n  return useStore((s) => s.queue);\n}\n\n/**\n * Live state for a single queue item by ID. Only re-renders when that specific\n * item changes — cheaper than `useEidosQueue().find(id)` which re-renders on\n * any queue mutation.\n */\nexport function useEidosAction(id: string) {\n  return useStore((s) => s.queue.find((item) => item.id === id));\n}\n\n/**\n * Online + SW status — cheap subscription, safe to use in header components.\n * Three separate primitive selectors so each only triggers a re-render when\n * its own value changes (no object-reference churn from a combined selector).\n */\nexport function useEidosStatus() {\n  const isOnline = useStore((s) => s.isOnline);\n  const swStatus = useStore((s) => s.swStatus);\n  const swError = useStore((s) => s.swError);\n  return { isOnline, swStatus, swError };\n}\n\n/**\n * Queue counts — single subscription, single loop. Re-renders only when a\n * count changes, not on every queue mutation. Use for badges and status bars\n * instead of `useEidosQueue()` when you only need numbers, not full items.\n */\nexport function useEidosQueueStats() {\n  // Encode as a comma-separated string so useSyncExternalStore's Object.is\n  // comparison bails out correctly when counts haven't changed. One loop,\n  // one subscription — cheaper than four separate filter() passes.\n  const encoded = useStore((s) => {\n    const { pending, failed, replaying, total } = countQueueByStatus(s.queue);\n    return `${pending},${failed},${replaying},${total}`;\n  });\n  const [p, f, r, t] = encoded.split(',');\n  return { pending: +p, failed: +f, replaying: +r, total: +t };\n}\n\n/**\n * Calls `callback` once each time the action queue drains from non-empty → 0.\n * Stable callback reference not required — always calls the latest version.\n * Use for \"all offline actions synced!\" toasts.\n *\n * @example\n * useEidosOnDrain(() => toast.success('All offline actions synced!'))\n */\nexport function useEidosOnDrain(callback: () => void) {\n  const total = useStore((s) => s.queue.length);\n  const prevRef = useRef(0);\n  const callbackRef = useRef(callback);\n\n  useEffect(() => {\n    callbackRef.current = callback;\n  });\n\n  useEffect(() => {\n    if (prevRef.current > 0 && total === 0) {\n      callbackRef.current();\n    }\n    prevRef.current = total;\n  }, [total]);\n}\n"],"mappings":";;;AAOA,SAAS,EAAyB,GAAwC;AACxE,QAAM,IAAK,MAAA,CAAc,MAAkB;AAC3C,SAAO,EAAqB,EAAc,WAAA,MAAiB,EAAG,EAAc,SAAS,CAAC,CAAC;AACzF;AAGA,SAAgB,IAAW;AACzB,SAAO,EAAS;AAClB;AAGA,SAAgB,IAAoB;AAClC,SAAO,EAAA,CAAU,MAAM,EAAE,SAAS;AACpC;AAGA,SAAgB,EAAiB,GAAa;AAC5C,SAAO,EAAA,CAAU,MAAM,EAAE,UAAU,CAAA,CAAI;AACzC;AAGA,SAAgB,IAAgB;AAC9B,SAAO,EAAA,CAAU,MAAM,EAAE,KAAK;AAChC;AAOA,SAAgB,EAAe,GAAY;AACzC,SAAO,EAAA,CAAU,MAAM,EAAE,MAAM,KAAA,CAAM,MAAS,EAAK,OAAO,CAAE,CAAC;AAC/D;AAOA,SAAgB,IAAiB;AAI/B,SAAO;AAAA,IAAE,UAHQ,EAAA,CAAU,MAAM,EAAE,QAG1B;AAAA,IAAU,UAFF,EAAA,CAAU,MAAM,EAAE,QAEhB;AAAA,IAAU,SADb,EAAA,CAAU,MAAM,EAAE,OACL;AAAA,EAAQ;AACvC;AAOA,SAAgB,IAAqB;AAQnC,QAAM,CAAC,GAAG,GAAG,GAAG,CAAA,IAJA,EAAA,CAAU,MAAM;AAC9B,UAAM,EAAE,SAAA,GAAS,QAAA,GAAQ,WAAA,GAAW,OAAA,EAAA,IAAU,EAAmB,EAAE,KAAK;AACxE,WAAO,GAAG,CAAA,IAAW,CAAA,IAAU,CAAA,IAAa,CAAA;AAAA,EAC9C,CACqB,EAAQ,MAAM,GAAG;AACtC,SAAO;AAAA,IAAE,SAAS,CAAC;AAAA,IAAG,QAAQ,CAAC;AAAA,IAAG,WAAW,CAAC;AAAA,IAAG,OAAO,CAAC;AAAA,EAAE;AAC7D;AAUA,SAAgB,EAAgB,GAAsB;AACpD,QAAM,IAAQ,EAAA,CAAU,MAAM,EAAE,MAAM,MAAM,GACtC,IAAU,EAAO,CAAC,GAClB,IAAc,EAAO,CAAQ;AAEnC,EAAA,EAAA,MAAgB;AACd,IAAA,EAAY,UAAU;AAAA,EACxB,CAAC,GAED,EAAA,MAAgB;AACd,IAAI,EAAQ,UAAU,KAAK,MAAU,KACnC,EAAY,QAAQ,GAEtB,EAAQ,UAAU;AAAA,EACpB,GAAG,CAAC,CAAK,CAAC;AACZ"}
+{"version":3,"file":"hooks.js","names":[],"sources":["../../src/react/hooks.ts"],"sourcesContent":["import { useEffect, useRef, useSyncExternalStore } from 'react';\nimport { useEidosStore } from '../store';\nimport type { EidosStore } from '../store';\nimport { countQueueByStatus } from '../types';\nimport { onQueueDrain } from '../stores';\n\nfunction useStore(): EidosStore;\nfunction useStore<T>(selector: (state: EidosStore) => T): T;\nfunction useStore<T = EidosStore>(selector?: (state: EidosStore) => T): T {\n  const fn = selector ?? ((s: EidosStore) => s as unknown as T);\n  return useSyncExternalStore(useEidosStore.subscribe, () => fn(useEidosStore.getState()));\n}\n\n/** Full Eidos store — prefer the narrower hooks below for performance. */\nexport function useEidos() {\n  return useStore();\n}\n\n/** All registered resources — only re-renders when the resources map changes, not on queue mutations. */\nexport function useEidosResources() {\n  return useStore((s) => s.resources);\n}\n\n/** Live state for a single registered resource URL. */\nexport function useEidosResource(url: string) {\n  return useStore((s) => s.resources[url]);\n}\n\n/** The current action queue. */\nexport function useEidosQueue() {\n  return useStore((s) => s.queue);\n}\n\n/**\n * Live state for a single queue item by ID. Only re-renders when that specific\n * item changes — cheaper than `useEidosQueue().find(id)` which re-renders on\n * any queue mutation.\n */\nexport function useEidosAction(id: string) {\n  return useStore((s) => s.queue.find((item) => item.id === id));\n}\n\n/**\n * Online + SW status — cheap subscription, safe to use in header components.\n * Three separate primitive selectors so each only triggers a re-render when\n * its own value changes (no object-reference churn from a combined selector).\n */\nexport function useEidosStatus() {\n  const isOnline = useStore((s) => s.isOnline);\n  const swStatus = useStore((s) => s.swStatus);\n  const swError = useStore((s) => s.swError);\n  return { isOnline, swStatus, swError };\n}\n\n/**\n * Queue counts — single subscription, single loop. Re-renders only when a\n * count changes, not on every queue mutation. Use for badges and status bars\n * instead of `useEidosQueue()` when you only need numbers, not full items.\n */\nexport function useEidosQueueStats() {\n  // Encode as a comma-separated string so useSyncExternalStore's Object.is\n  // comparison bails out correctly when counts haven't changed. One loop,\n  // one subscription — cheaper than four separate filter() passes.\n  const encoded = useStore((s) => {\n    const { pending, failed, replaying, total } = countQueueByStatus(s.queue);\n    return `${pending},${failed},${replaying},${total}`;\n  });\n  const [p, f, r, t] = encoded.split(',');\n  return { pending: +p, failed: +f, replaying: +r, total: +t };\n}\n\n/**\n * Calls `callback` once each time the action queue drains from non-empty → 0.\n * Stable callback reference not required — always calls the latest version.\n * Use for \"all offline actions synced!\" toasts.\n *\n * @example\n * useEidosOnDrain(() => toast.success('All offline actions synced!'))\n */\n/**\n * Cumulative, session-scoped `neverLose` queue outcome counters — opt-in\n * reliability telemetry for dashboards/devtools. Re-renders only when a\n * counter changes.\n */\nexport function useEidosReliabilityStats() {\n  return useStore((s) => s.reliability);\n}\n\nexport function useEidosOnDrain(callback: () => void) {\n  const callbackRef = useRef(callback);\n\n  useEffect(() => {\n    callbackRef.current = callback;\n  });\n\n  useEffect(() => onQueueDrain(() => callbackRef.current()), []);\n}\n"],"mappings":";;;;AAQA,SAAS,EAAyB,GAAwC;AACxE,QAAM,IAAK,MAAA,CAAc,MAAkB;AAC3C,SAAO,EAAqB,EAAc,WAAA,MAAiB,EAAG,EAAc,SAAS,CAAC,CAAC;AACzF;AAGA,SAAgB,IAAW;AACzB,SAAO,EAAS;AAClB;AAGA,SAAgB,IAAoB;AAClC,SAAO,EAAA,CAAU,MAAM,EAAE,SAAS;AACpC;AAGA,SAAgB,EAAiB,GAAa;AAC5C,SAAO,EAAA,CAAU,MAAM,EAAE,UAAU,CAAA,CAAI;AACzC;AAGA,SAAgB,IAAgB;AAC9B,SAAO,EAAA,CAAU,MAAM,EAAE,KAAK;AAChC;AAOA,SAAgB,EAAe,GAAY;AACzC,SAAO,EAAA,CAAU,MAAM,EAAE,MAAM,KAAA,CAAM,MAAS,EAAK,OAAO,CAAE,CAAC;AAC/D;AAOA,SAAgB,IAAiB;AAI/B,SAAO;AAAA,IAAE,UAHQ,EAAA,CAAU,MAAM,EAAE,QAG1B;AAAA,IAAU,UAFF,EAAA,CAAU,MAAM,EAAE,QAEhB;AAAA,IAAU,SADb,EAAA,CAAU,MAAM,EAAE,OACL;AAAA,EAAQ;AACvC;AAOA,SAAgB,IAAqB;AAQnC,QAAM,CAAC,GAAG,GAAG,GAAG,CAAA,IAJA,EAAA,CAAU,MAAM;AAC9B,UAAM,EAAE,SAAA,GAAS,QAAA,GAAQ,WAAA,GAAW,OAAA,EAAA,IAAU,EAAmB,EAAE,KAAK;AACxE,WAAO,GAAG,CAAA,IAAW,CAAA,IAAU,CAAA,IAAa,CAAA;AAAA,EAC9C,CACqB,EAAQ,MAAM,GAAG;AACtC,SAAO;AAAA,IAAE,SAAS,CAAC;AAAA,IAAG,QAAQ,CAAC;AAAA,IAAG,WAAW,CAAC;AAAA,IAAG,OAAO,CAAC;AAAA,EAAE;AAC7D;AAeA,SAAgB,IAA2B;AACzC,SAAO,EAAA,CAAU,MAAM,EAAE,WAAW;AACtC;AAEA,SAAgB,EAAgB,GAAsB;AACpD,QAAM,IAAc,EAAO,CAAQ;AAEnC,EAAA,EAAA,MAAgB;AACd,IAAA,EAAY,UAAU;AAAA,EACxB,CAAC,GAED,EAAA,MAAgB,EAAA,MAAmB,EAAY,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC/D"}

package/dist/resource.js

@@ -1,17 +1,17 @@
 import { useEidosStore as h } from "./store.js";
 import { sendToWorker as p } from "./sw-bridge.js";
-var d = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), v = null;
+var d = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), g = null;
 function _(e) {
-  v = e;
+  g = e;
 }
-function u(e) {
+function f(e) {
   return e.includes("*") || /:[^/]+/.test(e);
 }
 function k(e) {
   return "^" + e.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]+").replace(/:[^/]+/g, "[^/]+") + "$";
 }
 function m(e, s) {
-  const a = b(s), t = u(e) ? k(e) : void 0, r = {
+  const a = b(s), t = f(e) ? k(e) : void 0, r = {
     url: e,
     config: s,
     strategy: a,
@@ -40,17 +40,17 @@ function y(e, s, a) {
     if (t) {
       const r = await t.keys(), n = a ? new RegExp(a) : null, c = e.startsWith("http");
       await Promise.all(r.filter((i) => {
-        const o = i.url, f = new URL(o).pathname;
-        return n ? n.test(c ? o : f) : c ? o === e : o === e || f === e;
+        const o = i.url, u = new URL(o).pathname;
+        return n ? n.test(c ? o : u) : c ? o === e : o === e || u === e;
       }).map((i) => t.delete(i)));
     }
-    u(e) || h.getState().updateResource(e, {
+    f(e) || h.getState().updateResource(e, {
       status: "stale",
       cachedAt: void 0,
       lastEvent: "cache-cleared",
       cacheHits: 0,
       cacheMisses: 0
-    }), v?.(["eidos", e]);
+    }), g?.(["eidos", e]);
   };
 }
 function E(e) {
@@ -62,7 +62,7 @@ function E(e) {
   };
 }
 function A(e, s) {
-  if (u(e)) throw new Error(`[eidos] resource('${e}') is a URL pattern — use resourcePattern('${e}', config) instead. Pattern handles only support invalidate()/unregister(); the SW intercepts matching requests automatically.`);
+  if (f(e)) throw new Error(`[eidos] resource('${e}') is a URL pattern — use resourcePattern('${e}', config) instead. Pattern handles only support invalidate()/unregister(); the SW intercepts matching requests automatically.`);
   if (d.has(e)) return d.get(e);
   const { strategy: a } = m(e, s), t = {
     url: e,
@@ -88,8 +88,8 @@ function A(e, s) {
   };
   return d.set(e, t), t;
 }
-function O(e, s) {
-  if (!u(e)) throw new Error(`[eidos] resourcePattern('${e}') is not a URL pattern — use resource('${e}', config) instead.`);
+function $(e, s) {
+  if (!f(e)) throw new Error(`[eidos] resourcePattern('${e}') is not a URL pattern — use resource('${e}', config) instead.`);
   if (d.has(e)) return d.get(e);
   const { strategy: a, regexStr: t } = m(e, s), r = {
     url: e,
@@ -109,8 +109,8 @@ async function S(e, s, a) {
   const r = await caches.open(a.cacheName).catch(() => null);
   try {
     if (a.swStrategy !== "network-first") {
-      const i = r ? await r.match(e).catch(() => null) : null, o = h.getState().resources[e], f = s.maxAge !== void 0 && o?.cachedAt !== void 0 && Date.now() - o.cachedAt > s.maxAge;
-      if (i && !f)
+      const i = r ? await r.match(e).catch(() => null) : null, o = h.getState().resources[e], u = s.maxAge !== void 0 && o?.cachedAt !== void 0 && Date.now() - o.cachedAt > s.maxAge;
+      if (i && !u)
         return t.updateResource(e, {
           status: "fresh",
           lastEvent: "cache-hit",
@@ -150,7 +150,7 @@ async function S(e, s, a) {
 }
 function b(e) {
   const s = e.strategy;
-  return e.offline ? g(s ?? "stale-while-revalidate", e.cacheName) : g(s ?? "network-first", e.cacheName);
+  return e.offline ? v(s ?? "stale-while-revalidate", e.cacheName, e.version) : v(s ?? "network-first", e.cacheName, e.version);
 }
 var x = {
   "stale-while-revalidate": "StaleWhileRevalidate",
@@ -200,18 +200,18 @@ new NetworkFirst({
 })`
   }
 };
-function g(e, s) {
-  const a = C[e];
+function v(e, s, a) {
+  const t = C[e], r = s ?? "eidos-resources-v1";
   return {
     name: x[e],
     swStrategy: e,
-    cacheName: s ?? "eidos-resources-v1",
-    reasoning: a.reasoning,
-    behavior: a.behavior,
+    cacheName: a !== void 0 ? `${r}-v${a}` : r,
+    reasoning: t.reasoning,
+    behavior: t.behavior,
     equivalentCode: ""
   };
 }
-async function T(e) {
+async function O(e) {
   const s = await Promise.allSettled(e.map((t) => t.prefetch())), a = s.filter((t) => t.status === "rejected").map((t) => t.reason);
   return {
     warmed: s.filter((t) => t.status === "fulfilled").length,
@@ -221,9 +221,9 @@ async function T(e) {
 }
 export {
   A as resource,
-  O as resourcePattern,
+  $ as resourcePattern,
   _ as setQueryInvalidator,
-  T as warmCache
+  O as warmCache
 };
 
 //# sourceMappingURL=resource.js.map