@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/hostController.js

@@ -0,0 +1,3093 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomForbidden as n, RoomFull as r, RoomGone as i, RoomHibernatePending as a, RoomLocked as o } from "./errors.js";
+import { simulationOwnData as s } from "./simulationAuthoring.js";
+import { roomPoolLockstepCatchUp as c } from "./roomPoolRuntimeDefaults.js";
+import { createSimulationOptionsCodec as l } from "./simulationOptionsWire.js";
+import { captureRoomSeatAttributes as u } from "./room.js";
+import { RoomStateCodec as d } from "./stateCodec.js";
+import { geometryPersistenceId as f } from "./geometryPersistenceData.js";
+import { captureRoomGeometryReloadRequest as p, captureRoomGeometryRollbackRequest as m } from "./geometryAdminData.js";
+import { captureWorldData as h } from "./worldData.js";
+import { captureRoomTransportDataMethod as g } from "./transportAuthoring.js";
+import { RoomTransportCleanupFailure as _ } from "./transportCleanup.js";
+import { roomHostTransportEndpoints as v } from "./transportEndpoints.js";
+import { ROOMS_TABLE as y, ROOM_CREATIONS_TABLE as b, ROOM_HOSTS_TABLE as x } from "./identities.js";
+import { captureWorldCatalog as ee, worldCellAt as S } from "./world.js";
+import { canonicalRoomJson as C } from "./checkpointJson.js";
+import { assertRoomSubjectAdmission as w } from "./subjectAdmission.js";
+import { assertRoomSeatSecrets as te, resolveRoomSeatTokenStrategies as T, verifyRoomSeatWithStrategy as ne } from "./seats.js";
+import { assertRoomPoolRecoveryTarget as re, captureRoomPoolCatalog as ie, resolveRoomPool as ae, roomPoolHostedNames as oe, roomPoolRuntimeDefaults as E } from "./roomPoolTopology.js";
+import { dataStoreWorldCells as D } from "./worldCells.js";
+import { roomReservationBatchSessionId as se } from "./reservationBatch.js";
+import { readWorldTransitionSeatGroup as ce, worldTransitionSeatBatch as le } from "./worldTransitionSeatGroup.js";
+import { withWorldRecoveryActor as ue } from "./worldRecoveryActor.js";
+import { assertWorldActorSnapshotSource as de, captureWorldActorTransferSnapshot as O } from "./worldActorTransferSnapshot.js";
+import { makeWorldBoundaryCoordinator as fe } from "./worldBoundaryCoordinator.js";
+import { makeRoomWorldGhostReceiver as pe } from "./worldGhostHost.js";
+import { makeWorldGhostPublisher as me } from "./worldGhostPublisher.js";
+import { captureRoomWorldGhostOutboundOptions as k, ownWorldGhostOutbound as he } from "./worldGhostOutbound.js";
+import { dataStoreWorldGhostDestination as ge } from "./worldGhostDestination.js";
+import { roomWorldEntityCodec as A } from "./worldEntityCodec.js";
+import { openWorldGhostSocket as _e } from "./worldGhostSocket.js";
+import { bindWorldGhostIngress as ve } from "./worldGhostIngress.js";
+import { assertWorldInstanceRecreation as ye, dataStoreWorldInstances as be, worldInstanceCreationKey as j } from "./worldInstances.js";
+import { retireFailedWorldInstanceRoom as M, synchronizeWorldInstanceRoom as N } from "./worldInstanceLifecycle.js";
+import { assertWorldCellRecreation as xe, worldCellCreationKey as Se } from "./worldCellAllocation.js";
+import { insideRoomHostCommandScope as P, makeRoomHostCommandWindow as Ce, queueRoomHostCommandOperation as F, runRoomHostCommandOperation as we, withRoomHostCommandScope as Te } from "./hostCommandScope.js";
+import { assertWorldTransitionExecution as I, withWorldTransitionGroupMember as Ee, worldTransitionExecutionGroup as De } from "./worldTransitionExecutor.js";
+import { captureRoomWorldEntitySource as Oe } from "./worldHostSource.js";
+import { RoomHostCellObservation as ke } from "./hostCellObservation.js";
+import { dataStoreRoomCheckpoints as Ae } from "./checkpointStore.js";
+import { captureRoomHostDrainPolicy as je, dataStoreRoomHostDrain as Me } from "./hostDrain.js";
+import { dataStoreWorldGhostNeighbors as Ne } from "./worldGhostNeighbors.js";
+import { captureRoomLockstepTransportLimits as Pe } from "./lockstepTransportConfig.js";
+import { dataStoreRoomLockstepJournal as Fe } from "./lockstepJournal.js";
+import { dataStoreRoomLockstepAdmission as Ie } from "./lockstepAdmission.js";
+import { dataStoreRoomLockstepTerminal as Le } from "./lockstepTerminal.js";
+import { captureRoomSnapshotBudget as L, defaultRoomSnapshotBudget as Re } from "./snapshotBudget.js";
+import { captureRoomHostGeometryBinding as R, prepareRoomHostGeometry as z } from "./geometryHost.js";
+import { RoomRuntime as ze } from "./runtime.js";
+import { captureRoomLockstepInitialStrategies as Be, firstFreeRoomLockstepPlayerId as Ve, startFullRoomLockstepRoster as He } from "./lockstepInitialAdmission.js";
+import { RoomLockstepOwnedRoom as B } from "./lockstepOwnedRoom.js";
+import { randomRoomLockstepSeed as Ue, resolveRoomLockstepSeed as We } from "./lockstepSeed.js";
+import { matchRoomCreationKey as Ge } from "./matchRooms.js";
+import { RoomCommandDelivery as Ke } from "./commandDelivery.js";
+import { dataStoreRoomDirectory as qe } from "./directory.js";
+import { dataStoreRoomReservations as Je } from "./reservations.js";
+import { roomOwnershipRevoked as V } from "./ownership.js";
+import { captureRoomHostWithdrawalInput as Ye } from "./ownershipWithdrawal.js";
+import { and as H, eq as U, inSet as Xe } from "@voltro/database";
+import { Subject as W, checkGuardsEffect as Ze } from "@voltro/protocol";
+import { Effect as G, Result as K, Schema as q } from "effect";
+import { createHash as J } from "node:crypto";
+// src/hostController.ts
+var Y = async (e, t) => {
+	let n = await G.runPromise(G.result(e), { signal: t });
+	if (K.isFailure(n)) throw n.failure;
+	return n.success;
+}, X = (e) => {
+	if (e.type === "system" || e.type === "service" || !e.tenantId?.trim()) throw new n({ roomId: "" });
+	return {
+		tenantId: e.tenantId,
+		subjectId: e.id,
+		...e.type === "anonymous" ? {} : { subjectType: e.type },
+		...e.type === "user" && e.kind === "guest" ? { subjectKind: "guest" } : {}
+	};
+}, Z = class extends Error {
+	retryCleanup;
+	name = "RoomHostControllerStartFailure";
+	constructor(e) {
+		super("Room controller acquisition cleanup remains incomplete"), this.retryCleanup = e;
+	}
+}, Q = (e, t) => {
+	let n = !1, r = !1, i = null;
+	return () => {
+		if (r) return Promise.resolve();
+		if (i) return i;
+		let a = (async () => {
+			n ||= (await Y(e.setReady(t, !1)), !0), await Y(e.unregister(t)), r = !0;
+		})();
+		return i = a, a.then(() => {
+			i = null;
+		}, () => {
+			i = null;
+		}), a;
+	};
+}, $ = class $ {
+	host;
+	catalog;
+	store;
+	options;
+	runtime;
+	directory;
+	lockstepSeed;
+	lockstepInitial;
+	worldBoundaryClamps = 0;
+	worldBoundaryObserved = /* @__PURE__ */ new WeakMap();
+	ghostMaintenance;
+	boundaryMaintenance;
+	boundaryCellFactories = /* @__PURE__ */ new Map();
+	boundaryCoordinators = /* @__PURE__ */ new Map();
+	ghostCellFactories = /* @__PURE__ */ new Map();
+	ghostPublisherSequences = /* @__PURE__ */ new WeakMap();
+	ghostPublishers = /* @__PURE__ */ new Map();
+	ghostOutbounds = /* @__PURE__ */ new Set();
+	ghostTransports = /* @__PURE__ */ new Set();
+	ghostReceivers = /* @__PURE__ */ new Map();
+	owned = /* @__PURE__ */ new Map();
+	uninstalledCreations = /* @__PURE__ */ new Map();
+	pendingGeometryCleanup = /* @__PURE__ */ new Map();
+	geometryReloads = /* @__PURE__ */ new Map();
+	geometryRollbacks = /* @__PURE__ */ new Map();
+	lane = Promise.resolve();
+	queued = 0;
+	maxQueued;
+	nextHeartbeatAt;
+	closing = !1;
+	closed = !1;
+	activated = !1;
+	routingFenced = !1;
+	closeTask = null;
+	plannedDrain = null;
+	plannedRooms = /* @__PURE__ */ new Map();
+	delivery;
+	commandWindow = null;
+	seatToken;
+	spectatorGroups;
+	replayRecordings;
+	geometry;
+	cells;
+	constructor(e, t, n, r, i, a) {
+		this.host = e, this.catalog = t, this.store = n, this.options = r, this.directory = i, this.lockstepSeed = r.strategies?.lockstepSeed ?? Ue, this.lockstepInitial = Be({
+			playerId: r.strategies?.lockstepPlayerId ?? Ve,
+			start: r.strategies?.lockstepStart ?? He
+		}), this.seatToken = T(r.strategies?.seatToken), this.spectatorGroups = r.spectatorGroups, this.replayRecordings = r.replayRecordings, this.geometry = R(r.geometry), this.cells = new ke(r.worlds, e.id, r.capacity), this.activated = r.startSuspended !== !0, this.maxQueued = r.maxQueuedOperations ?? 128, this.nextHeartbeatAt = r.clock.now() + r.heartbeatEveryMs;
+		let o = r.ports?.checkpoints?.(e.id) ?? Ae(n, {
+			hostId: e.id,
+			epochNow: r.epochNow,
+			snapshotCodec: (e) => new d(t.get(e).state),
+			snapshotBlobs: r.snapshotBlobs,
+			maxInlineBytes: r.maxInlineBytes
+		});
+		this.runtime = new ze(r.capacity, r.clock, o, {
+			snapshotBudgetFactory: () => a,
+			poolDefaults: E(r.pools, r.pool)
+		}), this.delivery = new Ke(o, r.application, r.capacity, void 0, (e) => this.executeAppCommand(e));
+	}
+	static async start(e, n, r) {
+		let i = Object.getOwnPropertyDescriptor(r, "worldSnapshotMaxBytes");
+		if (i && (!("value" in i) || !Number.isSafeInteger(i.value) || i.value < 1 || i.value > 16777216) || !i && "worldSnapshotMaxBytes" in r) throw new t({ detail: "World snapshot recovery requires an own bounded byte budget" });
+		let a = Object.getOwnPropertyDescriptor(r, "worldGhostMaxConnections");
+		if (a && (!("value" in a) || !Number.isSafeInteger(a.value) || a.value < 1 || a.value > 65536) || !a && "worldGhostMaxConnections" in r) throw new t({ detail: "World ghost sockets require an own bounded connection inventory" });
+		if (r.ports && "hostDrain" in r.ports) {
+			let e = Object.getOwnPropertyDescriptor(r.ports, "hostDrain");
+			if (!e || !("value" in e) || typeof e.value != "function") throw new t({ detail: "Host drain requires its own callable provider factory" });
+			r = {
+				...r,
+				ports: {
+					...r.ports,
+					hostDrain: r.ports.hostDrain.bind(r.ports)
+				}
+			};
+		}
+		let o = Object.getOwnPropertyDescriptor(r, "resolveWorldPlayer");
+		if (o && (!("value" in o) || typeof o.value != "function") || !o && "resolveWorldPlayer" in r) throw new t({ detail: "World player selection requires an own server callback" });
+		o && (r = {
+			...r,
+			resolveWorldPlayer: o.value.bind(r)
+		});
+		let c = Object.getOwnPropertyDescriptor(r, "worldEntities");
+		if (c && !("value" in c) || !c && "worldEntities" in r) throw new t({ detail: "Host World recovery requires an own capability" });
+		c?.value !== void 0 && (r = {
+			...r,
+			worldEntities: Oe(c.value)
+		});
+		let l = Object.getOwnPropertyDescriptor(r, "geometry");
+		if (l && (!("value" in l) || !l.enumerable) || !l && "geometry" in r) throw new t({ detail: "Host geometry requires own complete source binding" });
+		let u = R(l?.value), d = Object.getOwnPropertyDescriptor(r, "webTransportAddress"), f = Object.getOwnPropertyDescriptor(r, "webTransportCertificateHash");
+		if (d && (!("value" in d) || !d.enumerable) || !d && "webTransportAddress" in r || f && (!("value" in f) || !f.enumerable) || !f && "webTransportCertificateHash" in r) throw new t({ detail: "Room host native endpoint requires own routing data" });
+		let p = v(r.address, d?.value, f?.value);
+		for (let e of [
+			"pools",
+			"pool",
+			"clientCapacity"
+		]) {
+			let n = Object.getOwnPropertyDescriptor(r, e);
+			if (n && (!n.enumerable || !("value" in n)) || !n && e in r) throw new t({ detail: "Host pool options require own data" });
+		}
+		if (r.pools === void 0) {
+			if (r.pool !== void 0 || r.clientCapacity !== void 0) throw new t({ detail: "Host pool options require an admitted topology" });
+		} else {
+			let e = ie(r.pools, n.inventory().map((e) => e.descriptor.name)), i = r.pool ?? e.default, a = Object.hasOwn(e.pools, i) ? e.pools[i] : void 0, o = r.clientCapacity ?? a?.capacity?.clients;
+			if (!a || !a.regions.includes(r.region) || !Number.isSafeInteger(o) || o < 1) throw new t({ detail: "Host pool requires an explicit positive client capacity" });
+			r = {
+				...r,
+				pools: e,
+				pool: i,
+				clientCapacity: o
+			};
+		}
+		let m = new Set(oe(r.pools, r.pool, n.inventory().map((e) => e.descriptor.name))), h = n.inventory().filter((e) => m.has(e.descriptor.name));
+		if (u?.worlds.some((e) => e.geometry && [...e.zones, ...e.instances].some((e) => m.has(e.room) && n.get(e.room).mode === "lockstep"))) throw new t({ detail: "World geometry requires its state-sync Host preparation; Lockstep geometry binding remains unimplemented" });
+		if (r.startSuspended !== void 0 && typeof r.startSuspended != "boolean") throw new t({ detail: "Invalid host activation policy" });
+		if (r.spectatorGroups !== void 0 && typeof r.spectatorGroups != "function") throw new t({ detail: "Invalid spectator view-group resolver" });
+		if (r.replayRecordings !== void 0 && typeof r.replayRecordings != "function") throw new t({ detail: "Invalid host replay recording resolver" });
+		if (!r.spectatorGroups && h.some((e) => e.descriptor.spectator)) throw new t({ detail: "Configured spectator history requires a host view-group resolver before registration" });
+		if (h.some((e) => e.descriptor.mode === "lockstep")) {
+			if (r.ports === void 0) throw new t({ detail: "Declared Lockstep requires complete coordinated erasure before host registration" });
+			let e = s(r.ports, [
+				"directory",
+				"checkpoints",
+				"recovery",
+				"erasure",
+				"hostDrain",
+				"lockstepAdmission",
+				"lockstepJournal",
+				"lockstepTerminal"
+			], ["erasure"]), n = s(e.erasure, ["erase"], ["erase"]), i = s(r.strategies ?? {}, [
+				"selectHost",
+				"seatToken",
+				"snapshotBudget",
+				"lockstepSeed",
+				"lockstepPlayerId",
+				"lockstepStart"
+			], []);
+			if (typeof n.erase != "function" || [
+				"lockstepSeed",
+				"lockstepPlayerId",
+				"lockstepStart"
+			].some((e) => Object.hasOwn(i, e) && typeof i[e] != "function")) throw new t({ detail: "Declared Lockstep needs complete coordinated erasure and callable server seed/initial roster slots" });
+			for (let n of [
+				"lockstepAdmission",
+				"lockstepJournal",
+				"lockstepTerminal"
+			]) if (Object.hasOwn(e, n) && typeof e[n] != "function") throw new t({ detail: "Lockstep replacement must provide an actual complete scoped capability factory" });
+			r = {
+				...r,
+				ports: Object.freeze({
+					...e,
+					erasure: Object.freeze({ erase: n.erase.bind(e.erasure) })
+				}),
+				strategies: Object.freeze(i),
+				lockstepTransport: Pe(r.lockstepTransport)
+			};
+		}
+		let g;
+		if (r.worldPersistence !== void 0) {
+			let e = r.worldPersistence, n = Object.getOwnPropertyDescriptor(e, "runDue"), i = Object.getOwnPropertyDescriptor(e, "close");
+			if (!n || !("value" in n) || typeof n.value != "function" || !i || !("value" in i) || typeof i.value != "function") throw new t({ detail: "World persistence requires explicit complete supervisor methods" });
+			let a = e.runDue.bind(e), o = e.close.bind(e), s = (e) => G.suspend(() => {
+				let n = e();
+				return G.isEffect(n) ? n : G.fail(new t({ detail: "World persistence supervisor requires an Effect" }));
+			});
+			g = Object.freeze({
+				runDue: () => s(a),
+				close: () => s(o)
+			});
+		}
+		r = {
+			...r,
+			worlds: r.worlds === void 0 ? void 0 : ee(r.worlds),
+			address: p.ws,
+			webTransportAddress: p.wt,
+			webTransportCertificateHash: p.wtCertificateHash,
+			spectatorGroups: r.spectatorGroups,
+			worldPersistence: g,
+			...u ? { geometry: u } : {}
+		}, te(r.secrets), T(r.strategies?.seatToken);
+		let _ = L(r.strategies?.snapshotBudget ?? Re, r.snapshotBudget ?? {});
+		for (let e of [
+			r.capacity,
+			r.heartbeatTtlMs,
+			r.heartbeatEveryMs,
+			r.seatTtlMs,
+			r.maxQueuedOperations ?? 128
+		]) if (!Number.isSafeInteger(e) || e <= 0) throw new t({ detail: "Invalid host control budgets" });
+		if (r.heartbeatEveryMs >= r.heartbeatTtlMs) throw new t({ detail: "Host heartbeat cadence must be shorter than its routing TTL" });
+		let y = r.measuredCpu();
+		if (!Number.isFinite(y) || y < 0 || y > 1) throw new t({ detail: "Host CPU must be an actual normalized measurement" });
+		let b = r.ports?.directory ?? qe(e, {
+			epochNow: r.epochNow,
+			heartbeatTtlMs: r.heartbeatTtlMs,
+			strategies: r.strategies,
+			pools: r.pools
+		}), x = await Y(b.register({
+			address: r.address,
+			webTransportAddress: r.webTransportAddress,
+			webTransportCertificateHash: r.webTransportCertificateHash,
+			region: r.region,
+			capacity: r.capacity,
+			pool: r.pool,
+			clientCapacity: r.clientCapacity,
+			ready: r.startSuspended !== !0,
+			membership: r.membership,
+			load: {
+				rooms: 0,
+				clients: 0,
+				cpu: y
+			}
+		}));
+		if (x.pool !== r.pool || x.clientCapacity !== r.clientCapacity || x.region !== r.region || x.capacity !== r.capacity || x.address !== p.ws || x.webTransportAddress !== p.wt || x.webTransportCertificateHash !== p.wtCertificateHash || x.ready !== (r.startSuspended !== !0) || r.membership && (x.membership?.instanceId !== r.membership.instanceId || x.membership?.startedAt !== r.membership.startedAt)) {
+			let e = Q(b, x.id);
+			try {
+				await e();
+			} catch {
+				throw new Z(e);
+			}
+			throw new t({ detail: "Room directory provider did not preserve requested readiness admission" });
+		}
+		try {
+			return new $(x, n, e, r, b, _);
+		} catch (e) {
+			let t = Q(b, x.id);
+			try {
+				await t();
+			} catch {
+				throw new Z(t);
+			}
+			throw e;
+		}
+	}
+	spectatorGroup(e, n, r, i) {
+		if (!e.spectator) return;
+		if (!this.spectatorGroups) throw new t({ detail: "Room spectator policy requires a host-owned view-group resolver" });
+		let a = this.spectatorGroups(Object.freeze({
+			roomId: n,
+			tenantId: r,
+			epoch: i,
+			name: e.name
+		}));
+		if (!a || typeof a.view != "function" || typeof a.authorize != "function") throw new t({ detail: "Spectator resolver must return a synchronous complete group binding" });
+		return Object.freeze({
+			view: a.view.bind(a),
+			authorize: a.authorize.bind(a)
+		});
+	}
+	requireOwned(e, t) {
+		let n = this.owned.get(e);
+		if (!n || n.listing.tenantId !== t) throw new i({ roomId: e });
+		return n;
+	}
+	async authorize(e, t, r, i = "", a) {
+		let o = X(t);
+		if (this.options.pools && ae(this.options.pools, e.name, o.tenantId, this.host.region, this.host.pool), o.subjectId === null && e.auth !== "public" || await Y(Ze(t, e.guards, r, {
+			defaultDeny: !0,
+			procedure: `rooms.${e.name}`
+		}), a)) throw new n({ roomId: i });
+		return o;
+	}
+	operation(t, n = !1) {
+		return this.closed || (!this.activated || this.closing) && !n ? Promise.reject(new i({ roomId: "host" })) : this.queued >= this.maxQueued ? Promise.reject(new e({
+			budget: "hostControlOperations",
+			limit: this.maxQueued
+		})) : F(this, this.queued !== 0, () => {
+			this.queued++;
+			let e = this.lane.then(t);
+			return this.lane = e.then(() => {
+				this.queued--;
+			}, () => {
+				this.queued--;
+			}), e;
+		});
+	}
+	worldOperation(e) {
+		if (this.closed || !this.activated) return Promise.reject(new i({ roomId: "host" }));
+		let t = we(this, e);
+		if (t) return t;
+		let n = this.commandWindow;
+		return n ? F(this, this.queued !== 0, () => this.enqueueCommandWorld(n, e)) : this.operation(e);
+	}
+	enqueueCommandWorld(n, r) {
+		return this.commandWindow === n ? this.queued >= this.maxQueued ? Promise.reject(new e({
+			budget: "hostControlOperations",
+			limit: this.maxQueued
+		})) : (this.queued++, n.run(r).finally(() => {
+			this.queued--;
+		})) : Promise.reject(new t({ detail: "Host command World operation window has expired" }));
+	}
+	async executeAppCommand(e) {
+		if (this.commandWindow) throw new t({ detail: "Host application command windows cannot overlap" });
+		let n = Ce(this);
+		this.commandWindow = n;
+		try {
+			await Te(this, e, (e) => this.enqueueCommandWorld(n, e));
+		} finally {
+			try {
+				await n.close();
+			} finally {
+				this.commandWindow = null;
+			}
+		}
+	}
+	capturedWorldOperation(e, n) {
+		try {
+			let t = e();
+			return this.worldOperation(() => n(t));
+		} catch {
+			return Promise.reject(new t({ detail: "World Host command request could not be captured" }));
+		}
+	}
+	capturedOperation(e, n, r = !1) {
+		try {
+			let t = e();
+			return this.operation(() => n(t), r);
+		} catch {
+			return Promise.reject(new t({ detail: "Room host request could not be captured" }));
+		}
+	}
+	activate() {
+		return this.operation(async () => {
+			if (this.closing || this.closed) throw new i({ roomId: "host" });
+			if (this.activated) return;
+			let e = this.runtime.metrics();
+			if (await Y(this.directory.heartbeat(this.host.id, {
+				rooms: e.ownedRooms,
+				clients: e.sessions,
+				cpu: this.options.measuredCpu()
+			})), await Y(this.directory.setReady(this.host.id, !0)), this.closing) throw new i({ roomId: "host" });
+			this.activated = !0;
+		}, !0);
+	}
+	create(n, r, i, a = {}, o) {
+		return this.capturedOperation(() => ({
+			options: structuredClone(r),
+			subject: structuredClone(i),
+			listing: structuredClone(a),
+			attributes: o === void 0 ? void 0 : u(n, o)
+		}), async ({ options: r, subject: i, listing: a, attributes: o }) => {
+			if (await this.cleanupGeometry(), this.owned.size + this.uninstalledCreations.size + this.pendingGeometryCleanup.size >= this.options.capacity) throw new e({
+				budget: "retainedHostRooms",
+				limit: this.options.capacity
+			});
+			let s = this.catalog.get(n), c = await this.authorize(s, i, {
+				name: n,
+				options: r
+			});
+			if (this.options.worlds?.some((e) => e.instances.some((e) => e.room === n))) throw new t({ detail: "Instance Room creation requires an explicit group placement" });
+			if (await w(this.store, c), s.mode === "lockstep") return this.createLockstep(s, r, i, c, a);
+			if (!s.initialState) throw new t({ detail: "Room author must define initialState before creation is available" });
+			let l = q.decodeUnknownSync(s.options)(r), u = C(q.encodeSync(s.options)(l)), d = JSON.parse(u), f = await Y(this.directory.createOwnedRoom(this.host.id, {
+				...c,
+				pool: this.host.pool,
+				name: n,
+				options: d,
+				maxClients: s.maxClients,
+				metadata: a.metadata ?? {},
+				private: a.private ?? !1,
+				staged: !0
+			}));
+			return await this.installCreatedRoom(f, s, r, u, a.private ?? !1), Y(this.reservationsFor(i).reserve(f.id, c, "player", o));
+		});
+	}
+	prepareMatchRoom(n, r, i, a) {
+		return this.capturedOperation(() => ({
+			options: structuredClone(r),
+			subject: structuredClone(i),
+			requestId: String(a)
+		}), async (r) => {
+			await this.cleanupGeometry();
+			let i = this.catalog.get(n);
+			if (i.world || this.options.worlds?.some((e) => e.zones.some((e) => e.room === n) || e.instances.some((e) => e.room === n))) throw new t({ detail: "World Rooms are placed by their World, not as match Rooms" });
+			if (i.mode === "lockstep" || !i.initialState) throw new t({ detail: "Match Rooms need a state-sync Room with initialState" });
+			let a = await this.authorize(i, r.subject, {
+				name: n,
+				options: r.options
+			});
+			await w(this.store, a);
+			let o = q.decodeUnknownSync(i.options)(r.options), s = C(q.encodeSync(i.options)(o)), c = await Y(this.directory.createOwnedRoom(this.host.id, {
+				...a,
+				pool: this.host.pool,
+				name: n,
+				options: JSON.parse(s),
+				maxClients: i.maxClients,
+				metadata: {},
+				private: !0,
+				staged: !0,
+				creationKey: Ge(a.tenantId, n, r.requestId)
+			})), l = this.owned.get(c.id);
+			if (l) {
+				if (l.listing.tenantId !== a.tenantId || l.listing.epoch !== c.epoch || l.descriptor !== i || l.optionFingerprint !== s) throw new t({ detail: "Match Room retry changed its Room" });
+				return (!l.published || this.runtime.hasPendingCheckpoint(c.id)) && await this.runtime.persist(c.id), l.published = !0, c;
+			}
+			let u = await Y(this.directory.observeOwnership(c.id, a.tenantId));
+			if (u?.state !== "creating" || u.hostId !== this.host.id || u.epoch !== c.epoch) throw new t({ detail: "Match Room retry cannot reset a published Room" });
+			if (this.owned.size + this.uninstalledCreations.size + this.pendingGeometryCleanup.size >= this.options.capacity) throw new e({
+				budget: "retainedHostRooms",
+				limit: this.options.capacity
+			});
+			try {
+				return await this.installCreatedRoom(c, i, r.options, s, !0), c;
+			} catch (e) {
+				if (!this.owned.has(c.id) && !this.pendingGeometryCleanup.has(c.id)) {
+					this.pendingGeometryCleanup.set(c.id, {
+						listing: c,
+						geometry: void 0,
+						abandonCreation: !0
+					});
+					try {
+						await this.cleanupGeometry();
+					} catch (t) {
+						throw AggregateError([e, t], "Match Room creation cleanup remains retained");
+					}
+				}
+				throw e;
+			}
+		});
+	}
+	prepareWorldRoom(n, r, i, a, o, s = 1, c) {
+		return this.capturedWorldOperation(() => ({
+			options: structuredClone(r),
+			subject: structuredClone(i),
+			creationKey: a,
+			creationGeneration: s,
+			worldCell: o === void 0 ? void 0 : h(o, 4096),
+			worldInstance: c === void 0 ? void 0 : h(c, 4096)
+		}), async (r) => {
+			await this.cleanupGeometry();
+			let i = this.catalog.get(n);
+			if (!i.world || !i.initialState || !this.options.worlds?.some((e) => e.zones.some((e) => e.room === n) || e.instances.some((e) => e.room === n))) throw new t({ detail: "World Room preparation requires an actual configured state-sync World Room" });
+			let a = r.worldCell, o = r.worldInstance, s = {
+				name: n,
+				options: r.options,
+				...a ? {
+					worldCell: a,
+					creationGeneration: r.creationGeneration
+				} : {},
+				...o ? {
+					worldInstance: o,
+					creationGeneration: r.creationGeneration,
+					operation: r.creationGeneration > 1 ? "reset" : "prepare"
+				} : {}
+			}, c = await this.authorize(i, r.subject, s);
+			if (await w(this.store, c), !Number.isSafeInteger(r.creationGeneration) || r.creationGeneration < 1 || r.creationGeneration > 2147483647 || !a && !o && r.creationGeneration !== 1) throw new t({ detail: "World creation generation requires an explicit bounded placement" });
+			if (o && (a || Object.keys(o).sort().join(",") !== "groupId,instance,tenantId,worldId" || o.tenantId !== c.tenantId || j(o, r.creationGeneration) !== r.creationKey || !this.options.worlds.some((e) => e.name === o.worldId && e.instances.some((e) => e.id === o.instance && e.room === n)) || this.options.worlds.some((e) => e.zones.some((e) => e.room === n)))) throw new t({ detail: "World instance creation differs from its actual group and Room authority" });
+			if (!o && this.options.worlds.some((e) => e.instances.some((e) => e.room === n))) throw new t({ detail: "Instance Room preparation requires an explicit group placement" });
+			o && r.creationGeneration > 1 && await ye(this.store, this.options.worlds.find((e) => e.name === o.worldId), o, r.creationGeneration);
+			let l = o ? be(this.store, {
+				worlds: this.options.worlds,
+				epochNow: this.options.epochNow,
+				maxManagedGroups: 65536,
+				authorize: (e) => G.tryPromise({
+					try: async () => {
+						await this.authorize(i, r.subject, {
+							...s,
+							operation: e
+						}), await w(this.store, c);
+					},
+					catch: () => new t({ detail: "Instance group placement authorization is no longer current" })
+				})
+			}) : void 0, u = a && this.options.worlds.find((e) => e.name === a.worldId);
+			if (a && (Object.keys(a).sort().join(",") !== "at,layer,worldId,zoneId" || !u || !Number.isSafeInteger(a.layer) || a.layer < 1 || !u.zones.some((e) => e.id === a.zoneId && e.room === n && (e.layering || a.layer === 1)) || Se(c.tenantId, u, a, r.creationGeneration) !== r.creationKey)) throw new t({ detail: "World creation placement does not match its admitted cell digest" });
+			a && u && r.creationGeneration > 1 && await xe(this.store, c.tenantId, u, a, r.creationGeneration);
+			let d = a ? D(this.store, {
+				worlds: this.options.worlds,
+				epochNow: this.options.epochNow,
+				maxListedCells: 1,
+				authorize: () => G.tryPromise({
+					try: async () => {
+						await this.authorize(i, r.subject, s), await w(this.store, c);
+					},
+					catch: () => new t({ detail: "World placement authorization is no longer current" })
+				})
+			}) : void 0, f = q.decodeUnknownSync(i.options)(r.options), p = C(q.encodeSync(i.options)(f)), m = await Y(this.directory.createOwnedRoom(this.host.id, {
+				...c,
+				pool: this.host.pool,
+				name: n,
+				options: JSON.parse(p),
+				maxClients: i.maxClients,
+				metadata: {},
+				private: !0,
+				staged: !0,
+				creationKey: r.creationKey
+			})), h = this.owned.get(m.id);
+			if (h) {
+				if (h.listing.tenantId !== c.tenantId || h.listing.epoch !== m.epoch || h.descriptor !== i || h.optionFingerprint !== p) throw new t({ detail: "World creation retry changed its actual actor" });
+				return (!h.published || this.runtime.hasPendingCheckpoint(m.id)) && await this.runtime.persist(m.id), d && a && await Y(d.publish({
+					tenantId: c.tenantId,
+					...a,
+					roomId: m.id,
+					hostId: this.host.id,
+					epoch: m.epoch
+				})), l && o && await Y(l.publish({
+					...o,
+					generation: r.creationGeneration,
+					roomId: m.id,
+					hostId: this.host.id,
+					epoch: m.epoch
+				})), h.published = !0, m;
+			}
+			let g = await Y(this.directory.observeOwnership(m.id, c.tenantId));
+			if (g?.state !== "creating" || g.hostId !== this.host.id || g.epoch !== m.epoch) throw new t({ detail: "World creation cannot reset a published actor; actual recovery is required" });
+			if (this.owned.size + this.uninstalledCreations.size + this.pendingGeometryCleanup.size >= this.options.capacity) throw new e({
+				budget: "retainedHostRooms",
+				limit: this.options.capacity
+			});
+			l && o && await Y((r.creationGeneration > 1 ? l.reset : l.prepare)({
+				...o,
+				generation: r.creationGeneration,
+				roomId: m.id,
+				hostId: this.host.id,
+				epoch: m.epoch
+			}));
+			try {
+				return d && a && await Y(d.prepare({
+					tenantId: c.tenantId,
+					...a,
+					roomId: m.id,
+					hostId: this.host.id,
+					epoch: m.epoch
+				})), await this.installCreatedRoom(m, i, r.options, p, !0), l && o && await Y(l.publish({
+					...o,
+					generation: r.creationGeneration,
+					roomId: m.id,
+					hostId: this.host.id,
+					epoch: m.epoch
+				})), d && a && await Y(d.publish({
+					tenantId: c.tenantId,
+					...a,
+					roomId: m.id,
+					hostId: this.host.id,
+					epoch: m.epoch
+				})), m;
+			} catch (e) {
+				if (!this.owned.has(m.id) && !this.pendingGeometryCleanup.has(m.id)) {
+					this.pendingGeometryCleanup.set(m.id, {
+						listing: m,
+						geometry: void 0,
+						abandonCreation: !0
+					});
+					try {
+						await this.cleanupGeometry();
+					} catch (t) {
+						throw AggregateError([e, t], "World placement creation cleanup remains retained");
+					}
+				}
+				throw e;
+			}
+		});
+	}
+	abandonWorldInstance(e, n, r = 1) {
+		return this.capturedWorldOperation(() => ({
+			identity: h(e, 4096),
+			subject: structuredClone(n),
+			generation: r
+		}), async (e) => {
+			let n = e.identity, r = j(n, e.generation);
+			if (Object.keys(n).sort().join(",") !== "groupId,instance,tenantId,worldId") throw new t({ detail: "Invalid instance abandonment identity" });
+			let i = this.options.worlds?.find((e) => e.name === n.worldId), a = i?.instances.find((e) => e.id === n.instance);
+			if (!i || !a) throw new t({ detail: "Instance abandonment requires its configured World" });
+			let o = this.catalog.get(a.room), s = await this.authorize(o, e.subject, {
+				worldInstance: n,
+				creationGeneration: e.generation,
+				operation: "abandon"
+			});
+			if (s.tenantId !== n.tenantId) throw new t({ detail: "Instance abandonment crossed its tenant" });
+			await w(this.store, s);
+			let c = await this.store.query({
+				table: b,
+				predicate: H(U("tenantId", s.tenantId), U("requestKey", r)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: ["roomId"]
+			});
+			if (c.length !== 1 || typeof c[0].roomId != "string") throw new t({ detail: "Instance abandonment requires its original creation receipt" });
+			let l = c[0].roomId, u = await this.store.query({
+				table: y,
+				predicate: H(U("id", l), U("tenantId", s.tenantId)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: ["name"]
+			});
+			if (u.length !== 1 || u[0].name !== a.room) throw new t({ detail: "Instance creation receipt names another declared Room" });
+			let d = () => {
+				if (this.owned.has(l) || this.uninstalledCreations.has(l)) throw new t({ detail: "Instance abandonment cannot replace a retained actor" });
+			};
+			d();
+			let f = await Y(this.directory.observeOwnership(l, s.tenantId));
+			if (!f || f.hostId !== this.host.id || f.epoch !== 1 || !["creating", "disposed"].includes(f.state)) throw new t({ detail: "Instance abandonment lost original unpublished ownership" });
+			f.state === "creating" && await Y(this.directory.abandonCreation(this.host.id, l, s.tenantId)), await M(this.store, this.options.worlds, {
+				tenantId: s.tenantId,
+				roomId: l,
+				hostId: this.host.id,
+				epoch: 1
+			}, this.options.epochNow, d), await this.cleanupGeometry();
+		});
+	}
+	async installCreatedRoom(e, n, r, a, o) {
+		if (n.mode === "lockstep") throw new t({ detail: "Lockstep rooms install through lockstep admission" });
+		let s = !1, c;
+		try {
+			if (c = await Y(z(this.geometry, {
+				roomId: e.id,
+				tenantId: e.tenantId,
+				hostId: this.host.id,
+				epoch: e.epoch,
+				name: n.name
+			})), c) {
+				let t = await Y(this.directory.observeOwnership(e.id, e.tenantId));
+				if (V(t, {
+					roomId: e.id,
+					tenantId: e.tenantId,
+					hostId: this.host.id,
+					epoch: e.epoch
+				}) || t?.state !== "creating" && t?.state !== "live") throw new i({ roomId: e.id });
+			}
+			return this.runtime.create(e.id, e.tenantId, n, r, e.epoch, this.reservationsFor().admission, {
+				epochNow: this.options.epochNow,
+				secrets: this.options.secrets,
+				seatToken: this.seatToken,
+				authorizeWorldTarget: this.authorizeWorldTarget,
+				...this.options.resolveWorldPlayer ? { authorizeWorldPlayer: this.authorizeWorldPlayer } : {},
+				...c ? { geometry: c } : {},
+				spectatorGroup: this.spectatorGroup(n, e.id, e.tenantId, e.epoch),
+				replayRecording: this.replayRecordings?.(Object.freeze({
+					roomId: e.id,
+					tenantId: e.tenantId,
+					name: n.name,
+					epoch: e.epoch
+				}))
+			}), s = !0, this.owned.set(e.id, {
+				listing: e,
+				descriptor: n,
+				optionFingerprint: a,
+				private: o,
+				published: !1,
+				...c ? { geometry: c } : {}
+			}), await this.runtime.persist(e.id), this.requireOwned(e.id, e.tenantId).published = !0, e;
+		} catch (t) {
+			if (!s) {
+				this.pendingGeometryCleanup.set(e.id, {
+					listing: e,
+					geometry: c,
+					abandonCreation: !0
+				});
+				try {
+					await this.cleanupGeometry();
+				} catch (e) {
+					throw AggregateError([t, e], "Room creation and compensation failed");
+				}
+			}
+			throw t;
+		}
+	}
+	kickSubject(e, n, r, a) {
+		return this.capturedOperation(() => ({
+			roomId: String(e),
+			tenantId: String(n),
+			subjectId: String(r),
+			reason: String(a)
+		}), async (e) => {
+			if (!e.roomId || !e.tenantId || !e.subjectId || e.reason.length > 200) throw new t({ detail: "Invalid Room kick request" });
+			if (!this.requireOwned(e.roomId, e.tenantId).published) throw new i({ roomId: e.roomId });
+			return { kicked: await this.runtime.kickSubject(e.roomId, e.tenantId, e.subjectId, e.reason) };
+		});
+	}
+	closeSessions(e, n, r) {
+		return this.capturedOperation(() => ({
+			roomId: String(e),
+			tenantId: String(n),
+			reason: String(r)
+		}), async (e) => {
+			if (!e.roomId || !e.tenantId || e.reason.length > 200) throw new t({ detail: "Invalid Room close request" });
+			if (!this.requireOwned(e.roomId, e.tenantId).published) throw new i({ roomId: e.roomId });
+			return { kicked: await this.runtime.kickSubject(e.roomId, e.tenantId, null, e.reason) };
+		});
+	}
+	reloadGeometry(e, n, r) {
+		return this.capturedOperation(() => ({
+			roomId: f(e),
+			request: p(n),
+			subject: structuredClone(r)
+		}), async (e) => {
+			let n = X(e.subject), r = this.requireOwned(e.roomId, n.tenantId), a = r.geometry, o = this.geometry?.reload;
+			if (!a || !o || !r.published || r.descriptor.mode === "lockstep") throw new t({ detail: "Room has no admitted administrative geometry reload source" });
+			let s = async () => {
+				await w(this.store, n), await Y(o.authorize(e.subject, a, e.request));
+				let t = await Y(this.directory.observeOwnership(e.roomId, n.tenantId));
+				if (V(t, {
+					roomId: e.roomId,
+					tenantId: n.tenantId,
+					hostId: this.host.id,
+					epoch: r.listing.epoch
+				}) || t?.state !== "live") throw r.published = !1, await this.runtime.withdrawOwnership(e.roomId, n.tenantId, r.listing.epoch), new i({ roomId: e.roomId });
+			};
+			if (this.geometryRollbacks.get(e.roomId)?.admitted === !1) throw new t({ detail: "Incomplete geometry rollback must resolve before reload" });
+			await s(), await this.releaseGeometryRollback(e.roomId);
+			let c = C([
+				n.tenantId,
+				n.subjectId,
+				e.subject.type
+			]), l = this.geometryReloads.get(e.roomId), u = l !== void 0 && JSON.stringify(l.request) === JSON.stringify(e.request) && l.subjectKey === c;
+			if (l && !l.admitted && !u) throw new t({ detail: "Incomplete geometry reload requires its exact owner request and Subject" });
+			if (l?.releasePending && await this.releaseGeometryReload(e.roomId), u && l?.admitted) return;
+			let d = u ? l : {
+				resource: a,
+				request: e.request,
+				subjectKey: c,
+				token: null,
+				admitted: !1,
+				releasePending: !1
+			};
+			this.geometryReloads.set(e.roomId, d);
+			let f = null;
+			try {
+				d.token ||= (await this.runtime.quiesceGeometry(e.roomId), d.releasePending = !0, await Y(o.prepare(a, d.request))), await s(), d.releasePending = !0, await Y(o.resume(a, d.request, d.token)), await s(), await this.runtime.activateGeometryVersion(e.roomId, d.token), d.admitted = !0;
+			} catch (e) {
+				f = e;
+			}
+			try {
+				await this.releaseGeometryReload(e.roomId);
+			} catch {
+				throw new t({ detail: "Geometry reload coordination cleanup remains retained; repeat its exact request" });
+			}
+			if (f) throw f;
+		});
+	}
+	async releaseGeometryReload(e) {
+		let n = this.geometryReloads.get(e), r = this.geometry?.reload;
+		if (n?.releasePending) {
+			if (!r) throw new t({ detail: "Actual geometry reload cleanup source is missing" });
+			await Y(r.release(n.resource, n.request)), n.releasePending = !1;
+		}
+	}
+	rollbackGeometry(e, n, r) {
+		return this.capturedOperation(() => ({
+			roomId: f(e),
+			request: m(n),
+			subject: structuredClone(r)
+		}), async (e) => {
+			let n = X(e.subject), r = this.requireOwned(e.roomId, n.tenantId), a = r.geometry, o = this.geometry?.rollback;
+			if (!a || !o || !r.published || r.descriptor.mode === "lockstep") throw new t({ detail: "Room has no admitted administrative geometry rollback source" });
+			let s = async () => {
+				await w(this.store, n), e.request.target !== null && await w(this.store, {
+					tenantId: n.tenantId,
+					subjectId: e.request.target.id
+				}), await Y(o.authorize(e.subject, a, e.request));
+				let t = await Y(this.directory.observeOwnership(e.roomId, n.tenantId));
+				if (V(t, {
+					roomId: e.roomId,
+					tenantId: n.tenantId,
+					hostId: this.host.id,
+					epoch: r.listing.epoch
+				}) || t?.state !== "live") throw r.published = !1, await this.runtime.withdrawOwnership(e.roomId, n.tenantId, r.listing.epoch), new i({ roomId: e.roomId });
+			};
+			if (this.geometryReloads.get(e.roomId)?.admitted === !1) throw new t({ detail: "Incomplete geometry reload must resolve before rollback" });
+			await s(), await this.releaseGeometryReload(e.roomId);
+			let c = C([
+				n.tenantId,
+				n.subjectId,
+				e.subject.type
+			]), l = this.geometryRollbacks.get(e.roomId), u = l !== void 0 && JSON.stringify(l.request) === JSON.stringify(e.request) && l.subjectKey === c;
+			if (l && !l.admitted && !u) throw new t({ detail: "Incomplete geometry rollback requires its exact owner request and Subject" });
+			if (l?.releasePending && l.token && await this.releaseGeometryRollback(e.roomId), u && l?.admitted) return;
+			let d = u ? l : {
+				resource: a,
+				request: e.request,
+				subjectKey: c,
+				token: null,
+				admitted: !1,
+				releasePending: !1
+			};
+			this.geometryRollbacks.set(e.roomId, d);
+			let f = null;
+			try {
+				d.token ||= (await this.runtime.quiesceGeometry(e.roomId), d.releasePending = !0, await Y(o.prepare(e.subject, a, d.request))), await s(), d.releasePending = !0, await Y(o.resume(e.subject, a, d.request, d.token)), await s(), await this.runtime.activateGeometryChange(e.roomId, d.token), d.admitted = !0;
+			} catch (e) {
+				f = e;
+			}
+			try {
+				await this.releaseGeometryRollback(e.roomId);
+			} catch {
+				throw new t({ detail: "Geometry rollback coordination cleanup remains retained; repeat its exact request" });
+			}
+			if (f) throw f;
+		});
+	}
+	async releaseGeometryRollback(e) {
+		let n = this.geometryRollbacks.get(e), r = this.geometry?.rollback;
+		if (n?.releasePending) {
+			if (!r) throw new t({ detail: "Actual geometry rollback cleanup source is missing" });
+			await Y(r.release(n.resource, n.request)), n.releasePending = !1;
+		}
+	}
+	lockstepServices(e, n) {
+		let r = this.options.ports?.erasure;
+		if (!r) throw new t({ detail: "Lockstep ownership requires complete coordinated erasure" });
+		let i = Object.freeze({
+			hostId: this.host.id,
+			roomId: n.id,
+			tenantId: n.tenantId,
+			epoch: n.epoch
+		}), a = {
+			roomId: n.id,
+			tenantId: n.tenantId,
+			epoch: n.epoch
+		}, o = (e) => e.roomId === i.roomId && e.tenantId === i.tenantId && e.epoch === i.epoch ? G.void : G.fail(new t({ detail: "Lockstep capability escaped the current controller Room scope" })), s = {
+			hostId: this.host.id,
+			epochNow: this.options.epochNow,
+			erasure: r,
+			authorize: o
+		}, l = this.options.ports?.lockstepAdmission?.(e, i) ?? Ie(this.store, e, s), u = this.options.ports?.lockstepJournal?.(e, i) ?? Fe(this.store, e.simulation, {
+			...s,
+			maxPlayers: e.maxClients
+		});
+		return {
+			journalScope: a,
+			terminal: this.options.ports?.lockstepTerminal?.(e, i) ?? Le(this.store, e, {
+				hostId: this.host.id,
+				epochNow: this.options.epochNow,
+				authorize: o
+			}),
+			dependencies: {
+				maxCatchUpTicks: c(e, E(this.options.pools, this.options.pool)),
+				hostId: this.host.id,
+				admission: l,
+				journal: u,
+				runEffect: G.runPromise,
+				clock: this.options.clock,
+				seats: this.reservationsFor().admission,
+				sessionOptions: {
+					epochNow: this.options.epochNow,
+					secrets: this.options.secrets,
+					seatToken: this.seatToken
+				},
+				transport: this.options.lockstepTransport
+			}
+		};
+	}
+	async installLockstepSuccessor(e) {
+		let r = e.listing, i = this.owned.get(r.id);
+		if (i) {
+			if (i.descriptor.mode !== "lockstep" || i.listing.tenantId !== r.tenantId || i.listing.epoch !== r.epoch || !this.runtime.retains(r.id)) throw new n({ roomId: r.id });
+			return;
+		}
+		let a = this.catalog.get(r.name);
+		if (a.mode !== "lockstep" || r.maxClients !== a.maxClients) throw new t({ detail: "Recovered Lockstep declaration or capacity changed" });
+		let { journalScope: o, terminal: s, dependencies: c } = this.lockstepServices(a, r), u = await B.restore(a, o, e.lockstep, c);
+		try {
+			let t = Buffer.from(l(a.simulation).encode(e.lockstep.options)).toString("base64url");
+			this.runtime.addLockstep(u, {
+				terminal: s,
+				runEffect: G.runPromise
+			}), this.owned.set(r.id, {
+				listing: r,
+				descriptor: a,
+				optionFingerprint: t,
+				private: e.private,
+				published: !1
+			});
+		} catch (e) {
+			try {
+				await u.disposeAsync(!0);
+			} catch (t) {
+				throw AggregateError([e, t], "Lockstep successor installation and withdrawal failed");
+			}
+			throw e;
+		}
+	}
+	async createLockstep(e, n, r, i, a) {
+		if (i.subjectId === null || !this.options.ports?.erasure) throw new t({ detail: "Lockstep creation requires Subject identity and complete coordinated erasure" });
+		let o = l(e.simulation), s = o.capture(n), c = Buffer.from(o.encode(s)).toString("base64url"), u = We(this.lockstepSeed), d = await Y(this.directory.createOwnedRoom(this.host.id, {
+			...i,
+			pool: this.host.pool,
+			name: e.name,
+			options: null,
+			maxClients: e.maxClients,
+			metadata: a.metadata ?? {},
+			private: a.private ?? !1,
+			staged: !0
+		})), { journalScope: f, terminal: p, dependencies: m } = this.lockstepServices(e, d), h = null, g = !1;
+		try {
+			return h = await B.create(e, {
+				...f,
+				requestId: `room:${d.id}:creation`,
+				creatorSubjectId: i.subjectId,
+				seed: u,
+				options: s
+			}, m), this.runtime.addLockstep(h, {
+				terminal: p,
+				runEffect: G.runPromise
+			}), g = !0, this.owned.set(d.id, {
+				listing: d,
+				descriptor: e,
+				optionFingerprint: c,
+				private: a.private ?? !1,
+				published: !1
+			}), await this.runtime.publishLockstep(d.id), this.requireOwned(d.id, i.tenantId).published = !0, await Y(this.reservationsFor(r).reserve(d.id, i));
+		} catch (e) {
+			if (!g) {
+				this.uninstalledCreations.set(d.id, {
+					listing: d,
+					owner: h
+				});
+				try {
+					await this.cleanupUninstalledCreations();
+				} catch (t) {
+					throw AggregateError([e, t], "Lockstep creation and retained cleanup failed");
+				}
+			}
+			throw e;
+		}
+	}
+	async cleanupUninstalledCreations() {
+		let e = [];
+		for (let [t, n] of this.uninstalledCreations) try {
+			n.owner && await n.owner.disposeAsync();
+			let e = await Y(this.directory.observeOwnership(t, n.listing.tenantId));
+			!V(e, {
+				roomId: t,
+				tenantId: n.listing.tenantId,
+				hostId: this.host.id,
+				epoch: n.listing.epoch
+			}) && e?.state !== "disposed" && await Y(this.directory.abandonCreation(this.host.id, t, n.listing.tenantId)), this.uninstalledCreations.delete(t);
+		} catch (t) {
+			e.push(t);
+		}
+		if (e.length) throw AggregateError(e, "Uninstalled Lockstep creation cleanup remains retained");
+	}
+	async cleanupGeometry() {
+		let e = [];
+		for (let [n, r] of this.pendingGeometryCleanup) try {
+			if (await r.geometry?.close(), r.abandonCreation) {
+				let e = await Y(this.directory.observeOwnership(n, r.listing.tenantId));
+				if (!V(e, {
+					roomId: n,
+					tenantId: r.listing.tenantId,
+					hostId: this.host.id,
+					epoch: r.listing.epoch
+				}) && e?.state !== "disposed" && await Y(this.directory.abandonCreation(this.host.id, n, r.listing.tenantId)), this.geometry?.cleanupCreation) {
+					let e = this.geometry.cleanupCreation(Object.freeze({
+						roomId: n,
+						tenantId: r.listing.tenantId,
+						hostId: this.host.id,
+						epoch: r.listing.epoch,
+						name: r.listing.name
+					}));
+					if (!G.isEffect(e) || await Y(e) !== void 0) throw new t({ detail: "World creating-Room routing cleanup must confirm its actual Effect" });
+				}
+				if (this.options.worlds?.length && this.catalog.get(r.listing.name).world) {
+					if (this.options.worlds.some((e) => e.instances.some((e) => e.room === r.listing.name))) {
+						await M(this.store, this.options.worlds, {
+							tenantId: r.listing.tenantId,
+							roomId: n,
+							hostId: this.host.id,
+							epoch: r.listing.epoch
+						}, this.options.epochNow, () => {
+							if (this.pendingGeometryCleanup.get(n) !== r || this.owned.has(n)) throw new t({ detail: "Failed instance cleanup lost retained creation authority" });
+						}), this.pendingGeometryCleanup.delete(n);
+						continue;
+					}
+					await Y(D(this.store, {
+						worlds: this.options.worlds,
+						epochNow: this.options.epochNow,
+						maxListedCells: 1,
+						authorize: (e, i) => G.sync(() => {
+							if (this.pendingGeometryCleanup.get(n) !== r || i.tenantId !== r.listing.tenantId) throw new t({ detail: "World creation cleanup lost its retained Host owner" });
+						})
+					}).synchronizeRoom({
+						tenantId: r.listing.tenantId,
+						roomId: n,
+						hostId: this.host.id,
+						epoch: r.listing.epoch
+					}));
+				}
+			}
+			this.pendingGeometryCleanup.delete(n);
+		} catch (t) {
+			e.push(t);
+		}
+		if (e.length) throw AggregateError(e, "Exact uninstalled geometry cleanup remains retained");
+	}
+	admitLockstep(e, t, n, r) {
+		return this.operation(async () => {
+			let a = this.requireOwned(e, t);
+			if (!a.published || a.descriptor.mode !== "lockstep") throw new i({ roomId: e });
+			return this.runtime.admitLockstep(e, n, r);
+		});
+	}
+	startLockstep(e, t) {
+		return this.operation(async () => {
+			let n = this.requireOwned(e, t);
+			if (!n.published || n.descriptor.mode !== "lockstep") throw new i({ roomId: e });
+			return this.runtime.startLockstep(e);
+		});
+	}
+	captureWorldTransitionSnapshot(e, n, r, a, o) {
+		return this.capturedWorldOperation(() => h(a, 4096), async (a) => {
+			let s = this.requireOwned(e, n), c = this.options.worldEntities?.transitions;
+			if (!s.published || s.listing.epoch !== r || s.descriptor.mode === "lockstep" || !s.descriptor.world || !c?.retainActorSnapshot || a.tenantId !== n || a.roomId !== e) throw new i({ roomId: e });
+			let l = async () => {
+				let t = await Y(this.directory.observeOwnership(e, n));
+				if (!t || t.hostId !== this.host.id || t.epoch !== r || t.state !== "live") throw new i({ roomId: e });
+			};
+			await l();
+			let u = c.observe(a);
+			if (!G.isEffect(u)) throw new t({ detail: "World transfer capture requires actual transition observation" });
+			let d = await Y(u);
+			if (!d || d.origin.tenantId !== n || d.origin.roomId !== e || d.origin.requestId !== a.requestId || d.source.roomId !== e) throw new t({ detail: "World transfer capture lost its source request" });
+			let f = d.actorSnapshot, p = d.actorSnapshotRevision;
+			if (!f) {
+				if (d.phase !== "reserving" || d.source.epoch !== r) throw new t({ detail: "World transfer capture requires current reserving source epoch" });
+				let i = await this.runtime.captureWorldEntity(e, n, r, d.entityId, o);
+				if (C(i.data) !== C(d.sourceData)) throw new t({ detail: "World persistence projection changed since transition resolution" });
+				let a = A(s.descriptor.state, {
+					maxBytes: o,
+					maxFieldId: Math.min(4096, o * 7),
+					maxCollectionLength: Math.min(16384, o)
+				}), c = q.decodeUnknownSync(a.schema)(i.entity), l = a.full(c);
+				if (K.isFailure(l)) throw l.failure;
+				f = O({
+					schemaHash: a.schemaHash,
+					bytes: Array.from(l.success),
+					entity: i.entity
+				}, o), p = d.revision;
+			}
+			f = O(f, o);
+			let m = c.retainActorSnapshot({
+				origin: a,
+				expectedRevision: p,
+				snapshot: f
+			});
+			if (!G.isEffect(m)) throw new t({ detail: "World transfer capture requires actual durable snapshot retention" });
+			let h = await Y(m);
+			return await l(), h;
+		});
+	}
+	decodeWorldActorSnapshot(e, n, r) {
+		if (e.mode === "lockstep") throw new t({ detail: "World transfer payload requires state-sync schema" });
+		let i = O(n, r), a = A(e.state, {
+			maxBytes: r,
+			maxFieldId: Math.min(4096, r * 7),
+			maxCollectionLength: Math.min(16384, r)
+		});
+		if (i.schemaHash !== a.schemaHash) throw new t({ detail: "World target entity schema differs from the retained snapshot" });
+		let o = q.decodeUnknownSync(a.schema)(i.entity), s = a.full(o);
+		if (K.isFailure(s)) throw s.failure;
+		if (s.success.length !== i.bytes.length || s.success.some((e, t) => e !== i.bytes[t])) throw new t({ detail: "World target snapshot bytes contradict its captured source entity" });
+		let c = a.decodeFull(Uint8Array.from(i.bytes));
+		if (K.isFailure(c)) throw c.failure;
+		return h(JSON.parse(JSON.stringify(c.success)), r);
+	}
+	worldTransitionPayload(e, n, r, i) {
+		if (!n.actorSnapshot) throw new t({ detail: "World transfer requires its retained snapshot" });
+		return {
+			epoch: r,
+			requestId: `${n.id}:enter`,
+			entity: this.decodeWorldActorSnapshot(e, n.actorFinalSnapshot?.snapshot ?? n.actorSnapshot, i),
+			location: n.source
+		};
+	}
+	applyWorldSourceTransition(e, t, n, r, i, a, o, s) {
+		return this.capturedWorldOperation(() => h({
+			origin: r,
+			operation: i
+		}, 4096), async (r) => this.applyWorldSourceTransitionOwned(e, t, n, r, a, o, s));
+	}
+	async applyWorldSourceTransitionOwned(e, n, r, a, o, s, c, l, u, d) {
+		let f = this.requireOwned(e, n), p = this.options.worldEntities?.transitions;
+		if ((l === void 0 ? !f.published : f.published || !this.runtime.isPublicationHeld(e) || a.operation !== "rollback" || r !== l + 1) || f.listing.epoch !== r || f.descriptor.mode === "lockstep" || !f.descriptor.world || !p?.admitActorSource || a.origin.tenantId !== n || a.origin.roomId !== e || !["detach", "rollback"].includes(a.operation)) throw new i({ roomId: e });
+		let m = async () => {
+			let i = l === void 0 ? p.admitActorSource({
+				origin: a.origin,
+				roomId: e,
+				hostId: this.host.id,
+				epoch: r,
+				operation: a.operation
+			}) : p.admitActorSourceRecovery?.({
+				origin: a.origin,
+				roomId: e,
+				hostId: this.host.id,
+				epoch: r,
+				priorEpoch: l,
+				worldRecoveryEpoch: u
+			}, d);
+			if (!G.isEffect(i)) throw new t({ detail: "World source requires actual current entity admission" });
+			let s = await Y(i);
+			if (s.origin.tenantId !== n || s.origin.roomId !== e || s.origin.requestId !== a.origin.requestId || s.source.roomId !== e || (l === void 0 ? s.source.epoch !== r : s.source.epoch < (u ?? l) || s.source.epoch > l)) throw new t({ detail: "World source admission escaped its request" });
+			let c = a.operation === "rollback" ? "rollback" : s.mode === "portal" ? "detach" : "switchClient";
+			return await Y(I(o, s, c)), s;
+		}, h = await m();
+		if (a.operation === "rollback") {
+			let i = this.runtime.worldFinalizationRequest(e, n, r);
+			if (i !== null && i !== `${h.id}:exit`) {
+				let a = (await Y(De(o, h, "rollback"))).find((t) => `${t.id}:exit` === i && t.source.roomId === e && t.origin.tenantId === n && t.phase === "failed");
+				if (!a) throw new t({ detail: "World rollback cannot release a foreign actor finalization" });
+				await Y(Ee(o, h, a, "rollback", (i) => G.tryPromise({
+					try: () => this.applyWorldSourceTransitionOwned(e, n, r, {
+						origin: a.origin,
+						operation: "rollback"
+					}, i, s, c, l, u, d),
+					catch: () => new t({ detail: "World held group source compensation remains incomplete" })
+				})));
+			}
+		}
+		let g = async () => {
+			let e = await m();
+			if (e.id !== h.id || e.revision !== h.revision) throw new t({ detail: "World source changed during final handoff" });
+		}, _ = async () => {
+			await this.runtime.persist(e), await g();
+			let t = a.operation === "detach" ? "exit" : "enter";
+			h.mode === "seamless" && this.runtime.hasWorldReceipt(e, n, r, `${h.id}:${t}`, t) && await this.runtime.notifyWorldHandoff(e, n, {
+				kind: "WorldHandoff",
+				phase: a.operation === "detach" ? "departed" : "cancelled",
+				transitionId: h.id,
+				entityId: h.entityId,
+				sourceEpoch: r,
+				targetRoomId: h.target.roomId,
+				targetEpoch: h.target.epoch,
+				holdMs: 1e3
+			}, g), await this.runtime.completeWorldFinalization(e, n, r, `${h.id}:exit`, g);
+		};
+		if (a.operation === "detach" && h.mode === "portal" && !this.runtime.hasWorldReceipt(e, n, r, `${h.id}:exit`, "exit")) {
+			if (!p.retainActorDeparture) throw new t({ detail: "World portal departure requires actual durable source fencing" });
+			this.worldTransitionPayload(f.descriptor, h, r, s), await this.runtime.finalizeWorldExit(e, n, {
+				epoch: r,
+				entityId: h.entityId,
+				requestId: `${h.id}:exit`,
+				location: h.target,
+				...h.subject ? { subjectId: h.subject.id } : {}
+			}, s, async () => {
+				let e = p.retainActorDeparture({
+					origin: a.origin,
+					expectedRevision: h.revision
+				});
+				if (!G.isEffect(e)) throw new t({ detail: "World portal departure requires an actual durable Effect" });
+				let n = await Y(e);
+				if (n.id !== h.id || n.revision !== h.revision || n.actorDepartureRevision !== h.revision) throw new t({ detail: "World portal departure acknowledgment changed its source phase" });
+			}, g, h.actorSnapshot.entity, c), await _();
+			return;
+		}
+		if (a.operation === "detach" && h.mode === "seamless" && !this.runtime.hasWorldReceipt(e, n, r, `${h.id}:exit`, "exit")) {
+			if (!p.finalizeActorSnapshot) throw new t({ detail: "World seamless handoff requires actual final snapshot source" });
+			let i = this.ghostReceivers.get(e), o = i?.epoch === r ? i.afterglowMs : void 0, l = o === void 0 ? void 0 : h.createdAt + o;
+			if (l !== void 0 && (!Number.isSafeInteger(l) || l < 0)) throw new t({ detail: "Source afterglow deadline exceeds its bounded transition lifetime" });
+			let u = this.runtime.worldFinalizationRequest(e, n, r) === null ? l === void 0 ? void 0 : {
+				requestId: `wghost-${J("sha256").update(JSON.stringify([
+					"afterglow",
+					n,
+					e,
+					r,
+					h.id
+				])).digest("hex")}:ghost`,
+				expiresAt: l
+			} : this.runtime.worldFinalizationAfterglow(e, n, r);
+			await this.runtime.finalizeWorldExit(e, n, {
+				epoch: r,
+				entityId: h.entityId,
+				requestId: `${h.id}:exit`,
+				location: h.target,
+				...u ? { afterglow: u } : {},
+				...h.subject ? { subjectId: h.subject.id } : {}
+			}, s, async (e) => {
+				let n = A(f.descriptor.state, {
+					maxBytes: s,
+					maxFieldId: Math.min(4096, s * 7),
+					maxCollectionLength: Math.min(16384, s)
+				}), r = q.decodeUnknownSync(n.schema)(e.entity), i = n.full(r);
+				if (K.isFailure(i)) throw i.failure;
+				let o = O({
+					schemaHash: n.schemaHash,
+					bytes: Array.from(i.success),
+					entity: e.entity
+				}, s), c = p.finalizeActorSnapshot({
+					origin: a.origin,
+					expectedRevision: h.revision,
+					snapshot: o,
+					data: e.data
+				});
+				if (!G.isEffect(c)) throw new t({ detail: "World final snapshot requires actual durable Effect" });
+				let l = await Y(c);
+				if (l.id !== h.id || l.revision !== h.revision || !l.actorFinalSnapshot || C(l.actorFinalSnapshot.snapshot) !== C(o) || C(l.actorFinalSnapshot.data) !== C(e.data)) throw new t({ detail: "World final snapshot acknowledgment conflicts with captured actor" });
+			}, g, h.actorFinalSnapshot?.snapshot.entity, c), await _();
+			return;
+		}
+		if (a.operation === "rollback" && !this.runtime.hasWorldReceipt(e, n, r, `${h.id}:exit`, "exit")) {
+			if ((h.actorFinalSnapshot || h.actorDepartureRevision !== void 0) && !this.runtime.hasWorldReceipt(e, n, r, `${h.id}:enter`, "enter")) {
+				let t = h.actorFinalSnapshot?.snapshot ?? h.actorSnapshot;
+				if (this.worldTransitionPayload(f.descriptor, h, r, s), l === void 0) {
+					let i = await this.runtime.captureWorldEntity(e, n, r, h.entityId, s);
+					de(i.entity, t, s);
+				}
+				await this.runtime.reconcileWorldSource(e, n, {
+					epoch: r,
+					requestId: `${h.id}:enter`,
+					entity: t.entity,
+					location: h.target
+				}, s, g, c);
+			} else await this.runtime.captureWorldEntity(e, n, r, h.entityId, s);
+			await _();
+			return;
+		}
+		this.worldTransitionPayload(f.descriptor, h, r, s);
+		let v = a.operation === "detach" ? "exit" : "enter", y = {
+			epoch: r,
+			requestId: `${h.id}:${v}`,
+			entity: (h.actorFinalSnapshot?.snapshot ?? h.actorSnapshot).entity,
+			location: h.target
+		}, b = a.operation === "rollback" ? this.runtime.worldReceiptSnapshot(e, n, r).filter((e) => e.projection?.expiresAt !== void 0 && e.projection.entity.id === h.entityId).map((e) => ({
+			epoch: r,
+			requestId: e.requestId,
+			entity: e.projection.entity,
+			location: e.projection.location
+		})) : [];
+		await this.runtime.applyWorldHook(e, n, v, y, s, c, async () => {
+			let e = await m();
+			if (e.id !== h.id || e.revision !== h.revision) throw new t({ detail: "World source changed before draft publication" });
+		}, a.operation === "rollback", void 0, !1, b), await _();
+	}
+	authorizeWorldPlayer = (e) => G.tryPromise({
+		try: async () => {
+			let n = this.requireOwned(e.roomId, e.tenantId);
+			if (!this.options.worlds?.some((e) => e.zones.some((e) => e.room === n.descriptor.name))) return;
+			let r = this.options.worldEntities, a = this.options.resolveWorldPlayer;
+			if (this.closed || this.closing || !n.published || n.listing.epoch !== e.epoch || !r?.admitActorPlayer || !a || e.role !== "player" || e.subjectId === null || this.runtime.isPublicationHeld(e.roomId)) throw new i({ roomId: e.roomId });
+			let o = this.options.resolveSubject(e);
+			if (!G.isEffect(o)) throw new t({ detail: "World player requires actual Subject resolution" });
+			let s = q.decodeUnknownSync(W)(await Y(o));
+			if (s.type !== "user" || s.id !== e.subjectId || s.tenantId !== e.tenantId) throw new t({ detail: "World player differs from its authenticated Subject" });
+			let c = a(Object.freeze({ ...e }), Object.freeze(structuredClone(s)));
+			if (!G.isEffect(c)) throw new t({ detail: "World character selection requires an actual Effect" });
+			let l = await Y(c), u = r.admitActorPlayer({
+				tenantId: e.tenantId,
+				roomId: e.roomId,
+				hostId: this.host.id,
+				epoch: e.epoch,
+				entityId: l,
+				subject: {
+					id: s.id,
+					kind: s.kind === "guest" ? "guest" : "user"
+				}
+			});
+			if (!G.isEffect(u)) throw new t({ detail: "World player admission requires actual entity authority" });
+			let d = await Y(u);
+			return typeof d == "object" && d ? h(d, this.options.worldSnapshotMaxBytes ?? 65536) : void 0;
+		},
+		catch: () => new t({ detail: "World player ownership admission refused" })
+	});
+	authorizeWorldTarget = (e, n, r) => G.tryPromise({
+		try: async () => {
+			let a = this.requireOwned(e.roomId, e.tenantId), o = this.options.worldEntities?.transitions;
+			if (this.closed || this.closing || !a.published || a.listing.epoch !== e.epoch || !o?.admitActorSeat || e.role !== "player" || e.subjectId === null || this.runtime.isPublicationHeld(e.roomId)) throw new i({ roomId: e.roomId });
+			let s = this.options.resolveSubject(e);
+			if (!G.isEffect(s)) throw new t({ detail: "World Seat requires actual current Subject resolution" });
+			let c = q.decodeUnknownSync(W)(await Y(s));
+			if (c.type !== "user" || c.tenantId !== e.tenantId || c.id !== e.subjectId) throw new t({ detail: "World Seat Subject differs from its authenticated player" });
+			let l = c.kind === "guest" ? "guest" : "user", u = o.admitActorSeat({
+				origin: {
+					tenantId: e.tenantId,
+					roomId: n.sourceRoomId,
+					requestId: n.requestId
+				},
+				roomId: e.roomId,
+				hostId: this.host.id,
+				epoch: e.epoch,
+				binding: n,
+				sessionId: e.sessionId,
+				subjectId: e.subjectId,
+				subjectKind: l,
+				credentialDigest: r
+			});
+			if (!G.isEffect(u)) throw new t({ detail: "World Session admission requires actual SQL authority" });
+			let d = await Y(u);
+			return d.phase === "settled" ? "settled" : d.phase === "committed" ? "committed" : "pending";
+		},
+		catch: () => new t({ detail: "World target Session authority is incomplete" })
+	});
+	commitWorldTransition(e, n, r, a, o, s, c) {
+		return this.capturedWorldOperation(() => h(a, 4096), async (a) => {
+			let l = this.requireOwned(e, n), u = this.options.worldEntities?.transitions;
+			if (!l.published || l.listing.epoch !== r || l.descriptor.mode === "lockstep" || !l.descriptor.world || !u?.admitActorTarget || a.tenantId !== n) throw new i({ roomId: e });
+			let d = async () => {
+				let i = u.admitActorTarget({
+					origin: a,
+					roomId: e,
+					hostId: this.host.id,
+					epoch: r
+				});
+				if (!G.isEffect(i)) throw new t({ detail: "World publication requires actual current target admission" });
+				let s = await Y(i);
+				if (s.origin.tenantId !== n || s.origin.roomId !== a.roomId || s.origin.requestId !== a.requestId || s.target.roomId !== e || s.target.epoch !== r || s.phase !== "committed") throw new t({ detail: "World target admission escaped the committed request" });
+				return await Y(I(o, s, "settle")), s;
+			}, f = await d(), p = {
+				...this.worldTransitionPayload(l.descriptor, f, r, s),
+				...l.descriptor.world.movement ? { arrival: f.target } : {}
+			}, m = [];
+			for (let t of this.runtime.worldReceiptSnapshot(e, n, r)) if (t.operation === "ghost") {
+				if (t.projection && t.projection.entity.id === f.entityId) m.push({
+					epoch: r,
+					requestId: t.requestId,
+					entity: t.projection.entity,
+					location: t.projection.location
+				});
+				else if (t.requestId === `${f.id}:ghost`) {
+					let { actorFinalSnapshot: e, ...n } = f;
+					m.push({
+						...this.worldTransitionPayload(l.descriptor, n, r, s),
+						requestId: t.requestId
+					});
+				}
+			}
+			await this.runtime.applyWorldHook(e, n, "enter", p, s, c, async () => {
+				let e = await d();
+				if (e.id !== f.id || e.revision !== f.revision) throw new t({ detail: "World target changed before draft publication" });
+			}, !1, void 0, !1, m), await this.runtime.persist(e), await d(), f.subject && await this.runtime.activateWorldMembers(e, n, r, {
+				transitionId: f.id,
+				sourceRoomId: f.origin.roomId,
+				requestId: f.origin.requestId,
+				entityId: f.entityId
+			}, async () => {
+				await d();
+			});
+		});
+	}
+	ghostWorldTransition(e, n, r, a, o, s, c) {
+		return this.capturedWorldOperation(() => h(a, 4096), async (a) => {
+			let l = this.requireOwned(e, n), u = this.options.worldEntities?.transitions;
+			if (!l.published || l.listing.epoch !== r || l.descriptor.mode === "lockstep" || !l.descriptor.world || !u?.admitActorGhost || a.tenantId !== n) throw new i({ roomId: e });
+			let d = async () => {
+				let i = u.admitActorGhost({
+					origin: a,
+					roomId: e,
+					hostId: this.host.id,
+					epoch: r
+				});
+				if (!G.isEffect(i)) throw new t({ detail: "World ghost requires actual SQL admission" });
+				let s = await Y(i);
+				if (s.origin.tenantId !== n || s.origin.roomId !== a.roomId || s.origin.requestId !== a.requestId || s.target.roomId !== e || s.target.epoch !== r || s.mode !== "seamless" || s.phase !== "ghosting") throw new t({ detail: "World ghost admission escaped its actual transition" });
+				return await Y(I(o, s, "ghost")), s;
+			};
+			if (this.options.worldSnapshotMaxBytes === void 0 || !Number.isSafeInteger(s) || s < 1 || s > this.options.worldSnapshotMaxBytes) throw new t({ detail: "World ghost exceeds its configured recovery snapshot budget" });
+			let f = await d(), p = {
+				...this.worldTransitionPayload(l.descriptor, f, r, s),
+				requestId: `${f.id}:ghost`
+			};
+			await this.runtime.applyWorldHook(e, n, "ghost", p, s, c, async () => {
+				let e = await d();
+				if (e.id !== f.id || e.revision !== f.revision) throw new t({ detail: "World ghost changed before draft publication" });
+			}), await this.runtime.persist(e), await d();
+		});
+	}
+	previewWorldTransition(e, n, r, a, o, s) {
+		return this.capturedWorldOperation(() => h(a, 4096), async (a) => {
+			let c = this.requireOwned(e, n), l = this.options.worldEntities?.transitions;
+			if (!c.published || c.listing.epoch !== r || c.descriptor.mode === "lockstep" || !c.descriptor.world || !l || a.tenantId !== n) throw new i({ roomId: e });
+			let u = async () => {
+				let t = await Y(this.directory.observeOwnership(e, n));
+				if (!t || t.hostId !== this.host.id || t.epoch !== r || t.state !== "live") throw new i({ roomId: e });
+			};
+			await u();
+			let d = l.observe(a);
+			if (!G.isEffect(d)) throw new t({ detail: "World target requires actual transition observation" });
+			let f = await Y(d);
+			if (!f || f.origin.tenantId !== n || f.origin.roomId !== a.roomId || f.origin.requestId !== a.requestId || f.target.roomId !== e || f.target.epoch !== r || !["reserving", "switching"].includes(f.phase) || !f.actorSnapshot) throw new t({ detail: "World target lost its snapshot, phase or target epoch" });
+			let p = {
+				...this.worldTransitionPayload(c.descriptor, f, r, o),
+				...c.descriptor.world.movement ? { arrival: f.target } : {}
+			};
+			await this.runtime.previewWorldEnter(e, n, p, o, s), await u();
+			let m = l.observe(a);
+			if (!G.isEffect(m)) throw new t({ detail: "World target requires final transition observation" });
+			let h = await Y(m);
+			if (!h || h.id !== f.id || h.revision !== f.revision || h.phase !== f.phase) throw new t({ detail: "World target transition changed during preparation" });
+		});
+	}
+	previewWorldEnter(e, t, n, r, a) {
+		return this.capturedWorldOperation(() => h(n, r), async (n) => {
+			let o = this.requireOwned(e, t);
+			if (!o.published || o.listing.epoch !== n.epoch || o.descriptor.mode === "lockstep" || !o.descriptor.world) throw new i({ roomId: e });
+			let s = async () => {
+				let r = await Y(this.directory.observeOwnership(e, t));
+				if (!r || r.hostId !== this.host.id || r.epoch !== n.epoch || r.state !== "live") throw new i({ roomId: e });
+			};
+			await s(), await this.runtime.previewWorldEnter(e, t, n, r, a), await s();
+		});
+	}
+	withdrawWorldTargetSession(e, n, r, a, o, s) {
+		return this.capturedWorldOperation(() => h(a, 4096), async (a) => {
+			let c = this.requireOwned(e, n), l = this.options.worldEntities?.transitions;
+			if (!c.published || c.listing.epoch !== r || !l || a.tenantId !== n) throw new i({ roomId: e });
+			let u = async () => {
+				let s = await Y(this.directory.observeOwnership(e, n));
+				if (!s || s.hostId !== this.host.id || s.epoch !== r || s.state !== "live") throw new i({ roomId: e });
+				let c = l.observe(a);
+				if (!G.isEffect(c)) throw new t({ detail: "World target withdrawal requires actual transition observation" });
+				let u = await Y(c);
+				if (!u || u.phase !== "failed" || u.origin.tenantId !== n || u.origin.roomId !== a.roomId || u.origin.requestId !== a.requestId || u.target.roomId !== e || u.target.epoch !== r) throw new t({ detail: "World target Session withdrawal escaped its failed transition" });
+				return await Y(I(o, u, "rollback")), u;
+			}, d = await u();
+			if (d.mode === "seamless" && d.actorSnapshot) {
+				if (!Number.isSafeInteger(s) || s < 1) throw new t({ detail: "Seamless target withdrawal requires its explicit snapshot byte budget" });
+				let { actorFinalSnapshot: i, ...a } = d, o = {
+					...this.worldTransitionPayload(c.descriptor, a, r, s),
+					requestId: `${d.id}:ghost`
+				};
+				await this.runtime.cancelWorldGhost(e, n, o, s, async () => {
+					await u();
+				}), await this.runtime.persist(e), await u();
+			}
+			if (!d.subject) {
+				await this.runtime.cancelWorldPreview(e, n, r, `${d.id}:enter`, async () => {
+					await u();
+				});
+				return;
+			}
+			let f = await Y(ce(this.store, l.observe.bind(l), d, d.group?.size ?? 1)), p = le(f, !0), m = p.seats.findIndex((e) => e.subjectId === d.subject.id), h = se(p, m);
+			await this.runtime.settleSessions(e, n, r), await u();
+			let g = this.runtime.readSessionAdmission(e, h);
+			if (g && (g.tenantId !== n || g.roomId !== e || g.epoch !== r || g.subjectId !== d.subject.id || g.role !== "player")) throw new t({ detail: "World target Session does not match its actual transition Subject" });
+			await this.runtime.leaveSession(e, h), await u(), await this.runtime.cancelWorldPreview(e, n, r, `${d.id}:enter`, async () => {
+				await u();
+			});
+		});
+	}
+	async compensateTerminalWorldGhost(e, n, r, a, o, s) {
+		if (a.phase !== "rolledBack" || a.mode !== "seamless" || a.target.roomId !== e || !this.runtime.hasWorldReceipt(e, n, r, o, "ghost")) return;
+		let c = this.options.worldEntities?.transitions, l = this.options.worldSnapshotMaxBytes;
+		if (!c?.observeActorReceipt || l === void 0 || !a.actorSnapshot || a.target.epoch > r) throw new t({ detail: "Terminal ghost recovery lacks its bounded original snapshot authority" });
+		let u = async () => {
+			let l = await Y(this.directory.observeOwnership(e, n));
+			if (!l || l.hostId !== this.host.id || l.epoch !== r || l.state !== (s ? "creating" : "live")) throw new i({ roomId: e });
+			let u = c.observeActorReceipt({
+				tenantId: n,
+				roomId: e,
+				transitionId: a.id
+			});
+			if (!G.isEffect(u)) throw new t({ detail: "Terminal ghost recovery requires actual transition observation" });
+			let d = await Y(u);
+			if (!d || d.id !== a.id || d.revision !== a.revision || d.phase !== "rolledBack" || d.target.roomId !== e || o !== `${d.id}:ghost`) throw new t({ detail: "Terminal ghost recovery lost its exact rollback receipt" });
+		};
+		await u();
+		let { actorFinalSnapshot: d, ...f } = a, p = {
+			...this.worldTransitionPayload(this.requireOwned(e, n).descriptor, f, r, l),
+			requestId: o
+		};
+		await this.runtime.cancelWorldGhost(e, n, p, l, u), await this.runtime.persist(e), await u();
+	}
+	async retireTerminalWorldReceipts(e, n, r, a = !1) {
+		let o = this.requireOwned(e, n), s = this.options.worldEntities?.transitions;
+		if (o.listing.epoch !== r || (a ? o.published || !this.runtime.isPublicationHeld(e) : !o.published || this.runtime.isPublicationHeld(e))) throw new i({ roomId: e });
+		if (this.runtime.hasPendingCheckpoint(e) || this.runtime.worldFinalizationRequest(e, n, r) !== null) return;
+		let c = async () => {
+			let t = await Y(this.directory.observeOwnership(e, n));
+			if (!t || t.hostId !== this.host.id || t.epoch !== r || t.state !== (a ? "creating" : "live")) throw new i({ roomId: e });
+		};
+		if (await c(), a || this.runtime.worldLifecycleQuiet(e)) {
+			for (let i of this.runtime.worldReceiptSnapshot(e, n, r)) {
+				if (i.projection) {
+					if (!a) {
+						let e = this.options.epochNow();
+						if (!Number.isSafeInteger(e) || e < 0) throw new t({ detail: "Afterglow expiry requires current epoch time" });
+						if (i.projection.expiresAt === void 0 || e < i.projection.expiresAt) continue;
+					}
+					let s = this.options.worldSnapshotMaxBytes;
+					if (s === void 0 || o.descriptor.mode === "lockstep") throw new t({ detail: "Ghost recovery requires its configured entity codec budget" });
+					let l = h(i.projection, s), u = A(o.descriptor.state, {
+						maxBytes: s,
+						maxFieldId: Math.min(4096, s * 7),
+						maxCollectionLength: Math.min(16384, s)
+					}), d = q.decodeUnknownSync(u.schema)(l.entity), f = u.full(d);
+					if (K.isFailure(f)) throw f.failure;
+					await c(), await this.runtime.cancelWorldGhost(e, n, {
+						epoch: r,
+						requestId: i.requestId,
+						entity: l.entity,
+						location: l.location
+					}, s, c), await this.runtime.persist(e), await c();
+					continue;
+				}
+				if (a && /^wghost-[0-9a-f]{64}:ghost$/.test(i.requestId)) throw new t({ detail: "Legacy streaming ghost checkpoint lacks its exact removal payload" });
+				if (!s?.observeActorReceipt) continue;
+				let l = `:${i.operation}`;
+				if (!i.requestId.endsWith(l)) continue;
+				let u = i.requestId.slice(0, -l.length);
+				if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(u)) continue;
+				let d = s.observeActorReceipt({
+					tenantId: n,
+					roomId: e,
+					transitionId: u
+				});
+				if (!G.isEffect(d)) throw new t({ detail: "World cleanup requires actual receipt observation" });
+				let f = await Y(d);
+				if (f && ["settled", "rolledBack"].includes(f.phase)) {
+					if (f.id !== u || f.origin.tenantId !== n || f.source.roomId !== e && f.target.roomId !== e) throw new t({ detail: "World terminal cleanup escaped its actor scope" });
+					await c(), i.operation === "ghost" && await this.compensateTerminalWorldGhost(e, n, r, f, i.requestId, a), await this.runtime.retireWorldReceipt(e, n, r, i.requestId, i.operation), await this.runtime.persist(e);
+				}
+			}
+			await c();
+		}
+	}
+	retireWorldReceipt(e, n, r, a, o, s) {
+		return this.capturedWorldOperation(() => h({
+			origin: a,
+			requestId: o,
+			operation: s
+		}, 4096), async (a) => {
+			let o = this.requireOwned(e, n), s = this.options.worldEntities?.transitions;
+			if (!o.published || o.listing.epoch !== r || !s || a.origin.tenantId !== n || ![
+				"enter",
+				"exit",
+				"ghost"
+			].includes(a.operation)) throw new i({ roomId: e });
+			let c = await Y(this.directory.observeOwnership(e, n));
+			if (!c || c.hostId !== this.host.id || c.epoch !== r || c.state !== "live") throw new i({ roomId: e });
+			let l = s.observe(a.origin);
+			if (!G.isEffect(l)) throw new t({ detail: "World receipt retirement requires actual transition observation" });
+			let u = await Y(l);
+			if (!u || u.origin.tenantId !== n || u.origin.roomId !== a.origin.roomId || u.origin.requestId !== a.origin.requestId || !["settled", "rolledBack"].includes(u.phase) || u.source.roomId !== e && u.target.roomId !== e || a.requestId !== `${u.id}:${a.operation}`) throw new t({ detail: "World actor receipt lacks matching terminal transition authority" });
+			a.operation === "ghost" && await this.compensateTerminalWorldGhost(e, n, r, u, a.requestId, !1), await this.runtime.retireWorldReceipt(e, n, r, a.requestId, a.operation), await this.runtime.persist(e);
+		});
+	}
+	applyWorldHook(e, t, n, r, a, o) {
+		return this.capturedWorldOperation(() => h(r, a), async (r) => {
+			let s = this.requireOwned(e, t);
+			if (!s.published || s.listing.epoch !== r.epoch || s.descriptor.mode === "lockstep" || !s.descriptor.world || r.requestId === void 0) throw new i({ roomId: e });
+			let c = await Y(this.directory.observeOwnership(e, t));
+			if (!c || c.hostId !== this.host.id || c.epoch !== r.epoch || c.state !== "live") throw new i({ roomId: e });
+			await this.runtime.applyWorldHook(e, t, n, r, a, o), await this.runtime.persist(e);
+		});
+	}
+	worldNeighborGhostInput(e, n, r, i, a, o) {
+		let s = this.requireOwned(e, n), c = i.capture, l = c.source;
+		if (!s.published || s.listing.epoch !== r || !s.descriptor.world || !Number.isSafeInteger(i.sequence) || i.sequence < 1 || i.sequence > 2147483647 || l.tenantId !== n || l.hostId !== a.hostId || c.snapshot.entity.id !== c.entityId || this.options.worldSnapshotMaxBytes === void 0 || o > this.options.worldSnapshotMaxBytes) throw new t({ detail: "World neighbor projection escaped its actual target or byte budget" });
+		return {
+			epoch: r,
+			requestId: `wghost-${J("sha256").update(JSON.stringify([
+				n,
+				e,
+				r,
+				l.roomId,
+				l.epoch,
+				a.hostId,
+				a.instanceId,
+				a.startedAt,
+				c.entityId,
+				i.sequence
+			])).digest("hex")}:ghost`,
+			entity: this.decodeWorldActorSnapshot(s.descriptor, c.snapshot, o),
+			location: {
+				worldId: l.worldId,
+				zoneId: l.zoneId,
+				at: l.at,
+				layer: l.layer,
+				roomId: l.roomId,
+				epoch: l.epoch
+			}
+		};
+	}
+	async assertWorldGhostPeer(e, n = !1) {
+		let r = this.host.membership, i = n && e.hostId !== this.host.id;
+		if (n && r?.instanceId === void 0) throw new t({ detail: "World ghost target lacks its registered instance" });
+		let a = [e, ...i ? [{
+			hostId: this.host.id,
+			instanceId: r.instanceId,
+			startedAt: r.startedAt
+		}] : []], o = await this.store.query({
+			table: x,
+			predicate: i ? Xe("id", a.map((e) => e.hostId)) : U("id", e.hostId),
+			order: [],
+			take: a.length + 1,
+			skip: void 0,
+			projection: [
+				"id",
+				"instanceId",
+				"membershipStartedAt",
+				"ready",
+				"draining",
+				"lastHeartbeatAt",
+				"pool"
+			]
+		}), s = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+		if (o.length !== a.length || !a.every((e) => {
+			let t = o.filter((t) => !i || t.id === e.hostId);
+			return t.length === 1 && t[0].instanceId === e.instanceId && s(t[0].membershipStartedAt) === e.startedAt && (t[0].pool ?? null) === (this.host.pool ?? null) && t[0].ready === !0 && t[0].draining === !1 && s(t[0].lastHeartbeatAt) > this.options.epochNow() - this.options.heartbeatTtlMs;
+		}) || n && !i && e.instanceId !== r.instanceId) throw new t({ detail: "World ghost peer registration is stale or unavailable" });
+	}
+	admitWorldGhostHandshake(e, n) {
+		return this.capturedWorldOperation(() => h(e, 16384), async (e) => {
+			let r = this.host.membership, a = this.requireOwned(e.roomId, e.tenantId), o = this.options.worldSnapshotMaxBytes;
+			if (!r || e.purpose !== "voltro.rooms.ghost.hello.v1" || e.target.hostId !== this.host.id || e.target.instanceId !== r.instanceId || e.target.startedAt !== r.startedAt || !a.published || a.listing.epoch !== e.epoch || !a.descriptor.world || o === void 0 || typeof n != "function") throw new i({ roomId: e.roomId });
+			if (A(a.descriptor.state, {
+				maxBytes: o,
+				maxFieldId: Math.min(4096, o * 7),
+				maxCollectionLength: Math.min(16384, o)
+			}).schemaHash !== e.schemaHash) throw new t({ detail: "Ghost peer entity schema differs from actual target" });
+			let s = async () => {
+				if (this.closing || this.closed || !this.activated || this.owned.get(e.roomId) !== a || !a.published || e.expiresAt <= this.options.epochNow() || e.issuedAt > this.options.epochNow()) throw new i({ roomId: e.roomId });
+				let t = await Y(this.directory.observeOwnership(e.roomId, e.tenantId));
+				if (!t || t.hostId !== this.host.id || t.epoch !== e.epoch || t.state !== "live") throw new i({ roomId: e.roomId });
+				await this.assertWorldGhostPeer(e.source), await this.assertWorldGhostPeer(e.target);
+			};
+			await s();
+			let c = n(e);
+			if (!G.isEffect(c) || await Y(c) !== void 0) throw new t({ detail: "Ghost handshake lacks actual target policy" });
+			await s();
+		});
+	}
+	async admitWorldNeighborGhostOwned(e, n, r, i, a, o, s, c) {
+		this.worldNeighborGhostInput(e, n, r, a, o, s);
+		let l = this.options.worldEntities, u = a.capture.source;
+		if (!l?.admitActorNeighbor || i.roomId !== e || i.epoch !== r || typeof c != "function") throw new t({ detail: "World neighbor requires acquired peer and actual SQL admission" });
+		let d = c(o);
+		if (!G.isEffect(d) || await Y(d) !== void 0) throw new t({ detail: "World neighbor peer authority is incomplete" });
+		await this.assertWorldGhostPeer(o, !0);
+		let f = l.admitActorNeighbor({
+			tenantId: n,
+			entityId: a.capture.entityId,
+			roomId: u.roomId,
+			hostId: u.hostId,
+			epoch: u.epoch,
+			expectedRevision: a.capture.revision,
+			source: {
+				worldId: u.worldId,
+				zoneId: u.zoneId,
+				at: u.at,
+				layer: u.layer,
+				roomId: u.roomId,
+				epoch: u.epoch
+			},
+			target: i,
+			targetHostId: this.host.id
+		});
+		if (!G.isEffect(f)) throw new t({ detail: "World neighbor requires actual SQL authority" });
+		await Y(f);
+	}
+	admitWorldNeighborGhost(e, t, n, r, i, a, o, s) {
+		return this.capturedWorldOperation(() => ({
+			target: h(r, 4096),
+			frame: h(i, o),
+			peer: h(a, 1024)
+		}), (r) => this.admitWorldNeighborGhostOwned(e, t, n, r.target, r.frame, r.peer, o, s));
+	}
+	applyWorldNeighborGhost(e, n, r, i, a, o, s, c, l) {
+		return this.capturedWorldOperation(() => ({
+			target: h(i, 4096),
+			frame: h(a, s),
+			peer: h(o, 1024),
+			previous: l === void 0 ? void 0 : {
+				frame: h(l.frame, s),
+				peer: h(l.peer, 1024)
+			}
+		}), async (i) => {
+			let a = () => this.admitWorldNeighborGhostOwned(e, n, r, i.target, i.frame, i.peer, s, c);
+			await a();
+			let o = this.worldNeighborGhostInput(e, n, r, i.frame, i.peer, s);
+			if (i.previous) {
+				if (i.previous.frame.capture.entityId !== i.frame.capture.entityId) throw new t({ detail: "World ghost replacement changed entity identity" });
+				let c = this.worldNeighborGhostInput(e, n, r, i.previous.frame, i.previous.peer, s);
+				await this.runtime.replaceWorldGhostProjection(e, n, o, c, s, a);
+			} else {
+				let c = this.runtime.worldReceiptSnapshot(e, n, r).filter((e) => e.projection?.expiresAt !== void 0 && e.projection.entity.id === i.frame.capture.entityId);
+				if (c.length > 1) throw new t({ detail: "Reverse ghost stream has ambiguous local afterglow" });
+				let l = c[0];
+				l ? await this.runtime.replaceWorldGhostProjection(e, n, o, {
+					epoch: r,
+					requestId: l.requestId,
+					entity: l.projection.entity,
+					location: l.projection.location
+				}, s, a) : await this.runtime.applyWorldHook(e, n, "ghost", o, s, void 0, a, !1, void 0, !0);
+			}
+			await this.runtime.persist(e), await a();
+		});
+	}
+	ownWorldGhostReceiver(e, n, r, i, a) {
+		let o = this.requireOwned(e, n);
+		if (P() || this.closed || this.closing || !this.activated || !o.published || o.listing.epoch !== r || this.ghostReceivers.has(e) || this.ghostReceivers.size >= this.options.capacity) throw new t({ detail: "Ghost receiver requires exclusive live target Room lifetime" });
+		if (a !== void 0 && (!Number.isSafeInteger(a) || a < 1 || a > 6e4)) throw new t({ detail: "Source afterglow requires its acquired receiver lifetime bound" });
+		let c = s(i, [
+			"receive",
+			"withdraw",
+			"runDue",
+			"close"
+		], [
+			"receive",
+			"withdraw",
+			"runDue",
+			"close"
+		]);
+		if (Object.values(c).some((e) => typeof e != "function")) throw new t({ detail: "Ghost receiver requires actual acquired operations" });
+		let l = {
+			tenantId: n,
+			epoch: r,
+			receiver: i,
+			...a === void 0 ? {} : { afterglowMs: a }
+		}, u = i.close.bind(i), d = i.runDue.bind(i), f = !1, p = (t) => G.sync(() => {
+			f && t.retained === 0 && t.deferred.length === 0 && this.ghostReceivers.get(e) === l && this.ghostReceivers.delete(e);
+		}), m = Object.freeze({
+			receive: i.receive.bind(i),
+			withdraw: i.withdraw.bind(i),
+			runDue: () => G.tap(d(), p),
+			close: () => G.suspend(() => (f = !0, G.tap(u(), p)))
+		});
+		return l.receiver = m, this.ghostReceivers.set(e, l), m;
+	}
+	configureWorldGhostCells(e, n) {
+		return this.operation(async () => {
+			if (this.closing || this.closed || typeof n != "function" || !this.options.worlds?.some((t) => t.name === e) || this.ghostCellFactories.has(e)) throw new t({ detail: "Ghost cell lifecycle requires one declared World policy" });
+			this.ghostCellFactories.set(e, n);
+		}, !0);
+	}
+	async acquireWorldGhostCells() {
+		if (this.closed || this.closing || !this.activated || !this.ghostCellFactories.size) return;
+		let e = [];
+		for (let [n, r] of [...this.owned]) if (r.published && r.descriptor.world && (this.ghostReceivers.get(n)?.epoch !== r.listing.epoch || this.ghostPublishers.get(n)?.owned !== r)) {
+			for (let [a, o] of this.ghostCellFactories) if (this.options.worlds?.find((e) => e.name === a)?.zones.some((e) => e.room === r.descriptor.name)) try {
+				let e = await this.worldOperation(async () => {
+					if (this.owned.get(n) !== r || !r.published) throw new i({ roomId: n });
+					let e = await Y(D(this.store, {
+						worlds: this.options.worlds,
+						epochNow: this.options.epochNow,
+						maxListedCells: 1,
+						authorize: () => G.sync(() => {
+							if (this.owned.get(n) !== r || !r.published) throw new i({ roomId: n });
+						})
+					}).observeRoom({
+						tenantId: r.listing.tenantId,
+						worldId: a,
+						roomId: n
+					}));
+					if (e && (e.cell.hostId !== this.host.id || e.cell.epoch !== r.listing.epoch)) throw new i({ roomId: n });
+					return e;
+				});
+				if (!e) continue;
+				let { cell: c, at: l } = e, u = Object.freeze({
+					worldId: a,
+					zoneId: c.zoneId,
+					roomId: n,
+					epoch: c.epoch,
+					layer: c.layer,
+					at: l
+				}), d = o(Object.freeze({
+					tenantId: c.tenantId,
+					target: u
+				}));
+				if (d instanceof Promise) throw d.catch(() => void 0), new t({ detail: "Ghost cell policies must be synchronous" });
+				s(d, ["receiver", "publisher"], ["receiver", "publisher"]);
+				let f = [
+					"maxEntities",
+					"maxFrameBytes",
+					"maxRetainedBytes",
+					"ttlMs",
+					"now",
+					"authorizePeer"
+				], p = [
+					"publication",
+					"neighborhood",
+					"position",
+					"outbound"
+				];
+				if (s(d.receiver, f, f), s(d.publisher, p, p), this.owned.get(n) !== r || !r.published || this.closing) throw new i({ roomId: n });
+				this.ghostReceivers.has(n) || pe(this, {
+					...d.receiver,
+					tenantId: c.tenantId,
+					target: u
+				}), this.ghostPublishers.has(n) || await this.ownWorldGhostPublisher(n, c.tenantId, c.epoch, {
+					...d.publisher,
+					worldId: a
+				});
+				break;
+			} catch (t) {
+				e.push(t);
+			}
+		}
+		if (e.length) throw AggregateError(e, "World cell ghost acquisition remains incomplete");
+	}
+	ownWorldGhostPublisher(e, n, r, a) {
+		return this.capturedWorldOperation(() => {
+			s(a, [
+				"worldId",
+				"publication",
+				"neighborhood",
+				"position",
+				"outbound"
+			], [
+				"worldId",
+				"publication",
+				"neighborhood",
+				"position",
+				"outbound"
+			]);
+			let e = [
+				"now",
+				"cadenceMs",
+				"maxEntities",
+				"maxChannels",
+				"maxFramesPerTurn",
+				"maxBytesPerTurn",
+				"maxRetainedBytes",
+				"maxSnapshotBytes",
+				"maxFrameBytes"
+			], n = s(a.publication, e, e), r = [
+				"maxZoneChecks",
+				"maxCandidateCells",
+				"maxObservationBytes",
+				"authorize"
+			], i = s(a.neighborhood, r, r);
+			if (typeof a.position != "function" || typeof n.now != "function" || typeof i.authorize != "function") throw new t({ detail: "Ghost publisher requires captured source policies" });
+			return {
+				worldId: a.worldId,
+				publication: {
+					...n,
+					now: n.now.bind(a.publication)
+				},
+				neighborhood: {
+					...i,
+					authorize: i.authorize.bind(a.neighborhood)
+				},
+				position: a.position.bind(a),
+				outbound: k(a.outbound)
+			};
+		}, async (a) => {
+			let o = this.requireOwned(e, n), s = this.options.worlds?.find((e) => e.name === a.worldId);
+			if (!o.published || o.listing.epoch !== r || !s || !o.descriptor.world || !s.zones.some((e) => e.room === o.descriptor.name) || this.ghostPublishers.has(e) || this.options.worldSnapshotMaxBytes === void 0 || a.publication.maxSnapshotBytes > this.options.worldSnapshotMaxBytes || a.publication.maxSnapshotBytes > a.outbound.sender.maxSnapshotBytes || a.publication.maxFrameBytes !== a.outbound.sender.maxFrameBytes) throw new t({ detail: "Ghost publisher lacks its actual bounded source lifetime" });
+			let c = Ne(this.store, {
+				...a.neighborhood,
+				world: s,
+				tenantId: n,
+				epochNow: this.options.epochNow
+			}), l = me({
+				...a.publication,
+				list: () => this.listWorldGhostEntityIds(e, n, r, a.publication.maxEntities, 1048576),
+				capture: (t) => this.captureWorldGhostSource(e, n, r, t, a.publication.maxSnapshotBytes, a.position),
+				neighbors: async (e) => (await Y(c.observe(e.source))).neighbors.flatMap((e) => e.placement?.state === "live" ? [e.placement] : []),
+				nextSequence: () => {
+					if (this.owned.get(e) !== o || o.listing.epoch !== r) throw new i({ roomId: e });
+					let n = (this.ghostPublisherSequences.get(o) ?? 0) + 1;
+					if (n > 2147483647) throw new t({ detail: "Ghost source exhausted its epoch sequence space" });
+					return this.ghostPublisherSequences.set(o, n), n;
+				},
+				open: (t) => this.openWorldGhostChannel(e, n, r, t, a.outbound)
+			}), u = {
+				owned: o,
+				publisher: l
+			};
+			return this.ghostPublishers.set(e, u), Object.freeze({
+				...l,
+				close: async () => {
+					await l.close(), this.ghostPublishers.get(e) === u && this.ghostPublishers.delete(e);
+				}
+			});
+		});
+	}
+	openWorldGhostChannel(e, n, r, a, o) {
+		return P() ? Promise.reject(new t({ detail: "Ghost socket acquisition must run outside command delivery" })) : this.capturedWorldOperation(() => ({
+			target: h(a, 4096),
+			options: k(o)
+		}), async (a) => {
+			let o = this.requireOwned(e, n), s = this.host.membership, c = this.options.worldGhostMaxConnections, l = a.options;
+			if (!o.published || o.listing.epoch !== r || !o.descriptor.world || !s || s.instanceId === void 0 || c === void 0 || this.ghostTransports.size + this.ghostOutbounds.size >= c || this.options.worldSnapshotMaxBytes === void 0 || l.sender.maxSnapshotBytes > this.options.worldSnapshotMaxBytes || [...this.ghostOutbounds].some((t) => t.roomId === e && t.tenantId === n && t.epoch === r && t.target.roomId === a.target.roomId && t.target.epoch === a.target.epoch)) throw new t({ detail: "World source lacks its bounded outbound channel lifetime" });
+			let u = Object.freeze({
+				hostId: this.host.id,
+				instanceId: s.instanceId,
+				startedAt: s.startedAt
+			}), d = A(o.descriptor.state, {
+				maxBytes: l.sender.maxFrameBytes,
+				maxFieldId: Math.min(4096, l.sender.maxFrameBytes * 7),
+				maxCollectionLength: Math.min(16384, l.sender.maxFrameBytes)
+			}), f = ge(this.store, {
+				tenantId: n,
+				source: u,
+				path: l.path,
+				epochNow: this.options.epochNow,
+				heartbeatTtlMs: this.options.heartbeatTtlMs,
+				authorize: l.authorize
+			}), p = async () => {
+				if (P()) throw new t({ detail: "Ghost socket operations must run outside command delivery" });
+				if (this.closing || this.closed || !this.activated || this.owned.get(e) !== o || !o.published || o.listing.epoch !== r) throw new i({ roomId: e });
+				let a = await Y(this.directory.observeOwnership(e, n));
+				if (!a || a.hostId !== this.host.id || a.epoch !== r || a.state !== "live") throw new i({ roomId: e });
+				await this.assertWorldGhostPeer(u);
+			}, m, h = he({
+				maxSnapshotBytes: l.sender.maxSnapshotBytes,
+				current: p,
+				validate: (i) => {
+					if (P()) throw new t({ detail: "Ghost publication must run outside command delivery" });
+					let a = i.capture.source;
+					if (a.roomId !== e || a.tenantId !== n || a.epoch !== r || a.hostId !== this.host.id || i.capture.snapshot.schemaHash !== d.schemaHash) throw new t({ detail: "Ghost frame escaped its actual source actor scope" });
+				},
+				acquire: async (e) => {
+					let t = await Y(f.resolve(a.target));
+					return m.destination = t, await p(), _e(t.address, e, {
+						carrier: l.carrier,
+						scope: {
+							source: u,
+							target: t.target,
+							tenantId: n,
+							roomId: t.cell.roomId,
+							epoch: t.cell.epoch,
+							schemaHash: d.schemaHash
+						},
+						sender: {
+							...l.sender,
+							state: o.descriptor.state
+						},
+						socket: l.socket,
+						handshakeTimeoutMs: l.handshakeTimeoutMs,
+						maxSignedBytes: l.maxSignedBytes
+					});
+				},
+				release: () => {
+					this.ghostOutbounds.delete(m);
+				}
+			});
+			return m = {
+				roomId: e,
+				tenantId: n,
+				epoch: r,
+				target: a.target,
+				owner: h,
+				current: p
+			}, this.ghostOutbounds.add(m), m;
+		}).then(async (e) => {
+			try {
+				return await e.owner.ready;
+			} catch (t) {
+				try {
+					await e.owner.close();
+				} catch {
+					throw new _(() => e.owner.close());
+				}
+				throw t;
+			}
+		});
+	}
+	bindWorldGhostTransport(e, n, r, i) {
+		let a, o;
+		try {
+			a = h(e, 16384), o = h(r, 1024);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		return this.admitWorldGhostHandshake(a, i).then(() => this.worldOperation(async () => {
+			let e = this.requireOwned(a.roomId, a.tenantId), r = this.ghostReceivers.get(a.roomId), i = this.options.worldGhostMaxConnections;
+			if (i === void 0 || this.ghostTransports.size + this.ghostOutbounds.size >= i || !r || r.tenantId !== a.tenantId || r.epoch !== a.epoch || !e.published || e.listing.epoch !== a.epoch || n.signal.aborted || this.options.worldSnapshotMaxBytes === void 0 || o.maxSnapshotBytes > this.options.worldSnapshotMaxBytes) throw new t({ detail: "Ghost transport lacks its bounded acquired target lifetime" });
+			let s = g(n, "close", "Ghost transport requires actual withdrawal"), c = ve(n, {
+				...o,
+				state: e.descriptor.state,
+				receive: (e) => r.receiver.receive(e, a.source),
+				withdraw: (e) => r.receiver.withdraw(e, a.source)
+			}), l, u = {
+				hello: a,
+				signal: n.signal,
+				receiver: r.receiver,
+				close: () => {
+					if (l) return l;
+					let e = Promise.resolve().then(async () => {
+						let e = [];
+						try {
+							s(1e3, "World ghost target lifetime ended");
+						} catch (t) {
+							e.push(t);
+						}
+						try {
+							await c.close();
+						} catch (t) {
+							e.push(t);
+						}
+						if (e.length) throw AggregateError(e, "Ghost target ingress cleanup remains incomplete");
+						this.ghostTransports.delete(u);
+					});
+					return l = e, e.catch(() => {
+						l === e && (l = void 0);
+					}), e;
+				}
+			};
+			return this.ghostTransports.add(u), Object.freeze({
+				close: u.close,
+				settled: c.settled,
+				snapshot: c.snapshot
+			});
+		}));
+	}
+	runWorldGhostReceivers(e) {
+		let t = this.ghostMaintenance;
+		if (t && !e) return t;
+		let n = Promise.resolve().then(async () => {
+			t && await t.catch(() => void 0), await this.runWorldGhostMaintenance(e);
+		});
+		return this.ghostMaintenance = n, n.then(() => {
+			this.ghostMaintenance === n && (this.ghostMaintenance = void 0);
+		}, () => {
+			this.ghostMaintenance === n && (this.ghostMaintenance = void 0);
+		}), n;
+	}
+	async runWorldGhostMaintenance(e) {
+		let n = [];
+		if (!e && !this.closing && (this.ghostCellFactories.size || this.ghostPublishers.size || this.ghostReceivers.size)) try {
+			await this.worldOperation(async () => {
+				for (let [e, t] of this.owned) if (t.published && t.descriptor.mode !== "lockstep" && t.descriptor.world && !this.runtime.isPublicationHeld(e)) try {
+					await this.synchronizeWorldCell(e, t);
+				} catch (e) {
+					n.push(e);
+				}
+			});
+		} catch (e) {
+			n.push(e);
+		}
+		for (let [t, r] of [...this.ghostPublishers]) try {
+			let n = await Y(this.directory.observeOwnership(t, r.owned.listing.tenantId));
+			(e || r.publisher.snapshot().closed || this.owned.get(t) !== r.owned || !r.owned.published || !n || n.hostId !== this.host.id || n.epoch !== r.owned.listing.epoch || n.state !== "live") && (await r.publisher.close(), this.ghostPublishers.get(t) === r && this.ghostPublishers.delete(t));
+		} catch (e) {
+			n.push(e);
+		}
+		for (let t of [...this.ghostOutbounds]) try {
+			let n = e || t.owner.status() === "failed" || t.owner.status() === "closing";
+			if (!n) try {
+				if (await t.current(), t.destination) {
+					let e = t.destination, r = await Y(this.directory.observeOwnership(e.cell.roomId, t.tenantId));
+					r && r.hostId === e.target.hostId && r.epoch === e.cell.epoch && r.state === "live" || (n = !0), await this.assertWorldGhostPeer(e.target);
+				}
+			} catch {
+				n = !0;
+			}
+			n && await t.owner.close();
+		} catch (e) {
+			n.push(e);
+		}
+		for (let t of [...this.ghostTransports]) try {
+			let n = e || t.signal.aborted || this.ghostReceivers.get(t.hello.roomId)?.receiver !== t.receiver;
+			if (!n) {
+				let e = await Y(this.directory.observeOwnership(t.hello.roomId, t.hello.tenantId));
+				n = !e || e.hostId !== this.host.id || e.epoch !== t.hello.epoch || e.state !== "live";
+				try {
+					await this.assertWorldGhostPeer(t.hello.source);
+				} catch {
+					n = !0;
+				}
+			}
+			n && await t.close();
+		} catch (e) {
+			n.push(e);
+		}
+		for (let [r, i] of [...this.ghostReceivers]) try {
+			let n = await Y(this.directory.observeOwnership(r, i.tenantId)), a = V(n, {
+				roomId: r,
+				tenantId: i.tenantId,
+				hostId: this.host.id,
+				epoch: i.epoch
+			}), o = await Y(e || a ? i.receiver.close() : i.receiver.runDue());
+			if ((e || a) && (o.retained !== 0 || o.deferred.length !== 0)) throw new t({ detail: "Host ghost cleanup retains unacknowledged projections" });
+		} catch (e) {
+			n.push(e);
+		}
+		if (!e && !this.closing && !this.closed) {
+			try {
+				await this.acquireWorldGhostCells();
+			} catch (e) {
+				n.push(e);
+			}
+			for (let e of [...this.ghostPublishers.values()]) try {
+				await e.publisher.runDue();
+			} catch (e) {
+				n.push(e);
+			}
+		}
+		if (n.length) throw AggregateError(n, "Host ghost receiver lifecycle remains incomplete");
+	}
+	removeWorldNeighborGhost(e, t, n, r, a, o) {
+		return this.capturedOperation(() => ({
+			frame: h(r, o),
+			peer: h(a, 1024)
+		}), async (r) => {
+			let a = await Y(this.directory.observeOwnership(e, t));
+			if (V(a, {
+				roomId: e,
+				tenantId: t,
+				hostId: this.host.id,
+				epoch: n
+			})) return;
+			let s = this.worldNeighborGhostInput(e, t, n, r.frame, r.peer, o), c = async () => {
+				let r = await Y(this.directory.observeOwnership(e, t));
+				if (!r || r.hostId !== this.host.id || r.epoch !== n || r.state !== "live") throw new i({ roomId: e });
+			};
+			await c(), await this.runtime.cancelWorldGhost(e, t, s, o, c), await this.runtime.persist(e), await c();
+		}, !0);
+	}
+	configureWorldBoundaryCells(e, n) {
+		return this.operation(async () => {
+			if (this.closing || this.closed || typeof n != "function" || this.boundaryCellFactories.has(e) || !this.options.worlds?.some((t) => t.name === e)) throw new t({ detail: "Boundary cells require one declared World factory" });
+			this.boundaryCellFactories.set(e, n);
+		}, !0);
+	}
+	async acquireWorldBoundaryCells() {
+		if (!this.activated || this.closing || this.closed || !this.boundaryCellFactories.size) return;
+		let e = [];
+		for (let [n, r] of [...this.owned]) if (r.published && r.descriptor.world?.movement && this.boundaryCoordinators.get(n)?.owned !== r) {
+			for (let [a, o] of this.boundaryCellFactories) if (this.options.worlds?.find((e) => e.name === a)?.zones.some((e) => e.room === r.descriptor.name)) try {
+				let e = await this.worldOperation(async () => {
+					if (this.owned.get(n) !== r || !r.published) throw new i({ roomId: n });
+					await this.synchronizeWorldCell(n, r);
+					let e = await Y(D(this.store, {
+						worlds: this.options.worlds,
+						epochNow: this.options.epochNow,
+						maxListedCells: 1,
+						authorize: () => G.sync(() => {
+							if (this.owned.get(n) !== r || !r.published) throw new i({ roomId: n });
+						})
+					}).observeRoom({
+						tenantId: r.listing.tenantId,
+						worldId: a,
+						roomId: n
+					}));
+					if (e && (e.cell.hostId !== this.host.id || e.cell.epoch !== r.listing.epoch)) throw new i({ roomId: n });
+					return e;
+				});
+				if (!e) continue;
+				let { cell: c, at: l } = e, u = Object.freeze({
+					worldId: a,
+					zoneId: c.zoneId,
+					roomId: n,
+					epoch: c.epoch,
+					layer: c.layer,
+					at: l
+				}), d = o(Object.freeze({
+					tenantId: c.tenantId,
+					source: u
+				}));
+				if (d instanceof Promise) throw d.catch(() => void 0), new t({ detail: "Boundary cell factories must be synchronous" });
+				if (s(d, ["executor", "policy"], ["executor", "policy"]), this.owned.get(n) !== r || this.closing || !r.published) throw new i({ roomId: n });
+				await this.ownWorldBoundaryCoordinator(n, c.tenantId, c.epoch, a, d.executor, d.policy);
+				break;
+			} catch (t) {
+				e.push(t);
+			}
+		}
+		if (e.length) throw AggregateError(e, "World boundary cell acquisition remains incomplete");
+	}
+	ownWorldBoundaryCoordinator(e, n, r, a, o, c) {
+		return this.capturedWorldOperation(() => {
+			let e = [
+				"maxPending",
+				"maxEntriesPerTurn",
+				"maxBytes",
+				"prepareTtlMs"
+			];
+			s(c, e, e);
+			for (let e of [
+				"prepare",
+				"commit",
+				"cancel",
+				"resume",
+				"status"
+			]) {
+				let n = Object.getOwnPropertyDescriptor(o, e);
+				if (!n || !("value" in n) || typeof n.value != "function") throw new t({ detail: "Boundary owner requires own executor capabilities" });
+			}
+			return {
+				policy: { ...c },
+				executor: {
+					prepare: o.prepare.bind(o),
+					commit: o.commit.bind(o),
+					cancel: o.cancel.bind(o),
+					resume: o.resume.bind(o),
+					status: o.status.bind(o)
+				}
+			};
+		}, async (o) => {
+			let s = this.requireOwned(e, n), c = this.options.worlds?.find((e) => e.name === a);
+			if (!s.published || s.listing.epoch !== r || !s.descriptor.world?.movement || !c || !c.zones.some((e) => e.room === s.descriptor.name) || this.boundaryCoordinators.has(e) || !this.options.worldEntities?.transitions?.scanSourceTransitions) throw new i({ roomId: e });
+			let l = fe(this, o.executor, {
+				...o.policy,
+				tenantId: n,
+				roomId: e,
+				epoch: r,
+				world: c,
+				epochNow: this.options.epochNow
+			}), u = {
+				owned: s,
+				coordinator: l
+			};
+			return this.boundaryCoordinators.set(e, u), Object.freeze({
+				observation: l.observation,
+				runDue: () => P() || this.owned.get(e) !== s || this.closing || this.closed ? Promise.reject(new t({ detail: "Boundary work requires its current owner outside command delivery" })) : l.runDue(),
+				close: async () => {
+					if (P()) throw new t({ detail: "Boundary cleanup must run outside command delivery" });
+					await l.close(), this.boundaryCoordinators.get(e) === u && this.boundaryCoordinators.delete(e);
+				}
+			});
+		});
+	}
+	runWorldBoundaries(e) {
+		let t = this.boundaryMaintenance;
+		if (t && !e) return t;
+		let n = Promise.resolve().then(async () => {
+			t && await t.catch(() => void 0);
+			let n = [];
+			for (let [t, r] of [...this.boundaryCoordinators]) try {
+				let n = e ? null : await Y(this.directory.observeOwnership(t, r.owned.listing.tenantId));
+				(e || this.closing || this.closed || r.coordinator.observation().closed || this.owned.get(t) !== r.owned || !r.owned.published || !n || n.hostId !== this.host.id || n.epoch !== r.owned.listing.epoch || n.state !== "live") && (await r.coordinator.close(), this.boundaryCoordinators.get(t) === r && this.boundaryCoordinators.delete(t));
+			} catch (e) {
+				n.push(e);
+			}
+			if (!e && !this.closing && !this.closed) {
+				try {
+					await this.acquireWorldBoundaryCells();
+				} catch (e) {
+					n.push(e);
+				}
+				for (let e of [...this.boundaryCoordinators.values()]) try {
+					await e.coordinator.runDue();
+				} catch (e) {
+					n.push(e);
+				}
+			}
+			if (n.length) throw AggregateError(n, "Host boundary coordination remains incomplete");
+		});
+		return this.boundaryMaintenance = n, n.then(() => {
+			this.boundaryMaintenance === n && (this.boundaryMaintenance = void 0);
+		}, () => {
+			this.boundaryMaintenance === n && (this.boundaryMaintenance = void 0);
+		}), n;
+	}
+	scanWorldSourceTransitions(e, t, n, r, a, o) {
+		return this.worldOperation(async () => {
+			let s = this.requireOwned(e, t), c = this.options.worldEntities?.transitions?.scanSourceTransitions;
+			if (!s.published || s.listing.epoch !== n || !s.descriptor.world || !c || !this.options.worlds?.some((e) => e.name === r && e.zones.some((e) => e.room === s.descriptor.name))) throw new i({ roomId: e });
+			let l = await Y(c({
+				roomId: e,
+				tenantId: t,
+				epoch: n,
+				worldId: r,
+				hostId: this.host.id,
+				maxRows: a,
+				maxBytes: o
+			})), u = await Y(this.directory.observeOwnership(e, t));
+			if (this.owned.get(e) !== s || !u || u.hostId !== this.host.id || u.epoch !== n || u.state !== "live") throw new i({ roomId: e });
+			return l;
+		});
+	}
+	captureWorldBoundaryIntents(e, n, r, a) {
+		return this.worldOperation(async () => {
+			let o = this.requireOwned(e, n), s = this.options.worldEntities, c = this.options.worlds?.find((e) => e.name === a);
+			if (!o.published || o.listing.epoch !== r || !o.descriptor.world?.movement || !s?.admitActorProjection || !c) throw new i({ roomId: e });
+			if (!this.runtime.worldMovementSnapshot(e, n, r).bound) return Object.freeze({
+				epoch: r,
+				tick: 0,
+				intents: Object.freeze([])
+			});
+			let l = await this.runtime.captureWorldMovement(e, n, r), u = [];
+			for (let i of l.intents) {
+				let o = {
+					tenantId: n,
+					entityId: i.entityId,
+					roomId: e,
+					hostId: this.host.id,
+					epoch: r
+				}, l = await Y(s.admitActorProjection(o)), d = c.zones.find((e) => e.id === l.zoneId);
+				if (!d || l.worldId !== a || l.roomId !== e || l.epoch !== r || S(c, {
+					zone: d.id,
+					at: i.sourceAt
+				}).id !== l.cellId) throw new t({ detail: "Boundary intention lost its actual source cell" });
+				let f = c.zones.filter((e) => (e.id === d.id || d.neighbors.includes(e.id)) && i.targetAt[0] >= e.bounds[0][0] && i.targetAt[0] < e.bounds[1][0] && i.targetAt[1] >= e.bounds[0][1] && i.targetAt[1] < e.bounds[1][1]);
+				if (!f.length) continue;
+				if (f.length !== 1) throw new t({ detail: "Boundary intention has ambiguous neighboring zones" });
+				if (S(c, {
+					zone: f[0].id,
+					at: i.targetAt
+				}).id === l.cellId && f[0].id === d.id) continue;
+				let p = await Y(s.admitActorProjection(o));
+				if (p.revision !== l.revision || p.worldId !== l.worldId || p.zoneId !== l.zoneId || p.cellId !== l.cellId || p.layer !== l.layer || p.roomId !== e || p.epoch !== r) throw new t({ detail: "Boundary source ownership changed during observation" });
+				u.push(Object.freeze({
+					crossing: i.crossing,
+					revision: l.revision,
+					intention: Object.freeze({
+						entityId: i.entityId,
+						target: Object.freeze({
+							kind: "cell",
+							zone: f[0].id,
+							at: i.targetAt
+						}),
+						options: Object.freeze({
+							mode: "seamless",
+							reason: "boundary",
+							crossPool: !1
+						})
+					})
+				}));
+			}
+			let d = await this.runtime.captureWorldMovement(e, n, r);
+			if (d.tick !== l.tick || JSON.stringify(d.intents) !== JSON.stringify(l.intents)) throw new t({ detail: "Boundary movement changed while checking SQL admission" });
+			return Object.freeze({
+				epoch: r,
+				tick: l.tick,
+				intents: Object.freeze(u)
+			});
+		});
+	}
+	listWorldGhostEntityIds(e, t, n, r, a) {
+		return this.worldOperation(async () => {
+			let o = this.requireOwned(e, t);
+			if (!o.published || o.listing.epoch !== n || !o.descriptor.world) throw new i({ roomId: e });
+			let s = async () => {
+				let r = await Y(this.directory.observeOwnership(e, t));
+				if (!r || r.hostId !== this.host.id || r.epoch !== n || r.state !== "live") throw new i({ roomId: e });
+			};
+			await s();
+			let c = await this.runtime.listWorldEntityIds(e, t, n, r, a);
+			return await s(), c;
+		});
+	}
+	captureWorldGhostSource(e, n, r, a, o, s) {
+		return this.worldOperation(async () => {
+			let c = this.requireOwned(e, n), l = this.options.worldEntities;
+			if (!c.published || c.listing.epoch !== r || c.descriptor.mode === "lockstep" || !c.descriptor.world || !l?.admitActorProjection || typeof s != "function" || this.options.worldSnapshotMaxBytes === void 0 || !Number.isSafeInteger(o) || o < 1 || o > this.options.worldSnapshotMaxBytes) throw new i({ roomId: e });
+			let u = async () => {
+				let i = l.admitActorProjection({
+					tenantId: n,
+					entityId: a,
+					roomId: e,
+					hostId: this.host.id,
+					epoch: r
+				});
+				if (!G.isEffect(i)) throw new t({ detail: "Ghost source requires actual persisted projection admission" });
+				let o = await Y(i);
+				if (o.tenantId !== n || o.entityId !== a || o.roomId !== e || o.epoch !== r) throw new t({ detail: "Ghost source admission escaped its actual actor" });
+				return o;
+			}, d = await u(), f = await this.runtime.captureWorldProjection(e, n, r, a, o), p = s(f.entity);
+			if (p instanceof Promise) throw p.catch(() => void 0), new t({ detail: "Ghost position projection must be synchronous" });
+			let m = h(p, 128), g = this.options.worlds?.find((e) => e.name === d.worldId);
+			if (!g || S(g, {
+				zone: d.zoneId,
+				at: m
+			}).id !== d.cellId) throw new t({ detail: "Ghost position escaped its still-authoritative source cell" });
+			let _ = A(c.descriptor.state, {
+				maxBytes: o,
+				maxFieldId: Math.min(4096, o * 7),
+				maxCollectionLength: Math.min(16384, o)
+			}), v = _.full(f.entity);
+			if (K.isFailure(v)) throw v.failure;
+			let y = O({
+				schemaHash: _.schemaHash,
+				bytes: Array.from(v.success),
+				entity: f.entity
+			}, o), b = await u();
+			if (b.revision !== d.revision || b.worldId !== d.worldId || b.zoneId !== d.zoneId || b.cellId !== d.cellId || b.layer !== d.layer) throw new t({ detail: "Ghost source changed while capturing actor bytes" });
+			return h({
+				source: {
+					tenantId: n,
+					worldId: d.worldId,
+					zoneId: d.zoneId,
+					layer: d.layer,
+					roomId: e,
+					hostId: this.host.id,
+					epoch: r,
+					at: m
+				},
+				entityId: a,
+				revision: d.revision,
+				tick: f.tick,
+				snapshot: y
+			}, o);
+		});
+	}
+	captureWorldEntity(e, t, n, r, a) {
+		return this.worldOperation(async () => {
+			let o = this.requireOwned(e, t);
+			if (!o.published || o.listing.epoch !== n || o.descriptor.mode === "lockstep" || !o.descriptor.world) throw new i({ roomId: e });
+			let s = async () => {
+				let r = await Y(this.directory.observeOwnership(e, t));
+				if (!r || r.hostId !== this.host.id || r.epoch !== n || r.state !== "live") throw new i({ roomId: e });
+			};
+			await s();
+			let c = await this.runtime.captureWorldEntity(e, t, n, r, a);
+			return await s(), c;
+		});
+	}
+	adopt(r, a, o) {
+		return this.operation(async () => {
+			let s = this.options.ports?.recovery;
+			if (!s) throw new t({ detail: "Room adoption requires the actual recovery port" });
+			let c = this.owned.get(r);
+			if (!c && this.owned.size >= this.options.capacity) throw new e({
+				budget: "retainedHostRooms",
+				limit: this.options.capacity
+			});
+			let l = await Y(s.claim(this.host.id, r, a, o));
+			if (l.listing.hostId !== this.host.id || l.listing.id !== r || l.listing.tenantId !== a || l.listing.epoch !== o + 1) throw new t({ detail: "Recovery port returned an unrelated ownership claim" });
+			if (re(this.options.pools, l.listing.name, a, l.listing.pool, this.host.pool, this.host.region), l.mode === "lockstep") {
+				await this.installLockstepSuccessor(l), await this.runtime.publishLockstep(r);
+				let e = this.requireOwned(r, a);
+				return e.published = !0, Object.freeze({
+					roomId: r,
+					epoch: e.listing.epoch,
+					recoveredTick: l.recoveredTick,
+					ticksLost: null
+				});
+			}
+			if (l.checkpoint.roomId !== r || l.checkpoint.tenantId !== a || l.checkpoint.epoch > l.listing.epoch) throw new t({ detail: "Recovery port returned an unrelated state checkpoint" });
+			if (c && (c.listing.tenantId !== a || c.listing.epoch !== l.listing.epoch)) throw new n({ roomId: r });
+			let u = this.options.worlds?.some((e) => e.zones.some((e) => e.room === l.listing.name) || e.instances.some((e) => e.room === l.listing.name)) === !0, d = async () => {
+				if (!u) return;
+				let e = this.options.worldEntities;
+				if (!e || typeof e.recoverRoom != "function") throw new t({ detail: "World Room adoption requires actual entity recovery authority" });
+				let n = l.checkpoint.worldRecoveryEpoch ?? Math.min(l.checkpoint.epoch, o), i = Object.freeze({
+					tenantId: a,
+					roomId: r,
+					hostId: this.host.id,
+					priorEpoch: o,
+					epoch: l.listing.epoch,
+					worldRecoveryEpoch: n
+				});
+				await ue(i, (e, t, i, s, c) => this.applyWorldSourceTransitionOwned(r, a, l.listing.epoch, {
+					origin: e,
+					operation: "rollback"
+				}, t, i, s, o, n, c), async (n) => {
+					let r = e.recoverRoom(i, n);
+					if (!G.isEffect(r)) throw new t({ detail: "World entity recovery must return an actual Effect" });
+					await Y(r);
+				});
+			};
+			if (u && !this.options.worldEntities) throw new t({ detail: "World Room adoption requires actual entity recovery authority" });
+			if (!c) {
+				let e = this.catalog.get(l.listing.name);
+				if (e.mode === "lockstep") throw new t({ detail: "Lockstep ownership adoption requires its SQL journal runtime binding" });
+				if (l.listing.maxClients !== e.maxClients) throw new t({ detail: "Recovered Room capacity no longer matches its descriptor" });
+				let n = q.decodeUnknownSync(e.options)(l.options), o = C(q.encodeSync(e.options)(n)), s = await Y(z(this.geometry, {
+					roomId: r,
+					tenantId: a,
+					hostId: this.host.id,
+					epoch: l.listing.epoch,
+					name: e.name
+				}));
+				try {
+					if (s) {
+						let e = await Y(this.directory.observeOwnership(r, a));
+						if (V(e, {
+							roomId: r,
+							tenantId: a,
+							hostId: this.host.id,
+							epoch: l.listing.epoch
+						}) || e?.state !== "creating" && e?.state !== "live") throw new i({ roomId: r });
+					}
+					this.runtime.restore(l.checkpoint, e, n, l.listing.epoch, this.reservationsFor().admission, {
+						epochNow: this.options.epochNow,
+						secrets: this.options.secrets,
+						seatToken: this.seatToken,
+						authorizeWorldTarget: this.authorizeWorldTarget,
+						...this.options.resolveWorldPlayer ? { authorizeWorldPlayer: this.authorizeWorldPlayer } : {},
+						...s ? { geometry: s } : {},
+						spectatorGroup: this.spectatorGroup(e, r, a, l.listing.epoch),
+						replayRecording: this.replayRecordings?.(Object.freeze({
+							roomId: r,
+							tenantId: a,
+							name: e.name,
+							epoch: l.listing.epoch
+						}))
+					}, !0), this.owned.set(r, {
+						listing: l.listing,
+						descriptor: e,
+						optionFingerprint: o,
+						private: l.private,
+						published: !1,
+						...s ? { geometry: s } : {}
+					});
+				} catch (e) {
+					if (s) {
+						this.pendingGeometryCleanup.set(r, {
+							listing: l.listing,
+							geometry: s,
+							abandonCreation: !1
+						});
+						try {
+							await this.cleanupGeometry();
+						} catch (t) {
+							throw AggregateError([e, t], "Successor geometry cleanup remains retained without abandoning SQL recovery");
+						}
+					}
+					throw e;
+				}
+			}
+			let f = this.requireOwned(r, a);
+			if (f.published) await d(), await this.synchronizeWorldCell(r, f);
+			else {
+				if (this.runtime.isPublicationHeld(r)) {
+					let e = await Y(this.directory.observeOwnership(r, a));
+					if (!e || e.hostId !== this.host.id || e.epoch !== l.listing.epoch || !["creating", "live"].includes(e.state)) throw new i({ roomId: r });
+					u && e.state === "creating" && await this.runtime.persist(r), await d(), u && e.state === "creating" && await this.retireTerminalWorldReceipts(r, a, l.listing.epoch, !0), await this.runtime.publishHeld(r, d);
+				} else await d(), await this.runtime.persist(r), await d();
+				await this.synchronizeWorldCell(r, f), f.published = !0;
+			}
+			return Object.freeze({
+				roomId: r,
+				epoch: f.listing.epoch,
+				recoveredTick: l.recoveredTick,
+				ticksLost: null
+			});
+		});
+	}
+	async join(e, t, n, a) {
+		t = structuredClone(t), n = structuredClone(n);
+		let s = await this.operation(async () => {
+			let r = this.catalog.get(e), i = await this.authorize(r, n, {
+				name: e,
+				options: t
+			}), a = q.decodeUnknownSync(r.options)(t), o = r.mode === "lockstep" ? Buffer.from(l(r.simulation).encode(t)).toString("base64url") : C(q.encodeSync(r.options)(a));
+			return [...this.owned.values()].filter((t) => t.published && !t.private && t.listing.name === e && t.listing.tenantId === i.tenantId && t.optionFingerprint === o && (t.descriptor.mode !== "lockstep" || this.runtime.lockstepRosterOpen(t.listing.id))).map((e) => e.listing.id).sort();
+		});
+		for (let e of s) try {
+			return await this.reserve(e, n, "player", a);
+		} catch (e) {
+			if (!(e instanceof r || e instanceof o || e instanceof i)) throw e;
+		}
+		return this.create(e, t, n, {}, a);
+	}
+	reservationsFor(e, t = !1) {
+		return Je(this.store, {
+			secrets: this.options.secrets,
+			epochNow: this.options.epochNow,
+			worlds: this.options.worlds,
+			seatToken: this.seatToken,
+			seatTtlMs: this.options.seatTtlMs,
+			graceMs: (e) => {
+				let t = this.owned.get(e);
+				if (!t) throw new i({ roomId: e });
+				return t.descriptor.reconnect.graceMs;
+			},
+			hostHeartbeatTtlMs: this.options.heartbeatTtlMs,
+			ownerHostId: this.host.id,
+			authorize: (r, a) => G.tryPromise({
+				try: async () => {
+					if (!e) throw new n({ roomId: r });
+					let o = this.requireOwned(r, a.tenantId);
+					if (!o.published || !t && o.descriptor.mode === "lockstep" && !this.runtime.lockstepRosterOpen(r)) throw new i({ roomId: r });
+					let s = await this.authorize(o.descriptor, e, { roomId: r }, r);
+					if (s.subjectId !== a.subjectId || s.tenantId !== a.tenantId) throw new n({ roomId: r });
+				},
+				catch: () => new n({ roomId: r })
+			})
+		});
+	}
+	reserve(e, n, r = "player", a) {
+		return this.capturedOperation(() => ({
+			subject: structuredClone(n),
+			attributes: a === void 0 ? void 0 : u(e, a)
+		}), async ({ subject: n, attributes: a }) => {
+			let o = X(n), s = this.requireOwned(e, o.tenantId);
+			if (!s.published || s.descriptor.mode === "lockstep" && !this.runtime.lockstepRosterOpen(e)) throw new i({ roomId: e });
+			if (s.descriptor.mode === "lockstep" && r !== "player") throw new t({ detail: "Lockstep initial roster cannot reserve spectator seats" });
+			return await this.authorize(s.descriptor, n, {
+				roomId: e,
+				role: r
+			}, e), Y(this.reservationsFor(n).reserve(e, o, r, a));
+		});
+	}
+	resume(e, t, n) {
+		return this.capturedOperation(() => ({
+			subject: structuredClone(t),
+			attributes: n === void 0 ? void 0 : u(e, n)
+		}), async ({ subject: t, attributes: n }) => {
+			let r = X(t);
+			return Y(this.reservationsFor(t, !0).resume(e, r, n));
+		});
+	}
+	leave(e, t, n) {
+		return this.capturedOperation(() => {
+			if (!(t instanceof Uint8Array) || t.byteLength < 1 || t.byteLength > 8192) throw Error("Invalid withdrawal bytes");
+			return {
+				token: Uint8Array.from(t),
+				subject: structuredClone(n)
+			};
+		}, async ({ token: t, subject: n }) => {
+			let r = X(n), i = await Y(this.reservationsFor().release(e, t, r));
+			return i !== null && await this.runtime.leaveSession(i, e), { ok: !0 };
+		}, !0);
+	}
+	list(e, t, n = 64) {
+		return this.capturedOperation(() => structuredClone(t), async (t) => {
+			let r = this.catalog.get(e), i = await this.authorize(r, t, { name: e });
+			return (await Y(this.directory.list(i.tenantId, e, n))).filter((e) => e.hostId === this.host.id && this.owned.get(e.id)?.published);
+		});
+	}
+	async verifySeat(e, r) {
+		if (!this.activated || this.closing || this.closed) throw new i({ roomId: "host" });
+		let a = ne(e, this.options.secrets, this.options.epochNow(), this.seatToken.verify), o = this.requireOwned(a.roomId, a.tenantId);
+		if (!o.published || o.listing.epoch !== a.epoch) throw new n({ roomId: a.roomId });
+		let s = await Y(this.options.resolveSubject(a), r), c = await this.authorize(o.descriptor, s, {
+			roomId: a.roomId,
+			sessionId: a.sessionId,
+			role: a.role
+		}, a.roomId, r);
+		if (r?.aborted) throw new t({ detail: "Room gateway admission was cancelled" });
+		if (c.tenantId !== a.tenantId || c.subjectId !== a.subjectId) throw new n({ roomId: a.roomId });
+		if (await w(this.store, c), r?.aborted) throw new t({ detail: "Room gateway admission was cancelled" });
+		return a;
+	}
+	connect(e, t, r) {
+		if (!this.activated || this.closing || this.closed) throw new i({ roomId: e.roomId });
+		let a = this.requireOwned(e.roomId, e.tenantId);
+		if (!a.published || a.listing.epoch !== e.epoch) throw new n({ roomId: e.roomId });
+		let o = this.runtime.connect(e.roomId, t);
+		return o.admitFirstFrame(r), o;
+	}
+	turn() {
+		if (P()) return Promise.reject(new t({ detail: "Host lifecycle cannot run inside command delivery" }));
+		if (!this.activated && !this.closing && !this.closed) return Promise.resolve(0);
+		let e;
+		return this.runWorldBoundaries(!1).catch((t) => {
+			e = t;
+		}).then(() => this.runWorldGhostReceivers(!1)).then(() => this.operation(async () => {
+			await this.cleanupUninstalledCreations(), await this.cleanupGeometry(), await this.reconcileOwnership();
+			for (let e of this.owned.keys()) this.runtime.isPublicationHeld(e) || await this.runtime.synchronizeGeometry(e);
+			this.options.worldPersistence && await Y(this.options.worldPersistence.runDue());
+			let t = [];
+			for (let [e, n] of this.owned) if (n.published && n.descriptor.mode !== "lockstep" && n.descriptor.world) try {
+				await this.retireTerminalWorldReceipts(e, n.listing.tenantId, n.listing.epoch);
+			} catch (e) {
+				t.push(e);
+			}
+			for (let [e, n] of this.owned) if (!this.runtime.isPublicationHeld(e)) try {
+				await this.delivery.deliver(e, n.listing.tenantId);
+			} catch (e) {
+				t.push(e);
+			}
+			for (let [e, n] of this.owned) if (n.published && n.descriptor.mode === "lockstep") try {
+				await this.runtime.prepareLockstepInitialRoster(e, this.lockstepInitial);
+			} catch (e) {
+				t.push(e);
+			}
+			for (let [e, n] of this.owned) if (n.published && n.descriptor.mode !== "lockstep" && n.descriptor.world?.movement && this.runtime.worldFinalizationRequest(e, n.listing.tenantId, n.listing.epoch) === null) try {
+				await this.bindWorldCellMovement(e, n);
+			} catch (e) {
+				t.push(e);
+			}
+			let n = 0;
+			try {
+				n = await this.runtime.turn();
+			} catch (e) {
+				t.push(e);
+			}
+			try {
+				this.observeWorldBoundaryClamps();
+			} catch (e) {
+				t.push(e);
+			}
+			if (this.options.worldPersistence) try {
+				await Y(this.options.worldPersistence.runDue());
+			} catch (e) {
+				t.push(e);
+			}
+			let r = new Set(this.runtime.host.activeRooms().map((e) => e.id));
+			for (let [e, n] of [...this.owned]) {
+				if (this.runtime.isPublicationHeld(e)) continue;
+				let i = null;
+				try {
+					i = await this.delivery.deliver(e, n.listing.tenantId);
+				} catch (e) {
+					t.push(e);
+				}
+				if (!r.has(e)) {
+					if (n.published = !1, this.runtime.isHibernating(e)) try {
+						await Y(this.reservationsFor().sweepExpired(e, n.listing.tenantId));
+					} catch (e) {
+						t.push(e);
+					}
+					if (i === 0 && !this.runtime.retains(e)) {
+						try {
+							await this.synchronizeWorldCell(e, n);
+						} catch (e) {
+							t.push(e);
+							continue;
+						}
+						await this.releaseGeometryReload(e), await this.releaseGeometryRollback(e), this.geometryReloads.delete(e), this.geometryRollbacks.delete(e), this.owned.delete(e);
+					}
+				} else if (!this.runtime.hasPendingCheckpoint(e)) {
+					if (n.descriptor.mode === "lockstep" && !n.published) try {
+						await this.runtime.publishLockstep(e);
+					} catch (e) {
+						t.push(e);
+						continue;
+					}
+					try {
+						await Y(this.reservationsFor().sweepExpired(e, n.listing.tenantId)), await this.runtime.synchronizeGeometry(e), await this.synchronizeWorldCell(e, n), n.published = !0;
+					} catch (e) {
+						n.published = !1, t.push(e);
+					}
+				}
+			}
+			let i = this.options.clock.now();
+			if (i >= this.nextHeartbeatAt) {
+				let e = this.runtime.metrics();
+				await Y(this.directory.heartbeat(this.host.id, {
+					rooms: e.ownedRooms,
+					clients: e.sessions,
+					cpu: this.options.measuredCpu()
+				})), this.nextHeartbeatAt = i + this.options.heartbeatEveryMs;
+			}
+			if (t.length) throw AggregateError(t, "Room host control turn failed");
+			if (await this.cells.refresh(this.store, this.cellOwners()), e) throw e;
+			return n;
+		}));
+	}
+	async bindWorldCellMovement(e, n) {
+		let r = n.listing.tenantId, a = n.listing.epoch;
+		await this.runtime.configureWorldCellMovement(e, r, a), await this.synchronizeWorldCell(e, n);
+		let o = this.options.worlds?.filter((e) => e.zones.some((e) => e.room === n.descriptor.name)) ?? [];
+		if (!o.length) {
+			let t = this.options.worlds?.filter((e) => e.instances.some((e) => e.room === n.descriptor.name)) ?? [];
+			t.length === 1 && await this.runtime.configureWorldCellMovement(e, r, a, t[0].map.bounds, 0);
+			return;
+		}
+		let s = D(this.store, {
+			worlds: o,
+			epochNow: this.options.epochNow,
+			maxListedCells: 1,
+			authorize: () => G.sync(() => {
+				if (this.owned.get(e) !== n || !n.published) throw new i({ roomId: e });
+			})
+		}), c, l = 0;
+		for (let n of o) {
+			let i = await Y(s.observeRoom({
+				tenantId: r,
+				worldId: n.name,
+				roomId: e
+			}));
+			if (i) {
+				if (c || i.cell.hostId !== this.host.id || i.cell.epoch !== a) throw new t({ detail: "World movement has ambiguous or foreign cell authority" });
+				c = S(n, {
+					zone: i.cell.zoneId,
+					at: i.at
+				}).bounds, l = n.handoff.marginUnits;
+			}
+		}
+		c && await this.runtime.configureWorldCellMovement(e, r, a, c, l);
+	}
+	async synchronizeWorldCell(e, n) {
+		n.descriptor.world && this.options.worlds?.length && (this.options.worlds.some((e) => e.instances.some((e) => e.room === n.descriptor.name)) ? await N(this.store, this.options.worlds, {
+			tenantId: n.listing.tenantId,
+			roomId: e,
+			hostId: this.host.id,
+			epoch: n.listing.epoch
+		}, this.options.epochNow, () => {
+			if (this.owned.get(e) !== n) throw new t({ detail: "Instance lifecycle lost its retained Host actor" });
+		}) : await Y(D(this.store, {
+			worlds: this.options.worlds,
+			epochNow: this.options.epochNow,
+			maxListedCells: 1,
+			authorize: (r, i) => G.sync(() => {
+				if (this.owned.get(e) !== n || i.tenantId !== n.listing.tenantId || !this.options.worlds.some((e) => e.name === i.worldId && e.zones.some((e) => e.room === n.descriptor.name))) throw new t({ detail: "World lifecycle requires the actual retained Host Room and catalogue" });
+			})
+		}).synchronizeRoom({
+			tenantId: n.listing.tenantId,
+			roomId: e,
+			hostId: this.host.id,
+			epoch: n.listing.epoch
+		})));
+	}
+	async reconcileOwnership() {
+		for (let [e, t] of this.owned) {
+			let n = await Y(this.directory.observeOwnership(e, t.listing.tenantId));
+			V(n, {
+				roomId: e,
+				tenantId: t.listing.tenantId,
+				hostId: this.host.id,
+				epoch: t.listing.epoch
+			}) && (t.published = !1, await this.runtime.withdrawOwnership(e, t.listing.tenantId, t.listing.epoch), await this.releaseGeometryReload(e), await this.releaseGeometryRollback(e), this.geometryReloads.delete(e), this.geometryRollbacks.delete(e), this.owned.delete(e));
+		}
+	}
+	withdraw(e) {
+		let n;
+		try {
+			n = Ye(e);
+		} catch {
+			return Promise.reject(new t({ detail: "Invalid room ownership withdrawal" }));
+		}
+		return this.operation(async () => {
+			let e = await Y(this.directory.observeOwnership(n.roomId, n.tenantId));
+			if (!e || e.roomId !== n.roomId || e.tenantId !== n.tenantId || e.hostId !== this.host.id || e.epoch !== n.withdrawnEpoch || e.state !== "disposed") throw new t({ detail: "Room withdrawal does not match its exact newer SQL authority" });
+			let r = this.owned.get(n.roomId);
+			if (r) {
+				if (r.listing.tenantId !== n.tenantId || r.listing.epoch !== n.priorEpoch) throw new t({ detail: "Room withdrawal targets another retained actor epoch" });
+				r.published = !1, await this.runtime.withdrawOwnership(n.roomId, n.tenantId, n.priorEpoch), await this.releaseGeometryReload(n.roomId), await this.releaseGeometryRollback(n.roomId), this.geometryReloads.delete(n.roomId), this.geometryRollbacks.delete(n.roomId), this.owned.delete(n.roomId);
+			}
+		}, !0);
+	}
+	drain(e) {
+		if (P()) return Promise.reject(new t({ detail: "Host lifecycle cannot run inside command delivery" }));
+		if (this.closed) return Promise.resolve();
+		try {
+			let n = je(e), { graceMs: r, maxCheckpointBytes: i } = n;
+			if (this.plannedDrain) {
+				if (this.plannedDrain.policy.graceMs !== r || this.plannedDrain.policy.maxCheckpointBytes !== i) throw new t({ detail: "Planned drain retry cannot change its retained policy" });
+			} else {
+				if (this.closing || this.closeTask || !this.host.membership || this.host.membership.instanceId === void 0) throw new t({ detail: "Planned drain requires its registered process before terminal shutdown" });
+				let e = Object.freeze({
+					hostId: this.host.id,
+					instanceId: this.host.membership.instanceId,
+					startedAt: this.host.membership.startedAt
+				}), r = {
+					...n,
+					epochNow: this.options.epochNow,
+					snapshotBlobs: this.options.snapshotBlobs,
+					snapshotCodec: (e) => new d(this.catalog.get(e).state),
+					lockstep: { descriptor: (e) => {
+						let t = this.catalog.get(e);
+						return t.mode === "lockstep" ? t : void 0;
+					} }
+				}, i = (this.options.ports?.hostDrain ?? ((e, t) => Me(this.store, e, t)))(e, r), a = s(i, ["begin", "handoff"], ["begin", "handoff"]);
+				if (typeof a.begin != "function" || typeof a.handoff != "function") throw new t({ detail: "Planned drain provider must supply both actual operations" });
+				this.plannedDrain = {
+					policy: n,
+					port: Object.freeze({
+						begin: i.begin.bind(i),
+						handoff: i.handoff.bind(i)
+					}),
+					begun: !1,
+					worldClosed: !1
+				};
+			}
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		if (this.closeTask) return this.closeTask;
+		this.closing = !0, this.activated = !1;
+		let n = this.plannedDrain, r = this.runWorldBoundaries(!0).then(() => this.runWorldGhostReceivers(!0)).then(() => this.operation(async () => {
+			let e = async (e) => {
+				if (!G.isEffect(e)) throw new t({ detail: "Planned drain provider must return its actual Effect" });
+				return Y(G.uninterruptible(e));
+			};
+			n.begun || (await e(n.port.begin()), n.begun = !0, this.routingFenced = !0), await this.cleanupUninstalledCreations(), await this.cleanupGeometry(), n.worldClosed ||= (this.options.worldPersistence && await Y(this.options.worldPersistence.close()), !0);
+			let r = [];
+			for (let [i, a] of this.owned) try {
+				let r = this.plannedRooms.get(i);
+				if (r && !r.boundary) {
+					let e = await Y(this.directory.observeOwnership(i, a.listing.tenantId));
+					if (V(e, {
+						roomId: i,
+						tenantId: a.listing.tenantId,
+						hostId: this.host.id,
+						epoch: a.listing.epoch
+					})) {
+						await this.runtime.withdrawOwnership(i, a.listing.tenantId, a.listing.epoch), await this.releasePlannedRoom(i);
+						continue;
+					}
+				}
+				if (!r) {
+					let e = await Y(this.directory.observeOwnership(i, a.listing.tenantId));
+					if (V(e, {
+						roomId: i,
+						tenantId: a.listing.tenantId,
+						hostId: this.host.id,
+						epoch: a.listing.epoch
+					})) {
+						await this.runtime.withdrawOwnership(i, a.listing.tenantId, a.listing.epoch), await this.releasePlannedRoom(i);
+						continue;
+					}
+					if (this.runtime.isHibernating(i) && await Y(this.reservationsFor().sweepExpired(i, a.listing.tenantId)), await this.delivery.deliver(i, a.listing.tenantId) > 0) throw new t({ detail: "Planned drain retains accepted lifecycle commands; retry" });
+					let n = await this.runtime.settleForDrain(i);
+					if (await this.delivery.deliver(i, a.listing.tenantId) > 0) throw new t({ detail: "Planned drain retains terminal lifecycle commands; retry" });
+					let o = await Y(this.directory.observeOwnership(i, a.listing.tenantId));
+					if (V(o, {
+						roomId: i,
+						tenantId: a.listing.tenantId,
+						hostId: this.host.id,
+						epoch: a.listing.epoch
+					}), n === "retired") {
+						if (o.epoch !== a.listing.epoch || ![
+							"disposed",
+							"faulted",
+							"hibernated"
+						].includes(o.state) || o.state !== "hibernated" && o.hostId !== this.host.id) throw new t({ detail: "Retired Room has no matching durable lifecycle boundary" });
+						await this.synchronizeWorldCell(i, a), await this.releasePlannedRoom(i);
+						continue;
+					}
+					if (o.hostId !== this.host.id || o.epoch !== a.listing.epoch || o.state !== "live") throw new t({ detail: "Active Room did not confirm its retained SQL publication" });
+					a.published = !0, r = {
+						boundary: null,
+						commandsDrained: !1,
+						handedOff: !1,
+						notified: !1,
+						withdrawn: !1
+					}, this.plannedRooms.set(i, r);
+				}
+				if (!r.handedOff) {
+					if (!r.commandsDrained) {
+						if (await this.delivery.deliver(i, a.listing.tenantId) > 0) throw new t({ detail: "Planned drain retains bounded application delivery work; retry" });
+						if (r.boundary ??= await this.runtime.prepareDrain(i), await this.delivery.deliver(i, a.listing.tenantId) > 0) throw new t({ detail: "Planned drain retains final checkpoint commands; retry" });
+						r.commandsDrained = !0;
+					}
+					if (!r.boundary) throw new t({ detail: "Planned drain lost its retained boundary" });
+					let o = await Y(this.directory.observeOwnership(i, a.listing.tenantId));
+					if (!(V(o, {
+						roomId: i,
+						tenantId: a.listing.tenantId,
+						hostId: this.host.id,
+						epoch: a.listing.epoch
+					}) && o.epoch > a.listing.epoch && o.hostId !== this.host.id && ["creating", "live"].includes(o.state))) {
+						let o = s(await e(n.port.handoff(r.boundary)), [
+							"hostId",
+							"roomId",
+							"tenantId",
+							"epoch",
+							"tick",
+							"state"
+						], [
+							"hostId",
+							"roomId",
+							"tenantId",
+							"epoch",
+							"tick",
+							"state"
+						]);
+						if (o.hostId !== this.host.id || o.roomId !== i || o.tenantId !== a.listing.tenantId || o.epoch !== a.listing.epoch || o.tick !== r.boundary.tick || o.state !== "orphaned") throw new t({ detail: "Planned handoff returned another ownership receipt" });
+					}
+					r.handedOff = !0, a.published = !1;
+				}
+				r.notified || (await this.runtime.notifyDrainMigration(i, n.policy.graceMs), r.notified = !0), r.withdrawn || (await this.runtime.withdrawOwnership(i, a.listing.tenantId, a.listing.epoch), r.withdrawn = !0), await this.releasePlannedRoom(i);
+			} catch (e) {
+				r.push(e);
+			}
+			if (r.length) throw AggregateError(r, "Planned Host drain retains incomplete Rooms");
+			await this.runtime.close(), await Y(this.directory.unregister(this.host.id)), this.closed = !0;
+		}, !0));
+		return this.closeTask = r, r.then(() => {
+			this.closeTask = null;
+		}, () => {
+			this.closeTask = null;
+		}), r;
+	}
+	async releasePlannedRoom(e) {
+		await this.releaseGeometryReload(e), await this.releaseGeometryRollback(e), this.geometryReloads.delete(e), this.geometryRollbacks.delete(e), this.owned.delete(e), this.plannedRooms.delete(e);
+	}
+	close() {
+		if (P()) return Promise.reject(new t({ detail: "Host lifecycle cannot run inside command delivery" }));
+		if (this.plannedDrain) return this.drain(this.plannedDrain.policy);
+		if (this.closed) return Promise.resolve();
+		if (this.closeTask) return this.closeTask;
+		this.closing = !0, this.activated = !1;
+		let e = this.runWorldBoundaries(!0).then(() => this.runWorldGhostReceivers(!0)).then(() => this.operation(async () => {
+			this.routingFenced ||= (await Y(this.directory.setReady(this.host.id, !1)), !0), await this.cleanupUninstalledCreations(), await this.cleanupGeometry(), await this.reconcileOwnership();
+			for (let e of this.geometryReloads.keys()) await this.releaseGeometryReload(e);
+			for (let e of this.geometryRollbacks.keys()) await this.releaseGeometryRollback(e);
+			let e = async () => {
+				for (let [e, t] of this.owned) {
+					for (; await this.delivery.deliver(e, t.listing.tenantId) > 0;);
+					this.runtime.isHibernating(e) && await Y(this.reservationsFor().sweepExpired(e, t.listing.tenantId));
+				}
+			};
+			await e();
+			try {
+				await this.runtime.close();
+			} catch (t) {
+				if (!(t instanceof a)) throw t;
+				await e(), await this.runtime.close();
+			}
+			for (let [e, t] of this.owned) for (; await this.delivery.deliver(e, t.listing.tenantId) > 0;);
+			for (let [e, t] of this.owned) await this.synchronizeWorldCell(e, t);
+			this.options.worldPersistence && await Y(this.options.worldPersistence.close()), await Y(this.directory.unregister(this.host.id)), this.owned.clear(), this.geometryReloads.clear(), this.geometryRollbacks.clear(), this.closed = !0;
+		}, !0));
+		return this.closeTask = e, e.then(() => {
+			this.closeTask = null;
+		}, () => {
+			this.closeTask = null;
+		}), e;
+	}
+	cellOwners() {
+		return [...this.owned].map(([e, t]) => ({
+			roomId: e,
+			tenantId: t.listing.tenantId,
+			epoch: t.listing.epoch,
+			name: t.descriptor.name,
+			published: t.published
+		}));
+	}
+	observeWorldBoundaryClamps() {
+		let e = new Set(this.runtime.host.activeRooms().map((e) => e.id));
+		for (let [n, r] of this.owned) if (e.has(n) && r.descriptor.mode !== "lockstep" && r.descriptor.world?.movement) {
+			let e = this.runtime.worldMovementSnapshot(n, r.listing.tenantId, r.listing.epoch).clamped, i = e - (this.worldBoundaryObserved.get(r) ?? 0);
+			if (!Number.isSafeInteger(i) || i < 0 || this.worldBoundaryClamps > 2 ** 53 - 1 - i) throw new t({ detail: "World boundary observation exceeded its monotonic Host counter" });
+			this.worldBoundaryClamps += i, this.worldBoundaryObserved.set(r, e);
+		}
+	}
+	metrics() {
+		return {
+			...this.runtime.metrics(),
+			worldBoundaryClamps: this.worldBoundaryClamps,
+			worldHandoffs: this.options.worldEntities?.handoffMetrics?.(),
+			cells: this.closing || !this.activated ? null : this.cells.snapshot(this.cellOwners()),
+			queuedOperations: this.queued,
+			closing: this.closing,
+			ready: this.activated
+		};
+	}
+};
+export { $ as RoomHostController, Z as RoomHostControllerStartFailure };