@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/wire.d.ts

@@ -0,0 +1,992 @@
+import { Duration } from 'effect';
+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>;
+
+/** Every malformed frame returns a typed failure, including invalid UTF-8. */
+export declare const decodeRoomFrame: (bytes: Uint8Array, limits?: Partial<RoomFrameLimits>) => Result.Result<RoomFrame, ProtocolError>;
+
+export declare const encodeRoomFrame: (frame: RoomFrame, limits?: Partial<RoomFrameLimits>) => Result.Result<Uint8Array<ArrayBuffer>, ProtocolError>;
+
+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 type GeometryChunk = GeometryTileChunk | GeometryHeightfieldChunk | GeometryShapesChunk | GeometryVoxelChunk;
+
+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 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;
+
+export declare interface GeometryNativeCodecMetadata {
+    readonly schemaHash: number;
+    readonly description: string;
+    readonly limits: RoomCodecLimits;
+}
+
+/** Compiler metadata only. Does not validate geometry semantics, authenticate a
+ * manifest, fetch resources or grant a Room/World session. Default wire profiles
+ * are explicit; applications with other profiles must not silently inherit them. */
+export declare const geometryNativeCodecMetadata: () => Readonly<{
+    profile: "default";
+    httpHeaders: Readonly<{
+        scope: "x-voltro-geometry-scope";
+        revision: "x-voltro-geometry-revision";
+        contentSha256: "x-voltro-geometry-content-sha256";
+    }>;
+    navigation: Readonly< GeometryTileNavigationLimits>;
+    navigationReaderLimit: 64;
+    envelopes: Readonly<{
+        '2d-tiles': readonly number[];
+        '2d-heightfield': readonly number[];
+        '3d-shapes': readonly number[];
+        '3d-voxel': readonly number[];
+        content: readonly number[];
+        patch: readonly number[];
+    }>;
+    channels: Readonly<{
+        manifest: Readonly<{
+            codec: GeometryNativeCodecMetadata;
+            fragmentBytes: 8192;
+        }>;
+        delta: Readonly<{
+            codec: GeometryNativeCodecMetadata;
+            fragmentBytes: 8192;
+        }>;
+        edit: Readonly<{
+            codec: GeometryNativeCodecMetadata;
+        }>;
+    }>;
+    chunks: readonly Readonly<{
+        kind: "2d-tiles" | "2d-heightfield" | "3d-shapes" | "3d-voxel";
+        profileLimits: Readonly<Record<string, number>>;
+        state: GeometryNativeCodecMetadata;
+        content: GeometryNativeCodecMetadata;
+    }>[];
+    patch: Readonly<{
+        limits: Readonly<{
+            maxBytes: number;
+            maxMetadataBytes: number;
+        }>;
+        metadata: GeometryNativeCodecMetadata;
+    }>;
+}>;
+
+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 GeometryProceduralContext {
+    readonly seed: number;
+    readonly kind: GeometryKind;
+    readonly address: GeometryChunk['address'];
+    readonly version: string;
+}
+
+declare type GeometryShapesChunk = (typeof GeometryShapesChunkSchema)["Type"];
+
+declare const GeometryShapesChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"3d-shapes">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+        readonly cz: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly extentXRaw: Schema.Int;
+    readonly extentYRaw: Schema.Int;
+    readonly extentZRaw: Schema.Int;
+    readonly shapes: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly halfXRaw: Schema.Int;
+        readonly halfYRaw: Schema.Int;
+        readonly halfZRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"aabb">;
+    }>, Schema.Struct<{
+        readonly radiusRaw: Schema.Int;
+        readonly id: Schema.String;
+        readonly xRaw: Schema.Int;
+        readonly yRaw: Schema.Int;
+        readonly zRaw: Schema.Int;
+        readonly kind: Schema.Literal<"sphere">;
+    }>]>>;
+}>;
+
+declare interface GeometryShapesLimits {
+    readonly maxShapes: number;
+    readonly maxBytes: number;
+}
+
+declare type GeometryShapeTemplate = {
+    readonly key: string;
+    readonly kind: 'aabb';
+    readonly halfXRaw: number;
+    readonly halfYRaw: number;
+    readonly halfZRaw: number;
+} | {
+    readonly key: string;
+    readonly kind: 'sphere';
+    readonly radiusRaw: number;
+};
+
+declare type GeometrySource = {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'cms';
+    readonly key: string;
+    readonly channel: string;
+} | {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'imported';
+    readonly directory: string;
+} | {
+    readonly _tag: 'GeometrySource';
+    readonly kind: 'procedural';
+    readonly seed: number;
+    readonly generator: GeometryGenerator;
+};
+
+declare type GeometryTileChunk = (typeof GeometryTileChunkSchema)["Type"];
+
+declare const GeometryTileChunkSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"2d-tiles">;
+    readonly formatVersion: Schema.Literal<1>;
+    readonly address: Schema.Struct<{
+        readonly worldId: Schema.String;
+        readonly layerSetId: Schema.String;
+        readonly cx: Schema.Int;
+        readonly cy: Schema.Int;
+    }>;
+    readonly version: Schema.String;
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+    readonly tileSizeRaw: Schema.Int;
+    readonly palette: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly solid: Schema.Boolean;
+    }>>;
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly paletteIndex: Schema.Int;
+        readonly length: Schema.Int;
+    }>>;
+}>;
+
+declare interface 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 GeometryTileNavigationLimits {
+    readonly maxDiscovered: number;
+    readonly maxOpen: number;
+    readonly maxPathLength: number;
+    readonly maxAdvanceExpansions: number;
+}
+
+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;
+}
+
+/** Pure projection of the actual admitted World catalogue. No generator,
+ * strategy, spawn, source path/credential or server service enters SDK metadata. */
+export declare const geometryWorldMetadata: (offered: ReadonlyArray<AnyWorldDescriptor>) => readonly Readonly<{
+    worldId: string;
+    kind: "2d-tiles" | "2d-heightfield" | "3d-shapes" | "3d-voxel";
+    bounds: WorldBounds;
+    rooms: readonly string[];
+    chunkSizeRaw: number;
+    sourceKind: "cms" | "imported" | "procedural";
+    dynamic: {
+        readonly enabled: boolean;
+        readonly maxDeltaBytesPerChunk: number;
+        readonly persist: {
+            readonly everyMs: number;
+            readonly onUnload: boolean;
+        };
+    };
+    collision: {
+        readonly derive: "bitgrid" | "heightfield" | "shapes";
+        readonly resolution: number;
+        readonly resolutionRaw: number;
+    };
+    nav: {
+        readonly derive: "grid" | "none";
+        readonly navBudgetMs: number;
+        readonly maxAdvanceSteps: number;
+    };
+    streaming: {
+        readonly client: {
+            readonly radiusChunks: number;
+            readonly prefetchChunks: number;
+            readonly maxConcurrent: number;
+            readonly maxCachedChunks: number;
+        };
+        readonly cell: {
+            readonly marginChunks: number;
+        };
+    };
+    lod: readonly {
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }[];
+    budgets: {
+        readonly maxPreparedChunks: number;
+        readonly maxPreparedBytes: number;
+        readonly maxLodLevels: number;
+        readonly maxRayCells: number;
+        readonly maxOverlapTests: number;
+    };
+    nativeStrategies: readonly ("opValidator" | "applyOp" | "collisionDerive" | "navDerive" | "compaction" | "migrateDelta")[];
+}>[];
+
+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 interface RoomCodecLimits {
+    readonly maxBytes: number;
+    readonly maxCollectionLength: number;
+    readonly maxFieldId: number;
+}
+
+export 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;
+};
+
+export declare interface RoomFrameInputReceipt {
+    readonly lastAppliedSeq: number;
+    readonly flags: number;
+}
+
+/** Frame layout participates in the normal Hello manifest hash. Peers with a
+ * different binary layout must refuse admission before any state/input use. */
+export declare const roomFrameLayout = "v1/input-ackTick/state-inputReceipt/pong-tick/lockstep-v4-snapshot/recovery-v2/world-handoff-v1";
+
+export declare interface RoomFrameLimits {
+    readonly maxBytes: number;
+    readonly maxInputs: number;
+}
+
+export 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>;
+}
+
+export declare interface RoomLockstepInputMatrix {
+    readonly players: RoomLockstepPlayerMask;
+    readonly inputs: ReadonlyArray<Uint8Array>;
+}
+
+/** Bits identify server-assigned roster slots 0..63, not Subject or player IDs. */
+export declare type RoomLockstepPlayerMask = Uint64Words;
+
+/** Public opaque simulation identities, never Subjects or Session credentials. */
+export declare interface RoomLockstepWirePlayer {
+    readonly slot: number;
+    readonly playerId: number;
+}
+
+/** Input and channel schemas are not state schemas: sorted field names derive
+ * their binary order, while server state always requires explicit field IDs. */
+export 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>;
+}
+
+export declare interface RoomStateField {
+    /** Parent scope is formed from field IDs, not mutable author field names. */
+    readonly scope: string;
+    readonly id: number;
+    readonly name: string;
+}
+
+export declare interface RoomStateTransformRules {
+    readonly scope: string;
+    readonly rules: TransformRules;
+}
+
+/** 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;
+}
+
+export declare type TransformRules = TransformRules2D | TransformRules3D;
+
+export 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;
+}
+
+export 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];
+
+declare interface WorldDefinition<Player> {
+    readonly name: string;
+    readonly map: {
+        readonly bounds: WorldBounds;
+    };
+    readonly zones: ReadonlyArray<WorldZone>;
+    readonly instances?: ReadonlyArray<WorldInstance>;
+    readonly persistence: {
+        readonly entities: 'world';
+        readonly snapshotEveryMs: number;
+        readonly journal: boolean;
+    };
+    readonly handoff: {
+        readonly marginUnits: number;
+        readonly ghostUnits: number;
+    };
+    readonly spawn: (context: {
+        readonly player: Player;
+    }) => WorldPosition;
+    readonly geometry?: WorldGeometryDefinition | undefined;
+    readonly hosts?: {
+        readonly pool: string;
+    };
+    readonly characters?: 'shared' | 'per-world';
+    readonly transitionCooldownMs?: number;
+    /** Authoring inventory bounds, not measured runtime capacity. */
+    readonly budgets?: {
+        readonly maxZones?: number;
+        readonly maxCells?: number | undefined;
+        readonly maxInstances?: number;
+    };
+    readonly strategies?: {
+        readonly layerPolicy?: WorldLayerPolicy | undefined;
+        readonly transitionPolicy?: WorldTransitionPolicy;
+        readonly onWorldChange?: WorldOnWorldChange;
+    };
+}
+
+declare interface WorldDescriptor<Player> extends Omit<WorldDefinition<Player>, 'instances' | 'budgets' | 'characters' | 'transitionCooldownMs' | 'strategies' | 'geometry'> {
+    readonly geometry?: WorldGeometryDescriptor | undefined;
+    readonly _tag: 'WorldDescriptor';
+    readonly instances: ReadonlyArray<Omit<WorldInstance, 'ttl'> & {
+        readonly ttlMs: number;
+    }>;
+    readonly budgets: {
+        readonly maxZones: number;
+        readonly maxCells: number;
+        readonly maxInstances: number;
+    };
+    readonly characters: 'shared' | 'per-world';
+    readonly transitionCooldownMs: number;
+    readonly cellCount: number;
+    readonly strategies: {
+        readonly layerPolicy: WorldLayerPolicy;
+        readonly transitionPolicy: WorldTransitionPolicy;
+        readonly onWorldChange: WorldOnWorldChange;
+    };
+}
+
+declare interface WorldGeometryDefinition {
+    readonly strategies?: WorldGeometryStrategies | undefined;
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize?: number;
+    readonly dynamic?: {
+        readonly enabled?: boolean | undefined;
+        readonly maxDeltaBytesPerChunk?: number;
+        readonly persist?: {
+            readonly everyMs?: number;
+            readonly onUnload?: boolean;
+        };
+    };
+    readonly collision?: {
+        readonly derive?: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution?: number;
+    };
+    readonly nav?: {
+        readonly derive?: 'grid' | 'none';
+        readonly navBudgetMs?: number;
+        readonly maxAdvanceSteps?: number;
+    };
+    readonly streaming?: {
+        readonly client?: {
+            readonly radiusChunks?: number;
+            readonly prefetchChunks?: number;
+            readonly maxConcurrent?: number | undefined;
+            readonly maxCachedChunks?: number;
+        };
+        readonly cell?: {
+            readonly marginChunks?: number;
+        };
+    };
+    readonly lod?: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets?: {
+        readonly maxPreparedChunks?: number;
+        readonly maxPreparedBytes?: number;
+        readonly maxLodLevels?: number;
+        readonly maxRayCells?: number | undefined;
+        readonly maxOverlapTests?: number | undefined;
+    };
+}
+
+declare interface WorldGeometryDescriptor {
+    readonly strategies: GeometryEditStrategies & GeometryDerivationStrategies & GeometryCompactionStrategies & {
+        readonly migrateDelta: GeometryMigrateDelta;
+    };
+    readonly _tag: 'WorldGeometry';
+    readonly kind: GeometryKind;
+    readonly static: GeometrySource;
+    readonly chunkSize: number;
+    readonly chunkSizeRaw: number;
+    readonly dynamic: {
+        readonly enabled: boolean;
+        readonly maxDeltaBytesPerChunk: number;
+        readonly persist: {
+            readonly everyMs: number;
+            readonly onUnload: boolean;
+        };
+    };
+    readonly collision: {
+        readonly derive: 'bitgrid' | 'heightfield' | 'shapes';
+        readonly resolution: number;
+        readonly resolutionRaw: number;
+    };
+    readonly nav: {
+        readonly derive: 'grid' | 'none';
+        readonly navBudgetMs: number;
+        readonly maxAdvanceSteps: number;
+    };
+    readonly streaming: {
+        readonly client: {
+            readonly radiusChunks: number;
+            readonly prefetchChunks: number;
+            readonly maxConcurrent: number;
+            readonly maxCachedChunks: number;
+        };
+        readonly cell: {
+            readonly marginChunks: number;
+        };
+    };
+    readonly lod: ReadonlyArray<{
+        readonly beyondChunks: number;
+        readonly fields: ReadonlyArray<string>;
+    }>;
+    readonly budgets: {
+        readonly maxPreparedChunks: number;
+        readonly maxPreparedBytes: number;
+        readonly maxLodLevels: number;
+        readonly maxRayCells: number;
+        readonly maxOverlapTests: number;
+    };
+}
+
+declare interface WorldGeometryStrategies extends GeometryVersionMigrationStrategies, Partial<GeometryEditStrategies>, Partial<GeometryDerivationStrategies>, Partial<GeometryCompactionStrategies> {
+}
+
+declare 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;
+}
+
+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 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 { }