@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/sidecarRuntime.js

@@ -0,0 +1,167 @@
+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 { RoomSidecarConfigPublicationFailure as a, publishRoomSidecarNativeConfig as o } from "./sidecarConfigPublication.js";
+import { captureRoomSidecarProcessExit as s } from "./sidecarProcessPort.js";
+import { RoomSidecarIpcAcquisitionError as c, openRoomSidecarIpc as l } from "./sidecarIpc.js";
+import { join as u } from "node:path";
+// src/sidecarRuntime.ts
+var d = class extends Error {
+	cleanup;
+	constructor(e) {
+		super("Room sidecar startup or owned cleanup remains incomplete; retained lifetime requires cleanup"), this.cleanup = e;
+	}
+}, f = (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-runtime",
+		detail: "Sidecar runtime requires captured own configuration and actual native providers"
+	});
+}, p = () => {
+	let e, t = new Promise((t, n) => {
+		e = n;
+	});
+	return t.catch(() => {}), {
+		promise: t,
+		reject: e
+	};
+}, m = async (m) => {
+	if (f(m, [
+		"ipc",
+		"native",
+		"process",
+		"signal"
+	]), f(m.ipc, [
+		"rootDirectory",
+		"peer",
+		"framing",
+		"maxPendingInboundFrames",
+		"maxPendingInboundBytes"
+	]), f(m.ipc.peer, [
+		"bootId",
+		"wire",
+		"maxConnections",
+		"maxRetiredConnections",
+		"maxListeners",
+		"maxPendingWrites",
+		"maxPendingEnvelopes",
+		"maxQueuedEnvelopeBytes",
+		"ackTimeoutMs",
+		"clock",
+		"bindConnection"
+	]), f(m.ipc.peer.wire, [
+		"maxFrameBytes",
+		"maxQueuedBytes",
+		"maxDatagramBytes",
+		"maxReasonBytes"
+	]), f(m.ipc.framing, [
+		"maxFrameBytes",
+		"maxChunkBytes",
+		"maxFramesPerChunk"
+	]), !(m.signal instanceof AbortSignal) || m.signal.aborted || !(m.ipc.peer.bootId instanceof Uint8Array) || m.ipc.peer.bootId.byteLength !== 16) throw new t({
+		room: "sidecar-runtime",
+		detail: "Sidecar startup requires actual current lifetime and opaque boot identity"
+	});
+	let h = i(m.native), g = m.signal, _ = r(m.process, "start", "Sidecar process requires actual captured start"), v = r(m.process, "stop", "Sidecar process requires actual captured stop"), y = r(m.process, "waitClosed", "Sidecar process requires actual captured terminal observation"), b = Object.freeze({
+		...m.ipc,
+		peer: Object.freeze({
+			...m.ipc.peer,
+			bootId: m.ipc.peer.bootId.slice(),
+			wire: Object.freeze({ ...m.ipc.peer.wire }),
+			clock: n(m.ipc.peer.clock),
+			bindConnection: r(m.ipc.peer, "bindConnection", "Sidecar runtime requires actual first-Hello binding")
+		}),
+		framing: Object.freeze({ ...m.ipc.framing })
+	}), x = new AbortController(), S = p(), C = p(), w, T, E, D, O, k, A, j, M, N, P, F = !1, I = !1, L = !1, R = null, z, B = () => {
+		z &&= (clearTimeout(z), void 0);
+	}, V = () => {
+		if (M) return Promise.resolve(M);
+		if (N) return N;
+		let t = (async () => {
+			let t;
+			try {
+				t = await v();
+			} catch {
+				throw new e({ detail: "Sidecar native process release remains incomplete" });
+			}
+			return M = s(t), M;
+		})();
+		return N = t, t.catch(() => {
+			L = !0;
+		}), t;
+	}, H = () => {
+		if (P) return P;
+		L &&= (N = void 0, !1), F = !0, B(), g.removeEventListener("abort", U), x.abort(), S.reject(new e({ detail: "Sidecar startup was withdrawn" }));
+		let t = (async () => {
+			T && await T.catch(() => {}), D && await D.catch(() => {});
+			let e = await V();
+			return j && await j.catch(() => {}), O &&= (await O(), void 0), w && await w.closeAsync(), k &&= (await k(), void 0), A && await A, e;
+		})();
+		return P = t, t.catch(() => {
+			P === t && (P = void 0);
+		}), t;
+	}, U = () => {
+		R ??= new e({ detail: I ? "Sidecar native lifetime was withdrawn" : "Sidecar startup was cancelled" }), S.reject(R), H().catch(() => {});
+	};
+	g.addEventListener("abort", U, { once: !0 }), z = setTimeout(() => {
+		R ??= new e({ detail: "Sidecar startup exceeded its admission deadline" }), S.reject(R), H().catch(() => {});
+	}, h.admissionTimeoutMs), g.aborted && U();
+	try {
+		if (T = (async () => {
+			try {
+				return w = await l({
+					...b,
+					signal: x.signal,
+					stopNative: V
+				}), w;
+			} catch (e) {
+				throw e instanceof c && (k = e.cleanup), e;
+			}
+		})(), w = await T, F || (D = (async () => {
+			try {
+				return await o(h, b.peer, w.address, x.signal);
+			} catch (e) {
+				throw e instanceof a && (O = e.cleanup), e;
+			}
+		})(), E = await D, F)) throw new e({ detail: "Sidecar startup was withdrawn" });
+		let t = u(b.rootDirectory, "native-" + Buffer.from(b.peer.bootId).toString("hex") + ".log");
+		if (j = Promise.resolve().then(() => _({
+			configurationPath: E.configurationPath,
+			logPath: t,
+			signal: x.signal
+		})), await j, F) throw new e({ detail: "Sidecar startup was withdrawn" });
+		if (A = (async () => {
+			try {
+				s(await y()), F || (R ??= new e({ detail: I ? "Sidecar native process ended" : "Sidecar native process ended before Ready" }));
+			} catch {
+				F || (R ??= new e({ detail: "Sidecar native terminal observation remains unknown" }));
+			}
+			C.reject(R ?? new e({ detail: "Sidecar native lifetime ended during startup" })), F || H().catch(() => {});
+		})(), await Promise.race([
+			w.ready,
+			S.promise,
+			C.promise
+		]), F || x.signal.aborted || R || w.failure) throw new e({ detail: "Sidecar current native Ready was not admitted" });
+		return I = !0, B(), Object.freeze({
+			peer: w.peer,
+			address: w.address,
+			configurationPath: E.configurationPath,
+			logPath: t,
+			get failure() {
+				return R ?? w?.failure ?? null;
+			},
+			closeAsync: H
+		});
+	} catch {
+		R ??= new e({ detail: "Sidecar startup failed before complete native Ready" });
+		try {
+			await H();
+		} catch {
+			throw new d(H);
+		}
+		throw R;
+	}
+};
+export { d as RoomSidecarRuntimeAcquisitionFailure, m as openRoomSidecarRuntime };

