statewire 0.24.1 → 0.24.2

package/src/host/host.ts

@@ -182,6 +182,7 @@ export type CommandsSubmission = {
   clientId?: string;
   caller?: StatewireHost.Caller;
   context?: Statewire.Context;
+  version?: string;
   attach?: StatewireHost.Attach;
   onApplied?: () => void;
   onSettle?: (outcome: CommandsOutcome) => void;
@@ -206,6 +207,7 @@ export const bindCommandsHost = (commands: object, host: CommandsHost) => {
 
 type QueuedCall = {
   context?: Statewire.Context;
+  version?: string | undefined;
   method: string;
   params: readonly unknown[];
   ts: number;
@@ -223,6 +225,7 @@ type ActiveInvocation = CommandsInvocation & {
 
 type CommandsCell = {
   context: (() => Statewire.Context) | undefined;
+  version: string | undefined;
   handlers: Record<string, (...args: never[]) => unknown> | null;
   queue: QueuedCall[];
   active: Map<ActiveInvocation, QueuedCall>;
@@ -364,9 +367,16 @@ const dispatch = (cell: CommandsCell, call: QueuedCall) => {
   cell.listener?.onStart(inv);
   cell.listener?.onPosted?.(inv);
   const attach = call.origin?.attach;
+  const version =
+    call.origin !== undefined ? call.origin.version : call.version;
   const ctx: StatewireHost.Ctx = {
     caller: call.origin?.caller ?? LOCAL_CALLER,
     context: call.context ?? call.origin?.context ?? Object.freeze({}),
+    get version() {
+      if (version === undefined)
+        throw new Error("statewire: in-process dispatch has no version");
+      return version;
+    },
     get attach() {
       if (attach === undefined)
         throw new Error("statewire: in-process dispatch has no attach");
@@ -445,6 +455,7 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
   const [built] = useState(() => {
     const cell: CommandsCell = {
       context: undefined,
+      version: undefined,
       handlers: null,
       queue: [],
       active: new Map(),
@@ -465,6 +476,7 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
           }
           cell.queue.push({
             context: captureContext(cell.context?.() ?? {}),
+            version: cell.version,
             method,
             params,
             ts: Date.now(),
@@ -507,6 +519,7 @@ export const useStatewireCommands = <THandlers extends Statewire.Commands>(
   });
 
   built.cell.context = options?.context;
+  built.cell.version = options?.version;
   useEffect(() => {
     const { cell } = built;
     cell.unmounted = false;

package/src/host/socket.ts

@@ -3,7 +3,6 @@ import { MAX_CONTEXT_BYTES } from "../wire/limits";
 import { encodeDocument } from "../document";
 import {
   DEFAULT_PROTOCOL,
-  WIRE_VERSION,
   DEFAULT_PROTOCOL_VERSION,
   GAP_FILL_VERSION,
   MIN_SERVED_WIRE_VERSION,
@@ -183,8 +182,9 @@ export type ParsedFrame = {
   res?: { protocol: string; seq: number }[];
 };
 
+// This host serves through the gap-fill wire: it names no attach to retire.
 const SERVED_WIRE: StatewireProtocol.Range = {
-  version: WIRE_VERSION,
+  version: GAP_FILL_VERSION,
   minVersion: MIN_SERVED_WIRE_VERSION,
 };
 
@@ -1147,6 +1147,9 @@ const admitCmd = (
     caller: callerOf(h, rec, conn),
     attach: conn.attach,
     context: captureContext(conn.contexts.get(statement.protocol) ?? {}),
+    version: conn.selection.protocols.find(
+      (p) => p.name === statement.protocol,
+    )!.version,
     onApplied: () => {
       if (adm.settled || adm.applied) return;
       adm.applied = true;

package/src/host.ts

@@ -45,19 +45,27 @@ export namespace StatewireHost {
     setOnDocuments: (listener: (() => void) | null) => void;
   };
 
+  /** What `this.context` and `this.version` read for a call made on the proxy (in-process dispatch). */
+  export type CommandsOptions = {
+    context?: () => Statewire.Context;
+    version?: string;
+  };
+
   /**
    * Per-invocation handle bound as `this` of a command handler: `caller` is
    * the submitting client, `attach` the admitting attach's document view
-   * (in-process dispatch has none — reading it throws), `applied()` states the
-   * broadcast state now contains the command's effects — the client drops its
-   * optimistic overlay — before the handler settles (idempotent, a no-op after
-   * settle). The command settles when the handler's returned promise does.
+   * (in-process dispatch has none — reading it throws), `version` the
+   * command protocol's version that attach negotiated (in-process dispatch
+   * reads `CommandsOptions.version`; without one, reading it throws),
+   * `applied()` states the broadcast state now contains the command's effects
+   * — the client drops its optimistic overlay — before the handler settles
+   * (idempotent, a no-op after settle). The command settles when the
+   * handler's returned promise does.
    */
-  export type CommandsOptions = { context?: () => Statewire.Context };
-
   export type Ctx = {
     readonly caller: Caller;
     readonly context: Statewire.Context;
+    readonly version: string;
     readonly attach: Attach;
     readonly signal: AbortSignal;
     readonly applied: () => void;

package/src/transports/sse.ts

@@ -4,6 +4,7 @@ import type { ResourceElement } from "@assistant-ui/tap";
 import { createSseParser } from "./sse-parser";
 import { timing } from "../client/timing";
 import {
+  replacing,
   settleFin,
   classify,
   handleEnvelope,
@@ -149,6 +150,7 @@ const attemptStream = async (
     if (!headers.has(name)) headers.set(name, value);
   }
   c.negotiation = parseNegotiation(headers);
+  replacing(c, headers);
   c.authStale = false;
   const lanes = flushTapSync(() => c.ctx.takeAttachLanes());
   const body = lanes === null ? undefined : JSON.stringify(lanes);

package/src/wire/protocol.ts

@@ -18,9 +18,17 @@ export namespace StatewireProtocol {
   };
 }
 
-export const WIRE_VERSION = "2026-11-01";
+export const WIRE_VERSION = "2026-11-02";
 /** Attach carries a results cursor and gets its verdicts gap-filled; a re-sent seq at or below the watermark is a protocol error. */
 export const GAP_FILL_VERSION = "2026-11-01";
+/** Every attach of a connection names its attacher; a host retires the attacher's earlier attaches before the hello. */
+export const FENCE_VERSION = "2026-11-02";
+/** The wire a client offers by default: the gap-fill contract and newer. */
+export const CLIENT_WIRE: StatewireProtocol.Range = {
+  version: WIRE_VERSION,
+  minVersion: GAP_FILL_VERSION,
+};
+export const ATTACHER_HEADER = "Statewire-Attacher";
 /** The oldest wire contract a host serves by default (re-sent seqs re-emit their verdicts). */
 export const MIN_SERVED_WIRE_VERSION = "2026-09-30";
 export const DEFAULT_PROTOCOL_VERSION = "2026-09-30";
@@ -81,7 +89,7 @@ export const negotiationHeaders = (
   if (offers !== "*" && !offers.length)
     invalid("protocol list must not be empty");
   return {
-    [VERSION_HEADER]: suffix(options.wireVersion ?? { version: WIRE_VERSION }),
+    [VERSION_HEADER]: suffix(options.wireVersion ?? CLIENT_WIRE),
     [PROTOCOL_HEADER]:
       offers === "*"
         ? "*"
@@ -201,7 +209,7 @@ export const validateSelection = (
     return invalid("missing negotiation selection");
   const syn = value as Record<string, unknown>;
   const version = validateVersion(syn.version);
-  if (!inRange(version, options.wireVersion ?? { version: WIRE_VERSION }))
+  if (!inRange(version, options.wireVersion ?? CLIENT_WIRE))
     invalid("selected wire version is outside offer");
   if (!Array.isArray(syn.protocols))
     return invalid("syn.protocols must be an array");