statewire 0.0.0-0 → 0.0.1

package/dist/host/draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft.d.ts","names":[],"sources":["../../src/host/draft.ts"],"mappings":";;KAEY,WAAW,QAAQ;EAAe;;KAElC;EACV;EACA,SAAS,IAAI;;cAGF,SAAU;cA6BV,mBAAoB,GAC/B,MAAM,WACN,OAAM,kBACL"}

package/dist/host/draft.js

@@ -0,0 +1,124 @@
+//#region src/host/draft.ts
+const frozen = (value) => {
+	if (value instanceof Date) return new Date(value.getTime());
+	if (Array.isArray(value)) return value.map((item) => frozen(item) ?? null);
+	if (typeof value === "object" && value !== null) {
+		const out = {};
+		for (const key of Object.keys(value)) {
+			const item = frozen(value[key]);
+			if (item !== void 0) out[key] = item;
+		}
+		return out;
+	}
+	return typeof value === "function" ? void 0 : value;
+};
+const lookup = (root, path) => {
+	let node = root;
+	for (const key of path) node = node[key];
+	return node;
+};
+const isIndex = (key) => /^(0|[1-9]\d*)$/.test(key);
+const invalid = (path, message) => /* @__PURE__ */ new Error(`statewire: ${message} at path: ${path.join(".")}`);
+const createStateDraft = (host, path = []) => {
+	const node = () => lookup(host.root(), path);
+	const assign = (container, key, value) => {
+		const old = Object.hasOwn(container, key) ? container[key] : void 0;
+		if (old === value) return;
+		if (typeof old === "string" && typeof value === "string" && value.startsWith(old)) {
+			host.record({
+				op: "append",
+				path: [...path, key],
+				value: value.slice(old.length)
+			});
+			return;
+		}
+		host.record({
+			op: "replace",
+			path: [...path, key],
+			value
+		});
+	};
+	return new Proxy(node(), {
+		get: (_target, prop) => {
+			const current = node();
+			if (typeof prop === "symbol") return current[prop];
+			const key = Array.isArray(current) && isIndex(prop) ? Number(prop) : prop;
+			const value = current[key];
+			if (typeof value === "object" && value !== null) return createStateDraft(host, [...path, key]);
+			return value;
+		},
+		set: (_target, prop, rawValue) => {
+			if (typeof prop === "symbol") return false;
+			const current = node();
+			const value = frozen(rawValue);
+			if (Array.isArray(current)) {
+				if (prop === "length") {
+					const next = Number(value);
+					if (!Number.isInteger(next) || next < 0 || next > current.length) throw invalid(path, `cannot set list length to ${String(value)}`);
+					for (let i = current.length - 1; i >= next; i--) host.record({
+						op: "remove",
+						path: [...path, i]
+					});
+					return true;
+				}
+				if (!isIndex(prop)) throw invalid(path, `cannot set key "${prop}" on a list`);
+				const index = Number(prop);
+				if (index > current.length) throw invalid(path, `list index ${index} out of range`);
+				if (index === current.length) {
+					host.record({
+						op: "add",
+						path: [...path, index],
+						value
+					});
+					return true;
+				}
+				assign(current, index, value);
+				return true;
+			}
+			assign(current, prop, value);
+			return true;
+		},
+		deleteProperty: (_target, prop) => {
+			if (typeof prop === "symbol") return false;
+			const current = node();
+			if (Array.isArray(current)) {
+				if (!isIndex(prop) || Number(prop) >= current.length) return true;
+				host.record({
+					op: "remove",
+					path: [...path, Number(prop)]
+				});
+				return true;
+			}
+			if (!Object.hasOwn(current, prop)) return true;
+			host.record({
+				op: "remove",
+				path: [...path, prop]
+			});
+			return true;
+		},
+		defineProperty: () => {
+			throw new Error("statewire: defineProperty is not supported on a state draft");
+		},
+		setPrototypeOf: () => {
+			throw new Error("statewire: setPrototypeOf is not supported on a state draft");
+		},
+		preventExtensions: () => {
+			throw new Error("statewire: preventExtensions is not supported on a state draft");
+		},
+		has: (_target, prop) => Reflect.has(node(), prop),
+		ownKeys: () => Reflect.ownKeys(node()),
+		getOwnPropertyDescriptor: (_target, prop) => {
+			const current = node();
+			const desc = Reflect.getOwnPropertyDescriptor(current, prop);
+			if (!desc) return void 0;
+			return {
+				...desc,
+				configurable: !Array.isArray(current) || prop !== "length"
+			};
+		}
+	});
+};
+//#endregion
+export { createStateDraft, frozen };
+
+//# sourceMappingURL=draft.js.map

