@adatechnology/game-audio 0.4.0 → 0.5.0

package/dist/index.global.js

@@ -29,58 +29,129 @@ var GameAudio = (() => {
     BUILD_ORDERS: () => BUILD_ORDERS,
     BUS_IDS: () => BUS_IDS,
     BUS_PRIORITY: () => BUS_PRIORITY,
+    CALIBRATION_ID: () => CALIBRATION_ID,
+    CALIBRATION_LOOP_ID: () => CALIBRATION_LOOP_ID,
+    CALIBRATION_LOOP_SOUND: () => CALIBRATION_LOOP_SOUND,
+    CALIBRATION_SOUND: () => CALIBRATION_SOUND,
+    CRITERIA: () => CRITERIA,
+    CRITERIA_TARGETS: () => CRITERIA_TARGETS,
+    CROSSFADE_STEPS: () => CROSSFADE_STEPS,
+    DEFAULT_CROSSOVER: () => DEFAULT_CROSSOVER,
     DEFAULT_LISTENER: () => DEFAULT_LISTENER,
+    DEFAULT_LOOP_CROSSFADE: () => DEFAULT_LOOP_CROSSFADE,
     DEFAULT_MAX_VOICES: () => DEFAULT_MAX_VOICES,
     DEFAULT_MIX: () => DEFAULT_MIX,
+    DEFAULT_SAMPLE_CUTOFF_K: () => DEFAULT_SAMPLE_CUTOFF_K,
+    DEFAULT_SAMPLE_FALLOFF: () => DEFAULT_SAMPLE_FALLOFF,
+    DEFAULT_SAMPLE_PITCH: () => DEFAULT_SAMPLE_PITCH,
+    DEFAULT_TAIL_GAIN: () => DEFAULT_TAIL_GAIN,
     DISTANCE_CURVES: () => DISTANCE_CURVES,
+    FOLEY_BANK: () => FOLEY_BANK,
+    FOLEY_FALLOFF: () => FOLEY_FALLOFF,
     FOOTSTEP_FALLOFF: () => FOOTSTEP_FALLOFF,
     GAME_SFX_BANK: () => GAME_SFX_BANK,
     GAME_SFX_CLASSES: () => GAME_SFX_CLASSES,
     GAME_SFX_FALLBACK: () => GAME_SFX_FALLBACK,
+    ITEM_FOLEY: () => ITEM_FOLEY,
+    KIT_CATEGORY_BUS: () => KIT_CATEGORY_BUS,
+    KIT_SAMPLE_ALIASES: () => KIT_SAMPLE_ALIASES,
+    LAYER_FLOOR: () => LAYER_FLOOR,
+    LEAF_FOLEY: () => LEAF_FOLEY,
+    LEAF_FOLEY_SETS: () => LEAF_FOLEY_SETS,
     LIBRARY_BANK: () => LIBRARY_BANK,
     LIBRARY_LOOPS: () => LIBRARY_LOOPS,
     LIBRARY_SOUNDS: () => LIBRARY_SOUNDS,
     LOOP_SMOOTHING: () => LOOP_SMOOTHING,
     LOOP_START_ABOVE: () => LOOP_START_ABOVE,
     MIX_PROFILES: () => MIX_PROFILES,
+    OPEN_CUTOFF: () => OPEN_CUTOFF,
     PAN_LIMIT: () => PAN_LIMIT,
     PAN_MIN_DISTANCE: () => PAN_MIN_DISTANCE,
+    PICKUP_CLASSES: () => PICKUP_CLASSES,
+    SAMPLE_ENVIRONMENTS: () => SAMPLE_ENVIRONMENTS,
+    SDK_LICENSES: () => SDK_LICENSES,
+    SFX_BLOWS: () => SFX_BLOWS,
+    SFX_CATALOG: () => SFX_CATALOG,
+    SFX_CATEGORIES: () => SFX_CATEGORIES,
+    SFX_IMPACTS: () => SFX_IMPACTS,
+    SFX_LAYERS: () => SFX_LAYERS,
+    SFX_MATERIALS: () => SFX_MATERIALS,
+    SFX_TIERS: () => SFX_TIERS,
     VOICE_GROUPS: () => VOICE_GROUPS,
     audioBenchTextOf: () => audioBenchTextOf,
+    balanceOf: () => balanceOf,
     bufferOf: () => bufferOf,
     buildChain: () => buildChain,
     busGain: () => busGain,
     busPriority: () => busPriority,
+    calibrationLoader: () => calibrationLoader,
+    centroidHz: () => centroidHz,
+    countHits: () => countHits,
     createAudioEngine: () => createAudioEngine,
     createAudioSink: () => createAudioSink,
     createAudioTestModule: () => createAudioTestModule,
     createLoopState: () => createLoopState,
     createRng: () => createRng,
+    createSampleStore: () => createSampleStore,
     createSetPicker: () => createSetPicker,
     createSoundRegistry: () => createSoundRegistry,
     createVoiceManager: () => createVoiceManager,
+    crossGains: () => crossGains,
     cutoffDivisor: () => cutoffDivisor,
+    dbOf: () => dbOf,
     drawBetween: () => drawBetween,
+    encodeWav: () => encodeWav,
+    endDropDb: () => endDropDb,
+    equalPowerIn: () => equalPowerIn,
     falloffGain: () => falloffGain,
+    farMixAt: () => farMixAt,
+    fetchLoader: () => fetchLoader,
     fillImpulse: () => fillImpulse,
     fillNoise: () => fillNoise,
     globalContext: () => globalContext,
+    impactSoundId: () => impactSoundId,
+    inlineLoader: () => inlineLoader,
+    isCalibrationUrl: () => isCalibrationUrl,
     isSilent: () => isSilent,
+    kitSampleBank: () => kitSampleBank,
+    kitSampleDefaults: () => kitSampleDefaults,
+    limiterCurve: () => limiterCurve2,
     listenerDistance: () => listenerDistance,
+    loadKitSamples: () => loadKitSamples,
+    loopCrossfade: () => loopCrossfade,
+    measureCriteria: () => measureCriteria,
     noiseClassRecipe: () => noiseClassRecipe,
+    onsetIndex: () => onsetIndex,
     panFor: () => panFor,
+    parseSfxName: () => parseSfxName,
+    peakIndex: () => peakIndex,
+    peakOf: () => peakOf,
+    pickTake: () => pickTake,
+    planSample: () => planSample,
     planSound: () => planSound,
     realize: () => realize,
+    realizeSample: () => realizeSample,
+    recordOutput: () => recordOutput,
     resolveMix: () => resolveMix,
     retunePlan: () => retunePlan,
+    ringSeconds: () => ringSeconds,
+    rmsDb: () => rmsDb,
+    sampleBankFromManifest: () => sampleBankFromManifest,
+    sampleCutoff: () => sampleCutoff,
+    sampleLength: () => sampleLength,
+    sampleUrls: () => sampleUrls,
     sceneMany: () => sceneMany,
     sceneNoise: () => sceneNoise,
     sceneRecipe: () => sceneRecipe,
     sceneTone: () => sceneTone,
     sceneVoice: () => sceneVoice,
+    sfxState: () => sfxState,
+    splitTier: () => splitTier,
     streamFor: () => streamFor,
     streamSeed: () => streamSeed,
-    unlockContext: () => unlockContext
+    tierFor: () => tierFor,
+    unlockContext: () => unlockContext,
+    withAliases: () => withAliases
   });
 
   // src/rng.ts
@@ -177,6 +248,19 @@ var GameAudio = (() => {
         "jogo:L66986 one groan every 0.25 s (`groanBudget`), only nearer than 40 m",
         "jogo:L70472 the budget counts down by the frame time"
       ]
+    },
+    fire_ignite: {
+      maxConcurrent: 2,
+      cooldown: 0.15,
+      sources: [
+        "sdk: many parts catching at once (a blast sets a shelf alight) are one or two ignitions, not forty"
+      ]
+    },
+    fire_crackle: {
+      maxConcurrent: 4,
+      sources: [
+        "sdk: the crackles of every fire share four voices"
+      ]
     }
   };
 
@@ -446,69 +530,200 @@ var GameAudio = (() => {
     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(recipe2, open = false) {
-    const startAbove = recipe2.startAbove ?? LOOP_START_ABOVE;
-    let created = open;
-    let volume = recipe2.volume ?? 0;
+  // src/sample.ts
+  var SAMPLE_ENVIRONMENTS = ["indoor", "outdoor"];
+  var DEFAULT_SAMPLE_FALLOFF = { model: "inverse_square", k: 2e-3, minGain: 2e-3 };
+  var DEFAULT_CROSSOVER = { from: 30, to: 80 };
+  var DEFAULT_SAMPLE_PITCH = 0.04;
+  var DEFAULT_TAIL_GAIN = 0.6;
+  var DEFAULT_SAMPLE_CUTOFF_K = 0.01;
+  var OPEN_CUTOFF = 2e4;
+  var LAYER_FLOOR = 1e-3;
+  function pickTake(count, last, random) {
+    if (count <= 1) return 0;
+    if (last === void 0 || last < 0 || last >= count) return Math.min(count - 1, Math.floor(random() * count));
+    const drawn = Math.min(count - 2, Math.floor(random() * (count - 1)));
+    return drawn >= last ? drawn + 1 : drawn;
+  }
+  function farMixAt(crossover, distance) {
+    if (crossover.to <= crossover.from) return distance >= crossover.to ? 1 : 0;
+    const t = (distance - crossover.from) / (crossover.to - crossover.from);
+    return t <= 0 ? 0 : t >= 1 ? 1 : t;
+  }
+  function crossGains(farMix) {
+    return { close: Math.cos(farMix * Math.PI / 2), far: Math.sin(farMix * Math.PI / 2) };
+  }
+  function sampleCutoff(cutoffK, distance, occlusion = 0) {
+    const byDistance = cutoffK > 0 ? OPEN_CUTOFF / (1 + distance * cutoffK) : OPEN_CUTOFF;
+    const occluded = occlusion > 0 ? byDistance / (1 + occlusion * 9) : byDistance;
+    return Math.max(80, Math.min(OPEN_CUTOFF, occluded));
+  }
+  function sampleUrls(sound) {
+    const tiers = (sound.tiers ?? []).flatMap((tier) => [...tier.close, ...tier.far ?? []]);
+    const all = [...sound.close, ...sound.far ?? [], ...tiers, ...sound.tail?.indoor ?? [], ...sound.tail?.outdoor ?? []].map((ref) => ref.url);
+    return [...new Set(all)];
+  }
+  function tierFor(sound, intensity) {
+    if (intensity === void 0 || !sound.tiers) return void 0;
+    let chosen;
+    for (const tier of sound.tiers) if (tier.from <= intensity) chosen = tier;
+    return chosen ?? sound.tiers[0];
+  }
+  function planSample(sound, input) {
+    if (sound.close.length === 0) throw new Error(`sample sound ${sound.id} has no close take`);
+    const listener = input.listener ?? DEFAULT_LISTENER;
+    const distance = input.distance ?? (input.position ? listenerDistance(listener, input.position, input.distanceMode) : 0);
+    const falloff = sound.falloff ?? DEFAULT_SAMPLE_FALLOFF;
+    const occlusion = Math.max(0, Math.min(1, input.occlusion ?? 0));
+    const level = falloffGain(falloff, (input.volume ?? 1) * (sound.gain ?? 1), distance) * (1 - 0.45 * occlusion);
+    if (isSilent(falloff, level) || level <= 0) return null;
+    const pitch = sound.pitch ?? DEFAULT_SAMPLE_PITCH;
+    const rate = pitch > 0 ? 1 + (input.random() * 2 - 1) * pitch : 1;
+    const environment = input.environment ?? "outdoor";
+    const tier = tierFor(sound, input.intensity);
+    const close = tier?.close.length ? tier.close : sound.close;
+    const far = tier?.far?.length ? tier.far : sound.far ?? [];
+    const farMix = far.length > 0 ? farMixAt(sound.crossover ?? DEFAULT_CROSSOVER, distance) : 0;
+    const gains = crossGains(farMix);
+    const layers = [];
+    const take = (role, refs, gain, at) => {
+      if (refs.length === 0 || gain < LAYER_FLOOR) return;
+      const key = `${sound.id}/${tier && role !== "tail" ? `${tier.name}/` : ""}${role}`;
+      const index = pickTake(refs.length, input.memory?.get(key), input.random);
+      input.memory?.set(key, index);
+      const ref = refs[index];
+      layers.push({ role, url: ref.url, take: index, gain: gain * (ref.gain ?? 1) * level, rate, at });
+    };
+    take("close", close, gains.close, 0);
+    take("far", far, gains.far, 0);
+    const tails = sound.tail?.[environment] ?? [];
+    take("tail", tails, sound.tail?.gain ?? DEFAULT_TAIL_GAIN, sound.tail?.at ?? 0);
+    const pan = (sound.pan ?? true) && input.position ? panFor(listener, input.position) : void 0;
     return {
-      set(state) {
-        volume = state.volume ?? volume;
-        const create = !created;
-        if (create && !(volume >= startAbove)) return null;
-        created = true;
-        const frequency = recipe2.source.kind === "osc" && state.frequency ? state.frequency : void 0;
-        return { create, volume, ...frequency === void 0 ? {} : { frequency } };
-      },
-      get created() {
-        return created;
-      },
-      reset() {
-        created = false;
-      }
+      kind: "sample",
+      id: sound.id,
+      bus: sound.bus,
+      level,
+      distance,
+      ...pan === void 0 ? {} : { pan },
+      cutoff: sampleCutoff(sound.cutoffK ?? DEFAULT_SAMPLE_CUTOFF_K, distance, occlusion),
+      rate,
+      environment,
+      ...tier ? { tier: tier.name } : {},
+      farMix,
+      layers,
+      priority: sound.priority ?? input.priority ?? busPriority(sound.bus),
+      ...sound.group ? { group: sound.group } : {}
     };
   }
 
-  // src/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/measure/calibration.ts
+  var CALIBRATION_ID = "calibration_shot";
+  var CALIBRATION_RATE = 48e3;
+  function encodeWav(samples, sampleRate = CALIBRATION_RATE) {
+    const bytes = new ArrayBuffer(44 + samples.length * 2);
+    const view = new DataView(bytes);
+    const text = (at, value) => {
+      for (let index = 0; index < value.length; index++) view.setUint8(at + index, value.charCodeAt(index));
+    };
+    text(0, "RIFF");
+    view.setUint32(4, 36 + samples.length * 2, true);
+    text(8, "WAVE");
+    text(12, "fmt ");
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, 1, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * 2, true);
+    view.setUint16(32, 2, true);
+    view.setUint16(34, 16, true);
+    text(36, "data");
+    view.setUint32(40, samples.length * 2, true);
+    for (let index = 0; index < samples.length; index++) {
+      const value = Math.max(-1, Math.min(1, samples[index]));
+      view.setInt16(44 + index * 2, value < 0 ? value * 32768 : value * 32767, true);
     }
-  ];
-
-  // 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;
+    return bytes;
   }
-  function busGain(setting) {
-    if (!setting) return 1;
-    return setting.muted ? 0 : setting.gain ?? 1;
+  function shotSamples(shot, sampleRate = CALIBRATION_RATE) {
+    const random = createRng(shot.seed);
+    const length = Math.round(shot.seconds * sampleRate);
+    const samples = new Float32Array(length);
+    let low = 0;
+    let phase = 0;
+    const attack = Math.max(1, Math.round((shot.attack ?? 0) * sampleRate));
+    for (let index = 0; index < length; index++) {
+      const time = index / sampleRate;
+      const envelope2 = Math.exp(-time / shot.decay) * Math.min(1, (index + 1) / attack);
+      phase += 2 * Math.PI * shot.thump * (1 + 0.6 * Math.exp(-time * 30)) / sampleRate;
+      const noise = random() * 2 - 1;
+      low += shot.brightness * (noise - low);
+      const fade = Math.min(1, (length - index) / (0.01 * sampleRate));
+      samples[index] = shot.gain * envelope2 * fade * (0.55 * Math.sin(phase) + shot.noise * low);
+    }
+    return samples;
+  }
+  var TAKES = {
+    "close_1.wav": { seconds: 0.4, thump: 150, noise: 1, decay: 0.06, brightness: 0.9, gain: 0.85, seed: 1 },
+    "close_2.wav": { seconds: 0.4, thump: 160, noise: 1, decay: 0.065, brightness: 0.85, gain: 0.85, seed: 2 },
+    "close_3.wav": { seconds: 0.4, thump: 142, noise: 1, decay: 0.055, brightness: 0.95, gain: 0.85, seed: 3 },
+    "close_4.wav": { seconds: 0.4, thump: 170, noise: 1, decay: 0.07, brightness: 0.8, gain: 0.85, seed: 4 },
+    "far_1.wav": { seconds: 0.9, thump: 90, noise: 0.8, decay: 0.2, brightness: 0.08, gain: 0.7, seed: 5, attack: 4e-3 },
+    "far_2.wav": { seconds: 0.9, thump: 95, noise: 0.8, decay: 0.22, brightness: 0.07, gain: 0.7, seed: 6, attack: 4e-3 },
+    "light_1.wav": { seconds: 0.25, thump: 220, noise: 0.6, decay: 0.03, brightness: 0.6, gain: 0.35, seed: 7 },
+    "light_2.wav": { seconds: 0.25, thump: 230, noise: 0.6, decay: 0.03, brightness: 0.55, gain: 0.35, seed: 8 },
+    "heavy_1.wav": { seconds: 0.6, thump: 110, noise: 1.2, decay: 0.11, brightness: 0.95, gain: 0.95, seed: 9 },
+    "heavy_2.wav": { seconds: 0.6, thump: 105, noise: 1.2, decay: 0.12, brightness: 0.9, gain: 0.95, seed: 10 },
+    "tail_in.wav": { seconds: 0.5, thump: 0, noise: 1, decay: 0.08, brightness: 0.4, gain: 0.25, seed: 11, attack: 0.01 },
+    "tail_out.wav": { seconds: 2, thump: 0, noise: 1, decay: 0.45, brightness: 0.25, gain: 0.2, seed: 12, attack: 0.02 },
+    "loop_1.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.5, gain: 0.5, seed: 13, attack: 0.01 },
+    "loop_2.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.45, gain: 0.5, seed: 14, attack: 0.01 },
+    "loop_3.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.55, gain: 0.5, seed: 15, attack: 0.01 }
+  };
+  var PREFIX = "calibration/";
+  var url = (name) => `${PREFIX}${name}`;
+  var CALIBRATION_SOUND = {
+    id: CALIBRATION_ID,
+    bus: "weapons",
+    close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })),
+    far: ["far_1.wav", "far_2.wav"].map((name) => ({ url: url(name) })),
+    tiers: [
+      { name: "light", from: 0, close: ["light_1.wav", "light_2.wav"].map((name) => ({ url: url(name) })) },
+      { name: "medium", from: 0.34, close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })) },
+      { name: "heavy", from: 0.67, close: ["heavy_1.wav", "heavy_2.wav"].map((name) => ({ url: url(name) })) }
+    ],
+    tail: { indoor: [{ url: url("tail_in.wav") }], outdoor: [{ url: url("tail_out.wav") }] },
+    pitch: 0.04,
+    choke: { voices: 2 },
+    fallback: "sfx_pistol",
+    sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+  };
+  var CALIBRATION_LOOP_ID = "calibration_loop";
+  var CALIBRATION_LOOP_SOUND = {
+    id: CALIBRATION_LOOP_ID,
+    bus: "ambience",
+    close: ["loop_1.wav", "loop_2.wav", "loop_3.wav"].map((name) => ({ url: url(name) })),
+    loop: { crossfade: 0.15 },
+    sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+  };
+  var isCalibrationUrl = (url2) => url2.startsWith(PREFIX);
+  function calibrationLoader(next) {
+    const made = /* @__PURE__ */ new Map();
+    return async (requested) => {
+      if (!requested.startsWith(PREFIX)) {
+        if (next) return next(requested);
+        throw new Error(`not a calibration file: ${requested}`);
+      }
+      const name = requested.slice(PREFIX.length);
+      const shot = TAKES[name];
+      if (!shot) throw new Error(`no calibration take ${name}`);
+      let bytes = made.get(name);
+      if (!bytes) {
+        bytes = encodeWav(shotSamples(shot));
+        made.set(name, bytes);
+      }
+      return bytes.slice(0);
+    };
   }
 
   // src/bank.ts
