@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/directory.js

@@ -0,0 +1,322 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomForbidden as n, RoomFull as r, RoomGone as i, RoomPoolWaking as a } from "./errors.js";
+import { roomHostTransportEndpoints as o } from "./transportEndpoints.js";
+import { ROOMS_TABLE as s, ROOM_CREATIONS_TABLE as c, ROOM_HOSTS_TABLE as l } from "./identities.js";
+import { canonicalRoomJson as u } from "./checkpointJson.js";
+import { RoomDirectoryPort as d } from "./ports.js";
+import { captureAdmittedRoomPoolTopology as f, resolveRoomPool as p } from "./roomPoolTopology.js";
+import { resolveRoomHostSelection as m } from "./hostSelection.js";
+import { resolveRoomPoolHostSelection as h } from "./roomPoolSelection.js";
+import { and as g, eq as _, generateId as v, gt as y, or as b } from "@voltro/database";
+import { Effect as x, Layer as S } from "effect";
+import { createHash as C } from "node:crypto";
+import { registerWakeup as w } from "@voltro/runtime";
+// src/directory.ts
+var T = "room-pool", E = 5e3;
+function D(e) {
+	throw new t({ detail: e });
+}
+var O = (e) => typeof e == "number" && Number.isSafeInteger(e) && e >= 0 ? e : D("Invalid durable directory counter"), k = (e) => typeof e == "string" && e.trim() && e.length <= 191 ? e : D("Invalid directory identity"), A = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return Number.isFinite(t) ? t : D("Invalid durable directory timestamp");
+}, j = (e) => !e || typeof e != "object" || Array.isArray(e) ? D("Directory metadata must be an object") : structuredClone(e), M = (e) => typeof e.locked == "boolean" ? Object.freeze({
+	id: k(e.id),
+	name: k(e.name),
+	hostId: k(e.hostId),
+	tenantId: k(e.tenantId),
+	metadata: j(e.metadata),
+	clients: O(e.clients),
+	maxClients: O(e.maxClients),
+	locked: e.locked,
+	epoch: O(e.epoch),
+	...e.pool == null ? {} : { pool: k(e.pool) }
+}) : D("Invalid durable Room listing"), N = (e) => {
+	let t = e.load;
+	if (!t || !Number.isFinite(t.cpu) || t.cpu < 0 || t.cpu > 1 || typeof e.ready != "boolean") return D("Invalid durable host load");
+	let n = e.pool !== null && e.pool !== void 0, r = e.clientCapacity !== null && e.clientCapacity !== void 0;
+	if (n !== r || r && O(e.clientCapacity) < 1) return D("Invalid durable host pool capacity");
+	let i = o(e.publicAddress, e.webTransportAddress, e.webTransportCertificateHash);
+	return Object.freeze({
+		id: k(e.id),
+		address: i.ws,
+		...i.wt === void 0 ? {} : { webTransportAddress: i.wt },
+		...i.wtCertificateHash === void 0 ? {} : { webTransportCertificateHash: i.wtCertificateHash },
+		region: k(e.region),
+		...n ? {
+			pool: k(e.pool),
+			clientCapacity: O(e.clientCapacity)
+		} : {},
+		capacity: O(e.capacity),
+		rooms: O(t.rooms),
+		clients: O(t.clients),
+		cpu: t.cpu,
+		lastHeartbeatAt: A(e.lastHeartbeatAt),
+		ready: e.ready,
+		...e.instanceId !== null && e.instanceId !== void 0 ? { membership: {
+			instanceId: k(e.instanceId),
+			startedAt: A(e.membershipStartedAt)
+		} } : {}
+	});
+}, P = (a) => x.tryPromise({
+	try: a,
+	catch: (a) => a instanceof t || a instanceof e || a instanceof n || a instanceof r || a instanceof i ? a : new t({ detail: "Durable Room directory operation failed" })
+}), F = (e, t, n, r, i = !1) => e.query({
+	table: t,
+	predicate: n,
+	order: [{
+		column: "id",
+		direction: "asc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0,
+	...i ? { lock: "update" } : {}
+}), I = (d, S) => {
+	let I = S.pools === void 0 ? void 0 : f(S.pools), L = S.maxHosts ?? 256, R = S.maxHostCapacity ?? 4096, z = S.maxListedRooms ?? 256;
+	(![
+		L,
+		R,
+		z
+	].every((e) => Number.isSafeInteger(e) && e > 0) || !Number.isFinite(S.heartbeatTtlMs) || S.heartbeatTtlMs <= 0) && D("Invalid directory budgets");
+	let B = () => {
+		let e = S.epochNow();
+		return Number.isFinite(e) && e >= 0 && e <= 864e13 ? e : D("Invalid directory wall clock");
+	}, V = (e) => (O(e.rooms), O(e.clients), (!Number.isFinite(e.cpu) || e.cpu < 0 || e.cpu > 1) && D("Host CPU load must be measured between zero and one"), { ...e }), H = (t, n) => P(async () => {
+		n === void 0 || I && Object.hasOwn(I.pools, n) && I.pools[n].regions.includes(t) || D("Unknown host pool or region");
+		let r = await F(d, l, g(_("region", k(t)), _("ready", !0), _("draining", !1), y("lastHeartbeatAt", new Date(B() - S.heartbeatTtlMs)), ...n === void 0 ? I ? [] : [_("pool", null)] : [_("pool", n)]), L + 1);
+		if (r.length > L) throw new e({
+			budget: "listedHosts",
+			limit: L
+		});
+		return r.map(N);
+	});
+	return Object.freeze({
+		register: (n) => {
+			let r = Object.getOwnPropertyDescriptor(n, "webTransportAddress"), i = Object.getOwnPropertyDescriptor(n, "webTransportCertificateHash");
+			if (r && (!("value" in r) || !r.enumerable) || !r && "webTransportAddress" in n || i && (!("value" in i) || !i.enumerable) || !i && "webTransportCertificateHash" in n) return x.fail(new t({ detail: "Room host native endpoint requires own routing data" }));
+			let a;
+			try {
+				a = o(n.address, r?.value, i?.value);
+			} catch {
+				return x.fail(new t({ detail: "Room host endpoints are malformed" }));
+			}
+			return P(async () => {
+				n.ready !== void 0 && typeof n.ready != "boolean" && D("Invalid host readiness admission");
+				let t = O(n.capacity);
+				if (t < 1 || t > R) throw new e({
+					budget: "hostCapacity",
+					limit: R
+				});
+				let r = Object.getOwnPropertyDescriptor(n, "pool"), i = Object.getOwnPropertyDescriptor(n, "clientCapacity");
+				(r && (!r.enumerable || !("value" in r)) || i && (!i.enumerable || !("value" in i)) || !r && "pool" in n || !i && "clientCapacity" in n) && D("Host pool registration requires own data");
+				let o = null, s = null;
+				if (I) {
+					o = k(r?.value), s = O(i?.value);
+					let e = Object.hasOwn(I.pools, o) ? I.pools[o] : void 0;
+					(!e || !e.regions.includes(n.region) || s < 1 || e.capacity && (t !== e.capacity.rooms || s !== e.capacity.clients)) && D("Host registration does not match its declared pool capacity or region");
+				} else (r?.value !== void 0 || i?.value !== void 0) && D("Host pool registration requires an admitted topology");
+				let c = B(), u = v({
+					kind: "typeid",
+					prefix: "rhost"
+				}, l);
+				n.membership && (!Number.isSafeInteger(n.membership.startedAt) || n.membership.startedAt < 0 || n.membership.startedAt > 864e13) && D("Invalid host membership process identity");
+				let f = {
+					id: u,
+					publicAddress: a.ws,
+					webTransportAddress: a.wt ?? null,
+					webTransportCertificateHash: a.wtCertificateHash ?? null,
+					region: k(n.region),
+					capacity: t,
+					pool: o,
+					clientCapacity: s,
+					ready: n.ready ?? !0,
+					draining: !1,
+					load: V(n.load),
+					heartbeatRevision: 1,
+					lastHeartbeatAt: new Date(c),
+					startedAt: new Date(c),
+					instanceId: n.membership ? k(n.membership.instanceId) : null,
+					membershipStartedAt: n.membership ? new Date(n.membership.startedAt) : null
+				};
+				return await d.insert(l, f), N(f);
+			});
+		},
+		heartbeat: (e, t) => P(() => d.transactional(async (n) => {
+			let r = (await F(n, l, _("id", k(e)), 1, !0))[0];
+			if (!r) throw new i({ roomId: "host" });
+			let a = O(r.heartbeatRevision);
+			if (a >= 2 ** 53 - 1 && D("Host heartbeat revision is exhausted"), await n.updateMany("_voltro_room_hosts", {
+				load: V(t),
+				lastHeartbeatAt: new Date(B()),
+				heartbeatRevision: a + 1
+			}, { where: g(_("id", e), _("heartbeatRevision", a)) }) !== 1) throw new i({ roomId: "host" });
+		})),
+		setReady: (e, t) => P(() => d.transactional(async (n) => {
+			typeof t != "boolean" && D("Invalid host readiness admission");
+			let r = (await F(n, l, _("id", k(e)), 1, !0))[0];
+			if (!r) throw new i({ roomId: "host" });
+			if (t && r.draining === !0 && D("A draining Host cannot reopen routing admission"), r.ready === t) return;
+			typeof r.ready != "boolean" && D("Invalid durable host readiness");
+			let a = O(r.heartbeatRevision);
+			if (a >= 2 ** 53 - 1 && D("Host heartbeat revision is exhausted"), await n.updateMany("_voltro_room_hosts", {
+				ready: t,
+				lastHeartbeatAt: new Date(B()),
+				heartbeatRevision: a + 1
+			}, { where: g(_("id", e), _("ready", r.ready)) }) !== 1) throw new i({ roomId: "host" });
+		})),
+		hosts: H,
+		observeOwnership: (e, t) => x.uninterruptible(P(() => d.transactional(async (n) => {
+			let r = (await n.query({
+				table: s,
+				predicate: g(_("id", k(e)), _("tenantId", k(t))),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: [
+					"id",
+					"tenantId",
+					"hostId",
+					"epoch",
+					"state"
+				],
+				lock: "update"
+			}))[0];
+			if (!r) return null;
+			let i = O(r.epoch), a = r.state;
+			return i < 1 || a !== "creating" && a !== "live" && a !== "orphaned" && a !== "faulted" && a !== "disposed" && a !== "hibernating" && a !== "hibernated" || (a === "hibernated" ? r.hostId !== null : r.hostId === null) ? D("Invalid durable Room ownership observation") : Object.freeze({
+				roomId: k(r.id),
+				tenantId: k(r.tenantId),
+				hostId: a === "hibernated" ? null : k(r.hostId),
+				epoch: i,
+				state: a
+			});
+		}))),
+		selectHost: (e, n) => x.gen(function* () {
+			let i = yield* x.try({
+				try: () => {
+					if (I) return n ? p(I, n.name, n.tenantId, e, n.pool).name : D("Pooled host selection requires room and tenant routing");
+					if (n?.pool !== void 0) return D("Explicit pool routing requires an admitted topology");
+				},
+				catch: () => new t({ detail: "Room pool routing could not be admitted" })
+			}), o = yield* H(e, i), s = yield* x.try({
+				try: () => I ? h(I, o.map((e) => e.pool === void 0 || e.clientCapacity === void 0 ? D("Pooled directory contains an incomplete host registration") : e), n.name, n.tenantId, e, n.pool, S.poolSelectHost ?? (S.strategies?.selectHost === void 0 ? void 0 : (e, t) => {
+					let n = S.strategies.selectHost(e, t);
+					return n === null ? null : n;
+				})) : m(o, e, S.strategies?.selectHost),
+				catch: () => new t({ detail: "Room host selection strategy failed" })
+			});
+			if (!s) {
+				let s = i === void 0 ? void 0 : I?.pools[i];
+				return i !== void 0 && o.length === 0 && s?.scaling.scaleToZero === !0 ? (yield* x.tryPromise({
+					try: () => w(d, {
+						tenantId: n.tenantId,
+						kind: T,
+						refId: `${i}/${e}`,
+						wakeAt: new Date(S.epochNow())
+					}),
+					catch: () => new t({ detail: "Room pool wake could not be recorded" })
+				}), yield* x.fail(new a({
+					pool: i,
+					retryAfterMs: E
+				}))) : yield* x.fail(new r({ roomId: "host" }));
+			}
+			return s;
+		}),
+		createOwnedRoom: (e, n) => {
+			let a, o;
+			try {
+				let e = Object.getOwnPropertyDescriptor(n, "creationKey");
+				(e && (!("value" in e) || !e.enumerable) || !e && "creationKey" in n) && D("Room creation key must be own server data"), o = e ? k(e.value) : void 0, o !== void 0 && !/^[a-f0-9]{64}$/.test(o) && D("Room creation key requires a server digest"), o !== void 0 && n.staged !== !0 && D("Idempotent Room creation requires staged publication"), a = structuredClone(n);
+			} catch {
+				return x.fail(new t({ detail: "Invalid captured Room creation request" }));
+			}
+			return P(() => d.transactional(async (t) => {
+				let n = B(), d = (await F(t, l, _("id", k(e)), 1, !0))[0];
+				if (!d || d.ready !== !0 || d.draining === !0 || A(d.lastHeartbeatAt) <= n - S.heartbeatTtlMs) throw new i({ roomId: "host" });
+				let f = null;
+				I ? (f = p(I, a.name, a.tenantId, k(d.region), a.pool).name, (d.pool !== f || O(d.clientCapacity) < 1) && D("Room creation target is outside its admitted pool")) : (d.pool != null || a.pool !== void 0) && D("Pooled Room creation requires an admitted topology");
+				let m = o === void 0 ? void 0 : C("sha256").update(u({
+					tenantId: k(a.tenantId),
+					name: k(a.name),
+					pool: f,
+					maxClients: a.maxClients,
+					metadata: j(a.metadata),
+					options: a.options ?? null,
+					private: a.private,
+					staged: !0
+				})).digest("hex");
+				if (o !== void 0) {
+					let n = await F(t, c, g(_("tenantId", k(a.tenantId)), _("requestKey", o)), 2, !0);
+					if (n.length > 1 && D("Ambiguous Room creation receipt"), n.length) {
+						let r = n[0];
+						(r.requestHash !== m || r.tenantId !== a.tenantId || r.requestKey !== o) && D("Room creation retry changed its original input");
+						let i = await F(t, s, _("id", k(r.roomId)), 2, !0), c = i[0];
+						return i.length === 1 && c && c.tenantId === a.tenantId && c.hostId === e && c.name === a.name && (c.pool ?? null) === f && c.epoch === 1 && ["creating", "live"].includes(String(c.state)) || D("Room creation retry requires its original active owner"), M(c);
+					}
+				}
+				let h = O(d.capacity);
+				if ((h < 1 || h > R) && D("Invalid durable host capacity"), (await F(t, "_voltro_rooms", g(_("hostId", e), b(_("state", "live"), _("state", "creating"), _("state", "hibernating"))), h + 1)).length >= h) throw new r({ roomId: "host" });
+				let y = O(a.maxClients);
+				(y < 1 || typeof a.private != "boolean") && D("Invalid Room creation options");
+				let x = v({
+					kind: "typeid",
+					prefix: "room"
+				}, s), w = {
+					id: x,
+					name: k(a.name),
+					hostId: e,
+					pool: f,
+					tenantId: k(a.tenantId),
+					metadata: j(a.metadata),
+					options: structuredClone(a.options ?? null),
+					locked: !1,
+					private: a.private,
+					clients: 0,
+					maxClients: y,
+					epoch: 1,
+					state: a.staged ? "creating" : "live",
+					createdAt: new Date(n),
+					updatedAt: new Date(n)
+				};
+				return await t.insert(s, w), o !== void 0 && await t.insert(c, {
+					id: v({
+						kind: "typeid",
+						prefix: "rcreate"
+					}, c),
+					tenantId: w.tenantId,
+					requestKey: o,
+					requestHash: m,
+					roomId: x,
+					createdAt: new Date(n)
+				}), M(w);
+			}));
+		},
+		abandonCreation: (e, t, r) => P(async () => {
+			if (await d.updateMany("_voltro_rooms", {
+				state: "disposed",
+				updatedAt: new Date(B())
+			}, { where: g(_("id", k(t)), _("hostId", k(e)), _("tenantId", k(r)), _("epoch", 1), _("state", "creating"), _("clients", 0)) }) !== 1) throw new n({ roomId: t });
+		}),
+		unregister: (e) => P(() => d.transactional(async (t) => {
+			if ((await F(t, "_voltro_room_hosts", _("id", k(e)), 1, !0))[0]) {
+				if ((await F(t, "_voltro_rooms", g(_("hostId", e), b(_("state", "live"), _("state", "creating"), _("state", "hibernating"))), 1)).length) return D("A host with authoritative active rooms cannot unregister");
+				await t.deleteMany(l, { where: _("id", e) });
+			}
+		})),
+		list: (t, n, r) => P(async () => {
+			if (!Number.isSafeInteger(r) || r < 1 || r > z) throw new e({
+				budget: "listedRooms",
+				limit: z
+			});
+			return (await F(d, s, g(_("tenantId", k(t)), _("name", k(n)), _("state", "live"), _("private", !1)), r)).map(M);
+		}),
+		setListing: (e, t, r, i, a) => P(async () => {
+			if ((O(i) < 1 || typeof a.locked != "boolean" || typeof a.private != "boolean") && D("Invalid listing options"), await d.updateMany("_voltro_rooms", {
+				metadata: j(a.metadata),
+				locked: a.locked,
+				private: a.private,
+				updatedAt: new Date(B())
+			}, { where: g(_("id", k(t)), _("tenantId", k(r)), _("hostId", k(e)), _("epoch", i), _("state", "live")) }) !== 1) throw new n({ roomId: t });
+		})
+	});
+}, L = (e, t) => S.succeed(d, I(e, t));
+export { T as ROOM_POOL_WAKE, E as ROOM_POOL_WAKE_RETRY_MS, I as dataStoreRoomDirectory, M as decodeRoomDirectoryListing, L as roomDirectoryLayer };

package/dist/directoryProjection.js

@@ -0,0 +1,116 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { Effect as n, Option as r } from "effect";
+import { HotError as i, readHotStoreWithFallback as a } from "@voltro/kv/hot/contract";
+// src/directoryProjection.ts
+var o = (e) => {
+	if (typeof e != "string" || !e.trim() || e.length > 191) throw new t({ detail: "Invalid directory projection identity" });
+	return e;
+}, s = (e) => {
+	if (!e || typeof e != "object" || Array.isArray(e)) throw new t({ detail: "Invalid directory projection configuration" });
+	let n = o(e.tenantId), r = e.namespace, i = e.maxEntries ?? 256, a = e.maxPayloadBytes ?? 65536, s = e.onUnavailable ?? "fail";
+	if (typeof r != "string" || !/^[a-zA-Z0-9][a-zA-Z0-9:_-]{0,95}$/.test(r) || !Number.isSafeInteger(e.ttlMs) || e.ttlMs < 1 || !Number.isSafeInteger(i) || i < 1 || !Number.isSafeInteger(a) || a < 1 || s !== "fail" && s !== "degrade") throw new t({ detail: "Invalid directory projection budgets or policy" });
+	return Object.freeze({
+		tenantId: n,
+		namespace: r,
+		maxEntries: i,
+		maxPayloadBytes: a,
+		onUnavailable: s,
+		ttlMs: e.ttlMs
+	});
+}, c = (e) => {
+	if (!e || typeof e != "object" || Array.isArray(e)) throw new t({ detail: "Malformed directory projection hint" });
+	let n = o(Reflect.get(e, "id")), r = o(Reflect.get(e, "hostId")), i = Reflect.get(e, "epoch"), a = Reflect.get(e, "clients"), s = Reflect.get(e, "maxClients"), c = Reflect.get(e, "locked");
+	if (typeof i != "number" || !Number.isSafeInteger(i) || i < 1 || typeof a != "number" || !Number.isSafeInteger(a) || a < 0 || typeof s != "number" || !Number.isSafeInteger(s) || s < 1 || a > s || typeof c != "boolean") throw new t({ detail: "Malformed directory projection counters" });
+	return Object.freeze({
+		id: n,
+		hostId: r,
+		epoch: i,
+		clients: a,
+		maxClients: s,
+		locked: c
+	});
+}, l = (l, u, d) => {
+	let { tenantId: f, namespace: p, maxEntries: m, maxPayloadBytes: h, onUnavailable: g, ttlMs: _ } = s(d), v = (e) => `${p}:directory:${Buffer.from(JSON.stringify([f, e]), "utf8").toString("base64url")}`, y = (r) => l.list(f, r, m).pipe(n.flatMap((i) => n.try({
+		try: () => {
+			if (i.length > m) throw new e({
+				budget: "directoryProjectionEntries",
+				limit: m
+			});
+			let n = /* @__PURE__ */ new Set(), a = i.map((e) => {
+				if (e.tenantId !== f || e.name !== r) throw new t({ detail: "Directory source escaped its tenant/name scope" });
+				let i = c(e);
+				if (n.has(i.id)) throw new t({ detail: "Duplicate directory projection identity" });
+				return n.add(i.id), i;
+			});
+			return Object.freeze(a.sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)));
+		},
+		catch: (n) => n instanceof e ? n : new t({ detail: "Directory source admission failed" })
+	}))), b = (e, r) => n.try({
+		try: () => {
+			if (Buffer.byteLength(r, "utf8") > h) throw Error("payload budget");
+			let t = JSON.parse(r);
+			if (!t || typeof t != "object" || Array.isArray(t) || Reflect.get(t, "version") !== 1 || Reflect.get(t, "tenantId") !== f || Reflect.get(t, "name") !== e) throw Error("scope");
+			let n = Reflect.get(t, "entries");
+			if (!Array.isArray(n) || n.length > m) throw Error("entry budget");
+			let i = /* @__PURE__ */ new Set(), a = n.map((e) => {
+				let t = c(e);
+				if (i.has(t.id)) throw Error("duplicate");
+				return i.add(t.id), t;
+			});
+			return Object.freeze(a.sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)));
+		},
+		catch: () => new t({ detail: "Cached directory hint payload failed admission" })
+	}), x = (e, r) => n.try({
+		try: () => o(e),
+		catch: () => new t({ detail: "Invalid directory projection room name" })
+	}).pipe(n.flatMap(r)), S = (e, t) => t.pipe(n.mapError((t) => t._tag === "HotError" ? new i({
+		operation: e,
+		key: "roomDirectory",
+		reason: t.reason
+	}) : t));
+	return Object.freeze({
+		hints: (t, i = m) => S("directoryRead", x(t, (t) => n.gen(function* () {
+			if (!Number.isSafeInteger(i) || i < 1 || i > m) return yield* n.fail(new e({
+				budget: "directoryProjectionRead",
+				limit: m
+			}));
+			let o = yield* a({
+				store: u,
+				onUnavailable: g,
+				read: (e) => e.hget(v(t), "payload", { consistency: "primary" }).pipe(n.map((e) => ({
+					kind: "hot",
+					value: e
+				}))),
+				fallback: () => y(t).pipe(n.map((e) => ({
+					kind: "sql",
+					value: e
+				})))
+			}), s = o.kind === "sql" ? o.value : r.isNone(o.value) ? yield* y(t) : yield* b(t, o.value.value);
+			return Object.freeze(s.slice(0, i));
+		}))),
+		rebuildFromSource: (t) => S("directoryRebuild", x(t, (t) => n.gen(function* () {
+			let r = yield* y(t), i = JSON.stringify({
+				version: 1,
+				tenantId: f,
+				name: t,
+				entries: r
+			});
+			return Buffer.byteLength(i, "utf8") > h ? yield* n.fail(new e({
+				budget: "directoryProjectionPayloadBytes",
+				limit: h
+			})) : (yield* u.hset(v(t), { payload: i }, { ttlMs: _ }), Object.freeze({ entries: r.length }));
+		}))),
+		invalidate: (e) => S("directoryInvalidate", x(e, (e) => u.delete(v(e)).pipe(n.asVoid)))
+	});
+}, u = async (e, n, r) => {
+	if (!e.connectionRegistry || !e.hotStore || r.availabilityRole !== void 0 && !e.connectionAvailability) throw new t({ detail: "Directory projection requires the app-owned connection registry and tenant HotStore port" });
+	let i = o(r.tenantId), a = r.availabilityRole === void 0 ? "fail" : e.connectionAvailability(r.availabilityRole);
+	if (a !== "fail" && a !== "degrade") throw new t({ detail: "Directory projection connection policy was not admitted" });
+	let c = s({
+		...r,
+		tenantId: i,
+		onUnavailable: a
+	});
+	return l(n, await e.hotStore({ tenantId: i }), c);
+};
+export { u as bindRoomDirectoryProjection, l as makeRoomDirectoryProjection };

