@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepJournalRebuild.js

@@ -0,0 +1,207 @@
+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 { assertCapturedSimulation as i, captureSimulationInputs as a, createSimulationRunner as o } from "./simulation.js";
+import { RoomLockstepJournalPort as s, roomLockstepJournalRosterAt as c } from "./lockstepJournalPorts.js";
+import { captureLockstepJournalScope as l, createLockstepJournalCodec as u, lockstepJournalIdentity as d } from "./lockstepJournalCodec.js";
+import { captureRoomAdmittedSessionReader as f } from "./serverSession.js";
+import { createRoomLockstepServer as p } from "./lockstepServerRoles.js";
+import { Effect as m, Exit as h } from "effect";
+// src/lockstepJournalRebuild.ts
+var g = (t, n, o, f, p = () => void 0, g = () => void 0) => {
+	try {
+		i(t);
+		let _ = l(n), v = r(o, [
+			"hostId",
+			"maxTicks",
+			"maxJournalBytes",
+			"maxInputBytes",
+			"maxPlayers",
+			"maxRejectionAttempts"
+		], ["hostId"]), y = d(v.hostId), b = {
+			maxTicks: 65536,
+			maxJournalBytes: 16777216,
+			maxInputBytes: 16777216,
+			maxPlayers: 8,
+			maxRejectionAttempts: 64
+		}, x = {
+			maxTicks: 65536,
+			maxJournalBytes: 67108864,
+			maxInputBytes: 16777216,
+			maxPlayers: 64,
+			maxRejectionAttempts: 65536
+		}, S = { ...b };
+		for (let t of Object.keys(b)) {
+			let n = Object.hasOwn(v, t) ? v[t] : b[t];
+			if (!Number.isSafeInteger(n) || n < 1 || n > x[t]) throw new e({ detail: "Invalid bounded SQL rebuild work limit" });
+			Object.defineProperty(S, t, {
+				value: n,
+				enumerable: !0
+			});
+		}
+		let C = u(t, S.maxTicks, S.maxJournalBytes, S.maxPlayers);
+		return m.flatMap(s, (n) => m.suspend(() => {
+			let r = {}, i = () => m.suspend(() => {
+				let t = n.load(_);
+				return m.isEffect(t) ? t : m.fail(new e({ detail: "SQL rebuild load requires an actual Effect" }));
+			});
+			return m.flatMap(i(), (n) => m.try({
+				try: () => {
+					if (n === null) throw new e({ detail: "SQL rebuild requires retained lockstep truth" });
+					let i = C.captureStored(n, _, y), o = C.optionsWire.decode(Buffer.from(i.initial.options, "base64url")), s = 0, l = i.ticks.map((n) => {
+						s += 12;
+						let r = c(i, n.tick), o = n.inputs.map((t, n) => {
+							if (s += 8 + Buffer.from(t, "base64url").length, s > S.maxInputBytes) throw new e({ detail: "SQL rebuild exceeds complete input byte budget" });
+							return {
+								playerId: r[n].playerId,
+								input: C.decodeInput(t)
+							};
+						});
+						return a(t, o, S.maxPlayers);
+					}), u = f({
+						scope: _,
+						journal: i,
+						codec: C,
+						options: o,
+						matrices: Object.freeze(l),
+						inputBytes: s,
+						limits: Object.freeze(S)
+					});
+					return r.value = u, {
+						value: u,
+						digest: i.digest
+					};
+				},
+				catch: () => new e({ detail: "SQL lockstep rebuild remains unconfirmed" })
+			})).pipe(m.flatMap((t) => m.flatMap(i(), (n) => m.try({
+				try: () => {
+					if (n === null || C.captureStored(n, _, y).digest !== t.digest) throw new e({ detail: "SQL lockstep truth changed during rebuild" });
+					return g(t.value), t.value;
+				},
+				catch: () => new e({ detail: "SQL lockstep rebuild lost its current receipt" })
+			})))).pipe(m.onExit((e) => h.isFailure(e) && Object.hasOwn(r, "value") ? m.sync(() => p(r.value)) : m.void));
+		}));
+	} catch {
+		return m.fail(new e({ detail: "Invalid SQL lockstep rebuild admission" }));
+	}
+}, _ = (e, t, r) => g(e, t, r, (t) => {
+	let { journal: r, matrices: i, limits: a } = t, s = o(e, r.initial.seed, t.options, {
+		rollbackHorizonTicks: 1,
+		maxReplaySteps: 1,
+		maxPlayers: a.maxPlayers,
+		maxRejectionAttempts: a.maxRejectionAttempts
+	});
+	for (let e of i) s.advance(e);
+	return n({
+		scope: t.scope,
+		seed: r.initial.seed,
+		options: t.options,
+		players: c(r, 2 ** 53 - 1),
+		journalDigest: r.digest,
+		replayedTicks: i.length,
+		inputBytes: t.inputBytes,
+		snapshot: s.snapshot()
+	});
+}), v = (n, i, a) => {
+	try {
+		let o = [
+			"hostId",
+			"maxTicks",
+			"maxJournalBytes",
+			"maxInputBytes",
+			"maxPlayers",
+			"maxRejectionAttempts"
+		], s = r(a, [
+			...o,
+			"players",
+			"serverOptions"
+		], ["hostId", "players"]), l = {};
+		for (let e of o) Object.hasOwn(s, e) && (l[e] = s[e]);
+		let u = s.players;
+		if (!Array.isArray(u) || !u.length || u.length > 64 || Reflect.ownKeys(u).length !== u.length + 1) throw new e({ detail: "Authority rebuild requires bounded actual Session bindings" });
+		let d = Array.from({ length: u.length }, (n, i) => {
+			let a = Object.getOwnPropertyDescriptor(u, String(i));
+			if (!a?.enumerable || !("value" in a)) throw new e({ detail: "Authority rebuild bindings require own dense data" });
+			let o = r(a.value, ["playerId", "actualSession"], ["playerId", "actualSession"]);
+			return Object.freeze({
+				playerId: t(o.playerId),
+				actualSession: o.actualSession,
+				read: f(o.actualSession)
+			});
+		}), m = s.serverOptions === void 0 ? {} : r(s.serverOptions, [
+			"maxPlayers",
+			"maxFutureTicks",
+			"maxBatchInputs",
+			"maxPendingInputs",
+			"maxPendingBytes",
+			"strategies",
+			"stallPolicy",
+			"serverRole",
+			"refereeLagTicks",
+			"hashEvery",
+			"hashHistoryTicks",
+			"maxQueuedTicks",
+			"maxQueuedInputBytes",
+			"maxPendingHashes",
+			"maxRefereeSteps",
+			"maxReplayTicks",
+			"maxReplayInputBytes",
+			"maxSnapshotBudgetBytes",
+			"maxRejectionAttempts",
+			"onDesync"
+		], []);
+		Object.hasOwn(m, "strategies") && (m.strategies = Object.freeze(r(m.strategies, [
+			"refereeLag",
+			"stallPolicy",
+			"onDesync"
+		], []))), Object.hasOwn(m, "stallPolicy") && (m.stallPolicy = Object.freeze(r(m.stallPolicy, ["afterTicks", "action"], [])));
+		let h = Object.freeze(m);
+		return g(n, i, l, (t) => {
+			let r = c(t.journal, 2 ** 53 - 1);
+			if (d.length !== r.length || new Set(d.map((e) => e.playerId)).size !== d.length) throw new e({ detail: "Authority rebuild needs the exact complete SQL roster" });
+			let i = r.map((n) => {
+				let r = d.find((e) => e.playerId === n.playerId), i = r?.read.identity();
+				if (!r || !i || i.roomId !== t.scope.roomId || i.tenantId !== t.scope.tenantId || i.epoch !== t.scope.epoch || i.subjectId !== n.subjectId || r.read.inputSchemaHash() !== t.codec.inputWire.schemaHash) throw new e({ detail: "Authority rebuild lost actual current Subject/Session evidence" });
+				return {
+					player: n,
+					binding: r,
+					evidence: i
+				};
+			});
+			if (new Set(i.map((e) => e.evidence.sessionId)).size !== i.length) throw new e({ detail: "Authority rebuild cannot share an actual Session across players" });
+			let a = p(n, t.journal.initial.seed, t.options, t.scope, {
+				maxPlayers: t.limits.maxPlayers,
+				maxRejectionAttempts: t.limits.maxRejectionAttempts,
+				...h
+			});
+			try {
+				for (let e of i) a.admitAt({
+					slot: e.player.slot,
+					playerId: e.player.playerId
+				}, e.binding.actualSession);
+				a.seal();
+				for (let n of t.journal.ticks) {
+					for (let e = 0; e < r.length; e++) a.submit(i[e].binding.actualSession, n.tick, [Uint8Array.from(Buffer.from(n.inputs[e], "base64url"))]);
+					let t = a.advance();
+					if (t._tag !== "relayed" || t.tick !== n.tick) throw new e({ detail: "Authority rebuild could not consume a retained complete matrix" });
+					a.role !== "relay" && a.pumpReferee(1);
+				}
+				for (let t of i) if (JSON.stringify(t.binding.read.identity()) !== JSON.stringify(t.evidence)) throw new e({ detail: "Authority rebuild Session changed during replay" });
+				return Object.freeze({
+					server: a,
+					scope: t.scope,
+					journalDigest: t.journal.digest,
+					replayedTicks: t.matrices.length,
+					inputBytes: t.inputBytes
+				});
+			} catch (e) {
+				throw a.withdraw(), e;
+			}
+		}, (e) => e.server.withdraw(), (t) => {
+			for (let n of d) if (t.server.playerForSession(n.actualSession).playerId !== n.playerId) throw new e({ detail: "Authority rebuild Session changed after SQL confirmation" });
+		});
+	} catch {
+		return m.fail(new e({ detail: "Invalid SQL authority rebuild admission" }));
+	}
+};
+export { v as rebuildRoomLockstepAuthorityFromSql, _ as rebuildRoomLockstepFromSql };

