statewire 0.0.0-0 → 0.0.1

package/dist/transports/testing.js

@@ -0,0 +1,121 @@
+import { recordMutations } from "../client/optimistic.js";
+import { StatewireSSE } from "./sse.js";
+//#region src/transports/testing.ts
+/** Let queued microtasks and op batches drain through the statewire client. */
+const tick = () => new Promise((r) => setTimeout(r, 0));
+/** Run a mutator against a recording draft, as the client does for `optimistic`. */
+const applyOptimistic = (state, mutate) => recordMutations(state, mutate).state;
+/**
+* A mock statewire backend: serves `initialState` as the attach snapshot,
+* records command POSTs (receipt only — acks and results are delivered from
+* test code), and exposes the wire as a transport ResourceElement.
+*/
+let mockCount = 0;
+const createMockTransport = (initialState) => {
+	let state = initialState;
+	let clientId = "";
+	let finished = false;
+	const clients = /* @__PURE__ */ new Map();
+	const streams = /* @__PURE__ */ new Set();
+	const commands = [];
+	const sendEnvelope = (envelope) => {
+		for (const stream of streams) stream.send(`data: ${JSON.stringify(envelope)}\n\n`);
+		return tick();
+	};
+	const handleStream = (id, signal) => {
+		clientId = id;
+		const lastSeq = clients.get(id) ?? 0;
+		clients.set(id, lastSeq);
+		const encoder = new TextEncoder();
+		let handle;
+		const body = new ReadableStream({
+			start: (controller) => {
+				let open = true;
+				handle = {
+					clientId: id,
+					send: (text) => {
+						if (open) controller.enqueue(encoder.encode(text));
+					},
+					close: () => {
+						if (!open) return;
+						open = false;
+						streams.delete(handle);
+						controller.close();
+					}
+				};
+				streams.add(handle);
+				handle.send(`data: ${JSON.stringify({
+					ops: [{
+						op: "replace",
+						path: [],
+						value: state
+					}],
+					syn: {
+						lastSeq,
+						lease: "mock-lease"
+					}
+				})}\n\n`);
+			},
+			cancel: () => {
+				streams.delete(handle);
+			}
+		});
+		signal?.addEventListener("abort", () => {
+			for (const stream of [...streams]) if (stream.clientId === id) stream.close();
+		});
+		return new Response(body, {
+			status: 200,
+			headers: { "content-type": "text/event-stream" }
+		});
+	};
+	const fakeFetch = (async (input, init) => {
+		if (finished) throw new TypeError("fetch failed (finished)");
+		const url = String(input);
+		const headers = new Headers(init?.headers);
+		const id = headers.get("Statewire-Client-Id") ?? "";
+		if (url.endsWith("/stream")) return handleStream(id, init?.signal ?? void 0);
+		if (url.endsWith("/commands")) {
+			const seq = Number(headers.get("Statewire-Command-Seq"));
+			clients.set(id, Math.max(clients.get(id) ?? 0, seq));
+			commands.push(JSON.parse(String(init?.body)));
+			return Response.json({});
+		}
+		return new Response(null, { status: 404 });
+	});
+	return {
+		transport: StatewireSSE({
+			url: `http://mock-${++mockCount}/api`,
+			fetch: fakeFetch
+		}),
+		commands,
+		setState: (next) => {
+			state = next;
+			return sendEnvelope({ ops: [{
+				op: "replace",
+				path: [],
+				value: next
+			}] });
+		},
+		ack: (seq) => sendEnvelope({ ack: seq }),
+		sendEnvelope,
+		finish: async (reason, message) => {
+			await sendEnvelope({ fin: {
+				reason,
+				...message !== void 0 && { message }
+			} });
+			finished = true;
+			for (const stream of [...streams]) stream.close();
+			await tick();
+		},
+		get clientId() {
+			return clientId;
+		},
+		get attached() {
+			return streams.size > 0;
+		}
+	};
+};
+//#endregion
+export { applyOptimistic, createMockTransport, tick };
+
+//# sourceMappingURL=testing.js.map

