@lunora/client 1.0.0-alpha.10 → 1.0.0-alpha.12

package/dist/packem_shared/SubscriptionRegistry-Cxr70og-.mjs

@@ -0,0 +1 @@
+export { S as SubscriptionRegistry } from './subscription-DoyO04-2.mjs';

package/dist/packem_shared/{createInMemoryPersistence-CW82inU5.mjs → createInMemoryPersistence-DlFjWtOm.mjs}

@@ -101,5 +101,17 @@ const createIndexedDbPersistence = (options = {}) => {
     }
   };
 };
+const resolvePersistenceAdapter = (option, autoProbe = true) => {
+  if (option === false) {
+    return void 0;
+  }
+  if (option) {
+    return option;
+  }
+  if (!autoProbe || typeof indexedDB === "undefined") {
+    return void 0;
+  }
+  return createIndexedDbPersistence();
+};
 
-export { createInMemoryPersistence, createIndexedDbPersistence };
+export { createInMemoryPersistence, createIndexedDbPersistence, resolvePersistenceAdapter };

package/dist/packem_shared/{createInMemoryQueryCache-B1PQ9Twl.mjs → createInMemoryQueryCache-4AkTV38-.mjs}

@@ -134,5 +134,17 @@ const createIndexedDbQueryCache = (options = {}) => {
     }
   };
 };
+const resolveQueryCacheAdapter = (option) => {
+  if (option === false) {
+    return void 0;
+  }
+  if (option) {
+    return option;
+  }
+  if (typeof indexedDB === "undefined") {
+    return void 0;
+  }
+  return createIndexedDbQueryCache();
+};
 
-export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey };
+export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey, resolveQueryCacheAdapter };

package/dist/packem_shared/{createServerClient-BxkNcRlR.mjs → createServerClient-C5GMCGSQ.mjs}

