@adatechnology/game-audio 0.3.5 → 0.4.0

package/dist/index.js

@@ -1,527 +1,54 @@
-// 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/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/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/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/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"
-    ]
-  }
-};
-
-// 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/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(envelope2, duration, level) {
-  return envelope2.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/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/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"
-    ]
-  }
-];
-
-// src/mix.ts
-var MIX_PROFILES = Object.fromEntries(
-  mix_profiles_default.map((profile) => [profile.id, profile])
-);
-var DEFAULT_MIX = "art_scene";
-function resolveMix(mix, profiles = MIX_PROFILES) {
-  if (typeof mix !== "string") return mix;
-  const profile = profiles[mix];
-  if (!profile) throw new Error(`game-audio: unknown mix profile "${mix}" (known: ${Object.keys(profiles).join(", ")})`);
-  return profile;
-}
-function busGain(setting) {
-  if (!setting) return 1;
-  return setting.muted ? 0 : setting.gain ?? 1;
-}
-
-// 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 owners = /* @__PURE__ */ new Map();
-  const registry = {
-    register(bank) {
-      for (const sound of bank.sounds ?? []) {
-        sounds.set(sound.id, sound);
-        owners.set(sound.id, bank.id);
-      }
-      for (const loop of bank.loops ?? []) {
-        loops.set(loop.id, loop);
-        owners.set(loop.id, bank.id);
-      }
-    },
-    patch(id, patch) {
-      const sound = sounds.get(id);
-      if (sound) sounds.set(id, mergeRecords(sound, patch));
-      const loop = loops.get(id);
-      if (loop) loops.set(id, mergeRecords(loop, patch));
-    },
-    remove(id) {
-      sounds.delete(id);
-      loops.delete(id);
-      owners.delete(id);
-    },
-    sound: (id) => sounds.get(id),
-    loop: (id) => loops.get(id),
-    soundIds: () => [...sounds.keys()],
-    loopIds: () => [...loops.keys()],
-    bankOf: (id) => owners.get(id)
-  };
-  for (const bank of banks) registry.register(bank);
-  return registry;
-}
-
-// 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)) };
+import {
+  BENCH_BANK,
+  BUILD_ORDERS,
+  BUS_IDS,
+  BUS_PRIORITY,
+  DEFAULT_LISTENER,
+  DEFAULT_MAX_VOICES,
+  DEFAULT_MIX,
+  DISTANCE_CURVES,
+  GAME_SFX_BANK,
+  GAME_SFX_CLASSES,
+  GAME_SFX_FALLBACK,
+  LIBRARY_BANK,
+  LIBRARY_LOOPS,
+  LIBRARY_SOUNDS,
+  LOOP_SMOOTHING,
+  LOOP_START_ABOVE,
+  MIX_PROFILES,
+  PAN_LIMIT,
+  PAN_MIN_DISTANCE,
+  VOICE_GROUPS,
+  audioBenchTextOf,
+  bufferOf,
+  buildChain,
+  busGain,
+  busPriority,
+  createAudioEngine,
+  createAudioTestModule,
+  createLoopState,
+  createRng,
+  createSetPicker,
+  createSoundRegistry,
+  createVoiceManager,
+  cutoffDivisor,
+  drawBetween,
+  falloffGain,
+  fillImpulse,
+  fillNoise,
+  globalContext,
+  isSilent,
+  listenerDistance,
+  noiseClassRecipe,
+  panFor,
+  planSound,
+  realize,
+  resolveMix,
+  retunePlan,
+  streamFor,
+  streamSeed,
+  unlockContext
+} from "./chunk-DZITVFMJ.js";
 
 // src/recipes/scene.ts
 var ATTACK = 2e-3;
@@ -600,1085 +127,184 @@ function sceneRecipe(id, layers, line, options = {}) {
   };
 }
 
