waa-play 0.2.0 → 0.2.1

package/dist/{chunk-2FFORBOP.js → chunk-GDBOHOGF.js}

@@ -1,4 +1,4 @@
-import { createEmitter } from './chunk-GYH2JSCY.js';
+import { createEmitter } from './chunk-FY273Z3I.js';
 
 // src/stretcher/constants.ts
 var CHUNK_DURATION_SEC = 8;
@@ -22,7 +22,300 @@ 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/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;
+  }
+  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
+  };
+}
+
+// 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 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 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);
+    }
+  }
+  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 {
+      }
+      currentSource.disconnect();
+      currentSource = null;
+    }
+    if (currentGain) {
+      currentGain.disconnect();
+      currentGain = null;
+    }
+  }
+  function stopNextSource() {
+    if (nextSource) {
+      nextSource.onended = null;
+      try {
+        nextSource.stop();
+      } catch {
+      }
+      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);
+  }
+  function stopLookahead() {
+    if (lookaheadTimer !== null) {
+      clearInterval(lookaheadTimer);
+      lookaheadTimer = null;
+    }
+  }
+  function cancelTransition() {
+    if (transitionTimerId !== null) {
+      clearTimeout(transitionTimerId);
+      transitionTimerId = null;
+    }
+  }
+  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;
+    }
+    onTransition?.();
+  }
+  function handleCurrentSourceEnded() {
+    if (disposed || paused || stopped) return;
+    if (nextSource) {
+      const buf = nextSource.buffer;
+      if (!buf) {
+        onChunkEnded?.();
+        return;
+      }
+      cancelTransition();
+      doTransition(buf, nextStartCtxTime);
+    } else {
+      onChunkEnded?.();
+    }
+  }
+  function getElapsedInChunk() {
+    if (paused) return pausedPosition;
+    if (stopped) return 0;
+    return ctx.currentTime - playStartCtxTime + playStartOffset;
+  }
+  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 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);
+    }
+    const transitionDelay = calcTransitionDelay(startTime, ctx.currentTime);
+    cancelTransition();
+    transitionTimerId = setTimeout(() => {
+      transitionTimerId = null;
+      if (disposed || !nextSource) return;
+      doTransition(buffer, nextStartCtxTime);
+    }, transitionDelay);
+  }
+  function handleSeek(buffer, offsetInChunk) {
+    playChunk(buffer, 0, offsetInChunk);
+  }
+  function pause() {
+    if (paused || stopped || disposed) return;
+    pausedPosition = getElapsedInChunk();
+    paused = true;
+    cancelTransition();
+    stopCurrentSource();
+    stopNextSource();
+    stopLookahead();
+  }
+  function resume() {
+    if (!paused || disposed) return;
+  }
+  function stop() {
+    if (stopped || disposed) return;
+    stopped = true;
+    paused = false;
+    pausedPosition = 0;
+    cancelTransition();
+    stopCurrentSource();
+    stopNextSource();
+    stopLookahead();
+  }
+  function getCurrentPosition() {
+    return getElapsedInChunk();
+  }
+  function hasNextScheduled() {
+    return nextSource !== null;
+  }
+  return {
+    playChunk,
+    scheduleNext,
+    hasNextScheduled,
+    handleSeek,
+    pause,
+    resume,
+    stop,
+    getCurrentPosition,
+    setOnChunkEnded(callback) {
+      onChunkEnded = callback;
+    },
+    setOnNeedNext(callback) {
+      onNeedNext = callback;
+    },
+    setOnTransition(callback) {
+      onTransition = callback;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      cancelTransition();
+      stopCurrentSource();
+      stopNextSource();
+      stopLookahead();
+    }
+  };
+}
 
 // src/stretcher/chunk-splitter.ts
 function splitIntoChunks(totalSamples, sampleRate, chunkDurationSec = CHUNK_DURATION_SEC, overlapSec = OVERLAP_SEC) {
@@ -84,9 +377,7 @@ function extractChunkData(buffer, chunk) {
   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)
-    );
+    chunkData.set(fullChannel.subarray(chunk.inputStartSample, chunk.inputEndSample));
     channels.push(chunkData);
   }
   return channels;
