@hraness/dawg 0.4.1 → 0.6.0

package/src/audio/effects/rig/section.ts

@@ -0,0 +1,78 @@
+/**
+ * One oversampler per nonlinear rig section (stomp, head): 4x at 22.05 kHz
+ * and below, 2x at 44.1/48 kHz, from the shared half-band primitives in
+ * src/audio/dsp/oversample.ts. The section's linear-phase delay is removed
+ * so a rigged track stays on the grid.
+ */
+import { Adaa1, logCosh } from "../../dsp/shape.ts";
+import { Oversample2x, Oversample4x } from "../../dsp/oversample.ts";
+
+/** Oversampling factor of a nonlinear section at `sampleRate`. */
+export function sectionFactor(sampleRate: number): 2 | 4 {
+  return sampleRate <= 32_000 ? 4 : 2;
+}
+
+type Oversampler = { process(x: number, fn: (x: number) => number): number };
+
+function oversampler(factor: 2 | 4): Oversampler {
+  return factor === 4 ? new Oversample4x() : new Oversample2x();
+}
+
+const latencies = new Map<number, number>();
+
+/** Base-rate delay of the up/down pair (impulse peak), measured once. */
+export function sectionLatency(factor: 2 | 4): number {
+  const known = latencies.get(factor);
+  if (known !== undefined) return known;
+  const os = oversampler(factor);
+  let peak = 0;
+  let at = 0;
+  for (let i = 0; i < 256; i += 1) {
+    const y = Math.abs(os.process(i === 0 ? 1 : 0, (x) => x));
+    if (y > peak) {
+      peak = y;
+      at = i;
+    }
+  }
+  latencies.set(factor, at);
+  return at;
+}
+
+/**
+ * Runs `fn` over `buffer` at the oversampled rate, in place and latency
+ * compensated. `control(i)` runs at the base rate before sample i.
+ */
+export function runSection(
+  buffer: Float64Array,
+  factor: 2 | 4,
+  fn: (x: number) => number,
+  control?: (index: number) => void,
+): void {
+  const os = oversampler(factor);
+  const latency = sectionLatency(factor);
+  const n = buffer.length;
+  for (let i = 0; i < n + latency; i += 1) {
+    if (control && i < n) control(i);
+    const y = os.process(i < n ? buffer[i]! : 0, fn);
+    if (i >= latency) buffer[i - latency] = y;
+  }
+}
+
+// Static curves with closed-form antiderivatives for first-order ADAA.
+
+/** Triode-like asymmetry: the positive half clips harder (grid current). */
+const ASYM_B = 0.35;
+const ASYM_T = Math.tanh(ASYM_B);
+const asymF = (x: number) => Math.tanh(x + ASYM_B) - ASYM_T;
+const asymAF = (x: number) => logCosh(x + ASYM_B) - ASYM_T * x;
+
+export const adaaTanh = () => new Adaa1(Math.tanh, logCosh);
+export const adaaTriode = () => new Adaa1(asymF, asymAF);
+/** Full-wave rectifier (octave up): |x|, antiderivative x|x|/2. */
+export const adaaRectify = () =>
+  new Adaa1(
+    (x) => Math.abs(x),
+    (x) => 0.5 * x * Math.abs(x),
+  );
+/** RAT diode pair: tanh of a cubic-boosted input (no closed-form F). */
+export const ratClip = (x: number) => Math.tanh(x + 0.18 * x * x * x);

package/src/audio/effects/rig/stomp.ts

