@lunora/client 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/packem_shared/offline-queue-D73Dq95V.mjs

@@ -0,0 +1 @@
+const c=(n,e)=>n!==void 0&&e!==n;let h=0;const a=()=>{if(typeof crypto<"u"&&typeof crypto.randomUUID=="function")return crypto.randomUUID();h+=1;const n=typeof crypto<"u"&&typeof crypto.getRandomValues=="function"?[...crypto.getRandomValues(new Uint8Array(8))].map(e=>e.toString(16).padStart(2,"0")).join(""):Math.random().toString(16).slice(2,12);return`m_${Date.now().toString(36)}_${h.toString(36)}_${n}`},r=(n,e,t,s)=>{if(n){n({error:t,mutationId:s,operation:e});return}console.warn(`[lunora] offline-queue persistence ${e} failed`,t)};class d{queueBeforeFirstConnect;maxItems;onPersistenceError;persistence;onEvict;onSizeChange;version;items=[];constructor(e={},t={}){this.maxItems=e.maxItems??1e3,this.queueBeforeFirstConnect=e.queueBeforeFirstConnect??!1,this.onPersistenceError=e.onPersistenceError,this.persistence=t.persistence,this.onEvict=t.onEvict,this.onSizeChange=t.onSizeChange,this.version=t.version}get size(){return this.items.length}enqueue(e){const t=e;for(t.id??=a(),this.items.push(t),this.persistence?.append({args:t.args,functionPath:t.functionPath,id:t.id,identity:t.identity,shardKey:t.shardKey,...this.version===void 0?{}:{version:this.version}}).catch(s=>{r(this.onPersistenceError,"append",s,t.id)});this.items.length>this.maxItems;){const s=this.items.shift();if(s){s.id&&this.persistence?.remove(s.id).catch(o=>{r(this.onPersistenceError,"remove",o,s.id)});const i=new Error("offline queue overflow");i.code="OFFLINE_QUEUE_OVERFLOW",s.reject(i),this.onEvict?.(s,i)}}this.notifySize()}async hydrate(){if(!this.persistence)return[];let e;try{e=await this.persistence.load()}catch(i){throw r(this.onPersistenceError,"load",i),i}const t=new Set,s=[];for(const i of e)if(!(this.items.some(o=>o.id===i.id)||s.some(o=>o.id===i.id))){if(c(this.version,i.version)){this.persistence.remove(i.id).catch(o=>{r(this.onPersistenceError,"remove",o,i.id)});continue}s.push({args:i.args,functionPath:i.functionPath,id:i.id,identity:i.identity,reject:()=>{},resolve:()=>{},shardKey:i.shardKey}),t.add(i.shardKey)}return this.items.unshift(...s),this.notifySize(),[...t]}drain(e){if(!e){const i=[...this.items];return this.items.length=0,this.notifySize(),i}const t=[],s=[];for(const i of this.items)(e(i)?t:s).push(i);return this.items.length=0,this.items.push(...s),this.notifySize(),t}requeue(e){e.length!==0&&(this.items.unshift(...e),this.notifySize())}drainConflict(){const e=[],t=[];for(const s of this.items)if(s.precondition!==void 0&&!s.precondition()){const i=new Error("offline mutation skipped: precondition failed before replay");i.code="OFFLINE_PRECONDITION_FAILED",s.reject(i),e.push(s)}else t.push(s);return e.length>0&&(this.items.length=0,this.items.push(...t),this.notifySize()),e}clear(){for(const e of this.items){const t=new Error("CLIENT_CLOSED");t.code="CLIENT_CLOSED",e.reject(t)}this.items.length=0,this.notifySize()}notifySize(){this.onSizeChange?.(this.items.length)}}export{d as c,c as d,r as s,a as u};

package/dist/packem_shared/preload.d-BmztUzzG.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-Bt65hm_E.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/packem_shared/preload.d-DGGRMWB5.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-Bt65hm_E.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/preloadQuery-DjwSjFwt.mjs

@@ -0,0 +1 @@
+const l=async(e,a,r,u={})=>{const o=await e.query(a,r,u);return{__lunoraPreloaded:!0,args:r??{},functionPath:a.__lunoraRef,shardKey:u.shardKey,value:o}},t=e=>e.value;export{l as preloadQuery,t as preloadedQueryResult};

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

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

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};