@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/ports.d.ts

@@ -0,0 +1,1241 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyRequest } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+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>;
+
+declare interface GeometryPersistenceSubject {
+    readonly id: string;
+    readonly kind: 'user' | 'guest';
+}
+
+declare class NotRoomMember extends NotRoomMember_base {
+}
+
+declare const NotRoomMember_base: Schema.Class<NotRoomMember, Schema.TaggedStruct<"NotRoomMember", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+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"]>>;
+}>]>;
+
+declare type ReserveRoomInput = typeof ReserveRoomInput.Type;
+
+export declare interface RoomAccessRecheckInput {
+    readonly tenantId: string;
+    readonly subjectId: string;
+}
+
+/** `visited`: seats asked again; `renewed`: still admitted (new deadline); `kicked`: sessions ended. */
+export declare interface RoomAccessRecheckReceipt {
+    readonly visited: number;
+    readonly renewed: number;
+    readonly kicked: number;
+}
+
+declare interface RoomAppCommand {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly requestId: string;
+    readonly command: RoomOutboxCommand;
+}
+
+/** Application dispatch must implement durable idempotency by requestId. */
+export declare class RoomAppCommandPort extends RoomAppCommandPort_base {
+}
+
+declare const RoomAppCommandPort_base: Context.ServiceClass<RoomAppCommandPort, "@voltro/RoomAppCommandPort", {
+    deliver(command: RoomAppCommand): Effect.Effect<void, ProtocolError>;
+}>;
+
+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 interface RoomCheckpoint {
+    readonly requestId: string;
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly epoch: number;
+    readonly revision: number;
+    readonly tick: number;
+    readonly commandCursor: number;
+    readonly bytes: Uint8Array;
+    readonly schemaHash: number;
+    readonly schedules: ReadonlyArray<RoomScheduleSnapshot>;
+    readonly worldReceipts?: ReadonlyArray<RoomWorldReceipt> | undefined;
+    readonly inputReceipts: ReadonlyArray<RoomInputReceipt>;
+    readonly commands: ReadonlyArray<RoomOutboxCommand>;
+    readonly publication?: 'held' | undefined;
+    /** Earliest World epoch represented by an interrupted held adoption. */
+    readonly worldRecoveryEpoch?: number | undefined;
+    readonly disposition: 'live' | 'faulted' | 'disposed' | 'hibernating' | 'hibernated';
+    /** The Room's own listing (`RoomDefinition.listing`), written to the directory with a live checkpoint. */
+    readonly listing?: RoomListing | undefined;
+    readonly snapshot?: {
+        readonly mode: 'full' | 'delta';
+        readonly fullEvery: number;
+        readonly keepFulls: number;
+        readonly store: 'auto';
+        readonly maxInlineBytes: number;
+    };
+}
+
+/** Browser-safe service contracts. Server adapters and fixture Layers share
+ * these exact Tags; imports of server-owned data shapes are erased types. */
+export declare class RoomCheckpointPort extends RoomCheckpointPort_base {
+}
+
+declare const RoomCheckpointPort_base: Context.ServiceClass<RoomCheckpointPort, "@voltro/RoomCheckpointPort", {
+    commit(checkpoint: RoomCheckpoint): Effect.Effect<void, ProtocolError | RoomHibernatePending>;
+    load(roomId: string, tenantId: string): Effect.Effect<RoomCheckpoint | null, ProtocolError>;
+    pending(roomId: string, tenantId: string, limit: number): Effect.Effect<ReadonlyArray<RoomOutboxCommand>, ProtocolError>;
+    acknowledge(roomId: string, tenantId: string, requestId: string): Effect.Effect<void, ProtocolError>;
+    /** Optional: retire a command whose handler keeps failing (marked failed, no longer pending).
+     * Without it, a failing command is retried on every turn. */
+    readonly park?: (roomId: string, tenantId: string, requestId: string) => Effect.Effect<void, ProtocolError>;
+}>;
+
+export declare interface RoomCloseAllInput {
+    readonly tenantId: string;
+    readonly reason: string;
+    readonly limit?: number;
+    readonly after?: string;
+}
+
+export declare interface RoomCloseAllReceipt {
+    readonly rooms: number;
+    readonly kicked: number;
+    readonly next: string | null;
+}
+
+/** Every admitted session of one Room (a maintenance drain); `reason` is shown to each player. */
+export declare interface RoomCloseInput {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly reason: string;
+}
+
+export declare type RoomControlError = ProtocolError | BudgetExceeded | NotRoomMember | RoomAuthoringError | RoomForbidden | RoomFull | RoomGone | RoomLocked | RoomPoolWaking | RoomsClosed | SeatExpired;
+
+declare interface RoomCreation {
+    /** Server-owned stable retry key. Requires staged creation; never a client
+     * permission or a request to resurrect a retired Room. */
+    readonly creationKey?: string;
+    /** Server-owned explicit QA override; canonical room ownership otherwise. */
+    readonly pool?: string | undefined;
+    readonly tenantId: string;
+    readonly name: string;
+    readonly maxClients: number;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly private: boolean;
+    readonly options?: unknown;
+    /** Remains unavailable until its first authoritative checkpoint commits. */
+    readonly staged?: boolean;
+}
+
+declare type RoomDirectoryError = ProtocolError | BudgetExceeded | RoomForbidden | RoomFull | RoomGone | RoomPoolWaking;
+
+declare interface RoomDirectoryListing {
+    readonly pool?: string | undefined;
+    readonly id: string;
+    readonly name: string;
+    readonly hostId: string;
+    readonly tenantId: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly clients: number;
+    readonly maxClients: number;
+    readonly locked: boolean;
+    readonly epoch: number;
+}
+
+export declare class RoomDirectoryPort extends RoomDirectoryPort_base {
+}
+
+declare const RoomDirectoryPort_base: Context.ServiceClass<RoomDirectoryPort, "@voltro/RoomDirectoryPort", {
+    register(input: RoomHostRegistration): Effect.Effect<RoomHostListing, RoomDirectoryError>;
+    heartbeat(hostId: string, load: RoomHostRegistration["load"]): Effect.Effect<void, RoomDirectoryError>;
+    setReady(hostId: string, ready: boolean): Effect.Effect<void, RoomDirectoryError>;
+    hosts(region: string, pool?: string): Effect.Effect<ReadonlyArray<RoomHostListing>, RoomDirectoryError>;
+    observeOwnership(roomId: string, tenantId: string): Effect.Effect<RoomOwnershipObservation | null, RoomDirectoryError>;
+    selectHost(region: string, routing?: RoomHostRouting): Effect.Effect<RoomHostListing, RoomDirectoryError>;
+    createOwnedRoom(hostId: string, input: RoomCreation): Effect.Effect<RoomDirectoryListing, RoomDirectoryError>;
+    abandonCreation(hostId: string, roomId: string, tenantId: string): Effect.Effect<void, RoomDirectoryError>;
+    unregister(hostId: string): Effect.Effect<void, RoomDirectoryError>;
+    list(tenantId: string, name: string, limit: number): Effect.Effect<ReadonlyArray<RoomDirectoryListing>, RoomDirectoryError>;
+    setListing(hostId: string, roomId: string, tenantId: string, epoch: number, listing: {
+        readonly metadata: Readonly<Record<string, unknown>>;
+        readonly locked: boolean;
+        readonly private: boolean;
+    }): Effect.Effect<void, RoomDirectoryError>;
+}>;
+
+/** Exact last committed boundary supplied by the quiesced local owner. No client RPC. */
+declare type RoomDrainHandoff = RoomDrainRoom & ({
+    readonly mode: 'state-sync';
+    readonly revision: number;
+} | {
+    readonly mode: 'lockstep';
+    readonly admissionDigest: string;
+    readonly journalDigest: string | null;
+});
+
+declare interface RoomDrainReceipt {
+    readonly hostId: string;
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly epoch: number;
+    readonly state: 'orphaned';
+    readonly tick: number;
+}
+
+declare interface RoomDrainRoom {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly epoch: number;
+    readonly tick: number;
+}
+
+declare interface RoomErasureInput {
+    readonly roomId: string;
+    readonly tenantId: string;
+    /** The caller retains this identity across uncertain outcomes and restart. */
+    readonly requestId: string;
+}
+
+/** Whole selected room, not a subject-selection/export policy. */
+export declare class RoomErasurePort extends RoomErasurePort_base {
+}
+
+declare const RoomErasurePort_base: Context.ServiceClass<RoomErasurePort, "@voltro/RoomErasurePort", {
+    erase(input: RoomErasureInput): Effect.Effect<void, ProtocolError>;
+}>;
+
+/** App-owned work spawned by room commands needs its own durable withdrawal.
+ * A dispatch ACK or actor shutdown does not establish that this work ended. */
+export declare class RoomExternalWorkWithdrawalPort extends RoomExternalWorkWithdrawalPort_base {
+}
+
+declare const RoomExternalWorkWithdrawalPort_base: Context.ServiceClass<RoomExternalWorkWithdrawalPort, "@voltro/RoomExternalWorkWithdrawalPort", {
+    withdraw(input: RoomHostWithdrawalInput & {
+        readonly requestId: string;
+    }): Effect.Effect<void, ProtocolError>;
+}>;
+
+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>;
+
+export declare interface RoomGeometryRollbackInput {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly request: RoomGeometryRollbackRequest;
+}
+
+/** Administrative intention only. World/version/owner/authority/baseline/patch
+ * are resolved by the actual Host/source, never accepted as client state. */
+declare interface RoomGeometryRollbackRequest {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+    /** The actor whose changes are undone; `null` undoes every actor's changes (chunk reset to its static baseline). */
+    readonly target: GeometryPersistenceSubject | null;
+    readonly requestId: string;
+}
+
+declare class RoomGone extends RoomGone_base {
+}
+
+declare const RoomGone_base: Schema.Class<RoomGone, Schema.TaggedStruct<"RoomGone", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+/** Durable work/capacity is still owned; this is backpressure, not completion. */
+declare class RoomHibernatePending extends RoomHibernatePending_base {
+}
+
+declare const RoomHibernatePending_base: Schema.Class<RoomHibernatePending, Schema.TaggedStruct<"RoomHibernatePending", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+export declare class RoomHostAdoptionPort extends RoomHostAdoptionPort_base {
+}
+
+declare const RoomHostAdoptionPort_base: Context.ServiceClass<RoomHostAdoptionPort, "@voltro/RoomHostAdoptionPort", {
+    adopt(hostId: string, roomId: string, tenantId: string, priorEpoch: number): Effect.Effect<void, ProtocolError>;
+}>;
+
+/** API-to-host transport seam. The target executes on its existing controller;
+ * resolved Subjects are trusted server inputs, never player-supplied authority. */
+export declare class RoomHostControlPort extends RoomHostControlPort_base {
+}
+
+declare const RoomHostControlPort_base: Context.ServiceClass<RoomHostControlPort, "@voltro/RoomHostControlPort", {
+    /** `attributes`: app data the API resolved for this seat; the Host signs it into the seat. */
+    reserve(hostId: string, input: ReserveRoomInput, subject: Subject, attributes?: RoomSeatAttributes): Effect.Effect<RoomReservation, RoomControlError>;
+    resume(hostId: string, sessionId: string, subject: Subject, attributes?: RoomSeatAttributes): Effect.Effect<RoomReservation, RoomControlError>;
+    leave(hostId: string, sessionId: string, token: Uint8Array, subject: Subject): Effect.Effect<{
+        readonly ok: true;
+    }, RoomControlError>;
+}>;
+
+declare type RoomHostDrainError = ProtocolError | BudgetExceeded | RoomForbidden | RoomGone;
+
+export declare class RoomHostDrainPort extends RoomHostDrainPort_base {
+}
+
+declare const RoomHostDrainPort_base: Context.ServiceClass<RoomHostDrainPort, "@voltro/RoomHostDrainPort", {
+    /** Irreversibly fences new SQL routing for this exact registered process. */
+    begin(): Effect.Effect<void, RoomHostDrainError>;
+    /** Requires the caller to have stopped simulation/session mutation first.
+     * This only commits SQL handoff; it neither stops the actor nor migrates clients. */
+    handoff(input: RoomDrainHandoff): Effect.Effect<RoomDrainReceipt, RoomHostDrainError>;
+}>;
+
+/** API-to-host operator kick on the owning Host's existing controller. */
+export declare class RoomHostKickPort extends RoomHostKickPort_base {
+}
+
+declare const RoomHostKickPort_base: Context.ServiceClass<RoomHostKickPort, "@voltro/RoomHostKickPort", {
+    kick(hostId: string, input: RoomKickInput): Effect.Effect<RoomKickReceipt, RoomControlError>;
+    close(hostId: string, input: RoomCloseInput): Effect.Effect<RoomKickReceipt, RoomControlError>;
+}>;
+
+declare interface RoomHostListing {
+    readonly pool?: string | undefined;
+    readonly clientCapacity?: number | undefined;
+    readonly id: string;
+    readonly address: string;
+    readonly webTransportAddress?: string | undefined;
+    readonly webTransportCertificateHash?: string | undefined;
+    readonly region: string;
+    readonly capacity: number;
+    readonly rooms: number;
+    readonly clients: number;
+    readonly cpu: number;
+    readonly lastHeartbeatAt: number;
+    /** Last registered SQL routing admission, not proof of membership liveness. */
+    readonly ready: boolean;
+    /** Process identity, never a sender-clock liveness deadline. */
+    readonly membership?: {
+        readonly instanceId: string | undefined;
+        readonly startedAt: number;
+    } | undefined;
+}
+
+declare interface RoomHostObservation {
+    readonly hostId: string;
+    readonly state: 'observing' | 'presumed-unreachable';
+    readonly sqlSilenceMs: number;
+    readonly membershipSilenceMs: number;
+}
+
+declare interface RoomHostRegistration {
+    readonly pool?: string | undefined;
+    readonly clientCapacity?: number | undefined;
+    readonly address: string;
+    readonly webTransportAddress?: string | undefined;
+    readonly webTransportCertificateHash?: string | undefined;
+    readonly region: string;
+    readonly capacity: number;
+    readonly load: {
+        readonly rooms: number;
+        readonly clients: number;
+        readonly cpu: number;
+    };
+    readonly ready?: boolean;
+    readonly membership?: {
+        readonly instanceId: string | undefined;
+        readonly startedAt: number;
+    } | undefined;
+}
+
+declare interface RoomHostRouting {
+    readonly name: string;
+    readonly tenantId: string;
+    readonly pool?: string | undefined;
+}
+
+export declare type RoomHostWithdrawalInput = typeof RoomHostWithdrawalInputSchema.Type;
+
+/** Trusted outside-tick withdrawal, never player-supplied state or authority. */
+declare const RoomHostWithdrawalInputSchema: Schema.Struct<{
+    readonly roomId: Schema.String;
+    readonly tenantId: Schema.String;
+    readonly priorEpoch: Schema.Int;
+    readonly withdrawnEpoch: Schema.Int;
+}>;
+
+/** Trusted coordinator waits for the exact former owner's local actor/session/
+ * command lane after a newer SQL withdrawal. No player RPC mounts this port. */
+export declare class RoomHostWithdrawalPort extends RoomHostWithdrawalPort_base {
+}
+
+declare const RoomHostWithdrawalPort_base: Context.ServiceClass<RoomHostWithdrawalPort, "@voltro/RoomHostWithdrawalPort", {
+    withdraw(hostId: string, input: RoomHostWithdrawalInput): Effect.Effect<void, ProtocolError>;
+}>;
+
+/** Captured outside the tick and stored with the exact state it describes. */
+declare interface RoomInputReceipt {
+    readonly sessionId: string;
+    readonly subjectId: string | null;
+    readonly lastAppliedSeq: number;
+    /** Intentionally discarded pending World input; never an applied ACK. */
+    readonly discardedThrough?: number;
+}
+
+export declare interface RoomKickInput {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly subjectId: string;
+    readonly reason: string;
+}
+
+export declare interface RoomKickReceipt {
+    readonly kicked: number;
+}
+
+/** A Room's own listing; scalar metadata only, at most 16 keys and 2 KiB. */
+declare interface RoomListing {
+    readonly metadata?: Readonly<Record<string, RoomScalar>>;
+    readonly private?: boolean;
+    readonly locked?: boolean;
+}
+
+declare class RoomLocked extends RoomLocked_base {
+}
+
+declare const RoomLocked_base: Schema.Class<RoomLocked, Schema.TaggedStruct<"RoomLocked", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare interface RoomLockstepAdmission {
+    readonly version: 1;
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly ownerEpoch: number;
+    readonly hostId: string;
+    readonly initial: {
+        readonly requestId: string;
+        readonly creatorSubjectId: string;
+        readonly name: string;
+        readonly seed: number;
+        readonly options: string;
+        readonly stateSchemaHash: number;
+        readonly inputSchemaHash: number;
+    };
+    readonly adoption: {
+        readonly requestId: string;
+        readonly priorEpoch: number;
+    } | null;
+    readonly digest: string;
+}
+
+/** Trusted complete outside-tick SQL creation capability, never a player state RPC. */
+export declare class RoomLockstepAdmissionPort extends RoomLockstepAdmissionPort_base {
+}
+
+declare const RoomLockstepAdmissionPort_base: Context.ServiceClass<RoomLockstepAdmissionPort, "@voltro/RoomLockstepAdmissionPort", {
+    prepare(input: RoomLockstepCreation): Effect.Effect<RoomLockstepAdmission, ProtocolError>;
+    publish(scope: RoomLockstepRosterScope): Effect.Effect<RoomLockstepAdmission, ProtocolError>;
+    load(scope: RoomLockstepRosterScope): Effect.Effect<RoomLockstepAdmission | null, ProtocolError>;
+    adopt(scope: RoomLockstepRosterScope, priorEpoch: number, requestId: string): Effect.Effect<RoomLockstepAdmission, ProtocolError>;
+    exportSubject(scope: RoomLockstepRosterScope, subjectId: string): Effect.Effect<RoomLockstepCreationExport | null, ProtocolError>;
+    erase(scope: RoomLockstepRosterScope, requestId: string): Effect.Effect<void, ProtocolError>;
+}>;
+
+declare interface RoomLockstepCreation extends RoomLockstepRosterScope {
+    readonly requestId: string;
+    readonly creatorSubjectId: string;
+    readonly seed: number;
+    readonly options: unknown;
+}
+
+declare interface RoomLockstepCreationExport {
+    readonly roomId: string;
+    readonly name: string;
+    readonly requestId: string;
+    readonly seed: number;
+    readonly stateSchemaHash: number;
+    readonly inputSchemaHash: number;
+}
+
+declare interface RoomLockstepJournal {
+    /** 1: Start roster only. 2: adds `joins`; every tick's matrix covers the roster at that tick. */
+    readonly version: 1 | 2;
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly ownerEpoch: number;
+    readonly hostId: string;
+    readonly initial: {
+        readonly requestId: string;
+        readonly seed: number;
+        readonly options: string;
+        readonly stateSchemaHash: number;
+        readonly inputSchemaHash: number;
+        readonly players: ReadonlyArray<{
+            readonly slot: number;
+            readonly playerId: number;
+            readonly subjectId: string;
+            readonly sessionId: string;
+        }>;
+    };
+    readonly adoption: {
+        readonly requestId: string;
+        readonly priorEpoch: number;
+    } | null;
+    readonly ticks: ReadonlyArray<{
+        readonly tick: number;
+        readonly requestId: string;
+        readonly inputs: ReadonlyArray<string>;
+    }>;
+    readonly joins?: ReadonlyArray<RoomLockstepJournalJoin>;
+    readonly digest: string;
+}
+
+declare interface RoomLockstepJournalAppend extends RoomLockstepRosterScope {
+    readonly requestId: string;
+    readonly tick: number;
+    readonly inputs: ReadonlyArray<Uint8Array>;
+}
+
+/** A player admitted after Start (late join), effective from `tick`. Version 2 journals only. */
+declare interface RoomLockstepJournalJoin {
+    readonly tick: number;
+    readonly requestId: string;
+    readonly slot: number;
+    readonly playerId: number;
+    readonly subjectId: string;
+    readonly sessionId: string;
+}
+
+/** Admit a player after Start, effective from `tick` (ahead of every committed matrix). */
+declare interface RoomLockstepJournalJoinInput extends RoomLockstepRosterScope {
+    readonly requestId: string;
+    readonly tick: number;
+    readonly player: RoomLockstepJournalPlayer;
+}
+
+declare interface RoomLockstepJournalPlayer {
+    readonly slot: number;
+    readonly playerId: number;
+    readonly actualSession: unknown;
+}
+
+/** Trusted server capability, not a player RPC or inspection authority. */
+export declare class RoomLockstepJournalPort extends RoomLockstepJournalPort_base {
+}
+
+declare const RoomLockstepJournalPort_base: Context.ServiceClass<RoomLockstepJournalPort, "@voltro/RoomLockstepJournalPort", {
+    initialize(input: RoomLockstepJournalStart): Effect.Effect<RoomLockstepJournal, ProtocolError>;
+    append(input: RoomLockstepJournalAppend): Effect.Effect<RoomLockstepJournal, ProtocolError>;
+    /** Late join (version-2 journal). Optional: a journal without it refuses late players. */
+    readonly join?: (input: RoomLockstepJournalJoinInput) => Effect.Effect<RoomLockstepJournal, ProtocolError>;
+    load(scope: RoomLockstepRosterScope): Effect.Effect<RoomLockstepJournal | null, ProtocolError>;
+    adopt(scope: RoomLockstepRosterScope, priorEpoch: number, requestId: string): Effect.Effect<RoomLockstepJournal, ProtocolError>;
+    exportSubject(scope: RoomLockstepRosterScope, subjectId: string): Effect.Effect<RoomLockstepJournalSubjectExport, ProtocolError>;
+    erase(scope: RoomLockstepRosterScope, requestId: string): Effect.Effect<void, ProtocolError>;
+}>;
+
+declare interface RoomLockstepJournalStart extends RoomLockstepRosterScope {
+    readonly requestId: string;
+    readonly seed: number;
+    readonly options: unknown;
+    readonly players: ReadonlyArray<RoomLockstepJournalPlayer>;
+}
+
+declare interface RoomLockstepJournalSubjectExport {
+    readonly roomId: string;
+    readonly inputs: ReadonlyArray<{
+        readonly tick: number;
+        readonly playerId: number;
+        readonly input: unknown;
+    }>;
+}
+
+declare interface RoomLockstepRecoveryTruth {
+    readonly admission: RoomLockstepAdmission;
+    readonly journal: RoomLockstepJournal | null;
+    readonly options: unknown;
+}
+
+declare interface RoomLockstepRosterScope {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly epoch: number;
+}
+
+declare interface RoomLockstepTerminal extends RoomLockstepRosterScope {
+    readonly disposition: 'faulted' | 'disposed';
+}
+
+/** Outside-tick lifecycle commit after actual Session/native withdrawal. Retains
+ * SQL creation and input truth; this is neither a checkpoint nor an erase. */
+export declare class RoomLockstepTerminalPort extends RoomLockstepTerminalPort_base {
+}
+
+declare const RoomLockstepTerminalPort_base: Context.ServiceClass<RoomLockstepTerminalPort, "@voltro/RoomLockstepTerminalPort", {
+    terminate(input: RoomLockstepTerminal): Effect.Effect<RoomLockstepTerminalReceipt, ProtocolError>;
+}>;
+
+declare interface RoomLockstepTerminalReceipt extends RoomLockstepTerminal {
+    readonly hostId: string;
+}
+
+export declare interface RoomMatchPreparation {
+    readonly requestId: string;
+    readonly room: string;
+    readonly options: unknown;
+    readonly pool?: string;
+}
+
+export declare interface RoomMatchReceipt {
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+/** Server-only operator moderation over the installed API binding: finds the owning
+ * Host and kicks. Callers admit their own staff authority first (`@voltro/plugin-gm`). */
+export declare interface RoomModerationService {
+    kick(input: RoomKickInput): Effect.Effect<RoomKickReceipt, RoomControlError>;
+    /** Kicks every session of one Room. */
+    close(input: RoomCloseInput): Effect.Effect<RoomKickReceipt, RoomControlError>;
+    /** Drain: closes the tenant's live Rooms in Room ID order (pair it with a closed reservation
+     * `admission`, or players join again). At most `limit` Rooms per call (default 256, max 1024);
+     * pass the receipt's `next` as `after` until it is `null`. */
+    closeAll(input: RoomCloseAllInput): Effect.Effect<RoomCloseAllReceipt, RoomControlError>;
+    /** Griefing rollback: undoes one player's geometry edits in one chunk of a live Room, as `staff`.
+     * The owning Host re-resolves the staff identity and asks the app's rollback policy. Optional:
+     * bindings without geometry administration leave it out. */
+    readonly rollbackGeometry?: (input: RoomGeometryRollbackInput, staff: Subject) => Effect.Effect<void, RoomControlError>;
+    /** One player's access changed before its deadline (a refunded period of game time): asks the
+     * reservation admission again now for their connected seats that carry a deadline and kicks
+     * them on a refusal. Bindings without an admission check nothing. */
+    readonly recheckAccess?: (input: RoomAccessRecheckInput) => Effect.Effect<RoomAccessRecheckReceipt, RoomControlError>;
+}
+
+declare interface RoomOrphanResult {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly epoch: number;
+    readonly state: 'orphaned' | 'disposed';
+}
+
+declare interface RoomOutboxCommand {
+    readonly requestId: string;
+    readonly kind: 'publish' | 'run';
+    readonly name: string;
+    readonly payload: unknown;
+    readonly key?: string;
+}
+
+/** SQL ownership observation, never a transport or process-liveness assertion. */
+declare interface RoomOwnershipObservation {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly hostId: string | null;
+    readonly epoch: number;
+    readonly state: 'creating' | 'live' | 'orphaned' | 'faulted' | 'disposed' | 'hibernating' | 'hibernated';
+}
+
+/** 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 interface RoomPublicEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly clients: number;
+    readonly maxClients: number;
+    readonly locked: boolean;
+}
+
+declare interface RoomReaperInput {
+    readonly hostId?: string | undefined;
+    readonly afterHostId?: string | undefined;
+    readonly afterRoomId?: string;
+}
+
+export declare class RoomReaperPort extends RoomReaperPort_base {
+}
+
+declare const RoomReaperPort_base: Context.ServiceClass<RoomReaperPort, "@voltro/RoomReaperPort", {
+    run(input: RoomReaperInput): Effect.Effect<RoomReaperReport, ProtocolError | BudgetExceeded>;
+}>;
+
+declare interface RoomReaperReport {
+    readonly hosts: ReadonlyArray<{
+        readonly hostId: string;
+        readonly state: 'observing' | 'presumed-unreachable' | 'untracked' | 'failed';
+        readonly rooms: ReadonlyArray<RoomReaperRoomResult>;
+        readonly nextAfterRoom: string | null;
+    }>;
+    readonly nextAfterHost: string | null;
+}
+
+declare interface RoomReaperRoomResult {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly state: 'disposed' | 'adopted' | 'waiting-target' | 'waiting-observation' | 'failed';
+}
+
+declare type RoomRecoveryClaim = RoomRecoveryClaimBase & ({
+    readonly mode: 'state-sync';
+    readonly checkpoint: RoomCheckpoint;
+} | {
+    readonly mode: 'lockstep';
+    readonly checkpoint: null;
+    readonly lockstep: RoomLockstepRecoveryTruth;
+});
+
+declare interface RoomRecoveryClaimBase {
+    readonly listing: RoomDirectoryListing;
+    readonly options: unknown;
+    readonly private: boolean;
+    /** Actual retained durable progress only, never an estimate of lost ticks. */
+    readonly recoveredTick: number;
+    readonly ticksLost: null;
+}
+
+/** Trusted outside-tick control, never a player RPC or a death certificate. */
+export declare class RoomRecoveryPort extends RoomRecoveryPort_base {
+}
+
+declare const RoomRecoveryPort_base: Context.ServiceClass<RoomRecoveryPort, "@voltro/RoomRecoveryPort", {
+    observe(hostId: string): Effect.Effect<RoomHostObservation, RoomDirectoryError>;
+    orphan(hostId: string, roomId: string, tenantId: string, epoch: number): Effect.Effect<RoomOrphanResult, RoomDirectoryError>;
+    claim(hostId: string, roomId: string, tenantId: string, priorEpoch: number): Effect.Effect<RoomRecoveryClaim, RoomDirectoryError>;
+}>;
+
+/** Browser-safe trusted server contract. No player mutation or storage adapter
+ * is imported at value level; replacement services use this exact Tag. */
+export declare class RoomReplayPort extends RoomReplayPort_base {
+}
+
+declare const RoomReplayPort_base: Context.ServiceClass<RoomReplayPort, "@voltro/RoomReplayPort", {
+    publish(input: RoomReplayPublish): Effect.Effect<RoomStoredReplay, ProtocolError>;
+    load(scope: RoomReplayScope): Effect.Effect<Uint8Array, ProtocolError>;
+    erase(scope: RoomReplayScope, requestId: string): Effect.Effect<void, ProtocolError>;
+    expire(scope: RoomReplayScope, requestId: string): Effect.Effect<void, ProtocolError>;
+    subjectRooms(request: PluginPrivacyRequest): Effect.Effect<ReadonlyArray<string>, ProtocolError>;
+    eraseSubject(request: PluginPrivacyRequest): Effect.Effect<void, ProtocolError>;
+    exportSubject(request: PluginPrivacyRequest, roomId?: string): Effect.Effect<ReadonlyArray<RoomStoredReplay>, ProtocolError>;
+}>;
+
+declare interface RoomReplayPublish extends RoomReplayScope {
+    readonly roomId: string;
+    readonly roomName: string;
+    readonly matchId: string;
+    readonly participants: ReadonlyArray<string>;
+    readonly visibility: 'private' | 'unlisted' | 'public';
+    readonly expiresAtMs: number | null;
+    readonly bytes: Uint8Array;
+}
+
+declare interface RoomReplayScope {
+    readonly tenantId: string;
+    readonly replayId: string;
+}
+
+declare interface RoomReservation {
+    readonly roomId: string;
+    readonly sessionId: string;
+    readonly token: Uint8Array;
+    readonly address: string;
+    readonly endpoints?: RoomTransportEndpoints | undefined;
+    readonly transport: readonly ['ws'] | readonly ['ws', 'wt'];
+    readonly expiresAt: number;
+}
+
+/** The game-stack reservation seam. Other systems receive the same service
+ * when the default SQL/host implementation is replaced by an application. */
+export declare class RoomReservePort extends RoomReservePort_base {
+}
+
+declare const RoomReservePort_base: Context.ServiceClass<RoomReservePort, "@voltro/RoomReservePort", {
+    reserve(input: ReserveRoomInput, subject: Subject, attributes?: RoomSeatAttributes): Effect.Effect<RoomReservation, RoomControlError>;
+    resume(sessionId: string, subject: Subject, attributes?: RoomSeatAttributes): Effect.Effect<RoomReservation, RoomControlError>;
+    leave(sessionId: string, token: Uint8Array, subject: Subject): Effect.Effect<{
+        readonly ok: true;
+    }, RoomControlError>;
+    list(name: string, subject: Subject, limit?: number): Effect.Effect<ReadonlyArray<RoomPublicEntry>, RoomControlError>;
+    /** A private match Room created once per server request: a retry by any member (each
+     * passes the Room guards) returns the same Room. Players then take Seats with `joinById`. */
+    readonly prepareMatch?: (input: RoomMatchPreparation, subject: Subject) => Effect.Effect<RoomMatchReceipt, RoomControlError>;
+}>;
+
+declare type RoomScalar = string | number | boolean | null;
+
+declare interface RoomScheduleSnapshot {
+    readonly label: string;
+    readonly remainingMs: number;
+    readonly intervalMs: number | null;
+}
+
+/** 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>;
+
+/** App data for one seat, resolved by the API when the seat is reserved (`seatAttributes`) and signed
+ * into it; scalars only, at most 16 keys and 2 KiB. */
+declare type RoomSeatAttributes = Readonly<Record<string, RoomScalar>>;
+
+/** Allocate/capture this actual owner before admission. A rejected start must
+ * retain its true process/resources for stop, including late acquisition.
+ * Successful start means OS birth only, never private Ready or Seat admission. */
+export declare interface RoomSidecarNativeProcessPort {
+    start(input: RoomSidecarProcessStart): Promise<void>;
+    stop(): Promise<RoomSidecarProcessExit>;
+    waitClosed(): Promise<RoomSidecarProcessExit>;
+}
+
+/** Pure lifecycle declarations only. No native import, socket, process or boot
+ * side effect. Not-started differs from an actual observed zero exit. */
+export declare type RoomSidecarProcessExit = {
+    readonly kind: 'not-started';
+} | {
+    readonly kind: 'exited';
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+};
+
+export declare interface RoomSidecarProcessStart {
+    readonly configurationPath: string;
+    readonly logPath: string;
+    readonly signal: AbortSignal;
+}
+
+declare interface RoomSnapshotBlobInput extends RoomSnapshotBlobScope {
+    readonly claimId: string;
+    readonly bytes: Uint8Array;
+}
+
+/** Trusted S2 materialization seam. SQL index/admission must authorize scope;
+ * it is never exposed through player intents or the actor tick context. */
+export declare class RoomSnapshotBlobPort extends RoomSnapshotBlobPort_base {
+}
+
+declare const RoomSnapshotBlobPort_base: Context.ServiceClass<RoomSnapshotBlobPort, "@voltro/RoomSnapshotBlobPort", {
+    recover(input: RoomSnapshotBlobRecoveryInput): Effect.Effect<RoomSnapshotBlobRecovery, ProtocolError>;
+    write(input: RoomSnapshotBlobInput): Effect.Effect<RoomSnapshotBlobReference, ProtocolError>;
+    read(reference: RoomSnapshotBlobReference, expected: RoomSnapshotBlobScope): Effect.Effect<Uint8Array, ProtocolError>;
+    /** Idempotently release this exact claim only; other claims must survive. */
+    release(reference: RoomSnapshotBlobReference, expected: RoomSnapshotBlobScope): Effect.Effect<void, ProtocolError>;
+}>;
+
+declare type RoomSnapshotBlobRecovery = {
+    readonly state: 'pending';
+} | {
+    readonly state: 'ready' | 'released';
+    readonly reference: RoomSnapshotBlobReference;
+};
+
+declare interface RoomSnapshotBlobRecoveryInput extends RoomSnapshotBlobScope {
+    readonly claimId: string;
+    readonly size: number;
+    readonly checksum: string;
+}
+
+declare interface RoomSnapshotBlobReference extends RoomSnapshotBlobScope {
+    readonly version: 1;
+    readonly refId: string;
+    readonly claim: string;
+    readonly size: number;
+    readonly checksum: string;
+}
+
+declare interface RoomSnapshotBlobScope {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly epoch: number;
+    readonly revision: number;
+}
+
+/** Inventory of actual implemented exports. `systemContract.test.ts` runs it
+ * through systemContractConformance with measured stages, table privacy for all
+ * eight tables and the five inspect endpoints. */
+export declare const roomsSystemContractManifest: Readonly<{
+    slots: Readonly<{
+        'lockstep.reconnectPolicy': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.playerId': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.start': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.seed': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.inputPrediction': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.hash': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.stallPolicy': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.onDesync': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'lockstep.refereeLag': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        selectHost: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'seatToken.sign': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        'seatToken.verify': {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        view: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        budgets: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        reconnectPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        spectatorPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        snapshotPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        snapshotBudget: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    }>;
+    ports: Readonly<{
+        hostDrain: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        lockstepTerminal: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        lockstepAdmission: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        lockstepJournal: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        worldClientControl: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        reserve: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        subjectPrivacy: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        checkpoint: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        snapshotBlob: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        replay: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        directory: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        application: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        recovery: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        reaper: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        adoption: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        control: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        kick: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        ownerWithdrawal: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        externalWithdrawal: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        erasure: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    }>;
+    events: readonly string[];
+}>;
+
+declare interface RoomStoredReplay {
+    readonly replayId: string;
+    readonly roomId: string;
+    readonly roomName: string;
+    readonly matchId: string;
+    readonly visibility: RoomReplayPublish['visibility'];
+    readonly expiresAtMs: number | null;
+    readonly durationMs: number;
+    readonly size: number;
+    readonly schemaHash: number;
+}
+
+/** Coordinated state/command/session withdrawal, not raw seat-row deletion.
+ * The trusted caller authorizes the target and owns durable request recovery. */
+export declare class RoomSubjectPrivacyPort extends RoomSubjectPrivacyPort_base {
+}
+
+declare const RoomSubjectPrivacyPort_base: Context.ServiceClass<RoomSubjectPrivacyPort, "@voltro/RoomSubjectPrivacyPort", {
+    erase(request: PluginPrivacyRequest): Effect.Effect<void, ProtocolError>;
+    export(request: PluginPrivacyRequest): Effect.Effect<unknown, ProtocolError>;
+}>;
+
+/** Public routing metadata only. Neither endpoint conveys seat authority. */
+declare interface RoomTransportEndpoints {
+    readonly ws: string;
+    readonly wt?: string | undefined;
+    /** Base64 SHA-256 of a short-lived development certificate the browser pins
+     * through `serverCertificateHashes`. Absent for a publicly trusted certificate. */
+    readonly wtCertificateHash?: string | undefined;
+}
+
+declare interface RoomWorldReceipt {
+    readonly requestId: string;
+    readonly operation: 'enter' | 'exit' | 'ghost';
+    readonly fingerprint: string;
+    readonly projection?: {
+        readonly entity: unknown;
+        readonly location: WorldEntityLocation;
+        readonly expiresAt?: number;
+    };
+}
+
+declare class SeatExpired extends SeatExpired_base {
+}
+
+declare const SeatExpired_base: Schema.Class<SeatExpired, Schema.TaggedStruct<"SeatExpired", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+declare interface WorldClientControl {
+    /** Own active transition for the caller's current connection; no history or preparation. */
+    readonly pending?: (input: {
+        readonly entityId: string;
+        readonly roomId: string;
+    }, subject: Subject) => Effect.Effect<WorldClientReceipt | null, ProtocolError>;
+    readonly join?: (worldId: string, subject: Subject) => Effect.Effect<WorldJoinResult, ProtocolError>;
+    readonly follow?: (requestId: string, subject: Subject) => Effect.Effect<RoomReservation, ProtocolError>;
+    readonly reservation?: (requestId: string, subject: Subject) => Effect.Effect<RoomReservation, ProtocolError>;
+    prepare(requestId: string, intention: WorldTransitionRequest, subject: Subject): Effect.Effect<WorldClientTicket, ProtocolError | WorldTransitionCooldown>;
+    observe(requestId: string, subject: Subject): Effect.Effect<WorldClientReceipt, ProtocolError>;
+    commit(ticket: WorldClientTicket, subject: Subject): Effect.Effect<WorldClientReceipt, ProtocolError>;
+    cancel(requestId: string, subject: Subject): Effect.Effect<WorldClientReceipt, ProtocolError>;
+}
+
+/** Authenticated API seam; default physical/SQL implementation stays explicit. */
+export declare class WorldClientControlPort extends WorldClientControlPort_base {
+}
+
+declare const WorldClientControlPort_base: Context.ServiceClass<WorldClientControlPort, "@voltro/WorldClientControlPort", WorldClientControl>;
+
+declare interface WorldClientLocation {
+    readonly worldId: string;
+    readonly cellId: string;
+    readonly layer: number;
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+declare interface WorldClientReceipt {
+    readonly ticket: WorldClientTicket;
+    readonly phase: 'prepared' | 'committed' | 'settled' | 'rolledBack';
+    readonly entityRevision: number | null;
+}
+
+/** Authenticated server preparation, never player-supplied authority or state. */
+declare interface WorldClientTicket {
+    readonly requestId: string;
+    readonly transitionId: string;
+    readonly mode: 'seamless' | 'portal';
+    readonly target: WorldClientLocation;
+}
+
+declare interface WorldEntityLocation {
+    readonly worldId: string;
+    readonly zoneId: string;
+    readonly at: WorldPoint;
+    readonly layer: number;
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+declare interface WorldJoinResult {
+    /** The server-owned entity this player controls (`intention.entityId` of later moves). */
+    readonly entityId: string;
+    readonly reservation: RoomReservation;
+}
+
+declare type WorldPoint = readonly [x: number, y: number];
+
+/** 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>;
+
+declare type WorldTransitionRequest = typeof WorldTransitionRequestSchema.Type;
+
+declare const WorldTransitionRequestSchema: 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">>;
+    }>;
+}>;
+
+export { }