@adatechnology/game-weapons-three 0.7.1 → 0.7.2

package/dist/index.global.js

@@ -13781,17 +13781,17 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var DEFAULT_NOISE_SECONDS = 1.5;
   var OCCLUSION_GAIN = 0.5;
   var OCCLUSION_CUTOFF = 0.6;
-  function isParamRef(range) {
-    return typeof range === "object" && !Array.isArray(range);
+  function isParamRef(range2) {
+    return typeof range2 === "object" && !Array.isArray(range2);
   }
-  function draw(range, scope2) {
-    if (typeof range === "number") return range;
-    if (isParamRef(range)) {
-      const value = scope2.params[range.param];
-      if (value === void 0) throw new Error(`game-audio: the recipe reads the param "${range.param}", which was not given`);
-      return value * (range.scale ?? 1) + (range.add ?? 0);
+  function draw(range2, scope2) {
+    if (typeof range2 === "number") return range2;
+    if (isParamRef(range2)) {
+      const value = scope2.params[range2.param];
+      if (value === void 0) throw new Error(`game-audio: the recipe reads the param "${range2.param}", which was not given`);
+      return value * (range2.scale ?? 1) + (range2.add ?? 0);
     }
-    const [min2, max2] = range;
+    const [min2, max2] = range2;
     return min2 + scope2.random() * (max2 - min2);
   }
   function drawTime(time, scope2) {
@@ -13956,7 +13956,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     };
     if (silent) return recipe.keepSilent ? { ...base, silent: true, length: 0, layers: [] } : null;
     const scope2 = { random: input.random ?? createRng2(1), params: { ...input.params } };
-    for (const [name, range] of Object.entries(recipe.vars ?? {})) if (scope2.params[name] === void 0) scope2.params[name] = draw(range, scope2);
+    for (const [name, range2] of Object.entries(recipe.vars ?? {})) if (scope2.params[name] === void 0) scope2.params[name] = draw(range2, scope2);
     const defaults = {
       ...recipe.duration === void 0 ? {} : { duration: draw(recipe.duration, scope2) },
       ...recipe.tail === void 0 ? {} : { tail: recipe.tail },
@@ -14233,7 +14233,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       }
     };
   }
-  var fixed = (range) => typeof range === "number" ? range : 0;
+  var fixed = (range2) => typeof range2 === "number" ? range2 : 0;
   var fixedFrequency = (automation) => fixed("set" in automation ? automation.set : automation.from);
   function sourceOf(recipe, target) {
     if (recipe.source.kind === "noise") return { source: noiseSource(target, true) };
@@ -15448,12 +15448,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var VIEWMODEL_NODE_NAME = "weapon-viewmodel";
   var IN_HAND_NODE_NAME = "weapon-in-hand";
   var LASER_RAYCAST_HZ = 30;
-  var isHeld = (object) => {
-    for (let node = object; node; node = node.parent) if (node.name === VIEWMODEL_NODE_NAME || node.name === IN_HAND_NODE_NAME) return true;
+  var isHeld = (object2) => {
+    for (let node = object2; node; node = node.parent) if (node.name === VIEWMODEL_NODE_NAME || node.name === IN_HAND_NODE_NAME) return true;
     return false;
   };
-  var isVisibleInScene = (object) => {
-    for (let node = object; node; node = node.parent) if (!node.visible) return false;
+  var isVisibleInScene = (object2) => {
+    for (let node = object2; node; node = node.parent) if (!node.visible) return false;
     return true;
   };
   var createLaserRaycast = (THREE, scene, camera2, options = {}) => {
@@ -15479,6 +15479,226 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     };
   };
 
+  // ../game-shapes/dist/chunk-R4RY23RH.js
+  function normalMatrix(me) {
+    const n11 = me[0], n21 = me[1], n31 = me[2];
+    const n12 = me[4], n22 = me[5], n32 = me[6];
+    const n13 = me[8], n23 = me[9], n33 = me[10];
+    const t11 = n33 * n22 - n32 * n23;
+    const t12 = n32 * n13 - n33 * n12;
+    const t13 = n23 * n12 - n22 * n13;
+    const det = n11 * t11 + n21 * t12 + n31 * t13;
+    if (det === 0) return [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const detInv = 1 / det;
+    const te = [
+      t11 * detInv,
+      (n31 * n23 - n33 * n21) * detInv,
+      (n32 * n21 - n31 * n22) * detInv,
+      t12 * detInv,
+      (n33 * n11 - n31 * n13) * detInv,
+      (n31 * n12 - n32 * n11) * detInv,
+      t13 * detInv,
+      (n21 * n13 - n23 * n11) * detInv,
+      (n22 * n11 - n21 * n12) * detInv
+    ];
+    let tmp = te[1];
+    te[1] = te[3];
+    te[3] = tmp;
+    tmp = te[2];
+    te[2] = te[6];
+    te[6] = tmp;
+    tmp = te[5];
+    te[5] = te[7];
+    te[7] = tmp;
+    return te;
+  }
+  function transformPoint(e, x, y, z) {
+    const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+    return [(e[0] * x + e[4] * y + e[8] * z + e[12]) * w, (e[1] * x + e[5] * y + e[9] * z + e[13]) * w, (e[2] * x + e[6] * y + e[10] * z + e[14]) * w];
+  }
+  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 = (min2) => (v) => typeof v === "number" && Number.isInteger(v) && v >= min2 ? null : `expected an integer >= ${min2}`;
+  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, min2 = 0) => (v) => {
+    if (!Array.isArray(v)) return "expected an array";
+    if (v.length < min2) return `expected at least ${min2} 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"] }
+  };
+  function mergeTransformed(pieces) {
+    let total = 0;
+    for (const piece2 of pieces) total += piece2.indices ? piece2.indices.length : piece2.positions.length / 3;
+    const positions = new Float32Array(total * 3);
+    const normals = new Float32Array(total * 3);
+    const uvs = new Float32Array(total * 2);
+    let at3 = 0;
+    for (const piece2 of pieces) {
+      const e = piece2.matrix;
+      const nm = normalMatrix(e);
+      const count = piece2.indices ? piece2.indices.length : piece2.positions.length / 3;
+      const p = new Float32Array(count * 3);
+      const n = new Float32Array(count * 3);
+      for (let k = 0; k < count; k++) {
+        const i = piece2.indices ? piece2.indices[k] : k;
+        for (let c = 0; c < 3; c++) {
+          p[k * 3 + c] = piece2.positions[i * 3 + c];
+          if (piece2.normals) n[k * 3 + c] = piece2.normals[i * 3 + c];
+        }
+        if (piece2.uvs) {
+          uvs[(at3 + k) * 2] = piece2.uvs[i * 2];
+          uvs[(at3 + k) * 2 + 1] = piece2.uvs[i * 2 + 1];
+        }
+      }
+      for (let k = 0; k < count; k++) {
+        const q = transformPoint(e, p[k * 3], p[k * 3 + 1], p[k * 3 + 2]);
+        positions[(at3 + k) * 3] = q[0];
+        positions[(at3 + k) * 3 + 1] = q[1];
+        positions[(at3 + k) * 3 + 2] = q[2];
+        const x = n[k * 3];
+        const y = n[k * 3 + 1];
+        const z = n[k * 3 + 2];
+        const vx2 = nm[0] * x + nm[3] * y + nm[6] * z;
+        const vy2 = nm[1] * x + nm[4] * y + nm[7] * z;
+        const vz2 = nm[2] * x + nm[5] * y + nm[8] * z;
+        const s = 1 / (Math.sqrt(vx2 * vx2 + vy2 * vy2 + vz2 * vz2) || 1);
+        normals[(at3 + k) * 3] = vx2 * s;
+        normals[(at3 + k) * 3 + 1] = vy2 * s;
+        normals[(at3 + k) * 3 + 2] = vz2 * s;
+      }
+      at3 += count;
+    }
+    return { positions, normals, uvs };
+  }
+
+  // ../game-shapes-three/dist/index.js
+  var isVisible = (object2) => {
+    for (let node = object2; node; node = node.parent) if (!node.visible) return false;
+    return true;
+  };
+  var plain = (attribute) => attribute !== void 0 && !attribute.isInterleavedBufferAttribute && attribute.array instanceof Float32Array && !attribute.normalized;
+  function piece(geometry, matrix) {
+    const position = geometry.getAttribute("position");
+    const normal = geometry.getAttribute("normal");
+    const uv = geometry.getAttribute("uv");
+    const ok = plain(position) && (normal === void 0 || plain(normal)) && (uv === void 0 || plain(uv)) && position.itemSize === 3 && (uv === void 0 || uv.itemSize === 2);
+    if (ok) {
+      return { positions: position.array, ...normal ? { normals: normal.array } : {}, ...uv ? { uvs: uv.array } : {}, indices: geometry.index ? geometry.index.array : null, matrix: matrix.elements };
+    }
+    const flat = geometry.index ? geometry.toNonIndexed() : geometry;
+    const read = (name, size) => {
+      const attribute = flat.getAttribute(name);
+      if (!attribute) return void 0;
+      const out = new Float32Array(attribute.count * size);
+      for (let i = 0; i < attribute.count; i++) for (let c = 0; c < size; c++) out[i * size + c] = c === 0 ? attribute.getX(i) : c === 1 ? attribute.getY(i) : attribute.getZ(i);
+      return out;
+    };
+    const positions = read("position", 3);
+    const normals = read("normal", 3);
+    const uvs = read("uv", 2);
+    if (flat !== geometry) flat.dispose();
+    return { positions, ...normals ? { normals } : {}, ...uvs ? { uvs } : {}, indices: null, matrix: matrix.elements };
+  }
+  function mergeByMaterial(THREE, root, space) {
+    const toSpace = space.matrixWorld.clone().invert();
+    const byMaterial = /* @__PURE__ */ new Map();
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || Array.isArray(mesh2.material) || !isVisible(mesh2)) return;
+      const list2 = byMaterial.get(mesh2.material) ?? [];
+      list2.push(piece(mesh2.geometry, new THREE.Matrix4().multiplyMatrices(toSpace, mesh2.matrixWorld)));
+      byMaterial.set(mesh2.material, list2);
+    });
+    return [...byMaterial].map(([material, pieces]) => {
+      const merged = mergeTransformed(pieces);
+      const geometry = new THREE.BufferGeometry();
+      geometry.setAttribute("position", new THREE.BufferAttribute(merged.positions, 3));
+      geometry.setAttribute("normal", new THREE.BufferAttribute(merged.normals, 3));
+      geometry.setAttribute("uv", new THREE.BufferAttribute(merged.uvs, 2));
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.castShadow = false;
+      mesh2.receiveShadow = true;
+      return mesh2;
+    });
+  }
+
   // ../game-props3d/dist/index.js
   var T = (id, interior, w, d, h, y, solid2, group) => ({ id, interior, w, d, h, y, solid: solid2, group });
   var TYPE_DEFS = [
@@ -15541,55 +15761,24 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     T("open_door", true, 0.9, 0.15, 2.15, 0, false, "house_state")
   ];
   var DEFS = Object.fromEntries(TYPE_DEFS.map((t) => [t.id, t]));
-  var ATTRIBUTES = ["position", "normal", "uv"];
-  var isVisible = (object) => {
-    for (let node = object; node; node = node.parent) if (!node.visible) return false;
-    return true;
-  };
-  var bake = (THREE, mesh2, matrix) => {
-    const source = mesh2.geometry.index ? mesh2.geometry.toNonIndexed() : mesh2.geometry.clone();
-    const baked = new THREE.BufferGeometry();
-    const count = source.getAttribute("position").count;
-    for (const name of ATTRIBUTES) {
-      const attribute = source.getAttribute(name);
-      baked.setAttribute(name, attribute ?? new THREE.BufferAttribute(new Float32Array(count * (name === "uv" ? 2 : 3)), name === "uv" ? 2 : 3));
-    }
-    source.dispose();
-    return baked.applyMatrix4(matrix);
-  };
-  var join = (THREE, geometries) => {
-    const merged = new THREE.BufferGeometry();
-    for (const name of ATTRIBUTES) {
-      const size = (geometries[0]?.getAttribute(name)).itemSize;
-      const total = geometries.reduce((sum2, geometry) => sum2 + geometry.getAttribute(name).count, 0);
-      const array = new Float32Array(total * size);
-      let offset = 0;
-      for (const geometry of geometries) {
-        array.set(geometry.getAttribute(name).array, offset);
-        offset += geometry.getAttribute(name).count * size;
-      }
-      merged.setAttribute(name, new THREE.BufferAttribute(array, size));
-    }
-    return merged;
-  };
-  function mergeByMaterial(THREE, root, space) {
-    const toSpace = space.matrixWorld.clone().invert();
-    const byMaterial = /* @__PURE__ */ new Map();
-    root.traverse((object) => {
-      const mesh2 = object;
-      if (!mesh2.isMesh || Array.isArray(mesh2.material) || !isVisible(mesh2)) return;
-      const list = byMaterial.get(mesh2.material) ?? [];
-      list.push(bake(THREE, mesh2, new THREE.Matrix4().multiplyMatrices(toSpace, mesh2.matrixWorld)));
-      byMaterial.set(mesh2.material, list);
-    });
-    return [...byMaterial].map(([material, geometries]) => {
-      const merged = new THREE.Mesh(join(THREE, geometries), material);
-      for (const geometry of geometries) geometry.dispose();
-      merged.castShadow = false;
-      merged.receiveShadow = true;
-      return merged;
-    });
-  }
+  var LEAF = (() => {
+    const f = [0, 0, 0, -0.5, 0.4, 0, 0.5, 0.4, 0, 0, 1, 0];
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    for (const side of [1, -1]) {
+      const base = positions.length / 3;
+      for (let i = 0; i < 4; i++) {
+        positions.push(f[i * 3], f[i * 3 + 1], f[i * 3 + 2]);
+        normals.push(0, 0, side);
+        uvs.push(f[i * 3] + 0.5, f[i * 3 + 1]);
+      }
+      if (side === 1) indices.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
+      else indices.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
+    }
+    return { positions, normals, uvs, indices };
+  })();
 
   // src/data/models.json
   var models_default = {
@@ -17177,7 +17366,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     geometry.setAttribute("uv", flat.attributes.uv);
     const position = new THREE.Vector3();
     const normal = new THREE.Vector3();
-    const box2 = new THREE.Vector3(width, height, depth).divideScalar(2).subScalar(rounding);
+    const box3 = new THREE.Vector3(width, height, depth).divideScalar(2).subScalar(rounding);
     const positions = geometry.attributes.position.array;
     const normals = geometry.attributes.normal.array;
     const uvs = geometry.attributes.uv.array;
@@ -17191,9 +17380,9 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       normal.y -= Math.sign(normal.y) * halfSegment;
       normal.z -= Math.sign(normal.z) * halfSegment;
       normal.normalize();
-      positions[i] = box2.x * Math.sign(position.x) + normal.x * rounding;
-      positions[i + 1] = box2.y * Math.sign(position.y) + normal.y * rounding;
-      positions[i + 2] = box2.z * Math.sign(position.z) + normal.z * rounding;
+      positions[i] = box3.x * Math.sign(position.x) + normal.x * rounding;
+      positions[i + 1] = box3.y * Math.sign(position.y) + normal.y * rounding;
+      positions[i + 2] = box3.z * Math.sign(position.z) + normal.z * rounding;
       normals[i] = normal.x;
       normals[i + 1] = normal.y;
       normals[i + 2] = normal.z;
@@ -17211,8 +17400,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   // src/models/kit.ts
   var PI = Math.PI;
   var createMaterials = (THREE) => {
-    const standard = (color, roughness = 0.7, metalness = 0.2, extra = {}) => new THREE.MeshStandardMaterial({ color, roughness, metalness, ...extra });
-    const basic = (color, extra = {}) => new THREE.MeshBasicMaterial({ color, ...extra });
+    const standard = (color2, roughness = 0.7, metalness = 0.2, extra = {}) => new THREE.MeshStandardMaterial({ color: color2, roughness, metalness, ...extra });
+    const basic = (color2, extra = {}) => new THREE.MeshBasicMaterial({ color: color2, ...extra });
     const additive = { transparent: true, opacity: 0.95, blending: THREE.AdditiveBlending, depthWrite: false };
     return {
       metal: standard(3422010, 0.42, 0.75),
@@ -17304,10 +17493,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       },
       torus: (parent, geometry, material, x, y, z) => place(parent, shadowed(new THREE.Mesh(geometry, material)), x, y, z),
       mark(parent, x, y, z) {
-        const object = new THREE.Object3D();
-        object.position.set(x, y, z);
-        parent.add(object);
-        return object;
+        const object2 = new THREE.Object3D();
+        object2.position.set(x, y, z);
+        parent.add(object2);
+        return object2;
       },
       pivot(parent, x = 0, y = 0, z = 0) {
         const group = new THREE.Group();
@@ -17327,32 +17516,32 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
 
   // src/models/break-action.ts
   function buildBreakAction(kit, options) {
-    const { M, box: box2, cylinderX, sphere } = kit;
+    const { M, box: box3, cylinderX, sphere: sphere2 } = kit;
     const group = kit.group();
     const L = (options.L ?? 0) / 1e3;
     const barrel = (options.B ?? 0) / 1e3;
     const parts = { family: "break", kick: 1.6, glow: [] };
-    box2(group, 0.09, 0.05, 0.042, M.steel, L - barrel - 0.04, -5e-3, 0);
-    for (let i = 0; i < 4; i++) box2(group, 0.05, 2e-3, 0.043, M.dark, L - barrel - 0.04, 0.01 - i * 8e-3, 0);
+    box3(group, 0.09, 0.05, 0.042, M.steel, L - barrel - 0.04, -5e-3, 0);
+    for (let i = 0; i < 4; i++) box3(group, 0.05, 2e-3, 0.043, M.dark, L - barrel - 0.04, 0.01 - i * 8e-3, 0);
     const barrels = kit.pivot(group, L - barrel, -0.01, 0);
     parts.barrels = barrels;
     heatify(parts.glow, cylinderX(barrels, 0.0105, barrel, M.steel, barrel / 2, 0.01, 0.011, 18));
     heatify(parts.glow, cylinderX(barrels, 0.0105, barrel, M.steel, barrel / 2, 0.01, -0.011, 18));
-    box2(barrels, barrel, 4e-3, 8e-3, M.metal, barrel / 2, 0.022, 0);
-    sphere(barrels, 2e-3, M.white, barrel - 0.01, 0.026, 0, 1);
+    box3(barrels, barrel, 4e-3, 8e-3, M.metal, barrel / 2, 0.022, 0);
+    sphere2(barrels, 2e-3, M.white, barrel - 0.01, 0.026, 0, 1);
     cylinderX(barrels, 75e-4, 4e-3, M.hole, barrel + 1e-3, 0.01, 0.011, 12);
     cylinderX(barrels, 75e-4, 4e-3, M.hole, barrel + 1e-3, 0.01, -0.011, 12);
-    box2(barrels, 0.22, 0.03, 0.038, M.wood, 0.12, -0.01, 0);
+    box3(barrels, 0.22, 0.03, 0.038, M.wood, 0.12, -0.01, 0);
     parts.breech = [kit.mark(barrels, 4e-3, 0.01, 0.011), kit.mark(barrels, 4e-3, 0.01, -0.011)];
-    box2(group, 0.12, 0.042, 0.032, M.wood, L - barrel - 0.14, -0.022, 0, 0.14);
-    box2(group, 0.28, 0.07, 0.036, M.wood, 0.15, -0.05, 0, 0.08);
-    box2(group, 0.012, 0.13, 0.04, M.rubber, 6e-3, -0.06, 0);
-    box2(group, 4e-3, 0.014, 4e-3, M.dark, L - barrel - 0.05, -0.04, 0);
-    parts.trigger = box2(group, 4e-3, 0.014, 4e-3, M.dark, L - barrel - 0.035, -0.04, 0);
-    box2(group, 0.04, 4e-3, 0.01, M.steel, L - barrel - 0.045, -0.05, 0);
-    box2(group, 0.012, 0.016, 6e-3, M.dark, L - barrel - 0.08, 0.022, 0.012, 0.5);
-    box2(group, 0.012, 0.016, 6e-3, M.dark, L - barrel - 0.08, 0.022, -0.012, 0.5);
-    parts.safety = box2(group, 0.02, 6e-3, 8e-3, M.steel, L - barrel - 0.07, 0.025, 0);
+    box3(group, 0.12, 0.042, 0.032, M.wood, L - barrel - 0.14, -0.022, 0, 0.14);
+    box3(group, 0.28, 0.07, 0.036, M.wood, 0.15, -0.05, 0, 0.08);
+    box3(group, 0.012, 0.13, 0.04, M.rubber, 6e-3, -0.06, 0);
+    box3(group, 4e-3, 0.014, 4e-3, M.dark, L - barrel - 0.05, -0.04, 0);
+    parts.trigger = box3(group, 4e-3, 0.014, 4e-3, M.dark, L - barrel - 0.035, -0.04, 0);
+    box3(group, 0.04, 4e-3, 0.01, M.steel, L - barrel - 0.045, -0.05, 0);
+    box3(group, 0.012, 0.016, 6e-3, M.dark, L - barrel - 0.08, 0.022, 0.012, 0.5);
+    box3(group, 0.012, 0.016, 6e-3, M.dark, L - barrel - 0.08, 0.022, -0.012, 0.5);
+    parts.safety = box3(group, 0.02, 6e-3, 8e-3, M.steel, L - barrel - 0.07, 0.025, 0);
     parts.muzzle = kit.mark(barrels, barrel + 0.01, 0.01, 0);
     parts.eject = parts.breech[0];
     return { group, parts };
@@ -17369,21 +17558,21 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   function deriveFrames(THREE, model) {
     const { root, inner, parts } = model;
     root.updateMatrixWorld(true);
-    const box2 = new THREE.Box3().setFromObject(root);
-    const span = box2.max.x - box2.min.x;
+    const box3 = new THREE.Box3().setFromObject(root);
+    const span = box3.max.x - box3.min.x;
     const toInnerX = (x) => (x - inner.position.x) / inner.scale.x;
     const muzzle2 = parts.muzzle?.position;
-    const length2 = muzzle2 ? muzzle2.x - 0.01 : toInnerX(box2.max.x);
-    const receiverStart = toInnerX(box2.min.x + span * RECEIVER_START_FRACTION);
-    const receiverEnd = toInnerX(box2.min.x + span * RECEIVER_END_FRACTION);
+    const length2 = muzzle2 ? muzzle2.x - 0.01 : toInnerX(box3.max.x);
+    const receiverStart = toInnerX(box3.min.x + span * RECEIVER_START_FRACTION);
+    const receiverEnd = toInnerX(box3.min.x + span * RECEIVER_END_FRACTION);
     return {
       length: length2,
-      barrelY: muzzle2?.y ?? (box2.max.y + box2.min.y) / 2,
+      barrelY: muzzle2?.y ?? (box3.max.y + box3.min.y) / 2,
       barrelRadius: DEFAULT_BARREL_RADIUS,
       receiverStart,
       receiverEnd,
-      receiverHeight: (box2.max.y - box2.min.y) * RECEIVER_HEIGHT_FRACTION,
-      receiverWidth: Math.min(DEFAULT_RECEIVER_WIDTH, box2.max.z - box2.min.z),
+      receiverHeight: (box3.max.y - box3.min.y) * RECEIVER_HEIGHT_FRACTION,
+      receiverWidth: Math.min(DEFAULT_RECEIVER_WIDTH, box3.max.z - box3.min.z),
       handguardEnd: receiverEnd + (length2 - receiverEnd) * HANDGUARD_FRACTION,
       magazineX: parts.mag ? parts.mag.position.x : (receiverStart + receiverEnd) / 2,
       gripX: receiverStart + DEFAULT_GRIP_OFFSET,
@@ -17435,33 +17624,33 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   // src/models/details.ts
   var PI2 = Math.PI;
   function rail(kit, parent, x, length2, y, z, width, rotationX = 0) {
-    const { M, box: box2 } = kit;
+    const { M, box: box3 } = kit;
     const pivot = kit.pivot(parent, 0, y, z);
     pivot.rotation.x = rotationX;
-    box2(pivot, length2, 5e-3, width, M.dark, x + length2 / 2, 0, 0);
+    box3(pivot, length2, 5e-3, width, M.dark, x + length2 / 2, 0, 0);
     const slots = Math.floor(length2 / 95e-4);
-    for (let i = 0; i < slots; i++) box2(pivot, 52e-4, 35e-4, width * 1.12, M.metal, x + 6e-3 + i * 95e-4, 35e-4, 0);
+    for (let i = 0; i < slots; i++) box3(pivot, 52e-4, 35e-4, width * 1.12, M.metal, x + 6e-3 + i * 95e-4, 35e-4, 0);
     return pivot;
   }
   function vents(kit, parent, x, length2, y, z, count, height) {
     for (let i = 0; i < count; i++) kit.box(parent, length2 / count * 0.45, height, 3e-3, kit.M.hole, x + (i + 0.5) * length2 / count, y, z);
   }
   function scope(kit, parent, kind, cx, cy, cz = 0) {
-    const { M, box: box2, cylinderX, cylinderY, cylinderZ, THREE } = kit;
+    const { M, box: box3, cylinderX, cylinderY, cylinderZ, THREE } = kit;
     if (kind === 1) {
-      box2(parent, 0.044, 0.01, 0.028, M.dark, cx, cy + 5e-3, cz);
+      box3(parent, 0.044, 0.01, 0.028, M.dark, cx, cy + 5e-3, cz);
       cylinderX(parent, 0.0155, 0.034, M.dark, cx + 4e-3, cy + 0.026, cz, 18);
       cylinderX(parent, 0.0125, 2e-3, M.lens, cx + 0.022, cy + 0.026, cz, 18);
       cylinderY(parent, 4e-3, 6e-3, M.dark, cx + 4e-3, cy + 0.044, cz, 10);
       return;
     }
     if (kind === 2) {
-      box2(parent, 0.07, 0.012, 0.026, M.dark, cx, cy + 6e-3, cz);
+      box3(parent, 0.07, 0.012, 0.026, M.dark, cx, cy + 6e-3, cz);
       cylinderX(parent, 0.016, 0.1, M.dark, cx - 0.01, cy + 0.032, cz, 18);
       cylinderX(parent, 0.016, 0.035, M.dark, cx + 0.055, cy + 0.032, cz, 18, 0.02);
       cylinderX(parent, 0.017, 2e-3, M.lens, cx + 0.073, cy + 0.032, cz, 18);
       cylinderY(parent, 7e-3, 0.012, M.dark, cx, cy + 0.052, cz, 12);
-      box2(parent, 0.03, 0.01, 0.012, M.dark, cx - 0.01, cy + 0.054, cz);
+      box3(parent, 0.03, 0.01, 0.012, M.dark, cx - 0.01, cy + 0.054, cz);
       return;
     }
     const sleeve = kind === 4 ? 0.2 : 0.32;
@@ -17476,9 +17665,9 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     cylinderY(parent, 0.011, 4e-3, M.metal, cx, cy + 0.078, cz, 14);
     cylinderZ(parent, 0.01, 0.022, M.dark, cx, cy + 0.045, cz + 0.022, 14);
     for (const offset of [-0.07, 0.07]) {
-      const ring2 = kit.torus(parent, new THREE.TorusGeometry(0.0155, 3e-3, 8, 20), M.dark, cx + offset, cy + 0.045, cz);
-      ring2.rotation.y = PI2 / 2;
-      box2(parent, 0.016, 0.03, 0.022, M.dark, cx + offset, cy + 0.018, cz);
+      const ring3 = kit.torus(parent, new THREE.TorusGeometry(0.0155, 3e-3, 8, 20), M.dark, cx + offset, cy + 0.045, cz);
+      ring3.rotation.y = PI2 / 2;
+      box3(parent, 0.016, 0.03, 0.022, M.dark, cx + offset, cy + 0.018, cz);
     }
   }
   var buttpad = (kit, parent, x, y, height, width) => void kit.box(parent, 0.012, height, width, kit.M.rubber, x, y, 0);
@@ -17486,47 +17675,47 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
 
   // src/models/bullpup.ts
   function buildBullpup(kit, options) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const group = kit.group();
     const L = (options.L ?? 0) / 1e3;
     const barrel = (options.B ?? 0) / 1e3;
     const bodyLength = Math.max(0.32, L - barrel * 0.72);
     const body = options.shot ? M.poly : M.olive;
     const parts = { family: options.shot ? "pump" : "rifle", stroke: 0.06, glow: [] };
-    box2(group, bodyLength, 0.075, 0.042, body, bodyLength / 2, 0, 0);
-    box2(group, bodyLength * 0.9, 0.02, 0.044, M.dark, bodyLength * 0.5, -0.02, 0);
-    box2(group, 0.032, 0.13, 0.044, M.rubber, 0.016, -0.025, 0);
+    box3(group, bodyLength, 0.075, 0.042, body, bodyLength / 2, 0, 0);
+    box3(group, bodyLength * 0.9, 0.02, 0.044, M.dark, bodyLength * 0.5, -0.02, 0);
+    box3(group, 0.032, 0.13, 0.044, M.rubber, 0.016, -0.025, 0);
     const gx = bodyLength * 0.8;
     const grip = kit.pivot(group, gx, -0.085, 0);
     grip.rotation.z = -0.25;
-    box2(grip, 0.03, 0.1, 0.03, M.poly, 0, 0, 0);
-    box2(group, 0.1, 6e-3, 0.03, body, gx + 0.01, -0.06, 0);
-    parts.trigger = box2(group, 4e-3, 0.016, 4e-3, M.dark, gx + 0.02, -0.05, 0, 0.15);
+    box3(grip, 0.03, 0.1, 0.03, M.poly, 0, 0, 0);
+    box3(group, 0.1, 6e-3, 0.03, body, gx + 0.01, -0.06, 0);
+    parts.trigger = box3(group, 4e-3, 0.016, 4e-3, M.dark, gx + 0.02, -0.05, 0, 0.15);
     heatify(parts.glow, cylinderX(group, options.shot ? 0.0105 : 85e-4, barrel, M.metal, L - barrel / 2, 0.012, 0, 16));
     cylinderX(group, 6e-3, 4e-3, M.hole, L + 1e-3, 0.012, 0, 12);
-    box2(group, 0.05, 0.024, 4e-3, M.hole, bodyLength * 0.25, 5e-3, 0.0212);
+    box3(group, 0.05, 0.024, 4e-3, M.hole, bodyLength * 0.25, 5e-3, 0.0212);
     const bolt = kit.pivot(group);
     parts.bolt = bolt;
-    box2(bolt, 0.044, 0.02, 6e-3, M.steelL, bodyLength * 0.25, 5e-3, 0.02);
+    box3(bolt, 0.044, 0.02, 6e-3, M.steelL, bodyLength * 0.25, 5e-3, 0.02);
     if (options.shot) {
       cylinderX(group, 0.012, bodyLength * 0.75, M.metal, bodyLength * 0.55, -0.025, 0.014, 14);
       cylinderX(group, 0.012, bodyLength * 0.75, M.metal, bodyLength * 0.55, -0.025, -0.014, 14);
       const pump = kit.pivot(group);
       parts.pump = pump;
-      box2(pump, 0.15, 0.045, 0.052, M.poly, bodyLength + 0.06, -0.015, 0);
-      for (let i = 0; i < 6; i++) box2(pump, 6e-3, 0.047, 0.054, M.dark, bodyLength + 5e-3 + i * 0.022, -0.015, 0);
+      box3(pump, 0.15, 0.045, 0.052, M.poly, bodyLength + 0.06, -0.015, 0);
+      for (let i = 0; i < 6; i++) box3(pump, 6e-3, 0.047, 0.054, M.dark, bodyLength + 5e-3 + i * 0.022, -0.015, 0);
       rail(kit, group, bodyLength * 0.15, bodyLength * 0.8, 0.04, 0, 0.02);
       parts.loadPort = kit.mark(group, bodyLength * 0.2, -0.04, 0);
     } else {
       const magazine = kit.pivot(group, gx - 0.11, -0.03, 0);
       magazine.rotation.z = 0.14;
       parts.mag = magazine;
-      box2(magazine, 0.05, 0.14, 0.026, M.glass, 0, -0.07, 0);
+      box3(magazine, 0.05, 0.14, 0.026, M.glass, 0, -0.07, 0);
       for (let i = 0; i < 6; i++) cylinderX(magazine, 3e-3, 0.04, M.brass, 0, -0.01 - i * 0.02, 0, 6);
       parts.magDrop = 0.18;
       scope(kit, group, 2, bodyLength * 0.5, 0.04, 0);
-      box2(group, 0.2, 0.03, 0.02, body, bodyLength * 0.62, 0.048, 0);
-      box2(group, 0.026, 0.075, 0.026, body, bodyLength + 0.05, -0.05, 0, 0.1);
+      box3(group, 0.2, 0.03, 0.02, body, bodyLength * 0.62, 0.048, 0);
+      box3(group, 0.026, 0.075, 0.026, body, bodyLength + 0.05, -0.05, 0, 0.1);
     }
     parts.muzzle = kit.mark(group, L + 0.01, 0.012, 0);
     parts.eject = kit.mark(group, bodyLength * 0.25, 5e-3, 0.03);
@@ -17547,7 +17736,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     cylinderX(group, 4e-3, 0.022, M.fire, x + 0.012, y, 0, 6, 0).userData.flame = 1;
   };
   function buildFlamethrower(kit, group, parts) {
-    const { M, box: box2, cylinderX, cylinderY, sphere } = kit;
+    const { M, box: box3, cylinderX, cylinderY, sphere: sphere2 } = kit;
     parts.kick = 0.15;
     heatify(parts.glow, cylinderX(group, 0.016, 0.62, M.steel, 0.42, 0, 0, 14));
     cylinderX(group, 0.022, 0.1, M.dark, 0.78, 0, 0, 14);
@@ -17557,52 +17746,52 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     pilot(kit, group, 0.92, -0.012);
     const foreGrip = kit.pivot(group, 0.6, -0.02, 0);
     foreGrip.rotation.z = -0.1;
-    box2(foreGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
+    box3(foreGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
     const lever = kit.pivot(group, 0.62, -0.02, 0);
-    parts.trigger = box2(lever, 8e-3, 0.05, 6e-3, M.metal, 0.02, -0.03, 0, 0.3);
+    parts.trigger = box3(lever, 8e-3, 0.05, 6e-3, M.metal, 0.02, -0.03, 0, 0.3);
     const rearGrip = kit.pivot(group, 0.17, -0.02, 0);
     rearGrip.rotation.z = -0.28;
-    box2(rearGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
-    box2(group, 0.05, 4e-3, 0.012, M.metal, 0.2, -0.035, 0);
+    box3(rearGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
+    box3(group, 0.05, 4e-3, 0.012, M.metal, 0.2, -0.035, 0);
     cylinderX(group, 0.02, 0.04, M.metal, 0.1, 0, 0, 12);
     hose(kit, group, [[0.08, 0, 0], [0, -0.04, 0], [-0.08, -0.2, 0.05], [-0.18, -0.32, 0.08], [-0.25, -0.33, 0.08]], 0.011, M.rubber);
     for (const z of [-0.1, 0.1]) {
       cylinderY(group, 0.085, 0.5, M.olive, -0.3, -0.05, z, 20);
-      sphere(group, 0.085, M.olive, -0.3, 0.2, z, 2).scale.y = 0.45;
-      sphere(group, 0.085, M.olive, -0.3, -0.3, z, 2).scale.y = 0.45;
+      sphere2(group, 0.085, M.olive, -0.3, 0.2, z, 2).scale.y = 0.45;
+      sphere2(group, 0.085, M.olive, -0.3, -0.3, z, 2).scale.y = 0.45;
       cylinderY(group, 0.03, 0.03, M.metal, -0.3, 0.24, z, 12);
     }
-    sphere(group, 0.075, M.olive, -0.3, 0.1, 0, 2).position.x = -0.39;
-    box2(group, 0.03, 0.6, 0.24, M.dark, -0.4, -0.05, 0);
+    sphere2(group, 0.075, M.olive, -0.3, 0.1, 0, 2).position.x = -0.39;
+    box3(group, 0.03, 0.6, 0.24, M.dark, -0.4, -0.05, 0);
     cylinderY(group, 0.03, 0.012, M.metal, -0.39, 0.18, 0, 14);
     const gauge = kit.pivot(group, -0.39, 0.18, 3e-3);
     parts.gauge = gauge;
-    box2(gauge, 2e-3, 0.022, 2e-3, M.red, 0, 8e-3, 0.012);
+    box3(gauge, 2e-3, 0.022, 2e-3, M.red, 0, 8e-3, 0.012);
     parts.muzzle = kit.pivot(group, 0.94, 0, 0);
     parts.rear = kit.pivot(group, 0.1, 0, 0);
   }
   function buildImprovisedFlamethrower(kit, group, parts) {
-    const { M, box: box2, cylinderX, cylinderY, sphere } = kit;
+    const { M, box: box3, cylinderX, cylinderY, sphere: sphere2 } = kit;
     parts.kick = 0.12;
     heatify(parts.glow, cylinderX(group, 0.011, 0.66, M.pipe, 0.38, 0, 0, 12));
     heatify(parts.glow, cylinderX(group, 0.015, 0.06, M.steel, 0.74, 0, 0, 12, 0.01));
     cylinderX(group, 6e-3, 0.05, M.metal, 0.735, -0.02, 0, 8);
     pilot(kit, group, 0.77, -0.02);
     cylinderY(group, 0.012, 0.04, M.redPaint, 0.72, -0.055, 0, 10);
-    box2(group, 0.02, 0.03, 0.012, M.dark, 0.72, -0.085, 0);
+    box3(group, 0.02, 0.03, 0.012, M.dark, 0.72, -0.085, 0);
     cylinderX(group, 0.06, 0.42, M.redPaint, 0.3, -0.09, 0, 22);
-    sphere(group, 0.06, M.redPaint, 0.51, -0.09, 0, 2).scale.x = 0.5;
-    sphere(group, 0.06, M.redPaint, 0.09, -0.09, 0, 2).scale.x = 0.5;
+    sphere2(group, 0.06, M.redPaint, 0.51, -0.09, 0, 2).scale.x = 0.5;
+    sphere2(group, 0.06, M.redPaint, 0.09, -0.09, 0, 2).scale.x = 0.5;
     cylinderX(group, 0.02, 0.04, M.dark, 0.04, -0.09, 0, 12);
-    box2(group, 0.02, 0.06, 5e-3, M.white, 0.3, -0.09, 0.06);
+    box3(group, 0.02, 0.06, 5e-3, M.white, 0.3, -0.09, 0.06);
     for (const x of [0.15, 0.3, 0.45]) cylinderX(group, 0.063, 0.03, M.tape, x, -0.09, 0, 22);
     cylinderX(group, 0.016, 0.03, M.tape, 0.3, 0, 0, 12);
     hose(kit, group, [[0.04, -0.09, 0], [-0.02, -0.06, 0.02], [0, 0, 0.02], [0.05, 0, 0]], 7e-3, M.rubber);
     const rearGrip = kit.pivot(group, 0.12, -0.01, 0);
     rearGrip.rotation.z = -0.3;
-    box2(rearGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
+    box3(rearGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
     const lever = kit.pivot(group, 0.17, -0.02, 0);
-    parts.trigger = box2(lever, 8e-3, 0.04, 6e-3, M.metal, 0, -0.02, 0, 0.2);
+    parts.trigger = box3(lever, 8e-3, 0.04, 6e-3, M.metal, 0, -0.02, 0, 0.2);
     parts.muzzle = kit.pivot(group, 0.78, 0, 0);
     parts.rear = kit.pivot(group, 0.05, 0, 0);
   }
@@ -17630,14 +17819,14 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     return round3;
   }
   function buildFlyingRocket(kit, launcherType) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const rocket = kit.group();
     const diameter = launcherType === "at4" || launcherType === "carl" ? 0.041 : 0.032;
     cylinderX(rocket, diameter * 0.5, 0.2, M.dark, -0.1, 0, 0, 10);
     cylinderX(rocket, diameter, 0.3, M.olive, 0.15, 0, 0, 18);
     cylinderX(rocket, diameter, 0.12, M.olive, 0.36, 0, 0, 18, diameter * 0.25);
     for (let i = 0; i < 4; i++) {
-      const fin = box2(rocket, 0.06, 2e-3, diameter * 1.4, M.metal, -0.17, 0, 0);
+      const fin = box3(rocket, 0.06, 2e-3, diameter * 1.4, M.metal, -0.17, 0, 0);
       fin.rotation.x = i * PI3 / 4;
     }
     return rocket;
@@ -17645,7 +17834,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
 
   // src/models/launcher-rocket.ts
   function buildRpg(kit, group, parts) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     parts.kick = 1.6;
     cylinderX(group, 0.036, 0.13, M.dark, 0.065, 0, 0, 20, 0.021);
     cylinderX(group, 0.038, 0.012, M.metal, 0, 0, 0, 20);
@@ -17654,25 +17843,25 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     cylinderX(group, 0.031, 0.012, M.metal, 0.32, 0, 0, 16);
     cylinderX(group, 0.031, 0.012, M.metal, 0.62, 0, 0, 16);
     cylinderX(group, 0.024, 0.02, M.metal, 0.94, 0, 0, 16);
-    box2(group, 0.09, 0.03, 0.032, M.metal, 0.46, -0.028, 0);
+    box3(group, 0.09, 0.03, 0.032, M.metal, 0.46, -0.028, 0);
     const frontGrip = kit.pivot(group, 0.4, -0.04, 0);
     frontGrip.rotation.z = -0.22;
-    box2(frontGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
+    box3(frontGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
     const rearGrip = kit.pivot(group, 0.5, -0.04, 0);
     rearGrip.rotation.z = -0.18;
-    box2(rearGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
-    box2(group, 0.06, 4e-3, 0.012, M.metal, 0.53, -0.05, 0);
-    box2(group, 4e-3, 0.025, 0.012, M.metal, 0.56, -0.04, 0);
-    parts.trigger = box2(group, 4e-3, 0.018, 4e-3, M.dark, 0.535, -0.045, 0, 0.15);
+    box3(rearGrip, 0.03, 0.1, 0.03, M.wood, 0, -0.05, 0);
+    box3(group, 0.06, 4e-3, 0.012, M.metal, 0.53, -0.05, 0);
+    box3(group, 4e-3, 0.025, 0.012, M.metal, 0.56, -0.04, 0);
+    parts.trigger = box3(group, 4e-3, 0.018, 4e-3, M.dark, 0.535, -0.045, 0, 0.15);
     const hammer = kit.pivot(group, 0.44, -0.012, 0);
     parts.hammer = hammer;
-    box2(hammer, 0.012, 0.02, 0.01, M.dark, 0, 0, 0);
-    box2(group, 6e-3, 0.03, 6e-3, M.dark, 0.78, 0.032, 0);
-    box2(group, 0.02, 0.022, 0.014, M.dark, 0.46, 0.032, 0);
-    box2(group, 0.12, 0.042, 0.032, M.dark, 0.5, 0.04, -0.04);
+    box3(hammer, 0.012, 0.02, 0.01, M.dark, 0, 0, 0);
+    box3(group, 6e-3, 0.03, 6e-3, M.dark, 0.78, 0.032, 0);
+    box3(group, 0.02, 0.022, 0.014, M.dark, 0.46, 0.032, 0);
+    box3(group, 0.12, 0.042, 0.032, M.dark, 0.5, 0.04, -0.04);
     cylinderX(group, 0.013, 0.05, M.rubber, 0.42, 0.048, -0.04, 14);
     cylinderX(group, 0.016, 4e-3, M.lens, 0.565, 0.048, -0.04, 14);
-    box2(group, 0.04, 0.012, 0.012, M.metal, 0.5, 0.016, -0.03);
+    box3(group, 0.04, 0.012, 0.012, M.metal, 0.5, 0.016, -0.03);
     const round3 = buildRocketGrenade(kit);
     round3.position.x = 0.95;
     group.add(round3);
@@ -17683,7 +17872,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     parts.rear = kit.pivot(group, 0, 0, 0);
   }
   function buildM72(kit, group, parts) {
-    const { M, box: box2, cylinderX, cylinderY } = kit;
+    const { M, box: box3, cylinderX, cylinderY } = kit;
     parts.kick = 1.1;
     parts.disposable = true;
     heatify(parts.glow, cylinderX(group, 0.0365, 0.6, M.olive, 0.58, 0, 0, 20));
@@ -17692,40 +17881,40 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     cylinderX(group, 0.035, 0.025, M.rubber, 0.012, 0, 0, 20);
     cylinderX(group, 0.037, 0.015, M.yellow, 0.8, 0, 0, 20);
     cylinderX(group, 0.037, 0.012, M.dark, 0.3, 0, 0, 20);
-    box2(group, 4e-3, 0.05, 0.05, M.dark, 0.79, 0.055, 0);
-    box2(group, 4e-3, 6e-3, 0.04, M.dark, 0.79, 0.078, 0);
-    box2(group, 4e-3, 0.035, 0.024, M.dark, 0.38, 0.05, 0);
+    box3(group, 4e-3, 0.05, 0.05, M.dark, 0.79, 0.055, 0);
+    box3(group, 4e-3, 6e-3, 0.04, M.dark, 0.79, 0.078, 0);
+    box3(group, 4e-3, 0.035, 0.024, M.dark, 0.38, 0.05, 0);
     cylinderY(group, 4e-3, 6e-3, M.lens, 0.38, 0.064, 0, 8);
-    parts.trigger = box2(group, 0.05, 0.016, 0.024, M.rubber, 0.5, 0.042, 0);
-    box2(group, 0.1, 0.01, 0.03, M.dark, 0.47, 0.036, 0);
-    box2(group, 0.02, 0.03, 0.01, M.dark, 0.66, -0.035, 0.03);
-    box2(group, 8e-3, 0.03, 8e-3, M.metal, 0.25, -0.04, 0.03);
+    parts.trigger = box3(group, 0.05, 0.016, 0.024, M.rubber, 0.5, 0.042, 0);
+    box3(group, 0.1, 0.01, 0.03, M.dark, 0.47, 0.036, 0);
+    box3(group, 0.02, 0.03, 0.01, M.dark, 0.66, -0.035, 0.03);
+    box3(group, 8e-3, 0.03, 8e-3, M.metal, 0.25, -0.04, 0.03);
     parts.muzzle = kit.pivot(group, 0.881, 0, 0);
     parts.rear = kit.pivot(group, 0, 0, 0);
   }
   function buildAt4(kit, group, parts) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     parts.kick = 1.3;
     parts.disposable = true;
     heatify(parts.glow, cylinderX(group, 0.05, 0.86, M.olive, 0.51, 0, 0, 24));
     cylinderX(group, 0.056, 0.08, M.dark, 0.98, 0, 0, 24);
     cylinderX(group, 0.058, 0.07, M.dark, 0.04, 0, 0, 24, 0.05);
     cylinderX(group, 0.051, 0.015, M.yellow, 0.86, 0, 0, 24);
-    box2(group, 0.16, 0.026, 0.05, M.dark, 0.42, 0.058, 0);
-    box2(group, 0.03, 0.012, 0.016, M.red, 0.47, 0.075, 0);
-    parts.trigger = box2(group, 0.022, 0.012, 0.018, M.rubber, 0.5, 0.074, 0);
-    box2(group, 0.012, 0.07, 0.02, M.dark, 0.35, 0.09, -0.035);
-    box2(group, 0.012, 0.05, 0.02, M.dark, 0.71, 0.08, -0.035);
+    box3(group, 0.16, 0.026, 0.05, M.dark, 0.42, 0.058, 0);
+    box3(group, 0.03, 0.012, 0.016, M.red, 0.47, 0.075, 0);
+    parts.trigger = box3(group, 0.022, 0.012, 0.018, M.rubber, 0.5, 0.074, 0);
+    box3(group, 0.012, 0.07, 0.02, M.dark, 0.35, 0.09, -0.035);
+    box3(group, 0.012, 0.05, 0.02, M.dark, 0.71, 0.08, -0.035);
     const grip = kit.pivot(group, 0.68, -0.05, 0);
     grip.rotation.z = -0.15;
-    box2(grip, 0.035, 0.11, 0.032, M.dark, 0, -0.05, 0);
-    box2(group, 0.14, 0.035, 0.06, M.rubber, 0.32, -0.06, 0);
-    box2(group, 0.3, 0.012, 0.055, M.dark, 0.5, -0.05, 0);
+    box3(grip, 0.035, 0.11, 0.032, M.dark, 0, -0.05, 0);
+    box3(group, 0.14, 0.035, 0.06, M.rubber, 0.32, -0.06, 0);
+    box3(group, 0.3, 0.012, 0.055, M.dark, 0.5, -0.05, 0);
     parts.muzzle = kit.pivot(group, 1.02, 0, 0);
     parts.rear = kit.pivot(group, 0, 0, 0);
   }
   function buildCarlGustaf(kit, group, parts) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     parts.kick = 1.4;
     heatify(parts.glow, cylinderX(group, 0.045, 0.72, M.dark, 0.59, 0, 0, 24));
     cylinderX(group, 0.05, 0.04, M.rubber, 0.93, 0, 0, 24);
@@ -17733,23 +17922,23 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     parts.breech = [breech];
     cylinderX(breech, 0.06, 0.16, M.dark, -0.1, 0, -0.05, 24, 0.046);
     cylinderX(breech, 0.062, 0.015, M.metal, -0.18, 0, -0.05, 24);
-    box2(group, 0.025, 0.03, 0.02, M.metal, 0.22, 0, 0.052);
+    box3(group, 0.025, 0.03, 0.02, M.metal, 0.22, 0, 0.052);
     const foreGrip = kit.pivot(group, 0.62, -0.05, 0);
     foreGrip.rotation.z = -0.2;
-    box2(foreGrip, 0.035, 0.11, 0.034, M.dark, 0, -0.05, 0);
-    parts.trigger = box2(group, 4e-3, 0.018, 4e-3, M.dark, 0.66, -0.06, 0, 0.15);
-    box2(group, 0.06, 4e-3, 0.012, M.metal, 0.66, -0.07, 0);
+    box3(foreGrip, 0.035, 0.11, 0.034, M.dark, 0, -0.05, 0);
+    parts.trigger = box3(group, 4e-3, 0.018, 4e-3, M.dark, 0.66, -0.06, 0, 0.15);
+    box3(group, 0.06, 4e-3, 0.012, M.metal, 0.66, -0.07, 0);
     const rearGrip = kit.pivot(group, 0.4, -0.05, 0);
     rearGrip.rotation.z = -0.25;
-    box2(rearGrip, 0.035, 0.1, 0.034, M.dark, 0, -0.05, 0);
-    box2(group, 0.13, 0.04, 0.07, M.rubber, 0.28, -0.065, 0);
-    box2(group, 0.16, 0.05, 0.045, M.dark, 0.56, 0.07, -0.035);
+    box3(rearGrip, 0.035, 0.1, 0.034, M.dark, 0, -0.05, 0);
+    box3(group, 0.13, 0.04, 0.07, M.rubber, 0.28, -0.065, 0);
+    box3(group, 0.16, 0.05, 0.045, M.dark, 0.56, 0.07, -0.035);
     cylinderX(group, 0.016, 0.05, M.rubber, 0.46, 0.075, -0.035, 14);
     cylinderX(group, 0.02, 4e-3, M.lens, 0.645, 0.075, -0.035, 14);
-    box2(group, 0.06, 0.02, 0.02, M.metal, 0.56, 0.04, -0.03);
-    box2(group, 0.22, 0.01, 0.02, M.dark, 0.6, 0.06, 0.03);
-    box2(group, 0.01, 0.03, 0.02, M.dark, 0.5, 0.05, 0.03);
-    box2(group, 0.01, 0.03, 0.02, M.dark, 0.7, 0.05, 0.03);
+    box3(group, 0.06, 0.02, 0.02, M.metal, 0.56, 0.04, -0.03);
+    box3(group, 0.22, 0.01, 0.02, M.dark, 0.6, 0.06, 0.03);
+    box3(group, 0.01, 0.03, 0.02, M.dark, 0.5, 0.05, 0.03);
+    box3(group, 0.01, 0.03, 0.02, M.dark, 0.7, 0.05, 0.03);
     parts.makeRound = () => buildRecoillessRound(kit);
     parts.muzzle = kit.pivot(group, 0.95, 0, 0);
     parts.rear = kit.pivot(group, 0.05, 0, 0);
@@ -17800,37 +17989,37 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     cylinderX(barrels, CLUSTER_RADIUS + BARREL_RADIUS * 1.8, 0.03, M.dark, BARREL_END - 0.015, 0, 0, 24);
   }
   function buildHousing(kit, parts, group) {
-    const { M, box: box2, cylinderX, cylinderZ } = kit;
-    box2(group, 0.3, 0.14, 0.15, M.metal, 0.18, 0, 0);
+    const { M, box: box3, cylinderX, cylinderZ } = kit;
+    box3(group, 0.3, 0.14, 0.15, M.metal, 0.18, 0, 0);
     cylinderX(group, 0.052, 0.12, M.dark, 0.06, 0, 0, 20);
     cylinderX(group, 0.062, 0.2, M.dark, 0.38, 0, 0, 22);
     for (let i = 0; i < 4; i++) cylinderX(group, 0.064, 8e-3, M.steel, 0.3 + i * 0.05, 0, 0, 22);
-    box2(group, 0.04, 0.05, 0.2, M.dark, 0.1, 0.095, 0);
-    box2(group, 0.2, 0.012, 0.045, M.dark, 0.22, 0.158, 0);
-    box2(group, 0.012, 0.05, 0.045, M.dark, 0.13, 0.13, 0);
-    box2(group, 0.012, 0.05, 0.045, M.dark, 0.31, 0.13, 0);
+    box3(group, 0.04, 0.05, 0.2, M.dark, 0.1, 0.095, 0);
+    box3(group, 0.2, 0.012, 0.045, M.dark, 0.22, 0.158, 0);
+    box3(group, 0.012, 0.05, 0.045, M.dark, 0.13, 0.13, 0);
+    box3(group, 0.012, 0.05, 0.045, M.dark, 0.31, 0.13, 0);
     for (const side of [-1, 1]) {
-      box2(group, 0.03, 0.03, 0.1, M.poly, 0.06, -0.01, side * 0.14);
+      box3(group, 0.03, 0.03, 0.1, M.poly, 0.06, -0.01, side * 0.14);
       cylinderZ(group, 0.016, 0.07, M.poly, 0.06, -0.01, side * 0.2, 14);
     }
-    parts.trigger = box2(group, 0.012, 0.02, 0.016, M.dark, 0.1, 0.085, 0.14, 0.3);
-    parts.safety = box2(group, 0.014, 6e-3, 0.01, M.dark, 0.2, 0.073, -0.076, 0.4);
+    parts.trigger = box3(group, 0.012, 0.02, 0.016, M.dark, 0.1, 0.085, 0.14, 0.3);
+    parts.safety = box3(group, 0.014, 6e-3, 0.01, M.dark, 0.2, 0.073, -0.076, 0.4);
   }
   function buildFeed(kit, parts, group) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const belt = kit.pivot(group, 0.2, -0.13, -0.16);
     parts.belt = belt;
-    box2(belt, 0.16, 0.12, 0.1, M.olive, 0, 0, 0);
-    box2(belt, 0.162, 0.012, 0.102, M.dark, 0, 0.056, 0);
+    box3(belt, 0.16, 0.12, 0.1, M.olive, 0, 0, 0);
+    box3(belt, 0.162, 0.012, 0.102, M.dark, 0, 0.056, 0);
     for (let i = 0; i < 8; i++) cylinderX(belt, 46e-4, 0.04, M.brass, -0.07 + i * 0.02, 0.075, 0.04, 10);
-    box2(group, 0.1, 0.03, 0.1, M.metal, 0.22, -0.06, -0.1, 0, 0, 0.5);
+    box3(group, 0.1, 0.03, 0.1, M.metal, 0.22, -0.06, -0.1, 0, 0, 0.5);
     const cover = kit.pivot(group, 0.1, 0.075, 0);
     parts.cover = cover;
-    box2(cover, 0.24, 0.012, 0.15, M.metal, 0.12, 6e-3, 0);
+    box3(cover, 0.24, 0.012, 0.15, M.metal, 0.12, 6e-3, 0);
     const bolt = kit.pivot(group);
     parts.bolt = bolt;
     parts.stroke = 0.03;
-    box2(bolt, 0.03, 0.012, 0.012, M.steelL, 0.28, 0.02, 0.078);
+    box3(bolt, 0.03, 0.012, 0.012, M.steelL, 0.28, 0.02, 0.078);
   }
   function buildM134(kit) {
     const group = kit.group();
@@ -17860,36 +18049,36 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
 
   // src/models/m2.ts
   function buildM2(kit) {
-    const { M, box: box2, cylinderX, cylinderZ } = kit;
+    const { M, box: box3, cylinderX, cylinderZ } = kit;
     const group = kit.group();
     const parts = { family: "belt", kick: 2.2, stroke: 0.08, glow: [] };
-    box2(group, 0.52, 0.13, 0.12, M.metal, 0.36, 0, 0);
+    box3(group, 0.52, 0.13, 0.12, M.metal, 0.36, 0, 0);
     for (let i = 0; i < 5; i++) cylinderZ(group, 6e-3, 0.124, M.dark, 0.15 + i * 0.1, -0.03, 0, 10);
     heatify(parts.glow, cylinderX(group, 0.016, 1.14, M.metal, 1.14, 0.01, 0, 16));
     cylinderX(group, 0.034, 0.24, M.dark, 0.74, 0.01, 0, 16);
     for (let i = 0; i < 6; i++) cylinderX(group, 0.036, 0.012, M.metal, 0.66 + i * 0.035, 0.01, 0, 16);
     cylinderX(group, 0.022, 0.05, M.dark, 1.69, 0.01, 0, 16);
-    box2(group, 0.04, 0.09, 0.03, M.wood, 0.05, -0.02, 0.05);
-    box2(group, 0.04, 0.09, 0.03, M.wood, 0.05, -0.02, -0.05);
-    box2(group, 0.06, 0.02, 0.12, M.metal, 0.09, -0.02, 0);
+    box3(group, 0.04, 0.09, 0.03, M.wood, 0.05, -0.02, 0.05);
+    box3(group, 0.04, 0.09, 0.03, M.wood, 0.05, -0.02, -0.05);
+    box3(group, 0.06, 0.02, 0.12, M.metal, 0.09, -0.02, 0);
     const belt = kit.pivot(group, 0.38, -0.05, -0.12);
     parts.belt = belt;
-    box2(belt, 0.16, 0.12, 0.09, M.olive, 0, 0, 0);
+    box3(belt, 0.16, 0.12, 0.09, M.olive, 0, 0, 0);
     for (let i = 0; i < 8; i++) cylinderX(belt, 6e-3, 0.05, M.brass, -0.08 + i * 0.02, 0.08, 0.04, 8);
     const cover = kit.pivot(group, 0.12, 0.065, 0);
     parts.cover = cover;
-    box2(cover, 0.4, 0.012, 0.12, M.metal, 0.2, 6e-3, 0);
-    box2(group, 0.04, 0.05, 0.04, M.dark, 0.66, 0.1, 0);
+    box3(cover, 0.4, 0.012, 0.12, M.metal, 0.2, 6e-3, 0);
+    box3(group, 0.04, 0.05, 0.04, M.dark, 0.66, 0.1, 0);
     const bolt = kit.pivot(group);
     parts.bolt = bolt;
-    box2(bolt, 0.03, 0.03, 0.02, M.metal, 0.5, 0, 0.07);
+    box3(bolt, 0.03, 0.03, 0.02, M.metal, 0.5, 0, 0.07);
     const tripod = kit.group();
     tripod.position.set(0.42, -0.1, 0);
     group.add(tripod);
-    box2(tripod, 0.03, 0.06, 0.03, M.metal, 0, 0, 0);
-    box2(tripod, 0.012, 0.62, 0.012, M.metal, -0.2, -0.25, 0, 0.75);
-    box2(tripod, 0.012, 0.62, 0.012, M.metal, 0.22, -0.25, 0.16, -0.75, 0, 0.3);
-    box2(tripod, 0.012, 0.62, 0.012, M.metal, 0.22, -0.25, -0.16, -0.75, 0, -0.3);
+    box3(tripod, 0.03, 0.06, 0.03, M.metal, 0, 0, 0);
+    box3(tripod, 0.012, 0.62, 0.012, M.metal, -0.2, -0.25, 0, 0.75);
+    box3(tripod, 0.012, 0.62, 0.012, M.metal, 0.22, -0.25, 0.16, -0.75, 0, 0.3);
+    box3(tripod, 0.012, 0.62, 0.012, M.metal, 0.22, -0.25, -0.16, -0.75, 0, -0.3);
     parts.muzzle = kit.mark(group, 1.72, 0.01, 0);
     parts.eject = kit.mark(group, 0.3, -0.07, 0);
     return { group, parts };
@@ -17897,26 +18086,26 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
 
   // src/models/p90.ts
   function buildP90(kit) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const group = kit.group();
     const parts = { family: "p90", stroke: 0.04, kick: 0.6, glow: [] };
-    box2(group, 0.4, 0.07, 0.055, M.poly, 0.2, 0, 0);
-    box2(group, 0.12, 0.075, 0.05, M.poly, 0.2, -0.07, 0);
-    box2(group, 0.08, 0.04, 0.03, M.hole, 0.21, -0.06, 0);
-    box2(group, 0.06, 0.13, 0.056, M.poly, 0.03, -0.03, 0);
-    box2(group, 0.05, 0.03, 0.056, M.poly, 0.33, -0.04, 0);
+    box3(group, 0.4, 0.07, 0.055, M.poly, 0.2, 0, 0);
+    box3(group, 0.12, 0.075, 0.05, M.poly, 0.2, -0.07, 0);
+    box3(group, 0.08, 0.04, 0.03, M.hole, 0.21, -0.06, 0);
+    box3(group, 0.06, 0.13, 0.056, M.poly, 0.03, -0.03, 0);
+    box3(group, 0.05, 0.03, 0.056, M.poly, 0.33, -0.04, 0);
     heatify(parts.glow, cylinderX(group, 8e-3, 0.09, M.metal, 0.43, 0, 0, 16));
     const magazine = kit.pivot(group, 0.22, 0.047, 0);
     parts.mag = magazine;
     parts.magDir = 1;
     parts.magDrop = 0.08;
-    box2(magazine, 0.3, 0.022, 0.05, M.glass, 0, 0, 0);
+    box3(magazine, 0.3, 0.022, 0.05, M.glass, 0, 0, 0);
     for (let i = 0; i < 12; i++) cylinderX(magazine, 28e-4, 0.02, M.brass, -0.12 + i * 0.022, 0, 0, 6);
     scope(kit, group, 1, 0.24, 0.06, 0);
     const bolt = kit.pivot(group);
     parts.bolt = bolt;
-    box2(bolt, 0.02, 0.012, 0.012, M.dark, 0.3, 0.02, 0.03);
-    parts.trigger = box2(group, 4e-3, 0.016, 4e-3, M.dark, 0.24, -0.045, 0);
+    box3(bolt, 0.02, 0.012, 0.012, M.dark, 0.3, 0.02, 0.03);
+    parts.trigger = box3(group, 4e-3, 0.016, 4e-3, M.dark, 0.24, -0.045, 0);
     parts.muzzle = kit.mark(group, 0.48, 0, 0);
     parts.eject = kit.mark(group, 0.2, -0.07, 0);
     return { group, parts };
@@ -17938,28 +18127,28 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   // src/models/pistol-slide.ts
   var PI5 = Math.PI;
   function buildSlide(kit, slide2, parts, options, style, size, metal2) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const { length: L, width: w } = size;
     const slideHeight = style.inset ? size.height * 0.92 : size.height;
     const slideWidth = style.inset ? w * 0.86 : w;
     kit.roundness = style.rf;
-    if (style.tri) box2(slide2, L * 0.42, slideHeight, slideWidth, metal2, L * 0.21, 0, 0);
+    if (style.tri) box3(slide2, L * 0.42, slideHeight, slideWidth, metal2, L * 0.21, 0, 0);
     else if (style.open) {
-      box2(slide2, L * 0.45, slideHeight, slideWidth, metal2, L * 0.225, 0, 0);
-      box2(slide2, L * 0.55, slideHeight * 0.62, slideWidth, metal2, L * 0.72, -slideHeight * 0.19, 0);
-    } else box2(slide2, L, slideHeight, slideWidth, metal2, L / 2, 0, 0);
-    if (style.slope) box2(slide2, L * 0.25, slideHeight * 0.5, slideWidth * 0.98, metal2, L * 0.86, slideHeight * 0.35, 0, -0.22);
+      box3(slide2, L * 0.45, slideHeight, slideWidth, metal2, L * 0.225, 0, 0);
+      box3(slide2, L * 0.55, slideHeight * 0.62, slideWidth, metal2, L * 0.72, -slideHeight * 0.19, 0);
+    } else box3(slide2, L, slideHeight, slideWidth, metal2, L / 2, 0, 0);
+    if (style.slope) box3(slide2, L * 0.25, slideHeight * 0.5, slideWidth * 0.98, metal2, L * 0.86, slideHeight * 0.35, 0, -0.22);
     kit.roundness = null;
-    for (let i = 0; i < (style.flush ? 9 : 7); i++) box2(slide2, 22e-4, slideHeight * 0.72, slideWidth + 14e-4, M.dark, 7e-3 + i * 52e-4, -2e-3, 0, 0);
-    if (style.frontSer) for (let i = 0; i < 5; i++) box2(slide2, 22e-4, slideHeight * 0.6, slideWidth + 14e-4, M.dark, L * 0.76 + i * 52e-4, -3e-3, 0);
+    for (let i = 0; i < (style.flush ? 9 : 7); i++) box3(slide2, 22e-4, slideHeight * 0.72, slideWidth + 14e-4, M.dark, 7e-3 + i * 52e-4, -2e-3, 0, 0);
+    if (style.frontSer) for (let i = 0; i < 5; i++) box3(slide2, 22e-4, slideHeight * 0.6, slideWidth + 14e-4, M.dark, L * 0.76 + i * 52e-4, -3e-3, 0);
     if (style.port) {
-      box2(slide2, L * style.port, 4e-3, slideWidth * 0.55, M.hole, L * 0.6, slideHeight / 2 - 1e-3, slideWidth * 0.12);
-      box2(slide2, L * style.port * 0.85, 3e-3, slideWidth * 0.4, M.steelL, L * 0.6, slideHeight / 2 - 4e-4, slideWidth * 0.1);
-      box2(slide2, 0.012, 4e-3, 2e-3, M.dark, L * 0.55, slideHeight * 0.15, slideWidth / 2 + 8e-4);
+      box3(slide2, L * style.port, 4e-3, slideWidth * 0.55, M.hole, L * 0.6, slideHeight / 2 - 1e-3, slideWidth * 0.12);
+      box3(slide2, L * style.port * 0.85, 3e-3, slideWidth * 0.4, M.steelL, L * 0.6, slideHeight / 2 - 4e-4, slideWidth * 0.1);
+      box3(slide2, 0.012, 4e-3, 2e-3, M.dark, L * 0.55, slideHeight * 0.15, slideWidth / 2 + 8e-4);
     }
     if (style.open) {
       heatify(parts.glow, cylinderX(slide2, 62e-4, L * 0.56, M.steelL, L * 0.7, slideHeight * 0.12, 0, 18));
-      box2(slide2, 0.03, 4e-3, slideWidth * 0.6, M.hole, L * 0.48, slideHeight / 2 - 1e-3, 0);
+      box3(slide2, 0.03, 4e-3, slideWidth * 0.6, M.hole, L * 0.48, slideHeight / 2 - 1e-3, 0);
     }
     if (style.tri) {
       const tube = new kit.THREE.Mesh(new kit.THREE.CylinderGeometry(0.016, 0.016, L * 0.6, 3), metal2);
@@ -17969,8 +18158,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       tube.position.set(L * 0.7, slideHeight * 0.08, 0);
       slide2.add(tube);
       heatify(parts.glow, tube);
-      box2(slide2, L * 0.6, 6e-3, 0.012, metal2, L * 0.7, slideHeight * 0.38, 0);
-      for (let i = 0; i < 6; i++) box2(slide2, 8e-3, 3e-3, 0.013, M.hole, L * 0.45 + i * 0.04, slideHeight * 0.41, 0);
+      box3(slide2, L * 0.6, 6e-3, 0.012, metal2, L * 0.7, slideHeight * 0.38, 0);
+      for (let i = 0; i < 6; i++) box3(slide2, 8e-3, 3e-3, 0.013, M.hole, L * 0.45 + i * 0.04, slideHeight * 0.41, 0);
     }
     if (style.bushing) {
       heatify(parts.glow, cylinderX(slide2, 78e-4, 6e-3, M.steelL, L + 2e-3, 1e-3, 0, 18));
@@ -17981,22 +18170,22 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     cylinderX(slide2, 34e-4, 5e-3, M.hole, L + 25e-4, muzzleY, 0, 12);
     const top = slideHeight / 2;
     if (style.sight === "u" || style.sight === "3dot") {
-      box2(slide2, 4e-3, 7e-3, 4e-3, M.dark, L - 8e-3, top + 35e-4, 0);
-      box2(slide2, 22e-4, 22e-4, 46e-4, M.white, L - 8e-3, top + 58e-4, 0);
-      box2(slide2, 8e-3, 7e-3, 0.016, M.dark, 9e-3, top + 35e-4, 0);
-      if (style.sight === "u") box2(slide2, 4e-3, 2e-3, 0.0122, M.white, 9e-3, top + 6e-3, 0);
-      else box2(slide2, 22e-4, 22e-4, 0.0166, M.white, 9e-3, top + 58e-4, 0);
+      box3(slide2, 4e-3, 7e-3, 4e-3, M.dark, L - 8e-3, top + 35e-4, 0);
+      box3(slide2, 22e-4, 22e-4, 46e-4, M.white, L - 8e-3, top + 58e-4, 0);
+      box3(slide2, 8e-3, 7e-3, 0.016, M.dark, 9e-3, top + 35e-4, 0);
+      if (style.sight === "u") box3(slide2, 4e-3, 2e-3, 0.0122, M.white, 9e-3, top + 6e-3, 0);
+      else box3(slide2, 22e-4, 22e-4, 0.0166, M.white, 9e-3, top + 58e-4, 0);
     } else {
-      box2(slide2, 6e-3, 4e-3, 3e-3, M.dark, L - 6e-3, top + 2e-3, 0);
-      box2(slide2, 6e-3, 4e-3, 0.012, M.dark, 8e-3, top + 2e-3, 0);
+      box3(slide2, 6e-3, 4e-3, 3e-3, M.dark, L - 6e-3, top + 2e-3, 0);
+      box3(slide2, 6e-3, 4e-3, 0.012, M.dark, 8e-3, top + 2e-3, 0);
     }
     if (style.decock === "slide") {
-      box2(slide2, 0.012, 8e-3, 4e-3, M.dark, 0.02, slideHeight * 0.15, slideWidth / 2 + 2e-3, 0.3);
-      box2(slide2, 0.012, 8e-3, 4e-3, M.dark, 0.02, slideHeight * 0.15, -slideWidth / 2 - 2e-3, 0.3);
+      box3(slide2, 0.012, 8e-3, 4e-3, M.dark, 0.02, slideHeight * 0.15, slideWidth / 2 + 2e-3, 0.3);
+      box3(slide2, 0.012, 8e-3, 4e-3, M.dark, 0.02, slideHeight * 0.15, -slideWidth / 2 - 2e-3, 0.3);
     }
-    if (style.safety === "slide") parts.safety = box2(slide2, 0.012, 8e-3, 4e-3, M.dark, 0.018, slideHeight * 0.1, -slideWidth / 2 - 2e-3, 0.2);
+    if (style.safety === "slide") parts.safety = box3(slide2, 0.012, 8e-3, 4e-3, M.dark, 0.018, slideHeight * 0.1, -slideWidth / 2 - 2e-3, 0.2);
     if (options.sel) {
-      const selector = box2(slide2, 0.01, 8e-3, 3e-3, M.dark, 0.014, -slideHeight * 0.2, slideWidth / 2 + 14e-4);
+      const selector = box3(slide2, 0.01, 8e-3, 3e-3, M.dark, 0.014, -slideHeight * 0.2, slideWidth / 2 + 14e-4);
       parts.safety ?? (parts.safety = selector);
     }
   }
@@ -18019,29 +18208,29 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   // src/models/pistol.ts
   var PI6 = Math.PI;
   function buildFrame(kit, group, parts, options, style, size, materials) {
-    const { M, box: box2, cylinderZ, sphere } = kit;
+    const { M, box: box3, cylinderZ, sphere: sphere2 } = kit;
     const { length: L, height: h, width: w } = size;
     const fm = materials.frame;
     if (style.inset) {
-      box2(group, L * 0.9, h * 0.35, w * 0.12, fm, L * 0.47, -h * 0.32, w * 0.47);
-      box2(group, L * 0.9, h * 0.35, w * 0.12, fm, L * 0.47, -h * 0.32, -w * 0.47);
+      box3(group, L * 0.9, h * 0.35, w * 0.12, fm, L * 0.47, -h * 0.32, w * 0.47);
+      box3(group, L * 0.9, h * 0.35, w * 0.12, fm, L * 0.47, -h * 0.32, -w * 0.47);
     }
     const frameLength = style.tri ? L * 0.66 : L * 0.8;
     kit.roundness = style.rf;
-    box2(group, frameLength, 0.016, w * 0.92, fm, frameLength / 2 + L * 0.06, -h / 2 - 8e-3, 0);
+    box3(group, frameLength, 0.016, w * 0.92, fm, frameLength / 2 + L * 0.06, -h / 2 - 8e-3, 0);
     kit.roundness = null;
-    if (style.rail) for (let i = 0; i < (style.slope ? 5 : 3); i++) box2(group, 4e-3, 3e-3, w * 0.96, M.dark, L * 0.62 + i * 9e-3, -h / 2 - 0.017, 0);
+    if (style.rail) for (let i = 0; i < (style.slope ? 5 : 3); i++) box3(group, 4e-3, 3e-3, w * 0.96, M.dark, L * 0.62 + i * 9e-3, -h / 2 - 0.017, 0);
     const isGlock = options.st === "glock" || !options.st;
     if (isGlock) {
-      box2(group, 8e-3, 4e-3, 3e-3, M.dark, L * 0.5, -h / 2 - 3e-3, -w / 2 - 12e-4);
-      box2(group, 8e-3, 4e-3, 3e-3, M.dark, L * 0.5, -h / 2 - 3e-3, w / 2 + 12e-4);
+      box3(group, 8e-3, 4e-3, 3e-3, M.dark, L * 0.5, -h / 2 - 3e-3, -w / 2 - 12e-4);
+      box3(group, 8e-3, 4e-3, 3e-3, M.dark, L * 0.5, -h / 2 - 3e-3, w / 2 + 12e-4);
     }
     if (style.slideStop) {
-      box2(group, 0.03, 6e-3, 3e-3, M.dark, L * 0.42, -h / 2 - 2e-3, -w / 2 - 14e-4);
-      sphere(group, 28e-4, M.dark, L * 0.55, -h / 2 - 3e-3, w / 2 + 1e-3, 1);
-    } else box2(group, 0.012, 4e-3, 3e-3, M.dark, L * 0.45, -h / 2 - 3e-3, -w / 2 - 12e-4);
-    if (style.decock === "frame") box2(group, 0.01, 0.012, 3e-3, M.dark, L * 0.38, -h / 2 - 0.012, -w / 2 - 14e-4, 0.6);
-    if (style.safety === "thumb") parts.safety = box2(group, 0.014, 6e-3, 4e-3, M.dark, 0.02, -h / 2 - 2e-3, -w / 2 - 16e-4);
+      box3(group, 0.03, 6e-3, 3e-3, M.dark, L * 0.42, -h / 2 - 2e-3, -w / 2 - 14e-4);
+      sphere2(group, 28e-4, M.dark, L * 0.55, -h / 2 - 3e-3, w / 2 + 1e-3, 1);
+    } else box3(group, 0.012, 4e-3, 3e-3, M.dark, L * 0.45, -h / 2 - 3e-3, -w / 2 - 12e-4);
+    if (style.decock === "frame") box3(group, 0.01, 0.012, 3e-3, M.dark, L * 0.38, -h / 2 - 0.012, -w / 2 - 14e-4, 0.6);
+    if (style.safety === "thumb") parts.safety = box3(group, 0.014, 6e-3, 4e-3, M.dark, 0.02, -h / 2 - 2e-3, -w / 2 - 16e-4);
     const gripLength = options.gl ?? 0.105;
     const gx = 0.034 + (L - 0.2) * 0.15;
     const gy = -h / 2 - gripLength / 2 + 6e-3;
@@ -18051,41 +18240,41 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const gripDepth = style.grip === "chunky" ? 0.036 : 0.032;
     kit.roundness = 0.3;
     if (style.grip === "wood" || style.grip === "star") {
-      box2(grip, gripDepth * 0.86, gripLength, w * 0.9, fm, 0, 0, 0);
-      box2(grip, gripDepth * 0.8, gripLength * 0.86, 4e-3, materials.grip, 1e-3, -2e-3, w * 0.47);
-      box2(grip, gripDepth * 0.8, gripLength * 0.86, 4e-3, materials.grip, 1e-3, -2e-3, -w * 0.47);
+      box3(grip, gripDepth * 0.86, gripLength, w * 0.9, fm, 0, 0, 0);
+      box3(grip, gripDepth * 0.8, gripLength * 0.86, 4e-3, materials.grip, 1e-3, -2e-3, w * 0.47);
+      box3(grip, gripDepth * 0.8, gripLength * 0.86, 4e-3, materials.grip, 1e-3, -2e-3, -w * 0.47);
       if (style.grip === "wood") {
-        for (let i = 0; i < 6; i++) for (let j = 0; j < 2; j++) box2(grip, 3e-3, 3e-3, 12e-4, M.woodL, -6e-3 + j * 0.012, -gripLength * 0.3 + i * 0.012, w * 0.495, 0, 0, 0);
+        for (let i = 0; i < 6; i++) for (let j = 0; j < 2; j++) box3(grip, 3e-3, 3e-3, 12e-4, M.woodL, -6e-3 + j * 0.012, -gripLength * 0.3 + i * 0.012, w * 0.495, 0, 0, 0);
         cylinderZ(grip, 35e-4, 15e-4, M.brass, 0, gripLength * 0.25, w * 0.5, 10);
         cylinderZ(grip, 35e-4, 15e-4, M.brass, 0, -gripLength * 0.3, w * 0.5, 10);
       } else cylinderZ(grip, 8e-3, 15e-4, M.dark, 0, gripLength * 0.1, w * 0.5, 5);
-    } else box2(grip, gripDepth, gripLength, gripWidth, materials.grip, 0, 0, 0);
+    } else box3(grip, gripDepth, gripLength, gripWidth, materials.grip, 0, 0, 0);
     kit.roundness = null;
     if (style.grip === "finger") {
-      for (let i = 0; i < 3; i++) box2(grip, 6e-3, 0.012, gripWidth * 0.98, materials.grip, gripDepth / 2 + 2e-3, gripLength * 0.18 - i * 0.022, 0);
-      for (let i = 0; i < 5; i++) for (let j = 0; j < 3; j++) box2(grip, 3e-3, 3e-3, 12e-4, M.dark, -8e-3 + j * 8e-3, -gripLength * 0.25 + i * 0.012, gripWidth / 2 + 4e-4);
+      for (let i = 0; i < 3; i++) box3(grip, 6e-3, 0.012, gripWidth * 0.98, materials.grip, gripDepth / 2 + 2e-3, gripLength * 0.18 - i * 0.022, 0);
+      for (let i = 0; i < 5; i++) for (let j = 0; j < 3; j++) box3(grip, 3e-3, 3e-3, 12e-4, M.dark, -8e-3 + j * 8e-3, -gripLength * 0.25 + i * 0.012, gripWidth / 2 + 4e-4);
     }
-    if (style.grip === "panel" || style.grip === "rubber" || style.grip === "chunky") for (let i = 0; i < 6; i++) box2(grip, gripDepth * 0.75, 25e-4, gripWidth + 1e-3, M.dark, 2e-3, -gripLength / 2 + 0.018 + i * 0.013, 0);
-    if (style.grip === "chunky") box2(grip, 8e-3, gripLength * 0.8, gripWidth * 0.9, materials.grip, gripDepth / 2 + 2e-3, -4e-3, 0);
+    if (style.grip === "panel" || style.grip === "rubber" || style.grip === "chunky") for (let i = 0; i < 6; i++) box3(grip, gripDepth * 0.75, 25e-4, gripWidth + 1e-3, M.dark, 2e-3, -gripLength / 2 + 0.018 + i * 0.013, 0);
+    if (style.grip === "chunky") box3(grip, 8e-3, gripLength * 0.8, gripWidth * 0.9, materials.grip, gripDepth / 2 + 2e-3, -4e-3, 0);
     if (style.beaver) {
-      box2(group, 0.026, 8e-3, w * 0.9, fm, -4e-3, -h / 2 - 4e-3, 0, 0.25);
-      box2(grip, 6e-3, gripLength * 0.55, w * 0.9, fm, -gripDepth * 0.5 - 2e-3, gripLength * 0.18, 0);
-    } else box2(group, 0.02, 9e-3, w * 0.9, fm, 4e-3, -h / 2 - 6e-3, 0);
+      box3(group, 0.026, 8e-3, w * 0.9, fm, -4e-3, -h / 2 - 4e-3, 0, 0.25);
+      box3(grip, 6e-3, gripLength * 0.55, w * 0.9, fm, -gripDepth * 0.5 - 2e-3, gripLength * 0.18, 0);
+    } else box3(group, 0.02, 9e-3, w * 0.9, fm, 4e-3, -h / 2 - 6e-3, 0);
     if (style.lanyard) {
-      const ring2 = kit.torus(grip, new kit.THREE.TorusGeometry(5e-3, 13e-4, 6, 12), M.dark, -0.012, -gripLength / 2 + 4e-3, 0);
-      ring2.position.set(-0.012, -gripLength / 2 + 4e-3, 0);
+      const ring3 = kit.torus(grip, new kit.THREE.TorusGeometry(5e-3, 13e-4, 6, 12), M.dark, -0.012, -gripLength / 2 + 4e-3, 0);
+      ring3.position.set(-0.012, -gripLength / 2 + 4e-3, 0);
     }
     const magazine = kit.pivot(grip);
     parts.mag = magazine;
     parts.magDrop = gripLength * 1.15;
-    box2(magazine, 0.022, gripLength * 0.94, w * 0.72, M.dark, 3e-3, -4e-3, 0);
-    if (style.grip === "chunky") box2(magazine, 0.04, 0.01, gripWidth * 1.02, M.poly, 3e-3, -gripLength / 2 - 4e-3, 0);
-    else if (style.flush || style.grip === "wood") box2(magazine, 0.028, 4e-3, w * 0.9, M.steel, 3e-3, -gripLength / 2 - 1e-3, 0);
-    else box2(magazine, 0.031, 6e-3, gripWidth * 1.02, M.dark, 3e-3, -gripLength / 2 - 2e-3, 0);
+    box3(magazine, 0.022, gripLength * 0.94, w * 0.72, M.dark, 3e-3, -4e-3, 0);
+    if (style.grip === "chunky") box3(magazine, 0.04, 0.01, gripWidth * 1.02, M.poly, 3e-3, -gripLength / 2 - 4e-3, 0);
+    else if (style.flush || style.grip === "wood") box3(magazine, 0.028, 4e-3, w * 0.9, M.steel, 3e-3, -gripLength / 2 - 1e-3, 0);
+    else box3(magazine, 0.031, 6e-3, gripWidth * 1.02, M.dark, 3e-3, -gripLength / 2 - 2e-3, 0);
     return { gx, ty: -h / 2 };
   }
   function buildPistol(kit, options) {
-    const { M, box: box2 } = kit;
+    const { M, box: box3 } = kit;
     const style = { ...STYLES[options.st ?? "glock"] };
     const group = kit.group();
     const parts = { family: "pistol", kick: options.deagle ? 1.8 : 0.6, glow: [] };
@@ -18100,31 +18289,31 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     buildSlide(kit, slide2, parts, options, style, size, slideMetal);
     const { gx, ty } = buildFrame(kit, group, parts, options, style, size, { frame: frameMetal, grip: gripMaterial });
     if (style.guard === "square") {
-      box2(group, 0.046, 4e-3, 9e-3, frameMetal, gx + 0.05, ty - 0.034, 0);
-      box2(group, 4e-3, 0.03, 9e-3, frameMetal, gx + 0.074, ty - 0.02, 0);
-      box2(group, 6e-3, 4e-3, 9e-3, frameMetal, gx + 0.075, ty - 0.034, 0);
+      box3(group, 0.046, 4e-3, 9e-3, frameMetal, gx + 0.05, ty - 0.034, 0);
+      box3(group, 4e-3, 0.03, 9e-3, frameMetal, gx + 0.074, ty - 0.02, 0);
+      box3(group, 6e-3, 4e-3, 9e-3, frameMetal, gx + 0.075, ty - 0.034, 0);
     } else if (style.guard === "hook") {
-      box2(group, 0.046, 4e-3, 9e-3, frameMetal, gx + 0.05, ty - 0.034, 0);
-      box2(group, 4e-3, 0.03, 9e-3, frameMetal, gx + 0.073, ty - 0.02, 0, 0.2);
-      box2(group, 8e-3, 6e-3, 9e-3, frameMetal, gx + 0.074, ty - 0.037, 0, 0.4);
+      box3(group, 0.046, 4e-3, 9e-3, frameMetal, gx + 0.05, ty - 0.034, 0);
+      box3(group, 4e-3, 0.03, 9e-3, frameMetal, gx + 0.073, ty - 0.02, 0, 0.2);
+      box3(group, 8e-3, 6e-3, 9e-3, frameMetal, gx + 0.074, ty - 0.037, 0, 0.4);
     } else {
       const guard = kit.torus(group, new kit.THREE.TorusGeometry(0.019, 22e-4, 6, 16, PI6), frameMetal, gx + 0.05, ty - 0.014, 0);
       guard.rotation.z = PI6;
       guard.scale.set(1.2, 1, 1);
     }
     const isGlock = options.st === "glock" || !options.st;
-    parts.trigger = box2(group, 4e-3, 0.014, 4e-3, isGlock ? M.dark : M.steel, gx + 0.042, ty - 0.022, 0, 0.2);
-    if (isGlock) box2(parts.trigger, 15e-4, 8e-3, 45e-4, M.metal, 0, -1e-3, 0);
+    parts.trigger = box3(group, 4e-3, 0.014, 4e-3, isGlock ? M.dark : M.steel, gx + 0.042, ty - 0.022, 0, 0.2);
+    if (isGlock) box3(parts.trigger, 15e-4, 8e-3, 45e-4, M.metal, 0, -1e-3, 0);
     if (style.hammer) {
       const hammer = kit.pivot(group, 3e-3, h / 2 - 8e-3, 0);
       parts.hammer = hammer;
       if (style.hammer === "ring") {
-        box2(hammer, 6e-3, 0.012, 6e-3, M.dark, -2e-3, 4e-3, 0, 0.3);
+        box3(hammer, 6e-3, 0.012, 6e-3, M.dark, -2e-3, 4e-3, 0, 0.3);
         kit.torus(hammer, new kit.THREE.TorusGeometry(45e-4, 16e-4, 6, 12), M.dark, -4e-3, 0.012, 0);
-      } else if (style.hammer === "big") box2(hammer, 0.014, 0.02, 9e-3, M.dark, -4e-3, 7e-3, 0, 0.35);
+      } else if (style.hammer === "big") box3(hammer, 0.014, 0.02, 9e-3, M.dark, -4e-3, 7e-3, 0, 0.35);
       else {
-        box2(hammer, 8e-3, 0.016, 7e-3, M.dark, -2e-3, 6e-3, 0, 0.3);
-        box2(hammer, 8e-3, 4e-3, 8e-3, M.dark, -6e-3, 0.013, 0, 0.3);
+        box3(hammer, 8e-3, 0.016, 7e-3, M.dark, -2e-3, 6e-3, 0, 0.3);
+        box3(hammer, 8e-3, 4e-3, 8e-3, M.dark, -6e-3, 0.013, 0, 0.3);
       }
     }
     parts.muzzle = kit.mark(group, L + 6e-3, style.tri ? h * 0.08 : 2e-3, 0);
@@ -18136,45 +18325,45 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var PI7 = Math.PI;
   var DEFAULT_CHAMBERS = 6;
   function buildRevolver(kit, options) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const group = kit.group();
     const parts = { family: "revolver", kick: options.cal === ".44 Magnum" ? 1.5 : 0.9, glow: [] };
     const barrel = (options.B ?? 0) / 1e3;
     const chambers = options.chambers ?? DEFAULT_CHAMBERS;
     const metal2 = options.steel ? M.steel : M.metal;
-    box2(group, 0.08, 0.044, 0.024, metal2, 0.07, 0, 0);
-    box2(group, 0.036, 0.012, 0.022, metal2, 0.096, 0.022, 0);
-    box2(group, 0.024, 0.012, 4e-3, M.dark, 0.055, 6e-3, -0.013);
+    box3(group, 0.08, 0.044, 0.024, metal2, 0.07, 0, 0);
+    box3(group, 0.036, 0.012, 0.022, metal2, 0.096, 0.022, 0);
+    box3(group, 0.024, 0.012, 4e-3, M.dark, 0.055, 6e-3, -0.013);
     const crane = kit.pivot(group, 0.077, -0.024, 0);
     parts.crane = crane;
-    const cylinder = kit.pivot(crane, 0, 0.022, 0);
-    parts.cylinder = cylinder;
-    cylinderX(cylinder, 0.0215, 0.042, metal2, 0, 0, 0, 24);
+    const cylinder2 = kit.pivot(crane, 0, 0.022, 0);
+    parts.cylinder = cylinder2;
+    cylinderX(cylinder2, 0.0215, 0.042, metal2, 0, 0, 0, 24);
     for (let i = 0; i < chambers; i++) {
       const angle = i * 2 * PI7 / chambers;
-      box2(cylinder, 0.026, 5e-3, 5e-3, M.dark, 0, Math.cos(angle) * 0.0205, Math.sin(angle) * 0.0205, 0, 0, angle);
+      box3(cylinder2, 0.026, 5e-3, 5e-3, M.dark, 0, Math.cos(angle) * 0.0205, Math.sin(angle) * 0.0205, 0, 0, angle);
     }
     parts.chambers = [];
     for (let i = 0; i < chambers; i++) {
       const angle = i * 2 * PI7 / chambers + PI7 / chambers;
-      parts.chambers.push(kit.mark(cylinder, -0.022, Math.cos(angle) * 0.013, Math.sin(angle) * 0.013));
-      cylinderX(cylinder, 46e-4, 2e-3, M.brass, -0.0215, Math.cos(angle) * 0.013, Math.sin(angle) * 0.013, 12);
+      parts.chambers.push(kit.mark(cylinder2, -0.022, Math.cos(angle) * 0.013, Math.sin(angle) * 0.013));
+      cylinderX(cylinder2, 46e-4, 2e-3, M.brass, -0.0215, Math.cos(angle) * 0.013, Math.sin(angle) * 0.013, 12);
     }
     heatify(parts.glow, cylinderX(group, 88e-4, barrel, metal2, 0.112 + barrel / 2, 9e-3, 0, 18));
-    box2(group, barrel * 0.92, 0.015, 0.013, metal2, 0.112 + barrel * 0.46, -5e-3, 0);
+    box3(group, barrel * 0.92, 0.015, 0.013, metal2, 0.112 + barrel * 0.46, -5e-3, 0);
     cylinderX(group, 4e-3, 5e-3, M.hole, 0.112 + barrel + 15e-4, 9e-3, 0, 12);
-    box2(group, 0.012, 9e-3, 4e-3, M.dark, 0.112 + barrel - 8e-3, 0.021, 0, -0.3);
-    box2(group, 0.012, 6e-3, 0.012, M.dark, 0.105, 0.031, 0);
+    box3(group, 0.012, 9e-3, 4e-3, M.dark, 0.112 + barrel - 8e-3, 0.021, 0, -0.3);
+    box3(group, 0.012, 6e-3, 0.012, M.dark, 0.105, 0.031, 0);
     const hammer = kit.pivot(group, 0.036, 0.018, 0);
-    box2(hammer, 0.01, 0.02, 8e-3, M.dark, -4e-3, 8e-3, 0, 0.45);
+    box3(hammer, 0.01, 0.02, 8e-3, M.dark, -4e-3, 8e-3, 0, 0.45);
     parts.hammer = hammer;
     const grip = kit.pivot(group, 0.024, -0.062, 0);
     grip.rotation.z = -0.38;
-    box2(grip, 0.034, 0.1, 0.031, options.wood ? M.wood : M.rubber, 0, 0, 0);
-    if (!options.wood) for (let i = 0; i < 4; i++) box2(grip, 6e-3, 0.07, 0.033, M.dark, -0.012 + i * 8e-3, 0, 0);
-    box2(group, 0.038, 4e-3, 8e-3, metal2, 0.062, -0.036, 0);
-    box2(group, 4e-3, 0.022, 8e-3, metal2, 0.08, -0.026, 0, 0.2);
-    parts.trigger = box2(group, 4e-3, 0.015, 4e-3, M.dark, 0.06, -0.027, 0, 0.2);
+    box3(grip, 0.034, 0.1, 0.031, options.wood ? M.wood : M.rubber, 0, 0, 0);
+    if (!options.wood) for (let i = 0; i < 4; i++) box3(grip, 6e-3, 0.07, 0.033, M.dark, -0.012 + i * 8e-3, 0, 0);
+    box3(group, 0.038, 4e-3, 8e-3, metal2, 0.062, -0.036, 0);
+    box3(group, 4e-3, 0.022, 8e-3, metal2, 0.08, -0.026, 0, 0.2);
+    parts.trigger = box3(group, 4e-3, 0.015, 4e-3, M.dark, 0.06, -0.027, 0, 0.2);
     parts.muzzle = kit.mark(group, 0.112 + barrel + 6e-3, 9e-3, 0);
     parts.eject = kit.mark(group, 0.077, 0, 0);
     return { group, parts };
@@ -18182,11 +18371,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
 
   // src/models/attachments/muzzle-brake.ts
   function buildBrake(kit, parent, kind, x, y, barrelRadius, heat = () => void 0) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const scale = kind === 2 ? 3.2 : 2;
     const length2 = kind === 2 ? 0.12 : 0.06;
     heat(cylinderX(parent, barrelRadius * scale, length2, M.dark, x - length2 / 2, y, 0, kind === 2 ? 8 : 16));
-    for (let i = 0; i < 3; i++) box2(parent, length2 * 0.16, barrelRadius * scale * 1.3, barrelRadius * scale * 2.2, M.hole, x - length2 * 0.25 - i * length2 * 0.25, y, 0);
+    for (let i = 0; i < 3; i++) box3(parent, length2 * 0.16, barrelRadius * scale * 1.3, barrelRadius * scale * 2.2, M.hole, x - length2 * 0.25 - i * length2 * 0.25, y, 0);
   }
 
   // src/models/capture.ts
@@ -18201,13 +18390,13 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
 
   // src/models/attachments/bipod.ts
   function buildBipod(kit, parent, x, y) {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     cylinderX(parent, 8e-3, 0.02, M.dark, x, y, 0, 12);
     for (const side of [-1, 1]) {
       const leg = kit.pivot(parent, x, y, side * 0.012);
       leg.rotation.set(side * 0.15, 0, -0.35);
-      box2(leg, 6e-3, 0.2, 6e-3, M.dark, 0, -0.1, 0);
-      box2(leg, 0.01, 6e-3, 0.01, M.rubber, 0, -0.2, 0);
+      box3(leg, 6e-3, 0.2, 6e-3, M.dark, 0, -0.1, 0);
+      box3(leg, 0.01, 6e-3, 0.01, M.rubber, 0, -0.2, 0);
     }
   }
   var buildBipodModel = ({ kit }) => {
@@ -18220,13 +18409,13 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var SCOPE_IDS = { 1: "red_dot", 2: "acog_4x", 3: "scope_3_9x", 4: "scope_6_24x" };
   function buildFittings(context, gripX) {
     const { kit, group, parts, options: o, furniture: furn, length: L, receiverStart: x0, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, barrelRadius: r, barrelY: by } = context;
-    const { M, box: box2, cylinderX, cylinderZ, sphere } = kit;
+    const { M, box: box3, cylinderX, cylinderZ, sphere: sphere2 } = kit;
     const middle = (x0 + x1) / 2;
     if (o.scope) recordFitting(parts, SCOPE_IDS[o.scope] ?? "scope", group, () => scope(kit, group, o.scope, middle + 0.03, hR / 2 + (o.rail ? 6e-3 : 0), o.scope === 4 ? -0.02 : 0));
     if (o.carry) {
-      box2(group, 0.15, 0.026, 0.014, M.metal, middle, hR / 2 + 0.03, 0);
-      box2(group, 0.012, 0.03, 0.014, M.metal, middle + 0.07, hR / 2 + 0.014, 0);
-      box2(group, 0.012, 0.03, 0.014, M.metal, middle - 0.07, hR / 2 + 0.014, 0);
+      box3(group, 0.15, 0.026, 0.014, M.metal, middle, hR / 2 + 0.03, 0);
+      box3(group, 0.012, 0.03, 0.014, M.metal, middle + 0.07, hR / 2 + 0.014, 0);
+      box3(group, 0.012, 0.03, 0.014, M.metal, middle - 0.07, hR / 2 + 0.014, 0);
     }
     if (o.bipod) recordFitting(parts, "bipod", group, () => buildBipod(kit, group, x1 + (L - x1) * 0.45 + 0.04, by - 0.012));
     if (o.bolt) {
@@ -18234,17 +18423,17 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       parts.boltHandle = handle;
       parts.boltHandleRest = handle.position.x;
       cylinderZ(handle, 42e-4, 0.05, M.steelL, 0, 0, wR / 2 + 0.022, 12);
-      sphere(handle, 95e-4, M.dark, 0, -4e-3, wR / 2 + 0.048, 1);
+      sphere2(handle, 95e-4, M.dark, 0, -4e-3, wR / 2 + 0.048, 1);
       cylinderX(group, hR * 0.3, 0.03, M.steel, x0 + 5e-3, by, 0, 16);
     }
     if (o.lever) {
       const lever = kit.pivot(group, gripX - 0.02, -hR / 2 - 0.01, 0);
       parts.lever = lever;
-      box2(lever, 0.11, 6e-3, 0.012, M.metal, 0.055, -0.052, 0);
-      box2(lever, 6e-3, 0.05, 0.012, M.metal, 3e-3, -0.028, 0);
-      box2(lever, 6e-3, 0.05, 0.012, M.metal, 0.108, -0.028, 0);
-      box2(lever, 0.04, 6e-3, 0.012, M.metal, 0.08, -2e-3, 0);
-      box2(group, 0.03, 0.012, 3e-3, M.dark, x1 - 0.04, by, wR / 2 + 1e-3);
+      box3(lever, 0.11, 6e-3, 0.012, M.metal, 0.055, -0.052, 0);
+      box3(lever, 6e-3, 0.05, 0.012, M.metal, 3e-3, -0.028, 0);
+      box3(lever, 6e-3, 0.05, 0.012, M.metal, 0.108, -0.028, 0);
+      box3(lever, 0.04, 6e-3, 0.012, M.metal, 0.08, -2e-3, 0);
+      box3(group, 0.03, 0.012, 3e-3, M.dark, x1 - 0.04, by, wR / 2 + 1e-3);
     }
     if (o.tube) {
       const tubeLength = (L - x1) * (o.tubeLen || 0.8);
@@ -18254,14 +18443,14 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     if (o.pump) {
       const pump = kit.pivot(group);
       parts.pump = pump;
-      box2(pump, 0.17, 0.042, 0.046, furn, x1 + 0.14, by - 0.022, 0);
-      for (let i = 0; i < 8; i++) box2(pump, 6e-3, 0.044, 0.048, M.dark, x1 + 0.07 + i * 0.02, by - 0.022, 0);
+      box3(pump, 0.17, 0.042, 0.046, furn, x1 + 0.14, by - 0.022, 0);
+      for (let i = 0; i < 8; i++) box3(pump, 6e-3, 0.044, 0.048, M.dark, x1 + 0.07 + i * 0.02, by - 0.022, 0);
     }
     if (o.heat) {
       cylinderX(group, r * 1.75, (L - x1) * 0.7, M.dark, x1 + (L - x1) * 0.4, by, 0, 12);
-      for (let i = 0; i < 10; i++) box2(group, 8e-3, r * 1.5, 4e-3, M.hole, x1 + (L - x1) * (0.1 + i * 0.06), by + r * 0.8, r * 1.5);
+      for (let i = 0; i < 10; i++) box3(group, 8e-3, r * 1.5, 4e-3, M.hole, x1 + (L - x1) * (0.1 + i * 0.06), by + r * 0.8, r * 1.5);
     }
-    if (o.bayo) box2(group, 0.025, 8e-3, 0.01, M.metal, L - 0.07, by - 0.016, 0);
+    if (o.bayo) box3(group, 0.025, 8e-3, 0.01, M.metal, L - 0.07, by - 0.016, 0);
     if (o.rod) cylinderX(group, 3e-3, (L - x1) * 0.85, M.steel, x1 + (L - x1) * 0.45, by - 0.014, 0, 8);
   }
 
@@ -18269,14 +18458,14 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var PI8 = Math.PI;
   function buildForend(context) {
     const { kit, group, options: o, furniture: furn, length: L, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, barrelRadius: r, barrelY: by } = context;
-    const { M, box: box2 } = kit;
+    const { M, box: box3 } = kit;
     const hasLongScope = (o.scope ?? 0) >= 3;
     if (!context.isTraditional && o.hg !== "none") {
       const handguardLength = (L - x1) * (o.hgFrac || 0.5);
       const hx = x1 + handguardLength / 2;
       const hh = hR * 0.8;
       if (o.hg === "rail") {
-        box2(group, handguardLength, hh, wR * 1.04, M.dark, hx, by - 2e-3, 0);
+        box3(group, handguardLength, hh, wR * 1.04, M.dark, hx, by - 2e-3, 0);
         rail(kit, group, x1, handguardLength, by + hh / 2, 0, wR * 0.66);
         rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - 2e-3, wR * 0.54, wR * 0.4, PI8 / 2);
         rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - 2e-3, -wR * 0.54, wR * 0.4, -PI8 / 2);
@@ -18284,49 +18473,49 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       } else {
         const material = o.hg === "wood" ? M.wood : furn;
         if (o.ak) {
-          box2(group, handguardLength, hh * 0.55, wR * 1.08, material, hx, by - hh * 0.22, 0);
-          box2(group, handguardLength * 0.75, hh * 0.35, wR * 0.7, material, hx - handguardLength * 0.1, by + r * 2.2, 0);
+          box3(group, handguardLength, hh * 0.55, wR * 1.08, material, hx, by - hh * 0.22, 0);
+          box3(group, handguardLength * 0.75, hh * 0.35, wR * 0.7, material, hx - handguardLength * 0.1, by + r * 2.2, 0);
         } else {
-          box2(group, handguardLength, hh, wR * 1.08, material, hx, by - 2e-3, 0);
+          box3(group, handguardLength, hh, wR * 1.08, material, hx, by - 2e-3, 0);
           vents(kit, group, x1 + 0.01, handguardLength - 0.02, by + hh * 0.15, wR * 0.54 + 1e-3, Math.round(handguardLength / 0.025), hh * 0.3);
           vents(kit, group, x1 + 0.01, handguardLength - 0.02, by + hh * 0.15, -wR * 0.54 - 1e-3, Math.round(handguardLength / 0.025), hh * 0.3);
         }
       }
       if (!hasLongScope && !o.rail && o.ak) {
-        box2(group, 0.03, 0.016, wR * 0.6, M.metal, x1 + 0.02, by + r * 2.5 + 0.01, 0);
-        box2(group, 0.012, 4e-3, wR * 0.5, M.dark, x1 + 0.03, by + r * 2.5 + 0.019, 0);
+        box3(group, 0.03, 0.016, wR * 0.6, M.metal, x1 + 0.02, by + r * 2.5 + 0.01, 0);
+        box3(group, 0.012, 4e-3, wR * 0.5, M.dark, x1 + 0.03, by + r * 2.5 + 0.019, 0);
       }
     }
     if (hasLongScope) return;
     const sightX = L - (o.ak ? 0.06 : 0.08);
     if (o.ak) {
-      box2(group, 0.022, 0.022, wR * 0.6, M.metal, sightX, by + 8e-3, 0);
-      box2(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, 8e-3);
-      box2(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, -8e-3);
-      box2(group, 3e-3, 0.016, 3e-3, M.dark, sightX, by + 0.022, 0);
+      box3(group, 0.022, 0.022, wR * 0.6, M.metal, sightX, by + 8e-3, 0);
+      box3(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, 8e-3);
+      box3(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, -8e-3);
+      box3(group, 3e-3, 0.016, 3e-3, M.dark, sightX, by + 0.022, 0);
     } else if (!o.rail || o.carry) {
-      box2(group, 0.018, 0.014, wR * 0.55, M.dark, sightX, by + 8e-3, 0);
-      box2(group, 0.012, 0.034, 8e-3, M.dark, sightX, by + 0.03, 0, -0.25);
-    } else box2(group, 0.012, 0.024, 0.012, M.dark, sightX - 0.04, by + hR * 0.4 + 0.012, 0);
+      box3(group, 0.018, 0.014, wR * 0.55, M.dark, sightX, by + 8e-3, 0);
+      box3(group, 0.012, 0.034, 8e-3, M.dark, sightX, by + 0.03, 0, -0.25);
+    } else box3(group, 0.012, 0.024, 0.012, M.dark, sightX - 0.04, by + hR * 0.4 + 0.012, 0);
   }
 
   // src/models/attachments/belt-box.ts
   function buildBeltBox(kit, belt) {
-    const { M, box: box2, cylinderX } = kit;
-    box2(belt, 0.11, 0.1, 0.08, M.olive, 0, 0, 0);
-    box2(belt, 0.112, 0.012, 0.082, M.dark, 0, 0.046, 0);
+    const { M, box: box3, cylinderX } = kit;
+    box3(belt, 0.11, 0.1, 0.08, M.olive, 0, 0, 0);
+    box3(belt, 0.112, 0.012, 0.082, M.dark, 0, 0.046, 0);
     for (let i = 0; i < 7; i++) {
       cylinderX(belt, 42e-4, 0.034, M.brass, -0.04 + i * 0.012, 0.07, 0.035, 10);
-      box2(belt, 6e-3, 6e-3, 0.012, M.metal, -0.04 + i * 0.012, 0.066, 0.035);
+      box3(belt, 6e-3, 6e-3, 0.012, M.metal, -0.04 + i * 0.012, 0.066, 0.035);
     }
   }
 
   // src/models/attachments/drum.ts
   function buildDrum(kit, magazine) {
-    const { M, box: box2, cylinderZ } = kit;
+    const { M, box: box3, cylinderZ } = kit;
     cylinderZ(magazine, 0.075, 0.07, M.dark, 0.02, -0.085, 0, 22);
     cylinderZ(magazine, 0.05, 0.074, M.metal, 0.02, -0.085, 0, 18);
-    box2(magazine, 0.05, 0.04, 0.03, M.dark, 0, -0.02, 0);
+    box3(magazine, 0.05, 0.04, 0.03, M.dark, 0, -0.02, 0);
   }
 
   // src/models/helical-magazine.ts
@@ -18336,7 +18525,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var TURNS = 11;
   function buildHelicalMagazine(context) {
     const { kit, group, parts, receiverEnd, barrelY, barrelRadius } = context;
-    const { M, cylinderX, box: box2 } = kit;
+    const { M, cylinderX, box: box3 } = kit;
     const x = receiverEnd + LENGTH / 2 + 0.02;
     const y = barrelY - barrelRadius - RADIUS - 0.012;
     const magazine = kit.pivot(group, x, y, 0);
@@ -18344,8 +18533,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     cylinderX(magazine, RADIUS, LENGTH, M.dark, 0, 0, 0, 20);
     cylinderX(magazine, RADIUS * 1.06, 0.01, M.metal, -LENGTH / 2, 0, 0, 20);
     cylinderX(magazine, RADIUS * 1.06, 0.01, M.metal, LENGTH / 2, 0, 0, 20);
-    for (let i = 0; i < TURNS; i++) box2(magazine, 0.012, RADIUS * 2.15, 0.014, M.metal, -LENGTH / 2 + (i + 0.5) * LENGTH / TURNS, 0, 0, 0, 0, i * PI9 / 4);
-    box2(magazine, 0.05, 0.03, 0.03, M.dark, -LENGTH / 2 - 0.02, RADIUS * 0.4, 0);
+    for (let i = 0; i < TURNS; i++) box3(magazine, 0.012, RADIUS * 2.15, 0.014, M.metal, -LENGTH / 2 + (i + 0.5) * LENGTH / TURNS, 0, 0, 0, 0, i * PI9 / 4);
+    box3(magazine, 0.05, 0.03, 0.03, M.dark, -LENGTH / 2 - 0.02, RADIUS * 0.4, 0);
     parts.magDrop = 0.16;
     return x;
   }
@@ -18353,24 +18542,24 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   // src/models/rifle-controls.ts
   function buildGrip(context) {
     const { kit, group, parts, options: o, furniture: furn, receiverStart: x0, receiverHeight: hR, receiverWidth: wR } = context;
-    const { M, box: box2 } = kit;
+    const { M, box: box3 } = kit;
     const gx = x0 + (o.gripAt || 0.07);
     if (!context.isTraditional && o.grip !== "none") {
       const grip = kit.pivot(group, gx - 0.012, -hR / 2 - 0.046, 0);
       grip.rotation.z = -0.3;
-      box2(grip, 0.032, 0.105, 0.028, furn, 0, 0, 0);
-      for (let i = 0; i < 3; i++) box2(grip, 6e-3, 0.012, 0.026, furn, 0.017, 0.022 - i * 0.02, 0);
-      box2(grip, 0.034, 8e-3, 0.03, furn, 0, -0.052, 0);
-    }
-    box2(group, 0.06, 4e-3, 0.01, M.metal, gx + 0.03, -hR / 2 - 0.024, 0);
-    box2(group, 4e-3, 0.022, 0.01, M.metal, gx + 0.06, -hR / 2 - 0.013, 0);
-    parts.trigger = box2(group, 4e-3, 0.016, 4e-3, M.dark, gx + 0.024, -hR / 2 - 0.012, 0, 0.15);
-    if (o.sel) parts.safety = box2(group, 0.016, 5e-3, 3e-3, M.dark, gx + 5e-3, -hR * 0.15, -wR / 2 - 2e-3, 0.4);
+      box3(grip, 0.032, 0.105, 0.028, furn, 0, 0, 0);
+      for (let i = 0; i < 3; i++) box3(grip, 6e-3, 0.012, 0.026, furn, 0.017, 0.022 - i * 0.02, 0);
+      box3(grip, 0.034, 8e-3, 0.03, furn, 0, -0.052, 0);
+    }
+    box3(group, 0.06, 4e-3, 0.01, M.metal, gx + 0.03, -hR / 2 - 0.024, 0);
+    box3(group, 4e-3, 0.022, 0.01, M.metal, gx + 0.06, -hR / 2 - 0.013, 0);
+    parts.trigger = box3(group, 4e-3, 0.016, 4e-3, M.dark, gx + 0.024, -hR / 2 - 0.012, 0, 0.15);
+    if (o.sel) parts.safety = box3(group, 0.016, 5e-3, 3e-3, M.dark, gx + 5e-3, -hR * 0.15, -wR / 2 - 2e-3, 0.4);
     return gx;
   }
   function buildMagazine(context, gx) {
     const { kit, group, parts, options: o, receiverStart: x0, receiverHeight: hR, receiverWidth: wR, receiverLength: RL } = context;
-    const { M, box: box2 } = kit;
+    const { M, box: box3 } = kit;
     if (o.mag === "helical") return buildHelicalMagazine(context);
     const mx = o.magAt != null ? x0 + o.magAt : gx + 0.075;
     const scale = o.magLen || 1;
@@ -18385,12 +18574,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         const length2 = 0.07 * scale;
         const cx = px + Math.sin(angle) * length2 / 2;
         const cy = py - Math.cos(angle) * length2 / 2;
-        box2(magazine, 0.052, length2 + 4e-3, 0.024, material, cx, cy, 0, angle);
-        box2(magazine, 0.04, length2 * 0.8, 0.026, M.dark, cx, cy, 0, angle);
+        box3(magazine, 0.052, length2 + 4e-3, 0.024, material, cx, cy, 0, angle);
+        box3(magazine, 0.04, length2 * 0.8, 0.026, M.dark, cx, cy, 0, angle);
         px += Math.sin(angle) * length2;
         py -= Math.cos(angle) * length2;
       }
-      box2(magazine, 0.058, 8e-3, 0.028, material, px, py, 0, 0.38);
+      box3(magazine, 0.058, 8e-3, 0.028, material, px, py, 0, 0.38);
       parts.magDrop = 0.07 * scale * 3 + 0.04;
     } else if (o.mag === "box") {
       const length2 = 0.13 * scale;
@@ -18404,18 +18593,18 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         angle = 0.08 + curve * i;
         const cx = px + Math.sin(angle) * segment / 2;
         const cy = py - Math.cos(angle) * segment / 2;
-        box2(magazine, 0.05, segment + 4e-3, 0.024, material, cx, cy, 0, angle);
-        box2(magazine, 0.04, 3e-3, 0.026, M.metal, cx, cy, 0, angle);
+        box3(magazine, 0.05, segment + 4e-3, 0.024, material, cx, cy, 0, angle);
+        box3(magazine, 0.04, 3e-3, 0.026, M.metal, cx, cy, 0, angle);
         px += Math.sin(angle) * segment;
         py -= Math.cos(angle) * segment;
       }
-      box2(magazine, 0.056, 7e-3, 0.028, material, px, py - 2e-3, 0, angle);
+      box3(magazine, 0.056, 7e-3, 0.028, material, px, py - 2e-3, 0, angle);
       parts.magDrop = length2 + 0.03;
     } else if (o.mag === "drum") {
       buildDrum(kit, magazine);
       parts.magDrop = 0.2;
     } else if (o.mag === "internal") {
-      box2(group, 0.08, 0.025, 0.03, context.isTraditional ? context.furniture : M.metal, mx, -hR / 2 - 0.012, 0);
+      box3(group, 0.08, 0.025, 0.03, context.isTraditional ? context.furniture : M.metal, mx, -hR / 2 - 0.012, 0);
       parts.mag = null;
     } else parts.mag = null;
     if (o.mag === "belt") {
@@ -18424,8 +18613,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       buildBeltBox(kit, belt);
       const cover = kit.pivot(group, x0 + 0.01, hR / 2, 0);
       parts.cover = cover;
-      box2(cover, RL - 0.03, 0.014, wR * 1.05, M.metal, (RL - 0.03) / 2, 7e-3, 0);
-      box2(cover, 0.02, 0.012, wR * 0.6, M.dark, RL - 0.04, 0.016, 0);
+      box3(cover, RL - 0.03, 0.014, wR * 1.05, M.metal, (RL - 0.03) / 2, 7e-3, 0);
+      box3(cover, 0.02, 0.012, wR * 0.6, M.dark, RL - 0.04, 0.016, 0);
     }
     return mx;
   }
@@ -18433,40 +18622,40 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   // src/models/rifle-stock.ts
   function buildStock(context, magazineX) {
     const { kit, group, options: o, furniture: furn, length: L, stockLength: S, receiverStart: x0, receiverEnd: x1, receiverHeight: hR } = context;
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     if (context.isTraditional) {
       buttpad(kit, group, 6e-3, -0.04, 0.13, 0.038);
-      box2(group, 0.03, 0.13, 0.038, furn, 0.024, -0.04, 0);
-      box2(group, S, 0.055, 0.034, furn, S / 2, -0.012, 0, 0.06);
-      box2(group, 0.09, 0.05, 0.032, furn, x0 - 0.02, -0.035, 0, 0.25);
+      box3(group, 0.03, 0.13, 0.038, furn, 0.024, -0.04, 0);
+      box3(group, S, 0.055, 0.034, furn, S / 2, -0.012, 0, 0.06);
+      box3(group, 0.09, 0.05, 0.032, furn, x0 - 0.02, -0.035, 0, 0.25);
       const forendLength = x1 - x0 + (L - x1) * (o.fore ?? 0.62);
-      if (forendLength > 0) box2(group, forendLength, 0.045, 0.04, furn, x0 + forendLength / 2, -hR / 2 + 4e-3, 0);
-      if (o.stock === "straight") box2(group, 0.15, 0.04, 0.035, furn, x1 + 0.08, -hR / 2, 0);
-      box2(group, 0.04, 4e-3, 0.03, M.metal, magazineX, -hR / 2 - 0.022, 0);
+      if (forendLength > 0) box3(group, forendLength, 0.045, 0.04, furn, x0 + forendLength / 2, -hR / 2 + 4e-3, 0);
+      if (o.stock === "straight") box3(group, 0.15, 0.04, 0.035, furn, x1 + 0.08, -hR / 2, 0);
+      box3(group, 0.04, 4e-3, 0.03, M.metal, magazineX, -hR / 2 - 0.022, 0);
       swivel(kit, group, 0.2, -0.08);
       swivel(kit, group, x1 + (L - x1) * 0.45, -hR / 2 - 0.03);
       if (o.bands) for (const fraction of [0.35, 0.75]) cylinderX(group, 0.024, 8e-3, M.metal, x1 + (L - x1) * fraction * (o.fore || 0.62), -4e-3, 0, 16);
     } else if (o.stock === "fixed" || o.stock === "wood") {
-      box2(group, S, 0.05, 0.03, furn, S / 2, -8e-3, 0, 0.05);
-      box2(group, 0.03, 0.13, 0.036, furn, 0.022, -0.035, 0);
+      box3(group, S, 0.05, 0.03, furn, S / 2, -8e-3, 0, 0.05);
+      box3(group, 0.03, 0.13, 0.036, furn, 0.022, -0.035, 0);
       buttpad(kit, group, 4e-3, -0.035, 0.13, 0.036);
-      if (o.stock === "wood") box2(group, S * 0.6, 0.03, 0.028, furn, S * 0.55, -0.045, 0, 0.2);
+      if (o.stock === "wood") box3(group, S * 0.6, 0.03, 0.028, furn, S * 0.55, -0.045, 0, 0.2);
       swivel(kit, group, 0.08, -0.09);
     } else if (o.stock === "skeleton") {
-      box2(group, S, 0.014, 0.026, furn, S / 2, 0.012, 0, 0.03);
-      box2(group, S, 0.014, 0.026, furn, S / 2, -0.05, 0, -0.08);
-      box2(group, 0.03, 0.12, 0.034, furn, 0.02, -0.025, 0);
+      box3(group, S, 0.014, 0.026, furn, S / 2, 0.012, 0, 0.03);
+      box3(group, S, 0.014, 0.026, furn, S / 2, -0.05, 0, -0.08);
+      box3(group, 0.03, 0.12, 0.034, furn, 0.02, -0.025, 0);
       buttpad(kit, group, 4e-3, -0.025, 0.12, 0.034);
     } else if (o.stock === "retract") {
       cylinderX(group, 0.013, S, M.metal, S / 2, 0, 0, 16);
-      for (let i = 0; i < 5; i++) box2(group, 3e-3, 3e-3, 8e-3, M.dark, S * 0.2 + i * 0.015, -0.013, 0);
-      box2(group, 0.034, 0.11, 0.036, furn, 0.02, -0.025, 0);
-      box2(group, S * 0.55, 0.032, 0.03, furn, S * 0.35, 0, 0);
+      for (let i = 0; i < 5; i++) box3(group, 3e-3, 3e-3, 8e-3, M.dark, S * 0.2 + i * 0.015, -0.013, 0);
+      box3(group, 0.034, 0.11, 0.036, furn, 0.02, -0.025, 0);
+      box3(group, S * 0.55, 0.032, 0.03, furn, S * 0.35, 0, 0);
       buttpad(kit, group, 3e-3, -0.025, 0.11, 0.036);
     } else if (o.stock === "fold") {
-      box2(group, S, 6e-3, 6e-3, M.metal, S / 2, 0.01, 0.012);
-      box2(group, S, 6e-3, 6e-3, M.metal, S / 2, -0.04, 0.012, -0.12);
-      box2(group, 0.012, 0.1, 0.03, M.metal, 6e-3, -0.02, 0.012);
+      box3(group, S, 6e-3, 6e-3, M.metal, S / 2, 0.01, 0.012);
+      box3(group, S, 6e-3, 6e-3, M.metal, S / 2, -0.04, 0.012, -0.12);
+      box3(group, 0.012, 0.1, 0.03, M.metal, 6e-3, -0.02, 0.012);
     }
   }
 
@@ -18474,49 +18663,49 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var PI10 = Math.PI;
   function buildReceiver(context) {
     const { kit, group, parts, options: o, length: L, receiverStart: x0, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, receiverLength: RL, barrelY: by } = context;
-    const { M, box: box2, cylinderX, cylinderY, cylinderZ, sphere } = kit;
+    const { M, box: box3, cylinderX, cylinderY, cylinderZ, sphere: sphere2 } = kit;
     const receiverMaterial = o.tan ? M.tan : M.metal;
     const middle = (x0 + x1) / 2;
     if (o.round) {
       cylinderX(group, hR * 0.36, RL, M.steel, middle, by, 0, 20);
       cylinderX(group, hR * 0.32, 0.05, M.steel, x0 - 0.01, by, 0, 18);
     } else if (o.ar) {
-      box2(group, RL, hR * 0.5, wR, receiverMaterial, middle, hR * 0.25, 0);
-      box2(group, RL * 0.92, hR * 0.52, wR * 0.96, receiverMaterial, middle - RL * 0.02, -hR * 0.24, 0);
-      box2(group, 0.05, 0.03, wR * 1.15, receiverMaterial, x0 + RL * 0.62, -hR * 0.5 - 0.01, 0);
+      box3(group, RL, hR * 0.5, wR, receiverMaterial, middle, hR * 0.25, 0);
+      box3(group, RL * 0.92, hR * 0.52, wR * 0.96, receiverMaterial, middle - RL * 0.02, -hR * 0.24, 0);
+      box3(group, 0.05, 0.03, wR * 1.15, receiverMaterial, x0 + RL * 0.62, -hR * 0.5 - 0.01, 0);
       cylinderZ(group, 6e-3, 0.012, M.metal, x1 - 0.03, hR * 0.28, wR / 2 + 6e-3, 12);
-      box2(group, 0.012, 0.01, 0.012, M.metal, x1 - 0.05, hR * 0.12, wR / 2 + 6e-3);
-      box2(group, 0.03, 8e-3, 0.012, M.dark, x0 + 0.02, hR / 2 + 4e-3, 0);
-      box2(group, 0.012, 6e-3, 4e-3, M.dark, x0 + RL * 0.55, -hR * 0.15, -wR / 2 - 2e-3);
-    } else box2(group, RL, hR, wR, receiverMaterial, middle, 0, 0);
+      box3(group, 0.012, 0.01, 0.012, M.metal, x1 - 0.05, hR * 0.12, wR / 2 + 6e-3);
+      box3(group, 0.03, 8e-3, 0.012, M.dark, x0 + 0.02, hR / 2 + 4e-3, 0);
+      box3(group, 0.012, 6e-3, 4e-3, M.dark, x0 + RL * 0.55, -hR * 0.15, -wR / 2 - 2e-3);
+    } else box3(group, RL, hR, wR, receiverMaterial, middle, 0, 0);
     if (o.ak) {
-      box2(group, RL * 0.86, hR * 0.28, wR * 0.95, M.metal, middle - 8e-3, hR / 2 + 4e-3, 0);
-      for (let i = 0; i < 3; i++) box2(group, 4e-3, hR * 0.3, wR * 0.97, M.dark, x0 + RL * 0.25 + i * 0.02, hR / 2 + 4e-3, 0);
-      box2(group, RL * 0.5, 0.012, 3e-3, M.metal, x0 + RL * 0.55, -hR * 0.02, wR / 2 + 15e-4, -0.05);
-      box2(group, 0.012, 0.014, 3e-3, M.dark, x0 + RL * 0.32, -hR * 0.05, wR / 2 + 2e-3);
+      box3(group, RL * 0.86, hR * 0.28, wR * 0.95, M.metal, middle - 8e-3, hR / 2 + 4e-3, 0);
+      for (let i = 0; i < 3; i++) box3(group, 4e-3, hR * 0.3, wR * 0.97, M.dark, x0 + RL * 0.25 + i * 0.02, hR / 2 + 4e-3, 0);
+      box3(group, RL * 0.5, 0.012, 3e-3, M.metal, x0 + RL * 0.55, -hR * 0.02, wR / 2 + 15e-4, -0.05);
+      box3(group, 0.012, 0.014, 3e-3, M.dark, x0 + RL * 0.32, -hR * 0.05, wR / 2 + 2e-3);
     }
     if (o.g3) {
       cylinderX(group, 9e-3, (L - x1) * 0.6, M.metal, x1 + (L - x1) * 0.28, hR * 0.48, 0, 14);
-      box2(group, 0.012, 0.024, 8e-3, M.dark, x1 + (L - x1) * 0.5, hR * 0.48, -0.012);
+      box3(group, 0.012, 0.024, 8e-3, M.dark, x1 + (L - x1) * 0.5, hR * 0.48, -0.012);
       cylinderY(group, 0.012, 0.016, M.dark, x0 + 0.03, hR / 2 + 8e-3, 0, 12);
     }
     const ejectX = x1 - (o.ejectBack || 0.07);
     const ejectY = o.ar ? hR * 0.2 : by;
-    box2(group, 0.05, hR * 0.36, 4e-3, M.hole, ejectX, ejectY, wR / 2 - 4e-4);
+    box3(group, 0.05, hR * 0.36, 4e-3, M.hole, ejectX, ejectY, wR / 2 - 4e-4);
     const bolt = kit.pivot(group);
     parts.bolt = bolt;
     parts.stroke = Math.min(0.1, RL * 0.32);
-    box2(bolt, 0.044, hR * 0.26, 6e-3, M.steelL, ejectX, ejectY, wR / 2 - 12e-4);
+    box3(bolt, 0.044, hR * 0.26, 6e-3, M.steelL, ejectX, ejectY, wR / 2 - 12e-4);
     if (o.charge) {
-      box2(bolt, 0.012, 0.01, 0.03, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.012);
-      sphere(bolt, 65e-4, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.028, 1);
+      box3(bolt, 0.012, 0.01, 0.03, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.012);
+      sphere2(bolt, 65e-4, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.028, 1);
     }
-    if (o.ar) box2(group, 0.012, 0.016, 6e-3, receiverMaterial, ejectX - 0.03, ejectY + 4e-3, wR / 2 + 4e-3);
+    if (o.ar) box3(group, 0.012, 0.016, 6e-3, receiverMaterial, ejectX - 0.03, ejectY + 4e-3, wR / 2 + 4e-3);
     if (o.rail) rail(kit, group, x0 - 5e-3, RL + 0.07, hR / 2 + (o.ar ? 0 : 3e-3), 0, wR * 0.68);
   }
   function buildBarrel(context) {
     const { kit, group, parts, options: o, length: L, barrelLength: Bl, receiverEnd: x1, barrelRadius: r, barrelY: by } = context;
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     heatify(parts.glow, cylinderX(group, r, Bl, M.metal, L - Bl / 2, by, 0, 16));
     if (o.jacket) {
       cylinderX(group, r * 2, (L - x1) * 0.6, M.dark, x1 + (L - x1) * 0.3, by, 0, 16);
@@ -18531,7 +18720,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         heatify(parts.glow, cylinderX(group, r * 1.45, 0.042, M.dark, L - 0.021, by, 0, 16));
         for (let i = 0; i < 4; i++) {
           const angle = i * PI10 / 2 + PI10 / 4;
-          box2(group, 0.026, 25e-4, 4e-3, M.hole, L - 0.02, by + Math.cos(angle) * r * 1.42, Math.sin(angle) * r * 1.42, 0, 0, angle);
+          box3(group, 0.026, 25e-4, 4e-3, M.hole, L - 0.02, by + Math.cos(angle) * r * 1.42, Math.sin(angle) * r * 1.42, 0, 0, angle);
         }
       });
     }
@@ -18634,10 +18823,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     for (const [name, part] of partRegistry(parts)) part.name = name;
   };
   var fitLength = (kit, inner, lengthMetres) => {
-    const box2 = new kit.THREE.Box3().setFromObject(inner);
-    const factor = lengthMetres / (box2.max.x - box2.min.x);
+    const box3 = new kit.THREE.Box3().setFromObject(inner);
+    const factor = lengthMetres / (box3.max.x - box3.min.x);
     inner.scale.x = factor;
-    inner.position.x = -box2.min.x * factor;
+    inner.position.x = -box3.min.x * factor;
     const root = kit.group();
     root.add(inner);
     return root;
@@ -18679,7 +18868,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   };
 
   // src/props.ts
-  var box = (id, material, size, position, extra = {}) => ({ id, material, shape: { kind: "box", size }, position, ...extra });
+  var box2 = (id, material, size, position, extra = {}) => ({ id, material, shape: { kind: "box", size }, position, ...extra });
   var joint = (a, b, kind) => ({ a, b, kind });
   var handled = (name, handle, head) => {
     const [handleMaterial, rawHandle] = handle;
@@ -18691,16 +18880,16 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     return {
       spec: {
         name,
-        parts: [box("handle", handleMaterial, handleSize, [-handleSize[0] / 2 + shift, thickness / 2, 0]), box("head", headMaterial, headSize, [headSize[0] / 2 + shift, thickness / 2, 0])],
+        parts: [box2("handle", handleMaterial, handleSize, [-handleSize[0] / 2 + shift, thickness / 2, 0]), box2("head", headMaterial, headSize, [headSize[0] / 2 + shift, thickness / 2, 0])],
         joints: [joint("handle", "head", "screw")],
         tags: ["weapon"]
       },
       colors: { handle: handleMaterial === "steel" ? 3816770 : handleMaterial === "plastic" ? 2829616 : 8017200, head: headMaterial === "steel" ? 9410206 : headMaterial === "copper" ? 12088115 : 7031338 }
     };
   };
-  var solid = (name, material, size, color) => ({
-    spec: { name, parts: [box("body", material, size, [0, size[1] / 2, 0])], joints: [], tags: ["weapon"] },
-    colors: { body: color }
+  var solid = (name, material, size, color2) => ({
+    spec: { name, parts: [box2("body", material, size, [0, size[1] / 2, 0])], joints: [], tags: ["weapon"] },
+    colors: { body: color2 }
   });
   var SHAPES = {
     pistol: (n) => handled(n, ["plastic", [0.06, 0.03, 0.11]], ["steel", [0.2, 0.03, 0.04]]),
@@ -18756,9 +18945,9 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     decorate?.(model.root);
     const group = new THREE.Group();
     group.name = name;
-    const box2 = new THREE.Box3().setFromObject(model.root);
-    const center = box2.getCenter(new THREE.Vector3());
-    model.root.position.set(-center.x, -box2.min.y, -center.z);
+    const box3 = new THREE.Box3().setFromObject(model.root);
+    const center = box3.getCenter(new THREE.Vector3());
+    model.root.position.set(-center.x, -box3.min.y, -center.z);
     group.add(model.root);
     group.updateMatrixWorld(true);
     for (const mesh2 of mergeByMaterial(THREE, model.root, group)) {
@@ -18766,7 +18955,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       group.add(mesh2);
     }
     group.remove(model.root);
-    const size = box2.getSize(new THREE.Vector3());
+    const size = box3.getSize(new THREE.Vector3());
     group.userData.footprint = [size.x, size.y, size.z];
     return group;
   }
@@ -18996,10 +19185,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     }
     const sampleKey = (t, includeInstants) => {
       const poses = /* @__PURE__ */ new Map();
-      for (const [key, list] of channels) {
+      for (const [key, list2] of channels) {
         const [part, channel, axis2] = key.split("|");
         const pose = poses.get(part) ?? { position: [0, 0, 0], rotation: [0, 0, 0] };
-        pose[channel][AXIS_INDEX[axis2]] = round(valueAt(list, t, includeInstants));
+        pose[channel][AXIS_INDEX[axis2]] = round(valueAt(list2, t, includeInstants));
         poses.set(part, pose);
       }
       const root = poses.get(ROOT);
@@ -19137,7 +19326,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   }
 
   // src/animation/reload-clips.ts
-  var KINDS = ["tactical", "empty", "one_by_one"];
+  var KINDS2 = ["tactical", "empty", "one_by_one"];
   var charge = (context, start) => {
     const travel = strokeOf(context.parts);
     return [move("bolt", "x", start, 0.12, 0, travel), move("bolt", "x", start + 0.18, 0.06, travel, 0)];
@@ -19246,7 +19435,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   function reloadClips(context) {
     const clips = [];
     let first;
-    for (const kind of KINDS) {
+    for (const kind of KINDS2) {
       const draft = draftFor(context, kind);
       if (!draft) return [];
       const clip = composeClip(kind === "tactical" ? "reload" : `reload_${kind}`, draft.tweens, [...draft.events, ...markers(context, kind, draft.end)], draft.end);
@@ -19421,12 +19610,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var BELT_POINTS = 16;
   var BELT_ROUND_EVERY = 2;
   var buildAmmoBackpack = ({ kit, frame, model }) => {
-    const { THREE, M, box: box2, cylinderZ } = kit;
+    const { THREE, M, box: box3, cylinderZ } = kit;
     const group = kit.group();
     const pack = [PACK_AT[0] - frame.position[0], PACK_AT[1] - frame.position[1], PACK_AT[2] - frame.position[2]];
-    box2(group, ...PACK_SIZE, M.olive, ...pack);
-    box2(group, PACK_SIZE[0] * 1.02, 0.03, PACK_SIZE[2] * 1.02, M.dark, pack[0], pack[1] + PACK_SIZE[1] / 2, pack[2]);
-    box2(group, 0.04, PACK_SIZE[1] * 0.9, 0.012, M.tan, pack[0] + PACK_SIZE[0] / 2, pack[1], pack[2] - 0.04);
+    box3(group, ...PACK_SIZE, M.olive, ...pack);
+    box3(group, PACK_SIZE[0] * 1.02, 0.03, PACK_SIZE[2] * 1.02, M.dark, pack[0], pack[1] + PACK_SIZE[1] / 2, pack[2]);
+    box3(group, 0.04, PACK_SIZE[1] * 0.9, 0.012, M.tan, pack[0] + PACK_SIZE[0] / 2, pack[1], pack[2] - 0.04);
     const feed = kit.pivot(group, 0, 0, 0);
     buildBeltBox(kit, feed);
     const points = catenary([pack[0] + PACK_SIZE[0] / 2, pack[1] + PACK_SIZE[1] * 0.3, pack[2]], [0, 0, 0], BELT_SAG, BELT_POINTS);
@@ -19447,10 +19636,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   // src/models/attachments/foregrip.ts
   var RIBS = 4;
   var buildForegrip = ({ kit, attachment }) => {
-    const { M, box: box2, cylinderY } = kit;
+    const { M, box: box3, cylinderY } = kit;
     const length2 = attachment.dims?.length ?? 0.1;
     const group = kit.group();
-    box2(group, 0.045, 0.014, 0.034, M.dark, 0, -7e-3, 0);
+    box3(group, 0.045, 0.014, 0.034, M.dark, 0, -7e-3, 0);
     cylinderY(group, 0.0135, length2, M.poly, 0, -0.014 - length2 / 2, 0, 14);
     for (let i = 0; i < RIBS; i++) cylinderY(group, 0.0145, 4e-3, M.rubber, 0, -0.03 - i * (length2 / (RIBS + 1)), 0, 14);
     cylinderY(group, 0.0155, 0.01, M.dark, 0, -0.014 - length2, 0, 14);
@@ -19463,20 +19652,20 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var BEAM_WIDTH = 25e-4;
   var DOT_RADIUS = 0.012;
   var buildLaser = ({ kit, attachment, frame, raycast }) => {
-    const { THREE, M, box: box2, cylinderX } = kit;
+    const { THREE, M, box: box3, cylinderX } = kit;
     const length2 = attachment.dims?.length ?? 0.08;
     const half = (attachment.dims?.diameter ?? 0.025) / 2;
-    const range = attachment.laser?.range ?? DEFAULT_RANGE;
-    const color = attachment.laser?.color ?? DEFAULT_COLOR;
+    const range2 = attachment.laser?.range ?? DEFAULT_RANGE;
+    const color2 = attachment.laser?.color ?? DEFAULT_COLOR;
     const group = kit.group();
     const offset = frame.side === 0 ? { y: -(half + 4e-3), z: 0 } : { y: 0, z: frame.side * (half + 4e-3) };
-    box2(group, 0.03, 0.012, 0.028, M.dark, 0, frame.side === 0 ? -2e-3 : 0, 0);
-    box2(group, length2, half * 2, half * 2, M.dark, 0, offset.y, offset.z);
+    box3(group, 0.03, 0.012, 0.028, M.dark, 0, frame.side === 0 ? -2e-3 : 0, 0);
+    box3(group, length2, half * 2, half * 2, M.dark, 0, offset.y, offset.z);
     const emitter = new THREE.MeshBasicMaterial({ color: 5574929 });
     cylinderX(group, half * 0.5, 4e-3, emitter, length2 / 2 + 1e-3, offset.y, offset.z, 10);
-    const glow = new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 0.7, blending: THREE.AdditiveBlending, depthWrite: false });
+    const glow = new THREE.MeshBasicMaterial({ color: color2, transparent: true, opacity: 0.7, blending: THREE.AdditiveBlending, depthWrite: false });
     const beam = new THREE.Mesh(new THREE.BoxGeometry(1, BEAM_WIDTH, BEAM_WIDTH), glow);
-    const dot2 = new THREE.Mesh(new THREE.SphereGeometry(DOT_RADIUS, 10, 8), new THREE.MeshBasicMaterial({ color }));
+    const dot2 = new THREE.Mesh(new THREE.SphereGeometry(DOT_RADIUS, 10, 8), new THREE.MeshBasicMaterial({ color: color2 }));
     const front = length2 / 2 + 4e-3;
     beam.position.set(front, offset.y, offset.z);
     dot2.position.set(front, offset.y, offset.z);
@@ -19491,7 +19680,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       object: group,
       setOn(on) {
         isOn = on;
-        emitter.color.setHex(on ? color : 5574929);
+        emitter.color.setHex(on ? color2 : 5574929);
         beam.visible = on;
         if (!on) dot2.visible = false;
       },
@@ -19501,8 +19690,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         group.getWorldPosition(origin);
         direction.set(1, 0, 0).transformDirection(group.matrixWorld);
         group.getWorldScale(scale);
-        const hit = raycast?.(origin, direction, range) ?? null;
-        const reach = (hit ?? range) / Math.max(scale.x, 1e-6);
+        const hit = raycast?.(origin, direction, range2) ?? null;
+        const reach = (hit ?? range2) / Math.max(scale.x, 1e-6);
         beam.scale.x = reach;
         beam.position.x = front + reach / 2;
         dot2.visible = hit !== null;
@@ -19524,18 +19713,18 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var DEFAULT_CONE_DEG = 30;
   var DEFAULT_RANGE2 = 60;
   var buildLight = ({ kit, attachment, frame }) => {
-    const { THREE, M, box: box2, cylinderX } = kit;
+    const { THREE, M, box: box3, cylinderX } = kit;
     const length2 = attachment.dims?.length ?? 0.1;
     const radius = (attachment.dims?.diameter ?? 0.03) / 2;
     const group = kit.group();
     const offset = frame.side === 0 ? { y: -(radius + 4e-3), z: 0 } : { y: 0, z: frame.side * (radius + 4e-3) };
-    box2(group, 0.035, 0.012, 0.03, M.dark, 0, frame.side === 0 ? -2e-3 : 0, 0);
+    box3(group, 0.035, 0.012, 0.03, M.dark, 0, frame.side === 0 ? -2e-3 : 0, 0);
     cylinderX(group, radius, length2, M.dark, 0, offset.y, offset.z, 14);
     cylinderX(group, radius * 1.08, 0.012, M.metal, length2 / 2 - 6e-3, offset.y, offset.z, 14);
     const lens2 = new THREE.MeshStandardMaterial({ color: 16773832, roughness: 0.1, metalness: 0.2, emissive: 16773832, emissiveIntensity: 0 });
     cylinderX(group, radius * 0.82, 4e-3, lens2, length2 / 2 + 1e-3, offset.y, offset.z, 14);
-    const cone = (attachment.light?.coneDeg ?? DEFAULT_CONE_DEG) * (Math.PI / 180);
-    const spot = new THREE.SpotLight(16773584, LIGHT_INTENSITY, attachment.light?.range ?? DEFAULT_RANGE2, cone / 2, 0.35, 1.2);
+    const cone2 = (attachment.light?.coneDeg ?? DEFAULT_CONE_DEG) * (Math.PI / 180);
+    const spot = new THREE.SpotLight(16773584, LIGHT_INTENSITY, attachment.light?.range ?? DEFAULT_RANGE2, cone2 / 2, 0.35, 1.2);
     spot.position.set(length2 / 2 + 0.01, offset.y, offset.z);
     spot.intensity = 0;
     const target = new THREE.Object3D();
@@ -19564,23 +19753,23 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     return { object: group, hangsFrom: "magazine", hides: factoryMagazine };
   };
   var buildExtendedMagazine = ({ kit, model }) => {
-    const { M, box: box2 } = kit;
+    const { M, box: box3 } = kit;
     const length2 = Math.max(0.1, (model.parts.magDrop ?? 0.16) - 0.03);
     const extension = length2 * EXTENSION_FRACTION;
     const group = kit.group();
     const lean = Math.sin(MAGAZINE_LEAN) * (length2 + extension / 2);
-    box2(group, 0.05, extension + 4e-3, 0.024, M.dark, lean, -(Math.cos(MAGAZINE_LEAN) * (length2 + extension / 2)), 0, MAGAZINE_LEAN);
-    box2(group, 0.056, 7e-3, 0.028, M.dark, lean + Math.sin(MAGAZINE_LEAN) * extension / 2, -(Math.cos(MAGAZINE_LEAN) * (length2 + extension)) - 3e-3, 0);
+    box3(group, 0.05, extension + 4e-3, 0.024, M.dark, lean, -(Math.cos(MAGAZINE_LEAN) * (length2 + extension / 2)), 0, MAGAZINE_LEAN);
+    box3(group, 0.056, 7e-3, 0.028, M.dark, lean + Math.sin(MAGAZINE_LEAN) * extension / 2, -(Math.cos(MAGAZINE_LEAN) * (length2 + extension)) - 3e-3, 0);
     return { object: group, hangsFrom: "magazine" };
   };
   var buildDualCoupler = ({ kit, factoryMagazine }) => {
-    const { M, box: box2 } = kit;
+    const { M, box: box3 } = kit;
     const group = kit.group();
     const spare = kit.group();
     spare.position.set(0, 0, 0.032);
-    for (const piece of factoryMagazine) spare.add(piece.clone(true));
+    for (const piece2 of factoryMagazine) spare.add(piece2.clone(true));
     group.add(spare);
-    box2(group, 0.05, 0.012, 0.04, M.tape, 0, -0.03, 0.016);
+    box3(group, 0.05, 0.012, 0.04, M.tape, 0, -0.03, 0.016);
     return { object: group, hangsFrom: "magazine" };
   };
 
@@ -19591,12 +19780,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     return group;
   };
   var buildCompensator = ({ kit, frame }) => {
-    const { M, box: box2, cylinderX } = kit;
+    const { M, box: box3, cylinderX } = kit;
     const radius = frame.barrelRadius * 1.9;
     const length2 = 0.07;
     const group = kit.group();
     cylinderX(group, radius, length2, M.dark, -length2 / 2, 0, 0, 16);
-    for (let i = 0; i < 3; i++) box2(group, length2 * 0.14, radius * 0.9, radius * 0.7, M.hole, -length2 * 0.2 - i * length2 * 0.25, radius * 0.75, 0);
+    for (let i = 0; i < 3; i++) box3(group, length2 * 0.14, radius * 0.9, radius * 0.7, M.hole, -length2 * 0.2 - i * length2 * 0.25, radius * 0.75, 0);
     return group;
   };
 
@@ -19614,9 +19803,9 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   };
   var ADAPTER_LENGTH = 0.1;
   var ADAPTER_BACK = 0.05;
-  var tinted = (context, group, color) => {
+  var tinted = (context, group, color2) => {
     const { THREE, M } = context.kit;
-    const lens2 = new THREE.MeshStandardMaterial({ color, roughness: 0.05, metalness: 0.3, transparent: true, opacity: 0.9, emissive: color, emissiveIntensity: 0.6 });
+    const lens2 = new THREE.MeshStandardMaterial({ color: color2, roughness: 0.05, metalness: 0.3, transparent: true, opacity: 0.9, emissive: color2, emissiveIntensity: 0.6 });
     group.traverse((node) => {
       const mesh2 = node;
       if (mesh2.isMesh && mesh2.material === M.lens) mesh2.material = lens2;
@@ -19690,14 +19879,14 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     ag36: { tubeRadius: 0.02, tubeFraction: 0.8, housing: [0.13, 0.06, 0.05], hasFrontGrip: true }
   };
   var drawFixed = (kit, group, look, length2) => {
-    const { M, box: box2, cylinderY } = kit;
+    const { M, box: box3, cylinderY } = kit;
     const [housingLength, housingHeight, housingWidth] = look.housing;
-    box2(group, housingLength, housingHeight, housingWidth, M.dark, housingLength / 2 - 0.02, -look.tubeRadius, 0);
-    box2(group, 0.05, 4e-3, 0.012, M.metal, housingLength * 0.45, -look.tubeRadius - housingHeight / 2 - 4e-3, 0);
-    box2(group, 4e-3, 0.02, 8e-3, M.dark, housingLength * 0.6, -look.tubeRadius - housingHeight / 2 - 0.016, 0);
+    box3(group, housingLength, housingHeight, housingWidth, M.dark, housingLength / 2 - 0.02, -look.tubeRadius, 0);
+    box3(group, 0.05, 4e-3, 0.012, M.metal, housingLength * 0.45, -look.tubeRadius - housingHeight / 2 - 4e-3, 0);
+    box3(group, 4e-3, 0.02, 8e-3, M.dark, housingLength * 0.6, -look.tubeRadius - housingHeight / 2 - 0.016, 0);
     if (look.hasFrontGrip) {
       cylinderY(group, 0.012, 0.07, M.poly, length2 * 0.55, -look.tubeRadius - 0.04, 0, 12);
-      box2(group, 0.04, 0.01, 0.03, M.dark, length2 * 0.55, -look.tubeRadius - 4e-3, 0);
+      box3(group, 0.04, 0.01, 0.03, M.dark, length2 * 0.55, -look.tubeRadius - 4e-3, 0);
     }
   };
   var buildUnderbarrelLauncher = ({ kit, attachment, slide: slide2 }) => {
@@ -19759,20 +19948,20 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const hiddenBy = /* @__PURE__ */ new Map();
     const switchedOn = /* @__PURE__ */ new Map();
     const hide = (id, objects) => {
-      for (const object of objects) {
-        const owners = hiddenBy.get(object) ?? /* @__PURE__ */ new Set();
+      for (const object2 of objects) {
+        const owners = hiddenBy.get(object2) ?? /* @__PURE__ */ new Set();
         owners.add(id);
-        hiddenBy.set(object, owners);
-        object.visible = false;
+        hiddenBy.set(object2, owners);
+        object2.visible = false;
       }
     };
     const unhide = (id, objects) => {
-      for (const object of objects) {
-        const owners = hiddenBy.get(object);
+      for (const object2 of objects) {
+        const owners = hiddenBy.get(object2);
         owners?.delete(id);
         if (!owners || owners.size === 0) {
-          hiddenBy.delete(object);
-          object.visible = true;
+          hiddenBy.delete(object2);
+          object2.visible = true;
         }
       }
     };
@@ -19808,15 +19997,15 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         entry.model.setOn?.(beams && switchedOn.get(id) === true);
       }
     };
-    const sync = (list) => {
-      const wanted = new Map(list.map((part) => [part.id, part]));
+    const sync = (list2) => {
+      const wanted = new Map(list2.map((part) => [part.id, part]));
       for (const id of [...drawn.keys()]) if (!wanted.has(id) || drawn.get(id)?.mount !== wanted.get(id)?.mount) take(id);
       for (const [id, objects] of Object.entries(parts.fittings ?? {})) {
         if (id === MUZZLE_DEFAULT) continue;
-        for (const object of objects) object.visible = wanted.has(id);
+        for (const object2 of objects) object2.visible = wanted.has(id);
       }
-      for (const object of parts.fittings?.[MUZZLE_DEFAULT] ?? []) object.visible = !list.some((part) => part.mount === "muzzle");
-      for (const part of list) {
+      for (const object2 of parts.fittings?.[MUZZLE_DEFAULT] ?? []) object2.visible = !list2.some((part) => part.mount === "muzzle");
+      for (const part of list2) {
         const attachment = options.catalogue.get(part.id);
         if (!attachment || drawn.has(part.id) || parts.fittings?.[part.id]) continue;
         if (part.integral === true && attachment.kind === "optic") continue;
@@ -19908,9 +20097,9 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const replacement = substitutions(kit, condition);
     const glowing = new Set(model.parts.glow);
     const paint2 = condition === "rusty" ? kit.M.rust.color : condition === "worn" ? kit.M.worn.color : void 0;
-    model.root.traverse((object) => {
+    model.root.traverse((object2) => {
       var _a, _b;
-      const mesh2 = object;
+      const mesh2 = object2;
       if (!mesh2.isMesh) return;
       (_a = mesh2.userData).baseMaterial ?? (_a.baseMaterial = mesh2.material);
       const base = mesh2.userData.baseMaterial;
@@ -21353,15 +21542,15 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     puff3.t += dt;
     return puff3.t < puff3.life;
   }
-  function moveOnRing(puff3, ring2, wind) {
-    const ringTime = ring2.t;
-    const centerY = ring2.y0 + ring2.rise * (1 - Math.exp(-ringTime * ring2.rk));
-    const majorRadius = ring2.R0 + (ring2.R1 - ring2.R0) * (1 - Math.exp(-ringTime * 1.6));
-    const theta = puff3.th + ringTime * ring2.roll;
-    const minorRadius = ring2.r * (0.8 + 0.4 * Math.min(1, ringTime));
+  function moveOnRing(puff3, ring22, wind) {
+    const ringTime = ring22.t;
+    const centerY = ring22.y0 + ring22.rise * (1 - Math.exp(-ringTime * ring22.rk));
+    const majorRadius = ring22.R0 + (ring22.R1 - ring22.R0) * (1 - Math.exp(-ringTime * 1.6));
+    const theta = puff3.th + ringTime * ring22.roll;
+    const minorRadius = ring22.r * (0.8 + 0.4 * Math.min(1, ringTime));
     const radius = majorRadius + minorRadius * Math.cos(theta);
-    puff3.x = ring2.x + Math.cos(puff3.ph) * radius + wind.x * ringTime * 0.6;
-    puff3.z = ring2.z + Math.sin(puff3.ph) * radius + wind.z * ringTime * 0.6;
+    puff3.x = ring22.x + Math.cos(puff3.ph) * radius + wind.x * ringTime * 0.6;
+    puff3.z = ring22.z + Math.sin(puff3.ph) * radius + wind.z * ringTime * 0.6;
     puff3.y = centerY + minorRadius * Math.sin(theta);
   }
   function moveFree(puff3, dt, age, heat, wind) {
@@ -21683,7 +21872,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var mesh = (options) => ({ op: "mesh", spawn: options });
   var debris = (options) => ({ op: "debris", spawn: options });
   var decal = (...args) => ({ op: "decal", args });
-  var ring = (...args) => ({ op: "ring", args });
+  var ring2 = (...args) => ({ op: "ring", args });
   var flash = (...args) => ({ op: "flash", args });
   var lens = (...args) => ({ op: "lens", args });
   var screen = (change) => ({ op: "screen", ...change });
@@ -21715,7 +21904,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         burst("normal", 30, { p: CENTRE, dir: UP, cone: 1.3, sp: [2, 4], life: 1.4, size: [0.04, 0.08], c0: 4872732, g: 9.8, fi: 0, gnd: 3, ds: [0.1, 0.2] }),
         repeat(scaled(10), debris({ p: CENTRE, dir: UP, cone: 1.2, sp: [2, 5], size: [0.07, 0.05, 0.07], k: [0.6, 1.4], c: ite(mod(INDEX, 2), 7043666, 4856338), life: 9 })),
         decal(0, 0, 0, 1.6, 6978084, { grow: 0.6, life: 60, fluid: "bile" }),
-        ring([0, 0.02, 0], 4, 4, 8, 3824160, UP, 0.35),
+        ring2([0, 0.02, 0], 4, 4, 8, 3824160, UP, 0.35),
         screen({ add: { shake: 0.15 } })
       )
     ],
@@ -21879,7 +22068,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     timeline: [
       after(
         PREPARATION_END,
-        repeat(3, after(add(PREPARATION_END, mul(INDEX, 0.18)), ring([0, 0.03, 0], 0.3, 9, 0.9, WHITE_RING))),
+        repeat(3, after(add(PREPARATION_END, mul(INDEX, 0.18)), ring2([0, 0.03, 0], 0.3, 9, 0.9, WHITE_RING))),
         screen({ add: { chroma: 7, shake: 0.25 } })
       )
     ],
@@ -23446,7 +23635,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       grow: 2.2
     })
   ];
-  var flashPiece = (shape, radius, height, width, at3, rot, color) => mesh({ shape, r: radius, ...height === void 0 ? {} : { h: height }, seg: width, seg2: shape === "sphere" ? 8 : 1, p: ORIGIN2, at: at3, rot, roll: variable("roll"), ramp: FLASH_RAMP, life: FLASH_SECONDS, c0: color, a: FLASH_OPACITY, add: true });
+  var flashPiece = (shape, radius, height, width, at3, rot, color2) => mesh({ shape, r: radius, ...height === void 0 ? {} : { h: height }, seg: width, seg2: shape === "sphere" ? 8 : 1, p: ORIGIN2, at: at3, rot, roll: variable("roll"), ramp: FLASH_RAMP, life: FLASH_SECONDS, c0: color2, a: FLASH_OPACITY, add: true });
   var MUZZLE_FLASH2 = {
     id: "viewmodel_muzzle_flash",
     pageId: "event:viewmodel_muzzle_flash",
@@ -23560,10 +23749,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       direction(out) {
         const up = next() * 2 - 1;
         const angle = next() * Math.PI * 2;
-        const ring2 = Math.sqrt(1 - up * up);
-        out.x = ring2 * Math.cos(angle);
+        const ring22 = Math.sqrt(1 - up * up);
+        out.x = ring22 * Math.cos(angle);
         out.y = up;
-        out.z = ring2 * Math.sin(angle);
+        out.z = ring22 * Math.sin(angle);
         return out;
       },
       get state() {
@@ -23578,7 +23767,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     mixed ^= mixed >>> 16;
     return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
   }
-  function streamFor2(eventSeed) {
+  function streamFor3(eventSeed) {
     return lehmer(mixEventSeed(eventSeed));
   }
   var TABLE = {
@@ -23602,10 +23791,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   function bloodHit(engine, point, exitDirection, age, scale = 1) {
     if (age === 3) return drySplash(engine, point, exitDirection, scale);
     const amount = BLEED_BY_AGE[age];
-    const color = BLOOD_COLORS[age];
-    engine.burst("normal", 10 * amount * scale, { p: point, dir: negated(exitDirection), cone: 0.9, sp: [0.2, 0.9], drag: 3, life: [0.25, 0.5], size: [0.08, 0.14], grow: 3, c0: color, a: 0.65 });
-    engine.burst("normal", 45 * amount * scale, { p: point, dir: exitDirection, cone: 0.45, sp: [2.5, 6], life: [1, 1.6], size: [0.035, 0.07], c0: color, a: 0.95, g: 9.8, fi: 0, gnd: 3, ds: [0.06, 0.16] });
-    engine.burst("normal", 14 * amount * scale, { p: point, dir: exitDirection, cone: 0.5, sp: [1, 2.5], drag: 2.5, life: [0.4, 0.8], size: [0.1, 0.18], grow: 3, c0: color, a: 0.45 });
+    const color2 = BLOOD_COLORS[age];
+    engine.burst("normal", 10 * amount * scale, { p: point, dir: negated(exitDirection), cone: 0.9, sp: [0.2, 0.9], drag: 3, life: [0.25, 0.5], size: [0.08, 0.14], grow: 3, c0: color2, a: 0.65 });
+    engine.burst("normal", 45 * amount * scale, { p: point, dir: exitDirection, cone: 0.45, sp: [2.5, 6], life: [1, 1.6], size: [0.035, 0.07], c0: color2, a: 0.95, g: 9.8, fi: 0, gnd: 3, ds: [0.06, 0.16] });
+    engine.burst("normal", 14 * amount * scale, { p: point, dir: exitDirection, cone: 0.5, sp: [1, 2.5], drag: 2.5, life: [0.4, 0.8], size: [0.1, 0.18], grow: 3, c0: color2, a: 0.45 });
   }
   function waterImpact(engine, point, scale) {
     engine.burst("normal", 22 * scale, { p: point, dir: [0, 1, 0], cone: 0.5, sp: [1.5, 3.5], life: [0.4, 0.7], size: [0.03, 0.06], c0: 13162214, a: 0.7, g: 9.8, fi: 0, gnd: 1 });
@@ -24250,8 +24439,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var UP12 = [0, 1, 0];
   var ZERO2 = [0, 0, 0];
   var FULL_TURN_DRAWN = 6.283;
-  function scaledSizes(range, factor) {
-    return [range[0] * Math.sqrt(factor), range[1] * Math.sqrt(factor)];
+  function scaledSizes(range2, factor) {
+    return [range2[0] * Math.sqrt(factor), range2[1] * Math.sqrt(factor)];
   }
   function fireEmit(engine, key, dt, centre, radius, factor, options = {}) {
     const wind = options.wind ?? ZERO2;
@@ -24896,7 +25085,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const px = x + Math.cos(angle) * distance2;
       const pz = z + Math.sin(angle) * distance2;
       const plate = random.next() < 0.6;
-      const color = RIM_COLORS[random.next() < 0.5 ? 0 : 1];
+      const color2 = RIM_COLORS[random.next() < 0.5 ? 0 : 1];
       const tiltX = random.between(-0.5, 0.5);
       const tiltZ = random.between(-0.6, 0.2);
       store.add({
@@ -24907,7 +25096,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         scale: [size * 2, size * 0.35, size * 1.4],
         rotation: [tiltX, angle, tiltZ],
         plate,
-        color
+        color: color2
       });
     }
   }
@@ -24928,27 +25117,27 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   function createRingPool(capacity) {
     return new OrderedPool(capacity, () => ({ x: 0, z: 0, y0: 0, rise: 0, rk: 0, R0: 0, R1: 0, r: 0, roll: 0, t: 0, life: 0 }));
   }
-  function ageOrKeep4(ring2, dt) {
-    ring2.t += dt;
-    return ring2.t <= ring2.life + 1;
+  function ageOrKeep4(ring22, dt) {
+    ring22.t += dt;
+    return ring22.t <= ring22.life + 1;
   }
   function updateRings(pool, dt) {
     pool.compact(ageOrKeep4, dt);
   }
   function spawnRing(pool, spec) {
-    const ring2 = pool.acquire();
-    ring2.x = spec.x;
-    ring2.z = spec.z;
-    ring2.y0 = spec.y0;
-    ring2.rise = spec.rise;
-    ring2.rk = spec.rk;
-    ring2.R0 = spec.R0;
-    ring2.R1 = spec.R1;
-    ring2.r = spec.r;
-    ring2.roll = spec.roll;
-    ring2.t = 0;
-    ring2.life = spec.life;
-    return ring2;
+    const ring22 = pool.acquire();
+    ring22.x = spec.x;
+    ring22.z = spec.z;
+    ring22.y0 = spec.y0;
+    ring22.rise = spec.rise;
+    ring22.rk = spec.rk;
+    ring22.R0 = spec.R0;
+    ring22.R1 = spec.R1;
+    ring22.r = spec.r;
+    ring22.roll = spec.roll;
+    ring22.t = 0;
+    ring22.life = spec.life;
+    return ring22;
   }
   var DEFAULT_DURATION = 0.3;
   var SHELL_GROWTH_SECONDS = 0.12;
@@ -25117,12 +25306,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const { core, def, random, x, z, size, scale } = context;
     if (!core.layers.smoke || !def.dust.count || !(scale > 0.15)) return;
     const count = Math.round(def.dust.count * scale);
-    const color = hexToLinearRgb(def.dust.color);
-    const cone = def.cone;
+    const color2 = hexToLinearRgb(def.dust.color);
+    const cone2 = def.cone;
     for (let index = 0; index < count; index++) {
       let angle = random.next() * Math.PI * 2;
-      if (cone) angle = coneAngle(context) + random.between(-cone.half, cone.half);
-      const speed = random.between(0.6, 1) * def.injury * (cone ? 1.6 : 0.9);
+      if (cone2) angle = coneAngle(context) + random.between(-cone2.half, cone2.half);
+      const speed = random.between(0.6, 1) * def.injury * (cone2 ? 1.6 : 0.9);
       const vy2 = random.between(0.2, 1.2);
       const s1 = size * random.between(0.5, 0.8);
       const sg = size * random.between(0.2, 0.35);
@@ -25141,21 +25330,21 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         life,
         drag: 3.6,
         buoy: 0.2,
-        color,
+        color: color2,
         kind: 1
       });
     }
   }
   function coneAngle(context) {
-    const cone = context.def.cone;
-    if (!cone) return 0;
-    return context.direction ? Math.atan2(context.direction.z, context.direction.x) : cone.angle;
+    const cone2 = context.def.cone;
+    if (!cone2) return 0;
+    return context.direction ? Math.atan2(context.direction.z, context.direction.x) : cone2.angle;
   }
   function sparkDirection(context) {
     const { def, random, direction } = context;
-    const cone = def.cone;
-    if (cone) {
-      const angle = coneAngle(context) + random.between(-cone.half, cone.half);
+    const cone2 = def.cone;
+    if (cone2) {
+      const angle = coneAngle(context) + random.between(-cone2.half, cone2.half);
       SCRATCH.x = Math.cos(angle);
       SCRATCH.y = random.between(-0.05, 0.25);
       SCRATCH.z = Math.sin(angle);
@@ -25215,7 +25404,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const s = random.between(0.07, 0.2) * (chunks.size ?? 1);
       const plate = chunks.plate ? random.next() < 0.6 : random.next() < 0.15;
       const sy = plate ? s * 0.3 : s * random.between(0.6, 1);
-      const color = hexToRgb(chunks.colors.length > 0 ? pick2(random, chunks.colors) : DEFAULT_CHUNK_COLOR);
+      const color2 = hexToRgb(chunks.colors.length > 0 ? pick2(random, chunks.colors) : DEFAULT_CHUNK_COLOR);
       const hot = random.next() < chunks.hot;
       addChunk(core, random, {
         x: x + d.x * 0.2,
@@ -25227,7 +25416,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         sx: plate ? s * 1.6 : s,
         sy,
         sz: plate ? s * 1.1 : s,
-        color,
+        color: color2,
         plate,
         hot
       });
@@ -25244,7 +25433,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const speed = random.between(3, 8) * speedScale;
       const s = random.between(0.12, 0.28);
       const vy2 = random.between(4, 10);
-      const color = hexToRgb(random.next() < 0.6 ? ROCK_COLORS[0] : ROCK_COLORS[1]);
+      const color2 = hexToRgb(random.next() < 0.6 ? ROCK_COLORS[0] : ROCK_COLORS[1]);
       addChunk(core, random, {
         x: x + Math.cos(angle) * 0.3,
         y: 0.1,
@@ -25255,7 +25444,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         sx: s * 1.6,
         sy: s * 0.35,
         sz: s * 1.2,
-        color,
+        color: color2,
         plate: true
       });
     }
@@ -25263,8 +25452,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   function composeMushroom(context, spec) {
     const { core, random, x, y, z } = context;
     core.trace?.mushroom?.(x, y, z, spec);
-    const color = spec.color !== void 0 ? hexToLinearRgb(spec.color) : SMOKE_COLORS.black;
-    const ring2 = spawnRing(core.rings, {
+    const color2 = spec.color !== void 0 ? hexToLinearRgb(spec.color) : SMOKE_COLORS.black;
+    const ring22 = spawnRing(core.rings, {
       x,
       z,
       y0: y + spec.height * 0.15,
@@ -25280,11 +25469,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const count = Math.round((spec.count || 40) * Math.max(lod, 0.4));
     for (let index = 0; index < count; index++) {
       const s1 = spec.radius * random.between(0.35, 0.5);
-      const life = random.between(ring2.life * 0.75, ring2.life);
+      const life = random.between(ring22.life * 0.75, ring22.life);
       const h0 = random.between(1, 1.25);
       const hl = random.between(0.9, 1.6);
-      const puff3 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color, kind: 0 });
-      puff3.ring = ring2;
+      const puff3 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color: color2, kind: 0 });
+      puff3.ring = ring22;
       puff3.ph = random.next() * Math.PI * 2;
       puff3.th = random.next() * Math.PI * 2;
     }
@@ -25300,7 +25489,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const life = random.between(3, 5);
       const h0 = random.between(0.9, 1.2);
       const hl = random.between(0.6, 1.1);
-      addPuff(core, random, { x: px, y: y + 0.3, z: pz, vx: vx2, vy: vy2, vz: vz2, s0: spec.radius * 0.12, s1, sg: spec.radius * 0.05, gk: 4, life, h0, hl, drag: 1.2, buoy: 0.5, color });
+      addPuff(core, random, { x: px, y: y + 0.3, z: pz, vx: vx2, vy: vy2, vz: vz2, s0: spec.radius * 0.12, s1, sg: spec.radius * 0.05, gk: 4, life, h0, hl, drag: 1.2, buoy: 0.5, color: color2 });
     }
   }
   function composeAfterEffects(context) {
@@ -26075,7 +26264,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const host = {
         groundAt: this.options.groundAt,
         gravity: this.options.gravity,
-        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag)
+        land: (owner, x, y, z, color2, tag) => this.listeners.get(owner)?.(x, y, z, color2, tag)
       };
       if (this.additive.live > 0 || this.additive.drawCount > 0) this.additive.update(dt, host);
       if (this.normal.live > 0 || this.normal.drawCount > 0) this.normal.update(dt, host);
@@ -26088,17 +26277,17 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var TWO_PI_ROUNDED = 6.2832;
   var WIDE_CONE = 3.1;
   var UP13 = [0, 1, 0];
-  function drawRange(random, range) {
-    if (Array.isArray(range)) return random.between(range[0], range[1]);
-    return range || 0;
+  function drawRange(random, range2) {
+    if (Array.isArray(range2)) return random.between(range2[0], range2[1]);
+    return range2 || 0;
   }
   function randomUnit(random, out) {
     const up = random.next() * 2 - 1;
     const angle = random.next() * TWO_PI_ROUNDED;
-    const ring2 = Math.sqrt(1 - up * up);
-    out.x = ring2 * Math.cos(angle);
+    const ring22 = Math.sqrt(1 - up * up);
+    out.x = ring22 * Math.cos(angle);
     out.y = up;
-    out.z = ring2 * Math.sin(angle);
+    out.z = ring22 * Math.sin(angle);
     return out;
   }
   var tangentA = { x: 0, y: 0, z: 0 };
@@ -26113,10 +26302,10 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     out.z = z;
     return out;
   }
-  function coneDirection(random, direction, cone, out) {
-    if (cone >= WIDE_CONE) return randomUnit(random, out);
+  function coneDirection(random, direction, cone2, out) {
+    if (cone2 >= WIDE_CONE) return randomUnit(random, out);
     const [dx, dy, dz] = direction ?? UP13;
-    const cosTilt = 1 - random.next() * (1 - Math.cos(cone));
+    const cosTilt = 1 - random.next() * (1 - Math.cos(cone2));
     const sinTilt = Math.sqrt(1 - cosTilt * cosTilt);
     const phase = random.next() * TWO_PI_ROUNDED;
     axis.x = dx;
@@ -26161,76 +26350,76 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     }
     spawn(options) {
       const random = this.context.random;
-      const piece = this.pieces[this.next++ % CAPACITY];
+      const piece2 = this.pieces[this.next++ % CAPACITY];
       coneDirection(random, options.dir, options.cone ?? 3.2, this.direction);
       const speed = drawRange(random, options.sp);
       const size = options.size ?? DEFAULT_SIZE;
       const scale = options.k ? drawRange(random, options.k) : 1;
-      const box2 = options.box;
+      const box3 = options.box;
       const spin = options.spin || DEFAULT_SPIN;
-      piece.on = true;
-      piece.x = options.p[0] + (box2 ? random.between(-box2[0], box2[0]) : 0);
-      piece.y = options.p[1] + (box2 ? random.between(-box2[1], box2[1]) : 0);
-      piece.z = options.p[2] + (box2 ? random.between(-box2[2], box2[2]) : 0);
-      piece.vx = this.direction.x * speed + (options.v ? options.v[0] : 0);
-      piece.vy = this.direction.y * speed + (options.v ? options.v[1] : 0);
-      piece.vz = this.direction.z * speed + (options.v ? options.v[2] : 0);
-      piece.sx = size[0] * scale;
-      piece.sy = size[1] * scale;
-      piece.sz = size[2] * scale;
-      piece.rx = random.between(0, FULL_TURN_DRAWN3);
-      piece.ry = random.between(0, FULL_TURN_DRAWN3);
-      piece.rz = random.between(0, FULL_TURN_DRAWN3);
-      piece.ax = random.between(-1, 1) * spin;
-      piece.ay = random.between(-1, 1) * spin;
-      piece.az = random.between(-1, 1) * spin;
-      piece.life = options.life || DEFAULT_LIFE;
-      piece.bounce = options.bounce ?? DEFAULT_BOUNCE;
-      piece.rest = false;
-      piece.color = options.c ?? DEFAULT_COLOR3;
+      piece2.on = true;
+      piece2.x = options.p[0] + (box3 ? random.between(-box3[0], box3[0]) : 0);
+      piece2.y = options.p[1] + (box3 ? random.between(-box3[1], box3[1]) : 0);
+      piece2.z = options.p[2] + (box3 ? random.between(-box3[2], box3[2]) : 0);
+      piece2.vx = this.direction.x * speed + (options.v ? options.v[0] : 0);
+      piece2.vy = this.direction.y * speed + (options.v ? options.v[1] : 0);
+      piece2.vz = this.direction.z * speed + (options.v ? options.v[2] : 0);
+      piece2.sx = size[0] * scale;
+      piece2.sy = size[1] * scale;
+      piece2.sz = size[2] * scale;
+      piece2.rx = random.between(0, FULL_TURN_DRAWN3);
+      piece2.ry = random.between(0, FULL_TURN_DRAWN3);
+      piece2.rz = random.between(0, FULL_TURN_DRAWN3);
+      piece2.ax = random.between(-1, 1) * spin;
+      piece2.ay = random.between(-1, 1) * spin;
+      piece2.az = random.between(-1, 1) * spin;
+      piece2.life = options.life || DEFAULT_LIFE;
+      piece2.bounce = options.bounce ?? DEFAULT_BOUNCE;
+      piece2.rest = false;
+      piece2.color = options.c ?? DEFAULT_COLOR3;
     }
     clear() {
-      for (const piece of this.pieces) piece.on = false;
+      for (const piece2 of this.pieces) piece2.on = false;
       this.count = 0;
     }
     update(dt) {
       this.count = 0;
-      for (const piece of this.pieces) {
-        if (!piece.on) continue;
+      for (const piece2 of this.pieces) {
+        if (!piece2.on) continue;
         this.count++;
-        piece.life -= dt;
-        if (piece.life <= 0) {
-          piece.on = false;
+        piece2.life -= dt;
+        if (piece2.life <= 0) {
+          piece2.on = false;
           continue;
         }
-        if (!piece.rest) this.move(piece, dt);
+        if (!piece2.rest) this.move(piece2, dt);
       }
     }
     /** Scale at the end of its life, 1 until the last half second (the renderer's `sh`). */
-    static fade(piece) {
-      return Math.min(1, piece.life / FADE_SECONDS);
-    }
-    move(piece, dt) {
-      piece.vy -= GRAVITY22 * dt;
-      piece.x += piece.vx * dt;
-      piece.y += piece.vy * dt;
-      piece.z += piece.vz * dt;
-      piece.rx += piece.ax * dt;
-      piece.ry += piece.ay * dt;
-      piece.rz += piece.az * dt;
-      const groundHeight = this.context.groundAt(piece.x, piece.z) + Math.min(piece.sx, piece.sy, piece.sz) * 0.5;
-      if (piece.y >= groundHeight) return;
-      piece.y = groundHeight;
-      piece.vy *= -piece.bounce;
-      piece.vx *= 0.55;
-      piece.vz *= 0.55;
-      piece.ax *= 0.5;
-      piece.ay *= 0.5;
-      piece.az *= 0.5;
-      if (Math.abs(piece.vy) < 0.5 && Math.hypot(piece.vx, piece.vz) < 0.3) {
-        piece.rest = true;
-        piece.rx = Math.round(piece.rx / QUARTER_TURN4) * QUARTER_TURN4;
-        piece.rz = Math.round(piece.rz / QUARTER_TURN4) * QUARTER_TURN4;
+    static fade(piece2) {
+      return Math.min(1, piece2.life / FADE_SECONDS);
+    }
+    move(piece2, dt) {
+      piece2.vy -= GRAVITY22 * dt;
+      piece2.x += piece2.vx * dt;
+      piece2.y += piece2.vy * dt;
+      piece2.z += piece2.vz * dt;
+      piece2.rx += piece2.ax * dt;
+      piece2.ry += piece2.ay * dt;
+      piece2.rz += piece2.az * dt;
+      const groundHeight = this.context.groundAt(piece2.x, piece2.z) + Math.min(piece2.sx, piece2.sy, piece2.sz) * 0.5;
+      if (piece2.y >= groundHeight) return;
+      piece2.y = groundHeight;
+      piece2.vy *= -piece2.bounce;
+      piece2.vx *= 0.55;
+      piece2.vz *= 0.55;
+      piece2.ax *= 0.5;
+      piece2.ay *= 0.5;
+      piece2.az *= 0.5;
+      if (Math.abs(piece2.vy) < 0.5 && Math.hypot(piece2.vx, piece2.vz) < 0.3) {
+        piece2.rest = true;
+        piece2.rx = Math.round(piece2.rx / QUARTER_TURN4) * QUARTER_TURN4;
+        piece2.rz = Math.round(piece2.rz / QUARTER_TURN4) * QUARTER_TURN4;
       }
     }
   };
@@ -26249,7 +26438,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       __publicField2(this, "count", 0);
       __publicField2(this, "next", 0);
     }
-    add(x, y, z, size, color, options = {}) {
+    add(x, y, z, size, color2, options = {}) {
       const random = this.context.random;
       const index = this.next++ % CAPACITY2;
       const decal2 = this.decals[index];
@@ -26265,7 +26454,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       decal2.t = -(options.delay || 0);
       decal2.grow = options.grow ?? DEFAULT_GROW;
       decal2.life = options.life || DEFAULT_LIFE2;
-      decal2.color = color;
+      decal2.color = color2;
       decal2.normal = normal;
       const fluid = options.fluid ?? (options.dark ? "blood" : void 0);
       decal2.fluid = fluid;
@@ -26296,7 +26485,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   };
   var CAPACITY3 = 400;
   var IDENTITY = [0, 0, 0, 1];
-  function multiply(a, b) {
+  function multiply2(a, b) {
     const [ax, ay, az, aw] = a;
     const [bx, by, bz, bw] = b;
     return [aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw, aw * bw - ax * bx - ay * by - az * bz];
@@ -26327,7 +26516,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         x: options.p[0],
         y: options.p[1],
         z: options.p[2],
-        frame: options.roll ? multiply(frame, aboutX(options.roll)) : frame,
+        frame: options.roll ? multiply2(frame, aboutX(options.roll)) : frame,
         at: options.at ?? [0, 0, 0],
         rx: options.rot?.[0] ?? 0,
         ry: options.rot?.[1] ?? 0,
@@ -26679,29 +26868,29 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       __publicField2(this, "count", 0);
       __publicField2(this, "next", 0);
     }
-    add(point, from, to, duration, color, normal, hold) {
-      const ring2 = this.rings[this.next++ % RING_CAPACITY];
-      ring2.on = true;
-      ring2.point = [point[0], point[1], point[2]];
-      ring2.from = from;
-      ring2.to = to;
-      ring2.t = 0;
-      ring2.duration = duration;
-      ring2.color = color;
-      ring2.normal = normal ?? UP15;
-      ring2.hold = hold || 0;
+    add(point, from, to, duration, color2, normal, hold) {
+      const ring22 = this.rings[this.next++ % RING_CAPACITY];
+      ring22.on = true;
+      ring22.point = [point[0], point[1], point[2]];
+      ring22.from = from;
+      ring22.to = to;
+      ring22.t = 0;
+      ring22.duration = duration;
+      ring22.color = color2;
+      ring22.normal = normal ?? UP15;
+      ring22.hold = hold || 0;
     }
     clear() {
-      for (const ring2 of this.rings) ring2.on = false;
+      for (const ring22 of this.rings) ring22.on = false;
       this.count = 0;
     }
     update(dt) {
       this.count = 0;
-      for (const ring2 of this.rings) {
-        if (!ring2.on) continue;
+      for (const ring22 of this.rings) {
+        if (!ring22.on) continue;
         this.count++;
-        ring2.t += dt;
-        if (ring2.t / ring2.duration >= 1 && !ring2.hold) ring2.on = false;
+        ring22.t += dt;
+        if (ring22.t / ring22.duration >= 1 && !ring22.hold) ring22.on = false;
       }
     }
   };
@@ -26718,7 +26907,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     get lit() {
       return this.lights.filter((light) => light.intensity > 0).length;
     }
-    flash(point, color, intensity, duration, distance2, force, steady) {
+    flash(point, color2, intensity, duration, distance2, force, steady) {
       const { level } = this.context.quality;
       if (level >= 1 && !force) return;
       if (level >= 2 && force !== "boom") return;
@@ -26726,7 +26915,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       light.x = point[0];
       light.y = point[1];
       light.z = point[2];
-      light.color = color;
+      light.color = color2;
       light.distance = distance2 || DEFAULT_LIGHT_DISTANCE;
       light.peak = intensity;
       light.duration = duration;
@@ -26893,13 +27082,13 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       light.z = point[2];
       light.intensity = intensity * (0.75 + FIRE_FLICKER_SWAY * Math.sin(time * 23) * Math.sin(time * 7.3) + this.random.between(-FIRE_FLICKER_JITTER, FIRE_FLICKER_JITTER));
     }
-    lensBlob(x, y, radius, color, alpha) {
-      this.lens.push({ x, y, radius, color, alpha, fall: this.random.between(2, 8) });
+    lensBlob(x, y, radius, color2, alpha) {
+      this.lens.push({ x, y, radius, color: color2, alpha, fall: this.random.between(2, 8) });
     }
     /** The order of the page's loop (W1285-1287): the sprites, streaks, debris, decals, rings and lights, then the screen and its lens. */
     update(dt) {
-      const leaveDecal = (x, y, z, size, color, options) => {
-        this.decal([x, y, z, size, color, options]);
+      const leaveDecal = (x, y, z, size, color2, options) => {
+        this.decal([x, y, z, size, color2, options]);
       };
       this.add.update(dt, leaveDecal);
       this.normal.update(dt, leaveDecal);
@@ -27013,7 +27202,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     function streamOf(seed) {
       if (randomMode === "shared") return sharedRandom;
       handles.events++;
-      return streamFor2(seed ?? Math.imul(handles.events, AUTO_SEED) + (options.seed ?? 0));
+      return streamFor3(seed ?? Math.imul(handles.events, AUTO_SEED) + (options.seed ?? 0));
     }
     function detonate(def, point, call3) {
       composeExplosion(core, def, { x: point[0], y: point[1], z: point[2], direction: call3.direction, random: call3.random, handle: call3.handle });
@@ -27367,8 +27556,8 @@ void main(){
     geometry.setAttribute("position", new THREE.Float32BufferAttribute([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0], 3));
     geometry.setIndex([0, 1, 2, 0, 2, 3]);
     const where = new Float32Array(capacity * 4);
-    const color = new Float32Array(capacity * 4);
-    const attributes = [dynamic(THREE, where, 4), dynamic(THREE, color, 4)];
+    const color2 = new Float32Array(capacity * 4);
+    const attributes = [dynamic(THREE, where, 4), dynamic(THREE, color2, 4)];
     geometry.setAttribute("aP", attributes[0]);
     geometry.setAttribute("aC", attributes[1]);
     geometry.instanceCount = 0;
@@ -27386,10 +27575,10 @@ void main(){
           where[n * 4 + 1] = g.outY;
           where[n * 4 + 2] = g.outZ;
           where[n * 4 + 3] = g.outSize;
-          color[n * 4] = g.color[0];
-          color[n * 4 + 1] = g.color[1];
-          color[n * 4 + 2] = g.color[2];
-          color[n * 4 + 3] = g.outIntensity;
+          color2[n * 4] = g.color[0];
+          color2[n * 4 + 1] = g.color[1];
+          color2[n * 4 + 2] = g.color[2];
+          color2[n * 4 + 3] = g.outIntensity;
           n++;
         }
         geometry.instanceCount = n;
@@ -27436,11 +27625,11 @@ void main(){
           const mesh2 = chunk.plate ? plates : rocks;
           const index = chunk.plate ? plateCount++ : rockCount++;
           mesh2.setMatrixAt(index, matrix);
-          const color = colorOf(chunk);
+          const color2 = colorOf(chunk);
           const colors = mesh2.instanceColor.array;
-          colors[index * 3] = color[0];
-          colors[index * 3 + 1] = color[1];
-          colors[index * 3 + 2] = color[2];
+          colors[index * 3] = color2[0];
+          colors[index * 3 + 1] = color2[1];
+          colors[index * 3 + 2] = color2[2];
         }
         rocks.count = rockCount;
         plates.count = plateCount;
@@ -27606,11 +27795,11 @@ void main(){
     const rockMaterials = /* @__PURE__ */ new Map();
     const blood = [];
     let meshCount = 0;
-    function rockMaterial(color) {
-      let material = rockMaterials.get(color);
+    function rockMaterial(color2) {
+      let material = rockMaterials.get(color2);
       if (!material) {
-        material = new THREE.MeshStandardMaterial({ color, roughness: 0.9, metalness: 0, flatShading: true });
-        rockMaterials.set(color, material);
+        material = new THREE.MeshStandardMaterial({ color: color2, roughness: 0.9, metalness: 0, flatShading: true });
+        rockMaterials.set(color2, material);
         owned.push(material);
       }
       return material;
@@ -27758,10 +27947,10 @@ void main(){
       });
       const shell = new THREE.Mesh(shellGeometry, shellMaterial);
       shell.renderOrder = 4;
-      const ring2 = new THREE.Mesh(ringGeometry, ringMaterial);
-      ring2.renderOrder = 3;
-      group.add(shell, ring2);
-      return { shell, ring: ring2, shellAlpha, ringAlpha };
+      const ring3 = new THREE.Mesh(ringGeometry, ringMaterial);
+      ring3.renderOrder = 3;
+      group.add(shell, ring3);
+      return { shell, ring: ring3, shellAlpha, ringAlpha };
     }
     return {
       group,
@@ -27982,9 +28171,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   function streakLayer(THREE, pool) {
     const geometry = new THREE.BufferGeometry();
     const position = new THREE.BufferAttribute(pool.segment, 3).setUsage(THREE.DynamicDrawUsage);
-    const color = new THREE.BufferAttribute(pool.segmentColor, 3).setUsage(THREE.DynamicDrawUsage);
+    const color2 = new THREE.BufferAttribute(pool.segmentColor, 3).setUsage(THREE.DynamicDrawUsage);
     geometry.setAttribute("position", position);
-    geometry.setAttribute("color", color);
+    geometry.setAttribute("color", color2);
     geometry.setDrawRange(0, 0);
     const material = new THREE.LineBasicMaterial({ vertexColors: true, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false });
     const lines = new THREE.LineSegments(geometry, material);
@@ -27995,7 +28184,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       object: lines,
       sync() {
         geometry.setDrawRange(0, pool.count * 2);
-        position.needsUpdate = color.needsUpdate = true;
+        position.needsUpdate = color2.needsUpdate = true;
         return pool.count > 0;
       },
       dispose() {
@@ -28049,18 +28238,18 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sync() {
         let drawn = false;
         for (let index = 0; index < DEBRIS_CAPACITY; index++) {
-          const piece = pool.pieces[index];
-          if (!piece.on) {
+          const piece2 = pool.pieces[index];
+          if (!piece2.on) {
             mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
-          const shrink = Math.min(1, piece.life / FADE_SECONDS2);
-          euler.set(piece.rx, piece.ry, piece.rz);
+          const shrink = Math.min(1, piece2.life / FADE_SECONDS2);
+          euler.set(piece2.rx, piece2.ry, piece2.rz);
           quaternion2.setFromEuler(euler);
-          matrix.compose(position.set(piece.x, piece.y, piece.z), quaternion2, scale.set(piece.sx * shrink, piece.sy * shrink, piece.sz * shrink));
+          matrix.compose(position.set(piece2.x, piece2.y, piece2.z), quaternion2, scale.set(piece2.sx * shrink, piece2.sy * shrink, piece2.sz * shrink));
           mesh2.setMatrixAt(index, matrix);
-          mesh2.setColorAt(index, colour.setHex(piece.color));
+          mesh2.setColorAt(index, colour.setHex(piece2.color));
         }
         mesh2.instanceMatrix.needsUpdate = true;
         if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
@@ -28200,18 +28389,18 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sync() {
         let drawn = false;
         for (let index = 0; index < RING_CAPACITY3; index++) {
-          const ring2 = pool.rings[index];
-          if (!ring2.on) {
+          const ring3 = pool.rings[index];
+          if (!ring3.on) {
             mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
-          const k = Math.min(1, ring2.t / ring2.duration);
-          const radius = ring2.from + (ring2.to - ring2.from) * (1 - Math.pow(1 - k, 2));
-          quaternion2.setFromUnitVectors(forward, normal.set(ring2.normal[0], ring2.normal[1], ring2.normal[2]));
-          matrix.compose(position.set(ring2.point[0], ring2.point[1], ring2.point[2]), quaternion2, scale.set(radius, radius, 1));
+          const k = Math.min(1, ring3.t / ring3.duration);
+          const radius = ring3.from + (ring3.to - ring3.from) * (1 - Math.pow(1 - k, 2));
+          quaternion2.setFromUnitVectors(forward, normal.set(ring3.normal[0], ring3.normal[1], ring3.normal[2]));
+          matrix.compose(position.set(ring3.point[0], ring3.point[1], ring3.point[2]), quaternion2, scale.set(radius, radius, 1));
           mesh2.setMatrixAt(index, matrix);
-          mesh2.setColorAt(index, colour.setHex(ring2.color).multiplyScalar(ring2.hold ? ring2.hold : 1 - k));
+          mesh2.setColorAt(index, colour.setHex(ring3.color).multiplyScalar(ring3.hold ? ring3.hold : 1 - k));
         }
         mesh2.instanceMatrix.needsUpdate = true;
         if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
@@ -28333,7 +28522,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sprites: [sprites.additive, sprites.normal, ...workshopLayers ? [workshopLayers.group] : []]
     });
     const applyLayers = () => {
-      for (const [id, objects] of Object.entries(layerObjects())) for (const object of objects) object.visible = layerOn.get(id) !== false;
+      for (const [id, objects] of Object.entries(layerObjects())) for (const object2 of objects) object2.visible = layerOn.get(id) !== false;
     };
     const screenNow = () => mergeScreens(world.screen(), world.peekWorkshop()?.screen);
     let clock = 0;
@@ -28557,25 +28746,25 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   // src/fx/particles.ts
   var MAX_PARTICLES = 900;
   var FLOOR_FRICTION = 0.45;
-  var disposeOwned = (object) => {
-    object.traverse((child) => {
+  var disposeOwned = (object2) => {
+    object2.traverse((child) => {
       const mesh2 = child;
       if (mesh2.isMesh) mesh2.geometry.dispose();
     });
   };
   function createParticles(THREE, scene, groundAt) {
-    let list = [];
+    let list2 = [];
     const remove = (particle) => {
       particle.object.removeFromParent();
       if (particle.ownsGeometry) disposeOwned(particle.object);
       if (particle.fadeFrom !== void 0) particle.object.material.dispose();
-      list = list.filter((other) => other !== particle);
+      list2 = list2.filter((other) => other !== particle);
     };
     const api = {
-      spawn(object, velocity, options = {}) {
-        scene.add(object);
-        list.push({
-          object,
+      spawn(object2, velocity, options = {}) {
+        scene.add(object2);
+        list2.push({
+          object: object2,
           velocity,
           spin: options.spin ?? new THREE.Vector3(),
           age: 0,
@@ -28593,35 +28782,35 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           ownsGeometry: options.ownsGeometry ?? false,
           bounces: 0
         });
-        const oldest = list[0];
-        if (list.length > MAX_PARTICLES && oldest) remove(oldest);
+        const oldest = list2[0];
+        if (list2.length > MAX_PARTICLES && oldest) remove(oldest);
       },
       update(dt) {
-        for (const particle of [...list]) {
+        for (const particle of [...list2]) {
           particle.age += dt;
           if (particle.age > particle.life) {
             remove(particle);
             continue;
           }
-          const { object } = particle;
-          if (particle.fadeFrom !== void 0) object.material.opacity = Math.max(0, particle.fadeFrom * (1 - particle.age / particle.life));
+          const { object: object2 } = particle;
+          if (particle.fadeFrom !== void 0) object2.material.opacity = Math.max(0, particle.fadeFrom * (1 - particle.age / particle.life));
           if (particle.resting) continue;
           particle.velocity.y -= particle.gravity * dt;
           if (particle.drag) particle.velocity.multiplyScalar(Math.max(0, 1 - particle.drag * dt));
-          object.position.addScaledVector(particle.velocity, dt);
-          object.rotation.x += particle.spin.x * dt;
-          object.rotation.y += particle.spin.y * dt;
-          object.rotation.z += particle.spin.z * dt;
-          if (particle.grow) object.scale.multiplyScalar(1 + particle.grow * dt);
+          object2.position.addScaledVector(particle.velocity, dt);
+          object2.rotation.x += particle.spin.x * dt;
+          object2.rotation.y += particle.spin.y * dt;
+          object2.rotation.z += particle.spin.z * dt;
+          if (particle.grow) object2.scale.multiplyScalar(1 + particle.grow * dt);
           if (particle.radius < 0) continue;
-          const floor2 = groundAt(object.position.x, object.position.z) + particle.radius;
-          if (object.position.y >= floor2 || particle.velocity.y >= 0) continue;
+          const floor2 = groundAt(object2.position.x, object2.position.z) + particle.radius;
+          if (object2.position.y >= floor2 || particle.velocity.y >= 0) continue;
           if (particle.onGround) {
-            particle.onGround(object.position.clone());
+            particle.onGround(object2.position.clone());
             remove(particle);
             continue;
           }
-          object.position.y = floor2;
+          object2.position.y = floor2;
           particle.velocity.y *= -particle.bounce;
           particle.velocity.x *= FLOOR_FRICTION;
           particle.velocity.z *= FLOOR_FRICTION;
@@ -28629,13 +28818,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           if (particle.bounces++ < 4 && Math.abs(particle.velocity.y) >= 0.18) api.onBounce?.(particle.kind);
           if (Math.abs(particle.velocity.y) < 0.18) {
             particle.resting = true;
-            particle.onRest?.(object);
+            particle.onRest?.(object2);
           }
         }
       },
-      count: (kind) => list.filter((particle) => particle.kind === kind).length,
+      count: (kind) => list2.filter((particle) => particle.kind === kind).length,
       dispose() {
-        for (const particle of [...list]) remove(particle);
+        for (const particle of [...list2]) remove(particle);
       }
     };
     return api;
@@ -28646,13 +28835,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const registry = partRegistry(model.parts);
     const rest = /* @__PURE__ */ new Map();
     for (const part of [...registry.values(), model.root]) rest.set(part, { position: part.position.clone(), rotation: part.rotation.clone() });
-    const apply = (object, pose) => {
-      const base = rest.get(object);
+    const apply = (object2, pose) => {
+      const base = rest.get(object2);
       if (!base) return;
       const [dx, dy, dz] = pose.position ?? [0, 0, 0];
       const [rx, ry, rz] = pose.rotation ?? [0, 0, 0];
-      object.position.set(base.position.x + dx, base.position.y + dy, base.position.z + dz);
-      object.rotation.set(base.rotation.x + rx, base.rotation.y + ry, base.rotation.z + rz);
+      object2.position.set(base.position.x + dx, base.position.y + dy, base.position.z + dz);
+      object2.rotation.set(base.rotation.x + rx, base.rotation.y + ry, base.rotation.z + rz);
     };
     return {
       setPartPose(partId, pose) {
@@ -28677,9 +28866,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   // src/fx/viewmodel-events.ts
   var PI14 = Math.PI;
   var UGL_FLASH = 1.6;
-  var restFlat = (object) => {
-    object.rotation.x = 0;
-    object.rotation.z = 0;
+  var restFlat = (object2) => {
+    object2.rotation.x = 0;
+    object2.rotation.z = 0;
   };
   function createClipEventHandler(world, session) {
     const { kit, particles, effects, random } = world;
@@ -28749,7 +28938,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       root.updateWorldMatrix(true, true);
       const copy = parts.mag.clone(true);
       parts.mag.matrixWorld.decompose(copy.position, copy.quaternion, copy.scale);
-      particles.spawn(copy, toWorld(session, vector(up ? -0.25 : 0.05, up ? 0.9 : -0.3, 0.18)), { kind: "magazine", life: 25, radius: 0.014, bounce: 0.15, spin: vector(1.5, 0.5, 2.5), onRest: (object) => object.rotation.set(0, object.rotation.y, PI14 / 2) });
+      particles.spawn(copy, toWorld(session, vector(up ? -0.25 : 0.05, up ? 0.9 : -0.3, 0.18)), { kind: "magazine", life: 25, radius: 0.014, bounce: 0.15, spin: vector(1.5, 0.5, 2.5), onRest: (object2) => object2.rotation.set(0, object2.rotation.y, PI14 / 2) });
     };
     const stuckCase = () => {
       if (!session.cartridge || !parts.eject) return;
@@ -29064,7 +29253,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   // src/fx.ts
   function createWeaponFx(options) {
     const layers = options.layers ?? createLayers();
-    const box2 = createBoxFx({ ...options, layers });
+    const box3 = createBoxFx({ ...options, layers });
     const model = createViewmodel({
       layers,
       ...options.soundDistance ? { soundDistance: options.soundDistance } : {},
@@ -29085,29 +29274,29 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       handle(event, tool) {
         if (event.type === "explosion") return;
         if (event.type === "tool") {
-          if (hasWeaponModel(event.weapon)) box2.unequip();
+          if (hasWeaponModel(event.weapon)) box3.unequip();
           else model.unequip();
         }
         if (model.inHand !== null || event.type === "tool" && hasWeaponModel(event.weapon)) model.handle(event, tool);
-        else box2.handle(event, tool);
+        else box3.handle(event, tool);
       },
       update(dt) {
-        box2.update(dt);
+        box3.update(dt);
         model.update(dt);
       },
       setCondition: (condition) => model.setCondition(condition),
       layers,
       get inHand() {
-        return model.inHand ?? box2.inHand;
+        return model.inHand ?? box3.inHand;
       },
       get casings() {
-        return box2.casings + model.casings;
+        return box3.casings + model.casings;
       },
       get magazines() {
-        return box2.magazines + model.magazines;
+        return box3.magazines + model.magazines;
       },
       dispose() {
-        box2.dispose();
+        box3.dispose();
         model.dispose();
       }
     };
@@ -30033,7 +30222,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       target_plywood: ["plywood", [0.6, 0.8, 0.018], 13214315],
       target_concrete: ["concrete", [0.4, 0.2, 0.2], 10132116]
     };
-    const [material, size, color] = face[id];
+    const [material, size, color2] = face[id];
     const spec = {
       name,
       parts: [
@@ -30043,7 +30232,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       joints: [{ a: "post", b: "face", kind: "bolt" }],
       tags: ["target"]
     };
-    return { spec, colors: { post: 3816770, face: color } };
+    return { spec, colors: { post: 3816770, face: color2 } };
   };
   var weaponItem = (def, name) => {
     const id = `${WEAPON_ITEM_PREFIX}${def.id}`;