@hraness/dawg 0.6.0 → 0.6.1

package/src/audio/resample.ts

@@ -0,0 +1,285 @@
+/**
+ * Resample (0.6.1): render one track, one orbit or the whole mix, over the
+ * song, a section or a bar range, to a 16-bit WAV a new sampler or granular
+ * track plays. The render is the same offline path `dawg render` writes
+ * (`renderArrangedPcm`), with the source soloed and, unless `master` is
+ * asked for, the song master left out (a pre-master stem), so the same score
+ * always gives the same bytes and the same sha256.
+ *
+ * Level: the sampler plays a resampled stereo file (a ref with `from`) as
+ * stereo, each channel scaled by SAMPLE_LEVEL and the centre pan's
+ * equal-power gain, so the file is written RESAMPLE_FILE_SCALE louder than
+ * the stem (about +0.09 dB) for the new track, at voice gain RESAMPLE_GAIN
+ * and pan 0, to match the source in both channels (panned sources and
+ * stereo effects keep their image). A granular track reads the mono
+ * mixdown. Peaks past full scale clamp.
+ *
+ * A section or bar range renders from PREROLL_BARS before it (or from the
+ * earliest source note still sounding at its start) and drops those
+ * frames, so held notes and effect tails cross into the range as in the
+ * song.
+ */
+import { createHash } from "node:crypto";
+import {
+  SCORE_LIMITS,
+  TrackScore,
+  ScoreValidationError,
+  type SampleProvenance,
+  type Track,
+} from "../../core/score.ts";
+import { barTicks, findSection, sectionScore } from "../../core/sections.ts";
+import { secondsAtTick } from "../../core/tempo.ts";
+import { renderArrangedPcm } from "./arrange.ts";
+import { orbitOf } from "./effects/duck.ts";
+import { exportSampleRate } from "./measure.ts";
+import { SAMPLE_LEVEL } from "./sampler.ts";
+import type { SampleBank } from "./samples.ts";
+import { RENDER_CHANNELS, encodeWav } from "./wav.ts";
+
+/** Bars rendered before a section or bar range for effect tails. */
+export const PREROLL_BARS = 2;
+
+/** Voice gain the new sampler track plays the file at. */
+export const RESAMPLE_GAIN = 2;
+/** File level over the rendered stem so the voice reproduces it. */
+export const RESAMPLE_FILE_SCALE =
+  Math.SQRT1_2 / (SAMPLE_LEVEL * RESAMPLE_GAIN * 0.5);
+
+export type ResampleSource =
+  | Readonly<{ kind: "track"; trackId: string }>
+  | Readonly<{ kind: "orbit"; orbit: number }>
+  | Readonly<{ kind: "master" }>;
+
+export type ResampleRange =
+  | Readonly<{ kind: "song" }>
+  | Readonly<{ kind: "section"; name: string }>
+  | Readonly<{ kind: "bars"; from: number; to: number }>;
+
+export type ResampleRequest = Readonly<{
+  source: ResampleSource;
+  range: ResampleRange;
+  /** Keep the song master on the render (always on for `master`). */
+  post?: boolean;
+}>;
+
+export type ResampleRender = Readonly<{
+  wav: Uint8Array;
+  sha256: string;
+  sampleRate: number;
+  seconds: number;
+  /** Score tick the rendered range starts at (where the new note goes). */
+  startTick: number;
+  /** Ticks the range covers (the new note's length). */
+  durationTicks: number;
+  from: SampleProvenance;
+}>;
+
+/** `track:<id>`, `orbit:<n>` or `master`: the provenance source name. */
+export function resampleSourceName(source: ResampleSource): string {
+  if (source.kind === "track") return `track:${source.trackId}`;
+  if (source.kind === "orbit") return `orbit:${source.orbit}`;
+  return "master";
+}
+
+/** sha256 of the score's canonical JSON (the provenance pin). */
+export function scoreSha256(score: TrackScore): string {
+  return createHash("sha256")
+    .update(JSON.stringify(score.toJSON()))
+    .digest("hex");
+}
+
+/** The tracks a source plays (throws for an unknown track or empty orbit). */
+export function resampleTracks(
+  score: TrackScore,
+  source: ResampleSource,
+): readonly Track[] {
+  if (source.kind === "master") return score.tracks;
+  const tracks =
+    source.kind === "track"
+      ? score.tracks.filter((track) => track.id === source.trackId)
+      : score.tracks.filter((track) => orbitOf(track) === source.orbit);
+  if (tracks.length === 0)
+    throw new ScoreValidationError(
+      source.kind === "track"
+        ? `no track ${source.trackId}`
+        : `no track plays on orbit ${source.orbit}`,
+      "invalid-track",
+    );
+  return tracks;
+}
+
+/**
+ * The score the render plays: the source soloed (every other track muted),
+ * the master removed unless `post`, cut to the range. Returns where the
+ * range sits in the song.
+ */
+export function resampleScore(
+  score: TrackScore,
+  request: ResampleRequest,
+): Readonly<{
+  score: TrackScore;
+  startTick: number;
+  durationTicks: number;
+  /** Ticks of lead-in the render plays before the range (sliced off). */
+  leadTicks: number;
+}> {
+  const sources = new Set(
+    resampleTracks(score, request.source).map((track) => track.id),
+  );
+  const post = request.post === true || request.source.kind === "master";
+  const json = { ...score.toJSON() } as Record<string, unknown>;
+  json.tracks = score.tracks.map((track) => {
+    const copy = { ...track } as Record<string, unknown>;
+    delete copy.solo;
+    // Solo, not mute, the others: a granular `quant chord` source still
+    // hears the song's harmony (muted tracks leave the chord).
+    if (request.source.kind !== "master" && sources.has(track.id)) {
+      delete copy.muted;
+      copy.solo = true;
+    }
+    return copy;
+  });
+  if (!post) delete json.master;
+  let played = new TrackScore(json as never);
+  const ticks = barTicks(played);
+  const range = request.range;
+  if (range.kind === "song")
+    return {
+      score: played,
+      startTick: 0,
+      durationTicks: played.bars * ticks,
+      leadTicks: 0,
+    };
+  let section;
+  if (range.kind === "section") {
+    section = findSection(played, range.name);
+    if (!section)
+      throw new ScoreValidationError(
+        `no section named ${range.name}${played.sections.length > 0 ? ` (sections: ${played.sections.map((s) => s.name).join(", ")})` : ""}`,
+        "invalid-track",
+      );
+  } else {
+    if (
+      !Number.isInteger(range.from) ||
+      !Number.isInteger(range.to) ||
+      range.from < 1 ||
+      range.to < range.from ||
+      range.to > played.bars
+    )
+      throw new ScoreValidationError(
+        `bars must be a-b inside 1-${played.bars}`,
+        "invalid-track",
+      );
+    section = {
+      name: "resample",
+      startBar: range.from - 1,
+      bars: range.to - range.from + 1,
+    };
+  }
+  // Lead-in: notes still sounding at the range start, and the effect tails
+  // of the bars before it, play from where they began (PREROLL_BARS back at
+  // least); the render then drops the lead-in frames.
+  const from = section.startBar * ticks;
+  let leadBar = Math.max(0, section.startBar - PREROLL_BARS);
+  for (const note of played.notes)
+    if (
+      sources.has(note.trackId) &&
+      note.startTick < from &&
+      note.startTick + note.durationTicks > from
+    )
+      leadBar = Math.min(leadBar, Math.floor(note.startTick / ticks));
+  const lead = section.startBar - leadBar;
+  played = sectionScore(played, {
+    ...section,
+    startBar: leadBar,
+    bars: section.bars + lead,
+  });
+  return {
+    score: played,
+    startTick: from,
+    durationTicks: section.bars * ticks,
+    leadTicks: lead * ticks,
+  };
+}
+
+/**
+ * Render a resample to WAV bytes. `samples` is the source score's loaded
+ * bank (needed when the source plays samples).
+ */
+export function renderResample(
+  score: TrackScore,
+  request: ResampleRequest,
+  samples?: SampleBank,
+): ResampleRender {
+  const {
+    score: played,
+    startTick,
+    durationTicks,
+    leadTicks,
+  } = resampleScore(score, request);
+  // The song's export rate (48 kHz once it has a master), so the new
+  // track nulls against the source when both play at that rate.
+  const sampleRate = exportSampleRate(score);
+  const rendered = renderArrangedPcm(played, {
+    sampleRate,
+    loop: false,
+    ...(samples ? { samples } : {}),
+  });
+  const skip = Math.min(
+    rendered.frames,
+    Math.round(secondsAtTick(played, leadTicks) * rendered.sampleRate),
+  );
+  const audio =
+    skip === 0
+      ? rendered
+      : {
+          ...rendered,
+          frames: rendered.frames - skip,
+          pcm: rendered.pcm.subarray(skip * RENDER_CHANNELS),
+        };
+  const full = new Int16Array(audio.pcm.length);
+  for (let index = 0; index < full.length; index += 1)
+    full[index] = Math.max(
+      -32_768,
+      Math.min(32_767, Math.round(audio.pcm[index]! * RESAMPLE_FILE_SCALE)),
+    );
+  // Trim the tail that rounds to digital silence (within 1 LSB): the new
+  // track's note length comes from the range, not from the file.
+  let end = full.length;
+  while (end > 0 && Math.abs(full[end - 1]!) <= 1) end -= 1;
+  if (end === 0)
+    throw new ScoreValidationError(
+      `${resampleSourceName(request.source)} is silent here · nothing to resample (add notes, unmute it or pick other bars)`,
+    );
+  // Keep 20 ms of silence so the sampler's end fade lands on nothing.
+  const frames = Math.min(
+    audio.frames,
+    Math.ceil(end / RENDER_CHANNELS) + Math.round(0.02 * audio.sampleRate),
+  );
+  const pcm = full.subarray(0, frames * RENDER_CHANNELS);
+  const seconds = frames / audio.sampleRate;
+  if (seconds > SCORE_LIMITS.maxResampleSeconds)
+    throw new ScoreValidationError(
+      `the resample is ${Math.round(seconds)} s; the limit is ${SCORE_LIMITS.maxResampleSeconds} s · pick a section or bars`,
+      "score-limit",
+    );
+  const wav = encodeWav(pcm, audio.sampleRate, RENDER_CHANNELS);
+  const range = request.range;
+  const from: SampleProvenance = {
+    source: resampleSourceName(request.source),
+    ...(range.kind === "section"
+      ? { section: findSection(score, range.name)?.name ?? range.name }
+      : {}),
+    ...(range.kind === "bars" ? { bars: [range.from, range.to] as const } : {}),
+    score: scoreSha256(score),
+  };
+  return {
+    wav,
+    sha256: createHash("sha256").update(wav).digest("hex"),
+    sampleRate: audio.sampleRate,
+    seconds,
+    startTick,
+    durationTicks,
+    from,
+  };
+}