-// 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/recipes/body-foley.ts
+import {
+  BODY_SOUND_IDS,
+  FOOTSTEP_SOUND_IDS,
+  GAIT_IDS,
+  LAND_SOUND_IDS,
+  LANDING_IDS,
+  SURFACE_IDS,
+  SWING_LEAD_SECONDS,
+  footstepSoundId
+} from "@adatechnology/game-contracts";
+var BODY_FOLEY_TAKES = 4;
+var TAKES = [
+  { f: 1, t: 1, v: 1 },
+  { f: 1.08, t: 0.9, v: 0.92 },
+  { f: 0.93, t: 1.12, v: 1.05 },
+  { f: 1.03, t: 1.05, v: 0.88 }
+];
+var FOOTSTEP_FALLOFF = { model: "inverse_square", k: 0.03, cutoffK: 0.03, minGain: 4e-3 };
+var BODY_FALLOFF = { model: "inverse_square", k: 0.012, cutoffK: 0.015, minGain: 4e-3 };
+var SURFACES = {
+  concrete: { heel: { f: 95, d: 0.05, vol: 0.55 }, roll: { type: "bandpass", f: 2300, q: 1.1, d: 0.05, vol: 0.38 }, grains: { count: 2, f: 4200, q: 2, spread: 0.04, vol: 0.08 } },
+  asphalt: { heel: { f: 90, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 1700, q: 0.9, d: 0.06, vol: 0.36 }, grains: { count: 4, f: 3600, q: 2.5, spread: 0.06, vol: 0.1 } },
+  wood: { heel: { f: 130, d: 0.08, vol: 0.55 }, roll: { type: "lowpass", f: 1300, q: 0.8, d: 0.06, vol: 0.3 }, ring: [{ f: 210, d: 0.1, vol: 0.18 }, { f: 470, d: 0.06, vol: 0.06 }] },
+  tile: { heel: { f: 110, d: 0.04, vol: 0.45 }, roll: { type: "bandpass", f: 3600, q: 2, d: 0.03, vol: 0.42 }, ring: [{ f: 1900, d: 0.03, vol: 0.05 }] },
+  dirt: { heel: { f: 75, d: 0.06, vol: 0.45 }, roll: { type: "lowpass", f: 750, q: 0.7, d: 0.09, vol: 0.4 }, grains: { count: 3, f: 1800, q: 1.5, spread: 0.07, vol: 0.06 } },
+  grass: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "highpass", f: 2600, q: 0.7, d: 0.13, vol: 0.28 }, grains: { count: 4, f: 5200, q: 1.2, spread: 0.1, vol: 0.07 } },
+  gravel: { heel: { f: 80, d: 0.05, vol: 0.4 }, roll: { type: "lowpass", f: 950, q: 0.8, d: 0.1, vol: 0.3 }, grains: { count: 8, f: 2600, q: 3, spread: 0.13, vol: 0.2 } },
+  sand: { heel: { f: 65, d: 0.06, vol: 0.3 }, roll: { type: "bandpass", f: 1500, q: 0.6, d: 0.16, vol: 0.3 }, grains: { count: 5, f: 4800, q: 1.5, spread: 0.12, vol: 0.05 } },
+  metal: { heel: { f: 120, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 2800, q: 1.5, d: 0.03, vol: 0.25 }, ring: [{ f: 420, d: 0.25, vol: 0.16 }, { f: 1130, d: 0.18, vol: 0.09 }, { f: 2470, d: 0.1, vol: 0.04 }] },
+  water: { heel: { f: 70, d: 0.04, vol: 0.25 }, roll: { type: "bandpass", f: 3e3, q: 1.2, d: 0.1, vol: 0.18 }, splash: { f: 1100, f2: 380, d: 0.22, vol: 0.55 }, grains: { count: 4, f: 2400, q: 6, spread: 0.18, vol: 0.12 } },
+  glass: { heel: { f: 90, d: 0.04, vol: 0.4 }, roll: { type: "highpass", f: 4500, q: 0.8, d: 0.06, vol: 0.2 }, grains: { count: 9, f: 6200, q: 5, spread: 0.12, vol: 0.22 }, ring: [{ f: 3900, d: 0.04, vol: 0.04 }, { f: 5300, d: 0.03, vol: 0.03 }] },
+  carpet: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "lowpass", f: 420, q: 0.7, d: 0.07, vol: 0.3 } }
 };
-
-// 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)"
-  ]
+var GAITS = {
+  walk: { vol: 1, bright: 1, toe: 0.075, short: 1 },
+  run: { vol: 1.35, bright: 1.25, toe: 0.035, short: 0.75 }
 };
