@adatechnology/game-audio 0.4.0 → 0.6.0

package/dist/chunk-KBTUANNG.js

@@ -0,0 +1,4429 @@
+// src/falloff.ts
+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, distance) {
+  if (!falloff || falloff.model === "none") return volume;
+  if (falloff.model === "linear") {
+    const level2 = Math.max(0, 1 - distance / falloff.range) * volume;
+    return falloff.scale === void 0 ? level2 : level2 * falloff.scale;
+  }
+  const level = volume / (1 + distance * distance * 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, distance) {
+  if (!falloff || falloff.model !== "inverse_square" || falloff.cutoffK === void 0) return 1;
+  return 1 + distance * falloff.cutoffK;
+}
+
+// src/data/game-sfx.json
+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 }
+};
+
+// src/recipes/noise-class.ts
+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)) };
+
+// src/library/crowd_rumble.json
+var crowd_rumble_default = {
+  id: "crowd_rumble",
+  bus: "ambience",
+  order: "game_loop",
+  source: { kind: "noise", loop: true },
+  filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 160 } }] },
+  smoothing: { volume: 0.15, frequency: 0.08 },
+  startAbove: 2e-3,
+  sources: ["jogo:L62116 horda: noise through a 160 Hz lowpass", "jogo:L70424 level min(0.16, near \xD7 0.0016)", "temporary home until the crowd package (Q12)"]
+};
+
+// src/library/engine_saw.json
+var engine_saw_default = {
+  id: "engine_saw",
+  bus: "world",
+  order: "game_loop",
+  source: { kind: "osc", wave: "sawtooth", loop: true },
+  filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 400 } }] },
+  smoothing: { volume: 0.15, frequency: 0.08 },
+  startAbove: 2e-3,
+  sources: [
+    "jogo:L62115 motor: sawtooth through a 400 Hz lowpass",
+    "jogo:L70421 level 0.035 + speed \xD7 0.003, frequency 38 + speed \xD7 7 (the host drives `set`)",
+    "temporary home until the vehicles package (Q12)"
+  ]
+};
+
+// src/library/horn.json
+var horn_default = {
+  id: "horn",
+  bus: "world",
+  order: "chord",
+  duration: 0.6,
+  tail: 0.02,
+  layers: [
+    { source: { kind: "osc", wave: "square", frequency: { set: 415 } }, envelope: [[0, 0.08, "set"], [0.6, 1e-4, "set", "fixed"]] },
+    { source: { kind: "osc", wave: "square", frequency: { set: 523 } }, envelope: [[0, 0.08, "set"], [0.6, 1e-4, "set", "fixed"]] }
+  ],
+  falloff: { model: "none" },
+  sources: ["jogo:L70272-70276 buzina: squares at 415 and 523 Hz, 0.08 for 0.6 s", "temporary home until the vehicles package (Q12)"]
+};
+
+// src/library/radio_static.json
+var radio_static_default = {
+  id: "radio_static",
+  bus: "world",
+  order: "static",
+  duration: 0.6,
+  layers: [
+    {
+      source: { kind: "noise", offset: "random" },
+      filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: 1800 }, q: 0.8 }] },
+      envelope: [[0, 0.06, "set"], ["1d", 1e-3, "exp", "fixed"]]
+    }
+  ],
+  falloff: { model: "none" },
+  sources: ["jogo:L69998-70004 chiado: noise through a 1800 Hz bandpass (Q 0.8), 0.06 falling over 0.6 s", "temporary home until the props or radio package (Q12)"]
+};
+
+// src/library/rotor_blades.json
+var rotor_blades_default = {
+  id: "rotor_blades",
+  bus: "world",
+  order: "game_loop",
+  source: { kind: "noise", loop: true },
+  filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 300 } }] },
+  modulators: [{ target: "gain", rate: 11, depth: 0.5, base: 0.5 }],
+  smoothing: { volume: 0.15, frequency: 0.08 },
+  startAbove: 2e-3,
+  sources: [
+    "jogo:L62116-62120 rotor: noise through a 300 Hz lowpass, blade beat as an 11 Hz LFO of 0.5 on a 0.5 gain stage",
+    "jogo:L70426 level min(0.5, 30 / (distance + 10))",
+    "temporary home until the vehicles package (Q12)"
+  ]
+};
+
+// src/library/siren.json
+var siren_default = {
+  id: "siren",
+  bus: "world",
+  order: "siren",
+  duration: 9,
+  tail: 0.2,
+  layers: [
+    {
+      wet: 1.5,
+      source: { kind: "osc", wave: "sine", frequency: { set: 850 } },
+      modulators: [{ target: "frequency", rate: 0.18, depth: 280 }],
+      filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 1400 } }] },
+      envelope: [[0, 1e-4, "set", "fixed"], [2, 0.035, "exp"], [6, 0.035, "set"], [9, 1e-4, "exp", "fixed"]]
+    }
+  ],
+  falloff: { model: "none" },
+  sources: ["cena:L1369 siren: 850 Hz sine swept \xB1280 Hz at 0.18 Hz, 1400 Hz lowpass, 0.035 for 9 s, reverb send 1.5", "temporary home until the vehicles package (Q12)"]
+};
+
+// src/library/index.ts
+var LIBRARY_SOUNDS = [horn_default, radio_static_default, siren_default];
+var LIBRARY_LOOPS = [engine_saw_default, rotor_blades_default, crowd_rumble_default];
+var LIBRARY_BANK = { id: "library", sounds: LIBRARY_SOUNDS, loops: LIBRARY_LOOPS };
+
+// src/data/mix-profiles.json
+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"
+    ]
+  },
+  {
+    id: "kit",
+    master: 0.85,
+    compressor: {
+      threshold: -12,
+      ratio: 5
+    },
+    reverb: {
+      seconds: 2.2,
+      decay: 3.4,
+      wet: 0.4
+    },
+    noise: {
+      seconds: 2,
+      create: "eager"
+    },
+    sources: [
+      "sdk: the art scene chain (cena L1308-L1312) with a limiter after the compressor: the page has none, and a blast with its debris and a fire catching reached +7 dBFS"
+    ],
+    limiter: {
+      ceiling: -1,
+      knee: -6
+    }
+  }
+];
+
+// src/mix.ts
+var MIX_PROFILES = Object.fromEntries(
+  mix_profiles_default.map((profile) => [profile.id, profile])
+);
+var DEFAULT_MIX = "kit";
+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;
+}
+
+// src/recipe.ts
+var BUS_IDS = ["weapons", "voices", "world", "ambience", "weather", "ui"];
+var BUILD_ORDERS = ["layered", "burst", "scream", "groan", "boom", "static", "chord", "calls", "siren", "weapon"];
+
+// src/data/voice-groups.json
+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"
+    ]
+  },
+  fire_ignite: {
+    maxConcurrent: 2,
+    cooldown: 0.15,
+    sources: [
+      "sdk: many parts catching at once (a blast sets a shelf alight) are one or two ignitions, not forty"
+    ]
+  },
+  fire_crackle: {
+    maxConcurrent: 4,
+    sources: [
+      "sdk: the crackles of every fire share four voices"
+    ]
+  }
+};
+
+// src/voices.ts
+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 })
+  };
+}
+
+// src/bank.ts
+function isPlainObject(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] = isPlainObject(current) && isPlainObject(value) ? mergeRecords(current, value) : value;
+  }
+  return merged;
+}
+function createSoundRegistry(banks = []) {
+  const sounds = /* @__PURE__ */ new Map();
+  const loops = /* @__PURE__ */ new Map();
+  const sets = /* @__PURE__ */ new Map();
+  const samples = /* @__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);
+      }
+      for (const set of bank.sets ?? []) {
+        if (set.variants.length === 0) throw new Error(`sound set ${set.id} has no variant`);
+        sets.set(set.id, set);
+        owners.set(set.id, bank.id);
+      }
+      for (const sample of bank.samples ?? []) {
+        samples.set(sample.id, sample);
+        owners.set(sample.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));
+      const sample = samples.get(id);
+      if (sample) samples.set(id, mergeRecords(sample, patch));
+    },
+    remove(id) {
+      sounds.delete(id);
+      loops.delete(id);
+      sets.delete(id);
+      samples.delete(id);
+      owners.delete(id);
+    },
+    sound: (id) => sounds.get(id),
+    loop: (id) => loops.get(id),
+    set: (id) => sets.get(id),
+    sample: (id) => samples.get(id),
+    soundIds: () => [...sounds.keys()],
+    setIds: () => [...sets.keys()],
+    loopIds: () => [...loops.keys()],
+    sampleIds: () => [...samples.keys()],
+    bankOf: (id) => owners.get(id)
+  };
+  for (const bank of banks) registry.register(bank);
+  return registry;
+}
+
+// src/listener.ts
+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 distance = Math.hypot(dx, dz) || 1;
+  const pan = (dx * rightX + dz * rightZ) / Math.max(distance, PAN_MIN_DISTANCE);
+  return pan < -PAN_LIMIT ? -PAN_LIMIT : pan > PAN_LIMIT ? PAN_LIMIT : pan;
+}
+
+// src/rng.ts
+var FNV_OFFSET = 2166136261;
+var FNV_PRIME = 16777619;
+var MIX = 2654435761;
+function createRng(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 createRng(streamSeed(seed, name));
+}
+function drawBetween(random, min, max) {
+  return min + random() * (max - min);
+}
+
+// src/plan.ts
+var DEFAULT_TAIL = 0.05;
+var DEFAULT_NOISE_SECONDS = 1.5;
+var OCCLUSION_GAIN = 0.5;
+var OCCLUSION_CUTOFF = 0.6;
+function isParamRef(range) {
+  return typeof range === "object" && !Array.isArray(range);
+}
+function draw(range, scope) {
+  if (typeof range === "number") return range;
+  if (isParamRef(range)) {
+    const value = scope.params[range.param];
+    if (value === void 0) throw new Error(`game-audio: the recipe reads the param "${range.param}", which was not given`);
+    return value * (range.scale ?? 1) + (range.add ?? 0);
+  }
+  const [min, max] = range;
+  return min + scope.random() * (max - min);
+}
+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(layer, scope) {
+  const pending = { at: 0, gain: 1, filters: [], modulators: [] };
+  for (const key of Object.keys(layer)) {
+    if (key === "at" && layer.at !== void 0) pending.at = draw(layer.at, scope);
+    else if (key === "duration" && layer.duration !== void 0) pending.duration = draw(layer.duration, scope);
+    else if (key === "gain" && layer.gain !== void 0) pending.gain = draw(layer.gain, scope);
+    else if (key === "source" && layer.source.kind === "osc") pending.automation = drawAutomation(layer.source.frequency, scope);
+    else if (key === "source" && layer.source.kind === "formant_voice") pending.voice = drawVoice(layer.source, scope);
+    else if (key === "filters" && layer.filters) pending.filters = layer.filters.bank.map((spec) => drawFilter(spec, scope));
+    else if (key === "modulators" && layer.modulators) pending.modulators = layer.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(layer, pending, duration, offset) {
+  const source = layer.source;
+  if (source.kind === "noise") return { kind: "noise", offset, loop: source.loop === true };
+  if (source.kind === "osc") return { kind: "osc", wave: source.wave, frequency: finishAutomation(pending.automation ?? {}, duration) };
+  const voice = pending.voice;
+  return {
+    kind: "formant_voice",
+    wave: source.wave,
+    frequency: finishAutomation(voice.frequency, duration),
+    vibrato: { rate: voice.vibratoRate, depth: startFrequency(voice.frequency) * source.vibrato.depth },
+    formants: voice.formants,
+    breath: { ...voice.breath, offset },
+    mix: source.mix
+  };
+}
+function finishModulator(pending, sourceFrequency) {
+  const { modulator } = pending;
+  const depth = typeof modulator.depth === "object" && "scaleOf" in modulator.depth ? sourceFrequency * modulator.depth.factor : pending.depth ?? 0;
+  return { target: modulator.target, ...modulator.wave ? { wave: modulator.wave } : {}, rate: pending.rate, depth, ...modulator.base === void 0 ? {} : { base: modulator.base } };
+}
+function finishEnvelope(envelope, duration, level) {
+  return envelope.map(([time, value, curve, fixed2]) => ({ time: timeOf(time, duration), value: fixed2 === "fixed" ? value : value * level, curve }));
+}
+function planLayer(layer, scope, defaults, levelInEnvelope, soundLevel) {
+  const pending = drawLayer(layer, 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(layer.source, duration, scope, defaults.noiseSeconds);
+  const level = pending.gain * soundLevel;
+  const sourceFrequency = layer.source.kind === "noise" ? 0 : startFrequency(pending.automation ?? pending.voice?.frequency ?? {});
+  const planned = {
+    at: pending.at,
+    duration,
+    tail: layer.tail ?? defaults.tail ?? DEFAULT_TAIL,
+    level,
+    ...layer.wet === void 0 ? {} : { wet: layer.wet },
+    source: finishSource(layer, pending, duration, offset),
+    ...layer.filters ? {
+      filters: {
+        mode: layer.filters.mode,
+        bank: pending.filters.map(({ spec, frequency, q, gain, level: filterLevel }) => ({
+          type: spec.type,
+          frequency: finishAutomation(frequency, duration),
+          ...q === void 0 ? {} : { q },
+          ...gain === void 0 ? {} : { gain },
+          ...filterLevel === void 0 ? {} : { level: filterLevel }
+        }))
+      }
+    } : {},
+    modulators: pending.modulators.map((modulator) => finishModulator(modulator, sourceFrequency)),
+    envelope: finishEnvelope(layer.envelope, duration, levelInEnvelope ? level : 1)
+  };
+  if (!layer.repeat) return [planned];
+  return Array.from({ length: layer.repeat.count }, (_, index) => ({ ...planned, at: planned.at + index * (layer.repeat?.spacing ?? 0) }));
+}
+function scaleAutomation(automation, divisor) {
+  const scale = (value) => value === void 0 ? void 0 : value / divisor;
+  const scaled = { ...automation };
+  for (const key of ["value", "from", "to"]) if (automation[key] !== void 0) scaled[key] = scale(automation[key]);
+  return scaled;
+}
+function muffle(layer, divisor) {
+  if (divisor === 1 || !layer.filters) return layer;
+  const bank = layer.filters.bank.map((filter) => filter.type === "lowpass" ? { ...filter, frequency: scaleAutomation(filter.frequency, divisor) } : filter);
+  return { ...layer, filters: { ...layer.filters, bank } };
+}
+var layerEnd = (layer) => layer.at + layer.duration + layer.tail;
+function planSound(recipe, input = {}) {
+  const listener = input.listener ?? DEFAULT_LISTENER;
+  const distance = 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, distance);
+  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,
+    ...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 ?? createRng(1), params: { ...input.params } };
+  for (const [name, range] of Object.entries(recipe.vars ?? {})) if (scope.params[name] === void 0) scope.params[name] = draw(range, 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, distance) / (1 - OCCLUSION_CUTOFF * occlusion);
+  const layers = recipe.layers.flatMap((layer) => planLayer(layer, scope, defaults, order !== "layered", level)).map((layer) => muffle(layer, divisor));
+  return { ...base, silent: false, length: Math.max(0, ...layers.map(layerEnd)), layers };
+}
+
+// src/webaudio/noise.ts
+function fillNoise(random, length) {
+  const samples = new Float32Array(length);
+  for (let index = 0; index < length; 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;
+}
+
+// src/webaudio/chain.ts
+var LIMITER_POINTS = 4097;
+function limiterCurve(ceilingDb, kneeDb, range, points = LIMITER_POINTS) {
+  const ceiling = 10 ** (ceilingDb / 20);
+  const knee = Math.min(10 ** (kneeDb / 20), ceiling);
+  const curve = new Float32Array(new ArrayBuffer(points * 4));
+  for (let i = 0; i < points; i++) {
+    const x = (i / (points - 1) * 2 - 1) * range;
+    const a = Math.abs(x);
+    const y = a <= knee || ceiling === knee ? Math.min(a, ceiling) : knee + (ceiling - knee) * Math.tanh((a - knee) / (ceiling - knee));
+    curve[i] = Math.sign(x) * y;
+  }
+  return curve;
+}
+function buildChain(context, profile, random) {
+  let limiter;
+  if (profile.limiter) {
+    const range = profile.limiter.range ?? 4;
+    const input = context.createGain();
+    input.gain.value = 1 / range;
+    const shaper = context.createWaveShaper();
+    shaper.curve = limiterCurve(profile.limiter.ceiling, profile.limiter.knee, range);
+    input.connect(shaper);
+    shaper.connect(context.destination);
+    limiter = { input, shaper };
+  }
+  const output = limiter?.input ?? context.destination;
+  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(output);
+  }
+  const master = context.createGain();
+  master.gain.value = profile.master;
+  master.connect(compressor ?? output);
+  if (!profile.reverb) {
+    return {
+      master,
+      disconnect: () => {
+        master.disconnect();
+        compressor?.disconnect();
+        limiter?.input.disconnect();
+        limiter?.shaper.disconnect();
+      }
+    };
+  }
+  const convolver = context.createConvolver();
+  const length = context.sampleRate * profile.reverb.seconds;
+  convolver.buffer = bufferOf(context, fillImpulse(random, { channels: 2, length, decay: profile.reverb.decay }), length);
+  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();
+      limiter?.input.disconnect();
+      limiter?.shaper.disconnect();
+    }
+  };
+}
+
+// src/webaudio/context.ts
+function globalContext() {
+  const scope = globalThis;
+  const Constructor = scope.AudioContext ?? scope.webkitAudioContext;
+  return Constructor ? new Constructor() : null;
+}
+function unlockContext(context) {
+  if (context.state === "suspended" && typeof context.close === "function") void context.resume();
+}
+
+// src/loops.ts
+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;
+    }
+  };
+}
+
+// src/webaudio/nodes.ts
+function assign(param, automation, time) {
+  if (automation.value !== void 0) param.value = automation.value;
+  if (automation.from !== void 0) param.setValueAtTime(automation.from, time);
+}
+function ramp(param, curve, value, at) {
+  if (curve === "set") param.setValueAtTime(value, at);
+  else if (curve === "exp") param.exponentialRampToValueAtTime(value, at);
+  else param.linearRampToValueAtTime(value, at);
+}
+function rampTo(param, automation, time) {
+  if (automation.to !== void 0 && automation.at !== void 0) ramp(param, automation.curve ?? "linear", automation.to, time + automation.at);
+}
+function applyEnvelope(param, points, time) {
+  for (const point of points) ramp(param, point.curve, point.value, time + point.time);
+}
+function noiseSource(target, loop) {
+  const source = target.context.createBufferSource();
+  source.buffer = target.noise();
+  if (loop) source.loop = true;
+  return source;
+}
+function filterNode(context, filter, time) {
+  const node = context.createBiquadFilter();
+  node.type = filter.type;
+  assign(node.frequency, filter.frequency, time);
+  if (filter.q !== void 0) node.Q.value = filter.q;
+  if (filter.gain !== void 0) node.gain.value = filter.gain;
+  return node;
+}
+function gainNode(context, value) {
+  const node = context.createGain();
+  node.gain.value = value;
+  return node;
+}
+function voiceOf(sources) {
+  return {
+    sources,
+    stop() {
+      for (const source of sources) {
+        try {
+          source.stop();
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/webaudio/realize-loop.ts
+function outputStage(recipe, target, gain) {
+  if (!recipe.pan) {
+    gain.connect(target.output);
+    return { out: gain };
+  }
+  const panner = target.context.createStereoPanner();
+  gain.connect(panner);
+  panner.connect(target.output);
+  return { out: panner, panner };
+}
+var fixed = (range) => typeof range === "number" ? range : 0;
+var fixedFrequency = (automation) => fixed("set" in automation ? automation.set : automation.from);
+function sourceOf(recipe, target) {
+  if (recipe.source.kind === "noise") return { source: noiseSource(target, true) };
+  const oscillator = target.context.createOscillator();
+  oscillator.type = recipe.source.wave;
+  if (recipe.source.frequency) oscillator.frequency.value = fixedFrequency(recipe.source.frequency);
+  return { source: oscillator, frequency: oscillator.frequency };
+}
+function stopAll(sources) {
+  return () => {
+    for (const source of sources) {
+      try {
+        source.stop();
+      } catch {
+      }
+    }
+  };
+}
+function realizeGameLoop(recipe, target) {
+  const { context } = target;
+  const gain = context.createGain();
+  const filters = (recipe.filters?.bank ?? []).map(() => context.createBiquadFilter());
+  gain.gain.value = 0;
+  const last = filters.reduce((previous, filter) => previous ? previous.connect(filter) : filter, void 0);
+  last?.connect(gain);
+  const output = outputStage(recipe, target, gain);
+  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, ...output, source, ...frequency ? { frequency } : {}, ...filters[0] ? { cutoff: filters[0].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);
+  const output = outputStage(recipe, target, gain);
+  source.start();
+  for (const lfo of lfos) lfo.start();
+  return { gain, ...output, source, ...frequency ? { frequency } : {}, ...filters[0] ? { cutoff: filters[0].frequency } : {}, stop: stopAll([source, ...lfos]) };
+}
+
+// src/webaudio/engine-loop.ts
+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?.out.disconnect();
+      nodes?.out.connect(host.output(loopRecipe.bus));
+    },
+    stop() {
+      nodes?.stop();
+      nodes?.out.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();
+  let position;
+  let cutoff;
+  const placed = loopRecipe.falloff !== void 0 || loopRecipe.pan === true;
+  return {
+    set(next) {
+      if (isChain && !nodes) open();
+      const context = host.ready();
+      if (!context) return;
+      position = next.position ?? position;
+      cutoff = next.cutoff ?? cutoff;
+      const action = state.set(next);
+      if (!action) return;
+      nodes ?? (nodes = create(context, 0));
+      const listener = placed && position ? host.listener?.() : void 0;
+      const distance = listener && position ? listenerDistance(listener, position, host.distance) : 0;
+      const level = listener ? falloffGain(loopRecipe.falloff, action.volume, distance) : action.volume;
+      nodes.gain.gain.setTargetAtTime(level, context.currentTime, smoothing.volume);
+      if (action.frequency !== void 0 && nodes.frequency) nodes.frequency.setTargetAtTime(action.frequency, context.currentTime, smoothing.frequency);
+      if (cutoff !== void 0 && nodes.cutoff) nodes.cutoff.setTargetAtTime(cutoff / cutoffDivisor(loopRecipe.falloff, distance), context.currentTime, smoothing.frequency);
+      if (listener && position && nodes.panner) nodes.panner.pan.setTargetAtTime(panFor(listener, position), context.currentTime, smoothing.frequency);
+    },
+    stop: entry.stop
+  };
+}
+
+// src/sample.ts
+var SAMPLE_ENVIRONMENTS = ["indoor", "outdoor"];
+var DEFAULT_SAMPLE_FALLOFF = { model: "inverse_square", k: 2e-3, minGain: 2e-3 };
+var DEFAULT_CROSSOVER = { from: 30, to: 80 };
+var DEFAULT_SAMPLE_PITCH = 0.04;
+var DEFAULT_TAIL_GAIN = 0.6;
+var DEFAULT_SAMPLE_CUTOFF_K = 0.01;
+var OPEN_CUTOFF = 2e4;
+var LAYER_FLOOR = 1e-3;
+function pickTake(count, last, random) {
+  if (count <= 1) return 0;
+  if (last === void 0 || last < 0 || last >= count) return Math.min(count - 1, Math.floor(random() * count));
+  const drawn = Math.min(count - 2, Math.floor(random() * (count - 1)));
+  return drawn >= last ? drawn + 1 : drawn;
+}
+function farMixAt(crossover, distance) {
+  if (crossover.to <= crossover.from) return distance >= crossover.to ? 1 : 0;
+  const t = (distance - crossover.from) / (crossover.to - crossover.from);
+  return t <= 0 ? 0 : t >= 1 ? 1 : t;
+}
+function crossGains(farMix) {
+  return { close: Math.cos(farMix * Math.PI / 2), far: Math.sin(farMix * Math.PI / 2) };
+}
+function sampleCutoff(cutoffK, distance, occlusion = 0) {
+  const byDistance = cutoffK > 0 ? OPEN_CUTOFF / (1 + distance * cutoffK) : OPEN_CUTOFF;
+  const occluded = occlusion > 0 ? byDistance / (1 + occlusion * 9) : byDistance;
+  return Math.max(80, Math.min(OPEN_CUTOFF, occluded));
+}
+function sampleUrls(sound) {
+  const tiers = (sound.tiers ?? []).flatMap((tier) => [...tier.close, ...tier.far ?? []]);
+  const all = [...sound.close, ...sound.far ?? [], ...tiers, ...sound.tail?.indoor ?? [], ...sound.tail?.outdoor ?? []].map((ref) => ref.url);
+  return [...new Set(all)];
+}
+function tierFor(sound, intensity) {
+  if (intensity === void 0 || !sound.tiers) return void 0;
+  let chosen;
+  for (const tier of sound.tiers) if (tier.from <= intensity) chosen = tier;
+  return chosen ?? sound.tiers[0];
+}
+function planSample(sound, input) {
+  if (sound.close.length === 0) throw new Error(`sample sound ${sound.id} has no close take`);
+  const listener = input.listener ?? DEFAULT_LISTENER;
+  const distance = input.distance ?? (input.position ? listenerDistance(listener, input.position, input.distanceMode) : 0);
+  const falloff = sound.falloff ?? DEFAULT_SAMPLE_FALLOFF;
+  const occlusion = Math.max(0, Math.min(1, input.occlusion ?? 0));
+  const level = falloffGain(falloff, (input.volume ?? 1) * (sound.gain ?? 1), distance) * (1 - 0.45 * occlusion);
+  if (isSilent(falloff, level) || level <= 0) return null;
+  const pitch = sound.pitch ?? DEFAULT_SAMPLE_PITCH;
+  const rate = pitch > 0 ? 1 + (input.random() * 2 - 1) * pitch : 1;
+  const environment = input.environment ?? "outdoor";
+  const tier = tierFor(sound, input.intensity);
+  const close = tier?.close.length ? tier.close : sound.close;
+  const far = tier?.far?.length ? tier.far : sound.far ?? [];
+  const farMix = far.length > 0 ? farMixAt(sound.crossover ?? DEFAULT_CROSSOVER, distance) : 0;
+  const gains = crossGains(farMix);
+  const layers = [];
+  const take = (role, refs, gain, at) => {
+    if (refs.length === 0 || gain < LAYER_FLOOR) return;
+    const key = `${sound.id}/${tier && role !== "tail" ? `${tier.name}/` : ""}${role}`;
+    const index = pickTake(refs.length, input.memory?.get(key), input.random);
+    input.memory?.set(key, index);
+    const ref = refs[index];
+    layers.push({ role, url: ref.url, take: index, gain: gain * (ref.gain ?? 1) * level, rate, at });
+  };
+  take("close", close, gains.close, 0);
+  take("far", far, gains.far, 0);
+  const tails = sound.tail?.[environment] ?? [];
+  take("tail", tails, sound.tail?.gain ?? DEFAULT_TAIL_GAIN, sound.tail?.at ?? 0);
+  const pan = (sound.pan ?? true) && input.position ? panFor(listener, input.position) : void 0;
+  return {
+    kind: "sample",
+    id: sound.id,
+    bus: sound.bus,
+    level,
+    distance,
+    ...pan === void 0 ? {} : { pan },
+    cutoff: sampleCutoff(sound.cutoffK ?? DEFAULT_SAMPLE_CUTOFF_K, distance, occlusion),
+    rate,
+    environment,
+    ...tier ? { tier: tier.name } : {},
+    farMix,
+    layers,
+    priority: sound.priority ?? input.priority ?? busPriority(sound.bus),
+    ...sound.group ? { group: sound.group } : {}
+  };
+}
+
+// src/webaudio/sample-loop.ts
+var DEFAULT_LOOP_CROSSFADE = 0.25;
+var LOOKAHEAD = 1.5;
+var VOLUME_SMOOTHING = 0.05;
+function loopCrossfade(sound) {
+  if (!sound.loop) return void 0;
+  return sound.loop === true ? DEFAULT_LOOP_CROSSFADE : Math.max(0, sound.loop.crossfade ?? DEFAULT_LOOP_CROSSFADE);
+}
+var CROSSFADE_STEPS = 8;
+var equalPowerIn = (t) => Math.sin(Math.max(0, Math.min(1, t)) * Math.PI / 2);
+var ramp2 = (param, direction, at, seconds) => {
+  const value = (t) => direction === "in" ? equalPowerIn(t) : equalPowerIn(1 - t);
+  param.setValueAtTime(value(0), at);
+  for (let step = 1; step <= CROSSFADE_STEPS; step++) param.linearRampToValueAtTime(value(step / CROSSFADE_STEPS), at + seconds * step / CROSSFADE_STEPS);
+};
+function createSampleLoopHandle(sound, host, volume = 0) {
+  const crossfade = loopCrossfade(sound) ?? DEFAULT_LOOP_CROSSFADE;
+  let level = volume;
+  let stopped = false;
+  let fallback;
+  let master;
+  let segments = [];
+  let last;
+  let timer;
+  const entry = {
+    get created() {
+      return master !== void 0;
+    },
+    rewire() {
+      master?.disconnect();
+      master?.connect(host.output(sound.bus));
+    },
+    stop() {
+      stopped = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      for (const segment of segments) {
+        try {
+          segment.source.stop();
+        } catch {
+        }
+        segment.source.disconnect();
+        segment.gain.disconnect();
+      }
+      segments = [];
+      master?.disconnect();
+      master = void 0;
+      fallback?.stop();
+      fallback = void 0;
+      host.unregister(entry);
+    }
+  };
+  const nextBuffer = () => {
+    const takes = sound.close;
+    const take = pickTake(takes.length, last, host.random);
+    last = take;
+    const ref = takes[take];
+    return ref ? host.buffer(ref.url) : void 0;
+  };
+  const schedule = (context, output, at, first) => {
+    const buffer = nextBuffer();
+    if (!buffer) return void 0;
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    const gain = context.createGain();
+    source.connect(gain);
+    gain.connect(output);
+    const fade = Math.min(crossfade, buffer.duration / 2);
+    if (buffer.duration < 2 * crossfade || sound.close.length === 1) {
+      source.loop = true;
+      if (!first) ramp2(gain.gain, "in", at, Math.max(1e-3, fade));
+      source.start(at);
+      segments.push({ source, gain, end: Number.POSITIVE_INFINITY });
+      return void 0;
+    }
+    if (first) gain.gain.setValueAtTime(1, at);
+    else ramp2(gain.gain, "in", at, fade);
+    const end3 = at + buffer.duration;
+    ramp2(gain.gain, "out", end3 - fade, fade);
+    source.start(at);
+    source.stop(end3);
+    segments.push({ source, gain, end: end3 });
+    source.onended = () => {
+      segments = segments.filter((segment) => segment.source !== source);
+      source.disconnect();
+      gain.disconnect();
+    };
+    return end3 - fade;
+  };
+  const pump = (context, output, at, first) => {
+    if (stopped) return;
+    let next = schedule(context, output, at, first);
+    while (next !== void 0 && next < context.currentTime + LOOKAHEAD) next = schedule(context, output, Math.max(next, context.currentTime), false);
+    if (next === void 0) return;
+    const wait = Math.max(0, (next - context.currentTime - LOOKAHEAD / 2) * 1e3);
+    timer = setTimeout(() => {
+      timer = void 0;
+      pump(context, output, next, false);
+    }, wait);
+  };
+  const fileLevel = () => level * (sound.gain ?? 1);
+  const startFiles = () => {
+    if (stopped || master || !host.isReady(sound)) return master !== void 0;
+    const context = host.ready();
+    if (!context) return false;
+    master = context.createGain();
+    master.gain.setValueAtTime(fileLevel(), context.currentTime);
+    master.connect(host.output(sound.bus));
+    host.register(entry);
+    pump(context, master, context.currentTime, true);
+    if (fallback) {
+      fallback.set({ volume: 0 });
+      const old = fallback;
+      fallback = void 0;
+      setTimeout(() => old.stop(), VOLUME_SMOOTHING * 6e3);
+    }
+    return true;
+  };
+  const ensure = () => {
+    if (stopped || master) return;
+    if (startFiles()) return;
+    if (!fallback) {
+      fallback = host.fallback(level);
+      void host.load(sound).then(() => {
+        if (level > 0 || master) startFiles();
+      }).catch(() => void 0);
+    }
+  };
+  if (volume > 0) ensure();
+  return {
+    set(next) {
+      if (stopped) return;
+      if (next.volume !== void 0) level = host.muted(sound.bus) ? 0 : Math.max(0, next.volume);
+      if (level > 0) ensure();
+      const context = host.ready();
+      if (master && context) master.gain.setTargetAtTime(fileLevel(), context.currentTime, VOLUME_SMOOTHING);
+      fallback?.set(next.volume === void 0 ? next : { ...next, volume: level });
+    },
+    stop: entry.stop
+  };
+}
+
+// src/webaudio/engine-noise.ts
+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;
+}
+
+// src/webaudio/engine-queue.ts
+import { DEFERRED_QUEUE_ID } from "@adatechnology/game-contracts";
+var nowMs = () => typeof performance === "undefined" ? Date.now() : performance.now();
+function scheduleTask(task) {
+  if (typeof MessageChannel === "undefined") {
+    setTimeout(task, 0);
+    return;
+  }
+  const channel = new MessageChannel();
+  channel.port1.onmessage = () => {
+    channel.port1.close();
+    task();
+  };
+  channel.port2.postMessage(0);
+}
+function createStartQueue(options = {}) {
+  const budgetMs = options.budgetMs ?? 2;
+  const maxLatencyMs = options.maxLatencyMs ?? 250;
+  let jobs = [];
+  let scheduled = false;
+  let attached = false;
+  const runNext = () => {
+    const job = jobs.shift();
+    if (nowMs() - job.queuedAt > maxLatencyMs) job.drop();
+    else job.run();
+  };
+  const drain = () => {
+    scheduled = false;
+    if (attached) return;
+    const began = nowMs();
+    while (jobs.length > 0) {
+      runNext();
+      if (nowMs() - began >= budgetMs) break;
+    }
+    if (jobs.length > 0) schedule();
+  };
+  const schedule = () => {
+    if (scheduled || attached) return;
+    scheduled = true;
+    scheduleTask(drain);
+  };
+  const queue = {
+    push(job) {
+      jobs.push({ ...job, queuedAt: nowMs() });
+      schedule();
+    },
+    clear() {
+      for (const job of jobs) job.drop();
+      jobs = [];
+    },
+    get size() {
+      return jobs.length;
+    },
+    deferredQueue: () => deferredQueue
+  };
+  const deferredQueue = {
+    id: DEFERRED_QUEUE_ID.AUDIO_VOICES,
+    pending: () => jobs.length,
+    run(deadline, clock) {
+      let ran = 0;
+      while (jobs.length > 0) {
+        runNext();
+        ran++;
+        if (clock() >= deadline) break;
+      }
+      return ran;
+    },
+    flush() {
+      while (jobs.length > 0) runNext();
+    },
+    attach() {
+      attached = true;
+    },
+    detach() {
+      attached = false;
+      if (jobs.length > 0) schedule();
+    }
+  };
+  return queue;
+}
+
+// src/webaudio/realize-game.ts
+var end = (layer, start) => start + layer.duration + layer.tail;
+var firstFilter = (layer) => layer.filters?.bank[0];
+var offsetOf = (layer) => layer.source.kind === "noise" ? layer.source.offset : 0;
+function setFilter(node, filter, time) {
+  if (!filter) return;
+  node.type = filter.type;
+  assign(node.frequency, filter.frequency, time);
+  if (filter.q !== void 0) node.Q.value = filter.q;
+}
+function realizeBurst(plan, target) {
+  const { context } = target;
+  const layer = plan.layers[0];
+  const time = target.time + layer.at;
+  const gain = context.createGain();
+  gain.connect(target.output);
+  const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+  const filter = context.createBiquadFilter();
+  source.connect(filter);
+  filter.connect(gain);
+  setFilter(filter, firstFilter(layer), time);
+  applyEnvelope(gain.gain, layer.envelope, time);
+  source.start(time, offsetOf(layer));
+  source.stop(end(layer, time));
+  return voiceOf([source]);
+}
+function realizeScream(plan, target) {
+  const { context } = target;
+  const layer = plan.layers[0];
+  const time = target.time + layer.at;
+  const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+  const gain = context.createGain();
+  gain.connect(target.output);
+  for (const band of layer.filters?.bank ?? []) {
+    const filter = context.createBiquadFilter();
+    filter.type = band.type;
+    if (band.q !== void 0) filter.Q.value = band.q;
+    assign(filter.frequency, band.frequency, time);
+    rampTo(filter.frequency, band.frequency, time);
+    const level = context.createGain();
+    level.gain.value = band.level ?? 1;
+    source.connect(filter);
+    filter.connect(level);
+    level.connect(gain);
+  }
+  const sources = [source];
+  const lfos = layer.modulators.map((modulator) => {
+    const lfo = context.createOscillator();
+    const depth = context.createGain();
+    if (modulator.wave) lfo.type = modulator.wave;
+    lfo.frequency.value = modulator.rate;
+    depth.gain.value = modulator.depth;
+    lfo.connect(depth);
+    depth.connect(gain.gain);
+    return lfo;
+  });
+  applyEnvelope(gain.gain, layer.envelope, time);
+  source.start(time, offsetOf(layer));
+  source.stop(end(layer, time));
+  for (const lfo of lfos) {
+    lfo.start(time);
+    lfo.stop(end(layer, time));
+    sources.push(lfo);
+  }
+  return voiceOf(sources);
+}
+function realizeGroan(plan, target) {
+  const { context } = target;
+  const layer = plan.layers[0];
+  const time = target.time + layer.at;
+  const oscillator = context.createOscillator();
+  const gain = context.createGain();
+  const filter = context.createBiquadFilter();
+  const band = firstFilter(layer);
+  if (layer.source.kind === "osc") oscillator.type = layer.source.wave;
+  if (band) {
+    filter.type = band.type;
+    if (band.q !== void 0) filter.Q.value = band.q;
+  }
+  if (layer.source.kind === "osc") {
+    assign(oscillator.frequency, layer.source.frequency, time);
+    rampTo(oscillator.frequency, layer.source.frequency, time);
+  }
+  if (band) assign(filter.frequency, band.frequency, time);
+  applyEnvelope(gain.gain, layer.envelope, time);
+  oscillator.connect(filter);
+  filter.connect(gain);
+  gain.connect(target.output);
+  oscillator.start(time);
+  oscillator.stop(end(layer, time));
+  return voiceOf([oscillator]);
+}
+function realizeBoom(plan, target) {
+  const { context } = target;
+  const layer = plan.layers[0];
+  const time = target.time + layer.at;
+  const oscillator = context.createOscillator();
+  const gain = context.createGain();
+  if (layer.source.kind === "osc") {
+    oscillator.type = layer.source.wave;
+    assign(oscillator.frequency, layer.source.frequency, time);
+    rampTo(oscillator.frequency, layer.source.frequency, time);
+  }
+  applyEnvelope(gain.gain, layer.envelope, time);
+  oscillator.connect(gain);
+  gain.connect(target.output);
+  oscillator.start(time);
+  oscillator.stop(end(layer, time));
+  return voiceOf([oscillator]);
+}
+function realizeStatic(plan, target) {
+  const { context } = target;
+  const layer = plan.layers[0];
+  const time = target.time + layer.at;
+  const gain = context.createGain();
+  const source = context.createBufferSource();
+  const filter = context.createBiquadFilter();
+  source.buffer = target.noise();
+  setFilter(filter, firstFilter(layer), time);
+  applyEnvelope(gain.gain, layer.envelope, time);
+  source.connect(filter);
+  filter.connect(gain);
+  gain.connect(target.output);
+  source.start(time, offsetOf(layer));
+  source.stop(end(layer, time));
+  return voiceOf([source]);
+}
+function realizeChord(plan, target) {
+  const { context } = target;
+  const layers = plan.layers;
+  const oscillators = layers.map(() => context.createOscillator());
+  const gain = context.createGain();
+  for (let index = layers.length - 1; index >= 0; index--) {
+    const source = layers[index].source;
+    if (source.kind === "osc") oscillators[index].type = source.wave;
+  }
+  layers.forEach((layer, index) => {
+    if (layer.source.kind === "osc") assign(oscillators[index].frequency, layer.source.frequency, target.time + layer.at);
+  });
+  applyEnvelope(gain.gain, layers[0].envelope, target.time + layers[0].at);
+  for (const oscillator of oscillators) oscillator.connect(gain);
+  gain.connect(target.output);
+  layers.forEach((layer, index) => oscillators[index].start(target.time + layer.at));
+  layers.forEach((layer, index) => oscillators[index].stop(end(layer, target.time + layer.at)));
+  return voiceOf(oscillators);
+}
+function realizeCalls(plan, target) {
+  const { context } = target;
+  const gain = context.createGain();
+  const filter = context.createBiquadFilter();
+  if (plan.silent) return voiceOf([]);
+  const band = firstFilter(plan.layers[0]);
+  if (band) filter.type = band.type;
+  filter.connect(gain);
+  gain.connect(target.output);
+  const oscillators = plan.layers.map((layer) => {
+    const time = target.time + layer.at;
+    const oscillator = context.createOscillator();
+    if (layer.source.kind === "osc") {
+      oscillator.type = layer.source.wave;
+      assign(oscillator.frequency, layer.source.frequency, time);
+      rampTo(oscillator.frequency, layer.source.frequency, time);
+    }
+    if (band) {
+      assign(filter.frequency, band.frequency, time);
+      if (band.q !== void 0) filter.Q.value = band.q;
+    }
+    const envelope = context.createGain();
+    applyEnvelope(envelope.gain, layer.envelope, time);
+    oscillator.connect(envelope);
+    envelope.connect(filter);
+    oscillator.start(time);
+    oscillator.stop(end(layer, time));
+    return oscillator;
+  });
+  return voiceOf(oscillators);
+}
+
+// src/webaudio/realize-layered.ts
+var end2 = (layer, start) => start + layer.duration + layer.tail;
+function outputStage2(plan, layer, target) {
+  const { context } = target;
+  const level = gainNode(context, layer.level);
+  let node = level;
+  if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
+    const panner = context.createStereoPanner();
+    panner.pan.value = plan.pan;
+    level.connect(panner);
+    node = panner;
+  }
+  node.connect(target.output);
+  if (layer.wet && target.wet) {
+    const send = gainNode(context, layer.wet);
+    node.connect(send);
+    send.connect(target.wet);
+  }
+  return level;
+}
+function realizeNoiseLayer(plan, layer, target) {
+  const { context } = target;
+  const time = target.time + layer.at;
+  const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+  const filters = (layer.filters?.bank ?? []).map((filter) => {
+    const node = filterNode(context, filter, time);
+    rampTo(node.frequency, filter.frequency, time);
+    return node;
+  });
+  const envelope = context.createGain();
+  applyEnvelope(envelope.gain, layer.envelope, time);
+  let tail = source;
+  for (const filter of filters) tail = tail.connect(filter);
+  tail.connect(envelope);
+  envelope.connect(outputStage2(plan, layer, target));
+  source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
+  source.stop(end2(layer, time));
+  return [source];
+}
+function realizeToneLayer(plan, layer, target) {
+  const { context } = target;
+  const time = target.time + layer.at;
+  const oscillator = context.createOscillator();
+  if (layer.source.kind === "osc") {
+    oscillator.type = layer.source.wave;
+    assign(oscillator.frequency, layer.source.frequency, time);
+    rampTo(oscillator.frequency, layer.source.frequency, time);
+  }
+  const envelope = context.createGain();
+  applyEnvelope(envelope.gain, layer.envelope, time);
+  oscillator.connect(envelope);
+  envelope.connect(outputStage2(plan, layer, target));
+  oscillator.start(time);
+  oscillator.stop(end2(layer, time));
+  return [oscillator];
+}
+function realizeVoiceLayer(plan, layer, target) {
+  const source = layer.source;
+  if (source.kind !== "formant_voice") return [];
+  const { context } = target;
+  const time = target.time + layer.at;
+  const oscillator = context.createOscillator();
+  oscillator.type = source.wave;
+  assign(oscillator.frequency, source.frequency, time);
+  rampTo(oscillator.frequency, source.frequency, time);
+  const vibrato = context.createOscillator();
+  vibrato.frequency.value = source.vibrato.rate;
+  const vibratoDepth = gainNode(context, source.vibrato.depth);
+  vibrato.connect(vibratoDepth);
+  vibratoDepth.connect(oscillator.frequency);
+  const formants = source.formants.map((formant) => filterNode(context, { type: "bandpass", frequency: { value: formant.frequency }, q: formant.q }, time));
+  const breath = noiseSource(target, true);
+  const breathBand = filterNode(context, { type: "bandpass", frequency: { value: source.breath.frequency }, q: source.breath.q }, time);
+  const breathLevel = gainNode(context, source.breath.gain);
+  const 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 envelope = context.createGain();
+  applyEnvelope(envelope.gain, layer.envelope, time);
+  mix.connect(envelope);
+  envelope.connect(outputStage2(plan, layer, target));
+  const stop = end2(layer, time);
+  oscillator.start(time);
+  vibrato.start(time);
+  breath.start(time, source.breath.offset);
+  oscillator.stop(stop);
+  vibrato.stop(stop);
+  breath.stop(stop);
+  return [oscillator, vibrato, breath];
+}
+function realizeLayered(plan, target) {
+  const sources = plan.layers.flatMap((layer) => {
+    if (layer.source.kind === "noise") return realizeNoiseLayer(plan, layer, target);
+    if (layer.source.kind === "osc") return realizeToneLayer(plan, layer, target);
+    return realizeVoiceLayer(plan, layer, target);
+  });
+  return voiceOf(sources);
+}
+function realizeSiren(plan, target) {
+  const { context } = target;
+  const layer = plan.layers[0];
+  const time = target.time + layer.at;
+  const oscillator = context.createOscillator();
+  if (layer.source.kind === "osc") {
+    oscillator.type = layer.source.wave;
+    assign(oscillator.frequency, layer.source.frequency, time);
+    rampTo(oscillator.frequency, layer.source.frequency, time);
+  }
+  const depths = layer.modulators.map((modulator) => {
+    const lfo = context.createOscillator();
+    if (modulator.wave) lfo.type = modulator.wave;
+    lfo.frequency.value = modulator.rate;
+    const depth = gainNode(context, modulator.depth);
+    lfo.connect(depth);
+    if (modulator.target === "frequency") depth.connect(oscillator.frequency);
+    return { lfo, depth, target: modulator.target };
+  });
+  const lfos = depths.map(({ lfo }) => lfo);
+  const envelope = context.createGain();
+  applyEnvelope(envelope.gain, layer.envelope, time);
+  for (const { depth, target: modulated } of depths) if (modulated === "gain") depth.connect(envelope.gain);
+  const filters = (layer.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+  let tail = oscillator;
+  for (const filter of filters) tail = tail.connect(filter);
+  tail.connect(envelope);
+  envelope.connect(target.output);
+  if (layer.wet && target.wet) {
+    const send = gainNode(context, layer.wet);
+    envelope.connect(send);
+    send.connect(target.wet);
+  }
+  const stop = end2(layer, time);
+  oscillator.start(time);
+  for (const lfo of lfos) lfo.start(time);
+  oscillator.stop(stop);
+  for (const lfo of lfos) lfo.stop(stop);
+  return voiceOf([oscillator, ...lfos]);
+}
+
+// src/webaudio/realize-weapon.ts
+function noiseLayer(layer, target, time) {
+  const { context } = target;
+  const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+  const filters = (layer.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+  const envelope = context.createGain();
+  applyEnvelope(envelope.gain, layer.envelope, time);
+  let tail = source;
+  for (const filter of filters) tail = tail.connect(filter);
+  tail.connect(envelope).connect(target.output);
+  source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
+  source.stop(time + layer.duration + layer.tail);
+  return source;
+}
+function toneLayer(layer, target, time) {
+  const { context } = target;
+  const oscillator = context.createOscillator();
+  if (layer.source.kind === "osc") {
+    oscillator.type = layer.source.wave;
+    assign(oscillator.frequency, layer.source.frequency, time);
+    rampTo(oscillator.frequency, layer.source.frequency, time);
+  }
+  const envelope = context.createGain();
+  applyEnvelope(envelope.gain, layer.envelope, time);
+  oscillator.connect(envelope).connect(target.output);
+  oscillator.start(time);
+  oscillator.stop(time + layer.duration + layer.tail);
+  return oscillator;
+}
+function realizeWeapon(plan, target) {
+  const sources = plan.layers.map((layer) => {
+    const time = target.time + layer.at;
+    return layer.source.kind === "noise" ? noiseLayer(layer, target, time) : toneLayer(layer, target, time);
+  });
+  return voiceOf(sources);
+}
+
+// src/webaudio/realize.ts
+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);
+}
+
+// src/variation.ts
+var tuneAutomation = (automation, rate) => {
+  const tuned = { ...automation };
+  if (automation.value !== void 0) tuned.value = automation.value * rate;
+  if (automation.from !== void 0) tuned.from = automation.from * rate;
+  if (automation.to !== void 0) tuned.to = automation.to * rate;
+  if (automation.at !== void 0) tuned.at = automation.at / rate;
+  return tuned;
+};
+var tuneFilter = (filter, rate) => ({ ...filter, frequency: tuneAutomation(filter.frequency, rate) });
+var tuneSource = (source, rate) => {
+  switch (source.kind) {
+    case "noise":
+      return source;
+    case "osc":
+      return { ...source, frequency: tuneAutomation(source.frequency, rate) };
+    case "formant_voice":
+      return {
+        ...source,
+        frequency: tuneAutomation(source.frequency, rate),
+        formants: source.formants.map((formant) => ({ ...formant, frequency: formant.frequency * rate })),
+        breath: { ...source.breath, frequency: source.breath.frequency * rate }
+      };
+  }
+};
+var tuneModulator = (modulator, rate) => ({
+  ...modulator,
+  rate: modulator.rate * rate,
+  ...modulator.target === "frequency" ? { depth: modulator.depth * rate } : {}
+});
+var tuneLayer = (layer, rate) => ({
+  ...layer,
+  at: layer.at / rate,
+  duration: layer.duration / rate,
+  tail: layer.tail / rate,
+  source: tuneSource(layer.source, rate),
+  ...layer.filters ? { filters: { ...layer.filters, bank: layer.filters.bank.map((filter) => tuneFilter(filter, rate)) } } : {},
+  modulators: layer.modulators.map((modulator) => tuneModulator(modulator, rate)),
+  envelope: layer.envelope.map((point) => ({ ...point, time: point.time / rate }))
+});
+function retunePlan(plan, rate) {
+  if (rate === 1 || !(rate > 0)) return plan;
+  return { ...plan, length: plan.length / rate, layers: plan.layers.map((layer) => tuneLayer(layer, rate)) };
+}
+function createSetPicker() {
+  const last = /* @__PURE__ */ new Map();
+  return {
+    pick(set, random) {
+      const count = set.variants.length;
+      const previous = last.get(set.id);
+      let index;
+      if (count === 1) index = 0;
+      else if (set.repeat || previous === void 0) index = Math.min(count - 1, Math.floor(random() * count));
+      else {
+        index = Math.min(count - 2, Math.floor(random() * (count - 1)));
+        if (index >= previous) index += 1;
+      }
+      last.set(set.id, index);
+      const [min, max] = set.rate ?? [1, 1];
+      const rate = min === max ? min : min + random() * (max - min);
+      return { id: set.variants[index], rate };
+    },
+    reset: () => last.clear()
+  };
+}
+
+// src/webaudio/sample-store.ts
+function fetchLoader(baseUrl) {
+  return async (url2) => {
+    const target = baseUrl ? new URL(url2, baseUrl).toString() : url2;
+    const response = await fetch(target);
+    if (!response.ok) throw new Error(`${response.status} ${response.statusText} for ${target}`);
+    return response.arrayBuffer();
+  };
+}
+function inlineLoader(files) {
+  return async (url2) => {
+    const text = files[url2];
+    if (text === void 0) throw new Error(`no inline file for ${url2}`);
+    const base64 = text.startsWith("data:") ? text.slice(text.indexOf(",") + 1) : text;
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+    return bytes.buffer;
+  };
+}
+var decode = (context, bytes) => new Promise((resolve, reject) => {
+  const result = context.decodeAudioData(bytes, resolve, reject);
+  result?.catch?.(reject);
+});
+function createSampleStore(loader = fetchLoader()) {
+  const buffers = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Map();
+  let generation = 0;
+  const loadOne = (url2, context) => {
+    const existing = buffers.get(url2);
+    if (existing) return Promise.resolve(existing);
+    const inFlight = pending.get(url2);
+    if (inFlight) return inFlight;
+    const started = generation;
+    failed.delete(url2);
+    const promise = loader(url2).then((bytes) => decode(context, bytes)).then((buffer) => {
+      if (started === generation) buffers.set(url2, buffer);
+      return buffer;
+    }).catch((error) => {
+      if (started === generation) failed.set(url2, error instanceof Error ? error.message : String(error));
+      throw error;
+    }).finally(() => {
+      if (pending.get(url2) === promise) pending.delete(url2);
+    });
+    pending.set(url2, promise);
+    return promise;
+  };
+  return {
+    status(url2) {
+      if (buffers.has(url2)) return "ready";
+      if (pending.has(url2)) return "loading";
+      if (failed.has(url2)) return "failed";
+      return "none";
+    },
+    buffer: (url2) => buffers.get(url2),
+    ready: (urls) => urls.every((url2) => buffers.has(url2)),
+    seconds: (url2) => buffers.get(url2)?.duration,
+    async load(urls, context) {
+      const results = await Promise.allSettled(urls.map((url2) => loadOne(url2, context)));
+      const loaded = [];
+      const errors = [];
+      results.forEach((result, index) => {
+        const url2 = urls[index];
+        if (result.status === "fulfilled") loaded.push(url2);
+        else errors.push({ url: url2, error: result.reason instanceof Error ? result.reason.message : String(result.reason) });
+      });
+      return { loaded, failed: errors };
+    },
+    clear() {
+      generation++;
+      buffers.clear();
+      pending.clear();
+      failed.clear();
+    }
+  };
+}
+
+// src/webaudio/realize-sample.ts
+function realizeSample(plan, target) {
+  const context = target.context;
+  let head = target.output;
+  if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
+    const panner = context.createStereoPanner();
+    panner.pan.value = plan.pan;
+    panner.connect(head);
+    head = panner;
+  }
+  if (plan.cutoff < OPEN_CUTOFF) {
+    const lowpass = context.createBiquadFilter();
+    lowpass.type = "lowpass";
+    lowpass.frequency.value = plan.cutoff;
+    lowpass.Q.value = 0.7;
+    lowpass.connect(head);
+    head = lowpass;
+  }
+  const voice = context.createGain();
+  voice.connect(head);
+  head = voice;
+  const sources = [];
+  for (const layer of plan.layers) {
+    const buffer = target.buffer(layer.url);
+    if (!buffer) continue;
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    source.playbackRate.value = layer.rate;
+    const gain = gainNode(context, layer.gain);
+    source.connect(gain);
+    gain.connect(head);
+    source.start(target.time + layer.at);
+    sources.push(source);
+  }
+  const realized = voiceOf(sources);
+  return {
+    ...realized,
+    fade(at, seconds) {
+      voice.gain.setValueAtTime(1, at);
+      voice.gain.linearRampToValueAtTime(0, at + seconds);
+      for (const source of sources) {
+        try {
+          source.stop(at + seconds);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function sampleLength(plan, seconds) {
+  let length = 0;
+  for (const layer of plan.layers) length = Math.max(length, layer.at + (seconds(layer.url) ?? 0) / layer.rate);
+  return length;
+}
+
+// src/webaudio/engine.ts
+function limiterCurve2(knee, ceiling, range, points = 2049) {
+  const curve = new Float32Array(points);
+  const room = Math.max(1e-6, ceiling - knee);
+  for (let index = 0; index < points; index++) {
+    const value = (index / (points - 1) * 2 - 1) * range;
+    const size = Math.abs(value);
+    const bent = size <= knee ? size : knee + room * Math.tanh((size - knee) / room);
+    curve[index] = Math.sign(value) * bent;
+  }
+  return curve;
+}
+var usesNoise = (recipe) => recipe.layers.some((layer) => layer.source.kind !== "osc");
+var planUsesNoise = (plan) => plan.layers.some((layer) => layer.source.kind !== "osc");
+function createAudioEngine(options = {}) {
+  const seed = options.seed ?? 1;
+  const registry = createSoundRegistry(options.banks);
+  const voices = createVoiceManager({ ...options.groups ? { groups: options.groups } : {}, ...options.maxVoices === void 0 ? {} : { maxVoices: options.maxVoices } });
+  const engineRandom = createRng(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;
+  let environment = options.environment ?? "outdoor";
+  const sampleLimiters = /* @__PURE__ */ new Map();
+  const sampleOutput = (bus) => {
+    const setting = options.samples?.limiter;
+    if (setting === false || !context) return outputFor(bus);
+    const existing = sampleLimiters.get(bus);
+    if (existing) return existing;
+    const range = 4;
+    const input = context.createGain();
+    input.gain.value = 1 / range;
+    const shaper = context.createWaveShaper();
+    shaper.curve = limiterCurve2(setting?.knee ?? 0.5, setting?.ceiling ?? 0.891, range);
+    ensureBus(bus);
+    input.connect(shaper);
+    shaper.connect(outputFor(bus));
+    sampleLimiters.set(bus, input);
+    return input;
+  };
+  const chokes = /* @__PURE__ */ new Map();
+  const choked = (id) => {
+    const list = (chokes.get(id) ?? []).filter((entry) => active.has(entry.id));
+    chokes.set(id, list);
+    return list;
+  };
+  const watchers = /* @__PURE__ */ new Set();
+  const announce = (event) => {
+    options.onVoiceStart?.(event);
+    for (const watcher of watchers) watcher(event);
+  };
+  const sources = [];
+  const baseLoader = options.samples?.loader ?? fetchLoader(options.samples?.baseUrl);
+  const sampleStore = createSampleStore((url2) => (sources.find((source) => source.accepts(url2))?.loader ?? baseLoader)(url2));
+  const memory = /* @__PURE__ */ new Map();
+  const latencyOf = (audio) => {
+    const live = audio;
+    return (live.baseLatency ?? 0) + (live.outputLatency ?? 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 startQueue = options.deferredStart ? createStartQueue(options.deferredStart) : null;
+  const build = (plan, store, delay, requestedAt, fallbackOf) => {
+    const audio = context;
+    const time = audio.currentTime + delay;
+    const realized = realize(plan, {
+      context: audio,
+      output: outputFor(plan.bus),
+      ...chain?.wet ? { wet: chain.wet } : {},
+      noise: () => noiseBuffer(store, audio, mix.noise.seconds),
+      time
+    });
+    const recipeBank = registry.bankOf(plan.id);
+    announce({
+      id: plan.id,
+      kind: "recipe",
+      ...fallbackOf ? { fallbackOf } : {},
+      ...recipeBank ? { bank: recipeBank } : {},
+      requestedAt,
+      startAt: time,
+      outputLatency: latencyOf(audio),
+      level: plan.level,
+      distance: plan.distance,
+      ...plan.pan === void 0 ? {} : { pan: plan.pan }
+    });
+    return realized;
+  };
+  const deferVoice = (plan, store, voiceId, delay, fallbackOf) => {
+    const requestedAt = context?.currentTime ?? 0;
+    let built = null;
+    let cancelled = false;
+    const pending = {
+      get sources() {
+        return built?.sources ?? [];
+      },
+      stop() {
+        cancelled = true;
+        built?.stop();
+      }
+    };
+    startQueue.push({
+      run() {
+        if (!cancelled && context) built = build(plan, store, delay, requestedAt, fallbackOf);
+      },
+      drop() {
+        if (voiceId === void 0) return;
+        voices.release(voiceId);
+        active.delete(voiceId);
+      }
+    });
+    return pending;
+  };
+  const start = (plan, store, voiceId, delay = 0, fallbackOf, urgent = false) => {
+    const realized = startQueue && !urgent ? deferVoice(plan, store, voiceId, delay, fallbackOf) : build(plan, store, delay, context?.currentTime ?? 0, fallbackOf);
+    if (voiceId === void 0) return null;
+    voices.setLength(voiceId, plan.length + delay);
+    active.set(voiceId, realized);
+    return {
+      id: voiceId,
+      kind: "recipe",
+      plan,
+      stop() {
+        realized.stop();
+        voices.release(voiceId);
+        active.delete(voiceId);
+      }
+    };
+  };
+  const admit = (recipe, gain, distance) => {
+    const decision = voices.request({ ...recipe.group ? { group: recipe.group } : {}, priority: recipe.priority ?? busPriority(recipe.bus), gain, distance, length: 0 });
+    if (!decision.accepted) return null;
+    for (const id of decision.evicted) {
+      active.get(id)?.stop();
+      active.delete(id);
+    }
+    return decision.id;
+  };
+  const picker = createSetPicker();
+  const resolve = (id, random, chooser = picker) => {
+    if (registry.sound(id)) return { id, rate: 1 };
+    const set = registry.set(id);
+    return set ? chooser.pick(set, random) : { id, rate: 1 };
+  };
+  const loadSounds = (sounds) => {
+    const audio = ready();
+    if (!audio) return Promise.resolve({ loaded: [], failed: sounds.flatMap(sampleUrls).map((url2) => ({ url: url2, error: "no audio context" })) });
+    return sampleStore.load([...new Set(sounds.flatMap(sampleUrls))], audio);
+  };
+  const sampleInput = (playOptions, random, withMemory) => ({
+    random,
+    listener,
+    environment: playOptions.environment ?? environment,
+    ...withMemory ? { memory } : {},
+    ...options.distance ? { distanceMode: options.distance } : {},
+    ...playOptions.volume === void 0 ? {} : { volume: playOptions.volume },
+    ...playOptions.intensity === void 0 ? {} : { intensity: playOptions.intensity },
+    ...playOptions.distance === void 0 ? {} : { distance: playOptions.distance },
+    ...playOptions.position ? { position: playOptions.position } : {},
+    ...playOptions.occlusion !== void 0 ? { occlusion: playOptions.occlusion } : options.occlusion && playOptions.position ? { occlusion: options.occlusion(playOptions.position) } : {}
+  });
+  const playSample = (sample, playOptions, random, store) => {
+    if (busSettings.get(sample.bus)?.muted) return null;
+    if (!sampleStore.ready(sampleUrls(sample))) {
+      if (options.samples?.autoLoad !== false && ready()) void loadSounds([sample]).catch(() => void 0);
+      if (sample.fallback && sample.fallback !== sample.id) return playWith(sample.fallback, playOptions, random, store, sample.id);
+      return registry.sound(sample.id) ? void 0 : null;
+    }
+    const plan = planSample(sample, sampleInput(playOptions, playOptions.seed === void 0 ? random : createRng(playOptions.seed), true));
+    if (!plan) return null;
+    const audio = ready();
+    if (!audio) return null;
+    unlockContext(audio);
+    advance();
+    const voiceId = admit(plan, plan.level, plan.distance);
+    if (voiceId === null) return null;
+    const requestedAt = audio.currentTime;
+    const time = requestedAt + (playOptions.delay ?? 0);
+    const chokeList = sample.choke ? choked(sample.id) : void 0;
+    const realized = realizeSample(plan, { context: audio, output: sampleOutput(plan.bus), buffer: (url2) => sampleStore.buffer(url2), time });
+    const sampleBank = registry.bankOf(plan.id);
+    announce({
+      id: plan.id,
+      kind: "sample",
+      ...sampleBank ? { bank: sampleBank } : {},
+      requestedAt,
+      startAt: time,
+      outputLatency: latencyOf(audio),
+      level: plan.level,
+      distance: plan.distance,
+      ...plan.pan === void 0 ? {} : { pan: plan.pan },
+      layers: plan.layers.map((layer) => ({ role: layer.role, url: layer.url, take: layer.take, rate: layer.rate })),
+      ...plan.tier ? { tier: plan.tier } : {}
+    });
+    voices.setLength(voiceId, sampleLength(plan, (url2) => sampleStore.seconds(url2)) + (playOptions.delay ?? 0));
+    active.set(voiceId, realized);
+    if (chokeList && sample.choke) {
+      chokeList.push({ id: voiceId, voice: realized });
+      while (chokeList.length > Math.max(1, sample.choke.voices)) {
+        const oldest = chokeList.shift();
+        if (!oldest) break;
+        oldest.voice.fade(time, sample.choke.fade ?? 0.03);
+        voices.release(oldest.id);
+        active.delete(oldest.id);
+      }
+    }
+    return {
+      id: voiceId,
+      kind: "sample",
+      plan,
+      stop() {
+        realized.stop();
+        voices.release(voiceId);
+        active.delete(voiceId);
+      }
+    };
+  };
+  const playWith = (asked, playOptions, streamRandom, store, fallbackOf) => {
+    const sample = fallbackOf === void 0 ? registry.sample(asked) : void 0;
+    if (sample) {
+      const played = playSample(sample, playOptions, streamRandom, store);
+      if (played !== void 0) return played;
+    }
+    const seeded = playOptions.seed === void 0 ? null : createRng(playOptions.seed);
+    const { id, rate } = resolve(asked, seeded ?? streamRandom);
+    const random = seeded ?? streamRandom;
+    const recipe = registry.sound(id);
+    if (!recipe || busSettings.get(recipe.bus)?.muted) return null;
+    const distance = playOptions.distance ?? (playOptions.position ? listenerDistance(listener, playOptions.position, options.distance) : 0);
+    const level = falloffGain(recipe.falloff, playOptions.volume ?? 1, distance);
+    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, distance);
+    if (voiceId === null) return null;
+    if (!silent && usesNoise(recipe)) prepareNoise(store, audio, mix.noise.seconds);
+    const plan = planSound(recipe, inputFor(recipe, playOptions, random));
+    return plan ? start(retunePlan(plan, rate), store, voiceId, playOptions.delay, fallbackOf, playOptions.urgent) : 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 = (asked, playOptions, random) => {
+    const { id, rate } = resolve(asked, random, createSetPicker());
+    const recipe = registry.sound(id);
+    const plan = recipe ? planSound(recipe, inputFor(recipe, playOptions, random)) : null;
+    return plan ? retunePlan(plan, rate) : 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),
+    listener: () => listener,
+    ...options.distance ? { distance: options.distance } : {}
+  };
+  return {
+    registry,
+    register: (bank) => registry.register(bank),
+    plan: (id, playOptions = {}) => planWith(id, playOptions, createRng(playOptions.seed ?? seed)),
+    planSample(id, playOptions = {}) {
+      const sample = registry.sample(id);
+      return sample ? planSample(sample, sampleInput(playOptions, createRng(playOptions.seed ?? seed), false)) : null;
+    },
+    loadSamples(ids) {
+      const chosen = (ids ?? registry.sampleIds()).map((id) => registry.sample(id)).filter((sample) => sample !== void 0);
+      return loadSounds(chosen);
+    },
+    sampleStatus(id) {
+      const sample = registry.sample(id);
+      if (!sample) return "none";
+      const statuses = sampleUrls(sample).map((url2) => sampleStore.status(url2));
+      if (statuses.every((status) => status === "ready")) return "ready";
+      if (statuses.includes("failed")) return "failed";
+      if (statuses.includes("loading")) return "loading";
+      return statuses.includes("ready") ? "loading" : "none";
+    },
+    setEnvironment(next) {
+      environment = next;
+    },
+    output: () => chain?.master ?? null,
+    addSampleSource(accepts, loader) {
+      sources.push({ accepts, loader });
+    },
+    watchVoices(listener2) {
+      watchers.add(listener2);
+      return () => void watchers.delete(listener2);
+    },
+    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 = {}) {
+      const sample = registry.sample(id);
+      if (!sample?.loop) return createLoopHandle(registry.loop(id), loopHost, loopOptions.volume);
+      return createSampleLoopHandle(
+        sample,
+        {
+          ready,
+          output: sampleOutput,
+          buffer: (url2) => sampleStore.buffer(url2),
+          isReady: (sound) => sampleStore.ready(sampleUrls(sound)),
+          load: (sound) => options.samples?.autoLoad === false ? Promise.resolve() : loadSounds([sound]),
+          fallback: (volume) => createLoopHandle(registry.loop(sample.fallback ?? sample.id) ?? registry.loop(sample.id), loopHost, volume),
+          random: engineRandom,
+          register: loopHost.register,
+          unregister: loopHost.unregister,
+          muted: (bus) => busSettings.get(bus)?.muted === true
+        },
+        loopOptions.volume
+      );
+    },
+    channel(channelOptions) {
+      const random = channelOptions.random ?? (channelOptions.seed === void 0 ? engineRandom : createRng(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, createRng(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);
+    },
+    warmUp() {
+      const audio = ready();
+      if (!audio) return false;
+      noiseBuffer(shared, audio, mix.noise.seconds);
+      return true;
+    },
+    level(bus) {
+      watched.add(bus);
+      ensureBus(bus);
+      const meter = meterOf(bus);
+      if (!meter) return 0;
+      meter.analyser.getFloatTimeDomainData(meter.data);
+      let sum = 0;
+      for (const sample of meter.data) sum += sample * sample;
+      return Math.sqrt(sum / meter.data.length);
+    },
+    deferredQueue: () => startQueue?.deferredQueue() ?? null,
+    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() {
+      startQueue?.clear();
+      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();
+      sampleStore.clear();
+      memory.clear();
+      sampleLimiters.clear();
+      chokes.clear();
+    }
+  };
+}
+
+// src/bench/locale.ts
+var EN = {
+  group: "Sound",
+  name: "Sound area",
+  probe: "Sound probe",
+  controls: {
+    sound: "Sound",
+    distance: "Distance",
+    bearing: "Bearing",
+    volume: "Volume",
+    mix: "Mixing chain",
+    seed: "Seed",
+    play: "Play",
+    voice_storm: "Voice storm",
+    loop: "Loop",
+    loop_level: "Loop level",
+    loop_pitch: "Loop pitch",
+    source: "Source"
+  },
+  hints: {
+    distance: "Metres from the listener: the level falls and the sound is muffled with it.",
+    bearing: "Degrees from straight ahead, positive to the right: shows the panning.",
+    mix: "The game chain (master only) or the art scene chain (compressor and reverb).",
+    seed: "The same seed gives the same sound.",
+    voice_storm: "Twenty of the chosen sound at once: the voice limiter drops what its group and the global cap refuse.",
+    loop_pitch: "Frequency of an oscillator loop, in hertz (0 leaves it where it is).",
+    source: "Where the sound comes from: the distance and bearing set here, or the probe standing in the area."
+  },
+  options: { none: "None", bench: "Bench settings", probe: "The probe" },
+  layers: { reverb: "Reverb", compressor: "Compressor", panning: "Panning", muffling: "Muffling by distance" },
+  metrics: {
+    voices: "Voices playing",
+    peak: "Most voices at once",
+    dropped: "Voices dropped",
+    loops: "Loops running",
+    context: "Audio context",
+    plan_length: "Chosen sound: length",
+    plan_level: "Chosen sound: level",
+    plan_pan: "Chosen sound: pan",
+    level_weapons: "Level: weapons",
+    level_voices: "Level: voices",
+    level_world: "Level: world",
+    level_ambience: "Level: ambience",
+    level_weather: "Level: weather",
+    level_ui: "Level: interface"
+  },
+  scenarios: {
+    panning: "A sound to the right is heard on the right, one to the left on the left, one ahead in the middle",
+    distance: "The farther a sound, the quieter, until it is not played",
+    determinism: "The same seed gives the same sound plan, another seed another one",
+    limiter: "The voice limiter holds a storm of voices to its group rule and its global cap"
+  },
+  mixes: { game: "Game", art_scene: "Art scene", kit: "Kit (art scene + limiter)" },
+  sheet: { title: "Sound plan", level: "level", distance: "distance", pan: "pan", length: "seconds", silent: "too far to be heard", layer: "layer", none: "no sound chosen" }
+};
+var PT_BR = {
+  group: "Som",
+  name: "\xC1rea de som",
+  probe: "Sonda de som",
+  controls: {
+    sound: "Som",
+    distance: "Dist\xE2ncia",
+    bearing: "Dire\xE7\xE3o",
+    volume: "Volume",
+    mix: "Cadeia de mixagem",
+    seed: "Semente",
+    play: "Tocar",
+    voice_storm: "Tempestade de vozes",
+    loop: "La\xE7o",
+    loop_level: "N\xEDvel do la\xE7o",
+    loop_pitch: "Altura do la\xE7o",
+    source: "Origem"
+  },
+  hints: {
+    distance: "Metros at\xE9 o ouvinte: o n\xEDvel cai e o som abafa junto.",
+    bearing: "Graus a partir da frente, positivo para a direita: mostra o pan.",
+    mix: "A cadeia do jogo (s\xF3 o master) ou a da Cena de Arte (compressor e reverb).",
+    seed: "A mesma semente d\xE1 o mesmo som.",
+    voice_storm: "Vinte do som escolhido de uma vez: o limite de vozes derruba o que a regra do grupo e o teto global recusam.",
+    loop_pitch: "Frequ\xEAncia de um la\xE7o de oscilador, em hertz (0 deixa onde est\xE1).",
+    source: "De onde vem o som: a dist\xE2ncia e a dire\xE7\xE3o daqui, ou a sonda que est\xE1 na \xE1rea."
+  },
+  options: { none: "Nenhum", bench: "Ajustes da bancada", probe: "A sonda" },
+  layers: { reverb: "Reverb", compressor: "Compressor", panning: "Pan", muffling: "Abafamento pela dist\xE2ncia" },
+  metrics: {
+    voices: "Vozes tocando",
+    peak: "Mais vozes de uma vez",
+    dropped: "Vozes derrubadas",
+    loops: "La\xE7os ligados",
+    context: "Contexto de \xE1udio",
+    plan_length: "Som escolhido: dura\xE7\xE3o",
+    plan_level: "Som escolhido: n\xEDvel",
+    plan_pan: "Som escolhido: pan",
+    level_weapons: "N\xEDvel: armas",
+    level_voices: "N\xEDvel: vozes",
+    level_world: "N\xEDvel: mundo",
+    level_ambience: "N\xEDvel: ambiente",
+    level_weather: "N\xEDvel: clima",
+    level_ui: "N\xEDvel: interface"
+  },
+  scenarios: {
+    panning: "Um som \xE0 direita sai \xE0 direita, \xE0 esquerda sai \xE0 esquerda, \xE0 frente sai no meio",
+    distance: "Quanto mais longe, mais baixo, at\xE9 n\xE3o tocar",
+    determinism: "A mesma semente d\xE1 o mesmo plano de som, outra semente d\xE1 outro",
+    limiter: "O limite de vozes segura uma tempestade de vozes na regra do grupo e no teto global"
+  },
+  mixes: { game: "Jogo", art_scene: "Cena de Arte", kit: "Kit (Cena de Arte + limitador)" },
+  sheet: { title: "Plano do som", level: "n\xEDvel", distance: "dist\xE2ncia", pan: "pan", length: "segundos", silent: "longe demais para ouvir", layer: "camada", none: "nenhum som escolhido" }
+};
+var audioBenchTextOf = (locale) => locale === "en" ? EN : PT_BR;
+
+// src/bench/module.ts
+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"]
+    }
+  ]
+};
+var DISTANCES = [0, 10, 40, 60, 120, 160];
+var STORM = 20;
+var PROBE_ID = "audio_probe";
+var PROBE_AT = [0, 0, -10];
+var NONE = "none";
+var DEFAULT_SOUND = "bench_ping";
+var variantOf = (profile, reverb, compressor) => {
+  const { reverb: wet, compressor: chain, ...rest } = profile;
+  return { ...rest, id: `${profile.id}${reverb ? "" : "+dry"}${compressor ? "" : "+open"}`, ...wet && reverb ? { reverb: wet } : {}, ...chain && compressor ? { compressor: chain } : {} };
+};
+function createAudioTestModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const text = audioBenchTextOf(locale);
+  const banks = [BENCH_BANK, ...options.banks ?? [GAME_SFX_BANK, LIBRARY_BANK]];
+  let engine = options.engine ?? createAudioEngine({ seed: options.seed ?? 1, banks });
+  for (const bank of banks) engine.register(bank);
+  let host = null;
+  let loop;
+  const state = {
+    sound: options.sound ?? DEFAULT_SOUND,
+    distance: 10,
+    bearing: 0,
+    volume: 1,
+    mix: DEFAULT_MIX,
+    seed: options.seed ?? 1,
+    source: "bench",
+    loop: NONE,
+    loopLevel: 0.1,
+    loopPitch: 0,
+    reverb: true,
+    compressor: true,
+    panning: true,
+    muffling: true
+  };
+  const nameOf = (id) => {
+    const translated = options.translate?.(`sound.${id}`, locale);
+    if (translated) return translated;
+    const bank = engine.registry.bankOf(id);
+    return bank ? `${bank} / ${id}` : id;
+  };
+  const soundOptions = () => engine.registry.soundIds().map((id) => ({ id, name: nameOf(id) }));
+  const loopOptions = () => [{ id: NONE, name: text.options.none }, ...engine.registry.loopIds().map((id) => ({ id, name: nameOf(id) }))];
+  const listener = () => {
+    const camera = host?.camera;
+    const three = host?.THREE;
+    if (typeof camera?.getWorldDirection !== "function" || typeof three?.Vector3 !== "function" || !camera.position) return { position: [0, 0, 0], yaw: 0 };
+    const direction = camera.getWorldDirection(new three.Vector3());
+    return { position: [camera.position.x, camera.position.y, camera.position.z], yaw: Math.atan2(-direction.x, -direction.z) };
+  };
+  const probePosition = () => {
+    const scene = host?.scene;
+    const three = host?.THREE;
+    if (typeof scene?.traverse !== "function" || typeof three?.Vector3 !== "function") return void 0;
+    let found;
+    scene.traverse((object) => {
+      if (found || object.userData?.[PROBE_ID] !== true) return;
+      const at = object.getWorldPosition(new three.Vector3());
+      found = [at.x, at.y, at.z];
+    });
+    return found;
+  };
+  const sourceAt = (ears) => {
+    const probe = state.source === "probe" ? probePosition() : void 0;
+    if (probe) return probe;
+    const bearing = state.bearing * Math.PI / 180;
+    const forward = [-Math.sin(ears.yaw), -Math.cos(ears.yaw)];
+    const right = [Math.cos(ears.yaw), -Math.sin(ears.yaw)];
+    return [ears.position[0] + state.distance * (forward[0] * Math.cos(bearing) + right[0] * Math.sin(bearing)), ears.position[1], ears.position[2] + state.distance * (forward[1] * Math.cos(bearing) + right[1] * Math.sin(bearing))];
+  };
+  const playOptions = () => {
+    const ears = listener();
+    engine.setListener(ears);
+    const at = sourceAt(ears);
+    const distance = Math.hypot(at[0] - ears.position[0], at[2] - ears.position[2]);
+    return { ...state.panning ? { position: at } : { distance }, volume: state.volume, seed: state.seed };
+  };
+  const withMuffling = (id, run) => {
+    const falloff = engine.registry.sound(id)?.falloff;
+    if (state.muffling || !falloff || falloff.model !== "inverse_square" || falloff.cutoffK === void 0) return run();
+    engine.registry.patch(id, { falloff: { cutoffK: 0 } });
+    try {
+      return run();
+    } finally {
+      engine.registry.patch(id, { falloff: { cutoffK: falloff.cutoffK } });
+    }
+  };
+  const play = () => {
+    engine.unlock();
+    const chosen = state.sound;
+    return withMuffling(chosen, () => engine.play(chosen, playOptions()));
+  };
+  const plan = () => {
+    const chosen = state.sound;
+    return withMuffling(chosen, () => engine.plan(chosen, playOptions()));
+  };
+  const sheet = () => {
+    const planned = plan();
+    if (!planned) return `${text.sheet.title}: ${engine.registry.sound(state.sound) ? text.sheet.silent : text.sheet.none}`;
+    const head = `${text.sheet.title}: ${planned.id} (${planned.bus}) ${text.sheet.level} ${planned.level.toFixed(4)} ${text.sheet.distance} ${planned.distance.toFixed(1)} m${planned.pan === void 0 ? "" : ` ${text.sheet.pan} ${planned.pan.toFixed(3)}`} ${planned.length.toFixed(3)} ${text.sheet.length}`;
+    const layers2 = planned.layers.map((layer, index) => {
+      const source = layer.source.kind === "noise" ? `noise@${layer.source.offset.toFixed(4)}` : layer.source.kind === "osc" ? `${layer.source.wave}@${layer.source.frequency.value ?? layer.source.frequency.from}` : layer.source.kind;
+      const filters = (layer.filters?.bank ?? []).map((filter) => `${filter.type}@${(filter.frequency.value ?? filter.frequency.from ?? 0).toFixed(1)}`).join(" ");
+      const envelope = layer.envelope.map((point) => `${point.time.toFixed(3)}:${point.value.toPrecision(3)}`).join(" ");
+      return `  ${text.sheet.layer} ${index + 1}: ${source} at ${layer.at.toFixed(3)} for ${layer.duration.toFixed(3)} ${filters} [${envelope}]`;
+    });
+    return [head, ...layers2].join("\n");
+  };
+  const applyMix = () => {
+    const profile = engine && MIX_PROFILES[state.mix];
+    if (profile) engine.setMix(variantOf(profile, state.reverb, state.compressor));
+  };
+  const setLoop = () => {
+    loop?.stop();
+    loop = void 0;
+    if (state.loop === NONE) return;
+    engine.unlock();
+    loop = engine.loop(state.loop);
+    loop.set({ volume: state.loopLevel, ...state.loopPitch > 0 ? { frequency: state.loopPitch } : {} });
+  };
+  const storm = () => {
+    engine.unlock();
+    const base = playOptions();
+    const chosen = state.sound;
+    for (let index = 0; index < STORM; index++) {
+      const spread = base.position ? { position: [base.position[0] + (index - STORM / 2), base.position[1], base.position[2]] } : {};
+      withMuffling(chosen, () => engine.play(chosen, { ...base, ...spread, seed: state.seed + index }));
+    }
+  };
+  const onChange = (change) => {
+    if (change.kind === "layer") {
+      if (change.id === "reverb" || change.id === "compressor") {
+        state[change.id] = change.on;
+        applyMix();
+      } else if (change.id === "panning" || change.id === "muffling") state[change.id] = change.on;
+      return;
+    }
+    if (change.kind === "action") {
+      if (change.id === "play") play();
+      else if (change.id === "voice_storm") storm();
+      return;
+    }
+    const { id, value } = change;
+    if (id === "sound" && typeof value === "string") state.sound = value;
+    else if (id === "distance" && typeof value === "string") state.distance = Number(value);
+    else if (id === "bearing" && typeof value === "number") state.bearing = value;
+    else if (id === "volume" && typeof value === "number") state.volume = value;
+    else if (id === "seed" && typeof value === "number") state.seed = value;
+    else if (id === "source" && typeof value === "string") state.source = value;
+    else if (id === "mix" && typeof value === "string") {
+      state.mix = value;
+      applyMix();
+    } else if (id === "loop" && typeof value === "string") {
+      state.loop = value;
+      setLoop();
+    } else if (id === "loop_level" && typeof value === "number") {
+      state.loopLevel = value;
+      loop?.set({ volume: value });
+    } else if (id === "loop_pitch" && typeof value === "number") {
+      state.loopPitch = value;
+      if (value > 0) loop?.set({ frequency: value });
+    }
+  };
+  const items = () => {
+    const probe = options.probe;
+    if (!probe) return [];
+    return [
+      {
+        id: PROBE_ID,
+        name: text.probe,
+        movable: false,
+        build: (THREE) => {
+          const root = probe(THREE);
+          root.userData = root.userData ?? {};
+          root.userData[PROBE_ID] = true;
+          return root;
+        }
+      }
+    ];
+  };
+  const controls = () => [
+    { kind: "choice", id: "sound", name: text.controls.sound, options: soundOptions(), default: state.sound },
+    { kind: "choice", id: "source", name: text.controls.source, hint: text.hints.source, options: [{ id: "bench", name: text.options.bench }, { id: "probe", name: text.options.probe }], default: state.source },
+    { kind: "choice", id: "distance", name: text.controls.distance, hint: text.hints.distance, options: DISTANCES.map((meters) => ({ id: String(meters), name: `${meters} m` })), default: String(state.distance) },
+    { kind: "number", id: "bearing", name: text.controls.bearing, hint: text.hints.bearing, unit: "\xB0", min: -180, max: 180, step: 15, default: state.bearing },
+    { kind: "number", id: "volume", name: text.controls.volume, min: 0, max: 1, step: 0.05, default: state.volume },
+    { kind: "choice", id: "mix", name: text.controls.mix, hint: text.hints.mix, options: Object.keys(MIX_PROFILES).map((id) => ({ id, name: text.mixes[id] ?? id })), default: state.mix },
+    { kind: "number", id: "seed", name: text.controls.seed, hint: text.hints.seed, min: 1, max: 9999, step: 1, default: state.seed },
+    { kind: "action", id: "play", name: text.controls.play },
+    { kind: "action", id: "voice_storm", name: text.controls.voice_storm, hint: text.hints.voice_storm },
+    { kind: "choice", id: "loop", name: text.controls.loop, options: loopOptions(), default: state.loop },
+    { kind: "number", id: "loop_level", name: text.controls.loop_level, min: 0, max: 0.6, step: 0.01, default: state.loopLevel },
+    { kind: "number", id: "loop_pitch", name: text.controls.loop_pitch, hint: text.hints.loop_pitch, unit: "Hz", min: 0, max: 400, step: 5, default: state.loopPitch }
+  ];
+  const layers = () => ["reverb", "compressor", "panning", "muffling"].map((id) => ({ id, name: text.layers[id] }));
+  const metrics = () => [
+    { id: "voices", name: text.metrics.voices, digits: 0, read: () => engine.stats().voices },
+    { id: "peak", name: text.metrics.peak, digits: 0, max: engine.stats().maxVoices > 0 && Number.isFinite(engine.stats().maxVoices) ? engine.stats().maxVoices : void 0, read: () => engine.stats().peak },
+    { id: "dropped", name: text.metrics.dropped, digits: 0, read: () => engine.stats().dropped },
+    { id: "loops", name: text.metrics.loops, digits: 0, read: () => engine.stats().loops },
+    { id: "context", name: text.metrics.context, read: () => engine.stats().context },
+    { id: "plan_length", name: text.metrics.plan_length, unit: "s", digits: 2, read: () => plan()?.length ?? 0 },
+    { id: "plan_level", name: text.metrics.plan_level, digits: 3, read: () => plan()?.level ?? 0 },
+    { id: "plan_pan", name: text.metrics.plan_pan, digits: 2, read: () => plan()?.pan ?? 0 },
+    ...BUS_IDS.map((bus) => ({ id: `level_${bus}`, name: text.metrics[`level_${bus}`], digits: 3, read: () => engine.level(bus) }))
+  ];
+  const scenarios = () => [
+    {
+      id: "panning",
+      name: text.scenarios.panning,
+      run: ({ expect }) => {
+        engine.setListener({ position: [0, 0, 0], yaw: 0 });
+        const pan = (at) => engine.plan("bench_ping", { position: at })?.pan ?? Number.NaN;
+        expect(pan([10, 0, 0]) > 0.3, "a sound to the right pans right", { pan: pan([10, 0, 0]) });
+        expect(pan([-10, 0, 0]) < -0.3, "a sound to the left pans left", { pan: pan([-10, 0, 0]) });
+        expect(Math.abs(pan([0, 0, -10])) < 0.05, "a sound ahead stays in the middle", { pan: pan([0, 0, -10]) });
+        engine.setListener({ position: [0, 0, 0], yaw: Math.PI / 2 });
+        expect(pan([0, 0, -10]) > 0.3, "turning the listener left puts what was ahead on the right", { pan: pan([0, 0, -10]) });
+        engine.setListener(listener());
+      }
+    },
+    {
+      id: "distance",
+      name: text.scenarios.distance,
+      run: ({ expect }) => {
+        const levels = [0, 10, 40, 100].map((meters) => engine.plan("bench_ping", { distance: meters })?.level ?? Number.NaN);
+        expect(levels.every((level, index) => index === 0 || level < levels[index - 1]), "the level falls with the distance", { levels });
+        const far = engine.registry.sound("sfx_pistol") ? engine.plan("sfx_pistol", { distance: 400 }) : null;
+        expect(far === null, "a game noise class is not played too far to be heard");
+      }
+    },
+    {
+      id: "determinism",
+      name: text.scenarios.determinism,
+      run: ({ expect }) => {
+        const a = engine.plan("bench_hiss", { seed: 5 });
+        const b = engine.plan("bench_hiss", { seed: 5 });
+        const c = engine.plan("bench_hiss", { seed: 6 });
+        expect(JSON.stringify(a) === JSON.stringify(b), "the same seed gives the same plan");
+        expect(JSON.stringify(a) !== JSON.stringify(c), "another seed gives another plan");
+      }
+    },
+    {
+      id: "limiter",
+      name: text.scenarios.limiter,
+      run: ({ expect }) => {
+        const voices = createVoiceManager({ maxVoices: 8 });
+        const request = (group) => voices.request({ ...group ? { group } : {}, priority: 3, gain: 0.5, distance: 5, length: 1 });
+        const grouped = Array.from({ length: STORM }, () => request("undead_voice")).filter((decision) => decision.accepted).length;
+        expect(grouped === 1, "the group cooldown lets one voice of a storm through", { accepted: grouped });
+        const plain = Array.from({ length: STORM }, () => request()).filter((decision) => decision.accepted).length;
+        expect(plain <= 8, "the global cap holds the rest", { accepted: plain });
+      }
+    }
+  ];
+  const area = () => ({
+    placements: options.probe ? [{ item: PROBE_ID, position: PROBE_AT, asleep: true }] : [],
+    view: { eye: [0, 1.7, 3], target: [0, 1.4, -10] }
+  });
+  const module = {
+    id: "audio_area",
+    name: text.name,
+    ground: { surface: "concrete_slab" },
+    group: text.group,
+    get engine() {
+      return engine;
+    },
+    items: () => items(),
+    area: () => area(),
+    controls: () => controls(),
+    layers: () => layers(),
+    metrics: () => metrics(),
+    scenarios: () => scenarios(),
+    sheet,
+    play,
+    attach(lent) {
+      host = lent;
+      const shared = lent.audio?.engine;
+      if (shared && shared !== engine) {
+        for (const bank of banks) shared.register(bank);
+        engine = shared;
+      }
+      for (const bus of BUS_IDS) {
+        engine.setBus(bus, {});
+        engine.level(bus);
+      }
+      lent.bench?.patch("sound", { options: soundOptions() });
+      lent.bench?.patch("loop", { options: loopOptions() });
+      const off = lent.bench?.onChange(onChange);
+      const offFrame = lent.onFrame(() => {
+        if (!shared) engine.setListener(listener());
+      });
+      return () => {
+        off?.();
+        offFrame();
+        loop?.stop();
+        loop = void 0;
+        host = null;
+      };
+    }
+  };
+  return module;
+}
+
+// src/catalog.ts
+var SFX_CATEGORIES = ["armas", "impactos", "explosoes-fogo", "personagem", "veiculos", "itens-portas", "ambiente"];
+var entries = (category, list) => list.map(([id, priority, current]) => ({ id, category, priority, ...current ? { current } : {} }));
+var SFX_CATALOG = [
+  ...entries("armas", [
+    ["pistol_22lr", 2, "sfx_pistol"],
+    ["pistol_9mm", 1, "sfx_pistol"],
+    ["pistol_45", 1, "sfx_pistol"],
+    ["revolver_38_357", 2, "sfx_pistol"],
+    ["revolver_44_50ae", 3, "sfx_pistol"],
+    ["smg_9mm_auto", 1, "sfx_pistol"],
+    ["shotgun_12", 1, "sfx_shotgun"],
+    ["rifle_5_56", 1, "sfx_rifle"],
+    ["rifle_7_62x39", 1, "sfx_rifle"],
+    ["rifle_auto_burst", 1, "sfx_rifle"],
+    ["rifle_308_3006", 2, "sfx_rifle"],
+    ["sniper_338_300wm", 2, "sfx_rifle"],
+    ["antimateriel_50bmg", 3, "sfx_rifle"],
+    ["suppressed_pistol", 2],
+    ["suppressed_rifle", 2],
+    ["gunshot_far_pistol", 1],
+    ["gunshot_far_rifle", 1],
+    ["gunshot_far_shotgun", 1],
+    ["gunshot_far_heavy", 2],
+    ["gunshot_tail_indoor", 1],
+    ["gunshot_tail_outdoor", 1],
+    ["bullet_crack_by", 2],
+    ["bullet_whiz", 2],
+    ["ricochet_metal", 2, "ping"],
+    ["dry_fire", 1],
+    ["mag_out", 1],
+    ["mag_in", 1],
+    ["slide_pull_release", 1],
+    ["pump_cycle", 1],
+    ["casing_drop_concreto_pistol", 1],
+    ["casing_drop_concreto_rifle", 1],
+    ["casing_drop_concreto_shell", 1],
+    ["casing_drop_madeira_pistol", 1],
+    ["casing_drop_madeira_rifle", 1],
+    ["casing_drop_madeira_shell", 1],
+    ["casing_drop_metal_pistol", 1],
+    ["casing_drop_metal_rifle", 1],
+    ["casing_drop_metal_shell", 1],
+    ["casing_drop_terra_pistol", 1],
+    ["casing_drop_terra_rifle", 1],
+    ["casing_drop_terra_shell", 1],
+    ["rocket_fire", 2],
+    ["smg_45_auto", 2, "sfx_pistol"],
+    ["weapon_draw", 2],
+    ["suppressor_attach", 3],
+    ["suppressor_detach", 3]
+  ]),
+  ...entries("explosoes-fogo", [
+    ["explosion_grenade", 1, "boom"],
+    ["explosion_big", 1, "boom_big"],
+    ["explosion_car", 2, "boom_big"],
+    ["explosion_far", 1],
+    ["debris_rain_stone", 1],
+    ["molotov_break_ignite", 1, "glass_shatter"],
+    ["fire_ignite", 1, "hiss"],
+    ["fire_loop_small", 1],
+    ["fire_loop_large", 1],
+    ["fire_extinguish", 2, "hiss"],
+    ["gas_leak_hiss", 2],
+    ["structure_collapse", 2, "crumble"],
+    ["grenade_bounce", 1],
+    ["c4_plant", 2],
+    ["c4_beep", 2],
+    ["c4_disarm", 2]
+  ]),
+  ...entries("personagem", [
+    ["footstep_concrete_walk", 1, "sfx_step"],
+    ["footstep_wood_walk", 1, "sfx_step"],
+    ["footstep_dirt_walk", 1, "sfx_step"],
+    ["footstep_grass_walk", 1, "sfx_step"],
+    ["footstep_gravel_walk", 1, "sfx_step"],
+    ["land_concrete", 1, "sfx_step"],
+    ["punch_swing", 1],
+    ["punch_hit_body", 1, "sfx_flesh"],
+    ["kick_hit", 1, "sfx_flesh"],
+    ["knife_stab", 1],
+    ["blunt_hit", 1],
+    ["bite", 1, "sfx_flesh"],
+    ["body_fall", 1],
+    ["player_hurt", 2],
+    ["footstep_tile_walk", 1, "sfx_step"],
+    ["footstep_water_walk", 1, "sfx_step"],
+    ["footstep_grate_walk", 2, "sfx_step"],
+    ["footstep_duct_walk", 3, "sfx_step"],
+    ["ladder_climb", 2],
+    ["swim", 2],
+    ["zombie_groan", 1],
+    ["zombie_alert", 1],
+    ["zombie_attack", 1],
+    ["zombie_pain", 1],
+    ["zombie_claw_hit", 1, "sfx_flesh"],
+    ["zombie_claw_miss", 2]
+  ]),
+  ...entries("veiculos", [
+    ["engine_loop_car", 1],
+    ["engine_start", 1],
+    ["crash_light", 1, "crash"],
+    ["crash_heavy", 1, "crash"],
+    ["car_door_open", 1, "latch"],
+    ["car_door_close", 1, "shut_metal"],
+    ["horn_car", 2, "horn"],
+    ["tire_skid_asphalt", 2]
+  ]),
+  ...entries("itens-portas", [
+    ["item_pickup_metal", 1],
+    ["can_open", 1],
+    ["can_crush", 1],
+    ["door_wood_open", 1, "latch"],
+    ["door_wood_close", 1, "shut_wood"],
+    ["door_creak", 1, "creak_wood"],
+    ["door_locked_rattle", 1, "rattle"],
+    ["drawer_open", 2, "slide"],
+    ["fridge_close", 2, "shut_metal"]
+  ]),
+  ...entries("ambiente", [
+    ["rain_loop", 2],
+    ["wind_loop", 2],
+    ["thunder_near", 2],
+    ["thunder_far", 2],
+    ["water_splash", 2],
+    ["helicopter_loop", 3]
+  ])
+];
+var SFX_MATERIALS = [
+  ["steel", "metal"],
+  ["aluminium", "metal"],
+  ["wood", "wood"],
+  ["plywood", "wood"],
+  ["mdf", "wood"],
+  ["glass", "glass"],
+  ["tempered_glass", "glass"],
+  ["ceramic", "glass"],
+  ["concrete", "masonry"],
+  ["brick", "masonry"],
+  ["plaster", "masonry"],
+  ["plastic", "soft"],
+  ["fabric", "soft"],
+  ["paper", "soft"],
+  ["foliage", "soft"],
+  ["soil", "soft"],
+  ["flesh", "soft"]
+];
+var SFX_BLOWS = ["bullet", "blunt", "blade", "break", "drag"];
+var CURRENT_BY_GROUP = {
+  metal: { bullet: "clang", blunt: "clang", blade: "clang", break: "clang", drag: "drag_metal" },
+  wood: { bullet: "wood_hit", blunt: "wood_hit", blade: "wood_hit", break: "crack", drag: "drag_wood" },
+  glass: { bullet: "ping", blunt: "ping", break: "glass_shatter", drag: "drag_glass" },
+  masonry: { bullet: "chip", blunt: "chip", blade: "chip", break: "crumble", drag: "drag_masonry" },
+  soft: { bullet: "thud", blunt: "thud", blade: "thud", break: "thud", drag: "drag_soft" }
+};
+var impactSoundId = (material, blow) => `impact_${material}_${blow}`;
+var SFX_IMPACTS = SFX_MATERIALS.flatMap(
+  ([material, group]) => SFX_BLOWS.map((blow) => {
+    const current = CURRENT_BY_GROUP[group]?.[blow];
+    return { id: impactSoundId(material, blow), category: "impactos", priority: ["steel", "wood", "glass", "concrete", "brick", "soil", "flesh"].includes(material) && blow === "bullet" ? 1 : 2, ...current ? { current } : {} };
+  })
+);
+function sfxState(entry, has) {
+  if (has.sample(entry.id)) return "file";
+  if (entry.current && has.sound(entry.current) || has.sound(entry.id)) return "synth";
+  return "missing";
+}
+
+// src/measure/calibration.ts
+var CALIBRATION_ID = "calibration_shot";
+var CALIBRATION_RATE = 48e3;
+function encodeWav(samples, sampleRate = CALIBRATION_RATE) {
+  const bytes = new ArrayBuffer(44 + samples.length * 2);
+  const view = new DataView(bytes);
+  const text = (at, value) => {
+    for (let index = 0; index < value.length; index++) view.setUint8(at + index, value.charCodeAt(index));
+  };
+  text(0, "RIFF");
+  view.setUint32(4, 36 + samples.length * 2, true);
+  text(8, "WAVE");
+  text(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  text(36, "data");
+  view.setUint32(40, samples.length * 2, true);
+  for (let index = 0; index < samples.length; index++) {
+    const value = Math.max(-1, Math.min(1, samples[index]));
+    view.setInt16(44 + index * 2, value < 0 ? value * 32768 : value * 32767, true);
+  }
+  return bytes;
+}
+function shotSamples(shot, sampleRate = CALIBRATION_RATE) {
+  const random = createRng(shot.seed);
+  const length = Math.round(shot.seconds * sampleRate);
+  const samples = new Float32Array(length);
+  let low = 0;
+  let phase = 0;
+  const attack = Math.max(1, Math.round((shot.attack ?? 0) * sampleRate));
+  for (let index = 0; index < length; index++) {
+    const time = index / sampleRate;
+    const envelope = Math.exp(-time / shot.decay) * Math.min(1, (index + 1) / attack);
+    phase += 2 * Math.PI * shot.thump * (1 + 0.6 * Math.exp(-time * 30)) / sampleRate;
+    const noise = random() * 2 - 1;
+    low += shot.brightness * (noise - low);
+    const fade = Math.min(1, (length - index) / (0.01 * sampleRate));
+    samples[index] = shot.gain * envelope * fade * (0.55 * Math.sin(phase) + shot.noise * low);
+  }
+  return samples;
+}
+var TAKES = {
+  "close_1.wav": { seconds: 0.4, thump: 150, noise: 1, decay: 0.06, brightness: 0.9, gain: 0.85, seed: 1 },
+  "close_2.wav": { seconds: 0.4, thump: 160, noise: 1, decay: 0.065, brightness: 0.85, gain: 0.85, seed: 2 },
+  "close_3.wav": { seconds: 0.4, thump: 142, noise: 1, decay: 0.055, brightness: 0.95, gain: 0.85, seed: 3 },
+  "close_4.wav": { seconds: 0.4, thump: 170, noise: 1, decay: 0.07, brightness: 0.8, gain: 0.85, seed: 4 },
+  "far_1.wav": { seconds: 0.9, thump: 90, noise: 0.8, decay: 0.2, brightness: 0.08, gain: 0.7, seed: 5, attack: 4e-3 },
+  "far_2.wav": { seconds: 0.9, thump: 95, noise: 0.8, decay: 0.22, brightness: 0.07, gain: 0.7, seed: 6, attack: 4e-3 },
+  "light_1.wav": { seconds: 0.25, thump: 220, noise: 0.6, decay: 0.03, brightness: 0.6, gain: 0.35, seed: 7 },
+  "light_2.wav": { seconds: 0.25, thump: 230, noise: 0.6, decay: 0.03, brightness: 0.55, gain: 0.35, seed: 8 },
+  "heavy_1.wav": { seconds: 0.6, thump: 110, noise: 1.2, decay: 0.11, brightness: 0.95, gain: 0.95, seed: 9 },
+  "heavy_2.wav": { seconds: 0.6, thump: 105, noise: 1.2, decay: 0.12, brightness: 0.9, gain: 0.95, seed: 10 },
+  "tail_in.wav": { seconds: 0.5, thump: 0, noise: 1, decay: 0.08, brightness: 0.4, gain: 0.25, seed: 11, attack: 0.01 },
+  "tail_out.wav": { seconds: 2, thump: 0, noise: 1, decay: 0.45, brightness: 0.25, gain: 0.2, seed: 12, attack: 0.02 },
+  "loop_1.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.5, gain: 0.5, seed: 13, attack: 0.01 },
+  "loop_2.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.45, gain: 0.5, seed: 14, attack: 0.01 },
+  "loop_3.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.55, gain: 0.5, seed: 15, attack: 0.01 }
+};
+var PREFIX = "calibration/";
+var url = (name) => `${PREFIX}${name}`;
+var CALIBRATION_SOUND = {
+  id: CALIBRATION_ID,
+  bus: "weapons",
+  close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })),
+  far: ["far_1.wav", "far_2.wav"].map((name) => ({ url: url(name) })),
+  tiers: [
+    { name: "light", from: 0, close: ["light_1.wav", "light_2.wav"].map((name) => ({ url: url(name) })) },
+    { name: "medium", from: 0.34, close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })) },
+    { name: "heavy", from: 0.67, close: ["heavy_1.wav", "heavy_2.wav"].map((name) => ({ url: url(name) })) }
+  ],
+  tail: { indoor: [{ url: url("tail_in.wav") }], outdoor: [{ url: url("tail_out.wav") }] },
+  pitch: 0.04,
+  choke: { voices: 2 },
+  fallback: "sfx_pistol",
+  sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+};
+var CALIBRATION_LOOP_ID = "calibration_loop";
+var CALIBRATION_LOOP_SOUND = {
+  id: CALIBRATION_LOOP_ID,
+  bus: "ambience",
+  close: ["loop_1.wav", "loop_2.wav", "loop_3.wav"].map((name) => ({ url: url(name) })),
+  loop: { crossfade: 0.15 },
+  sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+};
+var isCalibrationUrl = (url2) => url2.startsWith(PREFIX);
+function calibrationLoader(next) {
+  const made = /* @__PURE__ */ new Map();
+  return async (requested) => {
+    if (!requested.startsWith(PREFIX)) {
+      if (next) return next(requested);
+      throw new Error(`not a calibration file: ${requested}`);
+    }
+    const name = requested.slice(PREFIX.length);
+    const shot = TAKES[name];
+    if (!shot) throw new Error(`no calibration take ${name}`);
+    let bytes = made.get(name);
+    if (!bytes) {
+      bytes = encodeWav(shotSamples(shot));
+      made.set(name, bytes);
+    }
+    return bytes.slice(0);
+  };
+}
+
+// src/measure/analyze.ts
+var dbOf = (amplitude) => amplitude > 0 ? 20 * Math.log10(amplitude) : -Infinity;
+var clampIndex = (channels, index) => Math.max(0, Math.min(channels[0]?.length ?? 0, Math.round(index)));
+function peakOf(channels, start = 0, end3 = Number.POSITIVE_INFINITY) {
+  let peak = 0;
+  const from = clampIndex(channels, start);
+  for (const channel of channels) {
+    const to = Math.min(channel.length, end3);
+    for (let index = from; index < to; index++) {
+      const value = Math.abs(channel[index]);
+      if (value > peak) peak = value;
+    }
+  }
+  return peak;
+}
+function peakIndex(channels, start = 0, end3 = Number.POSITIVE_INFINITY) {
+  let peak = -1;
+  let at = -1;
+  const from = clampIndex(channels, start);
+  for (const channel of channels) {
+    const to = Math.min(channel.length, end3);
+    for (let index = from; index < to; index++) {
+      const value = Math.abs(channel[index]);
+      if (value > peak) {
+        peak = value;
+        at = index;
+      }
+    }
+  }
+  return at;
+}
+function onsetIndex(channels, start = 0, threshold = 1e-3) {
+  const length = channels[0]?.length ?? 0;
+  for (let index = clampIndex(channels, start); index < length; index++) {
+    for (const channel of channels) if (Math.abs(channel[index]) >= threshold) return index;
+  }
+  return -1;
+}
+function rmsDb(channels, start, end3) {
+  let sum = 0;
+  let count = 0;
+  const from = clampIndex(channels, start);
+  for (const channel of channels) {
+    const to = Math.min(channel.length, Math.round(end3));
+    for (let index = from; index < to; index++) {
+      const value = channel[index];
+      sum += value * value;
+      count++;
+    }
+  }
+  return count === 0 ? -Infinity : dbOf(Math.sqrt(sum / count));
+}
+function centroidHz(channels, sampleRate, start, size = 2048) {
+  const from = clampIndex(channels, start);
+  const frame = new Float64Array(size);
+  for (const channel of channels) {
+    for (let index = 0; index < size; index++) frame[index] = frame[index] + (channel[from + index] ?? 0);
+  }
+  for (let index = 0; index < size; index++) frame[index] = frame[index] * (0.5 - 0.5 * Math.cos(2 * Math.PI * index / (size - 1)));
+  let weighted = 0;
+  let total = 0;
+  const bins = size / 2;
+  for (let bin = 1; bin < bins; bin++) {
+    let re = 0;
+    let im = 0;
+    const step = 2 * Math.PI * bin / size;
+    for (let index = 0; index < size; index++) {
+      const value = frame[index];
+      re += value * Math.cos(step * index);
+      im -= value * Math.sin(step * index);
+    }
+    const magnitude = Math.hypot(re, im);
+    weighted += magnitude * (bin * sampleRate / size);
+    total += magnitude;
+  }
+  return total > 0 ? weighted / total : 0;
+}
+function balanceOf(left, right, start, end3) {
+  let l = 0;
+  let r = 0;
+  const to = Math.min(left.length, right.length, Math.round(end3));
+  for (let index = Math.max(0, Math.round(start)); index < to; index++) {
+    l += left[index] ** 2;
+    r += right[index] ** 2;
+  }
+  return l + r > 0 ? (r - l) / (r + l) : 0;
+}
+function ringSeconds(channels, sampleRate, start, floorDb = -60) {
+  const window = Math.max(1, Math.round(sampleRate * 0.01));
+  const length = channels[0]?.length ?? 0;
+  let last = clampIndex(channels, start);
+  for (let index = last; index < length; index += window) {
+    if (dbOf(peakOf(channels, index, index + window)) > floorDb) last = index + window;
+  }
+  return (last - start) / sampleRate;
+}
+function countHits(channels, sampleRate, threshold) {
+  const window = Math.max(1, Math.round(sampleRate * 2e-3));
+  const length = channels[0]?.length ?? 0;
+  const envelope = [];
+  for (let index = 0; index < length; index += window) envelope.push(peakOf(channels, index, index + window));
+  const history = 10;
+  const refractory = Math.round(0.03 / 2e-3);
+  let hits = 0;
+  let quietUntil = -1;
+  for (let index = 0; index < envelope.length; index++) {
+    const level = envelope[index];
+    if (index < quietUntil || level < threshold) continue;
+    let sum = 0;
+    for (let back = Math.max(0, index - history); back < index; back++) sum += envelope[back];
+    const before = index === 0 ? 0 : sum / Math.min(history, index);
+    if (level >= 2 * before) {
+      hits++;
+      quietUntil = index + refractory;
+    }
+  }
+  return hits;
+}
+function endDropDb(channels, sampleRate, seconds = 5e-3) {
+  const length = channels[0]?.length ?? 0;
+  const whole = peakOf(channels);
+  if (whole === 0) return -Infinity;
+  return dbOf(peakOf(channels, length - Math.round(sampleRate * seconds), length) / whole);
+}
+
+// src/measure/criteria.ts
+var CRITERIA = ["C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "C10"];
+var CRITERIA_TARGETS = {
+  /** C1: event to the first sample, and onset to the peak (one 60 fps frame). */
+  syncMs: 20,
+  peakAfterOnsetMs: 1e3 / 60,
+  /** C3: distances measured, metres. */
+  distances: [1, 10, 50, 200],
+  /** C5: plays, distinct takes and the pitch range (fraction). */
+  plays: 10,
+  minTakes: 4,
+  pitch: [0.03, 0.05],
+  /** C6: the highest peak, dBFS. */
+  peakDb: -1,
+  /** C8: the end of each file against its peak, dB. */
+  endDropDb: -40,
+  /** C9: a burst of rapid fire. */
+  burst: 20,
+  burstSpacing: 0.06
+};
+var EVENT_AT = 0.2;
+var offlineFactory = (options) => options.createOfflineContext ?? ((channels, length, sampleRate) => {
+  const Constructor = globalThis.OfflineAudioContext;
+  if (!Constructor) throw new Error("no OfflineAudioContext here: the harness runs in a browser");
+  return new Constructor(channels, length, sampleRate);
+});
+async function render(options, seconds, act, engineExtras = {}) {
+  const sampleRate = options.sampleRate ?? 48e3;
+  const context = offlineFactory(options)(2, Math.ceil(seconds * sampleRate), sampleRate);
+  const events = [];
+  const engine = createAudioEngine({
+    banks: options.banks,
+    createContext: () => context,
+    samples: { loader: options.loader, autoLoad: false },
+    onVoiceStart: (event) => events.push(event),
+    ...options.mix ? { mix: options.mix } : {},
+    ...engineExtras.occlusion ? { occlusion: engineExtras.occlusion } : {},
+    ...engineExtras.environment ? { environment: engineExtras.environment } : {}
+  });
+  const ids = [.../* @__PURE__ */ new Set([options.sound, ...(options.actions ?? []).map((action) => action.play), ...options.loudnessOrder ?? []])].filter((id) => engine.registry.sample(id));
+  const report = await engine.loadSamples(ids);
+  if (report.failed.length > 0) throw new Error(`files did not load: ${report.failed.map((entry) => `${entry.url} (${entry.error})`).join(", ")}`);
+  const handles = act(engine);
+  const buffer = await context.startRendering();
+  const channels = Array.from({ length: buffer.numberOfChannels }, (_, index) => buffer.getChannelData(index));
+  return { channels, sampleRate, events, handles };
+}
+var ms = (seconds) => `${(seconds * 1e3).toFixed(1)} ms`;
+var db = (value) => Number.isFinite(value) ? `${value.toFixed(1)} dB` : "\u2212\u221E";
+var decreasing = (values) => values.every((value, index) => index === 0 || value < values[index - 1]);
+async function c1(options) {
+  const result = await render(options, 1.2, (engine) => engine.play(options.sound, { distance: 1, delay: EVENT_AT }) ? 1 : 0);
+  const onset = onsetIndex(result.channels, 0, 1e-3);
+  const event = result.events.find((entry) => entry.id === options.sound);
+  if (onset < 0 || !event) return { id: "C1", pass: false, value: "sem som", target: `\u2264 ${CRITERIA_TARGETS.syncMs} ms` };
+  const delay = onset / result.sampleRate - EVENT_AT + (event.startAt - event.requestedAt - EVENT_AT) + (options.baseLatency ?? 0);
+  const peak = peakIndex(result.channels, onset, onset + Math.round(result.sampleRate * 0.25));
+  const toPeak = (peak - onset) / result.sampleRate;
+  const pass = delay <= CRITERIA_TARGETS.syncMs / 1e3 && toPeak <= CRITERIA_TARGETS.peakAfterOnsetMs / 1e3;
+  return {
+    id: "C1",
+    pass,
+    value: `${ms(delay)}, pico +${ms(toPeak)}`,
+    target: `\u2264 ${CRITERIA_TARGETS.syncMs} ms; pico no quadro do contato`,
+    data: { delay, toPeak, baseLatency: options.baseLatency ?? 0, outputLatency: options.outputLatency ?? 0 }
+  };
+}
+async function c2(options) {
+  const actions = options.actions ?? [{ action: options.sound, play: options.sound, expect: options.sound }];
+  const result = await render(options, 0.5, (engine) => {
+    let played = 0;
+    for (const action of actions) if (engine.play(action.play, { distance: 1, ...action.options })) played++;
+    return played;
+  });
+  const wrong = actions.filter((action, index) => {
+    const event = result.events[index];
+    return !event || (event.fallbackOf ?? event.id) !== action.expect || event.kind !== "sample";
+  });
+  return {
+    id: "C2",
+    pass: wrong.length === 0,
+    value: `${actions.length - wrong.length}/${actions.length} certas`,
+    target: "100% das a\xE7\xF5es batem com a tabela (arquivo, n\xE3o o substituto)",
+    data: { wrong: wrong.map((action) => action.action), events: result.events.map((event) => `${event.kind}:${event.id}`) }
+  };
+}
+async function c3(options, sound) {
+  const levels = [];
+  const brightness = [];
+  for (const distance of CRITERIA_TARGETS.distances) {
+    const result = await render(options, 1.2, (engine) => engine.play(options.sound, { position: [0, 0, -distance], seed: 1, delay: EVENT_AT }) ? 1 : 0);
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    levels.push(onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3));
+    brightness.push(onset < 0 ? 0 : centroidHz(result.channels, result.sampleRate, onset));
+  }
+  const far = planSample(sound, { random: createRng(1), distance: CRITERIA_TARGETS.distances.at(-1) });
+  const switched = (far?.farMix ?? 0) === 1 && (far?.layers.some((layer) => layer.role === "far") ?? false);
+  const pass = decreasing(levels) && decreasing(brightness) && switched;
+  return {
+    id: "C3",
+    pass,
+    value: `${levels.map((level) => db(level)).join(" \u203A ")}; ${brightness.map((hz) => `${Math.round(hz)} Hz`).join(" \u203A ")}${switched ? "; longe = far" : "; sem camada far"}`,
+    target: "cai e escurece com a dist\xE2ncia; troca para a vers\xE3o de longe depois de ~50 m",
+    data: { distances: CRITERIA_TARGETS.distances, levels, brightness, switched }
+  };
+}
+async function c4(options) {
+  const side = async (x) => {
+    const result = await render(options, 0.8, (engine) => engine.play(options.sound, { position: [x, 0, -2], seed: 1, delay: EVENT_AT }) ? 1 : 0);
+    const [left2, right2] = result.channels;
+    return balanceOf(left2, right2, 0, left2.length);
+  };
+  const right = await side(10);
+  const left = await side(-10);
+  const bright = async (occluded) => {
+    const result = await render(options, 0.8, (engine) => engine.play(options.sound, { position: [0, 0, -10], seed: 1, delay: EVENT_AT }) ? 1 : 0, occluded ? { occlusion: () => 1 } : {});
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    return onset < 0 ? 0 : centroidHz(result.channels, result.sampleRate, onset);
+  };
+  const clear = await bright(false);
+  const wall = await bright(true);
+  const pass = right > 0.2 && left < -0.2 && wall < clear * 0.7;
+  return {
+    id: "C4",
+    pass,
+    value: `dir ${right.toFixed(2)} esq ${left.toFixed(2)}; parede ${Math.round(wall)} Hz de ${Math.round(clear)} Hz`,
+    target: "lado certo; atr\xE1s da parede fica abafado",
+    data: { right, left, clear, wall }
+  };
+}
+async function c5(options, sound) {
+  const result = await render(options, 0.3 * CRITERIA_TARGETS.plays + 1, (engine) => {
+    let played = 0;
+    for (let index = 0; index < CRITERIA_TARGETS.plays; index++) if (engine.play(options.sound, { distance: 1, delay: 0.1 + index * 0.3 })) played++;
+    return played;
+  });
+  const close = result.events.map((event) => event.layers?.find((layer) => layer.role === "close"));
+  const takes = close.map((layer) => layer?.url ?? "");
+  const repeats = takes.filter((take, index) => index > 0 && take === takes[index - 1]).length;
+  const distinct = new Set(takes).size;
+  const rates = close.map((layer) => layer?.rate ?? 1);
+  const spread = (Math.max(...rates) - Math.min(...rates)) / 2;
+  const pitch = sound.pitch ?? 0.04;
+  const pass = distinct >= CRITERIA_TARGETS.minTakes && repeats === 0 && pitch >= CRITERIA_TARGETS.pitch[0] && pitch <= CRITERIA_TARGETS.pitch[1] && spread > 0.01;
+  return {
+    id: "C5",
+    pass,
+    value: `${distinct} tomadas, ${repeats} repeti\xE7\xF5es seguidas, tom \xB1${(pitch * 100).toFixed(0)}%`,
+    target: `\u2265 ${CRITERIA_TARGETS.minTakes} varia\xE7\xF5es, nunca a mesma duas vezes, tom \xB13\u20135%`,
+    data: { takes, rates }
+  };
+}
+async function c6(options) {
+  const peakAt = async (id) => {
+    const result = await render(options, 1.2, (engine) => engine.play(id, { distance: 1, seed: 1, delay: EVENT_AT }) ? 1 : 0);
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    return { peak: dbOf(peakOf(result.channels)), rms: onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3) };
+  };
+  const own = await peakAt(options.sound);
+  const order = options.loudnessOrder ?? [];
+  const loudness = [];
+  for (const id of order) loudness.push((await peakAt(id)).rms);
+  const ordered = order.length < 2 || decreasing(loudness);
+  const pass = own.peak <= CRITERIA_TARGETS.peakDb && ordered;
+  return {
+    id: "C6",
+    pass,
+    value: `pico ${db(own.peak)}, RMS ${db(own.rms)}${order.length > 1 ? `; ordem ${ordered ? "ok" : "errada"}` : ""}`,
+    target: "tiro > explos\xE3o > impacto > passo; pico \u2264 \u22121 dBFS",
+    data: { peak: own.peak, rms: own.rms, order, loudness }
+  };
+}
+async function c7(options, sound) {
+  if (!sound.tiers || sound.tiers.length < 2) return { id: "C7", pass: false, value: "sem camadas leve/m\xE9dio/forte", target: "muda de camada, n\xE3o s\xF3 de volume" };
+  const at = async (intensity) => {
+    const result = await render(options, 1.2, (engine) => engine.play(options.sound, { distance: 1, seed: 1, intensity, delay: EVENT_AT }) ? 1 : 0);
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    const event = result.events[0];
+    return { tier: event?.tier ?? "", rms: onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3), files: event?.layers?.find((layer) => layer.role === "close")?.url ?? "" };
+  };
+  const light = await at(0.1);
+  const heavy = await at(0.9);
+  const pass = light.tier !== heavy.tier && light.files !== heavy.files && heavy.rms > light.rms;
+  return {
+    id: "C7",
+    pass,
+    value: `${light.tier} ${db(light.rms)} \u2192 ${heavy.tier} ${db(heavy.rms)}`,
+    target: "golpe fraco x forte troca a camada (leve/m\xE9dio/forte), n\xE3o s\xF3 o volume",
+    data: { light, heavy }
+  };
+}
+async function c8(options, sound) {
+  const sampleRate = options.sampleRate ?? 48e3;
+  const decoder = offlineFactory(options)(1, sampleRate, sampleRate);
+  const drops = [];
+  for (const url2 of sampleUrls(sound)) {
+    const buffer = await decoder.decodeAudioData(await options.loader(url2));
+    drops.push({ url: url2, drop: endDropDb([buffer.getChannelData(0)], buffer.sampleRate) });
+  }
+  const worst = drops.reduce((max, entry) => Math.max(max, entry.drop), -Infinity);
+  const ring = async (environment) => {
+    const result = await render(options, 3, (engine) => engine.play(options.sound, { distance: 1, seed: 1, environment, delay: EVENT_AT }) ? 1 : 0);
+    return ringSeconds(result.channels, result.sampleRate, Math.round(EVENT_AT * result.sampleRate));
+  };
+  const indoor = await ring("indoor");
+  const outdoor = await ring("outdoor");
+  const hasTails = Boolean(sound.tail?.indoor?.length && sound.tail?.outdoor?.length);
+  const pass = worst <= CRITERIA_TARGETS.endDropDb && hasTails && outdoor > indoor;
+  return {
+    id: "C8",
+    pass,
+    value: `fim ${db(worst)}; cauda dentro ${indoor.toFixed(2)} s, fora ${outdoor.toFixed(2)} s${hasTails ? "" : " (sem as duas caudas)"}`,
+    target: "n\xE3o corta seco; cauda de interior x exterior coerente",
+    data: { drops, indoor, outdoor }
+  };
+}
+async function c9(options) {
+  const { burst, burstSpacing } = CRITERIA_TARGETS;
+  const first = 0.1;
+  const result = await render(options, burst * burstSpacing + 1.5, (engine) => {
+    let played = 0;
+    for (let index = 0; index < burst; index++) if (engine.play(options.sound, { distance: 1, delay: first + index * burstSpacing })) played++;
+    return played;
+  });
+  const peak = dbOf(peakOf(result.channels));
+  const slots = [];
+  for (let index = 0; index < burst; index++) {
+    const at = Math.round((first + index * burstSpacing) * result.sampleRate);
+    slots.push(rmsDb(result.channels, at, at + Math.round(burstSpacing * result.sampleRate)));
+  }
+  const sorted = [...slots].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)];
+  const vanished = slots.filter((level) => level < median - 6).length;
+  const buildUp = slots.slice(-5).reduce((sum, level) => sum + level, 0) / 5 - slots[0];
+  const pass = result.handles === burst && vanished === 0 && buildUp <= 6 && peak <= CRITERIA_TARGETS.peakDb;
+  return {
+    id: "C9",
+    pass,
+    value: `${result.handles}/${burst} tocaram, ${vanished} sumiram, ac\xFAmulo ${buildUp >= 0 ? "+" : ""}${buildUp.toFixed(1)} dB, pico ${db(peak)}`,
+    target: "rajada sem amontoar (ac\xFAmulo \u2264 6 dB) nem sumir; pico \u2264 \u22121 dBFS",
+    data: { handles: result.handles, slots, vanished, buildUp, peak }
+  };
+}
+async function measureCriteria(options, only = CRITERIA) {
+  const probe = createAudioEngine({ banks: options.banks, createContext: () => null });
+  const sound = probe.registry.sample(options.sound);
+  if (!sound) throw new Error(`${options.sound} is not a sample sound of these banks`);
+  const results = [];
+  for (const id of only) {
+    if (id === "C1") results.push(await c1(options));
+    else if (id === "C2") results.push(await c2(options));
+    else if (id === "C3") results.push(await c3(options, sound));
+    else if (id === "C4") results.push(await c4(options));
+    else if (id === "C5") results.push(await c5(options, sound));
+    else if (id === "C6") results.push(await c6(options));
+    else if (id === "C7") results.push(await c7(options, sound));
+    else if (id === "C8") results.push(await c8(options, sound));
+    else if (id === "C9") results.push(await c9(options));
+    else results.push({ id: "C10", pass: null, value: "gravar e ouvir", target: "aprovado pelo ouvido do dono (print + grava\xE7\xE3o na 4280)" });
+  }
+  return results;
+}
+async function recordOutput(engine, seconds, act) {
+  engine.unlock();
+  const output = engine.output();
+  const Recorder = globalThis.MediaRecorder;
+  const context = output?.context;
+  if (!output || !Recorder || !context || typeof context.createMediaStreamDestination !== "function") return null;
+  const tap = context.createMediaStreamDestination();
+  output.connect(tap);
+  const recorder = new Recorder(tap.stream);
+  const chunks = [];
+  recorder.ondataavailable = (event) => chunks.push(event.data);
+  const done = new Promise((resolve) => {
+    recorder.onstop = () => resolve();
+  });
+  recorder.start();
+  act();
+  await new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+  recorder.stop();
+  await done;
+  output.disconnect(tap);
+  return new Blob(chunks, { type: recorder.mimeType || "audio/webm" });
+}
+
+// src/manifest.ts
+var SDK_LICENSES = ["CC0", "CC-BY"];
+var SFX_LAYERS = ["close", "far", "tail_in", "tail_out"];
+var SFX_TIERS = { light: 0, medium: 0.34, heavy: 0.67 };
+function parseSfxName(name) {
+  const match = /^(.*?)(?:_(close|far|tail_in|tail_out))?(?:_(\d+))?$/.exec(name);
+  const id = match?.[1] || name;
+  const layer = match?.[2] ?? "close";
+  const take = match?.[3] ? Number(match[3]) : 1;
+  return { id, layer, take };
+}
+function splitTier(id) {
+  const match = /^(.*)_(light|medium|heavy)$/.exec(id);
+  return match ? { base: match[1], tier: match[2] } : { base: id };
+}
+var refsOf = (entries2, baseUrl) => (entries2 ?? []).map((entry) => ({ url: `${baseUrl}${entry.file}` }));
+function sampleBankFromManifest(manifest, options) {
+  const baseUrl = options.baseUrl ?? "";
+  const samples = [];
+  const tiersOf = /* @__PURE__ */ new Map();
+  for (const sound of manifest.sounds) {
+    const { base, tier } = splitTier(sound.id);
+    if (tier) tiersOf.set(base, [...tiersOf.get(base) ?? [], sound]);
+  }
+  const bases = /* @__PURE__ */ new Map();
+  for (const sound of manifest.sounds) {
+    if (!splitTier(sound.id).tier) bases.set(sound.id, sound);
+  }
+  for (const [base, tiers] of tiersOf) {
+    if (!bases.has(base)) bases.set(base, { id: base, category: tiers[0]?.category ?? "", layers: { close: tiers[0]?.layers.close ?? [] } });
+  }
+  for (const sound of bases.values()) {
+    const numbers = options.sounds?.[sound.id] ?? options.defaults?.(sound);
+    const close = refsOf(sound.layers.close, baseUrl);
+    if (!numbers || close.length === 0) continue;
+    const tiers = (tiersOf.get(sound.id) ?? []).map((tier) => {
+      const name = splitTier(tier.id).tier;
+      const tierFar = refsOf(tier.layers.far, baseUrl);
+      return { name, from: SFX_TIERS[name] ?? 0, close: refsOf(tier.layers.close, baseUrl), ...tierFar.length > 0 ? { far: tierFar } : {} };
+    }).sort((a, b) => a.from - b.from);
+    const far = refsOf(sound.layers.far, baseUrl);
+    const indoor = refsOf(sound.layers.tail_in, baseUrl);
+    const outdoor = refsOf(sound.layers.tail_out, baseUrl);
+    const files = [sound, ...tiersOf.get(sound.id) ?? []].flatMap((entry) => Object.values(entry.layers).flatMap((entries2) => entries2 ?? []));
+    samples.push({
+      id: sound.id,
+      bus: numbers.bus,
+      close,
+      ...far.length > 0 ? { far } : {},
+      ...tiers.length > 0 ? { tiers } : {},
+      ...numbers.crossover ? { crossover: numbers.crossover } : {},
+      ...indoor.length > 0 || outdoor.length > 0 ? { tail: { ...indoor.length > 0 ? { indoor } : {}, ...outdoor.length > 0 ? { outdoor } : {}, ...numbers.tailGain === void 0 ? {} : { gain: numbers.tailGain } } } : {},
+      ...numbers.pitch === void 0 ? {} : { pitch: numbers.pitch },
+      ...numbers.gain === void 0 ? {} : { gain: numbers.gain },
+      ...numbers.falloff ? { falloff: numbers.falloff } : {},
+      ...numbers.cutoffK === void 0 ? {} : { cutoffK: numbers.cutoffK },
+      ...numbers.group ? { group: numbers.group } : {},
+      ...numbers.priority === void 0 ? {} : { priority: numbers.priority },
+      ...numbers.fallback ? { fallback: numbers.fallback } : {},
+      sources: files.map((file) => `${file.file}: ${file.source} ${file.author} ${file.license}`)
+    });
+  }
+  return { id: options.id, samples };
+}
+
+// src/kit-samples.ts
+var KIT_CATEGORY_BUS = {
+  armas: "weapons",
+  impactos: "world",
+  "explosoes-fogo": "world",
+  personagem: "world",
+  veiculos: "world",
+  "itens-portas": "world",
+  ambiente: "ambience"
+};
+var VOICE_IDS = /^(player_(hurt|death|effort|breath)|scream|zombie_)/;
+var KIT_SAMPLE_ALIASES = {
+  // a house door: the latch giving, the hinge, the leaf meeting the frame, a locked one shaken; a drawer on its runners
+  latch: "metal_latch",
+  creak_wood: "door_creak",
+  shut_wood: "door_wood_shut",
+  rattle: "door_locked_rattle",
+  // a drawer stays on its recipe: the recorded runs (1 to 1.9 s) outlast a drawer's pull
+  // an item taken in the hand (game-destruction-three grab_* keys)
+  grab_hard: "item_pickup_generic",
+  grab_soft: "item_pickup_leather"
+};
+function kitSampleDefaults(sound) {
+  const bus = VOICE_IDS.test(sound.id) ? "voices" : KIT_CATEGORY_BUS[sound.category];
+  if (!bus) return void 0;
+  return { bus, pitch: sound.category === "ambiente" || /_loop/.test(sound.id) ? 0 : 0.04 };
+}
+function withAliases(manifest, aliases) {
+  const byId = new Map(manifest.sounds.map((sound) => [sound.id, sound]));
+  const extra = [];
+  for (const [alias, target] of Object.entries(aliases)) {
+    const sound = byId.get(target);
+    if (sound && !byId.has(alias)) extra.push({ ...sound, id: alias });
+  }
+  return { ...manifest, sounds: [...manifest.sounds, ...extra] };
+}
+function kitSampleBank(manifest, options = {}) {
+  return sampleBankFromManifest(withAliases(manifest, options.aliases ?? KIT_SAMPLE_ALIASES), {
+    id: options.id ?? "kit_samples",
+    baseUrl: options.baseUrl ?? "",
+    defaults: kitSampleDefaults
+  });
+}
+var isFileUrl = (url2) => {
+  const page = globalThis.location?.href;
+  try {
+    return new URL(url2, page).protocol === "file:";
+  } catch {
+    return false;
+  }
+};
+var fetchJson = async (url2) => {
+  if (isFileUrl(url2)) throw new Error(`${url2}: file:// is not fetched`);
+  const response = await fetch(url2);
+  if (!response.ok) throw new Error(`${url2}: ${response.status}`);
+  return await response.json();
+};
+async function loadKitSamples(engine, options = {}) {
+  const baseUrl = options.baseUrl ?? "";
+  let manifest;
+  try {
+    manifest = await (options.fetchManifest ?? fetchJson)(`${baseUrl}manifest.json`);
+  } catch {
+    return null;
+  }
+  const bank = kitSampleBank(manifest, options);
+  engine.register(bank);
+  if (options.preload && engine.loadSamples) void engine.loadSamples(options.preload).catch(() => void 0);
+  return bank;
+}
+
+// src/user-samples.ts
+var USER_SAMPLES_BANK = "user_samples";
+var KIT_SAMPLES_BANK = "kit_samples";
+var USER_SOUND_PREFIX = "user:";
+function soundSourceOf(event) {
+  if (event.kind === "recipe") return "synth";
+  return event.bank === USER_SAMPLES_BANK ? "user" : "sdk";
+}
+function userSampleBank(manifest, options = {}) {
+  const playing = [];
+  const behindKit = [];
+  const sounds = [];
+  for (const picked of manifest.sounds) {
+    const sound = { ...picked, id: splitTier(picked.id).base };
+    sounds.push({ ...sound, id: `${USER_SOUND_PREFIX}${sound.id}` });
+    if (sound.role === "fallback" && options.kitHas?.(sound.id)) {
+      behindKit.push(sound.id);
+      continue;
+    }
+    sounds.push(sound);
+    playing.push(sound.id);
+  }
+  const bank = sampleBankFromManifest(
+    { sounds },
+    {
+      id: USER_SAMPLES_BANK,
+      baseUrl: options.baseUrl ?? "",
+      defaults: (sound) => kitSampleDefaults({ id: sound.id.replace(USER_SOUND_PREFIX, ""), category: sound.category })
+    }
+  );
+  return { bank, playing, behindKit };
+}
+var fetchManifestJson = async (url2) => {
+  const page = globalThis.location?.href;
+  if (new URL(url2, page ?? "http://localhost/").protocol === "file:") throw new Error(`${url2}: file:// is not fetched`);
+  const response = await fetch(url2);
+  if (!response.ok) throw new Error(`${url2}: ${response.status}`);
+  return await response.json();
+};
+async function loadUserSamples(engine, options = {}) {
+  const baseUrl = options.baseUrl ?? "./sfx-local/";
+  let manifest;
+  try {
+    manifest = await (options.fetchManifest ?? fetchManifestJson)(`${baseUrl}manifest.json`);
+  } catch {
+    return null;
+  }
+  const kitHas = options.kitHas ?? ((id) => Boolean(engine.registry?.sample(id)));
+  const result = userSampleBank(manifest, { baseUrl, kitHas });
+  engine.register(result.bank);
+  return result;
+}
+
+// src/bench/sound-check-locale.ts
+var PT = {
+  group: "Som",
+  name: "Painel de som (arquivos e C1\u2013C10)",
+  controls: {
+    category: "1 \xB7 Categoria",
+    sound: "1 \xB7 Som",
+    play: "1 \xB7 \u25B6 Tocar",
+    play_user: "1 \xB7 \u25B6 Tocar o seu",
+    material: "2 \xB7 Material",
+    blow: "2 \xB7 Golpe",
+    strike: "2 \xB7 \u25B6 Tocar golpe",
+    distance: "3 \xB7 Dist\xE2ncia",
+    bearing: "3 \xB7 Dire\xE7\xE3o",
+    environment: "3 \xB7 Lugar",
+    strength: "3 \xB7 For\xE7a",
+    wall: "3 \xB7 Atr\xE1s da parede",
+    burst: "3 \xB7 Rajada 20\xD7",
+    play_a: "4 \xB7 \u25B6 A (atual)",
+    play_b: "4 \xB7 \u25B6 B (novo)",
+    ab_cycle: "4 \xB7 Alternar A/B",
+    blind: "4 \xB7 \xC0s cegas (X)",
+    reveal: "4 \xB7 Revelar X",
+    prefer_a: "4 \xB7 Prefiro A",
+    prefer_b: "4 \xB7 Prefiro B",
+    measure: "5 \xB7 Medir C1\u2013C10",
+    record: "5 \xB7 Gravar 3 s",
+    approve: "5 \xB7 Aprovo (C10)"
+  },
+  hints: {
+    play_user: "Toca a sua grava\xE7\xE3o deste som (dos seus pacotes, fora do git), mesmo quando o SDK tem uma melhor e toca na frente.",
+    sound: "A = arquivo, S = sintetizado, F = faltando. O que tem arquivo toca o arquivo; o resto toca o som atual.",
+    strike: "Toca impact_<material>_<golpe>: o arquivo se existir, sen\xE3o o som atual daquele material.",
+    wall: "P\xF5e a parede de casa entre voc\xEA e a fonte: o som fica abafado (C4).",
+    burst: "Vinte vezes a cada 60 ms, como uma rajada (C9).",
+    ab_cycle: "A, B, A, B, um por segundo.",
+    blind: "Toca A ou B sem dizer qual; depois revele.",
+    measure: "Mede o som escolhido no motor real (contexto offline): sincronia, som certo, dist\xE2ncia, lado, varia\xE7\xE3o, volume, for\xE7a, cauda e rajada.",
+    record: "Grava 3 s da sa\xEDda com o som tocando e baixa o arquivo (C10).",
+    approve: "Marca o C10 do som escolhido como aprovado pelo seu ouvido."
+  },
+  categories: {
+    armas: "Armas",
+    impactos: "Impactos",
+    "explosoes-fogo": "Explos\xF5es e fogo",
+    personagem: "Personagem",
+    veiculos: "Ve\xEDculos",
+    "itens-portas": "Itens e portas",
+    ambiente: "Ambiente",
+    calibracao: "Calibra\xE7\xE3o (SDK)"
+  },
+  blows: { bullet: "tiro", blunt: "soco/chute", blade: "faca", break: "quebra", drag: "arrasto/queda" },
+  materials: {
+    steel: "a\xE7o",
+    aluminium: "alum\xEDnio",
+    wood: "madeira",
+    plywood: "compensado",
+    mdf: "MDF",
+    glass: "vidro",
+    tempered_glass: "vidro temperado",
+    ceramic: "cer\xE2mica",
+    concrete: "concreto",
+    brick: "tijolo",
+    plaster: "gesso",
+    plastic: "pl\xE1stico",
+    fabric: "tecido",
+    paper: "papel\xE3o",
+    foliage: "folhagem",
+    soil: "terra",
+    flesh: "carne"
+  },
+  environments: { indoor: "interior", outdoor: "exterior" },
+  strengths: { light: "leve", medium: "m\xE9dio", heavy: "forte" },
+  states: { file: "A", synth: "S", missing: "F" },
+  criteria: { C1: "C1 Sincronia", C2: "C2 Certo p/ a\xE7\xE3o", C3: "C3 Dist\xE2ncia", C4: "C4 Posi\xE7\xE3o", C5: "C5 Varia\xE7\xE3o", C6: "C6 Volume", C7: "C7 Intensidade", C8: "C8 Cauda", C9: "C9 Rajada", C10: "C10 Escuta" },
+  metrics: { source: "1 \xB7 Fonte do que tocou", chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
+  run: { idle: "parada", measuring: "medindo\u2026", done: "pronta", failed: "falhou", recording: "gravando\u2026", recorded: "grava\xE7\xE3o baixada" },
+  words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono" },
+  sources: { sdk: "SDK", user: "seu som", synth: "sintetizado" },
+  probe: "Fonte do som",
+  wall: "Parede (oclus\xE3o)",
+  scenarios: { pipeline: "Arquivo \u2192 decodifica \u2192 toca (round-robin, cauda)", criteria: "Crit\xE9rios C1\u2013C9 no som de calibra\xE7\xE3o", loop: "Loop de arquivo: emenda sem buraco (crossfade)", panel: "Painel: categorias, matriz, A/B e parede" }
+};
+var EN2 = {
+  ...PT,
+  group: "Sound",
+  name: "Sound panel (files and C1\u2013C10)",
+  controls: {
+    category: "1 \xB7 Category",
+    sound: "1 \xB7 Sound",
+    play: "1 \xB7 \u25B6 Play",
+    play_user: "1 \xB7 \u25B6 Play yours",
+    material: "2 \xB7 Material",
+    blow: "2 \xB7 Blow",
+    strike: "2 \xB7 \u25B6 Play blow",
+    distance: "3 \xB7 Distance",
+    bearing: "3 \xB7 Bearing",
+    environment: "3 \xB7 Place",
+    strength: "3 \xB7 Strength",
+    wall: "3 \xB7 Behind the wall",
+    burst: "3 \xB7 Burst 20\xD7",
+    play_a: "4 \xB7 \u25B6 A (current)",
+    play_b: "4 \xB7 \u25B6 B (new)",
+    ab_cycle: "4 \xB7 Alternate A/B",
+    blind: "4 \xB7 Blind (X)",
+    reveal: "4 \xB7 Reveal X",
+    prefer_a: "4 \xB7 Prefer A",
+    prefer_b: "4 \xB7 Prefer B",
+    measure: "5 \xB7 Measure C1\u2013C10",
+    record: "5 \xB7 Record 3 s",
+    approve: "5 \xB7 Approve (C10)"
+  },
+  hints: {
+    play_user: "Plays your own take of this sound (from your packs, kept out of git), even where the SDK has a better one that plays first.",
+    sound: "A = file, S = synthesized, F = missing. A file plays the file; the rest plays the current sound.",
+    strike: "Plays impact_<material>_<blow>: the file if there is one, else the current sound of that material.",
+    wall: "Puts the house wall between you and the source: the sound is muffled (C4).",
+    burst: "Twenty times every 60 ms, like a burst (C9).",
+    ab_cycle: "A, B, A, B, one a second.",
+    blind: "Plays A or B without saying which; reveal it after.",
+    measure: "Measures the chosen sound through the real engine (offline context): sync, right sound, distance, side, variation, level, strength, tail and burst.",
+    record: "Records 3 s of the output with the sound playing and downloads it (C10).",
+    approve: "Marks C10 of the chosen sound as approved by your ear."
+  },
+  categories: { armas: "Weapons", impactos: "Impacts", "explosoes-fogo": "Explosions and fire", personagem: "Character", veiculos: "Vehicles", "itens-portas": "Items and doors", ambiente: "Ambience", calibracao: "Calibration (SDK)" },
+  blows: { bullet: "bullet", blunt: "punch/kick", blade: "knife", break: "break", drag: "drag/fall" },
+  materials: {
+    steel: "steel",
+    aluminium: "aluminium",
+    wood: "wood",
+    plywood: "plywood",
+    mdf: "MDF",
+    glass: "glass",
+    tempered_glass: "tempered glass",
+    ceramic: "ceramic",
+    concrete: "concrete",
+    brick: "brick",
+    plaster: "plaster",
+    plastic: "plastic",
+    fabric: "fabric",
+    paper: "cardboard",
+    foliage: "foliage",
+    soil: "soil",
+    flesh: "flesh"
+  },
+  environments: { indoor: "indoor", outdoor: "outdoor" },
+  strengths: { light: "light", medium: "medium", heavy: "heavy" },
+  criteria: { C1: "C1 Sync", C2: "C2 Right sound", C3: "C3 Distance", C4: "C4 Position", C5: "C5 Variation", C6: "C6 Level", C7: "C7 Strength", C8: "C8 Tail", C9: "C9 Burst", C10: "C10 Listening" },
+  metrics: { source: "1 \xB7 Source of what played", chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
+  run: { idle: "idle", measuring: "measuring\u2026", done: "done", failed: "failed", recording: "recording\u2026", recorded: "recording downloaded" },
+  words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner" },
+  sources: { sdk: "SDK", user: "your sound", synth: "synthesized" },
+  probe: "Sound source",
+  wall: "Wall (occlusion)",
+  scenarios: { pipeline: "File \u2192 decode \u2192 play (round-robin, tail)", criteria: "Criteria C1\u2013C9 on the calibration sound", loop: "File loop: seamless joins (crossfade)", panel: "Panel: categories, matrix, A/B and wall" }
+};
+var soundCheckTextOf = (locale) => locale.startsWith("en") ? EN2 : PT;
+
+// src/bench/sound-check.ts
+var SOUND_STRENGTHS = { light: 0.1, medium: 0.5, heavy: 0.9 };
+var CALIBRATION_CATEGORY = "calibracao";
+var CALIBRATION_BANK = { id: "calibration", samples: [CALIBRATION_SOUND, CALIBRATION_LOOP_SOUND] };
+var DISTANCES2 = [1, 10, 50, 200];
+var PROBE_ID2 = "sound_check_source";
+var WALL_ID = "sound_check_wall";
+var EYE = [0, 1.7, 3];
+var DRAWN_MAX = 11;
+var WALL_AT = -2.5;
+var LOG_LIMIT = 200;
+function createSoundCheckModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const text = soundCheckTextOf(locale);
+  const ownBanks = [CALIBRATION_BANK, ...options.banks ?? []];
+  const loader = calibrationLoader(options.loader ?? fetchLoader());
+  const log = [];
+  const catalog = options.catalog ?? [...SFX_CATALOG, ...SFX_IMPACTS];
+  let engine = options.engine ?? createAudioEngine({ banks: [GAME_SFX_BANK, ...ownBanks], samples: { loader } });
+  if (options.engine) for (const bank of ownBanks) engine.register(bank);
+  let host = null;
+  let results = [];
+  let run = "idle";
+  const verdicts = {};
+  const approvals = /* @__PURE__ */ new Set();
+  let blind = null;
+  const chosen = {
+    category: options.sound && options.sound !== CALIBRATION_ID ? catalog.find((entry) => entry.id === options.sound)?.category ?? CALIBRATION_CATEGORY : CALIBRATION_CATEGORY,
+    sound: options.sound ?? CALIBRATION_ID,
+    material: "concrete",
+    blow: "bullet",
+    distance: 10,
+    bearing: 0,
+    environment: "outdoor",
+    strength: "medium",
+    wall: false
+  };
+  const registry = () => engine.registry;
+  const entryOf = (id) => catalog.find((entry) => entry.id === id);
+  const stateOf = (id) => {
+    const entry = entryOf(id);
+    if (entry) return sfxState(entry, registry());
+    return registry().sample(id) ? "file" : registry().sound(id) ? "synth" : "missing";
+  };
+  const pairOf = (id) => {
+    const entry = entryOf(id);
+    const sample = registry().sample(id);
+    const current = entry?.current ?? sample?.fallback ?? (registry().sound(id) ? id : void 0);
+    return { a: current && registry().sound(current) ? current : null, b: sample ? id : null };
+  };
+  const soundsOf = (category) => {
+    if (category === CALIBRATION_CATEGORY) return registry().sampleIds().filter((id) => !entryOf(id));
+    return catalog.filter((entry) => entry.category === category).map((entry) => entry.id);
+  };
+  const sourceOfId = (id) => {
+    const state = stateOf(id);
+    if (state !== "file") return text.states[state];
+    const own = registry().sample(`${USER_SOUND_PREFIX}${id}`) ? " +seu" : "";
+    return `${text.states.file} ${text.sources[soundSourceOf({ kind: "sample", bank: registry().bankOf(id) })]}${own}`;
+  };
+  const label = (id) => {
+    const entry = entryOf(id);
+    return `${id}${entry ? ` \xB7 P${entry.priority}` : ""} \xB7 ${sourceOfId(id)}`;
+  };
+  const soundOptions = () => soundsOf(chosen.category).map((id) => ({ id, name: label(id) }));
+  const listener = () => {
+    const camera = host?.camera;
+    const three = host?.THREE;
+    if (typeof camera?.getWorldDirection !== "function" || typeof three?.Vector3 !== "function" || !camera.position) return { position: EYE, yaw: 0 };
+    const direction = camera.getWorldDirection(new three.Vector3());
+    return { position: [camera.position.x, camera.position.y, camera.position.z], yaw: Math.atan2(-direction.x, -direction.z) };
+  };
+  const offset = (ears, distance) => {
+    const bearing = chosen.bearing * Math.PI / 180;
+    const forward = [-Math.sin(ears.yaw), -Math.cos(ears.yaw)];
+    const right = [Math.cos(ears.yaw), -Math.sin(ears.yaw)];
+    return [ears.position[0] + distance * (forward[0] * Math.cos(bearing) + right[0] * Math.sin(bearing)), ears.position[1], ears.position[2] + distance * (forward[1] * Math.cos(bearing) + right[1] * Math.sin(bearing))];
+  };
+  const playOptions = (extra = {}) => {
+    const ears = listener();
+    engine.setListener(ears);
+    return { position: offset(ears, chosen.distance), environment: chosen.environment, intensity: SOUND_STRENGTHS[chosen.strength], occlusion: chosen.wall ? 1 : 0, ...extra };
+  };
+  const playId = (id, extra = {}) => {
+    if (!id) return null;
+    engine.unlock();
+    return engine.play(id, playOptions(extra));
+  };
+  const preferred = (id) => pairOf(id).b ?? pairOf(id).a ?? (registry().sound(id) ? id : null);
+  const play = () => playId(preferred(chosen.sound));
+  const playB = async (delay = 0) => {
+    const { b } = pairOf(chosen.sound);
+    if (!b) return;
+    if (engine.sampleStatus(b) !== "ready") await engine.loadSamples([b]);
+    playId(b, { delay });
+  };
+  const playUser = async () => {
+    const own = `${USER_SOUND_PREFIX}${chosen.sound}`;
+    if (!registry().sample(own)) return;
+    if (engine.sampleStatus(own) !== "ready") await engine.loadSamples([own]);
+    playId(own);
+  };
+  const playA = (delay = 0) => void playId(pairOf(chosen.sound).a, { delay });
+  const placeScenery = () => {
+    const scene = host?.scene;
+    if (typeof scene?.traverse !== "function") return;
+    const at = offset({ position: EYE, yaw: 0 }, Math.min(chosen.distance, DRAWN_MAX));
+    scene.traverse((object) => {
+      if (object.userData?.[PROBE_ID2] === true) object.position?.set(at[0], 0, at[2]);
+      if (object.userData?.[WALL_ID] === true) object.visible = chosen.wall;
+    });
+  };
+  const measure = async () => {
+    run = "measuring";
+    try {
+      engine.unlock();
+      const context = engine.output()?.context ?? null;
+      const bank = {
+        id: "measured",
+        sounds: registry().soundIds().map((id) => registry().sound(id)).filter((recipe) => recipe !== void 0),
+        loops: registry().loopIds().map((id) => registry().loop(id)).filter((recipe) => recipe !== void 0),
+        samples: registry().sampleIds().map((id) => registry().sample(id)).filter((sample) => sample !== void 0)
+      };
+      results = await measureCriteria({
+        sound: chosen.sound,
+        banks: [bank],
+        loader,
+        ...context ? { baseLatency: context.baseLatency ?? 0, outputLatency: context.outputLatency ?? 0 } : {},
+        ...options.actions?.[chosen.sound] ? { actions: options.actions[chosen.sound] } : {},
+        ...options.loudnessOrder ? { loudnessOrder: options.loudnessOrder } : {}
+      });
+      if (approvals.has(chosen.sound)) results = results.map((result) => result.id === "C10" ? { ...result, pass: true, value: text.words.approved } : result);
+      run = "done";
+    } catch (error) {
+      run = "failed";
+      results = [{ id: "C1", pass: false, value: error instanceof Error ? error.message : String(error), target: "" }];
+    }
+    ;
+    globalThis.__soundCheck = { sound: chosen.sound, results };
+    return results;
+  };
+  const record = async () => {
+    run = "recording";
+    const blob = await recordOutput(engine, 3, () => {
+      for (let index = 0; index < 4; index++) playId(preferred(chosen.sound), { delay: index * 0.6 });
+    });
+    const documentLike = globalThis.document;
+    if (blob && documentLike && typeof URL.createObjectURL === "function") {
+      const link = documentLike.createElement("a");
+      link.href = URL.createObjectURL(blob);
+      link.download = `${chosen.sound}-${chosen.environment}-${chosen.distance}m.webm`;
+      link.click();
+      run = "recorded";
+    } else run = blob ? "recorded" : "failed";
+  };
+  const approve = () => {
+    approvals.add(chosen.sound);
+    results = results.map((result) => result.id === "C10" ? { ...result, pass: true, value: text.words.approved } : result);
+    host?.log(`${chosen.sound}: C10 ${text.words.approved}`, { sound: chosen.sound }, "sound");
+  };
+  const prefer = (side) => {
+    verdicts[chosen.sound] = side;
+    const pair = pairOf(chosen.sound);
+    host?.log(`${chosen.sound}: ${text.words.prefers} ${side}`, { sound: chosen.sound, prefers: side, a: pair.a, b: pair.b }, "sound");
+  };
+  const controls = () => [
+    { kind: "choice", id: "category", name: text.controls.category, options: [...SFX_CATEGORIES, CALIBRATION_CATEGORY].map((id) => ({ id, name: text.categories[id] ?? id })), default: chosen.category },
+    { kind: "choice", id: "sound", name: text.controls.sound, hint: text.hints.sound, options: soundOptions(), default: chosen.sound },
+    { kind: "action", id: "play", name: text.controls.play },
+    { kind: "action", id: "play_user", name: text.controls.play_user, hint: text.hints.play_user },
+    { kind: "choice", id: "material", name: text.controls.material, options: SFX_MATERIALS.map(([id]) => ({ id, name: text.materials[id] })), default: chosen.material },
+    { kind: "choice", id: "blow", name: text.controls.blow, options: SFX_BLOWS.map((id) => ({ id, name: text.blows[id] })), default: chosen.blow },
+    { kind: "action", id: "strike", name: text.controls.strike, hint: text.hints.strike },
+    { kind: "choice", id: "distance", name: text.controls.distance, options: DISTANCES2.map((meters) => ({ id: String(meters), name: `${meters} m` })), default: String(chosen.distance) },
+    { kind: "number", id: "bearing", name: text.controls.bearing, unit: "\xB0", min: -180, max: 180, step: 15, default: chosen.bearing },
+    { kind: "choice", id: "environment", name: text.controls.environment, options: SAMPLE_ENVIRONMENTS.map((id) => ({ id, name: text.environments[id] })), default: chosen.environment },
+    { kind: "choice", id: "strength", name: text.controls.strength, options: Object.keys(SOUND_STRENGTHS).map((id) => ({ id, name: text.strengths[id] })), default: chosen.strength },
+    { kind: "boolean", id: "wall", name: text.controls.wall, hint: text.hints.wall, default: chosen.wall },
+    { kind: "action", id: "burst", name: text.controls.burst, hint: text.hints.burst },
+    { kind: "action", id: "play_a", name: text.controls.play_a },
+    { kind: "action", id: "play_b", name: text.controls.play_b },
+    { kind: "action", id: "ab_cycle", name: text.controls.ab_cycle, hint: text.hints.ab_cycle },
+    { kind: "action", id: "blind", name: text.controls.blind, hint: text.hints.blind },
+    { kind: "action", id: "reveal", name: text.controls.reveal },
+    { kind: "action", id: "prefer_a", name: text.controls.prefer_a },
+    { kind: "action", id: "prefer_b", name: text.controls.prefer_b },
+    { kind: "action", id: "measure", name: text.controls.measure, hint: text.hints.measure },
+    { kind: "action", id: "record", name: text.controls.record, hint: text.hints.record },
+    { kind: "action", id: "approve", name: text.controls.approve, hint: text.hints.approve }
+  ];
+  const line = (id) => {
+    const result = results.find((entry) => entry.id === id);
+    if (!result) return text.words.none;
+    return `${result.pass === null ? "\u25CC" : result.pass ? "\u2713" : "\u2717"} ${result.value}`;
+  };
+  const counts = () => {
+    const states = catalog.map((entry) => sfxState(entry, registry()));
+    const count = (state) => states.filter((each) => each === state).length;
+    return `${text.states.file} ${count("file")} \xB7 ${text.states.synth} ${count("synth")} \xB7 ${text.states.missing} ${count("missing")}`;
+  };
+  const strikeId = () => impactSoundId(chosen.material, chosen.blow);
+  const lastLine = () => {
+    const last = log.at(-1);
+    if (!last) return text.words.none;
+    const files = last.layers?.map((layer) => layer.url.split("/").pop()).join("+") ?? "";
+    return `${last.kind}:${last.fallbackOf ? `${last.fallbackOf}\u2192` : ""}${last.id}${last.tier ? `/${last.tier}` : ""} ${files}`.trim();
+  };
+  const sourceLine = () => {
+    const last = log.at(-1);
+    if (!last) return text.words.none;
+    const file = last.layers?.find((layer) => layer.role === "close")?.url.split("/").pop() ?? last.id;
+    return `${text.sources[soundSourceOf(last)]} \xB7 ${last.id.replace(USER_SOUND_PREFIX, "")} \xB7 ${file}`;
+  };
+  const metrics = () => [
+    { id: "source", name: text.metrics.source, read: sourceLine },
+    { id: "count", name: text.metrics.count, read: counts },
+    { id: "chosen", name: text.metrics.chosen, read: () => `${label(chosen.sound)}${registry().sample(chosen.sound) ? ` (${engine.sampleStatus(chosen.sound)})` : ""}` },
+    { id: "matrix", name: text.metrics.matrix, read: () => `${strikeId()} \xB7 ${text.states[stateOf(strikeId())]}${pairOf(strikeId()).a ? ` \xB7 A=${pairOf(strikeId()).a}` : ""}` },
+    { id: "ab", name: text.metrics.ab, read: () => `A ${pairOf(chosen.sound).a ?? text.words.none} \xB7 B ${pairOf(chosen.sound).b ?? text.words.none}` },
+    { id: "blind_state", name: text.metrics.blind, read: () => !blind ? text.words.none : blind.revealed ? `X = ${blind.side}` : text.words.hidden },
+    { id: "verdicts", name: text.metrics.verdicts, read: () => Object.entries(verdicts).map(([id, side]) => `${id} ${text.words.prefers} ${side}`).join("; ") || text.words.none },
+    { id: "last", name: text.metrics.last, read: lastLine },
+    { id: "state", name: text.metrics.state, read: () => text.run[run] },
+    ...CRITERIA.map((id) => ({ id: `criterion_${id.toLowerCase()}`, name: text.criteria[id], read: () => line(id) }))
+  ];
+  const act = (id) => {
+    if (id === "play") play();
+    else if (id === "play_user") void playUser();
+    else if (id === "strike") playId(preferred(strikeId()));
+    else if (id === "burst") for (let index = 0; index < 20; index++) playId(preferred(chosen.sound), { delay: index * 0.06 });
+    else if (id === "play_a") playA();
+    else if (id === "play_b") void playB();
+    else if (id === "ab_cycle") {
+      playA(0);
+      void playB(1).then(() => {
+        playA(2);
+        return playB(3);
+      });
+    } else if (id === "blind") {
+      const side = Math.random() < 0.5 ? "A" : "B";
+      blind = { side, revealed: false };
+      if (side === "A") playA();
+      else void playB();
+    } else if (id === "reveal" && blind) blind.revealed = true;
+    else if (id === "prefer_a") prefer("A");
+    else if (id === "prefer_b") prefer("B");
+    else if (id === "measure") void measure();
+    else if (id === "record") void record();
+    else if (id === "approve") approve();
+  };
+  const onChange = (change) => {
+    if (change.kind === "action") return act(change.id);
+    if (change.kind !== "control") return;
+    const { id, value } = change;
+    if (id === "category" && typeof value === "string") {
+      chosen.category = value;
+      const first = soundsOf(value)[0];
+      if (first) chosen.sound = first;
+      host?.bench?.patch("sound", { options: soundOptions(), value: chosen.sound });
+      results = [];
+    } else if (id === "sound" && typeof value === "string") {
+      chosen.sound = value;
+      results = [];
+      if (registry().sample(value)) void engine.loadSamples([value]);
+    } else if (id === "material" && typeof value === "string") chosen.material = value;
+    else if (id === "blow" && typeof value === "string") chosen.blow = value;
+    else if (id === "distance" && typeof value === "string") chosen.distance = Number(value);
+    else if (id === "bearing" && typeof value === "number") chosen.bearing = value;
+    else if (id === "environment" && (value === "indoor" || value === "outdoor")) chosen.environment = value;
+    else if (id === "strength" && typeof value === "string" && value in SOUND_STRENGTHS) chosen.strength = value;
+    else if (id === "wall" && typeof value === "boolean") chosen.wall = value;
+    placeScenery();
+  };
+  const items = () => {
+    const marked = (id, name, build) => ({
+      id,
+      name,
+      movable: false,
+      build: (THREE) => {
+        const root = build(THREE);
+        root.userData = root.userData ?? {};
+        root.userData[id] = true;
+        return root;
+      }
+    });
+    return [...options.probe ? [marked(PROBE_ID2, text.probe, options.probe)] : [], ...options.wall ? [marked(WALL_ID, text.wall, options.wall)] : []];
+  };
+  const area = () => ({
+    placements: [
+      ...options.probe ? [{ item: PROBE_ID2, position: offset({ position: EYE, yaw: 0 }, Math.min(chosen.distance, DRAWN_MAX)), asleep: true }] : [],
+      ...options.wall ? [{ item: WALL_ID, position: [0, 0, WALL_AT], asleep: true }] : []
+    ],
+    view: { eye: EYE, target: [0, 1.2, -8] }
+  });
+  const scenarios = () => [
+    {
+      id: "sample_pipeline",
+      name: text.scenarios.pipeline,
+      run: async ({ expect }) => {
+        const report = await engine.loadSamples([CALIBRATION_ID]);
+        expect(report.failed.length === 0 && engine.sampleStatus(CALIBRATION_ID) === "ready", "the calibration files load and decode", { failed: report.failed });
+        const started = [];
+        const offStarted = engine.watchVoices((event) => void started.push(event));
+        const handles = Array.from({ length: 6 }, (_, index) => engine.play(CALIBRATION_ID, { distance: 2, environment: index % 2 === 0 ? "indoor" : "outdoor" }));
+        offStarted();
+        expect(handles.every((handle) => handle?.kind === "sample"), "it plays the files, not the fallback", { kinds: handles.map((handle) => handle?.kind) });
+        const events = started.filter((event) => event.id === CALIBRATION_ID);
+        const takes = events.map((event) => event.layers?.find((layer) => layer.role === "close")?.url);
+        expect(takes.length === 6 && takes.every((take, index) => index === 0 || take !== takes[index - 1]), "never the same take twice in a row", { takes });
+        const tails = events.map((event) => event.layers?.find((layer) => layer.role === "tail")?.url ?? "");
+        expect(tails[0]?.endsWith("tail_in.wav") === true && tails[1]?.endsWith("tail_out.wav") === true, "the tail follows the place", { tails });
+        for (const handle of handles) handle?.stop();
+      }
+    },
+    {
+      id: "sample_criteria",
+      name: text.scenarios.criteria,
+      run: async ({ expect }) => {
+        const previous = chosen.sound;
+        chosen.sound = CALIBRATION_ID;
+        const measured = await measure();
+        chosen.sound = previous;
+        for (const result of measured) if (result.id !== "C10") expect(result.pass === true, `${result.id}: ${result.target}`, { value: result.value, data: result.data });
+      }
+    },
+    {
+      id: "sample_loop",
+      name: text.scenarios.loop,
+      run: async ({ expect }) => {
+        const report = await engine.loadSamples([CALIBRATION_LOOP_ID]);
+        expect(report.failed.length === 0, "the loop takes load and decode", { failed: report.failed });
+        engine.unlock();
+        engine.level("ambience");
+        const loop = engine.loop(CALIBRATION_LOOP_ID, { volume: 0.8 });
+        const wait = (ms2) => new Promise((resolve) => setTimeout(resolve, ms2));
+        const started = performance.now();
+        while (engine.level("ambience") < 0.01 && performance.now() - started < 2e3) await wait(20);
+        expect(performance.now() - started < 2e3, "the loop starts within 2 s", { ms: Math.round(performance.now() - started) });
+        await wait(200);
+        const levels = [];
+        for (let index = 0; index < 60; index++) {
+          levels.push(engine.level("ambience"));
+          await wait(40);
+        }
+        loop.stop();
+        const sorted = [...levels].sort((a, b) => a - b);
+        const median = sorted[Math.floor(sorted.length / 2)] ?? 0;
+        const lowest = sorted[0] ?? 0;
+        const dip = lowest > 0 && median > 0 ? 20 * Math.log10(lowest / median) : -Infinity;
+        expect(median > 0.01, "the loop sounds", { median });
+        expect(dip >= -6, "no seam: the level never dips more than 6 dB where two takes cross", { dip: Number(dip.toFixed(1)), lowest, median, levels: levels.map((level) => Number(level.toFixed(3))) });
+        await wait(200);
+        expect(engine.level("ambience") < median / 4, "stop silences it", { after: engine.level("ambience") });
+      }
+    },
+    {
+      id: "sound_panel",
+      name: text.scenarios.panel,
+      run: ({ expect }) => {
+        const categories = SFX_CATEGORIES.map((category) => soundsOf(category).length);
+        expect(categories.every((count) => count > 0), "every category lists its sounds", { categories });
+        expect(soundsOf("impactos").length >= SFX_MATERIALS.length * SFX_BLOWS.length, "the matrix has every material \xD7 blow");
+        const pair = pairOf(CALIBRATION_ID);
+        expect(pair.a === "sfx_pistol" && pair.b === CALIBRATION_ID, "A is the synthesized sound and B the file", pair);
+        const clear = engine.planSample(CALIBRATION_ID, { position: [0, 1.6, -10], occlusion: 0, seed: 1 });
+        const walled = engine.planSample(CALIBRATION_ID, { position: [0, 1.6, -10], occlusion: 1, seed: 1 });
+        expect((walled?.cutoff ?? Infinity) < (clear?.cutoff ?? 0) / 5, "behind the wall the sound is muffled", { clear: clear?.cutoff, walled: walled?.cutoff });
+      }
+    }
+  ];
+  return {
+    id: "sound_check_area",
+    name: text.name,
+    group: text.group,
+    ground: { surface: "concrete_slab" },
+    get engine() {
+      return engine;
+    },
+    items: () => items(),
+    area: () => area(),
+    controls: () => controls(),
+    metrics: () => metrics(),
+    scenarios: () => scenarios(),
+    measure,
+    results: () => results,
+    events: () => log,
+    play,
+    pair: () => pairOf(chosen.sound),
+    verdicts: () => ({ ...verdicts }),
+    approvals: () => [...approvals],
+    // the engine (and its context) is made on the first play or measure, not when the room loads the module
+    attach(lent) {
+      host = lent;
+      const shared = options.engine ? void 0 : lent.audio?.engine;
+      if (shared && shared !== engine) {
+        for (const bank of ownBanks) shared.register(bank);
+        shared.addSampleSource(isCalibrationUrl, loader);
+        engine = shared;
+      }
+      const offVoices = engine.watchVoices((event) => {
+        log.push(event);
+        if (log.length > LOG_LIMIT) log.splice(0, log.length - LOG_LIMIT);
+      });
+      lent.bench?.patch("sound", { options: soundOptions() });
+      const off = lent.bench?.onChange(onChange);
+      placeScenery();
+      return () => {
+        off?.();
+        offVoices();
+        host = null;
+      };
+    }
+  };
+}
+
+export {
+  createRng,
+  streamSeed,
+  streamFor,
+  drawBetween,
+  BUS_IDS,
+  BUILD_ORDERS,
+  DISTANCE_CURVES,
+  falloffGain,
+  isSilent,
+  cutoffDivisor,
+  DEFAULT_LISTENER,
+  PAN_LIMIT,
+  PAN_MIN_DISTANCE,
+  listenerDistance,
+  panFor,
+  VOICE_GROUPS,
+  BUS_PRIORITY,
+  DEFAULT_MAX_VOICES,
+  busPriority,
+  createVoiceManager,
+  planSound,
+  SAMPLE_ENVIRONMENTS,
+  DEFAULT_SAMPLE_FALLOFF,
+  DEFAULT_CROSSOVER,
+  DEFAULT_SAMPLE_PITCH,
+  DEFAULT_TAIL_GAIN,
+  DEFAULT_SAMPLE_CUTOFF_K,
+  OPEN_CUTOFF,
+  LAYER_FLOOR,
+  pickTake,
+  farMixAt,
+  crossGains,
+  sampleCutoff,
+  sampleUrls,
+  tierFor,
+  planSample,
+  CALIBRATION_ID,
+  encodeWav,
+  CALIBRATION_SOUND,
+  CALIBRATION_LOOP_ID,
+  CALIBRATION_LOOP_SOUND,
+  isCalibrationUrl,
+  calibrationLoader,
+  createSoundRegistry,
+  MIX_PROFILES,
+  DEFAULT_MIX,
+  resolveMix,
+  busGain,
+  fillNoise,
+  fillImpulse,
+  bufferOf,
+  buildChain,
+  globalContext,
+  unlockContext,
+  LOOP_START_ABOVE,
+  LOOP_SMOOTHING,
+  createLoopState,
+  DEFAULT_LOOP_CROSSFADE,
+  loopCrossfade,
+  CROSSFADE_STEPS,
+  equalPowerIn,
+  realize,
+  retunePlan,
+  createSetPicker,
+  fetchLoader,
+  inlineLoader,
+  createSampleStore,
+  realizeSample,
+  sampleLength,
+  limiterCurve2 as limiterCurve,
+  createAudioEngine,
+  dbOf,
+  peakOf,
+  peakIndex,
+  onsetIndex,
+  rmsDb,
+  centroidHz,
+  balanceOf,
+  ringSeconds,
+  countHits,
+  endDropDb,
+  CRITERIA,
+  CRITERIA_TARGETS,
+  measureCriteria,
+  recordOutput,
+  SFX_CATEGORIES,
+  SFX_CATALOG,
+  SFX_MATERIALS,
+  SFX_BLOWS,
+  impactSoundId,
+  SFX_IMPACTS,
+  sfxState,
+  SDK_LICENSES,
+  SFX_LAYERS,
+  SFX_TIERS,
+  parseSfxName,
+  splitTier,
+  sampleBankFromManifest,
+  KIT_CATEGORY_BUS,
+  KIT_SAMPLE_ALIASES,
+  kitSampleDefaults,
+  withAliases,
+  kitSampleBank,
+  loadKitSamples,
+  USER_SAMPLES_BANK,
+  KIT_SAMPLES_BANK,
+  USER_SOUND_PREFIX,
+  soundSourceOf,
+  userSampleBank,
+  loadUserSamples,
+  GAME_SFX_CLASSES,
+  GAME_SFX_FALLBACK,
+  noiseClassRecipe,
+  GAME_SFX_BANK,
+  LIBRARY_SOUNDS,
+  LIBRARY_LOOPS,
+  LIBRARY_BANK,
+  audioBenchTextOf,
+  BENCH_BANK,
+  createAudioTestModule,
+  soundCheckTextOf,
+  SOUND_STRENGTHS,
+  CALIBRATION_CATEGORY,
+  createSoundCheckModule
+};
+//# sourceMappingURL=chunk-KBTUANNG.js.map