@adatechnology/game-vehicles-three 0.6.0 → 0.6.2

package/dist/index.global.js

@@ -24,10 +24,12 @@ var GameVehiclesThree = (() => {
     BIKE_ENGINE: () => BIKE_ENGINE,
     CAR_ENGINE: () => CAR_ENGINE,
     CRASH_SPEEDS: () => CRASH_SPEEDS,
+    DASHBOARD_LOOK: () => DASHBOARD_LOOK,
     DEFAULT_TEST_VEHICLES: () => DEFAULT_TEST_VEHICLES,
     DEFAULT_TEST_WRECKS: () => DEFAULT_TEST_WRECKS,
     DEFAULT_VEHICLE_SOUND_KEYS: () => DEFAULT_VEHICLE_SOUND_KEYS,
     ENGINE_PROFILES: () => ENGINE_PROFILES,
+    LAMP_RULES: () => LAMP_RULES,
     LITE_CLASSES: () => LITE_CLASSES,
     PAGE_ITEM_ALIASES: () => PAGE_ITEM_ALIASES,
     PAGE_SCENARIO_ALIASES: () => PAGE_SCENARIO_ALIASES,
@@ -47,6 +49,8 @@ var GameVehiclesThree = (() => {
     createCabinSmoke: () => createCabinSmoke,
     createGearGuess: () => createGearGuess,
     createProvingModule: () => createProvingModule,
+    createVehicleDashboard: () => createVehicleDashboard,
+    createVehicleLamps: () => createVehicleLamps,
     createVehicleLod: () => createVehicleLod,
     createVehicleSound: () => createVehicleSound,
     createVehiclesTestModule: () => createVehiclesTestModule,
@@ -65,6 +69,7 @@ var GameVehiclesThree = (() => {
   });
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_BLAST_IMPULSE = { bodyArea: 0.7, lift: 0.15, minSpeed: 0.3, tntPerJoule: 0.24 / 2e5 };
   var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
   var DEFAULT_IGNITION_RULES = {
     fillCurve: [
@@ -6137,7 +6142,9 @@ var GameVehiclesThree = (() => {
     function fogLamp(c, s, r) {
       onSurf(c.cylinder(r * 1.4, r * 1.4, 0.014, LH, 0, 0, 0), s, 6e-3).castShadow = false;
       onSurf(c.cylinder(r, r, 0.012, REFL, 0, 0, 0), s, 0.012).castShadow = false;
-      onSurf(c.sphere(r * 0.45, MT.head, 0, 0, 0, 1, 0.5, 1), s, 0.016).castShadow = false;
+      const bulb = onSurf(c.sphere(r * 0.45, MT.head, 0, 0, 0, 1, 0.5, 1), s, 0.016);
+      bulb.castShadow = false;
+      (c.fogBulbs ?? (c.fogBulbs = [])).push(bulb);
     }
     function crease(c, I, sd, pts, o) {
       o = o || {};
@@ -15139,7 +15146,9 @@ var GameVehiclesThree = (() => {
     function fogLamp(c, s, r) {
       onSurf(c.cylinder(r * 1.4, r * 1.4, 0.014, LH, 0, 0, 0), s, 6e-3).castShadow = false;
       onSurf(c.cylinder(r, r, 0.012, REFL, 0, 0, 0), s, 0.012).castShadow = false;
-      onSurf(c.sphere(r * 0.45, MT.head, 0, 0, 0, 1, 0.5, 1), s, 0.016).castShadow = false;
+      const bulb = onSurf(c.sphere(r * 0.45, MT.head, 0, 0, 0, 1, 0.5, 1), s, 0.016);
+      bulb.castShadow = false;
+      (c.fogBulbs ?? (c.fogBulbs = [])).push(bulb);
     }
     function crease(c, I, sd, pts, o) {
       o = o || {};
@@ -22348,7 +22357,7 @@ var GameVehiclesThree = (() => {
       const x = kit.profX(s.lower, s.bottomY + 0.14, true) + 0.09;
       [1, -1].forEach(function(sd) {
         c.roundBox(0.04, r * 2.6, r * 3.2, 0.015, MT.housing, x, y, sd * z);
-        kit.headlight(c, {
+        const lamp = kit.headlight(c, {
           style: "round",
           x: x + 0.01,
           y,
@@ -22360,6 +22369,7 @@ var GameVehiclesThree = (() => {
           label: sd > 0 ? trl("labels.right_fog_light") : trl("labels.left_fog_light"),
           reach: 0.5
         });
+        lamp.fog = true;
       });
     }
     function roofBars(c, z, h, r) {
@@ -27987,6 +27997,16 @@ var GameVehiclesThree = (() => {
     });
     return best;
   }
+  var SEATED_EYE = { up: 0.55, back: 0.28 };
+  function eyeOf(THREE, c) {
+    const tops = c.seatTops ?? [];
+    if (!tops.length) return null;
+    const points = tops.map((t) => c.vehicle.localToWorld(new THREE.Vector3(t.x, t.y, t.z)));
+    const front = Math.max(...points.map((p) => p.z));
+    const row = points.filter((p) => p.z > front - 0.25);
+    const seat = row.reduce((a, b) => b.x > a.x ? b : a);
+    return [+seat.x.toFixed(3), +(seat.y + SEATED_EYE.up).toFixed(3), +(seat.z - SEATED_EYE.back).toFixed(3)];
+  }
   function createVehiclesThree(THREE, options) {
     const kit = options.kit;
     const fleet = options.fleet ?? { colorFromSeed, fleetDims, paintPalettes, paletteOf };
@@ -28022,6 +28042,7 @@ var GameVehiclesThree = (() => {
       markKitOrigin(group, { owner: "game-vehicles-three", kind: "vehicle", id: key });
       const damageables = kit.damageables(c, pivotMatrix);
       let pruned = 0;
+      let driverEye = null;
       if (quality === "high") {
         const pivot = new THREE.Group();
         pivot.name = "vehicle";
@@ -28043,6 +28064,7 @@ var GameVehiclesThree = (() => {
         }
         markDamageables(c, damageables);
         group.updateMatrixWorld(true);
+        driverEye = eyeOf(THREE, c);
       } else {
         const fusion = fuse(THREE, c, pivotMatrix, color2 ? new THREE.Color(color2) : null, primary, kit.lodHiddenMaterials());
         for (const mesh2 of liteMeshes(THREE, fusion, liteMaterials(THREE, kit.studioEnvironment()))) group.add(mesh2);
@@ -28068,6 +28090,7 @@ var GameVehiclesThree = (() => {
         pruned,
         expected: fleetDims2(key),
         context: quality === "high" ? c : null,
+        driverEye,
         dispose() {
           group.traverse((m) => {
             if (m.geometry) m.geometry.dispose();
@@ -44012,7 +44035,7 @@ var GameVehiclesThree = (() => {
     };
   }
 
-  // ../game-audio/dist/chunk-7TLFY7VO.js
+  // ../game-audio/dist/chunk-KBTUANNG.js
   var DISTANCE_CURVES = {
     /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
     game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
@@ -44313,7 +44336,11 @@ var GameVehiclesThree = (() => {
       ["casing_drop_terra_pistol", 1],
       ["casing_drop_terra_rifle", 1],
       ["casing_drop_terra_shell", 1],
-      ["rocket_fire", 2]
+      ["rocket_fire", 2],
+      ["smg_45_auto", 2, "sfx_pistol"],
+      ["weapon_draw", 2],
+      ["suppressor_attach", 3],
+      ["suppressor_detach", 3]
     ]),
     ...entries("explosoes-fogo", [
       ["explosion_grenade", 1, "boom"],
@@ -44327,7 +44354,11 @@ var GameVehiclesThree = (() => {
       ["fire_loop_large", 1],
       ["fire_extinguish", 2, "hiss"],
       ["gas_leak_hiss", 2],
-      ["structure_collapse", 2, "crumble"]
+      ["structure_collapse", 2, "crumble"],
+      ["grenade_bounce", 1],
+      ["c4_plant", 2],
+      ["c4_beep", 2],
+      ["c4_disarm", 2]
     ]),
     ...entries("personagem", [
       ["footstep_concrete_walk", 1, "sfx_step"],
@@ -44343,7 +44374,19 @@ var GameVehiclesThree = (() => {
       ["blunt_hit", 1],
       ["bite", 1, "sfx_flesh"],
       ["body_fall", 1],
-      ["player_hurt", 2]
+      ["player_hurt", 2],
+      ["footstep_tile_walk", 1, "sfx_step"],
+      ["footstep_water_walk", 1, "sfx_step"],
+      ["footstep_grate_walk", 2, "sfx_step"],
+      ["footstep_duct_walk", 3, "sfx_step"],
+      ["ladder_climb", 2],
+      ["swim", 2],
+      ["zombie_groan", 1],
+      ["zombie_alert", 1],
+      ["zombie_attack", 1],
+      ["zombie_pain", 1],
+      ["zombie_claw_hit", 1, "sfx_flesh"],
+      ["zombie_claw_miss", 2]
     ]),
     ...entries("veiculos", [
       ["engine_loop_car", 1],
@@ -44371,7 +44414,8 @@ var GameVehiclesThree = (() => {
       ["wind_loop", 2],
       ["thunder_near", 2],
       ["thunder_far", 2],
-      ["water_splash", 2]
+      ["water_splash", 2],
+      ["helicopter_loop", 3]
     ])
   ];
   var SFX_MATERIALS = [
@@ -44460,6 +44504,7 @@ var GameVehiclesThree = (() => {
       category: "1 \xB7 Categoria",
       sound: "1 \xB7 Som",
       play: "1 \xB7 \u25B6 Tocar",
+      play_user: "1 \xB7 \u25B6 Tocar o seu",
       material: "2 \xB7 Material",
       blow: "2 \xB7 Golpe",
       strike: "2 \xB7 \u25B6 Tocar golpe",
@@ -44481,6 +44526,7 @@ var GameVehiclesThree = (() => {
       approve: "5 \xB7 Aprovo (C10)"
     },
     hints: {
+      play_user: "Toca a sua grava\xE7\xE3o deste som (dos seus pacotes, fora do git), mesmo quando o SDK tem uma melhor e toca na frente.",
       sound: "A = arquivo, S = sintetizado, F = faltando. O que tem arquivo toca o arquivo; o resto toca o som atual.",
       strike: "Toca impact_<material>_<golpe>: o arquivo se existir, sen\xE3o o som atual daquele material.",
       wall: "P\xF5e a parede de casa entre voc\xEA e a fonte: o som fica abafado (C4).",
@@ -44525,9 +44571,10 @@ var GameVehiclesThree = (() => {
     strengths: { light: "leve", medium: "m\xE9dio", heavy: "forte" },
     states: { file: "A", synth: "S", missing: "F" },
     criteria: { C1: "C1 Sincronia", C2: "C2 Certo p/ a\xE7\xE3o", C3: "C3 Dist\xE2ncia", C4: "C4 Posi\xE7\xE3o", C5: "C5 Varia\xE7\xE3o", C6: "C6 Volume", C7: "C7 Intensidade", C8: "C8 Cauda", C9: "C9 Rajada", C10: "C10 Escuta" },
-    metrics: { chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
+    metrics: { source: "1 \xB7 Fonte do que tocou", chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
     run: { idle: "parada", measuring: "medindo\u2026", done: "pronta", failed: "falhou", recording: "gravando\u2026", recorded: "grava\xE7\xE3o baixada" },
     words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono" },
+    sources: { sdk: "SDK", user: "seu som", synth: "sintetizado" },
     probe: "Fonte do som",
     wall: "Parede (oclus\xE3o)",
     scenarios: { pipeline: "Arquivo \u2192 decodifica \u2192 toca (round-robin, cauda)", criteria: "Crit\xE9rios C1\u2013C9 no som de calibra\xE7\xE3o", loop: "Loop de arquivo: emenda sem buraco (crossfade)", panel: "Painel: categorias, matriz, A/B e parede" }
@@ -44540,6 +44587,7 @@ var GameVehiclesThree = (() => {
       category: "1 \xB7 Category",
       sound: "1 \xB7 Sound",
       play: "1 \xB7 \u25B6 Play",
+      play_user: "1 \xB7 \u25B6 Play yours",
       material: "2 \xB7 Material",
       blow: "2 \xB7 Blow",
       strike: "2 \xB7 \u25B6 Play blow",
@@ -44561,6 +44609,7 @@ var GameVehiclesThree = (() => {
       approve: "5 \xB7 Approve (C10)"
     },
     hints: {
+      play_user: "Plays your own take of this sound (from your packs, kept out of git), even where the SDK has a better one that plays first.",
       sound: "A = file, S = synthesized, F = missing. A file plays the file; the rest plays the current sound.",
       strike: "Plays impact_<material>_<blow>: the file if there is one, else the current sound of that material.",
       wall: "Puts the house wall between you and the source: the sound is muffled (C4).",
@@ -44595,9 +44644,10 @@ var GameVehiclesThree = (() => {
     environments: { indoor: "indoor", outdoor: "outdoor" },
     strengths: { light: "light", medium: "medium", heavy: "heavy" },
     criteria: { C1: "C1 Sync", C2: "C2 Right sound", C3: "C3 Distance", C4: "C4 Position", C5: "C5 Variation", C6: "C6 Level", C7: "C7 Strength", C8: "C8 Tail", C9: "C9 Burst", C10: "C10 Listening" },
-    metrics: { chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
+    metrics: { source: "1 \xB7 Source of what played", chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
     run: { idle: "idle", measuring: "measuring\u2026", done: "done", failed: "failed", recording: "recording\u2026", recorded: "recording downloaded" },
     words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner" },
+    sources: { sdk: "SDK", user: "your sound", synth: "synthesized" },
     probe: "Sound source",
     wall: "Wall (occlusion)",
     scenarios: { pipeline: "File \u2192 decode \u2192 play (round-robin, tail)", criteria: "Criteria C1\u2013C9 on the calibration sound", loop: "File loop: seamless joins (crossfade)", panel: "Panel: categories, matrix, A/B and wall" }
@@ -44679,6 +44729,80 @@ var GameVehiclesThree = (() => {
       sources: [`cena:${line}`]
     };
   }
+  var CABIN_SOUNDS = [
+    {
+      id: "blinker_tick",
+      bus: "world",
+      duration: 0.03,
+      layers: [
+        // the relay: a click of bright noise and a short low knock
+        { source: { kind: "noise", offset: "random" }, filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 2600 } }] }, envelope: [[0, 0.22, "set"], [0.025, 1e-4, "exp", "fixed"]] },
+        { source: { kind: "osc", wave: "triangle", frequency: { set: 180 } }, envelope: [[0, 0.12, "set"], [0.03, 1e-4, "exp", "fixed"]] }
+      ],
+      falloff: { model: "none" }
+    },
+    {
+      id: "starter_crank",
+      bus: "world",
+      duration: 0.9,
+      layers: [
+        // the starter motor turning the engine over: low noise chopped at the compression strokes
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 420 } }] },
+          modulators: [{ target: "gain", wave: "square", rate: 11, depth: 0.08, base: 0.1 }],
+          envelope: [[0, 1e-4, "set", "fixed"], [0.05, 0.25, "linear"], [0.8, 0.22, "set"], [0.9, 1e-4, "exp", "fixed"]]
+        },
+        { source: { kind: "osc", wave: "sawtooth", frequency: { set: 95, to: 120, curve: "linear", over: 0.9 } }, filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 300 } }] }, envelope: [[0, 0.04, "set"], [0.9, 1e-4, "exp", "fixed"]] }
+      ],
+      falloff: { model: "none" }
+    },
+    {
+      id: "car_alarm",
+      bus: "world",
+      order: "siren",
+      duration: 3,
+      tail: 0.1,
+      layers: [
+        // the whoop of a car alarm: a square swept up and down three times a second
+        {
+          source: { kind: "osc", wave: "square", frequency: { set: 1100 } },
+          modulators: [{ target: "frequency", wave: "triangle", rate: 3, depth: 420 }],
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 2600 } }] },
+          envelope: [[0, 1e-4, "set", "fixed"], [0.05, 0.05, "linear"], [2.9, 0.05, "set"], [3, 1e-4, "exp", "fixed"]]
+        }
+      ],
+      falloff: { model: "none" }
+    },
+    {
+      id: "alarm_chirp",
+      bus: "world",
+      duration: 0.1,
+      layers: [{ source: { kind: "osc", wave: "square", frequency: { set: 2300 } }, repeat: { count: 2, spacing: 0.16 }, envelope: [[0, 0.05, "set"], [0.09, 1e-4, "exp", "fixed"]] }],
+      falloff: { model: "none" }
+    },
+    {
+      id: "wiper_swish",
+      bus: "world",
+      duration: 0.45,
+      layers: [
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: 700, to: 1100, curve: "linear", over: 0.45 }, q: 1.2 }] },
+          envelope: [[0, 1e-4, "set", "fixed"], [0.2, 0.06, "linear"], [0.45, 1e-4, "exp", "fixed"]]
+        }
+      ],
+      falloff: { model: "none" }
+    },
+    {
+      id: "seatbelt_chime",
+      bus: "world",
+      duration: 0.5,
+      layers: [{ source: { kind: "osc", wave: "sine", frequency: { set: 880 } }, repeat: { count: 3, spacing: 0.7 }, envelope: [[0, 0.06, "set"], [0.5, 1e-4, "exp", "fixed"]] }],
+      falloff: { model: "none" }
+    }
+  ];
+  var CABIN_BANK = { id: "vehicle_cabin", sounds: CABIN_SOUNDS, loops: [] };
   var FOLEY_FALLOFF = {
     model: "inverse_square",
     k: 0.02,
@@ -45679,6 +45803,21 @@ var GameVehiclesThree = (() => {
 
   // ../game-render-three/dist/index.js
   var DEFAULT_ANGLE = Math.PI / 3;
+  var LIGHT_PRIORITY = {
+    blast: 900,
+    rocket: 800,
+    muzzle: 750,
+    fire: 600,
+    flare: 500,
+    headlight: 400,
+    weaponLight: 400,
+    lamp: 200,
+    street: 150
+  };
+  function isLightBudget(value) {
+    const candidate = value;
+    return typeof candidate === "object" && candidate !== null && typeof candidate.acquire === "function" && typeof candidate.addSource === "function" && typeof candidate.lease === "function" && typeof candidate.present === "function";
+  }
   var EFFECT_STEP_SECONDS = 1 / 50;
   function isRenderPools(value) {
     const candidate = value;
@@ -46343,6 +46482,205 @@ var GameVehiclesThree = (() => {
     const brakeForce = base.brakeForce ?? body.mass * 9.81 * (carRatio + (0.6 - carRatio) * heavyShare);
     return { ...spec, mass: body.mass, wheels, fourWheelDrive: driveAll, engine, gears, drag, brakeForce, tyre: { ...spec.tyre, friction: 0.8 + 0.03 * stats2.handling } };
   }
+  var DEFAULT_CONTROL_KEYS = {
+    throttle: ["KeyW", "ArrowUp"],
+    brake: ["KeyS", "ArrowDown"],
+    left: ["KeyA", "ArrowLeft"],
+    right: ["KeyD", "ArrowRight"],
+    handbrake: ["Space"],
+    horn: ["KeyH"],
+    ignition: ["KeyI"],
+    gearbox: ["KeyM"],
+    gear_up: ["KeyE"],
+    gear_down: ["KeyQ"],
+    parking_brake: ["KeyP"],
+    drive_mode: ["KeyG"],
+    lights: ["KeyL"],
+    high_beam: ["KeyK"],
+    fog_lights: ["KeyN"],
+    interior_light: ["KeyU"],
+    alarm: ["KeyY"],
+    radio: ["KeyR"],
+    radio_source: ["KeyT"],
+    exit: ["KeyF"],
+    indicator_left: ["Comma"],
+    indicator_right: ["Period"],
+    hazard: ["KeyB"],
+    wipers: ["KeyO"],
+    seatbelt: ["KeyJ"]
+  };
+  function createVehicleControls(options) {
+    const keys = { ...DEFAULT_CONTROL_KEYS, ...options.keys };
+    const auto4 = options.autoFourWheel ?? { slip: 0.18, releaseSeconds: 2 };
+    const hasFog = options.fogLamps !== false;
+    const held = /* @__PURE__ */ new Set();
+    const any = (codes) => codes.some((c) => held.has(c));
+    const commandOf = /* @__PURE__ */ new Map();
+    for (const [command2, codes] of Object.entries(keys)) if (!["throttle", "brake", "left", "right", "handbrake", "horn"].includes(command2)) for (const code of codes) commandOf.set(code, command2);
+    const driving = new Set(Object.values(keys).flat());
+    const state = {
+      ignition: !!options.running,
+      gearbox: options.gearbox ?? "automatic",
+      gear: 1,
+      parkingBrake: false,
+      driveMode: options.fourWheelDrive ? "auto" : "4x2",
+      fourWheelEngaged: false,
+      lamps: { mode: "off", fog: false, interior: false },
+      brakeLights: false,
+      reverseLights: false,
+      horn: false,
+      alarm: "off",
+      radio: { on: false, source: "radio" },
+      indicator: "off",
+      blinkOn: false,
+      tick: false,
+      wipers: "off",
+      seatbelt: false
+    };
+    const blinkHz = options.blinkHz ?? 1.5;
+    const cancelAt = options.indicatorCancel ?? 0.15;
+    let blink = 0;
+    let turned = 0;
+    let throttle = 0;
+    let brake = 0;
+    let steer = 0;
+    let calm = 0;
+    const emit = (event) => options.onEvent?.(event);
+    const LAMPS = ["off", "position", "low"];
+    const MODES = ["4x2", "4x4", "auto"];
+    const command = (c) => {
+      switch (c) {
+        case "ignition":
+          state.ignition = !state.ignition;
+          if (state.ignition && state.alarm !== "off") state.alarm = "off";
+          break;
+        case "gearbox":
+          state.gearbox = state.gearbox === "automatic" ? "manual" : "automatic";
+          state.gear = Math.max(1, state.gear);
+          break;
+        case "gear_up":
+        case "gear_down":
+          if (state.gearbox !== "manual") return;
+          state.gear = Math.max(-1, Math.min(options.gears, state.gear + (c === "gear_up" ? 1 : -1)));
+          break;
+        case "parking_brake":
+          state.parkingBrake = !state.parkingBrake;
+          break;
+        case "drive_mode": {
+          if (!options.fourWheelDrive) return emit({ type: "refused", command: c, reason: "no_four_wheel_drive" });
+          state.driveMode = MODES[(MODES.indexOf(state.driveMode) + 1) % MODES.length];
+          state.fourWheelEngaged = state.driveMode === "4x4";
+          break;
+        }
+        case "lights":
+          state.lamps.mode = state.lamps.mode === "high" ? "off" : LAMPS[(LAMPS.indexOf(state.lamps.mode) + 1) % LAMPS.length];
+          break;
+        case "high_beam":
+          state.lamps.mode = state.lamps.mode === "high" ? "low" : "high";
+          break;
+        case "fog_lights":
+          if (!hasFog) return emit({ type: "refused", command: c, reason: "no_fog_lamps" });
+          state.lamps.fog = !state.lamps.fog;
+          if (state.lamps.fog && state.lamps.mode === "off") state.lamps.mode = "position";
+          break;
+        case "interior_light":
+          state.lamps.interior = !state.lamps.interior;
+          break;
+        case "alarm":
+          state.alarm = state.alarm === "off" ? "armed" : state.alarm === "armed" ? "ringing" : "off";
+          break;
+        case "radio":
+          state.radio.on = !state.radio.on;
+          break;
+        case "radio_source":
+          state.radio.source = state.radio.source === "radio" ? "tape" : "radio";
+          break;
+        case "exit":
+          break;
+        case "indicator_left":
+        case "indicator_right": {
+          const side2 = c === "indicator_left" ? "left" : "right";
+          if (state.indicator === "hazard") return;
+          state.indicator = state.indicator === side2 ? "off" : side2;
+          turned = 0;
+          blink = 0;
+          break;
+        }
+        case "hazard":
+          state.indicator = state.indicator === "hazard" ? "off" : "hazard";
+          blink = 0;
+          break;
+        case "wipers":
+          state.wipers = state.wipers === "off" ? "slow" : state.wipers === "slow" ? "fast" : "off";
+          break;
+        case "seatbelt":
+          state.seatbelt = !state.seatbelt;
+          break;
+      }
+      emit({ type: "command", command: c, state });
+    };
+    const ease = (from, to, rate, dt) => from + Math.sign(to - from) * Math.min(Math.abs(to - from), rate * dt);
+    return {
+      keys,
+      state,
+      key(code, down) {
+        if (!driving.has(code)) return false;
+        const was = held.has(code);
+        if (down) held.add(code);
+        else held.delete(code);
+        const c = commandOf.get(code);
+        if (c && down && !was) command(c);
+        return true;
+      },
+      command,
+      input(dt, driver) {
+        const gas = any(keys.throttle) ? 1 : 0;
+        const stop = any(keys.brake) ? 1 : 0;
+        const wheel = (any(keys.left) ? 1 : 0) - (any(keys.right) ? 1 : 0);
+        throttle = ease(throttle, gas, gas > throttle ? 4 : 8, dt);
+        brake = ease(brake, stop, stop > brake ? 6 : 10, dt);
+        steer = ease(steer, wheel, wheel !== 0 && Math.sign(wheel) === Math.sign(steer || wheel) ? 3 : 6, dt);
+        const handbrake = state.parkingBrake || any(keys.handbrake);
+        state.tick = false;
+        if (state.indicator !== "off") {
+          const before = Math.floor(blink * blinkHz * 2);
+          blink += dt;
+          const now = Math.floor(blink * blinkHz * 2);
+          state.blinkOn = now % 2 === 0;
+          state.tick = now !== before;
+          if (state.indicator !== "hazard") {
+            const way = state.indicator === "left" ? steer : -steer;
+            if (way > 0.5) turned = 1;
+            else if (turned && way < cancelAt) state.indicator = "off";
+          }
+        } else state.blinkOn = false;
+        state.horn = any(keys.horn);
+        const gasNow = state.ignition ? throttle : 0;
+        const reversing = state.gearbox === "manual" ? state.gear < 0 : (driver?.state.gear ?? 1) < 0;
+        state.reverseLights = reversing;
+        state.brakeLights = handbrake || (reversing ? gasNow > 0.05 && (driver?.state.u ?? 0) < -0.3 : brake > 0.05);
+        if (state.gearbox === "automatic") return { throttle: gasNow, brake, steer, handbrake, horn: state.horn };
+        return state.gear < 0 ? { throttle: brake, brake: gasNow, steer, handbrake, horn: state.horn, gear: state.gear } : { throttle: gasNow, brake, steer, handbrake, horn: state.horn, gear: state.gear };
+      },
+      after(driver, dt) {
+        if (driver.state.engineOn && !state.ignition && driver.state.u !== 0) state.ignition = true;
+        if (!state.ignition && driver.state.engineOn) driver.state.engineOn = false;
+        if (state.driveMode === "auto" && options.fourWheelDrive) {
+          const slip = Math.max(0, ...driver.state.slip);
+          if (slip > auto4.slip) {
+            state.fourWheelEngaged = true;
+            calm = 0;
+          } else if (state.fourWheelEngaged && (calm += dt) > auto4.releaseSeconds) state.fourWheelEngaged = false;
+        } else state.fourWheelEngaged = state.driveMode === "4x4";
+        driver.spec.fourWheelDrive = !!options.fourWheelDrive && state.fourWheelEngaged;
+      },
+      release() {
+        held.clear();
+        throttle = brake = steer = 0;
+        state.horn = false;
+      }
+    };
+  }
   function conditionFromDamage(spec, report) {
     const tyres = spec.wheels.map((wheel) => {
       let best;
@@ -47949,21 +48287,521 @@ var GameVehiclesThree = (() => {
     return { ...certificate, results, status: statusOf(results) };
   }
 
+  // src/dashboard.ts
+  var DASHBOARD_LOOK = {
+    face: "#0b1110",
+    ring: "#2f3a36",
+    marks: "#cfe8dc",
+    needle: "#ff6a2a",
+    red: "#e2402f",
+    amber: "#f2a630",
+    green: "#46d16f",
+    blue: "#3f8cff",
+    dim: "rgba(207,232,220,0.12)",
+    /** How far in front of the kit's dial the face sits, metres (the kit's needle sticks out 6 mm). */
+    lift: 0.011
+  };
+  var SIZE = 256;
+  function createVehicleDashboard(THREE, built2, options) {
+    const maxKmh = options.maxKmh ?? 220;
+    const redline = options.redlineRpm ?? 6500;
+    const doc = options.document ?? (typeof document !== "undefined" ? document : null);
+    const dials = [];
+    built2.group.traverse((o) => {
+      if (o.isMesh && o.material === options.gauge) dials.push(o);
+    });
+    const eye = built2.driverEye;
+    const hidden = [];
+    const faces = [];
+    if (doc && eye && dials.length) {
+      built2.group.updateMatrixWorld(true);
+      const eyeWorld = built2.group.localToWorld(new THREE.Vector3(eye[0], eye[1], eye[2]));
+      const near = dials.map((d) => ({ d, at: d.getWorldPosition(new THREE.Vector3()) })).sort((a, b) => a.at.distanceTo(eyeWorld) - b.at.distanceTo(eyeWorld)).slice(0, 2).sort((a, b) => built2.group.worldToLocal(b.at.clone()).x - built2.group.worldToLocal(a.at.clone()).x);
+      near.forEach(({ d, at }, i) => {
+        const canvas = doc.createElement("canvas");
+        canvas.width = canvas.height = SIZE;
+        const g = canvas.getContext("2d");
+        if (!g) return;
+        const texture = new THREE.CanvasTexture(canvas);
+        const radius = d.geometry.parameters?.radiusTop ?? 0.055;
+        const mesh2 = new THREE.Mesh(new THREE.CircleGeometry(radius * 1.12, 40), new THREE.MeshBasicMaterial({ map: texture, transparent: true, toneMapped: false, depthWrite: false }));
+        mesh2.name = "dashboard_face";
+        const axis = new THREE.Vector3(0, 1, 0).applyQuaternion(d.getWorldQuaternion(d.quaternion.clone())).normalize();
+        if (axis.dot(eyeWorld.clone().sub(at)) < 0) axis.negate();
+        const front = at.clone().addScaledVector(axis, DASHBOARD_LOOK.lift);
+        mesh2.position.copy(built2.group.worldToLocal(front.clone()));
+        built2.group.add(mesh2);
+        mesh2.updateMatrixWorld(true);
+        mesh2.lookAt(front.add(axis));
+        d.visible = false;
+        hidden.push(d);
+        if (options.needle)
+          built2.group.traverse((o) => {
+            if (o.isMesh && o.material === options.needle && o.visible && o.getWorldPosition(new THREE.Vector3()).distanceTo(at) < radius * 1.2) {
+              o.visible = false;
+              hidden.push(o);
+            }
+          });
+        faces.push({ mesh: mesh2, canvas, g, texture, kind: near.length === 1 || i === 0 ? "speed" : "rpm" });
+      });
+    }
+    const lamp = (g, x, y, on, colour, draw2) => {
+      g.save();
+      g.translate(x, y);
+      g.fillStyle = g.strokeStyle = on ? colour : DASHBOARD_LOOK.dim;
+      g.lineWidth = 4;
+      draw2(g);
+      g.restore();
+    };
+    const arrow = (dir) => (g) => {
+      g.beginPath();
+      g.moveTo(dir * 14, 0);
+      g.lineTo(-dir * 2, -12);
+      g.lineTo(-dir * 2, -5);
+      g.lineTo(-dir * 14, -5);
+      g.lineTo(-dir * 14, 5);
+      g.lineTo(-dir * 2, 5);
+      g.lineTo(-dir * 2, 12);
+      g.closePath();
+      g.fill();
+    };
+    const beam = (g) => {
+      g.beginPath();
+      g.arc(-4, 0, 10, Math.PI / 2, -Math.PI / 2, true);
+      g.closePath();
+      g.fill();
+      for (let k = -1; k <= 1; k++) g.fillRect(8, k * 6 - 1.5, 10, 3);
+    };
+    const belt = (g) => {
+      g.beginPath();
+      g.arc(0, -10, 5, 0, Math.PI * 2);
+      g.fill();
+      g.fillRect(-6, -3, 12, 16);
+      g.strokeStyle = DASHBOARD_LOOK.face;
+      g.lineWidth = 3;
+      g.beginPath();
+      g.moveTo(-7, -3);
+      g.lineTo(7, 12);
+      g.stroke();
+    };
+    const letter = (text) => (g) => {
+      g.font = "bold 22px sans-serif";
+      g.textAlign = "center";
+      g.textBaseline = "middle";
+      g.fillText(text, 0, 1);
+    };
+    const ring2 = (text) => (g) => {
+      g.beginPath();
+      g.arc(0, 0, 13, 0, Math.PI * 2);
+      g.stroke();
+      letter(text)(g);
+    };
+    const dial = (g, value, top, step, redFrom, label) => {
+      const c = SIZE / 2;
+      g.clearRect(0, 0, SIZE, SIZE);
+      g.fillStyle = DASHBOARD_LOOK.face;
+      g.beginPath();
+      g.arc(c, c, c - 2, 0, Math.PI * 2);
+      g.fill();
+      g.strokeStyle = DASHBOARD_LOOK.ring;
+      g.lineWidth = 6;
+      g.stroke();
+      const angle = (v) => Math.PI * 0.75 + Math.max(0, Math.min(top, v)) / top * Math.PI * 1.5;
+      for (let v = 0; v <= top + 1e-6; v += step) {
+        const a2 = angle(v);
+        g.strokeStyle = redFrom !== null && v >= redFrom ? DASHBOARD_LOOK.red : DASHBOARD_LOOK.marks;
+        g.lineWidth = 4;
+        g.beginPath();
+        g.moveTo(c + Math.cos(a2) * (c - 12), c + Math.sin(a2) * (c - 12));
+        g.lineTo(c + Math.cos(a2) * (c - 30), c + Math.sin(a2) * (c - 30));
+        g.stroke();
+        g.fillStyle = DASHBOARD_LOOK.marks;
+        g.font = "18px sans-serif";
+        g.textAlign = "center";
+        g.textBaseline = "middle";
+        g.fillText(label(v), c + Math.cos(a2) * (c - 48), c + Math.sin(a2) * (c - 48));
+      }
+      const a = angle(value);
+      g.strokeStyle = DASHBOARD_LOOK.needle;
+      g.lineWidth = 6;
+      g.beginPath();
+      g.moveTo(c - Math.cos(a) * 14, c - Math.sin(a) * 14);
+      g.lineTo(c + Math.cos(a) * (c - 22), c + Math.sin(a) * (c - 22));
+      g.stroke();
+      g.fillStyle = DASHBOARD_LOOK.ring;
+      g.beginPath();
+      g.arc(c, c, 10, 0, Math.PI * 2);
+      g.fill();
+    };
+    const bar = (g, x, share, warnAbove, label) => {
+      if (share === void 0) return;
+      const h = 60;
+      g.strokeStyle = DASHBOARD_LOOK.marks;
+      g.lineWidth = 2;
+      g.strokeRect(x - 5, 150, 10, h);
+      const s = Math.max(0, Math.min(1, share));
+      g.fillStyle = (warnAbove ? s > 0.85 : s < 0.12) ? DASHBOARD_LOOK.red : DASHBOARD_LOOK.marks;
+      g.fillRect(x - 4, 150 + h * (1 - s), 8, h * s);
+      g.font = "14px sans-serif";
+      g.textAlign = "center";
+      g.fillText(label, x, 222);
+    };
+    const draw = (r) => {
+      const warn = r.ignition && !r.engineOn;
+      for (const f of faces) {
+        const g = f.g;
+        if (f.kind === "speed") {
+          dial(g, r.kmh, maxKmh, maxKmh > 160 ? 20 : 10, null, (v) => String(Math.round(v)));
+          g.fillStyle = DASHBOARD_LOOK.marks;
+          g.font = "bold 30px sans-serif";
+          g.textAlign = "center";
+          g.fillText(String(Math.round(r.kmh)), SIZE / 2, SIZE / 2 + 52);
+          lamp(g, 92, 178, r.left, DASHBOARD_LOOK.green, arrow(-1));
+          lamp(g, 164, 178, r.right, DASHBOARD_LOOK.green, arrow(1));
+          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");
+        } else {
+          dial(g, r.rpm / 1e3, Math.ceil(redline / 1e3) + 1, 1, redline / 1e3, (v) => String(Math.round(v)));
+          g.fillStyle = DASHBOARD_LOOK.marks;
+          g.font = "bold 34px sans-serif";
+          g.textAlign = "center";
+          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, ring2("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, 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");
+        }
+        f.texture.needsUpdate = true;
+      }
+    };
+    let wait = 0;
+    let last = "";
+    return {
+      dials: faces.length,
+      update(reading, dt) {
+        if (!faces.length) return;
+        wait -= dt;
+        const key = JSON.stringify(reading);
+        if (wait > 0 || key === last) return;
+        wait = 1 / (options.fps ?? 15);
+        last = key;
+        draw(reading);
+      },
+      dispose() {
+        for (const f of faces) {
+          discardObject3D(f.mesh);
+          f.texture.dispose();
+          f.canvas.width = f.canvas.height = 0;
+        }
+        faces.length = 0;
+        for (const o of hidden) o.visible = true;
+        hidden.length = 0;
+      }
+    };
+  }
+
+  // src/lamps.ts
+  var LAMP_RULES = {
+    glow: { head: { off: 0.04, position: 0.3, low: 1, high: 1.35 }, tail: { off: 0.15, on: 0.7, brake: 1.6 }, fog: { off: 0.04, on: 1.1 }, amber: { off: 0.1, on: 2.2 } },
+    low: { color: 16773584, intensity: 2.4, distance: 32, angle: 0.42, penumbra: 0.55, decay: 1.6, drop: 0.09 },
+    high: { color: 16774882, intensity: 3.6, distance: 70, angle: 0.3, penumbra: 0.45, decay: 1.4, drop: 0.015 },
+    fog: { color: 16773320, intensity: 1.6, distance: 16, angle: 0.75, penumbra: 0.7, decay: 1.8, drop: 0.12 },
+    reverse: { color: 16054015, intensity: 0.9, distance: 7, decay: 2 },
+    interior: { color: 16769712, intensity: 0.5, distance: 2.4, decay: 2 }
+  };
+  function createVehicleLamps(THREE, built2, options = {}) {
+    const budget = isLightBudget(options.lights) ? options.lights : null;
+    const owner = options.owner ?? "vehicle-lamps";
+    const context = built2.context;
+    const lamps = (context?.lights ?? []).filter((l) => l && Array.isArray(l.inner)).map((l) => l.fog ? { ...l, kind: "fog" } : l);
+    const bulbs = (context?.fogBulbs ?? []).filter((o) => o?.material);
+    built2.group.traverse((o) => {
+      if (o.userData?.lamp === "fog" && o.material && !bulbs.includes(o)) bulbs.push(o);
+    });
+    if (bulbs.length) lamps.push({ kind: "fog", inner: bulbs });
+    const has = { head: lamps.some((l) => l.kind === "headlight"), tail: lamps.some((l) => l.kind === "taillight"), fog: lamps.some((l) => l.kind === "fog"), indicators: false };
+    const originals = /* @__PURE__ */ new Map();
+    const copies = /* @__PURE__ */ new Map();
+    const base = /* @__PURE__ */ new Map();
+    const own = (mesh2) => {
+      const mat = mesh2.material;
+      if (!mat || Array.isArray(mat)) return null;
+      if (copies.has(mat) || base.has(mat)) return mat;
+      const copy = mat.clone();
+      originals.set(mesh2, mat);
+      copies.set(copy, mat);
+      base.set(copy, mat.emissiveIntensity ?? 1);
+      mesh2.material = copy;
+      return copy;
+    };
+    const haloBase = /* @__PURE__ */ new Map();
+    for (const l of lamps) {
+      for (const m of l.inner) own(m);
+      for (const h of l.halo ?? []) haloBase.set(h, h.scale.x);
+    }
+    const amber = /* @__PURE__ */ new Set();
+    const sideOf = /* @__PURE__ */ new Map();
+    for (const l of lamps) {
+      const x = l.group?.position?.x ?? 0;
+      for (const m of l.inner) {
+        const mat = Array.isArray(m.material) ? null : m.material;
+        const c = (mat && (copies.get(mat) ?? mat))?.color;
+        if (c && c.r > 0.5 && c.r - c.b > 0.35 && c.g < c.r * 0.8 && c.g > c.b) {
+          amber.add(m);
+          sideOf.set(m, x >= 0 ? "left" : "right");
+        }
+      }
+    }
+    has.indicators = amber.size > 0;
+    const glowMesh = (m, share) => {
+      const mat = m.material;
+      if (mat && !Array.isArray(mat) && base.has(mat) && "emissiveIntensity" in mat) mat.emissiveIntensity = base.get(mat) * share;
+    };
+    const glow = (l, share) => {
+      for (const m of l.inner) {
+        if (amber.has(m)) continue;
+        glowMesh(m, share);
+      }
+      for (const h of l.halo ?? []) {
+        h.visible = share > 0.5;
+        const s = (haloBase.get(h) ?? 1) * Math.min(1.4, share);
+        h.scale.set(s, s, 1);
+      }
+    };
+    const L = built2.length;
+    const W = built2.width;
+    const H = built2.height;
+    const anchors = [];
+    const anchor = (x, y, z, yaw, drop) => {
+      const a = new THREE.Object3D();
+      a.position.set(x, y, z);
+      a.rotation.set(-drop, yaw, 0, "YXZ");
+      built2.group.add(a);
+      anchors.push(a);
+      return a;
+    };
+    const front = [-1, 1].map((s) => anchor(s * W * 0.34, Math.min(0.9, H * 0.48), L / 2 - 0.05, Math.PI, 0));
+    const fogAnchors = [-1, 1].map((s) => anchor(s * W * 0.38, Math.min(0.45, H * 0.25), L / 2 - 0.03, Math.PI, 0));
+    const rear = anchor(0, Math.min(0.9, H * 0.45), -L / 2 - 0.3, 0, 0);
+    const cabin = anchor(0, H * 0.85, 0, 0, 0);
+    const sources = /* @__PURE__ */ new Map();
+    const beam = (id, on, make2) => {
+      const now = sources.get(id);
+      if (on && !now && budget) sources.set(id, make2());
+      if (!on && now) {
+        for (const s of now) s.remove();
+        sources.delete(id);
+      }
+    };
+    const spots = (at, rule) => at.map((a) => {
+      a.rotation.x = -rule.drop;
+      return budget.addSource({ owner, kind: "spot", priority: LIGHT_PRIORITY.headlight, color: rule.color, intensity: rule.intensity, distance: rule.distance, decay: rule.decay, angle: rule.angle, penumbra: rule.penumbra, position: [0, 0, 0], follow: a });
+    });
+    const point = (a, rule) => [
+      budget.addSource({ owner, kind: "point", priority: LIGHT_PRIORITY.lamp, color: rule.color, intensity: rule.intensity, distance: rule.distance, decay: rule.decay, position: [0, 0, 0], follow: a })
+    ];
+    const state = { mode: "off", fog: false, interior: false, brake: false, reverse: false, left: false, right: false };
+    const apply = () => {
+      const g = LAMP_RULES.glow;
+      for (const l of lamps) {
+        if (l.kind === "headlight") glow(l, g.head[state.mode]);
+        else if (l.kind === "taillight") glow(l, state.brake ? g.tail.brake : state.mode === "off" ? g.tail.off : g.tail.on);
+        else if (l.kind === "fog") glow(l, state.fog ? g.fog.on : g.fog.off);
+      }
+      for (const m of amber) glowMesh(m, state[sideOf.get(m) ?? "left"] ? g.amber.on : g.amber.off);
+      const beamId = state.mode === "low" || state.mode === "high" ? state.mode : null;
+      for (const id of ["low", "high"]) beam(id, beamId === id, () => spots(front, LAMP_RULES[id]));
+      beam("fog", state.fog && has.fog, () => spots(fogAnchors, LAMP_RULES.fog));
+      beam("reverse", state.reverse, () => point(rear, LAMP_RULES.reverse));
+      beam("interior", state.interior, () => point(cabin, LAMP_RULES.interior));
+    };
+    apply();
+    return {
+      has,
+      get state() {
+        return { ...state };
+      },
+      set(next) {
+        if (next.mode === state.mode && next.fog === state.fog && next.interior === state.interior && next.brake === state.brake && next.reverse === state.reverse && next.left === state.left && next.right === state.right) return;
+        Object.assign(state, next);
+        apply();
+      },
+      dispose() {
+        for (const list2 of sources.values()) for (const s of list2) s.remove();
+        sources.clear();
+        for (const a of anchors) a.removeFromParent();
+        anchors.length = 0;
+        for (const l of lamps) {
+          for (const m of l.inner) {
+            const copy = m.material;
+            const original = originals.get(m);
+            if (original) {
+              m.material = original;
+              if (copy && !Array.isArray(copy)) copy.dispose?.();
+            }
+          }
+          for (const h of l.halo ?? []) {
+            h.visible = true;
+            const s = haloBase.get(h) ?? 1;
+            h.scale.set(s, s, 1);
+          }
+        }
+        originals.clear();
+        copies.clear();
+        base.clear();
+      }
+    };
+  }
+
+  // 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" };
+  function createCockpit(o) {
+    const sounds = { ...DEFAULT_COCKPIT_SOUNDS, ...o.sounds };
+    const spec = subjectSpec(o.subject);
+    const driver = createSemiSimDriver(spec);
+    driver.place(o.place[0], o.place[1], o.place[2]);
+    const lamps = createVehicleLamps(o.THREE, o.built, { lights: o.host.lights, owner: "proving-ground" });
+    const audio = o.host.audio;
+    const top = o.subject.stats.maxSpeedKmh;
+    const dashboard = o.gauge ? createVehicleDashboard(o.THREE, o.built, { gauge: o.gauge, needle: o.needle, redlineRpm: spec.engine.redlineRpm, maxKmh: top ? Math.ceil((top + 10) / 20) * 20 : void 0 }) : null;
+    const at = () => [o.built.group.position.x, 1, o.built.group.position.z];
+    const play = (sound, volume = 1) => void audio?.play?.({ sound, position: at(), volume });
+    let alarmAgain = 0;
+    let hornAgain = 0;
+    let wipeAgain = 0;
+    let chimeAgain = 0;
+    let radioAgain = 0;
+    let exitAsked = false;
+    let gas = 0;
+    const controls = createVehicleControls({
+      gears: spec.gears?.length ?? 5,
+      fourWheelDrive: !!o.subject.body.fourWheelDrive,
+      fogLamps: lamps.has.fog,
+      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 === "exit") exitAsked = true;
+        }
+        o.onEvent?.(event);
+      }
+    });
+    driver.state.engineOn = false;
+    const target = typeof window !== "undefined" ? window : null;
+    const down = (e) => {
+      if (!controls.key(e.code, true)) return;
+      e.stopImmediatePropagation();
+      if (e.code.startsWith("Arrow") || e.code === "Space") e.preventDefault();
+    };
+    const up = (e) => {
+      if (controls.key(e.code, false)) e.stopImmediatePropagation();
+    };
+    const blur = () => controls.release();
+    target?.addEventListener("keydown", down, true);
+    target?.addEventListener("keyup", up, true);
+    target?.addEventListener("blur", blur);
+    return {
+      driver,
+      controls,
+      lamps,
+      dashboard,
+      get throttle() {
+        return gas;
+      },
+      step(dt) {
+        const input = controls.input(dt, driver);
+        gas = input.throttle;
+        driver.step(input, dt);
+        controls.after(driver, dt);
+        const s = controls.state;
+        lamps.set({
+          mode: s.lamps.mode,
+          fog: s.lamps.fog,
+          interior: s.lamps.interior,
+          brake: s.brakeLights,
+          reverse: s.reverseLights,
+          left: s.blinkOn && (s.indicator === "left" || s.indicator === "hazard"),
+          right: s.blinkOn && (s.indicator === "right" || s.indicator === "hazard")
+        });
+        dashboard?.update(
+          {
+            kmh: Math.abs(driver.state.u) * 3.6,
+            rpm: driver.state.engineOn ? driver.state.rpm : 0,
+            gear: driver.state.gear,
+            ignition: s.ignition,
+            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",
+            lowBeam: s.lamps.mode === "low" || s.lamps.mode === "position",
+            fog: s.lamps.fog,
+            parkingBrake: s.parkingBrake,
+            seatbelt: s.seatbelt,
+            fourWheel: s.fourWheelEngaged
+          },
+          dt
+        );
+        if (s.tick) play(sounds.blinker, 0.8);
+        if (s.horn && (hornAgain -= dt) <= 0) {
+          play(sounds.horn);
+          hornAgain = 0.5;
+        } else if (!s.horn) hornAgain = 0;
+        if (s.alarm === "ringing" && (alarmAgain -= dt) <= 0) {
+          play(sounds.alarm);
+          alarmAgain = 2.9;
+        }
+        if (s.wipers !== "off" && (wipeAgain -= dt) <= 0) {
+          play(sounds.wiper, 0.7);
+          wipeAgain = s.wipers === "fast" ? 0.6 : 1.4;
+        }
+        const kmh2 = Math.abs(driver.state.u) * 3.6;
+        if (!s.seatbelt && s.ignition && kmh2 > 10 && (chimeAgain -= dt) <= 0) {
+          play(sounds.chime, 0.6);
+          chimeAgain = 6;
+        }
+        if (s.radio.on && (radioAgain -= dt) <= 0) {
+          play(sounds.radio, s.radio.source === "tape" ? 0.25 : 0.45);
+          radioAgain = 0.55;
+        }
+        if (exitAsked) {
+          exitAsked = false;
+          o.onExit();
+        }
+      },
+      stop() {
+        target?.removeEventListener("keydown", down, true);
+        target?.removeEventListener("keyup", up, true);
+        target?.removeEventListener("blur", blur);
+        controls.release();
+        lamps.dispose();
+        dashboard?.dispose();
+      }
+    };
+  }
+
   // src/test-area/proving/text.ts
   var PROVING_TEXT = {
     "pt-BR": {
       name: "Banco de provas",
-      controls: { vehicle: "Ve\xEDculo", test: "Prova", camera: "C\xE2mera", time_scale: "Velocidade da simula\xE7\xE3o", visual_check: "Checagem visual" },
+      controls: { vehicle: "Ve\xEDculo", test: "Prova", camera: "C\xE2mera", time_scale: "Velocidade da simula\xE7\xE3o", visual_check: "Checagem visual", gearbox: "C\xE2mbio" },
+      gearbox: { automatic: "Autom\xE1tico", manual: "Manual" },
       hints: {
+        gearbox: "Autom\xE1tico troca sozinho. Manual: E sobe e Q desce a marcha (abaixo da 1\xAA v\xEAm o neutro e a r\xE9). M alterna dirigindo",
         vehicle: "Ve\xEDculo da frota que vai para a pista",
         test: "Prova medida que o bot\xE3o Rodar prova executa",
         camera: "Sala: a c\xE2mera do jogador. Persegui\xE7\xE3o, cabine e cap\xF4 seguem o ve\xEDculo",
         time_scale: "Quantas vezes mais r\xE1pido que o tempo real a prova roda",
         visual_check: "O que voc\xEA olhou e vai aprovar ou reprovar"
       },
-      actions: { run_test: "Rodar prova", run_all: "Rodar todas na pista", certify_now: "Homologar agora (sem anima\xE7\xE3o)", reverse_park: "Dar r\xE9 (c\xE2mera de r\xE9)", sign_ok: "Aprovar checagem visual", sign_fail: "Reprovar checagem visual", reset: "Limpar ficha" },
+      actions: { drive: "Dirigir (entrar / sair)", run_test: "Rodar prova", run_all: "Rodar todas na pista", certify_now: "Homologar agora (sem anima\xE7\xE3o)", reverse_park: "Dar r\xE9 (c\xE2mera de r\xE9)", sign_ok: "Aprovar checagem visual", sign_fail: "Reprovar checagem visual", reset: "Limpar ficha" },
       layers: { mirrors: "Retrovisores", reverse_camera: "C\xE2mera de r\xE9", scoreboard: "Painel da ficha" },
-      metrics: { speed: "Velocidade", time: "Tempo da prova", value: "Medi\xE7\xE3o", passed: "Aprovadas", failed: "Reprovadas", pending: "Pendentes", status: "Situa\xE7\xE3o (0 pend., 1 aprov., -1 reprov.)" },
+      metrics: { gear: "Marcha (-1 r\xE9, 0 neutro)", rpm: "Rota\xE7\xE3o", speed: "Velocidade", time: "Tempo da prova", value: "Medi\xE7\xE3o", passed: "Aprovadas", failed: "Reprovadas", pending: "Pendentes", status: "Situa\xE7\xE3o (0 pend., 1 aprov., -1 reprov.)" },
       cameras: { room: "Sala", chase: "Persegui\xE7\xE3o (3\xAA pessoa)", cockpit: "Cabine (1\xAA pessoa)", hood: "Cap\xF4" },
       tests: {
         accel_0_100: "0 a 100 km/h",
@@ -47985,22 +48823,49 @@ var GameVehiclesThree = (() => {
       },
       status: { approved: "APROVADO", rejected: "REPROVADO", pending: "PENDENTE" },
       verdict: { pass: "ok", fail: "falhou", pending: "\u2026" },
-      board: { title: "Ficha de homologa\xE7\xE3o", test: "Prova", value: "Medido", range: "Faixa", verdict: "Resultado", notRun: "n\xE3o rodada", running: "rodando" },
-      log: { start: "Prova {0}: {1}", result: "{0} \xB7 {1}: {2} {3} (faixa {4}) \u2192 {5}", signed: "{0} \xB7 {1}: {2} na sala", certified: "{0}: {1}" }
+      board: { title: "Ficha de homologa\xE7\xE3o", test: "Prova", value: "Medido", range: "Faixa", verdict: "Resultado", notRun: "n\xE3o rodada", running: "rodando", gear: "Marcha {0} \xB7 {1} rpm \xB7 {2} km/h" },
+      log: { start: "Prova {0}: {1}", result: "{0} \xB7 {1}: {2} {3} (faixa {4}) \u2192 {5}", signed: "{0} \xB7 {1}: {2} na sala", certified: "{0}: {1}", drive: "Dirigindo {0}: I liga o motor, F sai do carro", leave: "Saiu do volante", shift: "Marcha {0} \u2192 {1} a {2} km/h" },
+      cabin: {
+        keys: "W ou \u2191 acelera \xB7 S ou \u2193 freia (parado, d\xE1 r\xE9) \xB7 A/D ou \u2190/\u2192 vira \xB7 Espa\xE7o freio de m\xE3o \xB7 P puxa o freio de m\xE3o \xB7 I liga e desliga \xB7 M c\xE2mbio manual/autom\xE1tico \xB7 E sobe e Q desce marcha \xB7 G tra\xE7\xE3o 4x2/4x4/4x4 autom\xE1tica \xB7 L luzes (posi\xE7\xE3o, baixa) \xB7 K farol alto \xB7 N neblina \xB7 U luz interna \xB7 v\xEDrgula e ponto setas \xB7 B pisca-alerta \xB7 O limpador \xB7 J cinto \xB7 H buzina \xB7 Y alarme \xB7 R r\xE1dio \xB7 T r\xE1dio/fita \xB7 F sai do carro",
+        on: "ligado",
+        off: "desligado",
+        ignition: "Motor",
+        gearbox: "C\xE2mbio",
+        gear: "Marcha",
+        parkingBrake: "Freio de m\xE3o",
+        driveMode: "Tra\xE7\xE3o",
+        modes: { "4x2": "4x2", "4x4": "4x4", auto: "4x4 autom\xE1tica" },
+        lights: "Luzes",
+        lampModes: { off: "apagadas", position: "posi\xE7\xE3o", low: "farol baixo", high: "farol alto" },
+        fog: "Neblina",
+        interior: "Luz interna",
+        alarm: "Alarme",
+        alarmStates: { off: "desligado", armed: "armado", ringing: "disparado" },
+        radio: "Som",
+        sources: { radio: "r\xE1dio", tape: "toca-fitas" },
+        indicator: "Setas",
+        indicators: { off: "desligadas", left: "esquerda", right: "direita", hazard: "pisca-alerta" },
+        wipers: "Limpador",
+        wiperModes: { off: "desligado", slow: "lento", fast: "r\xE1pido" },
+        seatbelt: "Cinto",
+        refused: { no_four_wheel_drive: "Este ve\xEDculo n\xE3o tem tra\xE7\xE3o 4x4", no_fog_lamps: "Este ve\xEDculo n\xE3o tem farol de neblina", ignition_off: "Ligue o motor primeiro" }
+      }
     },
     en: {
       name: "Proving ground",
-      controls: { vehicle: "Vehicle", test: "Test", camera: "Camera", time_scale: "Simulation speed", visual_check: "Visual check" },
+      controls: { vehicle: "Vehicle", test: "Test", camera: "Camera", time_scale: "Simulation speed", visual_check: "Visual check", gearbox: "Gearbox" },
+      gearbox: { automatic: "Automatic", manual: "Manual" },
       hints: {
+        gearbox: "Automatic shifts by itself. Manual: E shifts up and Q down (below 1st come neutral and reverse). M switches while driving",
         vehicle: "Fleet vehicle that goes on the track",
         test: "Measured test the Run test button runs",
         camera: "Room: the player camera. Chase, cockpit and hood follow the vehicle",
         time_scale: "How many times faster than real time the test runs",
         visual_check: "What you looked at and will approve or refuse"
       },
-      actions: { run_test: "Run test", run_all: "Run all on the track", certify_now: "Certify now (no animation)", reverse_park: "Reverse (reversing camera)", sign_ok: "Approve visual check", sign_fail: "Refuse visual check", reset: "Clear certificate" },
+      actions: { drive: "Drive (get in / out)", run_test: "Run test", run_all: "Run all on the track", certify_now: "Certify now (no animation)", reverse_park: "Reverse (reversing camera)", sign_ok: "Approve visual check", sign_fail: "Refuse visual check", reset: "Clear certificate" },
       layers: { mirrors: "Mirrors", reverse_camera: "Reversing camera", scoreboard: "Certificate board" },
-      metrics: { speed: "Speed", time: "Test time", value: "Measured", passed: "Passed", failed: "Failed", pending: "Pending", status: "Status (0 pending, 1 approved, -1 rejected)" },
+      metrics: { gear: "Gear (-1 reverse, 0 neutral)", rpm: "Engine speed", speed: "Speed", time: "Test time", value: "Measured", passed: "Passed", failed: "Failed", pending: "Pending", status: "Status (0 pending, 1 approved, -1 rejected)" },
       cameras: { room: "Room", chase: "Chase (third person)", cockpit: "Cockpit (first person)", hood: "Hood" },
       tests: {
         accel_0_100: "0 to 100 km/h",
@@ -48022,8 +48887,33 @@ var GameVehiclesThree = (() => {
       },
       status: { approved: "APPROVED", rejected: "REJECTED", pending: "PENDING" },
       verdict: { pass: "ok", fail: "failed", pending: "\u2026" },
-      board: { title: "Certificate", test: "Test", value: "Measured", range: "Range", verdict: "Result", notRun: "not run", running: "running" },
-      log: { start: "Test {0}: {1}", result: "{0} \xB7 {1}: {2} {3} (range {4}) \u2192 {5}", signed: "{0} \xB7 {1}: {2} in the room", certified: "{0}: {1}" }
+      board: { title: "Certificate", test: "Test", value: "Measured", range: "Range", verdict: "Result", notRun: "not run", running: "running", gear: "Gear {0} \xB7 {1} rpm \xB7 {2} km/h" },
+      log: { start: "Test {0}: {1}", result: "{0} \xB7 {1}: {2} {3} (range {4}) \u2192 {5}", signed: "{0} \xB7 {1}: {2} in the room", certified: "{0}: {1}", drive: "Driving {0}: I starts the engine, F gets out", leave: "Left the wheel", shift: "Gear {0} \u2192 {1} at {2} km/h" },
+      cabin: {
+        keys: "W or \u2191 accelerates \xB7 S or \u2193 brakes (stopped, reverses) \xB7 A/D or \u2190/\u2192 steer \xB7 Space handbrake \xB7 P pulls the handbrake \xB7 I ignition \xB7 M manual/automatic gearbox \xB7 E shifts up, Q down \xB7 G drive 4x2/4x4/auto 4x4 \xB7 L lamps (position, low) \xB7 K high beam \xB7 N fog \xB7 U cabin light \xB7 comma and period indicators \xB7 B hazard \xB7 O wipers \xB7 J seat belt \xB7 H horn \xB7 Y alarm \xB7 R radio \xB7 T radio/tape \xB7 F gets out",
+        on: "on",
+        off: "off",
+        ignition: "Engine",
+        gearbox: "Gearbox",
+        gear: "Gear",
+        parkingBrake: "Handbrake",
+        driveMode: "Drive",
+        modes: { "4x2": "4x2", "4x4": "4x4", auto: "automatic 4x4" },
+        lights: "Lamps",
+        lampModes: { off: "off", position: "position", low: "low beam", high: "high beam" },
+        fog: "Fog lamps",
+        interior: "Cabin light",
+        alarm: "Alarm",
+        alarmStates: { off: "off", armed: "armed", ringing: "ringing" },
+        radio: "Sound",
+        sources: { radio: "radio", tape: "tape" },
+        indicator: "Indicators",
+        indicators: { off: "off", left: "left", right: "right", hazard: "hazard" },
+        wipers: "Wipers",
+        wiperModes: { off: "off", slow: "slow", fast: "fast" },
+        seatbelt: "Seat belt",
+        refused: { no_four_wheel_drive: "This vehicle has no 4x4", no_fog_lamps: "This vehicle has no fog lamps", ignition_off: "Start the engine first" }
+      }
     }
   };
   var fillText = (template, ...values) => template.replace(/\{(\d+)\}/g, (_, i) => String(values[Number(i)] ?? ""));
@@ -48057,6 +48947,10 @@ var GameVehiclesThree = (() => {
     let car = null;
     let run = null;
     let parking = null;
+    let driving = null;
+    let gearbox = "automatic";
+    let lastGear = null;
+    let driveClock = 0;
     let queue = [];
     let open = false;
     let lastWrap = 0;
@@ -48191,13 +49085,13 @@ var GameVehiclesThree = (() => {
       [text.board.test, text.board.value, text.board.range, text.board.verdict].forEach((h, i) => g.fillText(h.toUpperCase(), cols[i], 150));
       let y = 190;
       for (const r of cert.results) {
-        const live = run && run.test.id === r.test && !run.done;
+        const live2 = run && run.test.id === r.test && !run.done;
         g.fillStyle = "#e7e9ec";
         g.font = "26px sans-serif";
         g.fillText(text.tests[r.test] ?? r.test, cols[0], y);
         g.font = "26px monospace";
         g.fillStyle = "#5fd4e0";
-        const value = live ? text.board.running : r.value == null ? r.kind === "measured" && r.note === "not run" ? text.board.notRun : "\u2014" : `${r.value} ${r.unit}`;
+        const value = live2 ? text.board.running : r.value == null ? r.kind === "measured" && r.note === "not run" ? text.board.notRun : "\u2014" : `${r.value} ${r.unit}`;
         g.fillText(value, cols[1], y);
         g.fillStyle = "#8d95a3";
         g.fillText(r.kind === "measured" ? fmtRange(r.range) : r.kind === "visual" ? "visual" : "sala", cols[2], y);
@@ -48205,6 +49099,12 @@ var GameVehiclesThree = (() => {
         g.fillText(r.verdict === "pass" ? "\u2713 " + text.verdict.pass : r.verdict === "fail" ? "\u2717 " + text.verdict.fail : "\u2026", cols[3], y);
         y += 30;
       }
+      const live = run?.driver.state ?? driving?.driver.state;
+      if (live) {
+        g.font = "24px monospace";
+        g.fillStyle = "#f2c230";
+        g.fillText(fillText(text.board.gear, gearName(live.gear), Math.round(live.rpm), Math.round(Math.abs(live.u) * 3.6)), cols[0], y + 16);
+      }
       board.texture.needsUpdate = true;
     };
     const removeCar = () => {
@@ -48276,7 +49176,7 @@ var GameVehiclesThree = (() => {
     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 };
+      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 applyCamera = () => {
       if (!host?.setViewCamera) return;
@@ -48342,12 +49242,111 @@ var GameVehiclesThree = (() => {
       driver.place(40, 0, 0);
       parking = { driver, time: 0 };
     };
+    const stopDriving = () => {
+      if (!driving) return;
+      driving.stop();
+      driving = null;
+      host?.holdPlayer?.(false);
+      host?.bench?.sheet?.(null);
+      stopEngine();
+      host?.log(text.log.leave);
+    };
+    const startDriving = () => {
+      if (!host || !three) return;
+      if (!car || car.subject.id !== settings.vehicle) placeCar();
+      if (!car) return;
+      run = null;
+      queue = [];
+      parking = null;
+      setSurface("dry_asphalt");
+      driving = createCockpit({
+        THREE: three,
+        host,
+        built: car.built,
+        subject: car.subject,
+        place: [0, 0, 0],
+        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);
+          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);
+            else engine?.stop(at);
+          }
+          if (event.command === "gearbox") {
+            gearbox = st.gearbox;
+            host?.bench?.patch("gearbox", { value: st.gearbox });
+          }
+        }
+      });
+      if (gearbox !== driving.controls.state.gearbox) driving.controls.command("gearbox");
+      host.holdPlayer?.(true);
+      if (settings.camera === "room") {
+        settings.camera = "cockpit";
+        host.bench?.patch("camera", { value: "cockpit" });
+        applyCamera();
+      }
+      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.log(fillText(text.log.drive, name(settings.vehicle)));
+    };
+    const onOff = (on) => on ? text.cabin.on : text.cabin.off;
+    const cabinLine = (command, st) => {
+      const c = text.cabin;
+      switch (command) {
+        case "ignition":
+          return `${c.ignition}: ${onOff(st.ignition)}`;
+        case "gearbox":
+          return `${c.gearbox}: ${text.gearbox[st.gearbox]}`;
+        case "gear_up":
+        case "gear_down":
+          return `${c.gear}: ${gearName(st.gear)}`;
+        case "parking_brake":
+          return `${c.parkingBrake}: ${onOff(st.parkingBrake)}`;
+        case "drive_mode":
+          return `${c.driveMode}: ${c.modes[st.driveMode]}`;
+        case "lights":
+        case "high_beam":
+          return `${c.lights}: ${c.lampModes[st.lamps.mode]}`;
+        case "fog_lights":
+          return `${c.fog}: ${onOff(st.lamps.fog)}`;
+        case "interior_light":
+          return `${c.interior}: ${onOff(st.lamps.interior)}`;
+        case "alarm":
+          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 "indicator_left":
+        case "indicator_right":
+        case "hazard":
+          return `${c.indicator}: ${c.indicators[st.indicator]}`;
+        case "wipers":
+          return `${c.wipers}: ${c.wiperModes[st.wipers]}`;
+        case "seatbelt":
+          return `${c.seatbelt}: ${onOff(st.seatbelt)}`;
+        default:
+          return null;
+      }
+    };
+    const gearName = (gear) => gear < 0 ? "R" : gear === 0 ? "N" : String(gear);
     const onChange = (change) => {
       if (change.kind === "layer") {
         if (change.id === "scoreboard" && board) board.mesh.visible = !!host?.bench?.layer("scoreboard");
         return refreshMirrors();
       }
       if (change.kind === "action") {
+        if (change.id === "drive") return driving ? stopDriving() : startDriving();
+        if (change.id === "run_test" || change.id === "run_all" || change.id === "reverse_park") stopDriving();
         if (change.id === "run_test") {
           queue = [];
           startTest(settings.test);
@@ -48378,6 +49377,7 @@ var GameVehiclesThree = (() => {
       switch (change.id) {
         case "vehicle":
           settings.vehicle = String(change.value);
+          stopDriving();
           run = null;
           queue = [];
           parking = null;
@@ -48395,6 +49395,10 @@ var GameVehiclesThree = (() => {
         case "time_scale":
           settings.timeScale = Number(change.value);
           break;
+        case "gearbox":
+          gearbox = change.value === "manual" ? "manual" : "automatic";
+          if (driving && driving.controls.state.gearbox !== gearbox) driving.controls.command("gearbox");
+          break;
         case "visual_check":
           settings.visual = String(change.value);
           break;
@@ -48418,6 +49422,13 @@ var GameVehiclesThree = (() => {
         speed = s.u;
         steer = s.steerAngle;
         if (run.done) finishTest();
+      } else if (driving) {
+        const d = driving;
+        d.step(dt);
+        if (!driving) return;
+        pose(d.driver.state, d.driver.state.steerAngle);
+        speed = d.driver.state.u;
+        steer = d.driver.state.steerAngle;
       } else if (parking) {
         parking.time += dt;
         const p = parking;
@@ -48427,7 +49438,7 @@ var GameVehiclesThree = (() => {
         steer = p.driver.state.steerAngle;
         if (p.time > 9) parking = null;
       }
-      if (car) engine?.update({ dt, position: [car.built.group.position.x, 0.5, car.built.group.position.z], speed, throttle: run ? 1 : 0 });
+      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);
@@ -48437,11 +49448,19 @@ var GameVehiclesThree = (() => {
         mirrorKey = key;
         refreshMirrors();
       }
-      if (run && Math.floor(run.time * 2) !== Math.floor((run.time - dt * settings.timeScale) * 2)) drawBoard();
+      const geared = run?.driver.state ?? driving?.driver.state;
+      if (geared && geared.gear !== lastGear) {
+        if (lastGear !== null && geared.gear > 0) host.log(fillText(text.log.shift, gearName(lastGear), gearName(geared.gear), Math.round(Math.abs(geared.u) * 3.6)), { from: lastGear, to: geared.gear, kmh: +(Math.abs(geared.u) * 3.6).toFixed(1), rpm: Math.round(geared.rpm) }, "proving_shift");
+        lastGear = geared.gear;
+        drawBoard();
+      } else if (!geared) lastGear = null;
+      if (run && Math.floor(run.time * 2) !== Math.floor((run.time - dt * settings.timeScale) * 2) || driving && Math.floor(driveClock * 2) !== Math.floor((driveClock - dt) * 2)) drawBoard();
+      if (driving) driveClock += dt;
     };
-    const speedNow = () => Math.abs(run?.driver.state.u ?? parking?.driver.state.u ?? 0) * 3.6;
+    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 = () => {
+      stopDriving();
       stopEngine();
       for (const m of rig.mirrors) m.remove();
       rig.mirrors = [];
@@ -48473,6 +49492,8 @@ var GameVehiclesThree = (() => {
         { 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: "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 },
+        { 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 },
         { kind: "action", id: "certify_now", name: text.actions.certify_now },
@@ -48488,6 +49509,8 @@ var GameVehiclesThree = (() => {
       ],
       metrics: () => [
         { id: "speed", name: text.metrics.speed, unit: "km/h", digits: 0, read: speedNow },
+        { id: "gear", name: text.metrics.gear, read: () => driving?.driver.state.gear ?? run?.driver.state.gear ?? 0 },
+        { id: "rpm", name: text.metrics.rpm, unit: "rpm", digits: 0, read: () => driving?.driver.state.rpm ?? run?.driver.state.rpm ?? 0 },
         { id: "time", name: text.metrics.time, unit: "s", digits: 1, read: () => run?.time ?? 0 },
         { id: "value", name: text.metrics.value, digits: 1, read: () => run ? run.trace[run.trace.length - 1]?.[1] ?? 0 : 0 },
         { id: "passed", name: text.metrics.passed, read: () => counts("pass") },
@@ -48502,6 +49525,7 @@ var GameVehiclesThree = (() => {
         rig.camera = new three.PerspectiveCamera(60, 1.6, 0.05, 900);
         rig.vehicle = createVehicleCamera(three);
         lent.audio?.register?.(LIBRARY_BANK);
+        lent.audio?.register?.(CABIN_BANK);
         const stopChange = lent.bench?.onChange(onChange);
         const stopFrame = lent.onFrame(frame);
         const stopClear = lent.onClear?.(() => {