statewire 0.18.1 → 0.19.0

package/dist/host.d.ts

@@ -2,6 +2,7 @@ import { StatewireReject } from "./host/engine.js";
 import { useStatewireWork } from "./host/work.js";
 import { append } from "./host/draft.js";
 import { getStateHost, useStatewireCommands, useStatewireState } from "./host/host.js";
+import { syncedDocument } from "./host/synced.js";
 import { Statewire } from "./types.js";
 //#region src/host.d.ts
 declare namespace StatewireHost {
@@ -16,19 +17,35 @@ declare namespace StatewireHost {
     /** The committed plain state — immutably replaced per op, so a captured value is a stable snapshot. */
     snapshot: () => TState;
   };
+  type Document = {
+    protocol: string;
+    key: readonly string[] | null;
+    main: boolean;
+    value: unknown;
+  };
   type StateHost = Statewire.StateSource & {
     /** Synchronous, per locally-recorded op; the host owns batching. */
     setOnOp: (listener: ((op: Statewire.Op) => void) | null) => void;
+    /** Mount or replace the shared document `(protocol, key)`; keyed documents reach an attach only once it `include`s them. */
+    mount: (protocol: string, value: unknown, options?: {
+      key?: readonly string[];
+      main?: boolean;
+    }) => void;
+    unmount: (protocol: string, key?: readonly string[]) => void;
+    documents: () => ReadonlyMap<string, Document>;
+    setOnDocuments: (listener: (() => void) | null) => void;
   };
   /**
    * Per-invocation handle bound as `this` of a command handler: `caller` is
-   * the submitting client, `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.
+   * 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.
    */
   type Ctx = {
     readonly caller: Caller;
+    readonly attach: Attach;
     readonly signal: AbortSignal;
     readonly applied: () => void;
   };
@@ -37,16 +54,23 @@ declare namespace StatewireHost {
    * across a long run: `clientId` is the client's `Statewire-Client-Id`
    * (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),
-   * `isConnected` reports whether the client has an active stream attachment.
+   * for a void `authorize` and for in-process dispatch), `isConnected`
+   * reports whether the client has an active stream attachment.
    */
   type Caller = {
     readonly clientId: string;
     readonly auth: unknown;
-    readonly context: Record<string, unknown> | null;
     readonly isConnected: boolean;
   };
+  /** The admitting attach's view: its ephemeral documents plus the shared documents included for it. */
+  type Attach = {
+    document: (protocol: string, key?: readonly string[]) => unknown;
+    /** `protocol` must be ephemeral; the encoded value is bounded by `MAX_EPHEMERAL_DOCUMENT_BYTES`. */
+    mount: (protocol: string, value: unknown, key?: readonly string[], main?: boolean) => void;
+    unmount: (protocol: string, key?: readonly string[]) => void;
+    include: (protocol: string, key: readonly string[]) => void;
+    exclude: (protocol: string, key: readonly string[]) => void;
+  };
   type HandledCommands<THandlers extends Statewire.Commands> = { [K in keyof THandlers]: (...args: Parameters<THandlers[K]>) => Awaited<ReturnType<THandlers[K]>>; };
   type Fin = {
     reason: "reconnect" | "error" | "protocol-error" | "forbidden" | "unauthorized" | "gone" | "idle" | (string & {});
@@ -59,5 +83,5 @@ declare namespace StatewireHost {
   };
 }
 //#endregion
-export { StatewireHost, StatewireReject, append, getStateHost, useStatewireCommands, useStatewireState, useStatewireWork };
+export { StatewireHost, StatewireReject, append, getStateHost, syncedDocument, useStatewireCommands, useStatewireState, useStatewireWork };
 //# sourceMappingURL=host.d.ts.map

package/dist/host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host.d.ts","names":[],"sources":["../src/host.ts"],"mappings":";;;;;;kBAWiB;OACH;aACD;IACT,QAAQ,GAAG,MAAM,QAAQ,OAAO,QAAQ;IACxC,WAAW;;OAGD,SAAS;;IAEnB,QAAQ,cAAc,UAAU;;IAEhC,gBAAgB;;OAGN,YAAY,UAAU;;IAEhC,UAAU,YAAY,IAAI,UAAU;;;;;;;;;OAU1B;aACD,QAAQ;aACR,QAAQ;aACR;;;;;;;;;;;OAYC;aACD;aACA;aACA,SAAS;aACT;;OAGC,gBAAgB,kBAAkB,UAAU,eACrD,WAAW,gBACP,MAAM,WAAW,UAAU,QAC3B,QAAQ,WAAW,UAAU;OAGxB;IACV;IASA;IACA;IACA;IACA;IACA;IACA"}
+{"version":3,"file":"host.d.ts","names":[],"sources":["../src/host.ts"],"mappings":";;;;;;;kBAYiB;OACH;aACD;IACT,QAAQ,GAAG,MAAM,QAAQ,OAAO,QAAQ;IACxC,WAAW;;OAGD,SAAS;;IAEnB,QAAQ,cAAc,UAAU;;IAEhC,gBAAgB;;OAGN;IACV;IACA;IACA;IACA;;OAGU,YAAY,UAAU;;IAEhC,UAAU,YAAY,IAAI,UAAU;;IAEpC,QACE,kBACA,gBACA;MAAY;MAAyB;;IAEvC,UAAU,kBAAkB;IAC5B,iBAAiB,oBAAoB;IACrC,iBAAiB;;;;;;;;;;OAWP;aACD,QAAQ;aACR,QAAQ;aACR,QAAQ;aACR;;;;;;;;;;OAWC;aACD;aACA;aACA;;;OAIC;IACV,WAAW,kBAAkB;;IAE7B,QACE,kBACA,gBACA,yBACA;IAEF,UAAU,kBAAkB;IAC5B,UAAU,kBAAkB;IAC5B,UAAU,kBAAkB;;OAGlB,gBAAgB,kBAAkB,UAAU,eACrD,WAAW,gBACP,MAAM,WAAW,UAAU,QAC3B,QAAQ,WAAW,UAAU;OAGxB;IACV;IASA;IACA;IACA;IACA;IACA;IACA"}

package/dist/host.js

@@ -2,4 +2,5 @@ import { StatewireReject } from "./host/engine.js";
 import { append } from "./host/draft.js";
 import { getStateHost, useStatewireCommands, useStatewireState } from "./host/host.js";
 import { useStatewireWork } from "./host/work.js";
-export { StatewireReject, append, getStateHost, useStatewireCommands, useStatewireState, useStatewireWork };
+import { syncedDocument } from "./host/synced.js";
+export { StatewireReject, append, getStateHost, syncedDocument, useStatewireCommands, useStatewireState, useStatewireWork };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { StatewireDocuments } from "./wire/documents.js";
-import { StatewireProtocol } from "./wire/protocol.js";
+import { DEFAULT_PROTOCOL, StatewireProtocol } from "./wire/protocol.js";
 import { StatewireHttp } from "./transports/sse.js";
 import { StatewireClient, StatewireResource, useStatewire } from "./statewire.js";
 import { Statewire, StatewireSendError } from "./types.js";
 import { StatewireDocument, decodeDocument, encodeDocument } from "./document.js";
 import { StatewireWebsocket } from "./transports/ws.js";
-export { type Statewire, StatewireClient, type StatewireDocument, type StatewireDocuments, StatewireHttp, type StatewireProtocol, StatewireResource, StatewireSendError, StatewireWebsocket, decodeDocument, encodeDocument, useStatewire };
+export { DEFAULT_PROTOCOL, type Statewire, StatewireClient, type StatewireDocument, type StatewireDocuments, StatewireHttp, type StatewireProtocol, StatewireResource, StatewireSendError, StatewireWebsocket, decodeDocument, encodeDocument, useStatewire };

package/dist/index.js

@@ -1,6 +1,7 @@
 import { decodeDocument, encodeDocument } from "./document.js";
+import { DEFAULT_PROTOCOL } from "./wire/protocol.js";
 import { StatewireSendError } from "./types.js";
 import { StatewireClient, StatewireResource, useStatewire } from "./statewire.js";
 import { StatewireHttp } from "./transports/sse.js";
 import { StatewireWebsocket } from "./transports/ws.js";
-export { StatewireClient, StatewireHttp, StatewireResource, StatewireSendError, StatewireWebsocket, decodeDocument, encodeDocument, useStatewire };
+export { DEFAULT_PROTOCOL, StatewireClient, StatewireHttp, StatewireResource, StatewireSendError, StatewireWebsocket, decodeDocument, encodeDocument, useStatewire };

package/dist/statewire.d.ts

@@ -1,6 +1,6 @@
 import { StatewireDocuments } from "./wire/documents.js";
-import { StatewireProtocol } from "./wire/protocol.js";
 import { StatewireHost } from "./host.js";
+import { StatewireProtocol } from "./wire/protocol.js";
 import { TERMINAL } from "./client/connection.js";
 import { Statewire } from "./types.js";
 import { ResourceElement } from "@assistant-ui/tap";
@@ -17,9 +17,7 @@ declare class StatewireClient<TState, TCommands extends Statewire.Commands = Sta
   get documents(): StatewireDocuments.Source | undefined;
   get selection(): StatewireProtocol.Selection | undefined;
   invoke(protocol: string, method: string, params: readonly unknown[]): Promise<unknown>;
-  updateContext(ops: readonly unknown[]): void;
   get isBusy(): boolean;
-  setContext(value: Record<string, unknown>): void;
   get failed(): readonly StatewireClient.FailedCommand[];
   retryFailed(entry: StatewireClient.FailedCommand): Promise<unknown>;
   discardFailed(entry: StatewireClient.FailedCommand): void;
@@ -59,15 +57,12 @@ declare namespace StatewireClient {
     documents: StatewireDocuments.Source | undefined;
     selection: StatewireProtocol.Selection | undefined;
     invoke: (protocol: string, method: string, params: readonly unknown[]) => Promise<unknown>;
-    updateContext: (ops: readonly unknown[]) => void;
     /** Identity-stable across renders; reads the current canonical state without subscribing the caller. */
     getState: () => TState;
     connection: Connection;
     commands: Statewire.CommandsProxy<TCommands>;
     /** Negation of the server's broadcast idle level (a transport without idle is always busy). */
     isBusy: boolean;
-    /** Replace this client's ambient context on the server; throws on transports without a client context channel. */
-    setContext: (value: Record<string, unknown>) => void;
     /** Non-accepted sends retained in the session record; reload with it. */
     failed: readonly FailedCommand[];
     /** Re-enqueues the entry's command on fresh clocks and removes the entry. */
@@ -182,7 +177,6 @@ declare namespace StatewireClient {
   /** A command as persisted while un-durable: its lane seq plus the wire statement. */
   type SessionCommand = {
     seq: number;
-    protocol: string;
     produced?: {
       wire: StatewireProtocol.Range;
       protocols: readonly StatewireProtocol.Offer[] | "*";
@@ -191,26 +185,20 @@ declare namespace StatewireClient {
     params: unknown[];
     meta?: unknown;
   };
-  /** The persisted session: the lane identity, the lane clocks, and the commands the server has not marked durable. */
-  type SessionRecord = {
-    clientId: string;
+  /** A durable lane: its cmd clock and the commands the server has not marked durable. */
+  type SessionLane = {
     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[];
     /** Non-accepted sends retained for the user; survive record rebases and resets. */
     failed?: readonly FailedCommand[];
   };
+  /** The persisted session: the client identity plus one lane per durable protocol. */
+  type SessionRecord = {
+    clientId: string;
+    lanes: Readonly<Record<string, SessionLane>>;
+  };
   /** A terminal verdict one sharer's connection carried, parked for the sharer awaiting the seq. */
   type SessionVerdict = {
     seq: number;

package/dist/statewire.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statewire.d.ts","names":[],"sources":["../src/statewire.ts"],"mappings":"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"}
+{"version":3,"file":"statewire.d.ts","names":[],"sources":["../src/statewire.ts"],"mappings":"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"}

package/dist/statewire.js

@@ -41,18 +41,10 @@ const useStatewire = (options) => {
 				if (!value.invoke) throw new Error("statewire: transport does not support protocol commands");
 				return value.invoke(protocol_0, method, params);
 			},
-			updateContext: (ops) => {
-				if (!value.updateContext) throw new Error("statewire: transport does not support context documents");
-				value.updateContext(ops);
-			},
 			getState: core.getState,
 			connection,
 			commands: core.commands,
 			isBusy,
-			setContext: (contextValue) => {
-				if (!value.setContext) throw new Error("statewire: this transport has no client context channel");
-				value.setContext(contextValue);
-			},
 			failed,
 			retryFailed: (entry) => failures().retry(entry),
 			discardFailed: (entry_0) => failures().discard(entry_0)
@@ -92,15 +84,9 @@ var StatewireClient = class {
 	invoke(protocol, method, params) {
 		return this.root.getValue().invoke(protocol, method, params);
 	}
-	updateContext(ops) {
-		this.root.getValue().updateContext(ops);
-	}
 	get isBusy() {
 		return this.root.getValue().isBusy;
 	}
-	setContext(value) {
-		this.root.getValue().setContext(value);
-	}
 	get failed() {
 		return this.root.getValue().failed;
 	}

package/dist/statewire.js.map

@@ -1 +1 @@
-{"version":3,"file":"statewire.js","names":["StatewireDocuments","StatewireProtocol","StatewireHost","useMemo","useRef","useState","useSyncExternalStore","createTapRoot","flushTapSync","resource","useContextProvider","useResource","useResources","withKey","ResourceElement","CONNECTED_CONNECTION","useStatewireCore","Statewire","TERMINAL","DocumentStorageContext","ProtocolContext","SessionStorageContext","useSessionTransport","transport","session","documents","protocol","StatewireClient","SessionStorage","Storage","Options","SessionTransport","useStatewire","Commands","options","TState","TCommands","Helpers","latest","current","storage","undefined","wireVersion","applicationProtocols","keyPrefixes","value","core","subscribe","listener","state","getState","isBusy","getBusy","failed","getFailed","connection","failures","NonNullable","Error","selection","invoke","method","params","updateContext","ops","commands","CommandsProxy","setContext","contextValue","Record","retryFailed","entry","FailedCommand","retry","discardFailed","discard","StatewireResource","root","disposed","constructor","ClientRoot","getValue","Connection","Source","Selection","Promise","dispose","unmount","Readonly","Range","Offer","initialState","optimistic","Optimistic","materialize","Materialize","onStateChange","ctx","changes","Changes","onCommandChange","update","CommandUpdate","onConnectionChange","onError","error","ConnectionError","failureCovered","ConnectionState","status","reason","degraded","attempt","cause","code","nextRetryAt","lastError","message","payload","reconnect","ConnectionStatus","draft","command","Command","OptimisticContext","ts","seq","clientId","SendFailure","fate","predecessorLost","OnSessionLost","pending","ReadonlyArray","produced","SessionCommand","meta","failure","wire","protocols","SessionRecord","nextSeq","ctxNextSeq","context","recover","verdicts","SessionVerdict","type","ready","flush","load","save","record","migrate","lock","fn","T","fin","Fin","HeadersOption","HeadersInit","staleAuth","HttpOptions","sessionStore","url","isNew","headers","fetch","globalThis","onSessionLost","onChange","onDone","WebsocketOptions","query","webSocket","WebSocket"],"sources":["../src/statewire.ts"],"sourcesContent":["import type { StatewireDocuments } from \"./wire/documents\";\nimport type { StatewireProtocol } from \"./wire/protocol\";\nimport type { StatewireHost } from \"./host\";\nimport { useMemo, useRef, useState, useSyncExternalStore } from \"react\";\nimport {\n  createTapRoot,\n  flushTapSync,\n  resource,\n  useContextProvider,\n  useResource,\n  useResources,\n  withKey,\n} from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { CONNECTED_CONNECTION, useStatewireCore } from \"./client/core\";\nimport type { Statewire } from \"./types\";\nimport type { TERMINAL } from \"./client/connection\";\nimport {\n  DocumentStorageContext,\n  ProtocolContext,\n  SessionStorageContext,\n} from \"./client/sessionStore\";\n\nconst useSessionTransport = ({\n  transport,\n  session,\n  documents,\n  protocol,\n}: {\n  transport: ResourceElement<Statewire<any, any>>;\n  session: StatewireClient.SessionStorage | undefined;\n  documents: StatewireDocuments.Storage | undefined;\n  protocol: StatewireProtocol.Options;\n}): Statewire<unknown> =>\n  useContextProvider(SessionStorageContext, session, () =>\n    // oxlint-disable-next-line react-hooks/rules-of-hooks\n    useContextProvider(DocumentStorageContext, documents, () =>\n      // oxlint-disable-next-line react-hooks/rules-of-hooks\n      useContextProvider(ProtocolContext, protocol, () =>\n        // oxlint-disable-next-line react-hooks/rules-of-hooks\n        useResource(transport),\n      ),\n    ),\n  );\n\n// The transport owns the session; it reads the storage off the context this\n// wrapper's own fiber provides, so plain-React callers get a provider too.\nconst SessionTransport = resource(useSessionTransport);\n\nexport const useStatewire = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireClient.Options<TState, TCommands>,\n): StatewireClient.Helpers<TState, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n\n  const session = useResources(\n    options.storage?.session !== undefined\n      ? [withKey(\"session\", options.storage.session)]\n      : [],\n  )[0];\n  const documents = useResources(\n    options.storage?.documents === undefined\n      ? []\n      : [withKey(\"documents\", options.storage.documents)],\n  )[0];\n  const protocol: StatewireProtocol.Options = {\n    ...(options.protocol !== undefined && { protocol: options.protocol }),\n    ...(options.wireVersion !== undefined && {\n      wireVersion: options.wireVersion,\n    }),\n    ...(options.applicationProtocols !== undefined && {\n      applicationProtocols: options.applicationProtocols,\n    }),\n    ...(options.keyPrefixes !== undefined && {\n      keyPrefixes: options.keyPrefixes,\n    }),\n  };\n  const value = useResource(\n    SessionTransport({\n      transport: options.transport,\n      session,\n      documents,\n      protocol,\n    }),\n  );\n  const core = useStatewireCore(() => latest.current, value);\n  const [subscribe] = useState(\n    () => (listener: () => void) =>\n      core.subscribe(() => flushTapSync(listener)),\n  );\n\n  const state = useSyncExternalStore(\n    subscribe,\n    core.getState,\n    core.getState,\n  ) as TState;\n  const isBusy = useSyncExternalStore(subscribe, core.getBusy, core.getBusy);\n  const failed = useSyncExternalStore(\n    subscribe,\n    core.getFailed,\n    core.getFailed,\n  );\n  const connection = value.connection ?? CONNECTED_CONNECTION;\n\n  return useMemo(() => {\n    const failures = (): NonNullable<typeof value.failures> => {\n      if (!value.failures) {\n        throw new Error(\"statewire: this transport has no failed-send lane\");\n      }\n      return value.failures;\n    };\n    return {\n      state,\n      documents: value.documents,\n      selection: value.selection,\n      invoke: (\n        protocol: string,\n        method: string,\n        params: readonly unknown[],\n      ) => {\n        if (!value.invoke)\n          throw new Error(\n            \"statewire: transport does not support protocol commands\",\n          );\n        return value.invoke(protocol, method, params);\n      },\n      updateContext: (ops: readonly unknown[]) => {\n        if (!value.updateContext)\n          throw new Error(\n            \"statewire: transport does not support context documents\",\n          );\n        value.updateContext(ops);\n      },\n      getState: core.getState as () => TState,\n      connection,\n      commands: core.commands as Statewire.CommandsProxy<TCommands>,\n      isBusy,\n      setContext: (contextValue: Record<string, unknown>) => {\n        if (!value.setContext) {\n          throw new Error(\n            \"statewire: this transport has no client context channel\",\n          );\n        }\n        value.setContext(contextValue);\n      },\n      failed,\n      retryFailed: (entry: StatewireClient.FailedCommand) =>\n        failures().retry(entry),\n      discardFailed: (entry: StatewireClient.FailedCommand) =>\n        failures().discard(entry),\n    };\n  }, [state, isBusy, failed, connection, core, value]);\n};\n\nexport const StatewireResource = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireClient.Options<TState, TCommands>,\n): ResourceElement<StatewireClient.Helpers<TState, TCommands>> =>\n  resource(useStatewire<TState, TCommands>)(options);\n\nexport class StatewireClient<\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n> {\n  private readonly root;\n  private disposed = false;\n\n  constructor(options: StatewireClient.Options<TState, TCommands>) {\n    const ClientRoot = () => useStatewire<TState, TCommands>(options);\n    this.root = createTapRoot(ClientRoot);\n  }\n\n  get state(): TState {\n    return this.root.getValue().getState();\n  }\n\n  get connection(): StatewireClient.Connection {\n    return this.root.getValue().connection;\n  }\n\n  get commands(): Statewire.CommandsProxy<TCommands> {\n    return this.root.getValue().commands;\n  }\n\n  get documents(): StatewireDocuments.Source | undefined {\n    return this.root.getValue().documents;\n  }\n  get selection(): StatewireProtocol.Selection | undefined {\n    return this.root.getValue().selection;\n  }\n  invoke(\n    protocol: string,\n    method: string,\n    params: readonly unknown[],\n  ): Promise<unknown> {\n    return this.root.getValue().invoke(protocol, method, params);\n  }\n  updateContext(ops: readonly unknown[]): void {\n    this.root.getValue().updateContext(ops);\n  }\n\n  get isBusy(): boolean {\n    return this.root.getValue().isBusy;\n  }\n\n  setContext(value: Record<string, unknown>): void {\n    this.root.getValue().setContext(value);\n  }\n\n  get failed(): readonly StatewireClient.FailedCommand[] {\n    return this.root.getValue().failed;\n  }\n\n  retryFailed(entry: StatewireClient.FailedCommand): Promise<unknown> {\n    return this.root.getValue().retryFailed(entry);\n  }\n\n  discardFailed(entry: StatewireClient.FailedCommand): void {\n    this.root.getValue().discardFailed(entry);\n  }\n\n  subscribe(listener: () => void): () => void {\n    return this.root.subscribe(listener);\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.root.unmount();\n  }\n}\n\nexport namespace StatewireClient {\n  export type Options<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = {\n    protocol?: string;\n    keyPrefixes?: Readonly<Record<string, readonly string[]>>;\n    wireVersion?: StatewireProtocol.Range;\n    applicationProtocols?: readonly StatewireProtocol.Offer[] | \"*\";\n    transport: ResourceElement<Statewire<TState, TCommands>>;\n    /** Durable session: the mounted storage holds this client's lane identity and its un-durable commands, which resend on the next attach. */\n    storage?:\n      | {\n          session?: ResourceElement<SessionStorage> | undefined;\n          documents?: ResourceElement<StatewireDocuments.Storage> | undefined;\n        }\n      | undefined;\n    /** Served as the canonical state until the attach snapshot; own commands fold over it. */\n    initialState?: TState;\n    optimistic?: Optimistic<NonNullable<TState>, TCommands>;\n    materialize?: Materialize<NonNullable<TState>>;\n    onStateChange?: (\n      state: NonNullable<TState>,\n      ctx: { changes: Statewire.Changes },\n    ) => void;\n    onCommandChange?: (\n      update: Statewire.CommandUpdate<TCommands>,\n      ctx: { state: NonNullable<TState> },\n    ) => void;\n    onConnectionChange?: (connection: Connection) => void;\n    onError?: (error: ConnectionError) => void;\n    /** Drops a retained failed entry once a canonical snapshot shows its effect landed; checked against each new snapshot. */\n    failureCovered?: (\n      state: NonNullable<TState>,\n      entry: FailedCommand,\n    ) => boolean;\n  };\n\n  export type Helpers<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = {\n    /** The statewire's state type — remote statewires include `undefined` until the first attach snapshot applies. */\n    state: TState;\n    documents: StatewireDocuments.Source | undefined;\n    selection: StatewireProtocol.Selection | undefined;\n    invoke: (\n      protocol: string,\n      method: string,\n      params: readonly unknown[],\n    ) => Promise<unknown>;\n    updateContext: (ops: readonly unknown[]) => void;\n    /** Identity-stable across renders; reads the current canonical state without subscribing the caller. */\n    getState: () => TState;\n    connection: Connection;\n    commands: Statewire.CommandsProxy<TCommands>;\n    /** Negation of the server's broadcast idle level (a transport without idle is always busy). */\n    isBusy: boolean;\n    /** Replace this client's ambient context on the server; throws on transports without a client context channel. */\n    setContext: (value: Record<string, unknown>) => void;\n    /** Non-accepted sends retained in the session record; reload with it. */\n    failed: readonly FailedCommand[];\n    /** Re-enqueues the entry's command on fresh clocks and removes the entry. */\n    retryFailed: (entry: FailedCommand) => Promise<unknown>;\n    /** Removes the entry. */\n    discardFailed: (entry: FailedCommand) => void;\n  };\n\n  /** Connection lifecycle and whether its current state warrants a problem indicator. */\n  export type ConnectionState =\n    | { status: \"standby\"; reason: \"deferred\" | \"idle\"; degraded: false }\n    | { status: \"connecting\"; degraded: false }\n    | { status: \"connected\"; degraded: false }\n    | {\n        status: \"retrying\";\n        degraded: true;\n        attempt: number;\n        /** Backoff details are absent while the retry dial is in flight. */\n        cause?: \"dropped\" | \"reconnect\" | \"error\" | \"unauthorized\";\n        code?: string;\n        nextRetryAt?: number;\n        lastError?: string;\n        message?: string;\n      }\n    | {\n        status: \"stopped\";\n        degraded: true;\n        reason:\n          | \"gone\"\n          | \"forbidden\"\n          | \"protocol-error\"\n          | \"unauthorized\"\n          | \"storage-error\";\n        message?: string;\n        payload?: unknown;\n      };\n  export type Connection = ConnectionState & {\n    error?: ConnectionError;\n    reconnect: () => void;\n  };\n  export type ConnectionStatus = Connection[\"status\"];\n\n  /**\n   * Mutate the draft in place; the client records the next state plus the exact\n   * changed paths. Re-run against the new base on every rebase.\n   */\n  export type Optimistic<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = (\n    draft: TState,\n    command: Statewire.Command<TCommands>,\n    ctx: OptimisticContext,\n  ) => void;\n\n  export type OptimisticContext = {\n    ts: number;\n    seq: number;\n    clientId?: string;\n  };\n\n  /**\n   * Mutate the draft to make server-accepted, still-uncommitted intents in\n   * the state concrete (e.g. dispatch records into messages). Runs after the\n   * optimistic folds on every published state.\n   */\n  export type Materialize<TState> = (draft: TState) => void;\n\n  /**\n   * fate: \"aborted\" = never sent, \"rejected\" = the server refused it\n   * (`code` \"unknown-command\" | \"invalid-params\" for the static rejects,\n   * code-less for handler rejects), \"lost\" = sent but no verdict will ever\n   * arrive — the record is gone (a proven seq gap) or the channel died: it\n   * may or may not have run, \"failed\" = the handler ran and threw,\n   * \"crashed\" = the handler died involuntarily, \"expired\" = settled —\n   * result, rejected, failed, or crashed — but the verdict outlived the\n   * server's retention.\n   * cause is which channel settled it: \"server\" = the server's answer;\n   * the rest are channel deaths the client settled locally.\n   */\n  export type SendFailure =\n    | {\n        fate: \"rejected\";\n        cause: \"server\";\n        code?: string;\n        message?: string;\n        payload?: unknown;\n      }\n    | { fate: \"failed\"; cause: \"server\"; message?: string }\n    | { fate: \"crashed\"; cause: \"server\" }\n    | { fate: \"expired\"; cause: \"server\" }\n    | {\n        fate: \"aborted\";\n        cause: \"unmount\" | \"stream-gone\" | \"session-lost\";\n        predecessorLost?: true;\n      }\n    | {\n        fate: \"lost\";\n        cause: \"unmount\" | \"stream-gone\" | \"session-lost\";\n      };\n\n  /** Held commands a proven record gap settled `{fate: \"lost\", cause: \"session-lost\"}`; return \"requeue\" to re-enqueue them on the reset clocks. */\n  export type OnSessionLost = (\n    pending: ReadonlyArray<{\n      method: string;\n      params: readonly unknown[];\n      ts: number;\n      seq: number;\n      clientId?: string;\n    }>,\n  ) => \"requeue\" | \"drop\";\n\n  /** A non-accepted send retained for the user: the wire statement, its failure, and its original clocks. */\n  export type FailedCommand = {\n    readonly protocol: string;\n    readonly produced?: SessionCommand[\"produced\"];\n    readonly command: string;\n    readonly params: readonly unknown[];\n    readonly meta?: unknown;\n    readonly failure: SendFailure;\n    readonly ts: number;\n    readonly seq: number;\n  };\n\n  /** A command as persisted while un-durable: its lane seq plus the wire statement. */\n  export type SessionCommand = {\n    seq: number;\n    protocol: string;\n    produced?: {\n      wire: StatewireProtocol.Range;\n      protocols: readonly StatewireProtocol.Offer[] | \"*\";\n    };\n    method: string;\n    params: unknown[];\n    meta?: unknown;\n  };\n\n  /** The persisted session: the lane identity, the lane clocks, and the commands the server has not marked durable. */\n  export type SessionRecord = {\n    clientId: string;\n    nextSeq: number;\n    ctxNextSeq: number;\n    context?: {\n      ops: unknown[];\n      pending: { seq: number; ops: unknown[] }[];\n      /** Recover the original wire's unpersisted single-document context after the next hello. */\n      recover?: \"version-1\";\n    };\n    commands: readonly SessionCommand[];\n    /** Terminal verdicts parked for the sharer that minted the seq (shared storage only). */\n    verdicts?: readonly SessionVerdict[];\n    /** Non-accepted sends retained for the user; survive record rebases and resets. */\n    failed?: readonly FailedCommand[];\n  };\n\n  /** A terminal verdict one sharer's connection carried, parked for the sharer awaiting the seq. */\n  export type SessionVerdict = {\n    seq: number;\n    type: (typeof TERMINAL)[number];\n    code?: string;\n    message?: string;\n    payload?: unknown;\n    meta?: unknown;\n  };\n\n  /** Session storage seam with optional asynchronous hydration and persistence. */\n  export type SessionStorage = {\n    /** Resolves when a synchronous load can return the hydrated record. */\n    ready?: Promise<void>;\n    /** Resolves after all queued saves are persisted; awaited before sending statements. */\n    flush?: () => void | Promise<void>;\n    load: () => SessionRecord | null;\n    save: (record: SessionRecord) => void;\n    /** Upgrade incompatible stored commands; null discards the old record and starts a new client identity. */\n    migrate?: (\n      record: SessionRecord,\n      current: NonNullable<SessionCommand[\"produced\"]>,\n    ) => SessionRecord | null;\n    /** Serializes record mutations across sharers; presence marks the storage shared. */\n    lock?: <T>(fn: () => T | Promise<T>) => Promise<T>;\n    /** Notifies of record saves by other sharers; returns unsubscribe. Required alongside `lock`. */\n    subscribe?: (listener: () => void) => () => void;\n  };\n\n  /** Static headers, or a resolver invoked per request/attach; `staleAuth` is true right after an auth rejection. */\n  export type ConnectionError = Error & { fin?: StatewireHost.Fin };\n\n  export type HeadersOption =\n    | HeadersInit\n    | ((ctx: { staleAuth: boolean }) => HeadersInit | Promise<HeadersInit>);\n\n  export type HttpOptions = StatewireProtocol.Options & {\n    sessionStore?: SessionStorage | undefined;\n    url: string;\n    /** The session does not exist on the server yet: the first attach waits for the first command send (or an explicit `reconnect()`). */\n    isNew?: boolean;\n    headers?: HeadersOption;\n    fetch?: typeof globalThis.fetch;\n    onSessionLost?: OnSessionLost;\n    onChange?: (connection: Connection) => void;\n    onError?: (error: ConnectionError) => void;\n    /** The broadcast idle flag's rising edge: the instance went quiet. */\n    onDone?: () => void;\n  };\n\n  export type WebsocketOptions = StatewireProtocol.Options & {\n    sessionStore?: SessionStorage | undefined;\n    url: string;\n    /** The session does not exist on the server yet: the first attach waits for the first command send (or an explicit `reconnect()`). */\n    isNew?: boolean;\n    headers?: HeadersOption;\n    protocols?: string | string[];\n    query?:\n      | Record<string, string>\n      | (() => Record<string, string> | Promise<Record<string, string>>);\n    webSocket?: new (url: string, protocols?: string | string[]) => WebSocket;\n    onSessionLost?: OnSessionLost;\n    onChange?: (connection: Connection) => void;\n    onError?: (error: ConnectionError) => void;\n    /** The broadcast idle flag's rising edge: the instance went quiet. */\n    onDone?: () => void;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"statewire.js","names":["StatewireDocuments","StatewireProtocol","StatewireHost","useMemo","useRef","useState","useSyncExternalStore","createTapRoot","flushTapSync","resource","useContextProvider","useResource","useResources","withKey","ResourceElement","CONNECTED_CONNECTION","useStatewireCore","Statewire","TERMINAL","DocumentStorageContext","ProtocolContext","SessionStorageContext","useSessionTransport","transport","session","documents","protocol","StatewireClient","SessionStorage","Storage","Options","SessionTransport","useStatewire","Commands","options","TState","TCommands","Helpers","latest","current","storage","undefined","wireVersion","applicationProtocols","keyPrefixes","value","core","subscribe","listener","state","getState","isBusy","getBusy","failed","getFailed","connection","failures","NonNullable","Error","selection","invoke","method","params","commands","CommandsProxy","retryFailed","entry","FailedCommand","retry","discardFailed","discard","StatewireResource","root","disposed","constructor","ClientRoot","getValue","Connection","Source","Selection","Promise","dispose","unmount","Readonly","Record","Range","Offer","initialState","optimistic","Optimistic","materialize","Materialize","onStateChange","ctx","changes","Changes","onCommandChange","update","CommandUpdate","onConnectionChange","onError","error","ConnectionError","failureCovered","ConnectionState","status","reason","degraded","attempt","cause","code","nextRetryAt","lastError","message","payload","reconnect","ConnectionStatus","draft","command","Command","OptimisticContext","ts","seq","clientId","SendFailure","fate","predecessorLost","OnSessionLost","pending","ReadonlyArray","produced","SessionCommand","meta","failure","wire","protocols","SessionLane","nextSeq","verdicts","SessionVerdict","SessionRecord","lanes","type","ready","flush","load","save","record","migrate","lock","fn","T","fin","Fin","HeadersOption","HeadersInit","staleAuth","HttpOptions","sessionStore","url","isNew","headers","fetch","globalThis","onSessionLost","onChange","onDone","WebsocketOptions","query","webSocket","WebSocket"],"sources":["../src/statewire.ts"],"sourcesContent":["import type { StatewireDocuments } from \"./wire/documents\";\nimport type { StatewireProtocol } from \"./wire/protocol\";\nimport type { StatewireHost } from \"./host\";\nimport { useMemo, useRef, useState, useSyncExternalStore } from \"react\";\nimport {\n  createTapRoot,\n  flushTapSync,\n  resource,\n  useContextProvider,\n  useResource,\n  useResources,\n  withKey,\n} from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { CONNECTED_CONNECTION, useStatewireCore } from \"./client/core\";\nimport type { Statewire } from \"./types\";\nimport type { TERMINAL } from \"./client/connection\";\nimport {\n  DocumentStorageContext,\n  ProtocolContext,\n  SessionStorageContext,\n} from \"./client/sessionStore\";\n\nconst useSessionTransport = ({\n  transport,\n  session,\n  documents,\n  protocol,\n}: {\n  transport: ResourceElement<Statewire<any, any>>;\n  session: StatewireClient.SessionStorage | undefined;\n  documents: StatewireDocuments.Storage | undefined;\n  protocol: StatewireProtocol.Options;\n}): Statewire<unknown> =>\n  useContextProvider(SessionStorageContext, session, () =>\n    // oxlint-disable-next-line react-hooks/rules-of-hooks\n    useContextProvider(DocumentStorageContext, documents, () =>\n      // oxlint-disable-next-line react-hooks/rules-of-hooks\n      useContextProvider(ProtocolContext, protocol, () =>\n        // oxlint-disable-next-line react-hooks/rules-of-hooks\n        useResource(transport),\n      ),\n    ),\n  );\n\n// The transport owns the session; it reads the storage off the context this\n// wrapper's own fiber provides, so plain-React callers get a provider too.\nconst SessionTransport = resource(useSessionTransport);\n\nexport const useStatewire = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireClient.Options<TState, TCommands>,\n): StatewireClient.Helpers<TState, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n\n  const session = useResources(\n    options.storage?.session !== undefined\n      ? [withKey(\"session\", options.storage.session)]\n      : [],\n  )[0];\n  const documents = useResources(\n    options.storage?.documents === undefined\n      ? []\n      : [withKey(\"documents\", options.storage.documents)],\n  )[0];\n  const protocol: StatewireProtocol.Options = {\n    ...(options.protocol !== undefined && { protocol: options.protocol }),\n    ...(options.wireVersion !== undefined && {\n      wireVersion: options.wireVersion,\n    }),\n    ...(options.applicationProtocols !== undefined && {\n      applicationProtocols: options.applicationProtocols,\n    }),\n    ...(options.keyPrefixes !== undefined && {\n      keyPrefixes: options.keyPrefixes,\n    }),\n  };\n  const value = useResource(\n    SessionTransport({\n      transport: options.transport,\n      session,\n      documents,\n      protocol,\n    }),\n  );\n  const core = useStatewireCore(() => latest.current, value);\n  const [subscribe] = useState(\n    () => (listener: () => void) =>\n      core.subscribe(() => flushTapSync(listener)),\n  );\n\n  const state = useSyncExternalStore(\n    subscribe,\n    core.getState,\n    core.getState,\n  ) as TState;\n  const isBusy = useSyncExternalStore(subscribe, core.getBusy, core.getBusy);\n  const failed = useSyncExternalStore(\n    subscribe,\n    core.getFailed,\n    core.getFailed,\n  );\n  const connection = value.connection ?? CONNECTED_CONNECTION;\n\n  return useMemo(() => {\n    const failures = (): NonNullable<typeof value.failures> => {\n      if (!value.failures) {\n        throw new Error(\"statewire: this transport has no failed-send lane\");\n      }\n      return value.failures;\n    };\n    return {\n      state,\n      documents: value.documents,\n      selection: value.selection,\n      invoke: (\n        protocol: string,\n        method: string,\n        params: readonly unknown[],\n      ) => {\n        if (!value.invoke)\n          throw new Error(\n            \"statewire: transport does not support protocol commands\",\n          );\n        return value.invoke(protocol, method, params);\n      },\n      getState: core.getState as () => TState,\n      connection,\n      commands: core.commands as Statewire.CommandsProxy<TCommands>,\n      isBusy,\n      failed,\n      retryFailed: (entry: StatewireClient.FailedCommand) =>\n        failures().retry(entry),\n      discardFailed: (entry: StatewireClient.FailedCommand) =>\n        failures().discard(entry),\n    };\n  }, [state, isBusy, failed, connection, core, value]);\n};\n\nexport const StatewireResource = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireClient.Options<TState, TCommands>,\n): ResourceElement<StatewireClient.Helpers<TState, TCommands>> =>\n  resource(useStatewire<TState, TCommands>)(options);\n\nexport class StatewireClient<\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n> {\n  private readonly root;\n  private disposed = false;\n\n  constructor(options: StatewireClient.Options<TState, TCommands>) {\n    const ClientRoot = () => useStatewire<TState, TCommands>(options);\n    this.root = createTapRoot(ClientRoot);\n  }\n\n  get state(): TState {\n    return this.root.getValue().getState();\n  }\n\n  get connection(): StatewireClient.Connection {\n    return this.root.getValue().connection;\n  }\n\n  get commands(): Statewire.CommandsProxy<TCommands> {\n    return this.root.getValue().commands;\n  }\n\n  get documents(): StatewireDocuments.Source | undefined {\n    return this.root.getValue().documents;\n  }\n  get selection(): StatewireProtocol.Selection | undefined {\n    return this.root.getValue().selection;\n  }\n  invoke(\n    protocol: string,\n    method: string,\n    params: readonly unknown[],\n  ): Promise<unknown> {\n    return this.root.getValue().invoke(protocol, method, params);\n  }\n  get isBusy(): boolean {\n    return this.root.getValue().isBusy;\n  }\n\n  get failed(): readonly StatewireClient.FailedCommand[] {\n    return this.root.getValue().failed;\n  }\n\n  retryFailed(entry: StatewireClient.FailedCommand): Promise<unknown> {\n    return this.root.getValue().retryFailed(entry);\n  }\n\n  discardFailed(entry: StatewireClient.FailedCommand): void {\n    this.root.getValue().discardFailed(entry);\n  }\n\n  subscribe(listener: () => void): () => void {\n    return this.root.subscribe(listener);\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.root.unmount();\n  }\n}\n\nexport namespace StatewireClient {\n  export type Options<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = {\n    protocol?: string;\n    keyPrefixes?: Readonly<Record<string, readonly string[]>>;\n    wireVersion?: StatewireProtocol.Range;\n    applicationProtocols?: readonly StatewireProtocol.Offer[] | \"*\";\n    transport: ResourceElement<Statewire<TState, TCommands>>;\n    /** Durable session: the mounted storage holds this client's lane identity and its un-durable commands, which resend on the next attach. */\n    storage?:\n      | {\n          session?: ResourceElement<SessionStorage> | undefined;\n          documents?: ResourceElement<StatewireDocuments.Storage> | undefined;\n        }\n      | undefined;\n    /** Served as the canonical state until the attach snapshot; own commands fold over it. */\n    initialState?: TState;\n    optimistic?: Optimistic<NonNullable<TState>, TCommands>;\n    materialize?: Materialize<NonNullable<TState>>;\n    onStateChange?: (\n      state: NonNullable<TState>,\n      ctx: { changes: Statewire.Changes },\n    ) => void;\n    onCommandChange?: (\n      update: Statewire.CommandUpdate<TCommands>,\n      ctx: { state: NonNullable<TState> },\n    ) => void;\n    onConnectionChange?: (connection: Connection) => void;\n    onError?: (error: ConnectionError) => void;\n    /** Drops a retained failed entry once a canonical snapshot shows its effect landed; checked against each new snapshot. */\n    failureCovered?: (\n      state: NonNullable<TState>,\n      entry: FailedCommand,\n    ) => boolean;\n  };\n\n  export type Helpers<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = {\n    /** The statewire's state type — remote statewires include `undefined` until the first attach snapshot applies. */\n    state: TState;\n    documents: StatewireDocuments.Source | undefined;\n    selection: StatewireProtocol.Selection | undefined;\n    invoke: (\n      protocol: string,\n      method: string,\n      params: readonly unknown[],\n    ) => Promise<unknown>;\n    /** Identity-stable across renders; reads the current canonical state without subscribing the caller. */\n    getState: () => TState;\n    connection: Connection;\n    commands: Statewire.CommandsProxy<TCommands>;\n    /** Negation of the server's broadcast idle level (a transport without idle is always busy). */\n    isBusy: boolean;\n    /** Non-accepted sends retained in the session record; reload with it. */\n    failed: readonly FailedCommand[];\n    /** Re-enqueues the entry's command on fresh clocks and removes the entry. */\n    retryFailed: (entry: FailedCommand) => Promise<unknown>;\n    /** Removes the entry. */\n    discardFailed: (entry: FailedCommand) => void;\n  };\n\n  /** Connection lifecycle and whether its current state warrants a problem indicator. */\n  export type ConnectionState =\n    | { status: \"standby\"; reason: \"deferred\" | \"idle\"; degraded: false }\n    | { status: \"connecting\"; degraded: false }\n    | { status: \"connected\"; degraded: false }\n    | {\n        status: \"retrying\";\n        degraded: true;\n        attempt: number;\n        /** Backoff details are absent while the retry dial is in flight. */\n        cause?: \"dropped\" | \"reconnect\" | \"error\" | \"unauthorized\";\n        code?: string;\n        nextRetryAt?: number;\n        lastError?: string;\n        message?: string;\n      }\n    | {\n        status: \"stopped\";\n        degraded: true;\n        reason:\n          | \"gone\"\n          | \"forbidden\"\n          | \"protocol-error\"\n          | \"unauthorized\"\n          | \"storage-error\";\n        message?: string;\n        payload?: unknown;\n      };\n  export type Connection = ConnectionState & {\n    error?: ConnectionError;\n    reconnect: () => void;\n  };\n  export type ConnectionStatus = Connection[\"status\"];\n\n  /**\n   * Mutate the draft in place; the client records the next state plus the exact\n   * changed paths. Re-run against the new base on every rebase.\n   */\n  export type Optimistic<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = (\n    draft: TState,\n    command: Statewire.Command<TCommands>,\n    ctx: OptimisticContext,\n  ) => void;\n\n  export type OptimisticContext = {\n    ts: number;\n    seq: number;\n    clientId?: string;\n  };\n\n  /**\n   * Mutate the draft to make server-accepted, still-uncommitted intents in\n   * the state concrete (e.g. dispatch records into messages). Runs after the\n   * optimistic folds on every published state.\n   */\n  export type Materialize<TState> = (draft: TState) => void;\n\n  /**\n   * fate: \"aborted\" = never sent, \"rejected\" = the server refused it\n   * (`code` \"unknown-command\" | \"invalid-params\" for the static rejects,\n   * code-less for handler rejects), \"lost\" = sent but no verdict will ever\n   * arrive — the record is gone (a proven seq gap) or the channel died: it\n   * may or may not have run, \"failed\" = the handler ran and threw,\n   * \"crashed\" = the handler died involuntarily, \"expired\" = settled —\n   * result, rejected, failed, or crashed — but the verdict outlived the\n   * server's retention.\n   * cause is which channel settled it: \"server\" = the server's answer;\n   * the rest are channel deaths the client settled locally.\n   */\n  export type SendFailure =\n    | {\n        fate: \"rejected\";\n        cause: \"server\";\n        code?: string;\n        message?: string;\n        payload?: unknown;\n      }\n    | { fate: \"failed\"; cause: \"server\"; message?: string }\n    | { fate: \"crashed\"; cause: \"server\" }\n    | { fate: \"expired\"; cause: \"server\" }\n    | {\n        fate: \"aborted\";\n        cause: \"unmount\" | \"stream-gone\" | \"session-lost\";\n        predecessorLost?: true;\n      }\n    | {\n        fate: \"lost\";\n        cause: \"unmount\" | \"stream-gone\" | \"session-lost\";\n      };\n\n  /** Held commands a proven record gap settled `{fate: \"lost\", cause: \"session-lost\"}`; return \"requeue\" to re-enqueue them on the reset clocks. */\n  export type OnSessionLost = (\n    pending: ReadonlyArray<{\n      method: string;\n      params: readonly unknown[];\n      ts: number;\n      seq: number;\n      clientId?: string;\n    }>,\n  ) => \"requeue\" | \"drop\";\n\n  /** A non-accepted send retained for the user: the wire statement, its failure, and its original clocks. */\n  export type FailedCommand = {\n    readonly protocol: string;\n    readonly produced?: SessionCommand[\"produced\"];\n    readonly command: string;\n    readonly params: readonly unknown[];\n    readonly meta?: unknown;\n    readonly failure: SendFailure;\n    readonly ts: number;\n    readonly seq: number;\n  };\n\n  /** A command as persisted while un-durable: its lane seq plus the wire statement. */\n  export type SessionCommand = {\n    seq: number;\n    produced?: {\n      wire: StatewireProtocol.Range;\n      protocols: readonly StatewireProtocol.Offer[] | \"*\";\n    };\n    method: string;\n    params: unknown[];\n    meta?: unknown;\n  };\n\n  /** A durable lane: its cmd clock and the commands the server has not marked durable. */\n  export type SessionLane = {\n    nextSeq: number;\n    commands: readonly SessionCommand[];\n    /** Terminal verdicts parked for the sharer that minted the seq (shared storage only). */\n    verdicts?: readonly SessionVerdict[];\n    /** Non-accepted sends retained for the user; survive record rebases and resets. */\n    failed?: readonly FailedCommand[];\n  };\n\n  /** The persisted session: the client identity plus one lane per durable protocol. */\n  export type SessionRecord = {\n    clientId: string;\n    lanes: Readonly<Record<string, SessionLane>>;\n  };\n\n  /** A terminal verdict one sharer's connection carried, parked for the sharer awaiting the seq. */\n  export type SessionVerdict = {\n    seq: number;\n    type: (typeof TERMINAL)[number];\n    code?: string;\n    message?: string;\n    payload?: unknown;\n    meta?: unknown;\n  };\n\n  /** Session storage seam with optional asynchronous hydration and persistence. */\n  export type SessionStorage = {\n    /** Resolves when a synchronous load can return the hydrated record. */\n    ready?: Promise<void>;\n    /** Resolves after all queued saves are persisted; awaited before sending statements. */\n    flush?: () => void | Promise<void>;\n    load: () => SessionRecord | null;\n    save: (record: SessionRecord) => void;\n    /** Upgrade incompatible stored commands; null discards the old record and starts a new client identity. */\n    migrate?: (\n      record: SessionRecord,\n      current: NonNullable<SessionCommand[\"produced\"]>,\n    ) => SessionRecord | null;\n    /** Serializes record mutations across sharers; presence marks the storage shared. */\n    lock?: <T>(fn: () => T | Promise<T>) => Promise<T>;\n    /** Notifies of record saves by other sharers; returns unsubscribe. Required alongside `lock`. */\n    subscribe?: (listener: () => void) => () => void;\n  };\n\n  /** Static headers, or a resolver invoked per request/attach; `staleAuth` is true right after an auth rejection. */\n  export type ConnectionError = Error & { fin?: StatewireHost.Fin };\n\n  export type HeadersOption =\n    | HeadersInit\n    | ((ctx: { staleAuth: boolean }) => HeadersInit | Promise<HeadersInit>);\n\n  export type HttpOptions = StatewireProtocol.Options & {\n    sessionStore?: SessionStorage | undefined;\n    url: string;\n    /** The session does not exist on the server yet: the first attach waits for the first command send (or an explicit `reconnect()`). */\n    isNew?: boolean;\n    headers?: HeadersOption;\n    fetch?: typeof globalThis.fetch;\n    onSessionLost?: OnSessionLost;\n    onChange?: (connection: Connection) => void;\n    onError?: (error: ConnectionError) => void;\n    /** The broadcast idle flag's rising edge: the instance went quiet. */\n    onDone?: () => void;\n  };\n\n  export type WebsocketOptions = StatewireProtocol.Options & {\n    sessionStore?: SessionStorage | undefined;\n    url: string;\n    /** The session does not exist on the server yet: the first attach waits for the first command send (or an explicit `reconnect()`). */\n    isNew?: boolean;\n    headers?: HeadersOption;\n    protocols?: string | string[];\n    query?:\n      | Record<string, string>\n      | (() => Record<string, string> | Promise<Record<string, string>>);\n    webSocket?: new (url: string, protocols?: string | string[]) => WebSocket;\n    onSessionLost?: OnSessionLost;\n    onChange?: (connection: Connection) => void;\n    onError?: (error: ConnectionError) => void;\n    /** The broadcast idle flag's rising edge: the instance went quiet. */\n    onDone?: () => void;\n  };\n}\n"],"mappings":"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"}

package/dist/storage.d.ts

@@ -15,11 +15,8 @@ declare namespace KeyValueSessionStorage {
     backend: Backend;
     key: string;
     namespace?: string;
-    /** The application format used by sessions saved before version negotiation. */
-    legacyProtocol?: {
-      name: string;
-      version: string;
-    };
+    /** The lane that sessions saved in a single-lane format lift into; defaults to the client's default protocol. */
+    protocol?: string;
     migrate?: StatewireClient.SessionStorage["migrate"];
     retention?: {
       maxAgeMs?: number;

package/dist/storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","names":[],"sources":["../src/storage.ts"],"mappings":";;;cAmkBa,oDAAsB,SAAA,gBAAA,iBAAA,SAAA,uBAAA;kBAElB;OACH;IACV,UAAU,gCAAgC;IAC1C,UAAU,aAAa,yBAAyB;IAChD,aAAa,uBAAuB;IACpC,uCAAuC;;IAEvC,cAAc,aAAa,cAAc,kBAAkB;;OAEjD;IACV,SAAS;IACT;IACA;;IAEA;MAAmB;MAAc;;IACjC,UAAU,gBAAgB;IAC1B;MAAc;MAAmB;;IACjC,WAAW"}
+{"version":3,"file":"storage.d.ts","names":[],"sources":["../src/storage.ts"],"mappings":";;;cAggBa,oDAAsB,SAAA,gBAAA,iBAAA,SAAA,uBAAA;kBAElB;OACH;IACV,UAAU,gCAAgC;IAC1C,UAAU,aAAa,yBAAyB;IAChD,aAAa,uBAAuB;IACpC,uCAAuC;;IAEvC,cAAc,aAAa,cAAc,kBAAkB;;OAEjD;IACV,SAAS;IACT;IACA;;IAEA;IACA,UAAU,gBAAgB;IAC1B;MAAc;MAAmB;;IACjC,WAAW"}

package/dist/storage.js

@@ -1,5 +1,4 @@
-import { negotiationHeaders, protocolToken } from "./wire/protocol.js";
-import { applyDocumentOps } from "./wire/documents.js";
+import { DEFAULT_PROTOCOL, negotiationHeaders, protocolToken } from "./wire/protocol.js";
 import { wrapStorageError } from "./client/storageError.js";
 import { useEffect, useMemo, useRef } from "@assistant-ui/tap/react-shim";
 import { resource } from "@assistant-ui/tap";
@@ -22,7 +21,9 @@ const isSendFailure = (value) => {
 	}
 };
 const isFailedCommand = (value) => isRecord(value) && isProtocol(value["protocol"]) && isProducer(value["produced"]) && typeof value["command"] === "string" && Array.isArray(value["params"]) && isSendFailure(value["failure"]) && typeof value["ts"] === "number" && Number.isFinite(value["ts"]) && isPositiveSafeInteger(value["seq"]);
-const isSessionRecord = (value) => 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"] === void 0 || Array.isArray(value["verdicts"]) && value["verdicts"].every(isSessionVerdict)) && (value["failed"] === void 0 || Array.isArray(value["failed"]) && value["failed"].every(isFailedCommand));
+const isSessionLane = (value) => isRecord(value) && isPositiveSafeInteger(value["nextSeq"]) && Array.isArray(value["commands"]) && value["commands"].every(isSessionCommand) && (value["verdicts"] === void 0 || Array.isArray(value["verdicts"]) && value["verdicts"].every(isSessionVerdict)) && (value["failed"] === void 0 || Array.isArray(value["failed"]) && value["failed"].every(isFailedCommand));
+const isClientId = (value) => typeof value === "string" && value.length > 0;
+const isSessionRecord = (value) => isRecord(value) && isClientId(value["clientId"]) && isRecord(value["lanes"]) && Object.keys(value["lanes"]).every(isProtocol) && Object.values(value["lanes"]).every(isSessionLane);
 const isProtocol = (value) => value === void 0 || typeof value === "string" && value !== "*" && protocolToken.test(value);
 const isProducer = (value) => {
 	if (value === void 0) return true;
@@ -37,80 +38,49 @@ const isProducer = (value) => {
 		return false;
 	}
 };
-const isContextOperation = (value) => {
-	if (!isRecord(value)) return false;
-	if (value["doc"] !== void 0 && (typeof value["doc"] !== "number" || !Number.isSafeInteger(value["doc"]) || value["doc"] < 0)) return false;
-	if (value["op"] === "mount") try {
-		applyDocumentOps({
-			mode: "mounted",
-			documents: /* @__PURE__ */ new Map()
-		}, [value], void 0, true);
-		return true;
-	} catch {
-		return false;
-	}
-	if (value["op"] === "unmount") return true;
-	if (![
-		"add",
-		"replace",
-		"remove"
-	].includes(value["op"])) 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) => {
-	if (value === void 0) return true;
-	if (!isRecord(value) || !Array.isArray(value["ops"]) || !Array.isArray(value["pending"])) return false;
-	if (value["recover"] !== void 0 && value["recover"] !== "version-1") return false;
-	try {
-		const documents = applyDocumentOps({
-			mode: "mounted",
-			documents: /* @__PURE__ */ new Map()
-		}, value["ops"], void 0, 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 invalid = () => {
+	throw new Error("statewire: invalid stored session record");
 };
-const decode = (raw, legacyProtocol) => {
-	if (raw === null) return null;
-	const parsed = JSON.parse(raw);
-	if (!isSessionRecord(parsed)) throw new Error("statewire: invalid stored session record");
-	const { statewireStorageVersion: format, savedAt: _savedAt, ...value } = parsed;
-	if (!isSessionRecord(value)) throw new Error("statewire: invalid stored session record");
-	if (format !== void 0 && format !== 1) throw new Error("statewire: unsupported session storage version");
-	if (legacyProtocol === void 0 || format !== void 0) return value;
-	const produced = {
-		wire: { version: "2026-09-07" },
-		protocols: [legacyProtocol]
+const liftLegacy = (value, protocol) => {
+	const { clientId, nextSeq, commands, verdicts, failed } = value;
+	const lane = {
+		nextSeq,
+		commands: [],
+		...verdicts !== void 0 && { verdicts }
 	};
+	if (!isClientId(clientId) || !isSessionLane(lane) || !Array.isArray(commands)) return invalid();
+	const legacyCommands = commands;
+	if (!legacyCommands.every(isSessionCommand)) return invalid();
+	if (failed !== void 0 && (!Array.isArray(failed) || !failed.every(isFailedCommand))) return invalid();
+	const lanes = { [protocol]: {
+		...lane,
+		commands: legacyCommands.filter((command) => (command.protocol ?? protocol) === protocol).map(({ protocol: _protocol, ...command }) => command)
+	} };
+	for (const entry of failed ?? []) {
+		const target = lanes[entry.protocol] ?? {
+			nextSeq: 1,
+			commands: []
+		};
+		lanes[entry.protocol] = {
+			...target,
+			failed: [...target.failed ?? [], entry]
+		};
+	}
 	return {
-		...value,
-		...value.context === void 0 && value.ctxNextSeq > 1 ? { context: {
-			ops: [{
-				op: "mount",
-				protocol: legacyProtocol.name,
-				main: true,
-				value: {}
-			}],
-			pending: [],
-			recover: "version-1"
-		} } : {},
-		commands: value.commands.map((command) => command.produced === void 0 ? {
-			...command,
-			protocol: command.protocol ?? legacyProtocol.name,
-			produced
-		} : command),
-		...value.failed === void 0 ? {} : { failed: value.failed.map((entry) => ({
-			...entry,
-			protocol: entry.protocol ?? legacyProtocol.name,
-			produced: entry.produced ?? produced
-		})) }
+		clientId,
+		lanes
 	};
 };
+const normalize = (parsed, protocol) => {
+	if (!isRecord(parsed)) return invalid();
+	const { statewireStorageVersion: format, savedAt: _savedAt, ...value } = parsed;
+	if (format === 3) return isSessionRecord(value) ? value : invalid();
+	if (format !== void 0 && format !== 1 && format !== 2) throw new Error("statewire: unsupported session storage version");
+	const { ctxNextSeq: _ctxNextSeq, context: _context, ...legacy } = value;
+	return liftLegacy(legacy, protocol);
+};
+const decode = (raw, protocol) => raw === null ? null : normalize(JSON.parse(raw), protocol);
+const isEmpty = (record) => Object.values(record.lanes).every((lane) => lane.commands.length === 0 && !lane.failed?.length);
 const active = /* @__PURE__ */ new WeakMap();
 const sweep = async (options, currentKey, quota = false) => {
 	const { backend, retention, namespace = "" } = options;
@@ -124,9 +94,11 @@ const sweep = async (options, currentKey, quota = false) => {
 		} catch {
 			return;
 		}
-		const format = isRecord(value) ? value["statewireStorageVersion"] : void 0;
-		if (format !== void 0 && format !== 1) return void 0;
-		if (!isSessionRecord(value) || value.commands.length || value.failed?.length || value.context?.pending.length) return void 0;
+		try {
+			if (!isEmpty(normalize(value, "default"))) return void 0;
+		} catch {
+			return;
+		}
 		const savedAt = value["savedAt"] ?? value["updatedAt"];
 		return typeof savedAt === "number" && Number.isFinite(savedAt) ? savedAt : void 0;
 	};
@@ -159,16 +131,10 @@ const sweep = async (options, currentKey, quota = false) => {
 };
 const isQuotaError = (error) => error instanceof Error && error.name === "QuotaExceededError";
 const useKeyValueSessionStorage = (options) => {
-	const { backend, key, namespace = "", legacyProtocol: suppliedLegacyProtocol, migrate, retention: suppliedRetention, onError } = options;
+	const { backend, key, namespace = "", protocol = DEFAULT_PROTOCOL, migrate, retention: suppliedRetention, onError } = options;
 	const latestErrorHandler = useRef(onError);
 	latestErrorHandler.current = onError;
 	const reportError = useMemo(() => (error) => latestErrorHandler.current?.(error), []);
-	const legacyName = suppliedLegacyProtocol?.name;
-	const legacyVersion = suppliedLegacyProtocol?.version;
-	const legacyProtocol = useMemo(() => legacyName === void 0 ? void 0 : {
-		name: legacyName,
-		version: legacyVersion
-	}, [legacyName, legacyVersion]);
 	const retain = suppliedRetention !== void 0;
 	const maxAgeMs = suppliedRetention?.maxAgeMs;
 	const maxEntries = suppliedRetention?.maxEntries;
@@ -192,7 +158,6 @@ const useKeyValueSessionStorage = (options) => {
 		retention
 	]);
 	const storageKey = namespace + key;
-	if (legacyProtocol !== void 0) negotiationHeaders({ applicationProtocols: [legacyProtocol] });
 	if (retention !== void 0) {
 		if (!namespace) throw new Error("statewire: session retention requires a namespace");
 		if (!backend.getAllKeys) throw new Error("statewire: session retention requires getAllKeys");
@@ -219,7 +184,7 @@ const useKeyValueSessionStorage = (options) => {
 		};
 		if (state.asynchronous) {
 			state.ready = Promise.resolve(raw).then((value) => {
-				state.record = decode(value, legacyProtocol);
+				state.record = decode(value, protocol);
 				state.hydrated = true;
 			}).catch((cause_0) => {
 				const error_1 = wrapStorageError(cause_0);
@@ -229,7 +194,7 @@ const useKeyValueSessionStorage = (options) => {
 			});
 			state.ready.catch(() => {});
 		} else try {
-			state.record = decode(raw, legacyProtocol);
+			state.record = decode(raw, protocol);
 		} catch (cause_1) {
 			const error_2 = wrapStorageError(cause_1);
 			reportError(error_2);
@@ -239,7 +204,7 @@ const useKeyValueSessionStorage = (options) => {
 	}, [
 		backend,
 		storageKey,
-		legacyProtocol,
+		protocol,
 		reportError
 	]);
 	useEffect(() => {
@@ -281,7 +246,7 @@ const useKeyValueSessionStorage = (options) => {
 			}
 			if (typeof raw_0 !== "string" && raw_0 !== null) throw new Error("statewire: storage backend changed from synchronous to asynchronous");
 			try {
-				return decode(raw_0, legacyProtocol);
+				return decode(raw_0, protocol);
 			} catch (cause_4) {
 				const error_5 = wrapStorageError(cause_4);
 				reportError(error_5);
@@ -294,7 +259,7 @@ const useKeyValueSessionStorage = (options) => {
 			if (!isSessionRecord(record)) throw new Error("statewire: invalid session record");
 			const encoded = JSON.stringify({
 				...record,
-				statewireStorageVersion: 1,
+				statewireStorageVersion: 3,
 				savedAt: Date.now()
 			});
 			state_0.record = record;
@@ -356,7 +321,7 @@ const useKeyValueSessionStorage = (options) => {
 		state_0,
 		backend,
 		storageKey,
-		legacyProtocol,
+		protocol,
 		migrate,
 		retention,
 		configured,