@@ -0,0 +1,238 @@
+/**
+ * Stomp boxes (`fx.stomp`): fuzz (Big Muff family), face (Fuzz Face), od
+ * (Tube Screamer), rat (RAT) and octave (Octavia). Circuit-inspired
+ * per-sample models ported from the 0.6 guitar prototype, run inside one
+ * oversampler with ADAA shapers.
+ */
+import type { Adaa1 } from "../../dsp/shape.ts";
+import { Dc, Hp1, Lp1, clamp, dbToGain } from "./filters.ts";
+import {
+  adaaRectify,
+  adaaTanh,
+  adaaTriode,
+  ratClip,
+  runSection,
+} from "./section.ts";
+
+export const STOMP_TYPES = ["fuzz", "face", "od", "rat", "octave"] as const;
+export type StompType = (typeof STOMP_TYPES)[number];
+
+export type StompSettings = {
+  gain: number;
+  tone: number;
+  level: number;
+  octave: number;
+};
+
+/** A stomp circuit at the oversampled rate `sr`. */
+export type StompCircuit = {
+  process(x: number): number;
+  /** Re-reads gain, tone and level (control rate, automated only). */
+  set(settings: StompSettings): void;
+};
+
+export function stompCircuit(
+  type: string,
+  initial: StompSettings,
+  sr: number,
+): StompCircuit {
+  switch (type) {
+    case "fuzz":
+      return fuzz(initial, sr);
+    case "face":
+      return face(initial, sr);
+    case "rat":
+      return rat(initial, sr);
+    case "octave":
+      return octave(initial, sr);
+    default:
+      return od(initial, sr);
+  }
+}
+
+function fuzz(initial: StompSettings, sr: number): StompCircuit {
+  // Input HPF, two cascaded clipping stages with interstage lowpass, then
+  // the passive LP/HP tone blend (the Muff's mid scoop).
+  const hp = new Hp1(90, sr);
+  const s1 = adaaTanh();
+  const s2 = adaaTanh();
+  const lpA = new Lp1(3200, sr);
+  const hpB = new Hp1(60, sr);
+  const lpB = new Lp1(2600, sr);
+  const toneLp = new Lp1(800, sr);
+  const toneHp = new Hp1(1600, sr);
+  let pre = 1;
+  let tone = 0.5;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 2 ** (0.5 + 0.55 * p.gain);
+    tone = clamp(p.tone, 0, 1);
+    out = dbToGain(p.level) * 0.7;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      let x = hp.process(input) * pre;
+      x = lpA.process(s1.process(x)) * 6;
+      x = lpB.process(s2.process(hpB.process(x)));
+      const y = (1 - tone) * toneLp.process(x) + tone * toneHp.process(x) * 1.6;
+      return y * out;
+    },
+  };
+}
+
+function face(initial: StompSettings, sr: number): StompCircuit {
+  // Asymmetric and round; cleans up as the input drops.
+  const hp = new Hp1(40, sr);
+  const s = adaaTriode();
+  const dc = new Dc(sr, 12);
+  const lp = new Lp1(2500, sr);
+  let pre = 1;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 2 ** (0.3 + 0.5 * p.gain);
+    lp.set(2500 + 4000 * clamp(p.tone, 0, 1), sr);
+    out = dbToGain(p.level) * 0.8;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      return lp.process(dc.process(s.process(hp.process(input) * pre))) * out;
+    },
+  };
+}
+
+function od(initial: StompSettings, sr: number): StompCircuit {
+  // Clean path plus a soft-clipped 720 Hz high-passed gain path (diodes in
+  // the op-amp feedback), then the tone lowpass.
+  const hp = new Hp1(720, sr);
+  const lpGain = new Lp1(5600, sr);
+  const s = adaaTanh();
+  const tone = new Lp1(700, sr);
+  let pre = 1;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 1 + 10 ** (p.gain / 5);
+    tone.set(700 * 2 ** (3 * clamp(p.tone, 0, 1)), sr);
+    out = dbToGain(p.level) * 0.6;
+  };
+  set(initial);
+  return {
+    set,
+    process(x) {
+      const y = x + s.process(lpGain.process(hp.process(x) * pre)) * 0.5;
+      return tone.process(y) * out;
+    },
+  };
+}
+
+function rat(initial: StompSettings, sr: number): StompCircuit {
+  // Op-amp gain whose bandwidth shrinks with gain (LM308 GBW), hard diode
+  // clip to ground, then the passive filter.
+  const hp = new Hp1(60, sr);
+  const lpOp = new Lp1(20_000, sr);
+  const filter = new Lp1(475, sr);
+  let gain = 1;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    gain = Math.min(1 + 2 ** (0.67 * p.gain + 1.5), 2000);
+    lpOp.set(clamp(1.0e6 / 3 / gain, 900, 20_000), sr);
+    filter.set(475 * 2 ** (6 * clamp(p.tone, 0, 1)), sr);
+    out = dbToGain(p.level) * 0.55;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      const x = lpOp.process(hp.process(input) * gain * 0.02);
+      return filter.process(ratClip(x)) * out;
+    },
+  };
+}
+
+function octave(initial: StompSettings, sr: number): StompCircuit {
+  // Rectified (octave-up) path blended into a fuzz.
+  const hp = new Hp1(120, sr);
+  const rect: Adaa1 = adaaRectify();
+  const dc = new Dc(sr, 20);
+  const s = adaaTanh();
+  const lp = new Lp1(3000, sr);
+  let pre = 1;
+  let mix = 0.7;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 2 ** (0.5 + 0.5 * p.gain);
+    lp.set(3000 + 4000 * clamp(p.tone, 0, 1), sr);
+    mix = clamp(p.octave, 0, 1);
+    out = dbToGain(p.level) * 0.7;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      const x = hp.process(input);
+      const o = dc.process(rect.process(x * 2)) * 2;
+      return lp.process(s.process(((1 - mix) * x + mix * o) * pre)) * out;
+    },
+  };
+}
+
+/** Stomp calibration input: a 196 Hz (G3) sine at guitar level. */
+export const STOMP_CALIBRATION_DBFS = -18;
+
+const stompMakeups = new Map<string, number>();
+
+/**
+ * Linear gain that brings a pedal at `settings` (level taken as 0 dB) back
+ * to the calibration sine's level, so switching or kicking on a stomp does
+ * not jump the track by 15-25 dB; `level` stays a trim on top. Measured on
+ * the circuit itself, deterministic, cached per settings and rate.
+ */
+export function stompMakeup(
+  type: string,
+  settings: StompSettings,
+  sampleRate: number,
+  factor: 2 | 4,
+): number {
+  const key = `${sampleRate}|${factor}|${type}|${settings.gain}|${settings.tone}|${settings.octave}`;
+  const known = stompMakeups.get(key);
+  if (known !== undefined) return known;
+  const amplitude = 10 ** (STOMP_CALIBRATION_DBFS / 20) * Math.SQRT2;
+  const settle = Math.round(sampleRate * 0.1);
+  const length = settle + Math.round(sampleRate * 0.1);
+  const buffer = new Float64Array(length);
+  const w = (2 * Math.PI * 196) / sampleRate;
+  for (let i = 0; i < length; i += 1) buffer[i] = amplitude * Math.sin(w * i);
+  const circuit = stompCircuit(
+    type,
+    { ...settings, level: 0 },
+    sampleRate * factor,
+  );
+  runSection(buffer, factor, (x) => circuit.process(x));
+  let sum = 0;
+  for (let i = settle; i < length; i += 1) sum += buffer[i]! * buffer[i]!;
+  const rms = Math.sqrt(sum / (length - settle));
+  const target = 10 ** (STOMP_CALIBRATION_DBFS / 20);
+  const makeup = rms > 1e-12 ? target / rms : 1;
+  stompMakeups.set(key, makeup);
+  if (stompMakeups.size > 4096)
+    stompMakeups.delete(stompMakeups.keys().next().value!);
+  return makeup;
+}
+
+/** Makeup for an automated gain: linear between whole steps. */
+export function stompMakeupAt(
+  type: string,
+  settings: StompSettings,
+  sampleRate: number,
+  factor: 2 | 4,
+): number {
+  const g = clamp(settings.gain, 0, 10);
+  const g0 = Math.min(9, Math.floor(g));
+  const at = (gain: number) =>
+    stompMakeup(type, { ...settings, gain }, sampleRate, factor);
+  const a = at(g0);
+  return a + (at(g0 + 1) - a) * (g - g0);
+}

