@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/hostDeployment.js

@@ -0,0 +1,65 @@
+import { ProtocolError as e } from "./errors.js";
+import { roomHostTransportEndpoints as t } from "./transportEndpoints.js";
+import { roomHostMetricsRoute as n } from "./hostMetrics.js";
+//#region src/hostDeployment.ts
+var r = (r, i, a) => {
+	let o = r.VOLTRO_ROOMS_HOST_DEPLOYMENT;
+	if (o === void 0) return;
+	let s = () => {
+		throw new e({ detail: "Room host deployment binding is incomplete or differs from its process selection" });
+	};
+	if (o.length > 4096) return s();
+	let c;
+	try {
+		c = JSON.parse(o);
+	} catch {
+		return s();
+	}
+	if (!c || typeof c != "object" || Array.isArray(c)) return s();
+	let l = c;
+	if (Object.keys(l).some((e) => ![
+		"version",
+		"pool",
+		"region",
+		"port",
+		"metrics",
+		"publicRouting",
+		"shutdown"
+	].includes(e)) || l.version !== 1 || typeof l.pool != "string" || l.pool !== i || typeof l.region != "string" || l.region !== a || typeof l.port != "number" || !Number.isSafeInteger(l.port) || l.port < 1 || l.port > 65535 || typeof l.metrics != "boolean") return s();
+	let u;
+	if (l.shutdown !== void 0) {
+		let e = l.shutdown;
+		if (!e || typeof e != "object" || Array.isArray(e)) return s();
+		let t = e, n = t.drainMs, r = t.terminationGraceMs;
+		if (Object.keys(t).some((e) => !["drainMs", "terminationGraceMs"].includes(e)) || typeof n != "number" || !Number.isSafeInteger(n) || n < 1 || typeof r != "number" || !Number.isSafeInteger(r) || r < n + 5e3 || r > 36e5) return s();
+		u = Object.freeze({
+			drainMs: n,
+			terminationGraceMs: r
+		});
+	}
+	let d;
+	if (l.publicRouting !== void 0) {
+		let e = l.publicRouting;
+		if (!e || typeof e != "object" || Array.isArray(e)) return s();
+		let n = e, i = r.VOLTRO_ROOMS_HOST_POD_NAME;
+		if (Object.keys(n).some((e) => !["statefulSet", "template"].includes(e)) || typeof n.statefulSet != "string" || n.statefulSet.length > 52 || !/^[a-z][a-z0-9-]*[a-z0-9]$/.test(n.statefulSet) || n.statefulSet.includes("\n") || typeof n.template != "string" || n.template.length > 2048 || /[\r\n$]/.test(n.template) || !n.template.includes("{pod}") || /[{}]/.test(n.template.replaceAll("{pod}", "")) || typeof i != "string" || !i.startsWith(`${n.statefulSet}-`) || !/^(0|[1-9][0-9]*)$/.test(i.slice(n.statefulSet.length + 1)) || i.includes("\n") || i.length > 63) return s();
+		d = t(n.template.replaceAll("{pod}", i), void 0).ws;
+	}
+	let f = l.metrics ? r.VOLTRO_ROOMS_HOST_METRICS_TOKEN : void 0, p = l.metrics ? r.VOLTRO_ROOMS_HOST_METRICS_TOKEN_PREVIOUS : void 0, m = p === void 0 || p === "" || p === f ? void 0 : p;
+	if (l.metrics) {
+		if (f === void 0) return s();
+		n(f, () => {
+			throw Error("Credential preflight does not observe hosts");
+		}, m);
+	}
+	return Object.freeze({
+		port: l.port,
+		host: "0.0.0.0",
+		...u === void 0 ? {} : { shutdown: u },
+		...f === void 0 ? {} : { metricsToken: f },
+		...m === void 0 ? {} : { metricsPreviousToken: m },
+		...d === void 0 ? {} : { publicAddress: d }
+	});
+};
+//#endregion
+export { r as captureRoomHostDeployment };

package/dist/hostDrain.js

