statewire 0.20.0 → 0.22.0

package/dist/wire/protocol.js

@@ -1,4 +1,4 @@
-//#region src/wire/protocol.ts
+// src/wire/protocol.ts
 const WIRE_VERSION = "2026-09-30";
 const DEFAULT_PROTOCOL = "default";
 const PROTOCOL_HEADER = "Statewire-Protocol";
@@ -236,7 +236,6 @@ const negotiateProtocols = (headers, wire, definitions) => {
 		})
 	};
 };
-//#endregion
 export { DEFAULT_PROTOCOL, PROTOCOL_HEADER, VERSION_HEADER, WIRE_VERSION, inRange, negotiateProtocols, negotiationHeaders, parseNegotiation, protocolOffers, protocolToken, validateRange, validateSelection, validateVersion };
 
 //# sourceMappingURL=protocol.js.map

package/dist/wire/version.d.ts

@@ -1,5 +1,2 @@
-//#region src/wire/version.d.ts
-declare const WS_SUBPROTOCOL = "statewire.v1";
-//#endregion
-export { WS_SUBPROTOCOL };
+export declare const WS_SUBPROTOCOL = "statewire.v1";
 //# sourceMappingURL=version.d.ts.map

package/dist/wire/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","names":[],"sources":["../../src/wire/version.ts"],"mappings":";cAAa"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/wire/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,iBAAiB,CAAC"}

package/dist/wire/version.js

@@ -1,6 +1,5 @@
-//#region src/wire/version.ts
+// src/wire/version.ts
 const WS_SUBPROTOCOL = "statewire.v1";
-//#endregion
 export { WS_SUBPROTOCOL };
 
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statewire",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "State over the wire: snapshot-first delta streaming and command submission for any state and any command",
   "license": "MIT",
   "repository": {
@@ -47,16 +47,16 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@assistant-ui/tap": "^0.9.6"
+    "@assistant-ui/tap": "^0.9.24"
   },
   "peerDependencies": {
     "react": "^18 || ^19"
   },
   "devDependencies": {
-    "@assistant-ui/x-buildutils": "^0.0.20",
-    "@types/react": "^19.2.17",
+    "@assistant-ui/x-buildutils": "^0.0.31",
+    "@types/react": "^19.3.0",
     "babel-plugin-react-compiler": "^1.0.0",
-    "react": "^19.2.8",
-    "vitest": "^4.1.10"
+    "react": "^19.3.1",
+    "vitest": "^5.0.5"
   }
 }

package/src/client/connection.ts

@@ -167,13 +167,21 @@ const setStatus = (c: Conn, next: ConnectionState) => {
   c.onChange(c.connection);
 };
 
