@adatechnology/game-weapons-three 0.1.1 → 0.2.0

package/dist/index.js

@@ -2,90 +2,296 @@
 import { createArsenal } from "@adatechnology/game-weapons";
 
 // src/audio.ts
-var NOISE_SECONDS = 0.6;
-function createWeaponAudio(volume = 0.6) {
-  const Ctor = globalThis.AudioContext ?? globalThis.webkitAudioContext;
+import { createRng } from "@adatechnology/game-weapons";
+
+// src/audio/mechanical-sounds.ts
+var metal = (at, frequency, gain) => ({ layer: "metal", at, frequency, gain });
+var sound = (at, soundClass, volume) => ({ layer: "class", at, soundClass, volume });
+var thud = (at, gain, frequency) => ({ layer: "thud", at, gain, frequency });
+var slide = [metal(0, 900, 0.35), metal(0.14, 1300, 0.35)];
+var seat = [metal(0, 1100, 0.45), sound(0, "reload", 0.8)];
+var MECHANICAL_SOUNDS = {
+  dry_fire: [sound(0, "empty", 1), metal(0, 2600, 0.25)],
+  misfire: [sound(0, "empty", 0.8), metal(0, 2200, 0.2)],
+  feed: [metal(0, 1900, 0.2)],
+  cycle: [metal(0.22, 900, 0.35), metal(0.36, 1300, 0.35)],
+  mode: [metal(0, 2e3, 0.15)],
+  safety_on: [metal(0, 2200, 0.22)],
+  safety_off: [metal(0, 1800, 0.22)],
+  jam: [metal(0, 700, 0.4), metal(0.08, 500, 0.35)],
+  clear_start: [metal(0, 1e3, 0.3)],
+  clear_end: [metal(0, 1300, 0.35)],
+  magazine_out: [metal(0, 1500, 0.35), sound(0, "reload", 0.6)],
+  magazine_in: seat,
+  charge: slide,
+  bolt_open: [metal(0, 900, 0.35)],
+  round_in: [metal(0, 2e3, 0.2), sound(0, "reload", 0.6)],
+  bolt_close: [metal(0, 1300, 0.35)],
+  pump_cycle: slide,
+  lever_cycle: [metal(0, 1e3, 0.35), metal(0.12, 1500, 0.35)],
+  cylinder_open: [metal(0, 1500, 0.3)],
+  cylinder_eject: [metal(0, 2400, 0.25), metal(0.05, 2800, 0.2)],
+  cylinder_load: [metal(0, 2e3, 0.2)],
+  cylinder_close: seat,
+  barrels_open: [metal(0, 1e3, 0.4)],
+  casings_eject: [metal(0, 2600, 0.25)],
+  rounds_in: [metal(0, 2e3, 0.25), sound(0, "reload", 0.6)],
+  barrels_close: seat,
+  cover_open: [metal(0, 800, 0.4)],
+  belt_swap: [metal(0, 1400, 0.3), metal(0.08, 1800, 0.25)],
+  cover_close: [metal(0, 1e3, 0.45)],
+  tank_swap: [thud(0, 0.4, 500), metal(0.05, 600, 0.3)],
+  tube_drop: [thud(0, 0.35, 380)],
+  tube_seat: seat,
+  rocket_seat: [metal(0, 900, 0.45), sound(0, "reload", 0.8)],
+  breech_open: [metal(0, 1e3, 0.35)],
+  breech_close: seat
+};
+var mechanicalSoundOf = (event) => {
+  switch (event.type) {
+    case "reload_stage":
+      return event.stage;
+    case "empty":
+      return "dry_fire";
+    case "misfire":
+      return "misfire";
+    case "feed":
+      return "feed";
+    case "cycle":
+      return event.phase === "start" ? "cycle" : void 0;
+    case "mode":
+      return "mode";
+    case "safety":
+      return event.on ? "safety_on" : "safety_off";
+    case "fault":
+      return "jam";
+    case "clear":
+      return event.phase === "start" ? "clear_start" : "clear_end";
+    default:
+      return void 0;
+  }
+};
+
+// src/audio/shot-sound.ts
+import { muzzleEnergy } from "@adatechnology/game-weapons";
+var GAME_SOUND_CLASSES = {
+  pistol: [1800, 0.9, 0.18],
+  shotgun: [900, 1.2, 0.35],
+  rifle: [1400, 1.1, 0.28],
+  long_rifle: [1100, 1.3, 0.45],
+  impact: [2500, 0.25, 0.05],
+  flesh: [600, 0.35, 0.08],
+  step: [400, 0.08, 0.05],
+  glass: [5e3, 0.5, 0.3],
+  wood: [700, 0.5, 0.2],
+  reload: [3e3, 0.15, 0.06],
+  empty: [4e3, 0.12, 0.03],
+  explosion: [200, 1.6, 1.4]
+};
+var FALLBACK_SOUND_CLASS = [1e3, 0.5, 0.1];
+var GAME_DISTANCE_CURVE = { gainFalloff: 4e-3, cutoffFalloff: 0.01, minGain: 0.01 };
+var DEFAULT_ENERGY_CURVE = {
+  floorJ: 50,
+  spanDecades: 2.5,
+  gain: [0.7, 0.6],
+  duration: [0.75, 0.5],
+  cutoff: [1.15, -0.3],
+  crackGain: [0.3, 0.4],
+  bodyGain: [0.35, 0.4],
+  bodyDuration: [0.14, 0.2],
+  bodyFrequency: [140, -70]
+};
+var CLASS_REFERENCE_ENERGY = { pistol: 500, shotgun: 2700, rifle: 2100, long_rifle: 3500 };
+var HANDGUN_CATEGORIES = /* @__PURE__ */ new Set(["pistol", "revolver", "smg"]);
+var SHELL_KINDS = /* @__PURE__ */ new Set(["buck", "slug", "birdshot"]);
+var DEFAULT_BANDS = { handgunBelowJ: 1e3, rifleBelowJ: 3e3 };
+var DEFAULT_SUPPRESSOR = { gain: 0.3, cutoff: 0.6, crack: 0, body: 0.5 };
+var DEFAULT_INDOORS = { duration: 1.5, cutoff: 0.85 };
+var CRACK_CUTOFF = 3e3;
+var CRACK_SECONDS = 0.03;
+var BODY_TO_FREQUENCY = 40;
+var linear = ([base, span], k) => base + span * k;
+var energyPosition = (energyJ, curve) => Math.min(1, Math.max(0, Math.log10(Math.max(energyJ, curve.floorJ) / curve.floorJ) / curve.spanDecades));
+var energyOfShot = (input) => {
+  if (input.energyJ !== void 0) return input.energyJ;
+  if (!input.caliber) return 0;
+  return muzzleEnergy(input.caliber) * (input.caliber.pellets ?? 1);
+};
+var defaultClassOf = (input, energyJ, bands) => {
+  if (input.category === "shotgun" || (input.caliber?.pellets ?? 1) > 1 || SHELL_KINDS.has(input.caliber?.kind ?? "")) return "shotgun";
+  if (input.category && HANDGUN_CATEGORIES.has(input.category)) return "pistol";
+  if (energyJ < bands.handgunBelowJ) return "pistol";
+  return energyJ < bands.rifleBelowJ ? "rifle" : "long_rifle";
+};
+var computeShotSound = (input, options = {}) => {
+  const curve = { ...DEFAULT_ENERGY_CURVE, ...options.energy };
+  const distanceCurve = { ...GAME_DISTANCE_CURVE, ...options.distance };
+  const energyJ = energyOfShot(input);
+  const soundClass = options.classOf ? options.classOf(input, energyJ) : defaultClassOf(input, energyJ, options.bands ?? DEFAULT_BANDS);
+  const table = { ...GAME_SOUND_CLASSES, ...options.classes };
+  const [classCutoff, classGain, classSeconds] = table[soundClass] ?? FALLBACK_SOUND_CLASS;
+  const referenceEnergy = options.referenceEnergy?.[soundClass] ?? CLASS_REFERENCE_ENERGY[soundClass] ?? energyJ;
+  const k = energyPosition(energyJ, curve);
+  const referenceK = energyPosition(referenceEnergy, curve);
+  const distance = Math.max(0, input.distance ?? 0);
+  const attenuation = (input.volume ?? 1) / (1 + distance * distance * distanceCurve.gainFalloff);
+  const muffling = 1 / (1 + distance * distanceCurve.cutoffFalloff);
+  const suppressor = input.suppressed ? { ...DEFAULT_SUPPRESSOR, ...options.suppressor } : { gain: 1, cutoff: 1, crack: 1, body: 1 };
+  const indoors = input.indoors ? { ...DEFAULT_INDOORS, ...options.indoors } : { duration: 1, cutoff: 1 };
+  const gain = classGain * attenuation * (linear(curve.gain, k) / linear(curve.gain, referenceK)) * suppressor.gain;
+  const duration = classSeconds * (linear(curve.duration, k) / linear(curve.duration, referenceK)) * indoors.duration;
+  const cutoff = classCutoff * muffling * (linear(curve.cutoff, k) / linear(curve.cutoff, referenceK)) * suppressor.cutoff * indoors.cutoff;
+  return {
+    soundClass,
+    energyJ,
+    audible: attenuation >= distanceCurve.minGain,
+    cutoff,
+    gain,
+    duration,
+    crack: { gain: linear(curve.crackGain, k) * attenuation * suppressor.crack, cutoff: CRACK_CUTOFF, duration: CRACK_SECONDS },
+    body: {
+      gain: linear(curve.bodyGain, k) * attenuation * suppressor.body,
+      frequency: linear(curve.bodyFrequency, k),
+      to: BODY_TO_FREQUENCY,
+      duration: linear(curve.bodyDuration, k) * indoors.duration
+    }
+  };
+};
+
+// src/audio.ts
+var NOISE_SECONDS = 1.5;
+var globalContext = () => {
+  const scope2 = globalThis;
+  const Ctor = scope2.AudioContext ?? scope2.webkitAudioContext;
+  return Ctor ? new Ctor() : null;
+};
+function createWeaponAudio(volume = 0.6, options = {}) {
+  const makeContext = options.createContext ?? globalContext;
+  const rng = createRng(options.seed ?? 1);
+  const classes = { ...GAME_SOUND_CLASSES, ...options.classes };
+  const distanceCurve = { ...GAME_DISTANCE_CURVE, ...options.distance };
+  const mechanicalTable = { ...MECHANICAL_SOUNDS, ...options.mechanical };
   let ctx = null;
   let master = null;
   let noise = null;
   let level = volume;
   const ready = () => {
-    if (!Ctor) return null;
     if (!ctx) {
-      ctx = new Ctor();
+      const created = makeContext();
+      if (!created) return null;
+      ctx = created;
       master = ctx.createGain();
       master.gain.value = level;
       master.connect(ctx.destination);
       noise = ctx.createBuffer(1, Math.floor(ctx.sampleRate * NOISE_SECONDS), ctx.sampleRate);
       const data = noise.getChannelData(0);
-      for (let i = 0; i < data.length; i++) data[i] = Math.random() * 2 - 1;
+      for (let i = 0; i < data.length; i++) data[i] = rng() * 2 - 1;
     }
     if (ctx.state === "suspended") void ctx.resume();
     return ctx;
   };
-  const burst = (options) => {
+  const burst = (config) => {
     const audio = ready();
     if (!audio || !noise || !master) return;
-    const start = audio.currentTime + (options.at ?? 0);
+    const start = audio.currentTime + (config.at ?? 0);
     const source = audio.createBufferSource();
     source.buffer = noise;
     const filter = audio.createBiquadFilter();
-    filter.type = options.filter;
-    filter.frequency.value = options.frequency;
-    filter.Q.value = options.q ?? 0.8;
+    filter.type = config.filter;
+    filter.frequency.value = config.frequency;
+    filter.Q.value = config.q ?? 0.8;
     const gain = audio.createGain();
     gain.gain.setValueAtTime(1e-4, start);
-    gain.gain.exponentialRampToValueAtTime(options.gain, start + 4e-3);
-    gain.gain.exponentialRampToValueAtTime(1e-4, start + options.seconds);
+    gain.gain.exponentialRampToValueAtTime(Math.max(config.gain, 2e-4), start + 4e-3);
+    gain.gain.exponentialRampToValueAtTime(1e-4, start + config.seconds);
     source.connect(filter).connect(gain).connect(master);
-    source.start(start);
-    source.stop(start + options.seconds + 0.05);
+    source.start(start, rng() * Math.max(0, NOISE_SECONDS - config.seconds));
+    source.stop(start + config.seconds + 0.05);
   };
-  const tone = (options) => {
+  const classBurst = (at, cutoff, gain, seconds) => {
+    const audio = ready();
+    if (!audio || !noise || !master) return;
+    const start = audio.currentTime + at;
+    const source = audio.createBufferSource();
+    source.buffer = noise;
+    const filter = audio.createBiquadFilter();
+    filter.type = "lowpass";
+    filter.frequency.value = cutoff;
+    const envelope = audio.createGain();
+    envelope.gain.setValueAtTime(gain, start);
+    envelope.gain.exponentialRampToValueAtTime(1e-3, start + seconds);
+    source.connect(filter).connect(envelope).connect(master);
+    source.start(start, rng() * Math.max(0, NOISE_SECONDS - seconds));
+    source.stop(start + seconds + 0.05);
+  };
+  const tone = (config) => {
     const audio = ready();
     if (!audio || !master) return;
-    const start = audio.currentTime + (options.at ?? 0);
+    const start = audio.currentTime + (config.at ?? 0);
     const osc = audio.createOscillator();
-    osc.type = options.type ?? "sine";
-    osc.frequency.setValueAtTime(options.frequency, start);
-    if (options.to) osc.frequency.exponentialRampToValueAtTime(options.to, start + options.seconds);
+    osc.type = config.type ?? "sine";
+    osc.frequency.setValueAtTime(config.frequency, start);
+    if (config.to) osc.frequency.exponentialRampToValueAtTime(config.to, start + config.seconds);
     const gain = audio.createGain();
     gain.gain.setValueAtTime(1e-4, start);
-    gain.gain.exponentialRampToValueAtTime(options.gain, start + 3e-3);
-    gain.gain.exponentialRampToValueAtTime(1e-4, start + options.seconds);
+    gain.gain.exponentialRampToValueAtTime(Math.max(config.gain, 2e-4), start + 3e-3);
+    gain.gain.exponentialRampToValueAtTime(1e-4, start + config.seconds);
     osc.connect(gain).connect(master);
     osc.start(start);
-    osc.stop(start + options.seconds + 0.05);
+    osc.stop(start + config.seconds + 0.05);
   };
-  const metal = (at, frequency, gain) => {
+  const metal2 = (at, frequency, gain) => {
     burst({ at, seconds: 0.05, gain, filter: "highpass", frequency, q: 2 });
     tone({ at, seconds: 0.04, gain: gain * 0.6, frequency: frequency * 0.6, type: "square" });
   };
+  const play = (soundClass, classVolume = 1, distance = 0, at = 0) => {
+    const attenuation = classVolume / (1 + distance * distance * distanceCurve.gainFalloff);
+    if (attenuation < distanceCurve.minGain) return;
+    const [cutoff, gain, seconds] = classes[soundClass] ?? FALLBACK_SOUND_CLASS;
+    classBurst(at, cutoff / (1 + distance * distanceCurve.cutoffFalloff), gain * attenuation, seconds);
+  };
+  const step = (entry) => {
+    if (entry.layer === "metal") metal2(entry.at, entry.frequency, entry.gain);
+    else if (entry.layer === "class") play(entry.soundClass, entry.volume, 0, entry.at);
+    else burst({ at: entry.at, seconds: 0.09, gain: entry.gain, filter: "lowpass", frequency: entry.frequency });
+  };
+  const mechanical = (id) => {
+    for (const entry of mechanicalTable[id] ?? []) step(entry);
+  };
+  const shotSound = (input) => computeShotSound(input, options);
   return {
-    shot(energyJ, category) {
-      const k = Math.min(1, Math.max(0, Math.log10(Math.max(energyJ, 50) / 50) / 2.5));
-      const shotgun = category === "shotgun";
-      burst({ seconds: 0.12 + k * 0.35 + (shotgun ? 0.1 : 0), gain: 0.5 + k * 0.5, filter: "lowpass", frequency: 4200 - k * 2600 });
-      burst({ seconds: 0.03, gain: 0.6, filter: "highpass", frequency: 3e3 });
-      tone({ seconds: 0.14 + k * 0.2, gain: 0.35 + k * 0.4, frequency: 140 - k * 70, to: 40 });
+    shot(energyJ, category, extras = {}) {
+      const sound2 = shotSound({ ...extras, energyJ, category });
+      if (!sound2.audible) return;
+      classBurst(0, sound2.cutoff, sound2.gain, sound2.duration);
+      if (sound2.crack.gain > 0) burst({ seconds: sound2.crack.duration, gain: sound2.crack.gain, filter: "highpass", frequency: sound2.crack.cutoff });
+      tone({ seconds: sound2.body.duration, gain: sound2.body.gain, frequency: sound2.body.frequency, to: sound2.body.to });
     },
+    shotSound,
     click() {
-      metal(0, 2600, 0.25);
+      mechanical("dry_fire");
+    },
+    mechanical,
+    event(event) {
+      const id = mechanicalSoundOf(event);
+      if (id) mechanical(id);
+    },
+    play(soundClass, classVolume, distance) {
+      play(soundClass, classVolume, distance);
     },
     reloadStart(category) {
-      metal(0, 1500, 0.35);
-      if (category !== "shotgun" && category !== "revolver") metal(0.12, 900, 0.2);
+      metal2(0, 1500, 0.35);
+      if (category !== "shotgun" && category !== "revolver") metal2(0.12, 900, 0.2);
     },
     reloadEnd(category) {
-      metal(0, 1100, 0.45);
-      if (category !== "revolver") metal(0.18, 1900, 0.4);
+      metal2(0, 1100, 0.45);
+      if (category !== "revolver") metal2(0.18, 1900, 0.4);
     },
     cycle() {
-      metal(0.22, 900, 0.35);
-      metal(0.36, 1300, 0.35);
+      mechanical("cycle");
     },
     clink() {
-      const f = 3200 + Math.random() * 2e3;
+      const f = 3200 + rng() * 2e3;
       tone({ seconds: 0.09, gain: 0.12, frequency: f });
       tone({ seconds: 0.06, gain: 0.06, frequency: f * 2.7 });
     },
@@ -105,6 +311,2512 @@ function createWeaponAudio(volume = 0.6) {
   };
 }
 
+// src/box-fx.ts
+import { createRng as createRng2, muzzleEnergy as muzzleEnergy2 } from "@adatechnology/game-weapons";
+
+// src/fx/layers.ts
+var createLayers = () => ({ casings: true, magazines: true, muzzleFlash: true });
+
+// src/merge-by-material.ts
+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, mesh, matrix) => {
+  const source = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.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((sum, geometry) => sum + 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 mesh = object;
+    if (!mesh.isMesh || Array.isArray(mesh.material) || !isVisible(mesh)) return;
+    const list = byMaterial.get(mesh.material) ?? [];
+    list.push(bake(THREE, mesh, new THREE.Matrix4().multiplyMatrices(toSpace, mesh.matrixWorld)));
+    byMaterial.set(mesh.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;
+  });
+}
+
+// src/models/index.ts
+import { WEAPONS } from "@adatechnology/game-weapons";
+
+// src/data/models.json
+var models_default = {
+  glock_17: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 202,
+    barrel: 114,
+    options: {
+      st: "glock",
+      rel: 0.7
+    }
+  },
+  glock_18: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 202,
+    barrel: 114,
+    options: {
+      st: "glock",
+      sel: 1,
+      rpm: 1200,
+      rel: 0.9
+    }
+  },
+  glock_19: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 185,
+    barrel: 102,
+    options: {
+      st: "glock",
+      gl: 0.095,
+      rel: 0.7
+    }
+  },
+  taurus_g2c: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 159,
+    barrel: 81,
+    options: {
+      st: "g2c",
+      gl: 0.085,
+      rel: 1.5
+    }
+  },
+  taurus_ts9: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 194,
+    barrel: 104,
+    options: {
+      st: "taurus",
+      rel: 1.2
+    }
+  },
+  beretta_92fs: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 217,
+    barrel: 125,
+    options: {
+      st: "beretta",
+      h: 0.032,
+      rel: 0.9
+    }
+  },
+  sig_sauer_p226: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 196,
+    barrel: 112,
+    options: {
+      st: "sig",
+      h: 0.034,
+      rel: 0.8
+    }
+  },
+  cz_75: {
+    builder: "pistol",
+    caliber: "9\xD719",
+    length: 206,
+    barrel: 120,
+    options: {
+      st: "cz",
+      h: 0.03,
+      rel: 0.9
+    }
+  },
+  taurus_pt100: {
+    builder: "pistol",
+    caliber: ".40 S&W",
+    length: 216,
+    barrel: 127,
+    options: {
+      st: "pt100",
+      stain: 1,
+      rel: 1.2
+    }
+  },
+  colt_m1911: {
+    builder: "pistol",
+    caliber: ".45 ACP",
+    length: 216,
+    barrel: 127,
+    options: {
+      st: "m1911",
+      h: 0.029,
+      gl: 0.1,
+      rel: 1.1
+    }
+  },
+  makarov_pm: {
+    builder: "pistol",
+    caliber: "9\xD718",
+    length: 161,
+    barrel: 94,
+    options: {
+      st: "makarov",
+      h: 0.028,
+      gl: 0.088,
+      rel: 0.8
+    }
+  },
+  fn_five_seven: {
+    builder: "pistol",
+    caliber: "5,7\xD728",
+    length: 208,
+    barrel: 122,
+    options: {
+      st: "fiveseven",
+      gl: 0.12,
+      rel: 0.9
+    }
+  },
+  desert_eagle_mark_xix: {
+    builder: "pistol",
+    caliber: ".50 AE",
+    length: 270,
+    barrel: 152,
+    options: {
+      st: "deagle",
+      h: 0.04,
+      gl: 0.125,
+      deagle: 1,
+      steel: 1,
+      rel: 1.8
+    }
+  },
+  taurus_82: {
+    builder: "revolver",
+    caliber: ".38 SPL",
+    length: 240,
+    barrel: 102,
+    options: {
+      wood: 1
+    }
+  },
+  sw_686: {
+    builder: "revolver",
+    caliber: ".357 Magnum",
+    length: 244,
+    barrel: 102,
+    options: {
+      steel: 1,
+      chambers: 7
+    }
+  },
+  sw_model_29: {
+    builder: "revolver",
+    caliber: ".44 Magnum",
+    length: 302,
+    barrel: 165,
+    options: {
+      wood: 1
+    }
+  },
+  hk_mp5a3: {
+    builder: "rifle",
+    caliber: "9\xD719",
+    length: 700,
+    barrel: 225,
+    options: {
+      mag: "curved",
+      magLen: 0.72,
+      stock: "retract",
+      stockLen: 0.22,
+      hR: 0.055,
+      hg: "poly",
+      hgFrac: 0.85,
+      g3: 1,
+      rpm: 800,
+      sel: 1
+    }
+  },
+  taurus_smt9: {
+    builder: "rifle",
+    caliber: "9\xD719",
+    length: 660,
+    barrel: 200,
+    options: {
+      mag: "box",
+      stock: "retract",
+      stockLen: 0.2,
+      hg: "rail",
+      hgFrac: 0.8,
+      rail: 1,
+      rpm: 750,
+      sel: 1
+    }
+  },
+  hk_ump_45: {
+    builder: "rifle",
+    caliber: ".45 ACP",
+    length: 690,
+    barrel: 200,
+    options: {
+      mag: "box",
+      magLen: 1.1,
+      stock: "skeleton",
+      stockLen: 0.22,
+      hR: 0.07,
+      hg: "poly",
+      hgFrac: 0.85,
+      rpm: 600,
+      sel: 1,
+      rail: 1
+    }
+  },
+  uzi: {
+    builder: "rifle",
+    caliber: "9\xD719",
+    length: 650,
+    barrel: 260,
+    options: {
+      mag: "box",
+      magAt: 0.06,
+      magLen: 1.3,
+      stock: "fold",
+      stockLen: 0.2,
+      hR: 0.065,
+      hg: "poly",
+      hgFrac: 0.4,
+      grip: "none",
+      rpm: 600
+    }
+  },
+  fn_p90: {
+    builder: "p90",
+    caliber: "5,7\xD728",
+    length: 500,
+    barrel: 264,
+    options: {
+      rpm: 900
+    }
+  },
+  kriss_vector: {
+    builder: "rifle",
+    caliber: ".45 ACP",
+    length: 622,
+    barrel: 140,
+    options: {
+      mag: "box",
+      magLen: 1.1,
+      stock: "retract",
+      stockLen: 0.2,
+      hR: 0.085,
+      hg: "rail",
+      hgFrac: 0.9,
+      rail: 1,
+      scope: 1,
+      rpm: 1100
+    }
+  },
+  thompson_m1a1: {
+    builder: "rifle",
+    caliber: ".45 ACP",
+    length: 813,
+    barrel: 267,
+    options: {
+      wood: 1,
+      mag: "box",
+      magLen: 1.2,
+      stock: "fixed",
+      stockLen: 0.3,
+      hg: "none",
+      hR: 0.055,
+      jacket: 1,
+      rpm: 700,
+      charge: 1
+    }
+  },
+  cz_scorpion_evo_3: {
+    builder: "rifle",
+    caliber: "9\xD719",
+    length: 670,
+    barrel: 196,
+    options: {
+      mag: "box",
+      curve: 0.05,
+      magLen: 1.2,
+      stock: "fold",
+      stockLen: 0.22,
+      hg: "rail",
+      hgFrac: 0.85,
+      rail: 1,
+      scope: 1,
+      rpm: 1150
+    }
+  },
+  mac_10: {
+    builder: "rifle",
+    caliber: ".45 ACP",
+    length: 548,
+    barrel: 146,
+    options: {
+      mag: "box",
+      magAt: 0.04,
+      magLen: 1.2,
+      stock: "fold",
+      stockLen: 0.22,
+      hR: 0.075,
+      hg: "none",
+      grip: "none",
+      brake: 2,
+      rpm: 1090,
+      rel: 1.4
+    }
+  },
+  remington_870: {
+    builder: "rifle",
+    caliber: "12 ga",
+    length: 990,
+    barrel: 470,
+    options: {
+      wood: 1,
+      stock: "wood",
+      mag: "none",
+      tube: 1,
+      pump: 1,
+      hg: "none",
+      br: 0.0105,
+      hR: 0.055,
+      noFH: 1
+    }
+  },
+  mossberg_500: {
+    builder: "rifle",
+    caliber: "12 ga",
+    length: 990,
+    barrel: 470,
+    options: {
+      stock: "fixed",
+      mag: "none",
+      tube: 1,
+      pump: 1,
+      hg: "none",
+      br: 0.0105,
+      hR: 0.055,
+      noFH: 1
+    }
+  },
+  cbc_pump_military_3_0: {
+    builder: "rifle",
+    caliber: "12 ga",
+    length: 1e3,
+    barrel: 480,
+    options: {
+      stock: "fixed",
+      mag: "none",
+      tube: 1,
+      tubeLen: 0.95,
+      pump: 1,
+      hg: "none",
+      br: 0.0105,
+      hR: 0.055,
+      rail: 1,
+      noFH: 1
+    }
+  },
+  benelli_m4: {
+    builder: "rifle",
+    caliber: "12 ga",
+    length: 1010,
+    barrel: 470,
+    options: {
+      stock: "retract",
+      mag: "none",
+      tube: 1,
+      hg: "poly",
+      hgFrac: 0.55,
+      br: 0.0105,
+      hR: 0.06,
+      rail: 1,
+      scope: 1,
+      noFH: 1,
+      charge: 1
+    }
+  },
+  franchi_spas_12: {
+    builder: "rifle",
+    caliber: "12 ga",
+    length: 1041,
+    barrel: 546,
+    options: {
+      stock: "fold",
+      mag: "none",
+      tube: 1,
+      pump: 1,
+      hg: "none",
+      br: 0.0105,
+      hR: 0.06,
+      heat: 1,
+      noFH: 1
+    }
+  },
+  kel_tec_ksg: {
+    builder: "bullpup",
+    caliber: "12 ga",
+    length: 660,
+    barrel: 470,
+    options: {
+      shot: 1
+    }
+  },
+  saiga_12: {
+    builder: "rifle",
+    caliber: "12 ga",
+    length: 1e3,
+    barrel: 430,
+    options: {
+      mag: "box",
+      magLen: 1.15,
+      stock: "fixed",
+      hg: "poly",
+      br: 0.0105,
+      hR: 0.07,
+      gas: 1,
+      charge: 1,
+      ak: 1,
+      rel: 1.3
+    }
+  },
+  aa_12: {
+    builder: "rifle",
+    caliber: "12 ga",
+    length: 966,
+    barrel: 457,
+    options: {
+      mag: "drum",
+      stock: "fixed",
+      hg: "poly",
+      hgFrac: 0.6,
+      br: 0.0105,
+      hR: 0.085,
+      carry: 1,
+      rpm: 300
+    }
+  },
+  boito_double_barrel: {
+    builder: "break",
+    caliber: "12 ga",
+    length: 1130,
+    barrel: 710,
+    options: {}
+  },
+  ak_47: {
+    builder: "rifle",
+    caliber: "7,62\xD739",
+    length: 880,
+    barrel: 415,
+    options: {
+      wood: 1,
+      stock: "wood",
+      mag: "curved",
+      hg: "wood",
+      hgFrac: 0.42,
+      gas: 1,
+      charge: 1,
+      ak: 1,
+      rod: 1,
+      bayo: 1,
+      rpm: 600,
+      rel: 0.4
+    }
+  },
+  akm: {
+    builder: "rifle",
+    caliber: "7,62\xD739",
+    length: 880,
+    barrel: 415,
+    options: {
+      wood: 1,
+      stock: "wood",
+      mag: "curved",
+      hg: "wood",
+      hgFrac: 0.42,
+      gas: 1,
+      charge: 1,
+      ak: 1,
+      rod: 1,
+      rpm: 600,
+      magMat: "bakelite",
+      rel: 0.45
+    }
+  },
+  ak_74: {
+    builder: "rifle",
+    caliber: "5,45\xD739",
+    length: 943,
+    barrel: 415,
+    options: {
+      stock: "fixed",
+      mag: "curved",
+      hg: "poly",
+      hgFrac: 0.42,
+      gas: 1,
+      charge: 1,
+      brake: 1,
+      ak: 1,
+      rod: 1,
+      rpm: 650,
+      magMat: "bakelite"
+    }
+  },
+  ak_12: {
+    builder: "rifle",
+    caliber: "5,45\xD739",
+    length: 945,
+    barrel: 415,
+    options: {
+      stock: "retract",
+      mag: "curved",
+      hg: "rail",
+      hgFrac: 0.5,
+      rail: 1,
+      brake: 1,
+      scope: 1,
+      charge: 1,
+      ak: 1,
+      rpm: 700,
+      magMat: "poly"
+    }
+  },
+  imbel_ia2: {
+    builder: "rifle",
+    caliber: "5,56\xD745",
+    length: 850,
+    barrel: 330,
+    options: {
+      stock: "fold",
+      mag: "box",
+      curve: 0.07,
+      magLen: 1.25,
+      hg: "poly",
+      hgFrac: 0.6,
+      rail: 1,
+      charge: 1,
+      rpm: 700
+    }
+  },
+  taurus_t4: {
+    builder: "rifle",
+    caliber: "5,56\xD745",
+    length: 840,
+    barrel: 368,
+    options: {
+      stock: "retract",
+      mag: "box",
+      curve: 0.07,
+      magLen: 1.3,
+      hg: "rail",
+      hgFrac: 0.7,
+      rail: 1,
+      scope: 1,
+      ar: 1,
+      rpm: 750
+    }
+  },
+  colt_m4a1: {
+    builder: "rifle",
+    caliber: "5,56\xD745",
+    length: 840,
+    barrel: 368,
+    options: {
+      stock: "retract",
+      mag: "box",
+      curve: 0.07,
+      magLen: 1.3,
+      hg: "rail",
+      hgFrac: 0.6,
+      rail: 1,
+      scope: 2,
+      ar: 1,
+      rpm: 800
+    }
+  },
+  colt_m16a2: {
+    builder: "rifle",
+    caliber: "5,56\xD745",
+    length: 1e3,
+    barrel: 508,
+    options: {
+      stock: "fixed",
+      mag: "box",
+      curve: 0.07,
+      magLen: 1.3,
+      hg: "poly",
+      hgFrac: 0.55,
+      carry: 1,
+      ar: 1,
+      rpm: 800,
+      burst: 3
+    }
+  },
+  hk416: {
+    builder: "rifle",
+    caliber: "5,56\xD745",
+    length: 900,
+    barrel: 368,
+    options: {
+      stock: "retract",
+      mag: "box",
+      curve: 0.07,
+      magLen: 1.3,
+      hg: "rail",
+      hgFrac: 0.75,
+      rail: 1,
+      scope: 1,
+      ar: 1,
+      rpm: 850
+    }
+  },
+  steyr_aug_a1: {
+    builder: "bullpup",
+    caliber: "5,56\xD745",
+    length: 790,
+    barrel: 508,
+    options: {
+      rpm: 680
+    }
+  },
+  fn_fal: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1090,
+    barrel: 533,
+    options: {
+      stock: "fixed",
+      mag: "box",
+      curve: 0.05,
+      magLen: 1.05,
+      hg: "poly",
+      hgFrac: 0.45,
+      carry: 1,
+      brake: 1,
+      charge: 1,
+      rpm: 650
+    }
+  },
+  hk_g3a3: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1025,
+    barrel: 450,
+    options: {
+      stock: "fixed",
+      mag: "box",
+      curve: 0.07,
+      magLen: 1.05,
+      hg: "poly",
+      hgFrac: 0.55,
+      hR: 0.058,
+      g3: 1,
+      rpm: 550
+    }
+  },
+  sks: {
+    builder: "rifle",
+    caliber: "7,62\xD739",
+    length: 1020,
+    barrel: 520,
+    options: {
+      wood: 1,
+      stock: "trad",
+      mag: "internal",
+      fore: 0.55,
+      gas: 1,
+      charge: 1,
+      bayo: 1
+    }
+  },
+  m14_ebr: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1e3,
+    barrel: 457,
+    options: {
+      stock: "retract",
+      mag: "box",
+      curve: 0.035,
+      magLen: 1.05,
+      hg: "rail",
+      hgFrac: 0.7,
+      rail: 1,
+      scope: 3,
+      olive: 1,
+      charge: 1
+    }
+  },
+  svd_dragunov: {
+    builder: "rifle",
+    caliber: "7,62\xD754R",
+    length: 1225,
+    barrel: 620,
+    options: {
+      wood: 1,
+      stock: "skeleton",
+      stockLen: 0.32,
+      mag: "box",
+      curve: 0.09,
+      magLen: 0.9,
+      hg: "wood",
+      hgFrac: 0.4,
+      scope: 4,
+      brake: 1,
+      ak: 1,
+      charge: 1
+    }
+  },
+  fn_scar_h: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 965,
+    barrel: 400,
+    options: {
+      tan: 1,
+      stock: "fold",
+      mag: "box",
+      magLen: 1.05,
+      hg: "rail",
+      hgFrac: 0.7,
+      hR: 0.07,
+      rail: 1,
+      scope: 2,
+      charge: 1,
+      rpm: 600
+    }
+  },
+  knights_sr_25_mk11: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1156,
+    barrel: 508,
+    options: {
+      stock: "fixed",
+      mag: "box",
+      magLen: 1,
+      hg: "rail",
+      hgFrac: 0.75,
+      rail: 1,
+      scope: 3,
+      bipod: 1,
+      ar: 1
+    }
+  },
+  hk_psg_1: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1208,
+    barrel: 650,
+    options: {
+      stock: "fixed",
+      stockLen: 0.3,
+      mag: "box",
+      curve: 0.06,
+      magLen: 0.75,
+      hg: "poly",
+      hgFrac: 0.55,
+      hR: 0.058,
+      g3: 1,
+      scope: 3,
+      rel: 0.7
+    }
+  },
+  steyr_ssg_69: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1140,
+    barrel: 650,
+    options: {
+      olive: 1,
+      stock: "trad",
+      mag: "internal",
+      scope: 3,
+      bolt: 1,
+      round: 1,
+      rel: 0.6
+    }
+  },
+  barrett_mrad: {
+    builder: "rifle",
+    caliber: ".338 Lapua",
+    length: 1260,
+    barrel: 686,
+    options: {
+      tan: 1,
+      stock: "fold",
+      stockLen: 0.33,
+      mag: "box",
+      magLen: 0.75,
+      hg: "rail",
+      hgFrac: 0.55,
+      rail: 1,
+      scope: 3,
+      bolt: 1,
+      bipod: 1,
+      brake: 1,
+      round: 1
+    }
+  },
+  cheytac_m200: {
+    builder: "rifle",
+    caliber: ".408 CheyTac",
+    length: 1397,
+    barrel: 737,
+    options: {
+      stock: "retract",
+      stockLen: 0.3,
+      mag: "box",
+      magLen: 0.85,
+      hg: "poly",
+      hgFrac: 0.55,
+      hR: 0.07,
+      scope: 4,
+      bolt: 1,
+      bipod: 1,
+      brake: 1,
+      round: 1
+    }
+  },
+  remington_700: {
+    builder: "rifle",
+    caliber: ".308",
+    length: 1100,
+    barrel: 610,
+    options: {
+      wood: 1,
+      stock: "trad",
+      mag: "internal",
+      scope: 3,
+      bolt: 1,
+      round: 1
+    }
+  },
+  m24_sws: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1092,
+    barrel: 610,
+    options: {
+      olive: 1,
+      stock: "trad",
+      mag: "internal",
+      scope: 3,
+      bolt: 1,
+      bipod: 1,
+      round: 1
+    }
+  },
+  mosin_nagant_91_30: {
+    builder: "rifle",
+    caliber: "7,62\xD754R",
+    length: 1232,
+    barrel: 730,
+    options: {
+      wood: 1,
+      stock: "trad",
+      mag: "internal",
+      fore: 0.85,
+      bolt: 1,
+      round: 1,
+      bands: 1
+    }
+  },
+  accuracy_awm: {
+    builder: "rifle",
+    caliber: ".338 Lapua",
+    length: 1230,
+    barrel: 686,
+    options: {
+      olive: 1,
+      stock: "skeleton",
+      stockLen: 0.34,
+      mag: "box",
+      magLen: 0.6,
+      hg: "poly",
+      hgFrac: 0.3,
+      scope: 3,
+      bolt: 1,
+      bipod: 1,
+      brake: 1,
+      round: 1
+    }
+  },
+  sako_trg_42: {
+    builder: "rifle",
+    caliber: ".338 Lapua",
+    length: 1200,
+    barrel: 690,
+    options: {
+      stock: "fixed",
+      stockLen: 0.33,
+      mag: "box",
+      magLen: 0.6,
+      hg: "poly",
+      hgFrac: 0.3,
+      scope: 3,
+      bolt: 1,
+      bipod: 1,
+      brake: 1,
+      round: 1
+    }
+  },
+  barrett_m82a1: {
+    builder: "rifle",
+    caliber: ".50 BMG",
+    length: 1448,
+    barrel: 737,
+    options: {
+      stock: "fixed",
+      stockLen: 0.3,
+      mag: "box",
+      magLen: 0.8,
+      hg: "poly",
+      hgFrac: 0.55,
+      hR: 0.1,
+      wR: 0.05,
+      br: 0.014,
+      scope: 3,
+      bipod: 1,
+      brake: 2,
+      carry: 1,
+      charge: 1
+    }
+  },
+  ruger_10_22: {
+    builder: "rifle",
+    caliber: ".22 LR",
+    length: 940,
+    barrel: 470,
+    options: {
+      wood: 1,
+      stock: "trad",
+      mag: "internal",
+      hR: 0.05,
+      br: 7e-3,
+      charge: 1
+    }
+  },
+  cbc_7022: {
+    builder: "rifle",
+    caliber: ".22 LR",
+    length: 1e3,
+    barrel: 530,
+    options: {
+      stock: "trad",
+      mag: "internal",
+      hR: 0.05,
+      br: 7e-3,
+      charge: 1
+    }
+  },
+  cbc_122: {
+    builder: "rifle",
+    caliber: ".22 LR",
+    length: 1030,
+    barrel: 590,
+    options: {
+      wood: 1,
+      stock: "trad",
+      mag: "internal",
+      hR: 0.045,
+      br: 7e-3,
+      bolt: 1,
+      round: 1
+    }
+  },
+  winchester_1894: {
+    builder: "rifle",
+    caliber: ".30-30",
+    length: 965,
+    barrel: 508,
+    options: {
+      wood: 1,
+      stock: "straight",
+      mag: "none",
+      tube: 1,
+      lever: 1,
+      hR: 0.05,
+      fore: 0,
+      bands: 1
+    }
+  },
+  rossi_puma: {
+    builder: "rifle",
+    caliber: ".38 SPL / .357",
+    length: 950,
+    barrel: 508,
+    options: {
+      wood: 1,
+      stock: "straight",
+      mag: "none",
+      tube: 1,
+      lever: 1,
+      hR: 0.048,
+      fore: 0
+    }
+  },
+  hunting_rifle_30_06: {
+    builder: "rifle",
+    caliber: ".30-06",
+    length: 1100,
+    barrel: 560,
+    options: {
+      wood: 1,
+      stock: "trad",
+      mag: "internal",
+      scope: 3,
+      bolt: 1,
+      round: 1
+    }
+  },
+  fn_minimi: {
+    builder: "rifle",
+    caliber: "5,56\xD745",
+    length: 1040,
+    barrel: 465,
+    options: {
+      stock: "fixed",
+      mag: "belt",
+      hg: "poly",
+      hgFrac: 0.35,
+      bipod: 1,
+      hR: 0.08,
+      carry: 1,
+      charge: 1,
+      rpm: 850
+    }
+  },
+  pkm: {
+    builder: "rifle",
+    caliber: "7,62\xD754R",
+    length: 1173,
+    barrel: 658,
+    options: {
+      wood: 1,
+      stock: "skeleton",
+      mag: "belt",
+      hg: "none",
+      bipod: 1,
+      hR: 0.08,
+      br: 0.01,
+      charge: 1,
+      rpm: 650
+    }
+  },
+  m60: {
+    builder: "rifle",
+    caliber: "7,62\xD751",
+    length: 1105,
+    barrel: 560,
+    options: {
+      stock: "fixed",
+      mag: "belt",
+      hg: "poly",
+      hgFrac: 0.3,
+      bipod: 1,
+      hR: 0.085,
+      br: 0.011,
+      charge: 1,
+      rpm: 550,
+      rel: 1.3
+    }
+  },
+  rpg_7: {
+    builder: "launcher",
+    caliber: "PG-7V 40/85 mm",
+    length: 950,
+    barrel: 950,
+    options: {
+      lt: "rpg"
+    }
+  },
+  m72_law: {
+    builder: "launcher",
+    caliber: "66 mm HEAT",
+    length: 881,
+    barrel: 881,
+    options: {
+      lt: "m72"
+    }
+  },
+  at4: {
+    builder: "launcher",
+    caliber: "84 mm HEAT",
+    length: 1020,
+    barrel: 1020,
+    options: {
+      lt: "at4"
+    }
+  },
+  carl_gustaf_m4: {
+    builder: "launcher",
+    caliber: "84 mm (HE / HEAT)",
+    length: 950,
+    barrel: 950,
+    options: {
+      lt: "carl"
+    }
+  },
+  m2_flamethrower: {
+    builder: "launcher",
+    caliber: "Napalm / gasolina gel",
+    length: 1e3,
+    barrel: 620,
+    options: {
+      lt: "flame"
+    }
+  },
+  improvised_flamethrower: {
+    builder: "launcher",
+    caliber: "Gasolina + extintor pressurizado",
+    length: 800,
+    barrel: 660,
+    options: {
+      lt: "flameDIY"
+    }
+  },
+  browning_m2: {
+    builder: "m2",
+    caliber: ".50 BMG",
+    length: 1650,
+    barrel: 1140,
+    options: {
+      rpm: 550
+    }
+  },
+  remington_700_300wm: {
+    builder: "rifle",
+    caliber: ".308",
+    length: 1100,
+    barrel: 610,
+    options: {
+      wood: 1,
+      stock: "trad",
+      mag: "internal",
+      scope: 3,
+      bolt: 1,
+      round: 1
+    },
+    variantOf: "remington_700"
+  }
+};
+
+// src/models/rounded-box.ts
+var uvAlong = (THREE, faceDirection, normal, uvAxis, projectionAxis, radius, sideLength) => {
+  const arcLength = 2 * Math.PI * radius / 4;
+  const centerLength = Math.max(sideLength - 2 * radius, 0);
+  const halfArc = Math.PI / 4;
+  const projected = new THREE.Vector3().copy(normal);
+  projected[projectionAxis] = 0;
+  projected.normalize();
+  const arcUvRatio = 0.5 * arcLength / (arcLength + centerLength);
+  const arcAngleRatio = 1 - projected.angleTo(faceDirection) / halfArc;
+  if (Math.sign(projected[uvAxis]) === 1) return arcAngleRatio * arcUvRatio;
+  const centerUv = centerLength / (arcLength + centerLength);
+  return centerUv + arcUvRatio + arcUvRatio * (1 - arcAngleRatio);
+};
+var FACES = [
+  { direction: [1, 0, 0], u: ["z", "y", false], v: ["y", "z", true] },
+  { direction: [-1, 0, 0], u: ["z", "y", true], v: ["y", "z", true] },
+  { direction: [0, 1, 0], u: ["x", "z", true], v: ["z", "x", false] },
+  { direction: [0, -1, 0], u: ["x", "z", true], v: ["z", "x", true] },
+  { direction: [0, 0, 1], u: ["x", "y", true], v: ["y", "x", true] },
+  { direction: [0, 0, -1], u: ["x", "y", false], v: ["y", "x", true] }
+];
+function createRoundedBoxGeometry(THREE, width, height, depth, segments, radius) {
+  const count = segments * 2 + 1;
+  const rounding = Math.min(width / 2, height / 2, depth / 2, radius);
+  const geometry = new THREE.BoxGeometry(1, 1, 1, count, count, count);
+  const flat = geometry.toNonIndexed();
+  geometry.setIndex(null);
+  geometry.setAttribute("position", flat.attributes.position);
+  geometry.setAttribute("normal", flat.attributes.normal);
+  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 positions = geometry.attributes.position.array;
+  const normals = geometry.attributes.normal.array;
+  const uvs = geometry.attributes.uv.array;
+  const faceTriangles = positions.length / 6;
+  const halfSegment = 0.5 / count;
+  const sides = { x: width, y: height, z: depth };
+  for (let i = 0, j = 0; i < positions.length; i += 3, j += 2) {
+    position.fromArray(positions, i);
+    normal.copy(position);
+    normal.x -= Math.sign(normal.x) * halfSegment;
+    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;
+    normals[i] = normal.x;
+    normals[i + 1] = normal.y;
+    normals[i + 2] = normal.z;
+    const face = FACES[Math.floor(i / faceTriangles)];
+    if (!face) continue;
+    const direction = new THREE.Vector3(...face.direction);
+    for (const [offset, [uvAxis, projectionAxis, mirrored]] of [[0, face.u], [1, face.v]]) {
+      const value = uvAlong(THREE, direction, normal, uvAxis, projectionAxis, rounding, sides[uvAxis]);
+      uvs[j + offset] = mirrored ? 1 - value : value;
+    }
+  }
+  return geometry;
+}
+
+// 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 additive = { transparent: true, opacity: 0.95, blending: THREE.AdditiveBlending, depthWrite: false };
+  return {
+    metal: standard(3422010, 0.42, 0.75),
+    steel: standard(7106418, 0.32, 0.85),
+    steelL: standard(9080208, 0.28, 0.9),
+    dark: standard(1711133, 0.55, 0.5),
+    poly: standard(2369058, 0.8, 0.05),
+    olive: standard(4936241, 0.8, 0.05),
+    tan: standard(10259043, 0.8, 0.05),
+    wood: standard(4860951, 0.55, 0),
+    woodL: standard(6175263, 0.55, 0),
+    brass: standard(12819013, 0.28, 0.9),
+    copper: standard(11561531, 0.3, 0.85),
+    lead: standard(7171955, 0.5, 0.5),
+    shell: standard(10692380, 0.5, 0.05),
+    glass: standard(8364968, 0.05, 0.1, { transparent: true, opacity: 0.42 }),
+    lens: standard(2311770, 0.05, 0.3, { transparent: true, opacity: 0.9, emissive: 399392 }),
+    rubber: standard(1381653, 0.85, 0),
+    white: standard(13617332, 0.8, 0),
+    hole: standard(526343, 1, 0),
+    bake: standard(5911072, 0.55, 0),
+    rust: standard(7027230, 0.95, 0.3),
+    rustD: standard(4860440, 0.95, 0.25),
+    worn: standard(5593178, 0.6, 0.6),
+    fire: basic(16742946),
+    fire2: basic(16764762),
+    flashA: basic(16757575, additive),
+    flashB: basic(16773568, additive),
+    smokeP: standard(9079430, 1, 0, { transparent: true, opacity: 0.35, depthWrite: false }),
+    /** Launcher paints. */
+    yellow: standard(11570978, 0.6, 0),
+    red: standard(9313300, 0.45, 0.1),
+    redPaint: standard(10691354, 0.35, 0.2),
+    tape: standard(9079944, 0.9, 0),
+    pipe: standard(10115634, 0.35, 0.8),
+    green: standard(3818536, 0.75, 0.05),
+    /** Magazine finishes named by the options. */
+    bakelite: standard(6958620, 0.6, 0),
+    polyMag: standard(2763302, 0.85, 0)
+  };
+};
+var kits = /* @__PURE__ */ new WeakMap();
+function modelKit(THREE) {
+  const cached = kits.get(THREE);
+  if (cached) return cached;
+  const geometries = /* @__PURE__ */ new Map();
+  const shadowed = (mesh) => {
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    return mesh;
+  };
+  const place = (parent, mesh, x, y, z) => {
+    mesh.position.set(x, y, z);
+    parent.add(mesh);
+    return mesh;
+  };
+  const kit = {
+    THREE,
+    M: createMaterials(THREE),
+    roundness: null,
+    group: () => new THREE.Group(),
+    box(parent, w, h, d, material, x, y, z, rz = 0, ry = 0, rx = 0) {
+      const radius = Math.min(w, h, d) * (kit.roundness ?? 0.2);
+      const key = `${w.toFixed(4)},${h.toFixed(4)},${d.toFixed(4)},${radius.toFixed(5)}`;
+      let geometry = geometries.get(key);
+      if (!geometry) {
+        geometry = radius > 25e-5 ? createRoundedBoxGeometry(THREE, w, h, d, 2, radius) : new THREE.BoxGeometry(w, h, d);
+        geometries.set(key, geometry);
+      }
+      const mesh = place(parent, shadowed(new THREE.Mesh(geometry, material)), x, y, z);
+      mesh.rotation.set(rx, ry, rz);
+      return mesh;
+    },
+    cylinderX(parent, radius, length, material, x, y, z, segments = 16, radiusEnd) {
+      const mesh = shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radiusEnd ?? radius, radius, length, segments), material));
+      mesh.rotation.z = -PI / 2;
+      return place(parent, mesh, x, y, z);
+    },
+    cylinderY(parent, radius, height, material, x, y, z, segments = 16, radiusEnd) {
+      return place(parent, shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radiusEnd ?? radius, radius, height, segments), material)), x, y, z);
+    },
+    cylinderZ(parent, radius, length, material, x, y, z, segments = 16) {
+      const mesh = shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radius, radius, length, segments), material));
+      mesh.rotation.x = PI / 2;
+      return place(parent, mesh, x, y, z);
+    },
+    sphere(parent, radius, material, x, y, z, detail = 1) {
+      return place(parent, shadowed(new THREE.Mesh(new THREE.IcosahedronGeometry(radius, detail), material)), x, y, z);
+    },
+    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;
+    },
+    pivot(parent, x = 0, y = 0, z = 0) {
+      const group = new THREE.Group();
+      group.position.set(x, y, z);
+      parent.add(group);
+      return group;
+    }
+  };
+  kits.set(THREE, kit);
+  return kit;
+}
+function heatify(glow, mesh) {
+  mesh.material = mesh.material.clone();
+  glow.push(mesh);
+  return mesh;
+}
+
+// src/models/break-action.ts
+function buildBreakAction(kit, options) {
+  const { M, box: box2, cylinderX, sphere } = 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);
+  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);
+  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);
+  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);
+  parts.muzzle = kit.mark(barrels, barrel + 0.01, 0.01, 0);
+  parts.eject = parts.breech[0];
+  return { group, parts };
+}
+
+// src/models/details.ts
+var PI2 = Math.PI;
+function rail(kit, parent, x, length, y, z, width, rotationX = 0) {
+  const { M, box: box2 } = kit;
+  const pivot = kit.pivot(parent, 0, y, z);
+  pivot.rotation.x = rotationX;
+  box2(pivot, length, 5e-3, width, M.dark, x + length / 2, 0, 0);
+  const slots = Math.floor(length / 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);
+  return pivot;
+}
+function vents(kit, parent, x, length, y, z, count, height) {
+  for (let i = 0; i < count; i++) kit.box(parent, length / count * 0.45, height, 3e-3, kit.M.hole, x + (i + 0.5) * length / count, y, z);
+}
+function scope(kit, parent, kind, cx, cy, cz = 0) {
+  const { M, box: box2, cylinderX, cylinderY, cylinderZ, THREE } = kit;
+  if (kind === 1) {
+    box2(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);
+    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);
+    return;
+  }
+  const sleeve = kind === 4 ? 0.2 : 0.32;
+  cylinderX(parent, 0.0135, sleeve * 0.55, M.dark, cx, cy + 0.045, cz, 18);
+  cylinderX(parent, 0.0135, sleeve * 0.25, M.dark, cx + sleeve * 0.36, cy + 0.045, cz, 18, 0.026);
+  cylinderX(parent, 0.026, 0.05, M.dark, cx + sleeve * 0.5, cy + 0.045, cz, 18);
+  cylinderX(parent, 0.024, 2e-3, M.lens, cx + sleeve * 0.5 + 0.026, cy + 0.045, cz, 18);
+  cylinderX(parent, 0.019, 0.06, M.dark, cx - sleeve * 0.38, cy + 0.045, cz, 18, 0.0135);
+  cylinderX(parent, 0.019, 0.035, M.rubber, cx - sleeve * 0.38 - 0.045, cy + 0.045, cz, 18);
+  cylinderX(parent, 0.017, 2e-3, M.lens, cx - sleeve * 0.38 - 0.063, cy + 0.045, cz, 18);
+  cylinderY(parent, 0.01, 0.022, M.dark, cx, cy + 0.066, cz, 14);
+  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 ring = kit.torus(parent, new THREE.TorusGeometry(0.0155, 3e-3, 8, 20), M.dark, cx + offset, cy + 0.045, cz);
+    ring.rotation.y = PI2 / 2;
+    box2(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);
+var swivel = (kit, parent, x, y) => void kit.torus(parent, new kit.THREE.TorusGeometry(6e-3, 15e-4, 6, 12), kit.M.metal, x, y, 0);
+
+// src/models/bullpup.ts
+function buildBullpup(kit, options) {
+  const { M, box: box2, 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);
+  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);
+  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);
+  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);
+  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);
+    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);
+    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);
+  }
+  parts.muzzle = kit.mark(group, L + 0.01, 0.012, 0);
+  parts.eject = kit.mark(group, bodyLength * 0.25, 5e-3, 0.03);
+  return { group, parts };
+}
+
+// src/models/launcher-flame.ts
+var hose = (kit, group, points, radius, material) => {
+  const { THREE } = kit;
+  const curve = new THREE.CatmullRomCurve3(points.map((point) => new THREE.Vector3(...point)));
+  const tube = new THREE.Mesh(new THREE.TubeGeometry(curve, 40, radius, 8, false), material);
+  tube.castShadow = tube.receiveShadow = true;
+  group.add(tube);
+};
+var pilot = (kit, group, x, y) => {
+  const { M, cylinderX } = kit;
+  cylinderX(group, 6e-3, 0.03, M.fire2, x + 0.015, y, 0, 6, 0).userData.flame = 1;
+  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;
+  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);
+  heatify(parts.glow, cylinderX(group, 0.013, 0.1, M.steel, 0.88, 0, 0, 12, 9e-3));
+  cylinderX(group, 0.018, 0.02, M.metal, 0.73, 0, 0, 14);
+  cylinderX(group, 0.012, 0.06, M.metal, 0.84, -0.025, 0, 10);
+  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);
+  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);
+  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);
+  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;
+    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);
+  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);
+  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;
+  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);
+  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;
+  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);
+  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);
+  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.muzzle = kit.pivot(group, 0.78, 0, 0);
+  parts.rear = kit.pivot(group, 0.05, 0, 0);
+}
+
+// src/models/launcher-rounds.ts
+var PI3 = Math.PI;
+function buildRocketGrenade(kit) {
+  const { M, cylinderX } = kit;
+  const round2 = kit.group();
+  cylinderX(round2, 0.018, 0.15, M.olive, -0.05, 0, 0, 14);
+  cylinderX(round2, 0.02, 0.07, M.olive, 0.035, 0, 0, 18, 0.0425);
+  cylinderX(round2, 0.0425, 0.12, M.olive, 0.13, 0, 0, 20);
+  cylinderX(round2, 0.0428, 0.012, M.dark, 0.09, 0, 0, 20);
+  cylinderX(round2, 0.0425, 0.13, M.olive, 0.255, 0, 0, 20, 0.011);
+  cylinderX(round2, 0.011, 0.03, M.metal, 0.335, 0, 0, 10, 4e-3);
+  return round2;
+}
+function buildRecoillessRound(kit) {
+  const { M, cylinderX } = kit;
+  const round2 = kit.group();
+  cylinderX(round2, 0.041, 0.32, M.green, -0.16, 0, 0, 20);
+  cylinderX(round2, 0.0415, 0.02, M.yellow, -0.05, 0, 0, 20);
+  cylinderX(round2, 0.041, 0.12, M.green, 0.06, 0, 0, 20, 0.012);
+  cylinderX(round2, 0.043, 0.03, M.brass, -0.33, 0, 0, 20);
+  return round2;
+}
+function buildFlyingRocket(kit, launcherType) {
+  const { M, box: box2, 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);
+    fin.rotation.x = i * PI3 / 4;
+  }
+  return rocket;
+}
+
+// src/models/launcher-rocket.ts
+function buildRpg(kit, group, parts) {
+  const { M, box: box2, 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);
+  heatify(parts.glow, cylinderX(group, 0.021, 0.83, M.steel, 0.545, 0, 0, 18));
+  cylinderX(group, 0.03, 0.3, M.wood, 0.47, 0, 0, 16);
+  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);
+  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);
+  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);
+  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);
+  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);
+  const round2 = buildRocketGrenade(kit);
+  round2.position.x = 0.95;
+  group.add(round2);
+  parts.round = round2;
+  parts.roundRest = 0.95;
+  parts.makeRound = () => buildRocketGrenade(kit);
+  parts.muzzle = kit.pivot(group, 0.95, 0, 0);
+  parts.rear = kit.pivot(group, 0, 0, 0);
+}
+function buildM72(kit, group, parts) {
+  const { M, box: box2, 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));
+  cylinderX(group, 0.032, 0.32, M.olive, 0.16, 0, 0, 20);
+  cylinderX(group, 0.039, 0.03, M.rubber, 0.866, 0, 0, 20);
+  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);
+  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.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;
+  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);
+  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);
+  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;
+  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);
+  const breech = kit.pivot(group, 0.21, 0, 0.05);
+  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);
+  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);
+  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);
+  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);
+  parts.makeRound = () => buildRecoillessRound(kit);
+  parts.muzzle = kit.pivot(group, 0.95, 0, 0);
+  parts.rear = kit.pivot(group, 0.05, 0, 0);
+}
+var ROCKET_BUILDERS = {
+  rpg: buildRpg,
+  m72: buildM72,
+  at4: buildAt4,
+  carl: buildCarlGustaf
+};
+
+// src/models/launcher.ts
+function buildLauncher(kit, options) {
+  const group = kit.group();
+  const type = options.lt ?? "";
+  const isFlame = type === "flame" || type === "flameDIY";
+  const parts = { family: isFlame ? "flame" : "rocket", launcherType: type, glow: [] };
+  if (type === "flame") buildFlamethrower(kit, group, parts);
+  else if (type === "flameDIY") buildImprovisedFlamethrower(kit, group, parts);
+  else ROCKET_BUILDERS[type]?.(kit, group, parts);
+  parts.eject = parts.muzzle;
+  return { group, parts };
+}
+
+// src/models/m2.ts
+function buildM2(kit) {
+  const { M, box: box2, 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);
+  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);
+  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);
+  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);
+  const bolt = kit.pivot(group);
+  parts.bolt = bolt;
+  box2(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);
+  parts.muzzle = kit.mark(group, 1.72, 0.01, 0);
+  parts.eject = kit.mark(group, 0.3, -0.07, 0);
+  return { group, parts };
+}
+
+// src/models/p90.ts
+function buildP90(kit) {
+  const { M, box: box2, 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);
+  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);
+  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);
+  parts.muzzle = kit.mark(group, 0.48, 0, 0);
+  parts.eject = kit.mark(group, 0.2, -0.07, 0);
+  return { group, parts };
+}
+
+// src/models/part-registry.ts
+var SINGLE_PARTS = ["slide", "bolt", "boltHandle", "mag", "trigger", "hammer", "lever", "pump", "belt", "cover", "crane", "cylinder", "barrels", "safety", "muzzle", "eject", "loadPort", "topLoad", "rear", "round", "gauge"];
+function partRegistry(parts) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const key of SINGLE_PARTS) {
+    const part = parts[key];
+    if (part) registry.set(key, part);
+  }
+  parts.breech?.forEach((part, index) => registry.set(`breech_${index}`, part));
+  parts.chambers?.forEach((part, index) => registry.set(`chamber_${index}`, part));
+  return registry;
+}
+
+// src/models/pistol-slide.ts
+var PI4 = Math.PI;
+function buildSlide(kit, slide2, parts, options, style, size, metal2) {
+  const { M, box: box2, 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);
+  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);
+  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);
+  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);
+  }
+  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);
+  }
+  if (style.tri) {
+    const tube = new kit.THREE.Mesh(new kit.THREE.CylinderGeometry(0.016, 0.016, L * 0.6, 3), metal2);
+    tube.castShadow = tube.receiveShadow = true;
+    tube.rotation.set(0, 0, -PI4 / 2);
+    tube.rotateY(PI4 / 6);
+    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);
+  }
+  if (style.bushing) {
+    heatify(parts.glow, cylinderX(slide2, 78e-4, 6e-3, M.steelL, L + 2e-3, 1e-3, 0, 18));
+    cylinderX(slide2, 45e-4, 4e-3, M.steel, L + 2e-3, -0.012, 0, 12);
+  }
+  const muzzleY = style.tri ? slideHeight * 0.08 : 2e-3;
+  heatify(parts.glow, cylinderX(slide2, style.tri ? 72e-4 : 62e-4, 4e-3, M.dark, L + 15e-4, muzzleY, 0, 18));
+  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);
+  } 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);
+  }
+  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);
+  }
+  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 (options.sel) {
+    const selector = box2(slide2, 0.01, 8e-3, 3e-3, M.dark, 0.014, -slideHeight * 0.2, slideWidth / 2 + 14e-4);
+    parts.safety ?? (parts.safety = selector);
+  }
+}
+
+// src/models/pistol-style.ts
+var STYLES = {
+  glock: { rf: 0.07, ga: -0.36, grip: "finger", guard: "square", rail: 1, sight: "u", port: 0.2, slideM: "metal", frame: "poly" },
+  taurus: { rf: 0.16, ga: -0.3, grip: "panel", guard: "square", rail: 1, sight: "3dot", port: 0.18, frontSer: 1, frame: "poly" },
+  g2c: { rf: 0.2, ga: -0.3, grip: "panel", guard: "round", rail: 0, sight: "3dot", port: 0.17, frame: "poly", safety: "thumb" },
+  beretta: { rf: 0.28, ga: -0.27, grip: "wood", guard: "round", hammer: "spur", sight: "3dot", open: 1, decock: "slide", port: 0, frame: "metal" },
+  pt100: { rf: 0.25, ga: -0.27, grip: "rubber", guard: "round", hammer: "spur", sight: "3dot", port: 0.17, decock: "frame", frame: "metal" },
+  sig: { rf: 0.14, ga: -0.3, grip: "rubber", guard: "hook", hammer: "spur", sight: "3dot", port: 0.19, decock: "frame", rail: 1, tall: 1.12, frame: "metal" },
+  cz: { rf: 0.32, ga: -0.3, grip: "rubber", guard: "round", hammer: "spur", sight: "3dot", port: 0.15, inset: 1, safety: "thumb", frame: "metal" },
+  m1911: { rf: 0.24, ga: -0.2, grip: "wood", guard: "round", hammer: "ring", sight: "small", port: 0.12, bushing: 1, beaver: 1, safety: "thumb", slideStop: 1, frame: "metal" },
+  makarov: { rf: 0.48, ga: -0.24, grip: "star", guard: "round", hammer: "ring", sight: "small", port: 0.14, flush: 1, safety: "slide", lanyard: 1, frame: "metal" },
+  fiveseven: { rf: 0.2, ga: -0.4, grip: "chunky", guard: "square", rail: 1, sight: "3dot", port: 0.18, slope: 1, frame: "poly" },
+  deagle: { rf: 0.08, ga: -0.28, grip: "rubber", guard: "round", hammer: "big", sight: "small", port: 0.16, tri: 1, safety: "slide", frame: "metal" }
+};
+
+// src/models/pistol.ts
+var PI5 = Math.PI;
+function buildFrame(kit, group, parts, options, style, size, materials) {
+  const { M, box: box2, cylinderZ, sphere } = 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);
+  }
+  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);
+  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);
+  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);
+  }
+  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);
+  const gripLength = options.gl ?? 0.105;
+  const gx = 0.034 + (L - 0.2) * 0.15;
+  const gy = -h / 2 - gripLength / 2 + 6e-3;
+  const grip = kit.pivot(group, gx, gy, 0);
+  grip.rotation.z = style.ga;
+  const gripWidth = style.grip === "chunky" ? w * 1.18 : w * 1.06;
+  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);
+    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);
+      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);
+  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);
+  }
+  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.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);
+  if (style.lanyard) {
+    const ring = kit.torus(grip, new kit.THREE.TorusGeometry(5e-3, 13e-4, 6, 12), M.dark, -0.012, -gripLength / 2 + 4e-3, 0);
+    ring.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);
+  return { gx, ty: -h / 2 };
+}
+function buildPistol(kit, options) {
+  const { M, box: box2 } = kit;
+  const style = { ...STYLES[options.st ?? "glock"] };
+  const group = kit.group();
+  const parts = { family: "pistol", kick: options.deagle ? 1.8 : 0.6, glow: [] };
+  const size = { length: (options.L ?? 0) / 1e3 * 0.97, height: (options.h ?? 0.031) * (style.tall ?? 1), width: options.deagle ? 0.032 : style.flush ? 0.024 : 0.025 };
+  const { length: L, height: h, width: w } = size;
+  const slideMetal = options.steel ? M.steel : options.stain ? M.steelL : M.metal;
+  const frameMetal = style.frame === "poly" ? M.poly : slideMetal;
+  const gripMaterial = style.grip === "wood" ? M.wood : style.grip === "star" ? M.bake : style.grip === "rubber" ? M.rubber : M.poly;
+  const slide2 = kit.pivot(group);
+  parts.slide = slide2;
+  parts.stroke = L * 0.15;
+  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);
+  } 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);
+  } else {
+    const guard = kit.torus(group, new kit.THREE.TorusGeometry(0.019, 22e-4, 6, 16, PI5), frameMetal, gx + 0.05, ty - 0.014, 0);
+    guard.rotation.z = PI5;
+    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);
+  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);
+      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 {
+      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);
+    }
+  }
+  parts.muzzle = kit.mark(group, L + 6e-3, style.tri ? h * 0.08 : 2e-3, 0);
+  parts.eject = kit.mark(group, L * 0.6, h / 2, w * 0.25);
+  return { group, parts };
+}
+
+// src/models/revolver.ts
+var PI6 = Math.PI;
+var DEFAULT_CHAMBERS = 6;
+function buildRevolver(kit, options) {
+  const { M, box: box2, 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);
+  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);
+  for (let i = 0; i < chambers; i++) {
+    const angle = i * 2 * PI6 / 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);
+  }
+  parts.chambers = [];
+  for (let i = 0; i < chambers; i++) {
+    const angle = i * 2 * PI6 / chambers + PI6 / 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);
+  }
+  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);
+  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);
+  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);
+  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);
+  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 };
+}
+
+// src/models/rifle-fittings.ts
+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 middle = (x0 + x1) / 2;
+  if (o.scope) 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);
+  }
+  if (o.bipod) {
+    const bx = x1 + (L - x1) * 0.45;
+    cylinderX(group, 8e-3, 0.02, M.dark, bx + 0.04, by - 0.012, 0, 12);
+    for (const side of [-1, 1]) {
+      const leg = kit.pivot(group, bx + 0.04, by - 0.012, 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);
+    }
+  }
+  if (o.bolt) {
+    const handle = kit.pivot(group, x1 - 0.045, by, 0);
+    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);
+    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);
+  }
+  if (o.tube) {
+    const tubeLength = (L - x1) * (o.tubeLen || 0.8);
+    cylinderX(group, 0.0105, tubeLength, M.metal, x1 + tubeLength / 2, by - 0.023, 0, 16);
+    cylinderX(group, 0.0125, 0.02, M.dark, x1 + tubeLength + 6e-3, by - 0.023, 0, 16);
+  }
+  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);
+  }
+  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);
+  }
+  if (o.bayo) box2(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);
+}
+
+// src/models/rifle-forend.ts
+var PI7 = 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 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);
+      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, PI7 / 2);
+      rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - 2e-3, -wR * 0.54, wR * 0.4, -PI7 / 2);
+      rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - hh / 2, 0, wR * 0.6, PI7);
+    } 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);
+      } else {
+        box2(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);
+    }
+  }
+  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);
+  } 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);
+}
+
+// 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 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);
+  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, cylinderX, cylinderZ } = kit;
+  const mx = o.magAt != null ? x0 + o.magAt : gx + 0.075;
+  const scale = o.magLen || 1;
+  const magazine = kit.pivot(group, mx, -hR / 2, 0);
+  parts.mag = magazine;
+  const finish = o.magMat === "bakelite" ? M.bakelite : o.magMat === "poly" ? M.polyMag : void 0;
+  if (o.mag === "curved") {
+    let px = 0;
+    let py = 0;
+    const material = finish ?? M.metal;
+    for (const angle of [0.06, 0.22, 0.38]) {
+      const length = 0.07 * scale;
+      const cx = px + Math.sin(angle) * length / 2;
+      const cy = py - Math.cos(angle) * length / 2;
+      box2(magazine, 0.052, length + 4e-3, 0.024, material, cx, cy, 0, angle);
+      box2(magazine, 0.04, length * 0.8, 0.026, M.dark, cx, cy, 0, angle);
+      px += Math.sin(angle) * length;
+      py -= Math.cos(angle) * length;
+    }
+    box2(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 length = 0.13 * scale;
+    const curve = o.curve || 0;
+    const segment = length / 3;
+    const material = finish ?? M.dark;
+    let px = 0;
+    let py = 0;
+    let angle = 0.08;
+    for (let i = 0; i < 3; i++) {
+      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);
+      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);
+    parts.magDrop = length + 0.03;
+  } else if (o.mag === "drum") {
+    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);
+    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);
+    parts.mag = null;
+  } else parts.mag = null;
+  if (o.mag === "belt") {
+    const belt = kit.pivot(group, mx + 0.02, -hR / 2 - 0.05, -0.045);
+    parts.belt = belt;
+    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);
+    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);
+    }
+    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);
+  }
+  return mx;
+}
+
+// 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;
+  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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+  }
+}
+
+// src/models/rifle.ts
+var PI8 = 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 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);
+    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);
+  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);
+  }
+  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);
+    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);
+  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);
+  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);
+  }
+  if (o.ar) box2(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;
+  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);
+    for (let i = 0; i < 6; i++) cylinderX(group, r * 2.15, 4e-3, M.metal, x1 + (L - x1) * (0.05 + i * 0.09), by, 0, 16);
+  }
+  if (o.gas) cylinderX(group, r * 0.75, (L - x1) * 0.55, M.metal, x1 + (L - x1) * 0.3, by + r * 2.2, 0, 14);
+  if (o.brake) {
+    const scale = o.brake === 2 ? 3.2 : 2;
+    const brakeLength = o.brake === 2 ? 0.12 : 0.06;
+    heatify(parts.glow, cylinderX(group, r * scale, brakeLength, M.dark, L - brakeLength / 2, by, 0, o.brake === 2 ? 8 : 16));
+    for (let i = 0; i < 3; i++) box2(group, brakeLength * 0.16, r * scale * 1.3, r * scale * 2.2, M.hole, L - brakeLength * 0.25 - i * brakeLength * 0.25, by, 0);
+  } else if (!o.noFH) {
+    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 * PI8 / 2 + PI8 / 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);
+    }
+  }
+  cylinderX(group, r * 0.55, 4e-3, M.hole, L + 5e-4, by, 0, 12);
+}
+var familyOf = (o) => {
+  if (o.mag === "belt") return "belt";
+  if (o.pump) return "pump";
+  if (o.lever) return "lever";
+  if (o.tube) return "semi12";
+  if (o.bolt) return o.mag === "box" ? "boltmag" : "bolt";
+  return o.mag === "internal" ? "semiint" : "rifle";
+};
+function buildRifle(kit, options) {
+  const { M } = kit;
+  const group = kit.group();
+  const parts = { family: "rifle", glow: [] };
+  const length = (options.L ?? 0) / 1e3;
+  const barrelLength = (options.B ?? 0) / 1e3;
+  const isTraditional = options.stock === "trad" || options.stock === "straight";
+  const stockLength = options.stock === "none" ? 0 : options.stockLen || Math.min(0.36, Math.max(0.2, 0.3 * length));
+  const receiverStart = stockLength;
+  const receiverEnd = Math.max(receiverStart + 0.12, length - barrelLength * 0.92);
+  const receiverHeight = options.hR || 0.06;
+  const context = {
+    kit,
+    group,
+    parts,
+    options,
+    furniture: options.wood ? M.wood : options.olive ? M.olive : options.tan ? M.tan : M.poly,
+    isTraditional,
+    length,
+    barrelLength,
+    stockLength,
+    receiverStart,
+    receiverEnd,
+    receiverHeight,
+    receiverWidth: options.wR || 0.034,
+    barrelRadius: options.br || 85e-4,
+    barrelY: receiverHeight * 0.15,
+    receiverLength: receiverEnd - receiverStart
+  };
+  buildReceiver(context);
+  buildBarrel(context);
+  buildForend(context);
+  const gripX = buildGrip(context);
+  const magazineX = buildMagazine(context, gripX);
+  buildStock(context, magazineX);
+  buildFittings(context, gripX);
+  const { barrelY: by, receiverWidth: wR } = context;
+  const ejectX = receiverEnd - (options.ejectBack || 0.07);
+  const ejectY = options.ar ? receiverHeight * 0.2 : by;
+  parts.muzzle = kit.mark(group, length + 0.01, by, 0);
+  parts.eject = kit.mark(group, ejectX, ejectY, wR / 2 + 6e-3);
+  parts.loadPort = kit.mark(group, receiverEnd - 0.05, -receiverHeight / 2 - 4e-3, 0);
+  parts.topLoad = kit.mark(group, ejectX, receiverHeight / 2 + 4e-3, 0);
+  parts.family = familyOf(options);
+  return { group, parts };
+}
+
+// src/models/index.ts
+var MODEL_ENTRIES = models_default;
+var ARCHETYPE_MODELS = (() => {
+  const actionOf = new Map(WEAPONS.map((def) => [def.id, def.action.kind]));
+  const chosen = {};
+  for (const def of [...WEAPONS].sort((a, b) => a.id < b.id ? -1 : 1)) {
+    const { archetype } = def;
+    if (!archetype || !(def.id in MODEL_ENTRIES) || archetype in MODEL_ENTRIES || archetype in chosen) continue;
+    if (actionOf.get(archetype) === def.action.kind) chosen[archetype] = def.id;
+  }
+  return chosen;
+})();
+var BUILDERS = {
+  pistol: buildPistol,
+  revolver: buildRevolver,
+  rifle: buildRifle,
+  bullpup: buildBullpup,
+  p90: (kit) => buildP90(kit),
+  break: buildBreakAction,
+  m2: (kit) => buildM2(kit),
+  launcher: buildLauncher
+};
+var nameParts = (parts) => {
+  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);
+  inner.scale.x = factor;
+  inner.position.x = -box2.min.x * factor;
+  const root = kit.group();
+  root.add(inner);
+  return root;
+};
+var hasWeaponModel = (id) => id in MODEL_ENTRIES || id in ARCHETYPE_MODELS;
+function buildWeaponModelById(THREE, id) {
+  const entry = MODEL_ENTRIES[ARCHETYPE_MODELS[id] ?? id];
+  if (!entry) return void 0;
+  const kit = modelKit(THREE);
+  const options = { L: entry.length, B: entry.barrel, cal: entry.caliber, ...entry.options };
+  if (id in ARCHETYPE_MODELS) delete options.chambers;
+  const built = BUILDERS[entry.builder](kit, options);
+  nameParts(built.parts);
+  let root;
+  if (entry.builder === "launcher") {
+    root = kit.group();
+    root.add(built.group);
+    built.group.position.x = -new THREE.Box3().setFromObject(built.group).min.x;
+  } else root = fitLength(kit, built.group, entry.length / 1e3);
+  root.name = id;
+  return { id, root, inner: built.group, parts: built.parts };
+}
+
 // src/props.ts
 var box = (id, material, size, position, extra = {}) => ({ id, material, shape: { kind: "box", size }, position, ...extra });
 var joint = (a, b, kind) => ({ a, b, kind });
