@genex-ai/multiplayer 0.17.6 → 0.17.9

package/dist/shot-world-D22tqOUT.d.ts

@@ -0,0 +1,485 @@
+/** 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;
+    /** 1: a duck can deepen in the air, lifting the feet (a crouch-jump). 0: only on the ground. */
+    airDuck: 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;
+    /** 1: a jump works at `cap` 0. 0: a press at `cap` 0 is no jump (a freeze time). */
+    capZeroJump: number;
+    /** Button mask of a run the room owns: while not 0 and not held, speed is `jogSpeed`. 0: every move runs. */
+    runBit: number;
+    /** Speed multiplier without `runBit` (duck and walk win). */
+    jogSpeed: 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: 32768;
+    readonly MAX_RAMPS: 4096;
+    /** 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 32768 boxes and 4096 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;
+    caps?: {
+        readonly MAX_BOXES: number;
+        readonly MAX_RAMPS: number;
+    };
+}): 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;
+/** What a tree key multiplies its Morton code by (see {@link leafOrder}): 23 index bits above the 30-bit
+ *  code fill a float64's exact integers, far past any world's solids. A world that fitted the old 13 bits
+ *  keeps its tree: the order is the code's, ties by index, at any width. */
+declare const TREE_KEY_RADIX: number;
+/** The order a broadphase's tree keeps `solids` in, leaves first (each solid a box, or a ramp whose first
+ *  six values are its box): what every port's tree is held to, at any size (firstperson-large.json). */
+declare function worldTreeOrder(solids: readonly (readonly number[])[]): Int32Array;
+/** What a step does through its world, counted (see {@link withWorldCostMeter}). */
+interface WorldCostMeter {
+    /** Tree entries a query walked. */
+    nodes: number;
+    /** Exact tests of a solid: a query's candidates, each of which its helper tests, and each solid
+     *  `covered` looked at. */
+    tests: number;
+    /** A sweep's slab or wedge tests of its candidates. */
+    sweeps: number;
+    /** Of those, the wedges: seven planes and a slope against a slab's six, about three times the time. */
+    wedges: number;
+}
+/** Runs `run` with every step's world work counted into `meter`. Steps run one at a time, and a step's
+ *  results do not depend on the meter. */
+declare function withWorldCostMeter<T>(meter: WorldCostMeter, run: () => T): T;
+/** 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 · unit`). */
+    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;
+    /** 1: a jump works at `cap` 0. 0: a press at `cap` 0 is no jump (a freeze time). */
+    capZeroJump: 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>;
+
+/** Which world a ray asks. */
+declare const WorldKey: {
+    readonly Shot: "shot";
+};
+type WorldKey = (typeof WorldKey)[keyof typeof WorldKey];
+/** What `ctx.world.claim` made of a claimed stop. */
+declare const ClaimVerdict: {
+    /** Within the tolerance of the shot world's stop: the claim stands. */
+    readonly Accepted: "accepted";
+    /** Past the shot world's stop by more than the tolerance: the shot stops there. */
+    readonly Refused: "refused";
+    /** Short of the shot world's stop by more than the tolerance: raised to the tolerance. */
+    readonly Capped: "capped";
+    /** Past it, through one wall of no more than the weapon's `pierce`. */
+    readonly Pierced: "pierced";
+    /** The weapon's `rule` said. */
+    readonly Ruled: "ruled";
+};
+type ClaimVerdict = (typeof ClaimVerdict)[keyof typeof ClaimVerdict];
+/** What a shot world may cost, as a count (tree entries walked and solids tested) on seeded rays. */
+declare const ShotWorldCost: {
+    /** Eight shots a tick at this cost are one seat's share of a step (16,000 operations, world-cost's budget). */
+    readonly MAX_OPS_PER_RAY: 2000;
+    readonly RAYS: 128;
+    readonly SEED: 2027;
+    /** Solids a room may hold, its world and its shot world together: at the .46 KiB a solid a real room measured (module text included,
+     *  yard 152 m, 14.9 MiB at 33,233), this leaves the module a tenth of the 25.6 MiB a room is ended at. */
+    readonly MAX_ROOM_SOLIDS: 49152;
+    /** Surfaces a piercing claim may walk: a wall of a thousand slabs costs what this many do. */
+    readonly MAX_CLAIM_WALKS: 8;
+    /** The least a ray is taken to face a surface: how far along a graze the tolerance reaches, at most four times itself. Swept on the corpus (world-shots.yml,
+     *  run 42297695700, at each world's stated tolerance, 38 and 76 m, mean of 8 rows): from 1/2 to 1/4 honest claims refused or capped fall from 8.3% to 7.2% and a
+     *  hostile reach past a real surface at p99 doubles to 17 units; from 1/4 to 1/16 honest gains .3 more, for a reach of 51 units and a shot through at 48 of 3.1%, 0 before. */
+    readonly MIN_CLAIM_FACING: number;
+};
+/** What a load counted of its shot world (InitOut's `shotWorld`). */
+interface ShotWorldCount {
+    solids: number;
+    opsPerRay: number;
+}
+/** A claimed stop as `moveZ` in [-1, 1] (neither movement preset reads it, and every transport carries it, §17.7 *A claimed stop*):
+ *  [0, range] across the axis, and the axis's top for a shot that flew on. */
+declare function claimToAxis(dist: number | null, range: number): number;
+/** `claimToAxis`'s other way: a distance, or null for a shot that flew on. */
+declare function axisToClaim(axis: number, range: number): number | null;
+
+export { resolvePresetParams as $, type VehicleParams as A, type VehicleStep as B, ClaimVerdict as C, type WorldBox as D, EMPTY_WORLD as E, type FirstpersonWorld as F, WorldError as G, type HullBody as H, WorldKey as I, WorldLimits as J, type WorldRamp as K, axisToClaim as L, MoveState as M, NO_POSED as N, claimToAxis as O, type PresetName as P, definitionOf as Q, firstpersonWorld as R, type ShotWorldCount as S, TOPDOWN_DEFAULTS as T, hullOps as U, VEHICLE_DEFAULTS as V, type WorldCostMeter as W, isPresetName as X, posedWorld as Y, presetParamsValid as Z, resolveFirstpersonParams as _, type PosedSolid as a, resolveTopdownParams as a0, resolveVehicleParams as a1, stepFirstperson as a2, stepPreset as a3, stepTopdown as a4, stepVehicle as a5, withWorldCostMeter as a6, worldTreeOrder as a7, type HullOps as b, type PosedWorld as c, type FirstpersonWorldSpec as d, EMPTY_WORLD_HASH as e, FIRSTPERSON_DEFAULTS as f, type FirstpersonBody as g, type FirstpersonInput as h, type FirstpersonParams as i, type FirstpersonStep as j, POSED_MAX as k, PRESETS as l, PRESET_MAX_DT_S as m, Preset as n, type PresetBody as o, type PresetDefinition as p, type PresetField as q, type PresetInput as r, type PresetParamRange as s, ShotWorldCost as t, TREE_KEY_RADIX as u, type TopdownBody as v, type TopdownInput as w, type TopdownParams as x, type VehicleBody as y, type VehicleInput as z };