@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/serverSessionConfig.js

@@ -0,0 +1,42 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { RoomBaselineRing as n } from "./baselines.js";
+// src/serverSessionConfig.ts
+function r(r, i) {
+	let a = {
+		maxPendingWrites: 16,
+		maxFramesPerSecond: 128,
+		baselineCapacity: 8,
+		maxBaselineAgeMs: 3e3,
+		helloTimeoutMs: 5e3,
+		authTimeoutMs: 5e3,
+		idleTimeoutMs: 3e4
+	}, o = t(r, Object.keys(a), []), s = { ...a };
+	for (let e of Object.keys(a)) Object.defineProperty(s, e, {
+		value: o[e] ?? a[e],
+		enumerable: !0
+	});
+	if (![
+		s.helloTimeoutMs,
+		s.authTimeoutMs,
+		s.idleTimeoutMs
+	].every((e) => Number.isSafeInteger(e) && e > 0)) throw new e({
+		room: i,
+		detail: "Session deadlines must be positive safe integers"
+	});
+	if (!Number.isSafeInteger(s.maxPendingWrites) || s.maxPendingWrites < 1) throw new e({
+		room: i,
+		detail: "Pending transport writes must be bounded"
+	});
+	if (!Number.isSafeInteger(s.maxFramesPerSecond) || s.maxFramesPerSecond < 1) throw new e({
+		room: i,
+		detail: "Incoming frame rate must be bounded"
+	});
+	let c = new n(s.baselineCapacity, s.maxBaselineAgeMs);
+	return Object.freeze({
+		...s,
+		baselineCapacity: c.capacity,
+		maxBaselineAgeMs: c.maxBaselineAgeMs
+	});
+}
+export { r as captureRoomServerSessionLimits };

package/dist/sessionAdmission.js

@@ -0,0 +1,52 @@
+import { ProtocolError as e } from "./errors.js";
+import { Effect as t } from "effect";
+// src/sessionAdmission.ts
+var n = (t) => {
+	let n = () => {
+		throw new e({ detail: "Room session admission evidence is invalid" });
+	};
+	if (!t || typeof t != "object" || Object.getPrototypeOf(t) !== Object.prototype) return n();
+	let r = [
+		"tenantId",
+		"subjectId",
+		"roomId",
+		"sessionId",
+		"epoch",
+		"role",
+		"nonce",
+		"credentialDigest"
+	], i = Object.getOwnPropertyDescriptors(t);
+	if (Reflect.ownKeys(t).length !== r.length || r.some((e) => !i[e] || !("value" in i[e]))) return n();
+	let a = Object.fromEntries(r.map((e) => [e, i[e].value])), o = (e) => {
+		let t = a[e];
+		return typeof t != "string" || !t.trim() || t.length > 191 || /[\u0000-\u001f\u007f]/.test(t) ? n() : t;
+	};
+	return typeof a.epoch != "number" || !Number.isSafeInteger(a.epoch) || a.epoch < 0 || a.epoch > 2147483647 || a.role !== "player" || typeof a.nonce != "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(a.nonce) || typeof a.credentialDigest != "string" || !/^[a-f0-9]{64}$/.test(a.credentialDigest) ? n() : Object.freeze({
+		tenantId: o("tenantId"),
+		subjectId: o("subjectId"),
+		roomId: o("roomId"),
+		sessionId: o("sessionId"),
+		epoch: a.epoch,
+		role: "player",
+		nonce: a.nonce,
+		credentialDigest: a.credentialDigest
+	});
+}, r = (r) => {
+	if (typeof r != "function") throw new e({ detail: "Actual Room session admission reader is required" });
+	return (i) => {
+		let a;
+		try {
+			a = n(i);
+		} catch {
+			return t.fail(new e({ detail: "Invalid Room session admission confirmation" }));
+		}
+		return t.try({
+			try: () => {
+				let t = n(r(a.roomId, a.sessionId));
+				if (Object.keys(a).some((e) => a[e] !== t[e])) throw new e({ detail: "Room session admission no longer matches the actual target" });
+			},
+			catch: () => new e({ detail: "Actual admitted Room target session is unavailable" })
+		});
+	};
+};
+export { n as captureRoomSessionAdmissionEvidence, r as confirmRoomSessionAdmission };