-
-// 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"]] }
+var grainLayers = (g, take, start, scale) => Array.from(
+  { length: g.count },
+  (_, i) => sceneNoise({ type: "bandpass", f: [g.f * take.f * 0.85, g.f * take.f * 1.15], q: g.q, d: [8e-3, 0.02], vol: g.vol * scale * take.v, delay: start + (i + 0.5) / g.count * g.spread * take.t })
+);
+var ringLayers = (rings, take, scale, at = 0) => rings.map((r) => sceneTone({ f: r.f * take.f, d: r.d * take.t, vol: r.vol * scale * take.v, delay: at }));
+function footLayers(surface, take, gait, weight = 1) {
+  const s = SURFACES[surface];
+  const toe = gait.toe * take.t;
+  return [
+    sceneTone({ f: s.heel.f * take.f * weight ** -0.3, f2: s.heel.f * take.f * 0.6, d: s.heel.d * gait.short * take.t * weight ** 0.5, vol: s.heel.vol * gait.vol * take.v * weight ** 0.5 }),
+    sceneNoise({ type: "lowpass", f: 500 * gait.bright, d: 0.02 * take.t, vol: 0.18 * gait.vol * take.v * weight ** 0.5 }),
+    sceneNoise({ type: s.roll.type, f: [s.roll.f * take.f * gait.bright * 0.92, s.roll.f * take.f * gait.bright * 1.08], q: s.roll.q, d: s.roll.d * gait.short * take.t * weight ** 0.3, vol: s.roll.vol * gait.vol * take.v, delay: toe }),
+    ...s.grains ? grainLayers(s.grains, take, toe * 0.5, gait.vol * weight ** 0.5) : [],
+    ...s.ring ? ringLayers(s.ring, take, gait.vol * weight ** 0.5) : [],
+    ...s.splash ? [sceneNoise({ type: "bandpass", f: s.splash.f * take.f, f2: s.splash.f2 * take.f, q: 1.4, d: s.splash.d * take.t * weight ** 0.4, vol: s.splash.vol * gait.vol * take.v * weight ** 0.5 })] : []
+  ];
+}
+var quieter = (level, layers) => layers.map((layer) => {
+  const gain = layer.gain ?? 1;
+  if (typeof gain === "number") return { ...layer, gain: gain * level };
+  if (Array.isArray(gain)) return { ...layer, gain: [gain[0] * level, gain[1] * level] };
+  return layer;
+});
+var recipe = (id, layers, falloff, bus = "world") => ({ id, bus, pan: true, layers, falloff, sources: ["sdk"] });
+var takeId = (id, index) => `${id}_${String(index + 1).padStart(2, "0")}`;
+function takes(id, layersOf, falloff, rate = [0.96, 1.04], bus) {
+  const sounds = TAKES.map((take, index) => recipe(takeId(id, index), layersOf(take, index), falloff, bus));
+  return { sounds, set: { id, variants: sounds.map((sound) => sound.id), rate } };
+}
+var footstep = (surface, gait) => takes(footstepSoundId(surface, gait), (take) => footLayers(surface, take, GAITS[gait]), FOOTSTEP_FALLOFF);
+var LANDINGS = { light: { weight: 1.4, cloth: 0.12 }, heavy: { weight: 2.4, cloth: 0.22 } };
+var LANDING_LEVEL = 0.65;
+var landing = (surface, landing2) => takes(
+  `land_${surface}_${landing2}`,
+  (take) => quieter(LANDING_LEVEL, [
+    // both feet, a hair apart, then the knees taking the weight (a low body thump) and the clothes settling
+    ...footLayers(surface, take, GAITS.run, LANDINGS[landing2].weight),
+    ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer) => ({ ...layer, at: (typeof layer.at === "number" ? layer.at : 0) + 0.018 * take.t })),
+    sceneTone({ f: 60 * take.f, f2: 38, d: 0.14 * LANDINGS[landing2].weight * take.t, vol: 0.22 * LANDINGS[landing2].weight ** 0.7 * take.v, delay: 0.02 }),
+    sceneNoise({ type: "bandpass", f: [1800, 2600], q: 0.8, d: 0.18, vol: LANDINGS[landing2].cloth * take.v, delay: 0.04 })
+  ]),
+  FOOTSTEP_FALLOFF
+);
+var whoosh = (blow, from, to, d, vol, q = 1.6) => (take) => [
+  // the air: a band sweeping up as the limb speeds up; it peaks `SWING_LEAD_SECONDS` in, the moment before the contact, then dies away
+  sceneNoise({ type: "bandpass", f: from * take.f, f2: to * take.f, q, a: SWING_LEAD_SECONDS[blow], d: d * take.t, vol: vol * take.v }),
+  sceneNoise({ type: "lowpass", f: 600 * take.f, a: SWING_LEAD_SECONDS[blow], d: d * take.t * 0.8, vol: vol * 0.35 * take.v })
+];
+var fleshHit = (o) => (take) => [
+  sceneNoise({ type: "bandpass", f: o.slapF * take.f, q: 1.2, d: 0.03 * take.t, vol: o.slap * take.v }),
+  sceneNoise({ type: "highpass", f: 3500 * take.f, d: 0.012, vol: o.slap * 0.4 * take.v }),
+  sceneTone({ f: o.thudF * take.f, f2: o.thudF * 0.5, d: o.thudD * take.t, vol: o.thud * take.v }),
+  sceneNoise({ type: "lowpass", f: 600 * take.f, d: o.thudD * 1.2 * take.t, vol: o.thud * 0.5 * take.v }),
+  ...o.crack ? [sceneNoise({ type: "highpass", f: 2500, d: 0.015, vol: o.crack * take.v, delay: 6e-3 }), sceneTone({ wave: "square", f: 900 * take.f, f2: 300, d: 0.02, vol: o.crack * 0.15 * take.v, delay: 6e-3 })] : [],
+  ...o.wet ? [sceneNoise({ type: "bandpass", f: 1400 * take.f, f2: 500, q: 2.5, d: 0.12 * take.t, vol: o.wet * take.v, delay: 0.01 })] : []
+];
+var knock = (o) => (take) => [
+  sceneNoise({ type: "bandpass", f: o.clickF * take.f, q: 1.5, d: 0.018, vol: o.click * take.v }),
+  ...o.tones.map(([f, d, vol]) => sceneTone({ f: f * take.f, d: d * take.t, vol: vol * take.v }))
+];
+var voice = (o) => (take) => [
+  sceneVoice({ f0: o.f0 * take.f, f1: o.f1 * take.f, d: o.d * take.t, fA: o.fA * take.f, fB: o.fB * take.f, noise: o.noise, vol: o.vol * take.v })
+];
+var BODY = {
+  jump: (take) => [
+    sceneNoise({ type: "bandpass", f: 900 * take.f, f2: 1700 * take.f, q: 1, a: 0.03, d: 0.12, vol: 0.18 * take.v }),
+    sceneNoise({ type: "bandpass", f: 2200 * take.f, q: 0.8, d: 0.04, vol: 0.12 * take.v }),
+    sceneTone({ f: 85 * take.f, f2: 60, d: 0.04, vol: 0.2 * take.v })
   ],
-  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"]]
-    }
+  cloth_rustle: (take) => [
+    { ...sceneNoise({ type: "bandpass", f: 2400 * take.f, q: 0.8, a: 0.06, d: 0.22 * take.t, vol: 0.12 * take.v }), modulators: [{ target: "gain", wave: "triangle", rate: [9, 14], depth: 0.5 }] }
   ],
