@hraness/dawg 0.5.0 → 0.6.1

package/src/audio/sampler.ts

@@ -32,13 +32,22 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import { sampleKey, type DecodedSample, type SampleBank } from "./samples.ts";
+import { seedHash } from "./dsp/rng.ts";
 import {
   barAt,
   loopSecondsOf,
   performedNotes,
   secondsAtTick,
 } from "../../core/tempo.ts";
-import { sampleWarpFor, warpedSpan, type SampleWarp } from "./warp.ts";
+import {
+  beatFitMap,
+  sampleWarpFor,
+  spanFitMap,
+  warpedSpan,
+  type FitMap,
+  type SampleWarp,
+} from "./warp.ts";
+import { fittedBuffer, shiftedBuffer, windowAt } from "./fit.ts";
 import {
   performanceTimingFor,
   tunedTiming,
@@ -55,6 +64,8 @@ const ATTACK_SECONDS = 0.001;
 /** Fade at a natural end, a held release, a choke and a voice steal. */
 const END_FADE_SECONDS = 0.003;
 const RELEASE_SECONDS = 0.01;
+/** Extra fitted frames past a note's reach (read interpolation). */
+const REACH_MARGIN_FRAMES = 64;
 const CHOKE_SECONDS = 0.005;
 /** Loop seam crossfade (source time). */
 const LOOP_CROSSFADE_SECONDS = 0.005;
@@ -96,6 +107,10 @@ export type SamplerVoice = {
   readonly cents?: NotePerformance["cents"];
   /** Half pedal: the level fades from `from` seconds. */
   readonly damp?: NotePerformance["damp"];
+  /** `fadeInTime` in output frames (0.6.1); absent is the 1 ms anti-click. */
+  readonly attack?: number;
+  /** A resampled stereo file (0.6.1): plays its own left and right. */
+  readonly stereo?: boolean;
 };
 
 /**
@@ -150,38 +165,111 @@ function noteLengthFrames(note: Note, timing: SamplerTiming): number {
 function voiceResolver(
   track: Track,
   tuning?: TuningTable,
-): (pitch: number) => { voice: string; ratio: number } | undefined {
+): (
+  pitch: number,
+  velocity: number,
+) => { voice: string; ratio: number } | undefined {
   const sampler = track.sampler!;
+  const pick = layerPicker(
+    track.id,
+    sampler.voices,
+    sampler.mode === "oneshot",
+  );
   if (sampler.mode === "oneshot") {
     const byPitch = new Map<number, string>();
     for (const [voice, slot] of samplerVoiceSlots(sampler))
       byPitch.set(slot, voice);
-    return (pitch) => {
-      const voice = byPitch.get(pitch);
+    return (pitch, velocity) => {
+      const slotted = byPitch.get(pitch);
+      if (slotted === undefined) return undefined;
+      const voice = pick(slotted, velocity);
       return voice === undefined ? undefined : { voice, ratio: 1 };
     };
   }
   // Keyed: the voice whose root is the highest at or below the pitch (a
-  // multi-sampled instrument), else the lowest root.
+  // multi-sampled instrument), else the lowest root. With velocity layers
+  // only the voices whose `vel` holds the note's velocity take part.
   const keyed = Object.entries(sampler.voices)
-    .map(([voice, ref]) => ({ voice, root: ref.root ?? 60 }))
+    .map(([voice, ref]) => ({ voice, root: ref.root ?? 60, vel: ref.vel }))
     .sort((a, b) => a.root - b.root || (a.voice < b.voice ? -1 : 1));
-  return (pitch) => {
-    let chosen = keyed[0];
-    for (const candidate of keyed)
-      if (candidate.root <= pitch) chosen = candidate;
+  return (pitch, velocity) => {
+    let chosen: (typeof keyed)[number] | undefined;
+    for (const candidate of keyed) {
+      if (!inLayer(candidate.vel, velocity)) continue;
+      if (chosen === undefined || candidate.root <= pitch) chosen = candidate;
+    }
     if (!chosen) return undefined;
-    if (!tuning)
-      return { voice: chosen.voice, ratio: 2 ** ((pitch - chosen.root) / 12) };
+    const voice = pick(chosen.voice, velocity) ?? chosen.voice;
+    if (!tuning) return { voice, ratio: 2 ** ((pitch - chosen.root) / 12) };
     const hz = tuning.hz[pitch]!;
     if (!(hz > 0)) return undefined;
     return {
-      voice: chosen.voice,
+      voice,
       ratio: hz / (440 * 2 ** ((chosen.root - 69) / 12)),
     };
   };
 }
 
+/** MIDI velocity (0..127) of a note velocity 0..1. */
+export function midiVelocity(velocity: number): number {
+  return Math.max(0, Math.min(127, Math.round(velocity * 127)));
+}
+
+function inLayer(
+  vel: readonly [number, number] | undefined,
+  velocity: number,
+): boolean {
+  if (!vel) return true;
+  const v = midiVelocity(velocity);
+  return v >= vel[0] && v <= vel[1];
+}
+
+/**
+ * Velocity layers and round robin (0.6.1, SFZ lovel/hivel and seq_length).
+ * A voice with `rr` stands for its whole group: of the group's voices that
+ * hold the note's velocity (and, keyed, share its root) the next one in
+ * name order plays. When no layer of the group holds the velocity, the
+ * nearest layer plays rather than nothing. Each group keeps its own
+ * counter in note order, starting at a turn seeded by the track id and
+ * the group, so a render is deterministic (A B A B) while two tracks
+ * with the same samples need not alternate in lockstep. A keyed voice
+ * without `rr` plays itself when its `vel` holds the velocity, else
+ * nothing; a one-shot voice without `rr` (its own pad) always plays.
+ */
+function layerPicker(
+  trackId: string,
+  voices: Readonly<Record<string, SampleRef>>,
+  oneshot: boolean,
+): (voice: string, velocity: number) => string | undefined {
+  const counters = new Map<string, number>();
+  const names = Object.keys(voices).sort();
+  return (voice, velocity) => {
+    const ref = voices[voice]!;
+    if (ref.rr === undefined)
+      return oneshot || inLayer(ref.vel, velocity) ? voice : undefined;
+    const members = names.filter((name) => {
+      const other = voices[name]!;
+      return other.rr === ref.rr && (other.root ?? 60) === (ref.root ?? 60);
+    });
+    let group = members.filter((name) => inLayer(voices[name]!.vel, velocity));
+    if (group.length === 0) {
+      const v = midiVelocity(velocity);
+      const gap = (name: string) => {
+        const vel = voices[name]!.vel!;
+        return v < vel[0] ? vel[0] - v : v - vel[1];
+      };
+      const nearest = Math.min(...members.map(gap));
+      group = members.filter((name) => gap(name) === nearest);
+    }
+    if (group.length === 0) return undefined;
+    const key = `${ref.rr}:${ref.root ?? 60}:${group.join(",")}`;
+    const turn =
+      counters.get(key) ?? seedHash(`${trackId}:${key}`) % group.length;
+    counters.set(key, turn + 1);
+    return group[turn % group.length];
+  };
+}
+
 /** Plans every voice a sampler track plays, with choke and polyphony applied. */
 export function planSamplerVoices(
   track: Track,
@@ -214,35 +302,78 @@ export function planSamplerVoices(
     voice.fade = Math.min(fade, end - voice.start);
   };
   for (const note of ordered) {
-    const resolved = resolve(note.pitch);
+    const resolved = resolve(note.pitch, note.velocity);
     if (!resolved) continue;
     // A note's cents repitch every voice, keyed or one-shot.
     const target = note.cents
       ? { ...resolved, ratio: resolved.ratio * 2 ** (note.cents / 1200) }
       : resolved;
     const ref: SampleRef | undefined = sampler.voices[target.voice];
-    const sample = bank.voices.get(sampleKey(track.id, target.voice));
-    if (!ref || !sample) continue;
-    const speed = ref.speed ?? 1;
-    const regionStart = (ref.begin ?? 0) * sample.frames;
-    const regionEnd = (ref.end ?? 1) * sample.frames;
+    const decoded = bank.voices.get(sampleKey(track.id, target.voice));
+    if (!ref || !decoded) continue;
     const held = noteLengthFrames(note, timing);
+    // 0.6 fit (`bpm`, `len`, or `fit` with fitmode beats|tones): the window
+    // is fitted once into a render-rate buffer that plays forward at step 1
+    // (times the keyed ratio). Absent fields keep the 0.5 path untouched.
+    // Only the frames this note can reach are fitted: a keyed or clipped
+    // note (not looping, no accelerate) ends at its held length plus the
+    // release, read at the keyed ratio; anything else may play it all.
+    const reach =
+      ref.loop !== true &&
+      (ref.accelerate ?? 0) === 0 &&
+      (sampler.mode === "keyed" || ref.clip !== undefined)
+        ? Math.ceil(
+            ((ref.clip === undefined
+              ? held
+              : Math.max(1, Math.floor(held * ref.clip))) +
+              Math.round(RELEASE_SECONDS * sampleRate)) *
+              target.ratio,
+          ) + REACH_MARGIN_FRAMES
+        : Infinity;
+    const fitted = isFitted(ref)
+      ? fitVoice(ref, decoded, note.startTick, held, timing, reach)
+      : undefined;
+    if (fitted === null) continue;
+    // 0.6.1 `shift`/`formant`: a cached constant-length pitch shift of the
+    // played buffer (after any fit, so it follows fitmode).
+    const shifted = isShifted(ref)
+      ? shiftVoice(ref, fitted?.sample ?? decoded, fitted ? "fit" : "raw")
+      : undefined;
+    const sample = shifted ?? fitted?.sample ?? decoded;
+    // Live, until the cached shift is ready: a plain repitch at the shifted
+    // pitch (the length follows, like tape).
+    const repitch =
+      shifted === undefined && isShifted(ref)
+        ? 2 ** ((ref.shift ?? 0) / 12)
+        : 1;
+    const speed = fitted ? repitch : (ref.speed ?? 1) * repitch;
+    const regionStart = fitted ? 0 : (ref.begin ?? 0) * sample.frames;
+    const regionEnd = fitted ? sample.frames : (ref.end ?? 1) * sample.frames;
     // `fit`, `unit: "c"` and `unit: "s"` give the window a duration; the
     // keyed ratio still repitches on top.
     const unit = ref.unit ?? "r";
-    const seconds = ref.fit
-      ? held / sampleRate
-      : unit === "c"
-        ? cycleSeconds(timing.score, note.startTick) / Math.abs(speed)
-        : unit === "s"
-          ? Math.abs(speed)
-          : undefined;
+    const seconds = fitted
+      ? undefined
+      : ref.fit
+        ? held / sampleRate
+        : unit === "c"
+          ? cycleSeconds(timing.score, note.startTick) / Math.abs(speed)
+          : unit === "s"
+            ? Math.abs(speed)
+            : undefined;
     const step =
       seconds === undefined
         ? ((Math.abs(speed) * sample.sampleRate) / sampleRate) * target.ratio
         : ((regionEnd - regionStart) / (seconds * sampleRate)) * target.ratio;
     const natural = Math.max(1, Math.floor((regionEnd - regionStart) / step));
-    const release = Math.max(1, Math.round(RELEASE_SECONDS * sampleRate));
+    const release = Math.max(
+      1,
+      Math.round((ref.fadeTime ?? RELEASE_SECONDS) * sampleRate),
+    );
+    const endFade = Math.max(
+      1,
+      Math.round((ref.fadeTime ?? END_FADE_SECONDS) * sampleRate),
+    );
     const loop = ref.loop === true;
     const clipped =
       ref.clip === undefined ? held : Math.max(1, Math.floor(held * ref.clip));
@@ -259,7 +390,7 @@ export function planSamplerVoices(
       fade = release;
     } else {
       length = natural;
-      fade = Math.max(1, Math.round(END_FADE_SECONDS * sampleRate));
+      fade = endFade;
     }
     // accelerate: the rate ramps by `accelerate`× over the planned length;
     // a non-looping voice ends where the ramped read runs out (or stops).
@@ -273,13 +404,19 @@ export function planSamplerVoices(
       const until = Math.max(1, Math.floor(reach));
       if (until < length) {
         length = until;
-        fade = Math.max(1, Math.round(END_FADE_SECONDS * sampleRate));
+        fade = endFade;
       }
     }
-    const loopFrom =
-      ref.loopBegin === undefined ? regionStart : ref.loopBegin * sample.frames;
-    const loopTo =
-      ref.loopEnd === undefined ? regionEnd : ref.loopEnd * sample.frames;
+    const loopFrom = fitted
+      ? fitted.loopFrom
+      : ref.loopBegin === undefined
+        ? regionStart
+        : ref.loopBegin * sample.frames;
+    const loopTo = fitted
+      ? fitted.loopTo
+      : ref.loopEnd === undefined
+        ? regionEnd
+        : ref.loopEnd * sample.frames;
     const start = noteStartFrame(note, timing);
     const performance = (note as PerformedNote).performance;
     const voice: SamplerVoice = {
@@ -300,6 +437,12 @@ export function planSamplerVoices(
       loopSpan: loopTo - loopFrom,
       ramp,
       squiz: ref.squiz ?? 1,
+      ...(ref.fadeInTime !== undefined
+        ? { attack: Math.max(1, ref.fadeInTime * sampleRate) }
+        : {}),
+      ...(ref.from !== undefined && sample.left && sample.right
+        ? { stereo: true }
+        : {}),
       ...(performance?.cents ? { cents: performance.cents } : {}),
       ...(performance?.damp ? { damp: performance.damp } : {}),
     };
@@ -318,6 +461,153 @@ export function planSamplerVoices(
   return voices;
 }
 
+/** A SampleRef that fits its window to the song (0.6 `bpm`, `len`, fitmode). */
+export function isFitted(ref: SampleRef): boolean {
+  return (
+    ref.bpm !== undefined ||
+    ref.len !== undefined ||
+    (ref.fit === true && (ref.fitmode === "beats" || ref.fitmode === "tones"))
+  );
+}
+
+type FittedVoice = Readonly<{
+  sample: DecodedSample;
+  loopFrom: number;
+  loopTo: number;
+}>;
+
+/**
+ * The fitted window of one note. Precedence `fit` > `bpm` > `len`:
+ * - `fit`: the window fills the note (Strudel `fit`, with an algorithm);
+ * - `bpm`: the window advances `|speed|` source beats per song beat,
+ *   following the tempo map (ramps, steps, fermatas);
+ * - `len`: the window spans `len` song beats through the tempo map.
+ * A negative `speed` reverses the window; `unit` is ignored once fitted.
+ * Returns null while a live fit is still computing (the voice stays
+ * silent rather than playing at the wrong pitch).
+ */
+function fitVoice(
+  ref: SampleRef,
+  decoded: DecodedSample,
+  startTick: number,
+  held: number,
+  timing: SamplerTiming,
+  reach: number,
+): FittedVoice | null {
+  const { sampleRate, score, warp } = timing;
+  const speed = ref.speed ?? 1;
+  const reverse = speed < 0;
+  const from = (ref.begin ?? 0) * decoded.frames;
+  const to = (ref.end ?? 1) * decoded.frames;
+  const rate = decoded.sampleRate / sampleRate;
+  const window = windowAt(decoded.mono, from, to, rate, reverse);
+  const frames = window.length;
+  let map: FitMap;
+  if (ref.fit === true) map = spanFitMap(frames, held);
+  else {
+    const perBeat =
+      ref.bpm !== undefined
+        ? ((sampleRate * 60) / ref.bpm) * Math.abs(speed)
+        : frames / ref.len!;
+    map = beatFitMap(
+      warp,
+      {
+        tempoBpm: score.tempoBpm,
+        ticksPerBeat: score.ticksPerBeat,
+        sampleRate,
+      },
+      startTick,
+      frames,
+      perBeat,
+    );
+  }
+  const algorithm = ref.fitmode ?? "repitch";
+  const windowKey = `${decoded.sha256}:${decoded.sampleRate}:${from}:${to}:${sampleRate}:${reverse ? 1 : 0}`;
+  const length = Math.min(map.length, reach);
+  const key = `${windowKey}:${algorithm}:${mapPrint(map, frames)}:${Math.round(length)}`;
+  const buffer = fittedBuffer(
+    key,
+    window,
+    sampleRate,
+    map,
+    algorithm,
+    windowKey,
+    length,
+  );
+  if (!buffer) return null;
+  const sample: DecodedSample = Object.freeze({
+    sha256: decoded.sha256,
+    sampleRate,
+    channels: 1,
+    frames: buffer.length,
+    mono: buffer,
+  });
+  // Loop points move with the map (in window frames, then out frames).
+  const loopAt = (fraction: number | undefined, fallback: number) => {
+    if (fraction === undefined) return fallback;
+    const source = fraction * decoded.frames;
+    const inWindow = (reverse ? to - source : source - from) / rate;
+    return Math.max(0, Math.min(buffer.length, map.outAt(inWindow)));
+  };
+  const a = loopAt(ref.loopBegin, 0);
+  const b = loopAt(ref.loopEnd, buffer.length);
+  return Object.freeze({
+    sample,
+    loopFrom: Math.min(a, b),
+    loopTo: Math.max(a, b),
+  });
+}
+
+/** A SampleRef with a pitch or formant shift (0.6.1). */
+export function isShifted(ref: SampleRef): boolean {
+  return (
+    (ref.shift !== undefined && ref.shift !== 0) || ref.formant !== undefined
+  );
+}
+
+/** Buffers already shifted, by the identity of the buffer they shift. */
+const shiftKeys = new WeakMap<Float32Array, string>();
+let shiftSerial = 0;
+
+/**
+ * The shifted copy of `sample` (whole buffer, same length). Returns null
+ * while a live shift is still computing (the voice stays silent).
+ */
+function shiftVoice(
+  ref: SampleRef,
+  sample: DecodedSample,
+  kind: "raw" | "fit",
+): DecodedSample | undefined {
+  // Decoded files key by content; fitted buffers (already cached by their
+  // own key) by identity.
+  let base = shiftKeys.get(sample.mono);
+  if (base === undefined) {
+    base =
+      kind === "raw"
+        ? `${sample.sha256}:${sample.sampleRate}:${sample.frames}`
+        : `fit#${(shiftSerial += 1)}`;
+    shiftKeys.set(sample.mono, base);
+  }
+  const key = `shift:${base}:${ref.shift ?? 0}:${ref.formant ?? "follow"}`;
+  const buffer = shiftedBuffer(
+    key,
+    sample.mono,
+    sample.sampleRate,
+    ref.shift ?? 0,
+    ref.formant,
+  );
+  if (!buffer) return undefined;
+  return Object.freeze({ ...sample, frames: buffer.length, mono: buffer });
+}
+
+/** Fingerprint of a position map: its length and 64 exact samples. */
+function mapPrint(map: FitMap, frames: number): string {
+  const parts = [map.length.toString()];
+  for (let i = 1; i <= 64; i += 1)
+    parts.push(map.outAt((frames * i) / 64).toString());
+  return parts.join(",");
+}
+
 /** Linear-interpolated read, clamped to the sample. */
 function readAt(mono: Float32Array, position: number): number {
   const last = mono.length - 1;
@@ -337,6 +627,8 @@ export function renderSamplerVoices(
   voices: readonly SamplerVoice[],
   timing: SamplerTiming,
   gainAt: (tick: number) => number,
+  /** The channel a stereo voice reads (absent: every voice reads mono). */
+  channel?: "left" | "right",
 ): void {
   const { sampleRate, score, warp } = timing;
   const samplesPerTick =
@@ -345,7 +637,8 @@ export function renderSamplerVoices(
   for (const voice of voices) {
     const { sample, step, regionStart, regionEnd, reverse, loop } = voice;
     const { loopStart, loopSpan, ramp } = voice;
-    const mono = sample.mono;
+    const mono =
+      channel && voice.stereo ? (sample[channel] ?? sample.mono) : sample.mono;
     const span = regionEnd - regionStart;
     const crossfade = loop
       ? Math.min(LOOP_CROSSFADE_SECONDS * sample.sampleRate, loopSpan / 4)
@@ -403,7 +696,7 @@ export function renderSamplerVoices(
       const elapsed = index - voice.start;
       const value = squizzed ? squizzed[elapsed]! : read(elapsed);
       if (value === undefined) break;
-      let envelope = Math.min(1, elapsed / attack);
+      let envelope = Math.min(1, elapsed / (voice.attack ?? attack));
       if (index >= fadeFrom) envelope *= (voice.end - index) / voice.fade;
       const damp = voice.damp;
       if (damp && elapsed / sampleRate > damp.from)

package/src/audio/samples.ts

@@ -32,8 +32,10 @@ import {
   isLocalTableSrc,
   isWavetableInstrument,
   type SampleRef,
+  type Track,
   type TrackScore,
 } from "../../core/score.ts";
+import { GRANULAR_SOURCE_VOICE } from "../../core/granular.ts";
 import { PackError, PackStore } from "./packs.ts";
 import {
   DEFAULT_MEMORY_CACHE_BYTES,
@@ -56,6 +58,12 @@ export type DecodedSample = Readonly<{
   channels: number;
   frames: number;
   mono: Float32Array;
+  /**
+   * The two channels of a stereo file (0.6.1): a resampled ref (one with
+   * `from`) plays them as stereo. Absent for mono and multichannel files.
+   */
+  left?: Float32Array;
+  right?: Float32Array;
 }>;
 
 export type SampleProblem = Readonly<{
@@ -94,10 +102,35 @@ export function hasSamplerTracks(score: TrackScore): boolean {
         Object.keys(track.sampler.voices).length > 0) ||
       packWavetable(track) !== undefined ||
       localWavetable(track) !== undefined ||
-      reverbIrSample(track) !== undefined,
+      reverbIrSample(track) !== undefined ||
+      granularSample(track) !== undefined,
   );
 }
 
+/**
+ * A granular track's sample source (0.6): its `granular.src` when that is a
+ * SampleRef, loaded and sha256-pinned like a sampler voice under the voice
+ * name `granular:src`. A `synth:` source or no source needs no loading.
+ */
+export function granularSample(track: Track): SampleRef | undefined {
+  if (track.instrument !== "granular") return undefined;
+  const src = track.granular?.src;
+  return src !== undefined && typeof src !== "string" ? src : undefined;
+}
+
+/** The sample voices a track loads: sampler voices, then a granular source. */
+function trackSampleRefs(track: Track): [string, SampleRef][] {
+  const refs: [string, SampleRef][] = [];
+  if (isSamplerInstrument(track.instrument) && track.sampler) {
+    const names = Object.keys(track.sampler.voices).sort();
+    for (const voice of names.slice(0, SCORE_LIMITS.maxSamplerVoices))
+      refs.push([voice, track.sampler.voices[voice]!]);
+  }
+  const granular = granularSample(track);
+  if (granular) refs.push([GRANULAR_SOURCE_VOICE, granular]);
+  return refs;
+}
+
 /** The project WAV a wavetable track plays, if any. */
 export function localWavetable(
   track: TrackScore["tracks"][number],
@@ -297,6 +330,20 @@ function checkShape(sampleRate: number, channels: number, frames: number) {
 }
 
 /** Average the channels; the renderer plays sampler voices in mono before pan. */
+/** A stereo file's left and right channels (nothing for other shapes). */
+export function stereoChannels(
+  pcm: PcmData,
+): { left: Float32Array; right: Float32Array } | Record<string, never> {
+  if (pcm.channels !== 2) return {};
+  const left = new Float32Array(pcm.frames);
+  const right = new Float32Array(pcm.frames);
+  for (let frame = 0; frame < pcm.frames; frame += 1) {
+    left[frame] = pcm.data[frame * 2]!;
+    right[frame] = pcm.data[frame * 2 + 1]!;
+  }
+  return { left, right };
+}
+
 export function monoMix(pcm: PcmData): Float32Array {
   if (pcm.channels === 1) return pcm.data;
   const mono = new Float32Array(pcm.frames);
@@ -585,8 +632,7 @@ export class SampleLibrary implements SampleSource {
     this.inUse = new Set();
     const urls: string[] = [];
     for (const track of score.tracks) {
-      if (!isSamplerInstrument(track.instrument) || !track.sampler) continue;
-      for (const ref of Object.values(track.sampler.voices)) {
+      for (const [, ref] of trackSampleRefs(track)) {
         if (ref.sha256) this.inUse.add(ref.sha256);
         if (ref.url) urls.push(ref.url);
       }
@@ -656,10 +702,7 @@ export class SampleLibrary implements SampleSource {
       }
     }
     for (const track of score.tracks) {
-      if (!isSamplerInstrument(track.instrument) || !track.sampler) continue;
-      const names = Object.keys(track.sampler.voices).sort();
-      for (const voice of names.slice(0, SCORE_LIMITS.maxSamplerVoices)) {
-        const ref = track.sampler.voices[voice]!;
+      for (const [voice, ref] of trackSampleRefs(track)) {
         let src = ref.src;
         if (src.startsWith(PACK_PREFIX)) {
           try {
@@ -873,6 +916,7 @@ export class SampleLibrary implements SampleSource {
       channels: pcm.channels,
       frames: pcm.frames,
       mono: monoMix(pcm),
+      ...stereoChannels(pcm),
     });
     this.remember(sample);
     return sample;
@@ -920,6 +964,7 @@ export class SampleLibrary implements SampleSource {
       channels: pcm.channels,
       frames: pcm.frames,
       mono: monoMix(pcm),
+      ...stereoChannels(pcm),
     });
     this.remember(sample);
     return sample;
@@ -943,7 +988,10 @@ export class SampleLibrary implements SampleSource {
   }
 
   private remember(sample: DecodedSample): void {
-    const bytes = sample.mono.byteLength;
+    const bytes =
+      sample.mono.byteLength +
+      (sample.left?.byteLength ?? 0) +
+      (sample.right?.byteLength ?? 0);
     this.memory.set(sample.sha256, { sample, bytes });
     this.memoryBytes += bytes;
     for (const [sha, entry] of this.memory) {