@lunora/client 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/packem_shared/wire-codec-D_fiax9d.mjs

@@ -0,0 +1 @@
+const b=r=>{let n="";for(let u=0;u<r.length;u+=32768)n+=String.fromCharCode(...r.subarray(u,u+32768));return btoa(n)},g=r=>{const n=atob(r),u=new Uint8Array(n.length);for(let c=0;c<n.length;c+=1)u[c]=n.codePointAt(c)??0;return u},o="$lunora.wire$";const p="__proto__",w={BigInt64Array,BigUint64Array,Float32Array,Float64Array,Int8Array,Int16Array,Int32Array,Uint8Array,Uint8ClampedArray,Uint16Array,Uint32Array},d={Error,EvalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError},m=r=>{if(r===null||typeof r!="object")return!1;const n=Object.getPrototypeOf(r);return n===null||n===Object.prototype},s=(r,n=0)=>{if(n>64)throw new RangeError("wire-codec: value nesting exceeds the 64-level limit");if(r===void 0)return[o,"undefined"];if(r===null)return null;const u=typeof r;if(u==="bigint")return[o,"bigint",r.toString()];if(u==="number"){const e=r;return Number.isNaN(e)?[o,"nan"]:e===1/0?[o,"inf"]:e===-1/0?[o,"-inf"]:e}if(u!=="object")return r;if(r instanceof Date)return[o,"date",s(r.getTime(),n+1)];if(r instanceof Error){const e=r,a={};for(const l of Object.keys(e))e[l]!==void 0&&(a[l]=s(e[l],n+1));const i=[o,"error",e.name,e.message,a];return e.cause!==void 0&&i.push(s(e.cause,n+1)),i}if(r instanceof URL)return[o,"url",r.href];if(r instanceof Map)return[o,"map",[...r.entries()].map(([e,a])=>[s(e,n+1),s(a,n+1)])];if(r instanceof Set)return[o,"set",[...r].map(e=>s(e,n+1))];if(r instanceof ArrayBuffer)return[o,"bytes",b(new Uint8Array(r)),"ArrayBuffer"];if(ArrayBuffer.isView(r)){const e=r,a=e.constructor.name,i=new Uint8Array(e.buffer,e.byteOffset,e.byteLength);return a==="Uint8Array"?[o,"bytes",b(i)]:[o,"bytes",b(i),a]}if(Array.isArray(r)){const e=r.map(a=>s(a,n+1));return e.length>0&&e[0]===o?[o,"arr",e]:e}if(!m(r)){const e=r.constructor?.name??"value";throw new TypeError(`wire-codec: cannot encode a ${e} over the Lunora wire — only plain objects, arrays, and the supported built-ins (Date, Error, URL, Map, Set, ArrayBuffer/typed arrays, bigint) round-trip`)}const c=r,t={};for(const e of Object.keys(c)){const a=c[e];if(a===void 0)continue;const i=s(a,n+1);e===p?Object.defineProperty(t,e,{configurable:!0,enumerable:!0,value:i,writable:!0}):t[e]=i}return t},f=(r,n=0)=>{if(n>64)throw new RangeError("wire-codec: value nesting exceeds the 64-level limit");if(r===null||typeof r!="object")return r;if(Array.isArray(r)){if(r[0]===o)switch(r[1]){case"-inf":return-1/0;case"arr":return r[2].map(t=>f(t,n+1));case"bigint":{const t=r[2];if(typeof t!="string"||t.length>1024||!/^-?\d+$/.test(t))throw new RangeError("wire-codec: invalid or over-long bigint (max 1024 digits)");return BigInt(t)}case"date":return new Date(f(r[2],n+1));case"map":return new Map(r[2].map(([t,e])=>[f(t,n+1),f(e,n+1)]));case"set":return new Set(r[2].map(t=>f(t,n+1)));case"url":return new URL(r[2]);case"error":{const t=r[2],e=r[3],a=(Object.hasOwn(d,t)?d[t]:void 0)??Error,i=new a(e);i.name!==t&&Object.defineProperty(i,"name",{configurable:!0,value:t,writable:!0});const l=f(r[4],n+1);for(const y of Object.keys(l))y===p?Object.defineProperty(i,y,{configurable:!0,enumerable:!0,value:l[y],writable:!0}):i[y]=l[y];return r.length>5&&Object.defineProperty(i,"cause",{configurable:!0,value:f(r[5],n+1),writable:!0}),i}case"bytes":{const t=g(r[2]),e=r[3]??"Uint8Array";if(e==="ArrayBuffer")return t.buffer.byteLength===t.byteLength?t.buffer:t.slice().buffer;const a=Object.hasOwn(w,e)?w[e]:void 0;return a?new a(t.slice().buffer):t}case"inf":return 1/0;case"nan":return Number.NaN;case"undefined":return;default:return r.map(t=>f(t,n+1))}return r.map(t=>f(t,n+1))}const u=r,c={};for(const t of Object.keys(u)){const e=f(u[t],n+1);t===p?Object.defineProperty(c,t,{configurable:!0,enumerable:!0,value:e,writable:!0}):c[t]=e}return c};export{s as a,f as s};