@@ -176,19 +2888,47 @@ function buildProp(THREE, prop) {
 function buildWeaponModel(THREE, def) {
   return buildProp(THREE, weaponProp(def));
 }
+var MODEL_BODY = "body";
+function buildModeledProp(THREE, def, name) {
+  const model = buildWeaponModelById(THREE, def.id);
+  if (!model) return void 0;
+  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);
+  group.add(model.root);
+  group.updateMatrixWorld(true);
+  for (const mesh of mergeByMaterial(THREE, model.root, group)) {
+    mesh.userData.destructionPart = MODEL_BODY;
+    group.add(mesh);
+  }
+  group.remove(model.root);
+  const size = box2.getSize(new THREE.Vector3());
+  group.userData.footprint = [size.x, size.y, size.z];
+  return group;
+}
+function modeledPropSpec(root, def, name) {
+  const footprint = root.userData.footprint ?? [0.3, 0.1, 0.1];
+  const size = [Math.max(0.02, footprint[0]), Math.max(0.02, footprint[1]), Math.max(0.02, footprint[2])];
+  return { name, parts: [{ id: MODEL_BODY, material: "steel", shape: { kind: "box", size }, position: [0, size[1] / 2, 0], mass: def.mass }], joints: [], tags: ["weapon"] };
+}
 