-  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"]]
-    }
+  body_fall: (take) => [
+    sceneTone({ f: 58 * take.f, f2: 35, d: 0.28 * take.t, vol: 0.9 * take.v }),
+    sceneNoise({ type: "lowpass", f: 480 * take.f, d: 0.3 * take.t, vol: 0.55 * take.v }),
+    sceneNoise({ type: "bandpass", f: 1300 * take.f, q: 1, d: 0.05, vol: 0.3 * take.v }),
+    // the limbs a moment later, and the clothes
+    sceneTone({ f: 75 * take.f, f2: 45, d: 0.12, vol: 0.4 * take.v, delay: 0.13 * take.t }),
+    sceneNoise({ type: "bandpass", f: 2200, q: 0.8, d: 0.2, vol: 0.12 * take.v, delay: 0.05 })
+  ],
+  fall_damage: (take) => [
+    ...BODY.body_fall(take),
+    sceneNoise({ type: "highpass", f: 2800, d: 0.02, vol: 0.35 * take.v, delay: 0.01 }),
+    ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer) => ({ ...layer, at: 0.08 }))
+  ],
+  player_hurt: voice({ f0: 150, f1: 105, d: 0.26, fA: 620, fB: 1100, noise: 0.3, vol: 0.35 }),
+  player_breath_run: (take) => [
+    sceneNoise({ type: "bandpass", f: 1200 * take.f, q: 1, a: 0.08, d: 0.22 * take.t, vol: 0.25 * take.v }),
+    sceneNoise({ type: "bandpass", f: 900 * take.f, q: 1, a: 0.06, d: 0.26 * take.t, vol: 0.3 * take.v, delay: 0.3 * take.t })
+  ],
+  player_death: voice({ f0: 135, f1: 68, d: 1, fA: 560, fB: 980, noise: 0.35, vol: 0.4 }),
+  bite: (take) => [
+    sceneNoise({ type: "highpass", f: 2600, d: 0.015, vol: 0.4 * take.v }),
+    sceneNoise({ type: "bandpass", f: 1600 * take.f, f2: 450, q: 2.2, d: 0.16 * take.t, vol: 0.55 * take.v, delay: 0.01 }),
+    sceneNoise({ type: "bandpass", f: 3200 * take.f, f2: 1800, q: 1.2, d: 0.22 * take.t, vol: 0.25 * take.v, delay: 0.09 }),
+    sceneTone({ f: 120 * take.f, f2: 70, d: 0.06, vol: 0.3 * take.v })
+  ],
+  grab: (take) => [
+    sceneNoise({ type: "bandpass", f: 1900 * take.f, q: 0.9, a: 4e-3, d: 0.13 * take.t, vol: 0.32 * take.v }),
+    sceneTone({ f: 95 * take.f, f2: 60, d: 0.07, vol: 0.3 * take.v }),
+    sceneNoise({ type: "lowpass", f: 700, d: 0.08, vol: 0.2 * take.v })
   ],