package/dist/transports/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","names":["ResourceElement","StatewireEnvelope","recordMutations","StatewireSSE","StatewireTransport","tick","Promise","r","setTimeout","applyOptimistic","state","TState","mutate","draft","StreamHandle","clientId","send","text","close","MockTransport","transport","commands","method","params","setState","ack","seq","sendEnvelope","envelope","finish","reason","message","attached","mockCount","createMockTransport","initialState","finished","clients","Map","streams","Set","stream","JSON","stringify","handleStream","id","signal","AbortSignal","lastSeq","get","set","encoder","TextEncoder","handle","body","ReadableStream","Uint8Array","start","controller","open","enqueue","encode","delete","add","ops","op","path","value","syn","lease","cancel","addEventListener","Response","status","headers","fakeFetch","input","RequestInfo","URL","init","RequestInit","TypeError","url","String","Headers","endsWith","undefined","Number","Math","max","push","parse","json","fetch","next","fin","size"],"sources":["../../src/transports/testing.ts"],"sourcesContent":["import type { ResourceElement } from \"@assistant-ui/tap\";\nimport type { StatewireEnvelope } from \"../client/connection\";\nimport { recordMutations } from \"../client/optimistic\";\nimport { StatewireSSE } from \"./sse\";\nimport type { StatewireTransport } from \"../types\";\n\n/** Let queued microtasks and op batches drain through the statewire client. */\nexport const tick = () => new Promise<void>((r) => setTimeout(r, 0));\n\n/** Run a mutator against a recording draft, as the client does for `optimistic`. */\nexport const applyOptimistic = <TState>(\n  state: TState,\n  mutate: (draft: TState) => void,\n): TState => recordMutations(state, mutate).state;\n\ntype StreamHandle = {\n  clientId: string;\n  send: (text: string) => void;\n  close: () => void;\n};\n\nexport type MockTransport<TState> = {\n  /** Pass as the `transport:` option of useStatewire / Harness. */\n  transport: ResourceElement<StatewireTransport<TState | undefined, any, any>>;\n  /** Captured `{ method, params }` command bodies, in POST order. */\n  commands: { method: string; params: unknown[] }[];\n  /** Replace the replicated state and broadcast it as a root snapshot op. */\n  setState: (state: TState) => Promise<void>;\n  /** Deliver an ack watermark on the stream. */\n  ack: (seq: number) => Promise<void>;\n  /** Deliver an arbitrary envelope on the stream. */\n  sendEnvelope: (envelope: StatewireEnvelope) => Promise<void>;\n  /** End the stream with a fin; further attaches fail like a dead server. */\n  finish: (reason: string, message?: string) => Promise<void>;\n  readonly clientId: string;\n  readonly attached: boolean;\n};\n\n/**\n * A mock statewire backend: serves `initialState` as the attach snapshot,\n * records command POSTs (receipt only — acks and results are delivered from\n * test code), and exposes the wire as a transport ResourceElement.\n */\nlet mockCount = 0;\n\nexport const createMockTransport = <TState>(\n  initialState: TState,\n): MockTransport<TState> => {\n  let state: unknown = initialState;\n  let clientId = \"\";\n  let finished = false;\n  const clients = new Map<string, number>();\n  const streams = new Set<StreamHandle>();\n  const commands: { method: string; params: unknown[] }[] = [];\n\n  const sendEnvelope = (envelope: StatewireEnvelope) => {\n    for (const stream of streams) {\n      stream.send(`data: ${JSON.stringify(envelope)}\\n\\n`);\n    }\n    return tick();\n  };\n\n  const handleStream = (id: string, signal: AbortSignal | undefined) => {\n    clientId = id;\n    const lastSeq = clients.get(id) ?? 0;\n    clients.set(id, lastSeq);\n    const encoder = new TextEncoder();\n    let handle: StreamHandle;\n    const body = new ReadableStream<Uint8Array>({\n      start: (controller) => {\n        let open = true;\n        handle = {\n          clientId: id,\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        handle.send(\n          `data: ${JSON.stringify({\n            ops: [{ op: \"replace\", path: [], value: state }],\n            syn: { lastSeq, lease: \"mock-lease\" },\n          })}\\n\\n`,\n        );\n      },\n      cancel: () => {\n        streams.delete(handle);\n      },\n    });\n    signal?.addEventListener(\"abort\", () => {\n      for (const stream of [...streams]) {\n        if (stream.clientId === id) stream.close();\n      }\n    });\n    return new Response(body, {\n      status: 200,\n      headers: { \"content-type\": \"text/event-stream\" },\n    });\n  };\n\n  const fakeFetch = (async (\n    input: RequestInfo | URL,\n    init?: RequestInit,\n  ): Promise<Response> => {\n    if (finished) throw new TypeError(\"fetch failed (finished)\");\n    const url = String(input);\n    const headers = new Headers(init?.headers);\n    const id = headers.get(\"Statewire-Client-Id\") ?? \"\";\n    if (url.endsWith(\"/stream\"))\n      return handleStream(id, init?.signal ?? undefined);\n    if (url.endsWith(\"/commands\")) {\n      const seq = Number(headers.get(\"Statewire-Command-Seq\"));\n      clients.set(id, Math.max(clients.get(id) ?? 0, seq));\n      commands.push(\n        JSON.parse(String(init?.body)) as { method: string; params: unknown[] },\n      );\n      return Response.json({});\n    }\n    return new Response(null, { status: 404 });\n  }) as typeof fetch;\n\n  return {\n    transport: StatewireSSE({\n      url: `http://mock-${++mockCount}/api`,\n      fetch: fakeFetch,\n    }),\n    commands,\n    setState: (next) => {\n      state = next;\n      return sendEnvelope({ ops: [{ op: \"replace\", path: [], value: next }] });\n    },\n    ack: (seq) => sendEnvelope({ ack: seq }),\n    sendEnvelope,\n    finish: async (reason, message) => {\n      await sendEnvelope({\n        fin: { reason, ...(message !== undefined && { message }) },\n      });\n      finished = true;\n      for (const stream of [...streams]) stream.close();\n      await tick();\n    },\n    get clientId() {\n      return clientId;\n    },\n    get attached() {\n      return streams.size > 0;\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/transports/ws.d.ts

