statewire 0.0.1 → 0.0.3

package/dist/host.js

@@ -0,0 +1,4 @@
+import { StatewireReject } from "./host/engine.js";
+import { append } from "./host/draft.js";
+import { CommandExecution, getStateHost, useStatewireCommands, useStatewireEmit, useStatewireState } from "./host/host.js";
+export { CommandExecution, StatewireReject, append, getStateHost, useStatewireCommands, useStatewireEmit, useStatewireState };

package/dist/index.d.ts

@@ -1,28 +1,5 @@
-import { StatewireOp, applyOps } from "./wire/ops.js";
-import { StatewireConnection, StatewireSSE, StatewireSSEOptions } from "./transports/sse.js";
-import { SendFailure, StatewireChanges, StatewireCommand, StatewireCommandUpdate, StatewireCommands, StatewireCommandsProxy, StatewireHelpers, StatewireOptimistic, StatewireOptimisticContext, StatewireOptions, StatewireSendError, StatewireStateSource, StatewireTransport } from "./types.js";
-import { StatewireWS, StatewireWSOptions } from "./transports/ws.js";
-import { Statewire, StatewireResource, useStatewire } from "./statewire.js";
-//#region src/index.d.ts
-declare namespace Statewire {
-  type Connection = StatewireConnection;
-  type ConnectionStatus = StatewireConnection["status"];
-  type Transport<TState = any, TCommands extends StatewireCommands = StatewireCommands, TEvent = any> = StatewireTransport<TState, TCommands, TEvent>;
-  type StateSource = StatewireStateSource;
-  type SSEOptions = StatewireSSEOptions;
-  type WSOptions = StatewireWSOptions;
-  type Options<TState, TCommands extends StatewireCommands = StatewireCommands, TEvent = any> = StatewireOptions<TState, TCommands, TEvent>;
-  type Helpers<TState, TCommands extends StatewireCommands = StatewireCommands> = StatewireHelpers<TState, TCommands>;
-  type Commands = StatewireCommands;
-  type Command<TCommands extends StatewireCommands = StatewireCommands> = StatewireCommand<TCommands>;
-  type CommandsProxy<TCommands extends StatewireCommands> = StatewireCommandsProxy<TCommands>;
-  type CommandUpdate<TCommands extends StatewireCommands = StatewireCommands> = StatewireCommandUpdate<TCommands>;
-  type Optimistic<TState, TCommands extends StatewireCommands = StatewireCommands> = StatewireOptimistic<TState, TCommands>;
-  type OptimisticContext = StatewireOptimisticContext;
-  type SendFailure = SendFailure;
-  type Changes = StatewireChanges;
-  type Op = StatewireOp;
-}
-//#endregion
-export { Statewire, StatewireResource, StatewireSSE, StatewireSendError, StatewireWS, applyOps, useStatewire };
-//# sourceMappingURL=index.d.ts.map
+import { StatewireSSE } from "./transports/sse.js";
+import { StatewireClient, StatewireResource, useStatewire } from "./statewire.js";
+import { Statewire, StatewireSendError } from "./types.js";
+import { StatewireWS } from "./transports/ws.js";
+export { type Statewire, StatewireClient, StatewireResource, StatewireSSE, StatewireSendError, StatewireWS, useStatewire };

package/dist/index.js

@@ -1,6 +1,5 @@
-import { applyOps } from "./wire/ops.js";
 import { StatewireSendError } from "./types.js";
-import { Statewire, StatewireResource, useStatewire } from "./statewire.js";
+import { StatewireClient, StatewireResource, useStatewire } from "./statewire.js";
 import { StatewireSSE } from "./transports/sse.js";
 import { StatewireWS } from "./transports/ws.js";
-export { Statewire, StatewireResource, StatewireSSE, StatewireSendError, StatewireWS, applyOps, useStatewire };
+export { StatewireClient, StatewireResource, StatewireSSE, StatewireSendError, StatewireWS, useStatewire };

package/dist/statewire.d.ts

@@ -1,20 +1,107 @@
-import { StatewireConnection } from "./transports/sse.js";
-import { StatewireCommands, StatewireCommandsProxy, StatewireHelpers, StatewireOptions } from "./types.js";
+import { ConnectionState } from "./transports/sse.js";
+import { StatewireSessionStoreOptions } from "./client/sessionStore.js";
+import { Statewire } from "./types.js";
 import { ResourceElement } from "@assistant-ui/tap";
 //#region src/statewire.d.ts
