statewire 0.19.0 → 0.19.2

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

@@ -1,9 +1,9 @@
 import { CONNECTED_CONNECTION, useStatewireCore } from "./client/core.js";
-import { DocumentStorageContext, ProtocolContext, SessionStorageContext } from "./client/sessionStore.js";
-import { useMemo, useRef, useState, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
+import { DocumentStorageContext, LinkContext, ProtocolContext, SessionStorageContext } from "./client/sessionStore.js";
+import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
 import { createTapRoot, flushTapSync, resource, useContextProvider, useResource, useResources, withKey } from "@assistant-ui/tap";
 //#region src/statewire.ts
-const useSessionTransport = ({ transport, session, documents, protocol }) => useContextProvider(SessionStorageContext, session, () => useContextProvider(DocumentStorageContext, documents, () => useContextProvider(ProtocolContext, protocol, () => useResource(transport))));
+const useSessionTransport = ({ transport, session, documents, protocol, link }) => useContextProvider(SessionStorageContext, session, () => useContextProvider(DocumentStorageContext, documents, () => useContextProvider(ProtocolContext, protocol, () => useContextProvider(LinkContext, link, () => useResource(transport)))));
 const SessionTransport = resource(useSessionTransport);
 const useStatewire = (options) => {
 	const latest = useRef(options);
@@ -16,31 +16,36 @@ const useStatewire = (options) => {
 		...options.applicationProtocols !== void 0 && { applicationProtocols: options.applicationProtocols },
 		...options.keyPrefixes !== void 0 && { keyPrefixes: options.keyPrefixes }
 	};
+	const link = useMemo(() => options.isNew === void 0 ? {} : { isNew: options.isNew }, [options.isNew]);
 	const value = useResource(SessionTransport({
 		transport: options.transport,
 		session,
 		documents,
-		protocol
+		protocol,
+		link
 	}));
 	const core = useStatewireCore(() => latest.current, value);
+	useEffect(() => core.rematerialize(), [core, options.materializeKey]);
 	const [subscribe] = useState(() => (listener) => core.subscribe(() => flushTapSync(listener)));
 	const state = useSyncExternalStore(subscribe, core.getState, core.getState);
 	const isBusy = useSyncExternalStore(subscribe, core.getBusy, core.getBusy);
 	const failed = useSyncExternalStore(subscribe, core.getFailed, core.getFailed);
 	const connection = value.connection ?? CONNECTED_CONNECTION;
+	const { documents: source, selection, invoke: transportInvoke, failures: transportFailures } = value;
+	const invoke = useCallback((protocol_0, method, params) => {
+		if (!transportInvoke) throw new Error("statewire: transport does not support protocol commands");
+		return transportInvoke(protocol_0, method, params);
+	}, [transportInvoke]);
 	return useMemo(() => {
 		const failures = () => {
-			if (!value.failures) throw new Error("statewire: this transport has no failed-send lane");
-			return value.failures;
+			if (!transportFailures) throw new Error("statewire: this transport has no failed-send lane");
+			return transportFailures;
 		};
 		return {
 			state,
-			documents: value.documents,
-			selection: value.selection,
-			invoke: (protocol_0, method, params) => {
-				if (!value.invoke) throw new Error("statewire: transport does not support protocol commands");
-				return value.invoke(protocol_0, method, params);
-			},
+			documents: source,
+			selection,
+			invoke,
 			getState: core.getState,
 			connection,
 			commands: core.commands,
@@ -55,7 +60,10 @@ const useStatewire = (options) => {
 		failed,
 		connection,
 		core,
-		value
+		source,
+		selection,
+		invoke,
+		transportFailures
 	]);
 };
 const StatewireResource = (options) => resource(useStatewire)(options);

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","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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"}
+{"version":3,"file":"statewire.js","names":["StatewireDocuments","StatewireProtocol","StatewireHost","useCallback","useEffect","useMemo","useRef","useState","useSyncExternalStore","createTapRoot","flushTapSync","resource","useContextProvider","useResource","useResources","withKey","ResourceElement","CONNECTED_CONNECTION","useStatewireCore","Statewire","TERMINAL","DocumentStorageContext","LinkContext","ProtocolContext","SessionStorageContext","useSessionTransport","transport","session","documents","protocol","link","StatewireClient","SessionStorage","Storage","Options","isNew","SessionTransport","useStatewire","Commands","options","TState","TCommands","Helpers","latest","current","storage","undefined","wireVersion","applicationProtocols","keyPrefixes","value","core","rematerialize","materializeKey","subscribe","listener","state","getState","isBusy","getBusy","failed","getFailed","connection","source","selection","invoke","transportInvoke","failures","transportFailures","method","params","Error","NonNullable","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","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 {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} 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  LinkContext,\n  ProtocolContext,\n  SessionStorageContext,\n} from \"./client/sessionStore\";\n\nconst useSessionTransport = ({\n  transport,\n  session,\n  documents,\n  protocol,\n  link,\n}: {\n  transport: ResourceElement<Statewire<any, any>>;\n  session: StatewireClient.SessionStorage | undefined;\n  documents: StatewireDocuments.Storage | undefined;\n  protocol: StatewireProtocol.Options;\n  link: { isNew?: boolean | undefined };\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        useContextProvider(LinkContext, link, () =>\n          // oxlint-disable-next-line react-hooks/rules-of-hooks\n          useResource(transport),\n        ),\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 link = useMemo(\n    () => (options.isNew === undefined ? {} : { isNew: options.isNew }),\n    [options.isNew],\n  );\n  const value = useResource(\n    SessionTransport({\n      transport: options.transport,\n      session,\n      documents,\n      protocol,\n      link,\n    }),\n  );\n  const core = useStatewireCore(() => latest.current, value);\n  useEffect(() => core.rematerialize(), [core, options.materializeKey]);\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  const {\n    documents: source,\n    selection,\n    invoke: transportInvoke,\n    failures: transportFailures,\n  } = value;\n\n  const invoke = useCallback(\n    (protocol: string, method: string, params: readonly unknown[]) => {\n      if (!transportInvoke)\n        throw new Error(\n          \"statewire: transport does not support protocol commands\",\n        );\n      return transportInvoke(protocol, method, params);\n    },\n    [transportInvoke],\n  );\n\n  return useMemo(() => {\n    const failures = (): NonNullable<typeof transportFailures> => {\n      if (!transportFailures) {\n        throw new Error(\"statewire: this transport has no failed-send lane\");\n      }\n      return transportFailures;\n    };\n    return {\n      state,\n      documents: source,\n      selection,\n      invoke,\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  }, [\n    state,\n    isBusy,\n    failed,\n    connection,\n    core,\n    source,\n    selection,\n    invoke,\n    transportFailures,\n  ]);\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    /** The session does not exist on the server yet: the transport's first attach waits for the first command send; the transport's own `isNew` wins. */\n    isNew?: boolean;\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    /** Republishes through `materialize` when it changes (`Object.is`); `materialize` itself is read fresh on every publish. */\n    materializeKey?: unknown;\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 fold client-known facts into the state: server-accepted,\n   * still-uncommitted intents (e.g. dispatch records into messages) or the live\n   * state of a sibling statewire. Runs after the optimistic folds on every\n   * published state; `materializeKey` republishes when the facts change.\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/transports/remote.js

@@ -1,32 +1,36 @@
-import { ProtocolContext } from "../client/sessionStore.js";
+import { LinkContext, ProtocolContext } from "../client/sessionStore.js";
 import { discardFailed, documentSource, failedCommands, invokeProtocol, retryFailed, setTransport, useStatewireSession } from "../client/session.js";
-import { useContext, useEffect } from "@assistant-ui/tap/react-shim";
+import { useContext, useEffect, useMemo } from "@assistant-ui/tap/react-shim";
 //#region src/transports/remote.ts
 const useStatewireRemote = (options, useLink) => {
 	const configured = {
 		...useContext(ProtocolContext),
+		...useContext(LinkContext),
 		...options
 	};
 	const s = useStatewireSession(configured);
 	const conn = useLink(configured, s.ctx);
 	useEffect(() => setTransport(s, conn), [s, conn]);
+	const lanes = useMemo(() => ({
+		documents: documentSource(s),
+		invoke: (protocol, method, params) => invokeProtocol(s, protocol, method, params),
+		failures: {
+			list: () => failedCommands(s),
+			retry: (entry) => retryFailed(s, entry),
+			discard: (entry_0) => discardFailed(s, entry_0)
+		}
+	}), [s]);
 	return {
 		state: s.canonical,
-		documents: documentSource(s),
+		...lanes,
 		get selection() {
 			return s.selection;
 		},
-		invoke: (protocol, method, params) => invokeProtocol(s, protocol, method, params),
 		commands: s.commands,
 		connection: conn.connection,
 		source: s.source,
 		get isBusy() {
 			return !s.idle;
-		},
-		failures: {
-			list: () => failedCommands(s),
-			retry: (entry) => retryFailed(s, entry),
-			discard: (entry_0) => discardFailed(s, entry_0)
 		}
 	};
 };

package/dist/transports/remote.js.map

@@ -1 +1 @@
-{"version":3,"file":"remote.js","names":["useContext","useEffect","ProtocolContext","Statewire","documentSource","invokeProtocol","discardFailed","failedCommands","retryFailed","setTransport","useStatewireSession","StatewireSessionOptions","StatewireClient","RemoteLink","StatewireRemoteProps","useStatewireRemote","url","onChange","connection","Connection","onDone","options","TOptions","useLink","ctx","inherited","configured","s","conn","state","canonical","documents","selection","invoke","protocol","method","params","commands","source","isBusy","idle","failures","list","retry","entry","discard"],"sources":["../../src/transports/remote.ts"],"sourcesContent":["import { useContext, useEffect } from \"react\";\nimport { ProtocolContext } from \"../client/sessionStore\";\nimport type { Statewire } from \"../types\";\nimport {\n  documentSource,\n  invokeProtocol,\n  discardFailed,\n  failedCommands,\n  retryFailed,\n  setTransport,\n  useStatewireSession,\n} from \"../client/session\";\nimport type { StatewireSessionOptions } from \"../client/session\";\nimport type { StatewireClient } from \"../statewire\";\nimport type { RemoteLink, StatewireRemoteProps } from \"./sse\";\n\nexport const useStatewireRemote = <\n  TOptions extends {\n    url: string;\n    onChange?: (connection: StatewireClient.Connection) => void;\n    onDone?: () => void;\n  } & StatewireSessionOptions,\n>(\n  options: TOptions,\n  useLink: (options: TOptions, ctx: StatewireRemoteProps) => RemoteLink,\n): Statewire<any, any> => {\n  const inherited = useContext(ProtocolContext);\n  const configured = { ...inherited, ...options };\n  const s = useStatewireSession(configured);\n  const conn = useLink(configured, s.ctx);\n  useEffect(() => setTransport(s, conn), [s, conn]);\n\n  return {\n    state: s.canonical,\n    documents: documentSource(s),\n    get selection() {\n      return s.selection;\n    },\n    invoke: (protocol, method, params) =>\n      invokeProtocol(s, protocol, method, params),\n    commands: s.commands,\n    connection: conn.connection,\n    source: s.source,\n    get isBusy() {\n      return !s.idle;\n    },\n    failures: {\n      list: () => failedCommands(s),\n      retry: (entry) => retryFailed(s, entry),\n      discard: (entry) => discardFailed(s, entry),\n    },\n  };\n};\n"],"mappings":";;;;AAgBA,MAAae,sBAOXM,SACAE,YACwB;CAExB,MAAMG,aAAa;EAAE,GADH1B,WAAWE,eACLuB;EAAW,GAAGJ;CAAQ;CAC9C,MAAMM,IAAIjB,oBAAoBgB,UAAU;CACxC,MAAME,OAAOL,QAAQG,YAAYC,EAAEH,GAAG;CACtCvB,gBAAgBQ,aAAakB,GAAGC,IAAI,GAAG,CAACD,GAAGC,IAAI,CAAC;CAEhD,OAAO;EACLC,OAAOF,EAAEG;EACTC,WAAW3B,eAAeuB,CAAC;EAC3B,IAAIK,YAAY;GACd,OAAOL,EAAEK;EACX;EACAC,SAASC,UAAUC,QAAQC,WACzB/B,eAAesB,GAAGO,UAAUC,QAAQC,MAAM;EAC5CC,UAAUV,EAAEU;EACZnB,YAAYU,KAAKV;EACjBoB,QAAQX,EAAEW;EACV,IAAIC,SAAS;GACX,OAAO,CAACZ,EAAEa;EACZ;EACAC,UAAU;GACRC,YAAYnC,eAAeoB,CAAC;GAC5BgB,QAAQC,UAAUpC,YAAYmB,GAAGiB,KAAK;GACtCC,UAAUD,YAAUtC,cAAcqB,GAAGiB,OAAK;EAC5C;CACF;AACF"}
+{"version":3,"file":"remote.js","names":["useContext","useEffect","useMemo","LinkContext","ProtocolContext","Statewire","documentSource","invokeProtocol","discardFailed","failedCommands","retryFailed","setTransport","useStatewireSession","StatewireSessionOptions","StatewireClient","RemoteLink","StatewireRemoteProps","useStatewireRemote","url","onChange","connection","Connection","onDone","options","TOptions","useLink","ctx","configured","s","conn","lanes","documents","invoke","protocol","method","params","failures","list","retry","entry","FailedCommand","discard","state","canonical","selection","commands","source","isBusy","idle"],"sources":["../../src/transports/remote.ts"],"sourcesContent":["import { useContext, useEffect, useMemo } from \"react\";\nimport { LinkContext, ProtocolContext } from \"../client/sessionStore\";\nimport type { Statewire } from \"../types\";\nimport {\n  documentSource,\n  invokeProtocol,\n  discardFailed,\n  failedCommands,\n  retryFailed,\n  setTransport,\n  useStatewireSession,\n} from \"../client/session\";\nimport type { StatewireSessionOptions } from \"../client/session\";\nimport type { StatewireClient } from \"../statewire\";\nimport type { RemoteLink, StatewireRemoteProps } from \"./sse\";\n\nexport const useStatewireRemote = <\n  TOptions extends {\n    url: string;\n    onChange?: (connection: StatewireClient.Connection) => void;\n    onDone?: () => void;\n  } & StatewireSessionOptions,\n>(\n  options: TOptions,\n  useLink: (options: TOptions, ctx: StatewireRemoteProps) => RemoteLink,\n): Statewire<any, any> => {\n  const configured = {\n    ...useContext(ProtocolContext),\n    ...useContext(LinkContext),\n    ...options,\n  };\n  const s = useStatewireSession(configured);\n  const conn = useLink(configured, s.ctx);\n  useEffect(() => setTransport(s, conn), [s, conn]);\n  const lanes = useMemo(\n    () => ({\n      documents: documentSource(s),\n      invoke: (protocol: string, method: string, params: readonly unknown[]) =>\n        invokeProtocol(s, protocol, method, params),\n      failures: {\n        list: () => failedCommands(s),\n        retry: (entry: StatewireClient.FailedCommand) => retryFailed(s, entry),\n        discard: (entry: StatewireClient.FailedCommand) =>\n          discardFailed(s, entry),\n      },\n    }),\n    [s],\n  );\n\n  return {\n    state: s.canonical,\n    ...lanes,\n    get selection() {\n      return s.selection;\n    },\n    commands: s.commands,\n    connection: conn.connection,\n    source: s.source,\n    get isBusy() {\n      return !s.idle;\n    },\n  };\n};\n"],"mappings":";;;;AAgBA,MAAaiB,sBAOXM,SACAE,YACwB;CACxB,MAAME,aAAa;EACjB,GAAG3B,WAAWI,eAAe;EAC7B,GAAGJ,WAAWG,WAAW;EACzB,GAAGoB;CACL;CACA,MAAMK,IAAIhB,oBAAoBe,UAAU;CACxC,MAAME,OAAOJ,QAAQE,YAAYC,EAAEF,GAAG;CACtCzB,gBAAgBU,aAAaiB,GAAGC,IAAI,GAAG,CAACD,GAAGC,IAAI,CAAC;CAChD,MAAMC,QAAQ5B,eACL;EACL6B,WAAWzB,eAAesB,CAAC;EAC3BI,SAASC,UAAkBC,QAAgBC,WACzC5B,eAAeqB,GAAGK,UAAUC,QAAQC,MAAM;EAC5CC,UAAU;GACRC,YAAY5B,eAAemB,CAAC;GAC5BU,QAAQC,UAAyC7B,YAAYkB,GAAGW,KAAK;GACrEE,UAAUF,YACR/B,cAAcoB,GAAGW,OAAK;EAC1B;CACF,IACA,CAACX,CAAC,CACJ;CAEA,OAAO;EACLc,OAAOd,EAAEe;EACT,GAAGb;EACH,IAAIc,YAAY;GACd,OAAOhB,EAAEgB;EACX;EACAC,UAAUjB,EAAEiB;EACZzB,YAAYS,KAAKT;EACjB0B,QAAQlB,EAAEkB;EACV,IAAIC,SAAS;GACX,OAAO,CAACnB,EAAEoB;EACZ;CACF;AACF"}

package/dist/transports/testing.js

@@ -13,7 +13,7 @@ const tick = () => new Promise((r) => setTimeout(r, 0));
 */
 let mockCount = 0;
 const createMockTransport = (initialState, protocol = "default", options = {}) => {
-	const ephemeral = (options.ephemeral ?? []).map((child) => `${protocol}/${child}`);
+	const ephemeralLanes = () => (options.ephemeral ?? []).map((child) => `${protocol}/${child}`);
 	let state = initialState;
 	let clientId = "";
 	let finished = false;
@@ -44,6 +44,7 @@ const createMockTransport = (initialState, protocol = "default", options = {}) =
 			clientId = id;
 			if (!clients.has(id)) clients.set(id, {});
 			const rec = clients.get(id);
+			const ephemeral = ephemeralLanes();
 			for (const lane of ephemeral) delete rec[lane];
 			const frame = JSON.parse(String(init?.body ?? "{}"));
 			admit(id, frame);

package/dist/transports/testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing.js","names":["ResourceElement","StatewireEnvelope","StatewireHttp","StatewireFrame","Statewire","openSSEStream","sseFrame","FakeStreamHandle","WIRE_VERSION","tick","Promise","r","setTimeout","applyOptimistic","MockTransport","transport","TState","commands","protocol","method","params","setState","state","applied","seq","settle","payload","sendEnvelope","envelope","finish","reason","message","clientId","attached","mockCount","createMockTransport","initialState","options","ephemeral","map","child","finished","clients","Map","Record","streams","Set","stream","send","admit","id","frame","rec","get","statement","cmd","push","fakeFetch","input","RequestInfo","URL","init","RequestInit","Response","TypeError","url","String","headers","Headers","endsWith","has","set","lane","JSON","parse","body","handle","ops","op","main","value","syn","version","protocols","name","record","const","signal","undefined","json","status","fetch","next","path","type","fin","close","size"],"sources":["../../src/transports/testing.ts"],"sourcesContent":["import type { ResourceElement } from \"@assistant-ui/tap\";\nimport type { StatewireEnvelope } from \"../client/connection\";\nimport { StatewireHttp } from \"./sse\";\nimport type { StatewireFrame } from \"./sse\";\nimport type { Statewire } from \"../types\";\nimport { openSSEStream, sseFrame } from \"./fake-sse\";\nimport type { FakeStreamHandle } from \"./fake-sse\";\nimport { WIRE_VERSION } from \"../wire/protocol\";\n\nexport * from \"./fixtures\";\n\n/** Let queued microtasks and op batches drain through the statewire client. */\nexport const tick = () => new Promise<void>((r) => setTimeout(r, 0));\n\nexport { applyOptimistic } from \"../util/recordMutations\";\n\nexport type MockTransport<TState> = {\n  /** Pass as the `transport:` option of useStatewire / Harness. */\n  transport: ResourceElement<Statewire<TState | undefined, any>>;\n  /** Captured statements in arrival order. */\n  commands: { protocol: string; method: string; params: unknown[] }[];\n  /** Replace the replicated state and broadcast it as a root snapshot op. */\n  setState: (state: TState) => Promise<void>;\n  /** Deliver a bare ack cmd packet on the stream. */\n  applied: (seq: number) => Promise<void>;\n  /** Deliver a terminal result cmd packet on the stream. */\n  settle: (seq: number, payload?: unknown) => Promise<void>;\n  /** Deliver an arbitrary envelope on the stream. */\n  sendEnvelope: (envelope: StatewireEnvelope) => Promise<void>;\n  /** End the stream with a fin; further attaches fail like a dead server. */\n  finish: (reason: string, message?: string) => Promise<void>;\n  readonly clientId: string;\n  readonly attached: boolean;\n};\n\n/**\n * A mock statewire backend: serves `initialState` as the attach snapshot,\n * records submitted frames (receipt only — acks and results are delivered\n * from test code), and exposes the wire as a transport ResourceElement.\n */\nlet mockCount = 0;\n\nexport const createMockTransport = <TState>(\n  initialState: TState,\n  protocol = \"default\",\n  options: { ephemeral?: readonly string[] } = {},\n): MockTransport<TState> => {\n  const ephemeral = (options.ephemeral ?? []).map(\n    (child) => `${protocol}/${child}`,\n  );\n  let state: unknown = initialState;\n  let clientId = \"\";\n  let finished = false;\n  const clients = new Map<string, Record<string, number>>();\n  const streams = new Set<FakeStreamHandle>();\n  const commands: MockTransport<unknown>[\"commands\"] = [];\n\n  const sendEnvelope = (envelope: StatewireEnvelope) => {\n    for (const stream of streams) stream.send(sseFrame(envelope));\n    return tick();\n  };\n\n  const admit = (id: string, frame: StatewireFrame) => {\n    const rec = clients.get(id)!;\n    for (const statement of frame.cmd ?? []) {\n      if (statement.seq <= (rec[statement.protocol] ?? 0)) continue;\n      rec[statement.protocol] = statement.seq;\n      commands.push({\n        protocol: statement.protocol,\n        method: statement.method,\n        params: statement.params,\n      });\n    }\n  };\n\n  const fakeFetch = (async (\n    input: RequestInfo | URL,\n    init?: RequestInit,\n  ): Promise<Response> => {\n    if (finished) throw new TypeError(\"fetch failed (finished)\");\n    const url = String(input);\n    const headers = new Headers(init?.headers);\n    const id = headers.get(\"Statewire-Client-Id\") ?? \"\";\n    if (url.endsWith(\"/stream\")) {\n      clientId = id;\n      if (!clients.has(id)) clients.set(id, {});\n      const rec = clients.get(id)!;\n      for (const lane of ephemeral) delete rec[lane];\n      const frame = JSON.parse(String(init?.body ?? \"{}\")) as StatewireFrame;\n      admit(id, frame);\n      return openSSEStream(\n        streams,\n        id,\n        (handle) => {\n          handle.send(\n            sseFrame({\n              ops: [{ op: \"mount\", protocol, main: true, value: state }],\n              syn: {\n                version: WIRE_VERSION,\n                protocols: [\n                  {\n                    name: protocol,\n                    version: WIRE_VERSION,\n                    seq: rec[protocol] ?? 0,\n                  },\n                  ...ephemeral.map((name) => ({\n                    name,\n                    version: WIRE_VERSION,\n                    record: \"ephemeral\" as const,\n                    seq: 0,\n                  })),\n                ],\n              },\n            }),\n          );\n        },\n        init?.signal ?? undefined,\n        { \"Statewire-Lease\": \"mock-lease\" },\n      );\n    }\n    if (url.endsWith(\"/frames\")) {\n      admit(clientId, JSON.parse(String(init?.body ?? \"{}\")) as StatewireFrame);\n      return Response.json({});\n    }\n    return new Response(null, { status: 404 });\n  }) as typeof fetch;\n\n  return {\n    transport: StatewireHttp({\n      url: `http://mock-${++mockCount}/api`,\n      fetch: fakeFetch,\n    }),\n    commands,\n    setState: (next) => {\n      state = next;\n      return sendEnvelope({ ops: [{ op: \"replace\", path: [], value: next }] });\n    },\n    applied: (seq) =>\n      sendEnvelope({ cmd: [{ protocol, seq, type: \"applied\" }] }),\n    settle: (seq, payload) =>\n      sendEnvelope({\n        cmd: [\n          {\n            protocol,\n            seq,\n            type: \"result\",\n            ...(payload !== undefined && { payload }),\n          },\n        ],\n      }),\n    sendEnvelope,\n    finish: async (reason, message) => {\n      await sendEnvelope({\n        fin: { reason, ...(message !== undefined && { message }) },\n      });\n      finished = true;\n      for (const stream of [...streams]) stream.close();\n      await tick();\n    },\n    get clientId() {\n      return clientId;\n    },\n    get attached() {\n      return streams.size > 0;\n    },\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"testing.js","names":["ResourceElement","StatewireEnvelope","StatewireHttp","StatewireFrame","Statewire","openSSEStream","sseFrame","FakeStreamHandle","WIRE_VERSION","tick","Promise","r","setTimeout","applyOptimistic","MockTransport","transport","TState","commands","protocol","method","params","setState","state","applied","seq","settle","payload","sendEnvelope","envelope","finish","reason","message","clientId","attached","mockCount","createMockTransport","initialState","options","ephemeral","ephemeralLanes","map","child","finished","clients","Map","Record","streams","Set","stream","send","admit","id","frame","rec","get","statement","cmd","push","fakeFetch","input","RequestInfo","URL","init","RequestInit","Response","TypeError","url","String","headers","Headers","endsWith","has","set","lane","JSON","parse","body","handle","ops","op","main","value","syn","version","protocols","name","record","const","signal","undefined","json","status","fetch","next","path","type","fin","close","size"],"sources":["../../src/transports/testing.ts"],"sourcesContent":["import type { ResourceElement } from \"@assistant-ui/tap\";\nimport type { StatewireEnvelope } from \"../client/connection\";\nimport { StatewireHttp } from \"./sse\";\nimport type { StatewireFrame } from \"./sse\";\nimport type { Statewire } from \"../types\";\nimport { openSSEStream, sseFrame } from \"./fake-sse\";\nimport type { FakeStreamHandle } from \"./fake-sse\";\nimport { WIRE_VERSION } from \"../wire/protocol\";\n\nexport * from \"./fixtures\";\n\n/** Let queued microtasks and op batches drain through the statewire client. */\nexport const tick = () => new Promise<void>((r) => setTimeout(r, 0));\n\nexport { applyOptimistic } from \"../util/recordMutations\";\n\nexport type MockTransport<TState> = {\n  /** Pass as the `transport:` option of useStatewire / Harness. */\n  transport: ResourceElement<Statewire<TState | undefined, any>>;\n  /** Captured statements in arrival order. */\n  commands: { protocol: string; method: string; params: unknown[] }[];\n  /** Replace the replicated state and broadcast it as a root snapshot op. */\n  setState: (state: TState) => Promise<void>;\n  /** Deliver a bare ack cmd packet on the stream. */\n  applied: (seq: number) => Promise<void>;\n  /** Deliver a terminal result cmd packet on the stream. */\n  settle: (seq: number, payload?: unknown) => Promise<void>;\n  /** Deliver an arbitrary envelope on the stream. */\n  sendEnvelope: (envelope: StatewireEnvelope) => Promise<void>;\n  /** End the stream with a fin; further attaches fail like a dead server. */\n  finish: (reason: string, message?: string) => Promise<void>;\n  readonly clientId: string;\n  readonly attached: boolean;\n};\n\n/**\n * A mock statewire backend: serves `initialState` as the attach snapshot,\n * records submitted frames (receipt only — acks and results are delivered\n * from test code), and exposes the wire as a transport ResourceElement.\n */\nlet mockCount = 0;\n\nexport const createMockTransport = <TState>(\n  initialState: TState,\n  protocol = \"default\",\n  options: { ephemeral?: readonly string[] } = {},\n): MockTransport<TState> => {\n  // Read per attach: a test can grow the lane set between connects.\n  const ephemeralLanes = () =>\n    (options.ephemeral ?? []).map((child) => `${protocol}/${child}`);\n  let state: unknown = initialState;\n  let clientId = \"\";\n  let finished = false;\n  const clients = new Map<string, Record<string, number>>();\n  const streams = new Set<FakeStreamHandle>();\n  const commands: MockTransport<unknown>[\"commands\"] = [];\n\n  const sendEnvelope = (envelope: StatewireEnvelope) => {\n    for (const stream of streams) stream.send(sseFrame(envelope));\n    return tick();\n  };\n\n  const admit = (id: string, frame: StatewireFrame) => {\n    const rec = clients.get(id)!;\n    for (const statement of frame.cmd ?? []) {\n      if (statement.seq <= (rec[statement.protocol] ?? 0)) continue;\n      rec[statement.protocol] = statement.seq;\n      commands.push({\n        protocol: statement.protocol,\n        method: statement.method,\n        params: statement.params,\n      });\n    }\n  };\n\n  const fakeFetch = (async (\n    input: RequestInfo | URL,\n    init?: RequestInit,\n  ): Promise<Response> => {\n    if (finished) throw new TypeError(\"fetch failed (finished)\");\n    const url = String(input);\n    const headers = new Headers(init?.headers);\n    const id = headers.get(\"Statewire-Client-Id\") ?? \"\";\n    if (url.endsWith(\"/stream\")) {\n      clientId = id;\n      if (!clients.has(id)) clients.set(id, {});\n      const rec = clients.get(id)!;\n      const ephemeral = ephemeralLanes();\n      for (const lane of ephemeral) delete rec[lane];\n      const frame = JSON.parse(String(init?.body ?? \"{}\")) as StatewireFrame;\n      admit(id, frame);\n      return openSSEStream(\n        streams,\n        id,\n        (handle) => {\n          handle.send(\n            sseFrame({\n              ops: [{ op: \"mount\", protocol, main: true, value: state }],\n              syn: {\n                version: WIRE_VERSION,\n                protocols: [\n                  {\n                    name: protocol,\n                    version: WIRE_VERSION,\n                    seq: rec[protocol] ?? 0,\n                  },\n                  ...ephemeral.map((name) => ({\n                    name,\n                    version: WIRE_VERSION,\n                    record: \"ephemeral\" as const,\n                    seq: 0,\n                  })),\n                ],\n              },\n            }),\n          );\n        },\n        init?.signal ?? undefined,\n        { \"Statewire-Lease\": \"mock-lease\" },\n      );\n    }\n    if (url.endsWith(\"/frames\")) {\n      admit(clientId, JSON.parse(String(init?.body ?? \"{}\")) as StatewireFrame);\n      return Response.json({});\n    }\n    return new Response(null, { status: 404 });\n  }) as typeof fetch;\n\n  return {\n    transport: StatewireHttp({\n      url: `http://mock-${++mockCount}/api`,\n      fetch: fakeFetch,\n    }),\n    commands,\n    setState: (next) => {\n      state = next;\n      return sendEnvelope({ ops: [{ op: \"replace\", path: [], value: next }] });\n    },\n    applied: (seq) =>\n      sendEnvelope({ cmd: [{ protocol, seq, type: \"applied\" }] }),\n    settle: (seq, payload) =>\n      sendEnvelope({\n        cmd: [\n          {\n            protocol,\n            seq,\n            type: \"result\",\n            ...(payload !== undefined && { payload }),\n          },\n        ],\n      }),\n    sendEnvelope,\n    finish: async (reason, message) => {\n      await sendEnvelope({\n        fin: { reason, ...(message !== undefined && { message }) },\n      });\n      finished = true;\n      for (const stream of [...streams]) stream.close();\n      await tick();\n    },\n    get clientId() {\n      return clientId;\n    },\n    get attached() {\n      return streams.size > 0;\n    },\n  };\n};\n"],"mappings":";;;;;;;AAYA,MAAaS,aAAa,IAAIC,SAAeC,MAAMC,WAAWD,GAAG,CAAC,CAAC;;;;;;AA4BnE,IAAIuB,YAAY;AAEhB,MAAaC,uBACXC,cACAlB,WAAW,WACXmB,UAA6C,CAAC,MACpB;CAE1B,MAAME,wBACHF,QAAQC,aAAa,CAAA,EAAA,CAAIE,KAAKC,UAAU,GAAGvB,SAAQ,GAAIuB,OAAO;CACjE,IAAInB,QAAiBc;CACrB,IAAIJ,WAAW;CACf,IAAIU,WAAW;CACf,MAAMC,0BAAU,IAAIC,IAAoC;CACxD,MAAME,0BAAU,IAAIC,IAAsB;CAC1C,MAAM9B,WAA+C,CAAA;CAErD,MAAMU,gBAAgBC,aAAgC;EACpD,KAAK,MAAMoB,UAAUF,SAASE,OAAOC,KAAK3C,SAASsB,QAAQ,CAAC;EAC5D,OAAOnB,KAAK;CACd;CAEA,MAAMyC,SAASC,IAAYC,UAA0B;EACnD,MAAMC,MAAMV,QAAQW,IAAIH,EAAE;EAC1B,KAAK,MAAMI,aAAaH,MAAMI,OAAO,CAAA,GAAI;GACvC,IAAID,UAAU/B,QAAQ6B,IAAIE,UAAUrC,aAAa,IAAI;GACrDmC,IAAIE,UAAUrC,YAAYqC,UAAU/B;GACpCP,SAASwC,KAAK;IACZvC,UAAUqC,UAAUrC;IACpBC,QAAQoC,UAAUpC;IAClBC,QAAQmC,UAAUnC;GACpB,CAAC;EACH;CACF;CAEA,MAAMsC,aAAa,OACjBC,OACAG,SACsB;EACtB,IAAIpB,UAAU,MAAM,IAAIuB,UAAU,yBAAyB;EAC3D,MAAMC,MAAMC,OAAOR,KAAK;EAExB,MAAMR,KAAKiB,IADSC,QAAQP,MAAMM,OACvBA,CAAO,CAACd,IAAI,qBAAqB,KAAK;EACjD,IAAIY,IAAII,SAAS,SAAS,GAAG;GAC3BtC,WAAWmB;GACX,IAAI,CAACR,QAAQ4B,IAAIpB,EAAE,GAAGR,QAAQ6B,IAAIrB,IAAI,CAAC,CAAC;GACxC,MAAME,MAAMV,QAAQW,IAAIH,EAAE;GAC1B,MAAMb,YAAYC,eAAe;GACjC,KAAK,MAAMkC,QAAQnC,WAAW,OAAOe,IAAIoB;GACzC,MAAMrB,QAAQsB,KAAKC,MAAMR,OAAOL,MAAMc,QAAQ,IAAI,CAAC;GACnD1B,MAAMC,IAAIC,KAAK;GACf,OAAO/C,cACLyC,SACAK,KACC0B,WAAW;IACVA,OAAO5B,KACL3C,SAAS;KACPwE,KAAK,CAAC;MAAEC,IAAI;MAAS7D;MAAU8D,MAAM;MAAMC,OAAO3D;KAAM,CAAC;KACzD4D,KAAK;MACHC,SAAS3E;MACT4E,WAAW,CACT;OACEC,MAAMnE;OACNiE,SAAS3E;OACTgB,KAAK6B,IAAInC,aAAa;MACxB,GACA,GAAGoB,UAAUE,KAAK6C,UAAU;OAC1BA;OACAF,SAAS3E;OACT8E,QAAQ;OACR9D,KAAK;MACP,EAAE,CAAC;KAEP;IACF,CAAC,CACH;GACF,GACAsC,MAAM0B,UAAUC,KAAAA,GAChB,EAAE,mBAAmB,aAAa,CACpC;EACF;EACA,IAAIvB,IAAII,SAAS,SAAS,GAAG;GAC3BpB,MAAMlB,UAAU0C,KAAKC,MAAMR,OAAOL,MAAMc,QAAQ,IAAI,CAAC,CAAmB;GACxE,OAAOZ,SAAS0B,KAAK,CAAC,CAAC;EACzB;EACA,OAAO,IAAI1B,SAAS,MAAM,EAAE2B,QAAQ,IAAI,CAAC;CAC3C;CAEA,OAAO;EACL5E,WAAWb,cAAc;GACvBgE,KAAK,eAAe,EAAEhC,UAAS;GAC/B0D,OAAOlC;EACT,CAAC;EACDzC;EACAI,WAAWwE,SAAS;GAClBvE,QAAQuE;GACR,OAAOlE,aAAa,EAAEmD,KAAK,CAAC;IAAEC,IAAI;IAAWe,MAAM,CAAA;IAAIb,OAAOY;GAAK,CAAC,EAAE,CAAC;EACzE;EACAtE,UAAUC,QACRG,aAAa,EAAE6B,KAAK,CAAC;GAAEtC;GAAUM;GAAKuE,MAAM;EAAU,CAAC,EAAE,CAAC;EAC5DtE,SAASD,KAAKE,YACZC,aAAa,EACX6B,KAAK,CACH;GACEtC;GACAM;GACAuE,MAAM;GACN,GAAIrE,YAAY+D,KAAAA,KAAa,EAAE/D,QAAQ;EACzC,CAAC,EAEL,CAAC;EACHC;EACAE,QAAQ,OAAOC,QAAQC,YAAY;GACjC,MAAMJ,aAAa,EACjBqE,KAAK;IAAElE;IAAQ,GAAIC,YAAY0D,KAAAA,KAAa,EAAE1D,QAAQ;GAAG,EAC3D,CAAC;GACDW,WAAW;GACX,KAAK,MAAMM,UAAU,CAAC,GAAGF,OAAO,GAAGE,OAAOiD,MAAM;GAChD,MAAMxF,KAAK;EACb;EACA,IAAIuB,WAAW;GACb,OAAOA;EACT;EACA,IAAIC,WAAW;GACb,OAAOa,QAAQoD,OAAO;EACxB;CACF;AACF"}

package/dist/transports/ws.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws.d.ts","names":[],"sources":["../../src/transports/ws.ts"],"mappings":";;;;;cAwLa,qBACX,cACA,kBAAkB,UAAU,WAAW,UAAU,UAEjD,SAAS,gBAAgB,qBACtB,gBAAgB,UAAU,oBAAoB"}
+{"version":3,"file":"ws.d.ts","names":[],"sources":["../../src/transports/ws.ts"],"mappings":";;;;;cA8La,qBACX,cACA,kBAAkB,UAAU,WAAW,UAAU,UAEjD,SAAS,gBAAgB,qBACtB,gBAAgB,UAAU,oBAAoB"}

package/dist/transports/ws.js

@@ -20,6 +20,7 @@ const socketUrl = async (options, clientId) => {
 };
 const runSocket = (c, ws, frame, abort) => new Promise((resolve, reject) => {
 	let timer;
+	let ping;
 	let timedOut = false;
 	let outcome = null;
 	let closed = false;
@@ -41,10 +42,12 @@ const runSocket = (c, ws, frame, abort) => new Promise((resolve, reject) => {
 			return;
 		}
 		ws.send(frame);
+		ping = setInterval(() => ws.send("{}"), timing.pingIntervalMs);
 	};
 	const stale = () => Boolean(outcome) || closed || abort.signal.aborted;
 	const fail = (error) => {
 		clearTimeout(timer);
+		clearInterval(ping);
 		reject(error instanceof Error ? error : /* @__PURE__ */ new Error("protocol"));
 		ws.close();
 	};
@@ -72,6 +75,7 @@ const runSocket = (c, ws, frame, abort) => new Promise((resolve, reject) => {
 	ws.onclose = () => {
 		closed = true;
 		clearTimeout(timer);
+		clearInterval(ping);
 		if (outcome) resolve(outcome);
 		else reject(/* @__PURE__ */ new Error(timedOut ? "timeout" : "network"));
 	};

package/dist/transports/ws.js.map

@@ -1 +1 @@
-{"version":3,"file":"ws.js","names":["useState","flushTapSync","resource","ResourceElement","timing","attachFrame","handleEnvelope","unsupportedVersion","useLink","AttemptOutcome","Conn","StatewireEnvelope","Statewire","StatewireClient","useStatewireRemote","CLIENT_QUERY_PARAM","WS_SUBPROTOCOL","RemoteLink","StatewireFrame","StatewireSubmitResult","StatewireRemoteProps","WsChannel","socket","WebSocket","OPEN","socketUrl","options","WebsocketOptions","clientId","url","query","params","URLSearchParams","set","resolved","URL","globalThis","location","href","protocol","replace","pathname","search","toString","runSocket","c","ws","frame","abort","AbortController","Promise","resolve","reject","timer","ReturnType","setTimeout","timedOut","outcome","closed","arm","clearTimeout","close","heartbeatTimeoutMs","signal","addEventListener","onerror","onopen","negotiated","trim","send","stale","Boolean","aborted","fail","error","Error","onmessage","event","env","JSON","parse","String","data","SyntaxError","Object","keys","length","done","onclose","attemptSocket","w","ctx","body","headers","throwIfAborted","protocols","webSocket","WS","extra","undefined","sendFrame","readyState","stringify","type","useWsLink","$","_c","_temp","t0","t1","_","t2","attemptOnce","useStatewireWebsocket","StatewireWebsocket","Commands","TState","TCommands"],"sources":["../../src/transports/ws.ts"],"sourcesContent":["import { useState } from \"react\";\nimport { flushTapSync, resource } from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { timing } from \"../client/timing\";\nimport {\n  attachFrame,\n  handleEnvelope,\n  unsupportedVersion,\n  useLink,\n} from \"../client/connection\";\nimport type {\n  AttemptOutcome,\n  Conn,\n  StatewireEnvelope,\n} from \"../client/connection\";\nimport type { Statewire } from \"../types\";\nimport type { StatewireClient } from \"../statewire\";\nimport { useStatewireRemote } from \"./remote\";\nimport { CLIENT_QUERY_PARAM } from \"../host/adapter\";\nimport { WS_SUBPROTOCOL } from \"../wire/version\";\nimport type {\n  RemoteLink,\n  StatewireFrame,\n  StatewireSubmitResult,\n  StatewireRemoteProps,\n} from \"./sse\";\n\ntype WsChannel = {\n  socket: WebSocket | null;\n};\n\nconst OPEN = 1;\n\nexport { WS_SUBPROTOCOL };\n\nconst socketUrl = async (\n  options: StatewireClient.WebsocketOptions,\n  clientId: string,\n) => {\n  const { url, query } = options;\n  const params = new URLSearchParams(\n    typeof query === \"function\" ? await query() : query,\n  );\n  params.set(CLIENT_QUERY_PARAM, clientId);\n  const resolved = new URL(url, globalThis.location?.href);\n  resolved.protocol = resolved.protocol.replace(/^http/, \"ws\");\n  resolved.pathname = `${resolved.pathname.replace(/\\/$/, \"\")}/ws`;\n  resolved.search = params.toString();\n  return resolved.href;\n};\n\nconst runSocket = (\n  c: Conn,\n  ws: WebSocket,\n  frame: string,\n  abort: AbortController,\n): Promise<AttemptOutcome> =>\n  new Promise((resolve, reject) => {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let timedOut = false;\n    let outcome: AttemptOutcome | null = null;\n    let closed = false;\n    const arm = () => {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        timedOut = true;\n        ws.close();\n      }, timing.heartbeatTimeoutMs);\n    };\n    arm();\n    abort.signal.addEventListener(\"abort\", () => ws.close());\n    ws.onerror = () => {};\n    ws.onopen = () => {\n      const negotiated = ws.protocol.trim();\n      if (negotiated !== WS_SUBPROTOCOL) {\n        outcome = unsupportedVersion(c, negotiated);\n        ws.close();\n        return;\n      }\n      ws.send(frame);\n    };\n    const stale = () => Boolean(outcome) || closed || abort.signal.aborted;\n    const fail = (error: unknown) => {\n      clearTimeout(timer);\n      reject(error instanceof Error ? error : new Error(\"protocol\"));\n      ws.close();\n    };\n    ws.onmessage = (event) => {\n      if (stale()) return;\n      arm();\n      let env: StatewireEnvelope;\n      try {\n        env = JSON.parse(String(event.data)) as StatewireEnvelope;\n      } catch {\n        fail(new SyntaxError(\"invalid JSON packet\"));\n        return;\n      }\n      // {} heartbeats live below the packet layer: invisible to handlers.\n      if (\n        typeof env === \"object\" &&\n        env !== null &&\n        Object.keys(env).length === 0\n      ) {\n        return;\n      }\n      try {\n        const done = flushTapSync(() => handleEnvelope(c, env));\n        if (done) {\n          outcome = done;\n          ws.close();\n        }\n      } catch (error) {\n        fail(error);\n      }\n    };\n    ws.onclose = () => {\n      closed = true;\n      clearTimeout(timer);\n      if (outcome) resolve(outcome);\n      else reject(new Error(timedOut ? \"timeout\" : \"network\"));\n    };\n  });\n\nconst attemptSocket = async (\n  c: Conn,\n  w: WsChannel,\n  options: StatewireClient.WebsocketOptions,\n  abort: AbortController,\n): Promise<AttemptOutcome> => {\n  let ws: WebSocket | null = null;\n  try {\n    const url = await socketUrl(options, c.ctx.clientId);\n    const { body } = await attachFrame(c, options.headers);\n    abort.signal.throwIfAborted();\n    const { protocols, webSocket } = options;\n    const WS = webSocket ?? globalThis.WebSocket;\n    if (!WS) throw new Error(\"no WebSocket implementation\");\n    const extra =\n      protocols === undefined\n        ? []\n        : typeof protocols === \"string\"\n          ? [protocols]\n          : protocols;\n    ws = new WS(url, [WS_SUBPROTOCOL, ...extra]);\n    w.socket = ws;\n    return await runSocket(c, ws, body, abort);\n  } finally {\n    if (w.socket === ws) w.socket = null;\n  }\n};\n\nconst sendFrame = (\n  w: WsChannel,\n  frame: StatewireFrame,\n): Promise<StatewireSubmitResult> => {\n  const ws = w.socket;\n  if (!ws || ws.readyState !== OPEN) {\n    return Promise.reject(new Error(\"network\"));\n  }\n  try {\n    ws.send(JSON.stringify(frame));\n  } catch {\n    return Promise.reject(new Error(\"network\"));\n  }\n  return Promise.resolve({ type: \"ok\" });\n};\n\nconst useWsLink = (\n  options: StatewireClient.WebsocketOptions,\n  ctx: StatewireRemoteProps,\n): RemoteLink => {\n  const [w] = useState((): WsChannel => ({ socket: null }));\n  return useLink({\n    ...options,\n    ctx,\n    attemptOnce: (c, abort) => attemptSocket(c, w, options, abort),\n    send: (_, frame) => sendFrame(w, frame),\n  });\n};\n\nconst useStatewireWebsocket = (\n  options: StatewireClient.WebsocketOptions,\n): Statewire<any, any> => useStatewireRemote(options, useWsLink);\n\nexport const StatewireWebsocket = resource(useStatewireWebsocket) as <\n  TState = any,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireClient.WebsocketOptions,\n) => ResourceElement<Statewire<TState | undefined, TCommands>>;\n"],"mappings":"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"}
+{"version":3,"file":"ws.js","names":["useState","flushTapSync","resource","ResourceElement","timing","attachFrame","handleEnvelope","unsupportedVersion","useLink","AttemptOutcome","Conn","StatewireEnvelope","Statewire","StatewireClient","useStatewireRemote","CLIENT_QUERY_PARAM","WS_SUBPROTOCOL","RemoteLink","StatewireFrame","StatewireSubmitResult","StatewireRemoteProps","WsChannel","socket","WebSocket","OPEN","socketUrl","options","WebsocketOptions","clientId","url","query","params","URLSearchParams","set","resolved","URL","globalThis","location","href","protocol","replace","pathname","search","toString","runSocket","c","ws","frame","abort","AbortController","Promise","resolve","reject","timer","ReturnType","setTimeout","ping","setInterval","timedOut","outcome","closed","arm","clearTimeout","close","heartbeatTimeoutMs","signal","addEventListener","onerror","onopen","negotiated","trim","send","pingIntervalMs","stale","Boolean","aborted","fail","error","clearInterval","Error","onmessage","event","env","JSON","parse","String","data","SyntaxError","Object","keys","length","done","onclose","attemptSocket","w","ctx","body","headers","throwIfAborted","protocols","webSocket","WS","extra","undefined","sendFrame","readyState","stringify","type","useWsLink","$","_c","_temp","t0","t1","_","t2","attemptOnce","useStatewireWebsocket","StatewireWebsocket","Commands","TState","TCommands"],"sources":["../../src/transports/ws.ts"],"sourcesContent":["import { useState } from \"react\";\nimport { flushTapSync, resource } from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { timing } from \"../client/timing\";\nimport {\n  attachFrame,\n  handleEnvelope,\n  unsupportedVersion,\n  useLink,\n} from \"../client/connection\";\nimport type {\n  AttemptOutcome,\n  Conn,\n  StatewireEnvelope,\n} from \"../client/connection\";\nimport type { Statewire } from \"../types\";\nimport type { StatewireClient } from \"../statewire\";\nimport { useStatewireRemote } from \"./remote\";\nimport { CLIENT_QUERY_PARAM } from \"../host/adapter\";\nimport { WS_SUBPROTOCOL } from \"../wire/version\";\nimport type {\n  RemoteLink,\n  StatewireFrame,\n  StatewireSubmitResult,\n  StatewireRemoteProps,\n} from \"./sse\";\n\ntype WsChannel = {\n  socket: WebSocket | null;\n};\n\nconst OPEN = 1;\n\nexport { WS_SUBPROTOCOL };\n\nconst socketUrl = async (\n  options: StatewireClient.WebsocketOptions,\n  clientId: string,\n) => {\n  const { url, query } = options;\n  const params = new URLSearchParams(\n    typeof query === \"function\" ? await query() : query,\n  );\n  params.set(CLIENT_QUERY_PARAM, clientId);\n  const resolved = new URL(url, globalThis.location?.href);\n  resolved.protocol = resolved.protocol.replace(/^http/, \"ws\");\n  resolved.pathname = `${resolved.pathname.replace(/\\/$/, \"\")}/ws`;\n  resolved.search = params.toString();\n  return resolved.href;\n};\n\nconst runSocket = (\n  c: Conn,\n  ws: WebSocket,\n  frame: string,\n  abort: AbortController,\n): Promise<AttemptOutcome> =>\n  new Promise((resolve, reject) => {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let ping: ReturnType<typeof setInterval> | undefined;\n    let timedOut = false;\n    let outcome: AttemptOutcome | null = null;\n    let closed = false;\n    const arm = () => {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        timedOut = true;\n        ws.close();\n      }, timing.heartbeatTimeoutMs);\n    };\n    arm();\n    abort.signal.addEventListener(\"abort\", () => ws.close());\n    ws.onerror = () => {};\n    ws.onopen = () => {\n      const negotiated = ws.protocol.trim();\n      if (negotiated !== WS_SUBPROTOCOL) {\n        outcome = unsupportedVersion(c, negotiated);\n        ws.close();\n        return;\n      }\n      ws.send(frame);\n      // A ping keeps a host that cannot run timers (a hibernating durable\n      // object answers it without waking) talking before the silence timeout.\n      ping = setInterval(() => ws.send(\"{}\"), timing.pingIntervalMs);\n    };\n    const stale = () => Boolean(outcome) || closed || abort.signal.aborted;\n    const fail = (error: unknown) => {\n      clearTimeout(timer);\n      clearInterval(ping);\n      reject(error instanceof Error ? error : new Error(\"protocol\"));\n      ws.close();\n    };\n    ws.onmessage = (event) => {\n      if (stale()) return;\n      arm();\n      let env: StatewireEnvelope;\n      try {\n        env = JSON.parse(String(event.data)) as StatewireEnvelope;\n      } catch {\n        fail(new SyntaxError(\"invalid JSON packet\"));\n        return;\n      }\n      // {} heartbeats live below the packet layer: invisible to handlers.\n      if (\n        typeof env === \"object\" &&\n        env !== null &&\n        Object.keys(env).length === 0\n      ) {\n        return;\n      }\n      try {\n        const done = flushTapSync(() => handleEnvelope(c, env));\n        if (done) {\n          outcome = done;\n          ws.close();\n        }\n      } catch (error) {\n        fail(error);\n      }\n    };\n    ws.onclose = () => {\n      closed = true;\n      clearTimeout(timer);\n      clearInterval(ping);\n      if (outcome) resolve(outcome);\n      else reject(new Error(timedOut ? \"timeout\" : \"network\"));\n    };\n  });\n\nconst attemptSocket = async (\n  c: Conn,\n  w: WsChannel,\n  options: StatewireClient.WebsocketOptions,\n  abort: AbortController,\n): Promise<AttemptOutcome> => {\n  let ws: WebSocket | null = null;\n  try {\n    const url = await socketUrl(options, c.ctx.clientId);\n    const { body } = await attachFrame(c, options.headers);\n    abort.signal.throwIfAborted();\n    const { protocols, webSocket } = options;\n    const WS = webSocket ?? globalThis.WebSocket;\n    if (!WS) throw new Error(\"no WebSocket implementation\");\n    const extra =\n      protocols === undefined\n        ? []\n        : typeof protocols === \"string\"\n          ? [protocols]\n          : protocols;\n    ws = new WS(url, [WS_SUBPROTOCOL, ...extra]);\n    w.socket = ws;\n    return await runSocket(c, ws, body, abort);\n  } finally {\n    if (w.socket === ws) w.socket = null;\n  }\n};\n\nconst sendFrame = (\n  w: WsChannel,\n  frame: StatewireFrame,\n): Promise<StatewireSubmitResult> => {\n  const ws = w.socket;\n  if (!ws || ws.readyState !== OPEN) {\n    return Promise.reject(new Error(\"network\"));\n  }\n  try {\n    ws.send(JSON.stringify(frame));\n  } catch {\n    return Promise.reject(new Error(\"network\"));\n  }\n  return Promise.resolve({ type: \"ok\" });\n};\n\nconst useWsLink = (\n  options: StatewireClient.WebsocketOptions,\n  ctx: StatewireRemoteProps,\n): RemoteLink => {\n  const [w] = useState((): WsChannel => ({ socket: null }));\n  return useLink({\n    ...options,\n    ctx,\n    attemptOnce: (c, abort) => attemptSocket(c, w, options, abort),\n    send: (_, frame) => sendFrame(w, frame),\n  });\n};\n\nconst useStatewireWebsocket = (\n  options: StatewireClient.WebsocketOptions,\n): Statewire<any, any> => useStatewireRemote(options, useWsLink);\n\nexport const StatewireWebsocket = resource(useStatewireWebsocket) as <\n  TState = any,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n>(\n  options: StatewireClient.WebsocketOptions,\n) => ResourceElement<Statewire<TState | undefined, TCommands>>;\n"],"mappings":"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"}

package/dist/types.d.ts

@@ -58,6 +58,8 @@ interface Statewire<TState = any, TCommands extends Statewire.Commands = Statewi
   work?: {
     readonly isIdle: boolean;
   };
+  /** Called by the serving host once an attach is registered, before its hello: documents mounted here ride the hello. */
+  attaching?: (attach: StatewireHost.Attach) => void;
   /** Called by the serving host when an attach ends; its ephemeral documents and includes are gone. */
   detached?: (attach: StatewireHost.Attach) => void;
   /** The retained failed-send lane; present on transports with a durable session. */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;kBAMiB;OACH,WAAW,mBAAmB;OAE9B,QAAQ,kBAAkB,WAAW,eAC9C,WAAW;IAAc,QAAQ;IAAG,QAAQ,WAAW,UAAU;aAC5D;OAEI,cAAc,kBAAkB,eACzC,WAAW,gBACP,MAAM,WAAW,UAAU,QAC3B,QAAQ,QAAQ,WAAW,UAAU;OAGhC,cAAc,kBAAkB,WAAW,eACpD,WAAW;aACD;IACT,QAAQ;IACR,QAAQ,WAAW,UAAU;IAC7B;IACA;IACA;IACA,UAAU,gBAAgB;aAEtB;;OAGI;IACV;;IAEA,mBAAmB;;IAEnB,cAAc;;OAGJ;IACN;IAAe,MAAM;IAAe;;IACpC;IAAW,MAAM;IAAe;;IAChC;IAAc,MAAM;;OAEd;IACV,YAAY;IACZ,eAAe;;;UAIF,UACf,cACA,kBAAkB,UAAU,WAAW,UAAU;EAEjD,OAAO;EACP,YAAY,mBAAmB;EAC/B,YAAY,kBAAkB;EAC9B,UACE,kBACA,gBACA,+BACG;EACL,UAAU,UAAU,cAAc;EAClC,aAAa,gBAAgB;EAC7B,SAAS,UAAU;;EAEnB;EACA;aAAkB;;;EAElB,YAAY,QAAQ,cAAc;;EAElC;IACE,qBAAqB,gBAAgB;IACrC,QAAQ,OAAO,gBAAgB,kBAAkB;IACjD,UAAU,OAAO,gBAAgB;;;cAuBxB,2BAA2B;WAC7B,SAAS,gBAAgB;EAEtB,YAAA,SAAS,gBAAgB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;kBAMiB;OACH,WAAW,mBAAmB;OAE9B,QAAQ,kBAAkB,WAAW,eAC9C,WAAW;IAAc,QAAQ;IAAG,QAAQ,WAAW,UAAU;aAC5D;OAEI,cAAc,kBAAkB,eACzC,WAAW,gBACP,MAAM,WAAW,UAAU,QAC3B,QAAQ,QAAQ,WAAW,UAAU;OAGhC,cAAc,kBAAkB,WAAW,eACpD,WAAW;aACD;IACT,QAAQ;IACR,QAAQ,WAAW,UAAU;IAC7B;IACA;IACA;IACA,UAAU,gBAAgB;aAEtB;;OAGI;IACV;;IAEA,mBAAmB;;IAEnB,cAAc;;OAGJ;IACN;IAAe,MAAM;IAAe;;IACpC;IAAW,MAAM;IAAe;;IAChC;IAAc,MAAM;;OAEd;IACV,YAAY;IACZ,eAAe;;;UAIF,UACf,cACA,kBAAkB,UAAU,WAAW,UAAU;EAEjD,OAAO;EACP,YAAY,mBAAmB;EAC/B,YAAY,kBAAkB;EAC9B,UACE,kBACA,gBACA,+BACG;EACL,UAAU,UAAU,cAAc;EAClC,aAAa,gBAAgB;EAC7B,SAAS,UAAU;;EAEnB;EACA;aAAkB;;;EAElB,aAAa,QAAQ,cAAc;;EAEnC,YAAY,QAAQ,cAAc;;EAElC;IACE,qBAAqB,gBAAgB;IACrC,QAAQ,OAAO,gBAAgB,kBAAkB;IACjD,UAAU,OAAO,gBAAgB;;;cAuBxB,2BAA2B;WAC7B,SAAS,gBAAgB;EAEtB,YAAA,SAAS,gBAAgB"}

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":["StatewireDocuments","StatewireHost","StatewireProtocol","StatewireClient","StatewirePath","Statewire","Commands","Record","args","Command","TCommands","method","K","params","Parameters","CommandsProxy","Promise","Awaited","ReturnType","CommandUpdate","protocol","seq","status","result","failure","SendFailure","StateSource","snapshot","takeChanged","setOnChange","listener","Op","op","path","value","Changes","isChangedAt","getChangedKeys","state","TState","documents","Source","selection","Selection","invoke","commands","connection","Connection","source","isBusy","work","isIdle","detached","attach","Attach","failures","list","FailedCommand","retry","entry","discard","describe","fate","code","message","cause","StatewireSendError","Error","constructor","name"],"sources":["../src/types.ts"],"sourcesContent":["import type { StatewireDocuments } from \"./wire/documents\";\nimport type { StatewireHost } from \"./host\";\nimport type { StatewireProtocol } from \"./wire/protocol\";\nimport type { StatewireClient } from \"./statewire\";\nimport type { StatewirePath } from \"./wire/ops\";\n\nexport namespace Statewire {\n  export type Commands = Record<string, (...args: never[]) => unknown>;\n\n  export type Command<TCommands extends Commands = Commands> = {\n    [K in keyof TCommands]: { method: K; params: Parameters<TCommands[K]> };\n  }[keyof TCommands];\n\n  export type CommandsProxy<TCommands extends Commands> = {\n    [K in keyof TCommands]: (\n      ...args: Parameters<TCommands[K]>\n    ) => Promise<Awaited<ReturnType<TCommands[K]>>>;\n  };\n\n  export type CommandUpdate<TCommands extends Commands = Commands> = {\n    [K in keyof TCommands]: {\n      readonly protocol?: string;\n      method: K;\n      params: Parameters<TCommands[K]>;\n      seq: number;\n      status: \"queued\" | \"posted\" | \"applied\" | \"settled\";\n      result?: unknown;\n      failure?: StatewireClient.SendFailure;\n    };\n  }[keyof TCommands];\n\n  /** Push-based canonical state feed a statewire hands to the client core. */\n  export type StateSource = {\n    snapshot: () => unknown;\n    /** Drain the paths changed since the last take (`[]` entry = whole state). */\n    takeChanged: () => StatewirePath[];\n    /** Synchronous, per change; the consumer owns coalescing. */\n    setOnChange: (listener: (() => void) | null) => void;\n  };\n\n  export type Op =\n    | { op: \"replace\"; path: StatewirePath; value: unknown }\n    | { op: \"add\"; path: StatewirePath; value: unknown }\n    | { op: \"remove\"; path: StatewirePath };\n\n  export type Changes = {\n    isChangedAt(path: readonly (string | number)[]): boolean;\n    getChangedKeys(path: readonly (string | number)[]): string[];\n  };\n}\n\nexport interface Statewire<\n  TState = any,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n> {\n  state: TState;\n  documents?: StatewireDocuments.Source;\n  selection?: StatewireProtocol.Selection | undefined;\n  invoke?: (\n    protocol: string,\n    method: string,\n    params: readonly unknown[],\n  ) => Promise<unknown>;\n  commands: Statewire.CommandsProxy<TCommands>;\n  connection?: StatewireClient.Connection;\n  source?: Statewire.StateSource;\n  /** Negation of the server's broadcast idle level; absent means always busy. */\n  isBusy?: boolean;\n  work?: { readonly isIdle: boolean };\n  /** Called by the serving host when an attach ends; its ephemeral documents and includes are gone. */\n  detached?: (attach: StatewireHost.Attach) => void;\n  /** The retained failed-send lane; present on transports with a durable session. */\n  failures?: {\n    list: () => readonly StatewireClient.FailedCommand[];\n    retry: (entry: StatewireClient.FailedCommand) => Promise<unknown>;\n    discard: (entry: StatewireClient.FailedCommand) => void;\n  };\n}\n\nconst describe = (failure: StatewireClient.SendFailure): string => {\n  switch (failure.fate) {\n    case \"rejected\":\n      return `statewire: command rejected${failure.code ? ` (${failure.code})` : \"\"}${failure.message ? `: ${failure.message}` : \"\"}`;\n    case \"aborted\":\n      return `statewire: command aborted (${failure.cause})`;\n    case \"lost\":\n      return `statewire: command lost (${failure.cause})`;\n    case \"failed\":\n      return failure.message\n        ? `statewire: command failed: ${failure.message}`\n        : \"statewire: command failed\";\n    case \"crashed\":\n      return \"statewire: command crashed\";\n    case \"expired\":\n      return `statewire: command result expired (${failure.cause})`;\n  }\n};\n\nexport class StatewireSendError extends Error {\n  readonly failure: StatewireClient.SendFailure;\n\n  constructor(failure: StatewireClient.SendFailure) {\n    super(describe(failure));\n    this.name = \"StatewireSendError\";\n    this.failure = failure;\n  }\n}\n"],"mappings":";AA+EA,MAAM6D,YAAYrC,YAAiD;CACjE,QAAQA,QAAQsC,MAAhB;EACE,KAAK,YACH,OAAO,8BAA8BtC,QAAQuC,OAAO,KAAKvC,QAAQuC,KAAI,KAAM,KAAKvC,QAAQwC,UAAU,KAAKxC,QAAQwC,YAAY;EAC7H,KAAK,WACH,OAAO,+BAA+BxC,QAAQyC,MAAK;EACrD,KAAK,QACH,OAAO,4BAA4BzC,QAAQyC,MAAK;EAClD,KAAK,UACH,OAAOzC,QAAQwC,UACX,8BAA8BxC,QAAQwC,YACtC;EACN,KAAK,WACH,OAAO;EACT,KAAK,WACH,OAAO,sCAAsCxC,QAAQyC,MAAK;CAC9D;AACF;AAEA,IAAaC,qBAAb,cAAwCC,MAAM;CAC5C;CAEAC,YAAY5C,SAAsC;EAChD,MAAMqC,SAASrC,OAAO,CAAC;EACvB,KAAK6C,OAAO;EACZ,KAAK7C,UAAUA;CACjB;AACF"}
+{"version":3,"file":"types.js","names":["StatewireDocuments","StatewireHost","StatewireProtocol","StatewireClient","StatewirePath","Statewire","Commands","Record","args","Command","TCommands","method","K","params","Parameters","CommandsProxy","Promise","Awaited","ReturnType","CommandUpdate","protocol","seq","status","result","failure","SendFailure","StateSource","snapshot","takeChanged","setOnChange","listener","Op","op","path","value","Changes","isChangedAt","getChangedKeys","state","TState","documents","Source","selection","Selection","invoke","commands","connection","Connection","source","isBusy","work","isIdle","attaching","attach","Attach","detached","failures","list","FailedCommand","retry","entry","discard","describe","fate","code","message","cause","StatewireSendError","Error","constructor","name"],"sources":["../src/types.ts"],"sourcesContent":["import type { StatewireDocuments } from \"./wire/documents\";\nimport type { StatewireHost } from \"./host\";\nimport type { StatewireProtocol } from \"./wire/protocol\";\nimport type { StatewireClient } from \"./statewire\";\nimport type { StatewirePath } from \"./wire/ops\";\n\nexport namespace Statewire {\n  export type Commands = Record<string, (...args: never[]) => unknown>;\n\n  export type Command<TCommands extends Commands = Commands> = {\n    [K in keyof TCommands]: { method: K; params: Parameters<TCommands[K]> };\n  }[keyof TCommands];\n\n  export type CommandsProxy<TCommands extends Commands> = {\n    [K in keyof TCommands]: (\n      ...args: Parameters<TCommands[K]>\n    ) => Promise<Awaited<ReturnType<TCommands[K]>>>;\n  };\n\n  export type CommandUpdate<TCommands extends Commands = Commands> = {\n    [K in keyof TCommands]: {\n      readonly protocol?: string;\n      method: K;\n      params: Parameters<TCommands[K]>;\n      seq: number;\n      status: \"queued\" | \"posted\" | \"applied\" | \"settled\";\n      result?: unknown;\n      failure?: StatewireClient.SendFailure;\n    };\n  }[keyof TCommands];\n\n  /** Push-based canonical state feed a statewire hands to the client core. */\n  export type StateSource = {\n    snapshot: () => unknown;\n    /** Drain the paths changed since the last take (`[]` entry = whole state). */\n    takeChanged: () => StatewirePath[];\n    /** Synchronous, per change; the consumer owns coalescing. */\n    setOnChange: (listener: (() => void) | null) => void;\n  };\n\n  export type Op =\n    | { op: \"replace\"; path: StatewirePath; value: unknown }\n    | { op: \"add\"; path: StatewirePath; value: unknown }\n    | { op: \"remove\"; path: StatewirePath };\n\n  export type Changes = {\n    isChangedAt(path: readonly (string | number)[]): boolean;\n    getChangedKeys(path: readonly (string | number)[]): string[];\n  };\n}\n\nexport interface Statewire<\n  TState = any,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n> {\n  state: TState;\n  documents?: StatewireDocuments.Source;\n  selection?: StatewireProtocol.Selection | undefined;\n  invoke?: (\n    protocol: string,\n    method: string,\n    params: readonly unknown[],\n  ) => Promise<unknown>;\n  commands: Statewire.CommandsProxy<TCommands>;\n  connection?: StatewireClient.Connection;\n  source?: Statewire.StateSource;\n  /** Negation of the server's broadcast idle level; absent means always busy. */\n  isBusy?: boolean;\n  work?: { readonly isIdle: boolean };\n  /** Called by the serving host once an attach is registered, before its hello: documents mounted here ride the hello. */\n  attaching?: (attach: StatewireHost.Attach) => void;\n  /** Called by the serving host when an attach ends; its ephemeral documents and includes are gone. */\n  detached?: (attach: StatewireHost.Attach) => void;\n  /** The retained failed-send lane; present on transports with a durable session. */\n  failures?: {\n    list: () => readonly StatewireClient.FailedCommand[];\n    retry: (entry: StatewireClient.FailedCommand) => Promise<unknown>;\n    discard: (entry: StatewireClient.FailedCommand) => void;\n  };\n}\n\nconst describe = (failure: StatewireClient.SendFailure): string => {\n  switch (failure.fate) {\n    case \"rejected\":\n      return `statewire: command rejected${failure.code ? ` (${failure.code})` : \"\"}${failure.message ? `: ${failure.message}` : \"\"}`;\n    case \"aborted\":\n      return `statewire: command aborted (${failure.cause})`;\n    case \"lost\":\n      return `statewire: command lost (${failure.cause})`;\n    case \"failed\":\n      return failure.message\n        ? `statewire: command failed: ${failure.message}`\n        : \"statewire: command failed\";\n    case \"crashed\":\n      return \"statewire: command crashed\";\n    case \"expired\":\n      return `statewire: command result expired (${failure.cause})`;\n  }\n};\n\nexport class StatewireSendError extends Error {\n  readonly failure: StatewireClient.SendFailure;\n\n  constructor(failure: StatewireClient.SendFailure) {\n    super(describe(failure));\n    this.name = \"StatewireSendError\";\n    this.failure = failure;\n  }\n}\n"],"mappings":";AAiFA,MAAM8D,YAAYtC,YAAiD;CACjE,QAAQA,QAAQuC,MAAhB;EACE,KAAK,YACH,OAAO,8BAA8BvC,QAAQwC,OAAO,KAAKxC,QAAQwC,KAAI,KAAM,KAAKxC,QAAQyC,UAAU,KAAKzC,QAAQyC,YAAY;EAC7H,KAAK,WACH,OAAO,+BAA+BzC,QAAQ0C,MAAK;EACrD,KAAK,QACH,OAAO,4BAA4B1C,QAAQ0C,MAAK;EAClD,KAAK,UACH,OAAO1C,QAAQyC,UACX,8BAA8BzC,QAAQyC,YACtC;EACN,KAAK,WACH,OAAO;EACT,KAAK,WACH,OAAO,sCAAsCzC,QAAQ0C,MAAK;CAC9D;AACF;AAEA,IAAaC,qBAAb,cAAwCC,MAAM;CAC5C;CAEAC,YAAY7C,SAAsC;EAChD,MAAMsC,SAAStC,OAAO,CAAC;EACvB,KAAK8C,OAAO;EACZ,KAAK9C,UAAUA;CACjB;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statewire",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "description": "State over the wire: snapshot-first delta streaming and command submission for any state and any command",
   "license": "MIT",
   "repository": {

package/src/client/connection.ts

@@ -341,6 +341,11 @@ const helloSynOf = (env: StatewireEnvelope): StatewireSyn => {
   return env.syn as StatewireSyn;
 };
 
+// A host that woke on a retained socket re-sends its hello; the snapshot
+// replaces the session the way a fresh attach would.
+const isWakeHello = (env: StatewireEnvelope) =>
+  isObject(env.syn) && env.syn["version"] !== undefined;
+
 const handleHello = (c: Conn, env: StatewireEnvelope) => {
   const syn = helloSynOf(env);
   if (c.negotiation !== undefined) validateSelection(syn, c.negotiation);
@@ -470,7 +475,7 @@ export const handleEnvelope = (
   value: unknown,
 ): AttemptOutcome | null => {
   const env = validateEnvelope(value);
-  if (c.awaitingHello) {
+  if (c.awaitingHello || isWakeHello(env)) {
     if (env.fin !== undefined) return settleFin(c, env.fin);
     handleHello(c, env);
     return null;

package/src/client/core.ts

@@ -48,6 +48,7 @@ type Core = {
   stale: boolean;
   everAttached: boolean;
   overlaysDirty: boolean;
+  materializeKey: unknown;
   flushing: boolean;
   scheduled: boolean;
   listeners: Set<() => void>;
@@ -56,6 +57,7 @@ type Core = {
   getState: () => unknown;
   getBusy: () => boolean;
   getFailed: () => readonly StatewireClient.FailedCommand[];
+  rematerialize: () => void;
   commands: Statewire.CommandsProxy<any>;
   subscribe: (listener: () => void) => () => void;
 };
@@ -105,14 +107,17 @@ const dropCovered = (c: Core) => {
 };
 
 const recompute = (c: Core) => {
-  if (!c.stale || !c.value) return;
+  if (!c.value) return;
+  const { optimistic, materialize, materializeKey } = c.getOptions();
+  const rekeyed = !Object.is(materializeKey, c.materializeKey);
+  if (!c.stale && !rekeyed) return;
   c.stale = false;
   const prevCanonical = c.canonical;
   drainCanonical(c);
   if (c.canonical !== prevCanonical) dropCovered(c);
-  if (c.canonical === prevCanonical && !c.overlaysDirty) return;
+  if (c.canonical === prevCanonical && !c.overlaysDirty && !rekeyed) return;
   c.overlaysDirty = false;
-  const { optimistic, materialize } = c.getOptions();
+  c.materializeKey = materializeKey;
   let next = c.canonical;
   let paths: readonly StatewirePath[] = [];
   if (optimistic && c.canonical !== undefined) {
@@ -314,6 +319,7 @@ export const useStatewireCore = (
       stale: false,
       everAttached: false,
       overlaysDirty: false,
+      materializeKey: undefined,
       flushing: false,
       scheduled: false,
       listeners: new Set(),
@@ -354,6 +360,7 @@ export const useStatewireCore = (
       },
       getBusy: () => c.value?.isBusy ?? true,
       getFailed: () => c.notifiedFailed,
+      rematerialize: () => flush(c),
       commands: createMethodProxy<Statewire.CommandsProxy<any>>(
         (method, params) => {
           if (!c.value) {