@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/controlCarrier.js

@@ -0,0 +1,374 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomGeometryReloadRequestSchema as t, RoomGeometryRollbackRequestSchema as n } from "./geometryAdminSchemas.js";
+import { WorldTransitionRequestSchema as r } from "./worldCommands.js";
+import { RoomReservationSchema as i, RoomTransportEndpointsSchema as a } from "./reservationSchemas.js";
+import { ReserveRoomInput as o, RoomRpcError as s } from "./rpc.js";
+import { canonicalRoomJson as c } from "./checkpointJson.js";
+import { assertRoomSeatSecrets as l } from "./seats.js";
+import { RoomKickReasonSchema as u } from "./moderation.js";
+import { RoomHostWithdrawalInputSchema as d } from "./ownershipWithdrawal.js";
+import { SubjectIdentity as f, subjectIdentity as p } from "@voltro/protocol";
+import { Schema as m } from "effect";
+import { signSession as h, verifySessionKeyed as g } from "@voltro/protocol/session";
+// src/controlCarrier.ts
+var _ = m.NonEmptyString.pipe(m.check(m.isMaxLength(191))), v = m.Record(m.String, m.Union([
+	m.String,
+	m.Number,
+	m.Boolean,
+	m.Null
+])), y = m.String.pipe(m.check(m.isPattern(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/))), b = m.Int.pipe(m.check(m.isGreaterThanOrEqualTo(0))), x = m.Struct({
+	hostId: _,
+	instanceId: _,
+	startedAt: b
+}), S = {
+	mount: _,
+	clientId: y,
+	requestId: y,
+	target: x,
+	issuedAt: b,
+	expiresAt: b
+}, C = m.Int.pipe(m.check(m.isGreaterThan(0))), w = m.Struct({
+	tenantId: _,
+	roomId: _,
+	requestId: m.NonEmptyString.pipe(m.check(m.isMaxLength(384)))
+}), T = m.Int.pipe(m.check(m.isBetween({
+	minimum: 1,
+	maximum: 16777216
+}))), E = m.Struct({
+	tenantId: _,
+	roomId: _,
+	epoch: C,
+	origin: w,
+	action: m.Literals([
+		"snapshot",
+		"preview",
+		"ghost",
+		"detach",
+		"restore",
+		"commit",
+		"withdraw",
+		"retire"
+	]),
+	maxBytes: T,
+	receipt: m.optional(m.Struct({
+		requestId: m.NonEmptyString.pipe(m.check(m.isMaxLength(256))),
+		operation: m.Literals([
+			"enter",
+			"exit",
+			"ghost"
+		])
+	}))
+}), D = m.Struct({
+	transitionId: _,
+	revision: C,
+	entityId: _,
+	origin: w,
+	leaseToken: y
+}), O = m.Struct({
+	transitionId: _,
+	revision: C,
+	entityId: _,
+	operation: _,
+	leaseToken: y,
+	group: m.optional(m.Array(D).pipe(m.check(m.isMinLength(2)), m.check(m.isMaxLength(64))))
+}), k = m.Struct({
+	room: _,
+	creationKey: m.String.pipe(m.check(m.isPattern(/^[0-9a-f]{64}$/))),
+	generation: C,
+	worldCell: m.optional(m.Struct({
+		worldId: _,
+		zoneId: _,
+		at: m.Tuple([m.Number.pipe(m.check(m.isFinite())), m.Number.pipe(m.check(m.isFinite()))]),
+		layer: C
+	})),
+	worldInstance: m.optional(m.Struct({
+		tenantId: _,
+		worldId: _,
+		instance: _,
+		groupId: _
+	}))
+}), A = m.Struct({
+	room: _,
+	options: m.Unknown,
+	requestId: _
+}), j = m.Struct({
+	id: _,
+	kind: m.Literals(["user", "guest"])
+}), M = m.optional(j), N = m.Array(m.Struct({
+	origin: w,
+	expectedSubject: j
+})).pipe(m.check(m.isMinLength(1)), m.check(m.isMaxLength(64))), P = m.Union([
+	m.Struct({
+		action: m.Literal("prepare"),
+		origin: w,
+		intention: r,
+		expectedSubject: M
+	}),
+	m.Struct({
+		action: m.Literal("commit"),
+		origin: w,
+		expectedSubject: M
+	}),
+	m.Struct({
+		action: m.Literal("cancel"),
+		origin: w,
+		reason: m.NonEmptyString.pipe(m.check(m.isMaxLength(120))),
+		expectedSubject: M
+	}),
+	m.Struct({
+		action: m.Literals(["prepareTogether", "commitTogether"]),
+		origin: w,
+		members: N
+	}),
+	m.Struct({
+		action: m.Literal("cancelTogether"),
+		origin: w,
+		members: N,
+		reason: m.NonEmptyString.pipe(m.check(m.isMaxLength(120)))
+	})
+]), F = m.Struct({
+	roomId: _,
+	tenantId: _,
+	requestId: m.NonEmptyString.pipe(m.check(m.isMaxLength(448))),
+	command: m.Struct({
+		requestId: m.NonEmptyString.pipe(m.check(m.isMaxLength(448))),
+		kind: m.Literals(["run", "publish"]),
+		name: _,
+		payload: m.Unknown,
+		key: m.optional(m.NonEmptyString.pipe(m.check(m.isMaxLength(448))))
+	})
+}), I = m.Struct({
+	tenantId: _,
+	roomId: _,
+	epoch: C,
+	entityId: _,
+	maxBytes: T
+}), L = m.Struct({
+	roomId: _,
+	sessionId: _,
+	epoch: b
+}), R = m.Union([
+	m.Struct({
+		operation: m.Literal("worldAdmission"),
+		identity: f,
+		lookup: L
+	}),
+	m.Struct({
+		operation: m.Literal("reserve"),
+		identity: f,
+		input: o,
+		lockstepOptionsWire: m.optional(m.NonEmptyString.pipe(m.check(m.isPattern(/^[A-Za-z0-9_-]+$/)))),
+		attributes: m.optional(v)
+	}),
+	m.Struct({
+		operation: m.Literal("resume"),
+		identity: f,
+		sessionId: _,
+		attributes: m.optional(v)
+	}),
+	m.Struct({
+		operation: m.Literal("leave"),
+		identity: f,
+		sessionId: _,
+		token: m.String
+	}),
+	m.Struct({
+		operation: m.Literal("adopt"),
+		roomId: _,
+		tenantId: _,
+		priorEpoch: b
+	}),
+	m.Struct({
+		operation: m.Literal("withdraw"),
+		input: d
+	}),
+	m.Struct({
+		operation: m.Literal("geometryReload"),
+		identity: f,
+		roomId: _,
+		input: t
+	}),
+	m.Struct({
+		operation: m.Literal("geometryRollback"),
+		identity: f,
+		roomId: _,
+		input: n
+	}),
+	m.Struct({
+		operation: m.Literal("kick"),
+		roomId: _,
+		tenantId: _,
+		subjectId: _,
+		reason: u
+	}),
+	m.Struct({
+		operation: m.Literal("close"),
+		roomId: _,
+		tenantId: _,
+		reason: u
+	}),
+	m.Struct({
+		operation: m.Literal("worldStep"),
+		step: E,
+		authority: O
+	}),
+	m.Struct({
+		operation: m.Literal("worldCapture"),
+		capture: I
+	}),
+	m.Struct({
+		operation: m.Literal("worldPrepareRoom"),
+		identity: f,
+		prepare: k
+	}),
+	m.Struct({
+		operation: m.Literal("matchPrepareRoom"),
+		identity: f,
+		prepare: A
+	}),
+	m.Struct({
+		operation: m.Literal("worldTransition"),
+		forward: P
+	}),
+	m.Struct({
+		operation: m.Literal("appCommand"),
+		delivery: F
+	})
+]), z = m.Struct({
+	purpose: m.Literal("voltro.rooms.control.request.v3"),
+	...S,
+	body: R
+}), B = m.Struct({
+	roomId: _,
+	sessionId: _,
+	token: m.String,
+	address: m.NonEmptyString,
+	endpoints: m.optional(a),
+	transport: m.Union([m.Tuple([m.Literal("ws")]), m.Tuple([m.Literal("ws"), m.Literal("wt")])]),
+	expiresAt: m.Number.pipe(m.check(m.isFinite()), m.check(m.isGreaterThan(0)))
+}), V = m.Struct({
+	purpose: m.Literal("voltro.rooms.control.reply.v3"),
+	...S,
+	operation: m.Literals([
+		"reserve",
+		"resume",
+		"leave",
+		"adopt",
+		"withdraw",
+		"geometryReload",
+		"geometryRollback",
+		"kick",
+		"close",
+		"worldStep",
+		"worldCapture",
+		"worldAdmission",
+		"worldPrepareRoom",
+		"matchPrepareRoom",
+		"worldTransition",
+		"appCommand"
+	]),
+	result: m.Union([m.Struct({
+		ok: m.Literal(!0),
+		value: m.Union([
+			B,
+			m.Struct({ admission: m.Unknown }),
+			m.Struct({ ok: m.Literal(!0) }),
+			m.Struct({ kicked: b }),
+			m.Struct({ captured: m.Struct({
+				entity: m.Unknown,
+				data: m.Unknown
+			}) }),
+			m.Struct({ prepared: m.Struct({
+				roomId: _,
+				hostId: _,
+				epoch: C
+			}) }),
+			m.Null
+		])
+	}), m.Struct({
+		ok: m.Literal(!1),
+		error: s
+	})])
+});
+function H() {
+	throw new e({ detail: "Invalid authenticated Room control carrier" });
+}
+var U = (e, t) => e.hostId === t.hostId && e.instanceId === t.instanceId && e.startedAt === t.startedAt, W = (e) => {
+	if (e.type === "system" || e.type === "service" || !e.tenantId?.trim()) return H();
+	let { metadata: t, ...n } = p(e);
+	return m.decodeUnknownSync(f)(n, { onExcessProperty: "error" });
+}, G = (e, t) => c(e) === c(W(t)), K = (e) => !(e instanceof Uint8Array) || e.byteLength < 1 || e.byteLength > 8192 ? H() : Buffer.from(e).toString("base64url"), q = (e) => {
+	if (!e || e.length > 10923 || !/^[A-Za-z0-9_-]+$/.test(e)) return H();
+	let t = Buffer.from(e, "base64url");
+	return !t.length || t.length > 8192 || t.toString("base64url") !== e ? H() : Uint8Array.from(t);
+}, J = (e) => {
+	let t = m.decodeUnknownSync(m.toType(i))(e, { onExcessProperty: "error" });
+	return {
+		...t,
+		token: K(t.token)
+	};
+}, Y = (e) => m.decodeUnknownSync(m.toType(i))({
+	...e,
+	token: q(e.token)
+}), X = (e) => {
+	let t = structuredClone(e.projectControlSecrets), n = m.decodeUnknownSync(_)(e.mount);
+	l(t);
+	let r = e.epochNow, i = e.maxRequestMs ?? 2e3, a = e.maxSignedBytes ?? 262144;
+	if (typeof r != "function" || !Number.isSafeInteger(i) || i < 1 || i > 6e4 || !Number.isSafeInteger(a) || a < 1024 || a > 1048576) return H();
+	let o = () => {
+		let e = r();
+		return !Number.isSafeInteger(e) || e < 0 ? H() : e;
+	}, s = (e) => {
+		let t = o();
+		if (e.mount !== n || e.issuedAt > t || e.expiresAt <= t || e.expiresAt <= e.issuedAt || e.expiresAt - e.issuedAt > i) return H();
+	}, u = (e) => {
+		s(e);
+		let r = o(), i = e.purpose === "voltro.rooms.control.request.v3" ? m.encodeSync(z)(e) : m.encodeSync(V)(e), l = c(i);
+		if (Buffer.byteLength(l) > a) return H();
+		let u = h({
+			type: "serviceAccount",
+			id: e.requestId,
+			tenantId: n,
+			auditActorId: null,
+			metadata: JSON.parse(l)
+		}, t.current, {
+			now: () => r,
+			ttlSeconds: Math.ceil((e.expiresAt - Math.floor(r / 1e3) * 1e3) / 1e3)
+		});
+		return Buffer.byteLength(u) > a ? H() : u;
+	}, d = (e) => {
+		if (typeof e != "string" || !e.length || Buffer.byteLength(e) > a) return H();
+		let r = g(e, t, { now: o });
+		if (!r || r.subject.type !== "serviceAccount" || r.subject.tenantId !== n) return H();
+		let i = r.subject.metadata;
+		return !i || i.requestId !== r.subject.id ? H() : i;
+	}, f = `voltro.rooms.control.${Buffer.from(n).toString("hex")}`, p = (e) => {
+		if (e.body.operation === "reserve" && e.body.lockstepOptionsWire !== void 0) {
+			let t = e.body, n = t.lockstepOptionsWire;
+			if (t.input.mode === "joinById" || t.input.options !== null || Buffer.byteLength(n, "base64url") > a || Buffer.from(n, "base64url").toString("base64url") !== n) return H();
+		}
+		if (e.body.operation !== "adopt" && e.body.operation !== "withdraw" && e.body.operation !== "kick" && e.body.operation !== "close" && e.body.operation !== "worldStep" && e.body.operation !== "worldCapture" && e.body.operation !== "worldTransition" && e.body.operation !== "appCommand") {
+			if (Object.hasOwn(e.body.identity, "metadata")) return H();
+			W(e.body.identity);
+		}
+		return e;
+	};
+	return Object.freeze({
+		mount: n,
+		maxRequestMs: i,
+		now: o,
+		requestChannel: (e) => `${f}.host.${Buffer.from(c(m.decodeUnknownSync(x)(e))).toString("hex")}`,
+		replyChannel: (e) => `${f}.reply.${m.decodeUnknownSync(y)(e)}`,
+		signRequest: (e) => u(p(m.decodeUnknownSync(z)(e, { onExcessProperty: "error" }))),
+		readRequest: (e) => {
+			let t = p(m.decodeUnknownSync(z)(d(e), { onExcessProperty: "error" }));
+			return s(t), t;
+		},
+		signReply: (e) => u(m.decodeUnknownSync(m.toType(V))(e, { onExcessProperty: "error" })),
+		readReply: (e) => {
+			let t = m.decodeUnknownSync(V)(d(e), { onExcessProperty: "error" });
+			return s(t), t;
+		}
+	});
+};
+export { F as RoomControlAppCommandSchema, A as RoomControlMatchPrepareSchema, x as RoomControlTargetSchema, L as RoomControlWorldAdmissionSchema, O as RoomControlWorldAuthoritySchema, I as RoomControlWorldCaptureSchema, k as RoomControlWorldPrepareSchema, E as RoomControlWorldStepSchema, P as RoomControlWorldTransitionSchema, Y as decodeRoomControlReservation, q as decodeRoomControlToken, J as encodeRoomControlReservation, K as encodeRoomControlToken, X as makeRoomControlCarrier, W as roomControlIdentity, G as sameRoomControlIdentity, U as sameRoomControlTarget };

