@adatechnology/game-audio 0.4.0 → 0.5.0

package/dist/{chunk-DZITVFMJ.js → chunk-7TLFY7VO.js}

@@ -186,15 +186,31 @@ 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"]
+    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" },
+    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",
@@ -202,6 +218,30 @@ var mix_profiles_default = [
       "cena:L1311 wet 0.4",
       "cena:L1312 noise 2 s made with the chain"
     ]
+  },
+  {
+    id: "kit",
+    master: 0.85,
+    compressor: {
+      threshold: -12,
+      ratio: 5
+    },
+    reverb: {
+      seconds: 2.2,
+      decay: 3.4,
+      wet: 0.4
+    },
+    noise: {
+      seconds: 2,
+      create: "eager"
+    },
+    sources: [
+      "sdk: the art scene chain (cena L1308-L1312) with a limiter after the compressor: the page has none, and a blast with its debris and a fire catching reached +7 dBFS"
+    ],
+    limiter: {
+      ceiling: -1,
+      knee: -6
+    }
   }
 ];
 
@@ -209,7 +249,7 @@ var mix_profiles_default = [
 var MIX_PROFILES = Object.fromEntries(
   mix_profiles_default.map((profile) => [profile.id, profile])
 );
-var DEFAULT_MIX = "art_scene";
+var DEFAULT_MIX = "kit";
 function resolveMix(mix, profiles = MIX_PROFILES) {
   if (typeof mix !== "string") return mix;
   const profile = profiles[mix];
@@ -236,6 +276,19 @@ var voice_groups_default = {
       "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"
+    ]
   }
 };
 