package/dist/sidecarSelection.js

@@ -0,0 +1,141 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { RoomStreamFrameDecoder as t } from "./streamFraming.js";
+import { RoomSidecarWire as n } from "./sidecarWire.js";
+import { captureRoomSidecarNativeConfig as r } from "./sidecarConfig.js";
+import { isAbsolute as i, join as a, resolve as o } from "node:path";
+// src/sidecarSelection.ts
+function s() {
+	throw new e({
+		room: "sidecar-selection",
+		detail: "Native host selection requires complete own operator choices and bounded budgets"
+	});
+}
+var c = (e, t) => {
+	(!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);
+	})) && s();
+}, l = (e, t) => typeof e == "number" && Number.isSafeInteger(e) && e > 0 && e <= t ? e : s(), u = (e) => typeof e == "string" && i(e) && o(e) === e && !e.includes("\0") ? e : s(), d = (e) => {
+	c(e, [
+		"executablePath",
+		"termGraceMs",
+		"killGraceMs",
+		"native",
+		"ipc",
+		"admission",
+		"maintenance"
+	]), c(e.ipc, [
+		"rootDirectory",
+		"peer",
+		"framing",
+		"maxPendingInboundFrames",
+		"maxPendingInboundBytes"
+	]), c(e.ipc.peer, [
+		"wire",
+		"maxConnections",
+		"maxRetiredConnections",
+		"maxListeners",
+		"maxPendingWrites",
+		"maxPendingEnvelopes",
+		"maxQueuedEnvelopeBytes",
+		"ackTimeoutMs"
+	]), c(e.ipc.peer.wire, [
+		"maxFrameBytes",
+		"maxQueuedBytes",
+		"maxDatagramBytes",
+		"maxReasonBytes"
+	]), c(e.ipc.framing, [
+		"maxFrameBytes",
+		"maxChunkBytes",
+		"maxFramesPerChunk"
+	]), c(e.admission, ["verificationTimeoutMs", "maxHelloBytes"]), c(e.maintenance, ["cadenceMs"]);
+	let i = r(e.native), a = Object.freeze({
+		maxFrameBytes: l(e.ipc.peer.wire.maxFrameBytes, 16777216),
+		maxQueuedBytes: l(e.ipc.peer.wire.maxQueuedBytes, 33554432),
+		maxDatagramBytes: l(e.ipc.peer.wire.maxDatagramBytes, 65535),
+		maxReasonBytes: l(e.ipc.peer.wire.maxReasonBytes, 65535)
+	}), o = Object.freeze({
+		maxFrameBytes: l(e.ipc.framing.maxFrameBytes, 33554432),
+		maxChunkBytes: l(e.ipc.framing.maxChunkBytes, 33554432),
+		maxFramesPerChunk: l(e.ipc.framing.maxFramesPerChunk, 65536)
+	}), d = Object.freeze({
+		wire: a,
+		maxConnections: l(e.ipc.peer.maxConnections, 65536),
+		maxRetiredConnections: l(e.ipc.peer.maxRetiredConnections, 1048576),
+		maxListeners: l(e.ipc.peer.maxListeners, 1024),
+		maxPendingWrites: l(e.ipc.peer.maxPendingWrites, 4096),
+		maxPendingEnvelopes: l(e.ipc.peer.maxPendingEnvelopes, 65536),
+		maxQueuedEnvelopeBytes: l(e.ipc.peer.maxQueuedEnvelopeBytes, 33554432),
+		ackTimeoutMs: l(e.ipc.peer.ackTimeoutMs, 3e5)
+	}), f = Object.freeze({
+		rootDirectory: u(e.ipc.rootDirectory),
+		peer: d,
+		framing: o,
+		maxPendingInboundFrames: l(e.ipc.maxPendingInboundFrames, 65536),
+		maxPendingInboundBytes: l(e.ipc.maxPendingInboundBytes, 33554432)
+	}), p = Object.freeze({
+		verificationTimeoutMs: l(e.admission.verificationTimeoutMs, 3e5),
+		maxHelloBytes: l(e.admission.maxHelloBytes, a.maxFrameBytes)
+	}), m = Object.freeze({ cadenceMs: l(e.maintenance.cadenceMs, Math.min(d.ackTimeoutMs, 3e5)) }), h = Math.max(a.maxFrameBytes + 27, a.maxReasonBytes + 24, 30);
+	return new n(a), new t(o), (d.maxRetiredConnections < d.maxConnections || a.maxQueuedBytes < a.maxFrameBytes + 4 || a.maxDatagramBytes > a.maxFrameBytes || o.maxFrameBytes < h || o.maxChunkBytes < 4 || f.maxPendingInboundBytes < h || d.maxQueuedEnvelopeBytes < h + 4 || i.maxTotalPendingBytes < h + 4 || i.writeTimeoutMs > d.ackTimeoutMs) && s(), Object.freeze({
+		executablePath: u(e.executablePath),
+		termGraceMs: l(e.termGraceMs, 3e5),
+		killGraceMs: l(e.killGraceMs, 3e5),
+		native: i,
+		ipc: f,
+		admission: p,
+		maintenance: m
+	});
+}, f = (e) => {
+	let t = "127.0.0.1:" + e.port, n = u(e.privateDirectory);
+	return d({
+		executablePath: e.executablePath,
+		termGraceMs: 2e3,
+		killGraceMs: 2e3,
+		native: {
+			udpAddress: t,
+			requestAuthority: t,
+			path: e.path,
+			origins: [],
+			loopbackOrigins: !0,
+			certificateFile: a(n, "certificate.pem"),
+			privateKeyFile: a(n, "private.pem"),
+			maxTotalPendingBytes: 4194304,
+			maxTotalPendingFrames: 4096,
+			admissionTimeoutMs: 1e4,
+			writeTimeoutMs: 5e3,
+			idleTimeoutMs: 3e4
+		},
+		ipc: {
+			rootDirectory: n,
+			peer: {
+				wire: {
+					maxFrameBytes: 65536,
+					maxQueuedBytes: 1048576,
+					maxDatagramBytes: 1200,
+					maxReasonBytes: 1024
+				},
+				maxConnections: 1024,
+				maxRetiredConnections: 4096,
+				maxListeners: 4,
+				maxPendingWrites: 64,
+				maxPendingEnvelopes: 4096,
+				maxQueuedEnvelopeBytes: 4194304,
+				ackTimeoutMs: 5e3
+			},
+			framing: {
+				maxFrameBytes: 131072,
+				maxChunkBytes: 262144,
+				maxFramesPerChunk: 256
+			},
+			maxPendingInboundFrames: 4096,
+			maxPendingInboundBytes: 4194304
+		},
+		admission: {
+			verificationTimeoutMs: 5e3,
+			maxHelloBytes: 16384
+		},
+		maintenance: { cadenceMs: 25 }
+	});
+};
+export { d as captureRoomSidecarHostSelection, f as developmentRoomSidecarSelection };

