@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/subjectPrivacy.js

@@ -0,0 +1,280 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOMS_TABLE as t, ROOM_SEATS_TABLE as n, ROOM_SUBJECT_PRIVACY_TABLE as r } from "./identities.js";
+import { canonicalRoomJson as i } from "./checkpointJson.js";
+import { roomSubjectPrivacyKey as a } from "./subjectAdmission.js";
+import { RoomSubjectPrivacyPort as o } from "./ports.js";
+import { captureRoomSeatInputReceipt as s } from "./inputReceipts.js";
+import { captureRoomSnapshotEffectRunner as c } from "./snapshotBlobIndex.js";
+import { readRoomErasureJournal as l } from "./roomErasure.js";
+import { captureRoomLockstepAdmissionEnvelope as u, roomLockstepCreationProjection as d } from "./lockstepAdmissionCodec.js";
+import { and as f, eq as p } from "@voltro/database";
+import { Effect as m, Layer as h } from "effect";
+// src/subjectPrivacy.ts
+var g = [
+	"pending",
+	"fenced",
+	"selected",
+	"rooms-erased",
+	"data-erased",
+	"complete"
+];
+function _(t) {
+	throw new e({ detail: t });
+}
+var v = (e) => typeof e == "string" && e.trim() && e.length <= 191 ? e : _("Invalid Rooms Subject privacy identity"), y = (e) => !e || typeof e != "object" || Array.isArray(e) || !e.target || Object.keys(e).some((e) => !["requestId", "target"].includes(e)) || Object.keys(e.target).some((e) => ![
+	"tenantId",
+	"subjectId",
+	"kind"
+].includes(e)) || !["user", "guest"].includes(e.target.kind) ? _("Invalid Rooms Subject privacy request") : Object.freeze({
+	requestId: v(e.requestId),
+	target: Object.freeze({
+		tenantId: v(e.target.tenantId),
+		subjectId: v(e.target.subjectId),
+		kind: e.target.kind
+	})
+}), b = (e) => a(e.target.tenantId, e.target.subjectId), x = (e, t) => {
+	if (!Array.isArray(e) || e.length > t) return _("Rooms Subject association inventory exceeds its budget");
+	let n = [];
+	for (let t = 0; t < e.length; t++) {
+		if (!Object.hasOwn(e, t)) return _("Sparse Rooms Subject association inventory");
+		n.push(v(e[t]));
+	}
+	return new Set(n).size === n.length ? Object.freeze(n.sort()) : _("Duplicate Rooms Subject association");
+}, S = (e, t = 256) => {
+	if (!Number.isSafeInteger(t) || t < 1 || t > 65536) return _("Invalid Rooms Subject selection budget");
+	if (!e || typeof e != "object" || Array.isArray(e)) return _("Malformed Rooms Subject privacy receipt");
+	let n = e;
+	if (v(n.requestId), Object.keys(n).some((e) => ![
+		"version",
+		"requestId",
+		"kind",
+		"phase",
+		"roomIds"
+	].includes(e)) || n.version !== 1 || n.kind !== "user" && n.kind !== "guest" || !g.includes(n.phase)) return _("Rooms Subject privacy receipt identity changed");
+	let r = x(n.roomIds, t);
+	return (n.phase === "pending" || n.phase === "fenced") && r.length || r.some((e, t) => e !== n.roomIds[t]) ? _("Invalid Rooms Subject privacy selection receipt") : Object.freeze({
+		version: 1,
+		requestId: n.requestId,
+		kind: n.kind,
+		phase: n.phase,
+		roomIds: r
+	});
+}, C = (e, t, n = 256) => {
+	let r = S(e, n);
+	return r.requestId !== t.requestId || r.kind !== t.target.kind ? _("Rooms Subject privacy receipt identity changed") : r;
+}, w = (a, o) => {
+	if (!o || typeof o.epochNow != "function" || typeof o.erasure?.erase != "function" || !o.policy || ![
+		"withdraw",
+		"rooms",
+		"eraseAssociations",
+		"exportRoom"
+	].every((e) => typeof Reflect.get(o.policy, e) == "function")) return _("Rooms Subject privacy requires actual erasure and complete app data policy");
+	let h = Object.getOwnPropertyDescriptor(o.policy, "afterFence");
+	if (h && (!h.enumerable || !("value" in h) || typeof h.value != "function") || !h && "afterFence" in o.policy) return _("Rooms after-fence policy requires an own actual Effect function");
+	let S = h ? h.value.bind(o.policy) : void 0, w = o.epochNow.bind(o), T = o.erasure.erase.bind(o.erasure), E = o.policy.withdraw.bind(o.policy), D = o.policy.rooms.bind(o.policy), O = o.policy.eraseAssociations.bind(o.policy), k = o.policy.exportRoom.bind(o.policy), A = o.maxRooms ?? 256, j = o.maxSeats ?? 4096, M = o.maxExportBytes ?? 1048576;
+	if (![A, j].every((e) => Number.isSafeInteger(e) && e > 0 && e <= 65536) || !Number.isSafeInteger(M) || M < 1 || M > 67108864) return _("Invalid Rooms Subject privacy budgets");
+	let N = () => {
+		let e = w();
+		return !Number.isFinite(e) || e < 0 || e > 864e13 ? _("Invalid Rooms Subject privacy clock") : new Date(e);
+	}, P = (e) => f(p("tenantId", e.target.tenantId), p("subjectKey", b(e))), F = (e) => f(p("tenantId", e.target.tenantId), p("subjectId", e.target.subjectId)), I = async (e, t, n = !0) => {
+		let i = await e.query({
+			table: r,
+			predicate: P(t),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: [
+				"tenantId",
+				"subjectKey",
+				"journal"
+			],
+			lock: "update"
+		});
+		if (i.length > 1 || i.some((e) => e.tenantId !== t.target.tenantId || e.subjectKey !== b(t))) return _("Rooms Subject privacy receipt scope changed");
+		if (!i.length) return null;
+		let a = i[0].journal;
+		return C(a, n ? t : {
+			...t,
+			requestId: a?.requestId
+		}, A);
+	}, L = async (e) => {
+		let t = [
+			"id",
+			"roomId",
+			"sessionId",
+			"tenantId",
+			"subjectId",
+			"epoch",
+			"role",
+			"state",
+			"inputReceipt",
+			"attributes",
+			"expiresAt",
+			"graceUntil",
+			"createdAt",
+			"updatedAt"
+		], r = await a.query({
+			table: n,
+			predicate: F(e),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: j + 1,
+			skip: void 0,
+			projection: t
+		});
+		return r.length > j || new Set(r.map((e) => e.id)).size !== r.length || r.some((t) => t.tenantId !== e.target.tenantId || t.subjectId !== e.target.subjectId) ? _("Rooms Subject seat inventory exceeds its scope or budget") : Object.freeze(r.map((e) => (v(e.id), v(e.roomId), v(e.sessionId), !Number.isSafeInteger(e.epoch) || Number(e.epoch) < 1 || !["player", "spectator"].includes(String(e.role)) || ![
+			"reserved",
+			"connected",
+			"grace",
+			"released"
+		].includes(String(e.state)) ? _("Invalid Rooms Subject seat observation") : Object.freeze({
+			...Object.fromEntries(t.map((t) => [t, e[t]])),
+			inputReceipt: s(e.inputReceipt)
+		}))));
+	}, R = async (e) => {
+		let n = await a.query({
+			table: t,
+			predicate: f(p("tenantId", e.target.tenantId), p("lockstepCreatorSubjectId", e.target.subjectId)),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: A + 1,
+			skip: void 0,
+			projection: [
+				"id",
+				"tenantId",
+				"epoch",
+				"lockstepCreatorSubjectId",
+				"lockstepAdmission"
+			]
+		});
+		return n.length > A || new Set(n.map((e) => e.id)).size !== n.length ? _("Rooms Subject creation inventory exceeds its budget") : Object.freeze(n.map((t) => {
+			if (t.tenantId !== e.target.tenantId || t.lockstepCreatorSubjectId !== e.target.subjectId || !Number.isSafeInteger(t.epoch) || Number(t.epoch) < 1 || Number(t.epoch) > 2147483647) return _("Rooms Subject creation inventory changed scope");
+			let n = u(t.lockstepAdmission, {
+				roomId: v(t.id),
+				tenantId: e.target.tenantId,
+				epoch: Number(t.epoch)
+			});
+			return d(n, e.target.subjectId) || _("Rooms Subject indexed creator differs from its receipt");
+		}));
+	}, z = async (e, n, r) => {
+		let i = await a.query({
+			table: t,
+			predicate: f(p("id", n), p("tenantId", e.target.tenantId)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: r ? void 0 : ["id", "tenantId"]
+		});
+		if (i.length !== 1 || i[0].id !== n || i[0].tenantId !== e.target.tenantId) return _("Rooms Subject association has no exact SQL authority");
+		if (r) {
+			let t = l(i[0], n, e.target.tenantId);
+			if (t?.phase !== "complete" || t.requestId !== e.requestId) return _("Rooms Subject selected room is not erased");
+		}
+	}, B = async (e, t, n, r) => a.transactional(async (i) => {
+		let a = await I(i, e);
+		if (!a) return _("Rooms Subject privacy lost its receipt");
+		if (!(g.indexOf(a.phase) > g.indexOf(t))) {
+			if (a.phase !== t) return _("Rooms Subject privacy phase regressed");
+			if (await i.updateMany("_voltro_room_subject_privacy", {
+				journal: {
+					...a,
+					phase: n,
+					...r === void 0 ? {} : { roomIds: [...r] }
+				},
+				updatedAt: N()
+			}, { where: P(e) }) !== 1) return _("Rooms Subject privacy lost its transition");
+		}
+	}), V = async (e, t, n) => m.isEffect(t) ? (v(e.requestId), n(t)) : _("Rooms Subject policy must return actual Effects"), H = (t, n) => {
+		let r;
+		try {
+			r = y(t);
+		} catch {
+			return m.fail(new e({ detail: "Rooms Subject privacy admission failed" }));
+		}
+		return m.flatMap(m.context(), (t) => m.uninterruptible(m.tryPromise({
+			try: () => n(r, c(t)),
+			catch: () => new e({ detail: "Rooms Subject privacy remains unconfirmed" })
+		})));
+	};
+	return Object.freeze({
+		erase: (e) => H(e, async (e, t) => {
+			await a.insertIgnore(r, {
+				tenantId: e.target.tenantId,
+				subjectKey: b(e),
+				journal: {
+					version: 1,
+					requestId: e.requestId,
+					kind: e.target.kind,
+					phase: "pending",
+					roomIds: []
+				},
+				createdAt: N(),
+				updatedAt: N()
+			}, { conflictColumns: ["tenantId", "subjectKey"] });
+			for (let n of g) {
+				let r = await a.transactional((t) => I(t, e));
+				if (!r || g.indexOf(r.phase) < g.indexOf(n)) return _("Rooms Subject privacy receipt is incomplete");
+				if (r.phase === n) {
+					if (n === "pending") {
+						if (await V(e, E(e), t) !== void 0) return _("Rooms Subject withdrawal must confirm actual void");
+						await B(e, n, "fenced");
+					} else if (n === "fenced") {
+						if (S && await V(e, S(e), t) !== void 0) return _("Rooms after-fence privacy work must confirm actual void");
+						let r = x(await V(e, D(e), t), A), i = x([.../* @__PURE__ */ new Set([
+							...r,
+							...(await L(e)).map((e) => v(e.roomId)),
+							...(await R(e)).map((e) => e.roomId)
+						])], A);
+						for (let t of i) await z(e, t, !1);
+						await B(e, n, "selected", i);
+					} else if (n === "selected") {
+						for (let n of r.roomIds) await V(e, T(Object.freeze({
+							roomId: n,
+							tenantId: e.target.tenantId,
+							requestId: e.requestId
+						})), t);
+						for (let t of r.roomIds) await z(e, t, !0);
+						if ((await L(e)).length || (await R(e)).length || x(await V(e, D(e), t), A).some((e) => !r.roomIds.includes(e))) return _("Rooms Subject gained an unfenced association");
+						await B(e, n, "rooms-erased");
+					} else if (n === "rooms-erased") {
+						if (await V(e, O(e), t) !== void 0) return _("Rooms Subject association erasure must confirm actual void");
+						await B(e, n, "data-erased");
+					} else {
+						for (let n of r.roomIds) await V(e, T(Object.freeze({
+							roomId: n,
+							tenantId: e.target.tenantId,
+							requestId: e.requestId
+						})), t), await z(e, n, !0);
+						if ((await L(e)).length || (await R(e)).length || x(await V(e, D(e), t), A).length) return _("Rooms Subject erasure has remaining references");
+						if (n === "data-erased") await B(e, n, "complete");
+						else return;
+					}
+				}
+			}
+		}),
+		export: (e) => H(e, async (e, t) => {
+			let n = await L(e), r = await R(e), o = x(await V(e, D(e), t), A), s = x([.../* @__PURE__ */ new Set([...o, ...n.map((e) => v(e.roomId))])], A), c = [], l = M;
+			for (let n of s) {
+				await z(e, n, !1);
+				let r = i(await V(e, k(n, e), t));
+				if (l -= Buffer.byteLength(r, "utf8"), l < 0) return _("Rooms Subject export exceeds its byte budget");
+				c.push(Object.freeze({
+					roomId: n,
+					data: JSON.parse(r)
+				}));
+			}
+			let u = await a.transactional((t) => I(t, e, !1)), d = JSON.stringify({
+				seats: n,
+				creations: r,
+				rooms: c,
+				cleanup: { phase: u?.phase ?? null }
+			});
+			return Buffer.byteLength(d, "utf8") > M ? _("Rooms Subject export exceeds its byte budget") : JSON.parse(d);
+		})
+	});
+}, T = (e, t) => h.succeed(o, w(e, t));
+export { S as captureRoomSubjectPrivacyJournal, w as dataStoreRoomSubjectPrivacy, C as readRoomSubjectPrivacyJournal, T as roomSubjectPrivacyLayer };

package/dist/subjectPrivacyBinding.js

@@ -0,0 +1,89 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureRoomSnapshotBlobs as t } from "./snapshotBlobIndex.js";
+import { dataStoreRoomErasure as n } from "./roomErasure.js";
+import { dataStoreRoomSubjectPrivacy as r } from "./subjectPrivacy.js";
+import { applicationRoomExternalWorkWithdrawal as i } from "./commandWithdrawal.js";
+import { Effect as a } from "effect";
+// src/subjectPrivacyBinding.ts
+function o(t) {
+	throw new e({ detail: t });
+}
+var s = (e, t) => Number.isSafeInteger(e) && e > 0 && e <= t ? e : o("Invalid SQL Rooms Subject binding budget"), c = (c) => {
+	if (!c || typeof c != "object" || Array.isArray(c) || typeof c.epochNow != "function" || typeof c.invalidateDirectory != "function" || !c.policy || ![
+		"withdraw",
+		"rooms",
+		"eraseAssociations",
+		"exportRoom"
+	].every((e) => typeof Reflect.get(c.policy, e) == "function") || !c.commands?.run || !c.commands.publish) return o("SQL Rooms Subject binding requires complete domain policy and command withdrawal");
+	let l = Object.getOwnPropertyDescriptor(c.policy, "afterFence");
+	if (l && (!l.enumerable || !("value" in l) || typeof l.value != "function") || !l && "afterFence" in c.policy) return o("SQL Rooms after-fence policy requires own actual function");
+	let u = l ? l.value.bind(c.policy) : void 0, d = c.epochNow, f = c.invalidateDirectory, p = Object.freeze({
+		withdraw: c.policy.withdraw.bind(c.policy),
+		rooms: c.policy.rooms.bind(c.policy),
+		eraseAssociations: c.policy.eraseAssociations.bind(c.policy),
+		exportRoom: c.policy.exportRoom.bind(c.policy),
+		...u ? { afterFence: u } : {}
+	}), m = Object.entries(c.commands.run), h = Object.entries(c.commands.publish);
+	if ([...m, ...h].some(([, e]) => typeof e != "function")) return o("Invalid SQL Rooms command withdrawal handler");
+	let g = Object.freeze({
+		run: Object.freeze(Object.fromEntries(m)),
+		publish: Object.freeze(Object.fromEntries(h))
+	}), _ = t(c.snapshotBlobs), v = s(c.maxRooms ?? 256, 65536), y = s(c.maxSeats ?? 4096, 65536), b = s(c.maxCommands ?? 4096, 65536), x = s(c.maxCommandBytes ?? 1048576, 67108864), S = s(c.maxSnapshotBytes ?? 1048576, 67108864), C = s(c.maxExportBytes ?? 1048576, 67108864);
+	return async (t) => {
+		if (!t || t.signal?.aborted !== !1 || typeof t.store?.query != "function" || typeof t.store.transactional != "function" || typeof t.withdrawal?.withdraw != "function" || typeof t.pluginName != "string" || !t.pluginName.trim()) return o("SQL Rooms Subject binding requires the live API store and actual withdrawal endpoint");
+		let s = Object.getOwnPropertyDescriptor(t, "afterFence");
+		if (s && (!s.enumerable || !("value" in s) || typeof s.value != "function") || !s && "afterFence" in t) return o("SQL Rooms acquired after-fence callback requires own actual function");
+		let c = s ? s.value.bind(t) : void 0, l = Object.freeze({
+			...p,
+			...u || c ? { afterFence: (t) => {
+				let n = (n) => a.suspend(() => {
+					let r = n(t);
+					return a.isEffect(r) ? r.pipe(a.flatMap((t) => t === void 0 ? a.void : a.fail(new e({ detail: "After-fence privacy callback must confirm void" })))) : a.fail(new e({ detail: "After-fence privacy callback requires its actual Effect" }));
+				});
+				return (u ? n(u) : a.void).pipe(a.flatMap(() => c ? n(c) : a.void));
+			} } : {}
+		}), m = t.signal, h = t.store, w = i(h, g, {
+			maxCommands: b,
+			maxCommandBytes: x
+		}), T = n(h, {
+			epochNow: d,
+			owner: t.withdrawal,
+			external: w,
+			invalidateDirectory: f,
+			maxSeats: y,
+			maxCommands: b,
+			maxSnapshotBytes: S,
+			..._ === void 0 ? {} : { snapshotBlobs: _ }
+		}), E = r(h, {
+			epochNow: d,
+			policy: l,
+			erasure: T,
+			maxRooms: v,
+			maxSeats: y,
+			maxExportBytes: C
+		}), D = "open", O = 0, k = null, A = null, j = (t) => a.acquireUseRelease(a.try({
+			try: () => {
+				if (D !== "open" || m.aborted) throw Error("Subject binding is closing");
+				O++;
+			},
+			catch: () => new e({ detail: "Rooms Subject binding is unavailable or shutting down" })
+		}), () => t, () => a.sync(() => {
+			if (O--, O === 0) {
+				let e = k;
+				k = null, e?.();
+			}
+		}));
+		return Object.freeze({
+			service: Object.freeze({
+				erase: (e) => j(E.erase(e)),
+				export: (e) => j(E.export(e))
+			}),
+			release: () => A || (D = "closing", A = (O === 0 ? Promise.resolve() : new Promise((e) => {
+				k = e;
+			})).then(() => {
+				D = "closed";
+			}), A)
+		});
+	};
+};
+export { c as sqlRoomsSubjectPrivacyBinder };