package/dist/packem_shared/wire-key-j8BZ65HQ.mjs

@@ -0,0 +1 @@
+import{a as c}from"./wire-codec-D_fiax9d.mjs";const y=(e,t)=>e<t?-1:e>t?1:0,n=e=>{if(e===void 0)return"null";if(typeof e=="bigint")throw new TypeError("stableStringify: cannot use a bigint in a stable JSON cache key — pass it as a string, or use stableWireKey");if(e===null||typeof e!="object")return JSON.stringify(e);if(Array.isArray(e))return`[${e.map(r=>n(r)).join(",")}]`;const t=Object.getPrototypeOf(e);if(t!==null&&t!==Object.prototype){const r=e.constructor?.name??"value";throw new TypeError(`stableStringify: cannot use a ${r} in a stable JSON cache key — only plain objects, arrays, and JSON primitives are supported (wire-typed values key via stableWireKey)`)}const o=e,s=Object.keys(o).toSorted(y),i=[];for(const r of s){const a=o[r];a!==void 0&&i.push(`${JSON.stringify(r)}:${n(a)}`)}return`{${i.join(",")}}`},l=e=>n(c(e));export{l as t};

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/pagination/index.mjs

@@ -1,61 +1 @@
-const SPLIT_FACTOR = 2;
-const JOIN_FACTOR = 0.5;
-const initialPages = (numberItems) => [
-  // eslint-disable-next-line unicorn/no-null -- `lower: null` is the feed head, `upper: null` the open-ended tail — both are wire-shape cursors.
-  { lower: null, numItems: numberItems, upper: null }
-];
-const rebalance = (pages, results) => {
-  for (const [index, page] of pages.entries()) {
-    if (page.upper === null) {
-      continue;
-    }
-    const result = results[index];
-    if (!result) {
-      continue;
-    }
-    const size = result.page.length;
-    if (size > SPLIT_FACTOR * page.numItems && result.splitCursor) {
-      const split = result.splitCursor;
-      const next = [...pages];
-      next.splice(index, 1, { lower: page.lower, numItems: page.numItems, upper: split }, { lower: split, numItems: page.numItems, upper: page.upper });
-      return next;
-    }
-    if (size < JOIN_FACTOR * page.numItems && index + 1 < pages.length) {
-      const neighbour = pages[index + 1];
-      if (!neighbour) {
-        continue;
-      }
-      const next = [...pages];
-      next.splice(index, 2, { lower: page.lower, numItems: page.numItems, upper: neighbour.upper });
-      return next;
-    }
-  }
-  return void 0;
-};
-const derivePaginationStatus = (skipped, pageResults) => {
-  if (skipped || !pageResults[0]) {
-    return { nextCursor: void 0, status: "LoadingFirstPage" };
-  }
-  const tail = pageResults.at(-1);
-  if (!tail) {
-    return { nextCursor: void 0, status: "LoadingMore" };
-  }
-  if (tail.isDone || tail.continueCursor === null) {
-    return { nextCursor: void 0, status: "Exhausted" };
-  }
-  return { nextCursor: tail.continueCursor, status: "CanLoadMore" };
-};
-const applyLoadMore = (pages, cursor, numberItems) => {
-  if (cursor === void 0 || cursor === null) {
-    return void 0;
-  }
-  const next = [...pages];
-  const tail = next.at(-1);
-  if (tail) {
-    next[next.length - 1] = { lower: tail.lower, numItems: tail.numItems, upper: cursor };
-  }
-  next.push({ lower: cursor, numItems: numberItems, upper: null });
-  return next;
-};
-
-export { JOIN_FACTOR, SPLIT_FACTOR, applyLoadMore, derivePaginationStatus, initialPages, rebalance };
+const l=2,a=.5,p=r=>[{lower:null,numItems:r,upper:null}],m=(r,s)=>{for(const[n,e]of r.entries()){if(e.upper===null)continue;const t=s[n];if(!t)continue;const i=t.page.length;if(i>2*e.numItems&&t.splitCursor){const u=t.splitCursor,o=[...r];return o.splice(n,1,{lower:e.lower,numItems:e.numItems,upper:u},{lower:u,numItems:e.numItems,upper:e.upper}),o}if(i<.5*e.numItems&&n+1<r.length){const u=r[n+1];if(!u)continue;const o=[...r];return o.splice(n,2,{lower:e.lower,numItems:e.numItems,upper:u.upper}),o}}},c=(r,s)=>{if(r||!s[0])return{nextCursor:void 0,status:"LoadingFirstPage"};const n=s.at(-1);return n?n.isDone||n.continueCursor===null?{nextCursor:void 0,status:"Exhausted"}:{nextCursor:n.continueCursor,status:"CanLoadMore"}:{nextCursor:void 0,status:"LoadingMore"}},I=(r,s,n)=>{if(s==null)return;const e=[...r],t=e.at(-1);return t&&(e[e.length-1]={lower:t.lower,numItems:t.numItems,upper:s}),e.push({lower:s,numItems:n,upper:null}),e};export{a as JOIN_FACTOR,l as SPLIT_FACTOR,I as applyLoadMore,c as derivePaginationStatus,p as initialPages,m as rebalance};

