@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/worldServer.js

@@ -0,0 +1,48 @@
+import { WORLD_INSTANCES_TABLE as e, WORLD_INSTANCE_HISTORY_TABLE as t, WORLD_INSTANCE_SCOPES_TABLE as n, worldInstanceHistoryTable as r, worldInstanceScopesTable as i, worldInstanceTables as a, worldInstancesTable as o } from "./worldInstanceState.js";
+import { WORLD_TRANSITIONS_TABLE as s } from "./identities.js";
+import { makeWorldGhostNeighborhood as c } from "./worldGhostNeighborhood.js";
+import { WORLD_CELLS_TABLE as l, dataStoreWorldCells as u, worldCellsContribution as d, worldCellsTable as f } from "./worldCells.js";
+import { canAdvanceWorldTransition as p, nextWorldTransitionPhase as m, worldTransitionsTable as h } from "./worldTransitionState.js";
+import { captureWorldHandoffMetrics as g, makeWorldHandoffMetrics as _, worldHandoffDurationBuckets as v } from "./worldHandoffMetrics.js";
+import { worldGroupCommandRequestId as y } from "./worldGroupCommand.js";
+import { WORLD_ENTITIES_TABLE as b, WORLD_JOURNAL_TABLE as x, dataStoreWorldEntities as S, worldEntitiesContribution as C, worldEntitiesTable as w, worldEntityPersistenceCommandBindings as T, worldEntityTables as E, worldEntityTransferCommandBindings as D, worldJournalTable as O, worldTransitionTables as k } from "./worldEntities.js";
+import { makeWorldBoundaryCoordinator as A } from "./worldBoundaryCoordinator.js";
+import { captureWorldGhostWithdrawal as j, makeWorldGhostReceiver as M } from "./worldGhostReceiver.js";
+import { makeRoomWorldGhostReceiver as N } from "./worldGhostHost.js";
+import { makeWorldGhostPublisher as P } from "./worldGhostPublisher.js";
+import { dataStoreWorldGhostDestination as F } from "./worldGhostDestination.js";
+import { makeWorldGhostWireCodec as I, worldGhostWireLayout as L } from "./worldGhostWire.js";
+import { bindWorldGhostSender as R } from "./worldGhostSender.js";
+import { openWorldGhostSocket as z } from "./worldGhostSocket.js";
+import { bindWorldGhostIngress as B } from "./worldGhostIngress.js";
+import { assertWorldInstanceRecreation as V, dataStoreWorldInstances as H, worldInstanceCreationKey as U, worldInstanceGroupKey as W } from "./worldInstances.js";
+import { dataStoreWorldCellAllocation as G, worldCellCreationKey as K } from "./worldCellAllocation.js";
+import { bindWorldTransitionLeases as q, makeWorldTransitionLeases as J } from "./worldLeases.js";
+import { makeWorldTransitionExecutor as Y, worldRecoveryTransitionCompensation as X, worldSingleTransitionCommandBindings as Z } from "./worldTransitionExecutor.js";
+import { dataStoreWorldGhostNeighbors as Q } from "./worldGhostNeighbors.js";
+import { WorldCatalog as $, loadWorldCatalog as ee, validateWorldRooms as te } from "./worldCatalog.js";
+import { controllerWorldRoomSteps as ne, hostWorldRoomStepHandler as re, remoteWorldRoomSteps as ie, routedWorldRoomSteps as ae, worldRoomStepAuthority as oe } from "./worldRoomSteps.js";
+import { dataStoreWorldCellDestination as se } from "./worldCellDestination.js";
+import { dataStoreWorldInstanceDestination as ce } from "./worldInstanceDestination.js";
+import { defaultWorldClientAuthority as le, defaultWorldTransitionPolicies as ue } from "./worldTransitionDefaults.js";
+import { worldTransitionPhysicalSteps as de, worldTransitionSeatWithdrawal as fe } from "./worldTransitionPhysicalSteps.js";
+import { makeWorldTransitionResolver as pe } from "./worldTransitionResolver.js";
+import { dataStoreWorldTransitionSeats as me } from "./worldTransitionSeats.js";
+import { defaultWorldService as he, forwardedWorldTransitionExecutor as ge, runWorldTransitionForward as _e } from "./worldDefaultService.js";
+import { makeWorldClientControl as ve } from "./worldClientControl.js";
+import { dataStoreWorldInstanceAllocation as ye } from "./worldInstanceAllocation.js";
+import { makeWorldJoin as be } from "./worldJoin.js";
+import { defaultWorldGroupMembers as xe } from "./worldDefaultGroupMembers.js";
+import { makeWorldGroupDeadline as Se } from "./worldGroupDeadline.js";
+import { makeWorldGroupPreparation as Ce } from "./worldGroupPreparation.js";
+import { makeWorldGroupReadyControl as we } from "./worldGroupReadyControl.js";
+import { makeWorldGroupSupervisor as Te } from "./worldGroupSupervisor.js";
+import { WORLD_DEFAULT_MAX_BYTES as Ee, WORLD_LEASE_NAMESPACE as De, defaultApiWorldState as Oe, defaultHostWorld as ke, defaultWorldEntities as Ae } from "./worldDefaultBinding.js";
+import { makeWorldPersistence as je } from "./worldPersistence.js";
+import { bindWorldCellProjection as Me, makeWorldCellProjection as Ne } from "./worldProjection.js";
+import { dataStoreWorldInstanceExpiry as Pe } from "./worldInstanceExpiry.js";
+import { makeWorldInstanceExpirySupervisor as Fe } from "./worldInstanceExpirySupervisor.js";
+import { makeWorldGhostHandshake as Ie } from "./worldGhostHandshake.js";
+import { makeWorldGhostAdmission as Le } from "./worldGhostAdmission.js";
+import { makeWorldGhostGateway as Re } from "./worldGhostGateway.js";
+export { l as WORLD_CELLS_TABLE, Ee as WORLD_DEFAULT_MAX_BYTES, b as WORLD_ENTITIES_TABLE, e as WORLD_INSTANCES_TABLE, t as WORLD_INSTANCE_HISTORY_TABLE, n as WORLD_INSTANCE_SCOPES_TABLE, x as WORLD_JOURNAL_TABLE, De as WORLD_LEASE_NAMESPACE, s as WORLD_TRANSITIONS_TABLE, $ as WorldCatalog, V as assertWorldInstanceRecreation, Me as bindWorldCellProjection, B as bindWorldGhostIngress, R as bindWorldGhostSender, q as bindWorldTransitionLeases, p as canAdvanceWorldTransition, j as captureWorldGhostWithdrawal, g as captureWorldHandoffMetrics, ne as controllerWorldRoomSteps, G as dataStoreWorldCellAllocation, se as dataStoreWorldCellDestination, u as dataStoreWorldCells, S as dataStoreWorldEntities, F as dataStoreWorldGhostDestination, Q as dataStoreWorldGhostNeighbors, ye as dataStoreWorldInstanceAllocation, ce as dataStoreWorldInstanceDestination, Pe as dataStoreWorldInstanceExpiry, H as dataStoreWorldInstances, me as dataStoreWorldTransitionSeats, Oe as defaultApiWorldState, ke as defaultHostWorld, le as defaultWorldClientAuthority, Ae as defaultWorldEntities, xe as defaultWorldGroupMembers, he as defaultWorldService, ue as defaultWorldTransitionPolicies, ge as forwardedWorldTransitionExecutor, re as hostWorldRoomStepHandler, ee as loadWorldCatalog, N as makeRoomWorldGhostReceiver, A as makeWorldBoundaryCoordinator, Ne as makeWorldCellProjection, ve as makeWorldClientControl, Le as makeWorldGhostAdmission, Re as makeWorldGhostGateway, Ie as makeWorldGhostHandshake, c as makeWorldGhostNeighborhood, P as makeWorldGhostPublisher, M as makeWorldGhostReceiver, I as makeWorldGhostWireCodec, Se as makeWorldGroupDeadline, Ce as makeWorldGroupPreparation, we as makeWorldGroupReadyControl, Te as makeWorldGroupSupervisor, _ as makeWorldHandoffMetrics, Fe as makeWorldInstanceExpirySupervisor, be as makeWorldJoin, je as makeWorldPersistence, Y as makeWorldTransitionExecutor, J as makeWorldTransitionLeases, pe as makeWorldTransitionResolver, m as nextWorldTransitionPhase, z as openWorldGhostSocket, ie as remoteWorldRoomSteps, ae as routedWorldRoomSteps, _e as runWorldTransitionForward, te as validateWorldRooms, K as worldCellCreationKey, d as worldCellsContribution, f as worldCellsTable, C as worldEntitiesContribution, w as worldEntitiesTable, T as worldEntityPersistenceCommandBindings, E as worldEntityTables, D as worldEntityTransferCommandBindings, L as worldGhostWireLayout, y as worldGroupCommandRequestId, v as worldHandoffDurationBuckets, U as worldInstanceCreationKey, W as worldInstanceGroupKey, r as worldInstanceHistoryTable, i as worldInstanceScopesTable, a as worldInstanceTables, o as worldInstancesTable, O as worldJournalTable, X as worldRecoveryTransitionCompensation, oe as worldRoomStepAuthority, Z as worldSingleTransitionCommandBindings, de as worldTransitionPhysicalSteps, fe as worldTransitionSeatWithdrawal, k as worldTransitionTables, h as worldTransitionsTable };

