@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/worldClientControl.js

@@ -0,0 +1,140 @@
+import { ProtocolError as e, WorldTransitionCooldown as t } from "./errors.js";
+import { worldTransitionRequest as n } from "./worldCommands.js";
+import { worldClientReceipt as r, worldClientTicket as i } from "./worldClient.js";
+import { captureWorldCatalog as a, worldCellAt as o } from "./world.js";
+import { Subject as s } from "@voltro/protocol";
+import { Cause as c, Effect as l, Option as u, Schema as d } from "effect";
+// src/worldClientControl.ts
+function f() {
+	throw new e({ detail: "World client control admission refused" });
+}
+var p = (e, t = 191) => typeof e == "string" && e.length <= t && /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/.test(e) ? e : f(), m = (e, t) => {
+	e && typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype || f();
+	for (let n of Reflect.ownKeys(e)) {
+		let r = Object.getOwnPropertyDescriptor(e, n);
+		typeof n == "string" && t.includes(n) && r?.enumerable && "value" in r || f();
+	}
+}, h = (e, t) => {
+	let n = e && typeof e == "object" ? Object.getOwnPropertyDescriptor(e, t) : void 0;
+	return n && "value" in n && typeof n.value == "function" || f(), n.value.bind(e);
+}, g = (n) => l.suspend(() => {
+	let t = n();
+	return l.isEffect(t) ? t : l.fail(new e({ detail: "World client control requires actual Effects" }));
+}).pipe(l.catchCause((n) => {
+	let r = c.findErrorOption(n);
+	return l.fail(u.isSome(r) && r.value instanceof t ? r.value : new e({ detail: "World client control remains incomplete" }));
+})), _ = (t) => t.pipe(l.catchTag("WorldTransitionCooldown", () => l.fail(new e({ detail: "World client control remains incomplete" })))), v = (t) => {
+	m(t, [
+		"tenantId",
+		"worlds",
+		"executor",
+		"authorize",
+		"resolveOrigin",
+		"groupReady",
+		"groupCancel",
+		"seats",
+		"join"
+	]);
+	let c = p(t.tenantId), u = a(t.worlds);
+	u.length || f();
+	let v = t.seats === void 0 ? void 0 : h(t.seats, "reservation"), y = t.seats === void 0 ? void 0 : Object.getOwnPropertyDescriptor(t.seats, "follow");
+	t.seats && !y && "follow" in t.seats && f();
+	let b = y === void 0 ? void 0 : h(t.seats, "follow"), x = t.join === void 0 ? void 0 : h(t.join, "join"), S = t.groupReady === void 0 ? void 0 : h(t.groupReady, "commit"), C = t.groupCancel === void 0 ? void 0 : h(t.groupCancel, "cancel"), w = h(t.executor, "prepare"), T = h(t.executor, "commit"), E = h(t.executor, "cancel"), D = h(t.executor, "status"), O = h(t, "authorize"), k = h(t, "resolveOrigin"), A = (e, t, r = null) => {
+		let i = d.decodeUnknownSync(s)(structuredClone(t));
+		(i.type !== "user" || i.tenantId !== c) && f(), i.scopes && Object.freeze(i.scopes), Object.freeze(i);
+		let a = Object.freeze({
+			id: p(i.id),
+			kind: i.kind === "guest" ? "guest" : "user"
+		});
+		return Object.freeze({
+			subject: i,
+			expectedSubject: a,
+			input: Object.freeze({
+				requestId: p(e, 384),
+				intention: r === null ? null : n(r)
+			})
+		});
+	}, j = (t, n) => g(() => O(n, t.subject, t.input)).pipe(l.flatMap(() => g(() => k(t.subject, t.input))), l.flatMap((n) => l.try({
+		try: () => {
+			m(n, [
+				"tenantId",
+				"roomId",
+				"requestId"
+			]);
+			let e = Object.freeze({
+				tenantId: p(n.tenantId),
+				roomId: p(n.roomId),
+				requestId: p(n.requestId, 384)
+			});
+			return (e.tenantId !== c || e.requestId !== t.input.requestId) && f(), e;
+		},
+		catch: () => new e({ detail: "World client control has no matching trusted origin" })
+	}))), M = (e, t, n) => {
+		(e.origin.tenantId !== n.tenantId || e.origin.roomId !== n.roomId || e.origin.requestId !== n.requestId || e.subject?.id !== t.expectedSubject.id || e.subject?.kind !== t.expectedSubject.kind) && f();
+		let r = u.find((t) => t.name === e.target.worldId);
+		r || f();
+		let a = o(r, {
+			zone: e.target.zoneId,
+			at: e.target.at
+		});
+		return i({
+			requestId: n.requestId,
+			transitionId: e.id,
+			mode: e.mode,
+			target: {
+				worldId: r.name,
+				cellId: a.id,
+				layer: e.target.layer,
+				roomId: e.target.roomId,
+				epoch: e.target.epoch
+			}
+		});
+	}, N = (e, t, n) => {
+		let i = M(e, t, n), a = e.phase === "switching" ? "prepared" : e.phase;
+		return a !== "prepared" && a !== "committed" && a !== "settled" && a !== "rolledBack" && f(), r({
+			ticket: i,
+			phase: a,
+			entityRevision: a === "committed" || a === "settled" ? e.entityRevision : null
+		});
+	}, P = (t, n, r, i = null) => {
+		try {
+			let e = A(t, n, i);
+			return g(() => r(e));
+		} catch {
+			return l.fail(new e({ detail: "World client control requires a captured authenticated player intention" }));
+		}
+	};
+	return Object.freeze({
+		...x === void 0 ? {} : { join: (t, n) => {
+			try {
+				let e = d.decodeUnknownSync(s)(structuredClone(n));
+				return e.type === "user" && e.tenantId === c && u.some((e) => e.name === t) || f(), _(g(() => x(t, e)));
+			} catch {
+				return l.fail(new e({ detail: "World join requires a signed-in player of this tenant" }));
+			}
+		} },
+		...b === void 0 ? {} : { follow: (e, t) => _(P(e, t, (e) => j(e, "follow").pipe(l.flatMap((t) => g(() => D(t)).pipe(l.flatMap((n) => (M(n, e, t), n.phase === "settled" && n.groupProceed && n.groupCommand || f(), g(() => b(t, e.subject)).pipe(l.map((e) => (e.roomId !== n.target.roomId && f(), e)))))))))) },
+		...v === void 0 ? {} : { reservation: (e, t) => _(P(e, t, (e) => j(e, "reservation").pipe(l.flatMap((t) => g(() => D(t)).pipe(l.flatMap((n) => (M(n, e, t), [
+			"requested",
+			"reserving",
+			"failed",
+			"rolledBack"
+		].includes(n.phase) && f(), g(() => v(t, e.subject)).pipe(l.map((e) => (e.roomId !== n.target.roomId && f(), e)))))))))) },
+		prepare: (e, t, n) => P(e, n, (e) => j(e, "prepare").pipe(l.flatMap((t) => g(() => w(e.input.intention, t, e.expectedSubject)).pipe(l.map((n) => {
+			let r = N(n, e, t);
+			return r.phase === "rolledBack" && f(), r.ticket;
+		})))), t),
+		observe: (e, t) => _(P(e, t, (e) => j(e, "observe").pipe(l.flatMap((t) => g(() => D(t)).pipe(l.map((n) => N(n, e, t))))))),
+		commit: (t, n) => {
+			let r;
+			try {
+				r = i(t);
+			} catch {
+				return l.fail(new e({ detail: "World client commit ticket is invalid" }));
+			}
+			return _(P(r.requestId, n, (e) => j(e, "commit").pipe(l.flatMap((t) => g(() => D(t)).pipe(l.flatMap((n) => (JSON.stringify(M(n, e, t)) !== JSON.stringify(r) && f(), n.group ? (S || f(), g(() => S(t, e.subject)).pipe(l.map((n) => N(n, e, t)))) : g(() => T(t, e.expectedSubject)).pipe(l.map((n) => N(n, e, t))))))))));
+		},
+		cancel: (e, t) => _(P(e, t, (e) => j(e, "cancel").pipe(l.flatMap((t) => g(() => D(t)).pipe(l.flatMap((n) => (M(n, e, t), n.phase === "committed" || n.phase === "settled" ? l.succeed(N(n, e, t)) : n.group && C ? g(() => C(t, e.subject)).pipe(l.map((n) => N(n, e, t))) : g(() => E(t, "clientCancel", e.expectedSubject)).pipe(l.map((n) => N(n, e, t))))))))))
+	});
+};
+export { v as makeWorldClientControl };