package/dist/host/draft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft.js","names":["StatewireOp","StatewirePath","ServerOp","Exclude","op","DraftHost","root","record","frozen","value","Date","getTime","Array","isArray","map","item","out","Record","key","Object","keys","undefined","lookup","path","node","isIndex","test","invalid","message","Error","join","createStateDraft","host","T","assign","container","old","hasOwn","startsWith","slice","length","Proxy","get","_target","prop","current","Number","set","rawValue","next","isInteger","String","i","index","deleteProperty","defineProperty","setPrototypeOf","preventExtensions","has","Reflect","ownKeys","getOwnPropertyDescriptor","desc","configurable"],"sources":["../../src/host/draft.ts"],"sourcesContent":["import type { StatewireOp, StatewirePath } from \"../wire/ops\";\n\nexport type ServerOp = Exclude<StatewireOp, { op: \"event\" }>;\n\nexport type DraftHost = {\n  root: () => unknown;\n  record: (op: ServerOp) => void;\n};\n\nexport const frozen = (value: unknown): unknown => {\n  if (value instanceof Date) return new Date(value.getTime());\n  if (Array.isArray(value)) {\n    return value.map((item) => frozen(item) ?? null);\n  }\n  if (typeof value === \"object\" && value !== null) {\n    const out: Record<string, unknown> = {};\n    for (const key of Object.keys(value)) {\n      const item = frozen((value as Record<string, unknown>)[key]);\n      if (item !== undefined) out[key] = item;\n    }\n    return out;\n  }\n  return typeof value === \"function\" ? undefined : value;\n};\n\nconst lookup = (root: unknown, path: StatewirePath): unknown => {\n  let node = root;\n  for (const key of path) {\n    node = (node as Record<string | number, unknown>)[key];\n  }\n  return node;\n};\n\nconst isIndex = (key: string) => /^(0|[1-9]\\d*)$/.test(key);\n\nconst invalid = (path: StatewirePath, message: string) =>\n  new Error(`statewire: ${message} at path: ${path.join(\".\")}`);\n\nexport const createStateDraft = <T>(\n  host: DraftHost,\n  path: StatewirePath = [],\n): T => {\n  const node = () => lookup(host.root(), path);\n\n  const assign = (\n    container: Record<string | number, unknown>,\n    key: string | number,\n    value: unknown,\n  ) => {\n    const old = Object.hasOwn(container, key) ? container[key] : undefined;\n    if (old === value) return;\n    if (\n      typeof old === \"string\" &&\n      typeof value === \"string\" &&\n      value.startsWith(old)\n    ) {\n      host.record({\n        op: \"append\",\n        path: [...path, key],\n        value: value.slice(old.length),\n      });\n      return;\n    }\n    host.record({ op: \"replace\", path: [...path, key], value });\n  };\n\n  return new Proxy(node() as object, {\n    get: (_target, prop) => {\n      const current = node() as Record<string | number, unknown>;\n      if (typeof prop === \"symbol\") {\n        return (current as unknown as Record<symbol, unknown>)[prop];\n      }\n      const key = Array.isArray(current) && isIndex(prop) ? Number(prop) : prop;\n      const value = current[key];\n      if (typeof value === \"object\" && value !== null) {\n        return createStateDraft(host, [...path, key]);\n      }\n      return value;\n    },\n    set: (_target, prop, rawValue) => {\n      if (typeof prop === \"symbol\") return false;\n      const current = node();\n      const value = frozen(rawValue);\n      if (Array.isArray(current)) {\n        if (prop === \"length\") {\n          const next = Number(value);\n          if (!Number.isInteger(next) || next < 0 || next > current.length) {\n            throw invalid(path, `cannot set list length to ${String(value)}`);\n          }\n          for (let i = current.length - 1; i >= next; i--) {\n            host.record({ op: \"remove\", path: [...path, i] });\n          }\n          return true;\n        }\n        if (!isIndex(prop)) {\n          throw invalid(path, `cannot set key \"${prop}\" on a list`);\n        }\n        const index = Number(prop);\n        if (index > current.length) {\n          throw invalid(path, `list index ${index} out of range`);\n        }\n        if (index === current.length) {\n          host.record({ op: \"add\", path: [...path, index], value });\n          return true;\n        }\n        assign(\n          current as unknown as Record<string | number, unknown>,\n          index,\n          value,\n        );\n        return true;\n      }\n      assign(current as Record<string, unknown>, prop, value);\n      return true;\n    },\n    deleteProperty: (_target, prop) => {\n      if (typeof prop === \"symbol\") return false;\n      const current = node();\n      if (Array.isArray(current)) {\n        if (!isIndex(prop) || Number(prop) >= current.length) return true;\n        host.record({ op: \"remove\", path: [...path, Number(prop)] });\n        return true;\n      }\n      if (!Object.hasOwn(current as object, prop)) return true;\n      host.record({ op: \"remove\", path: [...path, prop] });\n      return true;\n    },\n    defineProperty: () => {\n      throw new Error(\n        \"statewire: defineProperty is not supported on a state draft\",\n      );\n    },\n    setPrototypeOf: () => {\n      throw new Error(\n        \"statewire: setPrototypeOf is not supported on a state draft\",\n      );\n    },\n    preventExtensions: () => {\n      throw new Error(\n        \"statewire: preventExtensions is not supported on a state draft\",\n      );\n    },\n    has: (_target, prop) => Reflect.has(node() as object, prop),\n    ownKeys: () => Reflect.ownKeys(node() as object),\n    getOwnPropertyDescriptor: (_target, prop) => {\n      const current = node() as object;\n      const desc = Reflect.getOwnPropertyDescriptor(current, prop);\n      if (!desc) return undefined;\n      return {\n        ...desc,\n        configurable: !Array.isArray(current) || prop !== \"length\",\n      };\n    },\n  }) as T;\n};\n"],"mappings":"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"}

package/dist/host/engine.d.ts

@@ -0,0 +1,14 @@
+//#region src/host/engine.d.ts
+/**
+ * Definitive handler rejection: the command settles rejected and
+ * message/payload travel to the client's rejected promise.
+ */
+declare class StatewireReject extends Error {
+  readonly payload?: unknown;
+  constructor(message: string, options?: {
+    payload?: unknown;
+  });
+}
+//#endregion
+export { StatewireReject };
+//# sourceMappingURL=engine.d.ts.map

package/dist/host/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","names":[],"sources":["../../src/host/engine.ts"],"mappings":";;;;;cAIa,wBAAwB;WAC1B;EAEG,YAAA,iBAAiB;IAAY"}

package/dist/host/engine.js

@@ -0,0 +1,17 @@
+//#region src/host/engine.ts
+/**
+* Definitive handler rejection: the command settles rejected and
+* message/payload travel to the client's rejected promise.
+*/
+var StatewireReject = class extends Error {
+	payload;
+	constructor(message, options) {
+		super(message);
+		this.name = "StatewireReject";
+		if (options?.payload !== void 0) this.payload = options.payload;
+	}
+};
+//#endregion
+export { StatewireReject };
+
+//# sourceMappingURL=engine.js.map

