@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/rpc.d.ts

@@ -0,0 +1,551 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare const BASE_NAME = "@voltro/plugin-rooms";
+
+export declare class BudgetExceeded extends BudgetExceeded_base {
+    get message(): string;
+}
+
+declare const BudgetExceeded_base: Schema.Class<BudgetExceeded, Schema.TaggedStruct<"BudgetExceeded", {
+    readonly budget: Schema.String;
+    readonly limit: Schema.Number;
+}>, YieldableError>;
+
+export declare const geometryAssetUrlDescriptor: ActionProcedureDescriptor<"rooms.geometry.assetUrl", Schema.Struct<{
+    readonly worldId: Schema.String;
+    readonly layerSetId: Schema.String;
+    readonly version: Schema.String;
+    readonly key: Schema.String;
+}>, Schema.Struct<{
+    readonly url: Schema.String;
+    readonly checksum: Schema.String;
+    readonly size: Schema.Int;
+    readonly contentType: Schema.String;
+}>, typeof ProtocolError>;
+
+/** The changed chunks a World cell Room owns, live from the chunk delta table (`_voltro_geo_chunk_deltas`). */
+export declare const geometryChunksDescriptor: QueryProcedureDescriptor<"rooms.geometry.chunks", Schema.Struct<{
+    readonly roomId: Schema.String;
+}>, Schema.Struct<{
+    readonly roomId: Schema.String;
+    readonly worldId: Schema.String;
+    readonly zoneId: Schema.String;
+    readonly cellId: Schema.String;
+    readonly truncated: Schema.Boolean;
+    readonly chunks: Schema.$Array<Schema.Struct<{
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.optional<Schema.Int>;
+        readonly layerSetId: Schema.String;
+        readonly version: Schema.String;
+        readonly revision: Schema.Int;
+        readonly changed: Schema.Boolean;
+        readonly updatedAt: Schema.Int;
+    }>>;
+}>, Schema.Union<readonly [typeof ProtocolError, typeof BudgetExceeded]>>;
+
+/** Browser-safe workflow control/results; no patch, Subject or credentials. */
+export declare const GeometryJournalRetentionWorkflowPayload: Schema.Struct<{
+    readonly runKey: Schema.NonEmptyString;
+    readonly maxPages: Schema.Int;
+}>;
+
+export declare type GeometryJournalRetentionWorkflowPayload = typeof GeometryJournalRetentionWorkflowPayload.Type;
+
+export declare const GeometryJournalRetentionWorkflowResult: Schema.Struct<{
+    readonly scopes: Schema.Int;
+    readonly pages: Schema.Int;
+    readonly selected: Schema.Int;
+    readonly compacted: Schema.Int;
+    readonly alreadyArchived: Schema.Int;
+    readonly skipped: Schema.Int;
+}>;
+
+export declare type GeometryJournalRetentionWorkflowResult = typeof GeometryJournalRetentionWorkflowResult.Type;
+
+export declare const geometryReloadDescriptor: ActionProcedureDescriptor<"rooms.geometry.reload", Schema.Struct<{
+    readonly roomId: Schema.String;
+    readonly request: Schema.Struct<{
+        readonly version: Schema.String;
+        readonly requestId: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+}>, Schema.Union<readonly [typeof ProtocolError, typeof BudgetExceeded]>>;
+
+export declare const geometryRollbackDescriptor: ActionProcedureDescriptor<"rooms.geometry.rollback", Schema.Struct<{
+    readonly roomId: Schema.String;
+    readonly request: Schema.Struct<{
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.optional<Schema.Int>;
+        readonly target: Schema.NullOr<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["user", "guest"]>;
+        }>>;
+        readonly requestId: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+}>, Schema.Union<readonly [typeof ProtocolError, typeof BudgetExceeded]>>;
+
+export declare const geometryStaticUrlDescriptor: ActionProcedureDescriptor<"rooms.geometry.staticUrl", Schema.Struct<{
+    readonly worldId: Schema.String;
+    readonly layerSetId: Schema.String;
+    readonly version: Schema.String;
+    readonly cx: Schema.Int;
+    readonly cy: Schema.Int;
+    readonly cz: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly url: Schema.String;
+}>, typeof ProtocolError>;
+
+export declare const leaveDescriptor: ActionProcedureDescriptor<"rooms.leave", Schema.Struct<{
+    readonly sessionId: Schema.NonEmptyString;
+    readonly token: Schema.Uint8Array;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+}>, Schema.Union<readonly [typeof BudgetExceeded, typeof NotRoomMember, typeof ProtocolError, typeof RoomAuthoringError, typeof RoomForbidden, typeof RoomFull, typeof RoomGone, typeof RoomLocked, typeof RoomPoolWaking, typeof RoomsClosed, typeof SeatExpired]>>;
+
+export declare const listDescriptor: QueryProcedureDescriptor<"rooms.list", Schema.Struct<{
+    readonly room: Schema.NonEmptyString;
+    readonly limit: Schema.optional<Schema.Int>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly clients: Schema.Int;
+    readonly maxClients: Schema.Int;
+    readonly locked: Schema.Boolean;
+}>>, Schema.Union<readonly [typeof BudgetExceeded, typeof NotRoomMember, typeof ProtocolError, typeof RoomAuthoringError, typeof RoomForbidden, typeof RoomFull, typeof RoomGone, typeof RoomLocked, typeof RoomPoolWaking, typeof RoomsClosed, typeof SeatExpired]>>;
+
+declare class NotRoomMember extends NotRoomMember_base {
+}
+
+declare const NotRoomMember_base: Schema.Class<NotRoomMember, Schema.TaggedStruct<"NotRoomMember", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+export declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+/** Action, not mutation: the host owns the room/seat transaction and admission
+ * spans host control. Wrapping it in an unrelated API transaction is incorrect. */
+export declare const reserveDescriptor: ActionProcedureDescriptor<"rooms.reserve", Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["join", "create"]>;
+    readonly room: Schema.NonEmptyString;
+    readonly options: Schema.Unknown;
+    readonly pool: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"joinById">;
+    readonly roomId: Schema.NonEmptyString;
+    readonly role: Schema.optional<Schema.Literals<readonly ["player", "spectator"]>>;
+}>]>, Schema.Struct<{
+    readonly roomId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly token: Schema.Uint8Array;
+    readonly address: Schema.NonEmptyString;
+    readonly endpoints: Schema.optional<Schema.Struct<{
+        readonly ws: Schema.NonEmptyString;
+        readonly wt: Schema.optional<Schema.NonEmptyString>;
+        readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+    }>>;
+    readonly transport: Schema.Union<readonly [Schema.Tuple<readonly [Schema.Literal<"ws">]>, Schema.Tuple<readonly [Schema.Literal<"ws">, Schema.Literal<"wt">]>]>;
+    readonly expiresAt: Schema.Number;
+}>, Schema.Union<readonly [typeof BudgetExceeded, typeof NotRoomMember, typeof ProtocolError, typeof RoomAuthoringError, typeof RoomForbidden, typeof RoomFull, typeof RoomGone, typeof RoomLocked, typeof RoomPoolWaking, typeof RoomsClosed, typeof SeatExpired]>>;
+
+export declare const ReserveRoomInput: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["join", "create"]>;
+    readonly room: Schema.NonEmptyString;
+    readonly options: Schema.Unknown;
+    readonly pool: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"joinById">;
+    readonly roomId: Schema.NonEmptyString;
+    readonly role: Schema.optional<Schema.Literals<readonly ["player", "spectator"]>>;
+}>]>;
+
+export declare type ReserveRoomInput = typeof ReserveRoomInput.Type;
+
+export declare const resumeDescriptor: ActionProcedureDescriptor<"rooms.resume", Schema.Struct<{
+    readonly sessionId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly roomId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly token: Schema.Uint8Array;
+    readonly address: Schema.NonEmptyString;
+    readonly endpoints: Schema.optional<Schema.Struct<{
+        readonly ws: Schema.NonEmptyString;
+        readonly wt: Schema.optional<Schema.NonEmptyString>;
+        readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+    }>>;
+    readonly transport: Schema.Union<readonly [Schema.Tuple<readonly [Schema.Literal<"ws">]>, Schema.Tuple<readonly [Schema.Literal<"ws">, Schema.Literal<"wt">]>]>;
+    readonly expiresAt: Schema.Number;
+}>, Schema.Union<readonly [typeof BudgetExceeded, typeof NotRoomMember, typeof ProtocolError, typeof RoomAuthoringError, typeof RoomForbidden, typeof RoomFull, typeof RoomGone, typeof RoomLocked, typeof RoomPoolWaking, typeof RoomsClosed, typeof SeatExpired]>>;
+
+declare class RoomAuthoringError extends RoomAuthoringError_base {
+    get message(): string;
+}
+
+declare const RoomAuthoringError_base: Schema.Class<RoomAuthoringError, Schema.TaggedStruct<"RoomAuthoringError", {
+    readonly room: Schema.String;
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+declare class RoomForbidden extends RoomForbidden_base {
+}
+
+declare const RoomForbidden_base: Schema.Class<RoomForbidden, Schema.TaggedStruct<"RoomForbidden", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare class RoomFull extends RoomFull_base {
+}
+
+declare const RoomFull_base: Schema.Class<RoomFull, Schema.TaggedStruct<"RoomFull", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare class RoomGone extends RoomGone_base {
+}
+
+declare const RoomGone_base: Schema.Class<RoomGone, Schema.TaggedStruct<"RoomGone", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare class RoomLocked extends RoomLocked_base {
+}
+
+declare const RoomLocked_base: Schema.Class<RoomLocked, Schema.TaggedStruct<"RoomLocked", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+/** The pool has no host because it scaled to zero; one is starting. Reserve again after `retryAfterMs`. */
+declare class RoomPoolWaking extends RoomPoolWaking_base {
+}
+
+declare const RoomPoolWaking_base: Schema.Class<RoomPoolWaking, Schema.TaggedStruct<"RoomPoolWaking", {
+    readonly pool: Schema.String;
+    readonly retryAfterMs: Schema.Number;
+}>, YieldableError>;
+
+export declare const RoomReaperWorkflowPayload: Schema.Struct<{
+    readonly runKey: Schema.NonEmptyString;
+    readonly maxPages: Schema.Int;
+}>;
+
+export declare type RoomReaperWorkflowPayload = typeof RoomReaperWorkflowPayload.Type;
+
+export declare const RoomReaperWorkflowResult: Schema.Struct<{
+    readonly pages: Schema.Int;
+    readonly hostsObserved: Schema.Int;
+    readonly roomsObserved: Schema.Int;
+    readonly adopted: Schema.Int;
+    readonly disposed: Schema.Int;
+    readonly waiting: Schema.Int;
+    readonly untrackedHosts: Schema.Int;
+}>;
+
+export declare type RoomReaperWorkflowResult = typeof RoomReaperWorkflowResult.Type;
+
+export declare const RoomReservationSchema: Schema.Struct<{
+    readonly roomId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly token: Schema.Uint8Array;
+    readonly address: Schema.NonEmptyString;
+    readonly endpoints: Schema.optional<Schema.Struct<{
+        readonly ws: Schema.NonEmptyString;
+        readonly wt: Schema.optional<Schema.NonEmptyString>;
+        readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+    }>>;
+    readonly transport: Schema.Union<readonly [Schema.Tuple<readonly [Schema.Literal<"ws">]>, Schema.Tuple<readonly [Schema.Literal<"ws">, Schema.Literal<"wt">]>]>;
+    readonly expiresAt: Schema.Number;
+}>;
+
+export declare const RoomRpcError: Schema.Union<readonly [typeof BudgetExceeded, typeof NotRoomMember, typeof ProtocolError, typeof RoomAuthoringError, typeof RoomForbidden, typeof RoomFull, typeof RoomGone, typeof RoomLocked, typeof RoomPoolWaking, typeof RoomsClosed, typeof SeatExpired]>;
+
+/** New Room reservations are closed for this caller (maintenance, a kill switch...): the app's
+ * `admission` refused. `until`: epoch ms when they reopen, if known; `messageKey`: the app's text. */
+declare class RoomsClosed extends RoomsClosed_base {
+}
+
+declare const RoomsClosed_base: Schema.Class<RoomsClosed, Schema.TaggedStruct<"RoomsClosed", {
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly messageKey: Schema.String;
+}>, YieldableError>;
+
+export declare const roomsRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const RoomTransportEndpointsSchema: Schema.Struct<{
+    readonly ws: Schema.NonEmptyString;
+    readonly wt: Schema.optional<Schema.NonEmptyString>;
+    readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+}>;
+
+declare class SeatExpired extends SeatExpired_base {
+}
+
+declare const SeatExpired_base: Schema.Class<SeatExpired, Schema.TaggedStruct<"SeatExpired", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+export declare const worldCancelDescriptor: ActionProcedureDescriptor<"rooms.world.cancel", Schema.Struct<{
+    readonly requestId: Schema.String;
+}>, Schema.Struct<{
+    readonly ticket: Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly transitionId: Schema.String;
+        readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+        readonly target: Schema.Struct<{
+            readonly worldId: Schema.String;
+            readonly cellId: Schema.String;
+            readonly layer: Schema.Int;
+            readonly roomId: Schema.String;
+            readonly epoch: Schema.Int;
+        }>;
+    }>;
+    readonly phase: Schema.Literals<readonly ["prepared", "committed", "settled", "rolledBack"]>;
+    readonly entityRevision: Schema.NullOr<Schema.Int>;
+}>, typeof ProtocolError>;
+
+/** The caller's local connection context, never permission to read another entity. */
+export declare const WorldClientPendingInputSchema: Schema.Struct<{
+    readonly entityId: Schema.String;
+    readonly roomId: Schema.String;
+}>;
+
+export declare const WorldClientReceiptSchema: Schema.Struct<{
+    readonly ticket: Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly transitionId: Schema.String;
+        readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+        readonly target: Schema.Struct<{
+            readonly worldId: Schema.String;
+            readonly cellId: Schema.String;
+            readonly layer: Schema.Int;
+            readonly roomId: Schema.String;
+            readonly epoch: Schema.Int;
+        }>;
+    }>;
+    readonly phase: Schema.Literals<readonly ["prepared", "committed", "settled", "rolledBack"]>;
+    readonly entityRevision: Schema.NullOr<Schema.Int>;
+}>;
+
+/** SQL origin IDs include the group command hash and full entity identity. */
+export declare const WorldClientRequestIdSchema: Schema.String;
+
+export declare const WorldClientTicketSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly transitionId: Schema.String;
+    readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+    readonly target: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly cellId: Schema.String;
+        readonly layer: Schema.Int;
+        readonly roomId: Schema.String;
+        readonly epoch: Schema.Int;
+    }>;
+}>;
+
+export declare const worldCommitDescriptor: ActionProcedureDescriptor<"rooms.world.commit", Schema.Struct<{
+    readonly ticket: Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly transitionId: Schema.String;
+        readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+        readonly target: Schema.Struct<{
+            readonly worldId: Schema.String;
+            readonly cellId: Schema.String;
+            readonly layer: Schema.Int;
+            readonly roomId: Schema.String;
+            readonly epoch: Schema.Int;
+        }>;
+    }>;
+}>, Schema.Struct<{
+    readonly ticket: Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly transitionId: Schema.String;
+        readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+        readonly target: Schema.Struct<{
+            readonly worldId: Schema.String;
+            readonly cellId: Schema.String;
+            readonly layer: Schema.Int;
+            readonly roomId: Schema.String;
+            readonly epoch: Schema.Int;
+        }>;
+    }>;
+    readonly phase: Schema.Literals<readonly ["prepared", "committed", "settled", "rolledBack"]>;
+    readonly entityRevision: Schema.NullOr<Schema.Int>;
+}>, typeof ProtocolError>;
+
+export declare const worldFollowDescriptor: ActionProcedureDescriptor<"rooms.world.follow", Schema.Struct<{
+    readonly requestId: Schema.String;
+}>, Schema.Struct<{
+    readonly roomId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly token: Schema.Uint8Array;
+    readonly address: Schema.NonEmptyString;
+    readonly endpoints: Schema.optional<Schema.Struct<{
+        readonly ws: Schema.NonEmptyString;
+        readonly wt: Schema.optional<Schema.NonEmptyString>;
+        readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+    }>>;
+    readonly transport: Schema.Union<readonly [Schema.Tuple<readonly [Schema.Literal<"ws">]>, Schema.Tuple<readonly [Schema.Literal<"ws">, Schema.Literal<"wt">]>]>;
+    readonly expiresAt: Schema.Number;
+}>, typeof ProtocolError>;
+
+export declare const worldJoinDescriptor: ActionProcedureDescriptor<"rooms.world.join", Schema.Struct<{
+    readonly world: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly entityId: Schema.NonEmptyString;
+    readonly reservation: Schema.Struct<{
+        readonly roomId: Schema.NonEmptyString;
+        readonly sessionId: Schema.NonEmptyString;
+        readonly token: Schema.Uint8Array;
+        readonly address: Schema.NonEmptyString;
+        readonly endpoints: Schema.optional<Schema.Struct<{
+            readonly ws: Schema.NonEmptyString;
+            readonly wt: Schema.optional<Schema.NonEmptyString>;
+            readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+        }>>;
+        readonly transport: Schema.Union<readonly [Schema.Tuple<readonly [Schema.Literal<"ws">]>, Schema.Tuple<readonly [Schema.Literal<"ws">, Schema.Literal<"wt">]>]>;
+        readonly expiresAt: Schema.Number;
+    }>;
+}>, typeof ProtocolError>;
+
+/** First visit: server spawn + entity; every visit: a Seat in the entity's current Room. */
+export declare const WorldJoinResultSchema: Schema.Struct<{
+    readonly entityId: Schema.NonEmptyString;
+    readonly reservation: Schema.Struct<{
+        readonly roomId: Schema.NonEmptyString;
+        readonly sessionId: Schema.NonEmptyString;
+        readonly token: Schema.Uint8Array;
+        readonly address: Schema.NonEmptyString;
+        readonly endpoints: Schema.optional<Schema.Struct<{
+            readonly ws: Schema.NonEmptyString;
+            readonly wt: Schema.optional<Schema.NonEmptyString>;
+            readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+        }>>;
+        readonly transport: Schema.Union<readonly [Schema.Tuple<readonly [Schema.Literal<"ws">]>, Schema.Tuple<readonly [Schema.Literal<"ws">, Schema.Literal<"wt">]>]>;
+        readonly expiresAt: Schema.Number;
+    }>;
+}>;
+
+export declare const worldObserveDescriptor: QueryProcedureDescriptor<"rooms.world.observe", Schema.Struct<{
+    readonly requestId: Schema.String;
+}>, Schema.Struct<{
+    readonly ticket: Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly transitionId: Schema.String;
+        readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+        readonly target: Schema.Struct<{
+            readonly worldId: Schema.String;
+            readonly cellId: Schema.String;
+            readonly layer: Schema.Int;
+            readonly roomId: Schema.String;
+            readonly epoch: Schema.Int;
+        }>;
+    }>;
+    readonly phase: Schema.Literals<readonly ["prepared", "committed", "settled", "rolledBack"]>;
+    readonly entityRevision: Schema.NullOr<Schema.Int>;
+}>, typeof ProtocolError>;
+
+export declare const worldPendingDescriptor: QueryProcedureDescriptor<"rooms.world.pending", Schema.Struct<{
+    readonly entityId: Schema.String;
+    readonly roomId: Schema.String;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly ticket: Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly transitionId: Schema.String;
+        readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+        readonly target: Schema.Struct<{
+            readonly worldId: Schema.String;
+            readonly cellId: Schema.String;
+            readonly layer: Schema.Int;
+            readonly roomId: Schema.String;
+            readonly epoch: Schema.Int;
+        }>;
+    }>;
+    readonly phase: Schema.Literals<readonly ["prepared", "committed", "settled", "rolledBack"]>;
+    readonly entityRevision: Schema.NullOr<Schema.Int>;
+}>>, typeof ProtocolError>;
+
+export declare const worldPrepareDescriptor: ActionProcedureDescriptor<"rooms.world.prepare", Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly intention: Schema.Struct<{
+        readonly entityId: Schema.String;
+        readonly target: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"cell">;
+            readonly zone: Schema.String;
+            readonly at: Schema.Tuple<readonly [Schema.Number, Schema.Number]>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"zone">;
+            readonly zone: Schema.String;
+            readonly at: Schema.Tuple<readonly [Schema.Number, Schema.Number]>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"layer">;
+            readonly layer: Schema.Number;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"world">;
+            readonly world: Schema.String;
+            readonly spawn: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"instance">;
+            readonly instance: Schema.String;
+            readonly group: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"return">;
+        }>]>;
+        readonly options: Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["auto", "seamless", "portal"]>;
+            readonly reason: Schema.String;
+            readonly crossPool: Schema.Boolean;
+            readonly returnTo: Schema.optional<Schema.Literal<"here">>;
+        }>;
+    }>;
+}>, Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly transitionId: Schema.String;
+    readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+    readonly target: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly cellId: Schema.String;
+        readonly layer: Schema.Int;
+        readonly roomId: Schema.String;
+        readonly epoch: Schema.Int;
+    }>;
+}>, Schema.Union<readonly [typeof ProtocolError, typeof WorldTransitionCooldown]>>;
+
+export declare const worldReservationDescriptor: ActionProcedureDescriptor<"rooms.world.reservation", Schema.Struct<{
+    readonly requestId: Schema.String;
+}>, Schema.Struct<{
+    readonly roomId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly token: Schema.Uint8Array;
+    readonly address: Schema.NonEmptyString;
+    readonly endpoints: Schema.optional<Schema.Struct<{
+        readonly ws: Schema.NonEmptyString;
+        readonly wt: Schema.optional<Schema.NonEmptyString>;
+        readonly wtCertificateHash: Schema.optional<Schema.NonEmptyString>;
+    }>>;
+    readonly transport: Schema.Union<readonly [Schema.Tuple<readonly [Schema.Literal<"ws">]>, Schema.Tuple<readonly [Schema.Literal<"ws">, Schema.Literal<"wt">]>]>;
+    readonly expiresAt: Schema.Number;
+}>, typeof ProtocolError>;
+
+/** A World transition asked for inside the World's `transitionCooldownMs`; retry after `retryAfterMs`. */
+declare class WorldTransitionCooldown extends WorldTransitionCooldown_base {
+}
+
+declare const WorldTransitionCooldown_base: Schema.Class<WorldTransitionCooldown, Schema.TaggedStruct<"WorldTransitionCooldown", {
+    readonly retryAfterMs: Schema.Number;
+}>, YieldableError>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,111 @@
+import { BudgetExceeded as e, NotRoomMember as t, ProtocolError as n, RoomAuthoringError as r, RoomForbidden as i, RoomFull as a, RoomGone as o, RoomLocked as s, RoomPoolWaking as c, RoomsClosed as l, SeatExpired as u } from "./errors.js";
+import { geometryChunksDescriptor as d, geometryReloadDescriptor as f, geometryRollbackDescriptor as p } from "./geometryAdminRpc.js";
+import { WorldClientReceiptSchema as m, WorldClientRequestIdSchema as h, WorldClientTicketSchema as g } from "./worldClientSchemas.js";
+import { WorldClientPendingInputSchema as _ } from "./worldClientPendingInput.js";
+import { RoomReservationSchema as v, RoomTransportEndpointsSchema as y } from "./reservationSchemas.js";
+import { ROOMS_TABLE as b } from "./identities.js";
+import { RoomReaperWorkflowPayload as x, RoomReaperWorkflowResult as S } from "./reaperSchemas.js";
+import { WorldJoinResultSchema as C, worldCancelDescriptor as w, worldCommitDescriptor as T, worldFollowDescriptor as E, worldJoinDescriptor as D, worldObserveDescriptor as O, worldPendingDescriptor as k, worldPrepareDescriptor as A, worldReservationDescriptor as j } from "./worldClientRpc.js";
+import { geometryStaticUrlDescriptor as M } from "./geometryReadRpc.js";
+import { geometryAssetUrlDescriptor as N } from "./geometryAssetRpc.js";
+import { GeometryJournalRetentionWorkflowPayload as P, GeometryJournalRetentionWorkflowResult as F } from "./geometryJournalRetentionSchemas.js";
+import { defineAction as I, defineQuery as L } from "@voltro/protocol";
+import { Schema as R } from "effect";
+// src/rpc.ts
+var z = "@voltro/plugin-rooms", B = R.Union([
+	e,
+	t,
+	n,
+	r,
+	i,
+	a,
+	o,
+	s,
+	c,
+	l,
+	u
+]), V = R.Union([R.Struct({
+	mode: R.Literals(["join", "create"]),
+	room: R.NonEmptyString,
+	options: R.Unknown,
+	pool: R.optional(R.String.pipe(R.check(R.isPattern(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,95}$/))))
+}), R.Struct({
+	mode: R.Literal("joinById"),
+	roomId: R.NonEmptyString,
+	role: R.optional(R.Literals(["player", "spectator"]))
+})]), H = "Room descriptors enforce their normal guards; identity and tenant come only from the resolved caller, including explicitly public rooms", U = I({
+	name: "rooms.reserve",
+	input: V,
+	output: v,
+	error: B,
+	openAccess: H
+}), W = I({
+	name: "rooms.resume",
+	input: R.Struct({ sessionId: R.NonEmptyString }),
+	output: v,
+	error: B,
+	openAccess: H
+}), G = I({
+	name: "rooms.leave",
+	input: R.Struct({
+		sessionId: R.NonEmptyString,
+		token: R.Uint8Array
+	}),
+	output: R.Struct({ ok: R.Literal(!0) }),
+	error: B,
+	openAccess: "Withdrawal is bound to the resolved identity, tenant, session and current credential digest; revoked room scopes cannot strand a seat"
+}), K = L({
+	name: "rooms.list",
+	source: b,
+	input: R.Struct({
+		room: R.NonEmptyString,
+		limit: R.optional(R.Int.pipe(R.check(R.isBetween({
+			minimum: 1,
+			maximum: 256
+		}))))
+	}),
+	output: R.Array(R.Struct({
+		id: R.String,
+		name: R.String,
+		metadata: R.Record(R.String, R.Unknown),
+		clients: R.Int,
+		maxClients: R.Int,
+		locked: R.Boolean
+	})),
+	error: B,
+	openAccess: H
+}), q = [
+	{
+		tag: "rooms.reserve",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "reserveDescriptor"
+		}
+	},
+	{
+		tag: "rooms.resume",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "resumeDescriptor"
+		}
+	},
+	{
+		tag: "rooms.leave",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "leaveDescriptor"
+		}
+	},
+	{
+		tag: "rooms.list",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-rooms/rpc",
+			name: "listDescriptor"
+		}
+	}
+];
+export { z as BASE_NAME, e as BudgetExceeded, P as GeometryJournalRetentionWorkflowPayload, F as GeometryJournalRetentionWorkflowResult, n as ProtocolError, V as ReserveRoomInput, x as RoomReaperWorkflowPayload, S as RoomReaperWorkflowResult, v as RoomReservationSchema, B as RoomRpcError, y as RoomTransportEndpointsSchema, _ as WorldClientPendingInputSchema, m as WorldClientReceiptSchema, h as WorldClientRequestIdSchema, g as WorldClientTicketSchema, C as WorldJoinResultSchema, N as geometryAssetUrlDescriptor, d as geometryChunksDescriptor, f as geometryReloadDescriptor, p as geometryRollbackDescriptor, M as geometryStaticUrlDescriptor, G as leaveDescriptor, K as listDescriptor, U as reserveDescriptor, W as resumeDescriptor, q as roomsRpcClientImports, w as worldCancelDescriptor, T as worldCommitDescriptor, E as worldFollowDescriptor, D as worldJoinDescriptor, O as worldObserveDescriptor, k as worldPendingDescriptor, A as worldPrepareDescriptor, j as worldReservationDescriptor };