@lunora/client 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/packem_shared/{lunora-client.d-BYkEjCEJ.d.mts → lunora-client.d-JvtVpf8A.d.mts}

@@ -1,5 +1,42 @@
 import { CronJobInfo, VectorIndexSummary, VectorQueryMatch, KvNamespaceSummary, KvKeyListResult, KvValueResult, AuthUser, AuthPage, AuthImpersonation, AuthCapabilities, AuthConfigInfo, AuthSession } from '@lunora/runtime';
 /**
+* Reactive key-value store for local-only client state.
+*
+* Unlike a server {@link SubscriptionState} (which tracks a live WS connection,
+* an `acked` flag, `serverBase`, optimistic layers, and the full subscription
+* machinery), a `ClientQueryRef` is purely local — no server round-trip, no
+* WebSocket, no persistence. It exists so framework adapters can offer a
+* `useClientQuery` hook whose values survive component remounts and are shared
+* across every consumer of the same ref, with none of the ceremony or coupling
+* of a dedicated context provider.
+*
+* The store lives inside `LunoraClient` (a private field) and is surfaced through
+* `client.getClientQuery(ref)` / `setClientQuery(ref, value)` /
+* `subscribeClientQuery(ref, callback)`.
+*/
+/** Opaque handle for a typed client-local query slot. */
+interface ClientQueryRef<T = unknown> {
+  /** Default value when no value has been set explicitly. */
+  readonly defaultValue: T;
+  /** Stable identity for the slot. Must be unique within a client instance. */
+  readonly key: string;
+}
+/** A subscriber callback for value changes to a {@link ClientQueryRef}. */
+
+/**
+* Create a typed {@link ClientQueryRef}. Call once per slot at module scope
+* (or inside a component module) — the ref object is the stable identity.
+* @example
+* ```ts
+* // lunora/client-queries.ts
+* import { createClientQuery } from "@lunora/client";
+*
+* export const sidebarOpen = createClientQuery("sidebarOpen", true);
+* export const selectedMessageId = createClientQuery("selectedMessageId", undefined as string | undefined);
+* ```
+*/
+declare const createClientQuery: <T>(key: string, defaultValue: T) => ClientQueryRef<T>;
+/**
 * The machine-readable error codes a client can observe on a failed
 * RPC/batch/subscription. Mirrors the server's `CODE_STATUS` keys
 * (`@lunora/server`'s `error.ts`) by hand — the client is framework-neutral and
@@ -80,6 +117,55 @@ interface FunctionReference<Kind extends FunctionKind = FunctionKind, Args = unk
 type ArgsOf<F> = F extends FunctionReference<infer _K, infer A, infer _R> ? A : never;
 /** Extract the return type from a {@link FunctionReference}. */
 type ReturnOf<F> = F extends FunctionReference<infer _K, infer _A, infer R> ? R : never;