package/dist/worldClientPendingInput.js

@@ -0,0 +1,15 @@
+import { ProtocolError as e } from "./errors.js";
+import { Schema as t } from "effect";
+// src/worldClientPendingInput.ts
+var n = t.String.pipe(t.check(t.isPattern(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/))), r = t.Struct({
+	entityId: n,
+	roomId: n
+}), i = (n) => {
+	if (!n || typeof n != "object" || Object.getPrototypeOf(n) !== Object.prototype || Reflect.ownKeys(n).length !== 2) throw new e({ detail: "Invalid World pending connection context" });
+	for (let t of ["entityId", "roomId"]) {
+		let r = Object.getOwnPropertyDescriptor(n, t);
+		if (!r?.enumerable || !("value" in r)) throw new e({ detail: "World pending connection context requires own data" });
+	}
+	return Object.freeze(t.decodeUnknownSync(r)(n));
+};
+export { r as WorldClientPendingInputSchema, i as captureWorldClientPendingInput };

package/dist/worldClientRpc.js

@@ -0,0 +1,132 @@
+import { ProtocolError as e, WorldTransitionCooldown as t } from "./errors.js";
+import { WorldTransitionRequestSchema as n } from "./worldCommands.js";
+import { WorldClientReceiptSchema as r, WorldClientRequestIdSchema as i, WorldClientTicketSchema as a } from "./worldClientSchemas.js";
+import { WorldClientPendingInputSchema as o } from "./worldClientPendingInput.js";
+import { RoomReservationSchema as s } from "./reservationSchemas.js";
+import { WORLD_TRANSITIONS_TABLE as c } from "./identities.js";
+import { defineAction as l, defineQuery as u } from "@voltro/protocol";
+import { Schema as d } from "effect";
+// src/worldClientRpc.ts
+var f = "Installed World client control requires the current authenticated user/guest, exact tenant/Subject ownership, real authorization and server-origin resolution; player payloads contain intentions only", p = l({
+	name: "rooms.world.prepare",
+	input: d.Struct({
+		requestId: i,
+		intention: n
+	}),
+	output: a,
+	error: d.Union([e, t]),
+	openAccess: f
+}), m = u({
+	name: "rooms.world.pending",
+	source: c,
+	input: o,
+	output: d.NullOr(r),
+	error: e,
+	openAccess: f
+}), h = u({
+	name: "rooms.world.observe",
+	source: c,
+	input: d.Struct({ requestId: i }),
+	output: r,
+	error: e,
+	openAccess: f
+}), g = l({
+	name: "rooms.world.commit",
+	input: d.Struct({ ticket: a }),
+	output: r,
+	error: e,
+	openAccess: f
+}), _ = l({
+	name: "rooms.world.cancel",
+	input: d.Struct({ requestId: i }),
+	output: r,
+	error: e,
+	openAccess: f
+}), v = l({
+	name: "rooms.world.reservation",
+	input: d.Struct({ requestId: i }),
+	output: s,
+	error: e,
+	openAccess: f
+}), y = l({
+	name: "rooms.world.follow",
+	input: d.Struct({ requestId: i }),
+	output: s,
+	error: e,
+	openAccess: f
+}), b = d.Struct({
+	entityId: d.NonEmptyString.pipe(d.check(d.isMaxLength(191))),
+	reservation: s
+}), x = l({
+	name: "rooms.world.join",
+	input: d.Struct({ world: d.NonEmptyString.pipe(d.check(d.isMaxLength(120))) }),
+	output: b,
+	error: e,
+	openAccess: f
+}), S = Object.freeze([
+	{
+		tag: "rooms.world.pending",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldPendingDescriptor"
+		}
+	},
+	{
+		tag: "rooms.world.prepare",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldPrepareDescriptor"
+		}
+	},
+	{
+		tag: "rooms.world.observe",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldObserveDescriptor"
+		}
+	},
+	{
+		tag: "rooms.world.commit",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldCommitDescriptor"
+		}
+	},
+	{
+		tag: "rooms.world.cancel",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldCancelDescriptor"
+		}
+	},
+	{
+		tag: "rooms.world.follow",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldFollowDescriptor"
+		}
+	},
+	{
+		tag: "rooms.world.reservation",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldReservationDescriptor"
+		}
+	},
+	{
+		tag: "rooms.world.join",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "worldJoinDescriptor"
+		}
+	}
+]);
+export { o as WorldClientPendingInputSchema, b as WorldJoinResultSchema, _ as worldCancelDescriptor, S as worldClientRpcImports, g as worldCommitDescriptor, y as worldFollowDescriptor, x as worldJoinDescriptor, h as worldObserveDescriptor, m as worldPendingDescriptor, p as worldPrepareDescriptor, v as worldReservationDescriptor };