package/dist/host/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","names":["StatewireReject","Error","payload","constructor","message","options","name","undefined"],"sources":["../../src/host/engine.ts"],"sourcesContent":["/**\n * Definitive handler rejection: the command settles rejected and\n * message/payload travel to the client's rejected promise.\n */\nexport class StatewireReject extends Error {\n  readonly payload?: unknown;\n\n  constructor(message: string, options?: { payload?: unknown }) {\n    super(message);\n    this.name = \"StatewireReject\";\n    if (options?.payload !== undefined) this.payload = options.payload;\n  }\n}\n"],"mappings":";;;;;AAIA,IAAaA,kBAAb,cAAqCC,MAAM;CACzC;CAEAE,YAAYC,SAAiBC,SAAiC;EAC5D,MAAMD,OAAO;EACb,KAAKE,OAAO;EACZ,IAAID,SAASH,YAAYK,KAAAA,GAAW,KAAKL,UAAUG,QAAQH;CAC7D;AACF"}

package/dist/host/host.d.ts

@@ -0,0 +1,79 @@
+import { StatewireOp } from "../wire/ops.js";
+import { StatewireCommands, StatewireCommandsProxy, StatewireStateSource } from "../types.js";
+import { ServerOp } from "./draft.js";
+//#region src/host/host.d.ts
+type StatewireStateCtl = {
+  /** Apply server-vocabulary ops (root replace = whole-state swap). */
+  apply: (ops: readonly StatewireOp[]) => void;
+};
+type StateHost = StatewireStateSource & {
+  /** Synchronous, per locally-recorded op; the host owns batching. */
+  setOnOp: (listener: ((op: ServerOp) => void) | null) => void;
+};
+declare const getStateHost: (state: object) => StateHost | undefined;
+declare const useStatewireState: <TState>(init: () => TState) => readonly [TState, StatewireStateCtl];
+declare const executionResult: unique symbol;
+/**
+ * Handle a command handler returns to keep the command open past its own
+ * return: `ack()` releases the client's optimistic overlay / ack watermark,
+ * `resolve`/`reject` settle the command (and imply ack). `ack` is idempotent
+ * and a no-op after settle.
+ */
+type CommandExecution<T = void> = {
+  readonly [executionResult]: (value: T) => void;
+};
+type CommandExecutionResolvers<T = void> = {
+  ack: () => void;
+  resolve: (value: T) => void;
+  reject: (error: unknown) => void;
+};
+/**
+ * `CommandExecution(executor)` runs the (possibly async) `executor({ ack })`
+ * immediately: its return value resolves the execution, a throw/rejection
+ * rejects it; `ack()` releases the client's ack watermark before the executor
+ * finishes. `CommandExecution.withResolvers()` returns `[execution,
+ * { ack, resolve, reject }]` instead — settle them from your own spawned work.
+ */
+declare const CommandExecution: (<T = void>(executor: (resolvers: {
+  ack: () => void;
+}) => T | void | PromiseLike<T | void>) => CommandExecution<T>) & {
+  withResolvers: <T = void>() => [CommandExecution<T>, CommandExecutionResolvers<T>];
+};
+type CommandsInvocation = {
+  readonly method: string;
+  readonly params: readonly unknown[];
+  readonly ts: number;
+  readonly seq: number;
+  readonly clientId?: string;
+};
+type CommandsOutcome = {
+  type: "accepted";
+  payload?: unknown;
+} | {
+  type: "rejected";
+  error: unknown;
+};
+type CommandsListener = {
+  onStart: (inv: CommandsInvocation) => void;
+  onPosted?: (inv: CommandsInvocation) => void;
+  onAck: (inv: CommandsInvocation) => void;
+  /** Canonical state now covers the invocation's effect — drop any overlay. */
+  onCovered?: (inv: CommandsInvocation) => void;
+  onSettle: (inv: CommandsInvocation, outcome: CommandsOutcome) => void;
+};
+type CommandsHost = {
+  setListener: (listener: CommandsListener | null) => void;
+};
+declare const getCommandsHost: (commands: object) => CommandsHost | undefined;
+declare const bindCommandsHost: (commands: object, host: CommandsHost) => void;
+type UnwrapExecution<V> = V extends CommandExecution<infer T> ? T : V;
+type StatewireHandledCommands<THandlers extends StatewireCommands> = { [K in keyof THandlers]: (...args: Parameters<THandlers[K]>) => UnwrapExecution<Awaited<ReturnType<THandlers[K]>>>; };
+declare const useStatewireCommands: <THandlers extends StatewireCommands>(commands: THandlers | undefined | null | false) => StatewireCommandsProxy<StatewireHandledCommands<THandlers>>;
+type EmitHost = {
+  setSink: (sink: ((event: unknown) => void) | null) => void;
+};
+declare const getEmitHost: (emit: object) => EmitHost | undefined;
+declare const useStatewireEmit: <TEvent>() => ((event: TEvent) => void);
+//#endregion
+export { CommandExecution, CommandExecutionResolvers, CommandsHost, CommandsInvocation, CommandsListener, CommandsOutcome, EmitHost, StateHost, StatewireHandledCommands, StatewireStateCtl, bindCommandsHost, getCommandsHost, getEmitHost, getStateHost, useStatewireCommands, useStatewireEmit, useStatewireState };
+//# sourceMappingURL=host.d.ts.map

