@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepOwnedRoom.js

@@ -0,0 +1,763 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomGone as n } from "./errors.js";
+import { unsignedWord as r } from "./fixedWords.js";
+import { freezeSimulationValue as i, simulationOwnData as a, simulationSyncValue as o } from "./simulationAuthoring.js";
+import { defineRoom as s } from "./room.js";
+import { roomLockstepStartBudgetRoster as c } from "./lockstepWireRoster.js";
+import { encodeRoomFrame as l } from "./wire.js";
+import { roomCodecs as u } from "./web.js";
+import { captureLockstepJournalScope as d, createLockstepJournalCodec as f, lockstepJournalIdentity as p } from "./lockstepJournalCodec.js";
+import { createRoomLockstepAdmissionCodec as m } from "./lockstepAdmissionCodec.js";
+import { RoomLockstepMemberOwner as h } from "./lockstepMembers.js";
+import { captureRoomServerSessionLimits as g } from "./serverSessionConfig.js";
+import { assertRoomSeatSecrets as _, resolveRoomSeatTokenStrategies as v } from "./seats.js";
+import { RoomServerSession as y, RoomServerSessionAcquisitionFailure as b, captureRoomLockstepSessionPort as x } from "./serverSession.js";
+import { captureRoomLockstepTransportLimits as S } from "./lockstepTransportConfig.js";
+import { createRoomLockstepTransportOwner as C } from "./lockstepTransport.js";
+import { captureRoomLockstepInitialStrategies as w, resolveRoomLockstepInitialPlayerId as T, resolveRoomLockstepInitialStart as E } from "./lockstepInitialAdmission.js";
+import { Effect as D, Result as O } from "effect";
+// src/lockstepOwnedRoom.ts
+var k = /* @__PURE__ */ new WeakSet(), A = (e) => typeof e == "object" && !!e && k.has(e);
+function j(e) {
+	throw new t({ detail: e });
+}
+var M = (e, t, n = []) => {
+	let r = a(e, [...t, ...n], t);
+	for (let e of n) if (Object.hasOwn(r, e) && typeof r[e] != "function") return j("Lockstep owned room requires complete actual capabilities");
+	for (let e of t) if (typeof r[e] != "function") return j("Lockstep owned room requires complete actual capabilities");
+}, N = class A {
+	id;
+	tenantId;
+	hostId;
+	epoch;
+	descriptor;
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s = [];
+	#c = 0;
+	#l = !1;
+	#u = /* @__PURE__ */ new Set();
+	#d = /* @__PURE__ */ new Map();
+	#f = !1;
+	#p = !1;
+	#m = null;
+	#h = !1;
+	#g = !1;
+	#_ = !1;
+	#v = null;
+	#y = !1;
+	#b = !1;
+	#x = null;
+	#S = null;
+	#C = null;
+	#w = !1;
+	#T = null;
+	#E = null;
+	constructor(e, t, n, r, i = null) {
+		this.#e = i, this.#t = JSON.stringify(r), this.id = t.roomId, this.tenantId = t.tenantId, this.hostId = n.hostId, this.epoch = t.epoch, this.descriptor = e, this.#i = n, this.#n = new h(e.simulation, {
+			roomId: this.id,
+			tenantId: this.tenantId,
+			epoch: this.epoch
+		}, {
+			name: e.name,
+			maxClients: e.maxClients,
+			budgets: e.budgets,
+			messages: e.messages,
+			...e.lockstep.lateJoin ? { lateJoin: !0 } : {}
+		}), this.#a = u(e), this.#o = S(n.transport);
+		let { inputSchema: a, inputDelayTicks: o, rollbackHorizonTicks: s, inputPrediction: c, lateJoin: l, ...d } = e.lockstep;
+		try {
+			this.#r = C(e.simulation, t.seed, t.options, {
+				roomId: this.id,
+				tenantId: this.tenantId,
+				epoch: this.epoch
+			}, n.clock.now, d, {
+				tickRate: e.tickRate,
+				maxCatchUpTicks: n.maxCatchUpTicks ?? e.maxCatchUpTicks
+			}, {
+				...n.transport,
+				journal: {
+					service: n.journal,
+					runEffect: n.runEffect,
+					startRequestId: `${t.requestId}::start`
+				}
+			});
+		} catch (e) {
+			throw this.#n.withdraw(), e;
+		}
+		Object.freeze(this);
+	}
+	static async create(e, t, n) {
+		return A.build(e, t, n, null);
+	}
+	static async restore(e, t, n, r) {
+		let i = s(e), o = d(t), c = a(n, [
+			"admission",
+			"journal",
+			"options"
+		], [
+			"admission",
+			"journal",
+			"options"
+		]), l = a(r, [
+			"hostId",
+			"admission",
+			"journal",
+			"runEffect",
+			"clock",
+			"seats",
+			"sessionOptions",
+			"transport",
+			"maxCatchUpTicks"
+		], [
+			"hostId",
+			"admission",
+			"journal",
+			"runEffect",
+			"clock",
+			"seats",
+			"sessionOptions"
+		]), u = p(l.hostId), h = m(i.simulation, 67108864), g = h.captureStored(c.admission, o, u);
+		if (!g.adoption || g.adoption.priorEpoch !== o.epoch - 1 || g.initial.name !== i.name) return j("Owned successor requires actual matching adopted SQL admission");
+		let _ = c.journal === null ? null : f(i.simulation, 65536, 67108864, i.maxClients).captureStored(c.journal, o, u);
+		if (_ && (!_.adoption || _.adoption.priorEpoch !== g.adoption.priorEpoch || _.initial.seed !== g.initial.seed || _.initial.options !== g.initial.options || _.initial.stateSchemaHash !== g.initial.stateSchemaHash || _.initial.inputSchemaHash !== g.initial.inputSchemaHash)) return j("Owned successor metadata and retained input truth disagree");
+		let v = h.optionsWire.decode(Buffer.from(g.initial.options, "base64url"));
+		if (Buffer.from(h.optionsWire.encode(c.options)).toString("base64url") !== g.initial.options) return j("Owned successor canonical options changed");
+		let y = Object.freeze({
+			admission: g,
+			journal: _,
+			options: v
+		});
+		return A.build(i, {
+			...o,
+			requestId: g.initial.requestId,
+			creatorSubjectId: g.initial.creatorSubjectId,
+			seed: g.initial.seed,
+			options: v
+		}, Object.freeze({ ...l }), y);
+	}
+	static async build(e, t, n, o) {
+		let u = s(e), h = [
+			"roomId",
+			"tenantId",
+			"epoch",
+			"requestId",
+			"creatorSubjectId",
+			"seed",
+			"options"
+		], y = a(t, h, h), b = d({
+			roomId: y.roomId,
+			tenantId: y.tenantId,
+			epoch: y.epoch
+		}), x = m(u.simulation, 67108864), C = x.optionsWire.capture(y.options), w = a(n, [
+			"hostId",
+			"admission",
+			"journal",
+			"runEffect",
+			"clock",
+			"seats",
+			"sessionOptions",
+			"transport",
+			"maxCatchUpTicks"
+		], [
+			"hostId",
+			"admission",
+			"journal",
+			"runEffect",
+			"clock",
+			"seats",
+			"sessionOptions"
+		]);
+		M(w.admission, [
+			"prepare",
+			"publish",
+			"load",
+			"adopt",
+			"exportSubject",
+			"erase"
+		]), M(w.journal, [
+			"initialize",
+			"append",
+			"load",
+			"adopt",
+			"exportSubject",
+			"erase"
+		], ["join"]), M(w.seats, ["consume", "disconnect"], ["revalidate"]);
+		let T = p(w.hostId), E = w.runEffect, N = w.maxCatchUpTicks;
+		if (N !== void 0 && (!Number.isSafeInteger(N) || N < 1 || N > 128)) return j("Invalid Lockstep host catch-up budget");
+		let P = w.clock, F = P && typeof P == "object" ? Object.getOwnPropertyDescriptor(P, "now") : void 0, I = { now: F && "value" in F ? F.value : void 0 };
+		if (typeof E != "function" || typeof I.now != "function") return j("Owned room requires its actual Effect runner and clock");
+		let L = a(w.sessionOptions, [
+			"secrets",
+			"epochNow",
+			"seatToken",
+			"maxPendingWrites",
+			"maxFramesPerSecond",
+			"baselineCapacity",
+			"maxBaselineAgeMs",
+			"helloTimeoutMs",
+			"authTimeoutMs",
+			"idleTimeoutMs"
+		], ["secrets", "epochNow"]), { secrets: ee, epochNow: te, seatToken: ne, ...re } = L, ie = g(re, b.roomId), R = L;
+		if (typeof R.epochNow != "function") return j("Owned room requires an actual Seat epoch clock");
+		let z = a(R.secrets, ["current", "previous"], ["current"]), B = i({
+			current: a(z.current, ["kid", "secret"], ["kid", "secret"]),
+			...z.previous === void 0 ? {} : { previous: a(z.previous, ["kid", "secret"], ["kid", "secret"]) }
+		});
+		_(B);
+		let ae = v(R.seatToken === void 0 ? {} : a(R.seatToken, ["sign", "verify"], [])), V = S(w.transport ?? {}), H = r(y.seed), U = x.optionsWire.encode(C), W = l({
+			kind: "LsStart",
+			startTick: 0,
+			seed: H,
+			options: U,
+			serverTimeMs: 2 ** 53 - 1,
+			localPlayerId: 4294967295,
+			roster: c(u.maxClients)
+		}, {
+			maxBytes: V.maxPendingWireBytes,
+			maxInputs: 4096
+		});
+		if (O.isFailure(W)) throw W.failure;
+		let G = w.admission, K = w.journal, q = w.seats, J = Object.freeze({
+			hostId: T,
+			runEffect: E,
+			clock: Object.freeze({ now: I.now.bind(w.clock) }),
+			admission: Object.freeze({
+				prepare: G.prepare.bind(G),
+				publish: G.publish.bind(G),
+				load: G.load.bind(G),
+				adopt: G.adopt.bind(G),
+				exportSubject: G.exportSubject.bind(G),
+				erase: G.erase.bind(G)
+			}),
+			journal: Object.freeze({
+				initialize: K.initialize.bind(K),
+				append: K.append.bind(K),
+				load: K.load.bind(K),
+				adopt: K.adopt.bind(K),
+				exportSubject: K.exportSubject.bind(K),
+				erase: K.erase.bind(K),
+				...typeof K.join == "function" ? { join: K.join.bind(K) } : {}
+			}),
+			seats: Object.freeze({
+				consume: q.consume.bind(q),
+				disconnect: q.disconnect.bind(q)
+			}),
+			sessionOptions: Object.freeze({
+				...ie,
+				epochNow: R.epochNow,
+				secrets: B,
+				seatToken: ae
+			}),
+			transport: V,
+			...N === void 0 ? {} : { maxCatchUpTicks: N }
+		}), Y = Object.freeze({
+			...b,
+			requestId: p(y.requestId),
+			creatorSubjectId: p(y.creatorSubjectId),
+			seed: H,
+			options: C
+		});
+		if (p(`${Y.requestId}::start`).length > 150) return j("Owned room Start request leaves no bounded tick suffix");
+		let X = o ? J.admission.load(b) : J.admission.prepare(Y);
+		if (!D.isEffect(X)) return j("Owned room preparation must return the actual admission Effect");
+		let Z = x.captureStored(await E(X), b, T);
+		if (Z.initial.requestId !== Y.requestId || Z.initial.creatorSubjectId !== Y.creatorSubjectId || Z.initial.name !== u.name || Z.initial.seed !== Y.seed || Z.initial.options !== Buffer.from(U).toString("base64url") || (o ? JSON.stringify(Z) !== JSON.stringify(o.admission) : Z.adoption !== null)) return j("Owned room preparation returned an unrelated creation receipt");
+		let Q = async () => {
+			let e = J.journal.load(b);
+			if (!D.isEffect(e)) return j("Owned successor Journal load must return its actual Effect");
+			let t = await E(e), n = t === null ? null : f(u.simulation, 65536, 67108864, u.maxClients).captureStored(t, b, T);
+			if (JSON.stringify(n) !== JSON.stringify(o?.journal ?? null)) return j("Owned successor retained SQL journal changed during construction");
+		};
+		o && await Q();
+		let $ = new A(u, {
+			...Y,
+			seed: Z.initial.seed,
+			options: x.optionsWire.decode(Buffer.from(Z.initial.options, "base64url"))
+		}, J, Z, o);
+		try {
+			if (o) {
+				o.journal && $.#r.stageRecovery(o.journal);
+				let e = J.admission.load(b);
+				if (!D.isEffect(e)) return j("Owned successor admission bookend must return its actual Effect");
+				let t = x.captureStored(await E(e), b, T);
+				if (JSON.stringify(t) !== JSON.stringify(Z)) return j("Owned successor metadata changed after construction");
+				await Q();
+			}
+			return k.add($), $;
+		} catch (e) {
+			try {
+				await $.disposeAsync(!0);
+			} catch (t) {
+				throw AggregateError([e, t], "Owned successor construction and withdrawal failed");
+			}
+			throw e;
+		}
+	}
+	publishAsync() {
+		try {
+			if (this.admitWork(), this.#v || this.#x || this.#S || this.#m) return j("Owned publication cannot overlap active supervision");
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		if (this.#_) return Promise.resolve();
+		let e = Promise.resolve().then(async () => {
+			let e = {
+				roomId: this.id,
+				tenantId: this.tenantId,
+				epoch: this.epoch
+			}, t = this.#i.admission.publish(e);
+			if (!D.isEffect(t)) return j("Owned publication must return its actual Admission Effect");
+			let n = m(this.descriptor.simulation, 67108864), r = n.captureStored(await this.#i.runEffect(t), e, this.hostId);
+			if (this.live(), JSON.stringify(r) !== this.#t) return j("Publication returned unrelated initial SQL creation");
+			let i = this.#i.admission.load(e);
+			if (!D.isEffect(i)) return j("Owned current publication must return its actual Admission Effect");
+			let a = await this.#i.runEffect(i), o = n.captureStored(a, e, this.hostId);
+			if (JSON.stringify(o) !== JSON.stringify(r)) return j("Publication changed its current SQL creation receipt");
+			this.live(), this.#_ = !0;
+		});
+		return this.#v = e, e.then(() => {
+			this.#v = null;
+		}, () => {
+			this.#v = null;
+		}), e;
+	}
+	recoveryTruth() {
+		return this.live(), this.#e;
+	}
+	rosterOpen() {
+		return this.#w || !this.isPublished() || this.#m ? !1 : this.#y ? this.descriptor.lockstep.lateJoin === !0 && this.#d.size < this.descriptor.maxClients : !this.#e?.journal && !this.#b;
+	}
+	isPublished() {
+		return this.#_ && !this.#g;
+	}
+	outside() {
+		if (this.#f || this.#p) return j("Owned lockstep supervision cannot run in tick or reenter an initial strategy");
+	}
+	live() {
+		if (this.outside(), this.#g || this.#r.isDisposed()) throw new n({ roomId: this.id });
+	}
+	admitWork() {
+		if (this.live(), this.#w) return j("Lockstep owner is frozen for planned handoff");
+	}
+	connect(t) {
+		if (this.admitWork(), !this.#_) return j("Owned Sessions require confirmed SQL publication after Runtime installation");
+		if (this.#m) return j("Owned Session cleanup cannot overlap connection admission");
+		if (this.#b && !this.#y) return j("A durable Start attempt sealed the initial roster; it cannot acquire another Session");
+		if (this.#d.size >= this.descriptor.maxClients) throw new e({
+			budget: "lockstepOwnedSessions",
+			limit: this.descriptor.maxClients
+		});
+		let n = t.closeAsync;
+		if (n !== void 0 && typeof n != "function") return j("Native async close must be callable");
+		try {
+			let e = new y(this.#n, t, this.#i.clock, this.#i.seats, {
+				...this.#i.sessionOptions,
+				epoch: this.epoch,
+				onClientMessage: (t, n, r) => {
+					this.receiveMessage(e, t, n, r);
+				}
+			});
+			return this.#d.set(e, {
+				session: e,
+				closeNative: n ? () => n.call(t, 1e3, "Owned Room closed") : null,
+				player: null,
+				nativeClosed: n === void 0
+			}), e;
+		} catch (e) {
+			throw e instanceof b && this.#u.add(e.releaseListeners), e;
+		}
+	}
+	admit(e, t) {
+		if (this.admitWork(), !this.#_) return j("Owned Sessions require confirmed SQL publication after Runtime installation");
+		if (this.#m) return j("Owned Session cleanup cannot overlap roster admission");
+		let n = this.#d.get(t);
+		if (!n || n.player || this.#b) return j("Lockstep roster requires an unbound actual owned Session");
+		let r = this.#r.admit(e, t);
+		return n.player = r, r;
+	}
+	roster() {
+		return this.outside(), Object.freeze([...this.#d.values()].flatMap((e) => e.player ? [e.player] : []).sort((e, t) => e.slot - t.slot));
+	}
+	async prepareInitialRoster(e = {}) {
+		this.admitWork();
+		let t = w(e);
+		if (this.#y) {
+			if (this.#x) return this.#x;
+			if (this.#m || this.#S || this.#v) return this.roster();
+			let e = Promise.resolve().then(async () => {
+				for (let e of this.#d.values()) {
+					if (e.player) continue;
+					let n = x(e.session), r = n.identity();
+					if (!r || !n.canActivate()) continue;
+					if (!this.#r.retains(e.session)) {
+						if (this.descriptor.lockstep.lateJoin !== !0 || !this.#r.lateJoinReady()) continue;
+						let n = this.roster(), i;
+						this.#p = !0;
+						try {
+							i = T({
+								roomId: this.id,
+								tenantId: this.tenantId,
+								epoch: this.epoch,
+								maxPlayers: this.descriptor.maxClients,
+								players: n,
+								subjectId: r.subjectId,
+								sessionId: r.sessionId
+							}, t.playerId);
+						} finally {
+							this.#p = !1;
+						}
+						this.live(), e.player = await this.#r.joinAsync(e.session, i, Math.max(this.descriptor.lockstep.inputDelayTicks, 1) + 1), this.live(), this.#h = !0;
+						break;
+					}
+					let i = await this.#r.rebindAsync(e.session);
+					this.live();
+					for (let t of this.#d.values()) t !== e && t.player?.playerId === i.playerId && (t.player = null);
+					e.player = i, this.#h = !0;
+					break;
+				}
+				return this.roster();
+			});
+			return this.#x = e, e.then(() => {
+				this.#x = null;
+			}, () => {
+				this.#x = null;
+			}), e;
+		}
+		if (this.#x) return this.#x;
+		if (this.#b) return this.startAsync();
+		if (!this.#_ || this.#m || this.#v) return this.roster();
+		if (this.#e?.journal) {
+			for (let e of this.#d.values()) {
+				if (e.player) continue;
+				let t = x(e.session);
+				t.identity() && t.canActivate() && (this.live(), e.player = this.#r.admitRecovered(e.session));
+			}
+			return this.roster().length === this.#e.journal.initial.players.length + (this.#e.journal.joins?.length ?? 0) ? this.startAsync() : this.roster();
+		}
+		for (let e of this.#d.values()) {
+			if (e.player) continue;
+			let n = x(e.session), r = n.identity();
+			if (!r || !n.canActivate()) continue;
+			let i = this.roster(), a;
+			this.#p = !0;
+			try {
+				a = T({
+					roomId: this.id,
+					tenantId: this.tenantId,
+					epoch: this.epoch,
+					maxPlayers: this.descriptor.maxClients,
+					players: i,
+					subjectId: r.subjectId,
+					sessionId: r.sessionId
+				}, t.playerId);
+			} finally {
+				this.#p = !1;
+			}
+			this.live(), this.admit(a, e.session);
+		}
+		let n = this.roster(), r;
+		this.#p = !0;
+		try {
+			r = E({
+				roomId: this.id,
+				tenantId: this.tenantId,
+				epoch: this.epoch,
+				maxPlayers: this.descriptor.maxClients,
+				players: n
+			}, t.start);
+		} finally {
+			this.#p = !1;
+		}
+		return this.live(), r ? this.startAsync() : n;
+	}
+	startAsync() {
+		try {
+			this.admitWork();
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		return this.startAccepted();
+	}
+	startAccepted() {
+		try {
+			if (this.live(), !this.#_) return j("Owned Start requires confirmed SQL publication");
+			if (this.#m) return j("Owned Session cleanup cannot overlap Start");
+			if (this.#y || this.#x || !this.#d.size || [...this.#d.values()].some((e) => !e.player)) return j("Start needs the complete admitted owned roster");
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		this.#b = !0;
+		let e = this.#r.startAsync().then((e) => this.#g ? j("Owned room was withdrawn during Start") : (this.#y = !0, this.#h = !0, e));
+		return this.#x = e, e.then(() => {
+			this.#x = null;
+		}, () => {
+			this.#x = null;
+		}), e;
+	}
+	advance() {
+		if (this.outside(), this.#g || this.#w || !this.#y || this.#x || this.#h || this.#S || this.#m) return 0;
+		this.#f = !0;
+		try {
+			return this.#h = !0, this.#r.advance();
+		} finally {
+			this.#f = !1;
+		}
+	}
+	messageTargets() {
+		return [...this.#d.values()].filter((e) => e.player && e.session.canSendLockstepMessages()).map((e) => e.session);
+	}
+	captureMessage(e, t, n) {
+		let r = this.#a.channels.findIndex((t) => t.name === e), i = this.#a.channels[r];
+		if (!i || i.direction === "client") return j("Channel is not server-sendable");
+		let a = i.codec.full(t);
+		if (O.isFailure(a)) throw a.failure;
+		let o = {
+			kind: "ServerMessage",
+			channelId: r,
+			payload: Uint8Array.from(a.success)
+		}, s = l(o, { maxBytes: this.#o.maxPendingWireBytes });
+		if (O.isFailure(s)) throw s.failure;
+		return {
+			frame: o,
+			bytes: s.success.byteLength,
+			targets: new Set(n)
+		};
+	}
+	admitMessages(t) {
+		let n = t.filter((e) => e.targets.size > 0), r = n.reduce((e, t) => e + t.bytes, 0);
+		if (this.#s.length + n.length > this.descriptor.budgets.maxOutboxCommands) throw new e({
+			budget: "lockstepMessageCommands",
+			limit: this.descriptor.budgets.maxOutboxCommands
+		});
+		if (this.#c + r > this.#o.maxPendingWireBytes) throw new e({
+			budget: "lockstepMessageBytes",
+			limit: this.#o.maxPendingWireBytes
+		});
+		this.#s.push(...n), this.#c += r;
+	}
+	broadcast(e, t) {
+		if (this.admitWork(), !this.#y || this.#l) return j("Message broadcast requires current outside-hook supervision");
+		this.admitMessages([this.captureMessage(e, t, this.messageTargets())]);
+	}
+	receiveMessage(t, n, r, a) {
+		this.admitWork();
+		let s = this.#d.get(t), c = this.descriptor.onMessage;
+		if (!this.#y || this.#l || !s?.player || !t.canSendLockstepMessages() || !c || t.id !== a.sessionId || a.roomId !== this.id || a.tenantId !== this.tenantId || a.epoch !== this.epoch || !a.subjectId) return j("Message hook requires the same current authenticated Lockstep player");
+		let l = [], u = !0, d = 0, f = (t, n, r) => {
+			if (this.live(), !u || !this.#l) return j("Message hook capabilities expire on return");
+			if (this.#s.length + l.length >= this.descriptor.budgets.maxOutboxCommands) throw new e({
+				budget: "lockstepMessageCommands",
+				limit: this.descriptor.budgets.maxOutboxCommands
+			});
+			let i = this.captureMessage(t, n, r);
+			if (this.#c + d + i.bytes > this.#o.maxPendingWireBytes) throw new e({
+				budget: "lockstepMessageBytes",
+				limit: this.#o.maxPendingWireBytes
+			});
+			d += i.bytes, l.push(i);
+		};
+		this.#l = !0;
+		try {
+			if (o(c(Object.freeze({
+				roomId: this.id,
+				tenantId: this.tenantId,
+				epoch: this.epoch,
+				client: Object.freeze({
+					sessionId: a.sessionId,
+					subjectId: a.subjectId,
+					tenantId: a.tenantId
+				}),
+				channel: n,
+				payload: i(r),
+				reply: (e, n) => f(e, n, [t]),
+				broadcast: (e, t) => f(e, t, this.messageTargets())
+			}))) !== void 0) return j("Message hooks must return undefined synchronously");
+			if (this.live(), !t.canSendLockstepMessages()) return j("Message author withdrew its actual native Session");
+			this.admitMessages(l);
+		} finally {
+			u = !1, this.#l = !1;
+		}
+	}
+	async flushMessages() {
+		let e = 0, t = 0;
+		for (; !this.#g && this.#s.length && t < this.#o.maxFlushWork;) {
+			let n = this.#s[0];
+			for (let r of n.targets) {
+				if (t++ >= this.#o.maxFlushWork) break;
+				if (!this.#d.get(r)?.player || !r.canSendLockstepMessages()) n.targets.delete(r);
+				else if (await r.sendLockstepMessage(n.frame), n.targets.delete(r), e++, this.#g) break;
+			}
+			if (this.#g || n.targets.size) break;
+			this.#s.shift(), this.#c -= n.bytes;
+		}
+		return {
+			writes: e,
+			pending: this.#s.length > 0
+		};
+	}
+	messageMetrics() {
+		return this.outside(), Object.freeze({
+			pendingCommands: this.#s.length,
+			pendingBytes: this.#c
+		});
+	}
+	flush() {
+		try {
+			this.admitWork();
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		return this.flushAccepted();
+	}
+	flushAccepted() {
+		try {
+			if (this.live(), this.#S || this.#x || this.#m || this.#v) return j("Owned lockstep flush cannot overlap Start or another flush");
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let e = this.#r.flush().then(async (e) => {
+			this.#h = e.pending;
+			let t = await this.flushMessages();
+			return {
+				writes: e.writes + t.writes,
+				pending: e.pending || t.pending
+			};
+		});
+		return this.#S = e, e.then(() => {
+			this.#S = null;
+		}, () => {
+			this.#S = null;
+		}), e;
+	}
+	async releaseSession(e, t) {
+		let n = t === void 0 ? [e.session.settled()] : t ? [e.session.closeFenced()] : [e.session.close("disposed"), e.session.settled()], r = (await Promise.allSettled(n)).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+		if (!e.nativeClosed) try {
+			await e.closeNative?.(), e.nativeClosed = !0;
+		} catch (e) {
+			r.push(e);
+		}
+		if (r.length) throw AggregateError(r, "Owned Session release remains incomplete");
+		this.#d.delete(e.session);
+	}
+	maintenance() {
+		try {
+			if (this.admitWork(), this.#m || this.#x || this.#S || this.#v) return j("Owned Session cleanup cannot overlap active supervision");
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let e = Promise.resolve().then(async () => {
+			let e = [];
+			for (let t of this.#u) try {
+				t(), this.#u.delete(t);
+			} catch (t) {
+				e.push(t);
+			}
+			for (let t of this.#d.values()) try {
+				if (t.session.maintenance(), !t.session.teardownReady()) continue;
+				await this.releaseSession(t);
+			} catch (t) {
+				e.push(t);
+			}
+			if (e.length) throw AggregateError(e, "Owned lockstep Session cleanup remains incomplete");
+		});
+		return this.#m = e, e.then(() => {
+			this.#m = null;
+		}, () => {
+			this.#m = null;
+		}), e;
+	}
+	metrics() {
+		return Object.freeze({
+			...this.#r.metrics(),
+			clients: this.#n.roster().length
+		});
+	}
+	prepareDrain() {
+		try {
+			if (this.live(), !this.#_) return j("Drain requires confirmed Lockstep publication");
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		if (this.#E) return Promise.resolve(this.#E);
+		if (this.#T) return this.#T;
+		this.#w = !0;
+		let e = [
+			this.#v,
+			this.#x,
+			this.#S,
+			this.#m
+		].filter((e) => e !== null), t = [...this.#d.values()].map((e) => e.session), n = t.map((e) => e.quiesceForDrain()), r = Promise.resolve().then(async () => {
+			let r = (await Promise.allSettled([...e, ...n])).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+			if (r.length) throw AggregateError(r, "Accepted Lockstep drain work remains incomplete");
+			if (this.live(), this.#b && !this.#y && await this.startAccepted(), (await this.flushAccepted()).pending) return j("Lockstep drain has retained bounded flush work; retry preparation");
+			if (await Promise.all(t.map((e) => e.settled())), t.some((e) => e.failure !== null)) return j("Lockstep Session failed before the final journal boundary");
+			let i = this.#r.journalBoundary(), a = {
+				roomId: this.id,
+				tenantId: this.tenantId,
+				epoch: this.epoch
+			}, o = async (e) => D.isEffect(e) ? this.#i.runEffect(D.uninterruptible(e)) : j("Drain truth requires its actual SQL Effect"), s = m(this.descriptor.simulation, 67108864).captureStored(await o(this.#i.admission.load(a)), a, this.hostId);
+			if (JSON.stringify(s) !== this.#t) return j("Lockstep drain creation changed its retained SQL truth");
+			let c = await o(this.#i.journal.load(a)), l = c === null ? null : f(this.descriptor.simulation, 65536, 67108864, this.descriptor.maxClients).captureStored(c, a, this.hostId);
+			return this.live(), (l?.digest ?? null) !== i.digest || (l?.ticks.length ?? 0) !== i.tick ? j("Lockstep drain SQL journal changed its retained durable frontier") : (this.#E = Object.freeze({
+				...a,
+				mode: "lockstep",
+				tick: i.tick,
+				admissionDigest: s.digest,
+				journalDigest: i.digest
+			}), this.#E);
+		});
+		return this.#T = r, r.catch(() => {
+			this.#T = null;
+		}), r;
+	}
+	transportMetrics() {
+		return this.#r.transportMetrics();
+	}
+	drainOutbox() {
+		return this.outside(), this.#r.drainOutbox();
+	}
+	isDisposed() {
+		return this.#g || this.#r.isDisposed();
+	}
+	dispose() {
+		this.outside(), this.#g = !0, this.#e = null, this.#t = "", this.#s.length = 0, this.#c = 0, this.#n.withdraw(), this.#r.dispose();
+	}
+	disposeAsync(e = !1) {
+		if (this.outside(), typeof e != "boolean") return Promise.reject(new t({ detail: "Invalid actual ownership withdrawal mode" }));
+		if (this.#C) return this.#C;
+		let n = [
+			...this.#T ? [this.#T] : [],
+			...this.#v ? [this.#v] : [],
+			...this.#x ? [this.#x] : [],
+			...this.#S ? [this.#S] : [],
+			...this.#m ? [this.#m] : []
+		];
+		this.dispose();
+		let r = (async () => {
+			let t = [], r = await Promise.allSettled(n);
+			t.push(...r.flatMap((e) => e.status === "rejected" ? [e.reason] : []));
+			for (let e of this.#u) try {
+				e(), this.#u.delete(e);
+			} catch (e) {
+				t.push(e);
+			}
+			let i = await Promise.allSettled([this.#r.disposeAsync(), ...[...this.#d.values()].map(async (n) => {
+				try {
+					await this.releaseSession(n, e);
+				} catch (e) {
+					t.push(e);
+				}
+			})]);
+			if (t.push(...i.flatMap((e) => e.status === "rejected" ? [e.reason] : [])), t.length) throw AggregateError(t, "Owned lockstep room cleanup remains incomplete");
+		})();
+		return this.#C = r, r.catch(() => {
+			this.#C = null;
+		}), r;
+	}
+};
+export { N as RoomLockstepOwnedRoom, A as isRoomLockstepOwnedRoom };