@@ -331,6 +384,7 @@ function createSoundRegistry(banks = []) {
   const sounds = /* @__PURE__ */ new Map();
   const loops = /* @__PURE__ */ new Map();
   const sets = /* @__PURE__ */ new Map();
+  const samples = /* @__PURE__ */ new Map();
   const owners = /* @__PURE__ */ new Map();
   const registry = {
     register(bank) {
@@ -347,25 +401,34 @@ function createSoundRegistry(banks = []) {
         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);
@@ -633,7 +696,32 @@ function bufferOf(context, channels, requestedLength) {
 }
 
 // src/webaudio/chain.ts
+var LIMITER_POINTS = 4097;
+function limiterCurve(ceilingDb, kneeDb, range, points = LIMITER_POINTS) {
+  const ceiling = 10 ** (ceilingDb / 20);
+  const knee = Math.min(10 ** (kneeDb / 20), ceiling);
+  const curve = new Float32Array(new ArrayBuffer(points * 4));
+  for (let i = 0; i < points; i++) {
+    const x = (i / (points - 1) * 2 - 1) * range;
+    const a = Math.abs(x);
+    const y = a <= knee || ceiling === knee ? Math.min(a, ceiling) : knee + (ceiling - knee) * Math.tanh((a - knee) / (ceiling - knee));
+    curve[i] = Math.sign(x) * y;
+  }
+  return curve;
+}
 function buildChain(context, profile, random) {
+  let limiter;
+  if (profile.limiter) {
+    const range = profile.limiter.range ?? 4;
+    const input = context.createGain();
+    input.gain.value = 1 / range;
+    const shaper = context.createWaveShaper();
+    shaper.curve = limiterCurve(profile.limiter.ceiling, profile.limiter.knee, range);
+    input.connect(shaper);
+    shaper.connect(context.destination);
+    limiter = { input, shaper };
+  }
+  const output = limiter?.input ?? context.destination;
   let compressor;
   if (profile.compressor) {
     compressor = context.createDynamicsCompressor();
@@ -642,17 +730,19 @@ function buildChain(context, profile, random) {
     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);
+    compressor.connect(output);
   }
   const master = context.createGain();
   master.gain.value = profile.master;
-  master.connect(compressor ?? context.destination);
+  master.connect(compressor ?? output);
   if (!profile.reverb) {
     return {
       master,
       disconnect: () => {
         master.disconnect();
         compressor?.disconnect();
+        limiter?.input.disconnect();
+        limiter?.shaper.disconnect();
       }
     };
   }
@@ -671,6 +761,8 @@ function buildChain(context, profile, random) {
       convolver.disconnect();
       master.disconnect();
       compressor?.disconnect();
+      limiter?.input.disconnect();
+      limiter?.shaper.disconnect();
     }
   };
 }
@@ -682,7 +774,7 @@ function globalContext() {
   return Constructor ? new Constructor() : null;
 }
 function unlockContext(context) {
-  if (context.state === "suspended") void context.resume();
+  if (context.state === "suspended" && typeof context.close === "function") void context.resume();
 }
 
 // src/loops.ts
@@ -760,6 +852,16 @@ function voiceOf(sources) {
 }
 
 // src/webaudio/realize-loop.ts
+function outputStage(recipe, target, gain) {
+  if (!recipe.pan) {
+    gain.connect(target.output);
+    return { out: gain };
+  }
+  const panner = target.context.createStereoPanner();
+  gain.connect(panner);
+  panner.connect(target.output);
+  return { out: panner, panner };
+}
 var fixed = (range) => typeof range === "number" ? range : 0;
 var fixedFrequency = (automation) => fixed("set" in automation ? automation.set : automation.from);
 function sourceOf(recipe, target) {
@@ -786,7 +888,7 @@ function realizeGameLoop(recipe, target) {
   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 output = outputStage(recipe, target, gain);
   const { source, frequency } = sourceOf(recipe, target);
   recipe.filters?.bank.forEach((spec, index) => {
     const filter = filters[index];
@@ -813,7 +915,7 @@ function realizeGameLoop(recipe, target) {
   }
   source.connect(filters[0] ?? gain);
   source.start();
-  return { gain, source, ...frequency ? { frequency } : {}, stop: stopAll(sources) };
+  return { gain, ...output, source, ...frequency ? { frequency } : {}, ...filters[0] ? { cutoff: filters[0].frequency } : {}, stop: stopAll(sources) };
 }
 function realizeChainLoop(recipe, target, volume) {
   const { context } = target;
@@ -834,10 +936,10 @@ function realizeChainLoop(recipe, target, volume) {
   let tail = source;
   for (const filter of filters) tail = tail.connect(filter);
   tail.connect(gain);
-  gain.connect(target.output);
+  const output = outputStage(recipe, target, gain);
   source.start();
   for (const lfo of lfos) lfo.start();
-  return { gain, source, ...frequency ? { frequency } : {}, stop: stopAll([source, ...lfos]) };
+  return { gain, ...output, source, ...frequency ? { frequency } : {}, ...filters[0] ? { cutoff: filters[0].frequency } : {}, stop: stopAll([source, ...lfos]) };
 }
 
 // src/webaudio/engine-loop.ts
@@ -857,12 +959,12 @@ function createLoopHandle(recipe, host, volume) {
       return nodes !== void 0;
     },
     rewire() {
-      nodes?.gain.disconnect();
-      nodes?.gain.connect(host.output(loopRecipe.bus));
+      nodes?.out.disconnect();
+      nodes?.out.connect(host.output(loopRecipe.bus));
     },
     stop() {
       nodes?.stop();
-      nodes?.gain.disconnect();
+      nodes?.out.disconnect();
       nodes = void 0;
       state = createLoopState(loopRecipe);
       host.unregister(entry);
@@ -882,16 +984,255 @@ function createLoopHandle(recipe, host, volume) {
     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));
-      nodes.gain.gain.setTargetAtTime(action.volume, context.currentTime, smoothing.volume);
+      const listener = placed && position ? host.listener?.() : void 0;
+      const distance = listener && position ? listenerDistance(listener, position, host.distance) : 0;
+      const level = listener ? falloffGain(loopRecipe.falloff, action.volume, distance) : action.volume;
+      nodes.gain.gain.setTargetAtTime(level, context.currentTime, smoothing.volume);
       if (action.frequency !== void 0 && nodes.frequency) nodes.frequency.setTargetAtTime(action.frequency, context.currentTime, smoothing.frequency);
+      if (cutoff !== void 0 && nodes.cutoff) nodes.cutoff.setTargetAtTime(cutoff / cutoffDivisor(loopRecipe.falloff, distance), context.currentTime, smoothing.frequency);
+      if (listener && position && nodes.panner) nodes.panner.pan.setTargetAtTime(panFor(listener, position), context.currentTime, smoothing.frequency);
+    },
+    stop: entry.stop
+  };
+}
+
+// src/sample.ts
+var SAMPLE_ENVIRONMENTS = ["indoor", "outdoor"];
+var DEFAULT_SAMPLE_FALLOFF = { model: "inverse_square", k: 2e-3, minGain: 2e-3 };
+var DEFAULT_CROSSOVER = { from: 30, to: 80 };
+var DEFAULT_SAMPLE_PITCH = 0.04;
+var DEFAULT_TAIL_GAIN = 0.6;
+var DEFAULT_SAMPLE_CUTOFF_K = 0.01;
+var OPEN_CUTOFF = 2e4;
+var LAYER_FLOOR = 1e-3;
+function pickTake(count, last, random) {
+  if (count <= 1) return 0;
+  if (last === void 0 || last < 0 || last >= count) return Math.min(count - 1, Math.floor(random() * count));
+  const drawn = Math.min(count - 2, Math.floor(random() * (count - 1)));
+  return drawn >= last ? drawn + 1 : drawn;
+}
+function farMixAt(crossover, distance) {
+  if (crossover.to <= crossover.from) return distance >= crossover.to ? 1 : 0;
+  const t = (distance - crossover.from) / (crossover.to - crossover.from);
+  return t <= 0 ? 0 : t >= 1 ? 1 : t;
+}
+function crossGains(farMix) {
+  return { close: Math.cos(farMix * Math.PI / 2), far: Math.sin(farMix * Math.PI / 2) };
+}
+function sampleCutoff(cutoffK, distance, occlusion = 0) {
+  const byDistance = cutoffK > 0 ? OPEN_CUTOFF / (1 + distance * cutoffK) : OPEN_CUTOFF;
+  const occluded = occlusion > 0 ? byDistance / (1 + occlusion * 9) : byDistance;
+  return Math.max(80, Math.min(OPEN_CUTOFF, occluded));
+}
+function sampleUrls(sound) {
+  const tiers = (sound.tiers ?? []).flatMap((tier) => [...tier.close, ...tier.far ?? []]);
+  const all = [...sound.close, ...sound.far ?? [], ...tiers, ...sound.tail?.indoor ?? [], ...sound.tail?.outdoor ?? []].map((ref) => ref.url);
+  return [...new Set(all)];
+}
+function tierFor(sound, intensity) {
+  if (intensity === void 0 || !sound.tiers) return void 0;
+  let chosen;
+  for (const tier of sound.tiers) if (tier.from <= intensity) chosen = tier;
+  return chosen ?? sound.tiers[0];
+}
+function planSample(sound, input) {
+  if (sound.close.length === 0) throw new Error(`sample sound ${sound.id} has no close take`);
+  const listener = input.listener ?? DEFAULT_LISTENER;
+  const distance = input.distance ?? (input.position ? listenerDistance(listener, input.position, input.distanceMode) : 0);
+  const falloff = sound.falloff ?? DEFAULT_SAMPLE_FALLOFF;
+  const occlusion = Math.max(0, Math.min(1, input.occlusion ?? 0));
+  const level = falloffGain(falloff, (input.volume ?? 1) * (sound.gain ?? 1), distance) * (1 - 0.45 * occlusion);
+  if (isSilent(falloff, level) || level <= 0) return null;
+  const pitch = sound.pitch ?? DEFAULT_SAMPLE_PITCH;
+  const rate = pitch > 0 ? 1 + (input.random() * 2 - 1) * pitch : 1;
+  const environment = input.environment ?? "outdoor";
+  const tier = tierFor(sound, input.intensity);
+  const close = tier?.close.length ? tier.close : sound.close;
+  const far = tier?.far?.length ? tier.far : sound.far ?? [];
+  const farMix = far.length > 0 ? farMixAt(sound.crossover ?? DEFAULT_CROSSOVER, distance) : 0;
+  const gains = crossGains(farMix);
+  const layers = [];
+  const take = (role, refs, gain, at) => {
+    if (refs.length === 0 || gain < LAYER_FLOOR) return;
+    const key = `${sound.id}/${tier && role !== "tail" ? `${tier.name}/` : ""}${role}`;
+    const index = pickTake(refs.length, input.memory?.get(key), input.random);
+    input.memory?.set(key, index);
+    const ref = refs[index];
+    layers.push({ role, url: ref.url, take: index, gain: gain * (ref.gain ?? 1) * level, rate, at });
+  };
+  take("close", close, gains.close, 0);
+  take("far", far, gains.far, 0);
+  const tails = sound.tail?.[environment] ?? [];
+  take("tail", tails, sound.tail?.gain ?? DEFAULT_TAIL_GAIN, sound.tail?.at ?? 0);
+  const pan = (sound.pan ?? true) && input.position ? panFor(listener, input.position) : void 0;
+  return {
+    kind: "sample",
+    id: sound.id,
+    bus: sound.bus,
+    level,
+    distance,
+    ...pan === void 0 ? {} : { pan },
+    cutoff: sampleCutoff(sound.cutoffK ?? DEFAULT_SAMPLE_CUTOFF_K, distance, occlusion),
+    rate,
+    environment,
+    ...tier ? { tier: tier.name } : {},
+    farMix,
+    layers,
+    priority: sound.priority ?? input.priority ?? busPriority(sound.bus),
+    ...sound.group ? { group: sound.group } : {}
+  };
+}
+
+// src/webaudio/sample-loop.ts
+var DEFAULT_LOOP_CROSSFADE = 0.25;
+var LOOKAHEAD = 1.5;
+var VOLUME_SMOOTHING = 0.05;
+function loopCrossfade(sound) {
+  if (!sound.loop) return void 0;
+  return sound.loop === true ? DEFAULT_LOOP_CROSSFADE : Math.max(0, sound.loop.crossfade ?? DEFAULT_LOOP_CROSSFADE);
+}
+var CROSSFADE_STEPS = 8;
+var equalPowerIn = (t) => Math.sin(Math.max(0, Math.min(1, t)) * Math.PI / 2);
+var ramp2 = (param, direction, at, seconds) => {
+  const value = (t) => direction === "in" ? equalPowerIn(t) : equalPowerIn(1 - t);
+  param.setValueAtTime(value(0), at);
+  for (let step = 1; step <= CROSSFADE_STEPS; step++) param.linearRampToValueAtTime(value(step / CROSSFADE_STEPS), at + seconds * step / CROSSFADE_STEPS);
+};
+function createSampleLoopHandle(sound, host, volume = 0) {
+  const crossfade = loopCrossfade(sound) ?? DEFAULT_LOOP_CROSSFADE;
+  let level = volume;
+  let stopped = false;
+  let fallback;
+  let master;
+  let segments = [];
+  let last;
+  let timer;
+  const entry = {
+    get created() {
+      return master !== void 0;
+    },
+    rewire() {
+      master?.disconnect();
+      master?.connect(host.output(sound.bus));
+    },
+    stop() {
+      stopped = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      for (const segment of segments) {
+        try {
+          segment.source.stop();
+        } catch {
+        }
+        segment.source.disconnect();
+        segment.gain.disconnect();
+      }
+      segments = [];
+      master?.disconnect();
+      master = void 0;
+      fallback?.stop();
+      fallback = void 0;
+      host.unregister(entry);
+    }
+  };
+  const nextBuffer = () => {
+    const takes = sound.close;
+    const take = pickTake(takes.length, last, host.random);
+    last = take;
+    const ref = takes[take];
+    return ref ? host.buffer(ref.url) : void 0;
+  };
+  const schedule = (context, output, at, first) => {
+    const buffer = nextBuffer();
+    if (!buffer) return void 0;
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    const gain = context.createGain();
+    source.connect(gain);
+    gain.connect(output);
+    const fade = Math.min(crossfade, buffer.duration / 2);
+    if (buffer.duration < 2 * crossfade || sound.close.length === 1) {
+      source.loop = true;
+      if (!first) ramp2(gain.gain, "in", at, Math.max(1e-3, fade));
+      source.start(at);
+      segments.push({ source, gain, end: Number.POSITIVE_INFINITY });
+      return void 0;
+    }
+    if (first) gain.gain.setValueAtTime(1, at);
+    else ramp2(gain.gain, "in", at, fade);
+    const end3 = at + buffer.duration;
+    ramp2(gain.gain, "out", end3 - fade, fade);
+    source.start(at);
+    source.stop(end3);
+    segments.push({ source, gain, end: end3 });
+    source.onended = () => {
+      segments = segments.filter((segment) => segment.source !== source);
+      source.disconnect();
+      gain.disconnect();
+    };
+    return end3 - fade;
+  };
+  const pump = (context, output, at, first) => {
+    if (stopped) return;
+    let next = schedule(context, output, at, first);
+    while (next !== void 0 && next < context.currentTime + LOOKAHEAD) next = schedule(context, output, Math.max(next, context.currentTime), false);
+    if (next === void 0) return;
+    const wait = Math.max(0, (next - context.currentTime - LOOKAHEAD / 2) * 1e3);
+    timer = setTimeout(() => {
+      timer = void 0;
+      pump(context, output, next, false);
+    }, wait);
+  };
+  const fileLevel = () => level * (sound.gain ?? 1);
+  const startFiles = () => {
+    if (stopped || master || !host.isReady(sound)) return master !== void 0;
+    const context = host.ready();
+    if (!context) return false;
+    master = context.createGain();
+    master.gain.setValueAtTime(fileLevel(), context.currentTime);
+    master.connect(host.output(sound.bus));
+    host.register(entry);
+    pump(context, master, context.currentTime, true);
+    if (fallback) {
+      fallback.set({ volume: 0 });
+      const old = fallback;
+      fallback = void 0;
+      setTimeout(() => old.stop(), VOLUME_SMOOTHING * 6e3);
+    }
+    return true;
+  };
+  const ensure = () => {
+    if (stopped || master) return;
+    if (startFiles()) return;
+    if (!fallback) {
+      fallback = host.fallback(level);
+      void host.load(sound).then(() => {
+        if (level > 0 || master) startFiles();
+      }).catch(() => void 0);
+    }
+  };
+  if (volume > 0) ensure();
+  return {
+    set(next) {
+      if (stopped) return;
+      if (next.volume !== void 0) level = host.muted(sound.bus) ? 0 : Math.max(0, next.volume);
+      if (level > 0) ensure();
+      const context = host.ready();
+      if (master && context) master.gain.setTargetAtTime(fileLevel(), context.currentTime, VOLUME_SMOOTHING);
+      fallback?.set(next.volume === void 0 ? next : { ...next, volume: level });
     },
     stop: entry.stop
   };
@@ -1179,7 +1520,7 @@ function realizeCalls(plan, target) {
 
 // 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;
@@ -1211,7 +1552,7 @@ function realizeNoiseLayer(plan, layer, target) {
   let tail = source;
   for (const filter of filters) tail = tail.connect(filter);
   tail.connect(envelope);
-  envelope.connect(outputStage(plan, layer, target));
+  envelope.connect(outputStage2(plan, layer, target));
   source.start(time, layer.source.kind === "noise" ? layer.source.offset : 0);
   source.stop(end2(layer, time));
   return [source];
@@ -1228,7 +1569,7 @@ function realizeToneLayer(plan, layer, target) {
   const envelope = context.createGain();
   applyEnvelope(envelope.gain, layer.envelope, time);
   oscillator.connect(envelope);
-  envelope.connect(outputStage(plan, layer, target));
+  envelope.connect(outputStage2(plan, layer, target));
   oscillator.start(time);
   oscillator.stop(end2(layer, time));
   return [oscillator];
@@ -1260,7 +1601,7 @@ function realizeVoiceLayer(plan, layer, target) {
   const envelope = context.createGain();
   applyEnvelope(envelope.gain, layer.envelope, time);
   mix.connect(envelope);
-  envelope.connect(outputStage(plan, layer, target));
+  envelope.connect(outputStage2(plan, layer, target));
   const stop = end2(layer, time);
   oscillator.start(time);
   vibrato.start(time);
@@ -1439,7 +1780,151 @@ function createSetPicker() {
   };
 }
 
+// src/webaudio/sample-store.ts
+function fetchLoader(baseUrl) {
+  return async (url2) => {
+    const target = baseUrl ? new URL(url2, baseUrl).toString() : url2;
+    const response = await fetch(target);
+    if (!response.ok) throw new Error(`${response.status} ${response.statusText} for ${target}`);
+    return response.arrayBuffer();
+  };
+}
+function inlineLoader(files) {
+  return async (url2) => {
+    const text = files[url2];
+    if (text === void 0) throw new Error(`no inline file for ${url2}`);
+    const base64 = text.startsWith("data:") ? text.slice(text.indexOf(",") + 1) : text;
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+    return bytes.buffer;
+  };
+}
+var decode = (context, bytes) => new Promise((resolve, reject) => {
+  const result = context.decodeAudioData(bytes, resolve, reject);
+  result?.catch?.(reject);
+});
+function createSampleStore(loader = fetchLoader()) {
+  const buffers = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Map();
+  let generation = 0;
+  const loadOne = (url2, context) => {
+    const existing = buffers.get(url2);
+    if (existing) return Promise.resolve(existing);
+    const inFlight = pending.get(url2);
+    if (inFlight) return inFlight;
+    const started = generation;
+    failed.delete(url2);
+    const promise = loader(url2).then((bytes) => decode(context, bytes)).then((buffer) => {
+      if (started === generation) buffers.set(url2, buffer);
+      return buffer;
+    }).catch((error) => {
+      if (started === generation) failed.set(url2, error instanceof Error ? error.message : String(error));
+      throw error;
+    }).finally(() => {
+      if (pending.get(url2) === promise) pending.delete(url2);
+    });
+    pending.set(url2, promise);
+    return promise;
+  };
+  return {
+    status(url2) {
+      if (buffers.has(url2)) return "ready";
+      if (pending.has(url2)) return "loading";
+      if (failed.has(url2)) return "failed";
+      return "none";
+    },
+    buffer: (url2) => buffers.get(url2),
+    ready: (urls) => urls.every((url2) => buffers.has(url2)),
+    seconds: (url2) => buffers.get(url2)?.duration,
+    async load(urls, context) {
+      const results = await Promise.allSettled(urls.map((url2) => loadOne(url2, context)));
+      const loaded = [];
+      const errors = [];
+      results.forEach((result, index) => {
+        const url2 = urls[index];
+        if (result.status === "fulfilled") loaded.push(url2);
+        else errors.push({ url: url2, error: result.reason instanceof Error ? result.reason.message : String(result.reason) });
+      });
+      return { loaded, failed: errors };
+    },
+    clear() {
+      generation++;
+      buffers.clear();
+      pending.clear();
+      failed.clear();
+    }
+  };
+}
+
+// src/webaudio/realize-sample.ts
+function realizeSample(plan, target) {
+  const context = target.context;
+  let head = target.output;
+  if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
+    const panner = context.createStereoPanner();
+    panner.pan.value = plan.pan;
+    panner.connect(head);
+    head = panner;
+  }
+  if (plan.cutoff < OPEN_CUTOFF) {
+    const lowpass = context.createBiquadFilter();
+    lowpass.type = "lowpass";
+    lowpass.frequency.value = plan.cutoff;
+    lowpass.Q.value = 0.7;
+    lowpass.connect(head);
+    head = lowpass;
+  }
+  const voice = context.createGain();
+  voice.connect(head);
+  head = voice;
+  const sources = [];
+  for (const layer of plan.layers) {
+    const buffer = target.buffer(layer.url);
+    if (!buffer) continue;
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    source.playbackRate.value = layer.rate;
+    const gain = gainNode(context, layer.gain);
+    source.connect(gain);
+    gain.connect(head);
+    source.start(target.time + layer.at);
+    sources.push(source);
+  }
+  const realized = voiceOf(sources);
+  return {
+    ...realized,
+    fade(at, seconds) {
+      voice.gain.setValueAtTime(1, at);
+      voice.gain.linearRampToValueAtTime(0, at + seconds);
+      for (const source of sources) {
+        try {
+          source.stop(at + seconds);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function sampleLength(plan, seconds) {
+  let length = 0;
+  for (const layer of plan.layers) length = Math.max(length, layer.at + (seconds(layer.url) ?? 0) / layer.rate);
+  return length;
+}
+
 // src/webaudio/engine.ts
+function limiterCurve2(knee, ceiling, range, points = 2049) {
+  const curve = new Float32Array(points);
+  const room = Math.max(1e-6, ceiling - knee);
+  for (let index = 0; index < points; index++) {
+    const value = (index / (points - 1) * 2 - 1) * range;
+    const size = Math.abs(value);
+    const bent = size <= knee ? size : knee + room * Math.tanh((size - knee) / room);
+    curve[index] = Math.sign(value) * bent;
+  }
+  return curve;
+}
 var usesNoise = (recipe) => recipe.layers.some((layer) => layer.source.kind !== "osc");
 var planUsesNoise = (plan) => plan.layers.some((layer) => layer.source.kind !== "osc");
 function createAudioEngine(options = {}) {
@@ -1459,6 +1944,43 @@ function createAudioEngine(options = {}) {
   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) => {
@@ -1515,17 +2037,31 @@ function createAudioEngine(options = {}) {
     ...options.occlusion && playOptions.position && recipe.falloff?.model !== "none" ? { occlusion: options.occlusion(playOptions.position) } : {}
   });
   const startQueue = options.deferredStart ? createStartQueue(options.deferredStart) : null;
-  const build = (plan, store, delay) => {
+  const 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 built = null;
     let cancelled = false;
     const pending = {
@@ -1539,7 +2075,7 @@ function createAudioEngine(options = {}) {
     };
     startQueue.push({
       run() {
-        if (!cancelled && context) built = build(plan, store, delay);
+        if (!cancelled && context) built = build(plan, store, delay, requestedAt, fallbackOf);
       },
       drop() {
         if (voiceId === void 0) return;
@@ -1549,13 +2085,14 @@ function createAudioEngine(options = {}) {
     });
     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();
@@ -1579,7 +2116,83 @@ function createAudioEngine(options = {}) {
     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;
@@ -1597,7 +2210,7 @@ function createAudioEngine(options = {}) {
     if (voiceId === null) return null;
     if (!silent && usesNoise(recipe)) prepareNoise(store, audio, mix.noise.seconds);
     const plan = planSound(recipe, inputFor(recipe, playOptions, random));
-    return plan ? start(retunePlan(plan, rate), store, voiceId, playOptions.delay) : 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;
@@ -1619,12 +2232,42 @@ function createAudioEngine(options = {}) {
     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)
+    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();
@@ -1636,7 +2279,26 @@ function createAudioEngine(options = {}) {
       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),
+    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;
@@ -1717,6 +2379,10 @@ function createAudioEngine(options = {}) {
       busNodes.clear();
       meters.clear();
       shared.reset();
+      sampleStore.clear();
+      memory.clear();
+      sampleLimiters.clear();
+      chokes.clear();
     }
   };
 }
@@ -1773,7 +2439,7 @@ var EN = {
     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 = {
@@ -1827,7 +2493,7 @@ var PT_BR = {
     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;
@@ -1901,7 +2567,7 @@ function createAudioTestModule(options = {}) {
     distance: 10,
     bearing: 0,
     volume: 1,
-    mix: "art_scene",
+    mix: DEFAULT_MIX,
     seed: options.seed ?? 1,
     source: "bench",
     loop: NONE,
@@ -2181,6 +2847,1218 @@ function createAudioTestModule(options = {}) {
   return module;
 }
 
+// src/catalog.ts
+var SFX_CATEGORIES = ["armas", "impactos", "explosoes-fogo", "personagem", "veiculos", "itens-portas", "ambiente"];
+var entries = (category, list) => list.map(([id, priority, current]) => ({ id, category, priority, ...current ? { current } : {} }));
+var SFX_CATALOG = [
+  ...entries("armas", [
+    ["pistol_22lr", 2, "sfx_pistol"],
+    ["pistol_9mm", 1, "sfx_pistol"],
+    ["pistol_45", 1, "sfx_pistol"],
+    ["revolver_38_357", 2, "sfx_pistol"],
+    ["revolver_44_50ae", 3, "sfx_pistol"],
+    ["smg_9mm_auto", 1, "sfx_pistol"],
+    ["shotgun_12", 1, "sfx_shotgun"],
+    ["rifle_5_56", 1, "sfx_rifle"],
+    ["rifle_7_62x39", 1, "sfx_rifle"],
+    ["rifle_auto_burst", 1, "sfx_rifle"],
+    ["rifle_308_3006", 2, "sfx_rifle"],
+    ["sniper_338_300wm", 2, "sfx_rifle"],
+    ["antimateriel_50bmg", 3, "sfx_rifle"],
+    ["suppressed_pistol", 2],
+    ["suppressed_rifle", 2],
+    ["gunshot_far_pistol", 1],
+    ["gunshot_far_rifle", 1],
+    ["gunshot_far_shotgun", 1],
+    ["gunshot_far_heavy", 2],
+    ["gunshot_tail_indoor", 1],
+    ["gunshot_tail_outdoor", 1],
+    ["bullet_crack_by", 2],
+    ["bullet_whiz", 2],
+    ["ricochet_metal", 2, "ping"],
+    ["dry_fire", 1],
+    ["mag_out", 1],
+    ["mag_in", 1],
+    ["slide_pull_release", 1],
+    ["pump_cycle", 1],
+    ["casing_drop_concreto_pistol", 1],
+    ["casing_drop_concreto_rifle", 1],
+    ["casing_drop_concreto_shell", 1],
+    ["casing_drop_madeira_pistol", 1],
+    ["casing_drop_madeira_rifle", 1],
+    ["casing_drop_madeira_shell", 1],
+    ["casing_drop_metal_pistol", 1],
+    ["casing_drop_metal_rifle", 1],
+    ["casing_drop_metal_shell", 1],
+    ["casing_drop_terra_pistol", 1],
+    ["casing_drop_terra_rifle", 1],
+    ["casing_drop_terra_shell", 1],
+    ["rocket_fire", 2]
+  ]),
+  ...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/measure/calibration.ts
+var CALIBRATION_ID = "calibration_shot";
+var CALIBRATION_RATE = 48e3;
+function encodeWav(samples, sampleRate = CALIBRATION_RATE) {
+  const bytes = new ArrayBuffer(44 + samples.length * 2);
+  const view = new DataView(bytes);
+  const text = (at, value) => {
+    for (let index = 0; index < value.length; index++) view.setUint8(at + index, value.charCodeAt(index));
+  };
+  text(0, "RIFF");
+  view.setUint32(4, 36 + samples.length * 2, true);
+  text(8, "WAVE");
+  text(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  text(36, "data");
+  view.setUint32(40, samples.length * 2, true);
+  for (let index = 0; index < samples.length; index++) {
+    const value = Math.max(-1, Math.min(1, samples[index]));
+    view.setInt16(44 + index * 2, value < 0 ? value * 32768 : value * 32767, true);
+  }
+  return bytes;
+}
+function shotSamples(shot, sampleRate = CALIBRATION_RATE) {
+  const random = createRng(shot.seed);
+  const length = Math.round(shot.seconds * sampleRate);
+  const samples = new Float32Array(length);
+  let low = 0;
+  let phase = 0;
+  const attack = Math.max(1, Math.round((shot.attack ?? 0) * sampleRate));
+  for (let index = 0; index < length; index++) {
+    const time = index / sampleRate;
+    const envelope = Math.exp(-time / shot.decay) * Math.min(1, (index + 1) / attack);
+    phase += 2 * Math.PI * shot.thump * (1 + 0.6 * Math.exp(-time * 30)) / sampleRate;
+    const noise = random() * 2 - 1;
+    low += shot.brightness * (noise - low);
+    const fade = Math.min(1, (length - index) / (0.01 * sampleRate));
+    samples[index] = shot.gain * envelope * fade * (0.55 * Math.sin(phase) + shot.noise * low);
+  }
+  return samples;
+}
+var TAKES = {
+  "close_1.wav": { seconds: 0.4, thump: 150, noise: 1, decay: 0.06, brightness: 0.9, gain: 0.85, seed: 1 },
+  "close_2.wav": { seconds: 0.4, thump: 160, noise: 1, decay: 0.065, brightness: 0.85, gain: 0.85, seed: 2 },
+  "close_3.wav": { seconds: 0.4, thump: 142, noise: 1, decay: 0.055, brightness: 0.95, gain: 0.85, seed: 3 },
+  "close_4.wav": { seconds: 0.4, thump: 170, noise: 1, decay: 0.07, brightness: 0.8, gain: 0.85, seed: 4 },
+  "far_1.wav": { seconds: 0.9, thump: 90, noise: 0.8, decay: 0.2, brightness: 0.08, gain: 0.7, seed: 5, attack: 4e-3 },
+  "far_2.wav": { seconds: 0.9, thump: 95, noise: 0.8, decay: 0.22, brightness: 0.07, gain: 0.7, seed: 6, attack: 4e-3 },
+  "light_1.wav": { seconds: 0.25, thump: 220, noise: 0.6, decay: 0.03, brightness: 0.6, gain: 0.35, seed: 7 },
+  "light_2.wav": { seconds: 0.25, thump: 230, noise: 0.6, decay: 0.03, brightness: 0.55, gain: 0.35, seed: 8 },
+  "heavy_1.wav": { seconds: 0.6, thump: 110, noise: 1.2, decay: 0.11, brightness: 0.95, gain: 0.95, seed: 9 },
+  "heavy_2.wav": { seconds: 0.6, thump: 105, noise: 1.2, decay: 0.12, brightness: 0.9, gain: 0.95, seed: 10 },
+  "tail_in.wav": { seconds: 0.5, thump: 0, noise: 1, decay: 0.08, brightness: 0.4, gain: 0.25, seed: 11, attack: 0.01 },
+  "tail_out.wav": { seconds: 2, thump: 0, noise: 1, decay: 0.45, brightness: 0.25, gain: 0.2, seed: 12, attack: 0.02 },
+  "loop_1.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.5, gain: 0.5, seed: 13, attack: 0.01 },
+  "loop_2.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.45, gain: 0.5, seed: 14, attack: 0.01 },
+  "loop_3.wav": { seconds: 0.6, thump: 0, noise: 1, decay: 100, brightness: 0.55, gain: 0.5, seed: 15, attack: 0.01 }
+};
+var PREFIX = "calibration/";
+var url = (name) => `${PREFIX}${name}`;
+var CALIBRATION_SOUND = {
+  id: CALIBRATION_ID,
+  bus: "weapons",
+  close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })),
+  far: ["far_1.wav", "far_2.wav"].map((name) => ({ url: url(name) })),
+  tiers: [
+    { name: "light", from: 0, close: ["light_1.wav", "light_2.wav"].map((name) => ({ url: url(name) })) },
+    { name: "medium", from: 0.34, close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })) },
+    { name: "heavy", from: 0.67, close: ["heavy_1.wav", "heavy_2.wav"].map((name) => ({ url: url(name) })) }
+  ],
+  tail: { indoor: [{ url: url("tail_in.wav") }], outdoor: [{ url: url("tail_out.wav") }] },
+  pitch: 0.04,
+  choke: { voices: 2 },
+  fallback: "sfx_pistol",
+  sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+};
+var CALIBRATION_LOOP_ID = "calibration_loop";
+var CALIBRATION_LOOP_SOUND = {
+  id: CALIBRATION_LOOP_ID,
+  bus: "ambience",
+  close: ["loop_1.wav", "loop_2.wav", "loop_3.wav"].map((name) => ({ url: url(name) })),
+  loop: { crossfade: 0.15 },
+  sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+};
+var isCalibrationUrl = (url2) => url2.startsWith(PREFIX);
+function calibrationLoader(next) {
+  const made = /* @__PURE__ */ new Map();
+  return async (requested) => {
+    if (!requested.startsWith(PREFIX)) {
+      if (next) return next(requested);
+      throw new Error(`not a calibration file: ${requested}`);
+    }
+    const name = requested.slice(PREFIX.length);
+    const shot = TAKES[name];
+    if (!shot) throw new Error(`no calibration take ${name}`);
+    let bytes = made.get(name);
+    if (!bytes) {
+      bytes = encodeWav(shotSamples(shot));
+      made.set(name, bytes);
+    }
+    return bytes.slice(0);
+  };
+}
+
+// src/measure/analyze.ts
+var dbOf = (amplitude) => amplitude > 0 ? 20 * Math.log10(amplitude) : -Infinity;
+var clampIndex = (channels, index) => Math.max(0, Math.min(channels[0]?.length ?? 0, Math.round(index)));
+function peakOf(channels, start = 0, end3 = Number.POSITIVE_INFINITY) {
+  let peak = 0;
+  const from = clampIndex(channels, start);
+  for (const channel of channels) {
+    const to = Math.min(channel.length, end3);
+    for (let index = from; index < to; index++) {
+      const value = Math.abs(channel[index]);
+      if (value > peak) peak = value;
+    }
+  }
+  return peak;
+}
+function peakIndex(channels, start = 0, end3 = Number.POSITIVE_INFINITY) {
+  let peak = -1;
+  let at = -1;
+  const from = clampIndex(channels, start);
+  for (const channel of channels) {
+    const to = Math.min(channel.length, end3);
+    for (let index = from; index < to; index++) {
+      const value = Math.abs(channel[index]);
+      if (value > peak) {
+        peak = value;
+        at = index;
+      }
+    }
+  }
+  return at;
+}
+function onsetIndex(channels, start = 0, threshold = 1e-3) {
+  const length = channels[0]?.length ?? 0;
+  for (let index = clampIndex(channels, start); index < length; index++) {
+    for (const channel of channels) if (Math.abs(channel[index]) >= threshold) return index;
+  }
+  return -1;
+}
+function rmsDb(channels, start, end3) {
+  let sum = 0;
+  let count = 0;
+  const from = clampIndex(channels, start);
+  for (const channel of channels) {
+    const to = Math.min(channel.length, Math.round(end3));
+    for (let index = from; index < to; index++) {
+      const value = channel[index];
+      sum += value * value;
+      count++;
+    }
+  }
+  return count === 0 ? -Infinity : dbOf(Math.sqrt(sum / count));
+}
+function centroidHz(channels, sampleRate, start, size = 2048) {
+  const from = clampIndex(channels, start);
+  const frame = new Float64Array(size);
+  for (const channel of channels) {
+    for (let index = 0; index < size; index++) frame[index] = frame[index] + (channel[from + index] ?? 0);
+  }
+  for (let index = 0; index < size; index++) frame[index] = frame[index] * (0.5 - 0.5 * Math.cos(2 * Math.PI * index / (size - 1)));
+  let weighted = 0;
+  let total = 0;
+  const bins = size / 2;
+  for (let bin = 1; bin < bins; bin++) {
+    let re = 0;
+    let im = 0;
+    const step = 2 * Math.PI * bin / size;
+    for (let index = 0; index < size; index++) {
+      const value = frame[index];
+      re += value * Math.cos(step * index);
+      im -= value * Math.sin(step * index);
+    }
+    const magnitude = Math.hypot(re, im);
+    weighted += magnitude * (bin * sampleRate / size);
+    total += magnitude;
+  }
+  return total > 0 ? weighted / total : 0;
+}
+function balanceOf(left, right, start, end3) {
+  let l = 0;
+  let r = 0;
+  const to = Math.min(left.length, right.length, Math.round(end3));
+  for (let index = Math.max(0, Math.round(start)); index < to; index++) {
+    l += left[index] ** 2;
+    r += right[index] ** 2;
+  }
+  return l + r > 0 ? (r - l) / (r + l) : 0;
+}
+function ringSeconds(channels, sampleRate, start, floorDb = -60) {
+  const window = Math.max(1, Math.round(sampleRate * 0.01));
+  const length = channels[0]?.length ?? 0;
+  let last = clampIndex(channels, start);
+  for (let index = last; index < length; index += window) {
+    if (dbOf(peakOf(channels, index, index + window)) > floorDb) last = index + window;
+  }
+  return (last - start) / sampleRate;
+}
+function countHits(channels, sampleRate, threshold) {
+  const window = Math.max(1, Math.round(sampleRate * 2e-3));
+  const length = channels[0]?.length ?? 0;
+  const envelope = [];
+  for (let index = 0; index < length; index += window) envelope.push(peakOf(channels, index, index + window));
+  const history = 10;
+  const refractory = Math.round(0.03 / 2e-3);
+  let hits = 0;
+  let quietUntil = -1;
+  for (let index = 0; index < envelope.length; index++) {
+    const level = envelope[index];
+    if (index < quietUntil || level < threshold) continue;
+    let sum = 0;
+    for (let back = Math.max(0, index - history); back < index; back++) sum += envelope[back];
+    const before = index === 0 ? 0 : sum / Math.min(history, index);
+    if (level >= 2 * before) {
+      hits++;
+      quietUntil = index + refractory;
+    }
+  }
+  return hits;
+}
+function endDropDb(channels, sampleRate, seconds = 5e-3) {
+  const length = channels[0]?.length ?? 0;
+  const whole = peakOf(channels);
+  if (whole === 0) return -Infinity;
+  return dbOf(peakOf(channels, length - Math.round(sampleRate * seconds), length) / whole);
+}
+
+// src/measure/criteria.ts
+var CRITERIA = ["C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "C10"];
+var CRITERIA_TARGETS = {
+  /** C1: event to the first sample, and onset to the peak (one 60 fps frame). */
+  syncMs: 20,
+  peakAfterOnsetMs: 1e3 / 60,
+  /** C3: distances measured, metres. */
+  distances: [1, 10, 50, 200],
+  /** C5: plays, distinct takes and the pitch range (fraction). */
+  plays: 10,
+  minTakes: 4,
+  pitch: [0.03, 0.05],
+  /** C6: the highest peak, dBFS. */
+  peakDb: -1,
+  /** C8: the end of each file against its peak, dB. */
+  endDropDb: -40,
+  /** C9: a burst of rapid fire. */
+  burst: 20,
+  burstSpacing: 0.06
+};
+var EVENT_AT = 0.2;
+var offlineFactory = (options) => options.createOfflineContext ?? ((channels, length, sampleRate) => {
+  const Constructor = globalThis.OfflineAudioContext;
+  if (!Constructor) throw new Error("no OfflineAudioContext here: the harness runs in a browser");
+  return new Constructor(channels, length, sampleRate);
+});
+async function render(options, seconds, act, engineExtras = {}) {
+  const sampleRate = options.sampleRate ?? 48e3;
+  const context = offlineFactory(options)(2, Math.ceil(seconds * sampleRate), sampleRate);
+  const events = [];
+  const engine = createAudioEngine({
+    banks: options.banks,
+    createContext: () => context,
+    samples: { loader: options.loader, autoLoad: false },
+    onVoiceStart: (event) => events.push(event),
+    ...options.mix ? { mix: options.mix } : {},
+    ...engineExtras.occlusion ? { occlusion: engineExtras.occlusion } : {},
+    ...engineExtras.environment ? { environment: engineExtras.environment } : {}
+  });
+  const ids = [.../* @__PURE__ */ new Set([options.sound, ...(options.actions ?? []).map((action) => action.play), ...options.loudnessOrder ?? []])].filter((id) => engine.registry.sample(id));
+  const report = await engine.loadSamples(ids);
+  if (report.failed.length > 0) throw new Error(`files did not load: ${report.failed.map((entry) => `${entry.url} (${entry.error})`).join(", ")}`);
+  const handles = act(engine);
+  const buffer = await context.startRendering();
+  const channels = Array.from({ length: buffer.numberOfChannels }, (_, index) => buffer.getChannelData(index));
+  return { channels, sampleRate, events, handles };
+}
+var ms = (seconds) => `${(seconds * 1e3).toFixed(1)} ms`;
+var db = (value) => Number.isFinite(value) ? `${value.toFixed(1)} dB` : "\u2212\u221E";
+var decreasing = (values) => values.every((value, index) => index === 0 || value < values[index - 1]);
+async function c1(options) {
+  const result = await render(options, 1.2, (engine) => engine.play(options.sound, { distance: 1, delay: EVENT_AT }) ? 1 : 0);
+  const onset = onsetIndex(result.channels, 0, 1e-3);
+  const event = result.events.find((entry) => entry.id === options.sound);
+  if (onset < 0 || !event) return { id: "C1", pass: false, value: "sem som", target: `\u2264 ${CRITERIA_TARGETS.syncMs} ms` };
+  const delay = onset / result.sampleRate - EVENT_AT + (event.startAt - event.requestedAt - EVENT_AT) + (options.baseLatency ?? 0);
+  const peak = peakIndex(result.channels, onset, onset + Math.round(result.sampleRate * 0.25));
+  const toPeak = (peak - onset) / result.sampleRate;
+  const pass = delay <= CRITERIA_TARGETS.syncMs / 1e3 && toPeak <= CRITERIA_TARGETS.peakAfterOnsetMs / 1e3;
+  return {
+    id: "C1",
+    pass,
+    value: `${ms(delay)}, pico +${ms(toPeak)}`,
+    target: `\u2264 ${CRITERIA_TARGETS.syncMs} ms; pico no quadro do contato`,
+    data: { delay, toPeak, baseLatency: options.baseLatency ?? 0, outputLatency: options.outputLatency ?? 0 }
+  };
+}
+async function c2(options) {
+  const actions = options.actions ?? [{ action: options.sound, play: options.sound, expect: options.sound }];
+  const result = await render(options, 0.5, (engine) => {
+    let played = 0;
+    for (const action of actions) if (engine.play(action.play, { distance: 1, ...action.options })) played++;
+    return played;
+  });
+  const wrong = actions.filter((action, index) => {
+    const event = result.events[index];
+    return !event || (event.fallbackOf ?? event.id) !== action.expect || event.kind !== "sample";
+  });
+  return {
+    id: "C2",
+    pass: wrong.length === 0,
+    value: `${actions.length - wrong.length}/${actions.length} certas`,
+    target: "100% das a\xE7\xF5es batem com a tabela (arquivo, n\xE3o o substituto)",
+    data: { wrong: wrong.map((action) => action.action), events: result.events.map((event) => `${event.kind}:${event.id}`) }
+  };
+}
+async function c3(options, sound) {
+  const levels = [];
+  const brightness = [];
+  for (const distance of CRITERIA_TARGETS.distances) {
+    const result = await render(options, 1.2, (engine) => engine.play(options.sound, { position: [0, 0, -distance], seed: 1, delay: EVENT_AT }) ? 1 : 0);
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    levels.push(onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3));
+    brightness.push(onset < 0 ? 0 : centroidHz(result.channels, result.sampleRate, onset));
+  }
+  const far = planSample(sound, { random: createRng(1), distance: CRITERIA_TARGETS.distances.at(-1) });
+  const switched = (far?.farMix ?? 0) === 1 && (far?.layers.some((layer) => layer.role === "far") ?? false);
+  const pass = decreasing(levels) && decreasing(brightness) && switched;
+  return {
+    id: "C3",
+    pass,
+    value: `${levels.map((level) => db(level)).join(" \u203A ")}; ${brightness.map((hz) => `${Math.round(hz)} Hz`).join(" \u203A ")}${switched ? "; longe = far" : "; sem camada far"}`,
+    target: "cai e escurece com a dist\xE2ncia; troca para a vers\xE3o de longe depois de ~50 m",
+    data: { distances: CRITERIA_TARGETS.distances, levels, brightness, switched }
+  };
+}
+async function c4(options) {
+  const side = async (x) => {
+    const result = await render(options, 0.8, (engine) => engine.play(options.sound, { position: [x, 0, -2], seed: 1, delay: EVENT_AT }) ? 1 : 0);
+    const [left2, right2] = result.channels;
+    return balanceOf(left2, right2, 0, left2.length);
+  };
+  const right = await side(10);
+  const left = await side(-10);
+  const bright = async (occluded) => {
+    const result = await render(options, 0.8, (engine) => engine.play(options.sound, { position: [0, 0, -10], seed: 1, delay: EVENT_AT }) ? 1 : 0, occluded ? { occlusion: () => 1 } : {});
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    return onset < 0 ? 0 : centroidHz(result.channels, result.sampleRate, onset);
+  };
+  const clear = await bright(false);
+  const wall = await bright(true);
+  const pass = right > 0.2 && left < -0.2 && wall < clear * 0.7;
+  return {
+    id: "C4",
+    pass,
+    value: `dir ${right.toFixed(2)} esq ${left.toFixed(2)}; parede ${Math.round(wall)} Hz de ${Math.round(clear)} Hz`,
+    target: "lado certo; atr\xE1s da parede fica abafado",
+    data: { right, left, clear, wall }
+  };
+}
+async function c5(options, sound) {
+  const result = await render(options, 0.3 * CRITERIA_TARGETS.plays + 1, (engine) => {
+    let played = 0;
+    for (let index = 0; index < CRITERIA_TARGETS.plays; index++) if (engine.play(options.sound, { distance: 1, delay: 0.1 + index * 0.3 })) played++;
+    return played;
+  });
+  const close = result.events.map((event) => event.layers?.find((layer) => layer.role === "close"));
+  const takes = close.map((layer) => layer?.url ?? "");
+  const repeats = takes.filter((take, index) => index > 0 && take === takes[index - 1]).length;
+  const distinct = new Set(takes).size;
+  const rates = close.map((layer) => layer?.rate ?? 1);
+  const spread = (Math.max(...rates) - Math.min(...rates)) / 2;
+  const pitch = sound.pitch ?? 0.04;
+  const pass = distinct >= CRITERIA_TARGETS.minTakes && repeats === 0 && pitch >= CRITERIA_TARGETS.pitch[0] && pitch <= CRITERIA_TARGETS.pitch[1] && spread > 0.01;
+  return {
+    id: "C5",
+    pass,
+    value: `${distinct} tomadas, ${repeats} repeti\xE7\xF5es seguidas, tom \xB1${(pitch * 100).toFixed(0)}%`,
+    target: `\u2265 ${CRITERIA_TARGETS.minTakes} varia\xE7\xF5es, nunca a mesma duas vezes, tom \xB13\u20135%`,
+    data: { takes, rates }
+  };
+}
+async function c6(options) {
+  const peakAt = async (id) => {
+    const result = await render(options, 1.2, (engine) => engine.play(id, { distance: 1, seed: 1, delay: EVENT_AT }) ? 1 : 0);
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    return { peak: dbOf(peakOf(result.channels)), rms: onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3) };
+  };
+  const own = await peakAt(options.sound);
+  const order = options.loudnessOrder ?? [];
+  const loudness = [];
+  for (const id of order) loudness.push((await peakAt(id)).rms);
+  const ordered = order.length < 2 || decreasing(loudness);
+  const pass = own.peak <= CRITERIA_TARGETS.peakDb && ordered;
+  return {
+    id: "C6",
+    pass,
+    value: `pico ${db(own.peak)}, RMS ${db(own.rms)}${order.length > 1 ? `; ordem ${ordered ? "ok" : "errada"}` : ""}`,
+    target: "tiro > explos\xE3o > impacto > passo; pico \u2264 \u22121 dBFS",
+    data: { peak: own.peak, rms: own.rms, order, loudness }
+  };
+}
+async function c7(options, sound) {
+  if (!sound.tiers || sound.tiers.length < 2) return { id: "C7", pass: false, value: "sem camadas leve/m\xE9dio/forte", target: "muda de camada, n\xE3o s\xF3 de volume" };
+  const at = async (intensity) => {
+    const result = await render(options, 1.2, (engine) => engine.play(options.sound, { distance: 1, seed: 1, intensity, delay: EVENT_AT }) ? 1 : 0);
+    const onset = onsetIndex(result.channels, 0, 1e-5);
+    const event = result.events[0];
+    return { tier: event?.tier ?? "", rms: onset < 0 ? -Infinity : rmsDb(result.channels, onset, onset + result.sampleRate * 0.3), files: event?.layers?.find((layer) => layer.role === "close")?.url ?? "" };
+  };
+  const light = await at(0.1);
+  const heavy = await at(0.9);
+  const pass = light.tier !== heavy.tier && light.files !== heavy.files && heavy.rms > light.rms;
+  return {
+    id: "C7",
+    pass,
+    value: `${light.tier} ${db(light.rms)} \u2192 ${heavy.tier} ${db(heavy.rms)}`,
+    target: "golpe fraco x forte troca a camada (leve/m\xE9dio/forte), n\xE3o s\xF3 o volume",
+    data: { light, heavy }
+  };
+}
+async function c8(options, sound) {
+  const sampleRate = options.sampleRate ?? 48e3;
+  const decoder = offlineFactory(options)(1, sampleRate, sampleRate);
+  const drops = [];
+  for (const url2 of sampleUrls(sound)) {
+    const buffer = await decoder.decodeAudioData(await options.loader(url2));
+    drops.push({ url: url2, drop: endDropDb([buffer.getChannelData(0)], buffer.sampleRate) });
+  }
+  const worst = drops.reduce((max, entry) => Math.max(max, entry.drop), -Infinity);
+  const ring = async (environment) => {
+    const result = await render(options, 3, (engine) => engine.play(options.sound, { distance: 1, seed: 1, environment, delay: EVENT_AT }) ? 1 : 0);
+    return ringSeconds(result.channels, result.sampleRate, Math.round(EVENT_AT * result.sampleRate));
+  };
+  const indoor = await ring("indoor");
+  const outdoor = await ring("outdoor");
+  const hasTails = Boolean(sound.tail?.indoor?.length && sound.tail?.outdoor?.length);
+  const pass = worst <= CRITERIA_TARGETS.endDropDb && hasTails && outdoor > indoor;
+  return {
+    id: "C8",
+    pass,
+    value: `fim ${db(worst)}; cauda dentro ${indoor.toFixed(2)} s, fora ${outdoor.toFixed(2)} s${hasTails ? "" : " (sem as duas caudas)"}`,
+    target: "n\xE3o corta seco; cauda de interior x exterior coerente",
+    data: { drops, indoor, outdoor }
+  };
+}
+async function c9(options) {
+  const { burst, burstSpacing } = CRITERIA_TARGETS;
+  const first = 0.1;
+  const result = await render(options, burst * burstSpacing + 1.5, (engine) => {
+    let played = 0;
+    for (let index = 0; index < burst; index++) if (engine.play(options.sound, { distance: 1, delay: first + index * burstSpacing })) played++;
+    return played;
+  });
+  const peak = dbOf(peakOf(result.channels));
+  const slots = [];
+  for (let index = 0; index < burst; index++) {
+    const at = Math.round((first + index * burstSpacing) * result.sampleRate);
+    slots.push(rmsDb(result.channels, at, at + Math.round(burstSpacing * result.sampleRate)));
+  }
+  const sorted = [...slots].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)];
+  const vanished = slots.filter((level) => level < median - 6).length;
+  const buildUp = slots.slice(-5).reduce((sum, level) => sum + level, 0) / 5 - slots[0];
+  const pass = result.handles === burst && vanished === 0 && buildUp <= 6 && peak <= CRITERIA_TARGETS.peakDb;
+  return {
+    id: "C9",
+    pass,
+    value: `${result.handles}/${burst} tocaram, ${vanished} sumiram, ac\xFAmulo ${buildUp >= 0 ? "+" : ""}${buildUp.toFixed(1)} dB, pico ${db(peak)}`,
+    target: "rajada sem amontoar (ac\xFAmulo \u2264 6 dB) nem sumir; pico \u2264 \u22121 dBFS",
+    data: { handles: result.handles, slots, vanished, buildUp, peak }
+  };
+}
+async function measureCriteria(options, only = CRITERIA) {
+  const probe = createAudioEngine({ banks: options.banks, createContext: () => null });
+  const sound = probe.registry.sample(options.sound);
+  if (!sound) throw new Error(`${options.sound} is not a sample sound of these banks`);
+  const results = [];
+  for (const id of only) {
+    if (id === "C1") results.push(await c1(options));
+    else if (id === "C2") results.push(await c2(options));
+    else if (id === "C3") results.push(await c3(options, sound));
+    else if (id === "C4") results.push(await c4(options));
+    else if (id === "C5") results.push(await c5(options, sound));
+    else if (id === "C6") results.push(await c6(options));
+    else if (id === "C7") results.push(await c7(options, sound));
+    else if (id === "C8") results.push(await c8(options, sound));
+    else if (id === "C9") results.push(await c9(options));
+    else results.push({ id: "C10", pass: null, value: "gravar e ouvir", target: "aprovado pelo ouvido do dono (print + grava\xE7\xE3o na 4280)" });
+  }
+  return results;
+}
+async function recordOutput(engine, seconds, act) {
+  engine.unlock();
+  const output = engine.output();
+  const Recorder = globalThis.MediaRecorder;
+  const context = output?.context;
+  if (!output || !Recorder || !context || typeof context.createMediaStreamDestination !== "function") return null;
+  const tap = context.createMediaStreamDestination();
+  output.connect(tap);
+  const recorder = new Recorder(tap.stream);
+  const chunks = [];
+  recorder.ondataavailable = (event) => chunks.push(event.data);
+  const done = new Promise((resolve) => {
+    recorder.onstop = () => resolve();
+  });
+  recorder.start();
+  act();
+  await new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+  recorder.stop();
+  await done;
+  output.disconnect(tap);
+  return new Blob(chunks, { type: recorder.mimeType || "audio/webm" });
+}
+
+// src/bench/sound-check-locale.ts
+var PT = {
+  group: "Som",
+  name: "Painel de som (arquivos e C1\u2013C10)",
+  controls: {
+    category: "1 \xB7 Categoria",
+    sound: "1 \xB7 Som",
+    play: "1 \xB7 \u25B6 Tocar",
+    material: "2 \xB7 Material",
+    blow: "2 \xB7 Golpe",
+    strike: "2 \xB7 \u25B6 Tocar golpe",
+    distance: "3 \xB7 Dist\xE2ncia",
+    bearing: "3 \xB7 Dire\xE7\xE3o",
+    environment: "3 \xB7 Lugar",
+    strength: "3 \xB7 For\xE7a",
+    wall: "3 \xB7 Atr\xE1s da parede",
+    burst: "3 \xB7 Rajada 20\xD7",
+    play_a: "4 \xB7 \u25B6 A (atual)",
+    play_b: "4 \xB7 \u25B6 B (novo)",
+    ab_cycle: "4 \xB7 Alternar A/B",
+    blind: "4 \xB7 \xC0s cegas (X)",
+    reveal: "4 \xB7 Revelar X",
+    prefer_a: "4 \xB7 Prefiro A",
+    prefer_b: "4 \xB7 Prefiro B",
+    measure: "5 \xB7 Medir C1\u2013C10",
+    record: "5 \xB7 Gravar 3 s",
+    approve: "5 \xB7 Aprovo (C10)"
+  },
+  hints: {
+    sound: "A = arquivo, S = sintetizado, F = faltando. O que tem arquivo toca o arquivo; o resto toca o som atual.",
+    strike: "Toca impact_<material>_<golpe>: o arquivo se existir, sen\xE3o o som atual daquele material.",
+    wall: "P\xF5e a parede de casa entre voc\xEA e a fonte: o som fica abafado (C4).",
+    burst: "Vinte vezes a cada 60 ms, como uma rajada (C9).",
+    ab_cycle: "A, B, A, B, um por segundo.",
+    blind: "Toca A ou B sem dizer qual; depois revele.",
+    measure: "Mede o som escolhido no motor real (contexto offline): sincronia, som certo, dist\xE2ncia, lado, varia\xE7\xE3o, volume, for\xE7a, cauda e rajada.",
+    record: "Grava 3 s da sa\xEDda com o som tocando e baixa o arquivo (C10).",
+    approve: "Marca o C10 do som escolhido como aprovado pelo seu ouvido."
+  },
+  categories: {
+    armas: "Armas",
+    impactos: "Impactos",
+    "explosoes-fogo": "Explos\xF5es e fogo",
+    personagem: "Personagem",
+    veiculos: "Ve\xEDculos",
+    "itens-portas": "Itens e portas",
+    ambiente: "Ambiente",
+    calibracao: "Calibra\xE7\xE3o (SDK)"
+  },
+  blows: { bullet: "tiro", blunt: "soco/chute", blade: "faca", break: "quebra", drag: "arrasto/queda" },
+  materials: {
+    steel: "a\xE7o",
+    aluminium: "alum\xEDnio",
+    wood: "madeira",
+    plywood: "compensado",
+    mdf: "MDF",
+    glass: "vidro",
+    tempered_glass: "vidro temperado",
+    ceramic: "cer\xE2mica",
+    concrete: "concreto",
+    brick: "tijolo",
+    plaster: "gesso",
+    plastic: "pl\xE1stico",
+    fabric: "tecido",
+    paper: "papel\xE3o",
+    foliage: "folhagem",
+    soil: "terra",
+    flesh: "carne"
+  },
+  environments: { indoor: "interior", outdoor: "exterior" },
+  strengths: { light: "leve", medium: "m\xE9dio", heavy: "forte" },
+  states: { file: "A", synth: "S", missing: "F" },
+  criteria: { C1: "C1 Sincronia", C2: "C2 Certo p/ a\xE7\xE3o", C3: "C3 Dist\xE2ncia", C4: "C4 Posi\xE7\xE3o", C5: "C5 Varia\xE7\xE3o", C6: "C6 Volume", C7: "C7 Intensidade", C8: "C8 Cauda", C9: "C9 Rajada", C10: "C10 Escuta" },
+  metrics: { chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
+  run: { idle: "parada", measuring: "medindo\u2026", done: "pronta", failed: "falhou", recording: "gravando\u2026", recorded: "grava\xE7\xE3o baixada" },
+  words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono" },
+  probe: "Fonte do som",
+  wall: "Parede (oclus\xE3o)",
+  scenarios: { pipeline: "Arquivo \u2192 decodifica \u2192 toca (round-robin, cauda)", criteria: "Crit\xE9rios C1\u2013C9 no som de calibra\xE7\xE3o", loop: "Loop de arquivo: emenda sem buraco (crossfade)", panel: "Painel: categorias, matriz, A/B e parede" }
+};
+var EN2 = {
+  ...PT,
+  group: "Sound",
+  name: "Sound panel (files and C1\u2013C10)",
+  controls: {
+    category: "1 \xB7 Category",
+    sound: "1 \xB7 Sound",
+    play: "1 \xB7 \u25B6 Play",
+    material: "2 \xB7 Material",
+    blow: "2 \xB7 Blow",
+    strike: "2 \xB7 \u25B6 Play blow",
+    distance: "3 \xB7 Distance",
+    bearing: "3 \xB7 Bearing",
+    environment: "3 \xB7 Place",
+    strength: "3 \xB7 Strength",
+    wall: "3 \xB7 Behind the wall",
+    burst: "3 \xB7 Burst 20\xD7",
+    play_a: "4 \xB7 \u25B6 A (current)",
+    play_b: "4 \xB7 \u25B6 B (new)",
+    ab_cycle: "4 \xB7 Alternate A/B",
+    blind: "4 \xB7 Blind (X)",
+    reveal: "4 \xB7 Reveal X",
+    prefer_a: "4 \xB7 Prefer A",
+    prefer_b: "4 \xB7 Prefer B",
+    measure: "5 \xB7 Measure C1\u2013C10",
+    record: "5 \xB7 Record 3 s",
+    approve: "5 \xB7 Approve (C10)"
+  },
+  hints: {
+    sound: "A = file, S = synthesized, F = missing. A file plays the file; the rest plays the current sound.",
+    strike: "Plays impact_<material>_<blow>: the file if there is one, else the current sound of that material.",
+    wall: "Puts the house wall between you and the source: the sound is muffled (C4).",
+    burst: "Twenty times every 60 ms, like a burst (C9).",
+    ab_cycle: "A, B, A, B, one a second.",
+    blind: "Plays A or B without saying which; reveal it after.",
+    measure: "Measures the chosen sound through the real engine (offline context): sync, right sound, distance, side, variation, level, strength, tail and burst.",
+    record: "Records 3 s of the output with the sound playing and downloads it (C10).",
+    approve: "Marks C10 of the chosen sound as approved by your ear."
+  },
+  categories: { armas: "Weapons", impactos: "Impacts", "explosoes-fogo": "Explosions and fire", personagem: "Character", veiculos: "Vehicles", "itens-portas": "Items and doors", ambiente: "Ambience", calibracao: "Calibration (SDK)" },
+  blows: { bullet: "bullet", blunt: "punch/kick", blade: "knife", break: "break", drag: "drag/fall" },
+  materials: {
+    steel: "steel",
+    aluminium: "aluminium",
+    wood: "wood",
+    plywood: "plywood",
+    mdf: "MDF",
+    glass: "glass",
+    tempered_glass: "tempered glass",
+    ceramic: "ceramic",
+    concrete: "concrete",
+    brick: "brick",
+    plaster: "plaster",
+    plastic: "plastic",
+    fabric: "fabric",
+    paper: "cardboard",
+    foliage: "foliage",
+    soil: "soil",
+    flesh: "flesh"
+  },
+  environments: { indoor: "indoor", outdoor: "outdoor" },
+  strengths: { light: "light", medium: "medium", heavy: "heavy" },
+  criteria: { C1: "C1 Sync", C2: "C2 Right sound", C3: "C3 Distance", C4: "C4 Position", C5: "C5 Variation", C6: "C6 Level", C7: "C7 Strength", C8: "C8 Tail", C9: "C9 Burst", C10: "C10 Listening" },
+  metrics: { chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
+  run: { idle: "idle", measuring: "measuring\u2026", done: "done", failed: "failed", recording: "recording\u2026", recorded: "recording downloaded" },
+  words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner" },
+  probe: "Sound source",
+  wall: "Wall (occlusion)",
+  scenarios: { pipeline: "File \u2192 decode \u2192 play (round-robin, tail)", criteria: "Criteria C1\u2013C9 on the calibration sound", loop: "File loop: seamless joins (crossfade)", panel: "Panel: categories, matrix, A/B and wall" }
+};
+var soundCheckTextOf = (locale) => locale.startsWith("en") ? EN2 : PT;
+
+// src/bench/sound-check.ts
+var SOUND_STRENGTHS = { light: 0.1, medium: 0.5, heavy: 0.9 };
+var CALIBRATION_CATEGORY = "calibracao";
+var CALIBRATION_BANK = { id: "calibration", samples: [CALIBRATION_SOUND, CALIBRATION_LOOP_SOUND] };
+var DISTANCES2 = [1, 10, 50, 200];
+var PROBE_ID2 = "sound_check_source";
+var WALL_ID = "sound_check_wall";
+var EYE = [0, 1.7, 3];
+var DRAWN_MAX = 11;
+var WALL_AT = -2.5;
+var LOG_LIMIT = 200;
+function createSoundCheckModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const text = soundCheckTextOf(locale);
+  const ownBanks = [CALIBRATION_BANK, ...options.banks ?? []];
+  const loader = calibrationLoader(options.loader ?? fetchLoader());
+  const log = [];
+  const catalog = options.catalog ?? [...SFX_CATALOG, ...SFX_IMPACTS];
+  let engine = options.engine ?? createAudioEngine({ banks: [GAME_SFX_BANK, ...ownBanks], samples: { loader } });
+  if (options.engine) for (const bank of ownBanks) engine.register(bank);
+  let host = null;
+  let results = [];
+  let run = "idle";
+  const verdicts = {};
+  const approvals = /* @__PURE__ */ new Set();
+  let blind = null;
+  const chosen = {
+    category: options.sound && options.sound !== CALIBRATION_ID ? catalog.find((entry) => entry.id === options.sound)?.category ?? CALIBRATION_CATEGORY : CALIBRATION_CATEGORY,
+    sound: options.sound ?? CALIBRATION_ID,
+    material: "concrete",
+    blow: "bullet",
+    distance: 10,
+    bearing: 0,
+    environment: "outdoor",
+    strength: "medium",
+    wall: false
+  };
+  const registry = () => engine.registry;
+  const entryOf = (id) => catalog.find((entry) => entry.id === id);
+  const stateOf = (id) => {
+    const entry = entryOf(id);
+    if (entry) return sfxState(entry, registry());
+    return registry().sample(id) ? "file" : registry().sound(id) ? "synth" : "missing";
+  };
+  const pairOf = (id) => {
+    const entry = entryOf(id);
+    const sample = registry().sample(id);
+    const current = entry?.current ?? sample?.fallback ?? (registry().sound(id) ? id : void 0);
+    return { a: current && registry().sound(current) ? current : null, b: sample ? id : null };
+  };
+  const soundsOf = (category) => {
+    if (category === CALIBRATION_CATEGORY) return registry().sampleIds().filter((id) => !entryOf(id));
+    return catalog.filter((entry) => entry.category === category).map((entry) => entry.id);
+  };
+  const label = (id) => {
+    const entry = entryOf(id);
+    return `${id}${entry ? ` \xB7 P${entry.priority}` : ""} \xB7 ${text.states[stateOf(id)]}`;
+  };
+  const soundOptions = () => soundsOf(chosen.category).map((id) => ({ id, name: label(id) }));
+  const listener = () => {
+    const camera = host?.camera;
+    const three = host?.THREE;
+    if (typeof camera?.getWorldDirection !== "function" || typeof three?.Vector3 !== "function" || !camera.position) return { position: EYE, yaw: 0 };
+    const direction = camera.getWorldDirection(new three.Vector3());
+    return { position: [camera.position.x, camera.position.y, camera.position.z], yaw: Math.atan2(-direction.x, -direction.z) };
+  };
+  const offset = (ears, distance) => {
+    const bearing = chosen.bearing * Math.PI / 180;
+    const forward = [-Math.sin(ears.yaw), -Math.cos(ears.yaw)];
+    const right = [Math.cos(ears.yaw), -Math.sin(ears.yaw)];
+    return [ears.position[0] + distance * (forward[0] * Math.cos(bearing) + right[0] * Math.sin(bearing)), ears.position[1], ears.position[2] + distance * (forward[1] * Math.cos(bearing) + right[1] * Math.sin(bearing))];
+  };
+  const playOptions = (extra = {}) => {
+    const ears = listener();
+    engine.setListener(ears);
+    return { position: offset(ears, chosen.distance), environment: chosen.environment, intensity: SOUND_STRENGTHS[chosen.strength], occlusion: chosen.wall ? 1 : 0, ...extra };
+  };
+  const playId = (id, extra = {}) => {
+    if (!id) return null;
+    engine.unlock();
+    return engine.play(id, playOptions(extra));
+  };
+  const preferred = (id) => pairOf(id).b ?? pairOf(id).a ?? (registry().sound(id) ? id : null);
+  const play = () => playId(preferred(chosen.sound));
+  const playB = async (delay = 0) => {
+    const { b } = pairOf(chosen.sound);
+    if (!b) return;
+    if (engine.sampleStatus(b) !== "ready") await engine.loadSamples([b]);
+    playId(b, { delay });
+  };
+  const playA = (delay = 0) => void playId(pairOf(chosen.sound).a, { delay });
+  const placeScenery = () => {
+    const scene = host?.scene;
+    if (typeof scene?.traverse !== "function") return;
+    const at = offset({ position: EYE, yaw: 0 }, Math.min(chosen.distance, DRAWN_MAX));
+    scene.traverse((object) => {
+      if (object.userData?.[PROBE_ID2] === true) object.position?.set(at[0], 0, at[2]);
+      if (object.userData?.[WALL_ID] === true) object.visible = chosen.wall;
+    });
+  };
+  const measure = async () => {
+    run = "measuring";
+    try {
+      engine.unlock();
+      const context = engine.output()?.context ?? null;
+      const bank = {
+        id: "measured",
+        sounds: registry().soundIds().map((id) => registry().sound(id)).filter((recipe) => recipe !== void 0),
+        loops: registry().loopIds().map((id) => registry().loop(id)).filter((recipe) => recipe !== void 0),
+        samples: registry().sampleIds().map((id) => registry().sample(id)).filter((sample) => sample !== void 0)
+      };
+      results = await measureCriteria({
+        sound: chosen.sound,
+        banks: [bank],
+        loader,
+        ...context ? { baseLatency: context.baseLatency ?? 0, outputLatency: context.outputLatency ?? 0 } : {},
+        ...options.actions?.[chosen.sound] ? { actions: options.actions[chosen.sound] } : {},
+        ...options.loudnessOrder ? { loudnessOrder: options.loudnessOrder } : {}
+      });
+      if (approvals.has(chosen.sound)) results = results.map((result) => result.id === "C10" ? { ...result, pass: true, value: text.words.approved } : result);
+      run = "done";
+    } catch (error) {
+      run = "failed";
+      results = [{ id: "C1", pass: false, value: error instanceof Error ? error.message : String(error), target: "" }];
+    }
+    ;
+    globalThis.__soundCheck = { sound: chosen.sound, results };
+    return results;
+  };
+  const record = async () => {
+    run = "recording";
+    const blob = await recordOutput(engine, 3, () => {
+      for (let index = 0; index < 4; index++) playId(preferred(chosen.sound), { delay: index * 0.6 });
+    });
+    const documentLike = globalThis.document;
+    if (blob && documentLike && typeof URL.createObjectURL === "function") {
+      const link = documentLike.createElement("a");
+      link.href = URL.createObjectURL(blob);
+      link.download = `${chosen.sound}-${chosen.environment}-${chosen.distance}m.webm`;
+      link.click();
+      run = "recorded";
+    } else run = blob ? "recorded" : "failed";
+  };
+  const approve = () => {
+    approvals.add(chosen.sound);
+    results = results.map((result) => result.id === "C10" ? { ...result, pass: true, value: text.words.approved } : result);
+    host?.log(`${chosen.sound}: C10 ${text.words.approved}`, { sound: chosen.sound }, "sound");
+  };
+  const prefer = (side) => {
+    verdicts[chosen.sound] = side;
+    const pair = pairOf(chosen.sound);
+    host?.log(`${chosen.sound}: ${text.words.prefers} ${side}`, { sound: chosen.sound, prefers: side, a: pair.a, b: pair.b }, "sound");
+  };
+  const controls = () => [
+    { kind: "choice", id: "category", name: text.controls.category, options: [...SFX_CATEGORIES, CALIBRATION_CATEGORY].map((id) => ({ id, name: text.categories[id] ?? id })), default: chosen.category },
+    { kind: "choice", id: "sound", name: text.controls.sound, hint: text.hints.sound, options: soundOptions(), default: chosen.sound },
+    { kind: "action", id: "play", name: text.controls.play },
+    { kind: "choice", id: "material", name: text.controls.material, options: SFX_MATERIALS.map(([id]) => ({ id, name: text.materials[id] })), default: chosen.material },
+    { kind: "choice", id: "blow", name: text.controls.blow, options: SFX_BLOWS.map((id) => ({ id, name: text.blows[id] })), default: chosen.blow },
+    { kind: "action", id: "strike", name: text.controls.strike, hint: text.hints.strike },
+    { kind: "choice", id: "distance", name: text.controls.distance, options: DISTANCES2.map((meters) => ({ id: String(meters), name: `${meters} m` })), default: String(chosen.distance) },
+    { kind: "number", id: "bearing", name: text.controls.bearing, unit: "\xB0", min: -180, max: 180, step: 15, default: chosen.bearing },
+    { kind: "choice", id: "environment", name: text.controls.environment, options: SAMPLE_ENVIRONMENTS.map((id) => ({ id, name: text.environments[id] })), default: chosen.environment },
+    { kind: "choice", id: "strength", name: text.controls.strength, options: Object.keys(SOUND_STRENGTHS).map((id) => ({ id, name: text.strengths[id] })), default: chosen.strength },
+    { kind: "boolean", id: "wall", name: text.controls.wall, hint: text.hints.wall, default: chosen.wall },
+    { kind: "action", id: "burst", name: text.controls.burst, hint: text.hints.burst },
+    { kind: "action", id: "play_a", name: text.controls.play_a },
+    { kind: "action", id: "play_b", name: text.controls.play_b },
+    { kind: "action", id: "ab_cycle", name: text.controls.ab_cycle, hint: text.hints.ab_cycle },
+    { kind: "action", id: "blind", name: text.controls.blind, hint: text.hints.blind },
+    { kind: "action", id: "reveal", name: text.controls.reveal },
+    { kind: "action", id: "prefer_a", name: text.controls.prefer_a },
+    { kind: "action", id: "prefer_b", name: text.controls.prefer_b },
+    { kind: "action", id: "measure", name: text.controls.measure, hint: text.hints.measure },
+    { kind: "action", id: "record", name: text.controls.record, hint: text.hints.record },
+    { kind: "action", id: "approve", name: text.controls.approve, hint: text.hints.approve }
+  ];
+  const line = (id) => {
+    const result = results.find((entry) => entry.id === id);
+    if (!result) return text.words.none;
+    return `${result.pass === null ? "\u25CC" : result.pass ? "\u2713" : "\u2717"} ${result.value}`;
+  };
+  const counts = () => {
+    const states = catalog.map((entry) => sfxState(entry, registry()));
+    const count = (state) => states.filter((each) => each === state).length;
+    return `${text.states.file} ${count("file")} \xB7 ${text.states.synth} ${count("synth")} \xB7 ${text.states.missing} ${count("missing")}`;
+  };
+  const strikeId = () => impactSoundId(chosen.material, chosen.blow);
+  const lastLine = () => {
+    const last = log.at(-1);
+    if (!last) return text.words.none;
+    const files = last.layers?.map((layer) => layer.url.split("/").pop()).join("+") ?? "";
+    return `${last.kind}:${last.fallbackOf ? `${last.fallbackOf}\u2192` : ""}${last.id}${last.tier ? `/${last.tier}` : ""} ${files}`.trim();
+  };
+  const metrics = () => [
+    { id: "count", name: text.metrics.count, read: counts },
+    { id: "chosen", name: text.metrics.chosen, read: () => `${label(chosen.sound)}${registry().sample(chosen.sound) ? ` (${engine.sampleStatus(chosen.sound)})` : ""}` },
+    { id: "matrix", name: text.metrics.matrix, read: () => `${strikeId()} \xB7 ${text.states[stateOf(strikeId())]}${pairOf(strikeId()).a ? ` \xB7 A=${pairOf(strikeId()).a}` : ""}` },
+    { id: "ab", name: text.metrics.ab, read: () => `A ${pairOf(chosen.sound).a ?? text.words.none} \xB7 B ${pairOf(chosen.sound).b ?? text.words.none}` },
+    { id: "blind_state", name: text.metrics.blind, read: () => !blind ? text.words.none : blind.revealed ? `X = ${blind.side}` : text.words.hidden },
+    { id: "verdicts", name: text.metrics.verdicts, read: () => Object.entries(verdicts).map(([id, side]) => `${id} ${text.words.prefers} ${side}`).join("; ") || text.words.none },
+    { id: "last", name: text.metrics.last, read: lastLine },
+    { id: "state", name: text.metrics.state, read: () => text.run[run] },
+    ...CRITERIA.map((id) => ({ id: `criterion_${id.toLowerCase()}`, name: text.criteria[id], read: () => line(id) }))
+  ];
+  const act = (id) => {
+    if (id === "play") play();
+    else if (id === "strike") playId(preferred(strikeId()));
+    else if (id === "burst") for (let index = 0; index < 20; index++) playId(preferred(chosen.sound), { delay: index * 0.06 });
+    else if (id === "play_a") playA();
+    else if (id === "play_b") void playB();
+    else if (id === "ab_cycle") {
+      playA(0);
+      void playB(1).then(() => {
+        playA(2);
+        return playB(3);
+      });
+    } else if (id === "blind") {
+      const side = Math.random() < 0.5 ? "A" : "B";
+      blind = { side, revealed: false };
+      if (side === "A") playA();
+      else void playB();
+    } else if (id === "reveal" && blind) blind.revealed = true;
+    else if (id === "prefer_a") prefer("A");
+    else if (id === "prefer_b") prefer("B");
+    else if (id === "measure") void measure();
+    else if (id === "record") void record();
+    else if (id === "approve") approve();
+  };
+  const onChange = (change) => {
+    if (change.kind === "action") return act(change.id);
+    if (change.kind !== "control") return;
+    const { id, value } = change;
+    if (id === "category" && typeof value === "string") {
+      chosen.category = value;
+      const first = soundsOf(value)[0];
+      if (first) chosen.sound = first;
+      host?.bench?.patch("sound", { options: soundOptions(), value: chosen.sound });
+      results = [];
+    } else if (id === "sound" && typeof value === "string") {
+      chosen.sound = value;
+      results = [];
+      if (registry().sample(value)) void engine.loadSamples([value]);
+    } else if (id === "material" && typeof value === "string") chosen.material = value;
+    else if (id === "blow" && typeof value === "string") chosen.blow = value;
+    else if (id === "distance" && typeof value === "string") chosen.distance = Number(value);
+    else if (id === "bearing" && typeof value === "number") chosen.bearing = value;
+    else if (id === "environment" && (value === "indoor" || value === "outdoor")) chosen.environment = value;
+    else if (id === "strength" && typeof value === "string" && value in SOUND_STRENGTHS) chosen.strength = value;
+    else if (id === "wall" && typeof value === "boolean") chosen.wall = value;
+    placeScenery();
+  };
+  const items = () => {
+    const marked = (id, name, build) => ({
+      id,
+      name,
+      movable: false,
+      build: (THREE) => {
+        const root = build(THREE);
+        root.userData = root.userData ?? {};
+        root.userData[id] = true;
+        return root;
+      }
+    });
+    return [...options.probe ? [marked(PROBE_ID2, text.probe, options.probe)] : [], ...options.wall ? [marked(WALL_ID, text.wall, options.wall)] : []];
+  };
+  const area = () => ({
+    placements: [
+      ...options.probe ? [{ item: PROBE_ID2, position: offset({ position: EYE, yaw: 0 }, Math.min(chosen.distance, DRAWN_MAX)), asleep: true }] : [],
+      ...options.wall ? [{ item: WALL_ID, position: [0, 0, WALL_AT], asleep: true }] : []
+    ],
+    view: { eye: EYE, target: [0, 1.2, -8] }
+  });
+  const scenarios = () => [
+    {
+      id: "sample_pipeline",
+      name: text.scenarios.pipeline,
+      run: async ({ expect }) => {
+        const report = await engine.loadSamples([CALIBRATION_ID]);
+        expect(report.failed.length === 0 && engine.sampleStatus(CALIBRATION_ID) === "ready", "the calibration files load and decode", { failed: report.failed });
+        const started = [];
+        const offStarted = engine.watchVoices((event) => void started.push(event));
+        const handles = Array.from({ length: 6 }, (_, index) => engine.play(CALIBRATION_ID, { distance: 2, environment: index % 2 === 0 ? "indoor" : "outdoor" }));
+        offStarted();
+        expect(handles.every((handle) => handle?.kind === "sample"), "it plays the files, not the fallback", { kinds: handles.map((handle) => handle?.kind) });
+        const events = started.filter((event) => event.id === CALIBRATION_ID);
+        const takes = events.map((event) => event.layers?.find((layer) => layer.role === "close")?.url);
+        expect(takes.length === 6 && takes.every((take, index) => index === 0 || take !== takes[index - 1]), "never the same take twice in a row", { takes });
+        const tails = events.map((event) => event.layers?.find((layer) => layer.role === "tail")?.url ?? "");
+        expect(tails[0]?.endsWith("tail_in.wav") === true && tails[1]?.endsWith("tail_out.wav") === true, "the tail follows the place", { tails });
+        for (const handle of handles) handle?.stop();
+      }
+    },
+    {
+      id: "sample_criteria",
+      name: text.scenarios.criteria,
+      run: async ({ expect }) => {
+        const previous = chosen.sound;
+        chosen.sound = CALIBRATION_ID;
+        const measured = await measure();
+        chosen.sound = previous;
+        for (const result of measured) if (result.id !== "C10") expect(result.pass === true, `${result.id}: ${result.target}`, { value: result.value, data: result.data });
+      }
+    },
+    {
+      id: "sample_loop",
+      name: text.scenarios.loop,
+      run: async ({ expect }) => {
+        const report = await engine.loadSamples([CALIBRATION_LOOP_ID]);
+        expect(report.failed.length === 0, "the loop takes load and decode", { failed: report.failed });
+        engine.unlock();
+        engine.level("ambience");
+        const loop = engine.loop(CALIBRATION_LOOP_ID, { volume: 0.8 });
+        const wait = (ms2) => new Promise((resolve) => setTimeout(resolve, ms2));
+        const started = performance.now();
+        while (engine.level("ambience") < 0.01 && performance.now() - started < 2e3) await wait(20);
+        expect(performance.now() - started < 2e3, "the loop starts within 2 s", { ms: Math.round(performance.now() - started) });
+        await wait(200);
+        const levels = [];
+        for (let index = 0; index < 60; index++) {
+          levels.push(engine.level("ambience"));
+          await wait(40);
+        }
+        loop.stop();
+        const sorted = [...levels].sort((a, b) => a - b);
+        const median = sorted[Math.floor(sorted.length / 2)] ?? 0;
+        const lowest = sorted[0] ?? 0;
+        const dip = lowest > 0 && median > 0 ? 20 * Math.log10(lowest / median) : -Infinity;
+        expect(median > 0.01, "the loop sounds", { median });
+        expect(dip >= -6, "no seam: the level never dips more than 6 dB where two takes cross", { dip: Number(dip.toFixed(1)), lowest, median, levels: levels.map((level) => Number(level.toFixed(3))) });
+        await wait(200);
+        expect(engine.level("ambience") < median / 4, "stop silences it", { after: engine.level("ambience") });
+      }
+    },
+    {
+      id: "sound_panel",
+      name: text.scenarios.panel,
+      run: ({ expect }) => {
+        const categories = SFX_CATEGORIES.map((category) => soundsOf(category).length);
+        expect(categories.every((count) => count > 0), "every category lists its sounds", { categories });
+        expect(soundsOf("impactos").length >= SFX_MATERIALS.length * SFX_BLOWS.length, "the matrix has every material \xD7 blow");
+        const pair = pairOf(CALIBRATION_ID);
+        expect(pair.a === "sfx_pistol" && pair.b === CALIBRATION_ID, "A is the synthesized sound and B the file", pair);
+        const clear = engine.planSample(CALIBRATION_ID, { position: [0, 1.6, -10], occlusion: 0, seed: 1 });
+        const walled = engine.planSample(CALIBRATION_ID, { position: [0, 1.6, -10], occlusion: 1, seed: 1 });
+        expect((walled?.cutoff ?? Infinity) < (clear?.cutoff ?? 0) / 5, "behind the wall the sound is muffled", { clear: clear?.cutoff, walled: walled?.cutoff });
+      }
+    }
+  ];
+  return {
+    id: "sound_check_area",
+    name: text.name,
+    group: text.group,
+    ground: { surface: "concrete_slab" },
+    get engine() {
+      return engine;
+    },
+    items: () => items(),
+    area: () => area(),
+    controls: () => controls(),
+    metrics: () => metrics(),
+    scenarios: () => scenarios(),
+    measure,
+    results: () => results,
+    events: () => log,
+    play,
+    pair: () => pairOf(chosen.sound),
+    verdicts: () => ({ ...verdicts }),
+    approvals: () => [...approvals],
+    // the engine (and its context) is made on the first play or measure, not when the room loads the module
+    attach(lent) {
+      host = lent;
+      const shared = options.engine ? void 0 : lent.audio?.engine;
+      if (shared && shared !== engine) {
+        for (const bank of ownBanks) shared.register(bank);
+        shared.addSampleSource(isCalibrationUrl, loader);
+        engine = shared;
+      }
+      const offVoices = engine.watchVoices((event) => {
+        log.push(event);
+        if (log.length > LOG_LIMIT) log.splice(0, log.length - LOG_LIMIT);
+      });
+      lent.bench?.patch("sound", { options: soundOptions() });
+      const off = lent.bench?.onChange(onChange);
+      placeScenery();
+      return () => {
+        off?.();
+        offVoices();
+        host = null;
+      };
+    }
+  };
+}
+
 export {
   createRng,
   streamSeed,
@@ -2203,33 +4081,90 @@ export {
   busPriority,
   createVoiceManager,
   planSound,
-  LOOP_START_ABOVE,
-  LOOP_SMOOTHING,
-  createLoopState,
+  SAMPLE_ENVIRONMENTS,
+  DEFAULT_SAMPLE_FALLOFF,
+  DEFAULT_CROSSOVER,
+  DEFAULT_SAMPLE_PITCH,
+  DEFAULT_TAIL_GAIN,
+  DEFAULT_SAMPLE_CUTOFF_K,
+  OPEN_CUTOFF,
+  LAYER_FLOOR,
+  pickTake,
+  farMixAt,
+  crossGains,
+  sampleCutoff,
+  sampleUrls,
+  tierFor,
+  planSample,
+  CALIBRATION_ID,
+  encodeWav,
+  CALIBRATION_SOUND,
+  CALIBRATION_LOOP_ID,
+  CALIBRATION_LOOP_SOUND,
+  isCalibrationUrl,
+  calibrationLoader,
+  createSoundRegistry,
   MIX_PROFILES,
   DEFAULT_MIX,
   resolveMix,
   busGain,
-  createSoundRegistry,
-  GAME_SFX_CLASSES,
-  GAME_SFX_FALLBACK,
-  noiseClassRecipe,
-  GAME_SFX_BANK,
-  LIBRARY_SOUNDS,
-  LIBRARY_LOOPS,
-  LIBRARY_BANK,
-  retunePlan,
-  createSetPicker,
   fillNoise,
   fillImpulse,
   bufferOf,
   buildChain,
   globalContext,
   unlockContext,
+  LOOP_START_ABOVE,
+  LOOP_SMOOTHING,
+  createLoopState,
+  DEFAULT_LOOP_CROSSFADE,
+  loopCrossfade,
+  CROSSFADE_STEPS,
+  equalPowerIn,
   realize,
+  retunePlan,
+  createSetPicker,
+  fetchLoader,
+  inlineLoader,
+  createSampleStore,
+  realizeSample,
+  sampleLength,
+  limiterCurve2 as limiterCurve,
   createAudioEngine,
+  dbOf,
+  peakOf,
+  peakIndex,
+  onsetIndex,
+  rmsDb,
+  centroidHz,
+  balanceOf,
+  ringSeconds,
+  countHits,
+  endDropDb,
+  CRITERIA,
+  CRITERIA_TARGETS,
+  measureCriteria,
+  recordOutput,
+  SFX_CATEGORIES,
+  SFX_CATALOG,
+  SFX_MATERIALS,
+  SFX_BLOWS,
+  impactSoundId,
+  SFX_IMPACTS,
+  sfxState,
+  GAME_SFX_CLASSES,
+  GAME_SFX_FALLBACK,
+  noiseClassRecipe,
+  GAME_SFX_BANK,
+  LIBRARY_SOUNDS,
+  LIBRARY_LOOPS,
+  LIBRARY_BANK,
   audioBenchTextOf,
   BENCH_BANK,
-  createAudioTestModule
+  createAudioTestModule,
+  soundCheckTextOf,
+  SOUND_STRENGTHS,
+  CALIBRATION_CATEGORY,
+  createSoundCheckModule
 };
-//# sourceMappingURL=chunk-DZITVFMJ.js.map
+//# sourceMappingURL=chunk-7TLFY7VO.js.map