@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/index.js

@@ -0,0 +1,231 @@
+import { worldInstanceTables as e } from "./worldInstanceState.js";
+import { ProtocolError as t } from "./errors.js";
+import { geometryAdminRpcImports as n } from "./geometryAdminRpc.js";
+import { geometryAdminRpcRoutes as r } from "./geometryAdminRpcRoutes.js";
+import { geometryJournalArchivesTable as ee } from "./geometryJournalArchiveTable.js";
+import { worldClientRpcImports as te } from "./worldClientRpc.js";
+import { geometryReadRpcImports as i } from "./geometryReadRpc.js";
+import { geometryAssetRpcImports as ne } from "./geometryAssetRpc.js";
+import { BASE_NAME as a, roomsRpcClientImports as re } from "./rpc.js";
+import { captureWorldCatalog as ie } from "./world.js";
+import { geometryAssetRpcRoutes as ae } from "./geometryAssetRpcRoutes.js";
+import { geometryMigrationsTable as oe } from "./geometryMigrationJournal.js";
+import { geometryReadRpcRoutes as se } from "./geometryReadRpcRoutes.js";
+import { roomsGeometryHttpRoute as o } from "./geometryHttpRoutes.js";
+import { roomsSystemContractManifest as s } from "./systemManifest.js";
+import { RoomHostDrainPort as c } from "./hostDrainPorts.js";
+import { RoomAppCommandPort as l, RoomCheckpointPort as u, RoomDirectoryPort as d, RoomErasurePort as f, RoomExternalWorkWithdrawalPort as p, RoomHostAdoptionPort as m, RoomHostControlPort as h, RoomHostKickPort as g, RoomHostWithdrawalPort as _, RoomReaperPort as v, RoomRecoveryPort as y, RoomReservePort as b, RoomSnapshotBlobPort as x, RoomSubjectPrivacyPort as S, WorldClientControlPort as C } from "./ports.js";
+import { roomSnapshotBlobLayer as w, storageRoomSnapshotBlobs as T } from "./snapshotBlob.js";
+import { captureRoomSnapshotEffectRunner as E } from "./snapshotBlobIndex.js";
+import { cleanupRoomCheckpointBlobs as D } from "./snapshotBlobCleanup.js";
+import { cleanupRoomSnapshotUploads as O } from "./snapshotUploads.js";
+import { eraseRoomSnapshots as k } from "./snapshotErasure.js";
+import { dataStoreRoomErasure as A, roomErasureLayer as j } from "./roomErasure.js";
+import { dataStoreRoomSubjectPrivacy as M, readRoomSubjectPrivacyJournal as N, roomSubjectPrivacyLayer as ce } from "./subjectPrivacy.js";
+import { resolveRoomSeatTokenStrategies as le, signRoomSeat as ue, verifiedRoomSeatClaims as de } from "./seats.js";
+import { confirmRoomSessionAdmission as fe } from "./sessionAdmission.js";
+import { geometryPersistenceTables as pe } from "./geometryPersistence.js";
+import { GeometryVersionMigrationPort as me } from "./geometryMigrations.js";
+import { roomsGeometryInspectEndpoint as P } from "./geometryInspectEndpoint.js";
+import { validateRoomSchemaHistory as F } from "./schemaHistory.js";
+import { RoomCatalog as I, loadRoomCatalog as L } from "./catalog.js";
+import { GeometryStaticReadGrantPort as R } from "./geometryReadPorts.js";
+import { GeometryManifestPort as z, geometryManifestLayer as he } from "./geometryManifestPorts.js";
+import { captureGeometryStreamManifest as ge } from "./geometryManifestData.js";
+import { captureRoomPoolTopology as _e } from "./roomPoolTopology.js";
+import { RoomKickInputSchema as ve, RoomKickReasonSchema as ye, roomModerationService as be } from "./moderation.js";
+import { RoomsApiBindFailure as xe, RoomsApiOwner as B } from "./apiBinding.js";
+import { roomsRpcRoutes as Se } from "./rpcRoutes.js";
+import { worldClientRpcRoutes as Ce } from "./worldClientRpcRoutes.js";
+import { roomCheckpointsTable as V, roomCommandsTable as H, roomCreationsTable as U, roomHostsTable as W, roomLockstepTicksTable as G, roomSeatsTable as K, roomSnapshotSegmentsTable as q, roomSubjectPrivacyTable as J, roomsTable as Y } from "./tables.js";
+import { roomsInspectEndpoints as we } from "./inspect.js";
+import { worldCellsPrivacyScope as X, worldCellsTable as Te } from "./worldCells.js";
+import { roomsWorldInspectEndpoint as Ee } from "./worldInspectEndpoint.js";
+import { worldEntityTables as De, worldTransitionTables as Oe } from "./worldEntities.js";
+import { captureRoomSidecarHostSelection as ke } from "./sidecarSelection.js";
+import { dataStoreRoomCheckpoints as Ae, roomCheckpointLayer as je } from "./checkpointStore.js";
+import { dataStoreRoomHostDrain as Me } from "./hostDrain.js";
+import { defaultRoomSnapshotBudget as Ne } from "./snapshotBudget.js";
+import { RoomReplayRecording as Pe } from "./replayRecording.js";
+import { RoomSpectatorProducer as Fe } from "./spectatorProducer.js";
+import { matchRoomCreationKey as Ie } from "./matchRooms.js";
+import { applicationRoomCommands as Le, roomCommandEpoch as Re } from "./commandDelivery.js";
+import { leastLoadedRoomHostInRegion as ze } from "./hostSelection.js";
+import { dataStoreRoomDirectory as Be, roomDirectoryLayer as Ve } from "./directory.js";
+import { dataStoreRoomReservations as He } from "./reservations.js";
+import { roomProcessCpuSampler as Ue } from "./hostDriver.js";
+import { controllerRoomHostControlService as We } from "./reservePort.js";
+import { RoomHostLane as Ge, RoomHostLaneStartFailure as Ke, RoomHostListenerBindFailure as qe } from "./hostLane.js";
+import { runtimeRoomHostListener as Je } from "./hostListener.js";
+import { dataStoreRoomApiReservations as Ye, roomApiReservationLayer as Xe, timedRoomAdmission as Ze } from "./apiReservations.js";
+import { RoomsHostDrainDeadline as Qe } from "./hostShutdown.js";
+import { RoomsHostBindFailure as $e, RoomsHostOwner as et, RoomsHostStartFailure as tt, RoomsHostStopFailure as nt } from "./hostBinding.js";
+import { controllerRoomHostWithdrawalLayer as rt, controllerRoomHostWithdrawalService as it, routedRoomHostWithdrawalService as at } from "./withdrawalPort.js";
+import { makeWorldTransitionResolver as ot } from "./worldTransitionResolver.js";
+import { openRoomControlClient as st, openRoomControlServer as ct } from "./controlTransport.js";
+import { openRegistryRoomControlClient as lt, openRegistryRoomControlServer as ut } from "./controlRegistry.js";
+import { directoryRoomControlTargetResolver as dt } from "./controlTarget.js";
+import { dataStoreRoomRecovery as ft, roomRecoveryLayer as pt } from "./recovery.js";
+import { dataStoreRoomReaper as mt, roomReaperLayer as ht } from "./reaper.js";
+import { registryRoomsApiBinder as gt } from "./apiRegistryBinding.js";
+import { applicationRoomExternalWorkWithdrawal as _t, roomExternalWorkWithdrawalLayer as vt } from "./commandWithdrawal.js";
+import { sqlRoomsSubjectPrivacyBinder as yt } from "./subjectPrivacyBinding.js";
+import { defaultRoomsHostAcquire as bt, registryRoomsHostBinder as xt } from "./hostRegistryBinding.js";
+import { dataStoreGeometryManifest as St } from "./geometryManifest.js";
+import { sqlRoomsGeometry as Ct } from "./geometryInstall.js";
+import { bindRoomDirectoryProjection as wt, makeRoomDirectoryProjection as Tt } from "./directoryProjection.js";
+import { roomControlSubjectResolver as Et, roomSeatSubjectIdentity as Dt, roomSeatSubjectResolver as Ot } from "./seatSubject.js";
+import { roomReaperWorkflowExecutor as Z, runRoomReaperWorkflow as kt } from "./reaperWorkflow.js";
+import { developmentRoomsBinding as At, trustedRoomSeatSubject as jt } from "./developmentBinding.js";
+import { roomsMatchRooms as Mt } from "./matchRoomProvider.js";
+import { pluginInstanceName as Nt } from "@voltro/protocol";
+import { Effect as Q } from "effect";
+import { defineLicensedGamePlugin as Pt } from "@voltro/plugin-licensing/gate";
+import { fileURLToPath as $ } from "node:url";
+// src/index.ts
+var Ft = (s = {}) => {
+	let c = Object.getOwnPropertyDescriptor(s, "hostWebTransport");
+	if (c && !("value" in c) || !c && "hostWebTransport" in s) throw new t({ detail: "Native host selection requires own data" });
+	let l = !c || c.value === void 0 ? void 0 : ke(c.value), u = ie(s.worlds ?? []), d = s.worldState === void 0 ? "none" : s.worldState;
+	if (![
+		"none",
+		"entities",
+		"transitions"
+	].includes(d) || d !== "none" && u.length === 0) throw new t({ detail: "World state requires an explicit World catalogue" });
+	let f = s.worldClientControls ?? !1;
+	if (typeof f != "boolean" || f && d !== "transitions") throw new t({ detail: "World client controls require transition state" });
+	let p = Nt({
+		base: a,
+		alias: s.alias
+	}), m = Object.getOwnPropertyDescriptor(s, "geometryReadUrls");
+	if (m && (!m.enumerable || !("value" in m)) || !m && "geometryReadUrls" in s) throw new t({ detail: "Geometry read URL configuration requires own data" });
+	let h = m?.value ?? !1;
+	if (typeof h != "boolean" || h && !u.some((e) => e.geometry)) throw new t({ detail: "Geometry read URL routes require an actual geometry World" });
+	let g = Object.getOwnPropertyDescriptor(s, "geometryMigrations");
+	if (g && (!g.enumerable || !("value" in g)) || !g && "geometryMigrations" in s) throw new t({ detail: "Geometry migrations configuration requires own data" });
+	let _ = g?.value ?? !1;
+	if (typeof _ != "boolean" || _ && !u.some((e) => e.geometry)) throw new t({ detail: "Geometry migrations require an actual geometry World" });
+	let v = Object.getOwnPropertyDescriptor(s, "geometryAssetUrls");
+	if (v && (!v.enumerable || !("value" in v)) || !v && "geometryAssetUrls" in s) throw new t({ detail: "Geometry asset configuration requires own data" });
+	let y = v?.value ?? !1;
+	if (typeof y != "boolean" || y && !u.some((e) => e.geometry)) throw new t({ detail: "Geometry asset action requires an actual geometry World" });
+	let b = Object.getOwnPropertyDescriptor(s, "geometryJournalArchives");
+	if (b && (!b.enumerable || !("value" in b)) || !b && "geometryJournalArchives" in s) throw new t({ detail: "Geometry archive configuration requires own data" });
+	let x = b?.value ?? !1;
+	if (typeof x != "boolean" || x && !u.some((e) => e.geometry)) throw new t({ detail: "Geometry journal archives require an actual geometry World" });
+	let S = Object.getOwnPropertyDescriptor(s, "geometryJournalRetention");
+	if (S && (!S.enumerable || !("value" in S)) || !S && "geometryJournalRetention" in s) throw new t({ detail: "Geometry retention configuration requires own data" });
+	let C = S?.value ?? !1;
+	if (typeof C != "boolean" || C && !x) throw new t({ detail: "Geometry retention requires the actual archive module" });
+	let w = Object.getOwnPropertyDescriptor(s, "geometryAdminControls");
+	if (w && (!w.enumerable || !("value" in w)) || !w && "geometryAdminControls" in s) throw new t({ detail: "Geometry administration configuration requires own data" });
+	let T = w?.value ?? !1;
+	if (typeof T != "boolean" || T && !u.some((e) => e.geometry)) throw new t({ detail: "Geometry administration requires an actual geometry World" });
+	let E = new B(p, s.bindApi, u, d, f, h, _, y, x, C, T), D = s.reaperSources ?? $(new URL("./reaper-app", "" + import.meta.url)), O = Object.getOwnPropertyDescriptor(s, "geometryHttp");
+	if (O && (!O.enumerable || !("value" in O)) || !O && "geometryHttp" in s) throw new t({ detail: "Geometry HTTP binding requires own data" });
+	let k = O ? [o(u, E.geometry, O.value)] : [], A = [
+		U,
+		W,
+		Y,
+		K,
+		V,
+		H,
+		q,
+		J,
+		G
+	];
+	u.length > 0 && A.push(Te), u.some((e) => e.instances.length > 0) && A.push(...e), u.some((e) => e.geometry !== void 0) && A.push(...pe), _ && A.push(oe), x && A.push(ee), d !== "none" && A.push(...d === "transitions" ? Oe : De);
+	let j = Pt({
+		name: p,
+		baseName: a,
+		description: "Room API control and coordinated subject data; simulation uses its own host lane.",
+		permissions: ["store:write", "inspect:read"],
+		needs: { hot: "local" },
+		sources: C ? {
+			reaper: D,
+			geometryRetention: $(new URL("./geometry-retention-app", "" + import.meta.url))
+		} : D,
+		inspectEndpoints: [
+			...we(E),
+			Ee(E, u, d),
+			P(E, u)
+		],
+		extendSchema: { tables: A },
+		...k.length ? { httpRoutes: k } : {},
+		routes: [
+			...Se(E.reservation),
+			...T ? r(E.geometryAdministration) : [],
+			...y ? ae(u, E.geometryAssetGrants) : [],
+			...h ? se(u, E.geometryReadGrants) : [],
+			...f ? Ce(E.worldClientControl) : []
+		],
+		rpcClientDescriptors: [
+			...re,
+			...T ? n : [],
+			...y ? ne : [],
+			...h ? i : [],
+			...f ? te : []
+		],
+		subjectPrivacy: {
+			tables: A.map((e) => e.tableName),
+			kinds: ["user", "guest"],
+			erasePhase: "prepare"
+		},
+		onErase: (e, t) => {
+			let n = E.privacy.erase({
+				requestId: t.requestId,
+				target: {
+					subjectId: e,
+					tenantId: t.tenantId,
+					kind: t.kind
+				}
+			});
+			return u.length === 0 ? n : X(e, t).pipe(Q.flatMap(() => n));
+		},
+		onExport: (e, t) => {
+			let n = E.privacy.export({
+				requestId: t.requestId,
+				target: {
+					subjectId: e,
+					tenantId: t.tenantId,
+					kind: t.kind
+				}
+			});
+			return u.length === 0 ? n : X(e, t).pipe(Q.flatMap(() => n));
+		},
+		bindDataStore: (e, t) => E.bind(e, t),
+		onDeactivate: () => Q.tryPromise({
+			try: () => E.close(),
+			catch: () => new t({ detail: "Rooms API cleanup remains incomplete" })
+		})
+	}), M = j.onActivate, N = M && ((e) => Q.suspend(() => {
+		let t = M(e);
+		return Q.isEffect(t) ? t : Q.tryPromise({
+			try: () => Promise.resolve(t),
+			catch: (e) => e
+		});
+	}).pipe(Q.onError(() => Q.ignore(Q.tryPromise(() => E.close())))));
+	return {
+		...j,
+		...N ? { onActivate: N } : {},
+		configureCatalog: (e) => E.configureCatalog(e),
+		configurePools: (e, t) => {
+			let n = new I(e.inventory(), { previousHistory: e.history }), r = _e(t, n.inventory().map((e) => e.descriptor.name));
+			return E.configurePools(r, n), r;
+		},
+		services: E.services,
+		moderation: E.moderation,
+		bindHost: s.bindHost,
+		hostWebTransport: l,
+		worlds: u,
+		worldState: d,
+		worldClientControls: f,
+		geometryReadUrls: h,
+		geometryMigrations: _,
+		geometryAssetUrls: y,
+		geometryJournalArchives: x,
+		geometryJournalRetention: C,
+		geometryAdminControls: T
+	};
+};
+export { z as GeometryManifestPort, R as GeometryStaticReadGrantPort, me as GeometryVersionMigrationPort, l as RoomAppCommandPort, I as RoomCatalog, u as RoomCheckpointPort, d as RoomDirectoryPort, f as RoomErasurePort, p as RoomExternalWorkWithdrawalPort, m as RoomHostAdoptionPort, h as RoomHostControlPort, c as RoomHostDrainPort, g as RoomHostKickPort, Ge as RoomHostLane, Ke as RoomHostLaneStartFailure, qe as RoomHostListenerBindFailure, _ as RoomHostWithdrawalPort, ve as RoomKickInputSchema, ye as RoomKickReasonSchema, v as RoomReaperPort, y as RoomRecoveryPort, Pe as RoomReplayRecording, b as RoomReservePort, x as RoomSnapshotBlobPort, Fe as RoomSpectatorProducer, S as RoomSubjectPrivacyPort, xe as RoomsApiBindFailure, B as RoomsApiOwner, $e as RoomsHostBindFailure, Qe as RoomsHostDrainDeadline, et as RoomsHostOwner, tt as RoomsHostStartFailure, nt as RoomsHostStopFailure, C as WorldClientControlPort, Le as applicationRoomCommands, _t as applicationRoomExternalWorkWithdrawal, wt as bindRoomDirectoryProjection, ge as captureGeometryStreamManifest, E as captureRoomSnapshotEffectRunner, D as cleanupRoomCheckpointBlobs, O as cleanupRoomSnapshotUploads, fe as confirmRoomSessionAdmission, We as controllerRoomHostControlService, rt as controllerRoomHostWithdrawalLayer, it as controllerRoomHostWithdrawalService, St as dataStoreGeometryManifest, Ye as dataStoreRoomApiReservations, Ae as dataStoreRoomCheckpoints, Be as dataStoreRoomDirectory, A as dataStoreRoomErasure, Me as dataStoreRoomHostDrain, mt as dataStoreRoomReaper, ft as dataStoreRoomRecovery, He as dataStoreRoomReservations, M as dataStoreRoomSubjectPrivacy, Ne as defaultRoomSnapshotBudget, bt as defaultRoomsHostAcquire, At as developmentRoomsBinding, dt as directoryRoomControlTargetResolver, k as eraseRoomSnapshots, he as geometryManifestLayer, ze as leastLoadedRoomHostInRegion, L as loadRoomCatalog, Tt as makeRoomDirectoryProjection, ot as makeWorldTransitionResolver, Ie as matchRoomCreationKey, lt as openRegistryRoomControlClient, ut as openRegistryRoomControlServer, st as openRoomControlClient, ct as openRoomControlServer, N as readRoomSubjectPrivacyJournal, gt as registryRoomsApiBinder, xt as registryRoomsHostBinder, le as resolveRoomSeatTokenStrategies, Xe as roomApiReservationLayer, je as roomCheckpointLayer, V as roomCheckpointsTable, Re as roomCommandEpoch, H as roomCommandsTable, Et as roomControlSubjectResolver, U as roomCreationsTable, Ve as roomDirectoryLayer, j as roomErasureLayer, vt as roomExternalWorkWithdrawalLayer, W as roomHostsTable, G as roomLockstepTicksTable, be as roomModerationService, Ue as roomProcessCpuSampler, ht as roomReaperLayer, Z as roomReaperWorkflowExecutor, pt as roomRecoveryLayer, Dt as roomSeatSubjectIdentity, Ot as roomSeatSubjectResolver, K as roomSeatsTable, w as roomSnapshotBlobLayer, q as roomSnapshotSegmentsTable, ce as roomSubjectPrivacyLayer, J as roomSubjectPrivacyTable, o as roomsGeometryHttpRoute, Mt as roomsMatchRooms, Ft as roomsPlugin, s as roomsSystemContractManifest, Y as roomsTable, at as routedRoomHostWithdrawalService, kt as runRoomReaperWorkflow, Je as runtimeRoomHostListener, ue as signRoomSeat, Ct as sqlRoomsGeometry, yt as sqlRoomsSubjectPrivacyBinder, T as storageRoomSnapshotBlobs, Ze as timedRoomAdmission, jt as trustedRoomSeatSubject, F as validateRoomSchemaHistory, de as verifiedRoomSeatClaims };