-declare const useStatewire: <TState, TCommands extends StatewireCommands = StatewireCommands, TEvent = any>(options: StatewireOptions<TState, TCommands, TEvent>) => StatewireHelpers<TState, TCommands>;
-declare const StatewireResource: <TState, TCommands extends StatewireCommands = StatewireCommands, TEvent = any>(options: StatewireOptions<TState, TCommands, TEvent>) => ResourceElement<StatewireHelpers<TState, TCommands>>;
-declare class Statewire<TState, TCommands extends StatewireCommands = StatewireCommands, TEvent = any> {
-  private readonly core;
+declare const useStatewire: <TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any>(options: StatewireClient.Options<TState, TCommands, TEvent>) => StatewireClient.Helpers<TState, TCommands>;
+declare const StatewireResource: <TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any>(options: StatewireClient.Options<TState, TCommands, TEvent>) => ResourceElement<StatewireClient.Helpers<TState, TCommands>>;
+declare class StatewireClient<TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any> {
   private readonly root;
   private disposed;
-  constructor(options: StatewireOptions<TState, TCommands, TEvent>);
+  constructor(options: StatewireClient.Options<TState, TCommands, TEvent>);
   get state(): TState;
-  get connection(): StatewireConnection;
-  get commands(): StatewireCommandsProxy<TCommands>;
+  get connection(): StatewireClient.Connection;
+  get commands(): Statewire.CommandsProxy<TCommands>;
+  setContext(value: Record<string, unknown>): Promise<unknown>;
   subscribe(listener: () => void): () => void;
   dispose(): void;
 }
+declare namespace StatewireClient {
+  type Options<TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any> = {
+    transport: ResourceElement<Statewire<TState, TCommands, TEvent>>;
+    optimistic?: Optimistic<NonNullable<TState>, TCommands>;
+    onEvent?: (event: TEvent, ctx: {
+      state: NonNullable<TState>;
+    }) => void;
+    onStateChange?: (state: NonNullable<TState>, ctx: {
+      changes: Statewire.Changes;
+    }) => void;
+    onCommandChange?: (update: Statewire.CommandUpdate<TCommands>, ctx: {
+      state: NonNullable<TState>;
+    }) => void;
+  };
+  type Helpers<TState, TCommands extends Statewire.Commands = Statewire.Commands> = {
+    /** The statewire's state type — remote statewires include `undefined` until the first attach snapshot applies. */
+    state: TState;
+    /** Identity-stable across renders; reads the current canonical state without subscribing the caller. */
+    getState: () => TState;
+    connection: Connection;
+    commands: Statewire.CommandsProxy<TCommands>;
+    /** Replace this client's ambient context on the server; throws on transports without a client context channel. */
+    setContext: (value: Record<string, unknown>) => Promise<unknown>;
+  };
+  type Connection = ConnectionState & {
+    reconnect: () => void;
+  };
+  type ConnectionStatus = Connection["status"];
+  /**
+   * Mutate the draft in place; the client records the next state plus the exact
+   * changed paths. Re-run against the new base on every rebase.
+   */
+  type Optimistic<TState, TCommands extends Statewire.Commands = Statewire.Commands> = (draft: TState, command: Statewire.Command<TCommands>, ctx: OptimisticContext) => void;
+  type OptimisticContext = {
+    ts: number;
+    seq: number;
+    clientId?: string;
+  };
+  /**
+   * fate: "aborted" = never sent, "rejected" = the handler refused,
+   * "unknown-command" = no such command, "invalid-params" = the args did not
+   * match the command's schema, "lost" = sent but never covered by an ack,
+   * "crashed" = acked but the processing died, "result-unavailable" = acked
+   * but the result is gone.
+   * cause is which channel settled it: "server" = the server's answer;
+   * the rest are channel deaths the client settled locally.
+   */
+  type SendFailure = {
+    fate: "rejected";
+    cause: "server";
+    message: string;
+    payload?: unknown;
+  } | {
+    fate: "unknown-command";
+    cause: "server";
+  } | {
+    fate: "invalid-params";
+    cause: "server";
+    message: string;
+  } | {
+    fate: "crashed";
+    cause: "server";
+  } | {
+    fate: "result-unavailable";
+    cause: "server" | "unmount" | "stream-gone" | "session-lost" | "superseded";
+  } | {
+    fate: "aborted";
+    cause: "cascade" | "unmount" | "stream-gone" | "session-lost" | "superseded";
+  } | {
+    fate: "lost";
+    cause: "unmount" | "stream-gone" | "session-lost" | "superseded";
+  };
+  type SSEOptions = StatewireSessionStoreOptions & {
+    url: string;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    fetch?: typeof globalThis.fetch;
+    onChange?: (connection: Connection) => void;
+  };
+  type WSOptions = StatewireSessionStoreOptions & {
+    url: string;
+    protocols?: string | string[];
+    query?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    webSocket?: new (url: string, protocols?: string | string[]) => WebSocket;
+    onChange?: (connection: Connection) => void;
+  };
+}
 //#endregion
-export { Statewire, StatewireResource, useStatewire };
+export { StatewireClient, StatewireResource, useStatewire };
 //# sourceMappingURL=statewire.d.ts.map

package/dist/statewire.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statewire.d.ts","names":[],"sources":["../src/statewire.ts"],"mappings":";;;;cAkBa,eACX,QACA,kBAAkB,oBAAoB,mBACtC,cAEA,SAAS,iBAAiB,QAAQ,WAAW,YAC5C,iBAAiB,QAAQ;cA6Bf,oBACX,QACA,kBAAkB,oBAAoB,mBACtC,cAEA,SAAS,iBAAiB,QAAQ,WAAW,YAC5C,gBAAgB,iBAAiB,QAAQ;cAG/B,UACX,QACA,kBAAkB,oBAAoB,mBACtC;mBAEiB;mBACA;UACT;EAEI,YAAA,SAAS,iBAAiB,QAAQ,WAAW;MAarD,SAAS;MAIT,cAAc;MAId,YAAY,uBAAuB;EAIvC,UAAU;EAIV"}
+{"version":3,"file":"statewire.d.ts","names":[],"sources":["../src/statewire.ts"],"mappings":";;;;;cAaa,eACX,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD,cAEA,SAAS,gBAAgB,QAAQ,QAAQ,WAAW,YACnD,gBAAgB,QAAQ,QAAQ;cAqCtB,oBACX,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD,cAEA,SAAS,gBAAgB,QAAQ,QAAQ,WAAW,YACnD,gBAAgB,gBAAgB,QAAQ,QAAQ;cAGtC,gBACX,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD;mBAEiB;UACT;EAEI,YAAA,SAAS,gBAAgB,QAAQ,QAAQ,WAAW;MAK5D,SAAS;MAIT,cAAc,gBAAgB;MAI9B,YAAY,UAAU,cAAc;EAIxC,WAAW,OAAO,0BAA0B;EAI5C,UAAU;EAIV;;kBAOe;OACH,QACV,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD;IAEA,WAAW,gBAAgB,UAAU,QAAQ,WAAW;IACxD,aAAa,WAAW,YAAY,SAAS;IAC7C,WAAW,OAAO,QAAQ;MAAO,OAAO,YAAY;;IACpD,iBACE,OAAO,YAAY,SACnB;MAAO,SAAS,UAAU;;IAE5B,mBACE,QAAQ,UAAU,cAAc,YAChC;MAAO,OAAO,YAAY;;;OAIlB,QACV,QACA,kBAAkB,UAAU,WAAW,UAAU;;IAGjD,OAAO;;IAEP,gBAAgB;IAChB,YAAY;IACZ,UAAU,UAAU,cAAc;;IAElC,aAAa,OAAO,4BAA4B;;OAGtC,aAAa;IAAoB;;OACjC,mBAAmB;;;;;OAMnB,WACV,QACA,kBAAkB,UAAU,WAAW,UAAU,aAEjD,OAAO,QACP,SAAS,UAAU,QAAQ,YAC3B,KAAK;OAGK;IACV;IACA;IACA;;;;;;;;;;;OAYU;IACN;IAAkB;IAAiB;IAAiB;;IACpD;IAAyB;;IACzB;IAAwB;IAAiB;;IACzC;IAAiB;;IAEjB;IACA;;IAQA;IACA;;IAQA;IACA;;OAGM,aAAa;IACvB;IACA,UAAU,qBAAqB,cAAc,QAAQ;IACrD,eAAe,WAAW;IAC1B,YAAY,YAAY;;OAGd,YAAY;IACtB;IACA;IACA,QACI,gCACO,yBAAyB,QAAQ;IAC5C,iBAAiB,aAAa,kCAAkC;IAChE,YAAY,YAAY"}

package/dist/statewire.js

@@ -1,65 +1,61 @@
-import { LIVE_CONNECTION, createStatewireCore } from "./client/core.js";
-import { useEffect, useRef, useState } from "@assistant-ui/tap/react-shim";
+import { LIVE_CONNECTION, useStatewireCore } from "./client/core.js";
+import { useMemo, useRef, useState, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
 import { createTapRoot, flushTapSync, resource, useResource } from "@assistant-ui/tap";
 //#region src/statewire.ts
 const useStatewire = (options) => {
 	const latest = useRef(options);
 	latest.current = options;
-	const [, setVersion] = useState(0);
-	const [core] = useState(() => createStatewireCore(() => latest.current));
 	const value = useResource(options.transport);
-	core.attach(value);
-	useEffect(() => {
-		core.attach(value);
-	});
-	useEffect(() => {
-		const unsubscribe = core.subscribe(() => flushTapSync(() => setVersion((v) => v + 1)));
-		return () => {
-			unsubscribe();
-			core.detach();
-		};
-	}, [core]);
-	return {
-		state: core.getState(),
-		connection: value.connection ?? LIVE_CONNECTION,
-		commands: core.commands
-	};
+	const core = useStatewireCore(() => latest.current, value);
+	const [subscribe] = useState(() => (listener) => core.subscribe(() => flushTapSync(listener)));
+	const state = useSyncExternalStore(subscribe, core.getState, core.getState);
+	const connection = value.connection ?? LIVE_CONNECTION;
+	return useMemo(() => ({
+		state,
+		getState: core.getState,
+		connection,
+		commands: core.commands,
+		setContext: (contextValue) => {
+			if (!value.setContext) throw new Error("statewire: this transport has no client context channel");
+			return value.setContext(contextValue);
+		}
+	}), [
+		state,
+		connection,
+		core,
+		value
+	]);
 };
 const StatewireResource = (options) => resource(useStatewire)(options);
-var Statewire = class {
-	core;
+var StatewireClient = class {
 	root;
 	disposed = false;
 	constructor(options) {
-		this.core = createStatewireCore(() => options);
-		const core = this.core;
-		this.root = createTapRoot(() => {
-			const value = useResource(options.transport);
-			core.attach(value);
-			return value;
-		});
-		flushTapSync(() => {});
+		const ClientRoot = () => useStatewire(options);
+		this.root = createTapRoot(ClientRoot);
 	}
 	get state() {
-		return this.core.getState();
+		return this.root.getValue().getState();
 	}
 	get connection() {
-		return this.root.getValue().connection ?? LIVE_CONNECTION;
+		return this.root.getValue().connection;
 	}
 	get commands() {
-		return this.core.commands;
+		return this.root.getValue().commands;
+	}
+	setContext(value) {
+		return this.root.getValue().setContext(value);
 	}
 	subscribe(listener) {
-		return this.core.subscribe(listener);
+		return this.root.subscribe(listener);
 	}
 	dispose() {
 		if (this.disposed) return;
 		this.disposed = true;
 		this.root.unmount();
-		this.core.dispose();
 	}
 };
 //#endregion
-export { Statewire, StatewireResource, useStatewire };
+export { StatewireClient, StatewireResource, useStatewire };
 
 //# sourceMappingURL=statewire.js.map

package/dist/statewire.js.map

@@ -1 +1 @@
-{"version":3,"file":"statewire.js","names":["useEffect","useRef","useState","createTapRoot","flushTapSync","resource","useResource","ResourceElement","createStatewireCore","LIVE_CONNECTION","StatewireTransport","StatewireCommands","StatewireCommandsProxy","StatewireHelpers","StatewireOptions","StatewireConnection","useStatewire","options","TState","TCommands","TEvent","latest","current","setVersion","core","value","transport","attach","unsubscribe","subscribe","v","detach","state","getState","connection","commands","StatewireResource","Statewire","root","disposed","constructor","getValue","listener","dispose","unmount"],"sources":["../src/statewire.ts"],"sourcesContent":["import { useEffect, useRef, useState } from \"react\";\nimport {\n  createTapRoot,\n  flushTapSync,\n  resource,\n  useResource,\n} from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { createStatewireCore, LIVE_CONNECTION } from \"./client/core\";\nimport type { StatewireTransport } from \"./types\";\nimport type {\n  StatewireCommands,\n  StatewireCommandsProxy,\n  StatewireHelpers,\n  StatewireOptions,\n} from \"./types\";\nimport type { StatewireConnection } from \"./transports/sse\";\n\nexport const useStatewire = <\n  TState,\n  TCommands extends StatewireCommands = StatewireCommands,\n  TEvent = any,\n>(\n  options: StatewireOptions<TState, TCommands, TEvent>,\n): StatewireHelpers<TState, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n  const [, setVersion] = useState(0);\n  const [core] = useState(() => createStatewireCore(() => latest.current));\n\n  const value = useResource(options.transport) as StatewireTransport<unknown>;\n  core.attach(value);\n\n  useEffect(() => {\n    core.attach(value);\n  });\n  useEffect(() => {\n    const unsubscribe = core.subscribe(() =>\n      flushTapSync(() => setVersion((v) => v + 1)),\n    );\n    return () => {\n      unsubscribe();\n      core.detach();\n    };\n  }, [core]);\n\n  return {\n    state: core.getState() as TState,\n    connection: value.connection ?? LIVE_CONNECTION,\n    commands: core.commands as StatewireCommandsProxy<TCommands>,\n  };\n};\n\nexport const StatewireResource = <\n  TState,\n  TCommands extends StatewireCommands = StatewireCommands,\n  TEvent = any,\n>(\n  options: StatewireOptions<TState, TCommands, TEvent>,\n): ResourceElement<StatewireHelpers<TState, TCommands>> =>\n  resource(useStatewire<TState, TCommands, TEvent>)(options);\n\nexport class Statewire<\n  TState,\n  TCommands extends StatewireCommands = StatewireCommands,\n  TEvent = any,\n> {\n  private readonly core;\n  private readonly root;\n  private disposed = false;\n\n  constructor(options: StatewireOptions<TState, TCommands, TEvent>) {\n    this.core = createStatewireCore(() => options);\n    const core = this.core;\n    this.root = createTapRoot(() => {\n      const value = useResource(\n        options.transport,\n      ) as StatewireTransport<unknown>;\n      core.attach(value);\n      return value;\n    });\n    flushTapSync(() => {});\n  }\n\n  get state(): TState {\n    return this.core.getState() as TState;\n  }\n\n  get connection(): StatewireConnection {\n    return this.root.getValue().connection ?? LIVE_CONNECTION;\n  }\n\n  get commands(): StatewireCommandsProxy<TCommands> {\n    return this.core.commands as StatewireCommandsProxy<TCommands>;\n  }\n\n  subscribe(listener: () => void): () => void {\n    return this.core.subscribe(listener);\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.root.unmount();\n    this.core.dispose();\n  }\n}\n"],"mappings":";;;;AAkBA,MAAagB,gBAKXC,YACwC;CACxC,MAAMI,SAASpB,OAAOgB,OAAO;CAC7BI,OAAOC,UAAUL;CACjB,MAAM,GAAGM,cAAcrB,SAAS,CAAC;CACjC,MAAM,CAACsB,QAAQtB,eAAeM,0BAA0Ba,OAAOC,OAAO,CAAC;CAEvE,MAAMG,QAAQnB,YAAYW,QAAQS,SAAS;CAC3CF,KAAKG,OAAOF,KAAK;CAEjBzB,gBAAgB;EACdwB,KAAKG,OAAOF,KAAK;CACnB,CAAC;CACDzB,gBAAgB;EACd,MAAM4B,cAAcJ,KAAKK,gBACvBzB,mBAAmBmB,YAAYO,MAAMA,IAAI,CAAC,CAAC,CAC7C;EACA,aAAa;GACXF,YAAY;GACZJ,KAAKO,OAAO;EACd;CACF,GAAG,CAACP,IAAI,CAAC;CAET,OAAO;EACLQ,OAAOR,KAAKS,SAAS;EACrBC,YAAYT,MAAMS,cAAczB;EAChC0B,UAAUX,KAAKW;CACjB;AACF;AAEA,MAAaC,qBAKXnB,YAEAZ,SAASW,YAAuC,CAAC,CAACC,OAAO;AAE3D,IAAaoB,YAAb,MAIE;CACA;CACA;CACA,WAAmB;CAEnBG,YAAYvB,SAAsD;EAChE,KAAKO,OAAOhB,0BAA0BS,OAAO;EAC7C,MAAMO,OAAO,KAAKA;EAClB,KAAKc,OAAOnC,oBAAoB;GAC9B,MAAMsB,QAAQnB,YACZW,QAAQS,SACV;GACAF,KAAKG,OAAOF,KAAK;GACjB,OAAOA;EACT,CAAC;EACDrB,mBAAmB,CAAC,CAAC;CACvB;CAEA,IAAI4B,QAAgB;EAClB,OAAO,KAAKR,KAAKS,SAAS;CAC5B;CAEA,IAAIC,aAAkC;EACpC,OAAO,KAAKI,KAAKG,SAAS,CAAC,CAACP,cAAczB;CAC5C;CAEA,IAAI0B,WAA8C;EAChD,OAAO,KAAKX,KAAKW;CACnB;CAEAN,UAAUa,UAAkC;EAC1C,OAAO,KAAKlB,KAAKK,UAAUa,QAAQ;CACrC;CAEAC,UAAgB;EACd,IAAI,KAAKJ,UAAU;EACnB,KAAKA,WAAW;EAChB,KAAKD,KAAKM,QAAQ;EAClB,KAAKpB,KAAKmB,QAAQ;CACpB;AACF"}
+{"version":3,"file":"statewire.js","names":["useMemo","useRef","useState","useSyncExternalStore","createTapRoot","flushTapSync","resource","useResource","ResourceElement","LIVE_CONNECTION","useStatewireCore","Statewire","ConnectionState","StatewireSessionStoreOptions","useStatewire","Commands","options","StatewireClient","Options","TState","TCommands","TEvent","Helpers","latest","current","value","transport","core","subscribe","listener","state","getState","connection","commands","CommandsProxy","setContext","contextValue","Record","Error","StatewireResource","root","disposed","constructor","ClientRoot","getValue","Connection","Promise","dispose","unmount","optimistic","Optimistic","NonNullable","onEvent","event","ctx","onStateChange","changes","Changes","onCommandChange","update","CommandUpdate","reconnect","ConnectionStatus","draft","command","Command","OptimisticContext","ts","seq","clientId","SendFailure","fate","cause","message","payload","SSEOptions","url","headers","HeadersInit","fetch","globalThis","onChange","WSOptions","protocols","query","webSocket","WebSocket"],"sources":["../src/statewire.ts"],"sourcesContent":["import { useMemo, useRef, useState, useSyncExternalStore } from \"react\";\nimport {\n  createTapRoot,\n  flushTapSync,\n  resource,\n  useResource,\n} from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { LIVE_CONNECTION, useStatewireCore } from \"./client/core\";\nimport type { Statewire } from \"./types\";\nimport type { ConnectionState } from \"./transports/sse\";\nimport type { StatewireSessionStoreOptions } from \"./client/sessionStore\";\n\nexport const useStatewire = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n  TEvent = any,\n>(\n  options: StatewireClient.Options<TState, TCommands, TEvent>,\n): StatewireClient.Helpers<TState, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n\n  const value = useResource(options.transport) as Statewire<unknown>;\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 connection = value.connection ?? LIVE_CONNECTION;\n\n  return useMemo(\n    () => ({\n      state,\n      getState: core.getState as () => TState,\n      connection,\n      commands: core.commands as Statewire.CommandsProxy<TCommands>,\n      setContext: (contextValue: Record<string, unknown>) => {\n        if (!value.setContext) {\n          throw new Error(\n            \"statewire: this transport has no client context channel\",\n          );\n        }\n        return value.setContext(contextValue);\n      },\n    }),\n    [state, connection, core, value],\n  );\n};\n\nexport const StatewireResource = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n  TEvent = any,\n>(\n  options: StatewireClient.Options<TState, TCommands, TEvent>,\n): ResourceElement<StatewireClient.Helpers<TState, TCommands>> =>\n  resource(useStatewire<TState, TCommands, TEvent>)(options);\n\nexport class StatewireClient<\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n  TEvent = any,\n> {\n  private readonly root;\n  private disposed = false;\n\n  constructor(options: StatewireClient.Options<TState, TCommands, TEvent>) {\n    const ClientRoot = () => useStatewire<TState, TCommands, TEvent>(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  setContext(value: Record<string, unknown>): Promise<unknown> {\n    return this.root.getValue().setContext(value);\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    TEvent = any,\n  > = {\n    transport: ResourceElement<Statewire<TState, TCommands, TEvent>>;\n    optimistic?: Optimistic<NonNullable<TState>, TCommands>;\n    onEvent?: (event: TEvent, ctx: { state: NonNullable<TState> }) => void;\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  };\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    /** 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    /** Replace this client's ambient context on the server; throws on transports without a client context channel. */\n    setContext: (value: Record<string, unknown>) => Promise<unknown>;\n  };\n\n  export type Connection = ConnectionState & { reconnect: () => void };\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   * fate: \"aborted\" = never sent, \"rejected\" = the handler refused,\n   * \"unknown-command\" = no such command, \"invalid-params\" = the args did not\n   * match the command's schema, \"lost\" = sent but never covered by an ack,\n   * \"crashed\" = acked but the processing died, \"result-unavailable\" = acked\n   * but the result is gone.\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    | { fate: \"rejected\"; cause: \"server\"; message: string; payload?: unknown }\n    | { fate: \"unknown-command\"; cause: \"server\" }\n    | { fate: \"invalid-params\"; cause: \"server\"; message: string }\n    | { fate: \"crashed\"; cause: \"server\" }\n    | {\n        fate: \"result-unavailable\";\n        cause:\n          | \"server\"\n          | \"unmount\"\n          | \"stream-gone\"\n          | \"session-lost\"\n          | \"superseded\";\n      }\n    | {\n        fate: \"aborted\";\n        cause:\n          | \"cascade\"\n          | \"unmount\"\n          | \"stream-gone\"\n          | \"session-lost\"\n          | \"superseded\";\n      }\n    | {\n        fate: \"lost\";\n        cause: \"unmount\" | \"stream-gone\" | \"session-lost\" | \"superseded\";\n      };\n\n  export type SSEOptions = StatewireSessionStoreOptions & {\n    url: string;\n    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);\n    fetch?: typeof globalThis.fetch;\n    onChange?: (connection: Connection) => void;\n  };\n\n  export type WSOptions = StatewireSessionStoreOptions & {\n    url: string;\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    onChange?: (connection: Connection) => void;\n  };\n}\n"],"mappings":";;;;AAaA,MAAac,gBAKXE,YAC+C;CAC/C,MAAMO,SAAStB,OAAOe,OAAO;CAC7BO,OAAOC,UAAUR;CAEjB,MAAMS,QAAQlB,YAAYS,QAAQU,SAAS;CAC3C,MAAMC,OAAOjB,uBAAuBa,OAAOC,SAASC,KAAK;CACzD,MAAM,CAACG,aAAa1B,gBACX2B,aACLF,KAAKC,gBAAgBvB,aAAawB,QAAQ,CAAC,CAC/C;CAEA,MAAMC,QAAQ3B,qBACZyB,WACAD,KAAKI,UACLJ,KAAKI,QACP;CACA,MAAMC,aAAaP,MAAMO,cAAcvB;CAEvC,OAAOT,eACE;EACL8B;EACAC,UAAUJ,KAAKI;EACfC;EACAC,UAAUN,KAAKM;EACfE,aAAaC,iBAA0C;GACrD,IAAI,CAACX,MAAMU,YACT,MAAM,IAAIG,MACR,yDACF;GAEF,OAAOb,MAAMU,WAAWC,YAAY;EACtC;CACF,IACA;EAACN;EAAOE;EAAYL;EAAMF;CAAK,CACjC;AACF;AAEA,MAAac,qBAKXvB,YAEAV,SAASQ,YAAuC,CAAC,CAACE,OAAO;AAE3D,IAAaC,kBAAb,MAIE;CACA;CACA,WAAmB;CAEnByB,YAAY1B,SAA6D;EACvE,MAAM2B,mBAAmB7B,aAAwCE,OAAO;EACxE,KAAKwB,OAAOpC,cAAcuC,UAAU;CACtC;CAEA,IAAIb,QAAgB;EAClB,OAAO,KAAKU,KAAKI,SAAS,CAAC,CAACb,SAAS;CACvC;CAEA,IAAIC,aAAyC;EAC3C,OAAO,KAAKQ,KAAKI,SAAS,CAAC,CAACZ;CAC9B;CAEA,IAAIC,WAA+C;EACjD,OAAO,KAAKO,KAAKI,SAAS,CAAC,CAACX;CAC9B;CAEAE,WAAWV,OAAkD;EAC3D,OAAO,KAAKe,KAAKI,SAAS,CAAC,CAACT,WAAWV,KAAK;CAC9C;CAEAG,UAAUC,UAAkC;EAC1C,OAAO,KAAKW,KAAKZ,UAAUC,QAAQ;CACrC;CAEAkB,UAAgB;EACd,IAAI,KAAKN,UAAU;EACnB,KAAKA,WAAW;EAChB,KAAKD,KAAKQ,QAAQ;CACpB;AACF"}

package/dist/transports/fake-sse.d.ts

@@ -0,0 +1,12 @@
+import { StatewireEnvelope } from "../client/connection.js";
+//#region src/transports/fake-sse.d.ts
+type FakeStreamHandle = {
+  clientId: string;
+  send: (text: string) => void;
+  close: () => void;
+};
+declare const sseFrame: (envelope: StatewireEnvelope) => string;
+declare const openSSEStream: (streams: Set<FakeStreamHandle>, clientId: string, onOpen: (handle: FakeStreamHandle) => void, signal?: AbortSignal) => Response;
+//#endregion
+export { FakeStreamHandle, openSSEStream, sseFrame };
+//# sourceMappingURL=fake-sse.d.ts.map

package/dist/transports/fake-sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-sse.d.ts","names":[],"sources":["../../src/transports/fake-sse.ts"],"mappings":";;KAEY;EACV;EACA,OAAO;EACP;;cAGW,WAAY,UAAU;cAGtB,gBACX,SAAS,IAAI,mBACb,kBACA,SAAS,QAAQ,2BACjB,SAAS,gBACR"}

package/dist/transports/fake-sse.js

@@ -0,0 +1,39 @@
+//#region src/transports/fake-sse.ts
+const sseFrame = (envelope) => `data: ${JSON.stringify(envelope)}\n\n`;
+const openSSEStream = (streams, clientId, onOpen, signal) => {
+	const encoder = new TextEncoder();
+	let handle;
+	const body = new ReadableStream({
+		start: (controller) => {
+			let open = true;
+			handle = {
+				clientId,
+				send: (text) => {
+					if (open) controller.enqueue(encoder.encode(text));
+				},
+				close: () => {
+					if (!open) return;
+					open = false;
+					streams.delete(handle);
+					controller.close();
+				}
+			};
+			streams.add(handle);
+			onOpen(handle);
+		},
+		cancel: () => {
+			streams.delete(handle);
+		}
+	});
+	signal?.addEventListener("abort", () => {
+		for (const stream of [...streams]) if (stream.clientId === clientId) stream.close();
+	});
+	return new Response(body, {
+		status: 200,
+		headers: { "content-type": "text/event-stream" }
+	});
+};
+//#endregion
+export { openSSEStream, sseFrame };
+
+//# sourceMappingURL=fake-sse.js.map

package/dist/transports/fake-sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-sse.js","names":["StatewireEnvelope","FakeStreamHandle","clientId","send","text","close","sseFrame","envelope","JSON","stringify","openSSEStream","streams","Set","onOpen","handle","signal","AbortSignal","Response","encoder","TextEncoder","body","ReadableStream","Uint8Array","start","controller","open","enqueue","encode","delete","add","cancel","addEventListener","stream","status","headers"],"sources":["../../src/transports/fake-sse.ts"],"sourcesContent":["import type { StatewireEnvelope } from \"../client/connection\";\n\nexport type FakeStreamHandle = {\n  clientId: string;\n  send: (text: string) => void;\n  close: () => void;\n};\n\nexport const sseFrame = (envelope: StatewireEnvelope) =>\n  `data: ${JSON.stringify(envelope)}\\n\\n`;\n\nexport const openSSEStream = (\n  streams: Set<FakeStreamHandle>,\n  clientId: string,\n  onOpen: (handle: FakeStreamHandle) => void,\n  signal?: AbortSignal,\n): Response => {\n  const encoder = new TextEncoder();\n  let handle: FakeStreamHandle;\n  const body = new ReadableStream<Uint8Array>({\n    start: (controller) => {\n      let open = true;\n      handle = {\n        clientId,\n        send: (text) => {\n          if (open) controller.enqueue(encoder.encode(text));\n        },\n        close: () => {\n          if (!open) return;\n          open = false;\n          streams.delete(handle);\n          controller.close();\n        },\n      };\n      streams.add(handle);\n      onOpen(handle);\n    },\n    cancel: () => {\n      streams.delete(handle);\n    },\n  });\n  signal?.addEventListener(\"abort\", () => {\n    for (const stream of [...streams]) {\n      if (stream.clientId === clientId) stream.close();\n    }\n  });\n  return new Response(body, {\n    status: 200,\n    headers: { \"content-type\": \"text/event-stream\" },\n  });\n};\n"],"mappings":";AAQA,MAAaM,YAAYC,aACvB,SAASC,KAAKC,UAAUF,QAAQ,EAAC;AAEnC,MAAaG,iBACXC,SACAT,UACAW,QACAE,WACa;CACb,MAAMG,UAAU,IAAIC,YAAY;CAChC,IAAIL;CACJ,MAAMM,OAAO,IAAIC,eAA2B;EAC1CE,QAAQC,eAAe;GACrB,IAAIC,OAAO;GACXX,SAAS;IACPZ;IACAC,OAAOC,SAAS;KACd,IAAIqB,MAAMD,WAAWE,QAAQR,QAAQS,OAAOvB,IAAI,CAAC;IACnD;IACAC,aAAa;KACX,IAAI,CAACoB,MAAM;KACXA,OAAO;KACPd,QAAQiB,OAAOd,MAAM;KACrBU,WAAWnB,MAAM;IACnB;GACF;GACAM,QAAQkB,IAAIf,MAAM;GAClBD,OAAOC,MAAM;EACf;EACAgB,cAAc;GACZnB,QAAQiB,OAAOd,MAAM;EACvB;CACF,CAAC;CACDC,QAAQgB,iBAAiB,eAAe;EACtC,KAAK,MAAMC,UAAU,CAAC,GAAGrB,OAAO,GAC9B,IAAIqB,OAAO9B,aAAaA,UAAU8B,OAAO3B,MAAM;CAEnD,CAAC;CACD,OAAO,IAAIY,SAASG,MAAM;EACxBa,QAAQ;EACRC,SAAS,EAAE,gBAAgB,oBAAoB;CACjD,CAAC;AACH"}

package/dist/transports/fixtures.d.ts

@@ -0,0 +1,33 @@
+import { StatewireHost } from "../host.js";
+import { Statewire } from "../types.js";
+import "../index.js";
+//#region src/transports/fixtures.d.ts
+/** Let several rounds of queued microtasks and op batches drain. */
+declare const settle: () => Promise<void>;
+/** A minimal statewire host element: `{ count }` state with an `increment` command. */
+declare const createCounterElement: () => import("@assistant-ui/tap").ResourceElement<{
+  state: {
+    count: number;
+  };
+  commands: Statewire.CommandsProxy<StatewireHost.HandledCommands<{
+    increment: () => void;
+  }>>;
+  emit: (event: unknown) => void;
+}>;
+/** Serialize a command frame as a client would send it over a socket. */
+declare const commandFrame: (method: string, seq: number, params?: unknown[]) => string;
+type SocketRecorder = {
+  sent: string[];
+  closes: {
+    code?: number;
+    reason?: string;
+  }[];
+  last: () => any;
+  send: (data: string) => void;
+  close: (code?: number, reason?: string) => void;
+};
+/** Record sent frames and close calls; `last()` parses the latest frame. */
+declare const createSocketRecorder: () => SocketRecorder;
+//#endregion
+export { SocketRecorder, commandFrame, createCounterElement, createSocketRecorder, settle };
+//# sourceMappingURL=fixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","names":[],"sources":["../../src/transports/fixtures.ts"],"mappings":";;;;;cASa,cAAM;;cAKN,wDAAoB;;;;YAApB,UAAA,cAAA,cAAA;;;;;;cAaA,eACX,gBACA,aACA;KAGU;EACV;EACA;IAAU;IAAe;;EACzB;EACA,OAAO;EACP,QAAQ,eAAe;;;cAIZ,4BAA2B"}

package/dist/transports/fixtures.js

@@ -0,0 +1,50 @@
+import { useStatewireCommands, useStatewireEmit, useStatewireState } from "../host/host.js";
+import "../host.js";
+import { tick } from "./testing.js";
+import { resource } from "@assistant-ui/tap";
+//#region src/transports/fixtures.ts
+/** Let several rounds of queued microtasks and op batches drain. */
+const settle = async () => {
+	for (let i = 0; i < 3; i++) await tick();
+};
+/** A minimal statewire host element: `{ count }` state with an `increment` command. */
+const createCounterElement = () => resource(() => {
+	const [state] = useStatewireState(() => ({ count: 0 }));
+	const emit = useStatewireEmit();
+	return {
+		state,
+		commands: useStatewireCommands({ increment: () => {
+			state.count += 1;
+		} }),
+		emit
+	};
+})();
+/** Serialize a command frame as a client would send it over a socket. */
+const commandFrame = (method, seq, params = []) => JSON.stringify({
+	method,
+	params,
+	seq
+});
+/** Record sent frames and close calls; `last()` parses the latest frame. */
+const createSocketRecorder = () => {
+	const sent = [];
+	const closes = [];
+	return {
+		sent,
+		closes,
+		last: () => JSON.parse(sent.at(-1)),
+		send: (data) => {
+			sent.push(data);
+		},
+		close: (code, reason) => {
+			closes.push({
+				...code !== void 0 && { code },
+				...reason !== void 0 && { reason }
+			});
+		}
+	};
+};
+//#endregion
+export { commandFrame, createCounterElement, createSocketRecorder, settle };
+
+//# sourceMappingURL=fixtures.js.map

package/dist/transports/fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.js","names":["resource","useStatewireCommands","useStatewireEmit","useStatewireState","tick","settle","i","createCounterElement","state","count","emit","commands","increment","commandFrame","method","seq","params","JSON","stringify","SocketRecorder","sent","closes","code","reason","last","send","data","close","createSocketRecorder","parse","at","push","undefined"],"sources":["../../src/transports/fixtures.ts"],"sourcesContent":["import { resource } from \"@assistant-ui/tap\";\nimport {\n  useStatewireCommands,\n  useStatewireEmit,\n  useStatewireState,\n} from \"../host\";\nimport { tick } from \"./testing\";\n\n/** Let several rounds of queued microtasks and op batches drain. */\nexport const settle = async () => {\n  for (let i = 0; i < 3; i++) await tick();\n};\n\n/** A minimal statewire host element: `{ count }` state with an `increment` command. */\nexport const createCounterElement = () =>\n  resource(() => {\n    const [state] = useStatewireState(() => ({ count: 0 }));\n    const emit = useStatewireEmit();\n    const commands = useStatewireCommands({\n      increment: () => {\n        state.count += 1;\n      },\n    });\n    return { state, commands, emit };\n  })();\n\n/** Serialize a command frame as a client would send it over a socket. */\nexport const commandFrame = (\n  method: string,\n  seq: number,\n  params: unknown[] = [],\n) => JSON.stringify({ method, params, seq });\n\nexport type SocketRecorder = {\n  sent: string[];\n  closes: { code?: number; reason?: string }[];\n  last: () => any;\n  send: (data: string) => void;\n  close: (code?: number, reason?: string) => void;\n};\n\n/** Record sent frames and close calls; `last()` parses the latest frame. */\nexport const createSocketRecorder = (): SocketRecorder => {\n  const sent: string[] = [];\n  const closes: { code?: number; reason?: string }[] = [];\n  return {\n    sent,\n    closes,\n    last: () => JSON.parse(sent.at(-1)!),\n    send: (data) => {\n      sent.push(data);\n    },\n    close: (code, reason) => {\n      closes.push({\n        ...(code !== undefined && { code }),\n        ...(reason !== undefined && { reason }),\n      });\n    },\n  };\n};\n"],"mappings":";;;;;;AASA,MAAaK,SAAS,YAAY;CAChC,KAAK,IAAIC,IAAI,GAAGA,IAAI,GAAGA,KAAK,MAAMF,KAAK;AACzC;;AAGA,MAAaG,6BACXP,eAAe;CACb,MAAM,CAACQ,SAASL,yBAAyB,EAAEM,OAAO,EAAE,EAAE;CACtD,MAAMC,OAAOR,iBAAiB;CAM9B,OAAO;EAAEM;EAAOG,UALCV,qBAAqB,EACpCW,iBAAiB;GACfJ,MAAMC,SAAS;EACjB,EACF,CACgBE;EAAUD;CAAK;AACjC,CAAC,CAAC,CAAC;;AAGL,MAAaG,gBACXC,QACAC,KACAC,SAAoB,CAAA,MACjBC,KAAKC,UAAU;CAAEJ;CAAQE;CAAQD;AAAI,CAAC;;AAW3C,MAAaa,6BAA6C;CACxD,MAAMR,OAAiB,CAAA;CACvB,MAAMC,SAA+C,CAAA;CACrD,OAAO;EACLD;EACAC;EACAG,YAAYP,KAAKY,MAAMT,KAAKU,GAAG,EAAE,CAAE;EACnCL,OAAOC,SAAS;GACdN,KAAKW,KAAKL,IAAI;EAChB;EACAC,QAAQL,MAAMC,WAAW;GACvBF,OAAOU,KAAK;IACV,GAAIT,SAASU,KAAAA,KAAa,EAAEV,KAAK;IACjC,GAAIC,WAAWS,KAAAA,KAAa,EAAET,OAAO;GACvC,CAAC;EACH;CACF;AACF"}