package/dist/worldClientRpcRoutes.js

@@ -0,0 +1,42 @@
+import { ProtocolError as e } from "./errors.js";
+import { worldCancelDescriptor as t, worldCommitDescriptor as n, worldFollowDescriptor as r, worldJoinDescriptor as i, worldObserveDescriptor as a, worldPendingDescriptor as o, worldPrepareDescriptor as s, worldReservationDescriptor as c } from "./worldClientRpc.js";
+import { Effect as l } from "effect";
+// src/worldClientRpcRoutes.ts
+var u = (u) => [
+	{
+		...o,
+		execute: (t, n) => u.pending ? u.pending(t, n.request.subject) : l.fail(new e({ detail: "World pending transition discovery is not installed" }))
+	},
+	{
+		...s,
+		execute: (e, t) => {
+			let n = e;
+			return u.prepare(n.requestId, n.intention, t.request.subject);
+		}
+	},
+	{
+		...a,
+		execute: (e, t) => u.observe(e.requestId, t.request.subject)
+	},
+	{
+		...n,
+		execute: (e, t) => u.commit(e.ticket, t.request.subject)
+	},
+	{
+		...t,
+		execute: (e, t) => u.cancel(e.requestId, t.request.subject)
+	},
+	{
+		...r,
+		execute: (t, n) => u.follow ? u.follow(t.requestId, n.request.subject) : l.fail(new e({ detail: "World follower Seat control is not installed" }))
+	},
+	{
+		...c,
+		execute: (t, n) => u.reservation ? u.reservation(t.requestId, n.request.subject) : l.fail(new e({ detail: "World target Seat control is not installed" }))
+	},
+	{
+		...i,
+		execute: (t, n) => u.join ? u.join(t.world, n.request.subject) : l.fail(new e({ detail: "World join is not installed" }))
+	}
+];
+export { u as worldClientRpcRoutes };

