@dawcore/transport 0.0.3 → 0.0.4

package/README.md

@@ -92,6 +92,38 @@ transport.setMetronomeEnabled(true);
 transport.play();
 ```
 
+### Tempo Automation
+
+```typescript
+const transport = new Transport(audioContext, { tempo: 100 });
+
+// Linear ramp from 100 to 160 BPM over 8 bars
+transport.setTempo(160, transport.barToTick(9), { interpolation: 'linear' });
+
+// Query interpolated BPM at any position
+transport.getTempo(transport.barToTick(5)); // 130 BPM (midway through ramp)
+
+// Curved ramp: ease-in (slow start, fast end)
+transport.clearTempos();
+transport.setTempo(80);
+transport.setTempo(160, transport.barToTick(9), {
+  interpolation: { type: 'curve', slope: 0.2 },  // concave
+});
+
+// Curved ramp: ease-out (fast start, slow end)
+transport.clearTempos();
+transport.setTempo(80);
+transport.setTempo(160, transport.barToTick(9), {
+  interpolation: { type: 'curve', slope: 0.8 },  // convex
+});
+
+// Mix step and linear: jump to 80 BPM at bar 4, ramp to 140 at bar 8
+transport.clearTempos();
+transport.setTempo(120);
+transport.setTempo(80, transport.barToTick(5));  // step (instant jump)
+transport.setTempo(140, transport.barToTick(9), { interpolation: 'linear' });  // ramp
+```
+
 ### Effects
 
 ```typescript
@@ -151,7 +183,7 @@ new Transport(audioContext: AudioContext, options?: TransportOptions)
 - `setLoopSamples(enabled, startSample: Sample, endSample: Sample)` — Set loop region in samples (convenience)
 
 **Tempo & Meter:**
-- `setTempo(bpm, atTick?)` / `getTempo(atTick?)`
+- `setTempo(bpm, atTick?, options?)` / `getTempo(atTick?: Tick)` — options: `{ interpolation: 'step' | 'linear' | { type: 'curve', slope } }`
 - `clearTempos()` — remove all tempo entries
 - `setMeter(numerator, denominator, atTick?: Tick)` / `getMeter(atTick?: Tick)`
 - `removeMeter(atTick: Tick)` / `clearMeters()`

package/dist/index.d.mts

@@ -57,11 +57,20 @@ interface MeterEntry {
     /** Cached cumulative bar count from tick 0 to this entry. Derived — do not set manually. */
     readonly barAtTick: number;
 }
+/** How to interpolate tempo from the previous entry to this one.
+ *  'step' = instant jump (default). 'linear' = linear ramp.
+ *  { type: 'curve', slope } = Möbius-Ease curve (slope 0-1 exclusive). */
+type TempoInterpolation = 'step' | 'linear' | {
+    type: 'curve';
+    slope: number;
+};
 interface TempoEntry {
     /** Tick position where this tempo starts */
     tick: Tick;
     /** Beats per minute */
     bpm: number;
+    /** How to arrive at this BPM from the previous entry */
+    readonly interpolation: TempoInterpolation;
     /** Cached cumulative seconds up to this tick (for O(log n) lookup). Derived — do not set manually. */
     readonly secondsAtTick: number;
 }
@@ -95,19 +104,52 @@ declare class Clock {
     isRunning(): boolean;
 }
 