package/dist/sidecarAdmission.js

@@ -0,0 +1,102 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { captureRoomTransportClock as n, captureRoomTransportDataMethod as r } from "./transportAuthoring.js";
+import { decodeRoomFrame as i } from "./wire.js";
+import { Result as a } from "effect";
+// src/sidecarAdmission.ts
+var o = (o, s) => {
+	let c = [
+		"verificationTimeoutMs",
+		"maxHelloBytes",
+		"clock",
+		"ready"
+	];
+	if (!s || Object.getPrototypeOf(s) !== Object.prototype || Reflect.ownKeys(s).length !== c.length || c.some((e) => {
+		let t = Object.getOwnPropertyDescriptor(s, e);
+		return !t?.enumerable || !("value" in t);
+	}) || !Number.isSafeInteger(s.verificationTimeoutMs) || s.verificationTimeoutMs < 1 || s.verificationTimeoutMs > 3e5 || !Number.isSafeInteger(s.maxHelloBytes) || s.maxHelloBytes < 1 || s.maxHelloBytes > 16777216) throw new t({
+		room: "sidecar-admission",
+		detail: "Sidecar admission requires complete captured host policy and bounded Hello"
+	});
+	let l = r(o, "verifySeat", "Sidecar admission requires actual host seat verification"), u = r(o, "connect", "Sidecar admission requires actual host session construction"), d = r(s, "ready", "Sidecar admission requires actual host readiness"), f = n(s.clock).now, p = s.verificationTimeoutMs, m = s.maxHelloBytes;
+	return (t) => {
+		if (t.name !== "wt" || !(t.signal instanceof AbortSignal) || t.signal.aborted) throw new e({ detail: "Sidecar admission requires a current actual native transport" });
+		let n = r(t.reliable, "onFrame", "Sidecar admission requires actual reliable ingress"), o = r(t, "close", "Sidecar admission requires actual transport withdrawal"), s = new AbortController(), c = "waiting", h, g, _, v, y = !1, b = !1, x = -1, S, C = () => {
+			let t = f();
+			if (!Number.isFinite(t) || t < 0 || t < x) throw new e({ detail: "Sidecar admission clock regressed" });
+			return x = t, t;
+		}, w = C() + p, T, E = () => {
+			T !== void 0 && (clearTimeout(T), T = void 0);
+		}, D = () => {
+			v &&= (v(), void 0);
+		}, O = (e, t, n = !1) => {
+			if (c !== "closed" || n) {
+				S ??= Object.freeze({
+					code: e,
+					detail: t
+				}), c = "closed", E(), s.abort();
+				try {
+					D(), y = !1;
+				} catch {
+					y = !0;
+				}
+				try {
+					o(S.code, S.detail), b = !1;
+				} catch {
+					b = !0;
+				}
+			}
+		}, k = () => {
+			O(1e3, "Room connection ended");
+		}, A = () => {
+			if (_) return _;
+			O(1e3, "Room connection ended", !0), t.signal.removeEventListener("abort", k);
+			let n = (async () => {
+				if (g && await g, h && (await Promise.allSettled([h.close("reconnecting"), h.settled()])).some((e) => e.status === "rejected")) throw new e({ detail: "Sidecar accepted Room session release remains incomplete" });
+				if (y) throw new e({ detail: "Sidecar Hello listener release remains incomplete" });
+				if (b) throw new e({ detail: "Sidecar native connection withdrawal remains incomplete" });
+			})();
+			return _ = n, n.catch(() => {
+				_ === n && (_ = void 0);
+			}), n;
+		};
+		t.signal.addEventListener("abort", k, { once: !0 }), T = setTimeout(() => O(1008, "Room Hello verification timed out"), p);
+		try {
+			let r = n((e) => {
+				if (c !== "closed") {
+					if (c !== "waiting") O(1008, "Room Hello verification pending");
+					else try {
+						if (d() !== !0 || C() >= w || !(e instanceof Uint8Array) || e.byteLength > m) {
+							O(1008, "Room Hello refused");
+							return;
+						}
+						let n = e.slice(), r = i(n);
+						if (a.isFailure(r) || r.success.kind !== "Hello") {
+							O(1008, "Room Hello refused");
+							return;
+						}
+						let o = r.success.token.slice();
+						c = "verifying", g = Promise.resolve().then(async () => {
+							try {
+								let e = await l(o, s.signal);
+								if (c !== "verifying" || s.signal.aborted || t.signal.aborted || d() !== !0 || C() >= w) {
+									O(1008, "Room Hello refused");
+									return;
+								}
+								D(), h = u(e, t, n), c = "admitted", E();
+							} catch {
+								O(1008, "Room Hello refused");
+							}
+						}), g.catch(() => {});
+					} catch {
+						O(1008, "Room Hello refused");
+					}
+				}
+			});
+			if (typeof r != "function") throw new e({ detail: "Sidecar reliable listener did not return actual withdrawal" });
+			return v = r, c === "closed" && D(), t.signal.aborted && k(), Object.freeze({ closeAsync: A });
+		} catch {
+			throw O(1011, "Room connection setup failed"), t.signal.removeEventListener("abort", k), new e({ detail: "Sidecar first-Hello listener could not be acquired" });
+		}
+	};
+};
+export { o as roomSidecarAdmission };

