@adatechnology/game-vehicles 0.6.3 → 0.6.4

package/dist/index.d.ts

@@ -1,70 +1,1056 @@
+import * as three from 'three';
+import { MeshStandardMaterial, Vector3, BufferGeometry, Object3D, Mesh, Material, Vector2, Box3, Matrix4, Group, ColorRepresentation, CanvasTexture, MeshBasicMaterial, Color, Texture, SpriteMaterial, Sprite, Raycaster } from 'three';
 import { MaterialId, Vec3, JointKind, ToolKind, DeferredQueue, DestructibleImpl, AnimationClipSpec, IgnitionRules, DestructionEvent, ObjectState, Enclosure } from '@adatechnology/game-contracts';
 
-/**
- * Light mode ("lite"): the same vehicles with fewer triangles, for a whole street of them. Port of the `[LOD]` hooks of the team's Frota Leve
- * (frota-leve.js lines 21-65, 232-257, 1205-1221, 14155-14170). Every number is a setting; with `on` false nothing changes, so every golden
- * of the full-detail build stays byte for byte the same.
- */
+/** Armoured vehicle details (plating, hatches, add-on armour) and the applyArmor helper. */
 
-interface LodSettings {
-    /** Light mode is active for the builds that run now. Set by `kit.build(key, state, zones, { lod: true })`. */
-    on: boolean;
-    /** Fraction of the segments three's own generators keep (cylinders, spheres, tori, lathes, tubes, extrusions, circles, rings). */
-    segmentFraction: number;
-    /** Rounding rings of a rounded box (the full build uses 3). */
-    roundingRings: number;
-    /** Multiplier of the maximum edge length when subdividing a mesh (bigger triangles). */
-    subdivisionFactor: number;
-    /** A box with an edge under this, or a rounding radius under 1.2 cm, is drawn as a plain 12-triangle box. */
-    flatBoxEdge: number;
-    /** Fewest segments of a superellipse loft. */
-    minLoftSegments: number;
-    /** Fraction of a loft's segments. */
-    loftSegmentFraction: number;
-    /** Fewest stations of a resampled loft. */
-    minStations: number;
-    /** Fraction of the stations of a resampled loft. */
-    stationFraction: number;
-    /** Multiplier of the grid cell size of grilles and side grilles. */
-    gridFactor: number;
-    /** Materials (by name in `kit.materials`) whose meshes are never seen from outside and are left out in light mode. */
-    hiddenMaterials: readonly string[];
+declare function installArmor(kit: Kit): {
+    STEEL_MATERIAL: MeshStandardMaterial;
+    PLATE_MATERIALS: MeshStandardMaterial[];
+    jerryCan: (c: BuildContext, x: number, y: number, z: number, col: string) => void;
+    applyArmor: (c: BuildContext) => void;
+};
+
+/** A cut for `geo.cut`: `sel(normal, centre)` picks the triangles, `sdf(x, y, z)` < 0 is removed, the removed pieces with a `tag` come back in `.cut[tag]`. */
+type CutTest = {
+    sel?: ((n: Vector3, ce: Vector3) => boolean) | null;
+    sdf: (x: number, y: number, z: number) => number;
+    tag?: string;
+    /** a box (in the frame of the geometry) that holds every point with sdf < 0 */
+    bounds?: {
+        lo: number[];
+        hi: number[];
+    };
+    /** how the removed pieces are smoothed: 'none', 'later' (a crease task) or right away */
+    pieces?: string;
+};
+type Rgb = {
+    r: number;
+    g: number;
+    b: number;
+};
+/** A station of a loft: centre x and y, width, height and the superellipse power. */
+type LoftStation = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    p?: number;
+};
+type HullSpec = {
+    n?: number;
+    L: number;
+    p?: number;
+    beam(t: number): number;
+    keel(t: number): number;
+    sheer(t: number): number;
+};
+/** A corner of a path ([x, y, radius]) or an arc ({ arc: [cx, cy, r, from, to, clockwise] }). */
+type PathItem = {
+    readonly arc?: readonly [number, number, number, number, number, boolean?];
+    readonly [i: number]: number;
+};
+type TaperSpec = {
+    sx?: number | null;
+    sz?: number | null;
+    shift?: number;
+};
+type TumbleSpec = {
+    belt: number;
+    top: number;
+    k: number;
+};
+declare function installGeometry(kit: Kit): {
+    roundedBoxGeometry: (w: number, h: number, d: number, r: number) => three.BoxGeometry;
+    taper: (geo: BufferGeometry, t: TaperSpec) => void;
+    subdivide: (geo: BufferGeometry, maxLen: number) => BufferGeometry<three.NormalBufferAttributes>;
+    crease: (geo: BufferGeometry, deg: number) => BufferGeometry<three.NormalBufferAttributes>;
+    creaseTask: (geo: BufferGeometry, deg: number) => {
+        geo: BufferGeometry<three.NormalBufferAttributes>;
+        step: (deadline: number) => boolean;
+    };
+    refreshBounds: (geo: BufferGeometry) => void;
+    pathShape: (items: readonly PathItem[]) => three.Shape;
+    tumble: (geo: BufferGeometry, T: TumbleSpec | null | undefined) => void;
+    loftGeometry: (st: readonly LoftStation[], seg: number, pw: number, colorFn?: ((x: number, y: number, z: number, s: LoftStation) => Rgb) | null) => BufferGeometry<three.NormalBufferAttributes>;
+    hullGeometry: (o: HullSpec, colorFn?: ((x: number, y: number, z: number) => Rgb) | null) => BufferGeometry<three.NormalBufferAttributes>;
+    cutGeometry: (geo: BufferGeometry, tests: readonly CutTest[]) => {
+        geo: BufferGeometry;
+        cut: Record<string, BufferGeometry>;
+        tasks: Record<string, ReturnType<(geo: BufferGeometry, deg: number) => {
+            geo: BufferGeometry<three.NormalBufferAttributes>;
+            step: (deadline: number) => boolean;
+        }>>;
+    };
+    mergeGeometries: (list: readonly BufferGeometry[]) => BufferGeometry<three.NormalBufferAttributes>;
+    uvProject: (geo: BufferGeometry, axes?: string) => number;
+};
+
+/** Shared materials, studio environment map, paint colours and text textures. */
+
+/** Options of `kit.makeMaterial`: the parameters of a `MeshStandardMaterial`, and `noEnv` to keep the studio environment map off a metallic one. */
+type MaterialOptions = three.MeshStandardMaterialParameters & {
+    noEnv?: boolean;
+};
+/** Options of `kit.textTexture` (and of `c.text`): canvas size, background, the blue band of a plate, text colour, size share, weight and font. */
+interface TextTextureOptions {
+    w?: number;
+    h?: number;
+    bg?: string;
+    band?: string;
+    fg?: string;
+    size?: number;
+    weight?: string;
+    font?: string;
+    [option: string]: unknown;
 }
-declare const defaultLodSettings: LodSettings;
-/** The settings the kit starts with: the defaults, overridden by the options. */
-declare function createLod(options?: Partial<LodSettings>): LodSettings;
-/**
- * A copy of the three.js namespace whose geometry generators take fewer segments while `lod.on` is true (and whose canvas textures come out in
- * sRGB when three has colour management). With `lod.on` false every generator passes its arguments through untouched.
- */
-declare function wrapThreeForLod(TH: any, lod: LodSettings): any;
+declare function installMaterials(kit: Kit): {
+    RUST: three.Color;
+    cache: Record<string, three.MeshStandardMaterial>;
+    studioEnvironment: () => three.CubeTexture;
+    makeMaterial: (color: three.ColorRepresentation, o?: MaterialOptions) => three.MeshStandardMaterial;
+    makeFlatMaterial: (color: three.ColorRepresentation, o?: MaterialOptions) => three.MeshStandardMaterial;
+    DOUBLE_SIDE: 2;
+    toColor: (hex: three.ColorRepresentation) => three.Color;
+    MATERIALS: {
+        trim: three.MeshStandardMaterial;
+        rubber: three.MeshStandardMaterial;
+        chrome: three.MeshStandardMaterial;
+        steel: three.MeshStandardMaterial;
+        glass: three.MeshStandardMaterial;
+        tint: three.MeshStandardMaterial;
+        rearTint: three.MeshStandardMaterial;
+        glassDark: three.MeshStandardMaterial;
+        armorGlass: three.MeshStandardMaterial;
+        glassEdge: three.MeshStandardMaterial;
+        lens: three.MeshStandardMaterial;
+        lensRed: three.MeshStandardMaterial;
+        lensAmber: three.MeshStandardMaterial;
+        housing: three.MeshStandardMaterial;
+        reflector: three.MeshStandardMaterial;
+        reflectorLit: three.MeshStandardMaterial;
+        hole: three.MeshStandardMaterial;
+        dark: three.MeshStandardMaterial;
+        head: three.MeshStandardMaterial;
+        led: three.MeshStandardMaterial;
+        tail: three.MeshStandardMaterial;
+        amber: three.MeshStandardMaterial;
+        rev: three.MeshStandardMaterial;
+        blue: three.MeshStandardMaterial;
+        green: three.MeshStandardMaterial;
+        broken: three.MeshStandardMaterial;
+        bulbBroken: three.MeshStandardMaterial;
+        wood: three.MeshStandardMaterial;
+        leather: three.MeshStandardMaterial;
+        seat: three.MeshStandardMaterial;
+        alu: three.MeshStandardMaterial;
+        carpet: three.MeshStandardMaterial;
+        plastic: three.MeshStandardMaterial;
+        headliner: three.MeshStandardMaterial;
+        gauge: three.MeshStandardMaterial;
+        screen: three.MeshStandardMaterial;
+        bay: three.MeshStandardMaterial;
+        hoodLiner: three.MeshStandardMaterial;
+        block: three.MeshStandardMaterial;
+        cover: three.MeshStandardMaterial;
+        radiator: three.MeshStandardMaterial;
+        yellow: three.MeshStandardMaterial;
+        capBlue: three.MeshStandardMaterial;
+        postRed: three.MeshStandardMaterial;
+        postBlack: three.MeshStandardMaterial;
+        coolant: three.MeshStandardMaterial;
+        coolantLiq: three.MeshStandardMaterial;
+        washer: three.MeshStandardMaterial;
+        hv: three.MeshStandardMaterial;
+        hose: three.MeshStandardMaterial;
+    };
+    paintColor: (hex: three.ColorRepresentation, st: string) => three.Color;
+    texCache: Record<string, three.CanvasTexture>;
+    textTexture: (text: string, o?: TextTextureOptions) => three.CanvasTexture;
+};
 
