@dawcore/transport 0.0.2 → 0.0.3

package/dist/index.mjs

@@ -49,12 +49,15 @@ var Clock = class {
 
 // src/core/scheduler.ts
 var Scheduler = class {
-  constructor(options = {}) {
+  constructor(tempoMap, options = {}) {
     this._rightEdge = 0;
+    // integer ticks
     this._listeners = /* @__PURE__ */ new Set();
     this._loopEnabled = false;
     this._loopStart = 0;
+    // integer ticks
     this._loopEnd = 0;
+    this._tempoMap = tempoMap;
     this._lookahead = options.lookahead ?? 0.2;
     this._onLoop = options.onLoop;
   }
@@ -64,25 +67,40 @@ var Scheduler = class {
   removeListener(listener) {
     this._listeners.delete(listener);
   }
-  setLoop(enabled, start, end) {
-    if (enabled && start >= end) {
+  /** Primary API — ticks as source of truth */
+  setLoop(enabled, startTick, endTick) {
+    if (enabled && (!Number.isFinite(startTick) || !Number.isFinite(endTick))) {
       console.warn(
-        "[waveform-playlist] Scheduler.setLoop: start (" + start + ") must be less than end (" + end + ")"
+        "[waveform-playlist] Scheduler.setLoop: non-finite tick values (" + startTick + ", " + endTick + ")"
+      );
+      return;
+    }
+    if (enabled && startTick >= endTick) {
+      console.warn(
+        "[waveform-playlist] Scheduler.setLoop: startTick (" + startTick + ") must be less than endTick (" + endTick + ")"
       );
       return;
     }
     this._loopEnabled = enabled;
-    this._loopStart = start;
-    this._loopEnd = end;
-  }
-  reset(time) {
-    this._rightEdge = time;
-  }
-  advance(currentTime) {
-    const targetEdge = currentTime + this._lookahead;
+    this._loopStart = Math.round(startTick);
+    this._loopEnd = Math.round(endTick);
+  }
+  /** Convenience — converts seconds to ticks via TempoMap */
+  setLoopSeconds(enabled, startSec, endSec) {
+    const startTick = this._tempoMap.secondsToTicks(startSec);
+    const endTick = this._tempoMap.secondsToTicks(endSec);
+    this.setLoop(enabled, startTick, endTick);
+  }
+  /** Reset scheduling cursor. Takes seconds (from Clock), converts to ticks. */
+  reset(timeSeconds) {
+    this._rightEdge = this._tempoMap.secondsToTicks(timeSeconds);
+  }
+  /** Advance the scheduling window. Takes seconds (from Clock), converts to ticks. */
+  advance(currentTimeSeconds) {
+    const targetTick = this._tempoMap.secondsToTicks(currentTimeSeconds + this._lookahead);
     if (this._loopEnabled && this._loopEnd > this._loopStart) {
       const loopDuration = this._loopEnd - this._loopStart;
-      let remaining = targetEdge - this._rightEdge;
+      let remaining = targetTick - this._rightEdge;
       while (remaining > 0) {
         const distToEnd = this._loopEnd - this._rightEdge;
         if (distToEnd <= 0 || distToEnd > remaining) {
@@ -95,21 +113,25 @@ var Scheduler = class {
         for (const listener of this._listeners) {
           listener.onPositionJump(this._loopStart);
         }
-        this._onLoop?.(this._loopStart);
+        this._onLoop?.(
+          this._tempoMap.ticksToSeconds(this._loopStart),
+          this._tempoMap.ticksToSeconds(this._loopEnd),
+          currentTimeSeconds
+        );
         this._rightEdge = this._loopStart;
         if (loopDuration <= 0) break;
       }
       return;
     }
-    if (targetEdge > this._rightEdge) {
-      this._generateAndConsume(this._rightEdge, targetEdge);
-      this._rightEdge = targetEdge;
+    if (targetTick > this._rightEdge) {
+      this._generateAndConsume(this._rightEdge, targetTick);
+      this._rightEdge = targetTick;
     }
   }
-  _generateAndConsume(from, to) {
+  _generateAndConsume(fromTick, toTick) {
     for (const listener of this._listeners) {
       try {
-        const events = listener.generate(from, to);
+        const events = listener.generate(fromTick, toTick);
         for (const event of events) {
           try {
             listener.consume(event);
@@ -159,17 +181,37 @@ var Timer = class {
 // src/timeline/sample-timeline.ts
 var SampleTimeline = class {
   constructor(sampleRate) {
+    this._tempoMap = null;
     this._sampleRate = sampleRate;
   }
   get sampleRate() {
     return this._sampleRate;
   }
+  setTempoMap(tempoMap) {
+    this._tempoMap = tempoMap;
+  }
   samplesToSeconds(samples) {
     return samples / this._sampleRate;
   }
   secondsToSamples(seconds) {
     return Math.round(seconds * this._sampleRate);
   }
+  ticksToSamples(ticks) {
+    if (!this._tempoMap) {
+      throw new Error(
+        "[waveform-playlist] SampleTimeline: tempoMap not set \u2014 call setTempoMap() first"
+      );
+    }
+    return Math.round(this._tempoMap.ticksToSeconds(ticks) * this._sampleRate);
+  }
+  samplesToTicks(samples) {
+    if (!this._tempoMap) {
+      throw new Error(
+        "[waveform-playlist] SampleTimeline: tempoMap not set \u2014 call setTempoMap() first"
+      );
+    }
+    return this._tempoMap.secondsToTicks(samples / this._sampleRate);
+  }
 };
 
 // src/timeline/tempo-map.ts
@@ -216,7 +258,7 @@ var TempoMap = class {
     const entry = this._entries[lo];
     const secondsIntoSegment = seconds - entry.secondsAtTick;
     const ticksPerSecond = entry.bpm / 60 * this._ppqn;
-    return entry.tick + secondsIntoSegment * ticksPerSecond;
+    return Math.round(entry.tick + secondsIntoSegment * ticksPerSecond);
   }
   beatsToSeconds(beats) {
     return this.ticksToSeconds(beats * this._ppqn);
@@ -518,14 +560,15 @@ var TrackNode = class {
 
 // src/audio/clip-player.ts
 var ClipPlayer = class {
-  constructor(audioContext, sampleTimeline, toAudioTime) {
+  constructor(audioContext, sampleTimeline, tempoMap, toAudioTime) {
     this._tracks = /* @__PURE__ */ new Map();
     this._trackNodes = /* @__PURE__ */ new Map();
     this._activeSources = /* @__PURE__ */ new Map();
     this._loopEnabled = false;
-    this._loopEnd = 0;
+    this._loopEndSamples = 0;
     this._audioContext = audioContext;
     this._sampleTimeline = sampleTimeline;
+    this._tempoMap = tempoMap;
     this._toAudioTime = toAudioTime;
   }
   setTracks(tracks, trackNodes) {
@@ -535,41 +578,50 @@ var ClipPlayer = class {
       this._tracks.set(track.id, { track, clips: track.clips });
     }
   }
-  setLoop(enabled, _start, end) {
+  /** Set loop region using ticks. startTick is unused — loop clamping only needs
+   *  the end boundary; mid-clip restart at loopStart is handled by onPositionJump. */
+  setLoop(enabled, _startTick, endTick) {
     this._loopEnabled = enabled;
-    this._loopEnd = end;
+    this._loopEndSamples = this._sampleTimeline.ticksToSamples(endTick);
+  }
+  /** Set loop region using samples directly */
+  setLoopSamples(enabled, _startSample, endSample) {
+    this._loopEnabled = enabled;
+    this._loopEndSamples = endSample;
   }
   updateTrack(trackId, track) {
     this._tracks.set(trackId, { track, clips: track.clips });
     this._silenceTrack(trackId);
   }
-  generate(fromTime, toTime) {
+  generate(fromTick, toTick) {
     const events = [];
+    const fromSample = this._sampleTimeline.ticksToSamples(fromTick);
+    const toSample = this._sampleTimeline.ticksToSamples(toTick);
     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;
+        const clipStartSample = clip.startSample;
+        if (clipStartSample < fromSample) continue;
+        if (clipStartSample >= toSample) continue;
+        const fadeInDurationSamples = clip.fadeIn ? clip.fadeIn.duration ?? 0 : 0;
+        const fadeOutDurationSamples = clip.fadeOut ? clip.fadeOut.duration ?? 0 : 0;
+        let durationSamples = clip.durationSamples;
+        if (this._loopEnabled && clipStartSample + durationSamples > this._loopEndSamples) {
+          durationSamples = this._loopEndSamples - clipStartSample;
         }
+        const clipTick = this._sampleTimeline.samplesToTicks(clipStartSample);
         events.push({
           trackId,
           clipId: clip.id,
           audioBuffer: clip.audioBuffer,
-          transportTime: clipStartTime,
-          offset: clipOffsetTime,
-          duration,
+          tick: clipTick,
+          startSample: clipStartSample,
+          offsetSamples: clip.offsetSamples,
+          durationSamples,
           gain: clip.gain,
-          fadeInDuration,
-          fadeOutDuration
+          fadeInDurationSamples,
+          fadeOutDurationSamples
         });
       }
     }
@@ -583,18 +635,25 @@ var ClipPlayer = class {
       );
       return;
     }
-    if (event.offset >= event.audioBuffer.duration) {
+    const sampleRate = this._sampleTimeline.sampleRate;
+    const offsetSeconds = event.offsetSamples / sampleRate;
+    const durationSeconds = event.durationSamples / sampleRate;
+    if (offsetSeconds >= event.audioBuffer.duration) {
+      console.warn(
+        "[waveform-playlist] ClipPlayer.consume: offset (" + offsetSeconds + "s) exceeds audioBuffer.duration (" + event.audioBuffer.duration + 's) for clipId "' + event.clipId + '" \u2014 clip will not play'
+      );
       return;
     }
     const source = this._audioContext.createBufferSource();
     source.buffer = event.audioBuffer;
-    const when = this._toAudioTime(event.transportTime);
+    const transportSeconds = this._tempoMap.ticksToSeconds(event.tick);
+    const when = this._toAudioTime(transportSeconds);
     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);
+    let fadeIn = event.fadeInDurationSamples / sampleRate;
+    let fadeOut = event.fadeOutDurationSamples / sampleRate;
+    if (fadeIn + fadeOut > durationSeconds) {
+      const ratio = durationSeconds / (fadeIn + fadeOut);
       fadeIn *= ratio;
       fadeOut *= ratio;
     }
@@ -603,9 +662,9 @@ var ClipPlayer = class {
       gainNode.gain.linearRampToValueAtTime(event.gain, when + fadeIn);
     }
     if (fadeOut > 0) {
-      const fadeOutStart = when + event.duration - fadeOut;
+      const fadeOutStart = when + durationSeconds - fadeOut;
       gainNode.gain.setValueAtTime(event.gain, fadeOutStart);
-      gainNode.gain.linearRampToValueAtTime(0, when + event.duration);
+      gainNode.gain.linearRampToValueAtTime(0, when + durationSeconds);
     }
     source.connect(gainNode);
     gainNode.connect(trackNode.input);
@@ -621,33 +680,37 @@ var ClipPlayer = class {
         console.warn("[waveform-playlist] ClipPlayer: error disconnecting gain node:", String(err));
       }
     });
-    source.start(when, event.offset, event.duration);
+    source.start(when, offsetSeconds, durationSeconds);
   }
-  onPositionJump(newTime) {
+  onPositionJump(newTick) {
     this.silence();
+    const newSample = this._sampleTimeline.ticksToSamples(newTick);
     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;
+        const clipStartSample = clip.startSample;
+        const clipEndSample = clipStartSample + clip.durationSamples;
+        if (clipStartSample <= newSample && clipEndSample > newSample) {
+          const offsetIntoClipSamples = newSample - clipStartSample;
+          const offsetSamples = clip.offsetSamples + offsetIntoClipSamples;
+          let durationSamples = clipEndSample - newSample;
+          if (this._loopEnabled && newSample + durationSamples > this._loopEndSamples) {
+            durationSamples = this._loopEndSamples - newSample;
+          }
+          if (durationSamples <= 0) continue;
+          const fadeOutDurationSamples = clip.fadeOut ? clip.fadeOut.duration ?? 0 : 0;
           this.consume({
             trackId,
             clipId: clip.id,
             audioBuffer: clip.audioBuffer,
-            transportTime: newTime,
-            offset,
-            duration,
+            tick: newTick,
+            startSample: newSample,
+            offsetSamples,
+            durationSamples,
             gain: clip.gain,
-            fadeInDuration: 0,
-            fadeOutDuration
+            fadeInDurationSamples: 0,
+            fadeOutDurationSamples
           });
         }
       }
@@ -720,31 +783,29 @@ var MetronomePlayer = class {
     this._accentBuffer = accent;
     this._normalBuffer = normal;
   }
-  generate(fromTime, toTime) {
+  generate(fromTick, toTick) {
     if (!this._enabled || !this._accentBuffer || !this._normalBuffer) {
       return [];
     }
     const events = [];
-    const fromTicks = this._tempoMap.secondsToTicks(fromTime);
-    const toTicks = this._tempoMap.secondsToTicks(toTime);
-    let entry = this._meterMap.getEntryAt(fromTicks);
-    let beatSize = this._meterMap.ticksPerBeat(fromTicks);
-    const tickIntoSection = fromTicks - entry.tick;
+    let entry = this._meterMap.getEntryAt(fromTick);
+    let beatSize = this._meterMap.ticksPerBeat(fromTick);
+    const tickIntoSection = fromTick - entry.tick;
     let tick = entry.tick + Math.ceil(tickIntoSection / beatSize) * beatSize;
-    while (tick < toTicks) {
-      const currentEntry = this._meterMap.getEntryAt(tick);
+    while (tick < toTick) {
+      const tickPos = tick;
+      const currentEntry = this._meterMap.getEntryAt(tickPos);
       if (currentEntry.tick !== entry.tick) {
         entry = currentEntry;
-        beatSize = this._meterMap.ticksPerBeat(tick);
+        beatSize = this._meterMap.ticksPerBeat(tickPos);
       }
-      const isAccent = this._meterMap.isBarBoundary(tick);
-      const transportTime = this._tempoMap.ticksToSeconds(tick);
+      const isAccent = this._meterMap.isBarBoundary(tickPos);
       events.push({
-        transportTime,
+        tick: tickPos,
         isAccent,
         buffer: isAccent ? this._accentBuffer : this._normalBuffer
       });
-      beatSize = this._meterMap.ticksPerBeat(tick);
+      beatSize = this._meterMap.ticksPerBeat(tickPos);
       tick += beatSize;
     }
     return events;
@@ -765,10 +826,10 @@ var MetronomePlayer = class {
         );
       }
     });
-    source.start(this._toAudioTime(event.transportTime));
+    const transportTime = this._tempoMap.ticksToSeconds(event.tick);
+    source.start(this._toAudioTime(transportTime));
   }
-  onPositionJump(_newTime) {
-    this.silence();
+  onPositionJump(_newTick) {
   }
   silence() {
     for (const source of this._activeSources) {
@@ -801,6 +862,8 @@ var Transport = class _Transport {
     this._soloedTrackIds = /* @__PURE__ */ new Set();
     this._mutedTrackIds = /* @__PURE__ */ new Set();
     this._playing = false;
+    this._loopEnabled = false;
+    this._loopStartSeconds = 0;
     this._listeners = /* @__PURE__ */ new Map();
     this._audioContext = audioContext;
     const sampleRate = options.sampleRate ?? audioContext.sampleRate;
@@ -811,15 +874,17 @@ var Transport = class _Transport {
     const lookahead = options.schedulerLookahead ?? 0.2;
     _Transport._validateOptions(sampleRate, ppqn, tempo, numerator, denominator, lookahead);
     this._clock = new Clock(audioContext);
-    this._scheduler = new Scheduler({
-      lookahead,
-      onLoop: (loopStartTime) => {
-        this._clock.seekTo(loopStartTime);
-      }
-    });
     this._sampleTimeline = new SampleTimeline(sampleRate);
     this._meterMap = new MeterMap(ppqn, numerator, denominator);
     this._tempoMap = new TempoMap(ppqn, tempo);
+    this._scheduler = new Scheduler(this._tempoMap, {
+      lookahead,
+      onLoop: (loopStartSeconds, loopEndSeconds, currentTimeSeconds) => {
+        const timeToBoundary = loopEndSeconds - currentTimeSeconds;
+        this._clock.seekTo(loopStartSeconds - timeToBoundary);
+      }
+    });
+    this._sampleTimeline.setTempoMap(this._tempoMap);
     this._initAudioGraph(audioContext);
     this._timer = new Timer(() => {
       const time = this._clock.getTime();
@@ -843,7 +908,8 @@ var Transport = class _Transport {
     this._scheduler.reset(currentTime);
     this._endTime = endTime;
     this._clock.start();
-    this._clipPlayer.onPositionJump(currentTime);
+    const currentTick = this._tempoMap.secondsToTicks(currentTime);
+    this._clipPlayer.onPositionJump(currentTick);
     this._timer.start();
     this._playing = true;
     this._emit("play");
@@ -879,12 +945,17 @@ var Transport = class _Transport {
     this._endTime = void 0;
     if (wasPlaying) {
       this._clock.start();
-      this._clipPlayer.onPositionJump(time);
+      const seekTick = this._tempoMap.secondsToTicks(time);
+      this._clipPlayer.onPositionJump(seekTick);
       this._timer.start();
     }
   }
   getCurrentTime() {
-    return this._clock.getTime();
+    const t = this._clock.getTime();
+    if (this._loopEnabled && t < this._loopStartSeconds) {
+      return this._loopStartSeconds;
+    }
+    return t;
   }
   isPlaying() {
     return this._playing;
@@ -1000,15 +1071,46 @@ var Transport = class _Transport {
     this._masterNode.setVolume(volume);
   }
   // --- Loop ---
-  setLoop(enabled, start, end) {
-    if (enabled && start >= end) {
+  /** Primary loop API — ticks as source of truth */
+  setLoop(enabled, startTick, endTick) {
+    if (enabled && startTick >= endTick) {
+      console.warn(
+        "[waveform-playlist] Transport.setLoop: startTick (" + startTick + ") must be less than endTick (" + endTick + ")"
+      );
+      return;
+    }
+    this._loopEnabled = enabled;
+    this._loopStartSeconds = this._tempoMap.ticksToSeconds(startTick);
+    this._scheduler.setLoop(enabled, startTick, endTick);
+    this._clipPlayer.setLoop(enabled, startTick, endTick);
+    this._emit("loop");
+  }
+  /** Convenience — converts seconds to ticks */
+  setLoopSeconds(enabled, startSec, endSec) {
+    const startTick = this._tempoMap.secondsToTicks(startSec);
+    const endTick = this._tempoMap.secondsToTicks(endSec);
+    this.setLoop(enabled, startTick, endTick);
+  }
+  /** Convenience — sets loop in samples */
+  setLoopSamples(enabled, startSample, endSample) {
+    if (enabled && (!Number.isFinite(startSample) || !Number.isFinite(endSample))) {
       console.warn(
-        "[waveform-playlist] Transport.setLoop: start (" + start + ") must be less than end (" + end + ")"
+        "[waveform-playlist] Transport.setLoopSamples: non-finite sample values (" + startSample + ", " + endSample + ")"
       );
       return;
     }
-    this._scheduler.setLoop(enabled, start, end);
-    this._clipPlayer.setLoop(enabled, start, end);
+    if (enabled && startSample >= endSample) {
+      console.warn(
+        "[waveform-playlist] Transport.setLoopSamples: startSample (" + startSample + ") must be less than endSample (" + endSample + ")"
+      );
+      return;
+    }
+    const startTick = this._sampleTimeline.samplesToTicks(startSample);
+    const endTick = this._sampleTimeline.samplesToTicks(endSample);
+    this._loopEnabled = enabled;
+    this._loopStartSeconds = this._tempoMap.ticksToSeconds(startTick);
+    this._clipPlayer.setLoopSamples(enabled, startSample, endSample);
+    this._scheduler.setLoop(enabled, startTick, endTick);
     this._emit("loop");
   }
   // --- Tempo ---
@@ -1132,7 +1234,12 @@ var Transport = class _Transport {
     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._clipPlayer = new ClipPlayer(
+      audioContext,
+      this._sampleTimeline,
+      this._tempoMap,
+      toAudioTime
+    );
     this._metronomePlayer = new MetronomePlayer(
       audioContext,
       this._tempoMap,
@@ -1235,7 +1342,7 @@ var NativePlayoutAdapter = class {
     this._transport.setTrackPan(trackId, pan);
   }
   setLoop(enabled, start, end) {
-    this._transport.setLoop(enabled, start, end);
+    this._transport.setLoopSeconds(enabled, start, end);
   }
   dispose() {
     this._transport.dispose();