@adatechnology/game-vehicles-three 0.5.0 → 0.6.1

package/dist/chunk-MRUPKE7J.js

@@ -0,0 +1,3138 @@
+// 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 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";
+
+// src/build.ts
+import { markKitOrigin } from "@adatechnology/game-contracts";
+import { colorFromSeed as defaultColorFromSeed, fleetDims as defaultFleetDims, paintPalettes as defaultPaintPalettes, paletteOf as defaultPaletteOf } from "@adatechnology/game-vehicles-fleet";
+
+// src/lite.ts
+var LITE_CLASSES = ["paint", "trim", "metal", "glass", "light", "plate"];
+var PRUNE_BELOW = 0.03;
+var createAccumulators = () => {
+  const acc = {};
+  for (const name of LITE_CLASSES) acc[name] = { P: [], N: [], C: [], U: [], I: [], nv: 0, alpha: name === "glass", uv: name === "plate", map: null };
+  return acc;
+};
+function classify(mat, mesh, c) {
+  if (mat.map) {
+    if (mesh.userData.plate) return "plate";
+    if (mat.userData && mat.userData.grille || mat.name === "grille" || mat.metalness != null && mat.roughness != null && !mat.transparent) return "trim";
+    return null;
+  }
+  if (mat.transparent && mat.opacity < 0.99) {
+    const col = mat.color;
+    if (col.r > col.g + col.b * 0.9 && col.r > 0.35) return "light";
+    if (col.r > 0.8 && col.g > 0.8 && mat.opacity < 0.3) return null;
+    return "glass";
+  }
+  if (mat.isMeshBasicMaterial) return null;
+  const e = mat.emissive;
+  const ei = mat.emissiveIntensity == null ? 1 : mat.emissiveIntensity;
+  if (e && (e.r + e.g + e.b) / 3 * ei > 0.25 && !mat.metalness) return "light";
+  if (e && (e.r + e.g + e.b) / 3 * ei > 0.45) return "light";
+  if (mat.metalness >= 0.5) return "metal";
+  if (c.paints && c.paints.has(mat)) return "paint";
+  if (mat.opacity < 1 && mat.transparent) return null;
+  return "trim";
+}
+function classColor(mat, cls, primary, paintColor, out) {
+  if (cls === "paint" && paintColor && mat === primary) return out.copy(paintColor);
+  if (cls === "light") {
+    const e = mat.emissive;
+    const ei = mat.emissiveIntensity == null ? 1 : mat.emissiveIntensity;
+    if (e && e.r + e.g + e.b > 0.05) {
+      out.copy(e).multiplyScalar(Math.max(1, ei) * 1);
+      out.r = Math.min(out.r, 1);
+      out.g = Math.min(out.g, 1);
+      out.b = Math.min(out.b, 1);
+      return out;
+    }
+    return out.copy(mat.color);
+  }
+  if (mat.map) return out.setRGB(0.12, 0.13, 0.14);
+  return out.copy(mat.color);
+}
+function liteMaterials(THREE, environment) {
+  return {
+    paint: new THREE.MeshStandardMaterial({ vertexColors: true, roughness: 0.42, metalness: 0.3, side: THREE.DoubleSide, envMap: environment, envMapIntensity: 0.35 }),
+    trim: new THREE.MeshStandardMaterial({ vertexColors: true, roughness: 0.78, metalness: 0.08, side: THREE.DoubleSide }),
+    metal: new THREE.MeshStandardMaterial({ vertexColors: true, roughness: 0.32, metalness: 0.85, envMap: environment, envMapIntensity: 1.1, side: THREE.DoubleSide }),
+    glass: new THREE.MeshStandardMaterial({ vertexColors: true, transparent: true, depthWrite: false, roughness: 0.06, metalness: 0.3, side: THREE.DoubleSide, envMap: environment, envMapIntensity: 0.9 }),
+    light: new THREE.MeshBasicMaterial({ vertexColors: true, side: THREE.DoubleSide }),
+    plate: new THREE.MeshStandardMaterial({ roughness: 0.5, metalness: 0.1, side: THREE.DoubleSide })
+  };
+}
+function fuse(THREE, c, pivot, paintColor, primary, hidden) {
+  const acc = createAccumulators();
+  const mw = new THREE.Matrix4();
+  const nm = new THREE.Matrix3();
+  const v = new THREE.Vector3();
+  const col = new THREE.Color();
+  const tmp = new THREE.Box3();
+  let pruned = 0;
+  c.vehicle.updateMatrixWorld(true);
+  c.vehicle.traverse((o) => {
+    if (!o.isMesh || o.isInstancedMesh || o.isSkinnedMesh || !o.geometry || !o.geometry.attributes.position) return;
+    for (let p = o; p; p = p.parent) if (p.visible === false) return;
+    if (o.userData && (o.userData.ghost || o.userData.skipLite)) return;
+    const mats = Array.isArray(o.material) ? o.material : [o.material];
+    const geo = o.geometry;
+    mw.multiplyMatrices(pivot, o.matrixWorld);
+    nm.getNormalMatrix(mw);
+    const flip = mw.determinant() < 0;
+    geo.computeBoundingBox();
+    tmp.copy(geo.boundingBox).applyMatrix4(mw);
+    const ext = Math.max(tmp.max.x - tmp.min.x, tmp.max.y - tmp.min.y, tmp.max.z - tmp.min.z);
+    const pa = geo.attributes.position;
+    const na = geo.attributes.normal;
+    const ua = geo.attributes.uv;
+    const ca = geo.attributes.color;
+    const ix = geo.index;
+    const tot = ix ? ix.count : pa.count;
+    const groups = Array.isArray(o.material) && geo.groups.length ? geo.groups : [{ start: 0, count: tot, materialIndex: 0 }];
+    groups.forEach((gr) => {
+      const mat = mats[gr.materialIndex] || mats[0];
+      if (!mat || hidden.has(mat)) return;
+      const cls = classify(mat, o, c);
+      if (!cls) return;
+      if (ext < PRUNE_BELOW && cls !== "plate") {
+        pruned++;
+        return;
+      }
+      const A = acc[cls];
+      const a0 = Math.min(gr.start, tot);
+      let n0 = Math.min(gr.count, tot - a0);
+      n0 -= n0 % 3;
+      if (n0 < 3) return;
+      const cc = classColor(mat, cls, primary, paintColor, col);
+      const alpha = cls === "glass" ? mat.transparent ? mat.opacity : 1 : 1;
+      if (cls === "plate" && A.map && mat.map !== A.map) return;
+      if (cls === "plate") A.map = mat.map;
+      const remap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < n0; i++) {
+        const vi = ix ? ix.getX(a0 + i) : a0 + i;
+        if (remap.has(vi)) continue;
+        remap.set(vi, A.nv++);
+        v.fromBufferAttribute(pa, vi).applyMatrix4(mw);
+        A.P.push(v.x, v.y, v.z);
+        if (na) {
+          v.fromBufferAttribute(na, vi).applyMatrix3(nm).normalize();
+          A.N.push(v.x, v.y, v.z);
+        } else A.N.push(0, 1, 0);
+        let cr = cc.r;
+        let cg = cc.g;
+        let cb = cc.b;
+        if (ca && cls !== "plate") {
+          cr *= ca.getX(vi);
+          cg *= ca.getY(vi);
+          cb *= ca.getZ(vi);
+        }
+        if (A.alpha) A.C.push(cr, cg, cb, alpha);
+        else A.C.push(cr, cg, cb);
+        if (A.uv) A.U.push(ua ? ua.getX(vi) : 0, ua ? ua.getY(vi) : 0);
+      }
+      for (let t = 0; t < n0; t += 3) {
+        const i0 = remap.get(ix ? ix.getX(a0 + t) : a0 + t);
+        const i1 = remap.get(ix ? ix.getX(a0 + t + 1) : a0 + t + 1);
+        const i2 = remap.get(ix ? ix.getX(a0 + t + 2) : a0 + t + 2);
+        if (flip) A.I.push(i0, i2, i1);
+        else A.I.push(i0, i1, i2);
+      }
+    });
+  });
+  return { acc, pruned };
+}
+function liteMeshes(THREE, fusion, materials) {
+  const meshes = [];
+  for (const name of LITE_CLASSES) {
+    const A = fusion.acc[name];
+    if (!A.I.length) continue;
+    const g = new THREE.BufferGeometry();
+    g.setAttribute("position", new THREE.Float32BufferAttribute(A.P, 3));
+    g.setAttribute("normal", new THREE.Float32BufferAttribute(A.N, 3));
+    g.setAttribute("color", new THREE.Float32BufferAttribute(A.C, A.alpha ? 4 : 3));
+    if (A.uv) g.setAttribute("uv", new THREE.Float32BufferAttribute(A.U, 2));
+    g.setIndex(A.nv > 65535 ? new THREE.Uint32BufferAttribute(A.I, 1) : new THREE.Uint16BufferAttribute(A.I, 1));
+    g.computeBoundingBox();
+    g.computeBoundingSphere();
+    let mt = materials[name];
+    if (name === "plate") {
+      mt = mt.clone();
+      mt.map = A.map;
+      if (mt.map) mt.map.needsUpdate = true;
+    }
+    const mesh = new THREE.Mesh(g, mt);
+    mesh.name = name;
+    mesh.castShadow = name !== "glass" && name !== "light";
+    mesh.receiveShadow = name !== "light";
+    meshes.push(mesh);
+  }
+  return meshes;
+}
+
+// src/build.ts
+function count(root) {
+  let triangles = 0;
+  let drawCalls = 0;
+  root.traverse((o) => {
+    if (!o.isMesh || !o.geometry) return;
+    for (let p = o; p; p = p.parent) if (p.visible === false) return;
+    const g = o.geometry;
+    const n = g.index ? g.index.count : g.attributes.position ? g.attributes.position.count : 0;
+    if (Array.isArray(o.material) && g.groups.length) drawCalls += g.groups.length;
+    else drawCalls++;
+    triangles += n / 3;
+  });
+  return { triangles: Math.round(triangles), drawCalls };
+}
+function primaryPaint(c) {
+  let best = null;
+  let bestCount = -1;
+  const counts = /* @__PURE__ */ new Map();
+  c.vehicle.traverse((o) => {
+    if (!o.isMesh || !o.geometry) return;
+    const mats = Array.isArray(o.material) ? o.material : [o.material];
+    const g = o.geometry;
+    const n = (g.index ? g.index.count : g.attributes.position.count) / 3;
+    for (const m of mats) if (c.paints.has(m)) counts.set(m, (counts.get(m) || 0) + n);
+  });
+  counts.forEach((n, m) => {
+    if (n > bestCount) {
+      bestCount = n;
+      best = m;
+    }
+  });
+  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 };
+  const { colorFromSeed: colorFromSeed2, fleetDims: fleetDims2, paintPalettes: paintPalettes2, paletteOf: paletteOf2 } = fleet;
+  const groupOf = options.groupOf || ((key) => kit.find(key)?.group === kit.config.defaultGroup ? "cars" : String(kit.find(key)?.group));
+  const militaryKeys = /* @__PURE__ */ new Set();
+  const isMilitary = (key) => militaryKeys.has(key) || paletteOf2(groupOf(key)) === paintPalettes2.military;
+  const build = (key, o = {}) => {
+    const quality = o.quality === "lite" ? "lite" : "high";
+    const spec = kit.find(key);
+    if (!spec) throw new Error(`createVehiclesThree: unknown vehicle "${key}"`);
+    const seed = o.seed == null ? null : o.seed;
+    const color = o.color || (seed != null ? colorFromSeed2(seed, isMilitary(key) ? paintPalettes2.military : paintPalettes2.civil) : null);
+    const c = kit.build(key, o.state || "intact", void 0, { lod: quality === "lite" });
+    c.root.updateMatrixWorld(true);
+    const primary = primaryPaint(c);
+    const rotation = new THREE.Matrix4().makeRotationY(-Math.PI / 2);
+    const bounds = new THREE.Box3();
+    const piece = new THREE.Box3();
+    const turned = new THREE.Matrix4();
+    c.vehicle.traverse((m) => {
+      if (!m.isMesh || !m.geometry || m.userData.ghost) return;
+      for (let p = m; p; p = p.parent) if (p.visible === false) return;
+      m.geometry.computeBoundingBox();
+      piece.copy(m.geometry.boundingBox).applyMatrix4(turned.multiplyMatrices(rotation, m.matrixWorld));
+      bounds.union(piece);
+    });
+    const cx = (bounds.min.x + bounds.max.x) / 2;
+    const cz = (bounds.min.z + bounds.max.z) / 2;
+    const pivotMatrix = new THREE.Matrix4().makeTranslation(-cx, -bounds.min.y, -cz).multiply(rotation);
+    const group = new THREE.Group();
+    group.name = `vehicle:${key}`;
+    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";
+      pivot.matrixAutoUpdate = false;
+      pivot.matrix.copy(pivotMatrix);
+      pivot.matrixWorldNeedsUpdate = true;
+      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);
+        c.vehicle.traverse((m) => {
+          if (!m.isMesh) return;
+          if (Array.isArray(m.material)) m.material = m.material.map((x) => x === primary ? repainted : x);
+          else if (m.material === primary) m.material = repainted;
+        });
+      }
+      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);
+      pruned = fusion.pruned;
+    }
+    const size = new THREE.Box3().setFromObject(group).getSize(new THREE.Vector3());
+    const counted = count(group);
+    group.userData.damageables = damageables;
+    group.userData.key = key;
+    group.userData.quality = quality;
+    return {
+      key,
+      quality,
+      color,
+      seed,
+      group,
+      damageables,
+      triangles: counted.triangles,
+      drawCalls: counted.drawCalls,
+      length: +size.z.toFixed(3),
+      width: +size.x.toFixed(3),
+      height: +size.y.toFixed(3),
+      pruned,
+      expected: fleetDims2(key),
+      context: quality === "high" ? c : null,
+      driverEye,
+      dispose() {
+        group.traverse((m) => {
+          if (m.geometry) m.geometry.dispose();
+        });
+      }
+    };
+  };
+  return { THREE, kit, build };
+}
+function markDamageables(c, damageables) {
+  const byZone = {};
+  for (const d of damageables) byZone[d.zone] = d;
+  for (const z of c.zones || []) {
+    const d = byZone[z.id];
+    if (!d) continue;
+    for (const o of z.objs || z.meshes || []) if (o && o.userData) o.userData.damageable = { material: d.material, zone: d.zone };
+  }
+  for (const w of c.wheels || []) {
+    const z = (c.zones || []).find((zz) => zz.type === "wheel" && zz.objs && zz.objs.indexOf(w) >= 0);
+    w.userData.damageable = { material: "rubber", zone: z ? z.id : "wheel" };
+  }
+}
+
+// src/vehicle-lod.ts
+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, 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();
+  const keyOf = () => full.children.filter((child) => child.name !== "static-batches").map((child) => child.uuid).join();
+  const armUpload = () => {
+    for (const [mesh, wasCulled] of culled) mesh.frustumCulled = wasCulled;
+    culled.clear();
+    modelKey = keyOf();
+    isUploaded = false;
+    full.traverse((object) => {
+      if (!object.isMesh || culled.has(object)) return;
+      culled.set(object, object.frustumCulled);
+      object.frustumCulled = false;
+    });
+    const probe = [...culled.keys()][0];
+    if (!probe) {
+      isUploaded = true;
+      return;
+    }
+    const before = probe.onAfterRender;
+    probe.onAfterRender = function(...args) {
+      isUploaded = true;
+      probe.onAfterRender = before;
+      before?.apply(this, args);
+    };
+  };
+  armUpload();
+  let lite = null;
+  let isFused = false;
+  let isLocked = false;
+  let batcher = null;
+  let shadow = null;
+  const castsShadow = /* @__PURE__ */ new Set();
+  const shadowProxyOf = (fused) => {
+    const positions = [];
+    const indices = [];
+    for (const mesh of fused.children) {
+      if (!mesh.isMesh || !mesh.castShadow) continue;
+      const geometry2 = mesh.geometry.clone().applyMatrix4(mesh.matrix);
+      const offset = positions.length / 3;
+      const position = geometry2.attributes.position;
+      for (let at = 0; at < position.count; at++) positions.push(position.getX(at), position.getY(at), position.getZ(at));
+      const index = geometry2.index ? Array.from(geometry2.index.array) : Array.from({ length: position.count }, (_, at) => at);
+      for (const vertex of index) indices.push(vertex + offset);
+      geometry2.dispose();
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    geometry.setIndex(indices);
+    geometry.computeBoundingSphere();
+    const proxy = new THREE.Mesh(geometry, new THREE.MeshBasicMaterial({ colorWrite: false, depthWrite: false }));
+    proxy.name = "vehicle-shadow";
+    markKitOrigin2(proxy, { owner: "game-vehicles-three", kind: "vehicle", id: root.name });
+    proxy.castShadow = true;
+    proxy.userData.skipLite = true;
+    proxy.raycast = () => void 0;
+    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) {
+      if (now() - changedAt >= VEHICLE_REBATCH_AFTER_MS) batchLocked();
+      return;
+    }
+    if (!batcher) {
+      lite ?? (lite = build());
+      lite.visible = isFused;
+      shadow ?? (shadow = shadowProxyOf(lite));
+      shadow.visible = !isFused;
+      full.traverse((object) => {
+        if (!object.isMesh || !object.castShadow) return;
+        castsShadow.add(object);
+        object.castShadow = false;
+      });
+      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;
+    }
+    if (!batcher) return;
+    if (batcher.update() > 0) changedAt = now();
+    if (batcher.stats().batched === 0 && batcher.stats().released > 0) {
+      batcher.dispose();
+      batcher = null;
+    }
+  };
+  const build = () => {
+    root.updateMatrixWorld(true);
+    const inverse = new THREE.Matrix4().copy(root.matrixWorld).invert();
+    const textured = [];
+    full.traverse((object) => {
+      if (!object.isMesh || object.userData.skipLite || !isShown(object, full)) return;
+      const materials = Array.isArray(object.material) ? object.material : [object.material];
+      if (materials.some((material) => material?.map && !/plate/i.test(material.name ?? "")) && !/plate/i.test(object.name ?? "")) textured.push(object);
+    });
+    for (const mesh of textured) mesh.userData.skipLite = true;
+    const fusion = fuse(THREE, { ...context, vehicle: full }, inverse, null, primaryPaint(context), kit.lodHiddenMaterials());
+    for (const mesh of textured) delete mesh.userData.skipLite;
+    const group = new THREE.Group();
+    group.name = "vehicle-lite";
+    markKitOrigin2(group, { owner: "game-vehicles-three", kind: "vehicle", id: root.name });
+    for (const mesh of liteMeshes(THREE, fusion, liteMaterials(THREE, kit.studioEnvironment()))) group.add(mesh);
+    for (const mesh of textured) {
+      const copy = new THREE.Mesh(mesh.geometry, mesh.material);
+      copy.matrixAutoUpdate = false;
+      copy.matrix.multiplyMatrices(inverse, mesh.matrixWorld);
+      copy.castShadow = mesh.castShadow;
+      copy.receiveShadow = mesh.receiveShadow;
+      group.add(copy);
+    }
+    root.add(group);
+    return group;
+  };
+  const show = (shouldFuse) => {
+    if (shouldFuse === isFused) return;
+    isFused = shouldFuse;
+    full.visible = !shouldFuse;
+    if (lite) lite.visible = shouldFuse;
+    if (shadow) shadow.visible = !shouldFuse;
+  };
+  const api = {
+    update(distance, touched, posed = false) {
+      if (touched && !isLocked) changedAt = now();
+      isLocked || (isLocked = touched);
+      if (keyOf() !== modelKey) {
+        changedAt = now();
+        api.dispose();
+        armUpload();
+      }
+      if (!isUploaded) return show(false);
+      if (culled.size > 0) {
+        for (const [mesh, wasCulled] of culled) mesh.frustumCulled = wasCulled;
+        culled.clear();
+      }
+      const shouldFuse = !isLocked && !posed && distance > (isFused ? VEHICLE_LOD_DISTANCE * 0.9 : VEHICLE_LOD_DISTANCE);
+      if (shouldFuse && !lite) lite = build();
+      show(shouldFuse);
+      if (!shouldFuse) drawFull();
+    },
+    get fused() {
+      return isFused;
+    },
+    dispose() {
+      show(false);
+      batcher?.dispose();
+      batcher = null;
+      for (const mesh of castsShadow) mesh.castShadow = true;
+      castsShadow.clear();
+      shadow?.removeFromParent();
+      shadow?.geometry.dispose();
+      shadow = null;
+      if (!lite) return;
+      lite.removeFromParent();
+      lite.traverse((object) => object.geometry?.dispose());
+      lite = null;
+    }
+  };
+  return api;
+}
+
+// src/cabin-smoke.ts
+import { cabinEnclosure } from "@adatechnology/game-vehicles";
+function createCabinSmoke() {
+  const tracked = /* @__PURE__ */ new Map();
+  const end = (id, entry, effects) => {
+    if (entry.declared) effects?.enclose?.(id, null);
+    tracked.delete(id);
+  };
+  return {
+    track(id, source, frame) {
+      tracked.set(id, { source, frame, declared: false, placed: false });
+    },
+    untrack(id, effects) {
+      const entry = tracked.get(id);
+      if (entry) end(id, entry, effects);
+    },
+    sync(effects) {
+      if (!effects?.enclose) return;
+      for (const [id, entry] of tracked) {
+        if (!entry.frame.parent) {
+          if (entry.placed) end(id, entry, effects);
+          continue;
+        }
+        entry.placed = true;
+        const enclosure = cabinEnclosure(entry.source, { frame: entry.frame });
+        if (enclosure || entry.declared) effects.enclose(id, enclosure);
+        entry.declared = enclosure !== null;
+      }
+    },
+    clear(effects) {
+      for (const [id, entry] of [...tracked]) end(id, entry, effects);
+    },
+    ids: () => [...tracked.keys()]
+  };
+}
+
+// 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";
+
+// src/test-area/text.ts
+var scenarioIds = [
+  "vehicles_9mm_windshield",
+  "vehicles_shotgun_door",
+  "vehicles_ram_front",
+  "vehicles_engine_fire",
+  "vehicles_fuel_tank",
+  "vehicles_unbolt_wheel",
+  "vehicles_tear_bumper",
+  "vehicles_break_mirror",
+  "vehicles_kill_battery",
+  "vehicles_rollover",
+  "vehicles_melt",
+  "vehicles_burnt_wreck",
+  "vehicles_drive_arcade",
+  "vehicles_drive_semi"
+];
+var VEHICLE_SCENARIO_IDS = scenarioIds;
+var PAGE_SCENARIO_ALIASES = {
+  veiculos_9mm_parabrisa: "vehicles_9mm_windshield",
+  veiculos_espingarda_porta: "vehicles_shotgun_door",
+  veiculos_bater_frente: "vehicles_ram_front",
+  veiculos_fogo_motor: "vehicles_engine_fire",
+  veiculos_tanque: "vehicles_fuel_tank",
+  veiculos_soltar_roda: "vehicles_unbolt_wheel",
+  veiculos_arrancar_parachoque: "vehicles_tear_bumper",
+  veiculos_quebrar_retrovisor: "vehicles_break_mirror",
+  veiculos_matar_bateria: "vehicles_kill_battery",
+  veiculos_capotar: "vehicles_rollover",
+  veiculos_derreter: "vehicles_melt"
+};
+var PAGE_ITEM_ALIASES = {
+  hatch: "hatch",
+  sedan: "sedan",
+  picape: "pickup",
+  moto: "sport_bike",
+  caminhao: "box_truck",
+  onibus: "city_bus",
+  tanque: "battle_tank",
+  helicoptero: "attack_helicopter"
+};
+var TEXT = {
+  en: {
+    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", 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)",
+      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" },
+      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", 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",
+      vehicles_ram_front: "Vehicles: ram the front",
+      vehicles_engine_fire: "Vehicles: fire on the engine",
+      vehicles_fuel_tank: "Vehicles: shoot the fuel tank (leaks, ignites, explodes)",
+      vehicles_unbolt_wheel: "Vehicles: unbolt the wheel with the wrench",
+      vehicles_tear_bumper: "Vehicles: tear off the bumper",
+      vehicles_break_mirror: "Vehicles: break the mirror",
+      vehicles_kill_battery: "Vehicles: kill the battery (lights go out)",
+      vehicles_rollover: "Vehicles: roll over",
+      vehicles_melt: "Vehicles: melt (long fire burns the tyres)",
+      vehicles_drive_arcade: "Vehicles: arcade driving down a lane that ends in a wall",
+      vehicles_drive_semi: "Vehicles: semi-simulation braking on dry, wet and mud",
+      vehicles_burnt_wreck: "Vehicles: the burnt sedan comes out of the kit burnt, with the glass gone"
+    },
+    checks: {
+      windshield_holes: "Windshield: {0} hole(s), went through {1:b} (expected: 1, true)",
+      windshield_cracks: "Windshield cracked: {0} crack(s), state {1} (expected: damaged)",
+      door_marks: "Front left door: {0} hole(s), {1} dent(s), hp {2}/{3} (expected: 2 marks or more)",
+      front_crush: "Front crushed: bumper {0} dent(s), hood {1} (expected: 1 or more each)",
+      bumper_off: "The bumper came off: {0} (expected: bumper_front)",
+      engine_burning: "Engine: burning {0:b}, {1} \xB0C (expected: true, above 250)",
+      ignite_lines: "Ignite lines in the log: {0} (expected: 1 or more)",
+      tank_leaking: "Tank leaking: {0} leak(s), {1} L left (expected: 1 or more, below 55)",
+      ignited: "Ignited: {0} ignite line(s) (expected: 1 or more)",
+      exploded: "Exploded: {0} explosion(s) (expected: 1)",
+      wheel_wrench: "Wrench on the wheel: bolts {0:open}, {1} group(s), {2} detach line(s) (expected: open, 2 or more, 1)",
+      loose_parts: "Loose parts: {0} (expected: bumper_front)",
+      mirror_broken: "Left mirror: {0} (expected: broken)",
+      battery_before: "Before: lights on and it starts (expected: yes)",
+      battery_after: "No battery: lights {0:on}, start {1:b} (expected: off, false)",
+      rolled_over: "Rolled over: {0:b} (expected: true)",
+      roof: "Roof: hp {0}/{1}, {2} dent(s) (expected: below max, 1 or more)",
+      tyre_melt: "Tyre: {0}, melted {1}%, {2} melt line(s) (expected: melted or above 50%)",
+      arcade_crash: "Arcade: the wall is hit at {0} m/s (expected: the crash above 4 m/s, at most {1})",
+      arcade_bounce: "Arcade: the car bounces back at {0} m/s (expected: below 0)",
+      arcade_noise: "Arcade: {0} engine noise(s) and {1} crash noise(s) (expected: 1 or more each)",
+      semi_order: "Semi: braking from 80 km/h takes dry {0} m, wet {1} m, mud {2} m (expected: dry shorter than wet shorter than mud)",
+      semi_mud: "Semi: a 2WD car on mud {0:on} (expected: bogged on, a bog event)",
+      wreck_burnt: "Burnt sedan: burnt flag {0:b} (expected: yes)",
+      wreck_glass: "Burnt sedan: {0} glass zone(s), {1} still above 0 (expected: 1 or more, none above 0)"
+    }
+  },
+  "pt-BR": {
+    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", 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)",
+      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" },
+      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", 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",
+      vehicles_ram_front: "Ve\xEDculos: bater de frente",
+      vehicles_engine_fire: "Ve\xEDculos: fogo no motor",
+      vehicles_fuel_tank: "Ve\xEDculos: atirar no tanque (vaza, pega fogo, explode)",
+      vehicles_unbolt_wheel: "Ve\xEDculos: soltar a roda com a chave inglesa",
+      vehicles_tear_bumper: "Ve\xEDculos: arrancar o para-choque",
+      vehicles_break_mirror: "Ve\xEDculos: quebrar o retrovisor",
+      vehicles_kill_battery: "Ve\xEDculos: matar a bateria (far\xF3is apagam)",
+      vehicles_rollover: "Ve\xEDculos: capotar",
+      vehicles_melt: "Ve\xEDculos: derreter (fogo longo queima os pneus)",
+      vehicles_drive_arcade: "Ve\xEDculos: dire\xE7\xE3o arcade numa pista que acaba num muro",
+      vehicles_drive_semi: "Ve\xEDculos: frenagem da semissimula\xE7\xE3o no seco, no molhado e na lama",
+      vehicles_burnt_wreck: "Ve\xEDculos: o sed\xE3 queimado sai do kit queimado, sem os vidros"
+    },
+    checks: {
+      windshield_holes: "Para-brisa: {0} furo(s), atravessou {1:b} (esperado: 1, sim)",
+      windshield_cracks: "Para-brisa trincou: {0} trinca(s), estado {1} (esperado: damaged)",
+      door_marks: "Porta dianteira esquerda: {0} furo(s), {1} amassado(s), vida {2}/{3} (esperado: 2 marcas ou mais)",
+      front_crush: "Frente amassada: para-choque {0} amassado(s), cap\xF4 {1} (esperado: 1 ou mais cada)",
+      bumper_off: "O para-choque soltou: {0} (esperado: bumper_front)",
+      engine_burning: "Motor: pegando fogo {0:b}, {1} \xB0C (esperado: sim, acima de 250)",
+      ignite_lines: "Linhas de igni\xE7\xE3o no log: {0} (esperado: 1 ou mais)",
+      tank_leaking: "Tanque vazando: {0} vazamento(s), {1} L restantes (esperado: 1 ou mais, menos de 55)",
+      ignited: "Pegou fogo: {0} linha(s) de igni\xE7\xE3o (esperado: 1 ou mais)",
+      exploded: "Explodiu: {0} explos\xE3o (esperado: 1)",
+      wheel_wrench: "Chave na roda: parafusos {0:open}, {1} grupo(s), {2} linha(s) de soltura (esperado: soltos, 2 ou mais, 1)",
+      loose_parts: "Pe\xE7as soltas: {0} (esperado: bumper_front)",
+      mirror_broken: "Retrovisor esquerdo: {0} (esperado: broken)",
+      battery_before: "Antes: far\xF3is acesos e d\xE1 partida (esperado: sim)",
+      battery_after: "Sem bateria: far\xF3is {0:on}, partida {1:b} (esperado: apagados, n\xE3o)",
+      rolled_over: "Capotou: {0:b} (esperado: sim)",
+      roof: "Teto: vida {0}/{1}, {2} amassado(s) (esperado: menos que o m\xE1ximo, 1 ou mais)",
+      tyre_melt: "Pneu: {0}, derretido {1}%, {2} linha(s) de derretimento (esperado: melted ou mais de 50%)",
+      arcade_crash: "Arcade: bate no muro a {0} m/s (esperado: a batida acima de 4 m/s, no m\xE1ximo {1})",
+      arcade_bounce: "Arcade: o carro volta a {0} m/s (esperado: abaixo de 0)",
+      arcade_noise: "Arcade: {0} ru\xEDdo(s) de motor e {1} de batida (esperado: 1 ou mais de cada)",
+      semi_order: "Semi: frear de 80 km/h leva no seco {0} m, no molhado {1} m, na lama {2} m (esperado: seco menor que molhado menor que lama)",
+      semi_mud: "Semi: um carro 2WD na lama {0:on} (esperado: atolado, com evento de atolamento)",
+      wreck_burnt: "Sed\xE3 queimado: marca de queimado {0:b} (esperado: sim)",
+      wreck_glass: "Sed\xE3 queimado: {0} zona(s) de vidro, {1} ainda acima de 0 (esperado: 1 ou mais, nenhuma acima de 0)"
+    }
+  }
+};
+function fill(text, locale, template, ...values) {
+  return template.replace(/\{(\d+)(?::(b|open|on))?\}/g, (_match, index, kind) => {
+    const value = values[Number(index)];
+    if (kind === "b") return locale === "en" ? String(value) : value ? text.words.yes : text.words.no;
+    if (kind === "open") return value ? text.words.open : text.words.tight;
+    if (kind === "on") return value ? text.words.on : text.words.off;
+    return String(value);
+  });
+}
+
+// src/test-area/scenarios.ts
+var add = (p, dx, dy, dz) => [p[0] + dx, p[1] + dy, p[2] + dz];
+var createScenarios = (deps) => {
+  const { text, locale } = deps;
+  const say = (id, ...values) => fill(text, locale, text.checks[id], ...values);
+  const scenario = (id, run) => ({ id, name: text.scenarios[id] ?? id, run });
+  const put = (room, item, z = -7) => {
+    const spawned = room.spawn(item, [0, 0, z], 0);
+    return { id: spawned.objectId, d: spawned.root.userData.destructible };
+  };
+  const part = (room, v, id) => room.world.part(v.id, id);
+  const events = (room, type, v) => room.log.entries({ type, objectId: v.id }).length;
+  return [
+    scenario("vehicles_9mm_windshield", ({ room, step, expect }) => {
+      const v = put(room, "hatch");
+      const c = v.d.partWorldCenter("windshield");
+      room.setTool("pistol_9mm");
+      room.waitUntilReady();
+      room.look(add(c, 0, 0.5, 3), c);
+      step(0.1);
+      room.use();
+      step(0.4);
+      const w = part(room, v, "windshield");
+      expect(w.holes.length >= 1 && !!w.holes[0]?.through, say("windshield_holes", w.holes.length, w.holes[0]?.through));
+      expect(w.cracks.length >= 1 && w.status === "damaged", say("windshield_cracks", w.cracks.length, w.status));
+    }),
+    scenario("vehicles_shotgun_door", ({ room, step, expect }) => {
+      const v = put(room, "sedan");
+      const c = v.d.partWorldCenter("door_front_left");
+      room.setTool("shotgun_pump_12");
+      room.waitUntilReady();
+      room.look(add(c, 2.5, 0, 0), c);
+      step(0.1);
+      room.use();
+      step(0.4);
+      const p = part(room, v, "door_front_left");
+      const marks = p.holes.length + p.dents.length;
+      expect(marks >= 2 && p.hp < p.maxHp, say("door_marks", p.holes.length, p.dents.length, Math.round(p.hp), p.maxHp));
+    }),
+    scenario("vehicles_ram_front", ({ room, step, expect }) => {
+      const v = put(room, "hatch");
+      const c = v.d.partWorldCenter("bumper_front");
+      room.world.hit(v.id, { type: "blunt", point: c, direction: [0, 0, -1], energy: 45e3, radius: 0.6, source: "teste" });
+      step(2.5);
+      const b = part(room, v, "bumper_front");
+      const h = part(room, v, "hood");
+      expect(b.dents.length >= 1 && h.dents.length >= 1, say("front_crush", b.dents.length, h.dents.length));
+      const det = v.d.detachedParts();
+      expect(det.indexOf("bumper_front") >= 0, say("bumper_off", det.join(", ")));
+    }),
+    scenario("vehicles_engine_fire", ({ room, step, expect }) => {
+      const v = put(room, "pickup");
+      const c = v.d.partWorldCenter("engine");
+      for (let i = 0; i < 80; i++) {
+        room.world.hit(v.id, { type: "fire", point: c, temperature: 900, radius: 0.5, duration: 0.1, source: "teste" });
+        step(0.1);
+      }
+      const e = part(room, v, "engine");
+      expect(e.burning && e.temperature > 250, say("engine_burning", e.burning, Math.round(e.temperature)));
+      expect(events(room, "ignite", v) >= 1, say("ignite_lines", events(room, "ignite", v)));
+    }),
+    scenario("vehicles_fuel_tank", ({ room, step, expect }) => {
+      const v = put(room, "hatch");
+      const spec = v.d.describe().parts.filter((p) => p.id === "fuel_tank")[0];
+      const c = v.d.partWorldCenter("fuel_tank");
+      const low = [c[0], c[1] - spec.shape.size[1] / 2 + 0.06, c[2]];
+      room.setTool("pistol_9mm");
+      room.waitUntilReady();
+      room.look(add(low, 0, 0, -2.5), low);
+      step(0.1);
+      room.use();
+      step(1);
+      const t = part(room, v, "fuel_tank");
+      const nl = v.d.status().leaking.length;
+      expect(nl >= 1 && t.liters < 55, say("tank_leaking", nl, t.liters.toFixed(1)));
+      for (let i = 0; i < 160 && !events(room, "explode", v); i++) {
+        room.world.hit(v.id, { type: "fire", point: c, temperature: 900, radius: 0.6, duration: 0.1, source: "teste" });
+        step(0.1);
+      }
+      expect(events(room, "ignite", v) >= 1, say("ignited", events(room, "ignite", v)));
+      step(2);
+      expect(events(room, "explode", v) === 1 && v.d.status().exploded, say("exploded", events(room, "explode", v)));
+      const vc = v.d.partWorldCenter("engine");
+      room.look(add(vc, 4, 0, -3), vc);
+    }),
+    scenario("vehicles_unbolt_wheel", ({ room, step, expect }) => {
+      const v = put(room, "sedan");
+      const joint = "wheel_front_left~underbody";
+      const c = v.d.partWorldCenter("wheel_front_left");
+      room.setTool("wrench");
+      for (let k = 0; k < 120 && room.world.disassemble(v.id, joint, "wrench", 0.1) < 1; k++) step(0.1);
+      step(1);
+      const st = room.world.state(v.id);
+      const open = !!st.joints.filter((j) => j.id === joint)[0]?.open;
+      expect(open && st.groups.length >= 2 && events(room, "detach", v) >= 1, say("wheel_wrench", open, st.groups.length, events(room, "detach", v)));
+      step(2);
+      room.look(add(c, 2.2, 0, 0.2), add(c, 0, -0.1, 0));
+    }),
+    scenario("vehicles_tear_bumper", ({ room, step, expect }) => {
+      const v = put(room, "hatch");
+      const c = v.d.partWorldCenter("bumper_front");
+      room.world.hit(v.id, { type: "blunt", point: c, direction: [0, 0, -1], energy: 3e4, radius: 0.6, source: "teste" });
+      step(2.5);
+      const det = v.d.detachedParts();
+      expect(det.indexOf("bumper_front") >= 0, say("loose_parts", det.join(", ")));
+      room.look(add(c, 2, 0, 3.5), add(c, 0, 0, -0.5));
+    }),
+    scenario("vehicles_break_mirror", ({ room, step, expect }) => {
+      const v = put(room, "sedan");
+      const c = v.d.partWorldCenter("mirror_left");
+      room.world.hit(v.id, { type: "blunt", point: c, direction: [-1, 0, 0], energy: 2500, radius: 0.1, source: "teste" });
+      step(2);
+      const m = part(room, v, "mirror_left");
+      expect(m.status === "broken" && v.d.state().groups.length >= 1, say("mirror_broken", m.status));
+    }),
+    scenario("vehicles_kill_battery", ({ room, step, expect }) => {
+      const v = put(room, "pickup");
+      expect(v.d.status().lightsOn && v.d.status().canStart, say("battery_before"));
+      room.playAnimation("open_hood", v.id);
+      step(1.5);
+      for (let i = 0; i < 80 && room.world.disassemble(v.id, "battery~underbody", "wrench", 0.1) < 1; i++) step(0.1);
+      step(0.5);
+      const s = v.d.status();
+      expect(!s.lightsOn && !s.canStart && !s.canDrive, say("battery_after", s.lightsOn, s.canStart));
+    }),
+    scenario("vehicles_rollover", ({ room, step, expect }) => {
+      const v = put(room, "sedan");
+      const maxRoof = v.d.describe().parts.filter((p) => p.id === "roof")[0].hp;
+      v.d.rollover();
+      step(8);
+      const roof = part(room, v, "roof");
+      expect(!!v.d.vehicle.flipped, say("rolled_over", !!v.d.vehicle.flipped));
+      expect(roof.hp < maxRoof && roof.dents.length >= 1, say("roof", Math.round(roof.hp), maxRoof, roof.dents.length));
+    }),
+    scenario("vehicles_melt", ({ room, step, expect }) => {
+      const v = put(room, "hatch");
+      const c = v.d.partWorldCenter("tyre_front_left");
+      for (let i = 0; i < 60; i++) {
+        room.world.hit(v.id, { type: "fire", point: c, temperature: 900, radius: 0.7, duration: 0.1, source: "teste" });
+        step(0.1);
+      }
+      step(30);
+      const t = part(room, v, "tyre_front_left");
+      expect(events(room, "melt", v) >= 1 && (t.status === "melted" || t.melt > 0.5), say("tyre_melt", t.status, Math.round(t.melt * 100), events(room, "melt", v)));
+    }),
+    // new in the kit: the burnt wreck comes ready from the kit (the fleet's `burnt` scenario built into the vehicle), no damage applied by the area
+    scenario("vehicles_burnt_wreck", ({ room, expect }) => {
+      const c = room.spawn("sedan_burnt", [0, 0, -7], 0).root.userData.vehicle;
+      expect(c.zoneState.flags.burnt === true, say("wreck_burnt", c.zoneState.flags.burnt === true));
+      const glass = c.zones.filter((z) => z.type === "glass");
+      const up = glass.filter((z) => (c.zoneState.health[z.id] ?? 100) > 0);
+      expect(glass.length >= 1 && up.length === 0, say("wreck_glass", glass.length, up.length));
+    }),
+    // new in the kit: the drivers, headless (no vehicle is spawned)
+    scenario("vehicles_drive_arcade", ({ expect }) => {
+      const driver = createArcadeDriver();
+      const wallX = 60;
+      driver.place(0, 0, 0);
+      const world = { blocked: (x, z, yaw) => vehicleCorners(driver.spec, x, z, yaw).some(([px]) => px >= wallX) };
+      let crashSpeed = 0;
+      let engine = 0;
+      let crashNoise = 0;
+      let after = 0;
+      for (let t = 0; t < 12; t += 1 / 60) {
+        const { events: out } = driver.step({ throttle: 1, brake: 0, steer: 0, handbrake: false }, 1 / 60, world);
+        for (const e of out) {
+          if (e.type === "crash" && !crashSpeed) {
+            crashSpeed = e.speed;
+            after = driver.state.v;
+          }
+          if (e.type === "noise" && e.source === "engine") engine++;
+          if (e.type === "noise" && e.source === "crash") crashNoise++;
+        }
+      }
+      expect(crashSpeed > driver.spec.crash.damageSpeed && crashSpeed <= driver.spec.maxForward + 1e-6, say("arcade_crash", crashSpeed.toFixed(1), driver.spec.maxForward));
+      expect(after < 0, say("arcade_bounce", after.toFixed(1)));
+      expect(engine >= 1 && crashNoise >= 1, say("arcade_noise", engine, crashNoise));
+    }),
+    scenario("vehicles_drive_semi", ({ expect }) => {
+      const surfaces = createSurfaces();
+      const coast = { throttle: 0, brake: 0, steer: 0, handbrake: false };
+      const dt = 1 / 60;
+      const world = (surface) => ({ ground: () => ({ surface }) });
+      const braking = (surface) => {
+        const driver = createSemiSimDriver({}, { surfaces });
+        driver.state.u = 80 / 3.6;
+        for (let t = 0; t < 1; t += dt) driver.step({ ...coast, throttle: 0.3 }, dt, world(surface));
+        driver.state.u = 80 / 3.6;
+        const start = driver.state.x;
+        for (let t = 0; t < 30 && driver.state.u > 0.1; t += dt) driver.step({ ...coast, brake: 1 }, dt, world(surface));
+        return driver.state.x - start;
+      };
+      const dry = braking("dry_asphalt");
+      const wet = braking("wet_asphalt");
+      const mud = braking("mud");
+      expect(dry < wet && wet < mud, say("semi_order", dry.toFixed(1), wet.toFixed(1), mud.toFixed(1)));
+      const bog = createSemiSimDriver({}, { surfaces });
+      let bogged = 0;
+      for (let t = 0; t < 8; t += dt) bogged += bog.step({ ...coast, throttle: 1 }, dt, world("mud")).events.filter((e) => e.type === "bogged").length;
+      expect(bog.state.bogged && bogged >= 1, say("semi_mud", bog.state.bogged));
+    })
+  ];
+};
+
+// 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",
+  explode: "car_fuel_tank",
+  glass: "glass_burst",
+  sparks: "impact_metal",
+  leak: "vehicle_leak",
+  leakIgnited: "vehicle_leak_ignited",
+  exhaust: "vehicle_exhaust"
+};
+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 = {}) {
+  const fleet = options.fleet ?? { colorFromSeed, fleetDims, installFleet, paintPalettes, paletteOf };
+  const locale = options.locale ?? "pt-BR";
+  const text = TEXT[locale] ?? TEXT["pt-BR"];
+  const keys = options.vehicles ?? DEFAULT_TEST_VEHICLES;
+  const wrecks = options.wrecks ?? DEFAULT_TEST_WRECKS;
+  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", damage: "none" };
+  const kits = /* @__PURE__ */ new WeakMap();
+  const placed = /* @__PURE__ */ new Map();
+  const cabins = createCabinSmoke();
+  let host = null;
+  let three = null;
+  let counter = 0;
+  let helpersShown = "";
+  let axes = [];
+  let lane = null;
+  const effects = () => host?.effects;
+  const audio = () => host?.audio;
+  let carSound;
+  const stopEngine = () => {
+    carSound?.dispose();
+    carSound = void 0;
+  };
+  const particleMaterials = {
+    own: (build) => isRenderPools(host?.pools) ? host.pools.materials.own(build) : build(),
+    release: (material) => isRenderPools(host?.pools) ? host.pools.materials.release(material) : material.dispose?.()
+  };
+  const kitFor = (THREE) => {
+    three = THREE;
+    let kit = kits.get(THREE);
+    if (!kit) {
+      if (options.createKit) kit = options.createKit(THREE);
+      else {
+        kit = createVehicleKit({ THREE, locale, particleMaterials, effects: () => host?.effects, ...options.document ? { document: options.document } : {} });
+        fleet.installFleet(kit);
+      }
+      kits.set(THREE, kit);
+    }
+    return kit;
+  };
+  const paletteFor = (key) => settings.palette === "civil" ? fleet.paintPalettes.civil : settings.palette === "military" ? fleet.paintPalettes.military : fleet.paletteOf(key);
+  const paintOf = (entry) => {
+    if (!settings.paint) return;
+    entry.lod?.dispose();
+    delete entry.lod;
+    const color = fleet.colorFromSeed(settings.seed + entry.index, paletteFor(entry.key));
+    if (!entry.paint) {
+      const vehicle = entry.item.vehicle;
+      const primary = primaryPaint(entry.item.vehicle);
+      if (!primary) return;
+      entry.paint = primary.clone();
+      vehicle.vehicle.traverse((mesh) => {
+        if (!mesh.isMesh) return;
+        if (Array.isArray(mesh.material)) mesh.material = mesh.material.map((m) => m === primary ? entry.paint : m);
+        else if (mesh.material === primary) mesh.material = entry.paint;
+      });
+    }
+    entry.paint.color.set(color);
+  };
+  const item = ({ key, id: itemKey, scenario }) => ({
+    id: itemKey,
+    name: text.items[itemKey] ?? key,
+    movable: false,
+    // the first build of a vehicle takes most of a second
+    slow: true,
+    build: (THREE) => {
+      const kit = kitFor(THREE);
+      const built = buildVehicleItem(kit, key, { lod: settings.quality === "lite", ...scenario ? { scenario } : {} });
+      built.root.userData.kit = kit;
+      const entry = { root: built.root, key, ...scenario ? { scenario } : {}, item: built, index: counter++, helpers: [] };
+      placed.set(built.root.uuid, entry);
+      measure(entry);
+      paintOf(entry);
+      return built.root;
+    },
+    impl: (root, id) => {
+      const r = root;
+      const kit = r.userData.kit;
+      const d = createVehicleDestructible2(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemKey] ?? key, creaseQueue });
+      tapEffects(d);
+      const setPartPose = d.setPartPose?.bind(d);
+      {
+        const rests = new Map(d.describe().parts.map((part) => [part.id, part.rotation ?? [0, 0, 0]]));
+        d.setPartPose = (partId, position, rotation) => {
+          const entry = [...placed.values()].find((candidate) => candidate.root === root);
+          const rest = rests.get(partId) ?? [0, 0, 0];
+          const isOpen = (rotation ?? [0, 0, 0]).some((angle, axis) => Math.abs(angle - (rest[axis] ?? 0)) > LEAF_REST_RADIANS);
+          if (entry) {
+            entry.posedParts ?? (entry.posedParts = /* @__PURE__ */ new Set());
+            if (isOpen) entry.posedParts.add(partId);
+            else entry.posedParts.delete(partId);
+          }
+          return setPartPose?.(partId, position, rotation);
+        };
+      }
+      const hitBody = d.hit.bind(d);
+      d.hit = (h) => {
+        const entry = [...placed.values()].find((candidate) => candidate.root === root);
+        if (entry) entry.touched = true;
+        return hitBody(h);
+      };
+      cabins.track(id, d, root);
+      r.userData.destructible = d;
+      return d;
+    },
+    ...clipsOf(key) ? { animations: clipsOf(key) } : {}
+  });
+  const clipCache = /* @__PURE__ */ new Map();
+  const clipsOf = (key) => {
+    const THREE = options.three ?? globalThis.THREE;
+    if (!THREE) return void 0;
+    if (!clipCache.has(key)) {
+      const kit = kitFor(THREE);
+      const built = buildVehicleItem(kit, key);
+      const d = createVehicleDestructible2(kit, built.vehicle, { id: `${itemId(key)}_clips`, frame: built.root, headless: true });
+      clipCache.set(key, d.animations());
+      kit.dispose(built.vehicle);
+    }
+    return clipCache.get(key);
+  };
+  const tapEffects = (d) => {
+    const request = (events) => {
+      const fx = effects();
+      if (!fx) return;
+      for (const e of events) {
+        const position = e.point ?? e.worldPoint;
+        if (!position) continue;
+        if (e.type === "ignite") fx.play({ effect: /fuel_tank|tank/.test(e.part ?? "") ? effectIds.leakIgnited : effectIds.ignite, point: position });
+        else if (e.type === "explode") fx.play({ effect: effectIds.explode, point: position });
+        else if (e.type === "leak") fx.play({ effect: effectIds.leak, point: position });
+        else if (e.type === "fracture" && /glass|window|windshield/.test(e.part ?? "")) fx.play({ effect: effectIds.glass, point: position });
+        else if (e.type === "hole") fx.play({ effect: /glass|window|windshield/.test(e.part ?? "") ? effectIds.glass : effectIds.sparks, point: position });
+      }
+    };
+    const hit = d.hit.bind(d);
+    d.hit = (h) => {
+      const events = hit(h);
+      request(events);
+      return events;
+    };
+    if (d.update) {
+      const update = d.update.bind(d);
+      d.update = (dt) => {
+        const events = update(dt);
+        request(events);
+        return events;
+      };
+    }
+  };
+  const rootMatrix = (entry) => {
+    const m = new three.Matrix4().copy(entry.root.matrixWorld).invert();
+    return m.multiply(entry.item.vehicle.vehicle.matrixWorld);
+  };
+  const measure = (entry) => {
+    if (entry.size) return entry.size;
+    entry.root.updateMatrixWorld(true);
+    const inverse = new three.Matrix4().copy(entry.root.matrixWorld).invert();
+    const bounds = new three.Box3();
+    const low = new three.Box3();
+    const piece = new three.Box3();
+    const matrix = new three.Matrix4();
+    entry.root.traverse((mesh) => {
+      if (!mesh.isMesh || !mesh.geometry || mesh.userData.ghost) return;
+      for (let p = mesh; p; p = p.parent) if (p.visible === false) return;
+      if (mesh.userData.helper) return;
+      mesh.geometry.computeBoundingBox();
+      piece.copy(mesh.geometry.boundingBox).applyMatrix4(matrix.multiplyMatrices(inverse, mesh.matrixWorld));
+      bounds.union(piece);
+      if (piece.min.y < BODY_HEIGHT) low.union(piece);
+    });
+    const size = bounds.getSize(new three.Vector3());
+    entry.size = { length: size.z, width: size.x, height: size.y };
+    if (!low.isEmpty()) entry.footprint = { minX: low.min.x, maxX: low.max.x, minZ: low.min.z, maxZ: low.max.z };
+    return entry.size;
+  };
+  const clearHelpers = () => {
+    for (const entry of placed.values()) {
+      discardObject3D(entry.helpers);
+      entry.helpers = [];
+    }
+    discardObject3D(axes);
+    axes = [];
+    helpersShown = "";
+  };
+  const boxKey = () => `${host?.bench?.layer("damageables")}|${host?.bench?.layer("zones")}|${host?.bench?.layer("axes")}|${placed.size}`;
+  const refreshLayers = () => {
+    if (!host?.bench || !three) return;
+    clearHelpers();
+    const kit = [...placed.values()][0] && ([...placed.values()][0].root.userData.kit ?? void 0);
+    const mark = (entry, box, color) => {
+      const helper = new three.Box3Helper(box, color);
+      helper.userData.helper = true;
+      entry.root.add(helper);
+      entry.helpers.push(helper);
+    };
+    if (kit) {
+      for (const entry of placed.values()) {
+        if (!entry.root.parent) continue;
+        entry.root.updateMatrixWorld(true);
+        const matrix = rootMatrix(entry);
+        if (host.bench.layer("damageables")) for (const d of kit.damageables(entry.item.vehicle, matrix)) mark(entry, d.box, MATERIAL_COLOURS[d.material] ?? 16777215);
+        if (host.bench.layer("zones")) {
+          for (const zone of entry.item.vehicle.zones ?? []) {
+            if (!zone.box || zone.type === "internal") continue;
+            const box = new three.Box3(new three.Vector3(zone.box.x0, zone.box.y0, zone.box.z0), new three.Vector3(zone.box.x1, zone.box.y1, zone.box.z1)).applyMatrix4(matrix);
+            mark(entry, box, ZONE_COLOURS[zone.type] ?? 16777215);
+          }
+        }
+      }
+    }
+    if (host.bench.layer("axes")) {
+      const front = new three.ArrowHelper(new three.Vector3(0, 0, 1), new three.Vector3(0, 0.05, 0), 3, 3368703);
+      const right = new three.ArrowHelper(new three.Vector3(-1, 0, 0), new three.Vector3(0, 0.05, 0), 3, 16724787);
+      const up = new three.ArrowHelper(new three.Vector3(0, 1, 0), new three.Vector3(0, 0.05, 0), 3, 3394611);
+      for (const arrow of [front, right, up]) {
+        ;
+        host.scene.add(arrow);
+        axes.push(arrow);
+      }
+    }
+    helpersShown = boxKey();
+  };
+  const laneBlocked = footprintBlocker(
+    () => lane?.group,
+    () => lane ? { minX: -lane.car.width / 2, maxX: lane.car.width / 2, minZ: -lane.car.length / 2, maxZ: lane.car.length / 2 } : null
+  );
+  const blocked = (x, z, radius) => {
+    for (const entry of placed.values()) if (entry.footprint && footprintBlocker(entry.root, entry.footprint)(x, z, radius)) return true;
+    return laneBlocked(x, z, radius);
+  };
+  const clearLane = () => {
+    stopEngine();
+    if (!lane) return;
+    lane.group.parent?.remove(lane.group);
+    lane.wall.parent?.remove(lane.wall);
+    lane = null;
+  };
+  const startLane = () => {
+    if (!host || !three) return;
+    clearLane();
+    const kit = kitFor(three);
+    const vehicles = createVehiclesThree(three, { kit, fleet });
+    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" || 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, 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;
+    driver.place(LANE.from, LANE.z, 0);
+    const gap = () => LANE.wall - (driver.state.x + built.length / 2);
+    const decel = () => mode === "semi" ? 9 * surfaces.get(settings.surface).grip : arcade.spec.brakeAgainstMotion;
+    const brakeAt = () => lane ? lane.speed() * lane.speed() / (2 * decel()) + 3 : 3;
+    const pose = () => {
+      built.group.position.set(driver.state.x, 0, driver.state.z);
+      built.group.rotation.y = driver.state.yaw + Math.PI / 2;
+    };
+    pose();
+    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,
+      group: built.group,
+      wall,
+      mode,
+      done: false,
+      stopped: 0,
+      speed: () => "u" in driver.state ? driver.state.u : driver.state.v,
+      distance: () => driver.state.x - LANE.from,
+      step(dt) {
+        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 = 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);
+            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));
+            carSound?.crash(semi.state.u, [driver.state.x + built.length / 2, 0.5, driver.state.z]);
+          }
+        }
+        pose();
+        {
+          const speed = Math.abs(lane?.speed() ?? 0);
+          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();
+        if (fx && state.exhaust <= 0 && Math.abs(lane?.speed() ?? 0) > 0.5) {
+          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 > LANE_START_S + 1 && Math.abs(lane?.speed() ?? 0) < 0.05) {
+          state.ended = true;
+          log("end", Math.max(0, gap()));
+        }
+      }
+    };
+  };
+  const onChange = (change) => {
+    if (change.kind === "layer") return refreshLayers();
+    if (change.kind === "action") {
+      if (change.id === "repaint") for (const entry of placed.values()) paintOf(entry);
+      else if (change.id === "drive_lane") startLane();
+      else if (change.id === "clear_lane") clearLane();
+      else if (change.id === "honk") audio()?.play({ sound: soundIds.horn, position: lane ? [lane.group.position.x, 1, lane.group.position.z] : void 0 });
+      return;
+    }
+    switch (change.id) {
+      case "quality":
+        settings.quality = String(change.value);
+        break;
+      case "paint_by_seed":
+        settings.paint = Boolean(change.value);
+        for (const entry of placed.values()) paintOf(entry);
+        break;
+      case "color_seed":
+        settings.seed = Number(change.value);
+        for (const entry of placed.values()) paintOf(entry);
+        break;
+      case "palette":
+        settings.palette = String(change.value);
+        for (const entry of placed.values()) paintOf(entry);
+        break;
+      case "driving":
+        settings.driving = String(change.value);
+        break;
+      case "surface":
+        settings.surface = String(change.value);
+        break;
+      case "lane_damage":
+        settings.damage = String(change.value);
+        break;
+      default:
+        break;
+    }
+  };
+  const creaseQueue = createCreaseQueue();
+  const updateLod = (entry) => {
+    if (!host || settings.quality === "lite") return;
+    entry.lod ?? (entry.lod = createVehicleLod(entry.root.userData.kit, entry.item.vehicle, entry.root, entry.root.children[0]));
+    const at = host.player().position;
+    const distance = Math.hypot(at[0] - entry.root.position.x, at[2] - entry.root.position.z);
+    const c = entry.item.vehicle;
+    if (c && (c.rollState || c.flipped || c.blast || c.exploded)) entry.touched = true;
+    entry.lod.update(distance, entry.touched === true, entry.scenario !== void 0 || (entry.posedParts?.size ?? 0) > 0);
+  };
+  const frame = (dt) => {
+    for (const [id, entry] of placed) {
+      if (!entry.root.parent) {
+        placed.delete(id);
+        continue;
+      }
+      measure(entry);
+      updateLod(entry);
+    }
+    if (host?.bench && boxKey() !== helpersShown && (host.bench.layer("damageables") || host.bench.layer("zones") || helpersShown !== "")) refreshLayers();
+    lane?.step(dt);
+    cabins.sync(effects());
+  };
+  const count2 = () => {
+    let drawCalls = 0;
+    let triangles = 0;
+    for (const entry of placed.values()) {
+      entry.root.traverse((mesh) => {
+        if (!mesh.isMesh || mesh.userData.helper) return;
+        for (let p = mesh; p; p = p.parent) if (p.visible === false) return;
+        drawCalls += 1;
+        const g = mesh.geometry;
+        triangles += (g.index ? g.index.count : g.attributes.position.count) / 3;
+      });
+    }
+    return { drawCalls, triangles: Math.round(triangles) };
+  };
+  const boxesOf = (material) => {
+    let total = 0;
+    for (const entry of placed.values()) {
+      const kit = entry.root.userData.kit;
+      if (kit) total += kit.damageables(entry.item.vehicle).filter((d) => d.material === material).length;
+    }
+    return total;
+  };
+  const sizeError = () => {
+    let worst = 0;
+    for (const entry of placed.values()) {
+      const want = fleet.fleetDims(entry.key);
+      const got = entry.size;
+      if (!want || !got || entry.scenario) continue;
+      worst = Math.max(worst, Math.abs(got.length - want.length), Math.abs(got.width - want.width), Math.abs(got.height - want.height));
+    }
+    return Math.round(worst * 1e3);
+  };
+  return {
+    id: VEHICLES_AREA_ID,
+    name: text.name,
+    ground: { surface: "road" },
+    group: text.group,
+    get placed() {
+      return placed;
+    },
+    items: () => entries.map(item),
+    area: () => {
+      const gap = 1.6;
+      const WIDE = 6;
+      const rowOf = (list, z) => {
+        let cursor = 0;
+        const spots = list.map((entry) => {
+          const width = fleet.fleetDims(entry.key)?.width ?? 2;
+          const x = cursor + width / 2;
+          cursor += width + gap;
+          return { id: entry.id, x };
+        });
+        return { spots, z, width: Math.max(0, cursor - gap) };
+      };
+      const front = rowOf(entries.filter((e) => (fleet.fleetDims(e.key)?.width ?? 2) <= WIDE), 0);
+      const back = rowOf(entries.filter((e) => (fleet.fleetDims(e.key)?.width ?? 2) > WIDE), -16);
+      const placements = [front, back].flatMap((row) => row.spots.map(({ id, x }) => ({ item: id, position: [x - row.width / 2, 0, row.z], rotationY: 0 })));
+      return { placements, view: { eye: [0, 5, Math.max(14, front.width * 0.6)], target: [0, 1, -2] } };
+    },
+    controls: () => {
+      const surfaceIds = createSurfaces2().surfaces.map((s) => s.id);
+      return [
+        { kind: "choice", id: "quality", name: text.controls.quality, hint: text.hints.quality, options: ["high", "lite"].map((id) => ({ id, name: text.options.quality[id] })), default: "high" },
+        { kind: "boolean", id: "paint_by_seed", name: text.controls.paint_by_seed, hint: text.hints.paint_by_seed, default: false },
+        { kind: "number", id: "color_seed", name: text.controls.color_seed, min: 0, max: 999, step: 1, default: 1 },
+        { 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 },
+        { kind: "action", id: "honk", name: text.actions.honk }
+      ];
+    },
+    layers: () => ["damageables", "zones", "axes"].map((id) => ({ id, name: text.layers[id], default: false })),
+    metrics: () => [
+      { id: "vehicles", name: text.metrics.vehicles, read: () => placed.size },
+      { id: "triangles", name: text.metrics.triangles, read: () => count2().triangles },
+      { id: "draw_calls", name: text.metrics.draw_calls, read: () => count2().drawCalls },
+      { id: "size_error_mm", name: text.metrics.size_error_mm, unit: "mm", read: sizeError },
+      { id: "metal", name: text.metrics.metal, read: () => boxesOf("metal") },
+      { id: "glass", name: text.metrics.glass, read: () => boxesOf("glass") },
+      { id: "rubber", name: text.metrics.rubber, read: () => boxesOf("rubber") },
+      { id: "fuel", name: text.metrics.fuel, read: () => boxesOf("fuel") },
+      { id: "speed", name: text.metrics.speed, unit: "km/h", digits: 0, read: () => Math.round(Math.abs(lane?.speed() ?? 0) * 3.6) },
+      { id: "lane", name: text.metrics.lane, unit: "m", digits: 1, read: () => lane?.distance() ?? 0 }
+    ],
+    scenarios: () => createScenarios({ text, locale }),
+    attach(lent) {
+      host = lent;
+      three = lent.THREE;
+      const stopChange = lent.bench?.onChange(onChange);
+      const stopFrame = lent.onFrame(frame);
+      const stopBlocker = lent.addBlocker?.(blocked);
+      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();
+        stopBlocker?.();
+        stopCrease?.();
+        cabins.clear(effects());
+        clearHelpers();
+        clearLane();
+        host = null;
+      };
+    }
+  };
+}
+function loadVehiclesTestModule(room, options = {}) {
+  let three = options.three;
+  if (!three) {
+    room.loadModule({ id: "vehicles_probe", name: "Vehicles probe", group: "Vehicles", items: () => [], attach: (lent) => {
+      three = lent.THREE;
+      return () => void 0;
+    } });
+  }
+  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 { 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", 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: { 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: { 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",
+      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", 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", 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: { 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: { 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",
+      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", 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)] ?? ""));
+
+// 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 driving = null;
+  let gearbox = "automatic";
+  let lastGear = null;
+  let driveClock = 0;
+  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 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 = 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);
+      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;
+    }
+    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;
+    discardObject3D3(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, ...car.built.driverEye ? { eye: car.built.driverEye } : {} };
+  };
+  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 = 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);
+      } 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);
+        stopDriving();
+        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 "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;
+      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 (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;
+      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 : 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);
+    void steer;
+    const key = `${host.bench?.layer("mirrors")}|${host.bench?.layer("reverse_camera")}`;
+    if (key !== mirrorKey) {
+      mirrorKey = key;
+      refreshMirrors();
+    }
+    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 ?? 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) discardObject3D3(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: "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 },
+      { 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: "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") },
+      { 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);
+      lent.audio?.register?.(CABIN_BANK);
+      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,
+  classify,
+  classColor,
+  liteMaterials,
+  fuse,
+  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,
+  PAGE_SCENARIO_ALIASES,
+  PAGE_ITEM_ALIASES,
+  defaultEffectIds,
+  defaultSoundIds,
+  DEFAULT_TEST_WRECKS,
+  VEHICLES_AREA_ID,
+  DEFAULT_TEST_VEHICLES,
+  createVehiclesTestModule,
+  loadVehiclesTestModule,
+  DASHBOARD_LOOK,
+  createVehicleDashboard,
+  LAMP_RULES,
+  createVehicleLamps,
+  PROVING_TEXT,
+  PROVING_AREA_ID,
+  createProvingModule,
+  loadProvingModule
+};
+//# sourceMappingURL=chunk-MRUPKE7J.js.map