@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepServer.js

@@ -0,0 +1,324 @@
+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 } from "./simulationAuthoring.js";
+import { captureSimulationBytes as o } from "./simulationBytes.js";
+import { simulationValueCodec as s } from "./simulationState.js";
+import { captureLockstepRosterOptions as c } from "./lockstepRosterConfig.js";
+import { RoomInputCodec as l } from "./stateCodec.js";
+import { RoomLockstepJournalPort as u } from "./lockstepJournalPorts.js";
+import { RoomLockstepAdmissionPort as d } from "./lockstepAdmissionPorts.js";
+import { RoomLockstepTerminalPort as f } from "./lockstepTerminalPorts.js";
+import { RoomLockstepMemberOwner as p } from "./lockstepMembers.js";
+import { captureRoomAdmittedSessionReader as m } from "./serverSession.js";
+import { dataStoreRoomLockstepJournal as h, roomLockstepJournalLayer as g } from "./lockstepJournal.js";
+import { rebuildRoomLockstepAuthorityFromSql as _, rebuildRoomLockstepFromSql as v } from "./lockstepJournalRebuild.js";
+import { dataStoreRoomLockstepAdmission as y, roomLockstepAdmissionLayer as b } from "./lockstepAdmission.js";
+import { dataStoreRoomLockstepTerminal as x, roomLockstepTerminalLayer as S } from "./lockstepTerminal.js";
+import { RoomRuntime as C } from "./runtime.js";
+import { RoomLockstepServer as w, createRoomLockstepServer as T } from "./lockstepServerRoles.js";
+import { RoomLockstepHostLoop as E, createRoomLockstepHostLoop as D } from "./lockstepHostLoop.js";
+import { RoomLockstepTransportOwner as O, createRoomLockstepTransportOwner as k } from "./lockstepTransport.js";
+import { RoomLockstepOwnedRoom as A } from "./lockstepOwnedRoom.js";
+import { Result as j } from "effect";
+// src/lockstepServer.ts
+function M(e) {
+	throw new t({ detail: e });
+}
+function N(e) {
+	throw new n({
+		room: "lockstep",
+		detail: e
+	});
+}
+var P = (e, t) => t !== null && Object.keys(e).every((n) => t[n] === e[n]), F = (e) => {
+	let t = 0, n = 0;
+	for (let r of e) r < 32 ? n = (n | 1 << r) >>> 0 : t = (t | 1 << r - 32) >>> 0;
+	return Object.freeze({
+		hi: t,
+		lo: n
+	});
+}, I = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a = !1;
+	#o = !1;
+	#s = /* @__PURE__ */ new Map();
+	#c = /* @__PURE__ */ new Map();
+	#l = /* @__PURE__ */ new Set();
+	#u = /* @__PURE__ */ new Set();
+	#d = /* @__PURE__ */ new Map();
+	#f = /* @__PURE__ */ new Map();
+	#p = 0;
+	#m = 0;
+	constructor(e, t, n = {}) {
+		let i = a(t, [
+			"roomId",
+			"tenantId",
+			"epoch"
+		], [
+			"roomId",
+			"tenantId",
+			"epoch"
+		]), o = (e) => typeof e == "string" && e.length > 0 && e.length <= 191 && e.trim() === e && !/[\u0000-\u001f\u007f]/.test(e) ? e : N("Invalid lockstep roster owner scope"), u = r(i.epoch);
+		u > 2147483647 && N("Lockstep epoch exceeds SQL ownership range"), this.#e = Object.freeze({
+			roomId: o(i.roomId),
+			tenantId: o(i.tenantId),
+			epoch: u
+		});
+		let d = c(n);
+		this.#t = d, this.#i = d.initialTick;
+		let f = Math.min(4096, d.maxPendingBytes * 7);
+		this.#n = new l(e, {
+			maxBytes: d.maxPendingBytes,
+			maxFieldId: f
+		}), this.#r = s(e, {
+			maxBytes: d.maxPendingBytes,
+			maxFieldId: f
+		}, !1, !0);
+	}
+	get tick() {
+		return this.#i;
+	}
+	get sealed() {
+		return this.#a;
+	}
+	metrics() {
+		return Object.freeze({
+			pendingInputs: this.#p,
+			pendingBytes: this.#m,
+			players: this.#s.size
+		});
+	}
+	work(e) {
+		if (this.#o) return M("Lockstep roster work cannot reenter admission, input, projection or privacy");
+		this.#o = !0;
+		try {
+			return e();
+		} finally {
+			this.#o = !1;
+		}
+	}
+	admit(e, t) {
+		return this.work(() => this.admitOwned(e, t));
+	}
+	admitAt(e, t) {
+		return this.work(() => {
+			let n = a(e, ["slot", "playerId"], ["slot", "playerId"]);
+			return !Number.isInteger(n.slot) || n.slot < 0 || n.slot > 63 ? M("Restored roster requires an actual bounded slot") : this.admitOwned(r(n.playerId), t, n.slot);
+		});
+	}
+	rebind(e) {
+		return this.work(() => {
+			let t = m(e), n = t.identity(), r = n ? this.#c.get(n.sessionId) : void 0, i = r === void 0 ? void 0 : this.#s.get(r);
+			return !this.#a || !n || !i || i.read.identity() !== null || n.roomId !== this.#e.roomId || n.tenantId !== this.#e.tenantId || n.epoch !== this.#e.epoch || n.subjectId !== i.evidence.subjectId || n.sessionId !== i.evidence.sessionId || t.inputSchemaHash() !== this.#n.schemaHash ? M("Reconnect requires the same retained withdrawn player with actual current admission") : (this.#s.set(i.player.slot, Object.freeze({
+				player: i.player,
+				evidence: n,
+				read: t
+			})), i.player);
+		});
+	}
+	seal() {
+		return this.work(() => this.sealOwned());
+	}
+	join(e, t, n) {
+		return this.work(() => {
+			if (!this.#a) return M("Late join requires a sealed roster");
+			let i = a(e, ["slot", "playerId"], ["slot", "playerId"]);
+			if (!Number.isInteger(i.slot) || i.slot < 0 || i.slot > 63) return M("Late join requires an actual bounded slot");
+			if (!Number.isSafeInteger(n) || n <= this.#i || n > 4294967295) return M("Late join tick must lie ahead of the consumed frontier");
+			this.#a = !1;
+			try {
+				let e = this.admitOwned(r(i.playerId), t, i.slot);
+				return this.#d.set(e.slot, n), e;
+			} finally {
+				this.#a = !0;
+			}
+		});
+	}
+	activeAt(e) {
+		return [...this.#s].filter(([t]) => (this.#d.get(t) ?? 0) <= e).sort((e, t) => e[0] - t[0]);
+	}
+	submit(e, t, n) {
+		return this.work(() => this.submitOwned(e, t, n));
+	}
+	next() {
+		return this.work(() => this.nextOwned());
+	}
+	consumeNext() {
+		return this.work(() => this.consumeNextOwned());
+	}
+	eraseSubject(e, t) {
+		return this.work(() => this.eraseSubjectOwned(e, t));
+	}
+	exportSubject(e, t) {
+		return this.work(() => this.exportSubjectOwned(e, t));
+	}
+	playerForSession(e) {
+		return this.work(() => {
+			let t = m(e).identity(), n = t ? this.#c.get(t.sessionId) : void 0, r = n === void 0 ? void 0 : this.#s.get(n);
+			return !this.#a || !r || !P(r.evidence, t) || !this.current(r) ? M("Lockstep player admission is no longer current") : r.player;
+		});
+	}
+	playersForSubject(e, t) {
+		return this.work(() => (this.privacyScope(e, t), Object.freeze([...this.#s.values()].filter((e) => e.evidence.subjectId === t).map((e) => e.player))));
+	}
+	withdraw() {
+		this.work(() => {
+			for (let e of [...this.#s.keys()]) this.removeSlot(e);
+		});
+	}
+	privacyScope(e, t) {
+		if (e !== this.#e.tenantId || typeof t != "string" || !t || t.length > 191) return M("Lockstep privacy scope does not match its Room owner");
+	}
+	current(e) {
+		return P(e.evidence, e.read.identity()) && e.read.inputSchemaHash() === this.#n.schemaHash;
+	}
+	admitOwned(t, n, i) {
+		if (r(t), this.#a) return M("Lockstep roster is sealed; late admission requires actual server snapshot integration");
+		let a = m(n), o = a.identity();
+		if (!o || o.roomId !== this.#e.roomId || o.tenantId !== this.#e.tenantId || o.epoch !== this.#e.epoch || a.inputSchemaHash() !== this.#n.schemaHash) return M("Lockstep requires the exact actual player admission and input layout");
+		if (this.#l.has(t) || this.#c.has(o.sessionId)) return M("Lockstep player/session identity is already assigned");
+		if (this.#u.size >= this.#t.maxPlayers) throw new e({
+			budget: "lockstepRosterSlots",
+			limit: this.#t.maxPlayers
+		});
+		let s = i ?? 0;
+		if (i === void 0) for (; this.#u.has(s);) s++;
+		if (this.#u.has(s)) return M("Lockstep player slot is already assigned");
+		let c = Object.freeze({
+			slot: s,
+			playerId: t
+		}), l = Object.freeze({
+			player: c,
+			evidence: o,
+			read: a
+		});
+		return this.#s.set(s, l), this.#c.set(o.sessionId, s), this.#l.add(t), this.#u.add(s), c;
+	}
+	sealOwned() {
+		if (this.#s.size === 0 || [...this.#s.values()].some((e) => !this.current(e))) return M("Cannot seal unavailable lockstep player admissions");
+		let e = Object.freeze([...this.#s.values()].map((e) => e.player));
+		return this.#a = !0, e;
+	}
+	submitOwned(t, n, a) {
+		if (!this.#a) return M("Lockstep input requires a sealed actual roster");
+		let s = m(t).identity(), c = s ? this.#c.get(s.sessionId) : void 0, l = c === void 0 ? void 0 : this.#s.get(c);
+		if (!l || !P(l.evidence, s) || !this.current(l)) return M("Lockstep player admission is no longer current");
+		if (r(n), !Array.isArray(a) || a.length < 1 || a.length > this.#t.maxBatchInputs || Reflect.ownKeys(a).length !== a.length + 1 || n > 4294967295 - a.length + 1) return M("Lockstep input batch exceeds dense/count/tick work");
+		let u = [], d = 0, f = 0, p = 0;
+		for (let t = 0; t < a.length; t++) {
+			let r = n + t;
+			if (r <= this.#i || r < (this.#d.get(l.player.slot) ?? 0)) {
+				f++;
+				continue;
+			}
+			if (r > this.#i + this.#t.maxFutureTicks) throw new e({
+				budget: "lockstepFutureTicks",
+				limit: this.#t.maxFutureTicks
+			});
+			let s = Object.getOwnPropertyDescriptor(a, String(t));
+			if (!s?.enumerable || !("value" in s)) return M("Lockstep input batch accessors refuse");
+			let c = o(s.value, this.#t.maxPendingBytes, "lockstepPendingBytes"), m = this.#f.get(r)?.get(l.player.slot);
+			if (m) {
+				if (c.length !== m.bytes.length || c.some((e, t) => e !== m.bytes[t])) return M("Conflicting lockstep intent for an admitted player tick");
+				d++;
+				continue;
+			}
+			if (this.#p + u.length + 1 > this.#t.maxPendingInputs) throw new e({
+				budget: "lockstepPendingInputs",
+				limit: this.#t.maxPendingInputs
+			});
+			if (p += c.length, this.#m + p > this.#t.maxPendingBytes) throw new e({
+				budget: "lockstepPendingBytes",
+				limit: this.#t.maxPendingBytes
+			});
+			let h = this.#n.decodeFull(c);
+			if (j.isFailure(h)) throw h.failure;
+			let g = i(this.#r.capture(h.success));
+			u.push({
+				tick: r,
+				pending: Object.freeze({
+					input: g,
+					bytes: c
+				})
+			});
+		}
+		for (let e of u) {
+			let t = this.#f.get(e.tick);
+			t || (t = /* @__PURE__ */ new Map(), this.#f.set(e.tick, t)), t.set(l.player.slot, e.pending);
+		}
+		return this.#p += u.length, this.#m += p, Object.freeze({
+			accepted: u.length,
+			duplicates: d,
+			expired: f
+		});
+	}
+	nextOwned() {
+		if (!this.#a) return M("Lockstep next input requires a sealed roster");
+		let e = r(this.#i + 1), t = this.activeAt(e);
+		if (!t.length) return Object.freeze({
+			_tag: "empty",
+			tick: e
+		});
+		let n = this.#f.get(e), a = [], o = [];
+		for (let [e, r] of t) {
+			let t = n?.get(e);
+			!t || !this.current(r) ? a.push(e) : o.push(Object.freeze({
+				playerId: r.player.playerId,
+				input: i(this.#r.capture(t.input))
+			}));
+		}
+		for (let [e, n] of t) !this.current(n) && !a.includes(e) && a.push(e);
+		return a.length ? Object.freeze({
+			_tag: "waiting",
+			tick: e,
+			waitingFor: F(a)
+		}) : Object.freeze({
+			_tag: "complete",
+			tick: e,
+			players: F(t.map(([e]) => e)),
+			inputs: Object.freeze(o)
+		});
+	}
+	consumeNextOwned() {
+		let e = this.nextOwned();
+		if (e._tag !== "complete") return e;
+		let t = this.#f.get(e.tick);
+		if (!t) return M("Lockstep pending matrix disappeared");
+		for (let e of t.values()) this.#p--, this.#m -= e.bytes.length;
+		return this.#f.delete(e.tick), this.#i = e.tick, e;
+	}
+	removeSlot(e) {
+		let t = this.#s.get(e);
+		if (t) {
+			for (let [t, n] of this.#f) {
+				let r = n.get(e);
+				r && (this.#p--, this.#m -= r.bytes.length, r.bytes.fill(0), n.delete(e)), n.size || this.#f.delete(t);
+			}
+			this.#s.delete(e), this.#c.delete(t.evidence.sessionId), this.#d.delete(e);
+		}
+	}
+	eraseSubjectOwned(e, t) {
+		this.privacyScope(e, t);
+		let n = [...this.#s.entries()].filter(([, e]) => e.evidence.subjectId === t).map(([e]) => e);
+		for (let e of n) this.removeSlot(e);
+		return n.length;
+	}
+	exportSubjectOwned(e, t) {
+		this.privacyScope(e, t);
+		let n = [];
+		for (let [e, r] of this.#s) if (r.evidence.subjectId === t) for (let [t, a] of this.#f) {
+			let o = a.get(e);
+			o && n.push(Object.freeze({
+				tick: t,
+				playerId: r.player.playerId,
+				input: i(this.#r.capture(o.input))
+			}));
+		}
+		return n.sort((e, t) => e.tick - t.tick || e.playerId - t.playerId), Object.freeze(n);
+	}
+}, L = (e, t, n = {}) => new I(e, t, n);
+export { d as RoomLockstepAdmissionPort, E as RoomLockstepHostLoop, I as RoomLockstepInputRoster, u as RoomLockstepJournalPort, p as RoomLockstepMemberOwner, A as RoomLockstepOwnedRoom, w as RoomLockstepServer, f as RoomLockstepTerminalPort, O as RoomLockstepTransportOwner, C as RoomRuntime, D as createRoomLockstepHostLoop, L as createRoomLockstepInputRoster, T as createRoomLockstepServer, k as createRoomLockstepTransportOwner, y as dataStoreRoomLockstepAdmission, h as dataStoreRoomLockstepJournal, x as dataStoreRoomLockstepTerminal, _ as rebuildRoomLockstepAuthorityFromSql, v as rebuildRoomLockstepFromSql, b as roomLockstepAdmissionLayer, g as roomLockstepJournalLayer, S as roomLockstepTerminalLayer };

package/dist/lockstepServerConfig.js

@@ -0,0 +1,100 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { captureLockstepRosterOptions as n } from "./lockstepRosterConfig.js";
+import { createLockstepPolicies as r, defaultLockstepStallPolicy as i } from "./lockstepPolicies.js";
+// src/lockstepServerConfig.ts
+function a(t) {
+	throw new e({
+		room: "lockstep",
+		detail: t
+	});
+}
+var o = Object.freeze({
+	refereeLagTicks: 12,
+	hashEvery: 10,
+	hashHistoryTicks: 64,
+	maxQueuedTicks: 64,
+	maxQueuedInputBytes: 1048576,
+	maxPendingHashes: 256,
+	maxRefereeSteps: 8,
+	maxReplayTicks: 16,
+	maxReplayInputBytes: 1048576,
+	maxSnapshotBudgetBytes: 134217728,
+	maxRejectionAttempts: 64
+}), s = Object.freeze({
+	refereeLagTicks: 4096,
+	hashEvery: 4096,
+	hashHistoryTicks: 4096,
+	maxQueuedTicks: 4096,
+	maxQueuedInputBytes: 16777216,
+	maxPendingHashes: 262144,
+	maxRefereeSteps: 4096,
+	maxReplayTicks: 4096,
+	maxReplayInputBytes: 16777216,
+	maxSnapshotBudgetBytes: 268435456,
+	maxRejectionAttempts: 65536
+}), c = (e = {}) => {
+	let c = [
+		"maxPlayers",
+		"maxFutureTicks",
+		"maxBatchInputs",
+		"maxPendingInputs",
+		"maxPendingBytes"
+	], l = t(e, [
+		...c,
+		...Object.keys(o),
+		"serverRole",
+		"onDesync",
+		"stallPolicy",
+		"strategies"
+	], []), u = Object.hasOwn(l, "serverRole") ? l.serverRole : "relay";
+	if (u !== "relay" && u !== "referee" && u !== "full") return a("Invalid lockstep server role");
+	let d = { ...o };
+	for (let e of Object.keys(o)) {
+		let t = Object.hasOwn(l, e) ? l[e] : o[e];
+		if (!Number.isSafeInteger(t) || t < (e === "refereeLagTicks" ? 0 : 1) || t > s[e]) return a("Invalid bounded lockstep role work limit");
+		Object.defineProperty(d, e, {
+			value: t,
+			enumerable: !0
+		});
+	}
+	let f = Object.hasOwn(l, "onDesync") ? l.onDesync : "resync";
+	if (f !== "resync" && f !== "end" && f !== "flag" && typeof f != "function") return a("Invalid lockstep desync policy");
+	let p = t(Object.hasOwn(l, "strategies") ? l.strategies : {}, [
+		"refereeLag",
+		"stallPolicy",
+		"onDesync"
+	], []);
+	if (typeof f == "function") {
+		if (Object.hasOwn(p, "onDesync")) return a("Configure desync through one actual callback or strategy slot");
+		p.onDesync = f;
+	}
+	let m = d.refereeLagTicks, h = i(Object.hasOwn(l, "stallPolicy") ? l.stallPolicy : {}), g = r({
+		refereeLagTicks: m,
+		stallPolicy: h,
+		onDesync: typeof f == "function" ? "resync" : f
+	}, p);
+	if (Object.defineProperty(d, "refereeLagTicks", {
+		value: g.refereeLagTicks,
+		enumerable: !0
+	}), d.refereeLagTicks >= d.maxQueuedTicks) return a("Referee queue must exceed its configured lag");
+	let _ = {};
+	for (let e of c) Object.hasOwn(l, e) && (_[e] = l[e]);
+	let { initialTick: v, ...y } = n(_), b = Object.freeze(p), x = Object.freeze({
+		...d,
+		...y,
+		refereeLagTicks: m,
+		serverRole: u,
+		stallPolicy: h,
+		onDesync: typeof f == "function" ? "resync" : f,
+		strategies: b
+	});
+	return Object.freeze({
+		role: u,
+		limits: Object.freeze(d),
+		roster: Object.freeze(y),
+		policies: g,
+		options: x
+	});
+};
+export { c as captureRoomLockstepServerOptions };