@hraness/dawg 0.4.1 → 0.5.0

package/src/audio/measure.ts

@@ -0,0 +1,110 @@
+/**
+ * Render a score and measure the result: the shared path behind
+ * `master measure`, `dawg render`'s loudness line and the measure_mix agent
+ * tool. The loop is measured as a loop playing forever (its steady state),
+ * a one-shot as rendered, so every reading matches what playback and export
+ * produce. Measuring never changes the score.
+ */
+import type { TrackScore } from "../../core/score.ts";
+import type { MeasureReply, MeasureRequest } from "./measure-worker.ts";
+import { measureMix, pcmChannels, type MixMeasurement } from "./loudness.ts";
+import type { MasterReport } from "./master.ts";
+import {
+  DEFAULT_SAMPLE_RATE,
+  renderScorePcm,
+  type RenderedAudio,
+  type RenderOptions,
+} from "./wav.ts";
+
+/** The rate a song with a master exports (and is measured) at. */
+export const MASTER_SAMPLE_RATE = 48_000;
+
+/**
+ * The rate `dawg render` writes and measurements use, so a reading matches
+ * the exported file: 48 kHz once the song has a master (a deliverable, with
+ * room for the high shelf and a true peak a platform's resampler will not
+ * raise), the engine's 22,050 Hz otherwise (dawg 0.4 exports unchanged).
+ */
+export function exportSampleRate(score: TrackScore): number {
+  return score.master ? MASTER_SAMPLE_RATE : DEFAULT_SAMPLE_RATE;
+}
+
+export type ScoreMeasurement = Readonly<{
+  mix: MixMeasurement;
+  master?: MasterReport;
+  sampleRate: number;
+  seconds: number;
+  loop: boolean;
+}>;
+
+/** Measure audio rendered elsewhere (the export, a preview). */
+export function measureRendered(
+  audio: RenderedAudio,
+  loop: boolean,
+): ScoreMeasurement {
+  const [left, right] = pcmChannels(audio.pcm);
+  return Object.freeze({
+    mix: measureMix(left, right, audio.sampleRate, { loop }),
+    ...(audio.master ? { master: audio.master } : {}),
+    sampleRate: audio.sampleRate,
+    seconds: audio.frames / audio.sampleRate,
+    loop,
+  });
+}
+
+/** Render `score` (as a loop by default) and measure it. */
+export function measureScore(
+  score: TrackScore,
+  options: RenderOptions = {},
+): ScoreMeasurement {
+  const loop = options.loop ?? true;
+  const audio = renderScorePcm(score, {
+    sampleRate: exportSampleRate(score),
+    ...options,
+    loop,
+  });
+  return measureRendered(audio, loop);
+}
+
+/**
+ * `measureScore` in a worker, so the caller's thread keeps running; falls
+ * back to measuring inline if the worker cannot start or fails.
+ */
+export async function measureScoreOffThread(
+  score: TrackScore,
+  options: Readonly<{
+    sampleRate?: number;
+    loop?: boolean;
+    projectRoot?: string;
+  }> = {},
+): Promise<ScoreMeasurement> {
+  let worker: Worker | undefined;
+  try {
+    worker = new Worker(new URL("./measure-worker.ts", import.meta.url).href);
+    const running = worker;
+    const reply = await new Promise<MeasureReply>((resolve, reject) => {
+      running.addEventListener("message", (event) =>
+        resolve((event as MessageEvent<MeasureReply>).data),
+      );
+      running.addEventListener("error", (event) =>
+        reject(new Error((event as ErrorEvent).message ?? "worker error")),
+      );
+      const request: MeasureRequest = {
+        score: score.toJSON(),
+        ...options,
+      };
+      running.postMessage(request);
+    });
+    if (reply.ok) return reply.measured;
+    throw new Error(reply.error);
+  } catch {
+    return measureScore(score, {
+      ...(options.sampleRate === undefined
+        ? {}
+        : { sampleRate: options.sampleRate }),
+      ...(options.loop === undefined ? {} : { loop: options.loop }),
+    });
+  } finally {
+    worker?.terminate();
+  }
+}

package/src/audio/player.ts

@@ -2,7 +2,9 @@ import { unlink } from "node:fs/promises";
 import type { TrackScore } from "../../core/score.ts";
 import { PlaybackLock } from "./lock.ts";
 import { SampleLibrary, hasSamplerTracks, type SampleBank } from "./samples.ts";