-const storageFailed = (c: Conn, error: Error) => {
+const stopForError = ({
+  connection: c,
+  error,
+  reason,
+}: {
+  connection: Conn;
+  error: Error;
+  reason: "storage-error" | "protocol-error";
+}) => {
   c.error = error;
   c.onError(error);
   flushTapSync(() =>
     setStatus(c, {
       status: "stopped",
-      reason: "storage-error",
+      reason,
       degraded: true,
       message: error.message,
     }),
@@ -481,6 +489,7 @@ export const handleEnvelope = (
     return null;
   }
   deliverEnvelope(c, env);
+  if (c.connection.status === "stopped") return "stop";
   if (env.fin !== undefined) return settleFin(c, env.fin);
   if (c.connection.status !== "connected") {
     c.attempt = 0;
@@ -568,7 +577,7 @@ const run = async (c: Conn, lifetime: AbortController, gate: Gate) => {
     } catch (error) {
       if (!abort.signal.aborted) {
         if (isStorageError(error)) {
-          storageFailed(c, error);
+          stopForError({ connection: c, error, reason: "storage-error" });
           outcome = "stop";
         } else if (
           error instanceof SyntaxError ||
@@ -709,18 +718,19 @@ export const useLink = (
     };
     return conn;
   });
-  const [link] = useState(
-    (): RemoteLink => ({
-      get connection() {
-        return c.connection;
-      },
-      get parked() {
-        return c.parked;
-      },
-      send: (frame) => latest.current.send(c, frame),
-      storageFailed: (error) => storageFailed(c, error),
-    }),
-  );
+  const [link] = useState((): RemoteLink => ({
+    get connection() {
+      return c.connection;
+    },
+    get parked() {
+      return c.parked;
+    },
+    send: (frame) => latest.current.send(c, frame),
+    storageFailed: (error) =>
+      stopForError({ connection: c, error, reason: "storage-error" }),
+    protocolFailed: (error) =>
+      stopForError({ connection: c, error, reason: "protocol-error" }),
+  }));
 
   const negotiation = JSON.stringify([
     props.protocol,

package/src/client/session.ts

@@ -85,6 +85,7 @@ export type StatewireSessionOptions = StatewireProtocol.Options & {
 
 type Shared = {
   txq: Promise<void>;
+  syncQueued: boolean;
   parked: { protocol: string; verdict: StatewireClient.SessionVerdict }[];
   unsubscribe: (() => void) | null;
 };
@@ -204,7 +205,6 @@ const storageFailed = (s: Session, cause: unknown) => {
 };
 
 const setRecord = (s: Session, record: StatewireClient.SessionRecord) => {
-  s.record = record;
   if (!s.deactivated) {
     try {
       s.store.save(record);
@@ -213,6 +213,7 @@ const setRecord = (s: Session, record: StatewireClient.SessionRecord) => {
       throw s.storageError;
     }
   }
+  s.record = record;
 };
 
 const toStored = (p: Pending): StatewireClient.SessionCommand => {
@@ -288,8 +289,16 @@ const syncBacklogInner = (s: Session) => {
 };
 
 const syncBacklog = (s: Session) => {
-  if (!s.shared) return syncBacklogInner(s);
-  transactBackground(s, () => syncBacklogInner(s));
+  const shared = s.shared;
+  if (!shared) return syncBacklogInner(s);
+  if (shared.syncQueued) return;
+  shared.syncQueued = true;
+  void transact(s, () => {
+    shared.syncQueued = false;
+    syncBacklogInner(s);
+  }).catch(() => {
+    shared.syncQueued = false;
+  });
 };
 
 // Every record mutation over shared storage is a locked read-modify-write.
@@ -305,7 +314,7 @@ const transact = (s: Session, fn: () => void): Promise<void> => {
       if (stored !== null && stored.clientId !== s.record.clientId) {
         adoptReset(s, stored);
       } else if (stored !== null) {
-        s.record = stored;
+        s.record = boundRecord(stored);
       }
       fn();
       const persistence = s.store.flush?.();
@@ -357,6 +366,25 @@ export const failedCommands = (
   return s.failedList;
 };
 
+export const MAX_FAILED_RETAINED = 256;
+
+const boundFailed = (failed: readonly StatewireClient.FailedCommand[]) =>
+  failed.length > MAX_FAILED_RETAINED
+    ? [...failed].sort((a, b) => a.ts - b.ts).slice(-MAX_FAILED_RETAINED)
+    : failed;
+
+const boundRecord = (record: StatewireClient.SessionRecord) => {
+  let lanes = record.lanes;
+  for (const [protocol, lane] of Object.entries(lanes)) {
+    if (lane.failed !== undefined && lane.failed.length > MAX_FAILED_RETAINED)
+      lanes = {
+        ...lanes,
+        [protocol]: { ...lane, failed: boundFailed(lane.failed) },
+      };
+  }
+  return lanes === record.lanes ? record : { ...record, lanes };
+};
+
 const retainFailedInner = (
   s: Session,
   entry: Pending,
@@ -367,7 +395,7 @@ const retainFailedInner = (
     s,
     withLane(s.record, entry.command.protocol, {
       ...lane,
-      failed: [
+      failed: boundFailed([
         ...(lane.failed ?? []),
         {
           protocol: entry.command.protocol,
@@ -381,7 +409,7 @@ const retainFailedInner = (
           ts: entry.inv.ts,
           seq: entry.seq,
         },
-      ],
+      ]),
     }),
   );
   s.notify();
@@ -497,7 +525,7 @@ const rebaseRecord = (s: Session, adopt: () => void) => {
       ...lanes,
       [protocol]: {
         ...current,
-        failed: [...(current.failed ?? []), ...failed],
+        failed: boundFailed([...(current.failed ?? []), ...failed]),
       },
     };
   }
@@ -515,7 +543,7 @@ const resetRecord = (s: Session, clientId: string) =>
 // attempted history and our survivors re-stamp on the stored clocks.
 const adoptReset = (s: Session, stored: StatewireClient.SessionRecord) => {
   rebaseRecord(s, () => {
-    s.record = stored;
+    s.record = boundRecord(stored);
   });
   // The host attributes frames by lease, and the lease is bound to the id
   // this attach was opened with.
@@ -825,7 +853,7 @@ const handleOps = (
 ) => {
   ingestOps(s, ops);
   for (const cmd of cmds) handleCmd(s, cmd);
-  syncBacklog(s);
+  if (cmds.length > 0) syncBacklog(s);
   publishIngested(s);
 };
 
@@ -1018,7 +1046,7 @@ const pump = async (s: Session) => {
         // Shared storage: the lock across the send keeps per-lane arrival
         // ordered across sharers during attach handover.
         const send = () => transport.send(lanes.frame);
-        result = await (s.shared && !s.deactivated
+        result = await (s.shared && !s.deactivated && lanes.entries.length > 0
           ? s.store.lock!(send)
           : send());
       } catch {
@@ -1224,7 +1252,10 @@ const adoptStored = (s: Session) => {
       const params =
         command.meta === undefined
           ? command.params
-          : (reviveValue([...command.params], command.meta) as unknown[]);
+          : (reviveValue(
+              structuredClone(command.params),
+              command.meta,
+            ) as unknown[]);
       const entry: Pending = {
         seq,
         command: { protocol, ...command },
@@ -1364,7 +1395,7 @@ export const retryFailed = (
   const params =
     found.meta === undefined
       ? found.params
-      : (reviveValue([...found.params], found.meta) as unknown[]);
+      : (reviveValue(structuredClone(found.params), found.meta) as unknown[]);
   const result = new Promise<unknown>((resolve, reject) => {
     const retry = () => {
       if (!s.running) {
@@ -1510,8 +1541,11 @@ const loadSessionRecord = (
       store.save(stored);
     }
   }
-  const record = stored ?? { clientId: newClientId(), lanes: {} };
-  if (stored === null) store.save(record);
+  const record =
+    stored === null
+      ? { clientId: newClientId(), lanes: {} }
+      : boundRecord(stored);
+  if (record !== stored) store.save(record);
   return record;
 };
 
@@ -1590,7 +1624,12 @@ export const useStatewireSession = (
       documentStore,
       shared:
         store.lock !== undefined
-          ? { txq: Promise.resolve(), parked: [], unsubscribe: null }
+          ? {
+              txq: Promise.resolve(),
+              syncQueued: false,
+              parked: [],
+              unsubscribe: null,
+            }
           : false,
       ephemeral: false,
       deactivated: false,

package/src/host/host.ts

@@ -231,8 +231,13 @@ const LOCAL_CALLER: StatewireHost.Caller = Object.freeze({
   isConnected: true,
 });
 
-const toSendError = (error: unknown): StatewireSendError =>
-  error instanceof StatewireSendError
+const toSendError = (error: unknown): StatewireSendError => {
+  if (
+    !(error instanceof StatewireSendError) &&
+    !(error instanceof StatewireReject)
+  )
+    console.error("statewire command failed", error);
+  return error instanceof StatewireSendError
     ? error
     : error instanceof StatewireReject
       ? new StatewireSendError({
@@ -245,8 +250,9 @@ const toSendError = (error: unknown): StatewireSendError =>
       : new StatewireSendError({
           fate: "failed",
           cause: "server",
-          message: error instanceof Error ? error.message : String(error),
+          message: "the command failed",
         });
+};
 
 const applyInvocation = (cell: CommandsCell, inv: ActiveInvocation) => {
   if (inv.applied) return;

package/src/host/http.ts

@@ -8,6 +8,7 @@ import {
   authEquals,
   closeConn,
   flush,
+  expireLease,
   parseFrame,
   parseFrameValue,
   register,
@@ -94,9 +95,10 @@ const headersOf = (request: Request): Record<string, string> =>
 const authorize = async (
   h: SocketHostState,
   headers: Record<string, string>,
-): Promise<{ auth: unknown } | { refused: Response }> => {
+): Promise<{ auth: unknown; authorizedAt: number } | { refused: Response }> => {
   try {
-    return { auth: await h.authorize?.({ headers }) };
+    const auth = await h.authorize?.({ headers });
+    return { auth, authorizedAt: Date.now() };
   } catch (error) {
     if (error instanceof Response) return { refused: error };
     throw error;
@@ -140,6 +142,7 @@ const attachSse = (
   h: SocketHostState,
   clientId: string,
   auth: unknown,
+  authorizedAt: number,
   selection: StatewireProtocol.Selection,
   frame?: ParsedFrame,
 ): SseAttachment => {
@@ -203,6 +206,7 @@ const attachSse = (
     auth,
     selection,
     frame,
+    authorizedAt,
   );
   connection = registration?.connection ?? null;
   if (!open) connection?.close();
@@ -249,7 +253,13 @@ const getStream = async (
   ]);
   if ("fin" in selection)
     return Response.json(selection, { status: selection.fin.status });
-  const attachment = attachSse(h, client.clientId, authorized.auth, selection);
+  const attachment = attachSse(
+    h,
+    client.clientId,
+    authorized.auth,
+    authorized.authorizedAt,
+    selection,
+  );
   const lease = attachment.registration === null ? null : mintLease();
   if (attachment.registration !== null)
     attachment.registration.conn.lease = lease;
@@ -301,6 +311,7 @@ const postStream = async (
       h,
       client.clientId,
       authorized.auth,
+      authorized.authorizedAt,
       selection,
       frame,
     );
@@ -365,11 +376,24 @@ export const frames = async (
     lease === null
       ? undefined
       : [...h.conns].find((conn) => conn.open && conn.lease === lease);
-  if (h.disposed || h.finished !== null || leased === undefined) {
+  if (
+    h.disposed ||
+    h.finished !== null ||
+    leased === undefined ||
+    expireLease(h, leased)
+  ) {
     return Response.json({ error: "stale-lease" }, { status: 423 });
   }
   const clientId = leased.clientId;
   const raw = await readFrameBody(request);
+  if (
+    !leased.open ||
+    h.disposed ||
+    h.finished !== null ||
+    expireLease(h, leased)
+  ) {
+    return Response.json({ error: "stale-lease" }, { status: 423 });
+  }
   if (raw === null) {
     return Response.json({ error: "frame body too large" }, { status: 413 });
   }
@@ -382,7 +406,12 @@ export const frames = async (
     }
     return violationResponse(h, clientId, error.message);
   }
-  if (!leased.open || h.disposed || h.finished !== null) {
+  if (
+    !leased.open ||
+    h.disposed ||
+    h.finished !== null ||
+    expireLease(h, leased)
+  ) {
     return Response.json({ error: "stale-lease" }, { status: 423 });
   }
   let admission: ReturnType<typeof admitFrame>;
@@ -393,6 +422,9 @@ export const frames = async (
       throw error;
     return violationResponse(h, clientId, error.message);
   }
+  if (admission.type === "expired") {
+    return Response.json({ error: "stale-lease" }, { status: 423 });
+  }
   if (admission.type === "refused") {
     const retry = admission.syn.syn.retry;
     return Response.json(admission.syn, {