@@ -1,4 +1,4 @@
-import { LunoraClient } from './LunoraClient-CgZ6FhKP.mjs';
+import { LunoraClient } from './LunoraClient-wh6w9Ivn.mjs';
 
 const createServerClient = (options) => {
   const client = new LunoraClient({ fetch: options.fetch, url: options.url });

package/dist/packem_shared/{lunora-client.d-B5vWSgvD.d.mts → lunora-client.d-DTwbfUWF.d.mts}

@@ -271,8 +271,16 @@ interface LunoraClientOptions {
   * standalone client, which keeps using {@link LunoraClientOptions.persistence}.
   */
   outbox?: OutboxSink;
-  /** Durable store for the offline mutation queue; omit to keep it in memory. */
-  persistence?: PersistenceAdapter;
+  /**
+  * Durable store for the offline mutation queue. Tri-state — an explicit
+  * {@link PersistenceAdapter} is used as-is; `false` opts out (the queue stays
+  * in memory, lost on reload); omitted (the default) auto-probes a durable
+  * IndexedDB store when the `indexedDB` global is present (browsers), otherwise
+  * in-memory, so SSR/Node/React-Native keep the in-memory behaviour and only
+  * environments that can persist do. Pass `createAsyncStoragePersistence()` on
+  * React Native.
+  */
+  persistence?: false | PersistenceAdapter;
   /**
   * App/schema version stamped onto every persisted queued write and cached
   * read. Bump it on a breaking change to a function signature or query shape:
@@ -289,11 +297,13 @@ interface LunoraClientOptions {
   */
   persistenceVersion?: string;
   /**
-  * Durable store for the read cache (Pillar 2). When supplied, query results
+  * Durable store for the read cache (Pillar 2). When active, query results
   * are persisted as their subscriptions advance and hydrated on construction
   * so a reload renders cached data before the socket reconnects, then resumes
-  * the live subscription from the persisted cursor. Omit (or pass `false`) to
-  * keep reads in memory only — the default, unchanged behaviour.
+  * the live subscription from the persisted cursor. Tri-state — an explicit
+  * {@link QueryCacheAdapter} is used as-is; `false` opts out (reads stay in
+  * memory only); omitted (the default) auto-probes IndexedDB exactly like
+  * {@link LunoraClientOptions.persistence}.
   */
   queryCache?: QueryCacheAdapter | false;
   reconnect?: ReconnectOptions;
@@ -348,6 +358,7 @@ interface RpcEnvelope {
 type RpcResponseBody = {
   error: {
     code: string;
+    data?: unknown;
     message: string;
   };
 } | {
@@ -1141,6 +1152,19 @@ interface SyncWatermark {
   checkpoint?: number;
   mutationId?: number;
 }
+/** An `Error` carrying the server's machine-readable `code` and (for a `LunoraError`) structured `data`. The client's public error contract for RPC/batch failures. */
+type LunoraClientError = Error & {
+  code?: string;
+  data?: unknown;
+};
+/** One demuxed result slot of a {@link LunoraClient.batch} call (plan 088). */
+type BatchSlot = {
+  error: LunoraClientError;
+  ok: false;
+} | {
+  ok: true;
+  value: unknown;
+};
 /**
 * Lunora browser/edge client. Talks RPC over HTTP and real-time deltas over
 * a single multiplexed WebSocket.
@@ -1488,6 +1512,25 @@ declare class LunoraClient {
     shardKey?: string;
   }): Promise<ReturnOf<F>>;
   /**
+  * Batch several independent calls into ONE round trip (plan 088). Each call is
+  * dispatched server-side exactly as an individual RPC — per-shard
+  * authorization, `(identity, mutationId)` idempotency, and custom-mutator
+  * watermark ordering are all preserved — and the worker splits the batch by
+  * shard so calls to different shards fan out to their own DOs. Results are
+  * demuxed back in input order; a failing call does NOT fail the batch (its
+  * slot carries `{ ok: false, error }`, with `.code`/`.data` reconstructed like
+  * a single call). Args/results ride the value codec (bytes/bigint survive).
+  *
+  * No promise pipelining and no capability passing — a call's args cannot
+  * reference another call's result (see plan 088 §fence; capabilities are
+  * incompatible with DO hibernation).
+  */
+  batch(calls: ReadonlyArray<{
+    args?: Record<string, unknown>;
+    fn: FunctionReference;
+    shardKey?: string;
+  }>): Promise<BatchSlot[]>;
+  /**
   * Invoke a mutation. Errors propagate as rejections.
   *
   * Offline-queue semantics: a mutation is queued (and replayed on reconnect)
@@ -2192,5 +2235,77 @@ declare class LunoraClient {
   */
   private clearQueryCacheForIdentityChange;
   private flushOfflineQueue;
+  /**
+  * Partition already-gated writes into the encodable ones (returned) and reject
+  * the rest terminally. A write whose args can't be wire-encoded (e.g. a RegExp
+  * or class instance in a `v.any()` field) can NEVER replay — the codec failure
+  * is deterministic, not transient. Rejecting here is essential: otherwise
+  * `encodeWire` throws mid-flush, is classified as transient (a codec error has
+  * no `.code`), and re-queues forever — a silent hang where the caller's Promise
+  * never settles and the optimistic write never rolls back. Encoding is cheap;
+  * the flush is the slow reconnect path.
+  */
+  private encodableOrSettleTerminal;
+  /**
+  * Identity guard for one queued write about to replay: a write stamped under
+  * one identity must never replay under another. The live `queuedIdentities`
+  * map is the source of truth for the current session; a hydrated write whose
+  * id isn't in the map falls back to the stamp persisted with the record
+  * (`item.identity`), so a reload can't replay another user's queued writes.
+  * Only legacy records (persisted before stamps were durable —
+  * `item.identity === undefined`) replay under whatever identity is current.
+  *
+  * `Map.get` returns `undefined` for unstamped/hydrated ids and `item.identity`
+  * is `undefined` for legacy records; a persisted `null` (queued while signed
+  * out) is a real value that must not collapse into `undefined` — hence the
+  * explicit `=== undefined` check rather than `??`. Returns `true` when the
+  * write may replay; otherwise settles it `OFFLINE_IDENTITY_CHANGED` and returns
+  * `false`. Either way the live stamp is consumed.
+  */
+  private passesReplayIdentityGate;
+  /** Settle a write that replayed successfully: confirm its optimistic layer against the echoed commit cursor BEFORE resolving, so the gapless drop is in place when the awaiter (and any confirming frame) observes the settle. */
+  private settleReplaySuccess;
+  /** Settle a write the server reached a coded verdict on: replaying would re-trigger the same failure (a poison-message loop), so drop it. */
+  private settleReplayTerminal;
+  /**
+  * Replay already-identity-gated writes one at a time on the single-call `/rpc`
+  * path, preserving FIFO order (parallel `.then()` chains would race the
+  * ordering callers depend on). Each replays under its stable `mutationId` so
+  * the server dedups a write it already committed (exactly-once). A coded error
+  * is a server verdict (drop it); a codeless (transport/transient) failure stops
+  * the flush and re-queues this write and every unreplayed one for the next
+  * reconnect — their callers stay pending, and the identity guard re-applies on
+  * retry via each record's persisted stamp.
+  */
+  private replaySequential;
+  /**
+  * Coalesce already-identity-gated writes for a single shard into ONE
+  * `/_lunora/rpc-batch` round trip (plan 088 follow-on). The worker forwards
+  * them to the shard DO, which replays each through its single-call dispatch, so
+  * per-entry `mutationId` idempotency and in-order application are inherited from
+  * the proven path. Per-slot demux mirrors {@link replaySequential}'s
+  * classification: success confirms the optimistic layer against the echoed
+  * `commitCursor`; a coded application verdict is terminal; a transient shard
+  * failure (`SHARD_UNAVAILABLE`/`SHARD_ERROR`), a missing slot, or a whole-batch
+  * transport failure re-queues for the next reconnect (never dropping a durable
+  * write). A whole-batch coded rejection (bad request / authorization denial the
+  * server reached a verdict on) is terminal for every entry.
+  *
+  * Returns the writes that must be re-queued and `stop` — `true` when the whole
+  * chunk failed at the transport level, so the caller leaves later chunks queued
+  * rather than sending on. The caller re-queues once, in order, so requeuing is
+  * NOT done here.
+  */
+  private replayBatched;
+  /**
+  * Demux a `/_lunora/rpc-batch` reply back onto the queued writes it replayed,
+  * in input order. Each slot's envelope classifies its write the same way
+  * {@link replaySequential} does: a success confirms the optimistic layer
+  * against the echoed `commitCursor`; a coded application verdict is terminal;
+  * a transient shard failure ({@link TRANSIENT_BATCH_ERROR_CODES}) or a slot the
+  * server never returned is returned for the caller to re-queue.
+  * @returns the writes that must be re-queued (transient slots), in input order
+  */
+  private settleReplayBatchSlots;
 }
-export { SubscriptionState as $, ArgsOf as A, BookmarkStorage as B, CachedQuery as C, DEFAULT_MAX_BUFFER as D, SchedulerStatus as E, FunctionReference as F, GlobalFacetResult as G, ServerMessage as H, ServerPokeEndMessage as I, ServerPokePartMessage as J, ServerPokeStartMessage as K, LunoraClient as L, MutationCallOptions as M, ShardTrafficEntry as N, OfflineQueueOptions as O, Preloaded as P, QueryCacheAdapter as Q, ReturnOf as R, SubscriptionError as S, ShardTrafficResult as T, User as U, StorageListPage as V, StorageObject as W, StreamHandle as X, StreamIterable as Y, SubscriptionCallback as Z, SubscriptionRegistry as _, Unsubscribe as a, SyncWatermark as a0, WorkflowInstanceAction as a1, WorkflowInstanceDetail as a2, WorkflowInstancePage as a3, WorkflowInstanceStatus as a4, WorkflowInstanceSummary as a5, WorkflowStepDetail as a6, createLocalStore as a7, createStream as a8, SubscriptionErrorCallback as b, PersistenceAdapter as c, ReconnectOptions as d, ClientMessage as e, ClientShapeSubscribeMessage as f, ClientShapeUnsubscribeMessage as g, ConnectionStatus as h, FunctionArgumentDescriptor as i, FunctionDescriptor as j, GlobalFacetValue as k, GlobalFilterClause as l, GlobalTableInfo as m, GlobalTablePage as n, LunoraClientOptions as o, MutationSettledEvent as p, OptimisticLocalStore as q, OptimisticUpdate as r, OutboxMutation as s, OutboxSink as t, PersistedMutation as u, RowOp as v, RpcEnvelope as w, RpcResponseBody as x, ScheduleRecord as y, SchedulerPoolStatus as z };
+export { SubscriptionCallback as $, ArgsOf as A, BookmarkStorage as B, CachedQuery as C, DEFAULT_MAX_BUFFER as D, ScheduleRecord as E, FunctionReference as F, GlobalFacetResult as G, SchedulerPoolStatus as H, SchedulerStatus as I, ServerMessage as J, ServerPokeEndMessage as K, LunoraClient as L, MutationCallOptions as M, ServerPokePartMessage as N, OfflineQueueOptions as O, Preloaded as P, QueryCacheAdapter as Q, ReturnOf as R, SubscriptionError as S, ServerPokeStartMessage as T, User as U, ShardTrafficEntry as V, ShardTrafficResult as W, StorageListPage as X, StorageObject as Y, StreamHandle as Z, StreamIterable as _, Unsubscribe as a, SubscriptionRegistry as a0, SubscriptionState as a1, SyncWatermark as a2, WorkflowInstanceAction as a3, WorkflowInstanceDetail as a4, WorkflowInstancePage as a5, WorkflowInstanceStatus as a6, WorkflowInstanceSummary as a7, WorkflowStepDetail as a8, createLocalStore as a9, createStream as aa, SubscriptionErrorCallback as b, PersistenceAdapter as c, ReconnectOptions as d, BatchSlot as e, ClientMessage as f, ClientShapeSubscribeMessage as g, ClientShapeUnsubscribeMessage as h, ConnectionStatus as i, FunctionArgumentDescriptor as j, FunctionDescriptor as k, GlobalFacetValue as l, GlobalFilterClause as m, GlobalTableInfo as n, GlobalTablePage as o, LunoraClientError as p, LunoraClientOptions as q, MutationSettledEvent as r, OptimisticLocalStore as s, OptimisticUpdate as t, OutboxMutation as u, OutboxSink as v, PersistedMutation as w, RowOp as x, RpcEnvelope as y, RpcResponseBody as z };

package/dist/packem_shared/{lunora-client.d-B5vWSgvD.d.ts → lunora-client.d-DTwbfUWF.d.ts}

@@ -271,8 +271,16 @@ interface LunoraClientOptions {
   * standalone client, which keeps using {@link LunoraClientOptions.persistence}.
   */
   outbox?: OutboxSink;
-  /** Durable store for the offline mutation queue; omit to keep it in memory. */
-  persistence?: PersistenceAdapter;
+  /**
+  * Durable store for the offline mutation queue. Tri-state — an explicit
+  * {@link PersistenceAdapter} is used as-is; `false` opts out (the queue stays
+  * in memory, lost on reload); omitted (the default) auto-probes a durable
+  * IndexedDB store when the `indexedDB` global is present (browsers), otherwise
+  * in-memory, so SSR/Node/React-Native keep the in-memory behaviour and only
+  * environments that can persist do. Pass `createAsyncStoragePersistence()` on
+  * React Native.
+  */
+  persistence?: false | PersistenceAdapter;
   /**
   * App/schema version stamped onto every persisted queued write and cached
   * read. Bump it on a breaking change to a function signature or query shape:
@@ -289,11 +297,13 @@ interface LunoraClientOptions {
   */
   persistenceVersion?: string;
   /**
-  * Durable store for the read cache (Pillar 2). When supplied, query results
+  * Durable store for the read cache (Pillar 2). When active, query results
   * are persisted as their subscriptions advance and hydrated on construction
   * so a reload renders cached data before the socket reconnects, then resumes
-  * the live subscription from the persisted cursor. Omit (or pass `false`) to
-  * keep reads in memory only — the default, unchanged behaviour.
+  * the live subscription from the persisted cursor. Tri-state — an explicit
+  * {@link QueryCacheAdapter} is used as-is; `false` opts out (reads stay in
+  * memory only); omitted (the default) auto-probes IndexedDB exactly like
+  * {@link LunoraClientOptions.persistence}.
   */
   queryCache?: QueryCacheAdapter | false;
   reconnect?: ReconnectOptions;
@@ -348,6 +358,7 @@ interface RpcEnvelope {
 type RpcResponseBody = {
   error: {
     code: string;
+    data?: unknown;
     message: string;
   };
 } | {
@@ -1141,6 +1152,19 @@ interface SyncWatermark {
   checkpoint?: number;
   mutationId?: number;
 }
+/** An `Error` carrying the server's machine-readable `code` and (for a `LunoraError`) structured `data`. The client's public error contract for RPC/batch failures. */
+type LunoraClientError = Error & {
+  code?: string;
+  data?: unknown;
+};
+/** One demuxed result slot of a {@link LunoraClient.batch} call (plan 088). */
+type BatchSlot = {
+  error: LunoraClientError;
+  ok: false;
+} | {
+  ok: true;
+  value: unknown;
+};
 /**
 * Lunora browser/edge client. Talks RPC over HTTP and real-time deltas over
 * a single multiplexed WebSocket.
@@ -1488,6 +1512,25 @@ declare class LunoraClient {
     shardKey?: string;
   }): Promise<ReturnOf<F>>;
   /**
+  * Batch several independent calls into ONE round trip (plan 088). Each call is
+  * dispatched server-side exactly as an individual RPC — per-shard
+  * authorization, `(identity, mutationId)` idempotency, and custom-mutator
+  * watermark ordering are all preserved — and the worker splits the batch by
+  * shard so calls to different shards fan out to their own DOs. Results are
+  * demuxed back in input order; a failing call does NOT fail the batch (its
+  * slot carries `{ ok: false, error }`, with `.code`/`.data` reconstructed like
+  * a single call). Args/results ride the value codec (bytes/bigint survive).
+  *
+  * No promise pipelining and no capability passing — a call's args cannot
+  * reference another call's result (see plan 088 §fence; capabilities are
+  * incompatible with DO hibernation).
+  */
+  batch(calls: ReadonlyArray<{
+    args?: Record<string, unknown>;
+    fn: FunctionReference;
+    shardKey?: string;
+  }>): Promise<BatchSlot[]>;
+  /**
   * Invoke a mutation. Errors propagate as rejections.
   *
   * Offline-queue semantics: a mutation is queued (and replayed on reconnect)
@@ -2192,5 +2235,77 @@ declare class LunoraClient {
   */
   private clearQueryCacheForIdentityChange;
   private flushOfflineQueue;
+  /**
+  * Partition already-gated writes into the encodable ones (returned) and reject
+  * the rest terminally. A write whose args can't be wire-encoded (e.g. a RegExp
+  * or class instance in a `v.any()` field) can NEVER replay — the codec failure
+  * is deterministic, not transient. Rejecting here is essential: otherwise
+  * `encodeWire` throws mid-flush, is classified as transient (a codec error has
+  * no `.code`), and re-queues forever — a silent hang where the caller's Promise
+  * never settles and the optimistic write never rolls back. Encoding is cheap;
+  * the flush is the slow reconnect path.
+  */
+  private encodableOrSettleTerminal;
+  /**
+  * Identity guard for one queued write about to replay: a write stamped under
+  * one identity must never replay under another. The live `queuedIdentities`
+  * map is the source of truth for the current session; a hydrated write whose
+  * id isn't in the map falls back to the stamp persisted with the record
+  * (`item.identity`), so a reload can't replay another user's queued writes.
+  * Only legacy records (persisted before stamps were durable —
+  * `item.identity === undefined`) replay under whatever identity is current.
+  *
+  * `Map.get` returns `undefined` for unstamped/hydrated ids and `item.identity`
+  * is `undefined` for legacy records; a persisted `null` (queued while signed
+  * out) is a real value that must not collapse into `undefined` — hence the
+  * explicit `=== undefined` check rather than `??`. Returns `true` when the
+  * write may replay; otherwise settles it `OFFLINE_IDENTITY_CHANGED` and returns
+  * `false`. Either way the live stamp is consumed.
+  */
+  private passesReplayIdentityGate;
+  /** Settle a write that replayed successfully: confirm its optimistic layer against the echoed commit cursor BEFORE resolving, so the gapless drop is in place when the awaiter (and any confirming frame) observes the settle. */
+  private settleReplaySuccess;
+  /** Settle a write the server reached a coded verdict on: replaying would re-trigger the same failure (a poison-message loop), so drop it. */
+  private settleReplayTerminal;
+  /**
+  * Replay already-identity-gated writes one at a time on the single-call `/rpc`
+  * path, preserving FIFO order (parallel `.then()` chains would race the
+  * ordering callers depend on). Each replays under its stable `mutationId` so
+  * the server dedups a write it already committed (exactly-once). A coded error
+  * is a server verdict (drop it); a codeless (transport/transient) failure stops
+  * the flush and re-queues this write and every unreplayed one for the next
+  * reconnect — their callers stay pending, and the identity guard re-applies on
+  * retry via each record's persisted stamp.
+  */
+  private replaySequential;
+  /**
+  * Coalesce already-identity-gated writes for a single shard into ONE
+  * `/_lunora/rpc-batch` round trip (plan 088 follow-on). The worker forwards
+  * them to the shard DO, which replays each through its single-call dispatch, so
+  * per-entry `mutationId` idempotency and in-order application are inherited from
+  * the proven path. Per-slot demux mirrors {@link replaySequential}'s
+  * classification: success confirms the optimistic layer against the echoed
+  * `commitCursor`; a coded application verdict is terminal; a transient shard
+  * failure (`SHARD_UNAVAILABLE`/`SHARD_ERROR`), a missing slot, or a whole-batch
+  * transport failure re-queues for the next reconnect (never dropping a durable
+  * write). A whole-batch coded rejection (bad request / authorization denial the
+  * server reached a verdict on) is terminal for every entry.
+  *
+  * Returns the writes that must be re-queued and `stop` — `true` when the whole
+  * chunk failed at the transport level, so the caller leaves later chunks queued
+  * rather than sending on. The caller re-queues once, in order, so requeuing is
+  * NOT done here.
+  */
+  private replayBatched;
+  /**
+  * Demux a `/_lunora/rpc-batch` reply back onto the queued writes it replayed,
+  * in input order. Each slot's envelope classifies its write the same way
+  * {@link replaySequential} does: a success confirms the optimistic layer
+  * against the echoed `commitCursor`; a coded application verdict is terminal;
+  * a transient shard failure ({@link TRANSIENT_BATCH_ERROR_CODES}) or a slot the
+  * server never returned is returned for the caller to re-queue.
+  * @returns the writes that must be re-queued (transient slots), in input order
+  */
+  private settleReplayBatchSlots;
 }
-export { SubscriptionState as $, ArgsOf as A, BookmarkStorage as B, CachedQuery as C, DEFAULT_MAX_BUFFER as D, SchedulerStatus as E, FunctionReference as F, GlobalFacetResult as G, ServerMessage as H, ServerPokeEndMessage as I, ServerPokePartMessage as J, ServerPokeStartMessage as K, LunoraClient as L, MutationCallOptions as M, ShardTrafficEntry as N, OfflineQueueOptions as O, Preloaded as P, QueryCacheAdapter as Q, ReturnOf as R, SubscriptionError as S, ShardTrafficResult as T, User as U, StorageListPage as V, StorageObject as W, StreamHandle as X, StreamIterable as Y, SubscriptionCallback as Z, SubscriptionRegistry as _, Unsubscribe as a, SyncWatermark as a0, WorkflowInstanceAction as a1, WorkflowInstanceDetail as a2, WorkflowInstancePage as a3, WorkflowInstanceStatus as a4, WorkflowInstanceSummary as a5, WorkflowStepDetail as a6, createLocalStore as a7, createStream as a8, SubscriptionErrorCallback as b, PersistenceAdapter as c, ReconnectOptions as d, ClientMessage as e, ClientShapeSubscribeMessage as f, ClientShapeUnsubscribeMessage as g, ConnectionStatus as h, FunctionArgumentDescriptor as i, FunctionDescriptor as j, GlobalFacetValue as k, GlobalFilterClause as l, GlobalTableInfo as m, GlobalTablePage as n, LunoraClientOptions as o, MutationSettledEvent as p, OptimisticLocalStore as q, OptimisticUpdate as r, OutboxMutation as s, OutboxSink as t, PersistedMutation as u, RowOp as v, RpcEnvelope as w, RpcResponseBody as x, ScheduleRecord as y, SchedulerPoolStatus as z };
+export { SubscriptionCallback as $, ArgsOf as A, BookmarkStorage as B, CachedQuery as C, DEFAULT_MAX_BUFFER as D, ScheduleRecord as E, FunctionReference as F, GlobalFacetResult as G, SchedulerPoolStatus as H, SchedulerStatus as I, ServerMessage as J, ServerPokeEndMessage as K, LunoraClient as L, MutationCallOptions as M, ServerPokePartMessage as N, OfflineQueueOptions as O, Preloaded as P, QueryCacheAdapter as Q, ReturnOf as R, SubscriptionError as S, ServerPokeStartMessage as T, User as U, ShardTrafficEntry as V, ShardTrafficResult as W, StorageListPage as X, StorageObject as Y, StreamHandle as Z, StreamIterable as _, Unsubscribe as a, SubscriptionRegistry as a0, SubscriptionState as a1, SyncWatermark as a2, WorkflowInstanceAction as a3, WorkflowInstanceDetail as a4, WorkflowInstancePage as a5, WorkflowInstanceStatus as a6, WorkflowInstanceSummary as a7, WorkflowStepDetail as a8, createLocalStore as a9, createStream as aa, SubscriptionErrorCallback as b, PersistenceAdapter as c, ReconnectOptions as d, BatchSlot as e, ClientMessage as f, ClientShapeSubscribeMessage as g, ClientShapeUnsubscribeMessage as h, ConnectionStatus as i, FunctionArgumentDescriptor as j, FunctionDescriptor as k, GlobalFacetValue as l, GlobalFilterClause as m, GlobalTableInfo as n, GlobalTablePage as o, LunoraClientError as p, LunoraClientOptions as q, MutationSettledEvent as r, OptimisticLocalStore as s, OptimisticUpdate as t, OutboxMutation as u, OutboxSink as v, PersistedMutation as w, RowOp as x, RpcEnvelope as y, RpcResponseBody as z };

package/dist/packem_shared/{preload.d-3XJD-2hM.d.mts → preload.d-BEp0JJeu.d.mts}

@@ -1,4 +1,4 @@
-import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-B5vWSgvD.mjs";
+import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-DTwbfUWF.mjs";
 /**
 * Run a query once on the server (during SSR) and capture its result in a
 * serializable {@link Preloaded} token. Embed the token in the rendered HTML and

package/dist/packem_shared/{preload.d-CKZR675M.d.ts → preload.d-CK2IYf5B.d.ts}

@@ -1,4 +1,4 @@
-import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-B5vWSgvD.js";
+import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-DTwbfUWF.js";
 /**
 * Run a query once on the server (during SSR) and capture its result in a
 * serializable {@link Preloaded} token. Embed the token in the rendered HTML and

package/dist/packem_shared/{subscription-C1Jy7HiF.mjs → subscription-DoyO04-2.mjs}

@@ -8,12 +8,22 @@ const stableStringify = (value) => {
   if (value === void 0) {
     return "null";
   }
+  if (typeof value === "bigint") {
+    throw new TypeError("stableStringify: cannot use a bigint in a cache key (query/subscription/shape args) — pass it as a string");
+  }
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
   }
   if (Array.isArray(value)) {
     return `[${value.map((item) => stableStringify(item)).join(",")}]`;
   }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(
+      `stableStringify: cannot use a ${name} in a cache key (query/subscription/shape args) — only plain objects, arrays, and JSON primitives are supported`
+    );
+  }
   const record = value;
   const keys = Object.keys(record).toSorted(compareKeys);
   const parts = [];

package/dist/query/index.d.mts

@@ -1,5 +1,5 @@
-import { S as SubscriptionError, F as FunctionReference, A as ArgsOf, R as ReturnOf, L as LunoraClient, a as Unsubscribe } from "../packem_shared/lunora-client.d-B5vWSgvD.mjs";
-export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-B5vWSgvD.mjs";
+import { S as SubscriptionError, F as FunctionReference, A as ArgsOf, R as ReturnOf, L as LunoraClient, a as Unsubscribe } from "../packem_shared/lunora-client.d-DTwbfUWF.mjs";
+export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-DTwbfUWF.mjs";
 import '@lunora/runtime';
 /**
 * The sentinel a framework adapter resolves its reactive args to when it wants

package/dist/query/index.d.ts

@@ -1,5 +1,5 @@
-import { S as SubscriptionError, F as FunctionReference, A as ArgsOf, R as ReturnOf, L as LunoraClient, a as Unsubscribe } from "../packem_shared/lunora-client.d-B5vWSgvD.js";
-export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-B5vWSgvD.js";
+import { S as SubscriptionError, F as FunctionReference, A as ArgsOf, R as ReturnOf, L as LunoraClient, a as Unsubscribe } from "../packem_shared/lunora-client.d-DTwbfUWF.js";
+export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-DTwbfUWF.js";
 import '@lunora/runtime';
 /**
 * The sentinel a framework adapter resolves its reactive args to when it wants

package/dist/ssr/index.d.mts

@@ -1,6 +1,6 @@
-import { P as Preloaded, L as LunoraClient } from "../packem_shared/lunora-client.d-B5vWSgvD.mjs";
-export type { A as ArgsOf, F as FunctionReference, R as ReturnOf } from "../packem_shared/lunora-client.d-B5vWSgvD.mjs";
-export { p as preloadQuery, a as preloadedQueryResult } from "../packem_shared/preload.d-3XJD-2hM.mjs";
+import { P as Preloaded, L as LunoraClient } from "../packem_shared/lunora-client.d-DTwbfUWF.mjs";
+export type { A as ArgsOf, F as FunctionReference, R as ReturnOf } from "../packem_shared/lunora-client.d-DTwbfUWF.mjs";
+export { p as preloadQuery, a as preloadedQueryResult } from "../packem_shared/preload.d-BEp0JJeu.mjs";
 import '@lunora/runtime';
 /**
 * Structural shape of a better-auth `getSession` call's resolved value.

package/dist/ssr/index.d.ts

@@ -1,6 +1,6 @@
-import { P as Preloaded, L as LunoraClient } from "../packem_shared/lunora-client.d-B5vWSgvD.js";
-export type { A as ArgsOf, F as FunctionReference, R as ReturnOf } from "../packem_shared/lunora-client.d-B5vWSgvD.js";
-export { p as preloadQuery, a as preloadedQueryResult } from "../packem_shared/preload.d-CKZR675M.js";
+import { P as Preloaded, L as LunoraClient } from "../packem_shared/lunora-client.d-DTwbfUWF.js";
+export type { A as ArgsOf, F as FunctionReference, R as ReturnOf } from "../packem_shared/lunora-client.d-DTwbfUWF.js";
+export { p as preloadQuery, a as preloadedQueryResult } from "../packem_shared/preload.d-CK2IYf5B.js";
 import '@lunora/runtime';
 /**
 * Structural shape of a better-auth `getSession` call's resolved value.

package/dist/ssr/index.mjs

@@ -1,4 +1,4 @@
 export { getServerSession } from '../packem_shared/getServerSession-8jXewqxd.mjs';
 export { deserializePreloaded, serializePreloaded } from '../packem_shared/deserializePreloaded-C0eJTY_W.mjs';
-export { createServerClient } from '../packem_shared/createServerClient-BxkNcRlR.mjs';
+export { createServerClient } from '../packem_shared/createServerClient-C5GMCGSQ.mjs';
 export { preloadQuery, preloadedQueryResult } from '../packem_shared/preloadQuery-lobFkD2Z.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/client",
-  "version": "1.0.0-alpha.10",
+  "version": "1.0.0-alpha.12",
   "description": "Lunora browser SDK: WebSocket transport, optimistic updates, and an offline mutation queue",
   "keywords": [
     "cloudflare",

package/dist/packem_shared/SubscriptionRegistry-Dn-7k7eo.mjs

@@ -1 +0,0 @@
-export { S as SubscriptionRegistry } from './subscription-C1Jy7HiF.mjs';