@adatechnology/game-test-room 0.7.0 → 0.9.0

package/dist/index.global.js

@@ -341,6 +341,37 @@ var GameTestRoom = (() => {
     }
     return { ok: problems.length === 0, problems };
   }
+  var DEFAULT_ENVIRONMENT = {
+    rain: 0,
+    windX: 0,
+    windZ: 0,
+    windSpeed: 0,
+    gust: 0,
+    fogFar: 220,
+    visibility: 220,
+    nightFactor: 0,
+    temperatureC: 20,
+    wetness: 0
+  };
+  function createEnvironmentBus(initial = {}) {
+    let state = { ...DEFAULT_ENVIRONMENT, ...initial };
+    const listeners = /* @__PURE__ */ new Set();
+    return {
+      get: () => state,
+      set(patch) {
+        const changed = Object.keys(patch).filter((key) => patch[key] !== void 0 && patch[key] !== state[key]);
+        if (changed.length === 0) return;
+        const next = { ...state };
+        for (const key of changed) next[key] = patch[key];
+        state = next;
+        for (const listener of [...listeners]) listener(state, changed);
+      },
+      on(listener) {
+        listeners.add(listener);
+        return () => void listeners.delete(listener);
+      }
+    };
+  }
 
   // ../game-destruction/dist/index.js
   var FIRE_PRIME_C = 300;
