sibujs 3.4.0 → 4.0.0

package/dist/data.d.cts

@@ -13,7 +13,15 @@ interface RetryOptions {
     maxDelay?: number;
     /** Jitter factor (0-1) to randomize delay. Default: 0.1 */
     jitter?: number;
-    /** Predicate to decide if an error is retryable. Default: () => true */
+    /**
+     * Predicate deciding whether a **non-cancellation** failure is retryable.
+     * Default: `() => true`.
+     *
+     * Cancellation never reaches this callback. An aborted signal, or a rejection
+     * that is itself an `AbortError`, bypasses retry policy entirely — so a
+     * `shouldRetry` returning `true` for everything still cannot resurrect a
+     * cancelled operation.
+     */
     shouldRetry?: (error: unknown, attempt: number) => boolean;
 }
 /**
@@ -24,9 +32,16 @@ declare function calculateDelay(attempt: number, strategy: "exponential" | "line
  * Execute an async function with retry logic.
  * Returns the result or throws after all retries are exhausted.
  *
+ * CANCELLATION OUTRANKS RETRY POLICY. A cancelled operation — signalled either
+ * by `signal.aborted` or by a rejection that is itself an `AbortError` — skips
+ * `shouldRetry`, `onRetry` and the backoff, and rejects immediately.
+ *
  * @param fn The async function to execute
  * @param options Retry configuration
- * @param onRetry Callback fired before each retry with error, attempt, and delay
+ * @param onRetry Fired only when another attempt WILL actually be scheduled —
+ *   never on the final failure, never for a rejection `shouldRetry` declined,
+ *   and never for a cancellation. Receives the error, the attempt index, and
+ *   the delay before the next attempt.
  * @param signal AbortSignal to cancel retries
  *
  * @example
@@ -40,6 +55,44 @@ declare function calculateDelay(attempt: number, strategy: "exponential" | "line
  */
 declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions, onRetry?: (error: unknown, attempt: number, delay: number) => void, signal?: AbortSignal): Promise<T>;
 