package/dist/worldClientSchemas.js

@@ -0,0 +1,27 @@
+import { Schema as e } from "effect";
+// src/worldClientSchemas.ts
+var t = e.String.pipe(e.check(e.isPattern(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/))), n = e.Int.pipe(e.check(e.isBetween({
+	minimum: 1,
+	maximum: 2147483647
+}))), r = e.String.pipe(e.check(e.isPattern(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,383}$/))), i = e.Struct({
+	requestId: r,
+	transitionId: t,
+	mode: e.Literals(["seamless", "portal"]),
+	target: e.Struct({
+		worldId: t,
+		cellId: t,
+		layer: n,
+		roomId: t,
+		epoch: n
+	})
+}), a = e.Struct({
+	ticket: i,
+	phase: e.Literals([
+		"prepared",
+		"committed",
+		"settled",
+		"rolledBack"
+	]),
+	entityRevision: e.NullOr(n)
+}).pipe(e.check(e.makeFilter((e) => (e.phase === "committed" || e.phase === "settled") == (e.entityRevision !== null))));
+export { a as WorldClientReceiptSchema, r as WorldClientRequestIdSchema, i as WorldClientTicketSchema };

package/dist/worldCommands.js

@@ -0,0 +1,139 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { Context as n, Effect as r, Schema as i } from "effect";
+// src/worldCommands.ts
+var a = i.String.pipe(i.check(i.isPattern(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/))), o = i.Number.pipe(i.check(i.isFinite())), s = i.Tuple([o, o]), c = i.Number.pipe(i.check(i.isInt()), i.check(i.isBetween({
+	minimum: 1,
+	maximum: 2 ** 53 - 1
+}))), l = i.Union([
+	i.Struct({
+		kind: i.Literal("cell"),
+		zone: a,
+		at: s
+	}),
+	i.Struct({
+		kind: i.Literal("zone"),
+		zone: a,
+		at: s
+	}),
+	i.Struct({
+		kind: i.Literal("layer"),
+		layer: c
+	}),
+	i.Struct({
+		kind: i.Literal("world"),
+		world: a,
+		spawn: a
+	}),
+	i.Struct({
+		kind: i.Literal("instance"),
+		instance: a,
+		group: a
+	}),
+	i.Struct({ kind: i.Literal("return") })
+]), u = i.Struct({
+	mode: i.Literals([
+		"auto",
+		"seamless",
+		"portal"
+	]),
+	reason: a,
+	crossPool: i.Boolean,
+	returnTo: i.optional(i.Literal("here"))
+}), d = i.Struct({
+	entityId: a,
+	target: l,
+	options: u
+}), f = i.Struct({
+	partyId: a,
+	target: l,
+	options: u,
+	waitForAllMs: c,
+	onTimeout: i.Literals(["proceed", "cancel"])
+}), p = Object.freeze([
+	"requested",
+	"reserving",
+	"prepared",
+	"ghosting",
+	"persisting",
+	"detaching",
+	"switching",
+	"committed",
+	"settled",
+	"failed",
+	"rolledBack"
+]), m = i.Literals(p), h = class extends n.Service()("@voltro/WorldTransitionPort") {};
+function g() {
+	throw new t({
+		room: "world",
+		detail: "Invalid World transition intention"
+	});
+}
+var _ = (e, t = 0, n = { remaining: 256 }) => {
+	if ((t > 8 || --n.remaining < 0) && g(), typeof e != "object" || !e) (typeof e == "function" || typeof e == "symbol" || typeof e == "bigint") && g();
+	else if (Array.isArray(e)) {
+		(e.length > 64 || Reflect.ownKeys(e).length !== e.length + 1) && g();
+		for (let r = 0; r < e.length; r++) {
+			let i = Object.getOwnPropertyDescriptor(e, String(r));
+			i?.enumerable && "value" in i || g(), _(i.value, t + 1, n);
+		}
+	} else {
+		(Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length > 32) && g();
+		for (let r of Reflect.ownKeys(e)) {
+			let i = Object.getOwnPropertyDescriptor(e, r);
+			typeof r == "string" && i?.enumerable && "value" in i || g(), _(i.value, t + 1, n);
+		}
+	}
+}, v = i.decodeUnknownSync(d, { onExcessProperty: "error" }), y = i.decodeUnknownSync(f, { onExcessProperty: "error" }), b = (e) => {
+	_(e);
+	try {
+		let t = v(e);
+		return t.options.returnTo !== void 0 && t.target.kind !== "instance" && g(), structuredClone(t);
+	} catch {
+		return g();
+	}
+}, x = (e) => {
+	_(e);
+	try {
+		let t = y(e);
+		return (t.target.kind === "instance" && t.target.group !== t.partyId || t.options.returnTo !== void 0 && t.target.kind !== "instance") && g(), structuredClone(t);
+	} catch {
+		return g();
+	}
+}, S = (e) => {
+	_(e);
+	try {
+		let t = i.decodeUnknownSync(i.Struct({
+			transition: a,
+			transitionGroup: a
+		}), { onExcessProperty: "error" })(e);
+		return t.transition === t.transitionGroup && g(), Object.freeze(t);
+	} catch {
+		return g();
+	}
+}, C = (e, t, n) => e.run(S(t).transition, b(n)), w = (e, t, n) => e.run(S(t).transitionGroup, x(n)), T = (e, t) => (t && typeof t.transition == "function" && typeof t.transitionGroup == "function" && typeof t.recover == "function" && typeof t.status == "function" || g(), E(e, t)), E = (t, n) => {
+	let o = S(t);
+	n && typeof n.transition == "function" && typeof n.transitionGroup == "function" || g();
+	let s = n.transition.bind(n), c = n.transitionGroup.bind(n), l = (e) => {
+		_(e);
+		try {
+			return Object.freeze(i.decodeUnknownSync(i.Struct({
+				roomId: a,
+				tenantId: a,
+				requestId: i.String.pipe(i.check(i.isPattern(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,383}$/)))
+			}), { onExcessProperty: "error" })(e));
+		} catch {
+			return g();
+		}
+	}, u = (t) => r.suspend(() => {
+		let n = t();
+		return r.isEffect(n) ? n : r.fail(new e({ detail: "World transition provider must return an Effect" }));
+	}).pipe(r.catchCause(() => r.fail(new e({ detail: "World transition command remains incomplete" }))));
+	return Object.freeze({
+		run: Object.freeze({
+			[o.transition]: (e, t) => u(() => s(b(e), l(t))),
+			[o.transitionGroup]: (e, t) => u(() => c(x(e), l(t)))
+		}),
+		publish: Object.freeze({})
+	});
+};
+export { f as WorldGroupTransitionRequestSchema, m as WorldTransitionPhaseSchema, h as WorldTransitionPort, d as WorldTransitionRequestSchema, l as WorldTransitionTargetSchema, E as bindWorldTransitionCommandHandlers, w as stageWorldGroupTransition, C as stageWorldTransition, x as worldGroupTransitionRequest, T as worldTransitionCommandBindings, p as worldTransitionPhases, b as worldTransitionRequest };

