@genex-ai/multiplayer 0.17.1 → 0.17.8

package/dist/module-CSpXrzFc.d.ts

@@ -0,0 +1,1187 @@
+import { P as PresetName, d as FirstpersonWorldSpec, I as WorldKey, C as ClaimVerdict } from './shot-world-D22tqOUT.js';
+
+/** What a room runs with, unless its module says otherwise, and the bounds of what it may say (seconds). */
+declare const AuthorityLifetime: {
+    readonly IDLE_SEAT_S: number;
+    readonly IDLE_SEAT_MIN_S: 30;
+    readonly IDLE_SEAT_MAX_S: number;
+    readonly ROOM_AGE_S: number;
+    readonly ROOM_AGE_MIN_S: 60;
+    readonly ROOM_AGE_MAX_S: number;
+};
+/** The resolved limits. */
+interface LifetimePolicy {
+    /** A seat whose input has not changed for this long leaves. */
+    readonly idleSeatS: number;
+    /** A room this old drains and ends. */
+    readonly maxRoomAgeS: number;
+}
+declare const LIFETIME_DEFAULT: LifetimePolicy;
+/** A refused `config.lifetime`: the path of the first bad value. */
+declare class LifetimeConfigError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+/** `config.lifetime` as a module declares it: either limit, whole seconds. */
+interface LifetimeDeclaration {
+    idleSeatS?: number;
+    maxRoomAgeS?: number;
+}
+/** `config.lifetime` resolved: what it gives, the defaults for the rest. Null when it is not declared (the
+ *  host runs {@link LIFETIME_DEFAULT}). Throws a {@link LifetimeConfigError} naming the path of a value
+ *  that is not an object, an unknown key, or a limit that is not a whole number inside its bounds. */
+declare function resolveLifetime(given: unknown, path?: string): LifetimePolicy | null;
+
+/** How a client draws other seats by default (PROTOCOL.md §17.11 *Drawing other seats*): `predicted` on
+ *  your own clock (the Rocket League model), `separate` on the render timeline and moved only out of
+ *  your entity, `timeline` on the render timeline alone. A lag-compensated room (§17.5) judges a shot
+ *  where the shooter's render timeline drew the target, so its seats are drawn there. */
+declare const ContactDrawing: {
+    readonly Predicted: "predicted";
+    readonly Separate: "separate";
+    readonly Timeline: "timeline";
+};
+type ContactDrawing = (typeof ContactDrawing)[keyof typeof ContactDrawing];
+/** How a side contact's push is split (PROTOCOL.md §17.11 *Contact policy* step 4): `shared` half each
+ *  (equal masses: a car shoves a car), `mover` by each seat's own closing speed (a player walking into
+ *  another is stopped by it and never shoves it: a shooter's solid players). */
+declare const ContactPush: {
+    readonly Shared: "shared";
+    readonly Mover: "mover";
+};
+type ContactPush = (typeof ContactPush)[keyof typeof ContactPush];
+/** The genre presets: each a full table of settings (DESIGN's preset table). */
+declare const ContactPreset: {
+    readonly Shooter: "shooter";
+    readonly Platformer: "platformer";
+    readonly VehicleArena: "vehicle-arena";
+    readonly PhysicsSandbox: "physics-sandbox";
+    readonly Party: "party";
+};
+type ContactPreset = (typeof ContactPreset)[keyof typeof ContactPreset];
+/** What happens when one seat comes to rest on another's top. */
+declare const TopPolicy: {
+    /** Rest on the head: a landing stands within `center` of the lower's half width and slides off by
+     *  `slide` elsewhere; a resting seat holds while its centre is over the footprint; `ride`: carried. */
+    readonly Stand: "stand";
+    /** Frictionless: the upper seat is slid off within a bounded time. */
+    readonly Slide: "slide";
+    /** A stomp: the upper seat bounces off, and the module hears it. */
+    readonly Bounce: "bounce";
+    /** No collision at all. */
+    readonly Ghost: "ghost";
+};
+type TopPolicy = (typeof TopPolicy)[keyof typeof TopPolicy];
+/** A seat's contact shape. */
+declare const ContactShapeKind: {
+    /** A box turned with the seat's heading and laid on its support up (a vehicle). */
+    readonly Box: "box";
+    /** An upright axis-aligned square footprint (a `firstperson` character). */
+    readonly Hull: "hull";
+};
+type ContactShapeKind = (typeof ContactShapeKind)[keyof typeof ContactShapeKind];
+/** A seat's contact shape, room units: a box's length along the heading, width across it and top
+ *  above the base; a hull's half side and height. */
+type ContactShape = {
+    readonly kind: typeof ContactShapeKind.Box;
+    readonly length: number;
+    readonly width: number;
+    readonly top: number;
+} | {
+    readonly kind: typeof ContactShapeKind.Hull;
+    readonly radius: number;
+    readonly height: number;
+};
+/** A slide: the parting brought up to `speed` (units/s) by at most `step` a tick, `share` of it on the
+ *  upper seat (the rest on the lower). `step` null: in one tick. */
+interface SlideRule {
+    readonly speed: number;
+    readonly step: number | null;
+    readonly share: number;
+}
+/** A resolved stand (§17.11 step 6 `stand`): carried by the lower seat when `ride`; a landing stands
+ *  only within `center` × the lower's half width (null: anywhere it touches), else slides by `slide`. */
+interface StandRule {
+    readonly policy: typeof TopPolicy.Stand;
+    readonly ride: boolean;
+    readonly center: number | null;
+    readonly slide: SlideRule;
+}
+/** A resolved top rule. A bounce under `stompMin` closing speed slides by its `slide`. */
+type TopRule = StandRule | ({
+    readonly policy: typeof TopPolicy.Slide;
+} & SlideRule) | {
+    readonly policy: typeof TopPolicy.Bounce;
+    readonly stompMin: number;
+    readonly bounceSpeed: number;
+    readonly jumpBoost: number;
+    readonly slide: SlideRule;
+} | {
+    readonly policy: typeof TopPolicy.Ghost;
+};
+/** A per-pair override: two seats, one carrying tag `a` and the other `b`, use `top`. */
+interface PairRule {
+    readonly a: string;
+    readonly b: string;
+    readonly top: TopRule;
+}
+/** The resolved policy: every setting filled (from the module, else its preset's table). */
+interface ContactPolicy {
+    readonly preset: ContactPreset;
+    readonly shape: ContactShape;
+    /** The hull the static world is grown by (the movement preset's radius and height) and its skin. */
+    readonly hull: {
+        readonly radius: number;
+        readonly height: number;
+        readonly skin: number;
+    };
+    /** How far under a base the support surface is found (the preset's `groundTrace`). */
+    readonly groundTrace: number;
+    /** A contact whose normal is at least this close to the lower seat's support up is a top contact;
+     *  a lower seat whose support up's z is under it cannot be stood on. */
+    readonly supportCos: number;
+    /** The least closing speed of an axis in the entry-time test (units/s). */
+    readonly entrySpeed: number;
+    /** How recently a pair must have come down across the plane for the across axis to be its contact
+     *  axis (seconds): an older overlap was there before the last pass. */
+    readonly entryWindow: number;
+    /** The share of the closing speed a side contact keeps. */
+    readonly restitution: number;
+    /** Pile passes a tick at most, and the depth a pair may stay inside another after the first. */
+    readonly passes: number;
+    readonly slop: number;
+    /** How far over a lower seat's top the upper seat is set (units). */
+    readonly roofSkin: number;
+    /** Each velocity axis a contact writes is clamped to ±this; null: not clamped. */
+    readonly maxVelocity: number | null;
+    /** A side contact stops both seats' `spin` (a vehicle's yaw rate). */
+    readonly stopSpin: boolean;
+    readonly top: TopRule;
+    /** The slide a top contact becomes when the lower seat's support cannot be stood on. */
+    readonly offWall: SlideRule;
+    readonly pairs: readonly PairRule[];
+    /** How a client draws other seats when the game gives no `seatDrawing`. */
+    readonly drawing: ContactDrawing;
+    /** How a side contact's push is split between the two seats (§17.11 step 4). */
+    readonly push: ContactPush;
+    /** How a dynamic module body resting on a seat's top is treated (§17.11 *Contact policy*, props). */
+    readonly headFriction: HeadFriction;
+    /** The nudge that slides a prop off a head under `headFriction: slide`: up to `speed` by `step` a tick. */
+    readonly propSlide: PropSlide;
+}
+/** How a prop on a seat's top is treated: `slide` off (its hull frictionless, nudged by `propSlide`),
+ *  or `carry` (friction holds it while level; it slides past its friction angle). */
+declare const HeadFriction: {
+    readonly Slide: "slide";
+    readonly Carry: "carry";
+};
+type HeadFriction = (typeof HeadFriction)[keyof typeof HeadFriction];
+/** A prop's slide off a head: its parting brought up to `speed` (u/s) by at most `step` a tick. */
+interface PropSlide {
+    readonly speed: number;
+    readonly step: number;
+}
+/** A refused `config.contacts`: the path of the first bad value and why. */
+declare class ContactConfigError extends RangeError {
+    readonly path: string;
+    constructor(path: string, why: string);
+}
+/** Per-pair overrides a module may declare at most, and a tag's length at most. */
+declare const CONTACT_PAIRS_MAX = 32;
+declare const CONTACT_TAG_MAX = 64;
+/** Pile passes a module may ask for at most. */
+declare const CONTACT_PASSES_MAX = 64;
+/** Every length and speed a module may give at most (units, units/s). */
+declare const CONTACT_VALUE_MAX = 100000;
+/** The share of a head's half width a shooter's landing stands within (owner: "stand on it with some
+ *  slide off"; 0.25 from the Lift Yard's aimed landings, owner 2026-11-02: a landing with over 3/8 of
+ *  the foot off the head slides). */
+declare const SHOOTER_CENTER = 0.25;
+/** One preset's table: the top rule by seat shape, the side restitution and the passes. */
+interface PresetTable {
+    readonly character: TopRule;
+    readonly vehicle: TopRule;
+    readonly restitution: number;
+    readonly passes: number;
+    readonly vehicleOffWall: SlideRule;
+    readonly stopSpin: boolean;
+    readonly drawing: ContactDrawing;
+    readonly push: ContactPush;
+    readonly headFriction: HeadFriction;
+}
+/** The genre presets' tables (PROTOCOL.md §17.11 *Contact policy*, the preset table). */
+declare const CONTACT_PRESETS: {
+    readonly [P in ContactPreset]: PresetTable;
+};
+/** The settings every preset shares (the preset table's SUPPORT_COS and PILE_SLOP rows). */
+declare const CONTACT_DEFAULTS: Readonly<{
+    supportCos: 0.7;
+    entrySpeed: 1;
+    entryWindow: number;
+    slop: 0.1;
+    roofSkin: 0.01;
+}>;
+/** A slide or top rule as a module declares it: every key but `policy` optional (the preset fills it). */
+type Declared<T> = {
+    readonly [K in keyof T]?: T[K];
+};
+/** `config.contacts` as a module declares it (PROTOCOL.md §17.11 *Contact policy*): the preset, and any
+ *  cell of its table overridden. Resolved by {@link resolveContactConfig}. */
+interface ContactDeclaration {
+    readonly preset: ContactPreset;
+    readonly shape?: ContactShape;
+    readonly top?: {
+        readonly policy: typeof TopPolicy.Stand;
+        readonly ride?: boolean;
+        readonly center?: number | null;
+        readonly slide?: Declared<SlideRule>;
+    } | {
+        readonly policy: typeof TopPolicy.Ghost;
+    } | ({
+        readonly policy: typeof TopPolicy.Slide;
+    } & Declared<SlideRule>) | {
+        readonly policy: typeof TopPolicy.Bounce;
+        readonly stompMin?: number;
+        readonly bounceSpeed?: number;
+        readonly jumpBoost?: number;
+    };
+    readonly offWall?: Declared<SlideRule>;
+    readonly restitution?: number;
+    readonly passes?: number;
+    readonly slop?: number;
+    readonly supportCos?: number;
+    readonly entrySpeed?: number;
+    readonly entryWindow?: number;
+    readonly roofSkin?: number;
+    readonly maxVelocity?: number | null;
+    readonly stopSpin?: boolean;
+    readonly pairs?: readonly {
+        readonly a: string;
+        readonly b: string;
+        readonly top: NonNullable<ContactDeclaration['top']>;
+    }[];
+    readonly drawing?: ContactDrawing;
+    readonly push?: ContactPush;
+    readonly headFriction?: HeadFriction;
+    readonly propSlide?: Declared<PropSlide>;
+}
+/** The movement preset the seats step with, as the contact policy reads it: its hull and ground. */
+interface ContactPresetParams {
+    readonly name: string;
+    readonly params: Readonly<Record<string, number>>;
+}
+/**
+ * `config.contacts` resolved against the room's movement preset (§17.11 *Contact policy*): every setting
+ * the module gave, else the genre preset's. Throws {@link ContactConfigError} (the path from `path`,
+ * default `$.config.contacts`) for a value that is not an object, an unknown key, a preset or policy
+ * that does not exist, a number out of range, a shape without its dimensions, more than
+ * CONTACT_PAIRS_MAX pair rules, or a room whose movement preset steps through no world.
+ */
+declare function resolveContactConfig(given: unknown, preset: ContactPresetParams | null, path?: string): ContactPolicy;
+
+/** Whether a predicting room repeats a starved seat's held input (§17.11 *Input pacing*): `on`, the
+ *  seat is stepped under its last input and its client reconciles at `ack + inRep` and throttles; `off`,
+ *  the seat holds on a starved tick, its client reads the plain ack and never throttles. */
+declare const InputRepeat: {
+    readonly On: "on";
+    readonly Off: "off";
+};
+type InputRepeat = (typeof InputRepeat)[keyof typeof InputRepeat];
+/** The resolved input settings a room runs with. `settleMs` is there only when set, so a room without it
+ *  publishes the text it always did. */
+interface InputPolicy {
+    readonly repeat: InputRepeat;
+    /** §17.11 *A quiet seat*: after this long with no input the room steps a seat's body under a stick at
+     *  rest until it lies still. Absent: the body holds where its last input left it. */
+    readonly settleMs?: number;
+}
+/** The range of `config.inputs.settleMs`, ms: above any hitch a game should sit through, below a long AFK. */
+declare const INPUT_SETTLE_MS: {
+    readonly MIN: 100;
+    readonly MAX: 60000;
+};
+/**
+ * Each genre preset's input settings. Measured on the bench (interleaved runs, one-sided Mann–Whitney,
+ * evidence folder input-repeat/ and R2): `vehicle-arena` is off, because on car-ball 3v3 at a clean
+ * 200 ms round trip the repeats and the throttle cost other players' cars (remote corrP95 and errAtLead
+ * worse, p ≤ .013) while a client that never asks for them stays within the base; `shooter` is on,
+ * because Mechanism Hall and Blast Yard under loss draw your own character with fewer pops and hitches
+ * and stack and rocket better with it. `platformer`, `party` and `physics-sandbox` seat characters as a
+ * shooter does and have no measurement of their own, so they are on as measured for characters.
+ */
+declare const INPUT_PRESETS: {
+    readonly shooter: {
+        readonly repeat: "on";
+    };
+    readonly platformer: {
+        readonly repeat: "on";
+    };
+    readonly "vehicle-arena": {
+        readonly repeat: "off";
+    };
+    readonly "physics-sandbox": {
+        readonly repeat: "on";
+    };
+    readonly party: {
+        readonly repeat: "on";
+    };
+};
+/** A room that names no genre and no setting repeats, as every predicting room did before the setting. */
+declare const INPUTS_DEFAULT: InputPolicy;
+/** A refused `config.inputs`: the path of the first bad value. */
+declare class InputConfigError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+/** `config.inputs` as a module declares it: a genre preset (default the contact policy's), and a
+ *  setting that overrides the preset's. */
+interface InputDeclaration {
+    preset?: ContactPreset;
+    repeat?: InputRepeat;
+    settleMs?: number;
+}
+/**
+ * `config.inputs` resolved (§17.11 *Input pacing*): `repeat` as given, else the table of the genre preset
+ * (`inputs.preset`, else `contactsPreset`, the room's declared contact policy's), else on. Null when the
+ * module declares neither inputs nor a contact policy (a room without the setting: on). Throws an
+ * {@link InputConfigError} naming the path (default `$.config.inputs`) of a value that is not an
+ * object, an unknown key, a preset that is not a genre preset or a setting that is not `on` or `off`.
+ */
+declare function resolveInputConfig(given: unknown, contactsPreset: ContactPreset | null, path?: string): InputPolicy | null;
+/**
+ * The room's input repeat setting as a client reads it from the state's `preset` text (JSON, its
+ * `inputs` key): `off` only when the text says so outright, `on` for anything else. Absent is a room
+ * without the setting or an older host, which repeats; for a hostile value the room's own fields are the
+ * truth, and a room that is off writes none of them.
+ */
+declare function presetInputRepeat(presetText: string): InputRepeat;
+
+/** A lift's shape, room units, about its centre. */
+declare const LiftShapeKind: {
+    /** A box `half` (x, y, z): axis-aligned, or turned about z when it spins (a sweeper bar). */
+    readonly Box: "box";
+    /** An upright disc of `radius`, `half` its half height (a turntable, a spinner). */
+    readonly Disc: "disc";
+};
+type LiftShapeKind = (typeof LiftShapeKind)[keyof typeof LiftShapeKind];
+/** How a path runs its points. */
+declare const LiftPathMode: {
+    /** Out along the legs, then back along them. */
+    readonly PingPong: "pingpong";
+    /** Round the points and from the last back to the first. */
+    readonly Loop: "loop";
+};
+type LiftPathMode = (typeof LiftPathMode)[keyof typeof LiftPathMode];
+/** How a leg moves between its points. */
+declare const LiftEase: {
+    /** At a steady speed. */
+    readonly Linear: "linear";
+    /** Starting and stopping at rest (`s·s·(3 − 2s)`; its peak speed 1.5 times the mean). */
+    readonly Smooth: "smooth";
+};
+type LiftEase = (typeof LiftEase)[keyof typeof LiftEase];
+/** What a rider keeps of its lift's motion when it leaves it. */
+declare const LiftImpart: {
+    /** The lift's velocity at the rider's point (Unreal's and Godot's default). */
+    readonly All: "all";
+    /** Nothing: the rider leaves with its own velocity. */
+    readonly None: "none";
+};
+type LiftImpart = (typeof LiftImpart)[keyof typeof LiftImpart];
+/** A point or size in room units. */
+type LiftVec = readonly [number, number, number];
+/** A lift's shape. */
+type LiftShape = {
+    readonly kind: typeof LiftShapeKind.Box;
+    readonly half: LiftVec;
+} | {
+    readonly kind: typeof LiftShapeKind.Disc;
+    readonly radius: number;
+    readonly half: number;
+};
+/** A resolved path: `points` (float32), a leg's ticks and a wait's ticks per point. */
+interface LiftPath {
+    readonly points: readonly LiftVec[];
+    readonly legs: readonly number[];
+    readonly waits: readonly number[];
+    readonly mode: LiftPathMode;
+    readonly ease: LiftEase;
+    readonly phase: number;
+    /** The ticks of one whole cycle. */
+    readonly period: number;
+}
+/** A resolved spin: a turn every `period` ticks, `dir` 1 (counter-clockwise from above) or −1. */
+interface LiftSpin {
+    readonly period: number;
+    readonly dir: 1 | -1;
+    readonly phase: number;
+}
+/** One resolved platform. */
+interface Lift {
+    readonly id: string;
+    readonly shape: LiftShape;
+    /** The centre when it has no path (else the path's first point). */
+    readonly at: LiftVec;
+    readonly path: LiftPath | null;
+    readonly spin: LiftSpin | null;
+    /** A conveyor's surface velocity in its own frame (u/s), or null. */
+    readonly surface: readonly [number, number] | null;
+    readonly impart: LiftImpart;
+    /** Still until the module calls it; a call runs one cycle of its path. */
+    readonly called: boolean;
+}
+/** The resolved `config.lifts`. */
+interface LiftsPolicy {
+    readonly platforms: readonly Lift[];
+    /** Whether seats ride level dynamic module bodies too. */
+    readonly bodies: boolean;
+}
+/** No lifts: what the slots run over in a room whose only carry is by seats (a stand rule that rides). */
+declare const NO_LIFTS: LiftsPolicy;
+/** A platform refused for moving too fast: its id, its fastest point's move a tick, the most allowed
+ *  (the hull radius) and the tick rate, all units a tick. */
+interface LiftTooFast {
+    readonly platform: string;
+    readonly move: number;
+    readonly allowed: number;
+    readonly tickHz: number;
+}
+/** A refused `config.lifts`: the path of the first bad value and why (`fast`: a platform too fast). */
+declare class LiftsConfigError extends RangeError {
+    readonly path: string;
+    readonly fast: LiftTooFast | undefined;
+    constructor(path: string, why: string, fast?: LiftTooFast);
+}
+/** Platforms a module may declare at most, points a path may hold, and a lift id's length. */
+declare const LIFTS_MAX = 32;
+declare const LIFT_POINTS_MAX = 16;
+declare const LIFT_ID_MAX = 32;
+/** Every position, size and speed's magnitude at most (units, units/s). */
+declare const LIFT_VALUE_MAX = 1000000;
+/** Every tick count (a leg, a wait, a phase, a spin's period) at most: about 4.6 days at 120 Hz. */
+declare const LIFT_TICKS_MAX: number;
+/** A spin's fewest ticks a turn. */
+declare const LIFT_SPIN_MIN_PERIOD = 8;
+/** Whether `id` is a lift id: 1 to LIFT_ID_MAX of a-z, 0-9 and -. */
+declare const isLiftId: (id: unknown) => id is string;
+/**
+ * `config.lifts` resolved against the room's movement preset and tick rate (§17.11 *Lifts*). Throws
+ * {@link LiftsConfigError} (the path from `path`, default `$.config.lifts`) for a value that is not an
+ * object, an unknown key, an empty list or more than LIFTS_MAX platforms, an id that is not 1-32 of
+ * `[a-z0-9-]` or repeats, a shape without its sizes, a path whose points, legs and waits do not match, a
+ * tick count that is not a whole number, a phase on a called lift, a value out of range, a platform any
+ * point of which moves more than the hull radius a tick (named, with its speed and the most allowed),
+ * or a room whose movement preset steps through no world.
+ */
+declare function resolveLifts(given: unknown, preset: ContactPresetParams | null, tickHz: number, path?: string): LiftsPolicy;
+
+declare const MODULE_CONTRACT = 1;
+/** A JSON value: what crosses the sandbox boundary in events, logs and entity `data`. */
+type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+/** A point or a direction in world units. */
+interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Fixed simulation rates a module may choose. */
+/** A room's tick rate. 120 is a physics room's only (PROTOCOL.md §17.11, car-ball rooms). */
+type TickHz = 20 | 30 | 60 | 120;
+/** Why a player left (`onLeave`). */
+declare const LeaveReason: {
+    /** The client left on purpose. */
+    readonly LEFT: "left";
+    /** The connection dropped and the reconnection grace ran out. */
+    readonly DROPPED: "dropped";
+    /** A newer session of the same player took the seat. */
+    readonly SUPERSEDED: "superseded";
+    /** The player's session was revoked. */
+    readonly REVOKED: "revoked";
+    /** The room is closing (drain, halt or fault). */
+    readonly CLOSING: "closing";
+    /** The seat's input had not changed for the room's `config.lifetime.idleSeatS`. */
+    readonly IDLE: "idle";
+};
+type LeaveReason = (typeof LeaveReason)[keyof typeof LeaveReason];
+/** A seated player, as the server verified them. */
+interface PlayerInfo {
+    /** The seat's session id: the key of `AuthorityRoomState.players` and an entity's `owner`. */
+    id: string;
+    /** The stable per-game player id (PROTOCOL.md §3.3). Key saves and scores by it. */
+    uid: string;
+    name: string;
+    /** '' = no team. */
+    team: string;
+}
+/** One frame of a player's input (`AuthorityInput`), already sanitized by the server: move axes in
+ *  [-1, 1], yaw and pitch wrapped to [-π, π), `buttons` an integer bitmask below 2^24. */
+interface InputData {
+    moveX: number;
+    moveY: number;
+    moveZ: number;
+    yaw: number;
+    pitch: number;
+    buttons: number;
+}
+/** An entity as the module reads it. Positions and velocities are float32 on the wire. */
+interface EntityData {
+    readonly id: string;
+    kind: string;
+    /** Owning seat's session id, or ''. */
+    owner: string;
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    /** Heading in radians. */
+    yaw: number;
+    hp: number;
+    /** Game-defined bitmask below 2^24. */
+    flags: number;
+    /** Bump it to make clients snap instead of interpolate (a teleport or a respawn). */
+    epoch: number;
+    /** Free-form JSON, at most 256 characters once encoded. */
+    data: Json;
+    /** A projectile's launch tick (§17.9); 0 = not a projectile. Written by `ctx.projectiles.launch`. */
+    t0: number;
+    /** A projectile's downward acceleration along −z, units/s², in [0, 1000]. */
+    g: number;
+    /** The seat that fired a projectile, '' = none (a server projectile). */
+    src: string;
+    /** A `firstperson` body's aim pitch, radians (§17.7): the preset writes it from the input. */
+    pitch: number;
+    /** A `firstperson` body's duck amount, 0 standing to 1 fully ducked: the preset writes it. */
+    duck: number;
+    /** A `firstperson` or `vehicle` body's movement bits (1 onGround, 2 ducking, 4 jumpHeld; a
+     *  vehicle keeps 1 and 4): the preset writes them; write 0 on a respawn to start a life in the air
+     *  with jump released. */
+    mstate: number;
+    /** A `firstperson` body's speed multiplier, or a `vehicle`'s multiplier of both top speeds,
+     *  [0, 4], default 1: yours to write (a weapon's or a wound's speed); the preset only reads it. */
+    cap: number;
+    /** A `vehicle` body's yaw rate, rad/s, positive toward +yaw (§17.7): the preset writes it; write 0
+     *  on a respawn. */
+    spin: number;
+    /** A `vehicle` body's boost fuel, [0, 1], default 0: write it to refuel (a boost pad, a respawn);
+     *  the preset only burns it. */
+    fuel: number;
+}
+/** The fields only `projectiles.launch` writes. */
+type ProjectileField = 't0' | 'g' | 'src';
+/** What `entities.spawn` takes: a kind, and any field to start from other than the default (a
+ *  projectile's fields come from `projectiles.launch`). */
+type EntityInit = {
+    kind: string;
+    id?: string;
+} & Partial<Omit<EntityData, 'id' | 'kind' | ProjectileField>>;
+/** The room's entities. Every write is recorded and only changed entities go out each tick. */
+interface EntityApi {
+    /** Adds an entity and returns its id (`id` when given and free, else a fresh one). */
+    spawn(entity: EntityInit): string;
+    get(id: string): EntityData | undefined;
+    update(id: string, patch: Partial<Omit<EntityData, 'id' | ProjectileField>>): void;
+    remove(id: string): void;
+    /** The first entity this seat owns. */
+    ownedBy(playerId: string): EntityData | undefined;
+    all(): readonly EntityData[];
+}
+/** An entity as the shooter saw it (`RewindApi.pose`): where it stood, which way it faced (radians)
+ *  and how far it ducked (0 standing to 1 fully ducked; 0 for an entity that never ducks). */
+interface RewoundPose extends Vec3 {
+    yaw: number;
+    duck: number;
+}
+/** Lag compensation. Both calls read the snapshot of positions the current input's sender saw when
+ *  they pressed it (only while handling an input whose buttons match `config.lagComp.buttons`;
+ *  otherwise the current positions). */
+interface RewindApi {
+    hitscan(origin: Vec3, dir: Vec3, options?: {
+        range?: number;
+        radius?: number;
+        kinds?: string[];
+    }): {
+        id: string;
+        dist: number;
+    } | null;
+    overlapAt(center: Vec3, radius: number): string[];
+    /** Where the shooter of the lag-compensated input being handled saw entity `id` (the position
+     *  `hitscan` and `overlapAt` judge it at), its live position otherwise; null for an unknown id, a
+     *  projectile or a physics body entity. For a module's own tests against things that are not
+     *  spheres (a door, a shutter): §17.5. */
+    at(id: string): Vec3 | null;
+    /** `at` with the entity's `yaw` and `duck` at that same instant, live where `at` is live and null
+     *  where `at` is null. For hit zones that depend on stance: a head lower on a ducking target. §17.5. */
+    pose(id: string): RewoundPose | null;
+}
+/** Where a ray entered the room's world (`WorldApi.ray`). */
+interface WorldRayHit {
+    /** World units along the ray from its origin; 0 when it started inside or on the way in. */
+    dist: number;
+    point: Vec3;
+    /** The face it entered by, a unit vector against the ray; all zeros when it started `inside`. */
+    normal: Vec3;
+    /** The ray started inside the solid. */
+    inside: boolean;
+    /** Which solid, counting the module's `boxes` and then its `ramps`. */
+    solid: number;
+}
+/** A world only rays read: `FirstpersonWorldSpec` plus how far off its surfaces may be, as its fit stated. */
+interface ShotWorldSpec extends FirstpersonWorldSpec {
+    /** Units a claimed stop may differ from this world: `ctx.world.claim`'s default. Default 0. */
+    tolerance?: number;
+}
+/** The room's collision world, for the module's own questions (§17.7 *Rays*). Static: it needs no
+ *  rewinding, and it holds what bodies collide with, not what is drawn. */
+interface WorldApi {
+    /** The first solid along the ray within `range` (default: no limit), or null: also null for a ray
+     *  that is none (zero length, or a value that is not a finite number). Touching a face is no hit.
+     *  Takes a hitscan's options as they are. Server only: no client SDK has it. */
+    ray(origin: Vec3, dir: Vec3, options?: WorldRayOptions): WorldRayHit | null;
+    /** A shooter's claimed stop, from its own render mesh, held to the shot world (§17.7 *A claimed stop*): the distance
+     *  the shot flies, and why. Null for a ray that is none. Any `claimed` that is not a number means the shot flew on. A room with
+     *  no shot world throws naming `no_shot_world`. */
+    claim(origin: Vec3, dir: Vec3, claimed: unknown, options?: WorldClaimOptions): WorldClaim | null;
+}
+/** What `WorldApi.ray` takes. */
+interface WorldRayOptions {
+    range?: number;
+    /** `'shot'`: the module's `shotWorld`. A room that has none throws naming `no_shot_world`, and is never answered from its `world`. */
+    world?: WorldKey;
+}
+/** What `WorldApi.claim` takes: a weapon's rules. */
+interface WorldClaimOptions {
+    range?: number;
+    /** How far off a surface a claim may be, either way: the cheat margin. Along a ray that grazes the surface it reads further. Default:
+     *  the shot world's own `tolerance`. */
+    tolerance?: number;
+    /** One wall this weapon goes through, in units along the ray. Default none. */
+    pierce?: number;
+    /** The weapon's last word: a distance replaces `dist`. Called with the verdict as it stands, each claim. */
+    rule?: (claim: WorldClaim) => number | undefined;
+}
+/** What `WorldApi.claim` decided. */
+interface WorldClaim {
+    /** How far the shot flies: judge targets inside this. The range, or Infinity without one, when nothing stops it. */
+    dist: number;
+    verdict: ClaimVerdict;
+    /** What was claimed, as read: Infinity for the shot flying on. */
+    claimed: number;
+    /** Where the shot world stops the ray, or null if nothing does in range. */
+    server: number | null;
+    tolerance: number;
+    /** How far either way of the world's stop this claim could stand, along this ray: the tolerance, grown by how much the ray grazes. */
+    slack: number;
+    /** The wall a piercing claim went through, or null. */
+    through: number | null;
+    /** Which solid and which face of the shot world stopped the ray, or null. */
+    solid: number | null;
+    normal: Vec3 | null;
+    /** Where the shot stops, or null when it flies on for ever. */
+    point: Vec3 | null;
+}
+/** What `projectiles.launch` takes: where and how fast the projectile starts. `g` (default 0) pulls
+ *  it down along −z; `id` is required outside a seat's input and refused inside one, where the id is
+ *  `<seat>.<seq>.<n>` (the input's client sequence, and the launches during it from 0). */
+interface ProjectileInit {
+    kind: string;
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    g?: number;
+    hp?: number;
+    flags?: number;
+    data?: Json;
+    id?: string;
+}
+/** Where a projectile is at one tick (its flight, §17.9). */
+interface ProjectileFlight {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+}
+/** One entity a projectile's path crossed this tick, and how far along the path from its point at
+ *  the previous tick (world units). */
+interface ProjectileHit {
+    id: string;
+    dist: number;
+}
+/** Projectiles (§17.9): entities on a closed-form ballistic flight that every client draws from its
+ *  launch. They take no part in lag compensation, and the server never ages one out. */
+interface ProjectileApi {
+    /** Launches (or, for an id that exists, re-launches) a projectile at the tick being stepped, with
+     *  `owner` '' and `src` the seat whose input is being handled ('' elsewhere). Returns its id.
+     *  Throws a RangeError, writing nothing, when the launches not yet sent would pass
+     *  `AuthorityLimits.MAX_LAUNCH_UPDATES` entities or `MAX_LAUNCH_BYTES` of output (about a hundred
+     *  a tick): catch it to cap a burst, or it is a strike. */
+    launch(projectile: ProjectileInit): string;
+    /** The projectile's flight at `tick` (default: the tick being stepped); undefined for an id that is
+     *  not a projectile. */
+    at(id: string, tick?: number): ProjectileFlight | undefined;
+    /** The entities of `kinds` whose sphere of `radius` the projectile's path crosses between the
+     *  previous tick and this one, nearest first. Only those kinds are visited, so a call costs the
+     *  number of their entities. */
+    sweep(id: string, options: {
+        kinds: string[];
+        radius: number;
+    }): ProjectileHit[];
+}
+/** Preset movement a module can hand to the server (`config.preset`). */
+interface PresetSpec {
+    name: PresetName;
+    params?: Record<string, number>;
+}
+/** A rotation as a unit quaternion. */
+interface Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+/** A position and a rotation. */
+interface PhysicsPose {
+    p: Vec3;
+    q: Quat;
+}
+/** The contract's limits of one world (C§11). `worldExtent` and `maxSpeed` are in the room's units
+ *  (they scale with `lengthUnit`); the rest are counts, bytes or rad/s. */
+interface PhysicsLimits {
+    bodies: number;
+    collidersPerBody: number;
+    hullVertices: number;
+    triangles: number;
+    joints: number;
+    ccdBodies: number;
+    queriesPerStep: number;
+    eventsPerStep: number;
+    heightfieldSamples: number;
+    staticPieces: number;
+    memoryBytes: number;
+    worldExtent: number;
+    maxSpeed: number;
+    maxAngularSpeed: number;
+}
+/** What a module may ask for in `config.physics` (`true` is the same as `{}`). Any other key, or a
+ *  value outside its range, is a bad config. */
+interface PhysicsRequest {
+    /** Room units per metre, (0, 1e6]. Default 39.37 with `firstperson`, 100 with `vehicle`, else 1. */
+    lengthUnit?: number;
+    /** Units/s² along −z, [0, 1e7]. Default the preset's `gravity` with `firstperson` or `vehicle`,
+     *  else 9.81 · lengthUnit. */
+    gravity?: number;
+    /** The solver hint, an integer in [1, 16]. Default 4. */
+    iterations?: number;
+    /** Lower any limit; one above the room's ceiling (the contract's default in release 1) is clamped. */
+    limits?: Partial<PhysicsLimits>;
+    /** At most 8 distinct physics kinds whose changed bodies the module receives each tick. */
+    subscribe?: string[];
+    /** The preset bodies: `radius` and `height` (each (0, 1e6]) size a `topdown` room's, and are
+     *  refused with any other preset; `events` (default false) opts their colliders into contact
+     *  events. */
+    player?: {
+        radius?: number;
+        height?: number;
+        events?: boolean;
+    };
+    /** Whether clients predict the room's bodies (§17.11). Default true; the operator and each client
+     *  can still turn it off. */
+    predict?: boolean;
+    /** Keyframes (tick-aligned patches) per second in a predicting room, one of 10, 15, 20, 30 and 60.
+     *  Default 20; the room uses the largest of those at or below it that divides its tick rate. */
+    patchHz?: number;
+    /** How a client moves other players' preset bodies between keyframes: by their velocity
+     *  (`extrapolate`, the default), by their last input held (`hold`, the Rocket League model: the room
+     *  preset's step under that input every tick), or by their last input, repeated and decayed
+     *  (`inputDecay`). */
+    remotePredict?: RemotePredict;
+    /** `inputDecay`: ms after which a repeated input's axes have decayed to 0, in [0, 1000]. Default 50. */
+    remoteDecayMs?: number;
+    /** How far a client predicts past a keyframe's ack, ms, in [50, 1000]. Default 250. */
+    leadMs?: number;
+}
+/** `config.physics.remotePredict` (§17.11). */
+declare const RemotePredict: {
+    readonly EXTRAPOLATE: "extrapolate";
+    readonly HOLD: "hold";
+    readonly INPUT_DECAY: "inputDecay";
+};
+type RemotePredict = (typeof RemotePredict)[keyof typeof RemotePredict];
+/** `config.physics` after defaults, as `init` sees it: what the room's world runs with. */
+interface ResolvedPhysics {
+    lengthUnit: number;
+    gravity: number;
+    iterations: number;
+    /** Every limit, clamped to the room's ceiling. */
+    limits: PhysicsLimits;
+    subscribe: string[];
+    player: {
+        radius?: number;
+        height?: number;
+        events: boolean;
+    };
+    /** Whether the module asked for prediction (§17.11); the host may still run the room without it. */
+    predict: boolean;
+    /** The requested keyframe rate (§17.11). */
+    patchHz: number;
+    remotePredict: RemotePredict;
+    remoteDecayMs: number;
+    leadMs: number;
+}
+/** Collision groups: 16-bit masks (C§6.2). */
+interface PhysicsGroups {
+    member: number;
+    collides: number;
+}
+/** A collider shape (C§6.2). */
+type PhysicsShape = {
+    kind: 'box';
+    half: Vec3;
+} | {
+    kind: 'sphere';
+    radius: number;
+} | {
+    kind: 'capsule';
+    halfHeight: number;
+    radius: number;
+    axis: 'x' | 'y' | 'z';
+} | {
+    kind: 'hull';
+    points: Vec3[];
+} | {
+    kind: 'trimesh';
+    vertices: Vec3[];
+    indices: [number, number, number][];
+} | {
+    kind: 'heightfield';
+    rows: number;
+    cols: number;
+    heights: number[];
+    size: Vec3;
+};
+/** One collider of a body (C§6.2). */
+interface PhysicsColliderDesc {
+    key: string;
+    shape: PhysicsShape;
+    offset?: PhysicsPose;
+    density?: number;
+    mass?: number;
+    friction?: number;
+    restitution?: number;
+    groups?: PhysicsGroups;
+    sensor?: boolean;
+    events?: boolean;
+}
+/** A body type (C§6.1). */
+type PhysicsBodyType = 'dynamic' | 'fixed' | 'kinematic';
+/** A body to spawn (C§6.1). `key` is the id of an entity that exists once this tick's entity
+ *  changes apply, and must be a contract key (1-64 of `[A-Za-z0-9_.:-]`, not `static:`…). `kind` is
+ *  the body's own physics kind (1-32 of the same charset, '' or absent = none), not the entity's. */
+interface PhysicsBodyDesc {
+    key: string;
+    type: PhysicsBodyType;
+    pose: PhysicsPose;
+    linvel?: Vec3;
+    angvel?: Vec3;
+    colliders: PhysicsColliderDesc[];
+    linearDamping?: number;
+    angularDamping?: number;
+    gravityScale?: number;
+    lockRotation?: [boolean, boolean, boolean];
+    ccd?: boolean;
+    canSleep?: boolean;
+    kind?: string;
+}
+/** A joint motor's targets (C§6.4). */
+interface PhysicsMotor {
+    targetVel?: number;
+    targetPos?: number;
+    stiffness?: number;
+    damping?: number;
+    maxForce?: number;
+}
+/** A joint (C§6.4). `b: null` attaches to the world. */
+interface PhysicsJointDesc {
+    key: string;
+    a: string;
+    b: string | null;
+    type: 'fixed' | 'hinge' | 'ball' | 'slider' | 'rope';
+    anchorA: Vec3;
+    anchorB: Vec3;
+    axis?: Vec3;
+    limits?: [number, number];
+    motor?: PhysicsMotor;
+    collideConnected?: boolean;
+}
+/** `setPose` options (C§7). */
+interface PhysicsSetPoseOptions {
+    resetVelocity?: boolean;
+    wake?: boolean;
+}
+/** A query filter (C§13). */
+interface PhysicsQueryFilter {
+    groups?: PhysicsGroups;
+    excludeBodies?: string[];
+    includeSensors?: boolean;
+}
+/** The contract's error codes (C§14), as `refused` and a refused query's answer carry them. */
+type PhysicsErrorCode = 'invalid-key' | 'duplicate-key' | 'unknown-key' | 'non-finite' | 'out-of-range' | 'bad-shape' | 'dynamic-mesh' | 'wrong-body-type' | 'bad-command' | 'limit-bodies' | 'limit-colliders' | 'limit-hull-vertices' | 'limit-triangles' | 'limit-joints' | 'limit-ccd' | 'limit-queries' | 'limit-static' | 'limit-memory' | 'bad-snapshot' | 'build-mismatch' | 'contract-mismatch' | 'internal';
+/** A command's number, or `'invalid-key'` when the prelude refused it before it was numbered. The
+ *  module's commands are numbered 0, 1, 2 … across the room's life. */
+type PhysicsCommandResult = number | 'invalid-key';
+/** A ray or shape-cast hit (C§13). */
+interface PhysicsHit {
+    body: string;
+    collider: string;
+    dist: number;
+    point: Vec3;
+    normal: Vec3;
+}
+/** An overlap's bodies: at most 64 keys in key order, `more` when the core found more. */
+interface PhysicsOverlap {
+    keys: string[];
+    more: boolean;
+}
+/** One query's answer on the next tick: a hit or null (ray, shapeCast), an overlap, or the C§14
+ *  code of a refused query (`limit-queries` past the quota). */
+type PhysicsAnswer = PhysicsHit | null | PhysicsOverlap | PhysicsErrorCode;
+/** A contact or trigger event of the last step (C§8.1). A missing physics kind is absent. */
+type PhysicsEvent = {
+    kind: 'contactBegin';
+    a: string;
+    b: string;
+    ca: string;
+    cb: string;
+    ka?: string;
+    kb?: string;
+    impulse: number;
+    point: Vec3;
+    normal: Vec3;
+} | {
+    kind: 'contactEnd';
+    a: string;
+    b: string;
+    ca: string;
+    cb: string;
+    ka?: string;
+    kb?: string;
+} | {
+    kind: 'triggerEnter';
+    sensor: string;
+    sc: string;
+    other: string;
+    oc: string;
+    ks?: string;
+    ko?: string;
+} | {
+    kind: 'triggerExit';
+    sensor: string;
+    sc: string;
+    other: string;
+    oc: string;
+    ks?: string;
+    ko?: string;
+};
+/** A body's replicated state (C§9.2's NetBodyState): position, rotation, linear velocity (room
+ *  units/s), angular velocity (rad/s, world axes). */
+interface PhysicsBodyState {
+    p: Vec3;
+    q: Quat;
+    v: Vec3;
+    w: Vec3;
+    sleeping: boolean;
+}
+/** A command the core refused (or the host or prelude did): its number and its C§14 code. */
+interface PhysicsRefusal {
+    n: number;
+    code: PhysicsErrorCode;
+}
+/** The physics commands (C§7), allowed in every hook and in `init` (they apply before tick 0). Each
+ *  takes effect in this tick's step. Past `AuthorityLimits.MAX_PHYS_COMMANDS` (or `MAX_PHYS_BYTES`)
+ *  waiting to go out, a command throws a RangeError and adds nothing. */
+interface PhysicsCommands {
+    spawn(desc: PhysicsBodyDesc): PhysicsCommandResult;
+    remove(key: string): PhysicsCommandResult;
+    addJoint(desc: PhysicsJointDesc): PhysicsCommandResult;
+    removeJoint(key: string): PhysicsCommandResult;
+    impulse(key: string, j: Vec3, at?: Vec3): PhysicsCommandResult;
+    setVelocity(key: string, linvel?: Vec3, angvel?: Vec3): PhysicsCommandResult;
+    setPose(key: string, pose: PhysicsPose, options?: PhysicsSetPoseOptions): PhysicsCommandResult;
+    setNextKinematicPose(key: string, pose: PhysicsPose): PhysicsCommandResult;
+    areaPush(center: Vec3, radius: number, strength: number, falloff: number, groups?: PhysicsGroups): PhysicsCommandResult;
+    setMotor(jointKey: string, motor: PhysicsMotor): PhysicsCommandResult;
+    wake(key: string): PhysicsCommandResult;
+    sleep(key: string): PhysicsCommandResult;
+}
+/** `ctx.physics` (§17.10) in a physics room: commands, queries answered on the next tick, and what
+ *  the last step did, as this tick's `TickIn` carried it. */
+interface PhysicsApi extends PhysicsCommands {
+    /** Each query returns its index in this tick's queries; read the answer at `answers[index]` on
+     *  the next tick, never this one. Past the world's `queriesPerStep`, it throws a RangeError. */
+    ray(origin: Vec3, dir: Vec3, maxDist: number, filter?: PhysicsQueryFilter): number;
+    shapeCast(shape: PhysicsShape, pose: PhysicsPose, dir: Vec3, maxDist: number, filter?: PhysicsQueryFilter): number;
+    overlap(shape: PhysicsShape, pose: PhysicsPose, filter?: PhysicsQueryFilter): number;
+    /** The answers to the previous tick's queries, in order; empty after an output the host did not
+     *  apply. */
+    readonly answers: readonly PhysicsAnswer[];
+    /** The commands the last step's batch refused. A refusal is never a strike. */
+    readonly refused: readonly PhysicsRefusal[];
+    readonly events: readonly PhysicsEvent[];
+    /** True when the last step dropped events past `eventsPerStep`. */
+    readonly overflowed: boolean;
+    /** The entities whose bodies left the world; the host has removed those entities. */
+    readonly escaped: readonly string[];
+    /** The latest state of a body of a subscribed kind, kept across ticks until it is removed or
+     *  escapes; undefined for any other body, and before the first state arrives. */
+    body(key: string): PhysicsBodyState | undefined;
+}
+/** What a module may ask for in `config`. The server clamps every value to the game's admission. */
+interface ModuleConfig {
+    tickHz?: TickHz;
+    maxPlayers?: number;
+    preset?: PresetSpec;
+    /** Inputs whose `buttons` intersect this mask carry the sender's `seen` snapshot (§17.5). */
+    lagComp?: {
+        buttons: number;
+    };
+    /** Server physics (§17.10): `true`, or a request. Absent, `false` or `null` = none. The room must
+     *  be admitted with physics (a published module's config says so). */
+    physics?: boolean | PhysicsRequest | null;
+    /** The seats' contact policy as data (§17.11 *Contact policy*): every SDK runs the declared pass in
+     *  its prediction and replay. Needs a `firstperson` or `vehicle` preset; a bad one is a bad config. */
+    contacts?: ContactDeclaration | null;
+    /** The seats' input settings as data (§17.11 *Input pacing*): whether a starved seat's held input is
+     *  repeated (`repeat`), else its genre `preset`'s setting, else the contact policy's preset's, else
+     *  on. A bad one is a bad config (input-config.ts `resolveInputConfig` names its path). */
+    inputs?: InputDeclaration | null;
+    /** How long a seat may sit idle and the room may live (§17.6 *Room lifetime*), whole seconds inside
+     *  their bounds; a bad one is a bad config (lifetime-config.ts `resolveLifetime` names its path). */
+    lifetime?: LifetimeDeclaration | null;
+    /** The room's lifts as data (§17.11 *Lifts*): platforms posed by an exact function of the tick,
+     *  which seats collide with and ride. Needs a `firstperson` or `vehicle` preset; a bad one is a bad
+     *  config (lifts-config.ts `resolveLifts` names its path). */
+    lifts?: unknown;
+}
+/** `config` after defaults: what the room actually runs with. */
+interface ResolvedModuleConfig {
+    tickHz: TickHz;
+    maxPlayers: number;
+    preset: PresetSpec | null;
+    lagComp: {
+        buttons: number;
+    } | null;
+    /** The physics the room runs (§17.10), null without. */
+    physics: ResolvedPhysics | null;
+    /** The declared contact policy, resolved by the host (§17.11 *Contact policy*); null or absent
+     *  without one. The host publishes it in the state's `preset` text; a module's own `ctx.config`
+     *  does not carry it. */
+    contacts?: ContactPolicy | null;
+    /** The input settings, resolved by the host (§17.11 *Input pacing*); absent when the module declares
+     *  neither inputs nor a contact policy (the room repeats, as before the setting). The host publishes
+     *  them in the state's `preset` text. */
+    inputs?: InputPolicy | null;
+    /** The declared lifts, resolved by the host (§17.11 *Lifts*); absent without. The host publishes
+     *  them in the state's `preset` text. */
+    lifts?: LiftsPolicy | null;
+    /** The declared limits on a seat's idling and the room's age, resolved by the host (§17.3 *Room
+     *  lifetime*); absent: the defaults. */
+    lifetime?: LifetimePolicy | null;
+}
+/** What `init` gets. */
+interface InitContext {
+    readonly config: ResolvedModuleConfig;
+    /** The room's seed; `random()` is a PRNG seeded from it, so a replay is exact. */
+    readonly seed: number;
+    /** The key its first client asked for (§17.2 *Choosing a room*), to choose a mode by; '' for none.
+     *  A client chose it: treat a key you do not know as the default, never as an error. */
+    readonly matchKey: string;
+    /** What the room this one follows returned from `onDrain` (§17.13 *Drain and rejoin*), or null: a
+     *  room with no predecessor, a predecessor with nothing to hand on, or one in another region. Treat
+     *  it as written by an older version of your module: the module may have changed in the deploy. */
+    readonly handoff: Json | null;
+    random(): number;
+    readonly entities: EntityApi;
+    /** The room's collision world, from where it stands before tick 0 (§17.7 *Rays*). */
+    readonly world: WorldApi;
+    /** Projectiles. `launch` throws here: a launch's `t0` is the tick being stepped, and `init` runs
+     *  before the first tick. Launch from `step` or a hook instead. */
+    readonly projectiles: ProjectileApi;
+    /** Physics commands (§17.10), applied before tick 0. Queries throw in `init`. */
+    readonly physics: PhysicsCommands;
+    /** Rate-limited server log line. */
+    log(...args: Json[]): void;
+}
+/** What every hook after `init` gets. */
+interface RoomContext<S> {
+    /** The module's own state, as `init` returned it. Never sent to clients. */
+    state: S;
+    /** Fixed-step tick number, from 0. */
+    readonly tick: number;
+    /** Seconds per tick (1 / tickHz). */
+    readonly dt: number;
+    random(): number;
+    readonly entities: EntityApi;
+    readonly rewind: RewindApi;
+    /** The room's collision world (§17.7 *Rays*). */
+    readonly world: WorldApi;
+    readonly projectiles: ProjectileApi;
+    /** Server physics (§17.10) in a room whose config asks for it. */
+    readonly physics: PhysicsApi;
+    /** The room's declared lifts (§17.11 *Lifts*). */
+    readonly lifts: LiftsApi;
+    /** Sends a game event to every client, or only to the seat `to`. */
+    emit(type: string, data?: Json, to?: string): void;
+    log(...args: Json[]): void;
+}
+/** What a module reads of its declared lifts this tick (§17.11 *Lifts*). */
+interface LiftsApi {
+    /** The seats a lift pushed against the world this tick, each with the lift (damage is the module's). */
+    crushed(): {
+        seat: string;
+        lift: string;
+    }[];
+}
+/** A game's room module. No Date, timers, fetch, require or shared memory exist inside it. */
+interface GenexRoomModule<S = unknown> {
+    contract: typeof MODULE_CONTRACT;
+    config?: ModuleConfig;
+    /** The `firstperson` and `vehicle` presets' collision world (§17.7): boxes then ramps, fixed for the room's
+     *  life. The sandbox validates it at init and writes its hash into the resolved preset's
+     *  `params.world`; the game client hands its SDK the same world (`session.setWorld`). Absent =
+     *  the empty world (no floor: add one box for open ground). */
+    world?: FirstpersonWorldSpec;
+    /** Several worlds, by match key (§17.2 *Choosing a room*): a room whose key the map names runs that
+     *  world, any other room `world`. At most 16, each name a match key, and one room compiles only its
+     *  own; `authority validate` loads them all. A module with this map leaves `params.world` unset. */
+    worlds?: Readonly<Record<string, FirstpersonWorldSpec>>;
+    /** What bullets meet where it differs from what bodies do (§17.7 *The shot world*): only `ctx.world`'s rays read it. Its own
+     *  tree, no hash, no client knows it, and it counts against the module's bytes and a load's cost. */
+    shotWorld?: ShotWorldSpec;
+    /** Several, by match key, as `worlds`: any other room `shotWorld`. */
+    shotWorlds?: Readonly<Record<string, ShotWorldSpec>>;
+    init(ctx: InitContext): S;
+    onJoin(ctx: RoomContext<S>, player: PlayerInfo): void;
+    onLeave(ctx: RoomContext<S>, player: PlayerInfo, reason: LeaveReason): void;
+    /** One call per input, in each player's sequence order, before `step`. */
+    onInput(ctx: RoomContext<S>, playerId: string, input: InputData): void;
+    /** Once per tick, after the tick's inputs. */
+    step(ctx: RoomContext<S>): void;
+    /** Optional. The server is about to close this room for a deploy (§17.13 *Drain and rejoin*): what to
+     *  hand the room that follows it, at most 256 KiB of JSON, which it reads as `ctx.handoff` in `init`.
+     *  Called once, right before the close, under `init`'s time limit. Its seats come back by themselves,
+     *  with new session ids: key what you keep by uid. Without this hook, or when it throws or returns
+     *  nothing, the successor starts clean. */
+    onDrain?(ctx: RoomContext<S>): Json | undefined;
+}
+/** Identity helper that types a room module: `export default defineRoom({ ... })`. */
+declare const defineRoom: <S>(module: GenexRoomModule<S>) => GenexRoomModule<S>;
+
+export { LiftEase as $, AuthorityLifetime as A, INPUT_SETTLE_MS as B, type ContactPolicy as C, type InitContext as D, type EntityData as E, InputConfigError as F, type GenexRoomModule as G, HeadFriction as H, type InputData as I, type Json as J, type InputDeclaration as K, LeaveReason as L, type InputPolicy as M, LIFETIME_DEFAULT as N, LIFTS_MAX as O, type PlayerInfo as P, LIFT_ID_MAX as Q, type ResolvedModuleConfig as R, type StandRule as S, type TickHz as T, LIFT_POINTS_MAX as U, LIFT_SPIN_MIN_PERIOD as V, LIFT_TICKS_MAX as W, LIFT_VALUE_MAX as X, LifetimeConfigError as Y, type LifetimeDeclaration as Z, type LifetimePolicy as _, type PhysicsErrorCode as a, LiftImpart as a0, type LiftPath as a1, LiftPathMode as a2, type LiftShape as a3, LiftShapeKind as a4, type LiftSpin as a5, type LiftTooFast as a6, type LiftsApi as a7, LiftsConfigError as a8, MODULE_CONTRACT as a9, type ProjectileField as aA, type ProjectileFlight as aB, type ProjectileHit as aC, type ProjectileInit as aD, type Quat as aE, type ResolvedPhysics as aF, type RewindApi as aG, type RewoundPose as aH, type RoomContext as aI, SHOOTER_CENTER as aJ, type ShotWorldSpec as aK, type SlideRule as aL, TopPolicy as aM, type Vec3 as aN, type WorldApi as aO, type WorldClaim as aP, type WorldClaimOptions as aQ, type WorldRayHit as aR, type WorldRayOptions as aS, defineRoom as aT, isLiftId as aU, presetInputRepeat as aV, resolveContactConfig as aW, resolveInputConfig as aX, resolveLifetime as aY, resolveLifts as aZ, type ModuleConfig as aa, NO_LIFTS as ab, type PairRule as ac, type PhysicsAnswer as ad, type PhysicsApi as ae, type PhysicsBodyDesc as af, type PhysicsBodyState as ag, type PhysicsBodyType as ah, type PhysicsColliderDesc as ai, type PhysicsCommandResult as aj, type PhysicsCommands as ak, type PhysicsEvent as al, type PhysicsGroups as am, type PhysicsHit as an, type PhysicsJointDesc as ao, type PhysicsLimits as ap, type PhysicsMotor as aq, type PhysicsOverlap as ar, type PhysicsPose as as, type PhysicsQueryFilter as at, type PhysicsRefusal as au, type PhysicsRequest as av, type PhysicsSetPoseOptions as aw, type PhysicsShape as ax, type PresetSpec as ay, type ProjectileApi as az, InputRepeat as b, type LiftVec as c, type Lift as d, type LiftsPolicy as e, RemotePredict as f, type TopRule as g, type PropSlide as h, ContactDrawing as i, CONTACT_DEFAULTS as j, CONTACT_PAIRS_MAX as k, CONTACT_PASSES_MAX as l, CONTACT_PRESETS as m, CONTACT_TAG_MAX as n, CONTACT_VALUE_MAX as o, ContactConfigError as p, type ContactDeclaration as q, ContactPreset as r, type ContactPresetParams as s, ContactPush as t, type ContactShape as u, ContactShapeKind as v, type EntityApi as w, type EntityInit as x, INPUTS_DEFAULT as y, INPUT_PRESETS as z };