@adatechnology/game-vehicles-three 0.1.0 → 0.3.0

package/dist/index.global.js

@@ -22,6 +22,7 @@ var GameVehiclesThree = (() => {
   var index_exports = {};
   __export(index_exports, {
     DEFAULT_TEST_VEHICLES: () => DEFAULT_TEST_VEHICLES,
+    DEFAULT_TEST_WRECKS: () => DEFAULT_TEST_WRECKS,
     LITE_CLASSES: () => LITE_CLASSES,
     PAGE_ITEM_ALIASES: () => PAGE_ITEM_ALIASES,
     PAGE_SCENARIO_ALIASES: () => PAGE_SCENARIO_ALIASES,
@@ -5128,8 +5129,8 @@ var GameVehiclesThree = (() => {
         });
       return GRM[kind];
     }
-    function mkSurf(mesh, W) {
-      const geo = mesh.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
+    function mkSurf(mesh2, W) {
+      const geo = mesh2.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
       geo.computeBoundingBox();
       const bb = geo.boundingBox.clone();
       const T = [], BY = {}, BX = {}, Q = 0.02;
@@ -5146,11 +5147,11 @@ var GameVehiclesThree = (() => {
       S.hit = function(o, dd) {
         const d = dd.clone().normalize();
         ray.set(o, d);
-        const list = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
-        if (!list) return null;
+        const list2 = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
+        if (!list2) return null;
         let best = 1e9, bt = null;
-        for (let k = 0; k < list.length; k++) {
-          const t = T[list[k]];
+        for (let k = 0; k < list2.length; k++) {
+          const t = T[list2[k]];
           if (!ray.intersectTriangle(t[0], t[1], t[2], false, tmp)) continue;
           const dist = tmp.distanceTo(o);
           if (dist < best) {
@@ -5325,8 +5326,8 @@ var GameVehiclesThree = (() => {
       t.castShadow = false;
       return t;
     }
-    function lineOn(c, Gd, list, r, mat, off) {
-      const pts = list.map(function(q) {
+    function lineOn(c, Gd, list2, r, mat, off) {
+      const pts = list2.map(function(q) {
         const s = Gd.at(q[0], q[1]);
         return s.p.addScaledVector(s.n, off || 3e-3);
       });
@@ -5397,8 +5398,8 @@ var GameVehiclesThree = (() => {
           const r = sh(q[0]), y = (r[0] + r[1]) / 2 + (q[1] || 0), s = Gd.at(q[0], y), rad = q[2] || Math.min(0.034, (r[1] - r[0]) * 0.4);
           const cup = onSurf(c.cylinder(rad * 1.35, rad * 1.2, 0.012, LH, 0, 0, 0), s, 8e-3);
           cup.castShadow = false;
-          const ring = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
-          ring.castShadow = false;
+          const ring2 = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
+          ring2.castShadow = false;
           const b = onSurf(c.sphere(rad, MT.head, 0, 0, 0, 1, 0.55, 1), s, 0.01);
           b.castShadow = false;
           inner.push(b);
@@ -6015,9 +6016,9 @@ var GameVehiclesThree = (() => {
       });
     })();
     const REFLB = CM("#d3d7da", { metalness: 0.35, roughness: 0.28 });
-    function dlo(list) {
+    function dlo(list2) {
       return function(def) {
-        return list.concat([def[def.length - 1]]);
+        return list2.concat([def[def.length - 1]]);
       };
     }
     function cabTaper(belt, top, x0, L, a) {
@@ -8375,7 +8376,7 @@ var GameVehiclesThree = (() => {
           guards: [-1.1, 2],
           lightsY: 0.62
         });
-        const box = boxBody(c, { x0: f - len - 0.1, x1: -3.72, y0: 0.98, y1: 3.38, W: 2.42, col: "#f1f1ec" });
+        const box2 = boxBody(c, { x0: f - len - 0.1, x1: -3.72, y0: 0.98, y1: 3.38, W: 2.42, col: "#f1f1ec" });
         [1, -1].forEach(function(s) {
           c.roundBox(4.6, 0.32, 0.01, 0.01, CM("#1f4fa3", { roughness: 0.5 }), -1, 1.35, s * 1.217);
           c.roundBox(4.6, 0.06, 0.01, 0.01, CM("#e0a21c", { roughness: 0.5 }), -1, 1.56, s * 1.217);
@@ -8406,7 +8407,7 @@ var GameVehiclesThree = (() => {
             c2.rod(new V3(-3.86, 0.6, z), new V3(-3.86, 3.5, z), 0.022, kit.steelMaterial);
           });
         });
-        void box;
+        void box2;
       }
     );
     fx.register(
@@ -9583,9 +9584,9 @@ var GameVehiclesThree = (() => {
       return m;
     }
     function fenestron(c, x, y, R, w, n, mat, bladeMat) {
-      const ring = c.add(new THREE.TorusGeometry(R + 0.06, 0.07, 10, 36), mat, x, y, 0);
-      ring.scale.z = w / 0.14;
-      c.deform.push(ring);
+      const ring2 = c.add(new THREE.TorusGeometry(R + 0.06, 0.07, 10, 36), mat, x, y, 0);
+      ring2.scale.z = w / 0.14;
+      c.deform.push(ring2);
       const duct = c.cylinder(R + 0.01, R + 0.01, w, MT.dark, x, y, 0, "z", { seg: 36, open: true });
       duct.material = CM("#141516", { roughness: 0.8, side: THREE.DoubleSide });
       const g = new THREE.Group();
@@ -9613,7 +9614,7 @@ var GameVehiclesThree = (() => {
         );
       }
       c.spin.push({ o: g, axis: "z", v: 22 });
-      return { ring, fan: g, duct };
+      return { ring: ring2, fan: g, duct };
     }
     function xRotor(c, x, y, z, R, ch, mat, tip) {
       const g = new THREE.Group();
@@ -11330,16 +11331,16 @@ var GameVehiclesThree = (() => {
     function settle(c, tilt, riseOnly) {
       if (tilt) c.vehicle.rotation.z += tilt;
       c.root.updateMatrixWorld(true);
-      const inv = new THREE.Matrix4().copy(c.root.matrixWorld).invert(), box = new THREE.Box3(), tmp = new THREE.Box3();
+      const inv = new THREE.Matrix4().copy(c.root.matrixWorld).invert(), box2 = new THREE.Box3(), tmp = new THREE.Box3();
       c.vehicle.traverse(function(ob) {
         if (!ob.isMesh) return;
         for (let q = ob; q && q !== c.vehicle; q = q.parent)
           if (!q.visible || q.userData.decal || q.userData.ghost || q.userData.antena) return;
         if (!ob.geometry.boundingBox) ob.geometry.computeBoundingBox();
         tmp.copy(ob.geometry.boundingBox).applyMatrix4(ob.matrixWorld).applyMatrix4(inv);
-        box.union(tmp);
+        box2.union(tmp);
       });
-      if (!box.isEmpty() && (!riseOnly || box.min.y < -5e-3)) c.vehicle.position.y -= box.min.y;
+      if (!box2.isEmpty() && (!riseOnly || box2.min.y < -5e-3)) c.vehicle.position.y -= box2.min.y;
     }
     function rollover(c, o) {
       o = o || {};
@@ -11616,10 +11617,10 @@ var GameVehiclesThree = (() => {
     function periscope(c, x, y, z, w, label, o) {
       o = o || {};
       const rot = o.rot || 0;
-      const box = c.roundBox(0.14, 0.12, w + 0.06, 0.02, o.mat || OLIVE_STEEL, x, y, z, { rot: [0, rot, 0] });
+      const box2 = c.roundBox(0.14, 0.12, w + 0.06, 0.02, o.mat || OLIVE_STEEL, x, y, z, { rot: [0, rot, 0] });
       const gl = c.roundBox(0.02, 0.07, w, 0.01, MT.armorGlass, x + Math.cos(rot) * 0.07, y, z - Math.sin(rot) * 0.07, { rot: [0, rot, 0] });
       if (label) kit.asGlass(c, gl, label, "laminated");
-      return box;
+      return box2;
     }
     function sideSeat(c, x0, x1, fl, z, dir, o) {
       o = o || {};
@@ -13947,7 +13948,7 @@ var GameVehiclesThree = (() => {
       o = o || {};
       if (kit.lod.on) o = Object.assign({}, o, { seg: Math.max(kit.lod.minLoftSegments, Math.round((o.seg || 24) * kit.lod.loftSegmentFraction)) });
       if (o.smooth) st = resample(st, o.smooth);
-      const seg = o.seg || 24, pos = [], idx = [], ring = seg + 1, axisY = o.axis === "y";
+      const seg = o.seg || 24, pos = [], idx = [], ring2 = seg + 1, axisY = o.axis === "y";
       st.forEach(function(s) {
         const a0 = s[1], b0 = s[2], cc = (a0 + b0) / 2, hh = Math.abs(a0 - b0) / 2, w = s[3] / 2, e = 2 / (s[4] || o.p || 2.4), zc = s[5] || 0;
         for (let j = 0; j <= seg; j++) {
@@ -13959,7 +13960,7 @@ var GameVehiclesThree = (() => {
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const A = i * ring + k, B = A + ring;
+          const A = i * ring2 + k, B = A + ring2;
           if (axisY) idx.push(A, B, A + 1, A + 1, B, B + 1);
           else idx.push(A, A + 1, B, A + 1, B + 1, B);
         }
@@ -13971,7 +13972,7 @@ var GameVehiclesThree = (() => {
         if (axisY) pos.push(cc, s[0], s[5] || 0);
         else pos.push(s[0], cc, s[5] || 0);
         for (let k = 0; k < seg; k++) {
-          const a = si * ring + k, flip = e === 0 !== axisY;
+          const a = si * ring2 + k, flip = e === 0 !== axisY;
           if (flip) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
         }
@@ -14158,8 +14159,8 @@ var GameVehiclesThree = (() => {
         });
       return GRM[kind];
     }
-    function mkSurf(mesh, W) {
-      const geo = mesh.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
+    function mkSurf(mesh2, W) {
+      const geo = mesh2.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
       geo.computeBoundingBox();
       const bb = geo.boundingBox.clone();
       const T = [], BY = {}, BX = {}, Q = 0.02;
@@ -14176,11 +14177,11 @@ var GameVehiclesThree = (() => {
       S.hit = function(o, dd) {
         const d = dd.clone().normalize();
         ray.set(o, d);
-        const list = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
-        if (!list) return null;
+        const list2 = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
+        if (!list2) return null;
         let best = 1e9, bt = null;
-        for (let k = 0; k < list.length; k++) {
-          const t = T[list[k]];
+        for (let k = 0; k < list2.length; k++) {
+          const t = T[list2[k]];
           if (!ray.intersectTriangle(t[0], t[1], t[2], false, tmp)) continue;
           const dist = tmp.distanceTo(o);
           if (dist < best) {
@@ -14355,8 +14356,8 @@ var GameVehiclesThree = (() => {
       t.castShadow = false;
       return t;
     }
-    function lineOn(c, Gd, list, r, mat, off) {
-      const pts = list.map(function(q) {
+    function lineOn(c, Gd, list2, r, mat, off) {
+      const pts = list2.map(function(q) {
         const s = Gd.at(q[0], q[1]);
         return s.p.addScaledVector(s.n, off || 3e-3);
       });
@@ -14427,8 +14428,8 @@ var GameVehiclesThree = (() => {
           const r = sh(q[0]), y = (r[0] + r[1]) / 2 + (q[1] || 0), s = Gd.at(q[0], y), rad = q[2] || Math.min(0.034, (r[1] - r[0]) * 0.4);
           const cup = onSurf(c.cylinder(rad * 1.35, rad * 1.2, 0.012, LH, 0, 0, 0), s, 8e-3);
           cup.castShadow = false;
-          const ring = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
-          ring.castShadow = false;
+          const ring2 = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
+          ring2.castShadow = false;
           const b = onSurf(c.sphere(rad, MT.head, 0, 0, 0, 1, 0.55, 1), s, 0.01);
           b.castShadow = false;
           inner.push(b);
@@ -16505,9 +16506,9 @@ var GameVehiclesThree = (() => {
       L.inner.push(m);
       return m;
     }
-    function bendSet(list, piv, axis, ang) {
+    function bendSet(list2, piv, axis, ang) {
       const q = new THREE.Quaternion().setFromAxisAngle(axis.clone().normalize(), ang);
-      list.forEach(function(m) {
+      list2.forEach(function(m) {
         if (!m.parent) return;
         m.position.sub(piv).applyQuaternion(q).add(piv);
         m.quaternion.premultiply(q);
@@ -17554,7 +17555,7 @@ var GameVehiclesThree = (() => {
       );
       [1, -1].forEach(function(s) {
         const z = s * (s > 0 ? 0.44 : 0.4);
-        const box = c.roundBox(0.5, 0.38, 0.2, 0.03, aluBox, -0.7, 0.8, z, { def: true }), luggageCase = [box, c.roundBox(0.52, 0.04, 0.21, 0.015, blk, -0.7, 0.98, z)];
+        const box2 = c.roundBox(0.5, 0.38, 0.2, 0.03, aluBox, -0.7, 0.8, z, { def: true }), luggageCase = [box2, c.roundBox(0.52, 0.04, 0.21, 0.015, blk, -0.7, 0.98, z)];
         [-0.88, -0.52].forEach(function(x) {
           luggageCase.push(c.roundBox(0.04, 0.06, 0.03, 0.01, blk, x, 0.95, z + s * 0.1));
         });
@@ -17568,7 +17569,7 @@ var GameVehiclesThree = (() => {
           blk,
           { seg: 12 }
         );
-        c.part("cargo", s > 0 ? trl("labels.right_pannier") : trl("labels.left_pannier"), box, new V3(-0.7, 0.8, z), 0.6);
+        c.part("cargo", s > 0 ? trl("labels.right_pannier") : trl("labels.left_pannier"), box2, new V3(-0.7, 0.8, z), 0.6);
         c.zone(
           s > 0 ? "case_right" : "case_left",
           s > 0 ? trl("labels.right_pannier") : trl("labels.left_pannier"),
@@ -18216,7 +18217,7 @@ var GameVehiclesThree = (() => {
     function sloft(st, o) {
       o = o || {};
       if (kit.lod.on) o = Object.assign({}, o, { seg: Math.max(kit.lod.minLoftSegments, Math.round((o.seg || 24) * kit.lod.loftSegmentFraction)) });
-      const seg = o.seg || 24, pos = [], idx = [], ring = seg + 1, axisY = o.axis === "y";
+      const seg = o.seg || 24, pos = [], idx = [], ring2 = seg + 1, axisY = o.axis === "y";
       st.forEach(function(s) {
         const a0 = s[1], b0 = s[2], cc = (a0 + b0) / 2, hh = Math.abs(a0 - b0) / 2, w = s[3] / 2, e = 2 / (s[4] || o.p || 2.4), zc = s[5] || 0;
         for (let j = 0; j <= seg; j++) {
@@ -18228,7 +18229,7 @@ var GameVehiclesThree = (() => {
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const A = i * ring + k, B = A + ring;
+          const A = i * ring2 + k, B = A + ring2;
           if (axisY) idx.push(A, B, A + 1, A + 1, B, B + 1);
           else idx.push(A, A + 1, B, A + 1, B + 1, B);
         }
@@ -18240,7 +18241,7 @@ var GameVehiclesThree = (() => {
         if (axisY) pos.push(cc, s[0], s[5] || 0);
         else pos.push(s[0], cc, s[5] || 0);
         for (let k = 0; k < seg; k++) {
-          const a = si * ring + k, flip = e === 0 !== axisY;
+          const a = si * ring2 + k, flip = e === 0 !== axisY;
           if (flip) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
         }
@@ -19471,12 +19472,12 @@ var GameVehiclesThree = (() => {
         });
         Z.fairing = grab(c, n0).concat([fendF]);
         const HL = lamp(c, { style: "round", x: 0.72, y: 0.84, z: 0, w: 0.19, h: 0.19, d: 0.1, side: 1, label: trl("labels.headlight") });
-        const ring = new THREE.Mesh(new THREE.TorusGeometry(0.075, 7e-3, 6, 32), DRL);
-        ring.rotation.y = PI / 2;
-        ring.position.set(0.052, 0, 0);
-        ring.castShadow = false;
-        HL.group.add(ring);
-        HL.inner.push(ring);
+        const ring2 = new THREE.Mesh(new THREE.TorusGeometry(0.075, 7e-3, 6, 32), DRL);
+        ring2.rotation.y = PI / 2;
+        ring2.position.set(0.052, 0, 0);
+        ring2.castShadow = false;
+        HL.group.add(ring2);
+        HL.inner.push(ring2);
         n0 = c.vehicle.children.length;
         const TK = [
           [0.46, 0.89, 0.76, 0.18, 2.2],
@@ -22525,7 +22526,7 @@ var GameVehiclesThree = (() => {
       });
     }
     function roofLining(c, extra) {
-      const m = c.meta, yb = (m.glasshouse ? m.glasshouse.belt : m.belt) + 0.25, bb = new THREE.Box3(), sz = new V3(), ce = new V3(), gl = new Set(c.glass), list = [];
+      const m = c.meta, yb = (m.glasshouse ? m.glasshouse.belt : m.belt) + 0.25, bb = new THREE.Box3(), sz = new V3(), ce = new V3(), gl = new Set(c.glass), list2 = [];
       const cols = [m.color, m.roofCol].filter(Boolean).map(function(h) {
         return new THREE.Color(h).getHex();
       });
@@ -22537,14 +22538,14 @@ var GameVehiclesThree = (() => {
         bb.copy(o.geometry.boundingBox).applyMatrix4(o.matrix);
         bb.getSize(sz);
         bb.getCenter(ce);
-        if (sz.x > 0.5 && sz.z > 0.6 && sz.y < 0.08 && ce.y > yb) list.push(o);
+        if (sz.x > 0.5 && sz.z > 0.6 && sz.y < 0.08 && ce.y > yb) list2.push(o);
       });
       extra = extra || [];
-      if (list.length || extra.length)
+      if (list2.length || extra.length)
         c.zone("roof", null, null, null, {
           onBand: function(c2, b) {
             if (b >= 4)
-              list.concat(extra).forEach(function(o) {
+              list2.concat(extra).forEach(function(o) {
                 o.visible = false;
               });
           }
@@ -24329,7 +24330,7 @@ var GameVehiclesThree = (() => {
         }
         return pts;
       }
-      const ring = 2 * (m1 + m2) + 1;
+      const ring2 = 2 * (m1 + m2) + 1;
       for (let i = 0; i <= n; i++) {
         const t = i / n, x = o.x0 + t * o.L, P = sec(t), row = [];
         for (let k = P.length - 1; k >= 1; k--) row.push([-P[k][0], P[k][1]]);
@@ -24345,8 +24346,8 @@ var GameVehiclesThree = (() => {
         });
       }
       for (let a = 0; a < n; a++)
-        for (let k2 = 0; k2 < ring - 1; k2++) {
-          const p0 = a * ring + k2, p1 = p0 + ring;
+        for (let k2 = 0; k2 < ring2 - 1; k2++) {
+          const p0 = a * ring2 + k2, p1 = p0 + ring2;
           idx.push(p0, p0 + 1, p1, p0 + 1, p1 + 1, p1);
         }
       const ci = pos.length / 3, sh0 = o.sheer(0), ky0 = o.keel(0);
@@ -24355,7 +24356,7 @@ var GameVehiclesThree = (() => {
         const c0 = o.col(o.x0, (sh0[1] + ky0) / 2, 0);
         col.push(c0.r, c0.g, c0.b);
       }
-      for (let r = 0; r < ring - 1; r++) idx.push(ci, r + 1, r);
+      for (let r = 0; r < ring2 - 1; r++) idx.push(ci, r + 1, r);
       let g = new THREE.BufferGeometry();
       g.setAttribute("position", new THREE.Float32BufferAttribute(pos, 3));
       if (o.col) g.setAttribute("color", new THREE.Float32BufferAttribute(col, 3));
@@ -24428,7 +24429,7 @@ var GameVehiclesThree = (() => {
     function foilGeo(sts, o) {
       o = o || {};
       const n = o.n || 12, up = o.up || "y", pos = [], idx = [];
-      let ring;
+      let ring2;
       const cnt = 0;
       function prof(st) {
         const out = [], cam = st.cam || 0;
@@ -24448,14 +24449,14 @@ var GameVehiclesThree = (() => {
       }
       sts.forEach(function(st) {
         const P = prof(st);
-        ring = P.length;
+        ring2 = P.length;
         P.forEach(function(p) {
           pos.push(p[0], p[1], p[2]);
         });
       });
       for (let a = 0; a < sts.length - 1; a++)
-        for (let k = 0; k < ring; k++) {
-          const k1 = (k + 1) % ring, p0 = a * ring + k, p1 = (a + 1) * ring + k, q0 = a * ring + k1, q1 = (a + 1) * ring + k1;
+        for (let k = 0; k < ring2; k++) {
+          const k1 = (k + 1) % ring2, p0 = a * ring2 + k, p1 = (a + 1) * ring2 + k, q0 = a * ring2 + k1, q1 = (a + 1) * ring2 + k1;
           idx.push(p0, q0, p1, q0, q1, p1);
         }
       ;
@@ -24463,8 +24464,8 @@ var GameVehiclesThree = (() => {
         if (sts[si].noCap) return;
         const ci = pos.length / 3, st = sts[si];
         pos.push(st.p[0] - st.c * 0.35, st.p[1], st.p[2]);
-        for (let k = 0; k < ring; k++) {
-          const a0 = si * ring + k, a1 = si * ring + (k + 1) % ring;
+        for (let k = 0; k < ring2; k++) {
+          const a0 = si * ring2 + k, a1 = si * ring2 + (k + 1) % ring2;
           if (e === 0) idx.push(ci, a1, a0);
           else idx.push(ci, a0, a1);
         }
@@ -24692,7 +24693,7 @@ var GameVehiclesThree = (() => {
       blue: CM("#1d4f9a", { emissive: new THREE.Color("#3a7cff"), emissiveIntensity: 1.4, roughness: 0.3 })
     };
     const HALO = { red: "#ff3a2a", green: "#3aff7a", white: "#fff1d0", amber: "#ffb040", blue: "#4a8cff" };
-    function navLight(c, x, y, z, color, label, o) {
+    function navLight(c, x, y, z, color2, label, o) {
       o = o || {};
       const r = o.r || 0.045, g = new THREE.Group();
       g.position.set(x, y, z);
@@ -24702,11 +24703,11 @@ var GameVehiclesThree = (() => {
       base.position.y = -r * 0.4;
       if (o.rot) base.rotation.set(o.rot[0], o.rot[1], o.rot[2]);
       g.add(base);
-      const bulb = new THREE.Mesh(new THREE.SphereGeometry(r * 0.55, 10, 8), NAV[color] || NAV.white);
+      const bulb = new THREE.Mesh(new THREE.SphereGeometry(r * 0.55, 10, 8), NAV[color2] || NAV.white);
       g.add(bulb);
       const lens = new THREE.Mesh(
         new THREE.SphereGeometry(r, 12, 8),
-        color === "red" ? MT.lensRed : color === "amber" ? MT.lensAmber : MT.lens
+        color2 === "red" ? MT.lensRed : color2 === "amber" ? MT.lensAmber : MT.lens
       );
       lens.renderOrder = 3;
       g.add(lens);
@@ -24715,10 +24716,10 @@ var GameVehiclesThree = (() => {
         inner: [bulb],
         lens: [lens],
         kind: o.front ? "headlight" : "taillight",
-        tint: color === "red" ? "red" : "clear",
+        tint: color2 === "red" ? "red" : "clear",
         broken: false
       };
-      if (o.halo !== false) L.halo = [kit.halo(g, 0, 0, 0, o.hs || 0.35, HALO[color] || "#ffffff", 0.5)];
+      if (o.halo !== false) L.halo = [kit.halo(g, 0, 0, 0, o.hs || 0.35, HALO[color2] || "#ffffff", 0.5)];
       c.lights.push(L);
       const pt = c.part(o.front ? "headlight" : "taillight", label, g, new V3(x, y, z), o.reach || 0.5);
       pt.light = L;
@@ -24840,15 +24841,15 @@ var GameVehiclesThree = (() => {
       c.roundBox(0.16 * r, 0.03, 0.04, 0.012, MT.chrome, x, y + 0.04, z);
       c.roundBox(0.04, 0.04, 0.03, 0.01, MT.chrome, x, y + 0.02, z);
     }
-    function skinOf2(c, mesh, keep, mat, o) {
+    function skinOf2(c, mesh2, keep, mat, o) {
       o = o || {};
-      const g = mesh.geometry.clone(), p = g.attributes.position, sz = o.sz || 1.006, dy = o.dy || 0;
+      const g = mesh2.geometry.clone(), p = g.attributes.position, sz = o.sz || 1.006, dy = o.dy || 0;
       for (let i = 0; i < p.count; i++) {
         p.setZ(i, p.getZ(i) * sz);
         p.setY(i, p.getY(i) + dy * Math.sign(p.getY(i)));
       }
       if (g.attributes.color) g.deleteAttribute("color");
-      const m = c.add(g, mat, mesh.position.x, mesh.position.y, mesh.position.z);
+      const m = c.add(g, mat, mesh2.position.x, mesh2.position.y, mesh2.position.z);
       m.castShadow = false;
       kit.cutMesh(m, [keep], 40, o.sub ? { sub: o.sub } : void 0);
       c.deform.push(m);
@@ -27604,9 +27605,9 @@ var GameVehiclesThree = (() => {
     for (const name of LITE_CLASSES) acc[name] = { P: [], N: [], C: [], U: [], I: [], nv: 0, alpha: name === "glass", uv: name === "plate", map: null };
     return acc;
   };
-  function classify(mat, mesh, c) {
+  function classify(mat, mesh2, c) {
     if (mat.map) {
-      if (mesh.userData.plate) return "plate";
+      if (mesh2.userData.plate) return "plate";
       if (mat.userData && mat.userData.grille || mat.name === "grille" || mat.metalness != null && mat.roughness != null && !mat.transparent) return "trim";
       return null;
     }
@@ -27752,11 +27753,11 @@ var GameVehiclesThree = (() => {
         mt.map = A.map;
         if (mt.map) mt.map.needsUpdate = true;
       }
-      const mesh = new THREE.Mesh(g, mt);
-      mesh.name = name;
-      mesh.castShadow = name !== "glass" && name !== "light";
-      mesh.receiveShadow = name !== "light";
-      meshes.push(mesh);
+      const mesh2 = new THREE.Mesh(g, mt);
+      mesh2.name = name;
+      mesh2.castShadow = name !== "glass" && name !== "light";
+      mesh2.receiveShadow = name !== "light";
+      meshes.push(mesh2);
     }
     return meshes;
   }
@@ -27805,7 +27806,7 @@ var GameVehiclesThree = (() => {
       const spec = kit.find(key);
       if (!spec) throw new Error(`createVehiclesThree: unknown vehicle "${key}"`);
       const seed = o.seed == null ? null : o.seed;
-      const color = o.color || (seed != null ? colorFromSeed(seed, isMilitary(key) ? paintPalettes.military : paintPalettes.civil) : null);
+      const color2 = o.color || (seed != null ? colorFromSeed(seed, isMilitary(key) ? paintPalettes.military : paintPalettes.civil) : null);
       const c = kit.build(key, o.state || "intact", void 0, { lod: quality === "lite" });
       c.root.updateMatrixWorld(true);
       const primary = primaryPaint(c);
@@ -27836,9 +27837,9 @@ var GameVehiclesThree = (() => {
         c.vehicle.matrixAutoUpdate = true;
         pivot.add(c.vehicle);
         group.add(pivot);
-        if (color && primary) {
+        if (color2 && primary) {
           const repainted = primary.clone();
-          repainted.color.set(color);
+          repainted.color.set(color2);
           c.vehicle.traverse((m) => {
             if (!m.isMesh) return;
             if (Array.isArray(m.material)) m.material = m.material.map((x) => x === primary ? repainted : x);
@@ -27848,8 +27849,8 @@ var GameVehiclesThree = (() => {
         markDamageables(c, damageables);
         group.updateMatrixWorld(true);
       } else {
-        const fusion = fuse(THREE, c, pivotMatrix, color ? new THREE.Color(color) : null, primary, kit.lodHiddenMaterials());
-        for (const mesh of liteMeshes(THREE, fusion, liteMaterials(THREE, kit.studioEnvironment()))) group.add(mesh);
+        const fusion = fuse(THREE, c, pivotMatrix, color2 ? new THREE.Color(color2) : null, primary, kit.lodHiddenMaterials());
+        for (const mesh2 of liteMeshes(THREE, fusion, liteMaterials(THREE, kit.studioEnvironment()))) group.add(mesh2);
         pruned = fusion.pruned;
       }
       const size = new THREE.Box3().setFromObject(group).getSize(new THREE.Vector3());
@@ -27860,7 +27861,7 @@ var GameVehiclesThree = (() => {
       return {
         key,
         quality,
-        color,
+        color: color2,
         seed,
         group,
         damageables,
@@ -27895,6 +27896,1594 @@ var GameVehiclesThree = (() => {
     }
   }
 
+  // ../game-shapes/dist/chunk-R4RY23RH.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));
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "boolean") return value ? "true" : "false";
+    if (typeof value === "function") throw new Error("game-shapes: a function cannot be part of a shape (register it as a generator)");
+    if (ArrayBuffer.isView(value)) return canonicalJson(Array.from(value));
+    if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : canonicalJson(item)).join(",")}]`;
+    if (typeof value === "object") {
+      const record = value;
+      const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
+      return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return "null";
+  }
+  function needsUint32(array) {
+    for (let i = array.length - 1; i >= 0; --i) if (array[i] >= 65535) return true;
+    return false;
+  }
+  var indexArray = (indices) => needsUint32(indices) ? new Uint32Array(indices) : new Uint16Array(indices);
+  function pack(type, parameters, a) {
+    return {
+      type,
+      parameters,
+      positions: new Float32Array(a.vertices),
+      normals: new Float32Array(a.normals),
+      uvs: new Float32Array(a.uvs),
+      ...a.indices ? { indices: indexArray(a.indices) } : {},
+      groups: a.groups
+    };
+  }
+  var normalize3 = (x, y, z) => {
+    const length = Math.sqrt(x * x + y * y + z * z);
+    const s = 1 / (length || 1);
+    return [x * s, y * s, z * s];
+  };
+  function box(width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1) {
+    const parameters = { width, height, depth, widthSegments, heightSegments, depthSegments };
+    widthSegments = Math.floor(widthSegments);
+    heightSegments = Math.floor(heightSegments);
+    depthSegments = Math.floor(depthSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let numberOfVertices = 0;
+    let groupStart = 0;
+    const buildPlane = (u, v, w, udir, vdir, width2, height2, depth2, gridX, gridY, materialIndex) => {
+      const segmentWidth = width2 / gridX;
+      const segmentHeight = height2 / gridY;
+      const widthHalf = width2 / 2;
+      const heightHalf = height2 / 2;
+      const depthHalf = depth2 / 2;
+      const gridX1 = gridX + 1;
+      const gridY1 = gridY + 1;
+      let vertexCounter = 0;
+      let groupCount = 0;
+      const vector = { x: 0, y: 0, z: 0 };
+      for (let iy = 0; iy < gridY1; iy++) {
+        const y = iy * segmentHeight - heightHalf;
+        for (let ix = 0; ix < gridX1; ix++) {
+          const x = ix * segmentWidth - widthHalf;
+          vector[u] = x * udir;
+          vector[v] = y * vdir;
+          vector[w] = depthHalf;
+          vertices.push(vector.x, vector.y, vector.z);
+          vector[u] = 0;
+          vector[v] = 0;
+          vector[w] = depth2 > 0 ? 1 : -1;
+          normals.push(vector.x, vector.y, vector.z);
+          uvs.push(ix / gridX);
+          uvs.push(1 - iy / gridY);
+          vertexCounter += 1;
+        }
+      }
+      for (let iy = 0; iy < gridY; iy++) {
+        for (let ix = 0; ix < gridX; ix++) {
+          const a = numberOfVertices + ix + gridX1 * iy;
+          const b = numberOfVertices + ix + gridX1 * (iy + 1);
+          const c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1);
+          const d = numberOfVertices + (ix + 1) + gridX1 * iy;
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex });
+      groupStart += groupCount;
+      numberOfVertices += vertexCounter;
+    };
+    buildPlane("z", "y", "x", -1, -1, depth, height, width, depthSegments, heightSegments, 0);
+    buildPlane("z", "y", "x", 1, -1, depth, height, -width, depthSegments, heightSegments, 1);
+    buildPlane("x", "z", "y", 1, 1, width, depth, height, widthSegments, depthSegments, 2);
+    buildPlane("x", "z", "y", 1, -1, width, depth, -height, widthSegments, depthSegments, 3);
+    buildPlane("x", "y", "z", 1, -1, width, height, depth, widthSegments, heightSegments, 4);
+    buildPlane("x", "y", "z", -1, -1, width, height, -depth, widthSegments, heightSegments, 5);
+    return pack("BoxGeometry", parameters, { vertices, normals, uvs, indices, groups });
+  }
+  function cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
+    radialSegments = Math.floor(radialSegments);
+    heightSegments = Math.floor(heightSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let index = 0;
+    const indexArray2 = [];
+    const halfHeight = height / 2;
+    let groupStart = 0;
+    const generateTorso = () => {
+      let groupCount = 0;
+      const slope = (radiusBottom - radiusTop) / height;
+      for (let y = 0; y <= heightSegments; y++) {
+        const indexRow = [];
+        const v = y / heightSegments;
+        const radius = v * (radiusBottom - radiusTop) + radiusTop;
+        for (let x = 0; x <= radialSegments; x++) {
+          const u = x / radialSegments;
+          const theta = u * thetaLength + thetaStart;
+          const sinTheta = Math.sin(theta);
+          const cosTheta = Math.cos(theta);
+          vertices.push(radius * sinTheta, -v * height + halfHeight, radius * cosTheta);
+          const n = normalize3(sinTheta, slope, cosTheta);
+          normals.push(n[0], n[1], n[2]);
+          uvs.push(u, 1 - v);
+          indexRow.push(index++);
+        }
+        indexArray2.push(indexRow);
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        for (let y = 0; y < heightSegments; y++) {
+          const a = indexArray2[y][x];
+          const b = indexArray2[y + 1][x];
+          const c = indexArray2[y + 1][x + 1];
+          const d = indexArray2[y][x + 1];
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: 0 });
+      groupStart += groupCount;
+    };
+    const generateCap = (top) => {
+      const centerIndexStart = index;
+      let groupCount = 0;
+      const radius = top === true ? radiusTop : radiusBottom;
+      const sign2 = top === true ? 1 : -1;
+      for (let x = 1; x <= radialSegments; x++) {
+        vertices.push(0, halfHeight * sign2, 0);
+        normals.push(0, sign2, 0);
+        uvs.push(0.5, 0.5);
+        index++;
+      }
+      const centerIndexEnd = index;
+      for (let x = 0; x <= radialSegments; x++) {
+        const u = x / radialSegments;
+        const theta = u * thetaLength + thetaStart;
+        const cosTheta = Math.cos(theta);
+        const sinTheta = Math.sin(theta);
+        vertices.push(radius * sinTheta, halfHeight * sign2, radius * cosTheta);
+        normals.push(0, sign2, 0);
+        uvs.push(cosTheta * 0.5 + 0.5, sinTheta * 0.5 * sign2 + 0.5);
+        index++;
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        const c = centerIndexStart + x;
+        const i = centerIndexEnd + x;
+        if (top === true) indices.push(i, i + 1, c);
+        else indices.push(i + 1, i, c);
+        groupCount += 3;
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: top === true ? 1 : 2 });
+      groupStart += groupCount;
+    };
+    generateTorso();
+    if (openEnded === false) {
+      if (radiusTop > 0) generateCap(true);
+      if (radiusBottom > 0) generateCap(false);
+    }
+    return { vertices, normals, uvs, indices, groups };
+  }
+  function cylinder(radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("CylinderGeometry", parameters, cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function cone(radius = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("ConeGeometry", parameters, cylinderArrays(0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function sphere(radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI) {
+    const parameters = { radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength };
+    widthSegments = Math.max(3, Math.floor(widthSegments));
+    heightSegments = Math.max(2, Math.floor(heightSegments));
+    const thetaEnd = Math.min(thetaStart + thetaLength, Math.PI);
+    let index = 0;
+    const grid = [];
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy <= heightSegments; iy++) {
+      const verticesRow = [];
+      const v = iy / heightSegments;
+      let uOffset = 0;
+      if (iy === 0 && thetaStart === 0) uOffset = 0.5 / widthSegments;
+      else if (iy === heightSegments && thetaEnd === Math.PI) uOffset = -0.5 / widthSegments;
+      for (let ix = 0; ix <= widthSegments; ix++) {
+        const u = ix / widthSegments;
+        const x = -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        const y = radius * Math.cos(thetaStart + v * thetaLength);
+        const z = radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        vertices.push(x, y, z);
+        const n = normalize3(x, y, z);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(u + uOffset, 1 - v);
+        verticesRow.push(index++);
+      }
+      grid.push(verticesRow);
+    }
+    for (let iy = 0; iy < heightSegments; iy++) {
+      for (let ix = 0; ix < widthSegments; ix++) {
+        const a = grid[iy][ix + 1];
+        const b = grid[iy][ix];
+        const c = grid[iy + 1][ix];
+        const d = grid[iy + 1][ix + 1];
+        if (iy !== 0 || thetaStart > 0) indices.push(a, b, d);
+        if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d);
+      }
+    }
+    return pack("SphereGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function plane(width = 1, height = 1, widthSegments = 1, heightSegments = 1) {
+    const parameters = { width, height, widthSegments, heightSegments };
+    const widthHalf = width / 2;
+    const heightHalf = height / 2;
+    const gridX = Math.floor(widthSegments);
+    const gridY = Math.floor(heightSegments);
+    const gridX1 = gridX + 1;
+    const gridY1 = gridY + 1;
+    const segmentWidth = width / gridX;
+    const segmentHeight = height / gridY;
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy < gridY1; iy++) {
+      const y = iy * segmentHeight - heightHalf;
+      for (let ix = 0; ix < gridX1; ix++) {
+        const x = ix * segmentWidth - widthHalf;
+        vertices.push(x, -y, 0);
+        normals.push(0, 0, 1);
+        uvs.push(ix / gridX);
+        uvs.push(1 - iy / gridY);
+      }
+    }
+    for (let iy = 0; iy < gridY; iy++) {
+      for (let ix = 0; ix < gridX; ix++) {
+        const a = ix + gridX1 * iy;
+        const b = ix + gridX1 * (iy + 1);
+        const c = ix + 1 + gridX1 * (iy + 1);
+        const d = ix + 1 + gridX1 * iy;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("PlaneGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function circle(radius = 1, segments = 32, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, segments, thetaStart, thetaLength };
+    segments = Math.max(3, segments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    vertices.push(0, 0, 0);
+    normals.push(0, 0, 1);
+    uvs.push(0.5, 0.5);
+    for (let s = 0, i = 3; s <= segments; s++, i += 3) {
+      const segment = thetaStart + s / segments * thetaLength;
+      vertices.push(radius * Math.cos(segment), radius * Math.sin(segment), 0);
+      normals.push(0, 0, 1);
+      uvs.push((vertices[i] / radius + 1) / 2, (vertices[i + 1] / radius + 1) / 2);
+    }
+    for (let i = 1; i <= segments; i++) indices.push(i, i + 1, 0);
+    return pack("CircleGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function ring(innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength };
+    thetaSegments = Math.max(3, thetaSegments);
+    phiSegments = Math.max(1, phiSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    let radius = innerRadius;
+    const radiusStep = (outerRadius - innerRadius) / phiSegments;
+    for (let j = 0; j <= phiSegments; j++) {
+      for (let i = 0; i <= thetaSegments; i++) {
+        const segment = thetaStart + i / thetaSegments * thetaLength;
+        const x = radius * Math.cos(segment);
+        const y = radius * Math.sin(segment);
+        vertices.push(x, y, 0);
+        normals.push(0, 0, 1);
+        uvs.push((x / outerRadius + 1) / 2, (y / outerRadius + 1) / 2);
+      }
+      radius += radiusStep;
+    }
+    for (let j = 0; j < phiSegments; j++) {
+      const thetaSegmentLevel = j * (thetaSegments + 1);
+      for (let i = 0; i < thetaSegments; i++) {
+        const segment = i + thetaSegmentLevel;
+        const a = segment;
+        const b = segment + thetaSegments + 1;
+        const c = segment + thetaSegments + 2;
+        const d = segment + 1;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("RingGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function lathe(points, segments = 12, phiStart = 0, phiLength = Math.PI * 2) {
+    const parameters = { points: points.map(([x, y]) => ({ x, y })), segments, phiStart, phiLength };
+    segments = Math.floor(segments);
+    phiLength = Math.max(0, Math.min(Math.PI * 2, phiLength));
+    const indices = [];
+    const vertices = [];
+    const uvs = [];
+    const initNormals = [];
+    const normals = [];
+    const inverseSegments = 1 / segments;
+    const normal = { x: 0, y: 0, z: 0 };
+    const curNormal = { x: 0, y: 0, z: 0 };
+    const prevNormal = { x: 0, y: 0, z: 0 };
+    let dx = 0;
+    let dy = 0;
+    const last = points.length - 1;
+    const px = (j) => points[j][0];
+    const py = (j) => points[j][1];
+    const setNormalized = () => {
+      const n = normalize3(normal.x, normal.y, normal.z);
+      normal.x = n[0];
+      normal.y = n[1];
+      normal.z = n[2];
+    };
+    for (let j = 0; j <= last; j++) {
+      if (j === 0) {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        prevNormal.x = normal.x;
+        prevNormal.y = normal.y;
+        prevNormal.z = normal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+      } else if (j === last) {
+        initNormals.push(prevNormal.x, prevNormal.y, prevNormal.z);
+      } else {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        curNormal.x = normal.x;
+        curNormal.y = normal.y;
+        curNormal.z = normal.z;
+        normal.x += prevNormal.x;
+        normal.y += prevNormal.y;
+        normal.z += prevNormal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+        prevNormal.x = curNormal.x;
+        prevNormal.y = curNormal.y;
+        prevNormal.z = curNormal.z;
+      }
+    }
+    for (let i = 0; i <= segments; i++) {
+      const phi = phiStart + i * inverseSegments * phiLength;
+      const sin = Math.sin(phi);
+      const cos = Math.cos(phi);
+      for (let j = 0; j <= last; j++) {
+        vertices.push(px(j) * sin, py(j), px(j) * cos);
+        uvs.push(i / segments, j / (points.length - 1));
+        const x = initNormals[3 * j + 0] * sin;
+        const y = initNormals[3 * j + 1];
+        const z = initNormals[3 * j + 0] * cos;
+        normals.push(x, y, z);
+      }
+    }
+    for (let i = 0; i < segments; i++) {
+      for (let j = 0; j < points.length - 1; j++) {
+        const base = j + i * points.length;
+        const a = base;
+        const b = base + points.length;
+        const c = base + points.length + 1;
+        const d = base + 1;
+        indices.push(a, b, d);
+        indices.push(c, d, b);
+      }
+    }
+    return pack("LatheGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function torus(radius = 1, tube = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) {
+    const parameters = { radius, tube, radialSegments, tubularSegments, arc };
+    radialSegments = Math.floor(radialSegments);
+    tubularSegments = Math.floor(tubularSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let j = 0; j <= radialSegments; j++) {
+      for (let i = 0; i <= tubularSegments; i++) {
+        const u = i / tubularSegments * arc;
+        const v = j / radialSegments * Math.PI * 2;
+        const x = (radius + tube * Math.cos(v)) * Math.cos(u);
+        const y = (radius + tube * Math.cos(v)) * Math.sin(u);
+        const z = tube * Math.sin(v);
+        vertices.push(x, y, z);
+        const cx = radius * Math.cos(u);
+        const cy = radius * Math.sin(u);
+        const n = normalize3(x - cx, y - cy, z - 0);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(i / tubularSegments);
+        uvs.push(j / radialSegments);
+      }
+    }
+    for (let j = 1; j <= radialSegments; j++) {
+      for (let i = 1; i <= tubularSegments; i++) {
+        const a = (tubularSegments + 1) * j + i - 1;
+        const b = (tubularSegments + 1) * (j - 1) + i - 1;
+        const c = (tubularSegments + 1) * (j - 1) + i;
+        const d = (tubularSegments + 1) * j + i;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("TorusGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function difference(size, subtract) {
+    const [w, h, d] = size;
+    const hw = w / 2;
+    const hh = h / 2;
+    const hd = d / 2;
+    const holes = subtract.map((hole) => ({ x0: Math.max(-hw, Math.min(hole.min[0], hole.max[0])), x1: Math.min(hw, Math.max(hole.min[0], hole.max[0])), y0: Math.max(-hh, Math.min(hole.min[1], hole.max[1])), y1: Math.min(hh, Math.max(hole.min[1], hole.max[1])) })).filter((hole) => hole.x1 > hole.x0 && hole.y1 > hole.y0);
+    const cuts = (lo, hi, values) => [.../* @__PURE__ */ new Set([lo, hi, ...values.filter((v) => v > lo && v < hi)])].sort((a, b) => a - b);
+    const xs = cuts(-hw, hw, holes.flatMap((hole) => [hole.x0, hole.x1]));
+    const ys = cuts(-hh, hh, holes.flatMap((hole) => [hole.y0, hole.y1]));
+    const nx = xs.length - 1;
+    const ny = ys.length - 1;
+    const solid = (i, j) => {
+      if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+      const cx = (xs[i] + xs[i + 1]) / 2;
+      const cy = (ys[j] + ys[j + 1]) / 2;
+      return !holes.some((hole) => cx > hole.x0 && cx < hole.x1 && cy > hole.y0 && cy < hole.y1);
+    };
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    const quad = (corners, normal, uv) => {
+      const base = positions.length / 3;
+      for (let k = 0; k < 4; k++) {
+        positions.push(...corners[k]);
+        normals.push(...normal);
+        uvs.push(...uv[k]);
+      }
+      indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    };
+    const fu = (x) => (x + hw) / w;
+    const fv = (y) => (y + hh) / h;
+    for (let j = 0; j < ny; j++) {
+      for (let i = 0; i < nx; i++) {
+        if (!solid(i, j)) continue;
+        const x0 = xs[i];
+        const x1 = xs[i + 1];
+        const y0 = ys[j];
+        const y1 = ys[j + 1];
+        quad([[x0, y0, hd], [x1, y0, hd], [x1, y1, hd], [x0, y1, hd]], [0, 0, 1], [[fu(x0), fv(y0)], [fu(x1), fv(y0)], [fu(x1), fv(y1)], [fu(x0), fv(y1)]]);
+        quad([[x1, y0, -hd], [x0, y0, -hd], [x0, y1, -hd], [x1, y1, -hd]], [0, 0, -1], [[1 - fu(x1), fv(y0)], [1 - fu(x0), fv(y0)], [1 - fu(x0), fv(y1)], [1 - fu(x1), fv(y1)]]);
+        const zu = (z) => (z + hd) / d;
+        if (!solid(i - 1, j)) quad([[x0, y0, -hd], [x0, y0, hd], [x0, y1, hd], [x0, y1, -hd]], [-1, 0, 0], [[zu(-hd), fv(y0)], [zu(hd), fv(y0)], [zu(hd), fv(y1)], [zu(-hd), fv(y1)]]);
+        if (!solid(i + 1, j)) quad([[x1, y0, hd], [x1, y0, -hd], [x1, y1, -hd], [x1, y1, hd]], [1, 0, 0], [[zu(hd), fv(y0)], [zu(-hd), fv(y0)], [zu(-hd), fv(y1)], [zu(hd), fv(y1)]]);
+        if (!solid(i, j - 1)) quad([[x0, y0, -hd], [x1, y0, -hd], [x1, y0, hd], [x0, y0, hd]], [0, -1, 0], [[fu(x0), zu(-hd)], [fu(x1), zu(-hd)], [fu(x1), zu(hd)], [fu(x0), zu(hd)]]);
+        if (!solid(i, j + 1)) quad([[x0, y1, hd], [x1, y1, hd], [x1, y1, -hd], [x0, y1, -hd]], [0, 1, 0], [[fu(x0), zu(hd)], [fu(x1), zu(hd)], [fu(x1), zu(-hd)], [fu(x0), zu(-hd)]]);
+      }
+    }
+    return {
+      type: "BufferGeometry",
+      parameters: { size: [w, h, d], subtract: holes.map((hole) => ({ min: [hole.x0, hole.y0], max: [hole.x1, hole.y1] })) },
+      positions: new Float32Array(positions),
+      normals: new Float32Array(normals),
+      uvs: new Float32Array(uvs),
+      indices: indexArray(indices),
+      groups: []
+    };
+  }
+  var Earcut = {
+    triangulate: function(data, holeIndices, dim = 2) {
+      const hasHoles = holeIndices && holeIndices.length;
+      const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+      let outerNode = linkedList(data, 0, outerLen, dim, true);
+      const triangles = [];
+      if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+      let minX, minY, maxX, maxY, x, y, invSize;
+      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+      if (data.length > 80 * dim) {
+        minX = maxX = data[0];
+        minY = maxY = data[1];
+        for (let i = dim; i < outerLen; i += dim) {
+          x = data[i];
+          y = data[i + 1];
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+        }
+        invSize = Math.max(maxX - minX, maxY - minY);
+        invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+      return triangles;
+    }
+  };
+  function linkedList(data, start, end, dim, clockwise) {
+    let i, last;
+    if (clockwise === signedArea(data, start, end, dim) > 0) {
+      for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+    } else {
+      for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start) return start;
+    if (!end) end = start;
+    let p = start, again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next) break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear) return;
+    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+    let stop = ear, prev, next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+    let p = ear.prevZ, n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev, b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+    const queue = [];
+    let i, len, start, end, list2;
+    for (i = 0, len = holeIndices.length; i < len; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+      list2 = linkedList(data, start, end, dim, false);
+      if (list2 === list2.next) list2.steiner = true;
+      queue.push(getLeftmost(list2));
+    }
+    queue.sort(compareX);
+    for (i = 0; i < queue.length; i++) {
+      outerNode = eliminateHole(queue[i], outerNode);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+      return outerNode;
+    }
+    const bridgeReverse = splitPolygon(bridge, hole);
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode, qx = -Infinity, m;
+    const hx = hole.x, hy = hole.y;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x <= hx && x > qx) {
+          qx = x;
+          m = p.x < p.next.x ? p : p.next;
+          if (x === hx) return m;
+        }
+      }
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m) return null;
+    const stop = m, mx = m.x, my = m.y;
+    let tanMin = Infinity, tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list2) {
+    let i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+    do {
+      p = list2;
+      list2 = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i = 0; i < inSize; i++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q) break;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail) tail.nextZ = e;
+          else list2 = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list2;
+  }
+  function zOrder(x, y, minX, minY, invSize) {
+    x = (x - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
+    x = (x | x << 8) & 16711935;
+    x = (x | x << 4) & 252645135;
+    x = (x | x << 2) & 858993459;
+    x = (x | x << 1) & 1431655765;
+    y = (y | y << 8) & 16711935;
+    y = (y | y << 4) & 252645135;
+    y = (y | y << 2) & 858993459;
+    y = (y | y << 1) & 1431655765;
+    return x | y << 1;
+  }
+  function getLeftmost(start) {
+    let p = start, leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+    (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+    (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+    equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4) return true;
+    if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+    if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+    if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+    if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num2) {
+    return num2 > 0 ? 1 : num2 < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a, inside = false;
+    const px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i, x, y, last) {
+    const p = new Node(i, x, y);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+  }
+  function Node(i, x, y) {
+    this.i = i;
+    this.x = x;
+    this.y = y;
+    this.prev = null;
+    this.next = null;
+    this.z = 0;
+    this.prevZ = null;
+    this.nextZ = null;
+    this.steiner = false;
+  }
+  function signedArea(data, start, end, dim) {
+    let sum = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+      j = i;
+    }
+    return sum;
+  }
+  var equals2 = (a, b) => a.x === b.x && a.y === b.y;
+  var linePoint = (v1, v2, t) => t === 1 ? { x: v2.x, y: v2.y } : { x: (v2.x - v1.x) * t + v1.x, y: (v2.y - v1.y) * t + v1.y };
+  function pathPoints(points) {
+    const out = [];
+    let last;
+    for (let i = 1; i < points.length; i++) {
+      const v1 = { x: points[i - 1][0], y: points[i - 1][1] };
+      const v2 = { x: points[i][0], y: points[i][1] };
+      for (let d = 0; d <= 1; d++) {
+        const point = linePoint(v1, v2, d / 1);
+        if (last && equals2(last, point)) continue;
+        out.push(point);
+        last = point;
+      }
+    }
+    return out;
+  }
+  function area2(contour) {
+    const n = contour.length;
+    let a = 0;
+    for (let p = n - 1, q = 0; q < n; p = q++) a += contour[p].x * contour[q].y - contour[q].x * contour[p].y;
+    return a * 0.5;
+  }
+  var isClockWise = (pts) => area2(pts) < 0;
+  function removeDupEndPts(points) {
+    const l = points.length;
+    if (l > 2 && equals2(points[l - 1], points[0])) points.pop();
+  }
+  function triangulateShape(contour, holes) {
+    const vertices = [];
+    const holeIndices = [];
+    const faces = [];
+    removeDupEndPts(contour);
+    for (const p of contour) vertices.push(p.x, p.y);
+    let holeIndex = contour.length;
+    holes.forEach(removeDupEndPts);
+    for (let i = 0; i < holes.length; i++) {
+      holeIndices.push(holeIndex);
+      holeIndex += holes[i].length;
+      for (const p of holes[i]) vertices.push(p.x, p.y);
+    }
+    const triangles = Earcut.triangulate(vertices, holeIndices);
+    for (let i = 0; i < triangles.length; i += 3) faces.push(triangles.slice(i, i + 3));
+    return faces;
+  }
+  function computeVertexNormals(positions, indices) {
+    const normals = new Float32Array(positions.length);
+    const get = (array, i) => [array[i * 3], array[i * 3 + 1], array[i * 3 + 2]];
+    const face = (vA, vB, vC) => {
+      const pA = get(positions, vA);
+      const pB = get(positions, vB);
+      const pC = get(positions, vC);
+      const cb = [pC[0] - pB[0], pC[1] - pB[1], pC[2] - pB[2]];
+      const ab = [pA[0] - pB[0], pA[1] - pB[1], pA[2] - pB[2]];
+      return [cb[1] * ab[2] - cb[2] * ab[1], cb[2] * ab[0] - cb[0] * ab[2], cb[0] * ab[1] - cb[1] * ab[0]];
+    };
+    const set = (i, x, y, z) => {
+      normals[i * 3] = x;
+      normals[i * 3 + 1] = y;
+      normals[i * 3 + 2] = z;
+    };
+    if (indices) {
+      for (let i = 0; i < indices.length; i += 3) {
+        const vA = indices[i];
+        const vB = indices[i + 1];
+        const vC = indices[i + 2];
+        const cb = face(vA, vB, vC);
+        for (const v of [vA, vB, vC]) {
+          const n = get(normals, v);
+          set(v, n[0] + cb[0], n[1] + cb[1], n[2] + cb[2]);
+        }
+      }
+    } else {
+      for (let i = 0; i < positions.length / 3; i += 3) {
+        const cb = face(i, i + 1, i + 2);
+        set(i, cb[0], cb[1], cb[2]);
+        set(i + 1, cb[0], cb[1], cb[2]);
+        set(i + 2, cb[0], cb[1], cb[2]);
+      }
+    }
+    for (let i = 0; i < normals.length / 3; i++) {
+      const [x, y, z] = get(normals, i);
+      const s = 1 / (Math.sqrt(x * x + y * y + z * z) || 1);
+      set(i, x * s, y * s, z * s);
+    }
+    return normals;
+  }
+  function extrude(outline, depth = 1, steps = 1, bevel = void 0) {
+    const parameters = { shape: outline, depth, steps, bevel: bevel ?? {} };
+    const verticesArray = [];
+    const uvArray = [];
+    const groups = [];
+    const placeholder = [];
+    const bevelEnabled = bevel !== false;
+    const spec = bevel === false || bevel === void 0 ? {} : bevel;
+    let bevelThickness = spec.thickness !== void 0 ? spec.thickness : 0.2;
+    let bevelSize = spec.size !== void 0 ? spec.size : bevelThickness - 0.1;
+    let bevelOffset = spec.offset !== void 0 ? spec.offset : 0;
+    let bevelSegments = spec.segments !== void 0 ? spec.segments : 3;
+    if (!bevelEnabled) {
+      bevelSegments = 0;
+      bevelThickness = 0;
+      bevelSize = 0;
+      bevelOffset = 0;
+    }
+    let vertices = pathPoints(outline.outer);
+    const holes = (outline.holes ?? []).map(pathPoints);
+    const reverse = !isClockWise(vertices);
+    if (reverse) {
+      vertices = vertices.reverse();
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        if (isClockWise(ahole)) holes[h] = ahole.reverse();
+      }
+    }
+    const faces = triangulateShape(vertices, holes);
+    const contour = vertices;
+    for (const ahole of holes) vertices = vertices.concat(ahole);
+    const scalePt2 = (pt, vec, size) => ({ x: pt.x + vec.x * size, y: pt.y + vec.y * size });
+    const vlen = vertices.length;
+    const flen = faces.length;
+    const getBevelVec = (inPt, inPrev, inNext) => {
+      let vTransX;
+      let vTransY;
+      let shrinkBy;
+      const vPrevX = inPt.x - inPrev.x;
+      const vPrevY = inPt.y - inPrev.y;
+      const vNextX = inNext.x - inPt.x;
+      const vNextY = inNext.y - inPt.y;
+      const vPrevLensq = vPrevX * vPrevX + vPrevY * vPrevY;
+      const collinear0 = vPrevX * vNextY - vPrevY * vNextX;
+      if (Math.abs(collinear0) > Number.EPSILON) {
+        const vPrevLen = Math.sqrt(vPrevLensq);
+        const vNextLen = Math.sqrt(vNextX * vNextX + vNextY * vNextY);
+        const ptPrevShiftX = inPrev.x - vPrevY / vPrevLen;
+        const ptPrevShiftY = inPrev.y + vPrevX / vPrevLen;
+        const ptNextShiftX = inNext.x - vNextY / vNextLen;
+        const ptNextShiftY = inNext.y + vNextX / vNextLen;
+        const sf = ((ptNextShiftX - ptPrevShiftX) * vNextY - (ptNextShiftY - ptPrevShiftY) * vNextX) / (vPrevX * vNextY - vPrevY * vNextX);
+        vTransX = ptPrevShiftX + vPrevX * sf - inPt.x;
+        vTransY = ptPrevShiftY + vPrevY * sf - inPt.y;
+        const vTransLensq = vTransX * vTransX + vTransY * vTransY;
+        if (vTransLensq <= 2) return { x: vTransX, y: vTransY };
+        shrinkBy = Math.sqrt(vTransLensq / 2);
+      } else {
+        let directionEq = false;
+        if (vPrevX > Number.EPSILON) {
+          if (vNextX > Number.EPSILON) directionEq = true;
+        } else if (vPrevX < -Number.EPSILON) {
+          if (vNextX < -Number.EPSILON) directionEq = true;
+        } else if (Math.sign(vPrevY) === Math.sign(vNextY)) {
+          directionEq = true;
+        }
+        if (directionEq) {
+          vTransX = -vPrevY;
+          vTransY = vPrevX;
+          shrinkBy = Math.sqrt(vPrevLensq);
+        } else {
+          vTransX = vPrevX;
+          vTransY = vPrevY;
+          shrinkBy = Math.sqrt(vPrevLensq / 2);
+        }
+      }
+      return { x: vTransX / shrinkBy, y: vTransY / shrinkBy };
+    };
+    const movements = (ring2) => {
+      const out = [];
+      for (let i = 0, il = ring2.length, j = il - 1, k = i + 1; i < il; i++, j++, k++) {
+        if (j === il) j = 0;
+        if (k === il) k = 0;
+        out[i] = getBevelVec(ring2[i], ring2[j], ring2[k]);
+      }
+      return out;
+    };
+    const contourMovements = movements(contour);
+    const holesMovements = [];
+    let verticesMovements = contourMovements.concat();
+    for (const ahole of holes) {
+      const oneHoleMovements = movements(ahole);
+      holesMovements.push(oneHoleMovements);
+      verticesMovements = verticesMovements.concat(oneHoleMovements);
+    }
+    const v = (x, y, z) => {
+      placeholder.push(x);
+      placeholder.push(y);
+      placeholder.push(z);
+    };
+    const bevelLayer = (b, zOf) => {
+      const t = b / bevelSegments;
+      const z = bevelThickness * Math.cos(t * Math.PI / 2);
+      const bs2 = bevelSize * Math.sin(t * Math.PI / 2) + bevelOffset;
+      for (let i = 0; i < contour.length; i++) {
+        const vert = scalePt2(contour[i], contourMovements[i], bs2);
+        v(vert.x, vert.y, zOf(z));
+      }
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        const oneHoleMovements = holesMovements[h];
+        for (let i = 0; i < ahole.length; i++) {
+          const vert = scalePt2(ahole[i], oneHoleMovements[i], bs2);
+          v(vert.x, vert.y, zOf(z));
+        }
+      }
+    };
+    for (let b = 0; b < bevelSegments; b++) bevelLayer(b, (z) => -z);
+    const bs = bevelSize + bevelOffset;
+    for (let i = 0; i < vlen; i++) {
+      const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+      v(vert.x, vert.y, 0);
+    }
+    for (let s = 1; s <= steps; s++) {
+      for (let i = 0; i < vlen; i++) {
+        const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+        v(vert.x, vert.y, depth / steps * s);
+      }
+    }
+    for (let b = bevelSegments - 1; b >= 0; b--) bevelLayer(b, (z) => depth + z);
+    const addVertex = (index) => {
+      verticesArray.push(placeholder[index * 3 + 0]);
+      verticesArray.push(placeholder[index * 3 + 1]);
+      verticesArray.push(placeholder[index * 3 + 2]);
+    };
+    const addUV = (x, y) => {
+      uvArray.push(x);
+      uvArray.push(y);
+    };
+    const at = (index, axis) => verticesArray[index * 3 + axis];
+    const f3 = (a, b, c) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(c);
+      const nextIndex = verticesArray.length / 3;
+      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at(index, 0), at(index, 1));
+    };
+    const f4 = (a, b, c, d) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(d);
+      addVertex(b);
+      addVertex(c);
+      addVertex(d);
+      const nextIndex = verticesArray.length / 3;
+      const iA = nextIndex - 6;
+      const iB = nextIndex - 3;
+      const iC = nextIndex - 2;
+      const iD = nextIndex - 1;
+      const byX = Math.abs(at(iA, 1) - at(iB, 1)) < Math.abs(at(iA, 0) - at(iB, 0));
+      const uv = (index) => [byX ? at(index, 0) : at(index, 1), 1 - at(index, 2)];
+      const uvs = [uv(iA), uv(iB), uv(iC), uv(iD)];
+      for (const k of [0, 1, 3, 1, 2, 3]) addUV(...uvs[k]);
+    };
+    let start = verticesArray.length / 3;
+    if (bevelEnabled) {
+      let offset = 0;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2] + offset, face[1] + offset, face[0] + offset);
+      }
+      const layer = steps + bevelSegments * 2;
+      offset = vlen * layer;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + offset, face[1] + offset, face[2] + offset);
+      }
+    } else {
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2], face[1], face[0]);
+      }
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + vlen * steps, face[1] + vlen * steps, face[2] + vlen * steps);
+      }
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 0 });
+    start = verticesArray.length / 3;
+    const sidewalls = (ring2, layeroffset2) => {
+      let i = ring2.length;
+      while (--i >= 0) {
+        const j = i;
+        let k = i - 1;
+        if (k < 0) k = ring2.length - 1;
+        for (let s = 0, sl = steps + bevelSegments * 2; s < sl; s++) {
+          const slen1 = vlen * s;
+          const slen2 = vlen * (s + 1);
+          f4(layeroffset2 + j + slen1, layeroffset2 + k + slen1, layeroffset2 + k + slen2, layeroffset2 + j + slen2);
+        }
+      }
+    };
+    let layeroffset = 0;
+    sidewalls(contour, layeroffset);
+    layeroffset += contour.length;
+    for (const ahole of holes) {
+      sidewalls(ahole, layeroffset);
+      layeroffset += ahole.length;
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 1 });
+    const positions = new Float32Array(verticesArray);
+    return { type: "ExtrudeGeometry", parameters, positions, normals: computeVertexNormals(positions), uvs: new Float32Array(uvArray), groups };
+  }
+  var PARAMETER_KEYS = {
+    box: ["size", "segments"],
+    cylinder: ["radiusTop", "radiusBottom", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    cone: ["radius", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    sphere: ["radius", "widthSegments", "heightSegments", "phiStart", "phiLength", "thetaStart", "thetaLength"],
+    plane: ["width", "height", "widthSegments", "heightSegments"],
+    circle: ["radius", "segments", "thetaStart", "thetaLength"],
+    ring: ["innerRadius", "outerRadius", "thetaSegments", "phiSegments", "thetaStart", "thetaLength"],
+    lathe: ["points", "segments", "phiStart", "phiLength"],
+    torus: ["radius", "tube", "radialSegments", "tubularSegments", "arc"],
+    extrude: ["shape", "depth", "steps", "bevel"],
+    difference: ["size", "subtract"],
+    mesh: ["positions", "normals", "uvs", "indices"]
+  };
+  var SEGMENT_KEYS = {
+    cylinder: ["radialSegments"],
+    cone: ["radialSegments"],
+    sphere: ["widthSegments", "heightSegments"],
+    circle: ["segments"],
+    ring: ["thetaSegments"],
+    lathe: ["segments"],
+    torus: ["radialSegments", "tubularSegments"]
+  };
+  var SEGMENT_DEFAULTS = { radialSegments: 32, widthSegments: 32, heightSegments: 16, segments: 12, thetaSegments: 32, tubularSegments: 48 };
+  var segmentDefault = (kind, key) => kind === "circle" && key === "segments" ? 32 : kind === "torus" && key === "radialSegments" ? 12 : SEGMENT_DEFAULTS[key];
+  function primitiveParameters(node, options = {}) {
+    const out = {};
+    const source = node;
+    for (const key of PARAMETER_KEYS[node.kind]) if (source[key] !== void 0) out[key] = source[key];
+    const detail = options.detail ?? 1;
+    if (detail !== 1) {
+      const floor = options.minSegments ?? 3;
+      for (const key of SEGMENT_KEYS[node.kind] ?? []) {
+        const given = out[key] ?? segmentDefault(node.kind, key);
+        out[key] = Math.max(floor, Math.round(given * detail));
+      }
+    }
+    return out;
+  }
+  function mesh(p) {
+    const positions = new Float32Array(p.positions);
+    const indices = p.indices ? indexArray(p.indices) : void 0;
+    return {
+      type: "BufferGeometry",
+      parameters: {},
+      positions,
+      normals: p.normals ? new Float32Array(p.normals) : computeVertexNormals(positions, indices),
+      uvs: p.uvs ? new Float32Array(p.uvs) : new Float32Array(positions.length / 3 * 2),
+      ...indices ? { indices } : {},
+      groups: []
+    };
+  }
+  function make(kind, p) {
+    switch (kind) {
+      case "box": {
+        const size = p.size ?? [1, 1, 1];
+        const segments = p.segments ?? [1, 1, 1];
+        return box(size[0], size[1], size[2], segments[0], segments[1], segments[2]);
+      }
+      case "cylinder":
+        return cylinder(p.radiusTop, p.radiusBottom, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "cone":
+        return cone(p.radius, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "sphere":
+        return sphere(p.radius, p.widthSegments, p.heightSegments, p.phiStart, p.phiLength, p.thetaStart, p.thetaLength);
+      case "plane":
+        return plane(p.width, p.height, p.widthSegments, p.heightSegments);
+      case "circle":
+        return circle(p.radius, p.segments, p.thetaStart, p.thetaLength);
+      case "ring":
+        return ring(p.innerRadius, p.outerRadius, p.thetaSegments, p.phiSegments, p.thetaStart, p.thetaLength);
+      case "lathe":
+        return lathe(p.points, p.segments, p.phiStart, p.phiLength);
+      case "torus":
+        return torus(p.radius, p.tube, p.radialSegments, p.tubularSegments, p.arc);
+      case "extrude":
+        return extrude(p.shape, p.depth, p.steps, p.bevel);
+      case "difference":
+        return difference(p.size, p.subtract ?? []);
+      case "mesh":
+        return mesh(p);
+      default:
+        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+    }
+  }
+  var templates = /* @__PURE__ */ new Map();
+  var templateLimit = 4096;
+  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);
+    const key = `${node.kind}:${canonicalJson(parameters)}`;
+    const cached = templates.get(key);
+    if (cached) {
+      stats.hits++;
+      templates.delete(key);
+      templates.set(key, cached);
+      return cached;
+    }
+    stats.misses++;
+    const built = make(node.kind, parameters);
+    templates.set(key, built);
+    if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
+    return built;
+  }
+  var num = (v) => typeof v === "number" && Number.isFinite(v) ? null : "expected a finite number";
+  var bool = (v) => typeof v === "boolean" ? null : "expected a boolean";
+  var str = (v) => typeof v === "string" ? null : "expected a string";
+  var int = (min) => (v) => typeof v === "number" && Number.isInteger(v) && v >= min ? null : `expected an integer >= ${min}`;
+  var range = (lo, hi, loOpen = false) => (v) => typeof v === "number" && (loOpen ? v > lo : v >= lo) && v <= hi ? null : `expected a number in ${loOpen ? "(" : "["}${lo}, ${hi}]`;
+  var tuple = (n, item = num) => (v) => {
+    if (!Array.isArray(v) || v.length !== n) return `expected an array of ${n}`;
+    for (const x of v) if (item(x)) return `expected an array of ${n} numbers`;
+    return null;
+  };
+  var list = (item, min = 0) => (v) => {
+    if (!Array.isArray(v)) return "expected an array";
+    if (v.length < min) return `expected at least ${min} items`;
+    for (let i = 0; i < v.length; i++) {
+      const e = item(v[i]);
+      if (e) return `[${i}]: ${e}`;
+    }
+    return null;
+  };
+  var color = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 16777215 || typeof v === "string" && /^#[0-9a-fA-F]{6}$/.test(v) ? null : 'expected 0xRRGGBB or "#rrggbb"';
+  var oneOf = (values) => (v) => values.includes(v) ? null : `expected one of ${values.map((x) => JSON.stringify(x)).join(", ")}`;
+  var object = (fields, required = []) => (v) => {
+    if (!v || typeof v !== "object" || Array.isArray(v)) return "expected an object";
+    const record = v;
+    for (const key of required) if (record[key] === void 0) return `${key}: required`;
+    for (const key of Object.keys(record)) {
+      if (record[key] === void 0) continue;
+      const check = fields[key];
+      if (!check) return `${key}: unknown field`;
+      const e = check(record[key]);
+      if (e) return `${key}: ${e}`;
+    }
+    return null;
+  };
+  var ORDERS = ["XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"];
+  var TRANSFORM = {
+    position: tuple(3),
+    rotation: tuple(3),
+    rotationOrder: oneOf(ORDERS),
+    scale: (v) => typeof v === "number" ? num(v) : tuple(3)(v),
+    heading: num,
+    matrix: tuple(16)
+  };
+  var UV = object({ u0: num, v0: num, u1: num, v1: num }, ["u0", "v0", "u1", "v1"]);
+  var INSTANCE = object({ ...TRANSFORM, color });
+  var COMMON = {
+    ...TRANSFORM,
+    kind: str,
+    name: str,
+    part: str,
+    material: str,
+    color,
+    uv: UV,
+    instances: list(INSTANCE),
+    minDetail: range(0, 1, true),
+    tags: list(str)
+  };
+  var vec2 = tuple(2);
+  var BEVEL = (v) => v === false ? null : object({ thickness: num, size: num, offset: num, segments: int(1) })(v);
+  var KINDS = {
+    group: { fields: {} },
+    box: { fields: { size: tuple(3), segments: tuple(3, int(1)) } },
+    cylinder: { fields: { radiusTop: num, radiusBottom: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    cone: { fields: { radius: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    sphere: { fields: { radius: num, widthSegments: int(3), heightSegments: int(2), phiStart: num, phiLength: num, thetaStart: num, thetaLength: num } },
+    plane: { fields: { width: num, height: num, widthSegments: int(1), heightSegments: int(1) } },
+    circle: { fields: { radius: num, segments: int(3), thetaStart: num, thetaLength: num } },
+    ring: { fields: { innerRadius: num, outerRadius: num, thetaSegments: int(3), phiSegments: int(1), thetaStart: num, thetaLength: num } },
+    lathe: { fields: { points: list(vec2, 2), segments: int(1), phiStart: num, phiLength: num }, required: ["points"] },
+    torus: { fields: { radius: num, tube: num, radialSegments: int(1), tubularSegments: int(1), arc: num } },
+    extrude: {
+      fields: { shape: object({ outer: list(vec2, 3), holes: list(list(vec2, 3)) }, ["outer"]), depth: num, steps: int(1), bevel: BEVEL },
+      required: ["shape"]
+    },
+    difference: { fields: { size: tuple(3), subtract: list(object({ min: vec2, max: vec2 }, ["min", "max"])) }, required: ["size", "subtract"] },
+    mesh: {
+      fields: {
+        positions: (v) => list(num)(v) ?? (v.length % 3 === 0 ? null : "expected a multiple of 3 numbers"),
+        normals: list(num),
+        uvs: list(num),
+        indices: list(int(0))
+      },
+      required: ["positions"]
+    },
+    point: { fields: { data: () => null } },
+    custom: { fields: { generator: str, params: () => null }, required: ["generator"] }
+  };
+
+  // ../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"]);
+  var isPrimitive = (value) => typeof value.type === "string";
+  function threeParameters(THREE, p) {
+    if (p.type === "LatheGeometry") {
+      const points = p.parameters.points.map(({ x, y }) => new THREE.Vector2(x, y));
+      return { ...p.parameters, points };
+    }
+    return { ...p.parameters };
+  }
+  function toGeometry(THREE, source, options = {}) {
+    const copy = options.copy !== false;
+    const primitive = isPrimitive(source) ? source : null;
+    const ThreeClass = primitive && primitive.type !== "BufferGeometry" ? THREE[primitive.type] : void 0;
+    const geometry = ThreeClass ? Reflect.construct(THREE.BufferGeometry, [], ThreeClass) : new THREE.BufferGeometry();
+    if (primitive && ThreeClass) {
+      Object.assign(geometry, { type: primitive.type, parameters: threeParameters(THREE, primitive) });
+    }
+    const attribute = (array, size) => copy ? new THREE.Float32BufferAttribute(array, size) : new THREE.BufferAttribute(array, size);
+    const index = source.indices;
+    const setIndex = () => {
+      if (!index) return;
+      geometry.setIndex(copy ? index instanceof Uint32Array ? new THREE.Uint32BufferAttribute(index, 1) : new THREE.Uint16BufferAttribute(index, 1) : new THREE.BufferAttribute(index, 1));
+    };
+    const type = primitive?.type ?? "BufferGeometry";
+    if (INDEX_FIRST.has(type)) setIndex();
+    geometry.setAttribute("position", attribute(source.positions, 3));
+    if (UV_BEFORE_NORMAL.has(type)) {
+      geometry.setAttribute("uv", attribute(source.uvs, 2));
+      geometry.setAttribute("normal", attribute(source.normals, 3));
+    } else {
+      geometry.setAttribute("normal", attribute(source.normals, 3));
+      geometry.setAttribute("uv", attribute(source.uvs, 2));
+    }
+    if (!primitive && source.colors) geometry.setAttribute("color", attribute(source.colors, 3));
+    if (!INDEX_FIRST.has(type)) setIndex();
+    if (primitive) for (const group of primitive.groups) geometry.addGroup(group.start, group.count, group.materialIndex);
+    return geometry;
+  }
+  var SHAPE_GEOMETRY_TYPES = ["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry", "ExtrudeGeometry"];
+  function linePoints(path) {
+    if (path.autoClose || path.curves.length === 0) return null;
+    const points = [];
+    for (const [index, curve] of path.curves.entries()) {
+      if (!curve.isLineCurve || !curve.v1 || !curve.v2) return null;
+      if (index === 0) points.push([curve.v1.x, curve.v1.y]);
+      else {
+        const last = points[points.length - 1];
+        if (last[0] !== curve.v1.x || last[1] !== curve.v1.y) return null;
+      }
+      points.push([curve.v2.x, curve.v2.y]);
+    }
+    return points;
+  }
+  function extrudeOf(shapes, options = {}) {
+    if (Array.isArray(shapes) || !shapes || options.extrudePath !== void 0 || options.UVGenerator !== void 0) return null;
+    const shape = shapes;
+    const outer = linePoints(shape);
+    if (!outer) return null;
+    const holes = [];
+    for (const hole of shape.holes ?? []) {
+      const points = linePoints(hole);
+      if (!points) return null;
+      holes.push(points);
+    }
+    const outline = holes.length ? { outer, holes } : { outer };
+    const bevel = options.bevelEnabled === false ? false : {
+      ...options.bevelThickness !== void 0 ? { thickness: options.bevelThickness } : {},
+      ...options.bevelSize !== void 0 ? { size: options.bevelSize } : {},
+      ...options.bevelOffset !== void 0 ? { offset: options.bevelOffset } : {},
+      ...options.bevelSegments !== void 0 ? { segments: options.bevelSegments } : {}
+    };
+    return extrude(outline, options.depth, options.steps, bevel);
+  }
+  var namespaces = /* @__PURE__ */ new WeakMap();
+  var shims = /* @__PURE__ */ new WeakSet();
+  function shapeGeometries(THREE, options = {}) {
+    if (shims.has(THREE)) return THREE;
+    const cache = options.cache !== false;
+    const key = cache ? "cache" : "nocache";
+    let byKey = namespaces.get(THREE);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      namespaces.set(THREE, byKey);
+    }
+    const existing = byKey.get(key);
+    if (existing) return existing;
+    const made = (p) => toGeometry(THREE, p);
+    const viaCache = (node, direct) => cache ? buildPrimitive(node) : direct();
+    const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+    const constructors = {
+      BoxGeometry: (width, height, depth, ws = 1, hs = 1, ds = 1) => made(viaCache({ kind: "box", size: [width ?? 1, height ?? 1, depth ?? 1], segments: [ws, hs, ds] }, () => box(width, height, depth, ws, hs, ds))),
+      CylinderGeometry: (radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cylinder", ...defined({ radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cylinder(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      ConeGeometry: (radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cone", ...defined({ radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cone(radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      SphereGeometry: (radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) => made(viaCache({ kind: "sphere", ...defined({ radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength }) }, () => sphere(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength))),
+      PlaneGeometry: (width, height, widthSegments, heightSegments) => made(viaCache({ kind: "plane", ...defined({ width, height, widthSegments, heightSegments }) }, () => plane(width, height, widthSegments, heightSegments))),
+      CircleGeometry: (radius, segments, thetaStart, thetaLength) => made(viaCache({ kind: "circle", ...defined({ radius, segments, thetaStart, thetaLength }) }, () => circle(radius, segments, thetaStart, thetaLength))),
+      RingGeometry: (innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength) => made(viaCache({ kind: "ring", ...defined({ innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength }) }, () => ring(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength))),
+      LatheGeometry: (points, segments, phiStart, phiLength) => {
+        if (!points) return new THREE.LatheGeometry(void 0, segments, phiStart, phiLength);
+        const profile = points.map((p) => [p.x, p.y]);
+        return made(viaCache({ kind: "lathe", points: profile, ...defined({ segments, phiStart, phiLength }) }, () => lathe(profile, segments, phiStart, phiLength)));
+      },
+      TorusGeometry: (radius, tube, radialSegments, tubularSegments, arc) => made(viaCache({ kind: "torus", ...defined({ radius, tube, radialSegments, tubularSegments, arc }) }, () => torus(radius, tube, radialSegments, tubularSegments, arc))),
+      ExtrudeGeometry: (shapes, extrudeOptions) => {
+        const buffers = shapes === void 0 ? null : extrudeOf(shapes, extrudeOptions);
+        if (!buffers) return new THREE.ExtrudeGeometry(shapes, extrudeOptions);
+        const geometry = toGeometry(THREE, buffers);
+        geometry.parameters = { shapes, options: extrudeOptions ?? {} };
+        return geometry;
+      }
+    };
+    const namespace = { ...THREE };
+    for (const type of SHAPE_GEOMETRY_TYPES) {
+      const make2 = constructors[type];
+      const Constructor = function(...args) {
+        return make2(...args);
+      };
+      Constructor.prototype = THREE[type].prototype;
+      Object.defineProperty(Constructor, "name", { value: type });
+      namespace[type] = Constructor;
+    }
+    const result = namespace;
+    byKey.set(key, result);
+    shims.add(result);
+    return result;
+  }
+
+  // ../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 = (fill2, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
+    if (curve.length === 0) return 1;
+    const f = Math.min(1, Math.max(0, fill2));
+    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 UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result[key];
+      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result;
+  };
+  var mergeById = (shipped, extra) => {
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+    return entries;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) entries.delete(id);
+  };
+
   // ../game-vehicles/dist/index.js
   var __defProp2 = Object.defineProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -28580,9 +30169,9 @@ var GameVehiclesThree = (() => {
       return envTex;
     }
     kit.studioEnvironment = studioEnvironment;
-    function makeMaterial(color, o) {
+    function makeMaterial(color2, o) {
       o = o || {};
-      const c = color instanceof THREE.Color ? color : new THREE.Color(color);
+      const c = color2 instanceof THREE.Color ? color2 : new THREE.Color(color2);
       const key = "s" + c.getHexString() + JSON.stringify(o, function(k, v) {
         return v && v.isColor ? "#" + v.getHexString() : v && v.isTexture ? v.uuid : v;
       });
@@ -28598,8 +30187,8 @@ var GameVehiclesThree = (() => {
       }
       return cache[key];
     }
-    function makeFlatMaterial(color, o) {
-      return makeMaterial(color, Object.assign({ flatShading: true, roughness: 0.92 }, o || {}));
+    function makeFlatMaterial(color2, o) {
+      return makeMaterial(color2, Object.assign({ flatShading: true, roughness: 0.92 }, o || {}));
     }
     const DOUBLE_SIDE = THREE.DoubleSide;
     function toColor(hex) {
@@ -28816,46 +30405,79 @@ var GameVehiclesThree = (() => {
       }
       const p = geo.attributes.position;
       const n = p.count;
-      const FN = [];
-      const map = {};
-      const A = new V3();
-      const B = new V3();
-      const C = new V3();
-      const e1 = new V3();
-      const e2 = new V3();
+      const faces = n / 3;
+      const FN = new Float64Array(faces * 3);
+      const map = /* @__PURE__ */ new Map();
+      const RANGE = 65536;
       function key(i) {
-        return Math.round(p.getX(i) * 2e3) + "," + Math.round(p.getY(i) * 2e3) + "," + Math.round(p.getZ(i) * 2e3);
+        const x = Math.round(p.getX(i) * 2e3);
+        const y = Math.round(p.getY(i) * 2e3);
+        const z = Math.round(p.getZ(i) * 2e3);
+        if (Math.abs(x) < RANGE && Math.abs(y) < RANGE && Math.abs(z) < RANGE) return ((x + RANGE) * 131072 + (y + RANGE)) * 131072 + (z + RANGE);
+        return x + "," + y + "," + z;
       }
       const keys = new Array(n);
-      for (let f = 0; f < n / 3; f++) {
-        A.fromBufferAttribute(p, 3 * f);
-        B.fromBufferAttribute(p, 3 * f + 1);
-        C.fromBufferAttribute(p, 3 * f + 2);
-        const nn = new V3().crossVectors(e1.subVectors(C, B), e2.subVectors(A, B));
-        if (nn.lengthSq() > 1e-20) nn.normalize();
-        FN.push(nn);
+      for (let f = 0; f < faces; f++) {
+        const ax = p.getX(3 * f);
+        const ay = p.getY(3 * f);
+        const az = p.getZ(3 * f);
+        const bx = p.getX(3 * f + 1);
+        const by = p.getY(3 * f + 1);
+        const bz = p.getZ(3 * f + 1);
+        const cx = p.getX(3 * f + 2);
+        const cy = p.getY(3 * f + 2);
+        const cz = p.getZ(3 * f + 2);
+        const e1x = cx - bx;
+        const e1y = cy - by;
+        const e1z = cz - bz;
+        const e2x = ax - bx;
+        const e2y = ay - by;
+        const e2z = az - bz;
+        let nx = e1y * e2z - e1z * e2y;
+        let ny = e1z * e2x - e1x * e2z;
+        let nz = e1x * e2y - e1y * e2x;
+        if (nx * nx + ny * ny + nz * nz > 1e-20) {
+          const inv = 1 / (Math.sqrt(nx * nx + ny * ny + nz * nz) || 1);
+          nx *= inv;
+          ny *= inv;
+          nz *= inv;
+        }
+        FN[3 * f] = nx;
+        FN[3 * f + 1] = ny;
+        FN[3 * f + 2] = nz;
         for (let k = 0; k < 3; k++) {
           const kk = key(3 * f + k);
           keys[3 * f + k] = kk;
-          (map[kk] || (map[kk] = [])).push(f);
+          const list2 = map.get(kk);
+          if (list2) list2.push(f);
+          else map.set(kk, [f]);
         }
       }
       const cs = Math.cos(deg * PI / 180);
       const out = new Float32Array(n * 3);
-      const s = new V3();
       for (let i = 0; i < n; i++) {
-        const fi = i / 3 | 0;
-        const list = map[keys[i]];
-        s.set(0, 0, 0);
-        for (let j = 0; j < list.length; j++) {
-          const g = FN[list[j]];
-          if (g.dot(FN[fi]) >= cs) s.add(g);
-        }
-        if (s.lengthSq() < 1e-20) s.copy(FN[fi]);
-        s.normalize();
-        out[3 * i] = s.x;
-        out[3 * i + 1] = s.y;
-        out[3 * i + 2] = s.z;
+        const fi = (i / 3 | 0) * 3;
+        const list2 = map.get(keys[i]);
+        let sx = 0;
+        let sy = 0;
+        let sz = 0;
+        for (let j = 0; j < list2.length; j++) {
+          const g = list2[j] * 3;
+          if (FN[g] * FN[fi] + FN[g + 1] * FN[fi + 1] + FN[g + 2] * FN[fi + 2] >= cs) {
+            sx += FN[g];
+            sy += FN[g + 1];
+            sz += FN[g + 2];
+          }
+        }
+        if (sx * sx + sy * sy + sz * sz < 1e-20) {
+          sx = FN[fi];
+          sy = FN[fi + 1];
+          sz = FN[fi + 2];
+        }
+        const inv = 1 / (Math.sqrt(sx * sx + sy * sy + sz * sz) || 1);
+        out[3 * i] = sx * inv;
+        out[3 * i + 1] = sy * inv;
+        out[3 * i + 2] = sz * inv;
       }
       geo.setAttribute("normal", new THREE.BufferAttribute(out, 3));
       geo.userData.crease = true;
@@ -28914,7 +30536,7 @@ var GameVehiclesThree = (() => {
       const pos = [];
       const col = [];
       const idx = [];
-      const ring = seg + 1;
+      const ring2 = seg + 1;
       st.forEach(function(s) {
         for (let j = 0; j <= seg; j++) {
           const a = j / seg * PI * 2;
@@ -28932,8 +30554,8 @@ var GameVehiclesThree = (() => {
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const a0 = i * ring + k;
-          const b0 = a0 + ring;
+          const a0 = i * ring2 + k;
+          const b0 = a0 + ring2;
           idx.push(a0, a0 + 1, b0, a0 + 1, b0 + 1, b0);
         }
       ;
@@ -28947,7 +30569,7 @@ var GameVehiclesThree = (() => {
           col.push(cc.r, cc.g, cc.b);
         }
         for (let k = 0; k < seg; k++) {
-          const a = si * ring + k;
+          const a = si * ring2 + k;
           if (e === 0) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
         }
@@ -29085,13 +30707,13 @@ var GameVehiclesThree = (() => {
         });
         tris = next;
       });
-      function build(list) {
+      function build(list2) {
         const g = new THREE.BufferGeometry();
         let off = 0;
         names.forEach(function(nm, a) {
-          const arr = new Float32Array(list.length * 3 * sizes[a]);
+          const arr = new Float32Array(list2.length * 3 * sizes[a]);
           let w = 0;
-          list.forEach(function(t) {
+          list2.forEach(function(t) {
             for (let k = 0; k < 3; k++) for (let q = 0; q < sizes[a]; q++) arr[w++] = t[k][off + q];
           });
           g.setAttribute(nm, new THREE.BufferAttribute(arr, sizes[a]));
@@ -29106,10 +30728,10 @@ var GameVehiclesThree = (() => {
       });
       return out;
     }
-    function mergeGeometries(list) {
+    function mergeGeometries(list2) {
       const pos = [];
       const nor = [];
-      list.forEach(function(g2) {
+      list2.forEach(function(g2) {
         const n = g2.index ? g2.toNonIndexed() : g2;
         if (!n.attributes.normal) n.computeVertexNormals();
         const pa = n.attributes.position.array;
@@ -29168,13 +30790,13 @@ var GameVehiclesThree = (() => {
     };
     kit.holeSide = function(poly, o) {
       o = o || {};
-      let area = 0;
+      let area3 = 0;
       for (let i = 0; i < poly.length; i++) {
         const a = poly[i];
         const b = poly[(i + 1) % poly.length];
-        area += a[0] * b[1] - b[0] * a[1];
+        area3 += a[0] * b[1] - b[0] * a[1];
       }
-      const sg = area > 0 ? 1 : -1;
+      const sg = area3 > 0 ? 1 : -1;
       const E2 = poly.map(function(a, i) {
         const b = poly[(i + 1) % poly.length];
         const dx = b[0] - a[0];
@@ -29475,11 +31097,11 @@ var GameVehiclesThree = (() => {
         return d.clone().applyQuaternion(this.vehicle.quaternion);
       }
       /** Declares or refines a damage zone: `c.zone(id, label, box, parts, options)`. Pass `label === false` to remove an auto-derived zone. */
-      zone(id, label, box, parts, o) {
+      zone(id, label, box2, parts, o) {
         const d = Object.assign({ id }, o || {});
         if (label === false) d.remove = true;
         else if (label) d.name = label;
-        if (box) d.box = I.normalizeBox(box);
+        if (box2) d.box = I.normalizeBox(box2);
         if (parts) d.objs = Array.isArray(parts) ? parts.slice() : [parts];
         this.zoneDefs.push(d);
         return d;
@@ -29628,7 +31250,7 @@ var GameVehiclesThree = (() => {
       const seg = o.seg || 24;
       const pos = [];
       const idx = [];
-      const ring = seg + 1;
+      const ring2 = seg + 1;
       const axisY = o.axis === "y";
       st.forEach(function(s) {
         const a0 = s[1];
@@ -29650,8 +31272,8 @@ var GameVehiclesThree = (() => {
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const A = i * ring + k;
-          const B = A + ring;
+          const A = i * ring2 + k;
+          const B = A + ring2;
           if (axisY) idx.push(A, B, A + 1, A + 1, B, B + 1);
           else idx.push(A, A + 1, B, A + 1, B + 1, B);
         }
@@ -29664,7 +31286,7 @@ var GameVehiclesThree = (() => {
         if (axisY) pos.push(cc, s[0], s[5] || 0);
         else pos.push(s[0], cc, s[5] || 0);
         for (let k = 0; k < seg; k++) {
-          const a = si * ring + k;
+          const a = si * ring2 + k;
           const flip = e === 0 !== axisY;
           if (flip) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
@@ -29892,15 +31514,15 @@ var GameVehiclesThree = (() => {
       c.part("glass", L, m, pos, o.reach || 0.9);
       return m;
     };
-    kit.asGlass = function(c, mesh, label, type, o) {
+    kit.asGlass = function(c, mesh2, label, type, o) {
       o = o || {};
-      const i = c.deform.indexOf(mesh);
+      const i = c.deform.indexOf(mesh2);
       if (i >= 0) c.deform.splice(i, 1);
-      if (mesh.parent) mesh.parent.remove(mesh);
-      const geo = mesh.geometry;
-      geo.applyMatrix4(new THREE.Matrix4().compose(mesh.position, mesh.quaternion, mesh.scale));
+      if (mesh2.parent) mesh2.parent.remove(mesh2);
+      const geo = mesh2.geometry;
+      geo.applyMatrix4(new THREE.Matrix4().compose(mesh2.position, mesh2.quaternion, mesh2.scale));
       if (o.reuv !== false) o.reuv = true;
-      return kit.addGlass(c, geo, label, type, Object.assign({ mat: mesh.material }, o));
+      return kit.addGlass(c, geo, label, type, Object.assign({ mat: mesh2.material }, o));
     };
     kit.sideWindows = function(c, polys, Wg, T, label, o) {
       o = o || {};
@@ -29946,12 +31568,12 @@ var GameVehiclesThree = (() => {
         });
       });
     };
-    kit.cutMesh = function(mesh, tests, deg, o) {
-      const src = o && o.sub ? subdivide(mesh.geometry, o.sub) : mesh.geometry;
+    kit.cutMesh = function(mesh2, tests, deg, o) {
+      const src = o && o.sub ? subdivide(mesh2.geometry, o.sub) : mesh2.geometry;
       const r = cutGeometry(src, tests);
       crease(r.geo, deg || 42);
-      mesh.geometry.dispose();
-      mesh.geometry = r.geo;
+      mesh2.geometry.dispose();
+      mesh2.geometry = r.geo;
       return r.cut;
     };
     kit.quadDef = function(pb, pt, Wg, T, which, bev, o) {
@@ -30149,8 +31771,8 @@ var GameVehiclesThree = (() => {
           const pz = nR === 1 ? 0 : (i ? 1 : -1) * w / 4;
           const back = gm(g, new THREE.CylinderGeometry(r * 1.06, r * 1.06, d * 0.8, 22), MATERIALS.housing, 0, 0, pz);
           back.rotation.z = PI / 2;
-          const ring = gm(g, new THREE.TorusGeometry(r * 1.02, 0.013, 8, 30), MATERIALS.chrome, d / 2 - 6e-3, 0, pz);
-          ring.rotation.y = PI / 2;
+          const ring2 = gm(g, new THREE.TorusGeometry(r * 1.02, 0.013, 8, 30), MATERIALS.chrome, d / 2 - 6e-3, 0, pz);
+          ring2.rotation.y = PI / 2;
           const bowl = gm(g, new THREE.SphereGeometry(r * 0.96, 18, 10, 0, PI * 2, 0, PI / 2), MATERIALS.reflectorLit, d / 2 - 0.012, 0, pz);
           bowl.rotation.z = PI / 2;
           bowl.scale.y = 0.55;
@@ -30227,8 +31849,8 @@ var GameVehiclesThree = (() => {
           const e = gm(g, new THREE.CylinderGeometry(r * 0.9, r * 0.9, 0.012, 20), q * ls > 0 ? MATERIALS.tail : MATERIALS.tail, d / 2 - 0.02, 0, pz);
           e.rotation.z = PI / 2;
           inner.push(e);
-          const ring = gm(g, new THREE.TorusGeometry(r, 0.01, 6, 24), MATERIALS.chrome, d / 2 - 4e-3, 0, pz);
-          ring.rotation.y = PI / 2;
+          const ring2 = gm(g, new THREE.TorusGeometry(r, 0.01, 6, 24), MATERIALS.chrome, d / 2 - 4e-3, 0, pz);
+          ring2.rotation.y = PI / 2;
           const ln = gm(g, new THREE.SphereGeometry(r, 16, 8, 0, PI * 2, 0, PI / 2), MATERIALS.lensRed, d / 2 - 0.01, 0, pz);
           ln.rotation.z = -PI / 2;
           ln.scale.y = 0.25;
@@ -30321,7 +31943,7 @@ var GameVehiclesThree = (() => {
       } else if (st === "mesh") {
         gm(g, roundedBoxGeometry(0.05, h, w, Math.min(0.03, h * 0.3)), MATERIALS.housing);
         const cell = 0.026;
-        const list = [];
+        const list2 = [];
         const rows = Math.floor(h * 0.85 / (cell * 1.6));
         const cols = Math.floor(w * 0.9 / (cell * 1.8));
         for (let rI = 0; rI < rows; rI++)
@@ -30330,9 +31952,9 @@ var GameVehiclesThree = (() => {
             hg.rotateZ(PI / 2);
             hg.rotateX(PI / 6);
             hg.translate(0.026, -h * 0.42 + (rI + 0.5) * h * 0.85 / rows, -w * 0.45 + (cI + 0.5 + rI % 2 * 0.5 - 0.25) * w * 0.9 / cols);
-            list.push(hg);
+            list2.push(hg);
           }
-        if (list.length) gm(g, mergeGeometries(list), MATERIALS.trim);
+        if (list2.length) gm(g, mergeGeometries(list2), MATERIALS.trim);
         gm(g, roundedBoxGeometry(0.022, 0.014, w, 6e-3), MATERIALS.chrome, 0.03, h / 2 - 8e-3, 0);
       } else if (st === "big") {
         const fr = roundedBoxGeometry(0.06, h, w, 0.03);
@@ -31167,7 +32789,7 @@ var GameVehiclesThree = (() => {
       m.underbodyGroup = ug;
       const DK = makeMaterial("#1a1b1c", { roughness: 0.75, metalness: 0.3 });
       const ST = MATERIALS.steel;
-      function box(w, h, d, mat, x, y, z) {
+      function box2(w, h, d, mat, x, y, z) {
         return c.roundBox(w, h, d, Math.min(0.02, h * 0.4), mat, x, y, z, { parent: ug });
       }
       function rod(a, b, r, mat) {
@@ -31184,9 +32806,9 @@ var GameVehiclesThree = (() => {
         rod(new V3(rx, rr, -zW), new V3(rx, rr, zW), 0.045, ST);
         c.sphere(0.13, ST, rx, rr, 0, 1, 0.85, 1, { parent: ug });
         rod(new V3(rx + 0.1, rr, 0), new V3(fx - 0.6, yU + 0.04, 0), 0.035, ST);
-      } else box(0.09, 0.08, zW * 2, DK, rx + 0.08, Math.max(yU, rr - 0.12), 0);
+      } else box2(0.09, 0.08, zW * 2, DK, rx + 0.08, Math.max(yU, rr - 0.12), 0);
       if (!ev) {
-        box(Math.min(0.5, (fx - rx) * 0.2), 0.1, 0.38, DK, fx - 0.25, yU + 0.01, -0.05);
+        box2(Math.min(0.5, (fx - rx) * 0.2), 0.1, 0.38, DK, fx - 0.25, yU + 0.01, -0.05);
         const tz = W * 0.3;
         const mx = rx - 0.15;
         const ty = Math.max(0.14, by - 0.06);
@@ -31203,10 +32825,10 @@ var GameVehiclesThree = (() => {
           { parent: ug, seg: 30, rs: 6 }
         );
         c.cylinder(0.1, 0.1, 0.42, ST, mx, ty + 0.02, tz, "x", { parent: ug });
-        box(0.24, 0.06, 0.2, DK, (fx + rx) / 2 + 0.1, ty, 0.16);
-        box(0.55, 0.18, W * 0.5, makeMaterial("#232527", { roughness: 0.7 }), rx + 0.62, Math.max(0.16, by - 0.02), -W * 0.1);
+        box2(0.24, 0.06, 0.2, DK, (fx + rx) / 2 + 0.1, ty, 0.16);
+        box2(0.55, 0.18, W * 0.5, makeMaterial("#232527", { roughness: 0.7 }), rx + 0.62, Math.max(0.16, by - 0.02), -W * 0.1);
       } else {
-        box(
+        box2(
           (fx - rx) * 0.72,
           0.1,
           W - 0.4,
@@ -31215,7 +32837,7 @@ var GameVehiclesThree = (() => {
           Math.max(0.14, by - 0.03),
           0
         );
-        for (let k = 0; k < 6; k++) box(0.03, 0.02, W - 0.45, ST, rx + 0.4 + k * (fx - rx - 0.8) / 5, Math.max(0.14, by - 0.03) - 0.06, 0);
+        for (let k = 0; k < 6; k++) box2(0.03, 0.02, W - 0.45, ST, rx + 0.4 + k * (fx - rx - 0.8) / 5, Math.max(0.14, by - 0.03) - 0.06, 0);
       }
       if (o.spare && m.rear < rx - 0.7) {
         c.cylinder(0.32, 0.32, 0.2, MATERIALS.rubber, rx - 0.55, Math.max(0.2, by - 0.05), 0, null, { parent: ug });
@@ -31539,16 +33161,16 @@ var GameVehiclesThree = (() => {
         }
       } else {
         const ns = o.spokes || 28;
-        const list = [];
+        const list2 = [];
         for (let jj = 0; jj < ns; jj++) {
           const a2 = jj / ns * PI * 2;
           const cg = new THREE.CylinderGeometry(25e-4, 25e-4, sl, 4);
           cg.applyMatrix4(
             new THREE.Matrix4().makeRotationZ(a2 - PI / 2).setPosition(Math.cos(a2) * sl / 2, Math.sin(a2) * sl / 2, (jj % 2 ? 1 : -1) * 0.012)
           );
-          list.push(cg);
+          list2.push(cg);
         }
-        g.add(new THREE.Mesh(mergeGeometries(list), MATERIALS.chrome));
+        g.add(new THREE.Mesh(mergeGeometries(list2), MATERIALS.chrome));
       }
       const hub = new THREE.Mesh(new THREE.CylinderGeometry(0.035, 0.035, 0.1, 12), MATERIALS.steel);
       hub.rotation.x = PI / 2;
@@ -31728,9 +33350,9 @@ var GameVehiclesThree = (() => {
           return puffTexture(k * 17, true);
         });
       }
-      const list = fire ? FIRE_TEXTURES : SMOKE_TEXTURES;
+      const list2 = fire ? FIRE_TEXTURES : SMOKE_TEXTURES;
       const mat = new THREE.SpriteMaterial({
-        map: list[Math.floor(Math.random() * list.length)],
+        map: list2[Math.floor(Math.random() * list2.length)],
         color: new THREE.Color(col),
         transparent: true,
         depthWrite: false,
@@ -33033,7 +34655,7 @@ var GameVehiclesThree = (() => {
         }
       });
       const dset = new Set(c.deform);
-      const box = new THREE.Box3();
+      const box2 = new THREE.Box3();
       c.vehicle.children.forEach(function(o) {
         if (dset.has(o) || o.userData.noFollow) return;
         if (!(o.isMesh || o.isGroup && o.userData.rigid)) return;
@@ -33044,10 +34666,10 @@ var GameVehiclesThree = (() => {
             if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
             o.userData.bb0 = o.geometry.boundingBox.clone().applyMatrix4(o.matrix);
           } else {
-            box.setFromObject(o);
-            box.applyMatrix4(gInv);
-            o.userData.c0 = box.getCenter(new V3());
-            o.userData.bb0 = box.clone();
+            box2.setFromObject(o);
+            box2.applyMatrix4(gInv);
+            o.userData.c0 = box2.getCenter(new V3());
+            o.userData.bb0 = box2.clone();
           }
           o.userData.pos0 = o.position.clone();
         }
@@ -33341,11 +34963,11 @@ var GameVehiclesThree = (() => {
         [12, "#d8322a", kit.t("blast.lethal", { m: 12 })],
         [30, "#e0a548", kit.t("blast.injury", { m: 30 })]
       ].forEach(function(r) {
-        const ring = new THREE.Mesh(new THREE.RingGeometry(r[0] - 0.25, r[0], 96), boomMat(r[1], 0.85));
-        ring.rotation.x = -PI / 2;
-        ring.position.y = 0.06;
-        ring.renderOrder = 5;
-        g.add(ring);
+        const ring2 = new THREE.Mesh(new THREE.RingGeometry(r[0] - 0.25, r[0], 96), boomMat(r[1], 0.85));
+        ring2.rotation.x = -PI / 2;
+        ring2.position.y = 0.06;
+        ring2.renderOrder = 5;
+        g.add(ring2);
         const fill2 = new THREE.Mesh(new THREE.CircleGeometry(r[0], 96), boomMat(r[1], 0.07));
         fill2.rotation.x = -PI / 2;
         fill2.position.y = 0.05;
@@ -33362,7 +34984,7 @@ var GameVehiclesThree = (() => {
         lb.rotation.x = -PI / 2;
         lb.position.set(0, 0.08, r[0] + r[0] * 0.06);
         g.add(lb);
-        c.bigFx.rings.push(ring, fill2, lb);
+        c.bigFx.rings.push(ring2, fill2, lb);
       });
     }
     function detonate(c) {
@@ -33635,7 +35257,7 @@ var GameVehiclesThree = (() => {
     const I = kit._;
     const { MATERIALS } = I;
     function rollMeshes(c) {
-      const list = [];
+      const list2 = [];
       const thin = [];
       c.root.updateMatrixWorld(true);
       const inv = new THREE.Matrix4().copy(c.vehicle.matrixWorld).invert();
@@ -33653,9 +35275,9 @@ var GameVehiclesThree = (() => {
           thin.push({ o: ob, M });
           return;
         }
-        list.push({ o: ob, M });
+        list2.push({ o: ob, M });
       });
-      return { list, thin };
+      return { list: list2, thin };
     }
     function convexHull(pts) {
       pts.sort(function(a, b) {
@@ -33738,7 +35360,7 @@ var GameVehiclesThree = (() => {
     };
     function rollContact(c, A, q) {
       const m = c.meta;
-      const list = [];
+      const list2 = [];
       const dy = A.cen[0] - q[0];
       const dz = A.cen[1] - q[1];
       const dl = Math.hypot(dy, dz) || 1;
@@ -33746,17 +35368,17 @@ var GameVehiclesThree = (() => {
       const f = 0.75;
       const bike = m.kind === "bike";
       (bike ? [0] : [-0.28, 0, 0.28]).forEach(function(k) {
-        list.push([new V3(A.x + k * A.L, q[0], q[1]), dir]);
+        list2.push([new V3(A.x + k * A.L, q[0], q[1]), dir]);
       });
       if (!bike && Math.abs(dir.z) > 0.75 && m.top - m.belt > 0.25 && A.hits < 3) {
         const sd = -Math.sign(dir.z);
         const yw = m.belt + (m.top - m.belt) * 0.45;
         [-0.25, 0.2].forEach(function(k) {
           const h = I.probe(c, new V3(A.x + k * A.L, yw, sd * (m.width / 2 + 2)), new V3(0, 0, -sd), 2 + m.width);
-          if (h) list.push([h.p, new V3(0, 0, -sd)]);
+          if (h) list2.push([h.p, new V3(0, 0, -sd)]);
         });
       }
-      list.forEach(function(e) {
+      list2.forEach(function(e) {
         I.impact(c, e[0], e[1], f, { noStain: true, maxDepth: 0.1 });
         const pf = c.toEffects(e[0]);
         pf.y = Math.max(0.03, pf.y);
@@ -33766,15 +35388,15 @@ var GameVehiclesThree = (() => {
       });
       A.hits++;
       A.bounce = A.hits === 1 ? 0.06 : 0.1;
-      if (m.kind === "boat") I.burst(c, "water", c.toEffects(list[0][0]).setY(0.05), 30, { speed: 3 });
+      if (m.kind === "boat") I.burst(c, "water", c.toEffects(list2[0][0]).setY(0.05), 30, { speed: 3 });
     }
-    function exactMinY(c, list) {
+    function exactMinY(c, list2) {
       c.root.updateMatrixWorld(true);
       const inv = new THREE.Matrix4().copy(c.root.matrixWorld).invert();
       const M = new THREE.Matrix4();
       const v = new V3();
       let mn = 1e9;
-      list.forEach(function(e) {
+      list2.forEach(function(e) {
         const ob = e.o;
         if (!ob.parent || !I.shown(c, ob)) return;
         M.multiplyMatrices(inv, ob.matrixWorld);
@@ -34473,6 +36095,153 @@ var GameVehiclesThree = (() => {
       return hole;
     }
     const _zr = new THREE.Raycaster();
+    const PROXY_MIN_TRIANGLES = 500;
+    const STROKE_REACH = 0.6;
+    const _pv = new V3();
+    const _pm = new THREE.Matrix4();
+    function decalRegion(c, z) {
+      const B = z.box;
+      const lo = [0, 1, 2].map(function(k) {
+        return I.boxLo(B, k) - STROKE_REACH;
+      });
+      const hi = [0, 1, 2].map(function(k) {
+        return I.boxHi(B, k) + STROKE_REACH;
+      });
+      const a = axisOf(z.dir);
+      const dn = z.dir.clone().normalize();
+      const sg = z.dir.getComponent(a) > 0 ? 1 : -1;
+      const outer = sg > 0 ? I.boxLo(B, a) - 0.6 : I.boxHi(B, a) + 0.6;
+      const far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
+      for (let i = 0; i < 8; i++) {
+        const p = new V3();
+        p.setComponent(a, outer);
+        [0, 1, 2].filter(function(k) {
+          return k !== a;
+        }).forEach(function(k, j) {
+          p.setComponent(k, i >> j & 1 ? I.boxHi(B, k) : I.boxLo(B, k));
+        });
+        for (let e = 0; e < 2; e++) {
+          const q = e ? p.clone().addScaledVector(dn, far) : p;
+          for (let k = 0; k < 3; k++) {
+            lo[k] = Math.min(lo[k], q.getComponent(k) - 0.05);
+            hi[k] = Math.max(hi[k], q.getComponent(k) + 0.05);
+          }
+        }
+      }
+      return { lo, hi };
+    }
+    function regionCands(c, z, cands) {
+      if (!cands.some(heavy)) return cands;
+      const R = decalRegion(c, z);
+      const Mw = c.vehicle.matrixWorld;
+      return cands.map(function(o) {
+        if (!heavy(o)) return o;
+        if (!o.geometry.boundingSphere) o.geometry.computeBoundingSphere();
+        if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
+        return proxyIn(o, Mw, R);
+      });
+    }
+    function heavy(o) {
+      const g = o.geometry;
+      const pos = g && g.attributes && g.attributes.position;
+      return o.raycast === THREE.Mesh.prototype.raycast && !o.isSkinnedMesh && !Array.isArray(o.material) && pos && !pos.isInterleavedBufferAttribute && pos.itemSize === 3 && !g.groups.length && !(g.morphAttributes && g.morphAttributes.position) && (g.index ? g.index.count : pos.count) / 3 >= PROXY_MIN_TRIANGLES;
+    }
+    function proxyIn(o, Mw, R) {
+      _pm.copy(o.matrixWorld).invert().multiply(Mw);
+      const lo = [Infinity, Infinity, Infinity];
+      const hi = [-Infinity, -Infinity, -Infinity];
+      for (let i = 0; i < 8; i++) {
+        _pv.set(i & 1 ? R.hi[0] : R.lo[0], i & 2 ? R.hi[1] : R.lo[1], i & 4 ? R.hi[2] : R.lo[2]).applyMatrix4(_pm);
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], _pv.getComponent(k));
+          hi[k] = Math.max(hi[k], _pv.getComponent(k));
+        }
+      }
+      const g = o.geometry;
+      const P = g.attributes.position.array;
+      const ix = g.index ? g.index.array : null;
+      const n = ix ? ix.length : P.length / 3;
+      const keep = new Uint32Array(n - n % 3);
+      let nk = 0;
+      for (let t = 0; t + 2 < n; t += 3) {
+        const a = (ix ? ix[t] : t) * 3;
+        const b = (ix ? ix[t + 1] : t + 1) * 3;
+        const d = (ix ? ix[t + 2] : t + 2) * 3;
+        let out = false;
+        for (let k = 0; k < 3 && !out; k++) {
+          const u = P[a + k];
+          const v = P[b + k];
+          const w = P[d + k];
+          out = Math.max(u, v, w) < lo[k] || Math.min(u, v, w) > hi[k];
+        }
+        if (!out) {
+          keep[nk++] = ix ? ix[t] : t;
+          keep[nk++] = ix ? ix[t + 1] : t + 1;
+          keep[nk++] = ix ? ix[t + 2] : t + 2;
+        }
+      }
+      if (!nk) return null;
+      const kept = keep.slice(0, nk);
+      const box2 = new Float32Array(kept.length / 3 * 6);
+      for (let t = 0, j = 0; t < kept.length; t += 3, j += 6) {
+        const a = kept[t] * 3;
+        const b = kept[t + 1] * 3;
+        const d = kept[t + 2] * 3;
+        for (let k = 0; k < 3; k++) {
+          box2[j + k] = Math.min(P[a + k], P[b + k], P[d + k]);
+          box2[j + 3 + k] = Math.max(P[a + k], P[b + k], P[d + k]);
+        }
+      }
+      const pg = new THREE.BufferGeometry();
+      pg.setAttribute("position", g.attributes.position);
+      pg.setIndex(new THREE.BufferAttribute(new Uint32Array(kept.length), 1));
+      pg.boundingSphere = g.boundingSphere;
+      pg.boundingBox = g.boundingBox;
+      const proxy = new THREE.Mesh(pg, o.material);
+      proxy.layers.mask = o.layers.mask;
+      proxy.proxyOf = o;
+      proxy.kept = kept;
+      proxy.keptBox = box2;
+      return proxy;
+    }
+    function narrowTo(rc, proxy) {
+      const o = proxy.proxyOf;
+      const ray = rc.ray;
+      _pm.copy(o.matrixWorld).invert();
+      _pv.copy(ray.origin).applyMatrix4(_pm);
+      const x0 = _pv.x;
+      const y0 = _pv.y;
+      const z0 = _pv.z;
+      _pv.copy(ray.direction).multiplyScalar(rc.far).add(ray.origin).applyMatrix4(_pm);
+      const lo0 = Math.min(x0, _pv.x) - 1e-4;
+      const lo1 = Math.min(y0, _pv.y) - 1e-4;
+      const lo2 = Math.min(z0, _pv.z) - 1e-4;
+      const hi0 = Math.max(x0, _pv.x) + 1e-4;
+      const hi1 = Math.max(y0, _pv.y) + 1e-4;
+      const hi2 = Math.max(z0, _pv.z) + 1e-4;
+      const K = proxy.kept;
+      const X = proxy.keptBox;
+      const dst = proxy.geometry.index.array;
+      let m = 0;
+      for (let t = 0, j = 0; t < K.length; t += 3, j += 6) {
+        if (X[j + 3] < lo0 || X[j] > hi0 || X[j + 4] < lo1 || X[j + 1] > hi1 || X[j + 5] < lo2 || X[j + 2] > hi2) continue;
+        dst[m++] = K[t];
+        dst[m++] = K[t + 1];
+        dst[m++] = K[t + 2];
+      }
+      proxy.geometry.setDrawRange(0, m);
+    }
+    function castAt(rc, cands) {
+      for (let i = 0; i < cands.length; i++) {
+        const q = cands[i];
+        if (!q.proxyOf) continue;
+        q.matrixWorld.copy(q.proxyOf.matrixWorld);
+        narrowTo(rc, q);
+      }
+      const hits = rc.intersectObjects(cands, false);
+      for (let i = 0; i < hits.length; i++) if (hits[i].object.proxyOf) hits[i].object = hits[i].object.proxyOf;
+      return hits;
+    }
     function zoneCands(c, z, inv, glassToo) {
       const out = [];
       c.vehicle.traverse(function(o) {
@@ -34525,7 +36294,7 @@ var GameVehiclesThree = (() => {
         });
         _zr.set(org.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
         _zr.far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
-        const hits = _zr.intersectObjects(cands, false);
+        const hits = castAt(_zr, cands);
         for (let i = 0; i < hits.length; i++) {
           const h = hits[i];
           if (!h.face) continue;
@@ -34553,7 +36322,7 @@ var GameVehiclesThree = (() => {
         const q = s.p.clone().addScaledVector(t, len * 0.5 * k / M);
         _rt.set(q.clone().addScaledVector(n, 0.08).applyMatrix4(Mw), n.clone().negate().transformDirection(Mw));
         _rt.far = 0.2;
-        const h = _rt.intersectObjects(cands, false).find(function(x) {
+        const h = castAt(_rt, cands).find(function(x) {
           return x.face;
         });
         if (!h) return null;
@@ -34624,6 +36393,7 @@ var GameVehiclesThree = (() => {
       const R = c.rand;
       const need = (spec.fine || 0) + (spec.deep || 0) + (spec.chip || 0) + (spec.rust || 0) + (spec.tear || 0) + (spec.ding || 0) + (spec.soot || 0) + (spec.crater || 0);
       if (!need) return [];
+      cands = regionCands(c, z, cands).filter(Boolean);
       const S = zoneSurf(c, z, need + 2, R, cands);
       let k = 0;
       const ang0 = R() * PI;
@@ -34702,8 +36472,25 @@ var GameVehiclesThree = (() => {
     }
     function subdivIn(geo, rel, B, maxLen) {
       const a = geo.attributes.position.array;
-      const out = [];
-      const v = new V3();
+      let out = new Float32Array(a.length + 4096);
+      let used = 0;
+      const push = function(a0, a1, a2, b0, b1, b2, c0, c1, c2) {
+        if (used + 9 > out.length) {
+          const bigger = new Float32Array(out.length * 2);
+          bigger.set(out);
+          out = bigger;
+        }
+        out[used] = a0;
+        out[used + 1] = a1;
+        out[used + 2] = a2;
+        out[used + 3] = b0;
+        out[used + 4] = b1;
+        out[used + 5] = b2;
+        out[used + 6] = c0;
+        out[used + 7] = c1;
+        out[used + 8] = c2;
+        used += 9;
+      };
       const e = 0.15;
       function d(p, q) {
         return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
@@ -34717,7 +36504,7 @@ var GameVehiclesThree = (() => {
         const ca = d(C, A);
         const mx = Math.max(ab, bc, ca);
         if (mx <= maxLen || depth > 9) {
-          out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
+          push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
           return;
         }
         if (mx === ab) {
@@ -34734,31 +36521,26 @@ var GameVehiclesThree = (() => {
           tri(F2, Bv, C, depth + 1);
         }
       }
+      const M = rel.elements;
+      const at = function(x, y, z, k) {
+        const w = 1 / (M[3] * x + M[7] * y + M[11] * z + M[15]);
+        return k === 0 ? (M[0] * x + M[4] * y + M[8] * z + M[12]) * w : k === 1 ? (M[1] * x + M[5] * y + M[9] * z + M[13]) * w : (M[2] * x + M[6] * y + M[10] * z + M[14]) * w;
+      };
+      const lo = [B.x0 - e, B.y0 - e, B.z0 - e];
+      const hi = [B.x1 + e, B.y1 + e, B.z1 + e];
       for (let i = 0; i < a.length; i += 9) {
-        const A = [a[i], a[i + 1], a[i + 2]];
-        const Bv = [a[i + 3], a[i + 4], a[i + 5]];
-        const C = [a[i + 6], a[i + 7], a[i + 8]];
-        let x0 = 1e9;
-        let x1 = -1e9;
-        let y0 = 1e9;
-        let y1 = -1e9;
-        let z0 = 1e9;
-        let z1 = -1e9;
-        [A, Bv, C].forEach(function(p) {
-          v.set(p[0], p[1], p[2]).applyMatrix4(rel);
-          x0 = Math.min(x0, v.x);
-          x1 = Math.max(x1, v.x);
-          y0 = Math.min(y0, v.y);
-          y1 = Math.max(y1, v.y);
-          z0 = Math.min(z0, v.z);
-          z1 = Math.max(z1, v.z);
-        });
-        if (x1 < B.x0 - e || x0 > B.x1 + e || y1 < B.y0 - e || y0 > B.y1 + e || z1 < B.z0 - e || z0 > B.z1 + e)
-          out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
-        else tri(A, Bv, C, 0);
+        let outside = false;
+        for (let k = 0; k < 3 && !outside; k++) {
+          const p = at(a[i], a[i + 1], a[i + 2], k);
+          const q = at(a[i + 3], a[i + 4], a[i + 5], k);
+          const r = at(a[i + 6], a[i + 7], a[i + 8], k);
+          outside = Math.max(p, q, r) < lo[k] || Math.min(p, q, r) > hi[k];
+        }
+        if (outside) push(a[i], a[i + 1], a[i + 2], a[i + 3], a[i + 4], a[i + 5], a[i + 6], a[i + 7], a[i + 8]);
+        else tri([a[i], a[i + 1], a[i + 2]], [a[i + 3], a[i + 4], a[i + 5]], [a[i + 6], a[i + 7], a[i + 8]], 0);
       }
       const g = new THREE.BufferGeometry();
-      g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+      g.setAttribute("position", new THREE.BufferAttribute(out.slice(0, used), 3));
       g.userData.crease = true;
       g.userData.p0 = null;
       return g;
@@ -34781,6 +36563,17 @@ var GameVehiclesThree = (() => {
       });
       return out;
     }
+    function boxInFrame(B, m, tmp) {
+      const r = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+      for (let i = 0; i < 8; i++) {
+        tmp.set(i & 1 ? B.x1 : B.x0, i & 2 ? B.y1 : B.y0, i & 4 ? B.z1 : B.z0).applyMatrix4(m);
+        for (let k = 0; k < 3; k++) {
+          r[k] = Math.min(r[k], tmp.getComponent(k) - 1e-4);
+          r[k + 3] = Math.max(r[k + 3], tmp.getComponent(k) + 1e-4);
+        }
+      }
+      return r;
+    }
     function zoneDent(c, z, dents, dirty, opt) {
       opt = opt || {};
       const B = z.box;
@@ -34835,6 +36628,7 @@ var GameVehiclesThree = (() => {
           g = msh.geometry = g.clone();
           msh.userData.zCloned = true;
         }
+        let boundsDue = false;
         const nonIdx = !g.index;
         const onlyPos = Object.keys(g.attributes).every(function(k) {
           return k === "position" || k === "normal";
@@ -34843,15 +36637,17 @@ var GameVehiclesThree = (() => {
           const ng = subdivIn(g, rel, B, opt.sub || 0.075);
           g.dispose();
           g = msh.geometry = ng;
-          ng.computeBoundingSphere();
-          ng.computeBoundingBox();
+          boundsDue = true;
           dirty.add(msh);
         }
         irel.copy(rel).invert();
         const pos = g.attributes.position;
         let changed = false;
+        const near = boxInFrame(B, irel, v);
         for (let i = 0; i < pos.count; i++) {
-          v.fromBufferAttribute(pos, i).applyMatrix4(rel);
+          v.fromBufferAttribute(pos, i);
+          if (v.x < near[0] || v.x > near[3] || v.y < near[1] || v.y > near[4] || v.z < near[2] || v.z > near[5]) continue;
+          v.applyMatrix4(rel);
           const f = field(v);
           if (f <= 1e-5) continue;
           v.addScaledVector(d, f);
@@ -34872,9 +36668,11 @@ var GameVehiclesThree = (() => {
         }
         if (changed) {
           pos.needsUpdate = true;
+          dirty.add(msh);
+        }
+        if (changed || boundsDue) {
           g.computeBoundingSphere();
           g.computeBoundingBox();
-          dirty.add(msh);
         }
       });
       const dset = new Set(c.deform);
@@ -35954,9 +37752,9 @@ var GameVehiclesThree = (() => {
         down: new V3(0, 1, 0)
       }[d] || null;
     }
-    function resolveObjs(c, list, z) {
+    function resolveObjs(c, list2, z) {
       const out = [];
-      (list || []).forEach(function(o) {
+      (list2 || []).forEach(function(o) {
         if (!o) return;
         if (typeof o === "string") {
           c.parts.forEach(function(p) {
@@ -35984,22 +37782,22 @@ var GameVehiclesThree = (() => {
     }
     function deriveZones(c) {
       const m = c.meta;
-      let list = [];
+      let list2 = [];
       const byId = {};
       (m.zones === false ? [] : I.autoZones(c)).forEach(function(z) {
         byId[z.id] = z;
-        list.push(z);
+        list2.push(z);
       });
       (c.zoneDefs || []).forEach(function(d) {
         let z = byId[d.id];
         if (d.remove) {
           if (z) {
-            list.splice(list.indexOf(z), 1);
+            list2.splice(list2.indexOf(z), 1);
             delete byId[d.id];
           }
-          list.slice().forEach(function(q) {
+          list2.slice().forEach(function(q) {
             if (q.id.indexOf(d.id + "_") === 0 && /^\d+$/.test(q.id.slice(d.id.length + 1))) {
-              list.splice(list.indexOf(q), 1);
+              list2.splice(list2.indexOf(q), 1);
               delete byId[q.id];
             }
           });
@@ -36012,7 +37810,7 @@ var GameVehiclesThree = (() => {
         } else {
           z = Object.assign({ type: "panel" }, d);
           byId[d.id] = z;
-          list.push(z);
+          list2.push(z);
         }
       });
       const inv = I.worldInverseOf(c);
@@ -36045,10 +37843,10 @@ var GameVehiclesThree = (() => {
         }
         z.box = I.normalizeBox(bb);
       });
-      list = list.filter(function(z) {
+      list2 = list2.filter(function(z) {
         return z.box && z.name;
       });
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         z.glass = (z.glass || []).slice();
         z.lights = (z.lights || []).slice();
         z.wheels = (z.wheels || []).slice();
@@ -36085,7 +37883,7 @@ var GameVehiclesThree = (() => {
         if (owner.has(g) || !g.parent || !g.userData.glass || g.userData.ghost) return;
         const cg = I.localBox(c, g, inv).getCenter(new V3());
         let best = null;
-        list.forEach(function(z) {
+        list2.forEach(function(z) {
           if (z.internal || z.type === "wheel" || z.type === "light") return;
           if (I.boxContains(z.box, cg.x, cg.y, cg.z, 0.05) && (!best || I.boxVolume(z.box) < I.boxVolume(best.box))) best = z;
         });
@@ -36094,7 +37892,7 @@ var GameVehiclesThree = (() => {
           owner.set(g, best);
         }
       });
-      const looseParts = list.filter(function(z) {
+      const looseParts = list2.filter(function(z) {
         return z.type === "part";
       });
       if (looseParts.length)
@@ -36119,7 +37917,7 @@ var GameVehiclesThree = (() => {
             });
           }
         });
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         if (!z.mirror) return;
         z.mirrors = [];
         const B = z.box;
@@ -36151,21 +37949,21 @@ var GameVehiclesThree = (() => {
           });
         }
       });
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         const B = z.box;
         z.map = z.map || [Math.max(B.x0, R - 0.3), Math.min(B.x1, F + 0.3), Math.max(B.z0, -W / 2 - 0.35), Math.min(B.z1, W / 2 + 0.35)];
       });
-      carMap(c, list);
+      carMap(c, list2);
       c.zoneOwners = owner;
-      return list;
+      return list2;
     }
-    function carMap(c, list) {
+    function carMap(c, list2) {
       const m = c.meta;
       const W = m.width || 1.7;
       const hw = W / 2;
       const gh = m.glasshouse;
       if ((m.kind || "car") !== "car" || !gh || gh.fb == null) return;
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         if (z.mapSet) return;
         const B = z.box;
         const s = z.side;
@@ -36228,8 +38026,8 @@ var GameVehiclesThree = (() => {
       const top = m.top || belt + 0.5;
       const hw = W / 2;
       const WH = I.wheelInfo(c);
-      function add2(id, name, type, box, o) {
-        const z = Object.assign({ id, name, type, box: I.normalizeBox(box) }, o || {});
+      function add2(id, name, type, box2, o) {
+        const z = Object.assign({ id, name, type, box: I.normalizeBox(box2) }, o || {});
         Z.push(z);
         return z;
       }
@@ -37723,9 +39521,9 @@ var GameVehiclesThree = (() => {
         const kind = kindOf2(zone);
         if (!kind || !zone.box) continue;
         const b = zone.box;
-        const box = new THREE.Box3(new THREE.Vector3(b.x0, b.y0, b.z0), new THREE.Vector3(b.x1, b.y1, b.z1));
-        if (matrix) box.applyMatrix4(matrix);
-        out.push({ material: kind.material, zone: zone.id, part: kind.part, side: zone.side === 0 ? "center" : zone.side < 0 ? "left" : "right", box });
+        const box2 = new THREE.Box3(new THREE.Vector3(b.x0, b.y0, b.z0), new THREE.Vector3(b.x1, b.y1, b.z1));
+        if (matrix) box2.applyMatrix4(matrix);
+        out.push({ material: kind.material, zone: zone.id, part: kind.part, side: zone.side === 0 ? "center" : zone.side < 0 ? "left" : "right", box: box2 });
       }
       return out;
     };
@@ -37734,7 +39532,7 @@ var GameVehiclesThree = (() => {
     const opts = options || {};
     if (!opts.THREE || !opts.THREE.Vector3) throw new Error("createVehicleKit: options.THREE (the three.js namespace) is required");
     const lod = createLod(opts.lod);
-    const THREE = wrapThreeForLod(opts.THREE, lod);
+    const THREE = wrapThreeForLod(shapeGeometries(opts.THREE), lod);
     const strings = resolveStrings(opts.locale);
     const t = createTranslate(strings);
     const doc = opts.document || (typeof document !== "undefined" ? document : void 0);
@@ -37957,6 +39755,20 @@ var GameVehiclesThree = (() => {
         else kit.applyArmor(c);
       }
       if (zoneState == null && st === "damaged" && kit.config.damagedScenario) zoneState = kit.zoneScenario(c, kit.config.damagedScenario);
+      else if (zoneState && zoneState.scenario != null) {
+        c.scenario = zoneState.scenario;
+        let fromScenario = { health: {}, flags: {} };
+        try {
+          fromScenario = kit.zoneScenario(c, zoneState.scenario);
+        } catch (e) {
+          ;
+          (c.zoneErrors = c.zoneErrors || []).push("scenario: " + (e && e.message));
+        }
+        zoneState = {
+          health: Object.assign({}, fromScenario.health, zoneState.health),
+          flags: Object.assign({}, fromScenario.flags, zoneState.flags)
+        };
+      }
       if (zoneState) kit.applyZones(c, zoneState);
       else {
         c.zoneState = { health: {}, flags: {} };
@@ -38120,19 +39932,19 @@ var GameVehiclesThree = (() => {
     for (const z of zones) {
       let role = roleOfZone(z);
       if (z === hubZone) role = "frame";
-      const box = boxOf(z);
-      const area = areaOf(box.size);
+      const box2 = boxOf(z);
+      const area3 = areaOf(box2.size);
       const id = z.id;
       const label = String(z.name ?? id);
       const tags = [...z.tags ?? []];
       if (role === "rim") {
         const wheels = z.wheels ?? [];
         const r = Math.max(0.2, ...wheels.map((w) => w.userData?.r ?? 0.3));
-        const sz = Math.sign(box.center[2]) || 1;
-        const rimBox = { center: [box.center[0], box.center[1], box.center[2] - sz * box.size[2] * 0.25], size: [box.size[0] * 0.7, box.size[1] * 0.7, box.size[2] * 0.5] };
+        const sz = Math.sign(box2.center[2]) || 1;
+        const rimBox = { center: [box2.center[0], box2.center[1], box2.center[2] - sz * box2.size[2] * 0.25], size: [box2.size[0] * 0.7, box2.size[1] * 0.7, box2.size[2] * 0.5] };
         add2({ id, role, name: label, material: kind === "plane" || kind === "heli" ? "aluminium" : "steel", box: rimBox, mass: 22 * r * Math.max(1, wheels.length), hp: 12e3 * armour, zoneId: id, visual: kind !== "plane" && !/landing/.test(id), tags: ["wheel", ...tags] });
         const tyreId = id.replace(/^wheels?/, "tyre").replace(/^(?!tyre)/, "tyre_");
-        const tyreBox = { center: box.center, size: [box.size[0] * 0.98, box.size[1] * 0.98, box.size[2]] };
+        const tyreBox = { center: box2.center, size: [box2.size[0] * 0.98, box2.size[1] * 0.98, box2.size[2]] };
         add2({
           id: tyreId,
           role: "tyre",
@@ -38152,29 +39964,29 @@ var GameVehiclesThree = (() => {
       if (role === "glass") {
         const glass = (z.glass ?? [])[0];
         const laminated = glass?.userData?.glass?.type === "laminated" || m.bullet;
-        add2({ id, role, name: label, material: "glass", box, mass: 10 * area, hp: laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
+        add2({ id, role, name: label, material: "glass", box: box2, mass: 10 * area3, hp: laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
         continue;
       }
       if (role === "light") {
-        add2({ id, role, name: label, material: "glass", box, mass: 1.2 + 4 * area, hp: 320, zoneId: id, visual: true, tags: ["light", ...tags] });
+        add2({ id, role, name: label, material: "glass", box: box2, mass: 1.2 + 4 * area3, hp: 320, zoneId: id, visual: true, tags: ["light", ...tags] });
         continue;
       }
       if (role === "bumper") {
-        add2({ id, role, name: label, material: "plastic", box, mass: 6 + 5 * area, hp: 9e3, ignitionC: 400, zoneId: id, visual: true, tags: ["bumper", ...tags] });
+        add2({ id, role, name: label, material: "plastic", box: box2, mass: 6 + 5 * area3, hp: 9e3, ignitionC: 400, zoneId: id, visual: true, tags: ["bumper", ...tags] });
         continue;
       }
       if (role === "engine") {
         const kg2 = { bike: 55, quad: 90, car: 150, tractor: 450, truck: 600, bus: 450, tank: 900, boat: 90, plane: 160, heli: 150 }[kind];
-        add2({ id, role, name: label, material: kind === "plane" || kind === "heli" ? "aluminium" : "steel", box, mass: kg2, hp: 6e4 * armour, ignitionC: 260, zoneId: id, visual: false, tags: ["engine", ...tags] });
+        add2({ id, role, name: label, material: kind === "plane" || kind === "heli" ? "aluminium" : "steel", box: box2, mass: kg2, hp: 6e4 * armour, ignitionC: 260, zoneId: id, visual: false, tags: ["engine", ...tags] });
         continue;
       }
       if (role === "radiator") {
-        add2({ id, role, name: label, material: "aluminium", box, mass: 8, hp: 3e3, zoneId: id, visual: false, contains: { fluid: "coolant", liters: kind === "truck" || kind === "bus" ? 18 : 7, pressurized: true }, tags: ["radiator", ...tags] });
+        add2({ id, role, name: label, material: "aluminium", box: box2, mass: 8, hp: 3e3, zoneId: id, visual: false, contains: { fluid: "coolant", liters: kind === "truck" || kind === "bus" ? 18 : 7, pressurized: true }, tags: ["radiator", ...tags] });
         continue;
       }
       if (role === "fuel_tank") {
         if (fuelless) {
-          add2({ id, role: "other", name: label, material: "steel", box, mass: 20, hp: 25e3, zoneId: id, visual: false, tags });
+          add2({ id, role: "other", name: label, material: "steel", box: box2, mass: 20, hp: 25e3, zoneId: id, visual: false, tags });
           continue;
         }
         const liters = { bike: 14, quad: 16, car: 55, tractor: 150, truck: 300, bus: 200, tank: 600, boat: 90, plane: 120, heli: 300 }[kind];
@@ -38184,7 +39996,7 @@ var GameVehiclesThree = (() => {
           role,
           name: label,
           material: "steel",
-          box,
+          box: box2,
           mass: 14 + liters * 0.8,
           hp: 25e3 * armour,
           zoneId: id,
@@ -38197,21 +40009,21 @@ var GameVehiclesThree = (() => {
         continue;
       }
       if (role === "battery") {
-        add2({ id, role, name: label, material: "plastic", box, mass: 14, hp: 1500, zoneId: id, visual: true, ignitionC: 200, tags: ["battery", ...tags] });
+        add2({ id, role, name: label, material: "plastic", box: box2, mass: 14, hp: 1500, zoneId: id, visual: true, ignitionC: 200, tags: ["battery", ...tags] });
         continue;
       }
       if (role === "frame") {
-        add2({ id, role, name: label, material: "steel", box: floorPan(box), mass: mass * 0.25, hp: 15e4 * armour, zoneId: id, visual: false, tags: ["frame", ...tags] });
+        add2({ id, role, name: label, material: "steel", box: floorPan(box2), mass: mass * 0.25, hp: 15e4 * armour, zoneId: id, visual: false, tags: ["frame", ...tags] });
         continue;
       }
       const roofLike = role === "roof";
-      const kg = (skin === "steel" ? STEEL_KG_M2 : ALU_KG_M2) * area * (role === "door" ? 1.6 : 1);
+      const kg = (skin === "steel" ? STEEL_KG_M2 : ALU_KG_M2) * area3 * (role === "door" ? 1.6 : 1);
       add2({
         id,
         role,
         name: label,
         material: skin,
-        box,
+        box: box2,
         mass: Math.max(2, kg),
         hp: (roofLike ? 3e4 : 2e4) * armour,
         zoneId: id,
@@ -38433,7 +40245,7 @@ var GameVehiclesThree = (() => {
       const my = kind === "bike" || kind === "quad" ? (m.top ?? belt + 0.25) - 0.1 : belt + 0.12;
       for (const s of [-1, 1]) {
         const door = zones.find((z) => z.type === "door" && z.side === s && (z.mirrors ?? []).length);
-        let box = { center: [mx, my, s * half], size: [0.14, 0.12, 0.2] };
+        let box2 = { center: [mx, my, s * half], size: [0.14, 0.12, 0.2] };
         if (door) {
           const bb = door.mirrors.reduce(
             (acc, o) => {
@@ -38446,14 +40258,14 @@ var GameVehiclesThree = (() => {
             },
             null
           );
-          if (bb) box = { center: [(bb[0] + bb[1]) / 2, (bb[2] + bb[3]) / 2, (bb[4] + bb[5]) / 2], size: [Math.max(0.06, bb[1] - bb[0]), Math.max(0.06, bb[3] - bb[2]), Math.max(0.06, bb[5] - bb[4])] };
+          if (bb) box2 = { center: [(bb[0] + bb[1]) / 2, (bb[2] + bb[3]) / 2, (bb[4] + bb[5]) / 2], size: [Math.max(0.06, bb[1] - bb[0]), Math.max(0.06, bb[3] - bb[2]), Math.max(0.06, bb[5] - bb[4])] };
         }
         add2({
           id: `mirror_${side(s)}`,
           role: "mirror",
           name: t("mechanics.mirror", { side: t(`sides.${side(s)}`), sideM: t(`sides.${side(s)}M`) }),
           material: "plastic",
-          box,
+          box: box2,
           mass: 1.1,
           hp: 1500,
           ignitionC: 400,
@@ -38639,13 +40451,13 @@ var GameVehiclesThree = (() => {
       (parent ?? this.c.vehicle).add(m);
       return m;
     }
-    surface(axis, sign, B, samples) {
+    surface(axis, sign2, B, samples) {
       const V3 = this.THREE.Vector3;
       const hits = [];
       const far = 3;
       for (const [u, v] of samples) {
-        const o = axis === "z" ? new V3(u, v, sign * (Math.max(Math.abs(B.z0), Math.abs(B.z1)) + 1)) : new V3(sign * (Math.max(Math.abs(B.x0), Math.abs(B.x1)) + 1), u, v);
-        const d = axis === "z" ? new V3(0, 0, -sign) : new V3(-sign, 0, 0);
+        const o = axis === "z" ? new V3(u, v, sign2 * (Math.max(Math.abs(B.z0), Math.abs(B.z1)) + 1)) : new V3(sign2 * (Math.max(Math.abs(B.x0), Math.abs(B.x1)) + 1), u, v);
+        const d = axis === "z" ? new V3(0, 0, -sign2) : new V3(-sign2, 0, 0);
         const h = this.I.probe(this.c, o, d, far);
         if (h) hits.push(axis === "z" ? h.p.z : h.p.x);
       }
@@ -38795,12 +40607,12 @@ var GameVehiclesThree = (() => {
       const z = this.zone(p);
       if (!z) return false;
       const V3 = this.THREE.Vector3;
-      const list = z.glass.filter((g) => g.parent && g.visible);
-      if (!list.length) return false;
+      const list2 = z.glass.filter((g) => g.parent && g.visible);
+      if (!list2.length) return false;
       const pt = new V3(...point);
-      let best = list[0];
+      let best = list2[0];
       let bd = Infinity;
-      for (const g of list) {
+      for (const g of list2) {
         g.geometry.computeBoundingBox();
         const bb = g.geometry.boundingBox.clone().applyMatrix4(g.matrix);
         const d = bb.distanceToPoint(pt);
@@ -39097,6 +40909,9 @@ var GameVehiclesThree = (() => {
     const headless = !!options.headless;
     const seedBase = strHash(`${c.key}|${id}|${options.seed ?? 0}`);
     let rand = rng(seedBase);
+    const ignitionRules = resolveIgnitionRules(options.ignition);
+    const fuelFraction = clamp(options.fuel ?? 1, 0, 1);
+    let igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
     let clock = 0;
     let model;
     let vis = null;
@@ -39164,7 +40979,7 @@ var GameVehiclesThree = (() => {
           dents: [],
           holes: [],
           cracks: [],
-          liters: d.contains?.liters,
+          liters: d.contains ? d.role === "fuel_tank" ? d.contains.liters * fuelFraction : d.contains.liters : void 0,
           lost: false,
           status: "intact",
           flat: false,
@@ -39182,6 +40997,7 @@ var GameVehiclesThree = (() => {
       wasLit = true;
       deadEngine = false;
       rand = rng(seedBase);
+      igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
       steerSign = rand() < 0.5 ? -1 : 1;
       vis = headless ? null : new VehicleVisuals(kit, c, model);
       recomputeGroups();
@@ -39203,8 +41019,8 @@ var GameVehiclesThree = (() => {
         comps.get(r).push(p);
       }
       const hubRoot = parent.has(model.hub) ? find(model.hub) : "";
-      const list = [...comps.entries()].sort((a, b) => a[0] === hubRoot ? -1 : b[0] === hubRoot ? 1 : 0);
-      groupsCache = list.map(([, v]) => v);
+      const list2 = [...comps.entries()].sort((a, b) => a[0] === hubRoot ? -1 : b[0] === hubRoot ? 1 : 0);
+      groupsCache = list2.map(([, v]) => v);
       groupOf = /* @__PURE__ */ new Map();
       groupsCache.forEach((g, i) => g.forEach((p) => groupOf.set(p, i)));
       return groupsCache;
@@ -39476,8 +41292,19 @@ var GameVehiclesThree = (() => {
         if (!p.burning && p.temp > AMBIENT) p.temp = Math.max(AMBIENT, p.temp - dt * 6);
       }
       for (const f of flames) heat(centreOf(f.def), 0.8, 500, dt * 0.5, out, 0);
+      fireNearLeak(flames, dt, out);
       thermal(out);
     };
+    const fireNearLeak = (flames, dt, out) => {
+      const tank = tankPart();
+      const leak = tank ? leaks.get(tank.def.id) : void 0;
+      if (!tank || !leak || tank.lost || tank.burning || exploded || leak.fluid !== "fuel" && leak.fluid !== "diesel") return;
+      if (leak.pud?.fire) return light(tank, out);
+      const { radius, chancePerSecond } = ignitionRules.fireNear;
+      if (chancePerSecond <= 0) return;
+      const near = flames.some((f) => f !== tank && distToBox(tank.def, centreOf(f.def)) - Math.max(...f.def.box.size) / 2 <= radius);
+      if (near && igniteRand() < 1 - Math.exp(-chancePerSecond * dt)) light(tank, out);
+    };
     const normalOf = (d, v) => faceNormal(d, v);
     const ballistic = (h, out) => {
       sync();
@@ -39545,10 +41372,21 @@ var GameVehiclesThree = (() => {
           let amount = through ? E * 0.6 : E * 0.25;
           if (through && (d.role === "battery" || d.role === "alternator")) amount = Math.max(amount, p.hp * 0.65);
           damage(p, amount, "ballistic", h.source, out, worldPoint);
-          if (d.role === "fuel_tank" && E > 1500 && (p.liters ?? 0) > 1) p.temp = Math.max(p.temp, d.ignitionC ?? 260);
+          if (through && d.role === "fuel_tank") rollIgnition(p, h, metal, out);
         }
       }
     };
+    const light = (tank, out) => {
+      tank.temp = Math.max(tank.temp, (tank.def.ignitionC ?? 260) + 1);
+      if ((tank.liters ?? 0) > 0.5) ignite(tank, out);
+    };
+    const rollIgnition = (tank, h, metal, out) => {
+      const d = tank.def;
+      if (!d.contains || tank.burning || (tank.liters ?? 0) <= 0.05) return;
+      const fill2 = d.contains.liters > 0 ? (tank.liters ?? 0) / d.contains.liters : 0;
+      const chance = ignitionChance(h, { sparkTarget: sparkTargetFactor(d.material, metal, ignitionRules), fill: fill2, fluid: d.contains.fluid }, ignitionRules);
+      if (chance > 0 && igniteRand() < chance) light(tank, out);
+    };
     const blunt = (h, out) => {
       sync();
       const M = toFrameMatrix();
@@ -39612,7 +41450,7 @@ var GameVehiclesThree = (() => {
           const verdict = kit.blastDamage(c, E / (1 + dist * dist * 4) / 50);
           if (verdict === "explosion") explode(tank, h.source, out);
           else if (verdict === "fire") {
-            tank.temp = Math.max(tank.temp, tank.def.ignitionC ?? 260);
+            light(tank, out);
             startLeak(tank, centreOf(tank.def).setY(tank.def.box.center[1] - tank.def.box.size[1] / 2 + 0.05), 12, out, dir);
           }
         }
@@ -39626,9 +41464,9 @@ var GameVehiclesThree = (() => {
       thermal(out);
     };
     const sound = (role) => {
-      const list = [...ps.values()].filter((p) => p.def.role === role);
-      if (!list.length) return true;
-      return list.every((p) => !p.lost && attached(p.def.id) && p.hp >= p.def.hp * 0.5);
+      const list2 = [...ps.values()].filter((p) => p.def.role === role);
+      if (!list2.length) return true;
+      return list2.every((p) => !p.lost && attached(p.def.id) && p.hp >= p.def.hp * 0.5);
     };
     const tankPart = () => [...ps.values()].find((p) => p.def.role === "fuel_tank" && p.def.contains);
     const computeStatus = () => {
@@ -39820,8 +41658,8 @@ var GameVehiclesThree = (() => {
       queue = [];
       const hood = c.hood;
       if (hood) {
-        const sign = hood.sign || 1;
-        const cur = hood.piv.rotation.z / sign;
+        const sign2 = hood.sign || 1;
+        const cur = hood.piv.rotation.z / sign2;
         if (Math.abs(cur - hood.ang) > 1e-4) {
           hood.ang = cur;
           hood.target = cur;
@@ -39874,7 +41712,7 @@ var GameVehiclesThree = (() => {
     const reset = () => {
       const old = c;
       const parent = old.root.parent;
-      const next = kit.build(old.key, old.state);
+      const next = kit.build(old.key, old.state, old.scenario != null ? { scenario: old.scenario } : void 0);
       if (parent) {
         next.root.position.copy(old.root.position);
         next.root.quaternion.copy(old.root.quaternion);
@@ -39929,7 +41767,8 @@ var GameVehiclesThree = (() => {
   }
   function buildVehicleItem(kit, key, options = {}) {
     const THREE = kit.THREE;
-    const vehicle = options.lod ? kit.build(key, options.state ?? "intact", void 0, { lod: true }) : kit.build(key, options.state ?? "intact");
+    const zoneState = options.scenario != null ? { scenario: options.scenario } : void 0;
+    const vehicle = options.lod ? kit.build(key, options.state ?? "intact", zoneState, { lod: true }) : kit.build(key, options.state ?? "intact", zoneState);
     const m = vehicle.meta;
     const root = new THREE.Group();
     root.name = key;
@@ -39942,34 +41781,6 @@ var GameVehiclesThree = (() => {
     return { root, vehicle };
   }
 
-  // ../game-contracts/dist/index.js
-  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
-  var deepMerge = (base, patch) => {
-    if (!patch) return base;
-    const result = { ...base };
-    for (const [key, value] of Object.entries(patch)) {
-      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
-      const current = result[key];
-      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
-    }
-    return result;
-  };
-  var mergeById = (shipped, extra) => {
-    const entries = /* @__PURE__ */ new Map();
-    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
-    return entries;
-  };
-  var applyPatches = (entries, patches) => {
-    for (const [id, patch] of Object.entries(patches ?? {})) {
-      const entry = entries.get(id);
-      if (entry) entries.set(id, deepMerge(entry, patch));
-    }
-  };
-  var removeIds = (entries, ids) => {
-    for (const id of ids ?? []) entries.delete(id);
-  };
-
   // ../game-vehicles-driving/dist/index.js
   var defaultArcadeSpec = {
     length: 4.3,
@@ -40105,7 +41916,7 @@ var GameVehiclesThree = (() => {
     { id: "blood", grip: 0.5 }
   ];
   function createSurfaces(options = {}) {
-    const entries = mergeById(defaultSurfaces, options.packs?.flatMap((pack) => pack.surfaces ?? []));
+    const entries = mergeById(defaultSurfaces, options.packs?.flatMap((pack2) => pack2.surfaces ?? []));
     applyPatches(entries, options.patch);
     removeIds(entries, options.remove);
     const fallback = entries.get("dry_asphalt") ?? { id: "dry_asphalt", grip: 1 };
@@ -40398,6 +42209,7 @@ var GameVehiclesThree = (() => {
     "vehicles_kill_battery",
     "vehicles_rollover",
     "vehicles_melt",
+    "vehicles_burnt_wreck",
     "vehicles_drive_arcade",
     "vehicles_drive_semi"
   ];
@@ -40429,7 +42241,7 @@ var GameVehiclesThree = (() => {
     en: {
       group: "Vehicles",
       name: "Vehicles area",
-      items: { hatch: "Compact hatch", sedan: "Midsize sedan", pickup: "Midsize pickup", sport_bike: "Sport bike", box_truck: "Box truck", city_bus: "City bus", battle_tank: "Battle tank", attack_helicopter: "Attack helicopter" },
+      items: { hatch: "Compact hatch", sedan: "Midsize sedan", pickup: "Midsize pickup", sport_bike: "Sport bike", box_truck: "Box truck", city_bus: "City bus", battle_tank: "Battle tank", attack_helicopter: "Attack helicopter", sedan_burnt: "Burnt sedan", hatch_burnt: "Burnt hatch" },
       controls: { quality: "Quality", paint_by_seed: "Paint by seed", color_seed: "Colour seed", palette: "Palette", driving: "Driving", surface: "Surface" },
       hints: {
         quality: "High: the kit at full detail. Light: fewer segments and no interior (the light mode of the fleet); applies to the vehicles placed from now on",
@@ -40462,7 +42274,8 @@ var GameVehiclesThree = (() => {
         vehicles_rollover: "Vehicles: roll over",
         vehicles_melt: "Vehicles: melt (long fire burns the tyres)",
         vehicles_drive_arcade: "Vehicles: arcade driving down a lane that ends in a wall",
-        vehicles_drive_semi: "Vehicles: semi-simulation braking on dry, wet and mud"
+        vehicles_drive_semi: "Vehicles: semi-simulation braking on dry, wet and mud",
+        vehicles_burnt_wreck: "Vehicles: the burnt sedan comes out of the kit burnt, with the glass gone"
       },
       checks: {
         windshield_holes: "Windshield: {0} hole(s), went through {1:b} (expected: 1, true)",
@@ -40487,13 +42300,15 @@ var GameVehiclesThree = (() => {
         arcade_bounce: "Arcade: the car bounces back at {0} m/s (expected: below 0)",
         arcade_noise: "Arcade: {0} engine noise(s) and {1} crash noise(s) (expected: 1 or more each)",
         semi_order: "Semi: braking from 80 km/h takes dry {0} m, wet {1} m, mud {2} m (expected: dry shorter than wet shorter than mud)",
-        semi_mud: "Semi: a 2WD car on mud {0:on} (expected: bogged on, a bog event)"
+        semi_mud: "Semi: a 2WD car on mud {0:on} (expected: bogged on, a bog event)",
+        wreck_burnt: "Burnt sedan: burnt flag {0:b} (expected: yes)",
+        wreck_glass: "Burnt sedan: {0} glass zone(s), {1} still above 0 (expected: 1 or more, none above 0)"
       }
     },
     "pt-BR": {
       group: "Ve\xEDculos",
       name: "\xC1rea de ve\xEDculos",
-      items: { hatch: "Hatch compacto", sedan: "Sed\xE3 m\xE9dio", pickup: "Picape m\xE9dia", sport_bike: "Moto esportiva", box_truck: "Caminh\xE3o ba\xFA", city_bus: "\xD4nibus urbano", battle_tank: "Tanque de guerra", attack_helicopter: "Helic\xF3ptero de ataque" },
+      items: { hatch: "Hatch compacto", sedan: "Sed\xE3 m\xE9dio", pickup: "Picape m\xE9dia", sport_bike: "Moto esportiva", box_truck: "Caminh\xE3o ba\xFA", city_bus: "\xD4nibus urbano", battle_tank: "Tanque de guerra", attack_helicopter: "Helic\xF3ptero de ataque", sedan_burnt: "Sed\xE3 queimado", hatch_burnt: "Hatch queimado" },
       controls: { quality: "Qualidade", paint_by_seed: "Pintar pela semente", color_seed: "Semente da cor", palette: "Paleta", driving: "Dire\xE7\xE3o", surface: "Piso" },
       hints: {
         quality: "Alta: o kit com todo o detalhe. Leve: menos segmentos e sem interior (o modo leve da frota); vale para os ve\xEDculos postos daqui em diante",
@@ -40526,7 +42341,8 @@ var GameVehiclesThree = (() => {
         vehicles_rollover: "Ve\xEDculos: capotar",
         vehicles_melt: "Ve\xEDculos: derreter (fogo longo queima os pneus)",
         vehicles_drive_arcade: "Ve\xEDculos: dire\xE7\xE3o arcade numa pista que acaba num muro",
-        vehicles_drive_semi: "Ve\xEDculos: frenagem da semissimula\xE7\xE3o no seco, no molhado e na lama"
+        vehicles_drive_semi: "Ve\xEDculos: frenagem da semissimula\xE7\xE3o no seco, no molhado e na lama",
+        vehicles_burnt_wreck: "Ve\xEDculos: o sed\xE3 queimado sai do kit queimado, sem os vidros"
       },
       checks: {
         windshield_holes: "Para-brisa: {0} furo(s), atravessou {1:b} (esperado: 1, sim)",
@@ -40551,7 +42367,9 @@ var GameVehiclesThree = (() => {
         arcade_bounce: "Arcade: o carro volta a {0} m/s (esperado: abaixo de 0)",
         arcade_noise: "Arcade: {0} ru\xEDdo(s) de motor e {1} de batida (esperado: 1 ou mais de cada)",
         semi_order: "Semi: frear de 80 km/h leva no seco {0} m, no molhado {1} m, na lama {2} m (esperado: seco menor que molhado menor que lama)",
-        semi_mud: "Semi: um carro 2WD na lama {0:on} (esperado: atolado, com evento de atolamento)"
+        semi_mud: "Semi: um carro 2WD na lama {0:on} (esperado: atolado, com evento de atolamento)",
+        wreck_burnt: "Sed\xE3 queimado: marca de queimado {0:b} (esperado: sim)",
+        wreck_glass: "Sed\xE3 queimado: {0} zona(s) de vidro, {1} ainda acima de 0 (esperado: 1 ou mais, nenhuma acima de 0)"
       }
     }
   };
@@ -40710,6 +42528,14 @@ var GameVehiclesThree = (() => {
         const t = part(room, v, "tyre_front_left");
         expect(events(room, "melt", v) >= 1 && (t.status === "melted" || t.melt > 0.5), say("tyre_melt", t.status, Math.round(t.melt * 100), events(room, "melt", v)));
       }),
+      // new in the kit: the burnt wreck comes ready from the kit (the fleet's `burnt` scenario built into the vehicle), no damage applied by the area
+      scenario("vehicles_burnt_wreck", ({ room, expect }) => {
+        const c = room.spawn("sedan_burnt", [0, 0, -7], 0).root.userData.vehicle;
+        expect(c.zoneState.flags.burnt === true, say("wreck_burnt", c.zoneState.flags.burnt === true));
+        const glass = c.zones.filter((z) => z.type === "glass");
+        const up = glass.filter((z) => (c.zoneState.health[z.id] ?? 100) > 0);
+        expect(glass.length >= 1 && up.length === 0, say("wreck_glass", glass.length, up.length));
+      }),
       // new in the kit: the drivers, headless (no vehicle is spawned)
       scenario("vehicles_drive_arcade", ({ expect }) => {
         const driver = createArcadeDriver();
@@ -40986,9 +42812,14 @@ var GameVehiclesThree = (() => {
     glass: "glass_burst",
     sparks: "impact_metal",
     leak: "vehicle_leak",
+    leakIgnited: "vehicle_leak_ignited",
     exhaust: "vehicle_exhaust"
   };
   var defaultSoundIds = { engine: "engine_saw", horn: "horn", crash: "sfx_impact" };
+  var DEFAULT_TEST_WRECKS = [
+    { key: "sedan_burnt", vehicle: "midsize_sedan", scenario: "burnt" },
+    { key: "hatch_burnt", vehicle: "compact_hatch", scenario: "burnt" }
+  ];
 
   // src/test-area/module.ts
   var VEHICLES_AREA_ID = "vehicles_area";
@@ -41002,6 +42833,8 @@ var GameVehiclesThree = (() => {
     const locale = options.locale ?? "pt-BR";
     const text = TEXT[locale] ?? TEXT["pt-BR"];
     const keys = options.vehicles ?? DEFAULT_TEST_VEHICLES;
+    const wrecks = options.wrecks ?? DEFAULT_TEST_WRECKS;
+    const entries = [...keys.map((key) => ({ key, id: itemId(key) })), ...wrecks.map((w) => ({ key: w.vehicle, id: w.key, scenario: w.scenario }))];
     const effectIds = { ...defaultEffectIds, ...options.effects };
     const soundIds = { ...defaultSoundIds, ...options.sounds };
     const settings = { quality: "high", paint: false, seed: 1, palette: "auto", driving: "arcade", surface: "dry_asphalt" };
@@ -41036,29 +42869,31 @@ var GameVehiclesThree = (() => {
     const paletteFor = (key) => settings.palette === "civil" ? paintPalettes.civil : settings.palette === "military" ? paintPalettes.military : paletteOf(key);
     const paintOf = (entry) => {
       if (!settings.paint) return;
-      const color = colorFromSeed(settings.seed + entry.index, paletteFor(entry.key));
+      const color2 = colorFromSeed(settings.seed + entry.index, paletteFor(entry.key));
       if (!entry.paint) {
         const vehicle = entry.item.vehicle;
         const primary = primaryPaint(entry.item.vehicle);
         if (!primary) return;
         entry.paint = primary.clone();
-        vehicle.vehicle.traverse((mesh) => {
-          if (!mesh.isMesh) return;
-          if (Array.isArray(mesh.material)) mesh.material = mesh.material.map((m) => m === primary ? entry.paint : m);
-          else if (mesh.material === primary) mesh.material = entry.paint;
+        vehicle.vehicle.traverse((mesh2) => {
+          if (!mesh2.isMesh) return;
+          if (Array.isArray(mesh2.material)) mesh2.material = mesh2.material.map((m) => m === primary ? entry.paint : m);
+          else if (mesh2.material === primary) mesh2.material = entry.paint;
         });
       }
-      entry.paint.color.set(color);
+      entry.paint.color.set(color2);
     };
-    const item = (key) => ({
-      id: itemId(key),
-      name: text.items[itemId(key)] ?? key,
+    const item = ({ key, id: itemKey, scenario }) => ({
+      id: itemKey,
+      name: text.items[itemKey] ?? key,
       movable: false,
+      // the first build of a vehicle takes most of a second
+      slow: true,
       build: (THREE) => {
         const kit = kitFor(THREE);
-        const built = buildVehicleItem(kit, key, { lod: settings.quality === "lite" });
+        const built = buildVehicleItem(kit, key, { lod: settings.quality === "lite", ...scenario ? { scenario } : {} });
         built.root.userData.kit = kit;
-        const entry = { root: built.root, key, item: built, index: counter++, helpers: [] };
+        const entry = { root: built.root, key, ...scenario ? { scenario } : {}, item: built, index: counter++, helpers: [] };
         placed.set(built.root.uuid, entry);
         measure(entry);
         paintOf(entry);
@@ -41067,7 +42902,7 @@ var GameVehiclesThree = (() => {
       impl: (root, id) => {
         const r = root;
         const kit = r.userData.kit;
-        const d = createVehicleDestructible(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemId(key)] ?? key });
+        const d = createVehicleDestructible(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemKey] ?? key });
         tapEffects(d);
         r.userData.destructible = d;
         return d;
@@ -41094,7 +42929,7 @@ var GameVehiclesThree = (() => {
         for (const e of events) {
           const position = e.point ?? e.worldPoint;
           if (!position) continue;
-          if (e.type === "ignite") fx.play({ effect: effectIds.ignite, point: position });
+          if (e.type === "ignite") fx.play({ effect: /fuel_tank|tank/.test(e.part ?? "") ? effectIds.leakIgnited : effectIds.ignite, point: position });
           else if (e.type === "explode") fx.play({ effect: effectIds.explode, point: position });
           else if (e.type === "leak") fx.play({ effect: effectIds.leak, point: position });
           else if (e.type === "fracture" && /glass|window|windshield/.test(e.part ?? "")) fx.play({ effect: effectIds.glass, point: position });
@@ -41127,12 +42962,12 @@ var GameVehiclesThree = (() => {
       const bounds = new three.Box3();
       const piece = new three.Box3();
       const matrix = new three.Matrix4();
-      entry.root.traverse((mesh) => {
-        if (!mesh.isMesh || !mesh.geometry || mesh.userData.ghost) return;
-        for (let p = mesh; p; p = p.parent) if (p.visible === false) return;
-        if (mesh.userData.helper) return;
-        mesh.geometry.computeBoundingBox();
-        piece.copy(mesh.geometry.boundingBox).applyMatrix4(matrix.multiplyMatrices(inverse, mesh.matrixWorld));
+      entry.root.traverse((mesh2) => {
+        if (!mesh2.isMesh || !mesh2.geometry || mesh2.userData.ghost) return;
+        for (let p = mesh2; p; p = p.parent) if (p.visible === false) return;
+        if (mesh2.userData.helper) return;
+        mesh2.geometry.computeBoundingBox();
+        piece.copy(mesh2.geometry.boundingBox).applyMatrix4(matrix.multiplyMatrices(inverse, mesh2.matrixWorld));
         bounds.union(piece);
       });
       const size = bounds.getSize(new three.Vector3());
@@ -41153,8 +42988,8 @@ var GameVehiclesThree = (() => {
       if (!host?.bench || !three) return;
       clearHelpers();
       const kit = [...placed.values()][0] && ([...placed.values()][0].root.userData.kit ?? void 0);
-      const mark = (entry, box, color) => {
-        const helper = new three.Box3Helper(box, color);
+      const mark = (entry, box2, color2) => {
+        const helper = new three.Box3Helper(box2, color2);
         helper.userData.helper = true;
         entry.root.add(helper);
         entry.helpers.push(helper);
@@ -41168,8 +43003,8 @@ var GameVehiclesThree = (() => {
           if (host.bench.layer("zones")) {
             for (const zone of entry.item.vehicle.zones ?? []) {
               if (!zone.box || zone.type === "internal") continue;
-              const box = new three.Box3(new three.Vector3(zone.box.x0, zone.box.y0, zone.box.z0), new three.Vector3(zone.box.x1, zone.box.y1, zone.box.z1)).applyMatrix4(matrix);
-              mark(entry, box, ZONE_COLOURS[zone.type] ?? 16777215);
+              const box2 = new three.Box3(new three.Vector3(zone.box.x0, zone.box.y0, zone.box.z0), new three.Vector3(zone.box.x1, zone.box.y1, zone.box.z1)).applyMatrix4(matrix);
+              mark(entry, box2, ZONE_COLOURS[zone.type] ?? 16777215);
             }
           }
         }
@@ -41318,11 +43153,11 @@ var GameVehiclesThree = (() => {
       let drawCalls = 0;
       let triangles = 0;
       for (const entry of placed.values()) {
-        entry.root.traverse((mesh) => {
-          if (!mesh.isMesh || mesh.userData.helper) return;
-          for (let p = mesh; p; p = p.parent) if (p.visible === false) return;
+        entry.root.traverse((mesh2) => {
+          if (!mesh2.isMesh || mesh2.userData.helper) return;
+          for (let p = mesh2; p; p = p.parent) if (p.visible === false) return;
           drawCalls += 1;
-          const g = mesh.geometry;
+          const g = mesh2.geometry;
           triangles += (g.index ? g.index.count : g.attributes.position.count) / 3;
         });
       }
@@ -41341,7 +43176,7 @@ var GameVehiclesThree = (() => {
       for (const entry of placed.values()) {
         const want = fleetDims(entry.key);
         const got = entry.size;
-        if (!want || !got) continue;
+        if (!want || !got || entry.scenario) continue;
         worst = Math.max(worst, Math.abs(got.length - want.length), Math.abs(got.width - want.width), Math.abs(got.height - want.height));
       }
       return Math.round(worst * 1e3);
@@ -41353,23 +43188,23 @@ var GameVehiclesThree = (() => {
       get placed() {
         return placed;
       },
-      items: () => keys.map(item),
+      items: () => entries.map(item),
       area: () => {
         const gap = 1.6;
         const WIDE = 6;
-        const rowOf = (list, z) => {
+        const rowOf = (list2, z) => {
           let cursor = 0;
-          const spots = list.map((key) => {
-            const width = fleetDims(key)?.width ?? 2;
+          const spots = list2.map((entry) => {
+            const width = fleetDims(entry.key)?.width ?? 2;
             const x = cursor + width / 2;
             cursor += width + gap;
-            return { key, x };
+            return { id: entry.id, x };
           });
           return { spots, z, width: Math.max(0, cursor - gap) };
         };
-        const front = rowOf(keys.filter((key) => (fleetDims(key)?.width ?? 2) <= WIDE), 0);
-        const back = rowOf(keys.filter((key) => (fleetDims(key)?.width ?? 2) > WIDE), -16);
-        const placements = [front, back].flatMap((row) => row.spots.map(({ key, x }) => ({ item: itemId(key), position: [x - row.width / 2, 0, row.z], rotationY: 0 })));
+        const front = rowOf(entries.filter((e) => (fleetDims(e.key)?.width ?? 2) <= WIDE), 0);
+        const back = rowOf(entries.filter((e) => (fleetDims(e.key)?.width ?? 2) > WIDE), -16);
+        const placements = [front, back].flatMap((row) => row.spots.map(({ id, x }) => ({ item: id, position: [x - row.width / 2, 0, row.z], rotationY: 0 })));
         return { placements, view: { eye: [0, 5, Math.max(14, front.width * 0.6)], target: [0, 1, -2] } };
       },
       controls: () => {