@adatechnology/game-weapons-three 0.7.1 → 0.8.0

package/dist/index.js

@@ -219,7 +219,40 @@ var ACCESSORY_TEXT = {
     metrics: { mass: "Weapon mass", aim: "Time to the sights", fitted: "Accessories on the weapon", suppressed: "Suppressed" },
     yes: "yes",
     no: "no",
-    attachments: {},
+    attachments: {
+      suppressor: "Suppressor",
+      oil_filter_suppressor: "Improvised oil filter suppressor",
+      integral_suppressor: "Integral suppressor",
+      muzzle_brake: "Muzzle brake",
+      muzzle_brake_heavy: "Heavy muzzle brake",
+      compensator: "Compensator",
+      red_dot: "Red dot sight",
+      holographic_sight: "Holographic sight",
+      acog_4x: "ACOG 4x",
+      scope_3_9x: "Rifle scope 3-9x",
+      scope_6_24x: "Rifle scope 6-24x",
+      night_vision_scope: "Night vision scope",
+      thermal_scope: "Thermal scope",
+      integral_optic_1_5x: "Integral 1.5x optic of the AUG",
+      integral_optic_3x: "Integral 3x optic of the G36",
+      pso_1: "PSO-1 scope",
+      fixed_scope_10x: "Fixed 10x scope of the M24",
+      vertical_grip: "Vertical foregrip",
+      bipod: "Bipod",
+      m203: "M203 grenade launcher",
+      gp_25: "GP-25 grenade launcher",
+      ag36: "AG36 grenade launcher",
+      weapon_light: "Weapon light",
+      laser_sight: "Laser sight",
+      extended_magazine: "Extended magazine",
+      drum_magazine: "Drum magazine",
+      dual_coupler: "Dual magazine coupler",
+      sawn_off_barrel: "Sawn-off barrel",
+      long_barrel: "Long barrel",
+      sling: "Sling",
+      ammo_backpack: "Ammunition backpack",
+      tripod: "Tripod mount"
+    },
     fitRefused: "Could not change {mount} of {weapon}: {reason}",
     fitting: "Fitting {attachment} on {weapon} ({seconds} s)",
     removing: "Taking {attachment} off {weapon} ({seconds} s)",
@@ -598,6 +631,731 @@ function weaponRecipes(curve) {
   ];
 }
 
+// src/data/reload-sounds.json
+var reload_sounds_default = {
+  source: "Authored in the kit. The art scene delivered sfx for the magazine, the bolt and the shell (cena L1339-L1343, used here for mag_seat, charging_handle_release and shell_insert); the gallery draws no sound, so the other cues combine the same primitives (metal click, thud, filtered noise, tones) of game-audio. Each cue is played at the second the reload clip says, so it follows the animation and scales with the weapon's reload time.",
+  profiles: {
+    weight: {
+      light: {
+        pitch: 1.3,
+        gain: 0.85
+      },
+      medium: {
+        pitch: 1,
+        gain: 1
+      },
+      heavy: {
+        pitch: 0.78,
+        gain: 1.2
+      }
+    },
+    material: {
+      steel: {
+        pitch: 1,
+        gain: 1
+      },
+      polymer: {
+        pitch: 0.82,
+        gain: 0.8
+      }
+    }
+  },
+  comment: "Light: pistols and revolvers. Medium: rifles, SMGs, bolt guns. Heavy: shotguns, belt-fed guns, launchers. Steel is the default; the polymer frames are listed in `polymer`.",
+  weights: {
+    pistol: "light",
+    revolver: "light",
+    rifle: "medium",
+    semiint: "medium",
+    semi12: "heavy",
+    p90: "medium",
+    belt: "heavy",
+    pump: "heavy",
+    lever: "medium",
+    bolt: "medium",
+    boltmag: "medium",
+    break: "heavy",
+    rocket: "heavy",
+    flame: "heavy"
+  },
+  polymer: [
+    "glock_17",
+    "glock_18",
+    "glock_19",
+    "taurus_g2c",
+    "taurus_ts9",
+    "fn_five_seven",
+    "pistol_9mm",
+    "fn_p90",
+    "hk_ump_45"
+  ],
+  cues: {
+    mag_release: [
+      {
+        layer: "scene_tone",
+        at: 0,
+        wave: "square",
+        f: 2400,
+        f2: 1680,
+        d: 0.02,
+        vol: 0.3
+      },
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "highpass",
+        f: 3e3,
+        q: 0.7,
+        d: 0.03,
+        vol: 0.24
+      },
+      {
+        layer: "thud",
+        at: 0.02,
+        gain: 0.12,
+        frequency: 700
+      }
+    ],
+    mag_out: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 900,
+        q: 2,
+        d: 0.1,
+        vol: 0.3,
+        f2: 600
+      },
+      {
+        layer: "metal",
+        at: 0.08,
+        frequency: 1200,
+        gain: 0.2
+      }
+    ],
+    mag_insert: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 700,
+        q: 2,
+        d: 0.12,
+        vol: 0.3,
+        f2: 1100
+      }
+    ],
+    mag_seat: [
+      {
+        layer: "scene_tone",
+        at: 0,
+        wave: "square",
+        f: 1100,
+        f2: 770,
+        d: 0.02,
+        vol: 0.5
+      },
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "highpass",
+        f: 3e3,
+        q: 0.7,
+        d: 0.03,
+        vol: 0.4
+      },
+      {
+        layer: "scene_tone",
+        at: 0,
+        wave: "sine",
+        f: 320,
+        f2: 200,
+        d: 0.05,
+        vol: 0.35
+      },
+      {
+        layer: "thud",
+        at: 0.01,
+        gain: 0.18,
+        frequency: 600
+      }
+    ],
+    slide_release: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 900,
+        gain: 0.35
+      },
+      {
+        layer: "scene_tone",
+        at: 0.02,
+        wave: "square",
+        f: 2e3,
+        f2: 1400,
+        d: 0.02,
+        vol: 0.4
+      },
+      {
+        layer: "scene_noise",
+        at: 0.02,
+        type: "highpass",
+        f: 3e3,
+        q: 0.7,
+        d: 0.03,
+        vol: 0.32
+      },
+      {
+        layer: "thud",
+        at: 0.03,
+        gain: 0.25,
+        frequency: 500
+      }
+    ],
+    charging_handle_pull: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 1500,
+        q: 3,
+        d: 0.09,
+        vol: 0.3,
+        f2: 900
+      },
+      {
+        layer: "metal",
+        at: 0.06,
+        frequency: 1300,
+        gain: 0.25
+      }
+    ],
+    charging_handle_release: [
+      {
+        layer: "scene_tone",
+        at: 0,
+        wave: "square",
+        f: 2200,
+        f2: 1540,
+        d: 0.02,
+        vol: 0.4
+      },
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "highpass",
+        f: 3e3,
+        q: 0.7,
+        d: 0.03,
+        vol: 0.32
+      },
+      {
+        layer: "scene_tone",
+        at: 0.02,
+        wave: "square",
+        f: 2700,
+        f2: 1890,
+        d: 0.02,
+        vol: 0.4
+      },
+      {
+        layer: "scene_noise",
+        at: 0.02,
+        type: "highpass",
+        f: 3e3,
+        q: 0.7,
+        d: 0.03,
+        vol: 0.32
+      },
+      {
+        layer: "thud",
+        at: 0.03,
+        gain: 0.2,
+        frequency: 600
+      }
+    ],
+    bolt_lift: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1500,
+        gain: 0.3
+      },
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 2e3,
+        q: 3,
+        d: 0.04,
+        vol: 0.15,
+        f2: 1500
+      }
+    ],
+    bolt_pull: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 1400,
+        q: 3,
+        d: 0.12,
+        vol: 0.3,
+        f2: 800
+      },
+      {
+        layer: "metal",
+        at: 0.1,
+        frequency: 900,
+        gain: 0.3
+      }
+    ],
+    bolt_push: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 800,
+        q: 3,
+        d: 0.1,
+        vol: 0.3,
+        f2: 1400
+      },
+      {
+        layer: "metal",
+        at: 0.08,
+        frequency: 1100,
+        gain: 0.3
+      }
+    ],
+    bolt_lock: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1800,
+        gain: 0.4
+      },
+      {
+        layer: "thud",
+        at: 0.02,
+        gain: 0.2,
+        frequency: 700
+      }
+    ],
+    shell_insert: [
+      {
+        layer: "scene_tone",
+        at: 0,
+        wave: "square",
+        f: 1400,
+        f2: 980,
+        d: 0.02,
+        vol: 0.35
+      },
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "highpass",
+        f: 3e3,
+        q: 0.7,
+        d: 0.03,
+        vol: 0.28
+      },
+      {
+        layer: "scene_noise",
+        at: 0.02,
+        type: "bandpass",
+        f: 1200,
+        q: 3,
+        d: 0.05,
+        vol: 0.25
+      }
+    ],
+    pump_back: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 1e3,
+        q: 2,
+        d: 0.12,
+        vol: 0.3,
+        f2: 700
+      },
+      {
+        layer: "metal",
+        at: 0.1,
+        frequency: 900,
+        gain: 0.35
+      }
+    ],
+    pump_forward: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 700,
+        q: 2,
+        d: 0.1,
+        vol: 0.3,
+        f2: 1e3
+      },
+      {
+        layer: "metal",
+        at: 0.08,
+        frequency: 1300,
+        gain: 0.4
+      },
+      {
+        layer: "thud",
+        at: 0.1,
+        gain: 0.25,
+        frequency: 500
+      }
+    ],
+    lever_open: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1e3,
+        gain: 0.35
+      },
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 1200,
+        q: 3,
+        d: 0.08,
+        vol: 0.2,
+        f2: 800
+      }
+    ],
+    lever_close: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1500,
+        gain: 0.4
+      },
+      {
+        layer: "thud",
+        at: 0.02,
+        gain: 0.2,
+        frequency: 550
+      }
+    ],
+    cylinder_open: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1500,
+        gain: 0.3
+      },
+      {
+        layer: "scene_noise",
+        at: 0.02,
+        type: "bandpass",
+        f: 1800,
+        q: 3,
+        d: 0.08,
+        vol: 0.2,
+        f2: 1200
+      }
+    ],
+    cylinder_eject: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 2400,
+        gain: 0.25
+      },
+      {
+        layer: "metal",
+        at: 0.05,
+        frequency: 2800,
+        gain: 0.2
+      },
+      {
+        layer: "metal",
+        at: 0.11,
+        frequency: 3200,
+        gain: 0.15
+      }
+    ],
+    speedloader: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 1500,
+        q: 3,
+        d: 0.08,
+        vol: 0.25,
+        f2: 2e3
+      },
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 2e3,
+        gain: 0.25
+      },
+      {
+        layer: "metal",
+        at: 0.05,
+        frequency: 2400,
+        gain: 0.2
+      },
+      {
+        layer: "thud",
+        at: 0.07,
+        gain: 0.15,
+        frequency: 800
+      }
+    ],
+    cylinder_close: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1100,
+        gain: 0.45
+      },
+      {
+        layer: "thud",
+        at: 0.01,
+        gain: 0.2,
+        frequency: 500
+      }
+    ],
+    barrels_open: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1e3,
+        gain: 0.4
+      },
+      {
+        layer: "thud",
+        at: 0.03,
+        gain: 0.2,
+        frequency: 450
+      }
+    ],
+    casings_eject: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 2600,
+        gain: 0.25
+      },
+      {
+        layer: "metal",
+        at: 0.08,
+        frequency: 3e3,
+        gain: 0.2
+      }
+    ],
+    barrels_close: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1100,
+        gain: 0.5
+      },
+      {
+        layer: "thud",
+        at: 0.02,
+        gain: 0.3,
+        frequency: 450
+      }
+    ],
+    belt_cover_open: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 800,
+        gain: 0.4
+      },
+      {
+        layer: "thud",
+        at: 0.03,
+        gain: 0.2,
+        frequency: 500
+      }
+    ],
+    belt_insert: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1400,
+        gain: 0.3
+      },
+      {
+        layer: "metal",
+        at: 0.08,
+        frequency: 1800,
+        gain: 0.25
+      },
+      {
+        layer: "thud",
+        at: 0.1,
+        gain: 0.25,
+        frequency: 450
+      }
+    ],
+    belt_cover_close: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1e3,
+        gain: 0.45
+      },
+      {
+        layer: "thud",
+        at: 0.02,
+        gain: 0.3,
+        frequency: 400
+      }
+    ],
+    rocket_load: [
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 600,
+        q: 1.5,
+        d: 0.25,
+        vol: 0.3,
+        f2: 400
+      },
+      {
+        layer: "thud",
+        at: 0.2,
+        gain: 0.2,
+        frequency: 450
+      }
+    ],
+    rocket_seat: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 900,
+        gain: 0.45
+      },
+      {
+        layer: "thud",
+        at: 0.01,
+        gain: 0.35,
+        frequency: 350
+      }
+    ],
+    grenade_load: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1100,
+        gain: 0.35
+      },
+      {
+        layer: "scene_noise",
+        at: 0,
+        type: "bandpass",
+        f: 1e3,
+        q: 2,
+        d: 0.1,
+        vol: 0.2,
+        f2: 700
+      }
+    ],
+    breech_open: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1e3,
+        gain: 0.35
+      },
+      {
+        layer: "thud",
+        at: 0.03,
+        gain: 0.15,
+        frequency: 500
+      }
+    ],
+    breech_close: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 1100,
+        gain: 0.45
+      },
+      {
+        layer: "thud",
+        at: 0.02,
+        gain: 0.25,
+        frequency: 450
+      }
+    ],
+    tube_drop: [
+      {
+        layer: "thud",
+        at: 0,
+        gain: 0.35,
+        frequency: 380
+      },
+      {
+        layer: "metal",
+        at: 0.05,
+        frequency: 700,
+        gain: 0.2
+      }
+    ],
+    tube_seat: [
+      {
+        layer: "metal",
+        at: 0,
+        frequency: 900,
+        gain: 0.45
+      },
+      {
+        layer: "thud",
+        at: 0.02,
+        gain: 0.3,
+        frequency: 380
+      }
+    ]
+  }
+};
+
+// src/audio/reload-sounds.ts
+var RELOAD_CUE_IDS = Object.keys(reload_sounds_default.cues);
+var DEFAULT_SOUND_PROFILE = { weight: "medium", material: "steel" };
+var RELOAD_CUES = reload_sounds_default.cues;
+var polymer = new Set(reload_sounds_default.polymer);
+var weights = reload_sounds_default.weights;
+var soundProfileOf = (weaponId, modelFamily) => ({ weight: weights[modelFamily] ?? "medium", material: polymer.has(weaponId) ? "polymer" : "steel" });
+var reloadCueSteps = (id, profile = DEFAULT_SOUND_PROFILE, table = RELOAD_CUES) => {
+  const steps = table[id];
+  if (!steps) return [];
+  const weight = reload_sounds_default.profiles.weight[profile.weight];
+  const material = reload_sounds_default.profiles.material[profile.material];
+  const pitch = weight.pitch * material.pitch;
+  const gain = weight.gain * material.gain;
+  return steps.map((entry) => {
+    switch (entry.layer) {
+      case "metal":
+        return { ...entry, frequency: Math.round(entry.frequency * pitch), gain: entry.gain * gain };
+      case "thud":
+        return { ...entry, frequency: Math.round(entry.frequency * pitch), gain: entry.gain * gain };
+      case "scene_tone":
+        return { ...entry, f: Math.round(entry.f * pitch), ...entry.f2 === void 0 ? {} : { f2: Math.round(entry.f2 * pitch) }, vol: entry.vol * gain };
+      case "scene_noise":
+        return { ...entry, f: Math.round(entry.f * pitch), ...entry.f2 === void 0 ? {} : { f2: Math.round(entry.f2 * pitch) }, vol: entry.vol * gain };
+      default:
+        return entry;
+    }
+  });
+};
+
 // src/audio.ts
 var NOISE_SECONDS = 1.5;
 var DEFAULT_SEED = 1;
