@dawcore/transport 0.0.3 → 0.0.5

package/dist/index.js

@@ -210,7 +210,9 @@ var Timer = class {
       } catch (err) {
         console.warn("[waveform-playlist] Timer tick error:", String(err));
       }
-      this._scheduleFrame();
+      if (this._running) {
+        this._scheduleFrame();
+      }
     });
   }
 };
@@ -252,28 +254,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 +311,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 +344,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 +470,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
       };
     }
   }
@@ -891,8 +1052,145 @@ var MetronomePlayer = class {
   }
 };
 
+// src/audio/count-in-player.ts
+var CountInPlayer = class {
+  constructor(audioContext, tempoMap, destination, toAudioTime) {
+    this._activeSources = /* @__PURE__ */ new Set();
+    this._totalBeats = 0;
+    this._beatsGenerated = 0;
+    this._accentBuffer = null;
+    this._normalBuffer = null;
+    this._meterMap = null;
+    this._onBeat = null;
+    this._audioContext = audioContext;
+    this._tempoMap = tempoMap;
+    this._destination = destination;
+    this._toAudioTime = toAudioTime;
+  }
+  configure(config) {
+    this._totalBeats = config.totalBeats;
+    this._beatsGenerated = 0;
+    this._accentBuffer = config.accentBuffer;
+    this._normalBuffer = config.normalBuffer;
+    this._meterMap = config.meterMap;
+    this._tempoMap = config.tempoMap;
+    this._onBeat = config.onBeat;
+  }
+  generate(fromTick, toTick) {
+    if (!this._accentBuffer || !this._normalBuffer || !this._meterMap) {
+      return [];
+    }
+    const events = [];
+    const meterMap = this._meterMap;
+    let entry = meterMap.getEntryAt(fromTick);
+    let beatSize = meterMap.ticksPerBeat(fromTick);
+    const tickIntoSection = fromTick - entry.tick;
+    let tick = entry.tick + Math.ceil(tickIntoSection / beatSize) * beatSize;
+    while (tick < toTick && this._beatsGenerated < this._totalBeats) {
+      const tickPos = tick;
+      const currentEntry = meterMap.getEntryAt(tickPos);
+      if (currentEntry.tick !== entry.tick) {
+        entry = currentEntry;
+        beatSize = meterMap.ticksPerBeat(tickPos);
+      }
+      this._beatsGenerated++;
+      const isAccent = meterMap.isBarBoundary(tickPos);
+      events.push({
+        tick: tickPos,
+        isAccent,
+        buffer: isAccent ? this._accentBuffer : this._normalBuffer,
+        beat: this._beatsGenerated,
+        totalBeats: this._totalBeats
+      });
+      beatSize = meterMap.ticksPerBeat(tickPos);
+      tick += beatSize;
+    }
+    return events;
+  }
+  consume(event) {
+    try {
+      const source = this._audioContext.createBufferSource();
+      source.buffer = event.buffer;
+      source.connect(this._destination);
+      this._activeSources.add(source);
+      source.addEventListener("ended", () => {
+        this._activeSources.delete(source);
+        try {
+          source.disconnect();
+        } catch (err) {
+          console.warn(
+            "[waveform-playlist] CountInPlayer: error disconnecting source:",
+            String(err)
+          );
+        }
+      });
+      const transportTime = this._tempoMap.ticksToSeconds(event.tick);
+      source.start(this._toAudioTime(transportTime));
+    } catch (err) {
+      console.warn(
+        "[waveform-playlist] CountInPlayer.consume: failed to schedule beat " + event.beat + "/" + event.totalBeats + ": " + String(err)
+      );
+    }
+    this._onBeat?.(event.beat, event.totalBeats);
+  }
+  onPositionJump(_newTick) {
+  }
+  silence() {
+    for (const source of this._activeSources) {
+      try {
+        source.stop();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] CountInPlayer.silence: error stopping source:",
+          String(err)
+        );
+      }
+      try {
+        source.disconnect();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] CountInPlayer.silence: error disconnecting:",
+          String(err)
+        );
+      }
+    }
+    this._activeSources.clear();
+  }
+};
+
+// src/audio/click-sounds.ts
+var DEFAULT_ACCENT_FREQUENCY = 1e3;
+var DEFAULT_NORMAL_FREQUENCY = 800;
+var ACCENT_DURATION = 0.04;
+var NORMAL_DURATION = 0.03;
+function synthesizeClick(audioContext, frequency, duration) {
+  const sampleRate = audioContext.sampleRate;
+  const length = Math.ceil(sampleRate * duration);
+  const buffer = audioContext.createBuffer(1, length, sampleRate);
+  const data = buffer.getChannelData(0);
+  for (let i = 0; i < length; i++) {
+    const t = i / sampleRate;
+    const envelope = Math.exp(-t * 50);
+    data[i] = Math.sin(2 * Math.PI * frequency * t) * envelope;
+  }
+  return buffer;
+}
+function createDefaultClickSounds(audioContext, options) {
+  const accentFreq = options?.accentFrequency ?? DEFAULT_ACCENT_FREQUENCY;
+  const normalFreq = options?.normalFrequency ?? DEFAULT_NORMAL_FREQUENCY;
+  if (accentFreq <= 0 || normalFreq <= 0) {
+    console.warn(
+      "[waveform-playlist] createDefaultClickSounds: frequency must be positive, got accent=" + accentFreq + " normal=" + normalFreq
+    );
+  }
+  return {
+    accent: synthesizeClick(audioContext, accentFreq, ACCENT_DURATION),
+    normal: synthesizeClick(audioContext, normalFreq, NORMAL_DURATION)
+  };
+}
+
 // src/transport.ts
