@lunora/solid 1.0.0-alpha.24 → 1.0.0-alpha.26

package/dist/index.mjs

@@ -1,14 +1,14 @@
 export { LunoraContext, useLunora } from './packem_shared/LunoraContext-C59PzHhN.mjs';
 export { createAgent } from './packem_shared/createAgent-D7EZBeql.mjs';
-export { createAgentChat } from './packem_shared/createAgentChat-CsoyE3RE.mjs';
+export { createAgentChat } from './packem_shared/createAgentChat-Bq-wzSxv.mjs';
 export { createAgentState } from './packem_shared/createAgentState-DckYu3G8.mjs';
 export { createAgentToolEvents } from './packem_shared/createAgentToolEvents-UavTO16u.mjs';
 export { AuthLoading, Authenticated, Unauthenticated, createAuth } from './packem_shared/AuthLoading-u5QJoV-J.mjs';
 export { default as createConnectionStatus } from './packem_shared/createConnectionStatus-1poqwqR9.mjs';
-export { createFlag, createFlags } from './packem_shared/createFlag-Bu9YfzcJ.mjs';
+export { createFlag, createFlags } from './packem_shared/createFlag-DQoGdUMB.mjs';
 export { createMutation, createMutationForClient } from './packem_shared/createMutation-LkrbhItI.mjs';
 export { createMutator } from './packem_shared/createMutator-foSnPJPt.mjs';
-export { createInfiniteQuery, createPaginatedQuery } from './packem_shared/createInfiniteQuery-Dy9k7Px2.mjs';
+export { createInfiniteQuery, createPaginatedQuery } from './packem_shared/createInfiniteQuery-CD2GT1_O.mjs';
 export { createPresence } from './packem_shared/createPresence-DM2cVkiG.mjs';
 export { createQuery } from './packem_shared/createQuery-BUldvZXj.mjs';
 export { createRateLimit } from './packem_shared/createRateLimit-BA2f8XyF.mjs';

package/dist/packem_shared/{createAgentChat-CsoyE3RE.mjs → createAgentChat-Bq-wzSxv.mjs}