+/**
+* Typed reference to an HTTP-SSE stream route (`httpRoute.&lt;verb>(path).stream()`)
+* emitted by `@lunora/codegen` as `httpStreams.&lt;namespace>.&lt;name>`.
+*
+* Distinct from {@link FunctionReference}: this is the **HTTP-SSE route stream**
+* (opened with `fetch` + `ReadableStream` against the route's own URL), not the
+* WS procedure stream (`kind: "stream"`). At runtime it carries the HTTP verb
+* and the route path; the phantom marker carries the chunk / searchParams /
+* params types so `httpStream` (and the framework hooks over it) infer the
+* chunk type end-to-end.
+* @experimental Reconnect/POST-body/wire-fidelity design questions are still open, so the shape may change.
+*/
+interface HttpStreamRef<Chunk = unknown, SearchParams = unknown, Params = unknown> {
+  /**
+  * Phantom marker carrying the `Chunk`/`SearchParams`/`Params` type
+  * parameters for inference. Never present at runtime; declared in a
+  * covariant (output) position so a concrete reference stays assignable to
+  * a widened one.
+  */
+  readonly __lunoraHttpStream?: {
+    chunk: Chunk;
+    params: Params;
+    searchParams: SearchParams;
+  };
+  /** HTTP verb the route binds to (uppercased), e.g. `"GET"`. */
+  readonly method: string;
+  /** The route path as declared, e.g. `/api/tokens/:id` — `:name` segments are filled from `params`. */
+  readonly path: string;
+}
+/**
+* The call-side args of an HTTP-SSE stream route: `:name` path params plus URL query params.
+* @experimental Part of the HTTP-SSE stream surface.
+*/
+interface HttpStreamCallArgs<SearchParams = unknown, Params = unknown> {
+  /** Values for the route path's `:name` segments. */
+  params?: Params;
+  /** URL query params, appended to the request URL (undefined entries are skipped). */
+  searchParams?: SearchParams;
+}
+/**
+* Extract the chunk type from a {@link HttpStreamRef}.
+* @experimental Part of the HTTP-SSE stream surface.
+*/
+type HttpStreamChunkOf<R> = R extends HttpStreamRef<infer Chunk, infer _S, infer _P> ? Chunk : never;
+/**
+* Extract the call-side args type from a {@link HttpStreamRef}.
+* @experimental Part of the HTTP-SSE stream surface.
+*/
+type HttpStreamArgsOf<R> = R extends HttpStreamRef<infer _C, infer S, infer P> ? HttpStreamCallArgs<S, P> : never;
 type Unsubscribe = () => void;
 /**
 * Serializable result of `preloadQuery`. Produced on the server during SSR,
@@ -272,6 +358,15 @@ interface QueryCacheAdapter {
   /** Remove one cached query by key. */
   remove: (key: string) => Promise<void>;
 }
+/**
+* Resolves the WS `?token=` credential fresh at every (re)connect — the channel
+* for short-lived tokens (e.g. the ephemeral admin sub-token the worker mints
+* at `POST /_lunora/admin/ws-token`) instead of a static secret in the URL.
+* May return the token synchronously or as a Promise; returning `undefined`
+* connects without a token. A thrown error / rejected Promise fails that
+* connect attempt, and the client retries with its normal reconnect backoff.
+*/
+type WsTokenProvider = () => Promise<string | undefined> | string | undefined;
 interface LunoraClientOptions {
   /**
   * Base path the worker mounts better-auth at, used by the client's
@@ -308,6 +403,16 @@ interface LunoraClientOptions {
   * Defaults to 10000 (10s); set to `0` (or negative) to disable.
   */
   connectTimeoutMs?: number;
+  /**
+  * When `true`, tabs sharing the same origin coordinate via BroadcastChannel
+  * so only one tab (the "leader") opens WebSocket connections to the server.
+  * Follower tabs receive subscription data through the channel instead.
+  *
+  * Reduces simultaneous WS connections, bandwidth, and cross-tab state drift.
+  * Requires `BroadcastChannel` (browser-only); silently ignored otherwise.
+  * Defaults to `false`.
+  */
+  crossTabSync?: boolean;
   fetch?: typeof fetch;
   /**
   * Interval (ms) between keepalive pings sent on each open subscription
@@ -317,6 +422,15 @@ interface LunoraClientOptions {
   * `0` (or a negative value) to disable the heartbeat entirely.
   */
   heartbeatIntervalMs?: number;
+  /**
+  * When `true` and a `queryCache` is active, framework hooks (React, Vue, …)
+  * wait for the durable cache to finish hydrating before their first render
+  * with an enabled subscription, so users see cached data instead of an
+  * undefined flash before the socket round-trip. Defaults to `false`.
+  *
+  * Requires `queryCache` to be set (not `false`); silently ignored otherwise.
+  */
+  hydrateOnStart?: boolean;
   offlineQueue?: OfflineQueueOptions;
   /**
   * Durable outbox seam for offline writes. When supplied (the `@lunora/db`
@@ -365,15 +479,21 @@ interface LunoraClientOptions {
   url: string;
   WebSocket?: typeof WebSocket;
   /**
-  * Token appended to the WebSocket URL as `?token=…`. The server matches it
-  * against `LUNORA_WS_BEARER` (to clear the upgrade gate) and/or
+  * Credential appended to the WebSocket URL as `?token=…`. The server matches
+  * it against `LUNORA_WS_BEARER` (to clear the upgrade gate) and/or
   * `LUNORA_ADMIN_TOKEN` (to authorize `__lunora_admin__:*` subscriptions —
-  * what the studio sets it to). Browsers can't set headers on the
-  * `WebSocket` constructor, so the query parameter is the only channel; it
-  * ends up in server logs and history, so prefer a short-lived rotating
-  * token in production.
+  * what the studio supplies). Browsers can't set headers on the `WebSocket`
+  * constructor, so the query parameter is the only channel; it ends up in
+  * server logs and history, so prefer a short-lived rotating token in
+  * production over a static secret.
+  *
+  * Pass a {@link WsTokenProvider} function to resolve the token fresh at
+  * every (re)connect — the channel for short-lived credentials such as the
+  * ephemeral admin sub-token minted by `POST /_lunora/admin/ws-token`: the
+  * provider re-mints on each reconnect, including the one following a `4001`
+  * token-expired drop, so a static master token never has to ride the URL.
   */
-  wsToken?: string;
+  wsToken?: string | WsTokenProvider;
   wsUrl?: string;
 }
 /** Wire envelope sent on `POST /_lunora/rpc`. */