package/dist/worldSourceSeatPending.js

@@ -0,0 +1,9 @@
+import { ProtocolError as e } from "./errors.js";
+//#region src/worldSourceSeatPending.ts
+var t = class extends e {
+	constructor() {
+		super({ detail: "World source Seat awaits transfer compensation" });
+	}
+};
+//#endregion
+export { t as WorldSourceSeatPending };

package/dist/worldStrategyFixtures.js

@@ -0,0 +1,164 @@
+import { defaultWorldLayerPolicy as e, resolveWorldLayerPolicy as t } from "./worldLayers.js";
+import { defaultWorldOnWorldChange as n, resolveWorldOnWorldChange as r } from "./worldChange.js";
+import { defaultWorldTransitionPolicy as i, resolveWorldTransitionPolicy as a } from "./worldTransitions.js";
+import { defineWorld as o, rect as s } from "./world.js";
+import { Effect as c } from "effect";
+//#region src/worldStrategyFixtures.ts
+var l = () => ({
+	name: "world-fixture",
+	map: { bounds: s(0, 0, 8, 4) },
+	zones: [{
+		id: "zone",
+		room: "zone",
+		bounds: s(0, 0, 8, 4),
+		neighbors: [],
+		cells: { size: 4 },
+		layering: {
+			maxPlayers: 120,
+			splitAt: 100,
+			mergeBelow: 40
+		}
+	}],
+	persistence: {
+		entities: "world",
+		snapshotEveryMs: 3e4,
+		journal: !0
+	},
+	handoff: {
+		marginUnits: 1,
+		ghostUnits: 2
+	},
+	spawn: () => ({
+		zone: "zone",
+		at: [1, 1]
+	})
+}), u = () => ({
+	policy: {
+		maxPlayers: 120,
+		splitAt: 100,
+		mergeBelow: 40
+	},
+	groupSize: 1,
+	affinity: null,
+	maxLayers: 4,
+	layers: [{
+		layer: 1,
+		players: 3,
+		state: "live"
+	}, {
+		layer: 2,
+		players: 1,
+		state: "live"
+	}]
+}), d = (e) => ({
+	kind: "cell",
+	sourceWorld: e,
+	targetWorld: e,
+	source: {
+		world: e.name,
+		pool: "fixture-pool",
+		zone: "zone",
+		at: [3, 1],
+		layer: 1,
+		instance: null
+	},
+	target: {
+		world: e.name,
+		pool: "fixture-pool",
+		zone: "zone",
+		at: [5, 1],
+		layer: 1,
+		instance: null
+	},
+	mode: "auto",
+	crossPool: !1,
+	recovery: !1
+}), f = {
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => c.sync(() => {
+			let e = o(l());
+			return t(u(), e.strategies.layerPolicy);
+		}),
+		expected: {
+			kind: "use",
+			layer: 2,
+			wake: !1
+		}
+	},
+	overrideProbe: {
+		run: () => c.sync(() => {
+			let e = o({
+				...l(),
+				strategies: { layerPolicy: () => ({
+					kind: "use",
+					layer: 1,
+					wake: !1
+				}) }
+			});
+			return t(u(), e.strategies.layerPolicy);
+		}),
+		expected: {
+			kind: "use",
+			layer: 1,
+			wake: !1
+		}
+	}
+}, p = {
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => c.sync(() => {
+			let e = o(l());
+			return a(d(e), e.strategies.transitionPolicy).mode;
+		}),
+		expected: "seamless"
+	},
+	overrideProbe: {
+		run: () => c.sync(() => {
+			let e = o({
+				...l(),
+				strategies: { transitionPolicy: (e) => ({
+					...i(e),
+					mode: "portal",
+					persistBeforeRelease: !0
+				}) }
+			});
+			return a(d(e), e.strategies.transitionPolicy).mode;
+		}),
+		expected: "portal"
+	}
+}, m = {
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => c.sync(() => {
+			let e = o(l());
+			return r({
+				sourceWorldId: e.name,
+				targetWorldId: "target",
+				sourceData: { coins: 10 },
+				targetData: { coins: 8 }
+			}, 1024, e.strategies.onWorldChange);
+		}),
+		expected: { coins: 8 }
+	},
+	overrideProbe: {
+		run: () => c.sync(() => {
+			let e = o({
+				...l(),
+				strategies: { onWorldChange: () => ({ coins: 5 }) }
+			});
+			return r({
+				sourceWorldId: e.name,
+				targetWorldId: "target",
+				sourceData: { coins: 10 },
+				targetData: { coins: 8 }
+			}, 1024, e.strategies.onWorldChange);
+		}),
+		expected: { coins: 5 }
+	}
+};
+//#endregion
+export { f as worldLayerPolicySlotFixture, m as worldOnWorldChangeSlotFixture, p as worldTransitionPolicySlotFixture };