package/dist/sidecarConfig.js

@@ -0,0 +1,115 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { RoomSidecarWire as t } from "./sidecarWire.js";
+import { isAbsolute as n, resolve as r } from "node:path";
+import { isIP as i } from "node:net";
+// src/sidecarConfig.ts
+function a() {
+	throw new e({
+		room: "sidecar-config",
+		detail: "Native sidecar configuration requires explicit canonical selections and matching bounded budgets"
+	});
+}
+var o = (e, t, n = []) => {
+	let r = e ? n.filter((t) => Object.hasOwn(e, t)) : [];
+	(!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== t.length + r.length || [...t, ...r].some((t) => {
+		let n = Object.getOwnPropertyDescriptor(e, t);
+		return !n?.enumerable || !("value" in n);
+	})) && a();
+}, s = (e, t) => typeof e != "number" || !Number.isSafeInteger(e) || e < 1 || e > t ? a() : e, c = (e) => typeof e != "string" || !n(e) || r(e) !== e || e.includes("\0") ? a() : e, l = (e) => {
+	o(e, [
+		"udpAddress",
+		"requestAuthority",
+		"path",
+		"origins",
+		"certificateFile",
+		"privateKeyFile",
+		"maxTotalPendingBytes",
+		"maxTotalPendingFrames",
+		"admissionTimeoutMs",
+		"writeTimeoutMs",
+		"idleTimeoutMs"
+	], ["loopbackOrigins"]);
+	let t = e.loopbackOrigins ?? !1;
+	typeof t != "boolean" && a(), (typeof e.udpAddress != "string" || typeof e.requestAuthority != "string" || typeof e.path != "string") && a();
+	let n = /^(?:\[([^\]]+)\]|([^:]+)):(\d+)$/.exec(e.udpAddress);
+	n || a();
+	let r = n[1] ?? n[2], l = i(r), u = Number(n[3]);
+	(!l || !Number.isSafeInteger(u) || u < 1024 || u > 65535 || String(u) !== n[3] || r.includes("%") || r === "0.0.0.0" || r === "::" || l === 4 && Number(r.split(".")[0]) >= 224 && Number(r.split(".")[0]) <= 239 || l === 6 && r.toLowerCase().startsWith("ff")) && a();
+	let d;
+	try {
+		d = new URL("https://" + e.requestAuthority + e.path);
+	} catch {
+		return a();
+	}
+	(!e.requestAuthority || e.requestAuthority.length > 253 || !e.path.startsWith("/") || e.path.length > 512 || d.host !== e.requestAuthority || d.pathname !== e.path || d.username || d.password || d.search || d.hash || e.path.includes("?") || e.path.includes("#")) && a();
+	let f = e.origins;
+	(!Array.isArray(f) || f.length < 1 && !t || f.length > 64 || Reflect.ownKeys(f).length !== f.length + 1) && a();
+	let p = [];
+	for (let e = 0; e < f.length; e++) {
+		let t = Object.getOwnPropertyDescriptor(f, String(e));
+		(!t || !("value" in t) || typeof t.value != "string" || t.value.length > 4096) && a();
+		let n;
+		try {
+			n = new URL(t.value);
+		} catch {
+			return a();
+		}
+		(n.protocol !== "https:" || !n.host || n.username || n.password || n.pathname !== "/" || n.search || n.hash || t.value !== "https://" + n.host || p.includes(t.value)) && a(), p.push(t.value);
+	}
+	return Object.freeze({
+		udpAddress: e.udpAddress,
+		requestAuthority: e.requestAuthority,
+		path: e.path,
+		origins: Object.freeze(p),
+		...t ? { loopbackOrigins: t } : {},
+		certificateFile: c(e.certificateFile),
+		privateKeyFile: c(e.privateKeyFile),
+		maxTotalPendingBytes: s(e.maxTotalPendingBytes, 33554432),
+		maxTotalPendingFrames: s(e.maxTotalPendingFrames, 65536),
+		admissionTimeoutMs: s(e.admissionTimeoutMs, 3e5),
+		writeTimeoutMs: s(e.writeTimeoutMs, 3e5),
+		idleTimeoutMs: s(e.idleTimeoutMs, 3e5)
+	});
+}, u = (e, n, r) => {
+	let i = l(e);
+	o(n, [
+		"bootId",
+		"wire",
+		"maxConnections",
+		"maxRetiredConnections",
+		"maxListeners",
+		"maxPendingWrites",
+		"maxPendingEnvelopes",
+		"maxQueuedEnvelopeBytes",
+		"ackTimeoutMs",
+		"clock",
+		"bindConnection"
+	]), new t(n.wire), n.bootId instanceof Uint8Array && n.bootId.byteLength === 16 || a();
+	let u = s(n.maxConnections, 65536), d = s(n.maxRetiredConnections, 1048576), f = s(n.maxPendingWrites, 4096);
+	(d < u || n.wire.maxQueuedBytes < n.wire.maxFrameBytes + 4 || n.wire.maxDatagramBytes > n.wire.maxFrameBytes || i.maxTotalPendingBytes < Math.max(n.wire.maxFrameBytes + 27, n.wire.maxReasonBytes + 24, 30) + 4 || i.writeTimeoutMs > s(n.ackTimeoutMs, 3e5)) && a(), c(r), new TextEncoder().encode(r).byteLength > 100 && a();
+	let p = {
+		bootId: Buffer.from(n.bootId).toString("hex"),
+		ipcPath: r,
+		udpAddress: i.udpAddress,
+		requestAuthority: i.requestAuthority,
+		path: i.path,
+		origins: i.origins,
+		loopbackOrigins: i.loopbackOrigins ?? !1,
+		certificateFile: i.certificateFile,
+		privateKeyFile: i.privateKeyFile,
+		maxConnections: u,
+		maxRetiredConnections: d,
+		maxFrameBytes: n.wire.maxFrameBytes,
+		maxQueuedBytes: n.wire.maxQueuedBytes,
+		maxPendingWrites: f,
+		maxTotalPendingBytes: i.maxTotalPendingBytes,
+		maxTotalPendingFrames: i.maxTotalPendingFrames,
+		maxDatagramBytes: n.wire.maxDatagramBytes,
+		maxReasonBytes: n.wire.maxReasonBytes,
+		admissionTimeoutMs: i.admissionTimeoutMs,
+		writeTimeoutMs: i.writeTimeoutMs,
+		idleTimeoutMs: i.idleTimeoutMs
+	}, m = new TextEncoder().encode(JSON.stringify(p) + "\n");
+	return m.byteLength > 65536 && a(), m;
+};
+export { l as captureRoomSidecarNativeConfig, u as encodeRoomSidecarNativeConfig };

