@adatechnology/game-weapons-three 0.5.0 → 0.6.0

package/dist/index.global.js

@@ -12937,10 +12937,10 @@ var GameWeaponsThree = (() => {
       __publicField(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) {
@@ -12949,7 +12949,7 @@ var GameWeaponsThree = (() => {
       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");
@@ -12959,10 +12959,10 @@ var GameWeaponsThree = (() => {
         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 });
@@ -13078,7 +13078,7 @@ var GameWeaponsThree = (() => {
         this.pend = { src: "trigger", amt: d };
       }
       const start = this.clock - overlap;
-      const end = start + d;
+      const end3 = start + d;
       this.settle(start);
       const dir = normalize(direction);
       let res;
@@ -13089,10 +13089,10 @@ var GameWeaponsThree = (() => {
       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":
@@ -13102,7 +13102,7 @@ var GameWeaponsThree = (() => {
           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);
@@ -13114,7 +13114,7 @@ var GameWeaponsThree = (() => {
           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;
     }
@@ -13146,9 +13146,9 @@ var GameWeaponsThree = (() => {
       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 });
@@ -13182,8 +13182,8 @@ var GameWeaponsThree = (() => {
       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);
@@ -13193,7 +13193,7 @@ var GameWeaponsThree = (() => {
       }
       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) {
@@ -13621,14 +13621,1434 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   };
   var accessoryTextOf = (locale) => ACCESSORY_TEXT[locale] ?? ACCESSORY_TEXT.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, distance2) {
+    if (!falloff || falloff.model === "none") return volume;
+    if (falloff.model === "linear") {
+      const level2 = Math.max(0, 1 - distance2 / falloff.range) * volume;
+      return falloff.scale === void 0 ? level2 : level2 * falloff.scale;
+    }
+    const level = volume / (1 + distance2 * distance2 * 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, distance2) {
+    if (!falloff || falloff.model !== "inverse_square" || falloff.cutoffK === void 0) return 1;
+    return 1 + distance2 * 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 distance2 = Math.hypot(dx, dz) || 1;
+    const pan = (dx * rightX + dz * rightZ) / Math.max(distance2, 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(range) {
+    return typeof range === "object" && !Array.isArray(range);
+  }
+  function draw(range, scope2) {
+    if (typeof range === "number") return range;
+    if (isParamRef(range)) {
+      const value = scope2.params[range.param];
+      if (value === void 0) throw new Error(`game-audio: the recipe reads the param "${range.param}", which was not given`);
+      return value * (range.scale ?? 1) + (range.add ?? 0);
+    }
+    const [min, max] = range;
+    return min + scope2.random() * (max - min);
+  }
+  function drawTime(time, scope2) {
+    if (time === "duration" || typeof time === "string" && time.endsWith("d")) return time;
+    return draw(time, scope2);
+  }
+  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, scope2) {
+    const pending = {};
+    for (const key of Object.keys(automation)) {
+      if (key === "set" && "set" in automation) pending.value = draw(automation.set, scope2);
+      else if (key === "from" && "from" in automation) pending.from = draw(automation.from, scope2);
+      else if (key === "to" && automation.to !== void 0) pending.to = automation.to === "from" ? pending.from ?? pending.value ?? 0 : draw(automation.to, scope2);
+      else if (key === "curve") pending.curve = automation.curve;
+      else if (key === "over" && automation.over !== void 0) pending.over = drawTime(automation.over, scope2);
+    }
+    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, scope2) {
+    const pending = { spec, frequency: {} };
+    for (const key of Object.keys(spec)) {
+      if (key === "frequency") pending.frequency = drawAutomation(spec.frequency, scope2);
+      else if (key === "q" && spec.q !== void 0) pending.q = draw(spec.q, scope2);
+      else if (key === "gain" && spec.gain !== void 0) pending.gain = draw(spec.gain, scope2);
+      else if (key === "level" && spec.level !== void 0) pending.level = draw(spec.level, scope2);
+    }
+    return pending;
+  }
+  function drawModulator(modulator, scope2) {
+    const pending = { modulator, rate: 0 };
+    for (const key of Object.keys(modulator)) {
+      if (key === "rate") pending.rate = draw(modulator.rate, scope2);
+      else if (key === "depth" && !(typeof modulator.depth === "object" && "scaleOf" in modulator.depth)) pending.depth = draw(modulator.depth, scope2);
+    }
+    return pending;
+  }
+  function drawVoice(source, scope2) {
+    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, scope2);
+      else if (key === "vibrato") pending.vibratoRate = draw(source.vibrato.rate, scope2);
+      else if (key === "formants") pending.formants = source.formants.map((formant) => ({ frequency: draw(formant.frequency, scope2), q: formant.q }));
+      else if (key === "breath") pending.breath = { frequency: draw(source.breath.frequency, scope2), q: source.breath.q, gain: draw(source.breath.gain, scope2) };
+    }
+    return pending;
+  }
+  function drawLayer(layer, scope2) {
+    const pending = { at: 0, gain: 1, filters: [], modulators: [] };
+    for (const key of Object.keys(layer)) {
+      if (key === "at" && layer.at !== void 0) pending.at = draw(layer.at, scope2);
+      else if (key === "duration" && layer.duration !== void 0) pending.duration = draw(layer.duration, scope2);
+      else if (key === "gain" && layer.gain !== void 0) pending.gain = draw(layer.gain, scope2);
+      else if (key === "source" && layer.source.kind === "osc") pending.automation = drawAutomation(layer.source.frequency, scope2);
+      else if (key === "source" && layer.source.kind === "formant_voice") pending.voice = drawVoice(layer.source, scope2);
+      else if (key === "filters" && layer.filters) pending.filters = layer.filters.bank.map((spec) => drawFilter(spec, scope2));
+      else if (key === "modulators" && layer.modulators) pending.modulators = layer.modulators.map((modulator) => drawModulator(modulator, scope2));
+    }
+    return pending;
+  }
+  function drawOffset(source, duration, scope2, noiseSeconds) {
+    if (source.kind === "formant_voice") return scope2.random();
+    if (source.kind !== "noise" || source.offset === void 0) return 0;
+    if (typeof source.offset === "number") return source.offset;
+    if (source.offset === "fit") return scope2.random() * Math.max(0, noiseSeconds - duration);
+    return scope2.random() * (source.offsetScale ?? 1);
+  }
+  function finishSource(layer, pending, duration, offset) {
+    const source = layer.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(envelope, duration, level) {
+    return envelope.map(([time, value, curve, fixed2]) => ({ time: timeOf(time, duration), value: fixed2 === "fixed" ? value : value * level, curve }));
+  }
+  function planLayer(layer, scope2, defaults, levelInEnvelope, soundLevel) {
+    const pending = drawLayer(layer, scope2);
+    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(layer.source, duration, scope2, defaults.noiseSeconds);
+    const level = pending.gain * soundLevel;
+    const sourceFrequency = layer.source.kind === "noise" ? 0 : startFrequency(pending.automation ?? pending.voice?.frequency ?? {});
+    const planned = {
+      at: pending.at,
+      duration,
+      tail: layer.tail ?? defaults.tail ?? DEFAULT_TAIL,
+      level,
+      ...layer.wet === void 0 ? {} : { wet: layer.wet },
+      source: finishSource(layer, pending, duration, offset),
+      ...layer.filters ? {
+        filters: {
+          mode: layer.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(layer.envelope, duration, levelInEnvelope ? level : 1)
+    };
+    if (!layer.repeat) return [planned];
+    return Array.from({ length: layer.repeat.count }, (_, index) => ({ ...planned, at: planned.at + index * (layer.repeat?.spacing ?? 0) }));
+  }
+  function scaleAutomation(automation, divisor) {
+    const scale = (value) => value === void 0 ? void 0 : value / divisor;
+    const scaled = { ...automation };
+    for (const key of ["value", "from", "to"]) if (automation[key] !== void 0) scaled[key] = scale(automation[key]);
+    return scaled;
+  }
+  function muffle(layer, divisor) {
+    if (divisor === 1 || !layer.filters) return layer;
+    const bank = layer.filters.bank.map((filter) => filter.type === "lowpass" ? { ...filter, frequency: scaleAutomation(filter.frequency, divisor) } : filter);
+    return { ...layer, filters: { ...layer.filters, bank } };
+  }
+  var layerEnd = (layer) => layer.at + layer.duration + layer.tail;
+  function planSound(recipe, input = {}) {
+    const listener = input.listener ?? DEFAULT_LISTENER;
+    const distance2 = 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, distance2);
+    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: distance2,
+      ...recipe.pan ? { pan: input.position ? panFor(listener, input.position) : 0 } : {}
+    };
+    if (silent) return recipe.keepSilent ? { ...base, silent: true, length: 0, layers: [] } : null;
+    const scope2 = { random: input.random ?? createRng2(1), params: { ...input.params } };
+    for (const [name, range] of Object.entries(recipe.vars ?? {})) if (scope2.params[name] === void 0) scope2.params[name] = draw(range, scope2);
+    const defaults = {
+      ...recipe.duration === void 0 ? {} : { duration: draw(recipe.duration, scope2) },
+      ...recipe.tail === void 0 ? {} : { tail: recipe.tail },
+      noiseSeconds: input.noiseSeconds ?? DEFAULT_NOISE_SECONDS
+    };
+    const divisor = cutoffDivisor(recipe.falloff, distance2) / (1 - OCCLUSION_CUTOFF * occlusion);
+    const layers = recipe.layers.flatMap((layer) => planLayer(layer, scope2, defaults, order !== "layered", level)).map((layer) => muffle(layer, 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(mix2, profiles = MIX_PROFILES) {
+    if (typeof mix2 !== "string") return mix2;
+    const profile = profiles[mix2];
+    if (!profile) throw new Error(`game-audio: unknown mix profile "${mix2}" (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 sound2 of bank.sounds ?? []) {
+          sounds.set(sound2.id, sound2);
+          owners.set(sound2.id, bank.id);
+        }
+        for (const loop of bank.loops ?? []) {
+          loops.set(loop.id, loop);
+          owners.set(loop.id, bank.id);
+        }
+      },
+      patch(id, patch) {
+        const sound2 = sounds.get(id);
+        if (sound2) sounds.set(id, mergeRecords(sound2, 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, length2) {
+    const samples = new Float32Array(length2);
+    for (let index = 0; index < length2; 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 length2 = context.sampleRate * profile.reverb.seconds;
+    convolver.buffer = bufferOf(context, fillImpulse(random, { channels: 2, length: length2, decay: profile.reverb.decay }), length2);
+    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 scope2 = globalThis;
+    const Constructor = scope2.AudioContext ?? scope2.webkitAudioContext;
+    return Constructor ? new Constructor() : null;
+  }
+  function unlockContext(context) {
+    if (context.state === "suspended") void context.resume();
+  }
+  function assign(param, automation, time) {
+    if (automation.value !== void 0) param.value = automation.value;
+    if (automation.from !== void 0) param.setValueAtTime(automation.from, time);
+  }
+  function ramp(param, curve, value, at) {
+    if (curve === "set") param.setValueAtTime(value, at);
+    else if (curve === "exp") param.exponentialRampToValueAtTime(value, at);
+    else param.linearRampToValueAtTime(value, at);
+  }
+  function rampTo(param, automation, time) {
+    if (automation.to !== void 0 && automation.at !== void 0) ramp(param, automation.curve ?? "linear", automation.to, time + automation.at);
+  }
+  function applyEnvelope(param, points, time) {
+    for (const point of points) ramp(param, 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 = (range) => typeof range === "number" ? range : 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 stage2 = context.createGain();
+      if (modulator.wave) lfo.type = modulator.wave;
+      lfo.frequency.value = fixed(modulator.rate);
+      depth.gain.value = fixed(modulator.depth);
+      stage2.gain.value = modulator.base ?? 0;
+      lfo.connect(depth);
+      depth.connect(stage2.gain);
+      last?.disconnect();
+      last?.connect(stage2);
+      stage2.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 = (layer, start) => start + layer.duration + layer.tail;
+  var firstFilter = (layer) => layer.filters?.bank[0];
+  var offsetOf = (layer) => layer.source.kind === "noise" ? layer.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 layer = plan.layers[0];
+    const time = target.time + layer.at;
+    const gain = context.createGain();
+    gain.connect(target.output);
+    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+    const filter = context.createBiquadFilter();
+    source.connect(filter);
+    filter.connect(gain);
+    setFilter(filter, firstFilter(layer), time);
+    applyEnvelope(gain.gain, layer.envelope, time);
+    source.start(time, offsetOf(layer));
+    source.stop(end(layer, time));
+    return voiceOf([source]);
+  }
+  function realizeScream(plan, target) {
+    const { context } = target;
+    const layer = plan.layers[0];
+    const time = target.time + layer.at;
+    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+    const gain = context.createGain();
+    gain.connect(target.output);
+    for (const band of layer.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 = layer.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, layer.envelope, time);
+    source.start(time, offsetOf(layer));
+    source.stop(end(layer, time));
+    for (const lfo of lfos) {
+      lfo.start(time);
+      lfo.stop(end(layer, time));
+      sources.push(lfo);
+    }
+    return voiceOf(sources);
+  }
+  function realizeGroan(plan, target) {
+    const { context } = target;
+    const layer = plan.layers[0];
+    const time = target.time + layer.at;
+    const oscillator = context.createOscillator();
+    const gain = context.createGain();
+    const filter = context.createBiquadFilter();
+    const band = firstFilter(layer);
+    if (layer.source.kind === "osc") oscillator.type = layer.source.wave;
+    if (band) {
+      filter.type = band.type;
+      if (band.q !== void 0) filter.Q.value = band.q;
+    }
+    if (layer.source.kind === "osc") {
+      assign(oscillator.frequency, layer.source.frequency, time);
+      rampTo(oscillator.frequency, layer.source.frequency, time);
+    }
+    if (band) assign(filter.frequency, band.frequency, time);
+    applyEnvelope(gain.gain, layer.envelope, time);
+    oscillator.connect(filter);
+    filter.connect(gain);
+    gain.connect(target.output);
+    oscillator.start(time);
+    oscillator.stop(end(layer, time));
+    return voiceOf([oscillator]);
+  }
+  function realizeBoom(plan, target) {
+    const { context } = target;
+    const layer = plan.layers[0];
+    const time = target.time + layer.at;
+    const oscillator = context.createOscillator();
+    const gain = context.createGain();
+    if (layer.source.kind === "osc") {
+      oscillator.type = layer.source.wave;
+      assign(oscillator.frequency, layer.source.frequency, time);
+      rampTo(oscillator.frequency, layer.source.frequency, time);
+    }
+    applyEnvelope(gain.gain, layer.envelope, time);
+    oscillator.connect(gain);
+    gain.connect(target.output);
+    oscillator.start(time);
+    oscillator.stop(end(layer, time));
+    return voiceOf([oscillator]);
+  }
+  function realizeStatic(plan, target) {
+    const { context } = target;
+    const layer = plan.layers[0];
+    const time = target.time + layer.at;
+    const gain = context.createGain();
+    const source = context.createBufferSource();
+    const filter = context.createBiquadFilter();
+    source.buffer = target.noise();
+    setFilter(filter, firstFilter(layer), time);
+    applyEnvelope(gain.gain, layer.envelope, time);
+    source.connect(filter);
+    filter.connect(gain);
+    gain.connect(target.output);
+    source.start(time, offsetOf(layer));
+    source.stop(end(layer, 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((layer, index) => {
+      if (layer.source.kind === "osc") assign(oscillators[index].frequency, layer.source.frequency, target.time + layer.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((layer, index) => oscillators[index].start(target.time + layer.at));
+    layers.forEach((layer, index) => oscillators[index].stop(end(layer, target.time + layer.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((layer) => {
+      const time = target.time + layer.at;
+      const oscillator = context.createOscillator();
+      if (layer.source.kind === "osc") {
+        oscillator.type = layer.source.wave;
+        assign(oscillator.frequency, layer.source.frequency, time);
+        rampTo(oscillator.frequency, layer.source.frequency, time);
+      }
+      if (band) {
+        assign(filter.frequency, band.frequency, time);
+        if (band.q !== void 0) filter.Q.value = band.q;
+      }
+      const envelope = context.createGain();
+      applyEnvelope(envelope.gain, layer.envelope, time);
+      oscillator.connect(envelope);
+      envelope.connect(filter);
+      oscillator.start(time);
+      oscillator.stop(end(layer, time));
+      return oscillator;
+    });
+    return voiceOf(oscillators);
+  }
+  var end2 = (layer, start) => start + layer.duration + layer.tail;
+  function outputStage(plan, layer, target) {
+    const { context } = target;
+    const level = gainNode(context, layer.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 (layer.wet && target.wet) {
+      const send = gainNode(context, layer.wet);
+      node.connect(send);
+      send.connect(target.wet);
+    }
+    return level;
+  }
+  function realizeNoiseLayer(plan, layer, target) {
+    const { context } = target;
+    const time = target.time + layer.at;
+    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+    const filters = (layer.filters?.bank ?? []).map((filter) => {
+      const node = filterNode(context, filter, time);
+      rampTo(node.frequency, filter.frequency, time);
+      return node;
+    });
+    const envelope = context.createGain();
+    applyEnvelope(envelope.gain, layer.envelope, time);
+    let tail = source;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(envelope);
+    envelope.connect(outputStage(plan, layer, target));
+    source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
+    source.stop(end2(layer, time));
+    return [source];
+  }
+  function realizeToneLayer(plan, layer, target) {
+    const { context } = target;
+    const time = target.time + layer.at;
+    const oscillator = context.createOscillator();
+    if (layer.source.kind === "osc") {
+      oscillator.type = layer.source.wave;
+      assign(oscillator.frequency, layer.source.frequency, time);
+      rampTo(oscillator.frequency, layer.source.frequency, time);
+    }
+    const envelope = context.createGain();
+    applyEnvelope(envelope.gain, layer.envelope, time);
+    oscillator.connect(envelope);
+    envelope.connect(outputStage(plan, layer, target));
+    oscillator.start(time);
+    oscillator.stop(end2(layer, time));
+    return [oscillator];
+  }
+  function realizeVoiceLayer(plan, layer, target) {
+    const source = layer.source;
+    if (source.kind !== "formant_voice") return [];
+    const { context } = target;
+    const time = target.time + layer.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 mix2 = 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(mix2);
+    breathLevel.connect(mix2);
+    const envelope = context.createGain();
+    applyEnvelope(envelope.gain, layer.envelope, time);
+    mix2.connect(envelope);
+    envelope.connect(outputStage(plan, layer, target));
+    const stop = end2(layer, 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((layer) => {
+      if (layer.source.kind === "noise") return realizeNoiseLayer(plan, layer, target);
+      if (layer.source.kind === "osc") return realizeToneLayer(plan, layer, target);
+      return realizeVoiceLayer(plan, layer, target);
+    });
+    return voiceOf(sources);
+  }
+  function realizeSiren(plan, target) {
+    const { context } = target;
+    const layer = plan.layers[0];
+    const time = target.time + layer.at;
+    const oscillator = context.createOscillator();
+    if (layer.source.kind === "osc") {
+      oscillator.type = layer.source.wave;
+      assign(oscillator.frequency, layer.source.frequency, time);
+      rampTo(oscillator.frequency, layer.source.frequency, time);
+    }
+    const depths = layer.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 envelope = context.createGain();
+    applyEnvelope(envelope.gain, layer.envelope, time);
+    for (const { depth, target: modulated } of depths) if (modulated === "gain") depth.connect(envelope.gain);
+    const filters = (layer.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    let tail = oscillator;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(envelope);
+    envelope.connect(target.output);
+    if (layer.wet && target.wet) {
+      const send = gainNode(context, layer.wet);
+      envelope.connect(send);
+      send.connect(target.wet);
+    }
+    const stop = end2(layer, 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(layer, target, time) {
+    const { context } = target;
+    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+    const filters = (layer.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    const envelope = context.createGain();
+    applyEnvelope(envelope.gain, layer.envelope, time);
+    let tail = source;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(envelope).connect(target.output);
+    source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
+    source.stop(time + layer.duration + layer.tail);
+    return source;
+  }
+  function toneLayer(layer, target, time) {
+    const { context } = target;
+    const oscillator = context.createOscillator();
+    if (layer.source.kind === "osc") {
+      oscillator.type = layer.source.wave;
+      assign(oscillator.frequency, layer.source.frequency, time);
+      rampTo(oscillator.frequency, layer.source.frequency, time);
+    }
+    const envelope = context.createGain();
+    applyEnvelope(envelope.gain, layer.envelope, time);
+    oscillator.connect(envelope).connect(target.output);
+    oscillator.start(time);
+    oscillator.stop(time + layer.duration + layer.tail);
+    return oscillator;
+  }
+  function realizeWeapon(plan, target) {
+    const sources = plan.layers.map((layer) => {
+      const time = target.time + layer.at;
+      return layer.source.kind === "noise" ? noiseLayer(layer, target, time) : toneLayer(layer, 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((layer) => layer.source.kind !== "osc");
+  var planUsesNoise = (plan) => plan.layers.some((layer) => layer.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 mix2 = 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, mix2, engineRandom);
+      if (mix2.noise.create === "eager") noiseBuffer(shared, created, mix2.noise.seconds);
+      for (const [bus, setting] of Object.entries(mix2.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: mix2.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, mix2.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, distance2) => {
+      const decision = voices.request({ ...recipe.group ? { group: recipe.group } : {}, priority: recipe.priority ?? busPriority(recipe.bus), gain, distance: distance2, 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 distance2 = playOptions.distance ?? (playOptions.position ? listenerDistance(listener, playOptions.position, options.distance) : 0);
+      const level = falloffGain(recipe.falloff, playOptions.volume ?? 1, distance2);
+      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, distance2);
+      if (voiceId === null) return null;
+      if (!silent && usesNoise(recipe)) prepareNoise(store, audio, mix2.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, mix2.noise.seconds),
+      noise: () => noiseBuffer(shared, context, mix2.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, mix2.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 = mix2;
+        mix2 = resolveMix(next, options.profiles);
+        if (!context || !chain) return;
+        const old = chain;
+        chain = buildChain(context, mix2, engineRandom);
+        if (mix2.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) {
+        mix2 = { ...mix2, 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();
+      }
+    };
+  }
+  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"]
+      }
+    ]
+  };
+
   // src/audio/mechanical-sounds.ts
   var metal = (at, frequency, gain) => ({ layer: "metal", at, frequency, gain });
   var sound = (at, soundClass, volume) => ({ layer: "class", at, soundClass, volume });
   var thud = (at, gain, frequency) => ({ layer: "thud", at, gain, frequency });
+  var sceneClick = (at, f, vol) => [
+    { layer: "scene_tone", at, wave: "square", f, f2: f * 0.7, d: 0.02, vol },
+    { layer: "scene_noise", at, type: "highpass", f: 3e3, q: 0.7, d: 0.03, vol: vol * 0.8 }
+  ];
+  var sceneNoise = (at, type, f, q, d, vol) => ({ layer: "scene_noise", at, type, f, q, d, vol });
+  var sceneEmpty = sceneClick(0, 3200, 0.35);
+  var sceneMagOut = [...sceneClick(0, 1600, 0.4), sceneNoise(0.03, "bandpass", 900, 2, 0.08, 0.3)];
+  var sceneMagIn = [...sceneClick(0, 1100, 0.5), { layer: "scene_tone", at: 0, wave: "sine", f: 320, f2: 200, d: 0.05, vol: 0.35 }];
+  var sceneBolt = [...sceneClick(0, 2200, 0.4), ...sceneClick(0.12, 2700, 0.4)];
+  var sceneShell = [...sceneClick(0, 1400, 0.35), sceneNoise(0.02, "bandpass", 1200, 3, 0.05, 0.25)];
   var slide = [metal(0, 900, 0.35), metal(0.14, 1300, 0.35)];
   var seat = [metal(0, 1100, 0.45), sound(0, "reload", 0.8)];
   var MECHANICAL_SOUNDS = {
-    dry_fire: [sound(0, "empty", 1), metal(0, 2600, 0.25)],
+    dry_fire: [sound(0, "empty", 1), ...sceneEmpty],
     misfire: [sound(0, "empty", 0.8), metal(0, 2200, 0.2)],
     feed: [metal(0, 1900, 0.2)],
     cycle: [metal(0.22, 900, 0.35), metal(0.36, 1300, 0.35)],
@@ -13641,11 +15061,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     stock_fold: [metal(0, 800, 0.3), metal(0.18, 1200, 0.3), thud(0.3, 0.2, 600)],
     light_click: [metal(0, 2400, 0.2), metal(0.03, 1800, 0.12)],
     attach: [metal(0, 1400, 0.35), thud(0.04, 0.2, 700), metal(0.12, 1900, 0.25)],
-    magazine_out: [metal(0, 1500, 0.35), sound(0, "reload", 0.6)],
-    magazine_in: seat,
-    charge: slide,
+    magazine_out: [...sceneMagOut, sound(0, "reload", 0.6)],
+    magazine_in: [...sceneMagIn, sound(0, "reload", 0.8)],
+    charge: sceneBolt,
     bolt_open: [metal(0, 900, 0.35)],
-    round_in: [metal(0, 2e3, 0.2), sound(0, "reload", 0.6)],
+    round_in: [...sceneShell, sound(0, "reload", 0.6)],
     bolt_close: [metal(0, 1300, 0.35)],
     pump_cycle: slide,
     lever_cycle: [metal(0, 1e3, 0.35), metal(0.12, 1500, 0.35)],
@@ -13785,100 +15205,185 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     };
   };
 
+  // src/audio/recipes.ts
+  var CLASS_BURST_ID = "weapon_class_burst";
+  var BURST_IDS = { lowpass: "weapon_burst_lowpass", highpass: "weapon_burst_highpass" };
+  var SCENE_NOISE_IDS = { lowpass: "scene_noise_lowpass", highpass: "scene_noise_highpass", bandpass: "scene_noise_bandpass" };
+  var SCENE_TONE_IDS = { sine: "scene_tone_sine", square: "scene_tone_square" };
+  var TONE_IDS = { sine: "weapon_tone_sine", sine_sweep: "weapon_tone_sine_sweep", square: "weapon_tone_square" };
+  var SOURCE_CLASS_BURST = "jogo:L62097-62110 sfx: lowpass noise, gain set at once, exponential fall to 0.001, stopped 0.05 s later";
+  var SOURCE_SDK = "sdk: the weapon synth of weapons-three (burst and tone), moved onto game-audio with the same nodes";
+  var FIT = { kind: "noise", offset: "fit" };
+  function classBurstId(curve) {
+    const same = curve.gainFalloff === GAME_DISTANCE_CURVE.gainFalloff && curve.cutoffFalloff === GAME_DISTANCE_CURVE.cutoffFalloff && curve.minGain === GAME_DISTANCE_CURVE.minGain;
+    return same ? CLASS_BURST_ID : `${CLASS_BURST_ID}@${curve.gainFalloff},${curve.cutoffFalloff},${curve.minGain}`;
+  }
+  function classBurstRecipe(curve) {
+    return {
+      id: classBurstId(curve),
+      bus: "weapons",
+      order: "weapon",
+      duration: { param: "seconds" },
+      layers: [
+        {
+          gain: { param: "gain" },
+          source: FIT,
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: { param: "cutoff" } } }] },
+          envelope: [
+            [0, 1, "set"],
+            ["1d", 1e-3, "exp", "fixed"]
+          ]
+        }
+      ],
+      falloff: { model: "inverse_square", k: curve.gainFalloff, cutoffK: curve.cutoffFalloff, minGain: curve.minGain },
+      sources: [SOURCE_CLASS_BURST]
+    };
+  }
+  var burstLayer = (type) => ({
+    gain: { param: "gain" },
+    source: FIT,
+    filters: { mode: "serial", bank: [{ type, frequency: { set: { param: "frequency" } }, q: { param: "q" } }] },
+    envelope: [
+      [0, 1e-4, "set", "fixed"],
+      [4e-3, 1, "exp"],
+      ["1d", 1e-4, "exp", "fixed"]
+    ]
+  });
+  var burstRecipe = (type) => ({
+    id: BURST_IDS[type],
+    bus: "weapons",
+    order: "weapon",
+    duration: { param: "seconds" },
+    layers: [burstLayer(type)],
+    falloff: { model: "none" },
+    sources: [SOURCE_SDK]
+  });
+  var toneLayer2 = (wave, sweep) => ({
+    gain: { param: "gain" },
+    source: { kind: "osc", wave, frequency: sweep ? { from: { param: "frequency" }, to: { param: "to" }, curve: "exp", over: "duration" } : { from: { param: "frequency" } } },
+    envelope: [
+      [0, 1e-4, "set", "fixed"],
+      [3e-3, 1, "exp"],
+      ["1d", 1e-4, "exp", "fixed"]
+    ]
+  });
+  var toneRecipe = (id, wave, sweep) => ({
+    id,
+    bus: "weapons",
+    order: "weapon",
+    duration: { param: "seconds" },
+    layers: [toneLayer2(wave, sweep)],
+    falloff: { model: "none" },
+    sources: [SOURCE_SDK]
+  });
+  var SOURCE_SCENE = "cena:L1323-L1324 sNoise and sTone, played at the listener (distance 0), through the art scene output stage";
+  var SCENE_ATTACK = 2e-3;
+  var sceneNoiseRecipe = (type, slide2) => ({
+    id: slide2 ? `${SCENE_NOISE_IDS[type]}_slide` : SCENE_NOISE_IDS[type],
+    bus: "weapons",
+    order: "layered",
+    duration: { param: "d", add: SCENE_ATTACK },
+    pan: true,
+    layers: [
+      {
+        gain: { param: "vol" },
+        source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+        filters: { mode: "serial", bank: [{ type, frequency: slide2 ? { set: { param: "f" }, to: { param: "f2" }, curve: "exp", over: { param: "d" } } : { set: { param: "f" } }, q: { param: "q" } }] },
+        envelope: [
+          [0, 1e-4, "set", "fixed"],
+          [SCENE_ATTACK, 1, "exp"],
+          ["1d", 1e-4, "exp", "fixed"]
+        ]
+      }
+    ],
+    falloff: DISTANCE_CURVES.art_scene,
+    sources: [SOURCE_SCENE]
+  });
+  var sceneToneRecipe = (wave) => ({
+    id: SCENE_TONE_IDS[wave],
+    bus: "weapons",
+    order: "layered",
+    duration: { param: "d", add: SCENE_ATTACK },
+    pan: true,
+    layers: [
+      {
+        gain: { param: "vol" },
+        source: { kind: "osc", wave, frequency: { from: { param: "f" }, to: { param: "f2" }, curve: "exp", over: "duration" } },
+        envelope: [
+          [0, 1e-4, "set", "fixed"],
+          [SCENE_ATTACK, 1, "exp"],
+          ["1d", 1e-4, "exp", "fixed"]
+        ]
+      }
+    ],
+    falloff: DISTANCE_CURVES.art_scene,
+    sources: [SOURCE_SCENE]
+  });
+  function weaponRecipes(curve) {
+    return [
+      classBurstRecipe(curve),
+      burstRecipe("lowpass"),
+      burstRecipe("highpass"),
+      toneRecipe(TONE_IDS.sine, "sine", false),
+      toneRecipe(TONE_IDS.sine_sweep, "sine", true),
+      toneRecipe(TONE_IDS.square, "square", false),
+      ...["lowpass", "highpass", "bandpass"].flatMap((type) => [sceneNoiseRecipe(type, false), sceneNoiseRecipe(type, true)]),
+      sceneToneRecipe("sine"),
+      sceneToneRecipe("square")
+    ];
+  }
+
   // src/audio.ts
   var NOISE_SECONDS = 1.5;
-  var globalContext = () => {
-    const scope2 = globalThis;
-    const Ctor = scope2.AudioContext ?? scope2.webkitAudioContext;
-    return Ctor ? new Ctor() : null;
-  };
+  var DEFAULT_SEED = 1;
   function createWeaponAudio(volume = 0.6, options = {}) {
-    const makeContext = options.createContext ?? globalContext;
-    const rng = createRng(options.seed ?? 1);
+    const seed = options.seed ?? DEFAULT_SEED;
     const classes = { ...GAME_SOUND_CLASSES, ...options.classes };
     const distanceCurve = { ...GAME_DISTANCE_CURVE, ...options.distance };
     const mechanicalTable = { ...MECHANICAL_SOUNDS, ...options.mechanical };
-    let ctx = null;
-    let master = null;
-    let noise = null;
-    let level = volume;
-    const ready = () => {
-      if (!ctx) {
-        const created = makeContext();
-        if (!created) return null;
-        ctx = created;
-        master = ctx.createGain();
-        master.gain.value = level;
-        master.connect(ctx.destination);
-        noise = ctx.createBuffer(1, Math.floor(ctx.sampleRate * NOISE_SECONDS), ctx.sampleRate);
-        const data = noise.getChannelData(0);
-        for (let i = 0; i < data.length; i++) data[i] = rng() * 2 - 1;
-      }
-      if (ctx.state === "suspended") void ctx.resume();
-      return ctx;
-    };
+    const shared = options.engine;
+    const engine = shared ?? createAudioEngine({
+      seed,
+      mix: { ...MIX_PROFILES.game, master: volume, noise: { seconds: NOISE_SECONDS, create: "eager" } },
+      maxVoices: Number.POSITIVE_INFINITY,
+      ...options.createContext ? { createContext: options.createContext } : {}
+    });
+    const channel = shared && options.seed !== void 0 ? shared.channel({ seed }) : engine.channel({});
+    engine.register({ id: `weapons_three@${classBurstId(distanceCurve)}`, sounds: weaponRecipes(distanceCurve) });
+    const classBurst = classBurstId(distanceCurve);
     const burst = (config) => {
-      const audio = ready();
-      if (!audio || !noise || !master) return;
-      const start = audio.currentTime + (config.at ?? 0);
-      const source = audio.createBufferSource();
-      source.buffer = noise;
-      const filter = audio.createBiquadFilter();
-      filter.type = config.filter;
-      filter.frequency.value = config.frequency;
-      filter.Q.value = config.q ?? 0.8;
-      const gain = audio.createGain();
-      gain.gain.setValueAtTime(1e-4, start);
-      gain.gain.exponentialRampToValueAtTime(Math.max(config.gain, 2e-4), start + 4e-3);
-      gain.gain.exponentialRampToValueAtTime(1e-4, start + config.seconds);
-      source.connect(filter).connect(gain).connect(master);
-      source.start(start, rng() * Math.max(0, NOISE_SECONDS - config.seconds));
-      source.stop(start + config.seconds + 0.05);
+      const id = config.filter === "highpass" ? BURST_IDS.highpass : BURST_IDS.lowpass;
+      const params = { frequency: config.frequency, q: config.q ?? 0.8, gain: Math.max(config.gain, 2e-4), seconds: config.seconds };
+      channel.play(id, { params, ...config.at ? { delay: config.at } : {} });
     };
-    const classBurst = (at, cutoff, gain, seconds) => {
-      const audio = ready();
-      if (!audio || !noise || !master) return;
-      const start = audio.currentTime + at;
-      const source = audio.createBufferSource();
-      source.buffer = noise;
-      const filter = audio.createBiquadFilter();
-      filter.type = "lowpass";
-      filter.frequency.value = cutoff;
-      const envelope = audio.createGain();
-      envelope.gain.setValueAtTime(gain, start);
-      envelope.gain.exponentialRampToValueAtTime(1e-3, start + seconds);
-      source.connect(filter).connect(envelope).connect(master);
-      source.start(start, rng() * Math.max(0, NOISE_SECONDS - seconds));
-      source.stop(start + seconds + 0.05);
+    const classBurstAt = (at, cutoff, gain, seconds) => {
+      channel.play(classBurst, { params: { cutoff, gain, seconds }, ...at ? { delay: at } : {} });
     };
     const tone = (config) => {
-      const audio = ready();
-      if (!audio || !master) return;
-      const start = audio.currentTime + (config.at ?? 0);
-      const osc = audio.createOscillator();
-      osc.type = config.type ?? "sine";
-      osc.frequency.setValueAtTime(config.frequency, start);
-      if (config.to) osc.frequency.exponentialRampToValueAtTime(config.to, start + config.seconds);
-      const gain = audio.createGain();
-      gain.gain.setValueAtTime(1e-4, start);
-      gain.gain.exponentialRampToValueAtTime(Math.max(config.gain, 2e-4), start + 3e-3);
-      gain.gain.exponentialRampToValueAtTime(1e-4, start + config.seconds);
-      osc.connect(gain).connect(master);
-      osc.start(start);
-      osc.stop(start + config.seconds + 0.05);
+      const id = config.to ? TONE_IDS.sine_sweep : config.type === "square" ? TONE_IDS.square : TONE_IDS.sine;
+      const params = { frequency: config.frequency, gain: Math.max(config.gain, 2e-4), seconds: config.seconds, ...config.to ? { to: config.to } : {} };
+      channel.play(id, { params, ...config.at ? { delay: config.at } : {} });
     };
     const metal2 = (at, frequency, gain) => {
       burst({ at, seconds: 0.05, gain, filter: "highpass", frequency, q: 2 });
       tone({ at, seconds: 0.04, gain: gain * 0.6, frequency: frequency * 0.6, type: "square" });
     };
     const play = (soundClass, classVolume = 1, distance2 = 0, at = 0) => {
-      const attenuation = classVolume / (1 + distance2 * distance2 * distanceCurve.gainFalloff);
-      if (attenuation < distanceCurve.minGain) return;
       const [cutoff, gain, seconds] = classes[soundClass] ?? FALLBACK_SOUND_CLASS;
-      classBurst(at, cutoff / (1 + distance2 * distanceCurve.cutoffFalloff), gain * attenuation, seconds);
+      channel.play(classBurst, { volume: classVolume, distance: distance2, params: { cutoff, gain, seconds }, ...at ? { delay: at } : {} });
+    };
+    const sceneTone = (entry) => {
+      channel.play(SCENE_TONE_IDS[entry.wave], { params: { f: entry.f, f2: entry.f2 ?? entry.f, d: entry.d, vol: entry.vol }, ...entry.at ? { delay: entry.at } : {} });
+    };
+    const sceneNoise2 = (entry) => {
+      const slide2 = entry.f2 !== void 0;
+      const id = slide2 ? `${SCENE_NOISE_IDS[entry.type]}_slide` : SCENE_NOISE_IDS[entry.type];
+      channel.play(id, { params: { f: entry.f, ...slide2 ? { f2: entry.f2 } : {}, q: entry.q, d: entry.d, vol: entry.vol }, ...entry.at ? { delay: entry.at } : {} });
     };
     const step = (entry) => {
       if (entry.layer === "metal") metal2(entry.at, entry.frequency, entry.gain);
+      else if (entry.layer === "scene_tone") sceneTone(entry);
+      else if (entry.layer === "scene_noise") sceneNoise2(entry);
       else if (entry.layer === "class") play(entry.soundClass, entry.volume, 0, entry.at);
       else burst({ at: entry.at, seconds: 0.09, gain: entry.gain, filter: "lowpass", frequency: entry.frequency });
     };
@@ -13890,7 +15395,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       shot(energyJ, category, extras = {}) {
         const sound2 = shotSound({ ...extras, energyJ, category });
         if (!sound2.audible) return;
-        classBurst(0, sound2.cutoff, sound2.gain, sound2.duration);
+        classBurstAt(0, sound2.cutoff, sound2.gain, sound2.duration);
         if (sound2.crack.gain > 0) burst({ seconds: sound2.crack.duration, gain: sound2.crack.gain, filter: "highpass", frequency: sound2.crack.cutoff });
         tone({ seconds: sound2.body.duration, gain: sound2.body.gain, frequency: sound2.body.frequency, to: sound2.body.to });
       },
@@ -13918,22 +15423,20 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         mechanical("cycle");
       },
       clink() {
-        const f = 3200 + rng() * 2e3;
-        tone({ seconds: 0.09, gain: 0.12, frequency: f });
-        tone({ seconds: 0.06, gain: 0.06, frequency: f * 2.7 });
+        const f = 4200 + channel.random() * 1500;
+        const at = 0.25 + channel.random() * 0.2;
+        sceneTone({ layer: "scene_tone", at, wave: "sine", f, f2: 3800, d: 0.06, vol: 0.06 });
       },
       thud() {
         burst({ seconds: 0.09, gain: 0.35, filter: "lowpass", frequency: 380 });
       },
       setVolume(next) {
-        level = Math.max(0, Math.min(1, next));
-        if (master) master.gain.value = level;
+        const level = Math.max(0, Math.min(1, next));
+        if (shared) shared.setBus("weapons", { gain: level });
+        else engine.setMaster(level);
       },
       dispose() {
-        void ctx?.close();
-        ctx = null;
-        master = null;
-        noise = null;
+        if (!shared) engine.dispose();
       }
     };
   }
@@ -16687,13 +18190,13 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   }
 
   // src/models/capture.ts
-  function captured(parent, draw) {
+  function captured(parent, draw2) {
     const before = parent.children.length;
-    draw();
+    draw2();
     return parent.children.slice(before);
   }
-  function recordFitting(parts, id, parent, draw) {
-    parts.fittings = { ...parts.fittings, [id]: captured(parent, draw) };
+  function recordFitting(parts, id, parent, draw2) {
+    parts.fittings = { ...parts.fittings, [id]: captured(parent, draw2) };
   }
 
   // src/models/attachments/bipod.ts
@@ -17116,7 +18619,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     }
     return chosen;
   })();
-  var BUILDERS = {
+  var BUILDERS2 = {
     pistol: buildPistol,
     revolver: buildRevolver,
     rifle: buildRifle,
@@ -17146,7 +18649,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const kit = modelKit(THREE);
     const options = { L: entry.length, B: entry.barrel, cal: entry.caliber, ...entry.options };
     if (id in ARCHETYPE_MODELS) delete options.chambers;
-    const built = BUILDERS[entry.builder](kit, options);
+    const built = BUILDERS2[entry.builder](kit, options);
     nameParts(built.parts);
     let root;
     if (entry.builder === "launcher") {
@@ -17540,12 +19043,12 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   var toggleClip = () => composeClip("toggle", [turn(ROOT, "z", 0, TOGGLE_SECONDS / 2, 0, TOGGLE_TILT), turn(ROOT, "z", TOGGLE_SECONDS / 2, TOGGLE_SECONDS / 2, TOGGLE_TILT, 0)]);
   function launcherClips(context) {
     if (!context.parts.ugl) return [];
-    const { open, loaded, close, end, slide: slide2, back } = LAUNCHER_RELOAD;
+    const { open, loaded, close, end: end3, slide: slide2, back } = LAUNCHER_RELOAD;
     const reload = composeClip(
       "reload_ugl",
       [move("ugl", "x", open, slide2, 0, LAUNCHER_SLIDE), move("ugl", "x", close, back, LAUNCHER_SLIDE, 0)],
       [stage("breech_open", open), stage("round_in", loaded), stage("breech_close", close)],
-      end
+      end3
     );
     const shot = composeClip("shot_ugl", [move(ROOT, "x", 0, 0.04, 0, -LAUNCHER_KICK), move(ROOT, "x", 0.04, 0.2, -LAUNCHER_KICK, 0)], [cue(0, "muzzle_flash", { at: "ugl" })]);
     return [reload, shot];
@@ -18202,8 +19705,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     if (!look || !slide2) return null;
     const { M, cylinderX } = kit;
     const length2 = attachment.dims?.length ?? 0.35;
-    const fixed = kit.group();
-    drawFixed(kit, fixed, look, length2);
+    const fixed2 = kit.group();
+    drawFixed(kit, fixed2, look, length2);
     const tubeLength = length2 * look.tubeFraction;
     const start = -0.02;
     cylinderX(slide2, look.tubeRadius, tubeLength, M.metal, start + tubeLength / 2, -look.tubeRadius, 0, 18);
@@ -18212,7 +19715,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const muzzle = kit.mark(slide2, start + tubeLength + 0.01, -look.tubeRadius, 0);
     muzzle.name = "ugl_muzzle";
     return {
-      object: fixed,
+      object: fixed2,
       muzzle,
       dispose() {
         slide2.remove(...slide2.children);
@@ -18839,11 +20342,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       if (!session.cartridge) return;
       const { group } = buildRound(kit, session.cartridge.dims, session.cartridge.shape);
       const start = root.worldToLocal(from.clone());
-      const end = root.worldToLocal(to.clone());
+      const end3 = root.worldToLocal(to.clone());
       group.rotation.z = tilt;
       group.position.copy(start);
       root.add(group);
-      world.schedule(0, 0.24, (eased) => group.position.lerpVectors(start, end, eased), () => {
+      world.schedule(0, 0.24, (eased) => group.position.lerpVectors(start, end3, eased), () => {
         group.removeFromParent();
         group.traverse((child) => {
           const mesh = child;
@@ -20227,7 +21730,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const arsenal = options.arsenal ?? createArsenal({ locale });
     const text = textOf(locale);
     const accessoryText = accessoryTextOf(locale);
-    const audio = options.sound === false ? null : createWeaponAudio(void 0, options.seed === void 0 ? {} : { seed: options.seed });
+    const seedOption = options.seed === void 0 ? {} : { seed: options.seed };
+    let audio = options.sound === false ? null : createWeaponAudio(void 0, seedOption);
     const weaponDefs = [...arsenal.weapons.values()].filter((def) => !BODY_ACTIONS.has(def.id));
     const thumbnailBase = options.thumbnailBase ?? DEFAULT_THUMBNAIL_BASE;
     const withThumbnail = (item, key) => {
@@ -20254,7 +21758,9 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       id: "weapons_area",
       name: text.name,
       group: text.group,
-      audio,
+      get audio() {
+        return audio;
+      },
       get fx() {
         return fx;
       },
@@ -20302,6 +21808,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       ],
       attach(lent) {
         host = lent;
+        const lentEngine = lent.audio?.engine;
+        if (audio && lentEngine) {
+          audio.dispose();
+          audio = createWeaponAudio(void 0, { ...seedOption, engine: lentEngine });
+        }
         const created = createWeaponFx({
           THREE: lent.THREE,
           scene: lent.scene,