-import { RENDER_CHANNELS, encodeWav, renderScorePcm } from "./wav.ts";
+import { RENDER_CHANNELS, encodeWav } from "./wav.ts";
+import { transportMapFor } from "./clock.ts";
+import { playbackTime, renderArrangedPcm } from "./arrange.ts";
 
 /** Small best-effort local player. The score and transport remain testable without a sound device. */
 export class LoopPlayer {
@@ -118,12 +120,15 @@ export function renderLoopWav(
   beat = 0,
   samples?: SampleBank,
 ): Uint8Array {
-  const audio = renderScorePcm(score, { loop: true, samples });
-  const framesPerBeat = (60 * audio.sampleRate) / score.tempoBpm;
+  const audio = renderArrangedPcm(score, { loop: true, samples });
+  const timeline = playbackTime(score);
+  const framesPerBeat = (60 * audio.sampleRate) / timeline.tempoBpm;
+  const map = transportMapFor(timeline);
+  const first = map
+    ? map.seconds(Math.max(0, beat) % map.loopBeats) * audio.sampleRate
+    : Math.max(0, beat) * framesPerBeat;
   const start =
-    ((Math.round(Math.max(0, beat) * framesPerBeat) % audio.frames) +
-      audio.frames) %
-    audio.frames;
+    ((Math.round(first) % audio.frames) + audio.frames) % audio.frames;
   const rotated = new Int16Array(audio.pcm.length);
   rotated.set(audio.pcm.subarray(start * RENDER_CHANNELS));
   rotated.set(

package/src/audio/preview.ts

@@ -16,6 +16,7 @@
  * wavetables so position changes are audible.
  */
 import { isDrumInstrument } from "../../core/drums.ts";
+import type { SongMaster } from "../../core/master.ts";
 import { MODES, parseKey } from "../../core/chords.ts";
 import { rhythmVoicePitch } from "../../core/rhythm.ts";
 import {
@@ -28,7 +29,9 @@ import {
   type NoteInput,
   type Track,
 } from "../../core/score.ts";
+import { barAt, barStartTick, songTimeSlice } from "../../core/tempo.ts";
 import { interpolateAutomation } from "./effects/common.ts";
+import { loopedSection, scoreBeatAt } from "./arrange.ts";
 import { RENDER_CHANNELS } from "./wav.ts";
 
 /** Longest preview loop, in bars. */
@@ -56,6 +59,14 @@ export type PreviewOptions = Readonly<{
    * the staged settings this way, so a voicing or arp change is audible.
    */
   phrase?: (score: TrackScore, track: Track, bars: number) => NoteInput[];
+  /**
+   * The limiter drive the song's master solved for its loudness target on
+   * the full mix, dB. A preview plays the master at this fixed drive instead
+   * of re-solving the target on its few bars, so a volume edit stays
+   * audible. Without it a solo plays the master with no target (the
+   * limiter at its own gain), and a context preview solves on its bars.
+   */
+  masterGainDb?: number;
 }>;
 
 export type Preview = Readonly<{
@@ -72,23 +83,42 @@ export function previewRegion(
   trackId: string,
   beat = 0,
 ): PreviewRegion {
-  if (score.bars <= MAX_PREVIEW_BARS) return { startBar: 0, bars: score.bars };
+  // A looped section bounds the audition, and the playhead (an arranged
+  // beat when the song has a form) maps back to the bars it is playing.
+  const section = loopedSection(score);
+  const bounded = section !== undefined && section.startBar < score.bars;
+  const lo = bounded ? section.startBar : 0;
+  const hi = bounded
+    ? Math.min(score.bars, section.startBar + section.bars)
+    : score.bars;
+  if (hi - lo <= MAX_PREVIEW_BARS) return { startBar: lo, bars: hi - lo };
   const bars = PREVIEW_REGION_BARS;
-  const barTicks = score.beatsPerBar * score.ticksPerBeat;
-  const last = score.bars - bars;
+  const last = hi - bars;
   const clampBar = (bar: number) =>
-    Math.max(0, Math.min(last, Number.isFinite(bar) ? Math.floor(bar) : 0));
-  let startBar = clampBar(beat / score.beatsPerBar);
+    Math.max(lo, Math.min(last, Number.isFinite(bar) ? Math.floor(bar) : lo));
+  // Bars through the meter changes; 0.4 scores keep `beat / beatsPerBar`.
+  const barOfTick = (tick: number) => barAt(score, tick).bar;
+  const scoreBeat = scoreBeatAt(score, beat);
+  let startBar = clampBar(
+    Number.isFinite(scoreBeat) ? barOfTick(scoreBeat * score.ticksPerBeat) : lo,
+  );
   const notes = score.notes.filter((note) => note.trackId === trackId);
   const inRegion = (from: number) =>
     notes.some(
       (note) =>
-        note.startTick >= from * barTicks &&
-        note.startTick < (from + bars) * barTicks,
+        note.startTick >= barStartTick(score, from) &&
+        note.startTick < barStartTick(score, from + bars),
     );
-  if (notes.length > 0 && !inRegion(startBar)) {
-    const first = Math.min(...notes.map((note) => note.startTick));
-    startBar = clampBar(first / barTicks);
+  const loTick = barStartTick(score, lo);
+  const hiTick = barStartTick(score, hi);
+  const pool = bounded
+    ? notes.filter(
+        (note) => note.startTick >= loTick && note.startTick < hiTick,
+      )
+    : notes;
+  if (pool.length > 0 && !inRegion(startBar)) {
+    const first = Math.min(...pool.map((note) => note.startTick));
+    startBar = clampBar(barOfTick(first));
   }
   return { startBar, bars };
 }
@@ -277,9 +307,8 @@ export function previewScore(
     Math.min(region.bars, score.bars - Math.max(0, region.startBar)),
   );
   const startBar = Math.max(0, Math.min(region.startBar, score.bars - 1));
-  const barTicks = score.beatsPerBar * score.ticksPerBeat;
-  const start = startBar * barTicks;
-  const end = start + bars * barTicks;
+  const start = barStartTick(score, startBar);
+  const end = barStartTick(score, startBar + bars);
   const context = options.context === true;
   const anySolo = score.tracks.some((candidate) => candidate.solo === true);
   const tracks = score.tracks
@@ -313,14 +342,23 @@ export function previewScore(
     role = phraseRole(track);
     notes.push(...defaultPhrase(score, track, bars, role));
   }
+  // The song's tempo map and meter, rebased to the region's first bar.
+  const timing = songTimeSlice(score, startBar, bars);
   const preview = new TrackScore({
-    tempoBpm: score.tempoBpm,
+    tempoBpm: timing.tempoBpm,
+    ...(timing.time ? { time: timing.time } : {}),
     beatsPerBar: score.beatsPerBar,
     bars,
     ticksPerBeat: score.ticksPerBeat,
     key: score.key,
     tracks,
     notes,
+    // The master is the song's output stage, so a soloed preview passes
+    // through it too, the way a DAW solo still reaches the master bus: at
+    // the song's fixed drive, not a target re-solved on what is soloed.
+    ...(score.master
+      ? { master: previewMaster(score.master, context, options.masterGainDb) }
+      : {}),
   });
   return {
     score: preview,
@@ -330,6 +368,28 @@ export function previewScore(
   };
 }
 
+/**
+ * The master a preview plays: the song's, with its loudness target swapped
+ * for a fixed limiter drive (see PreviewOptions.masterGainDb).
+ */
+export function previewMaster(
+  master: SongMaster,
+  context: boolean,
+  masterGainDb: number | undefined,
+): SongMaster {
+  if (master.target === undefined) return master;
+  if (masterGainDb === undefined && context) return master;
+  const { target: _target, ...rest } = master;
+  if (!rest.limiter || masterGainDb === undefined) return rest;
+  return {
+    ...rest,
+    limiter: {
+      ...rest.limiter,
+      gain: Math.max(0, Math.min(24, masterGainDb)),
+    },
+  };
+}
+
 // ── analysis ──────────────────────────────────────────────────────────
 
 export type SoundStats = Readonly<{

package/src/audio/render-worker.ts

@@ -5,6 +5,8 @@
  */
 import { scoreFromJSON } from "../../core/score.ts";
 import { SampleLibrary, hasSamplerTracks } from "./samples.ts";
+import type { MasterReport } from "./master.ts";
+import { renderArranged } from "./arrange.ts";
 import { StemRenderer } from "./wav.ts";
 
 export type RenderRequest = Readonly<{
@@ -24,6 +26,8 @@ export type RenderReply =
       pcm: Int16Array;
       /** Milliseconds spent rendering, excluding transfer. */
       renderMs: number;
+      /** Loudness after the song master; absent without one. */
+      master?: MasterReport;
     }>
   | Readonly<{ id: number; ok: false; error: string }>;
 
@@ -43,7 +47,7 @@ self.onmessage = async (event: MessageEvent<RenderRequest>) => {
         library = new SampleLibrary({ projectRoot });
       samples = await library.load(parsed);
     }
-    const audio = renderer.render(parsed, {
+    const audio = renderArranged(renderer, parsed, {
       sampleRate,
       loop: true,
       samples,
@@ -55,6 +59,7 @@ self.onmessage = async (event: MessageEvent<RenderRequest>) => {
       sampleRate: audio.sampleRate,
       pcm: audio.pcm,
       renderMs: performance.now() - started,
+      ...(audio.master ? { master: audio.master } : {}),
     };
     self.postMessage(reply, [audio.pcm.buffer]);
   } catch (error) {

package/src/audio/renderer.ts

@@ -1,6 +1,8 @@
 import type { TrackScore } from "../../core/score.ts";
+import type { MasterReport } from "./master.ts";
 import type { RenderReply, RenderRequest } from "./render-worker.ts";
 import { SampleLibrary, hasSamplerTracks } from "./samples.ts";
+import { renderArranged } from "./arrange.ts";
 import { StemRenderer } from "./wav.ts";
 
 export type LoopRender = Readonly<{
@@ -9,6 +11,8 @@ export type LoopRender = Readonly<{
   sampleRate: number;
   /** Milliseconds the render itself took (worker or inline). */
   renderMs: number;
+  /** Loudness after the song master; absent without one. */
+  master?: MasterReport;
 }>;
 
 export type LoopRendererOptions = Readonly<{
@@ -80,7 +84,7 @@ export class LoopRenderer {
       this.library ??= new SampleLibrary({ projectRoot: this.projectRoot });
       samples = await this.library.load(score);
     }
-    const audio = this.inline.render(score, {
+    const audio = renderArranged(this.inline, score, {
       sampleRate: this.sampleRate,
       loop: true,
       samples,
@@ -90,6 +94,7 @@ export class LoopRenderer {
       frames: audio.frames,
       sampleRate: audio.sampleRate,
       renderMs: performance.now() - started,
+      ...(audio.master ? { master: audio.master } : {}),
     };
   }
 
@@ -143,6 +148,7 @@ export class LoopRenderer {
           frames: reply.frames,
           sampleRate: reply.sampleRate,
           renderMs: reply.renderMs,
+          ...(reply.master ? { master: reply.master } : {}),
         });
       else waiter.reject(new Error(reply.error));
     });

package/src/audio/sampler.ts

@@ -13,7 +13,8 @@
  *   `accelerate` ramps the rate; `squiz` raises pitch per zero-crossing
  *   cycle (described in Tidal/SuperDirt docs; implemented here from that
  *   description).
- * - keyed mode repitches from `root` (rate × 2^((pitch − root)/12)) and holds
+ * - keyed mode repitches from `root` (rate × 2^((pitch − root)/12), or the
+ *   tuning's key frequency over the root's 12-TET frequency) and holds
  *   for the note's length; oneshot mode maps voices to pitch slots from 36 in
  *   voice-name order and plays the whole window unless `loop` is set.
  *
@@ -31,6 +32,21 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import { sampleKey, type DecodedSample, type SampleBank } from "./samples.ts";
+import {
+  barAt,
+  loopSecondsOf,
+  performedNotes,
+  secondsAtTick,
+} from "../../core/tempo.ts";
+import { sampleWarpFor, warpedSpan, type SampleWarp } from "./warp.ts";
+import {
+  performanceTimingFor,
+  tunedTiming,
+  performNotes,
+  type NotePerformance,
+  type PerformedNote,
+} from "../../core/expression.ts";
+import { resolveTuning, type TuningTable } from "../../core/tuning.ts";
 
 /** Output level of a full-scale sample at velocity 1 and gain 1. */
 export const SAMPLE_LEVEL = 0.7;
@@ -46,6 +62,8 @@ const LOOP_CROSSFADE_SECONDS = 0.005;
 export type SamplerTiming = Readonly<{
   score: TrackScore;
   sampleRate: number;
+  /** The song's tempo map in samples; absent keeps constant tempo. */
+  warp?: SampleWarp;
 }>;
 
 /** One planned voice: when it sounds and how it reads its sample. */
@@ -74,6 +92,10 @@ export type SamplerVoice = {
   readonly ramp: number;
   /** `squiz` ratio; 1 is off. */
   readonly squiz: number;
+  /** Note expression: pitch in cents over time (glide, bend, vibrato). */
+  readonly cents?: NotePerformance["cents"];
+  /** Half pedal: the level fades from `from` seconds. */
+  readonly damp?: NotePerformance["damp"];
 };
 
 /**
@@ -96,7 +118,8 @@ function framesToTravel(distance: number, step: number, ramp: number): number {
 }
 
 function noteStartFrame(note: Note, timing: SamplerTiming): number {
-  const { score, sampleRate } = timing;
+  const { score, sampleRate, warp } = timing;
+  if (warp) return warpedSpan(warp, note.startTick, note.durationTicks).start;
   return Math.max(
     0,
     Math.floor(
@@ -107,7 +130,8 @@ function noteStartFrame(note: Note, timing: SamplerTiming): number {
 }
 
 function noteLengthFrames(note: Note, timing: SamplerTiming): number {
-  const { score, sampleRate } = timing;
+  const { score, sampleRate, warp } = timing;
+  if (warp) return warpedSpan(warp, note.startTick, note.durationTicks).length;
   return Math.max(
     1,
     Math.floor(
@@ -117,9 +141,15 @@ function noteLengthFrames(note: Note, timing: SamplerTiming): number {
   );
 }
 
-/** Which voice a note plays and the pitch ratio it plays at. */
+/**
+ * Which voice a note plays and the pitch ratio it plays at. A keyed voice
+ * repitches to the tuning's key frequency over its root's 12-TET frequency
+ * (a sample is recorded at concert pitch); one-shot slots ignore tuning,
+ * since their pitch picks a voice rather than a note.
+ */
 function voiceResolver(
   track: Track,
+  tuning?: TuningTable,
 ): (pitch: number) => { voice: string; ratio: number } | undefined {
   const sampler = track.sampler!;
   if (sampler.mode === "oneshot") {
@@ -141,7 +171,14 @@ function voiceResolver(
     for (const candidate of keyed)
       if (candidate.root <= pitch) chosen = candidate;
     if (!chosen) return undefined;
-    return { voice: chosen.voice, ratio: 2 ** ((pitch - chosen.root) / 12) };
+    if (!tuning)
+      return { voice: chosen.voice, ratio: 2 ** ((pitch - chosen.root) / 12) };
+    const hz = tuning.hz[pitch]!;
+    if (!(hz > 0)) return undefined;
+    return {
+      voice: chosen.voice,
+      ratio: hz / (440 * 2 ** ((chosen.root - 69) / 12)),
+    };
   };
 }
 
@@ -154,7 +191,10 @@ export function planSamplerVoices(
 ): SamplerVoice[] {
   const sampler = track.sampler;
   if (!sampler) return [];
-  const resolve = voiceResolver(track);
+  const resolve = voiceResolver(
+    track,
+    resolveTuning(timing.score.tuning, track.tuning, timing.score.key),
+  );
   const ordered = [...notes].sort(
     (a, b) =>
       a.startTick - b.startTick ||
@@ -174,8 +214,12 @@ export function planSamplerVoices(
     voice.fade = Math.min(fade, end - voice.start);
   };
   for (const note of ordered) {
-    const target = resolve(note.pitch);
-    if (!target) continue;
+    const resolved = resolve(note.pitch);
+    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;
@@ -189,9 +233,7 @@ export function planSamplerVoices(
     const seconds = ref.fit
       ? held / sampleRate
       : unit === "c"
-        ? (timing.score.beatsPerBar * 60) /
-          timing.score.tempoBpm /
-          Math.abs(speed)
+        ? cycleSeconds(timing.score, note.startTick) / Math.abs(speed)
         : unit === "s"
           ? Math.abs(speed)
           : undefined;
@@ -239,6 +281,7 @@ export function planSamplerVoices(
     const loopTo =
       ref.loopEnd === undefined ? regionEnd : ref.loopEnd * sample.frames;
     const start = noteStartFrame(note, timing);
+    const performance = (note as PerformedNote).performance;
     const voice: SamplerVoice = {
       voice: target.voice,
       sample,
@@ -257,6 +300,8 @@ export function planSamplerVoices(
       loopSpan: loopTo - loopFrom,
       ramp,
       squiz: ref.squiz ?? 1,
+      ...(performance?.cents ? { cents: performance.cents } : {}),
+      ...(performance?.damp ? { damp: performance.damp } : {}),
     };
     if (voice.choke !== undefined) {
       const previous = lastInGroup.get(voice.choke);
@@ -293,7 +338,7 @@ export function renderSamplerVoices(
   timing: SamplerTiming,
   gainAt: (tick: number) => number,
 ): void {
-  const { sampleRate, score } = timing;
+  const { sampleRate, score, warp } = timing;
   const samplesPerTick =
     (sampleRate * 60) / (score.tempoBpm * score.ticksPerBeat);
   const attack = Math.max(1, ATTACK_SECONDS * sampleRate);
@@ -311,10 +356,31 @@ export function renderSamplerVoices(
     const level = SAMPLE_LEVEL * voice.gain;
     const at = (offset: number) =>
       readAt(mono, reverse ? regionEnd - 1 - offset : regionStart + offset);
+    // A bent voice (note expression) integrates its rate frame by frame;
+    // reads arrive in order, so the running sum is kept between calls.
+    const bent = voice.cents;
+    let bentAt = 0;
+    let bentTravel = 0;
+    const travel = (elapsed: number): number => {
+      if (!bent)
+        return ramp === 0 ? elapsed * step : travelAt(elapsed, step, ramp);
+      if (elapsed < bentAt) {
+        bentAt = 0;
+        bentTravel = 0;
+      }
+      while (bentAt < elapsed) {
+        const rate =
+          step *
+          (ramp === 0 ? 1 : Math.max(0, 1 + ramp * bentAt)) *
+          2 ** (bent(bentAt / sampleRate) / 1200);
+        bentTravel += rate;
+        bentAt += 1;
+      }
+      return bentTravel;
+    };
     // The raw read at an elapsed frame, or undefined past a one-shot's end.
     const read = (elapsed: number): number | undefined => {
-      const travelled =
-        ramp === 0 ? elapsed * step : travelAt(elapsed, step, ramp);
+      const travelled = travel(elapsed);
       if (!loop) return travelled >= span ? undefined : at(travelled);
       if (travelled < loopStart) return at(travelled);
       const into = travelled - loopStart;
@@ -339,11 +405,16 @@ export function renderSamplerVoices(
       if (value === undefined) break;
       let envelope = Math.min(1, elapsed / attack);
       if (index >= fadeFrom) envelope *= (voice.end - index) / voice.fade;
+      const damp = voice.damp;
+      if (damp && elapsed / sampleRate > damp.from)
+        envelope *= Math.exp(-(elapsed / sampleRate - damp.from) / damp.tau);
       target[index]! +=
         value *
         envelope *
         level *
-        gainAt(voice.startTick + elapsed / samplesPerTick);
+        gainAt(
+          warp ? warp.tick(index) : voice.startTick + elapsed / samplesPerTick,
+        );
     }
   }
 }
@@ -406,15 +477,33 @@ export function samplerTailSeconds(
   sampleRate: number,
 ): number {
   if (bank.voices.size === 0) return 0;
-  const loopEnd =
-    ((score.bars * score.beatsPerBar * 60) / score.tempoBpm) * sampleRate;
-  const timing = { score, sampleRate };
+  const loopEnd = loopSecondsOf(score) * sampleRate;
+  const warp = sampleWarpFor(score, sampleRate);
+  const timing = { score, sampleRate, ...(warp ? { warp } : {}) };
   let latest = 0;
+  const performance = performanceTimingFor(score);
   for (const track of score.tracks) {
     if (!track.sampler) continue;
-    const notes = score.notes.filter((note) => note.trackId === track.id);
+    const notes = performNotes(
+      track,
+      performedNotes(score).filter((note) => note.trackId === track.id),
+      tunedTiming(performance, score, track),
+    );
     for (const voice of planSamplerVoices(track, notes, bank, timing))
       latest = Math.max(latest, voice.end - loopEnd);
   }
   return latest / sampleRate;
 }
+
+/**
+ * Seconds of the bar (a `c` cycle) holding `tick`: through the meter and
+ * the tempo map when the song has `time`, else the 0.4 arithmetic.
+ */
+function cycleSeconds(score: TrackScore, tick: number): number {
+  if (!score.time) return (score.beatsPerBar * 60) / score.tempoBpm;
+  const bar = barAt(score, tick);
+  return (
+    secondsAtTick(score, bar.tick + bar.barTicks) -
+    secondsAtTick(score, bar.tick)
+  );
+}