@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/hostRegistryBinding.js

@@ -0,0 +1,418 @@
+import { ProtocolError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { RoomStateCodec as n } from "./stateCodec.js";
+import { roomHostTransportEndpoints as r } from "./transportEndpoints.js";
+import { captureRoomSnapshotBlobs as i } from "./snapshotBlobIndex.js";
+import { dataStoreRoomErasure as a } from "./roomErasure.js";
+import { assertRoomSeatSecrets as o, resolveRoomSeatTokenStrategies as s } from "./seats.js";
+import { captureAdmittedRoomPoolTopology as c, captureRoomPoolCatalog as l, roomPoolHostedNames as u, roomPoolPublicAddress as ee } from "./roomPoolTopology.js";
+import { roomCheckpointsTable as te, roomCommandsTable as ne, roomHostsTable as re, roomLockstepTicksTable as ie, roomSeatsTable as ae, roomSnapshotSegmentsTable as oe, roomSubjectPrivacyTable as se, roomsTable as ce } from "./tables.js";
+import { captureRoomWorldEntitySource as le } from "./worldHostSource.js";
+import { captureRoomHostGeometryBinding as ue } from "./geometryHost.js";
+import { dataStoreRoomDirectory as de } from "./directory.js";
+import { captureRoomHostDriverOptions as fe } from "./hostDriver.js";
+import { runtimeRoomHostListener as d } from "./hostListener.js";
+import { makeRoomControlCarrier as f } from "./controlCarrier.js";
+import { captureRoomHostShutdownPolicy as p } from "./hostShutdown.js";
+import { captureRoomHostDeployment as m } from "./hostDeployment.js";
+import { RoomsHostBindFailure as h } from "./hostBinding.js";
+import { routedRoomHostWithdrawalService as pe } from "./withdrawalPort.js";
+import { forwardedRoomAppCommands as me, roomAppCommandTarget as he } from "./roomAppCommandControl.js";
+import { openRegistryRoomControlClient as ge, openRegistryRoomControlServer as _e } from "./controlRegistry.js";
+import { directoryRoomControlTargetResolver as ve } from "./controlTarget.js";
+import { dataStoreRoomRecovery as ye } from "./recovery.js";
+import { WORLD_DEFAULT_MAX_BYTES as be, defaultHostWorld as xe } from "./worldDefaultBinding.js";
+import { applicationRoomExternalWorkWithdrawal as Se } from "./commandWithdrawal.js";
+import { Effect as g, Option as Ce } from "effect";
+import { ConnectionRegistry as we } from "@voltro/kv/connection";
+import { HotStore as Te, layerRoutedHotRedis as Ee } from "@voltro/kv/hot";
+//#region src/hostRegistryBinding.ts
+function _(t) {
+	throw new e({ detail: t });
+}
+var v = (e, t) => Number.isSafeInteger(e) && e > 0 && e <= t ? e : _("Invalid registry Rooms host budget"), y = (t) => typeof t.appDependencies == "function" ? t.appDependencies() : Promise.reject(new e({ detail: "Default Rooms host dependencies need the voltro rooms host runner; pass acquire for a custom process" })), b = (b) => {
+	if (!b || b.acquire !== void 0 && typeof b.acquire != "function" || !["single-node", "multi-node"].includes(b.topology) || !/^(redis|nats):[A-Za-z][A-Za-z0-9_-]*$/.test(b.controlConnection) || !/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(b.hotConnection) || !b.host || typeof b.host.clock?.now != "function" || typeof b.host.epochNow != "function" || typeof b.host.measuredCpu != "function" || typeof b.host.address != "string" || !b.host.address.trim() || typeof b.host.region != "string" || !b.host.region.trim() || !b.listener || typeof b.listener != "object" || Array.isArray(b.listener)) return _("Registry Rooms host requires explicit topology, app acquisition, routing and clocks");
+	if (Object.keys(b.host).some((e) => ![
+		"pools",
+		"pool",
+		"clientCapacity",
+		"address",
+		"webTransportAddress",
+		"webTransportCertificateHash",
+		"region",
+		"capacity",
+		"clock",
+		"epochNow",
+		"secrets",
+		"heartbeatTtlMs",
+		"heartbeatEveryMs",
+		"seatTtlMs",
+		"maxQueuedOperations",
+		"lockstepTransport",
+		"snapshotBudget",
+		"snapshotBlobs",
+		"maxInlineBytes",
+		"spectatorGroups",
+		"replayRecordings",
+		"measuredCpu",
+		"strategies"
+	].includes(e)) || Object.keys(b.listener).some((e) => ![
+		"port",
+		"host",
+		"health",
+		"security",
+		"startupTimeoutMs",
+		"onBound",
+		"metricsToken",
+		"metricsPreviousToken"
+	].includes(e))) return _("Registry Rooms host dependencies and listener admission belong to the acquired owner");
+	o(b.host.secrets), o(b.projectControlSecrets);
+	let x = Object.getOwnPropertyDescriptor(b.host, "webTransportAddress"), S = Object.getOwnPropertyDescriptor(b.host, "webTransportCertificateHash");
+	if (x && (!("value" in x) || !x.enumerable) || !x && "webTransportAddress" in b.host || S && (!("value" in S) || !S.enumerable) || !S && "webTransportCertificateHash" in b.host) return _("Registry Rooms host native endpoint requires own routing data");
+	let C = r(b.host.address, x?.value, S?.value);
+	if (b.host.spectatorGroups !== void 0 && typeof b.host.spectatorGroups != "function") return _("Invalid spectator view-group resolver");
+	if (b.host.replayRecordings !== void 0 && typeof b.host.replayRecordings != "function") return _("Invalid replay recording resolver");
+	for (let e of [
+		"pools",
+		"pool",
+		"clientCapacity"
+	]) {
+		let t = Object.getOwnPropertyDescriptor(b.host, e);
+		if (t && (!t.enumerable || !("value" in t)) || !t && e in b.host) return _("Registry host pool selection requires own data");
+	}
+	let w = b.host.pools === void 0 ? void 0 : c(b.host.pools), T = w === void 0 ? void 0 : b.host.pool ?? w.default, E = T === void 0 ? void 0 : w.pools[T];
+	if (w ? !E || !E.regions.includes(b.host.region) : b.host.pool !== void 0 || b.host.clientCapacity !== void 0) return _("Registry host pool or region is not admitted");
+	let D = E?.hot ?? b.hotConnection;
+	if (!/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(D)) return _("Registry host pools require a named Redis Hot Store connection");
+	if ("continueWorldGroups" in b.driver) return _("Registry World continuation must come from the acquired owner");
+	let De = b.acquire ?? y, O = b.topology, k = b.controlConnection, A = b.hotConnection, j = structuredClone(b.projectControlSecrets), M = structuredClone(b.host.secrets), N = b.host.epochNow, Oe = Object.freeze({ now: b.host.clock.now.bind(b.host.clock) }), ke = fe(b.driver), Ae = v(b.maxCheckpointBytes ?? 1048576, 67108864), P = v(b.maxRequestMs ?? 5e3, 6e4), je = v(b.maxReceipts ?? 4096, 65536), Me = v(b.maxInFlight ?? 128, je), Ne = v(b.graceMs, 2 ** 53 - 1), Pe = p({
+		graceMs: Ne,
+		maxCheckpointBytes: Ae,
+		...b.drainMs === void 0 ? {} : { drainMs: b.drainMs }
+	}), F = s(b.host.strategies?.seatToken), I = i(b.host.snapshotBlobs), L = Object.freeze({
+		...b.host,
+		pools: w,
+		pool: T,
+		address: C.ws,
+		webTransportAddress: C.wt,
+		webTransportCertificateHash: C.wtCertificateHash,
+		secrets: M,
+		epochNow: N,
+		clock: Oe,
+		measuredCpu: b.host.measuredCpu,
+		snapshotBudget: b.host.snapshotBudget === void 0 ? void 0 : Object.freeze({ ...b.host.snapshotBudget }),
+		snapshotBlobs: I,
+		strategies: Object.freeze({
+			...b.host.strategies,
+			seatToken: F
+		})
+	}), R = Object.freeze({
+		...b.listener,
+		security: b.listener.security === void 0 ? void 0 : structuredClone(b.listener.security)
+	}), Fe = b.gateway === void 0 ? void 0 : Object.freeze({
+		...b.gateway,
+		limits: b.gateway.limits === void 0 ? void 0 : Object.freeze({ ...b.gateway.limits })
+	});
+	for (let e of [
+		L.capacity,
+		L.heartbeatEveryMs,
+		L.heartbeatTtlMs,
+		L.seatTtlMs,
+		L.maxQueuedOperations ?? 128
+	]) v(e, 2 ** 53 - 1);
+	if (L.heartbeatEveryMs >= L.heartbeatTtlMs) return _("Room host heartbeat cadence must precede its routing TTL");
+	d({
+		...R,
+		readiness: async () => !1
+	});
+	let z = [j.current, ...j.previous ? [j.previous] : []], B = [M.current, ...M.previous ? [M.previous] : []];
+	return z.some((e) => B.some((t) => e.secret === t.secret)) ? _("Room control and seat signing keys must be independent") : async (r) => {
+		if (r.signal.aborted) return _("Registry Rooms host acquisition was cancelled");
+		if (r.pools !== void 0 && w !== void 0 && r.pools !== w) return _("Room pools must have one app-owned declaration");
+		let i = r.pools === void 0 ? w : l(r.pools, r.catalog.inventory().map((e) => e.descriptor.name)), o = r.selection?.pool ?? L.pool ?? i?.default, s = r.selection?.region ?? L.region, c = o === void 0 ? void 0 : i?.pools[o];
+		if (i ? !c || !c.regions.includes(s) : o !== void 0) return _("Registry host process pool or region is not admitted");
+		let p = m(process.env, o, s), v = p === void 0 ? R : Object.freeze({
+			...R,
+			port: p.port,
+			host: p.host,
+			...p.metricsToken === void 0 ? {} : { metricsToken: p.metricsToken },
+			...p.metricsPreviousToken === void 0 ? {} : { metricsPreviousToken: p.metricsPreviousToken }
+		});
+		d({
+			...v,
+			readiness: async () => !1
+		});
+		let y = c?.hot ?? A;
+		if (!/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(y)) return _("Registry host pools require a named Redis Hot Store connection");
+		let b = y, x = Object.freeze({
+			...L,
+			pools: i,
+			pool: o,
+			region: s,
+			capacity: c?.capacity?.rooms ?? L.capacity,
+			clientCapacity: c?.capacity?.clients ?? L.clientCapacity
+		});
+		i && l(i, r.catalog.inventory().map((e) => e.descriptor.name));
+		let S = new Set(u(i, o, r.catalog.inventory().map((e) => e.descriptor.name))), C = Object.freeze(r.worlds.filter((e) => [...e.zones, ...e.instances].some((e) => S.has(e.room)))), T = Object.freeze({
+			...r,
+			hostedRooms: Object.freeze(r.catalog.inventory().filter((e) => S.has(e.descriptor.name))),
+			hostedWorlds: C
+		});
+		f({
+			mount: r.pluginName,
+			projectControlSecrets: j,
+			epochNow: N,
+			maxRequestMs: P
+		});
+		let E;
+		try {
+			E = await De(T);
+		} catch (e) {
+			if (e instanceof h) throw e;
+			return _("Registry Rooms host app acquisition did not complete");
+		}
+		if (typeof E?.release != "function") return _("Registry Rooms host app acquisition must retain cleanup");
+		let D = E.release.bind(E), F = !1, z = null, B = () => {
+			if (F) return Promise.resolve();
+			if (z) return z;
+			let e = Promise.resolve().then(D).then(() => {
+				F = !0;
+			});
+			return z = e, e.then(() => {
+				z = null;
+			}, () => {
+				z = null;
+			}), e;
+		};
+		try {
+			let l = E.store, u = E.registry, f = Object.freeze({ ...E.instance }), m = E.runEffect;
+			if (!l || typeof l.query != "function" || typeof l.transactional != "function" || !u || typeof u.validate != "function" || typeof u.config != "function" || typeof u.probe != "function" || typeof u.pubsub != "function" || typeof m != "function" || typeof E.membership?.list != "function" || typeof E.resolveSeatSubject != "function" || typeof E.resolveControlSubject != "function" || E.application !== void 0 && typeof E.application.deliver != "function" || typeof E.readiness != "function" || typeof f.instanceId != "string" || !f.instanceId.trim() || f.instanceId.length > 191 || !Number.isSafeInteger(f.startedAt) || f.startedAt < 0) return _("Registry Rooms host app dependencies are incomplete");
+			let h = ee(i, o, s, f.instanceId, x.address);
+			if (p?.publicAddress !== void 0 && c?.publicAddress !== void 0 && p.publicAddress !== h) return _("Deployment public routing conflicts with the app pool address");
+			let y = p?.publicAddress ?? h, S = Object.freeze({ list: E.membership.list.bind(E.membership) }), w = E.resolveSeatSubject, D = E.resolveControlSubject, De = E.readiness, A, F = E.application, L = Object.freeze(F ? { deliver: F.deliver.bind(F) } : me({ deliver: (t) => A ? A.commands.deliver(t) : g.fail(new e({ detail: "Room app commands wait for the control client" })) })), R = Object.getOwnPropertyDescriptor(E, "erasure");
+			if (R && !("value" in R) || !R && "erasure" in E) return _("Registry Rooms erasure requires an own actual capability");
+			let z = R?.value === void 0 ? void 0 : t(R.value, ["erase"], ["erase"]);
+			if (z && typeof z.erase != "function") return _("Registry Rooms erasure capability is incomplete");
+			let Ie = z ? Object.freeze({ erase: z.erase.bind(R?.value) }) : void 0, V = Object.getOwnPropertyDescriptor(E, "lockstepPorts");
+			if (V && !("value" in V) || !V && "lockstepPorts" in E) return _("Registry Lockstep factories require own configuration");
+			let Le = V?.value === void 0 ? {} : t(V.value, [
+				"lockstepAdmission",
+				"lockstepJournal",
+				"lockstepTerminal"
+			], []);
+			if (Object.values(Le).some((e) => typeof e != "function")) return _("Registry Lockstep replacement factory is incomplete");
+			let H = Object.getOwnPropertyDescriptor(E, "worldEntities");
+			if (H && !("value" in H) || !H && "worldEntities" in E) return _("Registry World recovery requires an own capability");
+			let Re = H?.value, U = Re === void 0 ? void 0 : le(Re), W = Object.getOwnPropertyDescriptor(E, "resolveWorldPlayer");
+			if (W && (!("value" in W) || typeof W.value != "function") || !W && "resolveWorldPlayer" in E) return _("Registry World player selection requires an own acquired callback");
+			let ze = W === void 0 ? void 0 : W.value.bind(E);
+			if (ze && !U?.admitActorPlayer) return _("Registry World player selection requires actual entity admission");
+			let G = Object.getOwnPropertyDescriptor(E, "worldGroups");
+			if (G && !("value" in G) || !G && "worldGroups" in E) return _("Registry World supervision requires an own acquired capability");
+			let K = G === void 0 ? void 0 : t(G.value, ["runDue"], ["runDue"]);
+			if (K && typeof K.runDue != "function") return _("Registry World supervision requires actual bounded continuation");
+			let Be = K ? K.runDue.bind(G.value) : void 0, q = Object.getOwnPropertyDescriptor(E, "worldInstanceExpiry");
+			if (q && !("value" in q) || !q && "worldInstanceExpiry" in E) return _("Registry instance expiry requires an own acquired capability");
+			let J = q === void 0 ? void 0 : t(q.value, ["runDue"], ["runDue"]);
+			if (J && (typeof J.runDue != "function" || !U || !C.some((e) => e.instances.length))) return _("Registry instance expiry requires actual entity authority and instance declarations");
+			let Ve = J ? J.runDue.bind(q.value) : void 0, He = Be || Ve ? fe({
+				...ke,
+				continueWorldGroups: async () => {
+					let t = [];
+					if (Be) try {
+						let t = Be();
+						if (!g.isEffect(t)) throw new e({ detail: "World supervision requires an actual Effect" });
+						await m(t);
+					} catch (e) {
+						t.push(e);
+					}
+					if (Ve) try {
+						let t = Ve();
+						if (!g.isEffect(t)) throw new e({ detail: "Instance expiry supervision requires an actual Effect" });
+						let n = await m(t);
+						if (n.deferred.length || n.blocked) throw new e({ detail: "Instance expiry has deferred or explicitly blocked work" });
+					} catch (e) {
+						t.push(e);
+					}
+					if (t.length) throw AggregateError(t, "World group/instance continuations remain incomplete");
+				}
+			}) : ke, Y = Object.getOwnPropertyDescriptor(E, "geometry");
+			if (Y && !("value" in Y) || !Y && "geometry" in E) return _("Registry geometry requires an own actual Host capability");
+			let X = ue(Y?.value);
+			if (C.some((e) => e.geometry) && !X) return _("Configured World geometry requires actual complete Host preparation");
+			if (X && (X.worlds.length !== C.length || X.worlds.some((e, t) => e !== C[t]))) return _("Registry geometry must bind the exact admitted World catalogue");
+			let Z = () => {
+				if (r.signal.aborted) return _("Registry Rooms host acquisition was cancelled");
+			};
+			Z();
+			for (let e of [b, k]) {
+				let t = await m(u.validate(e));
+				if (Z(), t.reference !== e || t.tenantScoped) return _("Registry Rooms host needs shared declared connections");
+			}
+			let Ue = await m(u.config(b));
+			if (Z(), O === "multi-node" && Ue.driver === "memory") return _("Multi-node Rooms host requires Redis; memory hot data cannot boot");
+			let We = await m(Te.pipe(g.provide(Ee({
+				consumer: r.pluginName,
+				connection: b
+			})), g.provideService(we, u)));
+			if (Z(), We.capabilities.atomicMulti !== !0 || O === "multi-node" && We.capabilities.crossNode !== !0) return _("Room host HotStore capabilities do not satisfy its topology");
+			await m(u.probe(b)), Z(), k !== b && (await m(u.probe(k)), Z());
+			for (let e of [
+				re,
+				ce,
+				ae,
+				te,
+				ne,
+				oe,
+				se,
+				ie
+			]) await l.query({
+				table: e.tableName,
+				predicate: void 0,
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["id"]
+			}), Z();
+			let Ge = ye(l, {
+				pools: i,
+				membership: S,
+				observerNow: Oe.now,
+				epochNow: N,
+				heartbeatEveryMs: x.heartbeatEveryMs,
+				hostHeartbeatTtlMs: x.heartbeatTtlMs,
+				graceMs: Ne,
+				maxCheckpointBytes: Ae,
+				snapshotCodec: (e) => new n(r.catalog.get(e).state),
+				...I === void 0 ? {} : { snapshotBlobs: I }
+			}), Ke, Q, qe = T.hostedRooms.some((e) => e.descriptor.mode === "lockstep"), Je = pe({
+				local: () => Ke,
+				peers: () => Q?.withdrawal
+			}), Ye = Ie ?? (qe ? a(l, {
+				epochNow: N,
+				owner: Je,
+				external: Se(l, {
+					run: {},
+					publish: {}
+				}),
+				invalidateDirectory: () => g.void,
+				...I === void 0 ? {} : { snapshotBlobs: I }
+			}) : void 0), Xe = de(l, {
+				pools: i,
+				epochNow: N,
+				heartbeatTtlMs: x.heartbeatTtlMs
+			}), $ = C.length && Re === void 0 && r.worldState === "transitions" ? xe({
+				store: l,
+				worlds: C,
+				catalog: r.catalog,
+				controller: () => Ke,
+				peers: () => Q?.world,
+				ownership: Xe.observeOwnership.bind(Xe),
+				hot: We,
+				resolveSubject: D,
+				epochNow: N,
+				signing: {
+					secrets: M,
+					seatTtlMs: x.seatTtlMs,
+					graceMs: Ne,
+					hostHeartbeatTtlMs: x.heartbeatTtlMs
+				}
+			}) : void 0, Ze = $ === void 0 ? {} : {
+				worldEntities: le($.worldEntities),
+				resolveWorldPlayer: $.resolveWorldPlayer,
+				worldSnapshotMaxBytes: be,
+				worldGhostMaxConnections: 64
+			}, Qe = qe && Ie === void 0 && O === "multi-node" || $ !== void 0, $e = F === void 0, et = !1;
+			return Object.freeze({
+				store: l,
+				shutdown: Pe,
+				options: Object.freeze({
+					host: Object.freeze({
+						...x,
+						worlds: C,
+						address: y,
+						membership: f,
+						resolveSubject: w,
+						application: L,
+						...U ? { worldEntities: U } : {},
+						...ze ? { resolveWorldPlayer: ze } : {},
+						...Ze,
+						...X ? { geometry: X } : {},
+						ports: Object.freeze({
+							recovery: Ge,
+							...Le,
+							...Ye === void 0 ? {} : { erasure: Ye }
+						})
+					}),
+					driver: He,
+					listener: d({
+						...v,
+						readiness: De
+					}),
+					...Fe === void 0 ? {} : { gateway: Fe }
+				}),
+				openControl: async (t, n) => {
+					if (n !== r || et || t.status !== "binding" || t.controller.store !== l || t.controller.host.membership?.instanceId !== f.instanceId || t.controller.host.membership.startedAt !== f.startedAt) return _("Registry Rooms control requires its exact suspended owner");
+					Z(), et = !0, Ke = t.controller;
+					let a = await m(_e(u, t.controller, {
+						connection: k,
+						mount: r.pluginName,
+						projectControlSecrets: j,
+						epochNow: N,
+						maxRequestMs: P,
+						maxReceipts: je,
+						maxInFlight: Me,
+						resolveSubject: D,
+						onUnavailable: () => t.driver.options.onFailure(new e({ detail: "Room host control transport is unavailable" })),
+						...$ === void 0 ? {} : { worldSteps: $.worldSteps }
+					}));
+					if (!Qe && !$e) return a;
+					let o;
+					try {
+						let t = de(l, {
+							pools: i,
+							epochNow: N,
+							heartbeatTtlMs: x.heartbeatTtlMs
+						}), n = ve(t, S, s, i === void 0 ? void 0 : {
+							store: l,
+							pools: i
+						});
+						o = await m(ge(u, {
+							connection: k,
+							mount: r.pluginName,
+							projectControlSecrets: j,
+							epochNow: N,
+							maxRequestMs: P,
+							catalog: r.catalog,
+							resolveTarget: (t) => t === "app-commands" ? Ce.match(he(S.list()), {
+								onNone: () => g.fail(new e({ detail: "No API instance runs Room app commands" })),
+								onSome: g.succeed
+							}) : n(t)
+						}));
+					} catch (e) {
+						throw a.fence(), await a.close(), e;
+					}
+					return Qe && (Q = o), $e && (A = o), Object.freeze({
+						fence: () => {
+							o.fence(), a.fence();
+						},
+						close: async () => {
+							let e = (await Promise.allSettled([o.close(), a.close()])).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+							if (e.length) throw AggregateError(e, "Room host control did not close");
+						}
+					});
+				},
+				release: B
+			});
+		} catch {
+			try {
+				await B();
+			} catch {
+				throw new h(B);
+			}
+			throw new e({ detail: "Registry Rooms host preflight did not complete" });
+		}
+	};
+};
+//#endregion
+export { y as defaultRoomsHostAcquire, b as registryRoomsHostBinder };

package/dist/hostSelection.js

@@ -0,0 +1,16 @@
+import { ProtocolError as e } from "./errors.js";
+//#region src/hostSelection.ts
+var t = (e, t) => [...e].filter((e) => e.ready && e.region === t && e.rooms < e.capacity).sort((e, t) => e.rooms / e.capacity - t.rooms / t.capacity || e.cpu - t.cpu || (e.id < t.id ? -1 : +(e.id > t.id)))[0] ?? null, n = (n, r, i = t) => {
+	let a;
+	try {
+		a = i(structuredClone(n), r);
+	} catch {
+		throw new e({ detail: "Room host selection strategy failed" });
+	}
+	if (a === null) return null;
+	let o = n.find((e) => e.id === a?.id && e.ready && e.region === r && e.rooms < e.capacity);
+	if (!o) throw new e({ detail: "Room host strategy selected an ineligible host" });
+	return o;
+};
+//#endregion
+export { t as leastLoadedRoomHostInRegion, n as resolveRoomHostSelection };

package/dist/hostShutdown.js

@@ -0,0 +1,47 @@
+import { ProtocolError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { captureRoomHostDrainPolicy as n } from "./hostDrain.js";
+import { performance as r } from "node:perf_hooks";
+//#region src/hostShutdown.ts
+var i = (r) => {
+	let i = t(r, [
+		"graceMs",
+		"maxCheckpointBytes",
+		"drainMs"
+	], ["graceMs"]), a = i.drainMs ?? 15e3;
+	if (typeof a != "number" || !Number.isSafeInteger(a) || a < 1 || a > 2147483647) throw new e({ detail: "Room host drainMs must be a positive timer-sized integer" });
+	let o = n({
+		graceMs: i.graceMs,
+		...i.maxCheckpointBytes === void 0 ? {} : { maxCheckpointBytes: i.maxCheckpointBytes }
+	});
+	return Object.freeze({
+		...o,
+		drainMs: a
+	});
+}, a = class extends Error {
+	retryCleanup;
+	name = "RoomsHostDrainDeadline";
+	constructor(e) {
+		super("Room host drain deadline elapsed; accepted writes and resources remain owned until cleanup completes"), this.retryCleanup = e;
+	}
+}, o = async (e, t, n) => {
+	let i = () => new a(n);
+	for (;;) {
+		if (r.now() >= t) throw i();
+		let n;
+		try {
+			let a = new Promise((e, a) => {
+				n = setTimeout(() => a(i()), Math.max(1, t - r.now()));
+			});
+			await Promise.race([e(), a]);
+			return;
+		} catch (e) {
+			if (e instanceof a || r.now() >= t) throw i();
+		} finally {
+			n !== void 0 && clearTimeout(n);
+		}
+		await new Promise((e) => setTimeout(e, Math.min(100, Math.max(1, t - r.now()))));
+	}
+};
+//#endregion
+export { a as RoomsHostDrainDeadline, i as captureRoomHostShutdownPolicy, o as superviseRoomHostDrain };

package/dist/hostTurnObservation.js

@@ -0,0 +1,53 @@
+import { ProtocolError as e } from "./errors.js";
+import { performance as t } from "node:perf_hooks";
+//#region src/hostTurnObservation.ts
+var n = class {
+	budgetMs;
+	now;
+	lastClock = 0;
+	invalid = !1;
+	active = null;
+	completed = null;
+	duration = null;
+	progress = null;
+	saturatedUntil = 0;
+	constructor(n, r = () => t.now()) {
+		if (this.budgetMs = n, this.now = r, !Number.isFinite(n) || n <= 0) throw new e({ detail: "Host turn observation requires a positive budget" });
+	}
+	read() {
+		try {
+			let e = this.now();
+			return !Number.isFinite(e) || e < this.lastClock || e < 0 ? (this.invalid = !0, null) : (this.lastClock = e, e);
+		} catch {
+			return this.invalid = !0, null;
+		}
+	}
+	begin() {
+		this.active === null ? this.active = this.read() : this.invalid = !0;
+	}
+	arm() {
+		this.progress = this.read();
+	}
+	live() {
+		let e = this.read();
+		return e !== null && !this.invalid && this.progress !== null && e - this.progress <= 5e3;
+	}
+	finish(e = !0) {
+		let t = this.read(), n = this.active;
+		this.active = null, t !== null && n !== null && (this.duration = t - n, this.completed = t, e && (this.progress = t), this.duration > this.budgetMs && (this.saturatedUntil = t + 6e4));
+	}
+	snapshot() {
+		let e = this.read();
+		if (e === null || this.invalid) return {
+			lastTurnMs: null,
+			saturated: null
+		};
+		let t = this.active !== null && e - this.active > this.budgetMs || e < this.saturatedUntil ? !0 : this.completed !== null && e - this.completed <= 5e3 ? !1 : null;
+		return {
+			lastTurnMs: this.duration,
+			saturated: t
+		};
+	}
+};
+//#endregion
+export { n as RoomHostTurnObservation };

package/dist/identities.js

@@ -0,0 +1,4 @@
+//#region src/identities.ts
+var e = "_voltro_room_seats", t = "_voltro_rooms", n = "_voltro_room_hosts", r = "_voltro_room_snapshots", i = "_voltro_room_outbox", a = "_voltro_room_snapshot_segments", o = "_voltro_room_subject_privacy", s = "_voltro_world_transitions", c = "_voltro_room_creations", l = "_voltro_room_lockstep_ticks";
+//#endregion
+export { t as ROOMS_TABLE, r as ROOM_CHECKPOINTS_TABLE, i as ROOM_COMMANDS_TABLE, c as ROOM_CREATIONS_TABLE, n as ROOM_HOSTS_TABLE, l as ROOM_LOCKSTEP_TICKS_TABLE, e as ROOM_SEATS_TABLE, a as ROOM_SNAPSHOT_SEGMENTS_TABLE, o as ROOM_SUBJECT_PRIVACY_TABLE, s as WORLD_TRANSITIONS_TABLE };