@adatechnology/game-vehicles-three 0.6.3 → 0.7.0

package/dist/{chunk-MRUPKE7J.js → chunk-L63R2JQA.js}

@@ -1271,7 +1271,33 @@ var VEHICLE_SOUNDS = [
   recipe("car_trunk_close", [tone({ f: 90, f2: 55, d: 0.15, vol: 0.65 }), noise({ type: "bandpass", f: 500, q: 1, d: 0.12, vol: 0.5 }), ...latch(0.01, 0.28), noise({ type: "bandpass", f: 1800, q: 3, d: 0.04, vol: 0.1, delay: 0.06 })], "trunk or hatch shut: a lighter thump, the latch and a small rattle"),
   recipe("car_hood_close", [tone({ f: 70, f2: 40, d: 0.22, vol: 0.8 }), noise({ type: "bandpass", f: 850, q: 1.4, d: 0.2, vol: 0.6, wet: 0.3 }), tone({ f: 900, f2: 860, d: 0.18, vol: 0.05 }), ...latch(0.015, 0.3)], "hood slammed: a big sheet of metal ringing a little, the latch")
 ];
-var VEHICLE_SOUND_BANK = { id: "vehicles_three", sounds: VEHICLE_SOUNDS, loops: VEHICLE_LOOPS };
+var CAR_RECORDED_RPM = { idle: 1e3, high: 2520 };
+var CAR_START_RUN_STOP = {
+  /** The starter and the engine catching (at 0.58 s) and flaring; the loops take over at the crank time of the vehicle. */
+  start: { offset: 0, duration: 1.3 },
+  /** The ignition off: the engine running down to the end of the file. */
+  stop: { offset: 9.96, duration: 0.64 }
+};
+var carLayer = (id, file, rpm, harmonic, offset) => ({
+  id,
+  file,
+  loop: true,
+  // the layer's oscillator plays the firing frequency times its harmonic: the file sounds at that frequency for the RPM it was recorded at
+  baseFrequency: firingHz(CAR_ENGINE, rpm) * harmonic,
+  falloff: VEHICLE_LOOP_FALLOFF,
+  ...offset === void 0 ? {} : { offset }
+});
+var VEHICLE_SAMPLE_ALIASES = [
+  carLayer("engine_car_low", "engine_loop_car_idle", CAR_RECORDED_RPM.idle, 1),
+  carLayer("engine_car_mid", "engine_loop_car_high", CAR_RECORDED_RPM.high, 1),
+  // the same file as the mid layer, read from two seconds in, so the two do not sum in phase where they cross
+  carLayer("engine_car_high", "engine_loop_car_high", CAR_RECORDED_RPM.high, 2, 2),
+  { id: "engine_start", file: "engine_start_run_stop", ...CAR_START_RUN_STOP.start, falloff: VEHICLE_LOOP_FALLOFF },
+  { id: "engine_stop", file: "engine_start_run_stop", ...CAR_START_RUN_STOP.stop, falloff: VEHICLE_LOOP_FALLOFF },
+  { id: "car_door_close", file: "car_door_shut" },
+  { id: "car_trunk_close", file: "car_trunk_shut" }
+];
+var VEHICLE_SOUND_BANK = { id: "vehicles_three", sounds: VEHICLE_SOUNDS, loops: VEHICLE_LOOPS, sampleAliases: VEHICLE_SAMPLE_ALIASES };
 
 // src/test-area/module.ts
 var VEHICLES_AREA_ID = "vehicles_area";
