lecodes-sdk 0.20.2 → 1.1.0

package/dist/types/gl/{NavAgent.d.ts → nav/NavAgent.d.ts}

@@ -1,8 +1,8 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import { Vec3, type Vec3Like } from "../math/vec";
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import { Vec3, type Vec3Like } from "../../math/vec";
 import { NavCrowd } from "./NavMesh";
-import type { Node } from "./Node";
+import type { Node } from "../Node";
 export type NavAgentState = "idle" | "moving" | "arrived" | "blocked" | "offmesh";
 export type NavAgentAvoidance = "off" | "low" | "medium" | "high";
 export type NavAgentDrive = "position" | "controller";

package/dist/types/gl/{NavMesh.d.ts → nav/NavMesh.d.ts}

@@ -1,7 +1,7 @@
-import { System } from "../core/Aspect";
-import { Vec3, type Vec3Like } from "../math/vec";
-import type { Node } from "./Node";
-import type { Scene } from "./Scene";
+import { System } from "../../core/Aspect";
+import { Vec3, type Vec3Like } from "../../math/vec";
+import type { Node } from "../Node";
+import type { Scene } from "../Scene";
 export declare const NAV_AGENT: {
     readonly RADIUS: 0;
     readonly HEIGHT: 1;

package/dist/types/gl/{CharacterController.d.ts → physics/CharacterController.d.ts}

@@ -1,8 +1,8 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import { Vec3, type Vec2Like, type Vec3Like } from "../math/vec";
-import type { CompWriter } from "../core/compWrite";
-import type { Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import { Vec3, type Vec2Like, type Vec3Like } from "../../math/vec";
+import type { CompWriter } from "../../core/compWrite";
+import type { Node } from "../Node";
 /** Where the character's feet are, as reported by the solver after the last step. */
 export type GroundState = "ground" | "slope" | "unsupported" | "air";
 export declare class CharacterController extends Aspect<"controller", Node> implements CompWriter {

package/dist/types/gl/{Physics.d.ts → physics/Physics.d.ts}

@@ -1,8 +1,8 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import type { CompAxis, CompWriter } from "../core/compWrite";
-import { Vec3, type Vec3Like } from "../math/vec";
-import { type Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import type { CompAxis, CompWriter } from "../../core/compWrite";
+import { Vec3, type Vec3Like } from "../../math/vec";
+import { type Node } from "../Node";
 export type MotionType = "static" | "dynamic" | "kinematic";
 export interface PhysicsConfig {
     /** Gravity in world units/s² (Y-up: down is negative). Default [0, -9.81, 0]. */
@@ -57,6 +57,7 @@ export declare class Physics extends Aspect<"physics", Node> implements CompWrit
     /** Scene-editor inspector: `motion` as a dropdown (a string default alone infers a text box). */
     static fields: FieldMeta<Physics>;
     private _bodyId;
+    private static _refusedWarned;
     onAttach(): void;
     onDetach(): void;
     /** Native Jolt body id. 0 until attached, or if the build has no physics support. */

package/dist/types/gl/physics/Ragdoll.d.ts

@@ -0,0 +1,161 @@
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import { type Vec3Like } from "../../math/vec";
+import { Node } from "../Node";
+export interface RagdollHinge {
+    /** The hinge axis in the MODEL's space (its rest pose: +Z forward, +Y up, +X the model's left in
+     *  glTF). Perpendicular to the bone; the engine drops any component along it. */
+    axis: Vec3Like;
+    /** The bend range about `axis` in degrees, relative to the pose the ragdoll was built in — a knee
+     *  is `{ axis: [1, 0, 0], min: 0, max: 140 }`: it folds one way only. */
+    min: number;
+    max: number;
+}
+export interface RagdollPart {
+    /** The bone the body sits on — its origin is the joint. */
+    bone: string;
+    /** The bone the capsule points at (the next joint down). Omitted = a leaf: `length` along the line
+     *  from the parent part's origin (a head, a hand, a foot without toes). */
+    to?: string;
+    /** The bone of the part this one hangs from (default: the previous part in the list). The root
+     *  has none. */
+    parent?: string;
+    /** Capsule radius in metres (default 0.05). */
+    radius?: number;
+    /** Length in metres: a leaf's, or an override of the distance to `to`. */
+    length?: number;
+    /** This part's share of the ragdoll's `mass` (relative weight, default 1). */
+    mass?: number;
+    /** Cone half-angle in degrees the part may swing off its parent (default 30). Ignored with `hinge`. */
+    swing?: number;
+    /** Twist half-angle in degrees about its own axis (default 20). */
+    twist?: number;
+    /** A one-way joint instead of the cone. */
+    hinge?: RagdollHinge;
+}
+/** How the body lies: on its back (the chest points up), prone (the chest points down), or on a side. */
+export type RagdollFacing = "up" | "down" | "side";
+export interface RagdollActivateOptions {
+    /** A LAUNCH added to every part's own motion (world m/s) — an explosion, a throw. The bones' own
+     *  motion (the run, the swinging arms) is measured by the engine and needs no help. */
+    velocity?: Vec3Like;
+    /** The motors' strength from the first step (default: the current `strength`). */
+    strength?: number;
+    /** The root anchored to the animation from the first step (default: the current `anchored`). */
+    anchored?: boolean;
+}
+export interface RagdollDeactivateOptions {
+    /** Seconds the animator takes to transition OUT of the fallen pose into whatever plays next (a
+     *  get-up take started right after, or the loop). 0 (default) = a cut. Move the model node under
+     *  the hips before this call: the bones are handed back against its new transform. */
+    blend?: number;
+}
+export interface RagdollHitOptions {
+    /** How long the body stays powered before the bones go back to the animator (s, default 0.6). */
+    duration?: number;
+    /** The transition out of the reaction's last physical pose (s, default 0.25). */
+    blend?: number;
+    /** The motors' strength during the reaction (default 1). */
+    strength?: number;
+}
+export declare class Ragdoll extends Aspect<"ragdoll", Node> {
+    static readonly aspect = "ragdoll";
+    /** The parts: `'humanoid'` (default) finds the standard bones by name; a list places bodies on any
+     *  bones — parents before children. */
+    parts: RagdollPart[] | "humanoid";
+    /** Total mass in kg (default 70), split between the parts by their `mass` shares. */
+    mass: number;
+    /** Friction of every part (default 0.6 — the physics default). */
+    friction: number;
+    /** Linear / angular damping of every part; 0 = Jolt's own 0.05. More angular damping settles a
+     *  flailing body sooner. */
+    linearDamping: number;
+    angularDamping: number;
+    /** What the parts collide with. `'static'` (default): the static geometry and other such ragdolls
+     *  only — dynamic bodies, character controllers and vehicles pass through a fallen body, which then
+     *  never shoves or blocks anything and costs nothing when they meet. `'all'`: a regular dynamic
+     *  body that bumps into everything (and gets kicked awake by everything). */
+    collide: "static" | "all";
+    /** Once every part of a LIMP body has come to rest the parts turn static where they lie (default
+     *  true): the pose holds, nothing can wake a settled body and it costs the solver nothing —
+     *  `deactivate()` / `activate()` still work (activate makes it dynamic again). A driven or anchored
+     *  body never freezes. */
+    freeze: boolean;
+    /** Seconds limp after which the body freezes whatever it is doing — a twitch on a slope or a pile
+     *  never sleeps on its own. 0 (default) = no cap. */
+    freezeAfter: number;
+    /** The joint motors: the position spring's frequency in Hz (default 6 — higher = a stiffer, quicker
+     *  return to the animated pose) and damping ratio (default 1 = critical, no overshoot). */
+    driveFrequency: number;
+    driveDamping: number;
+    /** The motors' torque limit at strength 1, in N·m per kg of the part (default 12: ~180 N·m at the
+     *  hips of an 80 kg body, ~25 at a forearm). Lower = a hit displaces a limb more before the
+     *  animation wins it back. */
+    driveTorque: number;
+    /** Joint friction in N·m per kg of the part (default 0.3): a torque that resists any joint motion,
+     *  motor or not — a limp body folds instead of flopping like jelly. */
+    jointFriction: number;
+    /** Where the joint limits come from. `'clips'` (default): measured from the animation — at the first
+     *  activation that finds clips on the model's animator, every joint's swing and twist range over
+     *  every bound clip becomes its limit (plus `limitsMargin` on each side), so the motors never
+     *  target a pose the limits forbid and a limp body settles into poses the clips use; until clips
+     *  are bound the part table's cones apply. `'table'`: the part table's cones and hinges only. */
+    limits: "clips" | "table";
+    /** Degrees added on each side of a learned range (default 10). */
+    limitsMargin: number;
+    static fields: FieldMeta<Ragdoll>;
+    private _id;
+    private _active;
+    private _bones;
+    private _strength;
+    private _anchored;
+    private _hipsFwd;
+    private _hipsUp;
+    private _ramp;
+    private _release;
+    onAttach(): void;
+    onDetach(): void;
+    /** Hand the bones to physics from the pose they are in right now, each moving as it did over the
+     *  last two frames (the engine measures: a runner keeps travelling, a swinging arm keeps swinging). */
+    activate(opts?: RagdollActivateOptions): boolean;
+    /** Take the bones back: the animator's pose shows again from the next frame — through a `blend`
+     *  out of the fallen pose when asked (play the get-up take right after, with its own fade: it
+     *  starts from where the body lies). */
+    deactivate(opts?: RagdollDeactivateOptions): void;
+    /** Physics owns the bones right now. */
+    get active(): boolean;
+    /** Active and every part asleep (or frozen) — the body has come to rest. */
+    get settled(): boolean;
+    /** The joint motors' strength, 0..1: how hard every joint is pulled toward the pose the animator
+     *  shows (0 = off — a limp body). Kept across activations. */
+    get strength(): number;
+    set strength(v: number);
+    /** The hips follow the animation kinematically (the body stands in its clip while physics moves the
+     *  limbs — hit reactions, a stagger). Off = the hips are a free body (a fall). */
+    get anchored(): boolean;
+    set anchored(v: boolean);
+    /** The joints give way: the strength ramps to 0 over `seconds` and the anchor comes off — a body
+     *  shot mid-stride keeps its pose for a moment and then collapses, instead of switching off. */
+    goLimp(seconds?: number): void;
+    /** A flinch: the body powers up anchored to its animation (if it is not already active), the struck
+     *  part gets the impulse (N·s, at a world point), and after `duration` the bones go back to the
+     *  animator through `blend`. On a limp body (a corpse) it is just the impulse. */
+    hit(bone: string, v: Vec3Like, at?: Vec3Like, opts?: RagdollHitOptions): boolean;
+    /** The root part's bone (the hips): where the body is. */
+    get root(): Node | null;
+    /** How the body lies: `'up'` on its back (the chest points up), `'down'` prone, `'side'` otherwise.
+     *  Read while it is down, to pick the get-up take. */
+    get facing(): RagdollFacing;
+    /** Where the head points along the ground, as a yaw in degrees (the model node's `eulerAngles` y
+     *  that faces that way): where a get-up take that rises head-first ends up facing. A body still
+     *  upright answers with the way its chest faces. */
+    get heading(): number;
+    /** The bones that carry a part, in order. */
+    get bones(): string[];
+    /** The rigid-body id of a part (0 if none) — for the plain body calls. */
+    bodyOf(bone: string): number;
+    /** Push one part: an impulse in N·s, at a world point (a hit) or through its centre. Wakes the body. */
+    impulse(bone: string, v: Vec3Like, at?: Vec3Like): boolean;
+    /** The strength ramp (goLimp) and the hit reaction's hand-back. */
+    update(dt: number): void;
+}

package/dist/types/gl/{Shape.d.ts → physics/Shape.d.ts}

@@ -1,6 +1,6 @@
-import { Aspect } from "../core/Aspect";
-import { type Vec3Like } from "../math/vec";
-import type { Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import { type Vec3Like } from "../../math/vec";
+import type { Node } from "../Node";
 /** Which geometry a Shape uses — the one-of the fields below encode (see `_build`'s order). */
 export type ShapeKind = "auto" | "box" | "sphere" | "cylinder" | "capsule" | "mesh" | "convex" | "heightfield";
 /** A node-local AABB, in the node's OWN frame (its own transform excluded), before world scale. */

package/dist/types/gl/{Trigger.d.ts → physics/Trigger.d.ts}

@@ -1,5 +1,5 @@
-import { Aspect } from "../core/Aspect";
-import type { Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import type { Node } from "../Node";
 export declare class Trigger extends Aspect<"trigger", Node> {
     static readonly aspect = "trigger";
     private _bodyId;

package/dist/types/gl/{Terrain.d.ts → terrain/Terrain.d.ts}

@@ -1,15 +1,17 @@
-import { Node } from "./Node";
-import { Material } from "./Material";
-import { Texture } from "./Texture";
-import { Geometry } from "./Geometry";
-import { type ColorInput } from "../core/color";
-import { Vec3, type Vec3Like } from "../math/vec";
+import { Node } from "../Node";
+import { Material } from "../Material";
+import { Texture } from "../Texture";
+import { Geometry } from "../Geometry";
+import { type ColorInput } from "../../core/color";
+import { Vec3, type Vec3Like } from "../../math/vec";
 export type TerrainLayer = {
-    /** Albedo texture (a URL / `asset()` handle, or a loaded Texture). Unset = white. */
+    /** Albedo texture (a URL / `asset()` handle, or a loaded Texture). Unset = white. Its ALPHA is the layer's roughness
+     *  map (`lecodes assets terrain-pack --roughness` puts it there): an opaque albedo reads 1. */
     albedo?: string | Texture;
     /** Metres per texture repeat. Default 8. */
     tiling?: number;
-    /** Perceptual roughness of the layer. Default 1. */
+    /** Perceptual roughness of the layer — a factor on the albedo's alpha (its roughness map), the whole value when the
+     *  albedo is opaque. A terrain has no metallic: ground is a dielectric. Default 1. */
     roughness?: number;
     /** Normal-map strength (0 = the layer's slot of the pack is not read). Default 0 — set 1 when the
      *  layer has a normal map in `normals`. */

package/dist/types/gl/{terrainMesh.d.ts → terrain/terrainMesh.d.ts}

@@ -1,4 +1,4 @@
-import { Geometry } from "./Geometry";
+import { Geometry } from "../Geometry";
 export type TerrainGrid = {
     sizeX: number;
     sizeZ: number;

package/dist/types/gl/vehicle/Vehicle.d.ts

@@ -0,0 +1,300 @@
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import { Vec3, type Vec3Like } from "../../math/vec";
+import { type QuatLike } from "../../math/quat";
+import { Node } from "../Node";
+import { Wheel, type Point } from "./Wheel";
+/** Which axle the engine drives — the default for every wheel's own `driven` share. */
+export type DriveLayout = "rear" | "front" | "all" | "none";
+/**
+ * How an axle's two wheels share torque.
+ *  - `lsd` — limited slip (Jolt's 1.4 ratio), the sane default.
+ *  - `open` — fully open: a lifted or spinning wheel takes ALL the torque.
+ *  - `locked` — both wheels forced to the same speed. Breaks traction predictably: the drift diff.
+ *  A number is the raw max/min wheel-speed ratio (> 1; smaller is more locked).
+ */
+export type DifferentialMode = "lsd" | "open" | "locked";
+export interface EngineConfig {
+    /** Peak torque in N·m (default 500). The single biggest "how fast is it" knob. */
+    torque?: number;
+    /** Redline in RPM (default 6000) — Jolt's own clamp; a rev limiter's stutter is the game's. */
+    maxRpm?: number;
+    /** Idle RPM (default 1000): the engine's floor. `0` = no floor — the engine can be dragged to a
+     *  standstill and stall, and holding idle (a governor), cranking it, are the game's to write. */
+    idleRpm?: number;
+    /**
+     * The engine's CHARACTER: points `{ x, y }` in NORMALISED units — x a fraction of the redline, y a
+     * fraction of `torque`, x ascending. Left out, Jolt's own broad curve is used.
+     *
+     * `[{ x: 0, y: 0.8 }, { x: 0.66, y: 1 }, { x: 1, y: 0.8 }]` is an ordinary petrol engine (peak two
+     * thirds up, falling to the redline); `[{ x: 0, y: 1 }, { x: 1, y: 1 }]` is flat, an electric motor.
+     */
+    curve?: Point[];
+    /** Moment of inertia in kg·m² (default 0.5) — how eagerly it revs when the clutch is out. */
+    inertia?: number;
+    /** Engine braking: angular damping of the engine itself (default 0.2). */
+    braking?: number;
+}
+/**
+ * The steering wheel as a BODY the tires push back on, simulated by the engine every sub-step. With
+ * it, `steer` is where the driver's hands AIM the wheel and `steerForce` how firmly they hold it;
+ * where the road wheels end up is physics:
+ *
+ *     I·θ̈ = T_hand + T_align·(1 − powerSteering) + T_stop − (damping + endStop.damping·depth)·θ̇ − parkingFriction(v) − friction
+ *
+ * `T_align` is the tires' self-aligning torque (`steering.caster` / `trail` / `trailAtPeak` — the
+ * same torque `steerTorque` reports without a feedback body, for a force-feedback wheel). `T_hand`
+ * is the driver's arms, `steering.driver`. So: heavy at speed, light when the front lets go,
+ * self-centring on release, and in a slide a let-go wheel swings into opposite lock by itself.
+ * Without `feedback` there is no body: `steer` is the road wheels' angle as a fraction of `maxAngle`.
+ */
+export interface SteeringFeedback {
+    /** Moment of inertia of wheel + column + rack about the axis, kg·m² (default 1). Heavier = slower
+     *  off the mark under the hands, but a wheel whipping into counter-steer carries further. */
+    inertia?: number;
+    /** Viscous damping, N·m·s/rad (default 25): what keeps a let-go wheel from ringing about centre. */
+    damping?: number;
+    /** The column's own dry friction, N·m, at any speed (default 8) — rack and bearings: the floor a
+     *  free wheel's spin decays against, and what keeps a let-go wheel from creeping under a small torque. */
+    friction?: number;
+    /** The contact patch's dry friction while (nearly) parked, N·m (default 40), fading out by 1.5 m/s
+     *  — why a parked car is hard to steer, and why a wheel left turned stays turned. */
+    parkingFriction?: number;
+    /** Power steering, 0..1 (default 0.5): the share of the tires' aligning torque the wheel never
+     *  sees. It is NOT a gain on the angle: 0 is a kart (heavy, full of feel, a held key gives up its
+     *  lock early at speed), 1 is a dead rim that neither centres nor counter-steers. */
+    powerSteering?: number;
+    /** The END STOP before the lock — rubber, not a wall (default `{ band: 16, torque: 120, damping: 150 }`):
+     *  over the last `band` degrees the rack pushes back toward centre with the SQUARE of the depth,
+     *  `torque` N·m at the lock, and damps by `damping` N·m·s/rad × depth. A wheel let go on the stop
+     *  eases back off it a few degrees; `band: 0` = the hard clamp only. */
+    endStop?: {
+        band?: number;
+        torque?: number;
+        damping?: number;
+    };
+}
+/** The driver's ARMS on a `feedback` wheel — an actuator with numbers, because a stiff hand spring
+ *  has to be integrated with the column every sub-step. WHAT the hands do (aim, hold, let go) is
+ *  the game's, per frame, through `steer` and `steerForce`. */
+export interface SteeringDriver {
+    /** The most torque the hands can put on the wheel, N·m (default 130). The ceiling on how much lock
+     *  a held key keeps at speed against the tires' pull. */
+    maxTorque?: number;
+    /** How stiff the arms are, N·m/rad of the gap between where they aim and where the wheel is (default 500). */
+    stiffness?: number;
+    /** The fastest the hands turn the road wheels, deg/s (default 120): the hands cannot PUSH a wheel
+     *  that already outruns them, they can still hold and brake it; a let-go wheel is uncapped. */
+    maxRate?: number;
+    /** Seconds the hands' torque takes to build to `maxTorque` (default 0.1): muscles do not step. */
+    rampTime?: number;
+}
+export interface SteeringConfig {
+    /** Steering lock in degrees (default 35): what `steer = ±1` means. */
+    maxAngle?: number;
+    /** The front axle's GEOMETRY, the source of the tires' self-aligning torque (`steerTorque`, and
+     *  what a `feedback` wheel is pushed by): the mechanical caster's trail, metres (default 0.03)… */
+    caster?: number;
+    /** …and the pneumatic trail, metres (default 0.025) — the patch's own lever, which collapses as the
+     *  tire reaches its peak slip angle (the steering going light when the front lets go)… */
+    trail?: number;
+    /** …to this fraction of itself at the peak (default 0.5). */
+    trailAtPeak?: number;
+    /** Simulate the steering wheel as a body the tires push back on (`SteeringFeedback`). `true` = the
+     *  defaults. Without it `steer` sets the road wheels' angle directly. */
+    feedback?: boolean | SteeringFeedback;
+    /** The driver's arms on a `feedback` wheel (`SteeringDriver`); the defaults without it. */
+    driver?: SteeringDriver;
+}
+/**
+ * Aerodynamics. Both numbers are quoted the same way — **a fraction of the car's own weight at
+ * 30 m/s (108 km/h)** — and both grow with the SQUARE of speed from there, so `0.5` at 30 m/s is
+ * `2.0` at 60 m/s. One mental model for both, and no drag coefficients or frontal areas to invent.
+ */
+export interface AeroConfig {
+    /**
+     * Downforce (default 0 — a car with no wing). The knob that decides whether a car corners better
+     * or worse the faster it goes: tire grip is a constant, but the force a corner demands grows with
+     * v², so with no downforce every car runs out of road at speed. `0.6` roughly doubles a car's
+     * cornering at 150 km/h; a road car is nearer `0.1`, a race car well past `1`.
+     *
+     * It presses along the CHASSIS' own down axis (that is what keeps a car planted over a crest) and
+     * only while a wheel is on the ground — a car on its roof is never launched by its own wing.
+     */
+    downforce?: number;
+    /** Air resistance (default 0.03 — an ordinary car). What gives a car a top speed at all. */
+    drag?: number;
+}
+export declare class Vehicle extends Aspect<"vehicle", Node> {
+    static readonly aspect = "vehicle";
+    /** Chassis mass in kg (default 1200). Wheels are massless in this model. */
+    mass: number;
+    /** Centre of mass height in chassis space (metres, negative = lower). Left out, it drops to halfway
+     *  down the chassis shape — a car with its mass at the shape's centre tips over. */
+    centerOfMass?: number;
+    /** Which axle the engine drives (default "rear") — the default for every wheel's own `driven`
+     *  share: 1 on that axle, 0 elsewhere. `none` = no drive at all (a trailer, a pushed cart). */
+    driveAxle: DriveLayout;
+    /** Differential lock across each driven axle. `locked` is the drift setup — both wheels turn
+     *  together, so the pair lets go as a pair. Live: re-configure the aspect to switch it mid-drive. */
+    differential: DifferentialMode | number;
+    /**
+     * Anti-roll bars between each axle's wheels — what stops a car rolling onto its inside wheels in a
+     * fast corner. `true` (default) is a bar 0.01 as stiff as the wheel's own spring; a number is that
+     * ratio directly, and `0` / `false` removes the bars.
+     *
+     * **The numbers are far smaller than they look and the gain is steep** — Jolt's bar feeds
+     * `lengthDifference × stiffness × dt` as a bias into the suspension's own soft constraint, so 4%
+     * of the spring already flattens the body. Measured on a 1250 kg car: `0` → 1.3° of roll at 0.86 g,
+     * `0.01` → 0.6°, `0.15` → 0.2° (flat), `0.5` → the car HOPS.
+     *
+     * This is the knob for how much a car visibly LEANS, not for wheel lift: bars change how far the
+     * body tips, not how much load transfers. For lift, lower `centerOfMass`.
+     */
+    antiRoll: boolean | number;
+    /** Pitch/roll limit in degrees (default 60) before the constraint rights the car. 180 turns it off. */
+    maxTilt: number;
+    /** Friction of the CHASSIS body itself — how it slides when it lands on its roof or side. Nothing
+     *  to do with the tires; those are the `Wheel`'s `tire` × the ground's friction. */
+    friction: number;
+    /** Strength of the clutch when fully engaged (default 10). Small values slip; large ones weld the
+     *  engine to the wheels. `clutch` (the input) scales it 0..1. */
+    clutchStrength: number;
+    /** The clutch's torque CAPACITY, N·m (default 0 = none: Jolt's viscous clutch alone, torque =
+     *  `clutchStrength` × slip speed, no ceiling — rigid at any real slip). Set it and the clutch
+     *  SLIPS at this much torque × `clutch` — a dry clutch, emulated a physics step at a time: a
+     *  launch can be feathered, and a dumped clutch in too high a gear drags the engine down instead
+     *  of lurching. A road car's is ~1.5× the engine's peak torque. */
+    clutchCapacity: number;
+    engine: EngineConfig;
+    steering: SteeringConfig;
+    aero: AeroConfig;
+    /** Scene-editor inspector: the flat, tunable half. The grouped objects are edited in code. */
+    static fields: FieldMeta<Vehicle>;
+    static editor: {
+        rebuild: boolean;
+    };
+    /** Driver systems tick at the default 0, so their inputs land in the SAME early pass, before this flush. */
+    protected updateOrder: number;
+    private _id;
+    private _bodyId;
+    private _builtMass;
+    private _wheels;
+    private _state;
+    private _stateFrame;
+    private _throttle;
+    private _steer;
+    private _steerForce;
+    private _ratio;
+    private _clutch;
+    private _input;
+    private _sent;
+    private _dirty;
+    private _retunePending;
+    onAttach(): void;
+    onDetach(): void;
+    /**
+     * Re-configuring an attached vehicle retunes it in place — the way a drift button switches the
+     * differential without the car so much as blinking:
+     *
+     *   car.aspect(Vehicle, { differential: drift ? 'locked' : 'lsd' })
+     *
+     * Live: `differential`, `engine`, `steering`, `aero`, `maxTilt`, `friction`, `clutchStrength`,
+     * `clutchCapacity`, `antiRoll` (its stiffness, on axles that have a bar), and every `Wheel`'s
+     * `tire`. Everything else describes the car's STRUCTURE — `mass`, `centerOfMass`, which wheels
+     * exist and where, their suspension, the driven shares — and is baked into the constraint at
+     * attach; to change one of those, re-attach the aspect.
+     */
+    onReconfigure(): void;
+    /** Native vehicle id (0 until attached / no physics support). */
+    get id(): number;
+    /** The chassis rigid body id (for `physicsApplyImpulse`-style calls). */
+    get bodyId(): number;
+    /** The wheels, front axle first, in the order the engine knows them. */
+    get wheels(): readonly Wheel[];
+    /** Throttle 0..1 — the engine's pedal. No sign: the direction is `ratio`'s. */
+    get throttle(): number;
+    set throttle(v: number);
+    /** Steering −1..1. Without `steering.feedback`: the road wheels' angle as a fraction of `maxAngle`,
+     *  applied as is (a taper with speed, a rate limit, are the game's). With it: where the hands AIM
+     *  the wheel; the tires decide where the road wheels end up. */
+    get steer(): number;
+    set steer(v: number);
+    /** How firmly the hands hold a `feedback` wheel, 0..1 (default 1): the hands' torque is capped at
+     *  `driver.maxTorque × steerForce`. 0 = let go — the tires alone have the wheel: back to centre in
+     *  a grip corner, into opposite lock in a slide. Ignored without a feedback wheel. */
+    get steerForce(): number;
+    set steerForce(v: number);
+    /** The ONE gear ratio the engine runs (default 1): engine rpm = wheel rpm × ratio × the final
+     *  drive (3.42). The SIGN is the direction — negative is reverse — and 0 is neutral. */
+    get ratio(): number;
+    set ratio(v: number);
+    /** Clutch engagement 0..1 (default 1 = home). 0 = out: the engine is free of the wheels. */
+    get clutch(): number;
+    set clutch(v: number);
+    /**
+     * EARLY phase: hand this frame's inputs to the engine, before the step. The vector is sent when
+     * anything changed — and every frame while a throttle, steer or brake is non-zero, because that is
+     * what keeps a driven car awake (an idle car with zero input sleeps). The pending re-tune (a
+     * config or tire change) goes first, so the step runs on the new numbers.
+     */
+    protected updateBefore(): void;
+    /** Teleport upright and clear all motion (velocity, engine rpm, wheel spin). Defaults to the
+     *  chassis node's current pose — `reset()` alone un-flips a car where it lies. The inputs are
+     *  kept and re-sent on the next early pass. */
+    reset(position?: Vec3Like, rotation?: QuatLike): this;
+    /** Push the chassis (a boost pad, an explosion) — an instantaneous impulse in kg·m/s. */
+    applyImpulse(v: Vec3Like): this;
+    private _read;
+    /** Speed along the car's forward axis in m/s — negative when reversing (× 3.6 for km/h). */
+    get speed(): number;
+    /** Engine RPM. */
+    get rpm(): number;
+    /** How many wheels touch the ground this frame. */
+    get wheelsOnGround(): number;
+    /** At least one wheel on the ground. */
+    get grounded(): boolean;
+    /** Chassis velocity in world space, m/s. */
+    get velocity(): Vec3;
+    /** Chassis angular velocity in world space, rad/s. */
+    get angularVelocity(): Vec3;
+    /** How fast the car is turning about the vertical, in degrees per second — positive turning RIGHT
+     *  (the same sense as `steer`). The signal a counter-steer assist reads. */
+    get yawRate(): number;
+    /**
+     * The car's slip angle in degrees: the angle between where the nose points and where the car is
+     * actually travelling, positive when it is travelling to the RIGHT of the nose. 0 going straight,
+     * ±180 backing up, and past ~10° the rear has stepped out — a drift.
+     */
+    get slipAngle(): number;
+    /**
+     * The angle of the SLIDE, degrees, signed like `slipAngle` (positive = travelling to the right of
+     * the nose), −180..180: the angle between the car's axis and where its REAR AXLE travels — the
+     * mean of the non-steering wheels (every wheel if all of them steer), its velocity from the
+     * body's velocity and spin. Unlike `slipAngle` (the body's, at its centre) this is 0 on a clean
+     * corner at ANY speed: at walking pace and full lock the body already travels ~20° off its nose
+     * while the rear axle rolls straight along it. It is the rear stepping out — what a gyro comes in
+     * on, and what a drift meter should show — and unlike the tires' own `Wheel.slipAngle` it does
+     * not fold at 90°: a backward entry reads 110°, not 70°. The axis it is measured from is the one
+     * the DRIVETRAIN pushes along — the nose for a positive `ratio`, the tail for a negative one — so
+     * honest reversing reads 0, and a car spun round in a forward gear reads past 90°. 0 at a
+     * standstill: with no speed a direction is noise, so it fades in over walking pace,
+     * `DRIFT_SPEED_FROM`..`DRIFT_SPEED_FULL` of the axle's ground speed.
+     */
+    get driftAngle(): number;
+    /** Where the steered wheels actually are, in degrees, right-positive: the angle `steer` set, or
+     *  with `steering.feedback` where the column has come to. */
+    get steerAngle(): number;
+    /** The tires' self-aligning torque on the steering, N·m, positive = it pulls the wheel to the
+     *  RIGHT — what the driver feels: heavy at speed, light when the front lets go, and the
+     *  counter-steer in a slide. Reported with or without a `feedback` wheel: the signal a
+     *  force-feedback steering wheel is driven by. */
+    get steerTorque(): number;
+    /** Every Wheel under the chassis, ordered front axle first, with its axle group resolved. */
+    private _collectWheels;
+    /** Pack the whole configuration into the one blob the host ABI takes (see bridges.d.ts). */
+    private _buildSettings;
+    /** Edit mode: which way the chassis faces. Each wheel draws its own circle and travel range — see
+     *  `Wheel.rebuild()`. Play mode never calls this. */
+    rebuild(): void;
+}