@@ -0,0 +1,18 @@
+import { StatewireSessionStore } from "../client/sessionStore.js";
+import { StatewireConnection } from "./sse.js";
+import { StatewireCommands, StatewireTransport } from "../types.js";
+import { ResourceElement } from "@assistant-ui/tap";
+//#region src/transports/ws.d.ts
+type StatewireWSOptions = {
+  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: StatewireConnection) => void;
+  sessionStore?: StatewireSessionStore;
+};
+declare const WS_SUBPROTOCOL = "statewire.v1";
+declare const StatewireWS: <TState = any, TCommands extends StatewireCommands = StatewireCommands, TEvent = any>(options: StatewireWSOptions) => ResourceElement<StatewireTransport<TState | undefined, TCommands, TEvent>>;
+//#endregion
+export { StatewireWS, StatewireWSOptions, WS_SUBPROTOCOL };
+//# sourceMappingURL=ws.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ws.d.ts","names":[],"sources":["../../src/transports/ws.ts"],"mappings":";;;;;KAuBY;EACV;EACA;EACA,QACI,gCACO,yBAAyB,QAAQ;EAC5C,iBAAiB,aAAa,kCAAkC;EAChE,YAAY,YAAY;EACxB,eAAe;;cAuBJ;cAmNA,cACX,cACA,kBAAkB,oBAAoB,mBACtC,cAEA,SAAS,uBACN,gBAAgB,mBAAmB,oBAAoB,WAAW"}

package/dist/transports/ws.js