package/dist/host/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","names":[],"sources":["../../src/host/host.ts"],"mappings":";;;;KAkBY;;EAEV,QAAQ,cAAc;;KAGZ,YAAY;;EAEtB,UAAU,YAAY,IAAI;;cAKf,eAAgB,kBAAgB;cAchC,oBAAqB,QAChC,YAAY,qBACD,QAAQ;cAgFP;;;;;;;KAQF,iBAAiB;YACjB,mBAAmB,OAAO;;KAG1B,0BAA0B;EACpC;EACA,UAAU,OAAO;EACjB,SAAS;;;;;;;;;cAUE,oBACV,UAAC,WACW;EACT;MACI,WAAW,YAAY,cAC5B,iBAAiB;EAyBF,gBAAA,gBACd,iBAAiB,IACjB,0BAA0B;;KAkBpB;WACD;WACA;WACA;WACA;WACA;;KAGC;EACN;EAAkB;;EAClB;EAAkB;;KAEZ;EACV,UAAU,KAAK;EACf,YAAY,KAAK;EACjB,QAAQ,KAAK;;EAEb,aAAa,KAAK;EAClB,WAAW,KAAK,oBAAoB,SAAS;;KAGnC;EACV,cAAc,UAAU;;cAKb,kBAAmB,qBAAmB;cAGtC,mBAAoB,kBAAkB,MAAM;KAsIpD,gBAAgB,KAAK,UAAU,uBAAuB,KAAK,IAAI;KAExD,yBAAyB,kBAAkB,wBACpD,WAAW,gBACP,MAAM,WAAW,UAAU,QAC3B,gBAAgB,QAAQ,WAAW,UAAU;cAGvC,uBAAwB,kBAAkB,mBACrD,UAAU,yCACT,uBAAuB,yBAAyB;KA+EvC;EACV,UAAU,QAAQ;;cAKP,cAAe,iBAAe;cAG9B,mBAAoB,eAAa,OAAO"}

package/dist/host/host.js

