@adatechnology/game-vehicles-three 0.6.0 → 0.6.2

package/dist/{chunk-4SUQMRS3.js → chunk-MRUPKE7J.js}

@@ -209,6 +209,16 @@ function primaryPaint(c) {
   });
   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: defaultColorFromSeed, fleetDims: defaultFleetDims, paintPalettes: defaultPaintPalettes, paletteOf: defaultPaletteOf };
@@ -244,6 +254,7 @@ function createVehiclesThree(THREE, options) {
     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";
@@ -265,6 +276,7 @@ function createVehiclesThree(THREE, options) {
       }
       markDamageables(c, damageables);
       group.updateMatrixWorld(true);
+      driverEye = eyeOf(THREE, c);
     } else {
       const fusion = fuse(THREE, c, pivotMatrix, color ? new THREE.Color(color) : null, primary, kit.lodHiddenMaterials());
       for (const mesh of liteMeshes(THREE, fusion, liteMaterials(THREE, kit.studioEnvironment()))) group.add(mesh);
@@ -290,6 +302,7 @@ function createVehiclesThree(THREE, options) {
       pruned,
       expected: fleetDims2(key),
       context: quality === "high" ? c : null,
+      driverEye,
       dispose() {
         group.traverse((m) => {
           if (m.geometry) m.geometry.dispose();
@@ -1803,26 +1816,532 @@ function loadVehiclesTestModule(room, options = {}) {
 // src/test-area/proving/module.ts
 import { createVehicleCamera, mirrorPoses } from "@adatechnology/game-camera";
 import { markKitOrigin as markKitOrigin3 } from "@adatechnology/game-contracts";
-import { LIBRARY_BANK as LIBRARY_BANK2 } from "@adatechnology/game-audio";
-import { createSemiSimDriver as createSemiSimDriver3 } from "@adatechnology/game-vehicles-driving";
-import { certify, createProvingTests, startRun, statusOf, subjectSpec, withResult } from "@adatechnology/game-vehicles-proving";
+import { CABIN_BANK, LIBRARY_BANK as LIBRARY_BANK2 } 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 { subjectSpec } from "@adatechnology/game-vehicles-proving";
+
+// src/dashboard.ts
 import { discardObject3D as discardObject3D2 } from "@adatechnology/game-shapes-three";
+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, built, options) {
+  const maxKmh = options.maxKmh ?? 220;
+  const redline = options.redlineRpm ?? 6500;
+  const doc = options.document ?? (typeof document !== "undefined" ? document : null);
+  const dials = [];
+  built.group.traverse((o) => {
+    if (o.isMesh && o.material === options.gauge) dials.push(o);
+  });
+  const eye = built.driverEye;
+  const hidden = [];
+  const faces = [];
+  if (doc && eye && dials.length) {
+    built.group.updateMatrixWorld(true);
+    const eyeWorld = built.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) => built.group.worldToLocal(b.at.clone()).x - built.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 mesh = new THREE.Mesh(new THREE.CircleGeometry(radius * 1.12, 40), new THREE.MeshBasicMaterial({ map: texture, transparent: true, toneMapped: false, depthWrite: false }));
+      mesh.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);
+      mesh.position.copy(built.group.worldToLocal(front.clone()));
+      built.group.add(mesh);
+      mesh.updateMatrixWorld(true);
+      mesh.lookAt(front.add(axis));
+      d.visible = false;
+      hidden.push(d);
+      if (options.needle)
+        built.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, 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 ring = (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, 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, 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) {
+        discardObject3D2(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
+import { isLightBudget, LIGHT_PRIORITY } from "@adatechnology/game-render-three";
+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, built, options = {}) {
+  const budget = isLightBudget(options.lights) ? options.lights : null;
+  const owner = options.owner ?? "vehicle-lamps";
+  const context = built.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);
+  built.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 = (mesh) => {
+    const mat = mesh.material;
+    if (!mat || Array.isArray(mat)) return null;
+    if (copies.has(mat) || base.has(mat)) return mat;
+    const copy = mat.clone();
+    originals.set(mesh, mat);
+    copies.set(copy, mat);
+    base.set(copy, mat.emissiveIntensity ?? 1);
+    mesh.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 = built.length;
+  const W = built.width;
+  const H = built.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");
+    built.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, make) => {
+    const now = sources.get(id);
+    if (on && !now && budget) sources.set(id, make());
+    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 list of sources.values()) for (const s of list) 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 = createSemiSimDriver3(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 kmh = Math.abs(driver.state.u) * 3.6;
+      if (!s.seatbelt && s.ignition && kmh > 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",
@@ -1844,22 +2363,49 @@ var PROVING_TEXT = {
     },
     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",
@@ -1881,8 +2427,33 @@ var PROVING_TEXT = {
     },
     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)] ?? ""));
@@ -1916,6 +2487,10 @@ function createProvingModule(options) {
   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;
@@ -2050,13 +2625,13 @@ function createProvingModule(options) {
     [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);
@@ -2064,11 +2639,17 @@ function createProvingModule(options) {
       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 = () => {
     if (!car) return;
-    discardObject3D2(car.built.group);
+    discardObject3D3(car.built.group);
     car = null;
   };
   const placeCar = () => {
@@ -2135,7 +2716,7 @@ function createProvingModule(options) {
   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;
@@ -2197,16 +2778,115 @@ function createProvingModule(options) {
     run = null;
     queue = [];
     setSurface("dry_asphalt");
-    const driver = createSemiSimDriver3(subjectSpec(car.subject));
+    const driver = createSemiSimDriver4(subjectSpec2(car.subject));
     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);
@@ -2237,6 +2917,7 @@ function createProvingModule(options) {
     switch (change.id) {
       case "vehicle":
         settings.vehicle = String(change.value);
+        stopDriving();
         run = null;
         queue = [];
         parking = null;
@@ -2254,6 +2935,10 @@ function createProvingModule(options) {
       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;
@@ -2277,6 +2962,13 @@ function createProvingModule(options) {
       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;
@@ -2286,7 +2978,7 @@ function createProvingModule(options) {
       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);
@@ -2296,17 +2988,25 @@ function createProvingModule(options) {
       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 = [];
     removeCar();
     mirrorKey = "";
-    if (track) discardObject3D2(track);
+    if (track) discardObject3D3(track);
     track = null;
     strip = null;
     board = null;
@@ -2332,6 +3032,8 @@ function createProvingModule(options) {
       { 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 },
@@ -2347,6 +3049,8 @@ function createProvingModule(options) {
     ],
     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") },
@@ -2361,6 +3065,7 @@ function createProvingModule(options) {
       rig.camera = new three.PerspectiveCamera(60, 1.6, 0.05, 900);
       rig.vehicle = createVehicleCamera(three);
       lent.audio?.register?.(LIBRARY_BANK2);
+      lent.audio?.register?.(CABIN_BANK);
       const stopChange = lent.bench?.onChange(onChange);
       const stopFrame = lent.onFrame(frame);
       const stopClear = lent.onClear?.(() => {
@@ -2421,9 +3126,13 @@ export {
   DEFAULT_TEST_VEHICLES,
   createVehiclesTestModule,
   loadVehiclesTestModule,
+  DASHBOARD_LOOK,
+  createVehicleDashboard,
+  LAMP_RULES,
+  createVehicleLamps,
   PROVING_TEXT,
   PROVING_AREA_ID,
   createProvingModule,
   loadProvingModule
 };
-//# sourceMappingURL=chunk-4SUQMRS3.js.map
+//# sourceMappingURL=chunk-MRUPKE7J.js.map