@@ -836,9 +867,9 @@ var GameTestRoom = (() => {
     const step = count > 1 && room / (count - 1) < spacing ? room / (count - 1) : spacing;
     return Array.from({ length: count }, (_, i) => (i - (count - 1) / 2) * step);
   };
-  var bar = (axis2, along, fixed) => {
+  var bar = (axis2, along, fixed2) => {
     const a = [0, 0, 0], b = [0, 0, 0];
-    for (const [index, value] of fixed) {
+    for (const [index, value] of fixed2) {
       a[index] = value;
       b[index] = value;
     }
@@ -1159,7 +1190,8 @@ var GameTestRoom = (() => {
         0.25
       ],
       damageScale: {
-        blunt: 1.5
+        blunt: 1.5,
+        shelter: 3
       },
       hitDebris: "shards",
       breakDebris: "shards",
@@ -1210,7 +1242,10 @@ var GameTestRoom = (() => {
         "glass",
         "brittle"
       ],
-      compressive: 2e5
+      compressive: 2e5,
+      damageScale: {
+        shelter: 3
+      }
     },
     {
       id: "ceramic",
@@ -1890,10 +1925,14 @@ var GameTestRoom = (() => {
   };
   var DMG_PER_J = 0.02;
   var BLAST_COUPLING = 0.1;
+  var SHELTER_DEFAULTS = { k: 2800, brokenTransmission: 0.5, minPath: 5e-3 };
+  var FRAGMENT_HIT_DEFAULTS = { max: 24, energyFactor: 0.5, hitType: "blunt", range: 6, flightTime: 0.4, spread: 10, aim: 40 };
+  var CONFINEMENT_DEFAULTS = { rays: 26, reach: 1.5, gain: 1.5, power: 2, max: 3 };
   var FLAMMABLE_FLUIDS = ["gas", "fuel"];
   var BREACH_RADIUS = 0.55;
   var BREACH_BLAST_FACTOR = 6;
   var BREACH_AREA = 0.25;
+  var BREACH_BLAST_REACH = Infinity;
   var RESIDUAL_CAPACITY = 0.15;
   var UNIT_FRAGMENT_FACTOR = 4;
   var BREACH_GRID_CAP = 4096;
@@ -1928,6 +1967,7 @@ var GameTestRoom = (() => {
     const fireSpread = options.fireSpread ?? 0.6;
     const breachRadius = options.breach?.radius ?? BREACH_RADIUS;
     const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
+    const breachBlastReach = options.breach?.blastReach ?? BREACH_BLAST_REACH;
     const rng = createRng(options.seed ?? 1);
     const rnd2 = () => rng.next();
     let time = 0;
@@ -2283,7 +2323,7 @@ var GameTestRoom = (() => {
       if (disc < 0) return true;
       return -b - Math.sqrt(disc) > maxDist;
     };
-    const raycastInternal = (origin, dir, maxDist, ignore) => {
+    const raycastInternal = (origin, dir, maxDist, ignore, worldOnly = false) => {
       const d = vec.normalize(dir);
       let best = null;
       for (const o of objects.values()) {
@@ -2296,7 +2336,7 @@ var GameTestRoom = (() => {
           if (!best || r.t0 < best.distance) best = { object: o.id, part: p.spec.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
         }
       }
-      for (const im of impls.values()) {
+      for (const im of worldOnly ? [] : impls.values()) {
         for (const ps of im.impl.describe().parts) {
           if (ignore?.has(`${im.impl.id}\0${ps.id}`)) continue;
           const ov = im.poses.get(ps.id);
@@ -2709,7 +2749,7 @@ var GameTestRoom = (() => {
       else if (chained && (trigger === "explosion" || 1 - p.st.hp / p.st.maxHp >= shotDamageFractionOf(p.spec))) prime(o, p, trigger, src);
       return done;
     };
-    const ballistic2 = (o, p, entry, n, d, E, caliber, pathLen, src) => {
+    const ballistic2 = (o, p, entry, n, d, E, caliber, pathLen, src, piercing = 1) => {
       const mat = p.mat;
       if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry))) {
         return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry, d, Math.min(pathLen, p.thickness)), damage: 0 };
@@ -2722,7 +2762,9 @@ var GameTestRoom = (() => {
       const exitLocal = objLocal(o, vec.madd(entry, d, Math.min(pathLen, effM)));
       const coats = p.layers.length > 0 ? layersEnergy(p.layers, p.rt.spalls, face, objLocal(o, entry)) + layersEnergy(p.layers, p.rt.spalls, -face, exitLocal) : 0;
       const thr = coats > 0 ? (mat.penetration * p.thickness * 1e3 + coats) / slant : mat.penetration * effM * 1e3;
-      const penetrated = E > thr;
+      const hard = mat.tags?.includes("metal") || mat.tags?.includes("masonry");
+      const Ep = piercing === 1 || !hard ? E : E * piercing;
+      const penetrated = Ep > thr;
       const scale2 = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
       const id = p.spec.id;
       if (!penetrated && mat.ricochetDeg && angle < mat.ricochetDeg) {
@@ -2734,7 +2776,7 @@ var GameTestRoom = (() => {
       }
       if (p.layers.length > 0) spallOuter(o, p, entry, face, n, Math.max(0.03, caliber / 1e3 * 4), src);
       const brittle = mat.ductility < 0.3;
-      const ratio = E / Math.max(thr, 1e-6);
+      const ratio = Ep / Math.max(thr, 1e-6);
       const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
       let exitPoint;
       if (penetrated) {
@@ -2764,7 +2806,7 @@ var GameTestRoom = (() => {
       debris2(o, p, mat.hitDebris, entry, n, clamp2(Math.round(E / 60) + 2, 2, 14), clamp2(Math.sqrt(E) / 6, 1, 8), src);
       wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true);
       const dmg = applyDamage(o, p, E * DMG_PER_J * scale2, "ballistic", entry, d, E * 0.1, 12, src);
-      return { penetrated, exitEnergy: penetrated ? E - thr : 0, exitPoint, damage: dmg };
+      return { penetrated, exitEnergy: penetrated ? E - thr / (hard ? piercing : 1) : 0, exitPoint, damage: dmg };
     };
     const melee = (o, p, kind, E, point, n, d, contactR, src) => {
       const mat = p.mat;
@@ -2792,54 +2834,110 @@ var GameTestRoom = (() => {
       addBreach(o, p, point, breachAreaOf(p, done, false), E, d, src);
       return done;
     };
+    const blastPart = (o, p, point, energy, radius, src, res, reachAt) => {
+      if (isLost(p)) return null;
+      const { c, q } = partXf(o, p);
+      const lp = toLocal(c, q, point);
+      const dist = distanceToShape(p.spec.shape, lp);
+      if (dist >= radius) return null;
+      const sp = surfacePoint(p.spec.shape, lp);
+      const wp = toWorld(c, q, sp.point);
+      const reach = reachAt ? reachAt(wp, p) : 1;
+      const f = (1 - dist / radius) ** 2 * reach;
+      const Ein = energy * f * BLAST_COUPLING;
+      const wn = rotateVec(q, sp.normal);
+      if (!res.part) {
+        res.part = p.spec.id;
+        res.point = wp;
+      }
+      const mat = p.mat;
+      if (Ein > 20) {
+        if (mat.ductility >= 0.5) addDent(o, p, wp, wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), clamp2(4e-3 + Ein * 2e-5, 4e-3, 0.08), src);
+        else if (mat.ductility < 0.3 && Ein > 60) addCrack(o, p, wp, wn, clamp2(0.05 + Ein * 5e-4, 0.05, 1), src);
+        debris2(o, p, mat.hitDebris, wp, wn, clamp2(Math.round(Ein / 80) + 1, 1, 12), clamp2(Math.sqrt(Ein) / 4, 2, 15), src);
+      }
+      const th = mat.thermal;
+      if (th.ignitionC !== void 0 && p.st.fuel > 0) {
+        p.st.temperature += 300 * f;
+        o.active = true;
+        if (f >= 0.25 && !p.st.burning) {
+          p.st.temperature = Math.max(p.st.temperature, th.ignitionC + 1);
+          checkIgnite(o, p, src);
+        }
+      }
+      wearJoints(o, p, Ein * 0.5, void 0, 0, src);
+      const amount = Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1);
+      if (blastFrontSpeed > 0 && dist > 0 && mat.tags?.includes("glass")) {
+        frontQueue.push({ o, p, due: time + dist / blastFrontSpeed, amount, fragEnergy: Ein * 0.3, point, ...src !== void 0 ? { src } : {} });
+        return reach;
+      }
+      if (Ein > 20 && p.layers.length > 0) spallOuter(o, p, wp, faceOf(o, p, wn), wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), src);
+      const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
+      res.damage += dealt;
+      if (dist <= breachBlastReach * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
+      return reach;
+    };
     const blastObject = (o, point, energy, radius, src) => {
       const start = cur.length;
       const res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
-      for (const p of o.parts) {
-        if (isLost(p)) continue;
-        const { c, q } = partXf(o, p);
-        const lp = toLocal(c, q, point);
-        const dist = distanceToShape(p.spec.shape, lp);
-        if (dist >= radius) continue;
-        const f = (1 - dist / radius) ** 2;
-        const Ein = energy * f * BLAST_COUPLING;
-        const sp = surfacePoint(p.spec.shape, lp);
-        const wp = toWorld(c, q, sp.point);
-        const wn = rotateVec(q, sp.normal);
-        if (!res.part) {
-          res.part = p.spec.id;
-          res.point = wp;
-        }
-        const mat = p.mat;
-        if (Ein > 20) {
-          if (mat.ductility >= 0.5) addDent(o, p, wp, wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), clamp2(4e-3 + Ein * 2e-5, 4e-3, 0.08), src);
-          else if (mat.ductility < 0.3 && Ein > 60) addCrack(o, p, wp, wn, clamp2(0.05 + Ein * 5e-4, 0.05, 1), src);
-          debris2(o, p, mat.hitDebris, wp, wn, clamp2(Math.round(Ein / 80) + 1, 1, 12), clamp2(Math.sqrt(Ein) / 4, 2, 15), src);
-        }
-        const th = mat.thermal;
-        if (th.ignitionC !== void 0 && p.st.fuel > 0) {
-          p.st.temperature += 300 * f;
-          o.active = true;
-          if (f >= 0.25 && !p.st.burning) {
-            p.st.temperature = Math.max(p.st.temperature, th.ignitionC + 1);
-            checkIgnite(o, p, src);
-          }
+      for (const p of o.parts) blastPart(o, p, point, energy, radius, src, res);
+      res.events = cur.slice(start);
+      return res;
+    };
+    const blastCfg = (call3) => {
+      const pick3 = (key) => call3 && call3[key] !== void 0 ? call3[key] : options.blast?.[key];
+      const merge = (v, defaults) => {
+        if (!v) return null;
+        const out = { ...defaults };
+        if (v !== true) {
+          for (const [key, value] of Object.entries(v)) if (value !== void 0) out[key] = value;
         }
-        wearJoints(o, p, Ein * 0.5, void 0, 0, src);
-        const amount = Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1);
-        if (blastFrontSpeed > 0 && dist > 0 && mat.tags?.includes("glass")) {
-          frontQueue.push({ o, p, due: time + dist / blastFrontSpeed, amount, fragEnergy: Ein * 0.3, point, ...src !== void 0 ? { src } : {} });
-          continue;
+        return out;
+      };
+      const conf = pick3("confinement");
+      return {
+        shelter: merge(pick3("shelter"), SHELTER_DEFAULTS),
+        frag: merge(pick3("fragmentHits"), FRAGMENT_HIT_DEFAULTS),
+        conf: typeof conf === "number" ? Number.isFinite(conf) ? Math.max(0, conf) : 1 : merge(conf, CONFINEMENT_DEFAULTS)
+      };
+    };
+    const confinementRays = /* @__PURE__ */ new Map();
+    const raysOf = (n) => {
+      let rays = confinementRays.get(n);
+      if (rays) return rays;
+      const r = createRng((options.seed ?? 1) ^ 1540483477);
+      const off = r.next();
+      const phi0 = r.next() * Math.PI * 2;
+      rays = [];
+      for (let i = 0; i < n; i++) {
+        const y = 1 - 2 * (i + off) / n;
+        const s = Math.sqrt(Math.max(0, 1 - y * y));
+        const phi = phi0 + i * 2.399963229728653;
+        rays.push([Math.cos(phi) * s, y, Math.sin(phi) * s]);
+      }
+      confinementRays.set(n, rays);
+      return rays;
+    };
+    const confinementOf = (conf, point, radius) => {
+      if (conf === null) return 1;
+      if (typeof conf === "number") return conf;
+      let hits = 0;
+      let sum2 = 0;
+      for (const d of raysOf(Math.max(1, Math.round(conf.rays)))) {
+        const h = raycastInternal(point, d, radius * conf.reach, void 0, true);
+        if (h) {
+          hits++;
+          sum2 += h.distance;
         }
-        if (Ein > 20 && p.layers.length > 0) spallOuter(o, p, wp, faceOf(o, p, wn), wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), src);
-        const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
-        res.damage += dealt;
-        addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       }
-      res.events = cur.slice(start);
-      return res;
+      if (hits === 0) return 1;
+      const closed = hits / Math.max(1, Math.round(conf.rays));
+      const ratio = clamp2(radius / Math.max(sum2 / hits, 1e-3), 0, 2);
+      return Math.min(Math.max(1, conf.max), 1 + conf.gain * closed ** conf.power * ratio);
     };
-    const blastWorld = (point, energy, radius, src) => {
+    const FLAG_LOST = 1;
+    const FLAG_OPEN = 2;
+    const blastPlain = (point, energy, radius, src) => {
       const out = [];
       for (const o of [...objects.values()]) {
         if (vec.distance(toWorld(o.st.position, o.st.rotation, o.bc), point) - o.br >= radius) continue;
@@ -2847,16 +2945,225 @@ var GameTestRoom = (() => {
         if (r.part) out.push(r);
       }
       for (const im of [...impls.values()]) {
-        const inRange = im.impl.describe().parts.some((ps) => {
-          const ov = im.poses.get(ps.id);
-          const c = toWorld(im.position, im.rotation, ov?.pos ?? ps.position);
-          const q = quat.mul(im.rotation, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]));
-          return distanceToShape(ps.shape, toLocal(c, q, point)) < radius;
-        });
-        if (inRange) out.push(implHit(im, { type: "explosive", point, energy, radius, ...src !== void 0 ? { source: src } : {} }));
+        if (implInRange(im, point, radius)) out.push(implHit(im, { type: "explosive", point, energy, radius, ...src !== void 0 ? { source: src } : {} }));
+      }
+      return out;
+    };
+    const implParts = (im) => im.impl.describe().parts.map((ps) => {
+      const ov = im.poses.get(ps.id);
+      return { ps, c: toWorld(im.position, im.rotation, ov?.pos ?? ps.position), q: quat.mul(im.rotation, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0])) };
+    });
+    const implInRange = (im, point, radius) => implParts(im).some(({ ps, c, q }) => distanceToShape(ps.shape, toLocal(c, q, point)) < radius);
+    const blastScene = (point, energy, radius, src, cfg, only) => {
+      const mult = confinementOf(cfg.conf, point, radius);
+      const E = energy * mult;
+      const shelter = cfg.shelter;
+      const flags = /* @__PURE__ */ new Map();
+      const inRange = [];
+      for (const o of objects.values()) {
+        if (vec.distance(toWorld(o.st.position, o.st.rotation, o.bc), point) - o.br >= radius) continue;
+        inRange.push(o);
+        if (shelter) for (const p of o.parts) flags.set(p, (isLost(p) ? FLAG_LOST : 0) | (p.st.opening || p.st.stripped ? FLAG_OPEN : 0));
+      }
+      const shields = /* @__PURE__ */ new Map();
+      const reachAt = (tp, self) => {
+        if (!shelter) return 1;
+        const L = vec.distance(point, tp);
+        if (L < 1e-4) return 1;
+        const d = vec.scale(vec.sub(tp, point), 1 / L);
+        let t = 1;
+        for (const o of inRange) {
+          if (raySphereMiss(point, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, L)) continue;
+          for (const p of o.parts) {
+            if (p === self) continue;
+            const was = flags.get(p) ?? 0;
+            if (was & FLAG_LOST) continue;
+            const r = rayPart(o, p, point, d);
+            if (!r) continue;
+            const t0 = Math.max(r.t0, 0);
+            const path = Math.min(r.t1, L) - t0;
+            if (path < shelter.minPath) continue;
+            const mid = vec.madd(point, d, t0 + path / 2);
+            const opening = p.st.opening && insideOpening(o, p, mid);
+            if (opening && was & FLAG_OPEN) continue;
+            if (p.st.stripped && was & FLAG_OPEN) continue;
+            const resistance = p.mat.hpPerKg * p.mat.density * path * (p.mat.damageScale?.shelter ?? 1);
+            let ti = Math.exp(-resistance / shelter.k);
+            if (isLost(p) || opening || p.st.stripped && !(was & FLAG_OPEN)) ti += (1 - ti) * shelter.brokenTransmission;
+            t *= ti;
+            if (cfg.frag) {
+              let list = shields.get(p);
+              if (!list) shields.set(p, list = []);
+              list.push(tp);
+            }
+          }
+        }
+        return t;
+      };
+      const items = [];
+      let order = 0;
+      for (const o of inRange) {
+        if (only && only !== o) continue;
+        for (const p of o.parts) {
+          if (isLost(p)) continue;
+          const dist = distToPart(o, p, point);
+          if (dist < radius) items.push({ dist, order: order++, o, p });
+        }
+      }
+      for (const im of impls.values()) {
+        if (only && only !== im) continue;
+        let dist = Infinity;
+        for (const { ps, c, q } of implParts(im)) dist = Math.min(dist, distanceToShape(ps.shape, toLocal(c, q, point)));
+        if (dist < radius) items.push({ dist, order: order++, im });
+      }
+      items.sort((a, b) => a.dist - b.dist || a.order - b.order);
+      const results = /* @__PURE__ */ new Map();
+      const reports = /* @__PURE__ */ new Map();
+      const report = (key) => {
+        let r = reports.get(key);
+        if (!r) reports.set(key, r = { shelter: 0, confinement: mult, fragmentHits: 0 });
+        return r;
+      };
+      const thrown = [];
+      const sweep = (from) => {
+        if (!cfg.frag) return;
+        for (let i = from; i < cur.length; i++) {
+          const e = cur[i];
+          if (e.type !== "fracture" && e.type !== "stage") continue;
+          for (const frag of e.fragments ?? []) thrown.push({ frag, object: e.object, part: objects.get(e.object)?.byId.get(e.part) ?? null });
+        }
+      };
+      for (const it of items) {
+        if (it.o && it.p) {
+          const o = it.o;
+          let res = results.get(o);
+          if (!res) results.set(o, res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] });
+          const start = cur.length;
+          const k = blastPart(o, it.p, point, E, radius, src, res, shelter ? reachAt : void 0);
+          res.events.push(...cur.slice(start));
+          sweep(start);
+          if (k !== null) {
+            const rep = report(o);
+            rep.shelter = Math.max(rep.shelter, k);
+            if (shelter) (rep.parts ?? (rep.parts = {}))[it.p.spec.id] = k;
+          }
+        } else if (it.im) {
+          const im = it.im;
+          let num = 0;
+          let den = 0;
+          for (const { ps, c, q } of implParts(im)) {
+            const lp = toLocal(c, q, point);
+            const dist = distanceToShape(ps.shape, lp);
+            if (dist >= radius) continue;
+            const f = (1 - dist / radius) ** 2;
+            const sp = surfacePoint(ps.shape, lp);
+            num += f * reachAt(toWorld(c, q, sp.point), null);
+            den += f;
+          }
+          const k = den > 0 ? num / den : 1;
+          const res = implHit(im, { type: "explosive", point, energy: E * k, radius, ...shelter ? { shelter: k } : {}, ...src !== void 0 ? { source: src } : {} });
+          results.set(im, res);
+          report(im).shelter = k;
+        }
+      }
+      if (cfg.frag && thrown.length > 0) {
+        const g = cfg.frag;
+        const energyOf2 = (f) => 0.5 * f.mass * (f.velocity[0] ** 2 + f.velocity[1] ** 2 + f.velocity[2] ** 2);
+        const list = thrown.map((t, i) => ({ ...t, i, e: energyOf2(t.frag) })).sort((a, b) => b.e - a.e || a.i - b.i).slice(0, Math.max(0, Math.floor(g.max)));
+        list.forEach((t, i) => throwFragment(t.frag, t.object, t.part, g, point, i, src, shields, results, reports, mult));
       }
+      const out = [];
+      const reportShelter = (key, res) => {
+        res.blast = reports.get(key) ?? { shelter: 1, confinement: mult, fragmentHits: 0 };
+      };
+      const summary = [];
+      let fragmentHits = 0;
+      for (const o of objects.values()) {
+        const r = results.get(o);
+        if (!r?.part) continue;
+        reportShelter(o, r);
+        out.push(r);
+        for (const [part, factor] of Object.entries(r.blast?.parts ?? {})) summary.push({ object: o.id, part, factor });
+        fragmentHits += r.blast?.fragmentHits ?? 0;
+      }
+      for (const im of impls.values()) {
+        const r = results.get(im);
+        if (!r) continue;
+        reportShelter(im, r);
+        out.push(r);
+        if (shelter) summary.push({ object: im.impl.id, factor: r.blast?.shelter ?? 1 });
+        fragmentHits += r.blast?.fragmentHits ?? 0;
+      }
+      emit2({ type: "blast", object: "", time, ...src !== void 0 ? { source: src } : {}, point, energy: E, radius, confinement: mult, shelter: summary, fragmentHits });
       return out;
     };
+    const seedOf = (...nums) => {
+      let h = 2166136261;
+      for (const n of nums) {
+        h = Math.imul(h ^ (Math.round(n * 1e3) | 0), 16777619);
+        h ^= h >>> 15;
+      }
+      return h | 0;
+    };
+    const throwFragment = (frag, objectId, from, g, centre, index, src, shields, results, reports, mult) => {
+      const v = frag.velocity;
+      const speed = Math.hypot(v[0], v[1], v[2]);
+      const energy = g.energyFactor * 0.5 * frag.mass * speed * speed;
+      if (speed < 0.5 || energy < 1) return;
+      const r = createRng(seedOf(options.seed ?? 1, centre[0], centre[1], centre[2], index, frag.center[0], frag.center[1], frag.center[2]));
+      let dir = vec.scale(v, 1 / speed);
+      const behind = from ? shields.get(from) : void 0;
+      if (behind) {
+        let best = Math.cos(g.aim * Math.PI / 180);
+        for (const tp of behind) {
+          const to = vec.sub(tp, frag.center);
+          const len = vec.length(to);
+          if (len < 1e-4) continue;
+          const cos2 = vec.dot(dir, to) / len;
+          if (cos2 >= best) {
+            best = cos2;
+            dir = vec.scale(to, 1 / len);
+          }
+        }
+      }
+      const spread3 = Math.tan(g.spread * Math.PI / 180);
+      dir = vec.normalize([dir[0] + (r.next() - 0.5) * 2 * spread3, dir[1] + (r.next() - 0.5) * 2 * spread3, dir[2] + (r.next() - 0.5) * 2 * spread3], dir);
+      const range2 = Math.min(g.range, speed * g.flightTime);
+      const origin = vec.madd(frag.center, dir, 0.02);
+      const rh = raycastInternal(origin, dir, range2, from ? /* @__PURE__ */ new Set([`${objectId}\0${from.spec.id}`]) : void 0);
+      if (!rh) return;
+      const hit = {
+        type: g.hitType,
+        point: rh.point,
+        direction: dir,
+        energy,
+        radius: 0.05,
+        part: rh.part,
+        ...g.hitType === "ballistic" ? { caliber: clamp2(Math.max(...frag.size) * 1e3, 3, 30), mass: frag.mass * 1e3 } : {},
+        ...src !== void 0 ? { source: src } : {}
+      };
+      emit2({ type: "fragment_hit", object: objectId, time, ...src !== void 0 ? { source: src } : {}, from: { object: objectId, part: frag.part }, target: { object: rh.object, part: rh.part }, point: rh.point, direction: dir, energy, mass: frag.mass, speed });
+      const im = impls.get(rh.object);
+      const o = im ? void 0 : objects.get(rh.object);
+      const key = im ?? o;
+      if (!key) return;
+      const res = im ? implHit(im, hit) : doHit(o, hit, o.byId.get(rh.part));
+      const have = results.get(key);
+      if (have) {
+        have.damage += res.damage;
+        have.events.push(...res.events);
+        if (!have.part) have.part = res.part;
+        if (res.penetrated) have.penetrated = true;
+      } else results.set(key, { ...res, events: [...res.events] });
+      let rep = reports.get(key);
+      if (!rep) reports.set(key, rep = { shelter: 1, confinement: mult, fragmentHits: 0 });
+      rep.fragmentHits++;
+    };
+    const blastWorld = (point, energy, radius, src, call3, only) => {
+      const cfg = blastCfg(call3);
+      if (!cfg.shelter && !cfg.frag && cfg.conf === null) return blastPlain(point, energy, radius, src);
+      return blastScene(point, energy, radius, src, cfg, only);
+    };
     const heatObject = (o, point, T, radius, duration, src) => {
       const start = cur.length;
       const res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
@@ -2893,7 +3200,7 @@ var GameTestRoom = (() => {
       if (hit.type === "ballistic") {
         const loc = locate(o, point, dir, 0.05, only);
         if (loc) {
-          const out = ballistic2(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src);
+          const out = ballistic2(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src, hit.piercing ?? 1);
           res = { ...res, part: loc.p.spec.id, point: loc.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy };
         }
       } else if (hit.type === "blunt" || hit.type === "slash") {
@@ -2915,7 +3222,13 @@ var GameTestRoom = (() => {
           }
         }
       } else if (hit.type === "explosive") {
-        res = blastObject(o, point, E, hit.radius ?? 2, src);
+        const call3 = hit.blast || hit.confinement !== void 0 ? { ...hit.blast, ...hit.confinement !== void 0 ? { confinement: hit.confinement } : {} } : void 0;
+        const cfg = blastCfg(call3);
+        if (!cfg.shelter && !cfg.frag && cfg.conf === null) res = blastObject(o, point, E, hit.radius ?? 2, src);
+        else {
+          res = blastWorld(point, E, hit.radius ?? 2, src, call3, o)[0] ?? res;
+          res.events = cur.slice(start);
+        }
       } else {
         res = heatObject(o, point, hit.temperature ?? 800, hit.radius ?? 0.25, hit.duration ?? 1, src);
       }
@@ -3147,15 +3460,15 @@ var GameTestRoom = (() => {
       return best;
     };
     const detonatePrimed = (until) => {
-      const end = time;
+      const end3 = time;
       for (let next = nextPrimed(until); next; next = nextPrimed(until)) {
         primed.delete(next.p);
-        time = Math.max(0, Math.min(end, next.p.rt.chainDue));
+        time = Math.max(0, Math.min(end3, next.p.rt.chainDue));
         next.p.rt.chainDue = void 0;
         failPart(next.o, next.p, null, null, 0, 40);
         drainBlasts();
       }
-      time = end;
+      time = end3;
     };
     const releaseFront = () => {
       if (frontQueue.length === 0) return;
@@ -3172,6 +3485,14 @@ var GameTestRoom = (() => {
       for (const e of r.events) if (e.type === "collapse" && !r.value.some((h) => h.events.includes(e))) last.events.push(e);
       return r.value;
     };
+    const blastImpl = (im, h) => {
+      const call3 = h.blast || h.confinement !== void 0 ? { ...h.blast, ...h.confinement !== void 0 ? { confinement: h.confinement } : {} } : void 0;
+      const cfg = blastCfg(call3);
+      if (!cfg.shelter && !cfg.frag && cfg.conf === null) return implHit(im, h);
+      const world2 = h.space === "local" ? toWorld(im.position, im.rotation, h.point) : h.point;
+      const r = blastWorld(world2, h.energy ?? 0, h.radius ?? 2, h.source, call3, im);
+      return r.find((x) => x.object === im.impl.id) ?? implHit(im, h);
+    };
     const whole = (fn) => {
       const r = run(fn);
       r.value.events = r.events;
@@ -3259,7 +3580,7 @@ var GameTestRoom = (() => {
       },
       hit(objectId, h) {
         const im = impls.get(objectId);
-        if (im) return whole(() => implHit(im, h));
+        if (im) return whole(() => h.type === "explosive" ? blastImpl(im, h) : implHit(im, h));
         const o = getObj(objectId);
         return whole(() => doHit(o, h));
       },
@@ -3270,14 +3591,14 @@ var GameTestRoom = (() => {
         const p = getPart(o, partId);
         return whole(() => doHit(o, h, p));
       },
-      explode(point, energy, radius, source) {
-        return withCollapses(run(() => blastWorld(point, energy, radius, source)));
+      explode(point, energy, radius, source, blast) {
+        return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
       },
       raycast(origin, direction, maxDistance = Infinity) {
         const r = raycastInternal(origin, direction, maxDistance);
         return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
       },
-      shoot(origin, direction, energy, caliber, source) {
+      shoot(origin, direction, energy, caliber, source, piercing) {
         return withCollapses(run(() => {
           const results = [];
           const d = vec.normalize(direction);
@@ -3289,7 +3610,7 @@ var GameTestRoom = (() => {
             if (!rh) break;
             const im = impls.get(rh.object);
             if (im) {
-              const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...source !== void 0 ? { source } : {} });
+              const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...piercing !== void 0 ? { piercing } : {}, ...source !== void 0 ? { source } : {} });
               r.part = rh.part;
               r.point = rh.point;
               r.exitEnergy = r.penetrated ? E * 0.5 : 0;
@@ -3303,7 +3624,7 @@ var GameTestRoom = (() => {
             const o = getObj(rh.object);
             const p = getPart(o, rh.part);
             const start = cur.length;
-            const out = ballistic2(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source);
+            const out = ballistic2(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source, piercing ?? 1);
             results.push({ object: o.id, part: p.spec.id, point: rh.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy, events: cur.slice(start) });
             ignore.add(`${o.id}\0${p.spec.id}`);
             if (!out.penetrated || !out.exitPoint) break;
@@ -3673,6 +3994,8 @@ var GameTestRoom = (() => {
         stage: "damage stage",
         expose: "rebar bare",
         body: "body",
+        blast: "blast",
+        fragment_hit: "fragment hit",
         destroyed: "destroyed"
       },
       fractureStyles: { shatter: "shatter", crumble: "crumble", splinter: "splinter", tear: "tear", snap: "snap", none: "none" },
@@ -3759,6 +4082,8 @@ var GameTestRoom = (() => {
         stage: "est\xE1gio de dano",
         expose: "vergalh\xE3o \xE0 mostra",
         body: "corpo",
+        blast: "explos\xE3o",
+        fragment_hit: "estilha\xE7o atingiu",
         destroyed: "destru\xEDdo"
       },
       fractureStyles: { shatter: "estilha\xE7ar", crumble: "esfarelar", splinter: "lascar", tear: "rasgar", snap: "partir", none: "nenhuma" },
@@ -3767,6 +4092,1447 @@ var GameTestRoom = (() => {
   };
   var resolveStrings = (locale) => locales[locale ?? "en"] ?? locales.en;
 
+  // ../game-audio/dist/index.js
+  var FNV_OFFSET = 2166136261;
+  var FNV_PRIME = 16777619;
+  var MIX = 2654435761;
+  function createRng2(seed) {
+    let state = seed >>> 0;
+    return () => {
+      state = state + 1831565813 >>> 0;
+      let mixed = Math.imul(state ^ state >>> 15, state | 1);
+      mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+      return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  function streamSeed(seed, name) {
+    const label = String(name);
+    let hash = FNV_OFFSET;
+    for (let index = 0; index < label.length; index++) hash = Math.imul(hash ^ label.charCodeAt(index), FNV_PRIME) >>> 0;
+    return Math.imul(seed >>> 0 ^ hash, MIX) >>> 0;
+  }
+  function streamFor(seed, name) {
+    return createRng2(streamSeed(seed, name));
+  }
+  var DISTANCE_CURVES = {
+    /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
+    game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
+    /** The game's `grito`: `1 / (1 + d² × 0.006)`, silent below 0.02 (jogo L62129–62130). */
+    game_scream: { model: "inverse_square", k: 6e-3, minGain: 0.02 },
+    /** The game's `voz`: `1 / (1 + d² × 0.01)`, silent below 0.02 (jogo L62146–62147). */
+    game_voice: { model: "inverse_square", k: 0.01, minGain: 0.02 },
+    /** The game's `boom`: `1.4 / (1 + d² × 0.002)`, never silent (jogo L68280). */
+    game_boom: { model: "inverse_square", k: 2e-3, scale: 1.4 },
+    /** The art scene's `outAt`: `vol / (1 + d² × 0.008)` (cena L1320). */
+    art_scene: { model: "inverse_square", k: 8e-3 },
+    /** The game's animal calls: `max(0, 1 − d / 70) × 0.25`, silent at or below 0.005 (jogo L66627–66628). */
+    animals: { model: "linear", range: 70, scale: 0.25, minGain: 5e-3 }
+  };
+  function falloffGain(falloff, volume, distance4) {
+    if (!falloff || falloff.model === "none") return volume;
+    if (falloff.model === "linear") {
+      const level2 = Math.max(0, 1 - distance4 / falloff.range) * volume;
+      return falloff.scale === void 0 ? level2 : level2 * falloff.scale;
+    }
+    const level = volume / (1 + distance4 * distance4 * falloff.k);
+    return falloff.scale === void 0 ? level : falloff.scale * level;
+  }
+  function isSilent(falloff, gain) {
+    if (!falloff || falloff.model === "none" || falloff.minGain === void 0) return false;
+    return falloff.model === "linear" ? gain <= falloff.minGain : gain < falloff.minGain;
+  }
+  function cutoffDivisor(falloff, distance4) {
+    if (!falloff || falloff.model !== "inverse_square" || falloff.cutoffK === void 0) return 1;
+    return 1 + distance4 * falloff.cutoffK;
+  }
+  var DEFAULT_LISTENER = { position: [0, 0, 0], yaw: 0 };
+  var PAN_LIMIT = 0.85;
+  var PAN_MIN_DISTANCE = 2;
+  function listenerDistance(listener, position, mode = "xz") {
+    const dx = position[0] - listener.position[0];
+    const dz = position[2] - listener.position[2];
+    if (mode === "xz") return Math.hypot(dx, dz);
+    return Math.hypot(dx, position[1] - listener.position[1], dz);
+  }
+  function panFor(listener, position) {
+    const rightX = Math.cos(listener.yaw);
+    const rightZ = -Math.sin(listener.yaw);
+    const dx = position[0] - listener.position[0];
+    const dz = position[2] - listener.position[2];
+    const distance4 = Math.hypot(dx, dz) || 1;
+    const pan = (dx * rightX + dz * rightZ) / Math.max(distance4, PAN_MIN_DISTANCE);
+    return pan < -PAN_LIMIT ? -PAN_LIMIT : pan > PAN_LIMIT ? PAN_LIMIT : pan;
+  }
+  var voice_groups_default = {
+    undead_voice: {
+      maxConcurrent: 5,
+      cooldown: 0.25,
+      maxDistance: 40,
+      sources: [
+        "cena:L1342 `AU.groans > 4` refuses, so five play at once",
+        "jogo:L66986 one groan every 0.25 s (`groanBudget`), only nearer than 40 m",
+        "jogo:L70472 the budget counts down by the frame time"
+      ]
+    }
+  };
+  var VOICE_GROUPS = voice_groups_default;
+  var BUS_PRIORITY = { ui: 5, weapons: 4, voices: 3, world: 2, weather: 1, ambience: 1 };
+  var DEFAULT_MAX_VOICES = 32;
+  function busPriority(bus) {
+    return BUS_PRIORITY[bus];
+  }
+  function createVoiceManager(options = {}) {
+    const groups = new Map(Object.entries(options.groups ?? VOICE_GROUPS));
+    const maxVoices = options.maxVoices ?? DEFAULT_MAX_VOICES;
+    const budgets = /* @__PURE__ */ new Map();
+    let voices = [];
+    let nextId = 1;
+    let peak = 0;
+    let dropped = 0;
+    const refuse = (reason) => {
+      dropped += 1;
+      return { accepted: false, reason };
+    };
+    const groupCheck = (request, evicted) => {
+      const group = request.group === void 0 ? void 0 : groups.get(request.group);
+      if (!group) return void 0;
+      if (group.maxDistance !== void 0 && !((request.distance ?? 0) < group.maxDistance)) return "distance";
+      if (group.cooldown !== void 0 && (budgets.get(request.group) ?? 0) > 0) return "cooldown";
+      const members = voices.filter((voice) => voice.group === request.group);
+      if (group.maxConcurrent === void 0 || members.length < group.maxConcurrent) return void 0;
+      if (!group.steal) return "group_full";
+      evicted.push(members[0].id);
+      return void 0;
+    };
+    return {
+      request(request) {
+        const evicted = [];
+        const refusal = groupCheck(request, evicted);
+        if (refusal) return refuse(refusal);
+        const score = request.priority * request.gain;
+        const remaining = voices.filter((voice) => !evicted.includes(voice.id));
+        if (remaining.length >= maxVoices) {
+          const lowest = remaining.reduce((low, voice) => voice.score < low.score ? voice : low);
+          if (score <= lowest.score) return refuse("global_full");
+          evicted.push(lowest.id);
+          dropped += 1;
+        }
+        const group = request.group === void 0 ? void 0 : groups.get(request.group);
+        if (group?.cooldown !== void 0) budgets.set(request.group, group.cooldown);
+        const id = nextId++;
+        voices = [...voices.filter((voice) => !evicted.includes(voice.id)), { id, ...request.group === void 0 ? {} : { group: request.group }, score, remaining: request.length }];
+        peak = Math.max(peak, voices.length);
+        return { accepted: true, id, evicted };
+      },
+      release(id) {
+        voices = voices.filter((voice) => voice.id !== id);
+      },
+      setLength(id, seconds) {
+        const voice = voices.find((entry) => entry.id === id);
+        if (voice) voice.remaining = seconds;
+      },
+      advance(dt) {
+        for (const [group, budget] of budgets) budgets.set(group, budget - dt);
+        const ended = [];
+        for (const voice of voices) {
+          voice.remaining -= dt;
+          if (voice.remaining <= 0) ended.push(voice.id);
+        }
+        if (ended.length > 0) voices = voices.filter((voice) => voice.remaining > 0);
+        return ended;
+      },
+      setGroup(id, group) {
+        if (group) groups.set(id, group);
+        else groups.delete(id);
+      },
+      stats: () => ({ active: voices.length, peak, dropped, maxVoices })
+    };
+  }
+  var DEFAULT_TAIL = 0.05;
+  var DEFAULT_NOISE_SECONDS = 1.5;
+  var OCCLUSION_GAIN = 0.5;
+  var OCCLUSION_CUTOFF = 0.6;
+  function isParamRef(range2) {
+    return typeof range2 === "object" && !Array.isArray(range2);
+  }
+  function draw(range2, scope) {
+    if (typeof range2 === "number") return range2;
+    if (isParamRef(range2)) {
+      const value = scope.params[range2.param];
+      if (value === void 0) throw new Error(`game-audio: the recipe reads the param "${range2.param}", which was not given`);
+      return value * (range2.scale ?? 1) + (range2.add ?? 0);
+    }
+    const [min2, max2] = range2;
+    return min2 + scope.random() * (max2 - min2);
+  }
+  function drawTime(time, scope) {
+    if (time === "duration" || typeof time === "string" && time.endsWith("d")) return time;
+    return draw(time, scope);
+  }
+  function timeOf(time, duration) {
+    if (typeof time === "number") return time;
+    if (time === "duration") return duration;
+    return Number(time.slice(0, -1)) * duration;
+  }
+  function drawAutomation(automation, scope) {
+    const pending = {};
+    for (const key of Object.keys(automation)) {
+      if (key === "set" && "set" in automation) pending.value = draw(automation.set, scope);
+      else if (key === "from" && "from" in automation) pending.from = draw(automation.from, scope);
+      else if (key === "to" && automation.to !== void 0) pending.to = automation.to === "from" ? pending.from ?? pending.value ?? 0 : draw(automation.to, scope);
+      else if (key === "curve") pending.curve = automation.curve;
+      else if (key === "over" && automation.over !== void 0) pending.over = drawTime(automation.over, scope);
+    }
+    return pending;
+  }
+  function finishAutomation(pending, duration) {
+    if (pending.from !== void 0 && pending.to === void 0) return { from: pending.from };
+    if (pending.from !== void 0) return { from: pending.from, to: pending.to, curve: pending.curve ?? "linear", at: timeOf(pending.over ?? "duration", duration) };
+    if (pending.to === void 0 || pending.over === void 0) return { value: pending.value };
+    return { value: pending.value, to: pending.to, curve: pending.curve ?? "linear", at: timeOf(pending.over, duration) };
+  }
+  var startFrequency = (automation) => automation.from ?? automation.value ?? 0;
+  function drawFilter(spec, scope) {
+    const pending = { spec, frequency: {} };
+    for (const key of Object.keys(spec)) {
+      if (key === "frequency") pending.frequency = drawAutomation(spec.frequency, scope);
+      else if (key === "q" && spec.q !== void 0) pending.q = draw(spec.q, scope);
+      else if (key === "gain" && spec.gain !== void 0) pending.gain = draw(spec.gain, scope);
+      else if (key === "level" && spec.level !== void 0) pending.level = draw(spec.level, scope);
+    }
+    return pending;
+  }
+  function drawModulator(modulator, scope) {
+    const pending = { modulator, rate: 0 };
+    for (const key of Object.keys(modulator)) {
+      if (key === "rate") pending.rate = draw(modulator.rate, scope);
+      else if (key === "depth" && !(typeof modulator.depth === "object" && "scaleOf" in modulator.depth)) pending.depth = draw(modulator.depth, scope);
+    }
+    return pending;
+  }
+  function drawVoice(source, scope) {
+    const pending = { frequency: {}, vibratoRate: 0, formants: [], breath: { frequency: 0, q: source.breath.q, gain: 0 } };
+    for (const key of Object.keys(source)) {
+      if (key === "frequency") pending.frequency = drawAutomation(source.frequency, scope);
+      else if (key === "vibrato") pending.vibratoRate = draw(source.vibrato.rate, scope);
+      else if (key === "formants") pending.formants = source.formants.map((formant) => ({ frequency: draw(formant.frequency, scope), q: formant.q }));
+      else if (key === "breath") pending.breath = { frequency: draw(source.breath.frequency, scope), q: source.breath.q, gain: draw(source.breath.gain, scope) };
+    }
+    return pending;
+  }
+  function drawLayer(layer2, scope) {
+    const pending = { at: 0, gain: 1, filters: [], modulators: [] };
+    for (const key of Object.keys(layer2)) {
+      if (key === "at" && layer2.at !== void 0) pending.at = draw(layer2.at, scope);
+      else if (key === "duration" && layer2.duration !== void 0) pending.duration = draw(layer2.duration, scope);
+      else if (key === "gain" && layer2.gain !== void 0) pending.gain = draw(layer2.gain, scope);
+      else if (key === "source" && layer2.source.kind === "osc") pending.automation = drawAutomation(layer2.source.frequency, scope);
+      else if (key === "source" && layer2.source.kind === "formant_voice") pending.voice = drawVoice(layer2.source, scope);
+      else if (key === "filters" && layer2.filters) pending.filters = layer2.filters.bank.map((spec) => drawFilter(spec, scope));
+      else if (key === "modulators" && layer2.modulators) pending.modulators = layer2.modulators.map((modulator) => drawModulator(modulator, scope));
+    }
+    return pending;
+  }
+  function drawOffset(source, duration, scope, noiseSeconds) {
+    if (source.kind === "formant_voice") return scope.random();
+    if (source.kind !== "noise" || source.offset === void 0) return 0;
+    if (typeof source.offset === "number") return source.offset;
+    if (source.offset === "fit") return scope.random() * Math.max(0, noiseSeconds - duration);
+    return scope.random() * (source.offsetScale ?? 1);
+  }
+  function finishSource(layer2, pending, duration, offset) {
+    const source = layer2.source;
+    if (source.kind === "noise") return { kind: "noise", offset, loop: source.loop === true };
+    if (source.kind === "osc") return { kind: "osc", wave: source.wave, frequency: finishAutomation(pending.automation ?? {}, duration) };
+    const voice = pending.voice;
+    return {
+      kind: "formant_voice",
+      wave: source.wave,
+      frequency: finishAutomation(voice.frequency, duration),
+      vibrato: { rate: voice.vibratoRate, depth: startFrequency(voice.frequency) * source.vibrato.depth },
+      formants: voice.formants,
+      breath: { ...voice.breath, offset },
+      mix: source.mix
+    };
+  }
+  function finishModulator(pending, sourceFrequency) {
+    const { modulator } = pending;
+    const depth = typeof modulator.depth === "object" && "scaleOf" in modulator.depth ? sourceFrequency * modulator.depth.factor : pending.depth ?? 0;
+    return { target: modulator.target, ...modulator.wave ? { wave: modulator.wave } : {}, rate: pending.rate, depth, ...modulator.base === void 0 ? {} : { base: modulator.base } };
+  }
+  function finishEnvelope(envelope2, duration, level) {
+    return envelope2.map(([time, value, curve, fixed2]) => ({ time: timeOf(time, duration), value: fixed2 === "fixed" ? value : value * level, curve }));
+  }
+  function planLayer(layer2, scope, defaults, levelInEnvelope, soundLevel) {
+    const pending = drawLayer(layer2, scope);
+    const duration = pending.duration ?? defaults.duration;
+    if (duration === void 0) throw new Error("game-audio: a layer needs a duration (its own or the recipe\u2019s)");
+    const offset = drawOffset(layer2.source, duration, scope, defaults.noiseSeconds);
+    const level = pending.gain * soundLevel;
+    const sourceFrequency = layer2.source.kind === "noise" ? 0 : startFrequency(pending.automation ?? pending.voice?.frequency ?? {});
+    const planned = {
+      at: pending.at,
+      duration,
+      tail: layer2.tail ?? defaults.tail ?? DEFAULT_TAIL,
+      level,
+      ...layer2.wet === void 0 ? {} : { wet: layer2.wet },
+      source: finishSource(layer2, pending, duration, offset),
+      ...layer2.filters ? {
+        filters: {
+          mode: layer2.filters.mode,
+          bank: pending.filters.map(({ spec, frequency, q, gain, level: filterLevel }) => ({
+            type: spec.type,
+            frequency: finishAutomation(frequency, duration),
+            ...q === void 0 ? {} : { q },
+            ...gain === void 0 ? {} : { gain },
+            ...filterLevel === void 0 ? {} : { level: filterLevel }
+          }))
+        }
+      } : {},
+      modulators: pending.modulators.map((modulator) => finishModulator(modulator, sourceFrequency)),
+      envelope: finishEnvelope(layer2.envelope, duration, levelInEnvelope ? level : 1)
+    };
+    if (!layer2.repeat) return [planned];
+    return Array.from({ length: layer2.repeat.count }, (_, index) => ({ ...planned, at: planned.at + index * (layer2.repeat?.spacing ?? 0) }));
+  }
+  function scaleAutomation(automation, divisor) {
+    const scale2 = (value) => value === void 0 ? void 0 : value / divisor;
+    const scaled2 = { ...automation };
+    for (const key of ["value", "from", "to"]) if (automation[key] !== void 0) scaled2[key] = scale2(automation[key]);
+    return scaled2;
+  }
+  function muffle(layer2, divisor) {
+    if (divisor === 1 || !layer2.filters) return layer2;
+    const bank = layer2.filters.bank.map((filter) => filter.type === "lowpass" ? { ...filter, frequency: scaleAutomation(filter.frequency, divisor) } : filter);
+    return { ...layer2, filters: { ...layer2.filters, bank } };
+  }
+  var layerEnd = (layer2) => layer2.at + layer2.duration + layer2.tail;
+  function planSound(recipe, input = {}) {
+    const listener = input.listener ?? DEFAULT_LISTENER;
+    const distance4 = input.distance ?? (input.position ? listenerDistance(listener, input.position, input.distanceMode) : 0);
+    const occlusion = Math.min(1, Math.max(0, input.occlusion ?? 0));
+    const order = recipe.order ?? "layered";
+    const falloffLevel = falloffGain(recipe.falloff, input.volume ?? 1, distance4);
+    const level = occlusion > 0 ? falloffLevel * (1 - OCCLUSION_GAIN * occlusion) : falloffLevel;
+    const silent = isSilent(recipe.falloff, falloffLevel);
+    const base = {
+      id: recipe.id,
+      bus: recipe.bus,
+      order,
+      ...recipe.group === void 0 ? {} : { group: recipe.group },
+      priority: recipe.priority ?? busPriority(recipe.bus),
+      level,
+      distance: distance4,
+      ...recipe.pan ? { pan: input.position ? panFor(listener, input.position) : 0 } : {}
+    };
+    if (silent) return recipe.keepSilent ? { ...base, silent: true, length: 0, layers: [] } : null;
+    const scope = { random: input.random ?? createRng2(1), params: { ...input.params } };
+    for (const [name, range2] of Object.entries(recipe.vars ?? {})) if (scope.params[name] === void 0) scope.params[name] = draw(range2, scope);
+    const defaults = {
+      ...recipe.duration === void 0 ? {} : { duration: draw(recipe.duration, scope) },
+      ...recipe.tail === void 0 ? {} : { tail: recipe.tail },
+      noiseSeconds: input.noiseSeconds ?? DEFAULT_NOISE_SECONDS
+    };
+    const divisor = cutoffDivisor(recipe.falloff, distance4) / (1 - OCCLUSION_CUTOFF * occlusion);
+    const layers = recipe.layers.flatMap((layer2) => planLayer(layer2, scope, defaults, order !== "layered", level)).map((layer2) => muffle(layer2, divisor));
+    return { ...base, silent: false, length: Math.max(0, ...layers.map(layerEnd)), layers };
+  }
+  var LOOP_START_ABOVE = 2e-3;
+  var LOOP_SMOOTHING = { volume: 0.15, frequency: 0.08 };
+  function createLoopState(recipe, open = false) {
+    const startAbove = recipe.startAbove ?? LOOP_START_ABOVE;
+    let created = open;
+    let volume = recipe.volume ?? 0;
+    return {
+      set(state) {
+        volume = state.volume ?? volume;
+        const create = !created;
+        if (create && !(volume >= startAbove)) return null;
+        created = true;
+        const frequency = recipe.source.kind === "osc" && state.frequency ? state.frequency : void 0;
+        return { create, volume, ...frequency === void 0 ? {} : { frequency } };
+      },
+      get created() {
+        return created;
+      },
+      reset() {
+        created = false;
+      }
+    };
+  }
+  var mix_profiles_default = [
+    {
+      id: "game",
+      master: 0.5,
+      noise: { seconds: 1.5, create: "lazy" },
+      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
+    },
+    {
+      id: "art_scene",
+      master: 0.85,
+      compressor: { threshold: -12, ratio: 5 },
+      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
+      noise: { seconds: 2, create: "eager" },
+      sources: [
+        "cena:L1308 compressor -12 dB, ratio 5",
+        "cena:L1309 master 0.85",
+        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
+        "cena:L1311 wet 0.4",
+        "cena:L1312 noise 2 s made with the chain"
+      ]
+    }
+  ];
+  var MIX_PROFILES = Object.fromEntries(
+    mix_profiles_default.map((profile) => [profile.id, profile])
+  );
+  var DEFAULT_MIX = "art_scene";
+  function resolveMix(mix, profiles = MIX_PROFILES) {
+    if (typeof mix !== "string") return mix;
+    const profile = profiles[mix];
+    if (!profile) throw new Error(`game-audio: unknown mix profile "${mix}" (known: ${Object.keys(profiles).join(", ")})`);
+    return profile;
+  }
+  function busGain(setting) {
+    if (!setting) return 1;
+    return setting.muted ? 0 : setting.gain ?? 1;
+  }
+  function isPlainObject2(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function mergeRecords(base, patch) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0) continue;
+      const current = merged[key];
+      merged[key] = isPlainObject2(current) && isPlainObject2(value) ? mergeRecords(current, value) : value;
+    }
+    return merged;
+  }
+  function createSoundRegistry(banks = []) {
+    const sounds = /* @__PURE__ */ new Map();
+    const loops = /* @__PURE__ */ new Map();
+    const owners = /* @__PURE__ */ new Map();
+    const registry = {
+      register(bank) {
+        for (const sound of bank.sounds ?? []) {
+          sounds.set(sound.id, sound);
+          owners.set(sound.id, bank.id);
+        }
+        for (const loop of bank.loops ?? []) {
+          loops.set(loop.id, loop);
+          owners.set(loop.id, bank.id);
+        }
+      },
+      patch(id, patch) {
+        const sound = sounds.get(id);
+        if (sound) sounds.set(id, mergeRecords(sound, patch));
+        const loop = loops.get(id);
+        if (loop) loops.set(id, mergeRecords(loop, patch));
+      },
+      remove(id) {
+        sounds.delete(id);
+        loops.delete(id);
+        owners.delete(id);
+      },
+      sound: (id) => sounds.get(id),
+      loop: (id) => loops.get(id),
+      soundIds: () => [...sounds.keys()],
+      loopIds: () => [...loops.keys()],
+      bankOf: (id) => owners.get(id)
+    };
+    for (const bank of banks) registry.register(bank);
+    return registry;
+  }
+  var game_sfx_default = {
+    sources: ["jogo:L62089-62107"],
+    note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
+    classes: [
+      { id: "pistol", team: "pistola", bus: "weapons", cutoff: 1800, gain: 0.9, seconds: 0.18 },
+      { id: "shotgun", team: "escopeta", bus: "weapons", cutoff: 900, gain: 1.2, seconds: 0.35 },
+      { id: "rifle", team: "fuzil", bus: "weapons", cutoff: 1400, gain: 1.1, seconds: 0.28 },
+      { id: "long_rifle", team: "rifle", bus: "weapons", cutoff: 1100, gain: 1.3, seconds: 0.45 },
+      { id: "impact", team: "impacto", bus: "world", cutoff: 2500, gain: 0.25, seconds: 0.05 },
+      { id: "flesh", team: "carne", bus: "world", cutoff: 600, gain: 0.35, seconds: 0.08 },
+      { id: "step", team: "passo", bus: "world", cutoff: 400, gain: 0.08, seconds: 0.05 },
+      { id: "glass", team: "vidro", bus: "world", cutoff: 5e3, gain: 0.5, seconds: 0.3 },
+      { id: "wood", team: "madeira", bus: "world", cutoff: 700, gain: 0.5, seconds: 0.2 },
+      { id: "reload", team: "recarga", bus: "weapons", cutoff: 3e3, gain: 0.15, seconds: 0.06 },
+      { id: "empty", team: "vazio", bus: "weapons", cutoff: 4e3, gain: 0.12, seconds: 0.03 },
+      { id: "explosion", team: "explosao", bus: "world", cutoff: 200, gain: 1.6, seconds: 1.4 }
+    ],
+    fallback: { id: "unknown", team: "(any other name)", bus: "world", cutoff: 1e3, gain: 0.5, seconds: 0.1 }
+  };
+  var GAME_SFX = game_sfx_default;
+  var GAME_SFX_CLASSES = GAME_SFX.classes;
+  var GAME_SFX_FALLBACK = GAME_SFX.fallback;
+  function noiseClassRecipe(row, id = `sfx_${row.id}`) {
+    return {
+      id,
+      bus: row.bus,
+      order: "burst",
+      duration: row.seconds,
+      tail: 0.05,
+      layers: [
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: row.cutoff } }] },
+          envelope: [
+            [0, row.gain, "set"],
+            ["1d", 1e-3, "exp", "fixed"]
+          ]
+        }
+      ],
+      falloff: DISTANCE_CURVES.game_sfx,
+      sources: [...GAME_SFX.sources.map((source) => `${source} ${row.team}`)]
+    };
+  }
+  var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+  function fillNoise(random, length3) {
+    const samples = new Float32Array(length3);
+    for (let index = 0; index < length3; index++) samples[index] = random() * 2 - 1;
+    return samples;
+  }
+  function fillImpulse(random, options) {
+    const size = Math.floor(options.length);
+    return Array.from({ length: options.channels }, () => {
+      const samples = new Float32Array(size);
+      for (let index = 0; index < options.length; index++) {
+        const value = (random() * 2 - 1) * Math.exp(options.decay * Math.log(1 - index / options.length));
+        if (index < size) samples[index] = value;
+      }
+      return samples;
+    });
+  }
+  function bufferOf(context, channels, requestedLength) {
+    const buffer = context.createBuffer(channels.length, requestedLength, context.sampleRate);
+    channels.forEach((samples, channel) => buffer.getChannelData(channel).set(samples));
+    return buffer;
+  }
+  function buildChain(context, profile, random) {
+    let compressor;
+    if (profile.compressor) {
+      compressor = context.createDynamicsCompressor();
+      compressor.threshold.value = profile.compressor.threshold;
+      compressor.ratio.value = profile.compressor.ratio;
+      if (profile.compressor.knee !== void 0) compressor.knee.value = profile.compressor.knee;
+      if (profile.compressor.attack !== void 0) compressor.attack.value = profile.compressor.attack;
+      if (profile.compressor.release !== void 0) compressor.release.value = profile.compressor.release;
+      compressor.connect(context.destination);
+    }
+    const master = context.createGain();
+    master.gain.value = profile.master;
+    master.connect(compressor ?? context.destination);
+    if (!profile.reverb) {
+      return {
+        master,
+        disconnect: () => {
+          master.disconnect();
+          compressor?.disconnect();
+        }
+      };
+    }
+    const convolver = context.createConvolver();
+    const length3 = context.sampleRate * profile.reverb.seconds;
+    convolver.buffer = bufferOf(context, fillImpulse(random, { channels: 2, length: length3, decay: profile.reverb.decay }), length3);
+    const wet = context.createGain();
+    wet.gain.value = profile.reverb.wet;
+    wet.connect(convolver);
+    convolver.connect(master);
+    return {
+      master,
+      wet,
+      disconnect: () => {
+        wet.disconnect();
+        convolver.disconnect();
+        master.disconnect();
+        compressor?.disconnect();
+      }
+    };
+  }
+  function globalContext() {
+    const scope = globalThis;
+    const Constructor = scope.AudioContext ?? scope.webkitAudioContext;
+    return Constructor ? new Constructor() : null;
+  }
+  function unlockContext(context) {
+    if (context.state === "suspended") void context.resume();
+  }
+  function assign(param2, automation, time) {
+    if (automation.value !== void 0) param2.value = automation.value;
+    if (automation.from !== void 0) param2.setValueAtTime(automation.from, time);
+  }
+  function ramp(param2, curve, value, at3) {
+    if (curve === "set") param2.setValueAtTime(value, at3);
+    else if (curve === "exp") param2.exponentialRampToValueAtTime(value, at3);
+    else param2.linearRampToValueAtTime(value, at3);
+  }
+  function rampTo(param2, automation, time) {
+    if (automation.to !== void 0 && automation.at !== void 0) ramp(param2, automation.curve ?? "linear", automation.to, time + automation.at);
+  }
+  function applyEnvelope(param2, points, time) {
+    for (const point of points) ramp(param2, point.curve, point.value, time + point.time);
+  }
+  function noiseSource(target, loop) {
+    const source = target.context.createBufferSource();
+    source.buffer = target.noise();
+    if (loop) source.loop = true;
+    return source;
+  }
+  function filterNode(context, filter, time) {
+    const node = context.createBiquadFilter();
+    node.type = filter.type;
+    assign(node.frequency, filter.frequency, time);
+    if (filter.q !== void 0) node.Q.value = filter.q;
+    if (filter.gain !== void 0) node.gain.value = filter.gain;
+    return node;
+  }
+  function gainNode(context, value) {
+    const node = context.createGain();
+    node.gain.value = value;
+    return node;
+  }
+  function voiceOf(sources) {
+    return {
+      sources,
+      stop() {
+        for (const source of sources) {
+          try {
+            source.stop();
+          } catch {
+          }
+        }
+      }
+    };
+  }
+  var fixed = (range2) => typeof range2 === "number" ? range2 : 0;
+  var fixedFrequency = (automation) => fixed("set" in automation ? automation.set : automation.from);
+  function sourceOf(recipe, target) {
+    if (recipe.source.kind === "noise") return { source: noiseSource(target, true) };
+    const oscillator = target.context.createOscillator();
+    oscillator.type = recipe.source.wave;
+    if (recipe.source.frequency) oscillator.frequency.value = fixedFrequency(recipe.source.frequency);
+    return { source: oscillator, frequency: oscillator.frequency };
+  }
+  function stopAll(sources) {
+    return () => {
+      for (const source of sources) {
+        try {
+          source.stop();
+        } catch {
+        }
+      }
+    };
+  }
+  function realizeGameLoop(recipe, target) {
+    const { context } = target;
+    const gain = context.createGain();
+    const filters = (recipe.filters?.bank ?? []).map(() => context.createBiquadFilter());
+    gain.gain.value = 0;
+    const last = filters.reduce((previous, filter) => previous ? previous.connect(filter) : filter, void 0);
+    last?.connect(gain);
+    gain.connect(target.output);
+    const { source, frequency } = sourceOf(recipe, target);
+    recipe.filters?.bank.forEach((spec, index) => {
+      const filter = filters[index];
+      filter.type = spec.type;
+      filter.frequency.value = fixedFrequency(spec.frequency);
+      if (spec.q !== void 0) filter.Q.value = fixed(spec.q);
+    });
+    const sources = [source];
+    for (const modulator of recipe.modulators ?? []) {
+      const lfo = context.createOscillator();
+      const depth = context.createGain();
+      const stage = context.createGain();
+      if (modulator.wave) lfo.type = modulator.wave;
+      lfo.frequency.value = fixed(modulator.rate);
+      depth.gain.value = fixed(modulator.depth);
+      stage.gain.value = modulator.base ?? 0;
+      lfo.connect(depth);
+      depth.connect(stage.gain);
+      last?.disconnect();
+      last?.connect(stage);
+      stage.connect(gain);
+      lfo.start();
+      sources.push(lfo);
+    }
+    source.connect(filters[0] ?? gain);
+    source.start();
+    return { gain, source, ...frequency ? { frequency } : {}, stop: stopAll(sources) };
+  }
+  function realizeChainLoop(recipe, target, volume) {
+    const { context } = target;
+    const { source, frequency } = sourceOf(recipe, target);
+    const filters = (recipe.filters?.bank ?? []).map(
+      (spec) => filterNode(context, { type: spec.type, frequency: { value: fixedFrequency(spec.frequency) }, ...spec.q === void 0 ? {} : { q: fixed(spec.q) } }, target.time)
+    );
+    const gain = gainNode(context, volume);
+    const lfos = (recipe.modulators ?? []).map((modulator) => {
+      const lfo = context.createOscillator();
+      if (modulator.wave) lfo.type = modulator.wave;
+      lfo.frequency.value = fixed(modulator.rate);
+      const depth = gainNode(context, fixed(modulator.depth));
+      lfo.connect(depth);
+      depth.connect(gain.gain);
+      return lfo;
+    });
+    let tail = source;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(gain);
+    gain.connect(target.output);
+    source.start();
+    for (const lfo of lfos) lfo.start();
+    return { gain, source, ...frequency ? { frequency } : {}, stop: stopAll([source, ...lfos]) };
+  }
+  var INERT = { set() {
+  }, stop() {
+  } };
+  function createLoopHandle(recipe, host, volume) {
+    if (!recipe) return INERT;
+    const loopRecipe = recipe;
+    const isChain = loopRecipe.order === "chain_loop";
+    const opening = volume ?? loopRecipe.volume ?? 0;
+    const smoothing = loopRecipe.smoothing ?? LOOP_SMOOTHING;
+    let state = createLoopState(loopRecipe);
+    let nodes;
+    const entry = {
+      get created() {
+        return nodes !== void 0;
+      },
+      rewire() {
+        nodes?.gain.disconnect();
+        nodes?.gain.connect(host.output(loopRecipe.bus));
+      },
+      stop() {
+        nodes?.stop();
+        nodes?.gain.disconnect();
+        nodes = void 0;
+        state = createLoopState(loopRecipe);
+        host.unregister(entry);
+      }
+    };
+    const create = (context, startVolume) => {
+      if (loopRecipe.source.kind === "noise") host.prepareNoise();
+      const target = { context, output: host.output(loopRecipe.bus), noise: host.noise, time: context.currentTime };
+      const made = isChain ? realizeChainLoop(loopRecipe, target, startVolume) : realizeGameLoop(loopRecipe, target);
+      host.register(entry);
+      return made;
+    };
+    const open = () => {
+      const context = host.ready();
+      if (!context) return;
+      nodes = create(context, opening);
+      state = createLoopState({ ...loopRecipe, volume: opening }, true);
+    };
+    if (isChain) open();
+    return {
+      set(next) {
+        if (isChain && !nodes) open();
+        const context = host.ready();
+        if (!context) return;
+        const action = state.set(next);
+        if (!action) return;
+        nodes ?? (nodes = create(context, 0));
+        nodes.gain.gain.setTargetAtTime(action.volume, context.currentTime, smoothing.volume);
+        if (action.frequency !== void 0 && nodes.frequency) nodes.frequency.setTargetAtTime(action.frequency, context.currentTime, smoothing.frequency);
+      },
+      stop: entry.stop
+    };
+  }
+  function createNoiseStore(random) {
+    const store = {
+      random,
+      reset() {
+        store.samples = void 0;
+        store.buffer = void 0;
+      }
+    };
+    return store;
+  }
+  function prepareNoise(store, context, seconds) {
+    store.samples ?? (store.samples = fillNoise(store.random, Math.floor(context.sampleRate * seconds)));
+    return store.samples;
+  }
+  function noiseBuffer(store, context, seconds) {
+    const samples = prepareNoise(store, context, seconds);
+    store.buffer ?? (store.buffer = bufferOf(context, [samples], context.sampleRate * seconds));
+    return store.buffer;
+  }
+  var end = (layer2, start) => start + layer2.duration + layer2.tail;
+  var firstFilter = (layer2) => layer2.filters?.bank[0];
+  var offsetOf = (layer2) => layer2.source.kind === "noise" ? layer2.source.offset : 0;
+  function setFilter(node, filter, time) {
+    if (!filter) return;
+    node.type = filter.type;
+    assign(node.frequency, filter.frequency, time);
+    if (filter.q !== void 0) node.Q.value = filter.q;
+  }
+  function realizeBurst(plan, target) {
+    const { context } = target;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
+    const gain = context.createGain();
+    gain.connect(target.output);
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const filter = context.createBiquadFilter();
+    source.connect(filter);
+    filter.connect(gain);
+    setFilter(filter, firstFilter(layer2), time);
+    applyEnvelope(gain.gain, layer2.envelope, time);
+    source.start(time, offsetOf(layer2));
+    source.stop(end(layer2, time));
+    return voiceOf([source]);
+  }
+  function realizeScream(plan, target) {
+    const { context } = target;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const gain = context.createGain();
+    gain.connect(target.output);
+    for (const band of layer2.filters?.bank ?? []) {
+      const filter = context.createBiquadFilter();
+      filter.type = band.type;
+      if (band.q !== void 0) filter.Q.value = band.q;
+      assign(filter.frequency, band.frequency, time);
+      rampTo(filter.frequency, band.frequency, time);
+      const level = context.createGain();
+      level.gain.value = band.level ?? 1;
+      source.connect(filter);
+      filter.connect(level);
+      level.connect(gain);
+    }
+    const sources = [source];
+    const lfos = layer2.modulators.map((modulator) => {
+      const lfo = context.createOscillator();
+      const depth = context.createGain();
+      if (modulator.wave) lfo.type = modulator.wave;
+      lfo.frequency.value = modulator.rate;
+      depth.gain.value = modulator.depth;
+      lfo.connect(depth);
+      depth.connect(gain.gain);
+      return lfo;
+    });
+    applyEnvelope(gain.gain, layer2.envelope, time);
+    source.start(time, offsetOf(layer2));
+    source.stop(end(layer2, time));
+    for (const lfo of lfos) {
+      lfo.start(time);
+      lfo.stop(end(layer2, time));
+      sources.push(lfo);
+    }
+    return voiceOf(sources);
+  }
+  function realizeGroan(plan, target) {
+    const { context } = target;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
+    const oscillator = context.createOscillator();
+    const gain = context.createGain();
+    const filter = context.createBiquadFilter();
+    const band = firstFilter(layer2);
+    if (layer2.source.kind === "osc") oscillator.type = layer2.source.wave;
+    if (band) {
+      filter.type = band.type;
+      if (band.q !== void 0) filter.Q.value = band.q;
+    }
+    if (layer2.source.kind === "osc") {
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    }
+    if (band) assign(filter.frequency, band.frequency, time);
+    applyEnvelope(gain.gain, layer2.envelope, time);
+    oscillator.connect(filter);
+    filter.connect(gain);
+    gain.connect(target.output);
+    oscillator.start(time);
+    oscillator.stop(end(layer2, time));
+    return voiceOf([oscillator]);
+  }
+  function realizeBoom(plan, target) {
+    const { context } = target;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
+    const oscillator = context.createOscillator();
+    const gain = context.createGain();
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    }
+    applyEnvelope(gain.gain, layer2.envelope, time);
+    oscillator.connect(gain);
+    gain.connect(target.output);
+    oscillator.start(time);
+    oscillator.stop(end(layer2, time));
+    return voiceOf([oscillator]);
+  }
+  function realizeStatic(plan, target) {
+    const { context } = target;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
+    const gain = context.createGain();
+    const source = context.createBufferSource();
+    const filter = context.createBiquadFilter();
+    source.buffer = target.noise();
+    setFilter(filter, firstFilter(layer2), time);
+    applyEnvelope(gain.gain, layer2.envelope, time);
+    source.connect(filter);
+    filter.connect(gain);
+    gain.connect(target.output);
+    source.start(time, offsetOf(layer2));
+    source.stop(end(layer2, time));
+    return voiceOf([source]);
+  }
+  function realizeChord(plan, target) {
+    const { context } = target;
+    const layers = plan.layers;
+    const oscillators = layers.map(() => context.createOscillator());
+    const gain = context.createGain();
+    for (let index = layers.length - 1; index >= 0; index--) {
+      const source = layers[index].source;
+      if (source.kind === "osc") oscillators[index].type = source.wave;
+    }
+    layers.forEach((layer2, index) => {
+      if (layer2.source.kind === "osc") assign(oscillators[index].frequency, layer2.source.frequency, target.time + layer2.at);
+    });
+    applyEnvelope(gain.gain, layers[0].envelope, target.time + layers[0].at);
+    for (const oscillator of oscillators) oscillator.connect(gain);
+    gain.connect(target.output);
+    layers.forEach((layer2, index) => oscillators[index].start(target.time + layer2.at));
+    layers.forEach((layer2, index) => oscillators[index].stop(end(layer2, target.time + layer2.at)));
+    return voiceOf(oscillators);
+  }
+  function realizeCalls(plan, target) {
+    const { context } = target;
+    const gain = context.createGain();
+    const filter = context.createBiquadFilter();
+    if (plan.silent) return voiceOf([]);
+    const band = firstFilter(plan.layers[0]);
+    if (band) filter.type = band.type;
+    filter.connect(gain);
+    gain.connect(target.output);
+    const oscillators = plan.layers.map((layer2) => {
+      const time = target.time + layer2.at;
+      const oscillator = context.createOscillator();
+      if (layer2.source.kind === "osc") {
+        oscillator.type = layer2.source.wave;
+        assign(oscillator.frequency, layer2.source.frequency, time);
+        rampTo(oscillator.frequency, layer2.source.frequency, time);
+      }
+      if (band) {
+        assign(filter.frequency, band.frequency, time);
+        if (band.q !== void 0) filter.Q.value = band.q;
+      }
+      const envelope2 = context.createGain();
+      applyEnvelope(envelope2.gain, layer2.envelope, time);
+      oscillator.connect(envelope2);
+      envelope2.connect(filter);
+      oscillator.start(time);
+      oscillator.stop(end(layer2, time));
+      return oscillator;
+    });
+    return voiceOf(oscillators);
+  }
+  var end2 = (layer2, start) => start + layer2.duration + layer2.tail;
+  function outputStage(plan, layer2, target) {
+    const { context } = target;
+    const level = gainNode(context, layer2.level);
+    let node = level;
+    if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
+      const panner = context.createStereoPanner();
+      panner.pan.value = plan.pan;
+      level.connect(panner);
+      node = panner;
+    }
+    node.connect(target.output);
+    if (layer2.wet && target.wet) {
+      const send = gainNode(context, layer2.wet);
+      node.connect(send);
+      send.connect(target.wet);
+    }
+    return level;
+  }
+  function realizeNoiseLayer(plan, layer2, target) {
+    const { context } = target;
+    const time = target.time + layer2.at;
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const filters = (layer2.filters?.bank ?? []).map((filter) => {
+      const node = filterNode(context, filter, time);
+      rampTo(node.frequency, filter.frequency, time);
+      return node;
+    });
+    const envelope2 = context.createGain();
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    let tail = source;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(envelope2);
+    envelope2.connect(outputStage(plan, layer2, target));
+    source.start(time, layer2.source.kind === "noise" ? layer2.source.offset : 0);
+    source.stop(end2(layer2, time));
+    return [source];
+  }
+  function realizeToneLayer(plan, layer2, target) {
+    const { context } = target;
+    const time = target.time + layer2.at;
+    const oscillator = context.createOscillator();
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    }
+    const envelope2 = context.createGain();
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    oscillator.connect(envelope2);
+    envelope2.connect(outputStage(plan, layer2, target));
+    oscillator.start(time);
+    oscillator.stop(end2(layer2, time));
+    return [oscillator];
+  }
+  function realizeVoiceLayer(plan, layer2, target) {
+    const source = layer2.source;
+    if (source.kind !== "formant_voice") return [];
+    const { context } = target;
+    const time = target.time + layer2.at;
+    const oscillator = context.createOscillator();
+    oscillator.type = source.wave;
+    assign(oscillator.frequency, source.frequency, time);
+    rampTo(oscillator.frequency, source.frequency, time);
+    const vibrato = context.createOscillator();
+    vibrato.frequency.value = source.vibrato.rate;
+    const vibratoDepth = gainNode(context, source.vibrato.depth);
+    vibrato.connect(vibratoDepth);
+    vibratoDepth.connect(oscillator.frequency);
+    const formants = source.formants.map((formant) => filterNode(context, { type: "bandpass", frequency: { value: formant.frequency }, q: formant.q }, time));
+    const breath = noiseSource(target, true);
+    const breathBand = filterNode(context, { type: "bandpass", frequency: { value: source.breath.frequency }, q: source.breath.q }, time);
+    const breathLevel = gainNode(context, source.breath.gain);
+    const mix = gainNode(context, source.mix);
+    for (const formant of formants) oscillator.connect(formant);
+    breath.connect(breathBand);
+    breathBand.connect(breathLevel);
+    for (const formant of formants) formant.connect(mix);
+    breathLevel.connect(mix);
+    const envelope2 = context.createGain();
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    mix.connect(envelope2);
+    envelope2.connect(outputStage(plan, layer2, target));
+    const stop = end2(layer2, time);
+    oscillator.start(time);
+    vibrato.start(time);
+    breath.start(time, source.breath.offset);
+    oscillator.stop(stop);
+    vibrato.stop(stop);
+    breath.stop(stop);
+    return [oscillator, vibrato, breath];
+  }
+  function realizeLayered(plan, target) {
+    const sources = plan.layers.flatMap((layer2) => {
+      if (layer2.source.kind === "noise") return realizeNoiseLayer(plan, layer2, target);
+      if (layer2.source.kind === "osc") return realizeToneLayer(plan, layer2, target);
+      return realizeVoiceLayer(plan, layer2, target);
+    });
+    return voiceOf(sources);
+  }
+  function realizeSiren(plan, target) {
+    const { context } = target;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
+    const oscillator = context.createOscillator();
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    }
+    const depths = layer2.modulators.map((modulator) => {
+      const lfo = context.createOscillator();
+      if (modulator.wave) lfo.type = modulator.wave;
+      lfo.frequency.value = modulator.rate;
+      const depth = gainNode(context, modulator.depth);
+      lfo.connect(depth);
+      if (modulator.target === "frequency") depth.connect(oscillator.frequency);
+      return { lfo, depth, target: modulator.target };
+    });
+    const lfos = depths.map(({ lfo }) => lfo);
+    const envelope2 = context.createGain();
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    for (const { depth, target: modulated } of depths) if (modulated === "gain") depth.connect(envelope2.gain);
+    const filters = (layer2.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    let tail = oscillator;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(envelope2);
+    envelope2.connect(target.output);
+    if (layer2.wet && target.wet) {
+      const send = gainNode(context, layer2.wet);
+      envelope2.connect(send);
+      send.connect(target.wet);
+    }
+    const stop = end2(layer2, time);
+    oscillator.start(time);
+    for (const lfo of lfos) lfo.start(time);
+    oscillator.stop(stop);
+    for (const lfo of lfos) lfo.stop(stop);
+    return voiceOf([oscillator, ...lfos]);
+  }
+  function noiseLayer(layer2, target, time) {
+    const { context } = target;
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const filters = (layer2.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    const envelope2 = context.createGain();
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    let tail = source;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(envelope2).connect(target.output);
+    source.start(time, layer2.source.kind === "noise" ? layer2.source.offset : 0);
+    source.stop(time + layer2.duration + layer2.tail);
+    return source;
+  }
+  function toneLayer(layer2, target, time) {
+    const { context } = target;
+    const oscillator = context.createOscillator();
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    }
+    const envelope2 = context.createGain();
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    oscillator.connect(envelope2).connect(target.output);
+    oscillator.start(time);
+    oscillator.stop(time + layer2.duration + layer2.tail);
+    return oscillator;
+  }
+  function realizeWeapon(plan, target) {
+    const sources = plan.layers.map((layer2) => {
+      const time = target.time + layer2.at;
+      return layer2.source.kind === "noise" ? noiseLayer(layer2, target, time) : toneLayer(layer2, target, time);
+    });
+    return voiceOf(sources);
+  }
+  var BUILDERS = {
+    layered: realizeLayered,
+    burst: realizeBurst,
+    scream: realizeScream,
+    groan: realizeGroan,
+    boom: realizeBoom,
+    static: realizeStatic,
+    chord: realizeChord,
+    calls: realizeCalls,
+    siren: realizeSiren,
+    weapon: realizeWeapon
+  };
+  function realize(plan, target) {
+    return BUILDERS[plan.order](plan, target);
+  }
+  var usesNoise = (recipe) => recipe.layers.some((layer2) => layer2.source.kind !== "osc");
+  var planUsesNoise = (plan) => plan.layers.some((layer2) => layer2.source.kind !== "osc");
+  function createAudioEngine(options = {}) {
+    const seed = options.seed ?? 1;
+    const registry = createSoundRegistry(options.banks);
+    const voices = createVoiceManager({ ...options.groups ? { groups: options.groups } : {}, ...options.maxVoices === void 0 ? {} : { maxVoices: options.maxVoices } });
+    const engineRandom = createRng2(seed);
+    const shared = createNoiseStore(engineRandom);
+    const busSettings = /* @__PURE__ */ new Map();
+    const busNodes = /* @__PURE__ */ new Map();
+    const meters = /* @__PURE__ */ new Map();
+    const active = /* @__PURE__ */ new Map();
+    const loops = /* @__PURE__ */ new Set();
+    const named = /* @__PURE__ */ new Map();
+    let mix = resolveMix(options.mix ?? DEFAULT_MIX, options.profiles);
+    let context = null;
+    let chain = null;
+    let listener = DEFAULT_LISTENER;
+    let lastTime = 0;
+    const outputFor = (bus) => busNodes.get(bus) ?? chain?.master;
+    const watched = /* @__PURE__ */ new Set();
+    const meterOf = (bus) => {
+      const existing = meters.get(bus);
+      if (existing) return existing;
+      const node = busNodes.get(bus);
+      if (!context || !node || typeof context.createAnalyser !== "function") return void 0;
+      const analyser = context.createAnalyser();
+      analyser.fftSize = 1024;
+      node.connect(analyser);
+      const made = { analyser, data: new Float32Array(analyser.fftSize) };
+      meters.set(bus, made);
+      return made;
+    };
+    const ensureBus = (bus) => {
+      if (!context || !chain || busNodes.has(bus)) return;
+      const node = context.createGain();
+      node.connect(chain.master);
+      busNodes.set(bus, node);
+      if (watched.has(bus)) meterOf(bus);
+    };
+    const ready = () => {
+      if (context) return context;
+      const created = (options.createContext ?? globalContext)();
+      if (!created) return null;
+      context = created;
+      chain = buildChain(created, mix, engineRandom);
+      if (mix.noise.create === "eager") noiseBuffer(shared, created, mix.noise.seconds);
+      for (const [bus, setting] of Object.entries(mix.buses ?? {})) {
+        busSettings.set(bus, { ...setting, ...busSettings.get(bus) });
+      }
+      for (const [bus, setting] of busSettings) {
+        ensureBus(bus);
+        busNodes.get(bus).gain.value = busGain(setting);
+      }
+      lastTime = created.currentTime;
+      return created;
+    };
+    const advance = () => {
+      if (!context) return;
+      const elapsed = context.currentTime - lastTime;
+      lastTime = context.currentTime;
+      if (elapsed > 0) for (const id of voices.advance(elapsed)) active.delete(id);
+    };
+    const inputFor = (recipe, playOptions, random) => ({
+      random,
+      listener,
+      noiseSeconds: mix.noise.seconds,
+      ...options.distance ? { distanceMode: options.distance } : {},
+      ...playOptions.volume === void 0 ? {} : { volume: playOptions.volume },
+      ...playOptions.distance === void 0 ? {} : { distance: playOptions.distance },
+      ...playOptions.position ? { position: playOptions.position } : {},
+      ...playOptions.params ? { params: playOptions.params } : {},
+      ...options.occlusion && playOptions.position && recipe.falloff?.model !== "none" ? { occlusion: options.occlusion(playOptions.position) } : {}
+    });
+    const start = (plan, store, voiceId, delay = 0) => {
+      const audio = context;
+      const realized = realize(plan, {
+        context: audio,
+        output: outputFor(plan.bus),
+        ...chain?.wet ? { wet: chain.wet } : {},
+        noise: () => noiseBuffer(store, audio, mix.noise.seconds),
+        time: audio.currentTime + delay
+      });
+      if (voiceId === void 0) return null;
+      voices.setLength(voiceId, plan.length + delay);
+      active.set(voiceId, realized);
+      return {
+        id: voiceId,
+        plan,
+        stop() {
+          realized.stop();
+          voices.release(voiceId);
+          active.delete(voiceId);
+        }
+      };
+    };
+    const admit = (recipe, gain, distance4) => {
+      const decision = voices.request({ ...recipe.group ? { group: recipe.group } : {}, priority: recipe.priority ?? busPriority(recipe.bus), gain, distance: distance4, length: 0 });
+      if (!decision.accepted) return null;
+      for (const id of decision.evicted) {
+        active.get(id)?.stop();
+        active.delete(id);
+      }
+      return decision.id;
+    };
+    const playWith = (id, playOptions, random, store) => {
+      const recipe = registry.sound(id);
+      if (!recipe || busSettings.get(recipe.bus)?.muted) return null;
+      const distance4 = playOptions.distance ?? (playOptions.position ? listenerDistance(listener, playOptions.position, options.distance) : 0);
+      const level = falloffGain(recipe.falloff, playOptions.volume ?? 1, distance4);
+      const silent = isSilent(recipe.falloff, level);
+      if (silent && !recipe.keepSilent) return null;
+      const audio = ready();
+      if (!audio) return null;
+      unlockContext(audio);
+      advance();
+      const voiceId = silent ? void 0 : admit(recipe, level, distance4);
+      if (voiceId === null) return null;
+      if (!silent && usesNoise(recipe)) prepareNoise(store, audio, mix.noise.seconds);
+      const plan = planSound(recipe, inputFor(recipe, playOptions, playOptions.seed === void 0 ? random : createRng2(playOptions.seed)));
+      return plan ? start(plan, store, voiceId, playOptions.delay) : null;
+    };
+    const randomFor = (playOptions) => {
+      if (playOptions.channel === void 0) return engineRandom;
+      const existing = named.get(playOptions.channel);
+      if (existing) return existing;
+      const stream = streamFor(seed, playOptions.channel);
+      named.set(playOptions.channel, stream);
+      return stream;
+    };
+    const planWith = (id, playOptions, random) => {
+      const recipe = registry.sound(id);
+      return recipe ? planSound(recipe, inputFor(recipe, playOptions, random)) : null;
+    };
+    const loopHost = {
+      ready,
+      output: outputFor,
+      prepareNoise: () => context && prepareNoise(shared, context, mix.noise.seconds),
+      noise: () => noiseBuffer(shared, context, mix.noise.seconds),
+      register: (loop) => void loops.add(loop),
+      unregister: (loop) => void loops.delete(loop)
+    };
+    return {
+      registry,
+      register: (bank) => registry.register(bank),
+      plan: (id, playOptions = {}) => planWith(id, playOptions, createRng2(playOptions.seed ?? seed)),
+      play: (id, playOptions = {}) => playWith(id, playOptions, randomFor(playOptions), shared),
+      playPlan(plan, playOptions = {}) {
+        const audio = ready();
+        if (!audio) return null;
+        advance();
+        const recipe = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
+        const voiceId = plan.silent ? void 0 : admit(recipe, plan.level, plan.distance);
+        if (voiceId === null) return null;
+        if (planUsesNoise(plan)) prepareNoise(shared, audio, mix.noise.seconds);
+        return start(plan, shared, voiceId, playOptions.delay);
+      },
+      loop: (id, loopOptions = {}) => createLoopHandle(registry.loop(id), loopHost, loopOptions.volume),
+      channel(channelOptions) {
+        const random = channelOptions.random ?? (channelOptions.seed === void 0 ? engineRandom : createRng2(channelOptions.seed));
+        const store = channelOptions.ownNoise ? createNoiseStore(random) : shared;
+        return {
+          random,
+          play: (id, playOptions = {}) => playWith(id, playOptions, random, store),
+          plan: (id, playOptions = {}) => planWith(id, playOptions, createRng2(playOptions.seed ?? seed))
+        };
+      },
+      setListener(next) {
+        listener = next;
+      },
+      setBus(id, setting) {
+        busSettings.set(id, { ...busSettings.get(id), ...setting });
+        if (!context) return;
+        ensureBus(id);
+        busNodes.get(id).gain.value = busGain(busSettings.get(id));
+      },
+      setMix(next) {
+        const previous = mix;
+        mix = resolveMix(next, options.profiles);
+        if (!context || !chain) return;
+        const old = chain;
+        chain = buildChain(context, mix, engineRandom);
+        if (mix.noise.seconds !== previous.noise.seconds) shared.reset();
+        for (const node of busNodes.values()) {
+          node.disconnect();
+          node.connect(chain.master);
+        }
+        for (const loop of loops) loop.rewire();
+        old.disconnect();
+      },
+      setMaster(gain) {
+        mix = { ...mix, master: gain };
+        if (chain) chain.master.gain.value = gain;
+      },
+      unlock() {
+        const audio = ready();
+        if (audio) unlockContext(audio);
+      },
+      level(bus) {
+        watched.add(bus);
+        ensureBus(bus);
+        const meter = meterOf(bus);
+        if (!meter) return 0;
+        meter.analyser.getFloatTimeDomainData(meter.data);
+        let sum2 = 0;
+        for (const sample of meter.data) sum2 += sample * sample;
+        return Math.sqrt(sum2 / meter.data.length);
+      },
+      stats() {
+        advance();
+        const voiceStats = voices.stats();
+        return {
+          context: context ? context.state : "none",
+          voices: voiceStats.active,
+          peak: voiceStats.peak,
+          dropped: voiceStats.dropped,
+          maxVoices: voiceStats.maxVoices,
+          loops: [...loops].filter((loop) => loop.created).length
+        };
+      },
+      dispose() {
+        for (const id of active.keys()) voices.release(id);
+        for (const loop of [...loops]) loop.stop();
+        active.clear();
+        void context?.close();
+        context = null;
+        chain = null;
+        busNodes.clear();
+        meters.clear();
+        shared.reset();
+      }
+    };
+  }
+  function createAudioSink(engine) {
+    const playing = /* @__PURE__ */ new Map();
+    return {
+      engine,
+      play(request) {
+        const handle = engine.play(request.sound, {
+          ...request.position ? { position: request.position } : {},
+          ...request.volume === void 0 ? {} : { volume: request.volume },
+          ...request.params ? { params: request.params } : {},
+          ...request.seed === void 0 ? {} : { seed: request.seed }
+        });
+        if (!handle) return null;
+        playing.set(handle.id, handle);
+        return { id: handle.id };
+      },
+      stop(handle) {
+        playing.get(handle.id)?.stop();
+        playing.delete(handle.id);
+      },
+      loop(sound) {
+        const loop = engine.loop(sound);
+        return { set: (state) => loop.set({ ...state.volume === void 0 ? {} : { volume: state.volume }, ...state.frequency === void 0 ? {} : { frequency: state.frequency } }), stop: () => loop.stop() };
+      },
+      setListener(listener) {
+        engine.setListener(listener);
+      },
+      register(bank) {
+        engine.register(bank);
+      }
+    };
+  }
+  var BENCH_BANK = {
+    id: "audio_bench",
+    sounds: [
+      {
+        id: "bench_ping",
+        bus: "ui",
+        pan: true,
+        duration: 0.25,
+        layers: [
+          {
+            gain: 0.5,
+            wet: 0.3,
+            source: { kind: "osc", wave: "sine", frequency: { from: 880 } },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a 880 Hz ping through the art scene output stage"]
+      },
+      {
+        id: "bench_hiss",
+        bus: "ui",
+        pan: true,
+        duration: [0.3, 0.9],
+        layers: [
+          {
+            gain: 0.4,
+            source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+            filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3e3 }, q: 0.7 }] },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a highpass hiss of random length"]
+      }
+    ]
+  };
+
   // ../game-vfx/dist/index.js
   var __defProp2 = Object.defineProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -6974,7 +8740,7 @@ var GameTestRoom = (() => {
     mixed ^= mixed >>> 16;
     return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
   }
-  function streamFor(eventSeed) {
+  function streamFor2(eventSeed) {
     return lehmer(mixEventSeed(eventSeed));
   }
   var TABLE = {
@@ -7070,10 +8836,10 @@ var GameTestRoom = (() => {
           if (!best) return;
           const offsetX = clamp22(x - best.x, -0.2, 0.2);
           const offsetY = clamp22(y - best.y, -0.17, 0.17);
-          for (let draw = 0; draw < OBJECT_ID_DRAWS2; draw++) random.next();
+          for (let draw2 = 0; draw2 < OBJECT_ID_DRAWS2; draw2++) random.next();
           const chipTurn = random.between(0, 6);
           const chipScale = random.between(0.8, 1.3) * scale2;
-          for (let draw = 0; draw < OBJECT_ID_DRAWS2; draw++) random.next();
+          for (let draw2 = 0; draw2 < OBJECT_ID_DRAWS2; draw2++) random.next();
           best.holes.push({ x: offsetX, y: offsetY, scale: scale2, chipTurn, chipScale });
           impact(host.engine, "concrete", [ORIGIN2[0] + x, y, ORIGIN2[2] + 0.13], [0, 0, 1], 0.8);
         } else if (action === "collapse") {
@@ -7972,7 +9738,7 @@ var GameTestRoom = (() => {
     }
     cue(step) {
       const args = this.value(step.args);
-      for (let draw = 0; draw < (step.draws ?? 0); draw++) this.deps.engine.random.next();
+      for (let draw2 = 0; draw2 < (step.draws ?? 0); draw2++) this.deps.engine.random.next();
       this.deps.onCue?.({ cue: step.cue, args, time: this.time });
     }
     scheduleSteps(step) {
@@ -9023,9 +10789,9 @@ var GameTestRoom = (() => {
         this.color[i3] = lerp4(this.rgbStart[i3], this.rgbEnd[i3], t);
         this.color[i3 + 1] = lerp4(this.rgbStart[i3 + 1], this.rgbEnd[i3 + 1], t);
         this.color[i3 + 2] = lerp4(this.rgbStart[i3 + 2], this.rgbEnd[i3 + 2], t);
-        let envelope = t < def.fadeIn ? t / def.fadeIn : 1 - (t - def.fadeIn) / (1 - def.fadeIn);
-        if (def.flicker) envelope *= 1 - def.flicker * (0.5 + 0.5 * Math.sin(age * 38 + this.seed[i] * 50));
-        this.alpha[i] = clamp4(envelope, 0, 1) * def.alpha * this.alphaMul[i];
+        let envelope2 = t < def.fadeIn ? t / def.fadeIn : 1 - (t - def.fadeIn) / (1 - def.fadeIn);
+        if (def.flicker) envelope2 *= 1 - def.flicker * (0.5 + 0.5 * Math.sin(age * 38 + this.seed[i] * 50));
+        this.alpha[i] = clamp4(envelope2, 0, 1) * def.alpha * this.alphaMul[i];
         top = i + 1;
       }
       this.high = top;
@@ -9730,10 +11496,10 @@ var GameTestRoom = (() => {
       this.velocity[offset + 1] = this.direction.y * speed + (options.v ? options.v[1] : 0);
       this.velocity[offset + 2] = this.direction.z * speed + (options.v ? options.v[2] : 0);
       const start = hexToRgb(options.c0 ?? 16777215);
-      const end = options.c1 != null ? hexToRgb(options.c1) : start;
+      const end3 = options.c1 != null ? hexToRgb(options.c1) : start;
       for (let channel = 0; channel < FLOATS_PER_VECTOR; channel++) {
         this.colorStart[offset + channel] = start[channel];
-        this.colorEnd[offset + channel] = end[channel];
+        this.colorEnd[offset + channel] = end3[channel];
       }
       this.life[index] = this.maxLife[index] = drawRange(random, options.life || 1);
       this.startSize[index] = drawRange(random, options.size || 0.1);
@@ -9868,10 +11634,10 @@ var GameTestRoom = (() => {
       this.velocity[offset + 1] = this.direction.y * speed + (options.v ? options.v[1] : 0);
       this.velocity[offset + 2] = this.direction.z * speed + (options.v ? options.v[2] : 0);
       const start = hexToRgb(options.c0 ?? 16765056);
-      const end = options.c1 != null ? hexToRgb(options.c1) : start;
+      const end3 = options.c1 != null ? hexToRgb(options.c1) : start;
       for (let channel = 0; channel < FLOATS_PER_VECTOR2; channel++) {
         this.colorStart[offset + channel] = start[channel];
-        this.colorEnd[offset + channel] = end[channel];
+        this.colorEnd[offset + channel] = end3[channel];
       }
       this.life[index] = this.maxLife[index] = drawRange(random, options.life || 0.4);
       this.length[index] = options.len || 0.02;
@@ -10255,7 +12021,7 @@ var GameTestRoom = (() => {
     function streamOf(seed) {
       if (randomMode === "shared") return sharedRandom;
       handles.events++;
-      return streamFor(seed ?? Math.imul(handles.events, AUTO_SEED) + (options.seed ?? 0));
+      return streamFor2(seed ?? Math.imul(handles.events, AUTO_SEED) + (options.seed ?? 0));
     }
     function detonate(def, point, call3) {
       composeExplosion(core, def, { x: point[0], y: point[1], z: point[2], direction: call3.direction, random: call3.random, handle: call3.handle });
@@ -10834,12 +12600,12 @@ void main(){
     if (typeof document === "undefined") return blankCanvas();
     return document.createElement("canvas");
   }
-  function paint(createCanvas, draw) {
+  function paint(createCanvas, draw2) {
     const canvas = createCanvas();
     canvas.width = TEXTURE_SIZE;
     canvas.height = TEXTURE_SIZE;
     const context = canvas.getContext("2d");
-    if (context) draw(context, TEXTURE_SIZE);
+    if (context) draw2(context, TEXTURE_SIZE);
     return canvas;
   }
   function drawScorch(context, size, random) {
@@ -11697,7 +13463,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var __defProp3 = Object.defineProperty;
   var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  function createRng2(seed) {
+  function createRng3(seed) {
     let a = seed >>> 0;
     return () => {
       a = a + 1831565813 >>> 0;
@@ -11745,7 +13511,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField2(this, "m");
       __publicField2(this, "v");
       __publicField2(this, "w");
-      __publicField2(this, "rng", createRng2(1374496523));
+      __publicField2(this, "rng", createRng3(1374496523));
       __publicField2(this, "markGeometry", null);
       __publicField2(this, "markMaterial", null);
       this.box = new THREE.BoxGeometry(1, 1, 1);
@@ -11776,7 +13542,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const idx = seed % 6;
       let g = this.shardGeos[idx];
       if (!g) {
-        const r = createRng2(1e3 + idx);
+        const r = createRng3(1e3 + idx);
         const n = 3 + Math.floor(r() * 3);
         const shape = new this.THREE.Shape();
         const pts = [];
@@ -11981,9 +13747,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   };
   var MAX_RADIUS = 1.2;
   var GroundSpots = class {
-    constructor(THREE, scene, groundAt, cap) {
+    constructor(THREE, scene2, groundAt, cap) {
       __publicField2(this, "THREE", THREE);
-      __publicField2(this, "scene", scene);
+      __publicField2(this, "scene", scene2);
       __publicField2(this, "groundAt", groundAt);
       __publicField2(this, "cap", cap);
       __publicField2(this, "spots", []);
@@ -12381,9 +14147,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
   };
   var RebarCages = class {
-    constructor(THREE, scene, radius = 4e-3) {
+    constructor(THREE, scene2, radius = 4e-3) {
       __publicField2(this, "THREE", THREE);
-      __publicField2(this, "scene", scene);
+      __publicField2(this, "scene", scene2);
       __publicField2(this, "cages", /* @__PURE__ */ new Map());
       __publicField2(this, "geometry");
       __publicField2(this, "material");
@@ -12990,7 +14756,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     /** A star of jagged lines: `rays` rays up to `length` metres, seeded so the same event always draws the same star. */
     addCrack(mv, worldPoint, worldNormal, rays, length3, color, seed) {
       const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 2e-3);
-      const rnd2 = createRng2(seed);
+      const rnd2 = createRng3(seed);
       const verts = [];
       const n = clamp6(Math.round(rays), 3, 16);
       const L = Math.max(0.02, length3) / s;
@@ -13191,10 +14957,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const sy = lerp5(1, 0.25, melt);
       const sxz = 1 + 0.18 * melt;
       for (let i = range2[0] * 3, v = 0; i < range2[1] * 3; i += 3, v++) {
-        const noise = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+        const noise2 = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
         arr[i] = cx + (work[i] - cx) * sxz;
         arr[i + 2] = cz + (work[i + 2] - cz) * sxz;
-        arr[i + 1] = Math.max(minY, minY + (work[i + 1] - minY) * sy - noise * melt * h * 0.04);
+        arr[i + 1] = Math.max(minY, minY + (work[i + 1] - minY) * sy - noise2 * melt * h * 0.04);
       }
     }
     /** The colour attribute of the host's current geometry (created white when there is none) with vertex colours switched on in its material. */
@@ -13517,10 +15283,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField2(this, "cages");
       __publicField2(this, "active", /* @__PURE__ */ new Map());
       __publicField2(this, "fires", /* @__PURE__ */ new Map());
+      __publicField2(this, "primedBurning", /* @__PURE__ */ new Set());
       __publicField2(this, "leaks", []);
       __publicField2(this, "homeTags", []);
       __publicField2(this, "throttles", /* @__PURE__ */ new Map());
-      __publicField2(this, "rng", createRng2(12648430));
+      __publicField2(this, "rng", createRng3(12648430));
       __publicField2(this, "vfx");
       __publicField2(this, "owner", `destruction-${++rendererCount}`);
       __publicField2(this, "stopLanding");
@@ -13856,8 +15623,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         case "primed":
           if (ev.trigger !== "explosion") {
             this.vfx.fire({ point: ev.point, radius: PRIMED_FIRE_RADIUS, life: ev.delay });
+            this.primedBurning.add(`${ev.object}|${ev.part}`);
             this.activate(ev.object, ev.part);
             this.sound("ignite", ev.point, 0.7);
+            this.sound("burn_loop", ev.point, 0.5);
           }
           break;
         case "spall":
@@ -13875,16 +15644,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           break;
         case "extinguish": {
           const f = this.fires.get(`${ev.object}|${ev.part}`);
+          const primed = this.primedBurning.delete(`${ev.object}|${ev.part}`);
           if (f) {
             this.stopFire(`${ev.object}|${ev.part}`);
             this.vfx.burst("steam", f.point, [0, 1, 0], 14, 1.2);
           }
+          if (f || primed) this.sound("burn_end", f?.point ?? this.rootPoint(ev.object), 0.5);
           this.activate(ev.object, ev.part);
           this.sound("extinguish", f?.point ?? this.rootPoint(ev.object), 0.6);
           break;
         }
         case "burnout": {
           this.stopFire(`${ev.object}|${ev.part}`);
+          this.primedBurning.delete(`${ev.object}|${ev.part}`);
+          this.sound("burn_end", ev.point, 0.5);
           this.vfx.burst("ash", ev.point, [0, 1, 0], 16, 1);
           this.vfx.burst("smoke", ev.point, [0, 1, 0], 6, 0.8, { color: SMOKE_TONES.grey });
           const pv = this.partVis(ev.object, ev.part);
@@ -13926,6 +15699,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           break;
         }
         case "explode":
+          this.primedBurning.delete(`${ev.object}|${ev.part}`);
           this.onExplode(ev);
           break;
         case "destroyed":
@@ -14009,7 +15783,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (!b || !pv) return;
       const def = this.world.materials.get(pv.material);
       const n = this.worldDir(b, ev.hole.normal);
-      const draw = (point, normal) => {
+      const draw2 = (point, normal) => {
         const wp = new this.THREE.Vector3(point[0], point[1], point[2]);
         const mv = this.nearestMesh(pv, wp);
         if (!mv) return;
@@ -14020,8 +15794,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           this.visuals.addHole(mv, wp, normal, ev.hole.diameter);
         }
       };
-      draw(ev.worldPoint, n);
-      if (ev.hole.through && ev.exitPoint) draw(ev.exitPoint, n.clone().negate());
+      draw2(ev.worldPoint, n);
+      if (ev.hole.through && ev.exitPoint) draw2(ev.exitPoint, n.clone().negate());
       if (def?.tags?.includes("metal")) this.vfx.burst("sparks", ev.worldPoint, [n.x, n.y, n.z], 6, 3.5);
       this.sound(impactKey(def), ev.worldPoint, 0.6);
     }
@@ -14219,6 +15993,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (options.visual !== false) this.playExplosion(ev, options);
       this.vfx.push(p, ev.radius, 4);
       const c = this.v1;
+      const report = options.report;
+      const confinement = report?.find((r) => r.blast !== void 0)?.blast?.confinement ?? 1;
+      const energy = ev.energy * confinement;
       for (const pc of this.pieceSys.list) {
         this.pieceSys.centerOf(pc, c);
         const dx = c.x - p[0];
@@ -14227,13 +16004,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const d = Math.hypot(dx, dy, dz);
         if (d > ev.radius) continue;
         const fall = (1 - d / ev.radius) ** 2;
-        const speed = Math.min(30, Math.sqrt(2 * ev.energy * 0.02 / pc.mass)) * fall;
+        const reach = report?.find((r) => r.object === pc.objectId)?.blast?.shelter ?? 1;
+        const speed = Math.min(30, Math.sqrt(2 * energy * reach * 0.02 / pc.mass)) * fall;
         const inv = d > 1e-4 ? 1 / d : 0;
         const dir = d > 1e-4 ? [dx * inv, dy * inv + 0.3, dz * inv] : [0, 1, 0];
         const spread2 = pc.halfExtents[0];
         this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread2, c.y + spread2 * 0.5, c.z + (this.rng() - 0.5) * spread2]);
       }
-      this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(ev.energy) * 0.08));
+      this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(energy) * 0.08));
       this.sound("explode", p, clamp6(0.5 + ev.radius / 10, 0.5, 1));
     }
     playExplosion(ev, options) {
@@ -14416,6 +16194,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.fragments.clear();
       this.ground.clear();
       this.cages.clear();
+      this.primedBurning.clear();
       this.vfx.sprites().clear();
       this.ownVfx?.world.clear();
     }
@@ -14444,12 +16223,197 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.disposed = true;
     }
   };
+  var ATTACK = 2e-3;
+  var lengthOf = (d, attack) => {
+    if (typeof d === "number") return attack + d;
+    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
+    return { ...d, add: (d.add ?? 0) + attack };
+  };
+  var envelope = (attack) => [
+    [0, 1e-4, "set", "fixed"],
+    [attack, 1, "exp"],
+    ["1d", 1e-4, "exp", "fixed"]
+  ];
+  function noise(o) {
+    const a = o.a ?? ATTACK;
+    const over = typeof o.d === "number" ? o.d : 0;
+    return {
+      filters: {
+        mode: "serial",
+        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
+      },
+      duration: lengthOf(o.d, a),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+      envelope: envelope(a)
+    };
+  }
+  function tone(o) {
+    return {
+      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
+      duration: lengthOf(o.d, ATTACK),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      envelope: envelope(ATTACK)
+    };
+  }
+  var many = (count, make) => Array.from({ length: count }, make);
+  var scene = (id, layers, line, vars) => ({
+    id,
+    bus: "world",
+    pan: true,
+    layers,
+    falloff: DISTANCE_CURVES.art_scene,
+    ...vars ? { vars } : {},
+    sources: [`cena:${line}`]
+  });
+  var boomLayers = (big) => [
+    noise({ f: 1200, f2: 120, d: 1.8, vol: 2, wet: 1.2 }),
+    tone({ f: 65, f2: 24, d: 1, vol: 1.8 }),
+    noise({ type: "highpass", f: 1500, d: 0.2, vol: 0.8 }),
+    ...big ? [noise({ f: 500, f2: 90, a: 0.2, d: 2.4, vol: 1.2, wet: 1, delay: 0.15 })] : [],
+    ...many(8, () => tone({ f: [2600, 5600], d: 0.05, vol: 0.08, delay: [0.4, 1.6] }))
+  ];
+  var SCENE_SOUNDS = [
+    scene(
+      "glass_shatter",
+      [noise({ type: "highpass", f: 2800, d: 0.45, vol: 0.9, wet: 0.5 }), ...many(12, () => tone({ f: [3e3, 7500], d: [0.06, 0.14], vol: 0.18, delay: [0, 0.55] }))],
+      "L1359 glass"
+    ),
+    scene(
+      "wood_hit",
+      [noise({ type: "bandpass", f: 850, q: 1, d: 0.25, vol: 0.9, wet: 0.3 }), tone({ f: 210, f2: 90, d: 0.1, vol: 0.6 }), noise({ type: "highpass", f: 2e3, d: 0.04, vol: 0.5 })],
+      "L1360 wood"
+    ),
+    scene("thunk", [noise({ type: "bandpass", f: 700, q: 2, d: 0.07, vol: 0.4 })], "L1361 thunk"),
+    scene("ping", [tone({ f: [2600, 3500], f2: 1400, d: 0.14, vol: 0.18, wet: 0.3 })], "L1362 ping"),
+    scene("clang", [tone({ f: [520, 720], f2: 480, d: 0.5, vol: 0.35, wet: 0.4 }), tone({ f: 1370, f2: 1300, d: 0.3, vol: 0.15 }), noise({ type: "highpass", f: 2e3, d: 0.05, vol: 0.5 })], "L1363 clang"),
+    scene("chip", [noise({ type: "bandpass", f: 1600, q: 1.2, d: 0.06, vol: 0.5 })], "L1364 chip"),
+    scene(
+      "crumble",
+      [noise({ f: 900, f2: 200, d: 0.6, vol: 0.9, wet: 0.3 }), ...many(5, () => noise({ type: "bandpass", f: [500, 1400], q: 2, d: 0.05, vol: 0.4, delay: [0.1, 0.5] }))],
+      "L1365 crumble"
+    ),
+    // `thud(x, z, v)`: `v` is the `scale` param (default 1)
+    scene("thud", [tone({ f: 75, f2: 38, d: 0.22, vol: { param: "scale", scale: 0.6 } }), noise({ f: 420, d: 0.16, vol: { param: "scale", scale: 0.45 } })], "L1358 thud", { scale: 1 }),
+    // `hiss(x, z, d)`: `seconds` is the param `d` (default 1.2)
+    scene("hiss", [noise({ type: "highpass", f: 3500, a: 0.05, d: { param: "seconds" }, vol: 0.35 })], "L1366 hiss", { seconds: 1.2 }),
+    scene("boom", boomLayers(false), "L1367 boom"),
+    scene("boom_big", boomLayers(true), "L1367 boom (big)"),
+    scene("burst", [noise({ f: 700, f2: 120, d: 0.7, vol: 1.4, wet: 0.5 }), noise({ type: "highpass", f: 3e3, a: 0.05, d: 1.2, vol: 0.4, delay: 0.1 })], "L1357 burst"),
+    scene("crack", [noise({ type: "highpass", f: 1800, d: 0.05, vol: 0.8 }), tone({ f: 420, f2: 180, d: 0.06, vol: 0.4 })], "L1354 crack")
+  ];
+  var EXPLOSION_BOOM = {
+    id: "explosion_boom",
+    bus: "world",
+    order: "boom",
+    duration: 1.6,
+    tail: 0.1,
+    layers: [
+      {
+        source: { kind: "osc", wave: "sine", frequency: { from: 70, to: 28, curve: "exp", over: 1.2 } },
+        envelope: [
+          [0, 1, "set"],
+          ["1d", 1e-3, "exp", "fixed"]
+        ]
+      }
+    ],
+    falloff: DISTANCE_CURVES.game_boom,
+    sources: ["jogo:L68278-68285 boom"]
+  };
+  var BURN_LOOP = {
+    id: "burn_loop",
+    bus: "world",
+    order: "chain_loop",
+    source: { kind: "noise", loop: true },
+    filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: 1800 }, q: 0.6 }] },
+    volume: 0,
+    sources: ["cena:L1316 fire loop (silent in the page: its gain is never raised)", "sdk: the level while burning"]
+  };
+  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
+  var DESTRUCTION_SOUND_KEYS = {
+    art_scene: {
+      impact_metal: { sound: "clang" },
+      impact_wood: { sound: "wood_hit" },
+      impact_glass: { sound: "ping" },
+      impact_masonry: { sound: "chip" },
+      impact_soft: { sound: "thud" },
+      shatter_glass: { sound: "glass_shatter" },
+      crumble: { sound: "crumble" },
+      splinter: { sound: "crack" },
+      ricochet: { sound: "ping" },
+      unscrew: { sound: "chip" },
+      detach: { sound: "thunk" },
+      ignite: { sound: "hiss", params: { seconds: 0.5 } },
+      extinguish: { sound: "hiss" },
+      melt_sizzle: { sound: "hiss", params: { seconds: 0.6 } },
+      explode: { sound: "boom", above: { volume: 0.9, sound: "boom_big" } }
+    },
+    game: {
+      impact_metal: { sound: "sfx_impact" },
+      impact_wood: { sound: "sfx_wood" },
+      impact_glass: { sound: "sfx_glass" },
+      impact_masonry: { sound: "sfx_impact" },
+      impact_soft: { sound: "sfx_flesh" },
+      shatter_glass: { sound: "sfx_glass" },
+      crumble: { sound: "sfx_impact" },
+      splinter: { sound: "sfx_wood" },
+      explode: { sound: "explosion_boom" }
+    }
+  };
+  var DEFAULT_FIRE = { perFire: 0.05, max: 0.2 };
+  function createDestructionSound(engine, options = {}) {
+    engine.register(DESTRUCTION_SOUND_BANK);
+    engine.register(GAME_SFX_BANK);
+    const fire = { ...DEFAULT_FIRE, ...options.fire };
+    const rules = { ...DESTRUCTION_SOUND_KEYS.art_scene, ...options.style === "game" ? DESTRUCTION_SOUND_KEYS.game : {}, ...options.keys };
+    let loop;
+    let burning = 0;
+    const setFire = () => {
+      if (options.burnLoop === false) return;
+      if (burning <= 0) {
+        loop?.stop();
+        loop = void 0;
+        return;
+      }
+      loop ?? (loop = engine.loop("burn_loop"));
+      loop.set({ volume: Math.min(fire.max, fire.perFire * burning) });
+    };
+    return {
+      onSound(key, point, volume) {
+        if (key === "burn_loop") {
+          burning += 1;
+          setFire();
+          return;
+        }
+        if (key === "burn_end") {
+          if (burning > 0) burning -= 1;
+          setFire();
+          return;
+        }
+        const rule = rules[key];
+        if (!rule) return;
+        const sound = rule.above && volume >= rule.above.volume ? rule.above.sound : rule.sound;
+        engine.play(sound, { position: point, volume: volume * (rule.volumeScale ?? 1), ...rule.params ? { params: rule.params } : {} });
+      },
+      rule: (key) => rules[key] ?? void 0,
+      burning: () => burning,
+      dispose() {
+        loop?.stop();
+        loop = void 0;
+        burning = 0;
+      }
+    };
+  }
 
   // ../game-weapons/dist/index.js
   var __defProp4 = Object.defineProperty;
   var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
-  var createRng3 = (seed) => {
+  var createRng4 = (seed) => {
     let a = seed >>> 0;
     return () => {
       a = a + 1831565813 >>> 0;
@@ -26598,9 +28562,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.caliber = init.caliber;
       this.action = init.def.action;
       this.rules = init.rules;
-      this.rng = createRng3(init.seed);
-      this.faultRng = createRng3((init.seed ^ FAULT_RNG_SALT) >>> 0);
-      this.fuseRng = createRng3((init.seed ^ FUSE_RNG_SALT) >>> 0);
+      this.rng = createRng4(init.seed);
+      this.faultRng = createRng4((init.seed ^ FAULT_RNG_SALT) >>> 0);
+      this.fuseRng = createRng4((init.seed ^ FUSE_RNG_SALT) >>> 0);
       this.explosive = init.explosive ?? null;
       this._safety = init.rules.startSafe;
       this._condition = findById(init.rules.conditions, init.condition ?? init.rules.defaultCondition, "condition");
@@ -26862,7 +28826,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.isCompatible = init.isCompatible;
       this.makeUnderbarrel = init.makeUnderbarrel;
       this.seed = init.seed;
-      this.breakRng = createRng3((init.seed ^ BREAK_RNG_SALT) >>> 0);
+      this.breakRng = createRng4((init.seed ^ BREAK_RNG_SALT) >>> 0);
       this.fitted = (init.snapshot?.attachments ?? init.def.fitted ?? []).map(copyOf);
       if (init.snapshot) this.stockState = init.snapshot.stock;
       this.fitted = this.fitted.map((part) => part.shotsLeft === void 0 ? this.withDurability(part) : part);
@@ -27121,10 +29085,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField3(this, "lastRoundAt", Number.NEGATIVE_INFINITY);
     }
     /** When the barrels of a rotary gun are at speed: `upSeconds` after the pull began, and at once while they still spin from the last round. */
-    spunUpAt(spin, start, end) {
+    spunUpAt(spin, start, end3) {
       if (!spin || start - this.lastRoundAt <= spin.holdSeconds + EPS3) return 0;
       if (this.spinSince === void 0 || start - this.spinFrameEnd > SPIN_PULL_GAP) this.spinSince = start;
-      this.spinFrameEnd = end;
+      this.spinFrameEnd = end3;
       return this.spinSince + spin.upSeconds;
     }
     oncePerPull(held) {
@@ -27133,7 +29097,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.latched = true;
       return true;
     }
-    fireFirearm(a, origin, dir, start, end, held, source) {
+    fireFirearm(a, origin, dir, start, end3, held, source) {
       if (this._reloading) {
         if (this.loadStep !== null && this._ammo > 0) this.stopReload(start);
         else return result("reloading");
@@ -27143,10 +29107,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.emit({ type: "empty", at: start });
         return result("empty");
       }
-      const t0 = Math.max(start, this.readyAt, this.spunUpAt(a.spin, start, end));
-      if (t0 > end + EPS3) return result("cooldown");
+      const t0 = Math.max(start, this.readyAt, this.spunUpAt(a.spin, start, end3));
+      if (t0 > end3 + EPS3) return result("cooldown");
       const res = result("ok");
-      const times = planRounds(a, this.mode, this._ammo, t0, end);
+      const times = planRounds(a, this.mode, this._ammo, t0, end3);
       let lastAt = t0;
       for (const t of times) {
         const fault = rollFault({ def: this.def, caliber: this.caliber, condition: this._condition, ammoQuality: this._ammoQuality, heat: this._heat, rules: this.faultRules(), random: this.faultRng });
@@ -27262,7 +29226,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.pend = { src: "trigger", amt: d };
       }
       const start = this.clock - overlap;
-      const end = start + d;
+      const end3 = start + d;
       this.settle(start);
       const dir = normalize2(direction);
       let res;
@@ -27273,10 +29237,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       else if (launcher) res = launcher.trigger(origin, dir, d, held, source);
       else switch (a.kind) {
         case "firearm":
-          res = this.fireFirearm(a, origin, dir, start, end, held, source);
+          res = this.fireFirearm(a, origin, dir, start, end3, held, source);
           break;
         case "melee":
-          res = this.fireMelee(a, origin, dir, start, end);
+          res = this.fireMelee(a, origin, dir, start, end3);
           break;
         case "flame":
         case "heat":
@@ -27286,7 +29250,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           res = this.fireExtinguisher(a, origin, dir, d);
           break;
         case "throwable":
-          res = this.fireThrowable(a, origin, dir, held, start, end);
+          res = this.fireThrowable(a, origin, dir, held, start, end3);
           break;
         case "launcher":
           res = this.fireLauncher(a, origin, dir, start, held);
@@ -27298,7 +29262,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           res = this.oncePerPull(held) ? result("ok", { uses: [{ kind: "hand", reach: a.reach, origin, direction: dir }] }) : result("cooldown");
           break;
       }
-      this.advance(Math.max(0, end - this.clock));
+      this.advance(Math.max(0, end3 - this.clock));
       this.settle(this.clock);
       return res;
     }
@@ -27330,9 +29294,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.emit({ type: "shot", shots: 0, rounds: 1, mode: this.mode, at: t });
       return result("ok", { uses: launcherUses(a, this.explosive, origin, dir), recoil: [a.recoil[0], a.recoil[1]], noise: a.noise ?? 0, rounds: 1, roundTimes: [t - start] });
     }
-    fireMelee(a, origin, dir, start, end) {
+    fireMelee(a, origin, dir, start, end3) {
       const t0 = Math.max(start, this.readyAt);
-      if (t0 > end + EPS3) return result("cooldown");
+      if (t0 > end3 + EPS3) return result("cooldown");
       this.readyAt = t0 + 60 / a.rpm;
       const use = { kind: "melee", damage: a.damage, energy: a.energy, radius: a.radius, reach: a.reach, origin, direction: dir };
       return result("ok", { uses: [use], noise: a.noise });
@@ -27366,8 +29330,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return result("ok", { uses: [throwableUse({ action: a, explosive: this.explosive, origin, direction: dir, fuse, rules: this.rules.explosives, ...extra })], noise: a.noise });
     }
     /** A timer throwable is cooked from the pull; impact, remote and wire ones (and a long fuse that sets down) act at once. */
-    fireThrowable(a, origin, dir, held, start, end) {
-      if (this.cook) return this.cookStep(a, origin, dir, end);
+    fireThrowable(a, origin, dir, held, start, end3) {
+      if (this.cook) return this.cookStep(a, origin, dir, end3);
       if (!this.oncePerPull(held)) return result("cooldown");
       if (this._ammo <= 0) return result("empty");
       const fuse = this.sampleThrowFuse(a);
@@ -27377,7 +29341,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       this.cook = { start, fuse, origin, direction: dir };
       this.emit({ type: "cook", phase: "start", fuse, at: start });
-      return this.cookStep(a, origin, dir, end);
+      return this.cookStep(a, origin, dir, end3);
     }
     /** The trigger stays down on a cooked throwable: nothing happens until the fuse runs out in the hand. */
     cookStep(a, origin, dir, now) {
@@ -29734,17 +31698,17 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
             }
           }
           const start = time;
-          const end = Math.min(def.duration, time + Math.max(0, dt));
+          const end3 = Math.min(def.duration, time + Math.max(0, dt));
           for (let i = 0; i < keys.length && !done; i++) {
             const key = keys[i];
             const spanStart = key.t;
             const spanEnd = i + 1 < keys.length ? keys[i + 1].t : def.duration;
-            if ((key.action === "open" || key.action === "close") && !fired.has(i) && end >= spanStart) {
+            if ((key.action === "open" || key.action === "close") && !fired.has(i) && end3 >= spanStart) {
               fired.add(i);
               if (key.action === "open") world.open(containerId);
               else world.close(containerId);
             }
-            const overlap = Math.min(end, spanEnd) - Math.max(start, spanStart);
+            const overlap = Math.min(end3, spanEnd) - Math.max(start, spanStart);
             if (overlap <= 0) continue;
             if (key.action === "drink") {
               const ev = world.drink(containerId, (key.rate ?? DEFAULT_DRINK_RATE) * overlap);
@@ -29758,7 +31722,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
             }
           }
           if (!done) {
-            time = end;
+            time = end3;
             done = time >= def.duration;
           }
           follow(dt);
@@ -30360,8 +32324,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
           bedHeight = roadY * 1e3 + z * 14 - (x - params.roadSlopeAnchorX) * 5;
           roughness = 0.55;
         }
-        const noise = valueNoise(column * 0.35, row * 0.35) * 0.6 + valueNoise(column * 1.3, row * 1.3) * 0.4;
-        bed[index] = bedHeight + (noise - 0.5) * roughness * 2;
+        const noise2 = valueNoise(column * 0.35, row * 0.35) * 0.6 + valueNoise(column * 1.3, row * 1.3) * 0.4;
+        bed[index] = bedHeight + (noise2 - 0.5) * roughness * 2;
         vertical[index] = region === 0 || region === 2 ? 0.95 : 1;
         pin[index] = 0.62 + 0.76 * (valueNoise(column * 0.21 + 40, row * 0.21) * 0.5 + hashCell(column, row) * 0.5) * (region === 3 ? 1.25 : 1);
       }
@@ -30518,8 +32482,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         for (let column = 0; column < columns; column++) {
           const index = (region.firstRow + row) * columns + column;
           const centre = add2(add2(region.origin, scale(columnAxis, (column + 0.5) * cell)), scale(region.rowAxis, (row + 0.5) * cell));
-          const noise = valueNoise(column * 0.35, (region.firstRow + row) * 0.35) * 0.6 + valueNoise(column * 1.3, (region.firstRow + row) * 1.3) * 0.4;
-          bed[index] = centre[1] * 1e3 + (noise - 0.5) * strip.roughness * 2;
+          const noise2 = valueNoise(column * 0.35, (region.firstRow + row) * 0.35) * 0.6 + valueNoise(column * 1.3, (region.firstRow + row) * 1.3) * 0.4;
+          bed[index] = centre[1] * 1e3 + (noise2 - 0.5) * strip.roughness * 2;
           vertical[index] = region.isVertical ? 0.95 : 1;
           pin[index] = 0.62 + 0.76 * (valueNoise(column * 0.21 + 40, (region.firstRow + row) * 0.21) * 0.5 + valueNoise(column * 0.9, row * 0.9) * 0.5);
         }
@@ -31432,8 +33396,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         const b2x = ty * b1z - tz * b1y;
         const b2y = tz * b1x - tx * b1z;
         const b2z = tx * b1y - ty * b1x;
-        const end = Math.min(1, 0.35 + Math.min(k, 1 - k) * 8);
-        const r = this.radiusAt(state, gravity, t, r0, speed0) * end;
+        const end3 = Math.min(1, 0.35 + Math.min(k, 1 - k) * 8);
+        const r = this.radiusAt(state, gravity, t, r0, speed0) * end3;
         for (let j = 0; j < sides; j++) {
           const a = j / sides * Math.PI * 2;
           const c = Math.cos(a);
@@ -31467,15 +33431,15 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   };
   var rendererCount2 = 0;
   function createFluidRenderer(THREE, options) {
-    const { scene, fluids } = options;
+    const { scene: scene2, fluids } = options;
     const quality = options.quality ?? "medium";
     const profile = profileOf(quality);
     const materials = new MaterialCache(THREE, options.envMap ?? null);
     const root = new THREE.Group();
     root.name = "fluid_renderer";
-    scene.add(root);
+    scene2.add(root);
     const vfx = options.vfx ?? createVfx({ profile: quality, gravity: fluids.gravity, sprites: { capacity: profile.maxParticles } });
-    const ownVfx = options.vfx ? void 0 : createVfxRenderer(THREE, { scene, camera: options.camera ?? new THREE.PerspectiveCamera(), vfx, pointScale: options.pointScale ?? 600 });
+    const ownVfx = options.vfx ? void 0 : createVfxRenderer(THREE, { scene: scene2, camera: options.camera ?? new THREE.PerspectiveCamera(), vfx, pointScale: options.pointScale ?? 600 });
     const particles = new FluidSprites(vfx, `fluids-${++rendererCount2}`);
     const dropGeometry = new THREE.SphereGeometry(1, 8, 6);
     const bodies = /* @__PURE__ */ new Map();
@@ -31612,7 +33576,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         ownVfx?.dispose();
         dropGeometry.dispose();
         materials.dispose();
-        scene.remove(root);
+        scene2.remove(root);
         root.clear();
       },
       stats() {
@@ -32683,6 +34647,16 @@ void main(){
       "ui.slow": "Slow motion 0.25\xD7",
       "ui.fast": "Time \xD710",
       "ui.tap": "Tap",
+      "ui.blast.shelter": "Shelter",
+      "ui.blast.fragmentHits": "Fragments",
+      "ui.blast.confinement": "Confinement",
+      "ui.blast.shelter.hint": "Blasts: walls and other parts between the blast and the target take their share",
+      "ui.blast.fragmentHits.hint": "Blasts: the pieces of what breaks fly on and hit what is behind",
+      "ui.blast.confinement.hint": "Blasts: pressure builds up in an enclosed room",
+      "metric.blast_shelter": "Blast reaching (%)",
+      "metric.blast_confinement": "Blast pressure (x)",
+      "metric.blast_fragments": "Fragment hits",
+      "act.blast_report": "Blast: {shelter}% reached the most sheltered target, pressure x{confinement}, {fragments} fragment hits, {n} targets",
       "ui.quality": "Quality",
       "ui.quality.low": "low",
       "ui.quality.medium": "medium",
@@ -33008,6 +34982,16 @@ void main(){
       "ui.slow": "C\xE2mera lenta 0,25\xD7",
       "ui.fast": "Tempo \xD710",
       "ui.tap": "Torneira",
+      "ui.blast.shelter": "Abrigo",
+      "ui.blast.fragmentHits": "Estilha\xE7os",
+      "ui.blast.confinement": "Confinamento",
+      "ui.blast.shelter.hint": "Explos\xF5es: paredes e outras partes entre a explos\xE3o e o alvo ficam com a sua parte",
+      "ui.blast.fragmentHits.hint": "Explos\xF5es: os peda\xE7os do que quebra voam e acertam o que est\xE1 atr\xE1s",
+      "ui.blast.confinement.hint": "Explos\xF5es: a press\xE3o sobe num ambiente fechado",
+      "metric.blast_shelter": "Explos\xE3o que chegou (%)",
+      "metric.blast_confinement": "Press\xE3o da explos\xE3o (x)",
+      "metric.blast_fragments": "Estilha\xE7os que acertaram",
+      "act.blast_report": "Explos\xE3o: {shelter}% chegou ao alvo mais abrigado, press\xE3o x{confinement}, {fragments} estilha\xE7os acertaram, {n} alvos",
       "ui.quality": "Qualidade",
       "ui.quality.low": "baixa",
       "ui.quality.medium": "m\xE9dia",
@@ -33454,10 +35438,10 @@ void main(){
     }
     return { name: "shelf", parts, joints, tags: ["furniture"] };
   };
-  function createArena(THREE, size, scene) {
+  function createArena(THREE, size, scene2) {
     const group = new THREE.Group();
     group.name = "test-room-arena";
-    scene.background = new THREE.Color(10466504);
+    scene2.background = new THREE.Color(10466504);
     group.add(new THREE.HemisphereLight(13624319, 7037527, 0.75));
     const sun = new THREE.DirectionalLight(16777215, 2.1);
     sun.position.set(7, 13, 8);
@@ -33730,9 +35714,19 @@ void main(){
 
   // src/explosives.ts
   var CONE_BLAST_RADIUS = 0.5;
+  var summarizeBlast = (results) => {
+    const reports = results.flatMap((r) => r.blast ? [r.blast] : []);
+    if (reports.length === 0) return void 0;
+    return {
+      shelter: Math.min(...reports.map((r) => r.shelter)),
+      confinement: reports[0].confinement,
+      fragmentHits: reports.reduce((n, r) => n + r.fragmentHits, 0),
+      targets: reports.length
+    };
+  };
   var toArray = (vector) => [vector.x, vector.y, vector.z];
   function createExplosives(context) {
-    const { THREE, scene, camera: camera2, world, renderer, arsenal, translate, format, action } = context;
+    const { THREE, scene: scene2, camera: camera2, world, renderer, arsenal, translate, format, action } = context;
     const projectiles = [];
     const meshes = [];
     const up = new THREE.Vector3(0, 1, 0);
@@ -33745,7 +35739,7 @@ void main(){
       const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color, roughness: 0.6, metalness }));
       mesh.castShadow = true;
       mesh.position.set(at3[0], at3[1], at3[2]);
-      scene.add(mesh);
+      scene2.add(mesh);
       meshes.push(mesh);
       return mesh;
     };
@@ -33800,7 +35794,7 @@ void main(){
       flag.position.y = 0.46;
       marker.add(stake, flag);
       marker.position.set(at3[0] + 0.12, at3[1] - 0.03, at3[2]);
-      scene.add(marker);
+      scene2.add(marker);
       meshes.push(marker);
       return marker;
     };
@@ -33808,7 +35802,7 @@ void main(){
       const geometry = new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(...from), new THREE.Vector3(...to)]);
       const line = new THREE.Line(geometry, new THREE.LineBasicMaterial({ color: 15262920 }));
       line.name = "charge_wire";
-      scene.add(line);
+      scene2.add(line);
       meshes.push(line);
       return line;
     };
@@ -33876,17 +35870,27 @@ void main(){
         if (box2.isEmpty()) box2.expandByPoint(object.position);
         const at3 = mostExposedPoint(box2, detonation);
         if (!at3) continue;
-        reached += world.explode(at3, detonation.energy * blastEffect(detonation, at3).falloff, CONE_BLAST_RADIUS, "player").length;
+        const results = world.explode(at3, detonation.energy * blastEffect(detonation, at3).falloff, CONE_BLAST_RADIUS, "player", context.blast());
+        reached += results.length;
+        told(results);
       }
       return reached;
     };
+    const told = (results) => {
+      const summary = summarizeBlast(results);
+      if (!summary) return;
+      context.blasted(summary);
+      action("blast_report", translate("act.blast_report", { shelter: format(summary.shelter * 100, 0), confinement: format(summary.confinement, 2), fragments: summary.fragmentHits, n: summary.targets }), { data: { ...summary } });
+    };
     const detonate = (projectile, detonation) => {
       const weaponName = context.toolName(projectile.weapon);
       const reach = Math.max(detonation.injuryRadius, detonation.lethalRadius);
-      const reached = detonation.energy <= 0 ? 0 : detonation.cone ? coneBlast(detonation) : world.explode(detonation.point, detonation.energy, reach, "player").length;
+      const results = detonation.energy <= 0 || detonation.cone ? [] : world.explode(detonation.point, detonation.energy, reach, "player", context.blast());
+      const reached = detonation.energy <= 0 ? 0 : detonation.cone ? coneBlast(detonation) : results.length;
+      if (!detonation.cone) told(results);
       if (detonation.energy > 0) {
         const isPlayed = context.effects.explosion(detonation.explosive, detonation.point, { direction: detonation.direction }) !== null;
-        renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed });
+        renderer.explode(detonation.point, detonation.energy, reach, { visual: !isPlayed, report: results });
       }
       if (detonation.stunSeconds !== void 0) renderer.emit("flash", detonation.point, [0, 1, 0], 1, 1);
       const onPlayer = blastEffect(detonation, toArray(camera2.position));
@@ -34183,7 +36187,7 @@ void main(){
   }
 
   // src/metrics.ts
-  var ROOM_METRICS = ["fps", "frame_ms", "draw_calls", "triangles", "objects", "fragments", "particles", "decals"];
+  var ROOM_METRICS = ["fps", "frame_ms", "draw_calls", "triangles", "objects", "fragments", "particles", "decals", "blast_shelter", "blast_confinement", "blast_fragments"];
   var WINDOW_S = 0.5;
   function createRoomMetrics(sources) {
     const wanted = new Set(sources.ids);
@@ -34220,6 +36224,12 @@ void main(){
         const render = ownsRender ? { calls, triangles } : gl.info?.render;
         put("draw_calls", render?.calls);
         put("triangles", render?.triangles);
+        const blast = sources.blast?.();
+        if (blast) {
+          put("blast_shelter", blast.shelter * 100);
+          put("blast_confinement", blast.confinement);
+          put("blast_fragments", blast.fragmentHits);
+        }
         if (!["objects", "fragments", "particles", "decals"].some((id) => wanted.has(id))) return out;
         const destruction = sources.destruction.stats();
         const fluids = sources.fluids.stats();
@@ -34483,13 +36493,13 @@ void main(){
             if (!g || g.done) break;
             g.done = true;
             const [a, b] = ev.parts;
-            const many = g.list.length > 1;
+            const many2 = g.list.length > 1;
             c.log.add({
               channel: "event",
               type: "detach",
               objectId: ev.object,
               itemId: c.itemIdOf(ev.object),
-              text: many ? t(`ev.detach.many.${ev.by === "tool" ? "tool" : "break"}`, { obj: c.nameOf(ev.object), joints: joints(g.list.length), pieces: pieces(g.groups) }) : t("ev.detach", { obj: c.nameOf(ev.object), a, b, by: t(`by.${ev.by}`), pieces: pieces(g.groups) }),
+              text: many2 ? t(`ev.detach.many.${ev.by === "tool" ? "tool" : "break"}`, { obj: c.nameOf(ev.object), joints: joints(g.list.length), pieces: pieces(g.groups) }) : t("ev.detach", { obj: c.nameOf(ev.object), a, b, by: t(`by.${ev.by}`), pieces: pieces(g.groups) }),
               data: { joint: ev.joint, joints: g.list.map((j) => j.joint), parts: ev.parts, by: ev.by, groups: g.groups }
             });
             break;
@@ -35490,23 +37500,23 @@ void main(){
       }
       if (sheet.timeline) {
         const { segments, ticks, metric } = sheet.timeline;
-        const end = Math.max(1e-3, ...segments.map((segment) => segment.end), ...ticks);
+        const end3 = Math.max(1e-3, ...segments.map((segment) => segment.end), ...ticks);
         const strip = mk("div", "tr-timeline");
         for (const segment of segments) {
           const bar2 = mk("div", "tr-segment", segment.name);
-          bar2.style.left = `${segment.start / end * 100}%`;
-          bar2.style.width = `${(segment.end - segment.start) / end * 100}%`;
+          bar2.style.left = `${segment.start / end3 * 100}%`;
+          bar2.style.width = `${(segment.end - segment.start) / end3 * 100}%`;
           bar2.style.background = segment.color;
           strip.appendChild(bar2);
         }
         for (const tick of ticks) {
           const mark = mk("u", "tr-tick");
-          mark.style.left = `${tick / end * 100}%`;
+          mark.style.left = `${tick / end3 * 100}%`;
           strip.appendChild(mark);
         }
         const head = mk("s", "tr-playhead");
         strip.appendChild(head);
-        playhead = { node: head, metric, end };
+        playhead = { node: head, metric, end: end3 };
         card.appendChild(strip);
       }
       if (sheet.note) card.appendChild(mk("p", "sub", sheet.note));
@@ -35901,6 +37911,8 @@ void main(){
       o.onFast(fast);
     });
     const tapBtn = ctl(t("ui.tap"), () => o.onTap());
+    const blastBtns = ["shelter", "fragmentHits", "confinement"].map((key) => ({ key, b: ctl(t(`ui.blast.${key}`), () => o.onBlast(key)) }));
+    for (const { key, b } of blastBtns) b.title = t(`ui.blast.${key}.hint`);
     const qSel = mk2("select");
     for (const q of ["low", "medium", "high"]) {
       const op = mk2("option", void 0, t(`ui.quality.${q}`));
@@ -36105,6 +38117,7 @@ void main(){
         }
         slotsEl.forEach((b, i) => b.classList.toggle("on", i === s.slot));
         tapBtn.classList.toggle("on", s.tap);
+        for (const { key: key2, b } of blastBtns) b.classList.toggle("on", s.blast[key2]);
         count.textContent = t("ui.objects", { n: s.objects });
         const ak = JSON.stringify(s.animations);
         if (ak !== lastAnim) {
@@ -36187,9 +38200,9 @@ void main(){
     gl.setSize(width(), height());
     const dom = gl.domElement;
     if (dom && !dom.hasAttribute?.("tabindex")) dom.setAttribute?.("tabindex", "0");
-    const scene = options.scene ?? new THREE.Scene();
+    const scene2 = options.scene ?? new THREE.Scene();
     const camera2 = options.camera ?? new THREE.PerspectiveCamera(72, width() / height(), 0.05, 140);
-    if (!options.camera) scene.add(camera2);
+    if (!options.camera) scene2.add(camera2);
     const resize = () => {
       const w = width();
       const h = height();
@@ -36200,8 +38213,8 @@ void main(){
     const onResize = () => resize();
     window.addEventListener("resize", onResize);
     const arenaSize = options.arenaSize ?? 14;
-    const arena = createArena(THREE, arenaSize, scene);
-    scene.add(arena.group);
+    const arena = createArena(THREE, arenaSize, scene2);
+    scene2.add(arena.group);
     const ownWorld = !options.world;
     const world = options.world ?? createDestruction({ seed: 1, ...options.worldOptions, materials: [...DEMO_MATERIALS, ...options.worldOptions?.materials ?? []] });
     const pristineWorld = ownWorld ? world.serialize() : null;
@@ -36229,15 +38242,22 @@ void main(){
     let simTime = 0;
     const log = createLog({ exportCancelled: () => t("log.export_cancelled") });
     log.setClock(() => simTime);
+    const ownAudio = options.audio === void 0;
+    const audio = options.audio === false ? null : options.audio ?? createAudioEngine();
+    const destructionSound = audio ? createDestructionSound(audio) : null;
+    const playSound = (key, point, volume) => {
+      destructionSound?.onSound(key, point, volume);
+      options.onSound?.(key, point, volume);
+    };
     const craterField = options.craters ? createGroundField() : void 0;
     const craterPatch = craterField ? createGroundPatch(THREE, { field: craterField, material: new THREE.MeshStandardMaterial({ color: 9342602, roughness: 0.95 }) }) : void 0;
     if (craterPatch) {
       const floor2 = arena.group.getObjectByName("floor");
       if (floor2) floor2.visible = false;
-      scene.add(craterPatch.mesh);
+      scene2.add(craterPatch.mesh);
     }
     const vfx = createVfxRenderer(THREE, {
-      scene,
+      scene: scene2,
       camera: camera2,
       overlay: container,
       quality,
@@ -36249,13 +38269,13 @@ void main(){
       })
     });
     const renderer = createDestructionRenderer(THREE, {
-      scene,
+      scene: scene2,
       world,
       vfx: vfx.world,
       quality,
       groundAt,
       pointScale,
-      onSound: options.onSound,
+      onSound: playSound,
       onPiece: (piece) => {
         rendererPieces.set(piece.objectId, piece);
         loose.push(piece);
@@ -36277,10 +38297,10 @@ void main(){
         if (best) splitOf.set(piece.objectId, best);
       }
     });
-    const fluidView = createFluidRenderer(THREE, { scene, fluids, quality, pointScale, vfx: vfx.world });
+    const fluidView = createFluidRenderer(THREE, { scene: scene2, fluids, quality, pointScale, vfx: vfx.world });
     const filmRandom = createFilmLcg(1);
     const film = createFilmManager(THREE, {
-      scene,
+      scene: scene2,
       camera: camera2,
       random: filmRandom,
       fluids,
@@ -36477,7 +38497,7 @@ void main(){
       for (const o of arena.objects) {
         const root = buildFromSpec(THREE, o.spec, { colors: o.colors });
         root.position.set(o.position[0], o.position[1], o.position[2]);
-        scene.add(root);
+        scene2.add(root);
         root.updateMatrixWorld(true);
         world.add(structuredCloneSpec(o.spec), { id: o.id, position: o.position });
         registerEntry(o.id, o.id, root, o.spec, S.text[`arena.${o.id}`] ?? o.id, void 0, void 0, true, false);
@@ -36504,7 +38524,7 @@ void main(){
       root.position.set(pos[0], pos[1], pos[2]);
       root.rotation.y = rotationY ?? player.yaw;
       root.name = item.id;
-      scene.add(root);
+      scene2.add(root);
       root.updateMatrixWorld(true);
       const objectId = `${item.id}_${++counter}`;
       let own;
@@ -36691,7 +38711,7 @@ void main(){
         g.setAttribute("position", new THREE.Float32BufferAttribute(6, 3));
         const line = new THREE.Line(g, tracerMat);
         line.frustumCulled = false;
-        scene.add(line);
+        scene2.add(line);
         tr = { line, life: 0 };
         tracers.push(tr);
       }
@@ -36807,15 +38827,15 @@ void main(){
           energy = Math.max(energy, s.energy);
           const results = world.shoot(s.origin, s.direction, s.energy, s.caliber, "player");
           const r0 = results.find((r) => r.part && r.point);
-          let end = [s.origin[0] + s.direction[0] * 40, s.origin[1] + s.direction[1] * 40, s.origin[2] + s.direction[2] * 40];
+          let end3 = [s.origin[0] + s.direction[0] * 40, s.origin[1] + s.direction[1] * 40, s.origin[2] + s.direction[2] * 40];
           if (r0?.point && r0.part) {
             hits++;
-            end = r0.point;
+            end3 = r0.point;
             if (!first) first = { object: r0.object, part: r0.part, point: r0.point, normal: [0, 1, 0], distance: dist3(s.origin, r0.point) };
             const speed = Math.max(80, s.speed);
             pushPiece(r0.object, s.direction, 2 * s.energy / speed, r0.point);
           }
-          if (shots.length <= 3 || rnd2() < 0.34) tracer(m, end);
+          if (shots.length <= 3 || rnd2() < 0.34) tracer(m, end3);
         }
       });
       player.kick(recoil[0], recoil[1]);
@@ -36979,9 +38999,15 @@ void main(){
       bodies.push({ id: "player", box: new THREE.Box3(new THREE.Vector3(x - PLAYER_RADIUS, feet, z - PLAYER_RADIUS), new THREE.Vector3(x + PLAYER_RADIUS, y + 0.1, z + PLAYER_RADIUS)) });
       return bodies;
     }
+    let blastOptions = { ...options.blast };
+    let lastBlast;
+    const blastOn = (key) => Boolean(blastOptions[key]);
+    const toggleBlast = (key) => {
+      blastOptions = { ...blastOptions, [key]: blastOn(key) ? false : true };
+    };
     const explosives = createExplosives({
       THREE,
-      scene,
+      scene: scene2,
       camera: camera2,
       world,
       renderer,
@@ -36993,6 +39019,10 @@ void main(){
       toolName,
       withoutHeld,
       groundAt,
+      blast: () => blastOptions,
+      blasted: (summary) => {
+        lastBlast = summary;
+      },
       translate: t,
       format: num,
       action,
@@ -37419,7 +39449,7 @@ void main(){
     let metricsAcc = 0;
     let ownsLoop = false;
     const roomMetricIds = options.metrics === false ? [] : options.metrics ?? ROOM_METRICS;
-    const roomMetrics = createRoomMetrics({ gl, destruction: renderer, fluids: fluidView, effects: vfx.world, ids: roomMetricIds });
+    const roomMetrics = createRoomMetrics({ gl, destruction: renderer, fluids: fluidView, effects: vfx.world, ids: roomMetricIds, blast: () => lastBlast });
     let qualityName = quality;
     const syncContainers = (sdt) => {
       for (const e of entries.values()) {
@@ -37478,6 +39508,10 @@ void main(){
         s.update(dt);
         flushEvents(id, s);
       }
+      if (audio) {
+        const look = camera2.getWorldDirection(listenerDirection);
+        audio.setListener({ position: [camera2.position.x, camera2.position.y, camera2.position.z], yaw: Math.atan2(-look.x, -look.z) });
+      }
       for (const update2 of frameListeners) update2(dt);
       for (const tr of tracers) {
         if (tr.life > 0) {
@@ -37534,6 +39568,7 @@ void main(){
         timeScale,
         fast: fastForward,
         tap: isTapOn(),
+        blast: { shelter: blastOn("shelter"), fragmentHits: blastOn("fragmentHits"), confinement: blastOn("confinement") },
         quality: qualityName,
         objects: [...entries.values()].filter((e) => !e.arena).length
       };
@@ -37587,7 +39622,7 @@ void main(){
           const ev = evs[pl.fired++];
           action("animation_event", t("act.anim_event", { name: pl.entry.name, clip: pl.clip.id, type: ev.type }), { objectId: pl.entry.so.objectId, itemId: pl.entry.so.itemId, data: { clip: pl.clip.id, type: ev.type, at: ev.t, ...ev.data ?? {} } });
           const key = ev.type === "sound" ? ev.data?.key : void 0;
-          if (typeof key === "string") options.onSound?.(key, v3(pl.entry.so.root.getWorldPosition(tmpV2)), 1);
+          if (typeof key === "string") playSound(key, v3(pl.entry.so.root.getWorldPosition(tmpV2)), 1);
         }
         if (pl.t >= pl.clip.duration) {
           playing.splice(i, 1);
@@ -37680,6 +39715,9 @@ void main(){
     };
     const hostListeners = /* @__PURE__ */ new Set();
     const frameListeners = /* @__PURE__ */ new Set();
+    const listenerDirection = new THREE.Vector3();
+    const environment = options.environment ?? createEnvironmentBus();
+    const audioSink = audio ? createAudioSink(audio) : void 0;
     function emitHost(event) {
       for (const listener of hostListeners) listener(event);
     }
@@ -37726,9 +39764,11 @@ void main(){
     }
     const host = {
       THREE,
-      scene,
+      scene: scene2,
       camera: camera2,
       locale,
+      ...audioSink ? { audio: audioSink } : {},
+      environment,
       groundAt,
       effects: vfx,
       tool: () => ({
@@ -37977,11 +40017,13 @@ void main(){
     const room = {
       world,
       renderer,
-      scene,
+      scene: scene2,
       camera: camera2,
       arsenal,
       fluids,
       fluidRenderer: fluidView,
+      audio,
+      environment,
       log,
       get tool() {
         return tool;
@@ -38042,6 +40084,10 @@ void main(){
         heldTilt = rad;
       },
       toggleTap,
+      blast: () => ({ ...blastOptions }),
+      setBlast: (next) => {
+        blastOptions = { ...blastOptions, ...next };
+      },
       pause() {
         paused = true;
       },
@@ -38075,6 +40121,8 @@ void main(){
         return { room: roomMetrics.sample(), module: moduleMetrics() };
       },
       dispose() {
+        destructionSound?.dispose();
+        if (ownAudio) audio?.dispose();
         for (const detach of detachers.values()) detach();
         detachers.clear();
         for (const store of benches.values()) store.dispose();
@@ -38150,6 +40198,7 @@ void main(){
           setTool(loadout[index]);
         },
         onTap: () => toggleTap(),
+        onBlast: (key) => toggleBlast(key),
         onPlay: (objectId, clipId) => {
           playAnimation(clipId, objectId);
         },
@@ -38179,7 +40228,7 @@ void main(){
         last = now;
         if (!scenarioRunning) update(dt);
         const restoreCamera = vfx.applyCamera();
-        gl.render(scene, camera2);
+        gl.render(scene2, camera2);
         restoreCamera();
         roomMetrics.rendered();
       };