@sweidos/eidos 2.1.0 → 2.2.0

package/dist/index.d.ts

@@ -172,7 +172,7 @@ export declare function cancelByIdempotencyKey(idempotencyKey: string): Promise<
 /** Remove all items from the action queue (storage + in-memory store). */
 export declare function clearQueue(): Promise<void>;
 
-declare interface ConflictConfig {
+export declare interface ConflictConfig {
     /**
      * - `'serverWins'`: drop the queued item, keeping the server's state.
      * - `'clientWins'`: keep retrying — the client's write should eventually
@@ -188,7 +188,7 @@ declare interface ConflictConfig {
  * Passed to `ConflictConfig.resolve` (for `'merge'`/`'custom'` strategies)
  * when a queued action's replay receives a 4xx response.
  */
-declare interface ConflictContext {
+export declare interface ConflictContext {
     /** Whatever `fn` threw — typically a `Response` or an error with `.status`. */
     error: unknown;
     /** The original arguments the action was queued with. */
@@ -205,7 +205,7 @@ declare interface ConflictContext {
  * - `{ resolved: args }`: replace the queued args and retry immediately
  *   on the next replay pass.
  */
-declare type ConflictResolution = 'retry' | 'skip' | {
+export declare type ConflictResolution = 'retry' | 'skip' | {
     resolved: any[];
 };
 
@@ -224,6 +224,15 @@ export declare interface EidosConfig {
     swPath?: string;
     /** Automatically replay the action queue on reconnect. Default: true. */
     autoReplay?: boolean;
+    /**
+     * Opt-in reliability telemetry. Called with a snapshot of cumulative
+     * `neverLose` queue outcome counters (`ReliabilityStats`) every
+     * `reliabilityReportInterval` ms — wire this up to your analytics backend.
+     * Not called if omitted.
+     */
+    onReliabilityReport?: (stats: ReliabilityStats) => void;
+    /** Interval (ms) between `onReliabilityReport` calls. Default: 60000. */
+    reliabilityReportInterval?: number;
 }
 
 /**
@@ -262,6 +271,13 @@ export declare interface EidosReadable<T> {
     getState(): T;
 }
 
+/**
+ * Cumulative, session-scoped `neverLose` queue outcome counters — opt-in
+ * reliability telemetry. Re-emits only when a counter changes. See
+ * `EidosConfig.onReliabilityReport` to forward these to an analytics backend.
+ */
+export declare const eidosReliabilityStats: EidosReadable<ReliabilityStats>;
+
 /**
  * Live cache state for a single registered resource URL.
  * @example
@@ -277,6 +293,7 @@ export declare interface EidosState {
     swError?: string;
     resources: Record<string, ResourceEntry>;
     queue: ActionQueueItem[];
+    reliability: ReliabilityStats;
 }
 
 /**
@@ -289,7 +306,7 @@ export declare const eidosStatus: EidosReadable<{
     swError: string | undefined;
 }>;
 
-export declare interface EidosStore extends EidosState, ResourceActions, QueueActions {
+export declare interface EidosStore extends EidosState, ResourceActions, QueueActions, ReliabilityActions {
     setOnline: (online: boolean) => void;
     setSwStatus: (status: EidosState['swStatus'], error?: string) => void;
 }
@@ -321,6 +338,17 @@ export declare function isBgSyncSupported(): boolean;
 
 declare type Listener = () => void;
 
+/**
+ * Calls `callback` once each time the action queue drains from non-empty → 0.
+ * Framework-agnostic equivalent of `useEidosOnDrain` for Svelte/Vue/vanilla.
+ * Returns an unsubscribe function.
+ *
+ * @example
+ *   // Svelte
+ *   onMount(() => onQueueDrain(() => toast.success('All offline actions synced!')))
+ */
+export declare function onQueueDrain(callback: () => void): () => void;
+
 /**
  * Handle for a URL pattern (`/api/products/*`, `/api/users/:id`, `**`).
  * The SW intercepts all matching requests automatically — there is no single
@@ -372,6 +400,32 @@ export declare interface QueueStorage {
 
 export declare function registerPushCallbacks(handlers: PushHandlers): void;
 
+declare interface ReliabilityActions {
+    recordReliabilityEvent: (event: keyof ReliabilityStats) => void;
+    resetReliabilityStats: () => void;
+}
+
+/**
+ * Cumulative, session-scoped counters for `neverLose` queue outcomes — opt-in
+ * telemetry surfaced via `eidosReliabilityStats` / `useEidosReliabilityStats()`
+ * and `EidosConfig.onReliabilityReport`. Reset on page reload (not persisted).
+ */
+export declare interface ReliabilityStats {
+    [key: string]: number;
+    /** Actions persisted to the queue (offline, or online call that threw). */
+    queued: number;
+    /** Queue items that executed successfully (first attempt or a retry). */
+    succeeded: number;
+    /** Queue items that exhausted `maxRetries` and moved to `'failed'`. */
+    failed: number;
+    /** Replay attempts that failed but will retry (haven't exhausted `maxRetries`). */
+    retried: number;
+    /** Queue items dropped by a `serverWins`/`merge`/`custom` conflict resolution. */
+    conflicted: number;
+    /** Queue items removed via `handle.cancel(idempotencyKey)` before replay completed. */
+    cancelled: number;
+}
+
 export declare function replayQueue(): Promise<ReplayResult>;
 
 /** Summary returned by replayQueue(). */
@@ -507,14 +561,6 @@ export declare function useEidos(): EidosStore;
  */
 export declare function useEidosAction(id: string): ActionQueueItem | undefined;
 
-/**
- * Calls `callback` once each time the action queue drains from non-empty → 0.
- * Stable callback reference not required — always calls the latest version.
- * Use for "all offline actions synced!" toasts.
- *
- * @example
- * useEidosOnDrain(() => toast.success('All offline actions synced!'))
- */
 export declare function useEidosOnDrain(callback: () => void): void;
 
 /** The current action queue. */
@@ -532,6 +578,21 @@ export declare function useEidosQueueStats(): {
     total: number;
 };
 
+/**
+ * Calls `callback` once each time the action queue drains from non-empty → 0.
+ * Stable callback reference not required — always calls the latest version.
+ * Use for "all offline actions synced!" toasts.
+ *
+ * @example
+ * useEidosOnDrain(() => toast.success('All offline actions synced!'))
+ */
+/**
+ * Cumulative, session-scoped `neverLose` queue outcome counters — opt-in
+ * reliability telemetry for dashboards/devtools. Re-renders only when a
+ * counter changes.
+ */
+export declare function useEidosReliabilityStats(): ReliabilityStats;
+
 /** Live state for a single registered resource URL. */
 export declare function useEidosResource(url: string): ResourceEntry;
 
@@ -555,7 +616,7 @@ export declare const useEidosStore: {
     setState: (partial: Partial<EidosStore> | ((s: EidosStore) => Partial<EidosStore>)) => void;
 };
 
-export declare const VERSION = "2.1.0";
+export declare const VERSION = "2.2.0";
 
 /**
  * Bulk-prefetch an array of resource handles concurrently, warming the cache

package/dist/index.js

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

package/dist/react/hooks.js

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

package/dist/react/hooks.js.map

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

package/dist/runtime.js

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

package/dist/runtime.js.map

@@ -1 +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"}
+{"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, ReliabilityStats } 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   * Opt-in reliability telemetry. Called with a snapshot of cumulative\n   * `neverLose` queue outcome counters (`ReliabilityStats`) every\n   * `reliabilityReportInterval` ms — wire this up to your analytics backend.\n   * Not called if omitted.\n   */\n  onReliabilityReport?: (stats: ReliabilityStats) => void;\n  /** Interval (ms) between `onReliabilityReport` calls. Default: 60000. */\n  reliabilityReportInterval?: number;\n}\n\nlet _initialized = false;\nlet _unsubscribe: (() => void) | null = null;\nlet _unsubscribeQueueSync: (() => void) | null = null;\nlet _reliabilityReportTimer: ReturnType<typeof setInterval> | 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 (config.onReliabilityReport) {\n    const interval = config.reliabilityReportInterval ?? 60_000;\n    const report = config.onReliabilityReport;\n    _reliabilityReportTimer = setInterval(() => {\n      report(useEidosStore.getState().reliability);\n    }, interval);\n  }\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  if (_reliabilityReportTimer) clearInterval(_reliabilityReportTimer);\n  _reliabilityReportTimer = 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;AAkBA,IAAI,IAAe,IACf,IAAoC,MACpC,IAA6C,MAC7C,IAAiE;AAErE,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;AAmBA,MAdA,EAAA,MAA4B;AAC1B,IAAI,EAAc,SAAS,EAAE,YAC3B,WAAW,GAAa,GAAG;AAAA,EAE/B,CAAC,GAEG,MACF,IAAe,EAA2B,IAK5C,IAAwB,EAAmB,GAEvC,EAAO,qBAAqB;AAC9B,UAAM,IAAW,EAAO,6BAA6B,KAC/C,IAAS,EAAO;AACtB,IAAA,IAA0B,YAAA,MAAkB;AAC1C,MAAA,EAAO,EAAc,SAAS,EAAE,WAAW;AAAA,IAC7C,GAAG,CAAQ;AAAA,EACb;AAUF;AAEA,SAAgB,IAAc;AAC5B,EAAA,IAAe,GACf,IAAe,MACf,IAAwB,GACxB,IAAwB,MACpB,KAAyB,cAAc,CAAuB,GAClE,IAA0B,MAC1B,IAAe;AACjB"}

package/dist/store-slices.js

@@ -1,43 +1,54 @@
-function t(o) {
+import { emptyReliabilityStats as o } from "./types.js";
+function s(t) {
   return {
-    registerResource: (e, r) => o((u) => ({ resources: {
+    registerResource: (e, r) => t((u) => ({ resources: {
       ...u.resources,
       [e]: r
     } })),
-    updateResource: (e, r) => o((u) => ({ resources: {
+    updateResource: (e, r) => t((u) => ({ resources: {
       ...u.resources,
       [e]: u.resources[e] ? {
         ...u.resources[e],
         ...r
       } : u.resources[e]
     } })),
-    unregisterResource: (e) => o((r) => ({ resources: Object.fromEntries(Object.entries(r.resources).filter(([u]) => u !== e)) }))
+    unregisterResource: (e) => t((r) => ({ resources: Object.fromEntries(Object.entries(r.resources).filter(([u]) => u !== e)) }))
   };
 }
-function n(o) {
+function n(t) {
   return {
-    addQueueItem: (e) => o((r) => ({ queue: [...r.queue, e] })),
-    updateQueueItem: (e, r) => o((u) => ({ queue: u.queue.map((c) => c.id === e ? {
-      ...c,
+    addQueueItem: (e) => t((r) => ({ queue: [...r.queue, e] })),
+    updateQueueItem: (e, r) => t((u) => ({ queue: u.queue.map((i) => i.id === e ? {
+      ...i,
       ...r
-    } : c) })),
-    batchUpdateQueueItems: (e) => o((r) => {
-      const u = new Map(e.map((c) => [c.id, c.update]));
-      return { queue: r.queue.map((c) => {
-        const s = u.get(c.id);
-        return s ? {
-          ...c,
-          ...s
-        } : c;
+    } : i) })),
+    batchUpdateQueueItems: (e) => t((r) => {
+      const u = new Map(e.map((i) => [i.id, i.update]));
+      return { queue: r.queue.map((i) => {
+        const c = u.get(i.id);
+        return c ? {
+          ...i,
+          ...c
+        } : i;
       }) };
     }),
-    removeQueueItem: (e) => o((r) => ({ queue: r.queue.filter((u) => u.id !== e) })),
-    hydrateQueue: (e) => o(() => ({ queue: e }))
+    removeQueueItem: (e) => t((r) => ({ queue: r.queue.filter((u) => u.id !== e) })),
+    hydrateQueue: (e) => t(() => ({ queue: e }))
+  };
+}
+function l(t) {
+  return {
+    recordReliabilityEvent: (e) => t((r) => ({ reliability: {
+      ...r.reliability,
+      [e]: r.reliability[e] + 1
+    } })),
+    resetReliabilityStats: () => t(() => ({ reliability: o() }))
   };
 }
 export {
   n as createQueueActions,
-  t as createResourceActions
+  l as createReliabilityActions,
+  s as createResourceActions
 };
 
 //# sourceMappingURL=store-slices.js.map

package/dist/store-slices.js.map

@@ -1 +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"}
+{"version":3,"file":"store-slices.js","names":[],"sources":["../src/store-slices.ts"],"sourcesContent":["import type { ResourceEntry, ActionQueueItem, ReliabilityStats } from './types';\nimport { emptyReliabilityStats } 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\n// ── Reliability slice ─────────────────────────────────────────────────────────\n\nexport interface ReliabilityActions {\n  recordReliabilityEvent: (event: keyof ReliabilityStats) => void;\n  resetReliabilityStats: () => void;\n}\n\nexport function createReliabilityActions(set: Setter): ReliabilityActions {\n  return {\n    recordReliabilityEvent: (event) =>\n      set((s) => ({ reliability: { ...s.reliability, [event]: s.reliability[event] + 1 } })),\n\n    resetReliabilityStats: () => set(() => ({ reliability: emptyReliabilityStats() })),\n  };\n}\n"],"mappings":";AAcA,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;AASA,SAAgB,EAAyB,GAAiC;AACxE,SAAO;AAAA,IACL,wBAAA,CAAyB,MACvB,EAAA,CAAK,OAAO,EAAE,aAAa;AAAA,MAAE,GAAG,EAAE;AAAA,OAAc,CAAA,GAAQ,EAAE,YAAY,CAAA,IAAS;AAAA,IAAE,EAAE,EAAE;AAAA,IAEvF,uBAAA,MAA6B,EAAA,OAAW,EAAE,aAAa,EAAsB,EAAE,EAAE;AAAA,EACnF;AACF"}

package/dist/store.js

@@ -1,9 +1,10 @@
-import { createQueueActions as u, createResourceActions as i } from "./store-slices.js";
-var t, s = /* @__PURE__ */ new Set();
+import { emptyReliabilityStats as s } from "./types.js";
+import { createQueueActions as a, createReliabilityActions as u, createResourceActions as c } from "./store-slices.js";
+var t, o = /* @__PURE__ */ new Set();
 function r() {
-  s.forEach((e) => e());
+  o.forEach((e) => e());
 }
-function n(e) {
+function i(e) {
   t = {
     ...t,
     ...e(t)
@@ -15,35 +16,37 @@ t = {
   swError: void 0,
   resources: {},
   queue: [],
-  setOnline: (e) => n(() => ({ isOnline: e })),
-  setSwStatus: (e, o) => n(() => ({
+  reliability: s(),
+  setOnline: (e) => i(() => ({ isOnline: e })),
+  setSwStatus: (e, n) => i(() => ({
     swStatus: e,
-    swError: o
+    swError: n
   })),
-  ...i(n),
-  ...u(n)
+  ...c(i),
+  ...a(i),
+  ...u(i)
 };
-function a() {
+function f() {
   return t;
 }
-function c(e) {
-  return s.add(e), () => {
-    s.delete(e);
+function d(e) {
+  return o.add(e), () => {
+    o.delete(e);
   };
 }
-var d = {
-  getState: a,
-  subscribe: c,
+var b = {
+  getState: f,
+  subscribe: d,
   setState: (e) => {
-    const o = typeof e == "function" ? e(t) : e;
+    const n = typeof e == "function" ? e(t) : e;
     t = {
       ...t,
-      ...o
+      ...n
     }, r();
   }
 };
 export {
-  d as useEidosStore
+  b as useEidosStore
 };
 
 //# sourceMappingURL=store.js.map