@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepTransport.js

@@ -0,0 +1,772 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { unsignedWord as r } from "./fixedWords.js";
+import { simulationOwnData as i } from "./simulationAuthoring.js";
+import { createSimulationOptionsCodec as a } from "./simulationOptionsWire.js";
+import { createSimulationInputHistoryCodec as o } from "./simulationInputHistoryWire.js";
+import { createSimulationRecoveryCodec as s } from "./simulationRecoveryWire.js";
+import { assertCapturedSimulation as c } from "./simulation.js";
+import { captureRoomLockstepServerOptions as l } from "./lockstepServerConfig.js";
+import { RoomInputCodec as u } from "./stateCodec.js";
+import { captureRoomLockstepWireRoster as d, roomLockstepStartBudgetRoster as f } from "./lockstepWireRoster.js";
+import { encodeRoomFrame as p } from "./wire.js";
+import { roomLockstepJournalRosterAt as m } from "./lockstepJournalPorts.js";
+import { captureLockstepJournalScope as h, createLockstepJournalCodec as g, extendsRoomLockstepJournal as _, lockstepJournalIdentity as v } from "./lockstepJournalCodec.js";
+import { captureRoomLockstepSessionPort as y } from "./serverSession.js";
+import { captureRoomLockstepTransportLimits as b } from "./lockstepTransportConfig.js";
+import { createRoomLockstepHostLoop as x } from "./lockstepHostLoop.js";
+import { Effect as S, Result as C } from "effect";
+// src/lockstepTransport.ts
+function w(e) {
+	throw new t({ detail: e });
+}
+var T = (e, t) => t !== null && Object.keys(e).every((n) => e[n] === t[n]), E = class {
+	id;
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	#c;
+	#l;
+	#u;
+	#d = /* @__PURE__ */ new Map();
+	#f = /* @__PURE__ */ new WeakMap();
+	#p;
+	#m = null;
+	#h = null;
+	#g = [];
+	#_;
+	#v = null;
+	#y = null;
+	#b = null;
+	#x = null;
+	#S = /* @__PURE__ */ new Map();
+	#C = [];
+	#w = [];
+	#T = null;
+	#E = !1;
+	#D = !1;
+	#O = !1;
+	#k = null;
+	#A = null;
+	constructor(e, t, o, d, p, m = {}, _ = {}, y = {}) {
+		if (c(e), this.#e = e, this.#a = r(t), typeof p != "function") throw new n({
+			room: "lockstep",
+			detail: "Transport owner requires the actual host clock"
+		});
+		this.#i = p;
+		let S = i(y, [
+			"redundantTicks",
+			"maxFlushWork",
+			"maxPendingWireBytes",
+			"maxRedundancyWireBytes",
+			"maxPendingHashResults",
+			"journal"
+		], []), { journal: C, ...T } = S, E = b(T);
+		if (this.#c = h(d), this.#_ = g(e, 65536, 67108864, 64), Object.hasOwn(S, "journal")) {
+			let e = i(S.journal, [
+				"service",
+				"runEffect",
+				"startRequestId"
+			], [
+				"service",
+				"runEffect",
+				"startRequestId"
+			]), t = i(e.service, [
+				"initialize",
+				"append",
+				"join",
+				"load",
+				"adopt",
+				"exportSubject",
+				"erase"
+			], [
+				"initialize",
+				"append",
+				"load",
+				"adopt",
+				"exportSubject",
+				"erase"
+			]);
+			(typeof e.runEffect != "function" || Object.values(t).some((e) => typeof e != "function")) && w("Durable transport requires a complete Journal capability and actual Effect runner");
+			let n = v(e.startRequestId);
+			n.length > 150 && w("Journal start request leaves no bounded immutable tick suffix"), this.#l = Object.freeze({
+				service: Object.freeze(Object.fromEntries(Object.entries(t).map(([t, n]) => [t, n.bind(e.service)]))),
+				runEffect: e.runEffect,
+				startRequestId: n
+			});
+		} else this.#l = null;
+		let D = l(m);
+		this.#s = Object.freeze(E), this.#p = D.limits.maxReplayTicks, this.#u = D.limits.hashHistoryTicks, this.#o = a(e).encode(o), this.#n = new u(e.definition.input, e.inputCodec.limits), this.#r = s(e, {
+			maxBytes: this.#s.maxPendingWireBytes,
+			maxTicks: 4096
+		});
+		let O = Object.getOwnPropertyDescriptor(m, "maxPlayers");
+		(O && (!O.enumerable || !("value" in O)) || !O && "maxPlayers" in m) && w("Start player budget requires own data without accessors"), this.frameBytes({
+			kind: "LsStart",
+			startTick: 0,
+			seed: this.#a,
+			options: this.#o,
+			serverTimeMs: 2 ** 53 - 1,
+			localPlayerId: 4294967295,
+			roster: f(O ? O.value : 8)
+		}), this.#t = x(e, t, o, d, p, m, _), this.id = this.#t.id;
+	}
+	live() {
+		if (this.#D || this.#t.isDisposed()) return w("Lockstep transport owner is withdrawn");
+	}
+	operation(e) {
+		if (this.#O) return w("Lockstep transport supervision cannot reenter active work");
+		this.#O = !0;
+		try {
+			return e();
+		} finally {
+			this.#O = !1;
+		}
+	}
+	current(e) {
+		if (!T(e.evidence, e.port.identity()) || e.port.inputSchemaHash() !== this.#n.schemaHash) return w("Lockstep transport requires the same current SQL-admitted Session and input layout");
+	}
+	deliverable(e) {
+		return e.port.identity() !== null && (this.current(e), !0);
+	}
+	frameBytes(e) {
+		let t = p(e, {
+			maxBytes: this.#s.maxPendingWireBytes,
+			maxInputs: 4096
+		});
+		if (C.isFailure(t)) throw t.failure;
+		return t.success.byteLength;
+	}
+	admit(e, t) {
+		return this.operation(() => {
+			if (this.live(), this.#E || this.#b) return w("Transport roster cannot admit after start or a durable start attempt");
+			let n = y(t), r = n.identity();
+			if (!r || !n.canActivate()) return w("Transport needs a live unbound welcomed player");
+			let i = this.#t.admit(e, t), a = Object.freeze({
+				actual: t,
+				port: n,
+				evidence: r,
+				player: i
+			});
+			return this.#S.set(i.playerId, a), i;
+		});
+	}
+	stageRecovery(e) {
+		this.operation(() => {
+			if (this.live(), this.#E || this.#S.size || this.#v) return w("Recovery requires a fresh private transport owner");
+			let t = this.#_.captureStored(e, this.#c);
+			if (!this.#l || !t.adoption || t.adoption.priorEpoch !== this.#c.epoch - 1 || t.initial.seed !== this.#a || t.initial.options !== Buffer.from(this.#o).toString("base64url") || t.initial.requestId !== this.#l.startRequestId) return w("Recovery journal changed actual initial ownership");
+			let n = this.#t.serverRole === "relay" || t.ticks.length <= this.#t.roleMetrics().refereeLagTicks, r = n && t.ticks.length ? this.inputHistory(t, this.#p) : null, i = d(m(t, t.ticks.length).map((e) => ({
+				slot: e.slot,
+				playerId: e.playerId
+			})));
+			if (n) for (let e of i) this.frameBytes({
+				kind: "LsStart",
+				startTick: t.ticks.length,
+				seed: this.#a,
+				options: this.#o,
+				serverTimeMs: 2 ** 53 - 1,
+				roster: i,
+				localPlayerId: e.playerId,
+				...r ? { history: r } : {}
+			});
+			this.#v = {
+				journal: t,
+				history: r,
+				cursor: 0,
+				sealed: !1,
+				replayed: !1
+			}, this.#y = t;
+		});
+	}
+	admitRecovered(e) {
+		return this.operation(() => {
+			this.live();
+			let t = this.#v;
+			if (!t || this.#E || this.#b) return w("Recovered roster is not awaiting genuine current Sessions");
+			let n = y(e), r = n.identity(), i = r ? m(t.journal, 2 ** 53 - 1).find((e) => e.sessionId === r.sessionId && e.subjectId === r.subjectId) : void 0;
+			if (!i || !r || !n.canActivate() || this.#S.has(i.playerId)) return w("Recovery requires its exact retained Subject/Seat with actual current Welcome");
+			let a = t.journal.joins?.some((e) => e.playerId === i.playerId) ?? !1 ? Object.freeze({
+				slot: i.slot,
+				playerId: i.playerId
+			}) : this.#t.admitAt({
+				slot: i.slot,
+				playerId: i.playerId
+			}, e), o = Object.freeze({
+				actual: e,
+				port: n,
+				evidence: r,
+				player: a
+			});
+			return this.#S.set(a.playerId, o), a;
+		});
+	}
+	rebindAsync(e) {
+		if (this.#m || this.#h || this.#x || this.#k || this.#O) return Promise.reject(new t({ detail: "Reconnect cannot overlap active transport supervision" }));
+		let n, r, i, a, o = this.#l, s = this.#y;
+		if (!o || !s) return Promise.reject(new t({ detail: "Reconnect requires a confirmed SQL Journal capability" }));
+		try {
+			this.operation(() => {
+				if (this.live(), !this.#E || !o || !s || this.#T || this.#g.length || this.#t.roleMetrics().pendingDeliveries > 0 || this.#w.length || s.ticks.length !== this.#t.metrics().tick) return w("Reconnect requires a fully confirmed durable current frontier");
+				let t = y(e), i = t.identity(), a = i ? [...this.#S.values()].find((e) => e.evidence.sessionId === i.sessionId && e.evidence.subjectId === i.subjectId) : void 0;
+				if (!i || !a || a.port.identity() !== null || !t.canActivate()) return w("Reconnect requires a withdrawn retained Seat and genuine current Welcome");
+				let c = m(s, 2 ** 53 - 1).find((e) => e.sessionId === i.sessionId && e.subjectId === i.subjectId);
+				if (!c || c.slot !== a.player.slot || c.playerId !== a.player.playerId) return w("Reconnect changed retained SQL player identity");
+				n = Object.freeze({
+					actual: e,
+					port: t,
+					evidence: i,
+					player: a.player
+				}), r = a;
+			});
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let c = async () => {
+			for (let e = 0; e < 2; e++) {
+				let t = this.#_.captureStored(await this.runJournal(o.service.load(this.#c)), this.#c, s.hostId);
+				if (this.live(), t.digest !== s.digest || this.#y !== s || this.#t.metrics().tick !== s.ticks.length) return w("Reconnect lost its exact current SQL journal frontier");
+				if (this.current(n), !n.port.canActivate() || r.port.identity() !== null) return w("Reconnect admission changed while confirming SQL");
+				e === 0 && this.operation(() => {
+					i = this.bootstrap(s, n.player.playerId), a = this.frameBytes(i);
+				});
+			}
+			return this.operation(() => {
+				if (this.live(), this.#T || this.#S.get(r.player.playerId) !== r) return w("Reconnect lost its retained delivery owner");
+				let t = this.#t.rebind(e);
+				return n.port.activate((e) => {
+					this.receive(n, e);
+				}, () => this.#t.metrics().tick), r.port.withdraw(), this.#S.set(t.playerId, n), this.#b &&= Object.freeze(this.#b.map((e) => e === r ? n : e)), this.#T = {
+					frame: i,
+					bytes: a,
+					targets: Object.freeze([n]),
+					next: 0
+				}, this.#g.push(...this.futureJoins(s, [n])), t;
+			});
+		};
+		return this.#m = Promise.resolve().then(c).finally(() => {
+			this.#m = null;
+		}), this.#m;
+	}
+	inputHistory(e, t) {
+		let n = e.ticks.length, r = (e.joins ?? []).filter((e) => e.tick <= n);
+		return o(this.#e, {
+			maxBytes: this.#s.maxPendingWireBytes,
+			maxTicks: t,
+			maxPlayers: 64
+		}).encode({
+			fromTick: 0,
+			playerIds: m(e, n).map((e) => e.playerId),
+			...r.length ? { joins: r.map((e) => ({
+				playerId: e.playerId,
+				tick: e.tick
+			})) } : {},
+			inputs: e.ticks.map((t) => {
+				let n = m(e, t.tick);
+				return {
+					tick: t.tick,
+					inputs: t.inputs.map((e, t) => ({
+						playerId: n[t].playerId,
+						input: this.#_.decodeInput(e)
+					}))
+				};
+			})
+		});
+	}
+	futureJoins(e, t) {
+		return (e.joins ?? []).filter((t) => t.tick > e.ticks.length).map((e) => {
+			let n = {
+				kind: "LsJoin",
+				tick: e.tick,
+				slot: e.slot,
+				playerId: e.playerId
+			};
+			return {
+				frame: n,
+				bytes: this.frameBytes(n),
+				targets: Object.freeze([...t]),
+				next: 0
+			};
+		});
+	}
+	bootstrap(e, t) {
+		if (this.live(), e.ticks.length !== this.#t.metrics().tick) return w("Bootstrap requires the exact confirmed actual authority frontier");
+		let n = this.#t.roleMetrics().refereeTick, r = n !== null && n > 0 ? this.#t.recovery() : null;
+		if (r) {
+			if ((e.joins ?? []).some((t) => t.tick > r.snapshot.tick && t.tick <= e.ticks.length)) return w("Snapshot bootstrap waits until the referee passes the latest late join");
+			for (let t of [{
+				tick: r.snapshot.tick,
+				inputs: r.inputs
+			}, ...r.continuation ?? []]) {
+				let n = e.ticks[t.tick - 1], r = m(e, t.tick);
+				if (!n || t.inputs.length !== r.length) return w("Snapshot bootstrap needs its exact confirmed SQL matrix base/tail");
+				for (let e of t.inputs) {
+					let t = r.findIndex((t) => t.playerId === e.playerId), i = this.#n.full(e.input);
+					if (t < 0 || C.isFailure(i) || this.#_.captureInput(i.success) !== n.inputs[t]) return w("Snapshot bootstrap changed actual SQL intentions");
+				}
+			}
+		}
+		let i = r ? this.#r.encode(r) : void 0, a = this.#v?.journal.digest === e.digest ? this.#v : null, o = !r && e.ticks.length ? a?.history?.slice() ?? this.inputHistory(e, this.#p) : void 0, s = Math.floor(this.#i());
+		return !Number.isSafeInteger(s) || s < 0 ? w("Bootstrap needs the actual monotonic host time") : {
+			kind: "LsStart",
+			startTick: e.ticks.length,
+			seed: this.#a,
+			options: this.#o.slice(),
+			serverTimeMs: s,
+			roster: d(m(e, e.ticks.length).map((e) => ({
+				slot: e.slot,
+				playerId: e.playerId
+			}))),
+			localPlayerId: t,
+			...o ? { history: o } : {},
+			...i ? { snapshot: i } : {}
+		};
+	}
+	start() {
+		return this.operation(() => {
+			if (this.live(), this.#l) return w("Durable transport must await startAsync SQL admission");
+			if (this.#E) return w("Lockstep transport is already started");
+			let e = [...this.#S.values()];
+			if (!e.length) return w("Lockstep start requires players");
+			for (let t of e) if (this.current(t), !t.port.canActivate()) return w("Lockstep Session was bound by another owner");
+			return this.queueStart(e);
+		});
+	}
+	queueStart(e, t = !1, n) {
+		let r = n?.serverTimeMs ?? Math.floor(this.#i());
+		if (!Number.isSafeInteger(r) || r < 0) return w("Invalid host start time");
+		let i = d(e.map((e) => ({
+			slot: e.player.slot,
+			playerId: e.player.playerId
+		}))), a = n ?? (t ? this.bootstrap(this.#v.journal, e[0].player.playerId) : {
+			kind: "LsStart",
+			startTick: 0,
+			seed: this.#a,
+			options: this.#o.slice(),
+			serverTimeMs: r,
+			roster: i,
+			localPlayerId: e[0].player.playerId
+		}), o = Math.max(...e.map((e) => this.frameBytes({
+			...a,
+			localPlayerId: e.player.playerId
+		})));
+		for (let t of e) if (this.current(t), !t.port.canActivate()) return w("Lockstep start lost its current Session");
+		let s = t ? Object.freeze(e.map((e) => e.player)) : this.#t.seal();
+		t || this.#t.finishBootstrap();
+		for (let t of e) if (this.current(t), !t.port.canActivate()) return w("Lockstep seal lost its unbound Session");
+		for (let t of e) t.port.activate((e) => {
+			this.receive(t, e);
+		}, () => this.#t.metrics().tick);
+		return this.#E = !0, this.#T = {
+			frame: a,
+			bytes: o,
+			targets: Object.freeze(e),
+			next: 0
+		}, s;
+	}
+	startAsync() {
+		if (!this.#l) return Promise.resolve().then(() => this.start());
+		if (this.#x || this.#O || this.#E) return Promise.reject(new t({ detail: "Durable start cannot overlap or restart a sealed owner" }));
+		let e = this.#l;
+		try {
+			this.operation(() => {
+				this.live();
+				let e = this.#b ?? Object.freeze([...this.#S.values()]);
+				if (!e.length) return w("Durable start requires actual players");
+				for (let t of e) if (this.current(t), !t.port.canActivate()) return w("Durable start lost an unbound current Session");
+				this.#b = e;
+			});
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let n = async () => {
+			if (this.#v) return this.startRecovered();
+			let t = this.#b;
+			this.live();
+			let n = this.#_.optionsWire.decode(this.#o);
+			this.live();
+			let r = e.service.initialize({
+				...this.#c,
+				requestId: e.startRequestId,
+				seed: this.#a,
+				options: n,
+				players: t.map((e) => ({
+					...e.player,
+					actualSession: e.actual
+				}))
+			}), i = await this.runJournal(r);
+			return this.operation(() => {
+				this.live();
+				let n = this.#_.captureStored(i, this.#c);
+				if (n.ownerEpoch !== this.#c.epoch || n.adoption !== null || n.ticks.length || n.initial.requestId !== e.startRequestId || n.initial.seed !== this.#a || n.initial.options !== Buffer.from(this.#o).toString("base64url") || n.initial.players.length !== t.length) return w("Durable start receipt is not the exact new SQL seed/roster");
+				for (let e = 0; e < t.length; e++) {
+					let r = t[e], i = n.initial.players[e];
+					if (this.current(r), i.slot !== r.player.slot || i.playerId !== r.player.playerId || i.subjectId !== r.evidence.subjectId || i.sessionId !== r.evidence.sessionId) return w("Durable start receipt changed actual admitted identity");
+				}
+				return this.#y = n, this.queueStart(t);
+			});
+		};
+		return this.#x = Promise.resolve().then(n).finally(() => {
+			this.#x = null;
+		}), this.#x;
+	}
+	async startRecovered() {
+		let e = this.#v, t = this.#b, n = this.#l, r = m(e.journal, 2 ** 53 - 1).map((e) => t.find((t) => t.player.playerId === e.playerId));
+		if (r.length !== t.length || r.some((e) => !e)) return w("Recovery Start requires every retained genuine Session");
+		let i = r, a = async () => {
+			if (this.#_.captureStored(await this.runJournal(n.service.load(this.#c)), this.#c, e.journal.hostId).digest !== e.journal.digest) return w("Recovery Start lost its actual current SQL journal");
+			for (let e of i) if (this.current(e), !e.port.canActivate()) return w("Recovery Start lost its actual unbound Session");
+		};
+		if (await a(), this.live(), !e.sealed) {
+			this.#t.seal();
+			for (let t of e.journal.joins ?? []) this.#t.join({
+				slot: t.slot,
+				playerId: t.playerId
+			}, i.find((e) => e.player.playerId === t.playerId).actual, t.tick);
+			e.sealed = !0;
+		}
+		for (; e.cursor < e.journal.ticks.length; e.cursor++) {
+			let t = e.journal.ticks[e.cursor], n = m(e.journal, t.tick);
+			this.#t.replayMatrix(t.tick, n.map((e) => i.find((t) => t.player.playerId === e.playerId).actual), t.inputs.map((e) => Uint8Array.from(Buffer.from(e, "base64url"))));
+		}
+		e.replayed ||= (this.#t.finishBootstrap(), !0);
+		let o = this.operation(() => this.bootstrap(e.journal, i[0].player.playerId));
+		return this.frameBytes(o), await a(), this.live(), this.operation(() => {
+			let t = this.queueStart(i, !0, o);
+			return this.#g.push(...this.futureJoins(e.journal, i)), t;
+		});
+	}
+	retains(e) {
+		let t = y(e).identity();
+		return t !== null && [...this.#S.values()].some((e) => e.evidence.sessionId === t.sessionId && e.evidence.subjectId === t.subjectId);
+	}
+	lateJoinReady() {
+		let e = this.#y;
+		if (this.#D || !this.#E || !this.#l?.service.join || !e || this.#m || this.#h || this.#x || this.#k || this.#O || this.#T || this.#g.length || this.#t.roleMetrics().pendingDeliveries > 0 || this.#w.length || e.ticks.length !== this.#t.metrics().tick) return !1;
+		let t = this.#t.roleMetrics().refereeTick;
+		return t === null || t === 0 || !(e.joins ?? []).some((e) => e.tick > t);
+	}
+	joinAsync(e, n, i) {
+		if (this.#m || this.#h || this.#x || this.#k || this.#O) return Promise.reject(new t({ detail: "Late join cannot overlap active transport supervision" }));
+		let a = this.#l, o = this.#y, s = a?.service.join;
+		if (!a || !o || !s) return Promise.reject(new t({ detail: "Late join requires a confirmed SQL Journal with join support" }));
+		let c, l, u, d;
+		try {
+			this.operation(() => {
+				if (this.live(), !this.#E || this.#T || this.#g.length || this.#t.roleMetrics().pendingDeliveries > 0 || this.#w.length || o.ticks.length !== this.#t.metrics().tick) return w("Late join requires a fully confirmed durable current frontier");
+				if (!Number.isSafeInteger(i) || i < 1 || i > 4096) return w("Late join lead must be 1..4096 ticks");
+				let t = y(e), a = t.identity(), s = m(o, 2 ** 53 - 1);
+				if (!a || !t.canActivate() || s.some((e) => e.sessionId === a.sessionId || e.playerId === n)) return w("Late join requires a new player with a genuine current Welcome");
+				let f = 0;
+				for (; s.some((e) => e.slot === f);) f++;
+				d = o.ticks.length + i, c = Object.freeze({
+					actual: e,
+					port: t,
+					evidence: a,
+					player: Object.freeze({
+						slot: f,
+						playerId: r(n)
+					})
+				}), l = this.bootstrap(o, c.player.playerId), u = this.frameBytes(l);
+			});
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let f = async () => {
+			let t = await this.runJournal(s({
+				...this.#c,
+				requestId: `${a.startRequestId}::join:${c.player.playerId}`,
+				tick: d,
+				player: {
+					...c.player,
+					actualSession: e
+				}
+			}));
+			return this.operation(() => {
+				this.live();
+				let n = this.#_.captureStored(t, this.#c, o.hostId), r = n.joins?.find((e) => e.playerId === c.player.playerId);
+				if (this.#y !== o || this.#T || this.#g.length || this.#t.metrics().tick !== o.ticks.length || JSON.stringify(n.ticks) !== JSON.stringify(o.ticks) || JSON.stringify(n.initial) !== JSON.stringify(o.initial) || !r || r.tick !== d || r.slot !== c.player.slot || r.subjectId !== c.evidence.subjectId || r.sessionId !== c.evidence.sessionId) return w("Late join receipt changed the confirmed frontier or admitted identity");
+				if (this.current(c), !c.port.canActivate()) return w("Late join lost its unbound Session");
+				let i = Object.freeze([...this.#S.values()].filter((e) => this.deliverable(e))), a = this.#t.join(c.player, e, d);
+				return c.port.activate((e) => {
+					this.receive(c, e);
+				}, () => this.#t.metrics().tick), this.#S.set(a.playerId, c), this.#y = n, this.#T = {
+					frame: l,
+					bytes: u,
+					targets: Object.freeze([c]),
+					next: 0
+				}, this.#g.push(...this.futureJoins(n, [c]).map((e) => e.frame.playerId === a.playerId ? {
+					...e,
+					targets: Object.freeze([...i, c])
+				} : e)), a;
+			});
+		};
+		return this.#h = Promise.resolve().then(f).finally(() => {
+			this.#h = null;
+		}), this.#h;
+	}
+	runJournal(e) {
+		return !this.#l || !S.isEffect(e) ? Promise.reject(new t({ detail: "Journal must return an actual Effect" })) : this.#l.runEffect(S.uninterruptible(e));
+	}
+	receive(t, n) {
+		this.operation(() => {
+			if (this.live(), this.current(t), n.kind === "LsInput") {
+				this.#t.submit(t.actual, n.firstTick, n.inputs);
+				return;
+			}
+			if (this.#t.serverRole === "relay") return n.tick < 1 || n.tick > this.#t.metrics().tick ? w("Relay hash is outside actual confirmed input history") : void 0;
+			if (this.#w.length >= this.#s.maxPendingHashResults) throw new e({
+				budget: "lockstepWireHashResults",
+				limit: this.#s.maxPendingHashResults
+			});
+			let r = `${n.tick}/${t.player.playerId}`;
+			if (!this.#d.has(r) && this.#d.size >= this.#s.maxPendingHashResults) throw new e({
+				budget: "lockstepWireHashSources",
+				limit: this.#s.maxPendingHashResults
+			});
+			let i = this.#t.submitHash(t.actual, n.tick, {
+				hi: n.hi,
+				lo: n.lo
+			});
+			i._tag === "pending" && this.#d.set(r, Object.freeze({
+				tick: n.tick,
+				peer: t
+			})), i._tag === "desync" && (this.#f.set(i, t), this.#w.push(i));
+		});
+	}
+	advance() {
+		return this.operation(() => (this.live(), this.#m || this.#h ? 0 : this.#t.advance()));
+	}
+	prepareNext() {
+		return this.operation(() => {
+			if (this.live(), this.#T) return !0;
+			let t = this.#g.shift();
+			if (t) return this.#T = t, !0;
+			let n = this.#t.nextDelivery();
+			if (n) {
+				let t = Object.freeze([...this.#S.values()].filter((e) => this.deliverable(e))), r, i;
+				if (n._tag === "relayed") {
+					let t = n.inputs.map((e) => {
+						let t = this.#n.full(e.input);
+						if (C.isFailure(t)) throw t.failure;
+						return t.success;
+					}), a = Object.freeze({
+						players: n.players,
+						inputs: Object.freeze(t)
+					}), o = {
+						tick: n.tick,
+						matrix: a,
+						bytes: t.reduce((e, t) => e + t.length, 8)
+					};
+					if (i = [...this.#C, o].slice(-this.#s.redundantTicks), i.some((e, t) => t > 0 && e.tick !== i[t - 1].tick + 1)) return w("Redundant authority matrices are not contiguous");
+					if (i.reduce((e, t) => e + t.bytes, 0) > this.#s.maxRedundancyWireBytes) throw new e({
+						budget: "lockstepWireRedundancy",
+						limit: this.#s.maxRedundancyWireBytes
+					});
+					r = {
+						kind: "LsInputs",
+						firstTick: i[0].tick,
+						matrices: Object.freeze(i.map((e) => e.matrix))
+					};
+				} else r = {
+					kind: "LsStall",
+					waitingFor: n.waitingFor
+				};
+				let a = this.frameBytes(r);
+				for (let e of t) this.current(e);
+				let o = n._tag === "relayed" && this.#l ? Object.freeze({
+					...this.#c,
+					requestId: `${this.#l.startRequestId}::tick:${n.tick}`,
+					tick: n.tick,
+					inputs: Object.freeze(i[i.length - 1].matrix.inputs.map((e) => e.slice()))
+				}) : void 0;
+				return this.#T = {
+					frame: r,
+					bytes: a,
+					targets: t,
+					next: 0,
+					prepared: {
+						delivery: n,
+						...i ? { history: i } : {},
+						...o ? { append: o } : {}
+					}
+				}, !0;
+			}
+			let r = this.#t.roleMetrics().refereeTick;
+			if (r !== null) for (let [e, t] of this.#d) t.tick <= r - this.#u && this.#d.delete(e);
+			if (!this.#w.length && this.#t.serverRole !== "relay") {
+				let e = this.#t.comparePendingHashes(1);
+				if (e.length) {
+					for (let t of e) {
+						let e = t._tag === "desync" ? `${t.incident.tick}/${t.incident.playerId}` : `${t.tick}/${t.playerId}`, n = this.#d.get(e);
+						if (t._tag === "desync") {
+							if (!n) return w("Delayed hash result lost its actual Session provenance");
+							this.#f.set(t, n.peer), this.#w.push(t);
+						}
+						this.#d.delete(e);
+					}
+					if (!this.#w.length) return !0;
+				}
+			}
+			let i = this.#w[0];
+			if (!i || i._tag !== "desync") return !1;
+			let a = this.#f.get(i);
+			if (!a) return w("Desync result has no actual submitted Session provenance");
+			if (!this.deliverable(a)) return this.#w.shift(), !0;
+			let o = i.action === "resync" ? {
+				kind: "LsDesync",
+				tick: i.incident.tick,
+				action: "resync",
+				snapshot: this.#r.encode({
+					snapshot: i.snapshot,
+					inputs: i.inputs,
+					continuation: i.continuation
+				})
+			} : {
+				kind: "LsDesync",
+				tick: i.incident.tick,
+				action: i.action
+			}, s = this.frameBytes(o);
+			return this.current(a), this.#w.shift(), this.#T = {
+				frame: o,
+				bytes: s,
+				targets: Object.freeze([a]),
+				next: 0
+			}, !0;
+		});
+	}
+	async commitPrepared(e) {
+		let t = e.prepared;
+		if (t) {
+			if (t.append && !t.durable) {
+				this.live();
+				let n = this.#y;
+				if (!n || !this.#l) return w("No initialized SQL input journal");
+				let r = await this.runJournal(this.#l.service.append({
+					...t.append,
+					inputs: Object.freeze(t.append.inputs.map((e) => e.slice()))
+				}));
+				this.operation(() => {
+					if (this.live(), this.#T !== e) return w("Journal completion lost its retained delivery owner");
+					let i = this.#_.captureStored(r, this.#c, n.hostId), a = t.append.tick, o = i.ticks[a - 1];
+					if (i.ticks.length !== a || JSON.stringify(i.initial) !== JSON.stringify(n.initial) || JSON.stringify(i.adoption) !== JSON.stringify(n.adoption) || !_(i, n) || !o || o.requestId !== t.append.requestId || o.inputs.length !== t.append.inputs.length || o.inputs.some((e, n) => e !== this.#_.captureInput(t.append.inputs[n]))) return w("Journal receipt changed its immutable seed/prefix or current matrix");
+					this.#y = i, t.durable = !0;
+				});
+			}
+			this.operation(() => {
+				if (this.live(), this.#T !== e) return w("Prepared delivery lost its owner");
+				for (let t of e.targets) this.deliverable(t);
+				this.#t.consumeDelivery(t.delivery), t.history && (this.#C = t.history), delete e.prepared;
+			});
+		}
+	}
+	flush() {
+		if (this.#k || this.#m || this.#h || this.#O) return Promise.reject(new t({ detail: "Lockstep flush cannot overlap or reenter supervision" }));
+		if (this.live(), !this.#E) return Promise.resolve(Object.freeze({
+			writes: 0,
+			pending: !1
+		}));
+		let e = async () => {
+			let e = 0;
+			for (let t = 0; t < this.#s.maxFlushWork && !this.#D && (this.#T || this.prepareNext()); t++) {
+				let t = this.#T;
+				if (!t) continue;
+				if (await this.commitPrepared(t), this.#D) break;
+				let n = t.targets[t.next];
+				if (!n) this.#T = null;
+				else if (!this.deliverable(n)) t.next++, t.next === t.targets.length && (this.#T = null);
+				else {
+					if (await n.port.send(t.frame.kind === "LsStart" ? {
+						...t.frame,
+						localPlayerId: n.player.playerId
+					} : t.frame), this.#D) break;
+					this.deliverable(n), t.next++, e++, t.next === t.targets.length && (this.#T = null);
+				}
+			}
+			return Object.freeze({
+				writes: e,
+				pending: this.#T !== null || this.#g.length > 0 || this.#t.roleMetrics().pendingDeliveries > 0 || this.#w.length > 0
+			});
+		};
+		return this.#k = Promise.resolve().then(e).finally(() => {
+			this.#k = null;
+		}), this.#k;
+	}
+	retryFault() {
+		this.operation(() => {
+			this.live(), this.#t.retryFault();
+		});
+	}
+	drainOutbox() {
+		return this.#t.drainOutbox();
+	}
+	metrics() {
+		return this.#t.metrics();
+	}
+	journalBoundary() {
+		if (this.live(), !this.#l || this.#O || this.#k || this.#x || this.#m || this.#h || this.#T || this.#g.length || this.#t.roleMetrics().pendingDeliveries || this.#w.length || this.#b && !this.#E) return w("Lockstep journal boundary requires completed retained supervision");
+		let e = this.#y?.ticks.length ?? 0;
+		return this.#E && e !== this.#t.metrics().tick ? w("Lockstep journal does not cover the actual simulated frontier") : Object.freeze({
+			digest: this.#y?.digest ?? null,
+			tick: e
+		});
+	}
+	transportMetrics() {
+		return Object.freeze({
+			...this.#t.roleMetrics(),
+			started: this.#E,
+			disposed: this.#D,
+			pendingWireBytes: this.#T?.bytes ?? 0,
+			pendingTargets: this.#T ? this.#T.targets.length - this.#T.next : 0,
+			redundancyTicks: this.#C.length,
+			redundancyWireBytes: this.#C.reduce((e, t) => e + t.bytes, 0),
+			pendingHashResults: this.#w.length,
+			pendingHashSources: this.#d.size,
+			reconnecting: this.#m !== null,
+			joining: this.#h !== null,
+			queuedFrames: this.#g.length,
+			flushing: this.#k !== null,
+			journaled: this.#l !== null,
+			journalTick: this.#y?.ticks.length ?? 0,
+			initializing: this.#x !== null
+		});
+	}
+	exportSubject(e, t) {
+		return this.operation(() => this.#t.exportSubject(e, t));
+	}
+	async eraseSubject(e, t) {
+		let n = this.operation(() => this.#t.eraseSubject(e, t));
+		return n && await this.disposeAsync(), n;
+	}
+	release() {
+		if (!this.#D) {
+			this.#D = !0;
+			for (let e of this.#S.values()) e.port.withdraw();
+			this.#v?.history?.fill(0), this.#v = null, this.#t.dispose(), this.#S.clear(), this.#C = [], this.#w = [], this.#d.clear(), this.#f = /* @__PURE__ */ new WeakMap(), this.#T = null, this.#g = [], this.#y = null, this.#b = null, this.#o.fill(0);
+		}
+	}
+	dispose() {
+		this.operation(() => this.release());
+	}
+	disposeAsync() {
+		if (this.#A) return this.#A;
+		let e = [
+			this.#k ?? Promise.resolve(),
+			this.#x ?? Promise.resolve(),
+			this.#m ?? Promise.resolve(),
+			this.#h ?? Promise.resolve()
+		];
+		return this.dispose(), this.#A = (async () => {
+			let t = (await Promise.allSettled(e)).find((e) => e.status === "rejected");
+			if (t?.status === "rejected") throw t.reason;
+		})(), this.#A;
+	}
+	isDisposed() {
+		return this.#D || this.#t.isDisposed();
+	}
+}, D = (e, t, n, r, i, a = {}, o = {}, s = {}) => new E(e, t, n, r, i, a, o, s);
+export { E as RoomLockstepTransportOwner, D as createRoomLockstepTransportOwner };