package/src/audio/effects/space.ts

@@ -16,6 +16,7 @@ import {
   OnePole,
   Param,
   interpolateAutomation,
+  tickAtSample,
   type EffectContext,
 } from "./common.ts";
 
@@ -49,7 +50,12 @@ export function applyDelay(
   const feedbackLane = track.delayFeedbackAutomation ?? [];
   const mixLane = track.delayMixAutomation ?? [];
   if (delay.mix <= 0 && mixLane.length === 0) return;
-  const { sampleRate, samplesPerTick } = context;
+  const { sampleRate } = context;
+  const synced = !(delay.time !== undefined && delay.time > 0);
+  if (context.warp && synced) {
+    applyWarpedDelay(left, right, track, context, wetOnly);
+    return;
+  }
   const length = Math.max(
     1,
     Math.round(delaySeconds(track, context.tempoBpm) * sampleRate),
@@ -69,7 +75,7 @@ export function applyDelay(
         ];
   for (let index = 0; index < left.length; index += 1) {
     if (automated && index % CONTROL_SAMPLES === 0) {
-      const tick = index / samplesPerTick;
+      const tick = tickAtSample(context, index);
       feedback = interpolateAutomation(feedbackLane, tick, delay.feedback);
       mix = interpolateAutomation(mixLane, tick, delay.mix);
     }
@@ -98,6 +104,89 @@ export function applyDelay(
   }
 }
 
+/**
+ * The beat-synced delay under a tempo map: the read head trails the write
+ * head by `beats` of score time at every control block, read with linear
+ * interpolation, so each echo lands `beats` later on the grid through tempo
+ * steps, ramps and fermatas. Same routing and lanes as `applyDelay`.
+ */
+function applyWarpedDelay(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+  wetOnly: boolean,
+): void {
+  const delay = track.delay!;
+  const warp = context.warp!;
+  const { sampleRate } = context;
+  const feedbackLane = track.delayFeedbackAutomation ?? [];
+  const mixLane = track.delayMixAutomation ?? [];
+  // Ticks per beat, recovered from the context's start-tempo sample rate.
+  const ticksPerBeat = Math.round(
+    (sampleRate * 60) / (context.tempoBpm * context.samplesPerTick),
+  );
+  const lag = delay.beats * ticksPerBeat;
+  const lagAt = (index: number) =>
+    Math.max(2, index - warp.sample(warp.tick(index) - lag));
+  // Longest lag over the buffer sizes the lines.
+  let longest = 1;
+  for (let index = 0; index <= left.length; index += CONTROL_SAMPLES)
+    longest = Math.max(longest, lagAt(index));
+  const size = Math.ceil(longest) + 2;
+  const lineL = new Float64Array(size);
+  const lineR = new Float64Array(size);
+  const pingpong = delay.pingpong === true;
+  const highcut =
+    delay.highcut === undefined
+      ? undefined
+      : [
+          new OnePole(delay.highcut, sampleRate),
+          new OnePole(delay.highcut, sampleRate),
+        ];
+  let feedback = delay.feedback;
+  let mix = delay.mix;
+  let lagNow = lagAt(0);
+  let lagStep = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    if (index % CONTROL_SAMPLES === 0) {
+      const tick = tickAtSample(context, index);
+      feedback = interpolateAutomation(feedbackLane, tick, delay.feedback);
+      mix = interpolateAutomation(mixLane, tick, delay.mix);
+      lagNow = lagAt(index);
+      lagStep = (lagAt(index + CONTROL_SAMPLES) - lagNow) / CONTROL_SAMPLES;
+    } else lagNow += lagStep;
+    const read = index - Math.min(size - 2, lagNow);
+    const base = Math.floor(read);
+    const fraction = read - base;
+    const at = (line: Float64Array, position: number) =>
+      position < 0 ? 0 : line[position % size]!;
+    const wetL =
+      at(lineL, base) * (1 - fraction) + at(lineL, base + 1) * fraction;
+    const wetR =
+      at(lineR, base) * (1 - fraction) + at(lineR, base + 1) * fraction;
+    const dryL = left[index]!;
+    const dryR = right[index]!;
+    let writeL: number;
+    let writeR: number;
+    if (pingpong) {
+      writeL = (dryL + dryR) * 0.5 + wetR * feedback;
+      writeR = wetL * feedback;
+    } else {
+      writeL = dryL + wetR * feedback;
+      writeR = dryR + wetL * feedback;
+    }
+    if (highcut) {
+      writeL = highcut[0]!.process(writeL);
+      writeR = highcut[1]!.process(writeR);
+    }
+    lineL[index % size] = writeL;
+    lineR[index % size] = writeR;
+    left[index] = (wetOnly ? 0 : dryL) + wetL * mix;
+    right[index] = (wetOnly ? 0 : dryR) + wetR * mix;
+  }
+}
+
 /** Seconds until the track's delay decays below -60 dB, bounded. */
 export function delayTailFor(track: Track, tempoBpm: number): number {
   if (!track.delay) return 0;
@@ -211,6 +300,7 @@ function mixParamOf(track: Track, context: EffectContext): Param {
     track.reverb?.mix ?? 0,
     track.fxAutomation?.["reverb-mix"],
     context.samplesPerTick,
+    context.warp,
   );
 }
 

package/src/audio/engine.ts

@@ -2,10 +2,19 @@ import type { TrackScore } from "../../core/score.ts";
 import { PlaybackLock } from "./lock.ts";
 import { LoopPlayer } from "./player.ts";
 import { LoopRenderer, type LoopRender } from "./renderer.ts";
-import { clickSounds, clicksIn, type ClickLevel } from "./click.ts";
+import {
+  clickSounds,
+  clicksIn,
+  type ClickGrid,
+  type ClickLevel,
+} from "./click.ts";
 import type { LiveNotePcm } from "./live.ts";
+import { measureLoudness, pcmChannels } from "./loudness.ts";
+import type { MasterReport } from "./master.ts";
 import { levelOf, type SoundLevel } from "./preview.ts";
 import { DEFAULT_SAMPLE_RATE, RENDER_CHANNELS } from "./wav.ts";
+import { playbackTime } from "./arrange.ts";
+import { transportMapFor, type TransportMap } from "./clock.ts";
 
 /**
  * How dawgd (or a file-mode window) makes sound.
@@ -237,8 +246,35 @@ type Loop = Readonly<{
   pcm: Int16Array;
   frames: number;
   framesPerBeat: number;
+  /** The song's tempo map; absent, a beat is `framesPerBeat` frames. */
+  map?: TransportMap;
+  sampleRate: number;
 }>;
 
