@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepDefinition.js

@@ -0,0 +1,147 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { retainLockstepPoolOrigin as n } from "./roomPoolRuntimeDefaults.js";
+import { roomAuthoringStrategy as r } from "./roomAuthoringStrategy.js";
+import { assertCapturedSimulation as i } from "./simulation.js";
+import { captureRoomLockstepServerOptions as a } from "./lockstepServerConfig.js";
+import { captureLockstepMessages as o } from "./lockstepMessages.js";
+import { defaultRoomBudgets as s, defaultRoomReconnectPolicy as c } from "./room.js";
+// src/lockstepDefinition.ts
+var l = /* @__PURE__ */ new WeakMap();
+function u(t) {
+	throw new e({
+		room: "lockstep",
+		detail: t
+	});
+}
+var d = (e, t, n) => !Number.isSafeInteger(e) || e < t || e > n ? u("Invalid bounded lockstep declaration work limit") : e, f = (e) => {
+	let f = t(e, [
+		"name",
+		"mode",
+		"simulation",
+		"lockstep",
+		"guards",
+		"openAccess",
+		"auth",
+		"tickRate",
+		"maxCatchUpTicks",
+		"lifecycleTimeoutMs",
+		"budgets",
+		"_tag",
+		"state",
+		"input",
+		"options",
+		"maxClients",
+		"reconnect",
+		"strategies",
+		"messages",
+		"onMessage"
+	], [
+		"name",
+		"mode",
+		"simulation"
+	]), p = f.name;
+	if (typeof p != "string" || !p.trim() || p.length > 191 || f.mode !== "lockstep") return u("Lockstep declaration requires a bounded name and explicit mode");
+	if (Object.hasOwn(f, "auth") && f.auth !== "subject") return u("Lockstep initial admission requires an authenticated Subject player");
+	let m = f.simulation;
+	i(m);
+	for (let e of [
+		"state",
+		"input",
+		"options"
+	]) if (Object.hasOwn(f, e) && f[e] !== m.definition[e]) return u("Derived Room schemas must be the actual captured simulation schemas");
+	if (Object.hasOwn(f, "_tag") && f._tag !== "RoomDescriptor") return u("Invalid lockstep descriptor tag");
+	let h = t(Object.hasOwn(f, "lockstep") ? f.lockstep : {}, [
+		"inputSchema",
+		"inputDelayTicks",
+		"rollbackHorizonTicks",
+		"inputPrediction",
+		"lateJoin",
+		"maxPlayers",
+		"maxFutureTicks",
+		"maxBatchInputs",
+		"maxPendingInputs",
+		"maxPendingBytes",
+		"strategies",
+		"stallPolicy",
+		"serverRole",
+		"refereeLagTicks",
+		"hashEvery",
+		"hashHistoryTicks",
+		"maxQueuedTicks",
+		"maxQueuedInputBytes",
+		"maxPendingHashes",
+		"maxRefereeSteps",
+		"maxReplayTicks",
+		"maxReplayInputBytes",
+		"maxSnapshotBudgetBytes",
+		"maxRejectionAttempts",
+		"onDesync"
+	], []);
+	if (Object.hasOwn(h, "inputSchema") && h.inputSchema !== m.definition.input) return u("Lockstep inputSchema must be the actual shared simulation input");
+	let g = {};
+	for (let e of Object.keys(h)) [
+		"inputSchema",
+		"inputDelayTicks",
+		"rollbackHorizonTicks",
+		"inputPrediction",
+		"lateJoin"
+	].includes(e) || (g[e] = h[e]);
+	let _ = Object.hasOwn(h, "lateJoin") ? h.lateJoin : !1;
+	if (typeof _ != "boolean") return u("Lockstep lateJoin must be a boolean");
+	let v = a(g), y = d(Object.hasOwn(h, "inputDelayTicks") ? h.inputDelayTicks : 2, 0, v.roster.maxFutureTicks), b = d(Object.hasOwn(h, "rollbackHorizonTicks") ? h.rollbackHorizonTicks : 8, 1, 4096), x = Object.hasOwn(h, "inputPrediction") ? h.inputPrediction : "repeat-last";
+	if (x !== "repeat-last" && x !== "none" && typeof x != "function") return u("Invalid captured lockstep input prediction");
+	if (v.role !== "relay") {
+		let e = v.limits.hashHistoryTicks + 2 + (v.role === "full" ? v.limits.maxReplayTicks + 1 : 0);
+		if (m.stateCodec.limits.maxBytes > Math.floor(v.limits.maxSnapshotBudgetBytes / e)) return u("Referee/full snapshot upper-bound budget is too small for the selected schema/history");
+	}
+	let S = f.guards, C = f.openAccess;
+	if (S !== void 0 && (!Array.isArray(S) || !S.length || Reflect.ownKeys(S).length !== S.length + 1)) return u("Room guards require a nonempty dense explicit access decision");
+	if (C !== void 0 && (typeof C != "string" || !C.trim() || S !== void 0)) return u("Room openAccess requires a reason and cannot be combined with guards");
+	let w = [];
+	if (S) for (let e = 0; e < S.length; e++) {
+		let t = Object.getOwnPropertyDescriptor(S, String(e));
+		if (!t?.enumerable || !("value" in t)) return u("Room guard accessors and holes refuse");
+		w.push(t.value);
+	}
+	let T = Object.freeze(S ? w : C === void 0 ? [{ authenticated: !0 }] : [{ open: C }]), E = Object.keys(s()), D = Object.hasOwn(f, "budgets") ? t(f.budgets, E, []) : {}, O = v.roster.maxPlayers;
+	if (Object.hasOwn(f, "maxClients") && f.maxClients !== O) return u("Lockstep member capacity must equal its complete player budget");
+	let k = Object.hasOwn(f, "reconnect") ? t(f.reconnect, ["graceMs"], ["graceMs"]) : {};
+	if (Object.hasOwn(f, "reconnect") && typeof k.graceMs != "number") return u("Reconnect requires an actual positive grace duration");
+	let A = Object.hasOwn(f, "reconnect") ? Object.freeze({ graceMs: k.graceMs }) : Object.freeze({}), j = Object.hasOwn(f, "strategies") ? t(f.strategies, ["reconnectPolicy"], []) : {}, M = l.get(e) ?? A, N = Object.hasOwn(j, "reconnectPolicy") ? j.reconnectPolicy : c;
+	c(A), c(M);
+	let P = r(p, "reconnectPolicy", N, M), F = t(P, ["graceMs"], ["graceMs"]);
+	if (typeof F.graceMs != "number") return u("Reconnect slot must return its actual positive grace duration");
+	let I = c({ graceMs: F.graceMs }), L = o(Object.hasOwn(f, "messages") ? f.messages : {}), R = f.onMessage;
+	if (Object.hasOwn(f, "onMessage") && typeof R != "function" || Object.values(L).some((e) => e.direction !== "server") && !R) return u("Client-sendable Lockstep channels require a synchronous onMessage hook");
+	let z = Object.freeze({
+		_tag: "RoomDescriptor",
+		name: p,
+		mode: "lockstep",
+		simulation: m,
+		auth: "subject",
+		guards: T,
+		state: m.definition.state,
+		input: m.definition.input,
+		options: m.definition.options,
+		tickRate: d(Object.hasOwn(f, "tickRate") ? f.tickRate : 60, 1, 128),
+		maxCatchUpTicks: d(Object.hasOwn(f, "maxCatchUpTicks") ? f.maxCatchUpTicks : 5, 1, 128),
+		lifecycleTimeoutMs: d(Object.hasOwn(f, "lifecycleTimeoutMs") ? f.lifecycleTimeoutMs : 5e3, 1, 2147483647),
+		maxClients: O,
+		budgets: s(D),
+		reconnect: I,
+		strategies: Object.freeze({ reconnectPolicy: N }),
+		messages: L,
+		...R ? { onMessage: R } : {},
+		lockstep: Object.freeze({
+			...v.options,
+			inputSchema: m.definition.input,
+			inputDelayTicks: y,
+			rollbackHorizonTicks: b,
+			inputPrediction: x,
+			..._ ? { lateJoin: _ } : {}
+		})
+	});
+	return n(e, z), l.set(z, M), z;
+};
+export { f as captureLockstepRoomDefinition };

