@adatechnology/game-audio 0.3.6 → 0.4.0

package/dist/index.global.js

@@ -22,6 +22,10 @@ var GameAudio = (() => {
   var index_exports = {};
   __export(index_exports, {
     BENCH_BANK: () => BENCH_BANK,
+    BODY_FALLOFF: () => BODY_FALLOFF,
+    BODY_FOLEY_BANK: () => BODY_FOLEY_BANK,
+    BODY_FOLEY_SET_IDS: () => BODY_FOLEY_SET_IDS,
+    BODY_FOLEY_TAKES: () => BODY_FOLEY_TAKES,
     BUILD_ORDERS: () => BUILD_ORDERS,
     BUS_IDS: () => BUS_IDS,
     BUS_PRIORITY: () => BUS_PRIORITY,
@@ -29,6 +33,7 @@ var GameAudio = (() => {
     DEFAULT_MAX_VOICES: () => DEFAULT_MAX_VOICES,
     DEFAULT_MIX: () => DEFAULT_MIX,
     DISTANCE_CURVES: () => DISTANCE_CURVES,
+    FOOTSTEP_FALLOFF: () => FOOTSTEP_FALLOFF,
     GAME_SFX_BANK: () => GAME_SFX_BANK,
     GAME_SFX_CLASSES: () => GAME_SFX_CLASSES,
     GAME_SFX_FALLBACK: () => GAME_SFX_FALLBACK,
@@ -51,6 +56,7 @@ var GameAudio = (() => {
     createAudioTestModule: () => createAudioTestModule,
     createLoopState: () => createLoopState,
     createRng: () => createRng,
+    createSetPicker: () => createSetPicker,
     createSoundRegistry: () => createSoundRegistry,
     createVoiceManager: () => createVoiceManager,
     cutoffDivisor: () => cutoffDivisor,
@@ -66,6 +72,7 @@ var GameAudio = (() => {
     planSound: () => planSound,
     realize: () => realize,
     resolveMix: () => resolveMix,
+    retunePlan: () => retunePlan,
     sceneMany: () => sceneMany,
     sceneNoise: () => sceneNoise,
     sceneRecipe: () => sceneRecipe,
@@ -197,7 +204,7 @@ var GameAudio = (() => {
       if (!group) return void 0;
       if (group.maxDistance !== void 0 && !((request.distance ?? 0) < group.maxDistance)) return "distance";
       if (group.cooldown !== void 0 && (budgets.get(request.group) ?? 0) > 0) return "cooldown";
-      const members = voices.filter((voice) => voice.group === request.group);
+      const members = voices.filter((voice2) => voice2.group === request.group);
       if (group.maxConcurrent === void 0 || members.length < group.maxConcurrent) return void 0;
       if (!group.steal) return "group_full";
       evicted.push(members[0].id);
@@ -209,9 +216,9 @@ var GameAudio = (() => {
         const refusal = groupCheck(request, evicted);
         if (refusal) return refuse(refusal);
         const score = request.priority * request.gain;
-        const remaining = voices.filter((voice) => !evicted.includes(voice.id));
+        const remaining = voices.filter((voice2) => !evicted.includes(voice2.id));
         if (remaining.length >= maxVoices) {
-          const lowest = remaining.reduce((low, voice) => voice.score < low.score ? voice : low);
+          const lowest = remaining.reduce((low, voice2) => voice2.score < low.score ? voice2 : low);
           if (score <= lowest.score) return refuse("global_full");
           evicted.push(lowest.id);
           dropped += 1;
@@ -219,25 +226,25 @@ var GameAudio = (() => {
         const group = request.group === void 0 ? void 0 : groups.get(request.group);
         if (group?.cooldown !== void 0) budgets.set(request.group, group.cooldown);
         const id = nextId++;
-        voices = [...voices.filter((voice) => !evicted.includes(voice.id)), { id, ...request.group === void 0 ? {} : { group: request.group }, score, remaining: request.length }];
+        voices = [...voices.filter((voice2) => !evicted.includes(voice2.id)), { id, ...request.group === void 0 ? {} : { group: request.group }, score, remaining: request.length }];
         peak = Math.max(peak, voices.length);
         return { accepted: true, id, evicted };
       },
       release(id) {
-        voices = voices.filter((voice) => voice.id !== id);
+        voices = voices.filter((voice2) => voice2.id !== id);
       },
       setLength(id, seconds) {
-        const voice = voices.find((entry) => entry.id === id);
-        if (voice) voice.remaining = seconds;
+        const voice2 = voices.find((entry) => entry.id === id);
+        if (voice2) voice2.remaining = seconds;
       },
       advance(dt) {
         for (const [group, budget] of budgets) budgets.set(group, budget - dt);
         const ended = [];
-        for (const voice of voices) {
-          voice.remaining -= dt;
-          if (voice.remaining <= 0) ended.push(voice.id);
+        for (const voice2 of voices) {
+          voice2.remaining -= dt;
+          if (voice2.remaining <= 0) ended.push(voice2.id);
         }
-        if (ended.length > 0) voices = voices.filter((voice) => voice.remaining > 0);
+        if (ended.length > 0) voices = voices.filter((voice2) => voice2.remaining > 0);
         return ended;
       },
       setGroup(id, group) {
@@ -345,14 +352,14 @@ var GameAudio = (() => {
     const source = layer.source;
     if (source.kind === "noise") return { kind: "noise", offset, loop: source.loop === true };
     if (source.kind === "osc") return { kind: "osc", wave: source.wave, frequency: finishAutomation(pending.automation ?? {}, duration) };
-    const voice = pending.voice;
+    const voice2 = pending.voice;
     return {
       kind: "formant_voice",
       wave: source.wave,
-      frequency: finishAutomation(voice.frequency, duration),
-      vibrato: { rate: voice.vibratoRate, depth: startFrequency(voice.frequency) * source.vibrato.depth },
-      formants: voice.formants,
-      breath: { ...voice.breath, offset },
+      frequency: finishAutomation(voice2.frequency, duration),
+      vibrato: { rate: voice2.vibratoRate, depth: startFrequency(voice2.frequency) * source.vibrato.depth },
+      formants: voice2.formants,
+      breath: { ...voice2.breath, offset },
       mix: source.mix
     };
   }
@@ -408,51 +415,51 @@ var GameAudio = (() => {
     return { ...layer, filters: { ...layer.filters, bank } };
   }
   var layerEnd = (layer) => layer.at + layer.duration + layer.tail;
-  function planSound(recipe, input = {}) {
+  function planSound(recipe2, input = {}) {
     const listener = input.listener ?? DEFAULT_LISTENER;
     const distance = input.distance ?? (input.position ? listenerDistance(listener, input.position, input.distanceMode) : 0);
     const occlusion = Math.min(1, Math.max(0, input.occlusion ?? 0));
-    const order = recipe.order ?? "layered";
-    const falloffLevel = falloffGain(recipe.falloff, input.volume ?? 1, distance);
+    const order = recipe2.order ?? "layered";
+    const falloffLevel = falloffGain(recipe2.falloff, input.volume ?? 1, distance);
     const level = occlusion > 0 ? falloffLevel * (1 - OCCLUSION_GAIN * occlusion) : falloffLevel;
-    const silent = isSilent(recipe.falloff, falloffLevel);
+    const silent = isSilent(recipe2.falloff, falloffLevel);
     const base = {
-      id: recipe.id,
-      bus: recipe.bus,
+      id: recipe2.id,
+      bus: recipe2.bus,
       order,
-      ...recipe.group === void 0 ? {} : { group: recipe.group },
-      priority: recipe.priority ?? busPriority(recipe.bus),
+      ...recipe2.group === void 0 ? {} : { group: recipe2.group },
+      priority: recipe2.priority ?? busPriority(recipe2.bus),
       level,
       distance,
-      ...recipe.pan ? { pan: input.position ? panFor(listener, input.position) : 0 } : {}
+      ...recipe2.pan ? { pan: input.position ? panFor(listener, input.position) : 0 } : {}
     };
-    if (silent) return recipe.keepSilent ? { ...base, silent: true, length: 0, layers: [] } : null;
+    if (silent) return recipe2.keepSilent ? { ...base, silent: true, length: 0, layers: [] } : null;
     const scope = { random: input.random ?? createRng(1), params: { ...input.params } };
-    for (const [name, range] of Object.entries(recipe.vars ?? {})) if (scope.params[name] === void 0) scope.params[name] = draw(range, scope);
+    for (const [name, range] of Object.entries(recipe2.vars ?? {})) if (scope.params[name] === void 0) scope.params[name] = draw(range, scope);
     const defaults = {
-      ...recipe.duration === void 0 ? {} : { duration: draw(recipe.duration, scope) },
-      ...recipe.tail === void 0 ? {} : { tail: recipe.tail },
+      ...recipe2.duration === void 0 ? {} : { duration: draw(recipe2.duration, scope) },
+      ...recipe2.tail === void 0 ? {} : { tail: recipe2.tail },
       noiseSeconds: input.noiseSeconds ?? DEFAULT_NOISE_SECONDS
     };
-    const divisor = cutoffDivisor(recipe.falloff, distance) / (1 - OCCLUSION_CUTOFF * occlusion);
-    const layers = recipe.layers.flatMap((layer) => planLayer(layer, scope, defaults, order !== "layered", level)).map((layer) => muffle(layer, divisor));
+    const divisor = cutoffDivisor(recipe2.falloff, distance) / (1 - OCCLUSION_CUTOFF * occlusion);
+    const layers = recipe2.layers.flatMap((layer) => planLayer(layer, scope, defaults, order !== "layered", level)).map((layer) => muffle(layer, divisor));
     return { ...base, silent: false, length: Math.max(0, ...layers.map(layerEnd)), layers };
   }
 
   // src/loops.ts
   var LOOP_START_ABOVE = 2e-3;
   var LOOP_SMOOTHING = { volume: 0.15, frequency: 0.08 };
-  function createLoopState(recipe, open = false) {
-    const startAbove = recipe.startAbove ?? LOOP_START_ABOVE;
+  function createLoopState(recipe2, open = false) {
+    const startAbove = recipe2.startAbove ?? LOOP_START_ABOVE;
     let created = open;
-    let volume = recipe.volume ?? 0;
+    let volume = recipe2.volume ?? 0;
     return {
       set(state) {
         volume = state.volume ?? volume;
         const create = !created;
         if (create && !(volume >= startAbove)) return null;
         created = true;
-        const frequency = recipe.source.kind === "osc" && state.frequency ? state.frequency : void 0;
+        const frequency = recipe2.source.kind === "osc" && state.frequency ? state.frequency : void 0;
         return { create, volume, ...frequency === void 0 ? {} : { frequency } };
       },
       get created() {
@@ -520,6 +527,7 @@ var GameAudio = (() => {
   function createSoundRegistry(banks = []) {
     const sounds = /* @__PURE__ */ new Map();
     const loops = /* @__PURE__ */ new Map();
+    const sets = /* @__PURE__ */ new Map();
     const owners = /* @__PURE__ */ new Map();
     const registry = {
       register(bank) {
@@ -531,6 +539,11 @@ var GameAudio = (() => {
           loops.set(loop.id, loop);
           owners.set(loop.id, bank.id);
         }
+        for (const set of bank.sets ?? []) {
+          if (set.variants.length === 0) throw new Error(`sound set ${set.id} has no variant`);
+          sets.set(set.id, set);
+          owners.set(set.id, bank.id);
+        }
       },
       patch(id, patch) {
         const sound = sounds.get(id);
@@ -541,11 +554,14 @@ var GameAudio = (() => {
       remove(id) {
         sounds.delete(id);
         loops.delete(id);
+        sets.delete(id);
         owners.delete(id);
       },
       sound: (id) => sounds.get(id),
       loop: (id) => loops.get(id),
+      set: (id) => sets.get(id),
       soundIds: () => [...sounds.keys()],
+      setIds: () => [...sets.keys()],
       loopIds: () => [...loops.keys()],
       bankOf: (id) => owners.get(id)
     };
@@ -780,6 +796,293 @@ var GameAudio = (() => {
   var LIBRARY_LOOPS = [engine_saw_default, rotor_blades_default, crowd_rumble_default];
   var LIBRARY_BANK = { id: "library", sounds: LIBRARY_SOUNDS, loops: LIBRARY_LOOPS };
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing2) => `land_${surface}_${landing2}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+  var SWING_LEAD_SECONDS = { punch: 0.07, kick: 0.09, shove: 0, blade: 0.05, blunt: 0.1, chop: 0.11 };
+
+  // src/recipes/body-foley.ts
+  var BODY_FOLEY_TAKES = 4;
+  var TAKES = [
+    { f: 1, t: 1, v: 1 },
+    { f: 1.08, t: 0.9, v: 0.92 },
+    { f: 0.93, t: 1.12, v: 1.05 },
+    { f: 1.03, t: 1.05, v: 0.88 }
+  ];
+  var FOOTSTEP_FALLOFF = { model: "inverse_square", k: 0.03, cutoffK: 0.03, minGain: 4e-3 };
+  var BODY_FALLOFF = { model: "inverse_square", k: 0.012, cutoffK: 0.015, minGain: 4e-3 };
+  var SURFACES = {
+    concrete: { heel: { f: 95, d: 0.05, vol: 0.55 }, roll: { type: "bandpass", f: 2300, q: 1.1, d: 0.05, vol: 0.38 }, grains: { count: 2, f: 4200, q: 2, spread: 0.04, vol: 0.08 } },
+    asphalt: { heel: { f: 90, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 1700, q: 0.9, d: 0.06, vol: 0.36 }, grains: { count: 4, f: 3600, q: 2.5, spread: 0.06, vol: 0.1 } },
+    wood: { heel: { f: 130, d: 0.08, vol: 0.55 }, roll: { type: "lowpass", f: 1300, q: 0.8, d: 0.06, vol: 0.3 }, ring: [{ f: 210, d: 0.1, vol: 0.18 }, { f: 470, d: 0.06, vol: 0.06 }] },
+    tile: { heel: { f: 110, d: 0.04, vol: 0.45 }, roll: { type: "bandpass", f: 3600, q: 2, d: 0.03, vol: 0.42 }, ring: [{ f: 1900, d: 0.03, vol: 0.05 }] },
+    dirt: { heel: { f: 75, d: 0.06, vol: 0.45 }, roll: { type: "lowpass", f: 750, q: 0.7, d: 0.09, vol: 0.4 }, grains: { count: 3, f: 1800, q: 1.5, spread: 0.07, vol: 0.06 } },
+    grass: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "highpass", f: 2600, q: 0.7, d: 0.13, vol: 0.28 }, grains: { count: 4, f: 5200, q: 1.2, spread: 0.1, vol: 0.07 } },
+    gravel: { heel: { f: 80, d: 0.05, vol: 0.4 }, roll: { type: "lowpass", f: 950, q: 0.8, d: 0.1, vol: 0.3 }, grains: { count: 8, f: 2600, q: 3, spread: 0.13, vol: 0.2 } },
+    sand: { heel: { f: 65, d: 0.06, vol: 0.3 }, roll: { type: "bandpass", f: 1500, q: 0.6, d: 0.16, vol: 0.3 }, grains: { count: 5, f: 4800, q: 1.5, spread: 0.12, vol: 0.05 } },
+    metal: { heel: { f: 120, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 2800, q: 1.5, d: 0.03, vol: 0.25 }, ring: [{ f: 420, d: 0.25, vol: 0.16 }, { f: 1130, d: 0.18, vol: 0.09 }, { f: 2470, d: 0.1, vol: 0.04 }] },
+    water: { heel: { f: 70, d: 0.04, vol: 0.25 }, roll: { type: "bandpass", f: 3e3, q: 1.2, d: 0.1, vol: 0.18 }, splash: { f: 1100, f2: 380, d: 0.22, vol: 0.55 }, grains: { count: 4, f: 2400, q: 6, spread: 0.18, vol: 0.12 } },
+    glass: { heel: { f: 90, d: 0.04, vol: 0.4 }, roll: { type: "highpass", f: 4500, q: 0.8, d: 0.06, vol: 0.2 }, grains: { count: 9, f: 6200, q: 5, spread: 0.12, vol: 0.22 }, ring: [{ f: 3900, d: 0.04, vol: 0.04 }, { f: 5300, d: 0.03, vol: 0.03 }] },
+    carpet: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "lowpass", f: 420, q: 0.7, d: 0.07, vol: 0.3 } }
+  };
+  var GAITS = {
+    walk: { vol: 1, bright: 1, toe: 0.075, short: 1 },
+    run: { vol: 1.35, bright: 1.25, toe: 0.035, short: 0.75 }
+  };
+  var grainLayers = (g, take, start, scale) => Array.from(
+    { length: g.count },
+    (_, i) => sceneNoise({ type: "bandpass", f: [g.f * take.f * 0.85, g.f * take.f * 1.15], q: g.q, d: [8e-3, 0.02], vol: g.vol * scale * take.v, delay: start + (i + 0.5) / g.count * g.spread * take.t })
+  );
+  var ringLayers = (rings, take, scale, at = 0) => rings.map((r) => sceneTone({ f: r.f * take.f, d: r.d * take.t, vol: r.vol * scale * take.v, delay: at }));
+  function footLayers(surface, take, gait, weight = 1) {
+    const s = SURFACES[surface];
+    const toe = gait.toe * take.t;
+    return [
+      sceneTone({ f: s.heel.f * take.f * weight ** -0.3, f2: s.heel.f * take.f * 0.6, d: s.heel.d * gait.short * take.t * weight ** 0.5, vol: s.heel.vol * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: "lowpass", f: 500 * gait.bright, d: 0.02 * take.t, vol: 0.18 * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: s.roll.type, f: [s.roll.f * take.f * gait.bright * 0.92, s.roll.f * take.f * gait.bright * 1.08], q: s.roll.q, d: s.roll.d * gait.short * take.t * weight ** 0.3, vol: s.roll.vol * gait.vol * take.v, delay: toe }),
+      ...s.grains ? grainLayers(s.grains, take, toe * 0.5, gait.vol * weight ** 0.5) : [],
+      ...s.ring ? ringLayers(s.ring, take, gait.vol * weight ** 0.5) : [],
+      ...s.splash ? [sceneNoise({ type: "bandpass", f: s.splash.f * take.f, f2: s.splash.f2 * take.f, q: 1.4, d: s.splash.d * take.t * weight ** 0.4, vol: s.splash.vol * gait.vol * take.v * weight ** 0.5 })] : []
+    ];
+  }
+  var quieter = (level, layers) => layers.map((layer) => {
+    const gain = layer.gain ?? 1;
+    if (typeof gain === "number") return { ...layer, gain: gain * level };
+    if (Array.isArray(gain)) return { ...layer, gain: [gain[0] * level, gain[1] * level] };
+    return layer;
+  });
+  var recipe = (id, layers, falloff, bus = "world") => ({ id, bus, pan: true, layers, falloff, sources: ["sdk"] });
+  var takeId = (id, index) => `${id}_${String(index + 1).padStart(2, "0")}`;
+  function takes(id, layersOf, falloff, rate = [0.96, 1.04], bus) {
+    const sounds = TAKES.map((take, index) => recipe(takeId(id, index), layersOf(take, index), falloff, bus));
+    return { sounds, set: { id, variants: sounds.map((sound) => sound.id), rate } };
+  }
+  var footstep = (surface, gait) => takes(footstepSoundId(surface, gait), (take) => footLayers(surface, take, GAITS[gait]), FOOTSTEP_FALLOFF);
+  var LANDINGS = { light: { weight: 1.4, cloth: 0.12 }, heavy: { weight: 2.4, cloth: 0.22 } };
+  var LANDING_LEVEL = 0.65;
+  var landing = (surface, landing2) => takes(
+    `land_${surface}_${landing2}`,
+    (take) => quieter(LANDING_LEVEL, [
+      // both feet, a hair apart, then the knees taking the weight (a low body thump) and the clothes settling
+      ...footLayers(surface, take, GAITS.run, LANDINGS[landing2].weight),
+      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer) => ({ ...layer, at: (typeof layer.at === "number" ? layer.at : 0) + 0.018 * take.t })),
+      sceneTone({ f: 60 * take.f, f2: 38, d: 0.14 * LANDINGS[landing2].weight * take.t, vol: 0.22 * LANDINGS[landing2].weight ** 0.7 * take.v, delay: 0.02 }),
+      sceneNoise({ type: "bandpass", f: [1800, 2600], q: 0.8, d: 0.18, vol: LANDINGS[landing2].cloth * take.v, delay: 0.04 })
+    ]),
+    FOOTSTEP_FALLOFF
+  );
+  var whoosh = (blow, from, to, d, vol, q = 1.6) => (take) => [
+    // the air: a band sweeping up as the limb speeds up; it peaks `SWING_LEAD_SECONDS` in, the moment before the contact, then dies away
+    sceneNoise({ type: "bandpass", f: from * take.f, f2: to * take.f, q, a: SWING_LEAD_SECONDS[blow], d: d * take.t, vol: vol * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, a: SWING_LEAD_SECONDS[blow], d: d * take.t * 0.8, vol: vol * 0.35 * take.v })
+  ];
+  var fleshHit = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.slapF * take.f, q: 1.2, d: 0.03 * take.t, vol: o.slap * take.v }),
+    sceneNoise({ type: "highpass", f: 3500 * take.f, d: 0.012, vol: o.slap * 0.4 * take.v }),
+    sceneTone({ f: o.thudF * take.f, f2: o.thudF * 0.5, d: o.thudD * take.t, vol: o.thud * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, d: o.thudD * 1.2 * take.t, vol: o.thud * 0.5 * take.v }),
+    ...o.crack ? [sceneNoise({ type: "highpass", f: 2500, d: 0.015, vol: o.crack * take.v, delay: 6e-3 }), sceneTone({ wave: "square", f: 900 * take.f, f2: 300, d: 0.02, vol: o.crack * 0.15 * take.v, delay: 6e-3 })] : [],
+    ...o.wet ? [sceneNoise({ type: "bandpass", f: 1400 * take.f, f2: 500, q: 2.5, d: 0.12 * take.t, vol: o.wet * take.v, delay: 0.01 })] : []
+  ];
+  var knock = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.clickF * take.f, q: 1.5, d: 0.018, vol: o.click * take.v }),
+    ...o.tones.map(([f, d, vol]) => sceneTone({ f: f * take.f, d: d * take.t, vol: vol * take.v }))
+  ];
+  var voice = (o) => (take) => [
+    sceneVoice({ f0: o.f0 * take.f, f1: o.f1 * take.f, d: o.d * take.t, fA: o.fA * take.f, fB: o.fB * take.f, noise: o.noise, vol: o.vol * take.v })
+  ];
+  var BODY = {
+    jump: (take) => [
+      sceneNoise({ type: "bandpass", f: 900 * take.f, f2: 1700 * take.f, q: 1, a: 0.03, d: 0.12, vol: 0.18 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2200 * take.f, q: 0.8, d: 0.04, vol: 0.12 * take.v }),
+      sceneTone({ f: 85 * take.f, f2: 60, d: 0.04, vol: 0.2 * take.v })
+    ],
+    cloth_rustle: (take) => [
+      { ...sceneNoise({ type: "bandpass", f: 2400 * take.f, q: 0.8, a: 0.06, d: 0.22 * take.t, vol: 0.12 * take.v }), modulators: [{ target: "gain", wave: "triangle", rate: [9, 14], depth: 0.5 }] }
+    ],
+    body_fall: (take) => [
+      sceneTone({ f: 58 * take.f, f2: 35, d: 0.28 * take.t, vol: 0.9 * take.v }),
+      sceneNoise({ type: "lowpass", f: 480 * take.f, d: 0.3 * take.t, vol: 0.55 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, q: 1, d: 0.05, vol: 0.3 * take.v }),
+      // the limbs a moment later, and the clothes
+      sceneTone({ f: 75 * take.f, f2: 45, d: 0.12, vol: 0.4 * take.v, delay: 0.13 * take.t }),
+      sceneNoise({ type: "bandpass", f: 2200, q: 0.8, d: 0.2, vol: 0.12 * take.v, delay: 0.05 })
+    ],
+    fall_damage: (take) => [
+      ...BODY.body_fall(take),
+      sceneNoise({ type: "highpass", f: 2800, d: 0.02, vol: 0.35 * take.v, delay: 0.01 }),
+      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer) => ({ ...layer, at: 0.08 }))
+    ],
+    player_hurt: voice({ f0: 150, f1: 105, d: 0.26, fA: 620, fB: 1100, noise: 0.3, vol: 0.35 }),
+    player_breath_run: (take) => [
+      sceneNoise({ type: "bandpass", f: 1200 * take.f, q: 1, a: 0.08, d: 0.22 * take.t, vol: 0.25 * take.v }),
+      sceneNoise({ type: "bandpass", f: 900 * take.f, q: 1, a: 0.06, d: 0.26 * take.t, vol: 0.3 * take.v, delay: 0.3 * take.t })
+    ],
+    player_death: voice({ f0: 135, f1: 68, d: 1, fA: 560, fB: 980, noise: 0.35, vol: 0.4 }),
+    bite: (take) => [
+      sceneNoise({ type: "highpass", f: 2600, d: 0.015, vol: 0.4 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1600 * take.f, f2: 450, q: 2.2, d: 0.16 * take.t, vol: 0.55 * take.v, delay: 0.01 }),
+      sceneNoise({ type: "bandpass", f: 3200 * take.f, f2: 1800, q: 1.2, d: 0.22 * take.t, vol: 0.25 * take.v, delay: 0.09 }),
+      sceneTone({ f: 120 * take.f, f2: 70, d: 0.06, vol: 0.3 * take.v })
+    ],
+    grab: (take) => [
+      sceneNoise({ type: "bandpass", f: 1900 * take.f, q: 0.9, a: 4e-3, d: 0.13 * take.t, vol: 0.32 * take.v }),
+      sceneTone({ f: 95 * take.f, f2: 60, d: 0.07, vol: 0.3 * take.v }),
+      sceneNoise({ type: "lowpass", f: 700, d: 0.08, vol: 0.2 * take.v })
+    ],
+    punch_swing: whoosh("punch", 450, 1500, 0.16, 0.9),
+    punch_hit_body: fleshHit({ slap: 0.55, slapF: 1500, thud: 0.6, thudF: 115, thudD: 0.09 }),
+    punch_hit_face: fleshHit({ slap: 0.75, slapF: 2300, thud: 0.45, thudF: 150, thudD: 0.07, crack: 0.25 }),
+    punch_hit_object: knock({ clickF: 1800, click: 0.3, tones: [[210, 0.04, 0.25]] }),
+    kick_swing: whoosh("kick", 280, 950, 0.22, 1, 1.3),
+    kick_hit: fleshHit({ slap: 0.45, slapF: 1100, thud: 0.85, thudF: 82, thudD: 0.14 }),
+    kick_hit_object: knock({ clickF: 1e3, click: 0.3, tones: [[92, 0.08, 0.5]] }),
+    shove_two_hands: (take) => [
+      sceneNoise({ type: "bandpass", f: 950 * take.f, q: 0.9, a: 0.01, d: 0.13 * take.t, vol: 0.38 * take.v }),
+      sceneTone({ f: 100 * take.f, f2: 60, d: 0.1 * take.t, vol: 0.45 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2300, q: 0.8, d: 0.16, vol: 0.12 * take.v, delay: 0.03 })
+    ],
+    knife_swing: whoosh("blade", 1900, 4600, 0.12, 1.1, 2.2),
+    knife_stab: fleshHit({ slap: 0.2, slapF: 1200, thud: 0.4, thudF: 160, thudD: 0.06, wet: 0.5 }),
+    knife_slash: (take) => [
+      sceneNoise({ type: "highpass", f: 3200 * take.f, f2: 1800, d: 0.13 * take.t, vol: 0.35 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, f2: 600, q: 2.5, d: 0.12 * take.t, vol: 0.35 * take.v, delay: 0.02 })
+    ],
+    knife_hit_object: knock({ clickF: 3200, click: 0.25, tones: [[2800, 0.08, 0.07], [4150, 0.06, 0.05]] }),
+    blunt_swing: whoosh("blunt", 220, 760, 0.28, 1.1, 1.5),
+    blunt_hit: fleshHit({ slap: 0.35, slapF: 900, thud: 1, thudF: 70, thudD: 0.18, crack: 0.3 }),
+    blunt_hit_object: knock({ clickF: 1400, click: 0.35, tones: [[300, 0.12, 0.25], [760, 0.08, 0.12]] }),
+    axe_swing: whoosh("chop", 190, 620, 0.3, 1.2, 1.4),
+    axe_chop: fleshHit({ slap: 0.3, slapF: 1400, thud: 0.75, thudF: 140, thudD: 0.1, crack: 0.35, wet: 0.45 }),
+    axe_hit_object: knock({ clickF: 2200, click: 0.4, tones: [[1500, 0.15, 0.1], [2300, 0.1, 0.06], [140, 0.1, 0.35]] })
+  };
+  var BODY_BUS = { player_hurt: "voices", player_death: "voices", player_breath_run: "voices", fall_damage: "voices" };
+  var built = [
+    ...SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstep(surface, gait))),
+    ...SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((l) => landing(surface, l))),
+    ...BODY_SOUND_IDS.map((id) => takes(id, BODY[id], BODY_FALLOFF, id.endsWith("_swing") ? [0.94, 1.06] : [0.96, 1.04], BODY_BUS[id]))
+  ];
+  var BODY_FOLEY_BANK = {
+    id: "body_foley",
+    sounds: built.flatMap((entry) => entry.sounds),
+    sets: built.map((entry) => entry.set)
+  };
+  var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
+  // src/variation.ts
+  var tuneAutomation = (automation, rate) => {
+    const tuned = { ...automation };
+    if (automation.value !== void 0) tuned.value = automation.value * rate;
+    if (automation.from !== void 0) tuned.from = automation.from * rate;
+    if (automation.to !== void 0) tuned.to = automation.to * rate;
+    if (automation.at !== void 0) tuned.at = automation.at / rate;
+    return tuned;
+  };
+  var tuneFilter = (filter, rate) => ({ ...filter, frequency: tuneAutomation(filter.frequency, rate) });
+  var tuneSource = (source, rate) => {
+    switch (source.kind) {
+      case "noise":
+        return source;
+      case "osc":
+        return { ...source, frequency: tuneAutomation(source.frequency, rate) };
+      case "formant_voice":
+        return {
+          ...source,
+          frequency: tuneAutomation(source.frequency, rate),
+          formants: source.formants.map((formant) => ({ ...formant, frequency: formant.frequency * rate })),
+          breath: { ...source.breath, frequency: source.breath.frequency * rate }
+        };
+    }
+  };
+  var tuneModulator = (modulator, rate) => ({
+    ...modulator,
+    rate: modulator.rate * rate,
+    ...modulator.target === "frequency" ? { depth: modulator.depth * rate } : {}
+  });
+  var tuneLayer = (layer, rate) => ({
+    ...layer,
+    at: layer.at / rate,
+    duration: layer.duration / rate,
+    tail: layer.tail / rate,
+    source: tuneSource(layer.source, rate),
+    ...layer.filters ? { filters: { ...layer.filters, bank: layer.filters.bank.map((filter) => tuneFilter(filter, rate)) } } : {},
+    modulators: layer.modulators.map((modulator) => tuneModulator(modulator, rate)),
+    envelope: layer.envelope.map((point) => ({ ...point, time: point.time / rate }))
+  });
+  function retunePlan(plan, rate) {
+    if (rate === 1 || !(rate > 0)) return plan;
+    return { ...plan, length: plan.length / rate, layers: plan.layers.map((layer) => tuneLayer(layer, rate)) };
+  }
+  function createSetPicker() {
+    const last = /* @__PURE__ */ new Map();
+    return {
+      pick(set, random) {
+        const count = set.variants.length;
+        const previous = last.get(set.id);
+        let index;
+        if (count === 1) index = 0;
+        else if (set.repeat || previous === void 0) index = Math.min(count - 1, Math.floor(random() * count));
+        else {
+          index = Math.min(count - 2, Math.floor(random() * (count - 1)));
+          if (index >= previous) index += 1;
+        }
+        last.set(set.id, index);
+        const [min, max] = set.rate ?? [1, 1];
+        const rate = min === max ? min : min + random() * (max - min);
+        return { id: set.variants[index], rate };
+      },
+      reset: () => last.clear()
+    };
+  }
+
   // src/webaudio/noise.ts
   function fillNoise(random, length) {
     const samples = new Float32Array(length);
@@ -908,11 +1211,11 @@ var GameAudio = (() => {
   // src/webaudio/realize-loop.ts
   var fixed = (range) => typeof range === "number" ? range : 0;
   var fixedFrequency = (automation) => fixed("set" in automation ? automation.set : automation.from);
-  function sourceOf(recipe, target) {
-    if (recipe.source.kind === "noise") return { source: noiseSource(target, true) };
+  function sourceOf(recipe2, target) {
+    if (recipe2.source.kind === "noise") return { source: noiseSource(target, true) };
     const oscillator = target.context.createOscillator();
-    oscillator.type = recipe.source.wave;
-    if (recipe.source.frequency) oscillator.frequency.value = fixedFrequency(recipe.source.frequency);
+    oscillator.type = recipe2.source.wave;
+    if (recipe2.source.frequency) oscillator.frequency.value = fixedFrequency(recipe2.source.frequency);
     return { source: oscillator, frequency: oscillator.frequency };
   }
   function stopAll(sources) {
@@ -925,23 +1228,23 @@ var GameAudio = (() => {
       }
     };
   }
-  function realizeGameLoop(recipe, target) {
+  function realizeGameLoop(recipe2, target) {
     const { context } = target;
     const gain = context.createGain();
-    const filters = (recipe.filters?.bank ?? []).map(() => context.createBiquadFilter());
+    const filters = (recipe2.filters?.bank ?? []).map(() => context.createBiquadFilter());
     gain.gain.value = 0;
     const last = filters.reduce((previous, filter) => previous ? previous.connect(filter) : filter, void 0);
     last?.connect(gain);
     gain.connect(target.output);
-    const { source, frequency } = sourceOf(recipe, target);
-    recipe.filters?.bank.forEach((spec, index) => {
+    const { source, frequency } = sourceOf(recipe2, target);
+    recipe2.filters?.bank.forEach((spec, index) => {
       const filter = filters[index];
       filter.type = spec.type;
       filter.frequency.value = fixedFrequency(spec.frequency);
       if (spec.q !== void 0) filter.Q.value = fixed(spec.q);
     });
     const sources = [source];
-    for (const modulator of recipe.modulators ?? []) {
+    for (const modulator of recipe2.modulators ?? []) {
       const lfo = context.createOscillator();
       const depth = context.createGain();
       const stage = context.createGain();
@@ -961,14 +1264,14 @@ var GameAudio = (() => {
     source.start();
     return { gain, source, ...frequency ? { frequency } : {}, stop: stopAll(sources) };
   }
-  function realizeChainLoop(recipe, target, volume) {
+  function realizeChainLoop(recipe2, target, volume) {
     const { context } = target;
-    const { source, frequency } = sourceOf(recipe, target);
-    const filters = (recipe.filters?.bank ?? []).map(
+    const { source, frequency } = sourceOf(recipe2, target);
+    const filters = (recipe2.filters?.bank ?? []).map(
       (spec) => filterNode(context, { type: spec.type, frequency: { value: fixedFrequency(spec.frequency) }, ...spec.q === void 0 ? {} : { q: fixed(spec.q) } }, target.time)
     );
     const gain = gainNode(context, volume);
-    const lfos = (recipe.modulators ?? []).map((modulator) => {
+    const lfos = (recipe2.modulators ?? []).map((modulator) => {
       const lfo = context.createOscillator();
       if (modulator.wave) lfo.type = modulator.wave;
       lfo.frequency.value = fixed(modulator.rate);
@@ -990,9 +1293,9 @@ var GameAudio = (() => {
   var INERT = { set() {
   }, stop() {
   } };
-  function createLoopHandle(recipe, host, volume) {
-    if (!recipe) return INERT;
-    const loopRecipe = recipe;
+  function createLoopHandle(recipe2, host, volume) {
+    if (!recipe2) return INERT;
+    const loopRecipe = recipe2;
     const isChain = loopRecipe.order === "chain_loop";
     const opening = volume ?? loopRecipe.volume ?? 0;
     const smoothing = loopRecipe.smoothing ?? LOOP_SMOOTHING;
@@ -1083,23 +1386,28 @@ var GameAudio = (() => {
     const maxLatencyMs = options.maxLatencyMs ?? 250;
     let jobs = [];
     let scheduled = false;
+    let attached = false;
+    const runNext = () => {
+      const job = jobs.shift();
+      if (nowMs() - job.queuedAt > maxLatencyMs) job.drop();
+      else job.run();
+    };
     const drain = () => {
       scheduled = false;
+      if (attached) return;
       const began = nowMs();
       while (jobs.length > 0) {
-        const job = jobs.shift();
-        if (nowMs() - job.queuedAt > maxLatencyMs) job.drop();
-        else job.run();
+        runNext();
         if (nowMs() - began >= budgetMs) break;
       }
       if (jobs.length > 0) schedule();
     };
     const schedule = () => {
-      if (scheduled) return;
+      if (scheduled || attached) return;
       scheduled = true;
       scheduleTask(drain);
     };
-    return {
+    const queue = {
       push(job) {
         jobs.push({ ...job, queuedAt: nowMs() });
         schedule();
@@ -1110,8 +1418,33 @@ var GameAudio = (() => {
       },
       get size() {
         return jobs.length;
+      },
+      deferredQueue: () => deferredQueue
+    };
+    const deferredQueue = {
+      id: DEFERRED_QUEUE_ID.AUDIO_VOICES,
+      pending: () => jobs.length,
+      run(deadline, clock) {
+        let ran = 0;
+        while (jobs.length > 0) {
+          runNext();
+          ran++;
+          if (clock() >= deadline) break;
+        }
+        return ran;
+      },
+      flush() {
+        while (jobs.length > 0) runNext();
+      },
+      attach() {
+        attached = true;
+      },
+      detach() {
+        attached = false;
+        if (jobs.length > 0) schedule();
       }
     };
+    return queue;
   }
 
   // src/webaudio/realize-game.ts
@@ -1489,7 +1822,7 @@ var GameAudio = (() => {
   }
 
   // src/webaudio/engine.ts
-  var usesNoise = (recipe) => recipe.layers.some((layer) => layer.source.kind !== "osc");
+  var usesNoise = (recipe2) => recipe2.layers.some((layer) => layer.source.kind !== "osc");
   var planUsesNoise = (plan) => plan.layers.some((layer) => layer.source.kind !== "osc");
   function createAudioEngine(options = {}) {
     const seed = options.seed ?? 1;
@@ -1552,7 +1885,7 @@ var GameAudio = (() => {
       lastTime = context.currentTime;
       if (elapsed > 0) for (const id of voices.advance(elapsed)) active.delete(id);
     };
-    const inputFor = (recipe, playOptions, random) => ({
+    const inputFor = (recipe2, playOptions, random) => ({
       random,
       listener,
       noiseSeconds: mix.noise.seconds,
@@ -1561,7 +1894,7 @@ var GameAudio = (() => {
       ...playOptions.distance === void 0 ? {} : { distance: playOptions.distance },
       ...playOptions.position ? { position: playOptions.position } : {},
       ...playOptions.params ? { params: playOptions.params } : {},
-      ...options.occlusion && playOptions.position && recipe.falloff?.model !== "none" ? { occlusion: options.occlusion(playOptions.position) } : {}
+      ...options.occlusion && playOptions.position && recipe2.falloff?.model !== "none" ? { occlusion: options.occlusion(playOptions.position) } : {}
     });
     const startQueue = options.deferredStart ? createStartQueue(options.deferredStart) : null;
     const build = (plan, store, delay) => {
@@ -1575,20 +1908,20 @@ var GameAudio = (() => {
       });
     };
     const deferVoice = (plan, store, voiceId, delay) => {
-      let built = null;
+      let built2 = null;
       let cancelled = false;
       const pending = {
         get sources() {
-          return built?.sources ?? [];
+          return built2?.sources ?? [];
         },
         stop() {
           cancelled = true;
-          built?.stop();
+          built2?.stop();
         }
       };
       startQueue.push({
         run() {
-          if (!cancelled && context) built = build(plan, store, delay);
+          if (!cancelled && context) built2 = build(plan, store, delay);
         },
         drop() {
           if (voiceId === void 0) return;
@@ -1613,8 +1946,8 @@ var GameAudio = (() => {
         }
       };
     };
-    const admit = (recipe, gain, distance) => {
-      const decision = voices.request({ ...recipe.group ? { group: recipe.group } : {}, priority: recipe.priority ?? busPriority(recipe.bus), gain, distance, length: 0 });
+    const admit = (recipe2, gain, distance) => {
+      const decision = voices.request({ ...recipe2.group ? { group: recipe2.group } : {}, priority: recipe2.priority ?? busPriority(recipe2.bus), gain, distance, length: 0 });
       if (!decision.accepted) return null;
       for (const id of decision.evicted) {
         active.get(id)?.stop();
@@ -1622,22 +1955,31 @@ var GameAudio = (() => {
       }
       return decision.id;
     };
-    const playWith = (id, playOptions, random, store) => {
-      const recipe = registry.sound(id);
-      if (!recipe || busSettings.get(recipe.bus)?.muted) return null;
+    const picker = createSetPicker();
+    const resolve = (id, random, chooser = picker) => {
+      if (registry.sound(id)) return { id, rate: 1 };
+      const set = registry.set(id);
+      return set ? chooser.pick(set, random) : { id, rate: 1 };
+    };
+    const playWith = (asked, playOptions, streamRandom, store) => {
+      const seeded = playOptions.seed === void 0 ? null : createRng(playOptions.seed);
+      const { id, rate } = resolve(asked, seeded ?? streamRandom);
+      const random = seeded ?? streamRandom;
+      const recipe2 = registry.sound(id);
+      if (!recipe2 || busSettings.get(recipe2.bus)?.muted) return null;
       const distance = playOptions.distance ?? (playOptions.position ? listenerDistance(listener, playOptions.position, options.distance) : 0);
-      const level = falloffGain(recipe.falloff, playOptions.volume ?? 1, distance);
-      const silent = isSilent(recipe.falloff, level);
-      if (silent && !recipe.keepSilent) return null;
+      const level = falloffGain(recipe2.falloff, playOptions.volume ?? 1, distance);
+      const silent = isSilent(recipe2.falloff, level);
+      if (silent && !recipe2.keepSilent) return null;
       const audio = ready();
       if (!audio) return null;
       unlockContext(audio);
       advance();
-      const voiceId = silent ? void 0 : admit(recipe, level, distance);
+      const voiceId = silent ? void 0 : admit(recipe2, level, distance);
       if (voiceId === null) return null;
-      if (!silent && usesNoise(recipe)) prepareNoise(store, audio, mix.noise.seconds);
-      const plan = planSound(recipe, inputFor(recipe, playOptions, playOptions.seed === void 0 ? random : createRng(playOptions.seed)));
-      return plan ? start(plan, store, voiceId, playOptions.delay) : null;
+      if (!silent && usesNoise(recipe2)) prepareNoise(store, audio, mix.noise.seconds);
+      const plan = planSound(recipe2, inputFor(recipe2, playOptions, random));
+      return plan ? start(retunePlan(plan, rate), store, voiceId, playOptions.delay) : null;
     };
     const randomFor = (playOptions) => {
       if (playOptions.channel === void 0) return engineRandom;
@@ -1647,9 +1989,11 @@ var GameAudio = (() => {
       named.set(playOptions.channel, stream);
       return stream;
     };
-    const planWith = (id, playOptions, random) => {
-      const recipe = registry.sound(id);
-      return recipe ? planSound(recipe, inputFor(recipe, playOptions, random)) : null;
+    const planWith = (asked, playOptions, random) => {
+      const { id, rate } = resolve(asked, random, createSetPicker());
+      const recipe2 = registry.sound(id);
+      const plan = recipe2 ? planSound(recipe2, inputFor(recipe2, playOptions, random)) : null;
+      return plan ? retunePlan(plan, rate) : null;
     };
     const loopHost = {
       ready,
@@ -1668,8 +2012,8 @@ var GameAudio = (() => {
         const audio = ready();
         if (!audio) return null;
         advance();
-        const recipe = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
-        const voiceId = plan.silent ? void 0 : admit(recipe, plan.level, plan.distance);
+        const recipe2 = { id: plan.id, bus: plan.bus, layers: [], sources: [], priority: plan.priority, ...plan.group ? { group: plan.group } : {} };
+        const voiceId = plan.silent ? void 0 : admit(recipe2, plan.level, plan.distance);
         if (voiceId === null) return null;
         if (planUsesNoise(plan)) prepareNoise(shared, audio, mix.noise.seconds);
         return start(plan, shared, voiceId, playOptions.delay);
@@ -1731,6 +2075,7 @@ var GameAudio = (() => {
         for (const sample of meter.data) sum += sample * sample;
         return Math.sqrt(sum / meter.data.length);
       },
+      deferredQueue: () => startQueue?.deferredQueue() ?? null,
       stats() {
         advance();
         const voiceStats = voices.stats();
@@ -1768,7 +2113,8 @@ var GameAudio = (() => {
           ...request.position ? { position: request.position } : {},
           ...request.volume === void 0 ? {} : { volume: request.volume },
           ...request.params ? { params: request.params } : {},
-          ...request.seed === void 0 ? {} : { seed: request.seed }
+          ...request.seed === void 0 ? {} : { seed: request.seed },
+          ...request.delay === void 0 ? {} : { delay: request.delay }
         });
         if (!handle) return null;
         playing.set(handle.id, handle);