package/dist/worldTesting.js

@@ -0,0 +1,27 @@
+import { ProtocolError as e } from "./errors.js";
+import { WorldTransitionPort as t } from "./worldCommands.js";
+import { Effect as n, Layer as r, Result as i } from "effect";
+//#region src/worldTesting.ts
+var a = (t = {}) => {
+	let r = () => n.fail(new e({ detail: "World transition fixture has no configured provider" }));
+	return Object.freeze({
+		transition: t.transition ?? r,
+		transitionGroup: t.transitionGroup ?? r,
+		recover: t.recover ?? r,
+		status: t.status ?? r
+	});
+}, o = (e = {}) => r.succeed(t, a(e)), s = o(), c = {
+	kind: "port",
+	tag: t,
+	fakeLayer: s,
+	probe: {
+		run: () => n.scoped(t.pipe(n.flatMap((e) => e.status({
+			roomId: "fixture-room",
+			tenantId: "fixture-tenant",
+			requestId: "fixture-room:1:1"
+		})), n.result, n.map((e) => i.isFailure(e) ? e.failure._tag : "unexpected-success"), n.provide(s))),
+		expected: "ProtocolError"
+	}
+};
+//#endregion
+export { o as fakeWorldTransitionLayer, a as fakeWorldTransitionService, s as worldTransitionFakeLayer, c as worldTransitionPortFixture };