+/** Loop frame (unwrapped without a map) where transport `beat` sounds. */
+function frameOfBeat(loop: Loop, beat: number): number {
+  const map = loop.map;
+  if (!map) return beat * loop.framesPerBeat;
+  const inner = ((beat % map.loopBeats) + map.loopBeats) % map.loopBeats;
+  return map.seconds(inner) * loop.sampleRate;
+}
+
+/** Transport beat at loop `frame` (inside one pass with a map). */
+function beatOfFrame(loop: Loop, frame: number): number {
+  const map = loop.map;
+  if (!map) return frame / loop.framesPerBeat;
+  const seconds = frame / loop.sampleRate;
+  const inner =
+    ((seconds % map.loopSeconds) + map.loopSeconds) % map.loopSeconds;
+  return map.beat(inner);
+}
+
+/** The beat `frames` stream frames after `beat`. */
+function beatAfter(loop: Loop, beat: number, frames: number): number {
+  if (!loop.map) return beat + frames / loop.framesPerBeat;
+  return beatOfFrame(loop, frameOfBeat(loop, beat) + frames);
+}
+
 /** A loop fading out after a swap, read on from where it was. */
 type FadeOut = {
   loop: Loop;
@@ -259,6 +295,8 @@ export type ClickBus = Readonly<{
   volume: number;
   beatsPerBar: number;
   subdivision: number;
+  /** Meter-aware clicks (core/tempo.ts) replacing the fixed grid. */
+  grid?: ClickGrid;
   beatAt: (monotonicMs: number) => number | undefined;
 }>;
 
@@ -334,6 +372,9 @@ export class AudioEngine {
   /** The loop last swapped in, for `level` (measured on demand, once). */
   private lastLoopPcm: Int16Array | undefined;
   private measured: { pcm: Int16Array; level: SoundLevel } | undefined;
+  private loudnessOf: { pcm: Int16Array; report: MasterReport } | undefined;
+  /** Loudness the song master reached on the loop now playing. */
+  private lastMaster: MasterReport | undefined;
   private respawns = 0;
   private respawnTimer: ReturnType<typeof setTimeout> | undefined;
   /** Play mode: keep a player running without a loop for live voices. */
@@ -421,6 +462,33 @@ export class AudioEngine {
     return this.measured.level;
   }
 
+  /**
+   * Integrated loudness and true peak of the loop now playing, after the
+   * song master when there is one (the header meter). Without a master the
+   * loop's PCM is measured once per render, on first read. Undefined before
+   * any render.
+   */
+  public get loudness(): MasterReport | undefined {
+    const pcm = this.lastLoopPcm;
+    if (!pcm) return undefined;
+    if (this.lastMaster) return this.lastMaster;
+    if (this.loudnessOf?.pcm !== pcm) {
+      const [left, right] = pcmChannels(pcm);
+      const measured = measureLoudness(left, right, this.sampleRate, {
+        loop: true,
+      });
+      this.loudnessOf = {
+        pcm,
+        report: {
+          gainDb: 0,
+          integrated: measured.integrated,
+          truePeak: measured.truePeak,
+        },
+      };
+    }
+    return this.loudnessOf.report;
+  }
+
   public get canMonitor(): boolean {
     return this.info.backend !== "none" && !this.fallback;
   }
@@ -462,13 +530,14 @@ export class AudioEngine {
       existing.pcm = note.pcm;
       existing.frames = note.frames;
       existing.fadeLeft = undefined;
+      existing.fadeFrames = this.releaseFrames(note);
     } else
       this.voices.set(id, {
         pcm: note.pcm,
         frames: note.frames,
         position: 0,
         fadeLeft: undefined,
-        fadeFrames: Math.max(1, Math.round(this.sampleRate * 0.01)),
+        fadeFrames: this.releaseFrames(note),
       });
     // Write what is due now so the voice joins the very next chunk.
     const first = this.written;
@@ -476,6 +545,14 @@ export class AudioEngine {
     return this.frameMs(first);
   }
 
+  /** A live voice's note-off fade: 10 ms, or the instrument's release. */
+  private releaseFrames(note: LiveNotePcm): number {
+    return Math.max(
+      1,
+      Math.round(this.sampleRate * (note.releaseSeconds ?? 0.01)),
+    );
+  }
+
   /** Fade a live voice out over ~10 ms (sustain lifted, mode left). */
   public noteOff(id: number): void {
     const voice = this.voices.get(id);
@@ -552,6 +629,7 @@ export class AudioEngine {
           if (request.generation === this.generation) {
             await this.apply(this.toLoop(render, request.score), request);
             this.lastLoopPcm = render.pcm;
+            this.lastMaster = render.master;
           }
           for (const waiter of request.waiters) waiter.resolve();
         } catch (error) {
@@ -571,10 +649,11 @@ export class AudioEngine {
     const beat =
       request.beat === undefined
         ? undefined
-        : request.beat +
-          ((this.now() - request.atMs) * this.sampleRate) /
-            1000 /
-            loop.framesPerBeat;
+        : beatAfter(
+            loop,
+            request.beat,
+            ((this.now() - request.atMs) * this.sampleRate) / 1000,
+          );
     if (this.child) {
       this.swap(loop, beat);
       return;
@@ -595,19 +674,10 @@ export class AudioEngine {
     if (!this.loop || !this.child) return;
     this.cursor = this.frameForBeat(
       this.loop,
-      beat + this.queuedBeats(this.loop),
+      beatAfter(this.loop, beat, this.queuedFrames()),
     );
   }
 
-  /**
-   * Beats already queued ahead of the wall clock. The next frame written
-   * sounds this far after now, so a transport beat maps to the write head
-   * by adding it.
-   */
-  private queuedBeats(loop: Loop): number {
-    return this.queuedFrames() / loop.framesPerBeat;
-  }
-
   private queuedFrames(): number {
     const elapsed = Math.floor(
       ((this.now() - this.startMs) * this.sampleRate) / 1000,
@@ -622,6 +692,7 @@ export class AudioEngine {
   public async stopAsync(): Promise<void> {
     this.generation += 1;
     this.lastLoopPcm = undefined;
+    this.lastMaster = undefined;
     this.respawns = 0;
     if (this.respawnTimer) clearTimeout(this.respawnTimer);
     this.respawnTimer = undefined;
@@ -813,15 +884,19 @@ export class AudioEngine {
   }
 
   private toLoop(render: LoopRender, score: TrackScore): Loop {
+    const timeline = playbackTime(score);
+    const map = transportMapFor(timeline);
     return {
       pcm: render.pcm,
       frames: render.frames,
-      framesPerBeat: (60 * this.sampleRate) / score.tempoBpm,
+      framesPerBeat: (60 * this.sampleRate) / timeline.tempoBpm,
+      sampleRate: this.sampleRate,
+      ...(map ? { map } : {}),
     };
   }
 
   private frameForBeat(loop: Loop, beat: number): number {
-    const frame = Math.round(Math.max(0, beat) * loop.framesPerBeat);
+    const frame = Math.round(frameOfBeat(loop, Math.max(0, beat)));
     return ((frame % loop.frames) + loop.frames) % loop.frames;
   }
 
@@ -829,12 +904,16 @@ export class AudioEngine {
     const previous = this.loop;
     // Keep the musical position: the same beat inside the new loop.
     let cursor = previous
-      ? this.frameForBeat(next, this.cursor / previous.framesPerBeat)
+      ? this.frameForBeat(next, beatOfFrame(previous, this.cursor))
       : 0;
     if (beat !== undefined) {
       // Re-anchor to the transport only when it disagrees audibly (a seek
       // or a tempo change); sub-frame rounding must not click on edits.
-      const anchored = this.frameForBeat(next, beat + this.queuedBeats(next));
+      // The next frame written sounds `queuedFrames` after now.
+      const anchored = this.frameForBeat(
+        next,
+        beatAfter(next, beat, this.queuedFrames()),
+      );
       const distance = Math.abs(anchored - cursor);
       const wrapped = Math.min(distance, next.frames - distance);
       if (!previous || wrapped > this.sampleRate * RESYNC_SECONDS)
@@ -920,7 +999,7 @@ export class AudioEngine {
         if (generation !== this.generation || this.child || this.starting)
           return;
         const frame = heard + ((this.now() - diedAt) * this.sampleRate) / 1000;
-        const beat = loop ? frame / loop.framesPerBeat : 0;
+        const beat = loop ? beatOfFrame(loop, frame) : 0;
         this.starting = this.start(loop, beat).finally(() => {
           this.starting = undefined;
         });