package/dist/errors.d.ts

@@ -0,0 +1,125 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare class BudgetExceeded extends BudgetExceeded_base {
+    get message(): string;
+}
+
+declare const BudgetExceeded_base: Schema.Class<BudgetExceeded, Schema.TaggedStruct<"BudgetExceeded", {
+    readonly budget: Schema.String;
+    readonly limit: Schema.Number;
+}>, YieldableError>;
+
+export declare class NotRoomMember extends NotRoomMember_base {
+}
+
+declare const NotRoomMember_base: Schema.Class<NotRoomMember, Schema.TaggedStruct<"NotRoomMember", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+export declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+export declare class RoomAuthoringError extends RoomAuthoringError_base {
+    get message(): string;
+}
+
+declare const RoomAuthoringError_base: Schema.Class<RoomAuthoringError, Schema.TaggedStruct<"RoomAuthoringError", {
+    readonly room: Schema.String;
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+export declare class RoomForbidden extends RoomForbidden_base {
+}
+
+declare const RoomForbidden_base: Schema.Class<RoomForbidden, Schema.TaggedStruct<"RoomForbidden", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+export declare class RoomFull extends RoomFull_base {
+}
+
+declare const RoomFull_base: Schema.Class<RoomFull, Schema.TaggedStruct<"RoomFull", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+export declare class RoomGone extends RoomGone_base {
+}
+
+declare const RoomGone_base: Schema.Class<RoomGone, Schema.TaggedStruct<"RoomGone", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+/** Durable work/capacity is still owned; this is backpressure, not completion. */
+export declare class RoomHibernatePending extends RoomHibernatePending_base {
+}
+
+declare const RoomHibernatePending_base: Schema.Class<RoomHibernatePending, Schema.TaggedStruct<"RoomHibernatePending", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+export declare class RoomLocked extends RoomLocked_base {
+}
+
+declare const RoomLocked_base: Schema.Class<RoomLocked, Schema.TaggedStruct<"RoomLocked", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+/** The pool has no host because it scaled to zero; one is starting. Reserve again after `retryAfterMs`. */
+export declare class RoomPoolWaking extends RoomPoolWaking_base {
+}
+
+declare const RoomPoolWaking_base: Schema.Class<RoomPoolWaking, Schema.TaggedStruct<"RoomPoolWaking", {
+    readonly pool: Schema.String;
+    readonly retryAfterMs: Schema.Number;
+}>, YieldableError>;
+
+/** New Room reservations are closed for this caller (maintenance, a kill switch...): the app's
+ * `admission` refused. `until`: epoch ms when they reopen, if known; `messageKey`: the app's text. */
+export declare class RoomsClosed extends RoomsClosed_base {
+}
+
+declare const RoomsClosed_base: Schema.Class<RoomsClosed, Schema.TaggedStruct<"RoomsClosed", {
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly messageKey: Schema.String;
+}>, YieldableError>;
+
+export declare class SeatExpired extends SeatExpired_base {
+}
+
+declare const SeatExpired_base: Schema.Class<SeatExpired, Schema.TaggedStruct<"SeatExpired", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+export declare class SimulationConformanceDivergence extends SimulationConformanceDivergence_base {
+}
+
+declare const SimulationConformanceDivergence_base: Schema.Class<SimulationConformanceDivergence, Schema.TaggedStruct<"SimulationConformanceDivergence", {
+    readonly tick: Schema.Int;
+    readonly phase: Schema.Literals<readonly ["repeat", "rollback", "provided-trace"]>;
+    readonly component: Schema.Literals<readonly ["schemaHash", "hash", "rng"]>;
+}>, YieldableError>;
+
+export declare class SimulationConformanceFailure extends SimulationConformanceFailure_base {
+}
+
+declare const SimulationConformanceFailure_base: Schema.Class<SimulationConformanceFailure, Schema.TaggedStruct<"SimulationConformanceFailure", {
+    readonly tick: Schema.Int;
+    readonly phase: Schema.Literals<readonly ["repeat", "rollback", "trace"]>;
+    readonly operation: Schema.Literals<readonly ["init", "step", "replay"]>;
+}>, YieldableError>;
+
+/** A World transition asked for inside the World's `transitionCooldownMs`; retry after `retryAfterMs`. */
+export declare class WorldTransitionCooldown extends WorldTransitionCooldown_base {
+}
+
+declare const WorldTransitionCooldown_base: Schema.Class<WorldTransitionCooldown, Schema.TaggedStruct<"WorldTransitionCooldown", {
+    readonly retryAfterMs: Schema.Number;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,52 @@
+import { Schema as e } from "effect";
+// src/errors.ts
+var t = class extends e.TaggedError()("RoomAuthoringError", {
+	room: e.String,
+	detail: e.String
+}) {
+	get message() {
+		return this.detail;
+	}
+}, n = class extends e.TaggedError()("ProtocolError", { detail: e.String }) {
+	get message() {
+		return this.detail;
+	}
+}, r = class extends e.TaggedError()("SimulationConformanceDivergence", {
+	tick: e.Int,
+	phase: e.Literals([
+		"repeat",
+		"rollback",
+		"provided-trace"
+	]),
+	component: e.Literals([
+		"schemaHash",
+		"hash",
+		"rng"
+	])
+}) {}, i = class extends e.TaggedError()("SimulationConformanceFailure", {
+	tick: e.Int,
+	phase: e.Literals([
+		"repeat",
+		"rollback",
+		"trace"
+	]),
+	operation: e.Literals([
+		"init",
+		"step",
+		"replay"
+	])
+}) {}, a = class extends e.TaggedError()("RoomHibernatePending", { roomId: e.String }) {}, o = class extends e.TaggedError()("WorldTransitionCooldown", { retryAfterMs: e.Number }) {}, s = class extends e.TaggedError()("RoomsClosed", {
+	until: e.NullOr(e.Number),
+	messageKey: e.String
+}) {}, c = class extends e.TaggedError()("RoomFull", { roomId: e.String }) {}, l = class extends e.TaggedError()("RoomPoolWaking", {
+	pool: e.String,
+	retryAfterMs: e.Number
+}) {}, u = class extends e.TaggedError()("RoomLocked", { roomId: e.String }) {}, d = class extends e.TaggedError()("RoomGone", { roomId: e.String }) {}, f = class extends e.TaggedError()("RoomForbidden", { roomId: e.String }) {}, p = class extends e.TaggedError()("SeatExpired", { sessionId: e.String }) {}, m = class extends e.TaggedError()("NotRoomMember", { sessionId: e.String }) {}, h = class extends e.TaggedError()("BudgetExceeded", {
+	budget: e.String,
+	limit: e.Number
+}) {
+	get message() {
+		return `Room budget ${this.budget} exceeded (limit ${this.limit})`;
+	}
+};
+export { h as BudgetExceeded, m as NotRoomMember, n as ProtocolError, t as RoomAuthoringError, f as RoomForbidden, c as RoomFull, d as RoomGone, a as RoomHibernatePending, u as RoomLocked, l as RoomPoolWaking, s as RoomsClosed, p as SeatExpired, r as SimulationConformanceDivergence, i as SimulationConformanceFailure, o as WorldTransitionCooldown };