@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/runtime.js

@@ -0,0 +1,1123 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n, RoomForbidden as r, RoomGone as i, RoomHibernatePending as a } from "./errors.js";
+import { simulationOwnData as o } from "./simulationAuthoring.js";
+import { applyRoomPoolRuntimeDefaults as s } from "./roomPoolRuntimeDefaults.js";
+import { captureRoomListing as c } from "./room.js";
+import { RoomInputCodec as l, RoomStateCodec as u } from "./stateCodec.js";
+import { GeometryManifestFragmentSchema as d } from "./geometryManifestChannel.js";
+import { GeometryDeltaFragmentSchema as f } from "./geometryChannel.js";
+import { GeometryEditMessageSchema as p } from "./geometryEditChannel.js";
+import { canonicalRoomJson as m } from "./checkpointJson.js";
+import "./ports.js";
+import { captureLockstepJournalScope as h } from "./lockstepJournalCodec.js";
+import { captureRoomSessionAdmissionEvidence as g } from "./sessionAdmission.js";
+import { RoomServerSession as _ } from "./serverSession.js";
+import { RoomHostLoopObservation as v } from "./hostLoopObservation.js";
+import { GeometryChunkRequestSchema as y, GeometryChunkSnapshotFragmentSchema as b } from "./geometrySnapshotChannel.js";
+import { RoomActor as x } from "./actor.js";
+import { RoomHost as S } from "./host.js";
+import { captureRoomSnapshotBudget as C, defaultRoomSnapshotBudget as w } from "./snapshotBudget.js";
+import { RoomSpectatorProducer as T } from "./spectatorProducer.js";
+import { activateRoomGeometryChange as E, activateRoomGeometryVersion as D, bindRoomGeometryEditorPoints as O, captureRoomGeometryResource as k, currentRoomGeometryMutations as A, currentRoomGeometryStreams as j, fenceRoomGeometryMutations as M, fenceRoomGeometryStreams as N, openRoomGeometryMutations as P, openRoomGeometryStreams as F, pumpRoomGeometryMutations as I, pumpRoomGeometryStreams as L } from "./geometryHost.js";
+import { isRoomLockstepOwnedRoom as R } from "./lockstepOwnedRoom.js";
+import { Effect as z, Result as B, Schema as V } from "effect";
+import { createHash as H } from "node:crypto";
+//#region src/runtime.ts
+var U = (e) => H("sha256").update(e.bytes).update(m({
+	schemaHash: e.schemaHash,
+	schedules: e.schedules,
+	...e.worldReceipts === void 0 ? {} : { worldReceipts: e.worldReceipts },
+	inputReceipts: e.inputReceipts,
+	commandCursor: e.commandCursor
+})).digest("hex"), W = (e) => {
+	let { bytes: t, ...n } = e;
+	return t.byteLength + Buffer.byteLength(m(n));
+}, G = class {
+	capacity;
+	clock;
+	checkpoints;
+	host;
+	loopObservation = new v();
+	rooms = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	heldPublication = /* @__PURE__ */ new Set();
+	terminal = /* @__PURE__ */ new Map();
+	withdrawn = /* @__PURE__ */ new Map();
+	drains = /* @__PURE__ */ new Map();
+	migrationNotified = /* @__PURE__ */ new WeakSet();
+	turning = !1;
+	closed = !1;
+	checkpointCommits = 0;
+	checkpointStateBytes = 0;
+	unchangedSnapshotsSkipped = 0;
+	poolDefaults;
+	snapshotBudget;
+	lastPeriodicRoom = null;
+	constructor(e, n, r, i = {}) {
+		if (this.capacity = e, this.clock = n, this.checkpoints = r, !i || typeof i != "object" || Array.isArray(i) || Object.keys(i).some((e) => ![
+			"snapshotBudget",
+			"snapshotBudgetFactory",
+			"poolDefaults"
+		].includes(e))) throw new t({ detail: "Invalid implemented Room runtime snapshot options" });
+		let a = i.poolDefaults === void 0 ? void 0 : o(i.poolDefaults, [
+			"maxCatchUpTicks",
+			"snapshotEveryMs",
+			"hibernate"
+		], [
+			"maxCatchUpTicks",
+			"snapshotEveryMs",
+			"hibernate"
+		]);
+		if (a && (!Number.isSafeInteger(a.maxCatchUpTicks) || a.maxCatchUpTicks < 1 || a.maxCatchUpTicks > 128 || !Number.isSafeInteger(a.snapshotEveryMs) || a.snapshotEveryMs < 1 || a.snapshotEveryMs > 2147483647 || typeof a.hibernate != "boolean")) throw new t({ detail: "Invalid pool runtime defaults" });
+		this.poolDefaults = a === void 0 ? void 0 : Object.freeze({ ...a }), this.snapshotBudget = C(i.snapshotBudgetFactory ?? w, i.snapshotBudget ?? {}), this.host = new S(e);
+	}
+	create(e, t, r, i, a, o, s) {
+		if (this.assertAdmission(e), !r.initialState) throw new n({
+			room: r.name,
+			detail: "Room creation requires author-owned initialState"
+		});
+		let c = V.decodeUnknownSync(r.options)(i), l = r.initialState(structuredClone(c));
+		return this.add(e, t, r, l, c, {
+			epoch: a,
+			commandCursor: 0,
+			revision: 0
+		}, o, s);
+	}
+	add(e, r, i, a, o, m, h, g) {
+		if (this.assertAdmission(e), m.worldRecoveryEpoch !== void 0 && (!m.publicationHeld || !i.world || !Number.isSafeInteger(m.worldRecoveryEpoch) || m.worldRecoveryEpoch < 1 || m.worldRecoveryEpoch > m.epoch)) throw new t({ detail: "World recovery baseline requires a held World actor and a retained prior epoch" });
+		if (!Number.isSafeInteger(m.revision) || m.revision < 0 || m.epoch < 1) throw new n({
+			room: e,
+			detail: "Runtime requires a durable positive ownership epoch and checkpoint revision"
+		});
+		i = s(i, this.poolDefaults);
+		let v = new u(i.state);
+		if (g.spectatorGroup && g.spectatorHistory) throw new t({ detail: "Choose one owned spectator group or explicit borrowed history" });
+		if (i.spectator && !g.spectatorGroup && !g.spectatorHistory) throw new t({ detail: "Configured spectator history requires an actual host view group" });
+		if (g.spectatorGroup && !i.spectator) throw new t({ detail: "Spectator group requires an explicit descriptor policy" });
+		if (g.replayRecording && (!g.spectatorGroup || !i.spectator)) throw new t({ detail: "Host replay recording requires its owned spectator producer and descriptor policy" });
+		if (i.spectator && g.spectatorHistory && Object.entries(i.spectator).some(([e, t]) => g.spectatorHistory?.history.limits[e] !== t)) throw new t({ detail: "Borrowed spectator history does not preserve the descriptor policy" });
+		let S = i.spectator && g.spectatorGroup ? new T(i.state, {
+			roomId: e,
+			tenantId: r,
+			name: i.name,
+			epoch: m.epoch
+		}, g.spectatorGroup, i.spectator, g.replayRecording) : void 0, C = {
+			...g,
+			spectatorHistory: S?.history ?? g.spectatorHistory
+		};
+		delete C.geometry;
+		let w = g.geometry ? k(g.geometry, {
+			roomId: e,
+			tenantId: r,
+			hostId: g.geometry.scope.hostId,
+			epoch: m.epoch,
+			name: i.name
+		}) : void 0, R = /* @__PURE__ */ new Set(), V = w ? P(w, () => [...R]) : void 0, H = w ? F(w, () => [...R]) : void 0, U = (e, n) => {
+			if (e?.channel !== V?.channel || e?.publicationChannel !== V?.publicationChannel || n?.channel !== H?.channel || n?.recovery?.requestChannel !== H?.recovery?.requestChannel || n?.recovery?.responseChannel !== H?.recovery?.responseChannel) throw new t({ detail: "Reloaded geometry graph must preserve its compiled Room channel identities" });
+			if (e) {
+				let n = i.messages[e.channel], r = i.messages[e.publicationChannel];
+				if (!n || !r || !n.reliable || !r.reliable || n.direction !== "client" || r.direction !== "server" || new l(n.schema).schemaHash !== new l(p).schemaHash || new l(r.schema).schemaHash !== new l(f).schemaHash) throw new t({ detail: "Host geometry mutations require both actual reliable compiled intention and delta channels" });
+			}
+			if (n) {
+				let e = i.messages[n.channel];
+				if (!e || !e.reliable || e.direction !== "server" || new l(e.schema).schemaHash !== new l(d).schemaHash) throw new t({ detail: "Host geometry streams require the actual reliable compiled metadata channel" });
+			}
+			if (n?.recovery) {
+				let r = i.messages[n.recovery.requestChannel], a = i.messages[n.recovery.responseChannel], o = [
+					n.channel,
+					n.recovery.requestChannel,
+					n.recovery.responseChannel,
+					...e ? [e.channel, e.publicationChannel] : []
+				];
+				if (new Set(o).size !== o.length || !r || !a || !r.reliable || !a.reliable || r.direction !== "client" || a.direction !== "server" || new l(r.schema).schemaHash !== new l(y).schemaHash || new l(a.schema).schemaHash !== new l(b).schemaHash) throw new t({ detail: "Host geometry recovery needs distinct actual compiled readonly request/reply channels" });
+			}
+		};
+		U(V, H);
+		let W = new x(e, i, a, o, this.clock, r, m, w?.view);
+		w && O(w, (e) => W.worldEntityPoint(e));
+		let G = null, K = !1, q = {
+			mode: "state-sync",
+			id: e,
+			tenantId: r,
+			epoch: m.epoch,
+			revision: m.revision,
+			sendInterval: 1e3 / i.sendRate,
+			maxSessions: i.maxClients,
+			nextSendAt: this.clock.now(),
+			sessions: R,
+			hibernateOnEmpty: i.autoDispose.hibernate,
+			snapshotEveryMs: i.snapshot.everyMs,
+			onlyIfChanged: i.snapshot.onlyIfChanged,
+			snapshotEncoding: Object.freeze({
+				mode: i.snapshot.mode,
+				fullEvery: i.snapshot.fullEvery,
+				keepFulls: i.snapshot.keepFulls,
+				store: i.snapshot.store,
+				maxInlineBytes: i.snapshot.maxInlineBytes
+			}),
+			nextSnapshotAt: this.clock.now(),
+			lastCheckpointFingerprint: null,
+			lastListing: null,
+			confirmInputCheckpoint: (e) => W.confirmInputCheckpoint(e),
+			activateWorldMembers: (e, t) => W.activateWorldReservedAsync(e, t),
+			cancelWorldGhost: (e, t, n) => W.cancelWorldGhost(e, t, n),
+			cancelWorldPreview: (e, t) => W.cancelWorldPreview(e, t),
+			previewWorldEnter: (e, t, n) => W.previewWorldEnter(e, t, n),
+			retireWorldReceipt: (e, t) => W.retireWorldReceipt(e, t),
+			holdPublication: () => W.holdPublication(),
+			releasePublication: () => W.releasePublication(),
+			worldRecoveryEpoch: m.worldRecoveryEpoch,
+			worldReceiptSnapshot: () => W.worldReceiptSnapshot(),
+			hasWorldReceipt: (e, t) => W.hasWorldReceipt(e, t),
+			applyWorldHook: (e, t, n, r, i, a, o, s, c) => W.applyWorldHook(e, t, n, r, i, a, o, s, c),
+			finalizeWorldExit: (e, t, n, r, i, a) => W.finalizeWorldExit(e, t, n, r, i, a),
+			isWorldFinalizationHeld: () => W.isWorldFinalizationHeld(),
+			notifyWorldHandoff: (e, n) => W.notifyWorldHandoff(e, n, (e) => {
+				let n = [...R].filter((e) => e.status === "joined");
+				if (n.some((e) => typeof e.notifyWorldHandoff != "function")) throw new t({ detail: "World notice requires the actual reliable Session capability" });
+				for (let t of n) t.notifyWorldHandoff(e);
+			}),
+			worldFinalizationAfterglow: () => W.worldFinalizationAfterglow(),
+			worldFinalizationRequest: () => W.worldFinalizationRequest(),
+			completeWorldFinalization: (e, t) => W.completeWorldFinalization(e, t),
+			reconcileWorldSource: (e, t, n, r) => W.reconcileWorldSource(e, t, n, r),
+			configureWorldCellMovement: (e, t, n) => W.configureWorldCellMovement(e, t, n),
+			captureWorldMovement: (e) => W.captureWorldMovement(e),
+			worldMovementSnapshot: () => W.worldMovementSnapshot(),
+			listWorldEntityIds: (e, t, n) => W.listWorldEntityIds(e, t, n),
+			captureWorldProjection: (e, t, n) => W.captureWorldProjection(e, t, n),
+			captureWorldEntity: (e, t, n) => W.captureWorldEntity(e, t, n),
+			hasCommands: () => W.metrics().outboxCommands > 0,
+			listing: () => i.listing === void 0 ? void 0 : c(i.name, i.listing({
+				state: W.lastGoodSnapshot().state,
+				options: o
+			})),
+			capture: () => {
+				let r = W.lastGoodSnapshot(), a = i.snapshot.pick(r.state);
+				if (z.isEffect(a) || a && typeof a == "object" && "then" in a) throw a instanceof Promise && a.catch(() => void 0), new n({
+					room: e,
+					detail: "Snapshot projection must return synchronous full-schema state"
+				});
+				let o = v.full(a);
+				if (B.isFailure(o)) throw o.failure;
+				let s = i.world ? W.worldReceiptSnapshot() : void 0;
+				if (s?.length) {
+					let e = v.full(r.state);
+					if (B.isFailure(e)) throw e.failure;
+					if (e.success.length !== o.success.length || e.success.some((e, t) => e !== o.success[t])) throw new t({ detail: "World hook receipts require the actual actor state in the same checkpoint" });
+				}
+				let c = q.listing();
+				return {
+					tick: r.tick,
+					bytes: o.success,
+					schemaHash: v.schemaHash,
+					schedules: W.scheduleSnapshot(),
+					...s === void 0 ? {} : { worldReceipts: s },
+					inputReceipts: W.inputReceiptSnapshot(),
+					commandCursor: W.commandCursor(),
+					commands: W.drainOutbox(),
+					...c === void 0 ? {} : { listing: c }
+				};
+			},
+			flush: () => W.flushClientOperations(),
+			dispose: () => G ??= W.disposeAsync(),
+			checkpointReady: () => !W.isLifecycleBusy(),
+			releaseHibernated: () => W.releaseHibernated(),
+			freezeForDrain: () => W.freezeForDrain(),
+			releaseTransferred: () => W.releaseTransferred(),
+			quiesceDrainGeometry: async () => {
+				w && (M(w), N(w), await w.quiesce());
+			},
+			produceSpectators: () => S?.capture(Math.floor(this.clock.now()), W.lastGoodSnapshot()),
+			clearSpectators: () => S?.clear(),
+			finishRecording: async () => {
+				S && g.replayRecording && !K && (S.capture(Math.floor(this.clock.now()), W.lastGoodSnapshot()), await S.finishRecording(), K = !0);
+			},
+			fenceGeometry: () => {
+				w && (M(w), N(w));
+			},
+			pumpGeometry: async () => {
+				w && (await I(w), await L(w));
+			},
+			synchronizeGeometry: async () => {
+				await w?.synchronize();
+			},
+			quiesceGeometry: async () => {
+				if (!w) throw new t({ detail: "Room has no actual geometry resource to quiesce" });
+				await w.quiesce();
+			},
+			activateGeometryVersion: async (e) => {
+				if (!w) throw new t({ detail: "Room has no actual geometry resource for version activation" });
+				await D(w, e, () => [...R], U);
+			},
+			activateGeometryChange: async (e) => {
+				if (!w) throw new t({ detail: "Room has no actual geometry resource for change activation" });
+				await E(w, e, () => [...R], U);
+			},
+			finishGeometry: async () => {
+				await w?.close();
+			},
+			connect: (e) => {
+				let n = new _(W, e, this.clock, h, {
+					...C,
+					epoch: m.epoch,
+					...V || H?.recovery ? { onClientMessage: (e, r, i) => {
+						let a = w ? j(w) : void 0, o = w ? A(w) : void 0;
+						if (H?.recovery && e === H.recovery.requestChannel) {
+							if (!a?.recovery) throw new t({ detail: "Room geometry recovery graph was retired" });
+							a.recovery.stage(n, r);
+						} else if (V && e === V.channel) {
+							if (!o) throw new t({ detail: "Room geometry mutation graph was retired" });
+							o.stage(n, r);
+						} else {
+							if (C.onClientMessage) return C.onClientMessage(e, r, i);
+							throw new t({ detail: "Actual Room client channel has no acquired Host handler" });
+						}
+					} } : {}
+				});
+				return n;
+			}
+		};
+		return m.publicationHeld && W.holdPublication(), this.host.add(W), this.rooms.set(e, q), m.publicationHeld && this.heldPublication.add(e), W;
+	}
+	async activateWorldMembers(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.heldPublication.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.has(e)) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await o.activateWorldMembers(r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	replaceWorldGhostProjection(e, t, n, r, i, a) {
+		return this.applyWorldHook(e, t, "ghost", n, i, void 0, a, !1, r, !0);
+	}
+	async cancelWorldGhost(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n.epoch || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await o.cancelWorldGhost(n, r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async cancelWorldPreview(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await o.cancelWorldPreview(r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async previewWorldEnter(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n.epoch || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await o.previewWorldEnter(n, r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async settleSessions(e, n, r) {
+		let a = this.rooms.get(e);
+		if (this.closed || this.turning || !a || a.tenantId !== n || a.epoch !== r || this.withdrawn.has(e) || this.drains.has(e)) throw new i({ roomId: e });
+		if ((await Promise.allSettled([...a.sessions].map((e) => e.settled()))).some((e) => e.status === "rejected")) throw new t({ detail: "Room Session authentication/lifecycle remains incomplete" });
+	}
+	worldLifecycleQuiet(e) {
+		let t = this.rooms.get(e);
+		return t !== void 0 && t.mode === "state-sync" && t.checkpointReady();
+	}
+	worldReceiptSnapshot(e, t, n) {
+		let r = this.rooms.get(e);
+		if (this.closed || this.turning || !r || r.mode !== "state-sync" || r.tenantId !== t || r.epoch !== n || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e)) throw new i({ roomId: e });
+		return r.worldReceiptSnapshot();
+	}
+	async retireWorldReceipt(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await o.retireWorldReceipt(r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	hasWorldReceipt(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		return o.hasWorldReceipt(r, a);
+	}
+	async applyWorldHook(e, t, n, r, a, o, s, c, l, u, d) {
+		let f = this.rooms.get(e);
+		if (this.closed || this.turning || !f || f.mode !== "state-sync" || f.tenantId !== t || f.epoch !== r.epoch || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await f.applyWorldHook(n, r, a, o, s, c, l, u, d);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async finalizeWorldExit(e, t, n, r, a, o, s, c) {
+		let l = this.rooms.get(e);
+		if (this.closed || this.turning || !l || l.mode !== "state-sync" || l.tenantId !== t || l.epoch !== n.epoch || this.heldPublication.has(e) || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await l.finalizeWorldExit(n, r, a, o, s, c);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	worldFinalizationAfterglow(e, t, n) {
+		let r = this.rooms.get(e);
+		if (this.closed || !r || r.mode !== "state-sync" || r.tenantId !== t || r.epoch !== n) throw new i({ roomId: e });
+		return r.worldFinalizationAfterglow();
+	}
+	worldFinalizationRequest(e, t, n) {
+		let r = this.rooms.get(e);
+		if (this.closed || !r || r.mode !== "state-sync" || r.tenantId !== t || r.epoch !== n) throw new i({ roomId: e });
+		return r.worldFinalizationRequest();
+	}
+	async notifyWorldHandoff(e, t, n, r) {
+		let a = this.rooms.get(e);
+		if (this.closed || this.turning || !a || a.mode !== "state-sync" || a.tenantId !== t || a.epoch !== n.sourceEpoch || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.has(e)) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await a.notifyWorldHandoff(n, r);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async completeWorldFinalization(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.has(e)) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await o.completeWorldFinalization(r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async reconcileWorldSource(e, t, n, r, a, o) {
+		let s = this.rooms.get(e);
+		if (this.closed || this.turning || !s || s.mode !== "state-sync" || s.tenantId !== t || s.epoch !== n.epoch || !this.heldPublication.has(e) && !s.isWorldFinalizationHeld() || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await s.reconcileWorldSource(n, r, a, o);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async configureWorldCellMovement(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await o.configureWorldCellMovement(n, r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async captureWorldMovement(e, t, n) {
+		let r = this.rooms.get(e);
+		if (this.closed || this.turning || !r || r.mode !== "state-sync" || r.tenantId !== t || r.epoch !== n || this.heldPublication.has(e) || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			return await r.captureWorldMovement(n);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	worldMovementSnapshot(e, t, n) {
+		let r = this.rooms.get(e);
+		if (this.closed || !r || r.mode !== "state-sync" || r.tenantId !== t || r.epoch !== n) throw new i({ roomId: e });
+		return r.worldMovementSnapshot();
+	}
+	async listWorldEntityIds(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.heldPublication.has(e) || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			return await o.listWorldEntityIds(n, r, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async captureWorldProjection(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.heldPublication.has(e) || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			return await o.captureWorldProjection(r, n, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async captureWorldEntity(e, t, n, r, a) {
+		let o = this.rooms.get(e);
+		if (this.closed || this.turning || !o || o.mode !== "state-sync" || o.tenantId !== t || o.epoch !== n || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			return await o.captureWorldEntity(r, n, a);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async synchronizeGeometry(e) {
+		if (this.drains.has(e)) throw new i({ roomId: e });
+		if (this.turning) throw new n({
+			room: e,
+			detail: "Geometry directory synchronization must stay outside the host turn"
+		});
+		let t = this.rooms.get(e);
+		t?.mode === "state-sync" && await t.synchronizeGeometry();
+	}
+	async quiesceGeometry(e) {
+		if (this.drains.has(e)) throw new i({ roomId: e });
+		let t = this.rooms.get(e);
+		if (this.closed || this.turning || !t || t.mode !== "state-sync" || this.terminal.has(e) || this.withdrawn.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await t.quiesceGeometry();
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async activateGeometryVersion(e, t) {
+		if (this.drains.has(e)) throw new i({ roomId: e });
+		let n = this.rooms.get(e);
+		if (this.closed || this.turning || !n || n.mode !== "state-sync" || this.terminal.has(e) || this.withdrawn.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await n.activateGeometryVersion(t);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async activateGeometryChange(e, t) {
+		if (this.drains.has(e)) throw new i({ roomId: e });
+		let n = this.rooms.get(e);
+		if (this.closed || this.turning || !n || n.mode !== "state-sync" || this.terminal.has(e) || this.withdrawn.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await n.activateGeometryChange(t);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	addLockstep(e, n) {
+		if (!R(e) || e.isDisposed()) throw new t({ detail: "Runtime requires the genuine live SQL-created Lockstep owner" });
+		this.assertAdmission(e.id);
+		let r = o(n, ["terminal", "runEffect"], ["terminal", "runEffect"]), i = o(r.terminal, ["terminate"], ["terminate"]);
+		if (typeof r.runEffect != "function" || typeof i.terminate != "function") throw new t({ detail: "Runtime Lockstep requires complete terminal capability and actual Effect runner" });
+		let a = Object.freeze({
+			runEffect: r.runEffect,
+			terminal: Object.freeze({ terminate: i.terminate.bind(r.terminal) })
+		}), s = {
+			mode: "lockstep",
+			id: e.id,
+			tenantId: e.tenantId,
+			epoch: e.epoch,
+			maxSessions: e.descriptor.maxClients,
+			sessions: /* @__PURE__ */ new Set(),
+			owner: e,
+			binding: a,
+			connect: (t) => e.connect(t)
+		};
+		this.host.add(e), this.rooms.set(e.id, s);
+	}
+	async publishLockstep(e) {
+		let t = this.rooms.get(e);
+		if (this.closed || this.turning || !t || t.mode !== "lockstep" || this.terminal.has(e) || this.withdrawn.has(e)) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			await t.owner.publishAsync();
+		} finally {
+			this.turning = !1;
+		}
+	}
+	lockstepRosterOpen(e) {
+		let t = this.rooms.get(e);
+		return !this.closed && !this.turning && t?.mode === "lockstep" && !this.terminal.has(e) && !this.withdrawn.has(e) && t.owner.rosterOpen();
+	}
+	admitLockstep(e, n, r) {
+		let i = this.rooms.get(e);
+		if (this.closed || this.turning || !i || i.mode !== "lockstep" || this.terminal.has(e) || this.withdrawn.has(e) || !i.sessions.has(r)) throw new t({ detail: "Runtime Lockstep admission requires its exact owned actual Session outside a turn" });
+		return i.owner.admit(n, r);
+	}
+	async prepareLockstepInitialRoster(e, t = {}) {
+		let n = this.rooms.get(e);
+		if (this.closed || this.turning || !n || n.mode !== "lockstep" || this.terminal.has(e) || this.withdrawn.has(e)) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			return await n.owner.prepareInitialRoster(t);
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async startLockstep(e) {
+		let t = this.rooms.get(e);
+		if (this.closed || this.turning || !t || t.mode !== "lockstep" || this.terminal.has(e) || this.withdrawn.has(e)) throw new i({ roomId: e });
+		this.turning = !0;
+		try {
+			return await t.owner.startAsync();
+		} finally {
+			this.turning = !1;
+		}
+	}
+	assertAdmission(t) {
+		if (this.closed) throw new i({ roomId: t });
+		if (this.turning) throw new n({
+			room: t,
+			detail: "Runtime admission must wait for the current host turn"
+		});
+		if (this.rooms.has(t)) throw new n({
+			room: t,
+			detail: "Room is already owned by this runtime"
+		});
+		if (this.rooms.size >= this.capacity) throw new e({
+			budget: "runtimeRooms",
+			limit: this.capacity
+		});
+	}
+	holdPublication(e) {
+		let n = this.rooms.get(e);
+		if (this.closed || this.turning || !n || n.mode !== "state-sync" || n.sessions.size || n.lastCheckpointFingerprint !== null || this.pending.has(e) || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e)) throw new t({ detail: "Publication hold requires an unstarted owned state-sync actor" });
+		n.holdPublication(), this.heldPublication.add(e);
+	}
+	isPublicationHeld(e) {
+		return this.heldPublication.has(e);
+	}
+	async publishHeld(e, n) {
+		if (!this.heldPublication.has(e)) throw new t({ detail: "Publication requires its retained hold" });
+		await this.persistRoom(e, !0), n && await n();
+		let r = this.rooms.get(e);
+		if (!r || r.mode !== "state-sync") throw new i({ roomId: e });
+		r.releasePublication(), this.heldPublication.delete(e);
+	}
+	persist(e) {
+		return this.persistRoom(e, !1);
+	}
+	async persistRoom(e, r) {
+		if (this.closed || !this.rooms.has(e) || this.withdrawn.has(e) || this.drains.has(e)) throw new i({ roomId: e });
+		if (this.rooms.get(e)?.mode === "lockstep") throw new t({ detail: "Lockstep creation is persisted by SQL Admission, never a state checkpoint" });
+		if (this.turning) throw new n({
+			room: e,
+			detail: "Persistence must wait for the current host turn"
+		});
+		this.turning = !0;
+		try {
+			await this.commitPending();
+			let a = this.rooms.get(e);
+			if (!a) throw new i({ roomId: e });
+			if (a.mode === "lockstep") throw new t({ detail: "Lockstep creation is persisted by SQL Admission, never a state checkpoint" });
+			if (!a.checkpointReady()) throw new n({
+				room: e,
+				detail: "Initial checkpoint must wait for lifecycle work"
+			});
+			this.heldPublication.has(e) || a.produceSpectators(), this.capture(a, "live", void 0, !1, this.heldPublication.has(e) && !r), await this.commitPending();
+		} finally {
+			this.turning = !1;
+		}
+	}
+	connect(t, n) {
+		let r = this.rooms.get(t);
+		if (this.closed || !r || this.heldPublication.has(t) || this.pending.get(t)?.retire || this.terminal.has(t) || this.withdrawn.has(t) || this.drains.has(t)) throw new i({ roomId: t });
+		if (r.sessions.size >= r.maxSessions) throw new e({
+			budget: "roomSessions",
+			limit: r.maxSessions
+		});
+		let a = r.connect(n);
+		return r.sessions.add(a), a;
+	}
+	readSessionAdmission(e, n) {
+		let r = this.rooms.get(e);
+		if (this.closed || !r || this.pending.get(e)?.retire || this.terminal.has(e) || this.withdrawn.has(e) || this.drains.has(e)) return null;
+		for (let i of r.sessions) {
+			if (i.id !== n || typeof i.admittedIdentity != "function") continue;
+			let r = i.admittedIdentity();
+			if (!r) return null;
+			let a = g(r);
+			if (a.roomId !== e || a.sessionId !== n) throw new t({ detail: "Actual Room session admission escaped its host scope" });
+			return a;
+		}
+		return null;
+	}
+	async leaveSession(e, t) {
+		let r = this.rooms.get(e);
+		if (r) {
+			if (r.mode === "lockstep" && this.turning) throw new n({
+				room: e,
+				detail: "Lockstep Session departure must await the current turn"
+			});
+			for (let e of r.sessions) e.id === t && (await e.close("left"), await e.settled(), r.mode === "lockstep" && await r.owner.maintenance(), r.sessions.delete(e));
+		}
+	}
+	async kickSubject(e, i, a, o) {
+		let s = this.rooms.get(e);
+		if (!s) return 0;
+		if (s.tenantId !== i) throw new r({ roomId: e });
+		if (s.mode === "lockstep" && this.turning) throw new n({
+			room: e,
+			detail: "Lockstep kick must await the current turn"
+		});
+		let c = 0;
+		for (let e of [...s.sessions]) {
+			let n = typeof e.admittedIdentity == "function" ? e.admittedIdentity() : null;
+			if (!(n === null || n.tenantId !== i || a !== null && n.subjectId !== a)) {
+				if (typeof e.kick != "function") throw new t({ detail: "Room session provider cannot kick" });
+				await e.kick(o), await e.settled(), s.mode === "lockstep" && await s.owner.maintenance(), s.sessions.delete(e), c++;
+			}
+		}
+		return c;
+	}
+	async withdrawOwnership(e, r, i) {
+		if (this.turning) throw new n({
+			room: e,
+			detail: "Ownership withdrawal must wait for the current host turn"
+		});
+		let a = this.rooms.get(e);
+		if (a) {
+			if (a.tenantId !== r || a.epoch !== i) throw new t({ detail: "Revoked ownership tuple does not match the retained actor" });
+			this.turning = !0;
+			try {
+				this.withdrawn.has(e) || (this.host.take(e), this.withdrawn.set(e, {
+					disposed: !1,
+					disposalFailure: null
+				})), await this.finishWithdrawal(e);
+			} finally {
+				this.turning = !1;
+			}
+		}
+	}
+	async prepareDrain(e) {
+		if (this.closed || this.turning) throw new t({ detail: "Drain preparation requires the exclusive live runtime lane" });
+		let n = this.rooms.get(e);
+		if (!n || this.heldPublication.has(e) || this.terminal.has(e) || this.withdrawn.has(e) || this.pending.get(e)?.retire) throw new i({ roomId: e });
+		let r = [...n.sessions];
+		if (r.some((e) => typeof e.quiesceForDrain != "function" || typeof e.notifyMigration != "function")) throw new t({ detail: "Planned drain requires actual Session quiescence and migration capabilities" });
+		this.turning = !0;
+		let a = this.drains.get(e);
+		a || (a = {
+			frozen: !1,
+			checkpoint: null,
+			ready: !1
+		}, this.drains.set(e, a), this.host.take(e));
+		try {
+			if (n.mode === "lockstep") {
+				let e = await n.owner.prepareDrain();
+				return a.frozen = !0, a.ready = !0, e;
+			}
+			if (!a.frozen) {
+				await this.commitPending(e);
+				let i = (await Promise.allSettled(r.map(async (e) => {
+					let n = e.quiesceForDrain();
+					if (!(n instanceof Promise)) throw new t({ detail: "Session quiescence must return its actual lifetime" });
+					await n;
+				}))).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+				if (i.length) throw AggregateError(i, "Session drain preparation remains incomplete");
+				if (n.flush(), await Promise.all(r.map((e) => e.settled())), r.some((e) => e.failure !== null)) throw new t({ detail: "Session work failed before the final drain snapshot" });
+				await n.quiesceDrainGeometry(), await n.freezeForDrain(), a.frozen = !0;
+			}
+			if (!a.checkpoint) try {
+				a.checkpoint = this.capture(n, "live");
+			} catch (t) {
+				throw a.checkpoint = this.pending.get(e)?.checkpoint ?? null, t;
+			}
+			return await this.commitPending(e), a.ready = !0, Object.freeze({
+				mode: "state-sync",
+				roomId: e,
+				tenantId: n.tenantId,
+				epoch: n.epoch,
+				revision: a.checkpoint.revision,
+				tick: a.checkpoint.tick
+			});
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async notifyDrainMigration(e, n) {
+		let r = this.rooms.get(e);
+		if (this.closed || this.turning || !r || !this.drains.get(e)?.ready) throw new t({ detail: "Migration notification requires the retained prepared Room boundary" });
+		this.turning = !0;
+		try {
+			let e = (await Promise.allSettled([...r.sessions].map(async (e) => {
+				if (this.migrationNotified.has(e)) return;
+				if (!e.notifyMigration) throw new t({ detail: "Owned Session lacks its migration writer" });
+				let r = e.notifyMigration(n);
+				if (!(r instanceof Promise)) throw new t({ detail: "Migration writer must return its actual native lifetime" });
+				await r, this.migrationNotified.add(e);
+			}))).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+			if (e.length) throw AggregateError(e, "Migration notification retains failed native writes");
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async finishWithdrawal(e) {
+		let t = this.rooms.get(e), r = this.withdrawn.get(e);
+		if (!t || !r) throw new n({
+			room: e,
+			detail: "Revoked actor cleanup has lost its retained owner"
+		});
+		if (t.mode === "lockstep") {
+			await t.owner.disposeAsync(!0), t.sessions.clear(), this.pending.delete(e), this.terminal.delete(e), this.rooms.delete(e), this.heldPublication.delete(e), this.withdrawn.delete(e), this.snapshotBudget.forget(e), this.drains.delete(e);
+			return;
+		}
+		let i = [];
+		this.drains.get(e)?.frozen && !r.disposed && (t.releaseTransferred(), r.disposed = !0);
+		for (let e of t.sessions) try {
+			await e.closeFenced(), t.sessions.delete(e);
+		} catch (e) {
+			i.push(e);
+		}
+		if (!i.length && !r.disposed) try {
+			this.pending.get(e)?.checkpoint.disposition === "hibernated" ? t.releaseHibernated() : await t.dispose(), r.disposed = !0;
+		} catch (e) {
+			r.disposalFailure = e, r.disposed = !0;
+		}
+		if (t.mode === "state-sync") try {
+			await t.finishGeometry();
+		} catch (e) {
+			i.push(e);
+		}
+		if (r.disposalFailure !== null && i.push(r.disposalFailure), i.length) throw AggregateError(i, "Revoked Room owner cleanup failed; resources remain retained");
+		t.clearSpectators(), this.pending.delete(e), this.terminal.delete(e), this.rooms.delete(e), this.heldPublication.delete(e), this.withdrawn.delete(e), this.snapshotBudget.forget(e), this.drains.delete(e);
+	}
+	restore(e, n, r, a, o, s, c = !1) {
+		if (e.disposition === "disposed") throw new i({ roomId: e.roomId });
+		if (!Number.isSafeInteger(a) || a <= e.epoch) throw new t({ detail: "Rehydration requires a newer durable ownership epoch" });
+		let l = new u(n.state);
+		if (l.schemaHash !== e.schemaHash) throw new t({ detail: "Rehydration schema does not match the durable snapshot" });
+		let d = l.decodeFull(e.bytes);
+		if (B.isFailure(d)) throw d.failure;
+		return this.add(e.roomId, e.tenantId, n, d.success, r, {
+			epoch: a,
+			tick: e.tick,
+			commandCursor: e.commandCursor,
+			revision: e.revision,
+			schedules: e.schedules,
+			worldReceipts: e.worldReceipts,
+			rehydrate: !0,
+			publicationHeld: c,
+			...c && n.world ? { worldRecoveryEpoch: e.worldRecoveryEpoch ?? e.epoch } : {}
+		}, o, s);
+	}
+	capture(e, t, r, i = !1, a = !1) {
+		if (this.pending.has(e.id)) throw new n({
+			room: e.id,
+			detail: "An uncommitted checkpoint cannot be overwritten"
+		});
+		if (e.revision >= 2 ** 53 - 1) throw new n({
+			room: e.id,
+			detail: "Checkpoint revision is exhausted"
+		});
+		let o = r ?? e.capture(), s = e.revision + 1, c = Object.freeze({
+			...o,
+			roomId: e.id,
+			tenantId: e.tenantId,
+			epoch: e.epoch,
+			revision: s,
+			requestId: `${e.id}:${e.epoch}:checkpoint:${s}`,
+			disposition: t,
+			...a ? {
+				publication: "held",
+				...e.worldRecoveryEpoch === void 0 ? {} : { worldRecoveryEpoch: e.worldRecoveryEpoch }
+			} : {},
+			snapshot: e.snapshotEncoding
+		});
+		return i && !this.snapshotBudget.periodic(e.id, W(c), this.clock.now()) ? null : (e.revision = s, this.pending.set(e.id, {
+			checkpoint: c,
+			room: e,
+			retire: t === "disposed" || t === "faulted" || t === "hibernated"
+		}), i || (this.snapshotBudget.forget(e.id), this.snapshotBudget.forced(W(c), this.clock.now())), c);
+	}
+	async commitPending(e) {
+		let t = [];
+		for (let [n, r] of this.pending) if ((e === void 0 || n === e) && !this.withdrawn.has(n)) try {
+			let e = await z.runPromise(z.result(this.checkpoints.commit(structuredClone(r.checkpoint))));
+			if (B.isFailure(e)) {
+				if (e.failure instanceof a && r.checkpoint.disposition === "hibernated" && e.failure.roomId === n) continue;
+				throw e.failure;
+			}
+			r.room.confirmInputCheckpoint(r.checkpoint.inputReceipts), await r.room.synchronizeGeometry(), r.checkpoint.disposition === "hibernated" && (r.room.releaseHibernated(), await r.room.finishGeometry()), r.room.lastCheckpointFingerprint = U(r.checkpoint), r.checkpoint.listing !== void 0 && (r.room.lastListing = m(r.checkpoint.listing)), r.room.nextSnapshotAt = this.clock.now() + r.room.snapshotEveryMs, this.checkpointCommits++, this.checkpointStateBytes += r.checkpoint.bytes.byteLength, this.pending.delete(n), r.retire && (this.rooms.delete(n), this.heldPublication.delete(n), this.terminal.delete(n), this.snapshotBudget.forget(n));
+		} catch (e) {
+			t.push(e);
+		}
+		if (t.length) throw AggregateError(t, "Room checkpoint commit failed; retained for retry");
+	}
+	async retire(e, t = !1) {
+		e.fenceGeometry();
+		try {
+			await e.pumpGeometry();
+		} catch (e) {
+			return [e];
+		}
+		let n = [];
+		for (let t of e.sessions) try {
+			await t.close("disposed"), await t.settled(), e.sessions.delete(t);
+		} catch (e) {
+			try {
+				await t.settled();
+			} catch (e) {
+				n.push(e);
+			}
+			n.push(e);
+		}
+		if (n.length) return n;
+		try {
+			await e.finishRecording();
+		} catch (e) {
+			return [e];
+		}
+		if (!t) try {
+			await e.dispose();
+		} catch (e) {
+			n.push(e);
+		}
+		if (!t) try {
+			await e.finishGeometry();
+		} catch (e) {
+			n.push(e);
+		}
+		try {
+			e.flush();
+		} catch (e) {
+			n.push(e);
+		}
+		return n.length || e.clearSpectators(), n;
+	}
+	async captureTerminal(e) {
+		let r = [];
+		for (let [i, a] of this.terminal) {
+			if (e !== void 0 && i !== e) continue;
+			let s = this.rooms.get(i);
+			if (!s) throw new n({
+				room: i,
+				detail: "Host transferred an unowned room"
+			});
+			if (s.mode === "lockstep") try {
+				if (await s.owner.disposeAsync(), s.sessions.clear(), a.cleaned = !0, a.disposition === "hibernating") throw new t({ detail: "Lockstep has no state-checkpoint hibernation path" });
+				let e = h({
+					roomId: i,
+					tenantId: s.tenantId,
+					epoch: s.epoch
+				}), n = Object.freeze({
+					...e,
+					disposition: a.disposition
+				}), r = s.binding.terminal.terminate(n);
+				if (!z.isEffect(r)) throw new t({ detail: "Lockstep terminal capability must return its actual Effect" });
+				let c = o(await s.binding.runEffect(r), [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"disposition",
+					"hostId"
+				], [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"disposition",
+					"hostId"
+				]);
+				if (c.roomId !== i || c.tenantId !== s.tenantId || c.epoch !== s.epoch || c.disposition !== a.disposition || c.hostId !== s.owner.hostId) throw new t({ detail: "Lockstep terminal returned an unrelated SQL receipt" });
+				this.terminal.delete(i), this.rooms.delete(i), this.snapshotBudget.forget(i);
+			} catch (e) {
+				r.push(e);
+			}
+			else if (!this.pending.has(i)) {
+				if (!a.cleaned) {
+					let e = await this.retire(s, a.disposition === "hibernating");
+					if (e.length) {
+						r.push(...e);
+						continue;
+					}
+					a.cleaned = !0;
+				}
+				try {
+					a.disposition === "hibernating" ? a.staged ? this.capture(s, "hibernated", {
+						...a.staged,
+						commands: []
+					}) : a.staged = this.capture(s, "hibernating") : (this.capture(s, a.disposition), this.terminal.delete(i));
+				} catch (e) {
+					r.push(e);
+				}
+			}
+		}
+		return r;
+	}
+	async settleForDrain(e) {
+		if (this.closed || this.turning || this.drains.has(e) || this.heldPublication.has(e)) throw new t({ detail: "Retained lifecycle settlement requires exclusive pre-drain supervision" });
+		this.turning = !0;
+		try {
+			this.collectTerminal(), this.withdrawn.has(e) && await this.finishWithdrawal(e), await this.commitPending(e);
+			let n = await this.captureTerminal(e);
+			if (n.length) throw AggregateError(n, "Retained Room terminal work remains incomplete");
+			if (await this.commitPending(e), this.terminal.has(e) || this.pending.get(e)?.retire) throw this.isHibernating(e) ? new a({ roomId: e }) : new t({ detail: "Retained Room retirement requires another supervision pass" });
+			let r = this.rooms.get(e);
+			if (!r) return "retired";
+			if (r.mode === "lockstep") r.owner.isPublished() || await r.owner.publishAsync();
+			else if (r.lastCheckpointFingerprint === null) {
+				if (!r.checkpointReady()) throw new t({ detail: "Initial Room checkpoint awaits accepted lifecycle work" });
+				this.capture(r, "live"), await this.commitPending(e);
+			}
+			return "active";
+		} finally {
+			this.turning = !1;
+		}
+	}
+	collectTerminal() {
+		let e = [...this.host.drainFaults().map((e) => ({
+			id: e.roomId,
+			disposition: "faulted"
+		})), ...this.host.takeRetired().map((e) => ({
+			id: e.id,
+			disposition: this.rooms.get(e.id)?.mode === "state-sync" && this.rooms.get(e.id).hibernateOnEmpty ? "hibernating" : "disposed"
+		}))];
+		for (let t of e) this.snapshotBudget.forget(t.id), this.terminal.set(t.id, {
+			disposition: t.disposition,
+			cleaned: !1,
+			staged: null
+		});
+	}
+	async turn() {
+		if (this.closed) throw new i({ roomId: "host" });
+		if (this.turning) throw new n({
+			room: "host",
+			detail: "Runtime turns cannot overlap"
+		});
+		this.turning = !0;
+		try {
+			for (let e of this.withdrawn.keys()) await this.finishWithdrawal(e);
+			await this.commitPending();
+			for (let [e, t] of this.rooms) t.mode === "state-sync" && !this.heldPublication.has(e) && !this.terminal.has(e) && !this.withdrawn.has(e) && !this.drains.has(e) && !this.pending.get(e)?.retire && await t.pumpGeometry();
+			let e = this.loopObservation.measure(() => this.host.advance((e) => !this.heldPublication.has(e))), t = [];
+			this.collectTerminal(), t.push(...await this.captureTerminal());
+			let r = this.host.activeRooms(), i = r.findIndex((e) => e.id === this.lastPeriodicRoom), a = i < 0 ? r : [...r.slice(i + 1), ...r.slice(0, i + 1)];
+			for (let e of a) {
+				let r = this.rooms.get(e.id);
+				if (!r) throw new n({
+					room: e.id,
+					detail: "Host contains an unowned room"
+				});
+				if (this.heldPublication.has(e.id)) continue;
+				if (r.mode === "lockstep") {
+					try {
+						await r.owner.maintenance();
+						for (let e of r.sessions) e.teardownReady() && r.sessions.delete(e);
+						await r.owner.flush();
+					} catch (e) {
+						t.push(e);
+					}
+					continue;
+				}
+				let i = !1;
+				for (let e of r.sessions) if (e.maintenance(), e.teardownReady()) try {
+					await e.settled(), r.sessions.delete(e);
+				} catch (e) {
+					t.push(e), i = !0;
+				}
+				if (i || !r.checkpointReady()) continue;
+				try {
+					r.flush();
+				} catch (e) {
+					t.push(e);
+				}
+				let a = this.clock.now();
+				if (a >= r.nextSendAt) {
+					r.produceSpectators();
+					for (let e of r.sessions) e.publishState();
+					r.nextSendAt = a + r.sendInterval;
+				}
+				if (!r.checkpointReady()) continue;
+				let o = r.listing(), s = r.hasCommands() || o !== void 0 && m(o) !== r.lastListing;
+				if (!s && a < r.nextSnapshotAt || !s && this.snapshotBudget.blocked(r.id)) continue;
+				let c = r.capture();
+				!s && c.commands.length === 0 && r.onlyIfChanged && r.lastCheckpointFingerprint === U(c) ? (r.nextSnapshotAt = a + r.snapshotEveryMs, this.unchangedSnapshotsSkipped++, this.snapshotBudget.forget(r.id)) : s || c.commands.length ? this.capture(r, "live", c) : this.capture(r, "live", c, !0) && (this.lastPeriodicRoom = r.id);
+			}
+			try {
+				await this.commitPending();
+			} catch (e) {
+				t.push(e);
+			}
+			if (t.length) throw AggregateError(t, "Room supervision failed");
+			return e;
+		} finally {
+			this.turning = !1;
+		}
+	}
+	async close() {
+		if (this.heldPublication.size) throw new t({ detail: "Held publication must finish or lose ownership before terminal close" });
+		if (this.drains.size) throw new t({ detail: "Prepared drain ownership must be handed off and withdrawn before terminal close" });
+		if (this.turning) throw new n({
+			room: "host",
+			detail: "Await the current turn before shutdown"
+		});
+		this.turning = !0, this.closed = !0;
+		try {
+			for (let e of this.withdrawn.keys()) await this.finishWithdrawal(e);
+			await this.commitPending();
+			let e = [];
+			for (let e of this.host.takeAll()) this.terminal.set(e.id, {
+				disposition: "disposed",
+				cleaned: !1,
+				staged: null
+			});
+			e.push(...await this.captureTerminal());
+			try {
+				await this.commitPending();
+			} catch (t) {
+				e.push(t);
+			}
+			if (e.length) throw AggregateError(e, "Room runtime shutdown failed");
+			let t = [...this.terminal.keys()][0];
+			if (t !== void 0) throw new a({ roomId: t });
+		} finally {
+			this.turning = !1;
+		}
+	}
+	retains(e) {
+		return this.rooms.has(e);
+	}
+	isHibernating(e) {
+		return this.terminal.get(e)?.disposition === "hibernating";
+	}
+	hasPendingCheckpoint(e) {
+		return this.pending.has(e);
+	}
+	metrics() {
+		let e = 0, t = 0, n = 0, r = 0, i = null, a = 0;
+		for (let o of this.rooms.values()) {
+			e += o.sessions.size;
+			for (let e of o.sessions) {
+				let o = e.reportedLoss?.() ?? null;
+				o !== null && (i = Math.max(i ?? 0, o), o >= 100 && a++), r += e.staleInputs?.() ?? 0;
+				let s = e.sendThrottle?.();
+				s && (s.level > 0 && t++, n += s.throttles);
+			}
+		}
+		let o = this.snapshotBudget.metrics();
+		return {
+			loop: this.loopObservation.snapshot(),
+			ownedRooms: this.rooms.size,
+			pendingCheckpoints: this.pending.size,
+			sessions: e,
+			checkpointCommits: this.checkpointCommits,
+			checkpointStateBytes: this.checkpointStateBytes,
+			unchangedSnapshotsSkipped: this.unchangedSnapshotsSkipped,
+			snapshotDeferred: o.deferred,
+			snapshotForcedBytes: o.forcedBytes,
+			snapshotPeriodicBytes: o.periodicBytes,
+			snapshotDebtBytes: o.debtBytes,
+			throttledSessions: t,
+			clientThrottles: n,
+			staleInputsDropped: r,
+			maxReportedLossPermille: i,
+			lossySessions: a
+		};
+	}
+};
+//#endregion
+export { G as RoomRuntime };