@genex-ai/multiplayer 0.17.1 → 0.17.6

package/dist/module-DqtFb5wA.d.ts

@@ -0,0 +1,1436 @@
+/** Preset names. Append-only: a name, once published, keeps its step function forever. */
+declare const Preset: {
+    /** Planar movement on x/y with an aim angle: the server-authority spike's arena. */
+    readonly TOPDOWN: "topdown";
+    /** Source-engine character movement through a static box-and-ramp world, z up (§17.7). */
+    readonly FIRSTPERSON: "firstperson";
+    /** An arcade car (Rocket League's ground and air handling, kept level) through the same world (§17.7). */
+    readonly VEHICLE: "vehicle";
+};
+type PresetName = (typeof Preset)[keyof typeof Preset];
+/** The longest step a preset simulates; a longer dt (a stalled tab, a hostile value) is cut to it. */
+declare const PRESET_MAX_DT_S = 0.25;
+/** `topdown` parameters. */
+interface TopdownParams {
+    /** Movement speed, world units per second. */
+    speed: number;
+    /** Half the arena's side: x and y stay within [-arena, arena]. */
+    arena: number;
+}
+declare const TOPDOWN_DEFAULTS: Readonly<TopdownParams>;
+/** One parameter's accepted range: a finite number in [min, max], above 0 when `positive`, and an
+ *  integer when `integer` (absent = any number). */
+interface PresetParamRange {
+    min: number;
+    max: number;
+    positive: boolean;
+    integer?: true;
+}
+/** The fields a `topdown` step reads and writes. */
+interface TopdownBody {
+    x: number;
+    y: number;
+    /** Aim, radians. */
+    yaw: number;
+}
+/** The input fields a `topdown` step reads. */
+interface TopdownInput {
+    moveX?: unknown;
+    moveY?: unknown;
+    yaw?: unknown;
+}
+/** Whether `name` is a known preset. */
+declare function isPresetName(name: unknown): name is PresetName;
+/** Whether `params` is acceptable for preset `name`: absent, or an object whose every key is one of
+ *  the preset's parameters with a finite number in its range. */
+declare function presetParamsValid(name: PresetName, params: unknown): boolean;
+/** Preset `name`'s parameters from a module's `preset.params`: its defaults for anything unset or
+ *  invalid, key by key in the order of its range table. */
+declare function resolvePresetParams(name: PresetName, params: unknown): Record<string, number>;
+/** `topdown` parameters from a module's `preset.params`: defaults for anything unset or invalid. */
+declare function resolveTopdownParams(params: unknown): TopdownParams;
+/**
+ * One fixed `topdown` step. Pure: returns the next body.
+ *  - moveX, moveY: non-finite → 0, clamped to [-1, 1], float32; a vector longer than 1 is scaled to 1;
+ *  - dt: non-finite or ≤ 0 → 0, capped at {@link PRESET_MAX_DT_S};
+ *  - x' = fround(clamp(x + moveX * scale * speed * dt, -arena, arena)), y' likewise;
+ *  - yaw' = the input yaw wrapped to [-π, π) as float32, or the previous yaw when it is not usable.
+ */
+declare function stepTopdown(body: TopdownBody, input: TopdownInput, dt: number, params: TopdownParams): TopdownBody;
+/** `firstperson` parameters (§17.7's table, in its order). Each is used as float32. */
+interface FirstpersonParams {
+    /** Run speed, units/s, before the body's `cap`. */
+    maxSpeed: number;
+    /** Speed multiplier while walk is held. */
+    walkSpeed: number;
+    /** Speed multiplier while ducking (wins over walk). */
+    crouchSpeed: number;
+    accelerate: number;
+    airAccelerate: number;
+    /** Air wish speed is clamped to this before the projection (what makes air-strafing work). */
+    airMaxWishSpeed: number;
+    friction: number;
+    /** Below this speed friction acts as if at this speed. */
+    stopSpeed: number;
+    /** Units/s² along −z. */
+    gravity: number;
+    /** The `vz` a jump sets. */
+    jumpImpulse: number;
+    /** Each velocity axis is clamped to ±this. */
+    maxVelocity: number;
+    /** Half the side of the hull's square footprint. */
+    radius: number;
+    standHeight: number;
+    crouchHeight: number;
+    /** Seconds to duck fully, and to stand back up. */
+    duckTime: number;
+    /** Highest ledge walked up without a jump. */
+    stepHeight: number;
+    /** Least z of a ramp top's unit normal that can be stood on. */
+    standable: number;
+    /** How far below the feet ground is found. */
+    groundTrace: number;
+    /** How far above the feet ground is found (a hull sunk that far is lifted out). */
+    groundSnap: number;
+    /** Clearance kept from a surface (Source's DIST_EPSILON). */
+    skin: number;
+    /** Largest |pitch|, radians. */
+    pitchLimit: number;
+    /** Button masks: any shared bit counts as held; 0 disables. */
+    jumpBit: number;
+    duckBit: number;
+    walkBit: number;
+    /** Sub-steps per step, an integer in [1, 8]. */
+    substeps: number;
+    /** The collision world's hash ({@link firstpersonWorld}), written by the sandbox. */
+    world: number;
+}
+/** 32-bit FNV-1a of the empty world: two zero counts (§17.7). */
+declare const EMPTY_WORLD_HASH = 2615243109;
+declare const FIRSTPERSON_DEFAULTS: Readonly<FirstpersonParams>;
+/** `firstperson` parameters from a module's `preset.params`: defaults for anything unset or invalid. */
+declare function resolveFirstpersonParams(params: unknown): FirstpersonParams;
+/** `mstate` bits a `firstperson` step keeps. */
+declare const MoveState: {
+    readonly ON_GROUND: 1;
+    readonly DUCKING: 2;
+    readonly JUMP_HELD: 4;
+};
+/** The fields a `firstperson` step reads (`cap` too, which it never writes). */
+interface FirstpersonBody {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    /** Aim, radians: stored only. */
+    yaw: number;
+    pitch: number;
+    /** 0 standing, 1 fully ducked. */
+    duck: number;
+    /** {@link MoveState} bits. */
+    mstate: number;
+    /** Speed multiplier the module writes (a weapon's or a wound's), [0, 4]. */
+    cap?: number;
+}
+/** What a `firstperson` step writes: every body field but `cap`. */
+type FirstpersonStep = Omit<FirstpersonBody, 'cap'>;
+/** The input fields a `firstperson` step reads. `moveX`/`moveY` are WORLD axes. */
+interface FirstpersonInput {
+    moveX?: unknown;
+    moveY?: unknown;
+    yaw?: unknown;
+    pitch?: unknown;
+    buttons?: unknown;
+}
+/** A box: `[minX, minY, minZ, maxX, maxY, maxZ]`. */
+type WorldBox = readonly [number, number, number, number, number, number];
+/** A ramp: a box whose top rises along x (`axis` 0) or y (`axis` 1), from `lo` at that axis's min
+ *  end to `hi` at its max end: `[minX, minY, minZ, maxX, maxY, maxZ, axis, lo, hi]`. */
+type WorldRamp = readonly [number, number, number, number, number, number, number, number, number];
+/** A world as a module and a game give it (§17.7): boxes, then ramps. */
+interface FirstpersonWorldSpec {
+    boxes?: readonly (readonly number[])[];
+    ramps?: readonly (readonly number[])[];
+}
+/** A validated world ({@link firstpersonWorld}): frozen, every value a float32 (−0 read as 0). */
+interface FirstpersonWorld {
+    readonly boxes: readonly WorldBox[];
+    readonly ramps: readonly WorldRamp[];
+    /** 32-bit FNV-1a over its counts and values (§17.7): what `params.world` must equal. */
+    readonly hash: number;
+    /** Whether the step visits only the solids a bounding-volume tree over their boxes says could
+     *  matter (the results are bit-identical to visiting every one; only the cost changes). */
+    readonly broadphase: boolean;
+}
+declare const WorldLimits: {
+    readonly MAX_BOXES: 4096;
+    readonly MAX_RAMPS: 512;
+    /** Every world value's magnitude. */
+    readonly MAX_ABS: 1000000000;
+};
+/** Why a world was refused: the path of the first bad value. */
+declare class WorldError extends RangeError {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+/**
+ * Validates a collision world (§17.7) and returns it frozen, with its hash. Refused (a
+ * {@link WorldError}) unless it has at most 4096 boxes and 512 ramps, each exactly six (box) or
+ * nine (ramp) numbers, every one a float32 of magnitude at most 1e9, min < max on every axis, and
+ * each ramp `axis` 0 or 1 with `minZ ≤ lo`, `minZ ≤ hi` and `maxZ = max(lo, hi)`. `undefined` is
+ * the empty world; a missing `boxes` or `ramps` is none, and other keys are ignored. `broadphase`
+ * (default true) builds the bounding-volume tree the step filters with; it never changes a result. A
+ * world this function returned is returned as is.
+ */
+declare function firstpersonWorld(raw: unknown, options?: {
+    broadphase?: boolean;
+}): FirstpersonWorld;
+/** The empty world: no solids (a body in it falls until z reaches −1e9). */
+declare const EMPTY_WORLD: FirstpersonWorld;
+/** A solid posed for one tick beside the static world (a lift at its pose, a head slab): an
+ *  axis-aligned box `[min, max]`; a box of half extents `half` about centre `c` turned about z by the
+ *  angle whose sine and cosine are given (`obox`); or an upright disc of `radius` about `c`, `half` its
+ *  half height. Visited after the static solids, in order, never by the broad phase's tree. */
+type PosedSolid = {
+    readonly kind: 'box';
+    readonly min: readonly [number, number, number];
+    readonly max: readonly [number, number, number];
+} | {
+    readonly kind: 'obox';
+    readonly c: readonly [number, number, number];
+    readonly half: readonly [number, number, number];
+    readonly sin: number;
+    readonly cos: number;
+} | {
+    readonly kind: 'disc';
+    readonly c: readonly [number, number, number];
+    readonly radius: number;
+    readonly half: number;
+};
+/** Posed solids a tick may hold at most (32 lifts and a head slab for each of 64 seats). */
+declare const POSED_MAX = 96;
+/** The step's view of a tick's posed solids ({@link posedWorld}): one flat table per field. `min*`
+ *  and `max*` are each solid's bounds on x, y and z (an obox's or a disc's box around it). */
+interface PosedWorld {
+    readonly count: number;
+    readonly kind: Uint8Array;
+    readonly minX: Float64Array;
+    readonly minY: Float64Array;
+    readonly minZ: Float64Array;
+    readonly maxX: Float64Array;
+    readonly maxY: Float64Array;
+    readonly maxZ: Float64Array;
+    readonly cx: Float64Array;
+    readonly cy: Float64Array;
+    readonly hx: Float64Array;
+    readonly hy: Float64Array;
+    readonly sin: Float64Array;
+    readonly cos: Float64Array;
+    readonly radius: Float64Array;
+}
+/** A tick's posed solids compiled for the step, in the order given. */
+declare function posedWorld(solids: readonly PosedSolid[]): PosedWorld;
+/** No posed solids. */
+declare const NO_POSED: PosedWorld;
+/** A seat's body as the lift slots read it. */
+interface HullBody {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly vz?: number;
+    readonly duck?: number;
+}
+/** What the lift slots ask of a preset's hull, against the world and a tick's posed solids. */
+interface HullOps {
+    /** The posed solid (its index) the hull stands on: the highest standable top under it in
+     *  [z − groundTrace, z + groundSnap] (`checkGround`'s test) when that top is a posed solid's (the
+     *  first such in order), else −1; −1 too while rising (`vz > 0.1`). */
+    support(body: HullBody, solids: readonly PosedSolid[]): number;
+    /** Whether the hull is more than skin inside posed solid `k` (§17.7 *Starting inside*'s `inside`). */
+    inside(body: HullBody, solids: readonly PosedSolid[], k: number): boolean;
+    /** §17.7 *Starting inside* as `slideMove` applies it, with no move: up to four times, out through the
+     *  face a zero-length sweep reports, by its depth then skin. `inside`: still inside some solid. */
+    pushOut(body: HullBody, solids: readonly PosedSolid[]): {
+        x: number;
+        y: number;
+        z: number;
+        inside: boolean;
+    };
+}
+/** The preset's hull among `world` and a tick's posed solids. */
+declare function hullOps(preset: 'firstperson' | 'vehicle', params: Readonly<Record<string, number>>, world?: FirstpersonWorld): HullOps;
+/**
+ * One fixed `firstperson` step (§17.7) through `world` (default: the empty world). Pure: returns the
+ * next `x y z vx vy vz yaw pitch duck mstate`; the body's `cap` is read, never written. `world` must
+ * be the world whose hash is `params.world` for the result to be the server's; the step itself does
+ * not compare them.
+ */
+declare function stepFirstperson(body: Partial<FirstpersonBody>, input: FirstpersonInput, dt: number, params: FirstpersonParams, world?: FirstpersonWorld, posed?: PosedWorld): FirstpersonStep;
+/** `vehicle` parameters (§17.7's table, in its order). Each is used as float32 but the masks,
+ *  `substeps` and `world`. */
+interface VehicleParams {
+    /** Top speed on the throttle, units/s, before the body's `cap`. */
+    maxSpeed: number;
+    /** Throttle acceleration, units/s². */
+    accel: number;
+    /** Deceleration while the throttle opposes the motion. */
+    brake: number;
+    /** Deceleration with no throttle, and down to the throttle's speed when above it without boost. */
+    coast: number;
+    /** Boost's acceleration along the heading, on top of the throttle's. */
+    boostAccel: number;
+    /** Top speed under boost, before `cap`. */
+    boostMaxSpeed: number;
+    /** Fuel burned per second of boost (a full tank is 1). */
+    boostBurn: number;
+    /** Deceleration of the sideways speed on the ground, units/s². */
+    grip: number;
+    /** The same, while drift is held. */
+    driftGrip: number;
+    /** Yaw rate at full steer on the ground, rad/s, at or above `turnSpeed`. */
+    turnRate: number;
+    /** The forward speed at which the full turn rate is reached. */
+    turnSpeed: number;
+    /** How fast the yaw rate follows the steering on the ground, rad/s². */
+    spinAccel: number;
+    /** Yaw rate at full steer in the air, rad/s. */
+    airTurnRate: number;
+    /** How fast the yaw rate follows the steering in the air, rad/s². */
+    airSpinAccel: number;
+    /** Units/s² along −z. */
+    gravity: number;
+    /** The `vz` a jump sets. */
+    jumpImpulse: number;
+    /** Each velocity axis is clamped to ±this. */
+    maxVelocity: number;
+    /** Half the side of the hull's square footprint. */
+    radius: number;
+    /** Hull height. */
+    height: number;
+    /** Highest ledge driven up without a jump, and the deepest drop a sub-step follows down. */
+    stepHeight: number;
+    /** Least z of a ramp top's unit normal that can be driven on. */
+    standable: number;
+    /** How far below the hull's base ground is found. */
+    groundTrace: number;
+    /** How far above the hull's base ground is found. */
+    groundSnap: number;
+    /** Clearance kept from a surface. */
+    skin: number;
+    /** Button masks: any shared bit counts as held; 0 disables. */
+    jumpBit: number;
+    boostBit: number;
+    driftBit: number;
+    /** Sub-steps per step, an integer in [1, 8]. */
+    substeps: number;
+    /** The collision world's hash ({@link firstpersonWorld}), written by the sandbox. */
+    world: number;
+}
+declare const VEHICLE_DEFAULTS: Readonly<VehicleParams>;
+/** `vehicle` parameters from a module's `preset.params`: defaults for anything unset or invalid. */
+declare function resolveVehicleParams(params: unknown): VehicleParams;
+/** The fields a `vehicle` step reads (`cap` too, which it never writes; it never touches `pitch`
+ *  or `duck`). */
+interface VehicleBody {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    /** Heading, radians, +yaw counterclockwise seen from above (z up): body state, not input. */
+    yaw: number;
+    /** Yaw rate, rad/s, positive toward +yaw, [−1000, 1000]. */
+    spin: number;
+    /** The boost tank, [0, 1]. The module writes it to refuel; the step only burns it. */
+    fuel: number;
+    /** {@link MoveState} bits: onGround and jumpHeld. */
+    mstate: number;
+    /** Multiplier of both top speeds the module writes, [0, 4]. */
+    cap?: number;
+}
+/** What a `vehicle` step writes: every body field but `cap`. */
+type VehicleStep = Omit<VehicleBody, 'cap'>;
+/** The input fields a `vehicle` step reads: `moveY` the throttle, `moveX` the steer (+1 turns
+ *  right, toward −yaw), `buttons` jump, boost and drift. */
+interface VehicleInput {
+    moveX?: unknown;
+    moveY?: unknown;
+    buttons?: unknown;
+}
+/**
+ * One fixed `vehicle` step (§17.7) through `world` (default: the empty world). Pure: returns the
+ * next `x y z vx vy vz yaw spin fuel mstate`; the body's `cap` is read, never written, and `pitch`
+ * and `duck` are never touched. `world` must be the world whose hash is `params.world` for the
+ * result to be the server's; the step itself does not compare them.
+ */
+declare function stepVehicle(body: Partial<VehicleBody>, input: VehicleInput, dt: number, params: VehicleParams, world?: FirstpersonWorld, posed?: PosedWorld): VehicleStep;
+/** A body field a preset step may read and write: the entity's float32 pose and velocity,
+ *  firstperson's aim pitch, duck amount, movement bits and speed cap, and vehicle's yaw rate and
+ *  boost fuel. */
+type PresetField = 'x' | 'y' | 'z' | 'vx' | 'vy' | 'vz' | 'yaw' | 'pitch' | 'duck' | 'mstate' | 'cap' | 'spin' | 'fuel';
+/** The body a preset step reads: any of the fields, a missing one read as the step says (0, or 1
+ *  for `cap`). */
+type PresetBody = Readonly<Partial<Record<PresetField, number>>>;
+/** The input a preset step reads (sanitized by the step itself). */
+type PresetInput = Readonly<Partial<Record<'moveX' | 'moveY' | 'moveZ' | 'yaw' | 'pitch' | 'buttons', unknown>>>;
+/** One preset, type-erased: what a validator, a reconciler and a test server need to run it by
+ *  name. `fields` are the body fields its step writes (and so the fields a client mirrors);
+ *  `reads` the further fields it only reads (a client mirrors those too, so a replay sees the
+ *  server's value); `world` whether it steps through a collision world. */
+interface PresetDefinition {
+    readonly defaults: Readonly<Record<string, number>>;
+    readonly ranges: Readonly<Record<string, PresetParamRange>>;
+    readonly fields: readonly PresetField[];
+    readonly reads: readonly PresetField[];
+    readonly world: boolean;
+    step(body: PresetBody, input: PresetInput, dt: number, params: Readonly<Record<string, number>>, world?: FirstpersonWorld, posed?: PosedWorld): Record<string, number>;
+}
+/** Every preset by name. A new preset is one entry here (plus its §17.7 text and vectors). */
+declare const PRESETS: {
+    readonly [N in PresetName]: PresetDefinition;
+};
+/** Preset `name`'s table entry; undefined for a name not in the table (never one reached through
+ *  the prototype). */
+declare function definitionOf(name: unknown): PresetDefinition | undefined;
+/** One fixed step of preset `name` with already resolved `params` ({@link resolvePresetParams}),
+ *  through `world` for a preset that has one (default: the empty world). Pure: returns the next
+ *  values of the preset's `fields`. */
+declare function stepPreset(name: PresetName, body: PresetBody, input: PresetInput, dt: number, params: Readonly<Record<string, number>>, world?: FirstpersonWorld, posed?: PosedWorld): Record<string, number>;
+
+/** 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. */
+interface InputPolicy {
+    readonly repeat: InputRepeat;
+}
+/**
+ * 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;
+}
+/**
+ * `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";
+};
+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[];
+}
+/** 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;
+}
+/** 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;
+    /** 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;
+}
+/** 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;
+    random(): number;
+    readonly entities: EntityApi;
+    /** 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;
+    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;
+    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;
+}
+/** Identity helper that types a room module: `export default defineRoom({ ... })`. */
+declare const defineRoom: <S>(module: GenexRoomModule<S>) => GenexRoomModule<S>;
+
+export { type InputPolicy as $, EMPTY_WORLD as A, EMPTY_WORLD_HASH as B, type ContactPolicy as C, type EntityApi as D, type EntityData as E, type FirstpersonWorld as F, type EntityInit as G, type HullBody as H, type InputData as I, type Json as J, FIRSTPERSON_DEFAULTS as K, LeaveReason as L, type FirstpersonBody as M, type FirstpersonInput as N, type FirstpersonParams as O, type PlayerInfo as P, type FirstpersonStep as Q, type ResolvedModuleConfig as R, type StandRule as S, type TickHz as T, type GenexRoomModule as U, HeadFriction as V, INPUTS_DEFAULT as W, INPUT_PRESETS as X, type InitContext as Y, InputConfigError as Z, type InputDeclaration as _, type PhysicsErrorCode as a, SHOOTER_CENTER as a$, LIFTS_MAX as a0, LIFT_ID_MAX as a1, LIFT_POINTS_MAX as a2, LIFT_SPIN_MIN_PERIOD as a3, LIFT_TICKS_MAX as a4, LIFT_VALUE_MAX as a5, LiftEase as a6, LiftImpart as a7, type LiftPath as a8, LiftPathMode as a9, type PhysicsJointDesc as aA, type PhysicsLimits as aB, type PhysicsMotor as aC, type PhysicsOverlap as aD, type PhysicsPose as aE, type PhysicsQueryFilter as aF, type PhysicsRefusal as aG, type PhysicsRequest as aH, type PhysicsSetPoseOptions as aI, type PhysicsShape as aJ, Preset as aK, type PresetBody as aL, type PresetDefinition as aM, type PresetField as aN, type PresetInput as aO, type PresetName as aP, type PresetParamRange as aQ, type PresetSpec as aR, type ProjectileApi as aS, type ProjectileField as aT, type ProjectileFlight as aU, type ProjectileHit as aV, type ProjectileInit as aW, type Quat as aX, type ResolvedPhysics as aY, type RewindApi as aZ, type RoomContext as a_, type LiftShape as aa, LiftShapeKind as ab, type LiftSpin as ac, type LiftTooFast as ad, type LiftsApi as ae, LiftsConfigError as af, MODULE_CONTRACT as ag, type ModuleConfig as ah, MoveState as ai, NO_LIFTS as aj, NO_POSED as ak, POSED_MAX as al, PRESETS as am, PRESET_MAX_DT_S as an, type PairRule as ao, type PhysicsAnswer as ap, type PhysicsApi as aq, type PhysicsBodyDesc as ar, type PhysicsBodyState as as, type PhysicsBodyType as at, type PhysicsColliderDesc as au, type PhysicsCommandResult as av, type PhysicsCommands as aw, type PhysicsEvent as ax, type PhysicsGroups as ay, type PhysicsHit as az, InputRepeat as b, type SlideRule as b0, TOPDOWN_DEFAULTS as b1, TopPolicy as b2, type TopdownBody as b3, type TopdownInput as b4, type TopdownParams as b5, VEHICLE_DEFAULTS as b6, type Vec3 as b7, type VehicleBody as b8, type VehicleInput as b9, type VehicleParams as ba, type VehicleStep as bb, type WorldBox as bc, WorldError as bd, WorldLimits as be, type WorldRamp as bf, defineRoom as bg, definitionOf as bh, firstpersonWorld as bi, hullOps as bj, isLiftId as bk, isPresetName as bl, posedWorld as bm, presetInputRepeat as bn, presetParamsValid as bo, resolveContactConfig as bp, resolveFirstpersonParams as bq, resolveInputConfig as br, resolveLifts as bs, resolvePresetParams as bt, resolveTopdownParams as bu, resolveVehicleParams as bv, stepFirstperson as bw, stepPreset as bx, stepTopdown as by, stepVehicle as bz, type LiftVec as c, type PosedSolid as d, type Lift as e, type LiftsPolicy as f, type HullOps as g, type PosedWorld as h, RemotePredict as i, type TopRule as j, type PropSlide as k, ContactDrawing as l, type FirstpersonWorldSpec as m, CONTACT_DEFAULTS as n, CONTACT_PAIRS_MAX as o, CONTACT_PASSES_MAX as p, CONTACT_PRESETS as q, CONTACT_TAG_MAX as r, CONTACT_VALUE_MAX as s, ContactConfigError as t, type ContactDeclaration as u, ContactPreset as v, type ContactPresetParams as w, ContactPush as x, type ContactShape as y, ContactShapeKind as z };