@waveform-playlist/playout 7.1.3 → 8.1.0

package/dist/index.js

@@ -51,7 +51,7 @@ function getUnderlyingAudioParam(signal) {
   if (!param && !hasWarned) {
     hasWarned = true;
     console.warn(
-      "[waveform-playlist] Unable to access Tone.js internal _param. This likely means the Tone.js version is incompatible. Fades and mute scheduling may not work correctly."
+      "[waveform-playlist] Unable to access Tone.js internal _param. This likely means the Tone.js version is incompatible. Mute scheduling may not work correctly."
     );
   }
   return param;
@@ -145,13 +145,20 @@ function applyFadeOut(param, startTime, duration, type = "linear", startValue =
 
 // src/ToneTrack.ts
 var ToneTrack = class {
-  // Count of currently playing clips
   constructor(options) {
-    this.activePlayers = 0;
+    this.activeSources = /* @__PURE__ */ new Set();
+    // Guard against ghost tick schedule callbacks. After stop/start cycles with
+    // loops, stale Clock._lastUpdate causes ticks from the previous cycle to fire
+    // Transport.schedule() callbacks at past positions (e.g., time 0 clips fire
+    // when starting at offset 5s). Clips before this offset are handled by
+    // startMidClipSources(); schedule callbacks should only create sources for
+    // clips at/after this offset.
+    this._scheduleGuardOffset = 0;
     this.track = options.track;
     this.volumeNode = new import_tone.Volume(this.gainToDb(options.track.gain));
     this.panNode = new import_tone.Panner(options.track.stereoPan);
     this.muteGain = new import_tone.Gain(options.track.muted ? 0 : 1);
+    this.volumeNode.chain(this.panNode, this.muteGain);
     const destination = options.destination || (0, import_tone.getDestination)();
     if (options.effects) {
       const cleanup = options.effects(this.muteGain, destination, false);
@@ -165,45 +172,112 @@ var ToneTrack = class {
       {
         buffer: options.buffer,
         startTime: 0,
-        // Legacy: single buffer starts at timeline position 0
         duration: options.buffer.duration,
-        // Legacy: play full buffer duration
         offset: 0,
         fadeIn: options.track.fadeIn,
         fadeOut: options.track.fadeOut,
         gain: 1
       }
     ] : []);
-    this.clips = clipInfos.map((clipInfo) => {
-      const player = new import_tone.Player({
-        url: clipInfo.buffer,
-        loop: false,
-        onstop: () => {
-          this.activePlayers--;
-          if (this.activePlayers === 0 && this.onStopCallback) {
-            this.onStopCallback();
-          }
+    const transport = (0, import_tone.getTransport)();
+    const rawContext = (0, import_tone.getContext)().rawContext;
+    const volumeNativeInput = this.volumeNode.input.input;
+    this.scheduledClips = clipInfos.map((clipInfo) => {
+      const fadeGainNode = rawContext.createGain();
+      fadeGainNode.gain.value = clipInfo.gain;
+      fadeGainNode.connect(volumeNativeInput);
+      const absTransportTime = this.track.startTime + clipInfo.startTime;
+      const scheduleId = transport.schedule((audioContextTime) => {
+        if (absTransportTime < this._scheduleGuardOffset) {
+          return;
         }
-      });
-      const fadeGain = new import_tone.Gain(clipInfo.gain);
-      player.connect(fadeGain);
-      fadeGain.chain(this.volumeNode, this.panNode, this.muteGain);
-      return {
-        player,
-        clipInfo,
-        fadeGain,
-        pausedPosition: 0,
-        playStartTime: 0
-      };
+        this.startClipSource(clipInfo, fadeGainNode, audioContextTime);
+      }, absTransportTime);
+      return { clipInfo, fadeGainNode, scheduleId };
     });
   }
   /**
-   * Schedule fade envelopes for a clip at the given start time
+   * Create and start an AudioBufferSourceNode for a clip.
+   * Sources are one-shot: each play or loop iteration creates a fresh one.
    */
-  scheduleFades(clipPlayer, clipStartTime2, clipOffset = 0) {
-    const { clipInfo, fadeGain } = clipPlayer;
-    const audioParam = getUnderlyingAudioParam(fadeGain.gain);
-    if (!audioParam) return;
+  startClipSource(clipInfo, fadeGainNode, audioContextTime, bufferOffset, playDuration) {
+    const rawContext = (0, import_tone.getContext)().rawContext;
+    const source = rawContext.createBufferSource();
+    source.buffer = clipInfo.buffer;
+    source.connect(fadeGainNode);
+    const offset = bufferOffset ?? clipInfo.offset;
+    const duration = playDuration ?? clipInfo.duration;
+    try {
+      source.start(audioContextTime, offset, duration);
+    } catch (err) {
+      console.warn(
+        `[waveform-playlist] Failed to start source on track "${this.id}" (time=${audioContextTime}, offset=${offset}, duration=${duration}):`,
+        err
+      );
+      source.disconnect();
+      return;
+    }
+    this.activeSources.add(source);
+    source.onended = () => {
+      this.activeSources.delete(source);
+    };
+  }
+  /**
+   * Set the schedule guard offset. Schedule callbacks for clips before this
+   * offset are suppressed (already handled by startMidClipSources).
+   * Must be called before transport.start() and in the loop handler.
+   */
+  setScheduleGuardOffset(offset) {
+    this._scheduleGuardOffset = offset;
+  }
+  /**
+   * Start sources for clips that span the given Transport position.
+   * Used for mid-playback seeking and loop boundary handling where
+   * Transport.schedule() callbacks have already passed.
+   *
+   * Uses strict < for absClipStart to avoid double-creation with
+   * schedule callbacks at exact Transport position (e.g., loopStart).
+   */
+  startMidClipSources(transportOffset, audioContextTime) {
+    for (const { clipInfo, fadeGainNode } of this.scheduledClips) {
+      const absClipStart = this.track.startTime + clipInfo.startTime;
+      const absClipEnd = absClipStart + clipInfo.duration;
+      if (absClipStart < transportOffset && absClipEnd > transportOffset) {
+        const elapsed = transportOffset - absClipStart;
+        const adjustedOffset = clipInfo.offset + elapsed;
+        const remainingDuration = clipInfo.duration - elapsed;
+        this.startClipSource(
+          clipInfo,
+          fadeGainNode,
+          audioContextTime,
+          adjustedOffset,
+          remainingDuration
+        );
+      }
+    }
+  }
+  /**
+   * Stop all active AudioBufferSourceNodes and clear the set.
+   * Native AudioBufferSourceNodes ignore Transport state changes —
+   * they must be explicitly stopped.
+   */
+  stopAllSources() {
+    this.activeSources.forEach((source) => {
+      try {
+        source.stop();
+      } catch (err) {
+        console.warn(`[waveform-playlist] Error stopping source on track "${this.id}":`, err);
+      }
+    });
+    this.activeSources.clear();
+  }
+  /**
+   * Schedule fade envelopes for a clip at the given AudioContext time.
+   * Uses native GainNode.gain (AudioParam) directly — no _param workaround needed.
+   */
+  scheduleFades(scheduled, clipStartTime2, clipOffset = 0) {
+    const { clipInfo, fadeGainNode } = scheduled;
+    const audioParam = fadeGainNode.gain;
     audioParam.cancelScheduledValues(0);
     const skipTime = clipOffset - clipInfo.offset;
     if (clipInfo.fadeIn && skipTime < clipInfo.fadeIn.duration) {
@@ -262,6 +336,35 @@ var ToneTrack = class {
       }
     }
   }
+  /**
+   * Prepare fade envelopes for all clips based on Transport offset.
+   * Called before Transport.start() to schedule fades at correct AudioContext times.
+   */
+  prepareFades(when, transportOffset) {
+    this.scheduledClips.forEach((scheduled) => {
+      const absClipStart = this.track.startTime + scheduled.clipInfo.startTime;
+      const absClipEnd = absClipStart + scheduled.clipInfo.duration;
+      if (transportOffset >= absClipEnd) return;
+      if (transportOffset >= absClipStart) {
+        const clipOffset = transportOffset - absClipStart + scheduled.clipInfo.offset;
+        this.scheduleFades(scheduled, when, clipOffset);
+      } else {
+        const delay = absClipStart - transportOffset;
+        this.scheduleFades(scheduled, when + delay, scheduled.clipInfo.offset);
+      }
+    });
+  }
+  /**
+   * Cancel all scheduled fade automation and reset to nominal gain.
+   * Called on pause/stop to prevent stale fade envelopes.
+   */
+  cancelFades() {
+    this.scheduledClips.forEach(({ fadeGainNode, clipInfo }) => {
+      const audioParam = fadeGainNode.gain;
+      audioParam.cancelScheduledValues(0);
+      audioParam.setValueAtTime(clipInfo.gain, 0);
+    });
+  }
   gainToDb(gain) {
     return 20 * Math.log10(gain);
   }
@@ -283,99 +386,60 @@ var ToneTrack = class {
   setSolo(soloed) {
     this.track.soloed = soloed;
   }
-  play(when, offset = 0, duration) {
-    this.clips.forEach((clipPlayer) => {
-      clipPlayer.player.stop();
-      clipPlayer.player.disconnect();
-      clipPlayer.player.dispose();
-      const newPlayer = new import_tone.Player({
-        url: clipPlayer.clipInfo.buffer,
-        loop: false,
-        onstop: () => {
-          this.activePlayers--;
-          if (this.activePlayers === 0 && this.onStopCallback) {
-            this.onStopCallback();
-          }
-        }
-      });
-      newPlayer.connect(clipPlayer.fadeGain);
-      clipPlayer.player = newPlayer;
-      clipPlayer.pausedPosition = 0;
-    });
-    this.activePlayers = 0;
-    this.clips.forEach((clipPlayer) => {
-      const { player, clipInfo } = clipPlayer;
-      const playbackPosition = offset;
-      const clipStart = clipInfo.startTime;
-      const clipEnd = clipInfo.startTime + clipInfo.duration;
-      if (playbackPosition < clipEnd) {
-        this.activePlayers++;
-        const currentTime = when ?? (0, import_tone.now)();
-        clipPlayer.playStartTime = currentTime;
-        if (playbackPosition >= clipStart) {
-          const clipOffset = playbackPosition - clipStart + clipInfo.offset;
-          const remainingDuration = clipInfo.duration - (playbackPosition - clipStart);
-          const clipDuration = duration ? Math.min(duration, remainingDuration) : remainingDuration;
-          clipPlayer.pausedPosition = clipOffset;
-          this.scheduleFades(clipPlayer, currentTime, clipOffset);
-          player.start(currentTime, clipOffset, clipDuration);
-        } else {
-          const delay = clipStart - playbackPosition;
-          const clipDuration = duration ? Math.min(duration - delay, clipInfo.duration) : clipInfo.duration;
-          if (delay < (duration ?? Infinity)) {
-            clipPlayer.pausedPosition = clipInfo.offset;
-            this.scheduleFades(clipPlayer, currentTime + delay, clipInfo.offset);
-            player.start(currentTime + delay, clipInfo.offset, clipDuration);
-          } else {
-            this.activePlayers--;
-          }
-        }
-      }
-    });
-  }
-  pause() {
-    this.clips.forEach((clipPlayer) => {
-      if (clipPlayer.player.state === "started") {
-        const elapsed = ((0, import_tone.now)() - clipPlayer.playStartTime) * clipPlayer.player.playbackRate;
-        clipPlayer.pausedPosition = clipPlayer.pausedPosition + elapsed;
-      }
-      clipPlayer.player.stop();
-    });
-    this.activePlayers = 0;
-  }
-  stop(when) {
-    const stopWhen = when ?? (0, import_tone.now)();
-    this.clips.forEach((clipPlayer) => {
-      clipPlayer.player.stop(stopWhen);
-      clipPlayer.pausedPosition = 0;
-    });
-    this.activePlayers = 0;
-  }
   dispose() {
+    const transport = (0, import_tone.getTransport)();
     if (this.effectsCleanup) {
-      this.effectsCleanup();
+      try {
+        this.effectsCleanup();
+      } catch (err) {
+        console.warn(`[waveform-playlist] Error during track "${this.id}" effects cleanup:`, err);
+      }
     }
-    this.clips.forEach((clipPlayer) => {
-      clipPlayer.player.dispose();
-      clipPlayer.fadeGain.dispose();
+    this.stopAllSources();
+    this.scheduledClips.forEach((scheduled, index) => {
+      try {
+        transport.clear(scheduled.scheduleId);
+      } catch (err) {
+        console.warn(
+          `[waveform-playlist] Error clearing schedule ${index} on track "${this.id}":`,
+          err
+        );
+      }
+      try {
+        scheduled.fadeGainNode.disconnect();
+      } catch (err) {
+        console.warn(
+          `[waveform-playlist] Error disconnecting fadeGain ${index} on track "${this.id}":`,
+          err
+        );
+      }
     });
-    this.volumeNode.dispose();
-    this.panNode.dispose();
-    this.muteGain.dispose();
+    try {
+      this.volumeNode.dispose();
+    } catch (err) {
+      console.warn(`[waveform-playlist] Error disposing volumeNode on track "${this.id}":`, err);
+    }
+    try {
+      this.panNode.dispose();
+    } catch (err) {
+      console.warn(`[waveform-playlist] Error disposing panNode on track "${this.id}":`, err);
+    }
+    try {
+      this.muteGain.dispose();
+    } catch (err) {
+      console.warn(`[waveform-playlist] Error disposing muteGain on track "${this.id}":`, err);
+    }
   }
   get id() {
     return this.track.id;
   }
   get duration() {
-    if (this.clips.length === 0) return 0;
-    const lastClip = this.clips[this.clips.length - 1];
+    if (this.scheduledClips.length === 0) return 0;
+    const lastClip = this.scheduledClips[this.scheduledClips.length - 1];
     return lastClip.clipInfo.startTime + lastClip.clipInfo.duration;
   }
   get buffer() {
-    return this.clips[0]?.clipInfo.buffer;
-  }
-  get isPlaying() {
-    return this.clips.some((clipPlayer) => clipPlayer.player.state === "started");
+    return this.scheduledClips[0]?.clipInfo.buffer;
   }
   get muted() {
     return this.track.muted;
@@ -383,9 +447,6 @@ var ToneTrack = class {
   get startTime() {
     return this.track.startTime;
   }
-  setOnStopCallback(callback) {
-    this.onStopCallback = callback;
-  }
 };
 
 // src/TonePlayout.ts
@@ -395,9 +456,11 @@ var TonePlayout = class {
     this.isInitialized = false;
     this.soloedTracks = /* @__PURE__ */ new Set();
     this.manualMuteState = /* @__PURE__ */ new Map();
-    this.activeTracks = /* @__PURE__ */ new Map();
-    // Map track ID to session ID
-    this.playbackSessionId = 0;
+    this._completionEventId = null;
+    this._loopHandler = null;
+    this._loopEnabled = false;
+    this._loopStart = 0;
+    this._loopEnd = 0;
     this.masterVolume = new import_tone2.Volume(this.gainToDb(options.masterGain ?? 1));
     if (options.effects) {
       const cleanup = options.effects(this.masterVolume, (0, import_tone2.getDestination)(), false);
@@ -417,6 +480,16 @@ var TonePlayout = class {
   gainToDb(gain) {
     return 20 * Math.log10(gain);
   }
+  clearCompletionEvent() {
+    if (this._completionEventId !== null) {
+      try {
+        (0, import_tone2.getTransport)().clear(this._completionEventId);
+      } catch (err) {
+        console.warn("[waveform-playlist] Error clearing Transport completion event:", err);
+      }
+      this._completionEventId = null;
+    }
+  }
   async init() {
     if (this.isInitialized) return;
     await (0, import_tone2.start)();
@@ -456,63 +529,75 @@ var TonePlayout = class {
   }
   play(when, offset, duration) {
     if (!this.isInitialized) {
-      console.warn("TonePlayout not initialized. Call init() first.");
-      return;
+      throw new Error("[waveform-playlist] TonePlayout not initialized. Call init() first.");
     }
     const startTime = when ?? (0, import_tone2.now)();
-    const playbackPosition = offset ?? 0;
-    this.playbackSessionId++;
-    const currentSessionId = this.playbackSessionId;
-    this.activeTracks.clear();
-    this.tracks.forEach((toneTrack) => {
-      const trackStartTime = toneTrack.startTime;
-      if (playbackPosition >= trackStartTime) {
-        const bufferOffset = playbackPosition - trackStartTime;
-        if (duration !== void 0) {
-          this.activeTracks.set(toneTrack.id, currentSessionId);
-          toneTrack.setOnStopCallback(() => {
-            if (this.activeTracks.get(toneTrack.id) === currentSessionId) {
-              this.activeTracks.delete(toneTrack.id);
-              if (this.activeTracks.size === 0 && this.onPlaybackCompleteCallback) {
-                this.onPlaybackCompleteCallback();
-              }
-            }
-          });
+    const transport = (0, import_tone2.getTransport)();
+    this.clearCompletionEvent();
+    const transportOffset = offset ?? 0;
+    this.tracks.forEach((track) => {
+      track.cancelFades();
+      track.prepareFades(startTime, transportOffset);
+    });
+    if (duration !== void 0) {
+      this._completionEventId = transport.scheduleOnce(() => {
+        this._completionEventId = null;
+        try {
+          this.onPlaybackCompleteCallback?.();
+        } catch (err) {
+          console.warn("[waveform-playlist] Error in playback completion callback:", err);
         }
-        toneTrack.play(startTime, bufferOffset, duration);
+      }, transportOffset + duration);
+    }
+    try {
+      if (transport.state !== "stopped") {
+        transport.stop();
+      }
+      this.tracks.forEach((track) => track.stopAllSources());
+      transport.loopStart = this._loopStart;
+      transport.loopEnd = this._loopEnd;
+      transport.loop = this._loopEnabled;
+      this.tracks.forEach((track) => track.setScheduleGuardOffset(transportOffset));
+      if (offset !== void 0) {
+        transport.start(startTime, offset);
       } else {
-        const delay = trackStartTime - playbackPosition;
-        if (duration !== void 0) {
-          this.activeTracks.set(toneTrack.id, currentSessionId);
-          toneTrack.setOnStopCallback(() => {
-            if (this.activeTracks.get(toneTrack.id) === currentSessionId) {
-              this.activeTracks.delete(toneTrack.id);
-              if (this.activeTracks.size === 0 && this.onPlaybackCompleteCallback) {
-                this.onPlaybackCompleteCallback();
-              }
-            }
-          });
-        }
-        toneTrack.play(startTime + delay, 0, duration);
+        transport.start(startTime);
       }
-    });
-    if (offset !== void 0) {
-      (0, import_tone2.getTransport)().start(startTime, offset);
-    } else {
-      (0, import_tone2.getTransport)().start(startTime);
+      transport._clock._lastUpdate = startTime;
+      this.tracks.forEach((track) => {
+        track.startMidClipSources(transportOffset, startTime);
+      });
+    } catch (err) {
+      this.clearCompletionEvent();
+      this.tracks.forEach((track) => track.cancelFades());
+      console.warn(
+        "[waveform-playlist] Transport.start() failed. Audio playback could not begin.",
+        err
+      );
+      throw err;
     }
   }
   pause() {
-    (0, import_tone2.getTransport)().pause();
-    this.tracks.forEach((track) => {
-      track.pause();
-    });
+    const transport = (0, import_tone2.getTransport)();
+    try {
+      transport.pause();
+    } catch (err) {
+      console.warn("[waveform-playlist] Transport.pause() failed:", err);
+    }
+    this.tracks.forEach((track) => track.stopAllSources());
+    this.tracks.forEach((track) => track.cancelFades());
+    this.clearCompletionEvent();
   }
   stop() {
-    (0, import_tone2.getTransport)().stop();
-    this.tracks.forEach((track) => {
-      track.stop();
-    });
+    const transport = (0, import_tone2.getTransport)();
+    try {
+      transport.stop();
+    } catch (err) {
+      console.warn("[waveform-playlist] Transport.stop() failed:", err);
+    }
+    this.tracks.forEach((track) => track.stopAllSources());
+    this.tracks.forEach((track) => track.cancelFades());
+    this.clearCompletionEvent();
   }
   setMasterGain(gain) {
     this.masterVolume.volume.value = this.gainToDb(gain);
@@ -552,6 +637,43 @@ var TonePlayout = class {
       track.setMute(muted);
     }
   }
+  setLoop(enabled, loopStart, loopEnd) {
+    this._loopEnabled = enabled;
+    this._loopStart = loopStart;
+    this._loopEnd = loopEnd;
+    const transport = (0, import_tone2.getTransport)();
+    try {
+      transport.loopStart = loopStart;
+      transport.loopEnd = loopEnd;
+      transport.loop = enabled;
+    } catch (err) {
+      console.warn("[waveform-playlist] Error configuring Transport loop:", err);
+      return;
+    }
+    if (enabled && !this._loopHandler) {
+      this._loopHandler = () => {
+        const currentTime = (0, import_tone2.now)();
+        this.tracks.forEach((track) => {
+          try {
+            track.stopAllSources();
+            track.cancelFades();
+            track.setScheduleGuardOffset(this._loopStart);
+            track.startMidClipSources(this._loopStart, currentTime);
+            track.prepareFades(currentTime, this._loopStart);
+          } catch (err) {
+            console.warn(
+              `[waveform-playlist] Error re-scheduling track "${track.id}" on loop:`,
+              err
+            );
+          }
+        });
+      };
+      transport.on("loop", this._loopHandler);
+    } else if (!enabled && this._loopHandler) {
+      transport.off("loop", this._loopHandler);
+      this._loopHandler = null;
+    }
+  }
   getCurrentTime() {
     return (0, import_tone2.getTransport)().seconds;
   }
@@ -559,14 +681,35 @@ var TonePlayout = class {
     (0, import_tone2.getTransport)().seconds = time;
   }
   dispose() {
+    this.clearCompletionEvent();
+    if (this._loopHandler) {
+      try {
+        (0, import_tone2.getTransport)().off("loop", this._loopHandler);
+      } catch (err) {
+        console.warn("[waveform-playlist] Error removing Transport loop handler:", err);
+      }
+      this._loopHandler = null;
+    }
     this.tracks.forEach((track) => {
-      track.dispose();
+      try {
+        track.dispose();
+      } catch (err) {
+        console.warn(`[waveform-playlist] Error disposing track "${track.id}":`, err);
+      }
     });
     this.tracks.clear();
     if (this.effectsCleanup) {
-      this.effectsCleanup();
+      try {
+        this.effectsCleanup();
+      } catch (err) {
+        console.warn("[waveform-playlist] Error during master effects cleanup:", err);
+      }
+    }
+    try {
+      this.masterVolume.dispose();
+    } catch (err) {
+      console.warn("[waveform-playlist] Error disposing master volume:", err);
     }
-    this.masterVolume.dispose();
   }
   get context() {
     return (0, import_tone2.getContext)();
@@ -651,15 +794,33 @@ function createToneAdapter(options) {
   let playout = null;
   let _isPlaying = false;
   let _playoutGeneration = 0;
+  let _loopEnabled = false;
+  let _loopStart = 0;
+  let _loopEnd = 0;
+  let _audioInitialized = false;
   function buildPlayout(tracks) {
     if (playout) {
-      playout.dispose();
+      try {
+        playout.dispose();
+      } catch (err) {
+        console.warn("[waveform-playlist] Error disposing previous playout during rebuild:", err);
+      }
+      playout = null;
     }
     _playoutGeneration++;
     const generation = _playoutGeneration;
     playout = new TonePlayout({
       effects: options?.effects
     });
+    if (_audioInitialized) {
+      playout.init().catch((err) => {
+        console.warn(
+          "[waveform-playlist] Failed to re-initialize playout after rebuild. Audio playback will require another user gesture.",
+          err
+        );
+        _audioInitialized = false;
+      });
+    }
     for (const track of tracks) {
       const playableClips = track.clips.filter((c) => c.audioBuffer);
       if (playableClips.length === 0) continue;
@@ -691,6 +852,7 @@ function createToneAdapter(options) {
       });
     }
     playout.applyInitialSoloState();
+    playout.setLoop(_loopEnabled, _loopStart, _loopEnd);
     playout.setOnPlaybackComplete(() => {
       if (generation === _playoutGeneration) {
         _isPlaying = false;
@@ -701,14 +863,19 @@ function createToneAdapter(options) {
     async init() {
       if (playout) {
         await playout.init();
+        _audioInitialized = true;
       }
     },
     setTracks(tracks) {
       buildPlayout(tracks);
     },
-    async play(startTime, endTime) {
-      if (!playout) return;
-      await playout.init();
+    play(startTime, endTime) {
+      if (!playout) {
+        console.warn(
+          "[waveform-playlist] adapter.play() called but no playout is available. Tracks may not have been set, or the adapter was disposed."
+        );
+        return;
+      }
       const duration = endTime !== void 0 ? endTime - startTime : void 0;
       playout.play((0, import_tone5.now)(), startTime, duration);
       _isPlaying = true;
@@ -745,8 +912,18 @@ function createToneAdapter(options) {
     setTrackPan(trackId, pan) {
       playout?.getTrack(trackId)?.setPan(pan);
     },
+    setLoop(enabled, start2, end) {
+      _loopEnabled = enabled;
+      _loopStart = start2;
+      _loopEnd = end;
+      playout?.setLoop(enabled, start2, end);
+    },
     dispose() {
-      playout?.dispose();
+      try {
+        playout?.dispose();
+      } catch (err) {
+        console.warn("[waveform-playlist] Error disposing playout:", err);
+      }
       playout = null;
       _isPlaying = false;
     }