@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/sidecarIpc.js

@@ -0,0 +1,205 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { RoomStreamFrameDecoder as n, encodeRoomStreamFrame as r } from "./streamFraming.js";
+import { RoomSidecarPeer as i } from "./sidecarPeer.js";
+import { captureRoomSidecarProcessExit as a } from "./sidecarProcessPort.js";
+import { isAbsolute as o, join as s, resolve as c } from "node:path";
+import { createServer as l } from "node:net";
+import { chmod as u, lstat as d, mkdir as f, mkdtemp as p, realpath as m, rm as h } from "node:fs/promises";
+//#region src/sidecarIpc.ts
+var g = class extends Error {
+	cleanup;
+	constructor(e) {
+		super("Room sidecar IPC acquisition and owned cleanup remain incomplete"), this.cleanup = e;
+	}
+}, _ = async (_) => {
+	let v = [
+		"rootDirectory",
+		"peer",
+		"framing",
+		"maxPendingInboundFrames",
+		"maxPendingInboundBytes",
+		"signal",
+		"stopNative"
+	];
+	if (!_ || Object.getPrototypeOf(_) !== Object.prototype || Reflect.ownKeys(_).length !== v.length || v.some((e) => {
+		let t = Object.getOwnPropertyDescriptor(_, e);
+		return !t?.enumerable || !("value" in t);
+	}) || typeof _.rootDirectory != "string" || !o(_.rootDirectory) || typeof _.stopNative != "function" || typeof process.getuid != "function" || !(_.signal instanceof AbortSignal) || !Number.isSafeInteger(_.maxPendingInboundFrames) || _.maxPendingInboundFrames < 1 || _.maxPendingInboundFrames > 65536 || !Number.isSafeInteger(_.maxPendingInboundBytes) || _.maxPendingInboundBytes < 1 || _.maxPendingInboundBytes > 33554432) throw new t({
+		room: "sidecar-ipc",
+		detail: "Private Unix IPC requires complete actual providers and bounded budgets"
+	});
+	if (!_.peer || Object.getPrototypeOf(_.peer) !== Object.prototype || Reflect.ownKeys(_.peer).some((e) => {
+		let t = Object.getOwnPropertyDescriptor(_.peer, e);
+		return !t?.enumerable || !("value" in t);
+	})) throw new t({
+		room: "sidecar-ipc",
+		detail: "Private peer configuration requires own data"
+	});
+	let y = c(_.rootDirectory), b = process.getuid(), x = _.signal, S = _.stopNative.bind(_), C = _.maxPendingInboundFrames, w = _.maxPendingInboundBytes, T = new n(_.framing);
+	if (x.aborted) throw new e({ detail: "Sidecar IPC admission was cancelled" });
+	let E = Object.freeze({ ..._.framing }), D = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Set(), k = [], A, j, M, N, P, F = 0, I = 0, L = !1, R = !1, z, B = !1, V = !1, H, U = null, W = l(), G = (t) => {
+		if (L || !M || M.destroyed) return Promise.reject(new e({ detail: "Sidecar IPC writer is withdrawn" }));
+		let n;
+		try {
+			n = r(t, E.maxFrameBytes);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let i = M;
+		return new Promise((t, r) => {
+			let a = { reject: r };
+			O.add(a);
+			let o = (n) => {
+				O.delete(a), n || L || i.destroyed ? r(new e({ detail: "Sidecar IPC native write outcome remains unknown" })) : t();
+			};
+			try {
+				i.write(n, o);
+			} catch {
+				o(/* @__PURE__ */ Error("Room IPC write failed"));
+			}
+		});
+	}, K = async () => {
+		L = !0, R = !1, x.removeEventListener("abort", Z);
+		for (let t of O) t.reject(new e({ detail: "Sidecar IPC write withdrawn by parent shutdown" }));
+		if (O.clear(), !z) {
+			let t;
+			try {
+				t = await S();
+			} catch {
+				throw new e({ detail: "Sidecar native process shutdown remains incomplete" });
+			}
+			z = a(t);
+		}
+		for (let e of D.keys()) e.destroy();
+		if (await Promise.all(D.values()), P && await Promise.allSettled([P]), B ||= (W.listening && await new Promise((t, n) => {
+			W.close((r) => {
+				r ? n(new e({ detail: "Sidecar IPC listener shutdown remains incomplete" })) : t();
+			});
+		}), !0), A && !V) try {
+			await h(A, {
+				recursive: !0,
+				force: !1
+			}), V = !0;
+		} catch {
+			throw new e({ detail: "Sidecar private path cleanup remains incomplete" });
+		}
+	}, q = new i({
+		..._.peer,
+		sendEnvelope: G,
+		releaseParent: K
+	}), J = Math.max(_.peer.wire.maxFrameBytes + 27, _.peer.wire.maxReasonBytes + 24, 30);
+	if (E.maxFrameBytes < J || w < J || new TextEncoder().encode(y).byteLength > 74) throw new t({
+		room: "sidecar-ipc",
+		detail: "IPC framing/inbound/path budgets cannot hold the declared peer envelope"
+	});
+	let Y = () => {
+		if (H) return H;
+		let t = (async () => {
+			await q.closeAsync(), N && await N, k.splice(0), F = 0, I = 0;
+			try {
+				T.finish();
+			} catch {
+				U ||= new e({ detail: "Sidecar IPC ingress withdrawn before complete framing" });
+			}
+			if (!z) throw new e({ detail: "Sidecar native exit was not observed" });
+			return z;
+		})();
+		return H = t, t.catch(() => {
+			H === t && (H = void 0);
+		}), t;
+	}, X = () => {
+		U ??= new e({ detail: "Sidecar private IPC admission or native stream failed" }), q.closeAsync().catch(() => {});
+	}, Z = () => {
+		X();
+	}, Q = () => {
+		if (N || L) return;
+		let e = (async () => {
+			try {
+				for (; !L && k.length;) {
+					let e = k.shift();
+					try {
+						await q.receive(e);
+					} finally {
+						F -= e.byteLength, I--;
+					}
+				}
+			} catch {
+				X();
+			}
+		})();
+		N = e, e.then(() => {
+			N === e && (N = void 0), L || (k.length ? Q() : M?.resume());
+		}, () => {
+			X();
+		});
+	};
+	W.on("connection", (t) => {
+		let n = new Promise((e) => {
+			t.once("close", () => {
+				D.delete(t), e();
+			});
+		});
+		D.set(t, n), t.on("error", () => {
+			t === M && !L && X();
+		}), !R || L || M ? t.destroy() : (M = t, t.pause(), t.on("data", (n) => {
+			if (t.pause(), !L) try {
+				let r = T.push(typeof n == "string" ? new TextEncoder().encode(n) : new Uint8Array(n));
+				if (I + r.length > C || F + r.reduce((e, t) => e + t.byteLength, 0) > w) throw new e({ detail: "Sidecar pending IPC ingress exceeded its budget" });
+				for (let e of r) k.push(e), F += e.byteLength, I++;
+				k.length ? Q() : t.resume();
+			} catch {
+				X();
+			}
+		}), t.on("end", () => {
+			if (!L) {
+				try {
+					T.finish();
+				} catch {
+					U ??= new e({ detail: "Sidecar IPC ended inside an envelope" });
+				}
+				X();
+			}
+		}), t.on("close", () => {
+			L || X();
+		}), t.resume());
+	}), W.on("error", () => {
+		L || X();
+	});
+	try {
+		let t = await d(y).catch(async (e) => {
+			if (e.code !== "ENOENT") throw e;
+			return await f(y, { mode: 448 }), await u(y, 448), d(y);
+		});
+		if (!t.isDirectory() || t.isSymbolicLink() || t.uid !== b || (t.mode & 511) != 448 || await m(y) !== y) throw new e({ detail: "Sidecar IPC root must be canonical, owned and private" });
+		if (A = await p(s(y, "rooms-wt-")), await u(A, 448), j = s(A, "ipc.sock"), new TextEncoder().encode(j).byteLength > 100) throw new e({ detail: "Sidecar Unix socket path exceeded its budget" });
+		if (x.addEventListener("abort", Z, { once: !0 }), x.aborted || L) throw new e({ detail: "Sidecar IPC admission was cancelled" });
+		P = new Promise((t, n) => {
+			let r = () => {
+				n(new e({ detail: "Sidecar IPC listen failed" }));
+			};
+			W.once("error", r), W.listen(j, () => {
+				W.removeListener("error", r), t();
+			});
+		}), await P, await u(j, 384);
+		let n = await d(j), r = await d(A);
+		if (!n.isSocket() || n.uid !== b || (n.mode & 511) != 384 || !r.isDirectory() || r.uid !== b || (r.mode & 511) != 448 || L || x.aborted) throw new e({ detail: "Sidecar IPC private ownership admission failed" });
+		return R = !0, Object.freeze({
+			address: j,
+			peer: q,
+			ready: q.ready,
+			get failure() {
+				return U;
+			},
+			closeAsync: Y
+		});
+	} catch {
+		try {
+			await Y();
+		} catch {
+			throw new g(Y);
+		}
+		throw new e({ detail: "Sidecar IPC acquisition failed" });
+	}
+};
+//#endregion
+export { g as RoomSidecarIpcAcquisitionError, _ as openRoomSidecarIpc };

package/dist/sidecarPeer.js

@@ -0,0 +1,310 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { captureRoomTransportClock as r } from "./transportAuthoring.js";
+import { RoomLatestDatagram as i } from "./streamFraming.js";
+import { RoomSidecarWire as a } from "./sidecarWire.js";
+import { RoomSidecarWrites as o } from "./sidecarWrites.js";
+import { Result as s } from "effect";
+//#region src/sidecarPeer.ts
+var c = () => {
+	let e, t, n = new Promise((n, r) => {
+		e = n, t = r;
+	});
+	return n.catch(() => {}), {
+		promise: n,
+		resolve: e,
+		reject: t
+	};
+}, l = class {
+	wire;
+	bootId;
+	options;
+	limits;
+	now;
+	sendEnvelope;
+	bindConnection;
+	releaseParent;
+	connections = /* @__PURE__ */ new Map();
+	retired = /* @__PURE__ */ new Set();
+	readyState = c();
+	ready = this.readyState.promise;
+	submissions = /* @__PURE__ */ new Set();
+	admitted = !1;
+	closing = !1;
+	parentReleased = !1;
+	closeTask;
+	lastAt = -1;
+	queuedEnvelopeBytes = 0;
+	receiving = !1;
+	constructor(e) {
+		let t = [
+			"bootId",
+			"wire",
+			"maxConnections",
+			"maxRetiredConnections",
+			"maxListeners",
+			"maxPendingWrites",
+			"maxPendingEnvelopes",
+			"maxQueuedEnvelopeBytes",
+			"ackTimeoutMs",
+			"clock",
+			"sendEnvelope",
+			"bindConnection",
+			"releaseParent"
+		];
+		if (!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== t.length || t.some((t) => {
+			let n = Object.getOwnPropertyDescriptor(e, t);
+			return !n?.enumerable || !("value" in n);
+		}) || !(e.bootId instanceof Uint8Array) || e.bootId.byteLength !== 16 || !Number.isSafeInteger(e.maxConnections) || e.maxConnections < 1 || e.maxConnections > 65536 || !Number.isSafeInteger(e.maxRetiredConnections) || e.maxRetiredConnections < 1 || e.maxRetiredConnections > 1048576 || !Number.isSafeInteger(e.maxListeners) || e.maxListeners < 1 || e.maxListeners > 1024 || !Number.isSafeInteger(e.maxPendingWrites) || e.maxPendingWrites < 1 || e.maxPendingWrites > 4096 || !Number.isSafeInteger(e.maxPendingEnvelopes) || e.maxPendingEnvelopes < 1 || e.maxPendingEnvelopes > 65536 || !Number.isSafeInteger(e.maxQueuedEnvelopeBytes) || e.maxQueuedEnvelopeBytes < 64 || e.maxQueuedEnvelopeBytes > 33554432 || !Number.isSafeInteger(e.ackTimeoutMs) || e.ackTimeoutMs < 1 || e.ackTimeoutMs > 3e5 || typeof e.sendEnvelope != "function" || typeof e.bindConnection != "function" || typeof e.releaseParent != "function") throw new n({
+			room: "sidecar-peer",
+			detail: "Sidecar peer requires complete actual providers and bounded budgets"
+		});
+		this.wire = new a(e.wire), this.limits = Object.freeze({ ...e.wire }), this.bootId = e.bootId.slice(), this.now = r(e.clock).now, this.options = Object.freeze({
+			maxConnections: e.maxConnections,
+			maxRetiredConnections: e.maxRetiredConnections,
+			maxListeners: e.maxListeners,
+			maxPendingWrites: e.maxPendingWrites,
+			maxPendingEnvelopes: e.maxPendingEnvelopes,
+			maxQueuedEnvelopeBytes: e.maxQueuedEnvelopeBytes,
+			ackTimeoutMs: e.ackTimeoutMs
+		}), this.sendEnvelope = e.sendEnvelope.bind(e), this.bindConnection = e.bindConnection.bind(e), this.releaseParent = e.releaseParent.bind(e);
+	}
+	at() {
+		let e = this.now();
+		if (!Number.isFinite(e) || e < 0 || e < this.lastAt) throw new t({ detail: "Sidecar peer observation clock regressed" });
+		return this.lastAt = e, e;
+	}
+	submit(t) {
+		let n = this.wire.encode(t);
+		if (s.isFailure(n)) return Promise.reject(n.failure);
+		let r = n.success.byteLength + 4;
+		if (this.parentReleased || this.submissions.size >= this.options.maxPendingEnvelopes || this.queuedEnvelopeBytes + r > this.options.maxQueuedEnvelopeBytes) return this.closeAsync().catch(() => {}), Promise.reject(new e({
+			budget: "sidecarEnvelopeBytes",
+			limit: this.options.maxQueuedEnvelopeBytes
+		}));
+		this.queuedEnvelopeBytes += r;
+		let i = (async () => {
+			try {
+				await this.sendEnvelope(n.success);
+			} finally {
+				this.queuedEnvelopeBytes -= r;
+			}
+		})();
+		return this.submissions.add(i), i.then(() => {
+			this.submissions.delete(i);
+		}, () => {
+			this.submissions.delete(i);
+		}), i;
+	}
+	closeConnection(e, n, r) {
+		if (e.closeTask) return e.closeTask;
+		if (!Number.isSafeInteger(n) || n < 0 || n > 4294967295 || typeof r != "string" || !r.isWellFormed() || new TextEncoder().encode(r).byteLength > this.limits.maxReasonBytes) return Promise.reject(new t({ detail: "Invalid sidecar close information" }));
+		e.closeInfo ??= Object.freeze({
+			code: n,
+			reason: r
+		}), e.closing = !0, e.abort.abort(), e.reliable.clear(), e.datagrams.clear(), e.mailbox?.close();
+		let i = (async () => {
+			!e.nativeClosed && !e.closeSent && (await this.submit({
+				kind: "Close",
+				connectionId: e.id.slice(),
+				...e.closeInfo
+			}), e.closeSent = !0), await e.nativeEnd.promise, await e.writes.closeAsync(), e.datagramTask && await e.datagramTask;
+			try {
+				await e.binding?.closeAsync();
+			} catch {
+				throw new t({ detail: "Sidecar session withdrawal remains incomplete" });
+			}
+			this.connections.delete(e.key), this.retired.add(e.key);
+		})();
+		return e.closeTask = i, i.catch(() => {
+			e.closeTask === i && (e.closeTask = void 0);
+		}), i;
+	}
+	backgroundClose(e) {
+		this.closeConnection(e, 1e3, "").catch(() => {});
+	}
+	pumpDatagrams(e) {
+		if (e.datagramTask || e.closing) return;
+		let t = (async () => {
+			try {
+				for (; !e.closing && e.mailbox.bufferedBytes;) {
+					let t = e.mailbox.take();
+					e.datagramBytes = t.byteLength, await this.submit({
+						kind: "Frame",
+						connectionId: e.id.slice(),
+						lane: "datagram",
+						writeId: 0,
+						payload: t
+					}), e.datagramBytes = 0;
+				}
+			} catch {
+				e.datagramBytes = 0, this.backgroundClose(e);
+			}
+		})();
+		e.datagramTask = t, t.then(() => {
+			e.datagramTask === t && (e.datagramTask = void 0), !e.closing && e.mailbox.bufferedBytes && this.pumpDatagrams(e);
+		}, () => {
+			this.backgroundClose(e);
+		});
+	}
+	open(n) {
+		let r = [...n.connectionId].map((e) => e.toString(16).padStart(2, "0")).join("");
+		if (this.connections.has(r) || this.retired.has(r) || this.connections.size >= this.options.maxConnections || this.retired.size + this.connections.size >= this.options.maxRetiredConnections) throw new t({ detail: "Sidecar connection identity or bounded capacity refused" });
+		let a = {
+			id: n.connectionId.slice(),
+			key: r,
+			abort: new AbortController(),
+			nativeEnd: c(),
+			reliable: /* @__PURE__ */ new Set(),
+			datagrams: /* @__PURE__ */ new Set(),
+			nativeClosed: !1,
+			closing: !1,
+			closeSent: !1,
+			datagramBytes: 0,
+			nativeQueued: 0,
+			nativeDrops: 0,
+			receivedWriteId: 0,
+			...n.maxDatagramBytes ? { mailbox: new i(n.maxDatagramBytes) } : {},
+			writes: new o({
+				connectionId: n.connectionId.slice(),
+				maxPendingWrites: this.options.maxPendingWrites,
+				maxQueuedBytes: this.limits.maxQueuedBytes,
+				ackTimeoutMs: this.options.ackTimeoutMs,
+				clock: { now: () => this.at() },
+				send: (e) => this.submit(e),
+				fail: () => {
+					this.backgroundClose(a);
+				}
+			})
+		};
+		this.connections.set(r, a);
+		let s = (n, r) => {
+			if (a.closing || typeof r != "function") throw new t({ detail: "Sidecar connection cannot attach this listener" });
+			if (!n.has(r) && n.size >= this.options.maxListeners) throw new e({
+				budget: "sidecarListeners",
+				limit: this.options.maxListeners
+			});
+			return n.add(r), () => {
+				n.delete(r);
+			};
+		}, l = Object.freeze({
+			name: "wt",
+			signal: a.abort.signal,
+			reliable: Object.freeze({
+				send: (e) => a.closing ? Promise.reject(new t({ detail: "Sidecar connection is withdrawn" })) : a.writes.sendFrame(e),
+				onFrame: (e) => s(a.reliable, e)
+			}),
+			...a.mailbox ? { unreliable: Object.freeze({
+				maxDatagramBytes: n.maxDatagramBytes,
+				send: (e) => {
+					if (a.closing) throw new t({ detail: "Sidecar connection is withdrawn" });
+					if (a.mailbox.offer(e), !Number.isSafeInteger(a.nativeDrops + a.mailbox.droppedDatagrams)) throw this.backgroundClose(a), new t({ detail: "Sidecar datagram counter exhausted" });
+					this.pumpDatagrams(a);
+				},
+				onFrame: (e) => s(a.datagrams, e)
+			}) } : {},
+			stats: () => {
+				let e = a.nativeDrops + (a.mailbox?.droppedDatagrams ?? 0);
+				if (!Number.isSafeInteger(e)) throw new t({ detail: "Sidecar datagram counter exceeded its range" });
+				return {
+					rttMs: null,
+					queuedBytes: Math.max(a.writes.queuedBytes, a.nativeQueued) + a.datagramBytes + (a.mailbox?.bufferedBytes ?? 0),
+					droppedDatagrams: e
+				};
+			},
+			close: (e, t) => {
+				let n = "", r = 0;
+				if (typeof t == "string") for (let e of t.toWellFormed()) {
+					let t = new TextEncoder().encode(e).byteLength;
+					if (r + t > this.limits.maxReasonBytes) break;
+					n += e, r += t;
+				}
+				let i = Number.isSafeInteger(e) && e >= 0 && e <= 4294967295 ? e : 1e3;
+				this.closeConnection(a, i, n).catch(() => {});
+			},
+			closeAsync: (e, t) => this.closeConnection(a, e, t)
+		}), u = this.bindConnection(l), d = u ? Object.getOwnPropertyDescriptor(u, "closeAsync") : void 0;
+		if (!u || !d || !("value" in d) || typeof d.value != "function") throw new t({ detail: "Sidecar connection requires actual awaited session withdrawal" });
+		if (a.binding = Object.freeze({ closeAsync: d.value.bind(u) }), !a.reliable.size) throw new t({ detail: "Sidecar connection requires first-Hello handling before native frames" });
+	}
+	async receive(e) {
+		if (this.closing) throw new t({ detail: "Sidecar peer is withdrawn" });
+		if (this.receiving) throw new t({ detail: "Sidecar IPC reader must deliver envelopes in awaited order" });
+		this.receiving = !0;
+		try {
+			let n = this.wire.decode(e);
+			if (s.isFailure(n)) throw n.failure;
+			let r = n.success;
+			if (r.kind === "Ready") {
+				if (this.admitted || !r.bootId.every((e, t) => e === this.bootId[t])) throw new t({ detail: "Sidecar boot identity mismatch or duplicate readiness" });
+				this.admitted = !0, this.readyState.resolve();
+				return;
+			}
+			if (!this.admitted) throw new t({ detail: "Sidecar has not confirmed this actual boot" });
+			if (r.kind === "Open") {
+				this.open(r);
+				return;
+			}
+			let i = [...r.connectionId].map((e) => e.toString(16).padStart(2, "0")).join(""), a = this.connections.get(i);
+			if (!a) throw new t({ detail: "Sidecar referenced an unknown transport connection" });
+			switch (r.kind) {
+				case "Frame": {
+					if (r.lane === "datagram" && !a.mailbox) throw new t({ detail: "Sidecar frame lane/lifetime mismatch" });
+					if (r.lane === "reliable") {
+						if (r.writeId !== a.receivedWriteId + 1) throw new t({ detail: "Sidecar reliable ingress sequence drifted" });
+						a.receivedWriteId = r.writeId;
+					}
+					let e = this.at(), n = r.lane === "reliable" ? a.reliable : a.datagrams;
+					if (!a.closing) for (let t of n) t(r.payload.slice(), e);
+					r.lane === "reliable" && await this.submit({
+						kind: "Accepted",
+						connectionId: a.id.slice(),
+						writeId: r.writeId
+					});
+					return;
+				}
+				case "Accepted":
+					a.writes.accept(r);
+					return;
+				case "Pressure":
+					if (r.droppedDatagrams < a.nativeDrops || !Number.isSafeInteger(r.droppedDatagrams + (a.mailbox?.droppedDatagrams ?? 0))) throw new t({ detail: "Sidecar pressure counter regressed or exceeded its range" });
+					a.nativeQueued = r.queuedBytes, a.nativeDrops = r.droppedDatagrams;
+					return;
+				case "Close":
+					a.nativeClosed = !0, a.nativeEnd.resolve(), await this.closeConnection(a, r.code, r.reason);
+					return;
+			}
+		} catch {
+			try {
+				await this.closeAsync();
+			} catch {
+				throw new t({ detail: "Sidecar peer admission and native cleanup remain incomplete" });
+			}
+			throw new t({ detail: "Sidecar peer envelope admission failed" });
+		} finally {
+			this.receiving = !1;
+		}
+	}
+	maintenance() {
+		if (!this.closing) for (let e of this.connections.values()) e.writes.maintenance();
+	}
+	closeAsync() {
+		if (this.closeTask) return this.closeTask;
+		this.closing = !0, this.readyState.reject(new t({ detail: "Sidecar peer withdrawn before readiness" }));
+		for (let e of this.connections.values()) e.closing = !0, e.abort.abort();
+		let e = (async () => {
+			if (!this.parentReleased) try {
+				await this.releaseParent(), this.parentReleased = !0;
+			} catch {
+				throw new t({ detail: "Sidecar native parent release remains incomplete" });
+			}
+			for (let e of this.connections.values()) e.nativeClosed = !0, e.nativeEnd.resolve();
+			let e = await Promise.allSettled([...this.connections.values()].map((e) => this.closeConnection(e, 1e3, ""))), n = await Promise.allSettled(this.submissions);
+			if (e.some((e) => e.status === "rejected") || n.some((e) => e.status === "rejected")) throw new t({ detail: "Sidecar peer owned cleanup remains incomplete" });
+		})();
+		return this.closeTask = e, e.catch(() => {
+			this.closeTask === e && (this.closeTask = void 0);
+		}), e;
+	}
+};
+//#endregion
+export { l as RoomSidecarPeer };

package/dist/sidecarProcessPort.js

@@ -0,0 +1,28 @@
+import { ProtocolError as e } from "./errors.js";
+//#region src/sidecarProcessPort.ts
+var t = (t) => {
+	let n = () => {
+		throw new e({ detail: "Sidecar native exit observation is missing or malformed" });
+	};
+	if (!t || Object.getPrototypeOf(t) !== Object.prototype) return n();
+	let r = Object.getOwnPropertyDescriptor(t, "kind");
+	if (!r || !("value" in r)) return n();
+	let i = r.value === "not-started" ? ["kind"] : [
+		"kind",
+		"exitCode",
+		"signal"
+	];
+	if (Reflect.ownKeys(t).length !== i.length || i.some((e) => {
+		let n = Object.getOwnPropertyDescriptor(t, e);
+		return !n?.enumerable || !("value" in n);
+	})) return n();
+	if (r.value === "not-started") return Object.freeze({ kind: "not-started" });
+	let a = t, o = a.exitCode, s = a.signal;
+	return r.value !== "exited" || o === null && s === null || o !== null && (typeof o != "number" || !Number.isSafeInteger(o) || o < 0 || o > 255) || s !== null && (typeof s != "string" || !/^SIG[A-Z0-9]+$/.test(s)) || o !== null && s !== null ? n() : Object.freeze({
+		kind: "exited",
+		exitCode: o,
+		signal: s
+	});
+};
+//#endregion
+export { t as captureRoomSidecarProcessExit };