@adatechnology/game-vehicles 0.4.4 → 0.4.6

package/dist/index.js

@@ -661,7 +661,7 @@ function installMaterials(kit) {
   const I = kit._;
   const document2 = kit.document;
   const RUST = new THREE.Color("#5e3220");
-  const cache = {};
+  const cache2 = {};
   let envTex = null;
   function studioEnvironment() {
     if (envTex) return envTex;
@@ -706,7 +706,7 @@ function installMaterials(kit) {
     const key = "s" + c.getHexString() + JSON.stringify(o, function(k, v) {
       return v && v.isColor ? "#" + v.getHexString() : v && v.isTexture ? v.uuid : v;
     });
-    if (!cache[key]) {
+    if (!cache2[key]) {
       const o2 = Object.assign({}, o);
       delete o2.noEnv;
       const mt = new THREE.MeshStandardMaterial(Object.assign({ color: c, roughness: 0.8, metalness: 0, flatShading: false }, o2));
@@ -714,9 +714,9 @@ function installMaterials(kit) {
         mt.envMap = studioEnvironment();
         if (o.envMapIntensity == null) mt.envMapIntensity = 0.55 + (mt.metalness - 0.6) * 1.6;
       }
-      cache[key] = mt;
+      cache2[key] = mt;
     }
-    return cache[key];
+    return cache2[key];
   }
   function makeFlatMaterial(color, o) {
     return makeMaterial(color, Object.assign({ flatShading: true, roughness: 0.92 }, o || {}));
@@ -831,7 +831,131 @@ function installMaterials(kit) {
     return t;
   }
   kit.textTexture = textTexture;
-  Object.assign(I, { RUST, cache, studioEnvironment, makeMaterial, makeFlatMaterial, DOUBLE_SIDE, toColor, MATERIALS, paintColor, texCache, textTexture });
+  Object.assign(I, { RUST, cache: cache2, studioEnvironment, makeMaterial, makeFlatMaterial, DOUBLE_SIDE, toColor, MATERIALS, paintColor, texCache, textTexture });
+}
+
+// src/tri-index.ts
+var TRI_BLOCK = 32;
+var cache = /* @__PURE__ */ new WeakMap();
+function trianglesOf(geo) {
+  return Math.floor((geo.index ? geo.index.count : geo.attributes.position.count) / 3);
+}
+function supports(geo) {
+  const pos = geo.attributes && geo.attributes.position;
+  return !!pos && !pos.isInterleavedBufferAttribute && pos.itemSize === 3;
+}
+function isCurrent(geo, ti) {
+  const pos = geo.attributes.position;
+  return ti.position === pos && ti.positionVersion === pos.version && ti.index === (geo.index || null) && ti.indexVersion === (geo.index ? geo.index.version : 0) && ti.triangles === trianglesOf(geo);
+}
+function blockCount(triangles) {
+  return Math.ceil(triangles / TRI_BLOCK);
+}
+function boxBlock(ti, block) {
+  const B = ti.boxes;
+  const t0 = block * TRI_BLOCK;
+  const t1 = Math.min(ti.triangles, t0 + TRI_BLOCK);
+  const o = block * 6;
+  for (let k = 0; k < 3; k++) {
+    ti.blocks[o + k] = Infinity;
+    ti.blocks[o + 3 + k] = -Infinity;
+  }
+  for (let t = t0; t < t1; t++) {
+    const j = t * 6;
+    for (let k = 0; k < 3; k++) {
+      if (B[j + k] < ti.blocks[o + k]) ti.blocks[o + k] = B[j + k];
+      if (B[j + 3 + k] > ti.blocks[o + 3 + k]) ti.blocks[o + 3 + k] = B[j + 3 + k];
+    }
+  }
+}
+function boxTriangle(geo, ti, t) {
+  const P = geo.attributes.position.array;
+  const ix = geo.index ? geo.index.array : null;
+  const a = (ix ? ix[t * 3] : t * 3) * 3;
+  const b = (ix ? ix[t * 3 + 1] : t * 3 + 1) * 3;
+  const c = (ix ? ix[t * 3 + 2] : t * 3 + 2) * 3;
+  const j = t * 6;
+  for (let k = 0; k < 3; k++) {
+    ti.boxes[j + k] = Math.min(P[a + k], P[b + k], P[c + k]);
+    ti.boxes[j + 3 + k] = Math.max(P[a + k], P[b + k], P[c + k]);
+  }
+}
+function advance(geo, ti, deadline) {
+  const total = blockCount(ti.triangles);
+  while (ti.builtBlocks < total) {
+    const block = ti.builtBlocks;
+    const t1 = Math.min(ti.triangles, (block + 1) * TRI_BLOCK);
+    for (let t = block * TRI_BLOCK; t < t1; t++) boxTriangle(geo, ti, t);
+    boxBlock(ti, block);
+    ti.builtBlocks++;
+    if (deadline !== Infinity && performance.now() >= deadline) break;
+  }
+  return ti.builtBlocks === total;
+}
+function start(geo) {
+  const pos = geo.attributes.position;
+  const triangles = trianglesOf(geo);
+  const ti = {
+    position: pos,
+    positionVersion: pos.version,
+    index: geo.index || null,
+    indexVersion: geo.index ? geo.index.version : 0,
+    triangles,
+    boxes: new Float64Array(triangles * 6),
+    blocks: new Float64Array(blockCount(triangles) * 6),
+    builtBlocks: 0
+  };
+  cache.set(geo, ti);
+  return ti;
+}
+function triIndexOf(geo) {
+  if (!supports(geo)) return void 0;
+  let ti = cache.get(geo);
+  if (!ti || !isCurrent(geo, ti)) ti = start(geo);
+  advance(geo, ti, Infinity);
+  return ti;
+}
+function warmTriIndex(geo, deadline) {
+  if (!supports(geo)) return true;
+  let ti = cache.get(geo);
+  if (!ti || !isCurrent(geo, ti)) ti = start(geo);
+  return advance(geo, ti, deadline);
+}
+function storeTriIndex(geo, boxes) {
+  const ti = start(geo);
+  ti.boxes = boxes;
+  const total = blockCount(ti.triangles);
+  for (let b = 0; b < total; b++) boxBlock(ti, b);
+  ti.builtBlocks = total;
+}
+function liveTriIndex(geo) {
+  if (geo.index || !supports(geo)) return void 0;
+  const ti = cache.get(geo);
+  return ti && isCurrent(geo, ti) && ti.builtBlocks === blockCount(ti.triangles) ? ti : void 0;
+}
+function touchTriIndex(geo, ti, vertices) {
+  if (ti.positionVersion + 1 !== geo.attributes.position.version) return;
+  const blocks = /* @__PURE__ */ new Set();
+  for (const v of vertices) {
+    const t = Math.floor(v / 3);
+    if (t >= ti.triangles) continue;
+    boxTriangle(geo, ti, t);
+    blocks.add(Math.floor(t / TRI_BLOCK));
+  }
+  blocks.forEach((b) => boxBlock(ti, b));
+  ti.positionVersion = geo.attributes.position.version;
+}
+function boundsFromIndex(geo) {
+  if (geo.index || !supports(geo)) return void 0;
+  const ti = cache.get(geo);
+  if (!ti || !isCurrent(geo, ti) || ti.builtBlocks !== blockCount(ti.triangles) || !ti.triangles || geo.attributes.position.count !== ti.triangles * 3) return void 0;
+  const box = new Float64Array([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity]);
+  for (let b = 0, n = blockCount(ti.triangles); b < n; b++)
+    for (let k = 0; k < 3; k++) {
+      box[k] = Math.min(box[k], ti.blocks[b * 6 + k]);
+      box[3 + k] = Math.max(box[3 + k], ti.blocks[b * 6 + 3 + k]);
+    }
+  return { box, version: ti.positionVersion };
 }
 
 // src/geometry.ts
@@ -928,7 +1052,8 @@ function installGeometry(kit) {
     g.userData.crease = true;
     return g;
   }
-  function crease(geo, deg) {
+  const latestCrease = /* @__PURE__ */ new WeakMap();
+  function creaseTask(geo, deg) {
     if (geo.index) {
       const ni = geo.toNonIndexed();
       Object.keys(ni.attributes).forEach(function(k) {
@@ -936,30 +1061,22 @@ function installGeometry(kit) {
       });
       geo.setIndex(null);
     }
-    const p = geo.attributes.position;
-    const n = p.count;
+    const P = geo.attributes.position.array;
+    const n = geo.attributes.position.count;
     const faces = n / 3;
     const FN = new Float64Array(faces * 3);
-    const map = /* @__PURE__ */ new Map();
-    const RANGE = 65536;
-    function key(i) {
-      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);
+    const out = new Float32Array(n * 3);
     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 o = 9 * f;
+      const ax = P[o];
+      const ay = P[o + 1];
+      const az = P[o + 2];
+      const bx = P[o + 3];
+      const by = P[o + 4];
+      const bz = P[o + 5];
+      const cx = P[o + 6];
+      const cy = P[o + 7];
+      const cz = P[o + 8];
       const e1x = cx - bx;
       const e1y = cy - by;
       const e1z = cz - bz;
@@ -979,41 +1096,109 @@ function installGeometry(kit) {
       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;
-        const list = map.get(kk);
-        if (list) list.push(f);
-        else map.set(kk, [f]);
+        out[9 * f + 3 * k] = nx;
+        out[9 * f + 3 * k + 1] = ny;
+        out[9 * f + 3 * k + 2] = nz;
+      }
+    }
+    const normal = new THREE.BufferAttribute(out, 3);
+    geo.setAttribute("normal", normal);
+    const token = {};
+    latestCrease.set(geo, token);
+    let size = 16;
+    while (size < n * 2) size *= 2;
+    const mask = size - 1;
+    const slot = new Int32Array(size).fill(-1);
+    const gx = new Int32Array(n);
+    const gy = new Int32Array(n);
+    const gz = new Int32Array(n);
+    const groupOf = new Int32Array(n);
+    let groups = 0;
+    let start2;
+    let members;
+    const cs = Math.cos(deg * PI / 180);
+    let phase = 0;
+    let at = 0;
+    function hashSlice(deadline) {
+      for (; at < n; at++) {
+        if ((at & 1023) === 0 && performance.now() > deadline) return false;
+        const x = Math.round(P[3 * at] * 2e3) | 0;
+        const y = Math.round(P[3 * at + 1] * 2e3) | 0;
+        const z = Math.round(P[3 * at + 2] * 2e3) | 0;
+        let h = (Math.imul(x, 73856093) ^ Math.imul(y, 19349663) ^ Math.imul(z, 83492791)) & mask;
+        let g = slot[h];
+        while (g >= 0 && (gx[g] !== x || gy[g] !== y || gz[g] !== z)) {
+          h = h + 1 & mask;
+          g = slot[h];
+        }
+        if (g < 0) {
+          g = groups++;
+          slot[h] = g;
+          gx[g] = x;
+          gy[g] = y;
+          gz[g] = z;
+        }
+        groupOf[at] = g;
       }
+      return true;
     }
-    const cs = Math.cos(deg * PI / 180);
-    const out = new Float32Array(n * 3);
-    for (let i = 0; i < n; i++) {
-      const fi = (i / 3 | 0) * 3;
-      const list = map.get(keys[i]);
-      let sx = 0;
-      let sy = 0;
-      let sz = 0;
-      for (let j = 0; j < list.length; j++) {
-        const g = list[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];
+    function gather() {
+      start2 = new Int32Array(groups + 1);
+      for (let i = 0; i < n; i++) start2[groupOf[i] + 1]++;
+      for (let g = 0; g < groups; g++) start2[g + 1] += start2[g];
+      const fill = start2.slice(0, groups);
+      members = new Int32Array(n);
+      for (let i = 0; i < n; i++) members[fill[groupOf[i]]++] = i / 3 | 0;
+    }
+    function smoothSlice(deadline) {
+      for (; at < n; at++) {
+        if ((at & 1023) === 0 && performance.now() > deadline) return false;
+        const fi = (at / 3 | 0) * 3;
+        const g = groupOf[at];
+        let sx = 0;
+        let sy = 0;
+        let sz = 0;
+        for (let j = start2[g], end = start2[g + 1]; j < end; j++) {
+          const o = members[j] * 3;
+          if (FN[o] * FN[fi] + FN[o + 1] * FN[fi + 1] + FN[o + 2] * FN[fi + 2] >= cs) {
+            sx += FN[o];
+            sy += FN[o + 1];
+            sz += FN[o + 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 * at] = sx * inv;
+        out[3 * at + 1] = sy * inv;
+        out[3 * at + 2] = sz * inv;
       }
-      if (sx * sx + sy * sy + sz * sz < 1e-20) {
-        sx = FN[fi];
-        sy = FN[fi + 1];
-        sz = FN[fi + 2];
+      return true;
+    }
+    function step(deadline) {
+      if (latestCrease.get(geo) !== token) return true;
+      if (phase === 0) {
+        if (!hashSlice(deadline)) return false;
+        gather();
+        phase = 1;
+        at = 0;
+      }
+      if (phase === 1) {
+        const done = smoothSlice(deadline);
+        if (deadline !== Infinity) normal.needsUpdate = true;
+        if (!done) return false;
+        phase = 2;
+        geo.userData.crease = true;
       }
-      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;
+      return true;
     }
-    geo.setAttribute("normal", new THREE.BufferAttribute(out, 3));
-    geo.userData.crease = true;
+    return { geo, step };
+  }
+  function crease(geo, deg) {
+    creaseTask(geo, deg).step(Infinity);
     return geo;
   }
   function pathShape(items) {
@@ -1160,28 +1345,28 @@ function installGeometry(kit) {
     return g;
   }
   function cutGeometry(geo, tests) {
-    const src = geo.index ? geo.toNonIndexed() : geo;
+    const idx = geo.index ? geo.index.array : null;
     const names = ["position"].concat(
       ["color", "uv"].filter(function(n2) {
-        return !!src.attributes[n2];
+        return !!geo.attributes[n2];
       })
     );
     const sizes = names.map(function(n2) {
-      return src.attributes[n2].itemSize;
+      return geo.attributes[n2].itemSize;
     });
     const arrs = names.map(function(n2) {
-      return src.attributes[n2].array;
+      return geo.attributes[n2].array;
     });
-    const nv = src.attributes.position.count;
-    let tris = [];
-    for (let f = 0; f < nv; f += 3) {
+    const nv = idx ? idx.length : geo.attributes.position.count;
+    function readTri(f) {
       const t = [];
       for (let k = 0; k < 3; k++) {
+        const vi = idx ? idx[f + k] : f + k;
         const v = [];
-        for (let a = 0; a < names.length; a++) for (let q = 0; q < sizes[a]; q++) v.push(arrs[a][(f + k) * sizes[a] + q]);
+        for (let a = 0; a < names.length; a++) for (let q = 0; q < sizes[a]; q++) v.push(arrs[a][vi * sizes[a] + q]);
         t.push(v);
       }
-      tris.push(t);
+      return t;
     }
     const cut = {};
     const n = new V3();
@@ -1207,60 +1392,177 @@ function installGeometry(kit) {
     function fan(poly, arr) {
       for (let i = 1; i < poly.length - 1; i++) arr.push([poly[0], poly[i], poly[i + 1]]);
     }
-    tests.forEach(function(T) {
-      const next = [];
+    function testTri(T, t, next, rem) {
+      const A = t[0];
+      const B = t[1];
+      const C = t[2];
+      e1.set(B[0] - A[0], B[1] - A[1], B[2] - A[2]);
+      e2.set(C[0] - A[0], C[1] - A[1], C[2] - A[2]);
+      n.crossVectors(e1, e2);
+      const len = n.length();
+      if (len < 1e-12) {
+        next.push(t);
+        return;
+      }
+      n.multiplyScalar(1 / len);
+      ce.set((A[0] + B[0] + C[0]) / 3, (A[1] + B[1] + C[1]) / 3, (A[2] + B[2] + C[2]) / 3);
+      if (T.sel && !T.sel(n, ce)) {
+        next.push(t);
+        return;
+      }
+      const d = [T.sdf(A[0], A[1], A[2]), T.sdf(B[0], B[1], B[2]), T.sdf(C[0], C[1], C[2])];
+      const ins = (d[0] < 0 ? 1 : 0) + (d[1] < 0 ? 1 : 0) + (d[2] < 0 ? 1 : 0);
+      if (ins === 0) next.push(t);
+      else if (ins === 3) {
+        if (rem) rem.push(t);
+      } else {
+        fan(clip(t, d, 1), next);
+        if (rem) fan(clip(t, d, -1), rem);
+      }
+    }
+    const segments = [];
+    let total = 0;
+    const ti = tests.length === 1 && tests[0].bounds ? triIndexOf(geo) : void 0;
+    if (ti) {
+      const T = tests[0];
+      const lo = T.bounds.lo;
+      const hi = T.bounds.hi;
       const rem = T.tag ? cut[T.tag] = cut[T.tag] || [] : null;
-      tris.forEach(function(t) {
-        const A = t[0];
-        const B = t[1];
-        const C = t[2];
-        e1.set(B[0] - A[0], B[1] - A[1], B[2] - A[2]);
-        e2.set(C[0] - A[0], C[1] - A[1], C[2] - A[2]);
-        n.crossVectors(e1, e2);
-        const len = n.length();
-        if (len < 1e-12) {
-          next.push(t);
-          return;
-        }
-        n.multiplyScalar(1 / len);
-        ce.set((A[0] + B[0] + C[0]) / 3, (A[1] + B[1] + C[1]) / 3, (A[2] + B[2] + C[2]) / 3);
-        if (T.sel && !T.sel(n, ce)) {
-          next.push(t);
-          return;
+      const boxes = ti.boxes;
+      const blocks = ti.blocks;
+      let runFrom = -1;
+      const closeRun = function(end) {
+        if (runFrom < 0) return;
+        segments.push([runFrom, end]);
+        total += end - runFrom;
+        runFrom = -1;
+      };
+      for (let blk = 0, t0 = 0; t0 < ti.triangles; blk++, t0 += TRI_BLOCK) {
+        const j = blk * 6;
+        if (blocks[j + 3] < lo[0] || blocks[j] > hi[0] || blocks[j + 4] < lo[1] || blocks[j + 1] > hi[1] || blocks[j + 5] < lo[2] || blocks[j + 2] > hi[2]) {
+          if (runFrom < 0) runFrom = t0;
+          continue;
         }
-        const d = [T.sdf(A[0], A[1], A[2]), T.sdf(B[0], B[1], B[2]), T.sdf(C[0], C[1], C[2])];
-        const ins = (d[0] < 0 ? 1 : 0) + (d[1] < 0 ? 1 : 0) + (d[2] < 0 ? 1 : 0);
-        if (ins === 0) next.push(t);
-        else if (ins === 3) {
-          if (rem) rem.push(t);
-        } else {
-          fan(clip(t, d, 1), next);
-          if (rem) fan(clip(t, d, -1), rem);
+        const t1 = Math.min(ti.triangles, t0 + TRI_BLOCK);
+        for (let t = t0; t < t1; t++) {
+          const q = t * 6;
+          if (boxes[q + 3] < lo[0] || boxes[q] > hi[0] || boxes[q + 4] < lo[1] || boxes[q + 1] > hi[1] || boxes[q + 5] < lo[2] || boxes[q + 2] > hi[2]) {
+            if (runFrom < 0) runFrom = t;
+            continue;
+          }
+          closeRun(t);
+          const next = [];
+          testTri(T, readTri(t * 3), next, rem);
+          if (next.length) {
+            segments.push(next);
+            total += next.length;
+          }
         }
+      }
+      closeRun(ti.triangles);
+    } else {
+      let tris = [];
+      for (let f = 0; f < nv; f += 3) tris.push(readTri(f));
+      tests.forEach(function(T) {
+        const next = [];
+        const rem = T.tag ? cut[T.tag] = cut[T.tag] || [] : null;
+        tris.forEach(function(t) {
+          testTri(T, t, next, rem);
+        });
+        tris = next;
       });
-      tris = next;
-    });
-    function build(list) {
+      segments.push(tris);
+      total = tris.length;
+    }
+    function fill(segs, count, boxesOut2) {
       const g = new THREE.BufferGeometry();
-      let off = 0;
-      names.forEach(function(nm, a) {
-        const arr = new Float32Array(list.length * 3 * sizes[a]);
-        let w = 0;
-        list.forEach(function(t) {
-          for (let k = 0; k < 3; k++) for (let q = 0; q < sizes[a]; q++) arr[w++] = t[k][off + q];
+      const dst = names.map(function(_nm, a) {
+        return new Float32Array(count * 3 * sizes[a]);
+      });
+      const w = names.map(function() {
+        return 0;
+      });
+      let wb = 0;
+      segs.forEach(function(seg) {
+        if (typeof seg[0] === "number") {
+          for (let a = 0; a < names.length; a++) {
+            const size = sizes[a];
+            if (!idx) {
+              dst[a].set(arrs[a].subarray(seg[0] * 3 * size, seg[1] * 3 * size), w[a]);
+              w[a] += (seg[1] - seg[0]) * 3 * size;
+              continue;
+            }
+            for (let f = seg[0] * 3; f < seg[1] * 3; f++) for (let q = 0; q < size; q++) dst[a][w[a]++] = arrs[a][idx[f] * size + q];
+          }
+          if (boxesOut2 && ti) {
+            boxesOut2.set(ti.boxes.subarray(seg[0] * 6, seg[1] * 6), wb);
+            wb += (seg[1] - seg[0]) * 6;
+          }
+          return;
+        }
+        seg.forEach(function(t) {
+          if (boxesOut2) {
+            for (let k = 0; k < 3; k++) {
+              boxesOut2[wb + k] = Math.fround(Math.min(t[0][k], t[1][k], t[2][k]));
+              boxesOut2[wb + 3 + k] = Math.fround(Math.max(t[0][k], t[1][k], t[2][k]));
+            }
+            wb += 6;
+          }
+          let off = 0;
+          for (let a = 0; a < names.length; a++) {
+            for (let k = 0; k < 3; k++) for (let q = 0; q < sizes[a]; q++) dst[a][w[a]++] = t[k][off + q];
+            off += sizes[a];
+          }
         });
-        g.setAttribute(nm, new THREE.BufferAttribute(arr, sizes[a]));
-        off += sizes[a];
+      });
+      names.forEach(function(nm, a) {
+        g.setAttribute(nm, new THREE.BufferAttribute(dst[a], sizes[a]));
       });
       g.userData.crease = true;
       return g;
     }
-    const out = { geo: build(tris), cut: {} };
+    const boxesOut = ti ? new Float64Array(total * 6) : void 0;
+    const out = { geo: fill(segments, total, boxesOut), cut: {}, tasks: {} };
+    if (boxesOut) storeTriIndex(out.geo, boxesOut);
     Object.keys(cut).forEach(function(k) {
-      out.cut[k] = crease(build(cut[k]), 42);
+      const piece = fill([cut[k]], cut[k].length);
+      const mode = tests.find(function(T) {
+        return T.tag === k;
+      }).pieces;
+      if (mode === "none") out.cut[k] = piece;
+      else if (mode === "later") {
+        out.cut[k] = piece;
+        out.tasks[k] = creaseTask(piece, 42);
+      } else out.cut[k] = crease(piece, 42);
     });
     return out;
   }
+  function refreshBounds(geo) {
+    const found = boundsFromIndex(geo);
+    if (!found) {
+      geo.computeBoundingSphere();
+      geo.computeBoundingBox();
+      return;
+    }
+    if (geo.boundingBox && geo.boundingSphere && boundsDone.get(geo) === found.version) return;
+    const b = found.box;
+    if (!geo.boundingBox) geo.boundingBox = new THREE.Box3();
+    geo.boundingBox.min.set(b[0], b[1], b[2]);
+    geo.boundingBox.max.set(b[3], b[4], b[5]);
+    if (!geo.boundingSphere) geo.boundingSphere = new THREE.Sphere();
+    const center = geo.boundingBox.getCenter(geo.boundingSphere.center);
+    const P = geo.attributes.position.array;
+    let maxRadiusSq = 0;
+    for (let i = 0; i < P.length; i += 3) {
+      const dx = center.x - P[i];
+      const dy = center.y - P[i + 1];
+      const dz = center.z - P[i + 2];
+      maxRadiusSq = Math.max(maxRadiusSq, dx * dx + dy * dy + dz * dz);
+    }
+    geo.boundingSphere.radius = Math.sqrt(maxRadiusSq);
+    boundsDone.set(geo, found.version);
+  }
+  const boundsDone = /* @__PURE__ */ new WeakMap();
   function mergeGeometries(list) {
     const pos = [];
     const nor = [];
@@ -1391,7 +1693,7 @@ function installGeometry(kit) {
       }
     };
   };
-  Object.assign(I, { roundedBoxGeometry, taper, subdivide, crease, pathShape, tumble, loftGeometry, hullGeometry, cutGeometry, mergeGeometries, uvProject });
+  Object.assign(I, { roundedBoxGeometry, taper, subdivide, crease, creaseTask, refreshBounds, pathShape, tumble, loftGeometry, hullGeometry, cutGeometry, mergeGeometries, uvProject });
 }
 
 // src/context.ts
@@ -6721,6 +7023,8 @@ function installZoneDecals(kit) {
     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;
   }
+  let _keep = new Uint32Array(0);
+  let _box = new Float32Array(0);
   function proxyIn(o, Mw, R) {
     _pm.copy(o.matrixWorld).invert().multiply(Mw);
     const lo = [Infinity, Infinity, Infinity];
@@ -6733,39 +7037,48 @@ function installZoneDecals(kit) {
       }
     }
     const g = o.geometry;
-    const P = g.attributes.position.array;
+    const ti = triIndexOf(g);
+    if (!ti) return null;
     const ix = g.index ? g.index.array : null;
-    const n = ix ? ix.length : P.length / 3;
-    const keep = new Uint32Array(n - n % 3);
+    const boxes = ti.boxes;
+    const blocks = ti.blocks;
+    if (_keep.length < ti.triangles * 3) {
+      _keep = new Uint32Array(ti.triangles * 3);
+      _box = new Float32Array(ti.triangles * 6);
+    }
+    const keep = _keep;
+    const box = _box;
     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;
+    let nt = 0;
+    for (let blk = 0, t0 = 0; t0 < ti.triangles; blk++, t0 += TRI_BLOCK) {
+      const j = blk * 6;
+      if (blocks[j + 3] < lo[0] || blocks[j] > hi[0] || blocks[j + 4] < lo[1] || blocks[j + 1] > hi[1] || blocks[j + 5] < lo[2] || blocks[j + 2] > hi[2]) continue;
+      const t1 = Math.min(ti.triangles, t0 + TRI_BLOCK);
+      for (let t = t0; t < t1; t++) {
+        const q = t * 6;
+        if (boxes[q + 3] < lo[0] || boxes[q] > hi[0] || boxes[q + 4] < lo[1] || boxes[q + 1] > hi[1] || boxes[q + 5] < lo[2] || boxes[q + 2] > hi[2]) continue;
+        keep[nk++] = ix ? ix[t * 3] : t * 3;
+        keep[nk++] = ix ? ix[t * 3 + 1] : t * 3 + 1;
+        keep[nk++] = ix ? ix[t * 3 + 2] : t * 3 + 2;
+        for (let k = 0; k < 6; k++) box[nt * 6 + k] = boxes[q + k];
+        nt++;
       }
     }
     if (!nk) return null;
     const kept = keep.slice(0, nk);
-    const box = 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;
+    const keptBox = box.slice(0, nt * 6);
+    const keptBlocks = new Float32Array(Math.ceil(nt / TRI_BLOCK) * 6);
+    for (let blk = 0; blk * TRI_BLOCK < nt; blk++) {
+      const b = blk * 6;
       for (let k = 0; k < 3; k++) {
-        box[j + k] = Math.min(P[a + k], P[b + k], P[d + k]);
-        box[j + 3 + k] = Math.max(P[a + k], P[b + k], P[d + k]);
+        keptBlocks[b + k] = Infinity;
+        keptBlocks[b + 3 + k] = -Infinity;
       }
+      for (let t = blk * TRI_BLOCK, t1 = Math.min(nt, t + TRI_BLOCK); t < t1; t++)
+        for (let k = 0; k < 3; k++) {
+          if (keptBox[t * 6 + k] < keptBlocks[b + k]) keptBlocks[b + k] = keptBox[t * 6 + k];
+          if (keptBox[t * 6 + 3 + k] > keptBlocks[b + 3 + k]) keptBlocks[b + 3 + k] = keptBox[t * 6 + 3 + k];
+        }
     }
     const pg = new THREE.BufferGeometry();
     pg.setAttribute("position", g.attributes.position);
@@ -6776,7 +7089,8 @@ function installZoneDecals(kit) {
     proxy.layers.mask = o.layers.mask;
     proxy.proxyOf = o;
     proxy.kept = kept;
-    proxy.keptBox = box;
+    proxy.keptBox = keptBox;
+    proxy.keptBlocks = keptBlocks;
     return proxy;
   }
   function narrowTo(rc, proxy) {
@@ -6796,13 +7110,21 @@ function installZoneDecals(kit) {
     const hi2 = Math.max(z0, _pv.z) + 1e-4;
     const K = proxy.kept;
     const X = proxy.keptBox;
+    const KB = proxy.keptBlocks;
+    const nt = K.length / 3;
     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];
+    for (let blk = 0, t0 = 0; t0 < nt; blk++, t0 += TRI_BLOCK) {
+      const b = blk * 6;
+      if (KB[b + 3] < lo0 || KB[b] > hi0 || KB[b + 4] < lo1 || KB[b + 1] > hi1 || KB[b + 5] < lo2 || KB[b + 2] > hi2) continue;
+      const t1 = Math.min(nt, t0 + TRI_BLOCK);
+      for (let t = t0; t < t1; t++) {
+        const j = t * 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 * 3];
+        dst[m++] = K[t * 3 + 1];
+        dst[m++] = K[t * 3 + 2];
+      }
     }
     proxy.geometry.setDrawRange(0, m);
   }
@@ -7220,6 +7542,8 @@ function installZoneDent(kit) {
       irel.copy(rel).invert();
       const pos = g.attributes.position;
       let changed = false;
+      const liveIndex = liveTriIndex(g);
+      const movedVertices = [];
       const near = boxInFrame(B, irel, v);
       for (let i = 0; i < pos.count; i++) {
         v.fromBufferAttribute(pos, i);
@@ -7231,6 +7555,7 @@ function installZoneDent(kit) {
         if (opt.extra) opt.extra(v, f);
         v.applyMatrix4(irel);
         pos.setXYZ(i, v.x, v.y, v.z);
+        movedVertices.push(i);
         changed = true;
       }
       if (opt.extraAll) {
@@ -7239,12 +7564,14 @@ function installZoneDent(kit) {
           if (opt.extraAll(v)) {
             v.applyMatrix4(irel);
             pos.setXYZ(j, v.x, v.y, v.z);
+            movedVertices.push(j);
             changed = true;
           }
         }
       }
       if (changed) {
         pos.needsUpdate = true;
+        if (liveIndex) touchTriIndex(g, liveIndex, movedVertices);
         dirty.add(msh);
       }
       if (changed || boundsDue) {
@@ -7275,6 +7602,26 @@ function installZoneDent(kit) {
     });
     return { field, moved, ax, a, cu, cv, hu, hv, outer };
   }
+  function panelBoundsIn(rel, rect, B, a, ax) {
+    const det = rel.determinant();
+    if (!Number.isFinite(det) || Math.abs(det) < 1e-12) return void 0;
+    const back = rel.clone().invert();
+    const lo = [Infinity, Infinity, Infinity];
+    const hi = [-Infinity, -Infinity, -Infinity];
+    const q = new V3();
+    for (let i = 0; i < 8; i++) {
+      q.setComponent(ax[0], i & 1 ? rect[1] : rect[0]);
+      q.setComponent(ax[1], i & 2 ? rect[3] : rect[2]);
+      q.setComponent(a, i & 4 ? I.boxHi(B, a) : I.boxLo(B, a));
+      q.applyMatrix4(back);
+      for (let k = 0; k < 3; k++) {
+        lo[k] = Math.min(lo[k], q.getComponent(k));
+        hi[k] = Math.max(hi[k], q.getComponent(k));
+      }
+    }
+    const pad = 1e-3;
+    return { lo: lo.map((x) => x - pad), hi: hi.map((x) => x + pad) };
+  }
   function cutPanel(c, z, rect, keep, dirty, o) {
     o = o || {};
     const B = z.box;
@@ -7307,6 +7654,7 @@ function installZoneDent(kit) {
       }
       const test = {
         tag: "part",
+        pieces: keep ? o.pieceTasks ? "later" : "crease" : "none",
         sel: o.anyN || z.cutAll ? null : function(n) {
           nv.copy(n).applyMatrix3(nm).normalize();
           return nv.dot(outN) > 0.3;
@@ -7325,13 +7673,12 @@ function installZoneDent(kit) {
           return q;
         }
       };
-      const r = cutGeometry(g, [test]);
+      const r = cutGeometry(g, [{ ...test, bounds: panelBoundsIn(rel, rect, B, a, ax) }]);
       const cg = r.cut.part;
       if (!cg || !cg.attributes.position.count) return;
       g.dispose();
       msh.geometry = r.geo;
-      r.geo.computeBoundingSphere();
-      r.geo.computeBoundingBox();
+      I.refreshBounds(r.geo);
       dirty.add(msh);
       if (!keep) {
         cg.dispose();
@@ -7344,6 +7691,7 @@ function installZoneDent(kit) {
       rel.decompose(pm.position, pm.quaternion, pm.scale);
       c.vehicle.add(pm);
       pm.updateMatrixWorld(true);
+      if (o.pieceTasks) o.pieceTasks.set(pm, r.tasks.part);
       pieces.push({ mesh: pm, cut: true });
     });
     return pieces;
@@ -10983,7 +11331,15 @@ var VehicleVisuals = class {
     __publicField(this, "gone", /* @__PURE__ */ new Set());
     /** Shows or hides the plate and the recess of a door or lid by its state (see `showWhenOpen`). */
     __publicField(this, "syncPlates", /* @__PURE__ */ new Map());
+    /** Doors and lids whose own skin was cut from the body and hung on the hinge (true), or that had none to take and keep the plate (false). */
+    __publicField(this, "skins", /* @__PURE__ */ new Map());
     __publicField(this, "lightsOn", true);
+    /** Heavy body meshes whose triangle index is still to build (null once done). */
+    __publicField(this, "warming");
+    /** A panel was torn off since the last `pump`: that frame already paid for the cut, the smoothing starts on the next one. */
+    __publicField(this, "tornThisFrame", false);
+    /** Normal smoothing still running, by mesh: a mesh cut again gets a new task and the old one is dropped. */
+    __publicField(this, "smoothing", /* @__PURE__ */ new Map());
     __publicField(this, "hood");
     this.kit = kit;
     this.c = c;
@@ -10993,6 +11349,8 @@ var VehicleVisuals = class {
     for (const p of model.parts) this.byId.set(p.id, p);
     c.root.updateMatrixWorld(true);
     this.hood = this.nameHood();
+    this.warming = c.deform.filter((msh) => msh.geometry && msh.geometry.attributes.position && msh.geometry.attributes.position.count >= 1500);
+    if (!this.warming.length) this.warming = null;
     for (const p of model.parts) {
       if (p.role === "door" || p.role === "lid") this.makePlate(p);
       else if (p.role === "mirror" && !this.mirrorObjects(p).length) this.makeMirror(p);
@@ -11128,11 +11486,21 @@ var VehicleVisuals = class {
    * keeps the shape of its model instead of flat panels over its curved sides. Follows the hinge's rotation, whoever turns it (the clips of a host, `detach`).
    */
   showWhenOpen(id, piv, panel, recess) {
+    let busy = false;
     const sync = () => {
+      if (busy) return;
       const r = piv.rotation;
       const open = Math.abs(r.x) + Math.abs(r.y) + Math.abs(r.z) > 1e-3 || this.gone.has(id) || piv.parent !== this.c.vehicle;
-      panel.visible = open;
-      recess.visible = open;
+      if (open && !this.gone.has(id) && piv.parent === this.c.vehicle && !this.skins.has(id)) {
+        busy = true;
+        try {
+          this.skins.set(id, this.takeSkin(id, piv));
+        } finally {
+          busy = false;
+        }
+      }
+      panel.visible = open && !this.skins.get(id);
+      recess.visible = open && !this.skins.get(id);
     };
     const euler = piv.rotation;
     const quaternion = piv.quaternion;
@@ -11149,6 +11517,58 @@ var VehicleVisuals = class {
     this.syncPlates.set(id, sync);
     sync();
   }
+  /**
+   * Cuts the skin of a door or lid zone out of the body (as the damage's hanging door does) and hangs it, with the thin parts on it (trim, handle) and, for a door, the side
+   * window over it, on the hinge. Done with the hinge closed, so every piece keeps its place; answers whether there was skin to take.
+   */
+  takeSkin(id, piv) {
+    const p = this.byId.get(id);
+    const z = p && this.zone(p);
+    if (!p || !z) return false;
+    const I = this.I;
+    const B = z.box;
+    const q = piv.quaternion.clone();
+    piv.quaternion.identity();
+    this.c.root.updateMatrixWorld(true);
+    const inv = I.worldInverseOf(this.c);
+    let objs = [];
+    try {
+      if (p.role === "door") {
+        const dirty = /* @__PURE__ */ new Set();
+        const rect = [B.x0 + 0.03, B.x1 - 0.03, B.y0 + Math.min(0.08, (B.y1 - B.y0) * 0.1), B.y1 - 0.02];
+        const pcs = I.cutPanel(this.c, z, rect, true, dirty).map((x) => x.mesh).filter((m) => !!m);
+        this.mend(dirty);
+        if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv), ...I.windowsOver(this.c, z, inv)];
+      } else {
+        const pcs = this.cutZone(z);
+        if (pcs.length) objs = [...pcs, ...I.followersIn(this.c, z, inv)];
+      }
+    } catch {
+      objs = [];
+    }
+    const deform = this.c.deform ?? [];
+    for (const o of objs) {
+      if (!o.parent || o === piv) continue;
+      piv.attach(o);
+      o.traverse((x) => {
+        x.userData.noFollow = true;
+      });
+      const di = deform.indexOf(o);
+      if (di >= 0) deform.splice(di, 1);
+    }
+    piv.quaternion.copy(q);
+    this.c.root.updateMatrixWorld(true);
+    return objs.length > 0;
+  }
+  mend(dirty) {
+    dirty.forEach((msh) => {
+      const g = msh.geometry;
+      if (g.userData.crease || !g.index) this.I.crease(g, 42);
+      else g.computeVertexNormals();
+      g.computeBoundingSphere();
+      g.computeBoundingBox();
+    });
+  }
   makeMirror(p) {
     const [cx, cy, cz] = p.box.center;
     const s = cz < 0 ? -1 : 1;
@@ -11286,6 +11706,31 @@ var VehicleVisuals = class {
       this.I.flattenTire(w, Math.min(0.5, 0.12 + 0.38 * melt));
     }
   }
+  /** Smooths the normals of a cut mesh a slice per frame (see `pump`); until then it draws with flat face normals. */
+  smoothLater(msh) {
+    this.smoothing.set(msh, this.I.creaseTask(msh.geometry, 42));
+    this.tornThisFrame = true;
+  }
+  /** Spends at most `budgetMs` finishing the pending normal smoothing. Call once per frame. */
+  pump(budgetMs = 2.5) {
+    if (this.tornThisFrame) {
+      this.tornThisFrame = false;
+      return;
+    }
+    if (!this.smoothing.size && !this.warming) return;
+    const deadline = performance.now() + budgetMs;
+    for (const [msh, task] of this.smoothing) {
+      if (msh.geometry !== task.geo || task.step(deadline)) this.smoothing.delete(msh);
+      if (performance.now() >= deadline) return;
+    }
+    this.warmIndexes(deadline);
+  }
+  /** Measures the triangles of the heavy body meshes once, a slice per frame, so the first panel torn off finds them ready (see `triIndexOf`). */
+  warmIndexes(deadline) {
+    if (!this.warming) return;
+    this.warming = this.warming.filter((msh) => !warmTriIndex(msh.geometry, deadline));
+    if (!this.warming.length) this.warming = null;
+  }
   /** Moves the panel of a lost zone out of the body (the kit's torn-off look). */
   tearOff(p) {
     const z = this.zone(p);
@@ -11298,10 +11743,9 @@ var VehicleVisuals = class {
     }
     dirty.forEach((msh) => {
       const g = msh.geometry;
-      if (g.userData.crease || !g.index) this.I.crease(g, 42);
+      if (g.userData.crease || !g.index) this.smoothLater(msh);
       else g.computeVertexNormals();
-      g.computeBoundingSphere();
-      g.computeBoundingBox();
+      this.I.refreshBounds(g);
     });
     this.gone.add(p.id);
   }
@@ -11444,17 +11888,19 @@ var VehicleVisuals = class {
     const mg = Math.min(0.05, (u1 - u0) * 0.08, (v1 - v0) * 0.08);
     const dirty = /* @__PURE__ */ new Set();
     let pcs = [];
+    const pieceTasks = /* @__PURE__ */ new Map();
     try {
-      pcs = I.cutPanel(this.c, z, [u0 + mg, u1 - mg, v0 + mg, v1 - mg], true, dirty);
+      pcs = I.cutPanel(this.c, z, [u0 + mg, u1 - mg, v0 + mg, v1 - mg], true, dirty, { pieceTasks });
     } catch {
       pcs = [];
     }
+    pieceTasks.forEach((task, mesh) => this.smoothing.set(mesh, task));
+    this.tornThisFrame = true;
     dirty.forEach((msh) => {
       const g = msh.geometry;
-      if (g.userData.crease || !g.index) I.crease(g, 42);
+      if (g.userData.crease || !g.index) this.smoothLater(msh);
       else g.computeVertexNormals();
-      g.computeBoundingSphere();
-      g.computeBoundingBox();
+      I.refreshBounds(g);
     });
     return pcs.map((q) => q.mesh).filter((m) => !!m);
   }
@@ -12233,7 +12679,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     specCache = { name: options.name ?? c.spec.name ?? c.key, parts, joints, tags: ["vehicle", kindOf(c)] };
     return specCache;
   };
-  const state = () => {
+  const buildState = () => {
     const parts = model.parts.map((d) => {
       const p = ps.get(d.id);
       const marked = p.dents.length > 0 || p.holes.length > 0 || p.cracks.length > 0;
@@ -12270,7 +12716,15 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     }));
     return { id, name: options.name ?? c.spec.name ?? c.key, position: [0, 0, 0], rotation: [0, 0, 0, 1], parts, joints, groups: groupsCache.map((g) => [...g]), destroyed: parts.every((p) => p.status === "broken" || p.status === "melted" || p.status === "ashes") };
   };
+  let stateCache;
+  const state = () => stateCache ?? (stateCache = buildState());
+  const isSimulating = () => {
+    if (leaks.size > 0) return true;
+    for (const p of ps.values()) if (!p.lost && (p.burning || p.temp > AMBIENT)) return true;
+    return false;
+  };
   const hit = (h) => {
+    stateCache = void 0;
     const out = [];
     const hh = h.space === "local" ? { ...h, space: "world", point: toWorld(h.point) } : h;
     if (hh.space === "local" || !hh.point) return out;
@@ -12297,6 +12751,8 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     clock += dt;
     const out = queue;
     queue = [];
+    const wasSimulating = isSimulating();
+    const handledBefore = (blastHandled ? 1 : 0) + (rollHandled ? 2 : 0);
     const hood = c.hood;
     if (hood) {
       const sign = hood.sign || 1;
@@ -12317,12 +12773,15 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     afterBlast(out);
     afterRoll(out);
     applyEffects();
+    vis?.pump();
+    if (wasSimulating || out.length > 0 || handledBefore !== (blastHandled ? 1 : 0) + (rollHandled ? 2 : 0)) stateCache = void 0;
     return out;
   };
   const disassemble = (jointId, tool, dt) => {
     const j = js.find((x) => x.def.id === jointId);
     if (!j || !j.def.tools.includes(tool)) return -1;
     if (j.open) return 1;
+    stateCache = void 0;
     j.progress = Math.min(1, j.progress + dt / j.def.seconds);
     const step = Math.floor(j.progress * 4) / 4;
     if (step > j.reported && j.progress < 1) {
@@ -12338,6 +12797,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     return j.progress;
   };
   const extinguish = (partId) => {
+    stateCache = void 0;
     for (const p of ps.values()) {
       if (partId && p.def.id !== partId) continue;
       if (p.burning) {
@@ -12351,6 +12811,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     }
   };
   const reset = () => {
+    stateCache = void 0;
     const old = c;
     const parent = old.root.parent;
     const next = kit.build(old.key, old.state, old.scenario != null ? { scenario: old.scenario } : void 0);
@@ -12368,6 +12829,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     setup();
   };
   const rollover = (side2 = 1) => {
+    stateCache = void 0;
     if (kit.roll(c, side2)) rolled = true;
     void rolled;
   };