@@ -0,0 +1,172 @@
+import { encodeParams } from "../wire/meta.js";
+import { timing } from "../client/timing.js";
+import { createGate, handleEnvelope, overloadedError, reconnectConn } from "../client/connection.js";
+import { useStatewireRemote } from "./remote.js";
+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 params = new URLSearchParams(typeof query === "function" ? await query() : query);
+	params.set("client", c.latest.current.ctx.clientId);
+	return `${url.replace(/\/$/, "").replace(/^http/, "ws")}/ws?${params.toString()}`;
+};
+const settleOverloaded = (c, { seq, retryAfterMs }) => {
+	if (seq === void 0) throw overloadedError(retryAfterMs);
+	const entry = c.pending.find((p) => p.seq === seq);
+	if (!entry) return;
+	c.pending = c.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 remaining = [];
+	for (const entry of c.pending) if (seqs.has(entry.seq)) entry.resolve({ type: "receipt" });
+	else remaining.push(entry);
+	c.pending = remaining;
+};
+const failPending = (c, error) => {
+	const pending = c.pending;
+	c.pending = [];
+	for (const entry of pending) entry.reject(error);
+};
+const runSocket = (c, 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(() => {
+			timedOut = true;
+			ws.close();
+		}, timing.heartbeatTimeoutMs);
+	};
+	arm();
+	abort.signal.addEventListener("abort", () => ws.close());
+	ws.onerror = () => {};
+	const stale = () => Boolean(outcome) || closed || abort.signal.aborted;
+	const fail = (error) => {
+		clearTimeout(timer);
+		reject(error instanceof Error ? error : /* @__PURE__ */ new Error("protocol"));
+		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)));
+		if (done) {
+			outcome = done;
+			ws.close();
+		}
+	};
+	ws.onmessage = (event) => {
+		if (stale()) return;
+		arm();
+		let frame;
+		try {
+			frame = JSON.parse(String(event.data));
+		} catch {
+			fail(/* @__PURE__ */ new Error("protocol"));
+			return;
+		}
+		try {
+			if (frame.overloaded !== void 0) settleOverloaded(c, frame.overloaded);
+			else processEnv(frame);
+		} catch (error) {
+			fail(error);
+		}
+	};
+	ws.onclose = () => {
+		closed = true;
+		clearTimeout(timer);
+		if (c.socket === ws) failPending(c, /* @__PURE__ */ new Error("network"));
+		if (outcome) resolve(outcome);
+		else reject(/* @__PURE__ */ new Error(timedOut ? "timeout" : "network"));
+	};
+});
+const attemptSocket = async (c, abort) => {
+	let ws = null;
+	try {
+		const url = await socketUrl(c);
+		abort.signal.throwIfAborted();
+		const { protocols, webSocket } = c.latest.current.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);
+	} finally {
+		if (c.socket === ws) c.socket = null;
+	}
+};
+const sendCommand = (c, { seq, command }) => {
+	const ws = c.socket;
+	if (!ws || ws.readyState !== OPEN) return Promise.reject(/* @__PURE__ */ new Error("network"));
+	return new Promise((resolve, reject) => {
+		const entry = {
+			seq,
+			resolve: (result) => {
+				clearTimeout(timer);
+				resolve(result);
+			},
+			reject: (error) => {
+				clearTimeout(timer);
+				reject(error);
+			}
+		};
+		const timer = setTimeout(() => {
+			c.pending = c.pending.filter((p) => p !== entry);
+			reject(/* @__PURE__ */ new Error("timeout"));
+			ws.close();
+		}, timing.heartbeatTimeoutMs);
+		c.pending.push(entry);
+		try {
+			ws.send(JSON.stringify({
+				method: command.method,
+				...encodeParams(command.params),
+				seq
+			}));
+		} catch {
+			clearTimeout(timer);
+			c.pending = c.pending.filter((p) => p !== entry);
+			reject(/* @__PURE__ */ new Error("network"));
+		}
+	});
+};
+const useStatewireWS = (options) => {
+	return useStatewireRemote(options, createConn);
+};
+const StatewireWS = resource(useStatewireWS);
+//#endregion
+export { StatewireWS, WS_SUBPROTOCOL };
+
+//# sourceMappingURL=ws.js.map

package/dist/transports/ws.js.map

@@ -0,0 +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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"}

package/dist/types.d.ts

@@ -0,0 +1,107 @@
+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. */
+  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";
+};
+declare class StatewireSendError extends Error {
+  readonly failure: SendFailure;
+  constructor(failure: SendFailure);
+}
+//#endregion
+export { SendFailure, StatewireChanges, StatewireCommand, StatewireCommandUpdate, StatewireCommands, StatewireCommandsProxy, StatewireHelpers, StatewireOptimistic, StatewireOptimisticContext, StatewireOptions, StatewireSendError, StatewireStateSource, StatewireTransport };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +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"}

package/dist/types.js

@@ -0,0 +1,24 @@
+//#region src/types.ts
+const describe = (failure) => {
+	switch (failure.fate) {
+		case "rejected": return `statewire: command rejected: ${failure.message}`;
+		case "unknown-command": return "statewire: unknown command";
+		case "invalid-params": return `statewire: invalid params: ${failure.message}`;
+		case "aborted": return `statewire: command aborted (${failure.cause})`;
+		case "lost": return `statewire: command lost (${failure.cause})`;
+		case "crashed": return "statewire: command crashed";
+		case "result-unavailable": return `statewire: command result unavailable (${failure.cause})`;
+	}
+};
+var StatewireSendError = class extends Error {
+	failure;
+	constructor(failure) {
+		super(describe(failure));
+		this.name = "StatewireSendError";
+		this.failure = failure;
+	}
+};
+//#endregion
+export { StatewireSendError };
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +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"}

package/dist/wire/meta.d.ts

