@sweidos/eidos 2.2.0 → 2.3.0

package/dist/idb.d.ts

@@ -0,0 +1,10 @@
+import { ActionQueueItem } from './types';
+import { QueueStorage } from './queue-storage';
+export declare function idbAddToQueue(item: ActionQueueItem): Promise<void>;
+export declare function idbGetQueue(): Promise<ActionQueueItem[]>;
+export declare function idbUpdateQueueItem(id: string, update: Partial<ActionQueueItem>): Promise<void>;
+export declare function idbRemoveFromQueue(id: string): Promise<void>;
+export declare function idbGetPendingItems(): Promise<ActionQueueItem[]>;
+export declare function idbClearQueue(): Promise<void>;
+/** IndexedDB-backed QueueStorage implementation (default for browser environments). */
+export declare const idbQueueStorage: QueueStorage;

package/dist/index.d.ts

@@ -1,647 +1,20 @@
-import { JSX } from 'react';
-import { ReactNode } from 'react';
-
-export declare function action<TArgs extends any[], TReturn>(fn: ActionFn<TArgs, TReturn>, config: ActionConfig<TArgs>): ActionHandle<TArgs, TReturn>;
-
-export declare type ActionConfig<TArgs extends any[] = any[]> = (ActionConfigBase<TArgs> & {
-    /** Call directly, no persistence on failure. */
-    reliability: 'best-effort';
-}) | (ActionConfigBase<TArgs> & {
-    /** Persist to IndexedDB before executing; replay on reconnect. */
-    reliability: 'neverLose';
-    /**
-     * Required for `neverLose` — queued items must survive a page reload
-     * and be matched back to this action on replay. `fn.name` is not
-     * reliable (minifiers rename it, arrow functions may be anonymous).
-     */
-    name: string;
-});
-
-declare interface ActionConfigBase<TArgs extends any[] = any[]> {
-    /** Max retry attempts before marking as failed. Default: 3. */
-    maxRetries?: number;
-    /** Human-readable name for the action (used in devtools). */
-    name?: string;
-    /**
-     * Prefixes the registered action id (`namespace::name`). Use to avoid
-     * collisions when two actions share a name (e.g. across micro-frontends,
-     * or two `createOrder` actions in different modules) — without a
-     * namespace, the second registration silently overwrites the first.
-     */
-    namespace?: string;
-    /**
-     * Replay order when multiple queued actions are pending.
-     * `'high'` items replay before `'normal'`, which replay before `'low'`.
-     * Each tier completes fully before the next tier begins.
-     * Default: `'normal'`.
-     */
-    priority?: 'high' | 'normal' | 'low';
-    /**
-     * Called immediately before the async function executes, with the same args
-     * plus a trailing `ActionContext`. Use to apply an optimistic UI update (add
-     * item, mark as pending, etc.) and to capture `idempotencyKey` for later
-     * `handle.cancel(idempotencyKey)` calls. Called on every invocation —
-     * online, offline, and during queue replay.
-     */
-    onOptimistic?: (...args: [...TArgs, ActionContext]) => void;
-    /**
-     * Called when the action permanently fails and will not be retried.
-     * - `best-effort`: called on first throw.
-     * - `neverLose`: called when `maxRetries` is exhausted (status → `'failed'`).
-     * Use to revert the optimistic update.
-     */
-    onRollback?: (...args: [...TArgs, ActionContext]) => void;
-    /**
-     * Declarative conflict-resolution strategy used during queue replay when
-     * the server responds with a 4xx status (conflict, gone, unprocessable,
-     * etc.). If not provided, 4xx errors are treated identically to other
-     * errors (retried until `maxRetries` is exhausted, then `onRollback` is
-     * called). See `ConflictConfig`.
-     */
-    conflict?: ConflictConfig;
-    /**
-     * When `true`, each invocation gets an `AbortController` whose `signal` is
-     * passed via `ActionContext.signal`. Forward it to `fetch`/etc. so
-     * `handle.cancel(idempotencyKey)` can abort an in-flight call, or remove a
-     * not-yet-replayed queued item.
-     */
-    cancellable?: boolean;
-}
-
-/**
- * Passed as an extra argument after the declared params to `neverLose` actions,
- * on every invocation (initial call, offline queue, and replay). The same
- * `idempotencyKey` is reused across all retries of one logical invocation —
- * forward it to your server (e.g. as an `Idempotency-Key` header) so a retry
- * that reaches the server after a dropped response doesn't double-execute.
- */
-export declare interface ActionContext {
-    idempotencyKey: string;
-    /** 0 on the first attempt, incremented on each replay retry. */
-    attempt: number;
-    /** Set when `config.cancellable` is true. Forward to `fetch`/etc. for cancellation support. */
-    signal?: AbortSignal;
-}
-
-/**
- * Every action function receives its declared args plus a trailing
- * `ActionContext` — on every invocation (online, offline, and replay).
- */
-export declare type ActionFn<TArgs extends unknown[], TReturn> = (...args: [...TArgs, ActionContext]) => Promise<TReturn>;
-
-export declare interface ActionHandle<TArgs extends any[], TReturn> {
-    (...args: TArgs): Promise<TReturn | QueuedResult>;
-    readonly id: string;
-    readonly config: ActionConfig;
-    /**
-     * Cancel an invocation by its `idempotencyKey` (from `ActionContext` /
-     * `onOptimistic`). Aborts the in-flight call if `cancellable: true` and
-     * still running, otherwise removes a not-yet-replayed queued item.
-     * Returns `true` if something was cancelled/removed.
-     */
-    cancel: (idempotencyKey: string) => Promise<boolean>;
-}
-
-export declare interface ActionQueueItem {
-    /** Shape version this item was persisted with. Items from before v2 are migrated on load. */
-    schemaVersion: number;
-    id: string;
-    /** ID of the registered action (maps to the function in the registry). */
-    actionId: string;
-    actionName: string;
-    /**
-     * Stable per-invocation key, generated once and reused across every retry/replay
-     * of this item. Pass to your server as an idempotency key so retries that reach
-     * the server after a dropped response don't double-execute.
-     */
-    idempotencyKey: string;
-    args: unknown[];
-    queuedAt: number;
-    retryCount: number;
-    maxRetries: number;
-    status: 'pending' | 'replaying' | 'succeeded' | 'failed';
-    /** Replay priority. High items replay before normal, normal before low. Default: 'normal'. */
-    priority?: 'high' | 'normal' | 'low';
-    error?: string;
-    completedAt?: number;
-    /** Earliest timestamp at which this item should be retried (exponential backoff). */
-    nextRetryAt?: number;
-}
-
-/** A handle returned by either `resource()` or `resourcePattern()`. */
-export declare type AnyResourceHandle = ResourceHandle<any> | PatternResourceHandle;
-
-/** Minimal subset of @react-native-async-storage/async-storage (or any compatible key-value store). */
-export declare interface AsyncStorageLike {
-    getItem(key: string): Promise<string | null>;
-    setItem(key: string, value: string): Promise<void>;
-    removeItem(key: string): Promise<void>;
-}
-
-/**
- * QueueStorage implementation backed by any AsyncStorage-compatible API.
- * Pass the AsyncStorage singleton from @react-native-async-storage/async-storage
- * (or MMKV, SQLite, or any store that satisfies AsyncStorageLike).
- */
-export declare class AsyncStorageQueueStorage implements QueueStorage {
-    private readonly storage;
-    constructor(storage: AsyncStorageLike);
-    private readAll;
-    private writeAll;
-    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>;
-}
-
-export declare type CacheStrategy = 'cache-first' | 'stale-while-revalidate' | 'network-first';
-
-/**
- * Cancel an invocation by its `idempotencyKey` (from `ActionContext` /
- * `onOptimistic`). Aborts the in-flight call if `cancellable: true` and
- * still running, otherwise removes a not-yet-replayed queued item.
- * Returns `true` if something was cancelled/removed.
- *
- * Shared by every `ActionHandle.cancel()` and by devtools, which can't
- * address a specific handle from a queue item alone.
- */
-export declare function cancelByIdempotencyKey(idempotencyKey: string): Promise<boolean>;
-
-/** Remove all items from the action queue (storage + in-memory store). */
-export declare function clearQueue(): Promise<void>;
-
-export declare interface ConflictConfig {
-    /**
-     * - `'serverWins'`: drop the queued item, keeping the server's state.
-     * - `'clientWins'`: keep retrying — the client's write should eventually
-     *   be accepted (e.g. once the server-side conflict is cleared).
-     * - `'merge'` / `'custom'`: call `resolve` to decide.
-     */
-    strategy: 'serverWins' | 'clientWins' | 'merge' | 'custom';
-    /** Required for `'merge'` and `'custom'`. */
-    resolve?: (ctx: ConflictContext) => ConflictResolution;
-}
-
-/**
- * Passed to `ConflictConfig.resolve` (for `'merge'`/`'custom'` strategies)
- * when a queued action's replay receives a 4xx response.
- */
-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. */
-    args: any[];
-    /** Number of replay attempts so far (0 on first replay). */
-    attempt: number;
-    idempotencyKey: string;
-}
-
-/**
- * Outcome of `ConflictConfig.resolve`:
- * - `'retry'`: keep the item queued, retry per normal backoff.
- * - `'skip'`: silently remove the item (no `onRollback`).
- * - `{ resolved: args }`: replace the queued args and retry immediately
- *   on the next replay pass.
- */
-export declare type ConflictResolution = 'retry' | 'skip' | {
-    resolved: any[];
-};
-
-/**
- * Live state for a single queue item by ID. Returns `undefined` once the item
- * is removed from the queue (after a successful replay or `clearQueue()`).
- * @example
- *   // Svelte
- *   const item = eidosAction(queuedResult.id)
- *   $: status = $item?.status  // 'pending' | 'replaying' | 'succeeded' | 'failed' | undefined
- */
-export declare function eidosAction(id: string): EidosReadable<ActionQueueItem | undefined>;
-
-export declare interface EidosConfig {
-    /** Path to the eidos service worker. Defaults to '/eidos-sw.js'. */
-    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;
-}
-
-/**
- * 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): JSX.Element;
-
-declare interface EidosProviderProps extends EidosConfig {
-    children: ReactNode;
-}
-
-/** The action queue. Re-notifies on every queue mutation. */
-export declare const eidosQueue: EidosReadable<ActionQueueItem[]>;
-
-/**
- * Queue counts. Re-emits only when a count actually changes, not on every
- * queue mutation (e.g. a status transition that doesn't change counts is skipped).
- */
-export declare const eidosQueueStats: EidosReadable<{
-    pending: number;
-    failed: number;
-    replaying: number;
-    total: number;
-}>;
-
-export declare interface EidosReadable<T> {
-    /** Subscribe to value changes. Returns an unsubscribe function. */
-    subscribe(run: (value: T) => void): () => void;
-    /** Read the current value synchronously without subscribing. */
-    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
- *   // Svelte
- *   const entry = eidosResource('/api/products')
- *   $: hits = $entry?.cacheHits ?? 0
- */
-export declare function eidosResource(url: string): EidosReadable<ResourceEntry | undefined>;
-
-export declare interface EidosState {
-    isOnline: boolean;
-    swStatus: 'idle' | 'registering' | 'active' | 'error' | 'unsupported';
-    swError?: string;
-    resources: Record<string, ResourceEntry>;
-    queue: ActionQueueItem[];
-    reliability: ReliabilityStats;
-}
-
-/**
- * Online status + SW lifecycle.
- * Only re-emits when isOnline, swStatus, or swError actually changes.
- */
-export declare const eidosStatus: EidosReadable<{
-    isOnline: boolean;
-    swStatus: EidosStore['swStatus'];
-    swError: string | undefined;
-}>;
-
-export declare interface EidosStore extends EidosState, ResourceActions, QueueActions, ReliabilityActions {
-    setOnline: (online: boolean) => void;
-    setSwStatus: (status: EidosState['swStatus'], error?: string) => void;
-}
-
-/** Full Eidos state snapshot. Prefer the narrower stores below. */
-export declare const eidosStore: EidosReadable<EidosStore>;
-
-export declare interface GeneratedStrategy {
-    name: string;
-    swStrategy: CacheStrategy;
-    cacheName: string;
-    /** One-line rationale for why this strategy was chosen. */
-    reasoning: string;
-    /** Human-readable description of each behavioral step. */
-    behavior: string[];
-    /** Pseudocode showing the equivalent Workbox config. */
-    equivalentCode: string;
-}
-
-export declare function _getQueueStorage(): QueueStorage | null;
-
-declare function _getState(): EidosStore;
-
-export declare function getSwRegistration(): ServiceWorkerRegistration | null;
-
-export declare function initEidos(config?: EidosConfig): Promise<void>;
-
-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
- * URL to fetch/cache directly, so only cache-management methods are exposed.
- * Returned by `resourcePattern()`.
- */
-export declare interface PatternResourceHandle {
-    readonly url: string;
-    readonly config: ResourceConfig;
-    readonly strategy: GeneratedStrategy;
-    /** Clears all cache entries matching this pattern. */
-    invalidate: () => Promise<void>;
-    /** Remove from registry and SW. Required before re-registering the same pattern with different config. */
-    unregister: () => void;
-}
-
-declare interface PushHandlers {
-    onNotificationClick?: (data: unknown) => void;
-    onSubscriptionExpired?: (sub: PushSubscriptionJSON) => void;
-}
-
-declare type QueryInvalidator = (queryKey: [string, string]) => void;
-
-declare interface QueueActions {
-    addQueueItem: (item: ActionQueueItem) => void;
-    updateQueueItem: (id: string, update: Partial<ActionQueueItem>) => void;
-    batchUpdateQueueItems: (updates: Array<{
-        id: string;
-        update: Partial<ActionQueueItem>;
-    }>) => void;
-    removeQueueItem: (id: string) => void;
-    hydrateQueue: (items: ActionQueueItem[]) => void;
-}
-
-export declare interface QueuedResult {
-    readonly queued: true;
-    readonly id: string;
-    readonly message: string;
-}
-
-export declare 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>;
-}
-
-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(). */
-export declare interface ReplayResult {
-    /** Items where the registered function was found and called. */
-    attempted: number;
-    /** Items that resolved successfully. */
-    succeeded: number;
-    /** Items that failed and have no retries remaining (status: 'failed'). */
-    failed: number;
-    /** Items that failed but will be retried later (nextRetryAt set). */
-    retrying: number;
-    /** Items whose actionId had no registered function — likely not yet imported. */
-    skipped: number;
-    /** Items that received a 4xx response and were dropped via `conflict: { strategy: 'serverWins' }` (or `resolve()` returning `'skip'`). */
-    conflicted: number;
-    /** Items removed via `handle.cancel(idempotencyKey)` before/during replay. */
-    cancelled: number;
-}
-
-/**
- * Reset a `'failed'` queue item back to `'pending'` so the next
- * `replayQueue()` retries it — clears `error`/`nextRetryAt` and resets
- * `retryCount` to 0. Returns `true` if the item existed and was failed.
- * Used by devtools' per-item "Retry" action.
- */
-export declare function requeueItem(id: string): Promise<boolean>;
-
-export declare function _resetEidos(): 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>;
-
-declare interface ResourceActions {
-    registerResource: (url: string, entry: ResourceEntry) => void;
-    updateResource: (url: string, update: Partial<ResourceEntry>) => void;
-    unregisterResource: (url: string) => void;
-}
-
-export declare interface ResourceConfig {
-    /** Make this resource available when the device is offline. */
-    offline: boolean;
-    /** Override the auto-selected caching strategy. */
-    strategy?: CacheStrategy;
-    /** Custom cache bucket name. Defaults to 'eidos-resources-v1'. */
-    cacheName?: string;
-    /**
-     * Cache schema version. Bump when the response shape changes so old
-     * cached entries (a different shape) aren't served from a stale bucket.
-     * Appended to `cacheName` as a suffix (e.g. `eidos-resources-v1-v2`).
-     * Old-versioned buckets are left in Cache Storage — clear them via
-     * `caches.delete()` if needed.
-     */
-    version?: string | number;
-    /** Max age of cached response in milliseconds. Expired entries trigger a network fetch. */
-    maxAge?: number;
-}
-
-export declare interface ResourceEntry {
-    url: string;
-    config: ResourceConfig;
-    strategy: GeneratedStrategy;
-    status: 'idle' | 'fetching' | 'fresh' | 'stale' | 'error' | 'offline';
-    cachedAt?: number;
-    fetchedAt?: number;
-    cacheHits: number;
-    cacheMisses: number;
-    lastEvent?: 'cache-hit' | 'cache-updated' | 'network-error' | 'cache-cleared';
-}
-
-export declare interface ResourceHandle<T = unknown> {
-    readonly url: string;
-    readonly config: ResourceConfig;
-    readonly strategy: GeneratedStrategy;
-    fetch: () => Promise<Response>;
-    json: () => Promise<T>;
-    /** Returns a TanStack Query-compatible options object. */
-    query: () => {
-        queryKey: [string, string];
-        queryFn: () => Promise<T>;
-    };
-    prefetch: () => Promise<void>;
-    invalidate: () => Promise<void>;
-    /** Remove from registry and SW. Required before re-registering the same URL with different config. */
-    unregister: () => void;
-}
-
-/**
- * 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;
-
-export declare function sendToWorker(message: Record<string, unknown>): void;
-
-export declare function setOfflineSimulation(enabled: boolean): void;
-
-/* Excluded from this release type: setQueryInvalidator */
-
-/** Override the default IndexedDB queue with a custom storage backend (e.g. AsyncStorage for React Native). */
-export declare function setQueueStorage(s: QueueStorage): void;
-
-declare function _subscribe(listener: Listener): () => void;
-
-/**
- * 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;
-
-/** Full Eidos store — prefer the narrower hooks below for performance. */
-export declare function useEidos(): EidosStore;
-
-/**
- * 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): ActionQueueItem | undefined;
-
-export declare function useEidosOnDrain(callback: () => void): void;
-
-/** The current action queue. */
-export declare function useEidosQueue(): ActionQueueItem[];
-
-/**
- * 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(): ReliabilityStats;
-
-/** Live state for a single registered resource URL. */
-export declare function useEidosResource(url: string): ResourceEntry;
-
-/** All registered resources — only re-renders when the resources map changes, not on queue mutations. */
-export declare function useEidosResources(): Record<string, ResourceEntry>;
-
-/**
- * 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;
-};
-
-export declare const useEidosStore: {
-    getState: typeof _getState;
-    subscribe: typeof _subscribe;
-    setState: (partial: Partial<EidosStore> | ((s: EidosStore) => Partial<EidosStore>)) => void;
-};
-
-export declare const VERSION = "2.2.0";
-
-/**
- * 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>;
-
-/** Summary returned by warmCache(). */
-export declare interface WarmCacheResult {
-    /** Resources that were prefetched successfully. */
-    warmed: number;
-    /** Resources whose prefetch threw (network error, offline, etc.). */
-    failed: number;
-    /** The raw errors, in input order, for failed handles. */
-    errors: unknown[];
-}
-
-export { }
+export { resource, resourcePattern, warmCache, setQueryInvalidator } from './resource';
+export { action, replayQueue, clearQueue, cancelByIdempotencyKey, requeueItem } from './action';
+export { initEidos, _resetEidos } from './runtime';
+export type { EidosConfig } from './runtime';
+export { subscribeReplayOnReconnect } from './replay';
+export { setQueueStorage, _getQueueStorage } from './queue-storage';
+export type { QueueStorage } from './queue-storage';
+export { AsyncStorageQueueStorage } from './async-storage-adapter';
+export type { AsyncStorageLike } from './async-storage-adapter';
+export { EidosProvider } from './react/Provider';
+export { useEidos, useEidosResources, useEidosResource, useEidosQueue, useEidosAction, useEidosQueueStats, useEidosStatus, useEidosOnDrain, useEidosReliabilityStats, } from './react/hooks';
+export { VERSION } from './version';
+export { setOfflineSimulation, isBgSyncSupported, getSwRegistration, sendToWorker, registerPushCallbacks, triggerSwUpdate, } from './sw-bridge';
+export { eidosDebug } from './debug';
+export type { EidosDebugSnapshot } from './debug';
+export { useEidosStore } from './store';
+export type { EidosStore } from './store';
+export { eidosStore, eidosQueue, eidosStatus, eidosQueueStats, eidosResource, eidosAction, onQueueDrain, eidosReliabilityStats, } from './stores';
+export type { EidosReadable } from './stores';
+export type { ResourceConfig, ResourceHandle, PatternResourceHandle, AnyResourceHandle, ResourceEntry, GeneratedStrategy, WarmCacheResult, ActionConfig, ActionContext, ActionFn, ActionHandle, ActionQueueItem, QueuedResult, ReplayResult, EidosState, ReliabilityStats, ConflictContext, ConflictResolution, ConflictConfig, CacheStrategy, } from './types';