statewire 0.18.2 → 0.19.0

package/dist/host/socket.js

@@ -1,8 +1,8 @@
 import { encodeDocument, reviveDocumentValue } from "../document.js";
 import { DEFAULT_PROTOCOL, WIRE_VERSION, negotiateProtocols } from "../wire/protocol.js";
-import { applyDocumentOps, mainDocument } from "../wire/documents.js";
+import { sanitizeValue } from "../wire/ops.js";
 import { StatewireSendError } from "../types.js";
-import { getCommandsHost, getStateHost } from "./host.js";
+import { documentIdentity, getCommandsHost, getStateHost } from "./host.js";
 import { COMMAND_CAPACITY_RETRY_MS, MAX_INFLIGHT_COMMANDS_PER_HOST } from "../wire/limits.js";
 import { createMacrotaskPoster } from "../util/macrotask.js";
 import { frames, stream } from "./http.js";
@@ -35,62 +35,37 @@ const violation = (reason) => {
 };
 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;
-};
 const frameEncoder = new TextEncoder();
 const parseFrameValue = (frame) => {
 	if (!isPlainObject(frame)) return violation("malformed frame");
 	const keys = Object.keys(frame);
 	if (keys.length === 0) return violation("malformed frame");
-	const unknown = keys.filter((key) => key !== "ctx" && key !== "cmd").sort();
+	const unknown = keys.filter((key) => key !== "cmd").sort();
 	if (unknown.length > 0) return violation(`unknown frame key: '${unknown[0]}'`);
-	const ctx = [];
-	if (frame["ctx"] !== void 0) {
-		const lane = frame["ctx"];
-		if (Array.isArray(lane) && lane.length > 256) return violation("too many context statements");
-		for (const statement of parseLane(lane)) {
-			const ops = statement["ops"];
-			if (!Array.isArray(ops) || !ops.length) return violation("invalid-context");
-			if (frameEncoder.encode(JSON.stringify(ops)).byteLength > 65536) return violation("oversized-context");
-			ctx.push({
-				seq: statement["seq"],
-				ops
-			});
-		}
-	}
+	const lane = frame["cmd"];
+	if (!Array.isArray(lane)) return violation("malformed frame");
+	if (lane.length === 0) return violation("empty lane");
+	if (lane.length > 256) return violation("too many commands");
+	const prev = /* @__PURE__ */ new Map();
 	const cmd = [];
-	if (frame["cmd"] !== void 0) {
-		const lane = frame["cmd"];
-		if (Array.isArray(lane) && lane.length > 256) return violation("too many commands");
-		for (const statement of parseLane(lane)) {
-			const method = statement["method"];
-			if (typeof method !== "string" || typeof statement["protocol"] !== "string" || !("params" in statement)) return violation("malformed statement");
-			cmd.push({
-				protocol: statement["protocol"],
-				seq: statement["seq"],
-				method,
-				params: statement["params"],
-				...statement["meta"] !== void 0 && { meta: statement["meta"] }
-			});
-		}
+	for (const statement of lane) {
+		if (!isPlainObject(statement)) return violation("malformed statement");
+		const seq = statement["seq"];
+		const method = statement["method"];
+		const protocol = statement["protocol"];
+		if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 1 || typeof method !== "string" || typeof protocol !== "string" || !("params" in statement)) return violation("malformed statement");
+		const last = prev.get(protocol);
+		if (last !== void 0 && seq !== last + 1) return violation("malformed frame");
+		prev.set(protocol, seq);
+		cmd.push({
+			protocol,
+			seq,
+			method,
+			params: statement["params"],
+			...statement["meta"] !== void 0 && { meta: statement["meta"] }
+		});
 	}
-	return {
-		ctx,
-		cmd
-	};
+	return { cmd };
 };
 const parseFrame = (raw) => {
 	let frame;
@@ -111,19 +86,23 @@ const encodePayload = (payload) => {
 	};
 };
 const cmdOf = (adm, outcome) => {
+	const at = {
+		protocol: adm.protocol,
+		seq: adm.seq
+	};
 	if (outcome.type === "accepted") return {
-		seq: adm.seq,
+		...at,
 		type: "result",
 		...encodePayload(outcome.payload)
 	};
 	const failure = outcome.error instanceof StatewireSendError ? outcome.error.failure : null;
 	switch (failure?.fate) {
 		case "crashed": return {
-			seq: adm.seq,
+			...at,
 			type: "crashed"
 		};
 		case "failed": return {
-			seq: adm.seq,
+			...at,
 			type: "failed",
 			...failure.message !== void 0 && { message: failure.message }
 		};
@@ -131,20 +110,20 @@ const cmdOf = (adm, outcome) => {
 			if (failure.code !== void 0) {
 				const message = failure.code === "unknown-command" ? `unknown method: '${adm.method}'` : failure.message;
 				return {
-					seq: adm.seq,
+					...at,
 					type: "rejected",
 					code: failure.code,
 					...message !== void 0 && { message }
 				};
 			}
 			return {
-				seq: adm.seq,
+				...at,
 				type: "rejected",
 				...failure.message !== void 0 && { message: failure.message },
 				...encodePayload(failure.payload)
 			};
 		default: return {
-			seq: adm.seq,
+			...at,
 			type: "failed",
 			message: outcome.error instanceof Error ? outcome.error.message : String(outcome.error)
 		};
@@ -163,10 +142,7 @@ const parseInitialFrame = (raw) => {
 	if (!isPlainObject(headers) || Object.values(headers).some((v) => typeof v !== "string")) return violation("malformed headers");
 	return {
 		headers,
-		frame: Object.keys(lanes).length ? parseFrameValue(lanes) : {
-			ctx: [],
-			cmd: []
-		}
+		frame: Object.keys(lanes).length ? parseFrameValue(lanes) : { cmd: [] }
 	};
 };
 const scheduleFlush = (h) => {
@@ -174,6 +150,10 @@ const scheduleFlush = (h) => {
 	h.flushScheduled = true;
 	h.post();
 };
+const markViews = (h) => {
+	h.viewsDirty = true;
+	scheduleFlush(h);
+};
 const recordOp = (h, op) => {
 	if (op.op === "replace" || op.op === "add") {
 		const { value, meta } = encodeDocument(op.value);
@@ -193,8 +173,10 @@ const attach = (h, next) => {
 	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?.setOnDocuments(null);
 		h.stateHost = nextState;
 		h.stateHost.setOnOp((op) => recordOp(h, op));
+		h.stateHost.setOnDocuments(() => markViews(h));
 	}
 	h.commandsHost = nextCommands;
 };
@@ -205,6 +187,7 @@ const closeConn = (h, conn, code, reason) => {
 	try {
 		conn.socket.close(code, reason);
 	} catch {}
+	h.current?.detached?.(conn.attach);
 	if (h.conns.size === 0 && h.heartbeatTimer !== null) {
 		clearInterval(h.heartbeatTimer);
 		h.heartbeatTimer = null;
@@ -219,6 +202,13 @@ const sendTo = (h, conn, data) => {
 		closeConn(h, conn);
 	}
 };
+const violate = (h, conn, reason) => {
+	sendTo(h, conn, JSON.stringify({ fin: {
+		reason: "protocol-error",
+		message: reason
+	} }));
+	closeConn(h, conn, 1008, reason);
+};
 const atSubscriberLimit = (h) => h.conns.size + [...h.pendingConns].filter((conn) => conn.authorizing).length >= h.maxSubscribers;
 const ensureHeartbeat = (h) => {
 	if (h.heartbeatTimer !== null || h.heartbeatMs <= 0) return;
@@ -237,46 +227,146 @@ const setHeartbeatMs = (h, ms) => {
 		ensureHeartbeat(h);
 	}
 };
+const durableLanes = function* (h) {
+	for (const rec of h.clients.values()) yield* rec.lanes.values();
+};
+const allLanes = function* (h) {
+	yield* durableLanes(h);
+	for (const conn of h.conns) yield* conn.lanes.values();
+};
 const idleLevel = (h) => {
 	if (h.current?.work?.isIdle === false) return false;
-	for (const rec of h.clients.values()) if (rec.inflight.size > 0) return false;
+	for (const lane of allLanes(h)) if (lane.inflight.size > 0) return false;
 	return true;
 };
+const selects = (conn, protocol) => conn.selection.protocols.some((p) => p.name === protocol);
+const viewOf = (h, conn) => {
+	const view = /* @__PURE__ */ new Map();
+	const shared = h.stateHost.documents();
+	const hostMain = documentIdentity(h.protocol.name);
+	for (const p of conn.selection.protocols) if (p.record === "ephemeral") {
+		for (const [id, doc] of conn.documents) if (doc.protocol === p.name) view.set(id, doc);
+	} else for (const [id, doc] of shared) if (doc.protocol === p.name && id !== hostMain && (doc.main || conn.included.has(id))) view.set(id, doc);
+	return view;
+};
+const diffView = (h, conn) => {
+	const current = viewOf(h, conn);
+	const ops = [];
+	for (const [id, entry] of conn.view) {
+		if (current.has(id)) continue;
+		conn.view.delete(id);
+		ops.push({
+			op: "unmount",
+			doc: entry.doc
+		});
+	}
+	for (const [id, doc] of current) {
+		const entry = conn.view.get(id);
+		if (entry !== void 0 && entry.value === doc.value) continue;
+		const { value, meta } = encodeDocument(doc.value);
+		if (entry === void 0) {
+			const number = conn.nextDoc++;
+			conn.view.set(id, {
+				doc: number,
+				value: doc.value
+			});
+			ops.push({
+				op: "mount",
+				doc: number,
+				protocol: doc.protocol,
+				...doc.key !== null && { key: doc.key },
+				...doc.main && { main: true },
+				value,
+				...meta !== void 0 && { meta }
+			});
+		} else {
+			entry.value = doc.value;
+			ops.push({
+				op: "replace",
+				doc: entry.doc,
+				path: [],
+				value,
+				...meta !== void 0 && { meta }
+			});
+		}
+	}
+	return ops;
+};
+const attachOf = (h, conn) => {
+	const requireSelected = (protocol) => {
+		const entry = conn.selection.protocols.find((p) => p.name === protocol);
+		if (entry === void 0) throw new Error(`statewire: protocol ${protocol} was not negotiated`);
+		return entry;
+	};
+	return {
+		document: (protocol, key) => {
+			if (key === void 0 && protocol === h.protocol.name) return h.stateHost.snapshot();
+			const view = viewOf(h, conn);
+			if (key !== void 0) return view.get(documentIdentity(protocol, key))?.value;
+			for (const doc of view.values()) if (doc.protocol === protocol && doc.main) return doc.value;
+		},
+		mount: (protocol, value, key, main = key === void 0) => {
+			if (requireSelected(protocol).record !== "ephemeral") throw new Error(`statewire: protocol ${protocol} is not ephemeral`);
+			const encoded = encodeDocument(value);
+			if (frameEncoder.encode(JSON.stringify(encoded)).byteLength > 65536) throw new Error("statewire: oversized ephemeral document");
+			const id = documentIdentity(protocol, key);
+			if (main) {
+				for (const [other, doc] of conn.documents) if (doc.protocol === protocol && doc.main && other !== id) throw new Error(`statewire: ${protocol} already has a main document`);
+			}
+			conn.documents.set(id, {
+				protocol,
+				key: key === void 0 ? null : [...key],
+				main,
+				value: sanitizeValue(value)
+			});
+			markViews(h);
+		},
+		unmount: (protocol, key) => {
+			if (!conn.documents.delete(documentIdentity(protocol, key))) throw new Error("statewire: document is not mounted");
+			markViews(h);
+		},
+		include: (protocol, key) => {
+			if (requireSelected(protocol).record !== void 0) throw new Error(`statewire: protocol ${protocol} is not durable`);
+			conn.included.add(documentIdentity(protocol, key));
+			markViews(h);
+		},
+		exclude: (protocol, key) => {
+			conn.included.delete(documentIdentity(protocol, key));
+			markViews(h);
+		}
+	};
+};
 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) {
+	for (const lane of allLanes(h)) for (const adm of lane.inflight.values()) if (adm.applied && !adm.settled && !adm.appliedSent) {
 		adm.appliedSent = true;
-		queueApplied(h, rec.id, adm.seq);
+		queueApplied(h, lane, adm);
 	}
 	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;
+	if (h.pendingOps.length === 0 && h.pendingApplied.size === 0 && h.pendingCmds.size === 0 && !h.viewsDirty && fin === void 0 && !edge && ![...h.conns].some((conn) => conn.pendingApplied.length > 0 || conn.pendingCmds.length > 0)) return;
 	h.idleWire = level;
+	h.viewsDirty = false;
 	if (fin === void 0 && edge && level && h.finOnIdle) fin = { reason: "idle" };
-	const ops = h.pendingOps;
+	const mainOps = 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: "applied"
+		if (!conn.ready) continue;
+		const forConn = (list) => (list ?? []).filter((cmd) => selects(conn, cmd.protocol));
+		const ops = [...selects(conn, h.protocol.name) ? mainOps : [], ...diffView(h, conn)];
+		const appliedEntries = [...forConn(applied.get(conn.clientId)), ...conn.pendingApplied.splice(0)];
+		if (ops.length > 0) sendTo(h, conn, JSON.stringify({
+			ops,
+			...appliedEntries.length > 0 && { cmd: appliedEntries },
+			...edge && { idle: level }
 		}));
-		if (ops.length > 0) {
-			const packet = {
-				ops: conn.selection.protocols.some((p) => p.name === h.protocol.name) ? 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) ?? []).map((cmd) => conn.selection.protocols.some((p) => p.name === h.protocol.name) ? cmd : {
-			seq: cmd.seq,
-			...cmd.dur === void 0 ? {} : { dur: cmd.dur }
-		});
+		else if (appliedEntries.length > 0) sendTo(h, conn, JSON.stringify({ cmd: appliedEntries }));
+		const verdicts = [...forConn(cmds.get(conn.clientId)), ...conn.pendingCmds.splice(0)];
 		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) {
@@ -285,213 +375,237 @@ const flush = (h, fin) => {
 		}
 	}
 };
-const queueApplied = (h, clientId, seq) => {
-	const list = h.pendingApplied.get(clientId);
-	if (list) list.push(seq);
-	else h.pendingApplied.set(clientId, [seq]);
+const queueApplied = (h, lane, adm) => {
+	const cmd = {
+		protocol: adm.protocol,
+		seq: adm.seq,
+		type: "applied"
+	};
+	if (lane.conn !== null) lane.conn.pendingApplied.push(cmd);
+	else {
+		const list = h.pendingApplied.get(lane.clientId);
+		if (list) list.push(cmd);
+		else h.pendingApplied.set(lane.clientId, [cmd]);
+	}
 	scheduleFlush(h);
 };
-const queueCmd = (h, clientId, cmd) => {
-	const list = h.pendingCmds.get(clientId);
-	if (list) list.push(cmd);
-	else h.pendingCmds.set(clientId, [cmd]);
+const queueCmd = (h, lane, cmd) => {
+	if (lane.conn !== null) lane.conn.pendingCmds.push(cmd);
+	else {
+		const list = h.pendingCmds.get(lane.clientId);
+		if (list) list.push(cmd);
+		else h.pendingCmds.set(lane.clientId, [cmd]);
+	}
 	scheduleFlush(h);
 };
 const notifyClientRecords = (h) => {
 	h.persistence?.onClientRecordsChange?.([...h.clients.values()].map((rec) => ({
 		id: rec.id,
-		lastSeq: admittedThrough(rec),
 		touched: rec.touched,
-		results: [...rec.results].map(([seq, entry]) => ({
-			seq,
-			ts: entry.ts,
-			cmd: entry.cmd
-		})),
+		lanes: Object.fromEntries([...rec.lanes.values()].map((lane) => [lane.protocol, {
+			lastSeq: admittedThrough(lane),
+			results: [...lane.results].map(([seq, entry]) => ({
+				seq,
+				ts: entry.ts,
+				cmd: entry.cmd
+			}))
+		}])),
 		principal: rec.principal
 	})));
 };
-const retain = (rec, cmd) => {
+const retain = (lane, cmd) => {
 	const now = Date.now();
-	rec.results.set(cmd.seq, {
+	lane.results.set(cmd.seq, {
 		ts: now,
 		cmd
 	});
-	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);
+	const newest = Math.max(...lane.results.keys());
+	for (const [seq, entry] of lane.results) if (seq !== newest && now - entry.ts > RESULT_TTL_MS) lane.results.delete(seq);
+	while (lane.results.size > RESULT_LIMIT) lane.results.delete(Math.min(...lane.results.keys()));
+};
+/** Lane watermark: the last statement admitted, settled or not. */
+const admittedThrough = (lane) => Math.max(lane.lastSeq, ...lane.inflight.keys());
+const watermark = (h, conn, protocol) => {
+	const lane = conn.selection.protocols.find((p) => p.name === protocol).record === "ephemeral" ? conn.lanes.get(protocol) : h.clients.get(conn.clientId)?.lanes.get(protocol);
+	return lane === void 0 ? 0 : admittedThrough(lane);
+};
+const laneOf = (h, conn, protocol) => {
+	const entry = conn.selection.protocols.find((p) => p.name === protocol);
+	if (entry === void 0) return violation("unsupported protocol");
+	const ephemeral = entry.record === "ephemeral";
+	const lanes = ephemeral ? conn.lanes : h.clients.get(conn.clientId).lanes;
+	let lane = lanes.get(protocol);
+	if (lane === void 0) {
+		lane = {
+			protocol,
+			clientId: conn.clientId,
+			conn: ephemeral ? conn : null,
+			lastSeq: 0,
+			results: /* @__PURE__ */ new Map(),
+			inflight: /* @__PURE__ */ new Map()
+		};
+		lanes.set(protocol, lane);
+	}
+	return lane;
+};
+const reemit = (h, lane, seq) => {
+	const cached = lane.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);
+		if (seq === Math.max(...lane.results.keys()) || Date.now() - cached.ts <= RESULT_TTL_MS) {
+			queueCmd(h, lane, cached.cmd);
 			return;
 		}
-		rec.results.delete(seq);
+		lane.results.delete(seq);
 		notifyClientRecords(h);
 	}
-	const adm = rec.inflight.get(seq);
+	const adm = lane.inflight.get(seq);
 	if (adm) {
-		if (adm.applied) queueApplied(h, rec.id, seq);
+		if (adm.applied) queueApplied(h, lane, adm);
 		return;
 	}
-	queueCmd(h, rec.id, {
+	queueCmd(h, lane, {
+		protocol: lane.protocol,
 		seq,
 		type: "expired"
 	});
 };
-const settleCmd = (h, rec, adm, cmd) => {
+const settleCmd = (h, lane, 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);
+	lane.inflight.delete(adm.seq);
+	retain(lane, cmd);
+	lane.lastSeq = Math.max(lane.lastSeq, adm.seq);
 	adm.applied = true;
-	queueCmd(h, rec.id, cmd);
-	notifyClientRecords(h);
+	queueCmd(h, lane, cmd);
+	if (lane.conn === null) notifyClientRecords(h);
 };
-const settleWire = (h, rec, adm, outcome) => settleCmd(h, rec, adm, cmdOf(adm, outcome));
+const settleWire = (h, lane, adm, outcome) => settleCmd(h, lane, adm, cmdOf(adm, outcome));
 const callerOf = (h, rec, conn) => ({
 	clientId: rec.id,
 	auth: conn.auth,
-	get context() {
-		return conn.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, {
+const rejectStatement = (h, lane, adm, message) => settleCmd(h, lane, adm, {
+	protocol: adm.protocol,
 	seq: adm.seq,
 	type: "rejected",
 	code: "invalid-params",
 	message
 });
-const admitCmd = (h, rec, conn, statement) => {
+const admitCmd = (h, lane, conn, statement) => {
+	const rec = h.clients.get(conn.clientId);
 	const adm = {
+		protocol: statement.protocol,
 		seq: statement.seq,
 		method: statement.method,
 		applied: false,
 		appliedSent: false,
 		settled: false
 	};
-	rec.inflight.set(statement.seq, adm);
-	notifyClientRecords(h);
-	if (statement.protocol !== h.protocol.name || !conn.selection.protocols.some((p) => p.name === statement.protocol)) {
-		settleCmd(h, rec, adm, {
-			seq: adm.seq,
-			type: "rejected",
-			code: "unsupported-protocol",
-			message: "command protocol was not negotiated"
-		});
-		return;
-	}
+	lane.inflight.set(statement.seq, adm);
+	if (lane.conn === null) notifyClientRecords(h);
 	if (!Array.isArray(statement.params)) {
-		rejectStatement(h, rec, adm, "params must be an array");
+		rejectStatement(h, lane, adm, "params must be an array");
 		return;
 	}
 	let params = statement.params;
 	if (statement.meta !== void 0) try {
 		params = reviveDocumentValue(params, statement.meta, { rejectUnknown: true });
 	} catch (error) {
-		rejectStatement(h, rec, adm, `invalid params: ${error.message}`);
+		rejectStatement(h, lane, adm, `invalid params: ${error.message}`);
 		return;
 	}
 	if (statement.method === "statewire/commands") {
 		if (params.length > 0) {
-			rejectStatement(h, rec, adm, "statewire/commands takes no params");
+			rejectStatement(h, lane, adm, "statewire/commands takes no params");
 			return;
 		}
 		const names = [...h.commandsHost?.methods?.() ?? [], "statewire/commands"].sort();
-		settleCmd(h, rec, adm, {
+		settleCmd(h, lane, adm, {
+			protocol: adm.protocol,
 			seq: adm.seq,
 			type: "result",
 			payload: names
 		});
 		return;
 	}
+	const method = statement.protocol === h.protocol.name ? statement.method : `${statement.protocol}/${statement.method}`;
 	h.commandsHost.submit({
-		method: statement.method,
+		method,
 		params,
 		clientId: rec.id,
 		caller: callerOf(h, rec, conn),
+		attach: conn.attach,
 		onApplied: () => {
 			if (adm.settled || adm.applied) return;
 			adm.applied = true;
-			rec.lastSeq = Math.max(rec.lastSeq, adm.seq);
-			notifyClientRecords(h);
+			lane.lastSeq = Math.max(lane.lastSeq, adm.seq);
+			if (lane.conn === null) notifyClientRecords(h);
 			scheduleFlush(h);
 		},
-		onSettle: (outcome) => settleWire(h, rec, adm, outcome)
+		onSettle: (outcome) => settleWire(h, lane, adm, outcome)
 	}).catch((error) => {
-		if (!adm.settled) settleWire(h, rec, adm, {
+		if (!adm.settled) settleWire(h, lane, adm, {
 			type: "rejected",
 			error
 		});
 	});
 };
+const refusal = (h, conn, retry) => ({
+	type: "refused",
+	syn: { syn: {
+		protocols: conn.selection.protocols.map((p) => ({
+			name: p.name,
+			seq: watermark(h, conn, p.name)
+		})),
+		...retry !== void 0 && { retry }
+	} }
+});
 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 > conn.ctxSeq);
-	const cmdNew = frame.cmd.filter((s) => s.seq > through);
-	if (ctxNew.length > 0 && ctxNew[0].seq !== conn.ctxSeq + 1 || cmdNew.length > 0 && cmdNew[0].seq !== through + 1) {
-		notifyClientRecords(h);
-		return {
-			type: "refused",
-			syn: { syn: {
-				seq: through,
-				ctxSeq: conn.ctxSeq
-			} }
-		};
+	const lanes = new Map(frame.cmd.map((s) => [s.protocol, laneOf(h, conn, s.protocol)]));
+	const through = new Map([...lanes].map(([protocol, lane]) => [protocol, admittedThrough(lane)]));
+	const fresh = frame.cmd.filter((s) => s.seq > through.get(s.protocol));
+	for (const s of frame.cmd) if (s.seq <= through.get(s.protocol)) reemit(h, lanes.get(s.protocol), s.seq);
+	let durableNew = 0;
+	for (const [protocol, lane] of lanes) {
+		const first = fresh.find((s) => s.protocol === protocol);
+		if (first === void 0) continue;
+		if (first.seq !== through.get(protocol) + 1) {
+			if (lane.conn !== null) return violation("ephemeral lane gap");
+			notifyClientRecords(h);
+			return refusal(h, conn);
+		}
+		if (lane.conn === null) durableNew += fresh.filter((s) => s.protocol === protocol).length;
 	}
-	if (cmdNew.length > 0) {
-		let hostCommandLoad = 0;
-		for (const client of h.clients.values()) hostCommandLoad += client.inflight.size;
-		if (rec.inflight.size + cmdNew.length > 256 || hostCommandLoad + cmdNew.length > h.maxInflightCommands) return {
-			type: "refused",
-			syn: { syn: {
-				seq: through,
-				ctxSeq: conn.ctxSeq,
-				retry: COMMAND_CAPACITY_RETRY_MS
-			} }
-		};
+	if (durableNew > 0) {
+		let clientLoad = 0;
+		for (const lane of rec.lanes.values()) clientLoad += lane.inflight.size;
+		let hostLoad = 0;
+		for (const lane of durableLanes(h)) hostLoad += lane.inflight.size;
+		if (clientLoad + durableNew > 256 || hostLoad + durableNew > h.maxInflightCommands) return refusal(h, conn, COMMAND_CAPACITY_RETRY_MS);
 	}
-	if ((ctxNew.length || cmdNew.length) && h.pushback) {
+	if (fresh.length > 0 && h.pushback) {
 		const retry = h.pushback();
 		if (retry !== null) {
 			if (!Number.isSafeInteger(retry) || retry < 0) throw new TypeError("pushback must return a nonnegative safe integer or null");
-			return {
-				type: "refused",
-				syn: { syn: {
-					seq: through,
-					ctxSeq: conn.ctxSeq,
-					retry
-				} }
-			};
+			return refusal(h, conn, retry);
 		}
 	}
-	let contextDocuments = conn.contextDocuments;
-	try {
-		for (const statement of ctxNew) contextDocuments = applyDocumentOps(contextDocuments, statement.ops, conn.selection.protocols, true);
-		if (frameEncoder.encode(JSON.stringify([...contextDocuments.documents])).byteLength > 65536) return violation("oversized-context");
-	} catch {
-		return violation("invalid-context");
-	}
-	conn.contextDocuments = contextDocuments;
-	conn.context = mainDocument(contextDocuments, h.protocol.name)?.value ?? null;
-	if (ctxNew.length) conn.ctxSeq = ctxNew.at(-1).seq;
-	for (const statement of cmdNew) admitCmd(h, rec, conn, statement);
-	if (cmdNew.length > 0) queueCmd(h, rec.id, {
-		seq: cmdNew.at(-1).seq,
-		dur: true
-	});
+	for (const s of fresh) admitCmd(h, lanes.get(s.protocol), conn, s);
+	for (const [protocol, lane] of lanes) {
+		const last = fresh.findLast((s) => s.protocol === protocol);
+		if (last !== void 0 && lane.conn === null) queueCmd(h, lane, {
+			protocol,
+			seq: last.seq,
+			dur: true
+		});
+	}
 	notifyClientRecords(h);
 	scheduleFlush(h);
 	return { type: "ok" };
@@ -508,31 +622,15 @@ const message = (h, conn, data) => {
 	}
 	const first = !conn.sawFrame;
 	conn.sawFrame = true;
-	let frame;
-	try {
-		frame = first ? parseInitialFrame(data).frame : parseFrame(data);
-	} catch (error) {
-		const reason = violationReason(error);
-		if (reason === null) throw error;
-		sendTo(h, conn, JSON.stringify({ fin: {
-			reason: "protocol-error",
-			message: reason
-		} }));
-		closeConn(h, conn, 1008, reason);
-		return;
-	}
-	if (frame.ctx.length === 0 && frame.cmd.length === 0) return;
 	let admission;
 	try {
+		const frame = first ? parseInitialFrame(data).frame : parseFrame(data);
+		if (frame.cmd.length === 0) return;
 		admission = admitFrame(h, conn, frame);
 	} catch (error) {
 		const reason = violationReason(error);
 		if (reason === null) throw error;
-		sendTo(h, conn, JSON.stringify({ fin: {
-			reason: "protocol-error",
-			message: reason
-		} }));
-		closeConn(h, conn, 1008, reason);
+		violate(h, conn, reason);
 		return;
 	}
 	if (admission.type === "refused") sendTo(h, conn, JSON.stringify(admission.syn));
@@ -692,13 +790,15 @@ const connectAuthorized = (h, clientId, socket, options) => {
 				pending.open = false;
 				h.pendingConns.delete(pending);
 				if (pending.timer !== null) clearTimeout(pending.timer);
-				const registration = register(h, clientId, socket, true, auth, selection);
+				let registration;
+				try {
+					registration = register(h, clientId, socket, true, auth, selection, frame);
+				} catch (error) {
+					if (violationReason(error) === null) throw error;
+					return;
+				}
 				if (registration === null) return;
 				pending.connection = registration.connection;
-				if (frame.ctx.length || frame.cmd.length) message(h, registration.conn, JSON.stringify({
-					...frame.ctx.length ? { ctx: frame.ctx } : {},
-					...frame.cmd.length ? { cmd: frame.cmd } : {}
-				}));
 				for (const data of pending.queued.splice(0)) registration.connection.message(data);
 			}).catch((error) => {
 				if (pending.open) rejectPendingAuthorization(h, pending, error);
@@ -718,20 +818,25 @@ const gcClients = (h) => {
 	const oldest = [...h.clients.values()].sort((a, b) => a.touched - b.touched);
 	for (const rec of oldest) {
 		if (excess <= 0) break;
-		if (live.has(rec.id) || rec.inflight.size > 0) continue;
+		if (live.has(rec.id) || [...rec.lanes.values()].some((lane) => lane.inflight.size > 0)) continue;
 		h.clients.delete(rec.id);
 		changed = true;
 		excess -= 1;
 	}
 	if (changed) notifyClientRecords(h);
 };
+/**
+* Attach a socket: ephemeral-lane statements of the attach frame are admitted
+* before the snapshot (their documents and answers ride the hello), durable
+* ones after it. A violation in the attach frame closes the attach and throws.
+*/
 const register = (h, clientId, socket, sawFrame = false, auth = void 0, selection = {
 	version: h.wireVersion.version,
 	protocols: [{
 		name: h.protocol.name,
 		version: h.protocol.version
 	}]
-}) => {
+}, frame = { cmd: [] }) => {
 	const refuse = (code, reason) => {
 		try {
 			socket.close(code, reason);
@@ -763,10 +868,8 @@ const register = (h, clientId, socket, sawFrame = false, auth = void 0, selectio
 	const rec = known ?? (() => {
 		const created = {
 			id: clientId,
-			lastSeq: 0,
 			touched: Date.now(),
-			results: /* @__PURE__ */ new Map(),
-			inflight: /* @__PURE__ */ new Map(),
+			lanes: /* @__PURE__ */ new Map(),
 			principal: auth
 		};
 		h.clients.set(clientId, created);
@@ -778,39 +881,71 @@ const register = (h, clientId, socket, sawFrame = false, auth = void 0, selectio
 		clientId,
 		socket,
 		open: true,
+		ready: false,
 		sawFrame,
 		lastSentAt: 0,
 		lease: null,
 		auth,
-		ctxSeq: 0,
-		context: null,
-		contextDocuments: {
-			mode: "mounted",
-			documents: /* @__PURE__ */ new Map()
-		}
+		lanes: /* @__PURE__ */ new Map(),
+		documents: /* @__PURE__ */ new Map(),
+		included: /* @__PURE__ */ new Set(),
+		view: /* @__PURE__ */ new Map(),
+		nextDoc: 1,
+		pendingApplied: [],
+		pendingCmds: [],
+		attach: void 0
 	};
+	conn.attach = attachOf(h, conn);
 	h.conns.add(conn);
 	gcClients(h);
-	notifyClientRecords(h);
 	ensureHeartbeat(h);
-	const { value, meta } = encodeDocument(h.stateHost.snapshot());
-	const hello = {
-		ops: [{
+	const isEphemeral = (s) => selection.protocols.find((p) => p.name === s.protocol)?.record === "ephemeral";
+	const early = frame.cmd.filter(isEphemeral);
+	const late = frame.cmd.filter((s) => !isEphemeral(s));
+	const admit = (statements) => {
+		if (statements.length === 0) return null;
+		try {
+			return admitFrame(h, conn, { cmd: statements });
+		} catch (error) {
+			const reason = violationReason(error);
+			if (reason === null) throw error;
+			violate(h, conn, reason);
+			throw error;
+		}
+	};
+	const earlyAdmission = admit(early);
+	if (early.length > 0) flush(h);
+	notifyClientRecords(h);
+	const ops = [];
+	if (selects(conn, h.protocol.name)) {
+		const { value, meta } = encodeDocument(h.stateHost.snapshot());
+		ops.push({
 			op: "mount",
 			protocol: h.protocol.name,
 			main: true,
 			value,
 			...meta !== void 0 && { meta }
-		}],
+		});
+	}
+	ops.push(...diffView(h, conn));
+	const answers = [...conn.pendingApplied.splice(0), ...conn.pendingCmds.splice(0)];
+	const hello = {
+		ops,
 		syn: {
-			...selection,
-			seq: admittedThrough(rec),
-			ctxSeq: 0,
+			version: selection.version,
+			protocols: selection.protocols.map((p) => ({
+				...p,
+				seq: p.record === "ephemeral" ? 0 : watermark(h, conn, p.name)
+			})),
 			...h.idleWire && { idle: true }
-		}
+		},
+		...answers.length > 0 && { cmd: answers }
 	};
-	if (!selection.protocols.some((p) => p.name === h.protocol.name)) hello.ops = [];
+	conn.ready = true;
 	sendTo(h, conn, JSON.stringify(hello));
+	if (earlyAdmission?.type === "refused") sendTo(h, conn, JSON.stringify(earlyAdmission.syn));
+	const lateAdmission = admit(late);
+	if (lateAdmission?.type === "refused") sendTo(h, conn, JSON.stringify(lateAdmission.syn));
 	return {
 		conn,
 		connection: {
@@ -837,6 +972,7 @@ const finish = (h, fin) => {
 const resume = (h) => {
 	h.disposed = false;
 	h.stateHost?.setOnOp((op) => recordOp(h, op));
+	h.stateHost?.setOnDocuments(() => markViews(h));
 };
 const suspend = (h) => {
 	h.disposed = true;
@@ -845,16 +981,22 @@ const suspend = (h) => {
 		h.heartbeatTimer = null;
 	}
 	h.stateHost?.setOnOp(null);
+	h.stateHost?.setOnDocuments(null);
 };
 const restoreClientRecords = (records = []) => new Map(records.map((record) => [record.id, {
 	id: record.id,
-	lastSeq: record.lastSeq,
 	touched: record.touched,
-	results: new Map(record.results.map(({ seq, ts, cmd }) => [seq, {
-		ts,
-		cmd
+	lanes: new Map(Object.entries(record.lanes).map(([protocol, lane]) => [protocol, {
+		protocol,
+		clientId: record.id,
+		conn: null,
+		lastSeq: lane.lastSeq,
+		results: new Map(lane.results.map(({ seq, ts, cmd }) => [seq, {
+			ts,
+			cmd
+		}])),
+		inflight: /* @__PURE__ */ new Map()
 	}])),
-	inflight: /* @__PURE__ */ new Map(),
 	principal: record.principal
 }]));
 const useSocketHost = (transport, options, persistence) => {
@@ -880,6 +1022,7 @@ const useSocketHost = (transport, options, persistence) => {
 			pendingOps: [],
 			pendingApplied: /* @__PURE__ */ new Map(),
 			pendingCmds: /* @__PURE__ */ new Map(),
+			viewsDirty: false,
 			idleWire: true,
 			finished: null,
 			disposed: false,
@@ -902,9 +1045,9 @@ const useSocketHost = (transport, options, persistence) => {
 	});
 	h.protocol = options?.protocol ?? {
 		name: "default",
-		version: "2026-09-07"
+		version: "2026-09-13"
 	};
-	h.wireVersion = options?.wireVersion ?? { version: "2026-09-07" };
+	h.wireVersion = options?.wireVersion ?? { version: "2026-09-13" };
 	setHeartbeatMs(h, options?.heartbeatIntervalMs ?? 15e3);
 	h.pushback = options?.pushback;
 	h.wsInitTimeoutMs = options?.wsInitTimeoutMs ?? 5e3;
@@ -936,9 +1079,10 @@ const useSocketHost = (transport, options, persistence) => {
 * 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 packet protocol — snapshot-first hello with `syn`,
-* statement-lane client frames under one admission law, `{cmd}` answer
-* arrays fanned out to every attach of a client id, idle edges, and `fin` on
-* finish.
+* per-protocol statement lanes under one admission law, `{cmd}` answer
+* arrays fanned out to every attach of a client id (durable lanes) or the
+* admitting attach (ephemeral lanes), per-attach document views, idle edges,
+* and `fin` on finish.
 */
 const StatewireSocketHost = (transport, options, persistence) => {
 	const SocketHostRoot = () => {