package/dist/lockstepJournalRows.js

@@ -0,0 +1,56 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOM_LOCKSTEP_TICKS_TABLE as t } from "./identities.js";
+import { assembleRoomLockstepJournal as n, roomLockstepJournalHeader as r } from "./lockstepJournalCodec.js";
+import { and as i, eq as a, generateId as o } from "@voltro/database";
+// src/lockstepJournalRows.ts
+var s = (e) => i(a("tenantId", e.tenantId), a("roomId", e.roomId)), c = async (r, i, a) => {
+	let o = i.lockstepJournal;
+	if (o == null) return null;
+	let c = {
+		roomId: i.id,
+		tenantId: i.tenantId
+	}, l = await r.query({
+		table: t,
+		predicate: s(c),
+		order: [{
+			column: "tick",
+			direction: "asc"
+		}],
+		take: a + 1,
+		skip: void 0,
+		projection: [
+			"tick",
+			"requestId",
+			"inputs"
+		]
+	});
+	if (l.length > a) throw new e({ detail: "Stored lockstep journal exceeds its tick budget" });
+	return n(o, l.map((e) => ({
+		tick: e.tick,
+		requestId: e.requestId,
+		inputs: e.inputs
+	})));
+}, l = (e) => e === null ? null : r(e), u = async (n, r, i) => {
+	let a = r.ticks[r.ticks.length - 1];
+	if (!a) throw new e({ detail: "Lockstep journal has no tick to append" });
+	await n.insert(t, {
+		id: o({
+			kind: "typeid",
+			prefix: "rtick"
+		}, t),
+		tenantId: r.tenantId,
+		roomId: r.roomId,
+		tick: a.tick,
+		requestId: a.requestId,
+		inputs: a.inputs,
+		createdAt: i
+	});
+}, d = (e, n) => e.deleteMany(t, { where: s(n) }), f = async (e, n) => (await e.query({
+	table: t,
+	predicate: s(n),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: ["id"]
+})).length > 0;
+export { d as deleteLockstepJournalTicks, f as hasLockstepJournalTicks, u as insertLockstepJournalTick, c as readStoredLockstepJournal, l as storedLockstepJournalHeader };

