@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/hostListener.js

@@ -0,0 +1,78 @@
+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";
+// 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;
+};
+export { l as runtimeRoomHostListener };

package/dist/hostListenerBinding.js

@@ -0,0 +1,18 @@
+import { ProtocolError as e } from "./errors.js";
+import { createHash as t } from "node:crypto";
+// 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" });
+};
+export { o as assertRoomHostListenerDeployment, a as inheritRoomHostListener, i as registerRoomHostListener };

package/dist/hostLoopObservation.js

@@ -0,0 +1,89 @@
+// 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
+		};
+	}
+};
+export { t as RoomHostLoopObservation };

package/dist/hostMetrics.js

@@ -0,0 +1,55 @@
+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";
+// 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
+			};
+		}
+	}
+}));
+export { o as roomHostMetricsRoute };

package/dist/hostRegistryBinding.js

@@ -0,0 +1,417 @@
+import { ProtocolError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { RoomStateCodec as n } from "./stateCodec.js";
+import { roomHostTransportEndpoints as r } from "./transportEndpoints.js";
+import { captureRoomSnapshotBlobs as i } from "./snapshotBlobIndex.js";
+import { dataStoreRoomErasure as a } from "./roomErasure.js";
+import { assertRoomSeatSecrets as o, resolveRoomSeatTokenStrategies as s } from "./seats.js";
+import { captureAdmittedRoomPoolTopology as c, captureRoomPoolCatalog as l, roomPoolHostedNames as u, roomPoolPublicAddress as ee } from "./roomPoolTopology.js";
+import { roomCheckpointsTable as te, roomCommandsTable as ne, roomHostsTable as re, roomLockstepTicksTable as ie, roomSeatsTable as ae, roomSnapshotSegmentsTable as oe, roomSubjectPrivacyTable as se, roomsTable as ce } from "./tables.js";
+import { captureRoomWorldEntitySource as le } from "./worldHostSource.js";
+import { captureRoomHostGeometryBinding as ue } from "./geometryHost.js";
+import { dataStoreRoomDirectory as de } from "./directory.js";
+import { captureRoomHostDriverOptions as fe } from "./hostDriver.js";
+import { runtimeRoomHostListener as d } from "./hostListener.js";
+import { makeRoomControlCarrier as f } from "./controlCarrier.js";
+import { captureRoomHostShutdownPolicy as p } from "./hostShutdown.js";
+import { captureRoomHostDeployment as m } from "./hostDeployment.js";
+import { RoomsHostBindFailure as h } from "./hostBinding.js";
+import { routedRoomHostWithdrawalService as pe } from "./withdrawalPort.js";
+import { forwardedRoomAppCommands as me, roomAppCommandTarget as he } from "./roomAppCommandControl.js";
+import { openRegistryRoomControlClient as ge, openRegistryRoomControlServer as _e } from "./controlRegistry.js";
+import { directoryRoomControlTargetResolver as ve } from "./controlTarget.js";
+import { dataStoreRoomRecovery as ye } from "./recovery.js";
+import { WORLD_DEFAULT_MAX_BYTES as be, defaultHostWorld as xe } from "./worldDefaultBinding.js";
+import { applicationRoomExternalWorkWithdrawal as Se } from "./commandWithdrawal.js";
+import { Effect as g, Option as Ce } from "effect";
+import { ConnectionRegistry as we } from "@voltro/kv/connection";
+import { HotStore as Te, layerRoutedHotRedis as Ee } from "@voltro/kv/hot";
+// src/hostRegistryBinding.ts
+function _(t) {
+	throw new e({ detail: t });
+}
+var v = (e, t) => Number.isSafeInteger(e) && e > 0 && e <= t ? e : _("Invalid registry Rooms host budget"), y = (t) => typeof t.appDependencies == "function" ? t.appDependencies() : Promise.reject(new e({ detail: "Default Rooms host dependencies need the voltro rooms host runner; pass acquire for a custom process" })), b = (b) => {
+	if (!b || b.acquire !== void 0 && typeof b.acquire != "function" || !["single-node", "multi-node"].includes(b.topology) || !/^(redis|nats):[A-Za-z][A-Za-z0-9_-]*$/.test(b.controlConnection) || !/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(b.hotConnection) || !b.host || typeof b.host.clock?.now != "function" || typeof b.host.epochNow != "function" || typeof b.host.measuredCpu != "function" || typeof b.host.address != "string" || !b.host.address.trim() || typeof b.host.region != "string" || !b.host.region.trim() || !b.listener || typeof b.listener != "object" || Array.isArray(b.listener)) return _("Registry Rooms host requires explicit topology, app acquisition, routing and clocks");
+	if (Object.keys(b.host).some((e) => ![
+		"pools",
+		"pool",
+		"clientCapacity",
+		"address",
+		"webTransportAddress",
+		"webTransportCertificateHash",
+		"region",
+		"capacity",
+		"clock",
+		"epochNow",
+		"secrets",
+		"heartbeatTtlMs",
+		"heartbeatEveryMs",
+		"seatTtlMs",
+		"maxQueuedOperations",
+		"lockstepTransport",
+		"snapshotBudget",
+		"snapshotBlobs",
+		"maxInlineBytes",
+		"spectatorGroups",
+		"replayRecordings",
+		"measuredCpu",
+		"strategies"
+	].includes(e)) || Object.keys(b.listener).some((e) => ![
+		"port",
+		"host",
+		"health",
+		"security",
+		"startupTimeoutMs",
+		"onBound",
+		"metricsToken",
+		"metricsPreviousToken"
+	].includes(e))) return _("Registry Rooms host dependencies and listener admission belong to the acquired owner");
+	o(b.host.secrets), o(b.projectControlSecrets);
+	let x = Object.getOwnPropertyDescriptor(b.host, "webTransportAddress"), S = Object.getOwnPropertyDescriptor(b.host, "webTransportCertificateHash");
+	if (x && (!("value" in x) || !x.enumerable) || !x && "webTransportAddress" in b.host || S && (!("value" in S) || !S.enumerable) || !S && "webTransportCertificateHash" in b.host) return _("Registry Rooms host native endpoint requires own routing data");
+	let C = r(b.host.address, x?.value, S?.value);
+	if (b.host.spectatorGroups !== void 0 && typeof b.host.spectatorGroups != "function") return _("Invalid spectator view-group resolver");
+	if (b.host.replayRecordings !== void 0 && typeof b.host.replayRecordings != "function") return _("Invalid replay recording resolver");
+	for (let e of [
+		"pools",
+		"pool",
+		"clientCapacity"
+	]) {
+		let t = Object.getOwnPropertyDescriptor(b.host, e);
+		if (t && (!t.enumerable || !("value" in t)) || !t && e in b.host) return _("Registry host pool selection requires own data");
+	}
+	let w = b.host.pools === void 0 ? void 0 : c(b.host.pools), T = w === void 0 ? void 0 : b.host.pool ?? w.default, E = T === void 0 ? void 0 : w.pools[T];
+	if (w ? !E || !E.regions.includes(b.host.region) : b.host.pool !== void 0 || b.host.clientCapacity !== void 0) return _("Registry host pool or region is not admitted");
+	let D = E?.hot ?? b.hotConnection;
+	if (!/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(D)) return _("Registry host pools require a named Redis Hot Store connection");
+	if ("continueWorldGroups" in b.driver) return _("Registry World continuation must come from the acquired owner");
+	let De = b.acquire ?? y, O = b.topology, k = b.controlConnection, A = b.hotConnection, j = structuredClone(b.projectControlSecrets), M = structuredClone(b.host.secrets), N = b.host.epochNow, Oe = Object.freeze({ now: b.host.clock.now.bind(b.host.clock) }), ke = fe(b.driver), Ae = v(b.maxCheckpointBytes ?? 1048576, 67108864), P = v(b.maxRequestMs ?? 5e3, 6e4), je = v(b.maxReceipts ?? 4096, 65536), Me = v(b.maxInFlight ?? 128, je), Ne = v(b.graceMs, 2 ** 53 - 1), Pe = p({
+		graceMs: Ne,
+		maxCheckpointBytes: Ae,
+		...b.drainMs === void 0 ? {} : { drainMs: b.drainMs }
+	}), F = s(b.host.strategies?.seatToken), I = i(b.host.snapshotBlobs), L = Object.freeze({
+		...b.host,
+		pools: w,
+		pool: T,
+		address: C.ws,
+		webTransportAddress: C.wt,
+		webTransportCertificateHash: C.wtCertificateHash,
+		secrets: M,
+		epochNow: N,
+		clock: Oe,
+		measuredCpu: b.host.measuredCpu,
+		snapshotBudget: b.host.snapshotBudget === void 0 ? void 0 : Object.freeze({ ...b.host.snapshotBudget }),
+		snapshotBlobs: I,
+		strategies: Object.freeze({
+			...b.host.strategies,
+			seatToken: F
+		})
+	}), R = Object.freeze({
+		...b.listener,
+		security: b.listener.security === void 0 ? void 0 : structuredClone(b.listener.security)
+	}), Fe = b.gateway === void 0 ? void 0 : Object.freeze({
+		...b.gateway,
+		limits: b.gateway.limits === void 0 ? void 0 : Object.freeze({ ...b.gateway.limits })
+	});
+	for (let e of [
+		L.capacity,
+		L.heartbeatEveryMs,
+		L.heartbeatTtlMs,
+		L.seatTtlMs,
+		L.maxQueuedOperations ?? 128
+	]) v(e, 2 ** 53 - 1);
+	if (L.heartbeatEveryMs >= L.heartbeatTtlMs) return _("Room host heartbeat cadence must precede its routing TTL");
+	d({
+		...R,
+		readiness: async () => !1
+	});
+	let z = [j.current, ...j.previous ? [j.previous] : []], B = [M.current, ...M.previous ? [M.previous] : []];
+	return z.some((e) => B.some((t) => e.secret === t.secret)) ? _("Room control and seat signing keys must be independent") : async (r) => {
+		if (r.signal.aborted) return _("Registry Rooms host acquisition was cancelled");
+		if (r.pools !== void 0 && w !== void 0 && r.pools !== w) return _("Room pools must have one app-owned declaration");
+		let i = r.pools === void 0 ? w : l(r.pools, r.catalog.inventory().map((e) => e.descriptor.name)), o = r.selection?.pool ?? L.pool ?? i?.default, s = r.selection?.region ?? L.region, c = o === void 0 ? void 0 : i?.pools[o];
+		if (i ? !c || !c.regions.includes(s) : o !== void 0) return _("Registry host process pool or region is not admitted");
+		let p = m(process.env, o, s), v = p === void 0 ? R : Object.freeze({
+			...R,
+			port: p.port,
+			host: p.host,
+			...p.metricsToken === void 0 ? {} : { metricsToken: p.metricsToken },
+			...p.metricsPreviousToken === void 0 ? {} : { metricsPreviousToken: p.metricsPreviousToken }
+		});
+		d({
+			...v,
+			readiness: async () => !1
+		});
+		let y = c?.hot ?? A;
+		if (!/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(y)) return _("Registry host pools require a named Redis Hot Store connection");
+		let b = y, x = Object.freeze({
+			...L,
+			pools: i,
+			pool: o,
+			region: s,
+			capacity: c?.capacity?.rooms ?? L.capacity,
+			clientCapacity: c?.capacity?.clients ?? L.clientCapacity
+		});
+		i && l(i, r.catalog.inventory().map((e) => e.descriptor.name));
+		let S = new Set(u(i, o, r.catalog.inventory().map((e) => e.descriptor.name))), C = Object.freeze(r.worlds.filter((e) => [...e.zones, ...e.instances].some((e) => S.has(e.room)))), T = Object.freeze({
+			...r,
+			hostedRooms: Object.freeze(r.catalog.inventory().filter((e) => S.has(e.descriptor.name))),
+			hostedWorlds: C
+		});
+		f({
+			mount: r.pluginName,
+			projectControlSecrets: j,
+			epochNow: N,
+			maxRequestMs: P
+		});
+		let E;
+		try {
+			E = await De(T);
+		} catch (e) {
+			if (e instanceof h) throw e;
+			return _("Registry Rooms host app acquisition did not complete");
+		}
+		if (typeof E?.release != "function") return _("Registry Rooms host app acquisition must retain cleanup");
+		let D = E.release.bind(E), F = !1, z = null, B = () => {
+			if (F) return Promise.resolve();
+			if (z) return z;
+			let e = Promise.resolve().then(D).then(() => {
+				F = !0;
+			});
+			return z = e, e.then(() => {
+				z = null;
+			}, () => {
+				z = null;
+			}), e;
+		};
+		try {
+			let l = E.store, u = E.registry, f = Object.freeze({ ...E.instance }), m = E.runEffect;
+			if (!l || typeof l.query != "function" || typeof l.transactional != "function" || !u || typeof u.validate != "function" || typeof u.config != "function" || typeof u.probe != "function" || typeof u.pubsub != "function" || typeof m != "function" || typeof E.membership?.list != "function" || typeof E.resolveSeatSubject != "function" || typeof E.resolveControlSubject != "function" || E.application !== void 0 && typeof E.application.deliver != "function" || typeof E.readiness != "function" || typeof f.instanceId != "string" || !f.instanceId.trim() || f.instanceId.length > 191 || !Number.isSafeInteger(f.startedAt) || f.startedAt < 0) return _("Registry Rooms host app dependencies are incomplete");
+			let h = ee(i, o, s, f.instanceId, x.address);
+			if (p?.publicAddress !== void 0 && c?.publicAddress !== void 0 && p.publicAddress !== h) return _("Deployment public routing conflicts with the app pool address");
+			let y = p?.publicAddress ?? h, S = Object.freeze({ list: E.membership.list.bind(E.membership) }), w = E.resolveSeatSubject, D = E.resolveControlSubject, De = E.readiness, A, F = E.application, L = Object.freeze(F ? { deliver: F.deliver.bind(F) } : me({ deliver: (t) => A ? A.commands.deliver(t) : g.fail(new e({ detail: "Room app commands wait for the control client" })) })), R = Object.getOwnPropertyDescriptor(E, "erasure");
+			if (R && !("value" in R) || !R && "erasure" in E) return _("Registry Rooms erasure requires an own actual capability");
+			let z = R?.value === void 0 ? void 0 : t(R.value, ["erase"], ["erase"]);
+			if (z && typeof z.erase != "function") return _("Registry Rooms erasure capability is incomplete");
+			let Ie = z ? Object.freeze({ erase: z.erase.bind(R?.value) }) : void 0, V = Object.getOwnPropertyDescriptor(E, "lockstepPorts");
+			if (V && !("value" in V) || !V && "lockstepPorts" in E) return _("Registry Lockstep factories require own configuration");
+			let Le = V?.value === void 0 ? {} : t(V.value, [
+				"lockstepAdmission",
+				"lockstepJournal",
+				"lockstepTerminal"
+			], []);
+			if (Object.values(Le).some((e) => typeof e != "function")) return _("Registry Lockstep replacement factory is incomplete");
+			let H = Object.getOwnPropertyDescriptor(E, "worldEntities");
+			if (H && !("value" in H) || !H && "worldEntities" in E) return _("Registry World recovery requires an own capability");
+			let Re = H?.value, U = Re === void 0 ? void 0 : le(Re), W = Object.getOwnPropertyDescriptor(E, "resolveWorldPlayer");
+			if (W && (!("value" in W) || typeof W.value != "function") || !W && "resolveWorldPlayer" in E) return _("Registry World player selection requires an own acquired callback");
+			let ze = W === void 0 ? void 0 : W.value.bind(E);
+			if (ze && !U?.admitActorPlayer) return _("Registry World player selection requires actual entity admission");
+			let G = Object.getOwnPropertyDescriptor(E, "worldGroups");
+			if (G && !("value" in G) || !G && "worldGroups" in E) return _("Registry World supervision requires an own acquired capability");
+			let K = G === void 0 ? void 0 : t(G.value, ["runDue"], ["runDue"]);
+			if (K && typeof K.runDue != "function") return _("Registry World supervision requires actual bounded continuation");
+			let Be = K ? K.runDue.bind(G.value) : void 0, q = Object.getOwnPropertyDescriptor(E, "worldInstanceExpiry");
+			if (q && !("value" in q) || !q && "worldInstanceExpiry" in E) return _("Registry instance expiry requires an own acquired capability");
+			let J = q === void 0 ? void 0 : t(q.value, ["runDue"], ["runDue"]);
+			if (J && (typeof J.runDue != "function" || !U || !C.some((e) => e.instances.length))) return _("Registry instance expiry requires actual entity authority and instance declarations");
+			let Ve = J ? J.runDue.bind(q.value) : void 0, He = Be || Ve ? fe({
+				...ke,
+				continueWorldGroups: async () => {
+					let t = [];
+					if (Be) try {
+						let t = Be();
+						if (!g.isEffect(t)) throw new e({ detail: "World supervision requires an actual Effect" });
+						await m(t);
+					} catch (e) {
+						t.push(e);
+					}
+					if (Ve) try {
+						let t = Ve();
+						if (!g.isEffect(t)) throw new e({ detail: "Instance expiry supervision requires an actual Effect" });
+						let n = await m(t);
+						if (n.deferred.length || n.blocked) throw new e({ detail: "Instance expiry has deferred or explicitly blocked work" });
+					} catch (e) {
+						t.push(e);
+					}
+					if (t.length) throw AggregateError(t, "World group/instance continuations remain incomplete");
+				}
+			}) : ke, Y = Object.getOwnPropertyDescriptor(E, "geometry");
+			if (Y && !("value" in Y) || !Y && "geometry" in E) return _("Registry geometry requires an own actual Host capability");
+			let X = ue(Y?.value);
+			if (C.some((e) => e.geometry) && !X) return _("Configured World geometry requires actual complete Host preparation");
+			if (X && (X.worlds.length !== C.length || X.worlds.some((e, t) => e !== C[t]))) return _("Registry geometry must bind the exact admitted World catalogue");
+			let Z = () => {
+				if (r.signal.aborted) return _("Registry Rooms host acquisition was cancelled");
+			};
+			Z();
+			for (let e of [b, k]) {
+				let t = await m(u.validate(e));
+				if (Z(), t.reference !== e || t.tenantScoped) return _("Registry Rooms host needs shared declared connections");
+			}
+			let Ue = await m(u.config(b));
+			if (Z(), O === "multi-node" && Ue.driver === "memory") return _("Multi-node Rooms host requires Redis; memory hot data cannot boot");
+			let We = await m(Te.pipe(g.provide(Ee({
+				consumer: r.pluginName,
+				connection: b
+			})), g.provideService(we, u)));
+			if (Z(), We.capabilities.atomicMulti !== !0 || O === "multi-node" && We.capabilities.crossNode !== !0) return _("Room host HotStore capabilities do not satisfy its topology");
+			await m(u.probe(b)), Z(), k !== b && (await m(u.probe(k)), Z());
+			for (let e of [
+				re,
+				ce,
+				ae,
+				te,
+				ne,
+				oe,
+				se,
+				ie
+			]) await l.query({
+				table: e.tableName,
+				predicate: void 0,
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["id"]
+			}), Z();
+			let Ge = ye(l, {
+				pools: i,
+				membership: S,
+				observerNow: Oe.now,
+				epochNow: N,
+				heartbeatEveryMs: x.heartbeatEveryMs,
+				hostHeartbeatTtlMs: x.heartbeatTtlMs,
+				graceMs: Ne,
+				maxCheckpointBytes: Ae,
+				snapshotCodec: (e) => new n(r.catalog.get(e).state),
+				...I === void 0 ? {} : { snapshotBlobs: I }
+			}), Ke, Q, qe = T.hostedRooms.some((e) => e.descriptor.mode === "lockstep"), Je = pe({
+				local: () => Ke,
+				peers: () => Q?.withdrawal
+			}), Ye = Ie ?? (qe ? a(l, {
+				epochNow: N,
+				owner: Je,
+				external: Se(l, {
+					run: {},
+					publish: {}
+				}),
+				invalidateDirectory: () => g.void,
+				...I === void 0 ? {} : { snapshotBlobs: I }
+			}) : void 0), Xe = de(l, {
+				pools: i,
+				epochNow: N,
+				heartbeatTtlMs: x.heartbeatTtlMs
+			}), $ = C.length && Re === void 0 && r.worldState === "transitions" ? xe({
+				store: l,
+				worlds: C,
+				catalog: r.catalog,
+				controller: () => Ke,
+				peers: () => Q?.world,
+				ownership: Xe.observeOwnership.bind(Xe),
+				hot: We,
+				resolveSubject: D,
+				epochNow: N,
+				signing: {
+					secrets: M,
+					seatTtlMs: x.seatTtlMs,
+					graceMs: Ne,
+					hostHeartbeatTtlMs: x.heartbeatTtlMs
+				}
+			}) : void 0, Ze = $ === void 0 ? {} : {
+				worldEntities: le($.worldEntities),
+				resolveWorldPlayer: $.resolveWorldPlayer,
+				worldSnapshotMaxBytes: be,
+				worldGhostMaxConnections: 64
+			}, Qe = qe && Ie === void 0 && O === "multi-node" || $ !== void 0, $e = F === void 0, et = !1;
+			return Object.freeze({
+				store: l,
+				shutdown: Pe,
+				options: Object.freeze({
+					host: Object.freeze({
+						...x,
+						worlds: C,
+						address: y,
+						membership: f,
+						resolveSubject: w,
+						application: L,
+						...U ? { worldEntities: U } : {},
+						...ze ? { resolveWorldPlayer: ze } : {},
+						...Ze,
+						...X ? { geometry: X } : {},
+						ports: Object.freeze({
+							recovery: Ge,
+							...Le,
+							...Ye === void 0 ? {} : { erasure: Ye }
+						})
+					}),
+					driver: He,
+					listener: d({
+						...v,
+						readiness: De
+					}),
+					...Fe === void 0 ? {} : { gateway: Fe }
+				}),
+				openControl: async (t, n) => {
+					if (n !== r || et || t.status !== "binding" || t.controller.store !== l || t.controller.host.membership?.instanceId !== f.instanceId || t.controller.host.membership.startedAt !== f.startedAt) return _("Registry Rooms control requires its exact suspended owner");
+					Z(), et = !0, Ke = t.controller;
+					let a = await m(_e(u, t.controller, {
+						connection: k,
+						mount: r.pluginName,
+						projectControlSecrets: j,
+						epochNow: N,
+						maxRequestMs: P,
+						maxReceipts: je,
+						maxInFlight: Me,
+						resolveSubject: D,
+						onUnavailable: () => t.driver.options.onFailure(new e({ detail: "Room host control transport is unavailable" })),
+						...$ === void 0 ? {} : { worldSteps: $.worldSteps }
+					}));
+					if (!Qe && !$e) return a;
+					let o;
+					try {
+						let t = de(l, {
+							pools: i,
+							epochNow: N,
+							heartbeatTtlMs: x.heartbeatTtlMs
+						}), n = ve(t, S, s, i === void 0 ? void 0 : {
+							store: l,
+							pools: i
+						});
+						o = await m(ge(u, {
+							connection: k,
+							mount: r.pluginName,
+							projectControlSecrets: j,
+							epochNow: N,
+							maxRequestMs: P,
+							catalog: r.catalog,
+							resolveTarget: (t) => t === "app-commands" ? Ce.match(he(S.list()), {
+								onNone: () => g.fail(new e({ detail: "No API instance runs Room app commands" })),
+								onSome: g.succeed
+							}) : n(t)
+						}));
+					} catch (e) {
+						throw a.fence(), await a.close(), e;
+					}
+					return Qe && (Q = o), $e && (A = o), Object.freeze({
+						fence: () => {
+							o.fence(), a.fence();
+						},
+						close: async () => {
+							let e = (await Promise.allSettled([o.close(), a.close()])).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+							if (e.length) throw AggregateError(e, "Room host control did not close");
+						}
+					});
+				},
+				release: B
+			});
+		} catch {
+			try {
+				await B();
+			} catch {
+				throw new h(B);
+			}
+			throw new e({ detail: "Registry Rooms host preflight did not complete" });
+		}
+	};
+};
+export { y as defaultRoomsHostAcquire, b as registryRoomsHostBinder };