@@ -528,6 +743,7 @@ var GameAudio = (() => {
     const sounds = /* @__PURE__ */ new Map();
     const loops = /* @__PURE__ */ new Map();
     const sets = /* @__PURE__ */ new Map();
+    const samples = /* @__PURE__ */ new Map();
     const owners = /* @__PURE__ */ new Map();
     const registry = {
       register(bank) {
@@ -544,293 +760,655 @@ var GameAudio = (() => {
           sets.set(set.id, set);
           owners.set(set.id, bank.id);
         }
+        for (const sample of bank.samples ?? []) {
+          samples.set(sample.id, sample);
+          owners.set(sample.id, bank.id);
+        }
       },
       patch(id, patch) {
         const sound = sounds.get(id);
         if (sound) sounds.set(id, mergeRecords(sound, patch));
         const loop = loops.get(id);
         if (loop) loops.set(id, mergeRecords(loop, patch));
+        const sample = samples.get(id);
+        if (sample) samples.set(id, mergeRecords(sample, patch));
       },
       remove(id) {
         sounds.delete(id);
         loops.delete(id);
         sets.delete(id);
+        samples.delete(id);
         owners.delete(id);
       },
       sound: (id) => sounds.get(id),
       loop: (id) => loops.get(id),
       set: (id) => sets.get(id),
+      sample: (id) => samples.get(id),
       soundIds: () => [...sounds.keys()],
       setIds: () => [...sets.keys()],
       loopIds: () => [...loops.keys()],
+      sampleIds: () => [...samples.keys()],
       bankOf: (id) => owners.get(id)
     };
     for (const bank of banks) registry.register(bank);
     return registry;
   }
 
-  // src/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"]
-          ]
-        }
+  // src/data/mix-profiles.json
+  var mix_profiles_default = [
+    {
+      id: "game",
+      master: 0.5,
+      noise: {
+        seconds: 1.5,
+        create: "lazy"
+      },
+      sources: [
+        "jogo:L62077-62081 master 0.5 to the output",
+        "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"
+      ]
+    },
+    {
+      id: "art_scene",
+      master: 0.85,
+      compressor: {
+        threshold: -12,
+        ratio: 5
+      },
+      reverb: {
+        seconds: 2.2,
+        decay: 3.4,
+        wet: 0.4
+      },
+      noise: {
+        seconds: 2,
+        create: "eager"
+      },
+      sources: [
+        "cena:L1308 compressor -12 dB, ratio 5",
+        "cena:L1309 master 0.85",
+        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
+        "cena:L1311 wet 0.4",
+        "cena:L1312 noise 2 s made with the chain"
+      ]
+    },
+    {
+      id: "kit",
+      master: 0.85,
+      compressor: {
+        threshold: -12,
+        ratio: 5
+      },
+      reverb: {
+        seconds: 2.2,
+        decay: 3.4,
+        wet: 0.4
+      },
+      noise: {
+        seconds: 2,
+        create: "eager"
+      },
+      sources: [
+        "sdk: the art scene chain (cena L1308-L1312) with a limiter after the compressor: the page has none, and a blast with its debris and a fire catching reached +7 dBFS"
       ],
-      falloff: DISTANCE_CURVES.game_sfx,
-      sources: [...GAME_SFX.sources.map((source) => `${source} ${row.team}`)]
-    };
+      limiter: {
+        ceiling: -1,
+        knee: -6
+      }
+    }
+  ];
+
+  // src/mix.ts
+  var MIX_PROFILES = Object.fromEntries(
+    mix_profiles_default.map((profile) => [profile.id, profile])
+  );
+  var DEFAULT_MIX = "kit";
+  function resolveMix(mix, profiles = MIX_PROFILES) {
+    if (typeof mix !== "string") return mix;
+    const profile = profiles[mix];
+    if (!profile) throw new Error(`game-audio: unknown mix profile "${mix}" (known: ${Object.keys(profiles).join(", ")})`);
+    return profile;
+  }
+  function busGain(setting) {
+    if (!setting) return 1;
+    return setting.muted ? 0 : setting.gain ?? 1;
   }
-  var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
 
-  // src/recipes/scene.ts
-  var ATTACK = 2e-3;
-  function lengthOf(d, attack) {
-    if (typeof d === "number") return attack + d;
-    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
-    return { ...d, add: (d.add ?? 0) + attack };
+  // 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;
   }
-  var envelope = (attack) => [
-    [0, 1e-4, "set", "fixed"],
-    [attack, 1, "exp"],
-    ["1d", 1e-4, "exp", "fixed"]
-  ];
-  function sceneNoise(o) {
-    const a = o.a ?? ATTACK;
-    const over = typeof o.d === "number" ? o.d : 0;
-    return {
-      filters: {
-        mode: "serial",
-        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
-      },
-      duration: lengthOf(o.d, a),
-      gain: o.vol,
-      ...o.delay === void 0 ? {} : { at: o.delay },
-      ...o.wet === void 0 ? {} : { wet: o.wet },
-      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
-      envelope: envelope(a)
-    };
+  function 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 sceneTone(o) {
-    return {
-      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
-      duration: lengthOf(o.d, ATTACK),
-      gain: o.vol,
-      ...o.delay === void 0 ? {} : { at: o.delay },
-      ...o.wet === void 0 ? {} : { wet: o.wet },
-      envelope: envelope(ATTACK)
-    };
+  function bufferOf(context, channels, requestedLength) {
+    const buffer = context.createBuffer(channels.length, requestedLength, context.sampleRate);
+    channels.forEach((samples, channel) => buffer.getChannelData(channel).set(samples));
+    return buffer;
   }
-  function sceneVoice(o) {
-    return {
-      duration: lengthOf(o.d, 0),
-      gain: o.vol,
-      wet: 0.45,
-      source: {
-        kind: "formant_voice",
-        wave: o.wave ?? "sawtooth",
-        frequency: { from: o.f0, to: o.f1, curve: "linear", over: "duration" },
-        vibrato: { rate: [4, 10], depth: 0.08 },
-        formants: [
-          { frequency: o.fA, q: 4 },
-          { frequency: o.fB, q: 6 }
-        ],
-        breath: { frequency: o.fB, q: 1.1, gain: o.noise },
-        mix: 3.2
-      },
-      envelope: [
-        [0, 1e-4, "set", "fixed"],
-        [0.1, 1, "exp"],
-        ["0.6d", 1, "set"],
-        ["1d", 1e-4, "exp", "fixed"]
-      ]
-    };
+
+  // src/webaudio/chain.ts
+  var LIMITER_POINTS = 4097;
+  function limiterCurve(ceilingDb, kneeDb, range, points = LIMITER_POINTS) {
+    const ceiling = 10 ** (ceilingDb / 20);
+    const knee = Math.min(10 ** (kneeDb / 20), ceiling);
+    const curve = new Float32Array(new ArrayBuffer(points * 4));
+    for (let i = 0; i < points; i++) {
+      const x = (i / (points - 1) * 2 - 1) * range;
+      const a = Math.abs(x);
+      const y = a <= knee || ceiling === knee ? Math.min(a, ceiling) : knee + (ceiling - knee) * Math.tanh((a - knee) / (ceiling - knee));
+      curve[i] = Math.sign(x) * y;
+    }
+    return curve;
   }
-  var sceneMany = (count, make) => Array.from({ length: count }, make);
-  function sceneRecipe(id, layers, line, options = {}) {
+  function buildChain(context, profile, random) {
+    let limiter;
+    if (profile.limiter) {
+      const range = profile.limiter.range ?? 4;
+      const input = context.createGain();
+      input.gain.value = 1 / range;
+      const shaper = context.createWaveShaper();
+      shaper.curve = limiterCurve(profile.limiter.ceiling, profile.limiter.knee, range);
+      input.connect(shaper);
+      shaper.connect(context.destination);
+      limiter = { input, shaper };
+    }
+    const output = limiter?.input ?? context.destination;
+    let compressor;
+    if (profile.compressor) {
+      compressor = context.createDynamicsCompressor();
+      compressor.threshold.value = profile.compressor.threshold;
+      compressor.ratio.value = profile.compressor.ratio;
+      if (profile.compressor.knee !== void 0) compressor.knee.value = profile.compressor.knee;
+      if (profile.compressor.attack !== void 0) compressor.attack.value = profile.compressor.attack;
+      if (profile.compressor.release !== void 0) compressor.release.value = profile.compressor.release;
+      compressor.connect(output);
+    }
+    const master = context.createGain();
+    master.gain.value = profile.master;
+    master.connect(compressor ?? output);
+    if (!profile.reverb) {
+      return {
+        master,
+        disconnect: () => {
+          master.disconnect();
+          compressor?.disconnect();
+          limiter?.input.disconnect();
+          limiter?.shaper.disconnect();
+        }
+      };
+    }
+    const convolver = context.createConvolver();
+    const length = context.sampleRate * profile.reverb.seconds;
+    convolver.buffer = bufferOf(context, fillImpulse(random, { channels: 2, length, decay: profile.reverb.decay }), length);
+    const wet = context.createGain();
+    wet.gain.value = profile.reverb.wet;
+    wet.connect(convolver);
+    convolver.connect(master);
     return {
-      id,
-      bus: options.bus ?? "world",
-      pan: true,
-      layers,
-      falloff: DISTANCE_CURVES.art_scene,
-      ...options.vars ? { vars: options.vars } : {},
-      ...options.group ? { group: options.group } : {},
-      sources: [`cena:${line}`]
+      master,
+      wet,
+      disconnect: () => {
+        wet.disconnect();
+        convolver.disconnect();
+        master.disconnect();
+        compressor?.disconnect();
+        limiter?.input.disconnect();
+        limiter?.shaper.disconnect();
+      }
     };
   }
 
-  // src/library/crowd_rumble.json
-  var crowd_rumble_default = {
-    id: "crowd_rumble",
-    bus: "ambience",
-    order: "game_loop",
-    source: { kind: "noise", loop: true },
-    filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 160 } }] },
-    smoothing: { volume: 0.15, frequency: 0.08 },
-    startAbove: 2e-3,
-    sources: ["jogo:L62116 horda: noise through a 160 Hz lowpass", "jogo:L70424 level min(0.16, near \xD7 0.0016)", "temporary home until the crowd package (Q12)"]
-  };
-
-  // src/library/engine_saw.json
-  var engine_saw_default = {
-    id: "engine_saw",
-    bus: "world",
-    order: "game_loop",
-    source: { kind: "osc", wave: "sawtooth", loop: true },
-    filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 400 } }] },
-    smoothing: { volume: 0.15, frequency: 0.08 },
-    startAbove: 2e-3,
-    sources: [
-      "jogo:L62115 motor: sawtooth through a 400 Hz lowpass",
-      "jogo:L70421 level 0.035 + speed \xD7 0.003, frequency 38 + speed \xD7 7 (the host drives `set`)",
-      "temporary home until the vehicles package (Q12)"
-    ]
-  };
-
-  // src/library/horn.json
-  var horn_default = {
-    id: "horn",
-    bus: "world",
-    order: "chord",
-    duration: 0.6,
-    tail: 0.02,
-    layers: [
-      { source: { kind: "osc", wave: "square", frequency: { set: 415 } }, envelope: [[0, 0.08, "set"], [0.6, 1e-4, "set", "fixed"]] },
-      { source: { kind: "osc", wave: "square", frequency: { set: 523 } }, envelope: [[0, 0.08, "set"], [0.6, 1e-4, "set", "fixed"]] }
-    ],
-    falloff: { model: "none" },
-    sources: ["jogo:L70272-70276 buzina: squares at 415 and 523 Hz, 0.08 for 0.6 s", "temporary home until the vehicles package (Q12)"]
-  };
+  // src/webaudio/context.ts
+  function globalContext() {
+    const scope = globalThis;
+    const Constructor = scope.AudioContext ?? scope.webkitAudioContext;
+    return Constructor ? new Constructor() : null;
+  }
+  function unlockContext(context) {
+    if (context.state === "suspended" && typeof context.close === "function") void context.resume();
+  }
 
-  // src/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"]]
+  // src/loops.ts
+  var LOOP_START_ABOVE = 2e-3;
+  var LOOP_SMOOTHING = { volume: 0.15, frequency: 0.08 };
+  function createLoopState(recipe2, open = false) {
+    const startAbove = recipe2.startAbove ?? LOOP_START_ABOVE;
+    let created = open;
+    let volume = recipe2.volume ?? 0;
+    return {
+      set(state) {
+        volume = state.volume ?? volume;
+        const create = !created;
+        if (create && !(volume >= startAbove)) return null;
+        created = true;
+        const frequency = recipe2.source.kind === "osc" && state.frequency ? state.frequency : void 0;
+        return { create, volume, ...frequency === void 0 ? {} : { frequency } };
+      },
+      get created() {
+        return created;
+      },
+      reset() {
+        created = false;
       }
-    ],
-    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"]]
+  // 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 {
+          }
+        }
       }
-    ],
-    falloff: { model: "none" },
-    sources: ["cena:L1369 siren: 850 Hz sine swept \xB1280 Hz at 0.18 Hz, 1400 Hz lowpass, 0.035 for 9 s, reverb send 1.5", "temporary home until the vehicles package (Q12)"]
-  };
-
-  // src/library/index.ts
-  var LIBRARY_SOUNDS = [horn_default, radio_static_default, siren_default];
-  var LIBRARY_LOOPS = [engine_saw_default, rotor_blades_default, crowd_rumble_default];
-  var LIBRARY_BANK = { id: "library", sounds: LIBRARY_SOUNDS, loops: LIBRARY_LOOPS };
+    };
+  }
 