-  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)"]
+  punch_swing: whoosh("punch", 450, 1500, 0.16, 0.9),
+  punch_hit_body: fleshHit({ slap: 0.55, slapF: 1500, thud: 0.6, thudF: 115, thudD: 0.09 }),
+  punch_hit_face: fleshHit({ slap: 0.75, slapF: 2300, thud: 0.45, thudF: 150, thudD: 0.07, crack: 0.25 }),
+  punch_hit_object: knock({ clickF: 1800, click: 0.3, tones: [[210, 0.04, 0.25]] }),
+  kick_swing: whoosh("kick", 280, 950, 0.22, 1, 1.3),
+  kick_hit: fleshHit({ slap: 0.45, slapF: 1100, thud: 0.85, thudF: 82, thudD: 0.14 }),
+  kick_hit_object: knock({ clickF: 1e3, click: 0.3, tones: [[92, 0.08, 0.5]] }),
+  shove_two_hands: (take) => [
+    sceneNoise({ type: "bandpass", f: 950 * take.f, q: 0.9, a: 0.01, d: 0.13 * take.t, vol: 0.38 * take.v }),
+    sceneTone({ f: 100 * take.f, f2: 60, d: 0.1 * take.t, vol: 0.45 * take.v }),
+    sceneNoise({ type: "bandpass", f: 2300, q: 0.8, d: 0.16, vol: 0.12 * take.v, delay: 0.03 })
+  ],
+  knife_swing: whoosh("blade", 1900, 4600, 0.12, 1.1, 2.2),
+  knife_stab: fleshHit({ slap: 0.2, slapF: 1200, thud: 0.4, thudF: 160, thudD: 0.06, wet: 0.5 }),
+  knife_slash: (take) => [
+    sceneNoise({ type: "highpass", f: 3200 * take.f, f2: 1800, d: 0.13 * take.t, vol: 0.35 * take.v }),
+    sceneNoise({ type: "bandpass", f: 1300 * take.f, f2: 600, q: 2.5, d: 0.12 * take.t, vol: 0.35 * take.v, delay: 0.02 })
+  ],
+  knife_hit_object: knock({ clickF: 3200, click: 0.25, tones: [[2800, 0.08, 0.07], [4150, 0.06, 0.05]] }),
+  blunt_swing: whoosh("blunt", 220, 760, 0.28, 1.1, 1.5),
+  blunt_hit: fleshHit({ slap: 0.35, slapF: 900, thud: 1, thudF: 70, thudD: 0.18, crack: 0.3 }),
+  blunt_hit_object: knock({ clickF: 1400, click: 0.35, tones: [[300, 0.12, 0.25], [760, 0.08, 0.12]] }),
+  axe_swing: whoosh("chop", 190, 620, 0.3, 1.2, 1.4),
+  axe_chop: fleshHit({ slap: 0.3, slapF: 1400, thud: 0.75, thudF: 140, thudD: 0.1, crack: 0.35, wet: 0.45 }),
+  axe_hit_object: knock({ clickF: 2200, click: 0.4, tones: [[1500, 0.15, 0.1], [2300, 0.1, 0.06], [140, 0.1, 0.35]] })
 };
