@adatechnology/game-vehicles 0.5.0 → 0.6.1

package/dist/index.global.js

@@ -23,16 +23,23 @@ var GameVehicles = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    ARMOUR_LEVELS: () => ARMOUR_LEVELS,
     CABIN_LEAK: () => CABIN_LEAK,
+    CRASH_RULES: () => CRASH_RULES,
     JOINT_RULES: () => JOINT_RULES,
     LEGACY_STATES: () => LEGACY_STATES,
     LEGACY_ZONE_IDS: () => LEGACY_ZONE_IDS,
     SEED_SALTS: () => SEED_SALTS,
+    armourLevelOf: () => armourLevelOf,
     buildVehicleItem: () => buildVehicleItem,
     buildVehicleModel: () => buildVehicleModel,
     cabinBoxOf: () => cabinBoxOf,
     cabinEnclosure: () => cabinEnclosure,
     clamp: () => clamp,
+    crackedGlassMaterial: () => crackedGlassMaterial,
+    crashDeltaV: () => crashDeltaV,
+    crashVehicle: () => crashVehicle,
+    createCreaseQueue: () => createCreaseQueue,
     createLod: () => createLod,
     createTranslate: () => createTranslate,
     createVehicleDestructible: () => createVehicleDestructible,
@@ -55,7 +62,7 @@ var GameVehicles = (() => {
     wrapThreeForLod: () => wrapThreeForLod
   });
 
-  // ../game-shapes/dist/chunk-R4RY23RH.js
+  // ../game-shapes/dist/chunk-M5N2SHNL.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));
@@ -1302,8 +1309,8 @@ var GameVehicles = (() => {
       groups: []
     };
   }
