statewire 0.13.1 → 0.15.0

package/dist/host/socket.js

@@ -1,15 +1,33 @@
 import { StatewireSendError } from "../types.js";
 import { getCommandsHost, getStateHost } from "./host.js";
 import { encodeValue, reviveValue } from "../wire/meta.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";
 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 PRINCIPAL_MISMATCH_MESSAGE = "client id is bound to another principal";
+/** Structural equality over auth values: primitives, Dates, arrays, and plain
+* objects compare by value; anything else by identity. */
+const authEquals = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => authEquals(v, b[i]));
+	if (typeof a === "object" && typeof b === "object" && a !== null && b !== null && Object.getPrototypeOf(a) === Object.prototype && Object.getPrototypeOf(b) === Object.prototype) {
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		return keysA.length === keysB.length && keysA.every((key) => key in b && authEquals(a[key], b[key]));
+	}
+	return false;
+};
 const RESULT_TTL_MS = 3e4;
 const RESULT_LIMIT = 256;
 const CLIENT_RECORD_LIMIT = 1024;
+const MAX_SUBSCRIBERS = 1024;
+const SUBSCRIBER_LIMIT_MESSAGE = "stream subscriber limit reached";
+const STREAM_QUEUE_SIZE = 256;
 const violation = (reason) => {
 	throw Object.assign(new Error(reason), { name: "StatewireViolation" });
 };
@@ -30,6 +48,7 @@ const parseLane = (value) => {
 	}
 	return statements;
 };