package/dist/sidecarConfigPublication.js

@@ -0,0 +1,63 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { encodeRoomSidecarNativeConfig as n } from "./sidecarConfig.js";
+import { dirname as r, join as i } from "node:path";
+import { constants as a } from "node:fs";
+import { lstat as o, open as s, realpath as c } from "node:fs/promises";
+// src/sidecarConfigPublication.ts
+var l = class extends Error {
+	cleanup;
+	constructor(e) {
+		super("Room sidecar private configuration publication or owned descriptor cleanup remains incomplete"), this.cleanup = e;
+	}
+}, u = async (u, d, f, p) => {
+	let m = n(u, d, f);
+	if (!(p instanceof AbortSignal) || p.aborted || typeof process.getuid != "function") throw new t({
+		room: "sidecar-config",
+		detail: "Native configuration publication requires an actual current owned lifetime"
+	});
+	let h = r(f), g = i(h, "native.json"), _ = BigInt(process.getuid()), v, y, b, x = () => {
+		if (b) return b;
+		let t = (async () => {
+			let t = [];
+			if (y) try {
+				await y.close(), y = void 0;
+			} catch (e) {
+				t.push(e);
+			}
+			if (v) try {
+				await v.close(), v = void 0;
+			} catch (e) {
+				t.push(e);
+			}
+			if (t.length) throw new e({ detail: "Sidecar private configuration descriptor cleanup remains incomplete" });
+		})();
+		return b = t, t.catch(() => {
+			b === t && (b = void 0);
+		}), t;
+	};
+	try {
+		let t = await o(h, { bigint: !0 });
+		if (!t.isDirectory() || t.uid !== _ || (t.mode & 511n) != 448n || await c(h) !== h || p.aborted) throw new e({ detail: "Sidecar private configuration directory admission refused" });
+		v = await s(h, a.O_RDONLY | a.O_DIRECTORY | a.O_NOFOLLOW);
+		let n = await v.stat({ bigint: !0 });
+		if (!n.isDirectory() || n.uid !== _ || (n.mode & 511n) != 448n || n.dev !== t.dev || n.ino !== t.ino || p.aborted) throw new e({ detail: "Sidecar private configuration directory identity changed" });
+		y = await s(g, a.O_WRONLY | a.O_CREAT | a.O_EXCL | a.O_NOFOLLOW, 384);
+		let r = await y.stat({ bigint: !0 });
+		if (!r.isFile() || r.uid !== _ || (r.mode & 511n) != 384n || r.nlink !== 1n || p.aborted) throw new e({ detail: "Sidecar private configuration file admission refused" });
+		await y.writeFile(m), await y.sync(), await v.sync();
+		let i = await o(g, { bigint: !0 }), l = await o(h, { bigint: !0 });
+		if (!i.isFile() || i.uid !== _ || (i.mode & 511n) != 384n || i.nlink !== 1n || i.dev !== r.dev || i.ino !== r.ino || i.size !== BigInt(m.byteLength) || !l.isDirectory() || l.dev !== t.dev || l.ino !== t.ino || l.uid !== _ || (l.mode & 511n) != 448n || p.aborted) throw new e({ detail: "Sidecar private configuration publication changed or was cancelled" });
+		return await x(), Object.freeze({
+			configurationPath: g,
+			bytes: m.byteLength
+		});
+	} catch {
+		try {
+			await x();
+		} catch {
+			throw new l(x);
+		}
+		throw new e({ detail: "Sidecar private configuration publication failed" });
+	}
+};
+export { l as RoomSidecarConfigPublicationFailure, u as publishRoomSidecarNativeConfig };