-
-// 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/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
-function buildChain(context, profile, random) {
-  let compressor;
-  if (profile.compressor) {
-    compressor = context.createDynamicsCompressor();
-    compressor.threshold.value = profile.compressor.threshold;
-    compressor.ratio.value = profile.compressor.ratio;
-    if (profile.compressor.knee !== void 0) compressor.knee.value = profile.compressor.knee;
-    if (profile.compressor.attack !== void 0) compressor.attack.value = profile.compressor.attack;
-    if (profile.compressor.release !== void 0) compressor.release.value = profile.compressor.release;
-    compressor.connect(context.destination);
-  }
-  const master = context.createGain();
-  master.gain.value = profile.master;
-  master.connect(compressor ?? context.destination);
-  if (!profile.reverb) {
-    return {
-      master,
-      disconnect: () => {
-        master.disconnect();
-        compressor?.disconnect();
-      }
-    };
-  }
-  const convolver = context.createConvolver();
-  const 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();
-    }
-  };
-}
-
-// 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") void context.resume();
-}
-
-// 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
-var fixed = (range) => typeof range === "number" ? range : 0;
-var fixedFrequency = (automation) => fixed("set" in automation ? automation.set : automation.from);
-function sourceOf(recipe, target) {
-  if (recipe.source.kind === "noise") return { source: noiseSource(target, true) };
-  const oscillator = target.context.createOscillator();
-  oscillator.type = recipe.source.wave;
-  if (recipe.source.frequency) oscillator.frequency.value = fixedFrequency(recipe.source.frequency);
-  return { source: oscillator, frequency: oscillator.frequency };
-}
-function stopAll(sources) {
-  return () => {
-    for (const source of sources) {
-      try {
-        source.stop();
-      } catch {
-      }
-    }
-  };
-}
-function realizeGameLoop(recipe, target) {
-  const { context } = target;
-  const gain = context.createGain();
-  const filters = (recipe.filters?.bank ?? []).map(() => context.createBiquadFilter());
-  gain.gain.value = 0;
-  const last = filters.reduce((previous, filter) => previous ? previous.connect(filter) : filter, void 0);
-  last?.connect(gain);
-  gain.connect(target.output);
-  const { source, frequency } = sourceOf(recipe, target);
-  recipe.filters?.bank.forEach((spec, index) => {
-    const filter = filters[index];
-    filter.type = spec.type;
-    filter.frequency.value = fixedFrequency(spec.frequency);
-    if (spec.q !== void 0) filter.Q.value = fixed(spec.q);
-  });
-  const sources = [source];
-  for (const modulator of recipe.modulators ?? []) {
-    const lfo = context.createOscillator();
-    const depth = context.createGain();
-    const stage = context.createGain();
-    if (modulator.wave) lfo.type = modulator.wave;
-    lfo.frequency.value = fixed(modulator.rate);
-    depth.gain.value = fixed(modulator.depth);
-    stage.gain.value = modulator.base ?? 0;
-    lfo.connect(depth);
-    depth.connect(stage.gain);
-    last?.disconnect();
-    last?.connect(stage);
-    stage.connect(gain);
-    lfo.start();
-    sources.push(lfo);
-  }
-  source.connect(filters[0] ?? gain);
-  source.start();
-  return { gain, source, ...frequency ? { frequency } : {}, stop: stopAll(sources) };
-}
-function realizeChainLoop(recipe, target, volume) {
-  const { context } = target;
-  const { source, frequency } = sourceOf(recipe, target);
-  const filters = (recipe.filters?.bank ?? []).map(
-    (spec) => filterNode(context, { type: spec.type, frequency: { value: fixedFrequency(spec.frequency) }, ...spec.q === void 0 ? {} : { q: fixed(spec.q) } }, target.time)
-  );
-  const gain = gainNode(context, volume);
-  const lfos = (recipe.modulators ?? []).map((modulator) => {
-    const lfo = context.createOscillator();
-    if (modulator.wave) lfo.type = modulator.wave;
-    lfo.frequency.value = fixed(modulator.rate);
-    const depth = gainNode(context, fixed(modulator.depth));
-    lfo.connect(depth);
-    depth.connect(gain.gain);
-    return lfo;
-  });
-  let tail = source;
-  for (const filter of filters) tail = tail.connect(filter);
-  tail.connect(gain);
-  gain.connect(target.output);
-  source.start();
-  for (const lfo of lfos) lfo.start();
-  return { gain, source, ...frequency ? { frequency } : {}, stop: stopAll([source, ...lfos]) };
-}
-
-// 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?.gain.disconnect();
-      nodes?.gain.connect(host.output(loopRecipe.bus));
-    },
-    stop() {
-      nodes?.stop();
-      nodes?.gain.disconnect();
-      nodes = void 0;
-      state = createLoopState(loopRecipe);
-      host.unregister(entry);
-    }
-  };
-  const create = (context, startVolume) => {
-    if (loopRecipe.source.kind === "noise") host.prepareNoise();
-    const target = { context, output: host.output(loopRecipe.bus), noise: host.noise, time: context.currentTime };
-    const made = isChain ? realizeChainLoop(loopRecipe, target, startVolume) : realizeGameLoop(loopRecipe, target);
-    host.register(entry);
-    return made;
-  };
-  const open = () => {
-    const context = host.ready();
-    if (!context) return;
-    nodes = create(context, opening);
-    state = createLoopState({ ...loopRecipe, volume: opening }, true);
-  };
-  if (isChain) open();
-  return {
-    set(next) {
-      if (isChain && !nodes) open();
-      const context = host.ready();
-      if (!context) return;
-      const action = state.set(next);
-      if (!action) return;
-      nodes ?? (nodes = create(context, 0));
-      nodes.gain.gain.setTargetAtTime(action.volume, context.currentTime, smoothing.volume);
-      if (action.frequency !== void 0 && nodes.frequency) nodes.frequency.setTargetAtTime(action.frequency, context.currentTime, smoothing.frequency);
-    },
-    stop: entry.stop
-  };
-}
-
-// 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
-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;
-  const drain = () => {
-    scheduled = false;
-    const began = nowMs();
-    while (jobs.length > 0) {
-      const job = jobs.shift();
-      if (nowMs() - job.queuedAt > maxLatencyMs) job.drop();
-      else job.run();
-      if (nowMs() - began >= budgetMs) break;
-    }
-    if (jobs.length > 0) schedule();
-  };
-  const schedule = () => {
-    if (scheduled) return;
-    scheduled = true;
-    scheduleTask(drain);
-  };
-  return {
-    push(job) {
-      jobs.push({ ...job, queuedAt: nowMs() });
-      schedule();
-    },
-    clear() {
-      for (const job of jobs) job.drop();
-      jobs = [];
-    },
-    get size() {
-      return jobs.length;
-    }
-  };
-}
-
-// 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 envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer.envelope, time);
-    oscillator.connect(envelope2);
-    envelope2.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 outputStage(plan, layer, target) {
-  const { context } = target;
-  const level = gainNode(context, layer.level);
-  let node = level;
-  if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
-    const panner = context.createStereoPanner();
-    panner.pan.value = plan.pan;
-    level.connect(panner);
-    node = panner;
-  }
-  node.connect(target.output);
-  if (layer.wet && target.wet) {
-    const send = gainNode(context, layer.wet);
-    node.connect(send);
-    send.connect(target.wet);
-  }
-  return level;
-}
-function realizeNoiseLayer(plan, layer, target) {
-  const { context } = target;
-  const time = target.time + layer.at;
-  const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
-  const filters = (layer.filters?.bank ?? []).map((filter) => {
-    const node = filterNode(context, filter, time);
-    rampTo(node.frequency, filter.frequency, time);
-    return node;
-  });
-  const envelope2 = context.createGain();
-  applyEnvelope(envelope2.gain, layer.envelope, time);
-  let tail = source;
-  for (const filter of filters) tail = tail.connect(filter);
-  tail.connect(envelope2);
-  envelope2.connect(outputStage(plan, layer, target));
-  source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
-  source.stop(end2(layer, time));
-  return [source];
-}
-function realizeToneLayer(plan, layer, target) {
-  const { context } = target;
-  const time = target.time + layer.at;
-  const oscillator = context.createOscillator();
-  if (layer.source.kind === "osc") {
-    oscillator.type = layer.source.wave;
-    assign(oscillator.frequency, layer.source.frequency, time);
-    rampTo(oscillator.frequency, layer.source.frequency, time);
-  }
-  const envelope2 = context.createGain();
-  applyEnvelope(envelope2.gain, layer.envelope, time);
-  oscillator.connect(envelope2);
-  envelope2.connect(outputStage(plan, layer, target));
-  oscillator.start(time);
-  oscillator.stop(end2(layer, time));
-  return [oscillator];
-}
-function realizeVoiceLayer(plan, layer, target) {
-  const source = layer.source;
-  if (source.kind !== "formant_voice") return [];
-  const { context } = target;
-  const time = target.time + layer.at;
-  const oscillator = context.createOscillator();
-  oscillator.type = source.wave;
-  assign(oscillator.frequency, source.frequency, time);
-  rampTo(oscillator.frequency, source.frequency, time);
-  const vibrato = context.createOscillator();
-  vibrato.frequency.value = source.vibrato.rate;
-  const vibratoDepth = gainNode(context, source.vibrato.depth);
-  vibrato.connect(vibratoDepth);
-  vibratoDepth.connect(oscillator.frequency);
-  const formants = source.formants.map((formant) => filterNode(context, { type: "bandpass", frequency: { value: formant.frequency }, q: formant.q }, time));
-  const breath = noiseSource(target, true);
-  const breathBand = filterNode(context, { type: "bandpass", frequency: { value: source.breath.frequency }, q: source.breath.q }, time);
-  const breathLevel = gainNode(context, source.breath.gain);
-  const mix = gainNode(context, source.mix);
-  for (const formant of formants) oscillator.connect(formant);
-  breath.connect(breathBand);
-  breathBand.connect(breathLevel);
-  for (const formant of formants) formant.connect(mix);
-  breathLevel.connect(mix);
-  const envelope2 = context.createGain();
-  applyEnvelope(envelope2.gain, layer.envelope, time);
-  mix.connect(envelope2);
-  envelope2.connect(outputStage(plan, layer, target));
-  const stop = end2(layer, time);
-  oscillator.start(time);
-  vibrato.start(time);
-  breath.start(time, source.breath.offset);
-  oscillator.stop(stop);
-  vibrato.stop(stop);
-  breath.stop(stop);
-  return [oscillator, vibrato, breath];
-}
-function realizeLayered(plan, target) {
-  const sources = plan.layers.flatMap((layer) => {
-    if (layer.source.kind === "noise") return realizeNoiseLayer(plan, layer, target);
-    if (layer.source.kind === "osc") return realizeToneLayer(plan, layer, target);
-    return realizeVoiceLayer(plan, layer, target);
-  });
-  return voiceOf(sources);
-}
-function realizeSiren(plan, target) {
-  const { context } = target;
-  const layer = plan.layers[0];
-  const time = target.time + layer.at;
-  const oscillator = context.createOscillator();
-  if (layer.source.kind === "osc") {
-    oscillator.type = layer.source.wave;
-    assign(oscillator.frequency, layer.source.frequency, time);
-    rampTo(oscillator.frequency, layer.source.frequency, time);
-  }
-  const depths = layer.modulators.map((modulator) => {
-    const lfo = context.createOscillator();
-    if (modulator.wave) lfo.type = modulator.wave;
-    lfo.frequency.value = modulator.rate;
-    const depth = gainNode(context, modulator.depth);
-    lfo.connect(depth);
-    if (modulator.target === "frequency") depth.connect(oscillator.frequency);
-    return { lfo, depth, target: modulator.target };
-  });
-  const lfos = depths.map(({ lfo }) => lfo);
-  const envelope2 = context.createGain();
-  applyEnvelope(envelope2.gain, layer.envelope, time);
-  for (const { depth, target: modulated } of depths) if (modulated === "gain") depth.connect(envelope2.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(envelope2);
-  envelope2.connect(target.output);
-  if (layer.wet && target.wet) {
-    const send = gainNode(context, layer.wet);
-    envelope2.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 envelope2 = context.createGain();
-  applyEnvelope(envelope2.gain, layer.envelope, time);
-  let tail = source;
-  for (const filter of filters) tail = tail.connect(filter);
-  tail.connect(envelope2).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 envelope2 = context.createGain();
-  applyEnvelope(envelope2.gain, layer.envelope, time);
-  oscillator.connect(envelope2).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
+var BODY_BUS = { player_hurt: "voices", player_death: "voices", player_breath_run: "voices", fall_damage: "voices" };
+var built = [
+  ...SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstep(surface, gait))),
+  ...SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((l) => landing(surface, l))),
+  ...BODY_SOUND_IDS.map((id) => takes(id, BODY[id], BODY_FALLOFF, id.endsWith("_swing") ? [0.94, 1.06] : [0.96, 1.04], BODY_BUS[id]))
+];
+var BODY_FOLEY_BANK = {
+  id: "body_foley",
+  sounds: built.flatMap((entry) => entry.sounds),
+  sets: built.map((entry) => entry.set)
 };
