@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/rpcClient.js

@@ -0,0 +1,151 @@
+import { ProtocolError as e } from "./errors.js";
+import { worldTransitionRequest as t } from "./worldCommands.js";
+import { WorldClientRequestIdSchema as n } from "./worldClientSchemas.js";
+import { captureRoomTransportEndpoints as r } from "./transportEndpoints.js";
+import { captureWorldClientPendingInput as i } from "./worldClientPendingInput.js";
+import { RoomReservationSchema as a } from "./reservationSchemas.js";
+import { BASE_NAME as o, ReserveRoomInput as s, leaveDescriptor as c, listDescriptor as l } from "./rpc.js";
+import { worldClientReceipt as u, worldClientTicket as d } from "./worldClient.js";
+import { pluginTag as f } from "@voltro/protocol";
+import { Schema as p } from "effect";
+// src/rpcClient.ts
+var m = (t) => {
+	try {
+		let n = t && typeof t == "object" ? Object.getOwnPropertyDescriptor(t, "endpoints") : void 0;
+		if (n && (!("value" in n) || !n.enumerable) || !n && t && typeof t == "object" && "endpoints" in t) throw new e({ detail: "Room reservation endpoint data is malformed" });
+		let i = n?.value === void 0 ? void 0 : r(n.value), o = p.decodeUnknownSync(p.toType(a))(t), s = i ?? r({ ws: o.address });
+		if (s.ws !== r({ ws: o.address }).ws || s.wt === void 0 != (o.transport.length === 1)) throw new e({ detail: "Room reservation endpoints and transport capabilities differ" });
+		return Object.freeze({
+			...o,
+			address: s.ws,
+			endpoints: s,
+			token: Uint8Array.from(o.token)
+		});
+	} catch {
+		throw new e({ detail: "Room RPC returned a malformed reservation" });
+	}
+}, h = (t) => Object.freeze({
+	reserve: async (e, n) => {
+		let r = p.decodeUnknownSync(p.toType(s))(e);
+		return m(await t.call(f(o, "reserve"), r, { signal: n }));
+	},
+	resume: async (e, n) => m(await t.call(f(o, "resume"), { sessionId: e }, { signal: n })),
+	release: async (n, r, i) => {
+		let a = await t.call(f(o, "leave"), {
+			sessionId: n,
+			token: Uint8Array.from(r)
+		}, { signal: i });
+		try {
+			p.decodeUnknownSync(p.toType(c.output))(a);
+		} catch {
+			throw new e({ detail: "Room RPC returned a malformed withdrawal result" });
+		}
+	}
+}), g = (t) => {
+	let n = t && Object.getOwnPropertyDescriptor(t, "call");
+	if (!n || !("value" in n) || typeof n.value != "function") throw new e({ detail: "World join requires an own caller method" });
+	let r = t.call.bind(t);
+	return async (t, n) => {
+		let i = await r(f(o, "world.join"), { world: t }, { signal: n });
+		if (!i || typeof i.entityId != "string" || !i.entityId) throw new e({ detail: "World join returned a malformed result" });
+		return Object.freeze({
+			entityId: i.entityId,
+			reservation: m(i.reservation)
+		});
+	};
+}, _ = (t, n) => {
+	let r = t && Object.getOwnPropertyDescriptor(t, "call");
+	if (!r || !("value" in r) || typeof r.value != "function") throw new e({ detail: "World target reservation requires an own caller method" });
+	let i = t.call.bind(t), a = h({ call: i });
+	return Object.freeze({
+		reserve: async (t, r) => {
+			let a = d(t);
+			if (r.aborted) throw new e({ detail: "World target reservation was cancelled" });
+			let s = m(await i(f(o, n), { requestId: a.requestId }, { signal: r }));
+			if (s.roomId !== a.target.roomId) throw new e({ detail: "World target reservation Room changed" });
+			return s;
+		},
+		resume: a.resume,
+		...a.release === void 0 ? {} : { release: a.release }
+	});
+}, v = (e) => _(e, "world.reservation"), y = (e) => _(e, "world.follow"), b = async (t, n, r, i) => {
+	let a = p.decodeUnknownSync(p.toType(l.input))({
+		room: n,
+		...i === void 0 ? {} : { limit: i }
+	}), s = await t.call(f(o, "list"), a, { signal: r });
+	try {
+		return structuredClone(p.decodeUnknownSync(p.toType(l.output))(s));
+	} catch {
+		throw new e({ detail: "Room RPC returned a malformed public listing" });
+	}
+}, x = (t) => {
+	let n = t && Object.getOwnPropertyDescriptor(t, "call");
+	if (!n || !("value" in n) || typeof n.value != "function") throw new e({ detail: "World RPC needs an actual own caller method" });
+	let r = t.call.bind(t), i = Object.getOwnPropertyDescriptor(t, "subscribe");
+	if (i && (!("value" in i) || typeof i.value != "function")) throw new e({ detail: "World RPC needs an actual own subscription method" });
+	return {
+		request: async (t, n, i) => {
+			if (i.aborted) throw new e({ detail: "World RPC admission was cancelled" });
+			return r(f(o, `world.${t}`), n, { signal: i });
+		},
+		subscribe: i === void 0 ? void 0 : t.subscribe.bind(t)
+	};
+}, S = (t, n, r, i, a, o) => {
+	if (o.aborted) throw new e({ detail: "World RPC subscription admission was cancelled" });
+	let s = t(n, r, {
+		onValue: (e) => {
+			try {
+				a.onValue(i(e));
+			} catch (e) {
+				a.onError(e);
+			}
+		},
+		onError: (e) => {
+			a.onError(e);
+		}
+	}), c = s && Object.getOwnPropertyDescriptor(s, "unsubscribe");
+	if (!c || !("value" in c) || typeof c.value != "function") throw new e({ detail: "World live receipt requires actual subscription withdrawal" });
+	return Object.freeze({ unsubscribe: c.value.bind(s) });
+}, C = (e) => {
+	let { request: t, subscribe: n } = x(e), r = (e) => e === null ? null : u(e);
+	return Object.freeze({
+		pending: async (e, n) => r(await t("pending", i(e), n)),
+		...n === void 0 ? {} : { subscribePending: (e, t, a) => S(n, f(o, "world.pending"), i(e), r, t, a) }
+	});
+}, w = (r) => {
+	let { request: i, subscribe: a } = x(r), s = (e) => p.decodeUnknownSync(n)(e);
+	return Object.freeze({
+		...a === void 0 ? {} : { subscribeReceipt: (t, n, r) => {
+			let i = s(t);
+			return S(a, f(o, "world.observe"), { requestId: i }, (t) => {
+				let n = u(t);
+				if (n.ticket.requestId !== i) throw new e({ detail: "World live receipt identity changed" });
+				return n;
+			}, n, r);
+		} },
+		prepare: async (n, r, a) => {
+			let o = t(r), c = s(n), l = d(await i("prepare", {
+				requestId: c,
+				intention: o
+			}, a));
+			if (l.requestId !== c) throw new e({ detail: "World RPC preparation identity changed" });
+			return l;
+		},
+		observe: async (t, n) => {
+			let r = s(t), a = u(await i("observe", { requestId: r }, n));
+			if (a.ticket.requestId !== r) throw new e({ detail: "World RPC observation identity changed" });
+			return a;
+		},
+		commit: async (t, n) => {
+			let r = d(t), a = u(await i("commit", { ticket: r }, n));
+			if (JSON.stringify(a.ticket) !== JSON.stringify(r)) throw new e({ detail: "World RPC commit ticket changed" });
+			return a;
+		},
+		cancel: async (t, n) => {
+			let r = s(t), a = u(await i("cancel", { requestId: r }, n));
+			if (a.ticket.requestId !== r) throw new e({ detail: "World RPC cancellation identity changed" });
+			return a;
+		}
+	});
+};
+export { b as listRooms, h as roomRpcReservations, w as worldRpcControls, y as worldRpcFollowerReservations, g as worldRpcJoin, C as worldRpcPending, v as worldRpcReservations };

package/dist/rpcRoutes.js

@@ -0,0 +1,27 @@
+import { leaveDescriptor as e, listDescriptor as t, reserveDescriptor as n, resumeDescriptor as r } from "./rpc.js";
+// src/rpcRoutes.ts
+var i = (i) => [
+	{
+		...n,
+		execute: (e, t) => i.reserve(e, t.request.subject)
+	},
+	{
+		...r,
+		execute: (e, t) => i.resume(e.sessionId, t.request.subject)
+	},
+	{
+		...e,
+		execute: (e, t) => {
+			let n = e;
+			return i.leave(n.sessionId, n.token, t.request.subject);
+		}
+	},
+	{
+		...t,
+		execute: (e, t) => {
+			let n = e;
+			return i.list(n.room, t.request.subject, n.limit);
+		}
+	}
+];
+export { i as roomsRpcRoutes };