@lunora/client 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/query/index.d.ts

@@ -1,26 +1,39 @@
-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-DLbxPGH9.js";
-export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-DLbxPGH9.js";
+import { S as SubscriptionError, L as LunoraClient, a as Unsubscribe } from "../packem_shared/lunora-client.d-BkDgDzTg.js";
+export type {
+/**
+ * `@lunora/client/query` — the framework-neutral live-query state machine shared
+ * by every Lunora UI adapter (React, Vue, Svelte, Solid). It owns the seam
+ * between a `LunoraClient` subscription and a framework's reactivity primitive:
+ * the subscribe → snapshot → error/reset → cleanup lifecycle, with the
+ * skip-handling, value/error fan-out, attach-throw normalisation, and
+ * cancellation-guarded teardown all in one place. Nothing here imports a UI
+ * framework — each adapter supplies thin sinks that write into its own ref /
+ * store / signal / cache.
+ */
+b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-BkDgDzTg.js";
+import { F as FunctionReference, A as ArgsOf, R as ReturnOf } from "../packem_shared/function-reference.d-Br_hsKje.js";
+import '@lunora/errors';
 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 +46,85 @@ 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 };
+export {
+/**
+ * `@lunora/client/query` — the framework-neutral live-query state machine shared
+ * by every Lunora UI adapter (React, Vue, Svelte, Solid). It owns the seam
+ * between a `LunoraClient` subscription and a framework's reactivity primitive:
+ * the subscribe → snapshot → error/reset → cleanup lifecycle, with the
+ * skip-handling, value/error fan-out, attach-throw normalisation, and
+ * cancellation-guarded teardown all in one place. Nothing here imports a UI
+ * framework — each adapter supplies thin sinks that write into its own ref /
+ * store / signal / cache.
+ */
+type ArgsOf,
+/**
+ * `@lunora/client/query` — the framework-neutral live-query state machine shared
+ * by every Lunora UI adapter (React, Vue, Svelte, Solid). It owns the seam
+ * between a `LunoraClient` subscription and a framework's reactivity primitive:
+ * the subscribe → snapshot → error/reset → cleanup lifecycle, with the
+ * skip-handling, value/error fan-out, attach-throw normalisation, and
+ * cancellation-guarded teardown all in one place. Nothing here imports a UI
+ * framework — each adapter supplies thin sinks that write into its own ref /
+ * store / signal / cache.
+ */
+type FunctionReference, type QuerySubscriptionOptions, type QuerySubscriptionSinks, type ResolvedArgs,
+/**
+ * `@lunora/client/query` — the framework-neutral live-query state machine shared
+ * by every Lunora UI adapter (React, Vue, Svelte, Solid). It owns the seam
+ * between a `LunoraClient` subscription and a framework's reactivity primitive:
+ * the subscribe → snapshot → error/reset → cleanup lifecycle, with the
+ * skip-handling, value/error fan-out, attach-throw normalisation, and
+ * cancellation-guarded teardown all in one place. Nothing here imports a UI
+ * framework — each adapter supplies thin sinks that write into its own ref /
+ * store / signal / cache.
+ */
+type ReturnOf, SKIP,
+/**
+ * `@lunora/client/query` — the framework-neutral live-query state machine shared
+ * by every Lunora UI adapter (React, Vue, Svelte, Solid). It owns the seam
+ * between a `LunoraClient` subscription and a framework's reactivity primitive:
+ * the subscribe → snapshot → error/reset → cleanup lifecycle, with the
+ * skip-handling, value/error fan-out, attach-throw normalisation, and
+ * cancellation-guarded teardown all in one place. Nothing here imports a UI
+ * framework — each adapter supplies thin sinks that write into its own ref /
+ * store / signal / cache.
+ */
+type SubscriptionError,
+/**
+ * `@lunora/client/query` — the framework-neutral live-query state machine shared
+ * by every Lunora UI adapter (React, Vue, Svelte, Solid). It owns the seam
+ * between a `LunoraClient` subscription and a framework's reactivity primitive:
+ * the subscribe → snapshot → error/reset → cleanup lifecycle, with the
+ * skip-handling, value/error fan-out, attach-throw normalisation, and
+ * cancellation-guarded teardown all in one place. Nothing here imports a UI
+ * framework — each adapter supplies thin sinks that write into its own ref /
+ * store / signal / cache.
+ */
+type Unsubscribe, createQuerySubscription, toSubscriptionError };