@@ -606,6 +1364,7 @@ function createWeaponAudio(volume = 0.6, options = {}) {
   const classes = { ...GAME_SOUND_CLASSES, ...options.classes };
   const distanceCurve = { ...GAME_DISTANCE_CURVE, ...options.distance };
   const mechanicalTable = { ...MECHANICAL_SOUNDS, ...options.mechanical };
+  const cueTable = { ...RELOAD_CUES, ...options.reloadCues };
   const shared = options.engine;
   const engine = shared ?? createAudioEngine({
     seed,
@@ -658,17 +1417,20 @@ function createWeaponAudio(volume = 0.6, options = {}) {
   const shotSound = (input) => computeShotSound(input, options);
   return {
     shot(energyJ, category, extras = {}) {
-      const sound2 = shotSound({ ...extras, energyJ, category });
-      if (!sound2.audible) return;
-      classBurstAt(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 });
+      const sound3 = shotSound({ ...extras, energyJ, category });
+      if (!sound3.audible) return;
+      classBurstAt(0, sound3.cutoff, sound3.gain, sound3.duration);
+      if (sound3.crack.gain > 0) burst({ seconds: sound3.crack.duration, gain: sound3.crack.gain, filter: "highpass", frequency: sound3.crack.cutoff });
+      tone({ seconds: sound3.body.duration, gain: sound3.body.gain, frequency: sound3.body.frequency, to: sound3.body.to });
     },
     shotSound,
     click() {
       mechanical("dry_fire");
     },
     mechanical,
+    cue(id, profile) {
+      for (const entry of reloadCueSteps(id, profile, cueTable)) step(entry);
+    },
     event(event) {
       const id = mechanicalSoundOf(event);
       if (id) mechanical(id);
@@ -717,7 +1479,7 @@ var VIEWMODEL_NODE_NAME = "weapon-viewmodel";
 var IN_HAND_NODE_NAME = "weapon-in-hand";
 var LASER_RAYCAST_HZ = 30;
 var isHeld = (object) => {
-  for (let node = object; node; node = node.parent) if (node.name === VIEWMODEL_NODE_NAME || node.name === IN_HAND_NODE_NAME) return true;
+  for (let node = object; node; node = node.parent) if (node.name === VIEWMODEL_NODE_NAME || node.name === IN_HAND_NODE_NAME || node.userData?.viewmodel === true) return true;
   return false;
 };
 var isVisibleInScene = (object) => {
@@ -747,8 +1509,144 @@ var createLaserRaycast = (THREE, scene, camera, options = {}) => {
   };
 };
 
+// src/fx/hand-hold.ts
+var HAND_HOLD = {
+  /** Half the width of a pistol grip, the palm sits this far (plus the palm) off its middle. */
+  gripHalfWidth: 0.0145,
+  /** Half the thickness of a palm. */
+  palm: 0.011,
+  /** How far up the grip the web of the hand sits from its middle. */
+  gripUp: 6e-3,
+  /** How far down the grip the supporting hand of a pistol sits from the middle. */
+  supportDown: 0.036,
+  /** Where along the handguard (0 the receiver, 1 the end of the forend) the supporting hand closes. */
+  forendAt: 0.6,
+  /** How far under the handguard the palm sits (half a handguard plus the palm). */
+  forendUnder: 0.034,
+  /** The grip of a long gun that has no drawn pistol grip: how far under the receiver the hand sits. */
+  strapUnder: 0.04,
+  /** How far lower than touching the palm hangs under a handguard, so the fingers close under it and not over it. */
+  forendDrop: 0.03,
+  /** How far (radians) the fingers of a support hand under a handguard rise from level. */
+  forendTilt: 0.5,
+  /** How far a handgun's support hand dips for the new magazine, along the grip. */
+  magDip: 0.045,
+  /** Closure of the fingers on a grip and on a forend (0 open, 1 closed). */
+  closed: 0.9,
+  forend: 0.6,
+  /** How fast the supporting hand goes to the magazine and back, per second. */
+  magRate: 7,
+  /** The hands shrink with the tool: a tool drawn at scale `s` takes hands at `s ** handScaleExponent`. */
+  handScaleExponent: 0.55
+};
+var handFrame = (THREE, x, y) => {
+  const ax = x.clone().normalize();
+  const az = ax.clone().cross(y).normalize();
+  const ay = az.clone().cross(ax);
+  return new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().makeBasis(ax, ay, az));
+};
+var poseOf = (anchor, rootQuaternion) => {
+  const position = anchor.part.localToWorld(anchor.offset.clone());
+  const q = rootQuaternion.clone().multiply(anchor.quaternion);
+  return { position: [position.x, position.y, position.z], quaternion: [q.x, q.y, q.z, q.w] };
+};
+var blendPose = (THREE, a, b, k) => {
+  const q = new THREE.Quaternion(...a.quaternion).slerp(new THREE.Quaternion(...b.quaternion), k);
+  return {
+    position: [a.position[0] + (b.position[0] - a.position[0]) * k, a.position[1] + (b.position[1] - a.position[1]) * k, a.position[2] + (b.position[2] - a.position[2]) * k],
+    quaternion: [q.x, q.y, q.z, q.w]
+  };
+};
+var targetsOf = (THREE, hold, rootQuaternion, magazine, weights2) => {
+  let right = hold.right ? poseOf(hold.right, rootQuaternion) : null;
+  let left = null;
+  if (hold.left) {
+    left = poseOf(hold.left, rootQuaternion);
+    if (hold.leftMagazine && magazine > 0) left = blendPose(THREE, left, poseOf(hold.leftMagazine, rootQuaternion), magazine);
+  }
+  hold.works?.forEach((work, index) => {
+    const k = weights2?.[index] ?? 0;
+    if (k <= 0) return;
+    const pose = poseOf(work.anchor, rootQuaternion);
+    if (work.hand === "R") right = right ? blendPose(THREE, right, pose, k) : pose;
+    else left = left ? blendPose(THREE, left, pose, k) : pose;
+  });
+  return { R: right, L: left, grip: hold.grip, gripL: hold.gripLeft, scale: hold.scale };
+};
+var V = (THREE, x, y, z) => new THREE.Vector3(x, y, z);
+var gripFrame = (THREE, up, side) => {
+  const forward = V(THREE, 1, 0, 0);
+  const toSide = V(THREE, 0, 0, 1);
+  const tilt = new THREE.Quaternion().setFromUnitVectors(V(THREE, 0, 1, 0), up);
+  return handFrame(THREE, forward.clone().applyQuaternion(tilt), toSide.clone().applyQuaternion(tilt).multiplyScalar(side));
+};
+var forendFrame = (THREE, tilt = 0) => handFrame(THREE, V(THREE, 0, Math.sin(tilt), Math.cos(tilt)), V(THREE, 0, -Math.cos(tilt), Math.sin(tilt)));
+function holdOfModel(THREE, model, holderScale) {
+  const { root, inner, parts } = model;
+  const frames = parts.frames;
+  const toRoot = (x, y, z) => V(THREE, inner.position.x + x * inner.scale.x, y, z);
+  const handgun = parts.family === "pistol" || parts.family === "revolver";
+  root.updateWorldMatrix(true, true);
+  let gripAt;
+  let up;
+  if (parts.grip) {
+    gripAt = toRoot(parts.grip.position.x, parts.grip.position.y, parts.grip.position.z);
+    up = V(THREE, 0, 1, 0).applyQuaternion(parts.grip.quaternion);
+  } else {
+    const receiverHeight = frames?.receiverHeight ?? 0.06;
+    gripAt = toRoot(frames?.gripX ?? 0.07, -receiverHeight / 2 - HAND_HOLD.strapUnder, 0);
+    up = V(THREE, Math.sin(0.3), Math.cos(0.3), 0);
+  }
+  const side = HAND_HOLD.gripHalfWidth + HAND_HOLD.palm;
+  const right = {
+    part: root,
+    offset: gripAt.clone().addScaledVector(up, HAND_HOLD.gripUp).add(V(THREE, 0, 0, side)),
+    quaternion: gripFrame(THREE, up, 1)
+  };
+  let left = null;
+  let leftMagazine = null;
+  if (handgun) {
+    left = { part: root, offset: gripAt.clone().addScaledVector(up, -HAND_HOLD.supportDown).add(V(THREE, 0, 0, -side)), quaternion: gripFrame(THREE, up, -1) };
+  } else if (parts.pump) {
+    const box2 = new THREE.Box3().setFromObject(parts.pump);
+    const center = box2.getCenter(new THREE.Vector3());
+    const under = parts.pump.worldToLocal(V(THREE, center.x, box2.min.y - HAND_HOLD.palm, center.z));
+    left = { part: parts.pump, offset: under, quaternion: forendFrame(THREE) };
+  } else if (frames) {
+    const handguardHeight = frames.receiverHeight * 0.8;
+    const x = frames.receiverEnd + (frames.handguardEnd - frames.receiverEnd) * HAND_HOLD.forendAt;
+    left = { part: root, offset: toRoot(x, frames.barrelY - handguardHeight / 2 - HAND_HOLD.palm - HAND_HOLD.forendDrop, 0), quaternion: forendFrame(THREE, HAND_HOLD.forendTilt) };
+  }
+  if (left && parts.mag) {
+    const box2 = new THREE.Box3().setFromObject(parts.mag);
+    const center = box2.getCenter(new THREE.Vector3());
+    const local = parts.mag.worldToLocal(V(THREE, center.x, box2.min.y - HAND_HOLD.palm, center.z));
+    leftMagazine = handgun && left ? { part: root, offset: left.offset.clone().addScaledVector(up, -HAND_HOLD.magDip), quaternion: left.quaternion } : { part: parts.mag, offset: local, quaternion: forendFrame(THREE) };
+  }
+  return {
+    right,
+    left,
+    leftMagazine,
+    scale: holderScale ** HAND_HOLD.handScaleExponent,
+    grip: HAND_HOLD.closed,
+    gripLeft: HAND_HOLD.forend
+  };
+}
+function holdOfProp(THREE, group, category, scale) {
+  const handle = group.getObjectByName("handle") ?? group.getObjectByName("body") ?? group;
+  const head = group.getObjectByName("head");
+  const size = (object) => new THREE.Box3().setFromObject(object).getSize(new THREE.Vector3());
+  const wrap = handFrame(THREE, V(THREE, 0, 1, 0), V(THREE, 0, 0, 1));
+  const handleSize = size(handle);
+  const right = { part: group, offset: handle.position.clone().add(V(THREE, 0, handleSize.y / 2 + 2e-3, 0)), quaternion: wrap };
+  const long = head && ["smg", "carbine", "rifle", "sniper", "shotgun", "crossbow", "flame"].includes(category);
+  const headSize = head ? size(head) : null;
+  const left = long && head && headSize ? { part: group, offset: head.position.clone().add(V(THREE, -headSize.x * 0.15, -headSize.y / 2 - HAND_HOLD.palm, 0)), quaternion: forendFrame(THREE) } : null;
+  return { right, left, leftMagazine: null, scale: scale ** HAND_HOLD.handScaleExponent, grip: HAND_HOLD.closed, gripLeft: HAND_HOLD.forend };
+}
+
 // src/props.ts
-import { mergeByMaterial } from "@adatechnology/game-props3d";
+import { mergeByMaterial, shapeGeometries as shapeGeometries2 } from "@adatechnology/game-shapes-three";
 
 // src/models/index.ts
 import { WEAPONS } from "@adatechnology/game-weapons";
@@ -2306,6 +3204,9 @@ var models_default = {
   }
 };
 
+// src/models/kit.ts
+import { shapeGeometries } from "@adatechnology/game-shapes-three";
+
 // src/models/rounded-box.ts
 var uvAlong = (THREE, faceDirection, normal, uvAxis, projectionAxis, radius, sideLength) => {
   const arcLength = 2 * Math.PI * radius / 4;
@@ -2332,11 +3233,11 @@ 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();
+  const flat2 = geometry.toNonIndexed();
   geometry.setIndex(null);
-  geometry.setAttribute("position", flat.attributes.position);
-  geometry.setAttribute("normal", flat.attributes.normal);
-  geometry.setAttribute("uv", flat.attributes.uv);
+  geometry.setAttribute("position", flat2.attributes.position);
+  geometry.setAttribute("normal", flat2.attributes.normal);
+  geometry.setAttribute("uv", flat2.attributes.uv);
   const position = new THREE.Vector3();
   const normal = new THREE.Vector3();
   const box2 = new THREE.Vector3(width, height, depth).divideScalar(2).subScalar(rounding);
@@ -2417,9 +3318,10 @@ var createMaterials = (THREE) => {
   };
 };
 var kits = /* @__PURE__ */ new WeakMap();
-function modelKit(THREE) {
-  const cached = kits.get(THREE);
+function modelKit(host) {
+  const cached = kits.get(host);
   if (cached) return cached;
+  const THREE = shapeGeometries(host);
   const geometries = /* @__PURE__ */ new Map();
   const shadowed = (mesh) => {
     mesh.castShadow = true;
@@ -2478,7 +3380,7 @@ function modelKit(THREE) {
       return group;
     }
   };
-  kits.set(THREE, kit);
+  kits.set(host, kit);
   return kit;
 }
 function heatify(glow, mesh) {
@@ -2661,6 +3563,7 @@ function buildBullpup(kit, options) {
   const gx = bodyLength * 0.8;
   const grip = kit.pivot(group, gx, -0.085, 0);
   grip.rotation.z = -0.25;
+  parts.grip = grip;
   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);
@@ -2880,6 +3783,7 @@ function buildAt4(kit, group, parts) {
   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;
+  parts.grip = grip;
   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);
@@ -3209,6 +4113,7 @@ function buildFrame(kit, group, parts, options, style, size, materials) {
   const gy = -h / 2 - gripLength / 2 + 6e-3;
   const grip = kit.pivot(group, gx, gy, 0);
   grip.rotation.z = style.ga;
+  parts.grip = grip;
   const gripWidth = style.grip === "chunky" ? w * 1.18 : w * 1.06;
   const gripDepth = style.grip === "chunky" ? 0.036 : 0.032;
   kit.roundness = 0.3;
@@ -3332,6 +4237,7 @@ function buildRevolver(kit, options) {
   parts.hammer = hammer;
   const grip = kit.pivot(group, 0.024, -0.062, 0);
   grip.rotation.z = -0.38;
+  parts.grip = grip;
   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);
@@ -3520,6 +4426,7 @@ function buildGrip(context) {
   if (!context.isTraditional && o.grip !== "none") {
     const grip = kit.pivot(group, gx - 0.012, -hR / 2 - 0.046, 0);
     grip.rotation.z = -0.3;
+    parts.grip = grip;
     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);
@@ -3899,7 +4806,7 @@ function buildProp(THREE, prop) {
     if (part.shape.kind !== "box") continue;
     const [w, h, d] = part.shape.size;
     const material = new THREE.MeshStandardMaterial({ color: prop.colors[part.id] ?? 7829367, roughness: 0.6, metalness: part.material === "steel" ? 0.6 : 0.05 });
-    const mesh = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), material);
+    const mesh = new THREE.Mesh(new (shapeGeometries2(THREE)).BoxGeometry(w, h, d), material);
     mesh.name = part.id;
     mesh.position.set(part.position[0], part.position[1], part.position[2]);
     mesh.castShadow = true;
@@ -3970,11 +4877,13 @@ function createBoxFx(options) {
   let model = null;
   let inHand = null;
   let def = null;
+  let hold = null;
   let kick = 0;
   let dip = 0;
   let reloading = false;
   const v = new THREE.Vector3();
   const q = new THREE.Quaternion();
+  const q2 = new THREE.Quaternion();
   const pointForward = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2);
   const equip = (weapon) => {
     if (model) hand.remove(model);
@@ -3988,6 +4897,7 @@ function createBoxFx(options) {
     model.quaternion.copy(pointForward);
     hand.add(model);
     inHand = def.id;
+    hold = holdOfProp(THREE, model, def.category, model.scale.x);
   };
   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) => {
@@ -4079,9 +4989,15 @@ function createBoxFx(options) {
       if (model) hand.remove(model);
       model = null;
       inHand = null;
+      hold = null;
+    },
+    handTargets() {
+      if (!model || !hold) return null;
+      hand.updateMatrixWorld(true);
+      return targetsOf(THREE, hold, model.getWorldQuaternion(q2), 0);
     },
     handle(event, tool) {
-      if (event.type === "explosion") return;
+      if (event.type === "explosion" || event.type === "player") return;
       const weapon = arsenal.weapons.get(event.weapon);
       if (event.type === "tool") equip(event.weapon);
       if (!weapon) return;
@@ -4136,6 +5052,7 @@ var ease = (progress) => progress < 0.5 ? 2 * progress * progress : 1 - (-2 * pr
 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 sound2 = (t, id) => ({ t, type: "sound", data: { id } });
 var stage = (id, t) => ({ t, type: STAGE_EVENT, data: { stage: id } });
 var valueAt = (tweens, t, includeInstants) => {
   let value = 0;
@@ -4233,7 +5150,7 @@ function magazineSwap(parts, start) {
       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 })],
+    events: [sound2(start, "mag_release"), cue(start + 0.16, "drop_magazine", { up: direction > 0 }), sound2(start + 0.16, "mag_out"), sound2(start + MAGAZINE_IN_AT, "mag_insert"), sound2(start + MAGAZINE_IN_AT + 0.3, "mag_seat")],
     end: start + MAGAZINE_SWAP_SECONDS
   };
 }
@@ -4306,43 +5223,52 @@ function clearClips(context) {
 // src/animation/reload-clips.ts
 import { RELOAD_STAGES } from "@adatechnology/game-weapons";
 var KINDS = ["tactical", "empty", "one_by_one"];
+var chargeSounds = (start) => [sound2(start, "charging_handle_pull"), sound2(start + 0.2, "charging_handle_release")];
 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 boltSounds = (start) => [sound2(start, "bolt_lift"), sound2(start + 0.1, "bolt_pull"), sound2(start + 0.26, "bolt_push"), sound2(start + 0.45, "bolt_lock")];
 var cycleWithoutEject = (start) => ({ tweens: boltStroke(start), events: [], end: start + 0.55 });
+var RACK_BACK = 0.14;
+var RACK_HOLD = 0.04;
+var RACK_FORWARD = 0.06;
 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;
+      const travel = strokeOf(parts);
+      draft.tweens.push(move("slide", "x", swap.end + 0.04, RACK_BACK, 0, travel), move("slide", "x", swap.end + 0.04 + RACK_BACK + RACK_HOLD, RACK_FORWARD, travel, 0));
+      draft.events.push(sound2(swap.end + 0.04 + RACK_BACK + RACK_HOLD + 0.02, "slide_release"));
+      draft.end += 0.04 + RACK_BACK + RACK_HOLD + RACK_FORWARD + 0.08;
     }
   } else if (family === "boltmag") {
     const stroke = cycleWithoutEject(swap.end);
     draft.tweens.push(...stroke.tweens);
+    draft.events.push(...boltSounds(swap.end));
     draft.end = stroke.end;
   } else if (kind === "empty" && parts.bolt) {
     draft.tweens.push(...charge(context, swap.end));
+    draft.events.push(...chargeSounds(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" }));
+  const events = [sound2(0, "cylinder_open"), cue(0.32, "eject_casing", { from: "chambers", down: false }), sound2(0.32, "cylinder_eject"), sound2(1.2, "cylinder_close")];
+  if (kind !== "one_by_one") events.push(cue(0.7, "move_in", { from: "chambers" }), sound2(0.7, "speedloader"));
   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" })],
+  events: [sound2(0, "barrels_open"), cue(0.25, "eject_casing", { from: "breech", down: false }), sound2(0.25, "casings_eject"), cue(0.65, "move_in", { from: "breech" }), sound2(0.65, "shell_insert"), sound2(0.8, "shell_insert"), sound2(1.13, "barrels_close")],
   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: [],
+  events: [sound2(0, "belt_cover_open"), sound2(0.8, "belt_insert"), sound2(1.05, "belt_cover_close"), ...chargeSounds(1.15)],
   end: 1.55
 });
 var UNIT = 1;
@@ -4350,9 +5276,16 @@ 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));
+  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));
+    draft.events.push(sound2(0.88, "pump_back"), sound2(0.94, "pump_forward"));
+  } 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));
+    draft.events.push(sound2(0.87, "lever_open"), sound2(0.94, "lever_close"));
+  } 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));
+    draft.events.push(sound2(0.88, "charging_handle_pull"), sound2(0.95, "charging_handle_release"));
+  }
   return draft;
 }
 function boltReload(context) {
@@ -4366,13 +5299,13 @@ function boltReload(context) {
       move("bolt", "x", 0.86, 0.07, BOLT_TRAVEL, 0),
       turn("boltHandle", "x", 0.93, 0.05, BOLT_TURN, 0)
     ],
-    events: [],
+    events: [sound2(0, "bolt_lift"), sound2(0.05, "bolt_pull"), sound2(0.86, "bolt_push"), sound2(0.95, "bolt_lock")],
     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 };
+  return { tweens: context.parts.bolt ? [move("bolt", "x", 0, 0.04, 0, travel), move("bolt", "x", 0.89, 0.04, travel, 0)] : [], events: context.parts.bolt ? [sound2(0.04, "charging_handle_pull"), sound2(0.89, "charging_handle_release")] : [], end: UNIT };
 }
 function heavyReload(context) {
   const { parts, family } = context;
@@ -4380,20 +5313,20 @@ function heavyReload(context) {
   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")],
+      events: [cue(0, "drop_tube"), sound2(0, "tube_drop"), cue(0.6, "seat_tube"), sound2(1.08, "tube_seat")],
       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")],
+      events: [cue(0, "show_round"), sound2(0, "rocket_load"), sound2(0.55, "rocket_seat")],
       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")],
+    events: [sound2(0, "breech_open"), cue(0.3, "breech_round"), sound2(0.3, "grenade_load"), sound2(0.96, "breech_close")],
     end: 1.05
   };
 }
@@ -4424,11 +5357,12 @@ function reloadClips(context) {
   }
   return clips.length > 0 ? clips : first ? [renamed(first, "reload")] : [];
 }
+var FEED_SECONDS = 0.4;
 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);