+interface SetTempoOptions {
+    interpolation?: TempoInterpolation;
+}
 declare class TempoMap {
     private _ppqn;
     private _entries;
     constructor(ppqn?: number, initialBpm?: number);
     getTempo(atTick?: Tick): number;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     ticksToSeconds(ticks: Tick): number;
     secondsToTicks(seconds: number): Tick;
     beatsToSeconds(beats: number): number;
     secondsToBeats(seconds: number): number;
     clearTempos(): void;
+    /** Get the interpolated BPM at a tick position */
+    private _getTempoAt;
     private _ticksToSecondsInternal;
-    private _entryAt;
+    /**
+     * Exact integration for a linear BPM ramp using the logarithmic formula.
+     * For bpm(t) = bpm0 + r*t where r = (bpm1-bpm0)/T:
+     *   seconds = (T * 60) / (ppqn * (bpm1-bpm0)) * ln(bpmAtTick / bpm0)
+     */
+    private _ticksToSecondsLinear;
+    /**
+     * Inverse of _ticksToSecondsLinear: given seconds, return ticks.
+     * Closed-form via exponential: bpmAtTick = bpm0 * exp(seconds * deltaBpm * ppqn / (60 * T))
+     * then ticks = (bpmAtTick - bpm0) * T / deltaBpm
+     *
+     * Note: exp(log(x)) has ~1 ULP floating-point error, so round-trips depend on
+     * Math.round() in the caller (secondsToTicks). This is sufficient for all tested
+     * BPM ranges (10–300 BPM) but is not algebraically exact like the previous
+     * trapezoidal/quadratic approach was.
+     */
+    private _secondsToTicksLinear;
+    /**
+     * Subdivided trapezoidal integration for a Möbius-Ease tempo curve.
+     * The BPM at progress p is: bpm0 + curveNormalizedAt(p, slope) * (bpm1 - bpm0).
+     * We subdivide into CURVE_SUBDIVISIONS intervals and apply trapezoidal rule.
+     */
+    private _ticksToSecondsCurve;
+    /**
+     * Inverse of _ticksToSecondsCurve: given seconds into a curved segment,
+     * return ticks. Uses binary search since there's no closed-form inverse.
+     */
+    private _secondsToTicksCurve;
+    private _entryIndexAt;
     private _recomputeCache;
 }
 