-function realize(plan, target) {
-  return BUILDERS[plan.order](plan, target);
-}
-
-// src/webaudio/engine.ts
-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;
-  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) => {
-    const audio = context;
-    return realize(plan, {
-      context: audio,
-      output: outputFor(plan.bus),
-      ...chain?.wet ? { wet: chain.wet } : {},
-      noise: () => noiseBuffer(store, audio, mix.noise.seconds),
-      time: audio.currentTime + delay
-    });
-  };
-  const deferVoice = (plan, store, voiceId, delay) => {
-    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);
-      },
-      drop() {
-        if (voiceId === void 0) return;
-        voices.release(voiceId);
-        active.delete(voiceId);
-      }
-    });
-    return pending;
-  };
-  const start = (plan, store, voiceId, delay = 0) => {
-    const realized = startQueue ? deferVoice(plan, store, voiceId, delay) : build(plan, store, delay);
-    if (voiceId === void 0) return null;
-    voices.setLength(voiceId, plan.length + delay);
-    active.set(voiceId, realized);
-    return {
-      id: voiceId,
-      plan,
-      stop() {
-        realized.stop();
-        voices.release(voiceId);
-        active.delete(voiceId);
-      }
-    };
-  };
-  const admit = (recipe, gain, 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 playWith = (id, playOptions, random, store) => {
-    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, playOptions.seed === void 0 ? random : createRng(playOptions.seed)));
-    return plan ? start(plan, store, voiceId, playOptions.delay) : null;
-  };
-  const randomFor = (playOptions) => {
-    if (playOptions.channel === void 0) return engineRandom;
-    const existing = named.get(playOptions.channel);
-    if (existing) return existing;
-    const stream = streamFor(seed, playOptions.channel);
-    named.set(playOptions.channel, stream);
-    return stream;
-  };
-  const planWith = (id, playOptions, random) => {
-    const recipe = registry.sound(id);
-    return recipe ? planSound(recipe, inputFor(recipe, playOptions, random)) : null;
-  };
-  const loopHost = {
-    ready,
-    output: outputFor,
-    prepareNoise: () => context && prepareNoise(shared, context, mix.noise.seconds),
-    noise: () => noiseBuffer(shared, context, mix.noise.seconds),
-    register: (loop) => void loops.add(loop),
-    unregister: (loop) => void loops.delete(loop)
-  };
-  return {
-    registry,
-    register: (bank) => registry.register(bank),
-    plan: (id, playOptions = {}) => planWith(id, playOptions, createRng(playOptions.seed ?? seed)),
-    play: (id, playOptions = {}) => playWith(id, playOptions, randomFor(playOptions), shared),
-    playPlan(plan, playOptions = {}) {
-      const audio = ready();
-      if (!audio) return null;
-      advance();
-      const recipe = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
-      const voiceId = plan.silent ? void 0 : admit(recipe, plan.level, plan.distance);
-      if (voiceId === null) return null;
-      if (planUsesNoise(plan)) prepareNoise(shared, audio, mix.noise.seconds);
-      return start(plan, shared, voiceId, playOptions.delay);
-    },
-    loop: (id, loopOptions = {}) => createLoopHandle(registry.loop(id), loopHost, loopOptions.volume),
-    channel(channelOptions) {
-      const random = channelOptions.random ?? (channelOptions.seed === void 0 ? engineRandom : 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);
-    },
-    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();
-    }
-  };
-}
+var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
 
 // src/webaudio/sink.ts
 function createAudioSink(engine) {
@@ -1690,7 +316,8 @@ function createAudioSink(engine) {
         ...request.position ? { position: request.position } : {},
         ...request.volume === void 0 ? {} : { volume: request.volume },
         ...request.params ? { params: request.params } : {},
-        ...request.seed === void 0 ? {} : { seed: request.seed }
+        ...request.seed === void 0 ? {} : { seed: request.seed },
+        ...request.delay === void 0 ? {} : { delay: request.delay }
       });
       if (!handle) return null;
       playing.set(handle.id, handle);