-// src/fx.ts
+// src/box-fx.ts
 var EJECTS_ON_SHOT = /* @__PURE__ */ new Set(["pistol", "smg", "carbine", "rifle", "sniper", "shotgun"]);
 var DROPS_MAGAZINE = /* @__PURE__ */ new Set(["pistol", "smg", "carbine", "rifle", "sniper"]);
 var CYCLES = /* @__PURE__ */ new Set(["shotgun_pump_12", "rifle_bolt_308"]);
+var FALLBACK_ENERGY = 300;
 var MAX_CASINGS = 120;
 var MAX_MAGAZINES = 12;
 var LIFETIME_S = 25;
 var HAND_OFFSET = [0.2, -0.2, -0.42];
 var GRAVITY = 9.81;
-function createWeaponFx(options) {
+function createBoxFx(options) {
   const { THREE, scene, camera, arsenal, groundAt } = options;
   const audio = options.audio ?? null;
+  const random = createRng2(options.seed ?? 1);
+  const layers = options.layers ?? createLayers();
   const bodies = [];
   const brass = new THREE.MeshStandardMaterial({ color: 13214282, metalness: 0.8, roughness: 0.35 });
   const shell = new THREE.MeshStandardMaterial({ color: 11022891, roughness: 0.6 });
@@ -220,13 +2960,17 @@ function createWeaponFx(options) {
   };
   const handPoint = (x, y, z, out) => out.set(HAND_OFFSET[0] + x, HAND_OFFSET[1] + y, HAND_OFFSET[2] + z).applyQuaternion(camera.quaternion).add(camera.position);
   const throwBody = (kind, mesh, from, velocity, radius) => {
+    if (!(kind === "casing" ? layers.casings : layers.magazines)) {
+      mesh.geometry.dispose();
+      return;
+    }
     const limit = kind === "casing" ? MAX_CASINGS : MAX_MAGAZINES;
     const same = bodies.filter((b) => b.kind === kind);
     if (same.length >= limit) removeBody(same[0]);
     mesh.position.copy(from);
     mesh.castShadow = true;
     scene.add(mesh);
-    bodies.push({ mesh, velocity, spin: new THREE.Vector3(Math.random() * 20 - 10, Math.random() * 30 - 15, Math.random() * 20 - 10), radius, age: 0, resting: false, bounces: 0, kind });
+    bodies.push({ mesh, velocity, spin: new THREE.Vector3(random() * 20 - 10, random() * 30 - 15, random() * 20 - 10), radius, age: 0, resting: false, bounces: 0, kind });
   };
   const ejectCasing = (caliberMm, isShell, downward) => {
     const radius = isShell ? 0.0105 : Math.max(3e-3, caliberMm / 1e3 * 0.6);
@@ -236,7 +2980,7 @@ function createWeaponFx(options) {
     const from = handPoint(0.03, 0.03, 0.05, new THREE.Vector3());
     const right = new THREE.Vector3(1, 0, 0).applyQuaternion(camera.quaternion);
     const up = new THREE.Vector3(0, 1, 0);
-    const velocity = downward ? up.clone().multiplyScalar(-0.5).addScaledVector(right, (Math.random() - 0.5) * 0.4) : right.multiplyScalar(1.6 + Math.random() * 0.8).addScaledVector(up, 1.4 + Math.random() * 0.8);
+    const velocity = downward ? up.clone().multiplyScalar(-0.5).addScaledVector(right, (random() - 0.5) * 0.4) : right.multiplyScalar(1.6 + random() * 0.8).addScaledVector(up, 1.4 + random() * 0.8);
     throwBody("casing", mesh, from, velocity, radius);
   };
   const dropMagazine = (category) => {
@@ -248,7 +2992,7 @@ function createWeaponFx(options) {
     throwBody("magazine", mesh, from, new THREE.Vector3(0, -0.4, 0), size[1] / 2);
     audio?.reloadStart(category);
   };
-  const caliberOf = (weapon) => {
+  const caliberOf2 = (weapon) => {
     if (weapon.action.kind !== "firearm") return 9;
     return arsenal.calibers.get(weapon.action.caliber)?.diameter ?? 9;
   };
@@ -260,17 +3004,17 @@ function createWeaponFx(options) {
   const onShot = (weapon) => {
     kick = 1;
     const caliber = weapon.action.kind === "firearm" ? arsenal.calibers.get(weapon.action.caliber) : void 0;
-    const energy = caliber ? 0.5 * (caliber.bulletGrams / 1e3) * caliber.muzzleSpeed ** 2 * (caliber.pellets ?? 1) : 300;
-    audio?.shot(energy, weapon.category);
+    const energy = caliber ? muzzleEnergy2(caliber) * (caliber.pellets ?? 1) : FALLBACK_ENERGY;
+    audio?.shot(energy, weapon.category, { ...caliber ? { caliber } : {}, distance: options.soundDistance?.() ?? 0 });
     if (CYCLES.has(weapon.id)) audio?.cycle();
-    if (EJECTS_ON_SHOT.has(weapon.category) && weapon.id !== "shotgun_double_12") ejectCasing(caliberOf(weapon), weapon.category === "shotgun", false);
+    if (EJECTS_ON_SHOT.has(weapon.category) && weapon.id !== "shotgun_double_12") ejectCasing(caliberOf2(weapon), weapon.category === "shotgun", false);
   };
   const onReloadStart = (weapon, tool) => {
     if (DROPS_MAGAZINE.has(weapon.category)) dropMagazine(weapon.category);
     else audio?.reloadStart(weapon.category);
     if (weapon.category === "revolver" || weapon.id === "shotgun_double_12") {
       const spent = Math.max(1, tool.capacity - tool.ammo);
-      for (let i = 0; i < spent; i++) ejectCasing(caliberOf(weapon), weapon.category === "shotgun", true);
+      for (let i = 0; i < spent; i++) ejectCasing(caliberOf2(weapon), weapon.category === "shotgun", true);
     }
   };
   const stepBody = (body, dt) => {
@@ -300,7 +3044,13 @@ function createWeaponFx(options) {
     body.mesh.rotation.z = 0;
   };
   return {
+    unequip() {
+      if (model) hand.remove(model);
+      model = null;
+      inHand = null;
+    },
     handle(event, tool) {
+      if (event.type === "explosion") return;
       const weapon = arsenal.weapons.get(event.weapon);
       if (event.type === "tool") equip(event.weapon);
       if (!weapon) return;
@@ -342,14 +3092,1265 @@ function createWeaponFx(options) {
   };
 }
 
+// src/fx/viewmodel.ts
+import { createToolClipPlayer, toolAnimationStep } from "@adatechnology/game-contracts";
+import { createRng as createRng3, muzzleEnergy as muzzleEnergy3 } from "@adatechnology/game-weapons";
+
+// src/animation/clip-builder.ts
+import { STAGE_EVENT } from "@adatechnology/game-contracts";
+var ROOT = "root";
+var AXIS_INDEX = { x: 0, y: 1, z: 2 };
+var EASE_STEPS = 10;
+var ease = (progress) => progress < 0.5 ? 2 * progress * progress : 1 - (-2 * progress + 2) ** 2 / 2;
+var move = (part, axis, start, duration, from, to) => ({ part, channel: "position", axis, start, duration, from, to });
+var turn = (part, axis, start, duration, from, to) => ({ part, channel: "rotation", axis, start, duration, from, to });
+var cue = (t, type, data) => ({ t, type, ...data ? { data } : {} });
+var stage = (id, t) => ({ t, type: STAGE_EVENT, data: { stage: id } });
+var valueAt = (tweens, t, includeInstants) => {
+  let value = 0;
+  for (const tween of tweens) {
+    if (tween.start > t || tween.duration === 0 && (tween.start === t ? !includeInstants : false)) continue;
+    if (tween.duration === 0 || t >= tween.start + tween.duration) value = tween.to;
+    else value = tween.from + (tween.to - tween.from) * ease((t - tween.start) / tween.duration);
+  }
+  return value;
+};
+var round = (value) => Math.round(value * 1e6) / 1e6;
+function composeClip(id, tweens, events = [], minDuration = 0) {
+  const ordered = [...tweens].sort((a, b) => a.start - b.start);
+  const duration = Math.max(minDuration, 1e-3, ...ordered.map((tween) => tween.start + tween.duration), ...events.map((event) => event.t));
+  const times = /* @__PURE__ */ new Set([0, duration]);
+  for (const tween of ordered) {
+    times.add(round(tween.start));
+    if (tween.duration > 0) for (let step = 1; step <= EASE_STEPS; step++) times.add(round(tween.start + tween.duration * step / EASE_STEPS));
+  }
+  const instants = new Set(ordered.filter((tween) => tween.duration === 0).map((tween) => round(tween.start)));
+  const channels = /* @__PURE__ */ new Map();
+  for (const tween of ordered) {
+    const key = `${tween.part}|${tween.channel}|${tween.axis}`;
+    channels.set(key, [...channels.get(key) ?? [], tween]);
+  }
+  const sampleKey = (t, includeInstants) => {
+    const poses = /* @__PURE__ */ new Map();
+    for (const [key, list] of channels) {
+      const [part, channel, axis] = key.split("|");
+      const pose = poses.get(part) ?? { position: [0, 0, 0], rotation: [0, 0, 0] };
+      pose[channel][AXIS_INDEX[axis]] = round(valueAt(list, t, includeInstants));
+      poses.set(part, pose);
+    }
+    const root = poses.get(ROOT);
+    poses.delete(ROOT);
+    const parts = {};
+    for (const [part, pose] of poses) parts[part] = pose;
+    return { t, ...root ? { position: root.position, rotation: root.rotation } : {}, ...poses.size ? { parts } : {} };
+  };
+  const keys = [];
+  for (const t of [...times].sort((a, b) => a - b)) {
+    if (instants.has(t)) keys.push(sampleKey(t, false));
+    keys.push(sampleKey(t, true));
+  }
+  const sorted = [...events].sort((a, b) => a.t - b.t);
+  return { id, duration, keys, ...sorted.length ? { events: sorted } : {} };
+}
+var renamed = (clip, id) => ({ ...clip, id });
+
+// src/animation/magazine-clips.ts
+var MAGAZINE_SWAP_SECONDS = 0.82;
+var MAGAZINE_IN_AT = 0.45;
+function magazineSwap(parts, start) {
+  const direction = parts.magDir || -1;
+  const drop = parts.magDrop || 0.15;
+  return {
+    tweens: [
+      move("mag", "y", start, 0.16, 0, direction * drop * 0.6),
+      move("mag", "y", start + 0.16, 0, 0, direction * drop * 2.2),
+      move("mag", "y", start + MAGAZINE_IN_AT, 0.3, direction * drop * 2.2, 0)
+    ],
+    events: [cue(start + 0.16, "drop_magazine", { up: direction > 0 })],
+    end: start + MAGAZINE_SWAP_SECONDS
+  };
+}
+
+// src/animation/context.ts
+var KICK_BY_CASE = { shell: 1.6, big: 2.4, tiny: 0.3, pistol: 0.7, rifle: 1.1 };
+var kickOf = (context) => context.parts.kick ?? KICK_BY_CASE[context.caseType];
+var BLOWBACK = /* @__PURE__ */ new Set(["pistol", "rifle", "semiint", "semi12", "p90", "belt"]);
+var PUMP_TRAVEL = -0.075;
+var BOLT_TRAVEL = -0.07;
+var BOLT_TURN = -1.15;
+var LEVER_TURN = -0.85;
+var strokeOf = (parts) => -(parts.stroke || 0.06);
+var blowbackPart = (context) => context.family === "pistol" ? "slide" : "bolt";
+
+// src/animation/cycle-clips.ts
+function boltStroke(start, hold = 0) {
+  return [
+    turn("boltHandle", "x", start, 0.09, 0, BOLT_TURN),
+    move("boltHandle", "x", start + 0.1, 0.12, 0, BOLT_TRAVEL),
+    move("bolt", "x", start + 0.1, 0.12, 0, BOLT_TRAVEL),
+    move("boltHandle", "x", start + 0.26 + hold, 0.12, BOLT_TRAVEL, 0),
+    move("bolt", "x", start + 0.26 + hold, 0.12, BOLT_TRAVEL, 0),
+    turn("boltHandle", "x", start + 0.4 + hold, 0.09, BOLT_TURN, 0)
+  ];
+}
+function cycleClip(context) {
+  const { parts, family } = context;
+  if (family === "pump" && parts.pump) return composeClip("cycle", [move("pump", "x", 0.22, 0.11, 0, PUMP_TRAVEL), move("pump", "x", 0.36, 0.11, PUMP_TRAVEL, 0)], [cue(0.3, "eject_casing", { down: false })], 0.5);
+  if ((family === "bolt" || family === "boltmag") && parts.bolt && parts.boltHandle) return composeClip("cycle", boltStroke(0.3), [cue(0.5, "eject_casing", { down: false })], 0.82);
+  if (family === "lever" && parts.lever) return composeClip("cycle", [turn("lever", "z", 0.22, 0.13, 0, LEVER_TURN), turn("lever", "z", 0.38, 0.13, LEVER_TURN, 0)], [cue(0.3, "eject_casing", { down: false })], 0.55);
+  return void 0;
+}
+var STUCK_AT = { stovepipe: 0.35, double_feed: 0.6, misfire: 0, failure_to_extract: 0 };
+var CLEAR_HOLD = 0.04;
+function clearBlowback(context, fault) {
+  const { parts, family } = context;
+  const part = blowbackPart(context);
+  const travel = strokeOf(parts);
+  const stuck = travel * (STUCK_AT[fault] ?? 0);
+  const swap = fault === "double_feed" && parts.mag ? magazineSwap(parts, 0) : void 0;
+  const start = swap?.end ?? 0;
+  const tweens = [...swap?.tweens ?? []];
+  const events = [...swap?.events ?? []];
+  if (family === "belt" && parts.cover) {
+    tweens.push(turn("cover", "z", start, 0.18, 0, 0.9), turn("cover", "z", start + 0.3, 0.15, 0.9, 0));
+    return composeClip(`clear_${fault}`, [...tweens, ...slideOut(part, stuck, travel, start + 0.5)], [...events, cue(start + 0.5 + 0.1, "fly_jam", { jam: fault })]);
+  }
+  return composeClip(`clear_${fault}`, [...tweens, ...slideOut(part, stuck, travel, start)], [...events, cue(start + 0.1, "fly_jam", { jam: fault })]);
+}
+var slideOut = (part, from, travel, start) => [move(part, "x", start, 0.12, from, travel), move(part, "x", start + 0.2, 0.07, travel, 0)];
+function clearManual(context, fault) {
+  const { parts, family } = context;
+  const fly = (t) => [cue(t, "fly_jam", { jam: fault })];
+  if (family === "pump" && parts.pump) return composeClip(`clear_${fault}`, [move("pump", "x", 0, 0.12, 0, PUMP_TRAVEL), move("pump", "x", 0.2, 0.12, PUMP_TRAVEL, 0)], fly(0.12), 0.4);
+  if ((family === "bolt" || family === "boltmag") && parts.bolt && parts.boltHandle) return composeClip(`clear_${fault}`, boltStroke(0, CLEAR_HOLD), fly(0.22), 0.6);
+  if (family === "lever" && parts.lever) return composeClip(`clear_${fault}`, [turn("lever", "z", 0, 0.13, 0, LEVER_TURN), turn("lever", "z", 0.16, 0.13, LEVER_TURN, 0)], fly(0.1), 0.35);
+  return void 0;
+}
+function clearClips(context) {
+  return ["misfire", "stovepipe", "double_feed", "failure_to_extract"].map((fault) => {
+    const manual = clearManual(context, fault);
+    if (manual) return manual;
+    const part = blowbackPart(context);
+    if (context.parts[part] && ["pistol", "rifle", "semiint", "semi12", "p90", "belt"].includes(context.family)) return clearBlowback(context, fault);
+    return composeClip(`clear_${fault}`, [], [cue(0, "fly_jam", { jam: fault })], 0.1);
+  });
+}
+
+// src/animation/reload-clips.ts
+import { RELOAD_STAGES } from "@adatechnology/game-weapons";
+var KINDS = ["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)];
+};
+var cycleWithoutEject = (start) => ({ tweens: boltStroke(start), events: [], end: start + 0.55 });
+function magazineReload(context, kind) {
+  const { parts, family } = context;
+  const swap = magazineSwap(parts, 0);
+  const draft = { tweens: [...swap.tweens], events: [...swap.events], end: swap.end };
+  if (family === "pistol") {
+    if (kind === "empty" && parts.slide) {
+      draft.tweens.push(move("slide", "x", 0, 0, 0, strokeOf(parts)), move("slide", "x", swap.end, 0.05, strokeOf(parts), 0));
+      draft.end += 0.12;
+    }
+  } else if (family === "boltmag") {
+    const stroke = cycleWithoutEject(swap.end);
+    draft.tweens.push(...stroke.tweens);
+    draft.end = stroke.end;
+  } else if (kind === "empty" && parts.bolt) {
+    draft.tweens.push(...charge(context, swap.end));
+    draft.end += 0.35;
+  }
+  return draft;
+}
+function revolverReload(kind) {
+  const events = [cue(0.32, "eject_casing", { from: "chambers", down: false })];
+  if (kind !== "one_by_one") events.push(cue(0.7, "move_in", { from: "chambers" }));
+  return { tweens: [turn("crane", "x", 0, 0.22, 0, -1.25), turn("crane", "x", 1.05, 0.2, -1.25, 0)], events, end: 1.3 };
+}
+var breakReload = () => ({
+  tweens: [turn("barrels", "z", 0, 0.2, 0, -0.5), turn("barrels", "z", 1, 0.15, -0.5, 0)],
+  events: [cue(0.25, "eject_casing", { from: "breech", down: false }), cue(0.65, "move_in", { from: "breech" })],
+  end: 1.2
+});
+var beltReload = (context) => ({
+  tweens: [turn("cover", "z", 0, 0.2, 0, 0.9), move("belt", "z", 0.2, 0.25, 0, -0.3), move("belt", "z", 0.55, 0.3, -0.3, 0), turn("cover", "z", 0.9, 0.18, 0.9, 0), ...charge(context, 1.15)],
+  events: [],
+  end: 1.55
+});
+var UNIT = 1;
+function tubeReload(context, kind) {
+  const { parts, family } = context;
+  const draft = { tweens: [], events: [], end: UNIT };
+  if (kind !== "empty") return draft;
+  if (family === "pump" && parts.pump) draft.tweens.push(move("pump", "x", 0.88, 0.05, 0, PUMP_TRAVEL), move("pump", "x", 0.94, 0.05, PUMP_TRAVEL, 0));
+  else if (family === "lever" && parts.lever) draft.tweens.push(turn("lever", "z", 0.87, 0.06, 0, LEVER_TURN), turn("lever", "z", 0.94, 0.06, LEVER_TURN, 0));
+  else if (parts.bolt) draft.tweens.push(move("bolt", "x", 0.88, 0.07, 0, strokeOf(parts)), move("bolt", "x", 0.95, 0.04, strokeOf(parts), 0));
+  return draft;
+}
+function boltReload(context) {
+  if (!context.parts.boltHandle || !context.parts.bolt) return { tweens: [], events: [], end: UNIT };
+  return {
+    tweens: [
+      turn("boltHandle", "x", 0, 0.05, 0, BOLT_TURN),
+      move("boltHandle", "x", 0.05, 0.07, 0, BOLT_TRAVEL),
+      move("bolt", "x", 0.05, 0.07, 0, BOLT_TRAVEL),
+      move("boltHandle", "x", 0.86, 0.07, BOLT_TRAVEL, 0),
+      move("bolt", "x", 0.86, 0.07, BOLT_TRAVEL, 0),
+      turn("boltHandle", "x", 0.93, 0.05, BOLT_TURN, 0)
+    ],
+    events: [],
+    end: UNIT
+  };
+}
+function internalMagazineReload(context) {
+  const travel = strokeOf(context.parts);
+  return { tweens: context.parts.bolt ? [move("bolt", "x", 0, 0.04, 0, travel), move("bolt", "x", 0.89, 0.04, travel, 0)] : [], events: [], end: UNIT };
+}
+function heavyReload(context) {
+  const { parts, family } = context;
+  if (family === "flame") return { tweens: parts.gauge ? [turn("gauge", "z", 0, 1, -2.4, 0)] : [], events: [], end: 1.1 };
+  if (parts.disposable) {
+    return {
+      tweens: [move(ROOT, "y", 0.6, 0, 0, -0.6), move(ROOT, "y", 0.6, 0.5, -0.6, 0)],
+      events: [cue(0, "drop_tube"), cue(0.6, "seat_tube")],
+      end: 1.15
+    };
+  }
+  if (parts.round) {
+    return {
+      tweens: [move("round", "x", 0, 0.55, 0.45, 0), move("round", "y", 0, 0.55, 0.12, 0)],
+      events: [cue(0, "show_round")],
+      end: 0.6
+    };
+  }
+  return {
+    tweens: [turn("breech_0", "y", 0, 0.25, 0, -1.6), turn("breech_0", "y", 0.76, 0.22, -1.6, 0)],
+    events: [cue(0.3, "breech_round")],
+    end: 1.05
+  };
+}
+var isTube = (context) => ["pump", "semi12", "lever"].includes(context.family);
+function draftFor(context, kind) {
+  const { parts, family } = context;
+  if (family === "rocket" || family === "flame") return heavyReload(context);
+  if (parts.mag) return magazineReload(context, kind);
+  if (family === "revolver" && parts.crane) return revolverReload(kind);
+  if (family === "break" && parts.barrels) return breakReload();
+  if (family === "belt" && parts.cover && parts.belt) return beltReload(context);
+  if (isTube(context)) return tubeReload(context, kind);
+  if (family === "bolt") return boltReload(context);
+  if (family === "semiint") return internalMagazineReload(context);
+  return void 0;
+}
+var markers = (context, kind, duration) => context.reloadFamily ? RELOAD_STAGES[context.reloadFamily][kind].map((entry) => stage(entry.stage, entry.at * duration)) : [];
+function reloadClips(context) {
+  const clips = [];
+  let first;
+  for (const kind of KINDS) {
+    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);
+    if (!first) first = clip;
+    else if (JSON.stringify({ ...clip, id: first.id }) === JSON.stringify(first)) continue;
+    clips.push(clip);
+  }
+  return clips.length > 0 ? clips : first ? [renamed(first, "reload")] : [];
+}
+function feedClip(context) {
+  const { family } = context;
+  if (family === "revolver") return composeClip("feed", [], [cue(0, "move_in", { from: "chambers", next: true })], 0.24);
+  if (family === "bolt" || family === "semiint") return composeClip("feed", [], [cue(0, "move_in", { from: "topLoad" })], 0.24);
+  if (isTube(context)) return composeClip("feed", [], [cue(0, "move_in", { from: "loadPort" })], 0.24);
+  return void 0;
+}
+
+// src/animation/shot-clips.ts
+var FAULT_SLIDE_BACK = { stovepipe: 0.35, double_feed: 0.6 };
+var pullTrigger = (context) => context.parts.trigger ? [turn("trigger", "z", 0, 0.04, 0, 0.35), turn("trigger", "z", 0.06, 0.08, 0.35, 0)] : [];
+var recoil = (context) => {
+  const kick = kickOf(context);
+  return [
+    move(ROOT, "x", 0, 0.03, 0, -0.014 * kick),
+    turn(ROOT, "z", 0, 0.03, 0, 0.045 * kick),
+    move(ROOT, "x", 0.03, 0.18, -0.014 * kick, 0),
+    turn(ROOT, "z", 0.03, 0.18, 0.045 * kick, 0)
+  ];
+};
+var hammerFall = (context) => context.parts.hammer && context.family !== "revolver" ? [turn("hammer", "z", 0, 0.02, 0, -0.5), turn("hammer", "z", 0.05, 0.06, -0.5, 0)] : [];
+function shotClip(id, context, locked) {
+  const { parts, family } = context;
+  const tweens = [...pullTrigger(context), ...recoil(context), ...hammerFall(context)];
+  const events = [cue(0, "muzzle_flash")];
+  if (BLOWBACK.has(family)) {
+    const part = blowbackPart(context);
+    const travel = strokeOf(parts);
+    if (parts[part]) {
+      tweens.push(move(part, "x", 0, 0.025, 0, travel));
+      if (!locked) tweens.push(move(part, "x", 0.025, 0.045, travel, 0));
+    }
+    events.push(cue(0.012, "eject_casing", { down: family === "p90" || family === "belt" }));
+  } else if (family === "revolver" && parts.cylinder && parts.hammer) {
+    tweens.push(turn("cylinder", "x", 0, 0.05, 0, Math.PI / 3), turn("hammer", "z", 0, 0.05, 0, 0.5), turn("hammer", "z", 0.05, 0.03, 0.5, -0.5), turn("hammer", "z", 0.12, 0.08, -0.5, 0));
+  }
+  return composeClip(id, tweens, events);
+}
+function shotClips(context) {
+  const clips = [shotClip("shot", context, false)];
+  if (context.family === "pistol") clips.push(shotClip("shot_last", context, true));
+  return clips;
+}
+var dudTweens = (context) => [...pullTrigger(context), ...context.parts.hammer ? [turn("hammer", "z", 0, 0.03, 0, -0.5)] : []];
+function misfireClip(context) {
+  const tweens = dudTweens(context);
+  if (context.family === "revolver" && context.parts.cylinder) tweens.push(turn("cylinder", "x", 0, 0.07, 0, Math.PI / 3));
+  return composeClip("misfire", tweens);
+}
+var emptyClip = (context) => composeClip("empty", pullTrigger(context));
+function faultClips(context) {
+  const { parts, family } = context;
+  const misfire = composeClip("fault_misfire", dudTweens(context));
+  const part = blowbackPart(context);
+  if (!BLOWBACK.has(family) || !parts[part]) return [misfire];
+  const travel = strokeOf(parts);
+  const stopped = Object.entries(FAULT_SLIDE_BACK).map(
+    ([fault, back]) => composeClip(`fault_${fault}`, [move(part, "x", 0, 0.025, 0, travel), move(part, "x", 0.025, 0.04, travel, travel * back)], fault === "stovepipe" ? [cue(0.03, "stuck_case")] : [], 0.25)
+  );
+  return [misfire, ...stopped];
+}
+function safetyClips(context) {
+  if (!context.parts.safety) return [];
+  return [composeClip("safety_on", [turn("safety", "z", 0, 0.12, 0, -0.6)]), composeClip("safety_off", [turn("safety", "z", 0, 0.12, -0.6, 0)]), composeClip("mode", [turn("safety", "z", 0, 0.07, 0, 0.4), turn("safety", "z", 0.07, 0.07, 0.4, 0)])];
+}
+var drawClip = () => composeClip("draw", [move(ROOT, "y", 0, 0.35, -0.1, 0), turn(ROOT, "z", 0, 0.35, -0.6, 0)]);
+
+// src/animation/clip-set.ts
+function buildToolClips(context) {
+  const clips = [
+    ...shotClips(context),
+    misfireClip(context),
+    emptyClip(context),
+    cycleClip(context),
+    ...reloadClips(context),
+    feedClip(context),
+    ...faultClips(context),
+    ...clearClips(context),
+    ...safetyClips(context),
+    drawClip()
+  ];
+  const set = {};
+  for (const clip of clips) if (clip) set[clip.id] = clip;
+  return set;
+}
+
+// src/audio/host-events.ts
+var weaponEventOf = (event) => {
+  switch (event.type) {
+    case "misfire":
+      return { type: "misfire", at: 0 };
+    case "stage":
+      return { type: "reload_stage", stage: event.stage, at: 0 };
+    case "empty":
+    case "feed":
+      return { type: event.type, at: 0 };
+    case "cycle":
+      return { type: "cycle", phase: event.phase, at: 0 };
+    case "mode":
+      return { type: "mode", mode: event.mode, at: 0 };
+    case "fault":
+      return { type: "fault", fault: event.fault, at: 0 };
+    case "clear":
+      return { type: "clear", fault: event.fault, phase: event.phase, at: 0 };
+    case "safety":
+      return { type: "safety", on: event.on, at: 0 };
+    default:
+      return void 0;
+  }
+};
+
+// src/models/condition.ts
+var substitutions = (kit, condition) => {
+  const { M } = kit;
+  if (condition === "rusty")
+    return /* @__PURE__ */ new Map([
+      [M.metal, M.rust],
+      [M.dark, M.rustD],
+      [M.steel, M.rust],
+      [M.steelL, M.rust]
+    ]);
+  if (condition === "worn")
+    return /* @__PURE__ */ new Map([
+      [M.metal, M.worn],
+      [M.dark, M.worn]
+    ]);
+  return null;
+};
+function applyCondition(kit, model, condition) {
+  const replacement = substitutions(kit, condition);
+  const glowing = new Set(model.parts.glow);
+  const paint = condition === "rusty" ? kit.M.rust.color : condition === "worn" ? kit.M.worn.color : void 0;
+  model.root.traverse((object) => {
+    var _a, _b;
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    (_a = mesh.userData).baseMaterial ?? (_a.baseMaterial = mesh.material);
+    const base = mesh.userData.baseMaterial;
+    if (glowing.has(mesh)) {
+      const material = mesh.material;
+      (_b = mesh.userData).baseColor ?? (_b.baseColor = material.color.clone());
+      material.color.copy(paint ?? mesh.userData.baseColor);
+      return;
+    }
+    mesh.material = replacement?.get(base) ?? base;
+  });
+}
+
+// src/models/cartridge.ts
+var BOTTLENECK_RATIO = 0.8;
+function cartridgeShape(caliber, dims) {
+  if (caliber.caseType === "shell" || caliber.rim === "shell") return "shell";
+  if (caliber.rim === "rimfire") return "rim";
+  const isRimmed = caliber.rim === "rimmed";
+  const isBottleneck = dims.projectileDiameter / dims.caseDiameter < BOTTLENECK_RATIO;
+  if (isBottleneck) return isRimmed ? "rr" : "r";
+  return isRimmed ? "rimp" : "p";
+}
+function buildCartridge(kit, dims, shape) {
+  const { M, cylinderY } = kit;
+  const group = kit.group();
+  const radius = dims.caseDiameter / 2;
+  const bulletRadius = dims.projectileDiameter / 2;
+  const caseLength = dims.caseLength;
+  if (shape === "shell") {
+    cylinderY(group, radius, caseLength * 0.8, M.shell, 0, caseLength * 0.6, 0, 14);
+    cylinderY(group, radius * 1.03, caseLength * 0.22, M.brass, 0, caseLength * 0.11, 0, 14);
+    cylinderY(group, radius * 1.08, 1.2, M.brass, 0, 0.6, 0, 14);
+    return group;
+  }
+  if (shape === "rim" || shape === "rimp" || shape === "rr") cylinderY(group, radius * 1.15, 1.2, M.brass, 0, 0.6, 0, 14);
+  const extra = dims.overallLength - caseLength;
+  if (shape === "r" || shape === "rr") {
+    const bodyHeight = caseLength * 0.78;
+    const shoulder = caseLength * 0.08;
+    const neck = caseLength - bodyHeight - shoulder;
+    const neckRadius = bulletRadius + 0.35;
+    cylinderY(group, radius, bodyHeight, M.brass, 0, bodyHeight / 2, 0, 14);
+    cylinderY(group, neckRadius, shoulder, M.brass, 0, bodyHeight + shoulder / 2, 0, 14, radius);
+    cylinderY(group, neckRadius, neck, M.brass, 0, bodyHeight + shoulder + neck / 2, 0, 14);
+    cylinderY(group, bulletRadius, extra * 0.3, M.copper, 0, caseLength + extra * 0.15, 0, 14);
+    cylinderY(group, bulletRadius, extra * 0.7, M.copper, 0, caseLength + extra * 0.3 + extra * 0.35, 0, 14, bulletRadius * 0.12);
+    return group;
+  }
+  const bullet = shape === "rim" || shape === "rimp" ? M.lead : M.copper;
+  cylinderY(group, radius, caseLength, M.brass, 0, caseLength / 2, 0, 14);
+  cylinderY(group, bulletRadius, extra * 0.45, bullet, 0, caseLength + extra * 0.225, 0, 14);
+  cylinderY(group, bulletRadius, extra * 0.55, bullet, 0, caseLength + extra * 0.45 + extra * 0.275, 0, 14, bulletRadius * 0.45);
+  return group;
+}
+function buildCasing(kit, dims, shape) {
+  const { M, cylinderX } = kit;
+  const group = kit.group();
+  const radius = dims.caseDiameter / 2e3;
+  const length = dims.caseLength / 1e3;
+  if (shape === "shell") {
+    const scale = length / 0.07;
+    cylinderX(group, 0.0105 * scale, 0.05 * scale, M.shell, 8e-3 * scale, 0, 0, 14);
+    cylinderX(group, 0.011 * scale, 0.016 * scale, M.brass, -0.025 * scale, 0, 0, 14);
+    return { group, radius: 0.0105 * scale, length };
+  }
+  if (shape === "r" || shape === "rr") {
+    cylinderX(group, radius, length * 0.75, M.brass, -length * 0.12, 0, 0, 12);
+    cylinderX(group, radius * 0.62, length * 0.25, M.brass, length * 0.37, 0, 0, 12, radius * 0.55);
+  } else cylinderX(group, radius, length, M.brass, 0, 0, 0, 12);
+  return { group, radius, length };
+}
+function buildRound(kit, dims, shape) {
+  const group = kit.group();
+  const cartridge = buildCartridge(kit, dims, shape);
+  cartridge.scale.setScalar(1e-3);
+  cartridge.rotation.z = -Math.PI / 2;
+  group.add(cartridge);
+  return { group, radius: dims.caseDiameter / 2e3 };
+}
+
+// src/fx/effects.ts
+var PI9 = Math.PI;
+var FLASH_BY_CASE = { shell: 1.6, big: 2.6, tiny: 0.5, pistol: 0.8, rifle: 1.2 };
+var FLASH_SECONDS = 0.055;
+function createEffects(kit, scene, particles, random) {
+  const { THREE, M } = kit;
+  const light = new THREE.PointLight(16756832, 0, 3, 2);
+  scene.add(light);
+  let flash = null;
+  const buildFlash = (size) => {
+    const group = new THREE.Group();
+    const cone = new THREE.Mesh(new THREE.ConeGeometry(0.013 * size, 0.085 * size, 10, 1, true), M.flashA);
+    cone.rotation.z = -PI9 / 2;
+    cone.position.x = 0.042 * size;
+    group.add(cone);
+    for (let i = 0; i < 4; i++) {
+      const angle = i * PI9 / 2 + random() * 0.6;
+      const spike = new THREE.Mesh(new THREE.ConeGeometry(5e-3 * size, 0.04 * size, 6), M.flashA);
+      spike.position.set(0.012 * size, Math.cos(angle) * 0.016 * size, Math.sin(angle) * 0.016 * size);
+      spike.rotation.set(angle, 0, 0);
+      spike.rotateZ(-PI9 / 2);
+      group.add(spike);
+    }
+    const core = new THREE.Mesh(new THREE.SphereGeometry(0.016 * size, 12, 8), M.flashB);
+    core.position.x = 8e-3 * size;
+    group.add(core);
+    return group;
+  };
+  const endFlash = () => {
+    if (!flash) return;
+    flash.group.removeFromParent();
+    flash.group.traverse((child) => {
+      const mesh = child;
+      if (mesh.isMesh) mesh.geometry.dispose();
+    });
+    flash = null;
+    light.intensity = 0;
+  };
+  const effects = {
+    muzzleFlash(position, orientation, size) {
+      endFlash();
+      const group = buildFlash(size);
+      group.position.copy(position);
+      group.quaternion.copy(orientation);
+      group.rotateX(random() * PI9);
+      scene.add(group);
+      flash = { group, age: 0 };
+      light.position.copy(position);
+      light.intensity = 4 * size;
+      light.distance = 2 * size;
+      for (let i = 0; i < 6; i++) {
+        const velocity = new THREE.Vector3(0.15 + random() * 0.35, 0.03 + random() * 0.12, (random() - 0.5) * 0.14).applyQuaternion(orientation);
+        effects.smoke(position, velocity, 0.013 * size, 1.3 + random() * 0.6, 0.45);
+      }
+    },
+    smoke(position, velocity, size, life, opacity) {
+      const puff = new THREE.Mesh(new THREE.SphereGeometry(size, 10, 8), M.smokeP.clone());
+      puff.position.copy(position);
+      particles.spawn(puff, velocity, { gravity: -0.08, life, fadeFrom: opacity, grow: 2.1, drag: 2.2, radius: -1, ownsGeometry: true });
+    },
+    update(dt) {
+      if (!flash) return;
+      flash.age += dt;
+      flash.group.scale.setScalar(0.6 + Math.min(1, flash.age / FLASH_SECONDS) * 0.9);
+      if (flash.age >= FLASH_SECONDS) endFlash();
+    },
+    dispose() {
+      endFlash();
+      light.removeFromParent();
+      light.dispose();
+    }
+  };
+  return effects;
+}
+
+// src/fx/heavy.ts
+var PI10 = Math.PI;
+var flameMaterials = (kit) => {
+  const { THREE } = kit;
+  return [
+    new THREE.MeshBasicMaterial({ color: 16742946, transparent: true, opacity: 0.9, depthWrite: false }),
+    new THREE.MeshBasicMaterial({ color: 16760896, transparent: true, opacity: 0.9, depthWrite: false }),
+    new THREE.MeshBasicMaterial({ color: 13121050, transparent: true, opacity: 0.8, depthWrite: false }),
+    new THREE.MeshBasicMaterial({ color: 16773296, transparent: true, opacity: 0.9, blending: THREE.AdditiveBlending, depthWrite: false })
+  ];
+};
+var spread = (context, x, y, z) => new context.kit.THREE.Vector3((context.random() - 0.5) * x, (context.random() - 0.5) * y, (context.random() - 0.5) * z);
+function createBits(context) {
+  const { kit, particles, random } = context;
+  const { THREE } = kit;
+  const palette = flameMaterials(kit);
+  return {
+    flame(position, velocity, size, life) {
+      const bit = new THREE.Mesh(new THREE.IcosahedronGeometry(size, 1), palette[Math.floor(random() * 4)].clone());
+      bit.position.copy(position);
+      bit.rotation.set(random() * 3, random() * 3, 0);
+      particles.spawn(bit, velocity, { gravity: -1.4, life, fadeFrom: 0.9, grow: 2.2, drag: 1.4, radius: -1, spin: new THREE.Vector3(3, 4, 2), ownsGeometry: true });
+    },
+    smoke(position, velocity, size, life, opacity) {
+      context.effects.smoke(position, velocity, size, life, opacity);
+    },
+    dispose: () => palette.forEach((material) => material.dispose())
+  };
+}
+function launchRocket(context) {
+  const { kit, scene, parts, random } = context;
+  const { THREE } = kit;
+  const bits = createBits(context);
+  const forward = context.forward();
+  const muzzle = context.positionOf(parts.muzzle);
+  const rear = context.positionOf(parts.rear);
+  for (let i = 0; i < 26; i++) bits.smoke(rear.clone(), forward.clone().multiplyScalar(-(1.5 + random() * 3)).add(spread(context, 1.4, 0.8, 1.4)), 0.03 + random() * 0.03, 1.8 + random() * 1.4, 0.5);
+  for (let i = 0; i < 14; i++) bits.flame(rear.clone(), forward.clone().multiplyScalar(-(2 + random() * 2)).add(spread(context, 1, 0.6, 1)), 0.02, 0.25);
+  const rocket = parts.makeRound ? parts.makeRound() : buildFlyingRocket(kit, parts.launcherType);
+  if (parts.round) parts.round.visible = false;
+  rocket.quaternion.copy(context.orientation());
+  rocket.position.copy(muzzle);
+  scene.add(rocket);
+  const exhaust = new THREE.Mesh(new THREE.ConeGeometry(0.018, 0.12, 8, 1, true), new THREE.MeshBasicMaterial({ color: 16760896, transparent: true, opacity: 0.9, depthWrite: false }));
+  exhaust.rotation.z = PI10 / 2;
+  exhaust.position.x = -0.08;
+  rocket.add(exhaust);
+  const light = new THREE.PointLight(16751168, 3, 2.5);
+  rocket.add(light);
+  context.every(
+    1.6,
+    (progress, dt) => {
+      const flight = progress * 1.6;
+      const distance = 1.2 * flight + (flight > 0.25 ? 9 * (flight - 0.25) ** 2 : 0);
+      rocket.position.copy(muzzle).addScaledVector(forward, distance);
+      rocket.rotation.x += 0.25 * dt * 60;
+      exhaust.scale.set(1, 0.6 + random() * 0.8, 1);
+      if (random() < 0.9) bits.smoke(rocket.position.clone().addScaledVector(forward, -0.12), spread(context, 0.1, 0, 0.1).setY(0.05), 0.02 + random() * 0.015, 2.2, 0.5);
+    },
+    () => {
+      rocket.removeFromParent();
+      exhaust.geometry.dispose();
+      exhaust.material.dispose();
+      light.dispose();
+      bits.dispose();
+    }
+  );
+}
+function flameJet(context, dt, scale) {
+  const { kit, particles, random, parts } = context;
+  const { THREE } = kit;
+  const bits = createBits(context);
+  const forward = context.forward();
+  const muzzle = context.positionOf(parts.muzzle);
+  const count = Math.floor(dt * 420 * scale);
+  for (let i = 0; i < count; i++) {
+    const speed = (2.2 + random() * 1.1) * scale;
+    bits.flame(muzzle.clone().addScaledVector(forward, random() * speed * Math.min(dt, 0.3)), forward.clone().multiplyScalar(speed).add(new THREE.Vector3((random() - 0.5) * 0.35, (random() - 0.3) * 0.3, (random() - 0.5) * 0.35)), 0.02 + random() * 0.022, 0.4 + random() * 0.35);
+  }
+  if (random() < 0.5) bits.smoke(muzzle.clone().addScaledVector(forward, 1.1 * scale + random() * 0.4), new THREE.Vector3(forward.x * 0.6, 0.35, forward.z * 0.6), 0.03, 1.6, 0.4);
+  if (random() < 0.18) {
+    const droplet = new THREE.Mesh(new THREE.SphereGeometry(6e-3, 6, 4), new THREE.MeshBasicMaterial({ color: 16742946 }));
+    droplet.position.copy(muzzle).addScaledVector(forward, 0.3 + random() * 0.5);
+    particles.spawn(droplet, forward.clone().multiplyScalar(1.2 * scale).add(new THREE.Vector3(0, 0.2, 0)), { life: 3, radius: 3e-3, ownsGeometry: true, onGround: (position) => groundFire(context, bits, position) });
+  }
+  bits.dispose();
+}
+function groundFire(context, bits, position) {
+  const { kit, scene, random } = context;
+  const { THREE } = kit;
+  const fire = new THREE.Group();
+  fire.position.set(position.x, context.groundAt(position.x, position.z) + 5e-3, position.z);
+  scene.add(fire);
+  const materials = flameMaterials(kit);
+  const flames = [0, 1, 2].map((index) => {
+    const flame = new THREE.Mesh(new THREE.ConeGeometry(0.02, 0.07, 6), materials[index % 2].clone());
+    flame.position.set((random() - 0.5) * 0.04, 0.035, (random() - 0.5) * 0.04);
+    fire.add(flame);
+    return flame;
+  });
+  let clock = 0;
+  context.every(
+    4,
+    (progress, dt) => {
+      clock += dt;
+      flames.forEach((flame, index) => flame.scale.set(1 - progress * 0.7, (0.6 + Math.sin(clock * 20 + index * 2) * 0.35) * (1 - progress), 1 - progress * 0.7));
+      if (random() < 0.08) bits.smoke(fire.position.clone().add(new THREE.Vector3(0, 0.08, 0)), new THREE.Vector3(0, 0.15, 0), 0.015, 1.2, 0.25);
+    },
+    () => {
+      fire.removeFromParent();
+      flames.forEach((flame) => {
+        flame.geometry.dispose();
+        flame.material.dispose();
+      });
+      materials.forEach((material) => material.dispose());
+    }
+  );
+}
+
+// src/fx/particles.ts
+var MAX_PARTICLES = 900;
+var FLOOR_FRICTION = 0.45;
+var disposeOwned = (object) => {
+  object.traverse((child) => {
+    const mesh = child;
+    if (mesh.isMesh) mesh.geometry.dispose();
+  });
+};
+function createParticles(THREE, scene, groundAt) {
+  let list = [];
+  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);
+  };
+  const api = {
+    spawn(object, velocity, options = {}) {
+      scene.add(object);
+      list.push({
+        object,
+        velocity,
+        spin: options.spin ?? new THREE.Vector3(),
+        age: 0,
+        resting: false,
+        life: options.life ?? 2,
+        gravity: options.gravity ?? 9.8,
+        bounce: options.bounce ?? 0.3,
+        drag: options.drag ?? 0,
+        radius: options.radius ?? 3e-3,
+        grow: options.grow ?? 0,
+        kind: options.kind ?? "other",
+        fadeFrom: options.fadeFrom,
+        onRest: options.onRest,
+        onGround: options.onGround,
+        ownsGeometry: options.ownsGeometry ?? false,
+        bounces: 0
+      });
+      const oldest = list[0];
+      if (list.length > MAX_PARTICLES && oldest) remove(oldest);
+    },
+    update(dt) {
+      for (const particle of [...list]) {
+        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));
+        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);
+        if (particle.radius < 0) continue;
+        const floor = groundAt(object.position.x, object.position.z) + particle.radius;
+        if (object.position.y >= floor || particle.velocity.y >= 0) continue;
+        if (particle.onGround) {
+          particle.onGround(object.position.clone());
+          remove(particle);
+          continue;
+        }
+        object.position.y = floor;
+        particle.velocity.y *= -particle.bounce;
+        particle.velocity.x *= FLOOR_FRICTION;
+        particle.velocity.z *= FLOOR_FRICTION;
+        particle.spin.multiplyScalar(FLOOR_FRICTION);
+        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);
+        }
+      }
+    },
+    count: (kind) => list.filter((particle) => particle.kind === kind).length,
+    dispose() {
+      for (const particle of [...list]) remove(particle);
+    }
+  };
+  return api;
+}
+
+// src/fx/rig.ts
+function createModelRig(model) {
+  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);
+    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);
+  };
+  return {
+    setPartPose(partId, pose) {
+      const part = registry.get(partId);
+      if (part) apply(part, pose);
+    },
+    setRootPose: (pose) => apply(model.root, pose)
+  };
+}
+
+// src/fx/session.ts
+var worldPositionOf = (session, part, out) => {
+  session.model.root.updateWorldMatrix(true, true);
+  return part.getWorldPosition(out);
+};
+var toWorld = (session, vector, scaled = false) => {
+  const quaternion = session.model.root.getWorldQuaternion(new session.kit.THREE.Quaternion());
+  const world = vector.clone().applyQuaternion(quaternion);
+  return scaled ? world.multiplyScalar(session.holderScale) : world;
+};
+
+// src/fx/viewmodel-events.ts
+var PI11 = Math.PI;
+var restFlat = (object) => {
+  object.rotation.x = 0;
+  object.rotation.z = 0;
+};
+function createClipEventHandler(world, session) {
+  const { kit, particles, effects, random } = world;
+  const { THREE } = kit;
+  const { parts, root } = session.model;
+  const vector = (x, y, z) => new THREE.Vector3(x, y, z);
+  const positionOf = (part) => worldPositionOf(session, part, new THREE.Vector3());
+  const reach = Math.max(0.55, Math.min(1.2, session.lengthMetres));
+  const throwCase = (mark, velocity, spin, tilt = 0) => {
+    if (!session.cartridge || !world.layers.casings) return;
+    const casing = buildCasing(kit, session.cartridge.dims, session.cartridge.shape);
+    casing.group.position.copy(positionOf(mark));
+    casing.group.rotation.set(0, random() * 0.6 - 0.3, tilt);
+    particles.spawn(casing.group, velocity, { kind: "casing", life: 25, radius: casing.radius, bounce: 0.35, spin, onRest: restFlat, ownsGeometry: true });
+  };
+  const ejectFromPort = (down) => {
+    if (!parts.eject) return;
+    const local = down ? vector((random() - 0.5) * 0.3, -0.4, (random() - 0.5) * 0.3) : vector(-0.2 - random() * 0.4, (0.9 + random() * 0.5) * reach, (1 + random() * 0.6) * reach);
+    throwCase(parts.eject, toWorld(session, local), vector(random() * 30, random() * 30, random() * 30));
+  };
+  const ejectAll = (marks, spent) => {
+    marks?.forEach((mark, index) => {
+      const { velocity, spin, tilt } = spent(index);
+      throwCase(mark, toWorld(session, velocity), spin, tilt);
+    });
+  };
+  const moveIn = (from, to, tilt) => {
+    if (!session.cartridge) return;
+    const { group } = buildRound(kit, session.cartridge.dims, session.cartridge.shape);
+    const start = root.worldToLocal(from.clone());
+    const end = root.worldToLocal(to.clone());
+    group.rotation.z = tilt;
+    group.position.copy(start);
+    root.add(group);
+    world.schedule(0, 0.24, (eased) => group.position.lerpVectors(start, end, eased), () => {
+      group.removeFromParent();
+      group.traverse((child) => {
+        const mesh = child;
+        if (mesh.isMesh) mesh.geometry.dispose();
+      });
+    });
+  };
+  const offsetFrom = (point, x, y, z) => point.clone().add(toWorld(session, vector(x, y, z), true));
+  const feedRound = (from, next) => {
+    if (from === "loadPort" && parts.loadPort) {
+      const port = positionOf(parts.loadPort);
+      moveIn(offsetFrom(port, -0.03, -0.08, 0.07), port, 0.25);
+    } else if (from === "topLoad" && parts.topLoad) {
+      const point = positionOf(parts.topLoad);
+      moveIn(offsetFrom(point, 0, 0.07, 0), point, 0);
+    } else if (from === "chambers" && parts.chambers) {
+      const marks = next ? [parts.chambers[session.nextChamber++ % parts.chambers.length]] : parts.chambers;
+      for (const mark of marks) {
+        if (!mark) continue;
+        const point = positionOf(mark);
+        moveIn(offsetFrom(point, -0.07, 0, 0), offsetFrom(point, 6e-3, 0, 0), 0);
+      }
+    } else if (from === "breech" && parts.breech) {
+      for (const mark of parts.breech) {
+        const point = positionOf(mark);
+        moveIn(offsetFrom(point, -0.09, 0.05, 0), offsetFrom(point, 0.02, -0.01, 0), -0.5);
+      }
+    }
+  };
+  const dropMagazine = (up) => {
+    if (!parts.mag || !world.layers.magazines) return;
+    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, PI11 / 2) });
+  };
+  const stuckCase = () => {
+    if (!session.cartridge || !parts.eject) return;
+    const casing = buildCasing(kit, session.cartridge.dims, session.cartridge.shape);
+    const at = root.worldToLocal(offsetFrom(positionOf(parts.eject), 0, casing.length * 0.35, 0));
+    casing.group.position.copy(at);
+    casing.group.rotation.set(0, 0, PI11 / 2 - 0.25);
+    root.add(casing.group);
+    session.stuckCase = casing.group;
+  };
+  const flyJam = (jam) => {
+    const stuck = session.stuckCase;
+    session.stuckCase = null;
+    if (stuck) {
+      root.updateWorldMatrix(true, true);
+      stuck.updateWorldMatrix(true, false);
+      stuck.matrixWorld.decompose(stuck.position, stuck.quaternion, stuck.scale);
+      particles.spawn(stuck, toWorld(session, vector(-0.2, 1.2, 1.3)), { kind: "casing", life: 25, radius: 6e-3, bounce: 0.3, spin: vector(9, 14, 7), onRest: restFlat, ownsGeometry: true });
+    } else if (jam === "misfire" && session.cartridge && parts.eject) {
+      const round2 = buildRound(kit, session.cartridge.dims, session.cartridge.shape);
+      round2.group.position.copy(positionOf(parts.eject));
+      particles.spawn(round2.group, toWorld(session, vector(-0.2, 1.1, 1.2)), { kind: "round", life: 25, radius: round2.radius, bounce: 0.3, spin: vector(8, 12, 6), onRest: restFlat, ownsGeometry: true });
+    } else ejectFromPort(false);
+  };
+  return (event) => {
+    const data = event.data ?? {};
+    switch (event.type) {
+      case "muzzle_flash":
+        if (parts.muzzle && world.layers.muzzleFlash) effects.muzzleFlash(positionOf(parts.muzzle), root.getWorldQuaternion(new THREE.Quaternion()), session.def.action.kind === "launcher" ? 2.2 : FLASH_BY_CASE[session.caseType]);
+        break;
+      case "eject_casing":
+        if (data.from === "chambers") ejectAll(parts.chambers, () => ({ velocity: vector(-0.5 - random() * 0.3, -0.1 + random() * 0.3, (random() - 0.5) * 0.25), spin: vector(10, 20, 5), tilt: 0 }));
+        else if (data.from === "breech") ejectAll(parts.breech, () => ({ velocity: vector(-1, 0.9, (random() - 0.5) * 0.2), spin: vector(3, 8, 12), tilt: -0.5 }));
+        else ejectFromPort(data.down === true);
+        break;
+      case "drop_magazine":
+        dropMagazine(data.up === true);
+        break;
+      case "move_in":
+        feedRound(String(data.from), data.next === true);
+        break;
+      case "stuck_case":
+        stuckCase();
+        break;
+      case "fly_jam":
+        flyJam(String(data.jam));
+        break;
+      case "show_round":
+        if (parts.round) parts.round.visible = true;
+        break;
+      case "drop_tube":
+        dropTube();
+        break;
+      case "seat_tube":
+        root.visible = true;
+        break;
+      case "breech_round":
+        breechRound();
+        break;
+      default:
+        break;
+    }
+  };
+  function dropTube() {
+    root.updateWorldMatrix(true, true);
+    const old = root.clone(true);
+    root.matrixWorld.decompose(old.position, old.quaternion, old.scale);
+    root.visible = false;
+    particles.spawn(old, toWorld(session, vector(0.2, 0.4, 0.6)), { life: 8, radius: 0.05, bounce: 0.2, spin: vector(0, 0.8, 2.5) });
+  }
+  function breechRound() {
+    const make = parts.makeRound;
+    if (!make) return;
+    const shell = make();
+    session.model.inner.add(shell);
+    shell.position.set(-0.25, 0, 0);
+    world.schedule(0.02, 0.4, (eased) => shell.position.x = -0.25 + 0.6 * eased, () => {
+      shell.removeFromParent();
+    });
+  }
+}
+
+// src/fx/viewmodel.ts
+var PI12 = Math.PI;
+var HAND_OFFSET2 = [0.2, -0.2, -0.42];
+var HEAT_DISPLAY_MAX_FALLBACK = 120;
+var LAUNCH_VOLUME = 0.6;
+var caliberOf = (arsenal, def) => def.action.kind === "firearm" ? arsenal.calibers.get(def.action.caliber) : void 0;
+function createViewmodel(options) {
+  const { THREE, scene, camera, arsenal, groundAt, audio } = options;
+  const kit = modelKit(THREE);
+  const random = createRng3(options.seed ?? 1);
+  const layers = options.layers ?? createLayers();
+  const distance = () => options.soundDistance?.() ?? 0;
+  const particles = createParticles(THREE, scene, groundAt);
+  particles.onBounce = (kind) => kind === "casing" ? audio?.clink() : kind === "magazine" ? audio?.thud() : void 0;
+  const effects = createEffects(kit, scene, particles, random);
+  const hand = new THREE.Group();
+  hand.name = "weapon-viewmodel";
+  scene.add(hand);
+  const holder = new THREE.Group();
+  holder.quaternion.setFromAxisAngle(new THREE.Vector3(0, 1, 0), PI12 / 2);
+  hand.add(holder);
+  let tasks = [];
+  let session = null;
+  let player = null;
+  let condition = options.condition ?? "new";
+  let lastAmmo = 0;
+  let smokeDebt = 0;
+  const world = {
+    kit,
+    scene,
+    particles,
+    effects,
+    random,
+    audio,
+    layers,
+    groundAt,
+    schedule: (delay, seconds, step, done) => void tasks.push({ delay, seconds, elapsed: 0, step: (progress) => step(ease(progress)), done })
+  };
+  const heatMax = arsenal.rules.heat.displayMax || HEAT_DISPLAY_MAX_FALLBACK;
+  const release = () => {
+    if (!session) return;
+    session.model.root.removeFromParent();
+    player = null;
+    session = null;
+    tasks = [];
+  };
+  const heavy = (current) => ({
+    kit,
+    scene,
+    particles,
+    effects,
+    random,
+    parts: current.model.parts,
+    forward: () => toWorld(current, new THREE.Vector3(1, 0, 0)).normalize(),
+    positionOf: (part) => worldPositionOf(current, part, new THREE.Vector3()),
+    orientation: () => current.model.root.getWorldQuaternion(new THREE.Quaternion()),
+    every: (seconds, step, done) => void tasks.push({ delay: 0, seconds, elapsed: 0, step, done }),
+    groundAt
+  });
+  const equip = (weapon) => {
+    const def = arsenal.weapons.get(weapon);
+    const model = def ? buildWeaponModelById(THREE, weapon) : void 0;
+    if (!def || !model) return false;
+    release();
+    const length = new THREE.Box3().setFromObject(model.root).getSize(new THREE.Vector3()).x;
+    const scale = length > 0.8 ? 0.55 : length > 0.4 ? 0.75 : 1;
+    holder.scale.setScalar(scale);
+    holder.position.set(0, 0, Math.min(0.25, 0.25 * length * scale));
+    holder.add(model.root);
+    const caliber = caliberOf(arsenal, def);
+    const dims = caliber?.cartridge;
+    session = {
+      id: weapon,
+      def,
+      model,
+      holderScale: scale,
+      lengthMetres: length,
+      caseType: caliber?.caseType ?? "rifle",
+      kit,
+      cartridge: caliber && dims ? { dims, shape: cartridgeShape(caliber, dims) } : null,
+      stuckCase: null,
+      nextChamber: 0
+    };
+    const action = def.action;
+    const reloadFamily = action.kind === "firearm" || action.kind === "flame" || action.kind === "launcher" ? action.family : void 0;
+    const rpm = action.kind === "firearm" ? action.rpm : 0;
+    player = createToolClipPlayer({
+      clips: buildToolClips({ parts: model.parts, family: model.parts.family, caseType: session.caseType, reloadFamily }),
+      rig: createModelRig(model),
+      onEvent: createClipEventHandler(world, session),
+      repeatInterval: () => rpm > 0 ? 60 / rpm : 0.1
+    });
+    applyCondition(kit, model, condition);
+    lastAmmo = options.tool?.().ammo ?? 0;
+    return true;
+  };
+  const place = () => {
+    const [x, y, z] = HAND_OFFSET2;
+    hand.position.set(x, y, z).applyQuaternion(camera.quaternion).add(camera.position);
+    hand.quaternion.copy(camera.quaternion);
+    hand.updateMatrixWorld(true);
+  };
+  const glow = (tool) => {
+    if (!session) return;
+    const heat = (tool?.heat ?? 0) * heatMax;
+    const level = Math.max(0, Math.min(1, (heat - 50) / 50));
+    for (const mesh of session.model.parts.glow) {
+      const material = mesh.material;
+      material.emissive.setRGB(level, 0.2 * level * level, 0.02 * level * level);
+      material.emissiveIntensity = 2.2 * level;
+    }
+  };
+  const handleShot = (current) => {
+    const action = current.def.action;
+    if (action.kind === "launcher") {
+      launchRocket(heavy(current));
+      audio?.play("explosion", LAUNCH_VOLUME, distance());
+    }
+    if (action.kind !== "firearm") return;
+    const caliber = caliberOf(arsenal, current.def);
+    if (!caliber) return;
+    audio?.shot(muzzleEnergy3(caliber) * (caliber.pellets ?? 1), current.def.category, { caliber, distance: distance() });
+  };
+  return {
+    equip,
+    unequip: release,
+    handle(event, tool) {
+      if (event.type === "explosion") return;
+      if (event.type === "tool") equip(event.weapon);
+      if (!session || !player || event.weapon !== session.id) return;
+      const current = session;
+      if (event.type === "shot") handleShot(current);
+      else if (event.type === "reload" && event.phase === "start") current.nextChamber = 0;
+      else if (event.type === "clear" && event.phase === "end") current.stuckCase = null;
+      const mechanical = weaponEventOf(event);
+      if (mechanical) audio?.event(mechanical);
+      const step = toolAnimationStep(event);
+      if (!step) return;
+      const last = step.type === "play" && step.clip === "shot" && current.model.parts.family === "pistol" && tool.ammo === 0;
+      player.apply(last ? { ...step, variant: "last" } : step);
+    },
+    update(dt) {
+      if (session) {
+        place();
+        player?.update(dt);
+        const tool = options.tool?.();
+        glow(tool);
+        if (tool && session.def.action.kind === "flame") {
+          if (tool.ammo < lastAmmo) flameJet(heavy(session), dt, session.model.parts.launcherType === "flame" ? 1 : 0.6);
+          lastAmmo = tool.ammo;
+        }
+        if (tool && tool.heat !== void 0 && tool.heat * heatMax > 10 && session.model.parts.muzzle) {
+          smokeDebt += dt * tool.heat * heatMax * 0.1;
+          while (smokeDebt > 1) {
+            smokeDebt -= 1;
+            const k = 0.5 + tool.heat * heatMax / 60;
+            effects.smoke(worldPositionOf(session, session.model.parts.muzzle, new THREE.Vector3()), new THREE.Vector3((random() - 0.5) * 0.03, 0.07 + random() * 0.08, (random() - 0.5) * 0.03), 7e-3 * k, 1.6 + random(), Math.min(0.42, 0.14 + k * 0.1));
+          }
+        }
+      }
+      for (const task of [...tasks]) {
+        task.elapsed += dt;
+        if (task.elapsed < task.delay) continue;
+        const progress = task.seconds > 0 ? Math.min(1, (task.elapsed - task.delay) / task.seconds) : 1;
+        task.step(progress, dt);
+        if (progress >= 1) {
+          task.done?.();
+          tasks = tasks.filter((other) => other !== task);
+        }
+      }
+      effects.update(dt);
+      particles.update(dt);
+    },
+    setCondition(next) {
+      condition = next;
+      if (session) applyCondition(kit, session.model, condition);
+    },
+    get inHand() {
+      return session?.id ?? null;
+    },
+    get casings() {
+      return particles.count("casing");
+    },
+    get magazines() {
+      return particles.count("magazine");
+    },
+    dispose() {
+      release();
+      particles.dispose();
+      effects.dispose();
+      hand.removeFromParent();
+    }
+  };
+}
+
+// src/fx.ts
+function createWeaponFx(options) {
+  const layers = options.layers ?? createLayers();
+  const box2 = createBoxFx({ ...options, layers });
+  const model = createViewmodel({
+    layers,
+    ...options.soundDistance ? { soundDistance: options.soundDistance } : {},
+    THREE: options.THREE,
+    scene: options.scene,
+    camera: options.camera,
+    arsenal: options.arsenal,
+    groundAt: options.groundAt,
+    audio: options.audio ?? null,
+    ...options.seed === void 0 ? {} : { seed: options.seed },
+    ...options.tool ? { tool: options.tool } : {},
+    ...options.condition ? { condition: options.condition } : {}
+  });
+  return {
+    handle(event, tool) {
+      if (event.type === "explosion") return;
+      if (event.type === "tool") {
+        if (hasWeaponModel(event.weapon)) box2.unequip();
+        else model.unequip();
+      }
+      if (model.inHand !== null || event.type === "tool" && hasWeaponModel(event.weapon)) model.handle(event, tool);
+      else box2.handle(event, tool);
+    },
+    update(dt) {
+      box2.update(dt);
+      model.update(dt);
+    },
+    setCondition: (condition) => model.setCondition(condition),
+    layers,
+    get inHand() {
+      return model.inHand ?? box2.inHand;
+    },
+    get casings() {
+      return box2.casings + model.casings;
+    },
+    get magazines() {
+      return box2.magazines + model.magazines;
+    },
+    dispose() {
+      box2.dispose();
+      model.dispose();
+    }
+  };
+}
+
+// src/world-explosives.ts
+var WORLD_EXPLOSIVE_PREFIX = "world_";
+var SHAPES2 = {
+  fuel_barrel: { shape: { kind: "cylinder", radius: 0.3, height: 0.9 }, position: [0, 0.45, 0], color: 3104666 },
+  propane_p13: { shape: { kind: "cylinder", radius: 0.15, height: 0.48 }, position: [0, 0.24, 0], color: 13620184 },
+  car_fuel_tank: { shape: { kind: "box", size: [0.9, 0.25, 0.5] }, position: [0, 0.4, 0], color: 4935509 }
+};
+var WORLD_EXPLOSIVE_IDS = Object.keys(SHAPES2);
+var SHELL = { thickness: 1e-3, fill: 0.03 };
+var explosivePart = (def, shape) => ({
+  id: "tank",
+  material: "steel",
+  shape: shape.shape,
+  position: shape.position,
+  ...SHELL,
+  explodes: { energy: def.energy, radius: def.injuryRadius, ...def.chain ? { chain: { ...def.chain } } : {} }
+});
+var meshOf = (THREE, shape) => {
+  const geometry = shape.shape.kind === "cylinder" ? new THREE.CylinderGeometry(shape.shape.radius, shape.shape.radius, shape.shape.height, 16) : shape.shape.kind === "box" ? new THREE.BoxGeometry(...shape.shape.size) : new THREE.SphereGeometry(0.2);
+  const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color: shape.color, roughness: 0.55, metalness: 0.5 }));
+  mesh.name = "tank";
+  mesh.userData.destructionPart = "tank";
+  mesh.position.set(...shape.position);
+  mesh.castShadow = true;
+  mesh.receiveShadow = true;
+  return mesh;
+};
+var worldExplosiveItem = (def, name) => {
+  const shape = SHAPES2[def.id];
+  if (!shape) return void 0;
+  const spec = { name, parts: [explosivePart(def, shape)], joints: [], tags: ["explosive"] };
+  return {
+    id: `${WORLD_EXPLOSIVE_PREFIX}${def.id}`,
+    name,
+    build: (THREE) => {
+      const group = new THREE.Group();
+      group.add(meshOf(THREE, shape));
+      return group;
+    },
+    spec
+  };
+};
+
 // src/area.ts
 var WEAPON_ITEM_PREFIX = "weapon_";
 var COUNTER_ITEM_ID = "counter_weapons";