package/dist/worldTransitionDefaults.js

@@ -0,0 +1,198 @@
+import { ProtocolError as e, WorldTransitionCooldown as t } from "./errors.js";
+import { ROOMS_TABLE as n, WORLD_TRANSITIONS_TABLE as r } from "./identities.js";
+import { captureWorldCatalog as i, worldCellAt as a, worldSpawn as o } from "./world.js";
+import { dataStoreWorldCells as s } from "./worldCells.js";
+import { WORLD_ENTITIES_TABLE as c } from "./worldEntities.js";
+import { dataStoreWorldCellDestination as l } from "./worldCellDestination.js";
+import { dataStoreWorldInstanceDestination as u } from "./worldInstanceDestination.js";
+import { and as d, eq as f } from "@voltro/database";
+import { Effect as p } from "effect";
+//#region src/worldTransitionDefaults.ts
+var m = (t) => new e({ detail: t }), h = (e, t, n) => {
+	let r = n.split(":"), i = Number(r.pop()), o = Number(r.pop()), s = e.zones.find((e) => e.id === t);
+	if (!s || r.join(":") !== t || !Number.isSafeInteger(o) || !Number.isSafeInteger(i)) throw m("Stored World cell is not declared");
+	let c = s.cells?.size ?? Math.max(s.bounds[1][0] - s.bounds[0][0], s.bounds[1][1] - s.bounds[0][1]), l = [s.bounds[0][0] + o * c, s.bounds[0][1] + i * c];
+	if (a(e, {
+		zone: t,
+		at: l
+	}).id !== n) throw m("Stored World cell is not declared");
+	return l;
+}, g = (t) => {
+	let { store: n, tenantId: r, catalog: c, rooms: d, epochNow: f, maxDataBytes: g } = t, y = i(t.worlds), b = () => p.void, x = s(n, {
+		worlds: y,
+		epochNow: f,
+		maxListedCells: 1,
+		authorize: b
+	}), S = l(n, {
+		tenantId: r,
+		worlds: y,
+		maxDataBytes: g,
+		epochNow: f,
+		authorize: b
+	}), C = t.allocation?.instance, w = (e) => u(n, {
+		tenantId: r,
+		worlds: y,
+		maxDataBytes: g,
+		maxManagedGroups: t.maxManagedGroups,
+		epochNow: f,
+		authorize: () => p.void,
+		...C === void 0 ? {} : { prepare: (t) => C(t, e.entity.subject) }
+	})(e), T = (e) => {
+		let t = y.find((t) => t.name === e);
+		if (!t) throw m("World is not declared");
+		return t;
+	}, E = (e, t, n, i) => p.suspend(() => x.observe({
+		tenantId: r,
+		worldId: e,
+		zoneId: t,
+		cellId: a(T(e), {
+			zone: t,
+			at: n
+		}).id,
+		layer: i
+	})).pipe(p.map((e) => e && e.state === "live" && e.hostId ? {
+		roomId: e.roomId,
+		epoch: e.epoch
+	} : null)), D = (e, n, r) => e().pipe(p.flatMap((i) => {
+		if (i !== null) return p.succeed(i);
+		let a = t.allocation?.cell;
+		return a ? a(n, r).pipe(p.flatMap(e), p.flatMap((e) => e === null ? p.fail(m("World destination has no live Room")) : p.succeed(e))) : p.fail(m("World destination has no live Room"));
+	}));
+	return Object.freeze({
+		authorize: (e) => _(t, e.entityId).pipe(p.flatMap((e) => e ? p.void : p.fail(m("World entity does not exist")))),
+		captureCurrent: (t) => d.capture({
+			tenantId: r,
+			roomId: t.roomId,
+			epoch: t.epoch,
+			entityId: t.entityId,
+			maxBytes: g
+		}).pipe(p.flatMap((n) => p.try({
+			try: () => {
+				let e = T(t.worldId), r = e.zones.find((e) => e.id === t.zoneId), i = r ? c.get(r.room).world?.movement : void 0, a = i ? i.position(n.entity) : h(e, t.zoneId, t.cellId);
+				return Object.freeze({
+					data: n.data,
+					location: Object.freeze({
+						worldId: t.worldId,
+						zoneId: t.zoneId,
+						at: Object.freeze([a[0], a[1]]),
+						layer: t.layer,
+						roomId: t.roomId,
+						epoch: t.epoch
+					})
+				});
+			},
+			catch: (t) => t instanceof e ? t : m("World entity position is unavailable")
+		}))),
+		resolveDestination: (e) => p.suspend(() => {
+			let t = e.intent.target, n = e.current.location;
+			switch (t.kind) {
+				case "instance": return w(e);
+				case "world": {
+					let n = T(t.world), i = e.entity.subject;
+					if (!i) return p.fail(m("Only a player changes World"));
+					let a = o(n, {
+						id: i.id,
+						kind: i.kind,
+						spawn: t.spawn
+					});
+					return D(() => E(n.name, a.zone, a.at, 1), {
+						tenantId: r,
+						worldId: n.name,
+						zoneId: a.zone,
+						at: a.at,
+						layer: 1
+					}, i).pipe(p.map((t) => Object.freeze({
+						data: e.current.data,
+						location: Object.freeze({
+							worldId: n.name,
+							zoneId: a.zone,
+							at: Object.freeze([a.at[0], a.at[1]]),
+							layer: 1,
+							roomId: t.roomId,
+							epoch: t.epoch
+						})
+					})));
+				}
+				default: {
+					let i = t.kind === "return" ? e.entity.returnAnchor : void 0, a = t.kind === "cell" || t.kind === "zone" ? t.zone : i?.source.zoneId ?? n.zoneId, o = t.kind === "cell" || t.kind === "zone" ? t.at : i?.source.at ?? n.at, s = t.kind === "layer" ? t.layer : i?.source.layer ?? n.layer, c = {
+						tenantId: r,
+						worldId: n.worldId,
+						zoneId: a,
+						at: o,
+						layer: s
+					};
+					return D(() => S(e).pipe(p.option, p.map((e) => e._tag === "Some" ? e.value : null)), c, e.entity.subject);
+				}
+			}
+		}).pipe(p.catchDefect(() => p.fail(m("World destination is not declared")))),
+		admit: (e, t) => v(n, r, t.location.roomId, t.location.epoch)
+	});
+}, _ = (e, t) => p.tryPromise({
+	try: async () => {
+		let n = (await e.store.query({
+			table: c,
+			predicate: d(f("tenantId", e.tenantId), f("entityId", t)),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: [
+				"subjectId",
+				"subjectKind",
+				"roomId",
+				"worldId",
+				"transitionedAt"
+			]
+		}))[0], r = n?.transitionedAt, i = r instanceof Date ? r.getTime() : typeof r == "string" || typeof r == "number" ? new Date(r).getTime() : null;
+		return n ? {
+			subjectId: n.subjectId ?? null,
+			subjectKind: n.subjectKind ?? null,
+			roomId: String(n.roomId),
+			worldId: String(n.worldId),
+			transitionedAt: i !== null && Number.isFinite(i) ? i : null
+		} : null;
+	},
+	catch: () => m("World entity is unavailable")
+}), v = (e, t, r, i) => p.tryPromise({
+	try: () => e.query({
+		table: n,
+		predicate: d(f("id", r), f("tenantId", t)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["state", "epoch"]
+	}),
+	catch: () => m("World target Room is unavailable")
+}).pipe(p.flatMap((e) => e[0]?.state === "live" && Number(e[0].epoch) === i ? p.void : p.fail(m("World target Room is not live")))), y = (n) => {
+	let i = (e) => e.type === "user" && e.kind === "guest" ? "guest" : "user", a = (t, a) => p.tryPromise({
+		try: async () => {
+			let e = await n.store.query({
+				table: r,
+				predicate: d(f("tenantId", n.tenantId), f("subjectId", t.id ?? ""), f("subjectKind", i(t)), f("requestId", a)),
+				order: [],
+				take: 2,
+				skip: void 0,
+				projection: ["sourceRoomId"]
+			});
+			if (e.length > 1) throw m("World request ID is ambiguous");
+			return e[0] ? Object.freeze({
+				tenantId: n.tenantId,
+				roomId: String(e[0].sourceRoomId),
+				requestId: a
+			}) : null;
+		},
+		catch: (t) => t instanceof e ? t : m("World transition is unavailable")
+	}), o = (e, t) => _(n, t.entityId).pipe(p.flatMap((t) => t && t.subjectId === e.id && t.subjectKind === i(e) ? p.succeed(t) : p.fail(m("Only the owning player may move this World entity"))));
+	return Object.freeze({
+		authorize: (e, r, i) => e === "prepare" && i.intention !== null ? o(r, i.intention).pipe(p.flatMap((e) => {
+			let r = n.worlds?.find((t) => t.name === e.worldId)?.transitionCooldownMs ?? 0, i = n.epochNow?.(), a = e.transitionedAt === null || i === void 0 ? 0 : e.transitionedAt + r - i;
+			return a > 0 ? p.fail(new t({ retryAfterMs: Math.ceil(a) })) : p.void;
+		})) : p.void,
+		resolveOrigin: (e, t) => a(e, t.requestId).pipe(p.flatMap((r) => r ? p.succeed(r) : t.intention === null ? p.fail(m("World transition request was not found")) : o(e, t.intention).pipe(p.map((e) => Object.freeze({
+			tenantId: n.tenantId,
+			roomId: e.roomId,
+			requestId: t.requestId
+		})))))
+	});
+};
+//#endregion
+export { y as defaultWorldClientAuthority, g as defaultWorldTransitionPolicies };