@adatechnology/game-vehicles 0.6.2 → 0.6.4

package/dist/index.global.js

@@ -62,7 +62,7 @@ var GameVehicles = (() => {
     wrapThreeForLod: () => wrapThreeForLod
   });
 
-  // ../game-shapes/dist/chunk-M5N2SHNL.js
+  // ../game-shapes/dist/chunk-FZQTELDQ.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));
@@ -938,17 +938,19 @@ var GameVehicles = (() => {
     if (p.prevZ) p.prevZ.nextZ = p.nextZ;
     if (p.nextZ) p.nextZ.prevZ = p.prevZ;
   }
-  function Node(i, x, y) {
-    this.i = i;
-    this.x = x;
-    this.y = y;
-    this.prev = null;
-    this.next = null;
-    this.z = 0;
-    this.prevZ = null;
-    this.nextZ = null;
-    this.steiner = false;
-  }
+  var Node = class {
+    constructor(i, x, y) {
+      this.i = i;
+      this.x = x;
+      this.y = y;
+      this.prev = null;
+      this.next = null;
+      this.z = 0;
+      this.prevZ = null;
+      this.nextZ = null;
+      this.steiner = false;
+    }
+  };
   function signedArea(data, start2, end, dim) {
     let sum = 0;
     for (let i = start2, j = end - dim; i < end; i += dim) {
@@ -2141,10 +2143,11 @@ var GameVehicles = (() => {
     return out;
   }
   function assignDeep(target, source) {
+    const t = target;
     Object.keys(source || {}).forEach(function(k) {
       const v = source[k];
-      if (v && typeof v === "object" && !Array.isArray(v)) target[k] = assignDeep(target[k] && typeof target[k] === "object" ? target[k] : {}, v);
-      else if (v !== void 0) target[k] = v;
+      if (v && typeof v === "object" && !Array.isArray(v)) t[k] = assignDeep(t[k] && typeof t[k] === "object" ? t[k] : {}, v);
+      else if (v !== void 0) t[k] = v;
     });
     return target;
   }
@@ -2527,7 +2530,9 @@ var GameVehicles = (() => {
       return t;
     }
     kit.textTexture = textTexture;
-    Object.assign(I, { RUST, cache: cache2, studioEnvironment, makeMaterial, makeFlatMaterial, DOUBLE_SIDE, toColor, MATERIALS, paintColor, texCache, textTexture });
+    const shared = { RUST, cache: cache2, studioEnvironment, makeMaterial, makeFlatMaterial, DOUBLE_SIDE, toColor, MATERIALS, paintColor, texCache, textTexture };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/tri-index.ts
@@ -2682,7 +2687,8 @@ var GameVehicles = (() => {
     }
     return s;
   }
-  function indexable(THREE, mesh2) {
+  function indexable(THREE, object2) {
+    const mesh2 = object2;
     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;
@@ -3281,21 +3287,23 @@ var GameVehicles = (() => {
         let wb = 0;
         segs.forEach(function(seg) {
           if (typeof seg[0] === "number") {
+            const run = seg;
             for (let a = 0; a < names.length; a++) {
               const size = sizes[a];
               if (!idx) {
-                dst[a].set(arrs[a].subarray(seg[0] * 3 * size, seg[1] * 3 * size), w[a]);
-                w[a] += (seg[1] - seg[0]) * 3 * size;
+                dst[a].set(arrs[a].subarray(run[0] * 3 * size, run[1] * 3 * size), w[a]);
+                w[a] += (run[1] - run[0]) * 3 * size;
                 continue;
               }
-              for (let f = seg[0] * 3; f < seg[1] * 3; f++) for (let q = 0; q < size; q++) dst[a][w[a]++] = arrs[a][idx[f] * size + q];
+              for (let f = run[0] * 3; f < run[1] * 3; f++) for (let q = 0; q < size; q++) dst[a][w[a]++] = arrs[a][idx[f] * size + q];
             }
             if (boxesOut2 && ti) {
-              boxesOut2.set(ti.boxes.subarray(seg[0] * 6, seg[1] * 6), wb);
-              wb += (seg[1] - seg[0]) * 6;
+              boxesOut2.set(ti.boxes.subarray(run[0] * 6, run[1] * 6), wb);
+              wb += (run[1] - run[0]) * 6;
             }
             return;
           }
+          ;
           seg.forEach(function(t) {
             if (boxesOut2) {
               for (let k = 0; k < 3; k++) {
@@ -3489,7 +3497,9 @@ var GameVehicles = (() => {
         }
       };
     };
-    Object.assign(I, { roundedBoxGeometry, taper, subdivide, crease, creaseTask, refreshBounds, pathShape, tumble, loftGeometry, hullGeometry, cutGeometry, mergeGeometries, uvProject });
+    const shared = { roundedBoxGeometry, taper, subdivide, crease, creaseTask, refreshBounds, pathShape, tumble, loftGeometry, hullGeometry, cutGeometry, mergeGeometries, uvProject };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/context.ts
@@ -3743,6 +3753,7 @@ var GameVehicles = (() => {
     }
     kit.BuildContext = BuildContext;
     I.BuildContext = BuildContext;
+    return { resolveLabel, BuildContext };
   }
 
   // src/warp.ts
@@ -3938,7 +3949,9 @@ var GameVehicles = (() => {
     kit.applyWarp = applyWarp;
     kit.geo.resample = resample;
     kit.geo.smoothLoft = smoothLoft;
-    Object.assign(I, { makeWarp, applyWarp, resample, smoothLoft });
+    const shared = { makeWarp, applyWarp, resample, smoothLoft };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/body.ts
@@ -4004,23 +4017,24 @@ var GameVehicles = (() => {
         o.arches.forEach(function(a) {
           const a0 = Math.asin(clamp((o.bottomY - a[1]) / a[2], -1, 1));
           const rr = a[2] - 0.01;
+          const archInner = o.archInner;
           if (o.archInner == null) {
             const wl = c.add(new THREE.CylinderGeometry(rr, rr, o.W - 0.12, 20, 1, true, a0 + PI / 2, PI - 2 * a0), MATERIALS.dark, a[0], a[1], 0);
             wl.rotation.x = PI / 2;
             wl.castShadow = false;
           } else
             [1, -1].forEach(function(s) {
-              const len = o.W / 2 - 0.06 - o.archInner;
+              const len = o.W / 2 - 0.06 - archInner;
               const w2 = c.add(
                 new THREE.CylinderGeometry(rr, rr, len, 20, 1, true, a0 + PI / 2, PI - 2 * a0),
                 MATERIALS.dark,
                 a[0],
                 a[1],
-                s * (o.archInner + len / 2)
+                s * (archInner + len / 2)
               );
               w2.rotation.x = PI / 2;
               w2.castShadow = false;
-              const cap = c.add(new THREE.CircleGeometry(rr, 20, a0, PI - 2 * a0), MATERIALS.dark, a[0], a[1], s * o.archInner);
+              const cap = c.add(new THREE.CircleGeometry(rr, 20, a0, PI - 2 * a0), MATERIALS.dark, a[0], a[1], s * archInner);
               cap.castShadow = false;
             });
         });
@@ -4097,8 +4111,12 @@ var GameVehicles = (() => {
         if (!q.isMesh || !q.visible || q.userData.glass || q.userData.decal || q.isSprite) return;
         if (o.all || dset.has(q) || c.paints && c.paints.has(q.material)) cands.push(q);
       });
-      const d = (dir.isVector3 ? dir.clone() : new V3(dir[0], dir[1], dir[2])).normalize();
-      const p0 = org.isVector3 ? org.clone() : new V3(org[0], org[1], org[2]);
+      const dv = dir;
+      const da = dir;
+      const d = (dv.isVector3 ? dv.clone() : new V3(da[0], da[1], da[2])).normalize();
+      const ov = org;
+      const oa = org;
+      const p0 = ov.isVector3 ? ov.clone() : new V3(oa[0], oa[1], oa[2]);
       _sr.set(p0.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
       _sr.near = 0;
       _sr.far = o.max || 20;
@@ -4115,7 +4133,9 @@ var GameVehicles = (() => {
       const h = kit.surfaceAt(c, new V3(x0, y, z || 0), new V3(-sg, 0, 0));
       return h ? h.p.x : items ? profX(items, y, front !== false) : null;
     };
-    Object.assign(I, { halfAt, shell, autoWindows, profX, _sr });
+    const shared = { halfAt, shell, autoWindows, profX, _sr };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/glass.ts
@@ -4124,7 +4144,8 @@ var GameVehicles = (() => {
     const V3 = THREE.Vector3;
     const I = kit._;
     const { MATERIALS, crease, cutGeometry, pathShape, subdivide, tumble, uvProject } = I;
-    I.paneSeals = /* @__PURE__ */ new WeakMap();
+    const paneSeals = /* @__PURE__ */ new WeakMap();
+    I.paneSeals = paneSeals;
     kit.addGlass = function(c, geo, label, type, o) {
       o = o || {};
       if (!geo.attributes.uv || o.reuv) o.aspect = uvProject(geo, o.uvAxes);
@@ -4221,7 +4242,7 @@ var GameVehicles = (() => {
     };
     kit.quadDef = function(pb, pt, Wg, T, which, bev, o) {
       o = o || {};
-      bev = bev == null ? 0.05 : bev;
+      const bv = bev == null ? 0.05 : bev;
       const dx = pt[0] - pb[0];
       const dy = pt[1] - pb[1];
       const L = Math.hypot(dx, dy);
@@ -4230,13 +4251,13 @@ var GameVehicles = (() => {
       const nx = which === "front" ? uy : -uy;
       const ny = which === "front" ? -ux : ux;
       const ins = o.inset || 0.09;
-      const off = bev + 6e-3;
+      const off = bv + 6e-3;
       const sd = o.side || 0.1;
       const b = [pb[0] + ux * ins + nx * off, pb[1] + uy * ins + ny * off];
       const t = [pt[0] - ux * ins * 1.3 + nx * off, pt[1] - uy * ins * 1.3 + ny * off];
       const hb = I.halfAt(Wg, T, b[1]) - sd;
       const ht = I.halfAt(Wg, T, t[1]) - sd;
-      return { pb, pt, L, u: [ux, uy], n: [nx, ny], ins, b, t, hb, ht, which, bev, Wg, T };
+      return { pb, pt, L, u: [ux, uy], n: [nx, ny], ins, b, t, hb, ht, which, bev: bv, Wg, T };
     };
     kit.glassQuad = function(c, q, label, o) {
       o = o || {};
@@ -4290,7 +4311,9 @@ var GameVehicles = (() => {
       c.quads.push(q);
       return m;
     };
-    Object.assign(I, {});
+    const shared = { paneSeals };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/lights.ts
@@ -4627,7 +4650,9 @@ var GameVehicles = (() => {
       if (o.emblem !== false) kit.emblem(c, 0.05, st === "closed" ? h * 0.12 : 0, 0, Math.min(0.05, h * 0.3), g);
       return g;
     };
-    Object.assign(I, { lampGroup, gm, wedgeY, haloTex, glowTexture, haloMats, halo, lampKit });
+    const shared = { lampGroup, gm, wedgeY, haloTex, glowTexture, haloMats, halo, lampKit };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/interior.ts
@@ -4879,7 +4904,9 @@ var GameVehicles = (() => {
       c.roundBox(o.x0 - o.x1 + 1, 0.03, zi * 2, 0.01, MATERIALS.carpet, (o.x0 + o.x1) / 2, o.floor, 0);
       return n;
     };
-    Object.assign(I, { consoleBox });
+    const shared = { consoleBox };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/hood.ts
@@ -5274,7 +5301,9 @@ var GameVehicles = (() => {
       };
       return out;
     };
-    Object.assign(I, {});
+    const shared = {};
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/car.ts
@@ -5632,7 +5661,9 @@ var GameVehicles = (() => {
       });
       return out;
     };
-    Object.assign(I, {});
+    const shared = {};
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/trucks.ts
@@ -5777,7 +5808,9 @@ var GameVehicles = (() => {
       m.rear = rear;
       m.length = L;
     };
-    Object.assign(I, {});
+    const shared = {};
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/wheels.ts
@@ -5916,7 +5949,9 @@ var GameVehicles = (() => {
       c.part("track", kit.t("parts.track", { s: z > 0 ? 1 : -1 }), tm, new V3((x0 + x1) / 2, 0.3, z), 1.4);
       return { mesh: tm, wheels: gs, sprocket: spr, idler: idl };
     };
-    Object.assign(I, {});
+    const shared = {};
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/routed-particles.ts
@@ -6345,7 +6380,7 @@ var GameVehicles = (() => {
         }
       });
     }
-    Object.assign(I, {
+    const shared = {
       PARTICLE_LIMIT,
       PARTICLE_GEOMETRIES,
       PARTICLE_MATERIALS,
@@ -6365,7 +6400,9 @@ var GameVehicles = (() => {
       burst,
       exhaustLook,
       tickEmit
-    });
+    };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/fluids.ts
@@ -6839,7 +6876,9 @@ var GameVehicles = (() => {
       }
       return n;
     };
-    Object.assign(I, { _fr, buildDrip, DOWNHILL, PN, puddleGeometry, rimGeometry, puddle, shapePuddle, updateFluids });
+    const shared = { _fr, buildDrip, DOWNHILL, PN, puddleGeometry, rimGeometry, puddle, shapePuddle, updateFluids };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/glass-damage.ts
@@ -7163,8 +7202,20 @@ var GameVehicles = (() => {
       if (!L || L.broken) return;
       L.broken = true;
       L.lens.forEach(function(m) {
-        m.visible = false;
+        const rim = L.lensMaterial ? glassRim(m.geometry, c.rand) : null;
+        if (!rim) {
+          m.visible = false;
+          return;
+        }
+        m.geometry.dispose();
+        m.geometry = rim;
+        m.material = MATERIALS.glassEdge;
+        m.userData.lensRim = true;
       });
+      if (L.lensMaterial)
+        (L.reflector || []).forEach(function(m) {
+          m.material = MATERIALS.broken;
+        });
       L.inner.forEach(function(m) {
         m.material = MATERIALS.bulbBroken;
       });
@@ -7172,11 +7223,40 @@ var GameVehicles = (() => {
         h.visible = false;
       });
       const p = L.group ? L.group.position.clone() : L.inner[0] ? L.inner[0].position.clone() : new V3();
-      I.burst(c, "lens", c.toEffects(p), 10, { dir: c.dirToEffects(dir.clone().negate()), speed: 1.4, variant: L.tint === "red" ? "red" : "clear" });
-      I.burst(c, "plastic", c.toEffects(p), 2, { dir: c.dirToEffects(dir.clone().negate()), speed: 1 });
+      const glass = L.lensMaterial !== "plastic";
+      I.burst(c, "lens", c.toEffects(p), glass ? 10 : 5, { dir: c.dirToEffects(dir.clone().negate()), speed: glass ? 1.4 : 1.1, variant: L.tint === "red" ? "red" : "clear" });
+      I.burst(c, "plastic", c.toEffects(p), glass ? 2 : 5, { dir: c.dirToEffects(dir.clone().negate()), speed: 1 });
     }
     kit.breakLight = breakLight;
-    Object.assign(I, { glassUV, drawWeb, crackGlass, glassRim, shatterGlass, hitGlass, breakLight });
+    const crazedCache = /* @__PURE__ */ new Map();
+    const CRAZED_OPACITY = 0.6;
+    function crazed(material) {
+      const known = crazedCache.get(material);
+      if (known) return known;
+      const m = I.crackLens(material).clone();
+      m.opacity = Math.max(m.opacity ?? 1, CRAZED_OPACITY);
+      m.transparent = true;
+      m.userData.shared = true;
+      crazedCache.set(material, m);
+      return m;
+    }
+    function crackLight(c, L, dir, pierced) {
+      if (!L || L.broken) return;
+      if (!L.cracked) {
+        L.cracked = true;
+        for (const m of L.lens) if (m.material && !Array.isArray(m.material)) m.material = crazed(m.material);
+      }
+      const p = L.group ? L.group.position.clone() : L.inner[0] ? L.inner[0].position.clone() : new V3();
+      I.burst(c, "lens", c.toEffects(p), 3, { dir: c.dirToEffects(dir.clone().negate()), speed: 0.9, variant: L.tint === "red" ? "red" : "clear" });
+      if (!pierced || L.dark) return;
+      L.dark = true;
+      for (const m of L.inner) m.material = MATERIALS.bulbBroken;
+      for (const h of L.halo ?? []) h.visible = false;
+    }
+    kit.crackLight = crackLight;
+    const shared = { glassUV, drawWeb, crackGlass, glassRim, shatterGlass, hitGlass, breakLight, crackLight };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/impact.ts
@@ -7650,7 +7730,7 @@ var GameVehicles = (() => {
       return hit;
     }
     kit.zoneImpact = zoneImpact;
-    Object.assign(I, {
+    const shared = {
       dentField,
       hangBumper,
       tankFuel,
@@ -7666,7 +7746,9 @@ var GameVehicles = (() => {
       _pr,
       probe,
       zoneImpact
-    });
+    };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/explosion.ts
@@ -8051,7 +8133,9 @@ var GameVehicles = (() => {
         }
       }
     }
-    Object.assign(I, { BURNT, BURNT_RUB, boomMat, enginePos, fling, burnAll, bigBoomFx, detonate, tickBoom, tickFlying });
+    const shared = { BURNT, BURNT_RUB, boomMat, enginePos, fling, burnAll, bigBoomFx, detonate, tickBoom, tickFlying };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/rollover.ts
@@ -8253,7 +8337,8 @@ var GameVehicles = (() => {
         c.parts.forEach(function(p) {
           if (p.kind !== "rotor" && p.kind !== "tail_rotor" || !p.obj) return;
           const main = p.kind === "rotor";
-          p.obj.traverse(function(o) {
+          p.obj.traverse(function(node) {
+            const o = node;
             if (!o.isMesh || !o.visible) return;
             const bb = new THREE.Box3().setFromObject(o).applyMatrix4(inv);
             if (!main && bb.min.y >= -0.01) return;
@@ -8325,7 +8410,9 @@ var GameVehicles = (() => {
       if (p >= 1) finishRoll(c);
     }
     kit.rollContact = rollContact;
-    Object.assign(I, { rollMeshes, convexHull, rollContact, exactMinY, finishRoll, tickRoll });
+    const shared = { rollMeshes, convexHull, rollContact, exactMinY, finishRoll, tickRoll };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/tick.ts
@@ -8363,7 +8450,9 @@ var GameVehicles = (() => {
       c.hood.target = open ? c.hood.open : 0;
       return true;
     };
-    Object.assign(I, {});
+    const shared = {};
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/armor.ts
@@ -8615,7 +8704,9 @@ var GameVehicles = (() => {
       }
     }
     kit.applyArmor = applyArmor;
-    Object.assign(I, { STEEL_MATERIAL, PLATE_MATERIALS, jerryCan, applyArmor });
+    const shared = { STEEL_MATERIAL, PLATE_MATERIALS, jerryCan, applyArmor };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/zone-core.ts
@@ -8634,8 +8725,8 @@ var GameVehicles = (() => {
       return { id: b.id, name: kit.t("bands." + b.id), min: b.min, health: b.health, color: b.color };
     });
     function bandOf(h) {
-      h = Math.round(clamp(h == null ? 100 : h, 0, 100));
-      for (let i = 0; i < BANDS.length; i++) if (h >= BANDS[i].min) return i;
+      const v = Math.round(clamp(h == null ? 100 : h, 0, 100));
+      for (let i = 0; i < BANDS.length; i++) if (v >= BANDS[i].min) return i;
       return 4;
     }
     kit.bands = BANDS;
@@ -8661,8 +8752,12 @@ var GameVehicles = (() => {
           z0: Math.min(b[4], b[5]),
           z1: Math.max(b[4], b[5])
         };
-      if (b.isBox3) return { x0: b.min.x, x1: b.max.x, y0: b.min.y, y1: b.max.y, z0: b.min.z, z1: b.max.z };
-      return { x0: b.x0, x1: b.x1, y0: b.y0, y1: b.y1, z0: b.z0, z1: b.z1 };
+      if (b.isBox3) {
+        const box2 = b;
+        return { x0: box2.min.x, x1: box2.max.x, y0: box2.min.y, y1: box2.max.y, z0: box2.min.z, z1: box2.max.z };
+      }
+      const r = b;
+      return { x0: r.x0, x1: r.x1, y0: r.y0, y1: r.y1, z0: r.z0, z1: r.z1 };
     }
     kit.normalizeBox = normalizeBox;
     function boxLo(B, a) {
@@ -8699,7 +8794,8 @@ var GameVehicles = (() => {
       const bb = new THREE.Box3();
       const tmp = new THREE.Box3();
       const M = new THREE.Matrix4();
-      o.traverse(function(x) {
+      o.traverse(function(node) {
+        const x = node;
         if (!x.isMesh || !x.geometry || !x.geometry.attributes.position || x.userData.decal) return;
         if (!x.geometry.boundingBox) x.geometry.computeBoundingBox();
         tmp.copy(x.geometry.boundingBox).applyMatrix4(M.multiplyMatrices(inv, x.matrixWorld));
@@ -8765,7 +8861,7 @@ var GameVehicles = (() => {
       for (let q = o; q && q !== c.vehicle; q = q.parent) if (q.visible === false) return false;
       return !!o;
     }
-    Object.assign(I, {
+    const shared = {
       BANDS,
       bandOf,
       ZONE_WEIGHTS,
@@ -8788,7 +8884,9 @@ var GameVehicles = (() => {
       lightBoxOf,
       hideObj,
       shown
-    });
+    };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/zone-decals.ts
@@ -9073,7 +9171,10 @@ var GameVehicles = (() => {
         narrowTo(rc, q);
       }
       const hits = rc.intersectObjects(cands, false);
-      for (let i = 0; i < hits.length; i++) if (hits[i].object.proxyOf) hits[i].object = hits[i].object.proxyOf;
+      for (let i = 0; i < hits.length; i++) {
+        const proxyOf = hits[i].object.proxyOf;
+        if (proxyOf) hits[i].object = proxyOf;
+      }
       return hits;
     }
     function zoneCands(c, z, inv, glassToo) {
@@ -9274,7 +9375,7 @@ var GameVehicles = (() => {
       for (i = 0; i < (spec.tear || 0); i++) if (s = nx()) tears.push(tearDecal(c, s.p, s.n, 0.07 + R() * 0.06, R, s.obj));
       return S;
     }
-    Object.assign(I, {
+    const shared = {
       dmat,
       DAMAGE_MATERIALS,
       _zq,
@@ -9295,7 +9396,9 @@ var GameVehicles = (() => {
       ribbonGeo,
       scratchDecal,
       zoneDecals
-    });
+    };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/zone-dent.ts
@@ -9653,7 +9756,9 @@ var GameVehicles = (() => {
       });
       return piv;
     }
-    Object.assign(I, { sm, subdivIn, dentTargets, zoneDent, cutPanel, pivotOf });
+    const shared = { sm, subdivIn, dentTargets, zoneDent, cutPanel, pivotOf };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/damage-panels.ts
@@ -10006,7 +10111,9 @@ var GameVehicles = (() => {
       const sgn = new V3().crossVectors(axisV, tangent).dot(outv) > 0 ? 1 : -1;
       piv.quaternion.setFromAxisAngle(axisV, sgn * (0.6 + R() * 0.3));
     }
-    Object.assign(I, { panelBand, roofOff, tailOff, followersIn, windowsOver, doorGap, mirrorHang, doorHang, lidHang, flapHang });
+    const shared = { panelBand, roofOff, tailOff, followersIn, windowsOver, doorGap, mirrorHang, doorHang, lidHang, flapHang };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/damage-parts.ts
@@ -10122,7 +10229,8 @@ var GameVehicles = (() => {
     }
     function tireMeshes(w) {
       const out = [];
-      w.traverse(function(o) {
+      w.traverse(function(node) {
+        const o = node;
         if (o.isMesh && o.material === MATERIALS.rubber) out.push(o);
       });
       return out;
@@ -10181,7 +10289,8 @@ var GameVehicles = (() => {
         c.zoneDrops.push({ x: w.position.x, z: w.position.z, d: r * 0.24 });
       } else if (b === 4) {
         let rr = 0;
-        w.traverse(function(o) {
+        w.traverse(function(node) {
+          const o = node;
           if (!o.isMesh || o.material === MATERIALS.rubber) return;
           if (!o.geometry.boundingSphere) o.geometry.computeBoundingSphere();
           const cc = o.geometry.boundingSphere.center.clone().applyMatrix4(o.matrix);
@@ -10389,7 +10498,8 @@ var GameVehicles = (() => {
         const xf = H.x0 + (H.x1 - H.x0) * (0.5 + R() * 0.1);
         const k = 0.55 + R() * 0.2;
         const v = new V3();
-        H.piv.children.forEach(function(msh) {
+        H.piv.children.forEach(function(node) {
+          const msh = node;
           if (!msh.isMesh) return;
           msh.updateMatrix();
           const M = msh.matrix;
@@ -10582,7 +10692,7 @@ var GameVehicles = (() => {
       });
       void K;
     }
-    Object.assign(I, {
+    const shared = {
       glassPt,
       glassIn,
       glassBand,
@@ -10600,7 +10710,9 @@ var GameVehicles = (() => {
       bumperBand,
       partBand,
       bendAft
-    });
+    };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/zone-derive.ts
@@ -10623,7 +10735,8 @@ var GameVehicles = (() => {
     }
     function resolveObjs(c, list2, z) {
       const out = [];
-      (list2 || []).forEach(function(o) {
+      (list2 || []).forEach(function(item) {
+        const o = item;
         if (!o) return;
         if (typeof o === "string") {
           c.parts.forEach(function(p) {
@@ -10872,7 +10985,9 @@ var GameVehicles = (() => {
       return null;
     }
     kit.zoneOwner = ownerOf;
-    Object.assign(I, { parseDir, resolveObjs, deriveZones, carMap, zonesOf, ownerOf });
+    const shared = { parseDir, resolveObjs, deriveZones, carMap, zonesOf, ownerOf };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/zone-auto.ts
@@ -11667,7 +11782,9 @@ var GameVehicles = (() => {
       if (!wheelsDone) wheelZones(false);
       return Z;
     }
-    Object.assign(I, { autoZones });
+    const shared = { autoZones };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/zone-apply.ts
@@ -11878,7 +11995,9 @@ var GameVehicles = (() => {
       c.rand = R0;
       return c.zoneState;
     };
-    Object.assign(I, { fadePaint, abandonFx, burntFx, settleDrops });
+    const shared = { fadePaint, abandonFx, burntFx, settleDrops };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/scenarios.ts
@@ -12035,7 +12154,9 @@ var GameVehicles = (() => {
       }
       return { p, dir };
     };
-    Object.assign(I, { BODY_TYPES });
+    const shared = { BODY_TYPES };
+    Object.assign(I, shared);
+    return shared;
   }
 
   // src/ui.ts
@@ -12192,7 +12313,8 @@ var GameVehicles = (() => {
         }
         g.addEventListener("click", pick);
         g.addEventListener("keydown", function(e) {
-          if (e.key === "Enter" || e.key === " ") {
+          const key = e.key;
+          if (key === "Enter" || key === " ") {
             e.preventDefault();
             pick();
           }
@@ -12205,7 +12327,7 @@ var GameVehicles = (() => {
       return kit.bands.map(function(B, i) {
         const b = el("button", null, B.name);
         b.type = "button";
-        b.dataset.b = i;
+        b.dataset.b = String(i);
         b.style.setProperty("--band", B.color);
         b.addEventListener("click", function() {
           if (onPick) onPick(B.health, i);
@@ -12433,6 +12555,7 @@ var GameVehicles = (() => {
       hash,
       clamp,
       smooth,
+      // filled by the modules below, each with the helpers it shares
       _: {}
     };
     kit.fuels = {};
@@ -12510,8 +12633,8 @@ var GameVehicles = (() => {
         fn.apply(kit, args);
       });
     };
-    kit.configure = function(o) {
-      o = o || {};
+    kit.configure = function(cfg) {
+      const o = cfg || {};
       if (o.bands)
         o.bands.forEach(function(b, i) {
           if (kit.bands[i] && b) Object.assign(kit.bands[i], b);
@@ -12547,7 +12670,8 @@ var GameVehicles = (() => {
       }
       ;
       ["impactStain", "defaultSplat", "defaultGroup", "damagedScenario"].forEach(function(k) {
-        if (o[k] !== void 0) kit.config[k] = o[k];
+        const v = o[k];
+        if (v !== void 0) kit.config[k] = v;
       });
       return kit;
     };
@@ -12726,6 +12850,8 @@ var GameVehicles = (() => {
     heli: ["battery", "alternator", "gearbox"]
   };
   var HITCH_CHANCE = { car: 30, truck: 60, bus: 0, tractor: 100, quad: 40, bike: 0, tank: 0, boat: 0, plane: 0, heli: 0 };
+  var GLASS_LENS_HP = 320;
+  var PLASTIC_LENS_HP = 900;
   var STEEL_KG_M2 = 7;
   var ALU_KG_M2 = 3.2;
   var kindOf = (c) => {
@@ -12883,7 +13009,9 @@ var GameVehicles = (() => {
         continue;
       }
       if (role === "light") {
-        add({ id, role, name: label, material: "glass", box: box2, mass: 1.2 + 4 * area3, hp: 320, zoneId: id, visual: true, tags: ["light", ...tags] });
+        const lens = /^head/.test(id) ? spec.headlightLens ?? "polycarbonate" : "acrylic";
+        const glassLens = lens === "glass";
+        add({ id, role, name: label, material: glassLens ? "glass" : "plastic", box: box2, mass: 1.2 + 4 * area3, hp: glassLens ? GLASS_LENS_HP : PLASTIC_LENS_HP, zoneId: id, visual: true, tags: ["light", `lens_${lens}`, ...tags] });
         continue;
       }
       if (role === "bumper") {
@@ -13340,21 +13468,188 @@ var GameVehicles = (() => {
     mesh2.geometry = g;
   }
 
+  // src/destructible/door-open.ts
+  var STRIP_SMOOTH_DEG = 180;
+  var SKIN_BAND = 0.05;
+  var BODY_FACING = 0.5;
+  var FIELDS = 4;
+  var SEAM_THIN = 0.03;
+  var SEAM_AT_EDGE = 0.04;
+  var SEAM_TALL = 0.4;
+  var SLIVER_AREA = 1e-10;
+  function cutStripOverDoor(vehicleKit, params) {
+    const kit = vehicleKit;
+    const strip = params.strip;
+    const toVehicle = params.toVehicle;
+    const { x0, x1 } = params;
+    const THREE = kit.THREE;
+    const at = new THREE.Vector3();
+    const along = (x, y, z) => at.set(x, y, z).applyMatrix4(toVehicle).x;
+    const piece = (tests) => {
+      const mesh2 = new THREE.Mesh(strip.geometry.clone(), strip.material);
+      kit.cutMesh(mesh2, tests, STRIP_SMOOTH_DEG, {});
+      return mesh2;
+    };
+    const over = piece([{ sdf: (x, y, z) => along(x, y, z) - x0 }, { sdf: (x, y, z) => x1 - along(x, y, z) }]);
+    const after = piece([{ sdf: (x, y, z) => along(x, y, z) - x1 }]);
+    kit.cutMesh(strip, [{ sdf: (x, y, z) => x0 - along(x, y, z) }], STRIP_SMOOTH_DEG, {});
+    const joined = joinTriangles(THREE, strip.geometry, after.geometry);
+    strip.geometry.dispose();
+    after.geometry.dispose();
+    strip.geometry = joined;
+    return over;
+  }
+  function joinTriangles(THREE, first, second) {
+    const a = first.index ? first.toNonIndexed() : first;
+    const b = second.index ? second.toNonIndexed() : second;
+    const flags = [...solidTriangles(THREE, a), ...solidTriangles(THREE, b)];
+    const both = new THREE.BufferGeometry();
+    for (const name of Object.keys(a.attributes)) {
+      const p = a.getAttribute(name);
+      const q = b.getAttribute(name);
+      if (!q || q.itemSize !== p.itemSize) continue;
+      const array = new Float32Array(p.array.length + q.array.length);
+      array.set(p.array, 0);
+      array.set(q.array, p.array.length);
+      both.setAttribute(name, new THREE.Float32BufferAttribute(array, p.itemSize));
+    }
+    if (a !== first) a.dispose();
+    if (b !== second) b.dispose();
+    const out = pickTriangles(THREE, both, flags, true) ?? new THREE.BufferGeometry();
+    both.dispose();
+    return out;
+  }
+  function solidTriangles(THREE, geometry) {
+    const pos = geometry.getAttribute("position");
+    const triangle = new THREE.Triangle();
+    const flags = [];
+    for (let t = 0; t * 3 + 2 < pos.count; t++) {
+      triangle.a.fromBufferAttribute(pos, t * 3);
+      triangle.b.fromBufferAttribute(pos, t * 3 + 1);
+      triangle.c.fromBufferAttribute(pos, t * 3 + 2);
+      flags.push(triangle.getArea() > SLIVER_AREA);
+    }
+    return flags;
+  }
+  function splitDoorSkin(three, meshes, toVehicleOf, side2, depth) {
+    const THREE = three;
+    const pieces = meshes;
+    const toVehicle = toVehicleOf;
+    const v = new THREE.Vector3();
+    const corners = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+    const triangle = new THREE.Triangle();
+    const centres = pieces.map((mesh2) => {
+      const geometry = mesh2.geometry.index ? mesh2.geometry.toNonIndexed() : mesh2.geometry;
+      const matrix = toVehicle(mesh2);
+      const pos = geometry.getAttribute("position");
+      const out = new Float32Array(pos.count / 3 * FIELDS);
+      for (let t = 0; t * 3 + 2 < pos.count; t++) {
+        let y = 0;
+        let across = 0;
+        for (let k = 0; k < 3; k++) {
+          corners[k].fromBufferAttribute(pos, t * 3 + k).applyMatrix4(matrix);
+          y += corners[k].y / 3;
+          across += side2 * corners[k].z / 3;
+        }
+        out[t * FIELDS] = y;
+        out[t * FIELDS + 1] = across;
+        triangle.set(corners[0], corners[1], corners[2]).getNormal(v);
+        out[t * FIELDS + 2] = v.y;
+        out[t * FIELDS + 3] = v.x;
+      }
+      return { geometry, out };
+    });
+    const outer = /* @__PURE__ */ new Map();
+    for (const { out } of centres)
+      for (let t = 0; t * FIELDS < out.length; t++) {
+        const band = Math.floor(out[t * FIELDS] / SKIN_BAND);
+        outer.set(band, Math.max(outer.get(band) ?? -Infinity, out[t * FIELDS + 1]));
+      }
+    const surfaceAt = (y) => {
+      const band = Math.floor(y / SKIN_BAND);
+      return Math.max(outer.get(band - 1) ?? -Infinity, outer.get(band) ?? -Infinity, outer.get(band + 1) ?? -Infinity);
+    };
+    return centres.map(({ geometry, out }, i) => {
+      const near = [];
+      for (let t = 0; t * FIELDS < out.length; t++) {
+        const f = t * FIELDS;
+        const body = out[f + 1] < surfaceAt(out[f]) - depth && (out[f + 2] < -BODY_FACING || Math.abs(out[f + 3]) > BODY_FACING);
+        near.push(!body);
+      }
+      const result = { skin: pickTriangles(THREE, geometry, near, true), deep: pickTriangles(THREE, geometry, near, false) };
+      if (geometry !== pieces[i].geometry) geometry.dispose();
+      return result;
+    });
+  }
+  function leaveDeepSkinOnBody(three, meshes, params) {
+    const THREE = three;
+    const pieces = meshes;
+    const toVehicle = params.toVehicle;
+    const { side: side2, depth } = params;
+    const split = splitDoorSkin(THREE, pieces, (mesh2) => new THREE.Matrix4().multiplyMatrices(toVehicle, mesh2.matrixWorld), side2, depth);
+    split.forEach(({ skin, deep }, i) => {
+      const piece = pieces[i];
+      if (!deep || !skin || !piece.parent) return;
+      const body = new THREE.Mesh(deep, piece.material);
+      body.position.copy(piece.position);
+      body.quaternion.copy(piece.quaternion);
+      body.scale.copy(piece.scale);
+      body.castShadow = piece.castShadow;
+      body.receiveShadow = piece.receiveShadow;
+      piece.parent.add(body);
+      piece.geometry.dispose();
+      piece.geometry = skin;
+    });
+  }
+  function pickTriangles(THREE, geometry, flags, wanted) {
+    const count = flags.filter((flag) => flag === wanted).length;
+    if (!count) return null;
+    const out = new THREE.BufferGeometry();
+    for (const name of Object.keys(geometry.attributes)) {
+      const attribute = geometry.getAttribute(name);
+      const size = attribute.itemSize;
+      const source = attribute.array;
+      const array = new Float32Array(count * 3 * size);
+      let w = 0;
+      flags.forEach((flag, t) => {
+        if (flag !== wanted) return;
+        array.set(source.subarray(t * 3 * size, (t + 1) * 3 * size), w);
+        w += 3 * size;
+      });
+      out.setAttribute(name, new THREE.Float32BufferAttribute(array, size));
+    }
+    out.computeBoundingBox();
+    out.computeBoundingSphere();
+    return out;
+  }
+  function isDoorSeam(three, params) {
+    const THREE = three;
+    const box2 = params.box;
+    const { zone, side: side2, dark } = params;
+    if (!dark || box2.isEmpty()) return false;
+    const size = box2.getSize(new THREE.Vector3());
+    const centre = box2.getCenter(new THREE.Vector3());
+    if (Math.sign(centre.z) !== Math.sign(side2) || size.x > SEAM_THIN || size.z > SEAM_THIN || size.y < (zone.y1 - zone.y0) * SEAM_TALL) return false;
+    if (centre.y < zone.y0 || centre.y > zone.y1) return false;
+    return Math.abs(centre.x - zone.x0) < SEAM_AT_EDGE || Math.abs(centre.x - zone.x1) < SEAM_AT_EDGE;
+  }
+
   // src/destructible/visual.ts
   var HOLE_DECAL_SCALE = 2.4;
   var DOOR_DEPTH = 0.07;
+  var DOOR_SKIN_DEPTH = 0.09;
+  var DOOR_FLOOR_DEPTH = 0.2;
   var DOOR_EDGE_PIECES = 8;
   var DOOR_EDGE_REACH = 0.08;
   var DOOR_CARD_COLOR = "#3b3e42";
   var DOOR_LINER_COLOR = "#5a5e64";
   var DOOR_LINER_DARK = 0.15;
-  var DOOR_STRIP_THIN = 0.08;
+  var DOOR_STRIP_THIN = 0.13;
   var DOOR_STRIP_NEAR = 0.04;
   var DOOR_STRIP_TALL = 0.22;
-  var STRIP_SMOOTH_DEG = 180;
-  var DOOR_STRIP_VERTICES = 2e4;
+  var DOOR_STRIP_VERTICES = 6e4;
   var DOOR_SILL = 0.25;
-  var DOOR_STRIP_OVER = 0.3;
+  var DOOR_STRIP_OVER = 0.05;
   var DOOR_TOP_OVER_PANE = 0.03;
   var HOLE_TEXTURE_SIZE = 64;
   var LAMINATED_HP = 1e3;
@@ -13463,6 +13758,10 @@ var GameVehicles = (() => {
       __publicField(this, "skins", /* @__PURE__ */ new Map());
       /** How high each door's cut reaches. */
       __publicField(this, "doorTops", /* @__PURE__ */ new Map());
+      /** The shut lines drawn on the body at a door's edges, by line: the doors whose edge it marks. Shown only while all of them are closed. */
+      __publicField(this, "seams", /* @__PURE__ */ new Map());
+      /** Doors and lids standing open now. */
+      __publicField(this, "openNow", /* @__PURE__ */ new Set());
       __publicField(this, "lightsOn", true);
       /** Heavy body meshes whose triangle index is still to build (null once done). */
       __publicField(this, "warming");
@@ -13644,6 +13943,11 @@ var GameVehicles = (() => {
         }
         panel.visible = open && !this.skins.get(id);
         recess.visible = open && !this.skins.get(id);
+        if (open) this.openNow.add(id);
+        else this.openNow.delete(id);
+        this.seams.forEach((doors, seam) => {
+          if (doors.has(id)) seam.visible = ![...doors].some((door) => this.openNow.has(door));
+        });
       };
       const euler = piv.rotation;
       const quaternion = piv.quaternion;
@@ -13686,11 +13990,13 @@ var GameVehicles = (() => {
           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) {
+            leaveDeepSkinOnBody(this.THREE, pcs, { toVehicle: inv, side: z.side < 0 ? -1 : 1, depth: DOOR_SKIN_DEPTH });
             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);
             const frames = this.framesAround(panes, inv);
-            objs = [...pcs, ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors, ...frames];
+            const followers = I.followersIn(this.c, z, inv).filter((o) => !this.takeSeam(o, id, z, inv) && !this.inFloor(o, piv, z, inv));
+            objs = [...pcs, ...followers, ...panes, ...seals, ...mirrors, ...frames];
           }
         } else {
           const pcs = this.cutZone(z);
@@ -13718,6 +14024,25 @@ var GameVehicles = (() => {
       this.c.root.updateMatrixWorld(true);
       return objs.length > 0;
     }
+    /** A thin part at the foot of the opening, well inside the skin (a step, a sill trim, a rail on the floor), is the floor's: it does not swing with the door. */
+    inFloor(o, piv, z, inv) {
+      const side2 = z.side < 0 ? -1 : 1;
+      const centre = this.I.localBox(this.c, o, inv).getCenter(new this.THREE.Vector3());
+      const skin = side2 * (piv.position.z - side2 * 0.016);
+      return centre.y < z.box.y0 + DOOR_SILL && side2 * centre.z < skin - DOOR_FLOOR_DEPTH;
+    }
+    /** A shut line drawn at the door's edge stays on the body, hidden while a door it marks stands open; answers whether `o` is one. */
+    takeSeam(o, id, z, inv) {
+      const B = z.box;
+      const box2 = this.I.localBox(this.c, o, inv);
+      const color2 = o.material?.color;
+      const dark = !!color2 && color2.getHSL({ h: 0, s: 0, l: 0 }).l < DOOR_LINER_DARK;
+      if (!o.isMesh || !isDoorSeam(this.THREE, { box: box2, zone: { x0: B.x0, x1: B.x1, y0: B.y0, y1: B.y1 }, side: z.side, dark })) return false;
+      const doors = this.seams.get(o) ?? /* @__PURE__ */ new Set();
+      doors.add(id);
+      this.seams.set(o, doors);
+      return true;
+    }
     /** 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;
@@ -13739,13 +14064,15 @@ var GameVehicles = (() => {
         const at = this.surface("z", side2, B, [[x, y]]);
         return at != null && Math.abs(at - flat) < DOOR_EDGE_REACH ? at : flat;
       });
-      const band = (lift) => {
+      const band = (lift, path, closed) => {
         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));
+        path.forEach((at, i) => {
+          const [x, y] = loop[at];
+          position.push(x, y, heights[at] + side2 * lift, x, y, heights[at] + side2 * (lift - DOOR_DEPTH));
+          if (!closed && i === path.length - 1) return;
           const a = i * 2;
-          const b = (i + 1) % loop.length * 2;
+          const b = (i + 1) % path.length * 2;
           index.push(a, a + 1, b, b, a + 1, b + 1);
         });
         const g = new THREE.BufferGeometry();
@@ -13773,8 +14100,11 @@ var GameVehicles = (() => {
       card.castShadow = false;
       this.c.vehicle.add(card);
       piv.attach(card);
-      const edges = new THREE.Mesh(band(2e-3), paint);
-      const lining = new THREE.Mesh(band(2e-3), paint);
+      const all = loop.map((_, i) => i);
+      const top = 2 * DOOR_EDGE_PIECES;
+      const sides = [...all.slice(3 * DOOR_EDGE_PIECES), ...all.slice(0, top + 1)];
+      const edges = new THREE.Mesh(band(2e-3, all, true), paint);
+      const lining = new THREE.Mesh(band(2e-3, sides, false), paint);
       for (const m of [edges, lining]) {
         m.userData.noFollow = true;
         m.castShadow = false;
@@ -13831,26 +14161,14 @@ var GameVehicles = (() => {
         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_TALL || Math.min(box2.max.x, x1) - Math.max(box2.min.x, x0) < (x1 - x0) * DOOR_STRIP_OVER || mid.y < y0 || mid.y > y1) continue;
+        if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_TALL || Math.min(box2.max.x, x1) - Math.max(box2.min.x, 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);
-        };
-        const over = new THREE.Mesh(o.geometry.clone(), o.material);
+        const over = cutStripOverDoor(this.kit, { strip: o, toVehicle, x0, x1 });
         over.position.copy(o.position);
         over.quaternion.copy(o.quaternion);
         over.scale.copy(o.scale);
         this.c.vehicle.add(over);
         over.updateMatrixWorld(true);
-        const overToVehicle = new THREE.Matrix4().multiplyMatrices(inv, over.matrixWorld);
-        const w = new THREE.Vector3();
-        this.kit.cutMesh(over, [{ sdf: (x, y, zz) => {
-          w.set(x, y, zz).applyMatrix4(overToVehicle);
-          return -Math.max(x0 - w.x, w.x - x1);
-        } }], STRIP_SMOOTH_DEG, {});
-        this.kit.cutMesh(o, [{ sdf }], STRIP_SMOOTH_DEG, {});
         over.userData.noFollow = true;
         piv.attach(over);
       }
@@ -14431,11 +14749,18 @@ var GameVehicles = (() => {
         }
       }
     }
+    /** The lens of a light is holed or cracked and stays; `pierced`: a round went through it to the bulb, and the lamp goes dark. */
+    crackLight(p, pierced) {
+      const z = this.zone(p);
+      if (!z) return;
+      for (const L of z.lights) this.kit.crackLight(this.c, L, new this.THREE.Vector3(p.box.center[0] > 0 ? -1 : 1, 0, 0), pierced);
+    }
     /** The lens of a light breaks and its unit stays (damaged) or goes (destroyed). */
     breakLight(p, gone) {
       const z = this.zone(p);
       if (!z) return;
       for (const L of z.lights) {
+        L.lensMaterial = p.material;
         this.kit.breakLight(this.c, L, new this.THREE.Vector3(p.box.center[0] > 0 ? -1 : 1, 0, 0));
         if (gone) {
           if (L.group) L.group.visible = false;
@@ -15081,6 +15406,7 @@ var GameVehicles = (() => {
       wear(p, amount, out);
       syncZone(p);
       if (p.hp <= 0) lose(p, "broken", out, cause);
+      else if (p.def.role === "light") vis?.crackLight(p.def, dtype === "ballistic");
       if (p.def.role === "tyre" && !p.flat && p.hp < p.def.hp * 0.6 && !p.lost) {
         p.flat = true;
         vis?.tyreFlat(p.def, 0.24);
@@ -15893,7 +16219,7 @@ var GameVehicles = (() => {
           if (!list2.length) return 1;
           return Math.min(...list2.map((p) => p.lost || !attached(p.def.id) ? 0 : p.hp / p.def.hp));
         };
-        const tyres = [...ps.values()].filter((p) => p.def.role === "tyre").map((p) => ({ x: p.def.box.center[0], z: p.def.box.center[2], health: tyreHealth(p) }));
+        const tyres = [...ps.values()].filter((p) => p.def.role === "tyre").map((p) => ({ x: p.def.box.center[0], z: p.def.box.center[2], health: tyreHealth(p), rim: p.lost }));
         const status = computeStatus();
         const brakeSystem = [...ps.values()].find((p) => p.def.role === "brakes" && p.def.contains);
         const fluidLeft = brakeSystem ? clamp((brakeSystem.liters ?? 0) / brakeSystem.def.contains.liters / BRAKE_FLUID_NEEDED, 0, 1) : 1;