@@ -0,0 +1,303 @@
+import { applyOp, applyOps } from "../wire/ops.js";
+import { StatewireReject } from "./engine.js";
+import { createStateDraft, frozen } from "./draft.js";
+import { StatewireSendError } from "../types.js";
+import { useEffect, useState } from "@assistant-ui/tap/react-shim";
+//#region src/host/host.ts
+const isDev = () => typeof process === "undefined" || process.env["NODE_ENV"] !== "production";
+const stateHosts = /* @__PURE__ */ new WeakMap();
+const getStateHost = (state) => stateHosts.get(state);
+const useStatewireState = (init) => {
+	const [, setVersion] = useState(0);
+	const [cell] = useState(() => {
+		const c = {
+			current: frozen(init()),
+			draft: null,
+			changed: [[]],
+			onOp: null,
+			onChange: null,
+			bump: () => setVersion((v) => v + 1),
+			ctl: { apply: (ops) => {
+				const result = applyOps(c.current, ops);
+				if (result.events.length > 0) throw new Error("statewire: event ops do not apply to state — route them to emit");
+				c.current = result.state;
+				c.changed.push(...result.changedPaths);
+				c.bump();
+				c.onChange?.();
+			} },
+			host: {
+				root: () => c.current,
+				setOnOp: (listener) => {
+					c.onOp = listener;
+				},
+				setOnChange: (listener_0) => {
+					c.onChange = listener_0;
+				},
+				takeChanged: () => {
+					const changed = c.changed;
+					c.changed = [];
+					return changed;
+				}
+			}
+		};
+		return c;
+	});
+	let value = cell.current;
+	if (typeof value === "object" && value !== null) {
+		cell.draft ??= createStateDraft({
+			root: () => cell.current,
+			record: (op) => {
+				const applied = applyOp(cell.current, op);
+				cell.current = applied.state;
+				cell.changed.push(...applied.changedPaths);
+				cell.onOp?.(op);
+				cell.bump();
+				cell.onChange?.();
+			}
+		});
+		stateHosts.set(cell.draft, cell.host);
+		value = cell.draft;
+	}
+	return [value, cell.ctl];
+};
+const executionStates = /* @__PURE__ */ new WeakMap();
+/**
+* `CommandExecution(executor)` runs the (possibly async) `executor({ ack })`
+* immediately: its return value resolves the execution, a throw/rejection
+* rejects it; `ack()` releases the client's ack watermark before the executor
+* finishes. `CommandExecution.withResolvers()` returns `[execution,
+* { ack, resolve, reject }]` instead — settle them from your own spawned work.
+*/
+const CommandExecution = Object.assign((executor) => {
+	const state = {
+		acked: false,
+		settled: null,
+		bind: null
+	};
+	const execution = Object.freeze({});
+	executionStates.set(execution, state);
+	const settle = (settled) => {
+		if (state.settled) return;
+		state.settled = settled;
+		state.acked = true;
+		state.bind?.onSettle(settled);
+	};
+	const ack = () => {
+		if (state.acked) return;
+		state.acked = true;
+		state.bind?.onAck();
+	};
+	(async () => {
+		try {
+			settle({
+				type: "resolved",
+				value: await executor({ ack })
+			});
+		} catch (error) {
+			settle({
+				type: "rejected",
+				error
+			});
+		}
+	})();
+	return execution;
+}, { withResolvers: () => {
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	let ack;
+	return [CommandExecution(({ ack: a }) => {
+		ack = a;
+		return promise;
+	}), {
+		ack: () => ack(),
+		resolve,
+		reject
+	}];
+} });
+const commandsHosts = /* @__PURE__ */ new WeakMap();
+const getCommandsHost = (commands) => commandsHosts.get(commands);
+const bindCommandsHost = (commands, host) => {
+	commandsHosts.set(commands, host);
+};
+const STALL_WARN_MS = 5e3;
+const toSendError = (error) => error instanceof StatewireSendError ? error : new StatewireSendError({
+	fate: "rejected",
+	cause: "server",
+	message: error instanceof Error ? error.message : String(error),
+	...error instanceof StatewireReject && error.payload !== void 0 && { payload: error.payload }
+});
+const ackInvocation = (cell, inv) => {
+	if (inv.acked) return;
+	inv.acked = true;
+	cell.listener?.onAck(inv);
+};
+const settleInvocation = (cell, inv, call, settled) => {
+	ackInvocation(cell, inv);
+	if (settled.type === "resolved") {
+		const outcome = settled.value === void 0 ? { type: "accepted" } : {
+			type: "accepted",
+			payload: frozen(settled.value)
+		};
+		cell.listener?.onSettle(inv, outcome);
+		call.resolve(outcome.payload);
+	} else {
+		const error = toSendError(settled.error);
+		cell.listener?.onSettle(inv, {
+			type: "rejected",
+			error
+		});
+		call.reject(error);
+	}
+};
+const pump = (cell) => {
+	if (cell.running || !cell.handlers) {
+		watchStall(cell);
+		return;
+	}
+	const call = cell.queue.shift();
+	if (!call) return;
+	const handler = cell.handlers[call.method];
+	if (handler === void 0) {
+		call.reject(new StatewireSendError({
+			fate: "unknown-command",
+			cause: "server"
+		}));
+		pump(cell);
+		return;
+	}
+	const inv = {
+		method: call.method,
+		params: call.params,
+		ts: call.ts,
+		seq: ++cell.seq,
+		acked: false
+	};
+	cell.running = true;
+	cell.listener?.onStart(inv);
+	cell.listener?.onPosted?.(inv);
+	cell.listener?.onCovered?.(inv);
+	(async () => {
+		try {
+			const value = await handler(...call.params);
+			const execution = typeof value === "object" && value !== null ? executionStates.get(value) : void 0;
+			if (execution) {
+				if (execution.acked) ackInvocation(cell, inv);
+				if (execution.settled) settleInvocation(cell, inv, call, execution.settled);
+				else execution.bind = {
+					onAck: () => ackInvocation(cell, inv),
+					onSettle: (settled) => settleInvocation(cell, inv, call, settled)
+				};
+			} else settleInvocation(cell, inv, call, {
+				type: "resolved",
+				value
+			});
+		} catch (error) {
+			settleInvocation(cell, inv, call, {
+				type: "rejected",
+				error
+			});
+		} finally {
+			cell.running = false;
+			pump(cell);
+		}
+	})();
+};
+const watchStall = (cell) => {
+	if (!isDev() || cell.stallTimer !== null || cell.queue.length === 0) return;
+	if (cell.handlers) return;
+	cell.stallTimer = setTimeout(() => {
+		cell.stallTimer = null;
+		if (cell.handlers === null && cell.queue.length > 0 && !cell.unmounted) console.warn(`statewire: ${cell.queue.length} buffered command(s) waiting over ${STALL_WARN_MS}ms — did the host forget to arm useStatewireCommands?`);
+	}, STALL_WARN_MS);
+};
+const useStatewireCommands = (commands) => {
+	const [built] = useState(() => {
+		const cell = {
+			handlers: null,
+			queue: [],
+			running: false,
+			listener: null,
+			seq: 0,
+			unmounted: false,
+			stallTimer: null
+		};
+		const memo = /* @__PURE__ */ new Map();
+		const proxy = new Proxy({}, { get: (_target, method) => {
+			if (typeof method !== "string") return void 0;
+			let fn = memo.get(method);
+			if (fn === void 0) {
+				fn = (...params) => new Promise((resolve, reject) => {
+					if (cell.unmounted) {
+						reject(/* @__PURE__ */ new Error("statewire: commands called after unmount"));
+						return;
+					}
+					cell.queue.push({
+						method,
+						params,
+						ts: Date.now(),
+						resolve,
+						reject
+					});
+					pump(cell);
+				});
+				memo.set(method, fn);
+			}
+			return fn;
+		} });
+		commandsHosts.set(proxy, { setListener: (listener) => {
+			cell.listener = listener;
+		} });
+		return {
+			cell,
+			proxy
+		};
+	});
+	useEffect(() => {
+		const { cell: cell_0 } = built;
+		cell_0.unmounted = false;
+		return () => {
+			cell_0.unmounted = true;
+			cell_0.handlers = null;
+			if (cell_0.stallTimer !== null) {
+				clearTimeout(cell_0.stallTimer);
+				cell_0.stallTimer = null;
+			}
+			queueMicrotask(() => {
+				if (!cell_0.unmounted) return;
+				const queued = cell_0.queue;
+				cell_0.queue = [];
+				for (const call of queued) call.reject(/* @__PURE__ */ new Error("statewire: unmounted"));
+			});
+		};
+	}, [built]);
+	useEffect(() => {
+		built.cell.handlers = commands || null;
+		pump(built.cell);
+	});
+	return built.proxy;
+};
+const emitHosts = /* @__PURE__ */ new WeakMap();
+const getEmitHost = (emit) => emitHosts.get(emit);
+const useStatewireEmit = () => {
+	const [built] = useState(_temp);
+	return built;
+};
+function _temp() {
+	const cell = { sink: null };
+	const emit = (event) => {
+		if (!cell.sink) throw new Error("statewire: emit before a host bound the event sink");
+		cell.sink(frozen(event));
+	};
+	emitHosts.set(emit, { setSink: (sink) => {
+		cell.sink = sink;
+	} });
+	return emit;
+}
+//#endregion
+export { CommandExecution, bindCommandsHost, getCommandsHost, getEmitHost, getStateHost, useStatewireCommands, useStatewireEmit, useStatewireState };
+
+//# sourceMappingURL=host.js.map

