@sweidos/eidos 2.1.0 → 2.3.0

package/dist/index.js

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

package/dist/internal/url-base64.d.ts

@@ -0,0 +1,2 @@
+/** Decodes a base64url string (e.g. a VAPID public key) into raw bytes. */
+export declare function urlBase64ToUint8Array(base64Url: string): Uint8Array;

package/dist/query.d.ts

@@ -1,6 +1,5 @@
 import { UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult, QueryClient } from '@tanstack/react-query';
-import { ResourceHandle, AnyResourceHandle, ActionHandle, QueuedResult } from '@sweidos/eidos';
-
+import { ResourceHandle, AnyResourceHandle, ActionHandle, QueuedResult } from './index.ts';
 /**
  * Register a QueryClient with Eidos.
  *

package/dist/queue-storage.d.ts

@@ -0,0 +1,12 @@
+import { ActionQueueItem } from './types';
+export interface QueueStorage {
+    add(item: ActionQueueItem): Promise<void>;
+    getAll(): Promise<ActionQueueItem[]>;
+    getPending(): Promise<ActionQueueItem[]>;
+    update(id: string, patch: Partial<ActionQueueItem>): Promise<void>;
+    remove(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/** Override the default IndexedDB queue with a custom storage backend (e.g. AsyncStorage for React Native). */
+export declare function setQueueStorage(s: QueueStorage): void;
+export declare function _getQueueStorage(): QueueStorage | null;

package/dist/queue-sync.d.ts

@@ -0,0 +1,32 @@
+import { ActionQueueItem } from './types';
+type QueueSyncMessage = {
+    type: 'update';
+    id: string;
+    update: Partial<ActionQueueItem>;
+} | {
+    type: 'batchUpdate';
+    updates: Array<{
+        id: string;
+        update: Partial<ActionQueueItem>;
+    }>;
+} | {
+    type: 'remove';
+    id: string;
+};
+/**
+ * Broadcasts a queue-item status change to other tabs sharing the same
+ * IndexedDB queue. The replay-lock holder (see `replayQueue` in action.ts)
+ * is the only tab that mutates queue-item status, so non-leader tabs would
+ * otherwise show stale status until their own store re-hydrates.
+ *
+ * No-ops in environments without BroadcastChannel (React Native, old Safari).
+ */
+export declare function broadcastQueueSync(message: QueueSyncMessage): void;
+/**
+ * Applies queue-item status updates broadcast by the replay-lock holder to
+ * this tab's store. Returns an unsubscribe function.
+ */
+export declare function subscribeQueueSync(): () => void;
+/** Test-only: reset the cached channel so each test gets a fresh instance. */
+export declare function _resetQueueSyncChannel(): void;
+export {};

package/dist/react/Provider.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { EidosConfig } from '../runtime';
+interface EidosProviderProps extends EidosConfig {
+    children: ReactNode;
+}
+/**
+ * Mount once at the root of your application.
+ * Registers the service worker and initialises the Eidos runtime.
+ *
+ * @example
+ * <EidosProvider swPath="/eidos-sw.js">
+ *   <App />
+ * </EidosProvider>
+ */
+export declare function EidosProvider({ children, swPath, autoReplay }: EidosProviderProps): import("react").JSX.Element;
+export {};

package/dist/react/ProviderRN.d.ts

@@ -1,5 +1,4 @@
 import { default as React } from 'react';
-
 export interface EidosProviderRNProps {
     children: React.ReactNode;
     /**

package/dist/react/hooks.d.ts

@@ -0,0 +1,51 @@
+import { EidosStore } from '../store';
+/** Full Eidos store — prefer the narrower hooks below for performance. */
+export declare function useEidos(): EidosStore;
+/** All registered resources — only re-renders when the resources map changes, not on queue mutations. */
+export declare function useEidosResources(): Record<string, import('..').ResourceEntry>;
+/** Live state for a single registered resource URL. */
+export declare function useEidosResource(url: string): import('..').ResourceEntry;
+/** The current action queue. */
+export declare function useEidosQueue(): import('..').ActionQueueItem[];
+/**
+ * Live state for a single queue item by ID. Only re-renders when that specific
+ * item changes — cheaper than `useEidosQueue().find(id)` which re-renders on
+ * any queue mutation.
+ */
+export declare function useEidosAction(id: string): import('..').ActionQueueItem | undefined;
+/**
+ * Online + SW status — cheap subscription, safe to use in header components.
+ * Three separate primitive selectors so each only triggers a re-render when
+ * its own value changes (no object-reference churn from a combined selector).
+ */
+export declare function useEidosStatus(): {
+    isOnline: boolean;
+    swStatus: "idle" | "error" | "registering" | "active" | "unsupported";
+    swError: string | undefined;
+};
+/**
+ * Queue counts — single subscription, single loop. Re-renders only when a
+ * count changes, not on every queue mutation. Use for badges and status bars
+ * instead of `useEidosQueue()` when you only need numbers, not full items.
+ */
+export declare function useEidosQueueStats(): {
+    pending: number;
+    failed: number;
+    replaying: number;
+    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(): import('..').ReliabilityStats;
+export declare function useEidosOnDrain(callback: () => void): void;

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/replay.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Subscribe to online/offline transitions and trigger replayQueue() on
+ * reconnect, plus replay any pending items left over from a previous session.
+ *
+ * Shared by the web (runtime.ts) and React Native (runtime-rn.ts) init paths.
+ *
+ * WHY subscribe to the store instead of window.addEventListener('online'):
+ * setOfflineSimulation() updates the store directly but never fires a real
+ * browser `online` event. Watching the store catches both:
+ *   • Real network reconnects (sw-bridge updates store on window.online)
+ *   • Simulation toggled off (setOfflineSimulation(false) → store.setOnline(true))
+ *
+ * Returns an unsubscribe function.
+ */
+export declare function subscribeReplayOnReconnect(): () => void;

package/dist/resource.d.ts

@@ -0,0 +1,32 @@
+import { ResourceConfig, ResourceHandle, PatternResourceHandle, WarmCacheResult } from './types';
+type QueryInvalidator = (queryKey: [string, string]) => void;
+/** @internal Called by @sweidos/eidos/query. */
+export declare function setQueryInvalidator(fn: QueryInvalidator): void;
+/**
+ * Registers a concrete-URL resource. For URL patterns (`/api/products/*`,
+ * `/api/users/:id`, `**`), use `resourcePattern()` instead.
+ */
+export declare function resource<T = unknown>(url: string, config: ResourceConfig): ResourceHandle<T>;
+/**
+ * Registers a URL pattern (`/api/products/*`, `/api/users/:id`, `**`). The SW
+ * intercepts all matching requests automatically — there is no single URL to
+ * fetch/cache directly, so the returned handle only supports cache management
+ * (`invalidate`/`unregister`). For a fetchable resource, use `resource()`.
+ */
+export declare function resourcePattern(url: string, config: ResourceConfig): PatternResourceHandle;
+/**
+ * Bulk-prefetch an array of resource handles concurrently, warming the cache
+ * for each one. Useful on login / app init when you know which resources the
+ * user will need offline.
+ *
+ * Pattern handles (containing `*`, `**`, or `:param`) are silently skipped —
+ * they match multiple URLs so there is no single URL to prefetch.
+ *
+ * @example
+ * import { warmCache } from '@sweidos/eidos'
+ *
+ * // In EidosProvider's onReady, or after login:
+ * const { warmed, failed } = await warmCache([products, userProfile, settings])
+ */
+export declare function warmCache(handles: ResourceHandle[]): Promise<WarmCacheResult>;
+export {};