@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepPolicies.js

@@ -0,0 +1,83 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { captureUint64Words as t, unsignedWord as n } from "./fixedWords.js";
+import { simulationOwnData as r, simulationSyncValue as i } from "./simulationAuthoring.js";
+// src/lockstepPolicies.ts
+function a(t) {
+	throw new e({
+		room: "lockstep",
+		detail: t
+	});
+}
+var o = (e, t) => !Number.isInteger(e) || e < t || e > 4096 ? a("Lockstep policy ticks exceed their bounded integer domain") : e, s = (e) => e === "resync" || e === "end" || e === "flag" ? e : a("Invalid lockstep desync action"), c = (e) => o(e, 0), l = (e) => {
+	let t = r(e, ["afterTicks", "action"], []), n = o(Object.hasOwn(t, "afterTicks") ? t.afterTicks : 8, 1), i = Object.hasOwn(t, "action") ? t.action : "pause";
+	return i !== "pause" && i !== "drop-player" ? a("Invalid lockstep stall action") : Object.freeze({
+		afterTicks: n,
+		action: i
+	});
+}, u = (e, t) => s(t), d = class {
+	refereeLagTicks;
+	stallPolicy;
+	#e;
+	#t;
+	#n = !1;
+	constructor(e = {}, t = {}) {
+		let n = r(e, [
+			"refereeLagTicks",
+			"stallPolicy",
+			"onDesync"
+		], []), d = r(t, [
+			"refereeLag",
+			"stallPolicy",
+			"onDesync"
+		], []);
+		for (let e of Object.keys(d)) typeof d[e] != "function" && a("Lockstep policy strategies require captured functions");
+		let f = Object.hasOwn(n, "refereeLagTicks") ? o(n.refereeLagTicks, 0) : 12, p = d.refereeLag ?? c;
+		this.refereeLagTicks = o(i(p(f)), 0);
+		let m = l(Object.hasOwn(n, "stallPolicy") ? n.stallPolicy : {}), h = d.stallPolicy ?? l, g = r(i(h(m)), ["afterTicks", "action"], ["afterTicks", "action"]);
+		this.stallPolicy = l(g), this.#e = s(Object.hasOwn(n, "onDesync") ? n.onDesync : "resync"), this.#t = d.onDesync ?? u, Object.freeze(this);
+	}
+	stallDecision(e, r, i) {
+		if (n(e), n(r), r < 1) return a("Stall decision requires actual positive host observation ticks");
+		let o = t(i);
+		if (o.hi === 0 && o.lo === 0) return a("Stall decision requires a nonempty waiting-player mask");
+		let s = {
+			tick: e,
+			elapsedTicks: r,
+			waitingFor: o
+		};
+		return r < this.stallPolicy.afterTicks ? Object.freeze({
+			_tag: "waiting",
+			...s
+		}) : Object.freeze({
+			_tag: "action",
+			...s,
+			action: this.stallPolicy.action
+		});
+	}
+	desync(e) {
+		if (this.#n) return a("Lockstep desync policy cannot reenter its owner");
+		this.#n = !0;
+		try {
+			let a = r(e, [
+				"tick",
+				"playerId",
+				"expected",
+				"received"
+			], [
+				"tick",
+				"playerId",
+				"expected",
+				"received"
+			]), o = Object.freeze({
+				tick: n(a.tick),
+				playerId: n(a.playerId),
+				expected: t(a.expected),
+				received: t(a.received)
+			});
+			return s(i(this.#t(o, this.#e)));
+		} finally {
+			this.#n = !1;
+		}
+	}
+}, f = (e = {}, t = {}) => new d(e, t);
+export { d as LockstepPolicyOwner, f as createLockstepPolicies, u as defaultLockstepDesync, c as defaultLockstepRefereeLag, l as defaultLockstepStallPolicy };

package/dist/lockstepReact.js

@@ -0,0 +1,46 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { simulationSyncValue as t } from "./simulationAuthoring.js";
+import { isRoomLockstepClientSession as n } from "./lockstepClientSession.js";
+import { useCallback as r, useMemo as i, useSyncExternalStore as a } from "react";
+// src/lockstepReact.ts
+var o = (t) => {
+	if (!n(t)) throw new e({
+		room: "lockstep-react",
+		detail: "Hooks require an actual borrowed Lockstep client Session"
+	});
+}, s = (e) => {
+	o(e);
+	let t = r((t) => e.subscribe(t), [e]), n = r(() => e.observation(), [e]);
+	return a(t, n, n);
+}, c = (n, s, c = Object.is) => {
+	if (o(n), typeof s != "function" || typeof c != "function") throw new e({
+		room: "lockstep-react",
+		detail: "State projection requires synchronous selector and equality functions"
+	});
+	let l = r((e) => n.subscribe(e), [n]), u = i(() => {
+		let r = null, i = null;
+		return () => {
+			let a = n.observation();
+			if (a !== r) {
+				let n = t(s(a.snapshot?.state ?? null)), o = i ? t(c(i.value, n)) : !1;
+				if (typeof o != "boolean") throw new e({
+					room: "lockstep-react",
+					detail: "Projection equality requires an actual synchronous boolean"
+				});
+				o || (i = { value: n }), r = a;
+			}
+			return i.value;
+		};
+	}, [
+		n,
+		s,
+		c
+	]);
+	return a(l, u, u);
+}, l = (e) => (o(e), i(() => Object.freeze({
+	sendIntent: e.sendIntent.bind(e),
+	sendInitialIntents: e.sendInitialIntents.bind(e),
+	retryIntent: e.retryIntent.bind(e),
+	resendRetainedIntent: e.resendRetainedIntent.bind(e)
+}), [e]));
+export { l as useLocalInput, s as useLockstepRoom, c as useSimState };

package/dist/lockstepRecoveryTruth.js

@@ -0,0 +1,120 @@
+import { ProtocolError as e } from "./errors.js";
+import { simulationOwnData as t, simulationSyncValue as n } from "./simulationAuthoring.js";
+import { defineRoom as r } from "./room.js";
+import "./identities.js";
+import { assertRoomSubjectAdmission as i } from "./subjectAdmission.js";
+import { createLockstepJournalCodec as a, sealRoomLockstepJournal as o } from "./lockstepJournalCodec.js";
+import { readStoredLockstepJournal as s } from "./lockstepJournalRows.js";
+import { createRoomLockstepAdmissionCodec as c, sealRoomLockstepAdmission as l } from "./lockstepAdmissionCodec.js";
+import { and as u, eq as d } from "@voltro/database";
+// src/lockstepRecoveryTruth.ts
+function f(t) {
+	throw new e({ detail: t });
+}
+var p = (e) => {
+	if (e === void 0) return null;
+	let n = t(e, [
+		"descriptor",
+		"maxTicks",
+		"maxJournalBytes",
+		"maxPlayers"
+	], ["descriptor"]);
+	if (typeof n.descriptor != "function") return f("Lockstep recovery requires its actual declaration resolver");
+	let r = {
+		maxTicks: 65536,
+		maxJournalBytes: 16777216,
+		maxPlayers: 64
+	}, i = {
+		maxTicks: 65536,
+		maxJournalBytes: 67108864,
+		maxPlayers: 64
+	}, a = { ...r };
+	for (let e of Object.keys(r)) {
+		let t = Object.hasOwn(n, e) ? n[e] : r[e];
+		if (!Number.isSafeInteger(t) || t < 1 || t > i[e]) return f("Invalid bounded Lockstep recovery truth limit");
+		Object.defineProperty(a, e, {
+			value: t,
+			enumerable: !0
+		});
+	}
+	return Object.freeze({
+		descriptor: n.descriptor,
+		...a
+	});
+}, m = async (e, t, o) => {
+	if (t.lockstepAdmission == null && t.lockstepJournal == null && t.lockstepCreatorSubjectId == null) return null;
+	if (!o || typeof t.name != "string" || typeof t.hostId != "string") return f("Lockstep recovery cannot infer a declaration or owner");
+	if (t.erasure != null || t.snapshotErasure != null || t.options != null) return f("Lockstep recovery truth is privacy-fenced or contains state options");
+	let l = n(o.descriptor(t.name));
+	if (!l) return f("Lockstep recovery declaration is unavailable");
+	let p = r(l);
+	if (p.mode !== "lockstep" || p.name !== t.name || p.maxClients !== t.maxClients) return f("Lockstep recovery declaration/capacity changed");
+	let m = {
+		roomId: t.id,
+		tenantId: t.tenantId,
+		epoch: t.epoch
+	}, h = c(p.simulation, o.maxJournalBytes), g = h.captureStored(t.lockstepAdmission, m, t.hostId);
+	if (g.initial.name !== p.name || t.lockstepCreatorSubjectId !== g.initial.creatorSubjectId) return f("Lockstep recovery indexed creator changed");
+	if (await i(e, {
+		tenantId: m.tenantId,
+		subjectId: g.initial.creatorSubjectId
+	}), (await e.query({
+		table: "_voltro_room_snapshots",
+		predicate: u(d("roomId", m.roomId), d("tenantId", m.tenantId)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["roomId"],
+		lock: "update"
+	})).length) return f("Lockstep recovery cannot combine state checkpoints with retained inputs");
+	let _ = t.lockstepJournal == null ? null : a(p.simulation, o.maxTicks, o.maxJournalBytes, o.maxPlayers).captureStored(await s(e, t, o.maxTicks), m, t.hostId);
+	if (_) {
+		if (_.initial.seed !== g.initial.seed || _.initial.options !== g.initial.options || _.initial.stateSchemaHash !== g.initial.stateSchemaHash || _.initial.inputSchemaHash !== g.initial.inputSchemaHash) return f("Lockstep recovery journal changed initial metadata");
+		for (let t of _.initial.players) await i(e, {
+			tenantId: m.tenantId,
+			subjectId: t.subjectId
+		});
+	}
+	return Object.freeze({
+		admission: g,
+		journal: _,
+		options: h.optionsWire.decode(Buffer.from(g.initial.options, "base64url"))
+	});
+}, h = (e, t, n, r, i) => {
+	let a = n + 1, s = `room-recovery:${n}:${a}`;
+	if (a > 2147483647) return f("Lockstep recovery SQL epoch is exhausted");
+	if (r) {
+		for (let r of [e.admission, e.journal]) if (r && (r.hostId !== t || r.ownerEpoch !== a || r.adoption?.requestId !== s || r.adoption.priorEpoch !== n)) return f("Lockstep recovery retry changed its immutable claim");
+		return e;
+	}
+	for (let t of [e.admission, e.journal]) if (t && t.ownerEpoch !== n) return f("Lockstep recovery predecessor changed");
+	let { digest: c, ...u } = e.admission, d = l({
+		...u,
+		hostId: t,
+		ownerEpoch: a,
+		adoption: {
+			requestId: s,
+			priorEpoch: n
+		}
+	});
+	if (Buffer.byteLength(JSON.stringify(d), "utf8") > i) return f("Lockstep recovery metadata exceeds its complete byte budget");
+	let p = null;
+	if (e.journal) {
+		let { digest: r, ...c } = e.journal;
+		p = o({
+			...c,
+			hostId: t,
+			ownerEpoch: a,
+			adoption: {
+				requestId: s,
+				priorEpoch: n
+			}
+		}, i);
+	}
+	return Object.freeze({
+		admission: d,
+		journal: p,
+		options: e.options
+	});
+};
+export { h as adoptRoomLockstepRecoveryTruth, p as captureRoomLockstepRecoveryOptions, m as readRoomLockstepRecoveryTruth };

package/dist/lockstepRosterConfig.js

@@ -0,0 +1,31 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+// src/lockstepRosterConfig.ts
+var n = (n = {}) => {
+	let r = t(n, [
+		"initialTick",
+		"maxPlayers",
+		"maxFutureTicks",
+		"maxBatchInputs",
+		"maxPendingInputs",
+		"maxPendingBytes"
+	], []), i = {
+		initialTick: 0,
+		maxPlayers: 8,
+		maxFutureTicks: 16,
+		maxBatchInputs: 4,
+		maxPendingInputs: 256,
+		maxPendingBytes: 65536
+	}, a = { ...i };
+	for (let e of Object.keys(i)) Object.hasOwn(r, e) && (a[e] = r[e]);
+	for (let t of Object.keys(a)) if (!Number.isSafeInteger(a[t]) || a[t] < (t === "initialTick" ? 0 : 1) || a[t] > 4294967295) throw new e({
+		room: "lockstep",
+		detail: "Invalid lockstep input work limit"
+	});
+	if (a.maxPlayers > 64 || a.maxFutureTicks > 4096 || a.maxBatchInputs > 64 || a.maxPendingInputs > 262144 || a.maxPendingBytes > 16777216) throw new e({
+		room: "lockstep",
+		detail: "Lockstep input work limit exceeds its bounded domain"
+	});
+	return Object.freeze(a);
+};
+export { n as captureLockstepRosterOptions };

package/dist/lockstepSeed.js

@@ -0,0 +1,11 @@
+import { ProtocolError as e } from "./errors.js";
+import { unsignedWord as t } from "./fixedWords.js";
+import { randomBytes as n } from "node:crypto";
+// src/lockstepSeed.ts
+var r = () => n(4).readUInt32LE(), i = (n = r) => {
+	if (typeof n != "function") throw new e({ detail: "Lockstep seed slot requires its actual synchronous source" });
+	let i = n();
+	if (i instanceof Promise) throw i.catch(() => void 0), new e({ detail: "Lockstep seed slot cannot return asynchronous work" });
+	return t(i);
+};
+export { r as randomRoomLockstepSeed, i as resolveRoomLockstepSeed };

package/dist/lockstepSeedFixture.js

@@ -0,0 +1,19 @@
+import { randomRoomLockstepSeed as e, resolveRoomLockstepSeed as t } from "./lockstepSeed.js";
+import { Effect as n } from "effect";
+// src/lockstepSeedFixture.ts
+var r = {
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => n.sync(() => {
+			let e = t();
+			return Number.isInteger(e) && e >= 0 && e <= 4294967295;
+		}),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => n.sync(() => t(() => 42)),
+		expected: 42
+	}
+};
+export { r as lockstepSeedSlotFixture };