@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/testingServer.d.ts

@@ -0,0 +1,4060 @@
+import { Context } from 'effect';
+import { DeclaredAccess } from '@voltro/protocol';
+import { Duration } from 'effect';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+import { PluginPrivacyRequest } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { SessionSecrets } from '@voltro/protocol/session';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare type AnySchema = Schema.Codec<unknown, unknown>;
+
+/** Configuration consumers never invoke a player callback. Its player type
+ * stays author-owned; this inventory type does not erase it into an input. */
+declare type AnyWorldDescriptor = WorldDescriptor<never>;
+
+export declare class BotClient {
+    readonly transport: RoomTransport;
+    readonly maxRetainedFrames: number;
+    private readonly received;
+    private readonly unsubscribe;
+    constructor(transport: RoomTransport, maxRetainedFrames?: number);
+    send(frame: RoomFrame): Promise<void>;
+    frames(): ReadonlyArray<RoomFrame>;
+    close(): void;
+}
+
+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 type CollisionBody2D = {
+    readonly kind: 'circle';
+    readonly radius: number;
+} | {
+    readonly kind: 'aabb';
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+};
+
+declare interface CollisionResult2D {
+    readonly transform: Transform2D;
+    readonly collided: ReadonlyArray<string>;
+    readonly iterations: number;
+}
+
+/** Compare provided observations only. Runner identity/artifacts/exit status
+ * must be established outside this pure helper before any engine claim. */
+export declare const compareSimulationConformanceTraces: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, expected: SimulationConformanceTrace, actual: SimulationConformanceTrace, offeredLimits?: SimulationConformanceLimits) => {
+    readonly scope: "provided-trace-comparison";
+    readonly ticks: number;
+    readonly comparisons: number;
+};
+
+/**
+ * A real Room actor with one real server session per player and the real
+ * client session, joined over seeded in-memory networks (`NetSim`). For example
+ * tests of Room code: inputs, state convergence and reconnects, without a Host
+ * process, SQL or sockets. Seats are an in-memory admission, not the SQL store.
+ */
+export declare const connectTestRoomClients: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(descriptor: RoomDescriptor<S, I, O>, initial: S["Type"], options: O["Type"], config: TestRoomClientsOptions) => Promise<TestRoomClients<S, I, O>>;
+
+/** Source-portable fixture construction only. It never initializes simulation
+ * state, and the entire typed matrix is captured before a conformance run. */
+export declare const createSimulationConformanceCase: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCaseOptions<I["Type"], O["Type"]>) => SimulationConformanceCase;
+
+export declare const createTestRoom: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(descriptor: RoomDescriptor<S, I, O>, initial: S["Type"], options: O["Type"], config: {
+    readonly tenantId: string;
+    readonly id?: string;
+    readonly clock?: VirtualRoomClock;
+}) => {
+    readonly actor: RoomActor<S, I, O>;
+    readonly clock: VirtualRoomClock;
+    step(milliseconds: number): number;
+};
+
+/** Whole byte/layout/count/schema admission precedes any simulation init. */
+export declare const decodeSimulationConformanceCase: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: Uint8Array, offeredLimits?: SimulationConformanceLimits) => SimulationConformanceCase;
+
+/** SCF/v1 is an offline reproducibility artifact, not a Room frame, remote
+ * authentication grant, snapshot or process-execution receipt. */
+export declare const encodeSimulationConformanceCase: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCase, offeredLimits?: SimulationConformanceLimits) => Uint8Array;
+
+export declare const fakeRoomAppCommandLayer: (overrides?: RoomAppCommandFixtureOverrides) => Layer.Layer<RoomAppCommandPort>;
+
+export declare const fakeRoomAppCommandService: (overrides?: RoomAppCommandFixtureOverrides) => Context.Service.Shape<typeof RoomAppCommandPort>;
+
+export declare const fakeRoomCheckpointLayer: (overrides?: RoomCheckpointFixtureOverrides) => Layer.Layer<RoomCheckpointPort>;
+
+export declare const fakeRoomCheckpointService: (overrides?: RoomCheckpointFixtureOverrides) => Context.Service.Shape<typeof RoomCheckpointPort>;
+
+export declare const fakeRoomDirectoryLayer: (overrides?: RoomDirectoryFixtureOverrides) => Layer.Layer<RoomDirectoryPort>;
+
+export declare const fakeRoomDirectoryService: (overrides?: RoomDirectoryFixtureOverrides) => Context.Service.Shape<typeof RoomDirectoryPort>;
+
+export declare const fakeRoomErasureLayer: (overrides?: RoomErasureFixtureOverrides) => Layer.Layer<RoomErasurePort>;
+
+export declare const fakeRoomErasureService: (overrides?: RoomErasureFixtureOverrides) => Context.Service.Shape<typeof RoomErasurePort>;
+
+export declare const fakeRoomExternalWorkWithdrawalLayer: (overrides?: RoomExternalWorkWithdrawalFixtureOverrides) => Layer.Layer<RoomExternalWorkWithdrawalPort>;
+
+export declare const fakeRoomExternalWorkWithdrawalService: (overrides?: RoomExternalWorkWithdrawalFixtureOverrides) => Context.Service.Shape<typeof RoomExternalWorkWithdrawalPort>;
+
+export declare const fakeRoomHostAdoptionLayer: (overrides?: RoomAdoptionFixtureOverrides) => Layer.Layer<RoomHostAdoptionPort>;
+
+export declare const fakeRoomHostAdoptionService: (overrides?: RoomAdoptionFixtureOverrides) => Context.Service.Shape<typeof RoomHostAdoptionPort>;
+
+export declare const fakeRoomHostControlLayer: (overrides?: RoomHostControlFixtureOverrides) => Layer.Layer<RoomHostControlPort>;
+
+export declare const fakeRoomHostControlService: (overrides?: RoomHostControlFixtureOverrides) => Context.Service.Shape<typeof RoomHostControlPort>;
+
+export declare const fakeRoomHostDrainLayer: (overrides?: RoomHostDrainFixtureOverrides) => Layer.Layer<RoomHostDrainPort>;
+
+/** Explicit replacement seam; never manufactures a successful SQL handoff. */
+export declare const fakeRoomHostDrainService: (overrides?: RoomHostDrainFixtureOverrides) => Context.Service.Shape<typeof RoomHostDrainPort>;
+
+export declare const fakeRoomHostKickLayer: (overrides?: RoomHostKickFixtureOverrides) => Layer.Layer<RoomHostKickPort>;
+
+export declare const fakeRoomHostKickService: (overrides?: RoomHostKickFixtureOverrides) => Context.Service.Shape<typeof RoomHostKickPort>;
+
+export declare const fakeRoomHostWithdrawalLayer: (overrides?: RoomHostWithdrawalFixtureOverrides) => Layer.Layer<RoomHostWithdrawalPort>;
+
+export declare const fakeRoomHostWithdrawalService: (overrides?: RoomHostWithdrawalFixtureOverrides) => Context.Service.Shape<typeof RoomHostWithdrawalPort>;
+
+export declare const fakeRoomLockstepAdmissionLayer: (overrides?: RoomLockstepAdmissionFixtureOverrides) => Layer.Layer<RoomLockstepAdmissionPort>;
+
+/** Complete failing replacement seam; no SQL/seed/identity success is fabricated. */
+export declare const fakeRoomLockstepAdmissionService: (overrides?: RoomLockstepAdmissionFixtureOverrides) => Context.Service.Shape<typeof RoomLockstepAdmissionPort>;
+
+export declare const fakeRoomLockstepJournalLayer: (overrides?: RoomLockstepJournalFixtureOverrides) => Layer.Layer<RoomLockstepJournalPort>;
+
+/** Explicit failing replacement seam, never an SQL/auth/history emulator. */
+export declare const fakeRoomLockstepJournalService: (overrides?: RoomLockstepJournalFixtureOverrides) => Context.Service.Shape<typeof RoomLockstepJournalPort>;
+
+export declare const fakeRoomLockstepTerminalLayer: (overrides?: RoomLockstepTerminalFixtureOverrides) => Layer.Layer<RoomLockstepTerminalPort>;
+
+export declare const fakeRoomLockstepTerminalService: (overrides?: RoomLockstepTerminalFixtureOverrides) => Context.Service.Shape<typeof RoomLockstepTerminalPort>;
+
+export declare const fakeRoomReaperLayer: (overrides?: RoomReaperFixtureOverrides) => Layer.Layer<RoomReaperPort>;
+
+export declare const fakeRoomReaperService: (overrides?: RoomReaperFixtureOverrides) => Context.Service.Shape<typeof RoomReaperPort>;
+
+export declare const fakeRoomRecoveryLayer: (overrides?: RoomRecoveryFixtureOverrides) => Layer.Layer<RoomRecoveryPort>;
+
+export declare const fakeRoomRecoveryService: (overrides?: RoomRecoveryFixtureOverrides) => Context.Service.Shape<typeof RoomRecoveryPort>;
+
+export declare const fakeRoomReplayLayer: (overrides?: RoomReplayFixtureOverrides) => Layer.Layer<RoomReplayPort>;
+
+export declare const fakeRoomReplayService: (overrides?: RoomReplayFixtureOverrides) => Context.Service.Shape<typeof RoomReplayPort>;
+
+export declare const fakeRoomReserveLayer: (overrides?: RoomReserveFixtureOverrides) => Layer.Layer<RoomReservePort>;
+
+/** Explicit service seam for consumers testing replacement of the reservation
+ * system. Unconfigured methods refuse; this never emulates or proves SQL/auth. */
+export declare const fakeRoomReserveService: (overrides?: RoomReserveFixtureOverrides) => Context.Service.Shape<typeof RoomReservePort>;
+
+export declare const fakeRoomSnapshotBlobLayer: (overrides?: RoomSnapshotBlobFixtureOverrides) => Layer.Layer<RoomSnapshotBlobPort>;
+
+export declare const fakeRoomSnapshotBlobService: (overrides?: RoomSnapshotBlobFixtureOverrides) => Context.Service.Shape<typeof RoomSnapshotBlobPort>;
+
+export declare const fakeRoomSubjectPrivacyLayer: (overrides?: RoomSubjectPrivacyFixtureOverrides) => Layer.Layer<RoomSubjectPrivacyPort>;
+
+export declare const fakeRoomSubjectPrivacyService: (overrides?: RoomSubjectPrivacyFixtureOverrides) => Context.Service.Shape<typeof RoomSubjectPrivacyPort>;
+
+export declare const fakeWorldClientControlLayer: (overrides?: WorldClientControlFixtureOverrides) => Layer.Layer<WorldClientControlPort>;
+
+export declare const fakeWorldClientControlService: (overrides?: WorldClientControlFixtureOverrides) => Context.Service.Shape<typeof WorldClientControlPort>;
+
+export declare const fakeWorldTransitionLayer: (overrides?: WorldTransitionFixtureOverrides) => Layer.Layer<WorldTransitionPort>;
+
+/** Fail-closed fixture. It owns no fake transition, entity or durable success. */
+export declare const fakeWorldTransitionService: (overrides?: WorldTransitionFixtureOverrides) => Context.Service.Shape<typeof WorldTransitionPort>;
+
+/** Exact reduced integer ratio over admitted coordinates/differences of magnitude <= u32.
+ * Shared 2D/3D slab arithmetic; never round a fraction before comparing it. */
+declare interface FixedSlabFraction {
+    readonly numerator: number;
+    readonly denominator: number;
+}
+
+declare interface GeometryArtifact<C extends GeometryChunk = GeometryChunk> {
+    readonly chunk: C;
+    readonly blobSha256: string;
+    /** Canonical declared content/layout, excluding actual address/version only. */
+    readonly contentSha256: string;
+    bytes(): Uint8Array;
+}
+
+declare type GeometryArtifactLimits<K extends GeometryKind> = K extends '2d-tiles' ? Partial<GeometryTileLimits> : K extends '2d-heightfield' ? Partial<GeometryHeightfieldLimits> : K extends '3d-shapes' ? Partial<GeometryShapesLimits> : Partial<GeometryVoxelLimits>;
+
+declare interface GeometryBoxOverlapOptions {
+    readonly maxTests?: number;
+}
+
+declare type GeometryChunk = GeometryTileChunk | GeometryHeightfieldChunk | GeometryShapesChunk | GeometryVoxelChunk;
+
+declare type GeometryCollisionDerive = (context: GeometryDerivationContext) => GeometryChunk;
+
+/** Actual World/native preparation/CPU facade; no SQL/Host/whole-system flag. */
+export declare const geometryCollisionDeriveSlotFixture: {
+    kind: "slot";
+    defaultImplementation: GeometryCollisionDerive;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean | GeometryTilePathStatus, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean | GeometryTilePathStatus, never, never>;
+        expected: boolean;
+    };
+};
+
+declare type GeometryCompaction = (context: GeometryCompactionContext) => GeometryPatch;
+
+/** Genuine immutable native artifacts only. Compaction preserves the current
+ * truth; it cannot authorize a different edit, owner, revision or SQL write. */
+declare interface GeometryCompactionContext {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly limits: GeometryPatchLimits;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+/** Actual World-selected native preparation; excludes SQL/Host/system acceptance. */
+export declare const geometryCompactionSlotFixture: {
+    kind: "slot";
+    defaultImplementation: GeometryCompaction;
+    defaultProbe: {
+        run: () => Effect.Effect<"refused" | "preserved", never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<"refused" | "preserved", never, never>;
+        expected: string;
+    };
+};
+
+declare interface GeometryCompactionStrategies {
+    readonly compaction: GeometryCompaction;
+}
+
+declare interface GeometryDeltaMigrationFrom {
+    readonly static: GeometryArtifact;
+    readonly current: GeometryArtifact;
+    readonly revision: number;
+}
+
+declare interface GeometryDeltaMigrationTo {
+    readonly static: GeometryArtifact;
+}
+
+/** Outside-Tick native data only. No query callback, provider, actor, Store or
+ * authority capability is accepted as a derivation result. */
+declare interface GeometryDerivationContext {
+    readonly chunk: GeometryChunk;
+    readonly codecLimits: GeometryArtifactLimits<GeometryKind>;
+}
+
+declare interface GeometryDerivationStrategies {
+    readonly collisionDerive: GeometryCollisionDerive;
+    readonly navDerive: GeometryNavDerive;
+}
+
+/** Trusted server snapshot. Never derive these rights, positions, budgets or
+ * catalogs from the intent body. App policy must recheck authority at commit. */
+declare interface GeometryEditAuthority {
+    readonly dynamicEnabled: boolean;
+    readonly ownsChunk: boolean;
+    readonly canBuild: boolean;
+    readonly cooldownReady: boolean;
+    readonly remainingOps: number;
+    readonly maxReachRaw: number;
+    readonly maxHeightUnits: number;
+    readonly position: {
+        readonly xRaw: number;
+        readonly yRaw: number;
+        readonly zRaw: number;
+    };
+    readonly materials: ReadonlyArray<GeometryTileMaterial>;
+    readonly shapes: ReadonlyArray<GeometryShapeTemplate>;
+}
+
+declare interface GeometryEditContext {
+    readonly chunk: GeometryChunk;
+    readonly intent: GeometryEditIntent;
+    readonly authority: GeometryEditAuthority;
+    readonly placementId: string;
+    readonly codecLimits?: GeometryArtifactLimits<GeometryKind> | undefined;
+}
+
+/** Player requests an action and its target, never solidity, shape dimensions,
+ * an authoritative player position, revision, owner, full chunk or Delta bytes. */
+declare type GeometryEditIntent = {
+    readonly op: 'setTile';
+    readonly x: number;
+    readonly y: number;
+    readonly material: string;
+} | {
+    readonly op: 'raiseHeight';
+    readonly x: number;
+    readonly y: number;
+    readonly units: number;
+} | {
+    readonly op: 'setVoxel';
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly material: string;
+} | {
+    readonly op: 'placeShape';
+    readonly template: string;
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+} | {
+    readonly op: 'removeShape';
+    readonly id: string;
+};
+
+declare interface GeometryEditStrategies {
+    /** Pure policy slot. Current native Session/SQL ownership and codec integrity cannot be overridden by this slot. */
+    readonly opValidator: (context: GeometryEditContext) => void;
+    /** Pure rule slot; returned chunk is admitted under the original identity/layout/profile. */
+    readonly applyOp: (context: GeometryEditContext) => GeometryChunk;
+}
+
+declare type GeometryGenerator = (context: GeometryProceduralContext) => GeometryChunk;
+
+declare interface GeometryGridRayHit {
+    readonly kind: '2d-tiles' | '3d-voxel';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly cell: {
+        readonly x: number;
+        readonly y: number;
+        readonly z?: number;
+    };
+    /** Exact reduced infimum entry fraction on the offered segment, not a
+     * rounded contact point or a floating-point distance. */
+    readonly fraction: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+    readonly visitedCells: number;
+}
+
+declare interface GeometryGridRayOptions {
+    readonly maxVisitedCells?: number;
+}
+
+declare interface GeometryGridSweepHit {
+    readonly kind: '2d-tiles' | '3d-voxel';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly cell: {
+        readonly x: number;
+        readonly y: number;
+        readonly z?: number;
+    };
+    /** Infimum/supremum of positive-volume overlap, clipped to [0,1]. Contact
+     * alone is not an overlap; fractions are exact reduced integer ratios. */
+    readonly entry: FixedSlabFraction;
+    readonly exit: FixedSlabFraction;
+    readonly initialOverlap: boolean;
+    readonly testedCells: number;
+}
+
+/** A half-open raw box `[min, max)` on all three axes; a heightfield box needs its z extent. */
+declare interface GeometryHeightfieldBoxRaw {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly minZRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+    readonly maxZRaw: number;
+}
+
+declare type GeometryHeightfieldChunk = (typeof GeometryHeightfieldChunkSchema)["Type"];
+
+declare const GeometryHeightfieldChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"2d-heightfield">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly sampleSpacingRaw: Schema.Int;
+    readonly baseHeightRaw: Schema.Int;
+    readonly heightQuantumRaw: Schema.Int;
+    readonly heights: Schema.$Array<Schema.Int>;
+}>;
+
+declare interface GeometryHeightfieldLimits {
+    readonly maxSide: number;
+    readonly maxSamples: number;
+    readonly maxBytes: number;
+}
+
+declare interface GeometryHeightfieldRayHit {
+    readonly kind: '2d-heightfield';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    /** The first point on the segment at or below the surface, in global raw units. */
+    readonly point: GeometryHeightfieldRayPoint;
+    /** Exact reduced position on the offered segment whose raw-grid point is `point`. */
+    readonly fraction: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+    readonly visitedSamples: number;
+}
+
+declare interface GeometryHeightfieldRayPoint {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+}
+
+declare interface GeometryHeightfieldSweepHit {
+    readonly kind: '2d-heightfield';
+    /** The first box position along the path that reaches under the surface, on the raw grid. */
+    readonly box: GeometryHeightfieldBoxRaw;
+    /** Exact reduced position of `box` on the path: raw steps along the longest axis over its length. */
+    readonly fraction: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+    /** The start box already reaches under the surface (fraction 0). */
+    readonly initialOverlap: boolean;
+    /** Overlap evaluations used, coarse and refining together. */
+    readonly evaluations: number;
+}
+
+declare type GeometryKind = GeometryChunk['kind'];
+
+/** Pure native data rule only; no SQL, actor, journal, permission or Subject. */
+declare type GeometryMigrateDelta = (from: GeometryDeltaMigrationFrom, to: GeometryDeltaMigrationTo) => GeometryChunk | null;
+
+declare type GeometryNavDerive = (context: GeometryDerivationContext) => GeometryTileChunk | null;
+
+export declare const geometryNavDeriveSlotFixture: {
+    kind: "slot";
+    defaultImplementation: GeometryNavDerive;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean | GeometryTilePathStatus, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean | GeometryTilePathStatus, never, never>;
+        expected: string;
+    };
+};
+
+declare interface GeometryPatch {
+    readonly metadata: GeometryPatchMetadata;
+    bytes(): Uint8Array;
+}
+
+declare interface GeometryPatchLimits {
+    readonly maxBytes: number;
+    readonly maxMetadataBytes: number;
+}
+
+declare type GeometryPatchMetadata = (typeof GeometryPatchMetadataSchema)["Type"];
+
+declare const GeometryPatchMetadataSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["2d-tiles", "2d-heightfield", "3d-shapes", "3d-voxel"]>;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly worldId: Schema.String;
+    readonly layerSetId: Schema.String;
+    readonly cx: Schema.Int;
+    readonly cy: Schema.Int;
+    readonly cz: Schema.optional<Schema.Int>;
+    readonly version: Schema.String;
+    readonly baseRevision: Schema.Int;
+    readonly revision: Schema.Int;
+    readonly baseBlobSha256: Schema.String;
+    readonly blobSha256: Schema.String;
+    readonly baseContentSha256: Schema.String;
+    readonly contentSha256: Schema.String;
+    readonly changed: Schema.Boolean;
+    readonly stateSchemaHash: Schema.Int;
+}>;
+
+declare type GeometryPersistenceError = ProtocolError | BudgetExceeded;
+
+declare interface GeometryPersistenceScope {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly version: string;
+    readonly layerSetId: string;
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+}
+
+declare interface GeometryPersistenceSubject {
+    readonly id: string;
+    readonly kind: 'user' | 'guest';
+}
+
+declare interface GeometryPreparedScope {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+declare interface GeometryProceduralContext {
+    readonly seed: number;
+    readonly kind: GeometryKind;
+    readonly address: GeometryChunk['address'];
+    readonly version: string;
+}
+
+declare type GeometryShape = (typeof GeometryShapeSchema)["Type"];
+
+declare interface GeometryShapeRayHit {
+    readonly kind: '3d-shapes';
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    /** Native LOCAL shape; scope identifies its owning chunk. */
+    readonly shape: GeometryShape;
+    /** Encloses the exact infimum entry time; width <= 2^-52. Presentation only.
+     * Selection and ownership decisions never use these rounded bounds. */
+    readonly fractionBounds: {
+        readonly lower: number;
+        readonly upper: number;
+    };
+    readonly visitedChunks: number;
+    readonly testedShapes: number;
+}
+
+declare const GeometryShapeSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly halfXRaw: Schema.Int;
+    readonly halfYRaw: Schema.Int;
+    readonly halfZRaw: Schema.Int;
+    readonly id: Schema.String;
+    readonly xRaw: Schema.Int;
+    readonly yRaw: Schema.Int;
+    readonly zRaw: Schema.Int;
+    readonly kind: Schema.Literal<"aabb">;
+}>, Schema.Struct<{
+    readonly radiusRaw: Schema.Int;
+    readonly id: Schema.String;
+    readonly xRaw: Schema.Int;
+    readonly yRaw: Schema.Int;
+    readonly zRaw: Schema.Int;
+    readonly kind: Schema.Literal<"sphere">;
+}>]>;
+
+declare type GeometryShapesChunk = (typeof GeometryShapesChunkSchema)["Type"];
+
+declare const GeometryShapesChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"3d-shapes">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly extentXRaw: Schema.Int;
+    readonly extentYRaw: Schema.Int;
+    readonly extentZRaw: Schema.Int;
+    readonly shapes: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly halfXRaw: Schema.Int;
+        readonly halfYRaw: Schema.Int;
+        readonly halfZRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"aabb">;
+    }>, Schema.Struct<{
+        readonly radiusRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"sphere">;
+    }>]>>;
+}>;
+
+declare interface GeometryShapesLimits {
+    readonly maxShapes: number;
+    readonly maxBytes: number;
+}
+
+declare type GeometryShapeTemplate = {
+    readonly key: string;
+    readonly kind: 'aabb';
+    readonly halfXRaw: number;
+    readonly halfYRaw: number;
+    readonly halfZRaw: number;
+} | {
+    readonly key: string;
+    readonly kind: 'sphere';
+    readonly radiusRaw: number;
+};
+
+declare type GeometrySource = {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'cms';
+    readonly key: string;
+    readonly channel: string;
+} | {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'imported';
+    readonly directory: string;
+} | {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'procedural';
+    readonly seed: number;
+    readonly generator: GeometryGenerator;
+};
+
+declare type GeometryTileChunk = (typeof GeometryTileChunkSchema)["Type"];
+
+declare const GeometryTileChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"2d-tiles">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly tileSizeRaw: Schema.Int;
+    readonly palette: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly solid: Schema.Boolean;
+    }>>;
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly paletteIndex: Schema.Int;
+        readonly length: Schema.Int;
+    }>>;
+}>;
+
+declare interface GeometryTileCollisionOptions {
+    /** Total visited cells across every solver query, including its final check.
+     * May only narrow the world's maxOverlapTests. */
+    readonly maxTests?: number;
+    /** Existing discrete solver limit; defaults to 8, maximum 256. */
+    readonly maxIterations?: number;
+}
+
+declare interface GeometryTileLimits {
+    readonly maxSide: number;
+    readonly maxCells: number;
+    readonly maxPalette: number;
+    readonly maxRuns: number;
+    readonly maxBytes: number;
+}
+
+declare type GeometryTileMaterial = (typeof GeometryTileMaterialSchema)["Type"];
+
+declare const GeometryTileMaterialSchema: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly solid: Schema.Boolean;
+}>;
+
+declare type GeometryTilePathStatus = 'pending' | 'found' | 'unreachable' | 'budget-exhausted' | 'cancelled';
+
+declare interface GeometryVersionMigrationStrategies {
+    readonly migrateDelta?: GeometryMigrateDelta;
+}
+
+declare type GeometryVoxelChunk = (typeof GeometryVoxelChunkSchema)["Type"];
+
+declare const GeometryVoxelChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"3d-voxel">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly side: Schema.Int;
+    readonly voxelSizeRaw: Schema.Int;
+    readonly palette: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly solid: Schema.Boolean;
+    }>>;
+    readonly sections: Schema.$Array<Schema.Struct<{
+        readonly sx: Schema.Int;
+        readonly sy: Schema.Int;
+        readonly sz: Schema.Int;
+        readonly runs: Schema.$Array<Schema.Struct<{
+            readonly paletteIndex: Schema.Int;
+            readonly length: Schema.Int;
+        }>>;
+    }>>;
+}>;
+
+declare interface GeometryVoxelLimits {
+    readonly maxSide: number;
+    readonly maxVoxels: number;
+    readonly maxPalette: number;
+    readonly maxSections: number;
+    readonly maxRunsPerSection: number;
+    readonly maxBytes: number;
+}
+
+export declare const geometryWorldApplyOpSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (context: GeometryEditContext) => GeometryChunk;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+};
+
+/** Nonempty half-open raw box. Three-dimensional kinds require both Z fields. */
+declare interface GeometryWorldBoxRaw {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+    readonly minZRaw?: number;
+    readonly maxZRaw?: number;
+}
+
+/** Actual World declaration plus native pure edit pipeline. Not Host/SQL or
+ * complete geometry-system conformance; the app still supplies current authority. */
+export declare const geometryWorldOpValidatorSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (context: GeometryEditContext) => void;
+    defaultProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<"accepted" | "custom-refused", never, never>;
+        expected: string;
+    };
+};
+
+declare interface GeometryWorldPointRaw {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw?: number;
+}
+
+declare type GeometryWorldRayHit = GeometryGridRayHit | GeometryShapeRayHit | GeometryHeightfieldRayHit;
+
+declare interface GeometryWorldRayOptions extends GeometryGridRayOptions {
+    /** Shapes only; narrows maxOverlapTests for the total shape scan. */
+    readonly maxTests?: number;
+}
+
+declare interface GeometryWorldShapeHit {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly shape: GeometryShape;
+}
+
+declare interface GeometryWorldView {
+    readonly kind: GeometryKind;
+    readonly scope: GeometryPreparedScope;
+    /** Discrete AABB/circle resolution in world units against current tile data.
+     * Reuses the Transform solver; no swept movement or velocity integration. */
+    collide(transform: Transform2D, body: CollisionBody2D, options?: GeometryTileCollisionOptions): CollisionResult2D;
+    /** Tiles/voxels only. Unloaded coordinates refuse, never implicit empty terrain. */
+    materialAtRaw(point: GeometryWorldPointRaw): GeometryTileMaterial;
+    /** Tiles/voxels/shapes: the stored solidity. Heightfields (points with `zRaw`): terrain is solid at and
+     * below its surface, the same surface `raycastRaw` hits. Heightfield material is not invented. */
+    solidAtRaw(point: GeometryWorldPointRaw): boolean;
+    /** Heightfield only, with exact existing native interpolation. */
+    heightAtRaw(point: GeometryWorldPointRaw): number;
+    /** Shapes only; hit volumes retain native LOCAL coordinates and exact chunk scope. */
+    shapesAtRaw(point: GeometryWorldPointRaw): ReadonlyArray<GeometryWorldShapeHit>;
+    /** Tiles/voxels return exact rational entry; shapes select exact quadratic
+     * entry and expose enclosing presentation bounds; heightfields (points with
+     * `zRaw`) return the first sampled point at or below the surface, refined to
+     * one raw unit (`raycastGeometryHeightfield`). Missing coverage refuses. */
+    raycastRaw(from: GeometryWorldPointRaw, to: GeometryWorldPointRaw, options?: GeometryWorldRayOptions): GeometryWorldRayHit | null;
+    /** Tiles/voxels/closed native shapes, clipped by half-open chunk ownership. Heightfields need the z extent:
+     * the box touches terrain when the highest surface point over its footprint is at or above `minZRaw`
+     * (`overlapsGeometryHeightfieldBox`). Nonempty half-open raw boxes only; missing data or work exhaustion refuses. */
+    overlapsBoxRaw(box: GeometryWorldBoxRaw, options?: GeometryBoxOverlapOptions): boolean;
+    /** Translation-only tile/voxel sweep. Shares maxOverlapTests; validates the
+     * whole swept bounding region before publishing the earliest overlap. */
+    sweepBoxRaw(from: GeometryWorldBoxRaw, to: GeometryWorldBoxRaw, options?: GeometryBoxOverlapOptions): GeometryGridSweepHit | null;
+    /** Heightfields only (boxes with a z extent): the first raw-grid position that reaches under the surface
+     * (`sweepGeometryHeightfieldBox`), coarse steps of a quarter sample spacing, at most
+     * `geometry.budgets.maxRayCells` overlap evaluations of `maxTests` reads each. */
+    sweepHeightfieldBoxRaw(from: GeometryHeightfieldBoxRaw, to: GeometryHeightfieldBoxRaw, options?: GeometryBoxOverlapOptions): GeometryHeightfieldSweepHit | null;
+}
+
+declare type LockstepDesyncAction = 'resync' | 'end' | 'flag';
+
+declare interface LockstepDesyncContext {
+    readonly tick: number;
+    readonly playerId: number;
+    readonly expected: Uint64Words;
+    readonly received: Uint64Words;
+}
+
+export declare const lockstepDesyncSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (_incident: LockstepDesyncContext, configuredAction: LockstepDesyncAction) => LockstepDesyncAction;
+    defaultProbe: {
+        run: () => Effect.Effect< LockstepDesyncAction, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< LockstepDesyncAction, never, never>;
+        expected: string;
+    };
+};
+
+export declare const lockstepHashSlotFixture: {
+    kind: "slot";
+    defaultImplementation: <S extends Schema.Codec<unknown, unknown>>(codec: SimulationStateCodec<S>, state: S["Type"]) => Uint64Words;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+export declare const lockstepInitialPlayerSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (offered: RoomLockstepInitialPlayerContext) => number;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+export declare const lockstepInitialStartSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (offered: RoomLockstepInitialRosterContext) => boolean;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+};
+
+/** Actual local consumers, not passing full-system/engine/host conformance. */
+export declare const lockstepInputPredictionSlotFixture: {
+    kind: "slot";
+    defaultImplementation: <I>(last: I, _context: {
+        readonly playerId: number;
+        readonly tick: number;
+    }) => I;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+export declare const lockstepReconnectSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (options?: Partial<{
+        readonly graceMs: number;
+    }>) => {
+        readonly graceMs: number;
+    };
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+/** Actual role constructor captures the lag used by its genuine input queue;
+ * live Session queue behavior is exercised by the common admission source. */
+export declare const lockstepRefereeLagSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (configuredTicks: number) => number;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+export declare const lockstepSeedSlotFixture: {
+    kind: "slot";
+    defaultImplementation: () => number;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+declare interface LockstepStallPolicy {
+    readonly afterTicks: number;
+    readonly action: 'pause' | 'drop-player';
+}
+
+declare interface LockstepStallPolicyOptions {
+    readonly afterTicks?: number;
+    readonly action?: 'pause' | 'drop-player';
+}
+
+export declare const lockstepStallPolicySlotFixture: {
+    kind: "slot";
+    defaultImplementation: (offered: LockstepStallPolicyOptions) => LockstepStallPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<"action" | "waiting", never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<"action" | "waiting", never, never>;
+        expected: string;
+    };
+};
+
+/** Seeded network, not a transport-performance claim. Reliable loss stalls;
+ * datagram loss drops. Both halves share one owned virtual time source. */
+export declare class NetSim {
+    private readonly options;
+    readonly clock: VirtualRoomClock;
+    readonly client: RoomTransport;
+    readonly server: RoomTransport;
+    private readonly signals;
+    private readonly listeners;
+    private readonly deliveries;
+    private readonly queued;
+    private readonly lastReliableAt;
+    private readonly dropped;
+    private readonly maxQueuedBytes;
+    private readonly maxDatagramBytes;
+    private readonly maxInFlightDatagrams;
+    private seed;
+    private seq;
+    constructor(options: NetSimOptions);
+    private random;
+    private latency;
+    private transport;
+    advance(milliseconds: number): void;
+    private close;
+}
+
+export declare interface NetSimOptions {
+    readonly seed: number;
+    readonly latencyMs: number;
+    readonly jitterMs: number;
+    readonly lossRate: number;
+    readonly maxQueuedBytes?: number;
+    readonly maxDatagramBytes?: number;
+    readonly maxInFlightDatagrams?: number;
+    readonly datagrams?: boolean;
+}
+
+declare class NotRoomMember extends NotRoomMember_base {
+}
+
+declare const NotRoomMember_base: Schema.Class<NotRoomMember, Schema.TaggedStruct<"NotRoomMember", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+/** PCG-XSH-RR 64/32. Numeric seeds are unsigned 32-bit; word seeds retain 64 bits.
+ * Algorithm reference: https://www.pcg-random.org/using-pcg-c-basic.html
+ * No global generator, BigInt, native dependency or implicit time/entropy seed. */
+declare class Pcg32 {
+    #private;
+    constructor(seed: Pcg32Seed, stream?: Pcg32Seed, maxRejectionAttempts?: number);
+    get maxRejectionAttempts(): number;
+    nextU32(): number;
+    /** Rejection removes modulo bias. Exhaustion consumes exactly the bounded
+     * draws and fails; it never returns a biased fallback or substitutes entropy. */
+    bounded(bound: number): number;
+    snapshot(): Pcg32Snapshot;
+    restore(offered: Pcg32Snapshot): void;
+    clone(): Pcg32;
+    /** Exact skip-ahead modulo 2^64; at most 32 iterations for this delta API. */
+    advance(delta: number): void;
+}
+
+declare type Pcg32Seed = number | Uint64Words;
+
+declare interface Pcg32Snapshot {
+    readonly stateHi: number;
+    readonly stateLo: number;
+    readonly incrementHi: number;
+    readonly incrementLo: number;
+}
+
+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;
+
+/** One authoritative actor. This module contains no store, socket or timer. */
+declare class RoomActor<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    readonly id: string;
+    readonly descriptor: RoomDescriptor<S, I, O>;
+    private readonly clock;
+    readonly tenantId: string;
+    private currentState;
+    private lastGoodState;
+    private lastGoodTick;
+    readonly options: (O)["Type"];
+    private readonly members;
+    private readonly grace;
+    private readonly inputs;
+    private readonly outbox;
+    private readonly clientOperations;
+    private readonly schedules;
+    private readonly extensionDurationMs;
+    private readonly extensionOverruns;
+    private tick;
+    private droppedTicks;
+    private commandSeq;
+    readonly epoch: number;
+    private nextTickAt;
+    private emptyAt;
+    private locked;
+    private disposed;
+    private publicationHeldAt;
+    private drainFrozen;
+    private drainAt;
+    private retiring;
+    private faulted;
+    private ticking;
+    private lastNow;
+    private readonly app;
+    private readonly scheduler;
+    private readonly worldPreviews;
+    private readonly worldReceipts;
+    private readonly deferredWorldLeaves;
+    private worldMovement;
+    private worldMovementClamps;
+    private worldMovementMargin;
+    private worldMovementIntents;
+    private worldFinalizationHold;
+    private readonly worldPublishedTransitions;
+    private lifecycleTail;
+    private lifecycleRequests;
+    private lifecycleActive;
+    private readonly geometry;
+    constructor(id: string, descriptor: RoomDescriptor<S, I, O>, initialState: (S)["Type"], options: (O)["Type"], clock: RoomClock, tenantId: string, recovery?: RoomActorRecovery, geometry?: GeometryWorldView);
+    get state(): RoomState<(S)["Type"]>;
+    private now;
+    private ensureOpen;
+    private stage;
+    private schedule;
+    join(client: RoomClient): void;
+    joinAsync(client: RoomClient, signal?: AbortSignal): Promise<void>;
+    /** Only a trusted SQL seat adapter supplies this cursor; player Hello/input
+     * never contains it. The successful lifecycle commits cursor and membership. */
+    /** `authorizeCommit` runs before the join hook and again before publication; the World
+     * member its first run returns reaches `onJoin` as `world`. */
+    joinReservedAsync(client: RoomClient, consumed: RoomConsumedSeat, signal?: AbortSignal, authorizeCommit?: () => Promise<RoomWorldMember | undefined | void>): Promise<void>;
+    /** Trusted Host-only pending membership. The caller must separately establish
+     * current SQL transition/Seat authority; the marker itself grants nothing. */
+    joinWorldReservedAsync(client: RoomClient, consumed: RoomConsumedSeat, authorize: () => Promise<void | 'pending' | 'committed' | 'settled'>, signal?: AbortSignal): Promise<void>;
+    /** The author's view of a transition arrival becoming an active member (`world.onMemberEnter`). */
+    private worldMemberEntered;
+    /** The committed World point of one entity through `world.movement.position`: the last good state, never a
+     * draft. Null without a movement hook, without that entity, or without a finite point. */
+    worldEntityPoint(entityId: string): WorldPoint | null;
+    /** Release only after the Host has persisted actual target enter and rechecked
+     * SQL authority. The retained canonical enter receipt is required locally. */
+    activateWorldReservedAsync(binding: WorldTargetSeatBinding, authorize: () => Promise<void>): Promise<void>;
+    private assertWorldMemberEntity;
+    isWorldPending(sessionId: string): boolean;
+    /** Explicit trusted local-host admission. Authentication still follows the
+     * descriptor; the resulting capability is bound to this exact Member object,
+     * so a stale bot cannot submit to or release a later reused session ID. */
+    joinBotAsync(client: RoomClient, countsAsPlayer?: boolean, signal?: AbortSignal): Promise<RoomActorBotLease>;
+    playerCount(): number;
+    availablePlayerSlots(): number;
+    monotonicNow(): number;
+    roster(): ReadonlyArray<Pick<RoomClient, 'sessionId' | 'subjectId' | 'tenantId'> & {
+        readonly isBot: boolean;
+        readonly countsAsPlayer: boolean;
+    }>;
+    /** Check identity/lock and current counted/grace capacity before replacing a
+     * bot. Full prepareJoin repeats these immediately before membership commit. */
+    humanAdmissionNeedsReplacement(client: RoomClient): boolean;
+    private prepareClientIdentity;
+    private prepareJoin;
+    leave(sessionId: string, reason?: RoomLeaveReason): void;
+    leaveAsync(sessionId: string, reason?: RoomLeaveReason, signal?: AbortSignal): Promise<void>;
+    private prepareLeave;
+    private assertWorldArrival;
+    private enterWorldDraft;
+    /** Execute actual target admission on an isolated draft. Nothing is published
+     * or receipted here. Author Effects receive prepare phase and must supply their
+     * own external idempotency/compensation; this is not an ownership commit. */
+    previewWorldEnter(input: Parameters<RoomActor<S, I, O>['applyWorldHook']>[1], maxBytes: number, signal?: AbortSignal): Promise<void>;
+    /** Trusted server lifecycle only. The caller supplies the configured World
+     * byte budget and current epoch; this grants no SQL/transition admission. */
+    applyWorldHook(operation: 'enter' | 'exit' | 'ghost', input: RoomWorldHookInput<RoomWorldEntity<(S)["Type"]>>, maxBytes: number, signal?: AbortSignal, authorizeCommit?: () => Promise<void>, replaceExitReceipt?: boolean, previousGhost?: RoomWorldHookInput<RoomWorldEntity<(S)["Type"]>>, retainGhostProjection?: boolean, promoteGhosts?: ReadonlyArray<RoomWorldHookInput<RoomWorldEntity<(S)["Type"]>>>): Promise<void>;
+    private assertWorldHookResult;
+    private assertWorldEnterVacant;
+    /** Trusted Host terminal-proof path only; it checkpoints the removal before
+     * returning. No gameplay state or external effect is undone here. */
+    retireWorldReceipt(requestId: string, operation: 'enter' | 'exit' | 'ghost'): Promise<void>;
+    /** Failed transition compensation, guarded before draft publication. The
+     * author removes its projection in onGhost phase rollback; no source rewind. */
+    cancelWorldGhost(input: Parameters<RoomActor<S, I, O>['applyWorldHook']>[1], maxBytes: number, authorize: () => Promise<void>): Promise<void>;
+    cancelWorldPreview(requestId: string, authorize: () => Promise<void>): Promise<void>;
+    hasWorldReceipt(requestId: string, operation: 'enter' | 'exit' | 'ghost'): boolean;
+    worldReceiptSnapshot(): ReadonlyArray<RoomWorldReceipt>;
+    /** Capture the actual current actor entity, never a caller-provided replacement.
+     * Returned data is detached bounded JSON; persistence remains outside the tick. */
+    captureWorldEntity(entityId: string, epoch: number, maxBytes: number): Promise<{
+        readonly entity: RoomWorldEntity<(S)["Type"]>;
+        readonly data: unknown;
+    }>;
+    configureWorldCellMovement(epoch: number, bounds?: WorldBounds, marginUnits?: number): Promise<void>;
+    worldMovementSnapshot(): {
+        readonly bound: boolean;
+        readonly clamped: number;
+    };
+    captureWorldMovement(epoch: number): Promise<WorldMovementObservation>;
+    private constrainWorldMovement;
+    listWorldEntityIds(epoch: number, maximum: number, maxBytes: number): Promise<ReadonlyArray<string>>;
+    captureWorldProjection(entityId: string, epoch: number, maxBytes: number): Promise<{
+        readonly entity: RoomWorldEntity<(S)["Type"]>;
+        readonly data: unknown;
+        readonly tick: number;
+    }>;
+    private captureWorldEntityOwned;
+    /** Trusted Host handoff: one bounded room hold survives ambiguous durable writes.
+     * Completion must follow checkpoint acknowledgement; never release by timeout. */
+    finalizeWorldExit(input: {
+        readonly afterglow?: {
+            readonly requestId: string;
+            readonly expiresAt: number;
+        };
+        readonly subjectId?: string;
+        readonly epoch: number;
+        readonly entityId: string;
+        readonly requestId: string;
+        readonly location: WorldEntityLocation;
+    }, maxBytes: number, retain: (capture: {
+        readonly entity: RoomWorldEntity<(S)["Type"]>;
+        readonly data: unknown;
+    }) => Promise<void>, authorize: () => Promise<void>, expectedEntity?: unknown, signal?: AbortSignal): Promise<void>;
+    /** The actual Runtime supplies the synchronous bounded reliable enqueue. No
+     * network completion is awaited while the lifecycle/SQL fence is held. */
+    notifyWorldHandoff(input: Omit<RoomWorldHandoffFrame, 'tick'>, authorize: () => Promise<void>, enqueue: (frame: RoomWorldHandoffFrame) => void): Promise<void>;
+    /** Only the actual Host may call this after its durable checkpoint succeeds. */
+    completeWorldFinalization(requestId: string, authorize: () => Promise<void>): Promise<void>;
+    worldFinalizationAfterglow(): {
+        readonly requestId: string;
+        readonly expiresAt: number;
+    } | undefined;
+    worldFinalizationRequest(): string | null;
+    isWorldFinalizationHeld(): boolean;
+    /** Recovery-only source reconstruction from final durable capture. Caller owns
+     * unpublished successor/recovery authority and checkpoints before fence clear. */
+    reconcileWorldSource(input: {
+        readonly epoch: number;
+        readonly requestId: string;
+        readonly entity: RoomWorldEntity<(S)["Type"]>;
+        readonly location: WorldEntityLocation;
+    }, maxBytes: number, authorize: () => Promise<void>, signal?: AbortSignal): Promise<void>;
+    private assertSynchronousLifecycle;
+    private serializeLifecycle;
+    private mutateMemberAsync;
+    private pruneGrace;
+    private mutateMember;
+    /** encodedBytes is measured by the host transport, never supplied by a player. */
+    input(sessionId: string, seq: number, tickHint: number, payload: unknown, encodedBytes: number): boolean;
+    private send;
+    private extension;
+    holdPublication(): void;
+    releasePublication(): void;
+    /** Called by the host's single monotonic loop. Catch-up never spins unbounded. */
+    advance(): number;
+    drainOutbox(): ReadonlyArray<RoomOutboxCommand>;
+    private stageClientOperation;
+    /** Transport callbacks are invoked only by the supervisor after advance. */
+    flushClientOperations(): void;
+    /** Ordinary socket members and reconnect grace only. Local bots own no SQL
+     * seat. Queued-but-unapplied inputs never become applied receipts; discarded
+     * pending World inputs carry a separate durable rejection cursor. */
+    inputReceiptSnapshot(): ReadonlyArray<RoomInputReceipt>;
+    /** Runtime-only confirmation after the actual checkpoint port acknowledges.
+     * Inputs arriving during the write remain unconfirmed and block activation. */
+    confirmInputCheckpoint(receipts: ReadonlyArray<RoomInputReceipt>): void;
+    lastAppliedInputSeq(sessionId: string): number;
+    lock(): void;
+    unlock(): void;
+    dispose(): void;
+    isDisposed(): boolean;
+    isLifecycleBusy(): boolean;
+    /** Permanent local simulation fence before the final planned-handoff snapshot. */
+    freezeForDrain(): Promise<void>;
+    /** Only after real SQL ownership handoff. No leave/dispose game hooks, SQL,
+     * or new commands may run after the saved state has moved to its successor. */
+    releaseTransferred(): void;
+    disposeAsync(signal?: AbortSignal): Promise<void>;
+    isRetiring(): boolean;
+    /** Only the supervisor calls this after the final hibernated SQL receipt.
+     * Hibernate pauses a durable room; it must not run game-ending onDispose. */
+    releaseHibernated(): void;
+    isFaulted(): boolean;
+    commandCursor(): number;
+    scheduleSnapshot(): ReadonlyArray<RoomScheduleSnapshot>;
+    lastGoodSnapshot(): {
+        readonly tick: number;
+        readonly state: RoomState<(S)["Type"]>;
+    };
+    metrics(): RoomActorMetrics;
+}
+
+declare interface RoomActorBotLease {
+    readonly sessionId: string;
+    isCurrent(): boolean;
+    input(seq: number, tickHint: number, payload: unknown, encodedBytes: number): boolean;
+    leave(signal?: AbortSignal): Promise<void>;
+}
+
+declare interface RoomActorMetrics {
+    readonly tick: number;
+    readonly droppedTicks: number;
+    readonly queuedInputs: number;
+    readonly outboxCommands: number;
+    readonly clients: number;
+    readonly extensionDurationMs: Readonly<Record<string, number>>;
+    readonly extensionOverruns: Readonly<Record<string, number>>;
+}
+
+declare interface RoomActorRecovery {
+    /** SQL ownership generation; a new owner must use a strictly newer epoch. */
+    readonly epoch: number;
+    readonly commandCursor: number;
+    readonly tick?: number;
+    readonly rehydrate?: boolean;
+    readonly worldReceipts?: ReadonlyArray<RoomWorldReceipt> | undefined;
+    readonly schedules?: ReadonlyArray<RoomScheduleSnapshot>;
+}
+
+export declare type RoomAdoptionFixtureOverrides = Partial<Context.Service.Shape<typeof RoomHostAdoptionPort>>;
+
+/** Commands are staged in memory and drained outside the tick. */
+declare interface RoomAppBridge {
+    publish(event: string, payload: unknown, options: {
+        readonly key: string;
+    }): string;
+    run(descriptor: string, input: unknown): string;
+}
+
+declare interface RoomAppCommand {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly requestId: string;
+    readonly command: RoomOutboxCommand;
+}
+
+export declare const roomAppCommandFakeLayer: Layer.Layer<RoomAppCommandPort, never, never>;
+
+export declare type RoomAppCommandFixtureOverrides = Partial<Context.Service.Shape<typeof RoomAppCommandPort>>;
+
+/** Application dispatch must implement durable idempotency by requestId. */
+declare class RoomAppCommandPort extends RoomAppCommandPort_base {
+}
+
+declare const RoomAppCommandPort_base: Context.ServiceClass<RoomAppCommandPort, "@voltro/RoomAppCommandPort", {
+    deliver(command: RoomAppCommand): Effect.Effect<void, ProtocolError>;
+}>;
+
+export declare const roomAppCommandPortFixture: {
+    kind: "port";
+    tag: Context.Service<RoomAppCommandPort, {
+        deliver(command: RoomAppCommand): Effect.Effect<void, ProtocolError>;
+    }>;
+    fakeLayer: Layer.Layer<RoomAppCommandPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+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 RoomAuthoringStrategies<S = unknown> {
+    readonly budgets?: (options: Readonly<Partial<RoomBudgets>>) => RoomBudgets;
+    readonly reconnectPolicy?: (options: Readonly<Partial<{
+        readonly graceMs: number;
+    }>>) => {
+        readonly graceMs: number;
+    };
+    readonly snapshotPolicy?: (options: Readonly<Partial<RoomSnapshotPolicy<S>>>) => RoomSnapshotPolicy<S>;
+    readonly spectatorPolicy?: (options: Readonly<Partial<RoomSpectatorPolicy>>) => RoomSpectatorPolicy;
+}
+
+declare interface RoomBudgets {
+    readonly inputsPerSecond: number;
+    readonly bytesPerSecond: number;
+    readonly burst: number;
+    readonly maxQueuedInputs: number;
+    readonly maxOutboxCommands: number;
+    readonly maxScheduledHooks: number;
+    readonly maxQueuedLifecycleHooks: number;
+    readonly maxNpcs: number;
+    /** A player input acting on state older than this many milliseconds behind the newest state
+     * the Host sent that client is dropped (it arrived too late to apply fairly). */
+    readonly inputLatencyBudgetMs: number;
+}
+
+/** Actual descriptor admission exercises defaults and configured overrides.
+ * These fixtures do not register a passing whole-system manifest. */
+export declare const roomBudgetsSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (overrides?: Partial< RoomBudgets>) => RoomBudgets;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+declare interface RoomChannel {
+    readonly schema: Schema.Codec<unknown, unknown>;
+    readonly direction: 'both' | 'server' | 'client';
+    readonly reliable: boolean;
+}
+
+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;
+    };
+}
+
+export declare const roomCheckpointFakeLayer: Layer.Layer<RoomCheckpointPort, never, never>;
+
+export declare type RoomCheckpointFixtureOverrides = Partial<Context.Service.Shape<typeof RoomCheckpointPort>>;
+
+/** Browser-safe service contracts. Server adapters and fixture Layers share
+ * these exact Tags; imports of server-owned data shapes are erased types. */
+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 const roomCheckpointPortFixture: {
+    kind: "port";
+    tag: Context.Service<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>;
+        readonly park?: (roomId: string, tenantId: string, requestId: string) => Effect.Effect<void, ProtocolError>;
+    }>;
+    fakeLayer: Layer.Layer<RoomCheckpointPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+declare interface RoomClient {
+    readonly sessionId: string;
+    readonly subjectId: string | null;
+    readonly tenantId: string;
+    /** App data the API resolved for this seat (`seatAttributes` on the Rooms API binding), signed into
+     * the seat; absent without one. Not a secret from the player: it travels in their seat token. */
+    readonly attributes?: RoomSeatAttributes | undefined;
+    /** Actor-owned classification, never accepted from a socket input. */
+    readonly isBot?: boolean | undefined;
+    readonly countsAsPlayer?: boolean | undefined;
+    send(channel: string, payload: unknown): void;
+    kick(reason: string): void;
+}
+
+declare interface RoomClientInputRecovery {
+    readonly nextSeq: number;
+    readonly lastAppliedSeq: number;
+}
+
+declare interface RoomClock {
+    now(): number;
+}
+
+declare interface RoomClockSamplingOptions {
+    readonly maxPendingPings: number;
+    readonly pingTimeoutMs: number;
+}
+
+/** Syncs independent monotonic clocks; wall-clock changes do not participate. */
+declare class RoomClockSync {
+    private readonly clock;
+    private readonly samples;
+    private lastServerNow;
+    private provisionalOffset;
+    constructor(clock: RoomClock);
+    /** Welcome gives an approximate clock anchor, never an RTT measurement. */
+    anchor(serverTimeMs: number, receivedAt?: number): void;
+    reset(): void;
+    pong(clientTimeMs: number, serverTimeMs: number, receivedAt?: number): void;
+    stats(): {
+        readonly rttMs: number | null;
+        readonly offsetMs: number | null;
+    };
+    serverNow(): number | null;
+}
+
+/** Every admitted session of one Room (a maintenance drain); `reason` is shown to each player. */
+declare interface RoomCloseInput {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly reason: string;
+}
+
+declare interface RoomCodecLimits {
+    readonly maxBytes: number;
+    readonly maxCollectionLength: number;
+    readonly maxFieldId: number;
+}
+
+declare interface RoomConsumedSeat {
+    readonly lastAppliedSeq: number;
+    readonly discardedThrough?: number;
+    readonly worldTarget?: WorldTargetSeatBinding;
+}
+
+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 interface RoomDatagramLane {
+    readonly maxDatagramBytes: number;
+    send(frame: Uint8Array): void;
+    onFrame(listener: (frame: Uint8Array, receivedAt: number) => void): () => void;
+}
+
+declare interface RoomDefinition<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    readonly name: string;
+    readonly mode?: 'state-sync';
+    readonly state: S;
+    readonly auth?: 'subject' | 'public';
+    readonly guards?: DeclaredAccess;
+    readonly openAccess?: string | undefined;
+    readonly input: I;
+    readonly options: O;
+    /** Author-owned initial state; no game values are guessed by the host. */
+    readonly initialState?: (options: (O)["Type"]) => (S)["Type"];
+    readonly tickRate?: number;
+    readonly sendRate?: number;
+    readonly maxClients?: number;
+    readonly maxCatchUpTicks?: number;
+    readonly lifecycleTimeoutMs?: number;
+    readonly budgets?: Partial<RoomBudgets>;
+    readonly strategies?: RoomAuthoringStrategies<(S)["Type"]> | undefined;
+    readonly reconnect?: {
+        readonly graceMs: number;
+    };
+    readonly autoDispose?: {
+        readonly afterEmptyMs: number;
+        readonly hibernate?: boolean;
+    };
+    readonly snapshot?: Partial<RoomSnapshotPolicy<(S)["Type"]>>;
+    /** Opt-in shared history; host must supply the actual common view/admission. */
+    readonly spectator?: Partial<RoomSpectatorPolicy> | undefined;
+    readonly messages?: Readonly<Record<string, RoomChannel>>;
+    readonly view?: (context: RoomViewContext<(S)["Type"]>) => (S)["Type"];
+    readonly viewBudgetMs?: number;
+    /** How the Room appears in `rooms.list`, derived from its state: `private` takes it off the list
+     * (it stays joinable by ID), `locked` refuses every new seat, `metadata` is shown to listers.
+     * Omitted fields keep their current value. The Host writes a change with the next checkpoint,
+     * which a change triggers at once. Synchronous and pure, like `view`. */
+    readonly listing?: (context: RoomListingContext<(S)["Type"], (O)["Type"]>) => RoomListing;
+    readonly extensions?: ReadonlyArray<RoomExtension<(S)["Type"], (I)["Type"]>>;
+    readonly world?: RoomWorldHooks<(S)["Type"]> | undefined;
+    readonly onCreate?: RoomSyncHook<Omit<RoomMemberContext<(S)["Type"], (O)["Type"]>, 'client'>>;
+    readonly onRehydrate?: RoomSyncHook<Omit<RoomMemberContext<(S)["Type"], (O)["Type"]>, 'client'>>;
+    readonly onJoin?: RoomLifecycleHook<RoomMemberContext<(S)["Type"], (O)["Type"]>>;
+    readonly onLeave?: RoomLifecycleHook<RoomMemberContext<(S)["Type"], (O)["Type"]> & {
+        readonly reason: RoomLeaveReason;
+    }>;
+    readonly onTick: RoomSyncHook<RoomTickContext<(S)["Type"], (I)["Type"]>>;
+    readonly onSchedule?: RoomSyncHook<RoomTickContext<(S)["Type"], (I)["Type"]> & {
+        readonly label: string;
+    }>;
+    readonly onDispose?: RoomLifecycleHook<{
+        readonly state: RoomState<(S)["Type"]> | undefined;
+        readonly app: RoomAppBridge;
+        readonly geometry?: GeometryWorldView;
+    }> | undefined;
+}
+
+declare interface RoomDeliveredState<S> {
+    readonly epoch: number;
+    readonly tick: number;
+    /** Local transport observation, not an authoritative server timestamp. */
+    readonly receivedAt: number;
+    readonly state: S;
+}
+
+declare interface RoomDescriptor<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> extends RoomDefinition<S, I, O> {
+    readonly _tag: 'RoomDescriptor';
+    readonly auth: 'subject' | 'public';
+    readonly guards: DeclaredAccess;
+    readonly tickRate: number;
+    readonly sendRate: number;
+    readonly maxClients: number;
+    readonly maxCatchUpTicks: number;
+    readonly lifecycleTimeoutMs: number;
+    readonly budgets: RoomBudgets;
+    readonly view: (context: RoomViewContext<(S)["Type"]>) => (S)["Type"];
+    readonly reconnect: {
+        readonly graceMs: number;
+    };
+    readonly autoDispose: {
+        readonly afterEmptyMs: number;
+        readonly hibernate: boolean;
+    };
+    readonly snapshot: RoomSnapshotPolicy<(S)["Type"]>;
+    readonly spectator?: RoomSpectatorPolicy | undefined;
+    readonly messages: Readonly<Record<string, RoomChannel>>;
+    readonly viewBudgetMs: number;
+    readonly extensions: ReadonlyArray<RoomExtension<(S)["Type"], (I)["Type"]>>;
+}
+
+declare type RoomDirectoryError = ProtocolError | BudgetExceeded | RoomForbidden | RoomFull | RoomGone | RoomPoolWaking;
+
+export declare const roomDirectoryFakeLayer: Layer.Layer<RoomDirectoryPort, never, never>;
+
+export declare type RoomDirectoryFixtureOverrides = Partial<Context.Service.Shape<typeof RoomDirectoryPort>>;
+
+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;
+}
+
+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>;
+}>;
+
+export declare const roomDirectoryPortFixture: {
+    kind: "port";
+    tag: Context.Service<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>;
+    }>;
+    fakeLayer: Layer.Layer<RoomDirectoryPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+/** 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;
+}
+
+export declare const roomErasureFakeLayer: Layer.Layer<RoomErasurePort>;
+
+export declare type RoomErasureFixtureOverrides = Partial<Context.Service.Shape<typeof RoomErasurePort>>;
+
+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. */
+declare class RoomErasurePort extends RoomErasurePort_base {
+}
+
+declare const RoomErasurePort_base: Context.ServiceClass<RoomErasurePort, "@voltro/RoomErasurePort", {
+    erase(input: RoomErasureInput): Effect.Effect<void, ProtocolError>;
+}>;
+
+export declare const roomErasurePortFixture: {
+    kind: "port";
+    tag: typeof RoomErasurePort;
+    fakeLayer: Layer.Layer<RoomErasurePort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+declare interface RoomExtension<S, I> {
+    readonly name: string;
+    readonly fields: ReadonlyArray<Extract<keyof S, string>>;
+    readonly channel: string;
+    readonly tickBudgetMs: number;
+    readonly beforeTick?: RoomSyncHook<RoomExtensionContext<S, I>>;
+    readonly afterTick?: RoomSyncHook<RoomExtensionContext<S, I>>;
+}
+
+declare interface RoomExtensionContext<S, I> {
+    /** Prepared native CPU queries only, installed before actor lifecycle. */
+    readonly geometry?: GeometryWorldView | undefined;
+    readonly state: RoomState<Partial<S>>;
+    readonly tick: number;
+    readonly dt: number;
+    readonly inputs: ReadonlyArray<Omit<RoomInput<I>, 'client'> & {
+        readonly client: Pick<RoomClient, 'sessionId' | 'subjectId' | 'tenantId' | 'isBot' | 'countsAsPlayer' | 'attributes'>;
+    }>;
+    readonly clock: RoomClock;
+    send(sessionId: string, payload: unknown): void;
+}
+
+export declare const roomExternalWorkWithdrawalFakeLayer: Layer.Layer<RoomExternalWorkWithdrawalPort>;
+
+export declare type RoomExternalWorkWithdrawalFixtureOverrides = Partial<Context.Service.Shape<typeof RoomExternalWorkWithdrawalPort>>;
+
+/** 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. */
+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>;
+}>;
+
+export declare const roomExternalWorkWithdrawalPortFixture: {
+    kind: "port";
+    tag: typeof RoomExternalWorkWithdrawalPort;
+    fakeLayer: Layer.Layer<RoomExternalWorkWithdrawalPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+declare class RoomForbidden extends RoomForbidden_base {
+}
+
+declare const RoomForbidden_base: Schema.Class<RoomForbidden, Schema.TaggedStruct<"RoomForbidden", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare type RoomFrame = RoomWorldHandoffFrame | {
+    readonly kind: 'Hello';
+    readonly protocolVersion: number;
+    readonly token: Uint8Array;
+    readonly schemaHash: number;
+    readonly resumeFromTick?: number;
+    readonly transportCaps: number;
+} | {
+    readonly kind: 'Input';
+    readonly firstSeq: number;
+    readonly inputs: ReadonlyArray<{
+        readonly tickHint: number;
+        readonly payload: Uint8Array;
+    }>;
+    readonly ackTick?: number;
+}
+/** `lossPermille`: the client's estimated loss of state datagrams (0–1000), once it has one. */
+| {
+    readonly kind: 'Ack';
+    readonly tick: number;
+    readonly lossPermille?: number;
+} | {
+    readonly kind: 'Ping';
+    readonly clientTimeMs: number;
+} | {
+    readonly kind: 'ClientMessage' | 'ServerMessage';
+    readonly channelId: number;
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: 'Leave';
+    readonly reason: number;
+} | {
+    readonly kind: 'Welcome';
+    readonly sessionId: string;
+    readonly tick: number;
+    readonly serverTimeMs: number;
+    readonly epoch: number;
+    readonly baseline: Uint8Array;
+    readonly transformRules: Uint8Array;
+} | {
+    readonly kind: 'Delta';
+    readonly tick: number;
+    readonly baseTick: number;
+    readonly patch: Uint8Array;
+    readonly inputAck?: RoomFrameInputReceipt;
+} | {
+    readonly kind: 'Full';
+    readonly tick: number;
+    readonly epoch: number;
+    readonly baseline: Uint8Array;
+    readonly inputAck?: RoomFrameInputReceipt;
+} | {
+    readonly kind: 'InputAck';
+    readonly lastAppliedSeq: number;
+    readonly tick: number;
+    readonly flags: number;
+}
+/** `deltaDatagramsSent`: state deltas this Session sent as datagrams so far, for the client's loss estimate. */
+| {
+    readonly kind: 'Pong';
+    readonly clientTimeMs: number;
+    readonly serverTimeMs: number;
+    readonly tick: number;
+    readonly deltaDatagramsSent?: number;
+} | {
+    readonly kind: 'Kick';
+    readonly code: number;
+    readonly reason: string;
+} | {
+    readonly kind: 'Migrate';
+    readonly address?: string;
+    readonly graceMs: number;
+} | {
+    readonly kind: 'Error';
+    readonly code: number;
+    readonly detail: string;
+} | {
+    readonly kind: 'LsInput';
+    readonly firstTick: number;
+    readonly inputs: ReadonlyArray<Uint8Array>;
+} | {
+    readonly kind: 'LsInputs';
+    readonly firstTick: number;
+    readonly matrices: ReadonlyArray<RoomLockstepInputMatrix>;
+} | {
+    readonly kind: 'LsHash';
+    readonly tick: number;
+    readonly hi: number;
+    readonly lo: number;
+} | {
+    readonly kind: 'LsDesync';
+    readonly tick: number;
+    readonly action: 'resync';
+    readonly snapshot: Uint8Array;
+} | {
+    readonly kind: 'LsDesync';
+    readonly tick: number;
+    readonly action: 'end' | 'flag';
+    readonly snapshot?: never;
+} | {
+    readonly kind: 'LsStart';
+    readonly startTick: number;
+    readonly seed: number;
+    readonly options: Uint8Array;
+    readonly serverTimeMs: number;
+    readonly localPlayerId: number;
+    readonly roster: ReadonlyArray<RoomLockstepWirePlayer>;
+    readonly history?: Uint8Array;
+    readonly snapshot?: Uint8Array;
+} | {
+    readonly kind: 'LsStall';
+    readonly waitingFor: RoomLockstepPlayerMask;
+}
+/** A player admitted after Start: from `tick` on, every matrix carries its `slot`. */
+| {
+    readonly kind: 'LsJoin';
+    readonly tick: number;
+    readonly slot: number;
+    readonly playerId: number;
+};
+
+declare interface RoomFrameInputReceipt {
+    readonly lastAppliedSeq: number;
+    readonly flags: number;
+}
+
+declare class RoomFull extends RoomFull_base {
+}
+
+declare const RoomFull_base: Schema.Class<RoomFull, Schema.TaggedStruct<"RoomFull", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+export declare const roomGeometryAdministrationFakeLayer: Layer.Layer<RoomGeometryAdministrationPort, never, never>;
+
+/** API administration resolves actual current SQL Host; wire inputs never select it. */
+declare class RoomGeometryAdministrationPort extends RoomGeometryAdministrationPort_base {
+}
+
+declare const RoomGeometryAdministrationPort_base: Context.ServiceClass<RoomGeometryAdministrationPort, "@voltro/RoomGeometryAdministrationPort", {
+    reload(roomId: string, request: RoomGeometryReloadRequest, subject: Subject): Effect.Effect<void, GeometryPersistenceError>;
+    rollback(roomId: string, request: RoomGeometryRollbackRequest, subject: Subject): Effect.Effect<void, GeometryPersistenceError>;
+    /** The chunk view: present when the administration knows the Worlds. */
+    readonly chunks?: (roomId: string, subject: Subject) => Effect.Effect<RoomGeometryChunks, GeometryPersistenceError>;
+}>;
+
+export declare const roomGeometryAdministrationPortFixture: {
+    kind: "port";
+    tag: typeof RoomGeometryAdministrationPort;
+    fakeLayer: Layer.Layer<RoomGeometryAdministrationPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "BudgetExceeded" | "unexpectedSuccess", never, never>;
+        expected: string;
+    };
+};
+
+/** The changed chunks a World cell Room owns, newest first. `truncated` when more exist than the read returns. */
+declare interface RoomGeometryChunks {
+    readonly roomId: string;
+    readonly worldId: string;
+    readonly zoneId: string;
+    readonly cellId: string;
+    readonly chunks: ReadonlyArray<RoomGeometryChunkState>;
+    readonly truncated: boolean;
+}
+
+/** One chunk a World cell Room owns that players changed: its durable revision and whether it
+ * still differs from its static version (`changed: false` after a reset). */
+declare interface RoomGeometryChunkState {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+    readonly layerSetId: string;
+    readonly version: string;
+    readonly revision: number;
+    readonly changed: boolean;
+    readonly updatedAt: number;
+}
+
+export declare const roomGeometryControlFakeLayer: Layer.Layer<RoomGeometryControlPort, never, never>;
+
+/** Existing authenticated API-to-Host carrier. Caller authority must be
+ * resolved again at the actual Host; success joins native CPU admission and
+ * retained cleanup, never merely receipt publication. No player state input. */
+declare class RoomGeometryControlPort extends RoomGeometryControlPort_base {
+}
+
+declare const RoomGeometryControlPort_base: Context.ServiceClass<RoomGeometryControlPort, "@voltro/RoomGeometryControlPort", {
+    reload(hostId: string, roomId: string, request: RoomGeometryReloadRequest, subject: Subject): Effect.Effect<void, RoomControlError>;
+    rollback(hostId: string, roomId: string, request: RoomGeometryRollbackRequest, subject: Subject): Effect.Effect<void, RoomControlError>;
+}>;
+
+/** Same actual Tag/fail-closed replacement, not complete-system acceptance. */
+export declare const roomGeometryControlPortFixture: {
+    kind: "port";
+    tag: typeof RoomGeometryControlPort;
+    fakeLayer: Layer.Layer<RoomGeometryControlPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"RoomAuthoringError" | "ProtocolError" | "RoomsClosed" | "RoomFull" | "RoomPoolWaking" | "RoomLocked" | "RoomGone" | "RoomForbidden" | "SeatExpired" | "NotRoomMember" | "BudgetExceeded" | "unexpectedSuccess", never, never>;
+        expected: string;
+    };
+};
+
+declare interface RoomGeometryReloadRequest {
+    readonly version: string;
+    readonly requestId: string;
+}
+
+/** 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 const roomHostAdoptionFakeLayer: Layer.Layer<RoomHostAdoptionPort, never, never>;
+
+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>;
+}>;
+
+export declare const roomHostAdoptionPortFixture: {
+    kind: "port";
+    tag: Context.Service<RoomHostAdoptionPort, {
+        adopt(hostId: string, roomId: string, tenantId: string, priorEpoch: number): Effect.Effect<void, ProtocolError>;
+    }>;
+    fakeLayer: Layer.Layer<RoomHostAdoptionPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+export declare const roomHostControlFakeLayer: Layer.Layer<RoomHostControlPort, never, never>;
+
+export declare type RoomHostControlFixtureOverrides = Partial<Context.Service.Shape<typeof RoomHostControlPort>>;
+
+/** API-to-host transport seam. The target executes on its existing controller;
+ * resolved Subjects are trusted server inputs, never player-supplied authority. */
+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>;
+}>;
+
+export declare const roomHostControlPortFixture: {
+    kind: "port";
+    tag: Context.Service<RoomHostControlPort, {
+        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>;
+    }>;
+    fakeLayer: Layer.Layer<RoomHostControlPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+declare type RoomHostDrainError = ProtocolError | BudgetExceeded | RoomForbidden | RoomGone;
+
+export declare const roomHostDrainFakeLayer: Layer.Layer<RoomHostDrainPort, never, never>;
+
+export declare type RoomHostDrainFixtureOverrides = Partial<Context.Service.Shape<typeof RoomHostDrainPort>>;
+
+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>;
+}>;
+
+export declare const roomHostDrainPortFixture: {
+    kind: "port";
+    tag: typeof RoomHostDrainPort;
+    fakeLayer: Layer.Layer<RoomHostDrainPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<("ProtocolError" | "RoomGone" | "RoomForbidden" | "BudgetExceeded" | "unexpected-success")[], never, never>;
+        expected: string[];
+    };
+};
+
+export declare const roomHostKickFakeLayer: Layer.Layer<RoomHostKickPort>;
+
+export declare type RoomHostKickFixtureOverrides = Partial<Context.Service.Shape<typeof RoomHostKickPort>>;
+
+/** API-to-host operator kick on the owning Host's existing controller. */
+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>;
+}>;
+
+export declare const roomHostKickPortFixture: {
+    kind: "port";
+    tag: typeof RoomHostKickPort;
+    fakeLayer: Layer.Layer<RoomHostKickPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"RoomAuthoringError" | "ProtocolError" | "RoomsClosed" | "RoomFull" | "RoomPoolWaking" | "RoomLocked" | "RoomGone" | "RoomForbidden" | "SeatExpired" | "NotRoomMember" | "BudgetExceeded" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+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 const roomHostWithdrawalFakeLayer: Layer.Layer<RoomHostWithdrawalPort>;
+
+export declare type RoomHostWithdrawalFixtureOverrides = Partial<Context.Service.Shape<typeof RoomHostWithdrawalPort>>;
+
+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. */
+declare class RoomHostWithdrawalPort extends RoomHostWithdrawalPort_base {
+}
+
+declare const RoomHostWithdrawalPort_base: Context.ServiceClass<RoomHostWithdrawalPort, "@voltro/RoomHostWithdrawalPort", {
+    withdraw(hostId: string, input: RoomHostWithdrawalInput): Effect.Effect<void, ProtocolError>;
+}>;
+
+export declare const roomHostWithdrawalPortFixture: {
+    kind: "port";
+    tag: typeof RoomHostWithdrawalPort;
+    fakeLayer: Layer.Layer<RoomHostWithdrawalPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+declare interface RoomInput<I> {
+    readonly client: RoomClient;
+    readonly seq: number;
+    readonly tickHint: number;
+    readonly input: I;
+}
+
+/** 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;
+}
+
+declare interface RoomInputRedundancyOptions {
+    /** Input count is a redundancy budget, never a delivery guarantee. */
+    readonly inputRedundancy: number;
+    readonly maxInputHistoryBytes: number;
+}
+
+declare interface RoomKickInput {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly subjectId: string;
+    readonly reason: string;
+}
+
+declare interface RoomKickReceipt {
+    readonly kicked: number;
+}
+
+declare type RoomLeaveReason = 'left' | 'kicked' | 'reconnecting' | 'timeout' | 'disposed';
+
+/** Lifecycle Effects are run by the host outside the synchronous tick. `void` admits block bodies;
+ * a returned Promise is refused at runtime with an authoring error. */
+declare type RoomLifecycleHook<C> = (context: C) => void | Effect.Effect<void, unknown>;
+
+/** 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 interface RoomListingContext<S, O> {
+    readonly state: S;
+    readonly options: O;
+}
+
+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;
+}
+
+export declare const roomLockstepAdmissionFakeLayer: Layer.Layer<RoomLockstepAdmissionPort>;
+
+export declare type RoomLockstepAdmissionFixtureOverrides = Partial<Context.Service.Shape<typeof RoomLockstepAdmissionPort>>;
+
+/** Trusted complete outside-tick SQL creation capability, never a player state RPC. */
+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>;
+}>;
+
+export declare const roomLockstepAdmissionPortFixture: {
+    kind: "port";
+    tag: typeof RoomLockstepAdmissionPort;
+    fakeLayer: Layer.Layer<RoomLockstepAdmissionPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+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 RoomLockstepInitialPlayerContext extends RoomLockstepInitialRosterContext {
+    /** Server-private current admitted identity, never projected to the roster wire. */
+    readonly subjectId: string;
+    readonly sessionId: string;
+}
+
+declare interface RoomLockstepInitialRosterContext extends RoomLockstepRosterScope {
+    readonly maxPlayers: number;
+    readonly players: ReadonlyArray<RoomLockstepRosterPlayer>;
+}
+
+declare interface RoomLockstepInputMatrix {
+    readonly players: RoomLockstepPlayerMask;
+    readonly inputs: ReadonlyArray<Uint8Array>;
+}
+
+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>;
+}
+
+export declare const roomLockstepJournalFakeLayer: Layer.Layer<RoomLockstepJournalPort>;
+
+export declare type RoomLockstepJournalFixtureOverrides = Partial<Context.Service.Shape<typeof RoomLockstepJournalPort>>;
+
+/** 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. */
+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>;
+}>;
+
+export declare const roomLockstepJournalPortFixture: {
+    kind: "port";
+    tag: typeof RoomLockstepJournalPort;
+    fakeLayer: Layer.Layer<RoomLockstepJournalPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+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;
+    }>;
+}
+
+/** Bits identify server-assigned roster slots 0..63, not Subject or player IDs. */
+declare type RoomLockstepPlayerMask = Uint64Words;
+
+declare interface RoomLockstepRecoveryTruth {
+    readonly admission: RoomLockstepAdmission;
+    readonly journal: RoomLockstepJournal | null;
+    readonly options: unknown;
+}
+
+declare interface RoomLockstepRosterPlayer {
+    readonly slot: number;
+    readonly playerId: number;
+}
+
+declare interface RoomLockstepRosterScope {
+    readonly roomId: string;
+    readonly tenantId: string;
+    readonly epoch: number;
+}
+
+declare interface RoomLockstepTerminal extends RoomLockstepRosterScope {
+    readonly disposition: 'faulted' | 'disposed';
+}
+
+export declare const roomLockstepTerminalFakeLayer: Layer.Layer<RoomLockstepTerminalPort, never, never>;
+
+export declare type RoomLockstepTerminalFixtureOverrides = Partial<Context.Service.Shape<typeof RoomLockstepTerminalPort>>;
+
+/** Outside-tick lifecycle commit after actual Session/native withdrawal. Retains
+ * SQL creation and input truth; this is neither a checkpoint nor an erase. */
+declare class RoomLockstepTerminalPort extends RoomLockstepTerminalPort_base {
+}
+
+declare const RoomLockstepTerminalPort_base: Context.ServiceClass<RoomLockstepTerminalPort, "@voltro/RoomLockstepTerminalPort", {
+    terminate(input: RoomLockstepTerminal): Effect.Effect<RoomLockstepTerminalReceipt, ProtocolError>;
+}>;
+
+export declare const roomLockstepTerminalPortFixture: {
+    kind: "port";
+    tag: typeof RoomLockstepTerminalPort;
+    fakeLayer: Layer.Layer<RoomLockstepTerminalPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+declare interface RoomLockstepTerminalReceipt extends RoomLockstepTerminal {
+    readonly hostId: string;
+}
+
+/** Public opaque simulation identities, never Subjects or Session credentials. */
+declare interface RoomLockstepWirePlayer {
+    readonly slot: number;
+    readonly playerId: number;
+}
+
+declare interface RoomMatchPreparation {
+    readonly requestId: string;
+    readonly room: string;
+    readonly options: unknown;
+    readonly pool?: string;
+}
+
+declare interface RoomMatchReceipt {
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+declare interface RoomMemberContext<S, O> {
+    /** Prepared native CPU queries only, installed before actor lifecycle. */
+    readonly geometry?: GeometryWorldView | undefined;
+    readonly state: RoomState<S>;
+    readonly options: O;
+    readonly client: RoomClient;
+    readonly app: RoomAppBridge;
+    readonly clock: RoomClock;
+    readonly scheduler: RoomScheduler;
+    /** World Rooms, ordinary player join: the server-owned entity this Session controls and
+     * its last persisted `persistEntity` data. Build the state entity from it when absent. */
+    readonly world?: RoomWorldMember | undefined;
+}
+
+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>;
+
+declare interface RoomPublicEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly clients: number;
+    readonly maxClients: number;
+    readonly locked: boolean;
+}
+
+export declare const roomReaperFakeLayer: Layer.Layer<RoomReaperPort, never, never>;
+
+export declare type RoomReaperFixtureOverrides = Partial<Context.Service.Shape<typeof RoomReaperPort>>;
+
+declare interface RoomReaperInput {
+    readonly hostId?: string | undefined;
+    readonly afterHostId?: string | undefined;
+    readonly afterRoomId?: string;
+}
+
+declare class RoomReaperPort extends RoomReaperPort_base {
+}
+
+declare const RoomReaperPort_base: Context.ServiceClass<RoomReaperPort, "@voltro/RoomReaperPort", {
+    run(input: RoomReaperInput): Effect.Effect<RoomReaperReport, ProtocolError | BudgetExceeded>;
+}>;
+
+export declare const roomReaperPortFixture: {
+    kind: "port";
+    tag: Context.Service<RoomReaperPort, {
+        run(input: RoomReaperInput): Effect.Effect< RoomReaperReport, ProtocolError | BudgetExceeded>;
+    }>;
+    fakeLayer: Layer.Layer<RoomReaperPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+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';
+}
+
+/** Framework-free binary session core. Reservation, reconnect orchestration and
+ * render hooks are separate; this core never persists a seat token. */
+declare interface RoomReconciliationSnapshot<S> {
+    readonly epoch: number;
+    readonly tick: number;
+    readonly lastAppliedSeq: number;
+    readonly state: S;
+}
+
+export declare const roomReconnectSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (options?: Partial<{
+        readonly graceMs: number;
+    }>) => {
+        readonly graceMs: number;
+    };
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+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;
+}
+
+export declare const roomRecoveryFakeLayer: Layer.Layer<RoomRecoveryPort, never, never>;
+
+export declare type RoomRecoveryFixtureOverrides = Partial<Context.Service.Shape<typeof RoomRecoveryPort>>;
+
+/** Trusted outside-tick control, never a player RPC or a death certificate. */
+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>;
+}>;
+
+export declare const roomRecoveryPortFixture: {
+    kind: "port";
+    tag: Context.Service<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>;
+    }>;
+    fakeLayer: Layer.Layer<RoomRecoveryPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+declare interface RoomReliableLane {
+    send(frame: Uint8Array): Promise<void>;
+    onFrame(listener: (frame: Uint8Array, receivedAt: number) => void): () => void;
+}
+
+export declare const roomReplayFakeLayer: Layer.Layer<RoomReplayPort, never, never>;
+
+export declare type RoomReplayFixtureOverrides = Partial<Context.Service.Shape<typeof RoomReplayPort>>;
+
+/** Browser-safe trusted server contract. No player mutation or storage adapter
+ * is imported at value level; replacement services use this exact Tag. */
+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>;
+}>;
+
+export declare const roomReplayPortFixture: {
+    kind: "port";
+    tag: Context.Service<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>;
+    }>;
+    fakeLayer: Layer.Layer<RoomReplayPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+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;
+}
+
+/** Default fake deliberately fails closed. Its actual scoped read, rather than
+ * an exported passing flag, is available to the eventual system conformance. */
+export declare const roomReserveFakeLayer: Layer.Layer<RoomReservePort>;
+
+export declare type RoomReserveFixtureOverrides = Partial<Context.Service.Shape<typeof RoomReservePort>>;
+
+/** The game-stack reservation seam. Other systems receive the same service
+ * when the default SQL/host implementation is replaced by an application. */
+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>;
+}>;
+
+export declare const roomReservePortFixture: {
+    kind: "port";
+    tag: typeof RoomReservePort;
+    fakeLayer: Layer.Layer<RoomReservePort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"RoomAuthoringError" | "ProtocolError" | "RoomsClosed" | "RoomFull" | "RoomPoolWaking" | "RoomLocked" | "RoomGone" | "RoomForbidden" | "SeatExpired" | "NotRoomMember" | "BudgetExceeded" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+declare type RoomScalar = string | number | boolean | null;
+
+declare interface RoomScheduler {
+    after(milliseconds: number, label: string): void;
+    every(milliseconds: number, label: string): void;
+    cancel(label: string): void;
+}
+
+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>>;
+
+declare type RoomSeatClaims = Omit<(typeof SeatClaimsSchema)["Type"], 'purpose'>;
+
+/** Server-only fixtures preserve the actual default function identity and prove
+ * composed app framing through issued-identity validation and real HMAC. */
+export declare const roomSeatSignSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (claims: RoomSeatClaims, secrets: SessionSecrets, nowMs: number) => Uint8Array;
+    defaultProbe: {
+        run: () => Effect.Effect<"session" | "framed", never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<"session" | "framed", never, never>;
+        expected: string;
+    };
+};
+
+export declare const roomSeatVerifySlotFixture: {
+    kind: "slot";
+    defaultImplementation: (token: Uint8Array, secrets: SessionSecrets, nowMs: number) => RoomSeatClaims;
+    defaultProbe: {
+        run: () => Effect.Effect<"session" | "framed", never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<"session" | "framed", never, never>;
+        expected: string;
+    };
+};
+
+export declare const roomSelectHostSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (hosts: ReadonlyArray<RoomHostListing>, region: string) => RoomHostListing | null;
+    defaultProbe: {
+        run: () => Effect.Effect<string | undefined, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string | undefined, never, never>;
+        expected: string;
+    };
+};
+
+declare class RoomSession<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> {
+    readonly transport: RoomTransport;
+    readonly clock: RoomClock;
+    readonly maxBaselines: number;
+    private readonly codecs;
+    private readonly baselines;
+    private readonly handoffListeners;
+    private readonly listeners;
+    private readonly messageListeners;
+    private readonly detach;
+    private currentState;
+    private currentStatus;
+    private currentError;
+    private tick;
+    private epoch;
+    private receivedAt;
+    private seq;
+    private inputAck;
+    private acknowledgedTick;
+    private pendingInputAck;
+    private pairedInputState;
+    private sessionId;
+    private started;
+    private readonly pendingPings;
+    private deltaDatagramsReceived;
+    private lossSample;
+    private lossEstimate;
+    private readonly sampling;
+    readonly clockSync: RoomClockSync;
+    private readonly inputHistory;
+    constructor(transport: RoomTransport, manifest: RoomWireManifest<S, I>, clock: RoomClock, maxBaselines?: number, recovery?: RoomClientInputRecovery, sampling?: RoomClockSamplingOptions, redundancy?: RoomInputRedundancyOptions);
+    /* Excluded from this release type: currentReliableChannelIdentity */
+    /* Excluded from this release type: currentReliableClientChannelIdentity */
+    get status(): RoomSessionStatus;
+    get error(): ProtocolError | null;
+    get state(): (S)["Type"] | null;
+    get lastAppliedTick(): number;
+    get lastAppliedInputSeq(): number;
+    /** Actor-applied receipt paired with the exact delivered state tick/epoch.
+     * This is not a SQL persistence ACK or a state from a different tick. */
+    get reconciliationSnapshot(): RoomReconciliationSnapshot<(S)["Type"]> | null;
+    get nextInputSeq(): number;
+    get id(): string | null;
+    /** Estimated loss of state datagrams (0–1, smoothed), measured between Pongs; null until the
+     * Host has sent enough datagrams. Reported back to the Host in every Ack. */
+    get lossRate(): number | null;
+    deliveredSnapshot(): RoomDeliveredState<(S)["Type"]> | null;
+    serverNow(): number | null;
+    start(token: Uint8Array, resumeFromTick?: number): Promise<void>;
+    send(input: (I)["Type"]): Promise<number>;
+    message(channelName: string, payload: unknown): Promise<void>;
+    /** Reconnect replays only previously submitted, unacknowledged intentions. */
+    replay(seq: number, input: (I)["Type"]): Promise<void>;
+    ping(): Promise<void>;
+    subscribe(listener: () => void): () => void;
+    /** Render-only reliable notice; does not change state, inputs or connection ownership. */
+    onWorldHandoff(listener: (frame: RoomWorldHandoffFrame) => void): () => void;
+    onMessage(channel: string, listener: (payload: unknown) => void): () => void;
+    private sendFrame;
+    /** A window needs at least 8 datagrams; datagrams still in flight count as lost here and as
+     * received in the next window, which the smoothing evens out. */
+    private sampleLoss;
+    private ackFrame;
+    private acknowledge;
+    private fail;
+    private install;
+    private pairInputState;
+    /** Shared receipt authority for the independent frame and its exact state
+     * trailer. A state/receipt pair is installed before notifying subscribers. */
+    private observeInputAck;
+    private receive;
+    private notify;
+    private cleanup;
+    leave(): Promise<void>;
+}
+
+declare type RoomSessionStatus = 'connecting' | 'joined' | 'reconnecting' | 'left' | 'kicked' | 'gone';
+
+export declare const roomSnapshotBlobFakeLayer: Layer.Layer<RoomSnapshotBlobPort, never, never>;
+
+export declare type RoomSnapshotBlobFixtureOverrides = Partial<Context.Service.Shape<typeof RoomSnapshotBlobPort>>;
+
+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. */
+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>;
+}>;
+
+export declare const roomSnapshotBlobPortFixture: {
+    kind: "port";
+    tag: Context.Service<RoomSnapshotBlobPort, {
+        recover(input: RoomSnapshotBlobRecoveryInput): Effect.Effect< RoomSnapshotBlobRecovery, ProtocolError>;
+        write(input: RoomSnapshotBlobInput): Effect.Effect< RoomSnapshotBlobReference, ProtocolError>;
+        read(reference: RoomSnapshotBlobReference, expected: RoomSnapshotBlobScope): Effect.Effect<Uint8Array, ProtocolError>;
+        release(reference: RoomSnapshotBlobReference, expected: RoomSnapshotBlobScope): Effect.Effect<void, ProtocolError>;
+    }>;
+    fakeLayer: Layer.Layer<RoomSnapshotBlobPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+};
+
+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;
+}
+
+declare type RoomSnapshotBudgetFactory = (options: Readonly<RoomSnapshotBudgetOptions>) => RoomSnapshotBudgetService;
+
+declare interface RoomSnapshotBudgetOptions {
+    readonly budgetBytesPerSec?: number;
+    readonly burstBytes?: number;
+}
+
+declare interface RoomSnapshotBudgetService {
+    /** Account a durable boundary without dropping commands/initial/terminal
+     * state. Its debt defers subsequent periodic snapshots. */
+    forced(bytes: number, now: number): void;
+    periodic(roomId: string, bytes: number, now: number): boolean;
+    /** A blocked periodic head cannot be bypassed by smaller periodic payloads. */
+    blocked(roomId: string): boolean;
+    forget(roomId: string): void;
+    metrics(): {
+        readonly deferred: number;
+        readonly forcedBytes: number;
+        readonly periodicBytes: number;
+        readonly debtBytes: number;
+    };
+}
+
+export declare const roomSnapshotBudgetSlotFixture: {
+    kind: "slot";
+    defaultImplementation: RoomSnapshotBudgetFactory;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+declare interface RoomSnapshotPolicy<S> {
+    readonly everyMs: number;
+    readonly onlyIfChanged: boolean;
+    readonly mode: 'full' | 'delta';
+    readonly fullEvery: number;
+    readonly keepFulls: number;
+    readonly store: 'auto';
+    /** Maximum inline codec payload; the host may impose a smaller cutoff. */
+    readonly maxInlineBytes: number;
+    /** Full-schema projection of volatile data; never a partial-state format. */
+    readonly pick: (state: S) => S;
+}
+
+export declare const roomSnapshotSlotFixture: {
+    kind: "slot";
+    defaultImplementation: <S>(options?: Readonly<Partial< RoomSnapshotPolicy<S>>>) => RoomSnapshotPolicy<S>;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+declare interface RoomSpectatorPolicy {
+    readonly delayMs: number;
+    readonly retentionMs: number;
+    readonly maxFrames: number;
+    readonly maxBytes: number;
+    readonly maxFrameBytes: number;
+    readonly checkpointEveryMs: number;
+    readonly maxDeliveryFrames: number;
+}
+
+export declare const roomSpectatorSlotFixture: {
+    kind: "slot";
+    defaultImplementation: (input?: Readonly<Partial< RoomSpectatorPolicy>>) => RoomSpectatorPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<number | undefined, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number | undefined, never, never>;
+        expected: number;
+    };
+};
+
+/** Plain mutable state; the author receives no store or database capability. */
+declare type RoomState<A> = A extends ReadonlyArray<infer V> ? Array<RoomState<V>> : A extends object ? {
+    -readonly [K in keyof A]: RoomState<A[K]>;
+} : A;
+
+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;
+}
+
+export declare const roomSubjectPrivacyFakeLayer: Layer.Layer<RoomSubjectPrivacyPort>;
+
+export declare type RoomSubjectPrivacyFixtureOverrides = Partial<Context.Service.Shape<typeof RoomSubjectPrivacyPort>>;
+
+/** Coordinated state/command/session withdrawal, not raw seat-row deletion.
+ * The trusted caller authorizes the target and owns durable request recovery. */
+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>;
+}>;
+
+export declare const roomSubjectPrivacyPortFixture: {
+    kind: "port";
+    tag: typeof RoomSubjectPrivacyPort;
+    fakeLayer: Layer.Layer<RoomSubjectPrivacyPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+/** Synchronous hook. `void` admits parameterless block bodies (TypeScript cannot narrow those to
+ * `undefined`); any returned value, a Promise included, is refused at runtime with an authoring error. */
+declare type RoomSyncHook<C> = (context: C) => void;
+
+declare interface RoomTickContext<S, I> {
+    /** Prepared native CPU queries only, installed before actor lifecycle. */
+    readonly geometry?: GeometryWorldView | undefined;
+    readonly state: RoomState<S>;
+    readonly tick: number;
+    readonly dt: number;
+    readonly inputs: ReadonlyArray<RoomInput<I>>;
+    readonly app: RoomAppBridge;
+    readonly clock: RoomClock;
+    readonly scheduler: RoomScheduler;
+    broadcast(channel: string, payload: unknown): void;
+}
+
+declare interface RoomTransport {
+    readonly name: 'ws' | 'wt';
+    readonly reliable: RoomReliableLane;
+    readonly unreliable?: RoomDatagramLane | undefined;
+    readonly signal: AbortSignal;
+    stats(): {
+        readonly rttMs: number | null;
+        readonly queuedBytes: number;
+        readonly droppedDatagrams: number;
+    };
+    close(code: number, reason: string): void;
+    /** When provided, joins actual parent/stream withdrawal and permits retry.
+     * Synchronous close alone does not establish native terminal evidence. */
+    closeAsync?(code: number, reason: string): Promise<void>;
+}
+
+/** Execute transport observations against a fresh actual adapter pair. No
+ * Vitest runtime dependency, SQL/auth acceptance, synthetic latency claim or
+ * successful fixture fallback. Declare modeled/native provenance separately.
+ * Intent/stale/actor/Room authority stay in the actual session suites. */
+export declare const roomTransportConformance: (makeTransport: () => Promise<RoomTransportConformanceHarness>) => Promise<RoomTransportConformanceObservation>;
+
+export declare interface RoomTransportConformanceHarness {
+    readonly client: RoomTransport;
+    readonly server: RoomTransport;
+    /** Use small real fixture budgets, independent of production capacity. */
+    readonly maxQueuedBytes: number;
+    readonly maxFrameBytes: number;
+    /** Advance a modeled clock or await actual peer I/O; never fabricate frames. */
+    drive(): Promise<void>;
+    pauseReliable(): RoomTransportPressureControl;
+    pauseDatagrams?(): RoomTransportPressureControl;
+    /** Await both actual peers, pending tasks, parent transports and owned locks. */
+    close(): Promise<void>;
+}
+
+export declare interface RoomTransportConformanceObservation {
+    readonly scope: 'transport-only';
+    readonly datagrams: boolean;
+    readonly checks: ReadonlyArray<'binary-control' | 'reliable-order' | 'native-pressure' | 'queue-overflow' | 'withdrawal' | 'datagram-bound' | 'datagram-latest'>;
+}
+
+/** 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;
+}
+
+export declare interface RoomTransportPressureControl {
+    /** Settles when the actual submitted reliable write is held. */
+    readonly blocked: Promise<void>;
+    resume(): void;
+}
+
+declare interface RoomViewContext<S> {
+    readonly state: S;
+    readonly client: Pick<RoomClient, 'sessionId' | 'subjectId' | 'tenantId' | 'isBot' | 'countsAsPlayer' | 'attributes'>;
+    readonly role: 'player' | 'spectator';
+    readonly tick: number;
+}
+
+export declare const roomViewSlotFixture: {
+    kind: "slot";
+    defaultImplementation: <S>(context: RoomViewContext<S>) => S;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+declare interface RoomWireManifest<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> {
+    readonly state: S;
+    readonly input: I;
+    readonly messages?: Readonly<Record<string, RoomChannel>>;
+}
+
+/** World Rooms keep their authored entities in the declared state record. */
+declare type RoomWorldEntity<S> = S extends {
+    readonly entities: Readonly<Record<string, infer E>>;
+} ? RoomState<E> & {
+    readonly id: string;
+} : never;
+
+/** Render/connection coordination only: no token and no ownership assertion. */
+declare interface RoomWorldHandoffFrame {
+    readonly kind: 'WorldHandoff';
+    readonly phase: 'departed' | 'cancelled';
+    readonly transitionId: string;
+    readonly entityId: string;
+    readonly tick: number;
+    readonly sourceEpoch: number;
+    readonly targetRoomId: string;
+    readonly targetEpoch: number;
+    readonly holdMs: number;
+}
+
+declare interface RoomWorldHookContext<S> {
+    readonly state: RoomState<S>;
+    readonly phase: 'prepare' | 'commit' | 'rollback';
+    readonly requestId?: string | undefined;
+    readonly entity: RoomWorldEntity<S>;
+}
+
+declare interface RoomWorldHookInput<E = unknown> {
+    /** Actual target placement, distinct from the source location. Only guarded
+     * target entry uses it; source rollback must restore its exact snapshot. */
+    readonly arrival?: WorldEntityLocation;
+    readonly epoch: number;
+    readonly entity: E;
+    readonly location: WorldEntityLocation;
+    readonly requestId?: string | undefined;
+}
+
+declare interface RoomWorldHooks<S> {
+    /** Opt-in cell movement: synchronous author projection/write, no I/O. */
+    readonly movement?: RoomWorldMovement<S>;
+    /** Retained checkpoint receipts awaiting confirmed transition retirement. */
+    readonly maxPendingTransitions?: number;
+    readonly onEnter: RoomLifecycleHook<RoomWorldHookContext<S> & {
+        readonly from: WorldEntityLocation;
+        readonly to?: WorldEntityLocation;
+    }>;
+    readonly onExit: RoomLifecycleHook<RoomWorldHookContext<S> & {
+        readonly to: WorldEntityLocation;
+    }>;
+    /** Publish a projection on commit; remove that projection on rollback. Never
+     * promote it into authoritative entities. Rollback may retry after failure. */
+    readonly onGhost: RoomLifecycleHook<RoomWorldHookContext<S>>;
+    /** Synchronous, bounded JSON projection; no SQL or asynchronous effect here. */
+    readonly persistEntity: (context: {
+        readonly entity: RoomWorldEntity<S>;
+    }) => unknown;
+    /** A player who arrived by a World transition is now an active member. `onJoin` does not run for
+     * such arrivals (the entity came with `onEnter`); this is where the Room sees the arriving client,
+     * e.g. its seat attributes (`client.attributes`). */
+    readonly onMemberEnter?: RoomLifecycleHook<{
+        readonly state: RoomState<S>;
+        readonly client: RoomClient;
+        readonly entityId: string;
+    }>;
+}
+
+/** The server-owned entity an ordinary World player Session controls, as last persisted.
+ * The Room's `onJoin` receives it as `world` and builds the state entity when absent. */
+declare interface RoomWorldMember {
+    readonly entityId: string;
+    readonly worldId: string;
+    readonly zoneId: string;
+    readonly cellId: string;
+    readonly layer: number;
+    readonly revision: number;
+    /** The Room's `persistEntity` projection from the entity's last write. */
+    readonly data: unknown;
+}
+
+declare interface RoomWorldMovement<S> {
+    readonly maxEntities: number;
+    readonly maxBytesPerTick: number;
+    readonly position: (entity: RoomWorldEntity<S>) => WorldPoint;
+    readonly move: (entity: RoomWorldEntity<S>, at: WorldPoint) => void;
+}
+
+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;
+    };
+}
+
+/** Emit actual observations in this invocation. The result does not identify an
+ * engine, authenticate a remote runner or establish a cross-engine proof. */
+export declare const runSimulationConformanceTrace: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCase, offeredLimits?: SimulationConformanceLimits) => SimulationConformanceTrace;
+
+declare const SeatClaimsSchema: Schema.Struct<{
+    readonly purpose: Schema.Literal<"voltro.rooms.seat.v1">;
+    readonly roomId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly subjectId: Schema.NullOr<Schema.NonEmptyString>;
+    readonly subjectType: Schema.optionalKey<Schema.Literals<readonly ["user", "apiKey", "serviceAccount"]>>;
+    readonly subjectKind: Schema.optionalKey<Schema.Literal<"guest">>;
+    readonly tenantId: Schema.NonEmptyString;
+    readonly epoch: Schema.Int;
+    readonly nonce: Schema.NonEmptyString;
+    readonly expiresAt: Schema.Number;
+    readonly role: Schema.Literals<readonly ["player", "spectator"]>;
+    readonly attributes: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>>;
+}>;
+
+declare class SeatExpired extends SeatExpired_base {
+}
+
+declare const SeatExpired_base: Schema.Class<SeatExpired, Schema.TaggedStruct<"SeatExpired", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+declare interface Simulation<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    readonly definition: SimulationDefinition<S, I, O>;
+    readonly stateCodec: SimulationStateCodec<S>;
+    readonly inputCodec: SimulationStateCodec<I>;
+    readonly optionsCodec: SimulationStateCodec<O>;
+}
+
+/** Same-invocation fresh-run and real retained rollback controls, not B31. */
+export declare const simulationConformance: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCase, offeredLimits?: SimulationConformanceLimits) => SimulationConformanceResult;
+
+export declare interface SimulationConformanceCase {
+    readonly seed: number;
+    readonly stateSchemaHash: number;
+    /** Actual LSO bytes: never JSON-roundtrip init options. */
+    readonly options: Uint8Array;
+    /** Actual LSI bytes: complete canonical tick-zero input history. */
+    readonly inputs: Uint8Array;
+}
+
+export declare interface SimulationConformanceCaseOptions<I, O> {
+    readonly seed: number;
+    readonly options: O;
+    readonly playerIds: ReadonlyArray<number>;
+    readonly sample: (context: SimulationConformanceSampleContext) => I;
+    readonly inputSeed?: number;
+    readonly ticks?: number;
+    readonly maxBytes?: number | undefined;
+}
+
+export declare interface SimulationConformanceLimits {
+    readonly maxTicks?: number;
+    readonly maxCaseBytes?: number;
+    readonly maxStateBytes?: number;
+    readonly maxRetainedStateBytes?: number;
+    readonly maxWorkSteps?: number;
+    readonly maxObservations?: number;
+    readonly rollbackHorizonTicks?: number;
+    readonly replayEveryTicks?: number;
+}
+
+export declare interface SimulationConformanceObservation {
+    readonly tick: number;
+    /** Always compute the schema hash even when the author overrides hash. */
+    readonly schemaHash: Uint64Words;
+    readonly hash: Uint64Words;
+    readonly rng: Pcg32Snapshot;
+}
+
+export declare interface SimulationConformanceResult {
+    readonly scope: 'local-repeat-and-rollback';
+    readonly trace: SimulationConformanceTrace;
+    readonly ticks: number;
+    readonly stepsExecuted: number;
+    readonly comparisons: number;
+    readonly replays: number;
+}
+
+export declare interface SimulationConformanceSampleContext {
+    readonly tick: number;
+    readonly playerId: number;
+    /** Separate case-generation RNG, never the simulation's retained RNG. */
+    readonly rng: Pcg32;
+}
+
+export declare interface SimulationConformanceTrace {
+    readonly case: SimulationConformanceCase;
+    readonly observations: ReadonlyArray<SimulationConformanceObservation>;
+}
+
+declare interface SimulationDefinition<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    readonly state: S;
+    readonly input: I;
+    readonly options: O;
+    readonly init: (seed: number, options: (O)["Type"]) => (S)["Type"];
+    readonly step: (state: RoomState<(S)["Type"]>, inputs: ReadonlyArray<SimulationPlayerInput<(I)["Type"]>>, tick: number, rng: Pcg32) => (S)["Type"];
+    readonly hash?: (state: (S)["Type"]) => Uint64Words;
+    /** Late join: runs before `step` at the tick a player's input first appears (it was absent
+     * from the previous tick's inputs), in player-ID order, e.g. to spawn the player. Pure and
+     * deterministic like `step`. Start players are `init`'s job: tick 1 runs no join. */
+    readonly join?: (state: RoomState<(S)["Type"]>, playerId: number, tick: number, rng: Pcg32) => (S)["Type"];
+    readonly limits?: Partial<SimulationValueLimits>;
+}
+
+declare interface SimulationPlayerInput<I> {
+    readonly playerId: number;
+    readonly input: I;
+}
+
+declare interface SimulationStateCodec<S extends Schema.Codec<unknown, unknown>> {
+    readonly limits: SimulationValueLimits;
+    /** Admitted capture/hash plan, not a binary Room wire schema. */
+    schemaDescription?(): string;
+    capture(value: unknown): (S)["Type"];
+    hash(value: (S)["Type"]): Uint64Words;
+}
+
+declare interface SimulationValueLimits extends RoomCodecLimits {
+    readonly maxNodes: number;
+}
+
+export declare interface TestRoomClients<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    readonly actor: RoomActor<S, I, O>;
+    /** The player's current client session (replaced on reconnect). */
+    session(subjectId: string): RoomSession<S, I>;
+    /** Advance virtual time: one Host tick, state published to every connected client. */
+    step(milliseconds: number): Promise<void>;
+    send(subjectId: string, input: (I)["Type"]): Promise<number>;
+    /** Drop the player's transport; the server closes the session as `reconnecting`. */
+    disconnect(subjectId: string): Promise<void>;
+    /** A fresh seat and a new session for the same player. */
+    reconnect(subjectId: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare interface TestRoomClientsOptions {
+    /** Subject ids of the players to connect, in order. */
+    readonly players: ReadonlyArray<string>;
+    readonly tenantId?: string;
+    /** Seeded network per player; defaults to no latency, jitter or loss. */
+    readonly net?: Partial<NetSimOptions>;
+    /** Seat attributes per player, as the API's `seatAttributes` would resolve them (`client.attributes`). */
+    readonly attributes?: Readonly<Record<string, RoomSeatAttributes>>;
+}
+
+declare const Transform2D: Schema.Struct<{
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly rot: Schema.Number;
+    readonly vx: Schema.optional<Schema.Number>;
+    readonly vy: Schema.optional<Schema.Number>;
+}>;
+
+declare type Transform2D = (typeof Transform2D)["Type"];
+
+/** Exact unsigned 64-bit integer as independent 32-bit words. */
+declare interface Uint64Words {
+    readonly hi: number;
+    readonly lo: number;
+}
+
+export declare const virtualClock: (initialMs?: number) => VirtualRoomClock;
+
+export declare interface VirtualRoomClock extends RoomClock {
+    advance(milliseconds: number): void;
+}
+
+declare type WorldBounds = readonly [minimum: WorldPoint, maximum: WorldPoint];
+
+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>;
+}
+
+export declare const worldClientControlFakeLayer: Layer.Layer<WorldClientControlPort, never, never>;
+
+export declare type WorldClientControlFixtureOverrides = Partial<Context.Service.Shape<typeof WorldClientControlPort>>;
+
+/** Authenticated API seam; default physical/SQL implementation stays explicit. */
+declare class WorldClientControlPort extends WorldClientControlPort_base {
+}
+
+declare const WorldClientControlPort_base: Context.ServiceClass<WorldClientControlPort, "@voltro/WorldClientControlPort", WorldClientControl>;
+
+export declare const worldClientControlPortFixture: {
+    kind: "port";
+    tag: typeof WorldClientControlPort;
+    fakeLayer: Layer.Layer<WorldClientControlPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+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 WorldDefinition<Player> {
+    readonly name: string;
+    readonly map: {
+        readonly bounds: WorldBounds;
+    };
+    readonly zones: ReadonlyArray<WorldZone>;
+    readonly instances?: ReadonlyArray<WorldInstance>;
+    readonly persistence: {
+        readonly entities: 'world';
+        readonly snapshotEveryMs: number;
+        readonly journal: boolean;
+    };
+    readonly handoff: {
+        readonly marginUnits: number;
+        readonly ghostUnits: number;
+    };
+    readonly spawn: (context: {
+        readonly player: Player;
+    }) => WorldPosition;
+    readonly geometry?: WorldGeometryDefinition | undefined;
+    readonly hosts?: {
+        readonly pool: string;
+    };
+    readonly characters?: 'shared' | 'per-world';
+    readonly transitionCooldownMs?: number;
+    /** Authoring inventory bounds, not measured runtime capacity. */
+    readonly budgets?: {
+        readonly maxZones?: number;
+        readonly maxCells?: number | undefined;
+        readonly maxInstances?: number;
+    };
+    readonly strategies?: {
+        readonly layerPolicy?: WorldLayerPolicy | undefined;
+        readonly transitionPolicy?: WorldTransitionPolicy;
+        readonly onWorldChange?: WorldOnWorldChange;
+    };
+}
+
+declare interface WorldDescriptor<Player> extends Omit<WorldDefinition<Player>, 'instances' | 'budgets' | 'characters' | 'transitionCooldownMs' | 'strategies' | 'geometry'> {
+    readonly geometry?: WorldGeometryDescriptor | undefined;
+    readonly _tag: 'WorldDescriptor';
+    readonly instances: ReadonlyArray<Omit<WorldInstance, 'ttl'> & {
+        readonly ttlMs: number;
+    }>;
+    readonly budgets: {
+        readonly maxZones: number;
+        readonly maxCells: number;
+        readonly maxInstances: number;
+    };
+    readonly characters: 'shared' | 'per-world';
+    readonly transitionCooldownMs: number;
+    readonly cellCount: number;
+    readonly strategies: {
+        readonly layerPolicy: WorldLayerPolicy;
+        readonly transitionPolicy: WorldTransitionPolicy;
+        readonly onWorldChange: WorldOnWorldChange;
+    };
+}
+
+declare interface WorldEntityLocation {
+    readonly worldId: string;
+    readonly zoneId: string;
+    readonly at: WorldPoint;
+    readonly layer: number;
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+declare interface WorldGeometryDefinition {
+    readonly strategies?: WorldGeometryStrategies | undefined;
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize?: number;
+    readonly dynamic?: {
+        readonly enabled?: boolean | undefined;
+        readonly maxDeltaBytesPerChunk?: number;
+        readonly persist?: {
+            readonly everyMs?: number;
+            readonly onUnload?: boolean;
+        };
+    };
+    readonly collision?: {
+        readonly derive?: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution?: number;
+    };
+    readonly nav?: {
+        readonly derive?: 'grid' | 'none';
+        readonly navBudgetMs?: number;
+        readonly maxAdvanceSteps?: number;
+    };
+    readonly streaming?: {
+        readonly client?: {
+            readonly radiusChunks?: number;
+            readonly prefetchChunks?: number;
+            readonly maxConcurrent?: number | undefined;
+            readonly maxCachedChunks?: number;
+        };
+        readonly cell?: {
+            readonly marginChunks?: number;
+        };
+    };
+    readonly lod?: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets?: {
+        readonly maxPreparedChunks?: number;
+        readonly maxPreparedBytes?: number;
+        readonly maxLodLevels?: number;
+        readonly maxRayCells?: number | undefined;
+        readonly maxOverlapTests?: number | undefined;
+    };
+}
+
+declare interface WorldGeometryDescriptor {
+    readonly strategies: GeometryEditStrategies & GeometryDerivationStrategies & GeometryCompactionStrategies & {
+        readonly migrateDelta: GeometryMigrateDelta;
+    };
+    readonly _tag: 'WorldGeometry';
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize: number;
+    readonly chunkSizeRaw: number;
+    readonly dynamic: {
+        readonly enabled: boolean;
+        readonly maxDeltaBytesPerChunk: number;
+        readonly persist: {
+            readonly everyMs: number;
+            readonly onUnload: boolean;
+        };
+    };
+    readonly collision: {
+        readonly derive: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution: number;
+        readonly resolutionRaw: number;
+    };
+    readonly nav: {
+        readonly derive: 'grid' | 'none';
+        readonly navBudgetMs: number;
+        readonly maxAdvanceSteps: number;
+    };
+    readonly streaming: {
+        readonly client: {
+            readonly radiusChunks: number;
+            readonly prefetchChunks: number;
+            readonly maxConcurrent: number;
+            readonly maxCachedChunks: number;
+        };
+        readonly cell: {
+            readonly marginChunks: number;
+        };
+    };
+    readonly lod: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets: {
+        readonly maxPreparedChunks: number;
+        readonly maxPreparedBytes: number;
+        readonly maxLodLevels: number;
+        readonly maxRayCells: number;
+        readonly maxOverlapTests: number;
+    };
+}
+
+declare interface WorldGeometryStrategies extends GeometryVersionMigrationStrategies, Partial<GeometryEditStrategies>, Partial<GeometryDerivationStrategies>, Partial<GeometryCompactionStrategies> {
+}
+
+declare type WorldGroupTransitionRequest = typeof WorldGroupTransitionRequestSchema.Type;
+
+declare const WorldGroupTransitionRequestSchema: Schema.Struct<{
+    readonly partyId: 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">>;
+    }>;
+    readonly waitForAllMs: Schema.Number;
+    readonly onTimeout: Schema.Literals<readonly ["proceed", "cancel"]>;
+}>;
+
+declare interface WorldInstance {
+    readonly id: string;
+    readonly room: string;
+    readonly maxGroups: number;
+    readonly ttl: Duration.Input;
+}
+
+declare interface WorldJoinResult {
+    /** The server-owned entity this player controls (`intention.entityId` of later moves). */
+    readonly entityId: string;
+    readonly reservation: RoomReservation;
+}
+
+declare type WorldLayerDecision = {
+    readonly kind: 'use';
+    readonly layer: number;
+    readonly wake: boolean;
+} | {
+    readonly kind: 'create';
+    readonly layer: number;
+} | {
+    readonly kind: 'blocked';
+    readonly reason: 'affinity-unavailable' | 'capacity' | 'layer-budget';
+};
+
+declare interface WorldLayering {
+    readonly maxPlayers: number;
+    readonly splitAt: number;
+    readonly mergeBelow: number;
+}
+
+declare interface WorldLayerInput {
+    readonly policy: WorldLayering;
+    readonly layers: ReadonlyArray<WorldLayerObservation>;
+    readonly groupSize: number;
+    /** Actual server-owned party affinity; never silently choose a different layer. */
+    readonly affinity: number | null;
+    readonly maxLayers: number;
+}
+
+declare interface WorldLayerObservation {
+    readonly layer: number;
+    readonly players: number;
+    readonly state: 'live' | 'hibernated' | 'splitting' | 'merging';
+}
+
+declare type WorldLayerPolicy = (input: WorldLayerInput) => WorldLayerDecision;
+
+/** Actual configured definition + resolver, not a whole-world conformance flag. */
+export declare const worldLayerPolicySlotFixture: {
+    kind: "slot";
+    defaultImplementation: WorldLayerPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect< WorldLayerDecision, never, never>;
+        expected: {
+            kind: string;
+            layer: number;
+            wake: boolean;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< WorldLayerDecision, never, never>;
+        expected: {
+            kind: string;
+            layer: number;
+            wake: boolean;
+        };
+    };
+};
+
+declare interface WorldMovementIntent {
+    readonly entityId: string;
+    readonly sourceAt: WorldPoint;
+    readonly targetAt: WorldPoint;
+    readonly crossing: boolean;
+}
+
+declare interface WorldMovementObservation {
+    readonly epoch: number;
+    readonly tick: number;
+    readonly intents: ReadonlyArray<WorldMovementIntent>;
+}
+
+declare type WorldOnWorldChange = (input: WorldOnWorldChangeInput) => unknown;
+
+declare interface WorldOnWorldChangeInput {
+    readonly sourceWorldId: string;
+    readonly targetWorldId: string;
+    /** Current server-captured character data, never a player's wire state. */
+    readonly sourceData: unknown;
+    /** Actual server-selected target data before this policy. */
+    readonly targetData: unknown;
+}
+
+export declare const worldOnWorldChangeSlotFixture: {
+    kind: "slot";
+    defaultImplementation: WorldOnWorldChange;
+    defaultProbe: {
+        run: () => Effect.Effect<unknown, never, never>;
+        expected: {
+            coins: number;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<unknown, never, never>;
+        expected: {
+            coins: number;
+        };
+    };
+};
+
+declare type WorldPoint = readonly [x: number, y: number];
+
+declare interface WorldPosition {
+    readonly zone: string;
+    readonly at: WorldPoint;
+}
+
+/** Private durable restriction, never a bearer or a grant of transition authority.
+ * The enclosing Seat supplies tenant, target Room, Subject and ownership epoch. */
+declare interface WorldTargetSeatBinding {
+    readonly transitionId: string;
+    readonly sourceRoomId: string;
+    readonly requestId: string;
+    readonly entityId: string;
+}
+
+/** 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 declare const worldTransitionFakeLayer: Layer.Layer<WorldTransitionPort>;
+
+export declare type WorldTransitionFixtureOverrides = Partial<Context.Service.Shape<typeof WorldTransitionPort>>;
+
+declare type WorldTransitionKind = 'cell' | 'layer' | 'zone' | 'world' | 'instance' | 'return' | 'recover';
+
+declare interface WorldTransitionLocation extends WorldPosition {
+    readonly world: string;
+    readonly pool: string;
+    readonly layer: number;
+    readonly instance: string | null;
+}
+
+declare type WorldTransitionMode = 'seamless' | 'portal' | 'recover';
+
+declare interface WorldTransitionObservation {
+    readonly phase: typeof WorldTransitionPhaseSchema.Type;
+}
+
+declare type WorldTransitionOrigin = Omit<RoomAppCommand, 'command'>;
+
+declare const WorldTransitionPhaseSchema: Schema.Literals<readonly ["requested", "reserving", "prepared", "ghosting", "persisting", "detaching", "switching", "committed", "settled", "failed", "rolledBack"]>;
+
+declare interface WorldTransitionPlan {
+    readonly kind: WorldTransitionKind;
+    readonly mode: WorldTransitionMode;
+    readonly crossPool: boolean;
+    readonly persistBeforeRelease: boolean;
+    readonly sourceCell: string;
+    readonly targetCell: string;
+}
+
+declare type WorldTransitionPolicy = (input: WorldTransitionPolicyInput) => WorldTransitionPlan;
+
+declare interface WorldTransitionPolicyInput {
+    readonly kind: WorldTransitionKind;
+    readonly sourceWorld: AnyWorldDescriptor;
+    readonly targetWorld: AnyWorldDescriptor;
+    readonly source: WorldTransitionLocation;
+    readonly target: WorldTransitionLocation;
+    readonly mode: WorldTransitionMode | 'auto';
+    readonly crossPool: boolean;
+    /** Trusted server recovery classification, not a player intention field. */
+    readonly recovery: boolean;
+}
+
+export declare const worldTransitionPolicySlotFixture: {
+    kind: "slot";
+    defaultImplementation: WorldTransitionPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect< WorldTransitionMode, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< WorldTransitionMode, never, never>;
+        expected: string;
+    };
+};
+
+/** Actual provider owns SQL idempotency, current source authority, lease and commit. */
+declare class WorldTransitionPort extends WorldTransitionPort_base {
+}
+
+declare const WorldTransitionPort_base: Context.ServiceClass<WorldTransitionPort, "@voltro/WorldTransitionPort", {
+    transition(input: WorldTransitionRequest, origin: WorldTransitionOrigin): Effect.Effect<void, ProtocolError>;
+    transitionGroup(input: WorldGroupTransitionRequest, origin: WorldTransitionOrigin): Effect.Effect<void, ProtocolError>;
+    recover(input: {
+        readonly entityId: string;
+    }, origin: WorldTransitionOrigin): Effect.Effect<void, ProtocolError>;
+    status(origin: WorldTransitionOrigin): Effect.Effect<WorldTransitionObservation, ProtocolError>;
+}>;
+
+export declare const worldTransitionPortFixture: {
+    kind: "port";
+    tag: typeof WorldTransitionPort;
+    fakeLayer: Layer.Layer<WorldTransitionPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"ProtocolError" | "unexpected-success", never, never>;
+        expected: string;
+    };
+};
+
+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">>;
+    }>;
+}>;
+
+declare interface WorldZone {
+    readonly id: string;
+    readonly bounds: WorldBounds;
+    readonly room: string;
+    readonly neighbors: ReadonlyArray<string>;
+    readonly cells?: {
+        readonly size: number;
+    } | undefined;
+    readonly layering?: WorldLayering;
+}
+
+export { }