waa-play 0.1.0

package/dist/chunk-V2QX5K42.js

@@ -0,0 +1,1708 @@
+import { createEmitter } from './chunk-GYH2JSCY.js';
+
+// src/stretcher/constants.ts
+var CHUNK_DURATION_SEC = 8;
+var OVERLAP_SEC = 0.2;
+var CROSSFADE_SEC = 0.1;
+var WSOLA_FRAME_SIZE = 1024;
+var WSOLA_HOP_SIZE = 512;
+var WSOLA_TOLERANCE = 2048;
+var PRIORITY_FORWARD_WEIGHT = 1;
+var PRIORITY_BACKWARD_WEIGHT = 2.5;
+var CANCEL_DISTANCE_THRESHOLD = 6;
+var BUFFER_HEALTHY_SEC = 30;
+var BUFFER_LOW_SEC = 10;
+var BUFFER_CRITICAL_SEC = 3;
+var BUFFER_RESUME_SEC = 5;
+var KEEP_AHEAD_CHUNKS = 19;
+var KEEP_AHEAD_SECONDS = 150;
+var KEEP_BEHIND_CHUNKS = 8;
+var KEEP_BEHIND_SECONDS = 60;
+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;
+
+// src/stretcher/chunk-splitter.ts
+function splitIntoChunks(totalSamples, sampleRate, chunkDurationSec = CHUNK_DURATION_SEC, overlapSec = OVERLAP_SEC) {
+  if (totalSamples <= 0 || sampleRate <= 0) {
+    return [];
+  }
+  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 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 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)));
+  }
+  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 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;
+      }
+    }
+
+    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;
+      }
+    }
+
+    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;
+      }
+    }
+  }
+
+  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 });
+      } 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 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);
+  }
+  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;
+  }
+  for (let i = 0; i < poolSize; i++) {
+    const slot = {
+      worker: null,
+      busy: false,
+      currentChunkIndex: null,
+      crashCount: 0
+    };
+    slots.push(slot);
+    spawnWorkerForSlot(slot);
+  }
+  if (isAllDead()) {
+    onAllDead?.();
+  }
+  function findFreeSlot() {
+    for (const slot of slots) {
+      if (!slot.busy && slot.worker) {
+        return slot;
+      }
+    }
+    return null;
+  }
+  function findSlotByChunk(chunkIndex) {
+    for (const slot of slots) {
+      if (slot.busy && slot.currentChunkIndex === chunkIndex) {
+        return slot;
+      }
+    }
+    return 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;
+    },
+    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();
+    }
+  };
+}
+
+// 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 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 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;
+    },
+    toArray() {
+      return [...heap];
+    }
+  };
+}
+
+// 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;
+  }
+  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);
+        }
+      }
+    }
+  }
+  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
+      );
+    }
+  }
+  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();
+  }
+  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();
+  }
+  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 };
+      })
+    };
+    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();
+  }
+  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]);
+      }
+      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 getElapsedInChunk() {
+    if (paused) return pausedPosition;
+    if (stopped) return 0;
+    return ctx.currentTime - playStartCtxTime + playStartOffset;
+  }
+  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?.();
+      }
+    };
+    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?.();
+      }
+    };
+    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;
+    paused = false;
+  }
+  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/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/engine.ts
+function trimOverlap(outputData, outputLength, chunk, sampleRate) {
+  const inputLength = chunk.inputEndSample - chunk.inputStartSample;
+  if (inputLength === 0 || outputLength === 0) {
+    return { data: outputData, length: outputLength };
+  }
+  const ratio = outputLength / inputLength;
+  const crossfadeKeep = Math.round(CROSSFADE_SEC * sampleRate);
+  const overlapBeforeOutput = Math.round(chunk.overlapBefore * ratio);
+  const overlapAfterOutput = Math.round(chunk.overlapAfter * ratio);
+  const keepBefore = chunk.overlapBefore > 0 ? Math.min(crossfadeKeep, overlapBeforeOutput) : 0;
+  const trimStart = overlapBeforeOutput - keepBefore;
+  const trimEnd = overlapAfterOutput;
+  const newLength = outputLength - trimStart - trimEnd;
+  if (newLength <= 0) {
+    return { data: outputData, length: outputLength };
+  }
+  return {
+    data: outputData.map((ch) => ch.slice(trimStart, trimStart + newLength)),
+    length: newLength
+  };
+}
+function getCrossfadeStart(chunk) {
+  return chunk.overlapBefore > 0 ? CROSSFADE_SEC : 0;
+}
+function createStretcherEngine(ctx, buffer, options) {
+  const {
+    tempo: initialTempo,
+    offset = 0,
+    through = [],
+    destination = ctx.destination
+  } = options;
+  const emitter = createEmitter();
+  const sampleRate = buffer.sampleRate;
+  const totalDuration = buffer.duration;
+  let phase = "waiting";
+  let currentTempo = initialTempo;
+  let disposed = false;
+  let bufferingStartTime = 0;
+  let currentChunkIndex = 0;
+  let bufferingResumePosition = null;
+  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 monitor = createBufferMonitor();
+  const poolSize = options.workerPoolSize ?? WORKER_POOL_SIZE;
+  function handleWorkerResult(response) {
+    if (disposed) return;
+    if (response.type === "result") {
+      const chunk = chunks[response.chunkIndex];
+      if (chunk) {
+        const postTime = workerManager.getPostTimeForChunk(response.chunkIndex);
+        postTime !== null ? performance.now() - postTime : 0;
+        const trimmed = trimOverlap(
+          response.outputData,
+          response.outputLength,
+          chunk,
+          sampleRate
+        );
+        schedulerInternal._handleResult(
+          response.chunkIndex,
+          trimmed.data,
+          trimmed.length
+        );
+      }
+    } else if (response.type === "cancelled") {
+      const chunk = chunks[response.chunkIndex];
+      if (chunk && chunk.state === "converting") {
+        chunk.state = "queued";
+      }
+      scheduler.dispatchNext();
+    }
+  }
+  function handleWorkerError(response) {
+    if (disposed) return;
+    if (response.type === "error") {
+      schedulerInternal._handleError(
+        response.chunkIndex,
+        response.error ?? "Unknown error"
+      );
+    }
+  }
+  function switchToMainThread() {
+    if (disposed) return;
+    const fallback = createMainThreadProcessor(handleWorkerResult, handleWorkerError);
+    workerManager.terminate();
+    Object.assign(workerManager, fallback);
+  }
+  const workerManager = createWorkerManager(
+    handleWorkerResult,
+    handleWorkerError,
+    void 0,
+    poolSize,
+    switchToMainThread
+  );
+  const schedulerInternal = createConversionScheduler(
+    chunks,
+    workerManager,
+    (chunkIndex) => extractChunkData(buffer, chunks[chunkIndex]),
+    sampleRate,
+    currentTempo,
+    { keepAheadChunks: keepAhead, keepBehindChunks: keepBehind },
+    onChunkReady,
+    onChunkFailed
+  );
+  const scheduler = schedulerInternal;
+  const chunkPlayer = createChunkPlayer(ctx, {
+    through,
+    destination,
+    crossfadeSec: CROSSFADE_SEC
+  });
+  chunkPlayer.setOnChunkEnded(() => {
+    if (disposed || phase === "paused" || phase === "ended") return;
+    advanceToNextChunk();
+  });
+  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);
+        }
+      }
+    }
+  });
+  chunkPlayer.setOnTransition(() => {
+    if (disposed) return;
+    const nextIdx = currentChunkIndex + 1;
+    if (nextIdx < chunks.length) {
+      currentChunkIndex = nextIdx;
+      scheduler.updatePriorities(currentChunkIndex);
+      evictDistantChunks();
+    }
+  });
+  function onChunkReady(chunkIndex) {
+    if (disposed) return;
+    emitter.emit("chunkready", { index: chunkIndex });
+    emitProgress();
+    emitBufferHealth();
+    if (phase === "waiting" || phase === "buffering") {
+      if (monitor.shouldExitBuffering(currentChunkIndex, chunks)) {
+        exitBuffering();
+      }
+    }
+    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 allDone = chunks.every(
+      (c) => c.state === "ready" || c.state === "skipped" || c.state === "evicted"
+    );
+    if (allDone) {
+      emitter.emit("complete", void 0);
+    }
+    evictDistantChunks();
+  }
+  function onChunkFailed(chunkIndex, error) {
+    if (disposed) return;
+    const chunk = chunks[chunkIndex];
+    const fatal = chunk ? chunk.retryCount >= 3 : true;
+    emitter.emit("error", { message: error, chunkIndex, fatal });
+  }
+  function createAudioBufferFromChunk(chunk) {
+    if (!chunk.outputBuffer || chunk.outputLength === 0) return null;
+    const numChannels = chunk.outputBuffer.length;
+    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) {
+    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);
+  }
+  function advanceToNextChunk() {
+    const nextIdx = currentChunkIndex + 1;
+    if (nextIdx >= chunks.length) {
+      phase = "ended";
+      chunkPlayer.stop();
+      emitter.emit("ended", void 0);
+      emitter.emit("bufferhealth", {
+        health: monitor.getHealth(currentChunkIndex, chunks),
+        aheadSeconds: monitor.getAheadSeconds(currentChunkIndex, chunks)
+      });
+      return;
+    }
+    currentChunkIndex = nextIdx;
+    scheduler.updatePriorities(currentChunkIndex);
+    const chunk = chunks[currentChunkIndex];
+    if (chunk && chunk.state === "ready") {
+      playCurrentChunk(getCrossfadeStart(chunk));
+    } else {
+      const nextChunk = chunks[currentChunkIndex];
+      const nominalStartSample = nextChunk.inputStartSample + nextChunk.overlapBefore;
+      bufferingResumePosition = nominalStartSample / sampleRate;
+      enterBuffering("underrun");
+    }
+    evictDistantChunks();
+  }
+  function enterBuffering(reason) {
+    if (phase === "ended") return;
+    if (phase === "buffering" && reason !== "tempo-change" && reason !== "seek") return;
+    phase = "buffering";
+    bufferingStartTime = performance.now();
+    chunkPlayer.pause();
+    emitter.emit("buffering", { reason });
+  }
+  function exitBuffering() {
+    const stallDuration = performance.now() - bufferingStartTime;
+    phase = "playing";
+    emitter.emit("buffered", { stallDuration });
+    if (bufferingResumePosition !== null) {
+      const resumePos = bufferingResumePosition;
+      bufferingResumePosition = null;
+      const chunk = chunks[currentChunkIndex];
+      if (chunk && chunk.state === "ready" && chunk.outputBuffer) {
+        const nominalStartSample = chunk.inputStartSample + chunk.overlapBefore;
+        const nominalStartSec = nominalStartSample / sampleRate;
+        const offsetInOriginal = resumePos - nominalStartSec;
+        const offsetInOutput = Math.max(0, offsetInOriginal / currentTempo);
+        const outputDurationSec = chunk.outputLength / sampleRate;
+        const MIN_PLAYABLE_SEC = 0.05;
+        if (outputDurationSec > 0 && offsetInOutput >= outputDurationSec - MIN_PLAYABLE_SEC) {
+          advanceToNextChunk();
+          return;
+        }
+        playCurrentChunk(getCrossfadeStart(chunk) + offsetInOutput);
+      } else {
+        const cfChunk = chunks[currentChunkIndex];
+        const cfStart = cfChunk ? getCrossfadeStart(cfChunk) : 0;
+        playCurrentChunk(cfStart);
+      }
+    } else {
+      const chunk = chunks[currentChunkIndex];
+      const cfStart = chunk ? getCrossfadeStart(chunk) : 0;
+      playCurrentChunk(cfStart);
+    }
+  }
+  function evictDistantChunks() {
+    for (const chunk of chunks) {
+      if (chunk.state !== "ready") continue;
+      const dist = chunk.index - currentChunkIndex;
+      if (dist > keepAhead || dist < -keepBehind) {
+        chunk.outputBuffer = null;
+        chunk.outputLength = 0;
+        chunk.state = "evicted";
+      }
+    }
+  }
+  function emitProgress() {
+    const readyCount = chunks.filter((c) => c.state === "ready").length;
+    const total = chunks.length;
+    emitter.emit("progress", {
+      total,
+      ready: readyCount,
+      progress: total > 0 ? readyCount / total : 0
+    });
+  }
+  function emitBufferHealth() {
+    emitter.emit("bufferhealth", {
+      health: monitor.getHealth(currentChunkIndex, chunks),
+      aheadSeconds: monitor.getAheadSeconds(currentChunkIndex, chunks)
+    });
+  }
+  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);
+  }
+  function getStatus() {
+    const readyCount = chunks.filter((c) => c.state === "ready").length;
+    const convertingCount = chunks.filter(
+      (c) => c.state === "converting"
+    ).length;
+    const total = chunks.length;
+    return {
+      phase,
+      conversion: {
+        total,
+        ready: readyCount,
+        converting: convertingCount,
+        progress: total > 0 ? readyCount / total : 0
+      },
+      buffer: {
+        health: monitor.getHealth(currentChunkIndex, chunks),
+        aheadSeconds: monitor.getAheadSeconds(currentChunkIndex, chunks)
+      },
+      playback: {
+        position: getPositionInOriginalBuffer(),
+        duration: totalDuration,
+        tempo: currentTempo
+      }
+    };
+  }
+  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 windowStart = Math.max(0, currentChunkIndex - keepBehind);
+    const windowEnd = Math.min(total - 1, currentChunkIndex + keepAhead);
+    const windowSize = windowEnd - windowStart + 1;
+    const readyInWindow = chunks.slice(windowStart, windowEnd + 1).filter((c) => c.state === "ready").length;
+    return {
+      tempo: currentTempo,
+      converting: convertingCount > 0,
+      conversionProgress: total > 0 ? readyCount / total : 0,
+      bufferHealth: monitor.getHealth(currentChunkIndex, chunks),
+      aheadSeconds: monitor.getAheadSeconds(currentChunkIndex, chunks),
+      buffering: phase === "buffering" || phase === "waiting",
+      chunkStates: chunks.map((c) => c.state),
+      currentChunkIndex,
+      activeWindowStart: windowStart,
+      activeWindowEnd: windowEnd,
+      totalChunks: total,
+      windowConversionProgress: windowSize > 0 ? readyInWindow / windowSize : 0
+    };
+  }
+  function start() {
+    if (disposed) return;
+    currentChunkIndex = getChunkIndexForTime(chunks, offset, sampleRate);
+    bufferingResumePosition = offset;
+    phase = "waiting";
+    enterBuffering("initial");
+    scheduler.start(currentChunkIndex);
+  }
+  function pause() {
+    if (disposed || phase === "ended") return;
+    phase = "paused";
+    chunkPlayer.pause();
+  }
+  function resume() {
+    if (disposed || phase !== "paused") return;
+    const chunk = chunks[currentChunkIndex];
+    if (chunk && chunk.state === "ready") {
+      phase = "playing";
+      chunkPlayer.resume();
+      playCurrentChunk(chunkPlayer.getCurrentPosition());
+    } else {
+      enterBuffering("underrun");
+    }
+  }
+  function seek(position) {
+    if (disposed) return;
+    const clamped = Math.max(0, Math.min(position, totalDuration));
+    const newChunkIdx = getChunkIndexForTime(chunks, clamped, sampleRate);
+    currentChunkIndex = newChunkIdx;
+    scheduler.handleSeek(newChunkIdx);
+    const chunk = chunks[newChunkIdx];
+    if (chunk && chunk.state === "ready") {
+      const nominalStartSample = chunk.inputStartSample + chunk.overlapBefore;
+      const nominalStartSec = nominalStartSample / sampleRate;
+      const offsetInOriginal = clamped - nominalStartSec;
+      const offsetInOutput = offsetInOriginal / currentTempo;
+      if (phase === "playing" || phase === "buffering" || phase === "waiting") {
+        phase = "playing";
+        const audioBuf = createAudioBufferFromChunk(chunk);
+        if (audioBuf) {
+          const crossfadeStart = getCrossfadeStart(chunk);
+          const bufferOffset = crossfadeStart + offsetInOutput;
+          const clampedOffset = Math.min(Math.max(0, bufferOffset), audioBuf.duration - 1e-3);
+          chunkPlayer.handleSeek(audioBuf, clampedOffset);
+        }
+      }
+    } else {
+      bufferingResumePosition = clamped;
+      enterBuffering("seek");
+    }
+  }
+  function stop() {
+    if (disposed) return;
+    phase = "ended";
+    chunkPlayer.stop();
+  }
+  function setTempo(newTempo) {
+    if (disposed || phase === "ended" || newTempo === currentTempo) return;
+    bufferingResumePosition = getPositionInOriginalBuffer();
+    currentChunkIndex = getChunkIndexForTime(chunks, bufferingResumePosition, sampleRate);
+    currentTempo = newTempo;
+    enterBuffering("tempo-change");
+    scheduler.updatePriorities(currentChunkIndex);
+    scheduler.handleTempoChange(newTempo);
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    chunkPlayer.dispose();
+    scheduler.dispose();
+    workerManager.terminate();
+    emitter.clear();
+  }
+  return {
+    start,
+    pause,
+    resume,
+    seek,
+    stop,
+    setTempo,
+    getCurrentPosition: getPositionInOriginalBuffer,
+    getStatus,
+    getSnapshot,
+    on: emitter.on.bind(emitter),
+    off: emitter.off.bind(emitter),
+    dispose
+  };
+}
+
+export { createStretcherEngine };
+//# sourceMappingURL=chunk-V2QX5K42.js.map
+//# sourceMappingURL=chunk-V2QX5K42.js.map