@@ -1280,6 +1306,7 @@ var ITEM_OF = { compact_hatch: "hatch", midsize_sedan: "sedan", midsize_pickup:
 var itemId = (key) => ITEM_OF[key] ?? key;
 var LANE = { z: 11, from: -12, wall: 13 };
 var SPARK_EVERY_S = 0.08;
+var TYRE_DAMAGE = /* @__PURE__ */ new Set(["flat_tyre", "torn_tyre", "run_flat"]);
 var LEAF_REST_RADIANS = 0.02;
 var MATERIAL_COLOURS = { metal: 13421772, glass: 4500223, rubber: 16750848, fuel: 16724736 };
 var LANE_START_S = 1.2;
@@ -1575,7 +1602,8 @@ function createVehiclesTestModule(options = {}) {
         state.time += dt;
         const braking = settings.damage !== "into_wall" && gap() < brakeAt() && state.time > 0.5;
         const moving = state.time > LANE_START_S;
-        const input = { ...idle, throttle: braking || !moving ? 0 : 1, brake: braking ? 1 : 0, steer: settings.damage === "into_wall" || !moving ? 0 : Math.sin(state.time * 1.4) * 0.15 };
+        const straight = settings.damage === "into_wall" || TYRE_DAMAGE.has(settings.damage) || !moving;
+        const input = { ...idle, throttle: braking || !moving ? 0 : 1, brake: braking ? 1 : 0, steer: straight ? 0 : Math.sin(state.time * 1.4) * 0.15 };
         if (mode === "arcade") {
           const { events } = arcade.step(input, dt, { blocked: (x, z, yaw) => vehicleCorners2(arcade.spec, x, z, yaw).some(([px]) => px >= LANE.wall) });
           for (const e of events) {
@@ -1814,16 +1842,139 @@ function loadVehiclesTestModule(room, options = {}) {
 }
 
 // src/test-area/proving/module.ts
-import { createVehicleCamera, mirrorPoses } from "@adatechnology/game-camera";
+import { createVehicleCamera, defaultEye, mirrorPoses } from "@adatechnology/game-camera";
 import { markKitOrigin as markKitOrigin3 } from "@adatechnology/game-contracts";
-import { CABIN_BANK, LIBRARY_BANK as LIBRARY_BANK2 } from "@adatechnology/game-audio";
+import { CABIN_BANK, LIBRARY_BANK as LIBRARY_BANK2, RADIO_BANK } from "@adatechnology/game-audio";
 import { createSemiSimDriver as createSemiSimDriver4 } from "@adatechnology/game-vehicles-driving";
 import { certify, createProvingTests, startRun, statusOf, subjectSpec as subjectSpec2, withResult } from "@adatechnology/game-vehicles-proving";
 import { discardObject3D as discardObject3D3 } from "@adatechnology/game-shapes-three";
 
 // src/test-area/proving/cockpit.ts
-import { createSemiSimDriver as createSemiSimDriver3, createVehicleControls } from "@adatechnology/game-vehicles-driving";
+import { RADIO_TRACKS } from "@adatechnology/game-audio";
+import { bumperDistance, createSemiSimDriver as createSemiSimDriver3, createVehicleControls, createVehicleSystems, parkingBeepInterval } from "@adatechnology/game-vehicles-driving";
 import { subjectSpec } from "@adatechnology/game-vehicles-proving";
+import { createVehicleDestructible as createVehicleDestructible3 } from "@adatechnology/game-vehicles";
+
+// src/body.ts
+var OPEN_SOUND = "car_door_open";
+var SHUT_SOUND = { door: "car_door_close", hood: "car_hood_close", lid: "car_trunk_close" };
+var clamp = (x, a, b) => Math.max(a, Math.min(b, x));
+function createVehicleBody(built, options) {
+  const swing = options.swingSeconds ?? 1.2;
+  const windowSeconds = options.windowSeconds ?? 3.5;
+  const travel = options.windowTravel ?? 0.92;
+  const root = built.context?.vehicle ?? built.group;
+  const poses = /* @__PURE__ */ new Map();
+  for (const clip of options.clips) {
+    if (!clip.id.startsWith("open_")) continue;
+    const last = clip.keys[clip.keys.length - 1];
+    for (const [id, pose] of Object.entries(last?.parts ?? {})) if (pose.rotation) poses.set(id, pose.rotation);
+  }
+  const hinges = /* @__PURE__ */ new Map();
+  for (const [id, open] of poses) {
+    const pivot = root.getObjectByName(id);
+    if (pivot) hinges.set(id, { pivot, open, now: 0, target: 0 });
+  }
+  const kind = (part) => part.startsWith("door") ? "door" : part === "hood" ? "hood" : "lid";
+  const panes = /* @__PURE__ */ new Map();
+  for (const glass of built.context?.glass ?? []) {
+    const g = glass.userData.glass;
+    if (!g || g.key !== "window_front" && g.key !== "window_rear") continue;
+    const id = `${g.key === "window_front" ? "front" : "rear"}_${(g.side ?? 1) < 0 ? "left" : "right"}`;
+    if (panes.has(id) || !glass.geometry) continue;
+    glass.geometry.computeBoundingBox();
+    const box = glass.geometry.boundingBox;
+    if (box) panes.set(id, { pane: glass, drop: (box.max.y - box.min.y) * travel, now: 0, target: 0, applied: 0 });
+  }
+  const sunroofs = [];
+  const wipers = [];
+  const T = options.THREE;
+  const turn = new T.Quaternion();
+  root.traverse((o) => {
+    const sun = o.userData.sunroof;
+    if (sun) sunroofs.push({ obj: o, slide: sun.slide, base: o.position.x });
+  });
+  for (const { part, tag } of built.context?.wipers ?? [])
+    wipers.push({ obj: part, arm: tag.arm, sweep: tag.sweep, spindle: new T.Vector3(...tag.spindle), axis: new T.Vector3(...tag.axis), rest: part.position.clone(), restQ: part.quaternion.clone() });
+  let sunNow = 0;
+  let sunTarget = 0;
+  let wipePhase = 0;
+  let locked = false;
+  const placeWiper = (w, angle) => {
+    if (angle === 0) {
+      w.obj.position.copy(w.rest);
+      w.obj.quaternion.copy(w.restQ);
+      return;
+    }
+    turn.setFromAxisAngle(w.axis, angle);
+    w.obj.position.copy(w.rest).sub(w.spindle).applyQuaternion(turn).add(w.spindle);
+    w.obj.quaternion.copy(turn).multiply(w.restQ);
+  };
+  const ease = (now, target, seconds, dt) => now + clamp(target - now, -dt / seconds, dt / seconds);
+  return {
+    parts: [...hinges.keys()],
+    windows: [...panes.keys()],
+    hasSunroof: sunroofs.length > 0,
+    wipers: new Set(wipers.map((w) => w.arm)).size,
+    get locked() {
+      return locked;
+    },
+    openness: (part) => hinges.get(part)?.now ?? 0,
+    toggle(part) {
+      const h = hinges.get(part);
+      if (!h) return [{ type: "refused", part, reason: "missing" }];
+      if (locked && kind(part) !== "hood" && h.target === 0) return [{ type: "refused", part, reason: "locked" }];
+      h.target = h.target > 0 ? 0 : 1;
+      return h.target > 0 ? [{ type: "sound", key: OPEN_SOUND, part }] : [];
+    },
+    window: (id) => panes.get(id)?.now ?? 0,
+    toggleWindow(id) {
+      const w = panes.get(id);
+      if (w) w.target = w.target > 0.5 ? 0 : 1;
+    },
+    setWindow(id, open) {
+      const w = panes.get(id);
+      if (w) w.target = clamp(open, 0, 1);
+    },
+    toggleSunroof() {
+      sunTarget = sunTarget > 0.5 ? 0 : 1;
+    },
+    lock(on) {
+      locked = on;
+      return [{ type: "sound", key: "blinker_tick", part: "doors" }];
+    },
+    update(dt, wipe = 0) {
+      const events = [];
+      for (const [id, h] of hinges) {
+        if (h.now === h.target) continue;
+        h.now = ease(h.now, h.target, swing, dt);
+        h.pivot.rotation.set(h.open[0] * h.now, h.open[1] * h.now, h.open[2] * h.now);
+        if (h.now === 0) events.push({ type: "sound", key: SHUT_SOUND[kind(id)] ?? "car_door_close", part: id });
+      }
+      for (const w of panes.values()) {
+        if (w.now === w.target) continue;
+        w.now = ease(w.now, w.target, windowSeconds, dt);
+        const offset = -w.drop * w.now;
+        w.pane.position.y += offset - w.applied;
+        w.applied = offset;
+      }
+      if (sunNow !== sunTarget) {
+        sunNow = ease(sunNow, sunTarget, 2.5, dt);
+        for (const s of sunroofs) s.obj.position.x = s.base - s.slide * sunNow;
+      }
+      wipePhase = wipe > 0 ? (wipePhase + dt * wipe) % 1 : wipePhase > 0 ? Math.min(1, wipePhase + dt * 1.5) % 1 : 0;
+      const sweep = Math.sin(Math.PI * wipePhase);
+      for (const w of wipers) placeWiper(w, w.sweep * sweep);
+      return events;
+    },
+    dispose() {
+      for (const h of hinges.values()) h.pivot.rotation.set(0, 0, 0);
+      for (const w of panes.values()) w.pane.position.y -= w.applied;
+      for (const s of sunroofs) s.obj.position.x = s.base;
+      for (const w of wipers) placeWiper(w, 0);
+    }
+  };
+}
 
 // src/dashboard.ts
 import { discardObject3D as discardObject3D2 } from "@adatechnology/game-shapes-three";
@@ -2000,6 +2151,8 @@ function createVehicleDashboard(THREE, built, options) {
         lamp(g, 104, 214, r.highBeam, DASHBOARD_LOOK.blue, beam);
         lamp(g, 152, 214, r.lowBeam || r.fog, r.fog ? DASHBOARD_LOOK.amber : DASHBOARD_LOOK.green, beam);
         bar(g, 40, r.fuel, false, "F");
+        lamp(g, 104, 244, !!r.cruise, DASHBOARD_LOOK.green, letter("CRZ"));
+        if (r.profile && r.profile !== "normal") lamp(g, 152, 244, true, r.profile === "eco" ? DASHBOARD_LOOK.green : DASHBOARD_LOOK.amber, letter(r.profile === "eco" ? "E" : "S"));
       } else {
         dial(g, r.rpm / 1e3, Math.ceil(redline / 1e3) + 1, 1, redline / 1e3, (v) => String(Math.round(v)));
         g.fillStyle = DASHBOARD_LOOK.marks;
@@ -2008,7 +2161,9 @@ function createVehicleDashboard(THREE, built, options) {
         g.fillText(r.gear < 0 ? "R" : r.gear === 0 ? "N" : String(r.gear), SIZE / 2, SIZE / 2 + 54);
         lamp(g, 86, 178, r.parkingBrake, DASHBOARD_LOOK.red, ring("P"));
         lamp(g, 128, 214, r.ignition && !r.seatbelt, DASHBOARD_LOOK.red, belt);
-        lamp(g, 170, 178, warn, DASHBOARD_LOOK.red, letter("+\u2212"));
+        lamp(g, 170, 178, warn || r.engineOn && r.charging === false, DASHBOARD_LOOK.red, letter("+\u2212"));
+        lamp(g, 104, 244, r.ignition && !!r.tractionOff, DASHBOARD_LOOK.amber, letter("TC"));
+        lamp(g, 152, 244, r.ignition && !!r.absOff, DASHBOARD_LOOK.amber, letter("ABS"));
         lamp(g, 86, 214, warn, DASHBOARD_LOOK.red, letter("OIL"));
         lamp(g, 170, 214, r.fourWheel, DASHBOARD_LOOK.green, letter("4x4"));
         bar(g, SIZE - 40, r.temperature, true, "T");
@@ -2197,7 +2352,18 @@ function createVehicleLamps(THREE, built, options = {}) {
 }
 
 // src/test-area/proving/cockpit.ts
-var DEFAULT_COCKPIT_SOUNDS = { horn: "horn", blinker: "blinker_tick", starter: "starter_crank", alarm: "car_alarm", chirp: "alarm_chirp", wiper: "wiper_swish", chime: "seatbelt_chime", radio: "radio_static" };
+var DEFAULT_COCKPIT_SOUNDS = { horn: "horn", blinker: "blinker_tick", starter: "starter_crank", alarm: "car_alarm", chirp: "alarm_chirp", wiper: "wiper_swish", chime: "seatbelt_chime", radio: "radio_static", beep: "parking_beep" };
+var BODY_KEYS = {
+  Digit1: "door_front_left",
+  Digit2: "door_front_right",
+  Digit3: "door_rear_left",
+  Digit4: "door_rear_right",
+  Digit5: "hood",
+  Digit6: "lid"
+};
+var WINDOW_KEYS = { Digit1: "front_left", Digit2: "front_right", Digit3: "rear_left", Digit4: "rear_right" };
+var LOCK_KEY = "KeyV";
+var WIPE_RATE = { off: 0, intermittent: 0.25, slow: 0.7, fast: 1.4 };
 function createCockpit(o) {
   const sounds = { ...DEFAULT_COCKPIT_SOUNDS, ...o.sounds };
   const spec = subjectSpec(o.subject);
@@ -2214,19 +2380,38 @@ function createCockpit(o) {
   let wipeAgain = 0;
   let chimeAgain = 0;
   let radioAgain = 0;
+  let beepAgain = 0;
+  let bar = 0;
   let exitAsked = false;
   let gas = 0;
+  const systems = createVehicleSystems();
+  const context = o.built.context;
+  const destructible = o.kit && context ? createVehicleDestructible3(o.kit, context, { id: "driven", frame: o.built.group }) : null;
+  const body = destructible ? createVehicleBody(o.built, { THREE: o.THREE, clips: destructible.animations() }) : null;
+  const bodyEvents = (events) => {
+    for (const event of events) {
+      if (event.type === "sound") play(event.key, 0.9);
+      o.onEvent?.(event);
+    }
+  };
   const controls = createVehicleControls({
+    canCrank: systems.canCrank,
+    onCrank: systems.crank,
+    powerLimit: systems.powerLimit,
     gears: spec.gears?.length ?? 5,
     fourWheelDrive: !!o.subject.body.fourWheelDrive,
     fogLamps: lamps.has.fog,
+    clutchPedal: true,
+    radioTracks: RADIO_TRACKS.length,
     onEvent: (event) => {
       if (event.type === "command") {
-        if (event.command === "ignition" && event.state.ignition && sounds.starter) play(sounds.starter);
         if (event.command === "ignition" && !event.state.ignition) driver.state.engineOn = false;
         if (event.command === "alarm" && event.state.alarm === "armed") play(sounds.chirp);
         if (event.command === "alarm") alarmAgain = 0;
-        if (event.command === "radio" || event.command === "radio_source") radioAgain = 0;
+        if (event.command === "radio" || event.command === "radio_source" || event.command === "radio_track") {
+          radioAgain = 0;
+          bar = 0;
+        }
         if (event.command === "exit") exitAsked = true;
       }
       o.onEvent?.(event);
@@ -2234,7 +2419,20 @@ function createCockpit(o) {
   });
   driver.state.engineOn = false;
   const target = typeof window !== "undefined" ? window : null;
+  const bodyKey = (e) => {
+    if (!body) return false;
+    if (e.code === LOCK_KEY) bodyEvents(body.lock(!body.locked));
+    else if (e.shiftKey && e.code === "Digit5") body.toggleSunroof();
+    else if (e.shiftKey && WINDOW_KEYS[e.code]) body.toggleWindow(WINDOW_KEYS[e.code]);
+    else if (!e.shiftKey && BODY_KEYS[e.code]) bodyEvents(body.toggle(BODY_KEYS[e.code]));
+    else return false;
+    return true;
+  };
   const down = (e) => {
+    if (!e.repeat && bodyKey(e)) {
+      e.stopImmediatePropagation();
+      return;
+    }
     if (!controls.key(e.code, true)) return;
     e.stopImmediatePropagation();
     if (e.code.startsWith("Arrow") || e.code === "Space") e.preventDefault();
@@ -2246,9 +2444,13 @@ function createCockpit(o) {
   target?.addEventListener("keydown", down, true);
   target?.addEventListener("keyup", up, true);
   target?.addEventListener("blur", blur);
-  return {
+  const cockpit = {
+    radiator: 1,
     driver,
     controls,
+    systems,
+    body,
+    destructible,
     lamps,
     dashboard,
     get throttle() {
@@ -2257,11 +2459,16 @@ function createCockpit(o) {
     step(dt) {
       const input = controls.input(dt, driver);
       gas = input.throttle;
-      driver.step(input, dt);
+      if (input.start && sounds.starter) play(sounds.starter);
+      const engine = driver.step(input, dt).events;
       controls.after(driver, dt);
       const s = controls.state;
+      const report = [...engine.filter((e) => e.type !== "shift"), ...systems.step({ driver, controls: s, throttle: input.throttle, dt, radiator: cockpit.radiator })];
+      for (const event of report) o.onEvent?.(event);
+      const powered = driver.state.engineOn || systems.state.charge > 0;
+      const high = s.lamps.mode === "high" || s.lamps.flash;
       lamps.set({
-        mode: s.lamps.mode,
+        mode: !powered ? "off" : s.lamps.flash ? "high" : s.lamps.mode,
         fog: s.lamps.fog,
         interior: s.lamps.interior,
         brake: s.brakeLights,
@@ -2278,7 +2485,14 @@ function createCockpit(o) {
           engineOn: driver.state.engineOn,
           left: s.blinkOn && (s.indicator === "left" || s.indicator === "hazard"),
           right: s.blinkOn && (s.indicator === "right" || s.indicator === "hazard"),
-          highBeam: s.lamps.mode === "high",
+          highBeam: high,
+          fuel: driver.state.fuel / spec.tank.capacity,
+          temperature: systems.state.temperature,
+          cruise: s.cruise.on,
+          profile: s.profile,
+          tractionOff: !s.tractionControl,
+          absOff: !s.abs,
+          charging: systems.state.netW >= 0,
           lowBeam: s.lamps.mode === "low" || s.lamps.mode === "position",
           fog: s.lamps.fog,
           parkingBrake: s.parkingBrake,
@@ -2287,7 +2501,19 @@ function createCockpit(o) {
         },
         dt
       );
+      if (body) bodyEvents(body.update(dt, s.washer ? 1.2 : WIPE_RATE[s.wipers] ?? 0));
       if (s.tick) play(sounds.blinker, 0.8);
+      const near = o.obstacles?.() ?? [];
+      if (s.ignition && near.length && Math.abs(driver.state.u) < 3) {
+        const g = o.built.group;
+        const reversing = driver.state.gear < 0 || driver.state.u < -0.05;
+        const distance = bumperDistance({ x: g.position.x, z: g.position.z, heading: [Math.sin(g.rotation.y), Math.cos(g.rotation.y)], length: o.built.length, width: o.built.width, forward: !reversing, obstacles: near });
+        const every = parkingBeepInterval(distance);
+        if (every != null && (beepAgain -= dt) <= 0) {
+          play(sounds.beep, 0.7);
+          beepAgain = every === 0 ? 0.09 : every;
+        }
+      }
       if (s.horn && (hornAgain -= dt) <= 0) {
         play(sounds.horn);
         hornAgain = 0.5;
@@ -2296,9 +2522,9 @@ function createCockpit(o) {
         play(sounds.alarm);
         alarmAgain = 2.9;
       }
-      if (s.wipers !== "off" && (wipeAgain -= dt) <= 0) {
+      if ((s.wipers !== "off" || s.washer) && (wipeAgain -= dt) <= 0) {
         play(sounds.wiper, 0.7);
-        wipeAgain = s.wipers === "fast" ? 0.6 : 1.4;
+        wipeAgain = s.washer || s.wipers === "fast" ? 0.6 : s.wipers === "slow" ? 1.4 : 4;
       }
       const kmh = Math.abs(driver.state.u) * 3.6;
       if (!s.seatbelt && s.ignition && kmh > 10 && (chimeAgain -= dt) <= 0) {
@@ -2306,8 +2532,13 @@ function createCockpit(o) {
         chimeAgain = 6;
       }
       if (s.radio.on && (radioAgain -= dt) <= 0) {
-        play(sounds.radio, s.radio.source === "tape" ? 0.25 : 0.45);
-        radioAgain = 0.55;
+        const song = RADIO_TRACKS[s.radio.track % RADIO_TRACKS.length];
+        if (song) {
+          play(song.bars[bar % song.bars.length], s.radio.source === "tape" ? 0.8 : 0.7);
+          bar++;
+        }
+        if (s.radio.source === "radio") play(sounds.radio, 0.12);
+        radioAgain = song?.barSeconds ?? 2;
       }
       if (exitAsked) {
         exitAsked = false;
@@ -2321,10 +2552,151 @@ function createCockpit(o) {
       controls.release();
       lamps.dispose();
       dashboard?.dispose();
+      body?.dispose();
+      destructible?.dispose?.();
+    }
+  };
+  return cockpit;
+}
+
+// src/wheel-roll.ts
+var DEFAULT_RADIUS = 0.32;
+function createWheelRoll(THREE, built) {
+  const wheels = (built.context?.wheels ?? []).map((wheel) => ({
+    wheel,
+    rest: wheel.quaternion.clone(),
+    radius: Number(wheel.userData.r) || DEFAULT_RADIUS,
+    // in the kit's frame the front is +x: the wheels ahead of the middle steer
+    front: wheel.position.x > 0,
+    angle: 0
+  }));
+  const axle = new THREE.Vector3(0, 0, 1);
+  const up = new THREE.Vector3(0, 1, 0);
+  const spin = new THREE.Quaternion();
+  const steering = new THREE.Quaternion();
+  return {
+    count: wheels.length,
+    roll(distance, steer) {
+      for (const w of wheels) {
+        w.angle = (w.angle - distance / w.radius) % (Math.PI * 2);
+        spin.setFromAxisAngle(axle, w.angle);
+        steering.setFromAxisAngle(up, w.front ? steer : 0);
+        w.wheel.quaternion.copy(w.rest).premultiply(spin).premultiply(steering);
+      }
+    },
+    dispose() {
+      for (const w of wheels) w.wheel.quaternion.copy(w.rest);
+    }
+  };
+}
+
+// src/test-area/proving/crash.ts
+import { launchBody } from "@adatechnology/game-contracts";
+import { ejectionOf } from "@adatechnology/game-vehicles-driving";
+var GLASS_BLOW = 6e3;
+function createProvingCrash(host, occupant) {
+  const thrown = [];
+  const breakGlass = (destructible, exit, forward) => {
+    if (!destructible) return;
+    const want = exit === "windshield" ? "windshield" : exit === "rear_window" ? "rear" : exit.startsWith("left") ? "left" : "right";
+    const pane = destructible.describe().parts.find((p) => p.id.includes(exit === "windshield" || exit === "rear_window" ? want : "window") && (exit === "windshield" || exit === "rear_window" || p.id.includes(want)));
+    if (!pane) return;
+    destructible.hit({ type: "blunt", partId: pane.id, point: destructible.partWorldCenter(pane.id), direction: forward, energy: GLASS_BLOW, radius: 0.35, source: "occupant" });
+  };
+  return {
+    crash({ car, u, w, belted, destructible }) {
+      const ejection = ejectionOf({ before: { u, w }, after: { u: 0, w: 0 } }, belted);
+      if (!ejection) return null;
+      const s = Math.sin(car.rotationY);
+      const c = Math.cos(car.rotationY);
+      const forward = [s, 0, c];
+      const right = [-c, 0, s];
+      breakGlass(destructible, ejection.exit, forward);
+      const [vf, vr, vu] = ejection.velocity;
+      const start = [car.position.x + forward[0] * 1.2, 1.1, car.position.z + forward[2] * 1.2];
+      const placed = occupant ? host.addObject?.(occupant, { position: start, rotationY: car.rotationY }) : null;
+      if (placed) {
+        launchBody(placed.root, [forward[0] * vf + right[0] * vr, vu, forward[2] * vf + right[2] * vr]);
+        thrown.push(placed.remove);
+      }
+      return ejection;
+    },
+    dispose() {
+      for (const remove of thrown.splice(0)) remove();
     }
   };
 }
 
+// src/test-area/proving/systems-text.ts
+var SYSTEMS_TEXT = {
+  "pt-BR": {
+    keys: "C embreagem (c\xE2mbio manual) \xB7 X lampejo do farol alto \xB7 Z esguicho do limpador \xB7 7 modo econ\xF4mico/normal/esporte \xB7 8 controle de tra\xE7\xE3o \xB7 9 ABS \xB7 0 piloto autom\xE1tico \xB7 - ar-condicionado \xB7 = desemba\xE7ador \xB7 ] troca a faixa do r\xE1dio ou da fita",
+    profile: "Modo de condu\xE7\xE3o",
+    profiles: { eco: "econ\xF4mico", normal: "normal", sport: "esporte" },
+    traction: "Controle de tra\xE7\xE3o",
+    abs: "ABS",
+    cruise: "Piloto autom\xE1tico",
+    cruiseSet: "Piloto autom\xE1tico: segurando {0} km/h",
+    climate: "Ar-condicionado",
+    demist: "Desemba\xE7ador",
+    wiperModes: { off: "desligado", intermittent: "intermitente", slow: "lento", fast: "r\xE1pido" },
+    refused: { battery_flat: "Bateria descarregada: o motor de partida n\xE3o gira", too_slow: "Piloto autom\xE1tico s\xF3 acima de 30 km/h", locked: "Porta travada", missing: "Este ve\xEDculo n\xE3o tem essa pe\xE7a" },
+    events: {
+      stall: "O motor morreu",
+      out_of_fuel: "Acabou o combust\xEDvel",
+      bogged: "Atolou",
+      aquaplaning: "Aquaplanagem",
+      battery_flat: "A bateria descarregou",
+      overheating: "Motor superaquecendo: perdendo pot\xEAncia",
+      seized: "O motor fundiu de tanto esquentar",
+      spare_fitted: "Estepe colocado",
+      no_spare: "N\xE3o h\xE1 estepe",
+      cruise_cancelled: "Piloto autom\xE1tico desligado"
+    },
+    actions: { puncture: "Furar pneu (dianteiro esquerdo)", fit_spare: "Trocar pelo estepe", refuel: "Abastecer", drain_battery: "Descarregar bateria", jump_start: "Chupeta (carregar bateria)", break_radiator: "Furar o radiador", empty_tank: "Deixar o tanque na reserva", remote_lock: "Controle: travar (arma o alarme)", remote_unlock: "Controle: destravar", force_door: "For\xE7ar a porta do motorista", crash_wall: "Bater no muro (parada seca)", park_behind: "Estacionar um carro atr\xE1s (sensor de r\xE9)" },
+    parking: { placed: "Carro parado 3 m atr\xE1s: d\xEA r\xE9 e escute o sensor", none: "Sem cat\xE1logo de ve\xEDculos nesta sala: o sensor n\xE3o tem o que ver" },
+    track: "faixa {0}",
+    adjust: { seat_forward: "Banco: frente/tr\xE1s (m)", seat_height: "Banco: altura (m)", mirror_left: "Retrovisor esquerdo: \xE2ngulo", mirror_right: "Retrovisor direito: \xE2ngulo" },
+    crash: { mild: "Batida a {0} km/h: fraca demais para lan\xE7ar quem est\xE1 sem cinto", stayed: "Batida a {0} km/h: o cinto segurou o motorista", ejected: "Batida a {0} km/h sem cinto: o motorista saiu pelo {1}", exits: { windshield: "para-brisa", left_window: "vidro esquerdo", right_window: "vidro direito", rear_window: "vidro traseiro" } },
+    bodyKeys: "1 a 4 portas \xB7 5 cap\xF4 \xB7 6 porta-malas \xB7 Shift+1 a 4 vidros \xB7 Shift+5 teto solar \xB7 V trava as portas",
+    remote: { locked: "Travado pelo controle: alarme armado", unlocked: "Destravado pelo controle", forced: "Porta for\xE7ada" },
+    done: { puncture: "Pneu dianteiro esquerdo furado", refuel: "Tanque cheio", drain_battery: "Bateria quase sem carga", jump_start: "Bateria carregada", break_radiator: "Radiador furado: o motor vai esquentar", empty_tank: "Tanque na reserva" }
+  },
+  en: {
+    keys: "C clutch (manual gearbox) \xB7 X flash the high beam \xB7 Z washer \xB7 7 eco/normal/sport \xB7 8 traction control \xB7 9 ABS \xB7 0 cruise control \xB7 - air conditioning \xB7 = demister \xB7 ] next radio or tape track",
+    profile: "Drive profile",
+    profiles: { eco: "eco", normal: "normal", sport: "sport" },
+    traction: "Traction control",
+    abs: "ABS",
+    cruise: "Cruise control",
+    cruiseSet: "Cruise control: holding {0} km/h",
+    climate: "Air conditioning",
+    demist: "Demister",
+    wiperModes: { off: "off", intermittent: "intermittent", slow: "slow", fast: "fast" },
+    refused: { battery_flat: "Flat battery: the starter does not turn", too_slow: "Cruise control only above 30 km/h", locked: "The door is locked", missing: "This vehicle has no such part" },
+    events: {
+      stall: "The engine stalled",
+      out_of_fuel: "Out of fuel",
+      bogged: "Bogged down",
+      aquaplaning: "Aquaplaning",
+      battery_flat: "The battery went flat",
+      overheating: "Engine overheating: losing power",
+      seized: "The engine seized from the heat",
+      spare_fitted: "Spare tyre fitted",
+      no_spare: "No spare tyre left",
+      cruise_cancelled: "Cruise control off"
+    },
+    actions: { puncture: "Puncture a tyre (front left)", fit_spare: "Fit the spare", refuel: "Refuel", drain_battery: "Drain the battery", jump_start: "Jump start (charge the battery)", break_radiator: "Puncture the radiator", empty_tank: "Leave the tank on reserve", remote_lock: "Remote: lock (arms the alarm)", remote_unlock: "Remote: unlock", force_door: "Force the driver's door", crash_wall: "Hit a wall (dead stop)", park_behind: "Park a car behind (rear sensor)" },
+    parking: { placed: "A car parked 3 m behind: reverse and listen to the sensor", none: "No vehicle catalogue in this room: the sensor has nothing to see" },
+    track: "track {0}",
+    adjust: { seat_forward: "Seat: forward/back (m)", seat_height: "Seat: height (m)", mirror_left: "Left mirror: angle", mirror_right: "Right mirror: angle" },
+    crash: { mild: "Crash at {0} km/h: too mild to throw an unbelted occupant out", stayed: "Crash at {0} km/h: the belt held the driver", ejected: "Crash at {0} km/h without a belt: the driver went out through the {1}", exits: { windshield: "windshield", left_window: "left window", right_window: "right window", rear_window: "rear window" } },
+    bodyKeys: "1 to 4 doors \xB7 5 hood \xB7 6 trunk \xB7 Shift+1 to 4 windows \xB7 Shift+5 sunroof \xB7 V locks the doors",
+    remote: { locked: "Locked by the remote: alarm armed", unlocked: "Unlocked by the remote", forced: "Door forced" },
+    done: { puncture: "Front left tyre punctured", refuel: "Tank full", drain_battery: "Battery almost flat", jump_start: "Battery charged", break_radiator: "Radiator punctured: the engine will heat up", empty_tank: "Tank on reserve" }
+  }
+};
+
 // src/test-area/proving/text.ts
 var PROVING_TEXT = {
   "pt-BR": {
@@ -2469,9 +2841,11 @@ var MIRROR_RECTS = {
   right: { x: 0.79, y: 0.72, width: 0.19, height: 0.13, rounded: 0.3 },
   reverse: { x: 0.36, y: 0.13, width: 0.28, height: 0.18, rounded: 0.06 }
 };
+var ADJUST_KEYS = { seat_forward: "seatForward", seat_height: "seatHeight", mirror_left: "mirrorLeft", mirror_right: "mirrorRight" };
 function createProvingModule(options) {
   const locale = options.locale ?? "pt-BR";
   const text = PROVING_TEXT[locale] ?? PROVING_TEXT["pt-BR"];
+  const sysText = SYSTEMS_TEXT[locale] ?? SYSTEMS_TEXT["pt-BR"];
   const tests = options.tests ?? createProvingTests();
   const vehicles = options.vehicles;
   const sounds = { ...defaultSoundIds, ...options.sounds };
@@ -2488,6 +2862,15 @@ function createProvingModule(options) {
   let run = null;
   let parking = null;
   let driving = null;
+  let crashes = null;
+  let wheels = null;
+  let lastAt = null;
+  let parked = null;
+  const adjust = { seatForward: 0, seatHeight: 0, mirrorLeft: 0, mirrorRight: 0 };
+  const aimed = (pose2) => {
+    const turn = pose2.id === "left" ? adjust.mirrorLeft : pose2.id === "right" ? -adjust.mirrorRight : 0;
+    return turn ? { ...pose2, look: [pose2.look[0] + turn, pose2.look[1], pose2.look[2]] } : pose2;
+  };
   let gearbox = "automatic";
   let lastGear = null;
   let driveClock = 0;
@@ -2649,6 +3032,8 @@ function createProvingModule(options) {
   };
   const removeCar = () => {
     if (!car) return;
+    wheels = null;
+    lastAt = null;
     discardObject3D3(car.built.group);
     car = null;
   };
@@ -2662,6 +3047,7 @@ function createProvingModule(options) {
     built.group.add(guides);
     host.scene.add(built.group);
     car = { built, guides, subject };
+    wheels = createWheelRoll(three, built);
     pose({ x: 0, z: TRACK.start, yaw: 0, pitch: 0, roll: 0, height: 0 }, 0);
     rig.vehicle?.reset();
     drawBoard();
@@ -2712,11 +3098,18 @@ function createProvingModule(options) {
     car.built.group.position.set(TRACK.x0 + wrapped, 0, TRACK.z + s.z);
     car.built.group.rotation.set(-s.pitch, s.yaw + Math.PI / 2, s.roll, "YXZ");
     bendGuides(steer);
+    if (lastAt) {
+      const along = (s.x - lastAt.x) * Math.cos(s.yaw) - (s.z - lastAt.z) * Math.sin(s.yaw);
+      if (Math.abs(along) < 5) wheels?.roll(along, steer);
+    }
+    lastAt = { x: s.x, z: s.z };
   };
   const frameOf = (speed) => {
     if (!car) return null;
     const g = car.built.group;
-    return { x: g.position.x, y: g.position.y, z: g.position.z, yaw: g.rotation.y, pitch: -g.rotation.x, roll: g.rotation.z, speed, length: car.built.length, width: car.built.width, height: car.built.height, ...car.built.driverEye ? { eye: car.built.driverEye } : {} };
+    const size = { length: car.built.length, width: car.built.width, height: car.built.height };
+    const [ex, ey, ez] = car.built.driverEye ?? defaultEye(size);
+    return { x: g.position.x, y: g.position.y, z: g.position.z, yaw: g.rotation.y, pitch: -g.rotation.x, roll: g.rotation.z, speed, ...size, eye: [ex, ey + adjust.seatHeight, ez + adjust.seatForward] };
   };
   const applyCamera = () => {
     if (!host?.setViewCamera) return;
@@ -2805,19 +3198,26 @@ function createProvingModule(options) {
       built: car.built,
       subject: car.subject,
       place: [0, 0, 0],
+      kit: kitFor(three),
+      obstacles: () => parked ? [[parked.root.position.x, parked.root.position.z]] : [],
       gauge: kitFor(three).materials?.gauge,
       needle: kitFor(three).materials?.amber,
       // the engine's own sound turns the key (starter, catch, idle by RPM)
       sounds: { starter: "" },
       onExit: () => stopDriving(),
       onEvent: (event) => {
-        if (event.type === "refused") return host?.log(text.cabin.refused[event.reason] ?? event.reason);
+        if (event.type === "refused") return host?.log(text.cabin.refused[event.reason] ?? sysText.refused[event.reason] ?? event.reason);
+        if (event.type === "sound") return;
+        if (event.type !== "command") {
+          if (event.type === "out_of_fuel" || event.type === "stall" || event.type === "seized") engine?.stop([car?.built.group.position.x ?? 0, 0.5, car?.built.group.position.z ?? 0]);
+          return host?.log(sysText.events[event.type] ?? event.type, { vehicle: settings.vehicle, ...event }, "proving_system");
+        }
         const st = event.state;
         const line = cabinLine(event.command, st);
         if (line) host?.log(line);
         if (event.command === "ignition" && car) {
           const at = [car.built.group.position.x, 0.5, car.built.group.position.z];
-          if (st.ignition) engine?.start(at);
+          if (st.ignition && driving?.systems.canCrank() !== false) engine?.start(at);
           else engine?.stop(at);
         }
         if (event.command === "gearbox") {
@@ -2836,7 +3236,7 @@ function createProvingModule(options) {
     rig.vehicle?.reset();
     stopEngine();
     engine = createVehicleSound(host.audio, { sounds });
-    host.bench?.sheet?.({ kicker: text.name, title: fillText(text.log.drive, name(settings.vehicle)), body: text.cabin.keys });
+    host.bench?.sheet?.({ kicker: text.name, title: fillText(text.log.drive, name(settings.vehicle)), body: `${text.cabin.keys} \xB7 ${sysText.keys} \xB7 ${sysText.bodyKeys}` });
     host.log(fillText(text.log.drive, name(settings.vehicle)));
   };
   const onOff = (on) => on ? text.cabin.on : text.cabin.off;
@@ -2865,19 +3265,109 @@ function createProvingModule(options) {
         return `${c.alarm}: ${c.alarmStates[st.alarm]}`;
       case "radio":
       case "radio_source":
-        return `${c.radio}: ${st.radio.on ? c.sources[st.radio.source] : c.off}`;
+      case "radio_track":
+        return `${c.radio}: ${st.radio.on ? `${c.sources[st.radio.source]} \xB7 ${fillText(sysText.track, st.radio.track + 1)}` : c.off}`;
       case "indicator_left":
       case "indicator_right":
       case "hazard":
         return `${c.indicator}: ${c.indicators[st.indicator]}`;
       case "wipers":
-        return `${c.wipers}: ${c.wiperModes[st.wipers]}`;
+        return `${c.wipers}: ${sysText.wiperModes[st.wipers]}`;
+      case "drive_profile":
+        return `${sysText.profile}: ${sysText.profiles[st.profile]}`;
+      case "traction_control":
+        return `${sysText.traction}: ${onOff(st.tractionControl)}`;
+      case "abs":
+        return `${sysText.abs}: ${onOff(st.abs)}`;
+      case "cruise":
+        return st.cruise.on ? fillText(sysText.cruiseSet, Math.round(st.cruise.speed * 3.6)) : `${sysText.cruise}: ${c.off}`;
+      case "climate":
+        return `${sysText.climate}: ${onOff(st.climate.on)}`;
+      case "demist":
+        return `${sysText.demist}: ${onOff(st.climate.demist)}`;
       case "seatbelt":
         return `${c.seatbelt}: ${onOff(st.seatbelt)}`;
       default:
         return null;
     }
   };
+  const systemsAction = (id) => {
+    if (!driving) startDriving();
+    const cockpit = driving;
+    if (!cockpit) return;
+    const d = cockpit.driver;
+    const done = (key) => host?.log(sysText.done[key], { vehicle: settings.vehicle, action: key }, "proving_system");
+    switch (id) {
+      case "puncture": {
+        const tyres = d.spec.wheels.map((_, i) => d.condition.tyres?.[i] ?? 1);
+        tyres[0] = 0;
+        d.condition = { ...d.condition, tyres };
+        return done("puncture");
+      }
+      case "fit_spare": {
+        const flat = d.spec.wheels.findIndex((_, i) => (d.condition.tyres?.[i] ?? 1) < 0.2);
+        const event = cockpit.systems.fitSpare(d, Math.max(0, flat));
+        host?.log(sysText.events[event.type], { vehicle: settings.vehicle, ...event }, "proving_system");
+        return;
+      }
+      case "refuel":
+        d.refuel(d.spec.tank.capacity);
+        return done("refuel");
+      case "empty_tank":
+        d.state.fuel = Math.min(d.state.fuel, d.spec.tank.capacity * 0.04);
+        return done("empty_tank");
+      case "drain_battery":
+        cockpit.systems.charge(-(cockpit.systems.state.charge - 0.15));
+        return done("drain_battery");
+      case "jump_start":
+        cockpit.systems.charge(1);
+        return done("jump_start");
+      case "break_radiator":
+        cockpit.radiator = 0.05;
+        return done("break_radiator");
+      case "remote_lock":
+      case "remote_unlock": {
+        const lock = id === "remote_lock";
+        cockpit.body?.lock(lock);
+        cockpit.controls.state.alarm = lock ? "armed" : "off";
+        host?.audio?.play?.({ sound: "alarm_chirp", position: [car?.built.group.position.x ?? 0, 1, car?.built.group.position.z ?? 0] });
+        host?.log(sysText.remote[lock ? "locked" : "unlocked"], { vehicle: settings.vehicle, locked: lock }, "proving_system");
+        return;
+      }
+      case "crash_wall": {
+        const g = car?.built.group;
+        if (!g || !host) return;
+        crashes ?? (crashes = createProvingCrash(host, options.occupant));
+        const speed = d.state.u;
+        const ejection = crashes.crash({ car: { position: g.position, rotationY: g.rotation.y }, u: d.state.u, w: d.state.w, belted: cockpit.controls.state.seatbelt, destructible: cockpit.destructible });
+        d.state.u = d.state.w = d.state.yawRate = 0;
+        const kmh = Math.round(Math.abs(speed) * 3.6);
+        const belted = cockpit.controls.state.seatbelt;
+        host.log(ejection ? fillText(sysText.crash.ejected, kmh, sysText.crash.exits[ejection.exit]) : fillText(belted ? sysText.crash.stayed : sysText.crash.mild, kmh), { vehicle: settings.vehicle, kmh, belted: cockpit.controls.state.seatbelt, ejection }, "proving_crash");
+        return;
+      }
+      case "park_behind": {
+        const g = car?.built.group;
+        if (!g || !host) return;
+        parked?.remove();
+        const back = (car?.built.length ?? 4.5) / 2 + 3 + 2.3;
+        const at = [g.position.x - Math.sin(g.rotation.y) * back, 0, g.position.z - Math.cos(g.rotation.y) * back];
+        const placed = host.addObject?.(options.parkedCar ?? "sedan", { position: at, rotationY: g.rotation.y });
+        parked = placed ? { root: placed.root, remove: placed.remove } : null;
+        host.log(placed ? sysText.parking.placed : sysText.parking.none, { vehicle: settings.vehicle }, "proving_system");
+        return;
+      }
+      case "force_door": {
+        const body = cockpit.body;
+        if (!body) return;
+        if (body.locked) body.lock(false);
+        body.toggle("door_front_left");
+        if (cockpit.controls.state.alarm === "armed") cockpit.controls.state.alarm = "ringing";
+        host?.log(sysText.remote.forced, { vehicle: settings.vehicle, alarm: cockpit.controls.state.alarm }, "proving_system");
+        return;
+      }
+    }
+  };
   const gearName = (gear) => gear < 0 ? "R" : gear === 0 ? "N" : String(gear);
   const onChange = (change) => {
     if (change.kind === "layer") {
@@ -2886,6 +3376,7 @@ function createProvingModule(options) {
     }
     if (change.kind === "action") {
       if (change.id === "drive") return driving ? stopDriving() : startDriving();
+      if (change.id in sysText.actions) return systemsAction(change.id);
       if (change.id === "run_test" || change.id === "run_all" || change.id === "reverse_park") stopDriving();
       if (change.id === "run_test") {
         queue = [];
@@ -2932,6 +3423,12 @@ function createProvingModule(options) {
         settings.camera = String(change.value);
         applyCamera();
         break;
+      case "seat_forward":
+      case "seat_height":
+      case "mirror_left":
+      case "mirror_right":
+        adjust[ADJUST_KEYS[change.id]] = Number(change.value);
+        break;
       case "time_scale":
         settings.timeScale = Number(change.value);
         break;
@@ -2981,7 +3478,7 @@ function createProvingModule(options) {
     if (car) engine?.update({ dt, position: [car.built.group.position.x, 0.5, car.built.group.position.z], speed, throttle: run ? 1 : driving?.throttle ?? 0, rpm: driving ? driving.driver.state.rpm : void 0 });
     const f = frameOf(speed);
     if (f && rig.vehicle && settings.camera !== "room") rig.vehicle.update(rig.camera, f, dt);
-    if (f && rig.vehicle) for (const m of rig.mirrors) rig.vehicle.placeMirror(m.camera, m.pose, f);
+    if (f && rig.vehicle) for (const m of rig.mirrors) rig.vehicle.placeMirror(m.camera, aimed(m.pose), f);
     void steer;
     const key = `${host.bench?.layer("mirrors")}|${host.bench?.layer("reverse_camera")}`;
     if (key !== mirrorKey) {
@@ -3000,6 +3497,10 @@ function createProvingModule(options) {
   const speedNow = () => Math.abs(run?.driver.state.u ?? driving?.driver.state.u ?? parking?.driver.state.u ?? 0) * 3.6;
   const counts = (verdict) => certificateOf(settings.vehicle)?.results.filter((r) => r.verdict === verdict).length ?? 0;
   const teardown = () => {
+    crashes?.dispose();
+    crashes = null;
+    parked?.remove();
+    parked = null;
     stopDriving();
     stopEngine();
     for (const m of rig.mirrors) m.remove();
@@ -3030,9 +3531,14 @@ function createProvingModule(options) {
       { kind: "choice", id: "vehicle", name: text.controls.vehicle, hint: text.hints.vehicle, options: vehicles.map((id) => ({ id, name: name(id) })), default: settings.vehicle },
       { kind: "choice", id: "test", name: text.controls.test, hint: text.hints.test, options: measured.map((id) => ({ id, name: text.tests[id] ?? id })), default: settings.test },
       { kind: "choice", id: "camera", name: text.controls.camera, hint: text.hints.camera, options: ["room", "chase", "cockpit", "hood"].map((id) => ({ id, name: text.cameras[id] })), default: settings.camera },
+      { kind: "number", id: "seat_forward", name: sysText.adjust.seat_forward, min: -0.2, max: 0.2, step: 0.02, default: 0 },
+      { kind: "number", id: "seat_height", name: sysText.adjust.seat_height, min: -0.1, max: 0.1, step: 0.01, default: 0 },
+      { kind: "number", id: "mirror_left", name: sysText.adjust.mirror_left, min: -0.3, max: 0.3, step: 0.02, default: 0 },
+      { kind: "number", id: "mirror_right", name: sysText.adjust.mirror_right, min: -0.3, max: 0.3, step: 0.02, default: 0 },
       { kind: "number", id: "time_scale", name: text.controls.time_scale, hint: text.hints.time_scale, min: 1, max: 20, step: 1, default: settings.timeScale },
       { kind: "choice", id: "visual_check", name: text.controls.visual_check, hint: text.hints.visual_check, options: VISUAL_CHECKS.map((id) => ({ id, name: text.tests[id] ?? id })), default: settings.visual },
       { kind: "action", id: "drive", name: text.actions.drive },
+      ...Object.keys(sysText.actions).map((id) => ({ kind: "action", id, name: sysText.actions[id] })),
       { kind: "choice", id: "gearbox", name: text.controls.gearbox, hint: text.hints.gearbox, options: ["automatic", "manual"].map((id) => ({ id, name: text.gearbox[id] })), default: gearbox },
       { kind: "action", id: "run_test", name: text.actions.run_test },
       { kind: "action", id: "run_all", name: text.actions.run_all },
@@ -3066,6 +3572,8 @@ function createProvingModule(options) {
       rig.vehicle = createVehicleCamera(three);
       lent.audio?.register?.(LIBRARY_BANK2);
       lent.audio?.register?.(CABIN_BANK);
+      lent.audio?.register?.(VEHICLE_SOUND_BANK);
+      lent.audio?.register?.(RADIO_BANK);
       const stopChange = lent.bench?.onChange(onChange);
       const stopFrame = lent.onFrame(frame);
       const stopClear = lent.onClear?.(() => {
@@ -3098,10 +3606,6 @@ export {
   liteMeshes,
   createVehiclesThree,
   createCabinSmoke,
-  VEHICLE_LOOP_FALLOFF,
-  VEHICLE_LOOPS,
-  VEHICLE_SOUNDS,
-  VEHICLE_SOUND_BANK,
   firingHz,
   rpmShare,
   layerWeight,
@@ -3113,6 +3617,13 @@ export {
   TRUCK_ENGINE,
   BIKE_ENGINE,
   ENGINE_PROFILES,
+  VEHICLE_LOOP_FALLOFF,
+  VEHICLE_LOOPS,
+  VEHICLE_SOUNDS,
+  CAR_RECORDED_RPM,
+  CAR_START_RUN_STOP,
+  VEHICLE_SAMPLE_ALIASES,
+  VEHICLE_SOUND_BANK,
   createVehicleSound,
   VEHICLE_LOD_DISTANCE,
   createVehicleLod,
@@ -3126,13 +3637,15 @@ export {
   DEFAULT_TEST_VEHICLES,
   createVehiclesTestModule,
   loadVehiclesTestModule,
+  createVehicleBody,
   DASHBOARD_LOOK,
   createVehicleDashboard,
   LAMP_RULES,
   createVehicleLamps,
+  createWheelRoll,
   PROVING_TEXT,
   PROVING_AREA_ID,
   createProvingModule,
   loadProvingModule
 };
-//# sourceMappingURL=chunk-MRUPKE7J.js.map
+//# sourceMappingURL=chunk-L63R2JQA.js.map