@adatechnology/game-audio 0.7.0 → 0.9.0

package/dist/index.global.js

@@ -4,6 +4,7 @@ var GameAudio = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,6 +18,7 @@ var GameAudio = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   // src/index.ts
   var index_exports = {};
@@ -64,13 +66,19 @@ var GameAudio = (() => {
     LIBRARY_BANK: () => LIBRARY_BANK,
     LIBRARY_LOOPS: () => LIBRARY_LOOPS,
     LIBRARY_SOUNDS: () => LIBRARY_SOUNDS,
+    LOCAL_PACK_BANK_ID: () => LOCAL_PACK_BANK_ID,
+    LOCAL_PACK_LICENSES: () => LOCAL_PACK_LICENSES,
+    LOCAL_PACK_PREFERENCES: () => LOCAL_PACK_PREFERENCES,
     LOOP_SMOOTHING: () => LOOP_SMOOTHING,
     LOOP_START_ABOVE: () => LOOP_START_ABOVE,
+    LocalSoundPackError: () => LocalSoundPackError,
     MIX_PROFILES: () => MIX_PROFILES,
     OPEN_CUTOFF: () => OPEN_CUTOFF,
     PAN_LIMIT: () => PAN_LIMIT,
     PAN_MIN_DISTANCE: () => PAN_MIN_DISTANCE,
     PICKUP_CLASSES: () => PICKUP_CLASSES,
+    RADIO_BANK: () => RADIO_BANK,
+    RADIO_TRACKS: () => RADIO_TRACKS,
     SAMPLE_ENVIRONMENTS: () => SAMPLE_ENVIRONMENTS,
     SDK_LICENSES: () => SDK_LICENSES,
     SFX_BLOWS: () => SFX_BLOWS,
@@ -80,9 +88,12 @@ var GameAudio = (() => {
     SFX_LAYERS: () => SFX_LAYERS,
     SFX_MATERIALS: () => SFX_MATERIALS,
     SFX_TIERS: () => SFX_TIERS,
+    TRIM_FADE: () => TRIM_FADE,
     USER_SAMPLES_BANK: () => USER_SAMPLES_BANK,
     USER_SOUND_PREFIX: () => USER_SOUND_PREFIX,
     VOICE_GROUPS: () => VOICE_GROUPS,
+    aliasSample: () => aliasSample,
+    applyLocalSoundPack: () => applyLocalSoundPack,
     audioBenchTextOf: () => audioBenchTextOf,
     balanceOf: () => balanceOf,
     bufferOf: () => bufferOf,
@@ -104,6 +115,7 @@ var GameAudio = (() => {
     crossGains: () => crossGains,
     cutoffDivisor: () => cutoffDivisor,
     dbOf: () => dbOf,
+    defaultIdleScheduler: () => defaultIdleScheduler,
     drawBetween: () => drawBetween,
     encodeWav: () => encodeWav,
     endDropDb: () => endDropDb,
@@ -117,6 +129,7 @@ var GameAudio = (() => {
     impactSoundId: () => impactSoundId,
     inlineLoader: () => inlineLoader,
     isCalibrationUrl: () => isCalibrationUrl,
+    isShippableLicense: () => isShippableLicense,
     isSilent: () => isSilent,
     kitSampleBank: () => kitSampleBank,
     kitSampleDefaults: () => kitSampleDefaults,
@@ -124,17 +137,22 @@ var GameAudio = (() => {
     listenerDistance: () => listenerDistance,
     loadKitSamples: () => loadKitSamples,
     loadUserSamples: () => loadUserSamples,
+    localPackSamples: () => localPackSamples,
     loopCrossfade: () => loopCrossfade,
+    loopRate: () => loopRate,
     measureCriteria: () => measureCriteria,
     noiseClassRecipe: () => noiseClassRecipe,
     onsetIndex: () => onsetIndex,
     panFor: () => panFor,
+    parseLocalSoundPack: () => parseLocalSoundPack,
     parseSfxName: () => parseSfxName,
     peakIndex: () => peakIndex,
     peakOf: () => peakOf,
     pickTake: () => pickTake,
     planSample: () => planSample,
     planSound: () => planSound,
+    pointSamples: () => pointSamples,
+    radioTrack: () => radioTrack,
     realize: () => realize,
     realizeSample: () => realizeSample,
     recordOutput: () => recordOutput,
@@ -269,6 +287,20 @@ var GameAudio = (() => {
       sources: [
         "sdk: the crackles of every fire share four voices"
       ]
+    },
+    debris_knock: {
+      maxConcurrent: 3,
+      cooldown: 0.04,
+      sources: [
+        "sdk: forty parts coming loose in one blast are a few knocks, not forty (room log: thunk x34 in under a second when a molotov broke)"
+      ]
+    },
+    sizzle: {
+      maxConcurrent: 1,
+      cooldown: 0.5,
+      sources: [
+        "sdk: every melting part of a burning bin is one sizzle at a time (room log: hiss x34 in 1.6 s on a plastic bin)"
+      ]
     }
   };
 
@@ -420,16 +452,16 @@ var GameAudio = (() => {
     }
     return pending;
   }
-  function drawLayer(layer, scope) {
+  function drawLayer(layer2, scope) {
     const pending = { at: 0, gain: 1, filters: [], modulators: [] };
-    for (const key of Object.keys(layer)) {
-      if (key === "at" && layer.at !== void 0) pending.at = draw(layer.at, scope);
-      else if (key === "duration" && layer.duration !== void 0) pending.duration = draw(layer.duration, scope);
-      else if (key === "gain" && layer.gain !== void 0) pending.gain = draw(layer.gain, scope);
-      else if (key === "source" && layer.source.kind === "osc") pending.automation = drawAutomation(layer.source.frequency, scope);
-      else if (key === "source" && layer.source.kind === "formant_voice") pending.voice = drawVoice(layer.source, scope);
-      else if (key === "filters" && layer.filters) pending.filters = layer.filters.bank.map((spec) => drawFilter(spec, scope));
-      else if (key === "modulators" && layer.modulators) pending.modulators = layer.modulators.map((modulator) => drawModulator(modulator, scope));
+    for (const key of Object.keys(layer2)) {
+      if (key === "at" && layer2.at !== void 0) pending.at = draw(layer2.at, scope);
+      else if (key === "duration" && layer2.duration !== void 0) pending.duration = draw(layer2.duration, scope);
+      else if (key === "gain" && layer2.gain !== void 0) pending.gain = draw(layer2.gain, scope);
+      else if (key === "source" && layer2.source.kind === "osc") pending.automation = drawAutomation(layer2.source.frequency, scope);
+      else if (key === "source" && layer2.source.kind === "formant_voice") pending.voice = drawVoice(layer2.source, scope);
+      else if (key === "filters" && layer2.filters) pending.filters = layer2.filters.bank.map((spec) => drawFilter(spec, scope));
+      else if (key === "modulators" && layer2.modulators) pending.modulators = layer2.modulators.map((modulator) => drawModulator(modulator, scope));
     }
     return pending;
   }
@@ -440,8 +472,8 @@ var GameAudio = (() => {
     if (source.offset === "fit") return scope.random() * Math.max(0, noiseSeconds - duration);
     return scope.random() * (source.offsetScale ?? 1);
   }
-  function finishSource(layer, pending, duration, offset) {
-    const source = layer.source;
+  function finishSource(layer2, pending, duration, offset) {
+    const source = layer2.source;
     if (source.kind === "noise") return { kind: "noise", offset, loop: source.loop === true };
     if (source.kind === "osc") return { kind: "osc", wave: source.wave, frequency: finishAutomation(pending.automation ?? {}, duration) };
     const voice2 = pending.voice;
@@ -463,23 +495,23 @@ var GameAudio = (() => {
   function finishEnvelope(envelope2, duration, level) {
     return envelope2.map(([time, value, curve, fixed2]) => ({ time: timeOf(time, duration), value: fixed2 === "fixed" ? value : value * level, curve }));
   }
-  function planLayer(layer, scope, defaults, levelInEnvelope, soundLevel) {
-    const pending = drawLayer(layer, scope);
+  function planLayer(layer2, scope, defaults, levelInEnvelope, soundLevel) {
+    const pending = drawLayer(layer2, scope);
     const duration = pending.duration ?? defaults.duration;
     if (duration === void 0) throw new Error("game-audio: a layer needs a duration (its own or the recipe\u2019s)");
-    const offset = drawOffset(layer.source, duration, scope, defaults.noiseSeconds);
+    const offset = drawOffset(layer2.source, duration, scope, defaults.noiseSeconds);
     const level = pending.gain * soundLevel;
-    const sourceFrequency = layer.source.kind === "noise" ? 0 : startFrequency(pending.automation ?? pending.voice?.frequency ?? {});
+    const sourceFrequency = layer2.source.kind === "noise" ? 0 : startFrequency(pending.automation ?? pending.voice?.frequency ?? {});
     const planned = {
       at: pending.at,
       duration,
-      tail: layer.tail ?? defaults.tail ?? DEFAULT_TAIL,
+      tail: layer2.tail ?? defaults.tail ?? DEFAULT_TAIL,
       level,
-      ...layer.wet === void 0 ? {} : { wet: layer.wet },
-      source: finishSource(layer, pending, duration, offset),
-      ...layer.filters ? {
+      ...layer2.wet === void 0 ? {} : { wet: layer2.wet },
+      source: finishSource(layer2, pending, duration, offset),
+      ...layer2.filters ? {
         filters: {
-          mode: layer.filters.mode,
+          mode: layer2.filters.mode,
           bank: pending.filters.map(({ spec, frequency, q, gain, level: filterLevel }) => ({
             type: spec.type,
             frequency: finishAutomation(frequency, duration),
@@ -490,10 +522,10 @@ var GameAudio = (() => {
         }
       } : {},
       modulators: pending.modulators.map((modulator) => finishModulator(modulator, sourceFrequency)),
-      envelope: finishEnvelope(layer.envelope, duration, levelInEnvelope ? level : 1)
+      envelope: finishEnvelope(layer2.envelope, duration, levelInEnvelope ? level : 1)
     };
-    if (!layer.repeat) return [planned];
-    return Array.from({ length: layer.repeat.count }, (_, index) => ({ ...planned, at: planned.at + index * (layer.repeat?.spacing ?? 0) }));
+    if (!layer2.repeat) return [planned];
+    return Array.from({ length: layer2.repeat.count }, (_, index) => ({ ...planned, at: planned.at + index * (layer2.repeat?.spacing ?? 0) }));
   }
   function scaleAutomation(automation, divisor) {
     const scale = (value) => value === void 0 ? void 0 : value / divisor;
@@ -501,12 +533,12 @@ var GameAudio = (() => {
     for (const key of ["value", "from", "to"]) if (automation[key] !== void 0) scaled[key] = scale(automation[key]);
     return scaled;
   }
-  function muffle(layer, divisor) {
-    if (divisor === 1 || !layer.filters) return layer;
-    const bank = layer.filters.bank.map((filter) => filter.type === "lowpass" ? { ...filter, frequency: scaleAutomation(filter.frequency, divisor) } : filter);
-    return { ...layer, filters: { ...layer.filters, bank } };
+  function muffle(layer2, divisor) {
+    if (divisor === 1 || !layer2.filters) return layer2;
+    const bank = layer2.filters.bank.map((filter) => filter.type === "lowpass" ? { ...filter, frequency: scaleAutomation(filter.frequency, divisor) } : filter);
+    return { ...layer2, filters: { ...layer2.filters, bank } };
   }
-  var layerEnd = (layer) => layer.at + layer.duration + layer.tail;
+  var layerEnd = (layer2) => layer2.at + layer2.duration + layer2.tail;
   function planSound(recipe2, input = {}) {
     const listener = input.listener ?? DEFAULT_LISTENER;
     const distance = input.distance ?? (input.position ? listenerDistance(listener, input.position, input.distanceMode) : 0);
@@ -534,7 +566,7 @@ var GameAudio = (() => {
       noiseSeconds: input.noiseSeconds ?? DEFAULT_NOISE_SECONDS
     };
     const divisor = cutoffDivisor(recipe2.falloff, distance) / (1 - OCCLUSION_CUTOFF * occlusion);
-    const layers = recipe2.layers.flatMap((layer) => planLayer(layer, scope, defaults, order !== "layered", level)).map((layer) => muffle(layer, divisor));
+    const layers = recipe2.layers.flatMap((layer2) => planLayer(layer2, scope, defaults, order !== "layered", level)).map((layer2) => muffle(layer2, divisor));
     return { ...base, silent: false, length: Math.max(0, ...layers.map(layerEnd)), layers };
   }
 
@@ -600,7 +632,16 @@ var GameAudio = (() => {
       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 });
+      layers.push({
+        role,
+        url: ref.url,
+        take: index,
+        gain: gain * (ref.gain ?? 1) * level,
+        rate,
+        at,
+        ...ref.offset === void 0 ? {} : { offset: ref.offset },
+        ...ref.duration === void 0 ? {} : { duration: ref.duration }
+      });
     };
     take("close", close, gains.close, 0);
     take("far", far, gains.far, 0);
@@ -747,12 +788,48 @@ var GameAudio = (() => {
     }
     return merged;
   }
+  var trimmed = (refs, alias) => refs.filter((ref) => alias.only === void 0 || ref.url.includes(alias.only)).map((ref) => ({
+    ...ref,
+    ...alias.offset === void 0 ? {} : { offset: alias.offset },
+    ...alias.duration === void 0 ? {} : { duration: alias.duration }
+  }));
+  function aliasSample(alias, file) {
+    const close = trimmed(file.close, alias);
+    if (close.length === 0) return void 0;
+    const { tiers: _tiers, fallback: _fallback, choke: _choke, ...rest } = file;
+    return {
+      ...rest,
+      id: alias.id,
+      close,
+      ...file.far ? { far: trimmed(file.far, alias) } : {},
+      ...alias.loop === void 0 ? {} : { loop: alias.loop },
+      ...alias.baseFrequency === void 0 ? {} : { baseFrequency: alias.baseFrequency },
+      ...alias.gain === void 0 ? {} : { gain: alias.gain },
+      ...alias.pitch === void 0 ? {} : { pitch: alias.pitch },
+      ...alias.falloff ? { falloff: alias.falloff } : {},
+      fallback: alias.id,
+      sources: [...file.sources, `alias: ${alias.id} \u2192 ${alias.file}`]
+    };
+  }
   function createSoundRegistry(banks = []) {
     const sounds = /* @__PURE__ */ new Map();
     const loops = /* @__PURE__ */ new Map();
     const sets = /* @__PURE__ */ new Map();
     const samples = /* @__PURE__ */ new Map();
     const owners = /* @__PURE__ */ new Map();
+    const aliases = /* @__PURE__ */ new Map();
+    const derived = /* @__PURE__ */ new Map();
+    const resolveAlias = (id) => {
+      const alias = aliases.get(id);
+      if (!alias) return void 0;
+      const cached = derived.get(id);
+      if (cached) return cached;
+      const file = samples.get(alias.file);
+      if (!file) return void 0;
+      const sample = aliasSample(alias, file);
+      if (sample) derived.set(id, sample);
+      return sample;
+    };
     const registry = {
       register(bank) {
         for (const sound of bank.sounds ?? []) {
@@ -772,6 +849,11 @@ var GameAudio = (() => {
           samples.set(sample.id, sample);
           owners.set(sample.id, bank.id);
         }
+        for (const alias of bank.sampleAliases ?? []) {
+          aliases.set(alias.id, alias);
+          if (!owners.has(alias.id)) owners.set(alias.id, bank.id);
+        }
+        derived.clear();
       },
       patch(id, patch) {
         const sound = sounds.get(id);
@@ -780,22 +862,31 @@ var GameAudio = (() => {
         if (loop) loops.set(id, mergeRecords(loop, patch));
         const sample = samples.get(id);
         if (sample) samples.set(id, mergeRecords(sample, patch));
+        derived.clear();
       },
       remove(id) {
         sounds.delete(id);
         loops.delete(id);
         sets.delete(id);
         samples.delete(id);
+        aliases.delete(id);
         owners.delete(id);
+        derived.clear();
+      },
+      removeSample(id) {
+        samples.delete(id);
+        aliases.delete(id);
+        if (!sounds.has(id) && !loops.has(id) && !sets.has(id)) owners.delete(id);
+        derived.clear();
       },
       sound: (id) => sounds.get(id),
       loop: (id) => loops.get(id),
       set: (id) => sets.get(id),
-      sample: (id) => samples.get(id),
+      sample: (id) => samples.get(id) ?? resolveAlias(id),
       soundIds: () => [...sounds.keys()],
       setIds: () => [...sets.keys()],
       loopIds: () => [...loops.keys()],
-      sampleIds: () => [...samples.keys()],
+      sampleIds: () => [...samples.keys(), ...[...aliases.keys()].filter((id) => !samples.has(id) && resolveAlias(id) !== void 0)],
       bankOf: (id) => owners.get(id)
     };
     for (const bank of banks) registry.register(bank);
@@ -1223,6 +1314,8 @@ var GameAudio = (() => {
   var DEFAULT_LOOP_CROSSFADE = 0.25;
   var LOOKAHEAD = 1.5;
   var VOLUME_SMOOTHING = 0.05;
+  var RATE_SMOOTHING = 0.04;
+  var RATE_RANGE = [0.25, 4];
   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);
@@ -1234,6 +1327,7 @@ var GameAudio = (() => {
     param.setValueAtTime(value(0), at);
     for (let step = 1; step <= CROSSFADE_STEPS; step++) param.linearRampToValueAtTime(value(step / CROSSFADE_STEPS), at + seconds * step / CROSSFADE_STEPS);
   };
+  var loopRate = (sound, frequency) => sound.baseFrequency && sound.baseFrequency > 0 && frequency > 0 ? Math.max(RATE_RANGE[0], Math.min(RATE_RANGE[1], frequency / sound.baseFrequency)) : 1;
   function createSampleLoopHandle(sound, host, volume = 0) {
     const crossfade = loopCrossfade(sound) ?? DEFAULT_LOOP_CROSSFADE;
     let level = volume;
@@ -1243,13 +1337,17 @@ var GameAudio = (() => {
     let segments = [];
     let last;
     let timer;
+    let panner;
+    let rate = 1;
+    let position;
     const entry = {
       get created() {
         return master !== void 0;
       },
       rewire() {
-        master?.disconnect();
-        master?.connect(host.output(sound.bus));
+        const out = panner ?? master;
+        out?.disconnect();
+        out?.connect(host.output(sound.bus));
       },
       stop() {
         stopped = true;
@@ -1266,23 +1364,29 @@ var GameAudio = (() => {
         segments = [];
         master?.disconnect();
         master = void 0;
+        panner?.disconnect();
+        panner = void 0;
         fallback?.stop();
         fallback = void 0;
         host.unregister(entry);
       }
     };
-    const nextBuffer = () => {
+    const nextTake = () => {
       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 buffer = ref ? host.buffer(ref.url) : void 0;
+      return ref && buffer ? { buffer, ref } : void 0;
     };
     const schedule = (context, output, at, first) => {
-      const buffer = nextBuffer();
-      if (!buffer) return void 0;
+      const next = nextTake();
+      if (!next) return void 0;
+      const { buffer, ref } = next;
+      const offset = Math.max(0, Math.min(ref.offset ?? 0, buffer.duration));
       const source = context.createBufferSource();
       source.buffer = buffer;
+      source.playbackRate.value = rate;
       const gain = context.createGain();
       source.connect(gain);
       gain.connect(output);
@@ -1290,15 +1394,15 @@ var GameAudio = (() => {
       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);
+        source.start(at, offset);
         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;
+      const end3 = at + (buffer.duration - offset) / rate;
       ramp2(gain.gain, "out", end3 - fade, fade);
-      source.start(at);
+      source.start(at, offset);
       source.stop(end3);
       segments.push({ source, gain, end: end3 });
       source.onended = () => {
@@ -1319,14 +1423,26 @@ var GameAudio = (() => {
         pump(context, output, next, false);
       }, wait);
     };
-    const fileLevel = () => level * (sound.gain ?? 1);
+    const spatial = () => {
+      if (!position || !host.listener) return 1;
+      return falloffGain(sound.falloff ?? DEFAULT_SAMPLE_FALLOFF, 1, listenerDistance(host.listener(), position, host.distance));
+    };
+    const fileLevel = () => level * (sound.gain ?? 1) * spatial();
+    const place = (context) => {
+      if (panner && position && host.listener) panner.pan.setTargetAtTime(panFor(host.listener(), position), context.currentTime, VOLUME_SMOOTHING);
+    };
     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));
+      if (sound.pan !== false && position && typeof context.createStereoPanner === "function") {
+        panner = context.createStereoPanner();
+        if (host.listener) panner.pan.value = panFor(host.listener(), position);
+        master.connect(panner);
+        panner.connect(host.output(sound.bus));
+      } else master.connect(host.output(sound.bus));
       host.register(entry);
       pump(context, master, context.currentTime, true);
       if (fallback) {
@@ -1352,9 +1468,15 @@ var GameAudio = (() => {
       set(next) {
         if (stopped) return;
         if (next.volume !== void 0) level = host.muted(sound.bus) ? 0 : Math.max(0, next.volume);
+        if (next.position) position = next.position;
+        if (next.frequency !== void 0 && sound.baseFrequency) rate = loopRate(sound, next.frequency);
         if (level > 0) ensure();
         const context = host.ready();
-        if (master && context) master.gain.setTargetAtTime(fileLevel(), context.currentTime, VOLUME_SMOOTHING);
+        if (master && context) {
+          master.gain.setTargetAtTime(fileLevel(), context.currentTime, VOLUME_SMOOTHING);
+          place(context);
+          if (next.frequency !== void 0 && sound.baseFrequency) for (const segment of segments) segment.source.playbackRate.setTargetAtTime(rate, context.currentTime, RATE_SMOOTHING);
+        }
         fallback?.set(next.volume === void 0 ? next : { ...next, volume: level });
       },
       stop: entry.stop
@@ -1516,9 +1638,9 @@ var GameAudio = (() => {
   }
 
   // src/webaudio/realize-game.ts
-  var end = (layer, start) => start + layer.duration + layer.tail;
-  var firstFilter = (layer) => layer.filters?.bank[0];
-  var offsetOf = (layer) => layer.source.kind === "noise" ? layer.source.offset : 0;
+  var end = (layer2, start) => start + layer2.duration + layer2.tail;
+  var firstFilter = (layer2) => layer2.filters?.bank[0];
+  var offsetOf = (layer2) => layer2.source.kind === "noise" ? layer2.source.offset : 0;
   function setFilter(node, filter, time) {
     if (!filter) return;
     node.type = filter.type;
@@ -1527,28 +1649,28 @@ var GameAudio = (() => {
   }
   function realizeBurst(plan, target) {
     const { context } = target;
-    const layer = plan.layers[0];
-    const time = target.time + layer.at;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
     const gain = context.createGain();
     gain.connect(target.output);
-    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
     const filter = context.createBiquadFilter();
     source.connect(filter);
     filter.connect(gain);
-    setFilter(filter, firstFilter(layer), time);
-    applyEnvelope(gain.gain, layer.envelope, time);
-    source.start(time, offsetOf(layer));
-    source.stop(end(layer, time));
+    setFilter(filter, firstFilter(layer2), time);
+    applyEnvelope(gain.gain, layer2.envelope, time);
+    source.start(time, offsetOf(layer2));
+    source.stop(end(layer2, time));
     return voiceOf([source]);
   }
   function realizeScream(plan, target) {
     const { context } = target;
-    const layer = plan.layers[0];
-    const time = target.time + layer.at;
-    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
     const gain = context.createGain();
     gain.connect(target.output);
-    for (const band of layer.filters?.bank ?? []) {
+    for (const band of layer2.filters?.bank ?? []) {
       const filter = context.createBiquadFilter();
       filter.type = band.type;
       if (band.q !== void 0) filter.Q.value = band.q;
@@ -1561,7 +1683,7 @@ var GameAudio = (() => {
       level.connect(gain);
     }
     const sources = [source];
-    const lfos = layer.modulators.map((modulator) => {
+    const lfos = layer2.modulators.map((modulator) => {
       const lfo = context.createOscillator();
       const depth = context.createGain();
       if (modulator.wave) lfo.type = modulator.wave;
@@ -1571,75 +1693,75 @@ var GameAudio = (() => {
       depth.connect(gain.gain);
       return lfo;
     });
-    applyEnvelope(gain.gain, layer.envelope, time);
-    source.start(time, offsetOf(layer));
-    source.stop(end(layer, time));
+    applyEnvelope(gain.gain, layer2.envelope, time);
+    source.start(time, offsetOf(layer2));
+    source.stop(end(layer2, time));
     for (const lfo of lfos) {
       lfo.start(time);
-      lfo.stop(end(layer, time));
+      lfo.stop(end(layer2, time));
       sources.push(lfo);
     }
     return voiceOf(sources);
   }
   function realizeGroan(plan, target) {
     const { context } = target;
-    const layer = plan.layers[0];
-    const time = target.time + layer.at;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
     const oscillator = context.createOscillator();
     const gain = context.createGain();
     const filter = context.createBiquadFilter();
-    const band = firstFilter(layer);
-    if (layer.source.kind === "osc") oscillator.type = layer.source.wave;
+    const band = firstFilter(layer2);
+    if (layer2.source.kind === "osc") oscillator.type = layer2.source.wave;
     if (band) {
       filter.type = band.type;
       if (band.q !== void 0) filter.Q.value = band.q;
     }
-    if (layer.source.kind === "osc") {
-      assign(oscillator.frequency, layer.source.frequency, time);
-      rampTo(oscillator.frequency, layer.source.frequency, time);
+    if (layer2.source.kind === "osc") {
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
     }
     if (band) assign(filter.frequency, band.frequency, time);
-    applyEnvelope(gain.gain, layer.envelope, time);
+    applyEnvelope(gain.gain, layer2.envelope, time);
     oscillator.connect(filter);
     filter.connect(gain);
     gain.connect(target.output);
     oscillator.start(time);
-    oscillator.stop(end(layer, time));
+    oscillator.stop(end(layer2, time));
     return voiceOf([oscillator]);
   }
   function realizeBoom(plan, target) {
     const { context } = target;
-    const layer = plan.layers[0];
-    const time = target.time + layer.at;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
     const oscillator = context.createOscillator();
     const gain = context.createGain();
-    if (layer.source.kind === "osc") {
-      oscillator.type = layer.source.wave;
-      assign(oscillator.frequency, layer.source.frequency, time);
-      rampTo(oscillator.frequency, layer.source.frequency, time);
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
     }
-    applyEnvelope(gain.gain, layer.envelope, time);
+    applyEnvelope(gain.gain, layer2.envelope, time);
     oscillator.connect(gain);
     gain.connect(target.output);
     oscillator.start(time);
-    oscillator.stop(end(layer, time));
+    oscillator.stop(end(layer2, time));
     return voiceOf([oscillator]);
   }
   function realizeStatic(plan, target) {
     const { context } = target;
-    const layer = plan.layers[0];
-    const time = target.time + layer.at;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
     const gain = context.createGain();
     const source = context.createBufferSource();
     const filter = context.createBiquadFilter();
     source.buffer = target.noise();
-    setFilter(filter, firstFilter(layer), time);
-    applyEnvelope(gain.gain, layer.envelope, time);
+    setFilter(filter, firstFilter(layer2), time);
+    applyEnvelope(gain.gain, layer2.envelope, time);
     source.connect(filter);
     filter.connect(gain);
     gain.connect(target.output);
-    source.start(time, offsetOf(layer));
-    source.stop(end(layer, time));
+    source.start(time, offsetOf(layer2));
+    source.stop(end(layer2, time));
     return voiceOf([source]);
   }
   function realizeChord(plan, target) {
@@ -1651,14 +1773,14 @@ var GameAudio = (() => {
       const source = layers[index].source;
       if (source.kind === "osc") oscillators[index].type = source.wave;
     }
-    layers.forEach((layer, index) => {
-      if (layer.source.kind === "osc") assign(oscillators[index].frequency, layer.source.frequency, target.time + layer.at);
+    layers.forEach((layer2, index) => {
+      if (layer2.source.kind === "osc") assign(oscillators[index].frequency, layer2.source.frequency, target.time + layer2.at);
     });
     applyEnvelope(gain.gain, layers[0].envelope, target.time + layers[0].at);
     for (const oscillator of oscillators) oscillator.connect(gain);
     gain.connect(target.output);
-    layers.forEach((layer, index) => oscillators[index].start(target.time + layer.at));
-    layers.forEach((layer, index) => oscillators[index].stop(end(layer, target.time + layer.at)));
+    layers.forEach((layer2, index) => oscillators[index].start(target.time + layer2.at));
+    layers.forEach((layer2, index) => oscillators[index].stop(end(layer2, target.time + layer2.at)));
     return voiceOf(oscillators);
   }
   function realizeCalls(plan, target) {
@@ -1670,34 +1792,34 @@ var GameAudio = (() => {
     if (band) filter.type = band.type;
     filter.connect(gain);
     gain.connect(target.output);
-    const oscillators = plan.layers.map((layer) => {
-      const time = target.time + layer.at;
+    const oscillators = plan.layers.map((layer2) => {
+      const time = target.time + layer2.at;
       const oscillator = context.createOscillator();
-      if (layer.source.kind === "osc") {
-        oscillator.type = layer.source.wave;
-        assign(oscillator.frequency, layer.source.frequency, time);
-        rampTo(oscillator.frequency, layer.source.frequency, time);
+      if (layer2.source.kind === "osc") {
+        oscillator.type = layer2.source.wave;
+        assign(oscillator.frequency, layer2.source.frequency, time);
+        rampTo(oscillator.frequency, layer2.source.frequency, time);
       }
       if (band) {
         assign(filter.frequency, band.frequency, time);
         if (band.q !== void 0) filter.Q.value = band.q;
       }
       const envelope2 = context.createGain();
-      applyEnvelope(envelope2.gain, layer.envelope, time);
+      applyEnvelope(envelope2.gain, layer2.envelope, time);
       oscillator.connect(envelope2);
       envelope2.connect(filter);
       oscillator.start(time);
-      oscillator.stop(end(layer, time));
+      oscillator.stop(end(layer2, time));
       return oscillator;
     });
     return voiceOf(oscillators);
   }
 
   // src/webaudio/realize-layered.ts
-  var end2 = (layer, start) => start + layer.duration + layer.tail;
-  function outputStage2(plan, layer, target) {
+  var end2 = (layer2, start) => start + layer2.duration + layer2.tail;
+  function outputStage2(plan, layer2, target) {
     const { context } = target;
-    const level = gainNode(context, layer.level);
+    const level = gainNode(context, layer2.level);
     let node = level;
     if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
       const panner = context.createStereoPanner();
@@ -1706,54 +1828,54 @@ var GameAudio = (() => {
       node = panner;
     }
     node.connect(target.output);
-    if (layer.wet && target.wet) {
-      const send = gainNode(context, layer.wet);
+    if (layer2.wet && target.wet) {
+      const send = gainNode(context, layer2.wet);
       node.connect(send);
       send.connect(target.wet);
     }
     return level;
   }
-  function realizeNoiseLayer(plan, layer, target) {
+  function realizeNoiseLayer(plan, layer2, target) {
     const { context } = target;
-    const time = target.time + layer.at;
-    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
-    const filters = (layer.filters?.bank ?? []).map((filter) => {
+    const time = target.time + layer2.at;
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const filters = (layer2.filters?.bank ?? []).map((filter) => {
       const node = filterNode(context, filter, time);
       rampTo(node.frequency, filter.frequency, time);
       return node;
     });
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer.envelope, time);
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
     let tail = source;
     for (const filter of filters) tail = tail.connect(filter);
     tail.connect(envelope2);
-    envelope2.connect(outputStage2(plan, layer, target));
-    source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
-    source.stop(end2(layer, time));
+    envelope2.connect(outputStage2(plan, layer2, target));
+    source.start(time, layer2.source.kind === "noise" ? layer2.source.offset : 0);
+    source.stop(end2(layer2, time));
     return [source];
   }
-  function realizeToneLayer(plan, layer, target) {
+  function realizeToneLayer(plan, layer2, target) {
     const { context } = target;
-    const time = target.time + layer.at;
+    const time = target.time + layer2.at;
     const oscillator = context.createOscillator();
-    if (layer.source.kind === "osc") {
-      oscillator.type = layer.source.wave;
-      assign(oscillator.frequency, layer.source.frequency, time);
-      rampTo(oscillator.frequency, layer.source.frequency, time);
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
     }
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer.envelope, time);
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
     oscillator.connect(envelope2);
-    envelope2.connect(outputStage2(plan, layer, target));
+    envelope2.connect(outputStage2(plan, layer2, target));
     oscillator.start(time);
-    oscillator.stop(end2(layer, time));
+    oscillator.stop(end2(layer2, time));
     return [oscillator];
   }
-  function realizeVoiceLayer(plan, layer, target) {
-    const source = layer.source;
+  function realizeVoiceLayer(plan, layer2, target) {
+    const source = layer2.source;
     if (source.kind !== "formant_voice") return [];
     const { context } = target;
-    const time = target.time + layer.at;
+    const time = target.time + layer2.at;
     const oscillator = context.createOscillator();
     oscillator.type = source.wave;
     assign(oscillator.frequency, source.frequency, time);
@@ -1774,10 +1896,10 @@ var GameAudio = (() => {
     for (const formant of formants) formant.connect(mix);
     breathLevel.connect(mix);
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer.envelope, time);
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
     mix.connect(envelope2);
-    envelope2.connect(outputStage2(plan, layer, target));
-    const stop = end2(layer, time);
+    envelope2.connect(outputStage2(plan, layer2, target));
+    const stop = end2(layer2, time);
     oscillator.start(time);
     vibrato.start(time);
     breath.start(time, source.breath.offset);
@@ -1787,24 +1909,24 @@ var GameAudio = (() => {
     return [oscillator, vibrato, breath];
   }
   function realizeLayered(plan, target) {
-    const sources = plan.layers.flatMap((layer) => {
-      if (layer.source.kind === "noise") return realizeNoiseLayer(plan, layer, target);
-      if (layer.source.kind === "osc") return realizeToneLayer(plan, layer, target);
-      return realizeVoiceLayer(plan, layer, target);
+    const sources = plan.layers.flatMap((layer2) => {
+      if (layer2.source.kind === "noise") return realizeNoiseLayer(plan, layer2, target);
+      if (layer2.source.kind === "osc") return realizeToneLayer(plan, layer2, target);
+      return realizeVoiceLayer(plan, layer2, target);
     });
     return voiceOf(sources);
   }
   function realizeSiren(plan, target) {
     const { context } = target;
-    const layer = plan.layers[0];
-    const time = target.time + layer.at;
+    const layer2 = plan.layers[0];
+    const time = target.time + layer2.at;
     const oscillator = context.createOscillator();
-    if (layer.source.kind === "osc") {
-      oscillator.type = layer.source.wave;
-      assign(oscillator.frequency, layer.source.frequency, time);
-      rampTo(oscillator.frequency, layer.source.frequency, time);
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
     }
-    const depths = layer.modulators.map((modulator) => {
+    const depths = layer2.modulators.map((modulator) => {
       const lfo = context.createOscillator();
       if (modulator.wave) lfo.type = modulator.wave;
       lfo.frequency.value = modulator.rate;
@@ -1815,19 +1937,19 @@ var GameAudio = (() => {
     });
     const lfos = depths.map(({ lfo }) => lfo);
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer.envelope, time);
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
     for (const { depth, target: modulated } of depths) if (modulated === "gain") depth.connect(envelope2.gain);
-    const filters = (layer.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    const filters = (layer2.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
     let tail = oscillator;
     for (const filter of filters) tail = tail.connect(filter);
     tail.connect(envelope2);
     envelope2.connect(target.output);
-    if (layer.wet && target.wet) {
-      const send = gainNode(context, layer.wet);
+    if (layer2.wet && target.wet) {
+      const send = gainNode(context, layer2.wet);
       envelope2.connect(send);
       send.connect(target.wet);
     }
-    const stop = end2(layer, time);
+    const stop = end2(layer2, time);
     oscillator.start(time);
     for (const lfo of lfos) lfo.start(time);
     oscillator.stop(stop);
@@ -1836,38 +1958,38 @@ var GameAudio = (() => {
   }
 
   // src/webaudio/realize-weapon.ts
-  function noiseLayer(layer, target, time) {
+  function noiseLayer(layer2, target, time) {
     const { context } = target;
-    const source = noiseSource(target, layer.source.kind === "noise" && layer.source.loop);
-    const filters = (layer.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const filters = (layer2.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer.envelope, time);
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
     let tail = source;
     for (const filter of filters) tail = tail.connect(filter);
     tail.connect(envelope2).connect(target.output);
-    source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
-    source.stop(time + layer.duration + layer.tail);
+    source.start(time, layer2.source.kind === "noise" ? layer2.source.offset : 0);
+    source.stop(time + layer2.duration + layer2.tail);
     return source;
   }
-  function toneLayer(layer, target, time) {
+  function toneLayer(layer2, target, time) {
     const { context } = target;
     const oscillator = context.createOscillator();
-    if (layer.source.kind === "osc") {
-      oscillator.type = layer.source.wave;
-      assign(oscillator.frequency, layer.source.frequency, time);
-      rampTo(oscillator.frequency, layer.source.frequency, time);
+    if (layer2.source.kind === "osc") {
+      oscillator.type = layer2.source.wave;
+      assign(oscillator.frequency, layer2.source.frequency, time);
+      rampTo(oscillator.frequency, layer2.source.frequency, time);
     }
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer.envelope, time);
+    applyEnvelope(envelope2.gain, layer2.envelope, time);
     oscillator.connect(envelope2).connect(target.output);
     oscillator.start(time);
-    oscillator.stop(time + layer.duration + layer.tail);
+    oscillator.stop(time + layer2.duration + layer2.tail);
     return oscillator;
   }
   function realizeWeapon(plan, target) {
-    const sources = plan.layers.map((layer) => {
-      const time = target.time + layer.at;
-      return layer.source.kind === "noise" ? noiseLayer(layer, target, time) : toneLayer(layer, target, time);
+    const sources = plan.layers.map((layer2) => {
+      const time = target.time + layer2.at;
+      return layer2.source.kind === "noise" ? noiseLayer(layer2, target, time) : toneLayer(layer2, target, time);
     });
     return voiceOf(sources);
   }
@@ -1919,19 +2041,19 @@ var GameAudio = (() => {
     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 }))
+  var tuneLayer = (layer2, rate) => ({
+    ...layer2,
+    at: layer2.at / rate,
+    duration: layer2.duration / rate,
+    tail: layer2.tail / rate,
+    source: tuneSource(layer2.source, rate),
+    ...layer2.filters ? { filters: { ...layer2.filters, bank: layer2.filters.bank.map((filter) => tuneFilter(filter, rate)) } } : {},
+    modulators: layer2.modulators.map((modulator) => tuneModulator(modulator, rate)),
+    envelope: layer2.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)) };
+    return { ...plan, length: plan.length / rate, layers: plan.layers.map((layer2) => tuneLayer(layer2, rate)) };
   }
   function createSetPicker() {
     const last = /* @__PURE__ */ new Map();
@@ -2034,6 +2156,7 @@ var GameAudio = (() => {
   }
 
   // src/webaudio/realize-sample.ts
+  var TRIM_FADE = 0.04;
   function realizeSample(plan, target) {
     const context = target.context;
     let head = target.output;
@@ -2055,16 +2178,26 @@ var GameAudio = (() => {
     voice2.connect(head);
     head = voice2;
     const sources = [];
-    for (const layer of plan.layers) {
-      const buffer = target.buffer(layer.url);
+    for (const layer2 of plan.layers) {
+      const buffer = target.buffer(layer2.url);
       if (!buffer) continue;
       const source = context.createBufferSource();
       source.buffer = buffer;
-      source.playbackRate.value = layer.rate;
-      const gain = gainNode(context, layer.gain);
+      source.playbackRate.value = layer2.rate;
+      const gain = gainNode(context, layer2.gain);
       source.connect(gain);
       gain.connect(head);
-      source.start(target.time + layer.at);
+      const at = target.time + layer2.at;
+      const offset = Math.max(0, Math.min(layer2.offset ?? 0, buffer.duration));
+      if (layer2.duration === void 0) source.start(at, offset);
+      else {
+        const duration = Math.max(0, Math.min(layer2.duration, buffer.duration - offset));
+        const end3 = at + duration / layer2.rate;
+        const fade = Math.min(TRIM_FADE, (end3 - at) / 4);
+        gain.gain.setValueAtTime(layer2.gain, end3 - fade);
+        gain.gain.linearRampToValueAtTime(0, end3);
+        source.start(at, offset, duration);
+      }
       sources.push(source);
     }
     const realized = voiceOf(sources);
@@ -2084,7 +2217,11 @@ var GameAudio = (() => {
   }
   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);
+    for (const layer2 of plan.layers) {
+      const file = seconds(layer2.url) ?? 0;
+      const played = layer2.duration === void 0 ? file - (layer2.offset ?? 0) : Math.min(layer2.duration, file - (layer2.offset ?? 0));
+      length = Math.max(length, layer2.at + Math.max(0, played) / layer2.rate);
+    }
     return length;
   }
 
@@ -2100,8 +2237,8 @@ var GameAudio = (() => {
     }
     return curve;
   }
-  var usesNoise = (recipe2) => recipe2.layers.some((layer) => layer.source.kind !== "osc");
-  var planUsesNoise = (plan) => plan.layers.some((layer) => layer.source.kind !== "osc");
+  var usesNoise = (recipe2) => recipe2.layers.some((layer2) => layer2.source.kind !== "osc");
+  var planUsesNoise = (plan) => plan.layers.some((layer2) => layer2.source.kind !== "osc");
   function createAudioEngine(options = {}) {
     const seed = options.seed ?? 1;
     const registry = createSoundRegistry(options.banks);
@@ -2293,6 +2430,7 @@ var GameAudio = (() => {
       const set = registry.set(id);
       return set ? chooser.pick(set, random) : { id, rate: 1 };
     };
+    const wanted = /* @__PURE__ */ new Set();
     const loadSounds = (sounds) => {
       const audio = ready();
       if (!audio) return Promise.resolve({ loaded: [], failed: sounds.flatMap(sampleUrls).map((url2) => ({ url: url2, error: "no audio context" })) });
@@ -2340,7 +2478,7 @@ var GameAudio = (() => {
         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 })),
+        layers: plan.layers.map((layer2) => ({ role: layer2.role, url: layer2.url, take: layer2.take, rate: layer2.rate })),
         ...plan.tier ? { tier: plan.tier } : {}
       });
       voices.setLength(voiceId, sampleLength(plan, (url2) => sampleStore.seconds(url2)) + (playOptions.delay ?? 0));
@@ -2417,13 +2555,20 @@ var GameAudio = (() => {
     };
     return {
       registry,
-      register: (bank) => registry.register(bank),
+      register: (bank) => {
+        registry.register(bank);
+        if (wanted.size === 0) return;
+        const now = [...wanted].map((id) => registry.sample(id)).filter((sample) => sample !== void 0);
+        for (const sample of now) wanted.delete(sample.id);
+        if (now.length > 0) void loadSounds(now).catch(() => void 0);
+      },
       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) {
+        for (const id of ids ?? []) if (!registry.sample(id)) wanted.add(id);
         const chosen = (ids ?? registry.sampleIds()).map((id) => registry.sample(id)).filter((sample) => sample !== void 0);
         return loadSounds(chosen);
       },
@@ -2473,7 +2618,9 @@ var GameAudio = (() => {
             random: engineRandom,
             register: loopHost.register,
             unregister: loopHost.unregister,
-            muted: (bus) => busSettings.get(bus)?.muted === true
+            muted: (bus) => busSettings.get(bus)?.muted === true,
+            listener: () => listener,
+            ...options.distance ? { distance: options.distance } : {}
           },
           loopOptions.volume
         );
@@ -2787,12 +2934,12 @@ var GameAudio = (() => {
       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 switched = (far?.farMix ?? 0) === 1 && (far?.layers.some((layer2) => layer2.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"}`,
+      value: `${levels.map((level) => db(level)).join(" \u203A ")}; ${brightness.map((hz2) => `${Math.round(hz2)} 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 }
     };
@@ -2827,11 +2974,11 @@ var GameAudio = (() => {
       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 close = result.events.map((event) => event.layers?.find((layer2) => layer2.role === "close"));
+    const takes2 = close.map((layer2) => layer2?.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 rates = close.map((layer2) => layer2?.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;
@@ -2869,7 +3016,7 @@ var GameAudio = (() => {
       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 ?? "" };
+      return { tier: event?.tier ?? "", rms: onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3), files: event?.layers?.find((layer2) => layer2.role === "close")?.url ?? "" };
     };
     const light = await at(0.1);
     const heavy = await at(0.9);
@@ -3212,9 +3359,9 @@ var GameAudio = (() => {
   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 layer2 = match?.[2] ?? "close";
     const take = match?.[3] ? Number(match[3]) : 1;
-    return { id, layer, take };
+    return { id, layer: layer2, take };
   }
   function splitTier(id) {
     const match = /^(.*)_(light|medium|heavy)$/.exec(id);
@@ -3290,7 +3437,16 @@ var GameAudio = (() => {
     // 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"
+    grab_soft: "item_pickup_leather",
+    // the hand foley of the test room (game-audio FOLEY_BANK) whose id is not a file id: a wooden leaf shut and slammed, an item picked up by material.
+    // The metal door stays on its recipe (two of its takes run 10 s), and so do the fridge, the microwave and paper (no file for them).
+    door_wood_close: "door_wood_shut",
+    door_wood_slam: "door_slam_wood",
+    item_pickup_metal: "item_pickup_generic",
+    item_pickup_plastic: "item_pickup_generic",
+    item_pickup_glass: "item_pickup_generic",
+    item_pickup_wood: "item_pickup_generic",
+    item_pickup_fabric: "item_pickup_leather"
   };
   function kitSampleDefaults(sound) {
     const bus = VOICE_IDS.test(sound.id) ? "voices" : KIT_CATEGORY_BUS[sound.category];
@@ -3340,6 +3496,20 @@ var GameAudio = (() => {
     if (options.preload && engine.loadSamples) void engine.loadSamples(options.preload).catch(() => void 0);
     return bank;
   }
+  function pointSamples(engine, files, options = {}) {
+    const baseUrl = options.baseUrl ?? "";
+    const samples = Object.entries(files).map(([id, urls]) => {
+      const close = (typeof urls === "string" ? [urls] : [...urls]).map((url2) => ({ url: `${baseUrl}${url2}` }));
+      if (close.length === 0) throw new Error(`pointSamples: ${id} has no file`);
+      const kit = engine.registry.sample(id);
+      if (!kit) return { id, bus: options.bus ?? "world", close, sources: ["game: pointSamples"] };
+      const { far: _far, tiers: _tiers, tail: _tail, ...numbers } = kit;
+      return { ...numbers, close };
+    });
+    const bank = { id: options.id ?? "game_samples", samples };
+    engine.register(bank);
+    return bank;
+  }
 
   // src/user-samples.ts
   var USER_SAMPLES_BANK = "user_samples";
@@ -3394,6 +3564,145 @@ var GameAudio = (() => {
     return result;
   }
 
+  // src/local-pack.ts
+  var LOCAL_PACK_LICENSES = ["CC0", "CC-BY", "unknown", "proprietary"];
+  var LOCAL_PACK_PREFERENCES = ["pack", "sdk"];
+  var LocalSoundPackError = class extends Error {
+    constructor(problems) {
+      super(`invalid local sound pack: ${problems.join("; ")}`);
+      __publicField(this, "problems");
+      this.name = "LocalSoundPackError";
+      this.problems = problems;
+    }
+  };
+  var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  var isLicense = (value) => LOCAL_PACK_LICENSES.includes(value);
+  var isBus = (value) => BUS_IDS.includes(value);
+  function entryProblems(id, entry) {
+    if (!isRecord(entry)) return [`${id}: not an object`];
+    const problems = [];
+    const files = entry.files;
+    if (!Array.isArray(files) || files.length === 0 || !files.every((file) => typeof file === "string" && file.length > 0)) problems.push(`${id}: files must be a non-empty list of paths`);
+    if (!isLicense(entry.license)) problems.push(`${id}: license must be one of ${LOCAL_PACK_LICENSES.join(", ")}`);
+    if (entry.prefer !== void 0 && !LOCAL_PACK_PREFERENCES.includes(entry.prefer)) problems.push(`${id}: prefer must be pack or sdk`);
+    if (entry.bus !== void 0 && !isBus(entry.bus)) problems.push(`${id}: unknown bus ${String(entry.bus)}`);
+    if (entry.gain !== void 0 && (typeof entry.gain !== "number" || entry.gain < 0)) problems.push(`${id}: gain must be a number \u2265 0`);
+    if (entry.score !== void 0 && (typeof entry.score !== "number" || entry.score < 0 || entry.score > 10)) problems.push(`${id}: score must be 0\u201310`);
+    return problems;
+  }
+  function parseLocalSoundPack(value) {
+    if (!isRecord(value)) throw new LocalSoundPackError(["the pack is not an object"]);
+    const problems = [];
+    if (value.version !== 1) problems.push("version must be 1");
+    if (value.baseUrl !== void 0 && typeof value.baseUrl !== "string") problems.push("baseUrl must be a string");
+    if (!isRecord(value.sounds)) problems.push("sounds must be an object of id \u2192 entry");
+    else for (const [id, entry] of Object.entries(value.sounds)) problems.push(...entryProblems(id, entry));
+    if (problems.length > 0) throw new LocalSoundPackError(problems);
+    return value;
+  }
+  var isShippableLicense = (license) => SDK_LICENSES.includes(license);
+  var CATALOG = new Map([...SFX_CATALOG, ...SFX_IMPACTS].map((entry) => [entry.id, entry]));
+  var busOf = (id, entry) => {
+    if (entry.bus) return entry.bus;
+    const category = CATALOG.get(id)?.category ?? "";
+    return kitSampleDefaults({ id, category })?.bus ?? "world";
+  };
+  function localPackSamples(pack, options = {}) {
+    const baseUrl = options.baseUrl ?? pack.baseUrl ?? "";
+    return Object.entries(pack.sounds).map(([id, entry]) => {
+      const current = CATALOG.get(id)?.current;
+      const isLoop = /_loop(_|$)/.test(id);
+      return {
+        id,
+        bus: busOf(id, entry),
+        close: entry.files.map((file) => ({ url: `${baseUrl}${file}` })),
+        pitch: isLoop ? 0 : 0.04,
+        ...isLoop ? { loop: true } : {},
+        ...entry.gain === void 0 ? {} : { gain: entry.gain },
+        ...current ? { fallback: current } : {},
+        license: entry.license,
+        sources: entry.files.map((file) => `local: ${file} ${entry.license}`)
+      };
+    });
+  }
+
+  // src/local-pack-loader.ts
+  var LOCAL_PACK_BANK_ID = "local_sound_pack";
+  var STAGING_PREFIX = "local_pack_staging:";
+  var defaultIdleScheduler = (task) => {
+    const idle = globalThis;
+    if (idle.requestIdleCallback && idle.cancelIdleCallback) {
+      const handle2 = idle.requestIdleCallback(task);
+      const cancel = idle.cancelIdleCallback;
+      return () => cancel(handle2);
+    }
+    const handle = setTimeout(task, 0);
+    return () => clearTimeout(handle);
+  };
+  function applyLocalSoundPack(engine, pack, options = {}) {
+    const schedule = options.schedule ?? defaultIdleScheduler;
+    const samples = localPackSamples(pack, options);
+    const statuses = new Map(samples.map((sample) => [sample.id, "pending"]));
+    const priors = /* @__PURE__ */ new Map();
+    const report = { file: [], sdk: [], fallback: [] };
+    const queue = [...samples];
+    let cancel;
+    let disposed = false;
+    let finish = () => void 0;
+    const done = new Promise((resolve) => {
+      finish = resolve;
+    });
+    const swapIn = (sample) => {
+      const prior = engine.registry.sample(sample.id);
+      const bank = engine.registry.bankOf(sample.id);
+      priors.set(sample.id, { ...prior ? { sample: prior } : {}, ...bank ? { bank } : {} });
+      engine.register({ id: LOCAL_PACK_BANK_ID, samples: [{ ...sample, ...prior?.fallback ? { fallback: prior.fallback } : {} }] });
+      statuses.set(sample.id, "file");
+      report.file.push(sample.id);
+    };
+    const loadOne = async (sample) => {
+      if (pack.sounds[sample.id]?.prefer === "sdk" && engine.registry.sample(sample.id)) {
+        statuses.set(sample.id, "sdk");
+        report.sdk.push(sample.id);
+        return;
+      }
+      const staging = `${STAGING_PREFIX}${sample.id}`;
+      engine.register({ id: LOCAL_PACK_BANK_ID, samples: [{ ...sample, id: staging }] });
+      const loaded = await engine.loadSamples([staging]);
+      engine.registry.removeSample(staging);
+      if (disposed) return;
+      if (loaded.failed.length === 0) return swapIn(sample);
+      statuses.set(sample.id, "fallback");
+      report.fallback.push({ id: sample.id, error: loaded.failed.map((entry) => `${entry.url}: ${entry.error}`).join("; ") });
+    };
+    const next = () => {
+      const sample = queue.shift();
+      if (!sample || disposed) {
+        if (!disposed) finish(report);
+        return;
+      }
+      void loadOne(sample).finally(() => {
+        if (!disposed) cancel = schedule(next);
+      });
+    };
+    cancel = schedule(next);
+    return {
+      done,
+      status: (id) => statuses.get(id),
+      unlicensed: () => samples.filter((sample) => statuses.get(sample.id) === "file" && !isShippableLicense(sample.license)).map((sample) => sample.id),
+      dispose() {
+        disposed = true;
+        cancel?.();
+        for (const [id, prior] of priors) {
+          if (prior.sample) engine.register({ id: prior.bank ?? LOCAL_PACK_BANK_ID, samples: [prior.sample] });
+          else engine.registry.removeSample(id);
+        }
+        priors.clear();
+        finish(report);
+      }
+    };
+  }
+
   // src/data/game-sfx.json
   var game_sfx_default = {
     sources: ["jogo:L62089-62107"],
@@ -3693,10 +4002,140 @@ var GameAudio = (() => {
       duration: 0.5,
       layers: [{ source: { kind: "osc", wave: "sine", frequency: { set: 880 } }, repeat: { count: 3, spacing: 0.7 }, envelope: [[0, 0.06, "set"], [0.5, 1e-4, "exp", "fixed"]] }],
       falloff: { model: "none" }
+    },
+    {
+      // the parking sensor: a short high beep, repeated by the cabin faster as the obstacle comes close
+      id: "parking_beep",
+      bus: "world",
+      duration: 0.09,
+      layers: [{ source: { kind: "osc", wave: "sine", frequency: { set: 2300 } }, envelope: [[0, 0.07, "set"], [0.08, 1e-4, "exp", "fixed"]] }],
+      falloff: { model: "none" }
+    },
+    {
+      // an emergency siren's wail: a tone rising and falling slowly (one sweep about every 3 s), played again by the cabin as it ends
+      id: "siren_wail",
+      bus: "world",
+      order: "siren",
+      duration: 3,
+      tail: 0.05,
+      layers: [
+        {
+          source: { kind: "osc", wave: "sawtooth", frequency: { set: 1050 } },
+          modulators: [{ target: "frequency", wave: "sine", rate: 0.33, depth: 420 }],
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 2400 } }] },
+          envelope: [[0, 1e-4, "set", "fixed"], [0.08, 0.07, "linear"], [2.95, 0.07, "set"], [3, 1e-4, "exp", "fixed"]]
+        }
+      ],
+      falloff: { model: "none" }
+    },
+    {
+      // the yelp: the same tone swept fast, for a junction
+      id: "siren_yelp",
+      bus: "world",
+      order: "siren",
+      duration: 2,
+      tail: 0.05,
+      layers: [
+        {
+          source: { kind: "osc", wave: "sawtooth", frequency: { set: 1100 } },
+          modulators: [{ target: "frequency", wave: "triangle", rate: 4, depth: 380 }],
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 2600 } }] },
+          envelope: [[0, 1e-4, "set", "fixed"], [0.05, 0.07, "linear"], [1.95, 0.07, "set"], [2, 1e-4, "exp", "fixed"]]
+        }
+      ],
+      falloff: { model: "none" }
+    },
+    {
+      // the wires under the column touching: a crackle of bright noise
+      id: "hotwire_spark",
+      bus: "world",
+      duration: 0.12,
+      layers: [
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3200 } }] },
+          modulators: [{ target: "gain", wave: "square", rate: 60, depth: 0.1, base: 0.12 }],
+          envelope: [[0, 0.2, "set"], [0.12, 1e-4, "exp", "fixed"]]
+        }
+      ],
+      falloff: { model: "none" }
+    },
+    {
+      // the glovebox latch: a small plastic click and the lid dropping
+      id: "glovebox_latch",
+      bus: "world",
+      duration: 0.14,
+      layers: [
+        { source: { kind: "noise", offset: "random" }, filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: 1800 }, q: 2 }] }, envelope: [[0, 0.16, "set"], [0.03, 1e-4, "exp", "fixed"]] },
+        { source: { kind: "osc", wave: "triangle", frequency: { set: 240 } }, envelope: [[0, 1e-4, "set", "fixed"], [0.06, 0.08, "linear"], [0.14, 1e-4, "exp", "fixed"]] }
+      ],
+      falloff: { model: "none" }
     }
   ];
   var CABIN_BANK = { id: "vehicle_cabin", sounds: CABIN_SOUNDS, loops: [] };
 
+  // src/library/radio.ts
+  var hz = (midi) => 440 * 2 ** ((midi - 69) / 12);
+  var layer = (note, beat, wave, level) => {
+    const [at, midi, beats] = note;
+    const length = beats * beat;
+    return {
+      at: at * beat,
+      duration: length,
+      source: { kind: "osc", wave, frequency: { set: hz(midi) } },
+      envelope: [[0, 1e-4, "set"], [0.01, level, "linear"], [Math.max(0.02, length * 0.9), level * 0.35, "linear"], [length, 1e-4, "exp", "fixed"]]
+    };
+  };
+  function radioTrack(spec) {
+    const beat = 60 / spec.bpm;
+    const recipes = Array.from({ length: spec.bars }, (_, bar) => {
+      const inBar = (notes) => notes.filter((n) => n[0] >= bar * 4 && n[0] < bar * 4 + 4).map((n) => [n[0] - bar * 4, n[1], n[2]]);
+      const layers = [
+        ...inBar(spec.bass).map((n) => layer(n, beat, "triangle", 0.16)),
+        ...inBar(spec.chords).map((n) => layer(n, beat, "sine", 0.05)),
+        ...inBar(spec.melody).map((n) => layer(n, beat, spec.wave, 0.07))
+      ];
+      return { id: `${spec.id}_${bar}`, bus: "world", duration: 4 * beat, layers, falloff: { model: "none" } };
+    });
+    return { song: { id: spec.id, barSeconds: 4 * beat, bars: recipes.map((r) => r.id) }, recipes };
+  }
+  var chord = (bar, root, minor = false) => [[bar * 4, root, 4], [bar * 4, root + (minor ? 3 : 4), 4], [bar * 4, root + 7, 4]];
+  var bassLine = (roots, pattern) => roots.flatMap((root, bar) => pattern.map((b) => [bar * 4 + b, root - 12, 0.9]));
+  var TRACKS = [
+    // a bright pop loop: I–V–vi–IV in C
+    radioTrack({
+      id: "radio_track_pop",
+      bpm: 112,
+      bars: 4,
+      wave: "square",
+      bass: bassLine([48, 55, 57, 53], [0, 1.5, 2, 3]),
+      chords: [...chord(0, 60), ...chord(1, 55), ...chord(2, 57, true), ...chord(3, 53)],
+      melody: [[0, 76, 1], [1, 74, 0.5], [1.5, 72, 1.5], [4, 74, 1], [5, 76, 1], [6, 79, 2], [8, 76, 1], [9, 74, 1], [10, 72, 2], [12, 72, 1], [13, 74, 1], [14, 72, 2]]
+    }),
+    // a syncopated loop in A minor, the bass on the off-beats
+    radioTrack({
+      id: "radio_track_groove",
+      bpm: 100,
+      bars: 4,
+      wave: "triangle",
+      bass: bassLine([57, 62, 64, 57], [0, 0.75, 1.5, 2.5, 3.25]),
+      chords: [...chord(0, 57, true), ...chord(1, 62, true), ...chord(2, 64), ...chord(3, 57, true)],
+      melody: [[0.5, 72, 0.5], [1.25, 76, 0.75], [2.5, 74, 1], [4.5, 77, 0.5], [5.25, 74, 0.75], [6.5, 72, 1.5], [8.5, 71, 0.5], [9.25, 74, 0.75], [10.5, 76, 1.5], [12.5, 72, 0.5], [13.25, 69, 2]]
+    }),
+    // a slow blues-like loop in F with a swung melody
+    radioTrack({
+      id: "radio_track_slow",
+      bpm: 76,
+      bars: 4,
+      wave: "sine",
+      bass: bassLine([53, 58, 53, 60], [0, 2]),
+      chords: [...chord(0, 65), ...chord(1, 58), ...chord(2, 65), ...chord(3, 60)],
+      melody: [[0, 72, 1.5], [1.67, 75, 0.33], [2, 77, 2], [4, 74, 1], [5, 72, 1], [6, 70, 2], [8, 72, 1.5], [9.67, 69, 0.33], [10, 65, 2], [12, 67, 1], [13, 70, 1], [14, 72, 2]]
+    })
+  ];
+  var RADIO_TRACKS = TRACKS.map((t) => t.song);
+  var RADIO_BANK = { id: "vehicle_radio", sounds: TRACKS.flatMap((t) => t.recipes), loops: [] };
+
   // src/recipes/foley.ts
   var FOLEY_FALLOFF = {
     model: "inverse_square",
@@ -4338,11 +4777,11 @@ var GameAudio = (() => {
       ...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 quieter = (level, layers) => layers.map((layer2) => {
+    const gain = layer2.gain ?? 1;
+    if (typeof gain === "number") return { ...layer2, gain: gain * level };
+    if (Array.isArray(gain)) return { ...layer2, gain: [gain[0] * level, gain[1] * level] };
+    return layer2;
   });
   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")}`;
@@ -4358,7 +4797,7 @@ var GameAudio = (() => {
     (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 })),
+      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer2) => ({ ...layer2, at: (typeof layer2.at === "number" ? layer2.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 })
     ]),
@@ -4404,7 +4843,7 @@ var GameAudio = (() => {
     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 }))
+      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer2) => ({ ...layer2, 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) => [
@@ -4506,6 +4945,9 @@ var GameAudio = (() => {
       },
       register(bank) {
         engine.register(bank);
+      },
+      preload(sounds) {
+        void engine.loadSamples(sounds).catch(() => void 0);
       }
     };
   }
@@ -4766,11 +5208,11 @@ var GameAudio = (() => {
       const planned = plan();
       if (!planned) return `${text.sheet.title}: ${engine.registry.sound(state.sound) ? text.sheet.silent : text.sheet.none}`;
       const head = `${text.sheet.title}: ${planned.id} (${planned.bus}) ${text.sheet.level} ${planned.level.toFixed(4)} ${text.sheet.distance} ${planned.distance.toFixed(1)} m${planned.pan === void 0 ? "" : ` ${text.sheet.pan} ${planned.pan.toFixed(3)}`} ${planned.length.toFixed(3)} ${text.sheet.length}`;
-      const layers2 = planned.layers.map((layer, index) => {
-        const source = layer.source.kind === "noise" ? `noise@${layer.source.offset.toFixed(4)}` : layer.source.kind === "osc" ? `${layer.source.wave}@${layer.source.frequency.value ?? layer.source.frequency.from}` : layer.source.kind;
-        const filters = (layer.filters?.bank ?? []).map((filter) => `${filter.type}@${(filter.frequency.value ?? filter.frequency.from ?? 0).toFixed(1)}`).join(" ");
-        const envelope2 = layer.envelope.map((point) => `${point.time.toFixed(3)}:${point.value.toPrecision(3)}`).join(" ");
-        return `  ${text.sheet.layer} ${index + 1}: ${source} at ${layer.at.toFixed(3)} for ${layer.duration.toFixed(3)} ${filters} [${envelope2}]`;
+      const layers2 = planned.layers.map((layer2, index) => {
+        const source = layer2.source.kind === "noise" ? `noise@${layer2.source.offset.toFixed(4)}` : layer2.source.kind === "osc" ? `${layer2.source.wave}@${layer2.source.frequency.value ?? layer2.source.frequency.from}` : layer2.source.kind;
+        const filters = (layer2.filters?.bank ?? []).map((filter) => `${filter.type}@${(filter.frequency.value ?? filter.frequency.from ?? 0).toFixed(1)}`).join(" ");
+        const envelope2 = layer2.envelope.map((point) => `${point.time.toFixed(3)}:${point.value.toPrecision(3)}`).join(" ");
+        return `  ${text.sheet.layer} ${index + 1}: ${source} at ${layer2.at.toFixed(3)} for ${layer2.duration.toFixed(3)} ${filters} [${envelope2}]`;
       });
       return [head, ...layers2].join("\n");
     };