package/dist/worldData.js

@@ -0,0 +1,41 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+// src/worldData.ts
+function n(e) {
+	throw new t({ detail: e });
+}
+var r = (t, r) => {
+	(!Number.isSafeInteger(r) || r < 1 || r > 2147483647) && n("Invalid World JSON byte budget");
+	let i = /* @__PURE__ */ new Set(), a = { nodes: 4096 }, o = (t, r) => {
+		if (--a.nodes < 0 || r > 16) throw new e({
+			budget: "worldEntityJson",
+			limit: r > 16 ? 16 : 4096
+		});
+		if (t === null || typeof t == "boolean" || typeof t == "string" || typeof t == "number" && Number.isFinite(t)) return t;
+		(typeof t != "object" || !t || i.has(t)) && n("World entity payload must be acyclic plain JSON"), i.add(t);
+		let s;
+		if (Array.isArray(t)) {
+			(Object.getPrototypeOf(t) !== Array.prototype || Reflect.ownKeys(t).length !== t.length + 1) && n("World entity arrays require own elements");
+			let e = [];
+			for (let i = 0; i < t.length; i++) {
+				let a = Object.getOwnPropertyDescriptor(t, String(i));
+				a?.enumerable && "value" in a || n("World entity arrays require own elements"), e.push(o(a.value, r + 1));
+			}
+			s = Object.freeze(e);
+		} else {
+			Object.getPrototypeOf(t) !== Object.prototype && n("World entity payload requires plain objects");
+			let e = [];
+			for (let i of Reflect.ownKeys(t)) {
+				let a = Object.getOwnPropertyDescriptor(t, i);
+				typeof i == "string" && a?.enumerable && "value" in a || n("Invalid World entity JSON field"), e.push([i, o(a.value, r + 1)]);
+			}
+			s = Object.freeze(Object.fromEntries(e));
+		}
+		return i.delete(t), s;
+	}, s = o(t, 0);
+	if (new TextEncoder().encode(JSON.stringify(s)).byteLength > r) throw new e({
+		budget: "worldEntityBytes",
+		limit: r
+	});
+	return s;
+};
+export { r as captureWorldData };