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

package/dist/packem_shared/{offline-queue-CF4_Co5k.mjs → offline-queue-N-1JvYb4.mjs}

@@ -79,6 +79,16 @@ class OfflineQueue {
    * 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.
    */
   async hydrate() {
     if (!this.persistence) {
@@ -92,8 +102,9 @@ class OfflineQueue {
       throw error;
     }
     const shardKeys = /* @__PURE__ */ new Set();
+    const restored = [];
     for (const mutation of persisted) {
-      if (this.items.some((item) => item.id === mutation.id)) {
+      if (this.items.some((item) => item.id === mutation.id) || restored.some((item) => item.id === mutation.id)) {
         continue;
       }
       if (isStaleVersion(this.version, mutation.version)) {
@@ -102,7 +113,7 @@ class OfflineQueue {
         });
         continue;
       }
-      this.items.push({
+      restored.push({
         args: mutation.args,
         functionPath: mutation.functionPath,
         id: mutation.id,
@@ -113,6 +124,7 @@ class OfflineQueue {
       });
       shardKeys.add(mutation.shardKey);
     }
+    this.items.unshift(...restored);
     this.notifySize();
     return [...shardKeys];
   }

package/dist/packem_shared/preload.d-B6-lqUf2.d.ts

@@ -0,0 +1,20 @@
+import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-C4ud8bej.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
+ * pass it to `usePreloadedQuery` on the client: the first client render shows
+ * the server value with no loading flash, then a live subscription takes over.
+ *
+ * The query is executed through the supplied {@link LunoraClient} over the same
+ * HTTP RPC path the browser uses, so the SSR client only needs a `fetch`
+ * implementation that can reach the worker — no in-process Durable Object access.
+ */
+declare const preloadQuery: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => Promise<Preloaded<ReturnOf<F>>>;
+/**
+ * Read the captured value out of a {@link Preloaded} token without subscribing.
+ * Useful on the server (or in tests) when you only need the data, not a live feed.
+ */
+declare const preloadedQueryResult: <T>(preloaded: Preloaded<T>) => T;
+export { preloadedQueryResult as a, preloadQuery as p };

package/dist/packem_shared/preload.d-Dvk8zg6m.d.mts

@@ -0,0 +1,20 @@
+import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-C4ud8bej.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
+ * pass it to `usePreloadedQuery` on the client: the first client render shows
+ * the server value with no loading flash, then a live subscription takes over.
+ *
+ * The query is executed through the supplied {@link LunoraClient} over the same
+ * HTTP RPC path the browser uses, so the SSR client only needs a `fetch`
+ * implementation that can reach the worker — no in-process Durable Object access.
+ */
+declare const preloadQuery: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => Promise<Preloaded<ReturnOf<F>>>;
+/**
+ * Read the captured value out of a {@link Preloaded} token without subscribing.
+ * Useful on the server (or in tests) when you only need the data, not a live feed.
+ */
+declare const preloadedQueryResult: <T>(preloaded: Preloaded<T>) => T;
+export { preloadedQueryResult as a, preloadQuery as p };

package/dist/pagination/index.d.mts

@@ -1,13 +1,13 @@
 /**
-* `@lunora/client/pagination` — the framework-agnostic pagination state machine
-* shared by every Lunora UI adapter (React, Vue, Svelte, Solid).
-*
-* Owns cursor tracking, page-size rebalancing (split/join), `initialPages`,
-* `rebalance`, and the shared types (`Page`, `PaginationResult`,
-* `PaginationStatus`, `PaginatedCoreResult`). Nothing here imports a UI
-* framework — each adapter wires the pure functions into its own reactive
-* primitives.
-*/
+ * `@lunora/client/pagination` — the framework-agnostic pagination state machine
+ * shared by every Lunora UI adapter (React, Vue, Svelte, Solid).
+ *
+ * Owns cursor tracking, page-size rebalancing (split/join), `initialPages`,
+ * `rebalance`, and the shared types (`Page`, `PaginationResult`,
+ * `PaginationStatus`, `PaginatedCoreResult`). Nothing here imports a UI
+ * framework — each adapter wires the pure functions into its own reactive
+ * primitives.
+ */
 /** Grow factor: a bounded page is split when it exceeds this multiple of its target size. */
 declare const SPLIT_FACTOR = 2;
 /** Shrink factor: a bounded page with a neighbour is joined when it falls below this multiple of its target size. */
@@ -24,20 +24,20 @@ interface PaginationResult<T = unknown> {
   isDone: boolean;
   page: T[];
   /**
-  * Reactive-pagination only: the midpoint cursor of a bounded
-  * `(cursor, endCursor]` page, used to split an over-grown page into two
-  * adjacent ranges. Absent on legacy (open-ended) pages.
-  */
+   * Reactive-pagination only: the midpoint cursor of a bounded
+   * `(cursor, endCursor]` page, used to split an over-grown page into two
+   * adjacent ranges. Absent on legacy (open-ended) pages.
+   */
   splitCursor?: null | string;
 }
 /**
-* Lifecycle of a `usePaginatedQuery` feed.
-*
-* - `LoadingFirstPage` — the first page is in flight; `results` is empty.
-* - `CanLoadMore` — the loaded tail has a cursor; calling `loadMore` fetches the next page.
-* - `LoadingMore` — a `loadMore` page is in flight; earlier results stay visible.
-* - `Exhausted` — every page has loaded and the server reported `isDone`.
-*/
+ * Lifecycle of a `usePaginatedQuery` feed.
+ *
+ * - `LoadingFirstPage` — the first page is in flight; `results` is empty.
+ * - `CanLoadMore` — the loaded tail has a cursor; calling `loadMore` fetches the next page.
+ * - `LoadingMore` — a `loadMore` page is in flight; earlier results stay visible.
+ * - `Exhausted` — every page has loaded and the server reported `isDone`.
+ */
 type PaginationStatus = "CanLoadMore" | "Exhausted" | "LoadingFirstPage" | "LoadingMore";
 interface PaginatedCoreResult<T> {
   /** Request another page off the open-ended tail. A no-op unless `status === "CanLoadMore"`. */
@@ -49,34 +49,34 @@ interface PaginatedCoreResult<T> {
 /** First-page seed: a single open-ended range starting at the feed head. */
 declare const initialPages: (numberItems: number) => Page[];
 /**
-* Run the SPLIT/JOIN maintenance pass over the current page list given freshly
-* resolved results. Returns a new page list when a boundary changed, or
-* `undefined` when the layout is already balanced (so the caller can skip a
-* setState).
-*
-* Only ONE structural edit is applied per pass (the first split or join found),
-* letting the subsequent re-render's resolved results drive the next pass — this
-* keeps each transition observable and avoids reasoning about several
-* simultaneous boundary moves.
-*/
+ * Run the SPLIT/JOIN maintenance pass over the current page list given freshly
+ * resolved results. Returns a new page list when a boundary changed, or
+ * `undefined` when the layout is already balanced (so the caller can skip a
+ * setState).
+ *
+ * Only ONE structural edit is applied per pass (the first split or join found),
+ * letting the subsequent re-render's resolved results drive the next pass — this
+ * keeps each transition observable and avoids reasoning about several
+ * simultaneous boundary moves.
+ */
 declare const rebalance: (pages: Page[], results: (PaginationResult | undefined)[]) => Page[] | undefined;
 /**
-* Derive the feed `status` and the next-page cursor from the current page list
-* and resolved page results. Framework adapters call this each render/effect to
-* compute what to expose to callers.
-*/
+ * Derive the feed `status` and the next-page cursor from the current page list
+ * and resolved page results. Framework adapters call this each render/effect to
+ * compute what to expose to callers.
+ */
 declare const derivePaginationStatus: <T>(skipped: boolean, pageResults: (PaginationResult<T> | undefined)[]) => {
   nextCursor: null | string | undefined;
   status: PaginationStatus;
 };
 /**
-* Apply a `loadMore` to the current page list. Pins the open-ended tail at
-* `cursor` (making it a fixed bounded range) and appends a fresh open-ended
-* page starting at `cursor`. The shared boundary keeps the feed gap- and
-* dup-free.
-*
-* Returns the new page list, or `undefined` when the given `cursor` is not
-* valid (null or undefined — caller should no-op).
-*/
+ * Apply a `loadMore` to the current page list. Pins the open-ended tail at
+ * `cursor` (making it a fixed bounded range) and appends a fresh open-ended
+ * page starting at `cursor`. The shared boundary keeps the feed gap- and
+ * dup-free.
+ *
+ * Returns the new page list, or `undefined` when the given `cursor` is not
+ * valid (null or undefined — caller should no-op).
+ */
 declare const applyLoadMore: (pages: Page[], cursor: null | string | undefined, numberItems: number) => Page[] | undefined;
 export { JOIN_FACTOR, type Page, type PaginatedCoreResult, type PaginationResult, type PaginationStatus, SPLIT_FACTOR, applyLoadMore, derivePaginationStatus, initialPages, rebalance };

package/dist/pagination/index.d.ts

@@ -1,13 +1,13 @@
 /**
-* `@lunora/client/pagination` — the framework-agnostic pagination state machine
-* shared by every Lunora UI adapter (React, Vue, Svelte, Solid).
-*
-* Owns cursor tracking, page-size rebalancing (split/join), `initialPages`,
-* `rebalance`, and the shared types (`Page`, `PaginationResult`,
-* `PaginationStatus`, `PaginatedCoreResult`). Nothing here imports a UI
-* framework — each adapter wires the pure functions into its own reactive
-* primitives.
-*/
+ * `@lunora/client/pagination` — the framework-agnostic pagination state machine
+ * shared by every Lunora UI adapter (React, Vue, Svelte, Solid).
+ *
+ * Owns cursor tracking, page-size rebalancing (split/join), `initialPages`,
+ * `rebalance`, and the shared types (`Page`, `PaginationResult`,
+ * `PaginationStatus`, `PaginatedCoreResult`). Nothing here imports a UI
+ * framework — each adapter wires the pure functions into its own reactive
+ * primitives.
+ */
 /** Grow factor: a bounded page is split when it exceeds this multiple of its target size. */
 declare const SPLIT_FACTOR = 2;
 /** Shrink factor: a bounded page with a neighbour is joined when it falls below this multiple of its target size. */
@@ -24,20 +24,20 @@ interface PaginationResult<T = unknown> {
   isDone: boolean;
   page: T[];
   /**
-  * Reactive-pagination only: the midpoint cursor of a bounded
-  * `(cursor, endCursor]` page, used to split an over-grown page into two
-  * adjacent ranges. Absent on legacy (open-ended) pages.
-  */
+   * Reactive-pagination only: the midpoint cursor of a bounded
+   * `(cursor, endCursor]` page, used to split an over-grown page into two
+   * adjacent ranges. Absent on legacy (open-ended) pages.
+   */
   splitCursor?: null | string;
 }
 /**
-* Lifecycle of a `usePaginatedQuery` feed.
-*
-* - `LoadingFirstPage` — the first page is in flight; `results` is empty.
-* - `CanLoadMore` — the loaded tail has a cursor; calling `loadMore` fetches the next page.
-* - `LoadingMore` — a `loadMore` page is in flight; earlier results stay visible.
-* - `Exhausted` — every page has loaded and the server reported `isDone`.
-*/
+ * Lifecycle of a `usePaginatedQuery` feed.
+ *
+ * - `LoadingFirstPage` — the first page is in flight; `results` is empty.
+ * - `CanLoadMore` — the loaded tail has a cursor; calling `loadMore` fetches the next page.
+ * - `LoadingMore` — a `loadMore` page is in flight; earlier results stay visible.
+ * - `Exhausted` — every page has loaded and the server reported `isDone`.
+ */
 type PaginationStatus = "CanLoadMore" | "Exhausted" | "LoadingFirstPage" | "LoadingMore";
 interface PaginatedCoreResult<T> {
   /** Request another page off the open-ended tail. A no-op unless `status === "CanLoadMore"`. */
@@ -49,34 +49,34 @@ interface PaginatedCoreResult<T> {
 /** First-page seed: a single open-ended range starting at the feed head. */
 declare const initialPages: (numberItems: number) => Page[];
 /**
-* Run the SPLIT/JOIN maintenance pass over the current page list given freshly
-* resolved results. Returns a new page list when a boundary changed, or
-* `undefined` when the layout is already balanced (so the caller can skip a
-* setState).
-*
-* Only ONE structural edit is applied per pass (the first split or join found),
-* letting the subsequent re-render's resolved results drive the next pass — this
-* keeps each transition observable and avoids reasoning about several
-* simultaneous boundary moves.
-*/
+ * Run the SPLIT/JOIN maintenance pass over the current page list given freshly
+ * resolved results. Returns a new page list when a boundary changed, or
+ * `undefined` when the layout is already balanced (so the caller can skip a
+ * setState).
+ *
+ * Only ONE structural edit is applied per pass (the first split or join found),
+ * letting the subsequent re-render's resolved results drive the next pass — this
+ * keeps each transition observable and avoids reasoning about several
+ * simultaneous boundary moves.
+ */
 declare const rebalance: (pages: Page[], results: (PaginationResult | undefined)[]) => Page[] | undefined;
 /**
-* Derive the feed `status` and the next-page cursor from the current page list
-* and resolved page results. Framework adapters call this each render/effect to
-* compute what to expose to callers.
-*/
+ * Derive the feed `status` and the next-page cursor from the current page list
+ * and resolved page results. Framework adapters call this each render/effect to
+ * compute what to expose to callers.
+ */
 declare const derivePaginationStatus: <T>(skipped: boolean, pageResults: (PaginationResult<T> | undefined)[]) => {
   nextCursor: null | string | undefined;
   status: PaginationStatus;
 };
 /**
-* Apply a `loadMore` to the current page list. Pins the open-ended tail at
-* `cursor` (making it a fixed bounded range) and appends a fresh open-ended
-* page starting at `cursor`. The shared boundary keeps the feed gap- and
-* dup-free.
-*
-* Returns the new page list, or `undefined` when the given `cursor` is not
-* valid (null or undefined — caller should no-op).
-*/
+ * Apply a `loadMore` to the current page list. Pins the open-ended tail at
+ * `cursor` (making it a fixed bounded range) and appends a fresh open-ended
+ * page starting at `cursor`. The shared boundary keeps the feed gap- and
+ * dup-free.
+ *
+ * Returns the new page list, or `undefined` when the given `cursor` is not
+ * valid (null or undefined — caller should no-op).
+ */
 declare const applyLoadMore: (pages: Page[], cursor: null | string | undefined, numberItems: number) => Page[] | undefined;
 export { JOIN_FACTOR, type Page, type PaginatedCoreResult, type PaginationResult, type PaginationStatus, SPLIT_FACTOR, applyLoadMore, derivePaginationStatus, initialPages, rebalance };

package/dist/query/index.d.mts

@@ -1,26 +1,26 @@
-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-JvtVpf8A.mjs";
-export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-JvtVpf8A.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-C4ud8bej.mjs";
+export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-C4ud8bej.mjs";
 import '@lunora/runtime';
 /**
-* The sentinel a framework adapter resolves its reactive args to when it wants
-* to short-circuit a query — no network call, no socket.
-*/
+ * The sentinel a framework adapter resolves its reactive args to when it wants
+ * to short-circuit a query — no network call, no socket.
+ */
 declare const SKIP: "skip";
 /** Args after a framework has resolved its reactivity primitive, or the skip sentinel. */
 type ResolvedArgs<F extends FunctionReference> = ArgsOf<F> | typeof SKIP;
 /**
-* The framework-neutral sinks a {@link createQuerySubscription} call drives. A
-* framework adapter supplies these, wiring each into its own reactivity
-* primitive (a TanStack cache write, a Vue `ref`, a Svelte store `set`, a Solid
-* signal setter).
-*
-* `onData` fires when a fresh server value lands (the initial frame or a delta).
-* `onError` fires when the subscription attach threw, or the server pushed a
-* subscription-scoped error — it is optional, and when omitted an attach throw
-* propagates to the caller (preserving the "no error channel" behaviour of
-* adapters like Solid/Vue that never had one) rather than being swallowed.
-* `onReset` fires when the resolved args are `"skip"`: clear any prior value.
-*/
+ * The framework-neutral sinks a {@link createQuerySubscription} call drives. A
+ * framework adapter supplies these, wiring each into its own reactivity
+ * primitive (a TanStack cache write, a Vue `ref`, a Svelte store `set`, a Solid
+ * signal setter).
+ *
+ * `onData` fires when a fresh server value lands (the initial frame or a delta).
+ * `onError` fires when the subscription attach threw, or the server pushed a
+ * subscription-scoped error — it is optional, and when omitted an attach throw
+ * propagates to the caller (preserving the "no error channel" behaviour of
+ * adapters like Solid/Vue that never had one) rather than being swallowed.
+ * `onReset` fires when the resolved args are `"skip"`: clear any prior value.
+ */
 interface QuerySubscriptionSinks<T> {
   onData: (value: T) => void;
   onError?: (error: SubscriptionError) => void;
@@ -33,30 +33,30 @@ interface QuerySubscriptionOptions {
 /** Normalise an unknown thrown value into the client's {@link SubscriptionError} shape. */
 declare const toSubscriptionError: (error: unknown) => SubscriptionError;
 /**
-* The subscribe → snapshot → error/reset → cleanup state machine shared by
-* every Lunora framework adapter's live-query hook.
-*
-* Given a `client`, a function reference, the already-resolved `args` (a
-* framework reads its own reactive source first, then hands the plain value in),
-* and a set of {@link QuerySubscriptionSinks}, this opens one `client.subscribe`
-* registration and returns the {@link Unsubscribe} to tear it down. Each
-* framework owns *when* to call this (a React effect, a Vue `watch`, a Svelte
-* store start callback, a Solid `createEffect(on(...))`) and *where* to stash
-* the value — this owns the lifecycle in between, so the skip-handling, the
-* value/error fan-out, the attach-throw normalisation, and the
-* cancellation-guarded teardown live in exactly one place.
-*
-* Behaviour. When `args === "skip"` it calls `sinks.onReset?.()` and returns a
-* no-op teardown; no `client.subscribe` is issued. Otherwise it opens
-* `client.subscribe(fn, args, …, { shardKey, onError })`: server pushes route to
-* `sinks.onData`, and the client's own `onError` channel (a server-rejected
-* subscription) routes to `sinks.onError` when present. The attach is wrapped —
-* if `client.subscribe` itself throws, the error is normalised to a
-* {@link SubscriptionError} and delivered to `sinks.onError` when present; with
-* no `onError` sink the throw is rethrown so adapters without an error channel
-* behave exactly as before. The returned teardown is idempotent and
-* cancellation-guarded: once it runs, no further `onData`/`onError` from an
-* in-flight push reaches the sinks.
-*/
+ * The subscribe → snapshot → error/reset → cleanup state machine shared by
+ * every Lunora framework adapter's live-query hook.
+ *
+ * Given a `client`, a function reference, the already-resolved `args` (a
+ * framework reads its own reactive source first, then hands the plain value in),
+ * and a set of {@link QuerySubscriptionSinks}, this opens one `client.subscribe`
+ * registration and returns the {@link Unsubscribe} to tear it down. Each
+ * framework owns *when* to call this (a React effect, a Vue `watch`, a Svelte
+ * store start callback, a Solid `createEffect(on(...))`) and *where* to stash
+ * the value — this owns the lifecycle in between, so the skip-handling, the
+ * value/error fan-out, the attach-throw normalisation, and the
+ * cancellation-guarded teardown live in exactly one place.
+ *
+ * Behaviour. When `args === "skip"` it calls `sinks.onReset?.()` and returns a
+ * no-op teardown; no `client.subscribe` is issued. Otherwise it opens
+ * `client.subscribe(fn, args, …, { shardKey, onError })`: server pushes route to
+ * `sinks.onData`, and the client's own `onError` channel (a server-rejected
+ * subscription) routes to `sinks.onError` when present. The attach is wrapped —
+ * if `client.subscribe` itself throws, the error is normalised to a
+ * {@link SubscriptionError} and delivered to `sinks.onError` when present; with
+ * no `onError` sink the throw is rethrown so adapters without an error channel
+ * behave exactly as before. The returned teardown is idempotent and
+ * cancellation-guarded: once it runs, no further `onData`/`onError` from an
+ * in-flight push reaches the sinks.
+ */
 declare const createQuerySubscription: <F extends FunctionReference, T = ReturnOf<F>>(client: LunoraClient, function_: F, args: ResolvedArgs<F>, sinks: QuerySubscriptionSinks<T>, options?: QuerySubscriptionOptions) => Unsubscribe;
 export { type ArgsOf, type FunctionReference, type QuerySubscriptionOptions, type QuerySubscriptionSinks, type ResolvedArgs, type ReturnOf, SKIP, type SubscriptionError, type Unsubscribe, createQuerySubscription, toSubscriptionError };

package/dist/query/index.d.ts

@@ -1,26 +1,26 @@
-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-JvtVpf8A.js";
-export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-JvtVpf8A.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-C4ud8bej.js";
+export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-C4ud8bej.js";
 import '@lunora/runtime';
 /**
-* The sentinel a framework adapter resolves its reactive args to when it wants
-* to short-circuit a query — no network call, no socket.
-*/
+ * The sentinel a framework adapter resolves its reactive args to when it wants
+ * to short-circuit a query — no network call, no socket.
+ */
 declare const SKIP: "skip";
 /** Args after a framework has resolved its reactivity primitive, or the skip sentinel. */
 type ResolvedArgs<F extends FunctionReference> = ArgsOf<F> | typeof SKIP;
 /**
-* The framework-neutral sinks a {@link createQuerySubscription} call drives. A
-* framework adapter supplies these, wiring each into its own reactivity
-* primitive (a TanStack cache write, a Vue `ref`, a Svelte store `set`, a Solid
-* signal setter).
-*
-* `onData` fires when a fresh server value lands (the initial frame or a delta).
-* `onError` fires when the subscription attach threw, or the server pushed a
-* subscription-scoped error — it is optional, and when omitted an attach throw
-* propagates to the caller (preserving the "no error channel" behaviour of
-* adapters like Solid/Vue that never had one) rather than being swallowed.
-* `onReset` fires when the resolved args are `"skip"`: clear any prior value.
-*/
+ * The framework-neutral sinks a {@link createQuerySubscription} call drives. A
+ * framework adapter supplies these, wiring each into its own reactivity
+ * primitive (a TanStack cache write, a Vue `ref`, a Svelte store `set`, a Solid
+ * signal setter).
+ *
+ * `onData` fires when a fresh server value lands (the initial frame or a delta).
+ * `onError` fires when the subscription attach threw, or the server pushed a
+ * subscription-scoped error — it is optional, and when omitted an attach throw
+ * propagates to the caller (preserving the "no error channel" behaviour of
+ * adapters like Solid/Vue that never had one) rather than being swallowed.
+ * `onReset` fires when the resolved args are `"skip"`: clear any prior value.
+ */
 interface QuerySubscriptionSinks<T> {
   onData: (value: T) => void;
   onError?: (error: SubscriptionError) => void;
@@ -33,30 +33,30 @@ interface QuerySubscriptionOptions {
 /** Normalise an unknown thrown value into the client's {@link SubscriptionError} shape. */
 declare const toSubscriptionError: (error: unknown) => SubscriptionError;
 /**
-* The subscribe → snapshot → error/reset → cleanup state machine shared by
-* every Lunora framework adapter's live-query hook.
-*
-* Given a `client`, a function reference, the already-resolved `args` (a
-* framework reads its own reactive source first, then hands the plain value in),
-* and a set of {@link QuerySubscriptionSinks}, this opens one `client.subscribe`
-* registration and returns the {@link Unsubscribe} to tear it down. Each
-* framework owns *when* to call this (a React effect, a Vue `watch`, a Svelte
-* store start callback, a Solid `createEffect(on(...))`) and *where* to stash
-* the value — this owns the lifecycle in between, so the skip-handling, the
-* value/error fan-out, the attach-throw normalisation, and the
-* cancellation-guarded teardown live in exactly one place.
-*
-* Behaviour. When `args === "skip"` it calls `sinks.onReset?.()` and returns a
-* no-op teardown; no `client.subscribe` is issued. Otherwise it opens
-* `client.subscribe(fn, args, …, { shardKey, onError })`: server pushes route to
-* `sinks.onData`, and the client's own `onError` channel (a server-rejected
-* subscription) routes to `sinks.onError` when present. The attach is wrapped —
-* if `client.subscribe` itself throws, the error is normalised to a
-* {@link SubscriptionError} and delivered to `sinks.onError` when present; with
-* no `onError` sink the throw is rethrown so adapters without an error channel
-* behave exactly as before. The returned teardown is idempotent and
-* cancellation-guarded: once it runs, no further `onData`/`onError` from an
-* in-flight push reaches the sinks.
-*/
+ * The subscribe → snapshot → error/reset → cleanup state machine shared by
+ * every Lunora framework adapter's live-query hook.
+ *
+ * Given a `client`, a function reference, the already-resolved `args` (a
+ * framework reads its own reactive source first, then hands the plain value in),
+ * and a set of {@link QuerySubscriptionSinks}, this opens one `client.subscribe`
+ * registration and returns the {@link Unsubscribe} to tear it down. Each
+ * framework owns *when* to call this (a React effect, a Vue `watch`, a Svelte
+ * store start callback, a Solid `createEffect(on(...))`) and *where* to stash
+ * the value — this owns the lifecycle in between, so the skip-handling, the
+ * value/error fan-out, the attach-throw normalisation, and the
+ * cancellation-guarded teardown live in exactly one place.
+ *
+ * Behaviour. When `args === "skip"` it calls `sinks.onReset?.()` and returns a
+ * no-op teardown; no `client.subscribe` is issued. Otherwise it opens
+ * `client.subscribe(fn, args, …, { shardKey, onError })`: server pushes route to
+ * `sinks.onData`, and the client's own `onError` channel (a server-rejected
+ * subscription) routes to `sinks.onError` when present. The attach is wrapped —
+ * if `client.subscribe` itself throws, the error is normalised to a
+ * {@link SubscriptionError} and delivered to `sinks.onError` when present; with
+ * no `onError` sink the throw is rethrown so adapters without an error channel
+ * behave exactly as before. The returned teardown is idempotent and
+ * cancellation-guarded: once it runs, no further `onData`/`onError` from an
+ * in-flight push reaches the sinks.
+ */
 declare const createQuerySubscription: <F extends FunctionReference, T = ReturnOf<F>>(client: LunoraClient, function_: F, args: ResolvedArgs<F>, sinks: QuerySubscriptionSinks<T>, options?: QuerySubscriptionOptions) => Unsubscribe;
 export { type ArgsOf, type FunctionReference, type QuerySubscriptionOptions, type QuerySubscriptionSinks, type ResolvedArgs, type ReturnOf, SKIP, type SubscriptionError, type Unsubscribe, createQuerySubscription, toSubscriptionError };