waa-play 0.1.1 → 0.2.1

package/dist/{chunk-TULV7V5M.cjs → chunk-G37HMZEX.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk5J7S6QV3_cjs = require('./chunk-5J7S6QV3.cjs');
+var chunkHIF3UAF3_cjs = require('./chunk-HIF3UAF3.cjs');
 
 // src/stretcher/constants.ts
 var CHUNK_DURATION_SEC = 8;
@@ -24,688 +24,393 @@ var WORKER_POOL_SIZE = 2;
 var MAX_WORKER_CRASHES = 3;
 var MAX_CHUNK_RETRIES = 3;
 var LOOKAHEAD_INTERVAL_MS = 200;
-var LOOKAHEAD_THRESHOLD_SEC = 1.5;
+var LOOKAHEAD_THRESHOLD_SEC = 3;
+var PROACTIVE_SCHEDULE_THRESHOLD_SEC = 5;
 
-// src/stretcher/chunk-splitter.ts
-function splitIntoChunks(totalSamples, sampleRate, chunkDurationSec = CHUNK_DURATION_SEC, overlapSec = OVERLAP_SEC) {
-  if (totalSamples <= 0 || sampleRate <= 0) {
-    return [];
+// src/stretcher/buffer-monitor.ts
+function createBufferMonitor(options) {
+  const healthySec = BUFFER_HEALTHY_SEC;
+  const lowSec = BUFFER_LOW_SEC;
+  const criticalSec = BUFFER_CRITICAL_SEC;
+  const resumeSec = BUFFER_RESUME_SEC;
+  const chunkDurSec = CHUNK_DURATION_SEC;
+  function getAheadSeconds(currentChunkIndex, chunks) {
+    let aheadSec = 0;
+    for (let i = currentChunkIndex; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      if (!chunk || chunk.state !== "ready") break;
+      aheadSec += chunkDurSec;
+    }
+    return aheadSec;
   }
-  const chunkSamples = Math.round(chunkDurationSec * sampleRate);
-  const overlapSamples = Math.round(overlapSec * sampleRate);
-  if (chunkSamples <= 0) {
-    return [];
+  function getHealth(currentChunkIndex, chunks) {
+    const ahead = getAheadSeconds(currentChunkIndex, chunks);
+    if (ahead >= healthySec) return "healthy";
+    if (ahead >= lowSec) return "low";
+    if (ahead >= criticalSec) return "critical";
+    return "empty";
   }
-  if (totalSamples <= chunkSamples) {
-    return [
-      {
-        index: 0,
-        state: "pending",
-        inputStartSample: 0,
-        inputEndSample: totalSamples,
-        overlapBefore: 0,
-        overlapAfter: 0,
-        outputBuffer: null,
-        outputLength: 0,
-        priority: 0,
-        retryCount: 0
-      }
-    ];
+  function shouldEnterBuffering(currentChunkIndex, chunks) {
+    const ahead = getAheadSeconds(currentChunkIndex, chunks);
+    if (ahead >= criticalSec) return false;
+    const nextChunk = chunks[currentChunkIndex + 1];
+    if (nextChunk && nextChunk.state === "ready") return false;
+    const currentChunk = chunks[currentChunkIndex];
+    if (!currentChunk || currentChunk.state !== "ready") return true;
+    return ahead < criticalSec;
   }
-  const chunks = [];
-  let start = 0;
-  let index = 0;
-  while (start < totalSamples) {
-    const isFirst = index === 0;
-    const nominalEnd = Math.min(start + chunkSamples, totalSamples);
-    const isLast = nominalEnd >= totalSamples;
-    const overlapBefore = isFirst ? 0 : Math.min(overlapSamples, start);
-    const overlapAfter = isLast ? 0 : Math.min(overlapSamples, totalSamples - nominalEnd);
-    const inputStart = start - overlapBefore;
-    const inputEnd = Math.min(nominalEnd + overlapAfter, totalSamples);
-    chunks.push({
-      index,
-      state: "pending",
-      inputStartSample: inputStart,
-      inputEndSample: inputEnd,
-      overlapBefore,
-      overlapAfter,
-      outputBuffer: null,
-      outputLength: 0,
-      priority: 0,
-      retryCount: 0
-    });
-    start = nominalEnd;
-    index++;
+  function shouldExitBuffering(currentChunkIndex, chunks) {
+    const currentChunk = chunks[currentChunkIndex];
+    if (!currentChunk || currentChunk.state !== "ready") return false;
+    const ahead = getAheadSeconds(currentChunkIndex, chunks);
+    if (ahead >= resumeSec) return true;
+    const nextChunk = chunks[currentChunkIndex + 1];
+    if (nextChunk && nextChunk.state === "ready") return true;
+    const allReady = chunks.every((c) => c.state === "ready" || c.state === "skipped");
+    if (allReady) return true;
+    return false;
   }
-  return chunks;
+  return {
+    getHealth,
+    getAheadSeconds,
+    shouldEnterBuffering,
+    shouldExitBuffering
+  };
 }
-function extractChunkData(buffer, chunk) {
-  const channels = [];
-  const length = chunk.inputEndSample - chunk.inputStartSample;
-  for (let ch = 0; ch < buffer.numberOfChannels; ch++) {
-    const fullChannel = buffer.getChannelData(ch);
-    const chunkData = new Float32Array(length);
-    chunkData.set(
-      fullChannel.subarray(chunk.inputStartSample, chunk.inputEndSample)
-    );
-    channels.push(chunkData);
+
+// src/stretcher/transition-timing.ts
+var TRANSITION_MARGIN_MS = 50;
+function calcTransitionDelay(startTime, currentTime) {
+  return Math.max(0, (startTime - currentTime) * 1e3 + TRANSITION_MARGIN_MS);
+}
+
+// src/stretcher/chunk-player.ts
+var CURVE_LENGTH = 256;
+function createEqualPowerCurve(fadeIn) {
+  const curve = new Float32Array(CURVE_LENGTH);
+  for (let i = 0; i < CURVE_LENGTH; i++) {
+    const t = i / (CURVE_LENGTH - 1);
+    curve[i] = fadeIn ? Math.sin(t * Math.PI / 2) : Math.cos(t * Math.PI / 2);
   }
-  return channels;
+  return curve;
 }
-function getChunkIndexForSample(chunks, sample) {
-  for (let i = 0; i < chunks.length; i++) {
-    const chunk = chunks[i];
-    const nominalStart = chunk.inputStartSample + chunk.overlapBefore;
-    const nominalEnd = chunk.inputEndSample - chunk.overlapAfter;
-    if (sample >= nominalStart && sample < nominalEnd) {
-      return i;
+var fadeInCurve = createEqualPowerCurve(true);
+var fadeOutCurve = createEqualPowerCurve(false);
+function createChunkPlayer(ctx, options) {
+  const destination = options.destination ?? ctx.destination;
+  const through = options.through ?? [];
+  const crossfadeSec = options.crossfadeSec ?? CROSSFADE_SEC;
+  let currentSource = null;
+  let nextSource = null;
+  let currentGain = null;
+  let nextGain = null;
+  let playStartCtxTime = 0;
+  let playStartOffset = 0;
+  let currentChunkDuration = 0;
+  let nextStartCtxTime = 0;
+  let paused = false;
+  let pausedPosition = 0;
+  let stopped = true;
+  let lookaheadTimer = null;
+  let transitionTimerId = null;
+  let onChunkEnded = null;
+  let onNeedNext = null;
+  let onTransition = null;
+  let disposed = false;
+  function connectToDestination(node) {
+    if (through.length > 0) {
+      node.connect(through[0]);
+      for (let i = 0; i < through.length - 1; i++) {
+        through[i].connect(through[i + 1]);
+      }
+      through[through.length - 1].connect(destination);
+    } else {
+      node.connect(destination);
     }
   }
-  return Math.max(0, chunks.length - 1);
-}
-function getChunkIndexForTime(chunks, timeSeconds, sampleRate) {
-  const sample = Math.round(timeSeconds * sampleRate);
-  return getChunkIndexForSample(chunks, sample);
-}
-
-// src/stretcher/worker-inline.ts
-function getWorkerCode() {
-  return `"use strict";
-
-var FRAME_SIZE = ${WSOLA_FRAME_SIZE};
-var HOP_SIZE = ${WSOLA_HOP_SIZE};
-var TOLERANCE = ${WSOLA_TOLERANCE};
-
-function createHannWindow(size) {
-  var w = new Float32Array(size);
-  for (var i = 0; i < size; i++) {
-    w[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (size - 1)));
+  function createSourceFromBuffer(buffer, gain) {
+    const src = ctx.createBufferSource();
+    src.buffer = buffer;
+    src.connect(gain);
+    connectToDestination(gain);
+    return src;
   }
-  return w;
-}
-
-function findBestOffset(ref, search, overlapSize, maxOffset) {
-  var bestOffset = 0;
-  var bestCorr = -Infinity;
-  var searchLen = search.length;
-  var refLen = ref.length;
-  var len = Math.min(overlapSize, refLen);
-
-  for (var offset = 0; offset <= maxOffset; offset++) {
-    if (offset + len > searchLen) break;
-    var corr = 0;
-    var normRef = 0;
-    var normSearch = 0;
-    for (var i = 0; i < len; i++) {
-      var r = ref[i];
-      var s = search[offset + i];
-      corr += r * s;
-      normRef += r * r;
-      normSearch += s * s;
+  function stopCurrentSource() {
+    if (currentSource) {
+      currentSource.onended = null;
+      try {
+        currentSource.stop();
+      } catch {
+      }
+      currentSource.disconnect();
+      currentSource = null;
     }
-    var denom = Math.sqrt(normRef * normSearch);
-    var ncc = denom > 1e-10 ? corr / denom : 0;
-    if (ncc > bestCorr) {
-      bestCorr = ncc;
-      bestOffset = offset;
+    if (currentGain) {
+      currentGain.disconnect();
+      currentGain = null;
     }
   }
-  return bestOffset;
-}
-
-function wsolaTimeStretch(channels, tempo, sampleRate) {
-  if (channels.length === 0) {
-    return { output: [], length: 0 };
+  function stopNextSource() {
+    if (nextSource) {
+      nextSource.onended = null;
+      try {
+        nextSource.stop();
+      } catch {
+      }
+      nextSource.disconnect();
+      nextSource = null;
+    }
+    if (nextGain) {
+      nextGain.disconnect();
+      nextGain = null;
+    }
   }
-
-  var inputLength = channels[0].length;
-  if (inputLength === 0) {
-    return { output: channels.map(function() { return new Float32Array(0); }), length: 0 };
+  function startLookahead() {
+    if (lookaheadTimer !== null) return;
+    lookaheadTimer = setInterval(() => {
+      if (paused || stopped || disposed) return;
+      const pos = getElapsedInChunk();
+      const remaining = currentChunkDuration - pos;
+      if (remaining <= LOOKAHEAD_THRESHOLD_SEC && !nextSource) {
+        onNeedNext?.();
+      }
+    }, LOOKAHEAD_INTERVAL_MS);
   }
-
-  var synthesisHop = HOP_SIZE;
-  var analysisHop = Math.round(HOP_SIZE * tempo);
-  var numFrames = Math.floor((inputLength - FRAME_SIZE) / analysisHop) + 1;
-
-  if (numFrames <= 0) {
-    return {
-      output: channels.map(function(ch) { return new Float32Array(ch); }),
-      length: inputLength
-    };
-  }
-
-  var estimatedOutputLength = (numFrames - 1) * synthesisHop + FRAME_SIZE;
-  var outputChannels = channels.map(function() {
-    return new Float32Array(estimatedOutputLength);
-  });
-  var windowFunc = createHannWindow(FRAME_SIZE);
-  var normBuffer = new Float32Array(estimatedOutputLength);
-
-  var prevOutputFrame = channels.map(function() {
-    return new Float32Array(FRAME_SIZE);
-  });
-
-  var inputPos = 0;
-  var outputPos = 0;
-  var actualOutputLength = 0;
-
-  for (var frame = 0; frame < numFrames; frame++) {
-    if (cancelled) return null;
-    if (inputPos + FRAME_SIZE > inputLength) break;
-
-    var actualInputPos = inputPos;
-
-    if (frame > 0 && TOLERANCE > 0) {
-      var searchStart = Math.max(0, inputPos - TOLERANCE);
-      var searchEnd = Math.min(inputLength - FRAME_SIZE, inputPos + TOLERANCE);
-      var searchRange = searchEnd - searchStart;
-
-      if (searchRange > 0) {
-        var refChannel = prevOutputFrame[0];
-        var inputChannel = channels[0];
-
-        var overlapStart = FRAME_SIZE - synthesisHop;
-        var overlapSize = Math.min(synthesisHop, FRAME_SIZE - overlapStart);
-
-        var refSlice = refChannel.subarray(overlapStart, overlapStart + overlapSize);
-        var searchSlice = inputChannel.subarray(searchStart, searchEnd + overlapSize);
-
-        var bestOffset = findBestOffset(
-          refSlice, searchSlice, overlapSize,
-          Math.min(searchRange, searchSlice.length - overlapSize)
-        );
-
-        actualInputPos = searchStart + bestOffset;
-      }
+  function stopLookahead() {
+    if (lookaheadTimer !== null) {
+      clearInterval(lookaheadTimer);
+      lookaheadTimer = null;
     }
-
-    for (var ch = 0; ch < channels.length; ch++) {
-      var input = channels[ch];
-      var output = outputChannels[ch];
-      var prevFrame = prevOutputFrame[ch];
-      for (var i = 0; i < FRAME_SIZE; i++) {
-        var inIdx = actualInputPos + i;
-        if (inIdx >= inputLength) break;
-        var outIdx = outputPos + i;
-        if (outIdx >= estimatedOutputLength) break;
-        var sample = input[inIdx];
-        output[outIdx] += sample * windowFunc[i];
-        prevFrame[i] = sample;
-      }
+  }
+  function cancelTransition() {
+    if (transitionTimerId !== null) {
+      clearTimeout(transitionTimerId);
+      transitionTimerId = null;
     }
-
-    for (var i = 0; i < FRAME_SIZE; i++) {
-      var outIdx = outputPos + i;
-      if (outIdx >= estimatedOutputLength) break;
-      normBuffer[outIdx] += windowFunc[i];
+  }
+  function doTransition(buffer, startCtxTime) {
+    stopCurrentSource();
+    currentSource = nextSource;
+    currentGain = nextGain;
+    nextSource = null;
+    nextGain = null;
+    currentChunkDuration = buffer.duration;
+    playStartOffset = 0;
+    playStartCtxTime = startCtxTime;
+    if (currentSource) {
+      currentSource.onended = handleCurrentSourceEnded;
     }
-
-    inputPos += analysisHop;
-    outputPos += synthesisHop;
-    actualOutputLength = Math.min(outputPos + FRAME_SIZE, estimatedOutputLength);
+    onTransition?.();
   }
-
-  for (var ch = 0; ch < outputChannels.length; ch++) {
-    var output = outputChannels[ch];
-    for (var i = 0; i < actualOutputLength; i++) {
-      var norm = normBuffer[i];
-      if (norm > 1e-8) {
-        output[i] /= norm;
+  function handleCurrentSourceEnded() {
+    if (disposed || paused || stopped) return;
+    if (nextSource) {
+      const buf = nextSource.buffer;
+      if (!buf) {
+        onChunkEnded?.();
+        return;
       }
+      cancelTransition();
+      doTransition(buf, nextStartCtxTime);
+    } else {
+      onChunkEnded?.();
     }
   }
-
-  var trimmedOutput = outputChannels.map(function(ch) {
-    return ch.slice(0, actualOutputLength);
-  });
-
-  return { output: trimmedOutput, length: actualOutputLength };
-}
-
-var cancelled = false;
-
-self.onmessage = function(e) {
-  var msg = e.data;
-  if (msg.type === "cancel") {
-    cancelled = true;
-    return;
+  function getElapsedInChunk() {
+    if (paused) return pausedPosition;
+    if (stopped) return 0;
+    return ctx.currentTime - playStartCtxTime + playStartOffset;
   }
-  if (msg.type === "convert") {
-    cancelled = false;
-    try {
-      var result = wsolaTimeStretch(msg.inputData, msg.tempo, msg.sampleRate);
-      if (cancelled || result === null) {
-        self.postMessage({ type: "cancelled", chunkIndex: msg.chunkIndex });
-      } else {
-        self.postMessage(
-          { type: "result", chunkIndex: msg.chunkIndex, outputData: result.output, outputLength: result.length },
-          result.output.map(function(ch) { return ch.buffer; })
-        );
-      }
-    } catch (err) {
-      self.postMessage({ type: "error", chunkIndex: msg.chunkIndex, error: String(err) });
+  function playChunk(buffer, _startTime, offsetInChunk = 0, skipFadeIn = false) {
+    cancelTransition();
+    stopCurrentSource();
+    stopNextSource();
+    currentGain = ctx.createGain();
+    currentSource = createSourceFromBuffer(buffer, currentGain);
+    currentChunkDuration = buffer.duration;
+    playStartOffset = offsetInChunk;
+    playStartCtxTime = ctx.currentTime;
+    paused = false;
+    stopped = false;
+    currentSource.onended = handleCurrentSourceEnded;
+    currentSource.start(0, offsetInChunk);
+    if (crossfadeSec > 0 && !skipFadeIn) {
+      currentGain.gain.setValueCurveAtTime(fadeInCurve, ctx.currentTime, crossfadeSec);
     }
+    startLookahead();
   }
-};
-`;
-}
-function createWorkerURL() {
-  const code = getWorkerCode();
-  const blob = new Blob([code], { type: "application/javascript" });
-  return URL.createObjectURL(blob);
-}
-function revokeWorkerURL(url) {
-  URL.revokeObjectURL(url);
-}
-
-// src/stretcher/worker-manager.ts
-function createWorkerManager(onResult, onError, maxCrashes = MAX_WORKER_CRASHES, poolSize = WORKER_POOL_SIZE, onAllDead) {
-  let workerURL = null;
-  let terminated = false;
-  const postTimes = /* @__PURE__ */ new Map();
-  const slots = [];
-  function ensureWorkerURL() {
-    if (!workerURL) {
-      workerURL = createWorkerURL();
+  function scheduleNext(buffer, startTime) {
+    if (disposed) return;
+    stopNextSource();
+    nextGain = ctx.createGain();
+    nextSource = createSourceFromBuffer(buffer, nextGain);
+    nextSource.onended = handleCurrentSourceEnded;
+    nextStartCtxTime = startTime - crossfadeSec;
+    nextSource.start(nextStartCtxTime);
+    if (crossfadeSec > 0 && currentGain) {
+      currentGain.gain.setValueCurveAtTime(fadeOutCurve, nextStartCtxTime, crossfadeSec);
+      nextGain.gain.setValueCurveAtTime(fadeInCurve, nextStartCtxTime, crossfadeSec);
     }
-    return workerURL;
-  }
-  function isAllDead() {
-    return slots.every((s) => s.worker === null);
+    const transitionDelay = calcTransitionDelay(startTime, ctx.currentTime);
+    cancelTransition();
+    transitionTimerId = setTimeout(() => {
+      transitionTimerId = null;
+      if (disposed || !nextSource) return;
+      doTransition(buffer, nextStartCtxTime);
+    }, transitionDelay);
   }
-  function spawnWorkerForSlot(slot) {
-    if (terminated) return;
-    const url = ensureWorkerURL();
-    let worker;
-    try {
-      worker = new Worker(url);
-    } catch {
-      slot.worker = null;
-      return;
-    }
-    worker.onmessage = (e) => {
-      const response = e.data;
-      if (response.type === "result" || response.type === "cancelled") {
-        slot.busy = false;
-        slot.currentChunkIndex = null;
-      }
-      if (response.type === "error") {
-        slot.busy = false;
-        slot.currentChunkIndex = null;
-        onError(response);
-        return;
-      }
-      onResult(response);
-    };
-    worker.onerror = (e) => {
-      e.preventDefault();
-      slot.busy = false;
-      const failedChunkIndex = slot.currentChunkIndex;
-      slot.currentChunkIndex = null;
-      slot.crashCount++;
-      if (failedChunkIndex !== null) {
-        onError({
-          type: "error",
-          chunkIndex: failedChunkIndex,
-          error: `Worker crashed: ${e.message}`
-        });
-      }
-      if (slot.worker) {
-        slot.worker.onmessage = null;
-        slot.worker.onerror = null;
-        slot.worker.terminate();
-        slot.worker = null;
-      }
-      if (slot.crashCount < maxCrashes) {
-        spawnWorkerForSlot(slot);
-      } else {
-        onError({
-          type: "error",
-          chunkIndex: failedChunkIndex ?? -1,
-          error: `Worker crashed ${slot.crashCount} times, giving up`
-        });
-        if (isAllDead()) {
-          onAllDead?.();
-        }
-      }
-    };
-    slot.worker = worker;
+  function handleSeek(buffer, offsetInChunk) {
+    playChunk(buffer, 0, offsetInChunk);
   }
-  for (let i = 0; i < poolSize; i++) {
-    const slot = {
-      worker: null,
-      busy: false,
-      currentChunkIndex: null,
-      crashCount: 0
-    };
-    slots.push(slot);
-    spawnWorkerForSlot(slot);
+  function pause() {
+    if (paused || stopped || disposed) return;
+    pausedPosition = getElapsedInChunk();
+    paused = true;
+    cancelTransition();
+    stopCurrentSource();
+    stopNextSource();
+    stopLookahead();
   }
-  if (isAllDead()) {
-    onAllDead?.();
+  function resume() {
+    if (!paused || disposed) return;
   }
-  function findFreeSlot() {
-    for (const slot of slots) {
-      if (!slot.busy && slot.worker) {
-        return slot;
-      }
-    }
-    return null;
+  function stop() {
+    if (stopped || disposed) return;
+    stopped = true;
+    paused = false;
+    pausedPosition = 0;
+    cancelTransition();
+    stopCurrentSource();
+    stopNextSource();
+    stopLookahead();
   }
-  function findSlotByChunk(chunkIndex) {
-    for (const slot of slots) {
-      if (slot.busy && slot.currentChunkIndex === chunkIndex) {
-        return slot;
-      }
-    }
-    return null;
+  function getCurrentPosition() {
+    return getElapsedInChunk();
+  }
+  function hasNextScheduled() {
+    return nextSource !== null;
   }
   return {
-    postConvert(chunkIndex, inputData, tempo, sampleRate) {
-      if (terminated) return;
-      const slot = findFreeSlot();
-      if (!slot || !slot.worker) return;
-      slot.busy = true;
-      slot.currentChunkIndex = chunkIndex;
-      postTimes.set(chunkIndex, performance.now());
-      const transferables = inputData.map((ch) => ch.buffer);
-      slot.worker.postMessage(
-        { type: "convert", chunkIndex, inputData, tempo, sampleRate },
-        transferables
-      );
-    },
-    cancelCurrent() {
-      if (terminated) return;
-      for (const slot of slots) {
-        if (slot.busy && slot.worker && slot.currentChunkIndex !== null) {
-          slot.worker.postMessage({ type: "cancel", chunkIndex: slot.currentChunkIndex });
-        }
-      }
-    },
-    cancelChunk(chunkIndex) {
-      if (terminated) return;
-      const slot = findSlotByChunk(chunkIndex);
-      if (slot && slot.worker) {
-        slot.worker.postMessage({ type: "cancel", chunkIndex });
-      }
-    },
-    isBusy() {
-      return slots.every((s) => s.busy || !s.worker);
-    },
-    hasCapacity() {
-      return findFreeSlot() !== null;
-    },
-    getCurrentChunkIndex() {
-      for (const slot of slots) {
-        if (slot.busy && slot.currentChunkIndex !== null) {
-          return slot.currentChunkIndex;
-        }
-      }
-      return null;
+    playChunk,
+    scheduleNext,
+    hasNextScheduled,
+    handleSeek,
+    pause,
+    resume,
+    stop,
+    getCurrentPosition,
+    setOnChunkEnded(callback) {
+      onChunkEnded = callback;
     },
-    getLastPostTime() {
-      let latest = null;
-      for (const t of postTimes.values()) {
-        if (latest === null || t > latest) {
-          latest = t;
-        }
-      }
-      return latest;
+    setOnNeedNext(callback) {
+      onNeedNext = callback;
     },
-    getPostTimeForChunk(chunkIndex) {
-      return postTimes.get(chunkIndex) ?? null;
+    setOnTransition(callback) {
+      onTransition = callback;
     },
-    terminate() {
-      if (terminated) return;
-      terminated = true;
-      for (const slot of slots) {
-        if (slot.worker) {
-          slot.worker.onmessage = null;
-          slot.worker.onerror = null;
-          slot.worker.terminate();
-          slot.worker = null;
-        }
-      }
-      if (workerURL) {
-        revokeWorkerURL(workerURL);
-        workerURL = null;
-      }
-      postTimes.clear();
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      cancelTransition();
+      stopCurrentSource();
+      stopNextSource();
+      stopLookahead();
     }
   };
 }
 
-// src/stretcher/wsola.ts
-function createHannWindow(size) {
-  const window = new Float32Array(size);
-  for (let i = 0; i < size; i++) {
-    window[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (size - 1)));
+// src/stretcher/chunk-splitter.ts
+function splitIntoChunks(totalSamples, sampleRate, chunkDurationSec = CHUNK_DURATION_SEC, overlapSec = OVERLAP_SEC) {
+  if (totalSamples <= 0 || sampleRate <= 0) {
+    return [];
   }
-  return window;
+  const chunkSamples = Math.round(chunkDurationSec * sampleRate);
+  const overlapSamples = Math.round(overlapSec * sampleRate);
+  if (chunkSamples <= 0) {
+    return [];
+  }
+  if (totalSamples <= chunkSamples) {
+    return [
+      {
+        index: 0,
+        state: "pending",
+        inputStartSample: 0,
+        inputEndSample: totalSamples,
+        overlapBefore: 0,
+        overlapAfter: 0,
+        outputBuffer: null,
+        outputLength: 0,
+        priority: 0,
+        retryCount: 0
+      }
+    ];
+  }
+  const chunks = [];
+  let start = 0;
+  let index = 0;
+  while (start < totalSamples) {
+    const isFirst = index === 0;
+    const nominalEnd = Math.min(start + chunkSamples, totalSamples);
+    const isLast = nominalEnd >= totalSamples;
+    const overlapBefore = isFirst ? 0 : Math.min(overlapSamples, start);
+    const overlapAfter = isLast ? 0 : Math.min(overlapSamples, totalSamples - nominalEnd);
+    const inputStart = start - overlapBefore;
+    const inputEnd = Math.min(nominalEnd + overlapAfter, totalSamples);
+    chunks.push({
+      index,
+      state: "pending",
+      inputStartSample: inputStart,
+      inputEndSample: inputEnd,
+      overlapBefore,
+      overlapAfter,
+      outputBuffer: null,
+      outputLength: 0,
+      priority: 0,
+      retryCount: 0
+    });
+    start = nominalEnd;
+    index++;
+  }
+  return chunks;
 }
-function findBestOffset(ref, search, overlapSize, maxOffset) {
-  let bestOffset = 0;
-  let bestCorr = -Infinity;
-  const searchLen = search.length;
-  const refLen = ref.length;
-  const len = Math.min(overlapSize, refLen);
-  for (let offset = 0; offset <= maxOffset; offset++) {
-    if (offset + len > searchLen) break;
-    let corr = 0;
-    let normRef = 0;
-    let normSearch = 0;
-    for (let i = 0; i < len; i++) {
-      const r = ref[i];
-      const s = search[offset + i];
-      corr += r * s;
-      normRef += r * r;
-      normSearch += s * s;
-    }
-    const denom = Math.sqrt(normRef * normSearch);
-    const ncc = denom > 1e-10 ? corr / denom : 0;
-    if (ncc > bestCorr) {
-      bestCorr = ncc;
-      bestOffset = offset;
+function extractChunkData(buffer, chunk) {
+  const channels = [];
+  const length = chunk.inputEndSample - chunk.inputStartSample;
+  for (let ch = 0; ch < buffer.numberOfChannels; ch++) {
+    const fullChannel = buffer.getChannelData(ch);
+    const chunkData = new Float32Array(length);
+    chunkData.set(fullChannel.subarray(chunk.inputStartSample, chunk.inputEndSample));
+    channels.push(chunkData);
+  }
+  return channels;
+}
+function getChunkIndexForSample(chunks, sample) {
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    const nominalStart = chunk.inputStartSample + chunk.overlapBefore;
+    const nominalEnd = chunk.inputEndSample - chunk.overlapAfter;
+    if (sample >= nominalStart && sample < nominalEnd) {
+      return i;
     }
   }
-  return bestOffset;
+  return Math.max(0, chunks.length - 1);
 }
-function wsolaTimeStretch(channels, tempo, _sampleRate, frameSize = WSOLA_FRAME_SIZE, hopSize = WSOLA_HOP_SIZE, tolerance = WSOLA_TOLERANCE) {
-  if (channels.length === 0) {
-    return { output: [], length: 0 };
+function getChunkIndexForTime(chunks, timeSeconds, sampleRate) {
+  const sample = Math.round(timeSeconds * sampleRate);
+  return getChunkIndexForSample(chunks, sample);
+}
+
+// src/stretcher/priority-queue.ts
+function createPriorityQueue(compareFn) {
+  const heap = [];
+  function parent(i) {
+    return Math.floor((i - 1) / 2);
   }
-  const inputLength = channels[0].length;
-  if (inputLength === 0) {
-    return { output: channels.map(() => new Float32Array(0)), length: 0 };
+  function left(i) {
+    return 2 * i + 1;
   }
-  const synthesisHop = hopSize;
-  const analysisHop = Math.round(hopSize * tempo);
-  const numFrames = Math.floor((inputLength - frameSize) / analysisHop) + 1;
-  if (numFrames <= 0) {
-    return {
-      output: channels.map((ch) => new Float32Array(ch)),
-      length: inputLength
-    };
-  }
-  const estimatedOutputLength = (numFrames - 1) * synthesisHop + frameSize;
-  const outputChannels = channels.map(
-    () => new Float32Array(estimatedOutputLength)
-  );
-  const windowFunc = createHannWindow(frameSize);
-  const normBuffer = new Float32Array(estimatedOutputLength);
-  const prevOutputFrame = channels.map(() => new Float32Array(frameSize));
-  let inputPos = 0;
-  let outputPos = 0;
-  let actualOutputLength = 0;
-  for (let frame = 0; frame < numFrames; frame++) {
-    if (inputPos + frameSize > inputLength) break;
-    let actualInputPos = inputPos;
-    if (frame > 0 && tolerance > 0) {
-      const searchStart = Math.max(0, inputPos - tolerance);
-      const searchEnd = Math.min(inputLength - frameSize, inputPos + tolerance);
-      const searchRange = searchEnd - searchStart;
-      if (searchRange > 0) {
-        const refChannel = prevOutputFrame[0];
-        const inputChannel = channels[0];
-        const overlapStart = frameSize - synthesisHop;
-        const overlapSize = Math.min(synthesisHop, frameSize - overlapStart);
-        const refSlice = refChannel.subarray(
-          overlapStart,
-          overlapStart + overlapSize
-        );
-        const searchSlice = inputChannel.subarray(
-          searchStart,
-          searchEnd + overlapSize
-        );
-        const bestOffset = findBestOffset(
-          refSlice,
-          searchSlice,
-          overlapSize,
-          Math.min(searchRange, searchSlice.length - overlapSize)
-        );
-        actualInputPos = searchStart + bestOffset;
-      }
-    }
-    for (let ch = 0; ch < channels.length; ch++) {
-      const input = channels[ch];
-      const output = outputChannels[ch];
-      const prevFrame = prevOutputFrame[ch];
-      for (let i = 0; i < frameSize; i++) {
-        const inIdx = actualInputPos + i;
-        if (inIdx >= inputLength) break;
-        const outIdx = outputPos + i;
-        if (outIdx >= estimatedOutputLength) break;
-        const sample = input[inIdx];
-        output[outIdx] += sample * windowFunc[i];
-        prevFrame[i] = sample;
-      }
-    }
-    for (let i = 0; i < frameSize; i++) {
-      const outIdx = outputPos + i;
-      if (outIdx >= estimatedOutputLength) break;
-      normBuffer[outIdx] += windowFunc[i];
-    }
-    inputPos += analysisHop;
-    outputPos += synthesisHop;
-    actualOutputLength = Math.min(outputPos + frameSize, estimatedOutputLength);
-  }
-  for (let ch = 0; ch < outputChannels.length; ch++) {
-    const output = outputChannels[ch];
-    for (let i = 0; i < actualOutputLength; i++) {
-      const norm = normBuffer[i];
-      if (norm > 1e-8) {
-        output[i] /= norm;
-      }
-    }
-  }
-  const trimmedOutput = outputChannels.map(
-    (ch) => ch.subarray(0, actualOutputLength)
-  );
-  return { output: trimmedOutput, length: actualOutputLength };
-}
-
-// src/stretcher/main-thread-processor.ts
-function createMainThreadProcessor(onResult, onError) {
-  let terminated = false;
-  const postTimes = /* @__PURE__ */ new Map();
-  let currentChunkIndex = null;
-  let cancelledChunks = /* @__PURE__ */ new Set();
-  let busy = false;
-  return {
-    postConvert(chunkIndex, inputData, tempo, sampleRate) {
-      if (terminated) return;
-      busy = true;
-      currentChunkIndex = chunkIndex;
-      postTimes.set(chunkIndex, performance.now());
-      setTimeout(() => {
-        if (terminated) return;
-        if (cancelledChunks.has(chunkIndex)) {
-          cancelledChunks.delete(chunkIndex);
-          busy = false;
-          currentChunkIndex = null;
-          onResult({ type: "cancelled", chunkIndex });
-          return;
-        }
-        try {
-          const result = wsolaTimeStretch(inputData, tempo, sampleRate);
-          if (cancelledChunks.has(chunkIndex)) {
-            cancelledChunks.delete(chunkIndex);
-            busy = false;
-            currentChunkIndex = null;
-            onResult({ type: "cancelled", chunkIndex });
-            return;
-          }
-          busy = false;
-          currentChunkIndex = null;
-          onResult({
-            type: "result",
-            chunkIndex,
-            outputData: result.output,
-            outputLength: result.length
-          });
-        } catch (err) {
-          busy = false;
-          currentChunkIndex = null;
-          onError({
-            type: "error",
-            chunkIndex,
-            error: String(err)
-          });
-        }
-      }, 0);
-    },
-    cancelCurrent() {
-      if (terminated) return;
-      if (currentChunkIndex !== null) {
-        cancelledChunks.add(currentChunkIndex);
-      }
-    },
-    cancelChunk(chunkIndex) {
-      if (terminated) return;
-      cancelledChunks.add(chunkIndex);
-    },
-    isBusy() {
-      return busy;
-    },
-    hasCapacity() {
-      return !busy;
-    },
-    getCurrentChunkIndex() {
-      return currentChunkIndex;
-    },
-    getLastPostTime() {
-      let latest = null;
-      for (const t of postTimes.values()) {
-        if (latest === null || t > latest) {
-          latest = t;
-        }
-      }
-      return latest;
-    },
-    getPostTimeForChunk(chunkIndex) {
-      return postTimes.get(chunkIndex) ?? null;
-    },
-    terminate() {
-      if (terminated) return;
-      terminated = true;
-      cancelledChunks.clear();
-      postTimes.clear();
-    }
-  };
-}
-
-// src/stretcher/priority-queue.ts
-function createPriorityQueue(compareFn) {
-  const heap = [];
-  function parent(i) {
-    return Math.floor((i - 1) / 2);
-  }
-  function left(i) {
-    return 2 * i + 1;
-  }
-  function right(i) {
-    return 2 * i + 2;
+  function right(i) {
+    return 2 * i + 2;
   }
   function swap(i, j) {
     const tmp = heap[i];
@@ -798,14 +503,8 @@ function createConversionScheduler(chunks, workerManager, extractChunkData2, sam
   const forwardWeight = options?.forwardWeight ?? PRIORITY_FORWARD_WEIGHT;
   const backwardWeight = options?.backwardWeight ?? PRIORITY_BACKWARD_WEIGHT;
   const cancelDistThreshold = options?.cancelDistanceThreshold ?? CANCEL_DISTANCE_THRESHOLD;
-  const keepAhead = options?.keepAheadChunks ?? Math.max(
-    KEEP_AHEAD_CHUNKS,
-    Math.ceil(KEEP_AHEAD_SECONDS / CHUNK_DURATION_SEC)
-  );
-  const keepBehind = options?.keepBehindChunks ?? Math.max(
-    KEEP_BEHIND_CHUNKS,
-    Math.ceil(KEEP_BEHIND_SECONDS / CHUNK_DURATION_SEC)
-  );
+  const keepAhead = options?.keepAheadChunks ?? Math.max(KEEP_AHEAD_CHUNKS, Math.ceil(KEEP_AHEAD_SECONDS / CHUNK_DURATION_SEC));
+  const keepBehind = options?.keepBehindChunks ?? Math.max(KEEP_BEHIND_CHUNKS, Math.ceil(KEEP_BEHIND_SECONDS / CHUNK_DURATION_SEC));
   function isInActiveWindow(chunkIndex, playheadIndex) {
     const dist = chunkIndex - playheadIndex;
     return dist <= keepAhead && dist >= -keepBehind;
@@ -814,9 +513,7 @@ function createConversionScheduler(chunks, workerManager, extractChunkData2, sam
   let currentChunkIdx = 0;
   let previousTempoCache = null;
   let disposed = false;
-  const queue = createPriorityQueue(
-    (a, b) => a.priority - b.priority
-  );
+  const queue = createPriorityQueue((a, b) => a.priority - b.priority);
   function calcPriority(chunkIndex, playheadIndex) {
     const distance = chunkIndex - playheadIndex;
     if (distance >= 0) {
@@ -861,17 +558,17 @@ function createConversionScheduler(chunks, workerManager, extractChunkData2, sam
       }
       nextChunk.state = "converting";
       const data = extractChunkData2(nextChunk.index);
-      workerManager.postConvert(
-        nextChunk.index,
-        data,
-        currentTempo,
-        sampleRate
-      );
+      workerManager.postConvert(nextChunk.index, data, currentTempo, sampleRate);
     }
   }
   function handleResult(chunkIndex, outputData, outputLength) {
+    if (disposed) return;
     const chunk = chunks[chunkIndex];
     if (!chunk) return;
+    if (chunk.state !== "converting") {
+      dispatchNext();
+      return;
+    }
     chunk.state = "ready";
     chunk.outputBuffer = outputData;
     chunk.outputLength = outputLength;
@@ -879,6 +576,7 @@ function createConversionScheduler(chunks, workerManager, extractChunkData2, sam
     dispatchNext();
   }
   function handleError(chunkIndex, error) {
+    if (disposed) return;
     const chunk = chunks[chunkIndex];
     if (!chunk) return;
     chunk.retryCount++;
@@ -972,281 +670,616 @@ function createConversionScheduler(chunks, workerManager, extractChunkData2, sam
   };
 }
 
-// src/stretcher/chunk-player.ts
-var CURVE_LENGTH = 256;
-function createEqualPowerCurve(fadeIn) {
-  const curve = new Float32Array(CURVE_LENGTH);
-  for (let i = 0; i < CURVE_LENGTH; i++) {
-    const t = i / (CURVE_LENGTH - 1);
-    curve[i] = fadeIn ? Math.sin(t * Math.PI / 2) : Math.cos(t * Math.PI / 2);
-  }
-  return curve;
-}
-var fadeInCurve = createEqualPowerCurve(true);
-var fadeOutCurve = createEqualPowerCurve(false);
-function createChunkPlayer(ctx, options) {
-  const destination = options.destination ?? ctx.destination;
-  const through = options.through ?? [];
-  const crossfadeSec = options.crossfadeSec ?? CROSSFADE_SEC;
-  let currentSource = null;
-  let nextSource = null;
-  let currentGain = null;
-  let nextGain = null;
-  let playStartCtxTime = 0;
-  let playStartOffset = 0;
-  let currentChunkDuration = 0;
-  let paused = false;
-  let pausedPosition = 0;
-  let stopped = true;
-  let lookaheadTimer = null;
-  let transitionTimerId = null;
-  let onChunkEnded = null;
-  let onNeedNext = null;
-  let onTransition = null;
-  let disposed = false;
-  function connectToDestination(node) {
-    if (through.length > 0) {
-      node.connect(through[0]);
-      for (let i = 0; i < through.length - 1; i++) {
-        through[i].connect(through[i + 1]);
+// src/stretcher/wsola.ts
+function createHannWindow(size) {
+  const window = new Float32Array(size);
+  for (let i = 0; i < size; i++) {
+    window[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (size - 1)));
+  }
+  return window;
+}
+function findBestOffset(ref, search, overlapSize, maxOffset) {
+  let bestOffset = 0;
+  let bestCorr = -Infinity;
+  const searchLen = search.length;
+  const refLen = ref.length;
+  const len = Math.min(overlapSize, refLen);
+  for (let offset = 0; offset <= maxOffset; offset++) {
+    if (offset + len > searchLen) break;
+    let corr = 0;
+    let normRef = 0;
+    let normSearch = 0;
+    for (let i = 0; i < len; i++) {
+      const r = ref[i];
+      const s = search[offset + i];
+      corr += r * s;
+      normRef += r * r;
+      normSearch += s * s;
+    }
+    const denom = Math.sqrt(normRef * normSearch);
+    const ncc = denom > 1e-10 ? corr / denom : 0;
+    if (ncc > bestCorr) {
+      bestCorr = ncc;
+      bestOffset = offset;
+    }
+  }
+  return bestOffset;
+}
+function wsolaTimeStretch(channels, tempo, _sampleRate, frameSize = WSOLA_FRAME_SIZE, hopSize = WSOLA_HOP_SIZE, tolerance = WSOLA_TOLERANCE) {
+  if (channels.length === 0) {
+    return { output: [], length: 0 };
+  }
+  const inputLength = channels[0].length;
+  if (inputLength === 0) {
+    return { output: channels.map(() => new Float32Array(0)), length: 0 };
+  }
+  const TEMPO_IDENTITY_EPSILON = 1e-3;
+  if (Math.abs(tempo - 1) < TEMPO_IDENTITY_EPSILON) {
+    return {
+      output: channels.map((ch) => new Float32Array(ch)),
+      length: inputLength
+    };
+  }
+  const synthesisHop = hopSize;
+  const analysisHop = Math.round(hopSize * tempo);
+  const numFrames = Math.floor((inputLength - frameSize) / analysisHop) + 1;
+  if (numFrames <= 0) {
+    return {
+      output: channels.map((ch) => new Float32Array(ch)),
+      length: inputLength
+    };
+  }
+  const estimatedOutputLength = (numFrames - 1) * synthesisHop + frameSize;
+  const outputChannels = channels.map(() => new Float32Array(estimatedOutputLength));
+  const windowFunc = createHannWindow(frameSize);
+  const normBuffer = new Float32Array(estimatedOutputLength);
+  const prevOutputFrame = channels.map(() => new Float32Array(frameSize));
+  let inputPos = 0;
+  let outputPos = 0;
+  let actualOutputLength = 0;
+  for (let frame = 0; frame < numFrames; frame++) {
+    if (inputPos + frameSize > inputLength) break;
+    let actualInputPos = inputPos;
+    if (frame > 0 && tolerance > 0) {
+      const searchStart = Math.max(0, inputPos - tolerance);
+      const searchEnd = Math.min(inputLength - frameSize, inputPos + tolerance);
+      const searchRange = searchEnd - searchStart;
+      if (searchRange > 0) {
+        const refChannel = prevOutputFrame[0];
+        const inputChannel = channels[0];
+        const overlapStart = frameSize - synthesisHop;
+        const overlapSize = Math.min(synthesisHop, frameSize - overlapStart);
+        const refSlice = refChannel.subarray(overlapStart, overlapStart + overlapSize);
+        const searchSlice = inputChannel.subarray(searchStart, searchEnd + overlapSize);
+        const bestOffset = findBestOffset(
+          refSlice,
+          searchSlice,
+          overlapSize,
+          Math.min(searchRange, searchSlice.length - overlapSize)
+        );
+        actualInputPos = searchStart + bestOffset;
+      }
+    }
+    for (let ch = 0; ch < channels.length; ch++) {
+      const input = channels[ch];
+      const output = outputChannels[ch];
+      const prevFrame = prevOutputFrame[ch];
+      for (let i = 0; i < frameSize; i++) {
+        const inIdx = actualInputPos + i;
+        if (inIdx >= inputLength) break;
+        const outIdx = outputPos + i;
+        if (outIdx >= estimatedOutputLength) break;
+        const sample = input[inIdx];
+        output[outIdx] += sample * windowFunc[i];
+        prevFrame[i] = sample * windowFunc[i];
+      }
+    }
+    for (let i = 0; i < frameSize; i++) {
+      const outIdx = outputPos + i;
+      if (outIdx >= estimatedOutputLength) break;
+      normBuffer[outIdx] += windowFunc[i];
+    }
+    inputPos += analysisHop;
+    outputPos += synthesisHop;
+    actualOutputLength = Math.min(outputPos + frameSize, estimatedOutputLength);
+  }
+  for (let ch = 0; ch < outputChannels.length; ch++) {
+    const output = outputChannels[ch];
+    for (let i = 0; i < actualOutputLength; i++) {
+      const norm = normBuffer[i];
+      if (norm > 1e-8) {
+        output[i] /= norm;
+      }
+    }
+  }
+  const trimmedOutput = outputChannels.map((ch) => ch.subarray(0, actualOutputLength));
+  return { output: trimmedOutput, length: actualOutputLength };
+}
+
+// src/stretcher/main-thread-processor.ts
+function createMainThreadProcessor(onResult, onError) {
+  let terminated = false;
+  const postTimes = /* @__PURE__ */ new Map();
+  let currentChunkIndex = null;
+  const cancelledChunks = /* @__PURE__ */ new Set();
+  let busy = false;
+  return {
+    postConvert(chunkIndex, inputData, tempo, sampleRate) {
+      if (terminated) return;
+      busy = true;
+      currentChunkIndex = chunkIndex;
+      postTimes.set(chunkIndex, performance.now());
+      setTimeout(() => {
+        if (terminated) return;
+        if (cancelledChunks.has(chunkIndex)) {
+          cancelledChunks.delete(chunkIndex);
+          busy = false;
+          currentChunkIndex = null;
+          onResult({ type: "cancelled", chunkIndex });
+          return;
+        }
+        try {
+          const result = wsolaTimeStretch(inputData, tempo, sampleRate);
+          if (cancelledChunks.has(chunkIndex)) {
+            cancelledChunks.delete(chunkIndex);
+            busy = false;
+            currentChunkIndex = null;
+            onResult({ type: "cancelled", chunkIndex });
+            return;
+          }
+          busy = false;
+          currentChunkIndex = null;
+          onResult({
+            type: "result",
+            chunkIndex,
+            outputData: result.output,
+            outputLength: result.length
+          });
+        } catch (err) {
+          busy = false;
+          currentChunkIndex = null;
+          onError({
+            type: "error",
+            chunkIndex,
+            error: String(err)
+          });
+        }
+      }, 0);
+    },
+    cancelCurrent() {
+      if (terminated) return;
+      if (currentChunkIndex !== null) {
+        cancelledChunks.add(currentChunkIndex);
+      }
+    },
+    cancelChunk(chunkIndex) {
+      if (terminated) return;
+      cancelledChunks.add(chunkIndex);
+    },
+    isBusy() {
+      return busy;
+    },
+    hasCapacity() {
+      return !busy;
+    },
+    getCurrentChunkIndex() {
+      return currentChunkIndex;
+    },
+    getLastPostTime() {
+      let latest = null;
+      for (const t of postTimes.values()) {
+        if (latest === null || t > latest) {
+          latest = t;
+        }
+      }
+      return latest;
+    },
+    getPostTimeForChunk(chunkIndex) {
+      return postTimes.get(chunkIndex) ?? null;
+    },
+    terminate() {
+      if (terminated) return;
+      terminated = true;
+      cancelledChunks.clear();
+      postTimes.clear();
+    }
+  };
+}
+
+// src/stretcher/position-calc.ts
+function calcPositionInOriginalBuffer(p) {
+  if (p.phase === "ended") return p.totalDuration;
+  if (p.phase === "waiting") return p.offset;
+  if ((p.phase === "buffering" || p.phase === "paused") && p.bufferingResumePosition !== null) {
+    return p.bufferingResumePosition;
+  }
+  if (!p.chunk) return 0;
+  const nominalStartSample = p.chunk.inputStartSample + p.chunk.overlapBefore;
+  const nominalStartSec = nominalStartSample / p.sampleRate;
+  const crossfadeOffset = p.chunk.overlapBefore > 0 ? p.crossfadeSec : 0;
+  const adjustedPosInChunk = Math.max(0, p.posInChunk - crossfadeOffset);
+  const posInOriginal = adjustedPosInChunk * p.currentTempo;
+  return Math.min(nominalStartSec + posInOriginal, p.totalDuration);
+}
+
+// src/stretcher/worker-inline.ts
+function getWorkerCode() {
+  return `"use strict";
+
+var FRAME_SIZE = ${WSOLA_FRAME_SIZE};
+var HOP_SIZE = ${WSOLA_HOP_SIZE};
+var TOLERANCE = ${WSOLA_TOLERANCE};
+
+function createHannWindow(size) {
+  var w = new Float32Array(size);
+  for (var i = 0; i < size; i++) {
+    w[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (size - 1)));
+  }
+  return w;
+}
+
+function findBestOffset(ref, search, overlapSize, maxOffset) {
+  var bestOffset = 0;
+  var bestCorr = -Infinity;
+  var searchLen = search.length;
+  var refLen = ref.length;
+  var len = Math.min(overlapSize, refLen);
+
+  for (var offset = 0; offset <= maxOffset; offset++) {
+    if (offset + len > searchLen) break;
+    var corr = 0;
+    var normRef = 0;
+    var normSearch = 0;
+    for (var i = 0; i < len; i++) {
+      var r = ref[i];
+      var s = search[offset + i];
+      corr += r * s;
+      normRef += r * r;
+      normSearch += s * s;
+    }
+    var denom = Math.sqrt(normRef * normSearch);
+    var ncc = denom > 1e-10 ? corr / denom : 0;
+    if (ncc > bestCorr) {
+      bestCorr = ncc;
+      bestOffset = offset;
+    }
+  }
+  return bestOffset;
+}
+
+function wsolaTimeStretch(channels, tempo, sampleRate) {
+  if (channels.length === 0) {
+    return { output: [], length: 0 };
+  }
+
+  var inputLength = channels[0].length;
+  if (inputLength === 0) {
+    return { output: channels.map(function() { return new Float32Array(0); }), length: 0 };
+  }
+
+  var TEMPO_IDENTITY_EPSILON = 0.001;
+  if (Math.abs(tempo - 1.0) < TEMPO_IDENTITY_EPSILON) {
+    return {
+      output: channels.map(function(ch) { return new Float32Array(ch); }),
+      length: inputLength
+    };
+  }
+
+  var synthesisHop = HOP_SIZE;
+  var analysisHop = Math.round(HOP_SIZE * tempo);
+  var numFrames = Math.floor((inputLength - FRAME_SIZE) / analysisHop) + 1;
+
+  if (numFrames <= 0) {
+    return {
+      output: channels.map(function(ch) { return new Float32Array(ch); }),
+      length: inputLength
+    };
+  }
+
+  var estimatedOutputLength = (numFrames - 1) * synthesisHop + FRAME_SIZE;
+  var outputChannels = channels.map(function() {
+    return new Float32Array(estimatedOutputLength);
+  });
+  var windowFunc = createHannWindow(FRAME_SIZE);
+  var normBuffer = new Float32Array(estimatedOutputLength);
+
+  var prevOutputFrame = channels.map(function() {
+    return new Float32Array(FRAME_SIZE);
+  });
+
+  var inputPos = 0;
+  var outputPos = 0;
+  var actualOutputLength = 0;
+
+  for (var frame = 0; frame < numFrames; frame++) {
+    if (cancelled) return null;
+    if (inputPos + FRAME_SIZE > inputLength) break;
+
+    var actualInputPos = inputPos;
+
+    if (frame > 0 && TOLERANCE > 0) {
+      var searchStart = Math.max(0, inputPos - TOLERANCE);
+      var searchEnd = Math.min(inputLength - FRAME_SIZE, inputPos + TOLERANCE);
+      var searchRange = searchEnd - searchStart;
+
+      if (searchRange > 0) {
+        var refChannel = prevOutputFrame[0];
+        var inputChannel = channels[0];
+
+        var overlapStart = FRAME_SIZE - synthesisHop;
+        var overlapSize = Math.min(synthesisHop, FRAME_SIZE - overlapStart);
+
+        var refSlice = refChannel.subarray(overlapStart, overlapStart + overlapSize);
+        var searchSlice = inputChannel.subarray(searchStart, searchEnd + overlapSize);
+
+        var bestOffset = findBestOffset(
+          refSlice, searchSlice, overlapSize,
+          Math.min(searchRange, searchSlice.length - overlapSize)
+        );
+
+        actualInputPos = searchStart + bestOffset;
       }
-      through[through.length - 1].connect(destination);
-    } else {
-      node.connect(destination);
     }
-  }
-  function createSourceFromBuffer(buffer, gain) {
-    const src = ctx.createBufferSource();
-    src.buffer = buffer;
-    src.connect(gain);
-    connectToDestination(gain);
-    return src;
-  }
-  function stopCurrentSource() {
-    if (currentSource) {
-      currentSource.onended = null;
-      try {
-        currentSource.stop();
-      } catch {
+
+    for (var ch = 0; ch < channels.length; ch++) {
+      var input = channels[ch];
+      var output = outputChannels[ch];
+      var prevFrame = prevOutputFrame[ch];
+      for (var i = 0; i < FRAME_SIZE; i++) {
+        var inIdx = actualInputPos + i;
+        if (inIdx >= inputLength) break;
+        var outIdx = outputPos + i;
+        if (outIdx >= estimatedOutputLength) break;
+        var sample = input[inIdx];
+        output[outIdx] += sample * windowFunc[i];
+        prevFrame[i] = sample * windowFunc[i];
       }
-      currentSource.disconnect();
-      currentSource = null;
     }
-    if (currentGain) {
-      currentGain.disconnect();
-      currentGain = null;
+
+    for (var i = 0; i < FRAME_SIZE; i++) {
+      var outIdx = outputPos + i;
+      if (outIdx >= estimatedOutputLength) break;
+      normBuffer[outIdx] += windowFunc[i];
     }
+
+    inputPos += analysisHop;
+    outputPos += synthesisHop;
+    actualOutputLength = Math.min(outputPos + FRAME_SIZE, estimatedOutputLength);
   }
-  function stopNextSource() {
-    if (nextSource) {
-      nextSource.onended = null;
-      try {
-        nextSource.stop();
-      } catch {
+
+  for (var ch = 0; ch < outputChannels.length; ch++) {
+    var output = outputChannels[ch];
+    for (var i = 0; i < actualOutputLength; i++) {
+      var norm = normBuffer[i];
+      if (norm > 1e-8) {
+        output[i] /= norm;
       }
-      nextSource.disconnect();
-      nextSource = null;
-    }
-    if (nextGain) {
-      nextGain.disconnect();
-      nextGain = null;
     }
   }
-  function startLookahead() {
-    if (lookaheadTimer !== null) return;
-    lookaheadTimer = setInterval(() => {
-      if (paused || stopped || disposed) return;
-      const pos = getElapsedInChunk();
-      const remaining = currentChunkDuration - pos;
-      if (remaining <= LOOKAHEAD_THRESHOLD_SEC && !nextSource) {
-        onNeedNext?.();
-      }
-    }, LOOKAHEAD_INTERVAL_MS);
+
+  var trimmedOutput = outputChannels.map(function(ch) {
+    return ch.slice(0, actualOutputLength);
+  });
+
+  return { output: trimmedOutput, length: actualOutputLength };
+}
+
+var cancelled = false;
+
+self.onmessage = function(e) {
+  var msg = e.data;
+  if (msg.type === "cancel") {
+    cancelled = true;
+    return;
   }
-  function stopLookahead() {
-    if (lookaheadTimer !== null) {
-      clearInterval(lookaheadTimer);
-      lookaheadTimer = null;
+  if (msg.type === "convert") {
+    cancelled = false;
+    try {
+      var result = wsolaTimeStretch(msg.inputData, msg.tempo, msg.sampleRate);
+      if (cancelled || result === null) {
+        self.postMessage({ type: "cancelled", chunkIndex: msg.chunkIndex });
+      } else {
+        self.postMessage(
+          { type: "result", chunkIndex: msg.chunkIndex, outputData: result.output, outputLength: result.length },
+          result.output.map(function(ch) { return ch.buffer; })
+        );
+      }
+    } catch (err) {
+      self.postMessage({ type: "error", chunkIndex: msg.chunkIndex, error: String(err) });
     }
   }
-  function cancelTransition() {
-    if (transitionTimerId !== null) {
-      clearTimeout(transitionTimerId);
-      transitionTimerId = null;
+};
+`;
+}
+function createWorkerURL() {
+  const code = getWorkerCode();
+  const blob = new Blob([code], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+}
+function revokeWorkerURL(url) {
+  URL.revokeObjectURL(url);
+}
+
+// src/stretcher/worker-manager.ts
+function createWorkerManager(onResult, onError, maxCrashes = MAX_WORKER_CRASHES, poolSize = WORKER_POOL_SIZE, onAllDead) {
+  let workerURL = null;
+  let terminated = false;
+  let allDeadFired = false;
+  const postTimes = /* @__PURE__ */ new Map();
+  const slots = [];
+  function ensureWorkerURL() {
+    if (!workerURL) {
+      workerURL = createWorkerURL();
     }
+    return workerURL;
   }
-  function getElapsedInChunk() {
-    if (paused) return pausedPosition;
-    if (stopped) return 0;
-    return ctx.currentTime - playStartCtxTime + playStartOffset;
+  function isAllDead() {
+    return slots.every((s) => s.worker === null);
   }
-  function playChunk(buffer, _startTime, offsetInChunk = 0) {
-    cancelTransition();
-    stopCurrentSource();
-    stopNextSource();
-    currentGain = ctx.createGain();
-    currentSource = createSourceFromBuffer(buffer, currentGain);
-    currentChunkDuration = buffer.duration;
-    playStartOffset = offsetInChunk;
-    playStartCtxTime = ctx.currentTime;
-    paused = false;
-    stopped = false;
-    currentSource.onended = () => {
-      if (!disposed && !paused && !stopped) {
-        onChunkEnded?.();
+  function spawnWorkerForSlot(slot) {
+    if (terminated) return;
+    const url = ensureWorkerURL();
+    let worker;
+    try {
+      worker = new Worker(url);
+    } catch {
+      slot.worker = null;
+      return;
+    }
+    worker.onmessage = (e) => {
+      const response = e.data;
+      if (response.type === "result" || response.type === "cancelled") {
+        slot.busy = false;
+        slot.currentChunkIndex = null;
+        postTimes.delete(response.chunkIndex);
       }
+      if (response.type === "error") {
+        slot.busy = false;
+        slot.currentChunkIndex = null;
+        postTimes.delete(response.chunkIndex);
+        onError(response);
+        return;
+      }
+      onResult(response);
     };
-    currentSource.start(0, offsetInChunk);
-    if (crossfadeSec > 0) {
-      currentGain.gain.setValueCurveAtTime(fadeInCurve, ctx.currentTime, crossfadeSec);
-    }
-    startLookahead();
-  }
-  function scheduleNext(buffer, startTime) {
-    if (disposed) return;
-    stopNextSource();
-    nextGain = ctx.createGain();
-    nextSource = createSourceFromBuffer(buffer, nextGain);
-    nextSource.onended = () => {
-      if (!disposed && !paused && !stopped) {
-        onChunkEnded?.();
+    worker.onerror = (e) => {
+      e.preventDefault();
+      slot.busy = false;
+      const failedChunkIndex = slot.currentChunkIndex;
+      slot.currentChunkIndex = null;
+      slot.crashCount++;
+      if (failedChunkIndex !== null) {
+        postTimes.delete(failedChunkIndex);
+        onError({
+          type: "error",
+          chunkIndex: failedChunkIndex,
+          error: `Worker crashed: ${e.message}`
+        });
+      }
+      if (slot.worker) {
+        slot.worker.onmessage = null;
+        slot.worker.onerror = null;
+        slot.worker.terminate();
+        slot.worker = null;
+      }
+      if (slot.crashCount < maxCrashes) {
+        spawnWorkerForSlot(slot);
+      } else {
+        onError({
+          type: "error",
+          chunkIndex: failedChunkIndex ?? -1,
+          error: `Worker crashed ${slot.crashCount} times, giving up`
+        });
+        if (!allDeadFired && isAllDead()) {
+          allDeadFired = true;
+          onAllDead?.();
+        }
       }
     };
-    nextSource.start(startTime - crossfadeSec);
-    if (crossfadeSec > 0 && currentGain) {
-      currentGain.gain.setValueCurveAtTime(fadeOutCurve, startTime - crossfadeSec, crossfadeSec);
-      nextGain.gain.setValueCurveAtTime(fadeInCurve, startTime - crossfadeSec, crossfadeSec);
-    }
-    const transitionDelay = Math.max(
-      0,
-      (startTime - ctx.currentTime) * 1e3 + 50
-    );
-    cancelTransition();
-    transitionTimerId = setTimeout(() => {
-      transitionTimerId = null;
-      if (disposed) return;
-      stopCurrentSource();
-      currentSource = nextSource;
-      currentGain = nextGain;
-      nextSource = null;
-      nextGain = null;
-      currentChunkDuration = buffer.duration;
-      playStartOffset = 0;
-      playStartCtxTime = startTime - crossfadeSec;
-      onTransition?.();
-    }, transitionDelay);
-  }
-  function handleSeek(buffer, offsetInChunk) {
-    playChunk(buffer, 0, offsetInChunk);
-  }
-  function pause() {
-    if (paused || stopped || disposed) return;
-    pausedPosition = getElapsedInChunk();
-    paused = true;
-    cancelTransition();
-    stopCurrentSource();
-    stopNextSource();
-    stopLookahead();
+    slot.worker = worker;
   }
-  function resume() {
-    if (!paused || disposed) return;
-    paused = false;
+  for (let i = 0; i < poolSize; i++) {
+    const slot = {
+      worker: null,
+      busy: false,
+      currentChunkIndex: null,
+      crashCount: 0
+    };
+    slots.push(slot);
+    spawnWorkerForSlot(slot);
   }
-  function stop() {
-    if (stopped || disposed) return;
-    stopped = true;
-    paused = false;
-    pausedPosition = 0;
-    cancelTransition();
-    stopCurrentSource();
-    stopNextSource();
-    stopLookahead();
+  if (!allDeadFired && isAllDead()) {
+    allDeadFired = true;
+    onAllDead?.();
   }
-  function getCurrentPosition() {
-    return getElapsedInChunk();
+  function findFreeSlot() {
+    for (const slot of slots) {
+      if (!slot.busy && slot.worker) {
+        return slot;
+      }
+    }
+    return null;
   }
-  function hasNextScheduled() {
-    return nextSource !== null;
+  function findSlotByChunk(chunkIndex) {
+    for (const slot of slots) {
+      if (slot.busy && slot.currentChunkIndex === chunkIndex) {
+        return slot;
+      }
+    }
+    return null;
   }
   return {
-    playChunk,
-    scheduleNext,
-    hasNextScheduled,
-    handleSeek,
-    pause,
-    resume,
-    stop,
-    getCurrentPosition,
-    setOnChunkEnded(callback) {
-      onChunkEnded = callback;
+    postConvert(chunkIndex, inputData, tempo, sampleRate) {
+      if (terminated) return;
+      const slot = findFreeSlot();
+      if (!slot || !slot.worker) return;
+      slot.busy = true;
+      slot.currentChunkIndex = chunkIndex;
+      postTimes.set(chunkIndex, performance.now());
+      const transferables = inputData.map((ch) => ch.buffer);
+      slot.worker.postMessage(
+        { type: "convert", chunkIndex, inputData, tempo, sampleRate },
+        transferables
+      );
     },
-    setOnNeedNext(callback) {
-      onNeedNext = callback;
+    cancelCurrent() {
+      if (terminated) return;
+      for (const slot of slots) {
+        if (slot.busy && slot.worker && slot.currentChunkIndex !== null) {
+          slot.worker.postMessage({ type: "cancel", chunkIndex: slot.currentChunkIndex });
+        }
+      }
     },
-    setOnTransition(callback) {
-      onTransition = callback;
+    cancelChunk(chunkIndex) {
+      if (terminated) return;
+      const slot = findSlotByChunk(chunkIndex);
+      if (slot?.worker) {
+        slot.worker.postMessage({ type: "cancel", chunkIndex });
+      }
     },
-    dispose() {
-      if (disposed) return;
-      disposed = true;
-      cancelTransition();
-      stopCurrentSource();
-      stopNextSource();
-      stopLookahead();
-    }
-  };
-}
-
-// src/stretcher/buffer-monitor.ts
-function createBufferMonitor(options) {
-  const healthySec = BUFFER_HEALTHY_SEC;
-  const lowSec = BUFFER_LOW_SEC;
-  const criticalSec = BUFFER_CRITICAL_SEC;
-  const resumeSec = BUFFER_RESUME_SEC;
-  const chunkDurSec = CHUNK_DURATION_SEC;
-  function getAheadSeconds(currentChunkIndex, chunks) {
-    let aheadSec = 0;
-    for (let i = currentChunkIndex; i < chunks.length; i++) {
-      const chunk = chunks[i];
-      if (!chunk || chunk.state !== "ready") break;
-      aheadSec += chunkDurSec;
+    isBusy() {
+      return slots.every((s) => s.busy || !s.worker);
+    },
+    hasCapacity() {
+      return findFreeSlot() !== null;
+    },
+    getCurrentChunkIndex() {
+      for (const slot of slots) {
+        if (slot.busy && slot.currentChunkIndex !== null) {
+          return slot.currentChunkIndex;
+        }
+      }
+      return null;
+    },
+    getLastPostTime() {
+      let latest = null;
+      for (const t of postTimes.values()) {
+        if (latest === null || t > latest) {
+          latest = t;
+        }
+      }
+      return latest;
+    },
+    getPostTimeForChunk(chunkIndex) {
+      return postTimes.get(chunkIndex) ?? null;
+    },
+    terminate() {
+      if (terminated) return;
+      terminated = true;
+      for (const slot of slots) {
+        if (slot.worker) {
+          slot.worker.onmessage = null;
+          slot.worker.onerror = null;
+          slot.worker.terminate();
+          slot.worker = null;
+        }
+      }
+      if (workerURL) {
+        revokeWorkerURL(workerURL);
+        workerURL = null;
+      }
+      postTimes.clear();
     }
-    return aheadSec;
-  }
-  function getHealth(currentChunkIndex, chunks) {
-    const ahead = getAheadSeconds(currentChunkIndex, chunks);
-    if (ahead >= healthySec) return "healthy";
-    if (ahead >= lowSec) return "low";
-    if (ahead >= criticalSec) return "critical";
-    return "empty";
-  }
-  function shouldEnterBuffering(currentChunkIndex, chunks) {
-    const ahead = getAheadSeconds(currentChunkIndex, chunks);
-    if (ahead >= criticalSec) return false;
-    const nextChunk = chunks[currentChunkIndex + 1];
-    if (nextChunk && nextChunk.state === "ready") return false;
-    const currentChunk = chunks[currentChunkIndex];
-    if (!currentChunk || currentChunk.state !== "ready") return true;
-    return ahead < criticalSec;
-  }
-  function shouldExitBuffering(currentChunkIndex, chunks) {
-    const currentChunk = chunks[currentChunkIndex];
-    if (!currentChunk || currentChunk.state !== "ready") return false;
-    const ahead = getAheadSeconds(currentChunkIndex, chunks);
-    if (ahead >= resumeSec) return true;
-    const nextChunk = chunks[currentChunkIndex + 1];
-    if (nextChunk && nextChunk.state === "ready") return true;
-    const allReady = chunks.every(
-      (c) => c.state === "ready" || c.state === "skipped"
-    );
-    if (allReady) return true;
-    return false;
-  }
-  return {
-    getHealth,
-    getAheadSeconds,
-    shouldEnterBuffering,
-    shouldExitBuffering
   };
 }
 
@@ -1257,7 +1290,7 @@ function trimOverlap(outputData, outputLength, chunk, sampleRate) {
     return { data: outputData, length: outputLength };
   }
   const ratio = outputLength / inputLength;
-  const crossfadeKeep = Math.round(CROSSFADE_SEC * sampleRate);
+  const crossfadeKeep = Math.round(CROSSFADE_SEC * sampleRate * Math.min(1, ratio));
   const overlapBeforeOutput = Math.round(chunk.overlapBefore * ratio);
   const overlapAfterOutput = Math.round(chunk.overlapAfter * ratio);
   const keepBefore = chunk.overlapBefore > 0 ? Math.min(crossfadeKeep, overlapBeforeOutput) : 0;
@@ -1279,26 +1312,29 @@ function createStretcherEngine(ctx, buffer, options) {
   const {
     tempo: initialTempo,
     offset = 0,
+    loop: initialLoop = false,
     through = [],
     destination = ctx.destination
   } = options;
-  const emitter = chunk5J7S6QV3_cjs.createEmitter();
+  const emitter = chunkHIF3UAF3_cjs.createEmitter();
   const sampleRate = buffer.sampleRate;
   const totalDuration = buffer.duration;
   let phase = "waiting";
   let currentTempo = initialTempo;
+  let isLooping = initialLoop;
   let disposed = false;
   let bufferingStartTime = 0;
   let currentChunkIndex = 0;
   let bufferingResumePosition = null;
+  let expectedTransitionFrom = null;
+  let nextChunkScheduledIndex = null;
+  let pendingTempoChange = false;
   const keepAhead = Math.max(KEEP_AHEAD_CHUNKS, Math.ceil(KEEP_AHEAD_SECONDS / CHUNK_DURATION_SEC));
-  const keepBehind = Math.max(KEEP_BEHIND_CHUNKS, Math.ceil(KEEP_BEHIND_SECONDS / CHUNK_DURATION_SEC));
-  const chunks = splitIntoChunks(
-    buffer.length,
-    sampleRate,
-    CHUNK_DURATION_SEC,
-    OVERLAP_SEC
+  const keepBehind = Math.max(
+    KEEP_BEHIND_CHUNKS,
+    Math.ceil(KEEP_BEHIND_SECONDS / CHUNK_DURATION_SEC)
   );
+  const chunks = splitIntoChunks(buffer.length, sampleRate, CHUNK_DURATION_SEC, OVERLAP_SEC);
   const monitor = createBufferMonitor();
   const poolSize = options.workerPoolSize ?? WORKER_POOL_SIZE;
   function handleWorkerResult(response) {
@@ -1314,11 +1350,7 @@ function createStretcherEngine(ctx, buffer, options) {
           chunk,
           sampleRate
         );
-        schedulerInternal._handleResult(
-          response.chunkIndex,
-          trimmed.data,
-          trimmed.length
-        );
+        schedulerInternal._handleResult(response.chunkIndex, trimmed.data, trimmed.length);
       }
     } else if (response.type === "cancelled") {
       const chunk = chunks[response.chunkIndex];
@@ -1331,10 +1363,7 @@ function createStretcherEngine(ctx, buffer, options) {
   function handleWorkerError(response) {
     if (disposed) return;
     if (response.type === "error") {
-      schedulerInternal._handleError(
-        response.chunkIndex,
-        response.error ?? "Unknown error"
-      );
+      schedulerInternal._handleError(response.chunkIndex, response.error ?? "Unknown error");
     }
   }
   function switchToMainThread() {
@@ -1370,26 +1399,34 @@ function createStretcherEngine(ctx, buffer, options) {
     if (disposed || phase === "paused" || phase === "ended") return;
     advanceToNextChunk();
   });
+  function tryScheduleNext(nextIdx) {
+    if (nextChunkScheduledIndex === nextIdx) return;
+    if (nextIdx >= chunks.length) return;
+    const nextChunk = chunks[nextIdx];
+    if (!nextChunk || nextChunk.state !== "ready" || !nextChunk.outputBuffer) return;
+    if (chunkPlayer.hasNextScheduled()) return;
+    const curChunk = chunks[currentChunkIndex];
+    const curOutputDuration = curChunk ? curChunk.outputLength / sampleRate : 0;
+    const elapsed = chunkPlayer.getCurrentPosition();
+    const remaining = curOutputDuration - elapsed;
+    if (remaining <= 0) return;
+    const audioBuffer = createAudioBufferFromChunk(nextChunk);
+    if (!audioBuffer) return;
+    const startTime = ctx.currentTime + remaining;
+    expectedTransitionFrom = currentChunkIndex;
+    chunkPlayer.scheduleNext(audioBuffer, startTime);
+    nextChunkScheduledIndex = nextIdx;
+  }
   chunkPlayer.setOnNeedNext(() => {
     if (disposed) return;
-    const nextIdx = currentChunkIndex + 1;
-    if (nextIdx < chunks.length) {
-      const nextChunk = chunks[nextIdx];
-      if (nextChunk.state === "ready" && nextChunk.outputBuffer) {
-        const audioBuffer = createAudioBufferFromChunk(nextChunk);
-        if (audioBuffer) {
-          const curChunk = chunks[currentChunkIndex];
-          const curOutputDuration = curChunk ? curChunk.outputLength / sampleRate : 0;
-          const elapsed = chunkPlayer.getCurrentPosition();
-          const remaining = curOutputDuration - elapsed;
-          const startTime = ctx.currentTime + Math.max(0, remaining);
-          chunkPlayer.scheduleNext(audioBuffer, startTime);
-        }
-      }
-    }
+    tryScheduleNext(currentChunkIndex + 1);
   });
   chunkPlayer.setOnTransition(() => {
     if (disposed) return;
+    if (expectedTransitionFrom !== null && currentChunkIndex !== expectedTransitionFrom) {
+      return;
+    }
+    nextChunkScheduledIndex = null;
     const nextIdx = currentChunkIndex + 1;
     if (nextIdx < chunks.length) {
       currentChunkIndex = nextIdx;
@@ -1408,21 +1445,12 @@ function createStretcherEngine(ctx, buffer, options) {
       }
     }
     if (phase === "playing" && chunkIndex === currentChunkIndex + 1) {
-      if (!chunkPlayer.hasNextScheduled()) {
-        const curChunk = chunks[currentChunkIndex];
-        const curOutputDuration = curChunk ? curChunk.outputLength / sampleRate : 0;
-        const elapsed = chunkPlayer.getCurrentPosition();
-        const remaining = curOutputDuration - elapsed;
-        if (remaining <= LOOKAHEAD_THRESHOLD_SEC) {
-          const nextChunk = chunks[chunkIndex];
-          if (nextChunk && nextChunk.outputBuffer) {
-            const audioBuffer = createAudioBufferFromChunk(nextChunk);
-            if (audioBuffer) {
-              const startTime = ctx.currentTime + Math.max(0, remaining);
-              chunkPlayer.scheduleNext(audioBuffer, startTime);
-            }
-          }
-        }
+      const curChunk = chunks[currentChunkIndex];
+      const curOutputDuration = curChunk ? curChunk.outputLength / sampleRate : 0;
+      const elapsed = chunkPlayer.getCurrentPosition();
+      const remaining = curOutputDuration - elapsed;
+      if (remaining <= PROACTIVE_SCHEDULE_THRESHOLD_SEC) {
+        tryScheduleNext(chunkIndex);
       }
     }
     const allDone = chunks.every(
@@ -1442,27 +1470,37 @@ function createStretcherEngine(ctx, buffer, options) {
   function createAudioBufferFromChunk(chunk) {
     if (!chunk.outputBuffer || chunk.outputLength === 0) return null;
     const numChannels = chunk.outputBuffer.length;
-    const audioBuf = ctx.createBuffer(
-      numChannels,
-      chunk.outputLength,
-      sampleRate
-    );
+    const audioBuf = ctx.createBuffer(numChannels, chunk.outputLength, sampleRate);
     for (let ch = 0; ch < numChannels; ch++) {
       const channelData = chunk.outputBuffer[ch];
       audioBuf.getChannelData(ch).set(channelData.subarray(0, chunk.outputLength));
     }
     return audioBuf;
   }
-  function playCurrentChunk(offsetInBuffer = 0) {
+  function playCurrentChunk(offsetInBuffer = 0, skipFadeIn = false) {
     const chunk = chunks[currentChunkIndex];
     if (!chunk || chunk.state !== "ready" || !chunk.outputBuffer) return;
     const audioBuf = createAudioBufferFromChunk(chunk);
     if (!audioBuf) return;
-    chunkPlayer.playChunk(audioBuf, ctx.currentTime, offsetInBuffer);
+    chunkPlayer.playChunk(audioBuf, ctx.currentTime, offsetInBuffer, skipFadeIn);
   }
   function advanceToNextChunk() {
     const nextIdx = currentChunkIndex + 1;
     if (nextIdx >= chunks.length) {
+      if (isLooping) {
+        currentChunkIndex = 0;
+        scheduler.handleSeek(0);
+        const chunk2 = chunks[0];
+        if (chunk2 && chunk2.state === "ready") {
+          playCurrentChunk();
+        } else {
+          bufferingResumePosition = 0;
+          enterBuffering("seek");
+        }
+        emitter.emit("loop", void 0);
+        evictDistantChunks();
+        return;
+      }
       phase = "ended";
       chunkPlayer.stop();
       emitter.emit("ended", void 0);
@@ -1473,6 +1511,7 @@ function createStretcherEngine(ctx, buffer, options) {
       return;
     }
     currentChunkIndex = nextIdx;
+    nextChunkScheduledIndex = null;
     scheduler.updatePriorities(currentChunkIndex);
     const chunk = chunks[currentChunkIndex];
     if (chunk && chunk.state === "ready") {
@@ -1490,6 +1529,7 @@ function createStretcherEngine(ctx, buffer, options) {
     if (phase === "buffering" && reason !== "tempo-change" && reason !== "seek") return;
     phase = "buffering";
     bufferingStartTime = performance.now();
+    nextChunkScheduledIndex = null;
     chunkPlayer.pause();
     emitter.emit("buffering", { reason });
   }
@@ -1551,26 +1591,22 @@ function createStretcherEngine(ctx, buffer, options) {
     });
   }
   function getPositionInOriginalBuffer() {
-    if (phase === "ended") return totalDuration;
-    if (phase === "waiting") return offset;
-    if (phase === "buffering" && bufferingResumePosition !== null) {
-      return bufferingResumePosition;
-    }
-    const chunk = chunks[currentChunkIndex];
-    if (!chunk) return 0;
-    const nominalStartSample = chunk.inputStartSample + chunk.overlapBefore;
-    const nominalStartSec = nominalStartSample / sampleRate;
-    const posInChunk = chunkPlayer.getCurrentPosition();
-    const crossfadeOffset = chunk.overlapBefore > 0 ? CROSSFADE_SEC : 0;
-    const adjustedPosInChunk = Math.max(0, posInChunk - crossfadeOffset);
-    const posInOriginal = adjustedPosInChunk * currentTempo;
-    return Math.min(nominalStartSec + posInOriginal, totalDuration);
+    const chunk = chunks[currentChunkIndex] ?? null;
+    return calcPositionInOriginalBuffer({
+      phase,
+      totalDuration,
+      offset,
+      bufferingResumePosition,
+      currentTempo,
+      sampleRate,
+      crossfadeSec: CROSSFADE_SEC,
+      chunk: chunk ? { inputStartSample: chunk.inputStartSample, overlapBefore: chunk.overlapBefore } : null,
+      posInChunk: chunkPlayer.getCurrentPosition()
+    });
   }
   function getStatus() {
     const readyCount = chunks.filter((c) => c.state === "ready").length;
-    const convertingCount = chunks.filter(
-      (c) => c.state === "converting"
-    ).length;
+    const convertingCount = chunks.filter((c) => c.state === "converting").length;
     const total = chunks.length;
     return {
       phase,
@@ -1594,9 +1630,7 @@ function createStretcherEngine(ctx, buffer, options) {
   function getSnapshot() {
     const readyCount = chunks.filter((c) => c.state === "ready").length;
     const total = chunks.length;
-    const convertingCount = chunks.filter(
-      (c) => c.state === "converting"
-    ).length;
+    const convertingCount = chunks.filter((c) => c.state === "converting").length;
     const windowStart = Math.max(0, currentChunkIndex - keepBehind);
     const windowEnd = Math.min(total - 1, currentChunkIndex + keepAhead);
     const windowSize = windowEnd - windowStart + 1;
@@ -1631,11 +1665,37 @@ function createStretcherEngine(ctx, buffer, options) {
   }
   function resume() {
     if (disposed || phase !== "paused") return;
+    if (pendingTempoChange) {
+      pendingTempoChange = false;
+      currentChunkIndex = getChunkIndexForTime(chunks, bufferingResumePosition, sampleRate);
+      enterBuffering("tempo-change");
+      scheduler.updatePriorities(currentChunkIndex);
+      scheduler.handleTempoChange(currentTempo);
+      return;
+    }
+    if (bufferingResumePosition !== null) {
+      const resumePos = bufferingResumePosition;
+      bufferingResumePosition = null;
+      const chunk2 = chunks[currentChunkIndex];
+      if (chunk2 && chunk2.state === "ready" && chunk2.outputBuffer) {
+        const nominalStartSample = chunk2.inputStartSample + chunk2.overlapBefore;
+        const nominalStartSec = nominalStartSample / sampleRate;
+        const offsetInOriginal = resumePos - nominalStartSec;
+        const offsetInOutput = Math.max(0, offsetInOriginal / currentTempo);
+        phase = "playing";
+        playCurrentChunk(getCrossfadeStart(chunk2) + offsetInOutput, true);
+      } else {
+        bufferingResumePosition = resumePos;
+        enterBuffering("seek");
+      }
+      return;
+    }
     const chunk = chunks[currentChunkIndex];
     if (chunk && chunk.state === "ready") {
+      const resumePosition = chunkPlayer.getCurrentPosition();
       phase = "playing";
       chunkPlayer.resume();
-      playCurrentChunk(chunkPlayer.getCurrentPosition());
+      playCurrentChunk(resumePosition, true);
     } else {
       enterBuffering("underrun");
     }
@@ -1645,6 +1705,7 @@ function createStretcherEngine(ctx, buffer, options) {
     const clamped = Math.max(0, Math.min(position, totalDuration));
     const newChunkIdx = getChunkIndexForTime(chunks, clamped, sampleRate);
     currentChunkIndex = newChunkIdx;
+    nextChunkScheduledIndex = null;
     scheduler.handleSeek(newChunkIdx);
     const chunk = chunks[newChunkIdx];
     if (chunk && chunk.state === "ready") {
@@ -1661,10 +1722,16 @@ function createStretcherEngine(ctx, buffer, options) {
           const clampedOffset = Math.min(Math.max(0, bufferOffset), audioBuf.duration - 1e-3);
           chunkPlayer.handleSeek(audioBuf, clampedOffset);
         }
+      } else if (phase === "paused") {
+        bufferingResumePosition = clamped;
       }
     } else {
-      bufferingResumePosition = clamped;
-      enterBuffering("seek");
+      if (phase === "paused") {
+        bufferingResumePosition = clamped;
+      } else {
+        bufferingResumePosition = clamped;
+        enterBuffering("seek");
+      }
     }
   }
   function stop() {
@@ -1672,18 +1739,42 @@ function createStretcherEngine(ctx, buffer, options) {
     phase = "ended";
     chunkPlayer.stop();
   }
+  function setLoop(value) {
+    isLooping = value;
+  }
+  let tempoDebounceTimer = null;
   function setTempo(newTempo) {
     if (disposed || phase === "ended" || newTempo === currentTempo) return;
-    bufferingResumePosition = getPositionInOriginalBuffer();
-    currentChunkIndex = getChunkIndexForTime(chunks, bufferingResumePosition, sampleRate);
+    if (phase === "paused") {
+      if (!pendingTempoChange) {
+        bufferingResumePosition = getPositionInOriginalBuffer();
+      }
+      currentTempo = newTempo;
+      pendingTempoChange = true;
+      return;
+    }
+    const isFirstInBurst = tempoDebounceTimer === null;
+    if (isFirstInBurst) {
+      bufferingResumePosition = getPositionInOriginalBuffer();
+      currentChunkIndex = getChunkIndexForTime(chunks, bufferingResumePosition, sampleRate);
+      enterBuffering("tempo-change");
+    }
     currentTempo = newTempo;
-    enterBuffering("tempo-change");
-    scheduler.updatePriorities(currentChunkIndex);
-    scheduler.handleTempoChange(newTempo);
+    if (tempoDebounceTimer !== null) clearTimeout(tempoDebounceTimer);
+    tempoDebounceTimer = setTimeout(() => {
+      tempoDebounceTimer = null;
+      if (disposed || phase === "ended") return;
+      scheduler.updatePriorities(currentChunkIndex);
+      scheduler.handleTempoChange(currentTempo);
+    }, 50);
   }
   function dispose() {
     if (disposed) return;
     disposed = true;
+    if (tempoDebounceTimer !== null) {
+      clearTimeout(tempoDebounceTimer);
+      tempoDebounceTimer = null;
+    }
     chunkPlayer.dispose();
     scheduler.dispose();
     workerManager.terminate();
@@ -1696,6 +1787,7 @@ function createStretcherEngine(ctx, buffer, options) {
     seek,
     stop,
     setTempo,
+    setLoop,
     getCurrentPosition: getPositionInOriginalBuffer,
     getStatus,
     getSnapshot,
@@ -1706,5 +1798,6 @@ function createStretcherEngine(ctx, buffer, options) {
 }
 
 exports.createStretcherEngine = createStretcherEngine;
-//# sourceMappingURL=chunk-TULV7V5M.cjs.map
-//# sourceMappingURL=chunk-TULV7V5M.cjs.map
+exports.trimOverlap = trimOverlap;
+//# sourceMappingURL=chunk-G37HMZEX.cjs.map
+//# sourceMappingURL=chunk-G37HMZEX.cjs.map