@@ -0,0 +1,152 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomForbidden as n, RoomGone as r } from "./errors.js";
+import { simulationOwnData as i } from "./simulationAuthoring.js";
+import { ROOMS_TABLE as a, ROOM_CHECKPOINTS_TABLE as o, ROOM_HOSTS_TABLE as s, ROOM_SEATS_TABLE as c } from "./identities.js";
+import { RoomHostDrainPort as l } from "./hostDrainPorts.js";
+import { captureRoomSnapshotBlobs as u, captureRoomSnapshotEffectRunner as d } from "./snapshotBlobIndex.js";
+import { loadDurableRoomCheckpoint as f, prefetchRoomCheckpointBlobs as p } from "./checkpointStore.js";
+import { captureRoomLockstepRecoveryOptions as m, readRoomLockstepRecoveryTruth as h } from "./lockstepRecoveryTruth.js";
+import { fenceRoomRecoverySeats as g } from "./recoverySeats.js";
+import { and as _, eq as v, or as y } from "@voltro/database";
+import { Effect as b } from "effect";
+//#region src/hostDrain.ts
+function x() {
+	throw new t({ detail: "Planned Host drain lacks matching process, fenced ownership or durable progress" });
+}
+var S = (e) => typeof e == "string" && e.length > 0 && e.length <= 191 && e.trim() === e ? e : x(), C = (e, t = 0) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e < 2 ** 53 - 1 ? e : x(), w = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e) ? e : x(), T = (e) => {
+	let t = i(e, ["graceMs", "maxCheckpointBytes"], ["graceMs"]), n = C(t.graceMs, 1), r = C(t.maxCheckpointBytes ?? 1048576, 1);
+	return n > 4294967295 ? x() : Object.freeze({
+		graceMs: n,
+		maxCheckpointBytes: r
+	});
+}, E = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return Number.isSafeInteger(t) && t >= 0 ? t : x();
+}, D = (e, t, n, r) => e.query({
+	table: t,
+	predicate: n,
+	order: [{
+		column: "id",
+		direction: "asc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0,
+	lock: "update"
+}), O = (i) => b.flatMap(b.context(), (a) => b.uninterruptible(b.tryPromise({
+	try: () => i(d(a)),
+	catch: (i) => i instanceof t || i instanceof e || i instanceof n || i instanceof r ? i : new t({ detail: "Planned Host drain SQL operation remains incomplete" })
+}))), k = (e) => {
+	let t = i(e, [
+		"roomId",
+		"tenantId",
+		"epoch",
+		"tick",
+		"mode",
+		"revision",
+		"admissionDigest",
+		"journalDigest"
+	], [
+		"roomId",
+		"tenantId",
+		"epoch",
+		"tick",
+		"mode"
+	]), n = {
+		roomId: S(t.roomId),
+		tenantId: S(t.tenantId),
+		epoch: C(t.epoch, 1),
+		tick: C(t.tick)
+	};
+	return t.mode === "state-sync" && !Object.hasOwn(t, "admissionDigest") && !Object.hasOwn(t, "journalDigest") ? Object.freeze({
+		...n,
+		mode: "state-sync",
+		revision: C(t.revision, 1)
+	}) : t.mode === "lockstep" && !Object.hasOwn(t, "revision") ? Object.freeze({
+		...n,
+		mode: "lockstep",
+		admissionDigest: w(t.admissionDigest),
+		journalDigest: t.journalDigest === null ? null : w(t.journalDigest)
+	}) : x();
+}, A = (l, d, w) => {
+	let T = i(d, [
+		"hostId",
+		"instanceId",
+		"startedAt"
+	], [
+		"hostId",
+		"instanceId",
+		"startedAt"
+	]), A = Object.freeze({
+		hostId: S(T.hostId),
+		instanceId: S(T.instanceId),
+		startedAt: C(T.startedAt)
+	}), j = C(w.graceMs, 1), M = C(w.maxSeatRows ?? 4096, 1), N = C(w.maxCheckpointBytes ?? 1048576, 1);
+	if (A.startedAt > 864e13 || j > 864e13 || M > 65536 || typeof w.epochNow != "function") return x();
+	let P = w.epochNow.bind(w), F = w.snapshotCodec, I = u(w.snapshotBlobs), L = m(w.lockstep), R = async (e) => {
+		let t = await D(e, s, v("id", A.hostId), 2), n = t[0];
+		if (t.length !== 1 || !n) throw new r({ roomId: "host" });
+		return n.instanceId !== A.instanceId || E(n.membershipStartedAt) !== A.startedAt || typeof n.ready != "boolean" || typeof n.draining != "boolean" ? x() : n;
+	};
+	return Object.freeze({
+		begin: () => O(() => l.transactional(async (e) => {
+			let t = await R(e);
+			t.draining === !0 ? t.ready !== !1 && x() : await e.updateMany("_voltro_room_hosts", {
+				draining: !0,
+				ready: !1
+			}, { where: _(v("id", A.hostId), v("draining", !1)) }) !== 1 && x();
+		})),
+		handoff: (i) => {
+			let s;
+			try {
+				s = k(i);
+			} catch {
+				return b.fail(new t({ detail: "Invalid planned Room handoff boundary" }));
+			}
+			return O(async (t) => {
+				let i = s.mode === "lockstep" ? void 0 : await p(l, s.roomId, s.tenantId, N, F, I, t);
+				return l.transactional(async (l) => {
+					let u = await R(l);
+					if (u.draining !== !0 || u.ready !== !1) return x();
+					let d = _(v("id", s.roomId), v("tenantId", s.tenantId)), p = await D(l, a, d, 2), m = p[0];
+					if (p.length !== 1 || !m) throw new r({ roomId: s.roomId });
+					if (m.hostId !== A.hostId || m.epoch !== s.epoch) throw new n({ roomId: s.roomId });
+					if (!["live", "orphaned"].includes(String(m.state)) || m.erasure != null || m.snapshotErasure != null) return x();
+					let b = await h(l, m, L);
+					if (s.mode === "lockstep") {
+						if (!b || b.admission.digest !== s.admissionDigest || (b.journal?.digest ?? null) !== s.journalDigest || (b.journal?.ticks.length ?? 0) !== s.tick) return x();
+					} else {
+						if (b) return x();
+						let e = await D(l, o, _(v("roomId", s.roomId), v("tenantId", s.tenantId)), 2);
+						if (e.length !== 1) return x();
+						let n = await f(l, e[0], s.roomId, s.tenantId, N, F, i, t);
+						if (n.epoch !== s.epoch || n.revision !== s.revision || n.tick !== s.tick || n.disposition !== "live") return x();
+					}
+					let S = Object.freeze({
+						hostId: A.hostId,
+						roomId: s.roomId,
+						tenantId: s.tenantId,
+						epoch: s.epoch,
+						state: "orphaned",
+						tick: s.tick
+					});
+					if (m.state === "orphaned") return S;
+					let w = C(P());
+					if (w > 864e13 - j) return x();
+					let T = await D(l, c, _(v("roomId", s.roomId), v("tenantId", s.tenantId), y(v("state", "reserved"), v("state", "connected"), v("state", "grace"))), M + 1);
+					if (T.length > M) throw new e({
+						budget: "hostDrainSeats",
+						limit: M
+					});
+					let E = await g(l, s.roomId, s.tenantId, s.epoch, T, w, j, !0, C(m.maxClients, 1));
+					return await l.updateMany("_voltro_rooms", {
+						state: "orphaned",
+						clients: E,
+						updatedAt: new Date(w)
+					}, { where: _(d, v("hostId", A.hostId), v("epoch", s.epoch), v("state", "live")) }) === 1 ? S : x();
+				});
+			});
+		}
+	});
+};
+//#endregion
+export { l as RoomHostDrainPort, T as captureRoomHostDrainPolicy, A as dataStoreRoomHostDrain };

package/dist/hostDrainPorts.js

@@ -0,0 +1,5 @@
+import { Context as e } from "effect";
+//#region src/hostDrainPorts.ts
+var t = class extends e.Service()("@voltro/RoomHostDrainPort") {};
+//#endregion
+export { t as RoomHostDrainPort };

package/dist/hostDriver.js

@@ -0,0 +1,179 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomHostTurnObservation as t } from "./hostTurnObservation.js";
+import { performance as n } from "node:perf_hooks";
+import { availableParallelism as r } from "node:os";
+//#region src/hostDriver.ts
+var i = Object.freeze({ schedule: (e, t) => {
+	let n = setTimeout(t, e);
+	return () => clearTimeout(n);
+} }), a = (t) => {
+	let n = t && Object.getOwnPropertyDescriptor(t, "continueWorldGroups"), r = t && Object.getOwnPropertyDescriptor(t, "maintainWorldGhosts");
+	if (r && (!("value" in r) || typeof r.value != "function") || t && !r && "maintainWorldGhosts" in t) throw new e({ detail: "Ghost maintenance requires an own acquired callback" });
+	if (n && (!("value" in n) || typeof n.value != "function") || t && !n && "continueWorldGroups" in t) throw new e({ detail: "World continuation requires an own acquired callback" });
+	if (!t || typeof t != "object" || Array.isArray(t) || Object.keys(t).some((e) => ![
+		"cadenceMs",
+		"timer",
+		"onFailure",
+		"continueWorldGroups",
+		"maintainWorldGhosts"
+	].includes(e)) || !Number.isSafeInteger(t.cadenceMs) || t.cadenceMs < 1 || t.cadenceMs > 2147483647 || typeof t.onFailure != "function" || t.timer !== void 0 && typeof t.timer?.schedule != "function") throw new e({ detail: "Invalid host driver configuration" });
+	let a = t.timer ?? i;
+	return Object.freeze({
+		cadenceMs: t.cadenceMs,
+		onFailure: t.onFailure.bind(t),
+		timer: Object.freeze({ schedule: a.schedule.bind(a) }),
+		...r ? { maintainWorldGhosts: r.value.bind(t) } : {},
+		...n ? { continueWorldGroups: n.value.bind(t) } : {}
+	});
+}, o = class {
+	controller;
+	canTurn;
+	cancelTimer = null;
+	active = null;
+	stopTask = null;
+	quiesceTask = null;
+	running = !1;
+	stopping = !1;
+	failure = null;
+	timer;
+	scheduled = null;
+	turnController;
+	closeController;
+	observation;
+	options;
+	constructor(n, r, i = () => !0) {
+		if (this.controller = n, this.canTurn = i, this.options = a(r), typeof n?.turn != "function" || typeof n.close != "function" || typeof i != "function") throw new e({ detail: "Host driver requires complete controller and admission callbacks" });
+		this.observation = new t(this.options.cadenceMs), this.timer = this.options.timer, this.turnController = n.turn.bind(n), this.closeController = n.close.bind(n);
+	}
+	start() {
+		if (this.running || this.stopping) throw new e({ detail: "Room host driver already started or stopping" });
+		if (this.running = !0, this.observation.arm(), this.schedule(), !this.running) throw new e({ detail: "Room host driver could not acquire its control timer" });
+	}
+	report(t) {
+		this.failure = t;
+		try {
+			let n = this.options.onFailure(t);
+			if (n !== void 0) throw n instanceof Promise && n.catch(() => void 0), new e({ detail: "Host failure observer must return synchronous void" });
+		} catch (e) {
+			this.failure = AggregateError([t, e], "Room host turn and failure observer failed");
+		}
+	}
+	schedule() {
+		if (!this.running || this.stopping || this.active || this.scheduled) return;
+		let t = Object.freeze({});
+		this.scheduled = t;
+		let n = !0;
+		try {
+			let r = this.timer.schedule(this.options.cadenceMs, () => {
+				if (this.scheduled !== t || !this.running || this.stopping) return;
+				this.scheduled = null;
+				let r = Promise.withResolvers();
+				this.active = r.promise;
+				let i = async () => {
+					try {
+						if (this.cancelTimer) {
+							let e = this.cancelTimer;
+							try {
+								e(), this.cancelTimer = null;
+							} catch (e) {
+								throw this.running = !1, e;
+							}
+						}
+						if (!this.running || this.stopping) return;
+						let t = this.canTurn();
+						if (typeof t != "boolean") throw new e({ detail: "Host driver admission must be synchronous boolean data" });
+						if (!t) return;
+						this.observation.begin();
+						let n = !1;
+						try {
+							let t = [];
+							try {
+								await this.turnController();
+							} catch (e) {
+								t.push(e);
+							}
+							if (this.options.continueWorldGroups) try {
+								let t = this.options.continueWorldGroups();
+								if (!(t instanceof Promise)) throw new e({ detail: "World continuation must return its actual completion Promise" });
+								await t;
+							} catch (e) {
+								t.push(e);
+							}
+							if (this.options.maintainWorldGhosts) try {
+								let t = this.options.maintainWorldGhosts();
+								if (!(t instanceof Promise)) throw new e({ detail: "Ghost maintenance requires its actual completion Promise" });
+								await t;
+							} catch (e) {
+								t.push(e);
+							}
+							if (t.length === 1) throw t[0];
+							if (t.length > 1) throw AggregateError(t, "Room turn and World continuation failed");
+							n = !0;
+						} finally {
+							this.observation.finish(n);
+						}
+					} catch (e) {
+						this.report(e);
+					} finally {
+						this.active = null, r.resolve(), this.schedule();
+					}
+				};
+				n ? queueMicrotask(() => {
+					i();
+				}) : i();
+			});
+			if (typeof r != "function") throw new e({ detail: "Host timer must return its actual cancellation operation" });
+			this.cancelTimer = r, n = !1;
+		} catch (e) {
+			n = !1, this.scheduled = null, this.running = !1, this.report(e);
+		}
+	}
+	metrics() {
+		return this.observation.snapshot();
+	}
+	live() {
+		return this.running && !this.stopping && this.observation.live();
+	}
+	get lastFailure() {
+		return this.failure;
+	}
+	get turning() {
+		return this.active !== null;
+	}
+	quiesce() {
+		if (this.quiesceTask) return this.quiesceTask;
+		this.stopping = !0, this.running = !1, this.scheduled = null;
+		let e = (async () => {
+			if (this.cancelTimer) {
+				let e = this.cancelTimer;
+				e(), this.cancelTimer = null;
+			}
+			this.active && await this.active;
+		})();
+		return this.quiesceTask = e, e.catch(() => {
+			this.quiesceTask = null;
+		}), e;
+	}
+	stop() {
+		return this.stopTask || (this.stopTask = (async () => {
+			await this.quiesce(), await this.closeController();
+		})(), this.stopTask.then(() => void 0, (e) => {
+			this.report(e), this.stopTask = null;
+		})), this.stopTask;
+	}
+}, s = (t = {}) => {
+	let i = t.now ?? (() => n.now()), a = t.cpuUsage ?? process.cpuUsage, o = t.parallelism ?? r();
+	if (!Number.isSafeInteger(o) || o < 1) throw new e({ detail: "CPU parallelism must be positive" });
+	let s = i(), c = a(), l = 0;
+	if (!Number.isFinite(s) || s < 0) throw new e({ detail: "Invalid process measurement clock" });
+	return () => {
+		let t = i(), n = a(), r = t - s;
+		if (!Number.isFinite(t) || r < 0) throw new e({ detail: "Process measurement clock moved backwards" });
+		if (r === 0) throw new e({ detail: "Process CPU measurement requires an elapsed interval" });
+		let u = n.user + n.system - c.user - c.system;
+		if (!Number.isSafeInteger(u) || u < 0) throw new e({ detail: "Process CPU counters are invalid" });
+		return l = Math.min(1, u / (r * 1e3 * o)), s = t, c = n, l;
+	};
+};
+//#endregion
+export { o as RoomHostDriver, a as captureRoomHostDriverOptions, i as platformRoomHostTimer, s as roomProcessCpuSampler };