statewire 0.8.0 → 0.9.0

package/dist/host/socket.js

@@ -1,54 +1,85 @@
 import { StatewireSendError } from "../types.js";
-import { getCommandsHost, getEmitHost, getStateHost } from "./host.js";
+import { getCommandsHost, getStateHost } from "./host.js";
 import { encodeValue, reviveValue } from "../wire/meta.js";
 import { createMacrotaskPoster } from "../util/macrotask.js";
-import { randomId } from "../util/randomId.js";
-import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { useEffect, useState } from "@assistant-ui/tap/react-shim";
 import { createTapRoot, flushTapSync, useResource } from "@assistant-ui/tap";
 //#region src/host/socket.ts
 const CLIENT_ID_RE = /^[A-Za-z0-9._~-]{1,256}$/;
 const RESULT_TTL_MS = 3e4;
 const RESULT_LIMIT = 256;
-const parseFrame = (raw) => {
+const CLIENT_RECORD_LIMIT = 1024;
+const violation = (reason) => {
+	throw Object.assign(new Error(reason), { name: "StatewireViolation" });
+};
+const violationReason = (error) => error instanceof Error && error.name === "StatewireViolation" ? error.message : null;
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseLane = (value) => {
+	if (!Array.isArray(value)) return violation("malformed frame");
+	if (value.length === 0) return violation("empty lane");
+	const statements = [];
+	let prev = null;
+	for (const statement of value) {
+		if (!isPlainObject(statement)) return violation("malformed statement");
+		const seq = statement["seq"];
+		if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 1) return violation("malformed statement");
+		if (prev !== null && seq !== prev + 1) return violation("malformed frame");
+		prev = seq;
+		statements.push(statement);
+	}
+	return statements;
+};
+/** v1 ctx statements state the context whole: one root replace with an object value. */
+const contextValue = (ops) => {
+	if (!Array.isArray(ops) || ops.length !== 1) throw new Error("context must be a single-op array");
+	const op = ops[0];
+	if (!isPlainObject(op) || op["op"] !== "replace" || !Array.isArray(op["path"]) || op["path"].length !== 0) throw new Error("context op must be a root replace");
+	const value = op["meta"] !== void 0 ? reviveValue(op["value"], op["meta"]) : op["value"];
+	if (!isPlainObject(value)) throw new Error("context value must be an object");
+	return value;
+};
+const parseFrame = (raw, first) => {
 	let frame;
 	try {
 		frame = JSON.parse(raw);
 	} catch {
-		return null;
+		return violation("malformed frame");
 	}
-	if (typeof frame !== "object" || frame === null || Array.isArray(frame)) return null;
-	const { method, seq, params, meta, context } = frame;
-	if (method === void 0 && context === void 0) return null;
-	if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 1) return null;
-	if (method === void 0) return {
-		seq,
-		params: [],
-		...context !== void 0 && { context }
-	};
-	if (typeof method !== "string") return null;
-	if (!Array.isArray(params)) return null;
-	if (meta !== void 0) try {
-		reviveValue(params, meta);
+	if (!isPlainObject(frame)) return violation("malformed frame");
+	if (frame["headers"] === void 0 && frame["ctx"] === void 0 && frame["cmd"] === void 0) return violation("malformed frame");
+	let headers = null;
+	if (frame["headers"] !== void 0) {
+		if (!first) return violation("mid-session headers");
+		const raw = frame["headers"];
+		if (!isPlainObject(raw) || Object.values(raw).some((value) => typeof value !== "string")) return violation("malformed headers");
+		headers = raw;
+	}
+	const ctx = [];
+	if (frame["ctx"] !== void 0) for (const statement of parseLane(frame["ctx"])) try {
+		ctx.push({
+			seq: statement["seq"],
+			value: contextValue(statement["ops"])
+		});
 	} catch {
-		return null;
+		return violation("invalid-context");
+	}
+	const cmd = [];
+	if (frame["cmd"] !== void 0) for (const statement of parseLane(frame["cmd"])) {
+		const method = statement["method"];
+		if (typeof method !== "string" || !("params" in statement)) return violation("malformed statement");
+		cmd.push({
+			seq: statement["seq"],
+			method,
+			params: statement["params"],
+			...statement["meta"] !== void 0 && { meta: statement["meta"] }
+		});
 	}
 	return {
-		method,
-		seq,
-		params,
-		...context !== void 0 && { context }
+		headers,
+		ctx,
+		cmd
 	};
 };