+var EXPLOSION_VOLUME_BASE = 0.4;
+var EXPLOSION_VOLUME_PER_METRE = 0.04;
+var SOUND_DISTANCE_MAX = 200;
+var FUSE_LENGTH_MAX = 1;
+var DEFAULT_FUSE_LENGTH = 0.03;
 var COUNTER = { length: 4.8, depth: 1.6, height: 0.9 };
 var COUNTER_X = [-6.5, -9, -11.5];
-var COUNTER_Z = -1;
-var END_MARGIN = 0.6;
-var SLOT_GAP = 0.3;
+var COUNTER_Z = [-1, 5.5];
+var END_MARGIN = 0.5;
+var DEFAULT_PITCH = 0.16;
+var PITCH_BY_ID = { browning_m2: 0.5, m2_flamethrower: 0.45, bow: 0.3, crossbow: 0.3 };
+var WORLD_EXPLOSIVES = [
+  { id: "fuel_barrel", at: [10, 0, -8] },
+  { id: "fuel_barrel", at: [11.2, 0, -8] },
+  { id: "propane_p13", at: [10.6, 0, -9.3] },
+  { id: "car_fuel_tank", at: [8.6, 0, -9.3] }
+];
 var TARGETS = [
   { id: "target_steel_plate", at: [-1.5, 0, -7] },
   { id: "target_plywood", at: [0, 0, -7] },
@@ -362,7 +4363,20 @@ var TEXT = {
     counter: "Weapon counter",
     targets: { target_steel_plate: "Steel plate target", target_plywood: "Plywood target", target_concrete: "Concrete block target" },
     reloadStart: "Reload started: {weapon} ({ammo}/{capacity})",
-    reloadEnd: "Reload done: {weapon} ({ammo}/{capacity})"
+    reloadEnd: "Reload done: {weapon} ({ammo}/{capacity})",
+    worldExplosives: { fuel_barrel: "Fuel barrel", propane_p13: "Propane cylinder (P13)", car_fuel_tank: "Car fuel tank" },
+    condition: "Weapon condition",
+    conditionHint: "Wear of the weapon: it jams more and the metal shows it",
+    conditions: { new: "New", used: "Used", worn: "Worn", rusty: "Rusty" },
+    ammoQuality: "Ammunition",
+    ammoQualityHint: "Reloaded rounds misfire more often",
+    ammoQualities: { factory: "Factory", reloaded: "Reloaded" },
+    soundDistance: "Sound distance",
+    soundDistanceHint: "How far the listener is from the shot: farther is quieter and duller",
+    fuseLength: "Dynamite fuse length",
+    fuseLengthHint: "Metres of safety fuse (131 s per metre): a long one is set down lit, for a delayed trap",
+    layers: { muzzle_flash: "Muzzle flash", casings: "Ejected casings", magazines: "Dropped magazines" },
+    metrics: { casings_live: "Casings in the scene", magazines_live: "Magazines in the scene", heat: "Barrel heat" }
   },
   "pt-BR": {
     group: "Armas",
@@ -370,7 +4384,20 @@ var TEXT = {
     counter: "Balc\xE3o de armas",
     targets: { target_steel_plate: "Alvo: chapa de a\xE7o", target_plywood: "Alvo: compensado", target_concrete: "Alvo: bloco de concreto" },
     reloadStart: "Recarga iniciada: {weapon} ({ammo}/{capacity})",
-    reloadEnd: "Recarga completa: {weapon} ({ammo}/{capacity})"
+    reloadEnd: "Recarga completa: {weapon} ({ammo}/{capacity})",
+    worldExplosives: { fuel_barrel: "Barril de combust\xEDvel", propane_p13: "Botij\xE3o de g\xE1s (P13)", car_fuel_tank: "Tanque de combust\xEDvel do carro" },
+    condition: "Estado da arma",
+    conditionHint: "Desgaste da arma: trava mais e o metal mostra",
+    conditions: { new: "Nova", used: "Usada", worn: "Gasta", rusty: "Enferrujada" },
+    ammoQuality: "Muni\xE7\xE3o",
+    ammoQualityHint: "Muni\xE7\xE3o recarregada falha mais",
+    ammoQualities: { factory: "De f\xE1brica", reloaded: "Recarregada" },
+    soundDistance: "Dist\xE2ncia do som",
+    soundDistanceHint: "Qu\xE3o longe o ouvinte est\xE1 do tiro: mais longe soa mais baixo e abafado",
+    fuseLength: "Pavio da dinamite",
+    fuseLengthHint: "Metros de pavio de seguran\xE7a (131 s por metro): um longo \xE9 posto no ch\xE3o aceso, para armadilha com atraso",
+    layers: { muzzle_flash: "Clar\xE3o do cano", casings: "C\xE1psulas ejetadas", magazines: "Pentes que caem" },
+    metrics: { casings_live: "C\xE1psulas na cena", magazines_live: "Pentes na cena", heat: "Calor do cano" }
   }
 };
 var textOf = (locale) => TEXT[locale] ?? TEXT.en;
@@ -412,6 +4439,18 @@ var targetProp = (id, name) => {
   };
   return { spec, colors: { post: 3816770, face: color } };
 };