+const frameEncoder = new TextEncoder();
 /** 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");
@@ -39,54 +58,60 @@ const contextValue = (ops) => {
 	if (!isPlainObject(value)) throw new Error("context value must be an object");
 	return value;
 };
-const parseFrameValue = (frame, first) => {
+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 !== "headers" && key !== "ctx" && key !== "cmd").sort();
+	const unknown = keys.filter((key) => key !== "ctx" && key !== "cmd").sort();
 	if (unknown.length > 0) return violation(`unknown frame key: '${unknown[0]}'`);
-	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 violation("invalid-context");
+	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)) {
+			let value;
+			try {
+				value = contextValue(statement["ops"]);
+			} catch {
+				return violation("invalid-context");
+			}
+			if (frameEncoder.encode(JSON.stringify(value)).byteLength > 65536) return violation("oversized-context");
+			ctx.push({
+				seq: statement["seq"],
+				value
+			});
+		}
 	}
 	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"] }
-		});
+	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" || !("params" in statement)) return violation("malformed statement");
+			cmd.push({
+				seq: statement["seq"],
+				method,
+				params: statement["params"],
+				...statement["meta"] !== void 0 && { meta: statement["meta"] }
+			});
+		}
 	}
 	return {
-		headers,
 		ctx,
 		cmd
 	};
 };
-const parseFrame = (raw, first) => {
+const parseFrame = (raw) => {
 	let frame;
 	try {
 		frame = JSON.parse(raw);
 	} catch {
 		return violation("malformed frame");
 	}
-	return parseFrameValue(frame, first);
+	return parseFrameValue(frame);
 };
+const frameIsOversized = (raw) => raw.length > 8388608 || frameEncoder.encode(raw).byteLength > 8388608;
 const encodePayload = (payload) => {
 	if (payload === void 0) return {};
 	const { value, meta } = encodeValue(payload);
@@ -103,6 +128,10 @@ const cmdOf = (adm, outcome) => {
 	};
 	const failure = outcome.error instanceof StatewireSendError ? outcome.error.failure : null;
 	switch (failure?.fate) {
+		case "crashed": return {
+			seq: adm.seq,
+			type: "crashed"
+		};
 		case "failed": return {
 			seq: adm.seq,
 			type: "failed",
@@ -131,6 +160,25 @@ const cmdOf = (adm, outcome) => {
 		};
 	}
 };
+const parseInitialFrame = (raw) => {
+	let value;
+	try {
+		value = JSON.parse(raw);
+	} catch {
+		return violation("malformed frame");
+	}
+	if (!isPlainObject(value)) return violation("malformed frame");
+	const { headers, ...lanes } = value;
+	if (headers === void 0) throw new Response(null, { status: 401 });
+	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: []
+		}
+	};
+};
 const scheduleFlush = (h) => {
 	if (h.flushScheduled || h.disposed) return;
 	h.flushScheduled = true;
@@ -181,6 +229,7 @@ const sendTo = (h, conn, data) => {
 		closeConn(h, conn);
 	}
 };
+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;
 	h.heartbeatTimer = setInterval(() => {
@@ -199,6 +248,7 @@ const setHeartbeatMs = (h, ms) => {
 	}
 };
 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;
 	return true;
 };
@@ -254,6 +304,21 @@ const queueCmd = (h, clientId, cmd) => {
 	else h.pendingCmds.set(clientId, [cmd]);
 	scheduleFlush(h);
 };
+const notifyClientRecords = (h) => {
+	h.persistence?.onClientRecordsChange?.([...h.clients.values()].map((rec) => ({
+		id: rec.id,
+		lastSeq: admittedThrough(rec),
+		ctxSeq: rec.ctxSeq,
+		touched: rec.touched,
+		context: rec.context,
+		results: [...rec.results].map(([seq, entry]) => ({
+			seq,
+			ts: entry.ts,
+			cmd: entry.cmd
+		})),
+		principal: rec.principal
+	})));
+};
 const retain = (rec, cmd) => {
 	const now = Date.now();
 	rec.results.set(cmd.seq, {
@@ -274,6 +339,7 @@ const reemit = (h, rec, seq) => {
 			return;
 		}
 		rec.results.delete(seq);
+		notifyClientRecords(h);
 	}
 	const adm = rec.inflight.get(seq);
 	if (adm) {
@@ -293,10 +359,12 @@ const settleCmd = (h, rec, adm, cmd) => {
 	rec.lastSeq = Math.max(rec.lastSeq, adm.seq);
 	adm.applied = true;
 	queueCmd(h, rec.id, cmd);
+	notifyClientRecords(h);
 };
 const settleWire = (h, rec, adm, outcome) => settleCmd(h, rec, adm, cmdOf(adm, outcome));
-const callerOf = (h, rec) => ({
+const callerOf = (h, rec, auth) => ({
 	clientId: rec.id,
+	auth,
 	get context() {
 		return rec.context;
 	},
@@ -312,7 +380,7 @@ const rejectStatement = (h, rec, adm, message) => settleCmd(h, rec, adm, {
 	code: "invalid-params",
 	message
 });
-const admitCmd = (h, rec, statement) => {
+const admitCmd = (h, rec, statement, auth) => {
 	const adm = {
 		seq: statement.seq,
 		method: statement.method,
@@ -321,6 +389,7 @@ const admitCmd = (h, rec, statement) => {
 		settled: false
 	};
 	rec.inflight.set(statement.seq, adm);
+	notifyClientRecords(h);
 	if (!Array.isArray(statement.params)) {
 		rejectStatement(h, rec, adm, "params must be an array");
 		return;
@@ -349,11 +418,12 @@ const admitCmd = (h, rec, statement) => {
 		method: statement.method,
 		params,
 		clientId: rec.id,
-		caller: callerOf(h, rec),
+		caller: callerOf(h, rec, auth),
 		onApplied: () => {
 			if (adm.settled || adm.applied) return;
 			adm.applied = true;
 			rec.lastSeq = Math.max(rec.lastSeq, adm.seq);
+			notifyClientRecords(h);
 			scheduleFlush(h);
 		},
 		onSettle: (outcome) => settleWire(h, rec, adm, outcome)
@@ -364,62 +434,271 @@ const admitCmd = (h, rec, statement) => {
 		});
 	});
 };
-const admitFrame = (h, rec, frame) => {
+const admitFrame = (h, rec, frame, auth) => {
 	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) return {
-		type: "refused",
-		syn: { syn: {
-			seq: through,
-			ctxSeq: rec.ctxSeq
-		} }
-	};
+	if (ctxNew.length > 0 && ctxNew[0].seq !== rec.ctxSeq + 1 || cmdNew.length > 0 && cmdNew[0].seq !== through + 1) {
+		notifyClientRecords(h);
+		return {
+			type: "refused",
+			syn: { syn: {
+				seq: through,
+				ctxSeq: rec.ctxSeq
+			} }
+		};
+	}
+	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: rec.ctxSeq,
+				retry: COMMAND_CAPACITY_RETRY_MS
+			} }
+		};
+	}
+	if ((ctxNew.length || cmdNew.length) && 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: rec.ctxSeq,
+					retry
+				} }
+			};
+		}
+	}
 	for (const statement of ctxNew) {
 		rec.context = statement.value;
 		rec.ctxSeq = statement.seq;
 	}
-	for (const statement of cmdNew) admitCmd(h, rec, statement);
+	for (const statement of cmdNew) admitCmd(h, rec, statement, auth);
 	if (cmdNew.length > 0) queueCmd(h, rec.id, {
 		seq: cmdNew.at(-1).seq,
 		dur: true
 	});
+	notifyClientRecords(h);
 	scheduleFlush(h);
 	return { type: "ok" };
 };
 const message = (h, conn, data) => {
 	if (!conn.open || h.disposed || h.finished !== null) return;
+	if (frameIsOversized(data)) {
+		sendTo(h, conn, JSON.stringify({ fin: {
+			reason: "protocol-error",
+			message: "frame too large"
+		} }));
+		closeConn(h, conn, 1009, "frame too large");
+		return;
+	}
 	const first = !conn.sawFrame;
 	conn.sawFrame = true;
 	let frame;
 	try {
-		frame = parseFrame(data, first);
+		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;
 	const rec = h.clients.get(conn.clientId);
-	const admission = admitFrame(h, rec, frame);
+	const admission = admitFrame(h, rec, frame, conn.auth);
 	if (admission.type === "refused") sendTo(h, conn, JSON.stringify(admission.syn));
 };
+const closePending = (h, pending, code, reason) => {
+	if (!pending.open) return;
+	pending.open = false;
+	h.pendingConns.delete(pending);
+	if (pending.timer !== null) clearTimeout(pending.timer);
+	try {
+		pending.socket.close(code, reason);
+	} catch {}
+};
+const sendPending = (pending, data) => {
+	if (!pending.open) return false;
+	try {
+		pending.socket.send(data);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const refuseSubscriberLimit = (socket) => {
+	try {
+		socket.send(JSON.stringify({ fin: {
+			reason: "reconnect",
+			code: "overloaded",
+			message: SUBSCRIBER_LIMIT_MESSAGE
+		} }));
+	} catch {}
+	try {
+		socket.close(1013, SUBSCRIBER_LIMIT_MESSAGE);
+	} catch {}
+	return null;
+};
+const rejectPendingAuthorization = (h, pending, error) => {
+	const response = error instanceof Response ? error : null;
+	const unauthorized = response?.status === 401 || response?.status === 403;
+	const status = response?.status;
+	const message = unauthorized ? "unauthorized" : response?.statusText || (status === void 0 ? "authorization failed" : `HTTP ${status}`);
+	sendPending(pending, JSON.stringify({ fin: {
+		reason: status === 403 ? "forbidden" : unauthorized ? "unauthorized" : "error",
+		message,
+		...status !== void 0 && { status }
+	} }));
+	closePending(h, pending, unauthorized ? 1008 : 1011, message);
+};
+const normalizedHeaders = (headers) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of Object.keys(headers)) {
+		const key = name.toLowerCase();
+		if (seen.has(key)) throw new TypeError("duplicate header name");
+		seen.add(key);
+	}
+	return Object.fromEntries(new Headers(headers));
+};
+const connectAuthorized = (h, clientId, socket, options) => {
+	const authorize = h.authorize;
+	if (options.authorized === true) return register(h, clientId, socket, options.authorized === true, options.auth)?.connection ?? null;
+	const refuse = (code, reason) => {
+		try {
+			socket.close(code, reason);
+		} catch {}
+		return null;
+	};
+	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 pending = {
+		socket,
+		open: true,
+		authorizing: false,
+		queued: [],
+		timer: null,
+		connection: null
+	};
+	h.pendingConns.add(pending);
+	pending.timer = setTimeout(() => rejectPendingAuthorization(h, pending, new Response(null, { status: 401 })), h.wsInitTimeoutMs);
+	pending.timer.unref?.();
+	return {
+		clientId,
+		message: (data) => {
+			if (pending.connection !== null) {
+				pending.connection.message(data);
+				return;
+			}
+			if (!pending.open || h.disposed || h.finished !== null) return;
+			if (frameIsOversized(data)) {
+				sendPending(pending, JSON.stringify({ fin: {
+					reason: "protocol-error",
+					message: "frame too large"
+				} }));
+				closePending(h, pending, 1009, "frame too large");
+				return;
+			}
+			if (pending.authorizing) {
+				pending.queued.push(data);
+				return;
+			}
+			let initial;
+			try {
+				initial = parseInitialFrame(data);
+			} catch (error) {
+				if (error instanceof Response) {
+					rejectPendingAuthorization(h, pending, error);
+					return;
+				}
+				const reason = violationReason(error);
+				if (reason === null) throw error;
+				sendPending(pending, JSON.stringify({ fin: {
+					reason: "protocol-error",
+					message: reason
+				} }));
+				closePending(h, pending, 1008, reason);
+				return;
+			}
+			const frame = initial.frame;
+			let headers;
+			try {
+				headers = normalizedHeaders(initial.headers);
+			} catch {
+				sendPending(pending, JSON.stringify({ fin: {
+					reason: "protocol-error",
+					message: "malformed headers"
+				} }));
+				closePending(h, pending, 1008, "malformed headers");
+				return;
+			}
+			if (atSubscriberLimit(h)) {
+				sendPending(pending, JSON.stringify({ fin: {
+					reason: "reconnect",
+					code: "overloaded",
+					message: SUBSCRIBER_LIMIT_MESSAGE
+				} }));
+				closePending(h, pending, 1013, SUBSCRIBER_LIMIT_MESSAGE);
+				return;
+			}
+			pending.authorizing = true;
+			Promise.resolve().then(() => authorize?.({ headers })).then((auth) => {
+				if (!pending.open || h.disposed || h.finished !== null) return;
+				options.onAuthorized?.(auth);
+				pending.open = false;
+				h.pendingConns.delete(pending);
+				if (pending.timer !== null) clearTimeout(pending.timer);
+				const registration = register(h, clientId, socket, true, auth);
+				if (registration === null) return;
+				pending.connection = registration.connection;
+				if (frame.ctx.length || frame.cmd.length) {
+					const admission = admitFrame(h, registration.rec, frame, auth);
+					if (admission.type === "refused") sendTo(h, registration.conn, JSON.stringify(admission.syn));
+				}
+				for (const data of pending.queued.splice(0)) registration.connection.message(data);
+			}).catch((error) => {
+				if (pending.open) rejectPendingAuthorization(h, pending, error);
+			});
+		},
+		close: () => {
+			if (pending.connection !== null) pending.connection.close();
+			else closePending(h, pending);
+		}
+	};
+};
 const gcClients = (h) => {
 	let excess = h.clients.size - h.clientRecordLimit;
 	if (excess <= 0) return;
+	let changed = false;
 	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 (excess <= 0) break;
 		if (live.has(rec.id) || rec.inflight.size > 0) continue;
 		h.clients.delete(rec.id);
+		changed = true;
 		excess -= 1;
 	}
+	if (changed) notifyClientRecords(h);
 };
-const register = (h, clientId, socket) => {
+const register = (h, clientId, socket, sawFrame = false, auth = void 0) => {
 	const refuse = (code, reason) => {
 		try {
 			socket.close(code, reason);
@@ -436,7 +715,19 @@ const register = (h, clientId, socket) => {
 		refuse(1e3, "finished");
 		return null;
 	}
-	const rec = h.clients.has(clientId) ? h.clients.get(clientId) : (() => {
+	if (atSubscriberLimit(h)) return refuseSubscriberLimit(socket);
+	const known = h.clients.get(clientId);
+	if (known !== void 0 && !authEquals(known.principal, auth)) {
+		try {
+			socket.send(JSON.stringify({ fin: {
+				reason: "forbidden",
+				message: PRINCIPAL_MISMATCH_MESSAGE,
+				status: 403
+			} }));
+		} catch {}
+		return refuse(1008, PRINCIPAL_MISMATCH_MESSAGE);
+	}
+	const rec = known ?? (() => {
 		const created = {
 			id: clientId,
 			lastSeq: 0,
@@ -444,7 +735,8 @@ const register = (h, clientId, socket) => {
 			touched: Date.now(),
 			context: null,
 			results: /* @__PURE__ */ new Map(),
