@weasel-js/audio 1.9.4 → 1.10.1

package/dist/index.js

@@ -397,13 +397,15 @@ function createScheduler(opts) {
   let handle = null;
   let flushQueued = false;
   const fireDue = () => {
-    const horizon = opts.now() + lookahead;
+    const now = opts.now();
+    const horizon = now + lookahead;
     const due = [];
     const rest = [];
     for (const entry of queue) (entry.when <= horizon ? due : rest).push(entry);
     queue = rest;
     due.sort((a, b) => a.when - b.when);
     for (const entry of due) {
+      if (entry.waited && entry.when < now) opts.onLate?.(now - entry.when, entry.when);
       try {
         entry.fire(entry.when);
       } catch (err) {
@@ -432,8 +434,9 @@ function createScheduler(opts) {
       handle = null;
     },
     schedule(when, fire, key) {
-      queue.push({ when, fire, key });
-      if (running && !flushQueued && when <= opts.now() + lookahead) {
+      const waited = when > opts.now() + lookahead;
+      queue.push({ when, fire, key, waited });
+      if (running && !flushQueued && !waited) {
         flushQueued = true;
         queueMicrotask(flush);
       }
@@ -943,7 +946,8 @@ function createAudioEngine(opts = {}) {
     setTimer: timers.setTimer,
     clearTimer: timers.clearTimer,
     lookahead: opts.lookahead,
-    interval: opts.tickInterval
+    interval: opts.tickInterval,
+    onLate: opts.onLate
   });
   scheduler.start();
   const graph = createBusGraph(ctx, busNames, { ...timers, fadeMs: opts.insertFadeMs });
@@ -1557,6 +1561,11 @@ function createCompressorEffect(ctx, opts = {}) {
 
 // src/patternPlayer.ts
 var nextPlayer = 1;
+function patternLength(events, stepsPerBeat = 4) {
+  let last = -1;
+  for (const e of events) last = Math.max(last, Math.floor(e.step));
+  return Math.max(1, Math.ceil((last + 1) / stepsPerBeat)) * stepsPerBeat;
+}
 var checkTempo = (bpm) => {
   if (!(bpm > 0) || !Number.isFinite(bpm)) {
     throw new RangeError(`@weasel-js/audio: tempo must be a positive number of bpm, got ${bpm}`);
@@ -1568,21 +1577,22 @@ function createPatternPlayer(engine, opts) {
   const loop = opts.loop ?? true;
   const key = `\0pattern:${nextPlayer++}`;
   let bpm = opts.tempo;
+  let drift = opts.detune ?? 0;
   let length = 1;
   let byStep = /* @__PURE__ */ new Map();
   const setEvents = (events, len) => {
     byStep = /* @__PURE__ */ new Map();
-    let last = -1;
     for (const e of events) {
-      const list = byStep.get(e.step);
+      const step = Math.floor(e.step);
+      const list = byStep.get(step);
       if (list) list.push(e);
-      else byStep.set(e.step, [e]);
-      last = Math.max(last, e.step);
+      else byStep.set(step, [e]);
     }
-    length = len ?? Math.max(1, Math.ceil((last + 1) / stepsPerBeat)) * stepsPerBeat;
+    length = len ?? patternLength(events, stepsPerBeat);
   };
   setEvents(opts.events ?? [], opts.length);
   let running = false;
+  let inStep = false;
   let count = 0;
   let lastAt = null;
   let nextAt = 0;
@@ -1607,21 +1617,30 @@ function createPatternPlayer(engine, opts) {
     const step = count % length;
     for (const v of voices) if (!v.isPlaying()) voices.delete(v);
     for (const e of byStep.get(step) ?? []) {
+      const at = when + (e.step - step) * stepMs();
+      const detune = (e.detune ?? 0) + (typeof drift === "function" ? drift(e.step) : drift);
       if ("sound" in e) {
         const { step: _s, sound, ...play } = e;
-        voices.add(engine.play(sound, { ...play, when }));
+        voices.add(engine.play(sound, { ...play, detune, when: at }));
       } else if ("noise" in e) {
         const { step: _s, length: steps = 1, ...noise } = e;
-        voices.add(engine.playNoise({ ...noise, when, duration: steps * stepMs() }));
+        voices.add(engine.playNoise({ ...noise, detune, when: at, duration: steps * stepMs() }));
       } else {
         const { step: _s, length: steps = 1, ...note } = e;
-        voices.add(engine.playNote({ ...note, when, duration: steps * stepMs() }));
+        voices.add(engine.playNote({ ...note, detune, when: at, duration: steps * stepMs() }));
       }
     }
-    opts.onStep?.(step, when);
+    const ms = stepMs();
+    inStep = true;
+    try {
+      opts.onStep?.(step, when);
+    } finally {
+      inStep = false;
+    }
+    if (!running) return;
     count += 1;
     lastAt = when;
-    nextAt = when + stepMs();
+    nextAt = when + ms;
     book();
   };
   return {
@@ -1645,15 +1664,466 @@ function createPatternPlayer(engine, opts) {
     setTempo(next) {
       checkTempo(next);
       bpm = next;
-      if (!running || lastAt === null) return;
+      if (!running || lastAt === null || inStep) return;
       engine.stopKey(key);
       nextAt = Math.max(lastAt + stepMs(), engine.now());
       book();
     },
+    setDetune(next) {
+      drift = next;
+    },
     setEvents
   };
 }
 
-export { createAnalyserTap, createAudioEngine, createBusGraph, createCompressorEffect, createDelayEffect, createFilterEffect, createPatternPlayer, createReverbEffect, createScheduler, createSoundCache, createTickTimer, createVoicePool, envelopeLevel, envelopePoints, midiToFrequency, noiseSamples, noteToMidi, partialPresets, resolveEnvelope, spatialize, toFrequency };
+// src/patternLoad.ts
+function patternVoicePeaks(events, opts) {
+  const stepsPerBeat = opts.stepsPerBeat ?? 4;
+  const stepMs = 6e4 / opts.tempo / stepsPerBeat;
+  const passMs = (opts.length ?? patternLength(events, stepsPerBeat)) * stepMs;
+  const lead = opts.lookahead ?? 100;
+  const spans = events.map((e) => {
+    const sounds = "sound" in e ? opts.hitMs?.(e) ?? stepMs : (e.length ?? 1) * stepMs + resolveEnvelope(e.envelope).release;
+    const at = e.step * stepMs;
+    return { bus: e.bus ?? opts.bus ?? "sfx", from: at - lead, until: at + sounds };
+  });
+  const longest = Math.max(0, ...spans.map((s) => s.until - s.from));
+  const passes = opts.loop === false ? 0 : Math.ceil(longest / passMs);
+  const edges = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const list = edges.get(span.bus) ?? [];
+    edges.set(span.bus, list);
+    for (let pass = 0; pass <= passes; pass++) {
+      list.push({ at: span.from + pass * passMs, by: 1 }, { at: span.until + pass * passMs, by: -1 });
+    }
+  }
+  const peaks = {};
+  for (const [bus, list] of edges) {
+    list.sort((a, b) => a.at - b.at || a.by - b.by);
+    let held = 0;
+    let peak = 0;
+    for (const edge of list) {
+      held += edge.by;
+      peak = Math.max(peak, held);
+    }
+    peaks[bus] = peak;
+  }
+  return peaks;
+}
+
+// src/scoreMood.ts
+var scoreCues = [
+  {
+    name: "dread",
+    mood: { valence: -1, tension: 1, urgency: 0 },
+    device: "Sustained low tones a minor second and a tritone apart, with no pulse."
+  },
+  {
+    name: "investigation",
+    mood: { valence: -0.4, tension: 0.5, urgency: 0.5 },
+    device: "A plucked minor ostinato that adds a layer every two bars."
+  },
+  {
+    name: "wonder",
+    mood: { valence: 1, tension: 0.1, urgency: 0.1 },
+    device: "Lydian chords in open voicings, swelling in with a soft attack."
+  },
+  {
+    name: "urgency",
+    mood: { valence: 0, tension: 0.7, urgency: 1 },
+    device: "Driving sixteenths on stacked fourths and fifths, a new chord every bar."
+  }
+];
+var clamp = (value, lo, hi) => Math.min(hi, Math.max(lo, value));
+var inRange = (mood) => ({
+  valence: clamp(mood.valence, -1, 1),
+  tension: clamp(mood.tension, 0, 1),
+  urgency: clamp(mood.urgency, 0, 1)
+});
+function readScoreCue(mood) {
+  const m = inRange(mood);
+  const distance = scoreCues.map((cue) => ((m.valence - cue.mood.valence) / 2) ** 2 + (m.tension - cue.mood.tension) ** 2 + (m.urgency - cue.mood.urgency) ** 2);
+  const exact = distance.indexOf(0);
+  const raw = distance.map((d, i) => exact >= 0 ? Number(i === exact) : 1 / d);
+  const total = raw.reduce((sum, w) => sum + w, 0);
+  const weights = {};
+  scoreCues.forEach((cue, i) => {
+    weights[cue.name] = raw[i] / total;
+  });
+  return { name: scoreCues[raw.indexOf(Math.max(...raw))].name, weights };
+}
+var scoreModes = {
+  lydian: [0, 2, 4, 6, 7, 9, 11],
+  ionian: [0, 2, 4, 5, 7, 9, 11],
+  dorian: [0, 2, 3, 5, 7, 9, 10],
+  aeolian: [0, 2, 3, 5, 7, 8, 10],
+  phrygian: [0, 1, 3, 5, 7, 8, 10]
+};
+function scoreParams(mood) {
+  const { valence, tension, urgency } = inRange(mood);
+  const sustained = urgency < 0.35;
+  return {
+    mode: valence > 0.6 ? "lydian" : valence > 0.2 ? "ionian" : valence > -0.2 ? "dorian" : valence > -0.6 ? "aeolian" : "phrygian",
+    register: 36 + 12 * Math.round(valence + 1),
+    spread: 1 + Math.round(2 * Math.max(0, valence)),
+    harmony: tension >= 0.8 ? "cluster" : tension >= 0.55 ? "quartal" : "triadic",
+    layers: 1 + Math.round(4 * tension),
+    tempo: Math.round(60 + 80 * urgency),
+    density: urgency < 0.15 ? 0 : urgency < 0.4 ? 1 : urgency < 0.75 ? 2 : 4,
+    articulation: sustained ? "sustained" : "plucked",
+    harmonicRhythm: urgency < 0.33 ? 4 : urgency < 0.66 ? 2 : 1,
+    attack: sustained ? Math.round(800 * (1 - urgency)) : 5
+  };
+}
+
+// src/scoreBar.ts
+var SCORE_BAR_STEPS = 16;
+var PROGRESSION = [0, 5, 3, 4];
+function scoreChord(params, chord, tonic = 0) {
+  const scale = scoreModes[params.mode];
+  const tone = (degree2) => params.register + tonic + scale[degree2 % 7] + 12 * Math.floor(degree2 / 7);
+  if (params.harmony === "cluster") {
+    const root2 = tone(0);
+    return [root2, root2 + 1, root2 + 6];
+  }
+  const degree = PROGRESSION[chord % PROGRESSION.length];
+  const root = tone(degree);
+  if (params.harmony === "quartal") return [root, root + 7, root + 12, root + 17];
+  if (params.spread < 2) return [root, tone(degree + 2), tone(degree + 4)];
+  const open = [root, tone(degree + 4), tone(degree + 2) + 12];
+  if (params.spread >= 3) open.push(tone(degree + 3) + 24);
+  return open;
+}
+function figure(count, seed) {
+  const order = Array.from({ length: count }, (_, i) => i);
+  if (seed === void 0) return order;
+  let state = seed >>> 0 || 1;
+  for (let i = count - 1; i > 0; i--) {
+    state = Math.imul(state, 1664525) + 1013904223 >>> 0;
+    const j = state % (i + 1);
+    [order[i], order[j]] = [order[j], order[i]];
+  }
+  return order;
+}
+var PLUCK = { attack: 5, decay: 140, sustain: 0.2, release: 80 };
+function scoreBar(params, bar, opts = {}) {
+  const gain = opts.gain ?? 0.5;
+  const chord = scoreChord(params, Math.floor(bar / params.harmonicRhythm), opts.tonic);
+  const swell = { attack: params.attack, release: params.attack };
+  const held = params.articulation === "sustained";
+  const note = (step, length, midi, level, envelope2) => ({
+    step,
+    length,
+    pitch: { midi },
+    gain: gain * level,
+    envelope: envelope2,
+    wave: held ? "sine" : "triangle",
+    ...opts.bus === void 0 ? {} : { bus: opts.bus }
+  });
+  const pad = (level, envelope2) => chord.map((midi) => note(0, SCORE_BAR_STEPS, midi, level / chord.length, envelope2));
+  if (params.density === 0) return pad(1, swell);
+  const layers = Math.min(params.layers, 1 + Math.floor(bar / 2));
+  const every = 4 / params.density;
+  const order = figure(chord.length, opts.seed);
+  const envelope = held ? swell : PLUCK;
+  const events = [];
+  for (let pulse = 0; pulse * every < SCORE_BAR_STEPS; pulse++) {
+    const midi = chord[order[pulse % order.length]];
+    events.push(note(pulse * every, every, midi, 0.4, envelope));
+    if (layers >= 3 && pulse % 2 === 1) events.push(note(pulse * every, every, midi + 12, 0.15, envelope));
+  }
+  if (layers >= 2) {
+    for (const step of [0, 8]) events.push(note(step, 8, chord[0] - 12, 0.3, { attack: 5, release: 120 }));
+  }
+  if (layers >= 4) events.push(...pad(0.15, { attack: 120, release: 200 }));
+  return events;
+}
+
+// src/score.ts
+function createScore(engine, opts) {
+  const { mood: initial, onBar, ...barOpts } = opts;
+  let target = initial;
+  const stateAt = (bar, before) => {
+    const cue = readScoreCue(target);
+    return {
+      bar,
+      cueBar: before && before.cue.name === cue.name ? before.cueBar + 1 : 0,
+      mood: target,
+      cue,
+      params: scoreParams(target)
+    };
+  };
+  const eventsOf = (state) => scoreBar(state.params, state.cueBar, barOpts);
+  let current = stateAt(0, null);
+  let next = current;
+  const player = createPatternPlayer(engine, {
+    tempo: current.params.tempo,
+    length: SCORE_BAR_STEPS,
+    events: eventsOf(current),
+    onStep(step, when) {
+      if (step === 0) {
+        current = next;
+        onBar?.(current, when);
+      }
+      if (step !== SCORE_BAR_STEPS - 1) return;
+      next = stateAt(current.bar + 1, current);
+      player.setTempo(next.params.tempo);
+      player.setEvents(eventsOf(next), SCORE_BAR_STEPS);
+    }
+  });
+  return {
+    start(when) {
+      if (player.playing()) return;
+      current = next = stateAt(0, null);
+      player.setTempo(current.params.tempo);
+      player.setEvents(eventsOf(current), SCORE_BAR_STEPS);
+      player.start(when);
+    },
+    stop: () => player.stop(),
+    playing: () => player.playing(),
+    mood: () => target,
+    setMood(mood) {
+      target = mood;
+    },
+    state: () => current
+  };
+}
+
+// src/biquad.ts
+function biquadCoefficients(type, frequency, sampleRate, Q = 1, gain = 0, into = { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 }) {
+  const f = Math.min(Math.max(frequency, 1e-3), sampleRate * 0.4999);
+  const w0 = 2 * Math.PI * f / sampleRate;
+  const cos = Math.cos(w0);
+  const sin = Math.sin(w0);
+  const A = 10 ** (gain / 40);
+  const alphaQ = sin / (2 * Math.max(Q, 1e-4));
+  const alphaDb = sin / (2 * 10 ** (Q / 20));
+  const shelf = sin * Math.SQRT2 * Math.sqrt(A);
+  let b0 = (1 - cos) / 2;
+  let b1 = 1 - cos;
+  let b2 = b0;
+  let a0 = 1 + alphaDb;
+  let a1 = -2 * cos;
+  let a2 = 1 - alphaDb;
+  if (type === "highpass") {
+    b0 = b2 = (1 + cos) / 2;
+    b1 = -(1 + cos);
+  } else if (type === "peaking") {
+    b0 = 1 + alphaQ * A;
+    b1 = -2 * cos;
+    b2 = 1 - alphaQ * A;
+    a0 = 1 + alphaQ / A;
+    a2 = 1 - alphaQ / A;
+  } else if (type === "lowshelf") {
+    b0 = A * (A + 1 - (A - 1) * cos + shelf);
+    b1 = 2 * A * (A - 1 - (A + 1) * cos);
+    b2 = A * (A + 1 - (A - 1) * cos - shelf);
+    a0 = A + 1 + (A - 1) * cos + shelf;
+    a1 = -2 * (A - 1 + (A + 1) * cos);
+    a2 = A + 1 + (A - 1) * cos - shelf;
+  } else if (type === "highshelf") {
+    b0 = A * (A + 1 + (A - 1) * cos + shelf);
+    b1 = -2 * A * (A - 1 + (A + 1) * cos);
+    b2 = A * (A + 1 + (A - 1) * cos - shelf);
+    a0 = A + 1 - (A - 1) * cos + shelf;
+    a1 = 2 * (A - 1 - (A + 1) * cos);
+    a2 = A + 1 - (A - 1) * cos - shelf;
+  } else if (type !== "lowpass") {
+    a0 = 1 + alphaQ;
+    a2 = 1 - alphaQ;
+    b0 = type === "bandpass" ? alphaQ : type === "notch" ? 1 : 1 - alphaQ;
+    b1 = type === "bandpass" ? 0 : -2 * cos;
+    b2 = type === "bandpass" ? -alphaQ : type === "notch" ? 1 : 1 + alphaQ;
+  }
+  into.b0 = b0 / a0;
+  into.b1 = b1 / a0;
+  into.b2 = b2 / a0;
+  into.a1 = a1 / a0;
+  into.a2 = a2 / a0;
+  return into;
+}
+function biquadResponseDb(c, hz, sampleRate) {
+  const w = 2 * Math.PI * hz / sampleRate;
+  const c1 = Math.cos(w);
+  const s1 = Math.sin(w);
+  const c2 = Math.cos(2 * w);
+  const s2 = Math.sin(2 * w);
+  const num = (c.b0 + c.b1 * c1 + c.b2 * c2) ** 2 + (c.b1 * s1 + c.b2 * s2) ** 2;
+  const den = (1 + c.a1 * c1 + c.a2 * c2) ** 2 + (c.a1 * s1 + c.a2 * s2) ** 2;
+  return 10 * Math.log10(num / den);
+}
+
+// src/oscillator.ts
+var TAU = 2 * Math.PI;
+var PEAK_POINTS = 4096;
+var TRIANGLE_SUMMED_FROM = 1 / 128;
+function polyBlep(t, dt) {
+  const d = Math.min(dt, 0.5);
+  if (t < d) {
+    const x = t / d;
+    return x + x - x * x - 1;
+  }
+  if (t > 1 - d) {
+    const x = (t - 1) / d;
+    return x * x + x + x + 1;
+  }
+  return 0;
+}
+var sineShape = (phase) => Math.sin(TAU * phase);
+var STEPPED_LEVEL = 1 / 1.17898;
+var BUILT_IN = {
+  sine: sineShape,
+  square: (phase, dt) => STEPPED_LEVEL * ((phase < 0.5 ? 1 : -1) + polyBlep(phase, dt) - polyBlep((phase + 0.5) % 1, dt)),
+  sawtooth: (phase, dt) => {
+    const t = (phase + 0.5) % 1;
+    return STEPPED_LEVEL * (2 * t - 1 - polyBlep(t, dt));
+  },
+  triangle: (phase, dt) => {
+    if (dt < TRIANGLE_SUMMED_FROM) return phase < 0.25 ? 4 * phase : phase < 0.75 ? 2 - 4 * phase : 4 * phase - 4;
+    let v = 0;
+    let sign = 1;
+    for (let k = 1; k * dt < 0.5; k += 2) {
+      v += sign * Math.sin(TAU * k * phase) / (k * k);
+      sign = -sign;
+    }
+    return v * 8 / (Math.PI * Math.PI);
+  }
+};
+function harmonicShape(levels) {
+  const sum = (phase, count) => {
+    let v = 0;
+    for (let k = 1; k <= count; k += 1) v += levels[k - 1] * Math.sin(TAU * k * phase);
+    return v;
+  };
+  let peak = 0;
+  for (let i = 0; i < PEAK_POINTS; i += 1) peak = Math.max(peak, Math.abs(sum(i / PEAK_POINTS, levels.length)));
+  const scale = peak > 0 ? 1 / peak : 0;
+  return (phase, dt) => scale * sum(phase, Math.min(levels.length, Math.ceil(0.5 / dt) - 1));
+}
+function waveShape(wave) {
+  return typeof wave === "string" ? BUILT_IN[wave] : harmonicShape(wave);
+}
+
+// src/voiceKernel.ts
+var tuning = (rate, detune) => rate * 2 ** (detune / 1200);
+function filterStage(spec, sampleRate) {
+  const type = spec.type ?? "lowpass";
+  const amount = spec.amount ?? 0;
+  const env = spec.envelope && amount !== 0 ? resolveEnvelope(spec.envelope) : null;
+  const coefficients = biquadCoefficients(type, spec.frequency, sampleRate, spec.Q, spec.gain);
+  let cutoff = spec.frequency;
+  let z1 = 0;
+  let z2 = 0;
+  return (x, t, gate) => {
+    if (env) {
+      const hz = spec.frequency + amount * envelopeLevel(env, t, gate);
+      if (hz !== cutoff) {
+        cutoff = hz;
+        biquadCoefficients(type, hz, sampleRate, spec.Q, spec.gain, coefficients);
+      }
+    }
+    const y = coefficients.b0 * x + z1;
+    z1 = coefficients.b1 * x - coefficients.a1 * y + z2;
+    z2 = coefficients.b2 * x - coefficients.a2 * y;
+    return y;
+  };
+}
+function createKernel(patch, sampleRate, source) {
+  const env = resolveEnvelope(patch.envelope);
+  const gain = patch.gain ?? 1;
+  const filter = patch.filter ? filterStage(patch.filter, sampleRate) : null;
+  const msPerSample = 1e3 / sampleRate;
+  let gate = patch.duration;
+  let tune = tuning(patch.rate ?? 1, patch.detune ?? 0);
+  let n = 0;
+  let ended = false;
+  return {
+    render(out, from = 0, to = out.length) {
+      if (ended) return false;
+      for (let i = from; i < to; i += 1) {
+        const t = n * msPerSample;
+        if (gate !== void 0 && t >= gate + env.release) {
+          ended = true;
+          return false;
+        }
+        const raw = source(t, tune);
+        out[i] += gain * envelopeLevel(env, t, gate) * (filter ? filter(raw, t, gate) : raw);
+        n += 1;
+      }
+      return true;
+    },
+    release() {
+      const t = n * msPerSample;
+      if (gate === void 0 || t < gate) gate = t;
+    },
+    retune(rate, detune) {
+      tune = tuning(rate, detune);
+    }
+  };
+}
+function createNoteKernel(note, sampleRate) {
+  const from = toFrequency(note.pitch);
+  const glideTo = note.glide ? toFrequency(note.glide.to) : void 0;
+  const glideMs = note.glide?.ms ?? note.duration ?? 100;
+  const linear = note.glide?.curve === "linear";
+  const wave = note.wave ?? "sine";
+  const shape = isInharmonic(wave) ? sineShape : waveShape(wave);
+  const tones = isInharmonic(wave) ? resolvePartials(wave).map((p) => ({ ratio: p.ratio, gain: p.gain, decay: p.decay, phase: 0 })) : [{ ratio: 1, gain: 1, phase: 0 }];
+  return createKernel(note, sampleRate, (t, tune) => {
+    let hz = from;
+    if (glideTo !== void 0) {
+      const k = glideMs > 0 ? Math.min(1, t / glideMs) : 1;
+      hz = linear ? from + (glideTo - from) * k : from * (glideTo / from) ** k;
+    }
+    const cycles = hz * tune / sampleRate;
+    let sum = 0;
+    for (const tone of tones) {
+      const dt = cycles * tone.ratio;
+      if (dt >= 0.5) continue;
+      const level = tone.decay === void 0 ? tone.gain : tone.gain * Math.exp(-t / tone.decay);
+      sum += level * shape(tone.phase, dt);
+      tone.phase = (tone.phase + dt) % 1;
+    }
+    return sum;
+  });
+}
+var loops = /* @__PURE__ */ new Map();
+function noiseLoop(color, sampleRate) {
+  const key = `${color}:${sampleRate}`;
+  let loop = loops.get(key);
+  if (!loop) {
+    loop = noiseSamples(color, Math.round(sampleRate * NOISE_SECONDS));
+    loops.set(key, loop);
+  }
+  return loop;
+}
+function createNoiseKernel(noise, sampleRate, random = Math.random) {
+  const loop = noiseLoop(noise.noise, sampleRate);
+  let at = Math.floor(random() * loop.length);
+  return createKernel(noise, sampleRate, (_t, tune) => {
+    const i = Math.floor(at);
+    const a = loop[i];
+    const sample = a + (loop[(i + 1) % loop.length] - a) * (at - i);
+    at = (at + tune) % loop.length;
+    return sample;
+  });
+}
+function renderWhole(kernel, patch, sampleRate, what) {
+  if (patch.duration === void 0) {
+    throw new RangeError(`@weasel-js/audio: ${what} needs a duration to know where the voice ends`);
+  }
+  const total = patch.duration + resolveEnvelope(patch.envelope).release;
+  const out = new Float32Array(Math.round(total * sampleRate / 1e3));
+  kernel.render(out);
+  return out;
+}
+function renderNote(note, sampleRate) {
+  return renderWhole(createNoteKernel(note, sampleRate), note, sampleRate, "renderNote");
+}
+function renderNoise(noise, sampleRate, random = Math.random) {
+  return renderWhole(createNoiseKernel(noise, sampleRate, random), noise, sampleRate, "renderNoise");
+}
+
+export { SCORE_BAR_STEPS, biquadCoefficients, biquadResponseDb, createAnalyserTap, createAudioEngine, createBusGraph, createCompressorEffect, createDelayEffect, createFilterEffect, createNoiseKernel, createNoteKernel, createPatternPlayer, createReverbEffect, createScheduler, createScore, createSoundCache, createTickTimer, createVoicePool, envelopeLevel, envelopePoints, midiToFrequency, noiseSamples, noteToMidi, partialPresets, patternLength, patternVoicePeaks, readScoreCue, renderNoise, renderNote, resolveEnvelope, scoreBar, scoreChord, scoreCues, scoreModes, scoreParams, spatialize, toFrequency };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map