@sweidos/eidos 1.2.0 → 2.1.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.                                        |
 
 ---
 
@@ -158,6 +160,9 @@ const products = resource('/api/products', {
   strategy?: 'cache-first' | 'stale-while-revalidate' | 'network-first',
   cacheName?: string, // custom cache bucket
   maxAge?: number,    // TTL in ms — re-fetch after expiry
+  version?: string | number, // bump when the response shape changes —
+                              // appended to cacheName (e.g. 'eidos-resources-v1-v2')
+                              // so old-shaped cache entries aren't served
 })
 
 await products.fetch()          // Promise<Response>
@@ -175,20 +180,47 @@ 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.
+
+// Module-level helpers (used by the devtools queue inspector, and usable
+// directly): cancel/remove a queue item by idempotency key, or reset a
+// 'failed' item back to 'pending' for the next replayQueue().
+import { cancelByIdempotencyKey, requeueItem } from '@sweidos/eidos'
+await cancelByIdempotencyKey(idempotencyKey) // true if cancelled/removed
+await requeueItem(queueItemId)               // true if it was 'failed'
 ```
 
 ### React hooks
@@ -389,21 +421,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.3 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,86 +1,107 @@
-import { useEidosStore as y } 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 { useEidosStore as l } from "./store.js";
+import { getSwRegistration as A } from "./sw-bridge.js";
+import { idbQueueStorage as C } from "./idb.js";
+import { _getQueueStorage as _ } from "./queue-storage.js";
+import { broadcastQueueSync as u } from "./queue-sync.js";
+var w = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+function c() {
+  return _() ?? C;
 }
 function m() {
   return crypto.randomUUID();
 }
-function v(e, t, i) {
-  return e(...t, i);
+function v(e, t, n) {
+  return e(...t, n);
 }
-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 B(e, t) {
+  const n = t.name || e.name || m(), a = t.namespace ? `${t.namespace}::${n}` : n;
+  if (w.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.`);
+  w.set(a, e), k.set(a, t), t.onRollback && R.set(a, t.onRollback), t.conflict && Q.set(a, t.conflict);
+  const i = async (...r) => {
+    const { isOnline: o } = l.getState(), s = m();
+    let b;
     if (t.cancellable) {
-      const f = new AbortController();
-      p.set(o, f), d = f.signal;
+      const d = new AbortController();
+      p.set(s, d), b = d.signal;
     }
-    const g = {
-      idempotencyKey: o,
+    const y = {
+      idempotencyKey: s,
       attempt: 0,
-      signal: d
+      signal: b
     };
-    t.onOptimistic?.(...n, g);
+    t.onOptimistic?.(...r, y);
     try {
       if (t.reliability === "neverLose") {
-        if (!s) return R(a, a, n, t, o);
+        if (!o) return h(a, a, r, t, s);
         try {
-          return await v(e, n, g);
-        } catch (f) {
-          if (A(f)) throw f;
-          return R(a, a, n, t, o);
+          return await v(e, r, y);
+        } catch (d) {
+          if (x(d)) throw d;
+          return h(a, a, r, t, s);
         }
       }
       try {
-        return l ? await v(e, n, g) : await e(...n);
-      } catch (f) {
-        throw t.onRollback?.(...n), f;
+        return await v(e, r, y);
+      } catch (d) {
+        throw t.onRollback?.(...r, y), d;
       }
     } finally {
-      t.cancellable && p.delete(o);
+      t.cancellable && p.delete(s);
     }
-  }, r = async (n) => {
-    const s = p.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;
   };
-  return Object.defineProperty(c, "id", {
+  return Object.defineProperty(i, "id", {
     value: a,
     writable: !1
-  }), Object.defineProperty(c, "config", {
+  }), Object.defineProperty(i, "config", {
     value: t,
     writable: !1
-  }), Object.defineProperty(c, "cancel", {
-    value: r,
+  }), Object.defineProperty(i, "cancel", {
+    value: S,
     writable: !1
-  }), c;
+  }), i;
 }
