@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/hostLane.js

@@ -0,0 +1,288 @@
+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";
+//#region 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;
+	}
+};
+//#endregion
+export { _ as RoomHostLane, h as RoomHostLaneStartFailure, g as RoomHostListenerBindFailure };

package/dist/hostListener.js

@@ -0,0 +1,79 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomHostListenerBindFailure as t } from "./hostLane.js";
+import { registerRoomHostListener as n } from "./hostListenerBinding.js";
+import { roomHostMetricsRoute as r } from "./hostMetrics.js";
+import { Layer as i } from "effect";
+import { awaitServerListening as a, bindBootListener as o, startRpcServer as s } from "@voltro/runtime";
+import { RpcGroup as c } from "effect/rpc";
+//#region src/hostListener.ts
+var l = (l) => {
+	let u = Object.freeze({ ...l }), d = u.startupTimeoutMs ?? 1e4;
+	if (u.listener !== void 0 && u.port !== void 0 || u.listener === void 0 && (u.port === void 0 || !Number.isSafeInteger(u.port) || u.port < 0 || u.port > 65535) || !Number.isSafeInteger(d) || d < 1 || d > 2147483647 || typeof u.readiness != "function") throw new e({ detail: "Invalid Room listener configuration" });
+	let f, p = u.metricsToken === void 0 ? void 0 : r(u.metricsToken, () => {
+		if (!f) throw Error("Room metrics owner is unavailable");
+		return f();
+	}, u.metricsPreviousToken), m = !1, h = Object.freeze({ bind: async (n, r) => {
+		if (m) throw new e({ detail: "A Room listener port owns exactly one bind" });
+		m = !0, f = r.observeMetrics;
+		let l = null, h = null, g = !1, _ = null, v = [], y = () => {
+			if (g) return Promise.resolve();
+			if (_) return _;
+			let e = (async () => {
+				h ? await h.shutdown() : await l?.close();
+				for (let e of v) e();
+				v.length = 0, g = !0, h = null, l = null, f = void 0;
+			})();
+			return _ = e, e.then(() => {
+				_ = null;
+			}, () => {
+				_ = null;
+			}), e;
+		};
+		try {
+			if (l = u.listener ?? await o({
+				port: u.port,
+				...u.host === void 0 ? {} : { host: u.host },
+				...u.health === void 0 ? {} : { health: u.health }
+			}), p && !f) throw new e({ detail: "Room metrics require the actual host observation owner" });
+			if (typeof r.live != "function") throw new e({ detail: "Room listener requires the actual host progress watchdog" });
+			let t = r.live.bind(r);
+			v.push(l.addLivenessGate("rooms-host", t)), v.push(l.addReadinessGate("rooms-host", () => r.ready() && t())), l.setDependencyPing(async () => r.ready() && await u.readiness()), u.onBound?.(l.port);
+			let m = c.make();
+			return h = s({
+				group: m,
+				handlersLayer: i.empty,
+				listener: l,
+				webSocketGateways: [n, ...r.worldGhostGateway ? [r.worldGhostGateway] : []],
+				...p === void 0 ? {} : { httpRoutes: [p] },
+				...u.security === void 0 ? {} : { security: u.security }
+			}), await a(h.server, d), Object.freeze({
+				activate: () => {
+					if (g || _ || !l || !r.ready()) throw new e({ detail: "Room listener activation was fenced" });
+					l.set({ phase: "ready" });
+				},
+				stopAdmission: async () => {
+					l?.set({
+						phase: "error",
+						error: "Room host is stopping"
+					});
+				},
+				close: y
+			});
+		} catch {
+			try {
+				await y();
+			} catch {
+				throw new t(y);
+			}
+			throw new e({ detail: "Room listener could not bind its native gateway" });
+		}
+	} });
+	return n(h, {
+		port: u.listener?.port ?? u.port,
+		host: u.host,
+		metricsToken: u.metricsToken,
+		metricsPreviousToken: u.metricsPreviousToken
+	}), h;
+};
+//#endregion
+export { l as runtimeRoomHostListener };

package/dist/hostListenerBinding.js

@@ -0,0 +1,19 @@
+import { ProtocolError as e } from "./errors.js";
+import { createHash as t } from "node:crypto";
+//#region src/hostListenerBinding.ts
+var n = /* @__PURE__ */ new WeakMap(), r = (e) => t("sha256").update(e).digest("hex"), i = (e, t) => {
+	n.set(e, Object.freeze({
+		port: t.port,
+		host: t.host,
+		...t.metricsToken === void 0 ? {} : { metricsDigest: r(t.metricsToken) },
+		...t.metricsPreviousToken === void 0 ? {} : { metricsPreviousDigest: r(t.metricsPreviousToken) }
+	}));
+}, a = (e, t) => {
+	let r = n.get(t);
+	r && n.set(e, r);
+}, o = (t, i) => {
+	let a = n.get(t);
+	if (!a || a.port !== i.port || a.host !== i.host || i.metricsToken !== void 0 && a.metricsDigest !== r(i.metricsToken) || a.metricsPreviousDigest !== (i.metricsPreviousToken === void 0 ? void 0 : r(i.metricsPreviousToken))) throw new e({ detail: "Room host provider did not apply its deployment to an owned runtime listener" });
+};
+//#endregion
+export { o as assertRoomHostListenerDeployment, a as inheritRoomHostListener, i as registerRoomHostListener };