-/** v1 context submissions are exactly one root replace with an object value. */
-const contextValue = (context) => {
-	if (!Array.isArray(context) || context.length !== 1) throw new Error("context must be a single-op array");
-	const op = context[0];
-	if (typeof op !== "object" || op === null || op["op"] !== "replace" || !Array.isArray(op["path"]) || op["path"].length !== 0) throw new Error("context op must be a root replace");
-	const value = op["value"];
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("context value must be an object");
-	return value;
-};
 const encodePayload = (payload) => {
 	if (payload === void 0) return {};
 	const { value, meta } = encodeValue(payload);
@@ -57,437 +88,466 @@ const encodePayload = (payload) => {
 		...meta !== void 0 && { meta }
 	};
 };
-const responseOf = (adm, outcome) => {
+const cmdOf = (adm, outcome) => {
 	if (outcome.type === "accepted") return {
 		seq: adm.seq,
-		type: "accepted",
+		type: "result",
 		...encodePayload(outcome.payload)
 	};
 	const failure = outcome.error instanceof StatewireSendError ? outcome.error.failure : null;
 	switch (failure?.fate) {
-		case "unknown-command": return {
-			seq: adm.seq,
-			type: "rejected",
-			code: "unknown-command",
-			message: `unknown method: '${adm.method}'`
-		};
-		case "invalid-params": return {
-			seq: adm.seq,
-			type: "rejected",
-			code: "invalid-params",
-			message: failure.message
-		};
-		case "crashed": return {
+		case "failed": return {
 			seq: adm.seq,
-			type: "crashed"
-		};
-		case "rejected": return {
-			seq: adm.seq,
-			type: "rejected",
-			message: failure.message,
-			...encodePayload(failure.payload)
+			type: "failed",
+			...failure.message !== void 0 && { message: failure.message }
 		};
+		case "rejected":
+			if (failure.code !== void 0) {
+				const message = failure.code === "unknown-command" ? `unknown method: '${adm.method}'` : failure.message;
+				return {
+					seq: adm.seq,
+					type: "rejected",
+					code: failure.code,
+					...message !== void 0 && { message }
+				};
+			}
+			return {
+				seq: adm.seq,
+				type: "rejected",
+				...failure.message !== void 0 && { message: failure.message },
+				...encodePayload(failure.payload)
+			};
 		default: return {
 			seq: adm.seq,
-			type: "rejected",
+			type: "failed",
 			message: outcome.error instanceof Error ? outcome.error.message : String(outcome.error)
 		};
 	}
 };
-const createSocketHost = (options) => {
-	const heartbeatMs = options?.heartbeatIntervalMs ?? 15e3;
-	const clients = /* @__PURE__ */ new Map();
-	const conns = /* @__PURE__ */ new Set();
-	let pendingOps = [];
-	let dirtyAcks = /* @__PURE__ */ new Set();
-	let pendingRes = /* @__PURE__ */ new Map();
-	let inbox = Promise.resolve();
-	let finished = null;
-	let disposed = false;
-	let flushScheduled = false;
-	let heartbeatTimer = null;
-	let stateHost = null;
-	let commandsHost = null;
-	let emitHost = null;
-	let current = null;
-	const post = createMacrotaskPoster(() => {
-		flushScheduled = false;
-		flush();
-	});
-	const scheduleFlush = () => {
-		if (flushScheduled || disposed) return;
-		flushScheduled = true;
-		post();
-	};
-	const recordOp = (op) => {
-		if (op.op === "replace" || op.op === "add" || op.op === "event") {
-			const { value, meta } = encodeValue(op.value);
-			pendingOps.push({
-				...op,
-				value,
-				...meta !== void 0 && { meta }
-			});
-		} else pendingOps.push(op);
-		scheduleFlush();
-	};
-	const attach = (next) => {
-		if (next === current) return;
-		current = next;
-		const nextState = typeof next.state === "object" && next.state !== null ? getStateHost(next.state) : void 0;
-		const nextCommands = getCommandsHost(next.commands);
-		const nextEmit = getEmitHost(next.emit);
-		if (!nextState || !nextCommands?.submit || !nextEmit) throw new Error("StatewireSocketHost requires a statewire/host transport (useStatewireState with object state, useStatewireCommands, useStatewireEmit)");
-		if (nextState !== stateHost) {
-			stateHost?.setOnOp(null);
-			stateHost = nextState;
-			stateHost.setOnOp(recordOp);
-		}
-		commandsHost = nextCommands;
-		if (nextEmit !== emitHost) {
-			emitHost?.setSink(null);
-			emitHost = nextEmit;
-			emitHost.setSink((event) => recordOp({
-				op: "event",
-				value: event
-			}));
-		}
-	};
-	const closeConn = (conn, code, reason) => {
-		if (!conn.open) return;
-		conn.open = false;
-		conns.delete(conn);
-		try {
-			conn.socket.close(code, reason);
-		} catch {}
-		if (conns.size === 0 && heartbeatTimer !== null) {
-			clearInterval(heartbeatTimer);
-			heartbeatTimer = null;
-		}
-	};
-	const sendTo = (conn, data) => {
-		if (!conn.open) return;
-		conn.lastSentAt = Date.now();
-		try {
-			conn.socket.send(data);
-		} catch {
-			closeConn(conn);
-		}
-	};
-	const ensureHeartbeat = () => {
-		if (heartbeatTimer !== null || heartbeatMs <= 0) return;
-		heartbeatTimer = setInterval(() => {
-			const now = Date.now();
-			for (const conn of [...conns]) if (now - conn.lastSentAt >= heartbeatMs) sendTo(conn, "{}");
-		}, heartbeatMs);
-		heartbeatTimer.unref?.();
-	};
-	const flush = (fin) => {
-		flushTapSync(() => {});
-		stateHost?.takeChanged();
-		for (const rec of clients.values()) for (const adm of rec.inflight.values()) if (adm.acked && !adm.settled && !adm.pendingSent) {
-			adm.pendingSent = true;
-			queueRes(rec.id, {
-				seq: adm.seq,
-				type: "pending"
-			});
-		}
-		if (pendingOps.length === 0 && dirtyAcks.size === 0 && pendingRes.size === 0 && fin === void 0) return;
-		const ops = pendingOps;
-		const acks = dirtyAcks;
-		const res = pendingRes;
-		pendingOps = [];
-		dirtyAcks = /* @__PURE__ */ new Set();
-		pendingRes = /* @__PURE__ */ new Map();
-		for (const conn of [...conns]) {
-			const envelope = {};
-			if (ops.length > 0) envelope.ops = ops;
-			const clientRes = res.get(conn.clientId);
-			if (clientRes !== void 0) envelope.res = clientRes;
-			if (acks.has(conn.clientId)) {
-				const rec = clients.get(conn.clientId);
-				if (rec !== void 0) envelope.ack = rec.lastSeq;
-			}
-			if (fin !== void 0) envelope.fin = fin;
-			if (Object.keys(envelope).length === 0) continue;
-			sendTo(conn, JSON.stringify(envelope));
-			if (fin !== void 0) closeConn(conn);
-		}
-	};
-	const queueRes = (clientId, response) => {
-		const list = pendingRes.get(clientId);
-		if (list) list.push(response);
-		else pendingRes.set(clientId, [response]);
-	};
-	const advance = (rec, seq) => {
-		rec.lastSeq = seq;
-		dirtyAcks.add(rec.id);
-	};
-	const retain = (rec, response) => {
-		const now = Date.now();
-		rec.results.set(response.seq, {
-			ts: now,
-			res: response
+const scheduleFlush = (h) => {
+	if (h.flushScheduled || h.disposed) return;
+	h.flushScheduled = true;
+	h.post();
+};
+const recordOp = (h, op) => {
+	if (op.op === "replace" || op.op === "add") {
+		const { value, meta } = encodeValue(op.value);
+		h.pendingOps.push({
+			...op,
+			value,
+			...meta !== void 0 && { meta }
 		});
-		const newest = Math.max(...rec.results.keys());
-		for (const [seq, entry] of rec.results) if (seq !== newest && now - entry.ts > RESULT_TTL_MS) rec.results.delete(seq);
-		while (rec.results.size > RESULT_LIMIT) rec.results.delete(Math.min(...rec.results.keys()));
-	};
-	const duplicateAnswer = (rec, seq) => {
-		const cached = rec.results.get(seq);
-		if (cached) {
-			if (seq === Math.max(...rec.results.keys()) || Date.now() - cached.ts <= RESULT_TTL_MS) return cached.res;
-			rec.results.delete(seq);
-		}
-		if (rec.inflight.has(seq)) return {
-			seq,
-			type: "pending"
-		};
-		return {
+	} else h.pendingOps.push(op);
+	scheduleFlush(h);
+};
+const attach = (h, next) => {
+	if (next === h.current) return;
+	h.current = next;
+	const nextState = typeof next.state === "object" && next.state !== null ? getStateHost(next.state) : void 0;
+	const nextCommands = getCommandsHost(next.commands);
+	if (!nextState || !nextCommands?.submit) throw new Error("StatewireSocketHost requires a statewire/host transport (useStatewireState with object state, useStatewireCommands)");
+	if (nextState !== h.stateHost) {
+		h.stateHost?.setOnOp(null);
+		h.stateHost = nextState;
+		h.stateHost.setOnOp((op) => recordOp(h, op));
+	}
+	h.commandsHost = nextCommands;
+};
+const closeConn = (h, conn, code, reason) => {
+	if (!conn.open) return;
+	conn.open = false;
+	h.conns.delete(conn);
+	try {
+		conn.socket.close(code, reason);
+	} catch {}
+	if (h.conns.size === 0 && h.heartbeatTimer !== null) {
+		clearInterval(h.heartbeatTimer);
+		h.heartbeatTimer = null;
+	}
+};
+const sendTo = (h, conn, data) => {
+	if (!conn.open) return;
+	conn.lastSentAt = Date.now();
+	try {
+		conn.socket.send(data);
+	} catch {
+		closeConn(h, conn);
+	}
+};
+const ensureHeartbeat = (h) => {
+	if (h.heartbeatTimer !== null || h.heartbeatMs <= 0) return;
+	h.heartbeatTimer = setInterval(() => {
+		const now = Date.now();
+		for (const conn of [...h.conns]) if (now - conn.lastSentAt >= h.heartbeatMs) sendTo(h, conn, "{}");
+	}, h.heartbeatMs);
+	h.heartbeatTimer.unref?.();
+};
+const setHeartbeatMs = (h, ms) => {
+	if (ms === h.heartbeatMs) return;
+	h.heartbeatMs = ms;
+	if (h.heartbeatTimer !== null) {
+		clearInterval(h.heartbeatTimer);
+		h.heartbeatTimer = null;
+		ensureHeartbeat(h);
+	}
+};
+const idleLevel = (h) => {
+	for (const rec of h.clients.values()) if (rec.inflight.size > 0) return false;
+	return true;
+};
+const flush = (h, fin) => {
+	flushTapSync(() => {});
+	h.stateHost?.takeChanged();
+	for (const rec of h.clients.values()) for (const adm of rec.inflight.values()) if (adm.applied && !adm.settled && !adm.appliedSent) {
+		adm.appliedSent = true;
+		queueApplied(h, rec.id, adm.seq);
+	}
+	const level = idleLevel(h);
+	const edge = level !== h.idleWire;
+	if (h.pendingOps.length === 0 && h.pendingApplied.size === 0 && h.pendingCmds.size === 0 && fin === void 0 && !edge) return;
+	h.idleWire = level;
+	if (fin === void 0 && edge && level && h.finOnIdle) fin = { reason: "idle" };
+	const ops = h.pendingOps;
+	const applied = h.pendingApplied;
+	const cmds = h.pendingCmds;
+	h.pendingOps = [];
+	h.pendingApplied = /* @__PURE__ */ new Map();
+	h.pendingCmds = /* @__PURE__ */ new Map();
+	for (const conn of [...h.conns]) {
+		const appliedEntries = (applied.get(conn.clientId) ?? []).map((seq) => ({
 			seq,
-			type: "result-unavailable"
-		};
-	};
-	const settleResponse = (rec, adm, response) => {
-		if (adm.settled) return;
-		adm.settled = true;
-		rec.inflight.delete(adm.seq);
-		retain(rec, response);
-		if (!adm.acked) {
-			adm.acked = true;
-			advance(rec, adm.seq);
-		}
-		if (adm.pendingSent || response.type !== "accepted" || response.payload !== void 0) queueRes(rec.id, response);
-		scheduleFlush();
-		adm.release();
-	};
-	const settleWire = (rec, adm, outcome) => settleResponse(rec, adm, responseOf(adm, outcome));
-	const callerOf = (rec) => ({
-		clientId: rec.id,
-		get context() {
-			return rec.context;
-		},
-		get isConnected() {
-			if (clients.get(rec.id) !== rec) return false;
-			for (const conn of conns) if (conn.clientId === rec.id && conn.open) return true;
-			return false;
+			type: "applied"
+		}));
+		if (ops.length > 0) {
+			const packet = {
+				ops,
+				...appliedEntries.length > 0 && { cmd: appliedEntries },
+				...edge && { idle: level }
+			};
+			sendTo(h, conn, JSON.stringify(packet));
+		} else if (appliedEntries.length > 0) sendTo(h, conn, JSON.stringify({ cmd: appliedEntries }));
+		const verdicts = cmds.get(conn.clientId) ?? [];
+		if (verdicts.length > 0) sendTo(h, conn, JSON.stringify({ cmd: verdicts }));
+		if (edge && ops.length === 0) sendTo(h, conn, JSON.stringify({ idle: level }));
+		if (fin !== void 0) {
+			sendTo(h, conn, JSON.stringify({ fin }));
+			closeConn(h, conn);
 		}
+	}
+};
+const queueApplied = (h, clientId, seq) => {
+	const list = h.pendingApplied.get(clientId);
+	if (list) list.push(seq);
+	else h.pendingApplied.set(clientId, [seq]);
+	scheduleFlush(h);
+};
+const queueCmd = (h, clientId, cmd) => {
+	const list = h.pendingCmds.get(clientId);
+	if (list) list.push(cmd);
+	else h.pendingCmds.set(clientId, [cmd]);
+	scheduleFlush(h);
+};
+const retain = (rec, cmd) => {
+	const now = Date.now();
+	rec.results.set(cmd.seq, {
+		ts: now,
+		cmd
 	});
-	const admit = (conn, frame) => {
-		if (!conn.open || disposed || finished !== null) return;
-		const rec = clients.get(conn.clientId);
-		if (frame.seq <= rec.lastSeq || rec.inflight.has(frame.seq)) {
-			queueRes(rec.id, duplicateAnswer(rec, frame.seq));
-			scheduleFlush();
+	const newest = Math.max(...rec.results.keys());
+	for (const [seq, entry] of rec.results) if (seq !== newest && now - entry.ts > RESULT_TTL_MS) rec.results.delete(seq);
+	while (rec.results.size > RESULT_LIMIT) rec.results.delete(Math.min(...rec.results.keys()));
+};
+/** Cmd-lane watermark: the last statement admitted, settled or not. */
+const admittedThrough = (rec) => Math.max(rec.lastSeq, ...rec.inflight.keys());
+const reemit = (h, rec, seq) => {
+	const cached = rec.results.get(seq);
+	if (cached) {
+		if (seq === Math.max(...rec.results.keys()) || Date.now() - cached.ts <= RESULT_TTL_MS) {
+			queueCmd(h, rec.id, cached.cmd);
 			return;
 		}
-		if (frame.seq > rec.lastSeq + 1) {
-			closeConn(conn, 1008, `seq gap: expected ${rec.lastSeq + 1}, got ${frame.seq}`);
+		rec.results.delete(seq);
+	}
+	const adm = rec.inflight.get(seq);
+	if (adm) {
+		if (adm.applied) queueApplied(h, rec.id, seq);
+		return;
+	}
+	queueCmd(h, rec.id, {
+		seq,
+		type: "expired"
+	});
+};
+const settleCmd = (h, rec, adm, cmd) => {
+	if (adm.settled) return;
+	adm.settled = true;
+	rec.inflight.delete(adm.seq);
+	retain(rec, cmd);
+	rec.lastSeq = Math.max(rec.lastSeq, adm.seq);
+	adm.applied = true;
+	queueCmd(h, rec.id, cmd);
+};
+const settleWire = (h, rec, adm, outcome) => settleCmd(h, rec, adm, cmdOf(adm, outcome));
+const callerOf = (h, rec) => ({
+	clientId: rec.id,
+	get context() {
+		return rec.context;
+	},
+	get isConnected() {
+		if (h.clients.get(rec.id) !== rec) return false;
+		for (const conn of h.conns) if (conn.clientId === rec.id && conn.open) return true;
+		return false;
+	}
+});
+const rejectStatement = (h, rec, adm, message) => settleCmd(h, rec, adm, {
+	seq: adm.seq,
+	type: "rejected",
+	code: "invalid-params",
+	message
+});
+const admitCmd = (h, rec, statement) => {
+	const adm = {
+		seq: statement.seq,
+		method: statement.method,
+		applied: false,
+		appliedSent: false,
+		settled: false
+	};
+	rec.inflight.set(statement.seq, adm);
+	if (!Array.isArray(statement.params)) {
+		rejectStatement(h, rec, adm, "params must be an array");
+		return;
+	}
+	let params = statement.params;
+	if (statement.meta !== void 0) try {
+		params = reviveValue(params, statement.meta);
+	} catch (error) {
+		rejectStatement(h, rec, adm, `invalid params: ${error.message}`);
+		return;
+	}
+	if (statement.method === "statewire/commands") {
+		if (params.length > 0) {
+			rejectStatement(h, rec, adm, "statewire/commands takes no params");
 			return;
 		}
-		const adm = {
-			seq: frame.seq,
-			method: frame.method ?? "",
-			acked: false,
-			pendingSent: false,
-			settled: false,
-			release: () => {}
-		};
-		if (frame.context !== void 0) {
-			let value;
-			try {
-				value = contextValue(frame.context);
-			} catch (error) {
-				rec.inflight.set(frame.seq, adm);
-				settleResponse(rec, adm, {
-					seq: frame.seq,
-					type: "rejected",
-					code: "invalid-context",
-					message: `invalid context: ${error.message}`
-				});
-				return;
-			}
-			rec.context = value;
-			if (frame.method === void 0) {
-				rec.inflight.set(frame.seq, adm);
-				settleResponse(rec, adm, {
-					seq: frame.seq,
-					type: "accepted"
-				});
-				return;
-			}
-		}
-		const released = new Promise((resolve) => {
-			adm.release = resolve;
+		const names = [...h.commandsHost?.methods?.() ?? [], "statewire/commands"].sort();
+		settleCmd(h, rec, adm, {
+			seq: adm.seq,
+			type: "result",
+			payload: names
 		});
-		rec.inflight.set(frame.seq, adm);
-		commandsHost.submit({
-			method: frame.method,
-			params: frame.params,
-			clientId: rec.id,
-			caller: callerOf(rec),
-			onAck: () => {
-				if (adm.settled || adm.acked) return;
-				adm.acked = true;
-				advance(rec, adm.seq);
-				scheduleFlush();
-				adm.release();
-			},
-			onSettle: (outcome) => settleWire(rec, adm, outcome)
-		}).catch((error) => {
-			if (!adm.settled) settleWire(rec, adm, {
-				type: "rejected",
-				error
-			});
+		return;
+	}
+	h.commandsHost.submit({
+		method: statement.method,
+		params,
+		clientId: rec.id,
+		caller: callerOf(h, rec),
+		onApplied: () => {
+			if (adm.settled || adm.applied) return;
+			adm.applied = true;
+			rec.lastSeq = Math.max(rec.lastSeq, adm.seq);
+			scheduleFlush(h);
+		},
+		onSettle: (outcome) => settleWire(h, rec, adm, outcome)
+	}).catch((error) => {
+		if (!adm.settled) settleWire(h, rec, adm, {
+			type: "rejected",
+			error
 		});
-		return released;
+	});
+};
+const admitFrame = (h, conn, frame) => {
+	const rec = h.clients.get(conn.clientId);
+	rec.touched = Date.now();
+	const through = admittedThrough(rec);
+	for (const statement of frame.cmd) if (statement.seq <= through) reemit(h, rec, statement.seq);
+	const ctxNew = frame.ctx.filter((s) => s.seq > rec.ctxSeq);
+	const cmdNew = frame.cmd.filter((s) => s.seq > through);
+	if (ctxNew.length > 0 && ctxNew[0].seq !== rec.ctxSeq + 1 || cmdNew.length > 0 && cmdNew[0].seq !== through + 1) {
+		sendTo(h, conn, JSON.stringify({ syn: {
+			seq: through,
+			ctxSeq: rec.ctxSeq
+		} }));
+		return;
+	}
+	for (const statement of ctxNew) {
+		rec.context = statement.value;
+		rec.ctxSeq = statement.seq;
+	}
+	for (const statement of cmdNew) admitCmd(h, rec, statement);
+	if (cmdNew.length > 0) queueCmd(h, rec.id, {
+		seq: cmdNew.at(-1).seq,
+		dur: true
+	});
+	scheduleFlush(h);
+};
+const message = (h, conn, data) => {
+	if (!conn.open || h.disposed || h.finished !== null) return;
+	const first = !conn.sawFrame;
+	conn.sawFrame = true;
+	let frame;
+	try {
+		frame = parseFrame(data, first);
+	} catch (error) {
+		const reason = violationReason(error);
+		if (reason === null) throw error;
+		closeConn(h, conn, 1008, reason);
+		return;
+	}
+	if (frame.ctx.length === 0 && frame.cmd.length === 0) return;
+	admitFrame(h, conn, frame);
+};
+const gcClients = (h) => {
+	let excess = h.clients.size - h.clientRecordLimit;
+	if (excess <= 0) return;
+	const live = new Set([...h.conns].map((conn) => conn.clientId));
+	const oldest = [...h.clients.values()].sort((a, b) => a.touched - b.touched);
+	for (const rec of oldest) {
+		if (excess <= 0) return;
+		if (live.has(rec.id) || rec.inflight.size > 0) continue;
+		h.clients.delete(rec.id);
+		excess -= 1;
+	}
+};
+const connect = (h, clientId, socket) => {
+	const dead = {
+		clientId,
+		message: () => {},
+		close: () => {}
 	};
-	const message = (conn, data) => {
-		if (!conn.open || disposed || finished !== null) return;
-		const frame = parseFrame(data);
-		if (frame === null) {
-			closeConn(conn, 1008, "invalid frame");
-			return;
-		}
-		inbox = inbox.then(() => admit(conn, frame));
+	const refuse = (code, reason) => {
+		try {
+			socket.close(code, reason);
+		} catch {}
+		return dead;
 	};
-	const connect = (clientId, socket) => {
-		const dead = {
-			clientId,
-			message: () => {},
-			close: () => {}
-		};
-		const refuse = (code, reason) => {
-			try {
-				socket.close(code, reason);
-			} catch {}
-			return dead;
-		};
-		if (disposed) return refuse(1001, "disposed");
-		if (!CLIENT_ID_RE.test(clientId)) return refuse(1008, "invalid client id");
-		flush();
-		if (finished !== null) {
-			try {
-				socket.send(JSON.stringify({ fin: finished }));
-			} catch {}
-			return refuse(1e3, "finished");
-		}
-		const known = clients.has(clientId);
-		const rec = known ? clients.get(clientId) : (() => {
-			const created = {
-				id: clientId,
-				lastSeq: 0,
-				context: null,
-				results: /* @__PURE__ */ new Map(),
-				inflight: /* @__PURE__ */ new Map()
-			};
-			clients.set(clientId, created);
-			return created;
-		})();
-		for (const other of [...conns]) {
-			if (other.clientId !== clientId) continue;
-			sendTo(other, JSON.stringify({ fin: { reason: "superseded" } }));
-			closeConn(other);
-		}
-		const conn = {
-			clientId,
-			socket,
-			open: true,
-			lastSentAt: 0
-		};
-		conns.add(conn);
-		ensureHeartbeat();
-		const { value, meta } = encodeValue(stateHost.snapshot());
-		const snapshot = {
-			ops: [{
-				op: "replace",
-				path: [],
-				value,
-				...meta !== void 0 && { meta }
-			}],
-			syn: {
-				lastSeq: known ? rec.lastSeq : -1,
-				lease: randomId()
-			}
-		};
-		sendTo(conn, JSON.stringify(snapshot));
-		return {
-			clientId,
-			message: (data) => message(conn, data),
-			close: () => closeConn(conn)
+	if (h.disposed) return refuse(1001, "disposed");
+	if (!CLIENT_ID_RE.test(clientId)) return refuse(1008, "invalid client id");
+	flush(h);
+	if (h.finished !== null) {
+		try {
+			socket.send(JSON.stringify({ fin: h.finished }));
+		} catch {}
+		return refuse(1e3, "finished");
+	}
+	const known = h.clients.has(clientId);
+	const rec = known ? h.clients.get(clientId) : (() => {
+		const created = {
+			id: clientId,
+			lastSeq: 0,
+			ctxSeq: 0,
+			touched: Date.now(),
+			context: null,
+			results: /* @__PURE__ */ new Map(),
+			inflight: /* @__PURE__ */ new Map()
 		};
+		h.clients.set(clientId, created);
+		return created;
+	})();
+	rec.touched = Date.now();
+	for (const other of [...h.conns]) {
+		if (other.clientId !== clientId) continue;
+		sendTo(h, other, JSON.stringify({ fin: { reason: "superseded" } }));
+		closeConn(h, other);
+	}
+	const conn = {
+		clientId,
+		socket,
+		open: true,
+		sawFrame: false,
+		lastSentAt: 0
 	};
-	const finish = (fin) => {
-		if (finished !== null || disposed) return;
-		finished = fin;
-		flush(fin);
+	h.conns.add(conn);
+	gcClients(h);
+	ensureHeartbeat(h);
+	const { value, meta } = encodeValue(h.stateHost.snapshot());
+	const hello = {
+		ops: [{
+			op: "replace",
+			path: [],
+			value,
+			...meta !== void 0 && { meta }
+		}],
+		syn: {
+			seq: admittedThrough(rec),
+			ctxSeq: rec.ctxSeq,
+			record: known ? "resumed" : "fresh",
+			...h.idleWire && { idle: true }
+		}
 	};
+	sendTo(h, conn, JSON.stringify(hello));
 	return {
-		connect,
-		finish,
-		attach,
-		resume: () => {
-			disposed = false;
-			stateHost?.setOnOp(recordOp);
-			emitHost?.setSink((event) => recordOp({
-				op: "event",
-				value: event
-			}));
-		},
-		suspend: () => {
-			disposed = true;
-			if (heartbeatTimer !== null) {
-				clearInterval(heartbeatTimer);
-				heartbeatTimer = null;
-			}
-			stateHost?.setOnOp(null);
-			emitHost?.setSink(null);
-		}
+		clientId,
+		message: (data) => message(h, conn, data),
+		close: () => closeConn(h, conn)
 	};
 };
+const finish = (h, fin) => {
+	if (h.finished !== null || h.disposed) return;
+	h.finished = fin;
+	flush(h, fin);
+};
+const resume = (h) => {
+	h.disposed = false;
+	h.stateHost?.setOnOp((op) => recordOp(h, op));
+};
+const suspend = (h) => {
+	h.disposed = true;
+	if (h.heartbeatTimer !== null) {
+		clearInterval(h.heartbeatTimer);
+		h.heartbeatTimer = null;
+	}
+	h.stateHost?.setOnOp(null);
+};
 const useSocketHost = (transport, options) => {
-	const $ = c(8);
-	let t0;
-	if ($[0] !== options) {
-		t0 = () => createSocketHost(options);
-		$[0] = options;
-		$[1] = t0;
-	} else t0 = $[1];
-	const [h] = useState(t0);
-	const value = useResource(transport);
-	h.attach(value);
-	let t1;
-	if ($[2] !== h || $[3] !== value) {
-		t1 = () => {
-			h.attach(value);
-		};
-		$[2] = h;
-		$[3] = value;
-		$[4] = t1;
-	} else t1 = $[4];
-	useEffect(t1);
-	let t2;
-	let t3;
-	if ($[5] !== h) {
-		t2 = () => {
-			h.resume();
-			return () => h.suspend();
+	const [h] = useState(() => {
+		const host = {
+			heartbeatMs: 15e3,
+			clientRecordLimit: CLIENT_RECORD_LIMIT,
+			finOnIdle: false,
+			clients: /* @__PURE__ */ new Map(),
+			conns: /* @__PURE__ */ new Set(),
+			pendingOps: [],
+			pendingApplied: /* @__PURE__ */ new Map(),
+			pendingCmds: /* @__PURE__ */ new Map(),
+			idleWire: true,
+			finished: null,
+			disposed: false,
+			flushScheduled: false,
+			heartbeatTimer: null,
+			stateHost: null,
+			commandsHost: null,
+			current: null,
+			post: createMacrotaskPoster(() => {
+				host.flushScheduled = false;
+				flush(host);
+			}),
+			connect: (clientId, socket) => connect(host, clientId, socket),
+			finish: (fin) => finish(host, fin)
 		};
-		t3 = [h];
-		$[5] = h;
-		$[6] = t2;
-		$[7] = t3;
-	} else {
-		t2 = $[6];
-		t3 = $[7];
-	}
-	useEffect(t2, t3);
+		return host;
+	});
+	setHeartbeatMs(h, options?.heartbeatIntervalMs ?? 15e3);
+	h.clientRecordLimit = options?.clientRecordLimit ?? CLIENT_RECORD_LIMIT;
+	h.finOnIdle = options?.finOnIdle ?? false;
+	const value = useResource(transport);
+	attach(h, value);
+	useEffect(() => {
+		attach(h, value);
+	});
+	useEffect(() => {
+		resume(h);
+		return () => suspend(h);
+	}, [h]);
 	return h;
 };
 /**
 * Transport-agnostic WS binding over a statewire/host transport:
 * feed it sockets (anything with `send`/`close`) and raw text frames, and it
-* speaks the Statewire envelope protocol — snapshot-first attach with `syn`,
-* delta/ack/res envelopes, per-client-id supersede, and `fin` on finish.
+* speaks the Statewire packet protocol — snapshot-first hello with `syn`,
+* statement-lane client frames under one admission law, `{cmd}` answer
+* arrays, per-client-id supersede, idle edges, and `fin` on finish.
 */
 const StatewireSocketHost = (transport, options) => {
 	const SocketHostRoot = () => {