-  function make(kind, p) {
-    switch (kind) {
+  function make(p) {
+    switch (p.kind) {
       case "box": {
         const size = p.size ?? [1, 1, 1];
         const segments = p.segments ?? [1, 1, 1];
@@ -1332,7 +1339,7 @@ var GameVehicles = (() => {
       case "mesh":
         return mesh(p);
       default:
-        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+        throw new Error(`game-shapes: unknown primitive kind "${String(p.kind)}"`);
     }
   }
   var templates = /* @__PURE__ */ new Map();
@@ -1340,7 +1347,7 @@ var GameVehicles = (() => {
   var stats = { hits: 0, misses: 0 };
   function buildPrimitive(node, options = {}) {
     const parameters = primitiveParameters(node, options);
-    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    if (node.kind === "mesh" || templateLimit === 0) return make({ ...node, ...parameters });
     const key = `${node.kind}:${canonicalJson(parameters)}`;
     const cached = templates.get(key);
     if (cached) {
@@ -1350,7 +1357,7 @@ var GameVehicles = (() => {
       return cached;
     }
     stats.misses++;
-    const built = make(node.kind, parameters);
+    const built = make({ ...node, ...parameters });
     templates.set(key, built);
     if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
     return built;
@@ -1443,6 +1450,127 @@ var GameVehicles = (() => {
     custom: { fields: { generator: str, params: () => null }, required: ["generator"] }
   };
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFAULT_IGNITION_RULES = {
+    fillCurve: [
+      [0, 0.6],
+      [0.1, 1],
+      [0.35, 0.6],
+      [0.65, 0.3],
+      [0.9, 0.15],
+      [1, 0.12]
+    ],
+    flameFillInfluence: 0.5,
+    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
+    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
+    sparkMetalDefault: 0.5,
+    sparkFluid: { diesel: 0.15 },
+    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
+  };
+  var resolveIgnitionRules = (rules) => ({
+    ...DEFAULT_IGNITION_RULES,
+    ...rules,
+    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
+    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
+    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
+    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
+  });
+  var fillFactor = (fill, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
+    if (curve.length === 0) return 1;
+    const f = Math.min(1, Math.max(0, fill));
+    if (f <= curve[0][0]) return curve[0][1];
+    for (let i = 1; i < curve.length; i++) {
+      const [x1, y1] = curve[i];
+      const [x0, y0] = curve[i - 1];
+      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    }
+    return curve[curve.length - 1][1];
+  };
+  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
+  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
+    const k = fillFactor(target.fill, rules.fillCurve);
+    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
+    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
+    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 KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object2, origin) {
+    const node = object2;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object2;
+  }
+  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((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
   // ../game-shapes-three/dist/index.js
   var UV_BEFORE_NORMAL = /* @__PURE__ */ new Set(["LatheGeometry", "ExtrudeGeometry"]);
   var INDEX_FIRST = /* @__PURE__ */ new Set(["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry"]);
@@ -2459,7 +2587,7 @@ var GameVehicles = (() => {
     }
     return ti.builtBlocks === total;
   }
-  function start(geo) {
+  function start(geo, store = cache) {
     const pos = geo.attributes.position;
     const triangles = trianglesOf(geo);
     const ti = {
@@ -2472,7 +2600,7 @@ var GameVehicles = (() => {
       blocks: new Float64Array(blockCount(triangles) * 6),
       builtBlocks: 0
     };
-    cache.set(geo, ti);
+    store.set(geo, ti);
     return ti;
   }
   function triIndexOf(geo) {
@@ -2524,6 +2652,106 @@ var GameVehicles = (() => {
       }
     return { box: box2, version: ti.positionVersion };
   }
+  var rayCache = /* @__PURE__ */ new WeakMap();
+  function rayIndexOf(geo) {
+    const shared = cache.get(geo);
+    if (shared && isCurrent(geo, shared) && shared.builtBlocks === blockCount(shared.triangles)) return shared;
+    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 count = ix ? ix.count : P.count;
+    const first = Math.max(0, geo.drawRange.start);
+    const last = Math.min(count, 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 collect(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) collect(THREE, raycaster, child, true, out);
+  }
+  function raycastIndexed(THREE, raycaster, objects, recursive = false) {
+    const out = [];
+    for (const object2 of objects) collect(THREE, raycaster, object2, recursive, out);
+    out.sort((x, y) => x.distance - y.distance);
+    return out;
+  }
 
   // src/geometry.ts
   function installGeometry(kit) {
@@ -3263,58 +3491,6 @@ var GameVehicles = (() => {
     Object.assign(I, { roundedBoxGeometry, taper, subdivide, crease, creaseTask, refreshBounds, pathShape, tumble, loftGeometry, hullGeometry, cutGeometry, mergeGeometries, uvProject });
   }
 
-  // ../game-contracts/dist/index.js
-  var DEFAULT_IGNITION_RULES = {
-    fillCurve: [
-      [0, 0.6],
-      [0.1, 1],
-      [0.35, 0.6],
-      [0.65, 0.3],
-      [0.9, 0.15],
-      [1, 0.12]
-    ],
-    flameFillInfluence: 0.5,
-    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
-    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
-    sparkMetalDefault: 0.5,
-    sparkFluid: { diesel: 0.15 },
-    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
-  };
-  var resolveIgnitionRules = (rules) => ({
-    ...DEFAULT_IGNITION_RULES,
-    ...rules,
-    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
-    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
-    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
-    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
-  });
-  var fillFactor = (fill, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
-    if (curve.length === 0) return 1;
-    const f = Math.min(1, Math.max(0, fill));
-    if (f <= curve[0][0]) return curve[0][1];
-    for (let i = 1; i < curve.length; i++) {
-      const [x1, y1] = curve[i];
-      const [x0, y0] = curve[i - 1];
-      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
-    }
-    return curve[curve.length - 1][1];
-  };
-  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
-  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
-    const k = fillFactor(target.fill, rules.fillCurve);
-    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
-    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
-    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 KIT_ORIGIN_KEY = "kitOrigin";
-  function markKitOrigin(object2, origin) {
-    const node = object2;
-    node.userData = node.userData ?? {};
-    node.userData[KIT_ORIGIN_KEY] = { ...origin };
-    return object2;
-  }
-
   // src/context.ts
   function installContext(kit) {
     const THREE = kit.THREE;
@@ -3908,6 +4084,7 @@ var GameVehicles = (() => {
     }
     kit.profX = profX;
     const _sr = new THREE.Raycaster();
+    _sr.layers.enableAll();
     kit.surfaceAt = function(c, org, dir, o) {
       o = o || {};
       c.root.updateMatrixWorld(true);
@@ -3924,7 +4101,7 @@ var GameVehicles = (() => {
       _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();
@@ -3946,6 +4123,7 @@ var GameVehicles = (() => {
     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);
@@ -4012,7 +4190,7 @@ var GameVehicles = (() => {
           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),
@@ -4028,6 +4206,7 @@ var GameVehicles = (() => {
           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);
         });
       });
     };
@@ -4703,6 +4882,7 @@ var GameVehicles = (() => {
   }
 
   // src/hood.ts
+  var HOOD_LIFT = 8e-3;
   function installHood(kit) {
     const THREE = kit.THREE;
     const V3 = THREE.Vector3;
@@ -4725,7 +4905,7 @@ var GameVehicles = (() => {
       for (let i = 0; i < p.count; i++) {
         p.setX(i, cx + (p.getX(i) - cx) * sx);
         p.setZ(i, p.getZ(i) * sz);
-        p.setY(i, p.getY(i) + 8e-3);
+        p.setY(i, p.getY(i) + HOOD_LIFT);
       }
       geo.translate(-hx, -hy, 0);
       const under = geo.clone();
@@ -4754,7 +4934,8 @@ var GameVehicles = (() => {
         yMin: bb.min.y,
         zw: bb.max.z,
         label: o.label,
-        noLatch: !!o.noLatch
+        noLatch: !!o.noLatch,
+        lift: HOOD_LIFT
       };
       c.part("hood", { key: "hood" }, piv, new V3((hx + bb.max.x) / 2, hy, 0), 0.9);
       return c.hood;
@@ -5737,6 +5918,44 @@ var GameVehicles = (() => {
     Object.assign(I, {});
   }
 
+  // src/routed-particles.ts
+  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
+      }
+    };
+  }
+
   // src/particles.ts
   function installParticles(kit) {
     const THREE = kit.THREE;
@@ -5828,7 +6047,7 @@ var GameVehicles = (() => {
         });
       }
       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,
@@ -5836,6 +6055,7 @@ var GameVehicles = (() => {
         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) {
@@ -5863,11 +6083,37 @@ var GameVehicles = (() => {
     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];
@@ -6122,6 +6368,14 @@ var GameVehicles = (() => {
   }
 
   // src/fluids.ts
+  var PUDDLE_COLORS = {
+    coolant: 3123279,
+    brake_fluid: 12093738,
+    transmission_fluid: 10099746,
+    power_steering_fluid: 9054768,
+    washer_fluid: 2977744,
+    battery_acid: 14211272
+  };
   function installFluids(kit) {
     const THREE = kit.THREE;
     const V3 = THREE.Vector3;
@@ -6139,6 +6393,7 @@ var GameVehicles = (() => {
     };
     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();
@@ -6340,6 +6595,13 @@ var GameVehicles = (() => {
         transparent: true,
         opacity: 0.9,
         depthWrite: false
+      }) : PUDDLE_COLORS[kind] ? new THREE.MeshStandardMaterial({
+        color: PUDDLE_COLORS[kind],
+        roughness: 0.05,
+        metalness: 0.1,
+        transparent: true,
+        opacity: 0.7,
+        depthWrite: false
       }) : new THREE.MeshStandardMaterial({
         color: 0,
         roughness: 0.03,
@@ -6580,31 +6842,55 @@ var GameVehicles = (() => {
   }
 
   // src/glass-damage.ts
+  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 count = idx ? idx.count : pos.count;
+      for (let f = 0; f + 2 < count; 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);
@@ -6681,19 +6967,9 @@ var GameVehicles = (() => {
         x0.fillStyle = "rgba(48,66,72,0.5)";
         x0.fillRect(0, 0, 256, 256);
         G.tex = new THREE.CanvasTexture(G.cv);
-        msh.material = new THREE.MeshStandardMaterial({
-          color: 16777215,
-          map: G.tex,
-          emissive: 6976118,
-          emissiveMap: G.tex,
-          transparent: true,
-          roughness: 0.25,
-          metalness: 0.1,
-          side: DOUBLE_SIDE,
-          depthWrite: false
-        });
+        msh.material = crackedGlassMaterial(THREE, G.tex);
       }
-      const uv = glassUV(msh, p);
+      const uv = glassUV(c, msh, p);
       const x = G.cv.getContext("2d");
       drawWeb(x, uv[0] * 256, (1 - uv[1]) * 256, sc != null ? sc : 0.6 + force * 0.5, Math.max(0.4, G.aspect || 1), c.rand);
       G.tex.needsUpdate = true;
@@ -6838,6 +7114,13 @@ var GameVehicles = (() => {
       }
       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;
@@ -7040,6 +7323,7 @@ var GameVehicles = (() => {
       polygonOffsetUnits: -2
     });
     const _ray = new THREE.Raycaster();
+    _ray.layers.enableAll();
     function findSurface(c, p, dir) {
       c.root.updateMatrixWorld(true);
       const Mw = c.vehicle.matrixWorld;
@@ -7121,6 +7405,7 @@ var GameVehicles = (() => {
       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;
@@ -7135,7 +7420,15 @@ var GameVehicles = (() => {
         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;
@@ -7151,10 +7444,39 @@ var GameVehicles = (() => {
         }
         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());
+          if (pos.isInterleavedBufferAttribute || pos.normalized || Object.keys(g.morphAttributes).length > 0) {
+            g.computeBoundingBox();
+            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);
+          } else {
+            const box3 = g.boundingBox ?? (g.boundingBox = new THREE.Box3());
+            let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+            for (let i = 0; i < pos.count * 3; i += 3) {
+              const x = arr[i], y = arr[i + 1], z = arr[i + 2];
+              if (x < x0) x0 = x;
+              if (y < y0) y0 = y;
+              if (z < z0) z0 = z;
+              if (x > x1) x1 = x;
+              if (y > y1) y1 = y;
+              if (z > z1) z1 = z;
+            }
+            box3.min.set(x0, y0, z0);
+            box3.max.set(x1, y1, z1);
+            box3.getCenter(sphere2.center);
+            const cx = sphere2.center.x, cy = sphere2.center.y, cz = sphere2.center.z;
+            let far2 = 0;
+            for (let i = 0; i < pos.count * 3; i += 3) {
+              const dx = cx - arr[i], dy = cy - arr[i + 1], dz = cz - arr[i + 2];
+              far2 = Math.max(far2, dx * dx + dy * dy + dz * dz);
+            }
+            sphere2.radius = Math.sqrt(far2);
+          }
         }
       });
       const dset = new Set(c.deform);
@@ -7238,13 +7560,14 @@ var GameVehicles = (() => {
     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;
@@ -7557,7 +7880,8 @@ var GameVehicles = (() => {
         const G = gm2.userData.glass;
         if (!G || G.broken || !gm2.visible || !gm2.parent) return;
         if (G.type === "laminated") {
-          G.type = "tempered";
+          for (let k2 = 0; k2 < 3; k2++) I.crackGlass(c, gm2, I.glassPt ? I.glassPt(c, gm2, c.rand) : gm2.position.clone(), 1.2);
+          return;
         }
         I.shatterGlass(c, gm2, 1.4, new V3(0, 1, 0));
       });
@@ -7568,19 +7892,6 @@ var GameVehicles = (() => {
         fling(c, c.hood.piv, new V3(rv(1, 3), rv(6, 8.5), rv(-1.5, 1.5)), new V3(rv(-4, 4), rv(-2, 2), rv(3, 7)));
         c.hood = null;
       }
-      const W = m.width || 1.6;
-      const gh = m.glasshouse;
-      if (m.kind === "car" && gh) {
-        ;
-        [1, -1].forEach(function(sd) {
-          const dh = Math.max(0.35, (m.belt || 1) - (m.clearance || 0.3) - 0.08);
-          const dx = gh.fb - 0.55;
-          const door = c.roundBox(0.95, dh, 0.045, 0.03, c.paint(m.color || "#777"), dx, (m.clearance || 0.3) + dh / 2 + 0.04, sd * (W / 2 + 0.01));
-          const hole = c.roundBox(0.9, dh * 0.95, 0.02, 0.02, MATERIALS.dark, dx, (m.clearance || 0.3) + dh / 2 + 0.04, sd * (W / 2 - 0.01));
-          hole.userData.noFollow = true;
-          fling(c, door, c.dirToEffects(new V3(rv(-1, 1), rv(3.5, 6), sd * rv(4, 6.5))), new V3(rv(-5, 5), rv(-4, 4), rv(-5, 5)));
-        });
-      }
       if (m.rearBumper && m.rearBumper.parent)
         fling(
           c,
@@ -7588,20 +7899,6 @@ var GameVehicles = (() => {
           c.dirToEffects(new V3(rv(-5, -3), rv(4, 6), rv(-1, 1))),
           new V3(rv(-3, 3), rv(-6, 6), rv(-3, 3))
         );
-      if (c.wheels.length) {
-        const wi = Math.floor(c.rand() * c.wheels.length);
-        const wh = c.wheels[wi];
-        c.wheels.splice(wi, 1);
-        c.parts.forEach(function(p) {
-          if (p.obj === wh) p.done = true;
-        });
-        fling(
-          c,
-          wh,
-          c.dirToEffects(new V3(rv(-2, 2), rv(5, 7.5), (wh.position.z >= 0 ? 1 : -1) * rv(3, 5))),
-          new V3(rv(-8, 8), rv(-3, 3), rv(-8, 8))
-        );
-      }
       burnAll(c);
       c.emitters = c.emitters.filter(function(e) {
         return e.kind === "exhaust" ? false : true;
@@ -8610,6 +8907,7 @@ var GameVehicles = (() => {
       return hole;
     }
     const _zr = new THREE.Raycaster();
+    _zr.layers.enableAll();
     const PROXY_MIN_TRIANGLES = 500;
     const STROKE_REACH = 0.6;
     const _pv = new V3();
@@ -8844,6 +9142,7 @@ var GameVehicles = (() => {
       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);
@@ -12125,6 +12424,8 @@ var GameVehicles = (() => {
       V3: THREE.Vector3,
       PI: Math.PI,
       document: doc,
+      particleMaterials: opts.particleMaterials,
+      effects: opts.effects,
       strings,
       t,
       matchers: createMatchers(strings),
@@ -12380,7 +12681,9 @@ var GameVehicles = (() => {
       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;
@@ -12390,6 +12693,17 @@ var GameVehicles = (() => {
     return kit;
   }
 
+  // src/destructible/armour.ts
+  var ARMOUR_LEVELS = {
+    IIIA: { glassStops: 1700, glassHp: 6e3, glassTakes: 0.25, steel: 8 },
+    III: { glassStops: 3600, glassHp: 9e3, glassTakes: 0.25, steel: 30 }
+  };
+  function armourLevelOf(meta, option) {
+    if (option !== void 0) return option;
+    if (meta.armor === "IIIA" || meta.armor === "III") return meta.armor;
+    return meta.armored || meta.bullet ? "III" : null;
+  }
+
   // src/destructible/model.ts
   var JOINT_RULES = {
     hinge: { strength: 5e3, tools: ["wrench", "screwdriver"], seconds: 3 },
@@ -12433,6 +12747,12 @@ var GameVehicles = (() => {
     center: [(z.box.x0 + z.box.x1) / 2, (z.box.y0 + z.box.y1) / 2, (z.box.z0 + z.box.z1) / 2],
     size: [Math.max(0.02, z.box.x1 - z.box.x0), Math.max(0.02, z.box.y1 - z.box.y0), Math.max(0.02, z.box.z1 - z.box.z0)]
   });
+  var PART_FLUIDS = {
+    gearbox: { fluid: "transmission_fluid", liters: 6 },
+    brakes: { fluid: "brake_fluid", liters: 0.6 },
+    steering: { fluid: "power_steering_fluid", liters: 1 },
+    battery: { fluid: "battery_acid", liters: 3 }
+  };
   var skinOf = (kind) => kind === "plane" || kind === "heli" || kind === "boat" ? "aluminium" : "steel";
   var isFender = (id) => /^fender/.test(id);
   var roleOfZone = (z) => {
@@ -12476,13 +12796,22 @@ var GameVehicles = (() => {
     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;
     const spec = c.spec;
     const t = kit.t;
     const skin = skinOf(kind);
-    const armour = m.armored || m.bullet ? 12 : 1;
+    const armoured = options.armour ?? null;
+    const armour = armoured ? 12 : 1;
     const mass = vehicleMass(c);
     const W = m.width ?? 1.7;
     const F = m.front ?? 2;
@@ -12548,8 +12877,8 @@ var GameVehicles = (() => {
       }
       if (role === "glass") {
         const glass = (z.glass ?? [])[0];
-        const laminated = glass?.userData?.glass?.type === "laminated" || m.bullet;
-        add({ id, role, name: label, material: "glass", box: box2, mass: 10 * area3, hp: laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
+        const laminated = glass?.userData?.glass?.type === "laminated" || !!armoured;
+        add({ id, role, name: label, material: "glass", box: box2, mass: 10 * area3, hp: armoured ? armoured.glassHp : laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
         continue;
       }
       if (role === "light") {
@@ -12587,7 +12916,7 @@ var GameVehicles = (() => {
           zoneId: id,
           visual: false,
           contains: { fluid: diesel ? "diesel" : "fuel", liters },
-          explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320 },
+          explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320, effect: "car_fuel_tank" },
           ignitionC: diesel ? 330 : 260,
           tags: ["fuel_tank", ...tags]
         });
@@ -12616,6 +12945,16 @@ var GameVehicles = (() => {
         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 G = pane.userData.glass;
+      const bb = paneBox(c, pane, inverse);
+      const laminated = G?.type === "laminated" || !!armoured;
+      add({ id: `pane_${G?.key ?? "glass"}`, role: "glass", name: String(G?.label ?? G?.key ?? "glass"), material: "glass", box: bb, mass: 10 * areaOf(bb.size), hp: armoured ? armoured.glassHp : laminated ? 4e3 : 450, panes: [pane], visual: false, tags: ["glass"] });
+    }
     if (!hubZone) {
       const h = Math.max(0.15, belt - clearance);
       add({
@@ -12670,7 +13009,7 @@ var GameVehicles = (() => {
         visual: false,
         mechanical: true,
         contains: { fluid: diesel ? "diesel" : "fuel", liters },
-        explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320 },
+        explodes: diesel ? void 0 : { energy: 12e5 * (liters / 55), radius: 5 + liters / 30, atC: 320, effect: "car_fuel_tank" },
         ignitionC: diesel ? 330 : 260,
         tags: ["fuel_tank"]
       });
@@ -12947,10 +13286,163 @@ var GameVehicles = (() => {
       }
     }
     void has;
+    for (const part of parts) {
+      const fluid = PART_FLUIDS[part.role];
+      if (fluid && !part.contains && !(kind === "bike" && part.role === "steering")) part.contains = { ...fluid };
+    }
     return { parts, joints, hub: hubId, hitch };
   }
 
+  // src/destructible/subdivide-near.ts
+  var SUBDIVIDE_DEPTH = 12;
+  function subdivideNear(THREE, params) {
+    const { mesh: mesh2, maxLen, near } = params;
+    const src = mesh2.geometry.index ? mesh2.geometry.toNonIndexed() : mesh2.geometry;
+    const a = src.attributes.position.array;
+    const toWorld = mesh2.matrixWorld;
+    const out = [];
+    const mid = (p, q) => [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2, (p[2] + q[2]) / 2];
+    const split = (A, B, C, depth) => {
+      const ab = Math.hypot(A[0] - B[0], A[1] - B[1], A[2] - B[2]);
+      const bc = Math.hypot(B[0] - C[0], B[1] - C[1], B[2] - C[2]);
+      const ca = Math.hypot(C[0] - A[0], C[1] - A[1], C[2] - A[2]);
+      const longest = Math.max(ab, bc, ca);
+      if (longest <= maxLen || depth > SUBDIVIDE_DEPTH) {
+        out.push(...A, ...B, ...C);
+        return;
+      }
+      if (longest === ab) {
+        const D = mid(A, B);
+        split(A, D, C, depth + 1);
+        split(D, B, C, depth + 1);
+      } else if (longest === bc) {
+        const E = mid(B, C);
+        split(A, B, E, depth + 1);
+        split(A, E, C, depth + 1);
+      } else {
+        const F = mid(C, A);
+        split(A, B, F, depth + 1);
+        split(F, B, C, depth + 1);
+      }
+    };
+    for (let i = 0; i < a.length; i += 9) {
+      const A = [a[i], a[i + 1], a[i + 2]];
+      const B = [a[i + 3], a[i + 4], a[i + 5]];
+      const C = [a[i + 6], a[i + 7], a[i + 8]];
+      const corners = [A, B, C].map((p) => new THREE.Vector3(p[0], p[1], p[2]).applyMatrix4(toWorld));
+      if (near(corners)) split(A, B, C, 0);
+      else out.push(...A, ...B, ...C);
+    }
+    const g = new THREE.BufferGeometry();
+    g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+    mesh2.geometry.dispose();
+    mesh2.geometry = g;
+  }
+
   // src/destructible/visual.ts
+  var HOLE_DECAL_SCALE = 2.4;
+  var DOOR_DEPTH = 0.07;
+  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_NEAR = 0.04;
+  var DOOR_STRIP_TALL = 0.22;
+  var STRIP_SMOOTH_DEG = 180;
+  var DOOR_STRIP_VERTICES = 2e4;
+  var DOOR_SILL = 0.25;
+  var DOOR_STRIP_OVER = 0.3;
+  var DOOR_TOP_OVER_PANE = 0.03;
+  var HOLE_TEXTURE_SIZE = 64;
+  var LAMINATED_HP = 1e3;
+  var HOOD_SINK = 2e-3;
+  var HOOD_GAP_CLOSED = 0.016;
+  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.15;
+  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 PANE_MIN_SLOPE = 0.01;
+  var PANE_EDGE_BAND = 0.03;
+  var PANE_REACH_STEP = 0.01;
+  var PANE_REACH_MAX = 0.25;
+  var COWL_UNDER_GLASS = 0;
+  var COWL_NEAR_PANE = 0.08;
+  var COWL_PLATE = 0.06;
+  var COWL_DASH = 0.5;
+  var COWL_DEEP = 0.3;
+  var WINDOW_FRAME_NEAR = 0.06;
+  var WINDOW_FRAME_SPAN = 0.6;
+  var DASHBOARD_COLOR = "#121314";
+  var COWL_CUT_SUB = 0.1;
+  var COWL_CUT_MARGIN = 0.08;
+  var SKIN_UNDER_PANE = 0.025;
+  var SKIN_EDGE_KEPT = 0.06;
+  var SIDE_PANE_FACING = 0.6;
+  var COWL_LONG = 0.8;
+  var PANE_BAR_VERTICES = 48;
+  var PANE_BAR_LENGTH = 0.3;
+  var PANE_BORDER = 0.03;
+  var PANE_BORDER_LIFT = 3e-3;
+  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_PROUD = 1e-3;
+  var MIRROR_FACE_DEPTH = 0.012;
+  var MIRROR_GLASS_THIN = 0.04;
+  var DEFAULT_WHEEL_RADIUS = 0.3;
+  var SIDEWALL_SHARE = 0.3;
+  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");
@@ -12968,14 +13460,23 @@ var GameVehicles = (() => {
       __publicField(this, "syncPlates", /* @__PURE__ */ new Map());
       /** Doors and lids whose own skin was cut from the body and hung on the hinge (true), or that had none to take and keep the plate (false). */
       __publicField(this, "skins", /* @__PURE__ */ new Map());
+      /** How high each door's cut reaches. */
+      __publicField(this, "doorTops", /* @__PURE__ */ new Map());
       __publicField(this, "lightsOn", true);
       /** Heavy body meshes whose triangle index is still to build (null once done). */
       __publicField(this, "warming");
       /** A panel was torn off since the last `pump`: that frame already paid for the cut, the smoothing starts on the next one. */
       __publicField(this, "tornThisFrame", false);
+      /** A shared crease queue owns the smoothing: `pump` only closes the frame of the cut. */
+      __publicField(this, "queued", false);
+      /** A panel was torn and the queue has not asked yet: the first `pendingUnits(frame)` after it holds the work for that frame. */
+      __publicField(this, "holdArmed", false);
+      __publicField(this, "holdFrame", -1);
       /** Normal smoothing still running, by mesh: a mesh cut again gets a new task and the old one is dropped. */
       __publicField(this, "smoothing", /* @__PURE__ */ new Map());
       __publicField(this, "hood");
+      ;
+      c.smoothLater = (mesh2) => this.smoothLater(mesh2);
       this.kit = kit;
       this.c = c;
       this.model = model;
@@ -12984,6 +13485,9 @@ var GameVehicles = (() => {
       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.seatHood();
       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) {
@@ -13004,6 +13508,7 @@ var GameVehicles = (() => {
       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) {
@@ -13091,6 +13596,7 @@ var GameVehicles = (() => {
         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);
@@ -13107,6 +13613,7 @@ var GameVehicles = (() => {
         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);
@@ -13170,10 +13677,20 @@ var GameVehicles = (() => {
       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);
+            const frames = this.framesAround(panes, inv);
+            objs = [...pcs, ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors, ...frames];
+          }
         } else {
           const pcs = this.cutZone(z);
           if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv)];
@@ -13191,10 +13708,152 @@ var GameVehicles = (() => {
         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]) => {
+        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 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 cardPosition = [];
+      const mid = loop.reduce((acc, [x, y], i) => [acc[0] + x, acc[1] + y, acc[2] + heights[i]], [0, 0, 0]).map((v) => v / loop.length);
+      const cardZ = (z2) => z2 - side2 * DOOR_DEPTH;
+      loop.forEach(([x, y], i) => {
+        const j = (i + 1) % loop.length;
+        cardPosition.push(mid[0], mid[1], cardZ(mid[2]), x, y, cardZ(heights[i]), loop[j][0], loop[j][1], cardZ(heights[j]));
+      });
+      const cardGeometry = new THREE.BufferGeometry();
+      cardGeometry.setAttribute("position", new THREE.Float32BufferAttribute(cardPosition, 3));
+      cardGeometry.computeVertexNormals();
+      const cardMaterial = this.I.makeMaterial(DOOR_CARD_COLOR, { roughness: 0.85 }).clone();
+      cardMaterial.side = THREE.DoubleSide;
+      const card = new THREE.Mesh(cardGeometry, cardMaterial);
+      card.userData.noFollow = true;
+      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);
+      for (const m of [edges, lining]) {
+        m.userData.noFollow = true;
+        m.castShadow = false;
+        this.c.vehicle.add(m);
+      }
+      piv.attach(edges);
+    }
+    /** The frame the model draws round a door's window (a dark strip over the glass) goes with the door: left behind it hangs in the air over the opening. */
+    framesAround(panes, inv) {
+      const THREE = this.THREE;
+      const boxes = panes.map((g) => this.I.localBox(this.c, g, inv).expandByScalar(WINDOW_FRAME_NEAR));
+      return this.c.vehicle.children.filter((o) => {
+        if (!o.isMesh || !o.visible || o.userData.glass || o.userData.decal || this.c.deform?.includes(o)) return false;
+        const box2 = this.I.localBox(this.c, o, inv);
+        if (box2.isEmpty()) return false;
+        return boxes.some((b) => b.containsBox(box2) && box2.getSize(new THREE.Vector3()).x > b.getSize(new THREE.Vector3()).x * WINDOW_FRAME_SPAN);
+      });
+    }
+    /** 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_SILL;
+      const glassTop = (I) => {
+        let top = -Infinity;
+        for (const g of I.windowsOver(this.c, z, inv)) top = Math.max(top, I.localBox(this.c, g, inv).max.y);
+        return top;
+      };
+      const y1 = Math.max(B.y1, glassTop(this.I)) + DOOR_STRIP_NEAR;
+      const deform = this.c.deform ?? [];
+      for (const o of [...this.c.vehicle.children]) {
+        if (!o.isMesh || o === piv || o.userData.glass || o.userData.decal || !o.visible || deform.includes(o) && o.geometry.attributes.position.count > DOOR_STRIP_VERTICES) 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_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;
+        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);
+        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);
+      }
+    }
     mend(dirty) {
       dirty.forEach((msh) => {
         const g = msh.geometry;
@@ -13204,7 +13863,470 @@ var GameVehicles = (() => {
         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 local = this.shellAround(pane, shell);
+        if (!local) continue;
+        const seat = this.paneSeat(pane, [local], 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, [local], 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 }] });
+        this.reachShellBelow(pane, local, ray, seat.normal);
+        this.paneBorder(pane, near, seat);
+        this.keepUnderPane(pane, seat.normal);
+        const across = new this.THREE.Vector3(0, 0, 1).transformDirection(this.c.vehicle.matrixWorld);
+        if (Math.abs(seat.normal.dot(across)) < SIDE_PANE_FACING) {
+          for (const body of shell) if (body.parent === this.c.vehicle) this.cutUnderPane(body, pane, seat.normal, SKIN_UNDER_PANE, SKIN_EDGE_KEPT);
+        }
+      }
+    }
+    /** Only the triangles of the shell around a pane, in world space: seating casts many rays and the whole hull has too many triangles for each. */
+    shellAround(pane, shell) {
+      const THREE = this.THREE;
+      const box2 = new THREE.Box3().setFromObject(pane).expandByScalar(PANE_SEAT_REACH + PANE_SEAT_OUT);
+      const out = [];
+      const a = new THREE.Vector3();
+      const b = new THREE.Vector3();
+      const d = new THREE.Vector3();
+      const tri = new THREE.Box3();
+      for (const mesh2 of shell) {
+        const pos = mesh2.geometry.attributes.position;
+        const idx = mesh2.geometry.index;
+        const count = idx ? idx.count : pos.count;
+        const e = mesh2.matrixWorld.elements;
+        const world = (v, i) => {
+          const x = pos.getX(i);
+          const y = pos.getY(i);
+          const z = pos.getZ(i);
+          v.set(e[0] * x + e[4] * y + e[8] * z + e[12], e[1] * x + e[5] * y + e[9] * z + e[13], e[2] * x + e[6] * y + e[10] * z + e[14]);
+        };
+        for (let f = 0; f + 2 < count; f += 3) {
+          world(a, idx ? idx.getX(f) : f);
+          world(b, idx ? idx.getX(f + 1) : f + 1);
+          world(d, idx ? idx.getX(f + 2) : f + 2);
+          tri.makeEmpty().expandByPoint(a).expandByPoint(b).expandByPoint(d);
+          if (tri.intersectsBox(box2)) out.push(a.x, a.y, a.z, b.x, b.y, b.z, d.x, d.y, d.z);
+        }
+      }
+      if (!out.length) return null;
+      const g = new THREE.BufferGeometry();
+      g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+      const proxy = new THREE.Mesh(g, new THREE.MeshBasicMaterial({ side: THREE.DoubleSide }));
+      proxy.updateMatrixWorld(true);
+      return proxy;
+    }
+    /** 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 count = idx ? idx.count : pos.count;
+      for (let f = 0; f + 2 < count; 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;
+    }
+    /** The lower edge of a pane comes down to the shell: left short, the dashboard shows through the slit as a black bar under the glass. */
+    reachShellBelow(pane, shell, ray, normal) {
+      const THREE = this.THREE;
+      const down = new THREE.Vector3(0, -1, 0).applyQuaternion(this.c.root.getWorldQuaternion(new THREE.Quaternion()));
+      down.addScaledVector(normal, -down.dot(normal));
+      if (down.lengthSq() < PANE_MIN_SLOPE) return;
+      down.normalize();
+      const g = pane.geometry;
+      const pos = g.attributes.position;
+      const v = new THREE.Vector3();
+      let lowest = -Infinity;
+      for (let i = 0; i < pos.count; i++) lowest = Math.max(lowest, v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld).dot(down));
+      const edge = [];
+      const mid = new THREE.Vector3();
+      for (let i = 0; i < pos.count; i++) {
+        v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld);
+        if (v.dot(down) > lowest - PANE_EDGE_BAND) {
+          edge.push(i);
+          mid.add(v);
+        }
+      }
+      if (!edge.length) return;
+      mid.divideScalar(edge.length);
+      let reach = 0;
+      for (let d = PANE_REACH_STEP; d <= PANE_REACH_MAX; d += PANE_REACH_STEP) {
+        const at = mid.clone().addScaledVector(down, d).addScaledVector(normal, PANE_SEAT_REACH);
+        ray.set(at, normal.clone().negate());
+        ray.far = PANE_SEAT_REACH * 2;
+        if (ray.intersectObject(shell, false)[0]) {
+          reach = d + PANE_REACH_STEP;
+          break;
+        }
+      }
+      if (!reach) return;
+      const inverse = pane.matrixWorld.clone().invert();
+      for (const i of edge) {
+        v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld).addScaledVector(down, reach).applyMatrix4(inverse);
+        pos.setXYZ(i, v.x, v.y, v.z);
+      }
+      pos.needsUpdate = true;
+      g.computeBoundingBox();
+      g.computeBoundingSphere();
+    }
+    /** The plate drawn right under a windshield stays only outside the glass, in the body's paint: under the glass it would show inside the cabin. */
+    keepUnderPane(pane, normal) {
+      const THREE = this.THREE;
+      const paneBox2 = new THREE.Box3().setFromObject(pane).expandByScalar(COWL_NEAR_PANE);
+      const pos = pane.geometry.attributes.position;
+      const centre = new THREE.Vector3();
+      const v = new THREE.Vector3();
+      for (let i = 0; i < pos.count; i++) centre.add(v.fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld));
+      centre.divideScalar(pos.count);
+      const plane2 = centre.dot(normal);
+      for (const o of this.c.vehicle.children) {
+        if (!o.isMesh || o === pane || o.userData.glass || this.c.deform?.includes(o)) continue;
+        const box2 = new THREE.Box3().setFromObject(o);
+        const size = box2.getSize(new THREE.Vector3());
+        if (o.geometry.attributes.position.count <= PANE_BAR_VERTICES || size.y > COWL_DASH || Math.max(size.x, size.z) < COWL_LONG || Math.min(size.x, size.z) < COWL_DEEP || !paneBox2.intersectsBox(box2)) continue;
+        if (box2.getCenter(new THREE.Vector3()).dot(normal) - plane2 >= COWL_UNDER_GLASS) continue;
+        if (size.y >= COWL_PLATE) {
+          o.material = this.I.makeMaterial(DASHBOARD_COLOR, { roughness: 1, metalness: 0 });
+          continue;
+        }
+        o.material = this.paint();
+        this.cutUnderPane(o, pane, normal);
+      }
+    }
+    /** Cuts away the part of a mesh that lies under a pane (behind its plane, inside its outline seen along its normal). */
+    cutUnderPane(mesh2, pane, normal, behind = -Infinity, inset = 0) {
+      const THREE = this.THREE;
+      const outline = this.paneOutline(pane, normal);
+      if (outline.length < 3) return;
+      const u = new THREE.Vector3(0, 1, 0).cross(normal);
+      if (u.lengthSq() < 1e-4) u.set(1, 0, 0);
+      u.normalize();
+      const w = normal.clone().cross(u);
+      const cx = outline.reduce((sum, p) => sum + p.dot(u), 0) / outline.length;
+      const cy = outline.reduce((sum, p) => sum + p.dot(w), 0) / outline.length;
+      const poly = outline.map((p) => {
+        const x = p.dot(u);
+        const y = p.dot(w);
+        const d = Math.hypot(x - cx, y - cy) || 1;
+        const k = Math.max(0, d - inset) / d;
+        return [cx + (x - cx) * k, cy + (y - cy) * k];
+      });
+      const plane2 = outline.reduce((sum, p) => sum + p.dot(normal), 0) / outline.length;
+      const inside = (x, y) => {
+        let hit = false;
+        for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+          const [xi, yi] = poly[i];
+          const [xj, yj] = poly[j];
+          if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) hit = !hit;
+        }
+        return hit;
+      };
+      const v = new THREE.Vector3();
+      const toWorld = mesh2.matrixWorld;
+      mesh2.updateMatrixWorld(true);
+      const xs = poly.map((p) => p[0]);
+      const ys = poly.map((p) => p[1]);
+      const [x0, x1, y0, y1] = [Math.min(...xs) - COWL_CUT_MARGIN, Math.max(...xs) + COWL_CUT_MARGIN, Math.min(...ys) - COWL_CUT_MARGIN, Math.max(...ys) + COWL_CUT_MARGIN];
+      subdivideNear(THREE, { mesh: mesh2, maxLen: COWL_CUT_SUB, near: (corners) => {
+        const us = corners.map((c) => c.dot(u));
+        const ws = corners.map((c) => c.dot(w));
+        return Math.max(...us) >= x0 && Math.min(...us) <= x1 && Math.max(...ws) >= y0 && Math.min(...ws) <= y1;
+      } });
+      this.kit.cutMesh(
+        mesh2,
+        [
+          {
+            sdf: (x, y, z) => {
+              v.set(x, y, z).applyMatrix4(toWorld);
+              return inside(v.dot(u), v.dot(w)) && plane2 - v.dot(normal) > behind ? -1 : 1;
+            }
+          }
+        ],
+        42,
+        {}
+      );
+    }
+    /** The straight bars drawn round a quad pane stand off its edges: they give way to a thin dark band that lies on the glass, as on a bonded windshield. */
+    paneBorder(pane, near, seat) {
+      const THREE = this.THREE;
+      const bars = near.filter((o) => {
+        if (o.geometry.attributes.position.count > PANE_BAR_VERTICES) return false;
+        const size = new THREE.Box3().setFromObject(o).getSize(new THREE.Vector3());
+        return Math.max(size.x, size.y, size.z) > PANE_BAR_LENGTH;
+      });
+      if (!bars.length) return;
+      const outline = this.paneOutline(pane, seat.normal);
+      if (outline.length < 3) return;
+      const centre = new THREE.Vector3();
+      for (const p of outline) centre.add(p);
+      centre.divideScalar(outline.length);
+      const position = [];
+      const toVehicle = this.I.worldInverseOf(this.c);
+      const put = (p) => {
+        const q = p.clone().addScaledVector(seat.normal, PANE_BORDER_LIFT).applyMatrix4(toVehicle);
+        position.push(q.x, q.y, q.z);
+      };
+      const inward = (p) => p.clone().add(centre.clone().sub(p).normalize().multiplyScalar(PANE_BORDER));
+      outline.forEach((a, i) => {
+        const b = outline[(i + 1) % outline.length];
+        const c = inward(b);
+        const d = inward(a);
+        for (const p of [a, b, c, a, c, d]) put(p);
+      });
+      if (!position.length) return;
+      for (const o of bars) o.visible = false;
+      const band = new THREE.BufferGeometry();
+      band.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+      band.computeVertexNormals();
+      const material = this.I.MATERIALS.dark.clone();
+      material.side = THREE.DoubleSide;
+      const mesh2 = new THREE.Mesh(band, material);
+      mesh2.userData.noFollow = true;
+      mesh2.castShadow = false;
+      mesh2.raycast = () => {
+      };
+      this.c.vehicle.add(mesh2);
+    }
+    /** The outline of a pane, the convex hull of its vertices seen along its normal, in world space. */
+    paneOutline(pane, normal) {
+      const THREE = this.THREE;
+      const pos = pane.geometry.attributes.position;
+      const u = new THREE.Vector3(0, 1, 0).cross(normal);
+      if (u.lengthSq() < 1e-4) u.set(1, 0, 0);
+      u.normalize();
+      const w = normal.clone().cross(u);
+      const points = [];
+      for (let i = 0; i < pos.count; i++) {
+        const p = new THREE.Vector3().fromBufferAttribute(pos, i).applyMatrix4(pane.matrixWorld);
+        points.push({ x: p.dot(u), y: p.dot(w), p });
+      }
+      points.sort((a, b) => a.x - b.x || a.y - b.y);
+      const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+      const half = (list2) => {
+        const out = [];
+        for (const q of list2) {
+          while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], q) <= 0) out.pop();
+          out.push(q);
+        }
+        out.pop();
+        return out;
+      };
+      return [...half(points), ...half([...points].reverse())].map((q) => q.p);
+    }
+    /** 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 count = idx ? idx.count : pos.count;
+      const tri = new THREE.Triangle();
+      const step = Math.max(1, Math.floor(count / 3 / PANE_SEAT_SAMPLES)) * 3;
+      let past = 0;
+      for (let f = 0; f + 2 < count; 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 closed hood is flush with the fenders beside it: the height it was drawn with to keep clear of the hull goes, the hull has its hole. */
+    seatHood() {
+      const hood = this.c.hood;
+      if (!hood?.lift) return;
+      const THREE = this.THREE;
+      const box2 = new THREE.Box3().setFromObject(hood.piv).getSize(new THREE.Vector3());
+      for (const part of hood.piv.children) {
+        part.position.y -= hood.lift + HOOD_SINK;
+        part.scale.multiply(new THREE.Vector3(1 + HOOD_GAP_CLOSED / Math.max(0.3, box2.x), 1, 1 + HOOD_GAP_CLOSED / Math.max(0.3, box2.z)));
+      }
+    }
+    /** 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);
+      const bodyBox = new THREE.Box3();
+      for (const o of c.deform) if (o.isMesh && !o.userData.glass && c.paints?.has(o.material)) bodyBox.union(this.I.localBox(c, o, inv));
+      const outerHalf = Math.max(Math.abs(bodyBox.min.z), Math.abs(bodyBox.max.z));
+      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;
+          if (Math.abs(at.z) < outerHalf - 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, drawn) {
+      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;
+      const THREE = this.THREE;
+      const volumeOf = (o) => {
+        const size = new THREE.Box3().setFromObject(o).getSize(new THREE.Vector3());
+        return size.x * size.y * size.z;
+      };
+      const housing = drawn.filter((o) => o !== glass && o.isMesh && o.geometry).sort((a, b) => volumeOf(b) - volumeOf(a))[0];
+      if (housing) {
+        this.c.root.updateMatrixWorld(true);
+        const inv = this.I.worldInverseOf(this.c);
+        glass.updateMatrixWorld(true);
+        const gb = this.I.localBox(this.c, glass, inv);
+        const hb = this.I.localBox(this.c, housing, inv);
+        const side2 = hb.getCenter(new THREE.Vector3()).x > gb.getCenter(new THREE.Vector3()).x ? -1 : 1;
+        const face = side2 < 0 ? hb.min.x + MIRROR_FACE_DEPTH : hb.max.x - MIRROR_FACE_DEPTH;
+        const shape = housing.geometry.clone();
+        const pos = shape.attributes.position;
+        const toVehicle = new THREE.Matrix4().multiplyMatrices(inv, housing.matrixWorld);
+        const back = toVehicle.clone().invert();
+        const v = new THREE.Vector3();
+        for (let i = 0; i < pos.count; i++) {
+          v.fromBufferAttribute(pos, i).applyMatrix4(toVehicle);
+          if ((v.x - face) * side2 <= 0) continue;
+          v.x = face;
+          v.applyMatrix4(back);
+          pos.setXYZ(i, v.x, v.y, v.z);
+        }
+        shape.computeVertexNormals();
+        housing.geometry = shape;
+        const outer = side2 < 0 ? gb.min.x : gb.max.x;
+        glass.position.x += face + side2 * MIRROR_GLASS_PROUD - outer;
+      }
+      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());
+          const [thin, mid] = size.toArray().sort((a, b) => a - b);
+          if (thin < MIRROR_GLASS_THIN && mid > MIRROR_GLASS_MIN) {
+            this.seatMirrorGlass(o, drawn);
+            o.userData.mirrorGlass = true;
+          }
+        }
+        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;
@@ -13212,14 +14334,26 @@ var GameVehicles = (() => {
       g.name = `obj_${p.id}`;
       g.position.set(cx, cy, cz);
       this.c.vehicle.add(g);
-      this.box(0.05, 0.04, 0.1, mats.dark, 0, -0.04, -s * 0.07, g);
-      const housing = this.box(0.1, 0.12, 0.05, mats.plastic ?? mats.dark, 0, 0, s * 0.02, g);
+      this.box(0.05, 0.035, 0.05, mats.dark, 0, -0.04, -s * 0.06, g);
+      const housing = this.box(0.08, 0.11, 0.125, mats.plastic ?? mats.dark, 0, 0, s * 0.0225, g);
       housing.userData.mirrorHousing = true;
-      const glass = this.box(0.095, 0.1, 6e-3, mats.chrome ?? mats.dark, 0, 0, s * 0.048, g);
+      const glass = this.box(6e-3, 0.095, 0.115, mats.chrome ?? mats.dark, -0.043, 0, s * 0.0225, g);
       glass.userData.mirrorGlass = true;
       g.userData.rigid = true;
       this.extra.set(p.id, [g]);
     }
+    /** A round through the mirror shatters its glass: the shards drop out of the housing, which stays on with the hole. Returns whether there was glass to break. */
+    shatterMirror(id) {
+      let broke = false;
+      for (const o of this.extra.get(id) ?? []) {
+        o.traverse((m) => {
+          if (!m.userData.mirrorGlass || !m.visible) return;
+          m.visible = false;
+          broke = true;
+        });
+      }
+      return broke;
+    }
     makeBattery(p) {
       const mats = this.I.MATERIALS;
       const g = new this.THREE.Group();
@@ -13245,17 +14379,33 @@ var GameVehicles = (() => {
     }
     // ---- 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. */
+    /** The part a separately drawn piece stands for (a mirror on the door, a battery under the hood), so a shot at it lands on that part. */
+    extraIdOf(o) {
+      for (const [id, objs] of this.extra) if (objs.includes(o)) return id;
+      return void 0;
+    }
+    plateIdOf(o) {
+      return o.userData.plateOf;
     }
     spark(point, dir, count = 8) {
       const V3 = this.THREE.Vector3;
@@ -13295,10 +14445,8 @@ var GameVehicles = (() => {
     }
     /** 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];
@@ -13312,12 +14460,20 @@ var GameVehicles = (() => {
           best = g;
         }
       }
+      if (p.hp > LAMINATED_HP && best.userData.glass) best.userData.glass.type = "laminated";
       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);
     }
@@ -13326,6 +14482,17 @@ var GameVehicles = (() => {
       if (!z) return;
       for (const w of z.wheels) if (w.parent) this.I.flattenTire(w, k);
     }
+    /** A tyre driven flat until it tore apart: the rubber is gone and the bare rim shows. */
+    tyreTornOff(p) {
+      const z = this.zone(p);
+      if (!z) return;
+      for (const w of z.wheels) {
+        if (!w.parent || w.userData.tornOff) continue;
+        w.userData.tornOff = true;
+        for (const m of this.I.tireMeshes(w)) m.visible = false;
+        w.position.y -= (w.userData.r ?? DEFAULT_WHEEL_RADIUS) * SIDEWALL_SHARE;
+      }
+    }
     /** Burning rubber: the tyre sags and goes black as it melts. */
     tyreMelt(p, melt) {
       const z = this.zone(p);
@@ -13345,6 +14512,7 @@ var GameVehicles = (() => {
     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) {
@@ -13352,6 +14520,7 @@ var GameVehicles = (() => {
         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) {
@@ -13360,6 +14529,34 @@ var GameVehicles = (() => {
       }
       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;
@@ -13531,6 +14728,7 @@ var GameVehicles = (() => {
       }
       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);
@@ -13618,6 +14816,41 @@ var GameVehicles = (() => {
   var SHIELDED = /* @__PURE__ */ new Set(["engine", "gearbox", "frame", "radiator", "fuel_tank", "oil_pan", "battery", "alternator", "brakes", "steering", "shocks"]);
   var AMBIENT = 20;
   var FLAME = 700;
+  var STEEL_MM = { panel: 0.8, door: 1.6, hood: 0.8, lid: 0.8, roof: 0.8, fender: 0.8, pillar: 2, frame: 4, rim: 3, engine: 40, gearbox: 25, fuel_tank: 1, radiator: 1, battery: 2, brakes: 10, steering: 8, shocks: 6, oil_pan: 2, alternator: 4, hitch: 8, other: 2 };
+  var ARMOUR_STEEL_MM = { IIIA: 4, III: 7 };
+  var SOFT_LEAD = 0.8;
+  var TYRE_FLAT_HEALTH = 0.1;
+  var TYRE_BURST_JOULES = 1500;
+  var TYRE_BURST_CALIBER = 12;
+  var TYRE_LEAK_PER_MM2 = 26e-5;
+  var FLAT_TYRE_LIFE_M = 1500;
+  var FLAT_TYRE_TOWN_SPEED = 8;
+  var RUN_FLAT_LIFE_M = 8e4;
+  var RUN_FLAT_SPEED = 22;
+  var TYRE_RUNFLAT_HEALTH = 0.6;
+  var CRUMPLE_BASE_M = 0.04;
+  var CRUMPLE_PER_FORCE_M = 0.15;
+  var CRUMPLE_MIN_FORCE = 0.3;
+  var CRUMPLE_MAX_FORCE = 1.4;
+  var RIM_HEALTH = 0.05;
+  var RIM_GRIND_PER_M = 4e-4;
+  var TYRE_FLAT_SAG = 0.24;
+  var TYRE_FLAT_AIR = 0.2;
+  var BRAKE_FLUID_NEEDED = 0.6;
+  var BRAKE_NO_FLUID = 0.15;
+  var ENGINE_WORKING_C = 90;
+  var ENGINE_SETTLE_S = 30;
+  var ENGINE_HEATING = 0.5;
+  var ENGINE_STEAM_C = 120;
+  var ENGINE_SEIZE_C = 150;
+  var COOLANT_NEEDED = 0.4;
+  var OIL_NEEDED = 0.3;
+  var OIL_WEAR = 4e-3;
+  var ENGINE_SEIZE_HP = 0.2;
+  var EXPANDED_HOLE = 1.6;
+  var MIN_SPENT = 0.08;
+  var WELDED = /* @__PURE__ */ new Set(["roof", "pillar", "frame", "panel"]);
+  var CRUMPLES = /* @__PURE__ */ new Set(["door", "hood", "lid", "fender", "bumper"]);
   var FRACTURE = { glass: "shatter", plastic: "snap", rubber: "tear", steel: "none", aluminium: "none" };
   var add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
   var r3 = (v) => [Math.round(v[0] * 1e5) / 1e5, Math.round(v[1] * 1e5) / 1e5, Math.round(v[2] * 1e5) / 1e5];
@@ -13629,6 +14862,8 @@ var GameVehicles = (() => {
     let c = vehicleCtx;
     const id = options.id ?? c.key;
     const headless = !!options.headless;
+    const armourId = armourLevelOf(c.meta, options.armour);
+    const armourLevel = armourId ? { ...ARMOUR_LEVELS[armourId], ...options.armourLevels?.[armourId] } : null;
     const seedBase = strHash(`${c.key}|${id}|${options.seed ?? 0}`);
     let rand = rng(seedBase);
     const ignitionRules = resolveIgnitionRules(options.ignition);
@@ -13637,6 +14872,7 @@ var GameVehicles = (() => {
     let clock = 0;
     let model;
     let vis = null;
+    let releaseCrease;
     const ps = /* @__PURE__ */ new Map();
     let js = [];
     let leaks = /* @__PURE__ */ new Map();
@@ -13685,7 +14921,7 @@ var GameVehicles = (() => {
       return d.ignitionC ? 1 : 0;
     };
     const setup = () => {
-      model = buildVehicleModel(kit, c, { hitch: options.hitch });
+      model = buildVehicleModel(kit, c, { hitch: options.hitch, armour: armourLevel });
       ps.clear();
       for (const d of model.parts) {
         const kg = burnKg(d);
@@ -13705,6 +14941,8 @@ var GameVehicles = (() => {
           lost: false,
           status: "intact",
           flat: false,
+          air: 1,
+          airLoss: 0,
           fireLoss: 0
         });
       }
@@ -13721,7 +14959,9 @@ var GameVehicles = (() => {
       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 = () => {
@@ -13803,7 +15043,8 @@ var GameVehicles = (() => {
             vis.breakLight(d, true);
             break;
           case "tyre":
-            vis.tyreFlat(d, 0.34);
+            if (status === "broken") vis.tyreTornOff(d);
+            else vis.tyreFlat(d, 0.34);
             break;
           case "mirror":
           case "bumper":
@@ -13833,7 +15074,8 @@ var GameVehicles = (() => {
     const damage = (p, amount, dtype, source, out, cause) => {
       if (p.lost || !(amount > 0)) return;
       const before = p.hp;
-      p.hp = Math.max(0, p.hp - amount);
+      const crumples = dtype === "blunt" && CRUMPLES.has(p.def.role) && (p.def.material === "steel" || p.def.material === "aluminium");
+      p.hp = Math.max(WELDED.has(p.def.role) || crumples ? 1 : 0, p.hp - amount);
       out.push(ev({ type: "damage", part: p.def.id, amount: r2(before - p.hp), hp: r2(p.hp), damageType: dtype, ...source ? { source } : {} }));
       wear(p, amount, out);
       syncZone(p);
@@ -13876,11 +15118,22 @@ var GameVehicles = (() => {
       const p = v.clone().applyMatrix4(M);
       return [p.x, p.y, p.z];
     };
-    const armour = () => c.meta.armored || c.meta.bullet ? 30 : 1;
+    const armour = () => armourLevel?.steel ?? 1;
+    const steelMm = (d) => {
+      const base = STEEL_MM[d.role] ?? STEEL_MM.panel;
+      return d.material === "steel" || d.material === "aluminium" ? base * (armourLevel ? ARMOUR_STEEL_MM[armourId === "III" ? "III" : "IIIA"] / STEEL_MM.panel : 1) : base;
+    };
+    const goesThrough = (h, d, p, energy, res) => {
+      const piercing = h.piercing ?? 1;
+      const metal = d.material === "steel" || d.material === "aluminium";
+      const mm = h.penetration?.steel;
+      if (metal && mm != null) return mm >= steelMm(d) * (p.dents.length > 3 ? 0.9 : 1);
+      return energy * (metal || d.material === "glass" ? piercing : 1) >= res;
+    };
     const resist = (d, p) => {
       let base = RESIST[d.material] ?? 100;
       if (d.material === "glass" && d.hp > 1e3) base = 120;
-      if (d.material === "glass" && c.meta.bullet) base *= 30;
+      if (d.material === "glass" && armourLevel) base = armourLevel.glassStops;
       const k = ROLE_RESIST[d.role] ?? 1;
       const arm = d.material === "steel" || d.material === "aluminium" ? armour() : 1;
       return base * k * arm * (p.dents.length > 3 ? 0.9 : 1);
@@ -13903,7 +15156,7 @@ var GameVehicles = (() => {
         if (vis) {
           const pos = new V3(d.box.center[0], Math.max(0.2, (c.meta.clearance ?? 0.3) * 0.8), d.box.center[2]);
           if (fluid === "coolant") kit.addEmitter(c, new V3(d.box.center[0], d.box.center[1] + 0.2, d.box.center[2]), "white", { rate: 5, s: 0.8 });
-          else if ((c.meta.kind ?? "car") !== "boat") l.pud = I.puddle(c, fluidKind(fluid), pos, fluid === "oil" ? 0.8 : 1.1);
+          if ((c.meta.kind ?? "car") !== "boat") l.pud = I.puddle(c, fluidKind(fluid), pos, fluid === "oil" ? 0.8 : fluid === "brake_fluid" ? 0.4 : 1.1);
         }
       }
       const out3 = dirToWorld(new V3(dirLocal.x * 0.5, dirLocal.y * 0.5 - 0.6, dirLocal.z * 0.5));
@@ -13940,7 +15193,7 @@ var GameVehicles = (() => {
       exploded = true;
       const d = tank.def;
       const spec = d.explodes ?? { energy: 8e5, radius: 5, atC: 320 };
-      out.push(ev({ type: "explode", part: d.id, point: toWorld(d.box.center), energy: spec.energy, radius: spec.radius }));
+      out.push(ev({ type: "explode", part: d.id, point: toWorld(d.box.center), energy: spec.energy, radius: spec.radius, ..."effect" in spec && spec.effect !== void 0 ? { effect: spec.effect } : {} }));
       tank.liters = 0;
       leaks.delete(d.id);
       if (vis) kit.explode(c, { delay: 0.6 });
@@ -14032,15 +15285,15 @@ var GameVehicles = (() => {
       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 through = goesThrough(h, d, p, E, res);
       const cosInc = Math.abs(dir.dot(n));
       const metal = d.material === "steel" || d.material === "aluminium";
       const worldPoint = toWorld(v);
@@ -14051,13 +15304,21 @@ var GameVehicles = (() => {
         vis?.spark([v.x, v.y, v.z], [refl.x, refl.y, refl.z], 6);
         return;
       }
-      const holeDiam = Math.max(6e-3, cal / 1e3 * (d.material === "glass" ? 1.4 : 1));
+      const opens = (h.piercing ?? 1) < SOFT_LEAD ? EXPANDED_HOLE : 1;
+      const holeDiam = Math.max(6e-3, cal / 1e3 * (d.material === "glass" ? 1.4 : 1) * opens);
+      const energyLeft = () => {
+        const metal2 = d.material === "steel" || d.material === "aluminium";
+        const mm = h.penetration?.steel;
+        const spent = metal2 && mm ? clamp(steelMm(d) / mm, MIN_SPENT, 1) : clamp(res / Math.max(E, 1), MIN_SPENT, 1);
+        return E * (1 - spent);
+      };
       const push = (hole) => {
         if (!hole) return;
         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);
+        out.push(ev({ type: "hole", part: d.id, hole: hp, worldPoint, ...through ? { energyLeft: r2(energyLeft()) } : {}, ...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, d);
+        if (d.role === "mirror") vis?.shatterMirror(d.id);
         startLeak(p, v, cal, out, dir);
       };
       switch (d.material) {
@@ -14070,7 +15331,7 @@ var GameVehicles = (() => {
             const crack = { point: r3(fromVehicle(v, M)), normal: r3(fromVehicle(n, new THREE.Matrix4().extractRotation(M))), length: r2(0.15 + force * 0.35), rays: 6 + Math.round(force * 6) };
             p.cracks.push(crack);
             out.push(ev({ type: "crack", part: d.id, crack, worldPoint }));
-            damage(p, E * 0.5, "ballistic", h.source, out, worldPoint);
+            damage(p, E * (armourLevel && !through ? armourLevel.glassTakes : 0.5), "ballistic", h.source, out, worldPoint);
           } else damage(p, laminated ? E * 0.5 : p.hp, "ballistic", h.source, out, worldPoint);
           break;
         }
@@ -14078,8 +15339,8 @@ var GameVehicles = (() => {
           push(through);
           damage(p, E * 0.4, "ballistic", h.source, out, worldPoint);
           if (through && !p.lost && !p.flat) {
-            p.flat = true;
-            vis?.tyreFlat(d, 0.24);
+            if (E >= TYRE_BURST_JOULES || cal >= TYRE_BURST_CALIBER) deflate(p, 1);
+            else p.airLoss += TYRE_LEAK_PER_MM2 * Math.PI * (cal / 2) ** 2;
           }
           break;
         }
@@ -14195,7 +15456,7 @@ var GameVehicles = (() => {
       const electric = c.spec.fuel === "electric";
       const tank = tankPart();
       const fuel = tank ? tank.liters ?? 0 : electric ? 1 : 1;
-      const engineOk = sound("engine") && !exploded && fuel > 0.05;
+      const engineOk = sound("engine") && !exploded && !seized && fuel > 0.05;
       const powered = sound("battery") && sound("alternator");
       const gearOk = sound("gearbox");
       const brakes = [...ps.values()].find((p) => p.def.role === "brakes");
@@ -14355,9 +15616,62 @@ var GameVehicles = (() => {
     const state = () => stateCache ?? (stateCache = buildState());
     const isSimulating = () => {
       if (leaks.size > 0) return true;
-      for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT)) return true;
+      for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT || p.airLoss > 0 && p.air > 0)) return true;
       return false;
     };
+    let engineHeat = ENGINE_WORKING_C;
+    let seized = false;
+    let steaming = 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;
+        const piece = vis?.extraIdOf(q);
+        if (piece) return ps.get(piece) ?? null;
+      }
+      return locate(v, 0.08, (p) => p.def.role === "glass");
+    };
+    const surfaceMeshes = [];
+    const collectSurfaces = (o) => {
+      if (!o.visible || o.userData.decal || o.userData.ghost || o.userData.noSurfaceRay) return;
+      if (o.isMesh) surfaceMeshes.push(o);
+      for (const child of o.children) collectSurfaces(child);
+    };
+    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;
+      surfaceMeshes.length = 0;
+      for (const child of c.vehicle.children) collectSurfaces(child);
+      for (const h of surfaceRays.intersectObjects(surfaceMeshes, false)) {
+        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 = [];
@@ -14382,7 +15696,29 @@ var GameVehicles = (() => {
       applyEffects();
       return out;
     };
+    const runFlat = armourId != null;
+    const tyreHealth = (p) => {
+      if (p.lost) return RIM_HEALTH;
+      if (p.flat) return runFlat ? TYRE_RUNFLAT_HEALTH : TYRE_FLAT_HEALTH;
+      return Math.min(p.hp / p.def.hp, 0.2 + 0.8 * p.air);
+    };
+    const tyreOf = (rim) => {
+      let best;
+      let bestD = Infinity;
+      for (const p of ps.values()) {
+        if (p.def.role !== "tyre") continue;
+        const d = Math.hypot(p.def.box.center[0] - rim.def.box.center[0], p.def.box.center[2] - rim.def.box.center[2]);
+        if (d < bestD) [best, bestD] = [p, d];
+      }
+      return best;
+    };
+    const deflate = (p, share) => {
+      p.air = Math.max(0, p.air - share);
+      vis?.tyreFlat(p.def, TYRE_FLAT_SAG * (1 - p.air));
+      if (p.air <= TYRE_FLAT_AIR) p.flat = true;
+    };
     const update = (dt) => {
+      for (const p of ps.values()) if (p.airLoss > 0 && p.air > 0 && !p.lost) deflate(p, p.airLoss * dt);
       clock += dt;
       const out = queue;
       queue = [];
@@ -14480,9 +15816,14 @@ var GameVehicles = (() => {
       },
       describe,
       hit,
+      surfaceRay,
       update,
       state,
       reset,
+      dispose: () => {
+        releaseCrease?.();
+        releaseCrease = void 0;
+      },
       disassemble,
       extinguish,
       serialize: () => ({
@@ -14493,6 +15834,70 @@ var GameVehicles = (() => {
       partName: (pid) => ps.get(pid)?.def.name ?? pid,
       status: computeStatus,
       animations: () => createVehicleClips(model, vis, kit, c),
+      crumple: (point, direction, depth) => {
+        if (!vis || depth <= 0) return;
+        sync();
+        const force = clamp((depth - CRUMPLE_BASE_M) / CRUMPLE_PER_FORCE_M, CRUMPLE_MIN_FORCE, CRUMPLE_MAX_FORCE);
+        kit.impact(c, toLocal(point), dirToLocal(direction).normalize(), force, { maxDepth: depth });
+        stateCache = void 0;
+      },
+      rollFlat: (meters, speed) => {
+        for (const p of ps.values()) {
+          if (p.def.role !== "tyre" || !p.flat || p.lost) continue;
+          const life = runFlat ? RUN_FLAT_LIFE_M * Math.min(1, RUN_FLAT_SPEED / Math.max(speed, 1)) : FLAT_TYRE_LIFE_M * clamp(FLAT_TYRE_TOWN_SPEED / Math.max(speed, 1), 0.2, 1.5);
+          p.hp = Math.max(0, p.hp - p.def.hp * meters / life);
+          if (p.hp > 0) continue;
+          const at = toWorld(p.def.box.center);
+          lose(p, "broken", queue, at);
+          queue.push(ev({ type: "debris", part: p.def.id, kind: "fibers", point: at, normal: [0, 1, 0], count: 12, speed: Math.max(2, speed * 0.5) }));
+        }
+        let grinding = 0;
+        for (const rim of ps.values()) {
+          if (rim.def.role !== "rim" || rim.lost || !tyreOf(rim)?.lost) continue;
+          grinding += 1;
+          rim.hp = Math.max(1, rim.hp - rim.def.hp * RIM_GRIND_PER_M * meters);
+          const [x, y, z] = rim.def.box.center;
+          queue.push(ev({ type: "debris", part: rim.def.id, kind: "sparks", point: toWorld([x, y - rim.def.box.size[1] / 2, z]), normal: [0, 1, 0], count: Math.min(30, Math.ceil(4 + speed)), speed: Math.max(2, speed * 0.4) }));
+        }
+        stateCache = void 0;
+        return grinding;
+      },
+      runEngine: (seconds, load) => {
+        const engine = [...ps.values()].find((p) => p.def.role === "engine");
+        if (!engine || engine.lost || seized) return engineHeat;
+        const share = (fluid) => {
+          const list2 = [...ps.values()].filter((p) => p.def.contains?.fluid === fluid);
+          return list2.length ? Math.min(...list2.map((p) => (p.liters ?? 0) / p.def.contains.liters)) : 1;
+        };
+        const coolant = share("coolant");
+        const oil = share("oil");
+        const work = 0.4 + 0.6 * clamp(load, 0, 1);
+        if (coolant < COOLANT_NEEDED) engineHeat += (COOLANT_NEEDED - coolant) / COOLANT_NEEDED * ENGINE_HEATING * work * seconds;
+        else engineHeat += (ENGINE_WORKING_C - engineHeat) * Math.min(1, seconds / ENGINE_SETTLE_S);
+        if (oil < OIL_NEEDED) engine.hp = Math.max(0, engine.hp - engine.def.hp * OIL_WEAR * work * seconds * ((OIL_NEEDED - oil) / OIL_NEEDED));
+        if (engineHeat >= ENGINE_STEAM_C && vis && !steaming) {
+          steaming = true;
+          kit.addEmitter(c, new V3(engine.def.box.center[0], engine.def.box.center[1] + 0.4, 0), "white", { rate: 8, s: 1 });
+        }
+        if (engineHeat >= ENGINE_SEIZE_C || engine.hp <= engine.def.hp * ENGINE_SEIZE_HP) {
+          seized = true;
+          queue.push(ev({ type: "damage", part: engine.def.id, amount: 0, hp: r2(engine.hp), damageType: "heat" }));
+        }
+        stateCache = void 0;
+        return engineHeat;
+      },
+      driveReport: () => {
+        const health = (role) => {
+          const list2 = [...ps.values()].filter((p) => p.def.role === role);
+          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 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;
+        return { tyres, brakes: Math.min(1, 1 / status.brakeFactor) * (BRAKE_NO_FLUID + (1 - BRAKE_NO_FLUID) * fluidLeft), engine: status.canStart ? health("engine") : 0, suspension: health("shocks") };
+      },
       partWorldCenter: (pid) => {
         sync();
         const d = ps.get(pid)?.def;
@@ -14521,6 +15926,89 @@ var GameVehicles = (() => {
     return { root, vehicle };
   }
 
+  // src/destructible/crease-queue.ts
+  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);
+        };
+      }
+    };
+  }
+
+  // src/destructible/crash.ts
+  var CRASH_RULES = { energyToDamage: 0.3, hitSpacing: 0.6, minSpeed: 1.5, rows: [0, 0.3], crushPerMs: 0.035, maxCrush: 0.6 };
+  function crashDeltaV(speed, massKg, otherMassKg) {
+    if (!Number.isFinite(otherMassKg)) return speed;
+    return speed * otherMassKg / (massKg + otherMassKg);
+  }
+  function crashVehicle(d, crash) {
+    const rules = { ...CRASH_RULES, ...crash.rules };
+    const deltaV = crashDeltaV(crash.speed, crash.massKg, crash.otherMassKg);
+    const energy = 0.5 * crash.massKg * deltaV * deltaV;
+    if (crash.speed < rules.minSpeed) return { deltaV, energy, events: [] };
+    const [dx, , dz] = crash.direction;
+    const length = Math.hypot(dx, dz) || 1;
+    const across = [-dz / length, 0, dx / length];
+    const hits = Math.max(1, Math.round(crash.contactWidth / rules.hitSpacing));
+    const each = energy * rules.energyToDamage / (hits * rules.rows.length);
+    const events = [];
+    for (const up of rules.rows)
+      for (let i = 0; i < hits; i++) {
+        const offset = hits === 1 ? 0 : (i / (hits - 1) - 0.5) * crash.contactWidth;
+        const point = [crash.point[0] + across[0] * offset, crash.point[1] + up, crash.point[2] + across[2] * offset];
+        events.push(...d.hit({ type: "blunt", point, direction: [dx / length, 0, dz / length], energy: each, radius: rules.hitSpacing / 2, ...crash.source ? { source: crash.source } : {} }));
+      }
+    const crush = Math.min(rules.maxCrush, deltaV * rules.crushPerMs);
+    d.crumple(crash.point, [dx / length, 0, dz / length], crush);
+    return { deltaV, energy, events };
+  }
+
   // src/destructible/enclosure.ts
   var CABIN_LEAK = 0.02;
   var HOLE_RATE_PER_AREA = 3e3;