+/**
+ * ## Callback semantics
+ *
+ * These rules are shared by `query()`, `resource()`, `infiniteQuery()`, and
+ * `mutation()`.
+ *
+ * **A callback exception is not an operation failure.** Exceptions thrown by
+ * lifecycle callbacks (`onSuccess`, `onError`, `onSettled`, `onStart`) and by
+ * `select` do not retroactively change the success/failure state of the
+ * underlying request. A fetch that succeeded stays successful, its data stays
+ * available, and the shared cache keeps the value it committed:
+ *
+ * ```text
+ * network success → cache commit → onSuccess throws → still a success
+ * ```
+ *
+ * **Callback errors are surfaced separately.** They are reported via
+ * `console.error` (prefixed `[SibuJS data]`), never silently swallowed, and
+ * never routed into the operation's own error channel — a throwing `onSuccess`
+ * does not trigger `onError`, and does not populate `error()`.
+ *
+ * **Observers are isolated from each other.** Multiple observers sharing one
+ * cache key are notified independently: one observer's `select` throwing cannot
+ * prevent the others from receiving the shared result, and cannot poison the
+ * shared cache entry.
+ *
+ * **A throwing `select` keeps the previous data.** `select` is the observer's
+ * own transform, not part of the request. If it throws, this observer retains
+ * whatever data it already had rather than committing a value that was never
+ * produced; the request is still recorded as successful.
+ *
+ * **Ordering is guaranteed.** State is committed first, then `onSuccess` /
+ * `onError`, then `onSettled`. `onSettled` runs even when the callback before
+ * it threw.
+ *
+ * The one exception is `mutation()`'s `onMutate`, which is a step *of* the
+ * mutation rather than a notification — see `MutationOptions.onMutate`.
+ */
 interface QueryOptions<T> {
     /** Time in ms before cached data is considered stale. Default: 0 (always stale) */
     staleTime?: number;
@@ -103,10 +156,33 @@ declare function clearQueryCache(): void;
  */
 declare function __resetQueryCache(): void;
 
+/**
+ * Lifecycle callbacks follow the shared data-layer contract: an exception
+ * thrown by `onSuccess`, `onError`, or `onSettled` never changes the status of
+ * the mutation itself — a mutation that succeeded stays `success` and
+ * `mutateAsync` still resolves — and is reported separately via
+ * `console.error`. See `QueryOptions` for the full statement.
+ *
+ * `onMutate` is the deliberate exception; see its own note below.
+ */
 interface MutationOptions<TData, TVariables, TContext = unknown> {
     /** Retry options for failed mutations */
     retry?: RetryOptions;
-    /** Called before mutation — return context for rollback in onError */
+    /**
+     * Called before the mutation — return context for rollback in `onError`.
+     *
+     * Unlike the notification callbacks, `onMutate` is a **step of** the
+     * mutation: it produces the rollback context everything downstream depends
+     * on. An ordinary exception therefore fails the mutation — there is no
+     * context, and the optimistic update it was meant to apply never happened.
+     *
+     * An `AbortError` is the one exception, and it is cancellation rather than
+     * failure — the same rule `mutationFn` follows. `isAbortError()` is
+     * authoritative for the whole operation, so where a cancellation is raised
+     * inside it does not change what it means: no error state, no `onError`, and
+     * the state the mutation replaced is restored. Throw an ordinary `Error` from
+     * `onMutate` to fail the mutation.
+     */
     onMutate?: (variables: TVariables) => TContext | Promise<TContext>;
     /** Called on successful mutation */
     onSuccess?: (data: TData, variables: TVariables, context: TContext) => void;
@@ -135,6 +211,13 @@ interface MutationResult<TData, TVariables> {
 }
 declare function mutation<TData, TVariables = void, TContext = unknown>(mutationFn: (variables: TVariables, signal?: AbortSignal) => Promise<TData>, options?: MutationOptions<TData, TVariables, TContext>): MutationResult<TData, TVariables>;
 
+/**
+ * Lifecycle callbacks follow the shared data-layer contract: an exception
+ * thrown by `onSuccess` or `onError` never changes the success/failure state of
+ * the page fetch itself — a page that was appended stays appended — and is
+ * reported separately via `console.error`. See `QueryOptions` for the full
+ * statement.
+ */
 interface InfiniteQueryOptions<TData, TPageParam = number> {
     /** Get the param for the next page. Return undefined to signal end. */
     getNextPageParam: (lastPage: TData, allPages: TData[]) => TPageParam | undefined;
@@ -245,6 +328,12 @@ declare function debounce<T>(getter: () => T, delay: number): () => T;
  */
 declare function throttle<T>(getter: () => T, interval: number): () => T;
 
+/**
+ * Lifecycle callbacks follow the shared data-layer contract: an exception
+ * thrown by `onStart`, `onSuccess`, `onError`, or `onSettled` never changes the
+ * success/failure state of the fetch itself, and is reported separately via
+ * `console.error`. See `QueryOptions` for the full statement.
+ */
 interface ResourceOptions<T> {
     /** Initial data value before first fetch. Default: undefined */
     initialValue?: T;
@@ -318,13 +407,53 @@ interface OfflineStoreOptions<T> {
     /** Auto-sync when online status changes (default: true) */
     autoSync?: boolean;
 }
+/**
+ * How a pulled remote record is reconciled with a local record that still has
+ * an unpushed change queued for the same key. Records with no queued local
+ * change are never conflicts — the remote value always applies.
+ */
+type ConflictStrategy = "client-wins" | "server-wins" | "manual";
+/** The state handed to a `manual` resolver for one conflicting key. */
+interface SyncConflict<T> {
+    /** Value of the store's `keyPath` for the conflicting record. */
+    key: unknown;
+    /** Current local item — `undefined` when the queued local change is a delete. */
+    local: T | undefined;
+    /** The record as returned by the remote `pull()`. */
+    remote: T;
+    /** The queued local change that makes this key a conflict. */
+    pending: SyncChange<T>;
+}
 interface SyncAdapter<T> {
     /** Push local changes to remote */
     push: (changes: SyncChange<T>[]) => Promise<SyncResult>;
     /** Pull remote changes since last sync */
     pull: (since: number | null) => Promise<T[]>;
-    /** Conflict resolution strategy */
-    conflictStrategy: "client-wins" | "server-wins" | "manual";
+    /**
+     * Conflict resolution strategy. Defaults to `"client-wins"`.
+     *
+     * - `client-wins` — a pulled record is DISCARDED for any key that still has
+     *   an unpushed local change. The local edit survives and is pushed on the
+     *   next round. This is the safe default: it never destroys work made
+     *   offline.
+     * - `server-wins` — the pulled record OVERWRITES local state even for keys
+     *   with queued changes. The queued change itself is **retained**, not
+     *   dropped: it still has to reach the server, and discarding it here would
+     *   turn a display-precedence choice into silent data loss. A subsequent
+     *   successful push therefore re-asserts the local edit remotely.
+     * - `manual` — `resolveConflict` decides per key. Without a `resolveConflict`
+     *   implementation this degrades to `client-wins` and warns, because the only
+     *   other option is to guess with the user's unsynced data.
+     */
+    conflictStrategy?: ConflictStrategy;
+    /**
+     * Resolve one conflicting key. Required for `conflictStrategy: "manual"`.
+     *
+     * Return the value to store locally, or `undefined` to keep the local record
+     * untouched. May be async. A resolver that throws falls back to keeping the
+     * local record — the conservative direction.
+     */
+    resolveConflict?: (conflict: SyncConflict<T>) => T | undefined | Promise<T | undefined>;
 }
 interface SyncChange<T> {
     type: "put" | "delete";
@@ -369,6 +498,9 @@ interface OfflineStore<T> {
  *   adapter: syncAdapter({
  *     push: (changes) => fetch("/api/sync", { method: "POST", body: JSON.stringify(changes) }),
  *     pull: (since) => fetch(`/api/todos?since=${since}`).then(r => r.json()),
+ *     // client-wins (the default) never lets a pulled record overwrite a key
+ *     // that still has an unpushed local edit. Use "server-wins" to let the
+ *     // remote value win, or "manual" plus a `resolveConflict` resolver.
  *     conflictStrategy: "client-wins",
  *   }),
  * });
@@ -377,7 +509,7 @@ interface OfflineStore<T> {
  * store.data(); // [{ id: "1", text: "Buy milk", done: false }]
  * ```
  */
-declare function offlineStore<T extends Record<string, unknown>>(options: OfflineStoreOptions<T>): Promise<OfflineStore<T>>;
+declare function offlineStore<T extends object>(options: OfflineStoreOptions<T>): Promise<OfflineStore<T>>;
 /**
  * Helper to create a sync adapter configuration.
  */
@@ -464,4 +596,4 @@ declare function stream(url: string, options?: {
     dispose: () => void;
 };
 
-export { type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, resource, setQueryData, socket, stream, syncAdapter, throttle, withRetry };
+export { type ConflictStrategy, type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncConflict, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, resource, setQueryData, socket, stream, syncAdapter, throttle, withRetry };

package/dist/data.d.ts

@@ -13,7 +13,15 @@ interface RetryOptions {
     maxDelay?: number;
     /** Jitter factor (0-1) to randomize delay. Default: 0.1 */
     jitter?: number;
-    /** Predicate to decide if an error is retryable. Default: () => true */
+    /**
+     * Predicate deciding whether a **non-cancellation** failure is retryable.
+     * Default: `() => true`.
+     *
+     * Cancellation never reaches this callback. An aborted signal, or a rejection
+     * that is itself an `AbortError`, bypasses retry policy entirely — so a
+     * `shouldRetry` returning `true` for everything still cannot resurrect a
+     * cancelled operation.
+     */
     shouldRetry?: (error: unknown, attempt: number) => boolean;
 }
 /**
@@ -24,9 +32,16 @@ declare function calculateDelay(attempt: number, strategy: "exponential" | "line
  * Execute an async function with retry logic.
  * Returns the result or throws after all retries are exhausted.
  *
+ * CANCELLATION OUTRANKS RETRY POLICY. A cancelled operation — signalled either
+ * by `signal.aborted` or by a rejection that is itself an `AbortError` — skips
+ * `shouldRetry`, `onRetry` and the backoff, and rejects immediately.
+ *
  * @param fn The async function to execute
  * @param options Retry configuration
- * @param onRetry Callback fired before each retry with error, attempt, and delay
+ * @param onRetry Fired only when another attempt WILL actually be scheduled —
+ *   never on the final failure, never for a rejection `shouldRetry` declined,
+ *   and never for a cancellation. Receives the error, the attempt index, and
+ *   the delay before the next attempt.
  * @param signal AbortSignal to cancel retries
  *
  * @example
@@ -40,6 +55,44 @@ declare function calculateDelay(attempt: number, strategy: "exponential" | "line
  */
 declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions, onRetry?: (error: unknown, attempt: number, delay: number) => void, signal?: AbortSignal): Promise<T>;
 
+/**
+ * ## Callback semantics
+ *
+ * These rules are shared by `query()`, `resource()`, `infiniteQuery()`, and
+ * `mutation()`.
+ *
+ * **A callback exception is not an operation failure.** Exceptions thrown by
+ * lifecycle callbacks (`onSuccess`, `onError`, `onSettled`, `onStart`) and by
+ * `select` do not retroactively change the success/failure state of the
+ * underlying request. A fetch that succeeded stays successful, its data stays
+ * available, and the shared cache keeps the value it committed:
+ *
+ * ```text
+ * network success → cache commit → onSuccess throws → still a success
+ * ```
+ *
+ * **Callback errors are surfaced separately.** They are reported via
+ * `console.error` (prefixed `[SibuJS data]`), never silently swallowed, and
+ * never routed into the operation's own error channel — a throwing `onSuccess`
+ * does not trigger `onError`, and does not populate `error()`.
+ *
+ * **Observers are isolated from each other.** Multiple observers sharing one
+ * cache key are notified independently: one observer's `select` throwing cannot
+ * prevent the others from receiving the shared result, and cannot poison the
+ * shared cache entry.
+ *
+ * **A throwing `select` keeps the previous data.** `select` is the observer's
+ * own transform, not part of the request. If it throws, this observer retains
+ * whatever data it already had rather than committing a value that was never
+ * produced; the request is still recorded as successful.
+ *
+ * **Ordering is guaranteed.** State is committed first, then `onSuccess` /
+ * `onError`, then `onSettled`. `onSettled` runs even when the callback before
+ * it threw.
+ *
+ * The one exception is `mutation()`'s `onMutate`, which is a step *of* the
+ * mutation rather than a notification — see `MutationOptions.onMutate`.
+ */
 interface QueryOptions<T> {
     /** Time in ms before cached data is considered stale. Default: 0 (always stale) */
     staleTime?: number;
@@ -103,10 +156,33 @@ declare function clearQueryCache(): void;
  */
 declare function __resetQueryCache(): void;
 
+/**
+ * Lifecycle callbacks follow the shared data-layer contract: an exception
+ * thrown by `onSuccess`, `onError`, or `onSettled` never changes the status of
+ * the mutation itself — a mutation that succeeded stays `success` and
+ * `mutateAsync` still resolves — and is reported separately via
+ * `console.error`. See `QueryOptions` for the full statement.
+ *
+ * `onMutate` is the deliberate exception; see its own note below.
+ */
 interface MutationOptions<TData, TVariables, TContext = unknown> {
     /** Retry options for failed mutations */
     retry?: RetryOptions;
-    /** Called before mutation — return context for rollback in onError */
+    /**
+     * Called before the mutation — return context for rollback in `onError`.
+     *
+     * Unlike the notification callbacks, `onMutate` is a **step of** the
+     * mutation: it produces the rollback context everything downstream depends
+     * on. An ordinary exception therefore fails the mutation — there is no
+     * context, and the optimistic update it was meant to apply never happened.
+     *
+     * An `AbortError` is the one exception, and it is cancellation rather than
+     * failure — the same rule `mutationFn` follows. `isAbortError()` is
+     * authoritative for the whole operation, so where a cancellation is raised
+     * inside it does not change what it means: no error state, no `onError`, and
+     * the state the mutation replaced is restored. Throw an ordinary `Error` from
+     * `onMutate` to fail the mutation.
+     */
     onMutate?: (variables: TVariables) => TContext | Promise<TContext>;
     /** Called on successful mutation */
     onSuccess?: (data: TData, variables: TVariables, context: TContext) => void;
@@ -135,6 +211,13 @@ interface MutationResult<TData, TVariables> {
 }
 declare function mutation<TData, TVariables = void, TContext = unknown>(mutationFn: (variables: TVariables, signal?: AbortSignal) => Promise<TData>, options?: MutationOptions<TData, TVariables, TContext>): MutationResult<TData, TVariables>;
 
+/**
+ * Lifecycle callbacks follow the shared data-layer contract: an exception
+ * thrown by `onSuccess` or `onError` never changes the success/failure state of
+ * the page fetch itself — a page that was appended stays appended — and is
+ * reported separately via `console.error`. See `QueryOptions` for the full
+ * statement.
+ */
 interface InfiniteQueryOptions<TData, TPageParam = number> {
     /** Get the param for the next page. Return undefined to signal end. */
     getNextPageParam: (lastPage: TData, allPages: TData[]) => TPageParam | undefined;
@@ -245,6 +328,12 @@ declare function debounce<T>(getter: () => T, delay: number): () => T;
  */
 declare function throttle<T>(getter: () => T, interval: number): () => T;
 
+/**
+ * Lifecycle callbacks follow the shared data-layer contract: an exception
+ * thrown by `onStart`, `onSuccess`, `onError`, or `onSettled` never changes the
+ * success/failure state of the fetch itself, and is reported separately via
+ * `console.error`. See `QueryOptions` for the full statement.
+ */
 interface ResourceOptions<T> {
     /** Initial data value before first fetch. Default: undefined */
     initialValue?: T;
@@ -318,13 +407,53 @@ interface OfflineStoreOptions<T> {
     /** Auto-sync when online status changes (default: true) */
     autoSync?: boolean;
 }
+/**
+ * How a pulled remote record is reconciled with a local record that still has
+ * an unpushed change queued for the same key. Records with no queued local
+ * change are never conflicts — the remote value always applies.
+ */
+type ConflictStrategy = "client-wins" | "server-wins" | "manual";
+/** The state handed to a `manual` resolver for one conflicting key. */
+interface SyncConflict<T> {
+    /** Value of the store's `keyPath` for the conflicting record. */
+    key: unknown;
+    /** Current local item — `undefined` when the queued local change is a delete. */
+    local: T | undefined;
+    /** The record as returned by the remote `pull()`. */
+    remote: T;
+    /** The queued local change that makes this key a conflict. */
+    pending: SyncChange<T>;
+}
 interface SyncAdapter<T> {
     /** Push local changes to remote */
     push: (changes: SyncChange<T>[]) => Promise<SyncResult>;
     /** Pull remote changes since last sync */
     pull: (since: number | null) => Promise<T[]>;
-    /** Conflict resolution strategy */
-    conflictStrategy: "client-wins" | "server-wins" | "manual";
+    /**
+     * Conflict resolution strategy. Defaults to `"client-wins"`.
+     *
+     * - `client-wins` — a pulled record is DISCARDED for any key that still has
+     *   an unpushed local change. The local edit survives and is pushed on the
+     *   next round. This is the safe default: it never destroys work made
+     *   offline.
+     * - `server-wins` — the pulled record OVERWRITES local state even for keys
+     *   with queued changes. The queued change itself is **retained**, not
+     *   dropped: it still has to reach the server, and discarding it here would
+     *   turn a display-precedence choice into silent data loss. A subsequent
+     *   successful push therefore re-asserts the local edit remotely.
+     * - `manual` — `resolveConflict` decides per key. Without a `resolveConflict`
+     *   implementation this degrades to `client-wins` and warns, because the only
+     *   other option is to guess with the user's unsynced data.
+     */
+    conflictStrategy?: ConflictStrategy;
+    /**
+     * Resolve one conflicting key. Required for `conflictStrategy: "manual"`.
+     *
+     * Return the value to store locally, or `undefined` to keep the local record
+     * untouched. May be async. A resolver that throws falls back to keeping the
+     * local record — the conservative direction.
+     */
+    resolveConflict?: (conflict: SyncConflict<T>) => T | undefined | Promise<T | undefined>;
 }
 interface SyncChange<T> {
     type: "put" | "delete";
@@ -369,6 +498,9 @@ interface OfflineStore<T> {
  *   adapter: syncAdapter({
  *     push: (changes) => fetch("/api/sync", { method: "POST", body: JSON.stringify(changes) }),
  *     pull: (since) => fetch(`/api/todos?since=${since}`).then(r => r.json()),
+ *     // client-wins (the default) never lets a pulled record overwrite a key
+ *     // that still has an unpushed local edit. Use "server-wins" to let the
+ *     // remote value win, or "manual" plus a `resolveConflict` resolver.
  *     conflictStrategy: "client-wins",
  *   }),
  * });
@@ -377,7 +509,7 @@ interface OfflineStore<T> {
  * store.data(); // [{ id: "1", text: "Buy milk", done: false }]
  * ```
  */
-declare function offlineStore<T extends Record<string, unknown>>(options: OfflineStoreOptions<T>): Promise<OfflineStore<T>>;
+declare function offlineStore<T extends object>(options: OfflineStoreOptions<T>): Promise<OfflineStore<T>>;
 /**
  * Helper to create a sync adapter configuration.
  */
@@ -464,4 +596,4 @@ declare function stream(url: string, options?: {
     dispose: () => void;
 };
 
-export { type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, resource, setQueryData, socket, stream, syncAdapter, throttle, withRetry };
+export { type ConflictStrategy, type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncConflict, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, resource, setQueryData, socket, stream, syncAdapter, throttle, withRetry };

package/dist/data.js

@@ -20,16 +20,16 @@ import {
   syncAdapter,
   throttle,
   withRetry
-} from "./chunk-ELXMRSVN.js";
-import "./chunk-RT3IYFN2.js";
-import "./chunk-ITWCTZYH.js";
+} from "./chunk-NF3LYCQH.js";
+import "./chunk-O3QQ3XOL.js";
+import "./chunk-Z2CE42DB.js";
+import "./chunk-5INI7D2L.js";
 import "./chunk-7ZHH77QA.js";
-import "./chunk-L3GAGWCC.js";
-import "./chunk-BUKYCWHX.js";
-import "./chunk-S3NFJO6L.js";
-import "./chunk-KZBEVFXZ.js";
-import "./chunk-OOUQUCNN.js";
-import "./chunk-COY6PUD2.js";
+import "./chunk-PBQEW5VW.js";
+import "./chunk-TIRZCERI.js";
+import "./chunk-W55YHPEP.js";
+import "./chunk-ACBT6UZS.js";
+import "./chunk-VPP2FONR.js";
 export {
   __resetQueryCache,
   calculateDelay,