@adatechnology/game-vehicles-three 0.3.7 → 0.5.0

package/dist/index.js

@@ -1,1183 +1,26 @@
-// src/build.ts
-import { markKitOrigin } from "@adatechnology/game-contracts";
-import { colorFromSeed, fleetDims, paintPalettes, paletteOf } 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;
-}
-function createVehiclesThree(THREE, options) {
-  const kit = options.kit;
-  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) || paletteOf(groupOf(key)) === paintPalettes.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 ? colorFromSeed(seed, isMilitary(key) ? paintPalettes.military : paintPalettes.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;
-    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);
-      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);
-    } 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: fleetDims(key),
-      context: quality === "high" ? c : null,
-      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/test-area/module.ts
-import { discardObject3D } from "@adatechnology/game-shapes-three";
-import { footprintBlocker } from "@adatechnology/game-contracts";
-import { buildVehicleItem, createVehicleDestructible, createVehicleKit } from "@adatechnology/game-vehicles";
-import { createArcadeDriver as createArcadeDriver2, createSemiSimDriver as createSemiSimDriver2, createSurfaces as createSurfaces2, vehicleCorners as vehicleCorners2 } from "@adatechnology/game-vehicles-driving";
-import { colorFromSeed as colorFromSeed2, fleetDims as fleetDims2, installFleet, paintPalettes as paintPalettes2, paletteOf as paletteOf2 } from "@adatechnology/game-vehicles-fleet";
-
-// 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" },
-    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)"
-    },
-    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" }
-    },
-    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" },
-    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" },
-    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)"
-    },
-    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" }
-    },
-    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" },
-    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/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 = { engine: "engine_saw", horn: "horn", crash: "sfx_impact" };
-var DEFAULT_TEST_WRECKS = [
-  { key: "sedan_burnt", vehicle: "midsize_sedan", scenario: "burnt" },
-  { key: "hatch_burnt", vehicle: "compact_hatch", scenario: "burnt" }
-];
-
-// 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 MATERIAL_COLOURS = { metal: 13421772, glass: 4500223, rubber: 16750848, fuel: 16724736 };
-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 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" };
-  const kits = /* @__PURE__ */ new WeakMap();
-  const placed = /* @__PURE__ */ new Map();
-  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 engineLoop;
-  const stopEngine = () => {
-    engineLoop?.stop();
-    engineLoop = void 0;
-  };
-  const kitFor = (THREE) => {
-    three = THREE;
-    let kit = kits.get(THREE);
-    if (!kit) {
-      if (options.createKit) kit = options.createKit(THREE);
-      else {
-        kit = createVehicleKit({ THREE, locale, ...options.document ? { document: options.document } : {} });
-        installFleet(kit);
-      }
-      kits.set(THREE, kit);
-    }
-    return kit;
-  };
-  const paletteFor = (key) => settings.palette === "civil" ? paintPalettes2.civil : settings.palette === "military" ? paintPalettes2.military : paletteOf2(key);
-  const paintOf = (entry) => {
-    if (!settings.paint) return;
-    const color = colorFromSeed2(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 = createVehicleDestructible(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemKey] ?? key });
-      tapEffects(d);
-      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 = createVehicleDestructible(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 });
-    const built = vehicles.build("compact_hatch", { quality: "lite", seed: settings.seed });
-    const wall = new three.Mesh(new three.BoxGeometry(0.6, 2, 6), new three.MeshStandardMaterial({ color: 7829367 }));
-    wall.position.set(LANE.wall + 0.3, 1, LANE.z);
-    const scene = host.scene;
-    scene.add(built.group, wall);
-    const mode = settings.driving === "semi" ? "semi" : "arcade";
-    const surfaces = createSurfaces2();
-    const idle = { throttle: 0, brake: 0, steer: 0, handbrake: false };
-    const state = { time: 0, exhaust: 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();
-    engineLoop = audio()?.loop?.(soundIds.engine, { position: [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) return;
-        state.time += dt;
-        const braking = gap() < brakeAt() && state.time > 0.5;
-        const input = { ...idle, throttle: braking ? 0 : 1, brake: braking ? 1 : 0, steer: Math.sin(state.time * 1.4) * 0.15 };
-        if (mode === "arcade") {
-          const { events } = arcade.step(input, dt, { blocked: (x, z, yaw) => vehicleCorners2(arcade.spec, x, z, yaw).some(([px]) => px >= LANE.wall) });
-          for (const e of events) {
-            if (e.type !== "crash") continue;
-            log("crash", e.speed);
-            audio()?.play({ sound: soundIds.crash, position: [driver.state.x, 0.5, driver.state.z], volume: Math.min(1, e.speed / 15) });
-          }
-        } else {
-          semi.step(input, dt, { ground: () => ({ surface: settings.surface }) });
-          if (gap() <= 0) {
-            state.ended = true;
-            log("crash", Math.abs(semi.state.u));
-            audio()?.play({ sound: soundIds.crash, position: [driver.state.x, 0.5, driver.state.z], volume: Math.min(1, Math.abs(semi.state.u) / 15) });
-          }
-        }
-        pose();
-        {
-          const speed = Math.abs(lane?.speed() ?? 0);
-          engineLoop?.set({ volume: state.ended ? 0 : 0.035 + speed * 3e-3, frequency: 38 + speed * 7, position: [driver.state.x, 0.5, driver.state.z] });
-        }
-        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 > 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;
-      default:
-        break;
-    }
-  };
-  const frame = (dt) => {
-    for (const [id, entry] of placed) {
-      if (!entry.root.parent) {
-        placed.delete(id);
-        continue;
-      }
-      measure(entry);
-    }
-    if (host?.bench && boxKey() !== helpersShown && (host.bench.layer("damageables") || host.bench.layer("zones") || helpersShown !== "")) refreshLayers();
-    lane?.step(dt);
-  };
-  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 = fleetDims2(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 = fleetDims2(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) => (fleetDims2(e.key)?.width ?? 2) <= WIDE), 0);
-      const back = rowOf(entries.filter((e) => (fleetDims2(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: "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);
-      lent.audio?.register?.(LIBRARY_BANK);
-      return () => {
-        stopChange?.();
-        stopFrame();
-        stopBlocker?.();
-        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 }));
-}
+import {
+  DEFAULT_TEST_VEHICLES,
+  DEFAULT_TEST_WRECKS,
+  LITE_CLASSES,
+  PAGE_ITEM_ALIASES,
+  PAGE_SCENARIO_ALIASES,
+  PRUNE_BELOW,
+  VEHICLES_AREA_ID,
+  VEHICLE_LOD_DISTANCE,
+  VEHICLE_SCENARIO_IDS,
+  classColor,
+  classify,
+  createCabinSmoke,
+  createVehicleLod,
+  createVehiclesTestModule,
+  createVehiclesThree,
+  defaultEffectIds,
+  defaultSoundIds,
+  fuse,
+  liteMaterials,
+  liteMeshes,
+  loadVehiclesTestModule
+} from "./chunk-GAO7ZJP7.js";
 export {
   DEFAULT_TEST_VEHICLES,
   DEFAULT_TEST_WRECKS,
@@ -1186,9 +29,12 @@ export {
   PAGE_SCENARIO_ALIASES,
   PRUNE_BELOW,
   VEHICLES_AREA_ID,
+  VEHICLE_LOD_DISTANCE,
   VEHICLE_SCENARIO_IDS,
   classColor,
   classify,
+  createCabinSmoke,
+  createVehicleLod,
   createVehiclesTestModule,
   createVehiclesThree,
   defaultEffectIds,