@adatechnology/game-vehicles-three 0.5.0 → 0.6.0

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

@@ -1,7 +1,7 @@
 // src/test-area/module.ts
 import { DEFERRED_PRIORITY, DEFERRED_QUEUE_ID, footprintBlocker } from "@adatechnology/game-contracts";
 import { discardObject3D } from "@adatechnology/game-shapes-three";
-import { buildVehicleItem, crackedGlassMaterial, createCreaseQueue, createVehicleDestructible, createVehicleKit } from "@adatechnology/game-vehicles";
+import { buildVehicleItem, crackedGlassMaterial, createCreaseQueue, createVehicleDestructible as createVehicleDestructible2, createVehicleKit } from "@adatechnology/game-vehicles";
 import { isRenderPools } from "@adatechnology/game-render-three";
 import { createArcadeDriver as createArcadeDriver2, createSemiSimDriver as createSemiSimDriver2, createSurfaces as createSurfaces2, vehicleCorners as vehicleCorners2 } from "@adatechnology/game-vehicles-driving";
 import { colorFromSeed, fleetDims, installFleet, paintPalettes, paletteOf } from "@adatechnology/game-vehicles-fleet";
@@ -253,6 +253,7 @@ function createVehiclesThree(THREE, options) {
       c.vehicle.matrixAutoUpdate = true;
       pivot.add(c.vehicle);
       group.add(pivot);
+      c.root = group;
       if (color && primary) {
         const repainted = primary.clone();
         repainted.color.set(color);
@@ -317,12 +318,15 @@ import { markKitOrigin as markKitOrigin2 } from "@adatechnology/game-contracts";
 import { createStaticBatcher } from "@adatechnology/game-render-three";
 var VEHICLE_LOD_DISTANCE = 14;
 var BATCH_BUDGET_MS = 2;
+var VEHICLE_REBATCH_AFTER_MS = 1500;
 var isShown = (object, top) => {
   for (let node = object; node && node !== top; node = node.parent) if (node.visible === false) return false;
   return true;
 };
-function createVehicleLod(kit, context, root, full) {
+function createVehicleLod(kit, context, root, full, options = {}) {
   const THREE = kit.THREE;
+  const now = options.now ?? (() => performance.now());
+  let changedAt = Number.NEGATIVE_INFINITY;
   let isUploaded = false;
   let modelKey = "";
   const culled = /* @__PURE__ */ new Map();
@@ -382,8 +386,17 @@ function createVehicleLod(kit, context, root, full) {
     root.add(proxy);
     return proxy;
   };
+  const batchLocked = () => {
+    batcher = createStaticBatcher(THREE, full, { budgetMs: BATCH_BUDGET_MS });
+    batcher.group.traverse((object) => object.userData.skipLite = true);
+    batcher.group.userData.noSurfaceRay = true;
+    markKitOrigin2(batcher.group, { owner: "game-vehicles-three", kind: "vehicle", id: root.name });
+  };
   const drawFull = () => {
-    if (!batcher && isLocked) return;
+    if (!batcher && isLocked) {
+      if (now() - changedAt >= VEHICLE_REBATCH_AFTER_MS) batchLocked();
+      return;
+    }
     if (!batcher) {
       lite ?? (lite = build());
       lite.visible = isFused;
@@ -396,11 +409,13 @@ function createVehicleLod(kit, context, root, full) {
       });
       batcher = createStaticBatcher(THREE, full, { budgetMs: BATCH_BUDGET_MS });
       batcher.group.traverse((object) => object.userData.skipLite = true);
+      batcher.group.userData.noSurfaceRay = true;
       markKitOrigin2(batcher.group, { owner: "game-vehicles-three", kind: "vehicle", id: root.name });
       return;
     }
-    batcher.update();
-    if (!isLocked && batcher.stats().batched === 0 && batcher.stats().released > 0) {
+    if (!batcher) return;
+    if (batcher.update() > 0) changedAt = now();
+    if (batcher.stats().batched === 0 && batcher.stats().released > 0) {
       batcher.dispose();
       batcher = null;
     }
@@ -441,8 +456,10 @@ function createVehicleLod(kit, context, root, full) {
   };
   const api = {
     update(distance, touched, posed = false) {
+      if (touched && !isLocked) changedAt = now();
       isLocked || (isLocked = touched);
       if (keyOf() !== modelKey) {
+        changedAt = now();
         api.dispose();
         armUpload();
       }
@@ -513,6 +530,50 @@ function createCabinSmoke() {
   };
 }
 
+// src/test-area/lane-damage.ts
+import { crashVehicle, createVehicleDestructible } from "@adatechnology/game-vehicles";
+import { conditionFromDamage } from "@adatechnology/game-vehicles-driving";
+var LANE_DAMAGE = ["none", "into_wall", "flat_tyre", "torn_tyre", "run_flat", "no_brake_fluid"];
+var RIFLE = { energy: 3500, caliber: 7.8, penetration: { steel: 18 } };
+var TEAR_OFF_M = 5e3;
+var LANE_CAR_KG = 1150;
+var LANE_WALL_CONTACT = 1.6;
+var WALL_REACH = 0.15;
+var DRAIN_S = 600;
+function createLaneDamage(params) {
+  const d = createVehicleDestructible(params.kit, params.context, { id: "lane", frame: params.frame, armour: params.damage === "run_flat" ? "IIIA" : null });
+  const part = (prefix) => d.describe().parts.find((p) => p.id.startsWith(prefix))?.id;
+  const shoot = (id) => {
+    if (id) d.hit({ type: "ballistic", point: d.partWorldCenter(id), part: id, direction: [0, 0, 1], ...RIFLE });
+  };
+  if (params.damage === "into_wall") {
+  } else if (params.damage === "no_brake_fluid") {
+    shoot(part("brakes"));
+    for (let t = 0; t < DRAIN_S; t++) d.update?.(1);
+  } else {
+    shoot(part("tyre_front_left"));
+    if (params.damage === "torn_tyre") d.rollFlat(TEAR_OFF_M, 8);
+  }
+  return {
+    step({ dt, speed, throttle, driver }) {
+      d.rollFlat(speed * dt, speed);
+      d.runEngine(dt, throttle);
+      const events = d.update?.(dt) ?? [];
+      driver.condition = conditionFromDamage(driver.spec, d.driveReport());
+      return events.flatMap((e) => e.type === "debris" && e.kind === "sparks" ? [e.point] : []);
+    },
+    settle(dt) {
+      d.update?.(dt);
+    },
+    crash({ speed, direction }) {
+      const front = part("bumper_front");
+      if (!front) return [];
+      const at = d.partWorldCenter(front);
+      return crashVehicle(d, { point: [at[0] + direction[0] * WALL_REACH, at[1], at[2] + direction[2] * WALL_REACH], direction, speed, massKg: LANE_CAR_KG, otherMassKg: Infinity, contactWidth: LANE_WALL_CONTACT }).events;
+    }
+  };
+}
+
 // src/test-area/scenarios.ts
 import { createArcadeDriver, createSemiSimDriver, createSurfaces, vehicleCorners } from "@adatechnology/game-vehicles-driving";
 
@@ -562,25 +623,27 @@ var TEXT = {
     group: "Vehicles",
     name: "Vehicles area",
     items: { hatch: "Compact hatch", sedan: "Midsize sedan", pickup: "Midsize pickup", sport_bike: "Sport bike", box_truck: "Box truck", city_bus: "City bus", battle_tank: "Battle tank", attack_helicopter: "Attack helicopter", sedan_burnt: "Burnt sedan", hatch_burnt: "Burnt hatch" },
-    controls: { quality: "Quality", paint_by_seed: "Paint by seed", color_seed: "Colour seed", palette: "Palette", driving: "Driving", surface: "Surface" },
+    controls: { quality: "Quality", paint_by_seed: "Paint by seed", color_seed: "Colour seed", palette: "Palette", driving: "Driving", surface: "Surface", lane_damage: "Lane damage" },
     hints: {
       quality: "High: the kit at full detail. Light: fewer segments and no interior (the light mode of the fleet); applies to the vehicles placed from now on",
       paint_by_seed: "Off: every vehicle keeps its own paint. On: the body colour comes from the seed and the palette",
       palette: "Auto: the palette of the vehicle group (civil, or military for the army vehicles)",
       driving: "Arcade: the game car, simple and forgiving. Semi: a rigid body with springs, tyre friction, gears and surfaces",
-      surface: "The ground under the wheels in the semi mode (grip and aquaplaning)"
+      surface: "The ground under the wheels in the semi mode (grip and aquaplaning)",
+      lane_damage: "What the lane car starts with; it drives in the semi mode and the damage model sets its tyres, brakes and engine"
     },
     options: {
       quality: { high: "High", lite: "Light" },
       palette: { auto: "Auto", civil: "Civil", military: "Military" },
       driving: { arcade: "Arcade", semi: "Semi-simulation" },
-      surface: { dry_asphalt: "Dry asphalt", wet_asphalt: "Wet asphalt", dirt: "Dirt", grass: "Grass", mud: "Mud", blood: "Blood" }
+      surface: { dry_asphalt: "Dry asphalt", wet_asphalt: "Wet asphalt", dirt: "Dirt", grass: "Grass", mud: "Mud", blood: "Blood" },
+      lane_damage: { none: "None", into_wall: "Into the wall, no braking", flat_tyre: "Flat tyre (rifle round)", torn_tyre: "Tyre torn off: rim on the road", run_flat: "Armoured, flat tyre (run-flat)", no_brake_fluid: "No brake fluid" }
     },
     actions: { repaint: "Repaint with the seed", drive_lane: "Drive the lane", clear_lane: "Remove the lane car", honk: "Honk the horn" },
     layers: { damageables: "Damageable boxes by material", zones: "Zone boxes by type", axes: "Output frame axes" },
     metrics: { vehicles: "Vehicles", triangles: "Triangles", draw_calls: "Draw calls", size_error_mm: "Size against DIMS", metal: "Metal boxes", glass: "Glass boxes", rubber: "Rubber boxes", fuel: "Fuel boxes", speed: "Lane speed", lane: "Lane distance" },
     words: { yes: "true", no: "false", open: "open", tight: "tight", on: "on", off: "off" },
-    lane: { crash: "Lane: the car hit the wall at {0} m/s", end: "Lane: the car stopped {0} m from the wall" },
+    lane: { crash: "Lane: the car hit the wall at {0} m/s", end: "Lane: the car stopped {0} m from the wall", damage: "Lane: the crash dented {0} and broke {1}" },
     scenarios: {
       vehicles_9mm_windshield: "Vehicles: 9 mm through the windshield",
       vehicles_shotgun_door: "Vehicles: shotgun on the door",
@@ -629,25 +692,27 @@ var TEXT = {
     group: "Ve\xEDculos",
     name: "\xC1rea de ve\xEDculos",
     items: { hatch: "Hatch compacto", sedan: "Sed\xE3 m\xE9dio", pickup: "Picape m\xE9dia", sport_bike: "Moto esportiva", box_truck: "Caminh\xE3o ba\xFA", city_bus: "\xD4nibus urbano", battle_tank: "Tanque de guerra", attack_helicopter: "Helic\xF3ptero de ataque", sedan_burnt: "Sed\xE3 queimado", hatch_burnt: "Hatch queimado" },
-    controls: { quality: "Qualidade", paint_by_seed: "Pintar pela semente", color_seed: "Semente da cor", palette: "Paleta", driving: "Dire\xE7\xE3o", surface: "Piso" },
+    controls: { quality: "Qualidade", paint_by_seed: "Pintar pela semente", color_seed: "Semente da cor", palette: "Paleta", driving: "Dire\xE7\xE3o", surface: "Piso", lane_damage: "Dano na pista" },
     hints: {
       quality: "Alta: o kit com todo o detalhe. Leve: menos segmentos e sem interior (o modo leve da frota); vale para os ve\xEDculos postos daqui em diante",
       paint_by_seed: "Desligado: cada ve\xEDculo mant\xE9m a pr\xF3pria pintura. Ligado: a cor da carroceria vem da semente e da paleta",
       palette: "Auto: a paleta do grupo do ve\xEDculo (civil, ou militar para os do ex\xE9rcito)",
       driving: "Arcade: o carro do jogo, simples e tolerante. Semi: corpo r\xEDgido com molas, atrito do pneu, marchas e pisos",
-      surface: "O ch\xE3o sob as rodas no modo semi (ader\xEAncia e aquaplanagem)"
+      surface: "O ch\xE3o sob as rodas no modo semi (ader\xEAncia e aquaplanagem)",
+      lane_damage: "Com o que o carro da pista sai; ele anda no modo semi e o modelo de dano define pneus, freio e motor"
     },
     options: {
       quality: { high: "Alta", lite: "Leve" },
       palette: { auto: "Auto", civil: "Civil", military: "Militar" },
       driving: { arcade: "Arcade", semi: "Semissimula\xE7\xE3o" },
-      surface: { dry_asphalt: "Asfalto seco", wet_asphalt: "Asfalto molhado", dirt: "Terra", grass: "Grama", mud: "Lama", blood: "Sangue" }
+      surface: { dry_asphalt: "Asfalto seco", wet_asphalt: "Asfalto molhado", dirt: "Terra", grass: "Grama", mud: "Lama", blood: "Sangue" },
+      lane_damage: { none: "Nenhum", into_wall: "Contra o muro, sem frear", flat_tyre: "Pneu furado (tiro de fuzil)", torn_tyre: "Pneu desfeito: aro no ch\xE3o", run_flat: "Blindado, pneu furado (run-flat)", no_brake_fluid: "Sem fluido de freio" }
     },
     actions: { repaint: "Repintar com a semente", drive_lane: "Percorrer a pista", clear_lane: "Tirar o carro da pista", honk: "Buzinar" },
     layers: { damageables: "Caixas danific\xE1veis por material", zones: "Caixas das zonas por tipo", axes: "Eixos do quadro de sa\xEDda" },
     metrics: { vehicles: "Ve\xEDculos", triangles: "Tri\xE2ngulos", draw_calls: "Chamadas de desenho", size_error_mm: "Medida contra DIMS", metal: "Caixas de metal", glass: "Caixas de vidro", rubber: "Caixas de borracha", fuel: "Caixas de combust\xEDvel", speed: "Velocidade na pista", lane: "Dist\xE2ncia na pista" },
     words: { yes: "sim", no: "n\xE3o", open: "soltos", tight: "presos", on: "acesos", off: "apagados" },
-    lane: { crash: "Pista: o carro bateu no muro a {0} m/s", end: "Pista: o carro parou a {0} m do muro" },
+    lane: { crash: "Pista: o carro bateu no muro a {0} m/s", end: "Pista: o carro parou a {0} m do muro", damage: "Pista: a batida amassou {0} e quebrou {1}" },
     scenarios: {
       vehicles_9mm_windshield: "Ve\xEDculos: 9 mm atravessa o para-brisa",
       vehicles_shotgun_door: "Ve\xEDculos: espingarda na porta",
@@ -910,6 +975,57 @@ var createScenarios = (deps) => {
 // src/test-area/module.ts
 import { LIBRARY_BANK } from "@adatechnology/game-audio";
 
+// src/audio/profiles.ts
+var DEFAULT_VEHICLE_SOUND_KEYS = {
+  start: "engine_start",
+  stop: "engine_stop",
+  fail: "engine_fail",
+  crashLight: "crash_light",
+  crashMedium: "crash_medium",
+  crashHeavy: "crash_heavy",
+  skidAsphalt: "tire_skid_asphalt",
+  skidDirt: "tire_skid_dirt",
+  roll: "tire_roll"
+};
+var CRASH_SPEEDS = { medium: 6, heavy: 14 };
+var layers = (id, cutoffs, gains) => [
+  { sound: `engine_${id}_low`, centre: 0, width: 0.5, harmonic: 1, gain: gains[0], cutoff: cutoffs[0] },
+  { sound: `engine_${id}_mid`, centre: 0.45, width: 0.5, harmonic: 1, gain: gains[1], cutoff: cutoffs[1] },
+  { sound: `engine_${id}_high`, centre: 1, width: 0.6, harmonic: 2, gain: gains[2], cutoff: cutoffs[2] }
+];
+var CAR_ENGINE = {
+  id: "car",
+  cylinders: 4,
+  idleRpm: 800,
+  redlineRpm: 6500,
+  // a 5-speed hatch: 1st tops at ~13 m/s, 5th at ~50 m/s
+  rpmPerMps: [500, 300, 205, 155, 125],
+  layers: layers("car", [[220, 520], [420, 1300], [900, 2600]], [0.11, 0.075, 0.04]),
+  load: { sound: "engine_car_load", gain: 0.05, cutoff: [350, 1600] },
+  closedThrottle: 0.55
+};
+var TRUCK_ENGINE = {
+  id: "truck",
+  cylinders: 6,
+  idleRpm: 650,
+  redlineRpm: 2600,
+  rpmPerMps: [420, 260, 170, 120, 90, 72],
+  layers: layers("truck", [[160, 380], [300, 800], [600, 1500]], [0.13, 0.08, 0.035]),
+  load: { sound: "engine_truck_load", gain: 0.06, cutoff: [250, 900] },
+  closedThrottle: 0.6
+};
+var BIKE_ENGINE = {
+  id: "bike",
+  cylinders: 4,
+  idleRpm: 1300,
+  redlineRpm: 12e3,
+  rpmPerMps: [900, 640, 500, 410, 350, 310],
+  layers: layers("bike", [[350, 900], [700, 2200], [1500, 4200]], [0.08, 0.07, 0.05]),
+  load: { sound: "engine_bike_load", gain: 0.045, cutoff: [600, 2600] },
+  closedThrottle: 0.5
+};
+var ENGINE_PROFILES = { car: CAR_ENGINE, truck: TRUCK_ENGINE, bike: BIKE_ENGINE };
+
 // src/test-area/types.ts
 var defaultEffectIds = {
   ignite: "vehicle_fire",
@@ -920,20 +1036,240 @@ var defaultEffectIds = {
   leakIgnited: "vehicle_leak_ignited",
   exhaust: "vehicle_exhaust"
 };
-var defaultSoundIds = { engine: "engine_saw", horn: "horn", crash: "sfx_impact" };
+var defaultSoundIds = { horn: "horn_car", ...DEFAULT_VEHICLE_SOUND_KEYS };
 var DEFAULT_TEST_WRECKS = [
   { key: "sedan_burnt", vehicle: "midsize_sedan", scenario: "burnt" },
   { key: "hatch_burnt", vehicle: "compact_hatch", scenario: "burnt" }
 ];
 
+// src/audio/engine-mix.ts
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+var firingHz = (profile, rpm) => rpm / 60 * (profile.cylinders / 2);
+var rpmShare = (profile, rpm) => clamp01((rpm - profile.idleRpm) / (profile.redlineRpm - profile.idleRpm));
+var layerWeight = (centre, width, n) => {
+  const d = Math.abs(n - centre) / width;
+  return d >= 1 ? 0 : Math.cos(d * Math.PI / 2);
+};
+function engineMix(profile, input) {
+  const throttle = clamp01(input.throttle);
+  const on = input.rpm > 0;
+  const n = rpmShare(profile, input.rpm);
+  const level = on ? profile.closedThrottle + (1 - profile.closedThrottle) * throttle : 0;
+  const open = 0.5 * n + 0.5 * throttle;
+  const hz = firingHz(profile, input.rpm);
+  const tones = profile.layers.map((layer) => ({
+    sound: layer.sound,
+    volume: layer.gain * level * layerWeight(layer.centre, layer.width, n),
+    frequency: hz * layer.harmonic,
+    cutoff: layer.cutoff[0] + (layer.cutoff[1] - layer.cutoff[0]) * open
+  }));
+  const load = profile.load;
+  return [
+    ...tones,
+    { sound: load.sound, volume: on ? load.gain * (0.15 + 0.85 * throttle) * (0.35 + 0.65 * n) : 0, cutoff: load.cutoff[0] + (load.cutoff[1] - load.cutoff[0]) * open }
+  ];
+}
+function createGearGuess(profile) {
+  let gear = 0;
+  return {
+    rpm(speed, throttle) {
+      const v = Math.abs(speed);
+      const ratios = profile.rpmPerMps;
+      if (v < 0.3) {
+        gear = 0;
+        return profile.idleRpm + (profile.redlineRpm - profile.idleRpm) * 0.12 * clamp01(throttle);
+      }
+      const at = (g) => v * ratios[g];
+      while (gear < ratios.length - 1 && at(gear) > profile.redlineRpm * 0.85) gear++;
+      while (gear > 0 && at(gear) < profile.redlineRpm * 0.4) gear--;
+      return Math.max(profile.idleRpm, Math.min(profile.redlineRpm, at(gear)));
+    },
+    get gear() {
+      return gear;
+    }
+  };
+}
+
+// src/audio/vehicle-sound.ts
+var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function createVehicleSound(audio, options = {}) {
+  const profile = options.profile ?? CAR_ENGINE;
+  const keys = { ...DEFAULT_VEHICLE_SOUND_KEYS, ...options.sounds };
+  const crankSeconds = options.crankSeconds ?? 0.75;
+  const gears = createGearGuess(profile);
+  const loops = /* @__PURE__ */ new Map();
+  const levels = {};
+  const state = { running: false, cranking: 0, catches: false, flare: 0, rpm: 0 };
+  const loopOf = (sound) => {
+    let handle = loops.get(sound);
+    if (!handle && audio?.loop) {
+      handle = audio.loop(sound);
+      loops.set(sound, handle);
+    }
+    return handle;
+  };
+  const setLoop = (sound, volume, position, extra = {}) => {
+    levels[sound] = volume;
+    if (volume <= 0 && !loops.has(sound)) return;
+    loopOf(sound)?.set({ volume, position, ...extra.frequency === void 0 ? {} : { frequency: extra.frequency }, ...extra.cutoff === void 0 ? {} : { params: { cutoff: extra.cutoff } } });
+  };
+  const play = (sound, position, volume = 1) => void audio?.play({ sound, position, volume });
+  return {
+    start(position, startOptions = {}) {
+      if (state.running || state.cranking > 0) return;
+      state.catches = !startOptions.fail;
+      state.cranking = state.catches ? crankSeconds : 1.7;
+      play(state.catches ? keys.start : keys.fail, position);
+    },
+    stop(position) {
+      if (!state.running && state.cranking <= 0) return;
+      state.running = false;
+      state.cranking = 0;
+      play(keys.stop, position);
+    },
+    crash(speed, position) {
+      const v = Math.abs(speed);
+      const kind = v >= CRASH_SPEEDS.heavy ? "heavy" : v >= CRASH_SPEEDS.medium ? "medium" : "light";
+      play(kind === "heavy" ? keys.crashHeavy : kind === "medium" ? keys.crashMedium : keys.crashLight, position, Math.min(1, 0.35 + v / 20));
+      return kind;
+    },
+    update(frame) {
+      if (state.cranking > 0) {
+        state.cranking -= frame.dt;
+        if (state.cranking <= 0 && state.catches) {
+          state.running = true;
+          state.flare = 1;
+        }
+      }
+      state.flare = Math.max(0, state.flare - frame.dt / 0.9);
+      const throttle = clamp012(frame.throttle);
+      const driven = frame.rpm ?? gears.rpm(frame.speed, throttle);
+      const rpm = state.running ? Math.max(driven, profile.idleRpm * (1 + 1.2 * state.flare * state.flare)) : 0;
+      state.rpm = rpm;
+      for (const layer of engineMix(profile, { rpm, throttle: Math.max(throttle, state.flare * 0.6) })) {
+        setLoop(layer.sound, layer.volume, frame.position, { ...layer.frequency === void 0 ? {} : { frequency: layer.frequency }, cutoff: layer.cutoff });
+      }
+      const speed = Math.abs(frame.speed);
+      const slide = clamp012(((frame.slip ?? 0) - 0.15) / 0.5) * clamp012(speed / 4);
+      const dirt = frame.surface === "dirt";
+      setLoop(keys.skidAsphalt, dirt ? 0 : 0.16 * slide, frame.position, { cutoff: 1700 + 600 * slide });
+      setLoop(keys.skidDirt, dirt ? 0.2 * slide : 0, frame.position, { cutoff: 500 + 500 * slide });
+      setLoop(keys.roll, 0.06 * clamp012(speed / 25), frame.position, { cutoff: 250 + 45 * Math.min(speed, 40) });
+    },
+    get reading() {
+      return { running: state.running, rpm: state.rpm, levels: { ...levels } };
+    },
+    dispose() {
+      for (const handle of loops.values()) handle.stop();
+      loops.clear();
+    }
+  };
+}
+
+// src/audio/bank.ts
+import { sceneMany as many, sceneNoise as noise, sceneRecipe, sceneTone as tone } from "@adatechnology/game-audio";
+var VEHICLE_LOOP_FALLOFF = { model: "inverse_square", k: 4e-3, cutoffK: 0.01 };
+var SDK = "sdk: vehicle sounds (sons/checklist-sons.md 5.6)";
+var SMOOTHING = { volume: 0.06, frequency: 0.04 };
+var toneLoop = (id, wave, filter, cutoff, q, line) => ({
+  id,
+  bus: "world",
+  order: "game_loop",
+  source: { kind: "osc", wave, loop: true },
+  filters: { mode: "serial", bank: [{ type: filter, frequency: { set: cutoff }, q }] },
+  smoothing: SMOOTHING,
+  falloff: VEHICLE_LOOP_FALLOFF,
+  pan: true,
+  sources: [SDK, line]
+});
+var noiseLoop = (id, filter, cutoff, q, line) => ({
+  id,
+  bus: "world",
+  order: "game_loop",
+  source: { kind: "noise", offset: "random", loop: true },
+  filters: { mode: "serial", bank: [{ type: filter, frequency: { set: cutoff }, q }] },
+  smoothing: SMOOTHING,
+  falloff: VEHICLE_LOOP_FALLOFF,
+  pan: true,
+  sources: [SDK, line]
+});
+var engineLoops = (id, low, mid, high, load) => [
+  toneLoop(`engine_${id}_low`, "sawtooth", "lowpass", low, 1.4, "idle and low RPM: the firing frequency, a saw through a low-pass"),
+  toneLoop(`engine_${id}_mid`, "square", "lowpass", mid, 0.9, "mid RPM: odd harmonics, the bark"),
+  toneLoop(`engine_${id}_high`, "sawtooth", "bandpass", high, 1.2, "high RPM: the second harmonic through a band-pass, the scream near the redline"),
+  noiseLoop(`engine_${id}_load`, "bandpass", load, 0.8, "intake and exhaust roar, opened by the throttle")
+];
+var VEHICLE_LOOPS = [
+  ...engineLoops("car", 400, 900, 1600, 700),
+  ...engineLoops("truck", 280, 600, 1e3, 500),
+  ...engineLoops("bike", 600, 1400, 2800, 1200),
+  noiseLoop("tire_skid_asphalt", "bandpass", 1900, 5, "rubber squealing on asphalt: a narrow band of noise near 2 kHz"),
+  noiseLoop("tire_skid_dirt", "lowpass", 700, 0.8, "tyres sliding on dirt and gravel: a dull, wide hiss"),
+  noiseLoop("tire_roll", "lowpass", 400, 0.7, "road noise of the tyres rolling, brighter with the speed")
+];
+var recipe = (id, layers2, line) => ({ ...sceneRecipe(id, layers2, line), sources: [SDK, line] });
+var crank = (count2, spacing) => [
+  { ...noise({ type: "bandpass", f: [300, 380], q: 1.5, d: 0.07, vol: 0.45 }), repeat: { count: count2, spacing } },
+  tone({ wave: "sawtooth", f: 95, f2: count2 > 8 ? 70 : 110, d: count2 * spacing, vol: 0.035 })
+];
+var latch = (delay, vol) => [
+  noise({ type: "bandpass", f: [2600, 3200], q: 3, d: 0.018, vol, delay }),
+  tone({ f: 1300, f2: 1180, d: 0.025, vol: vol * 0.15, delay: delay + 4e-3 })
+];
+var VEHICLE_SOUNDS = [
+  // the engine catches at 0.75 s: the loops take over from there (the vehicle flares the RPM)
+  recipe("engine_start", [...crank(7, 0.105), tone({ wave: "sawtooth", f: 45, f2: 27, d: 0.35, vol: 0.3, delay: 0.72 }), noise({ f: 260, d: 0.3, vol: 0.35, delay: 0.72 })], "starter cranking, then the engine catches"),
+  recipe("engine_fail", [...crank(13, 0.125), ...latch(1.65, 0.2)], "starter cranking slower and slower, the engine never catches, the key released"),
+  recipe("engine_stop", [tone({ wave: "sawtooth", f: 27, f2: 8, d: 0.45, vol: 0.3 }), noise({ f: 200, f2: 60, d: 0.4, vol: 0.32 }), noise({ type: "bandpass", f: 120, q: 2, d: 0.12, vol: 0.3, delay: 0.32 })], "ignition off: the engine runs down and shudders to a stop"),
+  // light: a dent and plastic giving; medium: the body folding and a pane cracking; heavy: metal folding, glass going, debris falling
+  recipe(
+    "crash_light",
+    [tone({ f: 110, f2: 55, d: 0.16, vol: 0.7 }), noise({ type: "bandpass", f: 1100, q: 1, d: 0.18, vol: 0.85, wet: 0.2 }), noise({ type: "highpass", f: 2500, d: 0.05, vol: 0.45 }), ...many(3, () => noise({ type: "bandpass", f: [1800, 3200], q: 3, d: 0.03, vol: 0.2, delay: [0.03, 0.2] }))],
+    "crash below 22 km/h: bumper and plastic, a dull dent"
+  ),
+  recipe(
+    "crash_medium",
+    [
+      tone({ f: 85, f2: 38, d: 0.3, vol: 1.1 }),
+      noise({ type: "bandpass", f: 700, q: 0.9, d: 0.5, vol: 0.8, wet: 0.3 }),
+      ...many(5, () => noise({ type: "bandpass", f: [500, 1300], q: 2, d: [0.08, 0.18], vol: 0.55, delay: [0, 0.35] })),
+      ...many(6, () => tone({ f: [3500, 7e3], d: 0.06, vol: 0.08, delay: [0.05, 0.5] }))
+    ],
+    "crash at 22\u201350 km/h: the body folding, a pane cracking"
+  ),
+  recipe(
+    "crash_heavy",
+    [
+      tone({ f: 65, f2: 28, d: 0.6, vol: 1.5 }),
+      noise({ f: 900, f2: 150, d: 0.9, vol: 1.3, wet: 0.5 }),
+      ...many(9, () => noise({ type: "bandpass", f: [300, 1200], q: 2, d: [0.1, 0.25], vol: 0.6, delay: [0, 0.7] })),
+      noise({ type: "highpass", f: 3200, d: 0.5, vol: 0.7, delay: 0.03, wet: 0.4 }),
+      ...many(14, () => tone({ f: [3e3, 7500], d: [0.05, 0.12], vol: 0.12, delay: [0.05, 1.2] })),
+      ...many(6, () => noise({ type: "bandpass", f: [1500, 3e3], q: 2, d: 0.04, vol: 0.25, delay: [0.5, 1.5] }))
+    ],
+    "crash above 50 km/h: metal folding, the glass going, debris falling"
+  ),
+  // the game's horn (two squares at 415 and 523 Hz, jogo L70272) heard from where the car is; a truck's air horn lower and longer
+  recipe("horn_car", [tone({ wave: "square", f: 415, d: 0.6, vol: 0.09 }), tone({ wave: "square", f: 523, d: 0.6, vol: 0.09 })], "car horn: the game chord, placed and panned"),
+  recipe("horn_truck", [tone({ wave: "sawtooth", f: 220, d: 1.1, vol: 0.1 }), tone({ wave: "sawtooth", f: 277, d: 1.1, vol: 0.08 }), noise({ type: "bandpass", f: 900, q: 2, d: 1.1, vol: 0.05 })], "truck air horn: low reedy chord"),
+  // a car door is a padded "tum" with a latch, not a hollow metal box (the fridge's shut_metal)
+  recipe("car_door_open", [...latch(0, 0.32), noise({ f: 400, d: 0.06, vol: 0.14, delay: 0.035 })], "car door: the handle pulled, the latch released, the seal letting go"),
+  recipe("car_door_close", [tone({ f: 75, f2: 48, d: 0.16, vol: 0.75 }), noise({ f: 320, d: 0.1, vol: 0.6 }), ...latch(0.012, 0.3)], "car door shut: a dull padded thump and the latch catching"),
+  recipe("car_trunk_close", [tone({ f: 90, f2: 55, d: 0.15, vol: 0.65 }), noise({ type: "bandpass", f: 500, q: 1, d: 0.12, vol: 0.5 }), ...latch(0.01, 0.28), noise({ type: "bandpass", f: 1800, q: 3, d: 0.04, vol: 0.1, delay: 0.06 })], "trunk or hatch shut: a lighter thump, the latch and a small rattle"),
+  recipe("car_hood_close", [tone({ f: 70, f2: 40, d: 0.22, vol: 0.8 }), noise({ type: "bandpass", f: 850, q: 1.4, d: 0.2, vol: 0.6, wet: 0.3 }), tone({ f: 900, f2: 860, d: 0.18, vol: 0.05 }), ...latch(0.015, 0.3)], "hood slammed: a big sheet of metal ringing a little, the latch")
+];
+var VEHICLE_SOUND_BANK = { id: "vehicles_three", sounds: VEHICLE_SOUNDS, loops: VEHICLE_LOOPS };
+
 // src/test-area/module.ts
 var VEHICLES_AREA_ID = "vehicles_area";
 var DEFAULT_TEST_VEHICLES = ["compact_hatch", "midsize_sedan", "midsize_pickup", "sport_bike", "box_truck", "city_bus", "battle_tank", "attack_helicopter"];
 var ITEM_OF = { compact_hatch: "hatch", midsize_sedan: "sedan", midsize_pickup: "pickup", sport_bike: "sport_bike", box_truck: "box_truck", city_bus: "city_bus", battle_tank: "battle_tank", attack_helicopter: "attack_helicopter" };
 var itemId = (key) => ITEM_OF[key] ?? key;
 var LANE = { z: 11, from: -12, wall: 13 };
+var SPARK_EVERY_S = 0.08;
 var LEAF_REST_RADIANS = 0.02;
 var MATERIAL_COLOURS = { metal: 13421772, glass: 4500223, rubber: 16750848, fuel: 16724736 };
+var LANE_START_S = 1.2;
 var ZONE_COLOURS = { door: 5627221, hood: 14540083, lid: 14522675, bumper: 14505437, glass: 4500223, light: 16777215, wheel: 16742195 };
 var BODY_HEIGHT = 1.7;
 function createVehiclesTestModule(options = {}) {
@@ -945,7 +1281,7 @@ function createVehiclesTestModule(options = {}) {
   const entries = [...keys.map((key) => ({ key, id: itemId(key) })), ...wrecks.map((w) => ({ key: w.vehicle, id: w.key, scenario: w.scenario }))];
   const effectIds = { ...defaultEffectIds, ...options.effects };
   const soundIds = { ...defaultSoundIds, ...options.sounds };
-  const settings = { quality: "high", paint: false, seed: 1, palette: "auto", driving: "arcade", surface: "dry_asphalt" };
+  const settings = { quality: "high", paint: false, seed: 1, palette: "auto", driving: "arcade", surface: "dry_asphalt", damage: "none" };
   const kits = /* @__PURE__ */ new WeakMap();
   const placed = /* @__PURE__ */ new Map();
   const cabins = createCabinSmoke();
@@ -957,10 +1293,10 @@ function createVehiclesTestModule(options = {}) {
   let lane = null;
   const effects = () => host?.effects;
   const audio = () => host?.audio;
-  let engineLoop;
+  let carSound;
   const stopEngine = () => {
-    engineLoop?.stop();
-    engineLoop = void 0;
+    carSound?.dispose();
+    carSound = void 0;
   };
   const particleMaterials = {
     own: (build) => isRenderPools(host?.pools) ? host.pools.materials.own(build) : build(),
@@ -1017,7 +1353,7 @@ function createVehiclesTestModule(options = {}) {
     impl: (root, id) => {
       const r = root;
       const kit = r.userData.kit;
-      const d = createVehicleDestructible(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemKey] ?? key, creaseQueue });
+      const d = createVehicleDestructible2(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemKey] ?? key, creaseQueue });
       tapEffects(d);
       const setPartPose = d.setPartPose?.bind(d);
       {
@@ -1053,7 +1389,7 @@ function createVehiclesTestModule(options = {}) {
     if (!clipCache.has(key)) {
       const kit = kitFor(THREE);
       const built = buildVehicleItem(kit, key);
-      const d = createVehicleDestructible(kit, built.vehicle, { id: `${itemId(key)}_clips`, frame: built.root, headless: true });
+      const d = createVehicleDestructible2(kit, built.vehicle, { id: `${itemId(key)}_clips`, frame: built.root, headless: true });
       clipCache.set(key, d.animations());
       kit.dispose(built.vehicle);
     }
@@ -1181,15 +1517,16 @@ function createVehiclesTestModule(options = {}) {
     clearLane();
     const kit = kitFor(three);
     const vehicles = createVehiclesThree(three, { kit, fleet });
-    const built = vehicles.build("compact_hatch", { quality: "lite", seed: settings.seed });
+    const built = vehicles.build("compact_hatch", { quality: settings.damage === "none" ? "lite" : "high", seed: settings.seed });
     const wall = new three.Mesh(new three.BoxGeometry(0.6, 2, 6), new three.MeshStandardMaterial({ color: 7829367 }));
     wall.position.set(LANE.wall + 0.3, 1, LANE.z);
     const scene = host.scene;
     scene.add(built.group, wall);
-    const mode = settings.driving === "semi" ? "semi" : "arcade";
+    const mode = settings.driving === "semi" || settings.damage !== "none" ? "semi" : "arcade";
+    const damage = settings.damage === "none" || !built.context ? null : createLaneDamage({ kit, context: built.context, frame: built.group, damage: settings.damage });
     const surfaces = createSurfaces2();
     const idle = { throttle: 0, brake: 0, steer: 0, handbrake: false };
-    const state = { time: 0, exhaust: 0, ended: false, wasBlocked: false };
+    const state = { time: 0, exhaust: 0, sparks: 0, ended: false, wasBlocked: false };
     const arcade = createArcadeDriver2({ length: built.length, width: built.width });
     const semi = createSemiSimDriver2({}, { surfaces });
     const driver = mode === "semi" ? semi : arcade;
@@ -1202,7 +1539,8 @@ function createVehiclesTestModule(options = {}) {
       built.group.rotation.y = driver.state.yaw + Math.PI / 2;
     };
     pose();
-    engineLoop = audio()?.loop?.(soundIds.engine, { position: [driver.state.x, 0.5, driver.state.z] });
+    carSound = createVehicleSound(audio(), { sounds: soundIds });
+    carSound.start([driver.state.x, 0.5, driver.state.z]);
     const log = (key, value) => host?.log(fill(text, locale, text.lane[key], value.toFixed(1)));
     lane = {
       car: built,
@@ -1214,29 +1552,56 @@ function createVehiclesTestModule(options = {}) {
       speed: () => "u" in driver.state ? driver.state.u : driver.state.v,
       distance: () => driver.state.x - LANE.from,
       step(dt) {
-        if (state.ended) return;
+        if (state.ended) {
+          damage?.settle(dt);
+          const at = [driver.state.x, 0.5, driver.state.z];
+          if (carSound?.reading.running) carSound.stop(at);
+          carSound?.update({ dt, position: at, speed: 0, throttle: 0 });
+          return;
+        }
         state.time += dt;
-        const braking = gap() < brakeAt() && state.time > 0.5;
-        const input = { ...idle, throttle: braking ? 0 : 1, brake: braking ? 1 : 0, steer: Math.sin(state.time * 1.4) * 0.15 };
+        const braking = settings.damage !== "into_wall" && gap() < brakeAt() && state.time > 0.5;
+        const moving = state.time > LANE_START_S;
+        const input = { ...idle, throttle: braking || !moving ? 0 : 1, brake: braking ? 1 : 0, steer: settings.damage === "into_wall" || !moving ? 0 : Math.sin(state.time * 1.4) * 0.15 };
         if (mode === "arcade") {
           const { events } = arcade.step(input, dt, { blocked: (x, z, yaw) => vehicleCorners2(arcade.spec, x, z, yaw).some(([px]) => px >= LANE.wall) });
           for (const e of events) {
             if (e.type !== "crash") continue;
             log("crash", e.speed);
-            audio()?.play({ sound: soundIds.crash, position: [driver.state.x, 0.5, driver.state.z], volume: Math.min(1, e.speed / 15) });
+            carSound?.crash(e.speed, [driver.state.x + built.length / 2, 0.5, driver.state.z]);
           }
         } else {
           semi.step(input, dt, { ground: () => ({ surface: settings.surface }) });
+          const grinding = damage?.step({ dt, speed: Math.abs(lane?.speed() ?? 0), throttle: input.throttle, driver: semi }) ?? [];
+          state.sparks -= dt;
+          const fx2 = effects();
+          if (fx2 && state.sparks <= 0 && Math.abs(lane?.speed() ?? 0) > 0.5) {
+            state.sparks = grinding.length ? SPARK_EVERY_S : 0;
+            for (const point of grinding) fx2.play({ effect: effectIds.sparks, point });
+          }
           if (gap() <= 0) {
             state.ended = true;
+            const crashed = damage?.crash({ speed: Math.abs(semi.state.u), direction: [Math.cos(driver.state.yaw), 0, -Math.sin(driver.state.yaw)] });
+            if (crashed) {
+              const parts = (type) => [...new Set(crashed.flatMap((e) => e.type === type && "part" in e ? [e.part] : []))].join(", ") || "-";
+              host?.log(fill(text, locale, text.lane.damage, parts("dent"), parts("fracture")));
+            }
             log("crash", Math.abs(semi.state.u));
-            audio()?.play({ sound: soundIds.crash, position: [driver.state.x, 0.5, driver.state.z], volume: Math.min(1, Math.abs(semi.state.u) / 15) });
+            carSound?.crash(semi.state.u, [driver.state.x + built.length / 2, 0.5, driver.state.z]);
           }
         }
         pose();
         {
           const speed = Math.abs(lane?.speed() ?? 0);
-          engineLoop?.set({ volume: state.ended ? 0 : 0.035 + speed * 3e-3, frequency: 38 + speed * 7, position: [driver.state.x, 0.5, driver.state.z] });
+          const semiState = mode === "semi" ? semi.state : null;
+          carSound?.update({
+            dt,
+            position: [driver.state.x, 0.5, driver.state.z],
+            speed,
+            throttle: input.throttle,
+            ...semiState ? { rpm: semiState.rpm, slip: Math.max(0, ...semiState.slip.map(Math.abs)) } : { slip: braking && speed > 3 ? 0.6 : 0 },
+            surface: /dirt|gravel|sand|grass|mud/.test(settings.surface) ? "dirt" : "asphalt"
+          });
         }
         state.exhaust -= dt;
         const fx = effects();
@@ -1244,7 +1609,7 @@ function createVehiclesTestModule(options = {}) {
           state.exhaust = 0.4;
           fx.play({ effect: effectIds.exhaust, point: [driver.state.x - Math.cos(driver.state.yaw) * (built.length / 2), 0.3, driver.state.z + Math.sin(driver.state.yaw) * (built.length / 2)], scale: Math.min(1, Math.abs(lane?.speed() ?? 0) / 17) });
         }
-        if (!state.ended && state.time > 1 && Math.abs(lane?.speed() ?? 0) < 0.05) {
+        if (!state.ended && state.time > LANE_START_S + 1 && Math.abs(lane?.speed() ?? 0) < 0.05) {
           state.ended = true;
           log("end", Math.max(0, gap()));
         }
@@ -1282,6 +1647,9 @@ function createVehiclesTestModule(options = {}) {
       case "surface":
         settings.surface = String(change.value);
         break;
+      case "lane_damage":
+        settings.damage = String(change.value);
+        break;
       default:
         break;
     }
@@ -1377,6 +1745,7 @@ function createVehiclesTestModule(options = {}) {
         { kind: "choice", id: "palette", name: text.controls.palette, hint: text.hints.palette, options: ["auto", "civil", "military"].map((id) => ({ id, name: text.options.palette[id] })), default: "auto" },
         { kind: "choice", id: "driving", name: text.controls.driving, hint: text.hints.driving, options: ["arcade", "semi"].map((id) => ({ id, name: text.options.driving[id] })), default: "arcade" },
         { kind: "choice", id: "surface", name: text.controls.surface, hint: text.hints.surface, options: surfaceIds.map((id) => ({ id, name: text.options.surface[id] ?? id })), default: "dry_asphalt" },
+        { kind: "choice", id: "lane_damage", name: text.controls.lane_damage, hint: text.hints.lane_damage, options: LANE_DAMAGE.map((id) => ({ id, name: text.options.lane_damage[id] ?? id })), default: "none" },
         { kind: "action", id: "repaint", name: text.actions.repaint },
         { kind: "action", id: "drive_lane", name: text.actions.drive_lane },
         { kind: "action", id: "clear_lane", name: text.actions.clear_lane },
@@ -1406,6 +1775,7 @@ function createVehiclesTestModule(options = {}) {
       const stopCrease = lent.defer?.(creaseQueue.deferredQueue(), DEFERRED_PRIORITY[DEFERRED_QUEUE_ID.VEHICLE_CREASE]);
       if (isRenderPools(lent.pools)) lent.pools.materials.register("vehicles.cracked-glass", () => crackedGlassMaterial(three, new three.DataTexture(new Uint8Array(4), 1, 1)));
       lent.audio?.register?.(LIBRARY_BANK);
+      lent.audio?.register?.(VEHICLE_SOUND_BANK);
       return () => {
         stopChange?.();
         stopFrame();
@@ -1430,6 +1800,589 @@ function loadVehiclesTestModule(room, options = {}) {
   return room.loadModule(createVehiclesTestModule({ ...options, three }));
 }
 
+// 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 { discardObject3D as discardObject3D2 } from "@adatechnology/game-shapes-three";
+
+// 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" },
+    hints: {
+      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" },
+    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.)" },
+    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",
+      top_speed: "Velocidade m\xE1xima",
+      brake_100_0: "Frenagem 100 a 0",
+      turn_circle: "Di\xE2metro de giro",
+      wet_brake_80_0: "Frenagem molhada 80 a 0",
+      mud_traction: "Tra\xE7\xE3o na lama",
+      cabin: "Cabine e personagem",
+      cameras: "C\xE2meras",
+      mirrors: "Retrovisores e r\xE9",
+      terrain: "Terrenos",
+      wind_tunnel: "T\xFAnel de vento",
+      crash_test: "Crash test",
+      pedestrian: "Atropelamento",
+      performance: "Desempenho",
+      buoyancy: "Flutua\xE7\xE3o",
+      flight: "Voo"
+    },
+    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}" }
+  },
+  en: {
+    name: "Proving ground",
+    controls: { vehicle: "Vehicle", test: "Test", camera: "Camera", time_scale: "Simulation speed", visual_check: "Visual check" },
+    hints: {
+      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" },
+    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)" },
+    cameras: { room: "Room", chase: "Chase (third person)", cockpit: "Cockpit (first person)", hood: "Hood" },
+    tests: {
+      accel_0_100: "0 to 100 km/h",
+      top_speed: "Top speed",
+      brake_100_0: "Braking 100 to 0",
+      turn_circle: "Turning circle",
+      wet_brake_80_0: "Wet braking 80 to 0",
+      mud_traction: "Mud traction",
+      cabin: "Cabin and character",
+      cameras: "Cameras",
+      mirrors: "Mirrors and reversing",
+      terrain: "Terrain",
+      wind_tunnel: "Wind tunnel",
+      crash_test: "Crash test",
+      pedestrian: "Pedestrian impact",
+      performance: "Performance",
+      buoyancy: "Buoyancy",
+      flight: "Flight"
+    },
+    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}" }
+  }
+};
+var fillText = (template, ...values) => template.replace(/\{(\d+)\}/g, (_, i) => String(values[Number(i)] ?? ""));
+
+// src/test-area/proving/module.ts
+var PROVING_AREA_ID = "vehicles_proving";
+var TRACK = { x0: -30, z: 22, tile: 260, width: 14, start: 4 };
+var SURFACE_LOOK = { dry_asphalt: { color: 2829617, roughness: 0.95 }, wet_asphalt: { color: 1842980, roughness: 0.18 }, mud: { color: 4863268, roughness: 1 } };
+var VISUAL_CHECKS = ["cabin", "cameras", "mirrors"];
+var MIRROR_RECTS = {
+  rear_view: { x: 0.38, y: 0.02, width: 0.24, height: 0.09, rounded: 0.35 },
+  left: { x: 0.02, y: 0.72, width: 0.19, height: 0.13, rounded: 0.3 },
+  right: { x: 0.79, y: 0.72, width: 0.19, height: 0.13, rounded: 0.3 },
+  reverse: { x: 0.36, y: 0.13, width: 0.28, height: 0.18, rounded: 0.06 }
+};
+function createProvingModule(options) {
+  const locale = options.locale ?? "pt-BR";
+  const text = PROVING_TEXT[locale] ?? PROVING_TEXT["pt-BR"];
+  const tests = options.tests ?? createProvingTests();
+  const vehicles = options.vehicles;
+  const sounds = { ...defaultSoundIds, ...options.sounds };
+  const measured = tests.tests.filter((t) => t.kind === "measured").map((t) => t.id);
+  const settings = { vehicle: vehicles.includes("compact_hatch") ? "compact_hatch" : vehicles[0] ?? "compact_hatch", test: measured[0] ?? "accel_0_100", camera: "chase", timeScale: 4, visual: "cameras" };
+  const certificates = /* @__PURE__ */ new Map();
+  const kits = /* @__PURE__ */ new WeakMap();
+  let host = null;
+  let three = null;
+  let track = null;
+  let strip = null;
+  let board = null;
+  let car = null;
+  let run = null;
+  let parking = null;
+  let queue = [];
+  let open = false;
+  let lastWrap = 0;
+  let engine;
+  const rig = { camera: null, vehicle: null, mirrors: [] };
+  const name = (id) => options.nameOf?.(id) ?? id.replace(/_/g, " ");
+  const kitFor = (THREE) => {
+    let kit = kits.get(THREE);
+    if (!kit) {
+      kit = options.createKit(THREE);
+      kits.set(THREE, kit);
+    }
+    return kit;
+  };
+  const subjectOf = (id) => {
+    const mass = three ? kitFor(three).find(id)?.mass : void 0;
+    return options.subject(id, mass);
+  };
+  const blank = (subject) => {
+    const results = tests.forDomain(subject.domain).map((t) => ({ test: t.id, kind: t.kind, unit: t.unit, range: t.range?.(subject) ?? {}, value: null, verdict: "pending", note: t.kind === "measured" ? "not run" : t.kind === "visual" ? "awaiting sign-off" : "room not built yet" }));
+    return { vehicle: subject.id, domain: subject.domain, category: subject.category, status: statusOf(results), results };
+  };
+  const certificateOf = (id) => {
+    if (!certificates.has(id)) {
+      const subject = subjectOf(id);
+      if (subject) certificates.set(id, blank(subject));
+    }
+    return certificates.get(id);
+  };
+  const store = (certificate) => {
+    certificates.set(certificate.vehicle, certificate);
+    options.onCertificate?.(certificate);
+    drawBoard();
+  };
+  const buildTrack = () => {
+    if (!host || track) return;
+    const THREE = three;
+    track = markKitOrigin3(new THREE.Group(), { owner: "@adatechnology/game-vehicles-three", kind: "room", id: "proving_track" });
+    track.name = "proving_track";
+    const look = SURFACE_LOOK.dry_asphalt;
+    strip = new THREE.Mesh(new THREE.PlaneGeometry(TRACK.tile + 80, TRACK.width), new THREE.MeshStandardMaterial({ color: look.color, roughness: look.roughness, metalness: 0.05 }));
+    strip.rotation.x = -Math.PI / 2;
+    strip.position.set(TRACK.x0 + TRACK.tile / 2, 0.012, TRACK.z);
+    strip.receiveShadow = true;
+    track.add(strip);
+    const paint = new THREE.MeshBasicMaterial({ color: 15263970 });
+    const yellow = new THREE.MeshBasicMaterial({ color: 15909424 });
+    const dash = new THREE.PlaneGeometry(3, 0.14);
+    const edge = new THREE.PlaneGeometry(TRACK.tile + 80, 0.16);
+    for (const side of [-1, 1]) {
+      const line = new THREE.Mesh(edge, paint);
+      line.rotation.x = -Math.PI / 2;
+      line.position.set(TRACK.x0 + TRACK.tile / 2, 0.016, TRACK.z + side * (TRACK.width / 2 - 0.4));
+      track.add(line);
+    }
+    for (let x = TRACK.x0 - 40; x < TRACK.x0 + TRACK.tile + 40; x += 9) {
+      const d = new THREE.Mesh(dash, paint);
+      d.rotation.x = -Math.PI / 2;
+      d.position.set(x, 0.016, TRACK.z - 1.5);
+      track.add(d);
+    }
+    const post = new THREE.BoxGeometry(0.12, 1.4, 0.12);
+    const plate = new THREE.BoxGeometry(0.06, 0.5, 0.9);
+    for (let m = 0; m <= TRACK.tile; m += 50) {
+      const p = new THREE.Mesh(post, yellow);
+      p.position.set(TRACK.x0 + m, 0.7, TRACK.z - TRACK.width / 2 - 0.6);
+      const q = new THREE.Mesh(plate, m === 0 ? yellow : paint);
+      q.position.set(TRACK.x0 + m, 1.45, TRACK.z - TRACK.width / 2 - 0.6);
+      track.add(p, q);
+    }
+    const startLine = new THREE.Mesh(new THREE.PlaneGeometry(0.5, TRACK.width - 1), yellow);
+    startLine.rotation.x = -Math.PI / 2;
+    startLine.position.set(TRACK.x0, 0.017, TRACK.z);
+    track.add(startLine);
+    host.scene.add(track);
+    buildBoard();
+  };
+  const setSurface = (surface) => {
+    if (!strip) return;
+    const look = SURFACE_LOOK[surface] ?? SURFACE_LOOK.dry_asphalt;
+    strip.material.color.setHex(look.color);
+    strip.material.roughness = look.roughness;
+  };
+  const buildBoard = () => {
+    if (!host || board || typeof document === "undefined") return;
+    const THREE = three;
+    const canvas = document.createElement("canvas");
+    canvas.width = 1024;
+    canvas.height = 640;
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.colorSpace = THREE.SRGBColorSpace;
+    const mesh = markKitOrigin3(new THREE.Mesh(new THREE.PlaneGeometry(9.6, 6), new THREE.MeshBasicMaterial({ map: texture, toneMapped: false })), { owner: "@adatechnology/game-vehicles-three", kind: "room", id: "proving_board" });
+    mesh.position.set(TRACK.x0 + 6, 3.6, TRACK.z - TRACK.width / 2 - 3);
+    const legs = new THREE.Mesh(new THREE.BoxGeometry(9.8, 0.2, 0.2), new THREE.MeshStandardMaterial({ color: 1842981 }));
+    legs.position.set(0, -3.1, -0.05);
+    const stand = new THREE.Mesh(new THREE.BoxGeometry(0.25, 3.4, 0.25), legs.material);
+    stand.position.set(0, -4.6, -0.1);
+    mesh.add(legs, stand);
+    track.add(mesh);
+    board = { mesh, canvas, texture };
+    drawBoard();
+  };
+  const fmtRange = (r) => r.min == null && r.max == null ? "\u2014" : `${r.min ?? "\u2026"}\u2013${r.max ?? "\u2026"}`;
+  const drawBoard = () => {
+    if (!board) return;
+    const cert = certificateOf(settings.vehicle);
+    const g = board.canvas.getContext("2d");
+    if (!g || !cert) return;
+    const W = board.canvas.width;
+    g.fillStyle = "#16181c";
+    g.fillRect(0, 0, W, board.canvas.height);
+    g.fillStyle = "#f2c230";
+    g.fillRect(0, 0, W, 10);
+    g.font = "600 26px monospace";
+    g.fillStyle = "#8d95a3";
+    g.fillText(text.board.title.toUpperCase(), 32, 50);
+    g.font = "700 46px sans-serif";
+    g.fillStyle = "#e7e9ec";
+    g.fillText(name(cert.vehicle), 32, 102);
+    const colour = { approved: "#5cc98a", rejected: "#ef6a5b", pending: "#a7a0f0" }[cert.status];
+    g.font = "700 34px sans-serif";
+    const status = text.status[cert.status];
+    const sw = g.measureText(status).width + 32;
+    g.strokeStyle = colour;
+    g.lineWidth = 3;
+    g.strokeRect(W - sw - 32, 66, sw, 48);
+    g.fillStyle = colour;
+    g.fillText(status, W - sw - 16, 102);
+    g.font = "22px monospace";
+    g.fillStyle = "#8d95a3";
+    const cols = [32, 430, 640, 860];
+    [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;
+      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}`;
+      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);
+      g.fillStyle = { pass: "#5cc98a", fail: "#ef6a5b", pending: "#a7a0f0" }[r.verdict];
+      g.fillText(r.verdict === "pass" ? "\u2713 " + text.verdict.pass : r.verdict === "fail" ? "\u2717 " + text.verdict.fail : "\u2026", cols[3], y);
+      y += 30;
+    }
+    board.texture.needsUpdate = true;
+  };
+  const removeCar = () => {
+    if (!car) return;
+    discardObject3D2(car.built.group);
+    car = null;
+  };
+  const placeCar = () => {
+    if (!host || !three) return;
+    const subject = subjectOf(settings.vehicle);
+    if (!subject) return;
+    removeCar();
+    const built = createVehiclesThree(three, { kit: kitFor(three) }).build(settings.vehicle, { quality: "high" });
+    const guides = reverseGuides(built);
+    built.group.add(guides);
+    host.scene.add(built.group);
+    car = { built, guides, subject };
+    pose({ x: 0, z: TRACK.start, yaw: 0, pitch: 0, roll: 0, height: 0 }, 0);
+    rig.vehicle?.reset();
+    drawBoard();
+  };
+  const reverseGuides = (built) => {
+    const THREE = three;
+    const group = new THREE.Group();
+    group.name = "reverse_guides";
+    const half = built.width / 2 - 0.05;
+    const tail = -built.length / 2;
+    const bands = [
+      [0.2, 1, 15682107],
+      [1, 2, 15909424],
+      [2, 3.2, 6080906]
+    ];
+    for (const [a, b, colour] of bands) {
+      const material = new THREE.MeshBasicMaterial({ color: colour, transparent: true, opacity: 0.85, depthTest: false });
+      for (const side of [-1, 1]) {
+        const bar = new THREE.Mesh(new THREE.PlaneGeometry(0.06, b - a), material);
+        bar.rotation.x = -Math.PI / 2;
+        bar.position.set(side * half, 0.03, tail - (a + b) / 2);
+        bar.userData.side = side;
+        bar.userData.mid = (a + b) / 2;
+        group.add(bar);
+      }
+      const cross = new THREE.Mesh(new THREE.PlaneGeometry(half * 2, 0.05), material);
+      cross.rotation.x = -Math.PI / 2;
+      cross.position.set(0, 0.03, tail - a);
+      cross.userData.mid = a;
+      group.add(cross);
+    }
+    group.traverse((o) => o.layers.set(1));
+    return group;
+  };
+  const bendGuides = (steer) => {
+    if (!car) return;
+    for (const bar of car.guides.children) {
+      const d = bar.userData.mid;
+      const offset = -steer * 0.18 * d * d;
+      bar.position.x = (bar.userData.side ?? 0) * (car.built.width / 2 - 0.05) + offset;
+    }
+  };
+  const pose = (s, steer) => {
+    if (!car) return;
+    const wrapped = (s.x % TRACK.tile + TRACK.tile) % TRACK.tile;
+    if (Math.abs(wrapped - lastWrap) > TRACK.tile / 2) rig.vehicle?.reset();
+    lastWrap = wrapped;
+    car.built.group.position.set(TRACK.x0 + wrapped, 0, TRACK.z + s.z);
+    car.built.group.rotation.set(-s.pitch, s.yaw + Math.PI / 2, s.roll, "YXZ");
+    bendGuides(steer);
+  };
+  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 };
+  };
+  const applyCamera = () => {
+    if (!host?.setViewCamera) return;
+    host.setViewCamera(settings.camera === "room" ? null : rig.camera);
+    if (settings.camera !== "room") rig.vehicle?.setMode(settings.camera);
+  };
+  const refreshMirrors = () => {
+    for (const m of rig.mirrors) m.remove();
+    rig.mirrors = [];
+    if (!host?.addView || !car) return;
+    const poses = mirrorPoses(car.built);
+    const want = (id) => id === "reverse" ? !!host?.bench?.layer("reverse_camera") : !!host?.bench?.layer("mirrors");
+    for (const pose2 of poses) {
+      if (!want(pose2.id)) continue;
+      const camera = new three.PerspectiveCamera(pose2.fov, 2, 0.05, 400);
+      if (pose2.id === "reverse") camera.layers.enable(1);
+      const rect = MIRROR_RECTS[pose2.id];
+      const remove = host.addView({ camera, rect, mirror: pose2.mirror, rounded: rect.rounded, label: pose2.id, resolution: pose2.id === "reverse" ? 0.6 : 0.45 });
+      rig.mirrors.push({ pose: pose2, camera, remove });
+    }
+  };
+  let mirrorKey = "";
+  const stopEngine = () => {
+    engine?.dispose();
+    engine = void 0;
+  };
+  const startTest = (id) => {
+    const test = tests.get(id);
+    if (!host || !test || test.kind !== "measured") return;
+    if (!car || car.subject.id !== settings.vehicle) placeCar();
+    if (!car) return;
+    parking = null;
+    run = startRun(test, car.subject);
+    setSurface(run.surface);
+    if (id === "turn_circle") run.driver.place(0, TRACK.start, 0);
+    rig.vehicle?.reset();
+    stopEngine();
+    engine = createVehicleSound(host.audio, { sounds });
+    engine.start([car.built.group.position.x, 0.5, car.built.group.position.z]);
+    host.log(fillText(text.log.start, name(settings.vehicle), text.tests[id] ?? id));
+    drawBoard();
+  };
+  const finishTest = () => {
+    if (!run || !car) return;
+    const result = run.result();
+    const cert = certificateOf(car.subject.id);
+    if (cert) store(withResult(cert, result));
+    host?.log(fillText(text.log.result, name(car.subject.id), text.tests[result.test] ?? result.test, result.value ?? "\u2014", result.unit, fmtRange(result.range), result.verdict), { vehicle: car.subject.id, ...result, trace: void 0 }, "proving_result");
+    run = null;
+    stopEngine();
+    const next = queue.shift();
+    if (next) startTest(next);
+    else setSurface("dry_asphalt");
+  };
+  const startParking = () => {
+    if (!host) return;
+    if (!car || car.subject.id !== settings.vehicle) placeCar();
+    if (!car) return;
+    run = null;
+    queue = [];
+    setSurface("dry_asphalt");
+    const driver = createSemiSimDriver3(subjectSpec(car.subject));
+    driver.place(40, 0, 0);
+    parking = { driver, time: 0 };
+  };
+  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 === "run_test") {
+        queue = [];
+        startTest(settings.test);
+      } else if (change.id === "run_all") {
+        queue = measured.slice(1);
+        startTest(measured[0]);
+      } else if (change.id === "certify_now") {
+        const subject = subjectOf(settings.vehicle);
+        if (!subject) return;
+        const prior = certificateOf(subject.id);
+        const signOffs = (prior?.results ?? []).filter((r) => r.kind !== "measured" && r.verdict !== "pending").map((r) => ({ vehicle: subject.id, test: r.test, ok: r.verdict === "pass", by: r.signedBy ?? "test room" }));
+        const cert = certify(subject, { tests, signOffs });
+        store(cert);
+        host?.log(fillText(text.log.certified, name(subject.id), text.status[cert.status]), { vehicle: subject.id, status: cert.status }, "proving_certificate");
+      } else if (change.id === "reverse_park") startParking();
+      else if (change.id === "sign_ok" || change.id === "sign_fail") {
+        const cert = certificateOf(settings.vehicle);
+        if (!cert) return;
+        const ok = change.id === "sign_ok";
+        store(withResult(cert, { test: settings.visual, kind: "visual", unit: "", range: {}, value: null, verdict: ok ? "pass" : "fail", signedBy: "test room" }));
+        host?.log(fillText(text.log.signed, name(settings.vehicle), text.tests[settings.visual] ?? settings.visual, ok ? text.verdict.pass : text.verdict.fail));
+      } else if (change.id === "reset") {
+        const subject = subjectOf(settings.vehicle);
+        if (subject) store(blank(subject));
+      }
+      return;
+    }
+    switch (change.id) {
+      case "vehicle":
+        settings.vehicle = String(change.value);
+        run = null;
+        queue = [];
+        parking = null;
+        stopEngine();
+        placeCar();
+        refreshMirrors();
+        break;
+      case "test":
+        settings.test = String(change.value);
+        break;
+      case "camera":
+        settings.camera = String(change.value);
+        applyCamera();
+        break;
+      case "time_scale":
+        settings.timeScale = Number(change.value);
+        break;
+      case "visual_check":
+        settings.visual = String(change.value);
+        break;
+      default:
+        break;
+    }
+  };
+  const frame = (dt) => {
+    if (!host || !open) return;
+    if (!track) buildTrack();
+    if (!car) {
+      placeCar();
+      refreshMirrors();
+    }
+    let speed = 0;
+    let steer = 0;
+    if (run) {
+      run.step(dt * settings.timeScale);
+      const s = run.driver.state;
+      pose(s, s.steerAngle);
+      speed = s.u;
+      steer = s.steerAngle;
+      if (run.done) finishTest();
+    } else if (parking) {
+      parking.time += dt;
+      const p = parking;
+      p.driver.step({ throttle: 0, brake: p.time < 7 ? 0.35 : 1, steer: p.time > 2 ? -0.6 : 0, handbrake: false }, dt);
+      pose(p.driver.state, p.driver.state.steerAngle);
+      speed = p.driver.state.u;
+      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 });
+    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);
+    void steer;
+    const key = `${host.bench?.layer("mirrors")}|${host.bench?.layer("reverse_camera")}`;
+    if (key !== mirrorKey) {
+      mirrorKey = key;
+      refreshMirrors();
+    }
+    if (run && Math.floor(run.time * 2) !== Math.floor((run.time - dt * settings.timeScale) * 2)) drawBoard();
+  };
+  const speedNow = () => Math.abs(run?.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 = () => {
+    stopEngine();
+    for (const m of rig.mirrors) m.remove();
+    rig.mirrors = [];
+    removeCar();
+    mirrorKey = "";
+    if (track) discardObject3D2(track);
+    track = null;
+    strip = null;
+    board = null;
+    run = null;
+    parking = null;
+  };
+  return {
+    id: PROVING_AREA_ID,
+    name: text.name,
+    group: text.name,
+    ground: { surface: "road" },
+    certificates: () => [...certificates.values()],
+    certificate: (id) => certificateOf(id),
+    items: () => [],
+    area: () => {
+      open = true;
+      applyCamera();
+      return { placements: [], view: { eye: [TRACK.x0 - 4, 3.2, TRACK.z + 9], target: [TRACK.x0 + 6, 2.2, TRACK.z - TRACK.width / 2 - 3] } };
+    },
+    controls: () => [
+      { kind: "choice", id: "vehicle", name: text.controls.vehicle, hint: text.hints.vehicle, options: vehicles.map((id) => ({ id, name: name(id) })), default: settings.vehicle },
+      { kind: "choice", id: "test", name: text.controls.test, hint: text.hints.test, options: measured.map((id) => ({ id, name: text.tests[id] ?? id })), default: settings.test },
+      { kind: "choice", id: "camera", name: text.controls.camera, hint: text.hints.camera, options: ["room", "chase", "cockpit", "hood"].map((id) => ({ id, name: text.cameras[id] })), default: settings.camera },
+      { kind: "number", id: "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: "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 },
+      { kind: "action", id: "reverse_park", name: text.actions.reverse_park },
+      { kind: "action", id: "sign_ok", name: text.actions.sign_ok },
+      { kind: "action", id: "sign_fail", name: text.actions.sign_fail },
+      { kind: "action", id: "reset", name: text.actions.reset }
+    ],
+    layers: () => [
+      { id: "mirrors", name: text.layers.mirrors, default: false },
+      { id: "reverse_camera", name: text.layers.reverse_camera, default: false },
+      { id: "scoreboard", name: text.layers.scoreboard, default: true }
+    ],
+    metrics: () => [
+      { id: "speed", name: text.metrics.speed, unit: "km/h", digits: 0, read: speedNow },
+      { 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") },
+      { id: "failed", name: text.metrics.failed, read: () => counts("fail") },
+      { id: "pending", name: text.metrics.pending, read: () => counts("pending") },
+      { id: "status", name: text.metrics.status, read: () => ({ approved: 1, rejected: -1, pending: 0 })[certificateOf(settings.vehicle)?.status ?? "pending"] }
+    ],
+    scenarios: () => [],
+    attach(lent) {
+      host = lent;
+      three = lent.THREE;
+      rig.camera = new three.PerspectiveCamera(60, 1.6, 0.05, 900);
+      rig.vehicle = createVehicleCamera(three);
+      lent.audio?.register?.(LIBRARY_BANK2);
+      const stopChange = lent.bench?.onChange(onChange);
+      const stopFrame = lent.onFrame(frame);
+      const stopClear = lent.onClear?.(() => {
+        open = false;
+        teardown();
+        lent.setViewCamera?.(null);
+      });
+      return () => {
+        stopChange?.();
+        stopFrame();
+        stopClear?.();
+        teardown();
+        lent.setViewCamera?.(null);
+        host = null;
+      };
+    }
+  };
+}
+function loadProvingModule(room, options) {
+  return room.loadModule(createProvingModule(options));
+}
+
 export {
   LITE_CLASSES,
   PRUNE_BELOW,
@@ -1440,6 +2393,22 @@ export {
   liteMeshes,
   createVehiclesThree,
   createCabinSmoke,
+  VEHICLE_LOOP_FALLOFF,
+  VEHICLE_LOOPS,
+  VEHICLE_SOUNDS,
+  VEHICLE_SOUND_BANK,
+  firingHz,
+  rpmShare,
+  layerWeight,
+  engineMix,
+  createGearGuess,
+  DEFAULT_VEHICLE_SOUND_KEYS,
+  CRASH_SPEEDS,
+  CAR_ENGINE,
+  TRUCK_ENGINE,
+  BIKE_ENGINE,
+  ENGINE_PROFILES,
+  createVehicleSound,
   VEHICLE_LOD_DISTANCE,
   createVehicleLod,
   VEHICLE_SCENARIO_IDS,
@@ -1451,6 +2420,10 @@ export {
   VEHICLES_AREA_ID,
   DEFAULT_TEST_VEHICLES,
   createVehiclesTestModule,
-  loadVehiclesTestModule
+  loadVehiclesTestModule,
+  PROVING_TEXT,
+  PROVING_AREA_ID,
+  createProvingModule,
+  loadProvingModule
 };
-//# sourceMappingURL=chunk-GAO7ZJP7.js.map
+//# sourceMappingURL=chunk-4SUQMRS3.js.map