@hraness/dawg 0.4.1 → 0.5.0

package/src/audio/clock.ts

@@ -1,7 +1,40 @@
+import { loopTicksOf, timeMapFor, type TimeScore } from "../../core/tempo.ts";
+
+/**
+ * Beats and seconds through a song's tempo map, one loop at a time: the
+ * transport runs in score beats, and the map says how long each loop pass
+ * takes. Absent, the clock keeps its constant-tempo arithmetic.
+ */
+export type TransportMap = Readonly<{
+  loopBeats: number;
+  loopSeconds: number;
+  /** Seconds into a loop pass at `beat` (0..loopBeats). */
+  seconds(beat: number): number;
+  /** Beat inside a loop pass at `seconds` (0..loopSeconds). */
+  beat(seconds: number): number;
+}>;
+
+/** The transport map for a score, or undefined at a constant tempo. */
+export function transportMapFor(score: TimeScore): TransportMap | undefined {
+  const map = timeMapFor(score);
+  if (!map) return undefined;
+  const tpb = score.ticksPerBeat;
+  const loopBeats = loopTicksOf(score) / tpb;
+  const loopSeconds = map.seconds(loopTicksOf(score));
+  if (!(loopBeats > 0) || !(loopSeconds > 0)) return undefined;
+  return Object.freeze({
+    loopBeats,
+    loopSeconds,
+    seconds: (beat: number) => map.seconds(beat * tpb),
+    beat: (seconds: number) => map.tick(seconds) / tpb,
+  });
+}
+
 export class TransportClock {
   private startedAtMs: number | undefined;
   private pausedBeat = 0;
   private bpm: number;
+  private map: TransportMap | undefined;
 
   constructor(bpm = 120) {
     this.bpm = bpm;
@@ -24,6 +57,7 @@ export class TransportClock {
 
   beatAt(nowMs = performance.now()): number {
     if (this.startedAtMs === undefined) return this.pausedBeat;
+    if (this.map) return Math.max(0, this.msToBeat(nowMs - this.startedAtMs));
     return Math.max(0, (nowMs - this.startedAtMs) / this.beatToMs(1));
   }
 
@@ -40,6 +74,25 @@ export class TransportClock {
     else this.pausedBeat = beat;
   }
 
+  /**
+   * Follow a song's tempo map (`transportMapFor`), keeping the current
+   * beat; undefined returns to the constant `bpm`.
+   */
+  setTimeMap(map: TransportMap | undefined, nowMs = performance.now()): void {
+    if (map === this.map) return;
+    const beat = this.beatAt(nowMs);
+    this.map = map;
+    if (this.startedAtMs !== undefined)
+      this.startedAtMs = nowMs - this.beatToMs(beat);
+    else this.pausedBeat = beat;
+  }
+
+  /** Follow a score's start tempo and tempo map. */
+  follow(score: TimeScore, nowMs = performance.now()): void {
+    this.setTempo(score.tempoBpm, nowMs);
+    this.setTimeMap(transportMapFor(score), nowMs);
+  }
+
   /** Converge to a timestamped transport event from another TUI process. */
   sync(
     beat: number,
@@ -50,10 +103,10 @@ export class TransportClock {
   ): void {
     if (!Number.isFinite(beat) || beat < 0) return;
     if (!Number.isFinite(eventAtMs) || !Number.isFinite(nowWallMs)) return;
-    const elapsed = playing
-      ? Math.max(0, nowWallMs - eventAtMs) / this.beatToMs(1)
-      : 0;
-    const currentBeat = beat + elapsed;
+    const elapsedMs = playing ? Math.max(0, nowWallMs - eventAtMs) : 0;
+    const currentBeat = this.map
+      ? this.msToBeat(this.beatToMs(beat) + elapsedMs)
+      : beat + elapsedMs / this.beatToMs(1);
     if (playing) {
       this.startedAtMs = nowMonotonicMs - this.beatToMs(currentBeat);
     } else {
@@ -63,6 +116,19 @@ export class TransportClock {
   }
 
   private beatToMs(beats: number): number {
-    return (beats * 60_000) / this.bpm;
+    const map = this.map;
+    if (!map) return (beats * 60_000) / this.bpm;
+    const loops = Math.floor(beats / map.loopBeats);
+    const inner = beats - loops * map.loopBeats;
+    return (loops * map.loopSeconds + map.seconds(inner)) * 1000;
+  }
+
+  private msToBeat(ms: number): number {
+    const map = this.map;
+    if (!map) return ms / this.beatToMs(1);
+    const seconds = ms / 1000;
+    const loops = Math.floor(seconds / map.loopSeconds);
+    const inner = seconds - loops * map.loopSeconds;
+    return loops * map.loopBeats + map.beat(inner);
   }
 }

package/src/audio/effects/bus.ts

@@ -17,6 +17,7 @@ import type { Track } from "../../../core/score.ts";
 import {
   CONTROL_SAMPLES,
   interpolateAutomation,
+  tickAtSample,
   type EffectContext,
 } from "./common.ts";
 import { applyDelay, applyReverb } from "./space.ts";
@@ -58,13 +59,13 @@ function send(
   stemR: Float64Array,
   base: number,
   lane: readonly Readonly<{ tick: number; value: number }>[],
-  samplesPerTick: number,
+  context: Pick<EffectContext, "samplesPerTick" | "warp">,
 ): void {
   if (base <= 0 && lane.length === 0) return;
   let level = base;
   for (let index = 0; index < outL.length; index += 1) {
     if (lane.length > 0 && index % CONTROL_SAMPLES === 0)
-      level = interpolateAutomation(lane, index / samplesPerTick, base);
+      level = interpolateAutomation(lane, tickAtSample(context, index), base);
     outL[index]! += stemL[index]! * level;
     outR[index]! += stemR[index]! * level;
   }
@@ -89,7 +90,7 @@ export function sendToBus(
       stemR,
       track.delay.mix,
       track.delayMixAutomation ?? [],
-      context.samplesPerTick,
+      context,
     );
   }
   if (track.reverb) {
@@ -101,7 +102,7 @@ export function sendToBus(
       stemR,
       track.reverb.mix,
       track.fxAutomation?.["reverb-mix"] ?? [],
-      context.samplesPerTick,
+      context,
     );
   }
 }

package/src/audio/effects/common.ts

@@ -12,6 +12,7 @@
 import type { AutomationPoint, Track } from "../../../core/score.ts";
 import type { FxLane, FxValues } from "../../../core/fx.ts";
 import type { DecodedSample } from "../samples.ts";
+import type { SampleWarp } from "../warp.ts";
 
 /** Effect parameters are refreshed at this sample interval. */
 export const CONTROL_SAMPLES = 32;
@@ -22,8 +23,34 @@ export type EffectContext = Readonly<{
   tempoBpm: number;
   /** Decoded `reverb.ir` samples by track id (built-in impulses need none). */
   irs?: ReadonlyMap<string, DecodedSample>;
+  /** The song's tempo map in samples; absent: constant tempo. */
+  warp?: SampleWarp;
 }>;
 
+/** Score tick at sample `index`, through the tempo map when there is one. */
+export function tickAtSample(
+  context: Pick<EffectContext, "samplesPerTick" | "warp">,
+  index: number,
+): number {
+  return context.warp
+    ? context.warp.tick(index)
+    : index / context.samplesPerTick;
+}
+
+/**
+ * Tempo at sample `index` for tempo-synced LFOs and delays: through the
+ * tempo map when there is one (ramps, steps and fermata holds included),
+ * else the song's constant tempo.
+ */
+export function tempoAtSample(
+  context: Pick<EffectContext, "tempoBpm" | "warp">,
+  index: number,
+): number {
+  return context.warp
+    ? context.warp.bpm(context.warp.tick(index))
+    : context.tempoBpm;
+}
+
 /** Resolve a piecewise-linear automation lane, holding the static value before its first point. */
 export function interpolateAutomation(
   points: readonly AutomationPoint[],
@@ -58,6 +85,7 @@ export class Param {
     readonly fallback: number,
     points: readonly AutomationPoint[] | undefined,
     private readonly samplesPerTick: number,
+    private readonly warp?: SampleWarp,
   ) {
     this.points = points ?? [];
     this.automated = this.points.length > 0;
@@ -67,7 +95,7 @@ export class Param {
     return this.automated
       ? interpolateAutomation(
           this.points,
-          index / this.samplesPerTick,
+          this.warp ? this.warp.tick(index) : index / this.samplesPerTick,
           this.fallback,
         )
       : this.fallback;
@@ -93,6 +121,7 @@ export function fxReader(
         values[name] as number,
         track.fxAutomation?.[`${effect}-${name}` as FxLane],
         context.samplesPerTick,
+        context.warp,
       );
     },
   };

package/src/audio/effects/dynamics.ts

@@ -10,6 +10,7 @@ import {
   fxReader,
   lfo,
   lfoHz,
+  tempoAtSample,
   type EffectContext,
 } from "./common.ts";
 
@@ -42,7 +43,7 @@ export function applyTremolo(
   for (let index = 0; index < buffer.length; index += 1) {
     if (index % CONTROL_SAMPLES === 0) {
       phasor.setHz(
-        lfoHz(sync, rate.at(index), context.tempoBpm),
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
         context.sampleRate,
       );
       if (depth.automated) amount = depth.at(index);

package/src/audio/effects/filter.ts

@@ -15,7 +15,9 @@ import {
   interpolateAutomation,
   lfo,
   lfoHz,
+  tempoAtSample,
   resonanceQ,
+  tickAtSample,
   type EffectContext,
   type FilterType,
 } from "./common.ts";
@@ -99,7 +101,7 @@ export function applyTrackFilter(
   const resonanceLane = track.resonanceAutomation ?? [];
   if (!track.filter && automation.length === 0 && resonanceLane.length === 0)
     return;
-  const { sampleRate, samplesPerTick } = context;
+  const { sampleRate } = context;
   const staticCutoff = track.filter?.cutoff ?? SCORE_LIMITS.maxFilterCutoff;
   const staticResonance = track.filter?.resonance ?? 0;
   const automated = automation.length > 0 || resonanceLane.length > 0;
@@ -111,7 +113,7 @@ export function applyTrackFilter(
   filter.update(staticCutoff, staticResonance);
   for (let index = 0; index < buffer.length; index += 1) {
     if (automated && index % CONTROL_SAMPLES === 0) {
-      const tick = index / samplesPerTick;
+      const tick = tickAtSample(context, index);
       filter.update(
         interpolateAutomation(automation, tick, staticCutoff),
         interpolateAutomation(resonanceLane, tick, staticResonance),
@@ -205,7 +207,7 @@ export function applyAutoFilter(
         : release * envelope + (1 - release) * level;
     if (index % CONTROL_SAMPLES === 0) {
       phasor.setHz(
-        lfoHz(sync, rate.at(index), context.tempoBpm),
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
         context.sampleRate,
       );
       followOctaves = follow.at(index);

package/src/audio/effects/modulation.ts

@@ -9,6 +9,7 @@ import {
   clamp,
   fxReader,
   lfoHz,
+  tempoAtSample,
   readFractional,
   type EffectContext,
 } from "./common.ts";
@@ -57,7 +58,10 @@ export function applyPhaser(
   };
   for (let index = 0; index < left.length; index += 1) {
     if (index % CONTROL_SAMPLES === 0) {
-      phasor.setHz(lfoHz(sync, rate.at(index), context.tempoBpm), sampleRate);
+      phasor.setHz(
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
+        sampleRate,
+      );
       if (depth.automated) amount = depth.at(index);
       const frequency = clamp(
         center + (sweep / 2) * Math.sin(2 * Math.PI * phasor.phase),

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;
   }
@@ -552,6 +620,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 +640,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 +665,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 +683,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 +875,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 +895,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 +990,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;
         });