package/dist/lockstepHostLoop.js

@@ -0,0 +1,242 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { simulationOwnData as r } from "./simulationAuthoring.js";
+import { createRoomLockstepServer as i } from "./lockstepServerRoles.js";
+// src/lockstepHostLoop.ts
+function a(e) {
+	throw new t({ detail: e });
+}
+var o = class {
+	id;
+	#e;
+	#t;
+	#n;
+	#r = !1;
+	#i = !1;
+	#a = !1;
+	#o = !1;
+	#s = !1;
+	#c = !1;
+	#l = 0;
+	#u = 0;
+	#d = -1;
+	#f = [];
+	#p = 0;
+	constructor(e, t, a, o, s, c = {}, l = {}) {
+		if (typeof s != "function") throw new n({
+			room: "lockstep",
+			detail: "Host loop needs its actual captured clock callback"
+		});
+		let u = r(l, [
+			"tickRate",
+			"maxCatchUpTicks",
+			"maxPendingDeliveries",
+			"maxPendingInputRecordBytes"
+		], []), d = {
+			tickRate: 60,
+			maxCatchUpTicks: 5,
+			maxPendingDeliveries: 64,
+			maxPendingInputRecordBytes: 1048576
+		}, f = {
+			tickRate: 128,
+			maxCatchUpTicks: 128,
+			maxPendingDeliveries: 4096,
+			maxPendingInputRecordBytes: 16777216
+		}, p = { ...d };
+		for (let e of Object.keys(d)) {
+			let t = Object.hasOwn(u, e) ? u[e] : d[e];
+			if (!Number.isInteger(t) || t < 1 || t > f[e]) throw new n({
+				room: "lockstep",
+				detail: "Invalid bounded host-loop work limit"
+			});
+			Object.defineProperty(p, e, {
+				value: t,
+				enumerable: !0
+			});
+		}
+		this.#n = Object.freeze(p), this.#t = s;
+		let m = r(o, [
+			"roomId",
+			"tenantId",
+			"epoch"
+		], [
+			"roomId",
+			"tenantId",
+			"epoch"
+		]), h = Object.freeze({
+			roomId: m.roomId,
+			tenantId: m.tenantId,
+			epoch: m.epoch
+		});
+		this.#e = i(e, t, a, h, c), this.id = h.roomId;
+	}
+	outside() {
+		if (this.#i || this.#r) return a("Host delivery/admission/privacy operations belong outside its tick");
+	}
+	operation(e) {
+		this.outside(), this.#r = !0;
+		try {
+			return e();
+		} finally {
+			this.#r = !1;
+		}
+	}
+	live() {
+		if (this.#s || this.#c || this.#e.withdrawn) return a("Lockstep host owner is disposed, withdrawn or faulted");
+	}
+	clock() {
+		let e = this.#t();
+		return !Number.isFinite(e) || e < 0 || e < this.#d ? a("Lockstep host clock is not monotonic finite data") : (this.#d = e, e);
+	}
+	admit(e, t) {
+		return this.operation(() => (this.live(), this.#e.admit(e, t)));
+	}
+	rebind(e) {
+		return this.operation(() => (this.live(), this.#e.rebind(e)));
+	}
+	seal() {
+		return this.operation(() => {
+			if (this.live(), this.#o) return a("Host roster is already started");
+			let e = this.clock(), t = this.#e.seal();
+			return this.#u = e + 1e3 / this.#n.tickRate, this.#o = !0, this.#a = !0, t;
+		});
+	}
+	admitAt(e, t) {
+		return this.operation(() => (this.live(), this.#e.admitAt(e, t)));
+	}
+	join(e, t, n) {
+		return this.operation(() => (this.live(), this.#o ? this.#e.join(e, t, n) : a("Late join needs a started host roster")));
+	}
+	get inputTick() {
+		return this.#e.tick;
+	}
+	replayMatrix(e, t, n) {
+		this.operation(() => {
+			if (this.live(), !Array.isArray(t) || !Array.isArray(n) || Reflect.ownKeys(t).length !== t.length + 1 || Reflect.ownKeys(n).length !== n.length + 1 || !this.#o || !this.#a || !Number.isSafeInteger(e) || e < 1 || e > 4294967295 || t.length !== n.length || t.length < 1 || t.length > 64 || e !== this.#e.tick + 1 && e !== this.#e.tick) return a("Historical replay requires the exact next pre-delivery matrix");
+			let r = Array.from({ length: t.length }, (e, r) => {
+				let i = Object.getOwnPropertyDescriptor(t, String(r)), o = Object.getOwnPropertyDescriptor(n, String(r));
+				return !i?.enumerable || !o?.enumerable || !("value" in i) || !("value" in o) ? a("Historical replay requires own dense actual bindings") : {
+					session: i.value,
+					payload: o.value
+				};
+			});
+			if (this.#e.tick < e) {
+				for (let t of r) this.#e.submit(t.session, e, [t.payload]);
+				let t = this.#e.advance();
+				if (t._tag !== "relayed" || t.tick !== e) return a("Historical replay did not consume the complete real matrix");
+			}
+			this.#e.role !== "relay" && this.#e.pumpReferee(1);
+		});
+	}
+	finishBootstrap() {
+		this.operation(() => {
+			if (this.live(), !this.#o || !this.#a) return a("Host bootstrap is not awaiting supervision");
+			this.#u = this.clock() + 1e3 / this.#n.tickRate, this.#a = !1;
+		});
+	}
+	submit(e, t, n) {
+		return this.operation(() => (this.live(), this.#e.submit(e, t, n)));
+	}
+	submitHash(e, t, n) {
+		return this.operation(() => (this.live(), this.#e.submitHash(e, t, n)));
+	}
+	comparePendingHashes(e) {
+		return this.operation(() => (this.live(), this.#e.comparePendingHashes(e)));
+	}
+	recovery() {
+		return this.operation(() => (this.live(), this.#e.recovery()));
+	}
+	get serverRole() {
+		return this.#e.role;
+	}
+	advance() {
+		if (this.outside(), this.#s || !this.#o) return 0;
+		this.live(), this.#a = !1, this.#i = !0;
+		let t = 0;
+		try {
+			let n = this.clock(), r = 1e3 / this.#n.tickRate;
+			for (let i = 0; i < this.#n.maxCatchUpTicks && n >= this.#u; i++) {
+				if (this.#l === 4294967295) return a("Lockstep host observation tick is exhausted");
+				if (this.#f.length >= this.#n.maxPendingDeliveries) throw new e({
+					budget: "lockstepHostDeliveries",
+					limit: this.#n.maxPendingDeliveries
+				});
+				let n = this.#n.maxPendingInputRecordBytes - this.#p;
+				if (n < 1) throw new e({
+					budget: "lockstepHostInputRecords",
+					limit: this.#n.maxPendingInputRecordBytes
+				});
+				let i = this.#l + 1, o = this.#e.observeStall(i), s = this.#e.advance(n);
+				if (s._tag === "relayed" ? (this.#f.push(s), this.#p += s.inputRecordBytes, t++) : o._tag === "action" && this.#f.push(o), this.#l = i, this.#u += r, !Number.isFinite(this.#u)) return a("Lockstep host scheduling range is exhausted");
+				this.#e.role !== "relay" && this.#e.pumpReferee(1);
+			}
+			return t;
+		} catch (e) {
+			throw this.#c = !0, e;
+		} finally {
+			this.#i = !1;
+		}
+	}
+	drainDeliveries() {
+		return this.operation(() => {
+			let e = Object.freeze(this.#f.splice(0));
+			return this.#p = 0, e;
+		});
+	}
+	nextDelivery() {
+		return this.operation(() => this.#f[0] ?? null);
+	}
+	consumeDelivery(e) {
+		this.operation(() => {
+			if (this.#f[0] !== e) return a("Lockstep delivery acknowledgement does not name the retained head");
+			this.#f.shift(), e._tag === "relayed" && (this.#p -= e.inputRecordBytes);
+		});
+	}
+	retryFault() {
+		this.operation(() => {
+			if (this.#s || this.#e.withdrawn) return a("Cannot retry a disposed or withdrawn owner");
+			this.#c = !1;
+		});
+	}
+	drainOutbox() {
+		return this.operation(() => Object.freeze([]));
+	}
+	metrics() {
+		let e = this.#e.metrics();
+		return Object.freeze({
+			tick: e.tick,
+			droppedTicks: 0,
+			queuedInputs: e.pendingInputs + e.queuedInputs,
+			outboxCommands: 0,
+			clients: e.players,
+			extensionDurationMs: Object.freeze({}),
+			extensionOverruns: Object.freeze({})
+		});
+	}
+	roleMetrics() {
+		return Object.freeze({
+			...this.#e.metrics(),
+			observedTicks: this.#l,
+			faulted: this.#c,
+			pendingDeliveries: this.#f.length,
+			pendingInputRecordBytes: this.#p
+		});
+	}
+	exportSubject(e, t) {
+		return this.operation(() => this.#e.exportSubject(e, t));
+	}
+	eraseSubject(e, t) {
+		return this.operation(() => {
+			let n = this.#e.eraseSubject(e, t);
+			return n && (this.#s = !0, this.#f = [], this.#p = 0), n;
+		});
+	}
+	dispose() {
+		this.operation(() => {
+			this.#s || (this.#e.withdraw(), this.#s = !0, this.#f = [], this.#p = 0);
+		});
+	}
+	isDisposed() {
+		return this.#s || this.#e.withdrawn;
+	}
+}, s = (e, t, n, r, i, a = {}, s = {}) => new o(e, t, n, r, i, a, s);
+export { o as RoomLockstepHostLoop, s as createRoomLockstepHostLoop };

package/dist/lockstepInitialAdmission.js

@@ -0,0 +1,66 @@
+import { ProtocolError as e } from "./errors.js";
+import { unsignedWord as t } from "./fixedWords.js";
+import { simulationOwnData as n, simulationSyncValue as r } from "./simulationAuthoring.js";
+import { captureRoomLockstepWireRoster as i } from "./lockstepWireRoster.js";
+import { captureLockstepJournalScope as a, lockstepJournalIdentity as o } from "./lockstepJournalCodec.js";
+// src/lockstepInitialAdmission.ts
+function s(t) {
+	throw new e({ detail: t });
+}
+var c = (e, t) => {
+	let r = [
+		"roomId",
+		"tenantId",
+		"epoch",
+		"maxPlayers",
+		"players"
+	], c = n(e, t ? [
+		...r,
+		"subjectId",
+		"sessionId"
+	] : r, t ? [
+		...r,
+		"subjectId",
+		"sessionId"
+	] : r), l = a({
+		roomId: c.roomId,
+		tenantId: c.tenantId,
+		epoch: c.epoch
+	}), u = c.maxPlayers;
+	if (!Number.isInteger(u) || u < 1 || u > 64 || !Array.isArray(c.players) || Reflect.ownKeys(c.players).length !== c.players.length + 1) return s("Initial roster strategy requires bounded complete own data");
+	let d = c.players.length ? i(c.players, u) : Object.freeze([]);
+	return Object.freeze({
+		...l,
+		maxPlayers: u,
+		players: d,
+		...t ? {
+			subjectId: o(c.subjectId),
+			sessionId: o(c.sessionId)
+		} : {}
+	});
+}, l = (e) => {
+	let t = c(e, !0), n = new Set(t.players.map((e) => e.playerId));
+	if (n.size >= t.maxPlayers) return s("Initial player strategy cannot exceed the actual roster capacity");
+	let r = 0;
+	for (; n.has(r);) r++;
+	return r;
+}, u = (e) => {
+	let t = c(e, !1);
+	return t.players.length === t.maxPlayers;
+}, d = (e = {}) => {
+	let t = n(e, ["playerId", "start"], []);
+	for (let e of ["playerId", "start"]) if (Object.hasOwn(t, e) && typeof t[e] != "function") return s("Initial roster strategy slots must be callable");
+	return Object.freeze({
+		playerId: t.playerId ?? l,
+		start: t.start ?? u
+	});
+}, f = (e, n = l) => {
+	if (typeof n != "function") return s("Initial player strategy must be callable");
+	let i = c(e, !0), a = t(r(n(i)));
+	return i.players.length >= i.maxPlayers || i.players.some((e) => e.playerId === a) ? s("Initial player strategy changed actual uniqueness/capacity") : a;
+}, p = (e, t = u) => {
+	if (typeof t != "function") return s("Initial start strategy must be callable");
+	let n = r(t(c(e, !1)));
+	return typeof n == "boolean" ? n : s("Initial start strategy must return an actual synchronous boolean");
+};
+export { d as captureRoomLockstepInitialStrategies, l as firstFreeRoomLockstepPlayerId, f as resolveRoomLockstepInitialPlayerId, p as resolveRoomLockstepInitialStart, u as startFullRoomLockstepRoster };

package/dist/lockstepInitialStrategyFixtures.js

@@ -0,0 +1,44 @@
+import { firstFreeRoomLockstepPlayerId as e, resolveRoomLockstepInitialPlayerId as t, resolveRoomLockstepInitialStart as n, startFullRoomLockstepRoster as r } from "./lockstepInitialAdmission.js";
+import { Effect as i } from "effect";
+// src/lockstepInitialStrategyFixtures.ts
+var a = {
+	roomId: "initial-fixture-room",
+	tenantId: "initial-fixture-tenant",
+	epoch: 1,
+	maxPlayers: 2,
+	players: [{
+		slot: 0,
+		playerId: 0
+	}]
+}, o = {
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => i.sync(() => t({
+			...a,
+			subjectId: "initial-fixture-subject",
+			sessionId: "initial-fixture-session"
+		})),
+		expected: 1
+	},
+	overrideProbe: {
+		run: () => i.sync(() => t({
+			...a,
+			subjectId: "initial-fixture-subject",
+			sessionId: "initial-fixture-session"
+		}, () => 42)),
+		expected: 42
+	}
+}, s = {
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => i.sync(() => n(a)),
+		expected: !1
+	},
+	overrideProbe: {
+		run: () => i.sync(() => n(a, () => !0)),
+		expected: !0
+	}
+};
+export { o as lockstepInitialPlayerSlotFixture, s as lockstepInitialStartSlotFixture };