@@ -314,6 +356,7 @@ declare class Transport {
     private _playing;
     private _endTime;
     private _loopEnabled;
+    private _loopStartTick;
     private _loopStartSeconds;
     private _listeners;
     constructor(audioContext: AudioContext, options?: TransportOptions);
@@ -339,7 +382,7 @@ declare class Transport {
     setLoopSeconds(enabled: boolean, startSec: number, endSec: number): void;
     /** Convenience — sets loop in samples */
     setLoopSamples(enabled: boolean, startSample: Sample, endSample: Sample): void;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     getTempo(atTick?: Tick): number;
     setMeter(numerator: number, denominator: number, atTick?: Tick): void;
     getMeter(atTick?: Tick): MeterSignature;
@@ -391,4 +434,4 @@ declare class NativePlayoutAdapter implements PlayoutAdapter {
     dispose(): void;
 }
 
-export { type ClipEvent, ClipPlayer, Clock, MasterNode, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type TempoEntry, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };
+export { type ClipEvent, ClipPlayer, Clock, MasterNode, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type SetTempoOptions, type TempoEntry, type TempoInterpolation, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };

package/dist/index.d.ts

@@ -57,11 +57,20 @@ interface MeterEntry {
     /** Cached cumulative bar count from tick 0 to this entry. Derived — do not set manually. */
     readonly barAtTick: number;
 }
+/** How to interpolate tempo from the previous entry to this one.
+ *  'step' = instant jump (default). 'linear' = linear ramp.
+ *  { type: 'curve', slope } = Möbius-Ease curve (slope 0-1 exclusive). */
+type TempoInterpolation = 'step' | 'linear' | {
+    type: 'curve';
+    slope: number;
+};
 interface TempoEntry {
     /** Tick position where this tempo starts */
     tick: Tick;
     /** Beats per minute */
     bpm: number;
+    /** How to arrive at this BPM from the previous entry */
+    readonly interpolation: TempoInterpolation;
     /** Cached cumulative seconds up to this tick (for O(log n) lookup). Derived — do not set manually. */
     readonly secondsAtTick: number;
 }
@@ -95,19 +104,52 @@ declare class Clock {
     isRunning(): boolean;
 }
 
+interface SetTempoOptions {
+    interpolation?: TempoInterpolation;
+}
 declare class TempoMap {
     private _ppqn;
     private _entries;
     constructor(ppqn?: number, initialBpm?: number);
     getTempo(atTick?: Tick): number;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     ticksToSeconds(ticks: Tick): number;
     secondsToTicks(seconds: number): Tick;
     beatsToSeconds(beats: number): number;
     secondsToBeats(seconds: number): number;
     clearTempos(): void;
+    /** Get the interpolated BPM at a tick position */
+    private _getTempoAt;
     private _ticksToSecondsInternal;
-    private _entryAt;
+    /**
+     * Exact integration for a linear BPM ramp using the logarithmic formula.
+     * For bpm(t) = bpm0 + r*t where r = (bpm1-bpm0)/T:
+     *   seconds = (T * 60) / (ppqn * (bpm1-bpm0)) * ln(bpmAtTick / bpm0)
+     */
+    private _ticksToSecondsLinear;
+    /**
+     * Inverse of _ticksToSecondsLinear: given seconds, return ticks.
+     * Closed-form via exponential: bpmAtTick = bpm0 * exp(seconds * deltaBpm * ppqn / (60 * T))
+     * then ticks = (bpmAtTick - bpm0) * T / deltaBpm
+     *
+     * Note: exp(log(x)) has ~1 ULP floating-point error, so round-trips depend on
+     * Math.round() in the caller (secondsToTicks). This is sufficient for all tested
+     * BPM ranges (10–300 BPM) but is not algebraically exact like the previous
+     * trapezoidal/quadratic approach was.
+     */
+    private _secondsToTicksLinear;
+    /**
+     * Subdivided trapezoidal integration for a Möbius-Ease tempo curve.
+     * The BPM at progress p is: bpm0 + curveNormalizedAt(p, slope) * (bpm1 - bpm0).
+     * We subdivide into CURVE_SUBDIVISIONS intervals and apply trapezoidal rule.
+     */
+    private _ticksToSecondsCurve;
+    /**
+     * Inverse of _ticksToSecondsCurve: given seconds into a curved segment,
+     * return ticks. Uses binary search since there's no closed-form inverse.
+     */
+    private _secondsToTicksCurve;
+    private _entryIndexAt;
     private _recomputeCache;
 }
 
@@ -314,6 +356,7 @@ declare class Transport {
     private _playing;
     private _endTime;
     private _loopEnabled;
+    private _loopStartTick;
     private _loopStartSeconds;
     private _listeners;
     constructor(audioContext: AudioContext, options?: TransportOptions);
@@ -339,7 +382,7 @@ declare class Transport {
     setLoopSeconds(enabled: boolean, startSec: number, endSec: number): void;
     /** Convenience — sets loop in samples */
     setLoopSamples(enabled: boolean, startSample: Sample, endSample: Sample): void;
-    setTempo(bpm: number, atTick?: Tick): void;
+    setTempo(bpm: number, atTick?: Tick, options?: SetTempoOptions): void;
     getTempo(atTick?: Tick): number;
     setMeter(numerator: number, denominator: number, atTick?: Tick): void;
     getMeter(atTick?: Tick): MeterSignature;
@@ -391,4 +434,4 @@ declare class NativePlayoutAdapter implements PlayoutAdapter {
     dispose(): void;
 }
 
-export { type ClipEvent, ClipPlayer, Clock, MasterNode, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type TempoEntry, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };
+export { type ClipEvent, ClipPlayer, Clock, MasterNode, type MeterEntry, MeterMap, type MeterSignature, type MetronomeEvent, MetronomePlayer, NativePlayoutAdapter, type Sample, SampleTimeline, Scheduler, type SchedulerEvent, type SchedulerListener, type SchedulerOptions, type SetTempoOptions, type TempoEntry, type TempoInterpolation, TempoMap, type Tick, Timer, TrackNode, Transport, type TransportEvents, type TransportOptions, type TransportPosition };

package/dist/index.js

@@ -252,28 +252,43 @@ var SampleTimeline = class {
 };
 
 // src/timeline/tempo-map.ts
+var CURVE_EPSILON = 1e-15;
+var CURVE_SUBDIVISIONS = 64;
+function curveNormalizedAt(x, slope) {
+  if (slope > 0.499999 && slope < 0.500001) return x;
+  const p = Math.max(CURVE_EPSILON, Math.min(1 - CURVE_EPSILON, slope));
+  return p * p / (1 - p * 2) * (Math.pow((1 - p) / p, 2 * x) - 1);
+}
 var TempoMap = class {
   constructor(ppqn = 960, initialBpm = 120) {
     this._ppqn = ppqn;
-    this._entries = [{ tick: 0, bpm: initialBpm, secondsAtTick: 0 }];
+    this._entries = [{ tick: 0, bpm: initialBpm, interpolation: "step", secondsAtTick: 0 }];
   }
   getTempo(atTick = 0) {
-    const entry = this._entryAt(atTick);
-    return entry.bpm;
-  }
-  setTempo(bpm, atTick = 0) {
+    return this._getTempoAt(atTick);
+  }
+  setTempo(bpm, atTick = 0, options) {
+    const interpolation = options?.interpolation ?? "step";
+    if (typeof interpolation === "object" && interpolation.type === "curve") {
+      const s = interpolation.slope;
+      if (!Number.isFinite(s) || s <= 0 || s >= 1) {
+        throw new Error(
+          "[waveform-playlist] TempoMap: curve slope must be between 0 and 1 (exclusive), got " + s
+        );
+      }
+    }
     if (atTick === 0) {
-      this._entries[0] = { ...this._entries[0], bpm };
+      this._entries[0] = { ...this._entries[0], bpm, interpolation: "step" };
       this._recomputeCache(0);
       return;
     }
     let i = this._entries.length - 1;
     while (i > 0 && this._entries[i].tick > atTick) i--;
     if (this._entries[i].tick === atTick) {
-      this._entries[i] = { ...this._entries[i], bpm };
+      this._entries[i] = { ...this._entries[i], bpm, interpolation };
     } else {
       const secondsAtTick = this._ticksToSecondsInternal(atTick);
-      this._entries.splice(i + 1, 0, { tick: atTick, bpm, secondsAtTick });
+      this._entries.splice(i + 1, 0, { tick: atTick, bpm, interpolation, secondsAtTick });
       i = i + 1;
     }
     this._recomputeCache(i);
@@ -294,6 +309,28 @@ var TempoMap = class {
     }
     const entry = this._entries[lo];
     const secondsIntoSegment = seconds - entry.secondsAtTick;
+    const nextEntry = lo < this._entries.length - 1 ? this._entries[lo + 1] : null;
+    if (nextEntry && nextEntry.interpolation === "linear") {
+      return Math.round(
+        entry.tick + this._secondsToTicksLinear(
+          secondsIntoSegment,
+          entry.bpm,
+          nextEntry.bpm,
+          nextEntry.tick - entry.tick
+        )
+      );
+    }
+    if (nextEntry && typeof nextEntry.interpolation === "object") {
+      return Math.round(
+        entry.tick + this._secondsToTicksCurve(
+          secondsIntoSegment,
+          entry.bpm,
+          nextEntry.bpm,
+          nextEntry.tick - entry.tick,
+          nextEntry.interpolation.slope
+        )
+      );
+    }
     const ticksPerSecond = entry.bpm / 60 * this._ppqn;
     return Math.round(entry.tick + secondsIntoSegment * ticksPerSecond);
   }
@@ -305,15 +342,122 @@ var TempoMap = class {
   }
   clearTempos() {
     const first = this._entries[0];
-    this._entries = [{ tick: 0, bpm: first.bpm, secondsAtTick: 0 }];
+    this._entries = [{ tick: 0, bpm: first.bpm, interpolation: "step", secondsAtTick: 0 }];
+  }
+  /** Get the interpolated BPM at a tick position */
+  _getTempoAt(atTick) {
+    const entryIndex = this._entryIndexAt(atTick);
+    const entry = this._entries[entryIndex];
+    const nextEntry = entryIndex < this._entries.length - 1 ? this._entries[entryIndex + 1] : null;
+    if (nextEntry && nextEntry.interpolation !== "step") {
+      const segmentTicks = nextEntry.tick - entry.tick;
+      const ticksInto = atTick - entry.tick;
+      if (segmentTicks > 0) {
+        const progress = ticksInto / segmentTicks;
+        if (nextEntry.interpolation === "linear") {
+          return entry.bpm + (nextEntry.bpm - entry.bpm) * progress;
+        }
+        const t = curveNormalizedAt(progress, nextEntry.interpolation.slope);
+        return entry.bpm + (nextEntry.bpm - entry.bpm) * t;
+      }
+    }
+    return entry.bpm;
   }
   _ticksToSecondsInternal(ticks) {
-    const entry = this._entryAt(ticks);
+    const entryIndex = this._entryIndexAt(ticks);
+    const entry = this._entries[entryIndex];
     const ticksIntoSegment = ticks - entry.tick;
+    const nextEntry = entryIndex < this._entries.length - 1 ? this._entries[entryIndex + 1] : null;
+    if (nextEntry && nextEntry.interpolation === "linear") {
+      const segmentTicks = nextEntry.tick - entry.tick;
+      return entry.secondsAtTick + this._ticksToSecondsLinear(ticksIntoSegment, entry.bpm, nextEntry.bpm, segmentTicks);
+    }
+    if (nextEntry && typeof nextEntry.interpolation === "object") {
+      const segmentTicks = nextEntry.tick - entry.tick;
+      return entry.secondsAtTick + this._ticksToSecondsCurve(
+        ticksIntoSegment,
+        entry.bpm,
+        nextEntry.bpm,
+        segmentTicks,
+        nextEntry.interpolation.slope
+      );
+    }
     const secondsPerTick = 60 / (entry.bpm * this._ppqn);
     return entry.secondsAtTick + ticksIntoSegment * secondsPerTick;
   }
-  _entryAt(tick) {
+  /**
+   * Exact integration for a linear BPM ramp using the logarithmic formula.
+   * For bpm(t) = bpm0 + r*t where r = (bpm1-bpm0)/T:
+   *   seconds = (T * 60) / (ppqn * (bpm1-bpm0)) * ln(bpmAtTick / bpm0)
+   */
+  _ticksToSecondsLinear(ticks, bpm0, bpm1, totalSegmentTicks) {
+    if (totalSegmentTicks === 0) return 0;
+    const bpmAtTick = bpm0 + (bpm1 - bpm0) * (ticks / totalSegmentTicks);
+    if (Math.abs(bpm1 - bpm0) < 1e-10) {
+      return ticks * 60 / (bpm0 * this._ppqn);
+    }
+    const deltaBpm = bpm1 - bpm0;
+    return totalSegmentTicks * 60 / (this._ppqn * deltaBpm) * Math.log(bpmAtTick / bpm0);
+  }
+  /**
+   * Inverse of _ticksToSecondsLinear: given seconds, return ticks.
+   * Closed-form via exponential: bpmAtTick = bpm0 * exp(seconds * deltaBpm * ppqn / (60 * T))
+   * then ticks = (bpmAtTick - bpm0) * T / deltaBpm
+   *
+   * Note: exp(log(x)) has ~1 ULP floating-point error, so round-trips depend on
+   * Math.round() in the caller (secondsToTicks). This is sufficient for all tested
+   * BPM ranges (10–300 BPM) but is not algebraically exact like the previous
+   * trapezoidal/quadratic approach was.
+   */
+  _secondsToTicksLinear(seconds, bpm0, bpm1, totalSegmentTicks) {
+    if (totalSegmentTicks === 0 || seconds === 0) return 0;
+    if (Math.abs(bpm1 - bpm0) < 1e-10) {
+      return seconds * bpm0 * this._ppqn / 60;
+    }
+    const deltaBpm = bpm1 - bpm0;
+    const bpmAtTick = bpm0 * Math.exp(seconds * deltaBpm * this._ppqn / (60 * totalSegmentTicks));
+    return (bpmAtTick - bpm0) / deltaBpm * totalSegmentTicks;
+  }
+  /**
+   * Subdivided trapezoidal integration for a Möbius-Ease tempo curve.
+   * The BPM at progress p is: bpm0 + curveNormalizedAt(p, slope) * (bpm1 - bpm0).
+   * We subdivide into CURVE_SUBDIVISIONS intervals and apply trapezoidal rule.
+   */
+  _ticksToSecondsCurve(ticks, bpm0, bpm1, totalSegmentTicks, slope) {
+    if (totalSegmentTicks === 0 || ticks === 0) return 0;
+    const n = CURVE_SUBDIVISIONS;
+    const dt = ticks / n;
+    let seconds = 0;
+    let prevBpm = bpm0;
+    for (let i = 1; i <= n; i++) {
+      const progress = dt * i / totalSegmentTicks;
+      const curBpm = bpm0 + curveNormalizedAt(progress, slope) * (bpm1 - bpm0);
+      seconds += dt * 60 / this._ppqn * (1 / prevBpm + 1 / curBpm) / 2;
+      prevBpm = curBpm;
+    }
+    return seconds;
+  }
+  /**
+   * Inverse of _ticksToSecondsCurve: given seconds into a curved segment,
+   * return ticks. Uses binary search since there's no closed-form inverse.
+   */
+  _secondsToTicksCurve(seconds, bpm0, bpm1, totalSegmentTicks, slope) {
+    if (totalSegmentTicks === 0 || seconds === 0) return 0;
+    const iterations = Math.min(40, Math.max(1, Math.ceil(Math.log2(2 * totalSegmentTicks))));
+    let lo = 0;
+    let hi = totalSegmentTicks;
+    for (let i = 0; i < iterations; i++) {
+      const mid = (lo + hi) / 2;
+      const midSeconds = this._ticksToSecondsCurve(mid, bpm0, bpm1, totalSegmentTicks, slope);
+      if (midSeconds < seconds) {
+        lo = mid;
+      } else {
+        hi = mid;
+      }
+    }
+    return (lo + hi) / 2;
+  }
+  _entryIndexAt(tick) {
     let lo = 0;
     let hi = this._entries.length - 1;
     while (lo < hi) {
@@ -324,16 +468,31 @@ var TempoMap = class {
         hi = mid - 1;
       }
     }
-    return this._entries[lo];
+    return lo;
   }
   _recomputeCache(fromIndex) {
     for (let i = Math.max(1, fromIndex); i < this._entries.length; i++) {
       const prev = this._entries[i - 1];
       const tickDelta = this._entries[i].tick - prev.tick;
-      const secondsPerTick = 60 / (prev.bpm * this._ppqn);
+      const entry = this._entries[i];
+      let segmentSeconds;
+      if (entry.interpolation === "linear") {
+        segmentSeconds = this._ticksToSecondsLinear(tickDelta, prev.bpm, entry.bpm, tickDelta);
+      } else if (typeof entry.interpolation === "object") {
+        segmentSeconds = this._ticksToSecondsCurve(
+          tickDelta,
+          prev.bpm,
+          entry.bpm,
+          tickDelta,
+          entry.interpolation.slope
+        );
+      } else {
+        const secondsPerTick = 60 / (prev.bpm * this._ppqn);
+        segmentSeconds = tickDelta * secondsPerTick;
+      }
       this._entries[i] = {
-        ...this._entries[i],
-        secondsAtTick: prev.secondsAtTick + tickDelta * secondsPerTick
+        ...entry,
+        secondsAtTick: prev.secondsAtTick + segmentSeconds
       };
     }
   }
@@ -900,6 +1059,7 @@ var Transport = class _Transport {
     this._mutedTrackIds = /* @__PURE__ */ new Set();
     this._playing = false;
     this._loopEnabled = false;
+    this._loopStartTick = 0;
     this._loopStartSeconds = 0;
     this._listeners = /* @__PURE__ */ new Map();
     this._audioContext = audioContext;
@@ -1117,6 +1277,7 @@ var Transport = class _Transport {
       return;
     }
     this._loopEnabled = enabled;
+    this._loopStartTick = startTick;
     this._loopStartSeconds = this._tempoMap.ticksToSeconds(startTick);
     this._scheduler.setLoop(enabled, startTick, endTick);
     this._clipPlayer.setLoop(enabled, startTick, endTick);
@@ -1145,14 +1306,18 @@ var Transport = class _Transport {
     const startTick = this._sampleTimeline.samplesToTicks(startSample);
     const endTick = this._sampleTimeline.samplesToTicks(endSample);
     this._loopEnabled = enabled;
+    this._loopStartTick = startTick;
     this._loopStartSeconds = this._tempoMap.ticksToSeconds(startTick);
     this._clipPlayer.setLoopSamples(enabled, startSample, endSample);
     this._scheduler.setLoop(enabled, startTick, endTick);
     this._emit("loop");
   }
   // --- Tempo ---
-  setTempo(bpm, atTick) {
-    this._tempoMap.setTempo(bpm, atTick);
+  setTempo(bpm, atTick, options) {
+    this._tempoMap.setTempo(bpm, atTick, options);
+    if (this._loopEnabled) {
+      this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
+    }
     this._emit("tempochange");
   }
   getTempo(atTick) {
@@ -1176,6 +1341,9 @@ var Transport = class _Transport {
   }
   clearTempos() {
     this._tempoMap.clearTempos();
+    if (this._loopEnabled) {
+      this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
+    }
     this._emit("tempochange");
   }
   barToTick(bar) {