package/dist/query/index.d.mts

@@ -1,26 +1,27 @@
-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-CbnxmuqG.mjs";
-export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-CbnxmuqG.mjs";
+import { F as FunctionReference, A as ArgsOf, R as ReturnOf, a as Unsubscribe } from "../packem_shared/types.d-CA7ZeJm9.mjs";
+import { S as SubscriptionError, L as LunoraClient } from "../packem_shared/lunora-client.d-BRXKXo0T.mjs";
+export type { a as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-BRXKXo0T.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 +34,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,27 @@
-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-CbnxmuqG.js";
-export type { b as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-CbnxmuqG.js";
+import { F as FunctionReference, A as ArgsOf, R as ReturnOf, a as Unsubscribe } from "../packem_shared/types.d-CA7ZeJm9.js";
+import { S as SubscriptionError, L as LunoraClient } from "../packem_shared/lunora-client.d-B23myJYW.js";
+export type { a as SubscriptionErrorCallback } from "../packem_shared/lunora-client.d-B23myJYW.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 +34,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.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-CArzT3Vl.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/types.d-CA7ZeJm9.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/types.d-CA7ZeJm9.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{a as f,s as w}from"./packem_shared/wire-codec-D_fiax9d.mjs";const p="/_lunora/rpc",$="https://lunora.internal",g=e=>{const t=new Error(e.message??"request failed");return t.code=e.code,e.data!==void 0&&(t.data=w(e.data)),e.hint!==void 0&&(t.hint=e.hint),e.docsUrl!==void 0&&(t.docsUrl=e.docsUrl),t},h=async(e,t,a,o,d)=>{const s=a.__lunoraRef;let l;try{l=JSON.stringify({args:f(o??{}),functionPath:s,...d?.shardKey===void 0?{}:{shardKey:d.shardKey}})}catch(n){const y=n instanceof Error?n.message:String(n);throw new TypeError(`@lunora/client/service: cannot encode args for '${s}' — ${y}`,n instanceof Error?{cause:n}:void 0)}const r=await e.fetch(new Request(`${$}${p}`,{body:l,headers:{"content-type":"application/json"},method:"POST"}));let i;try{i=await r.json()}catch{throw new u("INTERNAL",`@lunora/client/service: ${t} "${s}" got a non-JSON response (status ${r.status.toString()}). Check the service binding points at the Lunora Worker that declares this function.`,{status:r.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 ${r.status.toString()}). Check the service binding points at the Lunora Worker that declares this function.`,{status:r.status});const c=i;if("error"in c)throw g(c.error);if(!r.ok)throw new u("INTERNAL",`@lunora/client/service: ${t} "${s}" failed with status ${r.status.toString()} and no error envelope.`,{status:r.status});return w(c.result)},m=e=>({action:async(t,a,o)=>await h(e,"action",t,a,o),mutation:async(t,a,o)=>await h(e,"mutation",t,a,o),query:async(t,a,o)=>await h(e,"query",t,a,o)});export{p as RPC_PATH,m as createServiceClient};