package/dist/sidecarWire.js

@@ -0,0 +1,177 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { Result as r } from "effect";
+// src/sidecarWire.ts
+function i() {
+	throw new t({ detail: "Malformed Room sidecar envelope" });
+}
+var a = (e) => !(e instanceof Uint8Array) || e.byteLength !== 16 ? i() : e, o = (e, t = 2 ** 53 - 1) => typeof e != "number" || !Number.isSafeInteger(e) || e < 0 || e > t ? i() : e, s = (e, t) => {
+	(!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);
+	})) && i();
+}, c = class {
+	limits;
+	constructor(e) {
+		if (s(e, [
+			"maxFrameBytes",
+			"maxQueuedBytes",
+			"maxDatagramBytes",
+			"maxReasonBytes"
+		]), !Number.isSafeInteger(e.maxFrameBytes) || e.maxFrameBytes < 1 || e.maxFrameBytes > 16777216 || !Number.isSafeInteger(e.maxQueuedBytes) || e.maxQueuedBytes < 1 || e.maxQueuedBytes > 33554432 || !Number.isSafeInteger(e.maxDatagramBytes) || e.maxDatagramBytes < 1 || e.maxDatagramBytes > 65535 || !Number.isSafeInteger(e.maxReasonBytes) || e.maxReasonBytes < 1 || e.maxReasonBytes > 1024) throw new n({
+			room: "sidecar-wire",
+			detail: "Sidecar wire requires explicit bounded byte budgets"
+		});
+		this.limits = Object.freeze({ ...e });
+	}
+	encode(n) {
+		try {
+			let t = Object.getOwnPropertyDescriptor(n, "kind");
+			t && "value" in t || i();
+			let c, l, u;
+			switch (t.value) {
+				case "Ready":
+					s(n, ["kind", "bootId"]), c = 1, l = 18;
+					break;
+				case "Open":
+					s(n, [
+						"kind",
+						"connectionId",
+						"maxDatagramBytes"
+					]), c = 2, l = 22;
+					break;
+				case "Frame":
+					if (s(n, [
+						"kind",
+						"connectionId",
+						"lane",
+						"writeId",
+						"payload"
+					]), c = 3, n.kind === "Frame" && n.payload instanceof Uint8Array && n.payload.byteLength || i(), n.payload.byteLength > this.limits.maxFrameBytes) throw new e({
+						budget: "sidecarFrameBytes",
+						limit: this.limits.maxFrameBytes
+					});
+					if (n.lane !== "reliable" && n.lane !== "datagram" && i(), n.lane === "datagram" && n.payload.byteLength > this.limits.maxDatagramBytes) throw new e({
+						budget: "maxDatagramBytes",
+						limit: this.limits.maxDatagramBytes
+					});
+					u = n.payload, l = 27 + u.byteLength;
+					break;
+				case "Accepted":
+					s(n, [
+						"kind",
+						"connectionId",
+						"writeId"
+					]), c = 4, l = 26;
+					break;
+				case "Close":
+					if (s(n, [
+						"kind",
+						"connectionId",
+						"code",
+						"reason"
+					]), c = 5, n.kind === "Close" && typeof n.reason == "string" && n.reason.isWellFormed() || i(), u = new TextEncoder().encode(n.reason), u.byteLength > this.limits.maxReasonBytes) throw new e({
+						budget: "sidecarReasonBytes",
+						limit: this.limits.maxReasonBytes
+					});
+					l = 24 + u.byteLength;
+					break;
+				case "Pressure":
+					s(n, [
+						"kind",
+						"connectionId",
+						"queuedBytes",
+						"droppedDatagrams"
+					]), c = 6, l = 30;
+					break;
+				default: return i();
+			}
+			let d = new Uint8Array(l), f = new DataView(d.buffer);
+			switch (d[0] = 1, d[1] = c, d.set(a(n.kind === "Ready" ? n.bootId : n.connectionId), 2), n.kind) {
+				case "Ready": break;
+				case "Open":
+					f.setUint32(18, o(n.maxDatagramBytes, this.limits.maxDatagramBytes), !1);
+					break;
+				case "Frame":
+					o(n.writeId), (n.lane === "reliable" && n.writeId === 0 || n.lane === "datagram" && n.writeId !== 0) && i(), d[18] = n.lane === "reliable" ? 0 : 1, f.setBigUint64(19, BigInt(n.writeId), !1), d.set(u, 27);
+					break;
+				case "Accepted":
+					o(n.writeId) === 0 && i(), f.setBigUint64(18, BigInt(n.writeId), !1);
+					break;
+				case "Close":
+					f.setUint32(18, o(n.code, 4294967295), !1), f.setUint16(22, u.byteLength, !1), d.set(u, 24);
+					break;
+				case "Pressure": f.setUint32(18, o(n.queuedBytes, this.limits.maxQueuedBytes), !1), f.setBigUint64(22, BigInt(o(n.droppedDatagrams)), !1);
+			}
+			return r.succeed(d);
+		} catch (n) {
+			return r.fail(n instanceof e ? n : new t({ detail: "Malformed Room sidecar envelope" }));
+		}
+	}
+	decode(n) {
+		try {
+			(!(n instanceof Uint8Array) || n.byteLength < 18 || n[0] !== 1) && i();
+			let t = new DataView(n.buffer, n.byteOffset, n.byteLength), a = n.slice(2, 18), s;
+			switch (n[1]) {
+				case 1:
+					n.byteLength !== 18 && i(), s = {
+						kind: "Ready",
+						bootId: a
+					};
+					break;
+				case 2:
+					n.byteLength !== 22 && i(), s = {
+						kind: "Open",
+						connectionId: a,
+						maxDatagramBytes: t.getUint32(18, !1)
+					};
+					break;
+				case 3:
+					if ((n.byteLength < 28 || n[18] > 1) && i(), n.byteLength - 27 > this.limits.maxFrameBytes) throw new e({
+						budget: "sidecarFrameBytes",
+						limit: this.limits.maxFrameBytes
+					});
+					s = {
+						kind: "Frame",
+						connectionId: a,
+						lane: n[18] === 0 ? "reliable" : "datagram",
+						writeId: o(Number(t.getBigUint64(19, !1))),
+						payload: n.slice(27)
+					};
+					break;
+				case 4:
+					n.byteLength !== 26 && i(), s = {
+						kind: "Accepted",
+						connectionId: a,
+						writeId: o(Number(t.getBigUint64(18, !1)))
+					};
+					break;
+				case 5:
+					if ((n.byteLength < 24 || n.byteLength !== 24 + t.getUint16(22, !1)) && i(), n.byteLength - 24 > this.limits.maxReasonBytes) throw new e({
+						budget: "sidecarReasonBytes",
+						limit: this.limits.maxReasonBytes
+					});
+					s = {
+						kind: "Close",
+						connectionId: a,
+						code: t.getUint32(18, !1),
+						reason: new TextDecoder("utf-8", { fatal: !0 }).decode(n.subarray(24))
+					};
+					break;
+				case 6:
+					n.byteLength !== 30 && i(), s = {
+						kind: "Pressure",
+						connectionId: a,
+						queuedBytes: t.getUint32(18, !1),
+						droppedDatagrams: o(Number(t.getBigUint64(22, !1)))
+					};
+					break;
+				default: return i();
+			}
+			let c = this.encode(s);
+			return r.isFailure(c) ? r.fail(c.failure) : r.succeed(Object.freeze(s));
+		} catch (n) {
+			return r.fail(n instanceof e ? n : new t({ detail: "Malformed Room sidecar envelope" }));
+		}
+	}
+};
+export { c as RoomSidecarWire };

