@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/web.d.ts

@@ -0,0 +1,2286 @@
+import { Duration } from 'effect';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Result } 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. */
+declare type AnyWorldDescriptor = WorldDescriptor<never>;
+
+declare class BudgetExceeded extends BudgetExceeded_base {
+    get message(): string;
+}
+
+declare const BudgetExceeded_base: Schema.Class<BudgetExceeded, Schema.TaggedStruct<"BudgetExceeded", {
+    readonly budget: Schema.String;
+    readonly limit: Schema.Number;
+}>, YieldableError>;
+
+export declare const captureRoomClientReliableChannel: (offered: unknown, channel: string, schemaHash: number) => Readonly<{
+    identity: () => {
+        readonly sessionId: string;
+        readonly epoch: number;
+    } | null;
+    onMessage: (listener: (payload: unknown) => void) => (() => void);
+    subscribe: (listener: () => void) => (() => void);
+}>;
+
+export declare const captureRoomClientReliableIntention: (offered: unknown, channel: string, schemaHash: number) => Readonly<{
+    identity: () => {
+        readonly sessionId: string;
+        readonly epoch: number;
+    } | null;
+    write: (payload: unknown) => Promise<void>;
+}>;
+
+export declare const captureRoomTransportEndpoints: (offered: RoomTransportEndpoints) => RoomTransportEndpoints;
+
+export declare const createRoom: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>>(client: RoomRpcCaller, manifest: RoomWireManifest<S, I>, input: {
+    readonly room: string;
+    readonly options: unknown;
+    readonly pool?: string | undefined;
+}, options: RoomClientOptions) => Promise<RoomConnection<S, I, {
+    readonly mode: "join" | "create";
+    readonly room: string;
+    readonly options: unknown;
+    readonly pool?: string | undefined;
+} | {
+    readonly mode: "joinById";
+    readonly roomId: string;
+    readonly role?: "spectator" | "player" | undefined;
+}>>;
+
+/** Framework-free client composition using the actual platform binary socket.
+ * The API facade supplies normal reserve/resume RPC methods; the token remains
+ * inside the connection and is transmitted only in the binary Hello. */
+export declare const createRoomClient: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, JoinInput>(manifest: RoomWireManifest<S, I>, reservations: RoomReservationClient<JoinInput>, options: RoomClientOptions) => RoomConnection<S, I, JoinInput>;
+
+/** Initial clock convergence and steady keepalive use one owned timeout. */
+export declare const defaultRoomClockPingCadence: RoomClockPingCadence;
+
+export declare const defaultRoomClockSampling: Readonly<RoomClockSamplingOptions>;
+
+export declare const defaultRoomInputRedundancy: Readonly<RoomInputRedundancyOptions>;
+
+/** Default policy is used by the orchestrator and can be composed/overridden. */
+export declare const defaultRoomReconnectPolicy: RoomReconnectPolicy;
+
+/** Uses the platform WebSocket, never an RPC socket or persistent credentials. */
+export declare const defaultRoomWebSocketFactory: RoomWebSocketFactory;
+
+/** Native TLS verification remains enabled. A development certificate is only
+ * ever pinned by its advertised digest (`serverCertificateHashes`), never
+ * bypassed. No credential URL, bearer header/query, global polyfill or eager
+ * socket on module import. */
+export declare const defaultRoomWebTransportFactory: RoomWebTransportFactory;
+
+/** One current reliable-stream envelope: four-byte unsigned big-endian length,
+ * then the existing Room wire frame. Datagram frames remain unprefixed. */
+export declare const encodeRoomStreamFrame: (offered: Uint8Array, maxFrameBytes: number) => Uint8Array;
+
+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;
+}
+
+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;
+});
+
+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;
+};
+
+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;
+}
+
+export declare const joinById: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>>(client: RoomRpcCaller, manifest: RoomWireManifest<S, I>, input: {
+    readonly roomId: string;
+    readonly role?: "player" | "spectator";
+}, options: RoomClientOptions) => Promise<RoomConnection<S, I, {
+    readonly mode: "join" | "create";
+    readonly room: string;
+    readonly options: unknown;
+    readonly pool?: string | undefined;
+} | {
+    readonly mode: "joinById";
+    readonly roomId: string;
+    readonly role?: "spectator" | "player" | undefined;
+}>>;
+
+export declare const joinRoom: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>>(client: RoomRpcCaller, manifest: RoomWireManifest<S, I>, input: {
+    readonly room: string;
+    readonly options: unknown;
+    readonly pool?: string | undefined;
+}, options: RoomClientOptions) => Promise<RoomConnection<S, I, {
+    readonly mode: "join" | "create";
+    readonly room: string;
+    readonly options: unknown;
+    readonly pool?: string | undefined;
+} | {
+    readonly mode: "joinById";
+    readonly roomId: string;
+    readonly role?: "spectator" | "player" | undefined;
+}>>;
+
+/** Enter a seat reserved for the caller elsewhere, such as a Matchmaking assignment: the
+ * seat is redeemed with `rooms.resume` (same subject only) instead of reserving a new one.
+ * Failed entry withdraws the seat, as the other entry helpers do. */
+export declare const joinSeat: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>>(client: RoomRpcCaller, manifest: RoomWireManifest<S, I>, input: {
+    readonly sessionId: string;
+}, options: RoomClientOptions) => Promise<RoomConnection<S, I, {
+    readonly sessionId: string;
+}>>;
+
+/** Enter a World: the server places a first-time player at the World's spawn and otherwise
+ * returns the player's current Room (`rooms.world.join`); `manifest` is that Room's
+ * definition. `entityId` names the player's entity in later World moves. */
+export declare const joinWorld: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>>(client: RoomRpcCaller, manifest: RoomWireManifest<S, I>, input: {
+    readonly world: string;
+}, options: RoomClientOptions) => Promise<{
+    connection: RoomConnection<S, I, {
+        readonly world: string;
+    }>;
+    entityId: string;
+}>;
+
+declare const listDescriptor: QueryProcedureDescriptor<"rooms.list", Schema.Struct<{
+    readonly room: Schema.NonEmptyString;
+    readonly limit: Schema.optional<Schema.Int>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly clients: Schema.Int;
+    readonly maxClients: Schema.Int;
+    readonly locked: Schema.Boolean;
+}>>, Schema.Union<readonly [typeof BudgetExceeded, typeof NotRoomMember, typeof ProtocolError, typeof RoomAuthoringError, typeof RoomForbidden, typeof RoomFull, typeof RoomGone, typeof RoomLocked, typeof RoomPoolWaking, typeof RoomsClosed, typeof SeatExpired]>>;
+
+export declare const listRooms: (client: RoomRpcCaller, room: string, signal: AbortSignal, limit?: number) => Promise<RoomPublicListing>;
+
+/** Explicit transferred Web Streams adapter. Owns frame boundaries/locks and
+ * bounded work, never TLS/auth/socket creation, registry, SQL or an actor tick.
+ * A native WT opener and actual sidecar must supply the real duplex/parent. */
+export declare const makeRoomStreamTransport: (offered: RoomStreamTransportOptions) => Promise<RoomManagedStreamTransport>;
+
+/** 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;
+}>;
+
+/** 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 class NotRoomMember extends NotRoomMember_base {
+}
+
+declare const NotRoomMember_base: Schema.Class<NotRoomMember, Schema.TaggedStruct<"NotRoomMember", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+/** Bounded binary WS lane. Native buffer drain is no peer receipt. One pressure
+ * poll only; close requests fence immediately, terminal cleanup remains awaited. */
+export declare const openRoomSocketTransport: (address: string, parentSignal: AbortSignal, offered?: RoomSocketTransportOptions) => Promise<RoomManagedSocketTransport>;
+
+/** Opens one real native session and one framed reliable stream. Capability
+ * comes from that session after ready, never browser/version guessing. The
+ * Room Hello and seat admission still belong to the existing RoomSession. */
+export declare const openRoomWebTransport: (address: string, signal: AbortSignal, offered: RoomWebTransportClientOptions, certificateHash?: string) => Promise<RoomManagedStreamTransport>;
+
+declare interface PreparedCommon {
+    readonly scope: GeometryPersistenceScope;
+    readonly revision: number;
+    readonly blobSha256: string;
+    readonly contentSha256: string;
+    readonly accountedBytes: 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;
+
+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>;
+
+export declare interface RoomByteDuplex {
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+}
+
+declare interface RoomChannel {
+    readonly schema: Schema.Codec<unknown, unknown>;
+    readonly direction: 'both' | 'server' | 'client';
+    readonly reliable: boolean;
+}
+
+export declare interface RoomClientInputRecovery {
+    readonly nextSeq: number;
+    readonly lastAppliedSeq: number;
+}
+
+export declare interface RoomClientOptions extends RoomConnectionOptions {
+    readonly clock?: RoomClock;
+    readonly socket?: RoomSocketTransportOptions | undefined;
+    readonly webTransport?: Omit<RoomWebTransportClientOptions, 'clock'>;
+    readonly transportPreference?: RoomTransportPreference;
+}
+
+/** API-facing reservation result. Credentials are retained only for Hello. */
+export declare interface RoomClientReservation {
+    readonly roomId: string;
+    readonly sessionId: string;
+    readonly token: Uint8Array;
+    readonly address: string;
+    readonly expiresAt: number;
+    readonly endpoints?: RoomTransportEndpoints | undefined;
+}
+
+/** Browser/Node-native shape; platform adapters may provide their own factory. */
+export declare interface RoomClientSocket {
+    readonly readyState: number;
+    readonly bufferedAmount: number;
+    binaryType: string;
+    addEventListener(type: 'open' | 'message' | 'close' | 'error', listener: (event: RoomSocketEvent) => void): void;
+    removeEventListener(type: 'open' | 'message' | 'close' | 'error', listener: (event: RoomSocketEvent) => void): void;
+    send(bytes: Uint8Array<ArrayBuffer>): void;
+    close(code: number, reason: string): void;
+}
+
+declare interface RoomClock {
+    now(): number;
+}
+
+declare type RoomClockPingCadence = (joinedForMs: number) => number;
+
+export 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;
+}
+
+declare interface RoomCodecLimits {
+    readonly maxBytes: number;
+    readonly maxCollectionLength: number;
+    readonly maxFieldId: number;
+}
+
+export declare const roomCodecs: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>>(manifest: RoomWireManifest<S, I>) => Readonly<{
+    state: RoomStateCodec<S>;
+    input: RoomInputCodec<I>;
+    channels: readonly Readonly<{
+        name: string;
+        direction: "both" | "client" | "server";
+        reliable: boolean;
+        codec: RoomInputCodec<Schema.Codec<unknown, unknown, never, never>>;
+    }>[];
+    schemaHash: number;
+    readonly transformRules: Uint8Array;
+}>;
+
+/** 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. */
+export 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;
+}
+
+export 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;
+}
+
+export declare interface RoomDatagramLane {
+    readonly maxDatagramBytes: number;
+    send(frame: Uint8Array): void;
+    onFrame(listener: (frame: Uint8Array, receivedAt: number) => void): () => void;
+}
+
+export 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 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>;
+
+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 class RoomGone extends RoomGone_base {
+}
+
+declare const RoomGone_base: Schema.Class<RoomGone, Schema.TaggedStruct<"RoomGone", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare class RoomInputCodec<S extends Schema.Codec<unknown, unknown>> {
+    readonly schema: S;
+    private readonly codec;
+    constructor(schema: S, config?: Partial<RoomCodecLimits>, defaultNumberPrecision?: 'f32' | 'f64');
+    get schemaHash(): number;
+    get limits(): RoomCodecLimits;
+    /** Actual admitted binary input/channel layout; no schema loader or authority. */
+    schemaDescription(): string;
+    full(input: (S)["Type"]): Result.Result<Uint8Array, ProtocolError>;
+    decodeFull(bytes: Uint8Array): Result.Result<(S)["Type"], ProtocolError>;
+}
+
+/** Pure bounded client intentions. Never state, socket retransmission, SQL or
+ * authority. A duplicate prefix is discarded by the actual actor's seq fence. */
+export declare class RoomInputRedundancy {
+    private readonly options;
+    private readonly entries;
+    private bytes;
+    private lastSeq;
+    constructor(offered?: RoomInputRedundancyOptions);
+    get bufferedBytes(): number;
+    get bufferedInputs(): number;
+    offer(seq: number, tickHint: number, payload: Uint8Array): Extract<RoomFrame, {
+        kind: 'Input';
+    }>;
+    clear(): void;
+}
+
+export declare interface RoomInputRedundancyOptions {
+    /** Input count is a redundancy budget, never a delivery guarantee. */
+    readonly inputRedundancy: number;
+    readonly maxInputHistoryBytes: number;
+}
+
+/** One replaceable unsent datagram, separate from an already accepted native
+ * write. Latest wins under pressure; a mailbox is never a reliable replay queue. */
+export declare class RoomLatestDatagram {
+    readonly maxDatagramBytes: number;
+    private pending;
+    private dropped;
+    private ended;
+    constructor(maxDatagramBytes: number);
+    get droppedDatagrams(): number;
+    get bufferedBytes(): number;
+    offer(offered: Uint8Array): void;
+    take(): Uint8Array | null;
+    close(): void;
+}
+
+declare class RoomLocked extends RoomLocked_base {
+}
+
+declare const RoomLocked_base: Schema.Class<RoomLocked, Schema.TaggedStruct<"RoomLocked", {
+    readonly roomId: Schema.String;
+}>, YieldableError>;
+
+declare interface RoomLockstepInputMatrix {
+    readonly players: RoomLockstepPlayerMask;
+    readonly inputs: ReadonlyArray<Uint8Array>;
+}
+
+/** Bits identify server-assigned roster slots 0..63, not Subject or player IDs. */
+declare type RoomLockstepPlayerMask = Uint64Words;
+
+/** Public opaque simulation identities, never Subjects or Session credentials. */
+declare interface RoomLockstepWirePlayer {
+    readonly slot: number;
+    readonly playerId: number;
+}
+
+export declare interface RoomManagedSocketTransport extends RoomTransport {
+    /** Joins actual native CLOSED/close-event evidence and listener cleanup.
+     * Failed cleanup remains owned and can be explicitly retried. */
+    closeAsync(code: number, reason: string): Promise<void>;
+}
+
+export declare interface RoomManagedStreamTransport extends RoomTransport {
+    /** Await owned reads/writes, parent release and lock cleanup; failed cleanup
+     * retains its handle and can be retried. Never a native delivery receipt. */
+    closeAsync(code: number, reason: string): Promise<void>;
+}
+
+/** Current native WebTransport API boundary. Platform objects may use native
+ * prototype getters; authored options below must contain own data properties. */
+export declare interface RoomNativeWebTransport {
+    readonly ready: Promise<void>;
+    readonly closed: Promise<unknown>;
+    /** Absent in Chromium; see the capability fallback in openRoomWebTransport. */
+    readonly reliability?: 'pending' | 'reliable-only' | 'supports-unreliable' | undefined;
+    readonly datagrams: {
+        readonly readable: ReadableStream<Uint8Array>;
+        readonly maxDatagramSize: number;
+        /** Current specification; Chromium exposes the single `writable` instead. */
+        createWritable?(): WritableStream<Uint8Array>;
+        readonly writable?: WritableStream<Uint8Array>;
+    };
+    createBidirectionalStream(): Promise<RoomByteDuplex>;
+    close(info: {
+        readonly closeCode: number;
+        readonly reason: string;
+    }): void;
+}
+
+/** The pool has no host because it scaled to zero; one is starting. Reserve again after `retryAfterMs`. */
+declare class RoomPoolWaking extends RoomPoolWaking_base {
+}
+
+declare const RoomPoolWaking_base: Schema.Class<RoomPoolWaking, Schema.TaggedStruct<"RoomPoolWaking", {
+    readonly pool: Schema.String;
+    readonly retryAfterMs: Schema.Number;
+}>, YieldableError>;
+
+export declare type RoomPublicListing = typeof listDescriptor.output.Type;
+
+/** Framework-free binary session core. Reservation, reconnect orchestration and
+ * render hooks are separate; this core never persists a seat token. */
+export declare interface RoomReconciliationSnapshot<S> {
+    readonly epoch: number;
+    readonly tick: number;
+    readonly lastAppliedSeq: number;
+    readonly state: S;
+}
+
+export declare type RoomReconnectPolicy = (input: RoomReconnectPolicyInput) => number;
+
+export declare interface RoomReconnectPolicyInput {
+    readonly attempt: number;
+    readonly initialBackoffMs: number;
+    readonly maxBackoffMs: number;
+    readonly remainingMs: number;
+    readonly random: number;
+}
+
+export declare interface RoomReliableLane {
+    send(frame: Uint8Array): Promise<void>;
+    onFrame(listener: (frame: Uint8Array, receivedAt: number) => void): () => void;
+}
+
+export 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>;
+}
+
+export 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;
+}
+
+/** Tags resolve per call, so an installed plugin alias moves the entire API.
+ * Responses are already decoded by the normal caller; tokens stay in memory. */
+export declare const roomRpcReservations: (client: RoomRpcCaller) => RoomReservationClient<ReserveRoomInput>;
+
+/** New Room reservations are closed for this caller (maintenance, a kill switch...): the app's
+ * `admission` refused. `until`: epoch ms when they reopen, if known; `messageKey`: the app's text. */
+declare class RoomsClosed extends RoomsClosed_base {
+}
+
+declare const RoomsClosed_base: Schema.Class<RoomsClosed, Schema.TaggedStruct<"RoomsClosed", {
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly messageKey: Schema.String;
+}>, YieldableError>;
+
+export declare 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>;
+}
+
+export declare type RoomSessionStatus = 'connecting' | 'joined' | 'reconnecting' | 'left' | 'kicked' | 'gone';
+
+declare interface RoomSocketEvent {
+    readonly type: string;
+    readonly data?: unknown;
+    readonly code?: number;
+    readonly reason?: string;
+}
+
+export declare interface RoomSocketTransportOptions {
+    readonly factory?: RoomWebSocketFactory;
+    readonly clock?: RoomClock;
+    readonly connectTimeoutMs?: number;
+    readonly drainPollMs?: number;
+    readonly maxFrameBytes?: number;
+    readonly maxPendingBytes?: number;
+    readonly maxPendingFrames?: number;
+    readonly highWaterBytes?: number;
+    readonly maxListeners?: number;
+}
+
+/** Input and channel schemas are not state schemas: sorted field names derive
+ * their binary order, while server state always requires explicit field IDs. */
+declare class RoomStateCodec<S extends Schema.Codec<unknown, unknown>> {
+    readonly schema: S;
+    private readonly codec;
+    constructor(schema: S, config?: Partial<RoomCodecLimits>);
+    get schemaHash(): number;
+    get limits(): RoomCodecLimits;
+    /** Canonical binary layout, including quantization and static movement rules.
+     * This is descriptive data; it grants neither authority nor a schema loader. */
+    schemaDescription(): string;
+    fieldManifest(): ReadonlyArray<RoomStateField>;
+    transformRulesManifest(): ReadonlyArray<RoomStateTransformRules>;
+    full(state: (S)["Type"]): Result.Result<Uint8Array, ProtocolError>;
+    decodeFull(bytes: Uint8Array): Result.Result<(S)["Type"], ProtocolError>;
+    delta(state: (S)["Type"], baseline: (S)["Type"], includeUnchanged?: boolean): Result.Result<Uint8Array | null, ProtocolError>;
+    decodeDelta(bytes: Uint8Array, baseline: (S)["Type"]): Result.Result<(S)["Type"], ProtocolError>;
+}
+
+declare interface RoomStateField {
+    /** Parent scope is formed from field IDs, not mutable author field names. */
+    readonly scope: string;
+    readonly id: number;
+    readonly name: string;
+}
+
+declare interface RoomStateTransformRules {
+    readonly scope: string;
+    readonly rules: TransformRules;
+}
+
+/** Incremental byte-stream framing only. Neither stream read boundaries nor
+ * writes are frame boundaries. At most one bounded frame is retained, no
+ * concatenation queue, SQL, transport, timer or authentication is owned. */
+export declare class RoomStreamFrameDecoder {
+    private readonly options;
+    private readonly header;
+    private headerBytes;
+    private payload;
+    private payloadBytes;
+    private ended;
+    constructor(offered: RoomStreamFramingOptions);
+    /** Received bytes retained for the next chunk, not allocated-buffer capacity. */
+    get bufferedBytes(): number;
+    push(offered: Uint8Array): ReadonlyArray<Uint8Array>;
+    /** EOF is valid only between frames. A truncated header/body fails closed. */
+    finish(): void;
+}
+
+export declare interface RoomStreamFramingOptions {
+    readonly maxFrameBytes: number;
+    readonly maxChunkBytes: number;
+    readonly maxFramesPerChunk: number;
+}
+
+export declare interface RoomStreamTransportOptions extends RoomStreamFramingOptions {
+    readonly reliable: RoomByteDuplex;
+    readonly datagrams?: RoomByteDuplex & {
+        readonly maxDatagramBytes: number;
+    };
+    readonly maxQueuedBytes: number;
+    readonly maxListeners: number;
+    readonly clock: Pick<RoomClock, 'now'>;
+    readonly signal: AbortSignal;
+    /** Release the actual transferred parent transport/session; await its close. */
+    readonly release: (code: number, reason: string) => Promise<void>;
+}
+
+export 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>;
+}
+
+/** Retains the actual transferred lifetime after a failed acquisition or
+ * withdrawal. A deadline or a thrown close is never terminal evidence. */
+export declare class RoomTransportCleanupFailure extends Error {
+    private readonly cleanup;
+    readonly _tag = "RoomTransportCleanupFailure";
+    private pending;
+    private complete;
+    constructor(cleanup: () => Promise<void>);
+    cleanupAsync(): Promise<void>;
+}
+
+/** Opens the advertised native endpoint first in auto mode. Only a completed
+ * failed acquisition can fall back; incomplete cleanup retains its owner. No
+ * browser/version guesses, bearer URL, Hello replay or post-admission switch. */
+export declare const roomTransportConnector: (options: RoomTransportConnectorOptions) => ((address: string, signal: AbortSignal, endpoints?: RoomTransportEndpoints) => Promise<RoomTransport>);
+
+export declare interface RoomTransportConnectorOptions {
+    readonly clock: Pick<RoomClock, 'now'>;
+    readonly preference?: RoomTransportPreference | undefined;
+    readonly socket?: RoomSocketTransportOptions | undefined;
+    readonly webTransport?: Omit<RoomWebTransportClientOptions, 'clock'> | undefined;
+}
+
+/** Public routing metadata only. Neither endpoint conveys seat authority. */
+export 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 type RoomTransportPreference = 'auto' | 'ws' | 'wt';
+
+export declare type RoomWebSocketFactory = (address: string) => RoomClientSocket;
+
+export declare interface RoomWebTransportClientOptions extends RoomStreamFramingOptions {
+    readonly factory?: RoomWebTransportFactory;
+    readonly clock: Pick<RoomClock, 'now'>;
+    readonly connectTimeoutMs: number;
+    readonly maxQueuedBytes: number;
+    readonly maxListeners: number;
+    readonly maxDatagramBytes: number;
+}
+
+/** `certificateHash` is the base64 SHA-256 of a pinned development certificate. */
+export declare type RoomWebTransportFactory = (address: string, certificateHash?: string) => RoomNativeWebTransport;
+
+export 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. */
+export 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 class SeatExpired extends SeatExpired_base {
+}
+
+declare const SeatExpired_base: Schema.Class<SeatExpired, Schema.TaggedStruct<"SeatExpired", {
+    readonly sessionId: Schema.String;
+}>, YieldableError>;
+
+declare type TransformRules = TransformRules2D | TransformRules3D;
+
+declare interface TransformRules2D {
+    readonly bounds: {
+        readonly min: readonly [number, number];
+        readonly max: readonly [number, number];
+    };
+    readonly maxSpeed: number;
+    readonly maxAccel: number;
+    readonly precision: number;
+    readonly rotation?: {
+        readonly bits: number;
+    } | undefined;
+    readonly velocity?: 'send' | 'derive' | 'none' | undefined;
+    readonly interpolation: 'linear' | 'hermite' | 'none';
+    readonly extrapolateMs: number;
+    readonly teleportThreshold: number;
+}
+
+declare interface TransformRules3D {
+    readonly bounds: {
+        readonly min: readonly [number, number, number];
+        readonly max: readonly [number, number, number];
+    };
+    readonly maxSpeed: number;
+    readonly maxAccel: number;
+    readonly precision: number;
+    readonly rotation?: {
+        readonly bits: number;
+    } | undefined;
+    readonly interpolation: 'linear' | 'hermite' | 'none';
+    readonly extrapolateMs: number;
+    readonly teleportThreshold: number;
+}
+
+/** Exact unsigned 64-bit integer as independent 32-bit words. */
+declare interface Uint64Words {
+    readonly hi: number;
+    readonly lo: number;
+}
+
+declare type WorldBounds = readonly [minimum: WorldPoint, maximum: WorldPoint];
+
+/** 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>;
+}
+
+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;
+
+export 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>;
+}>;
+
+export 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;
+    }>;
+}>;
+
+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;
+    };
+}
+
+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;
+}
+
+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> {
+}
+
+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;
+}
+
+declare interface WorldInstance {
+    readonly id: string;
+    readonly room: string;
+    readonly maxGroups: number;
+    readonly ttl: Duration.Input;
+}
+
+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;
+
+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;
+}
+
+declare type WorldPoint = readonly [x: number, y: number];
+
+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;
+
+/** Explicit settled-group follower provider; never an automatic fallback from a refused reservation. */
+export declare const worldRpcFollowerReservations: (client: RoomRpcCaller) => RoomReservationClient<WorldClientTicket>;
+
+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 worldRpcReservations: (client: RoomRpcCaller) => RoomReservationClient<WorldClientTicket>;
+
+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 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;
+}
+
+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 { }