@@ -8,12 +8,15 @@ const NO_STREAM_REF = {
   __lunoraRef: ""
 };
 const reconcileOptimistic = (optimistic, durable) => {
-  const pool = durable.filter((message) => message.role === "user").map((message) => message.content);
+  const durableUserRows = durable.filter((message) => message.role === "user");
+  const consumed = /* @__PURE__ */ new Set();
   return optimistic.filter((pending) => {
-    const index = pool.indexOf(pending.content);
-    if (index !== -1) {
-      pool.splice(index, 1);
-      return false;
+    for (let index = pending.durableUserCountAtSend; index < durableUserRows.length; index += 1) {
+      const row = durableUserRows[index];
+      if (row !== void 0 && !consumed.has(index) && row.content === pending.content) {
+        consumed.add(index);
+        return false;
+      }
     }
     return true;
   });
@@ -68,12 +71,18 @@ const createAgentChat = (options) => {
     if (visible.length === 0) {
       return rows;
     }
+    let maxDurableSeq = -1;
+    for (const message of rows) {
+      if (message.seq > maxDurableSeq) {
+        maxDurableSeq = message.seq;
+      }
+    }
     return [...rows, ...visible.map((pending, index) => {
       return {
         content: pending.content,
         optimistic: true,
         role: "user",
-        seq: rows.length + index
+        seq: maxDurableSeq + 1 + index
       };
     })];
   });
@@ -85,16 +94,23 @@ const createAgentChat = (options) => {
   const send = async (input, arguments_) => {
     const id = nextId;
     nextId += 1;
+    const durableUserCountAtSend = durable().filter((message) => message.role === "user").length;
     setOptimistic((previous) => [...reconcileOptimistic(previous, durable()), {
       content: input,
+      durableUserCountAtSend,
       id
     }]);
-    await sendMutation.mutate({
-      input,
-      threadKey: resolveMaybe(threadKey),
-      ...sendArgs,
-      ...arguments_
-    });
+    try {
+      await sendMutation.mutate({
+        input,
+        threadKey: resolveMaybe(threadKey),
+        ...sendArgs,
+        ...arguments_
+      });
+    } catch (error) {
+      setOptimistic((previous) => previous.filter((pending) => pending.id !== id));
+      throw error;
+    }
   };
   const approve = async (toolCallId, note) => {
     const instanceId = thread()?.instanceId;

package/dist/packem_shared/{createFlag-Bu9YfzcJ.mjs → createFlag-DQoGdUMB.mjs}

@@ -1,5 +1,5 @@
 import { createSignal, createEffect, on, onCleanup } from 'solid-js';
-import { s as stableStringify } from './stable-key-CGp4e2Ux.mjs';
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const FLAGS_EVAL_PATH = "__lunora_flags__:eval";

package/dist/packem_shared/{createInfiniteQuery-Dy9k7Px2.mjs → createInfiniteQuery-CD2GT1_O.mjs}

@@ -1,8 +1,106 @@
-import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
+import { initialPages, derivePaginationStatus, applyLoadMore, rebalance } from '@lunora/client/pagination';
 import { createMemo, createSignal, createEffect, on, onCleanup } from 'solid-js';
-import { s as stableStringify } from './stable-key-CGp4e2Ux.mjs';
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
+const toBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+
+const TAG = "$lunora.wire$";
+const MAX_DEPTH = 64;
+const encodeWire = (value, depth = 0) => {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
+  }
+  if (value === void 0) {
+    return [TAG, "undefined"];
+  }
+  if (value === null) {
+    return null;
+  }
+  const kind = typeof value;
+  if (kind === "bigint") {
+    return [TAG, "bigint", value.toString()];
+  }
+  if (kind === "number") {
+    const numeric = value;
+    if (Number.isNaN(numeric)) {
+      return [TAG, "nan"];
+    }
+    if (numeric === Infinity) {
+      return [TAG, "inf"];
+    }
+    if (numeric === -Infinity) {
+      return [TAG, "-inf"];
+    }
+    return numeric;
+  }
+  if (kind !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return [TAG, "date", encodeWire(value.getTime(), depth + 1)];
+  }
+  if (value instanceof Error) {
+    const error = value;
+    const properties = {};
+    for (const key of Object.keys(error)) {
+      if (error[key] !== void 0) {
+        properties[key] = encodeWire(error[key], depth + 1);
+      }
+    }
+    const encodedError = [TAG, "error", error.name, error.message, properties];
+    if (error.cause !== void 0) {
+      encodedError.push(encodeWire(error.cause, depth + 1));
+    }
+    return encodedError;
+  }
+  if (value instanceof URL) {
+    return [TAG, "url", value.href];
+  }
+  if (value instanceof Map) {
+    return [TAG, "map", [...value.entries()].map(([k, v]) => [encodeWire(k, depth + 1), encodeWire(v, depth + 1)])];
+  }
+  if (value instanceof Set) {
+    return [TAG, "set", [...value].map((item) => encodeWire(item, depth + 1))];
+  }
+  if (value instanceof ArrayBuffer) {
+    return [TAG, "bytes", toBase64(new Uint8Array(value)), "ArrayBuffer"];
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    const ctorName = view.constructor.name;
+    const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    return ctorName === "Uint8Array" ? [TAG, "bytes", toBase64(bytes)] : [TAG, "bytes", toBase64(bytes), ctorName];
+  }
+  if (Array.isArray(value)) {
+    const encoded = value.map((item) => encodeWire(item, depth + 1));
+    return encoded.length > 0 && encoded[0] === TAG ? [TAG, "arr", encoded] : encoded;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(`wire-codec: cannot encode a ${name} 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 source = value;
+  const result = {};
+  for (const key of Object.keys(source)) {
+    const field = source[key];
+    if (field !== void 0) {
+      result[key] = encodeWire(field, depth + 1);
+    }
+  }
+  return result;
+};
+
+const stableWireKey = (value) => stableStringify(encodeWire(value));
+
 const buildPageArgs = (page, baseArgs) => {
   return {
     ...baseArgs,
@@ -13,7 +111,7 @@ const buildPageArgs = (page, baseArgs) => {
     }
   };
 };
-const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${stableStringify(pageArgs)}`;
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${stableWireKey(pageArgs)}`;
 const createPaginatedCore = (function_, args, options) => {
   const client = useLunora();
   const {
@@ -49,7 +147,7 @@ const createPaginatedCore = (function_, args, options) => {
       }
     }
   };
-  const syncSubscriptions = (currentPages, baseArgs) => {
+  const syncPass = (currentPages, baseArgs) => {
     const wantedKeys = /* @__PURE__ */ new Set();
     for (const page of currentPages) {
       wantedKeys.add(buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs)));
@@ -91,6 +189,31 @@ const createPaginatedCore = (function_, args, options) => {
       activeSubs.set(key, unsub);
     }
   };
+  let syncing = false;
+  let resyncRequested = false;
+  const syncSubscriptions = (currentPages, baseArgs) => {
+    if (syncing) {
+      resyncRequested = true;
+      return;
+    }
+    syncing = true;
+    try {
+      let pagesToSync = currentPages;
+      let argsToSync = baseArgs;
+      do {
+        resyncRequested = false;
+        syncPass(pagesToSync, argsToSync);
+        const latestArgs = resolveArgs();
+        if (latestArgs === "skip") {
+          break;
+        }
+        pagesToSync = pages();
+        argsToSync = latestArgs;
+      } while (resyncRequested);
+    } finally {
+      syncing = false;
+    }
+  };
   const teardownAll = () => {
     for (const unsub of activeSubs.values()) {
       unsub();

package/dist/packem_shared/{stable-key-CGp4e2Ux.mjs → stable-key-DePnevIy.mjs}

@@ -9,7 +9,7 @@ const stableStringify = (value) => {
     return "null";
   }
   if (typeof value === "bigint") {
-    throw new TypeError("stableStringify: cannot use a bigint in a cache key (query/subscription/shape args) — pass it as a string");
+    throw new TypeError("stableStringify: cannot use a bigint in a stable JSON cache key — pass it as a string, or use stableWireKey");
   }
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
@@ -20,7 +20,7 @@ const stableStringify = (value) => {
   const proto = Object.getPrototypeOf(value);
   if (proto !== null && proto !== Object.prototype) {
     const name = value.constructor?.name ?? "value";
-    throw new TypeError(`stableStringify: cannot use a ${name} in a cache key (query/subscription/shape args) — only plain objects, arrays, and JSON primitives are supported`);
+    throw new TypeError(`stableStringify: cannot use a ${name} in a stable JSON cache key — only plain objects, arrays, and JSON primitives are supported (wire-typed values key via stableWireKey)`);
   }
   const record = value;
   const keys = Object.keys(record).toSorted(compareKeys);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/solid",
-  "version": "1.0.0-alpha.24",
+  "version": "1.0.0-alpha.26",
   "description": "SolidJS adapter for Lunora — live queries, optimistic mutations, and reactive loaders",
   "keywords": [
     "cloudflare",
@@ -50,9 +50,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.21",
-    "@lunora/errors": "1.0.0-alpha.4",
-    "@lunora/ratelimit": "1.0.0-alpha.7"
+    "@lunora/client": "1.0.0-alpha.24",
+    "@lunora/errors": "1.0.0-alpha.5",
+    "@lunora/ratelimit": "1.0.0-alpha.8"
   },
   "peerDependencies": {
     "solid-js": "^1.9.0"