package/dist/controlRegistry.js

@@ -0,0 +1,78 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomsApiBindFailure as t } from "./apiBinding.js";
+import { RoomsHostBindFailure as n } from "./hostBinding.js";
+import { openRoomAppCommandServer as r } from "./roomAppCommandControl.js";
+import { openRoomControlClient as i, openRoomControlServer as a } from "./controlTransport.js";
+import { Effect as o, Result as s } from "effect";
+// src/controlRegistry.ts
+var c = () => new e({ detail: "Room control requires an explicit shared registry Pub/Sub declaration" }), l = (t, r, i, a) => {
+	if (typeof r != "string" || !/^(redis|nats):[A-Za-z][A-Za-z0-9_-]*$/.test(r) || typeof t?.validate != "function" || typeof t.pubsub != "function") return o.fail(c());
+	let l = t.validate.bind(t), u = t.pubsub.bind(t);
+	return o.uninterruptible(o.gen(function* () {
+		let t = yield* o.context(), d = async (e) => {
+			let n = await o.runPromiseWith(t)(o.result(e));
+			if (s.isFailure(n)) throw n.failure;
+			return n.success;
+		}, f = yield* l(r).pipe(o.mapError(() => c()));
+		if (f.reference !== r || f.tenantScoped) return yield* o.fail(c());
+		let p = yield* u(r).pipe(o.mapError(() => c())), m = p.close, h = null, g = null, _ = !1, v = null, y = () => {
+			h?.fence();
+		}, b = () => {
+			if (y(), _) return Promise.resolve();
+			if (v) return v;
+			let e = (async () => {
+				h &&= (await h.close(), null), g &&= (await g(), null), await d(m), _ = !0;
+			})().catch(() => {
+				throw a(b);
+			});
+			return v = e, e.then(() => {
+				v = null;
+			}, () => {
+				v = null;
+			}), e;
+		}, x = yield* o.result(o.tryPromise({
+			try: () => d(i(p)),
+			catch: (e) => e
+		}));
+		if (s.isFailure(x)) {
+			x.failure instanceof n && (g = x.failure.retryCleanup);
+			let t = yield* o.result(o.tryPromise({
+				try: b,
+				catch: () => a(b)
+			}));
+			return s.isFailure(t) ? yield* o.fail(t.failure) : yield* o.fail(x.failure instanceof e ? x.failure : c());
+		}
+		return h = x.success, Object.freeze({
+			endpoint: h,
+			fence: y,
+			close: b
+		});
+	}));
+}, u = (e, t) => {
+	try {
+		return t({
+			...e,
+			projectControlSecrets: structuredClone(e.projectControlSecrets)
+		});
+	} catch {
+		return o.fail(c());
+	}
+}, d = (e, n) => u(n, (n) => l(e, n.connection, (e) => i(e, n), (e) => new t(e))).pipe(o.map((e) => Object.freeze({
+	control: e.endpoint.control,
+	adoption: e.endpoint.adoption,
+	withdrawal: e.endpoint.withdrawal,
+	geometry: e.endpoint.geometry,
+	kick: e.endpoint.kick,
+	world: e.endpoint.world,
+	match: e.endpoint.match,
+	commands: e.endpoint.commands,
+	fence: e.fence,
+	close: e.close
+}))), f = (e, t, r) => u(r, (r) => l(e, r.connection, (e) => a(e, t, r), (e) => new n(e))).pipe(o.map((e) => Object.freeze({
+	fence: e.fence,
+	close: e.close
+}))), p = (e, n) => u(n, (n) => l(e, n.connection, (e) => r(e, n).pipe(o.map((e) => Object.freeze({
+	fence: () => void 0,
+	close: e.close
+}))), (e) => new t(e))).pipe(o.map((e) => Object.freeze({ close: e.close })));
+export { p as openRegistryRoomAppCommandServer, d as openRegistryRoomControlClient, f as openRegistryRoomControlServer };

