@genex-ai/multiplayer 0.17.1 → 0.17.8

package/dist/physics-predict-C7ZB1gDG.d.ts

@@ -0,0 +1,1223 @@
+import { ap as PhysicsLimits, T as TickHz, a as PhysicsErrorCode, aF as ResolvedPhysics, ay as PresetSpec, f as RemotePredict, h as PropSlide, e as LiftsPolicy } from './module-CSpXrzFc.js';
+
+/** The contract version a physics room's world is created with (C§4 `WorldDesc.contract`). */
+declare const PHYSICS_CONTRACT = "1.0";
+/** C§11's default limits. `worldExtent` and `maxSpeed` are given per unit of `lengthUnit` (their
+ *  default at lengthUnit 1): the contract's defaults are 100_000 · lengthUnit and 1_000 · lengthUnit. */
+declare const PHYSICS_DEFAULT_LIMITS: Readonly<PhysicsLimits>;
+/** Every limit name, in C§11's order. */
+declare const PHYSICS_LIMIT_NAMES: readonly (keyof PhysicsLimits)[];
+/** The limits measured in room units: their default and their ceiling scale with `lengthUnit`. */
+declare const PHYSICS_SCALED_LIMITS: readonly (keyof PhysicsLimits)[];
+/** The limits that may be any number above 0; every other limit is an integer above 0. */
+declare const PHYSICS_REAL_LIMITS: readonly (keyof PhysicsLimits)[];
+/** A paid tier raises a limit at most to this many times its default (C§11). */
+declare const PHYSICS_CEILING_FACTOR = 4;
+/** What a world past the default `staticPieces` adds to the room's `memoryBytes`, per piece: above the core's model of
+ *  any piece (C§11.1: a box 1,568 bytes, an 8-point ramp 1,954), so the world leaves a room the bodies and contacts the
+ *  default gives one. */
+declare const PHYSICS_STATIC_PIECE_BYTES = 2048;
+/** The largest world a predicting room holds (§17.11): what every shipped client's core imports. Past it the client's
+ *  core refuses the world, so the host draws the bodies from the server for every seat rather than leave each to find out. */
+declare const PHYSICS_PREDICT_MAX_BOXES = 4096;
+declare const PHYSICS_PREDICT_MAX_RAMPS = 512;
+/** Whether a room with this static world predicts when it asks to. */
+declare const physicsWorldPredicts: (boxes: number, ramps: number) => boolean;
+/** A room's limits for a static world of `pieces` solids (§17.10 *The static world*). A world the limits hold changes
+ *  nothing: the description, and with it `physicsHash`, stay as they were. A larger one is the module's map, not a
+ *  paid extra: `staticPieces` rises to it and `memoryBytes` by its size, up to the core's ceiling. A module that lowered
+ *  `staticPieces` asked for less, and the core refuses its world. */
+declare function physicsLimitsForWorld(limits: PhysicsLimits, pieces: number): PhysicsLimits;
+/** A room's limit ceiling as its admission grants it, with `worldExtent` and `maxSpeed` per unit
+ *  of `lengthUnit`, like {@link PHYSICS_DEFAULT_LIMITS}. Each limit is between its default and
+ *  {@link PHYSICS_CEILING_FACTOR} times it. In release 1 every room's ceiling is the default. */
+type PhysicsCeiling = Readonly<PhysicsLimits>;
+/** Release 1's ceiling: the contract's defaults. */
+declare const PHYSICS_DEFAULT_CEILING: PhysicsCeiling;
+/** Whether `ceiling` is one admission may grant: every limit present, each between its default and
+ *  4× it (`worldExtent` and `maxSpeed` per unit of `lengthUnit`). */
+declare function physicsCeilingValid(ceiling: unknown): ceiling is PhysicsCeiling;
+/** Limits given per unit of `lengthUnit` (a ceiling, or the defaults) at the room's `lengthUnit`:
+ *  `worldExtent` and `maxSpeed` multiplied by it in float64, the rest as they are. */
+declare function physicsLimitsAt(perUnit: Readonly<PhysicsLimits>, lengthUnit: number): PhysicsLimits;
+/** The ranges of `config.physics` (§17.10 *Opt-in*). */
+declare const PhysicsConfigRange: {
+    /** `lengthUnit` is in (0, MAX_LENGTH_UNIT]. */
+    readonly MAX_LENGTH_UNIT: 1000000;
+    /** `gravity` is in [0, MAX_GRAVITY]; a default is never refused. */
+    readonly MAX_GRAVITY: 10000000;
+    /** Gravity without a world-stepping preset: this many metres per second squared. */
+    readonly EARTH_GRAVITY: 9.81;
+    readonly MIN_ITERATIONS: 1;
+    readonly MAX_ITERATIONS: 16;
+    readonly DEFAULT_ITERATIONS: 4;
+    /** Distinct physics kinds `subscribe` may name. */
+    readonly MAX_SUBSCRIBE_KINDS: 8;
+    /** `player.radius` and `player.height` are in (0, MAX_PLAYER_SIZE]. */
+    readonly MAX_PLAYER_SIZE: 1000000;
+};
+/** The `lengthUnit` a preset implies when the module gives none: its units are inches (Source's
+ *  `firstperson`) or centimetres (`vehicle`); anything else is metres. */
+declare const PHYSICS_PRESET_LENGTH_UNITS: Readonly<Partial<Record<string, number>>>;
+/** The keyframe rates a predicting room may ask for (`config.physics.patchHz`). */
+declare const PHYSICS_PATCH_HZ: readonly number[];
+/** `patchHz` when the module names none: K 1 at 20 Hz, 3 at 60 Hz, 6 at 120 Hz, and (15 Hz) 2 at
+ *  30 Hz. A car-ball room asks for 60 (K 2 at 120 Hz). */
+declare const PHYSICS_DEFAULT_PATCH_HZ = 20;
+/** The client prediction knobs a module may set (§17.11): their defaults and ranges. */
+declare const PhysicsPredictRange: {
+    readonly DEFAULT_REMOTE_PREDICT: "extrapolate";
+    readonly DEFAULT_REMOTE_DECAY_MS: 50;
+    readonly MAX_REMOTE_DECAY_MS: 1000;
+    readonly DEFAULT_LEAD_MS: 250;
+    readonly MIN_LEAD_MS: 50;
+    readonly MAX_LEAD_MS: 1000;
+};
+/** Whether `v` is a keyframe rate a module may ask for. */
+declare function isPhysicsPatchHz(v: unknown): v is number;
+/** The keyframe rate a room at `tickHz` runs for a requested `patchHz`: the largest allowed rate at
+ *  or below it that divides the tick rate (20 at 30 Hz is 15). */
+declare function effectivePatchHz(tickHz: TickHz, patchHz: number): number;
+/** K, the ticks between two keyframes: tickHz / the effective patchHz, a whole number ≥ 1. A
+ *  keyframe is the state after every tick t with t ≡ 0 (mod K). */
+declare function keyframeTicks(tickHz: TickHz, patchHz: number): number;
+/** In a predicting room every dynamic body's speed is clamped, by magnitude and every tick, to the
+ *  wire's velocity range: linear to this many metres per second (× lengthUnit), angular to this many
+ *  rad/s (§17.11 *The tick*). */
+declare const PHYSICS_PREDICT_MAX_LINEAR = 64;
+declare const PHYSICS_PREDICT_MAX_ANGULAR = 64;
+/**
+ * The stacking hook (§17.11): the solver iterations a predicting room runs at least. Canonicalizing
+ * drops warm starts, and the R2-0b experiment measured stacks of 10 and more falling over at 4
+ * iterations. The engine lane's stacking rule sets this; until then (null) a predicting room runs the
+ * module's own `iterations`.
+ */
+declare const PHYSICS_PREDICT_MIN_ITERATIONS: number | null;
+/** The solver iterations a room runs: the module's, raised to the stacking hook when it predicts. */
+declare function solverIterationsOf(physics: ResolvedPhysics, predicting: boolean): number;
+/** A contract key is at most this many bytes, a physics kind at most this many. */
+declare const PHYSICS_KEY_MAX_BYTES = 64;
+declare const PHYSICS_KIND_MAX_BYTES = 32;
+/** The prefix the contract keeps for static pieces (C§6.5): no body, collider or joint key has it. */
+declare const PHYSICS_STATIC_PREFIX = "static:";
+/** Whether `v` is a contract key fit to be a body's key: 1-64 bytes of `[A-Za-z0-9_.:-]` (ASCII, so
+ *  a byte is a character), not `__proto__`, `constructor` or `prototype`, not starting `static:`.
+ *  An entity with a body must have such an id; any other is refused with `invalid-key`. */
+declare function isPhysicsKey(v: unknown): v is string;
+/** Whether `v` is a physics kind: 1-32 bytes of the key charset. '' (or absent) means none and is
+ *  not a kind; the host passes it to the core absent. */
+declare function isPhysicsKind(v: unknown): v is string;
+/** A resolved `config.physics` (null = no physics), or the path of the first bad value. */
+type PhysicsResolution = {
+    ok: true;
+    value: ResolvedPhysics | null;
+} | {
+    ok: false;
+    path: string;
+};
+/**
+ * Resolves a module's `config.physics` (§17.10 *Opt-in*, *The resolved config*): `true` is `{}`;
+ * absent, `false` and `null` are no physics. Defaults are filled in (`lengthUnit` and `gravity` from
+ * the resolved `preset`), every limit is set and clamped to `ceiling` at the room's `lengthUnit`.
+ * `ceiling` is the room's admission: null when it was admitted without physics, which refuses a
+ * module that asks for it, as a ceiling refuses a module that does not. This is the reference the
+ * sandbox prelude ports.
+ */
+declare function resolvePhysicsConfig(request: unknown, preset: PresetSpec | null, ceiling: PhysicsCeiling | null): PhysicsResolution;
+/** Checks the sandbox's resolved `config.physics` from `InitOut`: null, or every key present and
+ *  in range, no limit above `ceiling` at its `lengthUnit`. Returns a fresh copy. */
+declare function checkResolvedPhysics(resolved: unknown, preset: PresetSpec | null, ceiling: PhysicsCeiling | null): PhysicsResolution;
+/** The core's sub-steps per tick at each tick rate: about 60 Hz of inner steps. */
+declare const PHYSICS_SUBSTEPS: Readonly<Record<TickHz, number>>;
+/** The contract's `WorldDesc` (C§4) as the host builds it for a room: z up, `dt` one tick. */
+interface PhysicsWorldDesc {
+    contract: typeof PHYSICS_CONTRACT;
+    dt: number;
+    substeps: number;
+    gravity: [number, number, number];
+    upAxis: 'z';
+    lengthUnit: number;
+    limits: PhysicsLimits;
+    solver: {
+        iterations: number;
+    };
+}
+/** The world a room with `physics` at `tickHz` creates; a predicting room's solver iterations follow
+ *  the stacking hook ({@link solverIterationsOf}). */
+declare function physicsWorldDesc(physics: ResolvedPhysics, tickHz: TickHz, predicting?: boolean, worldPieces?: number): PhysicsWorldDesc;
+/** `physEv`'s kind codes. */
+declare const PhysEvKind: {
+    readonly CONTACT_BEGIN: 0;
+    readonly CONTACT_END: 1;
+    readonly TRIGGER_ENTER: 2;
+    readonly TRIGGER_EXIT: 3;
+};
+type PhysEvKind = (typeof PhysEvKind)[keyof typeof PhysEvKind];
+/** A `contactBegin` event: kind code, the two bodies, their colliders, their kinds ('' = none), the
+ *  impulse, the contact point and the normal. */
+type PhysEvContactBegin = [
+    kind: typeof PhysEvKind.CONTACT_BEGIN,
+    a: string,
+    b: string,
+    ca: string,
+    cb: string,
+    ka: string,
+    kb: string,
+    impulse: number,
+    px: number,
+    py: number,
+    pz: number,
+    nx: number,
+    ny: number,
+    nz: number
+];
+/** Every other event ends after the kinds. A trigger puts `sensor, other, sc, oc, ks, ko` in the
+ *  places of `a, b, ca, cb, ka, kb`. */
+type PhysEvOther = [
+    kind: Exclude<PhysEvKind, typeof PhysEvKind.CONTACT_BEGIN>,
+    a: string,
+    b: string,
+    ca: string,
+    cb: string,
+    ka: string,
+    kb: string
+];
+type PhysEvRow = PhysEvContactBegin | PhysEvOther;
+/** A ray or shape-cast hit: body, collider, distance, point, normal. */
+type PhysHitRow = [body: string, collider: string, dist: number, px: number, py: number, pz: number, nx: number, ny: number, nz: number];
+/** An overlap: `more` (1 when the core found more than the keys listed, else 0), then the keys. */
+type PhysOverlapRow = [more: 0 | 1, ...keys: string[]];
+/** One answer: null (no hit), a hit, an overlap, or a refused query's C§14 code. */
+type PhysAnswerRow = PhysHitRow | PhysOverlapRow | PhysicsErrorCode | null;
+/** A subscribed body's state: key, position, rotation, linear and angular velocity, sleeping. */
+type PhysBodyRow = [
+    key: string,
+    px: number,
+    py: number,
+    pz: number,
+    qx: number,
+    qy: number,
+    qz: number,
+    qw: number,
+    vx: number,
+    vy: number,
+    vz: number,
+    wx: number,
+    wy: number,
+    wz: number,
+    sleeping: 0 | 1
+];
+/** An overlap answer lists at most this many keys. */
+declare const PHYSICS_OVERLAP_MAX_KEYS = 64;
+/** The physics fields of `AuthorityEntity`, which the host writes on body entities only. */
+declare const PHYSICS_BODY_FIELDS: readonly ["qx", "qy", "qz", "qw", "lvx", "lvy", "lvz", "avx", "avy", "avz", "sleep"];
+type PhysicsBodyField = (typeof PHYSICS_BODY_FIELDS)[number];
+/** Every field the host owns on a body entity: its position and its physics fields. A module that
+ *  writes one of these on a body entity is refused. */
+declare const HOST_BODY_FIELDS: readonly string[];
+/** A quantized body field's range. Each is 16 bits, clamped; its span is 65534 (the range is
+ *  symmetric about 0, so 0 is exact). */
+interface QuantizedRange {
+    readonly min: number;
+    readonly max: number;
+}
+declare const BodyQuantization: {
+    readonly BITS: 16;
+    /** Integer steps across a symmetric range (2^16 − 2). */
+    readonly SPAN: 65534;
+    /** `qx qy qz qw`. */
+    readonly ORIENTATION: QuantizedRange;
+    /** `lvx lvy lvz` (metres per second: velocity divided by lengthUnit) and `avx avy avz` (rad/s). */
+    readonly VELOCITY: QuantizedRange;
+};
+/** The uint16 a quantized field sends for `v` (Colyseus schema 5's clamp rule): out of range
+ *  clamps, NaN is `min`. */
+declare function quantizeBodyValue(v: number, range: QuantizedRange): number;
+/** The value a client decodes from the uint16 `q`, in float64. */
+declare function dequantizeBodyValue(q: number, range: QuantizedRange): number;
+/** In a predicting room a body within this many metres (× lengthUnit) of any seat's own entity is
+ *  contested: it is in every client's view at every keyframe, asleep or not, ahead of every other
+ *  (§17.11 *Interest*; a ball at rest that no update reaches is the "phantom ball"). */
+declare const PHYSICS_CONTESTED_METRES = 6;
+/** Body entities each client receives at full rate per patch, then the rotating ones after them. */
+declare const PHYSICS_FULL_RATE_BODIES = 100;
+declare const PHYSICS_ROTATING_BODIES = 25;
+/** A client extrapolates a body at most this far past its latest state. */
+declare const BODY_EXTRAPOLATE_MAX_MS = 250;
+/** A state that arrives before its own tick is moved back at most this many ticks (it lands up to
+ *  one early: tick t is stepped at its instant and its state is the body at t + 1). */
+declare const BODY_EXTRAPOLATE_BACK_TICKS = 1;
+/** A correction's offset decays as e^(−age / BODY_CORRECTION_TAU_MS). */
+declare const BODY_CORRECTION_TAU_MS = 100;
+/** A correction over this many metres (times lengthUnit, in room units) snaps instead. */
+declare const BODY_SNAP_METRES = 1;
+
+type DrawVec3 = readonly [number, number, number];
+type DrawQuat = readonly [number, number, number, number];
+/** A body's pose as drawn: position in room units, unit orientation [x, y, z, w]. */
+interface BodyPose {
+    p: DrawVec3;
+    q: DrawQuat;
+}
+/** A body entity's §17.10 fields as a decoder holds them (quantized fields already decoded to
+ *  float64, a field never received read as 0 / false). */
+interface BodyFields {
+    x: number;
+    y: number;
+    z: number;
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    lvx: number;
+    lvy: number;
+    lvz: number;
+    avx: number;
+    avy: number;
+    avz: number;
+    sleep: boolean;
+    epoch: number;
+}
+/** One body state off one patch. */
+interface BodyState {
+    /** The tick this state is the body at: the patch's `tick` + 1. */
+    tick: number;
+    /** Position, room units (the server's float32). */
+    p: DrawVec3;
+    /** Orientation, normalized. */
+    q: DrawQuat;
+    /** Linear velocity, metres per second (multiply by lengthUnit for room units). */
+    lv: DrawVec3;
+    /** Angular velocity in world axes, rad/s. */
+    av: DrawVec3;
+    sleep: boolean;
+    epoch: number;
+}
+/** The room facts drawing reads: its tick rate, the room clock at tick 0 (`tickOrigin`) and the
+ *  world's `lengthUnit`. Read fresh per call: `tickOrigin` moves when the server drops steps. */
+interface DrawClock {
+    tickHz: number;
+    tickOrigin: number;
+    lengthUnit: number;
+}
+/** Hamilton product a ⊗ b. */
+declare function quatMul(a: DrawQuat, b: DrawQuat): DrawQuat;
+/** `q` scaled to unit length; a quaternion of length 0 is the identity. */
+declare function quatNormalize(q: DrawQuat): DrawQuat;
+/** slerp(identity, dq, k) for a `dq` with w ≥ 0: the rotation by k·θ about dq's axis, where
+ *  θ = 2·atan2(|v|, w) is dq's own angle. */
+declare function slerpFromIdentity(dq: DrawQuat, k: number): DrawQuat;
+/** The state a patch whose `tick` was `patchTick` carries for a body. */
+declare function bodyStateOf(fields: BodyFields, patchTick: number): BodyState;
+/** How far past its own tick `state` is extrapolated at room-clock instant `at` (ms): seconds in
+ *  [−BODY_EXTRAPOLATE_BACK_TICKS / tickHz, BODY_EXTRAPOLATE_MAX_MS / 1000], and 0 while it sleeps.
+ *  Before its tick (the patch after a step lands up to a tick early) it is moved back, so the body is
+ *  drawn at the present: held there, it was drawn ahead and every state eased in a tick's travel off. */
+declare function extrapolationSeconds(state: BodyState, at: number, clock: DrawClock): number;
+/** `state` extrapolated to room-clock instant `at`: p + (lv · lengthUnit) · Δ, and the orientation
+ *  turned by |av| · Δ about av / |av| (world axes, so on the left), normalized. */
+declare function extrapolateBody(state: BodyState, at: number, clock: DrawClock): BodyPose;
+/** One body as a client draws it: its latest state, and the correction its arrival started. */
+interface BodyDrawing {
+    readonly state: BodyState;
+    /** Room-clock instant the state arrived, ms. */
+    readonly arrivedAt: number;
+    /** Position offset at arrival (older drawn − newer extrapolated), room units. */
+    readonly dp: DrawVec3;
+    /** Orientation offset at arrival (older drawn ⊗ newer⁻¹, w ≥ 0). */
+    readonly dq: DrawQuat;
+}
+/** Why the last state was not eased in. */
+declare const BodySnap: {
+    /** Its first state since it got its descriptor. */
+    readonly SPAWNED: "spawned";
+    readonly EPOCH: "epoch";
+    /** The offset was over one metre. */
+    readonly DISTANCE: "distance";
+};
+type BodySnap = (typeof BodySnap)[keyof typeof BodySnap];
+/** Where `drawing` draws its body at room-clock instant `at`. */
+declare function drawBody(drawing: BodyDrawing, at: number, clock: DrawClock): BodyPose;
+/**
+ * The drawing after `state` arrives at room-clock instant `at`. `previous` is the body's drawing
+ * until now (null when it just got its descriptor, `spawned`). Returns the new drawing and, when it
+ * snapped instead of easing, why.
+ */
+declare function receiveBodyState(previous: BodyDrawing | null, state: BodyState, at: number, clock: DrawClock): {
+    drawing: BodyDrawing;
+    snap: BodySnap | null;
+};
+/** Whether two states are the same body state (every field, the tick aside): a patch that did not
+ *  change the body carries no new state. */
+declare function sameBodyState(a: BodyState, b: BodyState): boolean;
+
+/** Numbers per body in a wire row (C§20.2). */
+declare const WIRE_ROW_STRIDE = 15;
+/** The largest sleep timer a row carries, in inner steps. */
+declare const WIRE_REST_MAX = 65535;
+/** The room's `physDesc` (§17.11 *State*): what a client needs to build the room's world exactly. */
+interface PhysDesc {
+    /** The contract's world description, as the server created the world. */
+    world: PhysicsWorldDesc;
+    /** K: a keyframe is the state after every tick t ≡ 0 (mod K). */
+    keyframeTicks: number;
+    /** The speed clamp: metres per second (× lengthUnit) and rad/s. */
+    maxLinear: number;
+    maxAngular: number;
+    /** The seats' preset bodies (§17.10 *Preset bodies*): a kinematic box of these half-extents,
+     *  `events` its collider's opt-in; null in a room without them. */
+    presetBody: PresetBodyShape | null;
+    /** How the client moves other players' preset bodies (`config.physics.remotePredict`). */
+    remotePredict: RemotePredict;
+    /** `inputDecay`: ms until a repeated input's axes reach 0. */
+    remoteDecayMs: number;
+    /** The lead cap, ms past a keyframe's ack. */
+    leadMs: number;
+}
+/** The client knobs of a predicting room, as `physDesc` carries them. */
+type PhysDescPredict = Pick<PhysDesc, 'remotePredict' | 'remoteDecayMs' | 'leadMs'>;
+/** A preset body's collider as the host spawns it. */
+interface PresetBodyShape {
+    half: [number, number, number];
+    events: boolean;
+}
+/** The state's `physDesc` text: the keys in this order, numbers as JavaScript prints them. */
+declare function physDescText(world: PhysicsWorldDesc, keyframeTicks: number, presetBody: PresetBodyShape | null, predict: PhysDescPredict): string;
+/** Reads `physDesc` text; null when it is absent or not one. */
+declare function parsePhysDesc(text: string | undefined): PhysDesc | null;
+/** One inner step, as the core computes it: `dt / substeps` in float32 (C§20.2). */
+declare function innerDtOf(world: Pick<PhysicsWorldDesc, 'dt' | 'substeps'>): number;
+/** A sleep timer (seconds, float32) in whole inner steps, rounded, at most {@link WIRE_REST_MAX}:
+ *  `min(65535, floor(rest / innerDt + 0.5))` in float64 (C§20.2). */
+declare function restStepsOf(rest: number, innerDt: number): number;
+/** A body entity's fields as a decoder holds them (§17.10 *State*, §17.11's `rest`). */
+interface WireFields {
+    x: number;
+    y: number;
+    z: number;
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    lvx: number;
+    lvy: number;
+    lvz: number;
+    avx: number;
+    avy: number;
+    avz: number;
+    sleep: boolean;
+    rest: number;
+}
+/** The wire row of a body entity's decoded fields, written into `out` at `offset`: a decoded
+ *  quantized value quantizes back to the integer the wire sent (`dequantize` then `quantize` is the
+ *  identity on integers), so the row is exactly what the server's canonical state was. */
+declare function writeWireRow(fields: WireFields, out: Float32Array | number[], offset: number): void;
+/** A core export (`exportChanged(…, { rest: true })`, 15 numbers a body) as the wire row the host
+ *  sends for it, at `lengthUnit` (the world's, as float32): what a client imports. */
+declare function wireRowOfExport(d: ArrayLike<number>, o: number, lengthUnit: number, innerDt: number, out: number[], at: number): void;
+/** A body's replicated state as the core's `exportBodyState(key, { rest: true })` gives it. */
+interface WireBodyState {
+    p: ArrayLike<number>;
+    q: ArrayLike<number>;
+    v: ArrayLike<number>;
+    w: ArrayLike<number>;
+    sleeping: boolean;
+    rest?: number;
+}
+/** A body state as its wire row (the same numbers {@link wireRowOfExport} gives for its export). */
+declare function wireRowOfState(st: WireBodyState, lengthUnit: number, innerDt: number): number[];
+/** A wire row's decoded fields (what a client's decoder would hold for it). */
+declare function wireFieldsOf(row: ArrayLike<number>, o?: number): WireFields;
+type Vec3 = [number, number, number];
+/**
+ * The clamp of one dynamic body's velocities (float32 values off an export): null when neither is
+ * over its bound, else the `setVelocity` arguments that bring the longer ones to it by magnitude,
+ * the other passed as it is. Linear is bounded at `maxLinear · lengthUnit` (lengthUnit the world's
+ * float32), angular at `maxAngular`.
+ */
+declare function clampedVelocity(linvel: readonly number[], angvel: readonly number[], lengthUnit: number, maxLinear?: number, maxAngular?: number): {
+    linvel: Vec3;
+    angvel: Vec3;
+} | null;
+/** The shape kinds that travel by reference: their size grows with their data. */
+declare const SHAPE_REF_KINDS: ReadonlySet<string>;
+/** A room holds at most this many distinct referenced shapes, each at most this many characters of
+ *  JSON; a body whose shape does not fit has no descriptor text and is drawn, never predicted. */
+declare const PHYSICS_SHAPES_MAX = 32;
+declare const PHYSICS_SHAPE_MAX_CHARS: number;
+/** A canonical body descriptor (C§20.5) parsed, its shapes inlined from `shapes` (reference → JSON
+ *  text). Null when the text is not a descriptor or names a shape `shapes` lacks. */
+declare function inlineShapes(descText: string, shapes: (ref: string) => string | undefined): Record<string, unknown> | null;
+/** Islands join bodies whose bounding spheres come within this many metres (× lengthUnit). */
+declare const ISLAND_MARGIN_METRES = 0.5;
+/** A body's bounding radius about its origin, from its (inlined) descriptor: every collider's
+ *  offset plus its shape's radius. */
+declare function bodyRadiusOf(desc: Record<string, unknown>): number;
+/** One body as islands see it: its key, origin and bounding radius (room units). */
+interface IslandBody {
+    key: string;
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+}
+/**
+ * Proximity islands: body key → island id (the island's first key in code-unit order). Two bodies
+ * are joined when the distance between their origins is at most the sum of their radii plus
+ * `margin`, or when a joint links them. Sweeps along x, so it costs about n log n for spread bodies.
+ */
+declare function proximityIslands(bodies: readonly IslandBody[], links: readonly (readonly [string, string])[], margin: number): Map<string, string>;
+/** A motor's canonical text: its keys sorted, every number its float32 (§17.11 *State*). */
+declare function motorText(motor: unknown): string;
+/** A seat's last applied input, as a keyframe carries it (`AuthorityPlayer`'s `in*` fields). */
+interface RemoteInput {
+    moveX: number;
+    moveY: number;
+    moveZ: number;
+    yaw: number;
+    pitch: number;
+    buttons: number;
+}
+/**
+ * `inputDecay`: the weight of a remote seat's repeated input on the `j`-th tick after the keyframe
+ * (j ≥ 1): whole on the first tick, then falling linearly to 0 at `decayMs`, as
+ * clamp(1 − (j − 1) · (1000 / tickHz) / decayMs, 0, 1); with `decayMs` 0, the first tick only.
+ * The movement axes are scaled by it; aim (yaw, pitch) and held buttons are repeated as they are, so
+ * a button's press edge (a jump, a flip, a boost start) is never predicted.
+ */
+declare function remoteInputWeight(j: number, tickHz: number, decayMs: number): number;
+/** The input a remote seat is stepped with on the `j`-th tick after the keyframe. */
+declare function decayedInput(input: RemoteInput, j: number, tickHz: number, decayMs: number): RemoteInput;
+/** A replay's correction decays with τ by its size: TAU_SMALL_MS up to SMALL_METRES, TAU_LARGE_MS from
+ *  LARGE_METRES, linear between; it snaps over SNAP_PLAYER_METRES for a player or vehicle body (its
+ *  physics kind in PLAYER_KINDS) and over SNAP_OTHER_METRES for any other. Physics always takes the
+ *  exact state; only the drawn offset decays. Another seat drawn `predicted` (§17.11 *Drawing other
+ *  seats*) returns its correction to 0 critically damped at 1 / SEAT_TAU_MS (1 / SEAT_CONTACT_TAU_MS
+ *  while it touches your entity in the prediction): it settles to a tenth in about 4 τ (280 ms, a
+ *  first-order τ of 120 ms) without ever jumping the drawn place or velocity, and snaps over
+ *  SEAT_SNAP_METRES or at a new life (epoch). It never pulls a seat drawn moving faster than
+ *  SEAT_MOVING_UNITS_PER_MS (200 u/s) back against that motion while its prediction goes on that way:
+ *  the seat stops instead, and returns from rest once it has stood SEAT_HOLD_MS. Other seats are drawn
+ *  at an input moved on with the frame's time and pulled toward yours at 1 / SEAT_CLOCK_TAU_MS
+ *  (`seatClock`), taken at once past SEAT_CLOCK_SNAP_INPUTS; a seat touching yours is blended onto
+ *  your exact input over SEAT_CLOCK_TAU_MS (§17.11 *Touching*). */
+declare const PredictSmoothing: {
+    readonly TAU_SMALL_MS: 300;
+    readonly TAU_LARGE_MS: 100;
+    readonly SMALL_METRES: 0.25;
+    readonly LARGE_METRES: 1;
+    readonly SNAP_PLAYER_METRES: 2;
+    readonly SNAP_OTHER_METRES: 6;
+    readonly PLAYER_KINDS: readonly string[];
+    readonly SEAT_TAU_MS: 70;
+    readonly SEAT_CONTACT_TAU_MS: 100;
+    readonly SEAT_SNAP_METRES: 6;
+    readonly SEAT_HOLD_MS: 120;
+    readonly SEAT_MOVING_UNITS_PER_MS: 0.2;
+    readonly SEAT_CLOCK_TAU_MS: 100;
+    readonly SEAT_CLOCK_SNAP_INPUTS: 1.5;
+};
+/** The share of a correction still drawn `age` ms after it started, τ `tauMs`: critically damped from
+ *  rest, (1 + age/τ)·e^(−age/τ), so the frame it starts on draws the body where it was drawn (a body
+ *  moving between the predictor's drawing and §17.10's, `DrawHandoff`). */
+declare function correctionShare(age: number, tauMs: number): number;
+/** A replay's correction of one axis `age` ms after it started from offset `o0` (room units) and rate
+ *  `r0` (units per ms), τ `tauMs`, critically damped at h = τ/2 (§17.11 *Drawing*; it trails a steady
+ *  drift by as much as a first-order τ did): the offset (o0 + (r0 + o0/h)·t)·e^(−t/h) and its rate
+ *  (r0 − (r0 + o0/h)·t/h)·e^(−t/h). A new correction starts
+ *  from where the body was drawn and keeps the rate the last one had, so a body corrected on every
+ *  keyframe still comes home, and none is drawn jumping on the frame its correction starts. */
+declare function correctionAt(o0: number, r0: number, age: number, tauMs: number): [number, number];
+/** The τ (ms) of a correction of `metres`. */
+declare function correctionTauMs(metres: number): number;
+/**
+ * §17.11 *Drawing*: a body that moves between the predictor's drawing (the client world's timeline,
+ * ahead) and §17.10's (the server's present) — it entered or left the simulated set — starts a
+ * correction from where it was last drawn, eased like a replay's (τ by its size, snapped past
+ * `snapMetres`), so it never jumps by its velocity times the lead. A new epoch never eases.
+ */
+declare class DrawHandoff {
+    private last;
+    private offset;
+    /** The pose to draw at room-clock `now` (ms) for `pose`, drawn by the predictor or not. */
+    draw(pose: BodyPose, predicted: boolean, epoch: number, now: number, snapMetres: number, lengthUnit: number): BodyPose;
+    private startFrom;
+    private apply;
+}
+/** The distance, metres, past which a body of physics `kind` snaps instead of easing. */
+declare function snapMetresOf(kind: unknown): number;
+
+/** A seat's entity as a seat contact rule sees and changes it (room units, per second). */
+interface ContactBody {
+    id: string;
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    yaw: number;
+    spin?: number;
+    /** The entity's `flags` (a declared contact policy's pair rules read them as `flag:k` tags). */
+    flags?: number;
+}
+/**
+ * A seat contact rule: what the room module does to two seats' entities after every tick's preset
+ * steps (a car-to-car bump), as a pure function of the two, `a` the lower id. It changes their fields
+ * in place. The module must run this very function on the same pairs.
+ */
+type AuthorityContactRule = (a: ContactBody, b: ContactBody) => void;
+/** The fields of your own entity a seat contact rule may change. */
+declare const CONTACT_FIELDS: readonly ["x", "y", "z", "vx", "vy", "vz", "yaw", "spin"];
+type ContactField = (typeof CONTACT_FIELDS)[number];
+/**
+ * One client's seat contacts. A pass is the inputs stepped from one state: `apply` for input `seq`
+ * under the state that consumed your inputs through `ack` starts a new pass when `ack` changed or
+ * `seq` is not after the last input stepped (a replay), taking the other seats from `others()`.
+ */
+declare class SeatContacts {
+    private pass;
+    private readonly rule;
+    /** The other seats' entities in the latest state. */
+    private readonly others;
+    constructor(rule: AuthorityContactRule, others: () => readonly ContactBody[]);
+    /**
+     * After your input `seq` was stepped into `own`: the rule against every other seat, moved on by its
+     * velocity to that input's tick (`seq − ack` ticks after the state, `tickHz` a second), in id order,
+     * `a` the lower id. A seat the rule changed moves on from there. Your fields it changed are written
+     * back as float32 (the entity's wire type).
+     */
+    apply(seq: number, ack: number, own: ContactBody, tickHz: number): void;
+    /**
+     * Another seat `id` where your inputs through `ack + j` meet it (§17.11 *Seat contacts*): the current
+     * pass's seat, moved on by its velocity from the input the rule last changed it at, or the latest
+     * state's when no pass of that `ack` has run. `j` may be fractional (your drawn car is rendered
+     * between two inputs). Undefined for a seat the latest state does not have. (The `predicted` drawing
+     * takes other seats from seat-predict.ts' `SeatWorld` instead.)
+     */
+    seatAt(id: string, ack: number, j: number, tickHz: number): ContactBody | undefined;
+}
+/**
+ * Another seat's drawn pose `seat` moved out of your drawn entity `you` (§17.11 *Drawing other seats*:
+ * a draw-only separation, never your entity, never the state): the contact rule run on copies of the
+ * two at rest, and the seat moved by its own change less yours, so the whole push is the seat's. A rule
+ * that leaves two resting seats as they are (the two do not touch) leaves the seat where it is.
+ */
+declare function separateDrawn(rule: AuthorityContactRule, you: ContactBody, seat: ContactBody): {
+    x: number;
+    y: number;
+    z: number;
+};
+/** A seat drawn against your entity that would go straight across it goes round it instead, at least
+ *  this fast (radians a second about your entity's centre: half a turn in a third of a second), and as
+ *  fast as its own pose moves past yours times ROUND_PER_STRAIGHT (half a circle over its diameter: the
+ *  way round takes as long as the way through). */
+declare const SEAT_ROUND_RATE: number;
+/** Where a seat was drawn against your entity last frame (`separateAround`'s memory, one a seat): its
+ *  offset from your drawn entity, whether it was drawn off its own pose (`held`: moved out of yours or
+ *  going round it), its own pose's offset (`bx`, `by`) and the frame's time (ms). */
+type SeatSide = {
+    dx: number;
+    dy: number;
+    dz: number;
+    held: boolean;
+    bx: number;
+    by: number;
+    at: number;
+    pair?: PairPush;
+};
+/** Two other seats drawn pushed apart (`separateSeats`' memory of a pair that touches, kept with its
+ *  `SeatSide`): the horizontal side the higher id's seat is pushed to from the lower's (`nx`, `ny`, a
+ *  unit vector), chosen once when the two first touch and kept until they part, and how much further
+ *  apart along it the two were drawn last frame than their own poses are (`push`, units). */
+type PairPush = {
+    nx: number;
+    ny: number;
+    push: number;
+};
+/** A seat drawn resting on your entity's roof (or yours on its), its floor a unit or two through it
+ *  from frame to frame as both drawings move, is lifted off it (or let down off it) by up to this much
+ *  (units) rather than pushed out across the ground: a push across from a roof is the whole footprint,
+ *  a pop every frame its floor dips under (the owner's 2026-10-30 report). */
+declare const SEAT_LIFT_MAX = 4;
+/**
+ * `seat` lifted off `you` along z (up when its centre is at or above yours, else down) by the least
+ * amount up to SEAT_LIFT_MAX that leaves the rule nothing to push, or `seat` itself when it does not
+ * touch you or no such lift does (it is beside you, not on you).
+ */
+declare function liftOff(rule: AuthorityContactRule, you: ContactBody, seat: ContactBody): ContactBody;
+/**
+ * Another seat's drawn pose `seat` moved out of your drawn entity `you` without ever being drawn across
+ * it (§17.11 *Drawing other seats*, draw-only), given where it was drawn last frame (`prev`, undefined
+ * for a seat not drawn against yours a frame ago) at `now` (ms). `separateDrawn` pushes the seat out on
+ * the side the rule finds nearest; while the seat the render timeline draws passes through yours, that
+ * side flips when it passes your entity's middle, and the seat leapt across your car between two frames.
+ * So when the straight move from last frame's drawn seat to this frame's separated one goes through your
+ * entity:
+ *  - a seat that was drawn off its own pose (`held`) goes round your entity instead, its heading about
+ *    your centre turning toward the separated one's along an arc ROUND_PER_STRAIGHT times as long as its
+ *    own pose moved past yours since last frame, at least at SEAT_ROUND_RATE, its distance and height
+ *    moving by the same share and never closer than where it stops touching yours;
+ *  - a seat that was drawn on its own pose (it came over your roof, or from far in one frame) is pushed
+ *    out on the side it came from instead, when the separated one is on the other side.
+ * `blocked` (`separateSeats`: the move would sweep it through another seat drawn last frame) takes the
+ * same way as a move through yours. Your entity and the state are never changed. Returns the drawn
+ * position and this frame's memory.
+ */
+declare function separateAround(rule: AuthorityContactRule, you: ContactBody, drawnSeat: ContactBody, prev: SeatSide | undefined, now: number, blocked?: boolean): {
+    x: number;
+    y: number;
+    z: number;
+    side: SeatSide;
+};
+/** The memory key of two other seats' pair in `separateSeats` (where the higher id's seat was drawn
+ *  from the lower's). */
+declare const seatPairKey: (a: string, b: string) => string;
+type Point = {
+    x: number;
+    y: number;
+    z: number;
+};
+/** Two other seats drawn pushed apart ease back toward their own poses at most this fast once less
+ *  push keeps them apart (units a second of the pair's push, half each: 6 units a car in a 60 Hz frame).
+ *  Pushed on whichever side the rule found nearest, two seats the prediction draws a few units from one
+ *  centre were drawn flipping sides every frame, each car 27 u off its pose one way, then the other (the
+ *  contact fix's round 1, 18 of one rtt-200 run's 30 contact jumps). */
+declare const SEAT_PAIR_EASE = 720;
+/**
+ * Every other seat's drawn pose `seats` (the render timeline's) moved out of your drawn entity `you`,
+ * never across it, and out of each other, never across each other (§17.11 *Drawing other seats*,
+ * draw-only), given last frame's memory `prev` (each seat's `SeatSide` by its id, each pair's by
+ * `seatPairKey`) at `now` (ms):
+ *  1. each seat moved out of yours by `separateAround`;
+ *  2. each pair kept on its sides of each other from last frame (`keepSide`): a seat let go off yours
+ *     jumped back to its own pose over the car it was pressed against;
+ *  3. a pile of up to PILE_PASSES passes, until no two touch: each seat drawn into yours moved back
+ *     out of it by the rule, unless that move would cross yours from where step 1 drew it (then it is
+ *     drawn there), then every two seats that touch pushed apart by the rule, half each; the last
+ *     pass ends with the step out of yours.
+ * A seat moved out of yours could otherwise land in a third car (two cars the timeline draws inside
+ * yours are both pushed to your side; one taken round your car swept through one against it). Your
+ * entity and the state are never changed, and no seat is left inside yours. Returns each seat's drawn
+ * position by id and this frame's memory (a seat is `held` when drawn off its own pose).
+ */
+declare function separateSeats(rule: AuthorityContactRule, you: ContactBody, seats: readonly ContactBody[], prev: ReadonlyMap<string, SeatSide>, now: number): {
+    drawn: Map<string, Point>;
+    sides: Map<string, SeatSide>;
+};
+/**
+ * A seat rule (§17.11 *Seat rules*): what the room module does to a seat's own entity at a tick it
+ * announced in advance (a kickoff that releases held cars on tick `go`), as a function of the entity's
+ * fields and the tick that seat's input is applied on. It changes the fields in place, before that
+ * input's step. The client runs it on your own entity before each predicted input, with that input's
+ * sequence `seq` (so a rule can key what it predicts to one of your inputs: an input fired at `s` was
+ * applied on `tick − (seq − s)`), and, in an `inputDecay` room, on each other seat's body before each
+ * of its steps (no `seq`).
+ */
+type AuthoritySeatRule = (seat: Record<string, number>, tick: number, seq?: number) => void;
+/** The tick your input `seq` is applied on, predicted from a state of tick `stateTick` that consumed
+ *  your inputs through `ack`: a predicting room feeds one input a tick (§17.11 *Input pacing*). */
+declare const seatRuleTick: (stateTick: number, ack: number, seq: number) => number;
+
+type PredictResult<T extends object = Record<never, never>> = ({
+    ok: true;
+} & T) | {
+    ok: false;
+    code: string;
+    detail?: string;
+};
+type V3 = [number, number, number];
+type Q4 = [number, number, number, number];
+/** One world of the game's core. */
+interface PredictWorld {
+    readonly tick: number;
+    addStaticWorld(world: {
+        boxes: number[][];
+        ramps: number[][];
+    }): PredictResult;
+    spawn(desc: unknown): PredictResult;
+    remove(key: string): PredictResult;
+    addJoint(desc: unknown): PredictResult;
+    removeJoint(key: string): PredictResult;
+    setMotor(key: string, motor: unknown): PredictResult;
+    setVelocity(key: string, linvel?: V3, angvel?: V3): PredictResult;
+    setNextKinematicPose(key: string, pose: {
+        p: V3;
+        q: Q4;
+    }): PredictResult;
+    importWire(keys: string[], rows: Float32Array | number[]): PredictResult;
+    canonicalize(options?: {
+        quantize?: boolean;
+    }): PredictResult;
+    step(): PredictResult<{
+        escaped: string[];
+    }>;
+    exportChanged(sinceTick: number, options?: {
+        rest?: boolean;
+    }): {
+        keys: string[];
+        data: Float32Array;
+    };
+    exportBodyState(key: string, options?: {
+        rest?: boolean;
+    }): WireBodyState | null;
+    stateHash(): string;
+    physicsHash(): string;
+    free(): void;
+}
+/** The game's loaded core: `@genex-ai/physics` after `init()`. */
+interface PredictCore {
+    buildId(): string;
+    World: {
+        create(desc: unknown): PredictResult<{
+            world: PredictWorld;
+        }>;
+    };
+}
+/** A module body in the client's view at the keyframe. */
+interface KeyframeBody {
+    key: string;
+    /** The canonical descriptor with its shapes inlined (C§20.5), or null: drawn, never predicted. */
+    desc: Record<string, unknown> | null;
+    /** The wire row (15 numbers, `importWire`'s form). */
+    row: ArrayLike<number>;
+    /** Its entity's epoch: a body the module respawned (a bump) is a deliberate discontinuity, never a
+     *  sample of the canary. */
+    epoch?: number;
+}
+/** A body the client knows but that is out of its view: where it last was (for islands only). */
+interface KeyframeOutside {
+    key: string;
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+}
+/** A seat's own entity (its preset body's pose, §17.10 *Preset bodies*). */
+interface KeyframeSeat {
+    /** The entity id: the preset body's key. */
+    key: string;
+    /** The entity's float32 position, and velocity in room units per second. */
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    epoch: number;
+    /** This client's own entity. */
+    own: boolean;
+    /** The seat's last applied input at the keyframe (`inputDecay` rooms; absent: extrapolated). */
+    input?: RemoteInput;
+    /** The entity's fields a {@link RemoteStep} reads (its x, y, z at least); absent: x, y, z. */
+    body?: Record<string, number>;
+}
+/** `inputDecay`: one fixed step of a remote seat's entity under `input` (the room preset's own step,
+ *  or a game's), mutating `body`; the predictor reads its x, y and z. */
+/** A remote seat's step under its held or decayed input, in the tick `tick` it runs in (a lift's carry
+ *  reads it: §17.11 *Lifts*). */
+type RemoteStep = (body: Record<string, number>, input: RemoteInput, dt: number, tick: number) => void;
+/** A room's declared lifts as a client world poses them (§17.11 *Lifts* step 9): the policy and the
+ *  called lifts' starts as the latest state has them. */
+interface PredictLifts {
+    readonly policy: LiftsPolicy;
+    readonly starts: ReadonlyMap<string, number> | undefined;
+}
+/** A joint (§17.11 *State*), its descriptor and the motor last set, parsed. */
+interface KeyframeJoint {
+    key: string;
+    desc: Record<string, unknown>;
+    motor: Record<string, unknown> | null;
+}
+/** One keyframe: the room state after tick `tick`, and how many of this client's inputs the server had
+ *  consumed by then. */
+interface PredictKeyframe {
+    tick: number;
+    ack: number;
+    bodies: readonly KeyframeBody[];
+    outside: readonly KeyframeOutside[];
+    joints: readonly KeyframeJoint[];
+    seats: readonly KeyframeSeat[];
+}
+/** Your predicted entity's position after input `seq` (room units), or undefined when unknown. */
+type OwnPoseOf = (seq: number) => DrawVec3 | undefined;
+/** A seat's entity at one predicted tick, as a body rule reads it: position (room units) and velocity
+ *  (room units per second). */
+interface RuleSeat {
+    key: string;
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    /** The heading, radians, where the seat's body carries one (the contact pass reads it). */
+    yaw?: number;
+}
+/** What a body rule reads at a predicted tick: every seat's entity at that tick (key order) and a
+ *  simulated dynamic body's state after the previous tick's step (room units, per second). */
+interface RuleTick {
+    tick: number;
+    seats: readonly RuleSeat[];
+    body(key: string): {
+        p: DrawVec3;
+        v: DrawVec3;
+    } | null;
+}
+/** A velocity a body rule sets (room units per second), as the module's `setVelocity` would. */
+interface RuleVelocity {
+    key: string;
+    v: DrawVec3;
+}
+/**
+ * A body rule (§17.11 *Body rules*): what the room module does each tick to its dynamic bodies'
+ * velocities from the seats' entities and the bodies' states (a scripted hit on a ball), as a pure
+ * function. The module runs this very function in its `step` and sends what it returns as
+ * `setVelocity` commands; the client world runs it before every predicted step.
+ */
+type PredictBodyRule = (tick: RuleTick) => readonly RuleVelocity[];
+/**
+ * A kinematic rule (§17.11 *Kinematic rules*): where the room module poses one of its kinematic bodies
+ * (a door, a platform, a moving floor) at tick `tick`, as a pure function of the body's key and the tick
+ * (its keyframed schedule), or null for a body it does not pose. The module issues
+ * `setNextKinematicPose(key, rule(key, t + 1))` in its step of tick t; the client world does the same
+ * before every predicted step and draws the body as a predicted one.
+ */
+type PredictKinematicRule = (key: string, tick: number) => {
+    p: DrawVec3;
+    q: DrawQuat;
+} | null;
+/** §17.11 *Kinematic rules*: where `rule` poses `key` at room-clock instant `at` on the server's own
+ *  timeline (its pose for tick T stands at `tickOrigin + T / tickHz`), between the two ticks around `at`;
+ *  null when the rule does not pose `key`. What a client draws for a ruled body whenever the predictor
+ *  does not draw it (no core, `cpu`, any fallback level), in place of §17.10's extrapolation. */
+declare function ruledPoseAt(rule: PredictKinematicRule, key: string, at: number, clock: {
+    tickHz: number;
+    tickOrigin: number;
+}): BodyPose | null;
+/** A ruled body outside the simulated set follows the world's timeline at a rate within this share of
+ *  the room clock's (§17.11 *Kinematic rules*): a 3-tick shift is absorbed in 30 ticks. */
+declare const RULED_SLEW = 0.1;
+/** Past this many ticks off the world's timeline the ruled clock snaps to it. */
+declare const RULED_SNAP_TICKS = 30;
+/** A replay's budget, ms, desktop and mobile: what the rolling window of replay costs is judged
+ *  against (§17.11 *Budgets*). */
+declare const PHYS_RESIM_BUDGET_MS: {
+    readonly desktop: 4;
+    readonly mobile: 5;
+};
+/** The replay budget in use: `override` (the connect option `physicsBudgetMs`) when it is a finite
+ *  number over 0, else the device's `deviceMs`. Anything else is ignored, never thrown: a bench or CI
+ *  holds every engine to one budget this way; a game leaves it unset. */
+declare function physicsBudgetMs(override: unknown, deviceMs: number): number;
+/** The simulated set's sizes: the next one that chooses fewer bodies is taken when replays run over
+ *  budget; with none left, `cpu`. */
+declare const PHYS_PREDICT_SET_SIZES: readonly number[];
+/** The rolling window of replay costs (wall clock around the rebuild and replay only): the latest
+ *  this many replays, judged once it holds PHYS_BUDGET_MIN_SAMPLES. */
+declare const PHYS_BUDGET_WINDOW = 60;
+declare const PHYS_BUDGET_MIN_SAMPLES = 20;
+/** Over budget: the window's median over the budget, or its p90 over this many budgets. A single
+ *  replay (a GC pause, the OS taking the thread) never decides. */
+declare const PHYS_BUDGET_P90_FACTOR = 2;
+/** Calm: the window's p90 (or a probe) at or under this share of the budget. A smaller set grows back
+ *  one size after a full calm window; `cpu` turns on again after PHYS_CPU_CALM_PROBES calm probes. */
+declare const PHYS_BUDGET_CALM_SHARE = 0.5;
+/** In `cpu`, one keyframe in this many ms is adopted by a full replay (a probe, never drawn). */
+declare const PHYS_CPU_PROBE_MS = 500;
+/** Calm probes in a row that turn prediction on again. */
+declare const PHYS_CPU_CALM_PROBES = 4;
+/** The set size to shrink to from `current` when the last choice took `chosen` bodies: the next size
+ *  under `chosen` (a size at or over it would choose the same bodies), or null when none is left. */
+declare function nextPredictSetSize(current: number, chosen: number): number | null;
+/** The runtime canary: over this many pure body-keyframes, more than this share mismatched is `diverged`. */
+declare const PHYS_CANARY_WINDOW = 500;
+declare const PHYS_CANARY_MAX_MISMATCH = 0.02;
+/** The canary judges no window smaller than this. */
+declare const PHYS_CANARY_MIN_SAMPLES = 200;
+/** Why bodies are (not) predicted. */
+declare const PredictStatus: {
+    /** Predicting. */
+    readonly ON: "on";
+    /** Turned off: by the client (`predictPhysics: false`), the room or the operator. */
+    readonly OFF: "off";
+    /** Waiting for the core or the first keyframe. */
+    readonly LOADING: "loading";
+    /** No core was handed over, or it failed to load. */
+    readonly UNAVAILABLE: "unavailable";
+    /** Level 1: the room's physicsHash or world description is not this client's. */
+    readonly MISMATCH: "mismatch";
+    /** Level 2: the core failed its self-test scene at load. */
+    readonly SELF_TEST: "self_test";
+    /** Level 3: the runtime canary saw more than 2% of pure bodies mismatch. */
+    readonly DIVERGED: "diverged";
+    /** Replays run over budget at the smallest set that helps: drawn §17.10's way, probing every
+     *  PHYS_CPU_PROBE_MS until calm, then on again. */
+    readonly CPU: "cpu";
+};
+type PredictStatus = (typeof PredictStatus)[keyof typeof PredictStatus];
+interface PredictorOptions {
+    /** The room's physDesc. */
+    desc: PhysDesc;
+    /** The static world (§17.7's `{ boxes, ramps }`); none is the empty world. */
+    staticWorld?: {
+        boxes: number[][];
+        ramps: number[][];
+    } | null;
+    /** The room's physicsHash: the client world must have it. */
+    physicsHash: string;
+    /** The room's tick rate. */
+    tickHz: number;
+    /** A replay's budget, ms (default the desktop one). */
+    budgetMs?: number;
+    /** The clock replays are timed on, ms (default `performance.now`). */
+    clock?: () => number;
+    /** How a remote seat steps under its decayed input (`physDesc.remotePredict` `inputDecay`); without
+     *  one every remote seat is extrapolated. */
+    remoteStep?: RemoteStep;
+    /** The lead cap, ms (default `physDesc.leadMs`). */
+    leadMs?: number;
+    /** The room module's seat rule (§17.11 *Seat rules*), run on each other seat's body before each of
+     *  its `inputDecay` steps (the step's tick: the keyframe's plus j). */
+    seatRule?: AuthoritySeatRule;
+    /** The room module's body rule (§17.11 *Body rules*); none: module commands arrive as corrections. */
+    bodyRule?: PredictBodyRule;
+    /** The room's declared `propSlide` under `headFriction: slide` (§17.11 *Contact policy*), else null:
+     *  preset hulls are then frictionless and the built-in prop rule runs after the module's. */
+    headSlide?: () => PropSlide | null;
+    /** The room module's kinematic rule (§17.11 *Kinematic rules*); none: every module kinematic body
+     *  holds the keyframe's pose and is drawn from the server's states. */
+    kinematicRule?: PredictKinematicRule;
+    /** The room's declared lifts (§17.11 *Lifts* step 9), else null: each a kinematic body `lift.<id>`
+     *  the client world poses at P(t + 1) in each predicted tick t (at P(keyframe + 1) on a rebuild), and
+     *  the built-in conveyor rule after the module's body rule. */
+    lifts?: () => PredictLifts | null;
+    /** Another seat's entity after the tick of your input `seq`, as the session's seat prediction has it
+     *  (§17.11 *Drawing other seats* `predicted`: stepped under its held input with the room's contact
+     *  pass); when it answers, it poses that seat's preset body, else the seat is moved as
+     *  `remotePredict` says. */
+    seatPose?: (key: string, seq: number) => RuleSeat | undefined;
+    /** The room's seat contact pass (§17.11 *Contact policy*, the declared one or the module's), run on
+     *  each predicted tick's seats in id order before they pose their preset bodies, on ticks where the
+     *  session's seat prediction posed none of them (that prediction runs the pass itself). */
+    contactPass?: (seats: ContactBody[]) => void;
+    /** How many of the latest per-tick stateHashes `hashes` keeps (default {@link PHYS_PREDICT_HASHES_KEPT};
+     *  a conformance run keeps all). */
+    hashesKept?: number;
+}
+/** The per-tick client stateHashes a predictor keeps by default (diagnostics only). */
+declare const PHYS_PREDICT_HASHES_KEPT = 600;
+/** What one keyframe's adoption did. */
+interface AdoptReport {
+    /** `match`: skip-on-match; `replay`: imported and replayed; `none`: not predicting. */
+    kind: 'match' | 'replay' | 'none';
+    /** Inputs replayed. */
+    replayed: number;
+    /** Replay time, ms. */
+    ms: number;
+    /** Pure bodies compared and mismatched (the canary's sample). */
+    pure: number;
+    mismatched: number;
+}
+/**
+ * One room's predictor. `adopt` each keyframe, `advance` once per input you send (with your predicted
+ * pose after it), and `draw` a body at render time; `stateHash` reads the client world.
+ */
+declare class PhysicsPredictor {
+    status: PredictStatus;
+    private readonly core;
+    private readonly desc;
+    private readonly tickHz;
+    private readonly innerDt;
+    private readonly lengthUnit;
+    private readonly leadMax;
+    private readonly budgetMs;
+    private readonly clock;
+    private readonly remoteStep;
+    private readonly hashesKept;
+    private world;
+    /** The keyframe the world was last rebuilt from or matched: its tick and ack. */
+    private base;
+    /** The last input stepped (the world is at base.tick + (seq − base.ack)). */
+    private seq;
+    /** Simulated module bodies: key → its type, and the descriptors they were spawned from. */
+    private simulated;
+    /** Seats' preset bodies: key → their keyframe pose and velocity (remotes are extrapolated). */
+    private seats;
+    /** Module kinematic bodies' keyframe rows, extrapolated each tick. */
+    private kinematic;
+    private joints;
+    /** Wire rows the world predicted at each keyframe tick it stepped through. */
+    private ring;
+    /** Bodies in islands with nothing but module dynamic bodies (the canary's sample). */
+    private pure;
+    private drawn;
+    /** Simulated bodies' physics kinds (their snap distance). */
+    private kinds;
+    /** The fractional tick ruled bodies outside the simulated set are drawn at (§17.11 *Kinematic rules*):
+     *  the world's timeline, slewed so a replay that moves it never jumps or reverses them. */
+    private ruledClock;
+    private ownPose;
+    private ownVelocity;
+    private readonly bodyRule;
+    private readonly headSlide;
+    /** The prop rule's view of the dynamic bodies after the last step (the clamp's export, its clamped
+     *  velocities), as the host keeps it; null after a rebuild until read whole once. */
+    private propStates;
+    /** Whether a keyframe's canonicalize quantized the velocities since `propStates` was read (its places
+     *  are float32 on the wire, so they stand): the bodies a rule's place test picks are read again. */
+    private propStale;
+    private readonly kinematicRule;
+    private readonly lifts;
+    /** The lift bodies this world holds, by key, and the policy they were spawned from. */
+    private liftBodies;
+    private readonly seatRule;
+    private readonly seatPose;
+    private readonly contactPass;
+    /** Whether the seat `seatAt` last gave came from the session's seat prediction. */
+    private posedBySeats;
+    /** `inputDecay`: each remote seat's body as last stepped, `j` ticks from the keyframe seat `from`. */
+    private remoteBodies;
+    private setSize;
+    /** The latest replay costs, ms (the budget's rolling window). */
+    private costs;
+    /** In `cpu`: when the last probe ran (the clock `adopt` is given), and calm probes in a row. */
+    private probedAt;
+    private calmProbes;
+    /** How many bodies the last choice took. */
+    private chosenCount;
+    /** How many times the budget turned prediction off, and on again. */
+    fallbacks: number;
+    recoveries: number;
+    /** When the world last stepped (the clock `adopt`, `advance` and `draw` are given), ms. */
+    private steppedAt;
+    private canary;
+    /** Each body's epoch at the last keyframe (the canary skips a body whose epoch moved). */
+    private epochs;
+    /** The client stateHash after each predicted tick, newest last (the conformance runner reads it). */
+    readonly hashes: {
+        tick: number;
+        hash: string;
+    }[];
+    constructor(core: PredictCore, options: PredictorOptions);
+    /** Whether bodies are predicted now (else the session draws them §17.10's way). */
+    get predicting(): boolean;
+    /** Whether the predictor stopped for good (its world freed): every status but `on`, `loading` and
+     *  `cpu`, which probes its way back. */
+    get stopped(): boolean;
+    /** Whether `key` is a body this predictor draws. */
+    draws(key: string): boolean;
+    /** A body the room's kinematic rule poses that the world does not simulate (out of view, or its
+     *  island not chosen): drawn by the rule on the world's timeline all the same (§17.11 *Kinematic
+     *  rules*), so it never jumps between the client's timeline and the server's present. */
+    private ruledElsewhere;
+    /** The client world's stateHash (C§10.1), '' without a world. */
+    stateHash(): string;
+    /** Stops predicting for good (a fallback, or the session ended). */
+    stop(status: PredictStatus): void;
+    /**
+     * Adopts a keyframe. `sent` is your last input's sequence; `ownPose` your predicted position after
+     * each of them, `ownVelocity` your predicted velocity (room units per second; a body rule reads it,
+     * absent: your entity's keyframe velocity). Returns what it did.
+     */
+    adopt(kf: PredictKeyframe, sent: number, ownPose: OwnPoseOf, now: number, ownVelocity?: OwnPoseOf): AdoptReport;
+    /** One predicted tick for input `seq`, sent at `now` (call it after sending that input): nothing
+     *  past the lead cap or before the first keyframe. */
+    advance(seq: number, now: number): void;
+    /** Where a predicted body is drawn at `now` (the clock `adopt` and `advance` were given): its present
+     *  pose moved on by its velocities for the time since the world last stepped (at most one tick, none
+     *  while it sleeps), plus the decaying correction. */
+    draw(key: string, now: number): BodyPose | null;
+    /** The bodies this client simulates: whole proximity islands of bodies in view with a descriptor,
+     *  none of whose members is out of view, nearest your own entity first, up to the set size. */
+    private choose;
+    /** Skip-on-match: the keyframe is exactly what the world predicted for its tick. */
+    private compare;
+    private sameJoints;
+    /** Every seat's preset body is where the world had it at the keyframe tick. */
+    private sameSeats;
+    private noteCanary;
+    /** §17.11 *Budgets*: the replay's cost joins the rolling window; once it holds enough, a window
+     *  over budget shrinks the set to the next size that chooses fewer bodies, or falls back to `cpu`,
+     *  and a full calm window grows a shrunken set back one size. */
+    private judgeBudget;
+    /** `cpu`: bodies are drawn §17.10's way; the world stays for the probes. */
+    private fallBack;
+    /** A probe's cost: PHYS_CPU_CALM_PROBES calm ones in a row turn prediction on again. */
+    private judgeProbe;
+    private jointsOf;
+    /** The bodies the last `choose` picked. */
+    private chosenKeys;
+    private chosenHas;
+    /** The seats whose preset bodies the room has: inside the world (§17.10 *Preset bodies*). */
+    private seatsOf;
+    /** A preset body's centre for an entity at float32 (x, y, z): half its height up, as float32. */
+    private presetPosition;
+    /** The world brought to the keyframe: bodies, joints and seats spawned or removed to match, every
+     *  state imported, then canonicalized. False when the core refused what the server accepted. */
+    private rebuild;
+    /** The room's lift bodies brought to the keyframe (§17.11 *Lifts* step 9): spawned once (again when
+     *  the policy changes), each with its wire row at P(tick + 1), still; null when the core refused one. */
+    private rebuildLifts;
+    private rebuildSeats;
+    private stepOnce;
+    /** A seat's entity `j` ticks after the keyframe: yours from your prediction; a remote one from the
+     *  session's seat prediction when it has it, else by its last input held (`hold`) or repeated and
+     *  decayed (`inputDecay`), else extrapolated by its velocity. */
+    private seatAt;
+    /** The room's contact pass on this tick's seats (copies, ids ascending), their poses and velocities
+     *  taken from what it left (§17.11 *Contact policy*: the replay runs the server's pass). */
+    private passSeats;
+    /** §17.11 *Body rules*: the room's rule on this tick's seats and the bodies as the last step left
+     *  them, its velocities set on the simulated dynamic bodies it names, in its order, before the step. */
+    private applyBodyRule;
+    /** After a keyframe's canonicalize: the bodies the built-in rules pick by place (over a seat's top,
+     *  over a conveyor) read again, so their quantized velocities are the host's; the rest keep theirs
+     *  until the step's export (a 128-body read every keyframe was a third of a replay's cost). */
+    private freshenPicked;
+    /** The speed clamp, on the simulated dynamic bodies, in key order (the export's). */
+    private clamp;
+    /** The wire rows of every simulated body and seat after a keyframe tick's canonicalize (seats under
+     *  `seat:<key>`), each read on its own: an export lists no body asleep since before the tick. */
+    private rowsNow;
+    /** A ruled body outside the world as drawn at `now`: the rule's pose at the ruled clock's tick. */
+    private ruledDrawn;
+    /** The ruled clock at `now`: it runs with the room clock and slews toward the world's timeline (the
+     *  last stepped tick plus one, toward the next by the time since that step, at most one tick) by
+     *  at most RULED_SLEW of the time passed, so a replay that moves the timeline (the server ran a tick
+     *  without your input, or took two in one) is absorbed without a jump or a reversal; past
+     *  RULED_SNAP_TICKS it snaps. */
+    private ruledTick;
+    /** Whether the room's kinematic rule poses module kinematic body `key` (at the world's tick). */
+    private ruled;
+    /** Keeps only the ring's keyframes after `tick`. */
+    private prune;
+    /** The simulated bodies' present states, from the bodies changed after `since`. */
+    private readDrawn;
+    /** Each predicted body's present pose with its correction at `now` (no extrapolation): where a
+     *  replay's correction starts from. The decay is memoryless, so a replay that changes nothing leaves
+     *  the drawing as it was. */
+    /** Every simulated body's present state, each read on its own (after a rebuild). */
+    /** Whether a built-in body rule runs (the prop rule under `headFriction: slide`, the conveyor rule). */
+    private builtInRules;
+    private readAll;
+    private snapshotDrawn;
+    /** A body's snap distance, room units, by its physics kind (§17.11 *Drawing*). */
+    private snapOf;
+    /** After a replay: each body that moved starts a correction from where it was drawn: `dp = old −
+     *  new`, `dq = old ⊗ new⁻¹` the short way, its τ by its size in metres, snapped past its snap
+     *  distance (§17.11 *Drawing*); a body in `respawned` (a new life) snaps. The world itself always holds
+     *  the exact state. */
+    private ease;
+}
+/**
+ * Whether the core keeps the promise prediction rests on, on this device: a world stepped, then
+ * canonicalized with `quantize`, and a second world built from the same descriptors that imports its
+ * wire rows and canonicalizes, step on with equal stateHashes. False also when the core refuses any of it.
+ */
+declare function selfTestPredictCore(core: PredictCore): boolean;
+/** Whether this runtime runs WebAssembly SIMD (every current browser; Safari since 16.4). Where it
+ *  does not, load the core with its non-SIMD module (`init({ module })`): the same stateHashes. */
+declare function wasmSimdSupported(): boolean;
+
+export { PHYSICS_PREDICT_MAX_RAMPS as $, type AuthorityContactRule as A, BODY_CORRECTION_TAU_MS as B, type ContactBody as C, type DrawClock as D, type KeyframeSeat as E, PHYSICS_BODY_FIELDS as F, PHYSICS_CEILING_FACTOR as G, HOST_BODY_FIELDS as H, ISLAND_MARGIN_METRES as I, PHYSICS_CONTESTED_METRES as J, type KeyframeBody as K, PHYSICS_CONTRACT as L, PHYSICS_DEFAULT_CEILING as M, PHYSICS_DEFAULT_LIMITS as N, type OwnPoseOf as O, type PhysicsCeiling as P, PHYSICS_DEFAULT_PATCH_HZ as Q, type RemoteInput as R, PHYSICS_FULL_RATE_BODIES as S, PHYSICS_KEY_MAX_BYTES as T, PHYSICS_KIND_MAX_BYTES as U, PHYSICS_LIMIT_NAMES as V, PHYSICS_OVERLAP_MAX_KEYS as W, PHYSICS_PATCH_HZ as X, PHYSICS_PREDICT_MAX_ANGULAR as Y, PHYSICS_PREDICT_MAX_BOXES as Z, PHYSICS_PREDICT_MAX_LINEAR as _, type PhysEvRow as a, clampedVelocity as a$, PHYSICS_PREDICT_MIN_ITERATIONS as a0, PHYSICS_PRESET_LENGTH_UNITS as a1, PHYSICS_REAL_LIMITS as a2, PHYSICS_ROTATING_BODIES as a3, PHYSICS_SCALED_LIMITS as a4, PHYSICS_SHAPES_MAX as a5, PHYSICS_SHAPE_MAX_CHARS as a6, PHYSICS_STATIC_PIECE_BYTES as a7, PHYSICS_STATIC_PREFIX as a8, PHYSICS_SUBSTEPS as a9, type PredictKeyframe as aA, type PredictLifts as aB, type PredictResult as aC, PredictSmoothing as aD, type PredictWorld as aE, type PredictorOptions as aF, type PresetBodyShape as aG, type QuantizedRange as aH, RULED_SLEW as aI, RULED_SNAP_TICKS as aJ, type RemoteStep as aK, type RuleSeat as aL, type RuleTick as aM, type RuleVelocity as aN, SEAT_LIFT_MAX as aO, SEAT_PAIR_EASE as aP, SEAT_ROUND_RATE as aQ, SHAPE_REF_KINDS as aR, SeatContacts as aS, type SeatSide as aT, WIRE_REST_MAX as aU, WIRE_ROW_STRIDE as aV, type WireBodyState as aW, type WireFields as aX, bodyRadiusOf as aY, bodyStateOf as aZ, checkResolvedPhysics as a_, PHYS_BUDGET_CALM_SHARE as aa, PHYS_BUDGET_MIN_SAMPLES as ab, PHYS_BUDGET_P90_FACTOR as ac, PHYS_BUDGET_WINDOW as ad, PHYS_CANARY_MAX_MISMATCH as ae, PHYS_CANARY_MIN_SAMPLES as af, PHYS_CANARY_WINDOW as ag, PHYS_CPU_CALM_PROBES as ah, PHYS_CPU_PROBE_MS as ai, PHYS_PREDICT_HASHES_KEPT as aj, PHYS_PREDICT_SET_SIZES as ak, PHYS_RESIM_BUDGET_MS as al, type PairPush as am, type PhysDesc as an, type PhysDescPredict as ao, type PhysEvContactBegin as ap, PhysEvKind as aq, type PhysEvOther as ar, type PhysHitRow as as, type PhysOverlapRow as at, type PhysicsBodyField as au, PhysicsConfigRange as av, PhysicsPredictRange as aw, PhysicsPredictor as ax, type PhysicsResolution as ay, type PhysicsWorldDesc as az, type PhysAnswerRow as b, correctionAt as b0, correctionShare as b1, correctionTauMs as b2, decayedInput as b3, dequantizeBodyValue as b4, drawBody as b5, effectivePatchHz as b6, extrapolateBody as b7, extrapolationSeconds as b8, inlineShapes as b9, seatPairKey as bA, seatRuleTick as bB, selfTestPredictCore as bC, separateAround as bD, separateDrawn as bE, separateSeats as bF, slerpFromIdentity as bG, snapMetresOf as bH, solverIterationsOf as bI, wasmSimdSupported as bJ, wireFieldsOf as bK, wireRowOfExport as bL, wireRowOfState as bM, writeWireRow as bN, innerDtOf as ba, isPhysicsKey as bb, isPhysicsKind as bc, isPhysicsPatchHz as bd, keyframeTicks as be, liftOff as bf, motorText as bg, nextPredictSetSize as bh, parsePhysDesc as bi, physDescText as bj, physicsBudgetMs as bk, physicsCeilingValid as bl, physicsLimitsAt as bm, physicsLimitsForWorld as bn, physicsWorldDesc as bo, physicsWorldPredicts as bp, proximityIslands as bq, quantizeBodyValue as br, quatMul as bs, quatNormalize as bt, receiveBodyState as bu, remoteInputWeight as bv, resolvePhysicsConfig as bw, restStepsOf as bx, ruledPoseAt as by, sameBodyState as bz, type PhysBodyRow as c, PredictStatus as d, type AuthoritySeatRule as e, type PredictCore as f, type PredictBodyRule as g, type PredictKinematicRule as h, type AdoptReport as i, BODY_EXTRAPOLATE_BACK_TICKS as j, BODY_EXTRAPOLATE_MAX_MS as k, BODY_SNAP_METRES as l, type BodyDrawing as m, type BodyFields as n, type BodyPose as o, BodyQuantization as p, BodySnap as q, type BodyState as r, CONTACT_FIELDS as s, type ContactField as t, DrawHandoff as u, type DrawQuat as v, type DrawVec3 as w, type IslandBody as x, type KeyframeJoint as y, type KeyframeOutside as z };