package/dist/systemManifest.js

@@ -0,0 +1,181 @@
+// src/systemManifest.ts
+var e = Object.freeze({
+	slots: Object.freeze({
+		"lockstep.reconnectPolicy": {
+			defaultExport: "defaultRoomReconnectPolicy",
+			fixtureExport: "lockstepReconnectSlotFixture"
+		},
+		"lockstep.playerId": {
+			defaultExport: "firstFreeRoomLockstepPlayerId",
+			fixtureExport: "lockstepInitialPlayerSlotFixture"
+		},
+		"lockstep.start": {
+			defaultExport: "startFullRoomLockstepRoster",
+			fixtureExport: "lockstepInitialStartSlotFixture"
+		},
+		"lockstep.seed": {
+			defaultExport: "randomRoomLockstepSeed",
+			fixtureExport: "lockstepSeedSlotFixture"
+		},
+		"lockstep.inputPrediction": {
+			defaultExport: "repeatLastLockstepInput",
+			fixtureExport: "lockstepInputPredictionSlotFixture"
+		},
+		"lockstep.hash": {
+			defaultExport: "schemaSimulationHash",
+			fixtureExport: "lockstepHashSlotFixture"
+		},
+		"lockstep.stallPolicy": {
+			defaultExport: "defaultLockstepStallPolicy",
+			fixtureExport: "lockstepStallPolicySlotFixture"
+		},
+		"lockstep.onDesync": {
+			defaultExport: "defaultLockstepDesync",
+			fixtureExport: "lockstepDesyncSlotFixture"
+		},
+		"lockstep.refereeLag": {
+			defaultExport: "defaultLockstepRefereeLag",
+			fixtureExport: "lockstepRefereeLagSlotFixture"
+		},
+		selectHost: {
+			defaultExport: "leastLoadedRoomHostInRegion",
+			fixtureExport: "roomSelectHostSlotFixture"
+		},
+		"seatToken.sign": {
+			defaultExport: "signRoomSeat",
+			fixtureExport: "roomSeatSignSlotFixture"
+		},
+		"seatToken.verify": {
+			defaultExport: "verifiedRoomSeatClaims",
+			fixtureExport: "roomSeatVerifySlotFixture"
+		},
+		view: {
+			defaultExport: "defaultRoomView",
+			fixtureExport: "roomViewSlotFixture"
+		},
+		budgets: {
+			defaultExport: "defaultRoomBudgets",
+			fixtureExport: "roomBudgetsSlotFixture"
+		},
+		reconnectPolicy: {
+			defaultExport: "defaultRoomReconnectPolicy",
+			fixtureExport: "roomReconnectSlotFixture"
+		},
+		spectatorPolicy: {
+			defaultExport: "defaultRoomSpectatorPolicy",
+			fixtureExport: "roomSpectatorSlotFixture"
+		},
+		snapshotPolicy: {
+			defaultExport: "defaultRoomSnapshotPolicy",
+			fixtureExport: "roomSnapshotSlotFixture"
+		},
+		snapshotBudget: {
+			defaultExport: "defaultRoomSnapshotBudget",
+			fixtureExport: "roomSnapshotBudgetSlotFixture"
+		}
+	}),
+	ports: Object.freeze({
+		hostDrain: {
+			tagExport: "RoomHostDrainPort",
+			fakeLayerExport: "roomHostDrainFakeLayer",
+			fixtureExport: "roomHostDrainPortFixture"
+		},
+		lockstepTerminal: {
+			tagExport: "RoomLockstepTerminalPort",
+			fakeLayerExport: "roomLockstepTerminalFakeLayer",
+			fixtureExport: "roomLockstepTerminalPortFixture"
+		},
+		lockstepAdmission: {
+			tagExport: "RoomLockstepAdmissionPort",
+			fakeLayerExport: "roomLockstepAdmissionFakeLayer",
+			fixtureExport: "roomLockstepAdmissionPortFixture"
+		},
+		lockstepJournal: {
+			tagExport: "RoomLockstepJournalPort",
+			fakeLayerExport: "roomLockstepJournalFakeLayer",
+			fixtureExport: "roomLockstepJournalPortFixture"
+		},
+		worldClientControl: {
+			tagExport: "WorldClientControlPort",
+			fakeLayerExport: "worldClientControlFakeLayer",
+			fixtureExport: "worldClientControlPortFixture"
+		},
+		reserve: {
+			tagExport: "RoomReservePort",
+			fakeLayerExport: "roomReserveFakeLayer",
+			fixtureExport: "roomReservePortFixture"
+		},
+		subjectPrivacy: {
+			tagExport: "RoomSubjectPrivacyPort",
+			fakeLayerExport: "roomSubjectPrivacyFakeLayer",
+			fixtureExport: "roomSubjectPrivacyPortFixture"
+		},
+		checkpoint: {
+			tagExport: "RoomCheckpointPort",
+			fakeLayerExport: "roomCheckpointFakeLayer",
+			fixtureExport: "roomCheckpointPortFixture"
+		},
+		snapshotBlob: {
+			tagExport: "RoomSnapshotBlobPort",
+			fakeLayerExport: "roomSnapshotBlobFakeLayer",
+			fixtureExport: "roomSnapshotBlobPortFixture"
+		},
+		replay: {
+			tagExport: "RoomReplayPort",
+			fakeLayerExport: "roomReplayFakeLayer",
+			fixtureExport: "roomReplayPortFixture"
+		},
+		directory: {
+			tagExport: "RoomDirectoryPort",
+			fakeLayerExport: "roomDirectoryFakeLayer",
+			fixtureExport: "roomDirectoryPortFixture"
+		},
+		application: {
+			tagExport: "RoomAppCommandPort",
+			fakeLayerExport: "roomAppCommandFakeLayer",
+			fixtureExport: "roomAppCommandPortFixture"
+		},
+		recovery: {
+			tagExport: "RoomRecoveryPort",
+			fakeLayerExport: "roomRecoveryFakeLayer",
+			fixtureExport: "roomRecoveryPortFixture"
+		},
+		reaper: {
+			tagExport: "RoomReaperPort",
+			fakeLayerExport: "roomReaperFakeLayer",
+			fixtureExport: "roomReaperPortFixture"
+		},
+		adoption: {
+			tagExport: "RoomHostAdoptionPort",
+			fakeLayerExport: "roomHostAdoptionFakeLayer",
+			fixtureExport: "roomHostAdoptionPortFixture"
+		},
+		control: {
+			tagExport: "RoomHostControlPort",
+			fakeLayerExport: "roomHostControlFakeLayer",
+			fixtureExport: "roomHostControlPortFixture"
+		},
+		kick: {
+			tagExport: "RoomHostKickPort",
+			fakeLayerExport: "roomHostKickFakeLayer",
+			fixtureExport: "roomHostKickPortFixture"
+		},
+		ownerWithdrawal: {
+			tagExport: "RoomHostWithdrawalPort",
+			fakeLayerExport: "roomHostWithdrawalFakeLayer",
+			fixtureExport: "roomHostWithdrawalPortFixture"
+		},
+		externalWithdrawal: {
+			tagExport: "RoomExternalWorkWithdrawalPort",
+			fakeLayerExport: "roomExternalWorkWithdrawalFakeLayer",
+			fixtureExport: "roomExternalWorkWithdrawalPortFixture"
+		},
+		erasure: {
+			tagExport: "RoomErasurePort",
+			fakeLayerExport: "roomErasureFakeLayer",
+			fixtureExport: "roomErasurePortFixture"
+		}
+	}),
+	events: Object.freeze([])
+});
+export { e as roomsSystemContractManifest };