package/dist/query/index.mjs

@@ -1 +1 @@
-export { SKIP, createQuerySubscription, toSubscriptionError } from '../packem_shared/SKIP-vItZChkw.mjs';
+import{SKIP as t,createQuerySubscription as e,toSubscriptionError as i}from"../packem_shared/SKIP-d7LeP-sY.mjs";export{t as SKIP,e as createQuerySubscription,i as toSubscriptionError};

package/dist/service.d.mts

@@ -0,0 +1,49 @@
+import { F as FunctionReference, A as ArgsOf, R as ReturnOf } from "./packem_shared/function-reference.d-Br_hsKje.mjs";
+/**
+ * The wire endpoint every Lunora Worker serves. Matches `createWorker`'s RPC
+ * route; the envelope shape below is that route's documented contract.
+ */
+declare const RPC_PATH = "/_lunora/rpc";
+/**
+ * The slice of a Cloudflare service binding this module uses.
+ *
+ * Structural on purpose: `env.BACKEND` satisfies it, and so does a one-method
+ * fake in a test. Declaring the full `Fetcher` would drag
+ * `@cloudflare/workers-types` into every consumer for a single method.
+ */
+interface ServiceBindingLike {
+  fetch: (request: Request) => Promise<Response>;
+}
+interface ServiceCallOptions {
+  /**
+   * Route to a specific shard. Omitted, the callee routes to its default shard
+   * — the same rule the HTTP path follows, so a sharded app must pass the key
+   * it would have passed there.
+   */
+  shardKey?: string;
+}
+/**
+ * A typed caller bound to one Lunora Worker.
+ *
+ * The three methods are separate rather than one `call` so a reader can tell a
+ * read from a write at the call site, and so the reference's `Kind` is checked:
+ * passing a mutation reference to `query` is a compile error, matching how
+ * `ctx.runQuery`/`ctx.runMutation` behave inside an app.
+ */
+interface LunoraServiceClient {
+  action: <F extends FunctionReference<"action">>(reference: F, args?: ArgsOf<F>, options?: ServiceCallOptions) => Promise<ReturnOf<F>>;
+  mutation: <F extends FunctionReference<"mutation">>(reference: F, args?: ArgsOf<F>, options?: ServiceCallOptions) => Promise<ReturnOf<F>>;
+  query: <F extends FunctionReference<"query">>(reference: F, args?: ArgsOf<F>, options?: ServiceCallOptions) => Promise<ReturnOf<F>>;
+}
+/**
+ * Build a typed caller for the Lunora Worker behind `binding`.
+ *
+ * Only PUBLIC functions are reachable. An `internal*` procedure is deliberately
+ * absent from the generated `api` object and rejected by the callee, because a
+ * service binding is a trust boundary between deployments, not the intra-app
+ * `ctx.run*` seam.
+ * @param binding The service binding, e.g. `env.BACKEND`.
+ * @returns a client whose methods type-check against the generated `api`.
+ */
+declare const createServiceClient: (binding: ServiceBindingLike) => LunoraServiceClient;
+export { type LunoraServiceClient, RPC_PATH, type ServiceBindingLike, type ServiceCallOptions, createServiceClient };

package/dist/service.d.ts

