@sweidos/eidos 2.2.0 → 2.3.1

package/dist/index.js

@@ -1,45 +1,48 @@
 import { useEidosStore as o } from "./store.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 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 { 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 { 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";
+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,
-  Y as VERSION,
-  f as _getQueueStorage,
-  P as _resetEidos,
+  Z as VERSION,
+  E as _getQueueStorage,
+  D as _resetEidos,
   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,
+  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,
-  h as initEidos,
-  s as isBgSyncSupported,
+  P as initEidos,
+  t as isBgSyncSupported,
   V as onQueueDrain,
-  t as registerPushCallbacks,
-  R as replayQueue,
-  b as requeueItem,
-  d as resource,
-  n as resourcePattern,
+  s as registerPushCallbacks,
+  b as replayQueue,
+  I as requeueItem,
+  n as resource,
+  p as resourcePattern,
   u as sendToWorker,
-  a as setOfflineSimulation,
+  m as setOfflineSimulation,
   c as setQueryInvalidator,
-  E as setQueueStorage,
-  O as subscribeReplayOnReconnect,
+  l as setQueueStorage,
+  w as subscribeReplayOnReconnect,
+  a as triggerSwUpdate,
   j as useEidos,
   z as useEidosAction,
   F as useEidosOnDrain,
@@ -48,7 +51,7 @@ export {
   J as useEidosReliabilityStats,
   L as useEidosResource,
   M as useEidosResources,
-  U as useEidosStatus,
+  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/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 {};

package/dist/resource.js

@@ -1,48 +1,51 @@
 import { useEidosStore as h } from "./store.js";
-import { sendToWorker as p } from "./sw-bridge.js";
-var d = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), g = null;
-function _(e) {
-  g = e;
+import { sendToWorker as m } from "./sw-bridge.js";
+var d = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), w = null;
+function q(e) {
+  w = e;
 }
 function f(e) {
   return e.includes("*") || /:[^/]+/.test(e);
 }
-function k(e) {
+function R(e) {
   return "^" + e.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]+").replace(/:[^/]+/g, "[^/]+") + "$";
 }
