@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/lockstepJournal.js

@@ -0,0 +1,395 @@
+import { ProtocolError as e } from "./errors.js";
+import { unsignedWord as t } from "./fixedWords.js";
+import { simulationOwnData as n } from "./simulationAuthoring.js";
+import { assertCapturedSimulation as r } from "./simulation.js";
+import { ROOMS_TABLE as i, ROOM_SEATS_TABLE as a } from "./identities.js";
+import { assertRoomSubjectAdmission as o, assertRoomSubjectsAdmission as s } from "./subjectAdmission.js";
+import { RoomLockstepJournalPort as c, roomLockstepJournalRosterAt as l } from "./lockstepJournalPorts.js";
+import { captureLockstepJournalArray as u, captureLockstepJournalScope as d, createLockstepJournalCodec as f, lockstepJournalIdentity as p, roomLockstepJournalHeader as m } from "./lockstepJournalCodec.js";
+import { insertLockstepJournalTick as h, readStoredLockstepJournal as g } from "./lockstepJournalRows.js";
+import { captureRoomSnapshotEffectRunner as _ } from "./snapshotBlobIndex.js";
+import { createRoomLockstepAdmissionCodec as v } from "./lockstepAdmissionCodec.js";
+import { captureRoomAdmittedSessionReader as y } from "./serverSession.js";
+import { and as b, eq as x } from "@voltro/database";
+import { Effect as S, Layer as C } from "effect";
+//#region src/lockstepJournal.ts
+function w(t) {
+	throw new e({ detail: t });
+}
+var T = (e) => b(x("id", e.roomId), x("tenantId", e.tenantId)), E = (c, C, E) => {
+	r(C);
+	let D = n(E, [
+		"hostId",
+		"epochNow",
+		"authorize",
+		"erasure",
+		"maxTicks",
+		"maxJournalBytes",
+		"maxPlayers"
+	], [
+		"hostId",
+		"epochNow",
+		"authorize",
+		"erasure"
+	]), O = p(D.hostId), k = D.epochNow, A = D.authorize, j = n(D.erasure, ["erase"], ["erase"]).erase;
+	if (typeof k != "function" || typeof A != "function" || typeof j != "function") return w("Journal requires actual clock, authorization and coordinated erasure capabilities");
+	let M = Object.hasOwn(D, "maxTicks") ? D.maxTicks : 65536, N = Object.hasOwn(D, "maxJournalBytes") ? D.maxJournalBytes : 16777216, P = Object.hasOwn(D, "maxPlayers") ? D.maxPlayers : 8;
+	if (!Number.isInteger(M) || M < 1 || M > 65536 || !Number.isInteger(N) || N < 1 || N > 67108864 || !Number.isInteger(P) || P < 1 || P > 64) return w("Invalid bounded SQL journal work configuration");
+	let F = M, I = N, L = P, { inputWire: R, stateWire: z, optionsWire: B, captureInput: ee, decodeInput: te, seal: V, append: ne, captureStored: H } = f(C, F, I, L), U = v(C, 67108864).captureStored, W = () => {
+		let e = k();
+		return typeof e != "number" || !Number.isSafeInteger(e) || e < 0 || e > 864e13 ? w("Invalid journal wall clock") : new Date(e);
+	}, G = async (e, t) => {
+		let n = await e.query({
+			table: i,
+			predicate: T(t),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		return n.length !== 1 || n[0].id !== t.roomId || n[0].tenantId !== t.tenantId ? w("Journal needs one exact SQL Room") : n[0];
+	}, K = async (e, t, n, r = !1, i = !0) => {
+		let a = U(t.lockstepAdmission, n, O), s = r && t.state === "creating" && a.adoption?.priorEpoch === n.epoch - 1;
+		return t.hostId !== O || t.epoch !== n.epoch || t.state !== "live" && !s || t.erasure != null || t.snapshotErasure != null ? w("Journal SQL owner is stale, inactive or privacy-fenced") : t.lockstepCreatorSubjectId !== a.initial.creatorSubjectId || t.name !== a.initial.name ? w("Journal pre-seat creation identity changed") : (i && await o(e, {
+			tenantId: n.tenantId,
+			subjectId: a.initial.creatorSubjectId
+		}), a.initial.creatorSubjectId);
+	}, q = async (e, t, n) => {
+		if (await e.updateMany("_voltro_rooms", {
+			lockstepJournal: m(n),
+			updatedAt: W()
+		}, { where: b(T(t), x("hostId", O), x("epoch", t.epoch), x("state", "live")) }) !== 1) return w("SQL journal owner CAS failed");
+		X(t, n);
+	}, J = /* @__PURE__ */ new Map(), Y = (e) => `${e.tenantId}\u0000${e.roomId}`, X = (e, t) => {
+		let n = Y(e), r = J.get(n);
+		r && r.journal.ticks.length + 1 === t.ticks.length && t.ticks[r.journal.ticks.length - 1] === r.journal.ticks[r.journal.ticks.length - 1] ? (r.requests.add(t.ticks[t.ticks.length - 1].requestId), r.journal = t) : r && r.journal.ticks === t.ticks ? r.journal = t : (J.delete(n), J.size >= 256 && J.delete(J.keys().next().value), J.set(n, {
+			journal: t,
+			requests: new Set(t.ticks.map((e) => e.requestId))
+		}));
+	}, Z = async (e, t, n, r) => {
+		let i = t.lockstepJournal;
+		if (i == null) return null;
+		let a = J.get(Y(n));
+		if (a && i.digest === a.journal.digest) return {
+			journal: H(a.journal, n, r),
+			requests: a.requests
+		};
+		let o = H(await g(e, t, F), n, r);
+		return X(n, o), J.get(Y(n));
+	}, Q = (t, n, r, i) => S.flatMap(S.context(), (a) => S.uninterruptible(S.tryPromise({
+		try: async () => {
+			let e = _(a), o = A(t, n, i);
+			return S.isEffect(o) ? (await e(o), r(e)) : w("Journal authorization must return an actual Effect");
+		},
+		catch: () => new e({ detail: "SQL lockstep journal operation remains unconfirmed" })
+	}))), $ = () => S.fail(new e({ detail: "Invalid SQL lockstep journal request" }));
+	return Object.freeze({
+		initialize: (e) => {
+			try {
+				let r = n(e, [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"requestId",
+					"seed",
+					"options",
+					"players"
+				], [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"requestId",
+					"seed",
+					"options",
+					"players"
+				]), i = d({
+					roomId: r.roomId,
+					tenantId: r.tenantId,
+					epoch: r.epoch
+				}), s = p(r.requestId), l = t(r.seed), f = B.encode(r.options), m = u(r.players, L).map((e) => {
+					let r = n(e, [
+						"slot",
+						"playerId",
+						"actualSession"
+					], [
+						"slot",
+						"playerId",
+						"actualSession"
+					]), a = r.slot, o = y(r.actualSession), s = o.identity();
+					return !Number.isInteger(a) || a < 0 || a > 63 || !s || s.roomId !== i.roomId || s.tenantId !== i.tenantId || s.epoch !== i.epoch || o.inputSchemaHash() !== R.schemaHash ? w("Journal start needs the exact current actual player admission") : {
+						player: Object.freeze({
+							slot: a,
+							playerId: t(r.playerId),
+							subjectId: s.subjectId,
+							sessionId: s.sessionId
+						}),
+						evidence: s,
+						reader: o
+					};
+				}).sort((e, t) => e.player.slot - t.player.slot), h = V({
+					version: 1,
+					roomId: i.roomId,
+					tenantId: i.tenantId,
+					ownerEpoch: i.epoch,
+					hostId: O,
+					initial: {
+						requestId: s,
+						seed: l,
+						options: Buffer.from(f).toString("base64url"),
+						stateSchemaHash: z.schemaHash,
+						inputSchemaHash: R.schemaHash,
+						players: m.map((e) => e.player)
+					},
+					adoption: null,
+					ticks: []
+				});
+				return H(h, i, O), Q(i, "initialize", async () => c.transactional(async (e) => {
+					let t = await G(e, i);
+					await K(e, t, i);
+					let n = U(t.lockstepAdmission, i, O);
+					if (n.initial.seed !== l || n.initial.options !== h.initial.options || n.initial.stateSchemaHash !== h.initial.stateSchemaHash || n.initial.inputSchemaHash !== h.initial.inputSchemaHash) return w("Journal Start cannot replace durable pre-seat seed/options/layout");
+					for (let t of m) {
+						await o(e, {
+							tenantId: i.tenantId,
+							subjectId: t.player.subjectId
+						});
+						let n = await e.query({
+							table: a,
+							predicate: b(x("tenantId", i.tenantId), x("roomId", i.roomId), x("sessionId", t.player.sessionId)),
+							order: [],
+							take: 2,
+							skip: void 0,
+							projection: void 0,
+							lock: "update"
+						}), r = n[0], s = t.reader.identity();
+						if (n.length !== 1 || !s || JSON.stringify(s) !== JSON.stringify(t.evidence) || r?.state !== "connected" || r.epoch !== i.epoch || r.subjectId !== t.player.subjectId || r.role !== "player" || r.nonce !== t.evidence.nonce || r.token !== t.evidence.credentialDigest) return w("Journal start lost its real SQL consumed seat");
+					}
+					if (t.lockstepJournal != null) {
+						let n = (await Z(e, t, i, O)).journal;
+						return JSON.stringify(n.initial) === JSON.stringify(h.initial) ? n : w("Conflicting immutable SQL journal start receipt");
+					}
+					for (let e of m) if (JSON.stringify(e.reader.identity()) !== JSON.stringify(e.evidence)) return w("Journal start Session was withdrawn before commit");
+					return await q(e, i, h), h;
+				}));
+			} catch {
+				return $();
+			}
+		},
+		append: (e) => {
+			try {
+				let r = n(e, [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"requestId",
+					"tick",
+					"inputs"
+				], [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"requestId",
+					"tick",
+					"inputs"
+				]), i = d({
+					roomId: r.roomId,
+					tenantId: r.tenantId,
+					epoch: r.epoch
+				}), a = t(r.tick), o = p(r.requestId), f = Object.freeze(u(r.inputs, L).map(ee));
+				if (a < 1 || a > F || !f.length) return $();
+				let m = Object.freeze({
+					tick: a,
+					requestId: o,
+					inputs: f
+				});
+				return Q(i, "append", async () => c.transactional(async (e) => {
+					let t = await G(e, i), n = await K(e, t, i, !1, !1), r = await Z(e, t, i, O);
+					if (!r) return w("Journal append needs a started journal");
+					let c = r.journal, u = l(c, a);
+					if (f.length !== u.length) return w("Journal append lacks a complete roster matrix");
+					await s(e, i.tenantId, [n, ...u.map((e) => e.subjectId)]);
+					let d = c.ticks[a - 1];
+					if (d) return JSON.stringify(d) === JSON.stringify(m) ? c : w("Conflicting committed immutable journal tick");
+					if (a !== c.ticks.length + 1 || o === c.initial.requestId || r.requests.has(o) || (c.joins ?? []).some((e) => e.requestId === o)) return w("Journal append is noncontiguous or reuses a request");
+					let p = ne(c, m);
+					return await h(e, p, W()), await q(e, i, p), p;
+				}));
+			} catch {
+				return $();
+			}
+		},
+		join: (e) => {
+			try {
+				let r = n(e, [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"requestId",
+					"tick",
+					"player"
+				], [
+					"roomId",
+					"tenantId",
+					"epoch",
+					"requestId",
+					"tick",
+					"player"
+				]), i = d({
+					roomId: r.roomId,
+					tenantId: r.tenantId,
+					epoch: r.epoch
+				}), s = t(r.tick), u = p(r.requestId), f = n(r.player, [
+					"slot",
+					"playerId",
+					"actualSession"
+				], [
+					"slot",
+					"playerId",
+					"actualSession"
+				]), m = f.slot;
+				if (s < 1 || s > F || !Number.isInteger(m) || m < 0 || m > 63) return $();
+				let h = y(f.actualSession), g = h.identity();
+				return !g || g.roomId !== i.roomId || g.tenantId !== i.tenantId || g.epoch !== i.epoch || h.inputSchemaHash() !== R.schemaHash ? $() : Q(i, "join", async () => c.transactional(async (e) => {
+					let n = await G(e, i);
+					await K(e, n, i);
+					let r = await Z(e, n, i, O);
+					if (!r) return w("Late join needs a started journal");
+					let c = r.journal, d = Object.freeze({
+						tick: s,
+						requestId: u,
+						slot: m,
+						playerId: t(f.playerId),
+						subjectId: g.subjectId,
+						sessionId: g.sessionId
+					}), p = c.joins?.find((e) => e.requestId === u);
+					if (p) return JSON.stringify(p) === JSON.stringify(d) ? c : w("Conflicting committed late join");
+					let _ = l(c, 2 ** 53 - 1);
+					if (s <= c.ticks.length || _.length >= L || _.some((e) => e.slot === d.slot || e.playerId === d.playerId || e.sessionId === d.sessionId) || u === c.initial.requestId || r.requests.has(u)) return w("Late join is behind the frontier, full or not unique");
+					await o(e, {
+						tenantId: i.tenantId,
+						subjectId: d.subjectId
+					});
+					let v = await e.query({
+						table: a,
+						predicate: b(x("tenantId", i.tenantId), x("roomId", i.roomId), x("sessionId", d.sessionId)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					}), y = v[0], S = h.identity();
+					if (v.length !== 1 || !S || JSON.stringify(S) !== JSON.stringify(g) || y?.state !== "connected" || y.epoch !== i.epoch || y.subjectId !== d.subjectId || y.role !== "player" || y.nonce !== g.nonce || y.token !== g.credentialDigest) return w("Late join lost its real SQL consumed seat");
+					let { digest: C, ...T } = c, E = V({
+						...T,
+						version: 2,
+						joins: [...c.joins ?? [], d]
+					});
+					return await q(e, i, E), E;
+				}));
+			} catch {
+				return $();
+			}
+		},
+		load: (e) => {
+			try {
+				let t = d(e);
+				return Q(t, "load", async () => c.transactional(async (e) => {
+					let n = await G(e, t);
+					await K(e, n, t, !0);
+					let r = await Z(e, n, t, O);
+					if (!r) return null;
+					let i = r.journal;
+					if (n.state === "creating" && i.adoption?.priorEpoch !== t.epoch - 1) return w("Staged journal read requires the same actual adopted ownership");
+					for (let n of i.initial.players) await o(e, {
+						tenantId: t.tenantId,
+						subjectId: n.subjectId
+					});
+					return i;
+				}));
+			} catch {
+				return $();
+			}
+		},
+		adopt: (e, n, r) => {
+			try {
+				let i = d(e), a = t(n), s = p(r);
+				return a < 1 || a >= i.epoch ? $() : Q(i, "adopt", async () => c.transactional(async (e) => {
+					let t = await G(e, i);
+					await K(e, t, i);
+					let n = await Z(e, t, i);
+					if (!n) return w("Journal adoption needs a started journal");
+					let r = n.journal;
+					for (let t of r.initial.players) await o(e, {
+						tenantId: i.tenantId,
+						subjectId: t.subjectId
+					});
+					if (r.ownerEpoch === i.epoch && r.hostId === O) return r.adoption?.requestId !== s || r.adoption.priorEpoch !== a ? w("Conflicting journal adoption receipt") : r;
+					if (r.ownerEpoch !== a) return w("Journal predecessor epoch changed");
+					let { digest: c, ...l } = r, u = V({
+						...l,
+						hostId: O,
+						ownerEpoch: i.epoch,
+						adoption: {
+							requestId: s,
+							priorEpoch: a
+						}
+					});
+					return await q(e, i, u), u;
+				}));
+			} catch {
+				return $();
+			}
+		},
+		exportSubject: (e, t) => {
+			try {
+				let n = d(e), r = p(t);
+				return Q(n, "export", async () => c.transactional(async (e) => {
+					let t = await G(e, n);
+					await K(e, t, n, !0);
+					let i = await Z(e, t, n, O);
+					if (!i) return Object.freeze({
+						roomId: n.roomId,
+						inputs: Object.freeze([])
+					});
+					let a = i.journal, o = [];
+					for (let e of a.ticks) for (let t = 0; t < a.initial.players.length; t++) {
+						let n = a.initial.players[t];
+						n.subjectId === r && o.push(Object.freeze({
+							tick: e.tick,
+							playerId: n.playerId,
+							input: te(e.inputs[t])
+						}));
+					}
+					return Object.freeze({
+						roomId: n.roomId,
+						inputs: Object.freeze(o)
+					});
+				}), r);
+			} catch {
+				return $();
+			}
+		},
+		erase: (e, t) => {
+			try {
+				let n = d(e), r = p(t);
+				return Q(n, "erase", async (e) => {
+					let t = j({
+						roomId: n.roomId,
+						tenantId: n.tenantId,
+						requestId: r
+					});
+					if (!S.isEffect(t)) return w("Journal erasure requires an actual coordinated Effect");
+					await e(t), await c.transactional(async (e) => {
+						let t = await G(e, n), i = t.erasure;
+						if (t.lockstepJournal != null || i?.requestId !== r || i.phase !== "complete") return w("Journal erasure has no completed coordinated receipt");
+					});
+				});
+			} catch {
+				return $();
+			}
+		}
+	});
+}, D = (e, t, n) => C.succeed(c, E(e, t, n));
+//#endregion
+export { c as RoomLockstepJournalPort, E as dataStoreRoomLockstepJournal, D as roomLockstepJournalLayer };

package/dist/lockstepJournalCodec.js

@@ -0,0 +1,254 @@
+import { ProtocolError as e } from "./errors.js";
+import { unsignedWord as t } from "./fixedWords.js";
+import { freezeSimulationValue as n, simulationOwnData as r } from "./simulationAuthoring.js";
+import { captureSimulationBytes as i } from "./simulationBytes.js";
+import { createSimulationOptionsCodec as a } from "./simulationOptionsWire.js";
+import { assertCapturedSimulation as o } from "./simulation.js";
+import { RoomInputCodec as s, RoomStateCodec as c } from "./stateCodec.js";
+import { Result as l } from "effect";
+import { createHash as u } from "node:crypto";
+//#region src/lockstepJournalCodec.ts
+function d(t) {
+	throw new e({ detail: t });
+}
+var f = (e) => typeof e == "string" && e.length > 0 && e.length <= 191 && e.trim() === e && !/[\u0000-\u001f\u007f]/.test(e) ? e : d("Invalid lockstep SQL journal identity"), p = (e) => {
+	let n = r(e, [
+		"roomId",
+		"tenantId",
+		"epoch"
+	], [
+		"roomId",
+		"tenantId",
+		"epoch"
+	]), i = t(n.epoch);
+	return i < 1 || i > 2147483647 ? d("Journal needs a positive durable SQL owner epoch") : Object.freeze({
+		roomId: f(n.roomId),
+		tenantId: f(n.tenantId),
+		epoch: i
+	});
+}, m = (e, t) => {
+	if (!Array.isArray(e) || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) return d("Journal arrays must be bounded dense own data");
+	let n = [];
+	for (let t = 0; t < e.length; t++) {
+		let r = Object.getOwnPropertyDescriptor(e, String(t));
+		if (!r?.enumerable || !("value" in r)) return d("Journal array accessors and holes refuse");
+		n.push(r.value);
+	}
+	return n;
+}, h = (e) => u("sha256").update(e).digest("hex"), g = h("voltro.lockstep.journal.ticks.v1"), _ = (e, t) => h(e + JSON.stringify(t)), v = /* @__PURE__ */ new WeakMap(), y = (e) => {
+	let t = v.get(e);
+	if (t) return t;
+	let n = g, r = 0;
+	for (let t of e) n = _(n, t), r += Buffer.byteLength(JSON.stringify(t), "utf8") + 1;
+	let i = Object.freeze({
+		head: n,
+		bytes: r
+	});
+	return v.set(e, i), i;
+}, b = /* @__PURE__ */ new WeakSet(), x = (e, t, r, i = e.ticks) => {
+	let { ticks: a, ...o } = e, s = JSON.stringify({
+		...o,
+		tickCount: a.length,
+		ticksDigest: t.head
+	});
+	if (Buffer.byteLength(s, "utf8") + t.bytes > r) return d("SQL lockstep journal exceeds its complete byte budget");
+	for (let e of i) n(e);
+	Object.freeze(a);
+	let c = Object.freeze({
+		...n({ ...o }),
+		ticks: a,
+		digest: h(s)
+	});
+	return v.set(c.ticks, t), b.add(c), c;
+}, S = (e, t) => x(e, y(e.ticks), t), C = (e, t, n) => {
+	let r = y(e.ticks), { digest: i, ...a } = e;
+	return x({
+		...a,
+		ticks: [...e.ticks, t]
+	}, {
+		head: _(r.head, t),
+		bytes: r.bytes + Buffer.byteLength(JSON.stringify(t), "utf8") + 1
+	}, n, [t]);
+}, w = (e, t) => {
+	let n = e.ticks[e.ticks.length - 1];
+	return n !== void 0 && e.ticks.length === t.ticks.length + 1 && y(e.ticks).head === _(y(t.ticks).head, n);
+}, T = (e) => {
+	let { ticks: t, ...n } = e;
+	return Object.freeze({
+		...n,
+		tickCount: t.length,
+		ticksDigest: y(t).head
+	});
+}, E = (e, t) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype) return d("Stored lockstep journal header is not plain data");
+	let { tickCount: n, ticksDigest: r, ...i } = e;
+	return n === t.length ? {
+		...i,
+		ticks: [...t]
+	} : d("Stored lockstep journal lost or gained tick rows");
+}, D = (e, u, p, h) => {
+	o(e);
+	let g = new s(e.definition.input, e.inputCodec.limits), _ = new c(e.definition.state, e.stateCodec.limits), v = a(e), y = (e, t) => {
+		if (typeof e != "string" || e.length > Math.ceil(t * 4 / 3) || !/^[A-Za-z0-9_-]*$/.test(e)) return d("Invalid or oversized journal byte text");
+		let n = Buffer.from(e, "base64url");
+		return n.length > t || n.toString("base64url") !== e ? d("Noncanonical journal byte text") : e;
+	}, x = (t) => {
+		let n = i(t, e.inputCodec.limits.maxBytes, "lockstepJournalInputBytes"), r = g.decodeFull(n);
+		if (l.isFailure(r)) throw r.failure;
+		let a = e.inputCodec.capture(r.success), o = g.full(a);
+		if (l.isFailure(o)) throw o.failure;
+		return Buffer.from(o.success).equals(Buffer.from(n)) ? Buffer.from(n).toString("base64url") : d("Journal input is not canonical declared intent");
+	}, w = (t) => {
+		let r = g.decodeFull(Buffer.from(y(t, e.inputCodec.limits.maxBytes), "base64url"));
+		if (l.isFailure(r)) throw r.failure;
+		return n(e.inputCodec.capture(r.success));
+	}, T = (e) => S(e, p);
+	return Object.freeze({
+		inputWire: g,
+		stateWire: _,
+		optionsWire: v,
+		captureInput: x,
+		decodeInput: w,
+		seal: T,
+		append: (e, t) => C(e, t, p),
+		captureStored: (n, i, a) => {
+			if (b.has(n)) {
+				let e = n;
+				return e.roomId !== i.roomId || e.tenantId !== i.tenantId || a !== void 0 && (e.ownerEpoch !== i.epoch || e.hostId !== a) || e.initial.stateSchemaHash !== _.schemaHash || e.initial.inputSchemaHash !== g.schemaHash || e.ticks.length > u ? d("Stored lockstep journal changed scope or owner") : e;
+			}
+			let o = n?.version, s = [
+				"version",
+				"roomId",
+				"tenantId",
+				"ownerEpoch",
+				"hostId",
+				"initial",
+				"adoption",
+				"ticks",
+				...o === 2 ? ["joins"] : [],
+				"digest"
+			], c = r(n, s, s), l = t(c.ownerEpoch), p = f(c.hostId);
+			if (o !== 1 && o !== 2 || c.roomId !== i.roomId || c.tenantId !== i.tenantId || l < 1 || l > 2147483647 || a !== void 0 && (l !== i.epoch || p !== a)) return d("Stored lockstep journal changed scope or owner");
+			let x = r(c.initial, [
+				"requestId",
+				"seed",
+				"options",
+				"stateSchemaHash",
+				"inputSchemaHash",
+				"players"
+			], [
+				"requestId",
+				"seed",
+				"options",
+				"stateSchemaHash",
+				"inputSchemaHash",
+				"players"
+			]);
+			if (x.stateSchemaHash !== _.schemaHash || x.inputSchemaHash !== g.schemaHash) return d("Stored journal simulation layout changed");
+			let S = y(x.options, v.maxBytes);
+			v.decode(Buffer.from(S, "base64url"));
+			let C = m(x.players, h).map((e) => {
+				let n = r(e, [
+					"slot",
+					"playerId",
+					"subjectId",
+					"sessionId"
+				], [
+					"slot",
+					"playerId",
+					"subjectId",
+					"sessionId"
+				]), i = n.slot;
+				return !Number.isInteger(i) || i < 0 || i > 63 ? d("Stored journal has invalid slot") : Object.freeze({
+					slot: i,
+					playerId: t(n.playerId),
+					subjectId: f(n.subjectId),
+					sessionId: f(n.sessionId)
+				});
+			});
+			if (!C.length || new Set(C.map((e) => e.slot)).size !== C.length || new Set(C.map((e) => e.playerId)).size !== C.length || new Set(C.map((e) => e.sessionId)).size !== C.length || C.some((e, t) => t > 0 && e.slot <= C[t - 1].slot)) return d("Stored journal roster is not canonical unique slot order");
+			let E = o === 2 ? m(c.joins, h).map((e) => {
+				let n = r(e, [
+					"tick",
+					"requestId",
+					"slot",
+					"playerId",
+					"subjectId",
+					"sessionId"
+				], [
+					"tick",
+					"requestId",
+					"slot",
+					"playerId",
+					"subjectId",
+					"sessionId"
+				]), i = n.slot, a = t(n.tick);
+				return !Number.isInteger(i) || i < 0 || i > 63 || a < 1 ? d("Stored journal has an invalid late join") : Object.freeze({
+					tick: a,
+					requestId: f(n.requestId),
+					slot: i,
+					playerId: t(n.playerId),
+					subjectId: f(n.subjectId),
+					sessionId: f(n.sessionId)
+				});
+			}) : [], D = [...C, ...E];
+			if (E.some((e, t) => t > 0 && e.tick < E[t - 1].tick) || D.length > h || new Set(D.map((e) => e.slot)).size !== D.length || new Set(D.map((e) => e.playerId)).size !== D.length || new Set(D.map((e) => e.sessionId)).size !== D.length) return d("Stored journal late joins are not unique and ordered");
+			let O = m(c.ticks, u).map((t, n) => {
+				let i = r(t, [
+					"tick",
+					"requestId",
+					"inputs"
+				], [
+					"tick",
+					"requestId",
+					"inputs"
+				]);
+				if (i.tick !== n + 1) return d("Stored journal input history is not contiguous from seed");
+				let a = m(i.inputs, h).map((t) => {
+					let n = y(t, e.inputCodec.limits.maxBytes);
+					return w(n), n;
+				});
+				return a.length === C.length + E.filter((e) => e.tick <= n + 1).length ? Object.freeze({
+					tick: n + 1,
+					requestId: f(i.requestId),
+					inputs: Object.freeze(a)
+				}) : d("Stored journal lacks a complete player matrix");
+			}), k = null;
+			if (c.adoption !== null) {
+				let e = r(c.adoption, ["requestId", "priorEpoch"], ["requestId", "priorEpoch"]), n = t(e.priorEpoch);
+				if (n < 1 || n >= l) return d("Stored adoption receipt has invalid epoch");
+				k = Object.freeze({
+					requestId: f(e.requestId),
+					priorEpoch: n
+				});
+			}
+			let A = T({
+				version: o,
+				roomId: i.roomId,
+				tenantId: i.tenantId,
+				ownerEpoch: l,
+				hostId: p,
+				initial: {
+					requestId: f(x.requestId),
+					seed: t(x.seed),
+					options: S,
+					stateSchemaHash: _.schemaHash,
+					inputSchemaHash: g.schemaHash,
+					players: Object.freeze(C)
+				},
+				adoption: k,
+				ticks: Object.freeze(O),
+				...o === 2 ? { joins: Object.freeze(E) } : {}
+			});
+			if (typeof c.digest != "string" || c.digest !== A.digest) return d("Stored journal integrity changed");
+			let j = [
+				A.initial.requestId,
+				...O.map((e) => e.requestId),
+				...E.map((e) => e.requestId)
+			];
+			return new Set(j).size === j.length ? A : d("Stored journal request receipts collide");
+		}
+	});
+};
+//#endregion
+export { C as appendRoomLockstepJournalTick, E as assembleRoomLockstepJournal, m as captureLockstepJournalArray, p as captureLockstepJournalScope, D as createLockstepJournalCodec, w as extendsRoomLockstepJournal, f as lockstepJournalIdentity, T as roomLockstepJournalHeader, S as sealRoomLockstepJournal };

package/dist/lockstepJournalPorts.js

@@ -0,0 +1,5 @@
+import { Context as e } from "effect";
+//#region src/lockstepJournalPorts.ts
+var t = (e, t) => [...e.initial.players, ...(e.joins ?? []).filter((e) => e.tick <= t)].sort((e, t) => e.slot - t.slot), n = class extends e.Service()("@voltro/RoomLockstepJournalPort") {};
+//#endregion
+export { n as RoomLockstepJournalPort, t as roomLockstepJournalRosterAt };