@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstep.js

@@ -0,0 +1,381 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError 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 { schemaSimulationHash as s } from "./simulationState.js";
+import { createSimulationInputHistoryCodec as c } from "./simulationInputHistoryWire.js";
+import { captureSimulationRecoveryContinuation as l } from "./simulationRecoveryWire.js";
+import { SimulationRunner as u, assertCapturedSimulation as d, captureSimulationInputs as f, captureSimulationSnapshot as p } from "./simulation.js";
+import { LockstepPolicyOwner as m, createLockstepPolicies as h } from "./lockstepPolicies.js";
+import { repeatLastLockstepInput as g } from "./lockstepStrategies.js";
+import { RoomLockstepClientSession as _, createRoomLockstepClientSession as v, isRoomLockstepClientSession as y } from "./lockstepClientSession.js";
+// src/lockstep.ts
+function b(e) {
+	throw new n({
+		room: "lockstep",
+		detail: e
+	});
+}
+var x = (t, n) => {
+	let r = t + n;
+	if (!Number.isSafeInteger(r)) throw new e({
+		budget: "lockstepCounter",
+		limit: 2 ** 53 - 1
+	});
+	return r;
+}, S = (e) => {
+	let t = a(e, [
+		"inputDelayTicks",
+		"rollbackHorizonTicks",
+		"maxFutureTicks",
+		"maxPlayers",
+		"maxRejectionAttempts",
+		"inputPrediction"
+	], []), n = (e, n) => Object.hasOwn(t, e) ? t[e] : n, r = n("inputDelayTicks", 2), i = n("maxFutureTicks", 16), o = n("rollbackHorizonTicks", 8), s = n("maxPlayers", 8), c = n("maxRejectionAttempts", 64);
+	for (let e of [
+		r,
+		i,
+		o,
+		s,
+		c
+	]) if (!Number.isSafeInteger(e)) return b("Lockstep tick/player/RNG budgets must be integers");
+	if (r < 0 || r > i || i < 1 || i > 4096 || o < 1 || o > 4096 || s < 1 || s > 64 || c < 1 || c > 65536) return b("Lockstep tick/player/RNG budgets are outside their work limits");
+	let l = n("inputPrediction", "repeat-last");
+	return l !== "repeat-last" && l !== "none" && typeof l != "function" ? b("Unknown lockstep input prediction") : Object.freeze({
+		inputDelayTicks: r,
+		maxFutureTicks: i,
+		rollbackHorizonTicks: o,
+		maxPlayers: s,
+		maxRejectionAttempts: c,
+		inputPrediction: l
+	});
+}, C = (e, t) => {
+	d(e);
+	let n = a(t, [
+		"localPlayerId",
+		"initialInputs",
+		"playerIds",
+		"inputDelayTicks",
+		"rollbackHorizonTicks",
+		"maxFutureTicks",
+		"maxPlayers",
+		"maxRejectionAttempts",
+		"inputPrediction",
+		"lateJoin"
+	], ["localPlayerId"]), { localPlayerId: i, initialInputs: o, playerIds: s, lateJoin: c, ...l } = n;
+	if (c !== void 0 && typeof c != "boolean") return b("Lockstep lateJoin must be a boolean");
+	let u = c === !0, p = S(l), m = p.maxPlayers, h = r(n.localPlayerId), g = Object.hasOwn(n, "initialInputs") ? f(e, n.initialInputs, m) : Object.freeze([]);
+	if (Object.hasOwn(n, "initialInputs") && !g.length) return b("Authored initial intentions require a nonempty complete matrix");
+	let _ = g.map((e) => e.playerId);
+	if (Object.hasOwn(n, "playerIds")) {
+		let e = n.playerIds;
+		if (!Array.isArray(e) || !e.length || e.length > m || Reflect.ownKeys(e).length !== e.length + 1) return b("Lockstep requires a bounded dense explicit player roster");
+		let t = [], i = /* @__PURE__ */ new Set();
+		for (let n = 0; n < e.length; n++) {
+			let a = Object.getOwnPropertyDescriptor(e, String(n));
+			if (!a?.enumerable || !("value" in a)) return b("Player roster holes and accessors refuse");
+			let o = r(a.value);
+			if (i.has(o)) return b("Player roster IDs must be unique");
+			i.add(o), t.push(o);
+		}
+		if (t.sort((e, t) => e - t), _ = Object.freeze(t), g.length && (g.length !== _.length || g.some((e, t) => e.playerId !== _[t]))) return b("Initial intentions must match the complete explicit roster");
+	}
+	return !_.length || _.includes(h) === u || u && g.length ? b(u ? "A late-joining local player is not in the Start roster and has no initial matrix" : "Lockstep requires a complete explicit roster including the local player") : Object.freeze({
+		...p,
+		localPlayerId: h,
+		initialInputs: g,
+		playerIds: Object.freeze([..._]),
+		lateJoin: u
+	});
+}, w = (e, t) => {
+	if (e === t) return !0;
+	if (!e || !t || typeof e != "object" || typeof t != "object" || Array.isArray(e) !== Array.isArray(t)) return !1;
+	let n = Reflect.ownKeys(e), r = Reflect.ownKeys(t);
+	return n.length === r.length && n.every((n) => Object.hasOwn(t, n) && w(Object.getOwnPropertyDescriptor(e, n)?.value, Object.getOwnPropertyDescriptor(t, n)?.value));
+}, T = class {
+	#e;
+	#t;
+	#n;
+	#r = [];
+	#i;
+	#a;
+	#o;
+	#s;
+	#c = /* @__PURE__ */ new Map();
+	#l = /* @__PURE__ */ new Map();
+	#u = /* @__PURE__ */ new Map();
+	#d = 0;
+	#f = 0;
+	#p = !1;
+	#m = !1;
+	#h = Object.freeze({
+		rollbackReplays: 0,
+		rollbackSteps: 0,
+		stallAttempts: 0
+	});
+	constructor(e, t, n, r) {
+		let i = C(e, r), a = i.initialInputs;
+		this.#e = e, this.#i = i.localPlayerId, this.#a = i.inputDelayTicks, this.#o = i.maxFutureTicks, this.#s = i.inputPrediction, this.#n = i.playerIds, a.length && this.#c.set(0, a), this.#t = new u(e, t, n, {
+			rollbackHorizonTicks: i.rollbackHorizonTicks,
+			maxReplaySteps: i.rollbackHorizonTicks,
+			maxPlayers: i.maxPlayers,
+			maxRejectionAttempts: i.maxRejectionAttempts
+		});
+	}
+	get tick() {
+		return this.#t.tick;
+	}
+	get confirmedThroughTick() {
+		return this.#d;
+	}
+	get metrics() {
+		return this.#h;
+	}
+	snapshot() {
+		return this.#t.snapshot();
+	}
+	confirmedSnapshot(e) {
+		return this.work(() => (r(e), e < 1 || !this.#l.has(e) ? b("Client hash requires an actual retained confirmed matrix") : this.#t.snapshotAt(e)));
+	}
+	installServerSnapshot(t, n, r = []) {
+		return this.work(() => {
+			let a = p(this.#e, t), o = n === void 0 ? a.tick === 0 ? this.#c.get(0) : this.#l.get(a.tick) : n;
+			if (!o || n === void 0 && a.tick > this.#d) return b("Server resync requires the actual retained confirmed input base");
+			let s = this.completeMatrix(o, a.tick), c = l(this.#e, a.tick, s, r, this.#o), u = c.length ? c[c.length - 1].tick : a.tick, d = /* @__PURE__ */ new Map();
+			for (let [t, n] of this.#u) if (t > a.tick) {
+				if (t > u + this.#o) throw new e({
+					budget: "lockstepRecoveryLocalFutureTicks",
+					limit: this.#o
+				});
+				d.set(t, i(this.#e.inputCodec.capture(n)));
+			}
+			let f = new Map(c.map((e) => [e.tick, this.completeMatrix(e.inputs, e.tick)])), m = this.#t.installSnapshot(a, s);
+			return this.#c = /* @__PURE__ */ new Map([[a.tick, s]]), this.#l = f, this.#u = d, this.#d = u, this.#f = 0, m;
+		});
+	}
+	installConfirmedHistory(e, t = {}) {
+		return this.work(() => {
+			if (this.tick !== 0 || this.#d !== 0 || this.#l.size || this.#u.size || this.#p) return b("Seed history requires a fresh unprogressed client without local samples");
+			let n = c(this.#e, t).capture(e), r = this.rosterAt(2 ** 53 - 1), i = n.joins ?? [];
+			if (n.fromTick !== 0 || n.playerIds.length !== r.length || n.playerIds.some((e, t) => e !== r[t]) || i.length !== this.#r.length || i.some((e) => !this.#r.some((t) => t.playerId === e.playerId && t.tick === e.tick))) return b("Seed history must name the actual complete initial roster from tick0");
+			let a = new Map(n.inputs.map((e) => [e.tick, e.inputs]));
+			return this.#l = a, this.#d = n.inputs.length, this.#f = this.#d, this.#p = !0, this.#d;
+		});
+	}
+	work(e) {
+		if (this.#m) return b("Lockstep mutation cannot reenter prediction, step or replay");
+		this.#m = !0;
+		try {
+			return e();
+		} finally {
+			this.#m = !1;
+		}
+	}
+	captureMatrix(t, n = this.#n.length) {
+		if (!Array.isArray(t) || t.length > n) throw new e({
+			budget: "lockstepPlayers",
+			limit: n
+		});
+		if (Reflect.ownKeys(t).length !== t.length + 1) return b("Lockstep input matrix requires dense own data");
+		let o = [], s = /* @__PURE__ */ new Set();
+		for (let e = 0; e < t.length; e++) {
+			let n = Object.getOwnPropertyDescriptor(t, String(e));
+			if (!n?.enumerable || !("value" in n)) return b("Lockstep matrix holes and accessors refuse");
+			let c = a(n.value, ["playerId", "input"], ["playerId", "input"]), l = r(c.playerId);
+			if (s.has(l)) return b("Lockstep player IDs must be unique");
+			s.add(l), o.push(Object.freeze({
+				playerId: l,
+				input: i(this.#e.inputCodec.capture(c.input))
+			}));
+		}
+		return o.sort((e, t) => e.playerId - t.playerId), Object.freeze(o);
+	}
+	rosterAt(e) {
+		return this.#r.length ? [...this.#n, ...this.#r.filter((t) => t.tick <= e).map((e) => e.playerId)].sort((e, t) => e - t) : this.#n;
+	}
+	completeMatrix(e, t) {
+		let n = this.rosterAt(t), r = this.captureMatrix(e, n.length);
+		return r.length !== n.length || r.some((e, t) => e.playerId !== n[t]) ? b("Confirmed matrix must match the complete roster of its tick") : r;
+	}
+	join(e, t) {
+		this.work(() => {
+			if (r(e), r(t), e <= this.#d || this.rosterAt(2 ** 53 - 1).includes(t) || this.rosterAt(2 ** 53 - 1).length >= this.#t.limits.maxPlayers) return b("Late join must be ahead of the confirmed frontier, new and within the player budget");
+			if (this.#r.some((t) => t.tick > e)) return b("Late joins arrive in tick order");
+			this.#r.push(Object.freeze({
+				tick: e,
+				playerId: t
+			}));
+		});
+	}
+	matrix(e, t, n) {
+		let r = n ?? this.#l.get(e);
+		if (r) return {
+			inputs: r,
+			predicted: [],
+			missing: []
+		};
+		let a = [], s = [], c = [];
+		for (let n of t) {
+			if (n.playerId === this.#i && this.#u.has(e)) {
+				a.push(Object.freeze({
+					playerId: n.playerId,
+					input: this.#u.get(e)
+				}));
+				continue;
+			}
+			if (this.#s === "none") {
+				c.push(n.playerId);
+				continue;
+			}
+			let t = Object.freeze({
+				playerId: n.playerId,
+				tick: e
+			}), r = this.#s === "repeat-last" ? g(n.input, t) : this.#s(n.input, t);
+			a.push(Object.freeze({
+				playerId: n.playerId,
+				input: i(this.#e.inputCodec.capture(o(r)))
+			})), s.push(n.playerId);
+		}
+		for (let n of this.rosterAt(e)) t.some((e) => e.playerId === n) || (n === this.#i && this.#u.has(e) ? a.push(Object.freeze({
+			playerId: n,
+			input: this.#u.get(e)
+		})) : this.#s === "none" && c.push(n));
+		return a.sort((e, t) => e.playerId - t.playerId), {
+			inputs: Object.freeze(a),
+			predicted: Object.freeze(s),
+			missing: Object.freeze(c)
+		};
+	}
+	prune() {
+		let e = this.#t.oldestTick;
+		for (let t of [
+			this.#c,
+			this.#l,
+			this.#u
+		]) for (let n of t.keys()) n < e && t.delete(n);
+	}
+	submitLocal(e) {
+		return this.work(() => {
+			if (this.tick < this.#f) return b("Consume retained confirmed history before sampling current intentions");
+			let t = r(this.tick + Math.max(1, this.#a));
+			if (this.#l.has(t)) return b("Local intent cannot replace an admitted server matrix");
+			let n = i(this.#e.inputCodec.capture(e)), a = Object.freeze({
+				tick: t,
+				input: n
+			});
+			return this.#u.set(t, n), a;
+		});
+	}
+	recentLocalInputs(e = 4) {
+		return !Number.isSafeInteger(e) || e < 1 || e > 64 ? b("Lockstep input redundancy requires a count from 1 through 64") : Object.freeze([...this.#u.entries()].sort((e, t) => e[0] - t[0]).slice(-e).map(([e, t]) => Object.freeze({
+			tick: e,
+			input: i(this.#e.inputCodec.capture(t))
+		})));
+	}
+	advance() {
+		return this.work(() => {
+			let e = r(this.tick + 1), t = this.#c.get(this.tick);
+			if (!t && this.tick !== 0) return b("Lockstep previous input matrix is unavailable");
+			if (!t && !this.#l.has(e)) return this.#h = Object.freeze({
+				...this.#h,
+				stallAttempts: x(this.#h.stallAttempts, 1)
+			}), Object.freeze({
+				_tag: "stalled",
+				tick: e,
+				reason: "inputs",
+				missingTick: e,
+				waitingFor: this.rosterAt(e)
+			});
+			if (e > this.#d + this.#t.limits.rollbackHorizonTicks) return this.#h = Object.freeze({
+				...this.#h,
+				stallAttempts: x(this.#h.stallAttempts, 1)
+			}), Object.freeze({
+				_tag: "stalled",
+				tick: e,
+				reason: "horizon",
+				missingTick: this.#d + 1,
+				waitingFor: this.rosterAt(this.#d + 1)
+			});
+			let n = t ? this.matrix(e, t) : {
+				inputs: this.#l.get(e),
+				predicted: [],
+				missing: []
+			};
+			if (n.missing.length) return this.#h = Object.freeze({
+				...this.#h,
+				stallAttempts: x(this.#h.stallAttempts, 1)
+			}), Object.freeze({
+				_tag: "stalled",
+				tick: e,
+				reason: "inputs",
+				missingTick: e,
+				waitingFor: n.missing
+			});
+			let i = this.#t.advance(n.inputs);
+			return this.#c.set(e, n.inputs), this.prune(), Object.freeze({
+				_tag: "advanced",
+				snapshot: i,
+				predictedPlayers: n.predicted
+			});
+		});
+	}
+	confirm(n, i) {
+		return this.work(() => {
+			if (r(n), n <= this.#t.oldestTick) return Object.freeze({
+				_tag: "expired",
+				tick: n,
+				oldestTick: this.#t.oldestTick
+			});
+			if (n > Math.max(this.tick, this.#f) + this.#o) throw new e({
+				budget: "lockstepFutureTicks",
+				limit: this.#o
+			});
+			let a = this.completeMatrix(i, n), o = this.#l.get(n);
+			if (o) {
+				if (!w(o, a)) throw new t({ detail: "Conflicting lockstep input matrix for an admitted tick" });
+				return Object.freeze({
+					_tag: "duplicate",
+					tick: n
+				});
+			}
+			let s = Object.freeze({
+				_tag: "queued",
+				tick: n
+			}), c = [], l = this.#h;
+			if (n <= this.tick) {
+				let e = this.#c.get(n);
+				if (!e) return b("Lockstep used input history is unavailable");
+				if (w(e, a)) s = Object.freeze({
+					_tag: "matched",
+					tick: n
+				});
+				else {
+					let e = this.#c.get(n - 1);
+					if (!e) return b("Lockstep rollback input base is unavailable");
+					for (let t = n; t <= this.tick; t++) {
+						let r = this.matrix(t, e, t === n ? a : void 0);
+						if (r.missing.length) return b("Lockstep replay cannot invent missing inputs");
+						c.push(Object.freeze({
+							tick: t,
+							inputs: r.inputs
+						})), e = r.inputs;
+					}
+					let t = this.tick - n + 1;
+					l = Object.freeze({
+						...this.#h,
+						rollbackReplays: x(this.#h.rollbackReplays, 1),
+						rollbackSteps: x(this.#h.rollbackSteps, t)
+					}), this.#t.replaceInputsRange(c), s = Object.freeze({
+						_tag: "replayed",
+						tick: n,
+						steps: t
+					});
+				}
+			}
+			this.#l.set(n, a);
+			for (let e of c) this.#c.set(e.tick, e.inputs);
+			for (this.#h = l; this.#l.has(this.#d + 1);) this.#d++;
+			return this.prune(), s;
+		});
+	}
+}, E = (e, t, n, r) => new T(e, t, n, r);
+export { T as LockstepClientSimulation, m as LockstepPolicyOwner, _ as RoomLockstepClientSession, C as captureLockstepClientOptions, S as captureLockstepClientPolicy, E as createLockstepClientSimulation, h as createLockstepPolicies, v as createRoomLockstepClientSession, y as isRoomLockstepClientSession, g as repeatLastLockstepInput, s as schemaSimulationHash };

package/dist/lockstepAdmission.js

@@ -0,0 +1,261 @@
+import { ProtocolError as e } from "./errors.js";
+import { unsignedWord as t } from "./fixedWords.js";
+import { simulationOwnData as n } from "./simulationAuthoring.js";
+import { defineRoom as r } from "./room.js";
+import { ROOMS_TABLE as i, ROOM_CHECKPOINTS_TABLE as a, ROOM_SEATS_TABLE as o } from "./identities.js";
+import { assertRoomSubjectAdmission as s } from "./subjectAdmission.js";
+import { RoomLockstepAdmissionPort as c } from "./lockstepAdmissionPorts.js";
+import { captureLockstepJournalScope as l, lockstepJournalIdentity as u } from "./lockstepJournalCodec.js";
+import { captureRoomSnapshotEffectRunner as d } from "./snapshotBlobIndex.js";
+import { createRoomLockstepAdmissionCodec as f, roomLockstepCreationProjection as p, sealRoomLockstepAdmission as m } from "./lockstepAdmissionCodec.js";
+import { captureRoomLockstepRecoveryOptions as h, readRoomLockstepRecoveryTruth as g } from "./lockstepRecoveryTruth.js";
+import { and as _, eq as v, or as y } from "@voltro/database";
+import { Effect as b, Layer as x } from "effect";
+// src/lockstepAdmission.ts
+function S(t) {
+	throw new e({ detail: t });
+}
+var C = (e) => _(v("id", e.roomId), v("tenantId", e.tenantId)), w = (c, x, w) => {
+	let T = r(x), E = n(w, [
+		"hostId",
+		"epochNow",
+		"authorize",
+		"erasure",
+		"maxAdmissionBytes"
+	], [
+		"hostId",
+		"epochNow",
+		"authorize",
+		"erasure"
+	]), D = u(E.hostId), O = E.epochNow, k = E.authorize, A = n(E.erasure, ["erase"], ["erase"]).erase, j = Object.hasOwn(E, "maxAdmissionBytes") ? E.maxAdmissionBytes : 16777216;
+	if (typeof O != "function" || typeof k != "function" || typeof A != "function" || !Number.isSafeInteger(j) || j < 1 || j > 67108864) return S("Creation requires complete clock, authorization, coordinated erasure and bounded metadata");
+	let { optionsWire: M, stateWire: N, inputWire: P, captureStored: F } = f(T.simulation, j), I = () => {
+		let e = O();
+		return typeof e != "number" || !Number.isSafeInteger(e) || e < 0 || e > 864e13 ? S("Invalid creation wall clock") : new Date(e);
+	}, L = async (e, t) => {
+		let n = await e.query({
+			table: i,
+			predicate: C(t),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		}), r = n[0];
+		return n.length !== 1 || !r || r.id !== t.roomId || r.tenantId !== t.tenantId || r.hostId !== D || r.epoch !== t.epoch || !["creating", "live"].includes(String(r.state)) || r.erasure != null || r.snapshotErasure != null || r.name !== T.name || r.maxClients !== T.maxClients ? S("Creation has no exact unfenced SQL owner/name/capacity") : r;
+	}, R = async (e, t, n) => {
+		let r = F(t.lockstepAdmission, n, D);
+		return t.lockstepCreatorSubjectId !== r.initial.creatorSubjectId || r.initial.name !== T.name ? S("Creation indexed owner identity changed") : (await s(e, {
+			tenantId: n.tenantId,
+			subjectId: r.initial.creatorSubjectId
+		}), r);
+	}, z = async (e, t, n) => {
+		if (await e.updateMany("_voltro_rooms", {
+			lockstepAdmission: n,
+			lockstepCreatorSubjectId: n.initial.creatorSubjectId,
+			updatedAt: I()
+		}, { where: _(C(t), v("hostId", D), v("epoch", t.epoch)) }) !== 1) return S("Creation SQL ownership CAS failed");
+	}, B = (t, n, r, i) => b.flatMap(b.context(), (a) => b.uninterruptible(b.tryPromise({
+		try: async () => {
+			let e = d(a), o = k(t, n, i);
+			return b.isEffect(o) ? (await e(o), r(e)) : S("Creation authorization must return an actual Effect");
+		},
+		catch: () => new e({ detail: "SQL lockstep creation operation remains unconfirmed" })
+	}))), V = () => b.fail(new e({ detail: "Invalid SQL lockstep creation request" }));
+	return Object.freeze({
+		prepare: (e) => {
+			try {
+				let r = [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"requestId",
+					"creatorSubjectId",
+					"seed",
+					"options"
+				], i = n(e, r, r), d = l({
+					roomId: i.roomId,
+					tenantId: i.tenantId,
+					epoch: i.epoch
+				}), f = u(i.creatorSubjectId), p = m({
+					version: 1,
+					roomId: d.roomId,
+					tenantId: d.tenantId,
+					ownerEpoch: d.epoch,
+					hostId: D,
+					initial: {
+						requestId: u(i.requestId),
+						creatorSubjectId: f,
+						name: T.name,
+						seed: t(i.seed),
+						options: Buffer.from(M.encode(i.options)).toString("base64url"),
+						stateSchemaHash: N.schemaHash,
+						inputSchemaHash: P.schemaHash
+					},
+					adoption: null
+				});
+				return F(p, d, D), B(d, "prepare", () => c.transactional(async (e) => {
+					let t = await L(e, d);
+					if (await s(e, {
+						tenantId: d.tenantId,
+						subjectId: f
+					}), t.lockstepAdmission != null) {
+						let n = await R(e, t, d);
+						return JSON.stringify(n.initial) !== JSON.stringify(p.initial) || n.adoption !== null ? S("Conflicting immutable creation receipt") : n;
+					}
+					if (t.lockstepCreatorSubjectId != null || t.lockstepJournal != null || t.clients !== 0) return S("Creation cannot replace current Room authority");
+					for (let t of [o, a]) if ((await e.query({
+						table: t,
+						predicate: _(v("roomId", d.roomId), v("tenantId", d.tenantId)),
+						order: [],
+						take: 1,
+						skip: void 0,
+						projection: ["roomId"],
+						lock: "update"
+					})).length) return S("Lockstep metadata must precede Seats and never replace a state checkpoint");
+					return await z(e, d, p), p;
+				}), f);
+			} catch {
+				return V();
+			}
+		},
+		publish: (e) => {
+			try {
+				let t = l(e);
+				return B(t, "publish", () => c.transactional(async (e) => {
+					let n = await L(e, t), r = await R(e, n, t);
+					if (n.state === "live") return r;
+					if (r.adoption) {
+						let i = await g(e, n, h({
+							descriptor: (e) => e === T.name ? T : void 0,
+							maxTicks: 65536,
+							maxJournalBytes: j,
+							maxPlayers: T.maxClients
+						}));
+						if (!i || r.adoption.priorEpoch !== t.epoch - 1) return S("Successor publication needs actual adopted SQL truth");
+						let a = await e.query({
+							table: o,
+							predicate: _(v("roomId", t.roomId), v("tenantId", t.tenantId), y(v("state", "reserved"), v("state", "connected"), v("state", "grace"))),
+							order: [],
+							take: T.maxClients + 1,
+							skip: void 0,
+							projection: [
+								"sessionId",
+								"subjectId",
+								"epoch",
+								"state",
+								"role"
+							],
+							lock: "update"
+						});
+						if (a.length > T.maxClients || n.clients !== a.length || new Set(a.map((e) => e.sessionId)).size !== a.length || a.some((e) => typeof e.sessionId != "string" || e.state !== "grace" || e.epoch !== t.epoch || e.role !== "player" || i.journal && !i.journal.initial.players.some((t) => t.sessionId === e.sessionId && t.subjectId === e.subjectId))) return S("Successor publication requires only its actual fenced retained grace players");
+						for (let n of a) {
+							if (typeof n.subjectId != "string") return S("Successor publication requires registered retained Subjects");
+							await s(e, {
+								tenantId: t.tenantId,
+								subjectId: n.subjectId
+							});
+						}
+					} else {
+						if (n.clients !== 0) return S("Publication cannot replace existing Room players");
+						for (let n of [o, a]) if ((await e.query({
+							table: n,
+							predicate: _(v("roomId", t.roomId), v("tenantId", t.tenantId)),
+							order: [],
+							take: 1,
+							skip: void 0,
+							projection: ["roomId"],
+							lock: "update"
+						})).length) return S("Publication must precede Seats and state checkpoints");
+					}
+					return await e.updateMany("_voltro_rooms", {
+						state: "live",
+						updatedAt: I()
+					}, { where: _(C(t), v("hostId", D), v("epoch", t.epoch), v("state", "creating")) }) === 1 ? r : S("Publication SQL ownership CAS failed");
+				}));
+			} catch {
+				return V();
+			}
+		},
+		load: (e) => {
+			try {
+				let t = l(e);
+				return B(t, "load", () => c.transactional(async (e) => {
+					let n = await L(e, t);
+					return n.lockstepAdmission == null ? n.lockstepCreatorSubjectId == null ? null : S("Creation owner has no immutable receipt") : R(e, n, t);
+				}));
+			} catch {
+				return V();
+			}
+		},
+		adopt: (e, n, r) => {
+			try {
+				let i = l(e), a = t(n), o = u(r);
+				return a < 1 || i.epoch !== a + 1 ? V() : B(i, "adopt", () => c.transactional(async (e) => {
+					let t = await L(e, i), n = F(t.lockstepAdmission, i);
+					if (t.lockstepCreatorSubjectId !== n.initial.creatorSubjectId || n.initial.name !== T.name) return S("Creation indexed creator changed");
+					if (await s(e, {
+						tenantId: i.tenantId,
+						subjectId: n.initial.creatorSubjectId
+					}), n.ownerEpoch === i.epoch && n.hostId === D) return n.adoption?.requestId !== o || n.adoption.priorEpoch !== a ? S("Conflicting immutable creation adoption receipt") : n;
+					if (n.ownerEpoch !== a) return S("Creation predecessor epoch changed");
+					let { digest: r, ...c } = n, l = m({
+						...c,
+						ownerEpoch: i.epoch,
+						hostId: D,
+						adoption: {
+							requestId: o,
+							priorEpoch: a
+						}
+					});
+					return await z(e, i, l), l;
+				}));
+			} catch {
+				return V();
+			}
+		},
+		exportSubject: (e, t) => {
+			try {
+				let n = l(e), r = u(t);
+				return B(n, "export", () => c.transactional(async (e) => {
+					let t = await L(e, n);
+					return t.lockstepAdmission == null ? null : p(await R(e, t, n), r);
+				}), r);
+			} catch {
+				return V();
+			}
+		},
+		erase: (e, t) => {
+			try {
+				let n = l(e), r = u(t);
+				return B(n, "erase", async (e) => {
+					let t = A(Object.freeze({
+						roomId: n.roomId,
+						tenantId: n.tenantId,
+						requestId: r
+					}));
+					if (!b.isEffect(t)) return S("Creation erasure must return the actual coordinated Effect");
+					await e(t);
+					let a = await c.query({
+						table: i,
+						predicate: C(n),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: [
+							"id",
+							"tenantId",
+							"lockstepAdmission",
+							"lockstepCreatorSubjectId",
+							"erasure"
+						]
+					}), o = a[0], s = o?.erasure;
+					if (a.length !== 1 || o?.id !== n.roomId || o.tenantId !== n.tenantId || o.lockstepAdmission != null || o.lockstepCreatorSubjectId != null || s?.requestId !== r || s.phase !== "complete") return S("Creation erasure has no completed coordinated receipt");
+				});
+			} catch {
+				return V();
+			}
+		}
+	});
+}, T = (e, t, n) => x.succeed(c, w(e, t, n));
+export { c as RoomLockstepAdmissionPort, w as dataStoreRoomLockstepAdmission, T as roomLockstepAdmissionLayer };