-function m(e, s) {
-  const a = b(s), t = f(e) ? k(e) : void 0, r = {
+function v(e, a) {
+  const s = S(a), t = f(e) ? R(e) : void 0, r = {
     url: e,
-    config: s,
-    strategy: a,
+    config: a,
+    strategy: s,
     status: "idle",
     cacheHits: 0,
     cacheMisses: 0
   };
-  return h.getState().registerResource(e, r), p({
+  return h.getState().registerResource(e, r), m({
     type: "EIDOS_REGISTER_RESOURCE",
     url: e,
-    strategy: a.swStrategy,
-    cacheName: a.cacheName,
-    ...t !== void 0 && { pattern: t }
+    strategy: s.swStrategy,
+    cacheName: s.cacheName,
+    ...t !== void 0 && { pattern: t },
+    ...a.maxAge !== void 0 && { maxAge: a.maxAge },
+    ...a.maxEntries !== void 0 && { maxEntries: a.maxEntries },
+    ...a.networkTimeoutMs !== void 0 && { networkTimeoutMs: a.networkTimeoutMs }
   }), {
-    strategy: a,
+    strategy: s,
     regexStr: t
   };
 }
-function y(e, s, a) {
+function y(e, a, s) {
   return async () => {
-    p({
+    m({
       type: "EIDOS_CLEAR_CACHE",
       url: e
     });
-    const t = await caches.open(s.cacheName).catch(() => null);
+    const t = await caches.open(a.cacheName).catch(() => null);
     if (t) {
-      const r = await t.keys(), n = a ? new RegExp(a) : null, c = e.startsWith("http");
-      await Promise.all(r.filter((i) => {
-        const o = i.url, u = new URL(o).pathname;
-        return n ? n.test(c ? o : u) : c ? o === e : o === e || u === e;
-      }).map((i) => t.delete(i)));
+      const r = await t.keys(), n = s ? new RegExp(s) : null, i = e.startsWith("http");
+      await Promise.all(r.filter((c) => {
+        const o = c.url, u = new URL(o).pathname;
+        return n ? n.test(i ? o : u) : i ? o === e : o === e || u === e;
+      }).map((c) => t.delete(c)));
     }
     f(e) || h.getState().updateResource(e, {
       status: "stale",
@@ -50,30 +53,30 @@ function y(e, s, a) {
       lastEvent: "cache-cleared",
       cacheHits: 0,
       cacheMisses: 0
-    }), g?.(["eidos", e]);
+    }), w?.(["eidos", e]);
   };
 }
 function E(e) {
   return () => {
-    d.delete(e), p({
+    d.delete(e), m({
       type: "EIDOS_UNREGISTER_RESOURCE",
       url: e
     }), h.getState().unregisterResource(e);
   };
 }
-function A(e, s) {
+function _(e, a) {
   if (f(e)) throw new Error(`[eidos] resource('${e}') is a URL pattern — use resourcePattern('${e}', config) instead. Pattern handles only support invalidate()/unregister(); the SW intercepts matching requests automatically.`);
   if (d.has(e)) return d.get(e);
-  const { strategy: a } = m(e, s), t = {
+  const { strategy: s } = v(e, a), t = {
     url: e,
-    config: s,
-    strategy: a,
+    config: a,
+    strategy: s,
     fetch: async () => {
       const r = l.get(e);
-      if (r) return r.then((c) => c.clone());
-      const n = S(e, s, a);
+      if (r) return r.then((i) => i.clone());
+      const n = k(e, a, s);
       return l.set(e, n), n.finally(() => l.delete(e)).catch(() => {
-      }), n.then((c) => c.clone());
+      }), n.then((i) => i.clone());
     },
     json: async () => (await t.fetch()).json(),
     query: () => ({
@@ -83,47 +86,47 @@ function A(e, s) {
     prefetch: async () => {
       await t.fetch();
     },
-    invalidate: y(e, a, void 0),
+    invalidate: y(e, s, void 0),
     unregister: E(e)
   };
   return d.set(e, t), t;
 }
-function $(e, s) {
+function T(e, a) {
   if (!f(e)) throw new Error(`[eidos] resourcePattern('${e}') is not a URL pattern — use resource('${e}', config) instead.`);
   if (d.has(e)) return d.get(e);
-  const { strategy: a, regexStr: t } = m(e, s), r = {
+  const { strategy: s, regexStr: t } = v(e, a), r = {
     url: e,
-    config: s,
-    strategy: a,
-    invalidate: y(e, a, t),
+    config: a,
+    strategy: s,
+    invalidate: y(e, s, t),
     unregister: E(e)
   };
   return d.set(e, r), r;
 }
-async function S(e, s, a) {
+async function k(e, a, s) {
   const t = h.getState();
   t.updateResource(e, {
     status: "fetching",
     fetchedAt: Date.now()
   });
-  const r = await caches.open(a.cacheName).catch(() => null);
+  const r = await caches.open(s.cacheName).catch(() => null);
   try {
-    if (a.swStrategy !== "network-first") {
-      const i = r ? await r.match(e).catch(() => null) : null, o = h.getState().resources[e], u = s.maxAge !== void 0 && o?.cachedAt !== void 0 && Date.now() - o.cachedAt > s.maxAge;
-      if (i && !u)
+    if (s.swStrategy !== "network-first") {
+      const c = r ? await r.match(e).catch(() => null) : null, o = h.getState().resources[e], u = a.maxAge !== void 0 && o?.cachedAt !== void 0 && Date.now() - o.cachedAt > a.maxAge;
+      if (c && !u)
         return t.updateResource(e, {
           status: "fresh",
           lastEvent: "cache-hit",
           cacheHits: (o?.cacheHits ?? 0) + 1
-        }), 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, {
+        }), s.swStrategy === "stale-while-revalidate" && fetch(e, { signal: AbortSignal.timeout(a.networkTimeoutMs ?? 3e3) }).then(async (g) => {
+          g.ok && r && (await r.put(e, g.clone()), h.getState().updateResource(e, {
             cachedAt: Date.now(),
             lastEvent: "cache-updated"
           }));
         }).catch(() => {
-        }), i;
-      const R = h.getState().resources[e];
-      t.updateResource(e, { cacheMisses: (R?.cacheMisses ?? 0) + 1 });
+        }), c;
+      const x = h.getState().resources[e];
+      t.updateResource(e, { cacheMisses: (x?.cacheMisses ?? 0) + 1 });
     }
     const n = await fetch(e);
     if (n.ok)
@@ -133,30 +136,30 @@ async function S(e, s, a) {
         lastEvent: "cache-updated"
       }), 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}`);
+    const i = n.headers.get("X-Eidos-Offline") === "true";
+    throw new Error(i ? `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];
+    const i = r ? await r.match(e).catch(() => null) : null;
+    if (i) {
+      const c = h.getState().resources[e];
       return t.updateResource(e, {
         status: "fresh",
         lastEvent: "cache-hit",
-        cacheHits: (i?.cacheHits ?? 0) + 1
-      }), c;
+        cacheHits: (c?.cacheHits ?? 0) + 1
+      }), i;
     }
     throw t.updateResource(e, { status: "error" }), n;
   }
 }
-function b(e) {
-  const s = e.strategy;
-  return e.offline ? v(s ?? "stale-while-revalidate", e.cacheName, e.version) : v(s ?? "network-first", e.cacheName, e.version);
+function S(e) {
+  const a = e.strategy;
+  return e.offline ? p(a ?? "stale-while-revalidate", e.cacheName, e.version) : p(a ?? "network-first", e.cacheName, e.version);
 }
-var x = {
+var A = {
   "stale-while-revalidate": "StaleWhileRevalidate",
   "cache-first": "CacheFirst",
   "network-first": "NetworkFirst"
-}, C = {
+}, b = {
   "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: [
@@ -165,10 +168,10 @@ var x = {
       "Offline → return cached version if available, 503 if not",
       "Reconnect → next request triggers a background refresh"
     ],
-    equivalentCode: `// Workbox equivalent
+    equivalentCode: `// Workbox equivalent (maxEntries/maxAge are configured via ResourceConfig)
 new StaleWhileRevalidate({
   cacheName: 'eidos-resources-v1',
-  plugins: [new ExpirationPlugin({ maxEntries: 60 })],
+  plugins: [new ExpirationPlugin({ maxEntries: config.maxEntries, maxAgeSeconds: config.maxAge && config.maxAge / 1000 })],
 })`
   },
   "cache-first": {
@@ -177,12 +180,12 @@ new StaleWhileRevalidate({
       "Cache hit → return immediately, no network request made",
       "Cache miss → fetch from network, cache the response, return it",
       "Offline → return cached version, 503 if cache is empty",
-      "Cache never expires unless explicitly invalidated"
+      "Cache never expires unless maxAge is set or explicitly invalidated"
     ],
-    equivalentCode: `// Workbox equivalent
+    equivalentCode: `// Workbox equivalent (maxEntries/maxAge are configured via ResourceConfig)
 new CacheFirst({
   cacheName: 'eidos-resources-v1',
-  plugins: [new ExpirationPlugin({ maxEntries: 60 })],
+  plugins: [new ExpirationPlugin({ maxEntries: config.maxEntries, maxAgeSeconds: config.maxAge && config.maxAge / 1000 })],
 })`
   },
   "network-first": {
@@ -196,34 +199,34 @@ new CacheFirst({
     equivalentCode: `// Workbox equivalent
 new NetworkFirst({
   cacheName: 'eidos-resources-v1',
-  networkTimeoutSeconds: 3,
+  networkTimeoutSeconds: 3, // controlled via ResourceConfig.networkTimeoutMs (default 3000)
 })`
   }
 };
-function v(e, s, a) {
-  const t = C[e], r = s ?? "eidos-resources-v1";
+function p(e, a, s) {
+  const t = b[e], r = a ?? "eidos-resources-v1";
   return {
-    name: x[e],
+    name: A[e],
     swStrategy: e,
-    cacheName: a !== void 0 ? `${r}-v${a}` : r,
+    cacheName: s !== void 0 ? `${r}-v${s}` : r,
     reasoning: t.reasoning,
     behavior: t.behavior,
     equivalentCode: ""
   };
 }
-async function O(e) {
-  const s = await Promise.allSettled(e.map((t) => t.prefetch())), a = s.filter((t) => t.status === "rejected").map((t) => t.reason);
+async function M(e) {
+  const a = await Promise.allSettled(e.map((t) => t.prefetch())), s = a.filter((t) => t.status === "rejected").map((t) => t.reason);
   return {
-    warmed: s.filter((t) => t.status === "fulfilled").length,
-    failed: a.length,
-    errors: a
+    warmed: a.filter((t) => t.status === "fulfilled").length,
+    failed: s.length,
+    errors: s
   };
 }
 export {
-  A as resource,
-  $ as resourcePattern,
-  _ as setQueryInvalidator,
-  O as warmCache
+  _ as resource,
+  T as resourcePattern,
+  q as setQueryInvalidator,
+  M as warmCache
 };
 
 //# sourceMappingURL=resource.js.map