package/dist/inputReceipts.js

@@ -0,0 +1,62 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureWorldTargetSeatBinding as t } from "./worldSeatBinding.js";
+// src/inputReceipts.ts
+function n() {
+	throw new e({ detail: "Invalid bounded Room input receipt" });
+}
+var r = (e) => !!e && typeof e == "object" && !Array.isArray(e) && [Object.prototype, null].includes(Object.getPrototypeOf(e)), i = (e, t) => Reflect.ownKeys(e).length === t.length && t.every((t) => {
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	return !!n && "value" in n && n.enumerable === !0;
+}), a = (e, t = 0) => typeof e == "number" && Number.isSafeInteger(e) && e >= t, o = (e) => typeof e == "string" && e.length > 0 && e.length <= 191, s = (e) => {
+	if (!r(e)) return n();
+	let o = "worldTarget" in e, s = "discardedThrough" in e;
+	return !i(e, [
+		"lastAppliedSeq",
+		...o ? ["worldTarget"] : [],
+		...s ? ["discardedThrough"] : []
+	]) || !a(e.lastAppliedSeq, -1) || s && (!o || !a(e.discardedThrough)) ? n() : Object.freeze({
+		lastAppliedSeq: e.lastAppliedSeq,
+		...s ? { discardedThrough: e.discardedThrough } : {},
+		...o ? { worldTarget: t(e.worldTarget) } : {}
+	});
+}, c = (e) => {
+	if (e == null) return null;
+	if (!r(e)) return n();
+	let t = "discardedThrough" in e;
+	return !i(e, [
+		"lastAppliedSeq",
+		"checkpointEpoch",
+		"checkpointRevision",
+		"checkpointTick",
+		...t ? ["discardedThrough"] : []
+	]) || !a(e.lastAppliedSeq, t ? -1 : 0) || t && !a(e.discardedThrough) || !a(e.checkpointEpoch, 1) || !a(e.checkpointRevision, 1) || !a(e.checkpointTick) ? n() : Object.freeze({
+		lastAppliedSeq: e.lastAppliedSeq,
+		...t ? { discardedThrough: e.discardedThrough } : {},
+		checkpointEpoch: e.checkpointEpoch,
+		checkpointRevision: e.checkpointRevision,
+		checkpointTick: e.checkpointTick
+	});
+}, l = (e, t = 16384) => {
+	if (!Number.isSafeInteger(t) || t < 1 || t > 16384 || !Array.isArray(e) || e.length > t) return n();
+	let s = /* @__PURE__ */ new Set(), c = [];
+	for (let t = 0; t < e.length; t++) {
+		if (!Object.hasOwn(e, t)) return n();
+		let l = e[t];
+		if (!r(l)) return n();
+		let u = "discardedThrough" in l;
+		if (!i(l, [
+			"sessionId",
+			"subjectId",
+			"lastAppliedSeq",
+			...u ? ["discardedThrough"] : []
+		]) || !o(l.sessionId) || l.subjectId !== null && !o(l.subjectId) || !a(l.lastAppliedSeq, u ? -1 : 0) || u && !a(l.discardedThrough) || s.has(l.sessionId)) return n();
+		s.add(l.sessionId), c.push(Object.freeze({
+			sessionId: l.sessionId,
+			subjectId: l.subjectId,
+			lastAppliedSeq: l.lastAppliedSeq,
+			...u ? { discardedThrough: l.discardedThrough } : {}
+		}));
+	}
+	return Object.freeze(c.sort((e, t) => e.sessionId < t.sessionId ? -1 : +(e.sessionId > t.sessionId)));
+};
+export { s as captureRoomConsumedSeat, l as captureRoomInputReceipts, c as captureRoomSeatInputReceipt };