-var Transport = class _Transport {
+var _Transport = class _Transport {
   constructor(audioContext, options = {}) {
     this._trackNodes = /* @__PURE__ */ new Map();
     this._tracks = [];
@@ -900,8 +1198,24 @@ var Transport = class _Transport {
     this._mutedTrackIds = /* @__PURE__ */ new Set();
     this._playing = false;
     this._loopEnabled = false;
+    this._loopStartTick = 0;
     this._loopStartSeconds = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this._listeners = /* @__PURE__ */ new Map();
+    // --- Count-In state ---
+    this._countInEnabled = false;
+    this._countInBars = 1;
+    this._countInMode = "recording-only";
+    this._recording = false;
+    this._countingIn = false;
+    this._countInStartPosition = 0;
+    this._countInDuration = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this._countInScheduler = null;
+    this._accentBuffer = null;
+    this._normalBuffer = null;
+    this._schedulerLookahead = 0.2;
+    this._ppqn = 960;
     this._audioContext = audioContext;
     const sampleRate = options.sampleRate ?? audioContext.sampleRate;
     const ppqn = options.ppqn ?? 960;
@@ -909,6 +1223,8 @@ var Transport = class _Transport {
     const numerator = options.numerator ?? 4;
     const denominator = options.denominator ?? 4;
     const lookahead = options.schedulerLookahead ?? 0.2;
+    this._ppqn = ppqn;
+    this._schedulerLookahead = lookahead;
     _Transport._validateOptions(sampleRate, ppqn, tempo, numerator, denominator, lookahead);
     this._clock = new Clock(audioContext);
     this._sampleTimeline = new SampleTimeline(sampleRate);
@@ -923,8 +1239,16 @@ var Transport = class _Transport {
     });
     this._sampleTimeline.setTempoMap(this._tempoMap);
     this._initAudioGraph(audioContext);
+    this._initCountIn(audioContext, options);
     this._timer = new Timer(() => {
       const time = this._clock.getTime();
+      if (this._countingIn) {
+        this._countInScheduler?.advance(time);
+        if (time >= this._countInDuration) {
+          this._finishCountIn();
+        }
+        return;
+      }
       if (this._endTime !== void 0 && time >= this._endTime) {
         this.stop();
         return;
@@ -941,6 +1265,10 @@ var Transport = class _Transport {
     if (startTime !== void 0) {
       this._clock.seekTo(startTime);
     }
+    if (this._shouldCountIn()) {
+      this._startCountIn(endTime);
+      return;
+    }
     const currentTime = this._clock.getTime();
     this._scheduler.reset(currentTime);
     this._endTime = endTime;
@@ -953,6 +1281,13 @@ var Transport = class _Transport {
   }
   pause() {
     if (!this._playing) return;
+    if (this._countingIn) {
+      this._cancelCountIn();
+      this._clock.stop();
+      this._playing = false;
+      this._emit("pause");
+      return;
+    }
     this._timer.stop();
     this._clock.stop();
     this._silenceAll();
@@ -961,6 +1296,9 @@ var Transport = class _Transport {
   }
   stop() {
     const wasPlaying = this._playing;
+    if (this._countingIn) {
+      this._cancelCountIn();
+    }
     this._timer.stop();
     this._clock.reset();
     this._scheduler.reset(0);
@@ -973,14 +1311,19 @@ var Transport = class _Transport {
   }
   seek(time) {
     const wasPlaying = this._playing;
-    if (wasPlaying) {
+    const wasCountingIn = this._countingIn;
+    if (wasCountingIn) {
+      this._cancelCountIn();
+      this._playing = false;
+    }
+    if (wasPlaying && !wasCountingIn) {
       this._timer.stop();
     }
     this._silenceAll();
     this._clock.seekTo(time);
     this._scheduler.reset(time);
     this._endTime = void 0;
-    if (wasPlaying) {
+    if (wasPlaying && !wasCountingIn) {
       this._clock.start();
       const seekTick = this._tempoMap.secondsToTicks(time);
       this._clipPlayer.onPositionJump(seekTick);
@@ -988,6 +1331,9 @@ var Transport = class _Transport {
     }
   }
   getCurrentTime() {
+    if (this._countingIn) {
+      return this._countInStartPosition;
+    }
     const t = this._clock.getTime();
     if (this._loopEnabled && t < this._loopStartSeconds) {
       return this._loopStartSeconds;
@@ -1117,6 +1463,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,15 +1492,19 @@ 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);
-    this._emit("tempochange");
+  setTempo(bpm, atTick, options) {
+    this._tempoMap.setTempo(bpm, atTick, options);
+    if (this._loopEnabled) {
+      this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
+    }
+    this._emit("tempochange", { bpm, atTick: atTick ?? 0 });
   }
   getTempo(atTick) {
     return this._tempoMap.getTempo(atTick);
@@ -1161,22 +1512,35 @@ var Transport = class _Transport {
   // --- Meter ---
   setMeter(numerator, denominator, atTick) {
     this._meterMap.setMeter(numerator, denominator, atTick);
-    this._emit("meterchange");
+    this._emit("meterchange", { numerator, denominator, atTick: atTick ?? 0 });
   }
   getMeter(atTick) {
     return this._meterMap.getMeter(atTick);
   }
   removeMeter(atTick) {
     this._meterMap.removeMeter(atTick);
-    this._emit("meterchange");
+    const meter = this._meterMap.getMeter(atTick);
+    this._emit("meterchange", {
+      numerator: meter.numerator,
+      denominator: meter.denominator,
+      atTick
+    });
   }
   clearMeters() {
     this._meterMap.clearMeters();
-    this._emit("meterchange");
+    const meter = this._meterMap.getMeter();
+    this._emit("meterchange", {
+      numerator: meter.numerator,
+      denominator: meter.denominator,
+      atTick: 0
+    });
   }
   clearTempos() {
     this._tempoMap.clearTempos();
-    this._emit("tempochange");
+    if (this._loopEnabled) {
+      this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
+    }
+    this._emit("tempochange", { bpm: this._tempoMap.getTempo(), atTick: 0 });
   }
   barToTick(bar) {
     return this._meterMap.barToTick(bar);
@@ -1197,8 +1561,40 @@ var Transport = class _Transport {
     this._metronomePlayer.setEnabled(enabled);
   }
   setMetronomeClickSounds(accent, normal) {
+    this._accentBuffer = accent;
+    this._normalBuffer = normal;
     this._metronomePlayer.setClickSounds(accent, normal);
   }
+  setCountIn(enabled) {
+    this._countInEnabled = enabled;
+  }
+  setCountInBars(bars) {
+    const rounded = Math.round(bars);
+    if (rounded < _Transport.MIN_COUNT_IN_BARS) {
+      console.warn(
+        "[waveform-playlist] Transport.setCountInBars: clamping " + bars + " to " + _Transport.MIN_COUNT_IN_BARS
+      );
+      this._countInBars = _Transport.MIN_COUNT_IN_BARS;
+      return;
+    }
+    if (rounded > _Transport.MAX_COUNT_IN_BARS) {
+      console.warn(
+        "[waveform-playlist] Transport.setCountInBars: clamping " + bars + " to " + _Transport.MAX_COUNT_IN_BARS
+      );
+      this._countInBars = _Transport.MAX_COUNT_IN_BARS;
+      return;
+    }
+    this._countInBars = rounded;
+  }
+  setCountInMode(mode) {
+    this._countInMode = mode;
+  }
+  setRecording(recording) {
+    this._recording = recording;
+  }
+  isCountingIn() {
+    return this._countingIn;
+  }
   // --- Effects Hook ---
   connectTrackOutput(trackId, node) {
     const trackNode = this._trackNodes.get(trackId);
@@ -1287,9 +1683,94 @@ var Transport = class _Transport {
     this._scheduler.addListener(this._clipPlayer);
     this._scheduler.addListener(this._metronomePlayer);
   }
+  _initCountIn(audioContext, options) {
+    const toAudioTime = (transportTime) => this._clock.toAudioTime(transportTime);
+    this._countInPlayer = new CountInPlayer(
+      audioContext,
+      this._tempoMap,
+      this._masterNode.input,
+      toAudioTime
+    );
+    try {
+      const { accent, normal } = createDefaultClickSounds(audioContext, {
+        accentFrequency: options.accentFrequency,
+        normalFrequency: options.normalFrequency
+      });
+      this._accentBuffer = accent;
+      this._normalBuffer = normal;
+      this._metronomePlayer.setClickSounds(accent, normal);
+    } catch (err) {
+      console.warn(
+        "[waveform-playlist] Transport: failed to create default click sounds. Metronome and count-in will be silent until setMetronomeClickSounds() is called. Error: " + String(err)
+      );
+    }
+  }
+  _shouldCountIn() {
+    if (!this._countInEnabled) return false;
+    if (!this._accentBuffer || !this._normalBuffer) {
+      console.warn("[waveform-playlist] Transport: count-in skipped \u2014 no click sounds loaded");
+      return false;
+    }
+    if (this._countInMode === "recording-only" && !this._recording) return false;
+    return true;
+  }
+  _startCountIn(endTime) {
+    const currentTime = this._clock.getTime();
+    this._countInStartPosition = currentTime;
+    this._countingIn = true;
+    this._playing = true;
+    this._endTime = endTime;
+    const playPositionTick = this._tempoMap.secondsToTicks(currentTime);
+    const meter = this._meterMap.getMeter(playPositionTick);
+    const totalBeats = meter.numerator * this._countInBars;
+    const bpmAtPosition = this._tempoMap.getTempo(playPositionTick);
+    const ticksPerBeat = this._ppqn * (4 / meter.denominator);
+    const countInTicks = totalBeats * ticksPerBeat;
+    const countInTempoMap = new TempoMap(this._ppqn, bpmAtPosition);
+    const countInMeterMap = new MeterMap(this._ppqn, meter.numerator, meter.denominator);
+    this._countInDuration = countInTempoMap.ticksToSeconds(countInTicks);
+    this._countInScheduler = new Scheduler(countInTempoMap, {
+      lookahead: this._schedulerLookahead
+    });
+    this._countInPlayer.configure({
+      totalBeats,
+      accentBuffer: this._accentBuffer,
+      normalBuffer: this._normalBuffer,
+      meterMap: countInMeterMap,
+      tempoMap: countInTempoMap,
+      onBeat: (beat, total) => {
+        this._emit("countIn", { beat, totalBeats: total });
+      }
+    });
+    this._countInScheduler.addListener(this._countInPlayer);
+    this._countInScheduler.reset(0);
+    this._clock.seekTo(0);
+    this._clock.start();
+    this._timer.start();
+  }
+  _finishCountIn() {
+    this._countInScheduler?.removeListener(this._countInPlayer);
+    this._countInScheduler = null;
+    this._countingIn = false;
+    this._emit("countInEnd");
+    this._clock.seekTo(this._countInStartPosition);
+    const currentTime = this._clock.getTime();
+    this._scheduler.reset(currentTime);
+    const currentTick = this._tempoMap.secondsToTicks(currentTime);
+    this._clipPlayer.onPositionJump(currentTick);
+    this._emit("play");
+  }
+  _cancelCountIn() {
+    this._countInPlayer.silence();
+    this._countInScheduler?.removeListener(this._countInPlayer);
+    this._countInScheduler = null;
+    this._countingIn = false;
+    this._timer.stop();
+  }
   _silenceAll() {
     this._clipPlayer.silence();
     this._metronomePlayer.silence();
+    this._countInPlayer.silence();
   }
   _applyMuteState() {
     const hasSolo = this._soloedTrackIds.size > 0;
@@ -1299,12 +1780,12 @@ var Transport = class _Transport {
       node.setMute(isExplicitlyMuted || isSoloMuted);
     }
   }
-  _emit(event) {
+  _emit(event, ...args) {
     const listeners = this._listeners.get(event);
     if (listeners) {
       for (const cb of listeners) {
         try {
-          cb();
+          cb(...args);
         } catch (err) {
           console.warn(
             '[waveform-playlist] Transport "' + event + '" listener threw:',
@@ -1315,6 +1796,10 @@ var Transport = class _Transport {
     }
   }
 };
+// --- Count-In ---
+_Transport.MIN_COUNT_IN_BARS = 1;
+_Transport.MAX_COUNT_IN_BARS = 8;
+var Transport = _Transport;
 
 // src/adapter.ts
 var NativePlayoutAdapter = class {
@@ -1381,6 +1866,21 @@ var NativePlayoutAdapter = class {
   setLoop(enabled, start, end) {
     this._transport.setLoopSeconds(enabled, start, end);
   }
+  setCountIn(enabled) {
+    this._transport.setCountIn(enabled);
+  }
+  setCountInBars(bars) {
+    this._transport.setCountInBars(bars);
+  }
+  setCountInMode(mode) {
+    this._transport.setCountInMode(mode);
+  }
+  setRecording(recording) {
+    this._transport.setRecording(recording);
+  }
+  isCountingIn() {
+    return this._transport.isCountingIn();
+  }
   dispose() {
     this._transport.dispose();
   }