statewire 0.11.0 → 0.12.2

package/src/statewire.ts

@@ -11,6 +11,7 @@ import {
 import type { ResourceElement } from "@assistant-ui/tap";
 import { LIVE_CONNECTION, useStatewireCore } from "./client/core";
 import type { Statewire } from "./types";
+import type { TERMINAL } from "./client/connection";
 import { SessionStorageContext } from "./client/sessionStore";
 
 const useSessionTransport = ({
@@ -218,7 +219,7 @@ export namespace StatewireClient {
    * fate: "aborted" = never sent, "rejected" = the server refused it
    * (`code` "unknown-command" | "invalid-params" for the static rejects,
    * code-less for handler rejects), "lost" = sent but no verdict will ever
-   * arrive — the record is gone (`record: "fresh"`) or the channel died: it
+   * arrive — the record is gone (a proven seq gap) or the channel died: it
    * may or may not have run, "failed" = the handler ran and threw,
    * "crashed" = the handler died involuntarily, "expired" = settled —
    * result, rejected, failed, or crashed — but the verdict outlived the
@@ -239,14 +240,25 @@ export namespace StatewireClient {
     | { fate: "expired"; cause: "server" }
     | {
         fate: "aborted";
-        cause: "unmount" | "stream-gone" | "session-lost" | "superseded";
+        cause: "unmount" | "stream-gone" | "session-lost";
         predecessorLost?: true;
       }
     | {
         fate: "lost";
-        cause: "unmount" | "stream-gone" | "session-lost" | "superseded";
+        cause: "unmount" | "stream-gone" | "session-lost";
       };
 
+  /** Held commands a proven record gap settled `{fate: "lost", cause: "session-lost"}`; return "requeue" to re-enqueue them on the reset clocks. */
+  export type OnSessionLost = (
+    pending: ReadonlyArray<{
+      method: string;
+      params: readonly unknown[];
+      ts: number;
+      seq: number;
+      clientId?: string;
+    }>,
+  ) => "requeue" | "drop";
+
   /** A command as persisted while un-durable: its lane seq plus the wire statement. */
   export type SessionCommand = {
     seq: number;
@@ -268,7 +280,7 @@ export namespace StatewireClient {
   /** A terminal verdict one sharer's connection carried, parked for the sharer awaiting the seq. */
   export type SessionVerdict = {
     seq: number;
-    type: "result" | "rejected" | "failed" | "crashed" | "expired";
+    type: (typeof TERMINAL)[number];
     code?: string;
     message?: string;
     payload?: unknown;
@@ -295,6 +307,7 @@ export namespace StatewireClient {
     url: string;
     headers?: HeadersOption;
     fetch?: typeof globalThis.fetch;
+    onSessionLost?: OnSessionLost;
     onChange?: (connection: Connection) => void;
     /** The broadcast idle flag's rising edge: the instance went quiet. */
     onDone?: () => void;
@@ -309,6 +322,7 @@ export namespace StatewireClient {
       | Record<string, string>
       | (() => Record<string, string> | Promise<Record<string, string>>);
     webSocket?: new (url: string, protocols?: string | string[]) => WebSocket;
+    onSessionLost?: OnSessionLost;
     onChange?: (connection: Connection) => void;
     /** The broadcast idle flag's rising edge: the instance went quiet. */
     onDone?: () => void;

package/src/transports/fake-sse.ts

@@ -30,7 +30,11 @@ export const openSSEStream = (
           if (!open) return;
           open = false;
           streams.delete(handle);
-          controller.close();
+          try {
+            controller.close();
+          } catch {
+            // the reader already canceled
+          }
         },
       };
       streams.add(handle);
@@ -40,11 +44,7 @@ export const openSSEStream = (
       streams.delete(handle);
     },
   });
-  signal?.addEventListener("abort", () => {
-    for (const stream of [...streams]) {
-      if (stream.clientId === clientId) stream.close();
-    }
-  });
+  signal?.addEventListener("abort", () => handle.close());
   return new Response(body, {
     status: 200,
     headers: { "content-type": "text/event-stream", ...headers },

package/src/transports/remote.ts

@@ -21,6 +21,7 @@ export const useStatewireRemote = <
 ): Statewire<any, any> => {
   const s = useStatewireSession({
     sessionStore: options.sessionStore,
+    onSessionLost: options.onSessionLost,
     onDone: options.onDone,
   });
   const conn = useLink(options, s.ctx);

package/src/transports/testing.ts

@@ -77,8 +77,7 @@ export const createMockTransport = <TState>(
     const id = headers.get("Statewire-Client-Id") ?? "";
     if (url.endsWith("/stream")) {
       clientId = id;
-      const known = clients.has(id);
-      if (!known) clients.set(id, { seq: 0, ctxSeq: 0 });
+      if (!clients.has(id)) clients.set(id, { seq: 0, ctxSeq: 0 });
       const rec = clients.get(id)!;
       const frame = JSON.parse(String(init?.body)) as StatewireFrame;
       admit(id, frame);
@@ -89,11 +88,7 @@ export const createMockTransport = <TState>(
           handle.send(
             sseFrame({
               ops: [{ op: "replace", path: [], value: state }],
-              syn: {
-                seq: rec.seq,
-                ctxSeq: rec.ctxSeq,
-                record: known ? "resumed" : "fresh",
-              },
+              syn: { seq: rec.seq, ctxSeq: rec.ctxSeq },
             }),
           );
         },

package/src/wire/meta.ts

@@ -17,15 +17,23 @@ const isPath = (path: unknown): path is (string | number)[] =>
       (typeof seg === "number" && Number.isInteger(seg)),
   );
 
-/** Revive meta-typed locations inside a wire value (in place). Unknown types
- * are skipped; a path that does not resolve to a valid target faults. */
-export const reviveValue = (value: unknown, meta: unknown): unknown => {
+/** Revive meta-typed locations inside a wire value (in place). Clients skip
+ * unknown types; hosts pass `rejectUnknown` to fault on them instead. */
+export const reviveValue = (
+  value: unknown,
+  meta: unknown,
+  { rejectUnknown = false } = {},
+): unknown => {
   if (!Array.isArray(meta)) return fault("meta must be an array");
   for (const entry of meta as { path?: unknown; type?: unknown }[]) {
     const path =
       typeof entry === "object" && entry !== null ? entry.path : null;
     if (!isPath(path)) return fault("meta entry must carry a path array");
-    if (entry.type !== "date") continue;
+    if (entry.type !== "date") {
+      if (rejectUnknown)
+        return fault(`unknown meta type: ${String(entry.type)}`);
+      continue;
+    }
     const walked = walkStatePath(value, path, "resolve");
     if (walked === undefined) {
       return fault(`meta path ${path.join(".")} does not resolve`);

package/src/wire/ops.ts

@@ -64,15 +64,42 @@ export const sanitizeValue = (value: unknown, parent?: string): unknown =>
 const invalid = (op: Statewire.Op) =>
   new Error(`Statewire cannot apply ${op.op} at path: ${op.path.join(".")}`);
 
+// Text-insert offsets are Unicode code points on the wire, not UTF-16 units.
+const utf16Index = (text: string, offset: number): number => {
+  let index = 0;
+  for (let remaining = offset; remaining > 0; remaining -= 1) {
+    if (index >= text.length) return -1;
+    index += text.codePointAt(index)! > 0xffff ? 2 : 1;
+  }
+  return index;
+};
+
+const countCodePoints = (text: string): number => {
+  let count = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text.codePointAt(index)! > 0xffff) index += 1;
+    count += 1;
+  }
+  return count;
+};
+
+let last: { str: string; count: number } | null = null;
+
 const insertedText = (
   current: string,
   op: Extract<Statewire.Op, { op: "add" }>,
   offset: number,
 ): string => {
-  if (typeof op.value !== "string" || offset > current.length) {
-    throw invalid(op);
+  if (typeof op.value !== "string") throw invalid(op);
+  const memoized =
+    last !== null && last.str === current && last.count === offset;
+  const index = memoized ? current.length : utf16Index(current, offset);
+  if (index < 0) throw invalid(op);
+  const next = current.slice(0, index) + op.value + current.slice(index);
+  if (index === current.length) {
+    last = { str: next, count: offset + countCodePoints(op.value) };
   }
-  return current.slice(0, offset) + op.value + current.slice(offset);
+  return next;
 };
 
 const applyAdd = (