@dawcore/transport 0.0.1

package/dist/index.js

@@ -0,0 +1,1107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClipPlayer: () => ClipPlayer,
+  Clock: () => Clock,
+  MasterNode: () => MasterNode,
+  MetronomePlayer: () => MetronomePlayer,
+  NativePlayoutAdapter: () => NativePlayoutAdapter,
+  SampleTimeline: () => SampleTimeline,
+  Scheduler: () => Scheduler,
+  TempoMap: () => TempoMap,
+  TickTimeline: () => TickTimeline,
+  Timer: () => Timer,
+  TrackNode: () => TrackNode,
+  Transport: () => Transport
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/clock.ts
+var Clock = class {
+  constructor(audioContext) {
+    this._running = false;
+    this._audioTimeAtStart = 0;
+    this._clockTimeAtStart = 0;
+    this._audioContext = audioContext;
+  }
+  start() {
+    if (this._running) return;
+    this._audioTimeAtStart = this._audioContext.currentTime;
+    this._running = true;
+  }
+  stop() {
+    if (!this._running) return;
+    this._clockTimeAtStart = this.getTime();
+    this._running = false;
+  }
+  reset() {
+    this._running = false;
+    this._clockTimeAtStart = 0;
+    this._audioTimeAtStart = 0;
+  }
+  getTime() {
+    if (this._running) {
+      return this._clockTimeAtStart + (this._audioContext.currentTime - this._audioTimeAtStart);
+    }
+    return this._clockTimeAtStart;
+  }
+  seekTo(time) {
+    if (this._running) {
+      this._clockTimeAtStart = time;
+      this._audioTimeAtStart = this._audioContext.currentTime;
+    } else {
+      this._clockTimeAtStart = time;
+    }
+  }
+  /**
+   * Convert transport time to AudioContext.currentTime space.
+   * Used by players to schedule AudioBufferSourceNode.start(when).
+   */
+  toAudioTime(transportTime) {
+    return this._audioContext.currentTime + (transportTime - this.getTime());
+  }
+  isRunning() {
+    return this._running;
+  }
+};
+
+// src/core/scheduler.ts
+var Scheduler = class {
+  constructor(options = {}) {
+    this._rightEdge = 0;
+    this._listeners = /* @__PURE__ */ new Set();
+    this._loopEnabled = false;
+    this._loopStart = 0;
+    this._loopEnd = 0;
+    this._lookahead = options.lookahead ?? 0.2;
+    this._onLoop = options.onLoop;
+  }
+  addListener(listener) {
+    this._listeners.add(listener);
+  }
+  removeListener(listener) {
+    this._listeners.delete(listener);
+  }
+  setLoop(enabled, start, end) {
+    if (enabled && start >= end) {
+      console.warn(
+        "[waveform-playlist] Scheduler.setLoop: start (" + start + ") must be less than end (" + end + ")"
+      );
+      return;
+    }
+    this._loopEnabled = enabled;
+    this._loopStart = start;
+    this._loopEnd = end;
+  }
+  reset(time) {
+    this._rightEdge = time;
+  }
+  advance(currentTime) {
+    const targetEdge = currentTime + this._lookahead;
+    if (this._loopEnabled && this._loopEnd > this._loopStart) {
+      const loopDuration = this._loopEnd - this._loopStart;
+      let remaining = targetEdge - this._rightEdge;
+      while (remaining > 0) {
+        const distToEnd = this._loopEnd - this._rightEdge;
+        if (distToEnd <= 0 || distToEnd > remaining) {
+          this._generateAndConsume(this._rightEdge, this._rightEdge + remaining);
+          this._rightEdge += remaining;
+          break;
+        }
+        this._generateAndConsume(this._rightEdge, this._loopEnd);
+        remaining -= distToEnd;
+        for (const listener of this._listeners) {
+          listener.onPositionJump(this._loopStart);
+        }
+        this._onLoop?.(this._loopStart);
+        this._rightEdge = this._loopStart;
+        if (loopDuration <= 0) break;
+      }
+      return;
+    }
+    if (targetEdge > this._rightEdge) {
+      this._generateAndConsume(this._rightEdge, targetEdge);
+      this._rightEdge = targetEdge;
+    }
+  }
+  _generateAndConsume(from, to) {
+    for (const listener of this._listeners) {
+      try {
+        const events = listener.generate(from, to);
+        for (const event of events) {
+          try {
+            listener.consume(event);
+          } catch (err) {
+            console.warn("[waveform-playlist] Scheduler: error consuming event:", String(err));
+          }
+        }
+      } catch (err) {
+        console.warn("[waveform-playlist] Scheduler: error generating events:", String(err));
+      }
+    }
+  }
+};
+
+// src/core/timer.ts
+var Timer = class {
+  constructor(onTick) {
+    this._rafId = null;
+    this._running = false;
+    this._onTick = onTick;
+  }
+  start() {
+    if (this._running) return;
+    this._running = true;
+    this._scheduleFrame();
+  }
+  stop() {
+    this._running = false;
+    if (this._rafId !== null) {
+      cancelAnimationFrame(this._rafId);
+      this._rafId = null;
+    }
+  }
+  _scheduleFrame() {
+    this._rafId = requestAnimationFrame(() => {
+      if (!this._running) return;
+      try {
+        this._onTick();
+      } catch (err) {
+        console.warn("[waveform-playlist] Timer tick error:", String(err));
+      }
+      this._scheduleFrame();
+    });
+  }
+};
+
+// src/timeline/sample-timeline.ts
+var SampleTimeline = class {
+  constructor(sampleRate) {
+    this._sampleRate = sampleRate;
+  }
+  get sampleRate() {
+    return this._sampleRate;
+  }
+  samplesToSeconds(samples) {
+    return samples / this._sampleRate;
+  }
+  secondsToSamples(seconds) {
+    return Math.round(seconds * this._sampleRate);
+  }
+};
+
+// src/timeline/tick-timeline.ts
+var TickTimeline = class {
+  constructor(ppqn = 960) {
+    this._ppqn = ppqn;
+  }
+  get ppqn() {
+    return this._ppqn;
+  }
+  ticksPerBeat() {
+    return this._ppqn;
+  }
+  ticksPerBar(beatsPerBar) {
+    return this._ppqn * beatsPerBar;
+  }
+  toPosition(ticks, beatsPerBar) {
+    const ticksPerBar = this.ticksPerBar(beatsPerBar);
+    const bar = Math.floor(ticks / ticksPerBar) + 1;
+    const remaining = ticks % ticksPerBar;
+    const beat = Math.floor(remaining / this._ppqn) + 1;
+    const tick = remaining % this._ppqn;
+    return { bar, beat, tick };
+  }
+  fromPosition(bar, beat, tick, beatsPerBar) {
+    const ticksPerBar = this.ticksPerBar(beatsPerBar);
+    return (bar - 1) * ticksPerBar + (beat - 1) * this._ppqn + tick;
+  }
+};
+
+// src/timeline/tempo-map.ts
+var TempoMap = class {
+  constructor(ppqn = 960, initialBpm = 120) {
+    this._ppqn = ppqn;
+    this._entries = [{ tick: 0, bpm: initialBpm, secondsAtTick: 0 }];
+  }
+  getTempo(atTick = 0) {
+    const entry = this._entryAt(atTick);
+    return entry.bpm;
+  }
+  setTempo(bpm, atTick = 0) {
+    if (atTick === 0) {
+      this._entries[0] = { ...this._entries[0], bpm };
+      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 };
+    } else {
+      const secondsAtTick = this._ticksToSecondsInternal(atTick);
+      this._entries.splice(i + 1, 0, { tick: atTick, bpm, secondsAtTick });
+      i = i + 1;
+    }
+    this._recomputeCache(i);
+  }
+  ticksToSeconds(ticks) {
+    return this._ticksToSecondsInternal(ticks);
+  }
+  secondsToTicks(seconds) {
+    let lo = 0;
+    let hi = this._entries.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (this._entries[mid].secondsAtTick <= seconds) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    const entry = this._entries[lo];
+    const secondsIntoSegment = seconds - entry.secondsAtTick;
+    const ticksPerSecond = entry.bpm / 60 * this._ppqn;
+    return entry.tick + secondsIntoSegment * ticksPerSecond;
+  }
+  beatsToSeconds(beats) {
+    return this.ticksToSeconds(beats * this._ppqn);
+  }
+  secondsToBeats(seconds) {
+    return this.secondsToTicks(seconds) / this._ppqn;
+  }
+  _ticksToSecondsInternal(ticks) {
+    const entry = this._entryAt(ticks);
+    const ticksIntoSegment = ticks - entry.tick;
+    const secondsPerTick = 60 / (entry.bpm * this._ppqn);
+    return entry.secondsAtTick + ticksIntoSegment * secondsPerTick;
+  }
+  _entryAt(tick) {
+    let lo = 0;
+    let hi = this._entries.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (this._entries[mid].tick <= tick) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return this._entries[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);
+      this._entries[i] = {
+        ...this._entries[i],
+        secondsAtTick: prev.secondsAtTick + tickDelta * secondsPerTick
+      };
+    }
+  }
+};
+
+// src/audio/master-node.ts
+var MasterNode = class {
+  constructor(audioContext) {
+    this._gainNode = audioContext.createGain();
+  }
+  get input() {
+    return this._gainNode;
+  }
+  get output() {
+    return this._gainNode;
+  }
+  setVolume(value) {
+    this._gainNode.gain.value = value;
+  }
+  dispose() {
+    try {
+      this._gainNode.disconnect();
+    } catch (err) {
+      console.warn("[waveform-playlist] MasterNode.dispose: error disconnecting:", String(err));
+    }
+  }
+};
+
+// src/audio/track-node.ts
+var TrackNode = class {
+  constructor(id, audioContext) {
+    this._destination = null;
+    this._effectsInput = null;
+    this.id = id;
+    this._volumeNode = audioContext.createGain();
+    this._panNode = audioContext.createStereoPanner();
+    this._panNode.channelCount = 2;
+    this._muteNode = audioContext.createGain();
+    this._volumeNode.connect(this._panNode);
+    this._panNode.connect(this._muteNode);
+  }
+  /** Where clip sources connect */
+  get input() {
+    return this._volumeNode;
+  }
+  /** Connect this track's output to a destination (master node) */
+  connectOutput(destination) {
+    this._destination = destination;
+    this._muteNode.connect(destination);
+  }
+  setVolume(value) {
+    this._volumeNode.gain.value = value;
+  }
+  setPan(value) {
+    this._panNode.pan.value = value;
+  }
+  setMute(muted) {
+    this._muteNode.gain.value = muted ? 0 : 1;
+  }
+  connectEffects(effectsInput) {
+    if (this._effectsInput) {
+      this.disconnectEffects();
+    }
+    this._muteNode.disconnect();
+    this._muteNode.connect(effectsInput);
+    this._effectsInput = effectsInput;
+  }
+  disconnectEffects() {
+    if (this._effectsInput && this._destination) {
+      this._muteNode.disconnect();
+      this._muteNode.connect(this._destination);
+      this._effectsInput = null;
+    }
+  }
+  dispose() {
+    for (const node of [this._volumeNode, this._panNode, this._muteNode]) {
+      try {
+        node.disconnect();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] TrackNode.dispose: error disconnecting node:",
+          String(err)
+        );
+      }
+    }
+  }
+};
+
+// src/audio/clip-player.ts
+var ClipPlayer = class {
+  constructor(audioContext, sampleTimeline, toAudioTime) {
+    this._tracks = /* @__PURE__ */ new Map();
+    this._trackNodes = /* @__PURE__ */ new Map();
+    this._activeSources = /* @__PURE__ */ new Map();
+    this._loopEnabled = false;
+    this._loopEnd = 0;
+    this._audioContext = audioContext;
+    this._sampleTimeline = sampleTimeline;
+    this._toAudioTime = toAudioTime;
+  }
+  setTracks(tracks, trackNodes) {
+    this._tracks.clear();
+    this._trackNodes = trackNodes;
+    for (const track of tracks) {
+      this._tracks.set(track.id, { track, clips: track.clips });
+    }
+  }
+  setLoop(enabled, _start, end) {
+    this._loopEnabled = enabled;
+    this._loopEnd = end;
+  }
+  updateTrack(trackId, track) {
+    this._tracks.set(trackId, { track, clips: track.clips });
+    this._silenceTrack(trackId);
+  }
+  generate(fromTime, toTime) {
+    const events = [];
+    for (const [trackId, state] of this._tracks) {
+      for (const clip of state.clips) {
+        if (clip.durationSamples === 0) continue;
+        if (!clip.audioBuffer) continue;
+        const clipStartTime = this._sampleTimeline.samplesToSeconds(clip.startSample);
+        const clipDuration = this._sampleTimeline.samplesToSeconds(clip.durationSamples);
+        const clipOffsetTime = this._sampleTimeline.samplesToSeconds(clip.offsetSamples);
+        if (clipStartTime < fromTime) continue;
+        if (clipStartTime >= toTime) continue;
+        const fadeInDuration = clip.fadeIn ? this._sampleTimeline.samplesToSeconds(clip.fadeIn.duration ?? 0) : 0;
+        const fadeOutDuration = clip.fadeOut ? this._sampleTimeline.samplesToSeconds(clip.fadeOut.duration ?? 0) : 0;
+        let duration = clipDuration;
+        if (this._loopEnabled && clipStartTime + duration > this._loopEnd) {
+          duration = this._loopEnd - clipStartTime;
+        }
+        events.push({
+          trackId,
+          clipId: clip.id,
+          audioBuffer: clip.audioBuffer,
+          transportTime: clipStartTime,
+          offset: clipOffsetTime,
+          duration,
+          gain: clip.gain,
+          fadeInDuration,
+          fadeOutDuration
+        });
+      }
+    }
+    return events;
+  }
+  consume(event) {
+    const trackNode = this._trackNodes.get(event.trackId);
+    if (!trackNode) {
+      console.warn(
+        '[waveform-playlist] ClipPlayer.consume: no TrackNode for trackId "' + event.trackId + '", clipId "' + event.clipId + '" \u2014 clip will not play'
+      );
+      return;
+    }
+    if (event.offset >= event.audioBuffer.duration) {
+      return;
+    }
+    const source = this._audioContext.createBufferSource();
+    source.buffer = event.audioBuffer;
+    const when = this._toAudioTime(event.transportTime);
+    const gainNode = this._audioContext.createGain();
+    gainNode.gain.value = event.gain;
+    let fadeIn = event.fadeInDuration;
+    let fadeOut = event.fadeOutDuration;
+    if (fadeIn + fadeOut > event.duration) {
+      const ratio = event.duration / (fadeIn + fadeOut);
+      fadeIn *= ratio;
+      fadeOut *= ratio;
+    }
+    if (fadeIn > 0) {
+      gainNode.gain.setValueAtTime(0, when);
+      gainNode.gain.linearRampToValueAtTime(event.gain, when + fadeIn);
+    }
+    if (fadeOut > 0) {
+      const fadeOutStart = when + event.duration - fadeOut;
+      gainNode.gain.setValueAtTime(event.gain, fadeOutStart);
+      gainNode.gain.linearRampToValueAtTime(0, when + event.duration);
+    }
+    source.connect(gainNode);
+    gainNode.connect(trackNode.input);
+    this._activeSources.set(source, {
+      trackId: event.trackId,
+      gainNode
+    });
+    source.addEventListener("ended", () => {
+      this._activeSources.delete(source);
+      try {
+        gainNode.disconnect();
+      } catch (err) {
+        console.warn("[waveform-playlist] ClipPlayer: error disconnecting gain node:", String(err));
+      }
+    });
+    source.start(when, event.offset, event.duration);
+  }
+  onPositionJump(newTime) {
+    this.silence();
+    for (const [trackId, state] of this._tracks) {
+      for (const clip of state.clips) {
+        if (clip.durationSamples === 0) continue;
+        if (!clip.audioBuffer) continue;
+        const clipStartTime = this._sampleTimeline.samplesToSeconds(clip.startSample);
+        const clipDuration = this._sampleTimeline.samplesToSeconds(clip.durationSamples);
+        const clipEndTime = clipStartTime + clipDuration;
+        const clipOffsetTime = this._sampleTimeline.samplesToSeconds(clip.offsetSamples);
+        if (clipStartTime <= newTime && clipEndTime > newTime) {
+          const offsetIntoClip = newTime - clipStartTime;
+          const offset = clipOffsetTime + offsetIntoClip;
+          const duration = clipEndTime - newTime;
+          const fadeOutDuration = clip.fadeOut ? this._sampleTimeline.samplesToSeconds(clip.fadeOut.duration ?? 0) : 0;
+          this.consume({
+            trackId,
+            clipId: clip.id,
+            audioBuffer: clip.audioBuffer,
+            transportTime: newTime,
+            offset,
+            duration,
+            gain: clip.gain,
+            fadeInDuration: 0,
+            fadeOutDuration
+          });
+        }
+      }
+    }
+  }
+  silence() {
+    for (const [source, { gainNode }] of this._activeSources) {
+      try {
+        source.stop();
+      } catch (err) {
+        console.warn("[waveform-playlist] ClipPlayer.silence: error stopping source:", String(err));
+      }
+      try {
+        gainNode.disconnect();
+      } catch (err) {
+        console.warn("[waveform-playlist] ClipPlayer.silence: error disconnecting:", String(err));
+      }
+    }
+    this._activeSources.clear();
+  }
+  _silenceTrack(trackId) {
+    const toDelete = [];
+    for (const [source, info] of this._activeSources) {
+      if (info.trackId === trackId) {
+        try {
+          source.stop();
+        } catch (err) {
+          console.warn(
+            "[waveform-playlist] ClipPlayer._silenceTrack: error stopping source:",
+            String(err)
+          );
+        }
+        try {
+          info.gainNode.disconnect();
+        } catch (err) {
+          console.warn(
+            "[waveform-playlist] ClipPlayer._silenceTrack: error disconnecting:",
+            String(err)
+          );
+        }
+        toDelete.push(source);
+      }
+    }
+    for (const source of toDelete) {
+      this._activeSources.delete(source);
+    }
+  }
+};
+
+// src/audio/metronome-player.ts
+var MetronomePlayer = class {
+  constructor(audioContext, tempoMap, tickTimeline, destination, toAudioTime) {
+    this._enabled = false;
+    this._beatsPerBar = 4;
+    this._accentBuffer = null;
+    this._normalBuffer = null;
+    this._activeSources = /* @__PURE__ */ new Set();
+    this._audioContext = audioContext;
+    this._tempoMap = tempoMap;
+    this._tickTimeline = tickTimeline;
+    this._destination = destination;
+    this._toAudioTime = toAudioTime;
+  }
+  setEnabled(enabled) {
+    this._enabled = enabled;
+    if (!enabled) {
+      this.silence();
+    }
+  }
+  setBeatsPerBar(beats) {
+    this._beatsPerBar = beats;
+  }
+  setClickSounds(accent, normal) {
+    this._accentBuffer = accent;
+    this._normalBuffer = normal;
+  }
+  generate(fromTime, toTime) {
+    if (!this._enabled || !this._accentBuffer || !this._normalBuffer) {
+      return [];
+    }
+    const events = [];
+    const ppqn = this._tickTimeline.ppqn;
+    const fromTicks = this._tempoMap.secondsToTicks(fromTime);
+    const toTicks = this._tempoMap.secondsToTicks(toTime);
+    const firstBeatTick = Math.ceil(fromTicks / ppqn) * ppqn;
+    for (let tick = firstBeatTick; tick < toTicks; tick += ppqn) {
+      const transportTime = this._tempoMap.ticksToSeconds(tick);
+      const ticksPerBar = this._tickTimeline.ticksPerBar(this._beatsPerBar);
+      const isAccent = tick % ticksPerBar === 0;
+      events.push({
+        transportTime,
+        isAccent,
+        buffer: isAccent ? this._accentBuffer : this._normalBuffer
+      });
+    }
+    return events;
+  }
+  consume(event) {
+    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] MetronomePlayer: error disconnecting source:",
+          String(err)
+        );
+      }
+    });
+    source.start(this._toAudioTime(event.transportTime));
+  }
+  onPositionJump(_newTime) {
+    this.silence();
+  }
+  silence() {
+    for (const source of this._activeSources) {
+      try {
+        source.stop();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] MetronomePlayer.silence: error stopping source:",
+          String(err)
+        );
+      }
+      try {
+        source.disconnect();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] MetronomePlayer.silence: error disconnecting:",
+          String(err)
+        );
+      }
+    }
+    this._activeSources.clear();
+  }
+};
+
+// src/transport.ts
+var Transport = class _Transport {
+  constructor(audioContext, options = {}) {
+    this._trackNodes = /* @__PURE__ */ new Map();
+    this._tracks = [];
+    this._soloedTrackIds = /* @__PURE__ */ new Set();
+    this._mutedTrackIds = /* @__PURE__ */ new Set();
+    this._playing = false;
+    this._listeners = /* @__PURE__ */ new Map();
+    this._audioContext = audioContext;
+    const sampleRate = options.sampleRate ?? audioContext.sampleRate;
+    const ppqn = options.ppqn ?? 960;
+    const tempo = options.tempo ?? 120;
+    const beatsPerBar = options.beatsPerBar ?? 4;
+    const lookahead = options.schedulerLookahead ?? 0.2;
+    _Transport._validateOptions(sampleRate, ppqn, tempo, beatsPerBar, lookahead);
+    this._clock = new Clock(audioContext);
+    this._scheduler = new Scheduler({
+      lookahead,
+      onLoop: (loopStartTime) => {
+        this._clock.seekTo(loopStartTime);
+      }
+    });
+    this._sampleTimeline = new SampleTimeline(sampleRate);
+    this._tickTimeline = new TickTimeline(ppqn);
+    this._tempoMap = new TempoMap(ppqn, tempo);
+    this._initAudioGraph(audioContext, beatsPerBar);
+    this._timer = new Timer(() => {
+      const time = this._clock.getTime();
+      if (this._endTime !== void 0 && time >= this._endTime) {
+        this.stop();
+        return;
+      }
+      this._scheduler.advance(time);
+    });
+  }
+  get audioContext() {
+    return this._audioContext;
+  }
+  // --- Playback ---
+  play(startTime, endTime) {
+    if (this._playing) return;
+    if (startTime !== void 0) {
+      this._clock.seekTo(startTime);
+    }
+    const currentTime = this._clock.getTime();
+    this._scheduler.reset(currentTime);
+    this._endTime = endTime;
+    this._clock.start();
+    this._clipPlayer.onPositionJump(currentTime);
+    this._timer.start();
+    this._playing = true;
+    this._emit("play");
+  }
+  pause() {
+    if (!this._playing) return;
+    this._timer.stop();
+    this._clock.stop();
+    this._silenceAll();
+    this._playing = false;
+    this._emit("pause");
+  }
+  stop() {
+    const wasPlaying = this._playing;
+    this._timer.stop();
+    this._clock.reset();
+    this._scheduler.reset(0);
+    this._silenceAll();
+    this._playing = false;
+    this._endTime = void 0;
+    if (wasPlaying) {
+      this._emit("stop");
+    }
+  }
+  seek(time) {
+    const wasPlaying = this._playing;
+    if (wasPlaying) {
+      this._timer.stop();
+    }
+    this._silenceAll();
+    this._clock.seekTo(time);
+    this._scheduler.reset(time);
+    this._endTime = void 0;
+    if (wasPlaying) {
+      this._clock.start();
+      this._clipPlayer.onPositionJump(time);
+      this._timer.start();
+    }
+  }
+  getCurrentTime() {
+    return this._clock.getTime();
+  }
+  isPlaying() {
+    return this._playing;
+  }
+  // --- Tracks ---
+  setTracks(tracks) {
+    for (const node of this._trackNodes.values()) {
+      node.dispose();
+    }
+    this._trackNodes.clear();
+    this._soloedTrackIds.clear();
+    this._mutedTrackIds.clear();
+    this._tracks = tracks;
+    for (const track of tracks) {
+      const trackNode = new TrackNode(track.id, this._audioContext);
+      trackNode.setVolume(track.volume);
+      trackNode.setPan(track.pan);
+      trackNode.connectOutput(this._masterNode.input);
+      this._trackNodes.set(track.id, trackNode);
+      if (track.muted) {
+        this._mutedTrackIds.add(track.id);
+      }
+      if (track.soloed) {
+        this._soloedTrackIds.add(track.id);
+      }
+    }
+    this._applyMuteState();
+    this._clipPlayer.setTracks(tracks, this._trackNodes);
+  }
+  addTrack(track) {
+    const trackNode = new TrackNode(track.id, this._audioContext);
+    trackNode.setVolume(track.volume);
+    trackNode.setPan(track.pan);
+    trackNode.connectOutput(this._masterNode.input);
+    this._trackNodes.set(track.id, trackNode);
+    if (track.muted) {
+      this._mutedTrackIds.add(track.id);
+    }
+    if (track.soloed) {
+      this._soloedTrackIds.add(track.id);
+    }
+    this._tracks = [...this._tracks, track];
+    this._applyMuteState();
+    this._clipPlayer.setTracks(this._tracks, this._trackNodes);
+  }
+  removeTrack(trackId) {
+    const node = this._trackNodes.get(trackId);
+    if (node) {
+      node.dispose();
+      this._trackNodes.delete(trackId);
+    }
+    this._soloedTrackIds.delete(trackId);
+    this._mutedTrackIds.delete(trackId);
+    this._tracks = this._tracks.filter((t) => t.id !== trackId);
+    this._applyMuteState();
+    this._clipPlayer.setTracks(this._tracks, this._trackNodes);
+  }
+  updateTrack(trackId, track) {
+    this._tracks = this._tracks.map((t) => t.id === trackId ? track : t);
+    const node = this._trackNodes.get(trackId);
+    if (node) {
+      node.setVolume(track.volume);
+      node.setPan(track.pan);
+    }
+    if (track.muted) {
+      this._mutedTrackIds.add(trackId);
+    } else {
+      this._mutedTrackIds.delete(trackId);
+    }
+    if (track.soloed) {
+      this._soloedTrackIds.add(trackId);
+    } else {
+      this._soloedTrackIds.delete(trackId);
+    }
+    this._applyMuteState();
+    this._clipPlayer.updateTrack(trackId, track);
+  }
+  // --- Track Controls ---
+  setTrackVolume(trackId, volume) {
+    const node = this._trackNodes.get(trackId);
+    if (!node) {
+      console.warn('[waveform-playlist] setTrackVolume: unknown trackId "' + trackId + '"');
+      return;
+    }
+    node.setVolume(volume);
+  }
+  setTrackPan(trackId, pan) {
+    const node = this._trackNodes.get(trackId);
+    if (!node) {
+      console.warn('[waveform-playlist] setTrackPan: unknown trackId "' + trackId + '"');
+      return;
+    }
+    node.setPan(pan);
+  }
+  setTrackMute(trackId, muted) {
+    if (muted) {
+      this._mutedTrackIds.add(trackId);
+    } else {
+      this._mutedTrackIds.delete(trackId);
+    }
+    this._applyMuteState();
+  }
+  setTrackSolo(trackId, soloed) {
+    if (soloed) {
+      this._soloedTrackIds.add(trackId);
+    } else {
+      this._soloedTrackIds.delete(trackId);
+    }
+    this._applyMuteState();
+  }
+  // --- Master ---
+  setMasterVolume(volume) {
+    this._masterNode.setVolume(volume);
+  }
+  // --- Loop ---
+  setLoop(enabled, start, end) {
+    if (enabled && start >= end) {
+      console.warn(
+        "[waveform-playlist] Transport.setLoop: start (" + start + ") must be less than end (" + end + ")"
+      );
+      return;
+    }
+    this._scheduler.setLoop(enabled, start, end);
+    this._clipPlayer.setLoop(enabled, start, end);
+    this._emit("loop");
+  }
+  // --- Tempo ---
+  setTempo(bpm) {
+    this._tempoMap.setTempo(bpm);
+    this._emit("tempochange");
+  }
+  getTempo() {
+    return this._tempoMap.getTempo();
+  }
+  setBeatsPerBar(beats) {
+    this._metronomePlayer.setBeatsPerBar(beats);
+  }
+  // --- Metronome ---
+  setMetronomeEnabled(enabled) {
+    this._metronomePlayer.setEnabled(enabled);
+  }
+  setMetronomeClickSounds(accent, normal) {
+    this._metronomePlayer.setClickSounds(accent, normal);
+  }
+  // --- Effects Hook ---
+  connectTrackOutput(trackId, node) {
+    const trackNode = this._trackNodes.get(trackId);
+    if (!trackNode) {
+      console.warn('[waveform-playlist] connectTrackOutput: unknown trackId "' + trackId + '"');
+      return;
+    }
+    trackNode.connectEffects(node);
+  }
+  disconnectTrackOutput(trackId) {
+    const trackNode = this._trackNodes.get(trackId);
+    if (!trackNode) {
+      console.warn('[waveform-playlist] disconnectTrackOutput: unknown trackId "' + trackId + '"');
+      return;
+    }
+    trackNode.disconnectEffects();
+  }
+  // --- Events ---
+  on(event, cb) {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this._listeners.get(event).add(cb);
+  }
+  off(event, cb) {
+    this._listeners.get(event)?.delete(cb);
+  }
+  // --- Dispose ---
+  dispose() {
+    this.stop();
+    for (const node of this._trackNodes.values()) {
+      node.dispose();
+    }
+    this._trackNodes.clear();
+    this._masterNode.dispose();
+    this._listeners.clear();
+  }
+  // --- Private ---
+  static _validateOptions(sampleRate, ppqn, tempo, beatsPerBar, lookahead) {
+    if (sampleRate <= 0) {
+      throw new Error(
+        "[waveform-playlist] Transport: sampleRate must be positive, got " + sampleRate
+      );
+    }
+    if (ppqn <= 0 || !Number.isInteger(ppqn)) {
+      throw new Error(
+        "[waveform-playlist] Transport: ppqn must be a positive integer, got " + ppqn
+      );
+    }
+    if (tempo <= 0) {
+      throw new Error("[waveform-playlist] Transport: tempo must be positive, got " + tempo);
+    }
+    if (beatsPerBar <= 0 || !Number.isInteger(beatsPerBar)) {
+      throw new Error(
+        "[waveform-playlist] Transport: beatsPerBar must be a positive integer, got " + beatsPerBar
+      );
+    }
+    if (lookahead <= 0) {
+      throw new Error(
+        "[waveform-playlist] Transport: schedulerLookahead must be positive, got " + lookahead
+      );
+    }
+  }
+  _initAudioGraph(audioContext, beatsPerBar) {
+    this._masterNode = new MasterNode(audioContext);
+    this._masterNode.output.connect(audioContext.destination);
+    const toAudioTime = (transportTime) => this._clock.toAudioTime(transportTime);
+    this._clipPlayer = new ClipPlayer(audioContext, this._sampleTimeline, toAudioTime);
+    this._metronomePlayer = new MetronomePlayer(
+      audioContext,
+      this._tempoMap,
+      this._tickTimeline,
+      this._masterNode.input,
+      toAudioTime
+    );
+    this._metronomePlayer.setBeatsPerBar(beatsPerBar);
+    this._scheduler.addListener(this._clipPlayer);
+    this._scheduler.addListener(this._metronomePlayer);
+  }
+  _silenceAll() {
+    this._clipPlayer.silence();
+    this._metronomePlayer.silence();
+  }
+  _applyMuteState() {
+    const hasSolo = this._soloedTrackIds.size > 0;
+    for (const [trackId, node] of this._trackNodes) {
+      const isExplicitlyMuted = this._mutedTrackIds.has(trackId);
+      const isSoloMuted = hasSolo && !this._soloedTrackIds.has(trackId);
+      node.setMute(isExplicitlyMuted || isSoloMuted);
+    }
+  }
+  _emit(event) {
+    const listeners = this._listeners.get(event);
+    if (listeners) {
+      for (const cb of listeners) {
+        try {
+          cb();
+        } catch (err) {
+          console.warn(
+            '[waveform-playlist] Transport "' + event + '" listener threw:',
+            String(err)
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/adapter.ts
+var NativePlayoutAdapter = class {
+  constructor(audioContext, options) {
+    this._audioContext = audioContext;
+    this._transport = new Transport(audioContext, options);
+  }
+  get transport() {
+    return this._transport;
+  }
+  async init() {
+    if (this._audioContext.state === "closed") {
+      throw new Error("[waveform-playlist] Cannot init: AudioContext is closed");
+    }
+    if (this._audioContext.state === "suspended") {
+      await this._audioContext.resume();
+    }
+  }
+  setTracks(tracks) {
+    this._transport.setTracks(tracks);
+  }
+  addTrack(track) {
+    this._transport.addTrack(track);
+  }
+  removeTrack(trackId) {
+    this._transport.removeTrack(trackId);
+  }
+  updateTrack(trackId, track) {
+    this._transport.updateTrack(trackId, track);
+  }
+  play(startTime, endTime) {
+    this._transport.play(startTime, endTime);
+  }
+  pause() {
+    this._transport.pause();
+  }
+  stop() {
+    this._transport.stop();
+  }
+  seek(time) {
+    this._transport.seek(time);
+  }
+  getCurrentTime() {
+    return this._transport.getCurrentTime();
+  }
+  isPlaying() {
+    return this._transport.isPlaying();
+  }
+  setMasterVolume(volume) {
+    this._transport.setMasterVolume(volume);
+  }
+  setTrackVolume(trackId, volume) {
+    this._transport.setTrackVolume(trackId, volume);
+  }
+  setTrackMute(trackId, muted) {
+    this._transport.setTrackMute(trackId, muted);
+  }
+  setTrackSolo(trackId, soloed) {
+    this._transport.setTrackSolo(trackId, soloed);
+  }
+  setTrackPan(trackId, pan) {
+    this._transport.setTrackPan(trackId, pan);
+  }
+  setLoop(enabled, start, end) {
+    this._transport.setLoop(enabled, start, end);
+  }
+  dispose() {
+    this._transport.dispose();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClipPlayer,
+  Clock,
+  MasterNode,
+  MetronomePlayer,
+  NativePlayoutAdapter,
+  SampleTimeline,
+  Scheduler,
+  TempoMap,
+  TickTimeline,
+  Timer,
+  TrackNode,
+  Transport
+});
+//# sourceMappingURL=index.js.map