@@ -941,9 +1061,10 @@ interface SubscriptionState {
   acked: boolean;
   readonly args: Record<string, unknown>;
   /**
-  * Stable-stringified `args`, computed once at subscribe time. Cached so the
-  * optimistic-update fan-out can compare against a mutation's args key without
-  * re-serializing every subscription's args on every mutation.
+  * Stable wire-key of `args` (`stableWireKey`), computed once at subscribe
+  * time. Cached so the optimistic-update fan-out can compare against a
+  * mutation's args key without re-serializing every subscription's args on
+  * every mutation.
   */
   readonly argsKey: string;
   readonly callbacks: Set<SubscriptionCallback>;
@@ -1012,11 +1133,13 @@ interface SubscriptionState {
 }
 /**
 * Active subscription registry. The client keys subscriptions by
-* `(functionPath, stableStringify(args), shardKey)` so duplicate calls share a
+* `(functionPath, stableWireKey(args), shardKey)` so duplicate calls share a
 * single server-side registration. Args are stably encoded (keys sorted at every
 * depth) so two structurally-equal arg records constructed with a different key
 * order (`{ a, b }` vs `{ b, a }`) collapse to the same key instead of leaking a
-* duplicate subscription.
+* duplicate subscription. Encoding the args' **wire form** keeps the key
+* byte-identical for pure-JSON args while giving wire-typed args (`bigint`,
+* `Date`, bytes, …) distinct stable tokens instead of a throw.
 */
 declare class SubscriptionRegistry {
   static key(functionPath: string, args: Record<string, unknown>, shardKey?: string): string;
@@ -1178,6 +1301,14 @@ interface MutationCallOptions<TCurrent = unknown, TValue = unknown, TArgs = unkn
   * once; every write is rolled back atomically if the mutation fails.
   */
   optimisticUpdate?: OptimisticUpdate<TArgs>;
+  /**
+  * Sync predicate evaluated just before the offline queue replays this
+  * write on reconnect. When it returns `false` the mutation is dropped
+  * instead of replayed — use it to guard against replaying writes whose
+  * assumptions are no longer valid (e.g. the document it referred to was
+  * deleted by another client while this tab was offline).
+  */
+  precondition?: () => boolean;
   shardKey?: string;
 }
 /** Callback a shape subscription invokes with its materialized rowset on every applied poke. */
@@ -1226,8 +1357,19 @@ type BatchSlot = {
 declare class LunoraClient {
   /** Hard cap on concurrently-buffered pokes — a backstop that reclaims buffers abandoned by a mid-poke disconnect (no `pokeEnd`). Far above any real concurrent-in-flight count. */
   private static readonly MAX_POKE_BUFFERS;
+  /**
+  * Create a typed {@link ClientQueryRef}. Convenience wrapper around
+  * {@link createClientQuery} so you don't need a separate import.
+  * @example
+  * ```ts
+  * const sidebarOpen = LunoraClient.createClientQuery("sidebarOpen", true);
+  * ```
+  */
+  static createClientQuery<T>(key: string, defaultValue: T): ClientQueryRef<T>;
   readonly url: string;
   readonly wsUrl: string;
+  /** Local reactive store for {@link ClientQueryRef} values — no server round-trip. Private; reach it via `getClientQuery` / `setClientQuery` / `subscribeClientQuery`. */
+  private readonly clientQueryStore;
   private wsToken;
   /** Better-auth base path (trailing slash stripped) for the `get-session` lookup. */
   private readonly authBasePath;
@@ -1249,6 +1391,20 @@ declare class LunoraClient {
   /** Stable per-client id stamped onto every `OutboxMutation` (custom-mutator watermark). */
   private readonly clientId;
   /**
+  * `true` when the constructor's hydration microtask has finished loading the
+  * durable read cache (Pillar 2) into `hydratedQueryCache`. Signals that
+  * the cache is ready for synchronous `peekHydratedQuery` reads.
+  */
+  private readyResolved;
+  /** Resolvers for `whenReady()` — called once hydration completes. */
+  private readyResolve;
+  /**
+  * Promise that resolves once the durable read cache has been loaded. When
+  * `hydrateOnStart` is not set or no query cache is configured, resolves
+  * immediately (the constructor creates an already-resolved promise).
+  */
+  private readonly readyPromise;
+  /**
   * Highest custom-mutator watermark the server has echoed for this client,
   * keyed by shard bucket (`shardKey ?? ""`) since the DO tracks one
   * `__client_watermark` per shard. `callMutator` bumps it from every
@@ -1281,6 +1437,12 @@ declare class LunoraClient {
   private readonly pendingCacheWrites;
   private cacheFlushTimer;
   private readonly subscriptions;
+  /**
+  * Cross-tab coordinator; created only when `crossTabSync: true`. When the
+  * client is not the elected leader, all WebSocket operations are skipped.
+  * Not `readonly` — `close()` clears it (mirrors `outboxLeaderRelease`).
+  */
+  private tabCoordinator;
   /** One {@link ShardConnection} per shard key (keyed by `shardKey ?? ""`). */
   private readonly connections;
   /** Default `connect`-envelope context applied to a shard with no explicit override. */
@@ -1444,10 +1606,12 @@ declare class LunoraClient {
   * Replace the token appended to WS upgrade URLs as `?token=…` and close
   * every open shard socket so the reconnect picks up the new value. Call
   * this whenever the user's WS credential changes (rotating the admin token
-  * in the studio, switching workspaces, etc.). Bearer tokens for HTTP
-  * RPC are independent — see {@link setAuthToken}.
+  * in the studio, switching workspaces, etc.). Accepts a static string or a
+  * {@link WsTokenProvider} resolved fresh at every (re)connect — the channel
+  * for short-lived credentials like the minted ephemeral admin sub-token.
+  * Bearer tokens for HTTP RPC are independent — see {@link setAuthToken}.
   */
-  setWsToken(token: string | undefined): void;
+  setWsToken(token: string | undefined | WsTokenProvider): void;
   /**
   * Register (or clear, with `undefined`) the app context sent in the `connect`
   * envelope for a shard's socket, overriding the client-wide
@@ -1559,6 +1723,93 @@ declare class LunoraClient {
   * unsubscribe function. See {@link MutationSettledEvent}.
   */
   onMutationSettled(listener: (event: MutationSettledEvent) => void): Unsubscribe;
+  /**
+  * Read the current value for a {@link ClientQueryRef}. Returns
+  * `ref.defaultValue` when no value has been explicitly set.
+  */
+  getClientQuery<T>(ref: ClientQueryRef<T>): T;
+  /**
+  * Set a new value for `ref` and notify every subscriber. Pass `undefined`
+  * to reset the slot to `ref.defaultValue`.
+  */
+  setClientQuery<T>(ref: ClientQueryRef<T>, value: T): void;
+  /**
+  * Subscribe to changes for `ref`. The callback is NOT invoked on
+  * registration — call {@link getClientQuery} for the current value.
+  * Returns an unsubscribe function.
+  */
+  subscribeClientQuery(ref: ClientQueryRef, callback: (value: unknown) => void): Unsubscribe;
+  /**
+  * Reset a {@link ClientQueryRef} to its default value, notifying every
+  * subscriber. Equivalent to `setClientQuery(ref, ref.defaultValue)` but
+  * removes the stored entry so a future {@link getClientQuery} returns
+  * the default rather than an explicitly-set value.
+  */
+  resetClientQuery(ref: ClientQueryRef): void;
+  /**
+  * 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 (on queue drain / reconnect).
+  *
+  * When the precondition is checked it re-reads the query's current value
+  * via `peekActiveQueryValue`. If the value differs from what was
+  * captured at call time the precondition returns `false` and the offline
+  * mutation is dropped as stale.
+  *
+  * This is a method wrapper around `createSnapshotPrecondition` that
+  * binds the client instance for you — no need to pass `client` explicitly.
+  * @example
+  * ```ts
+  * client.mutation(api.todos.update, { id, text }, {
+  *   precondition: client.snapshotPrecondition(api.todos.list, { userId }),
+  * });
+  * ```
+  */
+  snapshotPrecondition(functionRef: FunctionReference, args: Record<string, unknown>, shardKey?: string): () => boolean;
+  /**
+  * Resolves once the durable read cache has been loaded into memory. When
+  * `hydrateOnStart` is not configured or no query cache adapter is active,
+  * returns an already-resolved promise so callers can always await it
+  * unconditionally.
+  *
+  * Framework adapters (React, Vue, etc.) use this to gate the first
+  * (enabled) render of a live query behind hydration, so the user sees
+  * cached data instead of an undefined flash before the socket round-trip.
+  */
+  whenReady(): Promise<void>;
+  /**
+  * Synchronously reports whether {@link whenReady} has already resolved (the
+  * durable read cache is loaded, or none is configured). Framework adapters
+  * read this to seed the hydration-gate state on the first render without
+  * awaiting, then subscribe via {@link whenReady} for the pending case.
+  */
+  get isReady(): boolean;
+  /**
+  * Synchronously peek at a value the durable read cache loaded for the given
+  * function path + args + shard key. Returns `undefined` when:
+  *
+  * - No query cache adapter is configured.
+  * - Hydration hasn't completed yet (race — await {@link whenReady} first).
+  * - The cached value's identity fingerprint doesn't match the current auth.
+  *
+  * Unlike the internal {@link takeHydratedCache}, this is a READ-ONLY peek:
+  * the cached entry stays in `hydratedQueryCache` so the subscription created
+  * later by {@link subscribe} consumes it normally.
+  */
+  peekHydratedQuery(functionPath: string, args: Record<string, unknown>, shardKey?: string): unknown;
+  /**
+  * Peek at the **current live value** of an active subscription, if one
+  * exists. Returns the subscription's `lastValue` (which includes any
+  * optimistic overlay) or `undefined` if no subscription is active for the
+  * given `(functionPath, args, shardKey)`.
+  *
+  * Unlike {@link peekHydratedQuery} (which reads from the durable read cache
+  * and is independent of active subscriptions), this method reflects the
+  * current in-memory state of an already-opened subscription — useful for
+  * offline mutation preconditions that need to snapshot the value at call time
+  * and compare it at replay time.
+  */
+  peekActiveQueryValue(functionPath: string, args: Record<string, unknown>, shardKey?: string): unknown;
   query<F extends FunctionReference>(function_: F, args: ArgsOf<F>, options?: {
     shardKey?: string;
   }): Promise<ReturnOf<F>>;
@@ -1687,8 +1938,10 @@ declare class LunoraClient {
   * Subscribe to the live scheduled-jobs list over the SchedulerDO's admin
   * WebSocket. `onJobs` fires with the full list on connect and on every
   * change (schedule / cancel / alarm-fire). Reconnects with the client's
-  * configured backoff. Requires `wsToken` to be set to the admin token (the
-  * browser can't send an `Authorization` header on a WS). Returns an
+  * configured backoff. Requires `wsToken` to be set to an admin credential
+  * (the browser can't send an `Authorization` header on a WS) — the master
+  * token, or preferably a {@link WsTokenProvider} minting the ephemeral
+  * sub-token so the master credential stays out of the URL. Returns an
   * unsubscribe function that closes the socket and stops reconnecting.
   */
   subscribeScheduledJobs(onJobs: (jobs: ScheduleRecord[]) => void): Unsubscribe;
@@ -2188,6 +2441,25 @@ declare class LunoraClient {
     maxBuffer?: number;
     shardKey?: string;
   }): StreamIterable<ReturnOf<F>>;
+  /**
+  * Open a typed **HTTP-SSE route stream** (`httpRoute.&lt;verb>(path).stream()`).
+  * Distinct from {@link LunoraClient.stream}, which consumes the WS procedure
+  * stream (`kind: "stream"`): this one opens the route's own URL with `fetch`
+  * and parses the Server-Sent Events framing the route pump writes (`data:`
+  * chunks, a final `event: complete`, an `event: error` on throw).
+  *
+  * The reference comes from the generated `httpStreams.*` registry, so the
+  * yielded chunk type is the route handler's yielded type. Cancelling the
+  * returned iterable (or aborting `options.signal`) aborts the fetch, which
+  * the server handler observes via its `signal`. The client's bearer token
+  * (when set) rides as an `authorization` header.
+  * @experimental Reconnect/POST-body/wire-fidelity design questions are still open, so the shape may change.
+  */
+  httpStream<Ref extends HttpStreamRef>(route: Ref, args?: HttpStreamArgsOf<Ref>, options?: {
+    headers?: Record<string, string>;
+    maxBuffer?: number;
+    signal?: AbortSignal;
+  }): StreamIterable<HttpStreamChunkOf<Ref>>;
   close(): void;
   /**
   * Persist a mutation that can't go out on the wire right now (offline, or
@@ -2333,6 +2605,18 @@ declare class LunoraClient {
   */
   private resendShapeSubscriptions;
   private ensureSocket;
+  /**
+  * Resolve the {@link WsTokenProvider} and open the shard socket with the
+  * minted token. The connection is already in the `connecting` state, so the
+  * async gap is race-guarded: a client `close()`, a `setWsToken` bounce, or a
+  * competing connect that landed first all abandon this attempt. A provider
+  * failure fails the attempt through {@link handleDisconnect}, which arms the
+  * normal reconnect backoff — a broken mint endpoint degrades to retries, not
+  * a silent tokenless socket the admin gate would reject.
+  */
+  private openSocketWithProvidedToken;
+  /** Construct the shard socket and wire its lifecycle handlers. The connection must already be in the `connecting` state. */
+  private openSocket;
   private handleDisconnect;
   /**
   * Begin the keepalive heartbeat on an open connection. Each tick sends a
@@ -2537,4 +2821,4 @@ declare class LunoraClient {
   */
   private settleReplayBatchSlots;
 }
-export { StreamHandle as $, ArgsOf as A, BookmarkStorage as B, CONFLICT_ERROR_CODE as C, DEFAULT_MAX_BUFFER as D, RpcEnvelope as E, FunctionReference as F, GlobalFacetResult as G, RpcResponseBody as H, ScheduleRecord as I, SchedulerPoolStatus as J, SchedulerStatus as K, LunoraClient as L, MutationCallOptions as M, ServerMessage as N, OfflineQueueOptions as O, Preloaded as P, QueryCacheAdapter as Q, ReturnOf as R, SubscriptionError as S, ServerPokeEndMessage as T, User as U, ServerPokePartMessage as V, ServerPokeStartMessage as W, ShardTrafficEntry as X, ShardTrafficResult as Y, StorageListPage as Z, StorageObject as _, Unsubscribe as a, StreamIterable as a0, SubscriptionCallback as a1, SubscriptionRegistry as a2, SubscriptionState as a3, SyncWatermark as a4, WorkflowInstanceAction as a5, WorkflowInstanceDetail as a6, WorkflowInstancePage as a7, WorkflowInstanceStatus as a8, WorkflowInstanceSummary as a9, WorkflowStepDetail as aa, createLocalStore as ab, createStream as ac, getErrorCode as ad, getRetryAfterMs as ae, isConflictError as af, isForbiddenError as ag, isRateLimitedError as ah, isUnauthorizedError as ai, SubscriptionErrorCallback as b, PersistenceAdapter as c, ReconnectOptions as d, BatchSlot as e, CachedQuery as f, ClientMessage as g, ClientShapeSubscribeMessage as h, ClientShapeUnsubscribeMessage as i, ConnectionStatus as j, FunctionArgumentDescriptor as k, FunctionDescriptor as l, GlobalFacetValue as m, GlobalFilterClause as n, GlobalTableInfo as o, GlobalTablePage as p, LunoraClientError as q, LunoraClientOptions as r, LunoraErrorCode as s, MutationSettledEvent as t, OptimisticLocalStore as u, OptimisticUpdate as v, OutboxMutation as w, OutboxSink as x, PersistedMutation as y, RowOp as z };
+export { ServerPokePartMessage as $, ArgsOf as A, BookmarkStorage as B, CONFLICT_ERROR_CODE as C, DEFAULT_MAX_BUFFER as D, OptimisticUpdate as E, FunctionReference as F, GlobalFacetResult as G, HttpStreamRef as H, OutboxMutation as I, OutboxSink as J, PersistedMutation as K, LunoraClient as L, MutationCallOptions as M, RowOp as N, OfflineQueueOptions as O, Preloaded as P, QueryCacheAdapter as Q, ReturnOf as R, SubscriptionError as S, RpcEnvelope as T, User as U, RpcResponseBody as V, ScheduleRecord as W, SchedulerPoolStatus as X, SchedulerStatus as Y, ServerMessage as Z, ServerPokeEndMessage as _, Unsubscribe as a, ServerPokeStartMessage as a0, ShardTrafficEntry as a1, ShardTrafficResult as a2, StorageListPage as a3, StorageObject as a4, StreamHandle as a5, SubscriptionCallback as a6, SubscriptionRegistry as a7, SubscriptionState as a8, SyncWatermark as a9, WorkflowInstanceAction as aa, WorkflowInstanceDetail as ab, WorkflowInstancePage as ac, WorkflowInstanceStatus as ad, WorkflowInstanceSummary as ae, WorkflowStepDetail as af, WsTokenProvider as ag, createClientQuery as ah, createLocalStore as ai, createStream as aj, getErrorCode as ak, getRetryAfterMs as al, isConflictError as am, isForbiddenError as an, isRateLimitedError as ao, isUnauthorizedError as ap, SubscriptionErrorCallback as b, PersistenceAdapter as c, HttpStreamArgsOf as d, HttpStreamChunkOf as e, StreamIterable as f, ReconnectOptions as g, BatchSlot as h, CachedQuery as i, ClientMessage as j, ClientQueryRef as k, ClientShapeSubscribeMessage as l, ClientShapeUnsubscribeMessage as m, ConnectionStatus as n, FunctionArgumentDescriptor as o, FunctionDescriptor as p, GlobalFacetValue as q, GlobalFilterClause as r, GlobalTableInfo as s, GlobalTablePage as t, HttpStreamCallArgs as u, LunoraClientError as v, LunoraClientOptions as w, LunoraErrorCode as x, MutationSettledEvent as y, OptimisticLocalStore as z };