package/dist/hostLoopObservation.js

@@ -0,0 +1,90 @@
+//#region src/hostLoopObservation.ts
+var e = () => {
+	let e = performance.eventLoopUtilization;
+	if (typeof e != "function") throw Error("Event-loop utilization is unavailable");
+	return e.call(performance);
+}, t = class {
+	now;
+	eventLoop;
+	buckets = /* @__PURE__ */ new Map();
+	last = 0;
+	started;
+	errors = 0;
+	active = !1;
+	loopReadings = /* @__PURE__ */ new Map();
+	constructor(t = () => performance.now(), n = e) {
+		this.now = t, this.eventLoop = n, this.started = this.read() ?? 0, this.sampleEventLoop(this.started);
+	}
+	sampleEventLoop(e) {
+		let t = Math.floor(e / 1e3);
+		if (!this.loopReadings.has(t)) {
+			try {
+				let { idle: e, active: n } = this.eventLoop();
+				Number.isFinite(e) && Number.isFinite(n) && e >= 0 && n >= 0 && this.loopReadings.set(t, {
+					idle: e,
+					active: n
+				});
+			} catch {}
+			for (let e of this.loopReadings.keys()) e < t - 61 && this.loopReadings.delete(e);
+		}
+	}
+	eventLoopShare(e) {
+		let t = Math.floor(e / 1e3), n, r;
+		for (let e of this.loopReadings.keys()) e <= t && (n === void 0 || e > n) && (n = e), (r === void 0 || e > r) && (r = e);
+		if (n === void 0 || r === void 0 || r <= n) return null;
+		let i = this.loopReadings.get(n), a = this.loopReadings.get(r), o = a.active - i.active, s = o + a.idle - i.idle;
+		return s > 0 && o >= 0 ? Math.min(1, o / s) : null;
+	}
+	read() {
+		try {
+			let e = this.now();
+			if (!Number.isFinite(e) || e < this.last || e < 0) {
+				this.errors++;
+				return;
+			}
+			return this.last = e, e;
+		} catch {
+			this.errors++;
+			return;
+		}
+	}
+	prune(e) {
+		let t = Math.floor(e / 1e3) - 60;
+		for (let e of this.buckets.keys()) e < t && this.buckets.delete(e);
+	}
+	measure(e) {
+		if (this.active) return e();
+		this.active = !0;
+		let t = this.read();
+		try {
+			return e();
+		} finally {
+			let e = this.read();
+			if (this.active = !1, e !== void 0 && (this.prune(e), this.sampleEventLoop(e), t !== void 0 && e > t)) {
+				let n = Math.max(t, (Math.floor(e / 1e3) - 60) * 1e3);
+				for (; n < e;) {
+					let t = Math.floor(n / 1e3), r = Math.min(e, (t + 1) * 1e3);
+					this.buckets.set(t, (this.buckets.get(t) ?? 0) + r - n), n = r;
+				}
+			}
+		}
+	}
+	snapshot() {
+		let e = this.read() ?? this.last;
+		this.prune(e), this.sampleEventLoop(e);
+		let t = Math.floor(e / 1e3) * 1e3, n = Math.max(0, t - 6e4), r = 0;
+		for (let [e, i] of this.buckets) e * 1e3 >= n && e * 1e3 < t && (r += i);
+		let i = this.errors === 0 && t - this.started >= 6e4 && !this.active;
+		return {
+			from: n,
+			until: t,
+			coverage: this.errors > 0 ? "invalid" : i ? "complete" : "warming-up",
+			tickSeconds: r / 1e3,
+			loopUtilization: i ? r / 6e4 : null,
+			eventLoopUtilization: i ? this.eventLoopShare(n) : null,
+			clockErrors: this.errors
+		};
+	}
+};
+//#endregion
+export { t as RoomHostLoopObservation };

package/dist/hostMetrics.js