@@ -0,0 +1,22 @@
+//#region src/wire/meta.d.ts
+type StatewireMetaEntry = {
+  path: (string | number)[];
+  type: string;
+};
+/** Revive meta-typed locations inside a wire value (in place). Unknown types
+ * are skipped; a path that does not resolve to a valid target faults. */
+declare const reviveValue: (value: unknown, meta: unknown) => unknown;
+declare const reviveOps: (ops: unknown[]) => unknown[];
+declare const reviveResponse: <T extends {
+  payload?: unknown;
+  meta?: unknown;
+}>(response: T) => T;
+/** Encode Date instances inside command params as canonical ISO strings,
+ * recording their paths (starting at the param index) in meta. */
+declare const encodeParams: (params: readonly unknown[]) => {
+  params: unknown[];
+  meta?: StatewireMetaEntry[];
+};
+//#endregion
+export { StatewireMetaEntry, encodeParams, reviveOps, reviveResponse, reviveValue };
+//# sourceMappingURL=meta.d.ts.map

package/dist/wire/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","names":[],"sources":["../../src/wire/meta.ts"],"mappings":";KAAY;EACV;EACA;;;;cAiBW,cAAe,gBAAgB;cA6C/B,YAAa;cAOb,iBAAkB;EAAY;EAAmB;GAC5D,UAAU,MACT;;;cAQU,eACX;EACG;EAAmB,OAAO"}

package/dist/wire/meta.js

@@ -0,0 +1,73 @@
+//#region src/wire/meta.ts
+const fault = (message) => {
+	throw new Error(`statewire: protocol error: ${message}`);
+};
+const isPath = (path) => Array.isArray(path) && path.every((seg) => typeof seg === "string" || typeof seg === "number" && Number.isInteger(seg));
+/** Revive meta-typed locations inside a wire value (in place). Unknown types
+* are skipped; a path that does not resolve to a valid target faults. */
+const reviveValue = (value, meta) => {
+	if (!Array.isArray(meta)) return fault("meta must be an array");
+	for (const entry of meta) {
+		const path = typeof entry === "object" && entry !== null ? entry.path : null;
+		if (!isPath(path)) return fault("meta entry must carry a path array");
+		if (entry.type !== "date") continue;
+		let parent = null;
+		let key = "";
+		let node = value;
+		for (const seg of path) {
+			parent = node;
+			key = seg;
+			if (typeof seg === "string" && typeof node === "object" && node !== null && !Array.isArray(node) && Object.hasOwn(node, seg)) node = node[seg];
+			else if (typeof seg === "number" && Array.isArray(node) && seg >= 0 && seg < node.length) node = node[seg];
+			else return fault(`meta path ${path.join(".")} does not resolve`);
+		}
+		if (typeof node !== "string") return fault(`meta path ${path.join(".")} must name a string`);
+		const date = new Date(node);
+		if (Number.isNaN(date.getTime())) return fault(`invalid date at meta path ${path.join(".")}`);
+		if (parent === null) return date;
+		parent[key] = date;
+	}
+	return value;
+};
+const reviveOps = (ops) => ops.map((op) => {
+	if (typeof op !== "object" || op === null || !("meta" in op)) return op;
+	const { meta, ...rest } = op;
+	return {
+		...rest,
+		value: reviveValue(rest.value, meta)
+	};
+});
+const reviveResponse = (response) => {
+	if (response.meta === void 0) return response;
+	const { meta, ...rest } = response;
+	return {
+		...rest,
+		payload: reviveValue(rest.payload, meta)
+	};
+};
+/** Encode Date instances inside command params as canonical ISO strings,
+* recording their paths (starting at the param index) in meta. */
+const encodeParams = (params) => {
+	const meta = [];
+	const walk = (node, path) => {
+		if (node instanceof Date) {
+			meta.push({
+				path,
+				type: "date"
+			});
+			return node.toISOString();
+		}
+		if (Array.isArray(node)) return node.map((item, i) => walk(item, [...path, i]));
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.keys(node).map((key) => [key, walk(node[key], [...path, key])]));
+		return node;
+	};
+	const encoded = params.map((param, i) => walk(param, [i]));
+	return meta.length > 0 ? {
+		params: encoded,
+		meta
+	} : { params: encoded };
+};
+//#endregion
+export { encodeParams, reviveOps, reviveResponse, reviveValue };
+
+//# sourceMappingURL=meta.js.map

