@waveform-playlist/playout 7.1.3 → 8.1.0

package/dist/index.mjs

@@ -3,13 +3,20 @@ import {
   Volume as Volume2,
   getDestination as getDestination2,
   start,
-  now as now2,
-  getTransport,
-  getContext
+  now,
+  getTransport as getTransport2,
+  getContext as getContext2
 } from "tone";
 
 // src/ToneTrack.ts
-import { Player, Volume, Gain, Panner, getDestination, now } from "tone";
+import {
+  Volume,
+  Gain,
+  Panner,
+  getDestination,
+  getTransport,
+  getContext
+} from "tone";
 
 // src/fades.ts
 var hasWarned = false;
@@ -18,7 +25,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;
@@ -112,13 +119,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 Volume(this.gainToDb(options.track.gain));
     this.panNode = new Panner(options.track.stereoPan);
     this.muteGain = new Gain(options.track.muted ? 0 : 1);
+    this.volumeNode.chain(this.panNode, this.muteGain);
     const destination = options.destination || getDestination();
     if (options.effects) {
       const cleanup = options.effects(this.muteGain, destination, false);
@@ -132,45 +146,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 Player({
-        url: clipInfo.buffer,
-        loop: false,
-        onstop: () => {
-          this.activePlayers--;
-          if (this.activePlayers === 0 && this.onStopCallback) {
-            this.onStopCallback();
-          }
+    const transport = getTransport();
+    const rawContext = 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 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 };
+    });
+  }
+  /**
+   * Create and start an AudioBufferSourceNode for a clip.
+   * Sources are one-shot: each play or loop iteration creates a fresh one.
+   */
+  startClipSource(clipInfo, fadeGainNode, audioContextTime, bufferOffset, playDuration) {
+    const rawContext = 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 start time
+   * Schedule fade envelopes for a clip at the given AudioContext time.
+   * Uses native GainNode.gain (AudioParam) directly — no _param workaround needed.
    */
-  scheduleFades(clipPlayer, clipStartTime2, clipOffset = 0) {
-    const { clipInfo, fadeGain } = clipPlayer;
-    const audioParam = getUnderlyingAudioParam(fadeGain.gain);
-    if (!audioParam) return;
+  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) {
@@ -229,6 +310,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);
   }
@@ -250,99 +360,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 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 ?? 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 = (now() - clipPlayer.playStartTime) * clipPlayer.player.playbackRate;
-        clipPlayer.pausedPosition = clipPlayer.pausedPosition + elapsed;
-      }
-      clipPlayer.player.stop();
-    });
-    this.activePlayers = 0;
-  }
-  stop(when) {
-    const stopWhen = when ?? now();
-    this.clips.forEach((clipPlayer) => {
-      clipPlayer.player.stop(stopWhen);
-      clipPlayer.pausedPosition = 0;
-    });
-    this.activePlayers = 0;
-  }
   dispose() {
+    const transport = 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;
@@ -350,9 +421,6 @@ var ToneTrack = class {
   get startTime() {
     return this.track.startTime;
   }
-  setOnStopCallback(callback) {
-    this.onStopCallback = callback;
-  }
 };
 
 // src/TonePlayout.ts
@@ -362,9 +430,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 Volume2(this.gainToDb(options.masterGain ?? 1));
     if (options.effects) {
       const cleanup = options.effects(this.masterVolume, getDestination2(), false);
@@ -384,6 +454,16 @@ var TonePlayout = class {
   gainToDb(gain) {
     return 20 * Math.log10(gain);
   }
+  clearCompletionEvent() {
+    if (this._completionEventId !== null) {
+      try {
+        getTransport2().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 start();
@@ -423,63 +503,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 ?? now2();
-    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 startTime = when ?? now();
+    const transport = getTransport2();
+    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) {
-      getTransport().start(startTime, offset);
-    } else {
-      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() {
-    getTransport().pause();
-    this.tracks.forEach((track) => {
-      track.pause();
-    });
+    const transport = getTransport2();
+    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() {
-    getTransport().stop();
-    this.tracks.forEach((track) => {
-      track.stop();
-    });
+    const transport = getTransport2();
+    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);
@@ -519,27 +611,85 @@ var TonePlayout = class {
       track.setMute(muted);
     }
   }
+  setLoop(enabled, loopStart, loopEnd) {
+    this._loopEnabled = enabled;
+    this._loopStart = loopStart;
+    this._loopEnd = loopEnd;
+    const transport = getTransport2();
+    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 = 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 getTransport().seconds;
+    return getTransport2().seconds;
   }
   seekTo(time) {
-    getTransport().seconds = time;
+    getTransport2().seconds = time;
   }
   dispose() {
+    this.clearCompletionEvent();
+    if (this._loopHandler) {
+      try {
+        getTransport2().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 getContext();
+    return getContext2();
   }
   get sampleRate() {
-    return getContext().sampleRate;
+    return getContext2().sampleRate;
   }
   setOnPlaybackComplete(callback) {
     this.onPlaybackCompleteCallback = callback;
@@ -579,14 +729,14 @@ async function closeGlobalAudioContext() {
 }
 
 // src/mediaStreamSourceManager.ts
-import { getContext as getContext2 } from "tone";
+import { getContext as getContext3 } from "tone";
 var streamSources = /* @__PURE__ */ new Map();
 var streamCleanupHandlers = /* @__PURE__ */ new Map();
 function getMediaStreamSource(stream) {
   if (streamSources.has(stream)) {
     return streamSources.get(stream);
   }
-  const context = getContext2();
+  const context = getContext3();
   const source = context.createMediaStreamSource(stream);
   streamSources.set(stream, source);
   const cleanup = () => {
@@ -618,20 +768,38 @@ import {
   clipOffsetTime,
   clipDurationTime
 } from "@waveform-playlist/core";
-import { now as now3 } from "tone";
+import { now as now2 } from "tone";
 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;
@@ -663,6 +831,7 @@ function createToneAdapter(options) {
       });
     }
     playout.applyInitialSoloState();
+    playout.setLoop(_loopEnabled, _loopStart, _loopEnd);
     playout.setOnPlaybackComplete(() => {
       if (generation === _playoutGeneration) {
         _isPlaying = false;
@@ -673,16 +842,21 @@ 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(now3(), startTime, duration);
+      playout.play(now2(), startTime, duration);
       _isPlaying = true;
     },
     pause() {
@@ -717,8 +891,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;
     }