@sweidos/eidos 1.2.0 → 2.1.0

package/dist/push.cjs

@@ -1,5 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _sweidos_eidos = require("@sweidos/eidos");
+//#region src/internal/url-base64.ts
+/** Decodes a base64url string (e.g. a VAPID public key) into raw bytes. */
+function urlBase64ToUint8Array(base64Url) {
+	const base64 = (base64Url + "=".repeat((4 - base64Url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+	const raw = atob(base64);
+	return Uint8Array.from(raw, (c) => c.charCodeAt(0));
+}
+//#endregion
 //#region src/push.ts
 /**
 * @sweidos/eidos/push
@@ -94,11 +102,6 @@ async function getCurrentPushSubscription() {
 	const subscription = await registration.pushManager.getSubscription();
 	return subscription ? subscription.toJSON() : null;
 }
-function urlBase64ToUint8Array(base64Url) {
-	const base64 = (base64Url + "=".repeat((4 - base64Url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
-	const raw = atob(base64);
-	return Uint8Array.from(raw, (c) => c.charCodeAt(0));
-}
 function uint8ArrayToUrlBase64(bytes) {
 	let binary = "";
 	for (const byte of bytes) binary += String.fromCharCode(byte);

package/dist/push.js

@@ -1,4 +1,12 @@
 import { getSwRegistration, registerPushCallbacks, sendToWorker } from "@sweidos/eidos";
+//#region src/internal/url-base64.ts
+/** Decodes a base64url string (e.g. a VAPID public key) into raw bytes. */
+function urlBase64ToUint8Array(base64Url) {
+	const base64 = (base64Url + "=".repeat((4 - base64Url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+	const raw = atob(base64);
+	return Uint8Array.from(raw, (c) => c.charCodeAt(0));
+}
+//#endregion
 //#region src/push.ts
 /**
 * @sweidos/eidos/push
@@ -93,11 +101,6 @@ async function getCurrentPushSubscription() {
 	const subscription = await registration.pushManager.getSubscription();
 	return subscription ? subscription.toJSON() : null;
 }
-function urlBase64ToUint8Array(base64Url) {
-	const base64 = (base64Url + "=".repeat((4 - base64Url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
-	const raw = atob(base64);
-	return Uint8Array.from(raw, (c) => c.charCodeAt(0));
-}
 function uint8ArrayToUrlBase64(bytes) {
 	let binary = "";
 	for (const byte of bytes) binary += String.fromCharCode(byte);

package/dist/query.cjs

@@ -118,7 +118,7 @@ function useEidosMutation(handle, options) {
 			if (invalidates?.length) {
 				await Promise.all(invalidates.map((h) => h.invalidate()));
 				if (!_globalClient && contextClient) invalidates.forEach((h) => {
-					contextClient.invalidateQueries({ queryKey: h.query().queryKey });
+					contextClient.invalidateQueries({ queryKey: ["eidos", h.url] });
 				});
 			}
 			if (onSuccess) await onSuccess(...args);

package/dist/query.d.ts

@@ -1,5 +1,5 @@
 import { UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult, QueryClient } from '@tanstack/react-query';
-import { ResourceHandle, ActionHandle, QueuedResult } from '@sweidos/eidos';
+import { ResourceHandle, AnyResourceHandle, ActionHandle, QueuedResult } from '@sweidos/eidos';
 
 /**
  * Register a QueryClient with Eidos.
@@ -44,7 +44,6 @@ type EidosQueryOptions<T> = Omit<UseQueryOptions<T, Error, T, [string, string]>,
  * ```
  */
 export declare function useEidosQuery<T>(handle: ResourceHandle<T>, options?: EidosQueryOptions<T>): UseQueryResult<T, Error>;
-type AnyResourceHandle = ResourceHandle<any>;
 export interface EidosMutationOptions<TArg, TData> extends Omit<UseMutationOptions<TData | QueuedResult, Error, TArg>, 'mutationFn' | 'networkMode'> {
     /**
      * Resource handles to invalidate (Cache Storage + TanStack Query) after

package/dist/query.js

@@ -117,7 +117,7 @@ function useEidosMutation(handle, options) {
 			if (invalidates?.length) {
 				await Promise.all(invalidates.map((h) => h.invalidate()));
 				if (!_globalClient && contextClient) invalidates.forEach((h) => {
-					contextClient.invalidateQueries({ queryKey: h.query().queryKey });
+					contextClient.invalidateQueries({ queryKey: ["eidos", h.url] });
 				});
 			}
 			if (onSuccess) await onSuccess(...args);

package/dist/queue-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-storage.js","names":[],"sources":["../src/queue-storage.ts"],"sourcesContent":["import type { ActionQueueItem } from './types';\n\nexport interface QueueStorage {\n  add(item: ActionQueueItem): Promise<void>;\n  getAll(): Promise<ActionQueueItem[]>;\n  getPending(): Promise<ActionQueueItem[]>;\n  update(id: string, patch: Partial<ActionQueueItem>): Promise<void>;\n  remove(id: string): Promise<void>;\n  clear(): Promise<void>;\n}\n\nlet _storage: QueueStorage | null = null;\n\n/** Override the default IndexedDB queue with a custom storage backend (e.g. AsyncStorage for React Native). */\nexport function setQueueStorage(s: QueueStorage): void {\n  _storage = s;\n}\n\nexport function _getQueueStorage(): QueueStorage | null {\n  return _storage;\n}\n"],"mappings":"AAWA,IAAI,IAAgC;AAGpC,SAAgB,EAAgB,GAAuB;AACrD,EAAA,IAAW;AACb;AAEA,SAAgB,IAAwC;AACtD,SAAO;AACT"}

package/dist/queue-sync.js

@@ -0,0 +1,34 @@
+import { useEidosStore as o } from "./store.js";
+var c = "eidos-queue-sync", a;
+function r() {
+  return a !== void 0 || (a = typeof BroadcastChannel > "u" ? null : new BroadcastChannel(c)), a;
+}
+function i(e) {
+  r()?.postMessage(e);
+}
+function m() {
+  const e = r();
+  if (!e) return () => {
+  };
+  const s = (u) => {
+    const n = o.getState(), t = u.data;
+    switch (t.type) {
+      case "update":
+        n.updateQueueItem(t.id, t.update);
+        break;
+      case "batchUpdate":
+        n.batchUpdateQueueItems(t.updates);
+        break;
+      case "remove":
+        n.removeQueueItem(t.id);
+        break;
+    }
+  };
+  return e.addEventListener("message", s), () => e.removeEventListener("message", s);
+}
+export {
+  i as broadcastQueueSync,
+  m as subscribeQueueSync
+};
+
+//# sourceMappingURL=queue-sync.js.map

package/dist/queue-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-sync.js","names":[],"sources":["../src/queue-sync.ts"],"sourcesContent":["import { useEidosStore } from './store';\nimport type { ActionQueueItem } from './types';\n\nconst CHANNEL_NAME = 'eidos-queue-sync';\n\ntype QueueSyncMessage =\n  | { type: 'update'; id: string; update: Partial<ActionQueueItem> }\n  | { type: 'batchUpdate'; updates: Array<{ id: string; update: Partial<ActionQueueItem> }> }\n  | { type: 'remove'; id: string };\n\nlet _channel: BroadcastChannel | null | undefined;\n\nfunction getChannel(): BroadcastChannel | null {\n  if (_channel !== undefined) return _channel;\n  _channel = typeof BroadcastChannel === 'undefined' ? null : new BroadcastChannel(CHANNEL_NAME);\n  return _channel;\n}\n\n/**\n * Broadcasts a queue-item status change to other tabs sharing the same\n * IndexedDB queue. The replay-lock holder (see `replayQueue` in action.ts)\n * is the only tab that mutates queue-item status, so non-leader tabs would\n * otherwise show stale status until their own store re-hydrates.\n *\n * No-ops in environments without BroadcastChannel (React Native, old Safari).\n */\nexport function broadcastQueueSync(message: QueueSyncMessage): void {\n  getChannel()?.postMessage(message);\n}\n\n/**\n * Applies queue-item status updates broadcast by the replay-lock holder to\n * this tab's store. Returns an unsubscribe function.\n */\nexport function subscribeQueueSync(): () => void {\n  const channel = getChannel();\n  if (!channel) return () => {};\n\n  const handler = (event: MessageEvent<QueueSyncMessage>) => {\n    const store = useEidosStore.getState();\n    const message = event.data;\n    switch (message.type) {\n      case 'update':\n        store.updateQueueItem(message.id, message.update);\n        break;\n      case 'batchUpdate':\n        store.batchUpdateQueueItems(message.updates);\n        break;\n      case 'remove':\n        store.removeQueueItem(message.id);\n        break;\n    }\n  };\n\n  channel.addEventListener('message', handler);\n  return () => channel.removeEventListener('message', handler);\n}\n\n/** Test-only: reset the cached channel so each test gets a fresh instance. */\nexport function _resetQueueSyncChannel(): void {\n  _channel?.close();\n  _channel = undefined;\n}\n"],"mappings":";AAGA,IAAM,IAAe,oBAOjB;AAEJ,SAAS,IAAsC;AAC7C,SAAI,MAAa,WACjB,IAAW,OAAO,mBAAqB,MAAc,OAAO,IAAI,iBAAiB,CAAY,IACtF;AACT;AAUA,SAAgB,EAAmB,GAAiC;AAClE,EAAA,EAAW,GAAG,YAAY,CAAO;AACnC;AAMA,SAAgB,IAAiC;AAC/C,QAAM,IAAU,EAAW;AAC3B,MAAI,CAAC,EAAS,QAAA,MAAa;AAAA,EAAC;AAE5B,QAAM,IAAA,CAAW,MAA0C;AACzD,UAAM,IAAQ,EAAc,SAAS,GAC/B,IAAU,EAAM;AACtB,YAAQ,EAAQ,MAAhB;AAAA,MACE,KAAK;AACH,QAAA,EAAM,gBAAgB,EAAQ,IAAI,EAAQ,MAAM;AAChD;AAAA,MACF,KAAK;AACH,QAAA,EAAM,sBAAsB,EAAQ,OAAO;AAC3C;AAAA,MACF,KAAK;AACH,QAAA,EAAM,gBAAgB,EAAQ,EAAE;AAChC;AAAA,IACJ;AAAA,EACF;AAEA,SAAA,EAAQ,iBAAiB,WAAW,CAAO,GAC3C,MAAa,EAAQ,oBAAoB,WAAW,CAAO;AAC7D"}

package/dist/react/Provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.js","names":[],"sources":["../../src/react/Provider.tsx"],"sourcesContent":["import { useEffect, type ReactNode } from 'react';\nimport { initEidos, type EidosConfig } from '../runtime';\n\ninterface EidosProviderProps extends EidosConfig {\n  children: ReactNode;\n}\n\n/**\n * Mount once at the root of your application.\n * Registers the service worker and initialises the Eidos runtime.\n *\n * @example\n * <EidosProvider swPath=\"/eidos-sw.js\">\n *   <App />\n * </EidosProvider>\n */\nexport function EidosProvider({ children, swPath, autoReplay }: EidosProviderProps) {\n  useEffect(() => {\n    initEidos({ swPath, autoReplay });\n    // Run once on mount only\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return <>{children}</>;\n}\n"],"mappings":";;;AAgBA,SAAgB,EAAc,EAAE,UAAA,GAAU,QAAA,GAAQ,YAAA,EAAA,GAAkC;AAClF,SAAA,EAAA,MAAgB;AACd,IAAA,EAAU;AAAA,MAAE,QAAA;AAAA,MAAQ,YAAA;AAAA,IAAW,CAAC;AAAA,EAGlC,GAAG,CAAC,CAAC,GAEE,gBAAA,EAAA,GAAA,EAAG,UAAA,EAAW,CAAA;AACvB"}

package/dist/react/hooks.js

@@ -1,36 +1,36 @@
-import { useEidosStore as a } from "../store.js";
-import { useEffect as d, useRef as l, useSyncExternalStore as E } from "react";
+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";
 function u(e) {
   const t = e ?? ((n) => n);
-  return E(a.subscribe, () => t(a.getState()));
+  return p(o.subscribe, () => t(o.getState()));
 }
-function S() {
+function R() {
   return u();
 }
 function q() {
   return u((e) => e.resources);
 }
-function R(e) {
+function w(e) {
   return u((t) => t.resources[e]);
 }
-function m() {
+function y() {
   return u((e) => e.queue);
 }
-function w(e) {
+function $(e) {
   return u((t) => t.queue.find((n) => n.id === e));
 }
-function y() {
+function O() {
   return {
     isOnline: u((e) => e.isOnline),
     swStatus: u((e) => e.swStatus),
     swError: u((e) => e.swError)
   };
 }
-function $() {
+function Q() {
   const [e, t, n, r] = u((s) => {
-    let o = 0, f = 0, c = 0;
-    for (const i of s.queue) i.status === "pending" ? o++ : i.status === "failed" ? f++ : i.status === "replaying" && c++;
-    return `${o},${f},${c},${s.queue.length}`;
+    const { pending: f, failed: a, replaying: d, total: E } = l(s.queue);
+    return `${f},${a},${d},${E}`;
   }).split(",");
   return {
     pending: +e,
@@ -39,23 +39,23 @@ function $() {
     total: +r
   };
 }
-function O(e) {
-  const t = u((s) => s.queue.length), n = l(0), r = l(e);
-  d(() => {
+function b(e) {
+  const t = u((s) => s.queue.length), n = c(0), r = c(e);
+  i(() => {
     r.current = e;
-  }), d(() => {
+  }), i(() => {
     n.current > 0 && t === 0 && r.current(), n.current = t;
   }, [t]);
 }
 export {
-  S as useEidos,
-  w as useEidosAction,
-  O as useEidosOnDrain,
-  m as useEidosQueue,
-  $ as useEidosQueueStats,
-  R as useEidosResource,
+  R as useEidos,
+  $ as useEidosAction,
+  b as useEidosOnDrain,
+  y as useEidosQueue,
+  Q as useEidosQueueStats,
+  w as useEidosResource,
   q as useEidosResources,
-  y as useEidosStatus
+  O as useEidosStatus
 };
 
 //# sourceMappingURL=hooks.js.map

package/dist/react/hooks.js.map

@@ -0,0 +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"}

package/dist/replay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.js","names":[],"sources":["../src/replay.ts"],"sourcesContent":["import { useEidosStore } from './store';\nimport { replayQueue } from './action';\n\n/**\n * Subscribe to online/offline transitions and trigger replayQueue() on\n * reconnect, plus replay any pending items left over from a previous session.\n *\n * Shared by the web (runtime.ts) and React Native (runtime-rn.ts) init paths.\n *\n * WHY subscribe to the store instead of window.addEventListener('online'):\n * setOfflineSimulation() updates the store directly but never fires a real\n * browser `online` event. Watching the store catches both:\n *   • Real network reconnects (sw-bridge updates store on window.online)\n *   • Simulation toggled off (setOfflineSimulation(false) → store.setOnline(true))\n *\n * Returns an unsubscribe function.\n */\nexport function subscribeReplayOnReconnect(): () => void {\n  let prevIsOnline = useEidosStore.getState().isOnline;\n\n  const unsubscribe = useEidosStore.subscribe(() => {\n    const { isOnline } = useEidosStore.getState();\n    const justCameOnline = isOnline && !prevIsOnline;\n    prevIsOnline = isOnline;\n\n    if (justCameOnline) {\n      // Small delay so the connection (or simulation reset) settles first\n      setTimeout(replayQueue, 600);\n    }\n  });\n\n  // Replay any pending items that survived a reload/restart.\n  // 'failed' items have already exhausted maxRetries and are never\n  // re-replayed (see _doReplayQueue), so they don't count here.\n  const store = useEidosStore.getState();\n  const hasPending = store.queue.some((q) => q.status === 'pending');\n  if (store.isOnline && hasPending) {\n    setTimeout(replayQueue, 1200);\n  }\n\n  return unsubscribe;\n}\n"],"mappings":";;AAiBA,SAAgB,IAAyC;AACvD,MAAI,IAAe,EAAc,SAAS,EAAE;AAE5C,QAAM,IAAc,EAAc,UAAA,MAAgB;AAChD,UAAM,EAAE,UAAA,EAAA,IAAa,EAAc,SAAS,GACtC,IAAiB,KAAY,CAAC;AACpC,IAAA,IAAe,GAEX,KAEF,WAAW,GAAa,GAAG;AAAA,EAE/B,CAAC,GAKK,IAAQ,EAAc,SAAS,GAC/B,IAAa,EAAM,MAAM,KAAA,CAAM,MAAM,EAAE,WAAW,SAAS;AACjE,SAAI,EAAM,YAAY,KACpB,WAAW,GAAa,IAAI,GAGvB;AACT"}

package/dist/resource.js

@@ -1,149 +1,162 @@
 import { useEidosStore as h } from "./store.js";
-import { sendToWorker as v } from "./sw-bridge.js";
-var p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), E = null;
-function N(e) {
-  E = e;
+import { sendToWorker as p } from "./sw-bridge.js";
+var d = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), g = null;
+function _(e) {
+  g = e;
 }
-function d(e) {
+function f(e) {
   return e.includes("*") || /:[^/]+/.test(e);
 }
-function R(e) {
+function k(e) {
   return "^" + e.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]+").replace(/:[^/]+/g, "[^/]+") + "$";
 }
-function w(e, a) {
-  return /* @__PURE__ */ new Error(`[eidos] resource('${e}') is a URL pattern — ${a}() is not supported on pattern handles. The SW intercepts matching requests automatically; call fetch(specificUrl) directly in your app code.`);
-}
-function A(e, a) {
-  if (p.has(e)) return p.get(e);
-  const s = S(a), t = d(e) ? R(e) : void 0, c = {
+function m(e, s) {
+  const a = b(s), t = f(e) ? k(e) : void 0, r = {
     url: e,
-    config: a,
-    strategy: s,
+    config: s,
+    strategy: a,
     status: "idle",
     cacheHits: 0,
     cacheMisses: 0
   };
-  h.getState().registerResource(e, c), v({
+  return h.getState().registerResource(e, r), p({
     type: "EIDOS_REGISTER_RESOURCE",
     url: e,
-    strategy: s.swStrategy,
-    cacheName: s.cacheName,
+    strategy: a.swStrategy,
+    cacheName: a.cacheName,
     ...t !== void 0 && { pattern: t }
-  });
-  const r = {
+  }), {
+    strategy: a,
+    regexStr: t
+  };
+}
+function y(e, s, a) {
+  return async () => {
+    p({
+      type: "EIDOS_CLEAR_CACHE",
+      url: e
+    });
+    const t = await caches.open(s.cacheName).catch(() => null);
+    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, u = new URL(o).pathname;
+        return n ? n.test(c ? o : u) : c ? o === e : o === e || u === e;
+      }).map((i) => t.delete(i)));
+    }
+    f(e) || h.getState().updateResource(e, {
+      status: "stale",
+      cachedAt: void 0,
+      lastEvent: "cache-cleared",
+      cacheHits: 0,
+      cacheMisses: 0
+    }), g?.(["eidos", e]);
+  };
+}
+function E(e) {
+  return () => {
+    d.delete(e), p({
+      type: "EIDOS_UNREGISTER_RESOURCE",
+      url: e
+    }), h.getState().unregisterResource(e);
+  };
+}
+function A(e, s) {
+  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,
-    config: a,
-    strategy: s,
+    config: s,
+    strategy: a,
     fetch: async () => {
-      if (d(e)) throw w(e, "fetch");
-      const n = m.get(e);
-      if (n) return n.then((o) => o.clone());
-      const i = k(e, a, s);
-      return m.set(e, i), i.finally(() => m.delete(e)).catch(() => {
-      }), i.then((o) => o.clone());
-    },
-    json: async () => {
-      if (d(e)) throw w(e, "json");
-      return (await r.fetch()).json();
-    },
-    query: () => {
-      if (d(e)) throw w(e, "query");
-      return {
-        queryKey: ["eidos", e],
-        queryFn: () => r.json()
-      };
+      const r = l.get(e);
+      if (r) return r.then((c) => c.clone());
+      const n = S(e, s, a);
+      return l.set(e, n), n.finally(() => l.delete(e)).catch(() => {
+      }), n.then((c) => c.clone());
     },
+    json: async () => (await t.fetch()).json(),
+    query: () => ({
+      queryKey: ["eidos", e],
+      queryFn: () => t.json()
+    }),
     prefetch: async () => {
-      if (d(e)) throw w(e, "prefetch");
-      await r.fetch();
-    },
-    invalidate: async () => {
-      v({
-        type: "EIDOS_CLEAR_CACHE",
-        url: e
-      });
-      const n = await caches.open(s.cacheName).catch(() => null);
-      if (n) {
-        const i = await n.keys(), o = t ? new RegExp(t) : null, l = e.startsWith("http");
-        await Promise.all(i.filter((u) => {
-          const f = u.url, g = new URL(f).pathname;
-          return o ? o.test(l ? f : g) : l ? f === e : f === e || g === e;
-        }).map((u) => n.delete(u)));
-      }
-      d(e) || h.getState().updateResource(e, {
-        status: "stale",
-        cachedAt: void 0,
-        lastEvent: "cache-cleared",
-        cacheHits: 0,
-        cacheMisses: 0
-      }), E?.(["eidos", e]);
+      await t.fetch();
     },
-    unregister: () => {
-      p.delete(e), v({
-        type: "EIDOS_UNREGISTER_RESOURCE",
-        url: e
-      }), h.getState().unregisterResource(e);
-    }
+    invalidate: y(e, a, void 0),
+    unregister: E(e)
   };
-  return p.set(e, r), r;
+  return d.set(e, t), t;
 }
-async function k(e, a, s) {
+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,
+    config: s,
+    strategy: a,
+    invalidate: y(e, a, t),
+    unregister: E(e)
+  };
+  return d.set(e, r), r;
+}
+async function S(e, s, a) {
   const t = h.getState();
   t.updateResource(e, {
     status: "fetching",
     fetchedAt: Date.now()
   });
-  const c = await caches.open(s.cacheName).catch(() => null);
+  const r = await caches.open(a.cacheName).catch(() => null);
   try {
-    if (s.swStrategy !== "network-first") {
-      const i = c ? await c.match(e).catch(() => null) : null, o = h.getState().resources[e], l = a.maxAge !== void 0 && o?.cachedAt !== void 0 && Date.now() - o.cachedAt > a.maxAge;
-      if (i && !l)
+    if (a.swStrategy !== "network-first") {
+      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",
           cacheHits: (o?.cacheHits ?? 0) + 1
-        }), s.swStrategy === "stale-while-revalidate" && fetch(e, { signal: AbortSignal.timeout(5e3) }).then(async (f) => {
-          f.ok && c && (await c.put(e, f.clone()), h.getState().updateResource(e, {
+        }), a.swStrategy === "stale-while-revalidate" && fetch(e, { signal: AbortSignal.timeout(5e3) }).then(async (w) => {
+          w.ok && r && (await r.put(e, w.clone()), h.getState().updateResource(e, {
             cachedAt: Date.now(),
             lastEvent: "cache-updated"
           }));
         }).catch(() => {
         }), i;
-      const u = h.getState().resources[e];
-      t.updateResource(e, { cacheMisses: (u?.cacheMisses ?? 0) + 1 });
+      const R = h.getState().resources[e];
+      t.updateResource(e, { cacheMisses: (R?.cacheMisses ?? 0) + 1 });
     }
-    const r = await fetch(e);
-    if (r.ok)
-      return c && await c.put(e, r.clone()), t.updateResource(e, {
+    const n = await fetch(e);
+    if (n.ok)
+      return r && await r.put(e, n.clone()), t.updateResource(e, {
         status: "fresh",
         cachedAt: Date.now(),
         lastEvent: "cache-updated"
-      }), r;
-    t.updateResource(e, { status: r.status === 503 ? "offline" : "error" });
-    const n = r.headers.get("X-Eidos-Offline") === "true";
-    throw new Error(n ? `offline: no cached response for ${e}` : `${r.status} ${r.statusText}`);
-  } catch (r) {
-    const n = c ? await c.match(e).catch(() => null) : null;
-    if (n) {
+      }), n;
+    t.updateResource(e, { status: n.status === 503 ? "offline" : "error" });
+    const c = n.headers.get("X-Eidos-Offline") === "true";
+    throw new Error(c ? `offline: no cached response for ${e}` : `${n.status} ${n.statusText}`);
+  } catch (n) {
+    const c = r ? await r.match(e).catch(() => null) : null;
+    if (c) {
       const i = h.getState().resources[e];
       return t.updateResource(e, {
         status: "fresh",
         lastEvent: "cache-hit",
         cacheHits: (i?.cacheHits ?? 0) + 1
-      }), n;
+      }), c;
     }
-    throw t.updateResource(e, { status: "error" }), r;
+    throw t.updateResource(e, { status: "error" }), n;
   }
 }
-function S(e) {
-  const a = e.strategy;
-  return e.offline ? y(a ?? "stale-while-revalidate", e.cacheName) : y(a ?? "network-first", e.cacheName);
+function b(e) {
+  const s = e.strategy;
+  return e.offline ? v(s ?? "stale-while-revalidate", e.cacheName, e.version) : v(s ?? "network-first", e.cacheName, e.version);
 }
-var b = {
+var x = {
   "stale-while-revalidate": "StaleWhileRevalidate",
   "cache-first": "CacheFirst",
   "network-first": "NetworkFirst"
-}, x = {
+}, C = {
   "stale-while-revalidate": {
     reasoning: "offline: true signals resilience. SWR returns cached data instantly while revalidating in the background — the best tradeoff between speed and freshness for offline-capable resources.",
     behavior: [
@@ -187,29 +200,30 @@ new NetworkFirst({
 })`
   }
 };
-function y(e, a) {
-  const s = x[e];
+function v(e, s, a) {
+  const t = C[e], r = s ?? "eidos-resources-v1";
   return {
-    name: b[e],
+    name: x[e],
     swStrategy: e,
-    cacheName: a ?? "eidos-resources-v1",
-    reasoning: s.reasoning,
-    behavior: s.behavior,
+    cacheName: a !== void 0 ? `${r}-v${a}` : r,
+    reasoning: t.reasoning,
+    behavior: t.behavior,
     equivalentCode: ""
   };
 }
-async function _(e) {
-  const a = await Promise.allSettled(e.map((t) => t.prefetch())), s = a.filter((t) => t.status === "rejected").map((t) => t.reason);
+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: a.filter((t) => t.status === "fulfilled").length,
-    failed: s.length,
-    errors: s
+    warmed: s.filter((t) => t.status === "fulfilled").length,
+    failed: a.length,
+    errors: a
   };
 }
 export {
   A as resource,
-  N as setQueryInvalidator,
-  _ as warmCache
+  $ as resourcePattern,
+  _ as setQueryInvalidator,
+  O as warmCache
 };
 
 //# sourceMappingURL=resource.js.map

package/dist/resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.js","names":[],"sources":["../src/resource.ts"],"sourcesContent":["import { useEidosStore } from './store';\nimport { sendToWorker } from './sw-bridge';\nimport type {\n  ResourceConfig,\n  ResourceHandle,\n  PatternResourceHandle,\n  ResourceEntry,\n  GeneratedStrategy,\n  CacheStrategy,\n  WarmCacheResult,\n} from './types';\n\nconst _registry = new Map<string, ResourceHandle | PatternResourceHandle>();\n\n// ── Request deduplication ─────────────────────────────────────────────────────\n// If multiple callers invoke handle.fetch() simultaneously for the same URL,\n// only one network request is made. Each caller gets its own cloned Response.\n// Keyed by URL; entry is deleted when the request settles.\nconst _inflightRequests = /* @__PURE__ */ new Map<string, Promise<Response>>();\n\n// ── TanStack Query bridge (optional) ─────────────────────────────────────────\n// Set by @sweidos/eidos/query when withEidosQueryClient() is called.\n// Lets handle.invalidate() also invalidate the matching TQ cache entry.\ntype QueryInvalidator = (queryKey: [string, string]) => void;\nlet _queryInvalidator: QueryInvalidator | null = null;\n\n/** @internal Called by @sweidos/eidos/query. */\nexport function setQueryInvalidator(fn: QueryInvalidator): void {\n  _queryInvalidator = fn;\n}\n\n// ── URL pattern helpers ───────────────────────────────────────────────────────\n\n/** Returns true if `url` contains wildcard or :param segments. */\nfunction isPattern(url: string): boolean {\n  return url.includes('*') || /:[^/]+/.test(url);\n}\n\n/**\n * Converts a URL pattern to a regex source string for SW fetch matching.\n *  `**`     → multi-segment wildcard  (`.+`)\n *  `*`      → single-segment wildcard (`[^/]+`)\n *  `:param` → named single segment    (`[^/]+`)\n *\n * Special regex characters in the pattern (e.g. `.`) are escaped first so\n * they match literally.\n *\n * @example\n *   patternToRegexStr('/api/products/*')      // '^/api/products/[^/]+$'\n *   patternToRegexStr('/api/products/**')     // '^/api/products/.+$'\n *   patternToRegexStr('/api/users/:id')       // '^/api/users/[^/]+$'\n */\nfunction patternToRegexStr(pattern: string): string {\n  // Escape all regex-special chars except `*`, `/`, `:` (handled below)\n  const escaped = pattern.replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  return (\n    '^' +\n    escaped\n      .replace(/\\*\\*/g, '.+') // ** → multi-segment wildcard\n      .replace(/\\*/g, '[^/]+') // * → single-segment wildcard\n      .replace(/:[^/]+/g, '[^/]+') + // :param → single-segment wildcard\n    '$'\n  );\n}\n\n/** Shared setup for resource()/resourcePattern(): strategy derivation, store + SW registration. */\nfunction _register(\n  url: string,\n  config: ResourceConfig,\n): { strategy: GeneratedStrategy; regexStr: string | undefined } {\n  const strategy = deriveStrategy(config);\n  const regexStr = isPattern(url) ? patternToRegexStr(url) : undefined;\n\n  const entry: ResourceEntry = {\n    url,\n    config,\n    strategy,\n    status: 'idle',\n    cacheHits: 0,\n    cacheMisses: 0,\n  };\n\n  useEidosStore.getState().registerResource(url, entry);\n\n  sendToWorker({\n    type: 'EIDOS_REGISTER_RESOURCE',\n    url,\n    strategy: strategy.swStrategy,\n    cacheName: strategy.cacheName,\n    ...(regexStr !== undefined && { pattern: regexStr }),\n  });\n\n  return { strategy, regexStr };\n}\n\nfunction _invalidate(\n  url: string,\n  strategy: GeneratedStrategy,\n  regexStr: string | undefined,\n): () => Promise<void> {\n  return async () => {\n    sendToWorker({ type: 'EIDOS_CLEAR_CACHE', url });\n    const cache = await caches.open(strategy.cacheName).catch(() => null);\n    if (cache) {\n      const keys = await cache.keys();\n      const patternRe = regexStr ? new RegExp(regexStr) : null;\n      const isCrossOrigin = url.startsWith('http');\n      await Promise.all(\n        keys\n          .filter((r) => {\n            const rUrl = r.url;\n            const p = new URL(rUrl).pathname;\n            if (patternRe) {\n              // Cross-origin patterns were compiled from absolute URLs; test full URL.\n              return patternRe.test(isCrossOrigin ? rUrl : p);\n            }\n            return isCrossOrigin ? rUrl === url : rUrl === url || p === url;\n          })\n          .map((r) => cache.delete(r)),\n      );\n    }\n    // For exact-URL resources update the store entry; patterns don't have a\n    // single entry to update (individual URLs are not tracked per-pattern).\n    if (!isPattern(url)) {\n      useEidosStore.getState().updateResource(url, {\n        status: 'stale',\n        cachedAt: undefined,\n        lastEvent: 'cache-cleared',\n        cacheHits: 0,\n        cacheMisses: 0,\n      });\n    }\n    // Notify TanStack Query bridge if registered.\n    _queryInvalidator?.(['eidos', url]);\n  };\n}\n\nfunction _unregister(url: string): () => void {\n  return () => {\n    _registry.delete(url);\n    sendToWorker({ type: 'EIDOS_UNREGISTER_RESOURCE', url });\n    useEidosStore.getState().unregisterResource(url);\n  };\n}\n\nfunction _warnIfReregisteredWithDifferentConfig(\n  url: string,\n  existing: ResourceHandle | PatternResourceHandle,\n  config: ResourceConfig,\n  factoryName: string,\n): void {\n  if (!import.meta.env.DEV) return;\n  const existingCfg = existing.config;\n  if (\n    existingCfg.offline !== config.offline ||\n    existingCfg.strategy !== config.strategy ||\n    existingCfg.cacheName !== config.cacheName ||\n    existingCfg.version !== config.version\n  ) {\n    console.warn(\n      `[eidos] ${factoryName}('${url}') already registered with a different config — returning cached handle. Call handle.unregister() first to re-register.`,\n      { registered: existingCfg, ignored: config },\n    );\n  }\n}\n\n// ── resource() ────────────────────────────────────────────────────────────────\n\n/**\n * Registers a concrete-URL resource. For URL patterns (`/api/products/*`,\n * `/api/users/:id`, `**`), use `resourcePattern()` instead.\n */\nexport function resource<T = unknown>(url: string, config: ResourceConfig): ResourceHandle<T> {\n  if (isPattern(url)) {\n    throw new Error(\n      `[eidos] resource('${url}') is a URL pattern — use resourcePattern('${url}', config) instead. ` +\n        `Pattern handles only support invalidate()/unregister(); the SW intercepts matching requests automatically.`,\n    );\n  }\n\n  if (_registry.has(url)) {\n    const existing = _registry.get(url)!;\n    _warnIfReregisteredWithDifferentConfig(url, existing, config, 'resource');\n    return existing as ResourceHandle<T>;\n  }\n\n  const { strategy } = _register(url, config);\n\n  const handle: ResourceHandle<T> = {\n    url,\n    config,\n    strategy,\n\n    fetch: async () => {\n      // ── Deduplication: coalesce concurrent fetches for the same URL ─────\n      // If a request is already in-flight, piggyback on it and return a clone\n      // so each caller gets an independent readable Response body.\n      const existing = _inflightRequests.get(url);\n      if (existing) return existing.then((r) => r.clone());\n\n      // Store the raw-response promise. All callers (including the primary)\n      // receive a clone — the raw response stays unconsumed in the map so\n      // any caller arriving while the promise is still pending can clone it.\n      const task = _fetchResource(url, config, strategy);\n      _inflightRequests.set(url, task);\n      // .catch() silences the unhandled-rejection on the cleanup promise;\n      // the error still propagates to callers via task.then() below.\n      task.finally(() => _inflightRequests.delete(url)).catch(() => {});\n      return task.then((r) => r.clone());\n    },\n\n    json: async () => {\n      const res = await handle.fetch();\n      return res.json() as Promise<T>;\n    },\n\n    query: () => ({\n      queryKey: ['eidos', url] as [string, string],\n      queryFn: () => handle.json(),\n    }),\n\n    prefetch: async () => {\n      await handle.fetch();\n    },\n\n    invalidate: _invalidate(url, strategy, undefined),\n    unregister: _unregister(url),\n  };\n\n  _registry.set(url, handle);\n  return handle;\n}\n\n// ── resourcePattern() ────────────────────────────────────────────────────────\n\n/**\n * Registers a URL pattern (`/api/products/*`, `/api/users/:id`, `**`). The SW\n * intercepts all matching requests automatically — there is no single URL to\n * fetch/cache directly, so the returned handle only supports cache management\n * (`invalidate`/`unregister`). For a fetchable resource, use `resource()`.\n */\nexport function resourcePattern(url: string, config: ResourceConfig): PatternResourceHandle {\n  if (!isPattern(url)) {\n    throw new Error(\n      `[eidos] resourcePattern('${url}') is not a URL pattern — use resource('${url}', config) instead.`,\n    );\n  }\n\n  if (_registry.has(url)) {\n    const existing = _registry.get(url)!;\n    _warnIfReregisteredWithDifferentConfig(url, existing, config, 'resourcePattern');\n    return existing as PatternResourceHandle;\n  }\n\n  const { strategy, regexStr } = _register(url, config);\n\n  const handle: PatternResourceHandle = {\n    url,\n    config,\n    strategy,\n    invalidate: _invalidate(url, strategy, regexStr),\n    unregister: _unregister(url),\n  };\n\n  _registry.set(url, handle);\n  return handle;\n}\n\n// ── _fetchResource ─────────────────────────────────────────────────────────────\n// The actual network/cache implementation. Separated from handle.fetch() so the\n// deduplication wrapper can store the Promise and share it across concurrent callers.\n// Returns the raw (unconsumed) Response — callers MUST .clone() before reading body.\nasync function _fetchResource(\n  url: string,\n  config: ResourceConfig,\n  strategy: GeneratedStrategy,\n): Promise<Response> {\n  const store = useEidosStore.getState();\n  store.updateResource(url, { status: 'fetching', fetchedAt: Date.now() });\n\n  // Open cache once and reuse across try/catch — avoids a redundant\n  // caches.open() call in the error fallback path.\n  const cache = await caches.open(strategy.cacheName).catch(() => null);\n\n  try {\n    // ── network-first: skip cache check, go straight to network ─────────\n    // For cache-first / SWR the cache check below is correct. For\n    // network-first, reading cache first and returning early would\n    // contradict the strategy — fresh data is the priority.\n    if (strategy.swStrategy !== 'network-first') {\n      // ── Direct Cache API check ─────────────────────────────────────────\n      // We read the cache in the main thread rather than waiting for\n      // an async SW postMessage. This gives instant, reliable status\n      // updates regardless of SW message timing.\n      const cached = cache ? await cache.match(url).catch(() => null) : null;\n\n      // Treat cache as miss if maxAge exceeded\n      const current = useEidosStore.getState().resources[url];\n      const expired =\n        config.maxAge !== undefined &&\n        current?.cachedAt !== undefined &&\n        Date.now() - current.cachedAt > config.maxAge;\n\n      if (cached && !expired) {\n        store.updateResource(url, {\n          status: 'fresh',\n          lastEvent: 'cache-hit',\n          cacheHits: (current?.cacheHits ?? 0) + 1,\n        });\n\n        // Background revalidation for SWR (stale-while-revalidate)\n        if (strategy.swStrategy === 'stale-while-revalidate') {\n          fetch(url, { signal: AbortSignal.timeout(5000) })\n            .then(async (resp) => {\n              if (resp.ok && cache) {\n                await cache.put(url, resp.clone());\n                useEidosStore.getState().updateResource(url, {\n                  cachedAt: Date.now(),\n                  lastEvent: 'cache-updated',\n                });\n              }\n            })\n            .catch(() => {\n              /* offline or timed out — cached version stays valid */\n            });\n        }\n\n        return cached;\n      }\n\n      // Cache miss (or expired)\n      const storeEntry = useEidosStore.getState().resources[url];\n      store.updateResource(url, {\n        cacheMisses: (storeEntry?.cacheMisses ?? 0) + 1,\n      });\n    }\n\n    const response = await fetch(url);\n\n    if (response.ok) {\n      if (cache) await cache.put(url, response.clone());\n      store.updateResource(url, {\n        status: 'fresh',\n        cachedAt: Date.now(),\n        lastEvent: 'cache-updated',\n      });\n      return response;\n    }\n\n    // Non-2xx response (e.g. 503 from offline SW) — update status and throw\n    // so callers get a proper error instead of a plain-object body they can't use.\n    store.updateResource(url, { status: response.status === 503 ? 'offline' : 'error' });\n\n    // Check if the SW tagged this as an offline response\n    const isOffline = response.headers.get('X-Eidos-Offline') === 'true';\n    throw new Error(\n      isOffline\n        ? `offline: no cached response for ${url}`\n        : `${response.status} ${response.statusText}`,\n    );\n  } catch (err) {\n    // Network failure — try cache one more time as fallback\n    const fallback = cache ? await cache.match(url).catch(() => null) : null;\n\n    if (fallback) {\n      const current = useEidosStore.getState().resources[url];\n      store.updateResource(url, {\n        status: 'fresh',\n        lastEvent: 'cache-hit',\n        cacheHits: (current?.cacheHits ?? 0) + 1,\n      });\n      return fallback;\n    }\n\n    store.updateResource(url, { status: 'error' });\n    throw err;\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Strategy derivation — intent → deterministic caching strategy\n// ─────────────────────────────────────────────────────────────────────────────\n\nfunction deriveStrategy(config: ResourceConfig): GeneratedStrategy {\n  const explicit = config.strategy;\n  if (config.offline) {\n    return buildStrategy(explicit ?? 'stale-while-revalidate', config.cacheName, config.version);\n  }\n  return buildStrategy(explicit ?? 'network-first', config.cacheName, config.version);\n}\n\n// Strategy display names — always included (tiny, used by devtools).\nconst STRATEGY_NAMES: Record<CacheStrategy, string> = {\n  'stale-while-revalidate': 'StaleWhileRevalidate',\n  'cache-first': 'CacheFirst',\n  'network-first': 'NetworkFirst',\n};\n\n// Heavy descriptive strings — stripped from production bundles by Vite's\n// import.meta.env.DEV dead-code elimination. Only the names above ship in prod.\ntype StrategyDevInfo = Pick<GeneratedStrategy, 'reasoning' | 'behavior' | 'equivalentCode'>;\nconst _STRATEGY_DEV_META: Record<CacheStrategy, StrategyDevInfo> = {\n  'stale-while-revalidate': {\n    reasoning:\n      'offline: true signals resilience. SWR returns cached data instantly while revalidating in the background — the best tradeoff between speed and freshness for offline-capable resources.',\n    behavior: [\n      'Cache hit → return immediately, kick off background revalidation',\n      'Cache miss → fetch from network, cache the response, return it',\n      'Offline → return cached version if available, 503 if not',\n      'Reconnect → next request triggers a background refresh',\n    ],\n    equivalentCode: `// Workbox equivalent\nnew StaleWhileRevalidate({\n  cacheName: 'eidos-resources-v1',\n  plugins: [new ExpirationPlugin({ maxEntries: 60 })],\n})`,\n  },\n  'cache-first': {\n    reasoning:\n      'cache-first maximises speed and offline availability. Network is consulted only on cache miss. Best for static or infrequently-updated data.',\n    behavior: [\n      'Cache hit → return immediately, no network request made',\n      'Cache miss → fetch from network, cache the response, return it',\n      'Offline → return cached version, 503 if cache is empty',\n      'Cache never expires unless explicitly invalidated',\n    ],\n    equivalentCode: `// Workbox equivalent\nnew CacheFirst({\n  cacheName: 'eidos-resources-v1',\n  plugins: [new ExpirationPlugin({ maxEntries: 60 })],\n})`,\n  },\n  'network-first': {\n    reasoning:\n      'network-first prioritises fresh data. Cache acts as a safety net when offline. Best for frequently-updated resources where stale data causes problems.',\n    behavior: [\n      'Always try network first',\n      'Network success → update cache, return fresh response',\n      'Network failure → fall back to cached version',\n      'Offline with empty cache → return 503 error response',\n    ],\n    equivalentCode: `// Workbox equivalent\nnew NetworkFirst({\n  cacheName: 'eidos-resources-v1',\n  networkTimeoutSeconds: 3,\n})`,\n  },\n};\n\nfunction buildStrategy(\n  swStrategy: CacheStrategy,\n  cacheName?: string,\n  version?: string | number,\n): GeneratedStrategy {\n  const meta = _STRATEGY_DEV_META[swStrategy];\n  const baseName = cacheName ?? 'eidos-resources-v1';\n  return {\n    name: STRATEGY_NAMES[swStrategy],\n    swStrategy,\n    cacheName: version !== undefined ? `${baseName}-v${version}` : baseName,\n    // reasoning + behavior are rendered by the playground UI from live ResourceEntry objects —\n    // keep them in all builds. equivalentCode is a static code block only used in DEV tools.\n    reasoning: meta.reasoning,\n    behavior: meta.behavior,\n    equivalentCode: import.meta.env.DEV ? meta.equivalentCode : '',\n  };\n}\n\n// ── warmCache ─────────────────────────────────────────────────────────────────\n\n/**\n * Bulk-prefetch an array of resource handles concurrently, warming the cache\n * for each one. Useful on login / app init when you know which resources the\n * user will need offline.\n *\n * Pattern handles (containing `*`, `**`, or `:param`) are silently skipped —\n * they match multiple URLs so there is no single URL to prefetch.\n *\n * @example\n * import { warmCache } from '@sweidos/eidos'\n *\n * // In EidosProvider's onReady, or after login:\n * const { warmed, failed } = await warmCache([products, userProfile, settings])\n */\nexport async function warmCache(handles: ResourceHandle[]): Promise<WarmCacheResult> {\n  const results = await Promise.allSettled(handles.map((h) => h.prefetch()));\n  const errors = results\n    .filter((r): r is PromiseRejectedResult => r.status === 'rejected')\n    .map((r) => r.reason);\n\n  if (import.meta.env.DEV && errors.length > 0) {\n    console.warn(`[eidos] warmCache: ${errors.length} handle(s) failed to prefetch`, errors);\n  }\n\n  return {\n    warmed: results.filter((r) => r.status === 'fulfilled').length,\n    failed: errors.length,\n    errors,\n  };\n}\n"],"mappings":";;AAYA,IAAM,IAAY,oBAAI,IAAoD,GAMpE,IAAoC,oBAAI,IAA+B,GAMzE,IAA6C;AAGjD,SAAgB,EAAoB,GAA4B;AAC9D,EAAA,IAAoB;AACtB;AAKA,SAAS,EAAU,GAAsB;AACvC,SAAO,EAAI,SAAS,GAAG,KAAK,SAAS,KAAK,CAAG;AAC/C;AAgBA,SAAS,EAAkB,GAAyB;AAGlD,SACE,MAFc,EAAQ,QAAQ,sBAAsB,MAGpD,EACG,QAAQ,SAAS,IAAI,EACrB,QAAQ,OAAO,OAAO,EACtB,QAAQ,WAAW,OAAO,IAC7B;AAEJ;AAGA,SAAS,EACP,GACA,GAC+D;AAC/D,QAAM,IAAW,EAAe,CAAM,GAChC,IAAW,EAAU,CAAG,IAAI,EAAkB,CAAG,IAAI,QAErD,IAAuB;AAAA,IAC3B,KAAA;AAAA,IACA,QAAA;AAAA,IACA,UAAA;AAAA,IACA,QAAQ;AAAA,IACR,WAAW;AAAA,IACX,aAAa;AAAA,EACf;AAEA,SAAA,EAAc,SAAS,EAAE,iBAAiB,GAAK,CAAK,GAEpD,EAAa;AAAA,IACX,MAAM;AAAA,IACN,KAAA;AAAA,IACA,UAAU,EAAS;AAAA,IACnB,WAAW,EAAS;AAAA,IACpB,GAAI,MAAa,UAAa,EAAE,SAAS,EAAS;AAAA,EACpD,CAAC,GAEM;AAAA,IAAE,UAAA;AAAA,IAAU,UAAA;AAAA,EAAS;AAC9B;AAEA,SAAS,EACP,GACA,GACA,GACqB;AACrB,SAAO,YAAY;AACjB,IAAA,EAAa;AAAA,MAAE,MAAM;AAAA,MAAqB,KAAA;AAAA,IAAI,CAAC;AAC/C,UAAM,IAAQ,MAAM,OAAO,KAAK,EAAS,SAAS,EAAE,MAAA,MAAY,IAAI;AACpE,QAAI,GAAO;AACT,YAAM,IAAO,MAAM,EAAM,KAAK,GACxB,IAAY,IAAW,IAAI,OAAO,CAAQ,IAAI,MAC9C,IAAgB,EAAI,WAAW,MAAM;AAC3C,YAAM,QAAQ,IACZ,EACG,OAAA,CAAQ,MAAM;AACb,cAAM,IAAO,EAAE,KACT,IAAI,IAAI,IAAI,CAAI,EAAE;AACxB,eAAI,IAEK,EAAU,KAAK,IAAgB,IAAO,CAAC,IAEzC,IAAgB,MAAS,IAAM,MAAS,KAAO,MAAM;AAAA,MAC9D,CAAC,EACA,IAAA,CAAK,MAAM,EAAM,OAAO,CAAC,CAAC,CAC/B;AAAA,IACF;AAGA,IAAK,EAAU,CAAG,KAChB,EAAc,SAAS,EAAE,eAAe,GAAK;AAAA,MAC3C,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,WAAW;AAAA,MACX,WAAW;AAAA,MACX,aAAa;AAAA,IACf,CAAC,GAGH,IAAoB,CAAC,SAAS,CAAG,CAAC;AAAA,EACpC;AACF;AAEA,SAAS,EAAY,GAAyB;AAC5C,SAAA,MAAa;AACX,IAAA,EAAU,OAAO,CAAG,GACpB,EAAa;AAAA,MAAE,MAAM;AAAA,MAA6B,KAAA;AAAA,IAAI,CAAC,GACvD,EAAc,SAAS,EAAE,mBAAmB,CAAG;AAAA,EACjD;AACF;AA6BA,SAAgB,EAAsB,GAAa,GAA2C;AAC5F,MAAI,EAAU,CAAG,EACf,OAAM,IAAI,MACR,qBAAqB,CAAA,8CAAiD,CAAA,gIAExE;AAGF,MAAI,EAAU,IAAI,CAAG,EAGnB,QAFiB,EAAU,IAAI,CAExB;AAGT,QAAM,EAAE,UAAA,EAAA,IAAa,EAAU,GAAK,CAAM,GAEpC,IAA4B;AAAA,IAChC,KAAA;AAAA,IACA,QAAA;AAAA,IACA,UAAA;AAAA,IAEA,OAAO,YAAY;AAIjB,YAAM,IAAW,EAAkB,IAAI,CAAG;AAC1C,UAAI,EAAU,QAAO,EAAS,KAAA,CAAM,MAAM,EAAE,MAAM,CAAC;AAKnD,YAAM,IAAO,EAAe,GAAK,GAAQ,CAAQ;AACjD,aAAA,EAAkB,IAAI,GAAK,CAAI,GAG/B,EAAK,QAAA,MAAc,EAAkB,OAAO,CAAG,CAAC,EAAE,MAAA,MAAY;AAAA,MAAC,CAAC,GACzD,EAAK,KAAA,CAAM,MAAM,EAAE,MAAM,CAAC;AAAA,IACnC;AAAA,IAEA,MAAM,aAEG,MADW,EAAO,MAAM,GACpB,KAAK;AAAA,IAGlB,OAAA,OAAc;AAAA,MACZ,UAAU,CAAC,SAAS,CAAG;AAAA,MACvB,SAAA,MAAe,EAAO,KAAK;AAAA,IAC7B;AAAA,IAEA,UAAU,YAAY;AACpB,YAAM,EAAO,MAAM;AAAA,IACrB;AAAA,IAEA,YAAY,EAAY,GAAK,GAAU,MAAS;AAAA,IAChD,YAAY,EAAY,CAAG;AAAA,EAC7B;AAEA,SAAA,EAAU,IAAI,GAAK,CAAM,GAClB;AACT;AAUA,SAAgB,EAAgB,GAAa,GAA+C;AAC1F,MAAI,CAAC,EAAU,CAAG,EAChB,OAAM,IAAI,MACR,4BAA4B,CAAA,2CAA8C,CAAA,qBAC5E;AAGF,MAAI,EAAU,IAAI,CAAG,EAGnB,QAFiB,EAAU,IAAI,CAExB;AAGT,QAAM,EAAE,UAAA,GAAU,UAAA,EAAA,IAAa,EAAU,GAAK,CAAM,GAE9C,IAAgC;AAAA,IACpC,KAAA;AAAA,IACA,QAAA;AAAA,IACA,UAAA;AAAA,IACA,YAAY,EAAY,GAAK,GAAU,CAAQ;AAAA,IAC/C,YAAY,EAAY,CAAG;AAAA,EAC7B;AAEA,SAAA,EAAU,IAAI,GAAK,CAAM,GAClB;AACT;AAMA,eAAe,EACb,GACA,GACA,GACmB;AACnB,QAAM,IAAQ,EAAc,SAAS;AACrC,EAAA,EAAM,eAAe,GAAK;AAAA,IAAE,QAAQ;AAAA,IAAY,WAAW,KAAK,IAAI;AAAA,EAAE,CAAC;AAIvE,QAAM,IAAQ,MAAM,OAAO,KAAK,EAAS,SAAS,EAAE,MAAA,MAAY,IAAI;AAEpE,MAAI;AAKF,QAAI,EAAS,eAAe,iBAAiB;AAK3C,YAAM,IAAS,IAAQ,MAAM,EAAM,MAAM,CAAG,EAAE,MAAA,MAAY,IAAI,IAAI,MAG5D,IAAU,EAAc,SAAS,EAAE,UAAU,CAAA,GAC7C,IACJ,EAAO,WAAW,UAClB,GAAS,aAAa,UACtB,KAAK,IAAI,IAAI,EAAQ,WAAW,EAAO;AAEzC,UAAI,KAAU,CAAC;AACb,eAAA,EAAM,eAAe,GAAK;AAAA,UACxB,QAAQ;AAAA,UACR,WAAW;AAAA,UACX,YAAY,GAAS,aAAa,KAAK;AAAA,QACzC,CAAC,GAGG,EAAS,eAAe,4BAC1B,MAAM,GAAK,EAAE,QAAQ,YAAY,QAAQ,GAAI,EAAE,CAAC,EAC7C,KAAK,OAAO,MAAS;AACpB,UAAI,EAAK,MAAM,MACb,MAAM,EAAM,IAAI,GAAK,EAAK,MAAM,CAAC,GACjC,EAAc,SAAS,EAAE,eAAe,GAAK;AAAA,YAC3C,UAAU,KAAK,IAAI;AAAA,YACnB,WAAW;AAAA,UACb,CAAC;AAAA,QAEL,CAAC,EACA,MAAA,MAAY;AAAA,QAEb,CAAC,GAGE;AAIT,YAAM,IAAa,EAAc,SAAS,EAAE,UAAU,CAAA;AACtD,MAAA,EAAM,eAAe,GAAK,EACxB,cAAc,GAAY,eAAe,KAAK,EAChD,CAAC;AAAA,IACH;AAEA,UAAM,IAAW,MAAM,MAAM,CAAG;AAEhC,QAAI,EAAS;AACX,aAAI,KAAO,MAAM,EAAM,IAAI,GAAK,EAAS,MAAM,CAAC,GAChD,EAAM,eAAe,GAAK;AAAA,QACxB,QAAQ;AAAA,QACR,UAAU,KAAK,IAAI;AAAA,QACnB,WAAW;AAAA,MACb,CAAC,GACM;AAKT,IAAA,EAAM,eAAe,GAAK,EAAE,QAAQ,EAAS,WAAW,MAAM,YAAY,QAAQ,CAAC;AAGnF,UAAM,IAAY,EAAS,QAAQ,IAAI,iBAAiB,MAAM;AAC9D,UAAM,IAAI,MACR,IACI,mCAAmC,CAAA,KACnC,GAAG,EAAS,MAAA,IAAU,EAAS,UAAA,EACrC;AAAA,EACF,SAAS,GAAK;AAEZ,UAAM,IAAW,IAAQ,MAAM,EAAM,MAAM,CAAG,EAAE,MAAA,MAAY,IAAI,IAAI;AAEpE,QAAI,GAAU;AACZ,YAAM,IAAU,EAAc,SAAS,EAAE,UAAU,CAAA;AACnD,aAAA,EAAM,eAAe,GAAK;AAAA,QACxB,QAAQ;AAAA,QACR,WAAW;AAAA,QACX,YAAY,GAAS,aAAa,KAAK;AAAA,MACzC,CAAC,GACM;AAAA,IACT;AAEA,UAAA,EAAM,eAAe,GAAK,EAAE,QAAQ,QAAQ,CAAC,GACvC;AAAA,EACR;AACF;AAMA,SAAS,EAAe,GAA2C;AACjE,QAAM,IAAW,EAAO;AACxB,SAAI,EAAO,UACF,EAAc,KAAY,0BAA0B,EAAO,WAAW,EAAO,OAAO,IAEtF,EAAc,KAAY,iBAAiB,EAAO,WAAW,EAAO,OAAO;AACpF;AAGA,IAAM,IAAgD;AAAA,EACpD,0BAA0B;AAAA,EAC1B,eAAe;AAAA,EACf,iBAAiB;AACnB,GAKM,IAA6D;AAAA,EACjE,0BAA0B;AAAA,IACxB,WACE;AAAA,IACF,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlB;AAAA,EACA,eAAe;AAAA,IACb,WACE;AAAA,IACF,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlB;AAAA,EACA,iBAAiB;AAAA,IACf,WACE;AAAA,IACF,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlB;AACF;AAEA,SAAS,EACP,GACA,GACA,GACmB;AACnB,QAAM,IAAO,EAAmB,CAAA,GAC1B,IAAW,KAAa;AAC9B,SAAO;AAAA,IACL,MAAM,EAAe,CAAA;AAAA,IACrB,YAAA;AAAA,IACA,WAAW,MAAY,SAAY,GAAG,CAAA,KAAa,CAAA,KAAY;AAAA,IAG/D,WAAW,EAAK;AAAA,IAChB,UAAU,EAAK;AAAA,IACf,gBAA4D;AAAA,EAC9D;AACF;AAkBA,eAAsB,EAAU,GAAqD;AACnF,QAAM,IAAU,MAAM,QAAQ,WAAW,EAAQ,IAAA,CAAK,MAAM,EAAE,SAAS,CAAC,CAAC,GACnE,IAAS,EACZ,OAAA,CAAQ,MAAkC,EAAE,WAAW,UAAU,EACjE,IAAA,CAAK,MAAM,EAAE,MAAM;AAMtB,SAAO;AAAA,IACL,QAAQ,EAAQ,OAAA,CAAQ,MAAM,EAAE,WAAW,WAAW,EAAE;AAAA,IACxD,QAAQ,EAAO;AAAA,IACf,QAAA;AAAA,EACF;AACF"}