@adatechnology/game-test-room 0.7.0 → 0.8.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;
     }
@@ -3147,15 +3178,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;
@@ -3767,6 +3798,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 +8446,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 +8542,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 +9444,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 +10495,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 +11202,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 +11340,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 +11727,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 +12306,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 +13169,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 +13217,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 +13248,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 +13453,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 +13853,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 +14462,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 +14663,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 +14989,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 +15329,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 +15350,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 +15405,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 +15489,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 +15500,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);
     }
@@ -14416,6 +15896,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 +15925,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 +28264,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 +28528,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 +28787,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 +28799,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 +28809,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 +28928,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 +28939,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 +28952,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 +28964,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 +28996,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 +29032,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 +29043,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 +31400,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 +31424,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
             }
           }
           if (!done) {
-            time = end;
+            time = end3;
             done = time >= def.duration;
           }
           follow(dt);
@@ -30360,8 +32026,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 +32184,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 +33098,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 +33133,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 +33278,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         ownVfx?.dispose();
         dropGeometry.dispose();
         materials.dispose();
-        scene.remove(root);
+        scene2.remove(root);
         root.clear();
       },
       stats() {
@@ -33454,10 +35120,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);
@@ -33732,7 +35398,7 @@ void main(){
   var CONE_BLAST_RADIUS = 0.5;
   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 +35411,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 +35466,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 +35474,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;
     };
@@ -34483,13 +36149,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 +37156,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));
@@ -36187,9 +37853,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 +37866,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 +37895,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 +37922,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 +37950,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 +38150,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 +38177,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 +38364,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 +38480,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]);
@@ -36981,7 +38654,7 @@ void main(){
     }
     const explosives = createExplosives({
       THREE,
-      scene,
+      scene: scene2,
       camera: camera2,
       world,
       renderer,
@@ -37478,6 +39151,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) {
@@ -37587,7 +39264,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 +39357,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 +39406,11 @@ void main(){
     }
     const host = {
       THREE,
-      scene,
+      scene: scene2,
       camera: camera2,
       locale,
+      ...audioSink ? { audio: audioSink } : {},
+      environment,
       groundAt,
       effects: vfx,
       tool: () => ({
@@ -37977,11 +39659,13 @@ void main(){
     const room = {
       world,
       renderer,
-      scene,
+      scene: scene2,
       camera: camera2,
       arsenal,
       fluids,
       fluidRenderer: fluidView,
+      audio,
+      environment,
       log,
       get tool() {
         return tool;
@@ -38075,6 +39759,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();
@@ -38179,7 +39865,7 @@ void main(){
         last = now;
         if (!scenarioRunning) update(dt);
         const restoreCamera = vfx.applyCamera();
-        gl.render(scene, camera2);
+        gl.render(scene2, camera2);
         restoreCamera();
         roomMetrics.rendered();
       };