package/dist/sidecarWrites.js

@@ -0,0 +1,162 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { captureRoomTransportClock as r } from "./transportAuthoring.js";
+// src/sidecarWrites.ts
+var i = class {
+	id;
+	options;
+	send;
+	fail;
+	now;
+	pending = /* @__PURE__ */ new Map();
+	submissions = /* @__PURE__ */ new Set();
+	nextId = 1;
+	queued = 0;
+	lastAt = -1;
+	ended = !1;
+	terminal = null;
+	closeTask = null;
+	failureHookError = !1;
+	constructor(e) {
+		let t = [
+			"connectionId",
+			"maxPendingWrites",
+			"maxQueuedBytes",
+			"ackTimeoutMs",
+			"clock",
+			"send",
+			"fail"
+		];
+		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.connectionId instanceof Uint8Array) || e.connectionId.byteLength !== 16 || typeof e.send != "function" || typeof e.fail != "function" || !Number.isSafeInteger(e.maxPendingWrites) || e.maxPendingWrites < 1 || e.maxPendingWrites > 4096 || !Number.isSafeInteger(e.maxQueuedBytes) || e.maxQueuedBytes < 1 || e.maxQueuedBytes > 33554432 || !Number.isSafeInteger(e.ackTimeoutMs) || e.ackTimeoutMs < 1 || e.ackTimeoutMs > 3e5) throw new n({
+			room: "sidecar-writes",
+			detail: "Sidecar writes require actual captured IPC/withdrawal and bounded budgets"
+		});
+		this.id = e.connectionId.slice(), this.send = e.send.bind(e), this.fail = e.fail.bind(e), this.now = r(e.clock).now, this.options = Object.freeze({
+			maxPendingWrites: e.maxPendingWrites,
+			maxQueuedBytes: e.maxQueuedBytes,
+			ackTimeoutMs: e.ackTimeoutMs
+		});
+	}
+	get queuedBytes() {
+		return this.queued;
+	}
+	get pendingWrites() {
+		return this.pending.size;
+	}
+	observeTime() {
+		let e = this.now();
+		if (!Number.isFinite(e) || e < 0 || e < this.lastAt || !Number.isFinite(e + this.options.ackTimeoutMs)) throw new t({ detail: "Sidecar write clock must remain monotonic and bounded" });
+		return this.lastAt = e, e;
+	}
+	withdraw(e) {
+		if (!this.ended) {
+			this.ended = !0, this.terminal = e;
+			for (let t of this.pending.values()) t.reject(e);
+			this.pending.clear(), this.queued = 0, this.releaseFailureHook(e);
+		}
+	}
+	releaseFailureHook(e) {
+		try {
+			let t = this.fail(e);
+			if (this.failureHookError = t !== void 0, t instanceof Promise) {
+				let e = t.then(() => {}, () => {});
+				this.submissions.add(e), e.then(() => {
+					this.submissions.delete(e);
+				});
+			}
+		} catch {
+			this.failureHookError = !0;
+		}
+	}
+	sendFrame(n) {
+		if (this.ended) return Promise.reject(this.terminal ?? new t({ detail: "Sidecar writes are closed" }));
+		let r;
+		try {
+			if (!(n instanceof Uint8Array) || !n.byteLength) throw new t({ detail: "Sidecar reliable payload must contain binary bytes" });
+			if (this.pending.size >= this.options.maxPendingWrites) throw new e({
+				budget: "sidecarPendingWrites",
+				limit: this.options.maxPendingWrites
+			});
+			if (this.queued + n.byteLength > this.options.maxQueuedBytes) throw new e({
+				budget: "sidecarQueuedBytes",
+				limit: this.options.maxQueuedBytes
+			});
+			if (!Number.isSafeInteger(this.nextId)) throw new t({ detail: "Sidecar write identity exhausted" });
+			r = this.observeTime();
+		} catch (n) {
+			let r = n instanceof e ? n : new t({ detail: "Sidecar reliable write admission failed" });
+			return this.withdraw(r), Promise.reject(r);
+		}
+		let i = n.slice(), a = this.nextId++, o = new Promise((e, t) => {
+			this.pending.set(a, {
+				bytes: i.byteLength,
+				deadline: r + this.options.ackTimeoutMs,
+				resolve: e,
+				reject: t
+			}), this.queued += i.byteLength;
+		}), s = (async () => {
+			try {
+				await this.send(Object.freeze({
+					kind: "Frame",
+					connectionId: this.id.slice(),
+					lane: "reliable",
+					writeId: a,
+					payload: i
+				}));
+			} catch {
+				this.withdraw(new t({ detail: "Sidecar IPC reliable submission outcome remains unknown" }));
+			}
+		})();
+		return this.submissions.add(s), s.then(() => {
+			this.submissions.delete(s);
+		}, () => {
+			this.submissions.delete(s), this.withdraw(new t({ detail: "Sidecar IPC submission lifetime failed" }));
+		}), o;
+	}
+	accept(e) {
+		try {
+			this.acceptCurrent(e);
+		} catch {
+			let e = new t({ detail: "Sidecar native receipt admission failed" });
+			throw this.withdraw(e), e;
+		}
+	}
+	acceptCurrent(e) {
+		let n = [
+			"kind",
+			"connectionId",
+			"writeId"
+		];
+		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);
+		}) || e.kind !== "Accepted" || !(e.connectionId instanceof Uint8Array) || e.connectionId.byteLength !== 16 || !e.connectionId.every((e, t) => e === this.id[t]) || !Number.isSafeInteger(e.writeId) || e.writeId < 1) throw new t({ detail: "Sidecar native receipt does not match this connection" });
+		if (this.ended) return;
+		let r = this.pending.get(e.writeId);
+		if (!r) throw new t({ detail: "Sidecar native receipt is unknown or already consumed" });
+		if (this.observeTime() >= r.deadline) throw this.withdraw(new t({ detail: "Sidecar native acceptance deadline expired" })), this.terminal;
+		this.pending.delete(e.writeId), this.queued -= r.bytes, r.resolve();
+	}
+	maintenance() {
+		if (!this.ended) try {
+			let e = this.observeTime();
+			[...this.pending.values()].some((t) => e >= t.deadline) && this.withdraw(new t({ detail: "Sidecar native acceptance deadline expired" }));
+		} catch {
+			this.withdraw(new t({ detail: "Sidecar write supervision clock failed" }));
+		}
+	}
+	closeAsync() {
+		if (this.closeTask) return this.closeTask;
+		this.failureHookError && this.terminal && this.releaseFailureHook(this.terminal), this.withdraw(new t({ detail: "Sidecar reliable writes were withdrawn" }));
+		let e = (async () => {
+			let e = await Promise.allSettled(this.submissions);
+			if (this.failureHookError || e.some((e) => e.status === "rejected")) throw new t({ detail: "Sidecar reliable write cleanup remains incomplete" });
+		})();
+		return this.closeTask = e, e.catch(() => {
+			this.closeTask === e && (this.closeTask = null);
+		}), e;
+	}
+};
+export { i as RoomSidecarWrites };