-			inflight: /* @__PURE__ */ new Map()
+			inflight: /* @__PURE__ */ new Map(),
+			principal: auth
 		};
 		h.clients.set(clientId, created);
 		return created;
@@ -454,12 +746,14 @@ const register = (h, clientId, socket) => {
 		clientId,
 		socket,
 		open: true,
-		sawFrame: false,
+		sawFrame,
 		lastSentAt: 0,
-		lease: null
+		lease: null,
+		auth
 	};
 	h.conns.add(conn);
 	gcClients(h);
+	notifyClientRecords(h);
 	ensureHeartbeat(h);
 	const { value, meta } = encodeValue(h.stateHost.snapshot());
 	const hello = {
@@ -486,12 +780,18 @@ const register = (h, clientId, socket) => {
 		}
 	};
 };
-const connect = (h, clientId, socket) => {
-	return register(h, clientId, socket)?.connection ?? null;
+const connect = (h, clientId, socket, options = {}) => {
+	return connectAuthorized(h, clientId, socket, options);
 };
 const finish = (h, fin) => {
+	if (fin.retry !== void 0 && (!Number.isSafeInteger(fin.retry) || fin.retry < 0)) throw new Error("statewire: retry must be a nonnegative safe integer");
 	if (h.finished !== null || h.disposed) return;
+	h.commandsHost?.abort?.();
 	h.finished = fin;
+	for (const pending of [...h.pendingConns]) {
+		sendPending(pending, JSON.stringify({ fin }));
+		closePending(h, pending, 1e3, fin.reason);
+	}
 	flush(h, fin);
 };
 const resume = (h) => {
@@ -506,15 +806,29 @@ const suspend = (h) => {
 	}
 	h.stateHost?.setOnOp(null);
 };
-const useSocketHost = (transport, options) => {
+const restoreClientRecords = (records = []) => new Map(records.map((record) => [record.id, {
+	...record,
+	results: new Map(record.results.map(({ seq, ts, cmd }) => [seq, {
+		ts,
+		cmd
+	}])),
+	inflight: /* @__PURE__ */ new Map()
+}]));
+const useSocketHost = (transport, options, persistence) => {
 	const [h] = useState(() => {
 		const host = {
 			heartbeatMs: 15e3,
+			wsInitTimeoutMs: 5e3,
+			maxSubscribers: MAX_SUBSCRIBERS,
+			maxInflightCommands: MAX_INFLIGHT_COMMANDS_PER_HOST,
+			streamQueueSize: STREAM_QUEUE_SIZE,
 			clientRecordLimit: CLIENT_RECORD_LIMIT,
 			finOnIdle: false,
+			pushback: void 0,
 			authorize: void 0,
-			clients: /* @__PURE__ */ new Map(),
+			clients: restoreClientRecords(persistence?.clientRecords),
 			conns: /* @__PURE__ */ new Set(),
+			pendingConns: /* @__PURE__ */ new Set(),
 			pendingOps: [],
 			pendingApplied: /* @__PURE__ */ new Map(),
 			pendingCmds: /* @__PURE__ */ new Map(),
@@ -526,11 +840,12 @@ const useSocketHost = (transport, options) => {
 			stateHost: null,
 			commandsHost: null,
 			current: null,
+			persistence,
 			post: createMacrotaskPoster(() => {
 				host.flushScheduled = false;
 				flush(host);
 			}),
-			connect: (clientId, socket) => connect(host, clientId, socket),
+			connect: (clientId, socket, connectOptions) => connect(host, clientId, socket, connectOptions),
 			finish: (fin) => finish(host, fin),
 			stream: (request) => stream(host, request),
 			frames: (request_0) => frames(host, request_0)
@@ -538,6 +853,17 @@ const useSocketHost = (transport, options) => {
 		return host;
 	});
 	setHeartbeatMs(h, options?.heartbeatIntervalMs ?? 15e3);
+	h.pushback = options?.pushback;
+	h.wsInitTimeoutMs = options?.wsInitTimeoutMs ?? 5e3;
+	const maxSubscribers = options?.maxSubscribers === void 0 ? MAX_SUBSCRIBERS : options.maxSubscribers;
+	if (!Number.isInteger(maxSubscribers) || maxSubscribers < 1) throw new TypeError("maxSubscribers must be a positive integer");
+	h.maxSubscribers = maxSubscribers;
+	const maxInflightCommands = options?.maxInflightCommands === void 0 ? MAX_INFLIGHT_COMMANDS_PER_HOST : options.maxInflightCommands;
+	if (!Number.isInteger(maxInflightCommands) || maxInflightCommands < 1) throw new TypeError("maxInflightCommands must be a positive integer");
+	h.maxInflightCommands = maxInflightCommands;
+	const streamQueueSize = options?.streamQueueSize === void 0 ? STREAM_QUEUE_SIZE : options.streamQueueSize;
+	if (!Number.isInteger(streamQueueSize) || streamQueueSize < 1) throw new TypeError("streamQueueSize must be a positive integer");
+	h.streamQueueSize = streamQueueSize;
 	h.clientRecordLimit = options?.clientRecordLimit ?? CLIENT_RECORD_LIMIT;
 	h.finOnIdle = options?.finOnIdle ?? false;
 	h.authorize = options?.authorize;
@@ -545,6 +871,7 @@ const useSocketHost = (transport, options) => {
 	attach(h, value);
 	useEffect(() => {
 		attach(h, value);
+		scheduleFlush(h);
 	});
 	useEffect(() => {
 		resume(h);
@@ -560,26 +887,29 @@ const useSocketHost = (transport, options) => {
 * arrays fanned out to every attach of a client id, idle edges, and `fin` on
 * finish.
 */
-const StatewireSocketHost = (transport, options) => {
+const StatewireSocketHost = (transport, options, persistence) => {
 	const SocketHostRoot = () => {
-		return useSocketHost(transport, options);
+		return useSocketHost(transport, options, persistence);
 	};
 	const root = createTapRoot(SocketHostRoot);
 	let disposed = false;
 	return {
-		connect: (clientId, socket) => flushTapSync(() => root.getValue().connect(clientId, socket)),
+		connect: (clientId, socket, connectOptions) => flushTapSync(() => root.getValue().connect(clientId, socket, connectOptions)),
 		stream: (request) => flushTapSync(() => root.getValue().stream(request)),
 		frames: (request) => flushTapSync(() => root.getValue().frames(request)),
 		finish: (fin) => flushTapSync(() => root.getValue().finish(fin)),
 		dispose: () => {
 			if (disposed) return;
 			disposed = true;
-			flushTapSync(() => root.getValue().finish({ reason: "evicted" }));
+			flushTapSync(() => root.getValue().finish({
+				reason: "reconnect",
+				code: "evicted"
+			}));
 			root.unmount();
 		}
 	};
 };
 //#endregion
-export { CLIENT_ID_RE, StatewireSocketHost, admitFrame, closeConn, flush, parseFrame, parseFrameValue, register, sendTo };
+export { CLIENT_ID_RE, PRINCIPAL_MISMATCH_MESSAGE, SUBSCRIBER_LIMIT_MESSAGE, StatewireSocketHost, admitFrame, atSubscriberLimit, authEquals, closeConn, flush, parseFrame, parseFrameValue, register, sendTo };
 
 //# sourceMappingURL=socket.js.map