@sweidos/eidos 1.1.0 → 2.0.0

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(), v = null;
+function _(e) {
+  v = e;
 }
-function d(e) {
+function u(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 = u(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, f = new URL(o).pathname;
+        return n ? n.test(c ? o : f) : c ? o === e : o === e || f === e;
+      }).map((i) => t.delete(i)));
+    }
+    u(e) || h.getState().updateResource(e, {
+      status: "stale",
+      cachedAt: void 0,
+      lastEvent: "cache-cleared",
+      cacheHits: 0,
+      cacheMisses: 0
+    }), v?.(["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 (u(e)) throw new Error(`[eidos] resource('${e}') is a URL pattern — use resourcePattern('${e}', config) instead. Pattern handles only support invalidate()/unregister(); the SW intercepts matching requests automatically.`);
+  if (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 O(e, s) {
+  if (!u(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], f = s.maxAge !== void 0 && o?.cachedAt !== void 0 && Date.now() - o.cachedAt > s.maxAge;
+      if (i && !f)
         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 ? g(s ?? "stale-while-revalidate", e.cacheName) : g(s ?? "network-first", e.cacheName);
 }
-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 g(e, s) {
+  const a = C[e];
   return {
-    name: b[e],
+    name: x[e],
     swStrategy: e,
-    cacheName: a ?? "eidos-resources-v1",
-    reasoning: s.reasoning,
-    behavior: s.behavior,
+    cacheName: s ?? "eidos-resources-v1",
+    reasoning: a.reasoning,
+    behavior: a.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 T(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
+  O as resourcePattern,
+  _ as setQueryInvalidator,
+  T 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  ) {\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) return buildStrategy(explicit ?? 'stale-while-revalidate', config.cacheName);\n  return buildStrategy(explicit ?? 'network-first', config.cacheName);\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(swStrategy: CacheStrategy, cacheName?: string): GeneratedStrategy {\n  const meta = _STRATEGY_DEV_META[swStrategy];\n  return {\n    name: STRATEGY_NAMES[swStrategy],\n    swStrategy,\n    cacheName: cacheName ?? 'eidos-resources-v1',\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;AA4BA,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,UAAgB,EAAc,KAAY,0BAA0B,EAAO,SAAS,IACxF,EAAc,KAAY,iBAAiB,EAAO,SAAS;AACpE;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,EAAc,GAA2B,GAAuC;AACvF,QAAM,IAAO,EAAmB,CAAA;AAChC,SAAO;AAAA,IACL,MAAM,EAAe,CAAA;AAAA,IACrB,YAAA;AAAA,IACA,WAAW,KAAa;AAAA,IAGxB,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"}

package/dist/runtime.js

@@ -1,32 +1,50 @@
-import { useEidosStore as o } from "./store.js";
-import { registerBgSyncHandler as a, registerServiceWorker as u } from "./sw-bridge.js";
-import { idbGetQueue as c } from "./idb.js";
+import { useEidosStore as a } from "./store.js";
+import { registerBgSyncHandler as c, registerServiceWorker as m } from "./sw-bridge.js";
+import { idbGetQueue as y, idbQueueStorage as d } from "./idb.js";
+import { _getQueueStorage as p } from "./queue-storage.js";
+import { subscribeQueueSync as l } from "./queue-sync.js";
 import { replayQueue as f } from "./action.js";
-import { subscribeReplayOnReconnect as l } from "./replay.js";
-var e = !1, t = null;
-async function h(r = {}) {
-  if (typeof window > "u" || e) return;
-  e = !0;
-  const s = r.swPath ?? "/eidos-sw.js", n = r.autoReplay ?? !0;
+import { subscribeReplayOnReconnect as g } from "./replay.js";
+async function h(e) {
+  if (e.schemaVersion === 2 && e.idempotencyKey) return e;
+  const t = {
+    ...e,
+    schemaVersion: 2,
+    idempotencyKey: e.idempotencyKey ?? crypto.randomUUID()
+  };
+  return await (p() ?? d).update(t.id, {
+    schemaVersion: t.schemaVersion,
+    idempotencyKey: t.idempotencyKey
+  }).catch(() => {
+  }), t;
+}
+var r = !1, i = null, o = null;
+async function R(e = {}) {
+  if (typeof window > "u" || r) return;
+  r = !0;
+  const t = e.swPath ?? "/eidos-sw.js", s = e.autoReplay ?? !0;
   try {
-    const i = await c();
-    i.length > 0 && o.getState().hydrateQueue(i);
+    const n = await y();
+    if (n.length > 0) {
+      const u = await Promise.all(n.map(h));
+      a.getState().hydrateQueue(u);
+    }
   } catch {
   }
   try {
-    await u(s);
+    await m(t);
   } catch {
   }
-  a(() => {
-    o.getState().isOnline && setTimeout(f, 200);
-  }), n && (t = l());
+  c(() => {
+    a.getState().isOnline && setTimeout(f, 200);
+  }), s && (i = g()), o = l();
 }
-function b() {
-  t?.(), t = null, e = !1;
+function V() {
+  i?.(), i = null, o?.(), o = null, r = !1;
 }
 export {
-  b as _resetEidos,
-  h as initEidos
+  V as _resetEidos,
+  R as initEidos
 };
 
 //# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","names":[],"sources":["../src/runtime.ts"],"sourcesContent":["import { registerServiceWorker, registerBgSyncHandler } from './sw-bridge';\nimport { replayQueue } from './action';\nimport { useEidosStore } from './store';\nimport { idbGetQueue, idbQueueStorage } from './idb';\nimport { _getQueueStorage } from './queue-storage';\nimport { subscribeReplayOnReconnect } from './replay';\nimport { subscribeQueueSync } from './queue-sync';\nimport { CURRENT_QUEUE_SCHEMA_VERSION } from './types';\nimport type { ActionQueueItem } from './types';\n\n// Items persisted before idempotencyKey/schemaVersion existed (v1) are migrated\n// in place: assign a fresh idempotencyKey and bump schemaVersion. A fresh key on\n// first replay after upgrade is correct — these items were never sent with one.\nasync function migrateQueueItem(item: ActionQueueItem): Promise<ActionQueueItem> {\n  if (item.schemaVersion === CURRENT_QUEUE_SCHEMA_VERSION && item.idempotencyKey) {\n    return item;\n  }\n  const migrated: ActionQueueItem = {\n    ...item,\n    schemaVersion: CURRENT_QUEUE_SCHEMA_VERSION,\n    idempotencyKey: item.idempotencyKey ?? crypto.randomUUID(),\n  };\n  const storage = _getQueueStorage() ?? idbQueueStorage;\n  await storage\n    .update(migrated.id, {\n      schemaVersion: migrated.schemaVersion,\n      idempotencyKey: migrated.idempotencyKey,\n    })\n    .catch(() => {\n      // Best-effort persist — item still gets the migrated shape in memory this session\n    });\n  return migrated;\n}\n\nexport interface EidosConfig {\n  /** Path to the eidos service worker. Defaults to '/eidos-sw.js'. */\n  swPath?: string;\n  /** Automatically replay the action queue on reconnect. Default: true. */\n  autoReplay?: boolean;\n}\n\nlet _initialized = false;\nlet _unsubscribe: (() => void) | null = null;\nlet _unsubscribeQueueSync: (() => void) | null = null;\n\nexport async function initEidos(config: EidosConfig = {}): Promise<void> {\n  // Skip silently during SSR — SW, IndexedDB, and window are browser-only.\n  if (typeof window === 'undefined') return;\n  if (_initialized) return;\n  _initialized = true;\n\n  const swPath = config.swPath ?? '/eidos-sw.js';\n  const autoReplay = config.autoReplay ?? true;\n\n  // Restore persisted queue from IndexedDB on startup\n  try {\n    const persisted = await idbGetQueue();\n    if (persisted.length > 0) {\n      const migrated = await Promise.all(persisted.map(migrateQueueItem));\n      useEidosStore.getState().hydrateQueue(migrated);\n    }\n  } catch {\n    // IndexedDB unavailable (Firefox private browsing) — silent fallback\n  }\n\n  try {\n    await registerServiceWorker(swPath);\n  } catch {\n    // SW registration failed; app continues without offline support\n  }\n\n  // When the SW fires the Background Sync tag, replay the queue in the main thread.\n  // This path runs even if the user briefly navigated away and back — the browser\n  // triggers the sync event on the SW, which wakes up all open clients.\n  registerBgSyncHandler(() => {\n    if (useEidosStore.getState().isOnline) {\n      setTimeout(replayQueue, 200);\n    }\n  });\n\n  if (autoReplay) {\n    _unsubscribe = subscribeReplayOnReconnect();\n  }\n\n  // Apply queue-item status changes broadcast by the replay-lock holder so\n  // non-leader tabs reflect live status without waiting for re-hydration.\n  _unsubscribeQueueSync = subscribeQueueSync();\n\n  if (import.meta.env.DEV) {\n    const store = useEidosStore.getState();\n    console.groupCollapsed('%c⚡ Eidos', 'color:#22C55E;font-weight:bold');\n    console.log('SW path    :', swPath);\n    console.log('Auto-replay:', autoReplay);\n    console.log('SW status  :', store.swStatus);\n    console.groupEnd();\n  }\n}\n\nexport function _resetEidos() {\n  _unsubscribe?.();\n  _unsubscribe = null;\n  _unsubscribeQueueSync?.();\n  _unsubscribeQueueSync = null;\n  _initialized = false;\n}\n"],"mappings":";;;;;;;AAaA,eAAe,EAAiB,GAAiD;AAC/E,MAAI,EAAK,kBAAA,KAAkD,EAAK,eAC9D,QAAO;AAET,QAAM,IAA4B;AAAA,IAChC,GAAG;AAAA,IACH,eAAA;AAAA,IACA,gBAAgB,EAAK,kBAAkB,OAAO,WAAW;AAAA,EAC3D;AAEA,gBADgB,EAAiB,KAAK,GAEnC,OAAO,EAAS,IAAI;AAAA,IACnB,eAAe,EAAS;AAAA,IACxB,gBAAgB,EAAS;AAAA,EAC3B,CAAC,EACA,MAAA,MAAY;AAAA,EAEb,CAAC,GACI;AACT;AASA,IAAI,IAAe,IACf,IAAoC,MACpC,IAA6C;AAEjD,eAAsB,EAAU,IAAsB,CAAC,GAAkB;AAGvE,MADI,OAAO,SAAW,OAClB,EAAc;AAClB,EAAA,IAAe;AAEf,QAAM,IAAS,EAAO,UAAU,gBAC1B,IAAa,EAAO,cAAc;AAGxC,MAAI;AACF,UAAM,IAAY,MAAM,EAAY;AACpC,QAAI,EAAU,SAAS,GAAG;AACxB,YAAM,IAAW,MAAM,QAAQ,IAAI,EAAU,IAAI,CAAgB,CAAC;AAClE,MAAA,EAAc,SAAS,EAAE,aAAa,CAAQ;AAAA,IAChD;AAAA,EACF,QAAQ;AAAA,EAER;AAEA,MAAI;AACF,UAAM,EAAsB,CAAM;AAAA,EACpC,QAAQ;AAAA,EAER;AAKA,EAAA,EAAA,MAA4B;AAC1B,IAAI,EAAc,SAAS,EAAE,YAC3B,WAAW,GAAa,GAAG;AAAA,EAE/B,CAAC,GAEG,MACF,IAAe,EAA2B,IAK5C,IAAwB,EAAmB;AAU7C;AAEA,SAAgB,IAAc;AAC5B,EAAA,IAAe,GACf,IAAe,MACf,IAAwB,GACxB,IAAwB,MACxB,IAAe;AACjB"}

package/dist/store-slices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-slices.js","names":[],"sources":["../src/store-slices.ts"],"sourcesContent":["import type { ResourceEntry, ActionQueueItem } from './types';\nimport type { EidosStore } from './store';\n\ntype Setter = (updater: (prev: EidosStore) => Partial<EidosStore>) => void;\n\n// ── Resource slice ────────────────────────────────────────────────────────────\n\nexport interface ResourceActions {\n  registerResource: (url: string, entry: ResourceEntry) => void;\n  updateResource: (url: string, update: Partial<ResourceEntry>) => void;\n  unregisterResource: (url: string) => void;\n}\n\nexport function createResourceActions(set: Setter): ResourceActions {\n  return {\n    registerResource: (url, entry) => set((s) => ({ resources: { ...s.resources, [url]: entry } })),\n\n    updateResource: (url, update) =>\n      set((s) => ({\n        resources: {\n          ...s.resources,\n          [url]: s.resources[url] ? { ...s.resources[url], ...update } : s.resources[url],\n        },\n      })),\n\n    unregisterResource: (url) =>\n      set((s) => ({\n        resources: Object.fromEntries(Object.entries(s.resources).filter(([k]) => k !== url)),\n      })),\n  };\n}\n\n// ── Queue slice ───────────────────────────────────────────────────────────────\n\nexport interface QueueActions {\n  addQueueItem: (item: ActionQueueItem) => void;\n  updateQueueItem: (id: string, update: Partial<ActionQueueItem>) => void;\n  batchUpdateQueueItems: (updates: Array<{ id: string; update: Partial<ActionQueueItem> }>) => void;\n  removeQueueItem: (id: string) => void;\n  hydrateQueue: (items: ActionQueueItem[]) => void;\n}\n\nexport function createQueueActions(set: Setter): QueueActions {\n  return {\n    addQueueItem: (item) => set((s) => ({ queue: [...s.queue, item] })),\n\n    updateQueueItem: (id, update) =>\n      set((s) => ({\n        queue: s.queue.map((item) => (item.id === id ? { ...item, ...update } : item)),\n      })),\n\n    batchUpdateQueueItems: (updates) =>\n      set((s) => {\n        const map = new Map(updates.map((u) => [u.id, u.update]));\n        return {\n          queue: s.queue.map((item) => {\n            const u = map.get(item.id);\n            return u ? { ...item, ...u } : item;\n          }),\n        };\n      }),\n\n    removeQueueItem: (id) => set((s) => ({ queue: s.queue.filter((item) => item.id !== id) })),\n\n    hydrateQueue: (items) => set(() => ({ queue: items })),\n  };\n}\n"],"mappings":"AAaA,SAAgB,EAAsB,GAA8B;AAClE,SAAO;AAAA,IACL,kBAAA,CAAmB,GAAK,MAAU,EAAA,CAAK,OAAO,EAAE,WAAW;AAAA,MAAE,GAAG,EAAE;AAAA,OAAY,CAAA,GAAM;AAAA,IAAM,EAAE,EAAE;AAAA,IAE9F,gBAAA,CAAiB,GAAK,MACpB,EAAA,CAAK,OAAO,EACV,WAAW;AAAA,MACT,GAAG,EAAE;AAAA,OACJ,CAAA,GAAM,EAAE,UAAU,CAAA,IAAO;AAAA,QAAE,GAAG,EAAE,UAAU,CAAA;AAAA,QAAM,GAAG;AAAA,MAAO,IAAI,EAAE,UAAU,CAAA;AAAA,IAC7E,EACF,EAAE;AAAA,IAEJ,oBAAA,CAAqB,MACnB,EAAA,CAAK,OAAO,EACV,WAAW,OAAO,YAAY,OAAO,QAAQ,EAAE,SAAS,EAAE,OAAA,CAAQ,CAAC,CAAA,MAAO,MAAM,CAAG,CAAC,EACtF,EAAE;AAAA,EACN;AACF;AAYA,SAAgB,EAAmB,GAA2B;AAC5D,SAAO;AAAA,IACL,cAAA,CAAe,MAAS,EAAA,CAAK,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,OAAO,CAAI,EAAE,EAAE;AAAA,IAElE,iBAAA,CAAkB,GAAI,MACpB,EAAA,CAAK,OAAO,EACV,OAAO,EAAE,MAAM,IAAA,CAAK,MAAU,EAAK,OAAO,IAAK;AAAA,MAAE,GAAG;AAAA,MAAM,GAAG;AAAA,IAAO,IAAI,CAAK,EAC/E,EAAE;AAAA,IAEJ,uBAAA,CAAwB,MACtB,EAAA,CAAK,MAAM;AACT,YAAM,IAAM,IAAI,IAAI,EAAQ,IAAA,CAAK,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACxD,aAAO,EACL,OAAO,EAAE,MAAM,IAAA,CAAK,MAAS;AAC3B,cAAM,IAAI,EAAI,IAAI,EAAK,EAAE;AACzB,eAAO,IAAI;AAAA,UAAE,GAAG;AAAA,UAAM,GAAG;AAAA,QAAE,IAAI;AAAA,MACjC,CAAC,EACH;AAAA,IACF,CAAC;AAAA,IAEH,iBAAA,CAAkB,MAAO,EAAA,CAAK,OAAO,EAAE,OAAO,EAAE,MAAM,OAAA,CAAQ,MAAS,EAAK,OAAO,CAAE,EAAE,EAAE;AAAA,IAEzF,cAAA,CAAe,MAAU,EAAA,OAAW,EAAE,OAAO,EAAM,EAAE;AAAA,EACvD;AACF"}

package/dist/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../src/store.ts"],"sourcesContent":["import type { EidosState } from './types';\nimport { createResourceActions, createQueueActions } from './store-slices';\nimport type { ResourceActions, QueueActions } from './store-slices';\n\nexport interface EidosStore extends EidosState, ResourceActions, QueueActions {\n  // Online\n  setOnline: (online: boolean) => void;\n  // SW\n  setSwStatus: (status: EidosState['swStatus'], error?: string) => void;\n}\n\ntype Listener = () => void;\n\nlet _state: EidosStore;\nconst _listeners = new Set<Listener>();\n\nfunction _notify() {\n  _listeners.forEach((fn) => fn());\n}\n\nfunction _set(updater: (prev: EidosStore) => Partial<EidosStore>) {\n  _state = { ..._state, ...updater(_state) };\n  _notify();\n}\n\n_state = {\n  // navigator.onLine is undefined in React Native — default to true unless explicitly false\n  isOnline: typeof navigator === 'undefined' || navigator.onLine !== false,\n  swStatus: 'idle',\n  swError: undefined,\n  resources: {},\n  queue: [],\n\n  setOnline: (isOnline) => _set(() => ({ isOnline })),\n\n  setSwStatus: (swStatus, swError) => _set(() => ({ swStatus, swError })),\n\n  ...createResourceActions(_set),\n  ...createQueueActions(_set),\n};\n\nfunction _getState() {\n  return _state;\n}\n\nfunction _subscribe(listener: Listener) {\n  _listeners.add(listener);\n  return () => {\n    _listeners.delete(listener);\n  };\n}\n\nexport const useEidosStore = {\n  getState: _getState,\n  subscribe: _subscribe,\n  // Test/devtools helper — merges partial state, preserves action methods.\n  setState: (partial: Partial<EidosStore> | ((s: EidosStore) => Partial<EidosStore>)) => {\n    const update = typeof partial === 'function' ? partial(_state) : partial;\n    _state = { ..._state, ...update };\n    _notify();\n  },\n};\n"],"mappings":";AAaA,IAAI,GACE,IAAa,oBAAI,IAAc;AAErC,SAAS,IAAU;AACjB,EAAA,EAAW,QAAA,CAAS,MAAO,EAAG,CAAC;AACjC;AAEA,SAAS,EAAK,GAAoD;AAChE,EAAA,IAAS;AAAA,IAAE,GAAG;AAAA,IAAQ,GAAG,EAAQ,CAAM;AAAA,EAAE,GACzC,EAAQ;AACV;AAEA,IAAS;AAAA,EAEP,UAAU,OAAO,YAAc,OAAe,UAAU,WAAW;AAAA,EACnE,UAAU;AAAA,EACV,SAAS;AAAA,EACT,WAAW,CAAC;AAAA,EACZ,OAAO,CAAC;AAAA,EAER,WAAA,CAAY,MAAa,EAAA,OAAY,EAAE,UAAA,EAAS,EAAE;AAAA,EAElD,aAAA,CAAc,GAAU,MAAY,EAAA,OAAY;AAAA,IAAE,UAAA;AAAA,IAAU,SAAA;AAAA,EAAQ,EAAE;AAAA,EAEtE,GAAG,EAAsB,CAAI;AAAA,EAC7B,GAAG,EAAmB,CAAI;AAC5B;AAEA,SAAS,IAAY;AACnB,SAAO;AACT;AAEA,SAAS,EAAW,GAAoB;AACtC,SAAA,EAAW,IAAI,CAAQ,GACvB,MAAa;AACX,IAAA,EAAW,OAAO,CAAQ;AAAA,EAC5B;AACF;AAEA,IAAa,IAAgB;AAAA,EAC3B,UAAU;AAAA,EACV,WAAW;AAAA,EAEX,UAAA,CAAW,MAA4E;AACrF,UAAM,IAAS,OAAO,KAAY,aAAa,EAAQ,CAAM,IAAI;AACjE,IAAA,IAAS;AAAA,MAAE,GAAG;AAAA,MAAQ,GAAG;AAAA,IAAO,GAChC,EAAQ;AAAA,EACV;AACF"}

package/dist/stores.js

@@ -1,54 +1,46 @@
-import { useEidosStore as i } from "./store.js";
-function a(e, t) {
+import { useEidosStore as n } from "./store.js";
+import { countQueueByStatus as a } from "./types.js";
+function c(e, t) {
   const r = Object.keys(e);
   if (r.length !== Object.keys(t).length) return !1;
-  for (const s of r) if (e[s] !== t[s]) return !1;
+  for (const u of r) if (e[u] !== t[u]) return !1;
   return !0;
 }
-function o(e, t) {
-  return a(e, t);
+function i(e, t) {
+  return c(e, t);
 }
-function u(e, t = Object.is) {
+function s(e, t = Object.is) {
   return {
     subscribe(r) {
-      let s = e(i.getState());
-      return r(s), i.subscribe(() => {
-        const n = e(i.getState());
-        t(s, n) || (s = n, r(n));
+      let u = e(n.getState());
+      return r(u), n.subscribe(() => {
+        const o = e(n.getState());
+        t(u, o) || (u = o, r(o));
       });
     },
     getState() {
-      return e(i.getState());
+      return e(n.getState());
     }
   };
 }
-var l = u((e) => e), c = u((e) => e.queue), d = u((e) => ({
+var S = s((e) => e), d = s((e) => e.queue), b = s((e) => ({
   isOnline: e.isOnline,
   swStatus: e.swStatus,
   swError: e.swError
-}), o), g = u((e) => {
-  let t = 0, r = 0, s = 0;
-  for (const n of e.queue) n.status === "pending" ? t++ : n.status === "failed" ? r++ : n.status === "replaying" && s++;
-  return {
-    pending: t,
-    failed: r,
-    replaying: s,
-    total: e.queue.length
-  };
-}, o);
-function S(e) {
-  return u((t) => t.resources[e]);
+}), i), g = s((e) => a(e.queue), i);
+function w(e) {
+  return s((t) => t.resources[e]);
 }
-function b(e) {
-  return u((t) => t.queue.find((r) => r.id === e));
+function q(e) {
+  return s((t) => t.queue.find((r) => r.id === e));
 }
 export {
-  b as eidosAction,
-  c as eidosQueue,
+  q as eidosAction,
+  d as eidosQueue,
   g as eidosQueueStats,
-  S as eidosResource,
-  d as eidosStatus,
-  l as eidosStore
+  w as eidosResource,
+  b as eidosStatus,
+  S as eidosStore
 };
 
 //# sourceMappingURL=stores.js.map

package/dist/stores.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.js","names":[],"sources":["../src/stores.ts"],"sourcesContent":["/**\n * Framework-agnostic reactive stores — compatible with Svelte's store protocol,\n * Vue's watchEffect, RxJS, and vanilla JS. Zero framework dependencies.\n *\n * Svelte: use the `$` prefix — `$eidosQueue`, `$eidosStatus`, etc.\n * Vue:    call `.subscribe()` inside a composable with `onUnmounted` cleanup.\n * Vanilla: call `.subscribe(run)` directly; the return value unsubscribes.\n *\n * Each store calls its subscriber whenever any part of the Eidos state changes.\n * For fine-grained subscriptions, use `.getState()` to read the current snapshot\n * and compare manually in the subscriber callback.\n */\n\nimport { useEidosStore } from './store';\nimport type { EidosStore } from './store';\nimport { countQueueByStatus } from './types';\nimport type { ActionQueueItem, ResourceEntry } from './types';\n\n// ── Readable<T> — compatible with Svelte's Readable interface ─────────────────\n\nexport interface EidosReadable<T> {\n  /** Subscribe to value changes. Returns an unsubscribe function. */\n  subscribe(run: (value: T) => void): () => void;\n  /** Read the current value synchronously without subscribing. */\n  getState(): T;\n}\n\nfunction shallowEqual<T extends Record<string, unknown>>(a: T, b: T): boolean {\n  const keys = Object.keys(a) as (keyof T)[];\n  if (keys.length !== Object.keys(b).length) return false;\n  for (const k of keys) if (a[k] !== b[k]) return false;\n  return true;\n}\n\n// Typed comparator alias so call sites don't need inline casts.\nfunction shallowEq<T extends Record<string, unknown>>(a: T, b: T): boolean {\n  return shallowEqual(a, b);\n}\n\nfunction readable<T>(\n  selector: (s: EidosStore) => T,\n  equal: (a: T, b: T) => boolean = Object.is,\n): EidosReadable<T> {\n  return {\n    subscribe(run) {\n      // Emit current value immediately (Svelte store contract)\n      let last = selector(useEidosStore.getState());\n      run(last);\n      return useEidosStore.subscribe(() => {\n        const next = selector(useEidosStore.getState());\n        if (!equal(last, next)) {\n          last = next;\n          run(next);\n        }\n      });\n    },\n    getState() {\n      return selector(useEidosStore.getState());\n    },\n  };\n}\n\n// ── Static stores (created once at module scope) ──────────────────────────────\n\n/** Full Eidos state snapshot. Prefer the narrower stores below. */\nexport const eidosStore: EidosReadable<EidosStore> = readable((s) => s);\n\n/** The action queue. Re-notifies on every queue mutation. */\nexport const eidosQueue: EidosReadable<ActionQueueItem[]> = readable((s) => s.queue);\n\n/**\n * Online status + SW lifecycle.\n * Only re-emits when isOnline, swStatus, or swError actually changes.\n */\nexport const eidosStatus: EidosReadable<{\n  isOnline: boolean;\n  swStatus: EidosStore['swStatus'];\n  swError: string | undefined;\n}> = readable(\n  (s) => ({ isOnline: s.isOnline, swStatus: s.swStatus, swError: s.swError }),\n  shallowEq,\n);\n\n/**\n * Queue counts. Re-emits only when a count actually changes, not on every\n * queue mutation (e.g. a status transition that doesn't change counts is skipped).\n */\nexport const eidosQueueStats: EidosReadable<{\n  pending: number;\n  failed: number;\n  replaying: number;\n  total: number;\n}> = readable((s) => countQueueByStatus(s.queue), shallowEq);\n\n// ── Dynamic stores (created per URL / ID) ─────────────────────────────────────\n\n/**\n * Live cache state for a single registered resource URL.\n * @example\n *   // Svelte\n *   const entry = eidosResource('/api/products')\n *   $: hits = $entry?.cacheHits ?? 0\n */\nexport function eidosResource(url: string): EidosReadable<ResourceEntry | undefined> {\n  return readable((s) => s.resources[url]);\n}\n\n/**\n * Live state for a single queue item by ID. Returns `undefined` once the item\n * is removed from the queue (after a successful replay or `clearQueue()`).\n * @example\n *   // Svelte\n *   const item = eidosAction(queuedResult.id)\n *   $: status = $item?.status  // 'pending' | 'replaying' | 'succeeded' | 'failed' | undefined\n */\nexport function eidosAction(id: string): EidosReadable<ActionQueueItem | undefined> {\n  return readable((s) => s.queue.find((item) => item.id === id));\n}\n"],"mappings":";;AA2BA,SAAS,EAAgD,GAAM,GAAe;AAC5E,QAAM,IAAO,OAAO,KAAK,CAAC;AAC1B,MAAI,EAAK,WAAW,OAAO,KAAK,CAAC,EAAE,OAAQ,QAAO;AAClD,aAAW,KAAK,EAAM,KAAI,EAAE,CAAA,MAAO,EAAE,CAAA,EAAI,QAAO;AAChD,SAAO;AACT;AAGA,SAAS,EAA6C,GAAM,GAAe;AACzE,SAAO,EAAa,GAAG,CAAC;AAC1B;AAEA,SAAS,EACP,GACA,IAAiC,OAAO,IACtB;AAClB,SAAO;AAAA,IACL,UAAU,GAAK;AAEb,UAAI,IAAO,EAAS,EAAc,SAAS,CAAC;AAC5C,aAAA,EAAI,CAAI,GACD,EAAc,UAAA,MAAgB;AACnC,cAAM,IAAO,EAAS,EAAc,SAAS,CAAC;AAC9C,QAAK,EAAM,GAAM,CAAI,MACnB,IAAO,GACP,EAAI,CAAI;AAAA,MAEZ,CAAC;AAAA,IACH;AAAA,IACA,WAAW;AACT,aAAO,EAAS,EAAc,SAAS,CAAC;AAAA,IAC1C;AAAA,EACF;AACF;AAKA,IAAa,IAAwC,EAAA,CAAU,MAAM,CAAC,GAGzD,IAA+C,EAAA,CAAU,MAAM,EAAE,KAAK,GAMtE,IAIR,EAAA,CACF,OAAO;AAAA,EAAE,UAAU,EAAE;AAAA,EAAU,UAAU,EAAE;AAAA,EAAU,SAAS,EAAE;AAAQ,IACzE,CACF,GAMa,IAKR,EAAA,CAAU,MAAM,EAAmB,EAAE,KAAK,GAAG,CAAS;AAW3D,SAAgB,EAAc,GAAuD;AACnF,SAAO,EAAA,CAAU,MAAM,EAAE,UAAU,CAAA,CAAI;AACzC;AAUA,SAAgB,EAAY,GAAwD;AAClF,SAAO,EAAA,CAAU,MAAM,EAAE,MAAM,KAAA,CAAM,MAAS,EAAK,OAAO,CAAE,CAAC;AAC/D"}