package/dist/transports/remote.d.ts

@@ -1,19 +1,12 @@
-import { ConnBase } from "../client/connection.js";
-import { RemoteLink, StatewireConnection, StatewireTransportProps } from "./sse.js";
-import { StatewireTransport } from "../types.js";
-import { SessionOptions } from "../client/session.js";
+import { RemoteLink, StatewireRemoteProps } from "./sse.js";
+import { StatewireSessionStoreOptions } from "../client/sessionStore.js";
+import { StatewireClient } from "../statewire.js";
+import { Statewire } from "../types.js";
 //#region src/transports/remote.d.ts
 declare const useStatewireRemote: <TOptions extends {
   url: string;
-  onChange?: (connection: StatewireConnection) => void;
-} & SessionOptions>(options: TOptions, create: (latest: {
-  readonly current: {
-    options: TOptions;
-    ctx: StatewireTransportProps;
-  };
-}, notify: (connection: StatewireConnection) => void) => ConnBase & {
-  send: RemoteLink["send"];
-}) => StatewireTransport<any, any, any>;
+  onChange?: (connection: StatewireClient.Connection) => void;
+} & StatewireSessionStoreOptions>(options: TOptions, useLink: (options: TOptions, ctx: StatewireRemoteProps) => RemoteLink) => Statewire<any, any, any>;
 //#endregion
 export { useStatewireRemote };
 //# sourceMappingURL=remote.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"remote.d.ts","names":[],"sources":["../../src/transports/remote.ts"],"mappings":";;;;;cAqBa,qBACX;EACE;EACA,YAAY,YAAY;IACtB,gBAEJ,SAAS,UACT,SACE;WACW;IAAW,SAAS;IAAU,KAAK;;GAE9C,SAAS,YAAY,iCAClB;EAAa,MAAM;MACvB"}