+var weaponItem = (def, name) => {
+  const id = `${WEAPON_ITEM_PREFIX}${def.id}`;
+  if (!hasWeaponModel(def.id)) return asItem(id, name, weaponProp(def, name), { weapon: def.id, movable: true });
+  return {
+    id,
+    name,
+    build: (THREE) => buildModeledProp(THREE, def, name),
+    spec: (root) => modeledPropSpec(root, def, name),
+    weapon: def.id,
+    movable: true
+  };
+};
 var asItem = (id, name, prop, extra = {}) => ({
   id,
   name,
@@ -419,26 +4458,47 @@ var asItem = (id, name, prop, extra = {}) => ({
   spec: prop.spec,
   ...extra
 });
-function weaponsLayout(weaponItemIds) {
-  const perCounter = Math.floor((COUNTER.length - 2 * END_MARGIN) / SLOT_GAP) + 1;
-  const counters = COUNTER_X.slice(0, Math.max(1, Math.ceil(weaponItemIds.length / perCounter)));
-  const placements = counters.map((x) => ({ item: COUNTER_ITEM_ID, position: [x, 0, COUNTER_Z], surface: { halfSize: [COUNTER.depth / 2, COUNTER.length / 2], height: COUNTER.height } }));
-  weaponItemIds.forEach((item, index) => {
-    const x = counters[Math.min(counters.length - 1, Math.floor(index / perCounter))];
-    const z = COUNTER_Z - COUNTER.length / 2 + END_MARGIN + index % perCounter * SLOT_GAP;
-    placements.push({ item, position: [x, COUNTER.height + 0.01, z], asleep: true });
-  });
-  for (const target of TARGETS) placements.push({ item: target.id, position: target.at });
-  return placements;
+function weaponsLayout(weaponItemIds, pitchOf = () => DEFAULT_PITCH) {
+  const usable = COUNTER.length - 2 * END_MARGIN;
+  const slots = COUNTER_Z.flatMap((z) => COUNTER_X.map((x) => ({ x, z })));
+  const counterOf = [];
+  const placements = [];
+  for (const item of weaponItemIds) {
+    const pitch = pitchOf(item);
+    let counter = counterOf[counterOf.length - 1];
+    if (!counter || counter.used + pitch > usable + 1e-9) {
+      const slot = slots[counterOf.length];
+      if (!slot) throw new Error(`weapons area: ${weaponItemIds.length} weapons do not fit on ${slots.length} counters of ${usable.toFixed(2)} m`);
+      if (pitch > usable + 1e-9) throw new Error(`weapons area: "${item}" takes ${pitch} m and a counter holds ${usable.toFixed(2)} m`);
+      counter = { ...slot, used: 0 };
+      counterOf.push(counter);
+    }
+    placements.push({ item, position: [counter.x, COUNTER.height + 0.01, counter.z - COUNTER.length / 2 + END_MARGIN + counter.used + pitch / 2], asleep: true });
+    counter.used += pitch;
+  }
+  const counters = counterOf.map(({ x, z }) => ({ item: COUNTER_ITEM_ID, position: [x, 0, z], surface: { halfSize: [COUNTER.depth / 2, COUNTER.length / 2], height: COUNTER.height } }));
+  const targets = TARGETS.map((target) => ({ item: target.id, position: target.at }));
+  const explosives = WORLD_EXPLOSIVES.map((explosive) => ({ item: `${WORLD_EXPLOSIVE_PREFIX}${explosive.id}`, position: explosive.at }));
+  return [...counters, ...placements, ...targets, ...explosives];
 }
 function createWeaponsTestModule(options = {}) {
   const locale = options.locale ?? "pt-BR";
   const arsenal = options.arsenal ?? createArsenal({ locale });
   const text = textOf(locale);
-  const audio = options.sound === false ? null : createWeaponAudio();
+  const audio = options.sound === false ? null : createWeaponAudio(void 0, options.seed === void 0 ? {} : { seed: options.seed });
   const weaponDefs = [...arsenal.weapons.values()].filter((def) => !BODY_ACTIONS.has(def.id));
-  const weaponIds = weaponDefs.map((def) => `${WEAPON_ITEM_PREFIX}${def.id}`);
+  const weaponIds = weaponDefs.filter((def) => !(def.id in ARCHETYPE_MODELS)).map((def) => `${WEAPON_ITEM_PREFIX}${def.id}`);
+  const pitchOf = (itemId) => PITCH_BY_ID[itemId.slice(WEAPON_ITEM_PREFIX.length)] ?? DEFAULT_PITCH;
+  const worldExplosives = WORLD_EXPLOSIVE_IDS.flatMap((id) => {
+    const def = arsenal.explosives.get(id);
+    const item = def ? worldExplosiveItem(def, text.worldExplosives[id] ?? id) : void 0;
+    return item ? [item] : [];
+  });
+  const worldExplosiveIds = new Set(worldExplosives.map((item) => item.id));
   let fx = null;
+  let host = null;
+  let soundDistance = 0;
+  const heatPercent = () => Math.min(100, (host?.tool().heat ?? 0) * 100);
   return {
     id: "weapons_area",
     name: text.name,
@@ -448,48 +4508,126 @@ function createWeaponsTestModule(options = {}) {
       return fx;
     },
     items: () => [
-      ...weaponDefs.map((def) => asItem(`${WEAPON_ITEM_PREFIX}${def.id}`, arsenal.name(def.id), weaponProp(def, arsenal.name(def.id)), { weapon: def.id, movable: true })),
+      ...weaponDefs.map((def) => weaponItem(def, arsenal.name(def.id))),
       asItem(COUNTER_ITEM_ID, text.counter, counterProp(text.counter), { movable: false }),
-      ...TARGETS.map((target) => asItem(target.id, text.targets[target.id], targetProp(target.id, text.targets[target.id]), { movable: false }))
+      ...TARGETS.map((target) => asItem(target.id, text.targets[target.id] ?? target.id, targetProp(target.id, text.targets[target.id] ?? target.id), { movable: false })),
+      ...worldExplosives
+    ],
+    area: () => ({
+      placements: weaponsLayout(weaponIds, pitchOf).filter((placement) => !placement.item.startsWith(WORLD_EXPLOSIVE_PREFIX) || worldExplosiveIds.has(placement.item)),
+      view: { eye: [-3.4, 1.9, 9.2], target: [-9, 0.9, 1.6] }
+    }),
+    controls: () => [
+      {
+        kind: "choice",
+        id: "condition",
+        name: text.condition,
+        hint: text.conditionHint,
+        options: arsenal.rules.conditions.map((entry) => ({ id: entry.id, name: text.conditions[entry.id] ?? entry.id })),
+        default: options.condition ?? arsenal.rules.defaultCondition
+      },
+      {
+        kind: "choice",
+        id: "ammo_quality",
+        name: text.ammoQuality,
+        hint: text.ammoQualityHint,
+        options: arsenal.rules.ammoQualities.map((entry) => ({ id: entry.id, name: text.ammoQualities[entry.id] ?? entry.id })),
+        default: arsenal.rules.defaultAmmoQuality
+      },
+      { kind: "number", id: "sound_distance", name: text.soundDistance, hint: text.soundDistanceHint, unit: "m", min: 0, max: SOUND_DISTANCE_MAX, step: 5, default: 0 },
+      { kind: "number", id: "fuse_length", name: text.fuseLength, hint: text.fuseLengthHint, unit: "m", min: 0.01, max: FUSE_LENGTH_MAX, step: 0.01, default: arsenal.explosives.get("dynamite")?.fuseLength ?? DEFAULT_FUSE_LENGTH }
     ],
-    area: () => ({ placements: weaponsLayout(weaponIds), view: { eye: [-3.4, 1.7, 2.6], target: [-9, 0.9, -1.2] } }),
-    attach(host) {
+    layers: () => ["muzzle_flash", "casings", "magazines"].map((id) => ({ id, name: text.layers[id] })),
+    metrics: () => [
+      { id: "casings_live", name: text.metrics.casings_live, read: () => fx?.casings ?? 0 },
+      { id: "magazines_live", name: text.metrics.magazines_live, read: () => fx?.magazines ?? 0 },
+      { id: "heat", name: text.metrics.heat, unit: "%", max: 100, digits: 0, read: heatPercent }
+    ],
+    attach(lent) {
+      host = lent;
       const created = createWeaponFx({
-        THREE: host.THREE,
-        scene: host.scene,
-        camera: host.camera,
+        THREE: lent.THREE,
+        scene: lent.scene,
+        camera: lent.camera,
         arsenal,
-        groundAt: host.groundAt,
-        audio
+        groundAt: lent.groundAt,
+        audio,
+        tool: lent.tool,
+        soundDistance: () => soundDistance,
+        ...options.condition ? { condition: options.condition } : {},
+        ...options.seed === void 0 ? {} : { seed: options.seed }
       });
       fx = created;
-      const offEvents = host.on((event) => {
-        const tool = host.tool();
+      const camera = lent.camera;
+      const offBench = lent.bench?.onChange((change) => {
+        if (change.kind === "layer") {
+          if (change.id === "muzzle_flash") created.layers.muzzleFlash = change.on;
+          else if (change.id === "casings") created.layers.casings = change.on;
+          else if (change.id === "magazines") created.layers.magazines = change.on;
+        } else if (change.kind === "control" && typeof change.value === "string") {
+          if (change.id === "condition") {
+            created.setCondition(change.value);
+            lent.configureTool?.({ condition: change.value });
+          } else if (change.id === "ammo_quality") lent.configureTool?.({ ammo_quality: change.value });
+        } else if (change.kind === "control" && change.id === "sound_distance" && typeof change.value === "number") soundDistance = change.value;
+        else if (change.kind === "control" && change.id === "fuse_length" && typeof change.value === "number") lent.configureTool?.({ fuse_length: String(change.value) });
+      });
+      const offEvents = lent.on((event) => {
+        if (event.type === "explosion") {
+          const away = Math.hypot(event.point[0] - camera.position.x, event.point[1] - camera.position.y, event.point[2] - camera.position.z);
+          audio?.play("explosion", Math.min(1, EXPLOSION_VOLUME_BASE + event.radius * EXPLOSION_VOLUME_PER_METRE), away);
+          return;
+        }
+        const tool = lent.tool();
         created.handle(event, tool);
-        if (event.type === "reload") host.log(fill(event.phase === "start" ? text.reloadStart : text.reloadEnd, { weapon: arsenal.name(event.weapon), ammo: tool.ammo, capacity: tool.capacity }), { weapon: event.weapon, phase: event.phase });
+        if (event.type === "reload") lent.log(fill(event.phase === "start" ? text.reloadStart : text.reloadEnd, { weapon: arsenal.name(event.weapon), ammo: tool.ammo, capacity: tool.capacity }), { weapon: event.weapon, phase: event.phase });
       });
-      const offFrame = host.onFrame((dt) => created.update(dt));
-      created.handle({ type: "tool", weapon: host.tool().weapon }, host.tool());
+      const offFrame = lent.onFrame((dt) => created.update(dt));
+      created.handle({ type: "tool", weapon: lent.tool().weapon }, lent.tool());
       return () => {
+        offBench?.();
         offEvents();
         offFrame();
         created.dispose();
         audio?.dispose();
         fx = null;
+        host = null;
       };
     }
   };
 }
 export {
+  ARCHETYPE_MODELS,
   BODY_ACTIONS,
+  CLASS_REFERENCE_ENERGY,
   COUNTER_ITEM_ID,
+  DEFAULT_ENERGY_CURVE,
+  GAME_DISTANCE_CURVE,
+  GAME_SOUND_CLASSES,
+  MECHANICAL_SOUNDS,
+  MODEL_ENTRIES,
   WEAPON_ITEM_PREFIX,
+  WORLD_EXPLOSIVE_IDS,
+  WORLD_EXPLOSIVE_PREFIX,
+  applyCondition,
+  buildCartridge,
+  buildCasing,
   buildProp,
+  buildRound,
+  buildToolClips,
   buildWeaponModel,
+  buildWeaponModelById,
+  cartridgeShape,
+  computeShotSound,
   createWeaponAudio,
   createWeaponFx,
   createWeaponsTestModule,
+  hasWeaponModel,
+  mechanicalSoundOf,
+  modelKit,
+  partRegistry,
   weaponProp,
-  weaponsLayout
+  weaponsLayout,
+  worldExplosiveItem
 };
 //# sourceMappingURL=index.js.map