@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/world.d.ts

@@ -0,0 +1,1894 @@
+import { Context } from 'effect';
+import { Duration } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** Configuration consumers never invoke a player callback. Its player type
+ * stays author-owned; this inventory type does not erase it into an input. */
+export declare type AnyWorldDescriptor = WorldDescriptor<never>;
+
+export declare const captureWorldCatalog: (offered: ReadonlyArray<AnyWorldDescriptor>, maximum?: number) => ReadonlyArray<AnyWorldDescriptor>;
+
+/** Pure source selection only. Actual CMS publication/channel admission is a server capability. */
+export declare const cmsGeometry: (key: string, offered?: {
+    readonly channel?: string | undefined;
+}) => GeometrySource;
+
+export declare const decodeWorldInspection: (value: unknown) => WorldInspection;
+
+/** Observations only. SQL reservation and the real worker must still admit capacity. */
+export declare const defaultWorldLayerPolicy: WorldLayerPolicy;
+
+export declare const defaultWorldOnWorldChange: WorldOnWorldChange;
+
+/** Classification only, never a player guard, seat reservation or commit authority. */
+export declare const defaultWorldTransitionPolicy: WorldTransitionPolicy;
+
+/** Pure immutable authoring; no room creation, discovery, table, connection or timer. */
+export declare const defineWorld: <Player>(definition: WorldDefinition<Player>) => WorldDescriptor<Player>;
+
+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 GeometryAssetBundle {
+    readonly root: GeometryAssetRoot;
+    preload(signal: AbortSignal): Promise<void>;
+    at(key: string): GeometryVerifiedAsset;
+    observation(): {
+        readonly totalAssets: number;
+        readonly totalBytes: number;
+        readonly loadedAssets: number;
+        readonly loadedBytes: number;
+        readonly active: boolean;
+        readonly ready: boolean;
+        readonly closed: boolean;
+    };
+    /** Abort/join this bundle's actual accepted work only. Shared byte-cache and
+     * earlier detached aliases remain owned by their actual external lifetimes. */
+    close(): Promise<void>;
+}
+
+declare interface GeometryAssetRoot {
+    readonly tenantId: string;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+declare type GeometryChunk = GeometryTileChunk | GeometryHeightfieldChunk | GeometryShapesChunk | GeometryVoxelChunk;
+
+declare interface GeometryClientInterest {
+    readonly scope: GeometryPreparedScope;
+    readonly center: GeometryPreparedCoordinate;
+    readonly radiusChunks: number;
+    readonly prefetchChunks: number;
+    readonly visitedCoordinates: number;
+    readonly omittedPrefetch: number;
+    readonly chunks: ReadonlyArray<GeometryClientInterestEntry>;
+}
+
+declare interface GeometryClientInterestEntry {
+    readonly coordinate: GeometryPreparedCoordinate;
+    readonly distanceChunks: number;
+    readonly role: 'visible' | 'prefetch';
+    /** Declared render-field selection only. Native collision snapshots remain
+     * whole; this does not invent a coarse encoder/download/asset format. */
+    readonly fields: ReadonlyArray<string>;
+}
+
+declare interface GeometryClientInterestOptions {
+    readonly maxChunks?: number | undefined;
+    readonly maxVisitedCoordinates?: number;
+    /** Actual render Transform velocity in raw units/second, never server authority. */
+    readonly velocity?: GeometryWorldPointRaw | undefined;
+}
+
+declare type GeometryCollisionDerive = (context: GeometryDerivationContext) => GeometryChunk;
+
+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>;
+}
+
+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;
+}
+
+export declare type GeometryGenerator = (context: GeometryProceduralContext) => GeometryChunk;
+
+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 GeometryHeightfieldLodOptions {
+    readonly maxStride?: number;
+    readonly maxSamples?: number | undefined;
+    readonly codecLimits?: Partial<GeometryHeightfieldLimits> | undefined;
+    readonly strategies?: {
+        readonly sampleStride?: GeometryHeightfieldLodStride;
+    } | undefined;
+}
+
+declare type GeometryHeightfieldLodStride = (chunk: GeometryHeightfieldChunk, maxStride: number) => number;
+
+declare interface GeometryHeightfieldView {
+    readonly chunk: GeometryHeightfieldChunk;
+    heightAtSample(x: number, y: number): number;
+    heightAtRaw(xRaw: number, yRaw: number): 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;
+
+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 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 GeometryPointRaw3D {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw: number;
+}
+
+declare interface GeometryPreparedCoordinate {
+    readonly cx: number;
+    readonly cy: number;
+    readonly cz?: number | undefined;
+}
+
+declare type GeometryPreparedEntry = PreparedCommon & GeometryPreparedView & {
+    /** Independently prepared native collision data. Original view/artifact remains the edit/rebuild baseline. */
+    readonly collision: GeometryPreparedView;
+    readonly navigation: GeometryTileView | null;
+};
+
+declare interface GeometryPreparedScope {
+    readonly tenantId: string;
+    readonly kind: GeometryKind;
+    readonly worldId: string;
+    readonly layerSetId: string;
+    readonly version: string;
+}
+
+declare type GeometryPreparedView = ({
+    readonly kind: '2d-tiles';
+    readonly view: GeometryTileView;
+} | {
+    readonly kind: '2d-heightfield';
+    readonly view: GeometryHeightfieldView;
+} | {
+    readonly kind: '3d-shapes';
+    readonly view: GeometryShapesView;
+} | {
+    readonly kind: '3d-voxel';
+    readonly view: GeometryVoxelView;
+});
+
+export declare interface GeometryProceduralContext {
+    readonly seed: number;
+    readonly kind: GeometryKind;
+    readonly address: GeometryChunk['address'];
+    readonly version: string;
+}
+
+declare interface GeometryRenderLod {
+    readonly fields: ReadonlyArray<string>;
+    readonly sampleStride: number;
+    readonly sourceBlobSha256: string;
+    readonly sourceContentSha256: string;
+    readonly artifact: GeometryArtifact;
+    /** Present when both full heights and heightsCoarse are selected. */
+    readonly coarseArtifact?: GeometryArtifact;
+}
+
+declare interface GeometryRenderLodCache {
+    prepare(coordinate: GeometryPreparedCoordinate, distanceChunks: number): Promise<GeometryRenderLod>;
+    at(coordinate: GeometryPreparedCoordinate, distanceChunks: number): GeometryRenderLod;
+    observation(): {
+        readonly entries: number;
+        readonly encodedBytes: number;
+        readonly jobs: number;
+        readonly closed: boolean;
+        readonly withdrawn: boolean;
+    };
+    /** Clears owned references and joins all accepted preparation/hash work. It
+     * never closes the borrowed native cache/Session or erases earlier aliases. */
+    close(): Promise<void>;
+}
+
+declare interface GeometryRenderLodCacheOptions {
+    readonly maxEntries?: number;
+    readonly maxEncodedBytes?: number;
+    readonly maxConcurrent?: number | undefined;
+    readonly lod?: GeometryHeightfieldLodOptions;
+    readonly strategies?: {
+        readonly prepare?: GeometryRenderLodPreparer;
+    } | undefined;
+}
+
+declare type GeometryRenderLodPreparer = (world: AnyWorldDescriptor, artifact: GeometryArtifact, distanceChunks: number, options: GeometryHeightfieldLodOptions) => Promise<GeometryRenderLod>;
+
+declare type GeometryShape = (typeof GeometryShapeSchema)["Type"];
+
+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 interface GeometryShapesView {
+    readonly chunk: GeometryShapesChunk;
+    containingRaw(point: GeometryPointRaw3D, maximumShapes?: number): ReadonlyArray<GeometryShape>;
+    /** Closed LOCAL segment and native volumes. Canonical ID order, not distance
+     * order; no first-hit fraction or cross-chunk ownership is implied. */
+    intersectingSegmentRaw(from: GeometryPointRaw3D, to: GeometryPointRaw3D, maximumShapes?: number): ReadonlyArray<GeometryShape>;
+}
+
+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;
+};
+
+export 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 interface GeometryTileCellBounds {
+    readonly minXRaw: number;
+    readonly minYRaw: number;
+    readonly maxXRaw: number;
+    readonly maxYRaw: number;
+}
+
+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 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 interface GeometryTileView {
+    readonly chunk: GeometryTileChunk;
+    /** Local integer cell queries. Outside cells refuse; no missing-neighbor air. */
+    materialAt(x: number, y: number): GeometryTileMaterial;
+    solidAt(x: number, y: number): boolean;
+    materialAtRaw(xRaw: number, yRaw: number): GeometryTileMaterial;
+    cellBounds(x: number, y: number): GeometryTileCellBounds;
+    /** Detached row-major little-bit occupancy, never the retained mutable grid. */
+    occupancy(): Uint8Array;
+}
+
+declare interface GeometryVerifiedAsset {
+    readonly root: GeometryAssetRoot;
+    readonly key: string;
+    readonly checksum: string;
+    readonly size: number;
+    readonly contentType: string;
+    /** Detached owned bytes; no URL/token/permission retained. */
+    bytes(): Uint8Array;
+}
+
+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;
+}
+
+declare interface GeometryVoxelView {
+    readonly chunk: GeometryVoxelChunk;
+    materialAt(x: number, y: number, z: number): GeometryTileMaterial;
+    solidAt(x: number, y: number, z: number): boolean;
+    materialAtRaw(xRaw: number, yRaw: number, zRaw: number): GeometryTileMaterial;
+    occupancy(): Uint8Array;
+}
+
+declare interface GeometryWorldPointRaw {
+    readonly xRaw: number;
+    readonly yRaw: number;
+    readonly zRaw?: number;
+}
+
+/** App-root relative declaration; it neither opens a path nor proves filesystem custody. */
+export declare const importedGeometry: (directory: string) => GeometrySource;
+
+/** Pure synchronous constraint, not a Room ownership or crossing capability.
+ * The Host supplies actual cell bounds; ownership transfer installs a different
+ * actor/bounds. There is no caller-controlled allowCrossing boolean. */
+export declare const makeWorldCellMovement: (offered: WorldBounds) => Readonly<{
+    bounds: WorldBounds & any[];
+    /** Directional margin observation only. Target point crosses exactly one
+     * source edge; the actual catalogue/SQL resolver must admit its neighbor. */
+    approach: (offeredFrom: WorldPoint, offeredTo: WorldPoint, marginUnits: number) => Omit<WorldMovementIntent, "entityId"> | null;
+    constrain: (offeredFrom: WorldPoint, offeredTo: WorldPoint) => WorldCellMovement;
+}>;
+
+/** Independent immutable projections for rendering. Never merged into the
+ * authoritative Room snapshot, input history, collision state or SQL state. */
+export declare const makeWorldEntityHandoffView: <S, E>(options: WorldEntityHandoffViewOptions<S, E>) => Readonly<{
+    notice: (roomId: string, frame: RoomWorldHandoffFrame, snapshot: RoomDeliveredState<S> | null) => void;
+    observe: (roomId: string, snapshot: RoomDeliveredState<S> | null) => void;
+    read: (roomId: string, snapshot: RoomDeliveredState<S> | null) => ReadonlyArray<WorldEntityHandoffProjection<E>>;
+    attach: (roomId: string, connection: WorldHandoffConnection<S>) => (() => void);
+    stats: () => Readonly<{
+        entities: number;
+        bytes: number;
+        connections: number;
+    }>;
+    close: () => void;
+}>;
+
+/** Pure geometric selection, not ownership/Host/mesh admission. Candidate
+ * bounds are checked before enumeration; no partial neighborhood is returned. */
+export declare const makeWorldGhostNeighborhood: (offered: WorldGhostNeighborhoodOptions) => (raw: WorldPosition & {
+    readonly layer: number;
+}) => ReadonlyArray<WorldGhostNeighbor>;
+
+/** Presentation only. Retained state never becomes an authoritative delivered
+ * snapshot, input receipt, physics baseline or SQL ownership assertion. */
+export declare const makeWorldHandoffView: <S>(offered: WorldHandoffViewOptions<S>) => Readonly<{
+    begin: (requestId: string, entityId: string, source: RoomDeliveredState<S>) => void;
+    prepare: (mode: "portal" | "seamless", target: {
+        readonly roomId: string;
+        readonly epoch: number;
+    }) => void;
+    source: (raw: RoomDeliveredState<S> | null) => void;
+    commit: () => void;
+    rollback: () => void;
+    read: (roomId: string | null, raw: RoomDeliveredState<S> | null) => WorldHandoffPresentation<S> | null;
+    observation: () => Readonly<{
+        retained: boolean;
+        enabled: boolean;
+        committed: boolean;
+        expiresAt: number | null;
+    }>;
+    close: () => void;
+}>;
+
+declare interface PreparedCommon {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+    readonly accountedBytes: number;
+}
+
+/** Captured author callback only, never invoked during World declaration/catalogue admission. */
+export declare const procedural: (offered: {
+    readonly seed: number;
+    readonly generator: GeometryGenerator;
+}) => GeometrySource;
+
+declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+export declare const rect: (minX: number, minY: number, maxX: number, maxY: number) => WorldBounds;
+
+/** Validate replacement output against captured observations and party affinity. */
+export declare const resolveWorldLayerPolicy: (raw: WorldLayerInput, strategy?: WorldLayerPolicy) => WorldLayerDecision;
+
+/** Data policy only. No identity, placement, auth, I/O or ownership authority. */
+export declare const resolveWorldOnWorldChange: (input: WorldOnWorldChangeInput, maxBytes: number, strategy?: WorldOnWorldChange) => unknown;
+
+/** A replacement can select a safer portal, never remove required persistence. */
+export declare const resolveWorldTransitionPolicy: (raw: WorldTransitionPolicyInput, strategy?: WorldTransitionPolicy) => WorldTransitionPlan;
+
+/** 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;
+}
+
+/** The normal app dispatcher must use requestId for durable idempotency. SQL
+ * acknowledgement follows delivery, so a lost acknowledgement may retry that
+ * same operation. This port never promises exactly-once external effects. */
+declare interface RoomAppCommandBindings {
+    readonly run: Readonly<Record<string, (input: unknown, context: Omit<RoomAppCommand, 'command'>) => Effect.Effect<void, unknown>>>;
+    readonly publish: Readonly<Record<string, (payload: unknown, context: Omit<RoomAppCommand, 'command'> & {
+        readonly key: string;
+    }) => Effect.Effect<void, unknown>>>;
+}
+
+declare interface RoomChannel {
+    readonly schema: Schema.Codec<unknown, unknown>;
+    readonly direction: 'both' | 'server' | 'client';
+    readonly reliable: boolean;
+}
+
+/** API-facing reservation result. Credentials are retained only for Hello. */
+declare interface RoomClientReservation {
+    readonly roomId: string;
+    readonly sessionId: string;
+    readonly token: Uint8Array;
+    readonly address: string;
+    readonly expiresAt: number;
+    readonly endpoints?: RoomTransportEndpoints | undefined;
+}
+
+declare interface RoomClock {
+    now(): number;
+}
+
+declare type RoomClockPingCadence = (joinedForMs: number) => number;
+
+declare interface RoomClockSamplingOptions {
+    readonly maxPendingPings: number;
+    readonly pingTimeoutMs: number;
+}
+
+/** Framework-free reserve -> transport -> Hello orchestration. It preserves
+ * the last authoritative state during reconnect and never writes a token to
+ * persistent storage. RPC facade/platform/render-hook integration is pending. */
+declare class RoomConnection<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, JoinInput> {
+    readonly manifest: RoomWireManifest<S, I>;
+    readonly clock: RoomClock;
+    readonly reservations: RoomReservationClient<JoinInput>;
+    readonly connect: (address: string, signal: AbortSignal, endpoints?: RoomTransportEndpoints) => Promise<RoomTransport>;
+    private readonly controller;
+    private readonly listeners;
+    private readonly buffered;
+    private readonly pendingInputs;
+    private readonly options;
+    private session;
+    private handoffDetach;
+    private readonly handoffListeners;
+    private sessionDetach;
+    private currentState;
+    private currentStatus;
+    private currentError;
+    private reconnectTask;
+    private startTask;
+    private started;
+    private leaving;
+    private lastSessionId;
+    private lastTick;
+    private nextSeq;
+    private appliedSeq;
+    private clockTimer;
+    private readonly messageListeners;
+    private readonly messageDetach;
+    private reservation;
+    private readonly cleanupTasks;
+    private readonly cleanupFailures;
+    private pendingReservationCalls;
+    private pendingTransportCalls;
+    private readonly transportOwners;
+    private readonly transportLifetimes;
+    private withdrawalAttempted;
+    private leaveTask;
+    private left;
+    constructor(manifest: RoomWireManifest<S, I>, clock: RoomClock, reservations: RoomReservationClient<JoinInput>, connect: (address: string, signal: AbortSignal, endpoints?: RoomTransportEndpoints) => Promise<RoomTransport>, options: RoomConnectionOptions);
+    /* Excluded from this release type: captureGeometrySession */
+    /** `waking`: the pool scaled to zero and is starting a host; entry continues on its own. */
+    get status(): RoomSessionStatus | 'reserving' | 'waking';
+    get error(): unknown;
+    get state(): (S)["Type"] | null;
+    get id(): string | null;
+    /** Reserved Room identity, without exposing its seat credential. */
+    get roomId(): string | null;
+    get lastAppliedTick(): number;
+    get lastAppliedInputSeq(): number;
+    /** Exact current-session pairing; epoch changes need prediction reset. */
+    get reconciliationSnapshot(): RoomReconciliationSnapshot<(S)["Type"]> | null;
+    deliveredSnapshot(): RoomDeliveredState<(S)["Type"]> | null;
+    clockStats(): {
+        readonly rttMs: number | null;
+        readonly offsetMs: number | null;
+    };
+    serverNow(): number | null;
+    /** The current session's estimated datagram loss (0–1), null until measured. */
+    get lossRate(): number | null;
+    subscribe(listener: () => void): () => void;
+    private notify;
+    private active;
+    start(input: JoinInput): Promise<void>;
+    private attempt;
+    private install;
+    private waitForJoin;
+    private beginReconnect;
+    send(input: (I)["Type"]): Promise<number>;
+    private submit;
+    message(channel: string, payload: unknown): Promise<void>;
+    onWorldHandoff(listener: (frame: RoomWorldHandoffFrame) => void): () => void;
+    onMessage(channel: string, listener: (payload: unknown) => void): () => void;
+    private attachMessages;
+    private requestReservation;
+    private releaseReservation;
+    private stopClockSampling;
+    private releaseTransport;
+    private retainTransport;
+    private runTransportCleanup;
+    private startClockSampling;
+    private terminal;
+    leave(): Promise<void>;
+    private withdraw;
+}
+
+declare interface RoomConnectionOptions {
+    readonly graceMs: number;
+    readonly maxBufferedInputs?: number;
+    readonly maxPendingInputs?: number;
+    readonly initialBackoffMs?: number;
+    readonly maxBackoffMs?: number;
+    readonly connectTimeoutMs?: number;
+    readonly random?: () => number;
+    readonly sleep?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+    readonly reconnectPolicy?: RoomReconnectPolicy;
+    readonly clockSampling?: RoomClockSamplingOptions;
+    readonly inputRedundancy?: RoomInputRedundancyOptions;
+    readonly clockPingCadence?: RoomClockPingCadence;
+    readonly maxPendingReservationCalls?: number;
+    readonly maxCleanupFailures?: number;
+    readonly maxPendingTransportCalls?: number;
+    /** How long entry keeps waiting while a scaled-to-zero pool starts a host (`RoomPoolWaking`). Default 180000. */
+    readonly wakeTimeoutMs?: number;
+}
+
+declare interface RoomDatagramLane {
+    readonly maxDatagramBytes: number;
+    send(frame: Uint8Array): void;
+    onFrame(listener: (frame: Uint8Array, receivedAt: number) => void): () => void;
+}
+
+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 RoomGeometryChunkCache {
+    /** Last downloaded native query snapshot, never implied empty terrain. */
+    at(coordinate: GeometryPreparedCoordinate): GeometryPreparedEntry;
+    contains(coordinate: GeometryPreparedCoordinate): boolean;
+    /** Full requested set commits to bounded LRU only after all loads/hash/views
+     * complete. Failed batches preserve earlier same-admission snapshots. */
+    request(coordinates: ReadonlyArray<GeometryPreparedCoordinate>): Promise<void>;
+    /** Explicit render-frame work: native Deltas/recovery, visible-first load,
+     * directional prefetch and old-cache hysteresis. Caller awaits each frame. */
+    stream(focus: GeometryWorldPointRaw, options?: GeometryClientInterestOptions): Promise<GeometryClientInterest>;
+    /** Explicit current source reconciliation, including already cached chunks. */
+    /** Explicit serial native Delta application; gaps require actual source recovery. */
+    pump(): Promise<{
+        readonly applied: number;
+        readonly duplicates: number;
+        readonly obsolete: number;
+        readonly recovery: ReadonlyArray<GeometryPreparedCoordinate>;
+    }>;
+    refresh(coordinates: ReadonlyArray<GeometryPreparedCoordinate>): Promise<void>;
+    close(): Promise<void>;
+    observation(): RoomGeometryChunkCacheObservation;
+}
+
+declare interface RoomGeometryChunkCacheObservation {
+    readonly cached: number;
+    readonly accountedBytes: number;
+    readonly staged: number;
+    readonly stagedBytes: number;
+    readonly active: boolean;
+    readonly withdrawn: boolean;
+    readonly stale: number;
+    readonly queuedDeltas: number;
+    readonly queuedDeltaBytes: number;
+    readonly receiving: number;
+    readonly receivingBytes: number;
+}
+
+declare interface RoomInputRedundancyOptions {
+    /** Input count is a redundancy budget, never a delivery guarantee. */
+    readonly inputRedundancy: number;
+    readonly maxInputHistoryBytes: number;
+}
+
+declare interface RoomOutboxCommand {
+    readonly requestId: string;
+    readonly kind: 'publish' | 'run';
+    readonly name: string;
+    readonly payload: unknown;
+    readonly key?: string;
+}
+
+/** 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;
+}
+
+declare type RoomReconnectPolicy = (input: RoomReconnectPolicyInput) => number;
+
+declare interface RoomReconnectPolicyInput {
+    readonly attempt: number;
+    readonly initialBackoffMs: number;
+    readonly maxBackoffMs: number;
+    readonly remainingMs: number;
+    readonly random: number;
+}
+
+declare interface RoomReliableLane {
+    send(frame: Uint8Array): Promise<void>;
+    onFrame(listener: (frame: Uint8Array, receivedAt: number) => void): () => void;
+}
+
+declare interface RoomReservationClient<JoinInput> {
+    reserve(input: JoinInput, signal: AbortSignal): Promise<RoomClientReservation>;
+    resume(sessionId: string, signal: AbortSignal): Promise<RoomClientReservation>;
+    release?(sessionId: string, token: Uint8Array, signal: AbortSignal): Promise<void>;
+}
+
+declare interface RoomRpcCaller {
+    call(tag: string, input: unknown, options: {
+        readonly signal: AbortSignal;
+    }): Promise<unknown>;
+    /** Normal framework live-query callback boundary. No polling adapter. */
+    readonly subscribe?: (tag: string, input: unknown, handlers: {
+        readonly onValue: (value: unknown) => void;
+        readonly onError?: (error: unknown) => void;
+    }) => WorldClientReceiptSubscription;
+}
+
+declare type RoomSessionStatus = 'connecting' | 'joined' | 'reconnecting' | 'left' | 'kicked' | 'gone';
+
+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>;
+}
+
+/** Public routing metadata only. Neither endpoint conveys seat authority. */
+declare interface RoomTransportEndpoints {
+    readonly ws: string;
+    readonly wt?: string | undefined;
+    /** Base64 SHA-256 of a short-lived development certificate the browser pins
+     * through `serverCertificateHashes`. Absent for a publicly trusted certificate. */
+    readonly wtCertificateHash?: string | undefined;
+}
+
+declare interface 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>>;
+}
+
+/** 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;
+}
+
+/** 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. */
+export 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;
+}
+
+export declare const stageWorldGroupTransition: (app: RoomAppBridge, names: WorldTransitionCommandNames, input: WorldGroupTransitionRequest) => string;
+
+/** Uses the actual synchronous memory outbox; no Effect/port/store is run here. */
+export declare const stageWorldTransition: (app: RoomAppBridge, names: WorldTransitionCommandNames, input: WorldTransitionRequest) => string;
+
+export declare type WorldBounds = readonly [minimum: WorldPoint, maximum: WorldPoint];
+
+export declare interface WorldCell {
+    readonly id: string;
+    readonly zone: string;
+    readonly column: number;
+    readonly row: number;
+    readonly bounds: WorldBounds;
+}
+
+export declare const worldCellAt: <Player>(world: WorldDescriptor<Player>, position: WorldPosition) => WorldCell;
+
+/** The cell a recorded `zone:column:row` id names, with its half-open bounds. Refuses an id outside the zone grid. */
+export declare const worldCellById: <Player>(world: WorldDescriptor<Player>, zoneId: string, cellId: string) => WorldCell;
+
+export declare interface WorldCellMovement {
+    readonly at: WorldPoint;
+    readonly clamped: boolean;
+}
+
+/** Client connection ownership only. SQL commit is confirmed by an explicit
+ * authenticated provider; Welcome/assets/local status never prove that commit. */
+export declare class WorldClient<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> {
+    private readonly options;
+    private readonly input;
+    private readonly handoffView;
+    private handoffError;
+    private readonly controller;
+    private readonly commitWaitMs;
+    private readonly listeners;
+    private readonly queue;
+    private readonly sends;
+    private readonly receiptSubscriptions;
+    private draining;
+    private bytes;
+    private active;
+    private source;
+    private target;
+    private sourceGeometry;
+    private targetGeometry;
+    private recoveryGeometry;
+    private preparingAssets;
+    private earlyAssets;
+    private earlyAssetController;
+    private earlyAssetFailed;
+    private readonly pendingAssetBundles;
+    private readonly geometryAssets;
+    private readonly geometryRenders;
+    private detachSource;
+    private detachTarget;
+    private request;
+    private prepared;
+    private committed;
+    private assetsReady;
+    private operation;
+    private closeTask;
+    private closing;
+    private currentError;
+    private snapshot;
+    constructor(offered: WorldClientOptions<S, I>);
+    get observation(): WorldClientObservation;
+    /** Actual selected connection identity; unknown while committed target ownership is reconciling. */
+    get roomId(): string | null;
+    get geometry(): RoomGeometryChunkCache | null;
+    /** Actual selected source/target cache only, after confirmed transition
+     * choice. Own render work separately from server transition/intent state. */
+    renderGeometry(coordinate: GeometryPreparedCoordinate, distanceChunks: number): Promise<GeometryRenderLod>;
+    get geometryRenderObservation(): ReturnType<GeometryRenderLodCache['observation']> | null;
+    asset(key: string): GeometryVerifiedAsset;
+    get assetObservation(): ReturnType<GeometryAssetBundle['observation']> | null;
+    private admitGeometryAssets;
+    private closeGeometry;
+    get error(): ProtocolError | null;
+    get state(): (S)["Type"] | null;
+    deliveredSnapshot(): ReturnType<WorldClientRoom<S, I>['deliveredSnapshot']>;
+    /** Render-only view. A retained source snapshot carries handoff=true and
+     * must never feed prediction, input acknowledgements or authority decisions. */
+    presentationSnapshot(): WorldHandoffPresentation<(S)["Type"]> | null;
+    private presentationWork;
+    subscribe(listener: () => void): () => void;
+    private notify;
+    private update;
+    private admitRoom;
+    private run;
+    private stopReceipts;
+    transition(requestId: string, intention: WorldTransitionRequest): Promise<void>;
+    private beginRequest;
+    /** Adopt an existing server request through its authenticated receipt. The
+     * entity ID is presentation context, never authority. No preparation is sent. */
+    adopt(requestId: string, entityId: string): Promise<void>;
+    private beginAssetPrefetch;
+    private closePendingAssetBundles;
+    private acceptTicket;
+    private acceptReceipt;
+    private connectTarget;
+    private connectAndCommit;
+    private waitReceipt;
+    private flush;
+    private finishCommit;
+    /** Unknown preparation/commit outcomes are reconciled through the same
+     * authenticated request receipt. Never re-resolve or invent rollback. */
+    resume(): Promise<void>;
+    private reconcileRequest;
+    /** Explicit native Session/root recovery, separate from SQL transition
+     * reconciliation. No timer, default version, authorization or retry is guessed. */
+    recoverGeometry(): Promise<void>;
+    cancel(): Promise<void>;
+    private finishRollback;
+    send(input: (I)["Type"]): Promise<WorldClientInputReceipt>;
+    private trackSend;
+    /** Await owned client work/withdrawal only. Closing sockets never implies
+     * server rollback, SQL deletion or removal of the retained transition. */
+    close(): Promise<void>;
+}
+
+export declare interface WorldClientGeometryAssets<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> {
+    readonly source?: GeometryAssetBundle;
+    /** Authenticated catalogue/grants can start before target Welcome. Return
+     * a complete owned bundle; final native geometry root is checked later. */
+    readonly preload?: (ticket: WorldClientTicket, signal: AbortSignal) => Promise<GeometryAssetBundle>;
+    /** Own a fully preloaded bundle for this genuine selected target cache. */
+    readonly prepare: (target: WorldClientTargetRoom<S, I>, geometry: RoomGeometryChunkCache, ticket: WorldClientTicket, signal: AbortSignal) => Promise<GeometryAssetBundle>;
+    readonly recover?: (source: WorldClientRoom<S, I>, geometry: RoomGeometryChunkCache, signal: AbortSignal) => Promise<GeometryAssetBundle>;
+}
+
+export declare interface WorldClientGeometryBinding<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> {
+    /** Actual immutable World catalogue for owned local render preparation. */
+    readonly worlds?: ReadonlyArray<AnyWorldDescriptor> | undefined;
+    readonly assets?: WorldClientGeometryAssets<S, I>;
+    readonly render?: GeometryRenderLodCacheOptions;
+    /** Explicit ownership transfers to this WorldClient, Session stays separate. */
+    readonly source: RoomGeometryChunkCache;
+    /** Actual current source manifest/authorization after reconnect/version change. */
+    readonly recover?: (source: WorldClientRoom<S, I>, signal: AbortSignal) => Promise<RoomGeometryChunkCache>;
+    /** Return a fully prefetched owned cache on the actual joined target. Must
+     * join all acquisition/source work before settling, including abort. */
+    readonly prepare: (target: WorldClientTargetRoom<S, I>, ticket: WorldClientTicket, signal: AbortSignal) => Promise<RoomGeometryChunkCache>;
+}
+
+export declare interface WorldClientInputReceipt {
+    readonly sourceSeq: number | null;
+    readonly targetSeq: number | null;
+}
+
+export declare interface WorldClientLocation {
+    readonly worldId: string;
+    readonly cellId: string;
+    readonly layer: number;
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+export declare interface WorldClientObservation {
+    readonly status: WorldClientStatus;
+    readonly step: WorldClientStep;
+    readonly mode: 'seamless' | 'portal' | null;
+    readonly bufferedInputs: number;
+    readonly bufferedBytes: number;
+    readonly committed: boolean;
+    readonly error: 'incomplete' | null;
+}
+
+export declare interface WorldClientOptions<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> {
+    /** One bounded live-query wait outside the Room tick; default is a budget. */
+    readonly commitWaitMs?: number;
+    readonly subscribeReceipt?: (requestId: string, handlers: WorldClientReceiptHandlers, signal: AbortSignal) => WorldClientReceiptSubscription;
+    readonly source: WorldClientRoom<S, I>;
+    readonly geometry?: WorldClientGeometryBinding<S, I> | undefined;
+    /** Bounded presentation continuity; never changes authoritative state/input. */
+    readonly handoffView?: WorldHandoffViewOptions<(S)["Type"]>;
+    readonly input: I;
+    readonly maxBufferedInputs: number;
+    readonly maxBufferedBytes: number;
+    readonly maxInFlightInputs: number;
+    /** All server calls must be authenticated, bounded and request-idempotent. */
+    readonly prepare: (requestId: string, intention: WorldTransitionRequest, signal: AbortSignal) => Promise<WorldClientTicket>;
+    readonly observe: (requestId: string, signal: AbortSignal) => Promise<WorldClientReceipt>;
+    readonly commit: (ticket: WorldClientTicket, signal: AbortSignal) => Promise<WorldClientReceipt>;
+    readonly cancel: (requestId: string, signal: AbortSignal) => Promise<WorldClientReceipt>;
+    /** Returns an unopened owned connection. start must wait for its real Welcome. */
+    readonly createTarget: (ticket: WorldClientTicket) => WorldClientTargetRoom<S, I>;
+    readonly prefetchAssets: (ticket: WorldClientTicket, signal: AbortSignal) => Promise<void>;
+}
+
+export declare interface WorldClientReceipt {
+    readonly ticket: WorldClientTicket;
+    readonly phase: 'prepared' | 'committed' | 'settled' | 'rolledBack';
+    readonly entityRevision: number | null;
+}
+
+export declare const worldClientReceipt: (input: unknown) => WorldClientReceipt;
+
+declare interface WorldClientReceiptHandlers {
+    readonly onValue: (receipt: WorldClientReceipt) => void;
+    readonly onError: (error: unknown) => void;
+}
+
+export declare const WorldClientReceiptSchema: Schema.Struct<{
+    readonly ticket: Schema.Struct<{
+        readonly requestId: Schema.String;
+        readonly transitionId: Schema.String;
+        readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+        readonly target: Schema.Struct<{
+            readonly worldId: Schema.String;
+            readonly cellId: Schema.String;
+            readonly layer: Schema.Int;
+            readonly roomId: Schema.String;
+            readonly epoch: Schema.Int;
+        }>;
+    }>;
+    readonly phase: Schema.Literals<readonly ["prepared", "committed", "settled", "rolledBack"]>;
+    readonly entityRevision: Schema.NullOr<Schema.Int>;
+}>;
+
+declare interface WorldClientReceiptSubscription {
+    unsubscribe(): void;
+}
+
+/** SQL origin IDs include the group command hash and full entity identity. */
+export declare const WorldClientRequestIdSchema: Schema.String;
+
+export declare type WorldClientRoom<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> = Pick<RoomConnection<S, I, unknown>, 'status' | 'state' | 'roomId' | 'send' | 'subscribe' | 'leave' | 'deliveredSnapshot'>;
+
+export declare type WorldClientStatus = 'idle' | 'preparing' | 'loading' | 'switching' | 'settled' | 'failed' | 'closed';
+
+export declare type WorldClientStep = 'reserve' | 'connect' | 'welcome' | 'geometry' | 'assets' | 'commit' | 'cleanup' | null;
+
+export declare interface WorldClientTargetRoom<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>> extends WorldClientRoom<S, I> {
+    start(ticket: WorldClientTicket): Promise<void>;
+}
+
+/** Authenticated server preparation, never player-supplied authority or state. */
+export declare interface WorldClientTicket {
+    readonly requestId: string;
+    readonly transitionId: string;
+    readonly mode: 'seamless' | 'portal';
+    readonly target: WorldClientLocation;
+}
+
+export declare const worldClientTicket: (input: unknown) => WorldClientTicket;
+
+export declare const WorldClientTicketSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly transitionId: Schema.String;
+    readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+    readonly target: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly cellId: Schema.String;
+        readonly layer: Schema.Int;
+        readonly roomId: Schema.String;
+        readonly epoch: Schema.Int;
+    }>;
+}>;
+
+/** The player a World's `spawn` receives under the default World binding (`rooms.world.join`
+ * and `world` transitions). `spawn` is the named spawn of a `world` transition target. */
+export declare interface WorldDefaultPlayer {
+    readonly id: string;
+    readonly kind: 'user' | 'guest';
+    readonly spawn?: string;
+}
+
+export 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;
+    };
+}
+
+export 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;
+    };
+}
+
+export declare interface WorldEntityHandoffProjection<E> {
+    readonly transitionId: string;
+    readonly entityId: string;
+    readonly sourceRoomId: string;
+    readonly sourceEpoch: number;
+    readonly sourceTick: number;
+    readonly receivedAt: number;
+    readonly targetRoomId: string;
+    readonly targetEpoch: number;
+    readonly expiresAt: number;
+    readonly entity: E;
+}
+
+export declare type WorldEntityHandoffView<S, E> = ReturnType<typeof makeWorldEntityHandoffView<S, E>>;
+
+export declare interface WorldEntityHandoffViewOptions<S, E> {
+    readonly maxEntities: number;
+    readonly maxBytes: number;
+    readonly maxHoldMs: number;
+    readonly maxConnections: number;
+    readonly now: () => number;
+    /** Authoritative entity only. Never return a pending preview or neighbor ghost. */
+    readonly entity: (state: S, entityId: string) => E | undefined;
+}
+
+export 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;
+    };
+}
+
+export 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;
+    };
+}
+
+export declare interface WorldGeometryStrategies extends GeometryVersionMigrationStrategies, Partial<GeometryEditStrategies>, Partial<GeometryDerivationStrategies>, Partial<GeometryCompactionStrategies> {
+}
+
+export declare interface WorldGhostNeighbor {
+    readonly cell: WorldCell;
+    readonly layer: number;
+    readonly distance: number;
+    /** Near enough for explicit Seat/snapshot preparation; not a reservation. */
+    readonly prepare: boolean;
+}
+
+export declare interface WorldGhostNeighborhoodOptions {
+    readonly world: AnyWorldDescriptor;
+    readonly maxZoneChecks: number;
+    readonly maxCandidateCells: number;
+}
+
+export declare type WorldGroupTransitionRequest = typeof WorldGroupTransitionRequestSchema.Type;
+
+export declare const worldGroupTransitionRequest: (input: unknown) => WorldGroupTransitionRequest;
+
+export 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"]>;
+}>;
+
+export declare interface WorldHandoffConnection<S> {
+    deliveredSnapshot(): RoomDeliveredState<S> | null;
+    onWorldHandoff(listener: (frame: RoomWorldHandoffFrame) => void): () => void;
+    subscribe(listener: () => void): () => void;
+}
+
+export declare interface WorldHandoffPresentation<S> {
+    readonly snapshot: RoomDeliveredState<S>;
+    readonly handoff: boolean;
+    readonly requestId?: string | undefined;
+    readonly entityId?: string;
+}
+
+export declare type WorldHandoffView<S> = ReturnType<typeof makeWorldHandoffView<S>>;
+
+export declare interface WorldHandoffViewOptions<S> {
+    readonly maxBytes: number;
+    readonly maxHoldMs: number;
+    readonly now: () => number;
+    /** Synchronous author projection: true only for an authoritative entity in
+     * this delivered view, never a pending preview or neighbor ghost. */
+    readonly contains: (state: S, entityId: string) => boolean;
+}
+
+export declare type WorldInspection = typeof WorldInspectionSchema.Type;
+
+export declare interface WorldInspectionQuery {
+    readonly tenantId: string;
+    readonly worldId?: string | null;
+    readonly after?: string | null;
+    readonly transitionsAfter?: string | null;
+}
+
+export declare const WorldInspectionSchema: Schema.Struct<{
+    readonly worldState: Schema.Literals<readonly ["none", "entities", "transitions"]>;
+    readonly worldClientControls: Schema.Boolean;
+    readonly catalog: Schema.$Array<Schema.String>;
+    readonly page: Schema.Struct<{
+        readonly tenantId: Schema.String;
+        readonly worldId: Schema.NullOr<Schema.String>;
+        readonly after: Schema.NullOr<Schema.String>;
+        readonly nextAfter: Schema.NullOr<Schema.String>;
+    }>;
+    readonly world: Schema.NullOr<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly bounds: Schema.Tuple<readonly [Schema.Tuple<readonly [Schema.Number, Schema.Number]>, Schema.Tuple<readonly [Schema.Number, Schema.Number]>]>;
+        readonly zones: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly bounds: Schema.Tuple<readonly [Schema.Tuple<readonly [Schema.Number, Schema.Number]>, Schema.Tuple<readonly [Schema.Number, Schema.Number]>]>;
+            readonly cellSize: Schema.NullOr<Schema.Number>;
+            readonly maxPlayers: Schema.NullOr<Schema.Number>;
+        }>>;
+        readonly layerPolicy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly transitionPolicy: Schema.Literals<readonly ["default", "custom"]>;
+        readonly worldChangePolicy: Schema.Literals<readonly ["default", "custom"]>;
+    }>>;
+    readonly cells: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly zoneId: Schema.String;
+        readonly cellId: Schema.String;
+        readonly layer: Schema.Number;
+        readonly bounds: Schema.Tuple<readonly [Schema.Tuple<readonly [Schema.Number, Schema.Number]>, Schema.Tuple<readonly [Schema.Number, Schema.Number]>]>;
+        readonly players: Schema.Number;
+        readonly epoch: Schema.Number;
+        readonly revision: Schema.Number;
+        readonly state: Schema.Literals<readonly ["creating", "live", "hibernated"]>;
+        readonly roomObservation: Schema.Literals<readonly ["matching", "stale", "missing"]>;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly transitions: Schema.NullOr<Schema.Struct<{
+        readonly after: Schema.NullOr<Schema.String>;
+        readonly nextAfter: Schema.NullOr<Schema.String>;
+        readonly entries: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly mode: Schema.Literals<readonly ["seamless", "portal"]>;
+            readonly phase: Schema.Literals<readonly ["requested", "reserving", "prepared", "ghosting", "persisting", "detaching", "switching", "committed", "settled", "failed", "rolledBack"]>;
+            readonly revision: Schema.Number;
+            readonly entityRevision: Schema.Number;
+            readonly source: Schema.Struct<{
+                readonly worldId: Schema.String;
+                readonly zoneId: Schema.String;
+                readonly cellId: Schema.String;
+                readonly layer: Schema.Number;
+            }>;
+            readonly target: Schema.Struct<{
+                readonly worldId: Schema.String;
+                readonly zoneId: Schema.String;
+                readonly cellId: Schema.String;
+                readonly layer: Schema.Number;
+            }>;
+            readonly createdAt: Schema.String;
+            readonly updatedAt: Schema.String;
+            readonly committedAt: Schema.NullOr<Schema.String>;
+        }>>;
+    }>>;
+}>;
+
+export declare interface WorldInstance {
+    readonly id: string;
+    readonly room: string;
+    readonly maxGroups: number;
+    readonly ttl: Duration.Input;
+}
+
+export 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';
+};
+
+export declare interface WorldLayering {
+    readonly maxPlayers: number;
+    readonly splitAt: number;
+    readonly mergeBelow: number;
+}
+
+export 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;
+}
+
+/** Pure maintenance proposals. Draining never moves or deletes existing players. */
+export declare const worldLayerMaintenance: (raw: WorldLayerMaintenanceInput) => ReadonlyArray<WorldLayerMaintenanceProposal>;
+
+export declare type WorldLayerMaintenanceInput = Pick<WorldLayerInput, 'policy' | 'layers' | 'maxLayers'>;
+
+export declare type WorldLayerMaintenanceProposal = {
+    readonly kind: 'create';
+    readonly layer: number;
+} | {
+    readonly kind: 'drain' | 'hibernate' | 'dispose';
+    readonly layer: number;
+};
+
+export declare interface WorldLayerObservation {
+    readonly layer: number;
+    readonly players: number;
+    readonly state: 'live' | 'hibernated' | 'splitting' | 'merging';
+}
+
+export declare type WorldLayerPolicy = (input: WorldLayerInput) => WorldLayerDecision;
+
+export declare interface WorldMovementIntent {
+    readonly entityId: string;
+    readonly sourceAt: WorldPoint;
+    readonly targetAt: WorldPoint;
+    readonly crossing: boolean;
+}
+
+export declare interface WorldMovementObservation {
+    readonly epoch: number;
+    readonly tick: number;
+    readonly intents: ReadonlyArray<WorldMovementIntent>;
+}
+
+export declare type WorldOnWorldChange = (input: WorldOnWorldChangeInput) => unknown;
+
+export 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 type WorldPoint = readonly [x: number, y: number];
+
+export declare interface WorldPosition {
+    readonly zone: string;
+    readonly at: WorldPoint;
+}
+
+/** The ordinary Promise client's call boundary. An Effect RPC runtime can
+ * supply the same boundary by running its real generated client method. */
+export declare interface WorldRpcControls {
+    readonly subscribeReceipt?: (requestId: string, handlers: WorldClientReceiptHandlers, signal: AbortSignal) => WorldClientReceiptSubscription;
+    prepare(requestId: string, intention: WorldTransitionRequest, signal: AbortSignal): Promise<WorldClientTicket>;
+    observe(requestId: string, signal: AbortSignal): Promise<WorldClientReceipt>;
+    commit(ticket: WorldClientTicket, signal: AbortSignal): Promise<WorldClientReceipt>;
+    cancel(requestId: string, signal: AbortSignal): Promise<WorldClientReceipt>;
+}
+
+/** Transition providers for WorldClient's normal authenticated RPC calls. */
+export declare const worldRpcControls: (client: RoomRpcCaller) => WorldRpcControls;
+
+export declare interface WorldRpcPending {
+    pending(input: {
+        readonly entityId: string;
+        readonly roomId: string;
+    }, signal: AbortSignal): Promise<WorldClientReceipt | null>;
+    readonly subscribePending?: (input: {
+        readonly entityId: string;
+        readonly roomId: string;
+    }, handlers: {
+        readonly onValue: (receipt: WorldClientReceipt | null) => void;
+        readonly onError: (error: unknown) => void;
+    }, signal: AbortSignal) => WorldClientReceiptSubscription;
+}
+
+/** Own active server-request discovery; separate from transition providers. */
+export declare const worldRpcPending: (client: RoomRpcCaller) => WorldRpcPending;
+
+export declare const worldSpawn: <Player>(world: WorldDescriptor<Player>, player: Player) => WorldPosition;
+
+/** Implemented source export inventory only. Required runtime slots/events,
+ * installed table privacy/inspect/stages and actual whole-world conformance remain open. */
+export declare const worldSystemContractManifest: Readonly<{
+    slots: Readonly<{
+        onWorldChange: Readonly<{
+            defaultExport: "defaultWorldOnWorldChange";
+            fixtureExport: "worldOnWorldChangeSlotFixture";
+        }>;
+        layerPolicy: Readonly<{
+            defaultExport: "defaultWorldLayerPolicy";
+            fixtureExport: "worldLayerPolicySlotFixture";
+        }>;
+        transitionPolicy: Readonly<{
+            defaultExport: "defaultWorldTransitionPolicy";
+            fixtureExport: "worldTransitionPolicySlotFixture";
+        }>;
+    }>;
+    ports: Readonly<{
+        transition: Readonly<{
+            tagExport: "WorldTransitionPort";
+            fakeLayerExport: "worldTransitionFakeLayer";
+            fixtureExport: "worldTransitionPortFixture";
+        }>;
+    }>;
+    events: readonly string[];
+}>;
+
+/** Explicit ordinary command binding, never a player RPC or automatic installer. */
+export declare const worldTransitionCommandBindings: (raw: WorldTransitionCommandNames, service: Context.Service.Shape<typeof WorldTransitionPort>) => RoomAppCommandBindings;
+
+export declare interface WorldTransitionCommandNames {
+    readonly transition: string;
+    readonly transitionGroup: string;
+}
+
+export declare type WorldTransitionKind = 'cell' | 'layer' | 'zone' | 'world' | 'instance' | 'return' | 'recover';
+
+export declare interface WorldTransitionLocation extends WorldPosition {
+    readonly world: string;
+    readonly pool: string;
+    readonly layer: number;
+    readonly instance: string | null;
+}
+
+export declare type WorldTransitionMode = 'seamless' | 'portal' | 'recover';
+
+export declare interface WorldTransitionObservation {
+    readonly phase: typeof WorldTransitionPhaseSchema.Type;
+}
+
+export declare type WorldTransitionOrigin = Omit<RoomAppCommand, 'command'>;
+
+export declare const worldTransitionPhases: readonly ["requested", "reserving", "prepared", "ghosting", "persisting", "detaching", "switching", "committed", "settled", "failed", "rolledBack"];
+
+export declare const WorldTransitionPhaseSchema: Schema.Literals<readonly ["requested", "reserving", "prepared", "ghosting", "persisting", "detaching", "switching", "committed", "settled", "failed", "rolledBack"]>;
+
+export declare interface WorldTransitionPlan {
+    readonly kind: WorldTransitionKind;
+    readonly mode: WorldTransitionMode;
+    readonly crossPool: boolean;
+    readonly persistBeforeRelease: boolean;
+    readonly sourceCell: string;
+    readonly targetCell: string;
+}
+
+export declare type WorldTransitionPolicy = (input: WorldTransitionPolicyInput) => WorldTransitionPlan;
+
+export 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;
+}
+
+/** Actual provider owns SQL idempotency, current source authority, lease and commit. */
+export 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 type WorldTransitionRequest = typeof WorldTransitionRequestSchema.Type;
+
+export declare const worldTransitionRequest: (input: unknown) => WorldTransitionRequest;
+
+export declare const WorldTransitionRequestSchema: Schema.Struct<{
+    readonly entityId: Schema.String;
+    readonly target: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"cell">;
+        readonly zone: Schema.String;
+        readonly at: Schema.Tuple<readonly [Schema.Number, Schema.Number]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"zone">;
+        readonly zone: Schema.String;
+        readonly at: Schema.Tuple<readonly [Schema.Number, Schema.Number]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"layer">;
+        readonly layer: Schema.Number;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"world">;
+        readonly world: Schema.String;
+        readonly spawn: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"instance">;
+        readonly instance: Schema.String;
+        readonly group: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"return">;
+    }>]>;
+    readonly options: Schema.Struct<{
+        readonly mode: Schema.Literals<readonly ["auto", "seamless", "portal"]>;
+        readonly reason: Schema.String;
+        readonly crossPool: Schema.Boolean;
+        readonly returnTo: Schema.optional<Schema.Literal<"here">>;
+    }>;
+}>;
+
+export declare type WorldTransitionTarget = typeof WorldTransitionTargetSchema.Type;
+
+export declare const WorldTransitionTargetSchema: 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">;
+}>]>;
+
+export 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;
+}
+
+/** Half-open bounds give every shared edge one deterministic owner. */
+export declare const worldZoneAt: <Player>(world: WorldDescriptor<Player>, position: WorldPoint) => WorldZone;
+
+export { }