@@ -1712,468 +339,12 @@ function createAudioSink(engine) {
     }
   };
 }
-
-// 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" },
-  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" },
-  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: "art_scene",
-    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 envelope2 = 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} [${envelope2}]`;
-    });
-    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;
-}
 export {
   BENCH_BANK,
+  BODY_FALLOFF,
+  BODY_FOLEY_BANK,
+  BODY_FOLEY_SET_IDS,
+  BODY_FOLEY_TAKES,
   BUILD_ORDERS,
   BUS_IDS,
   BUS_PRIORITY,
@@ -2181,6 +352,7 @@ export {
   DEFAULT_MAX_VOICES,
   DEFAULT_MIX,
   DISTANCE_CURVES,
+  FOOTSTEP_FALLOFF,
   GAME_SFX_BANK,
   GAME_SFX_CLASSES,
   GAME_SFX_FALLBACK,
@@ -2203,6 +375,7 @@ export {
   createAudioTestModule,
   createLoopState,
   createRng,
+  createSetPicker,
   createSoundRegistry,
   createVoiceManager,
   cutoffDivisor,
@@ -2218,6 +391,7 @@ export {
   planSound,
   realize,
   resolveMix,
+  retunePlan,
   sceneMany,
   sceneNoise,
   sceneRecipe,