@@ -0,0 +1,49 @@
+import { F as FunctionReference, A as ArgsOf, R as ReturnOf } from "./packem_shared/function-reference.d-Br_hsKje.js";
+/**
+ * The wire endpoint every Lunora Worker serves. Matches `createWorker`'s RPC
+ * route; the envelope shape below is that route's documented contract.
+ */
+declare const RPC_PATH = "/_lunora/rpc";
+/**
+ * The slice of a Cloudflare service binding this module uses.
+ *
+ * Structural on purpose: `env.BACKEND` satisfies it, and so does a one-method
+ * fake in a test. Declaring the full `Fetcher` would drag
+ * `@cloudflare/workers-types` into every consumer for a single method.
+ */
+interface ServiceBindingLike {
+  fetch: (request: Request) => Promise<Response>;
+}
+interface ServiceCallOptions {
+  /**
+   * Route to a specific shard. Omitted, the callee routes to its default shard
+   * — the same rule the HTTP path follows, so a sharded app must pass the key
+   * it would have passed there.
+   */
+  shardKey?: string;
+}
+/**
+ * A typed caller bound to one Lunora Worker.
+ *
+ * The three methods are separate rather than one `call` so a reader can tell a
+ * read from a write at the call site, and so the reference's `Kind` is checked:
+ * passing a mutation reference to `query` is a compile error, matching how
+ * `ctx.runQuery`/`ctx.runMutation` behave inside an app.
+ */
+interface LunoraServiceClient {
+  action: <F extends FunctionReference<"action">>(reference: F, args?: ArgsOf<F>, options?: ServiceCallOptions) => Promise<ReturnOf<F>>;
+  mutation: <F extends FunctionReference<"mutation">>(reference: F, args?: ArgsOf<F>, options?: ServiceCallOptions) => Promise<ReturnOf<F>>;
+  query: <F extends FunctionReference<"query">>(reference: F, args?: ArgsOf<F>, options?: ServiceCallOptions) => Promise<ReturnOf<F>>;
+}
+/**
+ * Build a typed caller for the Lunora Worker behind `binding`.
+ *
+ * Only PUBLIC functions are reachable. An `internal*` procedure is deliberately
+ * absent from the generated `api` object and rejected by the callee, because a
+ * service binding is a trust boundary between deployments, not the intra-app
+ * `ctx.run*` seam.
+ * @param binding The service binding, e.g. `env.BACKEND`.
+ * @returns a client whose methods type-check against the generated `api`.
+ */
+declare const createServiceClient: (binding: ServiceBindingLike) => LunoraServiceClient;
+export { type LunoraServiceClient, RPC_PATH, type ServiceBindingLike, type ServiceCallOptions, createServiceClient };

package/dist/service.mjs

@@ -0,0 +1 @@
+import{LunoraError as u}from"@lunora/errors";import{e as w,d as f}from"./packem_shared/wire-codec-BfIZrTJe.mjs";const v="/_lunora/rpc",$="https://lunora.internal",N=e=>{const t=new Error(e.message??"request failed");return t.code=e.code,e.data!==void 0&&(t.data=f(e.data)),e.hint!==void 0&&(t.hint=e.hint),e.docsUrl!==void 0&&(t.docsUrl=e.docsUrl),t},h=async(e,t,r,a,l)=>{const s=r.__lunoraRef;let d;try{d=JSON.stringify({args:w(a??{}),functionPath:s,...l?.shardKey===void 0?{}:{shardKey:l.shardKey}})}catch(o){const p=o instanceof Error?o.message:String(o);throw new TypeError(`@lunora/client/service: cannot encode args for '${s}' — ${p}`,o instanceof Error?{cause:o}:void 0)}const n=await e.fetch(new Request(`${$}${v}`,{body:d,headers:{"content-type":"application/json"},method:"POST"}));let i;try{i=await n.json()}catch{throw new u("INTERNAL",`@lunora/client/service: ${t} "${s}" got a non-JSON response (status ${n.status.toString()}). Check the service binding points at the Lunora Worker that declares this function.`,{status:n.status})}if(i===null||typeof i!="object")throw new u("INTERNAL",`@lunora/client/service: ${t} "${s}" returned a JSON body that is not an object (status ${n.status.toString()}). Check the service binding points at the Lunora Worker that declares this function.`,{status:n.status});const c=i;if("error"in c)throw N(c.error);if(!n.ok)throw new u("INTERNAL",`@lunora/client/service: ${t} "${s}" failed with status ${n.status.toString()} and no error envelope.`,{status:n.status});return f(c.result)},E=e=>({action:async(t,r,a)=>await h(e,"action",t,r,a),mutation:async(t,r,a)=>await h(e,"mutation",t,r,a),query:async(t,r,a)=>await h(e,"query",t,r,a)});export{v as RPC_PATH,E as createServiceClient};

