@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/actor.js

@@ -0,0 +1,1473 @@
+import { BudgetExceeded as e, NotRoomMember as t, ProtocolError as n, RoomAuthoringError as r, RoomForbidden as i, RoomFull as a, RoomGone as o, RoomLocked as s } from "./errors.js";
+import { captureWorldData as c } from "./worldData.js";
+import { encodeRoomFrame as l } from "./wire.js";
+import { makeWorldCellMovement as u } from "./worldMovement.js";
+import { captureWorldTargetSeatBinding as d } from "./worldSeatBinding.js";
+import { captureRoomConsumedSeat as f, captureRoomInputReceipts as p } from "./inputReceipts.js";
+import { WorldAdmissionPending as m } from "./worldAdmissionPending.js";
+import { captureWorldActorReceipts as h, worldActorCanonicalJson as g, worldActorFingerprint as _ } from "./worldActorReceipts.js";
+import { captureGeometryWorldView as v } from "./geometryWorldView.js";
+import { Effect as y, Result as b, Schema as x } from "effect";
+// src/actor.ts
+var S = (e, t, n) => {
+	if (t === void 0) return;
+	let i = t(n);
+	if (i !== void 0) throw i instanceof Promise && i.catch(() => void 0), new r({
+		room: e,
+		detail: "Room actor hooks must return undefined; async work belongs outside the tick"
+	});
+}, C = (e, t, n) => {
+	if (t === void 0) return;
+	let i = t(n);
+	if (i !== void 0) throw i instanceof Promise && i.catch(() => void 0), new r({
+		room: e,
+		detail: "Use the asynchronous host lifecycle path for Effect hooks"
+	});
+}, w = class {
+	id;
+	descriptor;
+	clock;
+	tenantId;
+	currentState;
+	lastGoodState;
+	lastGoodTick = 0;
+	options;
+	members = /* @__PURE__ */ new Map();
+	grace = /* @__PURE__ */ new Map();
+	inputs = [];
+	outbox = [];
+	clientOperations = [];
+	schedules = /* @__PURE__ */ new Map();
+	extensionDurationMs = Object.create(null);
+	extensionOverruns = Object.create(null);
+	tick = 0;
+	droppedTicks = 0;
+	commandSeq = 0;
+	epoch;
+	nextTickAt;
+	emptyAt;
+	locked = !1;
+	disposed = !1;
+	publicationHeldAt = null;
+	drainFrozen = !1;
+	drainAt = null;
+	retiring = !1;
+	faulted = !1;
+	ticking = !1;
+	lastNow = -1;
+	app;
+	scheduler;
+	worldPreviews = /* @__PURE__ */ new Set();
+	worldReceipts = /* @__PURE__ */ new Map();
+	deferredWorldLeaves = /* @__PURE__ */ new Map();
+	worldMovement;
+	worldMovementClamps = 0;
+	worldMovementMargin = 0;
+	worldMovementIntents = Object.freeze([]);
+	worldFinalizationHold = null;
+	worldPublishedTransitions = /* @__PURE__ */ new Set();
+	lifecycleTail = Promise.resolve();
+	lifecycleRequests = 0;
+	lifecycleActive = !1;
+	geometry;
+	constructor(t, n, i, a, o, s, c = {
+		epoch: 0,
+		commandCursor: 0
+	}, l) {
+		if (this.id = t, this.descriptor = n, this.clock = o, this.tenantId = s, this.geometry = l === void 0 ? void 0 : v(l, s), !s.trim()) throw new r({
+			room: n.name,
+			detail: "Every actor requires its explicit tenant identity"
+		});
+		if (![
+			c.epoch,
+			c.commandCursor,
+			c.tick ?? 0
+		].every((e) => Number.isSafeInteger(e) && e >= 0)) throw new r({
+			room: n.name,
+			detail: "Actor recovery epoch and command cursor must be nonnegative safe integers"
+		});
+		for (let e of h(c.worldReceipts ?? [], n.world?.maxPendingTransitions ?? 128)) {
+			if (!n.world) throw new r({
+				room: n.name,
+				detail: "World receipts require the original configured hooks"
+			});
+			this.worldReceipts.set(e.requestId, e);
+		}
+		this.epoch = c.epoch, this.commandSeq = c.commandCursor, this.tick = c.tick ?? 0, this.lastGoodTick = this.tick;
+		let u = x.decodeUnknownSync(x.toType(n.state))(i);
+		this.currentState = structuredClone(u), this.options = structuredClone(x.decodeUnknownSync(x.toType(n.options))(a));
+		let d = this.now();
+		this.nextTickAt = d + 1e3 / n.tickRate, this.emptyAt = d, this.app = Object.freeze({
+			publish: (e, t, n) => this.stage("publish", e, t, n.key),
+			run: (e, t) => this.stage("run", e, t)
+		}), this.scheduler = Object.freeze({
+			after: (e, t) => this.schedule(e, t, !1),
+			every: (e, t) => this.schedule(e, t, !0),
+			cancel: (e) => {
+				this.schedules.delete(e);
+			}
+		});
+		for (let e of n.extensions) for (let t of e.fields) if (typeof this.state != "object" || this.state === null || !Object.hasOwn(this.state, t)) throw new r({
+			room: n.name,
+			detail: `Extension ${e.name} requires state field ${t}`
+		});
+		if ((c.schedules?.length ?? 0) > n.budgets.maxScheduledHooks) throw new e({
+			budget: "maxScheduledHooks",
+			limit: n.budgets.maxScheduledHooks
+		});
+		for (let e of c.schedules ?? []) {
+			if (!e.label.trim() || this.schedules.has(e.label) || !Number.isFinite(e.remainingMs) || e.remainingMs < 0 || e.intervalMs !== null && (!Number.isFinite(e.intervalMs) || e.intervalMs <= 0)) throw new r({
+				room: n.name,
+				detail: "Invalid recovered schedule"
+			});
+			this.schedules.set(e.label, {
+				label: e.label,
+				at: d + e.remainingMs,
+				interval: e.intervalMs
+			});
+		}
+		S(n.name, c.rehydrate ? n.onRehydrate : n.onCreate, {
+			state: this.state,
+			options: this.options,
+			app: this.app,
+			clock: o,
+			scheduler: this.scheduler,
+			...this.geometry ? { geometry: this.geometry } : {}
+		}), x.decodeUnknownSync(x.toType(n.state))(this.state), this.lastGoodState = structuredClone(this.state);
+	}
+	get state() {
+		return this.currentState;
+	}
+	now() {
+		let e = this.clock.now();
+		if (!Number.isFinite(e) || e < 0 || e < this.lastNow) throw new r({
+			room: this.descriptor.name,
+			detail: "The injected monotonic clock must return finite nonnegative nondecreasing time"
+		});
+		return this.lastNow = e, e;
+	}
+	ensureOpen() {
+		if (this.disposed || this.faulted || this.retiring || this.drainFrozen) throw new o({ roomId: this.id });
+	}
+	stage(t, n, i, a) {
+		if (this.ensureOpen(), !n.trim() || t === "publish" && !a?.trim()) throw new r({
+			room: this.descriptor.name,
+			detail: "App commands require a name and publishes require a key"
+		});
+		if (this.outbox.length >= this.descriptor.budgets.maxOutboxCommands) throw new e({
+			budget: "maxOutboxCommands",
+			limit: this.descriptor.budgets.maxOutboxCommands
+		});
+		if (this.commandSeq >= 2 ** 53 - 1) throw new r({
+			room: this.descriptor.name,
+			detail: "Room command cursor is exhausted"
+		});
+		let o = `${this.id}:${this.epoch}:${++this.commandSeq}`;
+		return this.outbox.push(Object.freeze({
+			requestId: o,
+			kind: t,
+			name: n,
+			payload: structuredClone(i),
+			...a === void 0 ? {} : { key: a }
+		})), o;
+	}
+	schedule(t, n, i) {
+		if (this.ensureOpen(), !Number.isFinite(t) || t <= 0 || !n.trim()) throw new r({
+			room: this.descriptor.name,
+			detail: "Scheduled hooks require a positive duration and nonempty label"
+		});
+		if (!this.schedules.has(n) && this.schedules.size >= this.descriptor.budgets.maxScheduledHooks) throw new e({
+			budget: "maxScheduledHooks",
+			limit: this.descriptor.budgets.maxScheduledHooks
+		});
+		this.schedules.set(n, {
+			label: n,
+			at: (this.publicationHeldAt ?? this.now()) + t,
+			interval: i ? t : null
+		});
+	}
+	join(e) {
+		this.assertSynchronousLifecycle();
+		let t = this.prepareJoin(e);
+		this.mutateMember(() => C(this.descriptor.name, this.descriptor.onJoin, t.context(this.state))), t.commit();
+	}
+	joinAsync(e, t) {
+		return this.serializeLifecycle(async () => {
+			let n = this.prepareJoin(e);
+			await this.mutateMemberAsync((e) => this.descriptor.onJoin?.(n.context(e)), t), n.commit();
+		});
+	}
+	joinReservedAsync(e, t, r, i) {
+		let a = f(t);
+		if (a.worldTarget) throw new n({ detail: "World target Seat requires transition-aware actor admission" });
+		if (typeof e?.send != "function" || typeof e.kick != "function") throw new n({ detail: "Reserved membership requires actual client callbacks" });
+		let o = Object.freeze({
+			...e,
+			send: e.send.bind(e),
+			kick: e.kick.bind(e)
+		});
+		return this.serializeLifecycle(async () => {
+			let e = i ? await i() ?? void 0 : void 0, t = this.prepareJoin(o, !1, !0, a.lastAppliedSeq);
+			await this.mutateMemberAsync((n) => this.descriptor.onJoin?.({
+				...t.context(n),
+				...e === void 0 ? {} : { world: e }
+			}), r, !0, void 0, i === void 0 ? void 0 : async () => {
+				await i();
+			}), t.commit();
+		});
+	}
+	joinWorldReservedAsync(t, r, i, a) {
+		let o = f(r), s = o.worldTarget;
+		if (!s || !this.descriptor.world || typeof i != "function" || typeof t?.send != "function" || typeof t.kick != "function") throw new n({ detail: "Pending World membership requires bound Seat and actual Host admission" });
+		let c = Object.freeze({
+			...t,
+			send: t.send.bind(t),
+			kick: t.kick.bind(t)
+		});
+		return this.serializeLifecycle(async () => {
+			if (a?.aborted) throw new n({ detail: "World membership admission aborted" });
+			let t = this.prepareJoin(c, !1, !0, o.lastAppliedSeq, s, o.discardedThrough ?? -1), r = await i();
+			if (a?.aborted) throw new n({ detail: "World membership admission aborted" });
+			let l = r === "settled" || r === "committed" && this.worldPublishedTransitions.has(s.transitionId);
+			if (!l && [...this.members.values()].filter((e) => e.worldPending).length >= (this.descriptor.world.maxPendingTransitions ?? 128)) throw new e({
+				budget: "worldPendingMembers",
+				limit: this.descriptor.world.maxPendingTransitions ?? 128
+			});
+			if (l && (this.assertWorldMemberEntity(s), !t.discardsPersisted)) throw new m();
+			t.commit();
+			let u = this.members.get(c.sessionId);
+			l && (u.worldPending = !1, await this.worldMemberEntered(u.client, s.entityId, a));
+		});
+	}
+	async worldMemberEntered(e, t, n) {
+		let r = this.descriptor.world?.onMemberEnter;
+		r && await this.mutateMemberAsync((n) => r({
+			state: n,
+			client: e,
+			entityId: t
+		}), n);
+	}
+	worldEntityPoint(e) {
+		let t = this.descriptor.world?.movement, n = Object.getOwnPropertyDescriptor(this.lastGoodState, "entities"), r = n && "value" in n ? n.value : void 0, i = t && typeof e == "string" && r && typeof r == "object" ? Object.getOwnPropertyDescriptor(r, e) : void 0;
+		if (!t || !i || !("value" in i)) return null;
+		try {
+			let e = t.position(c(i.value, t.maxBytesPerTick));
+			if (e instanceof Promise) return e.catch(() => void 0), null;
+			let n = c(e, 128);
+			return Array.isArray(n) && n.length === 2 && n.every((e) => typeof e == "number" && Number.isFinite(e)) ? Object.freeze([n[0], n[1]]) : null;
+		} catch {
+			return null;
+		}
+	}
+	activateWorldReservedAsync(e, t) {
+		let r = d(e);
+		if (typeof t != "function") throw new n({ detail: "World member activation requires actual Host authority" });
+		return this.serializeLifecycle(async () => {
+			this.ensureOpen();
+			let e = this.worldReceipts.get(`${r.transitionId}:enter`), i = Object.getOwnPropertyDescriptor(this.state, "entities"), a = i && "value" in i && i.value && typeof i.value == "object" ? Object.getOwnPropertyDescriptor(i.value, r.entityId) : void 0;
+			if (!this.descriptor.world || e?.operation !== "enter" || !a || !("value" in a) || a.value?.id !== r.entityId) throw new n({ detail: "World member activation lacks actual target enter" });
+			let o = [...this.members.values()].filter((e) => e.worldTarget?.transitionId === r.transitionId);
+			if (o.some((e) => JSON.stringify(e.worldTarget) !== JSON.stringify(r))) throw new n({ detail: "World member activation binding changed" });
+			if (await t(), o.some((e) => e.lastDiscardedSeq > e.checkpointedDiscardedSeq)) throw new n({ detail: "Pending World input discard must be checkpointed before activation" });
+			this.worldPublishedTransitions.add(r.transitionId);
+			for (let e of o) e.worldPending = !1;
+			for (let e of o) await this.worldMemberEntered(e.client, r.entityId);
+		});
+	}
+	assertWorldMemberEntity(e) {
+		let t = Object.getOwnPropertyDescriptor(this.state, "entities"), r = t && "value" in t && t.value && typeof t.value == "object" ? Object.getOwnPropertyDescriptor(t.value, e.entityId) : void 0;
+		if (!this.descriptor.world || !r || !("value" in r) || r.value?.id !== e.entityId) throw new n({ detail: "World reconnect lacks the actual owned target entity" });
+	}
+	isWorldPending(e) {
+		let t = this.members.get(e);
+		return t?.worldPending === !0 || t?.worldDeparture !== void 0;
+	}
+	joinBotAsync(e, t = !0, r) {
+		if (typeof t != "boolean") return Promise.reject(new n({ detail: "Bot capacity policy must be a boolean" }));
+		let i = Object.freeze({
+			sessionId: e.sessionId,
+			subjectId: e.subjectId,
+			tenantId: e.tenantId,
+			send: e.send.bind(e),
+			kick: e.kick.bind(e)
+		});
+		return this.serializeLifecycle(async () => {
+			let e = this.prepareJoin(i, !0, t);
+			await this.mutateMemberAsync((t) => this.descriptor.onJoin?.(e.context(t)), r), e.commit();
+			let n = this.members.get(i.sessionId);
+			return Object.freeze({
+				sessionId: i.sessionId,
+				isCurrent: () => this.members.get(i.sessionId) === n,
+				input: (e, t, r, a) => {
+					if (this.members.get(i.sessionId) !== n) throw new o({ roomId: this.id });
+					return this.input(i.sessionId, e, t, r, a);
+				},
+				leave: (e) => this.serializeLifecycle(async () => {
+					if (this.members.get(i.sessionId) !== n) return;
+					let t = this.prepareLeave(i.sessionId, "left");
+					await this.mutateMemberAsync((e) => this.descriptor.onLeave?.(t.context(e)), e), t.commit();
+				})
+			});
+		});
+	}
+	playerCount() {
+		return [...this.members.values()].filter((e) => e.client.countsAsPlayer !== !1).length;
+	}
+	availablePlayerSlots() {
+		return this.pruneGrace(this.now()), Math.max(0, this.descriptor.maxClients - this.playerCount() - this.grace.size);
+	}
+	monotonicNow() {
+		return this.now();
+	}
+	roster() {
+		return Object.freeze([...this.members.values()].map(({ client: e }) => Object.freeze({
+			sessionId: e.sessionId,
+			subjectId: e.subjectId,
+			tenantId: e.tenantId,
+			isBot: e.isBot === !0,
+			countsAsPlayer: e.countsAsPlayer !== !1
+		})));
+	}
+	humanAdmissionNeedsReplacement(e) {
+		let { resumed: t } = this.prepareClientIdentity(e, !1);
+		return this.playerCount() + this.grace.size - +!!t >= this.descriptor.maxClients;
+	}
+	prepareClientIdentity(e, t) {
+		if (this.ensureOpen(), !e || ![e.sessionId, e.tenantId].every((e) => typeof e == "string" && e.length > 0 && e.length <= 191) || e.subjectId !== null && (typeof e.subjectId != "string" || !e.subjectId || e.subjectId.length > 191)) throw new n({ detail: "Room membership requires bounded trusted identity" });
+		if (!t && (e.isBot === !0 || e.countsAsPlayer === !1)) throw new n({ detail: "Bot/NPC classification requires trusted local admission" });
+		if (e.tenantId !== this.tenantId || e.subjectId === null && this.descriptor.auth !== "public") throw new i({ roomId: this.id });
+		let a = this.now();
+		this.pruneGrace(a);
+		let o = this.grace.get(e.sessionId);
+		if (t && o) throw new n({ detail: "A local bot cannot resume a socket member grace seat" });
+		if (o && o.subjectId !== e.subjectId) throw new i({ roomId: this.id });
+		if (this.locked && !o) throw new s({ roomId: this.id });
+		if (this.members.has(e.sessionId)) throw new r({
+			room: this.descriptor.name,
+			detail: "A session is already connected"
+		});
+		return {
+			now: a,
+			resumed: o
+		};
+	}
+	prepareJoin(t, r = !1, i = !0, o = -1, s, c = -1) {
+		let { now: l, resumed: u } = this.prepareClientIdentity(t, r);
+		if (u?.worldDeparture) throw new n({ detail: "Departed World source membership awaits transfer compensation" });
+		if (u?.worldTarget && JSON.stringify(u.worldTarget) !== JSON.stringify(s)) throw new n({ detail: "World reconnect cannot discard its pending membership binding" });
+		if (i && this.playerCount() + this.grace.size - +!!u >= this.descriptor.maxClients) throw new a({ roomId: this.id });
+		if (!i && this.members.size - this.playerCount() >= this.descriptor.budgets.maxNpcs) throw new e({
+			budget: "maxNpcs",
+			limit: this.descriptor.budgets.maxNpcs
+		});
+		let d = Object.freeze({
+			sessionId: t.sessionId,
+			subjectId: t.subjectId,
+			tenantId: t.tenantId,
+			...r ? {
+				isBot: !0,
+				countsAsPlayer: i
+			} : {},
+			...t.attributes === void 0 ? {} : { attributes: Object.freeze({ ...t.attributes }) },
+			send: (e, r) => {
+				let i = this.descriptor.messages[e];
+				if (!i || i.direction === "client") throw new n({ detail: "Channel is not server-sendable" });
+				let a = structuredClone(x.decodeUnknownSync(i.schema)(r));
+				this.stageClientOperation(() => t.send(e, a));
+			},
+			kick: (e) => {
+				this.stageClientOperation(() => t.kick(e));
+			}
+		});
+		return {
+			discardsPersisted: (u?.discardedThrough ?? -1) <= c,
+			context: (e) => ({
+				state: e,
+				options: structuredClone(this.options),
+				client: d,
+				app: this.app,
+				clock: this.clock,
+				scheduler: this.scheduler,
+				...this.geometry ? { geometry: this.geometry } : {}
+			}),
+			commit: () => {
+				this.grace.delete(t.sessionId);
+				let e = Math.max(o, u?.lastAppliedSeq ?? -1);
+				this.members.set(t.sessionId, {
+					client: d,
+					lastSeq: Math.max(e, c, u?.discardedThrough ?? -1),
+					lastAppliedSeq: e,
+					lastDiscardedSeq: Math.max(c, u?.discardedThrough ?? -1),
+					checkpointedDiscardedSeq: c,
+					...s ? {
+						worldTarget: s,
+						worldPending: !0
+					} : {},
+					inputTokens: this.descriptor.budgets.burst,
+					byteTokens: this.descriptor.budgets.bytesPerSecond,
+					replenishedAt: l
+				}), this.emptyAt = null;
+			}
+		};
+	}
+	leave(e, t = "left") {
+		this.assertSynchronousLifecycle();
+		let n = this.prepareLeave(e, t);
+		n.pending || this.mutateMember(() => C(this.descriptor.name, this.descriptor.onLeave, n.context(this.state))), n.commit();
+	}
+	leaveAsync(e, n = "left", r) {
+		return this.serializeLifecycle(async () => {
+			if (this.worldFinalizationHold) {
+				if (!this.members.has(e)) throw new t({ sessionId: e });
+				this.deferredWorldLeaves.set(e, n);
+				return;
+			}
+			let i = this.prepareLeave(e, n);
+			i.pending || await this.mutateMemberAsync((e) => this.descriptor.onLeave?.(i.context(e)), r), i.commit();
+		}, () => this.worldFinalizationHold?.requestId);
+	}
+	prepareLeave(e, r) {
+		this.ensureOpen();
+		let i = this.members.get(e);
+		if (!i) throw new t({ sessionId: e });
+		if (i.client.isBot && r === "reconnecting") throw new n({ detail: "Local bots do not own socket reconnect grace" });
+		return {
+			pending: i.worldPending === !0,
+			context: (e) => ({
+				state: e,
+				options: structuredClone(this.options),
+				client: i.client,
+				app: this.app,
+				clock: this.clock,
+				scheduler: this.scheduler,
+				...this.geometry ? { geometry: this.geometry } : {},
+				reason: r
+			}),
+			commit: () => {
+				this.members.delete(e), r === "reconnecting" ? this.grace.set(e, {
+					subjectId: i.client.subjectId,
+					expiresAt: this.now() + this.descriptor.reconnect.graceMs,
+					lastAppliedSeq: i.lastAppliedSeq,
+					...i.worldDeparture ? { worldDeparture: i.worldDeparture } : {},
+					...i.worldTarget ? {
+						worldTarget: i.worldTarget,
+						discardedThrough: i.lastDiscardedSeq
+					} : {}
+				}) : this.grace.delete(e);
+				for (let t = this.inputs.length - 1; t >= 0; t--) this.inputs[t]?.client.sessionId === e && this.inputs.splice(t, 1);
+				this.members.size === 0 && (this.emptyAt = this.now());
+			}
+		};
+	}
+	assertWorldArrival(e) {
+		if (e !== void 0) {
+			if (!e || Object.keys(e).sort().join(",") !== "at,epoch,layer,roomId,worldId,zoneId" || e.roomId !== this.id || e.epoch !== this.epoch || ![
+				e.worldId,
+				e.zoneId,
+				e.roomId
+			].every((e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(e)) || !Number.isSafeInteger(e.layer) || e.layer < 1 || !Array.isArray(e.at) || e.at.length !== 2 || !e.at.every(Number.isFinite)) throw new n({ detail: "World arrival must name this actual target actor" });
+			this.worldMovement && this.worldMovement.constrain(e.at, e.at);
+		}
+	}
+	enterWorldDraft(e, t, r, i) {
+		let a = this.descriptor.world, o = t.arrival, s = () => {
+			if (!o || !a.movement) return;
+			this.assertWorldHookResult(e, "enter", t.entity.id);
+			let r = Object.getOwnPropertyDescriptor(e, "entities").value, s = Object.getOwnPropertyDescriptor(r, t.entity.id), l = structuredClone(s.value), u = a.movement.move(l, o.at);
+			if (u !== void 0) throw u instanceof Promise && u.catch(() => void 0), new n({ detail: "World arrival movement must return synchronous void" });
+			let d = c(l, i), f = a.movement.position(d);
+			if (f instanceof Promise) throw f.catch(() => void 0), new n({ detail: "World arrival position must be synchronous" });
+			if (d.id !== t.entity.id || g(c(f, 128)) !== g(o.at)) throw new n({ detail: "World arrival writer did not establish the admitted target position" });
+			r[t.entity.id] = l;
+		}, l = a.onEnter({
+			state: e,
+			phase: r,
+			entity: t.entity,
+			from: t.location,
+			...t.requestId === void 0 ? {} : { requestId: t.requestId },
+			...o ? { to: o } : {}
+		});
+		if (l === void 0) s();
+		else {
+			if (!y.isEffect(l)) throw l instanceof Promise && l.catch(() => void 0), new n({ detail: "World entry hooks require synchronous void or Effect" });
+			return l.pipe(y.flatMap((e) => e === void 0 ? y.sync(s) : y.fail(new n({ detail: "World entry Effect must produce void" }))));
+		}
+	}
+	previewWorldEnter(t, r, i) {
+		let a = c(t, r);
+		return a.epoch !== this.epoch || !Number.isSafeInteger(a.epoch) || a.epoch < 1 || typeof a.requestId != "string" || !a.requestId || a.requestId.length > 191 || !a.entity || typeof a.entity.id != "string" || !a.entity.id || a.entity.id.length > 191 || !a.location || Object.keys(a.location).length !== 6 || !Array.isArray(a.location.at) || a.location.at.length !== 2 || !a.location.at.every((e) => typeof e == "number" && Number.isFinite(e)) || ![
+			a.location.worldId,
+			a.location.zoneId,
+			a.location.roomId
+		].every((e) => typeof e == "string" && e.length > 0 && e.length <= 191) || ![a.location.epoch, a.location.layer].every((e) => Number.isSafeInteger(e) && e > 0) ? Promise.reject(new n({ detail: "World preview requires the actual actor epoch and bounded request/entity/location" })) : this.serializeLifecycle(async () => {
+			this.ensureOpen();
+			let t = this.descriptor.world;
+			if (!t) throw new n({ detail: "World preview requires configured actor hooks" });
+			if (this.assertWorldArrival(a.arrival), this.assertWorldEnterVacant(a.entity.id), !this.worldPreviews.has(a.requestId) && this.worldPreviews.size + this.worldReceipts.size >= (t.maxPendingTransitions ?? 128)) throw new e({
+				budget: "worldActorReceipts",
+				limit: t.maxPendingTransitions ?? 128
+			});
+			await this.mutateMemberAsync((e) => this.enterWorldDraft(e, a, "prepare", r), i, !1, (e) => this.assertWorldHookResult(e, "enter", a.entity.id)), this.worldPreviews.add(a.requestId);
+		});
+	}
+	applyWorldHook(t, r, i, a, o, s = !1, l, u = !1, d) {
+		let f = c(r, i), p = l === void 0 ? void 0 : c(l, i), m = d === void 0 ? [] : c(d, 1048576);
+		if (!Array.isArray(m) || m.length > 4096 || m.length > 0 && (t !== "enter" || !o)) return Promise.reject(new n({ detail: "World promotion requires bounded guarded target entry" }));
+		let v = f.location;
+		return ![
+			"enter",
+			"exit",
+			"ghost"
+		].includes(t) || f.epoch !== this.epoch || !Number.isSafeInteger(f.epoch) || f.epoch < 1 || !f.entity || typeof f.entity.id != "string" || !f.entity.id || f.entity.id.length > 191 || f.requestId !== void 0 && (typeof f.requestId != "string" || !f.requestId || f.requestId.length > 191) || !v || Object.keys(v).length !== 6 || ![
+			v.worldId,
+			v.zoneId,
+			v.roomId
+		].every((e) => typeof e == "string" && e.length > 0 && e.length <= 191) || ![v.epoch, v.layer].every((e) => Number.isSafeInteger(e) && e > 0) || !Array.isArray(v.at) || v.at.length !== 2 || !v.at.every((e) => typeof e == "number" && Number.isFinite(e)) ? Promise.reject(new n({ detail: "World hook lost its actual actor epoch or entity identity" })) : this.serializeLifecycle(async () => {
+			this.ensureOpen();
+			let r = this.descriptor.world;
+			if (!r) throw new n({ detail: "Room has no configured World lifecycle hooks" });
+			if (f.arrival && (t !== "enter" || s || !o)) throw new n({ detail: "World arrival belongs only to guarded target entry" });
+			if (this.assertWorldArrival(f.arrival), u && (t !== "ghost" || !o || !/^wghost-[0-9a-f]{64}:ghost$/.test(f.requestId ?? ""))) throw new n({ detail: "Retained ghost projection requires guarded streaming identity" });
+			let l = f.requestId === void 0 ? void 0 : await _({
+				roomId: this.id,
+				tenantId: this.tenantId,
+				operation: t,
+				entity: f.entity,
+				location: f.location,
+				...f.arrival ? { arrival: f.arrival } : {}
+			}), d, v;
+			if (s) {
+				if (t !== "enter" || !f.requestId?.endsWith(":enter") || !o) throw new n({ detail: "World compensation requires guarded canonical enter receipt" });
+				d = `${f.requestId.slice(0, -6)}:exit`;
+				let e = this.worldReceipts.get(d);
+				if (e && (e.operation !== "exit" || e.fingerprint !== await _({
+					roomId: this.id,
+					tenantId: this.tenantId,
+					operation: "exit",
+					entity: f.entity,
+					location: f.location
+				}))) throw new n({ detail: "World compensation conflicts with captured source exit" });
+				if (!e && !this.worldReceipts.has(f.requestId)) throw new n({ detail: "World compensation requires its retained exit receipt" });
+			}
+			if (p !== void 0) {
+				if (t !== "ghost" || s || !o || !f.requestId?.endsWith(":ghost") || p.epoch !== this.epoch || !p.requestId?.endsWith(":ghost") || p.requestId === f.requestId || p.entity?.id !== f.entity.id) throw new n({ detail: "Ghost replacement requires exact prior projection and current authority" });
+				v = p.requestId;
+				let e = this.worldReceipts.get(v);
+				if (e && (e.operation !== "ghost" || e.fingerprint !== await _({
+					roomId: this.id,
+					tenantId: this.tenantId,
+					operation: "ghost",
+					entity: p.entity,
+					location: p.location
+				}))) throw new n({ detail: "Ghost replacement differs from its retained predecessor" });
+				if (!e && !this.worldReceipts.has(f.requestId)) throw new n({ detail: "Ghost replacement predecessor is absent" });
+				if (e && this.worldReceipts.has(f.requestId)) throw new n({ detail: "Ghost replacement has contradictory receipts" });
+			}
+			let b = /* @__PURE__ */ new Set();
+			for (let e of m) {
+				let t = c(e, i);
+				if (t.epoch !== this.epoch || t.entity?.id !== f.entity.id || !t.requestId?.endsWith(":ghost") || b.has(t.requestId)) throw new n({ detail: "World promotion escaped its exact target entity" });
+				let r = this.worldReceipts.get(t.requestId);
+				if (!r) {
+					if (f.requestId && this.worldReceipts.get(f.requestId)?.operation === "enter") continue;
+					throw new n({ detail: "World promotion requires its retained ghost receipt" });
+				}
+				if (r.operation !== "ghost" || r.fingerprint !== await _({
+					roomId: this.id,
+					tenantId: this.tenantId,
+					operation: "ghost",
+					entity: t.entity,
+					location: t.location
+				})) throw new n({ detail: "World promotion differs from its retained projection" });
+				b.add(t.requestId);
+			}
+			if (f.requestId !== void 0) {
+				let i = this.worldReceipts.get(f.requestId);
+				if (i) {
+					if (i.operation !== t || i.fingerprint !== l) throw new n({ detail: "World actor request conflicts with its retained receipt" });
+					if (u && !i.projection) {
+						let e = {
+							...i,
+							projection: {
+								entity: f.entity,
+								location: f.location
+							}
+						};
+						h([...this.worldReceipts.values()].filter((e) => e.requestId !== i.requestId).concat(e)), await o(), this.worldReceipts.set(i.requestId, Object.freeze(e));
+					}
+					return;
+				}
+				if (this.worldReceipts.size + this.worldPreviews.size - b.size - (t === "enter" && this.worldPreviews.has(f.requestId) ? 1 : 0) >= (r.maxPendingTransitions ?? 128) && !(d && this.worldReceipts.has(d)) && !(v && this.worldReceipts.has(v))) throw new e({
+					budget: "worldActorReceipts",
+					limit: r.maxPendingTransitions ?? 128
+				});
+			}
+			let x = f.requestId === void 0 ? void 0 : Object.freeze({
+				requestId: f.requestId,
+				operation: t,
+				fingerprint: l,
+				...u ? { projection: {
+					entity: f.entity,
+					location: f.location
+				} } : {}
+			});
+			if (x && h([...this.worldReceipts.values()].filter((e) => e.requestId !== d && e.requestId !== v && !b.has(e.requestId)).concat(x)), t === "enter" && this.assertWorldEnterVacant(f.entity.id), t === "exit") {
+				let e = Object.getOwnPropertyDescriptor(this.state, "entities"), t = e && "value" in e && e.value && typeof e.value == "object" ? Object.getOwnPropertyDescriptor(e.value, f.entity.id) : void 0;
+				if (!t || !("value" in t) || await _(c(t.value, i)) !== await _(f.entity)) throw new n({ detail: "World source entity changed since transition capture" });
+			}
+			await this.mutateMemberAsync((e) => {
+				let a = {
+					state: e,
+					phase: s ? "rollback" : "commit",
+					entity: f.entity,
+					...f.requestId === void 0 ? {} : { requestId: f.requestId }
+				};
+				if (t === "enter" && b.size > 0) {
+					let t = this, a = (e) => y.suspend(() => {
+						let t = e();
+						if (t === void 0) return y.void;
+						if (!y.isEffect(t)) throw t instanceof Promise && t.catch(() => void 0), new n({ detail: "World promotion hooks require synchronous void or Effect" });
+						return t.pipe(y.flatMap((e) => e === void 0 ? y.void : y.fail(new n({ detail: "World promotion Effects must produce void" }))));
+					});
+					return y.gen(function* () {
+						for (let n of m) b.has(n.requestId) && (yield* a(() => r.onGhost({
+							state: e,
+							phase: "rollback",
+							entity: n.entity,
+							requestId: n.requestId
+						})), t.assertWorldHookResult(e, "ghost", f.entity.id));
+						yield* a(() => t.enterWorldDraft(e, f, s ? "rollback" : "commit", i));
+					});
+				}
+				return t === "enter" ? this.enterWorldDraft(e, f, s ? "rollback" : "commit", i) : t === "exit" ? r.onExit({
+					...a,
+					to: f.location
+				}) : r.onGhost(a);
+			}, a, !0, (e) => {
+				if (this.assertWorldHookResult(e, t, f.entity.id), s) {
+					let t = Object.getOwnPropertyDescriptor(e, "entities"), r = Object.getOwnPropertyDescriptor(t.value, f.entity.id);
+					if (g(c(r.value, i)) !== g(f.entity)) throw new n({ detail: "World rollback hook must restore the exact captured source entity" });
+				}
+			}, o);
+			for (let e of b) this.worldReceipts.delete(e);
+			if (d) {
+				this.worldReceipts.delete(d);
+				for (let e of this.members.values()) e.worldDeparture === d && (delete e.worldDeparture, e.lastSeq = Math.max(e.lastAppliedSeq, e.lastDiscardedSeq));
+				for (let [e, t] of this.grace) if (t.worldDeparture === d) {
+					let { worldDeparture: n, ...r } = t;
+					this.grace.set(e, r);
+				}
+			}
+			v && this.worldReceipts.delete(v), x && this.worldReceipts.set(x.requestId, x), t === "enter" && f.requestId !== void 0 && this.worldPreviews.delete(f.requestId);
+		}, s && f.requestId?.endsWith(":enter") ? `${f.requestId.slice(0, -6)}:exit` : t === "exit" && o ? f.requestId : void 0);
+	}
+	assertWorldHookResult(e, t, r) {
+		let i = Object.getOwnPropertyDescriptor(e, "entities"), a = i && "value" in i && i.value && typeof i.value == "object" ? Object.getOwnPropertyDescriptor(i.value, r) : void 0;
+		if (t === "ghost") {
+			let e = Object.getOwnPropertyDescriptor(this.state, "entities"), t = e && "value" in e && e.value && typeof e.value == "object" ? Object.getOwnPropertyDescriptor(e.value, r) : void 0;
+			if (g(t && "value" in t ? t.value : null) !== g(a && "value" in a ? a.value : null)) throw new n({ detail: "World ghost hook cannot change authoritative entity ownership or state" });
+		} else if (t === "exit" ? a !== void 0 : !a || !("value" in a) || a.value?.id !== r) throw new n({ detail: "World hook did not establish its declared entity ownership result" });
+	}
+	assertWorldEnterVacant(e) {
+		let t = Object.getOwnPropertyDescriptor(this.state, "entities");
+		if (!t || !("value" in t) || !t.value || typeof t.value != "object" || Object.hasOwn(t.value, e)) throw new n({ detail: "World target entity slot is unavailable" });
+	}
+	retireWorldReceipt(e, t) {
+		return this.serializeLifecycle(async () => {
+			this.ensureOpen();
+			let r = this.worldReceipts.get(e);
+			if (r) {
+				if (r.operation !== t) throw new n({ detail: "World receipt retirement operation conflicts" });
+				this.worldReceipts.delete(e), t === "enter" && e.endsWith(":enter") && this.worldPublishedTransitions.delete(e.slice(0, -6));
+			}
+		});
+	}
+	cancelWorldGhost(e, t, r) {
+		let i = c(e, t);
+		return i.epoch !== this.epoch || !i.requestId?.endsWith(":ghost") || typeof r != "function" ? Promise.reject(new n({ detail: "World ghost rollback requires its exact actor request" })) : this.serializeLifecycle(async () => {
+			this.ensureOpen(), await r();
+			let e = this.worldReceipts.get(i.requestId);
+			if (!e) return;
+			let t = this.descriptor.world;
+			if (!t || e.operation !== "ghost" || e.fingerprint !== await _({
+				roomId: this.id,
+				tenantId: this.tenantId,
+				operation: "ghost",
+				entity: i.entity,
+				location: i.location
+			})) throw new n({ detail: "World ghost rollback differs from its retained projection" });
+			await this.mutateMemberAsync((e) => t.onGhost({
+				state: e,
+				phase: "rollback",
+				entity: i.entity,
+				requestId: i.requestId
+			}), void 0, !0, (e) => this.assertWorldHookResult(e, "ghost", i.entity.id), r), this.worldReceipts.delete(i.requestId);
+		});
+	}
+	cancelWorldPreview(e, t) {
+		return typeof e != "string" || !e || e.length > 191 || typeof t != "function" ? Promise.reject(new n({ detail: "World preview cancellation requires a bounded request and actual authority" })) : this.serializeLifecycle(async () => {
+			this.ensureOpen(), await t(), this.worldPreviews.delete(e);
+		});
+	}
+	hasWorldReceipt(e, t) {
+		if (this.ticking || this.isLifecycleBusy()) throw new r({
+			room: this.id,
+			detail: "World receipts are observed outside actor lifecycle work"
+		});
+		let i = this.worldReceipts.get(e);
+		if (i && i.operation !== t) throw new n({ detail: "World receipt operation conflicts" });
+		return i !== void 0;
+	}
+	worldReceiptSnapshot() {
+		if (this.ticking || this.isLifecycleBusy()) throw new r({
+			room: this.id,
+			detail: "World receipts are captured outside actor lifecycle work"
+		});
+		return h([...this.worldReceipts.values()].sort((e, t) => e.requestId.localeCompare(t.requestId)), this.descriptor.world?.maxPendingTransitions ?? 128);
+	}
+	captureWorldEntity(e, t, n) {
+		return this.serializeLifecycle(async () => this.captureWorldEntityOwned(e, t, n), this.worldFinalizationHold?.requestId);
+	}
+	configureWorldCellMovement(e, t, r = 0) {
+		if (!Number.isFinite(r) || r < 0) throw new n({ detail: "World movement margin must be finite and nonnegative" });
+		let i = t === void 0 ? void 0 : u(t);
+		return this.serializeLifecycle(async () => {
+			if (this.ensureOpen(), e !== this.epoch || !this.descriptor.world?.movement) throw new n({ detail: "World movement binding lost its configured actor epoch" });
+			this.worldMovement = i, this.worldMovementMargin = r, this.worldMovementIntents = Object.freeze([]);
+		});
+	}
+	worldMovementSnapshot() {
+		return Object.freeze({
+			bound: this.worldMovement !== void 0,
+			clamped: this.worldMovementClamps
+		});
+	}
+	captureWorldMovement(e) {
+		return this.serializeLifecycle(async () => {
+			this.ensureOpen();
+			let t = this.descriptor.world?.movement;
+			if (!t || !this.worldMovement || e !== this.epoch || this.faulted || this.worldFinalizationHold) throw new n({ detail: "World movement observation requires its live bounded actor" });
+			let r = [], i = t.maxBytesPerTick;
+			for (let e of this.worldMovementIntents) {
+				let a = Object.getOwnPropertyDescriptor(this.state, "entities"), o = a && "value" in a ? a.value : void 0, s = o && typeof o == "object" ? Object.getOwnPropertyDescriptor(o, e.entityId) : void 0;
+				if (!s || !("value" in s)) continue;
+				let l = c(s.value, i);
+				i -= new TextEncoder().encode(JSON.stringify(l)).length;
+				let u = t.position(l);
+				if (u instanceof Promise) throw u.catch(() => void 0), new n({ detail: "World movement observation must be synchronous" });
+				l.id === e.entityId && g(c(u, 128)) === g(e.sourceAt) && r.push(e);
+			}
+			return Object.freeze({
+				epoch: e,
+				tick: this.lastGoodTick,
+				intents: Object.freeze(r)
+			});
+		});
+	}
+	constrainWorldMovement() {
+		let t = this.descriptor.world?.movement;
+		if (!t) return {
+			clamped: 0,
+			intents: Object.freeze([])
+		};
+		let r = this.worldMovement;
+		if (!r) throw new n({ detail: "World movement requires acquired source cell bounds" });
+		let i = t.maxBytesPerTick, a = 0, o = 0, s = [], l = (e) => {
+			let t = c(e, i);
+			return i -= new TextEncoder().encode(JSON.stringify(t)).length, t;
+		}, u = (e) => {
+			let r = t.position(e);
+			if (r instanceof Promise) throw r.catch(() => void 0), new n({ detail: "World movement position must be synchronous" });
+			return c(r, 128);
+		}, d = Object.getOwnPropertyDescriptor(this.state, "entities"), f = Object.getOwnPropertyDescriptor(this.lastGoodState, "entities"), p = d && "value" in d ? d.value : void 0, m = f && "value" in f ? f.value : void 0;
+		if (!p || typeof p != "object" || Array.isArray(p) || ![null, Object.prototype].includes(Object.getPrototypeOf(p)) || !m || typeof m != "object" || Array.isArray(m)) throw new n({ detail: "World movement requires actual entity records" });
+		for (let i in p) if (Object.hasOwn(p, i)) {
+			if (++a > t.maxEntities) throw new e({
+				budget: "worldMovementEntities",
+				limit: t.maxEntities
+			});
+			let c = Object.getOwnPropertyDescriptor(p, i), d = Object.getOwnPropertyDescriptor(m, i);
+			if (!c || !("value" in c)) throw new n({ detail: "World movement requires own entity data" });
+			let f = l(c.value);
+			if (f.id !== i) throw new n({ detail: "World movement entity differs from its state key" });
+			let h = u(f), _ = d && "value" in d ? u(l(d.value)) : h, v = r.constrain(_, h), y = r.approach(_, h, this.worldMovementMargin);
+			if (y && s.push(Object.freeze({
+				entityId: i,
+				...y
+			})), !v.clamped) continue;
+			let b = t.move(c.value, v.at);
+			if (b !== void 0) throw b instanceof Promise && b.catch(() => void 0), new n({ detail: "World movement write must return synchronous void" });
+			let x = l(c.value), S = u(x);
+			if (x.id !== i || g(S) !== g(v.at)) throw new n({ detail: "World movement writer did not establish its constrained position" });
+			o++;
+		}
+		if (this.worldMovementClamps > 2 ** 53 - 1 - o) throw new e({
+			budget: "worldMovementClamps",
+			limit: 2 ** 53 - 1
+		});
+		return {
+			clamped: o,
+			intents: Object.freeze(s)
+		};
+	}
+	listWorldEntityIds(t, r, i) {
+		return !Number.isSafeInteger(r) || r < 1 || r > 4095 || !Number.isSafeInteger(i) || i < 1 || i > 1048576 ? Promise.reject(new n({ detail: "World entity inventory requires a bounded count" })) : this.serializeLifecycle(async () => {
+			if (this.ensureOpen(), !this.descriptor.world || t !== this.epoch) throw new n({ detail: "World inventory lost its actor epoch" });
+			let a = Object.getOwnPropertyDescriptor(this.state, "entities"), o = a && "value" in a ? a.value : void 0;
+			if (!o || typeof o != "object" || Array.isArray(o) || ![null, Object.prototype].includes(Object.getPrototypeOf(o))) throw new n({ detail: "World inventory requires its actual entity record" });
+			let s = [];
+			for (let t in o) if (Object.hasOwn(o, t)) {
+				if (s.length >= r) throw new e({
+					budget: "worldGhostEntities",
+					limit: r
+				});
+				let i = Object.getOwnPropertyDescriptor(o, t), a = i && "value" in i ? i.value : void 0, c = a && typeof a == "object" ? Object.getOwnPropertyDescriptor(a, "id") : void 0;
+				if (!t || t.length > 191 || !c || !("value" in c) || c.value !== t) throw new n({ detail: "World inventory entity identity contradicts its state key" });
+				s.push(t);
+			}
+			return s.sort((e, t) => e < t ? -1 : +(e > t)), c(s, i);
+		});
+	}
+	captureWorldProjection(e, t, n) {
+		return this.serializeLifecycle(async () => Object.freeze({
+			...this.captureWorldEntityOwned(e, t, n),
+			tick: this.tick
+		}));
+	}
+	captureWorldEntityOwned(e, t, r) {
+		this.ensureOpen();
+		let i = this.descriptor.world;
+		if (!i || t !== this.epoch || typeof e != "string" || !e || e.length > 191) throw new n({ detail: "World capture requires current configured actor authority" });
+		let a = Object.getOwnPropertyDescriptor(this.state, "entities"), o = a && "value" in a && a.value && typeof a.value == "object" ? Object.getOwnPropertyDescriptor(a.value, e) : void 0;
+		if (!o || !("value" in o)) throw new n({ detail: "World entity is absent from the actual actor state" });
+		let s = c(o.value, r);
+		if (!s || s.id !== e) throw new n({ detail: "World actor entity identity contradicts its state key" });
+		let l = i.persistEntity({ entity: s });
+		if (l instanceof Promise) throw l.catch(() => void 0), new n({ detail: "World entity persistence projection must be synchronous" });
+		return Object.freeze({
+			entity: s,
+			data: c(l, r)
+		});
+	}
+	finalizeWorldExit(t, r, i, a, o, s) {
+		let l = c(t, r);
+		if (!l || l.epoch !== this.epoch || !l.requestId?.endsWith(":exit") || l.requestId.length > 191 || !l.location || Object.keys(l.location).length !== 6 || ![
+			l.location.worldId,
+			l.location.zoneId,
+			l.location.roomId
+		].every((e) => typeof e == "string" && e.length > 0 && e.length <= 191) || ![l.location.epoch, l.location.layer].every((e) => Number.isSafeInteger(e) && e > 0) || !Array.isArray(l.location.at) || l.location.at.length !== 2 || !l.location.at.every(Number.isFinite) || l.subjectId !== void 0 && (typeof l.subjectId != "string" || !l.subjectId || l.subjectId.length > 191) || l.afterglow !== void 0 && (!l.afterglow || Object.keys(l.afterglow).sort().join(",") !== "expiresAt,requestId" || !/^wghost-[0-9a-f]{64}:ghost$/.test(l.afterglow.requestId) || !Number.isSafeInteger(l.afterglow.expiresAt) || l.afterglow.expiresAt < 0) || typeof i != "function" || typeof a != "function") return Promise.reject(new n({ detail: "World finalization requires canonical exit and actual durable callbacks" }));
+		let u = o === void 0 ? void 0 : c(o, r);
+		return this.serializeLifecycle(async () => {
+			this.ensureOpen();
+			let t = this.captureWorldEntityOwned(l.entityId, l.epoch, r), o = this.worldFinalizationHold;
+			if (o && (g(o.afterglow ?? null) !== g(l.afterglow ?? null) || o.subjectId !== l.subjectId || o.entityId !== l.entityId || g(o.location) !== g(l.location) || g(o.entity) !== g(t.entity))) throw new n({ detail: "World finalization retry conflicts with retained source capture" });
+			if (u !== void 0 && g(u) !== g(t.entity)) throw new n({ detail: "World finalization requires exact retained final source entity" });
+			if (this.worldReceipts.has(l.requestId)) throw new n({ detail: "World finalization already has an exit receipt; replay its retained payload" });
+			if (this.worldReceipts.size + this.worldPreviews.size + +!!l.afterglow >= (this.descriptor.world.maxPendingTransitions ?? 128)) throw new e({
+				budget: "worldActorReceipts",
+				limit: this.descriptor.world.maxPendingTransitions ?? 128
+			});
+			let c = o ?? Object.freeze({
+				...t,
+				requestId: l.requestId,
+				entityId: l.entityId,
+				location: l.location,
+				...l.afterglow ? { afterglow: l.afterglow } : {},
+				...l.subjectId === void 0 ? {} : { subjectId: l.subjectId },
+				heldAt: this.now()
+			});
+			this.worldFinalizationHold = c;
+			let d = await _({
+				roomId: this.id,
+				tenantId: this.tenantId,
+				operation: "exit",
+				entity: c.entity,
+				location: l.location
+			}), f = c.afterglow ? Object.freeze({
+				requestId: c.afterglow.requestId,
+				operation: "ghost",
+				fingerprint: await _({
+					roomId: this.id,
+					tenantId: this.tenantId,
+					operation: "ghost",
+					entity: c.entity,
+					location: l.location
+				}),
+				projection: {
+					entity: c.entity,
+					location: l.location,
+					expiresAt: c.afterglow.expiresAt
+				}
+			}) : void 0;
+			if (f && this.worldReceipts.has(f.requestId)) throw new n({ detail: "Source afterglow conflicts with a retained projection" });
+			if (h([
+				...this.worldReceipts.values(),
+				{
+					requestId: l.requestId,
+					operation: "exit",
+					fingerprint: d
+				},
+				...f ? [f] : []
+			]), await this.mutateMemberAsync((e) => {
+				let t = this.descriptor.world, r = () => t.onExit({
+					state: e,
+					phase: "commit",
+					entity: c.entity,
+					to: l.location,
+					requestId: l.requestId
+				});
+				return f ? y.gen(function* () {
+					for (let i of [r, () => t.onGhost({
+						state: e,
+						phase: "commit",
+						entity: c.entity,
+						requestId: f.requestId
+					})]) {
+						let e = i();
+						if (e !== void 0) {
+							if (!y.isEffect(e)) throw e instanceof Promise && e.catch(() => void 0), new n({ detail: "Source afterglow requires synchronous void or Effect hooks" });
+							if ((yield* e) !== void 0) throw new n({ detail: "Source afterglow Effects must produce void" });
+						}
+					}
+				}) : r();
+			}, s, !0, (e) => this.assertWorldHookResult(e, "exit", l.entityId), async () => {
+				await a(), await i(Object.freeze({
+					entity: c.entity,
+					data: c.data
+				})), await a();
+			}), f && this.worldReceipts.set(f.requestId, f), this.worldReceipts.set(l.requestId, Object.freeze({
+				requestId: l.requestId,
+				operation: "exit",
+				fingerprint: d
+			})), l.subjectId !== void 0) {
+				for (let e of this.members.values()) e.client.subjectId === l.subjectId && (e.worldDeparture = l.requestId);
+				for (let [e, t] of this.grace) t.subjectId === l.subjectId && this.grace.set(e, {
+					...t,
+					worldDeparture: l.requestId
+				});
+				for (let e = this.inputs.length - 1; e >= 0; e--) this.inputs[e].client.subjectId === l.subjectId && this.inputs.splice(e, 1);
+			}
+		}, l.requestId);
+	}
+	notifyWorldHandoff(e, t, r) {
+		let i = c(e, 2048), a = l({
+			...i,
+			tick: 0
+		});
+		return b.isFailure(a) || i.kind !== "WorldHandoff" || typeof t != "function" || typeof r != "function" ? Promise.reject(new n({ detail: "World notice requires canonical metadata and actual authority" })) : this.serializeLifecycle(async () => {
+			if (this.ensureOpen(), !this.descriptor.world || i.sourceEpoch !== this.epoch) throw new n({ detail: "World notice lost its source epoch" });
+			let e = i.phase === "departed" ? "exit" : "enter", a = this.worldReceipts.get(`${i.transitionId}:${e}`);
+			if (!a || a.operation !== e) throw new n({ detail: "World notice requires its actual actor receipt" });
+			this.assertWorldHookResult(this.state, e, i.entityId), await t(), r(Object.freeze({
+				...i,
+				tick: this.tick
+			}));
+		}, `${i.transitionId}:exit`);
+	}
+	completeWorldFinalization(e, t) {
+		return this.serializeLifecycle(async () => {
+			if (!this.worldFinalizationHold) return;
+			if (typeof t != "function") throw new n({ detail: "World completion requires actual durable authority" });
+			await t();
+			for (let [e, t] of this.deferredWorldLeaves) {
+				let n = this.prepareLeave(e, t);
+				n.pending || await this.mutateMemberAsync((e) => this.descriptor.onLeave?.(n.context(e))), n.commit(), this.deferredWorldLeaves.delete(e);
+			}
+			let e = this.now() - this.worldFinalizationHold.heldAt;
+			this.nextTickAt += e, this.emptyAt !== null && this.emptyAt <= this.worldFinalizationHold.heldAt && (this.emptyAt += e);
+			for (let t of this.schedules.values()) t.at += e;
+			this.worldFinalizationHold = null;
+		}, e);
+	}
+	worldFinalizationAfterglow() {
+		return this.worldFinalizationHold?.afterglow;
+	}
+	worldFinalizationRequest() {
+		return this.worldFinalizationHold?.requestId ?? null;
+	}
+	isWorldFinalizationHeld() {
+		return this.worldFinalizationHold !== null;
+	}
+	reconcileWorldSource(t, r, i, a) {
+		let o = c(t, r);
+		return !o || o.epoch !== this.epoch || !o.requestId?.endsWith(":enter") || o.requestId.length > 191 || !o.entity || typeof o.entity.id != "string" || !o.entity.id || o.entity.id.length > 191 || !o.location || Object.keys(o.location).length !== 6 || ![
+			o.location.worldId,
+			o.location.zoneId,
+			o.location.roomId
+		].every((e) => typeof e == "string" && e.length > 0 && e.length <= 191) || ![o.location.epoch, o.location.layer].every((e) => Number.isSafeInteger(e) && e > 0) || !Array.isArray(o.location.at) || o.location.at.length !== 2 || !o.location.at.every(Number.isFinite) || typeof i != "function" ? Promise.reject(new n({ detail: "World source recovery requires canonical current authority" })) : this.serializeLifecycle(async () => {
+			if (this.ensureOpen(), !this.descriptor.world || this.publicationHeldAt === null && !this.worldFinalizationHold) throw new n({ detail: "World source recovery requires unpublished or held configured actor" });
+			if (this.publicationHeldAt === null && g(this.captureWorldEntityOwned(o.entity.id, o.epoch, r).entity) !== g(o.entity)) throw new n({ detail: "Live World compensation cannot replace divergent source state" });
+			let t = await _({
+				roomId: this.id,
+				tenantId: this.tenantId,
+				operation: "enter",
+				entity: o.entity,
+				location: o.location
+			}), s = this.worldReceipts.get(o.requestId);
+			if (s) {
+				if (s.operation !== "enter" || s.fingerprint !== t) throw new n({ detail: "World recovery conflicts with retained receipt" });
+				await i();
+			} else {
+				if (this.worldReceipts.size + this.worldPreviews.size >= (this.descriptor.world.maxPendingTransitions ?? 128)) throw new e({
+					budget: "worldActorReceipts",
+					limit: this.descriptor.world.maxPendingTransitions ?? 128
+				});
+				await this.mutateMemberAsync((e) => {
+					let t = Object.getOwnPropertyDescriptor(e, "entities");
+					if (!t || !("value" in t) || !t.value || typeof t.value != "object") throw new n({ detail: "World recovery requires actual entity state" });
+					return delete t.value[o.entity.id], this.descriptor.world.onEnter({
+						state: e,
+						phase: "rollback",
+						entity: o.entity,
+						from: o.location,
+						requestId: o.requestId
+					});
+				}, a, !0, (e) => {
+					this.assertWorldHookResult(e, "enter", o.entity.id);
+					let t = Object.getOwnPropertyDescriptor(e, "entities");
+					if (g(c(t.value[o.entity.id], r)) !== g(o.entity)) throw new n({ detail: "World recovery must restore exact final source entity" });
+				}, i), this.worldReceipts.set(o.requestId, Object.freeze({
+					requestId: o.requestId,
+					operation: "enter",
+					fingerprint: t
+				}));
+			}
+		}, `${o.requestId.slice(0, -6)}:exit`);
+	}
+	assertSynchronousLifecycle() {
+		if (this.isLifecycleBusy() || this.worldFinalizationHold) throw new r({
+			room: this.descriptor.name,
+			detail: "A synchronous lifecycle call cannot overlap queued Effect hooks"
+		});
+	}
+	serializeLifecycle(t, i) {
+		if (this.ticking) return Promise.reject(new r({
+			room: this.descriptor.name,
+			detail: "Lifecycle work must run outside the tick"
+		}));
+		if (this.lifecycleRequests >= this.descriptor.budgets.maxQueuedLifecycleHooks) return Promise.reject(new e({
+			budget: "maxQueuedLifecycleHooks",
+			limit: this.descriptor.budgets.maxQueuedLifecycleHooks
+		}));
+		this.lifecycleRequests++;
+		let a = this.lifecycleTail.then(async () => {
+			this.lifecycleActive = !0;
+			try {
+				if (this.worldFinalizationHold && this.worldFinalizationHold.requestId !== (typeof i == "function" ? i() : i)) throw new n({ detail: "World finalization holds actor lifecycle until durable completion" });
+				return await t();
+			} finally {
+				this.lifecycleActive = !1, this.lifecycleRequests--;
+			}
+		});
+		return this.lifecycleTail = a.then(() => void 0, () => void 0), a;
+	}
+	async mutateMemberAsync(e, t, n = !0, i, a) {
+		let o = structuredClone(this.state), s = this.outbox.length, c = this.clientOperations.length, l = [...this.schedules].map(([e, t]) => [e, { ...t }]), u = () => {
+			this.outbox.splice(s), this.clientOperations.splice(c), this.schedules.clear();
+			for (let [e, t] of l) this.schedules.set(e, t);
+		};
+		try {
+			if (t?.aborted) throw new r({
+				room: this.descriptor.name,
+				detail: "Lifecycle operation was cancelled"
+			});
+			let s = e(o);
+			if (s !== void 0) {
+				if (!y.isEffect(s)) throw s instanceof Promise && s.catch(() => void 0), new r({
+					room: this.descriptor.name,
+					detail: "Lifecycle hooks must return undefined or Effect, never Promise"
+				});
+				let e = s.pipe(y.timeout(this.descriptor.lifecycleTimeoutMs)), n = await y.runPromise(y.result(e), { signal: t });
+				if (b.isFailure(n)) throw n.failure;
+				if (n.success !== void 0) throw new r({
+					room: this.descriptor.name,
+					detail: "Lifecycle Effects must produce void"
+				});
+			}
+			if (t?.aborted) throw new r({
+				room: this.descriptor.name,
+				detail: "Lifecycle operation was cancelled"
+			});
+			if (x.decodeUnknownSync(x.toType(this.descriptor.state))(o), i?.(o), !n) {
+				u();
+				return;
+			}
+			let c = structuredClone(o);
+			if (a && await a(), t?.aborted) throw new r({
+				room: this.descriptor.name,
+				detail: "Lifecycle operation was cancelled"
+			});
+			this.currentState = c, this.lastGoodState = structuredClone(c);
+		} catch (e) {
+			throw u(), e;
+		}
+	}
+	pruneGrace(e) {
+		for (let [t, n] of this.grace) n.expiresAt <= e && this.grace.delete(t);
+	}
+	mutateMember(e) {
+		if (this.ticking) throw new r({
+			room: this.descriptor.name,
+			detail: "Membership hooks must run outside the tick"
+		});
+		let t = structuredClone(this.state), n = this.outbox.length, i = this.clientOperations.length, a = [...this.schedules].map(([e, t]) => [e, { ...t }]);
+		try {
+			e(), x.decodeUnknownSync(x.toType(this.descriptor.state))(this.state), this.lastGoodState = structuredClone(this.state);
+		} catch (e) {
+			this.currentState = t, this.outbox.splice(n), this.clientOperations.splice(i), this.schedules.clear();
+			for (let [e, t] of a) this.schedules.set(e, t);
+			throw e;
+		}
+	}
+	input(r, i, a, o, s) {
+		this.ensureOpen();
+		let c = this.members.get(r);
+		if (!c) throw new t({ sessionId: r });
+		if (![
+			i,
+			a,
+			s
+		].every((e) => Number.isSafeInteger(e) && e >= 0)) throw new n({ detail: "Input metadata must use nonnegative safe integers" });
+		if (i <= c.lastSeq) return !1;
+		let l = this.now(), u = Math.max(0, l - c.replenishedAt) / 1e3, d = this.descriptor.budgets;
+		if (c.inputTokens = Math.min(d.burst, c.inputTokens + u * d.inputsPerSecond), c.byteTokens = Math.min(d.bytesPerSecond, c.byteTokens + u * d.bytesPerSecond), c.replenishedAt = l, c.inputTokens < 1) throw new e({
+			budget: "inputsPerSecond",
+			limit: d.inputsPerSecond
+		});
+		if (c.byteTokens < s) throw new e({
+			budget: "bytesPerSecond",
+			limit: d.bytesPerSecond
+		});
+		let f = x.decodeUnknownResult(this.descriptor.input)(o);
+		if (b.isFailure(f)) throw new n({ detail: "Input does not match the declared intention schema" });
+		let p = f.success;
+		if (!c.worldPending && !c.worldDeparture && this.inputs.length >= d.maxQueuedInputs) throw new e({
+			budget: "maxQueuedInputs",
+			limit: d.maxQueuedInputs
+		});
+		return --c.inputTokens, c.byteTokens -= s, c.lastSeq = i, c.worldDeparture ? !1 : c.worldPending ? (c.lastDiscardedSeq = i, !1) : (this.inputs.push(Object.freeze({
+			client: c.client,
+			seq: i,
+			tickHint: a,
+			input: structuredClone(p)
+		})), !0);
+	}
+	send(e, t, n) {
+		let i = this.descriptor.messages[t];
+		if (!i || i.direction === "client") throw new r({
+			room: this.descriptor.name,
+			detail: `Channel ${t} is not server-sendable`
+		});
+		e.send(t, x.decodeUnknownSync(i.schema)(n));
+	}
+	extension(e, n, r) {
+		if (!n) return;
+		let i = Object.create(null);
+		for (let t of e.fields) i[t] = structuredClone(Reflect.get(Object(this.state), t));
+		Object.preventExtensions(i);
+		let a = this.now();
+		S(this.descriptor.name, n, {
+			state: i,
+			tick: r.tick,
+			dt: r.dt,
+			inputs: r.inputs.map((e) => ({
+				...e,
+				input: structuredClone(e.input),
+				client: Object.freeze({
+					sessionId: e.client.sessionId,
+					subjectId: e.client.subjectId,
+					tenantId: e.client.tenantId,
+					...e.client.isBot ? {
+						isBot: !0,
+						countsAsPlayer: e.client.countsAsPlayer !== !1
+					} : {}
+				})
+			})),
+			clock: this.clock,
+			...this.geometry ? { geometry: this.geometry } : {},
+			send: (n, r) => {
+				let i = this.members.get(n);
+				if (!i) throw new t({ sessionId: n });
+				this.send(i.client, e.channel, r);
+			}
+		});
+		for (let t of e.fields) Reflect.set(Object(this.state), t, structuredClone(i[t]));
+		let o = Math.max(0, this.now() - a);
+		this.extensionDurationMs[e.name] = (this.extensionDurationMs[e.name] ?? 0) + o, o > e.tickBudgetMs && (this.extensionOverruns[e.name] = (this.extensionOverruns[e.name] ?? 0) + 1);
+	}
+	holdPublication() {
+		if (this.ensureOpen(), this.assertSynchronousLifecycle(), this.ticking) throw new r({
+			room: this.id,
+			detail: "Publication cannot change inside a tick"
+		});
+		this.publicationHeldAt ??= this.now();
+	}
+	releasePublication() {
+		if (this.ensureOpen(), this.assertSynchronousLifecycle(), this.publicationHeldAt === null) throw new n({ detail: "Actor publication has no retained hold" });
+		let e = this.now() - this.publicationHeldAt;
+		this.nextTickAt += e, this.emptyAt !== null && (this.emptyAt += e);
+		for (let t of this.schedules.values()) t.at += e;
+		for (let [t, n] of this.grace) this.grace.set(t, {
+			...n,
+			expiresAt: n.expiresAt + e
+		});
+		this.publicationHeldAt = null;
+	}
+	advance() {
+		if (this.drainFrozen || this.publicationHeldAt !== null || this.worldFinalizationHold || this.isLifecycleBusy() || this.descriptor.world?.movement && !this.worldMovement) return 0;
+		if (this.ensureOpen(), this.ticking) throw new r({
+			room: this.descriptor.name,
+			detail: "A room cannot reenter its tick"
+		});
+		let e = this.now(), t = 1e3 / this.descriptor.tickRate;
+		if (this.pruneGrace(e), this.emptyAt !== null && this.grace.size === 0 && this.worldReceipts.size === 0 && this.worldPreviews.size === 0 && e - this.emptyAt >= this.descriptor.autoDispose.afterEmptyMs) return this.retiring = !0, 0;
+		if (e < this.nextTickAt) return 0;
+		let n = Math.floor((e - this.nextTickAt) / t) + 1, i = Math.max(0, n - this.descriptor.maxCatchUpTicks);
+		if (!Number.isSafeInteger(this.tick + n)) throw new r({
+			room: this.descriptor.name,
+			detail: "Room tick counter is exhausted"
+		});
+		this.droppedTicks += i, this.tick += i, this.nextTickAt += i * t;
+		let a = 0, o = this.outbox.length, s = this.clientOperations.length;
+		this.ticking = !0;
+		try {
+			for (; a < n - i; a++) {
+				o = this.outbox.length, s = this.clientOperations.length, this.tick++;
+				let e = Object.freeze(this.inputs.splice(0).sort((e, t) => e.client.sessionId < t.client.sessionId ? -1 : e.client.sessionId > t.client.sessionId ? 1 : e.seq - t.seq)), n = {
+					state: this.state,
+					tick: this.tick,
+					dt: 1 / this.descriptor.tickRate,
+					inputs: e,
+					app: this.app,
+					clock: this.clock,
+					scheduler: this.scheduler,
+					...this.geometry ? { geometry: this.geometry } : {},
+					broadcast: (e, t) => {
+						for (let n of this.members.values()) this.send(n.client, e, t);
+					}
+				};
+				for (let e of [...this.schedules.values()]) e.at > this.nextTickAt || this.schedules.get(e.label) !== e || (e.interval === null ? this.schedules.delete(e.label) : e.at += (Math.floor((this.nextTickAt - e.at) / e.interval) + 1) * e.interval, S(this.descriptor.name, this.descriptor.onSchedule, {
+					...n,
+					label: e.label
+				}));
+				for (let e of this.descriptor.extensions) this.extension(e, e.beforeTick, n);
+				S(this.descriptor.name, this.descriptor.onTick, n);
+				for (let e of this.descriptor.extensions) this.extension(e, e.afterTick, n);
+				let r = this.constrainWorldMovement();
+				x.decodeUnknownSync(x.toType(this.descriptor.state))(this.state), this.worldMovementClamps += r.clamped, this.worldMovementIntents = r.intents;
+				for (let t of e) {
+					let e = this.members.get(t.client.sessionId);
+					e && (e.lastAppliedSeq = Math.max(e.lastAppliedSeq, t.seq));
+				}
+				this.lastGoodState = structuredClone(this.state), this.lastGoodTick = this.tick, this.nextTickAt += t;
+			}
+		} catch (e) {
+			throw this.faulted = !0, this.worldMovementIntents = Object.freeze([]), this.currentState = structuredClone(this.lastGoodState), this.outbox.splice(o), this.clientOperations.splice(s), this.schedules.clear(), this.inputs.length = 0, e;
+		} finally {
+			this.ticking = !1;
+		}
+		return a;
+	}
+	drainOutbox() {
+		if (this.lifecycleActive) throw new r({
+			room: this.descriptor.name,
+			detail: "Lifecycle commands are drained only after the hook commits"
+		});
+		if (this.ticking) throw new r({
+			room: this.descriptor.name,
+			detail: "The app outbox can only be drained outside the tick"
+		});
+		return this.outbox.splice(0);
+	}
+	stageClientOperation(t) {
+		if (this.clientOperations.length >= this.descriptor.budgets.maxOutboxCommands) throw new e({
+			budget: "maxClientOperations",
+			limit: this.descriptor.budgets.maxOutboxCommands
+		});
+		this.clientOperations.push(t);
+	}
+	flushClientOperations() {
+		if (this.lifecycleActive) throw new r({
+			room: this.descriptor.name,
+			detail: "Lifecycle client operations flush only after the hook commits"
+		});
+		if (this.ticking) throw new r({
+			room: this.descriptor.name,
+			detail: "Client operations must be flushed outside the tick"
+		});
+		let e = [];
+		for (let t of this.clientOperations.splice(0)) try {
+			t();
+		} catch (t) {
+			e.push(t);
+		}
+		if (e.length) throw AggregateError(e, "Room client delivery failed");
+	}
+	inputReceiptSnapshot() {
+		if (this.ticking || this.isLifecycleBusy()) throw new r({
+			room: this.id,
+			detail: "Input receipts are captured outside committed lifecycle and tick work"
+		});
+		this.pruneGrace(this.drainAt ?? this.publicationHeldAt ?? this.worldFinalizationHold?.heldAt ?? this.now());
+		let e = [];
+		for (let [t, n] of this.members) !n.client.isBot && (n.lastAppliedSeq >= 0 || n.lastDiscardedSeq >= 0) && e.push({
+			sessionId: t,
+			subjectId: n.client.subjectId,
+			lastAppliedSeq: n.lastAppliedSeq,
+			...n.lastDiscardedSeq < 0 ? {} : { discardedThrough: n.lastDiscardedSeq }
+		});
+		for (let [t, n] of this.grace) (n.lastAppliedSeq >= 0 || (n.discardedThrough ?? -1) >= 0) && e.push({
+			sessionId: t,
+			subjectId: n.subjectId,
+			lastAppliedSeq: n.lastAppliedSeq,
+			...(n.discardedThrough ?? -1) < 0 ? {} : { discardedThrough: n.discardedThrough }
+		});
+		return p(e, Math.min(this.descriptor.maxClients, 16384));
+	}
+	confirmInputCheckpoint(e) {
+		for (let t of p(e, Math.min(this.descriptor.maxClients, 16384))) {
+			let e = this.members.get(t.sessionId);
+			e?.worldTarget && e.client.subjectId === t.subjectId && t.discardedThrough !== void 0 && (e.checkpointedDiscardedSeq = Math.max(e.checkpointedDiscardedSeq, Math.min(e.lastDiscardedSeq, t.discardedThrough)));
+		}
+	}
+	lastAppliedInputSeq(e) {
+		let n = this.members.get(e);
+		if (!n) throw new t({ sessionId: e });
+		return n.lastAppliedSeq;
+	}
+	lock() {
+		this.ensureOpen(), this.locked = !0;
+	}
+	unlock() {
+		this.ensureOpen(), this.locked = !1;
+	}
+	dispose() {
+		if (this.assertSynchronousLifecycle(), this.disposed) return;
+		if (this.ticking) throw new r({
+			room: this.descriptor.name,
+			detail: "Dispose must run outside the tick"
+		});
+		this.retiring = !1;
+		let e = [];
+		try {
+			for (let [t, n] of this.members) try {
+				this.faulted ? n.client.kick("Room fault") : this.leave(t, "disposed");
+			} catch (t) {
+				e.push(t);
+			}
+			if (!this.faulted) try {
+				C(this.descriptor.name, this.descriptor.onDispose, {
+					state: this.state,
+					app: this.app,
+					...this.geometry ? { geometry: this.geometry } : {}
+				});
+			} catch (t) {
+				e.push(t);
+			}
+		} finally {
+			this.disposed = !0, this.members.clear(), this.grace.clear(), this.schedules.clear(), this.inputs.length = 0;
+		}
+		if (e.length) throw AggregateError(e, "Room disposal failed");
+	}
+	isDisposed() {
+		return this.disposed;
+	}
+	isLifecycleBusy() {
+		return this.lifecycleRequests > 0;
+	}
+	async freezeForDrain() {
+		if (this.ticking || this.disposed || this.faulted || this.retiring) throw new o({ roomId: this.id });
+		this.drainFrozen ||= (this.drainAt = this.now(), !0), await this.lifecycleTail;
+	}
+	releaseTransferred() {
+		if (this.assertSynchronousLifecycle(), !this.disposed) {
+			if (!this.drainFrozen || this.ticking || this.outbox.length || this.clientOperations.length) throw new r({
+				room: this.id,
+				detail: "Transferred actor release requires its frozen committed boundary"
+			});
+			this.disposed = !0, this.members.clear(), this.grace.clear(), this.schedules.clear(), this.inputs.length = 0;
+		}
+	}
+	disposeAsync(e) {
+		return this.serializeLifecycle(async () => {
+			if (this.disposed) return;
+			this.retiring = !1;
+			let t = [];
+			try {
+				for (let [n, r] of this.members) try {
+					if (this.faulted || this.worldFinalizationHold) r.client.kick("Room fault");
+					else {
+						let t = this.prepareLeave(n, "disposed");
+						t.pending || await this.mutateMemberAsync((e) => this.descriptor.onLeave?.(t.context(e)), e), t.commit();
+					}
+				} catch (e) {
+					t.push(e);
+				}
+				if (!this.faulted && !this.worldFinalizationHold) try {
+					await this.mutateMemberAsync((e) => this.descriptor.onDispose?.({
+						state: e,
+						app: this.app,
+						...this.geometry ? { geometry: this.geometry } : {}
+					}), e);
+				} catch (e) {
+					t.push(e);
+				}
+			} finally {
+				this.disposed = !0, this.worldFinalizationHold = null, this.deferredWorldLeaves.clear(), this.members.clear(), this.grace.clear(), this.schedules.clear(), this.inputs.length = 0;
+			}
+			if (t.length) throw AggregateError(t, "Asynchronous Room disposal failed");
+		}, () => this.worldFinalizationHold?.requestId);
+	}
+	isRetiring() {
+		return this.retiring;
+	}
+	releaseHibernated() {
+		if (this.assertSynchronousLifecycle(), !this.disposed) {
+			if (this.ticking || !this.retiring || this.members.size || this.grace.size || this.outbox.length) throw new r({
+				room: this.descriptor.name,
+				detail: "Hibernate release requires an empty retired actor and committed outbox"
+			});
+			this.disposed = !0, this.retiring = !1, this.members.clear(), this.grace.clear(), this.schedules.clear(), this.inputs.length = 0, this.clientOperations.length = 0;
+		}
+	}
+	isFaulted() {
+		return this.faulted;
+	}
+	commandCursor() {
+		return this.commandSeq;
+	}
+	scheduleSnapshot() {
+		if (this.ticking) throw new r({
+			room: this.descriptor.name,
+			detail: "Schedules are checkpointed outside the tick"
+		});
+		let e = this.drainAt ?? this.publicationHeldAt ?? this.worldFinalizationHold?.heldAt ?? this.now();
+		return [...this.schedules.values()].map((t) => Object.freeze({
+			label: t.label,
+			remainingMs: Math.max(0, t.at - e),
+			intervalMs: t.interval
+		}));
+	}
+	lastGoodSnapshot() {
+		if (this.ticking) throw new r({
+			room: this.descriptor.name,
+			detail: "Fault snapshots are taken outside the tick"
+		});
+		return {
+			tick: this.lastGoodTick,
+			state: structuredClone(this.lastGoodState)
+		};
+	}
+	metrics() {
+		return {
+			tick: this.tick,
+			droppedTicks: this.droppedTicks,
+			queuedInputs: this.inputs.length,
+			outboxCommands: this.outbox.length,
+			clients: this.members.size,
+			extensionDurationMs: { ...this.extensionDurationMs },
+			extensionOverruns: { ...this.extensionOverruns }
+		};
+	}
+};
+export { w as RoomActor };