@sweidos/eidos 1.2.0 → 2.0.0

package/README.md

@@ -114,20 +114,22 @@ if ('queued' in result) {
 
 ## What you get
 
-| Feature                     | Description                                                                          |
-| --------------------------- | ------------------------------------------------------------------------------------ |
-| **Auto strategy selection** | `offline: true` → StaleWhileRevalidate. No config needed. Override when you want.    |
-| **Persistent action queue** | Failed writes go to IndexedDB and replay with exponential backoff on reconnect.      |
-| **Request deduplication**   | Concurrent `resource.fetch()` calls share one in-flight request.                     |
-| **Optimistic updates**      | `onOptimistic` / `onRollback` callbacks for instant UI feedback.                     |
-| **Conflict resolution**     | `onConflict` decides per 4xx whether to retry or drop a queued action.               |
-| **Queue prioritization**    | `priority: 'high' \| 'normal' \| 'low'` — high items replay before normal.           |
-| **Cache warming**           | `warmCache(handles[])` bulk-prefetches resources on login/init.                      |
-| **URL patterns**            | `/api/products/*`, `/api/users/:id`, `**` wildcards — SW intercepts all matches.     |
-| **Background Sync**         | Registers a `sync` tag so queued actions replay even after tab close.                |
-| **Devtools panel**          | `<EidosDevtools />` — live queue, cache state, offline toggle, no CSS import.        |
-| **Testing helpers**         | `mockOffline`, `drainQueue`, `resetEidos`, `getCachedEntry` for Vitest/Jest.         |
-| **OpenAPI codegen**         | `npx eidos-gen openapi.json` generates typed `resource()` + `action()` declarations. |
+| Feature                     | Description                                                                                                                 |
+| --------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| **Auto strategy selection** | `offline: true` → StaleWhileRevalidate. No config needed. Override when you want.                                           |
+| **Persistent action queue** | Failed writes go to IndexedDB and replay with exponential backoff on reconnect.                                             |
+| **Request deduplication**   | Concurrent `resource.fetch()` calls share one in-flight request.                                                            |
+| **Optimistic updates**      | `onOptimistic` / `onRollback` callbacks for instant UI feedback.                                                            |
+| **Conflict resolution**     | `conflict: { strategy: 'serverWins' \| 'clientWins' \| 'merge' \| 'custom' }` on 4xx replay responses.                      |
+| **Idempotent replay**       | Stable `idempotencyKey` per invocation, forwarded to `fn` via `ActionContext` — safe retries even after a dropped response. |
+| **Cancellable actions**     | `cancellable: true` → `AbortSignal` per call, plus `handle.cancel(idempotencyKey)`.                                         |
+| **Queue prioritization**    | `priority: 'high' \| 'normal' \| 'low'` — high items replay before normal.                                                  |
+| **Cache warming**           | `warmCache(handles[])` bulk-prefetches resources on login/init.                                                             |
+| **URL patterns**            | `/api/products/*`, `/api/users/:id`, `**` wildcards — SW intercepts all matches.                                            |
+| **Background Sync**         | Registers a `sync` tag so queued actions replay even after tab close.                                                       |
+| **Devtools panel**          | `<EidosDevtools />` — live queue, cache state, offline toggle, no CSS import.                                               |
+| **Testing helpers**         | `mockOffline`, `drainQueue`, `resetEidos`, `getCachedEntry` for Vitest/Jest.                                                |
+| **OpenAPI codegen**         | `npx eidos-gen openapi.json` generates typed `resource()` + `action()` declarations.                                        |
 
 ---
 
@@ -175,20 +177,40 @@ products.query()                 // { queryKey, queryFn } for useQuery
 | `offline: true, strategy: 'cache-first'`   | CacheFirst           | Static assets, config data          |
 | `offline: true, strategy: 'network-first'` | NetworkFirst         | Always-fresh with offline fallback  |
 
-URL patterns work on any handle: `/api/products/*`, `/api/users/:id`, `**`
+### `resourcePattern(pattern, config)`
+
+For URL patterns — `/api/products/*`, `/api/users/:id`, `**` — the SW intercepts
+all matching requests automatically, so there's no single URL to fetch. Use
+`resourcePattern()` instead of `resource()`; it returns a handle with only
+`invalidate()` and `unregister()`:
+
+```ts
+const productPattern = resourcePattern('/api/products/*', { offline: true });
+
+await productPattern.invalidate(); // clear all cached entries matching the pattern
+productPattern.unregister();
+```
 
 ### `action(fn, config)`
 
 ```ts
-const createOrder = action(async (payload: OrderPayload) => { ... }, {
+const createOrder = action(async (payload: OrderPayload, ctx: ActionContext) => { ... }, {
   reliability: 'neverLose', // persist to IDB + replay on reconnect
   name: 'createOrder',      // stable name for post-reload replay
+  namespace?: string,       // prefix actionId — avoids collisions across modules
   maxRetries?: number,      // default: 3
   priority?: 'high' | 'normal' | 'low',
+  cancellable?: boolean,    // adds AbortSignal to ctx, enables handle.cancel(key)
   onOptimistic?: (...args) => void, // instant UI update
   onRollback?: (...args) => void,   // revert on permanent failure
-  onConflict?: (error, args) => 'retry' | 'skip', // 4xx handler
+  conflict?: {               // 4xx replay handling
+    strategy: 'serverWins' | 'clientWins' | 'merge' | 'custom',
+    resolve?: (ctx) => 'retry' | 'skip' | { resolved: args },
+  },
 })
+
+// ctx.idempotencyKey is stable across retries — forward as e.g. an
+// `Idempotency-Key` header so the server can dedupe replayed writes.
 ```
 
 ### React hooks
@@ -389,21 +411,19 @@ Panel shows: live queue state · cache entries · SW status · offline simulatio
 
 ## How it compares
 
-|                            | **Eidos**                                                                                   | Workbox                                    | RTK Query / TanStack Query                                      |
-| -------------------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------ | --------------------------------------------------------------- |
-| Service worker setup       | Generated for you — `resource()`/`action()` declarations drive the SW                       | Hand-write `routing` + `strategies` config | None — no SW                                                    |
-| Caching strategy           | Auto-derived from intent (`offline: true` → SWR, etc.), inspectable via devtools            | Manually chosen per route                  | Configurable `staleTime`/`gcTime`, no Cache Storage integration |
-| Offline writes             | `action()` + `reliability: 'neverLose'` → IndexedDB queue, auto-replay, exponential backoff | Background Sync plugin, you wire the queue | No built-in offline mutation queue                              |
-| Framework support          | React, Svelte, Vue, Next.js, React Native, vanilla JS                                       | Framework-agnostic (SW only)               | Per-library (RTK Query = Redux, TanStack = many)                |
-| TanStack Query bridge      | `@sweidos/eidos/query` — drop-in `useEidosQuery`/`useEidosMutation`                         | —                                          | Native                                                          |
-| Bundle size (core, brotli) | ~5.4 kB                                                                                     | ~3-6 kB (modular)                          | ~13 kB (TanStack Query core)                                    |
-
-Eidos isn't a replacement for TanStack Query — `@sweidos/eidos/query` is a thin
-adapter so you keep TQ's cache/devtools while Eidos owns the offline layer
-(SW caching + IndexedDB write queue). Workbox is a lower-level toolkit Eidos
-generates strategies _for_; Eidos picks and configures the strategy from your
-`resource()`/`action()` declarations instead of you writing `workbox-*` config
-by hand.
+|                       | **Eidos**                                             | Workbox                      | RTK Query / TanStack Query |
+| --------------------- | ----------------------------------------------------- | ---------------------------- | -------------------------- |
+| Service worker setup  | Generated from `resource()`/`action()` declarations   | Hand-written routing config  | None — no SW               |
+| Caching strategy      | Auto-derived from intent, inspectable via devtools    | Manually chosen per route    | `staleTime`/`gcTime` only  |
+| Offline writes        | IndexedDB queue, auto-replay + backoff via `action()` | Background Sync, you wire it | No built-in mutation queue |
+| Framework support     | React, Svelte, Vue, Next.js, React Native, vanilla JS | Framework-agnostic (SW only) | Per-library                |
+| TanStack Query bridge | `@sweidos/eidos/query` adapter                        | —                            | Native                     |
+| Bundle size (core)    | ~6 kB brotli                                          | ~3-6 kB (modular)            | ~13 kB                     |
+
+Not a TanStack Query replacement — `@sweidos/eidos/query` is a thin adapter so
+you keep TQ's cache/devtools while Eidos owns the offline layer. Workbox is a
+lower-level toolkit; Eidos picks and configures strategies for you instead of
+hand-written `workbox-*` config.
 
 ---
 

package/dist/action.js

@@ -1,84 +1,89 @@
-import { useEidosStore as y } from "./store.js";
+import { useEidosStore as f } from "./store.js";
 import { getSwRegistration as _ } from "./sw-bridge.js";
-import { idbQueueStorage as S } from "./idb.js";
-import { _getQueueStorage as M } from "./queue-storage.js";
-var h = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
-function u() {
-  return M() ?? S;
+import { idbQueueStorage as A } from "./idb.js";
+import { _getQueueStorage as S } from "./queue-storage.js";
+import { broadcastQueueSync as d } from "./queue-sync.js";
+var m = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map();
+function c() {
+  return S() ?? A;
 }
-function m() {
+function b() {
   return crypto.randomUUID();
 }
-function v(e, t, i) {
-  return e(...t, i);
+function h(e, t, o) {
+  return e(...t, o);
 }
-function U(e, t) {
-  const i = t.name || e.name || m(), a = t.namespace ? `${t.namespace}::${i}` : i;
-  h.set(a, e), x.set(a, t), t.onRollback && k.set(a, t.onRollback), t.onConflict && C.set(a, t.onConflict), t.conflict && Q.set(a, t.conflict);
-  const c = async (...n) => {
-    const { isOnline: s } = y.getState(), l = t.reliability === "neverLose" || t.cancellable, o = l ? m() : "";
-    let d;
+function F(e, t) {
+  const o = t.name || e.name || b(), a = t.namespace ? `${t.namespace}::${o}` : o;
+  if (m.has(a)) throw new Error(`[eidos] duplicate action id "${a}" — an action with this id is already registered. Pass a unique config.name or config.namespace.`);
+  m.set(a, e), x.set(a, t), t.onRollback && k.set(a, t.onRollback), t.conflict && Q.set(a, t.conflict);
+  const r = async (...n) => {
+    const { isOnline: s } = f.getState(), u = b();
+    let p;
     if (t.cancellable) {
-      const f = new AbortController();
-      p.set(o, f), d = f.signal;
+      const l = new AbortController();
+      y.set(u, l), p = l.signal;
     }
-    const g = {
-      idempotencyKey: o,
+    const w = {
+      idempotencyKey: u,
       attempt: 0,
-      signal: d
+      signal: p
     };
-    t.onOptimistic?.(...n, g);
+    t.onOptimistic?.(...n, w);
     try {
       if (t.reliability === "neverLose") {
-        if (!s) return R(a, a, n, t, o);
+        if (!s) return R(a, a, n, t, u);
         try {
-          return await v(e, n, g);
-        } catch (f) {
-          if (A(f)) throw f;
-          return R(a, a, n, t, o);
+          return await h(e, n, w);
+        } catch (l) {
+          if (C(l)) throw l;
+          return R(a, a, n, t, u);
         }
       }
       try {
-        return l ? await v(e, n, g) : await e(...n);
-      } catch (f) {
-        throw t.onRollback?.(...n), f;
+        return await h(e, n, w);
+      } catch (l) {
+        throw t.onRollback?.(...n, w), l;
       }
     } finally {
-      t.cancellable && p.delete(o);
+      t.cancellable && y.delete(u);
     }
-  }, r = async (n) => {
-    const s = p.get(n);
+  }, i = async (n) => {
+    const s = y.get(n);
     if (s)
       return s.abort(), !0;
-    const l = (await u().getAll()).find((o) => o.idempotencyKey === n && o.status === "pending");
-    return l ? (y.getState().removeQueueItem(l.id), await u().remove(l.id), !0) : !1;
+    const u = (await c().getAll()).find((p) => p.idempotencyKey === n && p.status === "pending");
+    return u ? (f.getState().removeQueueItem(u.id), d({
+      type: "remove",
+      id: u.id
+    }), await c().remove(u.id), !0) : !1;
   };
-  return Object.defineProperty(c, "id", {
+  return Object.defineProperty(r, "id", {
     value: a,
     writable: !1
-  }), Object.defineProperty(c, "config", {
+  }), Object.defineProperty(r, "config", {
     value: t,
     writable: !1
-  }), Object.defineProperty(c, "cancel", {
-    value: r,
+  }), Object.defineProperty(r, "cancel", {
+    value: i,
     writable: !1
-  }), c;
+  }), r;
 }
-async function R(e, t, i, a, c) {
-  const r = m(), n = {
+async function R(e, t, o, a, r) {
+  const i = b(), n = {
     schemaVersion: 2,
-    id: r,
+    id: i,
     actionId: e,
     actionName: t,
-    idempotencyKey: c,
-    args: i,
+    idempotencyKey: r,
+    args: o,
     queuedAt: Date.now(),
     retryCount: 0,
     maxRetries: a.maxRetries ?? 3,
     status: "pending",
     priority: a.priority ?? "normal"
   };
-  await u().add(n), y.getState().addQueueItem(n);
+  await c().add(n), f.getState().addQueueItem(n);
   try {
     const s = _();
     s && "sync" in s && await s.sync.register("eidos-queue-replay");
@@ -86,11 +91,11 @@ async function R(e, t, i, a, c) {
   }
   return {
     queued: !0,
-    id: r,
+    id: i,
     message: `"${t}" queued — will execute when online`
   };
 }
-function A(e) {
+function C(e) {
   return e instanceof DOMException && e.name === "AbortError";
 }
 function K(e) {
@@ -101,10 +106,10 @@ function K(e) {
   }
   return !1;
 }
-function O(e) {
+function M(e) {
   return Math.min(2e3 * 2 ** e, 3e5) * (0.8 + Math.random() * 0.4);
 }
-function w() {
+function g() {
   return {
     attempted: 0,
     succeeded: 0,
@@ -115,138 +120,171 @@ function w() {
     cancelled: 0
   };
 }
-var b = !1, q = "eidos-queue-replay";
-async function $() {
-  const e = y.getState();
-  if (!e.isOnline) return w();
-  if (typeof navigator < "u" && navigator.locks) return navigator.locks.request(q, { ifAvailable: !0 }, async (t) => t ? I(e) : w());
-  if (b) return w();
-  b = !0;
+var v = !1, O = "eidos-queue-replay";
+async function V() {
+  const e = f.getState();
+  if (!e.isOnline) return g();
+  if (typeof navigator < "u" && navigator.locks) return navigator.locks.request(O, { ifAvailable: !0 }, async (t) => t ? I(e) : g());
+  if (v) return g();
+  v = !0;
   try {
     return await I(e);
   } finally {
-    b = !1;
+    v = !1;
   }
 }
-async function E(e, t) {
-  const i = h.get(e.actionId);
-  if (!i) return "skipped";
+async function q(e, t) {
+  const o = Date.now();
+  t.updateQueueItem(e.id, {
+    status: "succeeded",
+    completedAt: o
+  }), d({
+    type: "update",
+    id: e.id,
+    update: {
+      status: "succeeded",
+      completedAt: o
+    }
+  }), await c().update(e.id, {
+    status: "succeeded",
+    completedAt: o
+  }), setTimeout(() => {
+    t.removeQueueItem(e.id), d({
+      type: "remove",
+      id: e.id
+    }), c().remove(e.id);
+  }, 3e3);
+}
+async function E(e, t, o) {
+  const a = Q.get(e.actionId);
+  let r;
+  if (a) switch (a.strategy) {
+    case "serverWins":
+      r = "skip";
+      break;
+    case "clientWins":
+      r = "retry";
+      break;
+    case "merge":
+    case "custom": {
+      const i = {
+        error: o,
+        args: e.args,
+        attempt: e.retryCount,
+        idempotencyKey: e.idempotencyKey
+      };
+      r = a.resolve?.(i) ?? "retry";
+      break;
+    }
+  }
+  if (r === "skip")
+    return t.removeQueueItem(e.id), d({
+      type: "remove",
+      id: e.id
+    }), await c().remove(e.id), "conflicted";
+  r && typeof r == "object" && (e.args = r.resolved, t.updateQueueItem(e.id, { args: r.resolved }), d({
+    type: "update",
+    id: e.id,
+    update: { args: r.resolved }
+  }), await c().update(e.id, { args: r.resolved }));
+}
+async function P(e, t, o) {
+  const a = e.retryCount + 1;
+  if (a >= e.maxRetries) {
+    const i = {
+      status: "failed",
+      error: String(o),
+      retryCount: a
+    };
+    t.updateQueueItem(e.id, i), d({
+      type: "update",
+      id: e.id,
+      update: i
+    }), await c().update(e.id, i);
+    const n = {
+      idempotencyKey: e.idempotencyKey,
+      attempt: a
+    };
+    return k.get(e.actionId)?.(...e.args, n), "failed";
+  }
+  const r = {
+    status: "pending",
+    retryCount: a,
+    nextRetryAt: Date.now() + M(a)
+  };
+  return t.updateQueueItem(e.id, r), d({
+    type: "update",
+    id: e.id,
+    update: r
+  }), await c().update(e.id, r), "retrying";
+}
+async function D(e, t) {
+  const o = m.get(e.actionId);
+  if (!o) return "skipped";
   const a = x.get(e.actionId)?.cancellable;
-  let c;
+  let r;
   if (a) {
     const n = new AbortController();
-    p.set(e.idempotencyKey, n), c = n.signal;
+    y.set(e.idempotencyKey, n), r = n.signal;
   }
-  const r = {
+  const i = {
     idempotencyKey: e.idempotencyKey,
     attempt: e.retryCount,
-    signal: c
+    signal: r
   };
   try {
-    await v(i, e.args, r);
-    const n = Date.now();
-    return t.updateQueueItem(e.id, {
-      status: "succeeded",
-      completedAt: n
-    }), await u().update(e.id, {
-      status: "succeeded",
-      completedAt: n
-    }), setTimeout(() => {
-      t.removeQueueItem(e.id), u().remove(e.id);
-    }, 3e3), "succeeded";
+    return await h(o, e.args, i), await q(e, t), "succeeded";
   } catch (n) {
-    if (A(n))
-      return t.removeQueueItem(e.id), await u().remove(e.id), "cancelled";
+    if (C(n))
+      return t.removeQueueItem(e.id), d({
+        type: "remove",
+        id: e.id
+      }), await c().remove(e.id), "cancelled";
     if (K(n)) {
-      const l = Q.get(e.actionId);
-      let o;
-      if (l) switch (l.strategy) {
-        case "serverWins":
-          o = "skip";
-          break;
-        case "clientWins":
-        case "lastWriteWins":
-          o = "retry";
-          break;
-        case "merge":
-        case "custom": {
-          const d = {
-            error: n,
-            args: e.args,
-            attempt: e.retryCount,
-            idempotencyKey: e.idempotencyKey
-          };
-          o = l.resolve?.(d) ?? "retry";
-          break;
-        }
-      }
-      else {
-        const d = C.get(e.actionId);
-        d && (o = d(n, e.args));
-      }
-      if (o === "skip")
-        return t.removeQueueItem(e.id), await u().remove(e.id), "conflicted";
-      o && typeof o == "object" && (e.args = o.resolved, t.updateQueueItem(e.id, { args: o.resolved }), await u().update(e.id, { args: o.resolved }));
-    }
-    const s = e.retryCount + 1;
-    if (s >= e.maxRetries)
-      return t.updateQueueItem(e.id, {
-        status: "failed",
-        error: String(n),
-        retryCount: s
-      }), await u().update(e.id, {
-        status: "failed",
-        error: String(n),
-        retryCount: s
-      }), k.get(e.actionId)?.(...e.args), "failed";
-    {
-      const l = Date.now() + O(s);
-      return t.updateQueueItem(e.id, {
-        status: "pending",
-        retryCount: s,
-        nextRetryAt: l
-      }), await u().update(e.id, {
-        status: "pending",
-        retryCount: s,
-        nextRetryAt: l
-      }), "retrying";
+      const s = await E(e, t, n);
+      if (s) return s;
     }
+    return P(e, t, n);
   } finally {
-    a && p.delete(e.idempotencyKey);
+    a && y.delete(e.idempotencyKey);
   }
 }
-async function D(e, t, i) {
+async function j(e, t, o) {
   if (e.length === 0) return;
-  const a = e.filter((r) => h.has(r.actionId));
-  if (i.skipped += e.length - a.length, a.length > 0) {
-    t.batchUpdateQueueItems(a.map((r) => ({
-      id: r.id,
+  const a = e.filter((i) => m.has(i.actionId));
+  if (o.skipped += e.length - a.length, a.length > 0) {
+    const i = a.map((n) => ({
+      id: n.id,
       update: { status: "replaying" }
-    })));
-    for (const r of a) u().update(r.id, { status: "replaying" });
+    }));
+    t.batchUpdateQueueItems(i), d({
+      type: "batchUpdate",
+      updates: i
+    });
+    for (const n of a) c().update(n.id, { status: "replaying" });
   }
-  const c = await Promise.allSettled(a.map((r) => E(r, t)));
-  for (const r of c) {
-    const n = r.status === "fulfilled" ? r.value : "failed";
-    n === "skipped" ? i.skipped++ : n === "conflicted" ? i.conflicted++ : n === "cancelled" ? i.cancelled++ : (i.attempted++, i[n]++);
+  const r = await Promise.allSettled(a.map((i) => D(i, t)));
+  for (const i of r) {
+    const n = i.status === "fulfilled" ? i.value : "failed";
+    n === "skipped" ? o.skipped++ : n === "conflicted" ? o.conflicted++ : n === "cancelled" ? o.cancelled++ : (o.attempted++, o[n]++);
   }
 }
 async function I(e) {
-  const t = await u().getPending(), i = Date.now(), a = t.filter((r) => r.retryCount < r.maxRetries && (!r.nextRetryAt || r.nextRetryAt <= i)), c = w();
-  for (const r of [
+  const t = await c().getPending(), o = Date.now(), a = t.filter((i) => i.retryCount < i.maxRetries && (!i.nextRetryAt || i.nextRetryAt <= o)), r = g();
+  for (const i of [
     "high",
     "normal",
     "low"
-  ]) await D(a.filter((n) => (n.priority ?? "normal") === r), e, c);
-  return c;
+  ]) await j(a.filter((n) => (n.priority ?? "normal") === i), e, r);
+  return r;
 }
-async function T() {
-  await u().clear(), y.getState().hydrateQueue([]);
+async function Y() {
+  await c().clear(), f.getState().hydrateQueue([]);
 }
 export {
-  U as action,
-  T as clearQueue,
-  $ as replayQueue
+  F as action,
+  Y as clearQueue,
+  V as replayQueue
 };
 
 //# sourceMappingURL=action.js.map

package/dist/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":[],"sources":["../src/action.ts"],"sourcesContent":["import { useEidosStore } from './store';\nimport { getSwRegistration } from './sw-bridge';\nimport { idbQueueStorage } from './idb';\nimport { _getQueueStorage } from './queue-storage';\nimport { broadcastQueueSync } from './queue-sync';\nimport type { QueueStorage } from './queue-storage';\nimport { CURRENT_QUEUE_SCHEMA_VERSION } from './types';\nimport type {\n  ActionConfig,\n  ActionContext,\n  ActionHandle,\n  ActionFn,\n  ActionQueueItem,\n  ConflictConfig,\n  ConflictContext,\n  ConflictResolution,\n  QueuedResult,\n  ReplayResult,\n} from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _actionRegistry = new Map<string, ActionFn<any[], any>>();\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _rollbackRegistry = new Map<string, (...args: any[]) => void>();\nconst _conflictConfigRegistry = new Map<string, ConflictConfig>();\nconst _configRegistry = new Map<string, ActionConfig>();\n\n// In-flight AbortControllers for `cancellable` actions, keyed by idempotencyKey.\n// Populated for direct calls and replays alike; removed once the call settles.\nconst _inflightControllers = new Map<string, AbortController>();\n\nfunction qs(): QueueStorage {\n  // idbQueueStorage is the default browser fallback when no custom storage is set.\n  return _getQueueStorage() ?? idbQueueStorage;\n}\n\nfunction uid() {\n  return crypto.randomUUID();\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callWithContext<TArgs extends any[], TReturn>(\n  fn: ActionFn<TArgs, TReturn>,\n  args: TArgs,\n  ctx: ActionContext,\n): Promise<TReturn> {\n  return fn(...args, ctx);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function action<TArgs extends any[], TReturn>(\n  fn: ActionFn<TArgs, TReturn>,\n  config: ActionConfig<TArgs>,\n): ActionHandle<TArgs, TReturn> {\n  // || not ?? — fn.name can be '' (anonymous arrow fn) which ?? treats as a\n  // valid value, causing all anonymous actions to share actionId ''.\n  const baseId = config.name || fn.name || uid();\n  const actionId = config.namespace ? `${config.namespace}::${baseId}` : baseId;\n\n  if (import.meta.env.DEV && config.reliability === 'neverLose' && !config.name && !fn.name) {\n    console.warn(\n      `[eidos] action() registered with neverLose but no stable name was found (fn.name=\"${fn.name}\"). Pass config.name so queued items survive a page reload and can be replayed.`,\n    );\n  }\n\n  if (_actionRegistry.has(actionId)) {\n    throw new Error(\n      `[eidos] duplicate action id \"${actionId}\" — an action with this id is already registered. Pass a unique config.name or config.namespace.`,\n    );\n  }\n\n  // Registering here means the function is available for replay after\n  // the user refreshes the page (actions are defined at module scope).\n  _actionRegistry.set(actionId, fn as ActionFn<unknown[], unknown>);\n  _configRegistry.set(actionId, config as ActionConfig);\n\n  if (config.onRollback) {\n    _rollbackRegistry.set(actionId, config.onRollback);\n  }\n\n  if (config.conflict) {\n    if (\n      import.meta.env.DEV &&\n      (config.conflict.strategy === 'merge' || config.conflict.strategy === 'custom') &&\n      !config.conflict.resolve\n    ) {\n      console.error(\n        `[eidos] action \"${actionId}\" has conflict.strategy \"${config.conflict.strategy}\" but no resolve() — items will retry indefinitely on 4xx.`,\n      );\n    }\n    _conflictConfigRegistry.set(actionId, config.conflict);\n  }\n\n  const wrapped = async (...args: TArgs): Promise<TReturn | QueuedResult> => {\n    const { isOnline } = useEidosStore.getState();\n\n    // Generated for every invocation — reused across every retry/replay of a\n    // neverLose item, and used to key handle.cancel() for in-flight cancellable calls.\n    const idempotencyKey = uid();\n\n    let signal: AbortSignal | undefined;\n    if (config.cancellable) {\n      const controller = new AbortController();\n      _inflightControllers.set(idempotencyKey, controller);\n      signal = controller.signal;\n    }\n\n    const ctx: ActionContext = { idempotencyKey, attempt: 0, signal };\n\n    config.onOptimistic?.(...args, ctx);\n\n    try {\n      if (config.reliability === 'neverLose') {\n        if (!isOnline) {\n          return persistAndQueue(actionId, actionId, args, config, idempotencyKey);\n        }\n        // Online + neverLose: execute, queue on failure\n        try {\n          return await callWithContext(fn, args, ctx);\n        } catch (err) {\n          if (isAbortError(err)) throw err;\n          return persistAndQueue(actionId, actionId, args, config, idempotencyKey);\n        }\n      }\n\n      // best-effort: execute directly, rollback on failure\n      try {\n        return await callWithContext(fn, args, ctx);\n      } catch (err) {\n        config.onRollback?.(...args, ctx);\n        throw err;\n      }\n    } finally {\n      if (config.cancellable) _inflightControllers.delete(idempotencyKey);\n    }\n  };\n\n  const cancel = async (idempotencyKey: string): Promise<boolean> => {\n    const controller = _inflightControllers.get(idempotencyKey);\n    if (controller) {\n      controller.abort();\n      return true;\n    }\n\n    // Not in flight — check for a not-yet-replayed queued item with this key.\n    const items = await qs().getAll();\n    const item = items.find((i) => i.idempotencyKey === idempotencyKey && i.status === 'pending');\n    if (!item) return false;\n\n    useEidosStore.getState().removeQueueItem(item.id);\n    broadcastQueueSync({ type: 'remove', id: item.id });\n    await qs().remove(item.id);\n    return true;\n  };\n\n  Object.defineProperty(wrapped, 'id', { value: actionId, writable: false });\n  Object.defineProperty(wrapped, 'config', { value: config, writable: false });\n  Object.defineProperty(wrapped, 'cancel', { value: cancel, writable: false });\n\n  return wrapped as unknown as ActionHandle<TArgs, TReturn>;\n}\n\nfunction isJsonSerializable(value: unknown): boolean {\n  try {\n    JSON.stringify(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nasync function persistAndQueue<TArgs extends any[]>(\n  actionId: string,\n  actionName: string,\n  args: TArgs,\n  config: ActionConfig<TArgs>,\n  idempotencyKey: string,\n): Promise<QueuedResult> {\n  if (import.meta.env.DEV && !isJsonSerializable(args)) {\n    console.warn(\n      `[eidos] action \"${actionName}\" queued with non-JSON-serializable args. These args will be lost after a page reload. Use plain JSON values for neverLose actions.`,\n      args,\n    );\n  }\n\n  const id = uid();\n  const item: ActionQueueItem = {\n    schemaVersion: CURRENT_QUEUE_SCHEMA_VERSION,\n    id,\n    actionId,\n    actionName,\n    idempotencyKey,\n    args,\n    queuedAt: Date.now(),\n    retryCount: 0,\n    maxRetries: config.maxRetries ?? 3,\n    status: 'pending',\n    priority: config.priority ?? 'normal',\n  };\n\n  await qs().add(item);\n  useEidosStore.getState().addQueueItem(item);\n\n  // Register Background Sync tag so the browser can wake up open clients\n  // when connectivity returns, even if the user navigated away briefly.\n  // Graceful no-op when Background Sync is unsupported.\n  try {\n    const reg = getSwRegistration();\n    if (reg && 'sync' in reg) {\n      await (reg as unknown as { sync: { register(tag: string): Promise<void> } }).sync.register(\n        'eidos-queue-replay',\n      );\n    }\n  } catch {\n    // Background Sync not available — online-event replay remains the fallback\n  }\n\n  return {\n    queued: true,\n    id,\n    message: `\"${actionName}\" queued — will execute when online`,\n  };\n}\n\nfunction isAbortError(err: unknown): boolean {\n  return err instanceof DOMException && err.name === 'AbortError';\n}\n\nfunction isClientError(err: unknown): boolean {\n  if (err instanceof Response) return err.status >= 400 && err.status < 500;\n  if (typeof err === 'object' && err !== null) {\n    const s = (err as Record<string, unknown>).status;\n    if (typeof s === 'number') return s >= 400 && s < 500;\n  }\n  return false;\n}\n\n// Base delay 2s, doubles per retry, capped at 5 minutes, ±20% jitter\nfunction backoffMs(retryCount: number): number {\n  const base = Math.min(2000 * 2 ** retryCount, 300_000);\n  return base * (0.8 + Math.random() * 0.4);\n}\n\nfunction emptyReplayResult(): ReplayResult {\n  return {\n    attempted: 0,\n    succeeded: 0,\n    failed: 0,\n    retrying: 0,\n    skipped: 0,\n    conflicted: 0,\n    cancelled: 0,\n  };\n}\n\nlet _replaying = false;\nconst REPLAY_LOCK_NAME = 'eidos-queue-replay';\n\nexport async function replayQueue(): Promise<ReplayResult> {\n  const store = useEidosStore.getState();\n  if (!store.isOnline) return emptyReplayResult();\n\n  // Web Locks coordinate replay across tabs sharing the same IndexedDB queue —\n  // only the lock holder replays; other tabs no-op rather than re-executing\n  // the same queued actions in parallel.\n  if (typeof navigator !== 'undefined' && navigator.locks) {\n    return navigator.locks.request(REPLAY_LOCK_NAME, { ifAvailable: true }, async (lock) => {\n      if (!lock) return emptyReplayResult();\n      return _doReplayQueue(store);\n    });\n  }\n\n  // Fallback for environments without the Web Locks API (older Safari, React\n  // Native, test runners) — guards against concurrent replay within this tab only.\n  if (_replaying) return emptyReplayResult();\n  _replaying = true;\n  try {\n    return await _doReplayQueue(store);\n  } finally {\n    _replaying = false;\n  }\n}\n\ntype ItemOutcome = 'succeeded' | 'failed' | 'retrying' | 'skipped' | 'conflicted' | 'cancelled';\n\nasync function _markSucceeded(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n): Promise<void> {\n  const completedAt = Date.now();\n  store.updateQueueItem(item.id, { status: 'succeeded', completedAt });\n  broadcastQueueSync({ type: 'update', id: item.id, update: { status: 'succeeded', completedAt } });\n  await qs().update(item.id, { status: 'succeeded', completedAt });\n\n  // Remove from queue after a short delay so UI can show the success state briefly\n  setTimeout(() => {\n    store.removeQueueItem(item.id);\n    broadcastQueueSync({ type: 'remove', id: item.id });\n    qs().remove(item.id);\n  }, 3000);\n}\n\n/**\n * Resolves a 4xx error against the action's conflict strategy.\n * Returns 'conflicted' if the item was dropped, undefined if normal\n * retry/fail logic should run (possibly with `item.args` rewritten by `merge`).\n */\nasync function _resolveConflict(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n  err: unknown,\n): Promise<ItemOutcome | undefined> {\n  const conflictConfig = _conflictConfigRegistry.get(item.actionId);\n  let resolution: ConflictResolution | undefined;\n\n  if (conflictConfig) {\n    switch (conflictConfig.strategy) {\n      case 'serverWins':\n        resolution = 'skip';\n        break;\n      case 'clientWins':\n        resolution = 'retry';\n        break;\n      case 'merge':\n      case 'custom': {\n        const ctx: ConflictContext = {\n          error: err,\n          args: item.args as unknown[],\n          attempt: item.retryCount,\n          idempotencyKey: item.idempotencyKey,\n        };\n        resolution = conflictConfig.resolve?.(ctx) ?? 'retry';\n        break;\n      }\n    }\n  }\n\n  if (resolution === 'skip') {\n    store.removeQueueItem(item.id);\n    broadcastQueueSync({ type: 'remove', id: item.id });\n    await qs().remove(item.id);\n    return 'conflicted';\n  }\n  if (resolution && typeof resolution === 'object') {\n    item.args = resolution.resolved;\n    store.updateQueueItem(item.id, { args: resolution.resolved });\n    broadcastQueueSync({ type: 'update', id: item.id, update: { args: resolution.resolved } });\n    await qs().update(item.id, { args: resolution.resolved });\n  }\n  // 'retry' (or merged args) falls through to normal retry/fail logic\n  return undefined;\n}\n\nasync function _scheduleRetryOrFail(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n  err: unknown,\n): Promise<ItemOutcome> {\n  const retryCount = item.retryCount + 1;\n  if (retryCount >= item.maxRetries) {\n    const update = { status: 'failed' as const, error: String(err), retryCount };\n    store.updateQueueItem(item.id, update);\n    broadcastQueueSync({ type: 'update', id: item.id, update });\n    await qs().update(item.id, update);\n    const ctx: ActionContext = { idempotencyKey: item.idempotencyKey, attempt: retryCount };\n    _rollbackRegistry.get(item.actionId)?.(...(item.args as unknown[]), ctx);\n    return 'failed';\n  }\n\n  const nextRetryAt = Date.now() + backoffMs(retryCount);\n  const update = { status: 'pending' as const, retryCount, nextRetryAt };\n  store.updateQueueItem(item.id, update);\n  broadcastQueueSync({ type: 'update', id: item.id, update });\n  await qs().update(item.id, update);\n  return 'retrying';\n}\n\nasync function _replayItem(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n): Promise<ItemOutcome> {\n  const fn = _actionRegistry.get(item.actionId);\n  if (!fn) return 'skipped';\n\n  const cancellable = _configRegistry.get(item.actionId)?.cancellable;\n  let signal: AbortSignal | undefined;\n  if (cancellable) {\n    const controller = new AbortController();\n    _inflightControllers.set(item.idempotencyKey, controller);\n    signal = controller.signal;\n  }\n\n  const ctx: ActionContext = {\n    idempotencyKey: item.idempotencyKey,\n    attempt: item.retryCount,\n    signal,\n  };\n\n  try {\n    await callWithContext(fn, item.args as unknown[], ctx);\n    await _markSucceeded(item, store);\n    return 'succeeded';\n  } catch (err) {\n    // Cancelled via handle.cancel(idempotencyKey) — drop the item, no rollback/retry.\n    if (isAbortError(err)) {\n      store.removeQueueItem(item.id);\n      broadcastQueueSync({ type: 'remove', id: item.id });\n      await qs().remove(item.id);\n      return 'cancelled';\n    }\n\n    // 4xx: give the conflict strategy a chance to decide before normal retry/fail logic\n    if (isClientError(err)) {\n      const outcome = await _resolveConflict(item, store, err);\n      if (outcome) return outcome;\n    }\n\n    return _scheduleRetryOrFail(item, store, err);\n  } finally {\n    if (cancellable) _inflightControllers.delete(item.idempotencyKey);\n  }\n}\n\nasync function _replayTier(\n  items: ActionQueueItem[],\n  store: ReturnType<typeof useEidosStore.getState>,\n  result: ReplayResult,\n): Promise<void> {\n  if (items.length === 0) return;\n\n  // Batch 'replaying' status update — N items → 1 store notify.\n  // IDB write is fire-and-forget: on reload items stay 'pending', safe to re-replay.\n  const replayable = items.filter((item) => _actionRegistry.has(item.actionId));\n  result.skipped += items.length - replayable.length;\n\n  if (replayable.length > 0) {\n    const updates = replayable.map((item) => ({\n      id: item.id,\n      update: { status: 'replaying' as const },\n    }));\n    store.batchUpdateQueueItems(updates);\n    broadcastQueueSync({ type: 'batchUpdate', updates });\n    for (const item of replayable) {\n      qs().update(item.id, { status: 'replaying' });\n    }\n  }\n\n  const outcomes = await Promise.allSettled(replayable.map((item) => _replayItem(item, store)));\n\n  for (const o of outcomes) {\n    const outcome = o.status === 'fulfilled' ? o.value : 'failed';\n    if (outcome === 'skipped') {\n      result.skipped++;\n    } else if (outcome === 'conflicted') {\n      result.conflicted++;\n    } else if (outcome === 'cancelled') {\n      result.cancelled++;\n    } else {\n      result.attempted++;\n      result[outcome]++;\n    }\n  }\n}\n\nasync function _doReplayQueue(\n  store: ReturnType<typeof useEidosStore.getState>,\n): Promise<ReplayResult> {\n  const candidates = await qs().getPending();\n  const now = Date.now();\n  // getPending() includes 'failed' items (for UI/queue-stats visibility), but\n  // items that already exhausted maxRetries must not be auto-replayed again —\n  // otherwise every reconnect re-executes the action and re-fires onRollback.\n  // Those items stay 'failed' until the host app explicitly clears/re-queues them.\n  const pending = candidates.filter(\n    (item) => item.retryCount < item.maxRetries && (!item.nextRetryAt || item.nextRetryAt <= now),\n  );\n\n  const result: ReplayResult = emptyReplayResult();\n\n  // Process tiers sequentially: high items complete before normal, normal before low.\n  // Within each tier items run in parallel via Promise.allSettled.\n  for (const tier of ['high', 'normal', 'low'] as const) {\n    const tierItems = pending.filter((item) => (item.priority ?? 'normal') === tier);\n    await _replayTier(tierItems, store, result);\n  }\n\n  return result;\n}\n\n/** Remove all items from the action queue (storage + in-memory store). */\nexport async function clearQueue(): Promise<void> {\n  await qs().clear();\n  useEidosStore.getState().hydrateQueue([]);\n}\n"],"mappings":"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"}

package/dist/async-storage-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-storage-adapter.js","names":[],"sources":["../src/async-storage-adapter.ts"],"sourcesContent":["import type { ActionQueueItem } from './types';\nimport type { QueueStorage } from './queue-storage';\n\n/** Minimal subset of @react-native-async-storage/async-storage (or any compatible key-value store). */\nexport interface AsyncStorageLike {\n  getItem(key: string): Promise<string | null>;\n  setItem(key: string, value: string): Promise<void>;\n  removeItem(key: string): Promise<void>;\n}\n\nconst QUEUE_KEY = '@eidos:queue';\n\n/**\n * QueueStorage implementation backed by any AsyncStorage-compatible API.\n * Pass the AsyncStorage singleton from @react-native-async-storage/async-storage\n * (or MMKV, SQLite, or any store that satisfies AsyncStorageLike).\n */\nexport class AsyncStorageQueueStorage implements QueueStorage {\n  constructor(private readonly storage: AsyncStorageLike) {}\n\n  private async readAll(): Promise<ActionQueueItem[]> {\n    try {\n      const raw = await this.storage.getItem(QUEUE_KEY);\n      if (!raw) return [];\n      return JSON.parse(raw) as ActionQueueItem[];\n    } catch {\n      return [];\n    }\n  }\n\n  private async writeAll(items: ActionQueueItem[]): Promise<void> {\n    await this.storage.setItem(QUEUE_KEY, JSON.stringify(items));\n  }\n\n  async add(item: ActionQueueItem): Promise<void> {\n    const items = await this.readAll();\n    items.push(item);\n    await this.writeAll(items);\n  }\n\n  async getAll(): Promise<ActionQueueItem[]> {\n    return this.readAll();\n  }\n\n  async getPending(): Promise<ActionQueueItem[]> {\n    const items = await this.readAll();\n    return items.filter((i) => i.status === 'pending' || i.status === 'failed');\n  }\n\n  async update(id: string, patch: Partial<ActionQueueItem>): Promise<void> {\n    const items = await this.readAll();\n    const idx = items.findIndex((i) => i.id === id);\n    if (idx !== -1) items[idx] = { ...items[idx], ...patch };\n    await this.writeAll(items);\n  }\n\n  async remove(id: string): Promise<void> {\n    const items = await this.readAll();\n    await this.writeAll(items.filter((i) => i.id !== id));\n  }\n\n  async clear(): Promise<void> {\n    await this.storage.removeItem(QUEUE_KEY);\n  }\n}\n"],"mappings":"AAUA,IAAM,IAAY,gBAOL,IAAb,MAA8D;AAAA,EAC5D,YAAY,GAA4C;AAA3B,SAAA,UAAA;AAAA,EAA4B;AAAA,EAEzD,MAAc,UAAsC;AAClD,QAAI;AACF,YAAM,IAAM,MAAM,KAAK,QAAQ,QAAQ,CAAS;AAChD,aAAK,IACE,KAAK,MAAM,CAAG,IADJ,CAAC;AAAA,IAEpB,QAAQ;AACN,aAAO,CAAC;AAAA,IACV;AAAA,EACF;AAAA,EAEA,MAAc,SAAS,GAAyC;AAC9D,UAAM,KAAK,QAAQ,QAAQ,GAAW,KAAK,UAAU,CAAK,CAAC;AAAA,EAC7D;AAAA,EAEA,MAAM,IAAI,GAAsC;AAC9C,UAAM,IAAQ,MAAM,KAAK,QAAQ;AACjC,IAAA,EAAM,KAAK,CAAI,GACf,MAAM,KAAK,SAAS,CAAK;AAAA,EAC3B;AAAA,EAEA,MAAM,SAAqC;AACzC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,MAAM,aAAyC;AAE7C,YAAO,MADa,KAAK,QAAQ,GACpB,OAAA,CAAQ,MAAM,EAAE,WAAW,aAAa,EAAE,WAAW,QAAQ;AAAA,EAC5E;AAAA,EAEA,MAAM,OAAO,GAAY,GAAgD;AACvE,UAAM,IAAQ,MAAM,KAAK,QAAQ,GAC3B,IAAM,EAAM,UAAA,CAAW,MAAM,EAAE,OAAO,CAAE;AAC9C,IAAI,MAAQ,OAAI,EAAM,CAAA,IAAO;AAAA,MAAE,GAAG,EAAM,CAAA;AAAA,MAAM,GAAG;AAAA,IAAM,IACvD,MAAM,KAAK,SAAS,CAAK;AAAA,EAC3B;AAAA,EAEA,MAAM,OAAO,GAA2B;AACtC,UAAM,IAAQ,MAAM,KAAK,QAAQ;AACjC,UAAM,KAAK,SAAS,EAAM,OAAA,CAAQ,MAAM,EAAE,OAAO,CAAE,CAAC;AAAA,EACtD;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,QAAQ,WAAW,CAAS;AAAA,EACzC;AACF"}