package/src/audio/resonators.ts

@@ -158,6 +158,11 @@ export function renderResonatorTrack(
       : 1);
   const seedTick = context.seedTick ?? 0;
   const base = modalSettings(track.modal);
+  // An ombak pair (f061-gamelan-winds): the pengisep names its partner in
+  // `pair` and sounds `ombak` Hz above the same note, single voice; the
+  // partner (pengumbang) carries ombak 0. Each track renders from its own
+  // field, so stems key per track.
+  const paired = track.modal?.pair !== undefined;
   const banks: ModalBank[] = [];
   // Conservative end of each planned voice (its ring cap, or a steal).
   const ends: number[] = [];
@@ -186,10 +191,11 @@ export function renderResonatorTrack(
       performance?.accent || note.articulation === "marcato"
         ? ACCENT_HARDNESS
         : 0;
+    const hz = noteHz(note.pitch, note.cents, context.tuning);
     const bank = new ModalBank(
-      settings,
+      paired ? { ...settings, ombak: 0 } : settings,
       {
-        hz: noteHz(note.pitch, note.cents, context.tuning),
+        hz: paired ? hz + settings.ombak : hz,
         velocity: note.velocity,
         start: start / sampleRate,
         duration: length / sampleRate,
@@ -282,6 +288,8 @@ export const MODAL_ENGINE: InstrumentEngine = Object.freeze({
   },
   tailSeconds: (track: Track, lowestPitch?: number) =>
     modalTailSeconds(track.modal, lowestPitch),
+  // Undamped bars and gongs ring on after the key lifts, as struck metal does.
+  ringOut: (track: Track) => modalSettings(track.modal).damp === 0,
   stereo: () => false,
   assetDigests: () => [`resonators:${RESONATOR_TABLE_VERSION}`],
 });

package/src/audio/sampler.ts

@@ -32,6 +32,7 @@ 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,
@@ -46,7 +47,7 @@ import {
   type FitMap,
   type SampleWarp,
 } from "./warp.ts";
-import { fittedBuffer, windowAt } from "./fit.ts";
+import { fittedBuffer, shiftedBuffer, windowAt } from "./fit.ts";
 import {
   performanceTimingFor,
   tunedTiming,
@@ -106,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;
 };
 
 /**
@@ -160,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,
@@ -224,7 +302,7 @@ 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
@@ -256,8 +334,19 @@ export function planSamplerVoices(
       ? fitVoice(ref, decoded, note.startTick, held, timing, reach)
       : undefined;
     if (fitted === null) continue;
-    const sample = fitted?.sample ?? decoded;
-    const speed = fitted ? 1 : (ref.speed ?? 1);
+    // 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
@@ -277,7 +366,14 @@ export function planSamplerVoices(
         ? ((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));
@@ -294,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).
@@ -308,7 +404,7 @@ 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 = fitted
@@ -341,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 } : {}),
     };
@@ -456,6 +558,48 @@ function fitVoice(
   });
 }
 
+/** 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()];
@@ -483,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 =
@@ -491,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)
@@ -549,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

@@ -58,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<{
@@ -324,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);
@@ -896,6 +916,7 @@ export class SampleLibrary implements SampleSource {
       channels: pcm.channels,
       frames: pcm.frames,
       mono: monoMix(pcm),
+      ...stereoChannels(pcm),
     });
     this.remember(sample);
     return sample;
@@ -943,6 +964,7 @@ export class SampleLibrary implements SampleSource {
       channels: pcm.channels,
       frames: pcm.frames,
       mono: monoMix(pcm),
+      ...stereoChannels(pcm),
     });
     this.remember(sample);
     return sample;
@@ -966,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) {