statewire 0.18.1 → 0.18.2

package/src/host/socket.ts

@@ -94,16 +94,15 @@ type Admission = {
 export type ClientRec = {
   id: string;
   lastSeq: number;
-  ctxSeq: number;
   touched: number;
-  context: Record<string, unknown> | null;
-  contextDocuments: StatewireDocuments.State;
   results: Map<number, { ts: number; cmd: StatewireCmd }>;
   inflight: Map<number, Admission>;
   /** The auth captured at the record's first attach; later attaches must match. */
   principal: unknown;
 };
 
+// The ctx lane is attach scoped: a Conn is born with an empty context table
+// and outlives its socket so an admitted command keeps reading its last value.
 export type Conn = {
   selection: StatewireProtocol.Selection;
   clientId: string;
@@ -114,6 +113,9 @@ export type Conn = {
   lease: string | null;
   /** The awaited `authorize` return captured at this attach's authorization. */
   auth: unknown;
+  ctxSeq: number;
+  context: Record<string, unknown> | null;
+  contextDocuments: StatewireDocuments.State;
 };
 
 type PendingConn = {
@@ -556,10 +558,7 @@ const notifyClientRecords = (h: SocketHostState) => {
     [...h.clients.values()].map((rec) => ({
       id: rec.id,
       lastSeq: admittedThrough(rec),
-      ctxSeq: rec.ctxSeq,
       touched: rec.touched,
-      context: rec.context,
-      contextDocuments: [...rec.contextDocuments.documents],
       results: [...rec.results].map(([seq, entry]) => ({
         seq,
         ts: entry.ts,
@@ -636,12 +635,12 @@ const settleWire = (
 const callerOf = (
   h: SocketHostState,
   rec: ClientRec,
-  auth: unknown,
+  conn: Conn,
 ): StatewireHost.Caller => ({
   clientId: rec.id,
-  auth,
+  auth: conn.auth,
   get context() {
-    return rec.context;
+    return conn.context;
   },
   get isConnected() {
     if (h.clients.get(rec.id) !== rec) return false;
@@ -668,9 +667,8 @@ const rejectStatement = (
 const admitCmd = (
   h: SocketHostState,
   rec: ClientRec,
+  conn: Conn,
   statement: CmdStatement,
-  auth: unknown,
-  selection: StatewireProtocol.Selection,
 ) => {
   const adm: Admission = {
     seq: statement.seq,
@@ -683,7 +681,7 @@ const admitCmd = (
   notifyClientRecords(h);
   if (
     statement.protocol !== h.protocol.name ||
-    !selection.protocols.some((p) => p.name === statement.protocol)
+    !conn.selection.protocols.some((p) => p.name === statement.protocol)
   ) {
     settleCmd(h, rec, adm, {
       seq: adm.seq,
@@ -729,7 +727,7 @@ const admitCmd = (
     method: statement.method,
     params,
     clientId: rec.id,
-    caller: callerOf(h, rec, auth),
+    caller: callerOf(h, rec, conn),
     onApplied: () => {
       if (adm.settled || adm.applied) return;
       adm.applied = true;
@@ -743,9 +741,10 @@ const admitCmd = (
   });
 };
 
-// One admission law, both lanes: absorbed statements answer from the record,
-// then the new suffix is admitted whole or the frame is refused whole via a
-// {syn} stating both watermarks, nothing consumed. A gap is never a close.
+// One admission law, both lanes: absorbed statements answer from the record
+// (cmd) or the attach (ctx), then the new suffix is admitted whole or the
+// frame is refused whole via a {syn} stating both watermarks, nothing
+// consumed. A gap is never a close.
 export type FrameAdmission =
   | { type: "ok" }
   | {
@@ -757,29 +756,25 @@ export type FrameAdmission =
 
 export const admitFrame = (
   h: SocketHostState,
-  rec: ClientRec,
+  conn: Conn,
   frame: ParsedFrame,
-  auth: unknown,
-  selection: StatewireProtocol.Selection = {
-    version: h.wireVersion.version,
-    protocols: [{ name: h.protocol.name, version: h.protocol.version }],
-  },
 ): FrameAdmission => {
+  const rec = h.clients.get(conn.clientId)!;
   rec.touched = Date.now();
   const through = admittedThrough(rec);
   for (const statement of frame.cmd) {
     if (statement.seq <= through) reemit(h, rec, statement.seq);
   }
-  const ctxNew = frame.ctx.filter((s) => s.seq > rec.ctxSeq);
+  const ctxNew = frame.ctx.filter((s) => s.seq > conn.ctxSeq);
   const cmdNew = frame.cmd.filter((s) => s.seq > through);
   if (
-    (ctxNew.length > 0 && ctxNew[0]!.seq !== rec.ctxSeq + 1) ||
+    (ctxNew.length > 0 && ctxNew[0]!.seq !== conn.ctxSeq + 1) ||
     (cmdNew.length > 0 && cmdNew[0]!.seq !== through + 1)
   ) {
     notifyClientRecords(h);
     return {
       type: "refused",
-      syn: { syn: { seq: through, ctxSeq: rec.ctxSeq } },
+      syn: { syn: { seq: through, ctxSeq: conn.ctxSeq } },
     };
   }
   if (cmdNew.length > 0) {
@@ -796,7 +791,7 @@ export const admitFrame = (
         syn: {
           syn: {
             seq: through,
-            ctxSeq: rec.ctxSeq,
+            ctxSeq: conn.ctxSeq,
             retry: COMMAND_CAPACITY_RETRY_MS,
           },
         },
@@ -812,17 +807,17 @@ export const admitFrame = (
         );
       return {
         type: "refused",
-        syn: { syn: { seq: through, ctxSeq: rec.ctxSeq, retry } },
+        syn: { syn: { seq: through, ctxSeq: conn.ctxSeq, retry } },
       };
     }
   }
-  let contextDocuments = rec.contextDocuments;
+  let contextDocuments = conn.contextDocuments;
   try {
     for (const statement of ctxNew)
       contextDocuments = applyDocumentOps(
         contextDocuments,
         statement.ops,
-        selection.protocols,
+        conn.selection.protocols,
         true,
       );
     if (
@@ -833,11 +828,11 @@ export const admitFrame = (
   } catch {
     return violation("invalid-context");
   }
-  rec.contextDocuments = contextDocuments;
-  rec.context = (mainDocument(contextDocuments, h.protocol.name)?.value ??
+  conn.contextDocuments = contextDocuments;
+  conn.context = (mainDocument(contextDocuments, h.protocol.name)?.value ??
     null) as Record<string, unknown> | null;
-  if (ctxNew.length) rec.ctxSeq = ctxNew.at(-1)!.seq;
-  for (const statement of cmdNew) admitCmd(h, rec, statement, auth, selection);
+  if (ctxNew.length) conn.ctxSeq = ctxNew.at(-1)!.seq;
+  for (const statement of cmdNew) admitCmd(h, rec, conn, statement);
   if (cmdNew.length > 0) {
     // Memory host: admitted means retained — dur rides the admitting flush.
     queueCmd(h, rec.id, { seq: cmdNew.at(-1)!.seq, dur: true });
@@ -885,10 +880,9 @@ const message = (h: SocketHostState, conn: Conn, data: string) => {
     return;
   }
   if (frame.ctx.length === 0 && frame.cmd.length === 0) return;
-  const rec = h.clients.get(conn.clientId)!;
   let admission: ReturnType<typeof admitFrame>;
   try {
-    admission = admitFrame(h, rec, frame, conn.auth, conn.selection);
+    admission = admitFrame(h, conn, frame);
   } catch (error) {
     const reason = violationReason(error);
     if (reason === null) throw error;
@@ -1203,7 +1197,6 @@ const gcClients = (h: SocketHostState) => {
 };
 
 export type Registration = {
-  rec: ClientRec;
   conn: Conn;
   connection: StatewireHostInternal.SocketConnection;
 };
@@ -1265,10 +1258,7 @@ export const register = (
       const created: ClientRec = {
         id: clientId,
         lastSeq: 0,
-        ctxSeq: 0,
         touched: Date.now(),
-        context: null,
-        contextDocuments: { mode: "mounted", documents: new Map() },
         results: new Map(),
         inflight: new Map(),
         principal: auth,
@@ -1286,6 +1276,9 @@ export const register = (
     lastSentAt: 0,
     lease: null,
     auth,
+    ctxSeq: 0,
+    context: null,
+    contextDocuments: { mode: "mounted", documents: new Map() },
   };
   h.conns.add(conn);
   gcClients(h);
@@ -1305,7 +1298,7 @@ export const register = (
     syn: {
       ...selection,
       seq: admittedThrough(rec),
-      ctxSeq: rec.ctxSeq,
+      ctxSeq: 0,
       ...(h.idleWire && { idle: true }),
     },
   };
@@ -1317,7 +1310,7 @@ export const register = (
     message: (data) => message(h, conn, data),
     close: () => closeConn(h, conn),
   };
-  return { rec, conn, connection };
+  return { conn, connection };
 };
 
 const connect = (
@@ -1367,15 +1360,14 @@ const restoreClientRecords = (
     records.map((record) => [
       record.id,
       {
-        ...record,
-        contextDocuments: {
-          mode: "mounted",
-          documents: new Map(record.contextDocuments ?? []),
-        },
+        id: record.id,
+        lastSeq: record.lastSeq,
+        touched: record.touched,
         results: new Map(
           record.results.map(({ seq, ts, cmd }) => [seq, { ts, cmd }]),
         ),
         inflight: new Map(),
+        principal: record.principal,
       },
     ]),
   );

package/src/host-internal.ts

@@ -1,5 +1,4 @@
 import type { StatewireProtocol } from "./wire/protocol";
-import type { StatewireDocuments } from "./wire/documents";
 import type { StatewireHost } from "./host";
 import type { StatewireCmd } from "./client/connection";
 
@@ -49,10 +48,7 @@ export namespace StatewireHostInternal {
   export type ClientRecord = {
     id: string;
     lastSeq: number;
-    ctxSeq: number;
     touched: number;
-    context: Record<string, unknown> | null;
-    contextDocuments?: readonly [number, StatewireDocuments.Document][];
     results: readonly { seq: number; ts: number; cmd: StatewireCmd }[];
     principal: unknown;
   };

package/src/host.ts

@@ -47,7 +47,7 @@ export namespace StatewireHost {
    * (in-process dispatch has none — reading it throws), `auth` is the value
    * `authorize` returned for the attach that admitted the command (undefined
    * for a void `authorize` and for in-process dispatch), `context` reads the
-   * client's current ambient context live (null until the client sends one),
+   * admitting attach's context live (null until that attach sends one),
    * `isConnected` reports whether the client has an active stream attachment.
    */
   export type Caller = {

package/src/statewire.ts

@@ -432,17 +432,10 @@ export namespace StatewireClient {
     meta?: unknown;
   };
 
-  /** The persisted session: the lane identity, the lane clocks, and the commands the server has not marked durable. */
+  /** The persisted session: the lane identity, the cmd clock, and the commands the server has not marked durable. */
   export type SessionRecord = {
     clientId: string;
     nextSeq: number;
-    ctxNextSeq: number;
-    context?: {
-      ops: unknown[];
-      pending: { seq: number; ops: unknown[] }[];
-      /** Recover the original wire's unpersisted single-document context after the next hello. */
-      recover?: "version-1";
-    };
     commands: readonly SessionCommand[];
     /** Terminal verdicts parked for the sharer that minted the seq (shared storage only). */
     verdicts?: readonly SessionVerdict[];

package/src/storage.ts

@@ -4,7 +4,6 @@ import { resource } from "@assistant-ui/tap";
 import type { StatewireClient } from "./statewire";
 import type { StatewireProtocol } from "./wire/protocol";
 import { negotiationHeaders, protocolToken } from "./wire/protocol";
-import { applyDocumentOps } from "./wire/documents";
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value);
@@ -92,9 +91,7 @@ const isSessionRecord = (
   isRecord(value) &&
   typeof value["clientId"] === "string" &&
   value["clientId"].length > 0 &&
-  isContext(value["context"]) &&
   isPositiveSafeInteger(value["nextSeq"]) &&
-  isPositiveSafeInteger(value["ctxNextSeq"]) &&
   Array.isArray(value["commands"]) &&
   value["commands"].every(isSessionCommand) &&
   (value["verdicts"] === undefined ||
@@ -123,74 +120,6 @@ const isProducer = (value: unknown) => {
   }
 };
 
-const isContextOperation = (value: unknown) => {
-  if (!isRecord(value)) return false;
-  if (
-    value["doc"] !== undefined &&
-    (typeof value["doc"] !== "number" ||
-      !Number.isSafeInteger(value["doc"]) ||
-      value["doc"] < 0)
-  )
-    return false;
-  if (value["op"] === "mount") {
-    try {
-      applyDocumentOps(
-        { mode: "mounted", documents: new Map() },
-        [value],
-        undefined,
-        true,
-      );
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  if (value["op"] === "unmount") return true;
-  if (!["add", "replace", "remove"].includes(value["op"] as string))
-    return false;
-  return (
-    Array.isArray(value["path"]) &&
-    value["path"].every(
-      (part) =>
-        typeof part === "string" ||
-        (typeof part === "number" && Number.isSafeInteger(part) && part >= 0),
-    ) &&
-    (value["op"] === "remove" || "value" in value)
-  );
-};
-
-const isContext = (value: unknown) => {
-  if (value === undefined) return true;
-  if (
-    !isRecord(value) ||
-    !Array.isArray(value["ops"]) ||
-    !Array.isArray(value["pending"])
-  )
-    return false;
-  if (value["recover"] !== undefined && value["recover"] !== "version-1")
-    return false;
-  try {
-    const documents = applyDocumentOps(
-      { mode: "mounted", documents: new Map() },
-      value["ops"],
-      undefined,
-      true,
-    );
-    for (const entry of value["pending"]) {
-      if (
-        !isRecord(entry) ||
-        !isPositiveSafeInteger(entry["seq"]) ||
-        !Array.isArray(entry["ops"])
-      )
-        return false;
-      if (!entry["ops"].every(isContextOperation)) return false;
-    }
-    return documents.mode === "mounted";
-  } catch {
-    return false;
-  }
-};
-
 const decode = (
   raw: string | null,
   legacyProtocol: KeyValueSessionStorage.Options["legacyProtocol"],
@@ -202,14 +131,18 @@ const decode = (
   const {
     statewireStorageVersion: format,
     savedAt: _savedAt,
+    ctxNextSeq: _ctxNextSeq,
+    context: _context,
     ...value
   } = parsed as StatewireClient.SessionRecord & {
     statewireStorageVersion?: unknown;
     savedAt?: unknown;
+    ctxNextSeq?: unknown;
+    context?: unknown;
   };
   if (!isSessionRecord(value))
     throw new Error("statewire: invalid stored session record");
-  if (format !== undefined && format !== 1)
+  if (format !== undefined && format !== 1 && format !== 2)
     throw new Error("statewire: unsupported session storage version");
   if (legacyProtocol === undefined || format !== undefined) return value;
   const produced = {
@@ -218,22 +151,6 @@ const decode = (
   };
   return {
     ...value,
-    ...(value.context === undefined && value.ctxNextSeq > 1
-      ? {
-          context: {
-            ops: [
-              {
-                op: "mount",
-                protocol: legacyProtocol.name,
-                main: true,
-                value: {},
-              },
-            ],
-            pending: [],
-            recover: "version-1",
-          },
-        }
-      : {}),
     commands: value.commands.map((command) =>
       command.produced === undefined
         ? {
@@ -279,12 +196,11 @@ const sweep = async (
     const format = isRecord(value)
       ? value["statewireStorageVersion"]
       : undefined;
-    if (format !== undefined && format !== 1) return undefined;
+    if (format !== undefined && format !== 1 && format !== 2) return undefined;
     if (
       !isSessionRecord(value) ||
       value.commands.length ||
-      value.failed?.length ||
-      value.context?.pending.length
+      value.failed?.length
     )
       return undefined;
     const savedAt =
@@ -502,7 +418,7 @@ const useKeyValueSessionStorage = (
           throw new Error("statewire: invalid session record");
         const encoded = JSON.stringify({
           ...record,
-          statewireStorageVersion: 1,
+          statewireStorageVersion: 2,
           savedAt: Date.now(),
         });
         state.record = record;

package/src/transports/sse.ts

@@ -32,7 +32,7 @@ export type StatewireFrame = {
 export type StatewireRemoteProps = {
   beforeAttach?: () => void | Promise<void>;
   clientId: string;
-  /** Lanes to ride the attach frame (no-lease supersession only); records the included seqs. */
+  /** Lanes to ride the attach frame: the context restatement, plus cmds on no-lease supersession; records the included seqs. */
   takeAttachLanes: () => StatewireFrame | null;
   onHello: (args: { ops: unknown[]; syn: StatewireSyn }) => void;
   onOps: (args: { ops: unknown[]; cmds: StatewireCmd[] }) => void;

package/src/transports/testing.ts

@@ -82,6 +82,7 @@ export const createMockTransport = <TState>(
       clientId = id;
       if (!clients.has(id)) clients.set(id, { seq: 0, ctxSeq: 0 });
       const rec = clients.get(id)!;
+      rec.ctxSeq = 0;
       const frame = JSON.parse(String(init?.body ?? "{}")) as StatewireFrame;
       admit(id, frame);
       return openSSEStream(
@@ -93,7 +94,7 @@ export const createMockTransport = <TState>(
               ops: [{ op: "mount", protocol, main: true, value: state }],
               syn: {
                 seq: rec.seq,
-                ctxSeq: rec.ctxSeq,
+                ctxSeq: 0,
                 version: "2026-09-07",
                 protocols: [{ name: protocol, version: "2026-09-07" }],
               },