@adatechnology/game-vehicles-three 0.3.7 → 0.5.0

package/dist/index.global.js

@@ -28,9 +28,12 @@ var GameVehiclesThree = (() => {
     PAGE_SCENARIO_ALIASES: () => PAGE_SCENARIO_ALIASES,
     PRUNE_BELOW: () => PRUNE_BELOW,
     VEHICLES_AREA_ID: () => VEHICLES_AREA_ID,
+    VEHICLE_LOD_DISTANCE: () => VEHICLE_LOD_DISTANCE,
     VEHICLE_SCENARIO_IDS: () => VEHICLE_SCENARIO_IDS,
     classColor: () => classColor,
     classify: () => classify,
+    createCabinSmoke: () => createCabinSmoke,
+    createVehicleLod: () => createVehicleLod,
     createVehiclesTestModule: () => createVehiclesTestModule,
     createVehiclesThree: () => createVehiclesThree,
     defaultEffectIds: () => defaultEffectIds,
@@ -42,6 +45,7 @@ var GameVehiclesThree = (() => {
   });
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
   var DEFAULT_IGNITION_RULES = {
     fillCurve: [
       [0, 0.6],
@@ -85,6 +89,38 @@ var GameVehiclesThree = (() => {
     const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
     return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
   };
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var WARNED_KEY = /* @__PURE__ */ Symbol.for("@adatechnology/game-contracts.warned");
+  var warnedKeys = () => {
+    const holder = globalThis;
+    return holder[WARNED_KEY] ?? (holder[WARNED_KEY] = /* @__PURE__ */ new Set());
+  };
+  var isProduction = () => {
+    try {
+      return process.env.NODE_ENV === "production";
+    } catch {
+      return false;
+    }
+  };
+  var isQuiet = () => globalThis.__GAME_KIT_QUIET__ === true;
+  var warnOnce = (key, message) => {
+    if (isQuiet() || isProduction()) return;
+    const seen = warnedKeys();
+    if (seen.has(key)) return;
+    seen.add(key);
+    console.warn(`[game-kit] ${message}`);
+  };
   var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
   var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
   var deepMerge = (base, patch) => {
@@ -106,10 +142,13 @@ var GameVehiclesThree = (() => {
     for (const [id, patch] of Object.entries(patches ?? {})) {
       const entry = entries.get(id);
       if (entry) entries.set(id, deepMerge(entry, patch));
+      else warnOnce(`registry.patch.${id}`, `patch for "${id}" ignored: no entry has that id`);
     }
   };
   var removeIds = (entries, ids) => {
-    for (const id of ids ?? []) entries.delete(id);
+    for (const id of ids ?? []) {
+      if (!entries.delete(id)) warnOnce(`registry.remove.${id}`, `remove of "${id}" ignored: no entry has that id`);
+    }
   };
   var KIT_ORIGIN_KEY = "kitOrigin";
   function markKitOrigin(object2, origin) {
@@ -134,6 +173,43 @@ var GameVehiclesThree = (() => {
       return lx > fp.minX - radius && lx < fp.maxX + radius && lz > fp.minZ - radius && lz < fp.maxZ + radius;
     };
   }
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing2) => `land_${surface}_${landing2}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+  var SWING_LEAD_SECONDS = { punch: 0.07, kick: 0.09, shove: 0, blade: 0.05, blunt: 0.1, chop: 0.11 };
 
   // ../game-vehicles-fleet/dist/index.js
   var military = [
@@ -24323,7 +24399,7 @@ var GameVehiclesThree = (() => {
             c2.cylinder(0.03, 0.04, 0.08, MT.chrome, sx + 2.35, fl + 0.99, -0.75);
             c2.part("fuel_tank", trl("labels.oxygen_cylinder"), null, new V3(sx + 2.35, fl + 0.5, -0.75), 0.5);
             c2.roundBox(0.04, 0.26, 0.34, 0.02, MT.screen, 0.1, 1.7, 0.5);
-            const light = c2.roundBox(
+            const lightPanel = c2.roundBox(
               2.3,
               0.02,
               W - 0.3,
@@ -24333,7 +24409,7 @@ var GameVehiclesThree = (() => {
               m.top - 0.06,
               0
             );
-            light.castShadow = false;
+            lightPanel.castShadow = false;
             m.roofItems = beaconBar;
           }
         });
@@ -27892,15 +27968,17 @@ var GameVehiclesThree = (() => {
   }
   function createVehiclesThree(THREE, options) {
     const kit = options.kit;
+    const fleet = options.fleet ?? { colorFromSeed, fleetDims, paintPalettes, paletteOf };
+    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) || paletteOf(groupOf(key)) === paintPalettes.military;
+    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 color2 = o.color || (seed != null ? colorFromSeed(seed, isMilitary(key) ? paintPalettes.military : paintPalettes.civil) : null);
+      const color2 = 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);
@@ -27966,7 +28044,7 @@ var GameVehiclesThree = (() => {
         width: +size.x.toFixed(3),
         height: +size.y.toFixed(3),
         pruned,
-        expected: fleetDims(key),
+        expected: fleetDims2(key),
         context: quality === "high" ? c : null,
         dispose() {
           group.traverse((m) => {
@@ -27991,7 +28069,7 @@ var GameVehiclesThree = (() => {
     }
   }
 
-  // ../game-shapes/dist/chunk-R4RY23RH.js
+  // ../game-shapes/dist/chunk-IFXQIDSA.js
   function canonicalJson(value) {
     if (value === null) return "null";
     if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
@@ -29286,10 +29364,10 @@ var GameVehiclesThree = (() => {
       return cached;
     }
     stats.misses++;
-    const built = make(node.kind, parameters);
-    templates.set(key, built);
+    const built2 = make(node.kind, parameters);
+    templates.set(key, built2);
     if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
-    return built;
+    return built2;
   }
   var num = (v) => typeof v === "number" && Number.isFinite(v) ? null : "expected a finite number";
   var bool = (v) => typeof v === "boolean" ? null : "expected a boolean";
@@ -30467,7 +30545,7 @@ var GameVehiclesThree = (() => {
     }
     return ti.builtBlocks === total;
   }
-  function start(geo) {
+  function start(geo, store = cache) {
     const pos = geo.attributes.position;
     const triangles = trianglesOf(geo);
     const ti = {
@@ -30480,7 +30558,7 @@ var GameVehiclesThree = (() => {
       blocks: new Float64Array(blockCount(triangles) * 6),
       builtBlocks: 0
     };
-    cache.set(geo, ti);
+    store.set(geo, ti);
     return ti;
   }
   function triIndexOf(geo) {
@@ -30532,6 +30610,106 @@ var GameVehiclesThree = (() => {
       }
     return { box: box2, version: ti.positionVersion };
   }
+  var rayCache = /* @__PURE__ */ new WeakMap();
+  function rayIndexOf(geo) {
+    const shared2 = cache.get(geo);
+    if (shared2 && isCurrent(geo, shared2) && shared2.builtBlocks === blockCount(shared2.triangles)) return shared2;
+    let ti = rayCache.get(geo);
+    if (!ti || !isCurrent(geo, ti)) ti = start(geo, rayCache);
+    advance(geo, ti, Infinity);
+    return ti;
+  }
+  var BLOCK_SLACK = 1e-6;
+  var scratch = /* @__PURE__ */ new WeakMap();
+  function scratchOf(THREE) {
+    let s = scratch.get(THREE);
+    if (!s) {
+      s = {
+        inverse: new THREE.Matrix4(),
+        local: new THREE.Ray(),
+        box: new THREE.Box3(),
+        a: new THREE.Vector3(),
+        b: new THREE.Vector3(),
+        c: new THREE.Vector3(),
+        point: new THREE.Vector3(),
+        world: new THREE.Vector3(),
+        sphere: new THREE.Sphere()
+      };
+      scratch.set(THREE, s);
+    }
+    return s;
+  }
+  function indexable(THREE, mesh2) {
+    const geo = mesh2.geometry;
+    if (mesh2.raycast !== THREE.Mesh.prototype.raycast) return false;
+    if (!mesh2.isMesh || mesh2.isSkinnedMesh || mesh2.isInstancedMesh || mesh2.isBatchedMesh || !geo || !geo.isBufferGeometry) return false;
+    if (!mesh2.material || Array.isArray(mesh2.material)) return false;
+    if (geo.morphAttributes && geo.morphAttributes.position && geo.morphAttributes.position.length) return false;
+    return supports(geo);
+  }
+  function raycastMesh(THREE, raycaster, mesh2, out) {
+    const geo = mesh2.geometry;
+    const s = scratchOf(THREE);
+    if (geo.boundingSphere === null) geo.computeBoundingSphere();
+    s.sphere.copy(geo.boundingSphere).applyMatrix4(mesh2.matrixWorld);
+    if (!raycaster.ray.intersectsSphere(s.sphere)) return;
+    const ti = rayIndexOf(geo);
+    if (!ti) return;
+    s.inverse.copy(mesh2.matrixWorld).invert();
+    s.local.copy(raycaster.ray).applyMatrix4(s.inverse);
+    const material = mesh2.material;
+    const back = material.side === THREE.BackSide;
+    const cull = material.side === THREE.FrontSide;
+    const P = geo.attributes.position;
+    const ix = geo.index;
+    const count2 = ix ? ix.count : P.count;
+    const first = Math.max(0, geo.drawRange.start);
+    const last = Math.min(count2, geo.drawRange.start + geo.drawRange.count);
+    const t0 = Math.ceil(first / 3);
+    const t1 = Math.floor(last / 3);
+    const B = ti.boxes;
+    const K = ti.blocks;
+    for (let blk = Math.floor(t0 / TRI_BLOCK); blk * TRI_BLOCK < t1; blk++) {
+      const o = blk * 6;
+      s.box.min.set(K[o] - BLOCK_SLACK, K[o + 1] - BLOCK_SLACK, K[o + 2] - BLOCK_SLACK);
+      s.box.max.set(K[o + 3] + BLOCK_SLACK, K[o + 4] + BLOCK_SLACK, K[o + 5] + BLOCK_SLACK);
+      if (!s.local.intersectsBox(s.box)) continue;
+      const end = Math.min(t1, (blk + 1) * TRI_BLOCK);
+      for (let t = Math.max(t0, blk * TRI_BLOCK); t < end; t++) {
+        const j = t * 6;
+        s.box.min.set(B[j] - BLOCK_SLACK, B[j + 1] - BLOCK_SLACK, B[j + 2] - BLOCK_SLACK);
+        s.box.max.set(B[j + 3] + BLOCK_SLACK, B[j + 4] + BLOCK_SLACK, B[j + 5] + BLOCK_SLACK);
+        if (!s.local.intersectsBox(s.box)) continue;
+        const a = ix ? ix.getX(t * 3) : t * 3;
+        const b = ix ? ix.getX(t * 3 + 1) : t * 3 + 1;
+        const c = ix ? ix.getX(t * 3 + 2) : t * 3 + 2;
+        s.a.fromBufferAttribute(P, a);
+        s.b.fromBufferAttribute(P, b);
+        s.c.fromBufferAttribute(P, c);
+        const hit = back ? s.local.intersectTriangle(s.c, s.b, s.a, true, s.point) : s.local.intersectTriangle(s.a, s.b, s.c, cull, s.point);
+        if (hit === null) continue;
+        s.world.copy(s.point).applyMatrix4(mesh2.matrixWorld);
+        const distance = raycaster.ray.origin.distanceTo(s.world);
+        if (distance < raycaster.near || distance > raycaster.far) continue;
+        const normal = new THREE.Vector3();
+        THREE.Triangle.getNormal(s.a, s.b, s.c, normal);
+        out.push({ distance, point: s.world.clone(), object: mesh2, face: { a, b, c, normal, materialIndex: 0 }, faceIndex: Math.floor(t) });
+      }
+    }
+  }
+  function collect2(THREE, raycaster, object2, recursive, out) {
+    if (object2.layers.test(raycaster.layers)) {
+      if (indexable(THREE, object2)) raycastMesh(THREE, raycaster, object2, out);
+      else object2.raycast(raycaster, out);
+    }
+    if (recursive) for (const child of object2.children) collect2(THREE, raycaster, child, true, out);
+  }
+  function raycastIndexed(THREE, raycaster, objects, recursive = false) {
+    const out = [];
+    for (const object2 of objects) collect2(THREE, raycaster, object2, recursive, out);
+    out.sort((x, y) => x.distance - y.distance);
+    return out;
+  }
   function installGeometry(kit) {
     const THREE = kit.THREE;
     const V3 = THREE.Vector3;
@@ -31856,6 +32034,7 @@ var GameVehiclesThree = (() => {
     }
     kit.profX = profX;
     const _sr = new THREE.Raycaster();
+    _sr.layers.enableAll();
     kit.surfaceAt = function(c, org, dir, o) {
       o = o || {};
       c.root.updateMatrixWorld(true);
@@ -31872,7 +32051,7 @@ var GameVehiclesThree = (() => {
       _sr.set(p0.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
       _sr.near = 0;
       _sr.far = o.max || 20;
-      const h = _sr.intersectObjects(cands, false)[0];
+      const h = raycastIndexed(THREE, _sr, cands)[0];
       if (!h) return null;
       const n = h.face ? h.face.normal.clone().transformDirection(h.object.matrixWorld).transformDirection(inv) : d.clone().negate();
       if (n.dot(d) > 0) n.negate();
@@ -31892,6 +32071,7 @@ var GameVehiclesThree = (() => {
     const V3 = THREE.Vector3;
     const I = kit._;
     const { MATERIALS, crease, cutGeometry, pathShape, subdivide, tumble, uvProject } = I;
+    I.paneSeals = /* @__PURE__ */ new WeakMap();
     kit.addGlass = function(c, geo, label, type, o) {
       o = o || {};
       if (!geo.attributes.uv || o.reuv) o.aspect = uvProject(geo, o.uvAxes);
@@ -31958,7 +32138,7 @@ var GameVehiclesThree = (() => {
           cy /= poly.length;
           const base = I.resolveLabel(label ? label(i, polys.length) : { key: "window" });
           const lab = { key: base.key, label: kit.t("parts.glass_side", { label: base.label, s }) };
-          kit.addGlass(c, geo, lab, o.type || "tempered", {
+          const pane = kit.addGlass(c, geo, lab, o.type || "tempered", {
             mat: o.mat || (o.see === false ? MATERIALS.glassDark : MATERIALS.glass),
             pos: new V3(cx, cy, s * I.halfAt(Wg, T, cy)),
             outline: shp.getSpacedPoints(56),
@@ -31974,6 +32154,7 @@ var GameVehiclesThree = (() => {
           pts.pop();
           const seal = c.tube(pts, 0.011, MATERIALS.trim, { closed: true, seg: 72, rs: 5 });
           seal.castShadow = false;
+          I.paneSeals.set(pane, seal);
         });
       });
     };
@@ -33670,6 +33851,42 @@ var GameVehiclesThree = (() => {
     };
     Object.assign(I, {});
   }
+  var ROUTED_PARTICLE_TYPES = { smoke: "particle_puff", dust: "particle_puff", fire: "particle_glow" };
+  var PUFF_LOOKS = {
+    smokewhite: [10133927, 0.42],
+    smokeblack: [1776412, 0.62],
+    smokegray: [5593436, 0.5],
+    smokesteam: [11975873, 0.3],
+    dust: [7235160, 0.34],
+    fire: [16777215, 0.9]
+  };
+  var LIFE = { dust: 1.6, smoke: 2.8, fire: 0.7 };
+  var FIRE_COLOR = 16753968;
+  var SMOKE_START_SCALE = 0.18;
+  function routedParticleRequest(input) {
+    const { type } = input;
+    const look = PUFF_LOOKS[type + (input.variant ?? "")] ?? PUFF_LOOKS[type] ?? PUFF_LOOKS.smokewhite;
+    const life = input.life ?? LIFE[type] ?? 99;
+    const size = (input.size ?? 1) * (input.grow ?? 1);
+    const isFire = type === "fire";
+    const growth = isFire ? 1 : (SMOKE_START_SCALE + 1.5 * (1 - Math.exp(-life * 1.1)) + life * 0.12) / SMOKE_START_SCALE;
+    return {
+      effect: ROUTED_PARTICLE_TYPES[type],
+      point: input.position,
+      values: {
+        vx: input.velocity[0],
+        vy: input.velocity[1],
+        vz: input.velocity[2],
+        life,
+        size: isFire ? size * 0.85 : size * SMOKE_START_SCALE,
+        grow: growth,
+        color: input.color ?? (isFire ? FIRE_COLOR : look[0]),
+        alpha: input.alpha ?? look[1],
+        gravity: isFire ? 0 : type === "dust" ? 0 : -0.08,
+        drag: type === "dust" ? 2.5 : isFire ? 1.5 : 0.9
+      }
+    };
+  }
   function installParticles(kit) {
     const THREE = kit.THREE;
     const V3 = THREE.Vector3;
@@ -33760,7 +33977,7 @@ var GameVehiclesThree = (() => {
         });
       }
       const list2 = fire ? FIRE_TEXTURES : SMOKE_TEXTURES;
-      const mat = new THREE.SpriteMaterial({
+      const build = () => new THREE.SpriteMaterial({
         map: list2[Math.floor(Math.random() * list2.length)],
         color: new THREE.Color(col),
         transparent: true,
@@ -33768,6 +33985,7 @@ var GameVehiclesThree = (() => {
         opacity: op,
         blending: fire ? THREE.AdditiveBlending : THREE.NormalBlending
       });
+      const mat = kit.particleMaterials ? kit.particleMaterials.own(build) : build();
       const dis = { value: 0 };
       mat.userData.dis = dis;
       mat.onBeforeCompile = function(sh) {
@@ -33795,11 +34013,37 @@ var GameVehiclesThree = (() => {
     function killParticle(c, i) {
       const P = c.particles[i];
       c.effects.remove(P.m);
-      if (P.own) P.m.material.dispose();
+      if (P.own) {
+        if (kit.particleMaterials) kit.particleMaterials.release(P.m.material);
+        else P.m.material.dispose();
+      }
       c.particles.splice(i, 1);
     }
+    function routeParticle(c, effects, type, pos, vel, o) {
+      c.effects.updateWorldMatrix(true, false);
+      const at = pos.clone().applyMatrix4(c.effects.matrixWorld);
+      const to = vel.clone().transformDirection(c.effects.matrixWorld).multiplyScalar(vel.length());
+      const colour = o.col == null ? void 0 : new THREE.Color(o.col).getHex();
+      effects.play(
+        routedParticleRequest({
+          type,
+          position: [at.x, at.y, at.z],
+          velocity: [to.x, to.y, to.z],
+          ...o.variant ? { variant: o.variant } : {},
+          ...colour !== void 0 ? { color: colour } : {},
+          ...o.op != null ? { alpha: o.op } : {},
+          ...o.s ? { size: o.s } : {},
+          ...o.life ? { life: o.life } : {},
+          ...o.grow ? { grow: o.grow } : {}
+        })
+      );
+      return null;
+    }
     kit.spawn = function(c, type, pos, vel, o) {
       o = o || {};
+      const effects = ROUTED_PARTICLE_TYPES[type] ? kit.effects?.() : void 0;
+      if (effects) return routeParticle(c, effects, type, pos, vel, o);
+      if (ROUTED_PARTICLE_TYPES[type] && !kit.effects) warnOnce("game-vehicles.own-particles", "game-vehicles drew its smoke, fire and dust with sprites of its own because the host lent no effects world (options.effects); pass the host effects so the puffs share one budget");
       if (c.particles.length >= PARTICLE_LIMIT) {
         const idx = c.particles.findIndex(function(q) {
           return TRANSIENT_TYPES[q.type];
@@ -34069,6 +34313,7 @@ var GameVehiclesThree = (() => {
     };
     kit.defineFluid("stain", { fresh: "#4a4a44", dry: "#26241f", wipeable: false });
     const _fr = new THREE.Raycaster();
+    _fr.layers.enableAll();
     kit.splat = function(c, p, n, r, o) {
       o = o || {};
       n = n.clone().normalize();
@@ -34508,31 +34753,55 @@ var GameVehiclesThree = (() => {
     };
     Object.assign(I, { _fr, buildDrip, DOWNHILL, PN, puddleGeometry, rimGeometry, puddle, shapePuddle, updateFluids });
   }
+  function crackedGlassMaterial(THREE, texture) {
+    return new THREE.MeshStandardMaterial({
+      color: 16777215,
+      map: texture,
+      emissive: 6976118,
+      emissiveMap: texture,
+      transparent: true,
+      roughness: 0.25,
+      metalness: 0.1,
+      side: THREE.DoubleSide,
+      depthWrite: false
+    });
+  }
   function installGlassDamage(kit) {
     const THREE = kit.THREE;
     const V3 = THREE.Vector3;
     const PI = Math.PI;
     const I = kit._;
     const document2 = kit.document;
-    const { DOUBLE_SIDE, MATERIALS, crease, cutGeometry, mergeGeometries, subdivide, tumble } = I;
-    function glassUV(msh, pLocal) {
+    const { MATERIALS, crease, cutGeometry, mergeGeometries, subdivide, tumble } = I;
+    function glassUV(c, msh, pLocal) {
       const pos = msh.geometry.attributes.position;
       const uv = msh.geometry.attributes.uv;
       if (!uv) return [0.5, 0.5];
-      const inv = new THREE.Matrix4().copy(msh.matrix).invert();
-      const q = pLocal.clone().applyMatrix4(inv);
-      let best = 1e9;
-      let bi = 0;
-      const v = new V3();
-      for (let i = 0; i < pos.count; i++) {
-        v.fromBufferAttribute(pos, i);
-        const d = v.distanceToSquared(q);
-        if (d < best) {
-          best = d;
-          bi = i;
-        }
+      c.root.updateMatrixWorld(true);
+      const q = msh.worldToLocal(c.vehicle.localToWorld(pLocal.clone()));
+      const idx = msh.geometry.index;
+      const tri = new THREE.Triangle();
+      const near = new V3();
+      const bary = new V3();
+      let best = Infinity;
+      const out = [0.5, 0.5];
+      const count2 = idx ? idx.count : pos.count;
+      for (let f = 0; f + 2 < count2; f += 3) {
+        const ia = idx ? idx.getX(f) : f;
+        const ib = idx ? idx.getX(f + 1) : f + 1;
+        const ic = idx ? idx.getX(f + 2) : f + 2;
+        tri.a.fromBufferAttribute(pos, ia);
+        tri.b.fromBufferAttribute(pos, ib);
+        tri.c.fromBufferAttribute(pos, ic);
+        tri.closestPointToPoint(q, near);
+        const d = near.distanceToSquared(q);
+        if (d >= best) continue;
+        best = d;
+        tri.getBarycoord(near, bary);
+        out[0] = uv.getX(ia) * bary.x + uv.getX(ib) * bary.y + uv.getX(ic) * bary.z;
+        out[1] = uv.getY(ia) * bary.x + uv.getY(ib) * bary.y + uv.getY(ic) * bary.z;
       }
-      return [uv.getX(bi), uv.getY(bi)];
+      return out;
     }
     function drawWeb(x, cx, cy, s, ax, rnd) {
       const n = 16 + Math.floor(rnd() * 8);
@@ -34609,19 +34878,9 @@ var GameVehiclesThree = (() => {
         x0.fillStyle = "rgba(48,66,72,0.5)";
         x0.fillRect(0, 0, 256, 256);
         G2.tex = new THREE.CanvasTexture(G2.cv);
-        msh.material = new THREE.MeshStandardMaterial({
-          color: 16777215,
-          map: G2.tex,
-          emissive: 6976118,
-          emissiveMap: G2.tex,
-          transparent: true,
-          roughness: 0.25,
-          metalness: 0.1,
-          side: DOUBLE_SIDE,
-          depthWrite: false
-        });
+        msh.material = crackedGlassMaterial(THREE, G2.tex);
       }
-      const uv = glassUV(msh, p);
+      const uv = glassUV(c, msh, p);
       const x = G2.cv.getContext("2d");
       drawWeb(x, uv[0] * 256, (1 - uv[1]) * 256, sc != null ? sc : 0.6 + force * 0.5, Math.max(0.4, G2.aspect || 1), c.rand);
       G2.tex.needsUpdate = true;
@@ -34766,6 +35025,13 @@ var GameVehiclesThree = (() => {
       }
       const seatGeo = [];
       const d = dir.clone().normalize();
+      if (msh.parent && msh.parent !== c.vehicle) {
+        c.root.updateMatrixWorld(true);
+        const toVehicle = new THREE.Matrix4().copy(c.vehicle.matrixWorld).invert().multiply(msh.parent.matrixWorld);
+        cubesAt.forEach(function(q) {
+          q.applyMatrix4(toVehicle);
+        });
+      }
       cubesAt.forEach(function(p, i) {
         if (i % 3 === 0 && c.seatTops.length && !c.rollState && !c.flipped) {
           let best = null;
@@ -34966,6 +35232,7 @@ var GameVehiclesThree = (() => {
       polygonOffsetUnits: -2
     });
     const _ray = new THREE.Raycaster();
+    _ray.layers.enableAll();
     function findSurface(c, p, dir) {
       c.root.updateMatrixWorld(true);
       const Mw = c.vehicle.matrixWorld;
@@ -35047,6 +35314,7 @@ var GameVehiclesThree = (() => {
       const v0 = new V3();
       const w = new V3();
       const sc = new V3();
+      const local = new V3();
       const cab = m.cabin && !c.flipped && !c.rollState ? m.cabin : null;
       c.deform.forEach(function(msh) {
         if (!msh.parent || !msh.visible) return;
@@ -35061,7 +35329,15 @@ var GameVehiclesThree = (() => {
         irel.copy(rel).invert();
         if (!g.userData.p0) g.userData.p0 = new Float32Array(pos.array);
         const p0 = g.userData.p0;
+        local.copy(p).applyMatrix4(irel);
+        const reach = H.R / Math.max(1e-6, Math.min(sc.x, sc.y, sc.z));
+        const reach2 = reach * reach;
+        const arr = pos.array;
         for (let i = 0; i < pos.count; i++) {
+          const dx = arr[3 * i] - local.x;
+          const dy = arr[3 * i + 1] - local.y;
+          const dz = arr[3 * i + 2] - local.z;
+          if (dx * dx + dy * dy + dz * dz >= reach2) continue;
           v.fromBufferAttribute(pos, i).applyMatrix4(rel);
           const a = dentField(v, H);
           if (a <= 0) continue;
@@ -35077,10 +35353,15 @@ var GameVehiclesThree = (() => {
         }
         if (changed) {
           pos.needsUpdate = true;
-          if (g.userData.crease) crease(g, 42);
+          if (g.userData.crease && c.smoothLater) c.smoothLater(msh);
+          else if (g.userData.crease) crease(g, 42);
           else g.computeVertexNormals();
-          g.computeBoundingSphere();
           g.computeBoundingBox();
+          const sphere2 = g.boundingSphere ?? (g.boundingSphere = new THREE.Sphere());
+          g.boundingBox.getCenter(sphere2.center);
+          let far2 = 0;
+          for (let i = 0; i < pos.count; i++) far2 = Math.max(far2, sphere2.center.distanceToSquared(v.fromBufferAttribute(pos, i)));
+          sphere2.radius = Math.sqrt(far2);
         }
       });
       const dset = new Set(c.deform);
@@ -35164,13 +35445,14 @@ var GameVehiclesThree = (() => {
     kit.impact = impact;
     kit.partEffects = {};
     const _pr = new THREE.Raycaster();
+    _pr.layers.enableAll();
     function probe(c, o, d, far) {
       c.root.updateMatrixWorld(true);
       const Mw = c.vehicle.matrixWorld;
       const inv = new THREE.Matrix4().copy(Mw).invert();
       _pr.set(o.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
       _pr.far = far || 10;
-      const hits = _pr.intersectObject(c.vehicle, true);
+      const hits = raycastIndexed(THREE, _pr, [c.vehicle], true);
       for (let i = 0; i < hits.length; i++) {
         const h = hits[i];
         const ob = h.object;
@@ -36524,6 +36806,7 @@ var GameVehiclesThree = (() => {
       return hole;
     }
     const _zr = new THREE.Raycaster();
+    _zr.layers.enableAll();
     const PROXY_MIN_TRIANGLES = 500;
     const STROKE_REACH = 0.6;
     const _pv = new V3();
@@ -36758,6 +37041,7 @@ var GameVehiclesThree = (() => {
       return out;
     }
     const _rt = new THREE.Raycaster();
+    _rt.layers.enableAll();
     function scratchPath(c, s, len, ang, cands, B) {
       const n = s.n.clone().normalize();
       const t = Math.abs(n.y) < 0.9 ? new V3().crossVectors(new V3(0, 1, 0), n) : new V3().crossVectors(new V3(1, 0, 0), n);
@@ -40017,6 +40301,8 @@ var GameVehiclesThree = (() => {
       V3: THREE.Vector3,
       PI: Math.PI,
       document: doc,
+      particleMaterials: opts.particleMaterials,
+      effects: opts.effects,
       strings,
       t,
       matchers: createMatchers(strings),
@@ -40272,7 +40558,9 @@ var GameVehiclesThree = (() => {
       assignDeep(strings, resolveStrings(opts.locale));
       return kit;
     };
-    const { THREE: _three, lod: _lod, locale: _locale, document: _document, plugins, ...config } = opts;
+    const { THREE: _three, lod: _lod, locale: _locale, document: _document, particleMaterials: _particleMaterials, effects: _effects, plugins, ...config } = opts;
+    void _particleMaterials;
+    void _effects;
     void _three;
     void _lod;
     void _locale;
@@ -40366,6 +40654,14 @@ var GameVehiclesThree = (() => {
     center: [b.center[0], b.center[1] - b.size[1] / 2 + Math.min(0.14, b.size[1]) / 2 + 0.04, b.center[2]],
     size: [b.size[0] * 0.5, Math.min(0.14, b.size[1]), b.size[2] * 0.95]
   });
+  function paneBox(c, pane, inverse) {
+    pane.geometry.computeBoundingBox();
+    const box2 = pane.geometry.boundingBox.clone().applyMatrix4(pane.matrixWorld);
+    box2.applyMatrix4(inverse);
+    const center = [(box2.min.x + box2.max.x) / 2, (box2.min.y + box2.max.y) / 2, (box2.min.z + box2.max.z) / 2];
+    const size = [box2.max.x - box2.min.x, box2.max.y - box2.min.y, box2.max.z - box2.min.z];
+    return { center, size };
+  }
   function buildVehicleModel(kit, c, options = {}) {
     const kind = kindOf(c);
     const m = c.meta;
@@ -40506,6 +40802,16 @@ var GameVehiclesThree = (() => {
         tags: [role, ...tags]
       });
     }
+    const claimed = new Set(zones.filter((z) => roleOfZone(z) === "glass").flatMap((z) => z.glass ?? []));
+    c.root.updateMatrixWorld(true);
+    const inverse = c.vehicle.matrixWorld.clone().invert();
+    for (const pane of c.glass ?? []) {
+      if (claimed.has(pane)) continue;
+      const G2 = pane.userData.glass;
+      const bb = paneBox(c, pane, inverse);
+      const laminated = G2?.type === "laminated" || m.bullet;
+      add2({ id: `pane_${G2?.key ?? "glass"}`, role: "glass", name: String(G2?.label ?? G2?.key ?? "glass"), material: "glass", box: bb, mass: 10 * areaOf(bb.size), hp: laminated ? 4e3 : 450, panes: [pane], visual: false, tags: ["glass"] });
+    }
     if (!hubZone) {
       const h = Math.max(0.15, belt - clearance);
       add2({
@@ -40839,6 +41145,76 @@ var GameVehiclesThree = (() => {
     void has;
     return { parts, joints, hub: hubId, hitch };
   }
+  var HOLE_DECAL_SCALE = 2.4;
+  var DOOR_DEPTH = 0.07;
+  var DOOR_EDGE_PIECES = 16;
+  var DOOR_CARD_COLOR = "#3b3e42";
+  var DOOR_LINER_COLOR = "#5a5e64";
+  var DOOR_LINER_DARK = 0.15;
+  var DOOR_STRIP_THIN = 0.05;
+  var DOOR_STRIP_NEAR = 0.04;
+  var DOOR_STRIP_OVER = 0.3;
+  var DOOR_TOP_OVER_PANE = 0.03;
+  var DOOR_STRIP_SUB = 0.02;
+  var HOLE_TEXTURE_SIZE = 64;
+  var DOOR_HANDLE_INSET = 0.12;
+  var DOOR_HANDLE_MIN = 0.07;
+  var DOOR_HANDLE_MAX = 0.24;
+  var DOOR_HANDLE_THIN = 0.07;
+  var DOOR_HANDLE_OUTSIDE = 0.1;
+  var PANE_SEAT_OUT = 0.05;
+  var PANE_SEAT_IN = -0.05;
+  var PANE_SEAT_REACH = 0.14;
+  var PANE_SEAT_SAMPLES = 24;
+  var PANE_SEAT_LIFT = 4e-3;
+  var PANE_FRAME_NEAR = 0.07;
+  var DRAWN_MIRROR_SIZE = 0.3;
+  var DRAWN_MIRROR_REACH = 0.4;
+  var DRAWN_MIRROR_MOUNT = 0.2;
+  var MIRROR_GLASS_FIT = 0.76;
+  var MIRROR_GLASS_THIN = 0.04;
+  var MIRROR_GLASS_MIN = 0.05;
+  var MIRROR_GLASS_COLOR = "#59636a";
+  var HOLE_RIM = { steel: "#b7bcc0", aluminium: "#d3d6d8", plastic: "#d9d6cc", rubber: "#141414", glass: "#eef3f5" };
+  var holeMaterials = /* @__PURE__ */ new WeakMap();
+  var holeDisc = null;
+  function holeDiscGeometry(THREE) {
+    holeDisc = holeDisc ?? new THREE.CircleGeometry(1, 12);
+    return holeDisc;
+  }
+  function holeMaterial(kit, material) {
+    const key = kit;
+    const cache2 = holeMaterials.get(key) ?? /* @__PURE__ */ new Map();
+    holeMaterials.set(key, cache2);
+    const known = cache2.get(material);
+    if (known) return known;
+    const I = kit._;
+    const THREE = kit.THREE;
+    const canvas = kit.document?.createElement?.("canvas");
+    const x = canvas?.getContext?.("2d");
+    let made = I.MATERIALS.dark;
+    if (x) {
+      canvas.width = canvas.height = HOLE_TEXTURE_SIZE;
+      const mid = HOLE_TEXTURE_SIZE / 2;
+      x.fillStyle = HOLE_RIM[material] ?? HOLE_RIM.steel;
+      x.beginPath();
+      for (let i = 0; i < 18; i++) {
+        const a = i / 18 * Math.PI * 2;
+        const r = mid * (i % 2 ? 0.98 : 0.76);
+        x.lineTo(mid + Math.cos(a) * r, mid + Math.sin(a) * r);
+      }
+      x.closePath();
+      x.fill();
+      x.fillStyle = "#050505";
+      x.beginPath();
+      x.arc(mid, mid, mid * 0.42, 0, Math.PI * 2);
+      x.fill();
+      const map = new THREE.CanvasTexture(canvas);
+      made = new THREE.MeshStandardMaterial({ map, transparent: true, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -2, roughness: 0.55, metalness: material === "steel" || material === "aluminium" ? 0.6 : 0 });
+    }
+    cache2.set(material, made);
+    return made;
+  }
   var VehicleVisuals = class {
     constructor(kit, c, model) {
       __publicField(this, "kit");
@@ -40852,11 +41228,17 @@ var GameVehiclesThree = (() => {
       __publicField(this, "gone", /* @__PURE__ */ new Set());
       __publicField(this, "syncPlates", /* @__PURE__ */ new Map());
       __publicField(this, "skins", /* @__PURE__ */ new Map());
+      __publicField(this, "doorTops", /* @__PURE__ */ new Map());
       __publicField(this, "lightsOn", true);
       __publicField(this, "warming");
       __publicField(this, "tornThisFrame", false);
+      __publicField(this, "queued", false);
+      __publicField(this, "holdArmed", false);
+      __publicField(this, "holdFrame", -1);
       __publicField(this, "smoothing", /* @__PURE__ */ new Map());
       __publicField(this, "hood");
+      ;
+      c.smoothLater = (mesh2) => this.smoothLater(mesh2);
       this.kit = kit;
       this.c = c;
       this.model = model;
@@ -40865,6 +41247,8 @@ var GameVehiclesThree = (() => {
       for (const p of model.parts) this.byId.set(p.id, p);
       c.root.updateMatrixWorld(true);
       this.hood = this.nameHood();
+      this.seatPanes();
+      this.seatDoorHandles();
       this.warming = c.deform.filter((msh) => msh.geometry && msh.geometry.attributes.position && msh.geometry.attributes.position.count >= 1500);
       if (!this.warming.length) this.warming = null;
       for (const p of model.parts) {
@@ -40885,6 +41269,7 @@ var GameVehiclesThree = (() => {
       const id = z ? z.id : this.model.parts.find((p) => p.role === "hood")?.id;
       if (!id) return null;
       c.hood.piv.name = id;
+      c.hood.piv.userData.plateOf = id;
       return { id, open: c.hood.open, sign: c.hood.sign || 1 };
     }
     mirrorObjects(p) {
@@ -40972,6 +41357,7 @@ var GameVehiclesThree = (() => {
         recess.userData.noFollow = true;
         const piv = new THREE.Group();
         piv.name = p.id;
+        piv.userData.plateOf = p.id;
         piv.position.set(hx, cy, sk + s * 0.016);
         piv.userData.rigid = true;
         this.c.vehicle.add(piv);
@@ -40988,6 +41374,7 @@ var GameVehiclesThree = (() => {
         recess.userData.noFollow = true;
         const piv = new THREE.Group();
         piv.name = p.id;
+        piv.userData.plateOf = p.id;
         piv.position.set(sk - 0.016, B.y1 - 0.05, 0);
         piv.userData.rigid = true;
         this.c.vehicle.add(piv);
@@ -41051,10 +41438,19 @@ var GameVehiclesThree = (() => {
       try {
         if (p.role === "door") {
           const dirty = /* @__PURE__ */ new Set();
-          const rect = [B.x0 + 0.03, B.x1 - 0.03, B.y0 + Math.min(0.08, (B.y1 - B.y0) * 0.1), B.y1 - 0.02];
-          const pcs = I.cutPanel(this.c, z, rect, true, dirty).map((x) => x.mesh).filter((m) => !!m);
+          const glassBox = new this.THREE.Box3();
+          for (const g of I.windowsOver(this.c, z, inv)) glassBox.union(I.localBox(this.c, g, inv));
+          const top = glassBox.isEmpty() ? B.y1 - 0.02 : Math.max(B.y1 - 0.02, glassBox.min.y + DOOR_TOP_OVER_PANE);
+          this.doorTops.set(id, top);
+          const rect = [B.x0 + 0.03, B.x1 - 0.03, B.y0 + Math.min(0.08, (B.y1 - B.y0) * 0.1), top];
+          const pcs = I.cutPanel(this.c, z, rect, true, dirty, { anyN: true }).map((x) => x.mesh).filter((m) => !!m);
           this.mend(dirty);
-          if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv), ...I.windowsOver(this.c, z, inv)];
+          if (pcs.length) {
+            const panes = I.windowsOver(this.c, z, inv);
+            const seals = panes.map((g) => I.paneSeals.get(g)).filter((s) => !!s);
+            const mirrors = this.mirrorsOn(z);
+            objs = [...pcs, ...this.doorCards(pcs, z), ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors];
+          }
         } else {
           const pcs = this.cutZone(z);
           if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv)];
@@ -41072,10 +41468,124 @@ var GameVehiclesThree = (() => {
         const di = deform.indexOf(o);
         if (di >= 0) deform.splice(di, 1);
       }
+      if (p.role === "door" && objs.length > 0) {
+        this.doorEdges(piv, z, this.doorTops.get(id) ?? B.y1 - 0.02);
+        this.liftDoorTrim(objs, z);
+        this.cutStripsAcross(piv, z, inv);
+      }
       piv.quaternion.copy(q);
       this.c.root.updateMatrixWorld(true);
       return objs.length > 0;
     }
+    /** A door has edges: a band that follows the skin all round closes it to its card and hides where the cut followed the triangles of the shell; the same band, in the same paint as on a real car, lines the opening. */
+    doorEdges(piv, z, y1) {
+      const THREE = this.THREE;
+      const B = z.box;
+      const side2 = z.side < 0 ? -1 : 1;
+      const flat = piv.position.z - side2 * 0.016;
+      const x0 = B.x0 + 0.03;
+      const x1 = B.x1 - 0.03;
+      const y0 = B.y0 + Math.min(0.08, (B.y1 - B.y0) * 0.1);
+      const loop = [];
+      const run = (ax, ay, bx, by) => {
+        for (let i = 0; i < DOOR_EDGE_PIECES; i++) loop.push([ax + (bx - ax) * i / DOOR_EDGE_PIECES, ay + (by - ay) * i / DOOR_EDGE_PIECES]);
+      };
+      run(x0, y0, x1, y0);
+      run(x1, y0, x1, y1);
+      run(x1, y1, x0, y1);
+      run(x0, y1, x0, y0);
+      const heights = loop.map(([x, y]) => this.surface("z", side2, B, [[x, y]]) ?? flat);
+      const band = (lift) => {
+        const position = [];
+        const index = [];
+        loop.forEach(([x, y], i) => {
+          position.push(x, y, heights[i] + side2 * lift, x, y, heights[i] + side2 * (lift - DOOR_DEPTH));
+          const a = i * 2;
+          const b = (i + 1) % loop.length * 2;
+          index.push(a, a + 1, b, b, a + 1, b + 1);
+        });
+        const g = new THREE.BufferGeometry();
+        g.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+        g.setIndex(index);
+        g.computeVertexNormals();
+        return g;
+      };
+      const paint = this.paint().clone();
+      paint.side = THREE.DoubleSide;
+      const edges = new THREE.Mesh(band(2e-3), paint);
+      const lining = new THREE.Mesh(band(2e-3), paint);
+      for (const m of [edges, lining]) {
+        m.userData.noFollow = true;
+        m.castShadow = false;
+        this.c.vehicle.add(m);
+      }
+      piv.attach(edges);
+    }
+    /** A front door carries the mirror drawn at its corner. */
+    mirrorsOn(z) {
+      if (!z.mirror) return [];
+      const own = (z.mirrors ?? []).filter((o) => o.parent);
+      if (own.length) return own;
+      const part = this.model.parts.find((q) => q.role === "mirror" && Math.sign(q.box.center[2]) === Math.sign(z.side));
+      return part ? (this.extra.get(part.id) ?? []).filter((o) => o.parent) : [];
+    }
+    /** The panel drawn inside the door is lit like the rest of a cabin, not a black slab from end to end. */
+    liftDoorTrim(objs, z) {
+      const card = this.I.makeMaterial(DOOR_LINER_COLOR, { roughness: 0.85 });
+      const inv = this.I.worldInverseOf(this.c);
+      for (const o of objs) {
+        if (!o.isMesh || o.userData.glass) continue;
+        const box2 = this.I.localBox(this.c, o, inv);
+        const size = box2.getSize(new this.THREE.Vector3());
+        if (size.x > (z.box.x1 - z.box.x0) * 0.4 && size.y > (z.box.y1 - z.box.y0) * 0.3 && size.z < DOOR_DEPTH * 1.5 && o.material?.color?.getHSL({ h: 0, s: 0, l: 0 }).l < DOOR_LINER_DARK) o.material = card;
+      }
+    }
+    /** A long strip drawn along the side of the car (the chrome of the belt): the part over the door goes with the door, and nothing stays across the opening. */
+    cutStripsAcross(piv, z, inv) {
+      const THREE = this.THREE;
+      const B = z.box;
+      const x0 = B.x0 + 0.03;
+      const x1 = B.x1 - 0.03;
+      const y0 = B.y0 - DOOR_STRIP_NEAR;
+      const y1 = B.y1 + DOOR_STRIP_NEAR;
+      const deform = this.c.deform ?? [];
+      for (const o of [...this.c.vehicle.children]) {
+        if (!o.isMesh || o === piv || deform.includes(o) || o.userData.glass || o.userData.decal || !o.visible) continue;
+        const box2 = this.I.localBox(this.c, o, inv);
+        const size = box2.getSize(new THREE.Vector3());
+        const mid = box2.getCenter(new THREE.Vector3());
+        if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_THIN || Math.min(box2.max.x, x1) - Math.max(box2.min.x, x0) < (x1 - x0) * DOOR_STRIP_OVER || mid.y < y0 || mid.y > y1) continue;
+        const toVehicle = new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld);
+        const v = new THREE.Vector3();
+        const sdf = (x, y, zz) => {
+          v.set(x, y, zz).applyMatrix4(toVehicle);
+          return Math.max(x0 - v.x, v.x - x1);
+        };
+        this.kit.cutMesh(o, [{ sdf }], 42, { sub: DOOR_STRIP_SUB });
+        const from = Math.max(box2.min.x, x0);
+        const to = Math.min(box2.max.x, x1);
+        const piece = this.box(to - from, size.y, size.z, o.material, (from + to) / 2, mid.y, mid.z);
+        piece.userData.noFollow = true;
+        piv.attach(piece);
+      }
+    }
+    /** The inside of a door: its skin brought in by the depth of the door, in the trim's dark plastic, so the open door is a door and not one sheet of paint. */
+    doorCards(skins, z) {
+      const cardMaterial = this.I.makeMaterial(DOOR_CARD_COLOR, { roughness: 0.8 });
+      return skins.map((skin) => {
+        const card = new this.THREE.Mesh(skin.geometry, cardMaterial);
+        card.position.copy(skin.position);
+        card.quaternion.copy(skin.quaternion);
+        card.scale.copy(skin.scale);
+        const side2 = z.side < 0 ? -1 : 1;
+        const inward = -side2 * DOOR_DEPTH;
+        card.position.z += inward;
+        card.userData.noFollow = true;
+        card.castShadow = false;
+        this.c.vehicle.add(card);
+        return card;
+      });
+    }
     mend(dirty) {
       dirty.forEach((msh) => {
         const g = msh.geometry;
@@ -41085,7 +41595,191 @@ var GameVehiclesThree = (() => {
         g.computeBoundingBox();
       });
     }
+    /**
+     * A windshield or rear window is drawn as a flat quad, and the body under its edge is curved: the pane and its frame stand off the shell or rise past the roof. Each one
+     * comes to the shell along its own normal, by how far the shell is just outside each of its vertices.
+     */
+    seatPanes() {
+      const THREE = this.THREE;
+      const c = this.c;
+      c.root.updateMatrixWorld(true);
+      const shell = c.deform.filter((o) => o.isMesh && !o.userData.glass && c.paints?.has(o.material));
+      if (!shell.length) return;
+      const ray = new THREE.Raycaster();
+      ray.layers.enableAll();
+      for (const pane of c.glass) {
+        if (pane.userData.glass?.outline) continue;
+        const seat = this.paneSeat(pane, shell, ray);
+        if (!seat) continue;
+        const near = c.vehicle.children.filter((o) => o.isMesh && o !== pane && !o.userData.glass && !shell.includes(o) && this.onPane(o, pane, seat));
+        for (const m of [pane, ...near]) this.movePane(m, seat);
+        const past = this.shellPast(pane, shell, ray, seat.normal);
+        if (past > 0) for (const m of [pane, ...near]) this.movePane(m, { normal: seat.normal, samples: [{ at: seat.samples[0].at, by: past }] });
+      }
+    }
+    /** The outward normal of a pane and how far the shell is at each sampled point (world). */
+    paneSeat(pane, shell, ray) {
+      const THREE = this.THREE;
+      const pos = pane.geometry.attributes.position;
+      const box2 = new THREE.Box3().setFromObject(pane);
+      const centre = box2.getCenter(new THREE.Vector3());
+      const vehicleCentre = new THREE.Box3().setFromObject(this.c.root).getCenter(new THREE.Vector3());
+      const tri = new THREE.Triangle();
+      const normal = new THREE.Vector3();
+      let largest = 0;
+      const idx = pane.geometry.index;
+      const count2 = idx ? idx.count : pos.count;
+      for (let f = 0; f + 2 < count2; f += 3) {
+        tri.a.fromBufferAttribute(pos, idx ? idx.getX(f) : f);
+        tri.b.fromBufferAttribute(pos, idx ? idx.getX(f + 1) : f + 1);
+        tri.c.fromBufferAttribute(pos, idx ? idx.getX(f + 2) : f + 2);
+        if (tri.getArea() > largest) {
+          largest = tri.getArea();
+          tri.getNormal(normal);
+        }
+      }
+      normal.transformDirection(pane.matrixWorld);
+      if (normal.dot(centre.clone().sub(vehicleCentre)) < 0) normal.negate();
+      const samples = [];
+      const seen = /* @__PURE__ */ new Set();
+      const v = new THREE.Vector3();
+      const step = Math.max(1, Math.floor(pos.count / PANE_SEAT_SAMPLES));
+      for (let i = 0; i < pos.count; i += step) {
+        v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld);
+        const key = `${Math.round(v.x * 100)},${Math.round(v.y * 100)},${Math.round(v.z * 100)}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const away = v.clone().sub(centre);
+        away.addScaledVector(normal, -away.dot(normal)).normalize();
+        let by = -Infinity;
+        for (const off of [PANE_SEAT_OUT, PANE_SEAT_IN, PANE_SEAT_IN * 3]) {
+          const at = v.clone().addScaledVector(away, off);
+          ray.set(at.addScaledVector(normal, PANE_SEAT_REACH), normal.clone().negate());
+          ray.far = PANE_SEAT_REACH * 2;
+          const hit = raycastIndexed(THREE, ray, shell)[0];
+          if (hit) by = Math.max(by, PANE_SEAT_REACH - hit.distance);
+        }
+        if (by > -Infinity) samples.push({ at: v.clone(), by });
+      }
+      return samples.length >= 3 ? { normal, samples } : null;
+    }
+    /** How far the shell still stands past a seated pane, over its triangles. */
+    shellPast(pane, shell, ray, normal) {
+      const THREE = this.THREE;
+      const pos = pane.geometry.attributes.position;
+      const idx = pane.geometry.index;
+      const count2 = idx ? idx.count : pos.count;
+      const tri = new THREE.Triangle();
+      const step = Math.max(1, Math.floor(count2 / 3 / PANE_SEAT_SAMPLES)) * 3;
+      let past = 0;
+      for (let f = 0; f + 2 < count2; f += step) {
+        tri.a.fromBufferAttribute(pos, idx ? idx.getX(f) : f);
+        tri.b.fromBufferAttribute(pos, idx ? idx.getX(f + 1) : f + 1);
+        tri.c.fromBufferAttribute(pos, idx ? idx.getX(f + 2) : f + 2);
+        const mid = tri.getMidpoint(new THREE.Vector3()).applyMatrix4(pane.matrixWorld);
+        ray.set(mid.addScaledVector(normal, PANE_SEAT_REACH), normal.clone().negate());
+        ray.far = PANE_SEAT_REACH;
+        const hit = raycastIndexed(THREE, ray, shell)[0];
+        if (hit) past = Math.max(past, PANE_SEAT_REACH - hit.distance + PANE_SEAT_LIFT);
+      }
+      return past;
+    }
+    /** A frame or a seal drawn on the pane: small, and close to its plane. */
+    onPane(o, pane, seat) {
+      const THREE = this.THREE;
+      const box2 = new THREE.Box3().setFromObject(o);
+      if (box2.isEmpty() || !new THREE.Box3().setFromObject(pane).expandByScalar(PANE_FRAME_NEAR).containsBox(box2)) return false;
+      const at = box2.getCenter(new THREE.Vector3());
+      return Math.abs(at.clone().sub(seat.samples[0].at).dot(seat.normal)) < PANE_SEAT_REACH;
+    }
+    movePane(mesh2, seat) {
+      const THREE = this.THREE;
+      const g = mesh2.geometry.clone();
+      const pos = g.attributes.position;
+      const inverse = mesh2.matrixWorld.clone().invert();
+      const v = new THREE.Vector3();
+      for (let i = 0; i < pos.count; i++) {
+        v.fromBufferAttribute(pos, i).applyMatrix4(mesh2.matrixWorld);
+        let weight = 0;
+        let by = 0;
+        for (const s of seat.samples) {
+          const w = 1 / (s.at.distanceToSquared(v) + 1e-4);
+          weight += w;
+          by += s.by * w;
+        }
+        v.addScaledVector(seat.normal, by / weight + PANE_SEAT_LIFT).applyMatrix4(inverse);
+        pos.setXYZ(i, v.x, v.y, v.z);
+      }
+      pos.needsUpdate = true;
+      g.computeBoundingBox();
+      g.computeBoundingSphere();
+      mesh2.geometry = g;
+    }
+    /** A handle is at the free edge of its door, the end away from the hinge. */
+    seatDoorHandles() {
+      const THREE = this.THREE;
+      const c = this.c;
+      const inv = this.I.worldInverseOf(c);
+      for (const p of this.model.parts) {
+        if (p.role !== "door") continue;
+        const z = this.zone(p);
+        if (!z) continue;
+        const B = z.box;
+        const free = z.hinge === "rear" ? B.x1 - DOOR_HANDLE_INSET : B.x0 + DOOR_HANDLE_INSET;
+        for (const o of c.vehicle.children) {
+          if (!o.isMesh || o.material !== this.I.MATERIALS.chrome || o.userData.glass) continue;
+          const box2 = this.I.localBox(c, o, inv);
+          const size = box2.getSize(new THREE.Vector3());
+          const at = box2.getCenter(new THREE.Vector3());
+          const isHandle = size.x > DOOR_HANDLE_MIN && size.x < DOOR_HANDLE_MAX && size.y < DOOR_HANDLE_THIN && size.z < DOOR_HANDLE_THIN;
+          if (!isHandle || Math.sign(at.z) !== Math.sign(z.side) || at.x < B.x0 || at.x > B.x1 || at.y < B.y0 || at.y > B.y1) continue;
+          const here = this.surface("z", z.side < 0 ? -1 : 1, B, [[at.x, at.y]]);
+          if (here != null && Math.abs(here - at.z) > DOOR_HANDLE_OUTSIDE) continue;
+          const skin = this.surface("z", z.side < 0 ? -1 : 1, B, [[free, at.y]]);
+          o.position.x += free - at.x;
+          if (skin != null) o.position.z += skin + (z.side < 0 ? -1 : 1) * (size.z / 2) - at.z;
+        }
+      }
+      c.root.updateMatrixWorld(true);
+    }
+    /** The glass of a drawn mirror sits inside its rounded housing, without corners standing past it. */
+    seatMirrorGlass(glass) {
+      const g = glass.geometry.clone();
+      g.computeBoundingBox();
+      const mid = g.boundingBox.getCenter(new this.THREE.Vector3());
+      g.translate(-mid.x, -mid.y, -mid.z);
+      g.scale(MIRROR_GLASS_FIT, MIRROR_GLASS_FIT, MIRROR_GLASS_FIT);
+      g.translate(mid.x, mid.y, mid.z);
+      glass.geometry = g;
+      glass.material = this.I.makeMaterial(MIRROR_GLASS_COLOR, { metalness: 0.95, roughness: 0.12 });
+    }
+    /** The mirror the model already draws around where the part says, if it draws one. */
+    drawnMirror(p) {
+      const THREE = this.THREE;
+      const [cx, cy, cz] = p.box.center;
+      this.c.root.updateMatrixWorld(true);
+      const inv = this.I.worldInverseOf(this.c);
+      const small = this.c.vehicle.children.flatMap((o) => {
+        if (o.userData.glass || o.userData.decal || !(o.isMesh || o.isGroup) || !o.visible || this.c.deform?.includes(o)) return [];
+        const box2 = this.I.localBox(this.c, o, inv);
+        if (box2.isEmpty()) return [];
+        const size = box2.getSize(new THREE.Vector3());
+        return Math.max(size.x, size.y, size.z) < DRAWN_MIRROR_SIZE ? [{ o, at: box2.getCenter(new THREE.Vector3()) }] : [];
+      });
+      const housing = small.filter(({ at }) => Math.hypot(at.x - cx, at.y - cy, at.z - cz) < DRAWN_MIRROR_REACH && Math.abs(at.z) > Math.abs(cz) - DRAWN_MIRROR_REACH / 2);
+      return small.filter(({ at }) => housing.some((h) => h.at.distanceTo(at) < DRAWN_MIRROR_MOUNT)).map(({ o }) => o);
+    }
     makeMirror(p) {
+      const drawn = this.drawnMirror(p);
+      if (drawn.length) {
+        for (const o of drawn) {
+          if (!o.isMesh || o.material !== this.I.MATERIALS.chrome) continue;
+          const size = new this.THREE.Box3().setFromObject(o).getSize(new this.THREE.Vector3());
+          if (size.x < MIRROR_GLASS_THIN && size.y > MIRROR_GLASS_MIN && size.z > MIRROR_GLASS_MIN) this.seatMirrorGlass(o);
+        }
+        this.extra.set(p.id, drawn);
+        return;
+      }
       const [cx, cy, cz] = p.box.center;
       const s = cz < 0 ? -1 : 1;
       const mats = this.I.MATERIALS;
@@ -41126,17 +41820,28 @@ var GameVehiclesThree = (() => {
     }
     // ---- marks -------------------------------------------------------------------------------------------------------------------------------
     /** A bullet hole: a dark disc lying on the surface at `point` (`c.vehicle` coordinates). */
-    holeDecal(point, normal, diameter) {
+    holeDecal(point, normal, diameter, part) {
       const THREE = this.THREE;
-      const m = new THREE.Mesh(new THREE.CircleGeometry(Math.max(6e-3, diameter / 2), 10), this.I.MATERIALS.dark);
+      const pane = part?.role === "glass" ? this.panesOf(part).find((g) => g.visible) : void 0;
+      if (part?.role === "glass" && (!pane || pane.userData.glass?.broken)) return;
+      const radius = Math.max(6e-3, diameter / 2) * HOLE_DECAL_SCALE;
+      const m = new THREE.Mesh(holeDiscGeometry(THREE), holeMaterial(this.kit, part?.material ?? "steel"));
+      m.scale.set(radius, radius, 1);
       const n = new THREE.Vector3(...normal);
-      m.position.set(...point).addScaledVector(n, 4e-3);
-      m.lookAt(m.position.clone().add(n));
+      m.position.set(...point).addScaledVector(n, 3e-3);
+      this.c.vehicle.add(m);
+      m.lookAt(this.c.vehicle.localToWorld(m.position.clone().add(n)));
       m.userData.decal = true;
       m.userData.noFollow = true;
+      m.renderOrder = 3;
       m.raycast = () => {
       };
-      this.c.vehicle.add(m);
+      const carrier = (part && (this.plates.get(part.id) ?? (part.id === this.hood?.id ? this.c.hood?.piv : void 0))) ?? (pane && pane.parent !== this.c.vehicle ? pane.parent : null);
+      if (carrier) carrier.attach(m);
+    }
+    /** The door or lid a hinge group stands for. */
+    plateIdOf(o) {
+      return o.userData.plateOf;
     }
     spark(point, dir, count2 = 8) {
       const V3 = this.THREE.Vector3;
@@ -41176,10 +41881,8 @@ var GameVehiclesThree = (() => {
     }
     /** Glass: cracks (laminated) or shatters (tempered); returns whether it broke. */
     hitGlass(p, point, dir, force) {
-      const z = this.zone(p);
-      if (!z) return false;
       const V3 = this.THREE.Vector3;
-      const list2 = z.glass.filter((g) => g.parent && g.visible);
+      const list2 = this.panesOf(p).filter((g) => g.parent && g.visible);
       if (!list2.length) return false;
       const pt = new V3(...point);
       let best = list2[0];
@@ -41196,9 +41899,16 @@ var GameVehiclesThree = (() => {
       this.kit.hitGlass(this.c, best, pt, new V3(...dir), force);
       return !!best.userData.glass?.broken;
     }
+    panesOf(p) {
+      return p.panes ?? this.zone(p)?.glass ?? [];
+    }
     glassBreak(p) {
       const z = this.zone(p);
-      if (!z) return;
+      if (!z) {
+        for (const g of p.panes ?? []) if (g.parent && g.visible) this.kit.hitGlass(this.c, g, g.position.clone(), new this.THREE.Vector3(0, -1, 0), 0.6);
+        this.gone.add(p.id);
+        return;
+      }
       for (const g of z.glass) if (g.parent && g.visible) this.I.glassBand(this.c, z, g, 4);
       this.gone.add(p.id);
     }
@@ -41226,6 +41936,7 @@ var GameVehiclesThree = (() => {
     smoothLater(msh) {
       this.smoothing.set(msh, this.I.creaseTask(msh.geometry, 42));
       this.tornThisFrame = true;
+      this.holdArmed = true;
     }
     /** Spends at most `budgetMs` finishing the pending normal smoothing. Call once per frame. */
     pump(budgetMs = 2.5) {
@@ -41233,6 +41944,7 @@ var GameVehiclesThree = (() => {
         this.tornThisFrame = false;
         return;
       }
+      if (this.queued) return;
       if (!this.smoothing.size && !this.warming) return;
       const deadline = performance.now() + budgetMs;
       for (const [msh, task] of this.smoothing) {
@@ -41241,6 +41953,34 @@ var GameVehiclesThree = (() => {
       }
       this.warmIndexes(deadline);
     }
+    setQueued(isQueued) {
+      this.queued = isQueued;
+    }
+    /** Units the shared queue may run now: 0 in the frame of the cut (the first ask after it holds the work for that frame, or `pump` closes it when there is no frame). */
+    pendingUnits(frame) {
+      if (this.holdArmed && frame !== void 0) {
+        this.holdArmed = false;
+        this.holdFrame = frame;
+      }
+      if (frame !== void 0 && frame === this.holdFrame) return 0;
+      if (frame === void 0 && this.tornThisFrame) return 0;
+      return this.smoothing.size + (this.warming ? 1 : 0);
+    }
+    /** One slice of the pending work, for the shared queue. */
+    runStep(deadline) {
+      const next = this.smoothing.entries().next();
+      if (!next.done) {
+        const [msh, task] = next.value;
+        if (msh.geometry !== task.geo || task.step(deadline)) this.smoothing.delete(msh);
+        return true;
+      }
+      if (!this.warming) return false;
+      this.warmIndexes(deadline);
+      return true;
+    }
+    finishAll() {
+      while (this.runStep(Infinity)) ;
+    }
     /** Measures the triangles of the heavy body meshes once, a slice per frame, so the first panel torn off finds them ready (see `triIndexOf`). */
     warmIndexes(deadline) {
       if (!this.warming) return;
@@ -41412,6 +42152,7 @@ var GameVehiclesThree = (() => {
       }
       pieceTasks.forEach((task, mesh2) => this.smoothing.set(mesh2, task));
       this.tornThisFrame = true;
+      this.holdArmed = true;
       dirty.forEach((msh) => {
         const g = msh.geometry;
         if (g.userData.crease || !g.index) this.smoothLater(msh);
@@ -41514,6 +42255,7 @@ var GameVehiclesThree = (() => {
     let clock = 0;
     let model;
     let vis = null;
+    let releaseCrease;
     const ps = /* @__PURE__ */ new Map();
     let js = [];
     let leaks = /* @__PURE__ */ new Map();
@@ -41598,7 +42340,9 @@ var GameVehiclesThree = (() => {
       rand = rng(seedBase);
       igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
       steerSign = rand() < 0.5 ? -1 : 1;
+      releaseCrease?.();
       vis = headless ? null : new VehicleVisuals(kit, c, model);
+      releaseCrease = vis && options.creaseQueue ? options.creaseQueue.track(vis) : void 0;
       recomputeGroups();
     };
     const recomputeGroups = () => {
@@ -41909,13 +42653,13 @@ var GameVehiclesThree = (() => {
       sync();
       const M = toFrameMatrix();
       const v = toLocal(h.point);
-      const p = locate(v, 0.2);
+      const p = (h.part ? ps.get(h.part) : void 0) ?? locate(v, 0.2);
       if (!p) return;
       const d = p.def;
       const E = h.energy ?? 0;
       const cal = h.caliber ?? 9;
       const dir = dirToLocal(h.direction ?? [0, 0, -1]).normalize();
-      const n = normalOf(d, v);
+      const n = h.normal ? dirToLocal(h.normal).normalize() : normalOf(d, v);
       const res = resist(d, p);
       const through = E >= res;
       const cosInc = Math.abs(dir.dot(n));
@@ -41934,7 +42678,7 @@ var GameVehiclesThree = (() => {
         const hp = { point: r3(fromVehicle(v, M)), normal: r3(fromVehicle(n, new THREE.Matrix4().extractRotation(M))), diameter: r2(holeDiam), through };
         p.holes.push(hp);
         out.push(ev({ type: "hole", part: d.id, hole: hp, worldPoint, ...through ? { exitPoint: add3(worldPoint, r3(dirToWorld(dir.clone().multiplyScalar(Math.max(0.02, Math.min(d.box.size[0], d.box.size[1], d.box.size[2])))))) } : {} }));
-        vis?.holeDecal([v.x, v.y, v.z], [n.x, n.y, n.z], holeDiam);
+        vis?.holeDecal([v.x, v.y, v.z], [n.x, n.y, n.z], holeDiam, d);
         startLeak(p, v, cal, out, dir);
       };
       switch (d.material) {
@@ -42235,6 +42979,46 @@ var GameVehiclesThree = (() => {
       for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT)) return true;
       return false;
     };
+    const surfaceRays = new THREE.Raycaster();
+    surfaceRays.layers.enableAll();
+    surfaceRays.camera = new THREE.PerspectiveCamera();
+    let meshParts = null;
+    const paneParts = () => {
+      if (meshParts) return meshParts;
+      meshParts = /* @__PURE__ */ new Map();
+      for (const d of model.parts) {
+        if (d.role !== "glass") continue;
+        const z = kit.zonesOf(c).find((q) => q.id === d.zoneId);
+        for (const g of z?.glass ?? d.panes ?? []) meshParts.set(g, d.id);
+      }
+      return meshParts;
+    };
+    const isDrawnSurface = (o) => {
+      for (let q = o; q && q !== c.vehicle; q = q.parent) if (!q.visible || q.userData.decal || q.userData.ghost) return false;
+      return true;
+    };
+    const partOfSurface = (o, v) => {
+      const pane = paneParts().get(o);
+      if (pane) return ps.get(pane) ?? null;
+      for (let q = o; q && q !== c.vehicle; q = q.parent) {
+        if (vis?.plateIdOf(q)) return ps.get(vis.plateIdOf(q)) ?? null;
+      }
+      return locate(v, 0.08, (p) => p.def.role === "glass");
+    };
+    const surfaceRay = (ray) => {
+      sync();
+      surfaceRays.set(new V3(ray.origin[0], ray.origin[1], ray.origin[2]), new V3(ray.direction[0], ray.direction[1], ray.direction[2]));
+      surfaceRays.far = ray.maxDistance;
+      for (const h of surfaceRays.intersectObject(c.vehicle, true)) {
+        if (!h.face || !isDrawnSurface(h.object)) continue;
+        const p = partOfSurface(h.object, c.vehicle.worldToLocal(h.point.clone()));
+        if (!p || p.lost || ray.ignored?.(p.def.id)) continue;
+        const n = h.face.normal.clone().transformDirection(h.object.matrixWorld);
+        if (n.dot(surfaceRays.ray.direction) > 0) n.negate();
+        return { part: p.def.id, point: [h.point.x, h.point.y, h.point.z], normal: [n.x, n.y, n.z], distance: h.distance, pathLen: 0.02 };
+      }
+      return null;
+    };
     const hit = (h) => {
       stateCache = void 0;
       const out = [];
@@ -42357,9 +43141,14 @@ var GameVehiclesThree = (() => {
       },
       describe,
       hit,
+      surfaceRay,
       update,
       state,
       reset,
+      dispose: () => {
+        releaseCrease?.();
+        releaseCrease = void 0;
+      },
       disassemble,
       extinguish,
       serialize: () => ({
@@ -42395,6 +43184,387 @@ var GameVehiclesThree = (() => {
     root.userData.vehicle = vehicle;
     return { root, vehicle };
   }
+  function createCreaseQueue() {
+    const tracked = [];
+    let cursor = 0;
+    let lastFrame;
+    let attached = false;
+    const deferred = {
+      id: DEFERRED_QUEUE_ID.VEHICLE_CREASE,
+      pending(frame) {
+        lastFrame = frame;
+        let units = 0;
+        for (const work of tracked) units += work.pendingUnits(frame);
+        return units;
+      },
+      run(deadline, clock) {
+        let ran = 0;
+        let skipped = 0;
+        while (tracked.length > 0 && skipped < tracked.length) {
+          if (ran > 0 && clock() >= deadline) break;
+          const work = tracked[cursor % tracked.length];
+          cursor = (cursor + 1) % tracked.length;
+          if (work.pendingUnits(lastFrame) > 0 && work.runStep(deadline)) {
+            ran++;
+            skipped = 0;
+          } else skipped++;
+        }
+        return ran;
+      },
+      flush() {
+        for (const work of tracked) work.finishAll();
+      },
+      attach() {
+        attached = true;
+        for (const work of tracked) work.setQueued(true);
+      },
+      detach() {
+        attached = false;
+        for (const work of tracked) work.setQueued(false);
+      }
+    };
+    return {
+      deferredQueue: () => deferred,
+      track(work) {
+        tracked.push(work);
+        work.setQueued(attached);
+        return () => {
+          const at = tracked.indexOf(work);
+          if (at < 0) return;
+          tracked.splice(at, 1);
+          work.setQueued(false);
+        };
+      }
+    };
+  }
+  var CABIN_LEAK = 0.02;
+  var HOLE_RATE_PER_AREA = 3e3;
+  var CRACK_GAP_PER_METRE = 0.5;
+  var THROUGH = 0.18;
+  var HOLE_PATCH = 0.12;
+  var FULL_SWING = 1.15;
+  var SHELL_ROLES = /* @__PURE__ */ new Set(["door", "glass", "roof", "lid", "panel", "pillar"]);
+  var GONE = /* @__PURE__ */ new Set(["broken", "melted", "ashes"]);
+  function cabinBoxOf(vehicle) {
+    const cabin = vehicle.meta.cabin;
+    if (!cabin || !(cabin.x1 > cabin.x0) || !(cabin.y1 > cabin.y0) || !(cabin.z > 0)) return null;
+    return cabin;
+  }
+  function swingOf(vehicle, partId) {
+    const pivot = vehicle.vehicle?.getObjectByName?.(partId);
+    const q = pivot?.quaternion;
+    if (!q) return 0;
+    const angle = 2 * Math.acos(Math.min(1, Math.abs(q.w)));
+    return Math.min(1, angle / FULL_SWING);
+  }
+  var overlaps = (b, c, margin) => Math.abs(b.center[0] - (c.x0 + c.x1) / 2) <= b.size[0] / 2 + (c.x1 - c.x0) / 2 + margin && Math.abs(b.center[1] - (c.y0 + c.y1) / 2) <= b.size[1] / 2 + (c.y1 - c.y0) / 2 + margin && Math.abs(b.center[2]) <= b.size[2] / 2 + c.z + margin;
+  function cabinEnclosure(source, options = {}) {
+    const c = source.vehicle;
+    const cabin = cabinBoxOf(c);
+    const node = c.vehicle;
+    if (!cabin || !node?.localToWorld) return null;
+    const state = source.state();
+    if (state.destroyed) return null;
+    const V3 = node.position.constructor;
+    const Quat = node.quaternion.constructor;
+    const mid = [(cabin.x0 + cabin.x1) / 2, (cabin.y0 + cabin.y1) / 2, 0];
+    const half = [(cabin.x1 - cabin.x0) / 2, (cabin.y1 - cabin.y0) / 2, cabin.z];
+    const ajar = options.ajar ?? 0.06;
+    const byId = new Map(state.parts.map((p) => [p.id, p]));
+    const mainGroup = state.groups[0] ? new Set(state.groups[0]) : null;
+    const openings = [];
+    let crackLength = 0;
+    const toCabin = (b) => ({
+      center: [b.center[0] - mid[0], b.center[1] - mid[1], b.center[2] - mid[2]],
+      halfSize: [b.size[0] / 2 + THROUGH, b.size[1] / 2 + THROUGH, b.size[2] / 2 + THROUGH]
+    });
+    node.updateWorldMatrix?.(true, false);
+    const frame = options.frame ?? c.root;
+    frame?.updateWorldMatrix?.(true, false);
+    const inverse = node.matrixWorld.clone().invert();
+    for (const def of source.model.parts) {
+      if (!SHELL_ROLES.has(def.role) || !overlaps(def.box, cabin, 0.12)) continue;
+      const part = byId.get(def.id);
+      if (!part) continue;
+      const gone = GONE.has(part.status) || mainGroup !== null && !mainGroup.has(def.id);
+      const swung = (def.role === "door" || def.role === "lid") && swingOf(c, def.id) > ajar;
+      if (gone || swung) {
+        openings.push(toCabin(def.box));
+        continue;
+      }
+      for (const hole of part.holes) {
+        if (!hole.through && def.material !== "glass") continue;
+        const area3 = Math.PI * (hole.diameter / 2) ** 2;
+        const p = new V3(hole.point[0], hole.point[1], hole.point[2]);
+        if (frame?.localToWorld) frame.localToWorld(p);
+        p.applyMatrix4(inverse);
+        openings.push({
+          center: [p.x - mid[0], p.y - mid[1], p.z - mid[2]],
+          halfSize: [HOLE_PATCH, HOLE_PATCH, HOLE_PATCH],
+          // the patch is far bigger than the hole: only a share of what crosses it passes, more for a bigger hole
+          rate: Math.min(4, area3 * HOLE_RATE_PER_AREA)
+        });
+      }
+      for (const crack of part.cracks) crackLength += crack.length;
+    }
+    const center = node.localToWorld(new V3(mid[0], mid[1], mid[2]));
+    const q = node.getWorldQuaternion(new Quat());
+    const scale = node.getWorldScale(new V3());
+    const leak = (options.leak ?? CABIN_LEAK) * (1 + crackLength * CRACK_GAP_PER_METRE);
+    return {
+      center: [center.x, center.y, center.z],
+      halfSize: [half[0] * Math.abs(scale.x), half[1] * Math.abs(scale.y), half[2] * Math.abs(scale.z)],
+      orientation: [q.x, q.y, q.z, q.w],
+      openings: openings.map((o) => ({ ...o, center: [o.center[0] * scale.x, o.center[1] * scale.y, o.center[2] * scale.z], halfSize: [o.halfSize[0] * Math.abs(scale.x), o.halfSize[1] * Math.abs(scale.y), o.halfSize[2] * Math.abs(scale.z)] })),
+      leak
+    };
+  }
+
+  // src/cabin-smoke.ts
+  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()]
+    };
+  }
+
+  // ../game-render-three/dist/index.js
+  var DEFAULT_ANGLE = Math.PI / 3;
+  var EFFECT_STEP_SECONDS = 1 / 50;
+  function isRenderPools(value) {
+    const candidate = value;
+    return typeof candidate === "object" && candidate !== null && typeof candidate.geometries?.acquire === "function" && typeof candidate.materials?.acquire === "function";
+  }
+  var BATCHED_LAYER = 30;
+  var MATRIX_EPSILON = 1e-6;
+  var ATTRIBUTES = ["position", "normal", "uv", "color"];
+  var isShown = (object2, root) => {
+    for (let node = object2; node; node = node.parent) {
+      if (node === root) return true;
+      if (!node.visible) return false;
+    }
+    return false;
+  };
+  var isBatchable = (mesh2) => {
+    const flags = mesh2;
+    if (flags.isInstancedMesh === true || flags.isSkinnedMesh === true || Array.isArray(mesh2.material)) return false;
+    const geometry = mesh2.geometry;
+    return geometry.attributes.position !== void 0 && Object.keys(geometry.morphAttributes).length === 0;
+  };
+  var signatureOf = (mesh2) => {
+    const { attributes } = mesh2.geometry;
+    const present = ATTRIBUTES.filter((name) => attributes[name] !== void 0).map((name) => `${name}${attributes[name].itemSize}`);
+    return `${mesh2.material.uuid}|${present.join(",")}|${mesh2.castShadow ? 1 : 0}${mesh2.receiveShadow ? 1 : 0}`;
+  };
+  var sameMatrix = (a, b) => a.elements.every((value, index) => Math.abs(value - b.elements[index]) < MATRIX_EPSILON);
+  function createStaticBatcher(THREE, root, options = {}) {
+    const include = options.include ?? (() => true);
+    const follow = options.followMeshes === true;
+    root.updateMatrixWorld(true);
+    const inverse = new THREE.Matrix4().copy(root.matrixWorld).invert();
+    const groups = /* @__PURE__ */ new Map();
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || !isShown(mesh2, root) || !isBatchable(mesh2) || !include(mesh2)) return;
+      const key = signatureOf(mesh2);
+      groups.set(key, [...groups.get(key) ?? [], mesh2]);
+    });
+    const group = new THREE.Group();
+    group.name = "static-batches";
+    const sources = [];
+    const pending = [...groups.values()].filter((meshes) => meshes.length >= 2);
+    const mergeSome = (deadline) => {
+      while (pending.length > 0) {
+        const meshes = pending.shift();
+        if (meshes.every((mesh2) => isShown(mesh2, root))) sources.push(...mergeGroup(THREE, { meshes, inverse: new THREE.Matrix4().copy(root.matrixWorld).invert(), group, follow }));
+        if (performance.now() >= deadline) return;
+      }
+    };
+    if (options.budgetMs === void 0) mergeSome(Number.POSITIVE_INFINITY);
+    root.add(group);
+    const scratch2 = new THREE.Matrix4();
+    let released = 0;
+    const release = (source) => {
+      source.released = true;
+      source.mesh.layers.mask = source.mask;
+      const { index } = source.batch;
+      const first = index.array[source.start];
+      for (let at = source.start; at < source.start + source.count; at++) index.array[at] = first;
+      index.needsUpdate = true;
+      if (--source.batch.live === 0) source.batch.mesh.visible = false;
+      released++;
+    };
+    const hasChanged = (source) => {
+      const { mesh: mesh2 } = source;
+      if (mesh2.geometry !== source.geometry || mesh2.material !== source.material || !isShown(mesh2, root)) return true;
+      if (mesh2.geometry.attributes.position.version !== source.version) return true;
+      if (follow || sameMatrix(mesh2.matrixWorld, source.world)) return false;
+      if (!sameMatrix(scratch2.multiplyMatrices(inverse, mesh2.matrixWorld), source.local)) return true;
+      source.world.copy(mesh2.matrixWorld);
+      return false;
+    };
+    return {
+      group,
+      update() {
+        if (pending.length > 0) mergeSome(performance.now() + (options.budgetMs ?? Number.POSITIVE_INFINITY));
+        const before = released;
+        inverse.copy(root.matrixWorld).invert();
+        for (const source of sources) if (!source.released && hasChanged(source)) release(source);
+        return released - before;
+      },
+      stats: () => ({ batches: group.children.length, batched: sources.filter((source) => !source.released).length, released }),
+      dispose() {
+        for (const source of sources) if (!source.released) source.mesh.layers.mask = source.mask;
+        group.removeFromParent();
+        for (const child of group.children) {
+          ;
+          child.geometry.dispose();
+          child.skeleton?.dispose();
+        }
+      }
+    };
+  }
+  function copyAttribute(name, attribute, target, offset, matrix, normalMatrix2) {
+    const size = attribute.itemSize;
+    const source = attribute.array;
+    const flat = !attribute.isInterleavedBufferAttribute && source.length === attribute.count * size;
+    if (name !== "position" && name !== "normal") {
+      if (flat) target.set(source, offset * size);
+      else for (let at = 0; at < attribute.count; at++) for (let k = 0; k < size; k++) target[(offset + at) * size + k] = attribute.getComponent(at, k);
+      return;
+    }
+    const e = (name === "position" ? matrix : normalMatrix2).elements;
+    const isNormal = name === "normal";
+    for (let at = 0; at < attribute.count; at++) {
+      const x = attribute.getX(at);
+      const y = attribute.getY(at);
+      const z = attribute.getZ(at);
+      const out = (offset + at) * 3;
+      if (isNormal) {
+        const nx = e[0] * x + e[3] * y + e[6] * z;
+        const ny = e[1] * x + e[4] * y + e[7] * z;
+        const nz = e[2] * x + e[5] * y + e[8] * z;
+        const length = Math.hypot(nx, ny, nz) || 1;
+        target[out] = nx / length;
+        target[out + 1] = ny / length;
+        target[out + 2] = nz / length;
+      } else {
+        target[out] = e[0] * x + e[4] * y + e[8] * z + e[12];
+        target[out + 1] = e[1] * x + e[5] * y + e[9] * z + e[13];
+        target[out + 2] = e[2] * x + e[6] * y + e[10] * z + e[14];
+      }
+    }
+  }
+  function skinnedBatch(THREE, merged, material, meshes) {
+    const vertices = merged.attributes.position.count;
+    const skinIndex = new Uint16Array(vertices * 4);
+    const skinWeight = new Float32Array(vertices * 4);
+    let at = 0;
+    meshes.forEach((mesh22, bone) => {
+      for (let k = 0; k < mesh22.geometry.attributes.position.count; k++, at++) {
+        skinIndex[at * 4] = bone;
+        skinWeight[at * 4] = 1;
+      }
+    });
+    merged.setAttribute("skinIndex", new THREE.BufferAttribute(skinIndex, 4));
+    merged.setAttribute("skinWeight", new THREE.BufferAttribute(skinWeight, 4));
+    const mesh2 = new THREE.SkinnedMesh(merged, material);
+    const identities = meshes.map(() => new THREE.Matrix4());
+    mesh2.bind(new THREE.Skeleton(meshes, identities), new THREE.Matrix4());
+    mesh2.frustumCulled = false;
+    return mesh2;
+  }
+  function mergeGroup(THREE, { meshes, inverse: rootInverse, group, follow }) {
+    const identity = new THREE.Matrix4();
+    const inverse = follow ? identity : rootInverse;
+    const first = meshes[0];
+    const names = ATTRIBUTES.filter((name) => first.geometry.attributes[name] !== void 0);
+    const pieces = meshes.map((mesh22) => {
+      const local = new THREE.Matrix4().multiplyMatrices(inverse, mesh22.matrixWorld);
+      const vertices = mesh22.geometry.attributes.position.count;
+      const indexCount = mesh22.geometry.index ? mesh22.geometry.index.count : vertices;
+      return { mesh: mesh22, local, vertices, indexCount };
+    });
+    const totalVertices = pieces.reduce((sum, piece) => sum + piece.vertices, 0);
+    const totalIndices = pieces.reduce((sum, piece) => sum + piece.indexCount, 0);
+    const merged = new THREE.BufferGeometry();
+    const normalMatrix2 = new THREE.Matrix3();
+    for (const name of names) {
+      const size = first.geometry.attributes[name].itemSize;
+      const array = new Float32Array(totalVertices * size);
+      let offset = 0;
+      for (const piece of pieces) {
+        const matrix = follow ? identity : piece.local;
+        copyAttribute(name, piece.mesh.geometry.attributes[name], array, offset, matrix, normalMatrix2.getNormalMatrix(matrix));
+        offset += piece.vertices;
+      }
+      merged.setAttribute(name, new THREE.BufferAttribute(array, size));
+    }
+    const indexArray2 = totalVertices > 65535 ? new Uint32Array(totalIndices) : new Uint16Array(totalIndices);
+    const indexAttribute = new THREE.BufferAttribute(indexArray2, 1);
+    merged.setIndex(indexAttribute);
+    const mesh2 = follow ? skinnedBatch(THREE, merged, first.material, meshes) : new THREE.Mesh(merged, first.material);
+    mesh2.name = `batch:${first.material.name || first.material.type}`;
+    mesh2.castShadow = first.castShadow;
+    mesh2.receiveShadow = first.receiveShadow;
+    mesh2.raycast = () => void 0;
+    merged.computeBoundingBox();
+    merged.computeBoundingSphere();
+    group.add(mesh2);
+    const batch = { mesh: mesh2, live: pieces.length, index: indexAttribute };
+    const sources = [];
+    let vertexOffset = 0;
+    let indexOffset = 0;
+    for (const piece of pieces) {
+      const index = piece.mesh.geometry.index;
+      if (index) for (let at = 0; at < piece.indexCount; at++) indexArray2[indexOffset + at] = index.getX(at) + vertexOffset;
+      else for (let at = 0; at < piece.indexCount; at++) indexArray2[indexOffset + at] = at + vertexOffset;
+      sources.push({
+        mesh: piece.mesh,
+        geometry: piece.mesh.geometry,
+        material: piece.mesh.material,
+        version: piece.mesh.geometry.attributes.position.version,
+        local: piece.local,
+        world: piece.mesh.matrixWorld.clone(),
+        mask: piece.mesh.layers.mask,
+        batch,
+        start: indexOffset,
+        count: piece.indexCount,
+        released: false
+      });
+      piece.mesh.layers.set(BATCHED_LAYER);
+      vertexOffset += piece.vertices;
+      indexOffset += piece.indexCount;
+    }
+    return sources;
+  }
 
   // ../game-vehicles-driving/dist/index.js
   var defaultArcadeSpec = {
@@ -42811,6 +43981,169 @@ var GameVehiclesThree = (() => {
     return driver;
   }
 
+  // src/vehicle-lod.ts
+  var VEHICLE_LOD_DISTANCE = 14;
+  var BATCH_BUDGET_MS = 2;
+  var isShown2 = (object2, top) => {
+    for (let node = object2; node && node !== top; node = node.parent) if (node.visible === false) return false;
+    return true;
+  };
+  function createVehicleLod(kit, context, root, full) {
+    const THREE = kit.THREE;
+    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 [mesh2, wasCulled] of culled) mesh2.frustumCulled = wasCulled;
+      culled.clear();
+      modelKey = keyOf();
+      isUploaded = false;
+      full.traverse((object2) => {
+        if (!object2.isMesh || culled.has(object2)) return;
+        culled.set(object2, object2.frustumCulled);
+        object2.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 mesh2 of fused.children) {
+        if (!mesh2.isMesh || !mesh2.castShadow) continue;
+        const geometry2 = mesh2.geometry.clone().applyMatrix4(mesh2.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";
+      markKitOrigin(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 drawFull = () => {
+      if (!batcher && isLocked) return;
+      if (!batcher) {
+        lite ?? (lite = build());
+        lite.visible = isFused;
+        shadow ?? (shadow = shadowProxyOf(lite));
+        shadow.visible = !isFused;
+        full.traverse((object2) => {
+          if (!object2.isMesh || !object2.castShadow) return;
+          castsShadow.add(object2);
+          object2.castShadow = false;
+        });
+        batcher = createStaticBatcher(THREE, full, { budgetMs: BATCH_BUDGET_MS });
+        batcher.group.traverse((object2) => object2.userData.skipLite = true);
+        markKitOrigin(batcher.group, { owner: "game-vehicles-three", kind: "vehicle", id: root.name });
+        return;
+      }
+      batcher.update();
+      if (!isLocked && 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((object2) => {
+        if (!object2.isMesh || object2.userData.skipLite || !isShown2(object2, full)) return;
+        const materials = Array.isArray(object2.material) ? object2.material : [object2.material];
+        if (materials.some((material) => material?.map && !/plate/i.test(material.name ?? "")) && !/plate/i.test(object2.name ?? "")) textured.push(object2);
+      });
+      for (const mesh2 of textured) mesh2.userData.skipLite = true;
+      const fusion = fuse(THREE, { ...context, vehicle: full }, inverse, null, primaryPaint(context), kit.lodHiddenMaterials());
+      for (const mesh2 of textured) delete mesh2.userData.skipLite;
+      const group = new THREE.Group();
+      group.name = "vehicle-lite";
+      markKitOrigin(group, { owner: "game-vehicles-three", kind: "vehicle", id: root.name });
+      for (const mesh2 of liteMeshes(THREE, fusion, liteMaterials(THREE, kit.studioEnvironment()))) group.add(mesh2);
+      for (const mesh2 of textured) {
+        const copy = new THREE.Mesh(mesh2.geometry, mesh2.material);
+        copy.matrixAutoUpdate = false;
+        copy.matrix.multiplyMatrices(inverse, mesh2.matrixWorld);
+        copy.castShadow = mesh2.castShadow;
+        copy.receiveShadow = mesh2.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) {
+        isLocked || (isLocked = touched);
+        if (keyOf() !== modelKey) {
+          api.dispose();
+          armUpload();
+        }
+        if (!isUploaded) return show(false);
+        if (culled.size > 0) {
+          for (const [mesh2, wasCulled] of culled) mesh2.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 mesh2 of castsShadow) mesh2.castShadow = true;
+        castsShadow.clear();
+        shadow?.removeFromParent();
+        shadow?.geometry.dispose();
+        shadow = null;
+        if (!lite) return;
+        lite.removeFromParent();
+        lite.traverse((object2) => object2.geometry?.dispose());
+        lite = null;
+      }
+    };
+    return api;
+  }
+
   // src/test-area/text.ts
   var scenarioIds = [
     "vehicles_9mm_windshield",
@@ -43202,7 +44535,7 @@ var GameVehiclesThree = (() => {
     ];
   };
 
-  // ../game-audio/dist/index.js
+  // ../game-audio/dist/chunk-DZITVFMJ.js
   var DISTANCE_CURVES = {
     /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
     game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
@@ -43217,31 +44550,6 @@ var GameVehiclesThree = (() => {
     /** The game's animal calls: `max(0, 1 − d / 70) × 0.25`, silent at or below 0.005 (jogo L66627–66628). */
     animals: { model: "linear", range: 70, scale: 0.25, minGain: 5e-3 }
   };
-  var mix_profiles_default = [
-    {
-      id: "game",
-      master: 0.5,
-      noise: { seconds: 1.5, create: "lazy" },
-      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
-    },
-    {
-      id: "art_scene",
-      master: 0.85,
-      compressor: { threshold: -12, ratio: 5 },
-      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
-      noise: { seconds: 2, create: "eager" },
-      sources: [
-        "cena:L1308 compressor -12 dB, ratio 5",
-        "cena:L1309 master 0.85",
-        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
-        "cena:L1311 wet 0.4",
-        "cena:L1312 noise 2 s made with the chain"
-      ]
-    }
-  ];
-  var MIX_PROFILES = Object.fromEntries(
-    mix_profiles_default.map((profile) => [profile.id, profile])
-  );
   var game_sfx_default = {
     sources: ["jogo:L62089-62107"],
     note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
@@ -43374,6 +44682,31 @@ var GameVehiclesThree = (() => {
   var LIBRARY_SOUNDS = [horn_default, radio_static_default, siren_default];
   var LIBRARY_LOOPS = [engine_saw_default, rotor_blades_default, crowd_rumble_default];
   var LIBRARY_BANK = { id: "library", sounds: LIBRARY_SOUNDS, loops: LIBRARY_LOOPS };
+  var mix_profiles_default = [
+    {
+      id: "game",
+      master: 0.5,
+      noise: { seconds: 1.5, create: "lazy" },
+      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
+    },
+    {
+      id: "art_scene",
+      master: 0.85,
+      compressor: { threshold: -12, ratio: 5 },
+      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
+      noise: { seconds: 2, create: "eager" },
+      sources: [
+        "cena:L1308 compressor -12 dB, ratio 5",
+        "cena:L1309 master 0.85",
+        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
+        "cena:L1311 wet 0.4",
+        "cena:L1312 noise 2 s made with the chain"
+      ]
+    }
+  ];
+  var MIX_PROFILES = Object.fromEntries(
+    mix_profiles_default.map((profile) => [profile.id, profile])
+  );
   var BENCH_BANK = {
     id: "audio_bench",
     sounds: [
@@ -43420,6 +44753,236 @@ var GameVehiclesThree = (() => {
     ]
   };
 
+  // ../game-audio/dist/index.js
+  var ATTACK = 2e-3;
+  function lengthOf(d, attack) {
+    if (typeof d === "number") return attack + d;
+    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
+    return { ...d, add: (d.add ?? 0) + attack };
+  }
+  var envelope = (attack) => [
+    [0, 1e-4, "set", "fixed"],
+    [attack, 1, "exp"],
+    ["1d", 1e-4, "exp", "fixed"]
+  ];
+  function sceneNoise(o) {
+    const a = o.a ?? ATTACK;
+    const over = typeof o.d === "number" ? o.d : 0;
+    return {
+      filters: {
+        mode: "serial",
+        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
+      },
+      duration: lengthOf(o.d, a),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+      envelope: envelope(a)
+    };
+  }
+  function sceneTone(o) {
+    return {
+      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
+      duration: lengthOf(o.d, ATTACK),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      envelope: envelope(ATTACK)
+    };
+  }
+  function sceneVoice(o) {
+    return {
+      duration: lengthOf(o.d, 0),
+      gain: o.vol,
+      wet: 0.45,
+      source: {
+        kind: "formant_voice",
+        wave: o.wave ?? "sawtooth",
+        frequency: { from: o.f0, to: o.f1, curve: "linear", over: "duration" },
+        vibrato: { rate: [4, 10], depth: 0.08 },
+        formants: [
+          { frequency: o.fA, q: 4 },
+          { frequency: o.fB, q: 6 }
+        ],
+        breath: { frequency: o.fB, q: 1.1, gain: o.noise },
+        mix: 3.2
+      },
+      envelope: [
+        [0, 1e-4, "set", "fixed"],
+        [0.1, 1, "exp"],
+        ["0.6d", 1, "set"],
+        ["1d", 1e-4, "exp", "fixed"]
+      ]
+    };
+  }
+  var TAKES = [
+    { f: 1, t: 1, v: 1 },
+    { f: 1.08, t: 0.9, v: 0.92 },
+    { f: 0.93, t: 1.12, v: 1.05 },
+    { f: 1.03, t: 1.05, v: 0.88 }
+  ];
+  var FOOTSTEP_FALLOFF = { model: "inverse_square", k: 0.03, cutoffK: 0.03, minGain: 4e-3 };
+  var BODY_FALLOFF = { model: "inverse_square", k: 0.012, cutoffK: 0.015, minGain: 4e-3 };
+  var SURFACES = {
+    concrete: { heel: { f: 95, d: 0.05, vol: 0.55 }, roll: { type: "bandpass", f: 2300, q: 1.1, d: 0.05, vol: 0.38 }, grains: { count: 2, f: 4200, q: 2, spread: 0.04, vol: 0.08 } },
+    asphalt: { heel: { f: 90, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 1700, q: 0.9, d: 0.06, vol: 0.36 }, grains: { count: 4, f: 3600, q: 2.5, spread: 0.06, vol: 0.1 } },
+    wood: { heel: { f: 130, d: 0.08, vol: 0.55 }, roll: { type: "lowpass", f: 1300, q: 0.8, d: 0.06, vol: 0.3 }, ring: [{ f: 210, d: 0.1, vol: 0.18 }, { f: 470, d: 0.06, vol: 0.06 }] },
+    tile: { heel: { f: 110, d: 0.04, vol: 0.45 }, roll: { type: "bandpass", f: 3600, q: 2, d: 0.03, vol: 0.42 }, ring: [{ f: 1900, d: 0.03, vol: 0.05 }] },
+    dirt: { heel: { f: 75, d: 0.06, vol: 0.45 }, roll: { type: "lowpass", f: 750, q: 0.7, d: 0.09, vol: 0.4 }, grains: { count: 3, f: 1800, q: 1.5, spread: 0.07, vol: 0.06 } },
+    grass: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "highpass", f: 2600, q: 0.7, d: 0.13, vol: 0.28 }, grains: { count: 4, f: 5200, q: 1.2, spread: 0.1, vol: 0.07 } },
+    gravel: { heel: { f: 80, d: 0.05, vol: 0.4 }, roll: { type: "lowpass", f: 950, q: 0.8, d: 0.1, vol: 0.3 }, grains: { count: 8, f: 2600, q: 3, spread: 0.13, vol: 0.2 } },
+    sand: { heel: { f: 65, d: 0.06, vol: 0.3 }, roll: { type: "bandpass", f: 1500, q: 0.6, d: 0.16, vol: 0.3 }, grains: { count: 5, f: 4800, q: 1.5, spread: 0.12, vol: 0.05 } },
+    metal: { heel: { f: 120, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 2800, q: 1.5, d: 0.03, vol: 0.25 }, ring: [{ f: 420, d: 0.25, vol: 0.16 }, { f: 1130, d: 0.18, vol: 0.09 }, { f: 2470, d: 0.1, vol: 0.04 }] },
+    water: { heel: { f: 70, d: 0.04, vol: 0.25 }, roll: { type: "bandpass", f: 3e3, q: 1.2, d: 0.1, vol: 0.18 }, splash: { f: 1100, f2: 380, d: 0.22, vol: 0.55 }, grains: { count: 4, f: 2400, q: 6, spread: 0.18, vol: 0.12 } },
+    glass: { heel: { f: 90, d: 0.04, vol: 0.4 }, roll: { type: "highpass", f: 4500, q: 0.8, d: 0.06, vol: 0.2 }, grains: { count: 9, f: 6200, q: 5, spread: 0.12, vol: 0.22 }, ring: [{ f: 3900, d: 0.04, vol: 0.04 }, { f: 5300, d: 0.03, vol: 0.03 }] },
+    carpet: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "lowpass", f: 420, q: 0.7, d: 0.07, vol: 0.3 } }
+  };
+  var GAITS = {
+    walk: { vol: 1, bright: 1, toe: 0.075, short: 1 },
+    run: { vol: 1.35, bright: 1.25, toe: 0.035, short: 0.75 }
+  };
+  var grainLayers = (g, take, start2, scale) => Array.from(
+    { length: g.count },
+    (_, i) => sceneNoise({ type: "bandpass", f: [g.f * take.f * 0.85, g.f * take.f * 1.15], q: g.q, d: [8e-3, 0.02], vol: g.vol * scale * take.v, delay: start2 + (i + 0.5) / g.count * g.spread * take.t })
+  );
+  var ringLayers = (rings, take, scale, at = 0) => rings.map((r) => sceneTone({ f: r.f * take.f, d: r.d * take.t, vol: r.vol * scale * take.v, delay: at }));
+  function footLayers(surface, take, gait, weight = 1) {
+    const s = SURFACES[surface];
+    const toe = gait.toe * take.t;
+    return [
+      sceneTone({ f: s.heel.f * take.f * weight ** -0.3, f2: s.heel.f * take.f * 0.6, d: s.heel.d * gait.short * take.t * weight ** 0.5, vol: s.heel.vol * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: "lowpass", f: 500 * gait.bright, d: 0.02 * take.t, vol: 0.18 * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: s.roll.type, f: [s.roll.f * take.f * gait.bright * 0.92, s.roll.f * take.f * gait.bright * 1.08], q: s.roll.q, d: s.roll.d * gait.short * take.t * weight ** 0.3, vol: s.roll.vol * gait.vol * take.v, delay: toe }),
+      ...s.grains ? grainLayers(s.grains, take, toe * 0.5, gait.vol * weight ** 0.5) : [],
+      ...s.ring ? ringLayers(s.ring, take, gait.vol * weight ** 0.5) : [],
+      ...s.splash ? [sceneNoise({ type: "bandpass", f: s.splash.f * take.f, f2: s.splash.f2 * take.f, q: 1.4, d: s.splash.d * take.t * weight ** 0.4, vol: s.splash.vol * gait.vol * take.v * weight ** 0.5 })] : []
+    ];
+  }
+  var quieter = (level, layers) => layers.map((layer) => {
+    const gain = layer.gain ?? 1;
+    if (typeof gain === "number") return { ...layer, gain: gain * level };
+    if (Array.isArray(gain)) return { ...layer, gain: [gain[0] * level, gain[1] * level] };
+    return layer;
+  });
+  var recipe = (id, layers, falloff, bus = "world") => ({ id, bus, pan: true, layers, falloff, sources: ["sdk"] });
+  var takeId = (id, index) => `${id}_${String(index + 1).padStart(2, "0")}`;
+  function takes(id, layersOf, falloff, rate = [0.96, 1.04], bus) {
+    const sounds = TAKES.map((take, index) => recipe(takeId(id, index), layersOf(take, index), falloff, bus));
+    return { sounds, set: { id, variants: sounds.map((sound) => sound.id), rate } };
+  }
+  var footstep = (surface, gait) => takes(footstepSoundId(surface, gait), (take) => footLayers(surface, take, GAITS[gait]), FOOTSTEP_FALLOFF);
+  var LANDINGS = { light: { weight: 1.4, cloth: 0.12 }, heavy: { weight: 2.4, cloth: 0.22 } };
+  var LANDING_LEVEL = 0.65;
+  var landing = (surface, landing2) => takes(
+    `land_${surface}_${landing2}`,
+    (take) => quieter(LANDING_LEVEL, [
+      // both feet, a hair apart, then the knees taking the weight (a low body thump) and the clothes settling
+      ...footLayers(surface, take, GAITS.run, LANDINGS[landing2].weight),
+      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer) => ({ ...layer, at: (typeof layer.at === "number" ? layer.at : 0) + 0.018 * take.t })),
+      sceneTone({ f: 60 * take.f, f2: 38, d: 0.14 * LANDINGS[landing2].weight * take.t, vol: 0.22 * LANDINGS[landing2].weight ** 0.7 * take.v, delay: 0.02 }),
+      sceneNoise({ type: "bandpass", f: [1800, 2600], q: 0.8, d: 0.18, vol: LANDINGS[landing2].cloth * take.v, delay: 0.04 })
+    ]),
+    FOOTSTEP_FALLOFF
+  );
+  var whoosh = (blow, from, to, d, vol, q = 1.6) => (take) => [
+    // the air: a band sweeping up as the limb speeds up; it peaks `SWING_LEAD_SECONDS` in, the moment before the contact, then dies away
+    sceneNoise({ type: "bandpass", f: from * take.f, f2: to * take.f, q, a: SWING_LEAD_SECONDS[blow], d: d * take.t, vol: vol * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, a: SWING_LEAD_SECONDS[blow], d: d * take.t * 0.8, vol: vol * 0.35 * take.v })
+  ];
+  var fleshHit = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.slapF * take.f, q: 1.2, d: 0.03 * take.t, vol: o.slap * take.v }),
+    sceneNoise({ type: "highpass", f: 3500 * take.f, d: 0.012, vol: o.slap * 0.4 * take.v }),
+    sceneTone({ f: o.thudF * take.f, f2: o.thudF * 0.5, d: o.thudD * take.t, vol: o.thud * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, d: o.thudD * 1.2 * take.t, vol: o.thud * 0.5 * take.v }),
+    ...o.crack ? [sceneNoise({ type: "highpass", f: 2500, d: 0.015, vol: o.crack * take.v, delay: 6e-3 }), sceneTone({ wave: "square", f: 900 * take.f, f2: 300, d: 0.02, vol: o.crack * 0.15 * take.v, delay: 6e-3 })] : [],
+    ...o.wet ? [sceneNoise({ type: "bandpass", f: 1400 * take.f, f2: 500, q: 2.5, d: 0.12 * take.t, vol: o.wet * take.v, delay: 0.01 })] : []
+  ];
+  var knock = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.clickF * take.f, q: 1.5, d: 0.018, vol: o.click * take.v }),
+    ...o.tones.map(([f, d, vol]) => sceneTone({ f: f * take.f, d: d * take.t, vol: vol * take.v }))
+  ];
+  var voice = (o) => (take) => [
+    sceneVoice({ f0: o.f0 * take.f, f1: o.f1 * take.f, d: o.d * take.t, fA: o.fA * take.f, fB: o.fB * take.f, noise: o.noise, vol: o.vol * take.v })
+  ];
+  var BODY = {
+    jump: (take) => [
+      sceneNoise({ type: "bandpass", f: 900 * take.f, f2: 1700 * take.f, q: 1, a: 0.03, d: 0.12, vol: 0.18 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2200 * take.f, q: 0.8, d: 0.04, vol: 0.12 * take.v }),
+      sceneTone({ f: 85 * take.f, f2: 60, d: 0.04, vol: 0.2 * take.v })
+    ],
+    cloth_rustle: (take) => [
+      { ...sceneNoise({ type: "bandpass", f: 2400 * take.f, q: 0.8, a: 0.06, d: 0.22 * take.t, vol: 0.12 * take.v }), modulators: [{ target: "gain", wave: "triangle", rate: [9, 14], depth: 0.5 }] }
+    ],
+    body_fall: (take) => [
+      sceneTone({ f: 58 * take.f, f2: 35, d: 0.28 * take.t, vol: 0.9 * take.v }),
+      sceneNoise({ type: "lowpass", f: 480 * take.f, d: 0.3 * take.t, vol: 0.55 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, q: 1, d: 0.05, vol: 0.3 * take.v }),
+      // the limbs a moment later, and the clothes
+      sceneTone({ f: 75 * take.f, f2: 45, d: 0.12, vol: 0.4 * take.v, delay: 0.13 * take.t }),
+      sceneNoise({ type: "bandpass", f: 2200, q: 0.8, d: 0.2, vol: 0.12 * take.v, delay: 0.05 })
+    ],
+    fall_damage: (take) => [
+      ...BODY.body_fall(take),
+      sceneNoise({ type: "highpass", f: 2800, d: 0.02, vol: 0.35 * take.v, delay: 0.01 }),
+      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer) => ({ ...layer, at: 0.08 }))
+    ],
+    player_hurt: voice({ f0: 150, f1: 105, d: 0.26, fA: 620, fB: 1100, noise: 0.3, vol: 0.35 }),
+    player_breath_run: (take) => [
+      sceneNoise({ type: "bandpass", f: 1200 * take.f, q: 1, a: 0.08, d: 0.22 * take.t, vol: 0.25 * take.v }),
+      sceneNoise({ type: "bandpass", f: 900 * take.f, q: 1, a: 0.06, d: 0.26 * take.t, vol: 0.3 * take.v, delay: 0.3 * take.t })
+    ],
+    player_death: voice({ f0: 135, f1: 68, d: 1, fA: 560, fB: 980, noise: 0.35, vol: 0.4 }),
+    bite: (take) => [
+      sceneNoise({ type: "highpass", f: 2600, d: 0.015, vol: 0.4 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1600 * take.f, f2: 450, q: 2.2, d: 0.16 * take.t, vol: 0.55 * take.v, delay: 0.01 }),
+      sceneNoise({ type: "bandpass", f: 3200 * take.f, f2: 1800, q: 1.2, d: 0.22 * take.t, vol: 0.25 * take.v, delay: 0.09 }),
+      sceneTone({ f: 120 * take.f, f2: 70, d: 0.06, vol: 0.3 * take.v })
+    ],
+    grab: (take) => [
+      sceneNoise({ type: "bandpass", f: 1900 * take.f, q: 0.9, a: 4e-3, d: 0.13 * take.t, vol: 0.32 * take.v }),
+      sceneTone({ f: 95 * take.f, f2: 60, d: 0.07, vol: 0.3 * take.v }),
+      sceneNoise({ type: "lowpass", f: 700, d: 0.08, vol: 0.2 * take.v })
+    ],
+    punch_swing: whoosh("punch", 450, 1500, 0.16, 0.9),
+    punch_hit_body: fleshHit({ slap: 0.55, slapF: 1500, thud: 0.6, thudF: 115, thudD: 0.09 }),
+    punch_hit_face: fleshHit({ slap: 0.75, slapF: 2300, thud: 0.45, thudF: 150, thudD: 0.07, crack: 0.25 }),
+    punch_hit_object: knock({ clickF: 1800, click: 0.3, tones: [[210, 0.04, 0.25]] }),
+    kick_swing: whoosh("kick", 280, 950, 0.22, 1, 1.3),
+    kick_hit: fleshHit({ slap: 0.45, slapF: 1100, thud: 0.85, thudF: 82, thudD: 0.14 }),
+    kick_hit_object: knock({ clickF: 1e3, click: 0.3, tones: [[92, 0.08, 0.5]] }),
+    shove_two_hands: (take) => [
+      sceneNoise({ type: "bandpass", f: 950 * take.f, q: 0.9, a: 0.01, d: 0.13 * take.t, vol: 0.38 * take.v }),
+      sceneTone({ f: 100 * take.f, f2: 60, d: 0.1 * take.t, vol: 0.45 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2300, q: 0.8, d: 0.16, vol: 0.12 * take.v, delay: 0.03 })
+    ],
+    knife_swing: whoosh("blade", 1900, 4600, 0.12, 1.1, 2.2),
+    knife_stab: fleshHit({ slap: 0.2, slapF: 1200, thud: 0.4, thudF: 160, thudD: 0.06, wet: 0.5 }),
+    knife_slash: (take) => [
+      sceneNoise({ type: "highpass", f: 3200 * take.f, f2: 1800, d: 0.13 * take.t, vol: 0.35 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, f2: 600, q: 2.5, d: 0.12 * take.t, vol: 0.35 * take.v, delay: 0.02 })
+    ],
+    knife_hit_object: knock({ clickF: 3200, click: 0.25, tones: [[2800, 0.08, 0.07], [4150, 0.06, 0.05]] }),
+    blunt_swing: whoosh("blunt", 220, 760, 0.28, 1.1, 1.5),
+    blunt_hit: fleshHit({ slap: 0.35, slapF: 900, thud: 1, thudF: 70, thudD: 0.18, crack: 0.3 }),
+    blunt_hit_object: knock({ clickF: 1400, click: 0.35, tones: [[300, 0.12, 0.25], [760, 0.08, 0.12]] }),
+    axe_swing: whoosh("chop", 190, 620, 0.3, 1.2, 1.4),
+    axe_chop: fleshHit({ slap: 0.3, slapF: 1400, thud: 0.75, thudF: 140, thudD: 0.1, crack: 0.35, wet: 0.45 }),
+    axe_hit_object: knock({ clickF: 2200, click: 0.4, tones: [[1500, 0.15, 0.1], [2300, 0.1, 0.06], [140, 0.1, 0.35]] })
+  };
+  var BODY_BUS = { player_hurt: "voices", player_death: "voices", player_breath_run: "voices", fall_damage: "voices" };
+  var built = [
+    ...SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstep(surface, gait))),
+    ...SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((l) => landing(surface, l))),
+    ...BODY_SOUND_IDS.map((id) => takes(id, BODY[id], BODY_FALLOFF, id.endsWith("_swing") ? [0.94, 1.06] : [0.96, 1.04], BODY_BUS[id]))
+  ];
+  var BODY_FOLEY_BANK = {
+    id: "body_foley",
+    sounds: built.flatMap((entry) => entry.sounds),
+    sets: built.map((entry) => entry.set)
+  };
+  var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
   // src/test-area/types.ts
   var defaultEffectIds = {
     ignite: "vehicle_fire",
@@ -43442,10 +45005,12 @@ var GameVehiclesThree = (() => {
   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 LEAF_REST_RADIANS = 0.02;
   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 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;
@@ -43456,6 +45021,7 @@ var GameVehiclesThree = (() => {
     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();
+    const cabins = createCabinSmoke();
     let host = null;
     let three = null;
     let counter = 0;
@@ -43469,23 +45035,29 @@ var GameVehiclesThree = (() => {
       engineLoop?.stop();
       engineLoop = 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, ...options.document ? { document: options.document } : {} });
-          installFleet(kit);
+          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" ? paintPalettes.civil : settings.palette === "military" ? paintPalettes.military : paletteOf(key);
+    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;
-      const color2 = colorFromSeed(settings.seed + entry.index, paletteFor(entry.key));
+      entry.lod?.dispose();
+      delete entry.lod;
+      const color2 = fleet.colorFromSeed(settings.seed + entry.index, paletteFor(entry.key));
       if (!entry.paint) {
         const vehicle = entry.item.vehicle;
         const primary = primaryPaint(entry.item.vehicle);
@@ -43507,19 +45079,41 @@ var GameVehiclesThree = (() => {
       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);
+        const built2 = buildVehicleItem(kit, key, { lod: settings.quality === "lite", ...scenario ? { scenario } : {} });
+        built2.root.userData.kit = kit;
+        const entry = { root: built2.root, key, ...scenario ? { scenario } : {}, item: built2, index: counter++, helpers: [] };
+        placed.set(built2.root.uuid, entry);
         measure(entry);
         paintOf(entry);
-        return built.root;
+        return built2.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 });
+        const d = createVehicleDestructible(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;
       },
@@ -43531,10 +45125,10 @@ var GameVehiclesThree = (() => {
       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 });
+        const built2 = buildVehicleItem(kit, key);
+        const d = createVehicleDestructible(kit, built2.vehicle, { id: `${itemId(key)}_clips`, frame: built2.root, headless: true });
         clipCache.set(key, d.animations());
-        kit.dispose(built.vehicle);
+        kit.dispose(built2.vehicle);
       }
       return clipCache.get(key);
     };
@@ -43659,33 +45253,33 @@ var GameVehiclesThree = (() => {
       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 vehicles = createVehiclesThree(three, { kit, fleet });
+      const built2 = 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);
+      scene.add(built2.group, wall);
       const mode = settings.driving === "semi" ? "semi" : "arcade";
       const surfaces = createSurfaces();
       const idle = { throttle: 0, brake: 0, steer: 0, handbrake: false };
       const state = { time: 0, exhaust: 0, ended: false, wasBlocked: false };
-      const arcade = createArcadeDriver({ length: built.length, width: built.width });
+      const arcade = createArcadeDriver({ length: built2.length, width: built2.width });
       const semi = createSemiSimDriver({}, { 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 gap = () => LANE.wall - (driver.state.x + built2.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;
+        built2.group.position.set(driver.state.x, 0, driver.state.z);
+        built2.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,
+        car: built2,
+        group: built2.group,
         wall,
         mode,
         done: false,
@@ -43721,7 +45315,7 @@ var GameVehiclesThree = (() => {
           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) });
+            fx.play({ effect: effectIds.exhaust, point: [driver.state.x - Math.cos(driver.state.yaw) * (built2.length / 2), 0.3, driver.state.z + Math.sin(driver.state.yaw) * (built2.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;
@@ -43765,6 +45359,16 @@ var GameVehiclesThree = (() => {
           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) {
@@ -43772,9 +45376,11 @@ var GameVehiclesThree = (() => {
           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;
@@ -43801,7 +45407,7 @@ var GameVehiclesThree = (() => {
     const sizeError = () => {
       let worst = 0;
       for (const entry of placed.values()) {
-        const want = fleetDims(entry.key);
+        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));
@@ -43823,15 +45429,15 @@ var GameVehiclesThree = (() => {
         const rowOf = (list2, z) => {
           let cursor = 0;
           const spots = list2.map((entry) => {
-            const width = fleetDims(entry.key)?.width ?? 2;
+            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) => (fleetDims(e.key)?.width ?? 2) <= WIDE), 0);
-        const back = rowOf(entries.filter((e) => (fleetDims(e.key)?.width ?? 2) > WIDE), -16);
+        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] } };
       },
@@ -43870,11 +45476,15 @@ var GameVehiclesThree = (() => {
         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);
         return () => {
           stopChange?.();
           stopFrame();
           stopBlocker?.();
+          stopCrease?.();
+          cabins.clear(effects());
           clearHelpers();
           clearLane();
           host = null;