package/dist/controlTarget.js

@@ -0,0 +1,44 @@
+import { ProtocolError as e } from "./errors.js";
+import { ROOM_HOSTS_TABLE as t } from "./identities.js";
+import { captureAdmittedRoomPoolTopology as n } from "./roomPoolTopology.js";
+import { RoomControlTargetSchema as r } from "./controlCarrier.js";
+import { eq as i } from "@voltro/database";
+import { Effect as a, Schema as o } from "effect";
+// src/controlTarget.ts
+var s = (s, c, l, u) => {
+	if (typeof l != "string" || !l.trim() || l.length > 191 || typeof c.list != "function") throw new e({ detail: "Room control requires an admitted region and borrowed membership" });
+	let d = s.hosts.bind(s), f = c.list.bind(c), p = u === void 0 ? void 0 : n(u.pools), m = u?.store.query.bind(u.store);
+	return (n) => a.gen(function* () {
+		let s = p && m ? yield* a.tryPromise({
+			try: async () => {
+				let r = await m({
+					table: t,
+					predicate: i("id", n),
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: [
+						"id",
+						"pool",
+						"region"
+					]
+				}), a = r[0];
+				if (r.length !== 1 || a?.id !== n || a.region !== l || typeof a.pool != "string" || !p.pools[a.pool]?.regions.includes(l)) throw new e({ detail: "Room control pool target is not admitted" });
+				return a.pool;
+			},
+			catch: () => new e({ detail: "Room control pool target lookup failed" })
+		}) : void 0, c = yield* d(l, s).pipe(a.mapError(() => new e({ detail: "Room control target lookup failed" })));
+		return yield* a.try({
+			try: () => {
+				let t = c.filter((e) => e.id === n && e.ready && e.region === l && (s === void 0 || e.pool === s)), i = t.length === 1 ? t[0] : void 0;
+				if (!i?.membership || f().filter((e) => e.instanceId === i.membership.instanceId && e.startedAt === i.membership.startedAt).length !== 1) throw new e({ detail: "Room control target is not currently admitted" });
+				return o.decodeUnknownSync(r)({
+					hostId: i.id,
+					...i.membership
+				});
+			},
+			catch: () => new e({ detail: "Room control target is not currently admitted" })
+		});
+	});
+};
+export { s as directoryRoomControlTargetResolver };