-/** Smoke, fire and dust puffs handed to the host's effects world instead of the kit's own sprites. */
-/** What `EffectSink.play` of `game-contracts` takes, as a structural type: this package does not depend on the contracts layer. */
-interface ParticleEffectRequest {
-    readonly effect: string;
-    readonly point: [number, number, number];
-    readonly values: Readonly<Record<string, number>>;
+/** How a pane is made: its material, outline and seat on the body (side windows), the uv aspect, where its part sits and how far it reaches. */
+type GlassOptions = {
+    reuv?: boolean;
+    uvAxes?: string;
+    mat?: Material;
+    outline?: Vector2[] | null;
+    side?: number;
+    Wg?: number;
+    T?: TumbleSpec | null;
+    zpos?: number;
+    aspect?: number;
+    pos?: Vector3;
+    reach?: number;
+};
+type PaneLook = {
+    type?: string;
+    mat?: Material;
+    see?: boolean;
+};
+/** A windshield or rear window between the base point `pb` and the top `pt` of its pillar line (`kit.quadDef`). */
+type GlassQuad = {
+    pb: number[];
+    pt: number[];
+    L: number;
+    u: number[];
+    n: number[];
+    ins: number;
+    b: number[];
+    t: number[];
+    hb: number;
+    ht: number;
+    which: string;
+    bev: number;
+    Wg: number;
+    T: TumbleSpec | null | undefined;
+};
+declare function installGlass(kit: Kit): {
+    paneSeals: WeakMap<Object3D<three.Object3DEventMap>, Mesh<BufferGeometry<three.NormalBufferAttributes>, Material | Material[], three.Object3DEventMap>>;
+};
+
+/** What a builder declares about a zone (`c.zone(...)`): new fields, or `remove`; `objs` are parts by label or kind, lamps or objects. */
+/** A zone as `c.zone` declares or refines it: any field of a zone, plus remove, replace, fit and the objects it holds. */
+type ZoneDef = Partial<DamageZone> & {
+    id: string;
+    remove?: boolean;
+    replace?: boolean;
+    fit?: boolean;
+    objs?: unknown[];
+};
+declare function installZoneDerive(kit: Kit): {
+    parseDir: (d: unknown) => Vector3 | null;
+    resolveObjs: (c: BuildContext, list: readonly unknown[] | null | undefined, z: Pick<DamageZone, "lights" | "glass" | "wheels">) => Object3D<three.Object3DEventMap>[];
+    deriveZones: (c: BuildContext) => DamageZone[];
+    carMap: (c: BuildContext, list: DamageZone[]) => void;
+    zonesOf: (c: BuildContext) => any;
+    ownerOf: (c: BuildContext, o: Object3D | null | undefined) => DamageZone | null;
+};
+
+/** A zone box in `c.vehicle` coordinates. */
+interface ZoneBox {
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+    z0: number;
+    z1: number;
 }
-/** The host's effects world as far as the puffs need it (`EffectSink` of `game-contracts` fits). */
-interface ParticleEffects {
-    play(request: ParticleEffectRequest): unknown;
+/** What `normalizeBox` reads: `[x0, x1, y0, y1, z0, z1]`, a `ZoneBox` or a three.js `Box3`. */
+type ZoneBoxInput = readonly number[] | ZoneBox | Box3;
+declare function installZoneCore(kit: Kit): {
+    BANDS: {
+        id: string;
+        name: string;
+        min: number;
+        health: number;
+        color: string;
+    }[];
+    bandOf: (h: number | null | undefined) => number;
+    ZONE_WEIGHTS: Record<string, number>;
+    ZONE_EFFECTS: Record<string, string[]>;
+    zoneFx: (z: DamageZone, b: number) => any;
+    normalizeBox: (b: ZoneBoxInput | null | undefined) => ZoneBox | null;
+    boxLo: (B: ZoneBox, a: number) => number;
+    boxHi: (B: ZoneBox, a: number) => number;
+    boxContains: (B: ZoneBox, x: number, y: number, z: number, e: number) => boolean;
+    boxCenter: (B: ZoneBox) => Vector3;
+    boxVolume: (B: ZoneBox) => number;
+    boxDistance: (B: ZoneBox, p: Vector3) => number;
+    boxIntersects: (B: ZoneBox, b3: Box3) => boolean;
+    worldInverseOf: (c: BuildContext) => Matrix4;
+    localBox: (c: BuildContext, o: Object3D, inv?: Matrix4 | null) => Box3;
+    slug: (s: unknown) => string;
+    wheelInfo: (c: BuildContext) => {
+        list: Object3D<three.Object3DEventMap>[];
+        xf: number;
+        xr: number;
+        rf: number;
+        rr: number;
+    } | null;
+    partsOf: (c: BuildContext, kind: string) => VehiclePart[];
+    lightCenter: (c: BuildContext, L: VehicleLamp, inv: Matrix4) => Vector3;
+    lightBoxOf: (c: BuildContext, L: VehicleLamp, inv: Matrix4) => Box3;
+    hideObj: (c: BuildContext, o: Object3D | null | undefined) => void;
+    shown: (c: BuildContext, o: Object3D | null | undefined) => boolean;
+};
+
+/** A part's label: a text, or `{ key }` (the text of `parts.<key>`), or `{ key, label }` (the given text, keeping the key). */
+type LabelArgument = string | {
+    key?: string;
+    label?: string;
+};
+/** Where a builder puts a new mesh: its parent (default `c.vehicle`). */
+interface ParentOption {
+    parent?: Object3D | null;
 }
+declare function installContext(kit: Kit): {
+    resolveLabel: (l: LabelArgument) => {
+        label: string;
+        key?: string;
+    };
+    BuildContext: {
+        new (state: string, seed?: number): {
+            [key: string]: any;
+            root: Group;
+            vehicle: Group;
+            effects: Group;
+            state: string;
+            glass: Mesh[];
+            deform: Mesh[];
+            wheels: Object3D[];
+            parts: VehiclePart[];
+            lights: VehicleLamp[];
+            spin: VehicleSpin[];
+            emitters: VehicleEmitter[];
+            log: unknown[];
+            paints: Set<Material>;
+            seatTops: {
+                x: number;
+                y: number;
+                z: number;
+                w: number;
+                l: number;
+            }[];
+            flipped: boolean;
+            rollState: RollState | null;
+            quads: GlassQuad[];
+            zoneDefs: ZoneDef[];
+            flying?: FlyingPiece[];
+            /** How far each wheel drops when the zones are applied (flat tyre, broken rim), to settle the body on them. */
+            zoneDrops: {
+                x: number;
+                z: number;
+                d: number;
+            }[];
+            time: number;
+            rand: () => number;
+            add(geo: BufferGeometry, mat: Material | Material[], x?: number, y?: number, z?: number, parent?: Object3D | null): Mesh;
+            /** Paint material; `meta.matte` (or `o.matte`) gives a matte finish to everything, including parts created later (damage, hood). */
+            paint(hex: ColorRepresentation, o?: MaterialOptions & {
+                matte?: boolean;
+            }): MeshStandardMaterial;
+            roundBox(w: number, h: number, d: number, r: number, mat: Material | Material[], x?: number, y?: number, z?: number, o?: ParentOption & {
+                taper?: Parameters<(geo: BufferGeometry, t: TaperSpec) => void>[1];
+                sub?: number;
+                def?: boolean;
+                rot?: readonly number[];
+            }): Mesh;
+            cylinder(r1: number, r2: number, h: number, mat: Material | Material[], x?: number, y?: number, z?: number, axis?: string | null, o?: ParentOption & {
+                seg?: number;
+                open?: boolean;
+            }): Mesh;
+            sphere(r: number, mat: Material | Material[], x?: number, y?: number, z?: number, sx?: number, sy?: number, sz?: number, o?: ParentOption & {
+                ws?: number;
+                hs?: number;
+                tl?: number;
+            }): Mesh;
+            rod(a: Vector3, b: Vector3, r: number, mat: Material | Material[], o?: ParentOption & {
+                r2?: number;
+                seg?: number;
+            }): Mesh;
+            tube(pts: readonly (Vector3 | readonly number[])[], r: number, mat: Material | Material[], o?: ParentOption & {
+                closed?: boolean;
+                seg?: number;
+                rs?: number;
+            }): Mesh;
+            text(txt: string, w: number, h: number, x?: number, y?: number, z?: number, face?: string, o?: ParentOption & TextTextureOptions & {
+                glow?: ColorRepresentation;
+            }): Mesh;
+            plate(x: number, y: number, z: number, face?: string, txt?: string): Mesh;
+            part(kind: string, label: LabelArgument, obj: Object3D | null, pos: Vector3 | readonly number[], reach?: number, o?: Record<string, unknown>): VehiclePart;
+            wheel(x: number, z: number, r: number, w: number, o?: {
+                y?: number;
+                rimR?: number;
+                lugs?: boolean;
+                chevron?: boolean;
+                rim?: Material;
+                spokes?: number;
+                spokeMat?: Material;
+                noPart?: boolean;
+                label?: LabelArgument;
+            }): Group;
+            /** Point in `c.vehicle` coordinates to effects-group coordinates (vehicle world, ground y = 0). */
+            toEffects(p: Vector3): Vector3;
+            dirToEffects(d: Vector3): Vector3;
+            /** Declares or refines a damage zone: `c.zone(id, label, box, parts, options)`. Pass `label === false` to remove an auto-derived zone. */
+            zone(id: string, label: string | false | null | undefined, box?: ZoneBoxInput | null, parts?: Object3D | VehicleLamp | readonly (Object3D | VehicleLamp)[] | null, o?: Record<string, unknown>): ZoneDef;
+        };
+    };
+};
 
-/**
- * Damageable parts: what a bullet, a bat or a crash can hurt on a built vehicle, as boxes. Port of `coletarDanificaveis` and `tipoDaZona`
- * (frota-leve.js 14391-14405), driven by the zones the kit already derives, so it works for any vehicle of any pack.
- */
+/** A body shell (`kit.shell`): the side profile, its width, the wheel arches ([x, y, r]), the holes cut in it and the tumble of the sides. */
+type ShellSpec = {
+    items: readonly PathItem[];
+    W: number;
+    arches?: readonly number[][] | null;
+    bottomY?: number;
+    bev?: number | null;
+    sub?: number;
+    T?: TumbleSpec | null;
+    holes?: readonly CutTest[] | null;
+    archInner?: number | null;
+    mat?: Material;
+    col?: ColorRepresentation;
+};
+/** The greenhouse of a car: belt and roof heights, the rear and front pillar feet and tops, the pillars between windows and the width. */
+type Greenhouse = {
+    belt: number;
+    roof: number;
+    rb: number;
+    rt: number;
+    fb: number;
+    ft: number;
+    pillars: readonly number[];
+    Wg: number;
+};
+declare function installBody(kit: Kit): {
+    halfAt: (Wg: number, T: TumbleSpec | null | undefined, y: number) => number;
+    shell: (c: BuildContext, o: ShellSpec) => three.Mesh<BufferGeometry<three.NormalBufferAttributes>, Material | Material[], three.Object3DEventMap>;
+    autoWindows: (gh: Greenhouse) => number[][][];
+    profX: (items: readonly PathItem[], y: number, front: boolean) => number;
+    _sr: three.Raycaster;
+};
 
-type DamageableMaterial = 'metal' | 'glass' | 'rubber' | 'fuel';
-type DamageableSide = 'center' | 'left' | 'right';
-/** What a zone is, by type: the material it is made of and the part name a game shows. */
-interface DamageableKind {
-    material: DamageableMaterial;
-    part: string;
-}
-/** Zone type (and, for some, `fxKey` or `sub`) to material and part. A game replaces or adds entries with `kit.damageableKinds`. */
-declare const defaultDamageableKinds: Record<string, DamageableKind>;
+/** The rounding of `makeWarp`: where the front and rear start (xF, xR) and how long they bend (Lf, Lr), the half width, the bow and pinch of each end, the side curve (belt, ys, yb, kt, kb) and the drop of the nose. */
+type WarpOptions = {
+    xF: number;
+    xR: number;
+    Lf: number;
+    Lr: number;
+    hw: number;
+    bowF: number;
+    bowR: number;
+    pinF: number;
+    pinR: number;
+    belt: number;
+    ys: number;
+    yb: number;
+    kt: number;
+    kb: number;
+    dropF?: number;
+    dropY?: number;
+};
+/** A point warp: (x, y, z) to [x, y, z]. */
+type WarpFn = (x: number, y: number, z: number) => number[];
+/** A loft station of `smoothLoft`: [x, top, bottom, width, exponent?, z centre?]. */
+type LoftRow = readonly number[];
+type SmoothLoftOptions = {
+    smooth?: number;
+    seg?: number;
+    axis?: string;
+    p?: number;
+    crease?: number;
+};
+declare function installWarp(kit: Kit): {
+    makeWarp: (o: WarpOptions) => {
+        (x: number, y: number, z: number): number[];
+        sec: (y: number) => number;
+    };
+    applyWarp: (c: BuildContext, Wf: WarpFn) => void;
+    resample: (st: readonly (readonly (number | null | undefined)[])[], n: number) => number[][];
+    smoothLoft: (st: readonly LoftRow[], o?: SmoothLoftOptions | null) => three.BufferGeometry<three.NormalBufferAttributes>;
+};
+
+/** The generic car builder: shell, glasshouse, lights, wheels, interior and engine bay in one call. */
+
+type WheelOptions = Parameters<BuildContext['wheel']>[4] & {
+    track?: number;
+};
+/** A wheel of `kit.car`: [x, radius, width, options]. */
+type CarWheel = readonly [number, number, number, WheelOptions?];
+type LampSpec = {
+    style?: string;
+    w?: number;
+    h?: number;
+    y?: number;
+    in?: number;
+    yaw?: number;
+    dx?: number;
+    mat?: Material;
+    wrap?: boolean;
+};
+type GrilleSpec = {
+    style?: string;
+    w?: number;
+    h?: number;
+    y?: number;
+    emblem?: boolean;
+};
+/** The spec of `kit.car` (see the comment above it). */
+type CarSpec = {
+    W: number;
+    gh: Greenhouse & {
+        k: number;
+        r1?: number;
+        r2?: number;
+    };
+    col: ColorRepresentation;
+    roofCol?: ColorRepresentation;
+    mirrorCol?: ColorRepresentation;
+    lower: readonly PathItem[];
+    noseY: number;
+    tailY: number;
+    bottomY: number;
+    arches?: readonly number[][] | null;
+    interior?: false | Record<string, unknown> | null;
+    hood?: boolean | {
+        motor?: string;
+        front?: number;
+    } | null;
+    wheels?: readonly CarWheel[];
+    holes?: readonly CutTest[];
+    bed?: unknown;
+    under?: boolean;
+    motor?: string;
+    spareUnder?: boolean;
+    warp?: WarpOptions | WarpFn | null;
+    bodyBumper?: boolean;
+    headMat?: Material;
+    headW?: number;
+    headH?: number;
+    headY?: number;
+    hl?: LampSpec | null;
+    grille?: false | GrilleSpec | null;
+    noGrille?: boolean;
+    tailW?: number;
+    tailH?: number;
+    tailLightY?: number;
+    tl?: LampSpec | null;
+    seams?: readonly number[];
+    handles?: readonly number[];
+    plateRearY?: number;
+    noAntenna?: boolean;
+    track?: number;
+    noRadiator?: boolean;
+    tankLabel?: LabelArgument;
+};
+/** The underbody of `kit.underbody`: width, bottom height, the wheels, the motor and a spare wheel under the rear. */
+type UnderbodySpec = {
+    W: number;
+    bottomY: number;
+    wheels: readonly CarWheel[];
+    motor?: string;
+    spare?: boolean;
+};
+declare function installCar(kit: Kit): {};
+
+declare function installDamagePanels(kit: Kit): {
+    panelBand: (c: BuildContext, z: DamageZone, b: number, dirty: Set<Object3D>) => void;
+    roofOff: (c: BuildContext, z: DamageZone, inv: Matrix4) => void;
+    tailOff: (c: BuildContext, z: DamageZone, inv: Matrix4) => void;
+    followersIn: (c: BuildContext, z: DamageZone, inv: Matrix4) => Object3D<three.Object3DEventMap>[];
+    windowsOver: (c: BuildContext, z: DamageZone, inv: Matrix4) => Mesh<three.BufferGeometry<three.NormalBufferAttributes>, three.Material | three.Material[], three.Object3DEventMap>[];
+    doorGap: (c: BuildContext, z: DamageZone, b: number, cands: Object3D[]) => void;
+    mirrorHang: (c: BuildContext, z: DamageZone, ang: number) => void;
+    doorHang: (c: BuildContext, z: DamageZone, dirty: Set<Object3D>, inv: Matrix4) => void;
+    lidHang: (c: BuildContext, z: DamageZone, dirty: Set<Object3D>) => void;
+    flapHang: (c: BuildContext, z: DamageZone, dirty: Set<Object3D>) => void;
+};
+
+/** Per-zone damage for separate parts: lights, wheels, glass, internals, rotors and landing gear. */
+
+declare function installDamageParts(kit: Kit): {
+    glassPt: (c: BuildContext, g: Mesh, rnd: () => number) => Vector3;
+    glassIn: (c: BuildContext, g: Mesh) => Vector3;
+    glassBand: (c: BuildContext, z: DamageZone, g: Mesh, b: number) => void;
+    crackLensCache: Map<Material, Material>;
+    crackTextureCache: null;
+    crackTexture: () => CanvasTexture;
+    crackLens: (mat: Material) => Material;
+    lightBand: (c: BuildContext, z: DamageZone, Lt: VehicleLamp | null | undefined, b: number) => void;
+    tireMeshes: (w: Object3D) => Mesh[];
+    flattenTire: (w: Object3D, k: number) => void;
+    wheelBand: (c: BuildContext, z: DamageZone, w: Object3D | null | undefined, b: number) => void;
+    gearBand: (c: BuildContext, z: DamageZone, b: number) => void;
+    internalBand: (c: BuildContext, z: DamageZone, b: number) => void;
+    hoodBand: (c: BuildContext, z: DamageZone, b: number, dirty: Set<Object3D>) => void;
+    bumperBand: (c: BuildContext, z: DamageZone, b: number, dirty: Set<Object3D>) => void;
+    partBand: (c: BuildContext, z: DamageZone, b: number, dirty: Set<Object3D>) => void;
+    bendAft: (c: BuildContext, z: DamageZone, kx: number, ky: number, ang: number, dirty: Set<Object3D>) => void;
+};
+
+/** Fuel tank explosion, fireball, flying debris and burnt-out state. */
+
+declare function installExplosion(kit: Kit): {
+    BURNT: MeshStandardMaterial[];
+    BURNT_RUB: MeshStandardMaterial;
+    boomMat: (hex: ColorRepresentation, op: number, add?: boolean) => MeshBasicMaterial;
+    enginePos: (c: BuildContext) => any;
+    fling: (c: BuildContext, obj: Object3D, v: Vector3, w: Vector3) => FlyingPiece | null;
+    burnAll: (c: BuildContext) => void;
+    bigBoomFx: (c: BuildContext) => void;
+    detonate: (c: BuildContext) => void;
+    tickBoom: (c: BuildContext, dt: number) => void;
+    tickFlying: (c: BuildContext, dt: number) => void;
+};
+
+/** A lobe of a puddle's outline: its angle, width, how far it reaches and when it stops growing. */
+type PuddleLobe = {
+    a: number;
+    w: number;
+    amp: number;
+    stop: number;
+};
+/** A puddle on the ground (`puddle`): its mesh, age, final radius, centre, outline lobes and noise, and the oil drop, crown, gasoline haze and rim it may have. */
+type Puddle = {
+    kind: string;
+    m: Mesh<BufferGeometry, MeshStandardMaterial>;
+    t: number;
+    max: number;
+    x0: number;
+    z0: number;
+    lobes: PuddleLobe[];
+    nz: (x: number, y: number) => number;
+    ph: number;
+    R?: Float32Array;
+    rim?: Mesh<BufferGeometry, MeshBasicMaterial>;
+    drop?: Mesh;
+    dy0?: number;
+    crown?: Mesh<BufferGeometry, MeshStandardMaterial>;
+    phase?: number;
+    haze?: Mesh<BufferGeometry, MeshBasicMaterial>;
+    fire?: boolean;
+};
+/** A fluid type after `defineFluid`: the definition with its key and both colours. */
+type ResolvedFluid = FluidDefinition & {
+    key: string;
+    freshC: Color;
+    dryC: Color;
+    dryTime: number;
+    roughFresh: number;
+    roughDry: number;
+    metalFresh: number;
+    metalDry: number;
+};
+/** A splat on the body (`kit.splat`) with its trickle. */
+type Splat = {
+    kind: string;
+    def: ResolvedFluid;
+    grp: Group;
+    mat: MeshStandardMaterial;
+    drip: Mesh;
+    r: number;
+    t: number;
+    onGlass: boolean;
+    Lmax: number;
+    off: number[];
+    len: number;
+    w0: number;
+};
+declare function installFluids(kit: Kit): {
+    _fr: three.Raycaster;
+    buildDrip: (f: Splat, L: number) => void;
+    DOWNHILL: Vector3;
+    PN: number;
+    puddleGeometry: () => BufferGeometry<three.NormalBufferAttributes>;
+    rimGeometry: () => BufferGeometry<three.NormalBufferAttributes>;
+    puddle: (c: BuildContext, kind: string, pLocal: Vector3, maxR: number) => Puddle;
+    shapePuddle: (f: Puddle) => number;
+    updateFluids: (c: BuildContext, dt: number) => void;
+};
+
+/** The material of a pane with cracks drawn on it. A host warms its program at load with any texture: the first crack is in the middle of a blast. */
+declare function crackedGlassMaterial(THREE: Three, texture: Texture): MeshStandardMaterial;
+/** What `crackLight` reads of a lamp the kit drew (`c.lights`) and of its vehicle. */
+type LampMesh = Mesh;
+type CrackedLamp = {
+    lens: LampMesh[];
+    inner: LampMesh[];
+    halo?: Array<{
+        visible: boolean;
+    }>;
+    group: Object3D | null;
+    tint: string;
+    broken: unknown;
+    cracked?: boolean;
+    dark?: boolean;
+};
+declare function installGlassDamage(kit: Kit): {
+    glassUV: (c: BuildContext, msh: Mesh, pLocal: Vector3) => number[];
+    drawWeb: (x: CanvasRenderingContext2D, cx: number, cy: number, s: number, ax: number, rnd: () => number) => void;
+    crackGlass: (c: BuildContext, msh: Mesh, p: Vector3, force: number, sc?: number | null) => void;
+    glassRim: (geo: BufferGeometry, rnd: () => number) => BufferGeometry<three.NormalBufferAttributes> | null;
+    shatterGlass: (c: BuildContext, msh: Mesh, force: number, dir: Vector3) => void;
+    hitGlass: (c: BuildContext, msh: Mesh | null | undefined, p: Vector3, dir: Vector3, force: number) => void;
+    breakLight: (c: BuildContext, L: VehicleLamp | null | undefined, dir: Vector3) => void;
+    crackLight: (c: BuildContext, L: CrackedLamp, dir: Vector3, pierced: boolean) => void;
+};
+
+/** Hoods, engine bays and hinge helpers. */
+
+/** The engine bay of `kit.engineBay`: firewall and front x, half width, floor and free height, motor, axle x, paint, and the labels and views of the bay. */
+type EngineBaySpec = {
+    x0: number;
+    x1: number;
+    zw: number;
+    floor: number;
+    top: number;
+    motor?: string;
+    axle?: number;
+    col?: ColorRepresentation;
+    label?: LabelArgument;
+    turbo?: boolean;
+    view?: unknown;
+};
+declare function installHood(kit: Kit): {};
+
+/** The dent of one impact: point, direction into the body, radius, depth, ripple phase and the body centre it never crosses. */
+type DentSpot = {
+    p: Vector3;
+    dir: Vector3;
+    R: number;
+    depth: number;
+    ph: number;
+    C: Vector3;
+};
+declare function installImpact(kit: Kit): {
+    dentField: (v: Vector3, H: DentSpot) => number;
+    hangBumper: (c: BuildContext, o: Mesh | null | undefined, p: Vector3) => void;
+    tankFuel: (c: BuildContext, pt: {
+        label?: string;
+        fuel?: string;
+    }) => "diesel" | "gasoline" | null;
+    hurtEngine: (c: BuildContext, h: number) => void;
+    igniteFuel: (c: BuildContext, pd: Puddle | null | undefined) => void;
+    applyPart: (c: BuildContext, pt: VehiclePart, force: number, dir: Vector3, p: Vector3) => any;
+    SCRATCH_MATERIAL: MeshStandardMaterial;
+    SOOT_MATERIAL: MeshStandardMaterial;
+    _ray: three.Raycaster;
+    findSurface: (c: BuildContext, p: Vector3, dir: Vector3) => {
+        p: Vector3;
+        n: Vector3;
+        obj: Object3D<three.Object3DEventMap>;
+    } | null;
+    scratches: (c: BuildContext, p: Vector3, dir: Vector3, force: number) => void;
+    impact: (c: BuildContext, p: Vector3, dir: Vector3, force: number, opts?: ImpactOptions | null) => VehiclePart[];
+    _pr: three.Raycaster;
+    probe: (c: BuildContext, o: Vector3, d: Vector3, far: number) => {
+        p: Vector3;
+        obj: Object3D<three.Object3DEventMap>;
+    } | null;
+    zoneImpact: (c: BuildContext, zone: string, force: number) => VehiclePart[];
+};
+
+/** Cabin interior: seats, steering wheel, dashboard and bus rows. */
+
+/** A seat (`kit.seat`): width, seat height, length, backrest, lean, places on a bench, facing (+1 forward), material, headrest, sideways face and the parent it hangs from. */
+type SeatOptions = {
+    w?: number;
+    h?: number;
+    len?: number;
+    back?: number;
+    lean?: number;
+    n?: number;
+    dir?: number;
+    mat?: Material;
+    headrest?: boolean;
+    face?: string;
+    parent?: Object3D | null;
+};
+/** A dashboard (`kit.dashboard`): front edge x, top y, width, depth, height, driver z, material, top material and the screen. */
+type DashboardOptions = {
+    x: number;
+    y: number;
+    w: number;
+    d?: number;
+    h?: number;
+    drv?: number | null;
+    mat?: Material;
+    top?: Material;
+    screen?: boolean;
+};
+/** A car cabin (`kit.interior`), see the comment above it. */
+type InteriorOptions = {
+    x0: number;
+    ft: number;
+    rb: number;
+    rt: number;
+    roof: number;
+    belt: number;
+    floor: number;
+    zIn: number;
+    zRoof?: number;
+    zSeat?: number;
+    seatH?: number;
+    rows?: number;
+    col?: ColorRepresentation;
+    trim?: ColorRepresentation;
+    drive?: number;
+    front?: string;
+    xFront?: number;
+    xRear?: number;
+    noConsole?: boolean;
+};
+/** Bus rows (`kit.busRows`), see the comment above it. */
+type BusRowsOptions = {
+    x0: number;
+    x1: number;
+    pitch?: number;
+    floor: number;
+    zIn: number;
+    aisle?: number;
+    col?: ColorRepresentation;
+    seatH?: number;
+    ceil?: number;
+    poles?: boolean;
+    rails?: boolean;
+    mat?: Material;
+};
+declare function installInterior(kit: Kit): {
+    consoleBox: (c: BuildContext, x: number, fl: number, h: number, mat: MeshStandardMaterial) => void;
+};
+
+/** Where a lamp or a grille sits and how big it is (`c.vehicle` coordinates, metres); `side` +1 right, -1 left (default: the sign of `z`). */
+type LampPlacement = {
+    x: number;
+    y: number;
+    z: number;
+    w?: number;
+    h?: number;
+    d?: number;
+    side?: number;
+    label?: string;
+    noPart?: boolean;
+    reach?: number;
+    halo?: boolean;
+};
+type HeadlightOptions = LampPlacement & {
+    style?: 'round' | 'dround' | 'rect' | 'slim' | 'split' | 'wedge' | 'ledbar' | 'truck';
+    yaw?: number;
+    /** the material that glows (default `MATERIALS.head`) */
+    mat?: MeshStandardMaterial;
+    lens?: MeshStandardMaterial;
+};
+type TaillightOptions = LampPlacement & {
+    style?: 'wrap' | 'bar' | 'vertical' | 'L' | 'round2';
+    /** length of the wrap-around */
+    wrap?: number;
+};
+type GrilleOptions = {
+    x: number;
+    y: number;
+    z?: number;
+    w?: number;
+    h?: number;
+    style?: 'bars' | 'mesh' | 'big' | 'seven' | 'closed' | 'truck';
+    col?: ColorRepresentation;
+    emblem?: boolean;
+};
+declare function installLights(kit: Kit): {
+    lampGroup: (c: BuildContext, x: number, y: number, z: number, rotY: number) => three.Group<three.Object3DEventMap>;
+    gm: (g: Object3D, geo: BufferGeometry, mat: Material, x?: number, y?: number, z?: number) => three.Mesh<BufferGeometry<three.NormalBufferAttributes>, Material, three.Object3DEventMap>;
+    wedgeY: (geo: BufferGeometry, w: number, s: number, k: number) => BufferGeometry<three.NormalBufferAttributes>;
+    haloTex: null;
+    glowTexture: () => CanvasTexture;
+    haloMats: Record<string, SpriteMaterial>;
+    halo: (parent: Object3D, x: number, y: number, z: number, size: number, hex: string, op: number) => Sprite;
+    lampKit: (g: Object3D, d: number, inner: Object3D[], lens: Object3D[], lensMat: MeshStandardMaterial, refl?: MeshStandardMaterial) => {
+        housing: (w: number, h: number, y?: number, z?: number, geoFn?: (geo: BufferGeometry) => void) => three.Mesh<BufferGeometry<three.NormalBufferAttributes>, Material, three.Object3DEventMap>;
+        lens: (w: number, h: number, y?: number, z?: number, geoFn?: (geo: BufferGeometry) => void) => three.Mesh<BufferGeometry<three.NormalBufferAttributes>, Material, three.Object3DEventMap>;
+        glow: (geo: BufferGeometry, mat: MeshStandardMaterial, x: number, y: number, z: number) => three.Mesh<BufferGeometry<three.NormalBufferAttributes>, Material, three.Object3DEventMap>;
+        proj: (y: number, z: number, r: number, mat: MeshStandardMaterial) => three.Mesh<BufferGeometry<three.NormalBufferAttributes>, Material, three.Object3DEventMap>;
+    };
+};
+
+/** What a particle may override: colour, variant (`red`, `white`...), opacity, size, life, growth, material, rest height. */
+type SpawnOptions = {
+    col?: ColorRepresentation;
+    variant?: string;
+    op?: number;
+    s?: number;
+    life?: number;
+    grow?: number;
+    nofog?: boolean;
+    mat?: Material;
+    r?: number;
+    floor?: number;
+};
+/** A burst of particles: the spawn options plus a main direction, speed, spread and how far from the point they start. */
+type BurstOptions = SpawnOptions & {
+    dir?: Vector3;
+    speed?: number;
+    spread?: number;
+    jitter?: number;
+};
+declare function installParticles(kit: Kit): {
+    PARTICLE_LIMIT: number;
+    PARTICLE_GEOMETRIES: Record<string, BufferGeometry<three.NormalBufferAttributes>>;
+    PARTICLE_MATERIALS: Record<string, Material>;
+    valueNoise: (seed: number) => (x: number, y: number) => number;
+    puffTexture: (seed: number, fire: boolean) => CanvasTexture;
+    puffMaterial: (fire: boolean, col: ColorRepresentation, op: number) => any;
+    SPRITE_TYPES: Record<string, number>;
+    PUFF_COLORS: Record<string, [string, number]>;
+    WIND: Vector3;
+    PARTICLE_LIFE: Record<string, number>;
+    TRANSIENT_TYPES: Record<string, number>;
+    killParticle: (c: BuildContext, i: number) => void;
+    _q: three.Quaternion;
+    _z: Vector3;
+    _t: Vector3;
+    tickParticles: (c: BuildContext, dt: number) => void;
+    burst: (c: BuildContext, type: string, pFx: Vector3, n: number, o?: BurstOptions | null) => void;
+    exhaustLook: (h: number) => (string | number)[];
+    tickEmit: (c: BuildContext, dt: number) => void;
+};
+
+declare function installRollover(kit: Kit): {
+    rollMeshes: (c: BuildContext) => {
+        list: RollMesh[];
+        thin: RollMesh[];
+    };
+    convexHull: (pts: number[][]) => number[][];
+    rollContact: (c: BuildContext, A: RollState, q: readonly number[]) => void;
+    exactMinY: (c: BuildContext, list: readonly RollMesh[]) => number;
+    finishRoll: (c: BuildContext) => void;
+    tickRoll: (c: BuildContext, dt: number) => void;
+};
+
+declare function installScenarios(kit: Kit): {
+    BODY_TYPES: {
+        panel: number;
+        door: number;
+        roof: number;
+        lid: number;
+        hood: number;
+        bumper: number;
+    };
+};
+
+/** Per-frame update loop for particles, fluids, spinning parts and rollover. */
+
+declare function installTick(kit: Kit): {};
+
+declare function installTrucks(kit: Kit): {};
+
+declare function installWheels(kit: Kit): {};
+
+declare function installZoneApply(kit: Kit): {
+    fadePaint: (c: BuildContext) => void;
+    abandonFx: (c: BuildContext) => void;
+    burntFx: (c: BuildContext) => void;
+    settleDrops: (c: BuildContext) => void;
+};
+
+declare function installZoneAuto(kit: Kit): {
+    autoZones: (c: BuildContext) => DamageZone[];
+};
+
+/** A mesh a decal ray can hit: the mesh itself, or a proxy of a heavy one that holds only the triangles of the zone's region. */
+type DecalCandidate = Mesh & {
+    proxyOf?: Mesh;
+    kept?: Uint32Array;
+    keptBox?: Float32Array;
+    keptBlocks?: Float32Array;
+};
+/** A point of the bodywork found by the rays (`c.vehicle` coordinates) and the mesh under it. */
+type SurfacePoint = {
+    p: Vector3;
+    n: Vector3;
+    obj?: Object3D;
+};
+/** How many marks of each kind `zoneDecals` puts on a zone. */
+type DecalCounts = {
+    fine?: number;
+    deep?: number;
+    chip?: number;
+    rust?: number;
+    tear?: number;
+    ding?: number;
+    soot?: number;
+    crater?: number;
+};
+declare function installZoneDecals(kit: Kit): {
+    dmat: (hex: string, o: MaterialOptions) => MeshStandardMaterial;
+    DAMAGE_MATERIALS: Record<string, MeshStandardMaterial>;
+    _zq: three.Quaternion;
+    _zq2: three.Quaternion;
+    _zz: Vector3;
+    orientDecal: (m: Object3D, p: Vector3, n: Vector3, ang: number) => void;
+    decalMesh: (c: BuildContext, geo: BufferGeometry, mat: MeshStandardMaterial, p: Vector3, n: Vector3, ang: number, obj?: Object3D | null) => Mesh<BufferGeometry<three.NormalBufferAttributes>, three.Material | three.Material[], three.Object3DEventMap>;
+    blobGeometry: (r: number, rnd: () => number, jag?: boolean, ell?: number) => three.ShapeGeometry;
+    tearDecal: (c: BuildContext, p: Vector3, n: Vector3, r: number, rnd: () => number, obj: Object3D | null | undefined) => Mesh<BufferGeometry<three.NormalBufferAttributes>, three.Material | three.Material[], three.Object3DEventMap>;
+    _zr: Raycaster;
+    zoneCands: (c: BuildContext, z: DamageZone, inv: Matrix4, glassToo?: boolean) => DecalCandidate[];
+    _dsetC: WeakMap<Mesh<BufferGeometry<three.NormalBufferAttributes>, three.Material | three.Material[], three.Object3DEventMap>[], Set<Object3D<three.Object3DEventMap>>>;
+    skinOK: (c: BuildContext, z: DamageZone, o: SceneNode, ow: DamageZone | null | undefined) => boolean;
+    axisOf: (d: Vector3) => 0 | 1 | 2;
+    zoneSurf: (c: BuildContext, z: DamageZone, n: number, rnd: () => number, cands: DecalCandidate[], o?: {
+        u0?: number;
+        u1?: number;
+    } | null) => SurfacePoint[];
+    _rt: Raycaster;
+    scratchPath: (c: BuildContext, s: SurfacePoint, len: number, ang: number, cands: DecalCandidate[], B: ZoneBox | null | undefined) => SurfacePoint[] | null;
+    ribbonGeo: (pts: SurfacePoint[], wd: number, lift: number) => BufferGeometry<three.NormalBufferAttributes>;
+    scratchDecal: (c: BuildContext, s: SurfacePoint, len: number, wd: number, mat: MeshStandardMaterial, ang: number, cands: DecalCandidate[], B: ZoneBox | null | undefined, pts?: SurfacePoint[] | null) => Mesh<BufferGeometry<three.NormalBufferAttributes>, three.Material | three.Material[], three.Object3DEventMap> | null;
+    zoneDecals: (c: BuildContext, z: DamageZone, spec: DecalCounts, cands: DecalCandidate[]) => SurfacePoint[];
+};
+
+/** A mesh a zone dents, and whether it is the vehicle's shell (`c.deform`). */
+type DentTarget = {
+    o: Mesh;
+    deform: boolean;
+};
+/** A dent: centre (`u`, `v`, absolute tangent coordinates), radii (`ru`, `rv`, metres), depth and the phase of its ripple. */
+type Dent = {
+    u: number;
+    v: number;
+    ru: number;
+    rv: number;
+    depth: number;
+    ph: number;
+};
+type DentOptions = {
+    /** a crease along the panel: its `v`, width and depth */
+    crease?: {
+        v: number;
+        w: number;
+        depth: number;
+    } | null;
+    /** how close to the zone's edge the dent fades, as a share of it */
+    edge?: number;
+    /** the meshes to dent (default: `dentTargets`) */
+    targets?: DentTarget[];
+    noSub?: boolean;
+    /** the longest edge after subdividing, metres */
+    sub?: number;
+    /** moves a point already dented by `f` */
+    extra?: (p: Vector3, f: number) => void;
+    /** moves any point of the mesh; answers whether it moved */
+    extraAll?: (p: Vector3) => boolean;
+};
+/** A piece `cutPanel` made: the whole mesh (`whole`), a cut piece hung on the vehicle (`mesh`), or a cut whose piece was dropped (`cut` alone). */
+type PanelPiece = {
+    mesh?: Mesh;
+    whole?: boolean;
+    cut?: boolean;
+};
+type CutPanelOptions = {
+    anyN?: boolean;
+    pieceTasks?: Map<Mesh, {
+        geo: BufferGeometry;
+        step: (deadline: number) => boolean;
+    }>;
+};
+declare function installZoneDent(kit: Kit): {
+    sm: (t: number) => number;
+    subdivIn: (geo: BufferGeometry, rel: Matrix4, B: ZoneBox, maxLen: number) => BufferGeometry<three.NormalBufferAttributes>;
+    dentTargets: (c: BuildContext, z: DamageZone, inv: Matrix4) => DentTarget[];
+    zoneDent: (c: BuildContext, z: DamageZone, dents: Dent[], dirty: Set<Object3D>, opt?: DentOptions | null) => {
+        field: (p: Vector3) => number;
+        moved: Object3D<three.Object3DEventMap>[];
+        ax: number[];
+        a: number;
+        cu: number;
+        cv: number;
+        hu: number;
+        hv: number;
+        outer: number;
+    };
+    cutPanel: (c: BuildContext, z: DamageZone, rect: number[], keep: boolean, dirty: Set<Object3D>, o?: CutPanelOptions | null) => PanelPiece[];
+    pivotOf: (c: BuildContext, objs: readonly (Object3D | null | undefined)[], at: Vector3) => three.Group<three.Object3DEventMap>;
+};
 
 var plate = {
 	band: "BRAZIL"
@@ -295,7 +1281,7 @@ type PartialLocaleStrings = {
     [K in keyof LocaleStrings]?: Partial<LocaleStrings[K]>;
 };
 /** Registers (or extends) a locale under a code such as `es` or `pt-BR`. Missing keys fall back to English. */
-declare function registerLocale(code: string, strings: PartialLocaleStrings | Record<string, any>): void;
+declare function registerLocale(code: string, strings: PartialLocaleStrings | Record<string, unknown>): void;
 /** Codes of the registered locales. */
 declare function listLocales(): string[];
 /**
@@ -312,6 +1298,134 @@ type Translate = (key: string, vars?: Record<string, unknown>) => string;
  * `{side}` (feminine word) and `{sideM}` (masculine word), so one template reads right in languages with grammatical gender.
  */
 declare function createTranslate(strings: LocaleStrings): Translate;
+/** Regular expressions that recognise a part by its label when no `key` was given. Built from the `matchers` of the string table. */
+interface Matchers {
+    windshield: RegExp;
+    rear: RegExp;
+    side: RegExp;
+    tank: RegExp;
+    diesel: RegExp;
+    fuel: RegExp;
+    /** Zone ids that already start like a glass id, so no `glass_` prefix is added. */
+    glassId: RegExp;
+}
+declare function createMatchers(strings: LocaleStrings): Matchers;
+
+/** Pure helpers shared by every module. They never touch three.js. */
+/** Deterministic hash of three numbers to [0, 1). */
+declare function hash(a: number, b: number, c: number): number;
+declare function clamp(v: number, a: number, b: number): number;
+/** Smoothstep on [0, 1]. */
+declare function smooth(t: number): number;
+/** Mulberry32 pseudo random generator. The same seed always gives the same sequence. */
+declare function rng(seed: number): () => number;
+/** FNV-1a hash of a string, used to derive seeds from vehicle keys and zone ids. */
+declare function strHash(s: string): number;
+
+/** The three.js namespace the host passes (typed by `@types/three`; the package binds to no version at runtime). */
+type Three = typeof three;
+/** The helpers the modules share through `kit._`: what each `install*` puts there. */
+type KitShared = ReturnType<typeof installContext> & ReturnType<typeof installArmor> & ReturnType<typeof installBody> & ReturnType<typeof installCar> & ReturnType<typeof installDamagePanels> & ReturnType<typeof installDamageParts> & ReturnType<typeof installExplosion> & ReturnType<typeof installFluids> & ReturnType<typeof installGeometry> & ReturnType<typeof installGlassDamage> & ReturnType<typeof installGlass> & ReturnType<typeof installHood> & ReturnType<typeof installImpact> & ReturnType<typeof installInterior> & ReturnType<typeof installLights> & ReturnType<typeof installMaterials> & ReturnType<typeof installParticles> & ReturnType<typeof installRollover> & ReturnType<typeof installScenarios> & ReturnType<typeof installTick> & ReturnType<typeof installTrucks> & ReturnType<typeof installWarp> & ReturnType<typeof installWheels> & ReturnType<typeof installZoneApply> & ReturnType<typeof installZoneAuto> & ReturnType<typeof installZoneCore> & ReturnType<typeof installZoneDecals> & ReturnType<typeof installZoneDent> & ReturnType<typeof installZoneDerive>;
+/**
+ * Internal shape of the kit while the modules are installing. Modules attach the public API to it (`kit.x = ...`)
+ * and share helpers through `kit._`. The public, typed view of the same object is `VehicleKit` in `api.ts`.
+ */
+interface Kit {
+    THREE: Three;
+    V3: Three['Vector3'];
+    PI: number;
+    /** The page's document (the canvases of the glass, lamp and smoke textures); a host with no DOM never draws them. */
+    document: Document;
+    strings: ReturnType<typeof resolveStrings>;
+    t: (key: string, vars?: Record<string, unknown>) => string;
+    matchers: ReturnType<typeof createMatchers>;
+    hash: typeof hash;
+    clamp: typeof clamp;
+    smooth: typeof smooth;
+    /** Helpers shared between modules (not public). */
+    _: KitShared;
+    [key: string]: any;
+}
+/** The object a vehicle is built in (`kit.build` returns it): the groups, the parts, the zones and the builders `add`, `roundBox`, `part`, ... */
+type BuildContext = InstanceType<KitShared['BuildContext']>;
+/**
+ * A node of a vehicle's scene graph as the modules read it while they walk it (`traverse`): any `Object3D`, with what a mesh, a sprite or
+ * a group adds there when it is one. The modules check the flags (`isMesh`, `isSprite`) before they touch the mesh fields.
+ */
+type SceneNode = Object3D & {
+    geometry?: BufferGeometry;
+    material?: Material;
+    morphTargetInfluences?: number[];
+    isMesh?: boolean;
+    isSprite?: boolean;
+    isGroup?: boolean;
+    isInstancedMesh?: boolean;
+    isSkinnedMesh?: boolean;
+    isLight?: boolean;
+    isPoints?: boolean;
+    isLine?: boolean;
+};
+
+/**
+ * Light mode ("lite"): the same vehicles with fewer triangles, for a whole street of them. Port of the `[LOD]` hooks of the team's Frota Leve
+ * (frota-leve.js lines 21-65, 232-257, 1205-1221, 14155-14170). Every number is a setting; with `on` false nothing changes, so every golden
+ * of the full-detail build stays byte for byte the same.
+ */
+
+interface LodSettings {
+    /** Light mode is active for the builds that run now. Set by `kit.build(key, state, zones, { lod: true })`. */
+    on: boolean;
+    /** Fraction of the segments three's own generators keep (cylinders, spheres, tori, lathes, tubes, extrusions, circles, rings). */
+    segmentFraction: number;
+    /** Rounding rings of a rounded box (the full build uses 3). */
+    roundingRings: number;
+    /** Multiplier of the maximum edge length when subdividing a mesh (bigger triangles). */
+    subdivisionFactor: number;
+    /** A box with an edge under this, or a rounding radius under 1.2 cm, is drawn as a plain 12-triangle box. */
+    flatBoxEdge: number;
+    /** Fewest segments of a superellipse loft. */
+    minLoftSegments: number;
+    /** Fraction of a loft's segments. */
+    loftSegmentFraction: number;
+    /** Fewest stations of a resampled loft. */
+    minStations: number;
+    /** Fraction of the stations of a resampled loft. */
+    stationFraction: number;
+    /** Multiplier of the grid cell size of grilles and side grilles. */
+    gridFactor: number;
+    /** Materials (by name in `kit.materials`) whose meshes are never seen from outside and are left out in light mode. */
+    hiddenMaterials: readonly string[];
+}
+declare const defaultLodSettings: LodSettings;
+/** The settings the kit starts with: the defaults, overridden by the options. */
+declare function createLod(options?: Partial<LodSettings>): LodSettings;
+/**
+ * A copy of the three.js namespace whose geometry generators take fewer segments while `lod.on` is true (and whose canvas textures come out in
+ * sRGB when three has colour management). With `lod.on` false every generator passes its arguments through untouched.
+ */
+declare function wrapThreeForLod(TH: Three, lod: LodSettings): Three;
+
+/** Smoke, fire and dust puffs handed to the host's effects world instead of the kit's own sprites. */
+/** What `EffectSink.play` of `game-contracts` takes, as a structural type: this package does not depend on the contracts layer. */
+interface ParticleEffectRequest {
+    readonly effect: string;
+    readonly point: [number, number, number];
+    readonly values: Readonly<Record<string, number>>;
+}
+/** The host's effects world as far as the puffs need it (`EffectSink` of `game-contracts` fits). */
+interface ParticleEffects {
+    play(request: ParticleEffectRequest): unknown;
+}
+
+type DamageableMaterial = 'metal' | 'glass' | 'rubber' | 'fuel';
+type DamageableSide = 'center' | 'left' | 'right';
+/** What a zone is, by type: the material it is made of and the part name a game shows. */
+interface DamageableKind {
+    material: DamageableMaterial;
+    part: string;
+}
+/** Zone type (and, for some, `fxKey` or `sub`) to material and part. A game replaces or adds entries with `kit.damageableKinds`. */
+declare const defaultDamageableKinds: Record<string, DamageableKind>;
 
 /**
  * Public types of `@adatechnology/game-vehicles`.
@@ -337,8 +1451,10 @@ interface Band {
     /** CSS colour used by the UI widgets. */
     color: string;
 }
-/** Where a vehicle is built: the context returned by {@link VehicleKit.build}. */
-interface VehicleContext {
+/** Where a vehicle is built: the context returned by {@link VehicleKit.build}, with the builders of {@link BuildContext}. */
+type VehicleContext = BuildContext & VehicleContextFields;
+/** The fields of a built vehicle's context. */
+interface VehicleContextFields {
     /** Add this to the scene. */
     root: ThreeObject;
     /** The vehicle itself (a child of `root`); zones, parts and meshes live here. */
@@ -375,8 +1491,11 @@ interface VehicleMeta {
     bodyKind?: 'box' | 'body';
     exhaust?: ThreeVector | false;
     exhaustDir?: ThreeVector;
-    /** Replaces the default armour (state `modified`). */
-    armor?: (c: VehicleContext, kit: VehicleKit) => void;
+    /**
+     * Replaces the default armour (state `modified`). A few fleet vehicles write their protection level here as text (`'III'`) while they
+     * build and set the builder afterwards.
+     */
+    armor?: ((c: VehicleContext, kit: VehicleKit) => void) | string;
     [key: string]: any;
 }
 interface VehicleSpec {
@@ -410,6 +1529,77 @@ type PartLabel = string | {
     key: string;
     label?: string;
 };
+/** A mesh the rollover rests on, with its matrix into the vehicle frame (`rollMeshes`). */
+interface RollMesh {
+    o: Mesh;
+    M: Matrix4;
+}
+/** A rollover in progress (`kit.roll`): time and duration, side, the support hull S ([y, z]), the contact point and the fall target. */
+interface RollState {
+    t: number;
+    dur: number;
+    s: number;
+    S: number[][];
+    last: number;
+    cz: number;
+    target: number;
+    x: number;
+    L: number;
+    bounce: number;
+    cen: number[];
+    hitAt: readonly number[] | null;
+    hits: number;
+    thin: RollMesh[];
+    y0: number;
+    /** State a plugin keeps on the rollover (the fleet's military group marks its own handling). */
+    [extra: string]: unknown;
+}
+/** A part thrown by an explosion (`fling`): its holder, linear and angular velocity, radius, whether it landed and how long it keeps burning. */
+interface FlyingPiece {
+    o: Group;
+    v: Vector3;
+    w: Vector3;
+    r: number;
+    landed: boolean;
+    trail: number;
+}
+/** A part turning on its own every frame (a wheel, a rotor, a propeller): `v` radians per second about `axis`, slowing by `decay` per second. */
+interface VehicleSpin {
+    o: Object3D;
+    axis: 'x' | 'y' | 'z';
+    v: number;
+    decay?: number;
+    /** a road wheel, turned by the vehicle's speed */
+    track?: boolean;
+    /** a per-frame hook disguised as a spin (its `o.rotation` getter runs code), not a real part */
+    hook?: boolean;
+}
+/** A continuous source of smoke or fire (`kit.addEmitter`): where (`c.vehicle`, or the vehicle world with `world`), how many puffs a second. */
+interface VehicleEmitter {
+    p: Vector3;
+    kind: string;
+    world: boolean;
+    rate: number;
+    acc: number;
+    s: number;
+    dir: Vector3 | null;
+    gap: number;
+}
+/** A lamp the kit drew (`c.lights`): its group, the lens and the inner meshes (bulb, reflector), its tint and what happened to it. */
+interface VehicleLamp {
+    group: ThreeObject | null;
+    lens: ThreeObject[];
+    inner: ThreeObject[];
+    kind: string;
+    tint: string;
+    /** broken; `'gone'` once the whole unit came off */
+    broken: boolean | 'gone';
+    cracked?: boolean;
+    dark?: boolean;
+    /** The additive halo sprites of the lamp, hidden when it breaks. */
+    halo?: ThreeObject[];
+    [extra: string]: unknown;
+}
 /** A damage zone of a built vehicle. */
 interface DamageZone {
     id: string;
@@ -421,13 +1611,25 @@ interface DamageZone {
     health: number;
     band: number;
     internal?: boolean;
-    owned?: boolean;
+    /** The objects of the vehicle the zone holds (resolved when the zones are derived). */
+    owned: ThreeObject[];
+    /** The lamps, panes and wheels the zone holds. */
+    lights: VehicleLamp[];
+    glass: ThreeObject[];
+    wheels: ThreeObject[];
     tags: string[];
     /** `[xMin, xMax, zMin, zMax]` rectangle on the top-down damage map. */
     map: [number, number, number, number];
-    box: ThreeObject;
+    /** The zone's box in `c.vehicle` coordinates. */
+    box: ZoneBox;
     /** Overrides the id used to seed the random damage (keeps the output of an earlier pack identical). */
     seedId?: string;
+    /** What the zone is (`panel`, `door`, `glass`, `light`, `wheel`, `internal`...). */
+    type: string;
+    /** The internal system an internal zone stands for (`engine`, `fuel_tank`, `underbody`...). */
+    sub?: string;
+    /** The effects key (sounds, labels) when it differs from the id. */
+    fxKey?: string;
     [key: string]: any;
 }
 /** Health per zone id (0..100) and scenario flags. */
@@ -608,6 +1810,10 @@ interface ParticleMaterials {
 interface ImpactOptions {
     /** Do not leave a stain. */
     noStain?: boolean;
+    /** No sparks, scrap or splashes. */
+    noFx?: boolean;
+    /** Deepest dent in metres (the default comes from the width and the force). */
+    maxDepth?: number;
     [key: string]: any;
 }
 interface SplatOptions {
@@ -631,6 +1837,11 @@ interface ZoneDamageEntry {
     name: string;
     damage: number;
 }
+/** What `zoneDamageAt` returns: the id of the zone hit and the damage it spread to every zone near the point. */
+interface ZoneDamageResult {
+    main: string | null;
+    list: ZoneDamageEntry[];
+}
 interface DamageMapOptions {
     /** Id of the selected zone. */
     selected?: string;
@@ -716,8 +1927,12 @@ interface VehicleKit {
     zoneScenario(c: VehicleContext, idOrName: string): ScenarioResult;
     zoneOverall(c: VehicleContext): OverallHealth;
     zoneAt(c: VehicleContext, point: ThreeVector, object?: ThreeObject): DamageZone | null;
-    zoneDamageAt(c: VehicleContext, point: ThreeVector, dir: ThreeVector, force: number, object?: ThreeObject): ZoneDamageEntry[];
-    zonePoint(c: VehicleContext, zone: DamageZone): ThreeVector;
+    zoneDamageAt(c: VehicleContext, point: ThreeVector, dir: ThreeVector, force: number, object?: ThreeObject): ZoneDamageResult;
+    /** Point and direction of an impact on one side (`front`, `rear`, `left` or `right`), in vehicle coordinates. */
+    zonePoint(c: VehicleContext, side: 'front' | 'rear' | 'left' | 'right' | string): {
+        p: Vector3;
+        dir: Vector3;
+    };
     zoneImpact(c: VehicleContext, side: 'front' | 'rear' | 'left' | 'right' | string, force: number): unknown;
     impact(c: VehicleContext, point: ThreeVector, dir: ThreeVector, force: number, options?: ImpactOptions): unknown[];
     splat(c: VehicleContext, point: ThreeVector, normal: ThreeVector, radius: number, options?: SplatOptions): {
@@ -776,17 +1991,6 @@ declare function legacyGlassId(key: string | null, label: string, side: number,
 /** Original id of a light zone: `farol_e`, `lanterna_c`, `farol_d_2`... */
 declare function legacyLightId(kind: string, side: string, index: number): string;
 
-/** Pure helpers shared by every module. They never touch three.js. */
-/** Deterministic hash of three numbers to [0, 1). */
-declare function hash(a: number, b: number, c: number): number;
-declare function clamp(v: number, a: number, b: number): number;
-/** Smoothstep on [0, 1]. */
-declare function smooth(t: number): number;
-/** Mulberry32 pseudo random generator. The same seed always gives the same sequence. */
-declare function rng(seed: number): () => number;
-/** FNV-1a hash of a string, used to derive seeds from vehicle keys and zone ids. */
-declare function strHash(s: string): number;
-
 /**
  * Armour levels of a vehicle, after NIJ 0108: the level says which rounds the glass and the steel stop, and how many hits they take
  * before they give. Every number is configurable: a game passes its own table in `VehicleDestructibleOptions.armourLevels`.
@@ -806,7 +2010,7 @@ type ArmourLevel = {
 declare const ARMOUR_LEVELS: Readonly<Record<ArmourLevelId, ArmourLevel>>;
 /** The level a vehicle has: the host's option, else its spec (`armor`), else III for the old `armored`/`bullet` flags, else none. */
 declare function armourLevelOf(meta: {
-    armor?: string;
+    armor?: unknown;
     armored?: boolean;
     bullet?: boolean;
 }, option?: ArmourLevelId | null): ArmourLevelId | null;
@@ -839,7 +2043,7 @@ interface PartDef {
     /** The damage zone this part is, when it is one. */
     zoneId?: string;
     /** The panes of a glass part no damage zone claims. */
-    panes?: any[];
+    panes?: Mesh[];
     /** Fluid held, in litres. */
     contains?: {
         fluid: string;
@@ -913,21 +2117,13 @@ interface CreaseQueue {
  */
 declare function createCreaseQueue(): CreaseQueue;
 
-/**
- * `createVehicleDestructible`: a vehicle that follows the destruction contract of `@adatechnology/game-contracts` and brings its own rules.
- * Every damage zone and mechanical part is a part with a material, hits become events (dent, hole, crack, fracture, detach, leak, ignite,
- * melt, explode), joints come apart by wear, by a wrench or by breaking, and the hidden mechanics change how the vehicle drives.
- *
- * It depends on the contracts only (types) and on the kit it is given: not on the default destruction world.
- */
-
 interface VehicleDestructibleOptions {
     /** Object id the host gives (`DestructibleImpl.id`). Default: the vehicle key. */
     id?: string;
     /** Display name. Default: the vehicle name. */
     name?: string;
     /** Object whose space `describe()` answers in (the wrapper the host placed the vehicle in). Default: `c.root`. */
-    frame?: any;
+    frame?: unknown;
     /** Tow hitch: the option wins over the spec flag, the spec flag over the seeded choice. */
     hitch?: boolean;
     /** Do not create or move any mesh (logic only, for servers and tests that need no scene). */
@@ -1024,7 +2220,7 @@ interface VehicleItemOptions {
 }
 interface VehicleItem {
     /** Add this to the scene: origin at the centre of the footprint on the floor, front facing +z. */
-    root: any;
+    root: Group;
     /** The built vehicle inside it. */
     vehicle: VehicleContext;
 }
@@ -1104,7 +2300,7 @@ interface CabinSource {
 }
 interface CabinEnclosureOptions {
     /** The object the destructible answers in (its `frame` option, where the host placed the vehicle): the holes of `state()` are in its space. Default `vehicle.root`. */
-    readonly frame?: any;
+    readonly frame?: unknown;
     /** Gaps of the shut doors and vents, share per second of the smoke pressing on the closed shell (default {@link CABIN_LEAK}). */
     readonly leak?: number;
     /** How open a door or lid has to be (share of its full swing) to count as open (default 0.06: ajar). */
@@ -1122,9 +2318,4 @@ declare function swingOf(vehicle: VehicleContext, partId: string): number;
  */
 declare function cabinEnclosure(source: CabinSource, options?: CabinEnclosureOptions): Enclosure | null;
 
-/** Glass cracks, shattering and tempered or laminated breakage textures. */
-
-/** The material of a pane with cracks drawn on it. A host warms its program at load with any texture: the first crack is in the middle of a blast. */
-declare function crackedGlassMaterial(THREE: any, texture: unknown): any;
-
-export { ARMOUR_LEVELS, type ArmourLevel, type ArmourLevelId, type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type BuildZoneState, CABIN_LEAK, CRASH_RULES, type CabinBox, type CabinEnclosureOptions, type CabinSource, type CrashOptions, type CrashResult, type CrashRules, type CreaseQueue, type CreaseWork, type DamageMapOptions, type DamageZone, type Damageable, type DamageableKind, type DamageableMaterial, type DamageableSide, type DriveReport, type ExplodeOptions, type FlagEffect, type FluidDefinition, type HeadlightLens, type ImpactOptions, JOINT_RULES, type JointDef, type KitConfiguration, type KitInternals, type KitTexts, LEGACY_STATES, LEGACY_ZONE_IDS, type LocalBox, type LocaleStrings, type LodSettings, type OverallHealth, type PartDef, type PartLabel, type PartRole, type PartialLocaleStrings, type ParticleEffectRequest, type ParticleEffects, type ParticleMaterials, type Plugin, type ResolvedConfiguration, SEED_SALTS, type ScenarioContext, type ScenarioDefinition, type ScenarioResult, type SplatOptions, type ThreeObject, type ThreeVector, type Translate, type UiHelpers, type VehicleContext, type VehicleDestructible, type VehicleDestructibleOptions, type VehicleItem, type VehicleItemOptions, type VehicleKit, type VehicleKitOptions, type VehicleMeta, type VehicleModel, type VehiclePart, type VehicleSpec, type VehicleStatus, type ZoneDamageEntry, type ZoneEffect, type ZoneState, armourLevelOf, buildVehicleItem, buildVehicleModel, cabinBoxOf, cabinEnclosure, clamp, crackedGlassMaterial, crashDeltaV, crashVehicle, createCreaseQueue, createLod, createTranslate, createVehicleDestructible, createVehicleKit, defaultDamageableKinds, defaultLodSettings, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash, swingOf, wrapThreeForLod };
+export { ARMOUR_LEVELS, type ArmourLevel, type ArmourLevelId, type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type BuildZoneState, type BusRowsOptions, CABIN_LEAK, CRASH_RULES, type CabinBox, type CabinEnclosureOptions, type CabinSource, type CarSpec, type CarWheel, type CrashOptions, type CrashResult, type CrashRules, type CreaseQueue, type CreaseWork, type CutTest, type DamageMapOptions, type DamageZone, type Damageable, type DamageableKind, type DamageableMaterial, type DamageableSide, type DashboardOptions, type DriveReport, type EngineBaySpec, type ExplodeOptions, type FlagEffect, type FluidDefinition, type GlassOptions, type GlassQuad, type Greenhouse, type GrilleOptions, type HeadlightLens, type HeadlightOptions, type ImpactOptions, type InteriorOptions, JOINT_RULES, type JointDef, type KitConfiguration, type KitInternals, type KitTexts, LEGACY_STATES, LEGACY_ZONE_IDS, type LabelArgument, type LocalBox, type LocaleStrings, type LodSettings, type LoftRow, type LoftStation, type OverallHealth, type PaneLook, type PartDef, type PartLabel, type PartRole, type PartialLocaleStrings, type ParticleEffectRequest, type ParticleEffects, type ParticleMaterials, type PathItem, type Plugin, type Puddle, type PuddleLobe, type ResolvedConfiguration, SEED_SALTS, type ScenarioContext, type ScenarioDefinition, type ScenarioResult, type SceneNode, type SeatOptions, type ShellSpec, type SmoothLoftOptions, type Splat, type SplatOptions, type TaillightOptions, type ThreeObject, type ThreeVector, type Translate, type TumbleSpec, type UiHelpers, type UnderbodySpec, type VehicleContext, type VehicleDestructible, type VehicleDestructibleOptions, type VehicleItem, type VehicleItemOptions, type VehicleKit, type VehicleKitOptions, type VehicleMeta, type VehicleModel, type VehiclePart, type VehicleSpec, type VehicleStatus, type WarpFn, type WarpOptions, type ZoneDamageEntry, type ZoneDef, type ZoneEffect, type ZoneState, armourLevelOf, buildVehicleItem, buildVehicleModel, cabinBoxOf, cabinEnclosure, clamp, crackedGlassMaterial, crashDeltaV, crashVehicle, createCreaseQueue, createLod, createTranslate, createVehicleDestructible, createVehicleKit, defaultDamageableKinds, defaultLodSettings, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash, swingOf, wrapThreeForLod };