package/dist/inputRedundancy.js

@@ -0,0 +1,54 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+// src/inputRedundancy.ts
+var r = Object.freeze({
+	inputRedundancy: 3,
+	maxInputHistoryBytes: 262144
+}), i = class {
+	options;
+	entries = [];
+	bytes = 0;
+	lastSeq = null;
+	constructor(e = r) {
+		if (!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== 2 || ["inputRedundancy", "maxInputHistoryBytes"].some((t) => {
+			let n = Object.getOwnPropertyDescriptor(e, t);
+			return !n?.enumerable || !("value" in n);
+		}) || !Number.isSafeInteger(e.inputRedundancy) || e.inputRedundancy < 1 || e.inputRedundancy > 32 || !Number.isSafeInteger(e.maxInputHistoryBytes) || e.maxInputHistoryBytes < 1 || e.maxInputHistoryBytes > 16777216) throw new n({
+			room: "input-redundancy",
+			detail: "Input redundancy requires own bounded count and byte budgets"
+		});
+		this.options = Object.freeze({ ...e });
+	}
+	get bufferedBytes() {
+		return this.bytes;
+	}
+	get bufferedInputs() {
+		return this.entries.length;
+	}
+	offer(n, r, i) {
+		if (!Number.isSafeInteger(n) || n < 0 || !Number.isSafeInteger(r) || r < 0 || !(i instanceof Uint8Array) || this.lastSeq !== null && n !== this.lastSeq + 1) throw new t({ detail: "Redundant intentions require contiguous admitted sequence metadata" });
+		if (i.byteLength > this.options.maxInputHistoryBytes) throw new e({
+			budget: "maxInputHistoryBytes",
+			limit: this.options.maxInputHistoryBytes
+		});
+		for (; this.entries.length && (this.entries.length >= this.options.inputRedundancy || this.bytes + i.byteLength > this.options.maxInputHistoryBytes);) {
+			let e = this.entries.shift();
+			this.bytes -= e.payload.byteLength;
+		}
+		return this.entries.push(Object.freeze({
+			seq: n,
+			tickHint: r,
+			payload: i.slice()
+		})), this.bytes += i.byteLength, this.lastSeq = n, Object.freeze({
+			kind: "Input",
+			firstSeq: this.entries[0].seq,
+			inputs: Object.freeze(this.entries.map((e) => Object.freeze({
+				tickHint: e.tickHint,
+				payload: e.payload.slice()
+			})))
+		});
+	}
+	clear() {
+		this.entries.splice(0), this.bytes = 0, this.lastSeq = null;
+	}
+};
+export { i as RoomInputRedundancy, r as defaultRoomInputRedundancy };