package/dist/wire/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.js","names":["StatewireMetaEntry","path","type","fault","message","Error","isPath","Array","isArray","every","seg","Number","isInteger","reviveValue","value","meta","entry","parent","key","node","Object","hasOwn","Record","length","join","date","Date","isNaN","getTime","reviveOps","ops","map","op","rest","reviveResponse","payload","response","T","undefined","encodeParams","params","walk","push","toISOString","item","i","fromEntries","keys","encoded","param"],"sources":["../../src/wire/meta.ts"],"sourcesContent":["export type StatewireMetaEntry = {\n  path: (string | number)[];\n  type: string;\n};\n\nconst fault = (message: string): never => {\n  throw new Error(`statewire: protocol error: ${message}`);\n};\n\nconst isPath = (path: unknown): path is (string | number)[] =>\n  Array.isArray(path) &&\n  path.every(\n    (seg) =>\n      typeof seg === \"string\" ||\n      (typeof seg === \"number\" && Number.isInteger(seg)),\n  );\n\n/** Revive meta-typed locations inside a wire value (in place). Unknown types\n * are skipped; a path that does not resolve to a valid target faults. */\nexport const reviveValue = (value: unknown, meta: unknown): unknown => {\n  if (!Array.isArray(meta)) return fault(\"meta must be an array\");\n  for (const entry of meta as { path?: unknown; type?: unknown }[]) {\n    const path =\n      typeof entry === \"object\" && entry !== null ? entry.path : null;\n    if (!isPath(path)) return fault(\"meta entry must carry a path array\");\n    if (entry.type !== \"date\") continue;\n    let parent: unknown = null;\n    let key: string | number = \"\";\n    let node = value;\n    for (const seg of path) {\n      parent = node;\n      key = seg;\n      if (\n        typeof seg === \"string\" &&\n        typeof node === \"object\" &&\n        node !== null &&\n        !Array.isArray(node) &&\n        Object.hasOwn(node, seg)\n      ) {\n        node = (node as Record<string, unknown>)[seg];\n      } else if (\n        typeof seg === \"number\" &&\n        Array.isArray(node) &&\n        seg >= 0 &&\n        seg < node.length\n      ) {\n        node = node[seg];\n      } else {\n        return fault(`meta path ${path.join(\".\")} does not resolve`);\n      }\n    }\n    if (typeof node !== \"string\") {\n      return fault(`meta path ${path.join(\".\")} must name a string`);\n    }\n    const date = new Date(node);\n    if (Number.isNaN(date.getTime())) {\n      return fault(`invalid date at meta path ${path.join(\".\")}`);\n    }\n    if (parent === null) return date;\n    (parent as Record<string | number, unknown>)[key] = date;\n  }\n  return value;\n};\n\nexport const reviveOps = (ops: unknown[]): unknown[] =>\n  ops.map((op) => {\n    if (typeof op !== \"object\" || op === null || !(\"meta\" in op)) return op;\n    const { meta, ...rest } = op as { meta: unknown; value?: unknown };\n    return { ...rest, value: reviveValue(rest.value, meta) };\n  });\n\nexport const reviveResponse = <T extends { payload?: unknown; meta?: unknown }>(\n  response: T,\n): T => {\n  if (response.meta === undefined) return response;\n  const { meta, ...rest } = response;\n  return { ...rest, payload: reviveValue(rest.payload, meta) } as T;\n};\n\n/** Encode Date instances inside command params as canonical ISO strings,\n * recording their paths (starting at the param index) in meta. */\nexport const encodeParams = (\n  params: readonly unknown[],\n): { params: unknown[]; meta?: StatewireMetaEntry[] } => {\n  const meta: StatewireMetaEntry[] = [];\n  const walk = (node: unknown, path: (string | number)[]): unknown => {\n    if (node instanceof Date) {\n      meta.push({ path, type: \"date\" });\n      return node.toISOString();\n    }\n    if (Array.isArray(node)) {\n      return node.map((item, i) => walk(item, [...path, i]));\n    }\n    if (typeof node === \"object\" && node !== null) {\n      return Object.fromEntries(\n        Object.keys(node).map((key) => [\n          key,\n          walk((node as Record<string, unknown>)[key], [...path, key]),\n        ]),\n      );\n    }\n    return node;\n  };\n  const encoded = params.map((param, i) => walk(param, [i]));\n  return meta.length > 0 ? { params: encoded, meta } : { params: encoded };\n};\n"],"mappings":"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"}