@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/hostDeployment.js

@@ -0,0 +1,64 @@
+import { ProtocolError as e } from "./errors.js";
+import { roomHostTransportEndpoints as t } from "./transportEndpoints.js";
+import { roomHostMetricsRoute as n } from "./hostMetrics.js";
+// src/hostDeployment.ts
+var r = (r, i, a) => {
+	let o = r.VOLTRO_ROOMS_HOST_DEPLOYMENT;
+	if (o === void 0) return;
+	let s = () => {
+		throw new e({ detail: "Room host deployment binding is incomplete or differs from its process selection" });
+	};
+	if (o.length > 4096) return s();
+	let c;
+	try {
+		c = JSON.parse(o);
+	} catch {
+		return s();
+	}
+	if (!c || typeof c != "object" || Array.isArray(c)) return s();
+	let l = c;
+	if (Object.keys(l).some((e) => ![
+		"version",
+		"pool",
+		"region",
+		"port",
+		"metrics",
+		"publicRouting",
+		"shutdown"
+	].includes(e)) || l.version !== 1 || typeof l.pool != "string" || l.pool !== i || typeof l.region != "string" || l.region !== a || typeof l.port != "number" || !Number.isSafeInteger(l.port) || l.port < 1 || l.port > 65535 || typeof l.metrics != "boolean") return s();
+	let u;
+	if (l.shutdown !== void 0) {
+		let e = l.shutdown;
+		if (!e || typeof e != "object" || Array.isArray(e)) return s();
+		let t = e, n = t.drainMs, r = t.terminationGraceMs;
+		if (Object.keys(t).some((e) => !["drainMs", "terminationGraceMs"].includes(e)) || typeof n != "number" || !Number.isSafeInteger(n) || n < 1 || typeof r != "number" || !Number.isSafeInteger(r) || r < n + 5e3 || r > 36e5) return s();
+		u = Object.freeze({
+			drainMs: n,
+			terminationGraceMs: r
+		});
+	}
+	let d;
+	if (l.publicRouting !== void 0) {
+		let e = l.publicRouting;
+		if (!e || typeof e != "object" || Array.isArray(e)) return s();
+		let n = e, i = r.VOLTRO_ROOMS_HOST_POD_NAME;
+		if (Object.keys(n).some((e) => !["statefulSet", "template"].includes(e)) || typeof n.statefulSet != "string" || n.statefulSet.length > 52 || !/^[a-z][a-z0-9-]*[a-z0-9]$/.test(n.statefulSet) || n.statefulSet.includes("\n") || typeof n.template != "string" || n.template.length > 2048 || /[\r\n$]/.test(n.template) || !n.template.includes("{pod}") || /[{}]/.test(n.template.replaceAll("{pod}", "")) || typeof i != "string" || !i.startsWith(`${n.statefulSet}-`) || !/^(0|[1-9][0-9]*)$/.test(i.slice(n.statefulSet.length + 1)) || i.includes("\n") || i.length > 63) return s();
+		d = t(n.template.replaceAll("{pod}", i), void 0).ws;
+	}
+	let f = l.metrics ? r.VOLTRO_ROOMS_HOST_METRICS_TOKEN : void 0, p = l.metrics ? r.VOLTRO_ROOMS_HOST_METRICS_TOKEN_PREVIOUS : void 0, m = p === void 0 || p === "" || p === f ? void 0 : p;
+	if (l.metrics) {
+		if (f === void 0) return s();
+		n(f, () => {
+			throw Error("Credential preflight does not observe hosts");
+		}, m);
+	}
+	return Object.freeze({
+		port: l.port,
+		host: "0.0.0.0",
+		...u === void 0 ? {} : { shutdown: u },
+		...f === void 0 ? {} : { metricsToken: f },
+		...m === void 0 ? {} : { metricsPreviousToken: m },
+		...d === void 0 ? {} : { publicAddress: d }
+	});
+};
+export { r as captureRoomHostDeployment };

package/dist/hostDrain.js