package/dist/inspect.js

@@ -0,0 +1,237 @@
+import { roomHostTransportEndpoints as e } from "./transportEndpoints.js";
+import { ROOMS_TABLE as t, ROOM_HOSTS_TABLE as n, ROOM_SUBJECT_PRIVACY_TABLE as r } from "./identities.js";
+import { readRoomErasureJournal as i } from "./roomErasure.js";
+import { captureRoomSubjectPrivacyJournal as a } from "./subjectPrivacy.js";
+import { inspectRoomSnapshots as o } from "./snapshotInspection.js";
+import { and as s, eq as c, gt as l, or as u } from "@voltro/database";
+import { Effect as d, Result as f } from "effect";
+import { parseReplicaSelection as p } from "@voltro/protocol/inspect";
+// src/inspect.ts
+var m = 50, h = (e) => {
+	if (typeof e != "string" || !e.trim() || e.length > 191) throw Error("Invalid directory identity");
+	return e;
+}, g = (e) => {
+	if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0) throw Error("Invalid directory counter");
+	return e;
+}, _ = (e) => {
+	if (typeof e != "boolean") throw Error("Invalid directory flag");
+	return e;
+}, v = (e) => {
+	let t = e instanceof Date ? e : typeof e == "string" ? new Date(e) : null;
+	if (!t || !Number.isFinite(t.getTime())) throw Error("Invalid directory timestamp");
+	return t.toISOString();
+}, y = (e) => {
+	let t = e.state;
+	if (t !== "creating" && t !== "live" && t !== "disposed" && t !== "faulted" && t !== "orphaned" && t !== "hibernating" && t !== "hibernated") throw Error("Invalid directory state");
+	let n = g(e.maxClients), r = g(e.clients), a = g(e.epoch);
+	if (n < 1 || r > n || a < 1 || t === "hibernated" && (e.hostId !== null || r !== 0)) throw Error("Invalid directory capacity");
+	return {
+		cleanupPhase: i(e, h(e.id), h(e.tenantId))?.phase ?? "none",
+		id: h(e.id),
+		name: h(e.name),
+		hostId: t === "hibernated" ? null : h(e.hostId),
+		clients: r,
+		maxClients: n,
+		epoch: a,
+		state: t,
+		locked: _(e.locked),
+		private: _(e.private),
+		updatedAt: v(e.updatedAt)
+	};
+}, b = (t) => {
+	let n = e(t.publicAddress, t.webTransportAddress, t.webTransportCertificateHash), r = t.load;
+	if (!r || typeof r != "object" || Array.isArray(r)) throw Error("Invalid host load");
+	let i = Reflect.get(r, "cpu"), a = g(t.capacity);
+	if (typeof i != "number" || !Number.isFinite(i) || i < 0 || i > 1 || a < 1) throw Error("Invalid host load");
+	return {
+		id: h(t.id),
+		region: h(t.region),
+		capacity: a,
+		routingReady: _(t.ready),
+		advertisedTransports: n.wt === void 0 ? ["ws"] : ["ws", "wt"],
+		rooms: g(Reflect.get(r, "rooms")),
+		clients: g(Reflect.get(r, "clients")),
+		cpu: i,
+		lastHeartbeatAt: v(t.lastHeartbeatAt)
+	};
+}, x = (e) => {
+	let t = new URL(e.url, "http://inspect.local").searchParams;
+	p(t), t.delete("replica"), t.delete("replicas");
+	for (let e of t.keys()) if (e !== "tenantId" && e !== "after") throw Error("Unknown parameter");
+	if (t.getAll("tenantId").length !== 1 || t.getAll("after").length > 1) throw Error("Ambiguous parameter");
+	return {
+		tenantId: h(t.get("tenantId")),
+		after: t.has("after") ? h(t.get("after")) : null
+	};
+}, S = (e) => [
+	{
+		method: "GET",
+		path: "/status",
+		scope: "process",
+		description: "API control lifetime in the responding process",
+		handler: () => d.sync(() => ({
+			kind: "json",
+			data: e.status()
+		}))
+	},
+	{
+		method: "GET",
+		path: "/privacy",
+		scope: "shared-store",
+		description: "Bounded redacted Subject cleanup receipt observations from SQL",
+		handler: (t) => d.gen(function* () {
+			let n = yield* d.result(d.try({
+				try: () => x(t),
+				catch: () => "Invalid query"
+			}));
+			if (f.isFailure(n)) return {
+				kind: "json",
+				status: 400,
+				data: { error: "Rooms privacy inspection requires one tenantId and an optional after cursor" }
+			};
+			let { tenantId: i, after: o } = n.success, u = yield* d.result(e.inspect(async (e) => {
+				let t = await e.query({
+					table: r,
+					predicate: o === null ? c("tenantId", i) : s(c("tenantId", i), l("id", o)),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: 51,
+					skip: void 0,
+					projection: [
+						"id",
+						"tenantId",
+						"journal",
+						"createdAt",
+						"updatedAt"
+					]
+				});
+				if (t.length > 51 || new Set(t.map((e) => e.id)).size !== t.length || t.some((e, n) => e.tenantId !== i || o !== null && h(e.id) <= o || n > 0 && h(t[n - 1].id) >= h(e.id))) throw Error("Invalid privacy query scope/order");
+				let n = t.slice(0, m).map((e) => {
+					let t = a(e.journal, 65536);
+					return {
+						id: h(e.id),
+						phase: t.phase,
+						selectedRooms: t.roomIds.length,
+						createdAt: v(e.createdAt),
+						updatedAt: v(e.updatedAt)
+					};
+				});
+				return {
+					page: {
+						tenantId: i,
+						after: o,
+						nextAfter: t.length > m ? n.at(-1).id : null
+					},
+					receipts: n
+				};
+			}));
+			return f.isFailure(u) ? {
+				kind: "json",
+				status: 503,
+				data: { error: "Rooms privacy inspection is unavailable. Load it again." }
+			} : {
+				kind: "json",
+				data: u.success
+			};
+		})
+	},
+	{
+		method: "GET",
+		path: "/directory",
+		scope: "shared-store",
+		description: "Bounded tenant directory and referenced host observations from SQL",
+		handler: (r) => d.gen(function* () {
+			let i = yield* d.result(d.try({
+				try: () => x(r),
+				catch: () => "Invalid query"
+			}));
+			if (f.isFailure(i)) return {
+				kind: "json",
+				status: 400,
+				data: { error: "Rooms inspection requires one tenantId and an optional after cursor" }
+			};
+			let { tenantId: a, after: p } = i.success, g = yield* d.result(e.inspect(async (e) => {
+				let r = await e.query({
+					table: t,
+					predicate: p === null ? c("tenantId", a) : s(c("tenantId", a), l("id", p)),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: 51,
+					skip: void 0,
+					projection: [
+						"id",
+						"tenantId",
+						"name",
+						"hostId",
+						"clients",
+						"maxClients",
+						"epoch",
+						"state",
+						"locked",
+						"private",
+						"updatedAt",
+						"snapshotUploads",
+						"snapshotErasure",
+						"erasure"
+					]
+				});
+				if (r.length > 51 || r.some((e) => e.tenantId !== a)) throw Error("Invalid tenant query");
+				let i = r.slice(0, m), d = await o(e, i, a), f = i.map((e) => {
+					let t = y(e), n = d.get(h(e.id));
+					if ([
+						"snapshots-erased",
+						"data-erased",
+						"complete"
+					].includes(t.cleanupPhase) && n.erasurePhase !== "complete") throw Error("Room cleanup receipt contradicts snapshot observation");
+					return {
+						...t,
+						snapshot: n
+					};
+				}), g = [...new Set(f.map((e) => e.hostId).filter((e) => e !== null))].sort(), _ = g.length === 0 ? [] : (await e.query({
+					table: n,
+					predicate: u(...g.map((e) => c("id", e))),
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: g.length,
+					skip: void 0,
+					projection: [
+						"id",
+						"region",
+						"capacity",
+						"ready",
+						"load",
+						"lastHeartbeatAt",
+						"publicAddress",
+						"webTransportAddress",
+						"webTransportCertificateHash"
+					]
+				})).map(b);
+				if (_.some((e) => !g.includes(e.id)) || new Set(_.map((e) => e.id)).size !== _.length) throw Error("Invalid host query");
+				return {
+					page: {
+						tenantId: a,
+						after: p,
+						nextAfter: r.length > m ? f.at(-1).id : null
+					},
+					rooms: f,
+					hosts: _
+				};
+			}));
+			return f.isFailure(g) ? {
+				kind: "json",
+				status: 503,
+				data: { error: "Rooms directory inspection is unavailable. Read the API control status and try again." }
+			} : {
+				kind: "json",
+				data: g.success
+			};
+		})
+	}
+];
+export { S as roomsInspectEndpoints };