package/dist/lockstepMembers.js

@@ -0,0 +1,130 @@
+import { NotRoomMember as e, ProtocolError as t, RoomAuthoringError as n, RoomForbidden as r, RoomFull as i, RoomGone as a, RoomLocked as o } from "./errors.js";
+import { simulationOwnData as s } from "./simulationAuthoring.js";
+import { assertCapturedSimulation as c } from "./simulation.js";
+import { captureLockstepMessages as l } from "./lockstepMessages.js";
+import { defaultRoomBudgets as u } from "./room.js";
+import { captureRoomConsumedSeat as d } from "./inputReceipts.js";
+import { captureLockstepJournalScope as f } from "./lockstepJournalCodec.js";
+// src/lockstepMembers.ts
+var p = /* @__PURE__ */ new WeakSet(), m = (e) => {
+	if (typeof e != "string" || !e.trim() || e.length > 191) throw new t({ detail: "Lockstep membership requires bounded own identity" });
+	return e;
+}, h = class {
+	id;
+	tenantId;
+	epoch;
+	descriptor;
+	#e = /* @__PURE__ */ new Map();
+	#t = !1;
+	#n = /* @__PURE__ */ new Map();
+	#r = !1;
+	#i;
+	constructor(e, t, r) {
+		c(e);
+		let i = f(t), a = s(r, [
+			"name",
+			"maxClients",
+			"budgets",
+			"messages",
+			"lateJoin"
+		], ["name"]), o = m(a.name), d = Object.hasOwn(a, "maxClients") ? a.maxClients : 8;
+		if (!Number.isInteger(d) || d < 1 || d > 64) throw new n({
+			room: o,
+			detail: "Lockstep member capacity must be within 1–64"
+		});
+		let h = Object.hasOwn(a, "budgets") ? s(a.budgets, [
+			"inputsPerSecond",
+			"bytesPerSecond",
+			"burst",
+			"maxQueuedInputs",
+			"maxOutboxCommands",
+			"maxScheduledHooks",
+			"maxQueuedLifecycleHooks",
+			"maxNpcs",
+			"inputLatencyBudgetMs"
+		], []) : {};
+		this.id = i.roomId, this.tenantId = i.tenantId, this.epoch = i.epoch, this.#i = a.lateJoin === !0, this.descriptor = Object.freeze({
+			name: o,
+			state: e.definition.state,
+			input: e.definition.input,
+			auth: "subject",
+			maxClients: d,
+			budgets: u(h),
+			messages: l(Object.hasOwn(a, "messages") ? a.messages : {})
+		}), p.add(this), Object.freeze(this);
+	}
+	isDisposed() {
+		return this.#r;
+	}
+	isFaulted() {
+		return !1;
+	}
+	isRetiring() {
+		return !1;
+	}
+	live() {
+		if (this.#r) throw new a({ roomId: this.id });
+	}
+	joinReservedAsync(e, n, c) {
+		let l = s(e, [
+			"sessionId",
+			"subjectId",
+			"tenantId",
+			"send",
+			"kick"
+		], [
+			"sessionId",
+			"subjectId",
+			"tenantId",
+			"send",
+			"kick"
+		]), u = m(l.sessionId), f = m(l.subjectId), p = m(l.tenantId);
+		if (p !== this.tenantId || typeof l.send != "function" || typeof l.kick != "function") throw new r({ roomId: this.id });
+		let h = d(n);
+		if (h.worldTarget || h.lastAppliedSeq !== -1) throw new t({ detail: "State-sync input receipts cannot initialize lockstep membership" });
+		return Promise.resolve().then(() => {
+			this.live();
+			let e = this.#n.get(u);
+			if (this.#t && (e ? e.subjectId !== f || e.tenantId !== p : !this.#i)) throw new o({ roomId: this.id });
+			if (c?.aborted) throw new a({ roomId: this.id });
+			if (this.#e.has(u)) throw new t({ detail: "Lockstep Session is already connected" });
+			if (this.#e.size >= this.descriptor.maxClients) throw new i({ roomId: this.id });
+			this.#e.set(u, Object.freeze({
+				sessionId: u,
+				subjectId: f,
+				tenantId: p
+			}));
+		});
+	}
+	leaveAsync(t, n = "left") {
+		return Promise.resolve().then(() => {
+			if (this.live(), !this.#e.delete(t)) throw new e({ sessionId: t });
+		});
+	}
+	seal() {
+		if (this.live(), !this.#e.size) throw new t({ detail: "Cannot seal empty lockstep membership" });
+		if (!this.#t) this.#n = new Map(this.#e);
+		else if (this.#i) for (let [e, t] of this.#e) this.#n.set(e, t);
+		this.#t = !0;
+	}
+	isCurrent(e, t) {
+		return !this.#r && this.#e.get(e)?.subjectId === t;
+	}
+	roster() {
+		return Object.freeze([...this.#e.values()]);
+	}
+	exportSubject(e, t) {
+		return e === this.tenantId ? Object.freeze([...new Map([...this.#n, ...this.#e]).values()].filter((e) => e.subjectId === t)) : Object.freeze([]);
+	}
+	eraseSubject(e, t) {
+		let n = this.exportSubject(e, t).length;
+		return n && (this.#r = !0, this.#e.clear(), this.#n.clear()), n;
+	}
+	withdraw() {
+		this.#r = !0, this.#e.clear(), this.#n.clear();
+	}
+	async disposeAsync() {
+		this.withdraw();
+	}
+}, g = (e) => typeof e == "object" && !!e && p.has(e);
+export { h as RoomLockstepMemberOwner, g as isRoomLockstepMemberOwner };

package/dist/lockstepMessages.js

@@ -0,0 +1,46 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { RoomInputCodec as n } from "./stateCodec.js";
+// src/lockstepMessages.ts
+var r = (r) => {
+	if (!r || typeof r != "object" || Object.getPrototypeOf(r) !== Object.prototype) throw new e({
+		room: "lockstep",
+		detail: "Message channels require own plain data"
+	});
+	let i = Reflect.ownKeys(r);
+	if (i.length > 64 || i.some((e) => typeof e != "string" || !/^[A-Za-z][A-Za-z0-9._-]*$/.test(e))) throw new e({
+		room: "lockstep",
+		detail: "Message channels require at most 64 stable ASCII names"
+	});
+	let a = t(r, i, []), o = {};
+	for (let r of Object.keys(a)) {
+		let i = t(a[r], [
+			"schema",
+			"direction",
+			"reliable"
+		], [
+			"schema",
+			"direction",
+			"reliable"
+		]);
+		if (![
+			"both",
+			"server",
+			"client"
+		].includes(i.direction) || typeof i.reliable != "boolean") throw new e({
+			room: "lockstep",
+			detail: "Message channels require an explicit direction and reliability"
+		});
+		let s = i.schema;
+		new n(s), Object.defineProperty(o, r, {
+			value: Object.freeze({
+				schema: s,
+				direction: i.direction,
+				reliable: i.reliable
+			}),
+			enumerable: !0
+		});
+	}
+	return Object.freeze(o);
+};
+export { r as captureLockstepMessages };