package/dist/host/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","names":["useEffect","useState","applyOp","applyOps","StatewireOp","StatewirePath","StatewireReject","createStateDraft","frozen","ServerOp","StatewireSendError","StatewireCommands","StatewireCommandsProxy","StatewireStateSource","isDev","process","env","StatewireStateCtl","apply","ops","StateHost","setOnOp","listener","op","stateHosts","WeakMap","getStateHost","state","get","StateCell","current","draft","changed","onOp","onChange","ctl","host","bump","useStatewireState","init","TState","setVersion","cell","c","v","result","events","length","Error","push","changedPaths","root","setOnChange","takeChanged","value","record","applied","set","const","ExecutionSettled","type","error","ExecutionBind","onAck","onSettle","settled","ExecutionState","acked","bind","executionStates","executionResult","CommandExecution","T","CommandExecutionResolvers","ack","resolve","reject","Object","assign","executor","resolvers","PromiseLike","execution","freeze","settle","withResolvers","promise","Promise","res","rej","a","CommandsInvocation","method","params","ts","seq","clientId","CommandsOutcome","payload","CommandsListener","onStart","inv","onPosted","onCovered","outcome","CommandsHost","setListener","commandsHosts","getCommandsHost","commands","bindCommandsHost","QueuedCall","ActiveInvocation","CommandsCell","handlers","Record","args","queue","running","unmounted","stallTimer","ReturnType","setTimeout","STALL_WARN_MS","toSendError","fate","cause","message","String","undefined","ackInvocation","settleInvocation","call","pump","watchStall","shift","handler","console","warn","UnwrapExecution","V","StatewireHandledCommands","THandlers","Parameters","K","Awaited","useStatewireCommands","built","memo","Map","proxy","Proxy","_target","fn","Date","now","clearTimeout","queueMicrotask","queued","EmitHost","setSink","sink","event","emitHosts","getEmitHost","emit","useStatewireEmit","_temp"],"sources":["../../src/host/host.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { applyOp, applyOps } from \"../wire/ops\";\nimport type { StatewireOp, StatewirePath } from \"../wire/ops\";\nimport { StatewireReject } from \"./engine\";\nimport { createStateDraft, frozen } from \"./draft\";\nimport type { ServerOp } from \"./draft\";\nimport { StatewireSendError } from \"../types\";\nimport type {\n  StatewireCommands,\n  StatewireCommandsProxy,\n  StatewireStateSource,\n} from \"../types\";\n\nconst isDev = () =>\n  typeof process === \"undefined\" || process.env[\"NODE_ENV\"] !== \"production\";\n\n// ─── state ──────────────────────────────────────────────\n\nexport type StatewireStateCtl = {\n  /** Apply server-vocabulary ops (root replace = whole-state swap). */\n  apply: (ops: readonly StatewireOp[]) => void;\n};\n\nexport type StateHost = StatewireStateSource & {\n  /** Synchronous, per locally-recorded op; the host owns batching. */\n  setOnOp: (listener: ((op: ServerOp) => void) | null) => void;\n};\n\nconst stateHosts = new WeakMap<object, StateHost>();\n\nexport const getStateHost = (state: object): StateHost | undefined =>\n  stateHosts.get(state);\n\ntype StateCell = {\n  current: unknown;\n  draft: object | null;\n  changed: StatewirePath[];\n  onOp: ((op: ServerOp) => void) | null;\n  onChange: (() => void) | null;\n  ctl: StatewireStateCtl;\n  host: StateHost;\n  bump: () => void;\n};\n\nexport const useStatewireState = <TState>(\n  init: () => TState,\n): readonly [TState, StatewireStateCtl] => {\n  const [, setVersion] = useState(0);\n  const [cell] = useState((): StateCell => {\n    const c: StateCell = {\n      current: frozen(init()),\n      draft: null,\n      changed: [[]],\n      onOp: null,\n      onChange: null,\n      bump: () => setVersion((v) => v + 1),\n      ctl: {\n        apply: (ops) => {\n          const result = applyOps(c.current, ops);\n          if (result.events.length > 0) {\n            throw new Error(\n              \"statewire: event ops do not apply to state — route them to emit\",\n            );\n          }\n          c.current = result.state;\n          c.changed.push(...result.changedPaths);\n          c.bump();\n          c.onChange?.();\n        },\n      },\n      host: {\n        root: () => c.current,\n        setOnOp: (listener) => {\n          c.onOp = listener;\n        },\n        setOnChange: (listener) => {\n          c.onChange = listener;\n        },\n        takeChanged: () => {\n          const changed = c.changed;\n          c.changed = [];\n          return changed;\n        },\n      },\n    };\n    return c;\n  });\n\n  let value = cell.current;\n  if (typeof value === \"object\" && value !== null) {\n    cell.draft ??= createStateDraft<object>({\n      root: () => cell.current,\n      record: (op) => {\n        const applied = applyOp(cell.current, op);\n        cell.current = applied.state;\n        cell.changed.push(...applied.changedPaths);\n        cell.onOp?.(op);\n        cell.bump();\n        cell.onChange?.();\n      },\n    });\n    stateHosts.set(cell.draft, cell.host);\n    value = cell.draft;\n  }\n  return [value as TState, cell.ctl] as const;\n};\n\n// ─── commands ───────────────────────────────────────────\n\ntype ExecutionSettled =\n  | { type: \"resolved\"; value: unknown }\n  | { type: \"rejected\"; error: unknown };\n\ntype ExecutionBind = {\n  onAck: () => void;\n  onSettle: (settled: ExecutionSettled) => void;\n};\n\ntype ExecutionState = {\n  acked: boolean;\n  settled: ExecutionSettled | null;\n  bind: ExecutionBind | null;\n};\n\nconst executionStates = new WeakMap<object, ExecutionState>();\n\ndeclare const executionResult: unique symbol;\n\n/**\n * Handle a command handler returns to keep the command open past its own\n * return: `ack()` releases the client's optimistic overlay / ack watermark,\n * `resolve`/`reject` settle the command (and imply ack). `ack` is idempotent\n * and a no-op after settle.\n */\nexport type CommandExecution<T = void> = {\n  readonly [executionResult]: (value: T) => void;\n};\n\nexport type CommandExecutionResolvers<T = void> = {\n  ack: () => void;\n  resolve: (value: T) => void;\n  reject: (error: unknown) => void;\n};\n\n/**\n * `CommandExecution(executor)` runs the (possibly async) `executor({ ack })`\n * immediately: its return value resolves the execution, a throw/rejection\n * rejects it; `ack()` releases the client's ack watermark before the executor\n * finishes. `CommandExecution.withResolvers()` returns `[execution,\n * { ack, resolve, reject }]` instead — settle them from your own spawned work.\n */\nexport const CommandExecution = Object.assign(\n  <T = void>(\n    executor: (resolvers: {\n      ack: () => void;\n    }) => T | void | PromiseLike<T | void>,\n  ): CommandExecution<T> => {\n    const state: ExecutionState = { acked: false, settled: null, bind: null };\n    const execution = Object.freeze({}) as unknown as CommandExecution<T>;\n    executionStates.set(execution, state);\n    const settle = (settled: ExecutionSettled) => {\n      if (state.settled) return;\n      state.settled = settled;\n      state.acked = true;\n      state.bind?.onSettle(settled);\n    };\n    const ack = () => {\n      if (state.acked) return;\n      state.acked = true;\n      state.bind?.onAck();\n    };\n    void (async () => {\n      try {\n        settle({ type: \"resolved\", value: await executor({ ack }) });\n      } catch (error) {\n        settle({ type: \"rejected\", error });\n      }\n    })();\n    return execution;\n  },\n  {\n    withResolvers: <T = void>(): [\n      CommandExecution<T>,\n      CommandExecutionResolvers<T>,\n    ] => {\n      let resolve!: (value: T) => void;\n      let reject!: (error: unknown) => void;\n      const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n      });\n      let ack!: () => void;\n      const execution = CommandExecution<T>(({ ack: a }) => {\n        ack = a;\n        return promise;\n      });\n      return [execution, { ack: () => ack(), resolve, reject }];\n    },\n  },\n);\n\nexport type CommandsInvocation = {\n  readonly method: string;\n  readonly params: readonly unknown[];\n  readonly ts: number;\n  readonly seq: number;\n  readonly clientId?: string;\n};\n\nexport type CommandsOutcome =\n  | { type: \"accepted\"; payload?: unknown }\n  | { type: \"rejected\"; error: unknown };\n\nexport type CommandsListener = {\n  onStart: (inv: CommandsInvocation) => void;\n  onPosted?: (inv: CommandsInvocation) => void;\n  onAck: (inv: CommandsInvocation) => void;\n  /** Canonical state now covers the invocation's effect — drop any overlay. */\n  onCovered?: (inv: CommandsInvocation) => void;\n  onSettle: (inv: CommandsInvocation, outcome: CommandsOutcome) => void;\n};\n\nexport type CommandsHost = {\n  setListener: (listener: CommandsListener | null) => void;\n};\n\nconst commandsHosts = new WeakMap<object, CommandsHost>();\n\nexport const getCommandsHost = (commands: object): CommandsHost | undefined =>\n  commandsHosts.get(commands);\n\nexport const bindCommandsHost = (commands: object, host: CommandsHost) => {\n  commandsHosts.set(commands, host);\n};\n\ntype QueuedCall = {\n  method: string;\n  params: readonly unknown[];\n  ts: number;\n  resolve: (value: unknown) => void;\n  reject: (error: unknown) => void;\n};\n\ntype ActiveInvocation = CommandsInvocation & { acked: boolean };\n\ntype CommandsCell = {\n  handlers: Record<string, (...args: never[]) => unknown> | null;\n  queue: QueuedCall[];\n  running: boolean;\n  listener: CommandsListener | null;\n  seq: number;\n  unmounted: boolean;\n  stallTimer: ReturnType<typeof setTimeout> | null;\n};\n\nconst STALL_WARN_MS = 5000;\n\nconst toSendError = (error: unknown): StatewireSendError =>\n  error instanceof StatewireSendError\n    ? error\n    : new StatewireSendError({\n        fate: \"rejected\",\n        cause: \"server\",\n        message: error instanceof Error ? error.message : String(error),\n        ...(error instanceof StatewireReject &&\n          error.payload !== undefined && { payload: error.payload }),\n      });\n\nconst ackInvocation = (cell: CommandsCell, inv: ActiveInvocation) => {\n  if (inv.acked) return;\n  inv.acked = true;\n  cell.listener?.onAck(inv);\n};\n\nconst settleInvocation = (\n  cell: CommandsCell,\n  inv: ActiveInvocation,\n  call: QueuedCall,\n  settled: ExecutionSettled,\n) => {\n  ackInvocation(cell, inv);\n  if (settled.type === \"resolved\") {\n    const outcome: CommandsOutcome =\n      settled.value === undefined\n        ? { type: \"accepted\" }\n        : { type: \"accepted\", payload: frozen(settled.value) };\n    cell.listener?.onSettle(inv, outcome);\n    call.resolve(outcome.payload);\n  } else {\n    const error = toSendError(settled.error);\n    cell.listener?.onSettle(inv, { type: \"rejected\", error });\n    call.reject(error);\n  }\n};\n\nconst pump = (cell: CommandsCell) => {\n  if (cell.running || !cell.handlers) {\n    watchStall(cell);\n    return;\n  }\n  const call = cell.queue.shift();\n  if (!call) return;\n  const handler = cell.handlers[call.method];\n  if (handler === undefined) {\n    call.reject(\n      new StatewireSendError({ fate: \"unknown-command\", cause: \"server\" }),\n    );\n    pump(cell);\n    return;\n  }\n  const inv: ActiveInvocation = {\n    method: call.method,\n    params: call.params,\n    ts: call.ts,\n    seq: ++cell.seq,\n    acked: false,\n  };\n  cell.running = true;\n  cell.listener?.onStart(inv);\n  cell.listener?.onPosted?.(inv);\n  cell.listener?.onCovered?.(inv);\n  void (async () => {\n    try {\n      const value = await (handler as (...args: readonly unknown[]) => unknown)(\n        ...call.params,\n      );\n      const execution =\n        typeof value === \"object\" && value !== null\n          ? executionStates.get(value)\n          : undefined;\n      if (execution) {\n        if (execution.acked) ackInvocation(cell, inv);\n        if (execution.settled) {\n          settleInvocation(cell, inv, call, execution.settled);\n        } else {\n          execution.bind = {\n            onAck: () => ackInvocation(cell, inv),\n            onSettle: (settled) => settleInvocation(cell, inv, call, settled),\n          };\n        }\n      } else {\n        settleInvocation(cell, inv, call, { type: \"resolved\", value });\n      }\n    } catch (error) {\n      settleInvocation(cell, inv, call, { type: \"rejected\", error });\n    } finally {\n      cell.running = false;\n      pump(cell);\n    }\n  })();\n};\n\nconst watchStall = (cell: CommandsCell) => {\n  if (!isDev() || cell.stallTimer !== null || cell.queue.length === 0) return;\n  if (cell.handlers) return;\n  cell.stallTimer = setTimeout(() => {\n    cell.stallTimer = null;\n    if (cell.handlers === null && cell.queue.length > 0 && !cell.unmounted) {\n      console.warn(\n        `statewire: ${cell.queue.length} buffered command(s) waiting over ${STALL_WARN_MS}ms — did the host forget to arm useStatewireCommands?`,\n      );\n    }\n  }, STALL_WARN_MS);\n};\n\ntype UnwrapExecution<V> = V extends CommandExecution<infer T> ? T : V;\n\nexport type StatewireHandledCommands<THandlers extends StatewireCommands> = {\n  [K in keyof THandlers]: (\n    ...args: Parameters<THandlers[K]>\n  ) => UnwrapExecution<Awaited<ReturnType<THandlers[K]>>>;\n};\n\nexport const useStatewireCommands = <THandlers extends StatewireCommands>(\n  commands: THandlers | undefined | null | false,\n): StatewireCommandsProxy<StatewireHandledCommands<THandlers>> => {\n  const [built] = useState(() => {\n    const cell: CommandsCell = {\n      handlers: null,\n      queue: [],\n      running: false,\n      listener: null,\n      seq: 0,\n      unmounted: false,\n      stallTimer: null,\n    };\n    const memo = new Map<string, (...params: unknown[]) => Promise<unknown>>();\n    const proxy = new Proxy(\n      {} as StatewireCommandsProxy<StatewireHandledCommands<THandlers>>,\n      {\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[]) =>\n              new Promise((resolve, reject) => {\n                if (cell.unmounted) {\n                  reject(new Error(\"statewire: commands called after unmount\"));\n                  return;\n                }\n                cell.queue.push({\n                  method,\n                  params,\n                  ts: Date.now(),\n                  resolve,\n                  reject,\n                });\n                pump(cell);\n              });\n            memo.set(method, fn);\n          }\n          return fn;\n        },\n      },\n    );\n    commandsHosts.set(proxy, {\n      setListener: (listener) => {\n        cell.listener = listener;\n      },\n    });\n    return { cell, proxy };\n  });\n\n  useEffect(() => {\n    const { cell } = built;\n    cell.unmounted = false;\n    return () => {\n      cell.unmounted = true;\n      cell.handlers = null;\n      if (cell.stallTimer !== null) {\n        clearTimeout(cell.stallTimer);\n        cell.stallTimer = null;\n      }\n      queueMicrotask(() => {\n        if (!cell.unmounted) return;\n        const queued = cell.queue;\n        cell.queue = [];\n        for (const call of queued) {\n          call.reject(new Error(\"statewire: unmounted\"));\n        }\n      });\n    };\n  }, [built]);\n\n  useEffect(() => {\n    built.cell.handlers = commands || null;\n    pump(built.cell);\n  });\n\n  return built.proxy;\n};\n\n// ─── emit ───────────────────────────────────────────────\n\nexport type EmitHost = {\n  setSink: (sink: ((event: unknown) => void) | null) => void;\n};\n\nconst emitHosts = new WeakMap<object, EmitHost>();\n\nexport const getEmitHost = (emit: object): EmitHost | undefined =>\n  emitHosts.get(emit);\n\nexport const useStatewireEmit = <TEvent>(): ((event: TEvent) => void) => {\n  const [built] = useState(() => {\n    const cell = { sink: null as ((event: unknown) => void) | null };\n    const emit = (event: TEvent) => {\n      if (!cell.sink) {\n        throw new Error(\"statewire: emit before a host bound the event sink\");\n      }\n      cell.sink(frozen(event));\n    };\n    emitHosts.set(emit, {\n      setSink: (sink) => {\n        cell.sink = sink;\n      },\n    });\n    return emit;\n  });\n  return built;\n};\n"],"mappings":"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"}

package/dist/index.d.ts

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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;kBA4BiB;OACH,aAAa;OACb,mBAAmB;OACnB,UACV,cACA,kBAAkB,oBAAoB,mBACtC,gBACE,mBAAmB,QAAQ,WAAW;OAC9B,cAAc;OACd,aAAa;OACb,YAAY;OACZ,QACV,QACA,kBAAkB,oBAAoB,mBACtC,gBACE,iBAAiB,QAAQ,WAAW;OAC5B,QACV,QACA,kBAAkB,oBAAoB,qBACpC,iBAAiB,QAAQ;OACjB,WAAW;OACX,QAAQ,kBAAkB,oBAAoB,qBACxD,iBAAiB;OACP,cAAc,kBAAkB,qBAC1C,uBAAuB;OACb,cACV,kBAAkB,oBAAoB,qBACpC,uBAAuB;OACf,WACV,QACA,kBAAkB,oBAAoB,qBACpC,oBAAoB,QAAQ;OACpB,oBAAoB;OACpB,cAAc;OACd,UAAU;OACV,KAAK"}