package/dist/ssr/index.d.mts

@@ -1,27 +1,48 @@
-import { P as Preloaded, L as LunoraClient } from "../packem_shared/lunora-client.d-DLbxPGH9.mjs";
-export type { A as ArgsOf, F as FunctionReference, R as ReturnOf } from "../packem_shared/lunora-client.d-DLbxPGH9.mjs";
-export { p as preloadQuery, a as preloadedQueryResult } from "../packem_shared/preload.d-BAT6GeSD.mjs";
+import { P as Preloaded, L as LunoraClient } from "../packem_shared/lunora-client.d-BSNUC85h.mjs";
+export type { A as ArgsOf, F as FunctionReference, R as ReturnOf } from "../packem_shared/function-reference.d-Br_hsKje.mjs";
+export {
+/**
+ * `@lunora/client/ssr` — the framework-neutral server contract that every Lunora
+ * meta-framework adapter (React, Solid, Svelte, Vue) depends on. It owns the
+ * server-side seam: a request-scoped HTTP RPC client, session resolution from
+ * the inbound request, query preloading, and the dehydrate/serialize helpers
+ * for handing a preloaded snapshot to the client. Nothing here opens a
+ * WebSocket or touches a UI framework, so it is safe to import from any SSR
+ * loader.
+ */
+p as preloadQuery,
+/**
+ * `@lunora/client/ssr` — the framework-neutral server contract that every Lunora
+ * meta-framework adapter (React, Solid, Svelte, Vue) depends on. It owns the
+ * server-side seam: a request-scoped HTTP RPC client, session resolution from
+ * the inbound request, query preloading, and the dehydrate/serialize helpers
+ * for handing a preloaded snapshot to the client. Nothing here opens a
+ * WebSocket or touches a UI framework, so it is safe to import from any SSR
+ * loader.
+ */
+a as preloadedQueryResult } from "../packem_shared/preload.d-XsWPDlX6.mjs";
+import '@lunora/errors';
 import '@lunora/runtime';
 /**
-* Structural shape of a better-auth `getSession` call's resolved value.
-*
-* better-auth's `auth.api.getSession({ headers })` returns `{ user, session }`
-* when a valid session cookie is present, or `null` otherwise. We keep `user`
-* and `session` as open records so `@lunora/client/ssr` carries no hard dependency on
-* better-auth's concrete `User`/`Session` types — the adapter passing the real
-* `auth` instance keeps full inference, while this package stays decoupled.
-*/
+ * Structural shape of a better-auth `getSession` call's resolved value.
+ *
+ * better-auth's `auth.api.getSession({ headers })` returns `{ user, session }`
+ * when a valid session cookie is present, or `null` otherwise. We keep `user`
+ * and `session` as open records so `@lunora/client/ssr` carries no hard dependency on
+ * better-auth's concrete `User`/`Session` types — the adapter passing the real
+ * `auth` instance keeps full inference, while this package stays decoupled.
+ */
 interface ServerSession<User extends Record<string, unknown> = Record<string, unknown>, Session extends Record<string, unknown> = Record<string, unknown>> {
   readonly session: Session;
   readonly user: User;
 }
 /**
-* Structural subset of a better-auth instance: just the one endpoint
-* `getServerSession` needs. Typing it this way (rather than importing
-* `@lunora/auth`'s `LunoraAuth`) means `@lunora/client/ssr` does not depend on
-* better-auth internals — any object exposing `api.getSession` works, including
-* a test stub. The concrete return type is inferred from the passed instance.
-*/
+ * Structural subset of a better-auth instance: just the one endpoint
+ * `getServerSession` needs. Typing it this way (rather than importing
+ * `@lunora/auth`'s `LunoraAuth`) means `@lunora/client/ssr` does not depend on
+ * better-auth internals — any object exposing `api.getSession` works, including
+ * a test stub. The concrete return type is inferred from the passed instance.
+ */
 interface AuthLike<Result = ServerSession | null> {
   readonly api: {
     getSession: (input: {
@@ -30,86 +51,86 @@ interface AuthLike<Result = ServerSession | null> {
   };
 }
 /**
-* Anything `getServerSession` can read request headers from: a `Request`, a
-* `Headers` object, or a plain object exposing `headers`. SSR loaders across
-* meta-frameworks hand back slightly different request objects, so accept the
-* common shapes rather than forcing the caller to unwrap.
-*/
+ * Anything `getServerSession` can read request headers from: a `Request`, a
+ * `Headers` object, or a plain object exposing `headers`. SSR loaders across
+ * meta-frameworks hand back slightly different request objects, so accept the
+ * common shapes rather than forcing the caller to unwrap.
+ */
 type HeadersSource = Headers | Request | {
   readonly headers: Headers;
 };
 /**
-* Resolve the signed-in session from a request inside an SSR loader.
-*
-* Wraps `auth.api.getSession({ headers })` — the helper every meta-framework
-* app otherwise hand-rolls — so a loader can read identity off the inbound
-* cookies in one call. Returns `{ user, session }` when a valid session cookie
-* is present, or `null` for anonymous requests.
-*
-* The `auth` parameter is structurally typed ({@link AuthLike}), so this
-* package does not depend on better-auth internals; pass a real
-* `@lunora/auth` instance to keep full type inference on `user`/`session`.
-* Forward the resolved session's token to `createServerClient` to run the
-* server-side load (and the later WS subscription) as the same identity.
-*/
+ * Resolve the signed-in session from a request inside an SSR loader.
+ *
+ * Wraps `auth.api.getSession({ headers })` — the helper every meta-framework
+ * app otherwise hand-rolls — so a loader can read identity off the inbound
+ * cookies in one call. Returns `{ user, session }` when a valid session cookie
+ * is present, or `null` for anonymous requests.
+ *
+ * The `auth` parameter is structurally typed ({@link AuthLike}), so this
+ * package does not depend on better-auth internals; pass a real
+ * `@lunora/auth` instance to keep full type inference on `user`/`session`.
+ * Forward the resolved session's token to `createServerClient` to run the
+ * server-side load (and the later WS subscription) as the same identity.
+ */
 declare const getServerSession: <Result>(request: HeadersSource, auth: AuthLike<Result>) => Promise<NonNullable<Result> | null>;
 /**
-* Serialize a {@link Preloaded} token to a JSON string for embedding in the
-* rendered HTML (e.g. a `&lt;script>` payload the client
-* reads on hydration). Every field of `Preloaded` is JSON-serializable by
-* construction — `preloadQuery` only captures the query args, function path,
-* optional shard key, and the resolved value — so this is a thin, explicit
-* `JSON.stringify` that documents the dehydration seam and keeps callers from
-* accidentally stringifying a non-serializable wrapper.
-*
-* The `&lt;` is escaped to `&lt;` so the payload is safe to inline inside a
-* `&lt;script>` tag without a stray `&lt;/script>` (or `&lt;!--`) prematurely closing
-* it — the standard XSS-safe script-embedding precaution. This escaping is NOT
-* sufficient for an HTML *attribute* sink (which also needs the quote and `&amp;`
-* characters escaped); embed the output in a raw-text script element, not a
-* data attribute.
-*/
+ * Serialize a {@link Preloaded} token to a JSON string for embedding in the
+ * rendered HTML (e.g. a `<script>` payload the client
+ * reads on hydration). Every field of `Preloaded` is JSON-serializable by
+ * construction — `preloadQuery` only captures the query args, function path,
+ * optional shard key, and the resolved value — so this is a thin, explicit
+ * `JSON.stringify` that documents the dehydration seam and keeps callers from
+ * accidentally stringifying a non-serializable wrapper.
+ *
+ * The `<` is escaped to `<` so the payload is safe to inline inside a
+ * `<script>` tag without a stray `<\/script>` (or `<!--`) prematurely closing
+ * it — the standard XSS-safe script-embedding precaution. This escaping is NOT
+ * sufficient for an HTML *attribute* sink (which also needs the quote and `&`
+ * characters escaped); embed the output in a raw-text script element, not a
+ * data attribute.
+ */
 declare const serializePreloaded: <T>(preloaded: Preloaded<T>) => string;
 /**
-* Inverse of {@link serializePreloaded}: parse a serialized token back into a
-* {@link Preloaded} value on the client. The `&lt;` escape from serialization
-* is transparent to `JSON.parse`, so no un-escaping step is needed.
-*/
+ * Inverse of {@link serializePreloaded}: parse a serialized token back into a
+ * {@link Preloaded} value on the client. The `<` escape from serialization
+ * is transparent to `JSON.parse`, so no un-escaping step is needed.
+ */
 declare const deserializePreloaded: <T = unknown>(serialized: string) => Preloaded<T>;
 /** Options accepted by {@link createServerClient}. */
 interface ServerClientOptions {
   /**
-  * `fetch` implementation used for HTTP RPC. Defaults to the ambient global
-  * `fetch` (present in Node 18+, Workers, and meta-framework SSR runtimes).
-  * Pass one explicitly to forward cookies/headers or to use an instrumented
-  * fetch.
-  */
+   * `fetch` implementation used for HTTP RPC. Defaults to the ambient global
+   * `fetch` (present in Node 18+, Workers, and meta-framework SSR runtimes).
+   * Pass one explicitly to forward cookies/headers or to use an instrumented
+   * fetch.
+   */
   fetch?: typeof fetch;
   /**
-  * Bearer token sent as `Authorization: Bearer &lt;token>` on every RPC. In an
-  * SSR loader you typically read this from the request (e.g. the session
-  * resolved by `getServerSession`) and pass it here so the server-side
-  * load runs as the signed-in user — and so the client subscription that
-  * resumes after hydration carries the same identity.
-  */
+   * Bearer token sent as `Authorization: Bearer <token>` on every RPC. In an
+   * SSR loader you typically read this from the request (e.g. the session
+   * resolved by `getServerSession`) and pass it here so the server-side
+   * load runs as the signed-in user — and so the client subscription that
+   * resumes after hydration carries the same identity.
+   */
   token?: string;
   /** Base URL of the deployed Lunora worker, e.g. `https://app.example.workers.dev`. */
   url: string;
 }
 /**
-* Build a request-scoped {@link LunoraClient} for use inside an SSR loader. SSR
-* data loading only ever calls `.query()` (HTTP RPC over `fetch`); a
-* `LunoraClient` opens a socket lazily on `.subscribe()`/`.stream()` and those
-* are never called server-side, so no live connection is established even if the
-* server runtime happens to expose a global `WebSocket`.
-*
-* Create one per request rather than sharing a module-level instance: the bearer
-* token (and any forwarded cookies in `fetch`) are per-user, and a shared client
-* would leak one request's identity into another.
-*
-* This is the framework-neutral home of the helper that previously lived only in
-* `@lunora/react/server`; the React server module re-exports the same surface so
-* existing imports keep working.
-*/
+ * Build a request-scoped {@link LunoraClient} for use inside an SSR loader. SSR
+ * data loading only ever calls `.query()` (HTTP RPC over `fetch`); a
+ * `LunoraClient` opens a socket lazily on `.subscribe()`/`.stream()` and those
+ * are never called server-side, so no live connection is established even if the
+ * server runtime happens to expose a global `WebSocket`.
+ *
+ * Create one per request rather than sharing a module-level instance: the bearer
+ * token (and any forwarded cookies in `fetch`) are per-user, and a shared client
+ * would leak one request's identity into another.
+ *
+ * This is the framework-neutral home of the helper that previously lived only in
+ * `@lunora/react/server`; the React server module re-exports the same surface so
+ * existing imports keep working.
+ */
 declare const createServerClient: (options: ServerClientOptions) => LunoraClient;
 export { type AuthLike, type HeadersSource, type Preloaded, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, serializePreloaded };