+{"version":3,"file":"remote.d.ts","names":[],"sources":["../../src/transports/remote.ts"],"mappings":";;;;;cAYa,qBACX;EACE;EACA,YAAY,YAAY,gBAAgB;IACtC,8BAEJ,SAAS,UACT,UAAU,SAAS,UAAU,KAAK,yBAAyB,eAC1D"}

package/dist/transports/remote.js

@@ -1,37 +1,19 @@
 import { useStatewireEmit } from "../host/host.js";
-import { useStatewireConn } from "../client/connection.js";
-import { createSession, handleFinish, handleOps, handleSnapshot, setTransport, start, stop } from "../client/session.js";
-import { useEffect, useState } from "@assistant-ui/tap/react-shim";
+import { setContext, setTransport, useStatewireSession } from "../client/session.js";
+import { useEffect } from "@assistant-ui/tap/react-shim";
 //#region src/transports/remote.ts
-const useStatewireRemote = (options, create) => {
+const useStatewireRemote = (options, useLink) => {
 	const emit = useStatewireEmit();
-	const [s] = useState(() => createSession({ sessionStore: options.sessionStore }));
-	useEffect(() => {
-		s.emitEvent = emit;
-		return () => {
-			s.emitEvent = () => {};
-		};
-	}, [s, emit]);
-	useEffect(() => {
-		start(s);
-		return () => stop(s);
-	}, [s]);
-	const [ctx] = useState(() => ({
-		get clientId() {
-			return s.record.clientId;
-		},
-		onSnapshot: (args) => handleSnapshot(s, args),
-		onOps: (args_0) => handleOps(s, args_0),
-		onFinish: (args_1) => handleFinish(s, args_1)
-	}));
-	const conn = useStatewireConn(options, ctx, create);
+	const s = useStatewireSession({ sessionStore: options.sessionStore }, emit);
+	const conn = useLink(options, s.ctx);
 	useEffect(() => setTransport(s, conn), [s, conn]);
 	return {
 		state: s.canonical,
 		commands: s.commands,
 		emit,
 		connection: conn.connection,
-		source: s.source
+		source: s.source,
+		setContext: (value) => setContext(s, value)
 	};
 };
 //#endregion

package/dist/transports/remote.js.map

@@ -1 +1 @@
-{"version":3,"file":"remote.js","names":["useEffect","useState","useStatewireConn","ConnBase","useStatewireEmit","StatewireTransport","createSession","handleFinish","handleOps","handleSnapshot","setTransport","start","stop","SessionOptions","RemoteLink","StatewireConnection","StatewireTransportProps","useStatewireRemote","url","onChange","connection","options","TOptions","create","latest","current","ctx","notify","send","emit","s","sessionStore","emitEvent","clientId","record","onSnapshot","args","onOps","onFinish","conn","state","canonical","commands","source"],"sources":["../../src/transports/remote.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { useStatewireConn } from \"../client/connection\";\nimport type { ConnBase } from \"../client/connection\";\nimport { useStatewireEmit } from \"../host/host\";\nimport type { StatewireTransport } from \"../types\";\nimport {\n  createSession,\n  handleFinish,\n  handleOps,\n  handleSnapshot,\n  setTransport,\n  start,\n  stop,\n} from \"../client/session\";\nimport type { SessionOptions } from \"../client/session\";\nimport type {\n  RemoteLink,\n  StatewireConnection,\n  StatewireTransportProps,\n} from \"./sse\";\n\nexport const useStatewireRemote = <\n  TOptions extends {\n    url: string;\n    onChange?: (connection: StatewireConnection) => void;\n  } & SessionOptions,\n>(\n  options: TOptions,\n  create: (\n    latest: {\n      readonly current: { options: TOptions; ctx: StatewireTransportProps };\n    },\n    notify: (connection: StatewireConnection) => void,\n  ) => ConnBase & { send: RemoteLink[\"send\"] },\n): StatewireTransport<any, any, any> => {\n  const emit = useStatewireEmit<any>();\n  const [s] = useState(() =>\n    createSession({ sessionStore: options.sessionStore }),\n  );\n\n  useEffect(() => {\n    s.emitEvent = emit;\n    return () => {\n      s.emitEvent = () => {};\n    };\n  }, [s, emit]);\n  useEffect(() => {\n    start(s);\n    return () => stop(s);\n  }, [s]);\n\n  const [ctx] = useState(\n    (): StatewireTransportProps => ({\n      get clientId() {\n        return s.record.clientId;\n      },\n      onSnapshot: (args) => handleSnapshot(s, args),\n      onOps: (args) => handleOps(s, args),\n      onFinish: (args) => handleFinish(s, args),\n    }),\n  );\n  const conn = useStatewireConn(options, ctx, create);\n  useEffect(() => setTransport(s, conn), [s, conn]);\n\n  return {\n    state: s.canonical,\n    commands: s.commands,\n    emit,\n    connection: conn.connection,\n    source: s.source,\n  };\n};\n"],"mappings":";;;;;AAqBA,MAAaiB,sBAMXI,SACAE,WAMsC;CACtC,MAAMM,OAAOzB,iBAAsB;CACnC,MAAM,CAAC0B,KAAK7B,eACVK,cAAc,EAAEyB,cAAcV,QAAQU,aAAa,CAAC,CACtD;CAEA/B,gBAAgB;EACd8B,EAAEE,YAAYH;EACd,aAAa;GACXC,EAAEE,kBAAkB,CAAC;EACvB;CACF,GAAG,CAACF,GAAGD,IAAI,CAAC;CACZ7B,gBAAgB;EACdW,MAAMmB,CAAC;EACP,aAAalB,KAAKkB,CAAC;CACrB,GAAG,CAACA,CAAC,CAAC;CAEN,MAAM,CAACJ,OAAOzB,gBACoB;EAC9B,IAAIgC,WAAW;GACb,OAAOH,EAAEI,OAAOD;EAClB;EACAE,aAAaC,SAAS3B,eAAeqB,GAAGM,IAAI;EAC5CC,QAAQD,WAAS5B,UAAUsB,GAAGM,MAAI;EAClCE,WAAWF,WAAS7B,aAAauB,GAAGM,MAAI;CAC1C,EACF;CACA,MAAMG,OAAOrC,iBAAiBmB,SAASK,KAAKH,MAAM;CAClDvB,gBAAgBU,aAAaoB,GAAGS,IAAI,GAAG,CAACT,GAAGS,IAAI,CAAC;CAEhD,OAAO;EACLC,OAAOV,EAAEW;EACTC,UAAUZ,EAAEY;EACZb;EACAT,YAAYmB,KAAKnB;EACjBuB,QAAQb,EAAEa;CACZ;AACF"}
+{"version":3,"file":"remote.js","names":["useEffect","useStatewireEmit","Statewire","setContext","setTransport","useStatewireSession","StatewireSessionStoreOptions","StatewireClient","RemoteLink","StatewireRemoteProps","useStatewireRemote","url","onChange","connection","Connection","options","TOptions","useLink","ctx","emit","s","sessionStore","conn","state","canonical","commands","source","value"],"sources":["../../src/transports/remote.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useStatewireEmit } from \"../host/host\";\nimport type { Statewire } from \"../types\";\nimport {\n  setContext,\n  setTransport,\n  useStatewireSession,\n} from \"../client/session\";\nimport type { StatewireSessionStoreOptions } from \"../client/sessionStore\";\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  } & StatewireSessionStoreOptions,\n>(\n  options: TOptions,\n  useLink: (options: TOptions, ctx: StatewireRemoteProps) => RemoteLink,\n): Statewire<any, any, any> => {\n  const emit = useStatewireEmit<any>();\n  const s = useStatewireSession({ sessionStore: options.sessionStore }, emit);\n  const conn = useLink(options, s.ctx);\n  useEffect(() => setTransport(s, conn), [s, conn]);\n\n  return {\n    state: s.canonical,\n    commands: s.commands,\n    emit,\n    connection: conn.connection,\n    source: s.source,\n    setContext: (value) => setContext(s, value),\n  };\n};\n"],"mappings":";;;;AAYA,MAAaU,sBAMXK,SACAE,YAC6B;CAC7B,MAAME,OAAOlB,iBAAsB;CACnC,MAAMmB,IAAIf,oBAAoB,EAAEgB,cAAcN,QAAQM,aAAa,GAAGF,IAAI;CAC1E,MAAMG,OAAOL,QAAQF,SAASK,EAAEF,GAAG;CACnClB,gBAAgBI,aAAagB,GAAGE,IAAI,GAAG,CAACF,GAAGE,IAAI,CAAC;CAEhD,OAAO;EACLC,OAAOH,EAAEI;EACTC,UAAUL,EAAEK;EACZN;EACAN,YAAYS,KAAKT;EACjBa,QAAQN,EAAEM;EACVvB,aAAawB,UAAUxB,WAAWiB,GAAGO,KAAK;CAC5C;AACF"}