-async function R(e, t, i, a, c) {
-  const r = m(), n = {
+async function S(e) {
+  const t = p.get(e);
+  if (t)
+    return t.abort(), !0;
+  const n = (await c().getAll()).find((a) => a.idempotencyKey === e && a.status === "pending");
+  return n ? (l.getState().removeQueueItem(n.id), u({
+    type: "remove",
+    id: n.id
+  }), await c().remove(n.id), !0) : !1;
+}
+async function F(e) {
+  const t = (await c().getAll()).find((a) => a.id === e);
+  if (!t || t.status !== "failed") return !1;
+  const n = {
+    status: "pending",
+    error: void 0,
+    nextRetryAt: void 0,
+    retryCount: 0
+  };
+  return l.getState().updateQueueItem(e, n), u({
+    type: "update",
+    id: e,
+    update: n
+  }), await c().update(e, n), !0;
+}
+async function h(e, t, n, a, i) {
+  const r = m(), o = {
     schemaVersion: 2,
     id: r,
     actionId: e,
     actionName: t,
-    idempotencyKey: c,
-    args: i,
+    idempotencyKey: i,
+    args: n,
     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(o), l.getState().addQueueItem(o);
   try {
-    const s = _();
+    const s = A();
     s && "sync" in s && await s.sync.register("eidos-queue-replay");
   } catch {
   }
@@ -90,7 +111,7 @@ async function R(e, t, i, a, c) {
     message: `"${t}" queued — will execute when online`
   };
 }
-function A(e) {
+function x(e) {
   return e instanceof DOMException && e.name === "AbortError";
 }
 function K(e) {
@@ -101,10 +122,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 f() {
   return {
     attempted: 0,
     succeeded: 0,
@@ -115,138 +136,173 @@ 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 g = !1, q = "eidos-queue-replay";
+async function V() {
+  const e = l.getState();
+  if (!e.isOnline) return f();
+  if (typeof navigator < "u" && navigator.locks) return navigator.locks.request(q, { ifAvailable: !0 }, async (t) => t ? I(e) : f());
+  if (g) return f();
+  g = !0;
   try {
     return await I(e);
   } finally {
-    b = !1;
+    g = !1;
   }
 }
-async function E(e, t) {
-  const i = h.get(e.actionId);
-  if (!i) return "skipped";
-  const a = x.get(e.actionId)?.cancellable;
-  let c;
+async function O(e, t) {
+  const n = Date.now();
+  t.updateQueueItem(e.id, {
+    status: "succeeded",
+    completedAt: n
+  }), u({
+    type: "update",
+    id: e.id,
+    update: {
+      status: "succeeded",
+      completedAt: n
+    }
+  }), await c().update(e.id, {
+    status: "succeeded",
+    completedAt: n
+  }), setTimeout(() => {
+    t.removeQueueItem(e.id), u({
+      type: "remove",
+      id: e.id
+    }), c().remove(e.id);
+  }, 3e3);
+}
+async function E(e, t, n) {
+  const a = Q.get(e.actionId);
+  let i;
+  if (a) switch (a.strategy) {
+    case "serverWins":
+      i = "skip";
+      break;
+    case "clientWins":
+      i = "retry";
+      break;
+    case "merge":
+    case "custom": {
+      const r = {
+        error: n,
+        args: e.args,
+        attempt: e.retryCount,
+        idempotencyKey: e.idempotencyKey
+      };
+      i = a.resolve?.(r) ?? "retry";
+      break;
+    }
+  }
+  if (i === "skip")
+    return t.removeQueueItem(e.id), u({
+      type: "remove",
+      id: e.id
+    }), await c().remove(e.id), "conflicted";
+  i && typeof i == "object" && (e.args = i.resolved, t.updateQueueItem(e.id, { args: i.resolved }), u({
+    type: "update",
+    id: e.id,
+    update: { args: i.resolved }
+  }), await c().update(e.id, { args: i.resolved }));
+}
+async function P(e, t, n) {
+  const a = e.retryCount + 1;
+  if (a >= e.maxRetries) {
+    const r = {
+      status: "failed",
+      error: String(n),
+      retryCount: a
+    };
+    t.updateQueueItem(e.id, r), u({
+      type: "update",
+      id: e.id,
+      update: r
+    }), await c().update(e.id, r);
+    const o = {
+      idempotencyKey: e.idempotencyKey,
+      attempt: a
+    };
+    return R.get(e.actionId)?.(...e.args, o), "failed";
+  }
+  const i = {
+    status: "pending",
+    retryCount: a,
+    nextRetryAt: Date.now() + M(a)
+  };
+  return t.updateQueueItem(e.id, i), u({
+    type: "update",
+    id: e.id,
+    update: i
+  }), await c().update(e.id, i), "retrying";
+}
+async function D(e, t) {
+  const n = w.get(e.actionId);
+  if (!n) return "skipped";
+  const a = k.get(e.actionId)?.cancellable;
+  let i;
   if (a) {
-    const n = new AbortController();
-    p.set(e.idempotencyKey, n), c = n.signal;
+    const o = new AbortController();
+    p.set(e.idempotencyKey, o), i = o.signal;
   }
   const r = {
     idempotencyKey: e.idempotencyKey,
     attempt: e.retryCount,
-    signal: c
+    signal: i
   };
   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";
-  } catch (n) {
-    if (A(n))
-      return t.removeQueueItem(e.id), await u().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";
+    return await v(n, e.args, r), await O(e, t), "succeeded";
+  } catch (o) {
+    if (x(o))
+      return t.removeQueueItem(e.id), u({
+        type: "remove",
+        id: e.id
+      }), await c().remove(e.id), "cancelled";
+    if (K(o)) {
+      const s = await E(e, t, o);
+      if (s) return s;
     }
+    return P(e, t, o);
   } finally {
     a && p.delete(e.idempotencyKey);
   }
 }
-async function D(e, t, i) {
+async function j(e, t, n) {
   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((r) => w.has(r.actionId));
+  if (n.skipped += e.length - a.length, a.length > 0) {
+    const r = a.map((o) => ({
+      id: o.id,
       update: { status: "replaying" }
-    })));
-    for (const r of a) u().update(r.id, { status: "replaying" });
+    }));
+    t.batchUpdateQueueItems(r), u({
+      type: "batchUpdate",
+      updates: r
+    });
+    for (const o of a) c().update(o.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 i = await Promise.allSettled(a.map((r) => D(r, t)));
+  for (const r of i) {
+    const o = r.status === "fulfilled" ? r.value : "failed";
+    o === "skipped" ? n.skipped++ : o === "conflicted" ? n.conflicted++ : o === "cancelled" ? n.cancelled++ : (n.attempted++, n[o]++);
   }
 }
 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();
+  const t = await c().getPending(), n = Date.now(), a = t.filter((r) => r.retryCount < r.maxRetries && (!r.nextRetryAt || r.nextRetryAt <= n)), i = f();
   for (const r of [
     "high",
     "normal",
     "low"
-  ]) await D(a.filter((n) => (n.priority ?? "normal") === r), e, c);
-  return c;
+  ]) await j(a.filter((o) => (o.priority ?? "normal") === r), e, i);
+  return i;
 }
-async function T() {
-  await u().clear(), y.getState().hydrateQueue([]);
+async function Y() {
+  await c().clear(), l.getState().hydrateQueue([]);
 }
 export {
-  U as action,
-  T as clearQueue,
-  $ as replayQueue
+  B as action,
+  S as cancelByIdempotencyKey,
+  Y as clearQueue,
+  V as replayQueue,
+  F as requeueItem
 };
 
 //# sourceMappingURL=action.js.map