+  if (family === "revolver") return composeClip("feed", [], [cue(0, "move_in", { from: "chambers", next: true }), sound2(0.1, "shell_insert")], 0.24);
+  if (family === "bolt" || family === "semiint") return composeClip("feed", [], [cue(0, "move_in", { from: "topLoad" }), sound2(0.2, "shell_insert")], FEED_SECONDS);
+  if (isTube(context)) return composeClip("feed", [], [cue(0, "move_in", { from: "loadPort" }), sound2(0.2, "shell_insert")], FEED_SECONDS);
   return void 0;
 }
 
@@ -5131,6 +6065,7 @@ function buildRound(kit, dims, shape) {
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
 
 // src/fx/effects.ts
+import { MUZZLE_SMOKE } from "@adatechnology/game-weapons";
 var FLASH_BY_CASE = { shell: 1.6, big: 2.6, tiny: 0.5, pistol: 0.8, rifle: 1.2 };
 var VIEWMODEL_EFFECT_IDS = { flash: "viewmodel_muzzle_flash", smoke: "weapon_smoke_puff", backblast: "launcher_backblast", flameJet: "flame_jet" };
 var vec = (vector) => [vector.x, vector.y, vector.z];
@@ -5139,8 +6074,9 @@ function createEffects(THREE, sink, random) {
   const seed = () => 1 + Math.floor(random() * 2147483646);
   const barrel = (orientation) => vec(new THREE.Vector3(1, 0, 0).applyQuaternion(orientation));
   return {
-    muzzleFlash(position, orientation, size) {
-      sink?.play({ effect: VIEWMODEL_EFFECT_IDS.flash, point: vec(position), direction: barrel(orientation), orientation: quaternion(orientation), seed: seed(), values: { size } });
+    muzzleFlash(position, orientation, size, profile = MUZZLE_SMOKE.smokeless) {
+      if (profile.puffs <= 0 && profile.flash <= 0) return;
+      sink?.play({ effect: VIEWMODEL_EFFECT_IDS.flash, point: vec(position), direction: barrel(orientation), orientation: quaternion(orientation), seed: seed(), values: { size, ...profile } });
     },
     smoke(position, velocity, size, life, opacity) {
       sink?.play({ effect: VIEWMODEL_EFFECT_IDS.smoke, point: vec(position), seed: seed(), values: { vx: velocity.x, vy: velocity.y, vz: velocity.z, radius: size, life, opacity } });
@@ -5165,13 +6101,17 @@ var flameMaterials = (kit) => {
     new THREE.MeshBasicMaterial({ color: 16773296, transparent: true, opacity: 0.9, blending: THREE.AdditiveBlending, depthWrite: false })
   ];
 };
-function launchRocket(context) {
+function launchRocket(context, flyRound = true) {
   const { kit, scene, parts, random } = context;
   const { THREE } = kit;
   const forward = context.forward();
   const muzzle = context.positionOf(parts.muzzle);
   const rear = context.positionOf(parts.rear);
   context.effects.backblast(rear, context.orientation());
+  if (!flyRound) {
+    if (parts.round) parts.round.visible = false;
+    return;
+  }
   const rocket = parts.makeRound ? parts.makeRound() : buildFlyingRocket(kit, parts.launcherType);
   if (parts.round) parts.round.visible = false;
   rocket.quaternion.copy(context.orientation());
@@ -5366,6 +6306,7 @@ var toWorld = (session, vector, scaled = false) => {
 };
 
 // src/fx/viewmodel-events.ts
+import { muzzleSmokeOf } from "@adatechnology/game-weapons";
 var PI13 = Math.PI;
 var UGL_FLASH = 1.6;
 var restFlat = (object) => {
@@ -5471,7 +6412,11 @@ function createClipEventHandler(world, session) {
       case "muzzle_flash":
         if (data.at === "ugl") {
           if (parts.uglMuzzle && world.layers.muzzleFlash) effects.muzzleFlash(positionOf(parts.uglMuzzle), root.getWorldQuaternion(new THREE.Quaternion()), UGL_FLASH);
-        } else 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]);
+        } else if (parts.muzzle && world.layers.muzzleFlash && (session.def.action.kind === "firearm" || session.def.action.kind === "launcher")) {
+          const profile = muzzleSmokeOf({ caliber: session.caliber, weapon: session.def, suppressed: session.suppressed });
+          const size = session.def.action.kind === "launcher" ? 2.2 : FLASH_BY_CASE[session.caseType];
+          effects.muzzleFlash(positionOf(parts.muzzle), root.getWorldQuaternion(new THREE.Quaternion()), size, profile);
+        }
         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 }));
@@ -5502,6 +6447,9 @@ function createClipEventHandler(world, session) {
       case "breech_round":
         breechRound();
         break;
+      case "sound":
+        world.sound(session.id, String(data.id), session.soundProfile);
+        break;
       default:
         break;
     }
@@ -5525,10 +6473,321 @@ function createClipEventHandler(world, session) {
   }
 }
 
+// src/fx/hand-work.ts
+import { sampleClip } from "@adatechnology/game-contracts";
+
+// src/data/hand-work.json
+var hand_work_default = {
+  source: "Authored in the kit: the gallery's clips move the parts (slide, bolt, bolt handle, crane, cover) but the Galeria 3D do Arsenal draws no hands, so which hand works which part is written here. Times are not here: a hand takes a part while the clip of the weapon moves it, so they follow the clip and the seconds of the rule's reload.",
+  timing: {
+    lead: 0.08,
+    tail: 0.06,
+    comment: "fractions of the clip's duration: the hand arrives this long before the part starts to move and lets go this long after it stops"
+  },
+  pistolRelease: {
+    comment: "Pistols whose slide stop is worked with the thumb of the shooting hand after the magazine is in. Empty by default: every pistol is racked by the support hand taking the rear of the slide (the reading shot of the move). Put an id here only for a pistol that is meant to be released by the thumb.",
+    weapons: []
+  },
+  akCharge: {
+    comment: "Guns charged by a handle on the right of the receiver, reached over the top by the support hand; the rest of the magazine guns are charged at the rear top (AR style).",
+    weapons: [
+      "ak_47",
+      "akm",
+      "ak_74",
+      "ak_12",
+      "rpk",
+      "saiga_12",
+      "sks",
+      "m14_ebr",
+      "fn_fal",
+      "fn_parafal",
+      "hk_g3a3",
+      "hk_psg_1",
+      "svd_dragunov"
+    ]
+  },
+  works: [
+    {
+      family: "pistol",
+      clips: [
+        "reload_empty"
+      ],
+      part: "slide",
+      hand: "L",
+      anchor: "slide_rear",
+      style: "rack"
+    },
+    {
+      family: "pistol",
+      clips: [
+        "reload_empty"
+      ],
+      part: "slide",
+      hand: "R",
+      anchor: "thumb_release",
+      style: "release"
+    },
+    {
+      family: "rifle",
+      clips: [
+        "reload_empty"
+      ],
+      part: "bolt",
+      hand: "L",
+      anchor: "rear_top",
+      style: "ar"
+    },
+    {
+      family: "rifle",
+      clips: [
+        "reload_empty"
+      ],
+      part: "bolt",
+      hand: "L",
+      anchor: "side_right",
+      style: "ak"
+    },
+    {
+      family: "p90",
+      clips: [
+        "reload_empty"
+      ],
+      part: "bolt",
+      hand: "L",
+      anchor: "rear_top",
+      style: "ar"
+    },
+    {
+      family: "belt",
+      clips: [
+        "reload"
+      ],
+      part: "cover",
+      hand: "L",
+      anchor: "cover_top",
+      merge: 1
+    },
+    {
+      family: "boltmag",
+      clips: [
+        "reload",
+        "reload_empty",
+        "reload_one_by_one",
+        "cycle"
+      ],
+      part: "boltHandle",
+      hand: "R",
+      anchor: "top_handle"
+    },
+    {
+      family: "bolt",
+      clips: [
+        "reload",
+        "reload_empty",
+        "reload_one_by_one",
+        "feed"
+      ],
+      hand: "R",
+      anchor: "loading_port",
+      whole: true,
+      lead: 0.3,
+      tail: 0.3
+    },
+    {
+      family: "bolt",
+      clips: [
+        "reload",
+        "reload_empty",
+        "reload_one_by_one",
+        "cycle"
+      ],
+      part: "boltHandle",
+      hand: "R",
+      anchor: "top_handle"
+    },
+    {
+      family: "pump",
+      clips: [
+        "feed"
+      ],
+      hand: "R",
+      anchor: "loading_port",
+      whole: true,
+      lead: 0.3,
+      tail: 0.3
+    },
+    {
+      family: "semi12",
+      clips: [
+        "feed"
+      ],
+      hand: "R",
+      anchor: "loading_port",
+      whole: true,
+      lead: 0.3,
+      tail: 0.3
+    },
+    {
+      family: "semiint",
+      clips: [
+        "reload",
+        "reload_empty",
+        "reload_one_by_one",
+        "feed"
+      ],
+      hand: "R",
+      anchor: "loading_port",
+      whole: true,
+      lead: 0.3,
+      tail: 0.3
+    },
+    {
+      family: "lever",
+      clips: [
+        "feed"
+      ],
+      hand: "R",
+      anchor: "loading_port",
+      whole: true,
+      lead: 0.3,
+      tail: 0.3
+    },
+    {
+      family: "revolver",
+      clips: [
+        "reload",
+        "reload_one_by_one"
+      ],
+      part: "crane",
+      hand: "L",
+      anchor: "cylinder_side",
+      merge: 1
+    }
+  ]
+};
+
+// src/fx/hand-work.ts
+var V2 = (THREE, x, y, z) => new THREE.Vector3(x, y, z);
+var boxIn = (THREE, root, part) => {
+  const world = new THREE.Box3().setFromObject(part);
+  const box2 = new THREE.Box3();
+  for (const x of [world.min.x, world.max.x]) for (const y of [world.min.y, world.max.y]) for (const z of [world.min.z, world.max.z]) box2.expandByPoint(root.worldToLocal(V2(THREE, x, y, z)));
+  return box2;
+};
+var anchorsOf = (THREE, model, right) => {
+  const { root, parts } = model;
+  root.updateWorldMatrix(true, true);
+  const palm = HAND_HOLD.palm;
+  const anchorAt = (part, at, quaternion2) => ({ part, offset: part.worldToLocal(root.localToWorld(at.clone())), quaternion: quaternion2 });
+  return (kind, partId) => {
+    const part = partId ? parts[partId] ?? null : null;
+    if (kind === "loading_port") {
+      const port = parts.loadPort;
+      if (!port) return null;
+      const at = root.worldToLocal(port.getWorldPosition(V2(THREE, 0, 0, 0))).add(V2(THREE, 0, -palm - 4e-3, 0));
+      return anchorAt(port, at, handFrame(THREE, V2(THREE, 0, 0, -1), V2(THREE, 0, -1, 0)));
+    }
+    if (kind === "thumb_release") {
+      if (!right || !parts.slide) return null;
+      return { part: right.part, offset: right.offset.clone().add(V2(THREE, 0, 0.012, 0)), quaternion: right.quaternion };
+    }
+    if (!part) return null;
+    const b = boxIn(THREE, root, part);
+    const c = b.getCenter(V2(THREE, 0, 0, 0));
+    switch (kind) {
+      case "slide_rear":
+        return anchorAt(part, V2(THREE, b.min.x + 0.014, b.max.y - 6e-3, b.min.z - palm), handFrame(THREE, V2(THREE, 1, 0, 0), V2(THREE, 0, 0, -1)));
+      case "rear_top":
+        return anchorAt(part, V2(THREE, b.min.x + 0.016, b.max.y + palm, c.z), handFrame(THREE, V2(THREE, 1, 0, 0), V2(THREE, 0, 1, 0)));
+      case "side_right":
+        return anchorAt(part, V2(THREE, c.x, c.y, b.max.z + palm), handFrame(THREE, V2(THREE, 1, 0, 0), V2(THREE, 0, 0, 1)));
+      case "top_handle":
+        return anchorAt(part, V2(THREE, c.x, c.y, b.max.z + palm), handFrame(THREE, V2(THREE, 1, 0, 0), V2(THREE, 0, 0, 1)));
+      case "cover_top":
+        return anchorAt(part, V2(THREE, c.x, b.max.y + palm, c.z), handFrame(THREE, V2(THREE, 1, 0, 0), V2(THREE, 0, 1, 0)));
+      case "cylinder_side":
+        return anchorAt(part, V2(THREE, c.x, c.y, b.min.z - palm), handFrame(THREE, V2(THREE, 1, 0, 0), V2(THREE, 0, 0, -1)));
+      default:
+        return null;
+    }
+  };
+};
+var releasePistols = new Set(hand_work_default.pistolRelease.weapons);
+var akCharge = new Set(hand_work_default.akCharge.weapons);
+function handWorkOf(THREE, model, weaponId, right) {
+  const family = model.parts.family;
+  const anchors = anchorsOf(THREE, model, right);
+  const style = family === "pistol" ? releasePistols.has(weaponId) ? "release" : "rack" : akCharge.has(weaponId) ? "ak" : "ar";
+  const out = [];
+  for (const entry of hand_work_default.works) {
+    if (entry.family !== family || entry.style && entry.style !== style) continue;
+    const anchor = anchors(entry.anchor, entry.part ?? null);
+    if (!anchor) continue;
+    out.push({ hand: entry.hand, anchor, part: entry.whole ? null : entry.part ?? null, clips: entry.clips, merge: entry.merge ?? 0, id: entry.anchor, ...entry.lead === void 0 ? {} : { lead: entry.lead }, ...entry.tail === void 0 ? {} : { tail: entry.tail } });
+  }
+  return out;
+}
+var segmentsCache = /* @__PURE__ */ new WeakMap();
+var motionOf = (clip, part, merge) => {
+  const cache = segmentsCache.get(clip) ?? /* @__PURE__ */ new Map();
+  segmentsCache.set(clip, cache);
+  const key = `${part}|${merge}`;
+  const found = cache.get(key);
+  if (found) return found;
+  const steps = 240;
+  const dt = clip.duration / steps;
+  const spans = [];
+  let start = null;
+  for (let i = 1; i <= steps; i++) {
+    const a = sampleClip(clip, part, (i - 1) * dt);
+    const b = sampleClip(clip, part, i * dt);
+    const moving = [0, 1, 2].some((axis) => Math.abs(b.position[axis] - a.position[axis]) > 1e-6 || Math.abs(b.rotation[axis] - a.rotation[axis]) > 1e-6);
+    if (moving && start === null) start = (i - 1) * dt;
+    if (!moving && start !== null) {
+      spans.push([start, (i - 1) * dt]);
+      start = null;
+    }
+  }
+  if (start !== null) spans.push([start, clip.duration]);
+  const joined = [];
+  for (const span of spans) {
+    const last = joined[joined.length - 1];
+    if (last && span[0] - last[1] <= merge * clip.duration) last[1] = span[1];
+    else joined.push([span[0], span[1]]);
+  }
+  cache.set(key, joined);
+  return joined;
+};
+var smooth = (x) => {
+  const k = Math.min(1, Math.max(0, x));
+  return k * k * (3 - 2 * k);
+};
+function workWeights(works, running) {
+  return works.map((work) => {
+    const lead = work.lead ?? hand_work_default.timing.lead;
+    const tail = work.tail ?? hand_work_default.timing.tail;
+    let best = 0;
+    for (const { name, time, clip } of running) {
+      if (!work.clips.includes(name)) continue;
+      const spans = work.part ? motionOf(clip, work.part, work.merge) : [[0, clip.duration]];
+      for (const [from, to] of spans) {
+        const before = lead * clip.duration;
+        const after = tail * clip.duration;
+        const w = work.part ? smooth((time - (from - before)) / before) * smooth((to + after - time) / after) : smooth(time / before) * smooth((clip.duration - time) / after);
+        best = Math.max(best, w);
+      }
+    }
+    return best;
+  });
+}
+
 // src/fx/viewmodel.ts
 var PI14 = Math.PI;
 var HAND_OFFSET2 = [0.2, -0.2, -0.42];
+var HANDGUN_OFFSET = [0.1, -0.12, -0.44];
 var HEAT_DISPLAY_MAX_FALLBACK = 120;
+var WALL_PULL = { margin: 0.03, max: 0.7, rate: 14, probe: 3 };
+var HAND_IN_VIEW = { floor: -0.88, max: 0.18, rate: 10 };
 var LAUNCH_VOLUME = 0.6;
 var fittedOf2 = (parts) => parts.map((part) => ({ id: part.id, mount: part.mount, ...part.integral ? { integral: true } : {}, ...part.on === void 0 ? {} : { on: part.on } }));
 var collapsedStockPose = (move2) => {
@@ -5537,6 +6796,14 @@ var collapsedStockPose = (move2) => {
 };
 var underbarrelStep = (step, tool) => tool.underbarrelActive && step.type === "play" && (step.clip === "shot" || step.clip === "reload") ? { ...step, variant: "ugl" } : step;
 var caliberOf = (arsenal, def) => def.action.kind === "firearm" ? arsenal.calibers.get(def.action.caliber) : void 0;
+var TRIGGER_FINGER = { safe: 0, ready: 0.5, pulled: 1, readySeconds: 1.5, burstSeconds: 0.14, tremor: 0.03 };
+var TRIGGER_TURN = 0.35;
+var indexCurl = (turn2, sinceShot) => {
+  const ready = sinceShot < TRIGGER_FINGER.readySeconds ? TRIGGER_FINGER.ready : TRIGGER_FINGER.safe;
+  const pull = Math.min(1, Math.max(0, turn2 / TRIGGER_TURN));
+  const held = sinceShot < TRIGGER_FINGER.burstSeconds ? TRIGGER_FINGER.pulled - TRIGGER_FINGER.tremor * (0.5 + 0.5 * Math.sin(sinceShot * 220)) : 0;
+  return Math.max(ready + (TRIGGER_FINGER.pulled - ready) * pull, held);
+};
 function createViewmodel(options) {
   const { THREE, scene, camera, arsenal, groundAt, audio } = options;
   const kit = modelKit(THREE);
@@ -5559,6 +6826,15 @@ function createViewmodel(options) {
   let condition = options.condition ?? "new";
   let lastAmmo = 0;
   let smokeDebt = 0;
+  let secondsSinceShot = Number.POSITIVE_INFINITY;
+  let hold = null;
+  let reloading = false;
+  let magazineHand = 0;
+  let clock = 0;
+  let lastShot = -Infinity;
+  let triggerRest = 0;
+  let feedCued = false;
+  const rootQuaternion = new THREE.Quaternion();
   const world = {
     kit,
     scene,
@@ -5568,9 +6844,15 @@ function createViewmodel(options) {
     audio,
     layers,
     groundAt,
+    sound: (weapon, cue2, profile) => {
+      audio?.cue(cue2, profile);
+      options.onSound?.({ weapon, cue: cue2, profile });
+    },
     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 visual = arsenal.rules.heat.visual;
+  const hasSuppressor = (parts) => parts.some((part) => arsenal.attachments.get(part.id)?.kind === "suppressor");
   const release = () => {
     if (!session) return;
     session.attachments?.dispose();
@@ -5578,6 +6860,7 @@ function createViewmodel(options) {
     player = null;
     session = null;
     tasks = [];
+    hold = null;
   };
   const heavy = (current) => ({
     kit,
@@ -5597,6 +6880,14 @@ function createViewmodel(options) {
     const model = def ? buildWeaponModelById(THREE, weapon) : void 0;
     if (!def || !model) return false;
     release();
+    hold = null;
+    reloading = false;
+    magazineHand = 0;
+    reach = 0;
+    pull = 0;
+    lift = 0;
+    handHeight = 0;
+    handDepth = 0;
     rigStock(THREE, model, def);
     rigUnderbarrel(THREE, model, def);
     const length = new THREE.Box3().setFromObject(model.root).getSize(new THREE.Vector3()).x;
@@ -5606,31 +6897,36 @@ function createViewmodel(options) {
     holder.add(model.root);
     const caliber = caliberOf(arsenal, def);
     const dims = caliber?.cartridge;
+    const hostTool = options.tool?.();
+    const onTool = hostTool?.weapon === weapon ? hostTool : void 0;
+    const fitted = onTool?.attachments ? fittedOf2(onTool.attachments) : [...def.fitted ?? []];
     session = {
       id: weapon,
       def,
+      caliber,
       model,
       holderScale: scale,
       lengthMetres: length,
       caseType: caliber?.caseType ?? "rifle",
+      soundProfile: soundProfileOf(weapon, model.parts.family),
       kit,
       cartridge: caliber && dims ? { dims, shape: cartridgeShape(caliber, dims) } : null,
       stuckCase: null,
       nextChamber: 0,
       attachments: null,
-      attachmentsSignature: ""
+      attachmentsSignature: "",
+      suppressed: onTool?.suppressed ?? hasSuppressor(fitted)
     };
-    const hostTool = options.tool?.();
-    const onTool = hostTool?.weapon === weapon ? hostTool : void 0;
-    const fitted = onTool?.attachments ? fittedOf2(onTool.attachments) : [...def.fitted ?? []];
     session.attachments = fitAttachmentModels(model, fitted, kit, { catalogue: arsenal.attachments, isDrawn: () => layers.attachments, areBeamsOn: () => layers.beams, ...options.attachmentModels ? { overrides: options.attachmentModels } : {}, ...options.raycast ? { raycast: options.raycast } : {} });
     session.attachmentsSignature = attachmentsKey(onTool?.attachments);
     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;
     const rig = createModelRig(model);
+    const clips = buildToolClips({ parts: model.parts, family: model.parts.family, caseType: session.caseType, reloadFamily });
+    feedCued = clips.feed?.events?.some((entry) => entry.type === "sound") ?? false;
     player = createToolClipPlayer({
-      clips: buildToolClips({ parts: model.parts, family: model.parts.family, caseType: session.caseType, reloadFamily }),
+      clips,
       rig,
       onEvent: createClipEventHandler(world, session),
       repeatInterval: () => rpm > 0 ? 60 / rpm : 0.1
@@ -5638,25 +6934,67 @@ function createViewmodel(options) {
     if (model.parts.stockMove && onTool?.stock === "collapsed") rig.setPartPose("stock", collapsedStockPose(model.parts.stockMove));
     applyCondition(kit, model, condition);
     lastAmmo = options.tool?.().ammo ?? 0;
+    hand.updateMatrixWorld(true);
+    hold = holdOfModel(THREE, model, scale);
+    hold = { ...hold, works: handWorkOf(THREE, model, weapon, hold.right) };
+    triggerRest = model.parts.trigger?.rotation.z ?? 0;
+    lastShot = -Infinity;
     return true;
   };
   const syncAttachments = (current, tool) => {
-    if (!current.attachments || tool?.weapon !== current.id || !tool.attachments) return;
+    if (!current.attachments || tool?.weapon !== current.id) return;
+    if (tool.suppressed !== void 0) current.suppressed = tool.suppressed;
+    if (!tool.attachments) return;
     const signature = attachmentsKey(tool.attachments);
     if (signature === current.attachmentsSignature) return;
     current.attachmentsSignature = signature;
-    current.attachments.sync(fittedOf2(tool.attachments));
+    const fitted = fittedOf2(tool.attachments);
+    if (tool.suppressed === void 0) current.suppressed = hasSuppressor(fitted);
+    current.attachments.sync(fitted);
+  };
+  let reach = 0;
+  let pull = 0;
+  let lift = 0;
+  let handHeight = 0;
+  let handDepth = 0;
+  const ahead = new THREE.Vector3();
+  const up = new THREE.Vector3();
+  const seen = new THREE.Vector3();
+  const eyeTurn = new THREE.Quaternion();
+  const corner = new THREE.Vector3();
+  const bounds = new THREE.Box3();
+  const measureReach = (current) => {
+    bounds.setFromObject(current.model.root);
+    let farthest = 0;
+    for (const x of [bounds.min.x, bounds.max.x]) for (const y of [bounds.min.y, bounds.max.y]) for (const z of [bounds.min.z, bounds.max.z]) farthest = Math.max(farthest, corner.set(x, y, z).sub(camera.position).dot(ahead));
+    return farthest;
   };
-  const place = () => {
-    const [x, y, z] = HAND_OFFSET2;
+  const place = (dt = 0) => {
+    const family = session?.model.parts.family;
+    const [x, y, z] = family === "pistol" || family === "revolver" ? HANDGUN_OFFSET : HAND_OFFSET2;
     hand.position.set(x, y, z).applyQuaternion(camera.quaternion).add(camera.position);
     hand.quaternion.copy(camera.quaternion);
+    if (session && handDepth > 0.05 && "fov" in camera) {
+      const tanHalf = Math.tan((camera.fov ?? 70) * PI14 / 360);
+      const want2 = Math.max(0, Math.min(HAND_IN_VIEW.max, lift + (HAND_IN_VIEW.floor - handHeight) * tanHalf * handDepth));
+      lift += (want2 - lift) * Math.min(1, dt * HAND_IN_VIEW.rate);
+      if (lift > 1e-4) hand.position.addScaledVector(up.set(0, 1, 0).applyQuaternion(camera.quaternion), lift);
+    }
+    hand.updateMatrixWorld(true);
+    if (!options.contact || !session) return;
+    ahead.set(0, 0, -1).applyQuaternion(camera.quaternion);
+    if (reach === 0) reach = Math.max(0.01, measureReach(session));
+    const free = options.contact(camera.position, ahead, WALL_PULL.probe);
+    const want = free === null ? 0 : Math.max(0, Math.min(WALL_PULL.max, reach + WALL_PULL.margin - free));
+    pull += (want - pull) * Math.min(1, dt * WALL_PULL.rate);
+    if (pull < 1e-4) return;
+    hand.position.addScaledVector(ahead, -pull);
     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));
+    const level = Math.max(0, Math.min(1, (heat - visual.glowFrom) / visual.glowSpan));
     for (const mesh of session.model.parts.glow) {
       const material = mesh.material;
       material.emissive.setRGB(level, 0.2 * level * level, 0.02 * level * level);
@@ -5664,56 +7002,73 @@ function createViewmodel(options) {
     }
   };
   const handleShot = (current, event, tool) => {
+    secondsSinceShot = 0;
+    if (event.suppressed !== void 0) current.suppressed = event.suppressed;
+    else if (tool.suppressed !== void 0) current.suppressed = tool.suppressed;
+    else current.suppressed = hasSuppressor(tool.attachments ? fittedOf2(tool.attachments) : current.def.fitted ?? []);
     if (tool.underbarrelActive && current.model.parts.uglMuzzle) {
       audio?.play("explosion", LAUNCH_VOLUME, distance());
       return;
     }
     const action = current.def.action;
     if (action.kind === "launcher") {
-      launchRocket(heavy(current));
+      launchRocket(heavy(current), options.flyRocket !== false);
       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(), ...event.suppressed === true ? { suppressed: true } : {} });
+    audio?.shot(muzzleEnergy3(caliber) * (caliber.pellets ?? 1), current.def.category, { caliber, distance: distance(), ...current.suppressed ? { suppressed: true } : {} });
   };
   return {
     equip,
     unequip: release,
     handle(event, tool) {
-      if (event.type === "explosion") return;
+      if (event.type === "explosion" || event.type === "player") 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, event, tool);
-      else if (event.type === "reload" && event.phase === "start") current.nextChamber = 0;
+      if (event.type === "shot") {
+        lastShot = clock;
+        handleShot(current, event, tool);
+      } else if (event.type === "reload" && event.phase === "start") {
+        current.nextChamber = 0;
+        reloading = true;
+      } else if (event.type === "reload" && event.phase === "end") reloading = false;
       else if (event.type === "clear" && event.phase === "end") current.stuckCase = null;
       const mechanical = weaponEventOf(event);
-      if (mechanical) audio?.event(mechanical);
+      const cued = mechanical?.type === "feed" ? feedCued : mechanical?.type === "reload_stage" && (player.running.some(({ clip }) => clip.events?.some((entry) => entry.type === "sound")) ?? false);
+      if (mechanical && !cued) 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" } : underbarrelStep(step, tool));
     },
     update(dt) {
+      clock += dt;
       if (session) {
-        place();
+        place(dt);
         player?.update(dt);
+        const wantsMagazine = reloading || options.tool?.().reloading === true;
+        magazineHand += ((wantsMagazine ? 1 : 0) - magazineHand) * Math.min(1, dt * HAND_HOLD.magRate);
         const tool = options.tool?.();
         syncAttachments(session, tool);
         session.attachments?.update();
         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);
+          if (tool.ammo < lastAmmo) {
+            flameJet(heavy(session), dt, session.model.parts.launcherType === "flame" ? 1 : 0.6);
+            lastShot = clock;
+          }
           lastAmmo = tool.ammo;
         }
-        if (tool && tool.heat !== void 0 && tool.heat * heatMax > 10 && session.model.parts.muzzle) {
-          smokeDebt += dt * tool.heat * heatMax * 0.1;
+        secondsSinceShot += dt;
+        if (tool && tool.heat !== void 0 && tool.heat * heatMax > visual.smokeFrom && secondsSinceShot < visual.smokeSeconds && session.model.parts.muzzle) {
+          smokeDebt += dt * (tool.heat * heatMax - visual.smokeFrom) * 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));
+            const k = 0.5 + (tool.heat * heatMax - visual.smokeFrom) / 60;
+            effects.smoke(worldPositionOf(session, session.model.parts.muzzle, new THREE.Vector3()), new THREE.Vector3((random() - 0.5) * 0.015, 0.07 + random() * 0.08, (random() - 0.5) * 0.015), 4e-3 * k, 1.2 + random() * 0.6, Math.min(0.18, 0.06 + k * 0.04));
           }
         }
       }
@@ -5734,9 +7089,25 @@ function createViewmodel(options) {
       condition = next;
       if (session) applyCondition(kit, session.model, condition);
     },
+    handTargets() {
+      if (!session || !hold) return null;
+      hand.updateMatrixWorld(true);
+      const targets = targetsOf(THREE, hold, session.model.root.getWorldQuaternion(rootQuaternion), magazineHand, hold.works ? workWeights(hold.works, player?.running ?? []) : void 0);
+      const trigger = session.model.parts.trigger;
+      if (trigger) targets.fingers = { index: indexCurl(trigger.rotation.z - triggerRest, clock - lastShot) };
+      if (targets.R && "fov" in camera) {
+        seen.set(...targets.R.position).sub(camera.position).applyQuaternion(eyeTurn.copy(camera.quaternion).invert());
+        handDepth = -seen.z;
+        handHeight = handDepth > 0.05 ? seen.y / handDepth / Math.tan((camera.fov ?? 70) * PI14 / 360) : 0;
+      }
+      return targets;
+    },
     get inHand() {
       return session?.id ?? null;
     },
+    get clips() {
+      return (player?.running ?? []).map(({ name, clip }) => ({ name, seconds: clip.duration }));
+    },
     get casings() {
       return particles.count("casing");
     },
@@ -5759,6 +7130,7 @@ function createWeaponFx(options) {
   const model = createViewmodel({
     layers,
     ...options.soundDistance ? { soundDistance: options.soundDistance } : {},
+    ...options.onSound ? { onSound: options.onSound } : {},
     THREE: options.THREE,
     scene: options.scene,
     camera: options.camera,
@@ -5770,11 +7142,13 @@ function createWeaponFx(options) {
     ...options.condition ? { condition: options.condition } : {},
     ...options.attachmentModels ? { attachmentModels: options.attachmentModels } : {},
     ...options.raycast ? { raycast: options.raycast } : {},
-    ...options.effects ? { effects: options.effects } : {}
+    ...options.contact ? { contact: options.contact } : {},
+    ...options.effects ? { effects: options.effects } : {},
+    ...options.flyRocket === void 0 ? {} : { flyRocket: options.flyRocket }
   });
   return {
     handle(event, tool) {
-      if (event.type === "explosion") return;
+      if (event.type === "explosion" || event.type === "player") return;
       if (event.type === "tool") {
         if (hasWeaponModel(event.weapon)) box2.unequip();
         else model.unequip();
@@ -5787,10 +7161,14 @@ function createWeaponFx(options) {
       model.update(dt);
     },
     setCondition: (condition) => model.setCondition(condition),
+    handTargets: () => model.handTargets() ?? box2.handTargets(),
     layers,
     get inHand() {
       return model.inHand ?? box2.inHand;
     },
+    get clips() {
+      return model.clips;
+    },
     get casings() {
       return box2.casings + model.casings;
     },
@@ -6536,21 +7914,34 @@ function weaponThumbnailUrl(id, base = DEFAULT_THUMBNAIL_BASE) {
 }
 
 // src/world-explosives.ts
+import { buildItem } from "@adatechnology/game-items-three";
 var WORLD_EXPLOSIVE_PREFIX = "world_";
+var P13_VALVE_MESH = "valve";
+var P13_VALVE_COLOR = 12095802;
+var P13_WALL = 25e-4;
 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 },
+  propane_p13: {
+    shape: { kind: "cylinder", radius: 0.176, height: 0.49 },
+    position: [0, 0.245, 0],
+    color: 3497862,
+    model: { id: "lpg_cylinder_13kg", category: "fuel", size: [0.35299, 0.49, 0.35844], model: "lpg_cylinder_13kg" },
+    wall: P13_WALL
+  },
   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) => ({
+var explosivePart = (def, shape, scale) => ({
   id: "tank",
   material: "steel",
   shape: shape.shape,
   position: shape.position,
-  ...SHELL,
-  explodes: { energy: def.energy, radius: def.injuryRadius, effect: def.id, ...def.chain ? { chain: { ...def.chain } } : {} }
+  ...shape.wall === void 0 ? SHELL : { thickness: shape.wall },
+  // a real mass (the vessel and what it holds) replaces the hollow-sheet density
+  ...def.mass !== void 0 && shape.wall !== void 0 ? { mass: def.mass } : {},
+  ...def.leak ? { contains: { fluid: def.leak.fluid, liters: def.leak.liters, pressurized: def.leak.pressurized } } : {},
+  explodes: { energy: def.energy * scale, radius: def.injuryRadius * scale, lethalRadius: def.lethalRadius * scale, effect: def.id, ...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);
@@ -6562,16 +7953,55 @@ var meshOf = (THREE, shape) => {
   mesh.receiveShadow = true;
   return mesh;
 };
-var worldExplosiveItem = (def, name) => {
+var modelOf = (THREE, shape, wear = 0) => {
+  if (!shape.model) return void 0;
+  const { root, kind } = buildItem(THREE, shape.model, { wear });
+  if (kind !== "model") return void 0;
+  root.traverse((node) => {
+    const mesh = node;
+    if (!mesh.isMesh) return;
+    mesh.userData.destructionPart = "tank";
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    const material = mesh.material;
+    if (material.color?.getHex() === P13_VALVE_COLOR) mesh.name = P13_VALVE_MESH;
+  });
+  return root;
+};
+var worldExplosiveValve = (THREE, root) => {
+  const valve = root.getObjectByName(P13_VALVE_MESH);
+  if (!valve) return void 0;
+  root.updateMatrixWorld(true);
+  const centre = new THREE.Box3().setFromObject(valve).getCenter(new THREE.Vector3());
+  return [centre.x, centre.y, centre.z];
+};
+var worldExplosiveShell = (THREE, defId) => {
+  const shape = SHAPES2[defId];
+  const model = shape ? modelOf(THREE, shape, 2) : void 0;
+  if (!model) return void 0;
+  model.traverse((node) => {
+    const mesh = node;
+    if (!mesh.isMesh) return;
+    delete mesh.userData.destructionPart;
+    mesh.material.color.multiplyScalar(0.35);
+  });
+  model.name = `${WORLD_EXPLOSIVE_PREFIX}${defId}_shell`;
+  return model;
+};
+var worldExplosiveItem = (def, name, options = {}) => {
   const shape = SHAPES2[def.id];
   if (!shape) return void 0;
-  const spec = { name, parts: [explosivePart(def, shape)], joints: [], tags: ["explosive"] };
+  const scale = () => options.scale?.() ?? 1;
+  const spec = () => ({ name, parts: [explosivePart(def, shape, scale())], joints: [], tags: ["explosive"] });
   return {
     id: `${WORLD_EXPLOSIVE_PREFIX}${def.id}`,
     name,
     build: (THREE) => {
-      const group = new THREE.Group();
-      group.add(meshOf(THREE, shape));
+      const T = THREE;
+      const model = modelOf(T, shape);
+      if (model) return model;
+      const group = new T.Group();
+      group.add(meshOf(T, shape));
       return group;
     },
     spec
@@ -6623,6 +8053,100 @@ function createWorldEffects(options) {
   };
 }
 
+// src/scenarios.ts
+var TARGET_Z = -4;
+var SHOOTER_Z = -1.5;
+function weaponsScenarios(locale) {
+  const pt = locale.toLowerCase().startsWith("pt");
+  const T = (p, e) => pt ? p : e;
+  const faceY = (id) => id === "target_steel_plate" ? 1.35 : id === "target_plywood" ? 1.5 : 1.2;
+  const aimAt = (room, id) => room.look([0, faceY(id) + 0.05, SHOOTER_Z], [0, faceY(id), TARGET_Z]);
+  return [
+    {
+      id: "target_steel_heavy_through_hole",
+      name: T("Alvo de a\xE7o: um .50 BMG do Barrett M82A1 atravessa a chapa e o 9 mm s\xF3 amassa", "Steel target: the .50 BMG of the Barrett M82A1 goes through the plate and the 9 mm only dents it"),
+      run: ({ room, step, expect }) => {
+        const id = room.spawn("target_steel_plate", [0, 0, TARGET_Z]).objectId;
+        room.setTool("pistol_9mm");
+        room.waitUntilReady();
+        aimAt(room, "target_steel_plate");
+        room.use();
+        step(0.3);
+        const pistol = room.world.part(id, "face");
+        expect((pistol?.dents.length ?? 0) > 0 && !pistol?.holes.some((h) => h.through), T(`9 mm na chapa de 10 mm: amassados ${pistol?.dents.length ?? 0}, furos que atravessam ${pistol?.holes.filter((h) => h.through).length ?? 0} (esperado: amassa e n\xE3o atravessa)`, `9 mm on the 10 mm plate: dents ${pistol?.dents.length ?? 0}, through holes ${pistol?.holes.filter((h) => h.through).length ?? 0} (expected: dents it, no through hole)`));
+        room.setTool("barrett_m82a1");
+        room.waitUntilReady();
+        aimAt(room, "target_steel_plate");
+        room.use();
+        step(0.3);
+        const rifle = room.world.part(id, "face");
+        const hole = rifle?.holes.find((h) => h.through);
+        expect(!!hole, T(`.50 BMG na chapa: furo que atravessa ${hole ? "sim" : "n\xE3o"} (furos: ${rifle?.holes.length ?? 0})`, `.50 BMG on the plate: through hole ${hole ? "yes" : "no"} (holes: ${rifle?.holes.length ?? 0})`), { holes: rifle?.holes.length });
+      }
+    },
+    {
+      id: "target_concrete_stops_bullet",
+      name: T("Alvo de concreto: um 9 mm n\xE3o atravessa o bloco", "Concrete target: a 9 mm does not go through the block"),
+      run: ({ room, step, expect }) => {
+        const id = room.spawn("target_concrete", [0, 0, TARGET_Z]).objectId;
+        room.setTool("pistol_9mm");
+        room.waitUntilReady();
+        aimAt(room, "target_concrete");
+        room.use();
+        step(0.2);
+        const face = room.world.part(id, "face");
+        const through = face?.holes.some((h) => h.through) ?? true;
+        const marks = (face?.holes.length ?? 0) + (face?.dents.length ?? 0) + (face?.cracks.length ?? 0);
+        expect(!through && marks > 0, T(`Bloco de concreto: atravessou ${through ? "sim" : "n\xE3o"}, marcas ${marks} (esperado: n\xE3o atravessar e marcar)`, `Concrete block: went through ${through ? "yes" : "no"}, marks ${marks} (expected: stopped and marked)`), { through, marks });
+      }
+    },
+    {
+      id: "target_plywood_shotgun_holes",
+      name: T("Alvo de compensado: a escopeta de ferrolho crava v\xE1rios chumbos na madeira", "Plywood target: the pump shotgun drives several pellets through the wood"),
+      run: ({ room, step, expect }) => {
+        const id = room.spawn("target_plywood", [0, 0, TARGET_Z]).objectId;
+        room.setTool("shotgun_pump_12");
+        room.waitUntilReady();
+        aimAt(room, "target_plywood");
+        room.use();
+        step(1.1);
+        const holes = room.world.part(id, "face")?.holes.length ?? 0;
+        expect(holes >= 3, T(`Chumbos na madeira num tiro: ${holes} furos (esperado: 3 ou mais)`, `Pellets in the wood from one shot: ${holes} holes (expected: 3 or more)`), { holes });
+      }
+    },
+    {
+      id: "target_steel_hammer_dents",
+      name: T("Alvo de a\xE7o: a marreta amassa a chapa sem romper", "Steel target: the hammer dents the plate without breaking it"),
+      run: ({ room, step, expect }) => {
+        const id = room.spawn("target_steel_plate", [0, 0, TARGET_Z]).objectId;
+        room.setTool("hammer");
+        room.waitUntilReady();
+        room.look([0, 1.4, TARGET_Z + 0.65], [0, 1.35, TARGET_Z]);
+        let swings = 0;
+        for (; swings < 8 && (room.world.part(id, "face")?.dents.length ?? 0) === 0; swings++) {
+          room.use();
+          step(1);
+        }
+        const face = room.world.part(id, "face");
+        expect((face?.dents.length ?? 0) > 0 && face?.status !== "broken", T(`Amassados na chapa depois de ${swings} golpe(s): ${face?.dents.length ?? 0}`, `Dents in the plate after ${swings} swing(s): ${face?.dents.length ?? 0}`), { swings });
+      }
+    },
+    {
+      id: "target_steel_torch_melts",
+      name: T("Alvo de a\xE7o: o ma\xE7arico de corte derrete a chapa", "Steel target: the cutting torch melts the plate"),
+      run: ({ room, expect }) => {
+        const id = room.spawn("target_steel_plate", [0, 0, TARGET_Z]).objectId;
+        room.setTool("cutting_torch");
+        room.waitUntilReady();
+        room.look([0, faceY("target_steel_plate") + 0.05, TARGET_Z + 0.2], [0, faceY("target_steel_plate"), TARGET_Z]);
+        room.use(20);
+        const face = room.world.part(id, "face");
+        expect((face?.melt ?? 0) > 0.02 || face?.status === "melted" || (face?.holes.length ?? 0) > 0, T(`Chapa depois do ma\xE7arico: ${Math.round(face?.temperature ?? 0)} \xB0C, derretido ${Math.round((face?.melt ?? 0) * 100)}%`, `Plate after the torch: ${Math.round(face?.temperature ?? 0)} \xB0C, ${Math.round((face?.melt ?? 0) * 100)}% melted`), { temperature: face?.temperature, melt: face?.melt });
+      }
+    }
+  ];
+}
+
 // src/area.ts
 var WEAPON_ITEM_PREFIX = "weapon_";
 var COUNTER_ITEM_ID = "counter_weapons";
@@ -6658,6 +8182,10 @@ 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})",
+    reloadClip: "Reload of {weapon}: {kind}, clip {clip} ({seconds} s)",
+    soundCue: "Sound: {cue} ({weapon})",
+    soundCues: { mag_release: "magazine release button", mag_out: "magazine slides out", mag_insert: "magazine slides in", mag_seat: "magazine seats (click)", slide_release: "slide snaps forward", charging_handle_pull: "charging handle pulled", charging_handle_release: "charging handle released", bolt_lift: "bolt handle lifted", bolt_pull: "bolt pulled back", bolt_push: "bolt pushed forward", bolt_lock: "bolt handle locked down", shell_insert: "round inserted", pump_back: "pump back", pump_forward: "pump forward", lever_open: "lever down", lever_close: "lever up", cylinder_open: "cylinder opens", cylinder_eject: "cases fall out", speedloader: "speed loader empties", cylinder_close: "cylinder closes", barrels_open: "barrels open", casings_eject: "cases pop out", barrels_close: "barrels close", belt_cover_open: "cover opens", belt_insert: "belt seats", belt_cover_close: "cover closes", rocket_load: "rocket slides in", rocket_seat: "rocket seats", grenade_load: "grenade goes in", breech_open: "breech opens", breech_close: "breech closes", tube_drop: "empty tube dropped", tube_seat: "new tube seats" },
+    reloadKinds: { tactical: "tactical (round chambered, no pull)", empty: "empty chamber (works the action)", one_by_one: "one by one", full: "speed loader" },
     reloadEnd: "Reload done: {weapon} ({ammo}/{capacity})",
     worldExplosives: { fuel_barrel: "Fuel barrel", propane_p13: "Propane cylinder (P13)", car_fuel_tank: "Car fuel tank" },
     mountedM134: "M134 Minigun on its tripod",
@@ -6680,6 +8208,10 @@ 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})",
+    reloadClip: "Recarga de {weapon}: {kind}, clipe {clip} ({seconds} s)",
+    soundCue: "Som: {cue} ({weapon})",
+    soundCues: { mag_release: "bot\xE3o do carregador", mag_out: "carregador desliza para fora", mag_insert: "carregador desliza para dentro", mag_seat: "carregador encaixa (clique)", slide_release: "ferrolho volta com estalo", charging_handle_pull: "alavanca de armar puxada", charging_handle_release: "alavanca de armar solta", bolt_lift: "alavanca do ferrolho levantada", bolt_pull: "ferrolho puxado", bolt_push: "ferrolho empurrado", bolt_lock: "alavanca do ferrolho travada", shell_insert: "cartucho entra", pump_back: "bomba para tr\xE1s", pump_forward: "bomba para frente", lever_open: "alavanca para baixo", lever_close: "alavanca para cima", cylinder_open: "tambor abre", cylinder_eject: "c\xE1psulas caem", speedloader: "speedloader esvazia", cylinder_close: "tambor fecha", barrels_open: "canos abrem", casings_eject: "estojos saltam", barrels_close: "canos fecham", belt_cover_open: "tampa abre", belt_insert: "cinta encaixa", belt_cover_close: "tampa fecha", rocket_load: "foguete desliza para dentro", rocket_seat: "foguete encaixa", grenade_load: "granada entra", breech_open: "culatra abre", breech_close: "culatra fecha", tube_drop: "tubo vazio cai", tube_seat: "tubo novo encaixa" },
+    reloadKinds: { tactical: "t\xE1tica (com bala na c\xE2mara, sem puxar)", empty: "vazia (puxa o ferrolho ou a trava)", one_by_one: "uma a uma", full: "carregador r\xE1pido" },
     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" },
     mountedM134: "M134 Minigun no trip\xE9",
@@ -6832,6 +8364,7 @@ function createWeaponsTestModule(options = {}) {
       ...worldExplosives.map((item) => withThumbnail(item, item.id.slice(WORLD_EXPLOSIVE_PREFIX.length))),
       ...mountedM134.map((item) => withThumbnail(item, MOUNTED_M134.weaponId))
     ],
+    scenarios: (scenarioLocale) => weaponsScenarios(scenarioLocale ?? locale),
     area: () => ({
       placements: [
         ...weaponsLayout(weaponIds, pitchOf).filter((placement) => !placement.item.startsWith(WORLD_EXPLOSIVE_PREFIX) || worldExplosiveIds.has(placement.item)),
@@ -6874,7 +8407,10 @@ function createWeaponsTestModule(options = {}) {
         audio.dispose();
         audio = createWeaponAudio(void 0, { ...seedOption, engine: lentEngine });
       }
+      let simulatedMs = 0;
+      const offClock = lent.onFrame((dt) => simulatedMs += dt * 1e3);
       const created = createWeaponFx({
+        onSound: ({ weapon, cue: cue2, profile }) => lent.log(fill(text.soundCue, { weapon: arsenal.name(weapon), cue: text.soundCues[cue2] ?? cue2 }), { weapon, cue: cue2, weight: profile.weight, material: profile.material }, "sound"),
         THREE: lent.THREE,
         scene: lent.scene,
         camera: lent.camera,
@@ -6884,10 +8420,13 @@ function createWeaponsTestModule(options = {}) {
         tool: lent.tool,
         soundDistance: () => soundDistance,
         raycast: createLaserRaycast(lent.THREE, lent.scene, lent.camera),
+        // the weapon against a wall asks as often as the laser, on the clock of the simulation (so a fast-forwarded room measures as often per frame)
+        contact: createLaserRaycast(lent.THREE, lent.scene, lent.camera, { now: () => simulatedMs }),
         ...lent.effects ? { effects: lent.effects } : {},
         ...options.attachmentModels ? { attachmentModels: options.attachmentModels } : {},
         ...options.condition ? { condition: options.condition } : {},
-        ...options.seed === void 0 ? {} : { seed: options.seed }
+        ...options.seed === void 0 ? {} : { seed: options.seed },
+        ...options.flyRocket === void 0 ? {} : { flyRocket: options.flyRocket }
       });
       fx = created;
       const camera = lent.camera;
@@ -6918,15 +8457,25 @@ function createWeaponsTestModule(options = {}) {
         }
         const tool = lent.tool();
         created.handle(event, tool);
+        if (event.type === "reload" && event.phase === "start") {
+          const clip = created.clips.find((entry) => entry.name.startsWith("reload"));
+          if (clip) {
+            const kind = event.kind ?? "tactical";
+            lent.log(fill(text.reloadClip, { weapon: arsenal.name(event.weapon), kind: text.reloadKinds[kind] ?? kind, clip: clip.name, seconds: clip.seconds.toFixed(2) }), { weapon: event.weapon, kind, clip: clip.name, seconds: clip.seconds });
+          }
+        }
         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 = lent.onFrame((dt) => created.update(dt));
+      const offHands = lent.setHandTargets?.(() => created.handTargets());
       created.handle({ type: "tool", weapon: lent.tool().weapon }, lent.tool());
       return () => {
         accessories.dispose();
         offBench?.();
         offEvents();
         offFrame();
+        offClock();
+        offHands?.();
         created.dispose();
         audio?.dispose();
         fx = null;
@@ -6935,6 +8484,973 @@ function createWeaponsTestModule(options = {}) {
     }
   };
 }
+
+// src/explosives-area.ts
+import { EXPLOSIONS } from "@adatechnology/game-vfx";
+import { createArsenal as createArsenal2 } from "@adatechnology/game-weapons";
+
+// src/explosives-text.ts
+var EXPLOSIVES_TEXT = {
+  en: {
+    group: "Explosives",
+    name: "Explosives area",
+    cylinder: "Propane cylinder (P13)",
+    actions: {
+      shoot: { name: "Shoot the cylinder", hint: "Equips the 9 mm pistol, aims at the cylinder and fires: a hole in the shell, a white gas jet, a torch, the blast" },
+      valve: { name: "Open the valve", hint: "Opens (or closes) the valve: the gas leaks with no fire until a flame reaches it" },
+      light: { name: "Light it (lighter)", hint: "Holds a lighter flame at the valve: a gas leak catches fire and the cylinder goes off" },
+      fire: { name: "Throw it in the fire", hint: "Lights a fire next to the cylinder (and the table): the shell heats up until the fire chain sets it off" },
+      reset: { name: "Restart", hint: "Lays the scene again: a new cylinder, wall, furniture and people" }
+    },
+    blastScale: { name: "Blast strength (game multiplier)", hint: "Multiplies the energy and the lethal and injury radii of the P13 for the next one laid (restarts the scene). 1 is the arsenal; the arsenal itself is changed with ArsenalOptions.patch.explosives.propane_p13" },
+    layers: { rings: "Lethal and injury rings" },
+    metrics: { gas: "Gas left in the cylinder", clock: "Seconds since the first leak", phase: "Phase" },
+    phases: { rest: "At rest", leaking: "Leaking gas", torch: "Burning jet", primed: "About to go off", exploded: "Exploded" },
+    rings: { lethal: "lethal", injury: "injury" },
+    triggers: { shot: "a bullet", fire: "fire", explosion: "another blast" },
+    things: { zombie: "Zombie", survivor: "Survivor", fridge: "Fridge", kitchen_cabinet_base: "Kitchen cabinet", stove: "Stove", camp_table: "Table", can: "Can of beans", bottle: "Water bottle", chair: "Chair" },
+    verdicts: { wall_pieces: "broke loose into {pieces} pieces and cracked ({n} marks)", lost_parts: "lost {n} parts", dead: "dead", hurt: "hurt (vitality {vitality}%)", unhurt: "unhurt", wall_broken: "cracked and lost {n} brick panels", wall_cracked: "cracked ({n} marks)", wall_intact: "intact", burning: "burning", standing: "standing" },
+    log: {
+      leak_shot: "Hole of {diameter} mm in the shell: gas leaking at {rate} l/s ({liters} l left in the cylinder)",
+      leak_valve: "Valve open: gas leaking at {rate} l/s with no fire ({liters} l left in the cylinder)",
+      valve_closed: "Valve closed: the leak stopped ({liters} l left)",
+      valve_closed_late: "Too late to close the valve: the cylinder is already going off",
+      primed: "The cylinder was set off by {trigger}: it goes off in {delay} s",
+      jet_lit: "The jet caught fire (torch) {seconds} s after the hole; the cylinder goes off in {rest} s",
+      jet_lit_by: "The leaking gas caught fire (torch) from {by}; the cylinder goes off in {rest} s",
+      lighter_none: "Lighter flame at the valve: no gas is leaking, nothing happens",
+      lighter_lit: "Lighter flame at the leaking valve: the gas lights",
+      fire_set: "Fire lit next to the cylinder ({temperature} \xB0C, radius {radius} m): the shell heats up",
+      heating: "Shell at {temperature} \xB0C (the fire chain starts at {limit} \xB0C)",
+      explode: "Cylinder exploded: fireball of {fireball} m, lethal up to {lethal} m, injuries up to {injury} m (energy {energy} kJ, strength x{scale})",
+      shell: "The torn shell flew up at {speed} m/s trailing fire for {trail} s",
+      shell_landed: "The shell came down {distance} m away after {seconds} s",
+      residual: "Residual fire of {radius} m for {seconds} s",
+      aftermath_person: "{who} at {distance} m: {verdict}",
+      aftermath_wall: "Wall behind the cylinder: {verdict}",
+      aftermath_object: "{what} at {distance} m: {verdict}",
+      reset: "Scene laid again with a blast strength of x{scale}",
+      scale: "Blast strength x{scale}: energy {energy} kJ, lethal {lethal} m, injury {injury} m (valid for the next cylinder; the scene restarts)",
+      no_room: "The explosives area was loaded without the room: this action needs it",
+      shoot: "9 mm shot at the cylinder from {distance} m",
+      no_vessel: "There is no cylinder in the scene (restart it)"
+    },
+    sheet: {
+      kicker: "P13 cooking gas cylinder",
+      title: "What happens to a P13 under a bullet, a flame or a blast",
+      body: "Every kitchen has one. It goes off from a bullet or from fire, and it chains. The sequence is the Explosives Lab one (SC.p13): the gas jet hisses, catches fire as a torch, and the shell goes off.",
+      facts: { energy: "Energy", lethal: "Lethal radius", injury: "Injury radius", gas: "Gas", mass: "Mass", torch: "Torch after the hole", shot_chain: "Blast after a bullet", fire_chain: "Blast after fire" },
+      steps: [
+        { at: "0 s", text: "The bullet goes through the 2.5 mm steel shell: a white gas jet leaves the hole, hissing and shoving the cylinder" },
+        { at: "0.8 s", text: "The jet catches fire and burns as a torch at the hole" },
+        { at: "1.4 s", text: "The fuel fireball (light 70), the mushroom rises 7 m over 8 s, the shell flies up at 13 m/s trailing fire" },
+        { at: "1.4 s - 8.4 s", text: "Residual fire of 1.4 m for 7 s; walls, furniture and people inside the rings take the blast" }
+      ],
+      segments: { jet: "White gas jet", torch: "Torch", blast: "Blast" },
+      note: "Opening the valve leaks the gas with no fire; a flame near it lights the leak and the cylinder goes off 1.4 s later. The numbers come from the arsenal (propane_p13); the strength multiplier is a game value."
+    },
+    scenarios: {
+      shot: "P13 cylinder: a 9 mm through the shell leaks gas, the jet lights and the cylinder goes off with its chain delay",
+      shot_leak: "The shot made a gas leak with a white pressurized jet",
+      shot_ignite: "The jet caught fire (torch) between 0.7 and 1.0 s after the hole",
+      shot_explode: "The cylinder exploded within 1.6 s of the shot",
+      shot_zombie: "The zombie 3 m from the cylinder did not survive the blast",
+      shot_survivor: "The survivor 8 m away, past the lethal ring, is hurt but alive",
+      shot_wall: "The brick wall behind it was marked by the blast",
+      valve: "P13 cylinder: the open valve leaks gas without fire and the cylinder goes off only when a flame lights it",
+      valve_leak: "The open valve leaks gas",
+      valve_quiet: "Four seconds of leaking gas with no flame: no fire and no blast",
+      valve_lit: "The lighter flame lit the leak",
+      valve_explode: "The cylinder went off within 1.6 s of the flame",
+      fire: "P13 cylinder in a fire: the heat sets it off by the fire chain",
+      fire_explode: "The cylinder in the fire exploded",
+      chain: "P13 cylinder: another blast next to it sets it off by the explosion chain",
+      chain_explode: "The second cylinder exploded after the first one",
+      push_p13: "P13 blast: the loose items, the furniture and the people around it are thrown away from it, less the farther they stand",
+      push_grenade: "Thrown M67 grenade: the loose items and the people around it are thrown away from it, less the farther they stand",
+      push_told: "The explosion reached the host as an event",
+      push_found: "{n} bodies were laid around the blast to be measured ({kinds})",
+      push_outward: "Every body inside the reach moved away from the blast ({moved} of {n}, {least} m at the least)",
+      push_falloff: "{what}: the nearer one moved more than the farther one ({near} m at {nearDistance} m, {far} m at {farDistance} m)",
+      push_person: "{who} at {distance} m was pushed {moved} m away",
+      push_heavy: "{what} (too heavy to grab, not fixed) was moved {moved} m by the blast"
+    }
+  },
+  "pt-BR": {
+    group: "Explosivos",
+    name: "\xC1rea de explosivos",
+    cylinder: "Botij\xE3o de g\xE1s (P13)",
+    actions: {
+      shoot: { name: "Atirar no botij\xE3o", hint: "Equipa a pistola 9 mm, mira no botij\xE3o e atira: furo no casco, jato branco de g\xE1s, ma\xE7arico, explos\xE3o" },
+      valve: { name: "Abrir o registro", hint: "Abre (ou fecha) o registro: o g\xE1s vaza sem fogo at\xE9 uma chama encostar" },
+      light: { name: "Acender (isqueiro)", hint: "P\xF5e a chama de um isqueiro no registro: g\xE1s vazando pega fogo e o botij\xE3o explode" },
+      fire: { name: "Jogar no fogo", hint: "Acende um fogo ao lado do botij\xE3o (e da mesa): o casco esquenta at\xE9 a cadeia de fogo detonar" },
+      reset: { name: "Reiniciar", hint: "Monta a cena de novo: botij\xE3o novo, parede, m\xF3veis e pessoas" }
+    },
+    blastScale: { name: "For\xE7a da explos\xE3o (multiplicador de jogo)", hint: "Multiplica a energia e os raios letal e de ferimento do P13 para o pr\xF3ximo botij\xE3o montado (reinicia a cena). 1 \xE9 o arsenal; o arsenal em si muda com ArsenalOptions.patch.explosives.propane_p13" },
+    layers: { rings: "An\xE9is letal e de ferimento" },
+    metrics: { gas: "G\xE1s no botij\xE3o", clock: "Segundos desde o primeiro vazamento", phase: "Fase" },
+    phases: { rest: "Em repouso", leaking: "Vazando g\xE1s", torch: "Jato em chamas", primed: "Prestes a explodir", exploded: "Explodiu" },
+    rings: { lethal: "letal", injury: "ferimento" },
+    triggers: { shot: "um tiro", fire: "fogo", explosion: "outra explos\xE3o" },
+    things: { zombie: "Zumbi", survivor: "Sobrevivente", fridge: "Geladeira", kitchen_cabinet_base: "Arm\xE1rio de cozinha", stove: "Fog\xE3o", camp_table: "Mesa", can: "Lata de feij\xE3o", bottle: "Garrafa de \xE1gua", chair: "Cadeira" },
+    verdicts: { wall_pieces: "se soltou em {pieces} peda\xE7os e trincou ({n} marcas)", lost_parts: "perdeu {n} pe\xE7as", dead: "morto", hurt: "ferido (vitalidade {vitality}%)", unhurt: "ileso", wall_broken: "trincou e perdeu {n} pain\xE9is de tijolo", wall_cracked: "trincou ({n} marcas)", wall_intact: "intacta", burning: "pegando fogo", standing: "de p\xE9" },
+    log: {
+      leak_shot: "Furo de {diameter} mm no casco: g\xE1s vazando a {rate} l/s ({liters} l no botij\xE3o)",
+      leak_valve: "Registro aberto: g\xE1s vazando a {rate} l/s, sem fogo ({liters} l no botij\xE3o)",
+      valve_closed: "Registro fechado: o vazamento parou ({liters} l restantes)",
+      valve_closed_late: "Tarde demais para fechar o registro: o botij\xE3o j\xE1 vai explodir",
+      primed: "O botij\xE3o foi detonado por {trigger}: explode em {delay} s",
+      jet_lit: "O jato pegou fogo (ma\xE7arico) {seconds} s depois do furo; o botij\xE3o explode em {rest} s",
+      jet_lit_by: "O g\xE1s vazando pegou fogo (ma\xE7arico) por {by}; o botij\xE3o explode em {rest} s",
+      lighter_none: "Chama do isqueiro no registro: n\xE3o h\xE1 g\xE1s vazando, nada acontece",
+      lighter_lit: "Chama do isqueiro no registro que vaza: o g\xE1s acendeu",
+      fire_set: "Fogo aceso ao lado do botij\xE3o ({temperature} \xB0C, raio {radius} m): o casco esquenta",
+      heating: "Casco a {temperature} \xB0C (a cadeia de fogo come\xE7a em {limit} \xB0C)",
+      explode: "Botij\xE3o explodiu: bola de fogo de {fireball} m, letal at\xE9 {lethal} m, ferimentos at\xE9 {injury} m (energia {energy} kJ, for\xE7a x{scale})",
+      shell: "O casco rasgado voou para cima a {speed} m/s com rastro de fogo por {trail} s",
+      shell_landed: "O casco caiu a {distance} m depois de {seconds} s",
+      residual: "Fogo residual de {radius} m por {seconds} s",
+      aftermath_person: "{who} a {distance} m: {verdict}",
+      aftermath_wall: "Parede atr\xE1s do botij\xE3o: {verdict}",
+      aftermath_object: "{what} a {distance} m: {verdict}",
+      reset: "Cena montada de novo com for\xE7a de explos\xE3o x{scale}",
+      scale: "For\xE7a da explos\xE3o x{scale}: energia {energy} kJ, letal {lethal} m, ferimento {injury} m (vale para o pr\xF3ximo botij\xE3o; a cena reinicia)",
+      no_room: "A \xE1rea de explosivos foi carregada sem a sala: esta a\xE7\xE3o precisa dela",
+      shoot: "Tiro de 9 mm no botij\xE3o a {distance} m",
+      no_vessel: "N\xE3o h\xE1 botij\xE3o na cena (reinicie)"
+    },
+    sheet: {
+      kicker: "Botij\xE3o de g\xE1s de cozinha P13",
+      title: "O que acontece com um P13 sob um tiro, uma chama ou uma explos\xE3o",
+      body: "Toda cozinha tem um. Explode com tiro ou fogo, e entra em cadeia. A sequ\xEAncia \xE9 a do Laborat\xF3rio de Explos\xF5es (SC.p13): o jato de g\xE1s assobia, pega fogo como ma\xE7arico e o casco explode.",
+      facts: { energy: "Energia", lethal: "Raio letal", injury: "Raio de ferimento", gas: "G\xE1s", mass: "Massa", torch: "Ma\xE7arico ap\xF3s o furo", shot_chain: "Explos\xE3o ap\xF3s um tiro", fire_chain: "Explos\xE3o ap\xF3s fogo" },
+      steps: [
+        { at: "0 s", text: "A bala atravessa o casco de a\xE7o de 2,5 mm: um jato branco de g\xE1s sai do furo, assobiando e sacudindo o botij\xE3o" },
+        { at: "0,8 s", text: "O jato pega fogo e queima como ma\xE7arico no furo" },
+        { at: "1,4 s", text: "A bola de fogo de combust\xEDvel (luz 70), o cogumelo sobe 7 m em 8 s, o casco voa a 13 m/s com rastro de fogo" },
+        { at: "1,4 s - 8,4 s", text: "Fogo residual de 1,4 m por 7 s; paredes, m\xF3veis e pessoas dentro dos an\xE9is levam a explos\xE3o" }
+      ],
+      segments: { jet: "Jato branco de g\xE1s", torch: "Ma\xE7arico", blast: "Explos\xE3o" },
+      note: "Abrir o registro vaza o g\xE1s sem fogo; uma chama perto acende o vazamento e o botij\xE3o explode 1,4 s depois. Os n\xFAmeros v\xEAm do arsenal (propane_p13); o multiplicador de for\xE7a \xE9 um valor de jogo."
+    },
+    scenarios: {
+      shot: "Botij\xE3o P13: um 9 mm no casco vaza g\xE1s, o jato acende e o botij\xE3o explode com o atraso da cadeia",
+      shot_leak: "O tiro fez um vazamento de g\xE1s com jato branco pressurizado",
+      shot_ignite: "O jato pegou fogo (ma\xE7arico) entre 0,7 e 1,0 s depois do furo",
+      shot_explode: "O botij\xE3o explodiu at\xE9 1,6 s depois do tiro",
+      shot_zombie: "O zumbi a 3 m do botij\xE3o n\xE3o sobreviveu \xE0 explos\xE3o",
+      shot_survivor: "O sobrevivente a 8 m, depois do anel letal, fica ferido mas vivo",
+      shot_wall: "A parede de tijolo atr\xE1s dele ficou marcada pela explos\xE3o",
+      valve: "Botij\xE3o P13: o registro aberto vaza g\xE1s sem fogo e o botij\xE3o s\xF3 explode quando uma chama acende",
+      valve_leak: "O registro aberto vaza g\xE1s",
+      valve_quiet: "Quatro segundos de g\xE1s vazando sem chama: sem fogo e sem explos\xE3o",
+      valve_lit: "A chama do isqueiro acendeu o vazamento",
+      valve_explode: "O botij\xE3o explodiu at\xE9 1,6 s depois da chama",
+      fire: "Botij\xE3o P13 no fogo: o calor detona pela cadeia de fogo",
+      fire_explode: "O botij\xE3o no fogo explodiu",
+      chain: "Botij\xE3o P13: outra explos\xE3o ao lado detona pela cadeia de explos\xE3o",
+      chain_explode: "O segundo botij\xE3o explodiu depois do primeiro",
+      push_p13: "Explos\xE3o do P13: os itens soltos, os m\xF3veis e as pessoas em volta s\xE3o jogados para longe, menos quanto mais longe est\xE3o",
+      push_grenade: "Granada M67 arremessada: os itens soltos e as pessoas em volta s\xE3o jogados para longe, menos quanto mais longe est\xE3o",
+      push_told: "A explos\xE3o chegou ao host como evento",
+      push_found: "{n} corpos foram postos em volta da explos\xE3o para serem medidos ({kinds})",
+      push_outward: "Todo corpo dentro do alcance se afastou da explos\xE3o ({moved} de {n}, no m\xEDnimo {least} m)",
+      push_falloff: "{what}: o mais perto andou mais que o mais longe ({near} m a {nearDistance} m, {far} m a {farDistance} m)",
+      push_person: "{who} a {distance} m foi empurrado {moved} m para longe",
+      push_heavy: "{what} (pesado demais para pegar, mas solto) foi movido {moved} m pela explos\xE3o"
+    }
+  }
+};
+var explosivesTextOf = (locale) => EXPLOSIVES_TEXT[locale] ?? EXPLOSIVES_TEXT.en;
+var fillText2 = (template, vars) => template.replace(/\{(\w+)\}/g, (_, key) => String(vars[key] ?? ""));
+
+// src/explosives-bench.ts
+var EXPLOSIVES_AREA_ID = "explosives_area";
+var FLAME_C = 1100;
+var FLAME_RADIUS = 0.2;
+var FLAME_SECONDS = 0.3;
+var FIRE_CHAIN_C = 300;
+var FIRE_OFFSET = [0.4, 0, 0.15];
+var FIRE_VISUAL_RADIUS = 0.6;
+var HISS_SHOVE = 0.35;
+var AFTERMATH_DELAY = 2;
+var SHOOTER = "pistol_9mm";
+var AIM_HEIGHT = 0.2;
+var GRAVITY2 = 9.81;
+var REPORTED_OBJECTS = ["fridge", "kitchen_cabinet_base", "stove", "camp_table"];
+var RING_SEGMENTS = 128;
+var WALL_ID = "target_wall";
+var WALL_Z = -11;
+var dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var num = (value, digits = 1) => value.toFixed(digits);
+function createExplosivesBench(options) {
+  const { text, def, room, profile } = options;
+  const log = text.log;
+  let host = null;
+  let strength = options.blastScale;
+  let inArea = false;
+  let lastBlast;
+  let ringsOn = true;
+  let initial = true;
+  let aftermathDue = [];
+  const vessels = /* @__PURE__ */ new Map();
+  const wallParts = /* @__PURE__ */ new Set();
+  const shells = [];
+  const T = () => host?.THREE;
+  const now = () => room?.world.time ?? 0;
+  const say = (message, data = {}) => host?.log(message, { source: EXPLOSIVES_AREA_ID, ...data });
+  const leakConfig = def.leak;
+  const igniteDelay = leakConfig?.igniteDelay ?? 0.8;
+  const hissSeconds = leakConfig?.hissSeconds ?? igniteDelay;
+  const chainFire = (() => {
+    const fire2 = def.chain?.fire;
+    return fire2 === void 0 ? 1.4 : typeof fire2 === "number" ? fire2 : fire2[0];
+  })();
+  const liters = (vessel) => room?.world.part(vessel.objectId, "tank")?.liters ?? 0;
+  const throughHoles = (vessel) => room?.world.part(vessel.objectId, "tank")?.holes.filter((hole) => hole.through).length ?? 0;
+  const leaking = (vessel) => !vessel.exploded && liters(vessel) > 0 && throughHoles(vessel) > 0;
+  const centreOf = (vessel) => {
+    const p = vessel.root.getWorldPosition(new (T()).Vector3());
+    return [p.x, p.y + AIM_HEIGHT, p.z];
+  };
+  const valveOf = (vessel) => worldExplosiveValve(T(), vessel.root) ?? centreOf(vessel);
+  const target = () => [...vessels.values()].find((vessel) => !vessel.exploded) ?? [...vessels.values()][0];
+  const lethalOf = (vessel) => def.lethalRadius * vessel.scale;
+  const injuryOf = (vessel) => def.injuryRadius * vessel.scale;
+  const labelSprite = (words, colour, at) => {
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = 256;
+      canvas.height = 64;
+      const context = canvas.getContext("2d");
+      if (!context) return null;
+      context.fillStyle = colour;
+      context.font = "bold 40px sans-serif";
+      context.textAlign = "center";
+      context.fillText(words, 128, 46);
+      const sprite = new (T()).Sprite(new (T()).SpriteMaterial({ map: new (T()).CanvasTexture(canvas), transparent: true, depthWrite: false }));
+      sprite.scale.set(2.4, 0.6, 1);
+      sprite.position.set(...at);
+      return sprite;
+    } catch {
+      return null;
+    }
+  };
+  const ringLine = (radius, colour) => {
+    const points = [];
+    for (let i = 0; i < RING_SEGMENTS; i++) {
+      const angle = i / RING_SEGMENTS * Math.PI * 2;
+      points.push(Math.cos(angle) * radius, 0, Math.sin(angle) * radius);
+    }
+    const geometry = new (T()).BufferGeometry();
+    geometry.setAttribute("position", new (T()).Float32BufferAttribute(points, 3));
+    return new (T()).LineLoop(geometry, new (T()).LineBasicMaterial({ color: colour }));
+  };
+  const drawRings = (vessel) => {
+    const group = new (T()).Group();
+    group.name = "blast_rings";
+    const lethal = lethalOf(vessel);
+    const injury = injuryOf(vessel);
+    group.add(ringLine(lethal, 16726832), ringLine(injury, 16756768));
+    const lethalLabel = labelSprite(`${num(lethal, 0)} m ${text.rings.lethal}`, "#ff6a5e", [0, 0.35, lethal]);
+    const injuryLabel = labelSprite(`${num(injury, 0)} m ${text.rings.injury}`, "#ffc44d", [0, 0.35, injury]);
+    for (const label of [lethalLabel, injuryLabel]) if (label) group.add(label);
+    const p = vessel.root.getWorldPosition(new (T()).Vector3());
+    group.position.set(p.x, 0.03, p.z);
+    group.visible = ringsOn;
+    (host?.scene).add(group);
+    vessel.rings = group;
+  };
+  const clearRings = (vessel) => {
+    vessel.rings?.removeFromParent();
+    vessel.rings = void 0;
+  };
+  const phaseOf = (vessel) => {
+    if (!vessel) return "rest";
+    if (vessel.exploded) return "exploded";
+    if (vessel.explodeAt !== void 0) return "primed";
+    if (vessel.lit) return "torch";
+    return vessel.leakAt === void 0 ? "rest" : "leaking";
+  };
+  const ignite = (vessel, by) => {
+    if (vessel.lit || vessel.exploded || !room) return;
+    const leak = vessel.leaks[vessel.leaks.length - 1];
+    const point = leak?.point ?? valveOf(vessel);
+    room.world.hit(vessel.objectId, { type: "heat", point, temperature: FLAME_C, radius: FLAME_RADIUS, duration: FLAME_SECONDS, source: "p13_flame" });
+    vessel.lit = true;
+    vessel.litAt = now();
+    const rest = vessel.explodeAt === void 0 ? chainFire : Math.max(0, vessel.explodeAt - now());
+    if (by === "shot") say(fillText2(log.jet_lit, { seconds: num(now() - (vessel.leakAt ?? now()), 1), rest: num(rest, 1) }), { phase: "torch", objectId: vessel.objectId, seconds: now() - (vessel.leakAt ?? now()), rest });
+    else say(fillText2(log.lighter_lit, {}), { phase: "torch", objectId: vessel.objectId, by });
+  };
+  const shove = (vessel) => {
+    const leak = vessel.leaks[vessel.leaks.length - 1];
+    if (!room || !leak) return;
+    const [dx, dy, dz] = leak.direction;
+    const length = Math.hypot(dx, dy, dz) || 1;
+    room.renderer.impulse(vessel.objectId, [-dx / length * HISS_SHOVE, -dy / length * HISS_SHOVE * 0.2, -dz / length * HISS_SHOVE], leak.point);
+  };
+  const torchSprites = (vessel) => {
+    const leak = vessel.leaks[vessel.leaks.length - 1];
+    if (!room || !leak) return;
+    const [dx, dy, dz] = leak.direction;
+    const length = Math.hypot(dx, dy, dz) || 1;
+    const flame = () => 3 + Math.random() * 2.5;
+    for (let i = 0; i < 3; i++) room.vfx.spawn("fire", leak.point, [dx / length * flame() + (Math.random() - 0.5) * 0.7, dy / length * flame() + 0.6 + (Math.random() - 0.5) * 0.7, dz / length * flame() + (Math.random() - 0.5) * 0.7], { size: 0.45 + Math.random() * 0.35, life: 0.7 });
+    if (vessel.torchFrame++ % 3 === 0) room.vfx.spawn("smoke", leak.point, [dx / length * 2, 1.5, dz / length * 2], { size: 0.7, life: 1 });
+  };
+  const launchShell = (vessel, point) => {
+    const config = def.shell;
+    if (!config || !host) return;
+    const mesh = worldExplosiveShell(T(), def.id);
+    if (!mesh) return;
+    mesh.position.set(point[0], Math.max(point[1], 0.3), point[2]);
+    host.scene.add(mesh);
+    shells.push({
+      mesh,
+      position: [point[0], Math.max(point[1], 0.3), point[2]],
+      velocity: [(Math.random() - 0.5) * 3, config.launchSpeed, (Math.random() - 0.5) * 3],
+      spin: [(Math.random() - 0.5) * 12, (Math.random() - 0.5) * 6, (Math.random() - 0.5) * 12],
+      age: 0,
+      trail: config.trailSeconds,
+      landed: false,
+      start: point
+    });
+    say(fillText2(log.shell, { speed: num(config.launchSpeed, 0), trail: num(config.trailSeconds, 1) }), { phase: "shell", speed: config.launchSpeed, trailSeconds: config.trailSeconds });
+    void vessel;
+  };
+  const stepShells = (dt) => {
+    if (!host) return;
+    for (const shell of shells) {
+      if (shell.landed) continue;
+      shell.age += dt;
+      shell.velocity[1] -= GRAVITY2 * dt;
+      for (let axis = 0; axis < 3; axis++) shell.position[axis] = shell.position[axis] + shell.velocity[axis] * dt;
+      const ground = host.groundAt(shell.position[0], shell.position[2]) + 0.18;
+      if (shell.position[1] <= ground && shell.velocity[1] < 0) {
+        shell.position[1] = ground;
+        if (Math.abs(shell.velocity[1]) > 1.5) {
+          shell.velocity = [shell.velocity[0] * 0.5, -shell.velocity[1] * 0.35, shell.velocity[2] * 0.5];
+        } else {
+          shell.landed = true;
+          shell.mesh.rotation.set(Math.PI / 2, shell.mesh.rotation.y, 0);
+          const away = dist(shell.start, [shell.position[0], shell.position[1], shell.position[2]]);
+          say(fillText2(log.shell_landed, { distance: num(away, 1), seconds: num(shell.age, 1) }), { phase: "shell_landed", distance: away, seconds: shell.age });
+        }
+      } else {
+        shell.mesh.rotation.x += shell.spin[0] * dt;
+        shell.mesh.rotation.y += shell.spin[1] * dt;
+        shell.mesh.rotation.z += shell.spin[2] * dt;
+      }
+      shell.mesh.position.set(shell.position[0], shell.position[1], shell.position[2]);
+      if (room && shell.age < shell.trail) {
+        const at = [shell.position[0], shell.position[1], shell.position[2]];
+        room.vfx.spawn("fire", at, [(Math.random() - 0.5) * 0.6, -0.3 + Math.random() * 0.4, (Math.random() - 0.5) * 0.6], { size: 0.6, life: 0.6 });
+        room.vfx.spawn("smoke", at, [(Math.random() - 0.5) * 0.4, 0.2, (Math.random() - 0.5) * 0.4], { size: 0.7, life: 1.2 });
+      }
+    }
+  };
+  const clearShells = () => {
+    for (const shell of shells) shell.mesh.removeFromParent();
+    shells.length = 0;
+  };
+  const fullVitality = /* @__PURE__ */ new Map();
+  const witnesses = () => {
+    if (!room) return [];
+    const origin = [...vessels.values()][0]?.centre ?? options.scene.cylinder;
+    const found = [];
+    for (const spawned of room.spawned()) {
+      const position = spawned.root.getWorldPosition(new (T()).Vector3());
+      const at = [position.x, position.y, position.z];
+      const distance = dist([at[0], 0, at[2]], [origin[0], 0, origin[2]]);
+      if (spawned.itemId.startsWith("zombie_") || spawned.itemId.startsWith("person_")) {
+        const state = room.world.state(spawned.objectId);
+        const alive = state?.body?.alive ?? true;
+        const raw = state?.body?.vitality;
+        if (raw !== void 0) fullVitality.set(spawned.objectId, Math.max(fullVitality.get(spawned.objectId) ?? 0, raw));
+        const vitality = raw === void 0 ? void 0 : Math.max(0, raw) / Math.max(1e-9, fullVitality.get(spawned.objectId) ?? raw);
+        found.push({ kind: "person", id: spawned.objectId, itemId: spawned.itemId, distance, alive, ...vitality === void 0 ? {} : { vitality } });
+      } else if (REPORTED_OBJECTS.includes(spawned.itemId)) {
+        const parts = room.world.state(spawned.objectId)?.parts ?? [];
+        found.push({ kind: "object", id: spawned.objectId, itemId: spawned.itemId, distance, broken: parts.filter((part) => part.status === "broken").length, marks: parts.filter((part) => part.burning).length });
+      }
+    }
+    if (wallParts.size > 0) {
+      let broken = 0;
+      let marks = 0;
+      let pieces = 0;
+      for (const id of room.world.ids()) {
+        const mine = (room.world.state(id)?.parts ?? []).filter((part) => wallParts.has(part.id));
+        if (mine.length === 0) continue;
+        pieces++;
+        broken += mine.filter((part) => part.status === "broken").length;
+        marks += mine.reduce((n, part) => n + part.cracks.length + part.holes.length, 0);
+      }
+      found.push({ kind: "wall", id: "target_wall", itemId: "target_wall", distance: Math.abs(WALL_Z - origin[2]), broken, marks, pieces });
+    }
+    return found;
+  };
+  const whoIs = (itemId) => itemId.startsWith("zombie_") ? text.things.zombie : text.things.survivor;
+  const aftermath = (point) => {
+    for (const w of witnesses()) {
+      const distance = num(w.distance, 1);
+      if (w.kind === "person") {
+        const verdict = w.alive === false ? text.verdicts.dead : w.vitality !== void 0 && w.vitality < 0.999 ? fillText2(text.verdicts.hurt, { vitality: num(w.vitality * 100, 0) }) : text.verdicts.unhurt;
+        say(fillText2(log.aftermath_person, { who: whoIs(w.itemId), distance, verdict }), { phase: "aftermath", kind: w.kind, objectId: w.id, distance: w.distance, alive: w.alive, vitality: w.vitality, point });
+      } else if (w.kind === "wall") {
+        const verdict = (w.pieces ?? 1) > 1 ? fillText2(text.verdicts.wall_pieces, { pieces: w.pieces ?? 0, n: w.marks ?? 0 }) : (w.broken ?? 0) > 0 ? fillText2(text.verdicts.wall_broken, { n: w.broken ?? 0 }) : (w.marks ?? 0) > 0 ? fillText2(text.verdicts.wall_cracked, { n: w.marks ?? 0 }) : text.verdicts.wall_intact;
+        say(fillText2(log.aftermath_wall, { verdict }), { phase: "aftermath", kind: w.kind, objectId: w.id, broken: w.broken, marks: w.marks, pieces: w.pieces });
+      } else {
+        const verdict = (w.broken ?? 0) > 0 ? fillText2(text.verdicts.lost_parts, { n: w.broken ?? 0 }) : (w.marks ?? 0) > 0 ? text.verdicts.burning : text.verdicts.standing;
+        say(fillText2(log.aftermath_object, { what: text.things[w.itemId] ?? w.itemId, distance, verdict }), { phase: "aftermath", kind: w.kind, objectId: w.id, distance: w.distance, broken: w.broken });
+      }
+    }
+  };
+  const onEvent = (event) => {
+    const vessel = vessels.get(event.object);
+    if (!vessel || !("part" in event) || event.part !== "tank") return;
+    if (event.type === "leak") {
+      witnesses();
+      if (vessel.leakAt === void 0) {
+        vessel.leakAt = event.time;
+        vessel.cause = vessel.valveRequested ? "valve" : "shot";
+      }
+      vessel.valveRequested = false;
+      vessel.leaks.push({ point: event.point, direction: event.direction, rate: event.rate });
+      if (vessel.leaks.length > 8) vessel.leaks.shift();
+      const holes = room?.world.part(vessel.objectId, "tank")?.holes ?? [];
+      const diameter = (holes[holes.length - 1]?.diameter ?? 9e-3) * 1e3;
+      const vars = { diameter: num(diameter, 0), rate: num(event.rate, 2), liters: num(liters(vessel), 1) };
+      say(fillText2(vessel.cause === "valve" && vessel.leaks.length === 1 ? log.leak_valve : log.leak_shot, vars), { phase: "leak", objectId: vessel.objectId, cause: vessel.cause, ratePerS: event.rate, diameterMm: diameter, liters: liters(vessel), pressurized: event.pressurized });
+    } else if (event.type === "primed") {
+      vessel.explodeAt = event.time + event.delay;
+      say(fillText2(log.primed, { trigger: text.triggers[event.trigger], delay: num(event.delay, 1) }), { phase: "primed", objectId: vessel.objectId, trigger: event.trigger, delaySeconds: event.delay });
+    } else if (event.type === "explode") {
+      vessel.exploded = true;
+      vessel.explodedAt = event.time;
+      vessel.centre = event.point;
+      const radius = profile?.visualRadius;
+      const fireball = (radius ?? 2) * 2;
+      const lethal = lethalOf(vessel);
+      const injury = injuryOf(vessel);
+      say(fillText2(log.explode, { fireball: num(fireball, 1), lethal: num(lethal, 1), injury: num(injury, 1), energy: num(def.energy * vessel.scale / 1e3, 0), scale: num(vessel.scale, 2) }), {
+        phase: "explode",
+        objectId: vessel.objectId,
+        fireballMetres: fireball,
+        lethalRadius: lethal,
+        injuryRadius: injury,
+        energyJ: def.energy * vessel.scale,
+        scale: vessel.scale,
+        point: event.point,
+        sinceLeakSeconds: vessel.leakAt === void 0 ? void 0 : event.time - vessel.leakAt
+      });
+      const residual = profile?.residualFires?.[0];
+      if (residual) say(fillText2(log.residual, { radius: num(residual.radius, 1), seconds: num(residual.life, 0) }), { phase: "residual", radius: residual.radius, seconds: residual.life });
+      if (vessel.fireHandle !== void 0) room?.vfx.stop(vessel.fireHandle);
+      launchShell(vessel, event.point);
+      aftermathDue.push({ at: now() + AFTERMATH_DELAY, vessel, point: event.point });
+    }
+  };
+  const frame = (dt) => {
+    const t = now();
+    for (const vessel of vessels.values()) {
+      if (vessel.exploded) {
+        vessel.lit = false;
+        continue;
+      }
+      if (vessel.leakAt !== void 0) {
+        if (t - vessel.leakAt <= hissSeconds && leaking(vessel)) shove(vessel);
+        if (vessel.cause === "shot" && !vessel.lit && t - vessel.leakAt >= igniteDelay && leaking(vessel)) ignite(vessel, "shot");
+      }
+      if (vessel.lit) {
+        if (leaking(vessel)) torchSprites(vessel);
+        else vessel.lit = false;
+      }
+      if (vessel.fireUntil !== void 0 && t < vessel.fireUntil && room && vessel.firePoint) {
+        const fire2 = def.fire;
+        room.world.hit(vessel.objectId, { type: "heat", point: vessel.firePoint, temperature: fire2?.temperature ?? 700, radius: fire2?.radius ?? 1.4, duration: dt, source: "p13_fire" });
+        if (vessel.explodeAt === void 0 && t >= vessel.nextHeatLog) {
+          vessel.nextHeatLog = t + 1;
+          say(fillText2(log.heating, { temperature: num(room.world.part(vessel.objectId, "tank")?.temperature ?? 0, 0), limit: num(FIRE_CHAIN_C, 0) }), { phase: "heating", objectId: vessel.objectId });
+        }
+      }
+    }
+    stepShells(dt);
+    if (aftermathDue.length > 0) {
+      const ready = aftermathDue.filter((entry) => entry.at <= t);
+      aftermathDue = aftermathDue.filter((entry) => entry.at > t);
+      for (const entry of ready) aftermath(entry.point);
+    }
+  };
+  const needRoom = () => {
+    if (room) return true;
+    say(log.no_room);
+    return false;
+  };
+  const withVessel = () => {
+    const vessel = target();
+    if (!vessel || vessel.exploded) say(log.no_vessel);
+    return vessel && !vessel.exploded ? vessel : void 0;
+  };
+  const shoot = () => {
+    if (!needRoom() || !room || !host) return false;
+    const vessel = withVessel();
+    if (!vessel) return false;
+    if (host.tool().weapon !== SHOOTER) room.setTool(SHOOTER);
+    room.waitUntilReady();
+    const eye = host.camera.position;
+    const aim = centreOf(vessel);
+    room.look([eye.x, eye.y, eye.z], aim);
+    say(fillText2(log.shoot, { distance: num(dist([eye.x, eye.y, eye.z], aim), 1) }), { phase: "shoot", objectId: vessel.objectId, weapon: SHOOTER });
+    room.use();
+    return true;
+  };
+  const valve = () => {
+    if (!needRoom() || !room) return false;
+    const vessel = withVessel();
+    if (!vessel) return false;
+    if (vessel.valveOpen) {
+      if (vessel.explodeAt !== void 0) {
+        say(log.valve_closed_late, { phase: "valve", objectId: vessel.objectId });
+        return false;
+      }
+      room.world.seal(vessel.objectId, "tank");
+      vessel.valveOpen = false;
+      if (throughHoles(vessel) === 0) {
+        vessel.leakAt = void 0;
+        vessel.cause = void 0;
+        vessel.leaks = [];
+        vessel.lit = false;
+      }
+      say(fillText2(log.valve_closed, { liters: num(liters(vessel), 1) }), { phase: "valve_closed", objectId: vessel.objectId, liters: liters(vessel) });
+      return true;
+    }
+    vessel.valveRequested = true;
+    const opened = room.world.vent(vessel.objectId, "tank", { point: valveOf(vessel), normal: [0, 1, 0] });
+    vessel.valveRequested = false;
+    vessel.valveOpen = opened;
+    return opened;
+  };
+  const light = () => {
+    if (!needRoom() || !room) return false;
+    const vessel = withVessel();
+    if (!vessel) return false;
+    const at = vessel.leaks[vessel.leaks.length - 1]?.point ?? valveOf(vessel);
+    room.vfx.burst("fire", at, [0, 1, 0], 6, 0.8);
+    if (!leaking(vessel)) {
+      say(log.lighter_none, { phase: "lighter", objectId: vessel.objectId, leaking: false });
+      return false;
+    }
+    ignite(vessel, "lighter");
+    return true;
+  };
+  const fire = () => {
+    if (!needRoom() || !room) return false;
+    const vessel = withVessel();
+    if (!vessel) return false;
+    const base = vessel.root.getWorldPosition(new (T()).Vector3());
+    const point = [base.x + FIRE_OFFSET[0], base.y + FIRE_OFFSET[1], base.z + FIRE_OFFSET[2]];
+    const config = def.fire ?? { temperature: 700, radius: 1.4, seconds: 7 };
+    vessel.firePoint = point;
+    vessel.fireUntil = now() + config.seconds + 3;
+    vessel.nextHeatLog = now();
+    vessel.fireHandle = room.vfx.fire({ point, radius: FIRE_VISUAL_RADIUS, life: config.seconds + 3 });
+    for (const spawned of room.spawned()) {
+      if (spawned.itemId !== "camp_table") continue;
+      const top = spawned.root.getWorldPosition(new (T()).Vector3());
+      room.world.hit(spawned.objectId, { type: "heat", point: [top.x, top.y + 0.7, top.z], temperature: config.temperature + 200, radius: 0.9, duration: 3, source: "p13_fire" });
+    }
+    say(fillText2(log.fire_set, { temperature: num(config.temperature, 0), radius: num(config.radius, 1) }), { phase: "fire", objectId: vessel.objectId, temperatureC: config.temperature, radius: config.radius });
+    return true;
+  };
+  const reset = () => {
+    if (!needRoom() || !room) return false;
+    room.openArea(EXPLOSIVES_AREA_ID);
+    say(fillText2(log.reset, { scale: num(strength, 2) }), { phase: "reset", scale: strength });
+    return true;
+  };
+  const actionIds = ["shoot", "valve", "light", "fire", "reset"];
+  const actions = { shoot, valve, light, fire, reset };
+  const sheet = () => {
+    const energy = def.energy * strength / 1e3;
+    return {
+      kicker: text.sheet.kicker,
+      title: text.sheet.title,
+      body: text.sheet.body,
+      facts: [
+        { label: text.sheet.facts.energy, value: `${num(energy, 0)} kJ (x${num(strength, 2)})` },
+        { label: text.sheet.facts.lethal, value: `${num(def.lethalRadius * strength, 1)} m` },
+        { label: text.sheet.facts.injury, value: `${num(def.injuryRadius * strength, 1)} m` },
+        { label: text.sheet.facts.gas, value: `${num(leakConfig?.liters ?? 0, 0)} l` },
+        { label: text.sheet.facts.mass, value: `${num(def.mass ?? 0, 0)} kg` },
+        { label: text.sheet.facts.torch, value: `${num(igniteDelay, 1)} s` },
+        { label: text.sheet.facts.shot_chain, value: `${num(typeof def.chain?.shot === "number" ? def.chain.shot : def.chain?.shot?.[0] ?? 0, 1)} s` },
+        { label: text.sheet.facts.fire_chain, value: `${num(chainFire, 1)} s` }
+      ],
+      steps: text.sheet.steps,
+      note: text.sheet.note,
+      timeline: {
+        segments: [
+          { name: text.sheet.segments.jet, start: 0, end: igniteDelay, color: "#e8eef2" },
+          { name: text.sheet.segments.torch, start: igniteDelay, end: chainFire, color: "#ff9a2e" },
+          { name: text.sheet.segments.blast, start: chainFire, end: chainFire + 1, color: "#ff4d2e" }
+        ],
+        ticks: [0, igniteDelay, chainFire],
+        metric: "clock"
+      }
+    };
+  };
+  const adopt = (data) => {
+    const spawned = data;
+    if (spawned.itemId !== `${WORLD_EXPLOSIVE_PREFIX}${def.id}`) return;
+    const vessel = { objectId: spawned.objectId, root: spawned.root, scale: strength, leaks: [], valveRequested: false, valveOpen: false, lit: false, exploded: false, nextHeatLog: 0, torchFrame: 0 };
+    vessels.set(vessel.objectId, vessel);
+    if (wallParts.size === 0) for (const part of room?.world.state(WALL_ID)?.parts ?? []) wallParts.add(part.id);
+    if (inArea && host) drawRings(vessel);
+  };
+  const change = (change2) => {
+    if (change2.kind === "action") {
+      if (actionIds.includes(change2.id)) actions[change2.id]();
+    } else if (change2.kind === "layer" && change2.id === "rings") {
+      ringsOn = change2.on;
+      for (const vessel of vessels.values()) if (vessel.rings) vessel.rings.visible = ringsOn;
+    } else if (change2.kind === "control" && change2.id === "blast_scale" && typeof change2.value === "number") {
+      const first = initial;
+      initial = false;
+      if (change2.value === strength && !first) return;
+      strength = change2.value;
+      host?.bench?.sheet?.(sheet());
+      if (first) return;
+      say(fillText2(log.scale, { scale: num(strength, 2), energy: num(def.energy * strength / 1e3, 0), lethal: num(def.lethalRadius * strength, 1), injury: num(def.injuryRadius * strength, 1) }), { phase: "scale", scale: strength });
+      if (inArea) reset();
+    }
+  };
+  return {
+    room,
+    def,
+    blastScale: () => strength,
+    areaOpened: () => {
+      inArea = true;
+    },
+    controls: () => [
+      ...actionIds.map((id) => ({ kind: "action", id, name: text.actions[id].name, hint: text.actions[id].hint })),
+      { kind: "number", id: "blast_scale", name: text.blastScale.name, hint: text.blastScale.hint, unit: "x", min: 0.25, max: 3, step: 0.05, default: options.blastScale }
+    ],
+    layers: () => [{ id: "rings", name: text.layers.rings }],
+    metrics: () => [
+      { id: "gas", name: text.metrics.gas, unit: "l", digits: 1, max: leakConfig?.liters ?? 24, read: () => liters(target() ?? { objectId: "" }) },
+      { id: "clock", name: text.metrics.clock, unit: "s", digits: 2, read: () => {
+        const v = target();
+        return v?.leakAt === void 0 ? 0 : (v.explodedAt ?? now()) - v.leakAt;
+      } },
+      { id: "phase", name: text.metrics.phase, read: () => text.phases[phaseOf(target())] }
+    ],
+    attach(lent) {
+      host = lent;
+      const offs = [];
+      if (room) {
+        offs.push(room.world.on("*", onEvent));
+        offs.push(room.on("spawn", adopt));
+        for (const spawned of room.spawned()) adopt(spawned);
+      }
+      offs.push(
+        lent.on((event) => {
+          if (event.type === "explosion") lastBlast = { point: event.point, energy: event.energy, radius: event.radius, cause: event.cause, ...event.explosive === void 0 ? {} : { explosive: event.explosive } };
+        })
+      );
+      offs.push(lent.onFrame(frame));
+      offs.push(lent.bench?.onChange(change) ?? (() => void 0));
+      offs.push(
+        lent.onClear?.(() => {
+          for (const vessel of vessels.values()) clearRings(vessel);
+          vessels.clear();
+          clearShells();
+          wallParts.clear();
+          aftermathDue = [];
+          lastBlast = void 0;
+          inArea = false;
+        }) ?? (() => void 0)
+      );
+      lent.bench?.sheet?.(sheet());
+      return () => {
+        for (const off of offs) off();
+        for (const vessel of vessels.values()) clearRings(vessel);
+        vessels.clear();
+        clearShells();
+        host = null;
+      };
+    },
+    actions,
+    vessel: () => {
+      const v = target();
+      if (!v) return void 0;
+      return { objectId: v.objectId, leakAt: v.leakAt, litAt: v.litAt, explodedAt: v.explodedAt, cause: v.cause, valveOpen: v.valveOpen, lit: v.lit, exploded: v.exploded, point: v.leaks[v.leaks.length - 1]?.point };
+    },
+    lastBlast: () => lastBlast,
+    witnesses
+  };
+}
+
+// src/explosives-scenarios.ts
+var TORCH_WINDOW = [0.7, 1];
+var BLAST_WITHIN = 1.6;
+var CYLINDER_ITEM = `${WORLD_EXPLOSIVE_PREFIX}propane_p13`;
+var PUSH_KINDS = [
+  { kind: "can", item: "item_canned_beans" },
+  { kind: "bottle", item: "item_water_bottle" },
+  { kind: "chair", item: "dining_chair" }
+];
+var PUSH_READ_AT = 0.8;
+var MOVED = 0.15;
+var HEAVY_ITEMS = ["camp_table"];
+var flat = (a, b) => Math.hypot(a[0] - b[0], a[2] - b[2]);
+var bearing = (centre, distance, degrees) => [centre[0] + Math.sin(degrees * Math.PI / 180) * distance, 0, centre[2] + Math.cos(degrees * Math.PI / 180) * distance];
+var PUSH_LAYOUT = {
+  can: [[2.5, -52], [5, 12], [8, 78]],
+  bottle: [[2.5, 26], [5, -62], [8, -78]],
+  chair: [[2.5, -18], [5, 60], [8, -42]]
+};
+function pushScenario(all, bench, mode) {
+  const text = all.scenarios;
+  const things = all.things;
+  return {
+    id: `explosives_push_${mode}`,
+    name: mode === "p13" ? text.push_p13 : text.push_grenade,
+    run: ({ room, step, expect }) => {
+      let centre;
+      if (mode === "p13") {
+        room.openArea(EXPLOSIVES_AREA_ID);
+        const cylinder = room.spawned().find((spawned) => spawned.itemId === CYLINDER_ITEM);
+        const at = cylinder?.root?.position;
+        centre = [at?.x ?? 0, 0, at?.z ?? -10.66];
+      } else {
+        room.clear();
+        centre = [0, 0, -6];
+      }
+      const placed = [];
+      const lay = (kind, item, at) => {
+        try {
+          const spawned = room.spawn(item, at, 0);
+          placed.push({ kind, objectId: spawned.objectId, itemId: item, from: at, root: spawned.root });
+        } catch {
+        }
+      };
+      for (const { kind, item } of PUSH_KINDS) PUSH_LAYOUT[kind].forEach(([distance, degrees]) => lay(kind, item, bearing(centre, distance, degrees)));
+      if (mode === "grenade") {
+        lay("zombie", "zombie_walker", bearing(centre, 3.4, -34));
+        lay("survivor", "person_police_officer", bearing(centre, 7.5, 78));
+        lay("camp_table", "camp_table", bearing(centre, 3, 90));
+      }
+      step(0.6);
+      const start = (body) => [body.root.position.x, body.root.position.y, body.root.position.z];
+      const origin = new Map(placed.map((body) => [body.objectId, start(body)]));
+      const partsOf = (objectId) => room.world.state(objectId)?.parts.length ?? 0;
+      for (const spawned of room.spawned()) {
+        const known = placed.some((body2) => body2.objectId === spawned.objectId);
+        const role = spawned.itemId.startsWith("zombie_") ? "zombie" : spawned.itemId.startsWith("person_") ? "survivor" : HEAVY_ITEMS.includes(spawned.itemId) ? spawned.itemId : void 0;
+        if (known || !role || mode !== "p13") continue;
+        const root = spawned.root;
+        const body = { kind: role, objectId: spawned.objectId, itemId: spawned.itemId, from: [root.position.x, root.position.y, root.position.z], root };
+        placed.push(body);
+        origin.set(body.objectId, body.from);
+      }
+      const partsBefore = new Map(placed.map((body) => [body.objectId, partsOf(body.objectId)]));
+      expect(placed.length > 0, fillText2(text.push_found, { n: placed.length, kinds: [...new Set(placed.map((body) => body.kind))].join(", ") }), { placed: placed.map((body) => body.itemId) });
+      if (mode === "p13") bench.actions.shoot();
+      else {
+        room.setTool("frag_grenade");
+        step(0.5);
+        room.look([0, 1.6, 9.5], [0, 1, -2.5]);
+        room.use();
+      }
+      let waited = 0;
+      while (!bench.lastBlast() && waited < 9) {
+        step(0.05);
+        waited += 0.05;
+      }
+      const blast = bench.lastBlast();
+      expect(!!blast, text.push_told, { waited });
+      if (!blast) return;
+      step(PUSH_READ_AT);
+      const rows = placed.map((body) => {
+        const from = origin.get(body.objectId) ?? body.from;
+        const now = start(body);
+        const distance = flat(from, blast.point);
+        const away = Math.max(1e-6, distance);
+        const outward = ((now[0] - from[0]) * (from[0] - blast.point[0]) + (now[2] - from[2]) * (from[2] - blast.point[2])) / away;
+        return { ...body, distance, outward, moved: flat(now, from) };
+      });
+      const torn = (row) => PUSH_KINDS.some((entry) => entry.kind === row.kind) && partsOf(row.objectId) < (partsBefore.get(row.objectId) ?? 0);
+      const reached = rows.filter((row) => row.distance < blast.radius * 0.85 && !torn(row));
+      const movedAway = reached.filter((row) => row.outward >= MOVED);
+      const least = reached.length === 0 ? 0 : Math.min(...reached.map((row) => row.outward));
+      expect(reached.length > 0 && movedAway.length === reached.length, fillText2(text.push_outward, { moved: movedAway.length, n: reached.length, least: least.toFixed(2) }), { rows: reached.map((row) => ({ kind: row.kind, distance: row.distance, outward: row.outward })), torn: rows.filter(torn).map((row) => row.objectId) });
+      for (const { kind } of PUSH_KINDS) {
+        const ofKind = reached.filter((row) => row.kind === kind).sort((a, b) => a.distance - b.distance);
+        if (ofKind.length < 2) continue;
+        const near = ofKind[0];
+        const far = ofKind[ofKind.length - 1];
+        expect(near.outward > far.outward, fillText2(text.push_falloff, { what: things[kind] ?? kind, near: near.outward.toFixed(2), nearDistance: near.distance.toFixed(1), far: far.outward.toFixed(2), farDistance: far.distance.toFixed(1) }), { near: near.outward, far: far.outward });
+      }
+      for (const row of reached.filter((entry) => entry.kind === "zombie" || entry.kind === "survivor")) {
+        expect(row.outward >= MOVED, fillText2(text.push_person, { who: things[row.kind] ?? row.kind, distance: row.distance.toFixed(1), moved: row.outward.toFixed(2) }), { row });
+      }
+      const table = reached.find((row) => HEAVY_ITEMS.includes(row.kind));
+      if (table) expect(table.moved >= MOVED, fillText2(text.push_heavy, { what: things[table.itemId] ?? table.itemId, moved: table.moved.toFixed(2) }), { table });
+    }
+  };
+}
+function explosivesScenarios(locale, bench) {
+  const text = explosivesTextOf(locale).scenarios;
+  const record = (room) => {
+    const events = [];
+    const stop = room.world.on("*", (event) => {
+      if (event.object.startsWith(CYLINDER_ITEM)) events.push({ type: event.type, time: event.time, object: event.object });
+    });
+    return { events, stop };
+  };
+  const first = (events, type, after = -Infinity) => events.find((event) => event.type === type && event.time >= after);
+  return [
+    {
+      id: "explosives_p13_shot",
+      name: text.shot,
+      run: ({ room, step, expect }) => {
+        room.openArea(EXPLOSIVES_AREA_ID);
+        const { events, stop } = record(room);
+        bench.actions.shoot();
+        step(2.4);
+        stop();
+        const leak = first(events, "leak");
+        const explode = first(events, "explode");
+        const view = bench.vessel();
+        expect(!!leak, text.shot_leak, { events: events.map((event) => event.type) });
+        const torchAfter = view?.litAt !== void 0 && view.leakAt !== void 0 ? view.litAt - view.leakAt : -1;
+        expect(torchAfter >= TORCH_WINDOW[0] && torchAfter <= TORCH_WINDOW[1] + 0.05, `${text.shot_ignite} (${torchAfter.toFixed(2)} s)`, { torchAfter });
+        const blastAfter = leak && explode ? explode.time - leak.time : -1;
+        expect(blastAfter > 0 && blastAfter <= BLAST_WITHIN, `${text.shot_explode} (${blastAfter.toFixed(2)} s)`, { blastAfter });
+        const witnesses = bench.witnesses();
+        const zombie = witnesses.find((w) => w.itemId.startsWith("zombie_"));
+        expect(!!zombie && (zombie.alive === false || (zombie.vitality ?? 1) < 0.5), `${text.shot_zombie} (${zombie?.distance.toFixed(1)} m)`, { zombie });
+        const survivor = witnesses.find((w) => w.kind === "person" && !w.itemId.startsWith("zombie_"));
+        expect(!!survivor && survivor.alive === true && (survivor.vitality ?? 1) < 1, `${text.shot_survivor} (${survivor?.distance.toFixed(1)} m, ${survivor?.alive ? "alive" : "dead"})`, { survivor });
+        const wall = witnesses.find((w) => w.kind === "wall");
+        expect((wall?.marks ?? 0) + (wall?.broken ?? 0) + ((wall?.pieces ?? 1) - 1) > 0, text.shot_wall, { wall });
+      }
+    },
+    {
+      id: "explosives_p13_valve",
+      name: text.valve,
+      run: ({ room, step, expect }) => {
+        room.openArea(EXPLOSIVES_AREA_ID);
+        const { events, stop } = record(room);
+        bench.actions.valve();
+        step(4);
+        expect(!!first(events, "leak"), text.valve_leak);
+        expect(!first(events, "primed") && !first(events, "explode"), text.valve_quiet, { events: events.map((event) => event.type) });
+        const before = room.world.time;
+        bench.actions.light();
+        step(2.2);
+        stop();
+        expect(bench.vessel()?.lit === true || bench.vessel()?.litAt !== void 0, text.valve_lit);
+        const explode = first(events, "explode", before);
+        expect(!!explode && explode.time - before <= BLAST_WITHIN, `${text.valve_explode} (${explode ? (explode.time - before).toFixed(2) : "no blast"} s)`, { after: explode ? explode.time - before : null });
+      }
+    },
+    {
+      id: "explosives_p13_fire",
+      name: text.fire,
+      run: ({ room, step, expect }) => {
+        room.openArea(EXPLOSIVES_AREA_ID);
+        const { events, stop } = record(room);
+        bench.actions.fire();
+        step(8);
+        stop();
+        expect(!!first(events, "explode"), text.fire_explode, { events: events.map((event) => event.type) });
+      }
+    },
+    {
+      id: "explosives_p13_chain",
+      name: text.chain,
+      run: ({ room, step, expect }) => {
+        room.openArea(EXPLOSIVES_AREA_ID);
+        const near = [1, 0, -10];
+        const second = room.spawn(CYLINDER_ITEM, near, 0);
+        const { events, stop } = record(room);
+        bench.actions.shoot();
+        step(4);
+        stop();
+        const blasts = events.filter((event) => event.type === "explode");
+        const other = blasts.find((event) => event.object === second.objectId);
+        expect(blasts.length >= 2 && !!other, `${text.chain_explode} (${blasts.length} blasts)`, { blasts: blasts.map((event) => `${event.object}@${event.time.toFixed(2)}`) });
+      }
+    },
+    pushScenario(explosivesTextOf(locale), bench, "p13"),
+    pushScenario(explosivesTextOf(locale), bench, "grenade")
+  ];
+}
+
+// src/explosives-area.ts
+var DEFAULT_EXPLOSIVES_SCENE = {
+  furniture: [
+    { item: "fridge", at: [-1.65, 0, -10.55] },
+    { item: "kitchen_cabinet_base", at: [-0.78, 0, -10.6] },
+    { item: "stove", at: [0.72, 0, -10.58] },
+    { item: "camp_table", at: [2.4, 0, -10.2] }
+  ],
+  cylinder: [0.02, 0, -10.66],
+  zombie: { item: "zombie_walker", at: [-1.6, 0, -8.1] },
+  survivor: { item: "person_police_officer", at: [6, 0, -5.3] },
+  eye: [0, 1.7, -4.7]
+};
+var EXPLOSIVE_ID = "propane_p13";
+var AIM_HEIGHT2 = 0.25;
+function createExplosivesTestModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const arsenal = options.arsenal ?? createArsenal2({ locale });
+  const text = explosivesTextOf(locale);
+  const scene = { ...DEFAULT_EXPLOSIVES_SCENE, ...options.scene };
+  const def = arsenal.explosives.get(EXPLOSIVE_ID);
+  if (!def) throw new Error(`explosives area: the arsenal has no "${EXPLOSIVE_ID}"`);
+  const bench = createExplosivesBench({ locale, text, def, scene, room: options.room, blastScale: options.blastScale ?? 1, profile: EXPLOSIONS[EXPLOSIVE_ID] });
+  return {
+    id: EXPLOSIVES_AREA_ID,
+    name: text.name,
+    group: text.group,
+    bench,
+    // the cylinder of this area is the world explosive of the weapons module with the bench's strength: the same id, the same model, the same part
+    items: () => {
+      const item = worldExplosiveItem(def, text.cylinder, { scale: () => bench.blastScale() });
+      return item ? [item] : [];
+    },
+    area: () => {
+      bench.areaOpened();
+      const placements = [
+        ...scene.furniture.map((piece) => ({ item: piece.item, position: piece.at, ...piece.rotationY === void 0 ? {} : { rotationY: piece.rotationY } })),
+        { item: `${WORLD_EXPLOSIVE_PREFIX}${EXPLOSIVE_ID}`, position: scene.cylinder },
+        // facing the cylinder (the front of an item looks to +z, the cylinder is at -z)
+        { item: scene.zombie.item, position: scene.zombie.at, rotationY: Math.PI },
+        { item: scene.survivor.item, position: scene.survivor.at, rotationY: Math.PI }
+      ];
+      const centre = [scene.cylinder[0], AIM_HEIGHT2, scene.cylinder[2]];
+      return { placements, view: { eye: scene.eye, target: centre } };
+    },
+    controls: () => bench.controls(),
+    layers: () => bench.layers(),
+    metrics: () => bench.metrics(),
+    scenarios: (scenarioLocale) => explosivesScenarios(scenarioLocale ?? locale, bench),
+    attach: (host) => bench.attach(host)
+  };
+}
+
+// src/projectile-model.ts
+function projectileModel(THREE, query) {
+  if (query.kind !== "rocket") return null;
+  const launcher = buildWeaponModelById(THREE, query.weapon);
+  if (!launcher || launcher.parts.family !== "rocket") return null;
+  const round2 = launcher.parts.makeRound ? launcher.parts.makeRound() : buildFlyingRocket(modelKit(THREE), launcher.parts.launcherType);
+  return { model: round2, axis: [1, 0, 0] };
+}
 export {
   ARCHETYPE_MODELS,
   ATTACHMENT_MODELS,
@@ -6942,12 +9458,16 @@ export {
   CLASS_REFERENCE_ENERGY,
   COUNTER_ITEM_ID,
   DEFAULT_ENERGY_CURVE,
+  DEFAULT_EXPLOSIVES_SCENE,
   DEFAULT_THUMBNAIL_BASE,
+  EXPLOSIVES_AREA_ID,
+  EXPLOSIVES_TEXT,
   GAME_DISTANCE_CURVE,
   GAME_SOUND_CLASSES,
   MECHANICAL_SOUNDS,
   MODEL_ENTRIES,
   MOUNTED_M134_ITEM_ID,
+  P13_VALVE_MESH,
   WEAPON_ITEM_PREFIX,
   WEAPON_THUMBNAILS,
   WORLD_EFFECTS,
@@ -6963,23 +9483,28 @@ export {
   buildWeaponModelById,
   cartridgeShape,
   computeShotSound,
+  createExplosivesTestModule,
   createWeaponAudio,
   createWeaponFx,
   createWeaponsTestModule,
   createWorldEffects,
   deriveFrames,
+  explosivesTextOf,
   fitAttachmentModels,
   hasWeaponModel,
   mechanicalSoundOf,
   modelKit,
   mountFrame,
   partRegistry,
+  projectileModel,
   rigStock,
   rigUnderbarrel,
   weaponProp,
   weaponThumbnailCredit,
   weaponThumbnailUrl,
   weaponsLayout,
-  worldExplosiveItem
+  worldExplosiveItem,
+  worldExplosiveShell,
+  worldExplosiveValve
 };
 //# sourceMappingURL=index.js.map