statewire 0.0.1 → 0.0.3

package/dist/transports/ws.js

@@ -1,67 +1,42 @@
-import { encodeParams } from "../wire/meta.js";
+import { CLIENT_QUERY_PARAM } from "../host/adapter.js";
 import { timing } from "../client/timing.js";
-import { createGate, handleEnvelope, overloadedError, reconnectConn } from "../client/connection.js";
+import { handleEnvelope, overloadedError, useStatewireConn } from "../client/connection.js";
 import { useStatewireRemote } from "./remote.js";
+import { encodeWireCommand } from "./sse.js";
+import { useState } from "@assistant-ui/tap/react-shim";
 import { flushTapSync, resource } from "@assistant-ui/tap";
 //#region src/transports/ws.ts
 const OPEN = 1;
 const WS_SUBPROTOCOL = "statewire.v1";
-const createConn = (latest, notify) => {
-	const c = {
-		hasSnapshot: false,
-		lease: null,
-		attempt: 0,
-		episode: null,
-		abort: null,
-		socket: null,
-		pending: [],
-		gate: createGate(),
-		lifetime: null,
-		latest,
-		notify,
-		reconnect: () => reconnectConn(c),
-		attemptOnce: (abort) => attemptSocket(c, abort),
-		send: (args) => sendCommand(c, args),
-		connection: {
-			status: "connecting",
-			reconnect: () => c.reconnect()
-		}
-	};
-	return c;
-};
-const socketUrl = async (c) => {
-	const { url, query } = c.latest.current.options;
+const socketUrl = async (options, clientId) => {
+	const { url, query } = options;
 	const params = new URLSearchParams(typeof query === "function" ? await query() : query);
-	params.set("client", c.latest.current.ctx.clientId);
+	params.set(CLIENT_QUERY_PARAM, clientId);
 	return `${url.replace(/\/$/, "").replace(/^http/, "ws")}/ws?${params.toString()}`;
 };
-const settleOverloaded = (c, { seq, retryAfterMs }) => {
+const settleOverloaded = (w, { seq, retryAfterMs }) => {
 	if (seq === void 0) throw overloadedError(retryAfterMs);
-	const entry = c.pending.find((p) => p.seq === seq);
+	const entry = w.pending.find((p) => p.seq === seq);
 	if (!entry) return;
-	c.pending = c.pending.filter((p) => p !== entry);
+	w.pending = w.pending.filter((p) => p !== entry);
 	entry.reject(overloadedError(retryAfterMs));
 };
-const resolveReceipts = (c, ack) => {
-	while (c.pending[0] && c.pending[0].seq <= ack) c.pending.shift().resolve({ type: "receipt" });
-};
-const resolveResponded = (c, seqs) => {
+const resolvePending = (w, matches) => {
 	const remaining = [];
-	for (const entry of c.pending) if (seqs.has(entry.seq)) entry.resolve({ type: "receipt" });
+	for (const entry of w.pending) if (matches(entry)) entry.resolve({ type: "receipt" });
 	else remaining.push(entry);
-	c.pending = remaining;
+	w.pending = remaining;
 };
-const failPending = (c, error) => {
-	const pending = c.pending;
-	c.pending = [];
+const failPending = (w, error) => {
+	const pending = w.pending;
+	w.pending = [];
 	for (const entry of pending) entry.reject(error);
 };
-const runSocket = (c, ws, abort) => new Promise((resolve, reject) => {
+const runSocket = (c, w, ws, abort) => new Promise((resolve, reject) => {
 	let timer;
 	let timedOut = false;
 	let outcome = null;
 	let closed = false;
-	let attached = false;
 	const arm = () => {
 		clearTimeout(timer);
 		timer = setTimeout(() => {
@@ -79,10 +54,15 @@ const runSocket = (c, ws, abort) => new Promise((resolve, reject) => {
 		ws.close();
 	};
 	const processEnv = (env) => {
-		const done = flushTapSync(() => handleEnvelope(c, env, attached));
-		attached = true;
-		if (env.ack !== void 0) resolveReceipts(c, env.ack);
-		if (env.res !== void 0) resolveResponded(c, new Set(env.res.map((r) => r.seq)));
+		const done = flushTapSync(() => handleEnvelope(c, env));
+		if (env.ack !== void 0) {
+			const ack = env.ack;
+			resolvePending(w, (entry) => entry.seq <= ack);
+		}
+		if (env.res !== void 0) {
+			const seqs = new Set(env.res.map((r) => r.seq));
+			resolvePending(w, (entry) => seqs.has(entry.seq));
+		}
 		if (done) {
 			outcome = done;
 			ws.close();
@@ -99,7 +79,7 @@ const runSocket = (c, ws, abort) => new Promise((resolve, reject) => {
 			return;
 		}
 		try {
-			if (frame.overloaded !== void 0) settleOverloaded(c, frame.overloaded);
+			if (frame.overloaded !== void 0) settleOverloaded(w, frame.overloaded);
 			else processEnv(frame);
 		} catch (error) {
 			fail(error);
@@ -108,28 +88,28 @@ const runSocket = (c, ws, abort) => new Promise((resolve, reject) => {
 	ws.onclose = () => {
 		closed = true;
 		clearTimeout(timer);
-		if (c.socket === ws) failPending(c, /* @__PURE__ */ new Error("network"));
+		if (w.socket === ws) failPending(w, /* @__PURE__ */ new Error("network"));
 		if (outcome) resolve(outcome);
 		else reject(/* @__PURE__ */ new Error(timedOut ? "timeout" : "network"));
 	};
 });
-const attemptSocket = async (c, abort) => {
+const attemptSocket = async (c, w, options, abort) => {
 	let ws = null;
 	try {
-		const url = await socketUrl(c);
+		const url = await socketUrl(options, c.ctx.clientId);
 		abort.signal.throwIfAborted();
-		const { protocols, webSocket } = c.latest.current.options;
+		const { protocols, webSocket } = options;
 		const WS = webSocket ?? globalThis.WebSocket;
 		if (!WS) throw new Error("no WebSocket implementation");
 		ws = new WS(url, [WS_SUBPROTOCOL, ...protocols === void 0 ? [] : typeof protocols === "string" ? [protocols] : protocols]);
-		c.socket = ws;
-		return await runSocket(c, ws, abort);
+		w.socket = ws;
+		return await runSocket(c, w, ws, abort);
 	} finally {
-		if (c.socket === ws) c.socket = null;
+		if (w.socket === ws) w.socket = null;
 	}
 };
-const sendCommand = (c, { seq, command }) => {
-	const ws = c.socket;
+const sendCommand = (w, { seq, command }) => {
+	const ws = w.socket;
 	if (!ws || ws.readyState !== OPEN) return Promise.reject(/* @__PURE__ */ new Error("network"));
 	return new Promise((resolve, reject) => {
 		const entry = {
@@ -144,27 +124,43 @@ const sendCommand = (c, { seq, command }) => {
 			}
 		};
 		const timer = setTimeout(() => {
-			c.pending = c.pending.filter((p) => p !== entry);
+			w.pending = w.pending.filter((p) => p !== entry);
 			reject(/* @__PURE__ */ new Error("timeout"));
 			ws.close();
 		}, timing.heartbeatTimeoutMs);
-		c.pending.push(entry);
+		w.pending.push(entry);
 		try {
 			ws.send(JSON.stringify({
-				method: command.method,
-				...encodeParams(command.params),
+				...encodeWireCommand(command),
 				seq
 			}));
 		} catch {
 			clearTimeout(timer);
-			c.pending = c.pending.filter((p) => p !== entry);
+			w.pending = w.pending.filter((p) => p !== entry);
 			reject(/* @__PURE__ */ new Error("network"));
 		}
 	});
 };
-const useStatewireWS = (options) => {
-	return useStatewireRemote(options, createConn);
+const useWsLink = (options, ctx) => {
+	const [w] = useState(() => ({
+		socket: null,
+		pending: []
+	}));
+	const c_0 = useStatewireConn({
+		url: options.url,
+		onChange: options.onChange,
+		ctx,
+		attemptOnce: (c, abort) => attemptSocket(c, w, options, abort)
+	});
+	const [link] = useState(() => ({
+		get connection() {
+			return c_0.connection;
+		},
+		send: (args) => sendCommand(w, args)
+	}));
+	return link;
 };
+const useStatewireWS = (options) => useStatewireRemote(options, useWsLink);
 const StatewireWS = resource(useStatewireWS);
 //#endregion
 export { StatewireWS, WS_SUBPROTOCOL };

package/dist/transports/ws.js.map

@@ -1 +1 @@
-{"version":3,"file":"ws.js","names":["flushTapSync","resource","ResourceElement","encodeParams","timing","createGate","handleEnvelope","overloadedError","reconnectConn","ConnBase","StatewireEnvelope","StatewireTransport","useStatewireRemote","StatewireSessionStore","StatewireCommands","RemoteLink","StatewireSubmitResult","StatewireConnection","StatewireTransportProps","StatewireWireCommand","StatewireWSOptions","url","protocols","query","Record","Promise","webSocket","WebSocket","onChange","connection","sessionStore","Latest","options","ctx","PendingCommand","seq","resolve","result","reject","error","Error","Conn","socket","pending","latest","current","send","OPEN","WS_SUBPROTOCOL","createConn","notify","c","hasSnapshot","lease","attempt","episode","abort","gate","lifetime","reconnect","attemptOnce","attemptSocket","args","sendCommand","status","socketUrl","params","URLSearchParams","set","clientId","base","replace","toString","settleOverloaded","retryAfterMs","undefined","entry","find","p","filter","resolveReceipts","ack","shift","type","resolveResponded","seqs","Set","remaining","has","push","failPending","runSocket","ws","AbortController","timer","ReturnType","setTimeout","timedOut","outcome","closed","attached","arm","clearTimeout","close","heartbeatTimeoutMs","signal","addEventListener","onerror","stale","Boolean","aborted","fail","processEnv","env","done","res","map","r","onmessage","event","frame","overloaded","JSON","parse","String","data","onclose","throwIfAborted","WS","globalThis","extra","command","readyState","stringify","method","useStatewireWS","StatewireWS","TState","TCommands","TEvent"],"sources":["../../src/transports/ws.ts"],"sourcesContent":["import { flushTapSync, resource } from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { encodeParams } from \"../wire/meta\";\nimport { timing } from \"../client/timing\";\nimport {\n  createGate,\n  handleEnvelope,\n  overloadedError,\n  reconnectConn,\n} from \"../client/connection\";\nimport type { ConnBase, StatewireEnvelope } from \"../client/connection\";\nimport type { StatewireTransport } from \"../types\";\nimport { useStatewireRemote } from \"./remote\";\nimport type { StatewireSessionStore } from \"../client/sessionStore\";\nimport type { StatewireCommands } from \"../types\";\nimport type {\n  RemoteLink,\n  StatewireSubmitResult,\n  StatewireConnection,\n  StatewireTransportProps,\n  StatewireWireCommand,\n} from \"./sse\";\n\nexport type StatewireWSOptions = {\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: StatewireConnection) => void;\n  sessionStore?: StatewireSessionStore;\n};\n\ntype Latest = {\n  options: StatewireWSOptions;\n  ctx: StatewireTransportProps;\n};\n\ntype PendingCommand = {\n  seq: number;\n  resolve: (result: StatewireSubmitResult) => void;\n  reject: (error: Error) => void;\n};\n\ntype Conn = ConnBase & {\n  socket: WebSocket | null;\n  pending: PendingCommand[];\n  latest: { readonly current: Latest };\n  send: RemoteLink[\"send\"];\n};\n\nconst OPEN = 1;\n\nexport const WS_SUBPROTOCOL = \"statewire.v1\";\n\nconst createConn = (\n  latest: { readonly current: Latest },\n  notify: (connection: StatewireConnection) => void,\n): Conn => {\n  const c: Conn = {\n    hasSnapshot: false,\n    lease: null,\n    attempt: 0,\n    episode: null,\n    abort: null,\n    socket: null,\n    pending: [],\n    gate: createGate(),\n    lifetime: null,\n    latest,\n    notify,\n    reconnect: () => reconnectConn(c),\n    attemptOnce: (abort) => attemptSocket(c, abort),\n    send: (args) => sendCommand(c, args),\n    connection: { status: \"connecting\", reconnect: () => c.reconnect() },\n  };\n  return c;\n};\n\nconst socketUrl = async (c: Conn) => {\n  const { url, query } = c.latest.current.options;\n  const params = new URLSearchParams(\n    typeof query === \"function\" ? await query() : query,\n  );\n  params.set(\"client\", c.latest.current.ctx.clientId);\n  const base = url.replace(/\\/$/, \"\").replace(/^http/, \"ws\");\n  return `${base}/ws?${params.toString()}`;\n};\n\nconst settleOverloaded = (\n  c: Conn,\n  { seq, retryAfterMs }: { seq?: number; retryAfterMs?: number },\n) => {\n  if (seq === undefined) throw overloadedError(retryAfterMs);\n  const entry = c.pending.find((p) => p.seq === seq);\n  if (!entry) return;\n  c.pending = c.pending.filter((p) => p !== entry);\n  entry.reject(overloadedError(retryAfterMs));\n};\n\nconst resolveReceipts = (c: Conn, ack: number) => {\n  while (c.pending[0] && c.pending[0].seq <= ack) {\n    c.pending.shift()!.resolve({ type: \"receipt\" });\n  }\n};\n\nconst resolveResponded = (c: Conn, seqs: Set<number>) => {\n  const remaining: PendingCommand[] = [];\n  for (const entry of c.pending) {\n    if (seqs.has(entry.seq)) entry.resolve({ type: \"receipt\" });\n    else remaining.push(entry);\n  }\n  c.pending = remaining;\n};\n\nconst failPending = (c: Conn, error: Error) => {\n  const pending = c.pending;\n  c.pending = [];\n  for (const entry of pending) entry.reject(error);\n};\n\nconst runSocket = (\n  c: Conn,\n  ws: WebSocket,\n  abort: AbortController,\n): Promise<\"stop\" | \"reattach\"> =>\n  new Promise((resolve, reject) => {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let timedOut = false;\n    let outcome: \"stop\" | \"reattach\" | null = null;\n    let closed = false;\n    let attached = 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    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    const processEnv = (env: StatewireEnvelope) => {\n      const done = flushTapSync(() => handleEnvelope(c, env, attached));\n      attached = true;\n      if (env.ack !== undefined) resolveReceipts(c, env.ack);\n      if (env.res !== undefined) {\n        resolveResponded(c, new Set(env.res.map((r) => r.seq)));\n      }\n      if (done) {\n        outcome = done;\n        ws.close();\n      }\n    };\n    ws.onmessage = (event) => {\n      if (stale()) return;\n      arm();\n      let frame: StatewireEnvelope & {\n        overloaded?: { seq?: number; retryAfterMs?: number };\n      };\n      try {\n        frame = JSON.parse(String(event.data)) as typeof frame;\n      } catch {\n        fail(new Error(\"protocol\"));\n        return;\n      }\n      try {\n        if (frame.overloaded !== undefined) {\n          settleOverloaded(c, frame.overloaded);\n        } else {\n          processEnv(frame);\n        }\n      } catch (error) {\n        fail(error);\n      }\n    };\n    ws.onclose = () => {\n      closed = true;\n      clearTimeout(timer);\n      if (c.socket === ws) failPending(c, new Error(\"network\"));\n      if (outcome) resolve(outcome);\n      else reject(new Error(timedOut ? \"timeout\" : \"network\"));\n    };\n  });\n\nconst attemptSocket = async (\n  c: Conn,\n  abort: AbortController,\n): Promise<\"stop\" | \"reattach\"> => {\n  let ws: WebSocket | null = null;\n  try {\n    const url = await socketUrl(c);\n    abort.signal.throwIfAborted();\n    const { protocols, webSocket } = c.latest.current.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    c.socket = ws;\n    return await runSocket(c, ws, abort);\n  } finally {\n    if (c.socket === ws) c.socket = null;\n  }\n};\n\nconst sendCommand = (\n  c: Conn,\n  { seq, command }: { seq: number; command: StatewireWireCommand },\n): Promise<StatewireSubmitResult> => {\n  const ws = c.socket;\n  if (!ws || ws.readyState !== OPEN) {\n    return Promise.reject(new Error(\"network\"));\n  }\n  return new Promise((resolve, reject) => {\n    const entry: PendingCommand = {\n      seq,\n      resolve: (result) => {\n        clearTimeout(timer);\n        resolve(result);\n      },\n      reject: (error) => {\n        clearTimeout(timer);\n        reject(error);\n      },\n    };\n    // A timed-out command fails the socket: the retry then rides reconnect +\n    // attach-seq arbitration.\n    const timer = setTimeout(() => {\n      c.pending = c.pending.filter((p) => p !== entry);\n      reject(new Error(\"timeout\"));\n      ws.close();\n    }, timing.heartbeatTimeoutMs);\n    c.pending.push(entry);\n    try {\n      ws.send(\n        JSON.stringify({\n          method: command.method,\n          ...encodeParams(command.params),\n          seq,\n        }),\n      );\n    } catch {\n      clearTimeout(timer);\n      c.pending = c.pending.filter((p) => p !== entry);\n      reject(new Error(\"network\"));\n    }\n  });\n};\n\nconst useStatewireWS = (\n  options: StatewireWSOptions,\n): StatewireTransport<any, any, any> => useStatewireRemote(options, createConn);\n\nexport const StatewireWS = resource(useStatewireWS) as <\n  TState = any,\n  TCommands extends StatewireCommands = StatewireCommands,\n  TEvent = any,\n>(\n  options: StatewireWSOptions,\n) => ResourceElement<StatewireTransport<TState | undefined, TCommands, TEvent>>;\n"],"mappings":"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"}
+{"version":3,"file":"ws.js","names":["useState","flushTapSync","resource","ResourceElement","timing","handleEnvelope","overloadedError","useStatewireConn","Conn","StatewireEnvelope","Statewire","StatewireClient","useStatewireRemote","CLIENT_QUERY_PARAM","encodeWireCommand","RemoteLink","StatewireSubmitResult","StatewireRemoteProps","StatewireWireCommand","PendingCommand","seq","resolve","result","reject","error","Error","WsChannel","socket","WebSocket","pending","OPEN","WS_SUBPROTOCOL","socketUrl","options","WSOptions","clientId","url","query","params","URLSearchParams","set","base","replace","toString","settleOverloaded","w","retryAfterMs","undefined","entry","find","p","filter","resolvePending","matches","remaining","type","push","failPending","runSocket","c","ws","abort","AbortController","Promise","timer","ReturnType","setTimeout","timedOut","outcome","closed","arm","clearTimeout","close","heartbeatTimeoutMs","signal","addEventListener","onerror","stale","Boolean","aborted","fail","processEnv","env","done","ack","res","seqs","Set","map","r","has","onmessage","event","frame","overloaded","JSON","parse","String","data","onclose","attemptSocket","ctx","throwIfAborted","protocols","webSocket","WS","globalThis","extra","sendCommand","command","readyState","send","stringify","useWsLink","onChange","attemptOnce","link","connection","args","useStatewireWS","StatewireWS","Commands","TState","TCommands","TEvent"],"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  handleEnvelope,\n  overloadedError,\n  useStatewireConn,\n} from \"../client/connection\";\nimport type { Conn, StatewireEnvelope } 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 { encodeWireCommand } from \"./sse\";\nimport type {\n  RemoteLink,\n  StatewireSubmitResult,\n  StatewireRemoteProps,\n  StatewireWireCommand,\n} from \"./sse\";\n\ntype PendingCommand = {\n  seq: number;\n  resolve: (result: StatewireSubmitResult) => void;\n  reject: (error: Error) => void;\n};\n\ntype WsChannel = {\n  socket: WebSocket | null;\n  pending: PendingCommand[];\n};\n\nconst OPEN = 1;\n\nexport const WS_SUBPROTOCOL = \"statewire.v1\";\n\nconst socketUrl = async (\n  options: StatewireClient.WSOptions,\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 base = url.replace(/\\/$/, \"\").replace(/^http/, \"ws\");\n  return `${base}/ws?${params.toString()}`;\n};\n\nconst settleOverloaded = (\n  w: WsChannel,\n  { seq, retryAfterMs }: { seq?: number; retryAfterMs?: number },\n) => {\n  if (seq === undefined) throw overloadedError(retryAfterMs);\n  const entry = w.pending.find((p) => p.seq === seq);\n  if (!entry) return;\n  w.pending = w.pending.filter((p) => p !== entry);\n  entry.reject(overloadedError(retryAfterMs));\n};\n\nconst resolvePending = (\n  w: WsChannel,\n  matches: (entry: PendingCommand) => boolean,\n) => {\n  const remaining: PendingCommand[] = [];\n  for (const entry of w.pending) {\n    if (matches(entry)) entry.resolve({ type: \"receipt\" });\n    else remaining.push(entry);\n  }\n  w.pending = remaining;\n};\n\nconst failPending = (w: WsChannel, error: Error) => {\n  const pending = w.pending;\n  w.pending = [];\n  for (const entry of pending) entry.reject(error);\n};\n\nconst runSocket = (\n  c: Conn,\n  w: WsChannel,\n  ws: WebSocket,\n  abort: AbortController,\n): Promise<\"stop\" | \"reattach\"> =>\n  new Promise((resolve, reject) => {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let timedOut = false;\n    let outcome: \"stop\" | \"reattach\" | 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    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    const processEnv = (env: StatewireEnvelope) => {\n      const done = flushTapSync(() => handleEnvelope(c, env));\n      if (env.ack !== undefined) {\n        const ack = env.ack;\n        resolvePending(w, (entry) => entry.seq <= ack);\n      }\n      if (env.res !== undefined) {\n        const seqs = new Set(env.res.map((r) => r.seq));\n        resolvePending(w, (entry) => seqs.has(entry.seq));\n      }\n      if (done) {\n        outcome = done;\n        ws.close();\n      }\n    };\n    ws.onmessage = (event) => {\n      if (stale()) return;\n      arm();\n      let frame: StatewireEnvelope & {\n        overloaded?: { seq?: number; retryAfterMs?: number };\n      };\n      try {\n        frame = JSON.parse(String(event.data)) as typeof frame;\n      } catch {\n        fail(new Error(\"protocol\"));\n        return;\n      }\n      try {\n        if (frame.overloaded !== undefined) {\n          settleOverloaded(w, frame.overloaded);\n        } else {\n          processEnv(frame);\n        }\n      } catch (error) {\n        fail(error);\n      }\n    };\n    ws.onclose = () => {\n      closed = true;\n      clearTimeout(timer);\n      if (w.socket === ws) failPending(w, new Error(\"network\"));\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.WSOptions,\n  abort: AbortController,\n): Promise<\"stop\" | \"reattach\"> => {\n  let ws: WebSocket | null = null;\n  try {\n    const url = await socketUrl(options, c.ctx.clientId);\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, w, ws, abort);\n  } finally {\n    if (w.socket === ws) w.socket = null;\n  }\n};\n\nconst sendCommand = (\n  w: WsChannel,\n  { seq, command }: { seq: number; command: StatewireWireCommand },\n): Promise<StatewireSubmitResult> => {\n  const ws = w.socket;\n  if (!ws || ws.readyState !== OPEN) {\n    return Promise.reject(new Error(\"network\"));\n  }\n  return new Promise((resolve, reject) => {\n    const entry: PendingCommand = {\n      seq,\n      resolve: (result) => {\n        clearTimeout(timer);\n        resolve(result);\n      },\n      reject: (error) => {\n        clearTimeout(timer);\n        reject(error);\n      },\n    };\n    // A timed-out command fails the socket: the retry then rides reconnect +\n    // attach-seq arbitration.\n    const timer = setTimeout(() => {\n      w.pending = w.pending.filter((p) => p !== entry);\n      reject(new Error(\"timeout\"));\n      ws.close();\n    }, timing.heartbeatTimeoutMs);\n    w.pending.push(entry);\n    try {\n      ws.send(JSON.stringify({ ...encodeWireCommand(command), seq }));\n    } catch {\n      clearTimeout(timer);\n      w.pending = w.pending.filter((p) => p !== entry);\n      reject(new Error(\"network\"));\n    }\n  });\n};\n\nconst useWsLink = (\n  options: StatewireClient.WSOptions,\n  ctx: StatewireRemoteProps,\n): RemoteLink => {\n  const [w] = useState((): WsChannel => ({ socket: null, pending: [] }));\n  const c = useStatewireConn({\n    url: options.url,\n    onChange: options.onChange,\n    ctx,\n    attemptOnce: (c, abort) => attemptSocket(c, w, options, abort),\n  });\n  const [link] = useState(\n    (): RemoteLink => ({\n      get connection() {\n        return c.connection;\n      },\n      send: (args) => sendCommand(w, args),\n    }),\n  );\n  return link;\n};\n\nconst useStatewireWS = (\n  options: StatewireClient.WSOptions,\n): Statewire<any, any, any> => useStatewireRemote(options, useWsLink);\n\nexport const StatewireWS = resource(useStatewireWS) as <\n  TState = any,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n  TEvent = any,\n>(\n  options: StatewireClient.WSOptions,\n) => ResourceElement<Statewire<TState | undefined, TCommands, TEvent>>;\n"],"mappings":"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"}

package/dist/types.d.ts

@@ -1,107 +1,62 @@
+import { StatewireClient } from "./statewire.js";
 import { StatewirePath } from "./wire/ops.js";
-import { StatewireConnection } from "./transports/sse.js";
-import { ResourceElement } from "@assistant-ui/tap";
 //#region src/types.d.ts
-type StatewireCommands = Record<string, (...args: never[]) => unknown>;
-/** Push-based canonical state feed a transport hands to the client core. */
-type StatewireStateSource = {
-  root: () => unknown;
-  /** Drain the paths changed since the last take (`[]` entry = whole state). */
-  takeChanged: () => StatewirePath[];
-  /** Synchronous, per change; the consumer owns coalescing. */
-  setOnChange: (listener: (() => void) | null) => void;
-};
-type StatewireTransport<TState, TCommands extends StatewireCommands = StatewireCommands, TEvent = any> = {
-  state: TState;
-  commands: StatewireCommandsProxy<TCommands>;
-  emit: (event: TEvent) => void;
-  connection?: StatewireConnection;
-  source?: StatewireStateSource;
-};
-type StatewireCommand<TCommands extends StatewireCommands = StatewireCommands> = { [K in keyof TCommands]: {
-  method: K;
-  params: Parameters<TCommands[K]>;
-}; }[keyof TCommands];
-type StatewireCommandsProxy<TCommands extends StatewireCommands> = { [K in keyof TCommands]: (...args: Parameters<TCommands[K]>) => Promise<Awaited<ReturnType<TCommands[K]>>>; };
-type StatewireCommandUpdate<TCommands extends StatewireCommands = StatewireCommands> = { [K in keyof TCommands]: {
-  method: K;
-  params: Parameters<TCommands[K]>;
-  seq: number;
-  status: "queued" | "posted" | "acked" | "settled";
-  result?: unknown;
-  failure?: SendFailure;
-}; }[keyof TCommands];
-type StatewireOptimisticContext = {
-  ts: number;
-  seq: number;
-  clientId?: string;
-};
-/**
- * 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 StatewireOptimistic<TState, TCommands extends StatewireCommands = StatewireCommands> = (draft: TState, command: StatewireCommand<TCommands>, ctx: StatewireOptimisticContext) => void;
-type StatewireChanges = {
-  isChangedAt(path: readonly (string | number)[]): boolean;
-  getChangedKeys(path: readonly (string | number)[]): string[];
-};
-type StatewireOptions<TState, TCommands extends StatewireCommands = StatewireCommands, TEvent = any> = {
-  transport: ResourceElement<StatewireTransport<TState, TCommands, TEvent>>;
-  optimistic?: StatewireOptimistic<NonNullable<TState>, TCommands>;
-  onEvent?: (event: TEvent, ctx: {
-    state: NonNullable<TState>;
-  }) => void;
-  onStateChange?: (state: NonNullable<TState>, ctx: {
-    changes: StatewireChanges;
-  }) => void;
-  onCommandChange?: (update: StatewireCommandUpdate<TCommands>, ctx: {
-    state: NonNullable<TState>;
-  }) => void;
-};
-type StatewireHelpers<TState, TCommands extends StatewireCommands = StatewireCommands> = {
-  /** The transport's state type — remote transports include `undefined` until the first attach snapshot applies. */
+declare namespace Statewire {
+  type Commands = Record<string, (...args: never[]) => unknown>;
+  type Command<TCommands extends Commands = Commands> = { [K in keyof TCommands]: {
+    method: K;
+    params: Parameters<TCommands[K]>;
+  }; }[keyof TCommands];
+  type CommandsProxy<TCommands extends Commands> = { [K in keyof TCommands]: (...args: Parameters<TCommands[K]>) => Promise<Awaited<ReturnType<TCommands[K]>>>; };
+  type CommandUpdate<TCommands extends Commands = Commands> = { [K in keyof TCommands]: {
+    method: K;
+    params: Parameters<TCommands[K]>;
+    seq: number;
+    status: "queued" | "posted" | "acked" | "settled";
+    result?: unknown;
+    failure?: StatewireClient.SendFailure;
+  }; }[keyof TCommands];
+  /** Push-based canonical state feed a statewire hands to the client core. */
+  type StateSource = {
+    snapshot: () => unknown;
+    /** Drain the paths changed since the last take (`[]` entry = whole state). */
+    takeChanged: () => StatewirePath[];
+    /** Synchronous, per change; the consumer owns coalescing. */
+    setOnChange: (listener: (() => void) | null) => void;
+  };
+  type Op = {
+    op: "replace";
+    path: StatewirePath;
+    value: unknown;
+  } | {
+    op: "add";
+    path: StatewirePath;
+    value: unknown;
+  } | {
+    op: "remove";
+    path: StatewirePath;
+  } | {
+    op: "event";
+    value: object;
+  };
+  type Changes = {
+    isChangedAt(path: readonly (string | number)[]): boolean;
+    getChangedKeys(path: readonly (string | number)[]): string[];
+  };
+}
+interface Statewire<TState = any, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any> {
   state: TState;
-  connection: StatewireConnection;
-  commands: StatewireCommandsProxy<TCommands>;
-};
-/**
- * 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";
-};
+  commands: Statewire.CommandsProxy<TCommands>;
+  emit?: (event: TEvent) => void;
+  connection?: StatewireClient.Connection;
+  source?: Statewire.StateSource;
+  /** Replace this client's ambient context on the server; absent on transports without a client context channel. */
+  setContext?: (value: Record<string, unknown>) => Promise<unknown>;
+}
 declare class StatewireSendError extends Error {
-  readonly failure: SendFailure;
-  constructor(failure: SendFailure);
+  readonly failure: StatewireClient.SendFailure;
+  constructor(failure: StatewireClient.SendFailure);
 }
 //#endregion
-export { SendFailure, StatewireChanges, StatewireCommand, StatewireCommandUpdate, StatewireCommands, StatewireCommandsProxy, StatewireHelpers, StatewireOptimistic, StatewireOptimisticContext, StatewireOptions, StatewireSendError, StatewireStateSource, StatewireTransport };
+export { Statewire, StatewireSendError };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;KAIY,oBAAoB,mBAAmB;;KAGvC;EACV;;EAEA,mBAAmB;;EAEnB,cAAc;;KAGJ,mBACV,QACA,kBAAkB,oBAAoB,mBACtC;EAEA,OAAO;EACP,UAAU,uBAAuB;EACjC,OAAO,OAAO;EACd,aAAa;EACb,SAAS;;KAGC,iBACV,kBAAkB,oBAAoB,wBAErC,WAAW;EAAc,QAAQ;EAAG,QAAQ,WAAW,UAAU;WAC5D;KAEI,uBAAuB,kBAAkB,wBAClD,WAAW,gBACP,MAAM,WAAW,UAAU,QAC3B,QAAQ,QAAQ,WAAW,UAAU;KAGhC,uBACV,kBAAkB,oBAAoB,wBAErC,WAAW;EACV,QAAQ;EACR,QAAQ,WAAW,UAAU;EAC7B;EACA;EACA;EACA,UAAU;WAEN;KAEI;EACV;EACA;EACA;;;;;;KAOU,oBACV,QACA,kBAAkB,oBAAoB,sBAEtC,OAAO,QACP,SAAS,iBAAiB,YAC1B,KAAK;KAGK;EACV,YAAY;EACZ,eAAe;;KAGL,iBACV,QACA,kBAAkB,oBAAoB,mBACtC;EAEA,WAAW,gBAAgB,mBAAmB,QAAQ,WAAW;EACjE,aAAa,oBAAoB,YAAY,SAAS;EACtD,WAAW,OAAO,QAAQ;IAAO,OAAO,YAAY;;EACpD,iBACE,OAAO,YAAY,SACnB;IAAO,SAAS;;EAElB,mBACE,QAAQ,uBAAuB,YAC/B;IAAO,OAAO,YAAY;;;KAIlB,iBACV,QACA,kBAAkB,oBAAoB;;EAGtC,OAAO;EACP,YAAY;EACZ,UAAU,uBAAuB;;;;;;;;;;;KAYvB;EACN;EAAkB;EAAiB;EAAiB;;EACpD;EAAyB;;EACzB;EAAwB;EAAiB;;EACzC;EAAiB;;EAEjB;EACA;;EAQA;EACA;;EAQA;EACA;;cAsBO,2BAA2B;WAC7B,SAAS;EAEN,YAAA,SAAS"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;kBAGiB;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;IACV,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;;IACpB;IAAa;;OAEP;IACV,YAAY;IACZ,eAAe;;;UAIF,UACf,cACA,kBAAkB,UAAU,WAAW,UAAU,UACjD;EAEA,OAAO;EACP,UAAU,UAAU,cAAc;EAClC,QAAQ,OAAO;EACf,aAAa,gBAAgB;EAC7B,SAAS,UAAU;;EAEnB,cAAc,OAAO,4BAA4B;;cAsBtC,2BAA2B;WAC7B,SAAS,gBAAgB;EAEtB,YAAA,SAAS,gBAAgB"}

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":["ResourceElement","StatewireConnection","StatewirePath","StatewireCommands","Record","args","StatewireStateSource","root","takeChanged","setOnChange","listener","StatewireTransport","state","TState","commands","StatewireCommandsProxy","TCommands","emit","event","TEvent","connection","source","StatewireCommand","method","K","params","Parameters","Promise","Awaited","ReturnType","StatewireCommandUpdate","seq","status","result","failure","SendFailure","StatewireOptimisticContext","ts","clientId","StatewireOptimistic","draft","command","ctx","StatewireChanges","isChangedAt","path","getChangedKeys","StatewireOptions","transport","optimistic","NonNullable","onEvent","onStateChange","changes","onCommandChange","update","StatewireHelpers","fate","cause","message","payload","describe","StatewireSendError","Error","constructor","name"],"sources":["../src/types.ts"],"sourcesContent":["import type { ResourceElement } from \"@assistant-ui/tap\";\nimport type { StatewireConnection } from \"./transports/sse\";\nimport type { StatewirePath } from \"./wire/ops\";\n\nexport type StatewireCommands = Record<string, (...args: never[]) => unknown>;\n\n/** Push-based canonical state feed a transport hands to the client core. */\nexport type StatewireStateSource = {\n  root: () => 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\nexport type StatewireTransport<\n  TState,\n  TCommands extends StatewireCommands = StatewireCommands,\n  TEvent = any,\n> = {\n  state: TState;\n  commands: StatewireCommandsProxy<TCommands>;\n  emit: (event: TEvent) => void;\n  connection?: StatewireConnection;\n  source?: StatewireStateSource;\n};\n\nexport type StatewireCommand<\n  TCommands extends StatewireCommands = StatewireCommands,\n> = {\n  [K in keyof TCommands]: { method: K; params: Parameters<TCommands[K]> };\n}[keyof TCommands];\n\nexport type StatewireCommandsProxy<TCommands extends StatewireCommands> = {\n  [K in keyof TCommands]: (\n    ...args: Parameters<TCommands[K]>\n  ) => Promise<Awaited<ReturnType<TCommands[K]>>>;\n};\n\nexport type StatewireCommandUpdate<\n  TCommands extends StatewireCommands = StatewireCommands,\n> = {\n  [K in keyof TCommands]: {\n    method: K;\n    params: Parameters<TCommands[K]>;\n    seq: number;\n    status: \"queued\" | \"posted\" | \"acked\" | \"settled\";\n    result?: unknown;\n    failure?: SendFailure;\n  };\n}[keyof TCommands];\n\nexport type StatewireOptimisticContext = {\n  ts: number;\n  seq: number;\n  clientId?: string;\n};\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 */\nexport type StatewireOptimistic<\n  TState,\n  TCommands extends StatewireCommands = StatewireCommands,\n> = (\n  draft: TState,\n  command: StatewireCommand<TCommands>,\n  ctx: StatewireOptimisticContext,\n) => void;\n\nexport type StatewireChanges = {\n  isChangedAt(path: readonly (string | number)[]): boolean;\n  getChangedKeys(path: readonly (string | number)[]): string[];\n};\n\nexport type StatewireOptions<\n  TState,\n  TCommands extends StatewireCommands = StatewireCommands,\n  TEvent = any,\n> = {\n  transport: ResourceElement<StatewireTransport<TState, TCommands, TEvent>>;\n  optimistic?: StatewireOptimistic<NonNullable<TState>, TCommands>;\n  onEvent?: (event: TEvent, ctx: { state: NonNullable<TState> }) => void;\n  onStateChange?: (\n    state: NonNullable<TState>,\n    ctx: { changes: StatewireChanges },\n  ) => void;\n  onCommandChange?: (\n    update: StatewireCommandUpdate<TCommands>,\n    ctx: { state: NonNullable<TState> },\n  ) => void;\n};\n\nexport type StatewireHelpers<\n  TState,\n  TCommands extends StatewireCommands = StatewireCommands,\n> = {\n  /** The transport's state type — remote transports include `undefined` until the first attach snapshot applies. */\n  state: TState;\n  connection: StatewireConnection;\n  commands: StatewireCommandsProxy<TCommands>;\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 */\nexport 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\nconst describe = (failure: SendFailure): string => {\n  switch (failure.fate) {\n    case \"rejected\":\n      return `statewire: command rejected: ${failure.message}`;\n    case \"unknown-command\":\n      return \"statewire: unknown command\";\n    case \"invalid-params\":\n      return `statewire: invalid params: ${failure.message}`;\n    case \"aborted\":\n      return `statewire: command aborted (${failure.cause})`;\n    case \"lost\":\n      return `statewire: command lost (${failure.cause})`;\n    case \"crashed\":\n      return \"statewire: command crashed\";\n    case \"result-unavailable\":\n      return `statewire: command result unavailable (${failure.cause})`;\n  }\n};\n\nexport class StatewireSendError extends Error {\n  readonly failure: SendFailure;\n\n  constructor(failure: SendFailure) {\n    super(describe(failure));\n    this.name = \"StatewireSendError\";\n    this.failure = failure;\n  }\n}\n"],"mappings":";AA6IA,MAAM6D,YAAY3B,YAAiC;CACjD,QAAQA,QAAQuB,MAAhB;EACE,KAAK,YACH,OAAO,gCAAgCvB,QAAQyB;EACjD,KAAK,mBACH,OAAO;EACT,KAAK,kBACH,OAAO,8BAA8BzB,QAAQyB;EAC/C,KAAK,WACH,OAAO,+BAA+BzB,QAAQwB,MAAK;EACrD,KAAK,QACH,OAAO,4BAA4BxB,QAAQwB,MAAK;EAClD,KAAK,WACH,OAAO;EACT,KAAK,sBACH,OAAO,0CAA0CxB,QAAQwB,MAAK;CAClE;AACF;AAEA,IAAaI,qBAAb,cAAwCC,MAAM;CAC5C;CAEAC,YAAY9B,SAAsB;EAChC,MAAM2B,SAAS3B,OAAO,CAAC;EACvB,KAAK+B,OAAO;EACZ,KAAK/B,UAAUA;CACjB;AACF"}
+{"version":3,"file":"types.js","names":["StatewireClient","StatewirePath","Statewire","Commands","Record","args","Command","TCommands","method","K","params","Parameters","CommandsProxy","Promise","Awaited","ReturnType","CommandUpdate","seq","status","result","failure","SendFailure","StateSource","snapshot","takeChanged","setOnChange","listener","Op","op","path","value","Changes","isChangedAt","getChangedKeys","state","TState","commands","emit","event","TEvent","connection","Connection","source","setContext","describe","fate","message","cause","StatewireSendError","Error","constructor","name"],"sources":["../src/types.ts"],"sourcesContent":["import 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      method: K;\n      params: Parameters<TCommands[K]>;\n      seq: number;\n      status: \"queued\" | \"posted\" | \"acked\" | \"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    | { op: \"event\"; value: object };\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  TEvent = any,\n> {\n  state: TState;\n  commands: Statewire.CommandsProxy<TCommands>;\n  emit?: (event: TEvent) => void;\n  connection?: StatewireClient.Connection;\n  source?: Statewire.StateSource;\n  /** Replace this client's ambient context on the server; absent on transports without a client context channel. */\n  setContext?: (value: Record<string, unknown>) => Promise<unknown>;\n}\n\nconst describe = (failure: StatewireClient.SendFailure): string => {\n  switch (failure.fate) {\n    case \"rejected\":\n      return `statewire: command rejected: ${failure.message}`;\n    case \"unknown-command\":\n      return \"statewire: unknown command\";\n    case \"invalid-params\":\n      return `statewire: invalid params: ${failure.message}`;\n    case \"aborted\":\n      return `statewire: command aborted (${failure.cause})`;\n    case \"lost\":\n      return `statewire: command lost (${failure.cause})`;\n    case \"crashed\":\n      return \"statewire: command crashed\";\n    case \"result-unavailable\":\n      return `statewire: command result unavailable (${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":";AA8DA,MAAM4C,YAAYxB,YAAiD;CACjE,QAAQA,QAAQyB,MAAhB;EACE,KAAK,YACH,OAAO,gCAAgCzB,QAAQ0B;EACjD,KAAK,mBACH,OAAO;EACT,KAAK,kBACH,OAAO,8BAA8B1B,QAAQ0B;EAC/C,KAAK,WACH,OAAO,+BAA+B1B,QAAQ2B,MAAK;EACrD,KAAK,QACH,OAAO,4BAA4B3B,QAAQ2B,MAAK;EAClD,KAAK,WACH,OAAO;EACT,KAAK,sBACH,OAAO,0CAA0C3B,QAAQ2B,MAAK;CAClE;AACF;AAEA,IAAaC,qBAAb,cAAwCC,MAAM;CAC5C;CAEAC,YAAY9B,SAAsC;EAChD,MAAMwB,SAASxB,OAAO,CAAC;EACvB,KAAK+B,OAAO;EACZ,KAAK/B,UAAUA;CACjB;AACF"}

package/dist/util/draftTraps.d.ts

@@ -0,0 +1,6 @@
+//#region src/util/draftTraps.d.ts
+type SharedTraps = Pick<ProxyHandler<object>, "defineProperty" | "setPrototypeOf" | "preventExtensions" | "ownKeys" | "getOwnPropertyDescriptor">;
+declare const sharedDraftTraps: (current: () => object, context: string) => SharedTraps;
+//#endregion
+export { sharedDraftTraps };
+//# sourceMappingURL=draftTraps.d.ts.map

package/dist/util/draftTraps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draftTraps.d.ts","names":[],"sources":["../../src/util/draftTraps.ts"],"mappings":";KAAK,cAAc,KACjB;cAQW,mBACX,uBACA,oBACC"}

package/dist/util/draftTraps.js

@@ -0,0 +1,25 @@
+//#region src/util/draftTraps.ts
+const sharedDraftTraps = (current, context) => {
+	const unsupported = (op) => {
+		throw new Error(`statewire: ${op} is not supported ${context}`);
+	};
+	return {
+		defineProperty: () => unsupported("defineProperty"),
+		setPrototypeOf: () => unsupported("setPrototypeOf"),
+		preventExtensions: () => unsupported("preventExtensions"),
+		ownKeys: () => Reflect.ownKeys(current()),
+		getOwnPropertyDescriptor: (_target, prop) => {
+			const node = current();
+			const desc = Reflect.getOwnPropertyDescriptor(node, prop);
+			if (!desc) return void 0;
+			return {
+				...desc,
+				configurable: !Array.isArray(node) || prop !== "length"
+			};
+		}
+	};
+};
+//#endregion
+export { sharedDraftTraps };
+
+//# sourceMappingURL=draftTraps.js.map

package/dist/util/draftTraps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"draftTraps.js","names":["SharedTraps","Pick","ProxyHandler","sharedDraftTraps","current","context","unsupported","op","Error","defineProperty","setPrototypeOf","preventExtensions","ownKeys","Reflect","getOwnPropertyDescriptor","_target","prop","node","desc","undefined","configurable","Array","isArray"],"sources":["../../src/util/draftTraps.ts"],"sourcesContent":["type SharedTraps = Pick<\n  ProxyHandler<object>,\n  | \"defineProperty\"\n  | \"setPrototypeOf\"\n  | \"preventExtensions\"\n  | \"ownKeys\"\n  | \"getOwnPropertyDescriptor\"\n>;\n\nexport const sharedDraftTraps = (\n  current: () => object,\n  context: string,\n): SharedTraps => {\n  const unsupported = (op: string): never => {\n    throw new Error(`statewire: ${op} is not supported ${context}`);\n  };\n  return {\n    defineProperty: () => unsupported(\"defineProperty\"),\n    setPrototypeOf: () => unsupported(\"setPrototypeOf\"),\n    preventExtensions: () => unsupported(\"preventExtensions\"),\n    ownKeys: () => Reflect.ownKeys(current()),\n    getOwnPropertyDescriptor: (_target, prop) => {\n      const node = current();\n      const desc = Reflect.getOwnPropertyDescriptor(node, prop);\n      if (!desc) return undefined;\n      return {\n        ...desc,\n        configurable: !Array.isArray(node) || prop !== \"length\",\n      };\n    },\n  };\n};\n"],"mappings":";AASA,MAAaG,oBACXC,SACAC,YACgB;CAChB,MAAMC,eAAeC,OAAsB;EACzC,MAAM,IAAIC,MAAM,cAAcD,GAAE,oBAAqBF,SAAS;CAChE;CACA,OAAO;EACLI,sBAAsBH,YAAY,gBAAgB;EAClDI,sBAAsBJ,YAAY,gBAAgB;EAClDK,yBAAyBL,YAAY,mBAAmB;EACxDM,eAAeC,QAAQD,QAAQR,QAAQ,CAAC;EACxCU,2BAA2BC,SAASC,SAAS;GAC3C,MAAMC,OAAOb,QAAQ;GACrB,MAAMc,OAAOL,QAAQC,yBAAyBG,MAAMD,IAAI;GACxD,IAAI,CAACE,MAAM,OAAOC,KAAAA;GAClB,OAAO;IACL,GAAGD;IACHE,cAAc,CAACC,MAAMC,QAAQL,IAAI,KAAKD,SAAS;GACjD;EACF;CACF;AACF"}

package/dist/util/macrotask.d.ts

@@ -0,0 +1,5 @@
+//#region src/util/macrotask.d.ts
+declare const createMacrotaskPoster: (callback: () => void) => (() => void);
+//#endregion
+export { createMacrotaskPoster };
+//# sourceMappingURL=macrotask.d.ts.map

package/dist/util/macrotask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"macrotask.d.ts","names":[],"sources":["../../src/util/macrotask.ts"],"mappings":";cAIa,wBAAyB"}

package/dist/util/macrotask.js

@@ -0,0 +1,25 @@
+//#region src/util/macrotask.ts
+const createMacrotaskPoster = (callback) => {
+	if (typeof MessageChannel !== "undefined") {
+		let port1 = null;
+		let port2;
+		return () => {
+			if (!port1) {
+				const channel = new MessageChannel();
+				channel.port1.onmessage = () => {
+					port1?.unref?.();
+					callback();
+				};
+				port1 = channel.port1;
+				port2 = channel.port2;
+			}
+			port1.ref?.();
+			port2.postMessage(null);
+		};
+	}
+	return () => setTimeout(callback, 0);
+};
+//#endregion
+export { createMacrotaskPoster };
+
+//# sourceMappingURL=macrotask.js.map

package/dist/util/macrotask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"macrotask.js","names":["createMacrotaskPoster","callback","MessageChannel","port1","MessagePort","ref","unref","port2","channel","onmessage","postMessage","setTimeout"],"sources":["../../src/util/macrotask.ts"],"sourcesContent":["// MessageChannel schedules the flush as a macrotask (tap's pattern): it runs\n// after the whole microtask drain, so every producer in the current turn\n// coalesces. The port is ref'd only while a flush is pending — an active\n// MessagePort holds the Node event loop open. ref/unref are Node-only.\nexport const createMacrotaskPoster = (callback: () => void): (() => void) => {\n  if (typeof MessageChannel !== \"undefined\") {\n    let port1: (MessagePort & { ref?: () => void; unref?: () => void }) | null =\n      null;\n    let port2: MessagePort;\n    return () => {\n      if (!port1) {\n        const channel = new MessageChannel();\n        channel.port1.onmessage = () => {\n          port1?.unref?.();\n          callback();\n        };\n        port1 = channel.port1;\n        port2 = channel.port2;\n      }\n      port1.ref?.();\n      port2!.postMessage(null);\n    };\n  }\n  return () => setTimeout(callback, 0);\n};\n"],"mappings":";AAIA,MAAaA,yBAAyBC,aAAuC;CAC3E,IAAI,OAAOC,mBAAmB,aAAa;EACzC,IAAIC,QACF;EACF,IAAII;EACJ,aAAa;GACX,IAAI,CAACJ,OAAO;IACV,MAAMK,UAAU,IAAIN,eAAe;IACnCM,QAAQL,MAAMM,kBAAkB;KAC9BN,OAAOG,QAAQ;KACfL,SAAS;IACX;IACAE,QAAQK,QAAQL;IAChBI,QAAQC,QAAQD;GAClB;GACAJ,MAAME,MAAM;GACZE,MAAOG,YAAY,IAAI;EACzB;CACF;CACA,aAAaC,WAAWV,UAAU,CAAC;AACrC"}

package/dist/util/methodProxy.d.ts

@@ -0,0 +1,5 @@
+//#region src/util/methodProxy.d.ts
+declare const createMethodProxy: <T extends object>(dispatch: (method: string, params: unknown[]) => Promise<unknown>) => T;
+//#endregion
+export { createMethodProxy };
+//# sourceMappingURL=methodProxy.d.ts.map

package/dist/util/methodProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methodProxy.d.ts","names":[],"sources":["../../src/util/methodProxy.ts"],"mappings":";cAAa,oBAAqB,kBAChC,WAAW,gBAAgB,sBAAsB,qBAChD"}

package/dist/util/methodProxy.js

@@ -0,0 +1,17 @@
+//#region src/util/methodProxy.ts
+const createMethodProxy = (dispatch) => {
+	const memo = /* @__PURE__ */ new Map();
+	return new Proxy({}, { get: (_target, method) => {
+		if (typeof method !== "string") return void 0;
+		let fn = memo.get(method);
+		if (fn === void 0) {
+			fn = (...params) => dispatch(method, params);
+			memo.set(method, fn);
+		}
+		return fn;
+	} });
+};
+//#endregion
+export { createMethodProxy };
+
+//# sourceMappingURL=methodProxy.js.map

package/dist/util/methodProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methodProxy.js","names":["createMethodProxy","dispatch","method","params","Promise","T","memo","Map","Proxy","get","_target","undefined","fn","set"],"sources":["../../src/util/methodProxy.ts"],"sourcesContent":["export const createMethodProxy = <T extends object>(\n  dispatch: (method: string, params: unknown[]) => Promise<unknown>,\n): T => {\n  const memo = new Map<string, (...params: unknown[]) => Promise<unknown>>();\n  return new Proxy({} as T, {\n    get: (_target, method) => {\n      if (typeof method !== \"string\") return undefined;\n      let fn = memo.get(method);\n      if (fn === undefined) {\n        fn = (...params: unknown[]) => dispatch(method, params);\n        memo.set(method, fn);\n      }\n      return fn;\n    },\n  });\n};\n"],"mappings":";AAAA,MAAaA,qBACXC,aACM;CACN,MAAMK,uBAAO,IAAIC,IAAwD;CACzE,OAAO,IAAIC,MAAM,CAAC,GAAQ,EACxBC,MAAMC,SAASR,WAAW;EACxB,IAAI,OAAOA,WAAW,UAAU,OAAOS,KAAAA;EACvC,IAAIC,KAAKN,KAAKG,IAAIP,MAAM;EACxB,IAAIU,OAAOD,KAAAA,GAAW;GACpBC,MAAM,GAAGT,WAAsBF,SAASC,QAAQC,MAAM;GACtDG,KAAKO,IAAIX,QAAQU,EAAE;EACrB;EACA,OAAOA;CACT,EACF,CAAC;AACH"}

package/dist/util/randomId.d.ts

@@ -0,0 +1,5 @@
+//#region src/util/randomId.d.ts
+declare const randomId: () => string;
+//#endregion
+export { randomId };
+//# sourceMappingURL=randomId.d.ts.map

package/dist/util/randomId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomId.d.ts","names":[],"sources":["../../src/util/randomId.ts"],"mappings":";cAAa"}