package/dist/sidecarHostListener.js

@@ -0,0 +1,207 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { captureRoomTransportClock as n, captureRoomTransportDataMethod as r } from "./transportAuthoring.js";
+import { captureRoomSidecarNativeConfig as i } from "./sidecarConfig.js";
+import { platformRoomHostTimer as a } from "./hostDriver.js";
+import { RoomHostListenerBindFailure as o } from "./hostLane.js";
+import { inheritRoomHostListener as s } from "./hostListenerBinding.js";
+import { roomSidecarAdmission as c } from "./sidecarAdmission.js";
+import { RoomSidecarRuntimeAcquisitionFailure as l, openRoomSidecarRuntime as u } from "./sidecarRuntime.js";
+// src/sidecarHostListener.ts
+var d = (e, n) => {
+	if (!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== n.length || n.some((t) => {
+		let n = Object.getOwnPropertyDescriptor(e, t);
+		return !n?.enumerable || !("value" in n);
+	})) throw new t({
+		room: "sidecar-host",
+		detail: "Sidecar host listener requires complete own data and real providers"
+	});
+}, f = (f) => {
+	if (d(f, [
+		"fallback",
+		"ipc",
+		"native",
+		"process",
+		"signal",
+		"admission",
+		"maintenance"
+	]), d(f.ipc, [
+		"rootDirectory",
+		"peer",
+		"framing",
+		"maxPendingInboundFrames",
+		"maxPendingInboundBytes"
+	]), d(f.ipc.peer, [
+		"bootId",
+		"wire",
+		"maxConnections",
+		"maxRetiredConnections",
+		"maxListeners",
+		"maxPendingWrites",
+		"maxPendingEnvelopes",
+		"maxQueuedEnvelopeBytes",
+		"ackTimeoutMs",
+		"clock"
+	]), d(f.ipc.peer.wire, [
+		"maxFrameBytes",
+		"maxQueuedBytes",
+		"maxDatagramBytes",
+		"maxReasonBytes"
+	]), d(f.ipc.framing, [
+		"maxFrameBytes",
+		"maxChunkBytes",
+		"maxFramesPerChunk"
+	]), d(f.admission, ["verificationTimeoutMs", "maxHelloBytes"]), d(f.maintenance, Object.hasOwn(f.maintenance, "timer") ? ["cadenceMs", "timer"] : ["cadenceMs"]), !(f.signal instanceof AbortSignal) || f.signal.aborted || !(f.ipc.peer.bootId instanceof Uint8Array) || !Number.isSafeInteger(f.maintenance.cadenceMs) || f.maintenance.cadenceMs < 1 || f.maintenance.cadenceMs > 3e5) throw new t({
+		room: "sidecar-host",
+		detail: "Sidecar listener needs actual current lifetime and bounded maintenance cadence"
+	});
+	let p = r(f.fallback, "bind", "Sidecar listener requires actual WS listener ownership"), m = i(f.native), h = f.signal, g = Object.freeze({
+		start: r(f.process, "start", "Sidecar requires actual native start"),
+		stop: r(f.process, "stop", "Sidecar requires actual native stop"),
+		waitClosed: r(f.process, "waitClosed", "Sidecar requires actual terminal observation")
+	}), _ = n(f.ipc.peer.clock), v = Object.freeze({
+		...f.ipc,
+		framing: Object.freeze({ ...f.ipc.framing }),
+		peer: Object.freeze({
+			...f.ipc.peer,
+			bootId: f.ipc.peer.bootId.slice(),
+			wire: Object.freeze({ ...f.ipc.peer.wire }),
+			clock: _
+		})
+	}), y = Object.freeze({ ...f.admission }), b = f.maintenance.cadenceMs, x = r(f.maintenance.timer ?? a, "schedule", "Sidecar maintenance requires actual host timer ownership"), S = !1, C = Object.freeze({ bind: async (t, n, i) => {
+		if (S || !i || h.aborted) throw new e({ detail: "Sidecar listener requires its one current actual host binding" });
+		S = !0;
+		let a = r(n, "ready", "Sidecar requires actual suspended host admission"), s = r(n, "onFailure", "Sidecar requires actual HostLane owner failure observer"), d = new AbortController(), f = !1, C = !1, w, T, E, D, O, k, A = !1, j = !1, M, N = c(i, {
+			...y,
+			clock: _,
+			ready: () => f && !C && !h.aborted && a() === !0
+		}), P = () => {
+			E = void 0, T &&= (T(), void 0);
+		}, F = () => {
+			f = !1;
+			try {
+				P();
+			} catch {
+				M ??= new e({ detail: "Sidecar maintenance timer release remains incomplete" });
+			}
+			D || d.abort();
+		};
+		h.addEventListener("abort", F, { once: !0 }), h.aborted && F();
+		let I = () => {
+			f = !1;
+			try {
+				P();
+			} catch {
+				M ??= new e({ detail: "Sidecar maintenance timer release remains incomplete" });
+			}
+			try {
+				let t = s(M ?? new e({ detail: "Sidecar host transport is unavailable" }));
+				t !== void 0 && (t instanceof Promise && t.catch(() => {}), M = new e({ detail: "Sidecar failure observer must return synchronous void" }));
+			} catch {
+				M = new e({ detail: "Sidecar owner failure observation remains incomplete" });
+			}
+		}, L = () => {
+			if (!f || C || E) return;
+			let t = Object.freeze({});
+			E = t;
+			let n = !0;
+			try {
+				let r = x(b, () => {
+					if (E !== t || !f || C) return;
+					E = void 0;
+					let r = () => {
+						try {
+							if (P(), !f || C) return;
+							if (h.aborted || !D || D.failure) throw new e({ detail: "Sidecar actual native lifetime became unavailable" });
+							D.peer.maintenance();
+						} catch {
+							M ??= new e({ detail: "Sidecar host transport maintenance failed" }), I();
+							return;
+						}
+						L();
+					};
+					n ? queueMicrotask(r) : r();
+				});
+				if (typeof r != "function") throw new e({ detail: "Sidecar timer requires actual cancellation" });
+				T = r, n = !1;
+			} catch {
+				n = !1, E = void 0, M ??= new e({ detail: "Sidecar maintenance timer acquisition failed" }), I();
+			}
+		}, R = async () => {
+			if (f = !1, (await Promise.allSettled([Promise.resolve().then(P), Promise.resolve().then(() => k?.stopAdmission())])).some((e) => e.status === "rejected")) throw new e({ detail: "Sidecar host admission fencing remains incomplete" });
+		}, z = () => {
+			if (C) return Promise.resolve();
+			if (w) return w;
+			f = !1;
+			let t = (async () => {
+				let t = [];
+				try {
+					P();
+				} catch (e) {
+					t.push(e);
+				}
+				if (!j && D) try {
+					await D.closeAsync(), j = !0;
+				} catch (e) {
+					t.push(e);
+				}
+				if (O) try {
+					await O(), O = void 0, j = !0;
+				} catch (e) {
+					t.push(e);
+				}
+				if (!A && k) try {
+					await k.close(), A = !0;
+				} catch (e) {
+					t.push(e);
+				}
+				if (t.length) throw new e({ detail: "Sidecar host listener owned cleanup remains incomplete" });
+				C = !0, h.removeEventListener("abort", F);
+			})();
+			return w = t, t.catch(() => {
+				w === t && (w = void 0);
+			}), t;
+		};
+		try {
+			k = await p(t, n, i), k = Object.freeze({
+				activate: r(k, "activate", "WS listener requires actual activation"),
+				stopAdmission: r(k, "stopAdmission", "WS listener requires actual admission fence"),
+				close: r(k, "close", "WS listener requires actual owned close")
+			});
+			try {
+				D = await u({
+					ipc: {
+						...v,
+						peer: {
+							...v.peer,
+							bindConnection: N
+						}
+					},
+					native: m,
+					process: g,
+					signal: d.signal
+				});
+			} catch (e) {
+				throw e instanceof l && (O = e.cleanup), e;
+			}
+			if (h.aborted) throw new e({ detail: "Sidecar host admission was cancelled" });
+			return Object.freeze({
+				activate: () => {
+					if (f || C || w || h.aborted || a() !== !0 || D.failure) throw new e({ detail: "Sidecar listener activation was fenced" });
+					if (k.activate(), f = !0, L(), M) throw M;
+				},
+				stopAdmission: R,
+				close: z
+			});
+		} catch (t) {
+			t instanceof o && (O = t.retryCleanup);
+			try {
+				await z();
+			} catch {
+				throw new o(z);
+			}
+			throw new e({ detail: "Sidecar host listener acquisition did not complete" });
+		}
+	} });
+	return s(C, f.fallback), C;
+};
+export { f as sidecarRoomHostListener };