@genex-ai/multiplayer 0.17.6 → 0.17.8

package/dist/{module-DqtFb5wA.d.ts → module-CSpXrzFc.d.ts}

@@ -1,404 +1,36 @@
-/** 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;
+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;
 };
-/** Why a world was refused: the path of the first bad value. */
-declare class WorldError extends RangeError {
+/** 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, 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;
+    constructor(path: string);
 }
-/** 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;
+/** `config.lifetime` as a module declares it: either limit, whole seconds. */
+interface LifetimeDeclaration {
+    idleSeatS?: number;
+    maxRoomAgeS?: number;
 }
-/**
- * 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>;
+/** `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
@@ -655,10 +287,19 @@ declare const InputRepeat: {
     readonly Off: "off";
 };
 type InputRepeat = (typeof InputRepeat)[keyof typeof InputRepeat];
-/** The resolved input settings a room runs with. */
+/** 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
@@ -697,6 +338,7 @@ declare class InputConfigError extends Error {
 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
@@ -859,6 +501,8 @@ declare const LeaveReason: {
     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. */
@@ -945,6 +589,12 @@ interface EntityApi {
     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). */
@@ -963,6 +613,75 @@ interface RewindApi {
      *  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
@@ -1343,6 +1062,9 @@ interface ModuleConfig {
      *  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). */
@@ -1369,14 +1091,26 @@ interface ResolvedModuleConfig {
     /** 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;
@@ -1396,6 +1130,8 @@ interface RoomContext<S> {
     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;
@@ -1422,6 +1158,15 @@ interface GenexRoomModule<S = unknown> {
      *  `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;
@@ -1429,8 +1174,14 @@ interface GenexRoomModule<S = unknown> {
     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 { 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 };
+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 };