@@ -0,0 +1,56 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldHandoffMetrics as t, worldHandoffDurationBuckets as n } from "./worldHandoffMetrics.js";
+import { bearerMatches as r } from "@voltro/protocol/session";
+//#region src/hostMetrics.ts
+var i = (e) => e.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n"), a = (t) => {
+	if (typeof t != "string" || t.length < 32 || t.length > 512 || /[^A-Za-z0-9_-]/.test(t)) throw new e({ detail: "Room host metrics require a project-owned base64url credential of 32–512 characters" });
+}, o = (e, o, s) => (a(e), s !== void 0 && a(s), Object.freeze({
+	method: "GET",
+	path: "/_voltro/rooms/metrics",
+	match: "exact",
+	handle: async (a) => {
+		let c = a.headers.authorization, l = { "Cache-Control": "no-store" };
+		if (typeof c != "string" || c.length > 519 || !c.startsWith("Bearer ") || !r("rooms-metrics", c.slice(7), e, s)) return {
+			status: 401,
+			headers: {
+				...l,
+				"WWW-Authenticate": "Bearer"
+			}
+		};
+		try {
+			let e = o(), r = `host="${i(e.host)}",region="${i(e.region)}"${e.pool === void 0 ? "" : `,pool="${i(e.pool)}"`}`, a = e.loop.coverage === "complete" && e.loop.loopUtilization !== null && Number.isFinite(e.loop.loopUtilization) && e.loop.loopUtilization >= 0 && e.loop.loopUtilization <= 1, s = [
+				"# HELP rooms_host_loop_observation_complete Whether a complete rolling 60 second tick window is available.",
+				"# TYPE rooms_host_loop_observation_complete gauge",
+				`rooms_host_loop_observation_complete{${r}} ${+!!a}`
+			];
+			a && s.push("# HELP rooms_host_loop_utilization Fraction of the rolling 60 second window spent in synchronous host ticks.", "# TYPE rooms_host_loop_utilization gauge", `rooms_host_loop_utilization{${r}} ${e.loop.loopUtilization}`);
+			let c = e.loop.eventLoopUtilization;
+			a && typeof c == "number" && Number.isFinite(c) && c >= 0 && c <= 1 && s.push("# HELP rooms_host_event_loop_utilization Fraction of the rolling 60 second window the event loop was busy: ticks, networking, encoding and storage callbacks.", "# TYPE rooms_host_event_loop_utilization gauge", `rooms_host_event_loop_utilization{${r}} ${c}`), typeof e.turn?.saturated == "boolean" && s.push("# HELP rooms_host_saturated Host driver exceeded its configured turn cadence within the last 60 seconds, including awaited work.", "# TYPE rooms_host_saturated gauge", `rooms_host_saturated{${r}} ${+!!e.turn.saturated}`);
+			let u = (e) => typeof e == "number" && Number.isSafeInteger(e) && e >= 0;
+			u(e.rooms) && s.push("# HELP rooms_host_rooms Rooms owned by this host, as its directory heartbeat reports them.", "# TYPE rooms_host_rooms gauge", `rooms_host_rooms{${r}} ${e.rooms}`), u(e.clients) && s.push("# HELP rooms_host_clients Client sessions served by this host, as its directory heartbeat reports them.", "# TYPE rooms_host_clients gauge", `rooms_host_clients{${r}} ${e.clients}`), typeof e.cells == "number" && Number.isSafeInteger(e.cells) && e.cells >= 0 && s.push("# HELP rooms_host_cells Confirmed live SQL World cells held by the local host and epoch, observed less than five seconds ago.", "# TYPE rooms_host_cells gauge", `rooms_host_cells{${r}} ${e.cells}`), typeof e.worldBoundaryClamps == "number" && Number.isSafeInteger(e.worldBoundaryClamps) && e.worldBoundaryClamps >= 0 && s.push("# HELP world_boundary_clamps_total Published source-cell movement corrections observed during this Host process lifetime.", "# TYPE world_boundary_clamps_total counter", `world_boundary_clamps_total{${r}} ${e.worldBoundaryClamps}`);
+			let d = t(e.worldHandoffs);
+			if (d) {
+				s.push("# HELP world_handoffs_total New seamless SQL terminal changes acknowledged during this source lifetime; excludes replay and unacknowledged outcomes.", "# TYPE world_handoffs_total counter", "# HELP world_handoff_duration_ms Time from transition creation to acknowledged seamless terminal SQL change.", "# TYPE world_handoff_duration_ms histogram");
+				for (let e of d.results) {
+					let t = `${r},result="${e.result}"`;
+					s.push(`world_handoffs_total{${t}} ${e.count}`);
+					for (let r = 0; r < n.length; r++) s.push(`world_handoff_duration_ms_bucket{${t},le="${n[r]}"} ${e.buckets[r]}`);
+					s.push(`world_handoff_duration_ms_bucket{${t},le="+Inf"} ${e.count}`, `world_handoff_duration_ms_sum{${t}} ${e.durationMs}`, `world_handoff_duration_ms_count{${t}} ${e.count}`);
+				}
+			}
+			return {
+				status: 200,
+				headers: l,
+				contentType: "text/plain; version=0.0.4; charset=utf-8",
+				body: `${s.join("\n")}\n`
+			};
+		} catch {
+			return {
+				status: 503,
+				headers: l
+			};
+		}
+	}
+}));
+//#endregion
+export { o as roomHostMetricsRoute };