-  // ../game-contracts/dist/index.js
-  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
-  var DEFERRED_QUEUE_ID = {
-    DESTRUCTION_EVENTS: "destruction.events",
-    BREACH_PAINT: "floorplan.breach-paint",
-    AUDIO_VOICES: "audio.voices",
-    VEHICLE_CREASE: "vehicles.crease"
-  };
-  var DEFERRED_PRIORITY = {
-    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
-    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
-    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
-    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
-  };
-  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
-  var GAIT_IDS = ["walk", "run"];
-  var LANDING_IDS = ["light", "heavy"];
-  var BODY_SOUND_IDS = [
-    "jump",
-    "cloth_rustle",
-    "body_fall",
-    "fall_damage",
-    "player_hurt",
-    "player_breath_run",
-    "player_death",
-    "bite",
-    "grab",
-    "punch_swing",
-    "punch_hit_body",
-    "punch_hit_face",
-    "punch_hit_object",
-    "kick_swing",
-    "kick_hit",
-    "kick_hit_object",
-    "shove_two_hands",
+  // src/webaudio/realize-loop.ts
+  function outputStage(recipe2, target, gain) {
+    if (!recipe2.pan) {
+      gain.connect(target.output);
+      return { out: gain };
+    }
+    const panner = target.context.createStereoPanner();
+    gain.connect(panner);
+    panner.connect(target.output);
+    return { out: panner, panner };
+  }
+  var fixed = (range) => typeof range === "number" ? range : 0;
+  var fixedFrequency = (automation) => fixed("set" in automation ? automation.set : automation.from);
+  function sourceOf(recipe2, target) {
+    if (recipe2.source.kind === "noise") return { source: noiseSource(target, true) };
+    const oscillator = target.context.createOscillator();
+    oscillator.type = recipe2.source.wave;
+    if (recipe2.source.frequency) oscillator.frequency.value = fixedFrequency(recipe2.source.frequency);
+    return { source: oscillator, frequency: oscillator.frequency };
+  }
+  function stopAll(sources) {
+    return () => {
+      for (const source of sources) {
+        try {
+          source.stop();
+        } catch {
+        }
+      }
+    };
+  }
+  function realizeGameLoop(recipe2, target) {
+    const { context } = target;
+    const gain = context.createGain();
+    const filters = (recipe2.filters?.bank ?? []).map(() => context.createBiquadFilter());
+    gain.gain.value = 0;
+    const last = filters.reduce((previous, filter) => previous ? previous.connect(filter) : filter, void 0);
+    last?.connect(gain);
+    const output = outputStage(recipe2, target, gain);
+    const { source, frequency } = sourceOf(recipe2, target);
+    recipe2.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 recipe2.modulators ?? []) {
+      const lfo = context.createOscillator();
+      const depth = context.createGain();
+      const stage = context.createGain();
+      if (modulator.wave) lfo.type = modulator.wave;
+      lfo.frequency.value = fixed(modulator.rate);
+      depth.gain.value = fixed(modulator.depth);
+      stage.gain.value = modulator.base ?? 0;
+      lfo.connect(depth);
+      depth.connect(stage.gain);
+      last?.disconnect();
+      last?.connect(stage);
+      stage.connect(gain);
+      lfo.start();
+      sources.push(lfo);
+    }
+    source.connect(filters[0] ?? gain);
+    source.start();
+    return { gain, ...output, source, ...frequency ? { frequency } : {}, ...filters[0] ? { cutoff: filters[0].frequency } : {}, stop: stopAll(sources) };
+  }
+  function realizeChainLoop(recipe2, target, volume) {
+    const { context } = target;
+    const { source, frequency } = sourceOf(recipe2, target);
+    const filters = (recipe2.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 = (recipe2.modulators ?? []).map((modulator) => {
+      const lfo = context.createOscillator();
+      if (modulator.wave) lfo.type = modulator.wave;
+      lfo.frequency.value = fixed(modulator.rate);
+      const depth = gainNode(context, fixed(modulator.depth));
+      lfo.connect(depth);
+      depth.connect(gain.gain);
+      return lfo;
+    });
+    let tail = source;
+    for (const filter of filters) tail = tail.connect(filter);
+    tail.connect(gain);
+    const output = outputStage(recipe2, target, gain);
+    source.start();
+    for (const lfo of lfos) lfo.start();
+    return { gain, ...output, source, ...frequency ? { frequency } : {}, ...filters[0] ? { cutoff: filters[0].frequency } : {}, stop: stopAll([source, ...lfos]) };
+  }
+
+  // src/webaudio/engine-loop.ts
+  var INERT = { set() {
+  }, stop() {
+  } };
+  function createLoopHandle(recipe2, host, volume) {
+    if (!recipe2) return INERT;
+    const loopRecipe = recipe2;
+    const isChain = loopRecipe.order === "chain_loop";
+    const opening = volume ?? loopRecipe.volume ?? 0;
+    const smoothing = loopRecipe.smoothing ?? LOOP_SMOOTHING;
+    let state = createLoopState(loopRecipe);
+    let nodes;
+    const entry = {
+      get created() {
+        return nodes !== void 0;
+      },
+      rewire() {
+        nodes?.out.disconnect();
+        nodes?.out.connect(host.output(loopRecipe.bus));
+      },
+      stop() {
+        nodes?.stop();
+        nodes?.out.disconnect();
+        nodes = void 0;
+        state = createLoopState(loopRecipe);
+        host.unregister(entry);
+      }
+    };
+    const create = (context, startVolume) => {
+      if (loopRecipe.source.kind === "noise") host.prepareNoise();
+      const target = { context, output: host.output(loopRecipe.bus), noise: host.noise, time: context.currentTime };
+      const made = isChain ? realizeChainLoop(loopRecipe, target, startVolume) : realizeGameLoop(loopRecipe, target);
+      host.register(entry);
+      return made;
+    };
+    const open = () => {
+      const context = host.ready();
+      if (!context) return;
+      nodes = create(context, opening);
+      state = createLoopState({ ...loopRecipe, volume: opening }, true);
+    };
+    if (isChain) open();
+    let position;
+    let cutoff;
+    const placed = loopRecipe.falloff !== void 0 || loopRecipe.pan === true;
+    return {
+      set(next) {
+        if (isChain && !nodes) open();
+        const context = host.ready();
+        if (!context) return;
+        position = next.position ?? position;
+        cutoff = next.cutoff ?? cutoff;
+        const action = state.set(next);
+        if (!action) return;
+        nodes ?? (nodes = create(context, 0));
+        const listener = placed && position ? host.listener?.() : void 0;
+        const distance = listener && position ? listenerDistance(listener, position, host.distance) : 0;
+        const level = listener ? falloffGain(loopRecipe.falloff, action.volume, distance) : action.volume;
+        nodes.gain.gain.setTargetAtTime(level, context.currentTime, smoothing.volume);
+        if (action.frequency !== void 0 && nodes.frequency) nodes.frequency.setTargetAtTime(action.frequency, context.currentTime, smoothing.frequency);
+        if (cutoff !== void 0 && nodes.cutoff) nodes.cutoff.setTargetAtTime(cutoff / cutoffDivisor(loopRecipe.falloff, distance), context.currentTime, smoothing.frequency);
+        if (listener && position && nodes.panner) nodes.panner.pan.setTargetAtTime(panFor(listener, position), context.currentTime, smoothing.frequency);
+      },
+      stop: entry.stop
+    };
+  }
+
+  // src/webaudio/sample-loop.ts
+  var DEFAULT_LOOP_CROSSFADE = 0.25;
+  var LOOKAHEAD = 1.5;
+  var VOLUME_SMOOTHING = 0.05;
+  function loopCrossfade(sound) {
+    if (!sound.loop) return void 0;
+    return sound.loop === true ? DEFAULT_LOOP_CROSSFADE : Math.max(0, sound.loop.crossfade ?? DEFAULT_LOOP_CROSSFADE);
+  }
+  var CROSSFADE_STEPS = 8;
+  var equalPowerIn = (t) => Math.sin(Math.max(0, Math.min(1, t)) * Math.PI / 2);
+  var ramp2 = (param, direction, at, seconds) => {
+    const value = (t) => direction === "in" ? equalPowerIn(t) : equalPowerIn(1 - t);
+    param.setValueAtTime(value(0), at);
+    for (let step = 1; step <= CROSSFADE_STEPS; step++) param.linearRampToValueAtTime(value(step / CROSSFADE_STEPS), at + seconds * step / CROSSFADE_STEPS);
+  };
+  function createSampleLoopHandle(sound, host, volume = 0) {
+    const crossfade = loopCrossfade(sound) ?? DEFAULT_LOOP_CROSSFADE;
+    let level = volume;
+    let stopped = false;
+    let fallback;
+    let master;
+    let segments = [];
+    let last;
+    let timer;
+    const entry = {
+      get created() {
+        return master !== void 0;
+      },
+      rewire() {
+        master?.disconnect();
+        master?.connect(host.output(sound.bus));
+      },
+      stop() {
+        stopped = true;
+        if (timer !== void 0) clearTimeout(timer);
+        timer = void 0;
+        for (const segment of segments) {
+          try {
+            segment.source.stop();
+          } catch {
+          }
+          segment.source.disconnect();
+          segment.gain.disconnect();
+        }
+        segments = [];
+        master?.disconnect();
+        master = void 0;
+        fallback?.stop();
+        fallback = void 0;
+        host.unregister(entry);
+      }
+    };
+    const nextBuffer = () => {
+      const takes2 = sound.close;
+      const take = pickTake(takes2.length, last, host.random);
+      last = take;
+      const ref = takes2[take];
+      return ref ? host.buffer(ref.url) : void 0;
+    };
+    const schedule = (context, output, at, first) => {
+      const buffer = nextBuffer();
+      if (!buffer) return void 0;
+      const source = context.createBufferSource();
+      source.buffer = buffer;
+      const gain = context.createGain();
+      source.connect(gain);
+      gain.connect(output);
+      const fade = Math.min(crossfade, buffer.duration / 2);
+      if (buffer.duration < 2 * crossfade || sound.close.length === 1) {
+        source.loop = true;
+        if (!first) ramp2(gain.gain, "in", at, Math.max(1e-3, fade));
+        source.start(at);
+        segments.push({ source, gain, end: Number.POSITIVE_INFINITY });
+        return void 0;
+      }
+      if (first) gain.gain.setValueAtTime(1, at);
+      else ramp2(gain.gain, "in", at, fade);
+      const end3 = at + buffer.duration;
+      ramp2(gain.gain, "out", end3 - fade, fade);
+      source.start(at);
+      source.stop(end3);
+      segments.push({ source, gain, end: end3 });
+      source.onended = () => {
+        segments = segments.filter((segment) => segment.source !== source);
+        source.disconnect();
+        gain.disconnect();
+      };
+      return end3 - fade;
+    };
+    const pump = (context, output, at, first) => {
+      if (stopped) return;
+      let next = schedule(context, output, at, first);
+      while (next !== void 0 && next < context.currentTime + LOOKAHEAD) next = schedule(context, output, Math.max(next, context.currentTime), false);
+      if (next === void 0) return;
+      const wait = Math.max(0, (next - context.currentTime - LOOKAHEAD / 2) * 1e3);
+      timer = setTimeout(() => {
+        timer = void 0;
+        pump(context, output, next, false);
+      }, wait);
+    };
+    const fileLevel = () => level * (sound.gain ?? 1);
+    const startFiles = () => {
+      if (stopped || master || !host.isReady(sound)) return master !== void 0;
+      const context = host.ready();
+      if (!context) return false;
+      master = context.createGain();
+      master.gain.setValueAtTime(fileLevel(), context.currentTime);
+      master.connect(host.output(sound.bus));
+      host.register(entry);
+      pump(context, master, context.currentTime, true);
+      if (fallback) {
+        fallback.set({ volume: 0 });
+        const old = fallback;
+        fallback = void 0;
+        setTimeout(() => old.stop(), VOLUME_SMOOTHING * 6e3);
+      }
+      return true;
+    };
+    const ensure = () => {
+      if (stopped || master) return;
+      if (startFiles()) return;
+      if (!fallback) {
+        fallback = host.fallback(level);
+        void host.load(sound).then(() => {
+          if (level > 0 || master) startFiles();
+        }).catch(() => void 0);
+      }
+    };
+    if (volume > 0) ensure();
+    return {
+      set(next) {
+        if (stopped) return;
+        if (next.volume !== void 0) level = host.muted(sound.bus) ? 0 : Math.max(0, next.volume);
+        if (level > 0) ensure();
+        const context = host.ready();
+        if (master && context) master.gain.setTargetAtTime(fileLevel(), context.currentTime, VOLUME_SMOOTHING);
+        fallback?.set(next.volume === void 0 ? next : { ...next, volume: level });
+      },
+      stop: entry.stop
+    };
+  }
+
+  // src/webaudio/engine-noise.ts
+  function createNoiseStore(random) {
+    const store = {
+      random,
+      reset() {
+        store.samples = void 0;
+        store.buffer = void 0;
+      }
+    };
+    return store;
+  }
+  function prepareNoise(store, context, seconds) {
+    store.samples ?? (store.samples = fillNoise(store.random, Math.floor(context.sampleRate * seconds)));
+    return store.samples;
+  }
+  function noiseBuffer(store, context, seconds) {
+    const samples = prepareNoise(store, context, seconds);
+    store.buffer ?? (store.buffer = bufferOf(context, [samples], context.sampleRate * seconds));
+    return store.buffer;
+  }
+
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
     "knife_swing",
     "knife_stab",
     "knife_slash",
@@ -848,525 +1426,6 @@ var GameAudio = (() => {
   var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
   var SWING_LEAD_SECONDS = { punch: 0.07, kick: 0.09, shove: 0, blade: 0.05, blunt: 0.1, chop: 0.11 };
 
-  // src/recipes/body-foley.ts
-  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 } }
-  };
-  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 }
-  };
-  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 })
-    ],
-    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 }] }
-    ],
-    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 })
-    ],
-    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]] })
-  };
-  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)
-  };
-  var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
-
-  // src/variation.ts
-  var tuneAutomation = (automation, rate) => {
-    const tuned = { ...automation };
-    if (automation.value !== void 0) tuned.value = automation.value * rate;
-    if (automation.from !== void 0) tuned.from = automation.from * rate;
-    if (automation.to !== void 0) tuned.to = automation.to * rate;
-    if (automation.at !== void 0) tuned.at = automation.at / rate;
-    return tuned;
-  };
-  var tuneFilter = (filter, rate) => ({ ...filter, frequency: tuneAutomation(filter.frequency, rate) });
-  var tuneSource = (source, rate) => {
-    switch (source.kind) {
-      case "noise":
-        return source;
-      case "osc":
-        return { ...source, frequency: tuneAutomation(source.frequency, rate) };
-      case "formant_voice":
-        return {
-          ...source,
-          frequency: tuneAutomation(source.frequency, rate),
-          formants: source.formants.map((formant) => ({ ...formant, frequency: formant.frequency * rate })),
-          breath: { ...source.breath, frequency: source.breath.frequency * rate }
-        };
-    }
-  };
-  var tuneModulator = (modulator, rate) => ({
-    ...modulator,
-    rate: modulator.rate * rate,
-    ...modulator.target === "frequency" ? { depth: modulator.depth * rate } : {}
-  });
-  var tuneLayer = (layer, rate) => ({
-    ...layer,
-    at: layer.at / rate,
-    duration: layer.duration / rate,
-    tail: layer.tail / rate,
-    source: tuneSource(layer.source, rate),
-    ...layer.filters ? { filters: { ...layer.filters, bank: layer.filters.bank.map((filter) => tuneFilter(filter, rate)) } } : {},
-    modulators: layer.modulators.map((modulator) => tuneModulator(modulator, rate)),
-    envelope: layer.envelope.map((point) => ({ ...point, time: point.time / rate }))
-  });
-  function retunePlan(plan, rate) {
-    if (rate === 1 || !(rate > 0)) return plan;
-    return { ...plan, length: plan.length / rate, layers: plan.layers.map((layer) => tuneLayer(layer, rate)) };
-  }
-  function createSetPicker() {
-    const last = /* @__PURE__ */ new Map();
-    return {
-      pick(set, random) {
-        const count = set.variants.length;
-        const previous = last.get(set.id);
-        let index;
-        if (count === 1) index = 0;
-        else if (set.repeat || previous === void 0) index = Math.min(count - 1, Math.floor(random() * count));
-        else {
-          index = Math.min(count - 2, Math.floor(random() * (count - 1)));
-          if (index >= previous) index += 1;
-        }
-        last.set(set.id, index);
-        const [min, max] = set.rate ?? [1, 1];
-        const rate = min === max ? min : min + random() * (max - min);
-        return { id: set.variants[index], rate };
-      },
-      reset: () => last.clear()
-    };
-  }
-
-  // src/webaudio/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(recipe2, target) {
-    if (recipe2.source.kind === "noise") return { source: noiseSource(target, true) };
-    const oscillator = target.context.createOscillator();
-    oscillator.type = recipe2.source.wave;
-    if (recipe2.source.frequency) oscillator.frequency.value = fixedFrequency(recipe2.source.frequency);
-    return { source: oscillator, frequency: oscillator.frequency };
-  }
-  function stopAll(sources) {
-    return () => {
-      for (const source of sources) {
-        try {
-          source.stop();
-        } catch {
-        }
-      }
-    };
-  }
-  function realizeGameLoop(recipe2, target) {
-    const { context } = target;
-    const gain = context.createGain();
-    const filters = (recipe2.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(recipe2, target);
-    recipe2.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 recipe2.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(recipe2, target, volume) {
-    const { context } = target;
-    const { source, frequency } = sourceOf(recipe2, target);
-    const filters = (recipe2.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 = (recipe2.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(recipe2, host, volume) {
-    if (!recipe2) return INERT;
-    const loopRecipe = recipe2;
-    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) {
@@ -1627,7 +1686,7 @@ var GameAudio = (() => {
 
   // src/webaudio/realize-layered.ts
   var end2 = (layer, start) => start + layer.duration + layer.tail;
-  function outputStage(plan, layer, target) {
+  function outputStage2(plan, layer, target) {
     const { context } = target;
     const level = gainNode(context, layer.level);
     let node = level;
@@ -1659,7 +1718,7 @@ var GameAudio = (() => {
     let tail = source;
     for (const filter of filters) tail = tail.connect(filter);
     tail.connect(envelope2);
-    envelope2.connect(outputStage(plan, layer, target));
+    envelope2.connect(outputStage2(plan, layer, target));
     source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
     source.stop(end2(layer, time));
     return [source];
@@ -1676,7 +1735,7 @@ var GameAudio = (() => {
     const envelope2 = context.createGain();
     applyEnvelope(envelope2.gain, layer.envelope, time);
     oscillator.connect(envelope2);
-    envelope2.connect(outputStage(plan, layer, target));
+    envelope2.connect(outputStage2(plan, layer, target));
     oscillator.start(time);
     oscillator.stop(end2(layer, time));
     return [oscillator];
@@ -1708,7 +1767,7 @@ var GameAudio = (() => {
     const envelope2 = context.createGain();
     applyEnvelope(envelope2.gain, layer.envelope, time);
     mix.connect(envelope2);
-    envelope2.connect(outputStage(plan, layer, target));
+    envelope2.connect(outputStage2(plan, layer, target));
     const stop = end2(layer, time);
     oscillator.start(time);
     vibrato.start(time);
@@ -1821,7 +1880,217 @@ var GameAudio = (() => {
     return BUILDERS[plan.order](plan, target);
   }
 
+  // src/variation.ts
+  var tuneAutomation = (automation, rate) => {
+    const tuned = { ...automation };
+    if (automation.value !== void 0) tuned.value = automation.value * rate;
+    if (automation.from !== void 0) tuned.from = automation.from * rate;
+    if (automation.to !== void 0) tuned.to = automation.to * rate;
+    if (automation.at !== void 0) tuned.at = automation.at / rate;
+    return tuned;
+  };
+  var tuneFilter = (filter, rate) => ({ ...filter, frequency: tuneAutomation(filter.frequency, rate) });
+  var tuneSource = (source, rate) => {
+    switch (source.kind) {
+      case "noise":
+        return source;
+      case "osc":
+        return { ...source, frequency: tuneAutomation(source.frequency, rate) };
+      case "formant_voice":
+        return {
+          ...source,
+          frequency: tuneAutomation(source.frequency, rate),
+          formants: source.formants.map((formant) => ({ ...formant, frequency: formant.frequency * rate })),
+          breath: { ...source.breath, frequency: source.breath.frequency * rate }
+        };
+    }
+  };
+  var tuneModulator = (modulator, rate) => ({
+    ...modulator,
+    rate: modulator.rate * rate,
+    ...modulator.target === "frequency" ? { depth: modulator.depth * rate } : {}
+  });
+  var tuneLayer = (layer, rate) => ({
+    ...layer,
+    at: layer.at / rate,
+    duration: layer.duration / rate,
+    tail: layer.tail / rate,
+    source: tuneSource(layer.source, rate),
+    ...layer.filters ? { filters: { ...layer.filters, bank: layer.filters.bank.map((filter) => tuneFilter(filter, rate)) } } : {},
+    modulators: layer.modulators.map((modulator) => tuneModulator(modulator, rate)),
+    envelope: layer.envelope.map((point) => ({ ...point, time: point.time / rate }))
+  });
+  function retunePlan(plan, rate) {
+    if (rate === 1 || !(rate > 0)) return plan;
+    return { ...plan, length: plan.length / rate, layers: plan.layers.map((layer) => tuneLayer(layer, rate)) };
+  }
+  function createSetPicker() {
+    const last = /* @__PURE__ */ new Map();
+    return {
+      pick(set, random) {
+        const count = set.variants.length;
+        const previous = last.get(set.id);
+        let index;
+        if (count === 1) index = 0;
+        else if (set.repeat || previous === void 0) index = Math.min(count - 1, Math.floor(random() * count));
+        else {
+          index = Math.min(count - 2, Math.floor(random() * (count - 1)));
+          if (index >= previous) index += 1;
+        }
+        last.set(set.id, index);
+        const [min, max] = set.rate ?? [1, 1];
+        const rate = min === max ? min : min + random() * (max - min);
+        return { id: set.variants[index], rate };
+      },
+      reset: () => last.clear()
+    };
+  }
+
+  // src/webaudio/sample-store.ts
+  function fetchLoader(baseUrl) {
+    return async (url2) => {
+      const target = baseUrl ? new URL(url2, baseUrl).toString() : url2;
+      const response = await fetch(target);
+      if (!response.ok) throw new Error(`${response.status} ${response.statusText} for ${target}`);
+      return response.arrayBuffer();
+    };
+  }
+  function inlineLoader(files) {
+    return async (url2) => {
+      const text = files[url2];
+      if (text === void 0) throw new Error(`no inline file for ${url2}`);
+      const base64 = text.startsWith("data:") ? text.slice(text.indexOf(",") + 1) : text;
+      const binary = atob(base64);
+      const bytes = new Uint8Array(binary.length);
+      for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+      return bytes.buffer;
+    };
+  }
+  var decode = (context, bytes) => new Promise((resolve, reject) => {
+    const result = context.decodeAudioData(bytes, resolve, reject);
+    result?.catch?.(reject);
+  });
+  function createSampleStore(loader = fetchLoader()) {
+    const buffers = /* @__PURE__ */ new Map();
+    const pending = /* @__PURE__ */ new Map();
+    const failed = /* @__PURE__ */ new Map();
+    let generation = 0;
+    const loadOne = (url2, context) => {
+      const existing = buffers.get(url2);
+      if (existing) return Promise.resolve(existing);
+      const inFlight = pending.get(url2);
+      if (inFlight) return inFlight;
+      const started = generation;
+      failed.delete(url2);
+      const promise = loader(url2).then((bytes) => decode(context, bytes)).then((buffer) => {
+        if (started === generation) buffers.set(url2, buffer);
+        return buffer;
+      }).catch((error) => {
+        if (started === generation) failed.set(url2, error instanceof Error ? error.message : String(error));
+        throw error;
+      }).finally(() => {
+        if (pending.get(url2) === promise) pending.delete(url2);
+      });
+      pending.set(url2, promise);
+      return promise;
+    };
+    return {
+      status(url2) {
+        if (buffers.has(url2)) return "ready";
+        if (pending.has(url2)) return "loading";
+        if (failed.has(url2)) return "failed";
+        return "none";
+      },
+      buffer: (url2) => buffers.get(url2),
+      ready: (urls) => urls.every((url2) => buffers.has(url2)),
+      seconds: (url2) => buffers.get(url2)?.duration,
+      async load(urls, context) {
+        const results = await Promise.allSettled(urls.map((url2) => loadOne(url2, context)));
+        const loaded = [];
+        const errors = [];
+        results.forEach((result, index) => {
+          const url2 = urls[index];
+          if (result.status === "fulfilled") loaded.push(url2);
+          else errors.push({ url: url2, error: result.reason instanceof Error ? result.reason.message : String(result.reason) });
+        });
+        return { loaded, failed: errors };
+      },
+      clear() {
+        generation++;
+        buffers.clear();
+        pending.clear();
+        failed.clear();
+      }
+    };
+  }
+
+  // src/webaudio/realize-sample.ts
+  function realizeSample(plan, target) {
+    const context = target.context;
+    let head = target.output;
+    if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
+      const panner = context.createStereoPanner();
+      panner.pan.value = plan.pan;
+      panner.connect(head);
+      head = panner;
+    }
+    if (plan.cutoff < OPEN_CUTOFF) {
+      const lowpass = context.createBiquadFilter();
+      lowpass.type = "lowpass";
+      lowpass.frequency.value = plan.cutoff;
+      lowpass.Q.value = 0.7;
+      lowpass.connect(head);
+      head = lowpass;
+    }
+    const voice2 = context.createGain();
+    voice2.connect(head);
+    head = voice2;
+    const sources = [];
+    for (const layer of plan.layers) {
+      const buffer = target.buffer(layer.url);
+      if (!buffer) continue;
+      const source = context.createBufferSource();
+      source.buffer = buffer;
+      source.playbackRate.value = layer.rate;
+      const gain = gainNode(context, layer.gain);
+      source.connect(gain);
+      gain.connect(head);
+      source.start(target.time + layer.at);
+      sources.push(source);
+    }
+    const realized = voiceOf(sources);
+    return {
+      ...realized,
+      fade(at, seconds) {
+        voice2.gain.setValueAtTime(1, at);
+        voice2.gain.linearRampToValueAtTime(0, at + seconds);
+        for (const source of sources) {
+          try {
+            source.stop(at + seconds);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+  function sampleLength(plan, seconds) {
+    let length = 0;
+    for (const layer of plan.layers) length = Math.max(length, layer.at + (seconds(layer.url) ?? 0) / layer.rate);
+    return length;
+  }
+
   // src/webaudio/engine.ts
+  function limiterCurve2(knee, ceiling, range, points = 2049) {
+    const curve = new Float32Array(points);
+    const room = Math.max(1e-6, ceiling - knee);
+    for (let index = 0; index < points; index++) {
+      const value = (index / (points - 1) * 2 - 1) * range;
+      const size = Math.abs(value);
+      const bent = size <= knee ? size : knee + room * Math.tanh((size - knee) / room);
+      curve[index] = Math.sign(value) * bent;
+    }
+    return curve;
+  }
   var usesNoise = (recipe2) => recipe2.layers.some((layer) => layer.source.kind !== "osc");
   var planUsesNoise = (plan) => plan.layers.some((layer) => layer.source.kind !== "osc");
   function createAudioEngine(options = {}) {
@@ -1841,6 +2110,43 @@ var GameAudio = (() => {
     let chain = null;
     let listener = DEFAULT_LISTENER;
     let lastTime = 0;
+    let environment = options.environment ?? "outdoor";
+    const sampleLimiters = /* @__PURE__ */ new Map();
+    const sampleOutput = (bus) => {
+      const setting = options.samples?.limiter;
+      if (setting === false || !context) return outputFor(bus);
+      const existing = sampleLimiters.get(bus);
+      if (existing) return existing;
+      const range = 4;
+      const input = context.createGain();
+      input.gain.value = 1 / range;
+      const shaper = context.createWaveShaper();
+      shaper.curve = limiterCurve2(setting?.knee ?? 0.5, setting?.ceiling ?? 0.891, range);
+      ensureBus(bus);
+      input.connect(shaper);
+      shaper.connect(outputFor(bus));
+      sampleLimiters.set(bus, input);
+      return input;
+    };
+    const chokes = /* @__PURE__ */ new Map();
+    const choked = (id) => {
+      const list = (chokes.get(id) ?? []).filter((entry) => active.has(entry.id));
+      chokes.set(id, list);
+      return list;
+    };
+    const watchers = /* @__PURE__ */ new Set();
+    const announce = (event) => {
+      options.onVoiceStart?.(event);
+      for (const watcher of watchers) watcher(event);
+    };
+    const sources = [];
+    const baseLoader = options.samples?.loader ?? fetchLoader(options.samples?.baseUrl);
+    const sampleStore = createSampleStore((url2) => (sources.find((source) => source.accepts(url2))?.loader ?? baseLoader)(url2));
+    const memory = /* @__PURE__ */ new Map();
+    const latencyOf = (audio) => {
+      const live = audio;
+      return (live.baseLatency ?? 0) + (live.outputLatency ?? 0);
+    };
     const outputFor = (bus) => busNodes.get(bus) ?? chain?.master;
     const watched = /* @__PURE__ */ new Set();
     const meterOf = (bus) => {
@@ -1897,17 +2203,31 @@ var GameAudio = (() => {
       ...options.occlusion && playOptions.position && recipe2.falloff?.model !== "none" ? { occlusion: options.occlusion(playOptions.position) } : {}
     });
     const startQueue = options.deferredStart ? createStartQueue(options.deferredStart) : null;
-    const build = (plan, store, delay) => {
+    const build = (plan, store, delay, requestedAt, fallbackOf) => {
       const audio = context;
-      return realize(plan, {
+      const time = audio.currentTime + delay;
+      const realized = realize(plan, {
         context: audio,
         output: outputFor(plan.bus),
         ...chain?.wet ? { wet: chain.wet } : {},
         noise: () => noiseBuffer(store, audio, mix.noise.seconds),
-        time: audio.currentTime + delay
+        time
+      });
+      announce({
+        id: plan.id,
+        kind: "recipe",
+        ...fallbackOf ? { fallbackOf } : {},
+        requestedAt,
+        startAt: time,
+        outputLatency: latencyOf(audio),
+        level: plan.level,
+        distance: plan.distance,
+        ...plan.pan === void 0 ? {} : { pan: plan.pan }
       });
+      return realized;
     };
-    const deferVoice = (plan, store, voiceId, delay) => {
+    const deferVoice = (plan, store, voiceId, delay, fallbackOf) => {
+      const requestedAt = context?.currentTime ?? 0;
       let built2 = null;
       let cancelled = false;
       const pending = {
@@ -1921,7 +2241,7 @@ var GameAudio = (() => {
       };
       startQueue.push({
         run() {
-          if (!cancelled && context) built2 = build(plan, store, delay);
+          if (!cancelled && context) built2 = build(plan, store, delay, requestedAt, fallbackOf);
         },
         drop() {
           if (voiceId === void 0) return;
@@ -1931,13 +2251,14 @@ var GameAudio = (() => {
       });
       return pending;
     };
-    const start = (plan, store, voiceId, delay = 0) => {
-      const realized = startQueue ? deferVoice(plan, store, voiceId, delay) : build(plan, store, delay);
+    const start = (plan, store, voiceId, delay = 0, fallbackOf, urgent = false) => {
+      const realized = startQueue && !urgent ? deferVoice(plan, store, voiceId, delay, fallbackOf) : build(plan, store, delay, context?.currentTime ?? 0, fallbackOf);
       if (voiceId === void 0) return null;
       voices.setLength(voiceId, plan.length + delay);
       active.set(voiceId, realized);
       return {
         id: voiceId,
+        kind: "recipe",
         plan,
         stop() {
           realized.stop();
@@ -1961,7 +2282,83 @@ var GameAudio = (() => {
       const set = registry.set(id);
       return set ? chooser.pick(set, random) : { id, rate: 1 };
     };
-    const playWith = (asked, playOptions, streamRandom, store) => {
+    const loadSounds = (sounds) => {
+      const audio = ready();
+      if (!audio) return Promise.resolve({ loaded: [], failed: sounds.flatMap(sampleUrls).map((url2) => ({ url: url2, error: "no audio context" })) });
+      return sampleStore.load([...new Set(sounds.flatMap(sampleUrls))], audio);
+    };
+    const sampleInput = (playOptions, random, withMemory) => ({
+      random,
+      listener,
+      environment: playOptions.environment ?? environment,
+      ...withMemory ? { memory } : {},
+      ...options.distance ? { distanceMode: options.distance } : {},
+      ...playOptions.volume === void 0 ? {} : { volume: playOptions.volume },
+      ...playOptions.intensity === void 0 ? {} : { intensity: playOptions.intensity },
+      ...playOptions.distance === void 0 ? {} : { distance: playOptions.distance },
+      ...playOptions.position ? { position: playOptions.position } : {},
+      ...playOptions.occlusion !== void 0 ? { occlusion: playOptions.occlusion } : options.occlusion && playOptions.position ? { occlusion: options.occlusion(playOptions.position) } : {}
+    });
+    const playSample = (sample, playOptions, random, store) => {
+      if (busSettings.get(sample.bus)?.muted) return null;
+      if (!sampleStore.ready(sampleUrls(sample))) {
+        if (options.samples?.autoLoad !== false && ready()) void loadSounds([sample]).catch(() => void 0);
+        if (sample.fallback && sample.fallback !== sample.id) return playWith(sample.fallback, playOptions, random, store, sample.id);
+        return registry.sound(sample.id) ? void 0 : null;
+      }
+      const plan = planSample(sample, sampleInput(playOptions, playOptions.seed === void 0 ? random : createRng(playOptions.seed), true));
+      if (!plan) return null;
+      const audio = ready();
+      if (!audio) return null;
+      unlockContext(audio);
+      advance();
+      const voiceId = admit(plan, plan.level, plan.distance);
+      if (voiceId === null) return null;
+      const requestedAt = audio.currentTime;
+      const time = requestedAt + (playOptions.delay ?? 0);
+      const chokeList = sample.choke ? choked(sample.id) : void 0;
+      const realized = realizeSample(plan, { context: audio, output: sampleOutput(plan.bus), buffer: (url2) => sampleStore.buffer(url2), time });
+      announce({
+        id: plan.id,
+        kind: "sample",
+        requestedAt,
+        startAt: time,
+        outputLatency: latencyOf(audio),
+        level: plan.level,
+        distance: plan.distance,
+        ...plan.pan === void 0 ? {} : { pan: plan.pan },
+        layers: plan.layers.map((layer) => ({ role: layer.role, url: layer.url, take: layer.take, rate: layer.rate })),
+        ...plan.tier ? { tier: plan.tier } : {}
+      });
+      voices.setLength(voiceId, sampleLength(plan, (url2) => sampleStore.seconds(url2)) + (playOptions.delay ?? 0));
+      active.set(voiceId, realized);
+      if (chokeList && sample.choke) {
+        chokeList.push({ id: voiceId, voice: realized });
+        while (chokeList.length > Math.max(1, sample.choke.voices)) {
+          const oldest = chokeList.shift();
+          if (!oldest) break;
+          oldest.voice.fade(time, sample.choke.fade ?? 0.03);
+          voices.release(oldest.id);
+          active.delete(oldest.id);
+        }
+      }
+      return {
+        id: voiceId,
+        kind: "sample",
+        plan,
+        stop() {
+          realized.stop();
+          voices.release(voiceId);
+          active.delete(voiceId);
+        }
+      };
+    };
+    const playWith = (asked, playOptions, streamRandom, store, fallbackOf) => {
+      const sample = fallbackOf === void 0 ? registry.sample(asked) : void 0;
+      if (sample) {
+        const played = playSample(sample, playOptions, streamRandom, store);
+        if (played !== void 0) return played;
+      }
       const seeded = playOptions.seed === void 0 ? null : createRng(playOptions.seed);
       const { id, rate } = resolve(asked, seeded ?? streamRandom);
       const random = seeded ?? streamRandom;
@@ -1979,7 +2376,7 @@ var GameAudio = (() => {
       if (voiceId === null) return null;
       if (!silent && usesNoise(recipe2)) prepareNoise(store, audio, mix.noise.seconds);
       const plan = planSound(recipe2, inputFor(recipe2, playOptions, random));
-      return plan ? start(retunePlan(plan, rate), store, voiceId, playOptions.delay) : null;
+      return plan ? start(retunePlan(plan, rate), store, voiceId, playOptions.delay, fallbackOf, playOptions.urgent) : null;
     };
     const randomFor = (playOptions) => {
       if (playOptions.channel === void 0) return engineRandom;
@@ -1989,119 +2386,1857 @@ var GameAudio = (() => {
       named.set(playOptions.channel, stream);
       return stream;
     };
-    const planWith = (asked, playOptions, random) => {
-      const { id, rate } = resolve(asked, random, createSetPicker());
-      const recipe2 = registry.sound(id);
-      const plan = recipe2 ? planSound(recipe2, inputFor(recipe2, playOptions, random)) : null;
-      return plan ? retunePlan(plan, rate) : null;
+    const planWith = (asked, playOptions, random) => {
+      const { id, rate } = resolve(asked, random, createSetPicker());
+      const recipe2 = registry.sound(id);
+      const plan = recipe2 ? planSound(recipe2, inputFor(recipe2, playOptions, random)) : null;
+      return plan ? retunePlan(plan, rate) : null;
+    };
+    const loopHost = {
+      ready,
+      output: outputFor,
+      prepareNoise: () => context && prepareNoise(shared, context, mix.noise.seconds),
+      noise: () => noiseBuffer(shared, context, mix.noise.seconds),
+      register: (loop) => void loops.add(loop),
+      unregister: (loop) => void loops.delete(loop),
+      listener: () => listener,
+      ...options.distance ? { distance: options.distance } : {}
+    };
+    return {
+      registry,
+      register: (bank) => registry.register(bank),
+      plan: (id, playOptions = {}) => planWith(id, playOptions, createRng(playOptions.seed ?? seed)),
+      planSample(id, playOptions = {}) {
+        const sample = registry.sample(id);
+        return sample ? planSample(sample, sampleInput(playOptions, createRng(playOptions.seed ?? seed), false)) : null;
+      },
+      loadSamples(ids) {
+        const chosen = (ids ?? registry.sampleIds()).map((id) => registry.sample(id)).filter((sample) => sample !== void 0);
+        return loadSounds(chosen);
+      },
+      sampleStatus(id) {
+        const sample = registry.sample(id);
+        if (!sample) return "none";
+        const statuses = sampleUrls(sample).map((url2) => sampleStore.status(url2));
+        if (statuses.every((status) => status === "ready")) return "ready";
+        if (statuses.includes("failed")) return "failed";
+        if (statuses.includes("loading")) return "loading";
+        return statuses.includes("ready") ? "loading" : "none";
+      },
+      setEnvironment(next) {
+        environment = next;
+      },
+      output: () => chain?.master ?? null,
+      addSampleSource(accepts, loader) {
+        sources.push({ accepts, loader });
+      },
+      watchVoices(listener2) {
+        watchers.add(listener2);
+        return () => void watchers.delete(listener2);
+      },
+      play: (id, playOptions = {}) => playWith(id, playOptions, randomFor(playOptions), shared),
+      playPlan(plan, playOptions = {}) {
+        const audio = ready();
+        if (!audio) return null;
+        advance();
+        const recipe2 = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
+        const voiceId = plan.silent ? void 0 : admit(recipe2, plan.level, plan.distance);
+        if (voiceId === null) return null;
+        if (planUsesNoise(plan)) prepareNoise(shared, audio, mix.noise.seconds);
+        return start(plan, shared, voiceId, playOptions.delay);
+      },
+      loop(id, loopOptions = {}) {
+        const sample = registry.sample(id);
+        if (!sample?.loop) return createLoopHandle(registry.loop(id), loopHost, loopOptions.volume);
+        return createSampleLoopHandle(
+          sample,
+          {
+            ready,
+            output: sampleOutput,
+            buffer: (url2) => sampleStore.buffer(url2),
+            isReady: (sound) => sampleStore.ready(sampleUrls(sound)),
+            load: (sound) => options.samples?.autoLoad === false ? Promise.resolve() : loadSounds([sound]),
+            fallback: (volume) => createLoopHandle(registry.loop(sample.fallback ?? sample.id) ?? registry.loop(sample.id), loopHost, volume),
+            random: engineRandom,
+            register: loopHost.register,
+            unregister: loopHost.unregister,
+            muted: (bus) => busSettings.get(bus)?.muted === true
+          },
+          loopOptions.volume
+        );
+      },
+      channel(channelOptions) {
+        const random = channelOptions.random ?? (channelOptions.seed === void 0 ? engineRandom : createRng(channelOptions.seed));
+        const store = channelOptions.ownNoise ? createNoiseStore(random) : shared;
+        return {
+          random,
+          play: (id, playOptions = {}) => playWith(id, playOptions, random, store),
+          plan: (id, playOptions = {}) => planWith(id, playOptions, createRng(playOptions.seed ?? seed))
+        };
+      },
+      setListener(next) {
+        listener = next;
+      },
+      setBus(id, setting) {
+        busSettings.set(id, { ...busSettings.get(id), ...setting });
+        if (!context) return;
+        ensureBus(id);
+        busNodes.get(id).gain.value = busGain(busSettings.get(id));
+      },
+      setMix(next) {
+        const previous = mix;
+        mix = resolveMix(next, options.profiles);
+        if (!context || !chain) return;
+        const old = chain;
+        chain = buildChain(context, mix, engineRandom);
+        if (mix.noise.seconds !== previous.noise.seconds) shared.reset();
+        for (const node of busNodes.values()) {
+          node.disconnect();
+          node.connect(chain.master);
+        }
+        for (const loop of loops) loop.rewire();
+        old.disconnect();
+      },
+      setMaster(gain) {
+        mix = { ...mix, master: gain };
+        if (chain) chain.master.gain.value = gain;
+      },
+      unlock() {
+        const audio = ready();
+        if (audio) unlockContext(audio);
+      },
+      warmUp() {
+        const audio = ready();
+        if (!audio) return false;
+        noiseBuffer(shared, audio, mix.noise.seconds);
+        return true;
+      },
+      level(bus) {
+        watched.add(bus);
+        ensureBus(bus);
+        const meter = meterOf(bus);
+        if (!meter) return 0;
+        meter.analyser.getFloatTimeDomainData(meter.data);
+        let sum = 0;
+        for (const sample of meter.data) sum += sample * sample;
+        return Math.sqrt(sum / meter.data.length);
+      },
+      deferredQueue: () => startQueue?.deferredQueue() ?? null,
+      stats() {
+        advance();
+        const voiceStats = voices.stats();
+        return {
+          context: context ? context.state : "none",
+          voices: voiceStats.active,
+          peak: voiceStats.peak,
+          dropped: voiceStats.dropped,
+          maxVoices: voiceStats.maxVoices,
+          loops: [...loops].filter((loop) => loop.created).length
+        };
+      },
+      dispose() {
+        startQueue?.clear();
+        for (const id of active.keys()) voices.release(id);
+        for (const loop of [...loops]) loop.stop();
+        active.clear();
+        void context?.close();
+        context = null;
+        chain = null;
+        busNodes.clear();
+        meters.clear();
+        shared.reset();
+        sampleStore.clear();
+        memory.clear();
+        sampleLimiters.clear();
+        chokes.clear();
+      }
+    };
+  }
+
+  // src/measure/analyze.ts
+  var dbOf = (amplitude) => amplitude > 0 ? 20 * Math.log10(amplitude) : -Infinity;
+  var clampIndex = (channels, index) => Math.max(0, Math.min(channels[0]?.length ?? 0, Math.round(index)));
+  function peakOf(channels, start = 0, end3 = Number.POSITIVE_INFINITY) {
+    let peak = 0;
+    const from = clampIndex(channels, start);
+    for (const channel of channels) {
+      const to = Math.min(channel.length, end3);
+      for (let index = from; index < to; index++) {
+        const value = Math.abs(channel[index]);
+        if (value > peak) peak = value;
+      }
+    }
+    return peak;
+  }
+  function peakIndex(channels, start = 0, end3 = Number.POSITIVE_INFINITY) {
+    let peak = -1;
+    let at = -1;
+    const from = clampIndex(channels, start);
+    for (const channel of channels) {
+      const to = Math.min(channel.length, end3);
+      for (let index = from; index < to; index++) {
+        const value = Math.abs(channel[index]);
+        if (value > peak) {
+          peak = value;
+          at = index;
+        }
+      }
+    }
+    return at;
+  }
+  function onsetIndex(channels, start = 0, threshold = 1e-3) {
+    const length = channels[0]?.length ?? 0;
+    for (let index = clampIndex(channels, start); index < length; index++) {
+      for (const channel of channels) if (Math.abs(channel[index]) >= threshold) return index;
+    }
+    return -1;
+  }
+  function rmsDb(channels, start, end3) {
+    let sum = 0;
+    let count = 0;
+    const from = clampIndex(channels, start);
+    for (const channel of channels) {
+      const to = Math.min(channel.length, Math.round(end3));
+      for (let index = from; index < to; index++) {
+        const value = channel[index];
+        sum += value * value;
+        count++;
+      }
+    }
+    return count === 0 ? -Infinity : dbOf(Math.sqrt(sum / count));
+  }
+  function centroidHz(channels, sampleRate, start, size = 2048) {
+    const from = clampIndex(channels, start);
+    const frame = new Float64Array(size);
+    for (const channel of channels) {
+      for (let index = 0; index < size; index++) frame[index] = frame[index] + (channel[from + index] ?? 0);
+    }
+    for (let index = 0; index < size; index++) frame[index] = frame[index] * (0.5 - 0.5 * Math.cos(2 * Math.PI * index / (size - 1)));
+    let weighted = 0;
+    let total = 0;
+    const bins = size / 2;
+    for (let bin = 1; bin < bins; bin++) {
+      let re = 0;
+      let im = 0;
+      const step = 2 * Math.PI * bin / size;
+      for (let index = 0; index < size; index++) {
+        const value = frame[index];
+        re += value * Math.cos(step * index);
+        im -= value * Math.sin(step * index);
+      }
+      const magnitude = Math.hypot(re, im);
+      weighted += magnitude * (bin * sampleRate / size);
+      total += magnitude;
+    }
+    return total > 0 ? weighted / total : 0;
+  }
+  function balanceOf(left, right, start, end3) {
+    let l = 0;
+    let r = 0;
+    const to = Math.min(left.length, right.length, Math.round(end3));
+    for (let index = Math.max(0, Math.round(start)); index < to; index++) {
+      l += left[index] ** 2;
+      r += right[index] ** 2;
+    }
+    return l + r > 0 ? (r - l) / (r + l) : 0;
+  }
+  function ringSeconds(channels, sampleRate, start, floorDb = -60) {
+    const window = Math.max(1, Math.round(sampleRate * 0.01));
+    const length = channels[0]?.length ?? 0;
+    let last = clampIndex(channels, start);
+    for (let index = last; index < length; index += window) {
+      if (dbOf(peakOf(channels, index, index + window)) > floorDb) last = index + window;
+    }
+    return (last - start) / sampleRate;
+  }
+  function countHits(channels, sampleRate, threshold) {
+    const window = Math.max(1, Math.round(sampleRate * 2e-3));
+    const length = channels[0]?.length ?? 0;
+    const envelope2 = [];
+    for (let index = 0; index < length; index += window) envelope2.push(peakOf(channels, index, index + window));
+    const history = 10;
+    const refractory = Math.round(0.03 / 2e-3);
+    let hits = 0;
+    let quietUntil = -1;
+    for (let index = 0; index < envelope2.length; index++) {
+      const level = envelope2[index];
+      if (index < quietUntil || level < threshold) continue;
+      let sum = 0;
+      for (let back = Math.max(0, index - history); back < index; back++) sum += envelope2[back];
+      const before = index === 0 ? 0 : sum / Math.min(history, index);
+      if (level >= 2 * before) {
+        hits++;
+        quietUntil = index + refractory;
+      }
+    }
+    return hits;
+  }
+  function endDropDb(channels, sampleRate, seconds = 5e-3) {
+    const length = channels[0]?.length ?? 0;
+    const whole = peakOf(channels);
+    if (whole === 0) return -Infinity;
+    return dbOf(peakOf(channels, length - Math.round(sampleRate * seconds), length) / whole);
+  }
+
+  // src/measure/criteria.ts
+  var CRITERIA = ["C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "C10"];
+  var CRITERIA_TARGETS = {
+    /** C1: event to the first sample, and onset to the peak (one 60 fps frame). */
+    syncMs: 20,
+    peakAfterOnsetMs: 1e3 / 60,
+    /** C3: distances measured, metres. */
+    distances: [1, 10, 50, 200],
+    /** C5: plays, distinct takes and the pitch range (fraction). */
+    plays: 10,
+    minTakes: 4,
+    pitch: [0.03, 0.05],
+    /** C6: the highest peak, dBFS. */
+    peakDb: -1,
+    /** C8: the end of each file against its peak, dB. */
+    endDropDb: -40,
+    /** C9: a burst of rapid fire. */
+    burst: 20,
+    burstSpacing: 0.06
+  };
+  var EVENT_AT = 0.2;
+  var offlineFactory = (options) => options.createOfflineContext ?? ((channels, length, sampleRate) => {
+    const Constructor = globalThis.OfflineAudioContext;
+    if (!Constructor) throw new Error("no OfflineAudioContext here: the harness runs in a browser");
+    return new Constructor(channels, length, sampleRate);
+  });
+  async function render(options, seconds, act, engineExtras = {}) {
+    const sampleRate = options.sampleRate ?? 48e3;
+    const context = offlineFactory(options)(2, Math.ceil(seconds * sampleRate), sampleRate);
+    const events = [];
+    const engine = createAudioEngine({
+      banks: options.banks,
+      createContext: () => context,
+      samples: { loader: options.loader, autoLoad: false },
+      onVoiceStart: (event) => events.push(event),
+      ...options.mix ? { mix: options.mix } : {},
+      ...engineExtras.occlusion ? { occlusion: engineExtras.occlusion } : {},
+      ...engineExtras.environment ? { environment: engineExtras.environment } : {}
+    });
+    const ids = [.../* @__PURE__ */ new Set([options.sound, ...(options.actions ?? []).map((action) => action.play), ...options.loudnessOrder ?? []])].filter((id) => engine.registry.sample(id));
+    const report = await engine.loadSamples(ids);
+    if (report.failed.length > 0) throw new Error(`files did not load: ${report.failed.map((entry) => `${entry.url} (${entry.error})`).join(", ")}`);
+    const handles = act(engine);
+    const buffer = await context.startRendering();
+    const channels = Array.from({ length: buffer.numberOfChannels }, (_, index) => buffer.getChannelData(index));
+    return { channels, sampleRate, events, handles };
+  }
+  var ms = (seconds) => `${(seconds * 1e3).toFixed(1)} ms`;
+  var db = (value) => Number.isFinite(value) ? `${value.toFixed(1)} dB` : "\u2212\u221E";
+  var decreasing = (values) => values.every((value, index) => index === 0 || value < values[index - 1]);
+  async function c1(options) {
+    const result = await render(options, 1.2, (engine) => engine.play(options.sound, { distance: 1, delay: EVENT_AT }) ? 1 : 0);
+    const onset = onsetIndex(result.channels, 0, 1e-3);
+    const event = result.events.find((entry) => entry.id === options.sound);
+    if (onset < 0 || !event) return { id: "C1", pass: false, value: "sem som", target: `\u2264 ${CRITERIA_TARGETS.syncMs} ms` };
+    const delay = onset / result.sampleRate - EVENT_AT + (event.startAt - event.requestedAt - EVENT_AT) + (options.baseLatency ?? 0);
+    const peak = peakIndex(result.channels, onset, onset + Math.round(result.sampleRate * 0.25));
+    const toPeak = (peak - onset) / result.sampleRate;
+    const pass = delay <= CRITERIA_TARGETS.syncMs / 1e3 && toPeak <= CRITERIA_TARGETS.peakAfterOnsetMs / 1e3;
+    return {
+      id: "C1",
+      pass,
+      value: `${ms(delay)}, pico +${ms(toPeak)}`,
+      target: `\u2264 ${CRITERIA_TARGETS.syncMs} ms; pico no quadro do contato`,
+      data: { delay, toPeak, baseLatency: options.baseLatency ?? 0, outputLatency: options.outputLatency ?? 0 }
+    };
+  }
+  async function c2(options) {
+    const actions = options.actions ?? [{ action: options.sound, play: options.sound, expect: options.sound }];
+    const result = await render(options, 0.5, (engine) => {
+      let played = 0;
+      for (const action of actions) if (engine.play(action.play, { distance: 1, ...action.options })) played++;
+      return played;
+    });
+    const wrong = actions.filter((action, index) => {
+      const event = result.events[index];
+      return !event || (event.fallbackOf ?? event.id) !== action.expect || event.kind !== "sample";
+    });
+    return {
+      id: "C2",
+      pass: wrong.length === 0,
+      value: `${actions.length - wrong.length}/${actions.length} certas`,
+      target: "100% das a\xE7\xF5es batem com a tabela (arquivo, n\xE3o o substituto)",
+      data: { wrong: wrong.map((action) => action.action), events: result.events.map((event) => `${event.kind}:${event.id}`) }
+    };
+  }
+  async function c3(options, sound) {
+    const levels = [];
+    const brightness = [];
+    for (const distance of CRITERIA_TARGETS.distances) {
+      const result = await render(options, 1.2, (engine) => engine.play(options.sound, { position: [0, 0, -distance], seed: 1, delay: EVENT_AT }) ? 1 : 0);
+      const onset = onsetIndex(result.channels, 0, 1e-5);
+      levels.push(onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3));
+      brightness.push(onset < 0 ? 0 : centroidHz(result.channels, result.sampleRate, onset));
+    }
+    const far = planSample(sound, { random: createRng(1), distance: CRITERIA_TARGETS.distances.at(-1) });
+    const switched = (far?.farMix ?? 0) === 1 && (far?.layers.some((layer) => layer.role === "far") ?? false);
+    const pass = decreasing(levels) && decreasing(brightness) && switched;
+    return {
+      id: "C3",
+      pass,
+      value: `${levels.map((level) => db(level)).join(" \u203A ")}; ${brightness.map((hz) => `${Math.round(hz)} Hz`).join(" \u203A ")}${switched ? "; longe = far" : "; sem camada far"}`,
+      target: "cai e escurece com a dist\xE2ncia; troca para a vers\xE3o de longe depois de ~50 m",
+      data: { distances: CRITERIA_TARGETS.distances, levels, brightness, switched }
+    };
+  }
+  async function c4(options) {
+    const side = async (x) => {
+      const result = await render(options, 0.8, (engine) => engine.play(options.sound, { position: [x, 0, -2], seed: 1, delay: EVENT_AT }) ? 1 : 0);
+      const [left2, right2] = result.channels;
+      return balanceOf(left2, right2, 0, left2.length);
+    };
+    const right = await side(10);
+    const left = await side(-10);
+    const bright = async (occluded) => {
+      const result = await render(options, 0.8, (engine) => engine.play(options.sound, { position: [0, 0, -10], seed: 1, delay: EVENT_AT }) ? 1 : 0, occluded ? { occlusion: () => 1 } : {});
+      const onset = onsetIndex(result.channels, 0, 1e-5);
+      return onset < 0 ? 0 : centroidHz(result.channels, result.sampleRate, onset);
+    };
+    const clear = await bright(false);
+    const wall = await bright(true);
+    const pass = right > 0.2 && left < -0.2 && wall < clear * 0.7;
+    return {
+      id: "C4",
+      pass,
+      value: `dir ${right.toFixed(2)} esq ${left.toFixed(2)}; parede ${Math.round(wall)} Hz de ${Math.round(clear)} Hz`,
+      target: "lado certo; atr\xE1s da parede fica abafado",
+      data: { right, left, clear, wall }
+    };
+  }
+  async function c5(options, sound) {
+    const result = await render(options, 0.3 * CRITERIA_TARGETS.plays + 1, (engine) => {
+      let played = 0;
+      for (let index = 0; index < CRITERIA_TARGETS.plays; index++) if (engine.play(options.sound, { distance: 1, delay: 0.1 + index * 0.3 })) played++;
+      return played;
+    });
+    const close = result.events.map((event) => event.layers?.find((layer) => layer.role === "close"));
+    const takes2 = close.map((layer) => layer?.url ?? "");
+    const repeats = takes2.filter((take, index) => index > 0 && take === takes2[index - 1]).length;
+    const distinct = new Set(takes2).size;
+    const rates = close.map((layer) => layer?.rate ?? 1);
+    const spread = (Math.max(...rates) - Math.min(...rates)) / 2;
+    const pitch = sound.pitch ?? 0.04;
+    const pass = distinct >= CRITERIA_TARGETS.minTakes && repeats === 0 && pitch >= CRITERIA_TARGETS.pitch[0] && pitch <= CRITERIA_TARGETS.pitch[1] && spread > 0.01;
+    return {
+      id: "C5",
+      pass,
+      value: `${distinct} tomadas, ${repeats} repeti\xE7\xF5es seguidas, tom \xB1${(pitch * 100).toFixed(0)}%`,
+      target: `\u2265 ${CRITERIA_TARGETS.minTakes} varia\xE7\xF5es, nunca a mesma duas vezes, tom \xB13\u20135%`,
+      data: { takes: takes2, rates }
+    };
+  }
+  async function c6(options) {
+    const peakAt = async (id) => {
+      const result = await render(options, 1.2, (engine) => engine.play(id, { distance: 1, seed: 1, delay: EVENT_AT }) ? 1 : 0);
+      const onset = onsetIndex(result.channels, 0, 1e-5);
+      return { peak: dbOf(peakOf(result.channels)), rms: onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3) };
+    };
+    const own = await peakAt(options.sound);
+    const order = options.loudnessOrder ?? [];
+    const loudness = [];
+    for (const id of order) loudness.push((await peakAt(id)).rms);
+    const ordered = order.length < 2 || decreasing(loudness);
+    const pass = own.peak <= CRITERIA_TARGETS.peakDb && ordered;
+    return {
+      id: "C6",
+      pass,
+      value: `pico ${db(own.peak)}, RMS ${db(own.rms)}${order.length > 1 ? `; ordem ${ordered ? "ok" : "errada"}` : ""}`,
+      target: "tiro > explos\xE3o > impacto > passo; pico \u2264 \u22121 dBFS",
+      data: { peak: own.peak, rms: own.rms, order, loudness }
+    };
+  }
+  async function c7(options, sound) {
+    if (!sound.tiers || sound.tiers.length < 2) return { id: "C7", pass: false, value: "sem camadas leve/m\xE9dio/forte", target: "muda de camada, n\xE3o s\xF3 de volume" };
+    const at = async (intensity) => {
+      const result = await render(options, 1.2, (engine) => engine.play(options.sound, { distance: 1, seed: 1, intensity, delay: EVENT_AT }) ? 1 : 0);
+      const onset = onsetIndex(result.channels, 0, 1e-5);
+      const event = result.events[0];
+      return { tier: event?.tier ?? "", rms: onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3), files: event?.layers?.find((layer) => layer.role === "close")?.url ?? "" };
+    };
+    const light = await at(0.1);
+    const heavy = await at(0.9);
+    const pass = light.tier !== heavy.tier && light.files !== heavy.files && heavy.rms > light.rms;
+    return {
+      id: "C7",
+      pass,
+      value: `${light.tier} ${db(light.rms)} \u2192 ${heavy.tier} ${db(heavy.rms)}`,
+      target: "golpe fraco x forte troca a camada (leve/m\xE9dio/forte), n\xE3o s\xF3 o volume",
+      data: { light, heavy }
+    };
+  }
+  async function c8(options, sound) {
+    const sampleRate = options.sampleRate ?? 48e3;
+    const decoder = offlineFactory(options)(1, sampleRate, sampleRate);
+    const drops = [];
+    for (const url2 of sampleUrls(sound)) {
+      const buffer = await decoder.decodeAudioData(await options.loader(url2));
+      drops.push({ url: url2, drop: endDropDb([buffer.getChannelData(0)], buffer.sampleRate) });
+    }
+    const worst = drops.reduce((max, entry) => Math.max(max, entry.drop), -Infinity);
+    const ring = async (environment) => {
+      const result = await render(options, 3, (engine) => engine.play(options.sound, { distance: 1, seed: 1, environment, delay: EVENT_AT }) ? 1 : 0);
+      return ringSeconds(result.channels, result.sampleRate, Math.round(EVENT_AT * result.sampleRate));
+    };
+    const indoor = await ring("indoor");
+    const outdoor = await ring("outdoor");
+    const hasTails = Boolean(sound.tail?.indoor?.length && sound.tail?.outdoor?.length);
+    const pass = worst <= CRITERIA_TARGETS.endDropDb && hasTails && outdoor > indoor;
+    return {
+      id: "C8",
+      pass,
+      value: `fim ${db(worst)}; cauda dentro ${indoor.toFixed(2)} s, fora ${outdoor.toFixed(2)} s${hasTails ? "" : " (sem as duas caudas)"}`,
+      target: "n\xE3o corta seco; cauda de interior x exterior coerente",
+      data: { drops, indoor, outdoor }
+    };
+  }
+  async function c9(options) {
+    const { burst, burstSpacing } = CRITERIA_TARGETS;
+    const first = 0.1;
+    const result = await render(options, burst * burstSpacing + 1.5, (engine) => {
+      let played = 0;
+      for (let index = 0; index < burst; index++) if (engine.play(options.sound, { distance: 1, delay: first + index * burstSpacing })) played++;
+      return played;
+    });
+    const peak = dbOf(peakOf(result.channels));
+    const slots = [];
+    for (let index = 0; index < burst; index++) {
+      const at = Math.round((first + index * burstSpacing) * result.sampleRate);
+      slots.push(rmsDb(result.channels, at, at + Math.round(burstSpacing * result.sampleRate)));
+    }
+    const sorted = [...slots].sort((a, b) => a - b);
+    const median = sorted[Math.floor(sorted.length / 2)];
+    const vanished = slots.filter((level) => level < median - 6).length;
+    const buildUp = slots.slice(-5).reduce((sum, level) => sum + level, 0) / 5 - slots[0];
+    const pass = result.handles === burst && vanished === 0 && buildUp <= 6 && peak <= CRITERIA_TARGETS.peakDb;
+    return {
+      id: "C9",
+      pass,
+      value: `${result.handles}/${burst} tocaram, ${vanished} sumiram, ac\xFAmulo ${buildUp >= 0 ? "+" : ""}${buildUp.toFixed(1)} dB, pico ${db(peak)}`,
+      target: "rajada sem amontoar (ac\xFAmulo \u2264 6 dB) nem sumir; pico \u2264 \u22121 dBFS",
+      data: { handles: result.handles, slots, vanished, buildUp, peak }
+    };
+  }
+  async function measureCriteria(options, only = CRITERIA) {
+    const probe = createAudioEngine({ banks: options.banks, createContext: () => null });
+    const sound = probe.registry.sample(options.sound);
+    if (!sound) throw new Error(`${options.sound} is not a sample sound of these banks`);
+    const results = [];
+    for (const id of only) {
+      if (id === "C1") results.push(await c1(options));
+      else if (id === "C2") results.push(await c2(options));
+      else if (id === "C3") results.push(await c3(options, sound));
+      else if (id === "C4") results.push(await c4(options));
+      else if (id === "C5") results.push(await c5(options, sound));
+      else if (id === "C6") results.push(await c6(options));
+      else if (id === "C7") results.push(await c7(options, sound));
+      else if (id === "C8") results.push(await c8(options, sound));
+      else if (id === "C9") results.push(await c9(options));
+      else results.push({ id: "C10", pass: null, value: "gravar e ouvir", target: "aprovado pelo ouvido do dono (print + grava\xE7\xE3o na 4280)" });
+    }
+    return results;
+  }
+  async function recordOutput(engine, seconds, act) {
+    engine.unlock();
+    const output = engine.output();
+    const Recorder = globalThis.MediaRecorder;
+    const context = output?.context;
+    if (!output || !Recorder || !context || typeof context.createMediaStreamDestination !== "function") return null;
+    const tap = context.createMediaStreamDestination();
+    output.connect(tap);
+    const recorder = new Recorder(tap.stream);
+    const chunks = [];
+    recorder.ondataavailable = (event) => chunks.push(event.data);
+    const done = new Promise((resolve) => {
+      recorder.onstop = () => resolve();
+    });
+    recorder.start();
+    act();
+    await new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+    recorder.stop();
+    await done;
+    output.disconnect(tap);
+    return new Blob(chunks, { type: recorder.mimeType || "audio/webm" });
+  }
+
+  // src/catalog.ts
+  var SFX_CATEGORIES = ["armas", "impactos", "explosoes-fogo", "personagem", "veiculos", "itens-portas", "ambiente"];
+  var entries = (category, list) => list.map(([id, priority, current]) => ({ id, category, priority, ...current ? { current } : {} }));
+  var SFX_CATALOG = [
+    ...entries("armas", [
+      ["pistol_22lr", 2, "sfx_pistol"],
+      ["pistol_9mm", 1, "sfx_pistol"],
+      ["pistol_45", 1, "sfx_pistol"],
+      ["revolver_38_357", 2, "sfx_pistol"],
+      ["revolver_44_50ae", 3, "sfx_pistol"],
+      ["smg_9mm_auto", 1, "sfx_pistol"],
+      ["shotgun_12", 1, "sfx_shotgun"],
+      ["rifle_5_56", 1, "sfx_rifle"],
+      ["rifle_7_62x39", 1, "sfx_rifle"],
+      ["rifle_auto_burst", 1, "sfx_rifle"],
+      ["rifle_308_3006", 2, "sfx_rifle"],
+      ["sniper_338_300wm", 2, "sfx_rifle"],
+      ["antimateriel_50bmg", 3, "sfx_rifle"],
+      ["suppressed_pistol", 2],
+      ["suppressed_rifle", 2],
+      ["gunshot_far_pistol", 1],
+      ["gunshot_far_rifle", 1],
+      ["gunshot_far_shotgun", 1],
+      ["gunshot_far_heavy", 2],
+      ["gunshot_tail_indoor", 1],
+      ["gunshot_tail_outdoor", 1],
+      ["bullet_crack_by", 2],
+      ["bullet_whiz", 2],
+      ["ricochet_metal", 2, "ping"],
+      ["dry_fire", 1],
+      ["mag_out", 1],
+      ["mag_in", 1],
+      ["slide_pull_release", 1],
+      ["pump_cycle", 1],
+      ["casing_drop_concreto_pistol", 1],
+      ["casing_drop_concreto_rifle", 1],
+      ["casing_drop_concreto_shell", 1],
+      ["casing_drop_madeira_pistol", 1],
+      ["casing_drop_madeira_rifle", 1],
+      ["casing_drop_madeira_shell", 1],
+      ["casing_drop_metal_pistol", 1],
+      ["casing_drop_metal_rifle", 1],
+      ["casing_drop_metal_shell", 1],
+      ["casing_drop_terra_pistol", 1],
+      ["casing_drop_terra_rifle", 1],
+      ["casing_drop_terra_shell", 1],
+      ["rocket_fire", 2]
+    ]),
+    ...entries("explosoes-fogo", [
+      ["explosion_grenade", 1, "boom"],
+      ["explosion_big", 1, "boom_big"],
+      ["explosion_car", 2, "boom_big"],
+      ["explosion_far", 1],
+      ["debris_rain_stone", 1],
+      ["molotov_break_ignite", 1, "glass_shatter"],
+      ["fire_ignite", 1, "hiss"],
+      ["fire_loop_small", 1],
+      ["fire_loop_large", 1],
+      ["fire_extinguish", 2, "hiss"],
+      ["gas_leak_hiss", 2],
+      ["structure_collapse", 2, "crumble"]
+    ]),
+    ...entries("personagem", [
+      ["footstep_concrete_walk", 1, "sfx_step"],
+      ["footstep_wood_walk", 1, "sfx_step"],
+      ["footstep_dirt_walk", 1, "sfx_step"],
+      ["footstep_grass_walk", 1, "sfx_step"],
+      ["footstep_gravel_walk", 1, "sfx_step"],
+      ["land_concrete", 1, "sfx_step"],
+      ["punch_swing", 1],
+      ["punch_hit_body", 1, "sfx_flesh"],
+      ["kick_hit", 1, "sfx_flesh"],
+      ["knife_stab", 1],
+      ["blunt_hit", 1],
+      ["bite", 1, "sfx_flesh"],
+      ["body_fall", 1],
+      ["player_hurt", 2]
+    ]),
+    ...entries("veiculos", [
+      ["engine_loop_car", 1],
+      ["engine_start", 1],
+      ["crash_light", 1, "crash"],
+      ["crash_heavy", 1, "crash"],
+      ["car_door_open", 1, "latch"],
+      ["car_door_close", 1, "shut_metal"],
+      ["horn_car", 2, "horn"],
+      ["tire_skid_asphalt", 2]
+    ]),
+    ...entries("itens-portas", [
+      ["item_pickup_metal", 1],
+      ["can_open", 1],
+      ["can_crush", 1],
+      ["door_wood_open", 1, "latch"],
+      ["door_wood_close", 1, "shut_wood"],
+      ["door_creak", 1, "creak_wood"],
+      ["door_locked_rattle", 1, "rattle"],
+      ["drawer_open", 2, "slide"],
+      ["fridge_close", 2, "shut_metal"]
+    ]),
+    ...entries("ambiente", [
+      ["rain_loop", 2],
+      ["wind_loop", 2],
+      ["thunder_near", 2],
+      ["thunder_far", 2],
+      ["water_splash", 2]
+    ])
+  ];
+  var SFX_MATERIALS = [
+    ["steel", "metal"],
+    ["aluminium", "metal"],
+    ["wood", "wood"],
+    ["plywood", "wood"],
+    ["mdf", "wood"],
+    ["glass", "glass"],
+    ["tempered_glass", "glass"],
+    ["ceramic", "glass"],
+    ["concrete", "masonry"],
+    ["brick", "masonry"],
+    ["plaster", "masonry"],
+    ["plastic", "soft"],
+    ["fabric", "soft"],
+    ["paper", "soft"],
+    ["foliage", "soft"],
+    ["soil", "soft"],
+    ["flesh", "soft"]
+  ];
+  var SFX_BLOWS = ["bullet", "blunt", "blade", "break", "drag"];
+  var CURRENT_BY_GROUP = {
+    metal: { bullet: "clang", blunt: "clang", blade: "clang", break: "clang", drag: "drag_metal" },
+    wood: { bullet: "wood_hit", blunt: "wood_hit", blade: "wood_hit", break: "crack", drag: "drag_wood" },
+    glass: { bullet: "ping", blunt: "ping", break: "glass_shatter", drag: "drag_glass" },
+    masonry: { bullet: "chip", blunt: "chip", blade: "chip", break: "crumble", drag: "drag_masonry" },
+    soft: { bullet: "thud", blunt: "thud", blade: "thud", break: "thud", drag: "drag_soft" }
+  };
+  var impactSoundId = (material, blow) => `impact_${material}_${blow}`;
+  var SFX_IMPACTS = SFX_MATERIALS.flatMap(
+    ([material, group]) => SFX_BLOWS.map((blow) => {
+      const current = CURRENT_BY_GROUP[group]?.[blow];
+      return { id: impactSoundId(material, blow), category: "impactos", priority: ["steel", "wood", "glass", "concrete", "brick", "soil", "flesh"].includes(material) && blow === "bullet" ? 1 : 2, ...current ? { current } : {} };
+    })
+  );
+  function sfxState(entry, has) {
+    if (has.sample(entry.id)) return "file";
+    if (entry.current && has.sound(entry.current) || has.sound(entry.id)) return "synth";
+    return "missing";
+  }
+
+  // src/manifest.ts
+  var SDK_LICENSES = ["CC0", "CC-BY"];
+  var SFX_LAYERS = ["close", "far", "tail_in", "tail_out"];
+  var SFX_TIERS = { light: 0, medium: 0.34, heavy: 0.67 };
+  function parseSfxName(name) {
+    const match = /^(.*?)(?:_(close|far|tail_in|tail_out))?(?:_(\d+))?$/.exec(name);
+    const id = match?.[1] || name;
+    const layer = match?.[2] ?? "close";
+    const take = match?.[3] ? Number(match[3]) : 1;
+    return { id, layer, take };
+  }
+  function splitTier(id) {
+    const match = /^(.*)_(light|medium|heavy)$/.exec(id);
+    return match ? { base: match[1], tier: match[2] } : { base: id };
+  }
+  var refsOf = (entries2, baseUrl) => (entries2 ?? []).map((entry) => ({ url: `${baseUrl}${entry.file}` }));
+  function sampleBankFromManifest(manifest, options) {
+    const baseUrl = options.baseUrl ?? "";
+    const samples = [];
+    const tiersOf = /* @__PURE__ */ new Map();
+    for (const sound of manifest.sounds) {
+      const { base, tier } = splitTier(sound.id);
+      if (tier) tiersOf.set(base, [...tiersOf.get(base) ?? [], sound]);
+    }
+    const bases = /* @__PURE__ */ new Map();
+    for (const sound of manifest.sounds) {
+      if (!splitTier(sound.id).tier) bases.set(sound.id, sound);
+    }
+    for (const [base, tiers] of tiersOf) {
+      if (!bases.has(base)) bases.set(base, { id: base, category: tiers[0]?.category ?? "", layers: { close: tiers[0]?.layers.close ?? [] } });
+    }
+    for (const sound of bases.values()) {
+      const numbers = options.sounds?.[sound.id] ?? options.defaults?.(sound);
+      const close = refsOf(sound.layers.close, baseUrl);
+      if (!numbers || close.length === 0) continue;
+      const tiers = (tiersOf.get(sound.id) ?? []).map((tier) => {
+        const name = splitTier(tier.id).tier;
+        const tierFar = refsOf(tier.layers.far, baseUrl);
+        return { name, from: SFX_TIERS[name] ?? 0, close: refsOf(tier.layers.close, baseUrl), ...tierFar.length > 0 ? { far: tierFar } : {} };
+      }).sort((a, b) => a.from - b.from);
+      const far = refsOf(sound.layers.far, baseUrl);
+      const indoor = refsOf(sound.layers.tail_in, baseUrl);
+      const outdoor = refsOf(sound.layers.tail_out, baseUrl);
+      const files = [sound, ...tiersOf.get(sound.id) ?? []].flatMap((entry) => Object.values(entry.layers).flatMap((entries2) => entries2 ?? []));
+      samples.push({
+        id: sound.id,
+        bus: numbers.bus,
+        close,
+        ...far.length > 0 ? { far } : {},
+        ...tiers.length > 0 ? { tiers } : {},
+        ...numbers.crossover ? { crossover: numbers.crossover } : {},
+        ...indoor.length > 0 || outdoor.length > 0 ? { tail: { ...indoor.length > 0 ? { indoor } : {}, ...outdoor.length > 0 ? { outdoor } : {}, ...numbers.tailGain === void 0 ? {} : { gain: numbers.tailGain } } } : {},
+        ...numbers.pitch === void 0 ? {} : { pitch: numbers.pitch },
+        ...numbers.gain === void 0 ? {} : { gain: numbers.gain },
+        ...numbers.falloff ? { falloff: numbers.falloff } : {},
+        ...numbers.cutoffK === void 0 ? {} : { cutoffK: numbers.cutoffK },
+        ...numbers.group ? { group: numbers.group } : {},
+        ...numbers.priority === void 0 ? {} : { priority: numbers.priority },
+        ...numbers.fallback ? { fallback: numbers.fallback } : {},
+        sources: files.map((file) => `${file.file}: ${file.source} ${file.author} ${file.license}`)
+      });
+    }
+    return { id: options.id, samples };
+  }
+
+  // src/kit-samples.ts
+  var KIT_CATEGORY_BUS = {
+    armas: "weapons",
+    impactos: "world",
+    "explosoes-fogo": "world",
+    personagem: "world",
+    veiculos: "world",
+    "itens-portas": "world",
+    ambiente: "ambience"
+  };
+  var VOICE_IDS = /^(player_(hurt|death|effort|breath)|scream|zombie_)/;
+  var KIT_SAMPLE_ALIASES = {
+    // a house door: the latch giving, the hinge, the leaf meeting the frame, a locked one shaken; a drawer on its runners
+    latch: "metal_latch",
+    creak_wood: "door_creak",
+    shut_wood: "door_wood_shut",
+    rattle: "door_locked_rattle",
+    // a drawer stays on its recipe: the recorded runs (1 to 1.9 s) outlast a drawer's pull
+    // an item taken in the hand (game-destruction-three grab_* keys)
+    grab_hard: "item_pickup_generic",
+    grab_soft: "item_pickup_leather"
+  };
+  function kitSampleDefaults(sound) {
+    const bus = VOICE_IDS.test(sound.id) ? "voices" : KIT_CATEGORY_BUS[sound.category];
+    if (!bus) return void 0;
+    return { bus, pitch: sound.category === "ambiente" || /_loop/.test(sound.id) ? 0 : 0.04 };
+  }
+  function withAliases(manifest, aliases) {
+    const byId = new Map(manifest.sounds.map((sound) => [sound.id, sound]));
+    const extra = [];
+    for (const [alias, target] of Object.entries(aliases)) {
+      const sound = byId.get(target);
+      if (sound && !byId.has(alias)) extra.push({ ...sound, id: alias });
+    }
+    return { ...manifest, sounds: [...manifest.sounds, ...extra] };
+  }
+  function kitSampleBank(manifest, options = {}) {
+    return sampleBankFromManifest(withAliases(manifest, options.aliases ?? KIT_SAMPLE_ALIASES), {
+      id: options.id ?? "kit_samples",
+      baseUrl: options.baseUrl ?? "",
+      defaults: kitSampleDefaults
+    });
+  }
+  var isFileUrl = (url2) => {
+    const page = globalThis.location?.href;
+    try {
+      return new URL(url2, page).protocol === "file:";
+    } catch {
+      return false;
+    }
+  };
+  var fetchJson = async (url2) => {
+    if (isFileUrl(url2)) throw new Error(`${url2}: file:// is not fetched`);
+    const response = await fetch(url2);
+    if (!response.ok) throw new Error(`${url2}: ${response.status}`);
+    return await response.json();
+  };
+  async function loadKitSamples(engine, options = {}) {
+    const baseUrl = options.baseUrl ?? "";
+    let manifest;
+    try {
+      manifest = await (options.fetchManifest ?? fetchJson)(`${baseUrl}manifest.json`);
+    } catch {
+      return null;
+    }
+    const bank = kitSampleBank(manifest, options);
+    engine.register(bank);
+    if (options.preload && engine.loadSamples) void engine.loadSamples(options.preload).catch(() => void 0);
+    return bank;
+  }
+
+  // src/data/game-sfx.json
+  var game_sfx_default = {
+    sources: ["jogo:L62089-62107"],
+    note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
+    classes: [
+      { id: "pistol", team: "pistola", bus: "weapons", cutoff: 1800, gain: 0.9, seconds: 0.18 },
+      { id: "shotgun", team: "escopeta", bus: "weapons", cutoff: 900, gain: 1.2, seconds: 0.35 },
+      { id: "rifle", team: "fuzil", bus: "weapons", cutoff: 1400, gain: 1.1, seconds: 0.28 },
+      { id: "long_rifle", team: "rifle", bus: "weapons", cutoff: 1100, gain: 1.3, seconds: 0.45 },
+      { id: "impact", team: "impacto", bus: "world", cutoff: 2500, gain: 0.25, seconds: 0.05 },
+      { id: "flesh", team: "carne", bus: "world", cutoff: 600, gain: 0.35, seconds: 0.08 },
+      { id: "step", team: "passo", bus: "world", cutoff: 400, gain: 0.08, seconds: 0.05 },
+      { id: "glass", team: "vidro", bus: "world", cutoff: 5e3, gain: 0.5, seconds: 0.3 },
+      { id: "wood", team: "madeira", bus: "world", cutoff: 700, gain: 0.5, seconds: 0.2 },
+      { id: "reload", team: "recarga", bus: "weapons", cutoff: 3e3, gain: 0.15, seconds: 0.06 },
+      { id: "empty", team: "vazio", bus: "weapons", cutoff: 4e3, gain: 0.12, seconds: 0.03 },
+      { id: "explosion", team: "explosao", bus: "world", cutoff: 200, gain: 1.6, seconds: 1.4 }
+    ],
+    fallback: { id: "unknown", team: "(any other name)", bus: "world", cutoff: 1e3, gain: 0.5, seconds: 0.1 }
+  };
+
+  // src/recipes/noise-class.ts
+  var GAME_SFX = game_sfx_default;
+  var GAME_SFX_CLASSES = GAME_SFX.classes;
+  var GAME_SFX_FALLBACK = GAME_SFX.fallback;
+  function noiseClassRecipe(row, id = `sfx_${row.id}`) {
+    return {
+      id,
+      bus: row.bus,
+      order: "burst",
+      duration: row.seconds,
+      tail: 0.05,
+      layers: [
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: row.cutoff } }] },
+          envelope: [
+            [0, row.gain, "set"],
+            ["1d", 1e-3, "exp", "fixed"]
+          ]
+        }
+      ],
+      falloff: DISTANCE_CURVES.game_sfx,
+      sources: [...GAME_SFX.sources.map((source) => `${source} ${row.team}`)]
+    };
+  }
+  var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+
+  // src/recipes/scene.ts
+  var ATTACK = 2e-3;
+  function lengthOf(d, attack) {
+    if (typeof d === "number") return attack + d;
+    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
+    return { ...d, add: (d.add ?? 0) + attack };
+  }
+  var envelope = (attack) => [
+    [0, 1e-4, "set", "fixed"],
+    [attack, 1, "exp"],
+    ["1d", 1e-4, "exp", "fixed"]
+  ];
+  function sceneNoise(o) {
+    const a = o.a ?? ATTACK;
+    const over = typeof o.d === "number" ? o.d : 0;
+    return {
+      filters: {
+        mode: "serial",
+        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
+      },
+      duration: lengthOf(o.d, a),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+      envelope: envelope(a)
     };
-    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)
+  }
+  function sceneTone(o) {
+    return {
+      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
+      duration: lengthOf(o.d, ATTACK),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      envelope: envelope(ATTACK)
     };
+  }
+  function sceneVoice(o) {
     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 recipe2 = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
-        const voiceId = plan.silent ? void 0 : admit(recipe2, 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);
-      },
-      deferredQueue: () => startQueue?.deferredQueue() ?? null,
-      stats() {
-        advance();
-        const voiceStats = voices.stats();
-        return {
-          context: context ? context.state : "none",
-          voices: voiceStats.active,
-          peak: voiceStats.peak,
-          dropped: voiceStats.dropped,
-          maxVoices: voiceStats.maxVoices,
-          loops: [...loops].filter((loop) => loop.created).length
-        };
+      duration: lengthOf(o.d, 0),
+      gain: o.vol,
+      wet: 0.45,
+      source: {
+        kind: "formant_voice",
+        wave: o.wave ?? "sawtooth",
+        frequency: { from: o.f0, to: o.f1, curve: "linear", over: "duration" },
+        vibrato: { rate: [4, 10], depth: 0.08 },
+        formants: [
+          { frequency: o.fA, q: 4 },
+          { frequency: o.fB, q: 6 }
+        ],
+        breath: { frequency: o.fB, q: 1.1, gain: o.noise },
+        mix: 3.2
       },
-      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();
+      envelope: [
+        [0, 1e-4, "set", "fixed"],
+        [0.1, 1, "exp"],
+        ["0.6d", 1, "set"],
+        ["1d", 1e-4, "exp", "fixed"]
+      ]
+    };
+  }
+  var sceneMany = (count, make) => Array.from({ length: count }, make);
+  function sceneRecipe(id, layers, line, options = {}) {
+    return {
+      id,
+      bus: options.bus ?? "world",
+      pan: true,
+      layers,
+      falloff: DISTANCE_CURVES.art_scene,
+      ...options.vars ? { vars: options.vars } : {},
+      ...options.group ? { group: options.group } : {},
+      sources: [`cena:${line}`]
+    };
+  }
+
+  // src/library/crowd_rumble.json
+  var crowd_rumble_default = {
+    id: "crowd_rumble",
+    bus: "ambience",
+    order: "game_loop",
+    source: { kind: "noise", loop: true },
+    filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 160 } }] },
+    smoothing: { volume: 0.15, frequency: 0.08 },
+    startAbove: 2e-3,
+    sources: ["jogo:L62116 horda: noise through a 160 Hz lowpass", "jogo:L70424 level min(0.16, near \xD7 0.0016)", "temporary home until the crowd package (Q12)"]
+  };
+
+  // src/library/engine_saw.json
+  var engine_saw_default = {
+    id: "engine_saw",
+    bus: "world",
+    order: "game_loop",
+    source: { kind: "osc", wave: "sawtooth", loop: true },
+    filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 400 } }] },
+    smoothing: { volume: 0.15, frequency: 0.08 },
+    startAbove: 2e-3,
+    sources: [
+      "jogo:L62115 motor: sawtooth through a 400 Hz lowpass",
+      "jogo:L70421 level 0.035 + speed \xD7 0.003, frequency 38 + speed \xD7 7 (the host drives `set`)",
+      "temporary home until the vehicles package (Q12)"
+    ]
+  };
+
+  // src/library/horn.json
+  var horn_default = {
+    id: "horn",
+    bus: "world",
+    order: "chord",
+    duration: 0.6,
+    tail: 0.02,
+    layers: [
+      { source: { kind: "osc", wave: "square", frequency: { set: 415 } }, envelope: [[0, 0.08, "set"], [0.6, 1e-4, "set", "fixed"]] },
+      { source: { kind: "osc", wave: "square", frequency: { set: 523 } }, envelope: [[0, 0.08, "set"], [0.6, 1e-4, "set", "fixed"]] }
+    ],
+    falloff: { model: "none" },
+    sources: ["jogo:L70272-70276 buzina: squares at 415 and 523 Hz, 0.08 for 0.6 s", "temporary home until the vehicles package (Q12)"]
+  };
+
+  // src/library/radio_static.json
+  var radio_static_default = {
+    id: "radio_static",
+    bus: "world",
+    order: "static",
+    duration: 0.6,
+    layers: [
+      {
+        source: { kind: "noise", offset: "random" },
+        filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: 1800 }, q: 0.8 }] },
+        envelope: [[0, 0.06, "set"], ["1d", 1e-3, "exp", "fixed"]]
+      }
+    ],
+    falloff: { model: "none" },
+    sources: ["jogo:L69998-70004 chiado: noise through a 1800 Hz bandpass (Q 0.8), 0.06 falling over 0.6 s", "temporary home until the props or radio package (Q12)"]
+  };
+
+  // src/library/rotor_blades.json
+  var rotor_blades_default = {
+    id: "rotor_blades",
+    bus: "world",
+    order: "game_loop",
+    source: { kind: "noise", loop: true },
+    filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 300 } }] },
+    modulators: [{ target: "gain", rate: 11, depth: 0.5, base: 0.5 }],
+    smoothing: { volume: 0.15, frequency: 0.08 },
+    startAbove: 2e-3,
+    sources: [
+      "jogo:L62116-62120 rotor: noise through a 300 Hz lowpass, blade beat as an 11 Hz LFO of 0.5 on a 0.5 gain stage",
+      "jogo:L70426 level min(0.5, 30 / (distance + 10))",
+      "temporary home until the vehicles package (Q12)"
+    ]
+  };
+
+  // src/library/siren.json
+  var siren_default = {
+    id: "siren",
+    bus: "world",
+    order: "siren",
+    duration: 9,
+    tail: 0.2,
+    layers: [
+      {
+        wet: 1.5,
+        source: { kind: "osc", wave: "sine", frequency: { set: 850 } },
+        modulators: [{ target: "frequency", rate: 0.18, depth: 280 }],
+        filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 1400 } }] },
+        envelope: [[0, 1e-4, "set", "fixed"], [2, 0.035, "exp"], [6, 0.035, "set"], [9, 1e-4, "exp", "fixed"]]
       }
-    };
+    ],
+    falloff: { model: "none" },
+    sources: ["cena:L1369 siren: 850 Hz sine swept \xB1280 Hz at 0.18 Hz, 1400 Hz lowpass, 0.035 for 9 s, reverb send 1.5", "temporary home until the vehicles package (Q12)"]
+  };
+
+  // src/library/index.ts
+  var LIBRARY_SOUNDS = [horn_default, radio_static_default, siren_default];
+  var LIBRARY_LOOPS = [engine_saw_default, rotor_blades_default, crowd_rumble_default];
+  var LIBRARY_BANK = { id: "library", sounds: LIBRARY_SOUNDS, loops: LIBRARY_LOOPS };
+
+  // src/recipes/foley.ts
+  var FOLEY_FALLOFF = {
+    model: "inverse_square",
+    k: 0.02,
+    cutoffK: 0.04,
+    minGain: 4e-3
+  };
+  var vary = (f, pct = 0.04) => [Math.round(f * (1 - pct)), Math.round(f * (1 + pct))];
+  var foley = (id, layers, note) => ({
+    id,
+    bus: "world",
+    pan: true,
+    layers,
+    falloff: FOLEY_FALLOFF,
+    sources: [`sdk: ${note}`]
+  });
+  var click = (f, vol, delay = 0) => [
+    sceneNoise({
+      type: "bandpass",
+      f: vary(f, 0.08),
+      q: 4,
+      d: [0.018, 0.03],
+      vol: [vol * 0.85, vol * 1.1],
+      delay
+    }),
+    sceneTone({
+      f: vary(f * 0.8, 0.06),
+      f2: Math.round(f * 0.62),
+      d: [0.015, 0.025],
+      vol: vol * 0.18,
+      delay
+    })
+  ];
+  var meet = (body, panel, vol, latch) => [
+    sceneTone({
+      f: vary(body),
+      f2: Math.round(body * 0.5),
+      d: [0.12, 0.16],
+      vol: [vol * 0.9, vol * 1.1]
+    }),
+    sceneNoise({
+      type: "bandpass",
+      f: vary(panel, 0.06),
+      q: 1.2,
+      d: [0.08, 0.12],
+      vol: [vol * 0.9, vol * 1.1],
+      wet: 0.25
+    }),
+    ...click(latch, vol * 0.45, [0.012, 0.028])
+  ];
+  var LEAF_FOLEY = [
+    // a wooden house door or wardrobe door: latch, a short creak, the leaf on the frame (the hard slam adds the frame rattling)
+    foley("door_wood_open", click(2400, 0.4), "the latch of a wooden door giving"),
+    foley(
+      "door_creak",
+      [
+        sceneTone({ f: [190, 240], f2: 310, d: [0.4, 0.55], vol: [0.04, 0.06] }),
+        sceneNoise({
+          type: "bandpass",
+          f: [480, 560],
+          q: 6,
+          a: 0.05,
+          d: [0.35, 0.5],
+          vol: [0.1, 0.14]
+        })
+      ],
+      "a wooden hinge turning"
+    ),
+    foley("door_wood_close", meet(120, 600, 0.55, 2400), "a wooden leaf meeting its frame"),
+    foley(
+      "door_wood_slam",
+      [
+        ...meet(110, 560, 0.85, 2300),
+        ...sceneMany(
+          3,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [900, 1500],
+            q: 3,
+            d: 0.03,
+            vol: [0.08, 0.14],
+            delay: [0.05, 0.18]
+          })
+        )
+      ],
+      "a wooden door slammed: the frame and the hinges rattle after the hit"
+    ),
+    // a metal door or gate: a hollow panel that rings a little
+    foley("door_metal_open_close", [...meet(160, 900, 0.55, 2e3), sceneTone({ f: vary(1250), f2: 1150, d: [0.1, 0.16], vol: 0.06, wet: 0.3 })], "a metal door or gate meeting its frame"),
+    foley(
+      "door_creak_metal",
+      [
+        sceneTone({ f: [620, 760], f2: 900, d: [0.3, 0.4], vol: [0.03, 0.045] }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1300, 1500],
+          q: 8,
+          a: 0.04,
+          d: [0.25, 0.35],
+          vol: [0.07, 0.09]
+        })
+      ],
+      "a metal hinge turning"
+    ),
+    // the handle of a locked door shaken: the latch knocking in its keeper, five to seven times in half a second
+    foley(
+      "door_locked_rattle",
+      [
+        ...sceneMany(
+          6,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [1600, 2600],
+            q: 3,
+            d: [0.025, 0.04],
+            vol: [0.22, 0.34],
+            delay: [0, 0.45]
+          })
+        ),
+        ...sceneMany(
+          3,
+          () => sceneTone({
+            f: [170, 210],
+            f2: 120,
+            d: 0.05,
+            vol: [0.12, 0.18],
+            delay: [0.02, 0.4]
+          })
+        )
+      ],
+      "the handle of a locked door shaken: latch knocks and the leaf thumping in its frame"
+    ),
+    // a fridge: the rubber seal lets go with a soft suck, the bottles in the door clink; closing it is a soft thump and the seal pulling shut
+    foley(
+      "fridge_open",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [320, 380],
+          a: 0.03,
+          d: [0.14, 0.2],
+          vol: [0.32, 0.4]
+        }),
+        sceneNoise({
+          type: "bandpass",
+          f: [800, 950],
+          f2: 1400,
+          q: 2,
+          a: 0.02,
+          d: 0.12,
+          vol: [0.08, 0.12]
+        }),
+        ...sceneMany(
+          2,
+          () => sceneTone({
+            f: [2600, 4200],
+            d: [0.04, 0.08],
+            vol: [0.015, 0.03],
+            delay: [0.08, 0.22]
+          })
+        )
+      ],
+      "a fridge door: the seal letting go and the bottles in the door"
+    ),
+    foley(
+      "fridge_close",
+      [
+        sceneTone({ f: vary(85), f2: 45, d: [0.1, 0.13], vol: [0.38, 0.46] }),
+        sceneNoise({
+          type: "lowpass",
+          f: [520, 620],
+          d: [0.08, 0.12],
+          vol: [0.3, 0.36]
+        }),
+        sceneNoise({
+          type: "lowpass",
+          f: [260, 320],
+          a: 0.02,
+          d: 0.1,
+          vol: [0.12, 0.18],
+          delay: [0.04, 0.07]
+        }),
+        ...sceneMany(
+          2,
+          () => sceneTone({
+            f: [2600, 4200],
+            d: [0.04, 0.07],
+            vol: [0.015, 0.03],
+            delay: [0.03, 0.12]
+          })
+        )
+      ],
+      "a fridge door shut: a soft thump, the seal pulling and the bottles"
+    ),
+    // a microwave: the spring catch of the door, plastic on plastic
+    foley(
+      "microwave_open",
+      [
+        ...click(1800, 0.34),
+        sceneTone({
+          f: [3e3, 3400],
+          f2: 2800,
+          d: 0.05,
+          vol: 0.025,
+          delay: [0.01, 0.02]
+        })
+      ],
+      "the spring catch of a microwave door"
+    ),
+    foley(
+      "microwave_close",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1200, 1450],
+          q: 2.5,
+          d: [0.04, 0.06],
+          vol: [0.36, 0.44]
+        }),
+        sceneTone({ f: vary(180), f2: 120, d: 0.05, vol: [0.16, 0.22] }),
+        ...click(2200, 0.2, [8e-3, 0.016])
+      ],
+      "a microwave door clacking shut"
+    ),
+    foley("microwave_beep", [sceneTone({ wave: "square", f: 2e3, d: 0.12, vol: 0.05 })], "the beep of a microwave"),
+    // drawers and sliding leaves: the runners, then the stop
+    foley(
+      "drawer_open",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [620, 780],
+          q: 2,
+          a: 0.04,
+          d: [0.28, 0.36],
+          vol: [0.18, 0.24]
+        }),
+        sceneNoise({ type: "bandpass", f: [2e3, 2400], q: 5, d: 0.28, vol: 0.04 }),
+        ...click(1400, 0.16, [0.28, 0.34])
+      ],
+      "a drawer on its runners and its stop"
+    ),
+    foley(
+      "drawer_close",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [620, 780],
+          q: 2,
+          a: 0.03,
+          d: [0.2, 0.28],
+          vol: [0.18, 0.24]
+        }),
+        sceneTone({
+          f: vary(150),
+          f2: 90,
+          d: 0.08,
+          vol: [0.22, 0.3],
+          delay: [0.2, 0.26]
+        })
+      ],
+      "a drawer pushed home"
+    )
+  ];
+  var ITEM_FOLEY = [
+    // the hand closing on the item: a touch of skin and cloth, then the item's own small sound
+    foley(
+      "item_pickup_metal",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneTone({
+          f: [1900, 2600],
+          f2: 1700,
+          d: [0.05, 0.08],
+          vol: [0.06, 0.09],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a metal thing"
+    ),
+    foley(
+      "item_pickup_plastic",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1500, 1900],
+          q: 3,
+          d: 0.03,
+          vol: [0.15, 0.21],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a plastic thing"
+    ),
+    foley(
+      "item_pickup_glass",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.15 }),
+        sceneTone({
+          f: [3200, 4200],
+          d: [0.05, 0.08],
+          vol: [0.038, 0.06],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a glass thing"
+    ),
+    foley(
+      "item_pickup_paper",
+      [
+        sceneNoise({
+          type: "highpass",
+          f: [2600, 3400],
+          a: 0.01,
+          d: [0.1, 0.14],
+          vol: [0.12, 0.18]
+        }),
+        sceneNoise({ type: "bandpass", f: [800, 1e3], q: 1, d: 0.05, vol: 0.12 })
+      ],
+      "picking up paper or cardboard"
+    ),
+    foley(
+      "item_pickup_fabric",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [900, 1300],
+          q: 0.8,
+          a: 0.02,
+          d: [0.12, 0.16],
+          vol: [0.15, 0.21]
+        })
+      ],
+      "picking up cloth"
+    ),
+    foley(
+      "item_pickup_wood",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "bandpass",
+          f: [900, 1100],
+          q: 2,
+          d: 0.04,
+          vol: [0.15, 0.21],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a wooden thing"
+    ),
+    foley(
+      "item_pickup_food",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "lowpass",
+          f: [500, 650],
+          d: 0.05,
+          vol: 0.12,
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up food"
+    ),
+    foley(
+      "item_throw",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [450, 650],
+          f2: 1400,
+          q: 1.5,
+          a: 0.05,
+          d: 0.18,
+          vol: [0.1, 0.14]
+        })
+      ],
+      "the arm throwing something: air"
+    ),
+    // a can: the tab cracks, the gas hisses out; drinking is gulps; crushing it crumples the sheet
+    foley(
+      "can_open",
+      [
+        ...click(3200, 0.36),
+        sceneNoise({
+          type: "highpass",
+          f: [3600, 4400],
+          a: 5e-3,
+          d: [0.22, 0.3],
+          vol: [0.16, 0.22],
+          delay: [0.012, 0.02]
+        }),
+        ...sceneMany(5, () => sceneTone({ f: [4e3, 7e3], d: 0.02, vol: 0.01, delay: [0.05, 0.4] }))
+      ],
+      "the tab of a can and the gas hissing out"
+    ),
+    foley(
+      "can_crush",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1600, 2200],
+          q: 1.2,
+          d: [0.18, 0.25],
+          vol: [0.3, 0.38]
+        }),
+        ...sceneMany(
+          6,
+          () => sceneTone({
+            f: [1200, 3400],
+            f2: 900,
+            d: 0.03,
+            vol: [0.03, 0.06],
+            delay: [0, 0.2]
+          })
+        )
+      ],
+      "a can crushed in the hand"
+    ),
+    foley(
+      "can_puncture_spray",
+      [
+        sceneNoise({
+          type: "highpass",
+          f: [2400, 3e3],
+          a: 5e-3,
+          d: [0.5, 0.7],
+          vol: [0.2, 0.26]
+        }),
+        sceneNoise({ type: "bandpass", f: [600, 800], q: 2, d: 0.4, vol: 0.06 })
+      ],
+      "a can holed: the jet hissing out"
+    ),
+    foley(
+      "bottle_open",
+      [
+        ...sceneMany(
+          5,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [2200, 3e3],
+            q: 4,
+            d: 8e-3,
+            vol: [0.1, 0.16],
+            delay: [0, 0.18]
+          })
+        ),
+        sceneNoise({
+          type: "highpass",
+          f: 3800,
+          a: 5e-3,
+          d: 0.12,
+          vol: [0.06, 0.1],
+          delay: [0.18, 0.22]
+        })
+      ],
+      "the screw cap of a bottle turning off"
+    ),
+    foley(
+      "drink_gulp",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [280, 360],
+          a: 0.02,
+          d: [0.1, 0.14],
+          vol: [0.24, 0.3]
+        }),
+        sceneTone({ f: [140, 170], f2: 85, d: [0.08, 0.11], vol: [0.12, 0.16] })
+      ],
+      "a gulp"
+    ),
+    foley(
+      "eat_crunch",
+      [
+        ...sceneMany(
+          4,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [1800, 3200],
+            q: 1.5,
+            d: [0.02, 0.04],
+            vol: [0.12, 0.2],
+            delay: [0, 0.12]
+          })
+        )
+      ],
+      "a bite of something crunchy"
+    ),
+    foley(
+      "eat_chew",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [450, 600],
+          a: 0.03,
+          d: [0.1, 0.14],
+          vol: [0.12, 0.16]
+        }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1100, 1400],
+          q: 2,
+          d: 0.04,
+          vol: 0.04,
+          delay: [0.03, 0.06]
+        })
+      ],
+      "chewing"
+    ),
+    foley(
+      "bandage_wrap",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1400, 1800],
+          f2: 2400,
+          q: 1,
+          a: 0.04,
+          d: [0.3, 0.4],
+          vol: [0.12, 0.16]
+        })
+      ],
+      "a bandage unrolled round a limb"
+    ),
+    foley(
+      "pills_shake",
+      [
+        ...sceneMany(
+          8,
+          () => sceneTone({
+            f: [2400, 3600],
+            d: 0.015,
+            vol: [0.03, 0.05],
+            delay: [0, 0.25]
+          })
+        ),
+        sceneNoise({ type: "bandpass", f: [1500, 1900], q: 2, d: 0.25, vol: 0.05 })
+      ],
+      "pills shaken in their bottle"
+    ),
+    foley(
+      "medkit_use",
+      [
+        ...click(1700, 0.24),
+        sceneNoise({
+          type: "bandpass",
+          f: [1e3, 1400],
+          q: 1,
+          a: 0.03,
+          d: [0.25, 0.32],
+          vol: [0.08, 0.12],
+          delay: [0.05, 0.08]
+        })
+      ],
+      "a first aid kit opened and rummaged"
+    ),
+    foley("flashlight_click", click(2600, 0.3), "the switch of a flashlight")
+  ];
+  var FOLEY_BANK = {
+    id: "foley",
+    sounds: [...LEAF_FOLEY, ...ITEM_FOLEY]
+  };
+  var PICKUP_CLASSES = ["metal", "plastic", "glass", "paper", "fabric", "wood", "food"];
+  var LEAF_FOLEY_SETS = {
+    wood_door: {
+      open: "door_wood_open",
+      turn: "door_creak",
+      close: "door_wood_close",
+      slam: "door_wood_slam",
+      locked: "door_locked_rattle"
+    },
+    metal_door: {
+      open: "door_wood_open",
+      turn: "door_creak_metal",
+      close: "door_metal_open_close",
+      locked: "door_locked_rattle"
+    },
+    fridge: {
+      open: "fridge_open",
+      close: "fridge_close",
+      locked: "door_locked_rattle"
+    },
+    microwave: {
+      open: "microwave_open",
+      close: "microwave_close",
+      locked: "door_locked_rattle"
+    },
+    drawer: {
+      open: "drawer_open",
+      close: "drawer_close",
+      locked: "door_locked_rattle"
+    }
+  };
+
+  // src/recipes/body-foley.ts
+  var BODY_FOLEY_TAKES = 4;
+  var TAKES2 = [
+    { 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 } }
+  };
+  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 }
+  };
+  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 = TAKES2.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 })
+    ],
+    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 }] }
+    ],
+    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 })
+    ],
+    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]] })
+  };
+  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)
+  };
+  var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
 
   // src/webaudio/sink.ts
   function createAudioSink(engine) {
@@ -2114,7 +4249,8 @@ var GameAudio = (() => {
           ...request.volume === void 0 ? {} : { volume: request.volume },
           ...request.params ? { params: request.params } : {},
           ...request.seed === void 0 ? {} : { seed: request.seed },
-          ...request.delay === void 0 ? {} : { delay: request.delay }
+          ...request.delay === void 0 ? {} : { delay: request.delay },
+          ...request.urgent ? { urgent: true } : {}
         });
         if (!handle) return null;
         playing.set(handle.id, handle);
@@ -2124,9 +4260,22 @@ var GameAudio = (() => {
         playing.get(handle.id)?.stop();
         playing.delete(handle.id);
       },
-      loop(sound) {
+      loop(sound, options) {
         const loop = engine.loop(sound);
-        return { set: (state) => loop.set({ ...state.volume === void 0 ? {} : { volume: state.volume }, ...state.frequency === void 0 ? {} : { frequency: state.frequency } }), stop: () => loop.stop() };
+        let position = options?.position;
+        return {
+          set: (state) => {
+            position = state.position ?? position;
+            const cutoff = state.params?.["cutoff"];
+            loop.set({
+              ...state.volume === void 0 ? {} : { volume: state.volume },
+              ...state.frequency === void 0 ? {} : { frequency: state.frequency },
+              ...position ? { position } : {},
+              ...cutoff === void 0 ? {} : { cutoff }
+            });
+          },
+          stop: () => loop.stop()
+        };
       },
       setListener(listener) {
         engine.setListener(listener);
@@ -2189,7 +4338,7 @@ var GameAudio = (() => {
       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" },
+    mixes: { game: "Game", art_scene: "Art scene", kit: "Kit (art scene + limiter)" },
     sheet: { title: "Sound plan", level: "level", distance: "distance", pan: "pan", length: "seconds", silent: "too far to be heard", layer: "layer", none: "no sound chosen" }
   };
   var PT_BR = {
@@ -2243,7 +4392,7 @@ var GameAudio = (() => {
       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" },
+    mixes: { game: "Jogo", art_scene: "Cena de Arte", kit: "Kit (Cena de Arte + limitador)" },
     sheet: { title: "Plano do som", level: "n\xEDvel", distance: "dist\xE2ncia", pan: "pan", length: "segundos", silent: "longe demais para ouvir", layer: "camada", none: "nenhum som escolhido" }
   };
   var audioBenchTextOf = (locale) => locale === "en" ? EN : PT_BR;
@@ -2317,7 +4466,7 @@ var GameAudio = (() => {
       distance: 10,
       bearing: 0,
       volume: 1,
-      mix: "art_scene",
+      mix: DEFAULT_MIX,
       seed: options.seed ?? 1,
       source: "bench",
       loop: NONE,