@@ -107,370 +398,273 @@ function getChunkIndexForTime(chunks, 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)));
-  }
-  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;
-    }
+// src/stretcher/priority-queue.ts
+function createPriorityQueue(compareFn) {
+  const heap = [];
+  function parent(i) {
+    return Math.floor((i - 1) / 2);
   }
-  return bestOffset;
-}
-
-function wsolaTimeStretch(channels, tempo, sampleRate) {
-  if (channels.length === 0) {
-    return { output: [], length: 0 };
+  function left(i) {
+    return 2 * i + 1;
   }
-
-  var inputLength = channels[0].length;
-  if (inputLength === 0) {
-    return { output: channels.map(function() { return new Float32Array(0); }), length: 0 };
+  function right(i) {
+    return 2 * i + 2;
   }
-
-  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
-    };
+  function swap(i, j) {
+    const tmp = heap[i];
+    heap[i] = heap[j];
+    heap[j] = tmp;
   }
-
-  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 siftUp(i) {
+    while (i > 0) {
+      const p = parent(i);
+      if (compareFn(heap[i], heap[p]) < 0) {
+        swap(i, p);
+        i = p;
+      } else {
+        break;
       }
     }
-
-    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 siftDown(i) {
+    const n = heap.length;
+    while (true) {
+      let smallest = i;
+      const l = left(i);
+      const r = right(i);
+      if (l < n && compareFn(heap[l], heap[smallest]) < 0) {
+        smallest = l;
+      }
+      if (r < n && compareFn(heap[r], heap[smallest]) < 0) {
+        smallest = r;
+      }
+      if (smallest !== i) {
+        swap(i, smallest);
+        i = smallest;
+      } else {
+        break;
       }
     }
-
-    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);
   }
-
-  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 heapify() {
+    for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
+      siftDown(i);
     }
   }
-
-  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;
-  }
-  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 });
+  return {
+    enqueue(item) {
+      heap.push(item);
+      siftUp(heap.length - 1);
+    },
+    dequeue() {
+      if (heap.length === 0) return void 0;
+      const min = heap[0];
+      const last = heap.pop();
+      if (heap.length > 0) {
+        heap[0] = last;
+        siftDown(0);
+      }
+      return min;
+    },
+    peek() {
+      return heap[0];
+    },
+    remove(predicate) {
+      const idx = heap.findIndex(predicate);
+      if (idx === -1) return false;
+      if (idx === heap.length - 1) {
+        heap.pop();
       } else {
-        self.postMessage(
-          { type: "result", chunkIndex: msg.chunkIndex, outputData: result.output, outputLength: result.length },
-          result.output.map(function(ch) { return ch.buffer; })
-        );
+        heap[idx] = heap.pop();
+        siftDown(idx);
+        siftUp(idx);
       }
-    } catch (err) {
-      self.postMessage({ type: "error", chunkIndex: msg.chunkIndex, error: String(err) });
+      return true;
+    },
+    rebuild() {
+      heapify();
+    },
+    clear() {
+      heap.length = 0;
+    },
+    size() {
+      return heap.length;
+    },
+    toArray() {
+      return [...heap];
     }
-  }
-};
-`;
-}
-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();
-    }
-    return workerURL;
-  }
-  function isAllDead() {
-    return slots.every((s) => s.worker === null);
+// src/stretcher/conversion-scheduler.ts
+function createConversionScheduler(chunks, workerManager, extractChunkData2, sampleRate, tempo, options, onChunkReady, onChunkFailed) {
+  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));
+  function isInActiveWindow(chunkIndex, playheadIndex) {
+    const dist = chunkIndex - playheadIndex;
+    return dist <= keepAhead && dist >= -keepBehind;
   }
-  function spawnWorkerForSlot(slot) {
-    if (terminated) return;
-    const url = ensureWorkerURL();
-    let worker;
-    try {
-      worker = new Worker(url);
-    } catch {
-      slot.worker = null;
-      return;
+  let currentTempo = tempo;
+  let currentChunkIdx = 0;
+  let previousTempoCache = null;
+  let disposed = false;
+  const queue = createPriorityQueue((a, b) => a.priority - b.priority);
+  function calcPriority(chunkIndex, playheadIndex) {
+    const distance = chunkIndex - playheadIndex;
+    if (distance >= 0) {
+      return distance * forwardWeight;
     }
-    worker.onmessage = (e) => {
-      const response = e.data;
-      if (response.type === "result" || response.type === "cancelled") {
-        slot.busy = false;
-        slot.currentChunkIndex = null;
+    return Math.abs(distance) * backwardWeight;
+  }
+  function updatePriorities(playheadIndex) {
+    currentChunkIdx = playheadIndex;
+    queue.clear();
+    for (const chunk of chunks) {
+      if (chunk.state === "pending" || chunk.state === "queued" || chunk.state === "failed") {
+        chunk.priority = calcPriority(chunk.index, playheadIndex);
+        chunk.state = "queued";
+        queue.enqueue(chunk);
+      } else if (chunk.state === "evicted" && isInActiveWindow(chunk.index, playheadIndex)) {
+        chunk.state = "queued";
+        chunk.retryCount = 0;
+        chunk.priority = calcPriority(chunk.index, playheadIndex);
+        queue.enqueue(chunk);
       }
-      if (response.type === "error") {
-        slot.busy = false;
-        slot.currentChunkIndex = null;
-        onError(response);
-        return;
+    }
+    for (const chunk of chunks) {
+      if (chunk.state === "converting") {
+        const dist = Math.abs(chunk.index - playheadIndex);
+        if (dist > cancelDistThreshold) {
+          workerManager.cancelChunk(chunk.index);
+        }
       }
-      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}`
-        });
+    }
+  }
+  function dispatchNext() {
+    if (disposed) return;
+    while (workerManager.hasCapacity()) {
+      let nextChunk = queue.dequeue();
+      while (nextChunk && nextChunk.state === "ready") {
+        nextChunk = queue.dequeue();
       }
-      if (slot.worker) {
-        slot.worker.onmessage = null;
-        slot.worker.onerror = null;
-        slot.worker.terminate();
-        slot.worker = null;
+      if (!nextChunk) return;
+      if (nextChunk.state !== "queued" && nextChunk.state !== "pending" && nextChunk.state !== "failed") {
+        continue;
       }
-      if (slot.crashCount < maxCrashes) {
-        spawnWorkerForSlot(slot);
-      } else {
-        onError({
-          type: "error",
-          chunkIndex: failedChunkIndex ?? -1,
-          error: `Worker crashed ${slot.crashCount} times, giving up`
-        });
-        if (isAllDead()) {
-          onAllDead?.();
+      nextChunk.state = "converting";
+      const data = extractChunkData2(nextChunk.index);
+      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;
+    onChunkReady?.(chunkIndex);
+    dispatchNext();
+  }
+  function handleError(chunkIndex, error) {
+    if (disposed) return;
+    const chunk = chunks[chunkIndex];
+    if (!chunk) return;
+    chunk.retryCount++;
+    if (chunk.retryCount < MAX_CHUNK_RETRIES) {
+      chunk.state = "queued";
+      chunk.priority = calcPriority(chunk.index, currentChunkIdx);
+      queue.enqueue(chunk);
+    } else {
+      chunk.state = "failed";
+      onChunkFailed?.(chunkIndex, error);
+    }
+    dispatchNext();
+  }
+  function handleSeek(newChunkIndex) {
+    for (const chunk of chunks) {
+      if (chunk.state === "converting") {
+        const dist = Math.abs(chunk.index - newChunkIndex);
+        if (dist > cancelDistThreshold) {
+          workerManager.cancelChunk(chunk.index);
         }
       }
-    };
-    slot.worker = worker;
+    }
+    updatePriorities(newChunkIndex);
+    dispatchNext();
   }
-  for (let i = 0; i < poolSize; i++) {
-    const slot = {
-      worker: null,
-      busy: false,
-      currentChunkIndex: null,
-      crashCount: 0
+  function handleTempoChange(newTempo) {
+    previousTempoCache = {
+      tempo: currentTempo,
+      chunks: chunks.map((c) => {
+        if (isInActiveWindow(c.index, currentChunkIdx) && c.outputBuffer) {
+          return { outputBuffer: c.outputBuffer, outputLength: c.outputLength };
+        }
+        return { outputBuffer: null, outputLength: 0 };
+      })
     };
-    slots.push(slot);
-    spawnWorkerForSlot(slot);
-  }
-  if (isAllDead()) {
-    onAllDead?.();
-  }
-  function findFreeSlot() {
-    for (const slot of slots) {
-      if (!slot.busy && slot.worker) {
-        return slot;
+    currentTempo = newTempo;
+    workerManager.cancelCurrent();
+    for (const chunk of chunks) {
+      if (chunk.state === "evicted") continue;
+      if (isInActiveWindow(chunk.index, currentChunkIdx)) {
+        chunk.outputBuffer = null;
+        chunk.outputLength = 0;
+        chunk.state = "pending";
+        chunk.retryCount = 0;
+      } else {
+        chunk.outputBuffer = null;
+        chunk.outputLength = 0;
+        chunk.state = "evicted";
       }
     }
-    return null;
+    updatePriorities(currentChunkIdx);
+    dispatchNext();
   }
-  function findSlotByChunk(chunkIndex) {
-    for (const slot of slots) {
-      if (slot.busy && slot.currentChunkIndex === chunkIndex) {
-        return slot;
+  function restorePreviousTempo() {
+    if (!previousTempoCache) return false;
+    currentTempo = previousTempoCache.tempo;
+    for (let i = 0; i < chunks.length; i++) {
+      const cached = previousTempoCache.chunks[i];
+      const chunk = chunks[i];
+      if (chunk && cached?.outputBuffer) {
+        chunk.outputBuffer = cached.outputBuffer;
+        chunk.outputLength = cached.outputLength;
+        chunk.state = "ready";
       }
     }
-    return null;
+    previousTempoCache = null;
+    workerManager.cancelCurrent();
+    updatePriorities(currentChunkIdx);
+    dispatchNext();
+    return true;
+  }
+  function start(playheadIndex) {
+    updatePriorities(playheadIndex);
+    dispatchNext();
   }
   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;
-    },
-    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;
+    start,
+    updatePriorities,
+    handleSeek,
+    handleTempoChange,
+    restorePreviousTempo,
+    dispatchNext,
+    getChunks: () => chunks,
+    dispose() {
+      disposed = true;
+      queue.clear();
     },
-    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();
-    }
+    // Expose internal handlers for the engine to wire up
+    _handleResult: handleResult,
+    _handleError: handleError
   };
 }
 
@@ -517,6 +711,13 @@ function wsolaTimeStretch(channels, tempo, _sampleRate, frameSize = WSOLA_FRAME_
   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;
@@ -527,9 +728,7 @@ function wsolaTimeStretch(channels, tempo, _sampleRate, frameSize = WSOLA_FRAME_
     };
   }
   const estimatedOutputLength = (numFrames - 1) * synthesisHop + frameSize;
-  const outputChannels = channels.map(
-    () => new Float32Array(estimatedOutputLength)
-  );
+  const outputChannels = channels.map(() => new Float32Array(estimatedOutputLength));
   const windowFunc = createHannWindow(frameSize);
   const normBuffer = new Float32Array(estimatedOutputLength);
   const prevOutputFrame = channels.map(() => new Float32Array(frameSize));
@@ -548,14 +747,8 @@ function wsolaTimeStretch(channels, tempo, _sampleRate, frameSize = WSOLA_FRAME_
         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 refSlice = refChannel.subarray(overlapStart, overlapStart + overlapSize);
+        const searchSlice = inputChannel.subarray(searchStart, searchEnd + overlapSize);
         const bestOffset = findBestOffset(
           refSlice,
           searchSlice,
@@ -576,7 +769,7 @@ function wsolaTimeStretch(channels, tempo, _sampleRate, frameSize = WSOLA_FRAME_
         if (outIdx >= estimatedOutputLength) break;
         const sample = input[inIdx];
         output[outIdx] += sample * windowFunc[i];
-        prevFrame[i] = sample;
+        prevFrame[i] = sample * windowFunc[i];
       }
     }
     for (let i = 0; i < frameSize; i++) {
@@ -597,9 +790,7 @@ function wsolaTimeStretch(channels, tempo, _sampleRate, frameSize = WSOLA_FRAME_
       }
     }
   }
-  const trimmedOutput = outputChannels.map(
-    (ch) => ch.subarray(0, actualOutputLength)
-  );
+  const trimmedOutput = outputChannels.map((ch) => ch.subarray(0, actualOutputLength));
   return { output: trimmedOutput, length: actualOutputLength };
 }
 
@@ -608,7 +799,7 @@ function createMainThreadProcessor(onResult, onError) {
   let terminated = false;
   const postTimes = /* @__PURE__ */ new Map();
   let currentChunkIndex = null;
-  let cancelledChunks = /* @__PURE__ */ new Set();
+  const cancelledChunks = /* @__PURE__ */ new Set();
   let busy = false;
   return {
     postConvert(chunkIndex, inputData, tempo, sampleRate) {
@@ -681,569 +872,412 @@ function createMainThreadProcessor(onResult, onError) {
       }
       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 swap(i, j) {
-    const tmp = heap[i];
-    heap[i] = heap[j];
-    heap[j] = tmp;
-  }
-  function siftUp(i) {
-    while (i > 0) {
-      const p = parent(i);
-      if (compareFn(heap[i], heap[p]) < 0) {
-        swap(i, p);
-        i = p;
-      } else {
-        break;
-      }
-    }
-  }
-  function siftDown(i) {
-    const n = heap.length;
-    while (true) {
-      let smallest = i;
-      const l = left(i);
-      const r = right(i);
-      if (l < n && compareFn(heap[l], heap[smallest]) < 0) {
-        smallest = l;
-      }
-      if (r < n && compareFn(heap[r], heap[smallest]) < 0) {
-        smallest = r;
-      }
-      if (smallest !== i) {
-        swap(i, smallest);
-        i = smallest;
-      } else {
-        break;
-      }
-    }
-  }
-  function heapify() {
-    for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
-      siftDown(i);
-    }
-  }
-  return {
-    enqueue(item) {
-      heap.push(item);
-      siftUp(heap.length - 1);
-    },
-    dequeue() {
-      if (heap.length === 0) return void 0;
-      const min = heap[0];
-      const last = heap.pop();
-      if (heap.length > 0) {
-        heap[0] = last;
-        siftDown(0);
-      }
-      return min;
-    },
-    peek() {
-      return heap[0];
-    },
-    remove(predicate) {
-      const idx = heap.findIndex(predicate);
-      if (idx === -1) return false;
-      if (idx === heap.length - 1) {
-        heap.pop();
-      } else {
-        heap[idx] = heap.pop();
-        siftDown(idx);
-        siftUp(idx);
-      }
-      return true;
-    },
-    rebuild() {
-      heapify();
-    },
-    clear() {
-      heap.length = 0;
-    },
-    size() {
-      return heap.length;
+    getPostTimeForChunk(chunkIndex) {
+      return postTimes.get(chunkIndex) ?? null;
     },
-    toArray() {
-      return [...heap];
+    terminate() {
+      if (terminated) return;
+      terminated = true;
+      cancelledChunks.clear();
+      postTimes.clear();
     }
   };
 }
 
-// src/stretcher/conversion-scheduler.ts
-function createConversionScheduler(chunks, workerManager, extractChunkData2, sampleRate, tempo, options, onChunkReady, onChunkFailed) {
-  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)
-  );
-  function isInActiveWindow(chunkIndex, playheadIndex) {
-    const dist = chunkIndex - playheadIndex;
-    return dist <= keepAhead && dist >= -keepBehind;
-  }
-  let currentTempo = tempo;
-  let currentChunkIdx = 0;
-  let previousTempoCache = null;
-  let disposed = false;
-  const queue = createPriorityQueue(
-    (a, b) => a.priority - b.priority
-  );
-  function calcPriority(chunkIndex, playheadIndex) {
-    const distance = chunkIndex - playheadIndex;
-    if (distance >= 0) {
-      return distance * forwardWeight;
-    }
-    return Math.abs(distance) * backwardWeight;
+// 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)));
   }
-  function updatePriorities(playheadIndex) {
-    currentChunkIdx = playheadIndex;
-    queue.clear();
-    for (const chunk of chunks) {
-      if (chunk.state === "pending" || chunk.state === "queued" || chunk.state === "failed") {
-        chunk.priority = calcPriority(chunk.index, playheadIndex);
-        chunk.state = "queued";
-        queue.enqueue(chunk);
-      } else if (chunk.state === "evicted" && isInActiveWindow(chunk.index, playheadIndex)) {
-        chunk.state = "queued";
-        chunk.retryCount = 0;
-        chunk.priority = calcPriority(chunk.index, playheadIndex);
-        queue.enqueue(chunk);
-      }
-    }
-    for (const chunk of chunks) {
-      if (chunk.state === "converting") {
-        const dist = Math.abs(chunk.index - playheadIndex);
-        if (dist > cancelDistThreshold) {
-          workerManager.cancelChunk(chunk.index);
-        }
-      }
+  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 dispatchNext() {
-    if (disposed) return;
-    while (workerManager.hasCapacity()) {
-      let nextChunk = queue.dequeue();
-      while (nextChunk && nextChunk.state === "ready") {
-        nextChunk = queue.dequeue();
-      }
-      if (!nextChunk) return;
-      if (nextChunk.state !== "queued" && nextChunk.state !== "pending" && nextChunk.state !== "failed") {
-        continue;
-      }
-      nextChunk.state = "converting";
-      const data = extractChunkData2(nextChunk.index);
-      workerManager.postConvert(
-        nextChunk.index,
-        data,
-        currentTempo,
-        sampleRate
-      );
+    var denom = Math.sqrt(normRef * normSearch);
+    var ncc = denom > 1e-10 ? corr / denom : 0;
+    if (ncc > bestCorr) {
+      bestCorr = ncc;
+      bestOffset = offset;
     }
   }
-  function handleResult(chunkIndex, outputData, outputLength) {
-    const chunk = chunks[chunkIndex];
-    if (!chunk) return;
-    chunk.state = "ready";
-    chunk.outputBuffer = outputData;
-    chunk.outputLength = outputLength;
-    onChunkReady?.(chunkIndex);
-    dispatchNext();
-  }
-  function handleError(chunkIndex, error) {
-    const chunk = chunks[chunkIndex];
-    if (!chunk) return;
-    chunk.retryCount++;
-    if (chunk.retryCount < MAX_CHUNK_RETRIES) {
-      chunk.state = "queued";
-      chunk.priority = calcPriority(chunk.index, currentChunkIdx);
-      queue.enqueue(chunk);
-    } else {
-      chunk.state = "failed";
-      onChunkFailed?.(chunkIndex, error);
-    }
-    dispatchNext();
+  return bestOffset;
+}
+
+function wsolaTimeStretch(channels, tempo, sampleRate) {
+  if (channels.length === 0) {
+    return { output: [], length: 0 };
   }
-  function handleSeek(newChunkIndex) {
-    for (const chunk of chunks) {
-      if (chunk.state === "converting") {
-        const dist = Math.abs(chunk.index - newChunkIndex);
-        if (dist > cancelDistThreshold) {
-          workerManager.cancelChunk(chunk.index);
-        }
-      }
-    }
-    updatePriorities(newChunkIndex);
-    dispatchNext();
+
+  var inputLength = channels[0].length;
+  if (inputLength === 0) {
+    return { output: channels.map(function() { return new Float32Array(0); }), length: 0 };
   }
-  function handleTempoChange(newTempo) {
-    previousTempoCache = {
-      tempo: currentTempo,
-      chunks: chunks.map((c) => {
-        if (isInActiveWindow(c.index, currentChunkIdx) && c.outputBuffer) {
-          return { outputBuffer: c.outputBuffer, outputLength: c.outputLength };
-        }
-        return { outputBuffer: null, outputLength: 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
     };
-    currentTempo = newTempo;
-    workerManager.cancelCurrent();
-    for (const chunk of chunks) {
-      if (chunk.state === "evicted") continue;
-      if (isInActiveWindow(chunk.index, currentChunkIdx)) {
-        chunk.outputBuffer = null;
-        chunk.outputLength = 0;
-        chunk.state = "pending";
-        chunk.retryCount = 0;
-      } else {
-        chunk.outputBuffer = null;
-        chunk.outputLength = 0;
-        chunk.state = "evicted";
-      }
-    }
-    updatePriorities(currentChunkIdx);
-    dispatchNext();
-  }
-  function restorePreviousTempo() {
-    if (!previousTempoCache) return false;
-    currentTempo = previousTempoCache.tempo;
-    for (let i = 0; i < chunks.length; i++) {
-      const cached = previousTempoCache.chunks[i];
-      const chunk = chunks[i];
-      if (chunk && cached?.outputBuffer) {
-        chunk.outputBuffer = cached.outputBuffer;
-        chunk.outputLength = cached.outputLength;
-        chunk.state = "ready";
-      }
-    }
-    previousTempoCache = null;
-    workerManager.cancelCurrent();
-    updatePriorities(currentChunkIdx);
-    dispatchNext();
-    return true;
   }
-  function start(playheadIndex) {
-    updatePriorities(playheadIndex);
-    dispatchNext();
+
+  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
+    };
   }
-  return {
-    start,
-    updatePriorities,
-    handleSeek,
-    handleTempoChange,
-    restorePreviousTempo,
-    dispatchNext,
-    getChunks: () => chunks,
-    dispose() {
-      disposed = true;
-      queue.clear();
-    },
-    // Expose internal handlers for the engine to wire up
-    _handleResult: handleResult,
-    _handleError: handleError
-  };
-}
 
-// 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]);
+  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);
+    };
+    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?.();
+        }
       }
     };
-    currentSource.start(0, offsetInChunk);
-    if (crossfadeSec > 0) {
-      currentGain.gain.setValueCurveAtTime(fadeInCurve, ctx.currentTime, crossfadeSec);
-    }
-    startLookahead();
+    slot.worker = worker;
   }
-  function scheduleNext(buffer, startTime) {
-    if (disposed) return;
-    stopNextSource();
-    nextGain = ctx.createGain();
-    nextSource = createSourceFromBuffer(buffer, nextGain);
-    nextSource.onended = () => {
-      if (!disposed && !paused && !stopped) {
-        onChunkEnded?.();
-      }
+  for (let i = 0; i < poolSize; i++) {
+    const slot = {
+      worker: null,
+      busy: false,
+      currentChunkIndex: null,
+      crashCount: 0
     };
-    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();
-  }
-  function resume() {
-    if (!paused || disposed) return;
+    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
   };
 }
 
@@ -1254,7 +1288,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;
@@ -1290,14 +1324,15 @@ function createStretcherEngine(ctx, buffer, options) {
   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) {
@@ -1313,11 +1348,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];
@@ -1330,10 +1361,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() {
@@ -1369,26 +1397,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;
@@ -1407,21 +1443,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(
@@ -1441,23 +1468,19 @@ 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;
@@ -1486,6 +1509,7 @@ function createStretcherEngine(ctx, buffer, options) {
       return;
     }
     currentChunkIndex = nextIdx;
+    nextChunkScheduledIndex = null;
     scheduler.updatePriorities(currentChunkIndex);
     const chunk = chunks[currentChunkIndex];
     if (chunk && chunk.state === "ready") {
@@ -1503,6 +1527,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 });
   }
@@ -1564,26 +1589,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,
@@ -1607,9 +1628,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;
@@ -1644,12 +1663,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(resumePosition);
+      playCurrentChunk(resumePosition, true);
     } else {
       enterBuffering("underrun");
     }
@@ -1659,6 +1703,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") {
@@ -1675,10 +1720,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() {
@@ -1689,18 +1740,39 @@ function createStretcherEngine(ctx, buffer, options) {
   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();
@@ -1723,6 +1795,6 @@ function createStretcherEngine(ctx, buffer, options) {
   };
 }
 
-export { createStretcherEngine };
-//# sourceMappingURL=chunk-2FFORBOP.js.map
-//# sourceMappingURL=chunk-2FFORBOP.js.map
+export { createStretcherEngine, trimOverlap };
+//# sourceMappingURL=chunk-GDBOHOGF.js.map
+//# sourceMappingURL=chunk-GDBOHOGF.js.map