@@ -0,0 +1,151 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomForbidden as n, RoomGone as r } from "./errors.js";
+import { simulationOwnData as i } from "./simulationAuthoring.js";
+import { ROOMS_TABLE as a, ROOM_CHECKPOINTS_TABLE as o, ROOM_HOSTS_TABLE as s, ROOM_SEATS_TABLE as c } from "./identities.js";
+import { RoomHostDrainPort as l } from "./hostDrainPorts.js";
+import { captureRoomSnapshotBlobs as u, captureRoomSnapshotEffectRunner as d } from "./snapshotBlobIndex.js";
+import { loadDurableRoomCheckpoint as f, prefetchRoomCheckpointBlobs as p } from "./checkpointStore.js";
+import { captureRoomLockstepRecoveryOptions as m, readRoomLockstepRecoveryTruth as h } from "./lockstepRecoveryTruth.js";
+import { fenceRoomRecoverySeats as g } from "./recoverySeats.js";
+import { and as _, eq as v, or as y } from "@voltro/database";
+import { Effect as b } from "effect";
+// src/hostDrain.ts
+function x() {
+	throw new t({ detail: "Planned Host drain lacks matching process, fenced ownership or durable progress" });
+}
+var S = (e) => typeof e == "string" && e.length > 0 && e.length <= 191 && e.trim() === e ? e : x(), C = (e, t = 0) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e < 2 ** 53 - 1 ? e : x(), w = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e) ? e : x(), T = (e) => {
+	let t = i(e, ["graceMs", "maxCheckpointBytes"], ["graceMs"]), n = C(t.graceMs, 1), r = C(t.maxCheckpointBytes ?? 1048576, 1);
+	return n > 4294967295 ? x() : Object.freeze({
+		graceMs: n,
+		maxCheckpointBytes: r
+	});
+}, E = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return Number.isSafeInteger(t) && t >= 0 ? t : x();
+}, D = (e, t, n, r) => e.query({
+	table: t,
+	predicate: n,
+	order: [{
+		column: "id",
+		direction: "asc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0,
+	lock: "update"
+}), O = (i) => b.flatMap(b.context(), (a) => b.uninterruptible(b.tryPromise({
+	try: () => i(d(a)),
+	catch: (i) => i instanceof t || i instanceof e || i instanceof n || i instanceof r ? i : new t({ detail: "Planned Host drain SQL operation remains incomplete" })
+}))), k = (e) => {
+	let t = i(e, [
+		"roomId",
+		"tenantId",
+		"epoch",
+		"tick",
+		"mode",
+		"revision",
+		"admissionDigest",
+		"journalDigest"
+	], [
+		"roomId",
+		"tenantId",
+		"epoch",
+		"tick",
+		"mode"
+	]), n = {
+		roomId: S(t.roomId),
+		tenantId: S(t.tenantId),
+		epoch: C(t.epoch, 1),
+		tick: C(t.tick)
+	};
+	return t.mode === "state-sync" && !Object.hasOwn(t, "admissionDigest") && !Object.hasOwn(t, "journalDigest") ? Object.freeze({
+		...n,
+		mode: "state-sync",
+		revision: C(t.revision, 1)
+	}) : t.mode === "lockstep" && !Object.hasOwn(t, "revision") ? Object.freeze({
+		...n,
+		mode: "lockstep",
+		admissionDigest: w(t.admissionDigest),
+		journalDigest: t.journalDigest === null ? null : w(t.journalDigest)
+	}) : x();
+}, A = (l, d, w) => {
+	let T = i(d, [
+		"hostId",
+		"instanceId",
+		"startedAt"
+	], [
+		"hostId",
+		"instanceId",
+		"startedAt"
+	]), A = Object.freeze({
+		hostId: S(T.hostId),
+		instanceId: S(T.instanceId),
+		startedAt: C(T.startedAt)
+	}), j = C(w.graceMs, 1), M = C(w.maxSeatRows ?? 4096, 1), N = C(w.maxCheckpointBytes ?? 1048576, 1);
+	if (A.startedAt > 864e13 || j > 864e13 || M > 65536 || typeof w.epochNow != "function") return x();
+	let P = w.epochNow.bind(w), F = w.snapshotCodec, I = u(w.snapshotBlobs), L = m(w.lockstep), R = async (e) => {
+		let t = await D(e, s, v("id", A.hostId), 2), n = t[0];
+		if (t.length !== 1 || !n) throw new r({ roomId: "host" });
+		return n.instanceId !== A.instanceId || E(n.membershipStartedAt) !== A.startedAt || typeof n.ready != "boolean" || typeof n.draining != "boolean" ? x() : n;
+	};
+	return Object.freeze({
+		begin: () => O(() => l.transactional(async (e) => {
+			let t = await R(e);
+			t.draining === !0 ? t.ready !== !1 && x() : await e.updateMany("_voltro_room_hosts", {
+				draining: !0,
+				ready: !1
+			}, { where: _(v("id", A.hostId), v("draining", !1)) }) !== 1 && x();
+		})),
+		handoff: (i) => {
+			let s;
+			try {
+				s = k(i);
+			} catch {
+				return b.fail(new t({ detail: "Invalid planned Room handoff boundary" }));
+			}
+			return O(async (t) => {
+				let i = s.mode === "lockstep" ? void 0 : await p(l, s.roomId, s.tenantId, N, F, I, t);
+				return l.transactional(async (l) => {
+					let u = await R(l);
+					if (u.draining !== !0 || u.ready !== !1) return x();
+					let d = _(v("id", s.roomId), v("tenantId", s.tenantId)), p = await D(l, a, d, 2), m = p[0];
+					if (p.length !== 1 || !m) throw new r({ roomId: s.roomId });
+					if (m.hostId !== A.hostId || m.epoch !== s.epoch) throw new n({ roomId: s.roomId });
+					if (!["live", "orphaned"].includes(String(m.state)) || m.erasure != null || m.snapshotErasure != null) return x();
+					let b = await h(l, m, L);
+					if (s.mode === "lockstep") {
+						if (!b || b.admission.digest !== s.admissionDigest || (b.journal?.digest ?? null) !== s.journalDigest || (b.journal?.ticks.length ?? 0) !== s.tick) return x();
+					} else {
+						if (b) return x();
+						let e = await D(l, o, _(v("roomId", s.roomId), v("tenantId", s.tenantId)), 2);
+						if (e.length !== 1) return x();
+						let n = await f(l, e[0], s.roomId, s.tenantId, N, F, i, t);
+						if (n.epoch !== s.epoch || n.revision !== s.revision || n.tick !== s.tick || n.disposition !== "live") return x();
+					}
+					let S = Object.freeze({
+						hostId: A.hostId,
+						roomId: s.roomId,
+						tenantId: s.tenantId,
+						epoch: s.epoch,
+						state: "orphaned",
+						tick: s.tick
+					});
+					if (m.state === "orphaned") return S;
+					let w = C(P());
+					if (w > 864e13 - j) return x();
+					let T = await D(l, c, _(v("roomId", s.roomId), v("tenantId", s.tenantId), y(v("state", "reserved"), v("state", "connected"), v("state", "grace"))), M + 1);
+					if (T.length > M) throw new e({
+						budget: "hostDrainSeats",
+						limit: M
+					});
+					let E = await g(l, s.roomId, s.tenantId, s.epoch, T, w, j, !0, C(m.maxClients, 1));
+					return await l.updateMany("_voltro_rooms", {
+						state: "orphaned",
+						clients: E,
+						updatedAt: new Date(w)
+					}, { where: _(d, v("hostId", A.hostId), v("epoch", s.epoch), v("state", "live")) }) === 1 ? S : x();
+				});
+			});
+		}
+	});
+};
+export { l as RoomHostDrainPort, T as captureRoomHostDrainPolicy, A as dataStoreRoomHostDrain };

package/dist/hostDrainPorts.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/hostDrainPorts.ts
+var t = class extends e.Service()("@voltro/RoomHostDrainPort") {};
+export { t as RoomHostDrainPort };

package/dist/hostDriver.js

@@ -0,0 +1,178 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomHostTurnObservation as t } from "./hostTurnObservation.js";
+import { performance as n } from "node:perf_hooks";
+import { availableParallelism as r } from "node:os";
+// src/hostDriver.ts
+var i = Object.freeze({ schedule: (e, t) => {
+	let n = setTimeout(t, e);
+	return () => clearTimeout(n);
+} }), a = (t) => {
+	let n = t && Object.getOwnPropertyDescriptor(t, "continueWorldGroups"), r = t && Object.getOwnPropertyDescriptor(t, "maintainWorldGhosts");
+	if (r && (!("value" in r) || typeof r.value != "function") || t && !r && "maintainWorldGhosts" in t) throw new e({ detail: "Ghost maintenance requires an own acquired callback" });
+	if (n && (!("value" in n) || typeof n.value != "function") || t && !n && "continueWorldGroups" in t) throw new e({ detail: "World continuation requires an own acquired callback" });
+	if (!t || typeof t != "object" || Array.isArray(t) || Object.keys(t).some((e) => ![
+		"cadenceMs",
+		"timer",
+		"onFailure",
+		"continueWorldGroups",
+		"maintainWorldGhosts"
+	].includes(e)) || !Number.isSafeInteger(t.cadenceMs) || t.cadenceMs < 1 || t.cadenceMs > 2147483647 || typeof t.onFailure != "function" || t.timer !== void 0 && typeof t.timer?.schedule != "function") throw new e({ detail: "Invalid host driver configuration" });
+	let a = t.timer ?? i;
+	return Object.freeze({
+		cadenceMs: t.cadenceMs,
+		onFailure: t.onFailure.bind(t),
+		timer: Object.freeze({ schedule: a.schedule.bind(a) }),
+		...r ? { maintainWorldGhosts: r.value.bind(t) } : {},
+		...n ? { continueWorldGroups: n.value.bind(t) } : {}
+	});
+}, o = class {
+	controller;
+	canTurn;
+	cancelTimer = null;
+	active = null;
+	stopTask = null;
+	quiesceTask = null;
+	running = !1;
+	stopping = !1;
+	failure = null;
+	timer;
+	scheduled = null;
+	turnController;
+	closeController;
+	observation;
+	options;
+	constructor(n, r, i = () => !0) {
+		if (this.controller = n, this.canTurn = i, this.options = a(r), typeof n?.turn != "function" || typeof n.close != "function" || typeof i != "function") throw new e({ detail: "Host driver requires complete controller and admission callbacks" });
+		this.observation = new t(this.options.cadenceMs), this.timer = this.options.timer, this.turnController = n.turn.bind(n), this.closeController = n.close.bind(n);
+	}
+	start() {
+		if (this.running || this.stopping) throw new e({ detail: "Room host driver already started or stopping" });
+		if (this.running = !0, this.observation.arm(), this.schedule(), !this.running) throw new e({ detail: "Room host driver could not acquire its control timer" });
+	}
+	report(t) {
+		this.failure = t;
+		try {
+			let n = this.options.onFailure(t);
+			if (n !== void 0) throw n instanceof Promise && n.catch(() => void 0), new e({ detail: "Host failure observer must return synchronous void" });
+		} catch (e) {
+			this.failure = AggregateError([t, e], "Room host turn and failure observer failed");
+		}
+	}
+	schedule() {
+		if (!this.running || this.stopping || this.active || this.scheduled) return;
+		let t = Object.freeze({});
+		this.scheduled = t;
+		let n = !0;
+		try {
+			let r = this.timer.schedule(this.options.cadenceMs, () => {
+				if (this.scheduled !== t || !this.running || this.stopping) return;
+				this.scheduled = null;
+				let r = Promise.withResolvers();
+				this.active = r.promise;
+				let i = async () => {
+					try {
+						if (this.cancelTimer) {
+							let e = this.cancelTimer;
+							try {
+								e(), this.cancelTimer = null;
+							} catch (e) {
+								throw this.running = !1, e;
+							}
+						}
+						if (!this.running || this.stopping) return;
+						let t = this.canTurn();
+						if (typeof t != "boolean") throw new e({ detail: "Host driver admission must be synchronous boolean data" });
+						if (!t) return;
+						this.observation.begin();
+						let n = !1;
+						try {
+							let t = [];
+							try {
+								await this.turnController();
+							} catch (e) {
+								t.push(e);
+							}
+							if (this.options.continueWorldGroups) try {
+								let t = this.options.continueWorldGroups();
+								if (!(t instanceof Promise)) throw new e({ detail: "World continuation must return its actual completion Promise" });
+								await t;
+							} catch (e) {
+								t.push(e);
+							}
+							if (this.options.maintainWorldGhosts) try {
+								let t = this.options.maintainWorldGhosts();
+								if (!(t instanceof Promise)) throw new e({ detail: "Ghost maintenance requires its actual completion Promise" });
+								await t;
+							} catch (e) {
+								t.push(e);
+							}
+							if (t.length === 1) throw t[0];
+							if (t.length > 1) throw AggregateError(t, "Room turn and World continuation failed");
+							n = !0;
+						} finally {
+							this.observation.finish(n);
+						}
+					} catch (e) {
+						this.report(e);
+					} finally {
+						this.active = null, r.resolve(), this.schedule();
+					}
+				};
+				n ? queueMicrotask(() => {
+					i();
+				}) : i();
+			});
+			if (typeof r != "function") throw new e({ detail: "Host timer must return its actual cancellation operation" });
+			this.cancelTimer = r, n = !1;
+		} catch (e) {
+			n = !1, this.scheduled = null, this.running = !1, this.report(e);
+		}
+	}
+	metrics() {
+		return this.observation.snapshot();
+	}
+	live() {
+		return this.running && !this.stopping && this.observation.live();
+	}
+	get lastFailure() {
+		return this.failure;
+	}
+	get turning() {
+		return this.active !== null;
+	}
+	quiesce() {
+		if (this.quiesceTask) return this.quiesceTask;
+		this.stopping = !0, this.running = !1, this.scheduled = null;
+		let e = (async () => {
+			if (this.cancelTimer) {
+				let e = this.cancelTimer;
+				e(), this.cancelTimer = null;
+			}
+			this.active && await this.active;
+		})();
+		return this.quiesceTask = e, e.catch(() => {
+			this.quiesceTask = null;
+		}), e;
+	}
+	stop() {
+		return this.stopTask || (this.stopTask = (async () => {
+			await this.quiesce(), await this.closeController();
+		})(), this.stopTask.then(() => void 0, (e) => {
+			this.report(e), this.stopTask = null;
+		})), this.stopTask;
+	}
+}, s = (t = {}) => {
+	let i = t.now ?? (() => n.now()), a = t.cpuUsage ?? process.cpuUsage, o = t.parallelism ?? r();
+	if (!Number.isSafeInteger(o) || o < 1) throw new e({ detail: "CPU parallelism must be positive" });
+	let s = i(), c = a(), l = 0;
+	if (!Number.isFinite(s) || s < 0) throw new e({ detail: "Invalid process measurement clock" });
+	return () => {
+		let t = i(), n = a(), r = t - s;
+		if (!Number.isFinite(t) || r < 0) throw new e({ detail: "Process measurement clock moved backwards" });
+		if (r === 0) throw new e({ detail: "Process CPU measurement requires an elapsed interval" });
+		let u = n.user + n.system - c.user - c.system;
+		if (!Number.isSafeInteger(u) || u < 0) throw new e({ detail: "Process CPU counters are invalid" });
+		return l = Math.min(1, u / (r * 1e3 * o)), s = t, c = n, l;
+	};
+};
+export { o as RoomHostDriver, a as captureRoomHostDriverOptions, i as platformRoomHostTimer, s as roomProcessCpuSampler };

package/dist/hostLane.js

@@ -0,0 +1,287 @@
+import { ProtocolError as e, RoomGone as t } from "./errors.js";
+import { simulationOwnData as n } from "./simulationAuthoring.js";
+import { captureRoomTransportDataMethod as r } from "./transportAuthoring.js";
+import { RoomReservePort as i } from "./ports.js";
+import { roomsGateway as a } from "./gateway.js";
+import { captureRoomHostDrainPolicy as o } from "./hostDrain.js";
+import { RoomHostController as s, RoomHostControllerStartFailure as c } from "./hostController.js";
+import { RoomHostDriver as l, captureRoomHostDriverOptions as u } from "./hostDriver.js";
+import { hostRoomReserveService as d } from "./reservePort.js";
+import { frameworkStartCause as f } from "./startFailureCause.js";
+import { Effect as p, Layer as m } from "effect";
+// src/hostLane.ts
+var h = class extends Error {
+	stage;
+	retryCleanup;
+	name = "RoomHostLaneStartFailure";
+	constructor(e, t, n) {
+		super(`Room host lane failed during ${e} acquisition`, f(n) === void 0 ? void 0 : { cause: n }), this.stage = e, this.retryCleanup = t;
+	}
+}, g = class extends Error {
+	retryCleanup;
+	name = "RoomHostListenerBindFailure";
+	constructor(e) {
+		super("Room listener acquisition cleanup remains incomplete"), this.retryCleanup = e;
+	}
+}, _ = class f {
+	controller;
+	ghostGateway = null;
+	ghostsStopped = !1;
+	phase = "binding";
+	listener = null;
+	admissionStopped = !1;
+	controllerStopped = !1;
+	listenerStopped = !1;
+	partialListenerCleanup = null;
+	closeTask = null;
+	activation = null;
+	plannedDrain = null;
+	gateway;
+	reservation;
+	services;
+	driver;
+	sessionHost;
+	constructor(e, n) {
+		this.controller = e, this.driver = new l(e, {
+			...n.driver,
+			maintainWorldGhosts: async () => {
+				let e = (await Promise.allSettled([Promise.resolve().then(() => this.ghostGateway?.runDue()), Promise.resolve().then(() => n.driver.maintainWorldGhosts?.())])).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+				if (e.length) throw AggregateError(e, "World ghost maintenance remains incomplete");
+			}
+		}, () => this.phase === "running"), this.sessionHost = Object.freeze({
+			verifySeat: async (t, n) => {
+				this.requireRunning();
+				let r = await e.verifySeat(t, n);
+				return this.requireRunning(), r;
+			},
+			connect: (t, n, r) => (this.requireRunning(), e.connect(t, n, r))
+		}), this.gateway = a(this.sessionHost, n.gateway);
+		let r = d(e), o = (e) => p.suspend(() => this.phase === "running" ? e : p.fail(new t({ roomId: "host" })));
+		this.reservation = Object.freeze({
+			reserve: (e, t) => o(r.reserve(e, t)),
+			resume: (e, t) => o(r.resume(e, t)),
+			leave: (e, t, n) => o(r.leave(e, t, n)),
+			list: (e, t, n) => o(r.list(e, t, n))
+		}), this.services = m.succeed(i, this.reservation);
+	}
+	static async start(t, i, a) {
+		if (a.processRole !== "rooms") throw new e({ detail: "A Room host requires its dedicated process role" });
+		if (a.startSuspended !== void 0 && typeof a.startSuspended != "boolean") throw new e({ detail: "Invalid Room lane activation policy" });
+		let o = Object.getOwnPropertyDescriptor(a, "worldGhostGateway");
+		if (o && (!("value" in o) || typeof o.value != "function") || !o && "worldGhostGateway" in a) throw new e({ detail: "World ghost gateway requires an own acquired factory" });
+		let l = Object.getOwnPropertyDescriptor(a, "worldGhostCells"), d = [];
+		if (l && (!("value" in l) || !Array.isArray(l.value) || l.value.length > 1024) || !l && "worldGhostCells" in a) throw new e({ detail: "World ghost cells require a bounded own policy inventory" });
+		if (l) for (let t = 0; t < l.value.length; t++) {
+			let r = Object.getOwnPropertyDescriptor(l.value, String(t));
+			if (!r || !("value" in r)) throw new e({ detail: "World ghost cell policy inventory must be dense own data" });
+			let i = n(r.value, ["worldId", "factory"], ["worldId", "factory"]);
+			if (typeof i.worldId != "string" || typeof i.factory != "function" || !a.host.worlds?.some((e) => e.name === i.worldId) || d.some((e) => e.worldId === i.worldId)) throw new e({ detail: "World ghost cells require unique declared World policies" });
+			d.push(Object.freeze({
+				worldId: i.worldId,
+				factory: i.factory.bind(r.value)
+			}));
+		}
+		if (d.length && !o) throw new e({ detail: "World ghost cell policies require their acquired authenticated gateway" });
+		let p = Object.getOwnPropertyDescriptor(a, "worldBoundaryCells"), m = [];
+		if (p && (!("value" in p) || !Array.isArray(p.value) || Object.getPrototypeOf(p.value) !== Array.prototype || p.value.length > 1024 || Reflect.ownKeys(p.value).length !== p.value.length + 1) || !p && "worldBoundaryCells" in a) throw new e({ detail: "World boundary cells require bounded own policies" });
+		if (p) for (let t = 0; t < p.value.length; t++) {
+			let r = Object.getOwnPropertyDescriptor(p.value, String(t));
+			if (!r?.enumerable || !("value" in r)) throw new e({ detail: "World boundary policy inventory must be dense own data" });
+			let i = n(r.value, ["worldId", "factory"], ["worldId", "factory"]);
+			if (typeof i.worldId != "string" || typeof i.factory != "function" || !a.host.worlds?.some((e) => e.name === i.worldId) || m.some((e) => e.worldId === i.worldId)) throw new e({ detail: "World boundary cells require unique declared World policies" });
+			m.push(Object.freeze({
+				worldId: i.worldId,
+				factory: i.factory.bind(r.value)
+			}));
+		}
+		let _ = u(a.driver);
+		if (typeof a.listener?.bind != "function") throw new e({ detail: "Room listener must provide its bind operation" });
+		let v = a.listener.bind.bind(a.listener), y = Object.freeze({
+			...a,
+			worldBoundaryCells: Object.freeze(m),
+			worldGhostCells: Object.freeze(d),
+			...o ? { worldGhostGateway: a.worldGhostGateway.bind(a) } : {},
+			host: Object.freeze({ ...a.host }),
+			driver: _,
+			gateway: a.gateway === void 0 ? void 0 : Object.freeze({ ...a.gateway }),
+			listener: Object.freeze({ bind: v })
+		}), b;
+		try {
+			b = await s.start(t, i, {
+				...y.host,
+				startSuspended: !0
+			});
+		} catch (e) {
+			throw e instanceof c ? new h("controller", e.retryCleanup, e) : e;
+		}
+		let x;
+		try {
+			x = new f(b, y);
+		} catch (e) {
+			try {
+				await b.close();
+			} catch {}
+			throw new h("driver", () => b.close(), e);
+		}
+		let S = "listener";
+		try {
+			if (y.worldGhostGateway) {
+				let t = y.worldGhostGateway(b);
+				x.ghostGateway = t;
+				let n = r(t, "close", "World ghost gateway requires joined cleanup"), i = r(t, "runDue", "World ghost gateway requires bounded maintenance"), a = r(t, "snapshot", "World ghost gateway requires inventory observation");
+				if (!t.route || t.route.auth !== "token" || t.route.path === x.gateway.path) throw new e({ detail: "World ghost gateway requires a separate authenticated route" });
+				x.ghostGateway = Object.freeze({
+					route: t.route,
+					close: n,
+					runDue: i,
+					snapshot: a
+				});
+			}
+			for (let e of y.worldBoundaryCells) await b.configureWorldBoundaryCells(e.worldId, e.factory);
+			for (let e of y.worldGhostCells) await b.configureWorldGhostCells(e.worldId, e.factory);
+			let t = await v(x.gateway, Object.freeze({
+				ready: () => x.phase === "running",
+				...x.ghostGateway ? { worldGhostGateway: x.ghostGateway.route } : {},
+				onFailure: y.driver.onFailure,
+				live: () => x.phase !== "running" || x.driver.live(),
+				observeMetrics: () => {
+					let e = b.metrics();
+					return {
+						host: b.host.id,
+						region: b.host.region,
+						...b.host.pool === void 0 ? {} : { pool: b.host.pool },
+						loop: e.loop,
+						cells: e.cells,
+						worldBoundaryClamps: e.worldBoundaryClamps,
+						worldHandoffs: e.worldHandoffs,
+						rooms: e.ownedRooms,
+						clients: e.sessions,
+						turn: x.driver.metrics()
+					};
+				}
+			}), x.sessionHost);
+			if (typeof t?.close != "function") throw new e({ detail: "Room listener must return its owned close operation" });
+			if (x.listener = Object.freeze({
+				close: t.close.bind(t),
+				activate: typeof t.activate == "function" ? t.activate.bind(t) : () => {
+					throw new e({ detail: "Room listener has no activation operation" });
+				},
+				stopAdmission: typeof t.stopAdmission == "function" ? t.stopAdmission.bind(t) : async () => {
+					throw new e({ detail: "Room listener has no admission fence" });
+				}
+			}), typeof t.activate != "function" || typeof t.stopAdmission != "function") throw new e({ detail: "Room listener must return its complete owned lifetime" });
+			return S = "driver", y.startSuspended || await x.activate(), x;
+		} catch (e) {
+			e instanceof g && (x.partialListenerCleanup = e.retryCleanup), x.phase = "stopping";
+			try {
+				await x.close();
+			} catch {}
+			throw e instanceof h ? e : new h(S, () => x.close(), e);
+		}
+	}
+	requireRunning() {
+		if (this.phase !== "running") throw new t({ roomId: "host" });
+	}
+	get status() {
+		return this.phase;
+	}
+	activate() {
+		if (this.activation) return this.activation;
+		if (this.phase === "running") return Promise.resolve();
+		if (this.phase !== "binding" || !this.listener) return Promise.reject(new t({ roomId: "host" }));
+		let e = (async () => {
+			let e = "driver";
+			try {
+				if (this.driver.start(), e = "activation", await this.controller.activate(), this.phase !== "binding") throw new t({ roomId: "host" });
+				this.phase = "running", this.listener.activate();
+			} catch (t) {
+				throw this.phase = "stopping", new h(e, () => this.close(), t);
+			}
+		})();
+		return this.activation = e, e.then(() => {
+			this.activation = null;
+		}, () => {
+			this.activation = null;
+		}), e;
+	}
+	drain(t) {
+		if (this.phase === "closed") return Promise.resolve();
+		let n;
+		try {
+			if (n = o(t), this.plannedDrain) {
+				if (n.graceMs !== this.plannedDrain.graceMs || n.maxCheckpointBytes !== this.plannedDrain.maxCheckpointBytes) throw new e({ detail: "Lane drain retry cannot change its retained policy" });
+			} else if (this.phase !== "running" || this.closeTask) throw new e({ detail: "Planned lane drain requires its running owner before terminal shutdown" });
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		if (this.plannedDrain ??= n, this.closeTask) return this.closeTask;
+		this.phase = "stopping";
+		let r = (async () => {
+			this.admissionStopped ||= (await this.listener.stopAdmission(), !0), await this.driver.quiesce(), this.ghostsStopped ||= (await this.ghostGateway?.close(), !0), this.controllerStopped ||= (await this.controller.drain(n), !0), await this.closeListeners(), this.listener = null, this.phase = "closed";
+		})();
+		return this.closeTask = r, r.then(() => {
+			this.closeTask = null;
+		}, () => {
+			this.closeTask = null;
+		}), r;
+	}
+	async closeListeners() {
+		let e = [];
+		if (!this.listenerStopped) try {
+			await this.listener?.close(), this.listenerStopped = !0, this.admissionStopped = !0;
+		} catch (t) {
+			e.push(t);
+		}
+		if (this.partialListenerCleanup) try {
+			await this.partialListenerCleanup(), this.partialListenerCleanup = null;
+		} catch (t) {
+			e.push(t);
+		}
+		if (e.length) throw AggregateError(e, "Room listener cleanup remains incomplete");
+	}
+	close() {
+		if (this.plannedDrain) return this.drain(this.plannedDrain);
+		if (this.phase === "closed") return Promise.resolve();
+		if (this.closeTask) return this.closeTask;
+		this.phase = "stopping";
+		let e = (async () => {
+			try {
+				await this.activation;
+			} catch {}
+			let e = [];
+			if (!this.admissionStopped) try {
+				await this.listener?.stopAdmission(), this.admissionStopped = !0;
+			} catch (t) {
+				e.push(t);
+			}
+			try {
+				await this.driver.quiesce();
+			} catch (t) {
+				e.push(t);
+			}
+			if (!this.ghostsStopped) try {
+				await this.ghostGateway?.close(), this.ghostsStopped = !0;
+			} catch (t) {
+				e.push(t);
+			}
+			if (!this.controllerStopped) try {
+				await this.driver.stop(), this.controllerStopped = !0;
+			} catch (t) {
+				e.push(t);
+			}
+			try {
+				await this.closeListeners();
+			} catch (t) {
+				e.push(t);
+			}
+			if (e.length) throw AggregateError(e, "Room host lane cleanup remains incomplete");
+			this.listener = null, this.phase = "closed";
+		})();
+		return this.closeTask = e, e.then(() => {
+			this.closeTask = null;
+		}, () => {
+			this.closeTask = null;
+		}), e;
+	}
+};
+export { _ as RoomHostLane, h as RoomHostLaneStartFailure, g as RoomHostListenerBindFailure };