@lunora/client 1.0.0-alpha.24 → 1.0.0-alpha.26

package/dist/index.d.mts

@@ -1,13 +1,13 @@
-import { c as PersistenceAdapter, B as BookmarkStorage, S as SubscriptionError, H as HttpStreamRef, d as HttpStreamArgsOf, e as HttpStreamChunkOf, f as StreamIterable, F as FunctionReference, A as ArgsOf, M as MutationCallOptions, R as ReturnOf, O as OfflineQueueOptions, Q as QueryCacheAdapter, g as ReconnectOptions, L as LunoraClient } from "./packem_shared/lunora-client.d-B8bdwHLr.mjs";
-export { type h as BatchSlot, C as CONFLICT_ERROR_CODE, type i as CachedQuery, type j as ClientMessage, type k as ClientQueryRef, type l as ClientShapeSubscribeMessage, type m as ClientShapeUnsubscribeMessage, type n as ConnectionStatus, D as DEFAULT_MAX_BUFFER, type o as FunctionArgumentDescriptor, type p as FunctionDescriptor, type G as GlobalFacetResult, type q as GlobalFacetValue, type r as GlobalFilterClause, type s as GlobalTableInfo, type t as GlobalTablePage, type u as HttpStreamCallArgs, type v as LunoraClientError, type w as LunoraClientOptions, type x as LunoraErrorCode, type y as MutationSettledEvent, type z as OptimisticLocalStore, type E as OptimisticUpdate, type I as OutboxMutation, type J as OutboxSink, type K as PersistedMutation, type P as Preloaded, type N as RowOp, type T as RpcEnvelope, type V as RpcResponseBody, type W as ScheduleRecord, type X as SchedulerPoolStatus, type Y as SchedulerStatus, type Z as ServerMessage, type _ as ServerPokeEndMessage, type $ as ServerPokePartMessage, type a0 as ServerPokeStartMessage, type a1 as ShardTrafficEntry, type a2 as ShardTrafficResult, type a3 as StorageListPage, type a4 as StorageObject, type a5 as StreamHandle, type a6 as SubscriptionCallback, type b as SubscriptionErrorCallback, a7 as SubscriptionRegistry, type a8 as SubscriptionState, type a9 as SyncWatermark, type a as Unsubscribe, type U as User, type aa as WorkflowInstanceAction, type ab as WorkflowInstanceDetail, type ac as WorkflowInstancePage, type ad as WorkflowInstanceStatus, type ae as WorkflowInstanceSummary, type af as WorkflowStepDetail, type ag as WsTokenProvider, ah as createClientQuery, ai as createLocalStore, aj as createStream, ak as getErrorCode, al as getRetryAfterMs, am as isConflictError, an as isForbiddenError, ao as isRateLimitedError, ap as isUnauthorizedError } from "./packem_shared/lunora-client.d-B8bdwHLr.mjs";
-export { p as preloadQuery, a as preloadedQueryResult } from "./packem_shared/preload.d-Ccrgw2z0.mjs";
-export type { AuthCapabilities, AuthConfigInfo, AuthImpersonation, AuthPage, AuthSession, AuthUser, AuthUserFieldSpec, CronJobInfo, KvKeyEntry, KvKeyListResult, KvNamespaceSummary, KvValueResult, VectorIndexSummary, VectorQueryMatch } from '@lunora/runtime';
-/**
-* The slice of React Native's `AsyncStorage` (or any async key/value store —
-* Expo `SecureStore`, a wrapped `localForage`, an in-memory map in tests) this
-* adapter needs. Matches `@react-native-async-storage/async-storage`'s core
-* surface, so you can pass the module straight in.
-*/
+import { c as PersistenceAdapter, B as BookmarkStorage, S as SubscriptionError, H as HttpStreamRef, d as HttpStreamArgsOf, e as HttpStreamChunkOf, f as StreamIterable, F as FunctionReference, A as ArgsOf, M as MutationCallOptions, R as ReturnOf, O as OfflineQueueOptions, Q as QueryCacheAdapter, g as ReconnectOptions, L as LunoraClient } from "./packem_shared/lunora-client.d-B1iZb2Ph.mjs";
+export { type h as BatchSlot, C as CONFLICT_ERROR_CODE, type i as CachedQuery, type j as ClientMessage, type k as ClientQueryRef, type l as ClientShapeSubscribeMessage, type m as ClientShapeUnsubscribeMessage, type n as ConnectionStatus, D as DEFAULT_MAX_BUFFER, type o as FunctionArgumentDescriptor, type p as FunctionDescriptor, type G as GlobalFacetResult, type q as GlobalFacetValue, type r as GlobalFilterClause, type s as GlobalTableInfo, type t as GlobalTablePage, type u as HttpStreamCallArgs, type v as LunoraClientError, type w as LunoraClientOptions, type x as LunoraErrorCode, type y as MutationSettledEvent, type z as OptimisticLocalStore, type E as OptimisticUpdate, type I as OutboxMutation, type J as OutboxSink, type K as PersistedMutation, type P as Preloaded, type N as RowOp, type T as RpcEnvelope, type V as RpcResponseBody, type W as ScheduleRecord, type X as SchedulerPoolStatus, type Y as SchedulerStatus, type Z as ServerMessage, type _ as ServerPokeEndMessage, type $ as ServerPokePartMessage, type a0 as ServerPokeStartMessage, type a1 as ShardTrafficEntry, type a2 as ShardTrafficResult, type a3 as StorageListPage, type a4 as StorageObject, type a5 as StreamHandle, type a6 as SubscriptionCallback, type b as SubscriptionErrorCallback, a7 as SubscriptionRegistry, type a8 as SubscriptionState, type a9 as SyncWatermark, type a as Unsubscribe, type U as User, type aa as WorkflowInstanceAction, type ab as WorkflowInstanceDetail, type ac as WorkflowInstancePage, type ad as WorkflowInstanceStatus, type ae as WorkflowInstanceSummary, type af as WorkflowStepDetail, type ag as WsTokenProvider, ah as createClientQuery, ai as createLocalStore, aj as createStream, ak as getErrorCode, al as getRetryAfterMs, am as isConflictError, an as isForbiddenError, ao as isRateLimitedError, ap as isUnauthorizedError } from "./packem_shared/lunora-client.d-B1iZb2Ph.mjs";
+export { p as preloadQuery, a as preloadedQueryResult } from "./packem_shared/preload.d-CLwoXl3R.mjs";
+export type { AuthCapabilities, AuthConfigInfo, AuthImpersonation, AuthPage, AuthSession, AuthUser, AuthUserFieldSpec, CronJobInfo, KvKeyEntry, KvKeyListResult, KvNamespaceSummary, KvValueResult, PipelineLogColumnMap, PipelineLogCursor, PipelineLogField, PipelineLogPage, PipelineLogQuery, PipelineLogRow, VectorIndexSummary, VectorQueryMatch } from '@lunora/runtime';
+/**
+ * The slice of React Native's `AsyncStorage` (or any async key/value store —
+ * Expo `SecureStore`, a wrapped `localForage`, an in-memory map in tests) this
+ * adapter needs. Matches `@react-native-async-storage/async-storage`'s core
+ * surface, so you can pass the module straight in.
+ */
 interface AsyncStorageLike {
   getItem: (key: string) => Promise<string | null>;
   removeItem: (key: string) => Promise<void>;
@@ -20,48 +20,48 @@ interface AsyncStoragePersistenceOptions {
   storage: AsyncStorageLike;
 }
 /**
-* Builds a {@link PersistenceAdapter} over an async key/value store — the React
-* Native / Expo counterpart to the IndexedDB adapter (`createIndexedDbPersistence`).
-* The whole FIFO mutation log is serialized to JSON under a single key (`key`),
-* so enqueue order is preserved and `load()` returns freshly-parsed records that
-* callers can't alias.
-*
-* AsyncStorage has no transactions, so every read-modify-write is funnelled
-* through a single promise chain — concurrent `append`/`remove` calls run one at
-* a time and can't clobber each other's writes.
-*/
+ * Builds a {@link PersistenceAdapter} over an async key/value store — the React
+ * Native / Expo counterpart to the IndexedDB adapter (`createIndexedDbPersistence`).
+ * The whole FIFO mutation log is serialized to JSON under a single key (`key`),
+ * so enqueue order is preserved and `load()` returns freshly-parsed records that
+ * callers can't alias.
+ *
+ * AsyncStorage has no transactions, so every read-modify-write is funnelled
+ * through a single promise chain — concurrent `append`/`remove` calls run one at
+ * a time and can't clobber each other's writes.
+ */
 declare const createAsyncStoragePersistence: (options: AsyncStoragePersistenceOptions) => PersistenceAdapter;
 /** Default in-memory bookmark store. Survives the lifetime of the client. */
 declare const createInMemoryBookmarkStorage: () => BookmarkStorage;
 interface TabCoordinatorOptions {
   /**
-  * BroadcastChannel name. Defaults to `"lunora-bridge"`.
-  */
+   * BroadcastChannel name. Defaults to `"lunora-bridge"`.
+   */
   channelName?: string;
   /**
-  * Interval (ms) between leader heartbeats. Defaults to 1000.
-  */
+   * Interval (ms) between leader heartbeats. Defaults to 1000.
+   */
   heartbeatInterval?: number;
   /**
-  * Milliseconds without a heartbeat to consider the leader dead. Must be
-  * larger than `heartbeatInterval`. Defaults to 3000.
-  */
+   * Milliseconds without a heartbeat to consider the leader dead. Must be
+   * larger than `heartbeatInterval`. Defaults to 3000.
+   */
   leaderTimeout?: number;
   /**
-  * Called when this tab becomes the leader (should open WS connections).
-  */
+   * Called when this tab becomes the leader (should open WS connections).
+   */
   onBecomeLeader?: () => void;
   /**
-  * Called when this tab loses leadership (should close WS connections).
-  */
+   * Called when this tab loses leadership (should close WS connections).
+   */
   onStopBeingLeader?: () => void;
   /**
-  * Called when the leader broadcasts subscription data.
-  */
+   * Called when the leader broadcasts subscription data.
+   */
   onSubscriptionData?: (key: string, data: unknown) => void;
   /**
-  * Called when the leader broadcasts a subscription error.
-  */
+   * Called when the leader broadcasts a subscription error.
+   */
   onSubscriptionError?: (key: string, error: SubscriptionError) => void;
 }
 declare class TabCoordinator {
@@ -86,14 +86,14 @@ declare class TabCoordinator {
   private readonly onSubscriptionError;
   constructor(options?: TabCoordinatorOptions);
   /**
-  * Start the coordinator: attempt to claim leadership and begin the
-  * heartbeat/leader-check cycle. Safe to call multiple times.
-  */
+   * Start the coordinator: attempt to claim leadership and begin the
+   * heartbeat/leader-check cycle. Safe to call multiple times.
+   */
   start(): void;
   /**
-  * Stop the coordinator: yield leadership (if held), close the channel, and
-  * clear all timers. Safe to call multiple times.
-  */
+   * Stop the coordinator: yield leadership (if held), close the channel, and
+   * clear all timers. Safe to call multiple times.
+   */
   stop(): void;
   /** `true` when this tab is the current WebSocket leader. */
   isLeader(): boolean;
@@ -104,63 +104,63 @@ declare class TabCoordinator {
   /** `true` when the coordinator has been started and is not yet stopped. */
   get isRunning(): boolean;
   /**
-  * Broadcast subscription data to all follower tabs. Only the leader should
-  * call this.
-  */
+   * Broadcast subscription data to all follower tabs. Only the leader should
+   * call this.
+   */
   broadcastSubscriptionData(key: string, data: unknown): void;
   /**
-  * Broadcast a subscription error to all follower tabs. Only the leader
-  * should call this.
-  */
+   * Broadcast a subscription error to all follower tabs. Only the leader
+   * should call this.
+   */
   broadcastSubscriptionError(key: string, error: SubscriptionError): void;
   private broadcast;
   private handleMessage;
   private handleClaimLeadership;
   private handleHeartbeat;
   /**
-  * Resolve two leaders existing at once — e.g. this tab was backgrounded
-  * and its heartbeat/health timers were throttled while a foreground
-  * follower's were not, so the follower's `checkLeaderHealth` timed out
-  * the (still-alive) leader and self-promoted. `BroadcastChannel` message
-  * delivery isn't subject to the same timer-throttling clamp, so even a
-  * backgrounded leader eventually observes the pretender's heartbeat here
-  * — resolve the split-brain deterministically with the same
-  * lexicographically-smaller-tabId rule used at claim-adoption. If the
-  * other tab wins, step down; if we win, reassert immediately so the
-  * pretender demotes itself the moment it processes our heartbeat.
-  */
+   * Resolve two leaders existing at once — e.g. this tab was backgrounded
+   * and its heartbeat/health timers were throttled while a foreground
+   * follower's were not, so the follower's `checkLeaderHealth` timed out
+   * the (still-alive) leader and self-promoted. `BroadcastChannel` message
+   * delivery isn't subject to the same timer-throttling clamp, so even a
+   * backgrounded leader eventually observes the pretender's heartbeat here
+   * — resolve the split-brain deterministically with the same
+   * lexicographically-smaller-tabId rule used at claim-adoption. If the
+   * other tab wins, step down; if we win, reassert immediately so the
+   * pretender demotes itself the moment it processes our heartbeat.
+   */
   private resolveLeaderVsLeaderTieBreak;
   private becomeLeader;
   private sendHeartbeat;
   private checkLeaderHealth;
 }
 /**
-* Client-side incremental merging of structured mutation deltas.
-*
-* Lunora's live-query fan-out has two server paths:
-*
-* 1. Server re-execution (subscriptions carrying a `functionPath`) pushes a
-* full `data` snapshot whenever a write touches a table the query reads. These
-* already carry the authoritative result and are applied wholesale.
-* 2. Legacy delta fan-out (`broadcastDelta`) pushes a structured `MutationDelta`
-* as a `delta` frame to subscribers matched by table + args. The delta describes
-* a single row change (`insert` / `update` / `delete`) keyed by row id, so the
-* client can splice it into the cached list result without a full re-send.
-*
-* Historically the client treated the `delta` field as an opaque blob and
-* replaced the whole cached value with it on every message — which only made
-* sense for the rare delta payloads that already carried the full result. This
-* module lets the client recognise a structured delta and merge it into the
-* existing array (preserving order, no dup/loss), falling back to full
-* replacement when the payload isn't a recognisable row delta or can't be
-* applied cleanly against the current cached shape.
-*/
-/**
-* One row change as emitted by `@lunora/do`'s `broadcastDelta`. Mirrors
-* `MutationDelta` in `@lunora/do` structurally so the client carries no
-* dependency on it. `row` is absent on `delete` events (and may be absent on
-* older servers for any op).
-*/
+ * Client-side incremental merging of structured mutation deltas.
+ *
+ * Lunora's live-query fan-out has two server paths:
+ *
+ * 1. Server re-execution (subscriptions carrying a `functionPath`) pushes a
+ * full `data` snapshot whenever a write touches a table the query reads. These
+ * already carry the authoritative result and are applied wholesale.
+ * 2. Legacy delta fan-out (`broadcastDelta`) pushes a structured `MutationDelta`
+ * as a `delta` frame to subscribers matched by table + args. The delta describes
+ * a single row change (`insert` / `update` / `delete`) keyed by row id, so the
+ * client can splice it into the cached list result without a full re-send.
+ *
+ * Historically the client treated the `delta` field as an opaque blob and
+ * replaced the whole cached value with it on every message — which only made
+ * sense for the rare delta payloads that already carried the full result. This
+ * module lets the client recognise a structured delta and merge it into the
+ * existing array (preserving order, no dup/loss), falling back to full
+ * replacement when the payload isn't a recognisable row delta or can't be
+ * applied cleanly against the current cached shape.
+ */
+/**
+ * One row change as emitted by `@lunora/do`'s `broadcastDelta`. Mirrors
+ * `MutationDelta` in `@lunora/do` structurally so the client carries no
+ * dependency on it. `row` is absent on `delete` events (and may be absent on
+ * older servers for any op).
+ */
 interface MutationDelta {
   /** Row id (`_id`) the change applies to. */
   key: string;
@@ -169,43 +169,43 @@ interface MutationDelta {
   table: string;
 }
 /**
-* Structural guard: is `value` a `MutationDelta` the client knows how to merge?
-* We require `op`, `table`, and a string `key` so opaque payloads that merely
-* happen to be objects (e.g. an aggregate `{ count: 1 }` a query returns
-* verbatim) are never mistaken for a row delta and keep replacing the cached
-* value wholesale.
-*/
+ * Structural guard: is `value` a `MutationDelta` the client knows how to merge?
+ * We require `op`, `table`, and a string `key` so opaque payloads that merely
+ * happen to be objects (e.g. an aggregate `{ count: 1 }` a query returns
+ * verbatim) are never mistaken for a row delta and keep replacing the cached
+ * value wholesale.
+ */
 declare const isMutationDelta: (value: unknown) => value is MutationDelta;
 /**
-* Apply a structured `MutationDelta` to a cached array result, returning a new
-* array (never mutating the input). Returns `undefined` when the delta can't be
-* applied cleanly — the caller should then fall back to the existing
-* full-replacement behaviour (or trust the next snapshot to reconcile).
-*
-* Mergeable shape: a plain array of id-bearing row objects, e.g. the result of
-* `db.query().collect()`.
-*
-* Insert / update / delete are matched by row `_id`:
-* - `insert`: appended (or placed by `_creationTime` order) if absent; treated
-* as an update if a row with the same id already exists (idempotent — guards
-* against a delta replayed after a snapshot already included it).
-* - `update`: replaces the matching row in place, preserving its position.
-* - `delete`: removes the matching row.
-*
-* Returns `undefined` when `current` isn't an array of id-keyable objects, or
-* when an `insert`/`update` delta carries no `row` to splice in.
-*/
+ * Apply a structured `MutationDelta` to a cached array result, returning a new
+ * array (never mutating the input). Returns `undefined` when the delta can't be
+ * applied cleanly — the caller should then fall back to the existing
+ * full-replacement behaviour (or trust the next snapshot to reconcile).
+ *
+ * Mergeable shape: a plain array of id-bearing row objects, e.g. the result of
+ * `db.query().collect()`.
+ *
+ * Insert / update / delete are matched by row `_id`:
+ * - `insert`: appended (or placed by `_creationTime` order) if absent; treated
+ * as an update if a row with the same id already exists (idempotent — guards
+ * against a delta replayed after a snapshot already included it).
+ * - `update`: replaces the matching row in place, preserving its position.
+ * - `delete`: removes the matching row.
+ *
+ * Returns `undefined` when `current` isn't an array of id-keyable objects, or
+ * when an `insert`/`update` delta carries no `row` to splice in.
+ */
 declare const applyDelta: (current: unknown, delta: MutationDelta) => undefined | unknown[];
 /**
-* Options accepted by {@link httpStream}.
-* @experimental Part of the HTTP-SSE stream surface.
-*/
+ * Options accepted by {@link httpStream}.
+ * @experimental Part of the HTTP-SSE stream surface.
+ */
 interface HttpStreamOptions {
   /**
-  * Origin (or origin + prefix) the route path is appended to, e.g.
-  * `https://my-app.example.com`. Defaults to `""` — a relative URL, which
-  * resolves against the page origin in a browser.
-  */
+   * Origin (or origin + prefix) the route path is appended to, e.g.
+   * `https://my-app.example.com`. Defaults to `""` — a relative URL, which
+   * resolves against the page origin in a browser.
+   */
   baseUrl?: string;
   /** `fetch` implementation override; defaults to the global `fetch`. */
   fetch?: typeof fetch;
@@ -217,32 +217,32 @@ interface HttpStreamOptions {
   signal?: AbortSignal;
 }
 /**
-* Open a typed HTTP-SSE stream route and iterate its chunks:
-*
-* ```ts
-* const stream = httpStream(httpStreams.http.tokens, { searchParams: { prompt } }, { baseUrl });
-* for await (const token of stream) {
-*     render(token); // typed as the route handler's yielded chunk
-* }
-* ```
-*
-* The returned iterable terminates when the server writes `event: complete`;
-* an `event: error` frame (or a transport failure) surfaces as a coded
-* rejection on the next `next()`. `.cancel()` — or aborting `options.signal` —
-* aborts the underlying fetch, which the server observes via `request.signal`.
-* @experimental Reconnect/POST-body/wire-fidelity design questions are still open, so the shape may change.
-*/
+ * Open a typed HTTP-SSE stream route and iterate its chunks:
+ *
+ * ```ts
+ * const stream = httpStream(httpStreams.http.tokens, { searchParams: { prompt } }, { baseUrl });
+ * for await (const token of stream) {
+ *     render(token); // typed as the route handler's yielded chunk
+ * }
+ * ```
+ *
+ * The returned iterable terminates when the server writes `event: complete`;
+ * an `event: error` frame (or a transport failure) surfaces as a coded
+ * rejection on the next `next()`. `.cancel()` — or aborting `options.signal` —
+ * aborts the underlying fetch, which the server observes via `request.signal`.
+ * @experimental Reconnect/POST-body/wire-fidelity design questions are still open, so the shape may change.
+ */
 declare const httpStream: <Ref extends HttpStreamRef>(route: Ref, args?: HttpStreamArgsOf<Ref>, options?: HttpStreamOptions) => StreamIterable<HttpStreamChunkOf<Ref>>;
 /** The single transport method a mutation runner needs — narrowed so adapters can test against a stub. */
 interface MutationCapableClient<F extends FunctionReference> {
   mutation: (function_: F, args: ArgsOf<F>, options?: MutationCallOptions<unknown, unknown, ArgsOf<F>>) => Promise<ReturnOf<F>>;
 }
 /**
-* Reactive sinks an adapter binds to its own primitive's setters (a Solid
-* signal, a Vue ref, a Svelte store). The runner pushes into them; how they
-* store the value is the adapter's concern (e.g. Solid wraps function-valued
-* results in a thunk).
-*/
+ * Reactive sinks an adapter binds to its own primitive's setters (a Solid
+ * signal, a Vue ref, a Svelte store). The runner pushes into them; how they
+ * store the value is the adapter's concern (e.g. Solid wraps function-valued
+ * results in a thunk).
+ */
 interface MutationRunnerSinks<R> {
   /** Receives the normalized {@link Error} when an invocation rejects. */
   setError: (error: Error) => void;
@@ -252,41 +252,41 @@ interface MutationRunnerSinks<R> {
   setResult: (result: R) => void;
 }
 /**
-* Build the framework-neutral `mutate` half of an adapter's mutation hook.
-*
-* Owns the orchestration every adapter otherwise copy-pastes: ref-counts
-* overlapping invocations into `setPending` (so it only clears once the last
-* settles), normalizes a thrown non-`Error`, and routes success/failure to
-* `setResult`/`setError` before re-throwing. Each adapter (`@lunora/react`,
-* `/solid`, `/svelte`, `/vue`) binds the three sinks to its own reactive
-* setters, so this logic lives in exactly one place. Optimistic-update options
-* pass straight through to `client.mutation`.
-*/
+ * Build the framework-neutral `mutate` half of an adapter's mutation hook.
+ *
+ * Owns the orchestration every adapter otherwise copy-pastes: ref-counts
+ * overlapping invocations into `setPending` (so it only clears once the last
+ * settles), normalizes a thrown non-`Error`, and routes success/failure to
+ * `setResult`/`setError` before re-throwing. Each adapter (`@lunora/react`,
+ * `/solid`, `/svelte`, `/vue`) binds the three sinks to its own reactive
+ * setters, so this logic lives in exactly one place. Optimistic-update options
+ * pass straight through to `client.mutation`.
+ */
 declare const createMutationRunner: <F extends FunctionReference>(client: MutationCapableClient<F>, function_: F, sinks: MutationRunnerSinks<ReturnOf<F>>) => ((args: ArgsOf<F>, options?: MutationCallOptions<unknown, unknown, ArgsOf<F>>) => Promise<ReturnOf<F>>);
 /**
-* The structural surface of a TanStack `Transaction` a bound custom mutator
-* returns — its `isPersisted.promise` resolves once the write is persisted and
-* rejects on failure. Typed structurally so the framework adapters need not
-* depend on `@tanstack/db` or `@lunora/db` (the handle is created app-side by
-* `bindMutators`).
-*/
+ * The structural surface of a TanStack `Transaction` a bound custom mutator
+ * returns — its `isPersisted.promise` resolves once the write is persisted and
+ * rejects on failure. Typed structurally so the framework adapters need not
+ * depend on `@tanstack/db` or `@lunora/db` (the handle is created app-side by
+ * `bindMutators`).
+ */
 interface MutatorTransaction {
   isPersisted: {
     promise: Promise<unknown>;
   };
 }
 /**
-* A bound custom-mutator handle produced by `bindMutators(client, ctx, mutators)`
-* in `@lunora/db`. Calling it applies the optimistic overlay to the local
-* collections and pushes the authoritative server write; it returns the TanStack
-* transaction whose `isPersisted` promise tracks completion.
-*/
+ * A bound custom-mutator handle produced by `bindMutators(client, ctx, mutators)`
+ * in `@lunora/db`. Calling it applies the optimistic overlay to the local
+ * collections and pushes the authoritative server write; it returns the TanStack
+ * transaction whose `isPersisted` promise tracks completion.
+ */
 type MutatorHandle<TArgs> = (args: TArgs) => MutatorTransaction;
 /**
-* Reactive sinks an adapter binds to its own primitive's setters (a React
-* `useState`, a Solid signal, a Vue ref, a Svelte store). The runner pushes into
-* them; how they store the value is the adapter's concern.
-*/
+ * Reactive sinks an adapter binds to its own primitive's setters (a React
+ * `useState`, a Solid signal, a Vue ref, a Svelte store). The runner pushes into
+ * them; how they store the value is the adapter's concern.
+ */
 interface MutatorRunnerSinks {
   /** Receives the normalized {@link Error} when an invocation rejects, or `undefined` on success / reset. */
   setError: (error: Error | undefined) => void;
@@ -294,24 +294,24 @@ interface MutatorRunnerSinks {
   setPending: (pending: boolean) => void;
 }
 /**
-* Build the framework-neutral `mutate` / `reset` pair of an adapter's
-* custom-mutator hook (`useMutator` / `createMutator` / `mutator`).
-*
-* Owns the orchestration every adapter otherwise copy-pastes: ref-counts
-* overlapping invocations into `setPending` (so it only clears once the last
-* settles), awaits the bound handle's `isPersisted` promise, normalizes a thrown
-* non-`Error`, and routes failure to `setError` (clearing it on success) before
-* re-throwing. Each adapter (`@lunora/react`, `/solid`, `/svelte`, `/vue`) binds
-* the two sinks to its own reactive setters, so this logic lives in exactly one
-* place. The optimistic overlay + server push are owned by the bound handle.
-*
-* `error` tracks the LATEST invocation, not the last to settle: overlapping
-* calls can resolve out of order, so an earlier call that finishes later must
-* not clobber a newer call's outcome. Each invocation takes a monotonic token
-* and only writes `setError` while it is still the most recent one — otherwise
-* `error`/`isError` could surface a stale success or failure (the documented
-* "latest invocation's error" contract every adapter advertises).
-*/
+ * Build the framework-neutral `mutate` / `reset` pair of an adapter's
+ * custom-mutator hook (`useMutator` / `createMutator` / `mutator`).
+ *
+ * Owns the orchestration every adapter otherwise copy-pastes: ref-counts
+ * overlapping invocations into `setPending` (so it only clears once the last
+ * settles), awaits the bound handle's `isPersisted` promise, normalizes a thrown
+ * non-`Error`, and routes failure to `setError` (clearing it on success) before
+ * re-throwing. Each adapter (`@lunora/react`, `/solid`, `/svelte`, `/vue`) binds
+ * the two sinks to its own reactive setters, so this logic lives in exactly one
+ * place. The optimistic overlay + server push are owned by the bound handle.
+ *
+ * `error` tracks the LATEST invocation, not the last to settle: overlapping
+ * calls can resolve out of order, so an earlier call that finishes later must
+ * not clobber a newer call's outcome. Each invocation takes a monotonic token
+ * and only writes `setError` while it is still the most recent one — otherwise
+ * `error`/`isError` could surface a stale success or failure (the documented
+ * "latest invocation's error" contract every adapter advertises).
+ */
 declare const createMutatorRunner: <TArgs>(handle: MutatorHandle<TArgs>, sinks: MutatorRunnerSinks) => {
   mutate: (args: TArgs) => Promise<void>;
   reset: () => void;
@@ -322,31 +322,31 @@ interface QueuedMutation<T = unknown> {
   /** Stable id used to remove the entry from durable storage once replayed; assigned by the queue when absent. */
   id?: string;
   /**
-  * Issuing identity fingerprint carried through to durable storage (`null` =
-  * signed out). Absent on hydrated legacy records, which replay ambiently.
-  */
+   * Issuing identity fingerprint carried through to durable storage (`null` =
+   * signed out). Absent on hydrated legacy records, which replay ambiently.
+   */
   readonly identity?: string | null;
   /**
-  * `true` when a live caller is still awaiting this write's `mutation()`
-  * Promise; `false`/absent for a write restored from durable storage after a
-  * reload (its original awaiter is gone). Carried so terminal-verdict
-  * observers can distinguish "the caller already saw this" from "nothing else
-  * will report this". Maps to the public `MutationSettledEvent.hadAwaiter`.
-  */
+   * `true` when a live caller is still awaiting this write's `mutation()`
+   * Promise; `false`/absent for a write restored from durable storage after a
+   * reload (its original awaiter is gone). Carried so terminal-verdict
+   * observers can distinguish "the caller already saw this" from "nothing else
+   * will report this". Maps to the public `MutationSettledEvent.hadAwaiter`.
+   */
   liveAwaiter?: boolean;
   /**
-  * Invoked on a successful replay with the server's echoed commit CDC cursor,
-  * so a live per-call optimistic layer drops gaplessly once a frame reaches it.
-  * Absent on hydrated records (the optimistic write lived in a prior session).
-  */
+   * Invoked on a successful replay with the server's echoed commit CDC cursor,
+   * so a live per-call optimistic layer drops gaplessly once a frame reaches it.
+   * Absent on hydrated records (the optimistic write lived in a prior session).
+   */
   readonly onCommit?: (commitCursor: number | undefined) => void;
   /**
-  * Optional sync predicate evaluated just before replay. When it returns
-  * `false` the write is dropped instead of replaying, handling the case
-  * where the mutation's preconditions are no longer valid (e.g. the
-  * document it referred to was deleted while offline). Absent or `true`
-  * means "ok to replay".
-  */
+   * Optional sync predicate evaluated just before replay. When it returns
+   * `false` the write is dropped instead of replaying, handling the case
+   * where the mutation's preconditions are no longer valid (e.g. the
+   * document it referred to was deleted while offline). Absent or `true`
+   * means "ok to replay".
+   */
   readonly precondition?: () => boolean;
   /** Rejects if the mutation can no longer be replayed. */
   readonly reject: (error: unknown) => void;
@@ -355,11 +355,11 @@ interface QueuedMutation<T = unknown> {
   readonly shardKey?: string;
 }
 /**
-* Invoked when the queue itself discards an entry on overflow (capacity
-* eviction), so the client can surface the dropped write on its
-* terminal-verdict observer even when the entry has no live awaiter (a hydrated
-* record). The `error` carries the `OFFLINE_QUEUE_OVERFLOW` code.
-*/
+ * Invoked when the queue itself discards an entry on overflow (capacity
+ * eviction), so the client can surface the dropped write on its
+ * terminal-verdict observer even when the entry has no live awaiter (a hydrated
+ * record). The `error` carries the `OFFLINE_QUEUE_OVERFLOW` code.
+ */
 type EvictHandler = (entry: QueuedMutation, error: Error & {
   code?: string;
 }) => void;
@@ -375,28 +375,17 @@ interface OfflineQueueDeps {
   version?: string;
 }
 /**
-* A process-unique id, used both per-mutation and as the fallback `clientId`. It
-* MUST be globally unique: the server scopes a custom mutator's replay watermark
-* by `(verifiedIdentity, clientId)`, and an anonymous push has no verified
-* identity — so two anonymous clients that collide on `clientId` would share one
-* watermark namespace, letting one stall/suppress the other's ordered mutations.
-* `crypto.randomUUID` covers every modern runtime; the fallback still mixes
-* crypto-quality (or `Math.random`) entropy with the timestamp + counter so it
-* can't collide across two clients started in the same millisecond.
-*/
-
-/**
-* Bounded FIFO queue. Mutations issued while the client is offline are
-* enqueued and replayed in the order they were submitted once the WS
-* reconnects and identifies. If the queue exceeds `maxItems` the oldest
-* entry is rejected with `OFFLINE_QUEUE_OVERFLOW`.
-*
-* When a {@link PersistenceAdapter} is supplied, enqueued mutations are mirrored
-* to durable storage so they survive a reload — {@link OfflineQueue.hydrate} restores them on
-* the next startup and the client replays them on reconnect. Durable removal is
-* the caller's responsibility *after* a successful replay (see `LunoraClient`);
-* the queue only persists on enqueue and un-persists on overflow.
-*/
+ * Bounded FIFO queue. Mutations issued while the client is offline are
+ * enqueued and replayed in the order they were submitted once the WS
+ * reconnects and identifies. If the queue exceeds `maxItems` the oldest
+ * entry is rejected with `OFFLINE_QUEUE_OVERFLOW`.
+ *
+ * When a {@link PersistenceAdapter} is supplied, enqueued mutations are mirrored
+ * to durable storage so they survive a reload — {@link OfflineQueue.hydrate} restores them on
+ * the next startup and the client replays them on reconnect. Durable removal is
+ * the caller's responsibility *after* a successful replay (see `LunoraClient`);
+ * the queue only persists on enqueue and un-persists on overflow.
+ */
 declare class OfflineQueue {
   /** Opt-in to queueing mutations before the targeted shard's first connect. */
   readonly queueBeforeFirstConnect: boolean;
@@ -412,58 +401,58 @@ declare class OfflineQueue {
   get size(): number;
   enqueue<T>(entry: QueuedMutation<T>): void;
   /**
-  * Restore mutations persisted in a prior session and re-queue them in FIFO
-  * order. Restored entries already live in durable storage, so they are not
-  * re-appended; they carry no-op `resolve`/`reject` (the original awaiter is
-  * gone after a reload). No-op when no persistence adapter is configured.
-  * Returns the distinct shard keys of the restored writes so the caller can
-  * open their sockets to trigger a flush.
-  *
-  * `hydrate()` runs post-construction (the caller awaits an async durable-store
-  * load), so a mutation issued while offline during that boot window is
-  * enqueued into `items` *before* this method's `await` resolves. Restored
-  * records are therefore `unshift`-ed ahead of whatever is already queued
-  * rather than `push`-ed to the end: the durable store's persist order is
-  * authoritative (a prior-session write is always older than anything from
-  * this session), so replaying a same-session boot-time write before an
-  * older restored write on the same document would let last-writer-wins
-  * silently clobber the newer data with the stale one.
-  */
+   * Restore mutations persisted in a prior session and re-queue them in FIFO
+   * order. Restored entries already live in durable storage, so they are not
+   * re-appended; they carry no-op `resolve`/`reject` (the original awaiter is
+   * gone after a reload). No-op when no persistence adapter is configured.
+   * Returns the distinct shard keys of the restored writes so the caller can
+   * open their sockets to trigger a flush.
+   *
+   * `hydrate()` runs post-construction (the caller awaits an async durable-store
+   * load), so a mutation issued while offline during that boot window is
+   * enqueued into `items` *before* this method's `await` resolves. Restored
+   * records are therefore `unshift`-ed ahead of whatever is already queued
+   * rather than `push`-ed to the end: the durable store's persist order is
+   * authoritative (a prior-session write is always older than anything from
+   * this session), so replaying a same-session boot-time write before an
+   * older restored write on the same document would let last-writer-wins
+   * silently clobber the newer data with the stale one.
+   */
   hydrate(): Promise<(string | undefined)[]>;
   /**
-  * Remove and return queued mutations. With no `predicate`, drains the whole
-  * queue. With one, drains only matching entries (preserving FIFO order) and
-  * leaves the rest queued — used to flush a single shard's writes when its
-  * socket reconnects while other shards are still down.
-  */
+   * Remove and return queued mutations. With no `predicate`, drains the whole
+   * queue. With one, drains only matching entries (preserving FIFO order) and
+   * leaves the rest queued — used to flush a single shard's writes when its
+   * socket reconnects while other shards are still down.
+   */
   drain(predicate?: (item: QueuedMutation) => boolean): QueuedMutation[];
   /**
-  * Return previously-drained mutations to the front of the queue, preserving
-  * their FIFO order, without re-persisting them — they were never unpersisted,
-  * so durable storage still holds them. Used when a flush aborts on a transient
-  * transport failure: the unreplayed writes stay queued for the next reconnect.
-  */
+   * Return previously-drained mutations to the front of the queue, preserving
+   * their FIFO order, without re-persisting them — they were never unpersisted,
+   * so durable storage still holds them. Used when a flush aborts on a transient
+   * transport failure: the unreplayed writes stay queued for the next reconnect.
+   */
   requeue(items: QueuedMutation[]): void;
   /**
-  * Remove mutations whose precondition evaluates to `false` (stale/dirty
-  * writes that should not replay) and reject each with an
-  * `OFFLINE_PRECONDITION_FAILED` error. The valid (admitted) mutations stay
-  * queued in FIFO order. Returns the drained stale entries.
-  *
-  * Called during reconnect before the flush cycle to weed out writes whose
-  * assumptions no longer hold (e.g. a document was deleted by another client).
-  */
+   * Remove mutations whose precondition evaluates to `false` (stale/dirty
+   * writes that should not replay) and reject each with an
+   * `OFFLINE_PRECONDITION_FAILED` error. The valid (admitted) mutations stay
+   * queued in FIFO order. Returns the drained stale entries.
+   *
+   * Called during reconnect before the flush cycle to weed out writes whose
+   * assumptions no longer hold (e.g. a document was deleted by another client).
+   */
   drainConflict(): QueuedMutation[];
   clear(): void;
   /** Notify the size observer (the client's pending-sync count) after any change. */
   private notifySize;
 }
 /**
-* In-memory {@link PersistenceAdapter}. Doesn't survive a reload — it exists so
-* the persistence wiring can be exercised without IndexedDB (tests, SSR, or as
-* a deliberate "no durable store" choice that still satisfies the interface).
-* Preserves enqueue order; `clone` keeps callers from mutating stored args.
-*/
+ * In-memory {@link PersistenceAdapter}. Doesn't survive a reload — it exists so
+ * the persistence wiring can be exercised without IndexedDB (tests, SSR, or as
+ * a deliberate "no durable store" choice that still satisfies the interface).
+ * Preserves enqueue order; `clone` keeps callers from mutating stored args.
+ */
 declare const createInMemoryPersistence: () => PersistenceAdapter;
 interface IndexedDbPersistenceOptions {
   /** Database name; defaults to `"lunora-outbox"` (its own DB, separate from the read cache). */
@@ -474,47 +463,29 @@ interface IndexedDbPersistenceOptions {
   storeName?: string;
 }
 /**
-* IndexedDB-backed {@link PersistenceAdapter}. Each mutation is stored under an
-* autoincrementing key (so `load()` returns them in enqueue order regardless of
-* the string ids) with a unique secondary index on `id` for `remove()`.
-*
-* The store handle is opened lazily and the open promise is cached, so repeated
-* ops reuse one connection. Throws eagerly if no `IDBFactory` is available —
-* callers in non-browser environments should use {@link createInMemoryPersistence}.
-*/
+ * IndexedDB-backed {@link PersistenceAdapter}. Each mutation is stored under an
+ * autoincrementing key (so `load()` returns them in enqueue order regardless of
+ * the string ids) with a unique secondary index on `id` for `remove()`.
+ *
+ * The store handle is opened lazily and the open promise is cached, so repeated
+ * ops reuse one connection. Throws eagerly if no `IDBFactory` is available —
+ * callers in non-browser environments should use {@link createInMemoryPersistence}.
+ */
 declare const createIndexedDbPersistence: (options?: IndexedDbPersistenceOptions) => PersistenceAdapter;
 /**
-* Resolve the effective offline-queue persistence from the user option,
-* defaulting to a durable IndexedDB store when the environment supports one.
-*
-* An explicit adapter is used as-is; `false` opts out (the caller keeps an
-* in-memory queue, lost on reload); `undefined` (the default) auto-probes
-* IndexedDB when the global is present (browsers) and `autoProbe` is set,
-* otherwise `undefined` — so SSR/Node/React-Native keep today's in-memory
-* behaviour and only environments that can persist do.
-*
-* `autoProbe` is `false` when the `@lunora/db` outbox is wired: that sink is the
-* single durable write path, so the built-in queue must stay in memory rather
-* than persist a second, never-flushed copy. An explicit adapter is still
-* honoured (the caller asked for it); only the implicit default is suppressed.
-*
-* The IndexedDB adapter opens its connection lazily, so constructing it here is
-* cheap and never throws (the `indexedDB` global is verified present first).
-*/
-/**
-* Compose the read-cache key for a subscription. Mirrors how
-* `SubscriptionRegistry` keys live subscriptions so a hydrated value lines up
-* with the subscription that will consume it. `shardKey` defaults to `""` (the
-* root shard) exactly as the registry does.
-*/
+ * Compose the read-cache key for a subscription. Mirrors how
+ * `SubscriptionRegistry` keys live subscriptions so a hydrated value lines up
+ * with the subscription that will consume it. `shardKey` defaults to `""` (the
+ * root shard) exactly as the registry does.
+ */
 declare const queryCacheKey: (functionPath: string, argsKey: string, shardKey?: string) => string;
 /**
-* In-memory {@link QueryCacheAdapter}. Doesn't survive a reload — it exists so
-* the read-cache wiring can be exercised without IndexedDB (tests, SSR, or as a
-* deliberate "no durable store" choice that still satisfies the interface).
-* Enforces the same LRU row cap as the IndexedDB adapter; `clone` keeps callers
-* from mutating stored values.
-*/
+ * In-memory {@link QueryCacheAdapter}. Doesn't survive a reload — it exists so
+ * the read-cache wiring can be exercised without IndexedDB (tests, SSR, or as a
+ * deliberate "no durable store" choice that still satisfies the interface).
+ * Enforces the same LRU row cap as the IndexedDB adapter; `clone` keeps callers
+ * from mutating stored values.
+ */
 declare const createInMemoryQueryCache: (options?: {
   maxEntries?: number;
 }) => QueryCacheAdapter;
@@ -529,34 +500,25 @@ interface IndexedDbQueryCacheOptions {
   storeName?: string;
 }
 /**
-* IndexedDB-backed {@link QueryCacheAdapter}. Each query is stored under its
-* composite key (`functionPath::argsKey::shardKey`) with a `ts` index driving
-* LRU eviction. The store handle is opened lazily and cached, so repeated ops
-* reuse one connection.
-*
-* The store lives in its own `lunora-query-cache` database — deliberately
-* separate from the offline-mutation outbox's `lunora-outbox` database so the two
-* independently-toggleable adapters never share (and drift on) a schema version.
-* Throws eagerly if no `IDBFactory` is available — callers in non-browser
-* environments should use {@link createInMemoryQueryCache}.
-*/
+ * IndexedDB-backed {@link QueryCacheAdapter}. Each query is stored under its
+ * composite key (`functionPath::argsKey::shardKey`) with a `ts` index driving
+ * LRU eviction. The store handle is opened lazily and cached, so repeated ops
+ * reuse one connection.
+ *
+ * The store lives in its own `lunora-query-cache` database — deliberately
+ * separate from the offline-mutation outbox's `lunora-outbox` database so the two
+ * independently-toggleable adapters never share (and drift on) a schema version.
+ * Throws eagerly if no `IDBFactory` is available — callers in non-browser
+ * environments should use {@link createInMemoryQueryCache}.
+ */
 declare const createIndexedDbQueryCache: (options?: IndexedDbQueryCacheOptions) => QueryCacheAdapter;
 /**
-* Resolve the effective read-cache from the user option, defaulting to a durable
-* IndexedDB store when the environment supports one. Same tri-state semantics as
-* `resolvePersistenceAdapter` in `./persistence`:
-*
-* - an explicit adapter is used as-is;
-* - `false` opts out — reads stay in memory only;
-* - `undefined` (the default) auto-probes IndexedDB (browsers), else `undefined`.
-*/
-/**
-* Exponential backoff calculator with optional jitter.
-*
-* `next()` doubles the delay each call up to `maxDelayMs`. When `jitter` is
-* enabled the returned value is randomized in `[delay/2, delay]` so a fleet
-* of clients reconnecting at the same time spread out their retries.
-*/
+ * Exponential backoff calculator with optional jitter.
+ *
+ * `next()` doubles the delay each call up to `maxDelayMs`. When `jitter` is
+ * enabled the returned value is randomized in `[delay/2, delay]` so a fleet
+ * of clients reconnecting at the same time spread out their retries.
+ */
 interface ReconnectCalculator {
   /** Returns the delay to wait before the next reconnect attempt. */
   next: () => number;
@@ -565,34 +527,34 @@ interface ReconnectCalculator {
 }
 declare const createReconnect: (options?: ReconnectOptions, random?: () => number) => ReconnectCalculator;
 /**
-* Capture a snapshot of the current live query value at call time and produce a
-* `() => boolean` precondition that compares it against the value at replay time.
-*
-* When the precondition is checked (on queue drain / reconnect) it re-reads the
-* query's current value via {@link LunoraClient.peekActiveQueryValue}. If the
-* value differs from what was captured at call time the precondition returns
-* `false` and the offline mutation is dropped as stale.
-* @example
-* ```ts
-* client.mutation(api.todos.update, { id, text }, {
-*   precondition: createSnapshotPrecondition(client, api.todos.list, { userId }),
-* });
-* ```
-*/
+ * Capture a snapshot of the current live query value at call time and produce a
+ * `() => boolean` precondition that compares it against the value at replay time.
+ *
+ * When the precondition is checked (on queue drain / reconnect) it re-reads the
+ * query's current value via {@link LunoraClient.peekActiveQueryValue}. If the
+ * value differs from what was captured at call time the precondition returns
+ * `false` and the offline mutation is dropped as stale.
+ * @example
+ * ```ts
+ * client.mutation(api.todos.update, { id, text }, {
+ *   precondition: createSnapshotPrecondition(client, api.todos.list, { userId }),
+ * });
+ * ```
+ */
 declare const createSnapshotPrecondition: (client: LunoraClient, functionRef: FunctionReference, args: Record<string, unknown>, shardKey?: string) => (() => boolean);
 /**
-* Client-side service-worker registration and lifecycle management.
-*
-* Usage:
-* ```ts
-* const sw = new ClientServiceWorker({ swUrl: "/sw.js" });
-* await sw.register();
-*
-* if (sw.active) {
-*   sw.postMessage({ type: "sync" });
-* }
-* ```
-*/
+ * Client-side service-worker registration and lifecycle management.
+ *
+ * Usage:
+ * ```ts
+ * const sw = new ClientServiceWorker({ swUrl: "/sw.js" });
+ * await sw.register();
+ *
+ * if (sw.active) {
+ *   sw.postMessage({ type: "sync" });
+ * }
+ * ```
+ */
 type ServiceWorkerStatus = "unsupported" | "unregistered" | "registering" | "active" | "error";
 interface ClientSwOptions {
   /** Called when the status changes. */
@@ -603,9 +565,9 @@ interface ClientSwOptions {
   swUrl: string;
 }
 /**
-* Manages service-worker registration and provides a simple API for
-* sending messages and listening for responses.
-*/
+ * Manages service-worker registration and provides a simple API for
+ * sending messages and listening for responses.
+ */
 declare class ClientServiceWorker {
   #private;
   readonly swUrl: string;
@@ -618,30 +580,30 @@ declare class ClientServiceWorker {
   /** Whether the SW is currently controlling this page. */
   get active(): boolean;
   /**
-  * Register the service worker.
-  *
-  * Returns `false` when the browser does not support service workers.
-  */
+   * Register the service worker.
+   *
+   * Returns `false` when the browser does not support service workers.
+   */
   register(): Promise<boolean>;
   /**
-  * Remove the active service worker registration and clear listeners.
-  *
-  * Returns `false` when no registration is currently held.
-  */
+   * Remove the active service worker registration and clear listeners.
+   *
+   * Returns `false` when no registration is currently held.
+   */
   unregister(): Promise<boolean>;
   /**
-  * Send a message to the active service worker.
-  */
+   * Send a message to the active service worker.
+   */
   postMessage(message: unknown): void;
   /**
-  * Register a handler for messages **from** the service worker.
-  * @returns Unsubscribe function.
-  */
+   * Register a handler for messages **from** the service worker.
+   * @returns Unsubscribe function.
+   */
   onMessage(handler: (event: MessageEvent) => void): () => void;
 }
 /**
-* Outbound message from the client to the SW.
-*/
+ * Outbound message from the client to the SW.
+ */
 interface ClientToSwMessage {
   /** Opaque correlation ID for request/response patterns. */
   correlationId?: string;
@@ -649,8 +611,8 @@ interface ClientToSwMessage {
   type: string;
 }
 /**
-* Inbound message from the SW to the client.
-*/
+ * Inbound message from the SW to the client.
+ */
 interface SwToClientMessage {
   /** Echoes the correlation ID from the client request, if any. */
   correlationId?: string;
@@ -658,14 +620,14 @@ interface SwToClientMessage {
   type: string;
 }
 /**
-* Send a typed message to the service worker and optionally await a
-* matching response.
-* @returns A promise that resolves when the SW sends a reply with the
-* same `correlationId` (if `expectResponse` is true).
-*/
+ * Send a typed message to the service worker and optionally await a
+ * matching response.
+ * @returns A promise that resolves when the SW sends a reply with the
+ * same `correlationId` (if `expectResponse` is true).
+ */
 declare const sendToSw: (sw: ServiceWorker | null, message: ClientToSwMessage, expectResponse?: boolean) => Promise<unknown>;
 /**
-* Create a reply for a client message (call from inside the SW).
-*/
+ * Create a reply for a client message (call from inside the SW).
+ */
 declare const createReply: (original: ClientToSwMessage, payload?: unknown) => SwToClientMessage;
 export { type ArgsOf, type AsyncStorageLike, type AsyncStoragePersistenceOptions, type BookmarkStorage, ClientServiceWorker, type ClientSwOptions, type ClientToSwMessage, type FunctionReference, type HttpStreamArgsOf, type HttpStreamChunkOf, type HttpStreamOptions, type HttpStreamRef, type IndexedDbPersistenceOptions, type IndexedDbQueryCacheOptions, LunoraClient, type MutationCallOptions, type MutationDelta, type MutationRunnerSinks, type MutatorHandle, type MutatorRunnerSinks, type MutatorTransaction, OfflineQueue, type OfflineQueueOptions, type PersistenceAdapter, type QueryCacheAdapter, type QueuedMutation, type ReconnectCalculator, type ReconnectOptions, type ReturnOf, type ServiceWorkerStatus, type StreamIterable, type SubscriptionError, type SwToClientMessage, TabCoordinator, applyDelta, createAsyncStoragePersistence, createInMemoryBookmarkStorage, createInMemoryPersistence, createInMemoryQueryCache, createIndexedDbPersistence, createIndexedDbQueryCache, createMutationRunner, createMutatorRunner, createReconnect, createReply, createSnapshotPrecondition, httpStream, isMutationDelta, queryCacheKey, sendToSw };