@buffered-audio/nodes 0.23.0 → 0.24.2

package/dist/index.js

@@ -1,15 +1,16 @@
-import { __commonJS, __export, __toESM, deinterleaveBuffer, TruePeakAccumulator, LoudnessAccumulator, AmplitudeHistogramAccumulator, hanningWindow, createFftWorkspace, detectFftBackend, getFftAddon, interleave, IntegratedLufsAccumulator, initFftBackend, linearToDb, stft, applyDfttSmoothing, istft, ResampleStream, bandpass, MixedRadixFft, fft, TruePeakUpsampler, SlidingWindowMaxStream, getLraConsideredStats, BidirectionalIir, applyNlmSmoothingRange, dbToLinear, SlidingWindowMinStream } from './chunk-YJWZP2OD.js';
+import { __commonJS, __export, __toESM, deinterleaveBuffer, TruePeakAccumulator, LoudnessAccumulator, AmplitudeHistogramAccumulator, hanningWindow, createFftWorkspace, detectFftBackend, getFftAddon, interleave, IntegratedLufsAccumulator, initFftBackend, linearToDb, stft, applyDfttSmoothing, istft, bandpass, MixedRadixFft, fft, TruePeakUpsampler, SlidingWindowMaxStream, getLraConsideredStats, BidirectionalIir, applyNlmSmoothingRange, dbToLinear, SlidingWindowMinStream } from './chunk-BKEMKXGG.js';
 import path, { extname, join } from 'path';
 import { spawn } from 'child_process';
+import { open, stat, readFile, unlink, mkdtemp, writeFile, rm } from 'fs/promises';
+import { Readable } from 'stream';
 import { randomUUID } from 'crypto';
 import { createWriteStream, createReadStream, existsSync } from 'fs';
-import { open, stat, readFile, unlink, mkdtemp, writeFile, rm } from 'fs/promises';
 import os, { tmpdir } from 'os';
-import { Readable } from 'stream';
 import { EventEmitter } from 'events';
 import { fileURLToPath } from 'url';
 import { Worker } from 'worker_threads';
 import { createRequire } from 'module';
+import { StringDecoder } from 'string_decoder';
 
 // ../../node_modules/wavefile/dist/wavefile.js
 var require_wavefile = __commonJS({
@@ -15548,30 +15549,96 @@ var __export2 = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var HIGH_WATER_MARK = 10 * 1024 * 1024;
-var REVERSE_STRIPE_BYTES = 10 * 1024 * 1024;
-function deinterleave(buf, channels) {
+var BufferedStream = class {
+  constructor(node, context) {
+    this.processingMs = 0;
+    this.destroyed = false;
+    this.node = node;
+    this.events = context.events;
+    const constructor = node.constructor;
+    this.identity = { nodeName: constructor.nodeName, nodeId: node.id, streamId: context.nextStreamId() };
+  }
+  get properties() {
+    return this.node.properties;
+  }
+  emitStarted() {
+    this.events.emit("started", this.identity, { createdAt: Date.now() });
+  }
+  emitFinished(payload) {
+    this.events.emit("finished", this.identity, { ...payload, createdAt: Date.now() });
+  }
+  emitProgress(phase2, framesDone, framesTotal) {
+    this.events.emit("progress", this.identity, { phase: phase2, framesDone, framesTotal, createdAt: Date.now() });
+  }
+  log(message, data, level = "info") {
+    this.events.emit("log", this.identity, { level, message, data, createdAt: Date.now() });
+  }
+  async *timed(source) {
+    const iterator = (async function* () {
+      yield* source;
+    })();
+    try {
+      for (; ; ) {
+        const start = performance.now();
+        const result = await iterator.next();
+        this.processingMs += performance.now() - start;
+        if (result.done) return;
+        yield result.value;
+      }
+    } finally {
+      await iterator.return();
+    }
+  }
+  async destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    await this._destroy();
+  }
+  _destroy() {
+    return;
+  }
+};
+var PROGRESS_PERCENT_QUANTUM = 0.01;
+var PROGRESS_MIN_INTERVAL_MS = 1e4;
+function createProgressGate(framesTotal) {
+  let lastBucket = -1;
+  let lastEmitAt;
+  return (framesDone, now) => {
+    const bucket = framesTotal !== void 0 ? Math.floor(framesDone / framesTotal / PROGRESS_PERCENT_QUANTUM) : void 0;
+    const bucketAdvanced = bucket === void 0 || bucket > lastBucket;
+    const intervalPassed = lastEmitAt === void 0 || now - lastEmitAt >= PROGRESS_MIN_INTERVAL_MS;
+    if (!bucketAdvanced || !intervalPassed) return false;
+    if (bucket !== void 0) lastBucket = bucket;
+    lastEmitAt = now;
+    return true;
+  };
+}
+async function awaitStreamClose(stream) {
+  if (stream.closed) return;
+  await new Promise((resolve) => {
+    stream.once("close", () => resolve());
+  });
+}
+function deinterleave(buffer, channels) {
   const bytesPerFrame = channels * 4;
-  const frames = Math.floor(buf.length / bytesPerFrame);
-  const interleaved = new Float32Array(buf.buffer, buf.byteOffset, frames * channels);
-  const out = [];
-  for (let ch = 0; ch < channels; ch++) out.push(new Float32Array(frames));
+  const frames = Math.floor(buffer.length / bytesPerFrame);
+  const interleaved = new Float32Array(buffer.buffer, buffer.byteOffset, frames * channels);
+  const samples = [];
+  for (let channel = 0; channel < channels; channel++) samples.push(new Float32Array(frames));
   for (let frame = 0; frame < frames; frame++) {
     const base = frame * channels;
-    for (let ch = 0; ch < channels; ch++) {
-      out[ch][frame] = interleaved[base + ch];
-    }
+    for (let channel = 0; channel < channels; channel++) samples[channel][frame] = interleaved[base + channel];
   }
-  return out;
+  return samples;
 }
 function buildBlock(samples, offset, sampleRate, bitDepth) {
   return { samples, offset, sampleRate: sampleRate ?? 0, bitDepth: bitDepth ?? 0 };
 }
-async function pullBytes(rs, isEnded, bytesNeeded) {
+async function pullBytes(stream, isEnded, bytesNeeded) {
   const chunks = [];
   let collected = 0;
   while (collected < bytesNeeded) {
-    const chunk = rs.read();
+    const chunk = stream.read();
     if (chunk !== null) {
       const remaining = bytesNeeded - collected;
       if (chunk.length <= remaining) {
@@ -15580,35 +15647,154 @@ async function pullBytes(rs, isEnded, bytesNeeded) {
       } else {
         chunks.push(chunk.subarray(0, remaining));
         collected += remaining;
-        rs.unshift(chunk.subarray(remaining));
+        stream.unshift(chunk.subarray(remaining));
       }
       continue;
     }
     if (isEnded()) break;
     await new Promise((resolve) => {
       const wake = () => {
-        rs.off("readable", wake);
-        rs.off("end", wake);
-        rs.off("error", wake);
-        rs.off("close", wake);
+        stream.off("readable", wake);
+        stream.off("end", wake);
+        stream.off("error", wake);
+        stream.off("close", wake);
         resolve();
       };
-      rs.once("readable", wake);
-      rs.once("end", wake);
-      rs.once("error", wake);
-      rs.once("close", wake);
+      stream.once("readable", wake);
+      stream.once("end", wake);
+      stream.once("error", wake);
+      stream.once("close", wake);
     });
   }
   if (chunks.length === 0) return Buffer.alloc(0);
   if (chunks.length === 1) return chunks[0];
   return Buffer.concat(chunks);
 }
-async function awaitStreamClose(stream) {
-  if (stream.closed) return;
-  await new Promise((resolve) => {
-    stream.once("close", () => resolve());
-  });
-}
+var REVERSE_STRIPE_BYTES = 10 * 1024 * 1024;
+var ReverseBlockReader = class {
+  constructor(path2, metadata, stripeBytes = REVERSE_STRIPE_BYTES, parent) {
+    this.framesReturned = 0;
+    this.closed = false;
+    this.path = path2;
+    this.frames = path2 === void 0 ? 0 : metadata.frames;
+    this.channels = metadata.channels;
+    this.sampleRate = metadata.sampleRate;
+    this.bitDepth = metadata.bitDepth;
+    this.bytesPerFrame = metadata.channels * 4;
+    this.windowBytes = metadata.channels === 0 ? stripeBytes : Math.max(this.bytesPerFrame, Math.floor(stripeBytes / this.bytesPerFrame) * this.bytesPerFrame);
+    this.parent = parent;
+  }
+  async read(frames) {
+    if (this.closed) throw new Error("ReverseBlockReader: read() after close()");
+    const offset = this.framesReturned;
+    const remaining = this.frames - this.framesReturned;
+    if (this.path === void 0 || this.channels === 0 || frames <= 0 || remaining <= 0) {
+      return buildBlock([], offset, this.sampleRate, this.bitDepth);
+    }
+    const count = Math.min(frames, remaining);
+    const stream = this.ensureStream();
+    const buffer = await pullBytes(stream, () => stream.destroyed || stream.readableEnded, count * this.bytesPerFrame);
+    const actualFrames = Math.floor(buffer.length / this.bytesPerFrame);
+    if (actualFrames < count) throw this.streamError ?? new Error("ReverseBlockReader: unexpected end of reverse stream");
+    this.framesReturned += actualFrames;
+    return buildBlock(deinterleave(buffer, this.channels), offset, this.sampleRate, this.bitDepth);
+  }
+  async *iterate(frames) {
+    for (; ; ) {
+      const block = await this.read(frames);
+      if ((block.samples[0]?.length ?? 0) === 0) return;
+      yield block;
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const stream = this.stream;
+    this.stream = void 0;
+    if (stream) {
+      stream.destroy();
+      await awaitStreamClose(stream);
+    }
+    this.parent?.deregisterReverseReader(this);
+  }
+  ensureStream() {
+    if (this.stream) return this.stream;
+    if (this.path === void 0) throw new Error("ReverseBlockReader: no source file");
+    const totalBytes = this.frames * this.bytesPerFrame;
+    const stream = new ReverseReadable(this.path, totalBytes, this.bytesPerFrame, this.windowBytes);
+    stream.once("error", (error50) => {
+      this.streamError = error50;
+    });
+    this.stream = stream;
+    return stream;
+  }
+};
+var ReverseReadable = class extends Readable {
+  constructor(path2, totalBytes, bytesPerFrame, windowBytes) {
+    super({ highWaterMark: windowBytes });
+    this.path = path2;
+    this.bytesPerFrame = bytesPerFrame;
+    this.windowBytes = windowBytes;
+    this.position = totalBytes;
+  }
+  _read() {
+    void this.readWindow();
+  }
+  async readWindow() {
+    try {
+      if (this.position <= 0) {
+        this.push(null);
+        return;
+      }
+      const startByte = Math.max(0, this.position - this.windowBytes);
+      const length = this.position - startByte;
+      const buffer = Buffer.alloc(length);
+      await this.readFully(buffer, startByte);
+      this.reverseFramesInPlace(buffer);
+      this.position = startByte;
+      this.push(buffer);
+    } catch (error50) {
+      this.destroy(error50);
+    }
+  }
+  reverseFramesInPlace(buffer) {
+    const frameCount = Math.floor(buffer.length / this.bytesPerFrame);
+    const scratch = Buffer.alloc(this.bytesPerFrame);
+    for (let low = 0, high = frameCount - 1; low < high; low++, high--) {
+      const lowByte = low * this.bytesPerFrame;
+      const highByte = high * this.bytesPerFrame;
+      buffer.copy(scratch, 0, lowByte, lowByte + this.bytesPerFrame);
+      buffer.copy(buffer, lowByte, highByte, highByte + this.bytesPerFrame);
+      scratch.copy(buffer, highByte, 0, this.bytesPerFrame);
+    }
+  }
+  async readFully(target, position) {
+    const handle = await this.ensureHandle();
+    let filled = 0;
+    while (filled < target.length) {
+      const { bytesRead } = await handle.read(target, filled, target.length - filled, position + filled);
+      if (bytesRead === 0) throw new Error(`ReverseReadable: unexpected EOF at byte ${position + filled}`);
+      filled += bytesRead;
+    }
+  }
+  ensureHandle() {
+    this.handlePromise ?? (this.handlePromise = open(this.path, "r"));
+    return this.handlePromise;
+  }
+  _destroy(error50, callback) {
+    const handlePromise = this.handlePromise;
+    this.handlePromise = void 0;
+    if (!handlePromise) {
+      callback(error50);
+      return;
+    }
+    void handlePromise.then((handle) => handle.close()).then(
+      () => callback(error50),
+      (closeError) => callback(error50 ?? (closeError instanceof Error ? closeError : new Error(String(closeError))))
+    );
+  }
+};
+var HIGH_WATER_MARK = 10 * 1024 * 1024;
 var BlockBuffer = class {
   constructor() {
     this._frames = 0;
@@ -15645,50 +15831,37 @@ var BlockBuffer = class {
     const channels = this._channels;
     const interleaved = new Float32Array(duration4 * channels);
     for (let frame = 0; frame < duration4; frame++) {
-      for (let ch = 0; ch < channels; ch++) {
-        const src = samples[ch];
-        interleaved[frame * channels + ch] = src ? src[frame] ?? 0 : 0;
+      for (let channel = 0; channel < channels; channel++) {
+        const sourceSamples = samples[channel];
+        interleaved[frame * channels + channel] = sourceSamples ? sourceSamples[frame] ?? 0 : 0;
       }
     }
-    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
+    const writeBuffer = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
     const ws = this.ensureWriteStream();
-    const ok = ws.write(buf);
+    const ok = ws.write(writeBuffer);
     if (!ok) {
       await new Promise((resolve) => ws.once("drain", () => resolve()));
     }
-    this.writePositionByte += buf.length;
+    this.writePositionByte += writeBuffer.length;
     const writtenFrames = Math.floor(this.writePositionByte / (this._channels * 4));
     if (writtenFrames > this._frames) this._frames = writtenFrames;
   }
   async flushWrites() {
     await this.endWriteStream();
   }
-  // Opens a read-only reverse view over this buffer's temp file. Flushes pending writes first, then
-  // snapshots frames/channels/sampleRate/bitDepth so the reader is stable against later reads on the
-  // source. The reader is registered here and closed by clear()/close() (Windows blocks unlink while a
-  // handle is open — same EBUSY guard the forward read stream uses in endReadStream). See the
-  // ReverseBlockReader class comment for the full borrow contract.
   async openReverseReader() {
     await this.flushWrites();
-    const reader = new ReverseBlockReader(
-      this.tempPath,
-      { frames: this._frames, channels: this._channels, sampleRate: this._sampleRate, bitDepth: this._bitDepth },
-      REVERSE_STRIPE_BYTES,
-      this
-    );
+    const reader = new ReverseBlockReader(this.tempPath, { frames: this._frames, channels: this._channels, sampleRate: this._sampleRate, bitDepth: this._bitDepth }, void 0, this);
     this.reverseReaders.add(reader);
     return reader;
   }
-  // Called by a factory-created reader from its close() so it deregisters itself. Idempotent.
   deregisterReverseReader(reader) {
     this.reverseReaders.delete(reader);
   }
   async closeReverseReaders() {
     const readers = [...this.reverseReaders];
     this.reverseReaders.clear();
-    for (const reader of readers) {
-      await reader.close().catch(() => void 0);
-    }
+    for (const reader of readers) await reader.close().catch(() => void 0);
   }
   async read(frames) {
     const channels = this._channels;
@@ -15698,11 +15871,11 @@ var BlockBuffer = class {
     }
     const bytesPerFrame = channels * 4;
     const rs = this.ensureReadStream();
-    const buf = await pullBytes(rs, () => rs.destroyed || this.readStreamEnded, frames * bytesPerFrame);
-    const actualFrames = Math.floor(buf.length / bytesPerFrame);
+    const readBuffer = await pullBytes(rs, () => rs.destroyed || this.readStreamEnded, frames * bytesPerFrame);
+    const actualFrames = Math.floor(readBuffer.length / bytesPerFrame);
     if (actualFrames <= 0) return buildBlock([], startFrame, this._sampleRate, this._bitDepth);
     this.framesReadInSession += actualFrames;
-    const out = deinterleave(buf, channels);
+    const out = deinterleave(readBuffer, channels);
     return buildBlock(out, startFrame, this._sampleRate, this._bitDepth);
   }
   async *iterate(frames) {
@@ -15820,210 +15993,6 @@ var BlockBuffer = class {
     await awaitStreamClose(rs);
   }
 };
-var ReverseBlockReader = class {
-  constructor(path2, meta4, stripeBytes = REVERSE_STRIPE_BYTES, parent) {
-    this.framesReturned = 0;
-    this.closed = false;
-    this.path = path2;
-    this.frames = path2 === void 0 ? 0 : meta4.frames;
-    this.channels = meta4.channels;
-    this.sampleRate = meta4.sampleRate;
-    this.bitDepth = meta4.bitDepth;
-    this.bytesPerFrame = meta4.channels * 4;
-    this.windowBytes = meta4.channels === 0 ? stripeBytes : Math.max(this.bytesPerFrame, Math.floor(stripeBytes / this.bytesPerFrame) * this.bytesPerFrame);
-    this.parent = parent;
-  }
-  async read(frames) {
-    if (this.closed) {
-      throw new Error("ReverseBlockReader: read() after close()");
-    }
-    const offset = this.framesReturned;
-    const remaining = this.frames - this.framesReturned;
-    if (this.path === void 0 || this.channels === 0 || frames <= 0 || remaining <= 0) {
-      return buildBlock([], offset, this.sampleRate, this.bitDepth);
-    }
-    const count = Math.min(frames, remaining);
-    const rs = this.ensureStream();
-    const buf = await pullBytes(rs, () => rs.destroyed || rs.readableEnded, count * this.bytesPerFrame);
-    const actualFrames = Math.floor(buf.length / this.bytesPerFrame);
-    if (actualFrames < count) {
-      throw this.streamError ?? new Error("ReverseBlockReader: unexpected end of reverse stream");
-    }
-    this.framesReturned += actualFrames;
-    const out = deinterleave(buf, this.channels);
-    return buildBlock(out, offset, this.sampleRate, this.bitDepth);
-  }
-  async *iterate(frames) {
-    for (; ; ) {
-      const block = await this.read(frames);
-      if ((block.samples[0]?.length ?? 0) === 0) return;
-      yield block;
-    }
-  }
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    const stream = this.stream;
-    this.stream = void 0;
-    if (stream) {
-      stream.destroy();
-      await awaitStreamClose(stream);
-    }
-    this.parent?.deregisterReverseReader(this);
-  }
-  ensureStream() {
-    if (this.stream) return this.stream;
-    if (this.path === void 0) {
-      throw new Error("ReverseBlockReader: no source file");
-    }
-    const totalBytes = this.frames * this.bytesPerFrame;
-    const stream = new ReverseReadable(this.path, totalBytes, this.bytesPerFrame, this.windowBytes);
-    stream.once("error", (error50) => {
-      this.streamError = error50;
-    });
-    this.stream = stream;
-    return stream;
-  }
-};
-var ReverseReadable = class extends Readable {
-  constructor(path2, totalBytes, bytesPerFrame, windowBytes) {
-    super({ highWaterMark: windowBytes });
-    this.path = path2;
-    this.bytesPerFrame = bytesPerFrame;
-    this.windowBytes = windowBytes;
-    this.pos = totalBytes;
-  }
-  // Emits the next backward window [max(0, pos - windowBytes), pos), with the frame order reversed in
-  // place (channel order INSIDE each frame preserved — interleaved layout intact), then walks pos toward
-  // 0 and pushes null at start-of-file. Node does not consume a rejected _read promise — an uncaught
-  // throw becomes an unhandled rejection and the stream never errors — so any failure is routed to
-  // destroy(err), which fires the 'error'/'close' events pullBytes waits on.
-  _read() {
-    void this.readWindow();
-  }
-  async readWindow() {
-    try {
-      if (this.pos <= 0) {
-        this.push(null);
-        return;
-      }
-      const startByte = Math.max(0, this.pos - this.windowBytes);
-      const length = this.pos - startByte;
-      const buf = Buffer.alloc(length);
-      await this.readFully(buf, startByte);
-      this.reverseFramesInPlace(buf);
-      this.pos = startByte;
-      this.push(buf);
-    } catch (error50) {
-      this.destroy(error50);
-    }
-  }
-  // Reverse the frame order within the window in place: frame i swaps with frame (frameCount - 1 - i),
-  // each frame being one bytesPerFrame-wide slice. Channel order inside a frame is untouched, so the
-  // interleaved layout survives — only the time order flips.
-  reverseFramesInPlace(buf) {
-    const frameCount = Math.floor(buf.length / this.bytesPerFrame);
-    const scratch = Buffer.alloc(this.bytesPerFrame);
-    for (let low = 0, high = frameCount - 1; low < high; low++, high--) {
-      const lowByte = low * this.bytesPerFrame;
-      const highByte = high * this.bytesPerFrame;
-      buf.copy(scratch, 0, lowByte, lowByte + this.bytesPerFrame);
-      buf.copy(buf, lowByte, highByte, highByte + this.bytesPerFrame);
-      scratch.copy(buf, highByte, 0, this.bytesPerFrame);
-    }
-  }
-  // The one centralized positioned read-fully helper. Loops on handle.read and throws on a zero-byte
-  // read (unexpected EOF) — the shared guard against the former unchecked-bytesRead short-read bug.
-  async readFully(target, position) {
-    const handle = await this.ensureHandle();
-    let filled = 0;
-    while (filled < target.length) {
-      const { bytesRead } = await handle.read(target, filled, target.length - filled, position + filled);
-      if (bytesRead === 0) {
-        throw new Error(`ReverseReadable: unexpected EOF at byte ${position + filled}`);
-      }
-      filled += bytesRead;
-    }
-  }
-  async ensureHandle() {
-    if (this.handle) return this.handle;
-    this.handle = await open(this.path, "r");
-    return this.handle;
-  }
-  _destroy(error50, callback) {
-    const handle = this.handle;
-    this.handle = void 0;
-    if (!handle) {
-      callback(error50);
-      return;
-    }
-    handle.close().then(() => callback(error50)).catch((closeError) => callback(error50 ?? closeError));
-  }
-};
-var PROGRESS_PERCENT_QUANTUM = 0.01;
-var PROGRESS_MIN_INTERVAL_MS = 1e4;
-function createProgressGate(framesTotal) {
-  let lastBucket = -1;
-  let lastEmitAt;
-  return (framesDone, now) => {
-    const bucket = framesTotal !== void 0 ? Math.floor(framesDone / framesTotal / PROGRESS_PERCENT_QUANTUM) : void 0;
-    const bucketAdvanced = bucket === void 0 || bucket > lastBucket;
-    const intervalPassed = lastEmitAt === void 0 || now - lastEmitAt >= PROGRESS_MIN_INTERVAL_MS;
-    if (!bucketAdvanced || !intervalPassed) return false;
-    if (bucket !== void 0) lastBucket = bucket;
-    lastEmitAt = now;
-    return true;
-  };
-}
-var BufferedStream = class {
-  constructor(node, context) {
-    this.processingMs = 0;
-    this.destroyed = false;
-    this.node = node;
-    this.events = context.events;
-    const constructor = node.constructor;
-    this.identity = { nodeName: constructor.nodeName, nodeId: node.id, streamId: context.nextStreamId() };
-  }
-  get properties() {
-    return this.node.properties;
-  }
-  emitStarted() {
-    this.events.emit("started", this.identity, { createdAt: Date.now() });
-  }
-  emitFinished(payload) {
-    this.events.emit("finished", this.identity, { ...payload, createdAt: Date.now() });
-  }
-  emitProgress(phase2, framesDone, framesTotal) {
-    this.events.emit("progress", this.identity, { phase: phase2, framesDone, framesTotal, createdAt: Date.now() });
-  }
-  log(message, data, level = "info") {
-    this.events.emit("log", this.identity, { level, message, data, createdAt: Date.now() });
-  }
-  async *timed(source) {
-    const iterator = (async function* () {
-      yield* source;
-    })();
-    try {
-      for (; ; ) {
-        const start = performance.now();
-        const result = await iterator.next();
-        this.processingMs += performance.now() - start;
-        if (result.done) return;
-        yield result.value;
-      }
-    } finally {
-      await iterator.return();
-    }
-  }
-  async destroy() {
-    if (this.destroyed) return;
-    this.destroyed = true;
-    await this._destroy();
-  }
-  _destroy() {
-    return;
-  }
-};
 function sliceBlock(block, offset, frames) {
   if (offset === 0 && frames === (block.samples[0]?.length ?? 0)) return block;
   return {
@@ -16072,7 +16041,7 @@ var BufferedTransformStream = class extends BufferedStream {
     return this.properties.streamChunkSize;
   }
   async setup(input, context) {
-    this.sourceTotalFrames = context.durationFrames;
+    this.sourceTotalFrames = context.sourceTotalFrames;
     await this._setup(context);
     return this._pipe(input);
   }
@@ -16168,7 +16137,7 @@ var UnbufferedTransformStream = class extends BufferedStream {
     this.hasStarted = false;
   }
   async setup(input, context) {
-    this.sourceTotalFrames = context.durationFrames;
+    this.sourceTotalFrames = context.sourceTotalFrames;
     await this._setup(context);
     return this._pipe(input);
   }
@@ -23372,11 +23341,11 @@ var capitalizeFirstCharacter2 = (text) => {
 };
 function getUnitTypeFromNumber2(number42) {
   const abs = Math.abs(number42);
-  const last = abs % 10;
-  const last2 = abs % 100;
-  if (last2 >= 11 && last2 <= 19 || last === 0)
+  const last2 = abs % 10;
+  const last22 = abs % 100;
+  if (last22 >= 11 && last22 <= 19 || last2 === 0)
     return "many";
-  if (last === 1)
+  if (last2 === 1)
     return "one";
   return "few";
 }
@@ -29856,75 +29825,6 @@ var BufferedAudioNode = class {
 BufferedAudioNode.apiVersion = 1;
 BufferedAudioNode.description = "";
 BufferedAudioNode.schema = external_exports2.object({});
-var BufferedSourceStream = class extends BufferedStream {
-  constructor() {
-    super(...arguments);
-    this.framesRead = 0;
-    this.hasStarted = false;
-  }
-  setup(context) {
-    return Promise.resolve(this._setup(context));
-  }
-  _setup(context) {
-    let done = false;
-    this.framesRead = 0;
-    this.processingMs = 0;
-    this.hasStarted = false;
-    const { signal, durationFrames: sourceTotalFrames, highWaterMark } = context;
-    const readGate = createProgressGate(sourceTotalFrames);
-    return new ReadableStream(
-      {
-        pull: async (controller) => {
-          if (done) return;
-          if (signal?.aborted) {
-            done = true;
-            await this.destroy();
-            controller.close();
-            return;
-          }
-          try {
-            if (!this.hasStarted) {
-              this.hasStarted = true;
-              this.emitStarted();
-            }
-            const start = performance.now();
-            const chunk = await this._read();
-            this.processingMs += performance.now() - start;
-            if (!chunk) {
-              done = true;
-              this.emitProgress("read", this.framesRead, sourceTotalFrames);
-              this.emitFinished({ framesDone: this.framesRead, processingMs: this.processingMs });
-              await this.destroy();
-              controller.close();
-              return;
-            }
-            this.framesRead += chunk.samples[0]?.length ?? 0;
-            controller.enqueue(chunk);
-            if (readGate(this.framesRead, Date.now())) this.emitProgress("read", this.framesRead, sourceTotalFrames);
-          } catch (error482) {
-            done = true;
-            await this.destroy();
-            controller.error(error482);
-          }
-        },
-        cancel: async () => {
-          done = true;
-          await this.destroy();
-        }
-      },
-      { highWaterMark }
-    );
-  }
-};
-var SourceNode = class extends BufferedAudioNode {
-  to(child) {
-    const head = "head" in child ? child.head : child;
-    this.properties = { ...this.properties, children: [...this.properties.children ?? [], head] };
-  }
-  createRenderJob(options) {
-    return new RenderJob(this, options);
-  }
-};
 var BufferedTargetStream = class extends BufferedStream {
   constructor() {
     super(...arguments);
@@ -29932,7 +29832,7 @@ var BufferedTargetStream = class extends BufferedStream {
     this.framesWritten = 0;
   }
   setup(readable, context) {
-    this.sourceTotalFrames = context.durationFrames;
+    this.sourceTotalFrames = context.sourceTotalFrames;
     return Promise.resolve(this._setup(readable, context));
   }
   _setup(input, _context) {
@@ -29971,23 +29871,106 @@ var BufferedTargetStream = class extends BufferedStream {
 };
 var TargetNode = class extends BufferedAudioNode {
 };
+function assertFirstBlockSampleRate(readable, expected, nodeName) {
+  const reader = readable.getReader();
+  let checked = false;
+  return new ReadableStream({
+    pull: async (controller) => {
+      const result = await reader.read();
+      if (result.done) {
+        controller.close();
+        return;
+      }
+      if (!checked) {
+        checked = true;
+        if (result.value.sampleRate !== expected) {
+          controller.error(
+            new Error(
+              `${nodeName}: emitted ${result.value.sampleRate} Hz where ${expected} Hz was declared \u2014 a rate-changing stream must assign context.sampleRate in _setup`
+            )
+          );
+          await reader.cancel();
+          return;
+        }
+      }
+      controller.enqueue(result.value);
+    },
+    cancel: async (reason) => {
+      await reader.cancel(reason);
+    }
+  });
+}
 function teeReadable(readable, items) {
   if (items.length === 0) return [];
   const first = items[0];
   if (items.length === 1) return [[readable, first]];
-  const pairs = [];
-  let current = readable;
-  for (let offset = 0; offset < items.length - 1; offset++) {
-    const [left, right] = current.tee();
-    pairs.push([left, items[offset]]);
-    current = right;
-  }
-  pairs.push([current, items[items.length - 1]]);
-  return pairs;
-}
-function isSourceStream(stream) {
-  return stream instanceof BufferedSourceStream;
+  const reader = readable.getReader();
+  const branches = [];
+  let serving = false;
+  let finished = false;
+  const settleDemand = (branch) => {
+    branch.demandResolvers.shift()?.();
+  };
+  const settleAllDemand = (branch) => {
+    while (branch.demandResolvers.length > 0) settleDemand(branch);
+  };
+  const liveBranches = () => branches.filter((branch) => !branch.cancelled);
+  const serve = async () => {
+    if (serving) return;
+    serving = true;
+    try {
+      while (!finished) {
+        const demanding = liveBranches();
+        if (demanding.length === 0) return;
+        if (!demanding.every((branch) => branch.demandResolvers.length > 0)) return;
+        let result;
+        try {
+          result = await reader.read();
+        } catch (error482) {
+          finished = true;
+          for (const branch of liveBranches()) {
+            branch.controller.error(error482);
+            settleAllDemand(branch);
+          }
+          return;
+        }
+        for (const branch of liveBranches()) {
+          if (result.done) branch.controller.close();
+          else branch.controller.enqueue(result.value);
+          settleDemand(branch);
+        }
+        if (result.done) finished = true;
+      }
+    } finally {
+      serving = false;
+    }
+  };
+  const streams = items.map(() => {
+    let branch;
+    return new ReadableStream({
+      start: (controller) => {
+        branch = { controller, demandResolvers: [], cancelled: false };
+        branches.push(branch);
+      },
+      pull: () => new Promise((resolve) => {
+        branch.demandResolvers.push(resolve);
+        void serve();
+      }),
+      cancel: async (reason) => {
+        branch.cancelled = true;
+        settleAllDemand(branch);
+        if (branches.every((entry) => entry.cancelled)) {
+          finished = true;
+          await reader.cancel(reason);
+          return;
+        }
+        void serve();
+      }
+    });
+  });
+  return streams.map((stream, offset) => [stream, items[offset]]);
 }
+var RENDER_LIVENESS_INTERVAL_MS = 3e4;
 var RenderJob = class {
   constructor(source, options) {
     this.options = options;
@@ -29998,10 +29981,11 @@ var RenderJob = class {
     let streamIdCounter = 0;
     this.renderContext = { events: this.events, nextStreamId: () => streamIdCounter++ };
     this.root = this.build(source, /* @__PURE__ */ new Set());
-    if (!isSourceStream(this.root.stream)) {
+    const sourceStream = this.root.stream;
+    if (!(sourceStream instanceof BufferedSourceStream)) {
       throw new Error("Source node did not produce a source stream");
     }
-    this.sourceStream = this.root.stream;
+    this.sourceStream = sourceStream;
   }
   get streams() {
     return this.streamsMap;
@@ -30052,53 +30036,65 @@ var RenderJob = class {
   async render() {
     if (this.started) throw new Error("RenderJob is single-use; render() was already called");
     this.started = true;
-    const meta32 = await this.sourceStream.getMetadata();
-    const defaultProviders = ["gpu", "cpu-native", "cpu"];
-    const memoryLimit = this.options?.memoryLimit ?? 256 * 1024 * 1024;
-    const stages = Math.max(1, this.countStreams());
-    const chunkSize = this.options?.chunkSize ?? 128 * 1024;
-    const bytesPerChunk = meta32.channels * chunkSize * 4;
-    const computedHighWaterMark = Math.max(1, Math.floor(memoryLimit / (stages * bytesPerChunk)));
-    const context = {
-      executionProviders: this.options?.executionProviders ?? defaultProviders,
-      memoryLimit,
-      durationFrames: meta32.durationFrames,
-      highWaterMark: this.options?.highWaterMark ?? computedHighWaterMark,
-      signal: this.signal()
-    };
-    const start = performance.now();
+    const renderCalledAt = performance.now();
+    const livenessInterval = setInterval(() => {
+      this.events.emit("liveness", { createdAt: Date.now(), elapsedMs: performance.now() - renderCalledAt });
+    }, RENDER_LIVENESS_INTERVAL_MS);
     try {
-      const readable = await this.sourceStream.setup(context);
-      const promises = await this.wireChildren(this.root.children, readable, context);
-      await Promise.all(promises);
-    } finally {
-      for (const streams of this.streamsMap.values()) {
-        for (const stream of streams) {
-          await stream.destroy();
+      const meta32 = await this.sourceStream.getMetadata();
+      const defaultProviders = ["gpu", "cpu-native", "cpu"];
+      const memoryLimit = this.options?.memoryLimit ?? 256 * 1024 * 1024;
+      const stages = Math.max(1, this.countStreams());
+      const chunkSize = this.options?.chunkSize ?? 128 * 1024;
+      const bytesPerChunk = meta32.channels * chunkSize * 4;
+      const computedHighWaterMark = Math.max(1, Math.floor(memoryLimit / (stages * bytesPerChunk)));
+      const context = {
+        executionProviders: this.options?.executionProviders ?? defaultProviders,
+        memoryLimit,
+        sourceSampleRate: meta32.sampleRate,
+        sampleRate: meta32.sampleRate,
+        sourceTotalFrames: meta32.durationFrames,
+        highWaterMark: this.options?.highWaterMark ?? computedHighWaterMark,
+        signal: this.signal()
+      };
+      const start = performance.now();
+      try {
+        const readable = await this.sourceStream.setup(context);
+        const sourceName = this.root.node.constructor.nodeName;
+        const promises = await this.setupChildren(this.root.children, assertFirstBlockSampleRate(readable, context.sampleRate, sourceName), context);
+        await Promise.all(promises);
+      } finally {
+        for (const streams of this.streamsMap.values()) {
+          for (const stream of streams) {
+            await stream.destroy();
+          }
         }
+        const totalMs = performance.now() - start;
+        const audioDurationMs = meta32.durationFrames !== void 0 ? meta32.durationFrames / meta32.sampleRate * 1e3 : 0;
+        this.timingData = {
+          totalMs,
+          audioDurationMs,
+          realTimeMultiplier: audioDurationMs > 0 ? audioDurationMs / totalMs : 0
+        };
       }
-      const totalMs = performance.now() - start;
-      const audioDurationMs = meta32.durationFrames !== void 0 ? meta32.durationFrames / meta32.sampleRate * 1e3 : 0;
-      this.timingData = {
-        totalMs,
-        audioDurationMs,
-        realTimeMultiplier: audioDurationMs > 0 ? audioDurationMs / totalMs : 0
-      };
+    } finally {
+      clearInterval(livenessInterval);
     }
   }
-  async wireChildren(children, readable, context) {
+  async setupChildren(children, readable, context) {
     const pairs = teeReadable(readable, children);
-    const nested = await Promise.all(pairs.map(([branch, child]) => this.wire(child, branch, context)));
+    const nested = await Promise.all(pairs.map(([branch, child]) => this.setup(child, branch, { ...context })));
     return nested.flat();
   }
-  async wire(plan, input, context) {
+  async setup(plan, input, context) {
     const { stream } = plan;
     if (stream instanceof BufferedTargetStream) {
       return [stream.setup(input, context)];
     }
     if (stream instanceof BufferedTransformStream || stream instanceof UnbufferedTransformStream) {
+      const nodeName = plan.node.constructor.nodeName;
       const output = await stream.setup(input, context);
-      return this.wireChildren(plan.children, output, context);
+      return this.setupChildren(plan.children, assertFirstBlockSampleRate(output, context.sampleRate, nodeName), context);
     }
     throw new Error(`Unexpected stream type for node "${plan.node.constructor.nodeName}"`);
   }
@@ -30112,12 +30108,114 @@ var RenderJob = class {
     return AbortSignal.any([this.options.signal, this.abortController.signal]);
   }
 };
+var BufferedSourceStream = class extends BufferedStream {
+  constructor() {
+    super(...arguments);
+    this.framesRead = 0;
+    this.hasStarted = false;
+  }
+  setup(context) {
+    return Promise.resolve(this._setup(context));
+  }
+  _setup(context) {
+    let done = false;
+    this.framesRead = 0;
+    this.processingMs = 0;
+    this.hasStarted = false;
+    const { signal, sourceTotalFrames, highWaterMark } = context;
+    const readGate = createProgressGate(sourceTotalFrames);
+    return new ReadableStream(
+      {
+        pull: async (controller) => {
+          if (done) return;
+          if (signal?.aborted) {
+            done = true;
+            await this.destroy();
+            controller.close();
+            return;
+          }
+          try {
+            if (!this.hasStarted) {
+              this.hasStarted = true;
+              this.emitStarted();
+            }
+            const start = performance.now();
+            const chunk = await this._read();
+            this.processingMs += performance.now() - start;
+            if (!chunk) {
+              done = true;
+              this.emitProgress("read", this.framesRead, sourceTotalFrames);
+              this.emitFinished({ framesDone: this.framesRead, processingMs: this.processingMs });
+              await this.destroy();
+              controller.close();
+              return;
+            }
+            this.framesRead += chunk.samples[0]?.length ?? 0;
+            controller.enqueue(chunk);
+            if (readGate(this.framesRead, Date.now())) this.emitProgress("read", this.framesRead, sourceTotalFrames);
+          } catch (error482) {
+            done = true;
+            await this.destroy();
+            controller.error(error482);
+          }
+        },
+        cancel: async () => {
+          done = true;
+          await this.destroy();
+        }
+      },
+      { highWaterMark }
+    );
+  }
+};
+var SourceNode = class extends BufferedAudioNode {
+  to(child) {
+    const head = "head" in child ? child.head : child;
+    this.properties = { ...this.properties, children: [...this.properties.children ?? [], head] };
+  }
+  createRenderJob(options) {
+    return new RenderJob(this, options);
+  }
+};
 var TransformNode = class extends BufferedAudioNode {
   to(child) {
     const head = "head" in child ? child.head : child;
     this.properties = { ...this.properties, children: [...this.properties.children ?? [], head] };
   }
 };
+new Map(
+  Object.entries({
+    \u00C6: "Ae",
+    \u00D0: "D",
+    \u00D8: "O",
+    \u00DE: "Th",
+    \u00DF: "ss",
+    \u00E6: "ae",
+    \u00F0: "d",
+    \u00F8: "o",
+    \u00FE: "th",
+    \u0110: "D",
+    \u0111: "d",
+    \u0126: "H",
+    \u0127: "h",
+    \u0131: "i",
+    \u0132: "IJ",
+    \u0133: "ij",
+    \u0138: "k",
+    \u013F: "L",
+    \u0140: "l",
+    \u0141: "L",
+    \u0142: "l",
+    \u0149: "'n",
+    \u014A: "N",
+    \u014B: "n",
+    \u0152: "Oe",
+    \u0153: "oe",
+    \u0166: "T",
+    \u0167: "t",
+    \u017F: "s"
+  })
+);
 var graphNodeSchema = external_exports2.object({
   id: external_exports2.string().min(1),
   packageName: external_exports2.string().min(1),
@@ -30457,13 +30555,13 @@ var ReadWavStream = class extends BufferedSourceStream {
     const fileChannels = format.channels;
     const selectedChannels = this.properties.channels;
     const allChannels = [];
-    for (let ch = 0; ch < fileChannels; ch++) {
+    for (let fileChannel = 0; fileChannel < fileChannels; fileChannel++) {
       allChannels.push(new Float32Array(frames));
     }
     for (let frame = 0; frame < frames; frame++) {
-      for (let ch = 0; ch < fileChannels; ch++) {
-        const byteOffset = frame * format.blockAlign + ch * (format.bitsPerSample / 8);
-        const channel = allChannels[ch];
+      for (let fileChannel = 0; fileChannel < fileChannels; fileChannel++) {
+        const byteOffset = frame * format.blockAlign + fileChannel * (format.bitsPerSample / 8);
+        const channel = allChannels[fileChannel];
         if (channel) {
           channel[frame] = readSample(chunk, byteOffset, format.bitsPerSample, format.audioFormat);
         }
@@ -30824,7 +30922,7 @@ var SpectrogramStream = class extends BufferedTargetStream {
       this.outputBins = numBands;
     }
     this.sampleBuffers = [];
-    for (let ch = 0; ch < this.channels; ch++) {
+    for (let channel = 0; channel < this.channels; channel++) {
       this.sampleBuffers.push(new Float32Array(this.sampleBufferCapacity));
     }
     if (!this.fileHandle) return;
@@ -30845,17 +30943,17 @@ var SpectrogramStream = class extends BufferedTargetStream {
     const frames = chunk.samples[0]?.length ?? 0;
     if (this.sampleBufferOffset + frames > this.sampleBufferCapacity) {
       const newCapacity = Math.max(this.sampleBufferCapacity * 2, this.sampleBufferOffset + frames);
-      for (let ch = 0; ch < this.channels; ch++) {
+      for (let channel = 0; channel < this.channels; channel++) {
         const newBuf = new Float32Array(newCapacity);
-        newBuf.set(this.sampleBuffers[ch].subarray(0, this.sampleBufferOffset));
-        this.sampleBuffers[ch] = newBuf;
+        newBuf.set(this.sampleBuffers[channel].subarray(0, this.sampleBufferOffset));
+        this.sampleBuffers[channel] = newBuf;
       }
       this.sampleBufferCapacity = newCapacity;
     }
-    for (let ch = 0; ch < this.channels; ch++) {
-      const src = chunk.samples[ch];
-      if (!src) continue;
-      this.sampleBuffers[ch].set(src, this.sampleBufferOffset);
+    for (let channel = 0; channel < this.channels; channel++) {
+      const channelSamples = chunk.samples[channel];
+      if (!channelSamples) continue;
+      this.sampleBuffers[channel].set(channelSamples, this.sampleBufferOffset);
     }
     this.sampleBufferOffset += frames;
     await this.processAccumulatedSamples(false);
@@ -30879,9 +30977,9 @@ var SpectrogramStream = class extends BufferedTargetStream {
     const halfSize = this.linearBins;
     const magScale = 2 / fftSize;
     if (flush && this.sampleBufferOffset > 0 && this.sampleBufferOffset < fftSize) {
-      for (let ch = 0; ch < this.channels; ch++) {
-        const buf = this.sampleBuffers[ch];
-        buf.fill(0, this.sampleBufferOffset, fftSize);
+      for (let channel = 0; channel < this.channels; channel++) {
+        const buffer = this.sampleBuffers[channel];
+        buffer.fill(0, this.sampleBufferOffset, fftSize);
       }
       this.sampleBufferOffset = fftSize;
     }
@@ -30895,9 +30993,9 @@ var SpectrogramStream = class extends BufferedTargetStream {
       this.writeBufferOffset = 0;
       this.writeBufferFileOffset = this.fileOffset;
     }
-    for (let ch = 0; ch < this.channels; ch++) {
+    for (let channel = 0; channel < this.channels; channel++) {
       const frames = computeSpectrogramFrames(
-        this.sampleBuffers[ch],
+        this.sampleBuffers[channel],
         batchFrames,
         fftSize,
         hopSize,
@@ -30911,30 +31009,30 @@ var SpectrogramStream = class extends BufferedTargetStream {
         this.magnitudes
       );
       for (const frame of frames) {
-        await this.writeFrame(ch, frame);
+        await this.writeFrame(channel, frame);
       }
     }
     await this.flushWriteBuffer();
     const keepFrom = batchFrames * hopSize;
     const keepCount = this.sampleBufferOffset - keepFrom;
     if (keepCount > 0) {
-      for (let ch = 0; ch < this.channels; ch++) {
-        const buf = this.sampleBuffers[ch];
-        buf.copyWithin(0, keepFrom, keepFrom + keepCount);
+      for (let channel = 0; channel < this.channels; channel++) {
+        const buffer = this.sampleBuffers[channel];
+        buffer.copyWithin(0, keepFrom, keepFrom + keepCount);
       }
     }
     this.sampleBufferOffset = keepCount > 0 ? keepCount : 0;
   }
-  async writeFrame(ch, frame) {
+  async writeFrame(channel, frame) {
     const frameByteSize = this.outputBins * this.channels * 4;
     if (this.writeBuffer && this.writeBufferOffset + frameByteSize > this.writeBuffer.length) {
       await this.flushWriteBuffer();
     }
-    const buf = this.writeBuffer;
-    if (!buf) return;
+    const writeBuffer = this.writeBuffer;
+    if (!writeBuffer) return;
     const offset = this.writeBufferOffset;
     for (let bin = 0; bin < this.outputBins; bin++) {
-      buf.writeFloatLE(frame[bin], offset + (ch * this.outputBins + bin) * 4);
+      writeBuffer.writeFloatLE(frame[bin], offset + (channel * this.outputBins + bin) * 4);
     }
     this.writeBufferOffset += frameByteSize;
     this.fileOffset += frameByteSize;
@@ -30960,18 +31058,18 @@ function spectrogram(outputPath, options) {
 
 // src/targets/waveform/utils/minmax.ts
 function updateMinMax(samples, frame, channels, min, max) {
-  for (let ch = 0; ch < channels; ch++) {
-    const sample = samples[ch]?.[frame] ?? 0;
-    const currentMin = min[ch];
-    const currentMax = max[ch];
-    if (currentMin !== void 0 && sample < currentMin) min[ch] = sample;
-    if (currentMax !== void 0 && sample > currentMax) max[ch] = sample;
+  for (let channel = 0; channel < channels; channel++) {
+    const sample = samples[channel]?.[frame] ?? 0;
+    const currentMin = min[channel];
+    const currentMax = max[channel];
+    if (currentMin !== void 0 && sample < currentMin) min[channel] = sample;
+    if (currentMax !== void 0 && sample > currentMax) max[channel] = sample;
   }
 }
 function writeMinMaxPoint(min, max, channels, target, offset) {
-  for (let ch = 0; ch < channels; ch++) {
-    target.writeFloatLE(min[ch] ?? 0, offset + ch * 8);
-    target.writeFloatLE(max[ch] ?? 0, offset + ch * 8 + 4);
+  for (let channel = 0; channel < channels; channel++) {
+    target.writeFloatLE(min[channel] ?? 0, offset + channel * 8);
+    target.writeFloatLE(max[channel] ?? 0, offset + channel * 8 + 4);
   }
 }
 
@@ -31218,7 +31316,7 @@ function bitDepthToPcmFormat(bitDepth) {
 }
 var encodingSchema = external_exports.object({
   format: external_exports.enum(["wav", "flac", "mp3", "aac"]),
-  bitrate: external_exports.string().optional(),
+  bitrate: external_exports.number().int().min(8).max(1024).optional().describe("Constant bitrate in kbps for MP3 and AAC. Defaults to 192 kbps."),
   vbr: external_exports.number().min(0).max(9).optional(),
   sampleRate: external_exports.number().int().positive().optional().describe("Output sample rate (Hz). When set, ffmpeg resamples on encode.")
 });
@@ -31336,8 +31434,8 @@ var WriteStream = class extends BufferedTargetStream {
     const buffer = Buffer.alloc(frames * channels * bytesPerSample);
     let offset = 0;
     for (let frame = 0; frame < frames; frame++) {
-      for (let ch = 0; ch < channels; ch++) {
-        const sample = chunk.samples[ch]?.[frame] ?? 0;
+      for (let channel = 0; channel < channels; channel++) {
+        const sample = chunk.samples[channel]?.[frame] ?? 0;
         offset = writeSample(buffer, offset, sample, this.properties.bitDepth);
       }
     }
@@ -31355,11 +31453,11 @@ var WriteStream = class extends BufferedTargetStream {
         if (encoding.vbr !== void 0) {
           args.push("-q:a", String(encoding.vbr));
         } else {
-          args.push("-b:a", encoding.bitrate ?? "192k");
+          args.push("-b:a", `${encoding.bitrate ?? 192}k`);
         }
         break;
       case "aac":
-        args.push("-codec:a", "aac", "-b:a", encoding.bitrate ?? "192k");
+        args.push("-codec:a", "aac", "-b:a", `${encoding.bitrate ?? 192}k`);
         break;
     }
     if (encoding.sampleRate !== void 0) {
@@ -31440,8 +31538,8 @@ var CutStream = class extends UnbufferedTransformStream {
     }
     const channels = chunk.samples.length;
     const output = [];
-    for (let ch = 0; ch < channels; ch++) {
-      const channel = chunk.samples[ch];
+    for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+      const channel = chunk.samples[channelIndex];
       if (!channel) {
         output.push(new Float32Array(totalKept));
         continue;
@@ -31493,18 +31591,18 @@ var DitherStream = class extends UnbufferedTransformStream {
     while (this.lastError.length < chunk.samples.length) {
       this.lastError.push(0);
     }
-    const samples = chunk.samples.map((channel, ch) => {
+    const samples = chunk.samples.map((channel, channelIndex) => {
       const output = new Float32Array(channel.length);
       for (let index = 0; index < channel.length; index++) {
         const sample = channel[index] ?? 0;
         const tpdfNoise = (Math.random() - Math.random()) * lsb;
         let dithered = sample + tpdfNoise;
         if (noiseShaping) {
-          dithered += this.lastError[ch] ?? 0;
+          dithered += this.lastError[channelIndex] ?? 0;
         }
         const quantized = quantizeSample(dithered, levels);
         if (noiseShaping) {
-          this.lastError[ch] = dithered - quantized;
+          this.lastError[channelIndex] = dithered - quantized;
         }
         output[index] = quantized;
       }
@@ -31712,9 +31810,9 @@ var PhaseStream = class extends UnbufferedTransformStream {
     while (this.allpassState.length < chunk.samples.length) {
       this.allpassState.push(0);
     }
-    const samples = chunk.samples.map((channel, ch) => {
-      const { output, state } = applyAllpass(channel, coefficient, this.allpassState[ch] ?? 0);
-      this.allpassState[ch] = state;
+    const samples = chunk.samples.map((channel, channelIndex) => {
+      const { output, state } = applyAllpass(channel, coefficient, this.allpassState[channelIndex] ?? 0);
+      this.allpassState[channelIndex] = state;
       return output;
     });
     return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
@@ -31829,9 +31927,9 @@ var SpliceStream = class extends UnbufferedTransformStream {
     const { samples, sampleRate } = await readWavSamples(this.properties.insertPath);
     const targetChannels = this.properties.channels;
     if (targetChannels) {
-      for (const ch of targetChannels) {
-        if (ch < 0) {
-          throw new Error(`Splice: target channel ${ch} is out of range`);
+      for (const targetChannel of targetChannels) {
+        if (targetChannel < 0) {
+          throw new Error(`Splice: target channel ${targetChannel} is out of range`);
         }
       }
     }
@@ -31864,9 +31962,9 @@ var SpliceStream = class extends UnbufferedTransformStream {
         applyInsert(channelSamples, insertChannel, overlap);
       }
     } else {
-      for (let ch = 0; ch < samples.length; ch++) {
-        const channelSamples = samples[ch];
-        const insertChannel = this.insertSamples[ch];
+      for (let channel = 0; channel < samples.length; channel++) {
+        const channelSamples = samples[channel];
+        const insertChannel = this.insertSamples[channel];
         if (!channelSamples || !insertChannel) continue;
         applyInsert(channelSamples, insertChannel, overlap);
       }
@@ -31991,8 +32089,8 @@ function downmixToMono(samples) {
   const mono = new Float32Array(frames);
   if (channels === 0) return mono;
   const scale = 1 / channels;
-  for (let ch = 0; ch < channels; ch++) {
-    const channel = samples[ch] ?? new Float32Array(0);
+  for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+    const channel = samples[channelIndex] ?? new Float32Array(0);
     for (let index = 0; index < frames; index++) {
       mono[index] = (mono[index] ?? 0) + (channel[index] ?? 0) * scale;
     }
@@ -32036,7 +32134,7 @@ var DuplicateChannelsStream = class extends UnbufferedTransformStream {
     const source = chunk.samples[0] ?? new Float32Array(0);
     const outputCount = this.properties.channels;
     const samples = [];
-    for (let ch = 0; ch < outputCount; ch++) {
+    for (let channel = 0; channel < outputCount; channel++) {
       samples.push(Float32Array.from(source));
     }
     yield { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
@@ -32146,15 +32244,11 @@ var STDERR_CAP_BYTES = 64 * 1024;
 function spawnFfmpegChild(options) {
   const child = spawn(options.ffmpegPath, [...options.args], { stdio: ["pipe", "pipe", "pipe"] });
   child.stderr.on("data", options.onStderr);
-  child.stdout.on("data", options.onStdout);
   child.stdin.on("error", options.onStdinError);
   const exitPromise = new Promise((resolve) => {
     child.once("exit", (code, signal) => resolve({ code, signal }));
   });
-  const stdoutEndPromise = new Promise((resolve) => {
-    child.stdout.once("end", () => resolve());
-  });
-  return { child, exitPromise, stdoutEndPromise };
+  return { child, exitPromise };
 }
 function buildInputArgs(sampleRate, channels) {
   return ["-f", "f32le", "-ar", String(sampleRate), "-ac", String(channels), "-i", "pipe:0"];
@@ -32189,14 +32283,14 @@ function parseStdoutFrames(stash, bytes, channels, offset, sampleRate) {
     floatView = new Float32Array(aligned.buffer, aligned.byteOffset, totalFloats);
   }
   const samples = [];
-  for (let ch = 0; ch < channels; ch++) {
+  for (let channel = 0; channel < channels; channel++) {
     samples.push(new Float32Array(frameCount));
   }
   for (let frame = 0; frame < frameCount; frame++) {
-    for (let ch = 0; ch < channels; ch++) {
-      const channelArray = samples[ch];
+    for (let channel = 0; channel < channels; channel++) {
+      const channelArray = samples[channel];
       if (channelArray) {
-        channelArray[frame] = floatView[frame * channels + ch] ?? 0;
+        channelArray[frame] = floatView[frame * channels + channel] ?? 0;
       }
     }
   }
@@ -32219,15 +32313,16 @@ var TEARDOWN_KILL_GRACE_MS2 = 2e3;
 var FfmpegStream = class extends UnbufferedTransformStream {
   constructor() {
     super(...arguments);
-    this.pending = [];
     this.stdoutStash = Buffer.alloc(0);
     this.outputOffset = 0;
     this.stderr = "";
+    this.stdoutEnded = false;
     this.inputSampleRate = 0;
     this.inputChannels = 0;
   }
   _setup(context) {
     this.streamContext = context;
+    if (this.properties.outputSampleRate !== void 0) context.sampleRate = this.properties.outputSampleRate;
   }
   _buildArgs(context) {
     const { args } = this.properties;
@@ -32240,29 +32335,72 @@ var FfmpegStream = class extends UnbufferedTransformStream {
     this.inputChannels = channels;
     const outRate = this.properties.outputSampleRate ?? sampleRate;
     const args = [...buildInputArgs(sampleRate, channels), ...this._buildArgs(this.streamContext), ...buildOutputArgs(outRate, channels)];
-    const { child, exitPromise, stdoutEndPromise } = spawnFfmpegChild({
+    const { child, exitPromise } = spawnFfmpegChild({
       ffmpegPath: this.properties.ffmpegPath,
       args,
       onStderr: (chunk) => {
         this.stderr = appendStderr(this.stderr, chunk);
       },
-      onStdout: (bytes) => this.handleStdoutBytes(bytes),
       onStdinError: (error50) => {
         if (error50.code === "EPIPE") return;
         this.stdinError ?? (this.stdinError = new Error(`ffmpeg stdin error: ${error50.message}`));
       }
     });
+    child.stdout.on("readable", () => this.wakeStdout());
+    child.stdout.on("end", () => {
+      this.stdoutEnded = true;
+      this.wakeStdout();
+    });
     this.child = child;
     this.exitPromise = exitPromise;
-    this.stdoutEndPromise = stdoutEndPromise;
   }
-  handleStdoutBytes(bytes) {
+  wakeStdout() {
+    const notify = this.stdoutNotify;
+    this.stdoutNotify = void 0;
+    this.stdoutWait = void 0;
+    notify?.();
+  }
+  *readAvailableStdout() {
+    const stdout = this.child?.stdout;
+    if (!stdout) return;
     const outRate = this.properties.outputSampleRate ?? this.inputSampleRate;
-    const { block, stash, frameCount } = parseStdoutFrames(this.stdoutStash, bytes, this.inputChannels, this.outputOffset, outRate);
-    this.stdoutStash = stash;
-    if (!block) return;
-    this.pending.push(block);
-    this.outputOffset += frameCount;
+    for (; ; ) {
+      const bytes = stdout.read();
+      if (!bytes) return;
+      const { block, stash, frameCount } = parseStdoutFrames(this.stdoutStash, bytes, this.inputChannels, this.outputOffset, outRate);
+      this.stdoutStash = stash;
+      if (block) {
+        this.outputOffset += frameCount;
+        yield block;
+      }
+    }
+  }
+  waitForStdoutReadableOrEnd() {
+    const stdout = this.child?.stdout;
+    if (!stdout || this.stdoutEnded) return Promise.resolve();
+    if (stdout.readableLength > 0) return Promise.resolve();
+    if (stdout.readableEnded) {
+      this.stdoutEnded = true;
+      return Promise.resolve();
+    }
+    if (this.stdoutWait) return this.stdoutWait;
+    const wait = new Promise((resolve) => {
+      this.stdoutNotify = resolve;
+    });
+    this.stdoutWait = wait;
+    return wait;
+  }
+  async *serveWhileParked() {
+    for (; ; ) {
+      yield* this.readAvailableStdout();
+      const drain = this.pendingDrain;
+      if (drain === void 0) return;
+      if (this.stdoutEnded) {
+        await drain;
+        return;
+      }
+      await Promise.race([drain, this.waitForStdoutReadableOrEnd()]);
+    }
   }
   async *_transform(block) {
     if (this.stdinError) throw this.stdinError;
@@ -32275,11 +32413,8 @@ var FfmpegStream = class extends UnbufferedTransformStream {
     const child = this.child;
     if (!child) throw new Error("FfmpegStream.child not initialized");
     const interleaved = interleave(block.samples, frames, channels);
-    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
-    if (this.pendingDrain) {
-      await this.pendingDrain;
-    }
-    const ok = child.stdin.write(buf);
+    const interleavedBuffer = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
+    const ok = child.stdin.write(interleavedBuffer);
     if (!ok) {
       this.pendingDrain = new Promise((resolve) => {
         child.stdin.once("drain", () => {
@@ -32288,27 +32423,31 @@ var FfmpegStream = class extends UnbufferedTransformStream {
         });
       });
     }
-    yield* this.pending.splice(0);
+    yield* this.serveWhileParked();
+    yield* this.readAvailableStdout();
   }
   async *_flush() {
     const child = this.child;
     if (!child) return;
-    if (this.pendingDrain) {
-      await this.pendingDrain;
-    }
+    yield* this.serveWhileParked();
     child.stdin.end();
     if (this.stdinError) throw this.stdinError;
-    const stdoutEnd = this.stdoutEndPromise ?? Promise.resolve();
-    const exit = this.exitPromise ?? Promise.resolve({ code: 0, signal: null });
-    const [, exitResult] = await Promise.all([stdoutEnd, exit]);
+    for (; ; ) {
+      yield* this.readAvailableStdout();
+      if (this.stdoutEnded) break;
+      await this.waitForStdoutReadableOrEnd();
+    }
+    if (this.stdoutStash.length >= this.inputChannels * 4) {
+      const outRate = this.properties.outputSampleRate ?? this.inputSampleRate;
+      const { block } = parseStdoutFrames(this.stdoutStash, Buffer.alloc(0), this.inputChannels, this.outputOffset, outRate);
+      this.stdoutStash = Buffer.alloc(0);
+      if (block) yield block;
+    }
+    const exitResult = await (this.exitPromise ?? Promise.resolve({ code: 0, signal: null }));
     if (exitResult.code !== null && exitResult.code !== 0) {
       const detail = this.stderr ? `: ${this.stderr.slice(0, 1024)}` : "";
       throw new Error(`ffmpeg exited ${exitResult.code}${detail}`);
     }
-    if (this.stdoutStash.length >= this.inputChannels * 4) {
-      this.handleStdoutBytes(Buffer.alloc(0));
-    }
-    yield* this.pending.splice(0);
   }
   async _destroy() {
     const child = this.child;
@@ -32404,8 +32543,9 @@ function windowSamplesFromMs(smoothingMs, sampleRate) {
   return Math.max(1, Math.round(smoothingMs * sampleRate / 1e3));
 }
 async function applyBackwardPassOverChunkBuffer(args) {
-  const { sourceBuffer, destBuffer, iir, chunkSize, minHeldBuffer } = args;
+  const { sourceBuffer, destBuffer, iir, chunkSize, minHeldBuffer, progress } = args;
   const totalFrames = sourceBuffer.frames;
+  const totalWork = totalFrames * 2;
   if (totalFrames === 0) return;
   if (chunkSize <= 0) {
     throw new Error(`applyBackwardPassOverChunkBuffer: chunkSize must be > 0 (got ${chunkSize})`);
@@ -32421,6 +32561,7 @@ async function applyBackwardPassOverChunkBuffer(args) {
   try {
     const backwardState = { value: 0 };
     let seeded = false;
+    let filteredFrames = 0;
     const sourceReader = await sourceBuffer.openReverseReader();
     try {
       for (; ; ) {
@@ -32433,12 +32574,15 @@ async function applyBackwardPassOverChunkBuffer(args) {
         }
         const filtered = iir.applyForwardPass(reversed, backwardState);
         await filteredReversed.write([filtered], sr, bd);
+        filteredFrames += reversed.length;
+        progress?.(filteredFrames, totalWork);
       }
     } finally {
       await sourceReader.close();
     }
     if (minHeldBuffer !== void 0) await minHeldBuffer.reset();
     const filteredReader = await filteredReversed.openReverseReader();
+    let restoredFrames = 0;
     try {
       for (; ; ) {
         const chunk = await filteredReader.read(chunkSize);
@@ -32460,6 +32604,8 @@ async function applyBackwardPassOverChunkBuffer(args) {
           }
         }
         await destBuffer.write([forwardOrder], sr, bd);
+        restoredFrames += stripeFrames;
+        progress?.(totalFrames + restoredFrames, totalWork);
       }
     } finally {
       await filteredReader.close();
@@ -32618,7 +32764,8 @@ async function iterateForTargets(args) {
     tolerance = DEFAULT_TOLERANCE,
     peakTolerance,
     seedB,
-    onAttempt
+    onAttempt,
+    progress
   } = args;
   const channelCount = buffer.channels;
   const frames = buffer.frames;
@@ -32680,7 +32827,10 @@ async function iterateForTargets(args) {
     let winnerLufsErr = Infinity;
     let winnerPeakErr = Infinity;
     let previousStepMagnitude = Infinity;
+    const attemptWork = frames * 4;
+    const totalWork = maxAttempts * attemptWork;
     for (let attemptIdx = 0; attemptIdx < maxAttempts; attemptIdx++) {
+      const attemptBase = attemptIdx * attemptWork;
       const tAttempt0 = Date.now();
       const anchors = {
         floorDb: anchorBase.floorDb,
@@ -32695,16 +32845,24 @@ async function iterateForTargets(args) {
         iir,
         halfWidth,
         forwardEnvelopeBuffer,
-        minHeldEnvelopeBuffer
+        minHeldEnvelopeBuffer,
+        progress: (done) => progress?.(attemptBase + done, totalWork)
       });
       await applyBackwardPassOverChunkBuffer({
         sourceBuffer: forwardEnvelopeBuffer,
         destBuffer: activeRef,
         iir,
         chunkSize: CHUNK_FRAMES3,
-        minHeldBuffer: minHeldEnvelopeBuffer
+        minHeldBuffer: minHeldEnvelopeBuffer,
+        progress: (done) => progress?.(attemptBase + frames + done, totalWork)
+      });
+      const measured = await measureAttemptOutput({
+        source: buffer,
+        sampleRate,
+        channelCount,
+        gSmoothed: activeRef,
+        progress: (done) => progress?.(attemptBase + frames * 3 + done, totalWork)
       });
-      const measured = await measureAttemptOutput({ source: buffer, sampleRate, channelCount, gSmoothed: activeRef });
       const lufsErr = measured.outputLufs - targetLufs;
       const peakErr = measured.outputTruePeakDb - effectiveTargetTp;
       const attempt = {
@@ -32785,7 +32943,7 @@ async function iterateForTargets(args) {
   }
 }
 async function streamCurveAndForwardIir(args) {
-  const { detectionEnvelope, anchors, iir, halfWidth, forwardEnvelopeBuffer, minHeldEnvelopeBuffer } = args;
+  const { detectionEnvelope, anchors, iir, halfWidth, forwardEnvelopeBuffer, minHeldEnvelopeBuffer, progress } = args;
   const totalFrames = detectionEnvelope.frames;
   if (totalFrames === 0) return;
   await detectionEnvelope.reset();
@@ -32820,13 +32978,14 @@ async function streamCurveAndForwardIir(args) {
       await forwardEnvelopeBuffer.write([forwardChunk], detectionSampleRate, detectionBitDepth);
       await minHeldEnvelopeBuffer.write([minHeldChunk], detectionSampleRate, detectionBitDepth);
     }
+    progress?.(consumedFrames, totalFrames);
     if (chunkLength < CHUNK_FRAMES3) break;
   }
   await forwardEnvelopeBuffer.flushWrites();
   await minHeldEnvelopeBuffer.flushWrites();
 }
 async function measureAttemptOutput(args) {
-  const { source, sampleRate, channelCount, gSmoothed } = args;
+  const { source, sampleRate, channelCount, gSmoothed, progress } = args;
   const accumulator = new LoudnessAccumulator(sampleRate, channelCount);
   const truePeakAccumulator = new TruePeakAccumulator(sampleRate, channelCount);
   const applyOutputScratch = [];
@@ -32835,6 +32994,8 @@ async function measureAttemptOutput(args) {
   }
   await source.reset();
   await gSmoothed.reset();
+  const totalFrames = source.frames;
+  let framesDone = 0;
   for (; ; ) {
     const sourceChunk = await source.read(CHUNK_FRAMES3);
     const chunkFrames = sourceChunk.samples[0]?.length ?? 0;
@@ -32856,6 +33017,8 @@ async function measureAttemptOutput(args) {
     });
     accumulator.push(transformed, chunkFrames);
     truePeakAccumulator.push(transformed, chunkFrames);
+    framesDone += chunkFrames;
+    progress?.(framesDone, totalFrames);
     if (chunkFrames < CHUNK_FRAMES3) break;
   }
   const result = accumulator.finalize();
@@ -33311,7 +33474,8 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
       tolerance
     });
     const tIterate0 = Date.now();
-    const attemptGate = createProgressGate(maxAttempts);
+    const totalWork = maxAttempts * buffer.frames * 4;
+    const progressGate = createProgressGate(totalWork);
     const result = await iterateForTargets({
       buffer,
       sampleRate,
@@ -33328,6 +33492,9 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
       peakTolerance,
       seedB,
       detectionEnvelope,
+      progress: (done, total) => {
+        if (progressGate(done, Date.now())) this.emitProgress("process", done, total);
+      },
       onAttempt: (attempt, attemptIndex) => {
         this.log("attempt", {
           attempt: attemptIndex + 1,
@@ -33338,7 +33505,6 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
           outputLra: attempt.outputLra,
           elapsedMs: attempt.elapsedMs
         });
-        if (attemptGate(attemptIndex + 1, Date.now())) this.emitProgress("process", attemptIndex + 1, maxAttempts);
       }
     });
     this.learnTimingMs.iteration = Date.now() - tIterate0;
@@ -34083,10 +34249,10 @@ async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addo
     for (let index = 0; index < got; index++) {
       let sample = 0;
       const ringPos = consumed % frameSize;
-      for (let ch = 0; ch < channelCount; ch++) {
-        const value = chunk.samples[ch]?.[index] ?? 0;
+      for (let channel = 0; channel < channelCount; channel++) {
+        const value = chunk.samples[channel]?.[index] ?? 0;
         sample = Math.fround(sample + value);
-        const channelRing = channelRings[ch];
+        const channelRing = channelRings[channel];
         if (channelRing) channelRing[ringPos] = value;
       }
       sumRing[ringPos] = sample;
@@ -34094,9 +34260,9 @@ async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addo
       while (nextFrame < frameCount && consumed >= nextFrame * hopSize + frameSize) {
         const start = nextFrame * hopSize;
         for (let pos = 0; pos < frameSize; pos++) window2[pos] = sumRing[(start + pos) % frameSize] ?? 0;
-        for (let ch = 0; ch < channelCount; ch++) {
-          const channelRing = channelRings[ch];
-          const channelWindow = channelWindows[ch];
+        for (let channel = 0; channel < channelCount; channel++) {
+          const channelRing = channelRings[channel];
+          const channelWindow = channelWindows[channel];
           if (!channelRing || !channelWindow) continue;
           for (let pos = 0; pos < frameSize; pos++) channelWindow[pos] = channelRing[(start + pos) % frameSize] ?? 0;
         }
@@ -34183,10 +34349,10 @@ var _LatticeApplyState = class _LatticeApplyState {
       const fraction = framePos - frame0;
       const row0 = rows[frame0] ?? this.trajectory.identity;
       const row1 = rows[frame1] ?? this.trajectory.identity;
-      for (let ch = 0; ch < channelCount; ch++) {
-        const inputValue = channels[ch]?.[index] ?? 0;
-        const outChannel = out[ch];
-        const chState = this.state[ch] ?? new Float32Array(order);
+      for (let channel = 0; channel < channelCount; channel++) {
+        const inputValue = channels[channel]?.[index] ?? 0;
+        const outChannel = out[channel];
+        const chState = this.state[channel] ?? new Float32Array(order);
         let signalValue = inputValue;
         for (let section = 0; section < order; section++) {
           const interpolated = (row0[section] ?? 0) + fraction * ((row1[section] ?? 0) - (row0[section] ?? 0));
@@ -34279,7 +34445,7 @@ var CrestReduceStream = class extends BufferedTransformStream {
       }
       applyState ?? (applyState = new LatticeApplyState(smoothedTrajectory, order, hopSize, blockChannelCount));
       const transformed = applyState.apply(block.samples, frames);
-      const samples = block.samples.map((inputChannel, ch) => transformed[ch] ?? inputChannel);
+      const samples = block.samples.map((inputChannel, channelIndex) => transformed[channelIndex] ?? inputChannel);
       yield { samples, offset: block.offset, sampleRate: block.sampleRate, bitDepth: block.bitDepth };
       appliedFrames += frames;
       const doneFrames = Math.min(appliedFrames, totalFrames);
@@ -34746,13 +34912,13 @@ var WindowReader = class {
     this.channels = channels;
     this.windowSamples = windowSamples;
     this.scratch = [];
-    for (let ch = 0; ch < channels; ch++) this.scratch.push(new Float32Array(windowSamples));
+    for (let channelIndex = 0; channelIndex < channels; channelIndex++) this.scratch.push(new Float32Array(windowSamples));
   }
   getScratch() {
     return this.scratch;
   }
   async preload(buffer, edgePadSamples) {
-    for (let ch = 0; ch < this.channels; ch++) this.scratch[ch].fill(0);
+    for (let channelIndex = 0; channelIndex < this.channels; channelIndex++) this.scratch[channelIndex].fill(0);
     this.virtualCursor = 0;
     this.bufferDrained = false;
     const headPad = Math.min(edgePadSamples, this.windowSamples);
@@ -34763,8 +34929,8 @@ var WindowReader = class {
   async advance(buffer, step) {
     if (step <= 0) return;
     const keep = this.windowSamples - step;
-    for (let ch = 0; ch < this.channels; ch++) {
-      const view = this.scratch[ch];
+    for (let channelIndex = 0; channelIndex < this.channels; channelIndex++) {
+      const view = this.scratch[channelIndex];
       if (keep > 0) view.copyWithin(0, step, this.windowSamples);
       view.fill(0, keep, this.windowSamples);
     }
@@ -34782,10 +34948,10 @@ var WindowReader = class {
         this.bufferDrained = true;
         return;
       }
-      for (let ch = 0; ch < this.channels; ch++) {
-        const src = chunk.samples[ch];
-        const dest = this.scratch[ch];
-        if (src) dest.set(src.subarray(0, chunkFrames), outOffset);
+      for (let channelIndex = 0; channelIndex < this.channels; channelIndex++) {
+        const sourceSamples = chunk.samples[channelIndex];
+        const dest = this.scratch[channelIndex];
+        if (sourceSamples) dest.set(sourceSamples.subarray(0, chunkFrames), outOffset);
       }
       outOffset += chunkFrames;
       remaining -= chunkFrames;
@@ -34947,8 +35113,8 @@ async function readSequentialPadded(chunkBuffer, channelIndex, frames, out, hopS
     const chunk = await chunkBuffer.read(toRead);
     const chunkFrames = chunk.samples[0]?.length ?? 0;
     if (chunkFrames === 0) return;
-    const src = chunk.samples[channelIndex];
-    if (src) out.set(src.subarray(0, chunkFrames), headPad + written);
+    const sourceSamples = chunk.samples[channelIndex];
+    if (sourceSamples) out.set(sourceSamples.subarray(0, chunkFrames), headPad + written);
     written += chunkFrames;
     toRead -= chunkFrames;
   }
@@ -35030,7 +35196,7 @@ var DeBleedStream = class extends BufferedTransformStream {
     const targetPaddeds = Array.from({ length: channels }, () => new Float32Array(warmupFrames * hopSize + (fftSize - hopSize)));
     const refPaddeds = Array.from({ length: refCount }, () => new Float32Array(warmupFrames * hopSize + (fftSize - hopSize)));
     await buffer.reset();
-    for (let ch = 0; ch < channels; ch++) targetPaddeds[ch].fill(0);
+    for (let channelIndex = 0; channelIndex < channels; channelIndex++) targetPaddeds[channelIndex].fill(0);
     const targetSamples = warmupFrames * hopSize + (fftSize - hopSize);
     let written = 0;
     let toRead = Math.min(targetSamples, buffer.frames);
@@ -35038,9 +35204,9 @@ var DeBleedStream = class extends BufferedTransformStream {
       const chunk = await buffer.read(toRead);
       const chunkFrames = chunk.samples[0]?.length ?? 0;
       if (chunkFrames === 0) break;
-      for (let ch = 0; ch < channels; ch++) {
-        const src = chunk.samples[ch];
-        if (src) targetPaddeds[ch].set(src.subarray(0, chunkFrames), written);
+      for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+        const sourceSamples = chunk.samples[channelIndex];
+        if (sourceSamples) targetPaddeds[channelIndex].set(sourceSamples.subarray(0, chunkFrames), written);
       }
       written += chunkFrames;
       toRead -= chunkFrames;
@@ -35051,13 +35217,13 @@ var DeBleedStream = class extends BufferedTransformStream {
     }
     const targetStftOutputs = Array.from({ length: channels }, () => allocateStftOutput(warmupFrames, numBins));
     const refStftOutputs = Array.from({ length: refCount }, () => allocateStftOutput(warmupFrames, numBins));
-    const targetStfts = targetPaddeds.map((padded, ch) => stft(padded, fftSize, hopSize, targetStftOutputs[ch], this.fftBackend, this.fftAddonOptions));
+    const targetStfts = targetPaddeds.map((padded, channelIndex) => stft(padded, fftSize, hopSize, targetStftOutputs[channelIndex], this.fftBackend, this.fftAddonOptions));
     const refStfts = refPaddeds.map((padded, refIndex) => stft(padded, fftSize, hopSize, refStftOutputs[refIndex], this.fftBackend, this.fftAddonOptions));
     const maxRefPows = refStfts.map((refStft) => findMaxRefPower(refStft.real, refStft.imag, refStft.frames, numBins));
     const weightEpsilons = maxRefPows.map((maxPow) => 1e-10 * (maxPow + 1e-20));
     const seedsByChannel = [];
-    for (let ch = 0; ch < channels; ch++) {
-      const targetStft = targetStfts[ch];
+    for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+      const targetStft = targetStfts[channelIndex];
       const accumulators = refStfts.map(() => createTransferAccumulator(numBins));
       for (let refIndex = 0; refIndex < refCount; refIndex++) {
         const refStft = refStfts[refIndex];
@@ -35157,8 +35323,8 @@ var DeBleedStream = class extends BufferedTransformStream {
         const _tstft = _profStart();
         const targetScratch = targetReader.getScratch();
         const targetStfts = [];
-        for (let ch = 0; ch < channels; ch++) {
-          const stftOut = stft(targetScratch[ch].subarray(0, winSamples), fftSize, hopSize, targetStftOutputs[ch], this.fftBackend, this.fftAddonOptions);
+        for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+          const stftOut = stft(targetScratch[channelIndex].subarray(0, winSamples), fftSize, hopSize, targetStftOutputs[channelIndex], this.fftBackend, this.fftAddonOptions);
           targetStfts.push(stftOut);
         }
         const refStftsForChunk = [];
@@ -35171,12 +35337,12 @@ var DeBleedStream = class extends BufferedTransformStream {
         const cleanedByChannel = [];
         const sHatRe = new Float32Array(numBins);
         const sHatIm = new Float32Array(numBins);
-        for (let ch = 0; ch < channels; ch++) {
-          const kalmanStates = kalmanStatesByCh[ch];
-          const interfererPsd = interfererPsdByCh[ch];
-          const msadChannelStates = msadChannelStatesByCh[ch];
-          const ispStates = ispStatesByCh[ch];
-          const targetStft = targetStfts[ch];
+        for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+          const kalmanStates = kalmanStatesByCh[channelIndex];
+          const interfererPsd = interfererPsdByCh[channelIndex];
+          const msadChannelStates = msadChannelStatesByCh[channelIndex];
+          const ispStates = ispStatesByCh[channelIndex];
+          const targetStft = targetStfts[channelIndex];
           for (let frame = 0; frame < winFrames; frame++) {
             const frameOffset = frame * numBins;
             const frameReal = targetStft.real.subarray(frameOffset, frameOffset + numBins);
@@ -35274,13 +35440,13 @@ var DeBleedStream = class extends BufferedTransformStream {
         if (!clip) continue;
         const { clipStart, sliceFromOffset, sliceLength } = clip;
         const writeSamplesByChannel = [];
-        for (let ch = 0; ch < channels; ch++) {
-          writeSamplesByChannel.push(cleanedByChannel[ch].subarray(sliceFromOffset, sliceFromOffset + sliceLength));
+        for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+          writeSamplesByChannel.push(cleanedByChannel[channelIndex].subarray(sliceFromOffset, sliceFromOffset + sliceLength));
         }
         if (clipStart > outputBuffer.frames) {
           const padFrames = clipStart - outputBuffer.frames;
           const zeroSamples = [];
-          for (let ch = 0; ch < channels; ch++) zeroSamples.push(new Float32Array(padFrames));
+          for (let channelIndex = 0; channelIndex < channels; channelIndex++) zeroSamples.push(new Float32Array(padFrames));
           const _twritePad = _profStart();
           await outputBuffer.write(zeroSamples, sampleRate, bitDepth);
           _profAdd("write", _twritePad);
@@ -35294,7 +35460,7 @@ var DeBleedStream = class extends BufferedTransformStream {
       if (outputBuffer.frames < totalFrames) {
         const padFrames = totalFrames - outputBuffer.frames;
         const zeroSamples = [];
-        for (let ch = 0; ch < channels; ch++) zeroSamples.push(new Float32Array(padFrames));
+        for (let channelIndex = 0; channelIndex < channels; channelIndex++) zeroSamples.push(new Float32Array(padFrames));
         await outputBuffer.write(zeroSamples, sampleRate, bitDepth);
       }
       await outputBuffer.reset();
@@ -35376,6 +35542,31 @@ function createOnnxSession(addonPath, modelPath, options, log) {
   };
 }
 
+// src/utils/resample-composition.ts
+function createResampleComposition(options) {
+  const edgeRate = options.context.sampleRate;
+  if (edgeRate === options.modelRate) return void 0;
+  const upResample = new FfmpegStream(
+    ffmpeg({
+      ffmpegPath: options.ffmpegPath,
+      args: ["-af", `aresample=${options.modelRate}`],
+      outputSampleRate: options.modelRate
+    }),
+    options.streamContext
+  );
+  const downResample = new FfmpegStream(
+    ffmpeg({
+      ffmpegPath: options.ffmpegPath,
+      args: ["-af", `aresample=${edgeRate}`],
+      outputSampleRate: edgeRate
+    }),
+    options.streamContext
+  );
+  upResample._setup(options.context);
+  downResample._setup(options.context);
+  return { upResample, downResample };
+}
+
 // src/transforms/deep-filter-net-3/utils/dfn.ts
 var DFN3_SAMPLE_RATE = 48e3;
 var DFN3_HOP_SIZE = 480;
@@ -35428,9 +35619,8 @@ function processDfnBlock(dfnState, signal, session, attenLimDb) {
 var DFN3_BUFFER_SIZE = 100 * DFN3_HOP_SIZE;
 var schema23 = external_exports.object({
   modelPath: external_exports.string().default("").meta({ input: "file", mode: "open", accept: ".onnx", binary: "dfn3", download: "https://github.com/yuyun2000/SpeechDenoiser" }).describe("DeepFilterNet3 48 kHz denoiser model (.onnx)"),
-  ffmpegPath: external_exports.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 only used when sampleRate \u2260 48000 to chain up/down resamplers around the inference stream; can be left blank when sampleRate === 48000."),
+  ffmpegPath: external_exports.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 used when the input audio is not 48 kHz to chain up/down resamplers around the inference stream; can be left blank for 48 kHz input."),
   onnxAddonPath: external_exports.string().default("").meta({ input: "file", mode: "open", binary: "onnx-addon", download: "https://github.com/visionsofparadise/onnx-runtime-addon" }).describe("ONNX Runtime native addon"),
-  sampleRate: external_exports.number().int().positive().describe("Source audio sample rate in Hz. Required. When \u2260 48000, ffmpeg resampling is chained around the inference stream via _setup composition."),
   attenuation: external_exports.number().min(0).max(100).default(30).describe("Attenuation cap in dB. Maps to the ONNX `atten_lim_db` input; 0 = no cap")
 });
 var DeepFilterNet3Stream = class extends BufferedTransformStream {
@@ -35442,26 +35632,11 @@ var DeepFilterNet3Stream = class extends BufferedTransformStream {
   }
   _setup(context) {
     this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: ["cpu"] }, (message, data) => this.log(message, data));
-    const sourceRate = this.properties.sampleRate;
-    if (sourceRate === DFN3_SAMPLE_RATE) return;
-    this.upResample = new FfmpegStream(
-      ffmpeg({
-        ffmpegPath: this.properties.ffmpegPath,
-        args: ["-af", `aresample=${DFN3_SAMPLE_RATE}`],
-        outputSampleRate: DFN3_SAMPLE_RATE
-      }),
-      this.renderContext
-    );
-    this.downResample = new FfmpegStream(
-      ffmpeg({
-        ffmpegPath: this.properties.ffmpegPath,
-        args: ["-af", `aresample=${sourceRate}`],
-        outputSampleRate: sourceRate
-      }),
-      this.renderContext
-    );
-    this.upResample._setup(context);
-    this.downResample._setup(context);
+    const composition = createResampleComposition({ context, streamContext: this.renderContext, ffmpegPath: this.properties.ffmpegPath, modelRate: DFN3_SAMPLE_RATE });
+    if (composition) {
+      this.upResample = composition.upResample;
+      this.downResample = composition.downResample;
+    }
   }
   _pipe(input) {
     if (!this.upResample || !this.downResample) return super._pipe(input);
@@ -35469,9 +35644,6 @@ var DeepFilterNet3Stream = class extends BufferedTransformStream {
   }
   async *_transform(buffered) {
     if (!this.session) throw new Error("deep-filter-net-3: stream not set up");
-    if (this.sampleRate !== void 0 && this.sampleRate !== DFN3_SAMPLE_RATE) {
-      throw new Error(`deep-filter-net-3: inference stream received ${this.sampleRate} Hz audio; expected ${DFN3_SAMPLE_RATE} Hz (composition in _setup should have resampled \u2014 check sampleRate property and pipeline setup)`);
-    }
     const session = this.session;
     const frames = buffered.frames;
     const channels = buffered.channels;
@@ -35482,9 +35654,9 @@ var DeepFilterNet3Stream = class extends BufferedTransformStream {
       this.dfnStates.push(createDfnState());
     }
     const outputChannels = [];
-    for (let ch = 0; ch < channels; ch++) {
-      const channel = chunk.samples[ch];
-      const dfnState = this.dfnStates[ch];
+    for (let channelIndex = 0; channelIndex < channels; channelIndex++) {
+      const channel = chunk.samples[channelIndex];
+      const dfnState = this.dfnStates[channelIndex];
       if (!channel || !dfnState) {
         outputChannels.push(new Float32Array(frames));
         continue;
@@ -35504,7 +35676,7 @@ var DeepFilterNet3Node = class extends TransformNode {
 };
 DeepFilterNet3Node.nodeName = "DeepFilterNet3 (Denoiser)";
 DeepFilterNet3Node.packageName = PACKAGE_NAME;
-DeepFilterNet3Node.description = "Remove background noise from speech using DeepFilterNet3 (48 kHz full-band CRN)";
+DeepFilterNet3Node.description = "Remove background noise from speech using DeepFilterNet3 (48 kHz full-band CRN). At other source rates, the internal resampling round trip may add or drop up to two source-rate frames.";
 DeepFilterNet3Node.schema = schema23;
 DeepFilterNet3Node.Stream = DeepFilterNet3Stream;
 function deepFilterNet3(options) {
@@ -35630,15 +35802,14 @@ var DtlnBlockStream = class {
 // src/transforms/dtln/utils/pump.ts
 var DTLN_SAMPLE_RATE = 16e3;
 var CHUNK_FRAMES5 = 16e3;
-var RESAMPLE_DRAIN_CHUNK = 16384;
 var STEP_BATCH_SIZE = 16e3;
 var WARMUP_SAMPLES = WARMUP_SHIFTS * BLOCK_SHIFT;
 function stepAllChannels(args) {
   const { channels, streams, inputs, stepBatch, stepBatchLen, batchSize, warmupRemaining } = args;
   const stepOutputs = [];
-  for (let ch = 0; ch < channels; ch++) {
-    const stream = streams[ch];
-    const input = inputs[ch];
+  for (let channel = 0; channel < channels; channel++) {
+    const stream = streams[channel];
+    const input = inputs[channel];
     if (!stream || !input) {
       stepOutputs.push(new Float32Array(BLOCK_SHIFT));
       continue;
@@ -35666,11 +35837,11 @@ function appendToStepBatch(args) {
     const space = batchSize - batchLen;
     const copy = Math.min(space, length - offset);
     const firstSample = samples[0];
-    for (let ch = 0; ch < channels; ch++) {
-      const src = samples[ch] ?? firstSample;
-      const dest = stepBatch[ch];
-      if (!src || !dest) continue;
-      dest.set(src.subarray(offset, offset + copy), batchLen);
+    for (let channel = 0; channel < channels; channel++) {
+      const sourceChannel = samples[channel] ?? firstSample;
+      const dest = stepBatch[channel];
+      if (!sourceChannel || !dest) continue;
+      dest.set(sourceChannel.subarray(offset, offset + copy), batchLen);
     }
     batchLen += copy;
     offset += copy;
@@ -35678,90 +35849,39 @@ function appendToStepBatch(args) {
   return { stepBatchLen: batchLen, warmupRemaining: warmupLeft };
 }
 async function commitStepBatch(args) {
-  const { stepBatch, length, channels, pair, output, sourceRate, bitDepth, originalFrames, writerState } = args;
+  const { stepBatch, length, channels, output, sampleRate, bitDepth, originalFrames, writerState } = args;
   if (length === 0) return;
   const slices = [];
-  for (let ch = 0; ch < channels; ch++) {
-    const src = stepBatch[ch] ?? new Float32Array(length);
-    slices.push(src.subarray(0, length));
-  }
-  if (pair) {
-    await pair.resampleOut.write(slices);
-  } else {
-    const remaining = Math.max(0, originalFrames - writerState.written);
-    if (remaining > 0) {
-      const take = Math.min(length, remaining);
-      const writeChannels = take === length ? slices : slices.map((channel) => channel.subarray(0, take));
-      await output.write(writeChannels, sourceRate, bitDepth);
-      writerState.written += take;
-    }
-  }
-}
-async function drainResampleOutToBuffer(args) {
-  const { resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState } = args;
-  for (; ; ) {
-    const chunk = await resampleOut.read(RESAMPLE_DRAIN_CHUNK);
-    const got = chunk[0]?.length ?? 0;
-    if (got === 0) return;
-    await commitResampledFrames({ chunk, channels, output, sourceRate, bitDepth, originalFrames, writerState });
-  }
+  for (let channel = 0; channel < channels; channel++) {
+    const sourceChannel = stepBatch[channel] ?? new Float32Array(length);
+    slices.push(sourceChannel.subarray(0, length));
+  }
+  const remaining = Math.max(0, originalFrames - writerState.written);
+  if (remaining === 0) return;
+  const take = Math.min(length, remaining);
+  const writeChannels = take === length ? slices : slices.map((channel) => channel.subarray(0, take));
+  await output.write(writeChannels, sampleRate, bitDepth);
+  writerState.written += take;
 }
 async function pullNextChunkAt16k(args) {
-  const { buffer, pair, channels, frames } = args;
-  if (!pair) {
-    const chunk = await buffer.read(frames);
-    const got2 = chunk.samples[0]?.length ?? 0;
-    if (got2 === 0) return void 0;
-    const out2 = [];
-    for (let ch = 0; ch < channels; ch++) {
-      out2.push(chunk.samples[ch] ?? chunk.samples[0] ?? new Float32Array(got2));
-    }
-    return out2;
-  }
-  const out = await pair.resampleIn.read(frames);
-  const got = out[0]?.length ?? 0;
+  const { buffer, channels, frames } = args;
+  const chunk = await buffer.read(frames);
+  const got = chunk.samples[0]?.length ?? 0;
   if (got === 0) return void 0;
-  return out;
-}
-async function pumpSourceToResampleIn(args) {
-  const { buffer, resampleIn, channels, chunkFrames } = args;
-  for (; ; ) {
-    const sourceChunk = await buffer.read(chunkFrames);
-    const sourceFrames = sourceChunk.samples[0]?.length ?? 0;
-    if (sourceFrames === 0) break;
-    const sourceChannels = [];
-    for (let ch = 0; ch < channels; ch++) {
-      sourceChannels.push(sourceChunk.samples[ch] ?? sourceChunk.samples[0] ?? new Float32Array(sourceFrames));
-    }
-    await resampleIn.write(sourceChannels);
-    if (sourceFrames < chunkFrames) break;
-  }
-  await resampleIn.end();
-}
-async function commitResampledFrames(args) {
-  const { chunk, channels, output, sourceRate, bitDepth, originalFrames, writerState } = args;
-  const firstChannel = chunk[0];
-  const got = firstChannel?.length ?? 0;
-  if (got === 0 || !firstChannel) return;
-  const remaining = originalFrames - writerState.written;
-  if (remaining <= 0) return;
-  const take = Math.min(got, remaining);
-  const writeChannels = [];
-  for (let ch = 0; ch < channels; ch++) {
-    const src = chunk[ch] ?? firstChannel;
-    writeChannels.push(take === got ? src : src.subarray(0, take));
+  const out = [];
+  for (let channel = 0; channel < channels; channel++) {
+    out.push(chunk.samples[channel] ?? chunk.samples[0] ?? new Float32Array(got));
   }
-  await output.write(writeChannels, sourceRate, bitDepth);
-  writerState.written += take;
+  return out;
 }
-async function padTail(output, channels, originalFrames, written, sourceRate, bitDepth) {
+async function padTail(output, channels, originalFrames, written, sampleRate, bitDepth) {
   if (written >= originalFrames) return;
   const missing = originalFrames - written;
   const padChannels = [];
   for (let channel = 0; channel < Math.max(1, channels); channel++) {
     padChannels.push(new Float32Array(missing));
   }
-  await output.write(padChannels, sourceRate, bitDepth);
+  await output.write(padChannels, sampleRate, bitDepth);
 }
 
 // src/transforms/dtln/index.ts
@@ -35774,9 +35894,10 @@ var schema24 = external_exports.object({
   fftwAddonPath: external_exports.string().default("").meta({ input: "file", mode: "open", binary: "fftw-addon", download: "https://github.com/visionsofparadise/fftw-addon" }).describe("FFTW native addon \u2014 CPU FFT acceleration")
 });
 var DtlnStream = class extends BufferedTransformStream {
-  constructor() {
-    super(...arguments);
+  constructor(node, context) {
+    super(node, context);
     this.blockSize = WHOLE_FILE;
+    this.renderContext = context;
   }
   _setup(context) {
     const onnxProviders = filterOnnxProviders(context.executionProviders);
@@ -35786,30 +35907,22 @@ var DtlnStream = class extends BufferedTransformStream {
     const fft2 = initFftBackend(cpuProviders.length > 0 ? cpuProviders : ["cpu"], this.properties);
     this.fftBackend = fft2.backend;
     this.fftAddonOptions = fft2.addonOptions;
+    const composition = createResampleComposition({ context, streamContext: this.renderContext, ffmpegPath: this.properties.ffmpegPath, modelRate: DTLN_SAMPLE_RATE });
+    if (composition) {
+      this.upResample = composition.upResample;
+      this.downResample = composition.downResample;
+    }
+  }
+  _pipe(input) {
+    if (!this.upResample || !this.downResample) return super._pipe(input);
+    return this.downResample._pipe(super._pipe(this.upResample._pipe(input)));
   }
   async *_transform(buffered) {
     const originalFrames = buffered.frames;
     const channels = buffered.channels;
     if (originalFrames === 0 || channels === 0) return;
-    const sourceRate = this.sampleRate ?? DTLN_SAMPLE_RATE;
     const bitDepth = this.bitDepth;
-    const needsResample = sourceRate !== DTLN_SAMPLE_RATE;
     await buffered.reset();
-    let pair;
-    if (needsResample) {
-      pair = {
-        resampleIn: new ResampleStream(this.properties.ffmpegPath, {
-          sourceSampleRate: sourceRate,
-          targetSampleRate: DTLN_SAMPLE_RATE,
-          channels
-        }),
-        resampleOut: new ResampleStream(this.properties.ffmpegPath, {
-          sourceSampleRate: DTLN_SAMPLE_RATE,
-          targetSampleRate: sourceRate,
-          channels
-        })
-      };
-    }
     const output = new BlockBuffer();
     try {
       await this.runMainPass({
@@ -35817,40 +35930,32 @@ var DtlnStream = class extends BufferedTransformStream {
         output,
         channels,
         originalFrames,
-        sourceRate,
-        bitDepth,
-        pair
+        bitDepth
       });
       await output.reset();
       yield* output.iterate(CHUNK_FRAMES5);
     } finally {
-      if (pair) {
-        await Promise.all([pair.resampleIn.close(), pair.resampleOut.close()]);
-      }
       await output.close();
     }
   }
   async runMainPass(args) {
-    const { buffer, output, channels, originalFrames, sourceRate, bitDepth, pair } = args;
+    const { buffer, output, channels, originalFrames, bitDepth } = args;
     const streams = [];
-    for (let ch = 0; ch < channels; ch++) {
+    for (let channel = 0; channel < channels; channel++) {
       streams.push(new DtlnBlockStream({ session1: this.session1, session2: this.session2, fftBackend: this.fftBackend, fftAddonOptions: this.fftAddonOptions }));
     }
     const stepAccum = [];
-    for (let ch = 0; ch < channels; ch++) stepAccum.push(new Float32Array(BLOCK_SHIFT));
+    for (let channel = 0; channel < channels; channel++) stepAccum.push(new Float32Array(BLOCK_SHIFT));
     let stepAccumLen = 0;
     const stepBatch = [];
-    for (let ch = 0; ch < channels; ch++) stepBatch.push(new Float32Array(STEP_BATCH_SIZE));
+    for (let channel = 0; channel < channels; channel++) stepBatch.push(new Float32Array(STEP_BATCH_SIZE));
     let stepBatchLen = 0;
     let samplesFed = 0;
     let warmupRemaining = WARMUP_SAMPLES;
     const writerState = { written: 0 };
-    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES5 }) : Promise.resolve();
-    const drainerDone = pair !== void 0 ? drainResampleOutToBuffer({ resampleOut: pair.resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState }) : Promise.resolve();
-    const total16k = Math.round(originalFrames * DTLN_SAMPLE_RATE / sourceRate);
-    const progressGate = createProgressGate(total16k);
+    const progressGate = createProgressGate(originalFrames);
     for (; ; ) {
-      const got16k = await pullNextChunkAt16k({ buffer, pair, channels, frames: CHUNK_FRAMES5 });
+      const got16k = await pullNextChunkAt16k({ buffer, channels, frames: CHUNK_FRAMES5 });
       if (got16k === void 0) break;
       const firstChannel = got16k[0];
       const chunkFrames = firstChannel?.length ?? 0;
@@ -35859,11 +35964,11 @@ var DtlnStream = class extends BufferedTransformStream {
       while (consumed < chunkFrames) {
         const need = BLOCK_SHIFT - stepAccumLen;
         const take = Math.min(need, chunkFrames - consumed);
-        for (let ch = 0; ch < channels; ch++) {
-          const src = got16k[ch] ?? firstChannel;
-          const dest = stepAccum[ch];
-          if (!src || !dest) continue;
-          dest.set(src.subarray(consumed, consumed + take), stepAccumLen);
+        for (let channel = 0; channel < channels; channel++) {
+          const sourceChannel = got16k[channel] ?? firstChannel;
+          const dest = stepAccum[channel];
+          if (!sourceChannel || !dest) continue;
+          dest.set(sourceChannel.subarray(consumed, consumed + take), stepAccumLen);
         }
         stepAccumLen += take;
         consumed += take;
@@ -35874,50 +35979,45 @@ var DtlnStream = class extends BufferedTransformStream {
           samplesFed += BLOCK_SHIFT;
           stepAccumLen = 0;
           if (stepBatchLen >= STEP_BATCH_SIZE) {
-            await commitStepBatch({ stepBatch, length: stepBatchLen, channels, pair, output, sourceRate, bitDepth, originalFrames, writerState });
+            await commitStepBatch({ stepBatch, length: stepBatchLen, channels, output, sampleRate: DTLN_SAMPLE_RATE, bitDepth, originalFrames, writerState });
             stepBatchLen = 0;
           }
         }
       }
-      const doneFrames = Math.min(samplesFed, total16k);
-      if (progressGate(doneFrames, Date.now())) this.emitProgress("process", doneFrames, total16k);
+      const doneFrames = Math.min(samplesFed, originalFrames);
+      if (progressGate(doneFrames, Date.now())) this.emitProgress("process", doneFrames, originalFrames);
     }
-    await pumpDone;
     if (samplesFed > 0 && samplesFed < BLOCK_LEN) {
       const zeroInputs = [];
-      for (let ch = 0; ch < channels; ch++) zeroInputs.push(new Float32Array(BLOCK_SHIFT));
+      for (let channel = 0; channel < channels; channel++) zeroInputs.push(new Float32Array(BLOCK_SHIFT));
       while (samplesFed < BLOCK_LEN) {
         const result = stepAllChannels({ channels, streams, inputs: zeroInputs, stepBatch, stepBatchLen, batchSize: STEP_BATCH_SIZE, warmupRemaining });
         stepBatchLen = result.stepBatchLen;
         warmupRemaining = result.warmupRemaining;
         samplesFed += BLOCK_SHIFT;
         if (stepBatchLen >= STEP_BATCH_SIZE) {
-          await commitStepBatch({ stepBatch, length: stepBatchLen, channels, pair, output, sourceRate, bitDepth, originalFrames, writerState });
+          await commitStepBatch({ stepBatch, length: stepBatchLen, channels, output, sampleRate: DTLN_SAMPLE_RATE, bitDepth, originalFrames, writerState });
           stepBatchLen = 0;
         }
       }
     }
     const flushOutputs = [];
-    for (let ch = 0; ch < channels; ch++) flushOutputs.push(streams[ch]?.flush() ?? new Float32Array(0));
+    for (let channel = 0; channel < channels; channel++) flushOutputs.push(streams[channel]?.flush() ?? new Float32Array(0));
     const flushLen = flushOutputs[0]?.length ?? 0;
     if (flushLen > 0) {
       const result = appendToStepBatch({ samples: flushOutputs, channels, stepBatch, stepBatchLen, batchSize: STEP_BATCH_SIZE, warmupRemaining });
       stepBatchLen = result.stepBatchLen;
       warmupRemaining = result.warmupRemaining;
       if (stepBatchLen >= STEP_BATCH_SIZE) {
-        await commitStepBatch({ stepBatch, length: stepBatchLen, channels, pair, output, sourceRate, bitDepth, originalFrames, writerState });
+        await commitStepBatch({ stepBatch, length: stepBatchLen, channels, output, sampleRate: DTLN_SAMPLE_RATE, bitDepth, originalFrames, writerState });
         stepBatchLen = 0;
       }
     }
     if (stepBatchLen > 0) {
-      await commitStepBatch({ stepBatch, length: stepBatchLen, channels, pair, output, sourceRate, bitDepth, originalFrames, writerState });
+      await commitStepBatch({ stepBatch, length: stepBatchLen, channels, output, sampleRate: DTLN_SAMPLE_RATE, bitDepth, originalFrames, writerState });
       stepBatchLen = 0;
     }
-    if (pair) {
-      await pair.resampleOut.end();
-    }
-    await drainerDone;
-    await padTail(output, channels, originalFrames, writerState.written, sourceRate, bitDepth);
+    await padTail(output, channels, originalFrames, writerState.written, DTLN_SAMPLE_RATE, bitDepth);
   }
 };
 var DtlnNode = class extends TransformNode {
@@ -35994,12 +36094,12 @@ function computeIstftScaled(real, imag, outputLength) {
 // src/transforms/htdemucs/utils/stems.ts
 function buildModelInput(segLeft, segRight, stftLeft, stftRight, segmentLength, xBins, xFrames) {
   const xData = new Float32Array(4 * xBins * xFrames);
-  for (let ch = 0; ch < 2; ch++) {
-    const stftCh = ch === 0 ? stftLeft : stftRight;
+  for (let channel = 0; channel < 2; channel++) {
+    const stftCh = channel === 0 ? stftLeft : stftRight;
     for (let freq = 0; freq < xBins; freq++) {
       for (let frame = 0; frame < xFrames; frame++) {
-        const realIdx = 2 * ch * xBins * xFrames + freq * xFrames + frame;
-        const imagIdx = (2 * ch + 1) * xBins * xFrames + freq * xFrames + frame;
+        const realIdx = 2 * channel * xBins * xFrames + freq * xFrames + frame;
+        const imagIdx = (2 * channel + 1) * xBins * xFrames + freq * xFrames + frame;
         const srcFrame = frame + 2;
         xData[realIdx] = stftCh.real[srcFrame]?.[freq] ?? 0;
         xData[imagIdx] = stftCh.imag[srcFrame]?.[freq] ?? 0;
@@ -36034,8 +36134,8 @@ function mixStemsToStereo(stemAccum, sumWeight, stemGains, stats, nStable) {
 function extractStems(xtOut, xOut, workspace, stemOutputs, weight, segmentOffset, chunkLength, segmentLength) {
   const { freqRealBuffers, freqImagBuffers, nbFrames, stftLen, stftPad, pad: pad2, xBins, xFrames } = workspace;
   for (let source = 0; source < 4; source++) {
-    for (let ch = 0; ch < 2; ch++) {
-      const xtIndex = source * 2 * segmentLength + ch * segmentLength;
+    for (let channel = 0; channel < 2; channel++) {
+      const xtIndex = source * 2 * segmentLength + channel * segmentLength;
       for (let frame = 0; frame < nbFrames; frame++) {
         freqRealBuffers[frame]?.fill(0);
         freqImagBuffers[frame]?.fill(0);
@@ -36044,8 +36144,8 @@ function extractStems(xtOut, xOut, workspace, stemOutputs, weight, segmentOffset
         const baseOffset = source * 4 * xBins * xFrames;
         for (let freq = 0; freq < xBins; freq++) {
           for (let frame = 0; frame < xFrames; frame++) {
-            const realIdx = baseOffset + 2 * ch * xBins * xFrames + freq * xFrames + frame;
-            const imagIdx = baseOffset + (2 * ch + 1) * xBins * xFrames + freq * xFrames + frame;
+            const realIdx = baseOffset + 2 * channel * xBins * xFrames + freq * xFrames + frame;
+            const imagIdx = baseOffset + (2 * channel + 1) * xBins * xFrames + freq * xFrames + frame;
             const destFrame = frame + 2;
             const realArr = freqRealBuffers[destFrame];
             const imagArr = freqImagBuffers[destFrame];
@@ -36063,10 +36163,10 @@ function extractStems(xtOut, xOut, workspace, stemOutputs, weight, segmentOffset
         const freqVal = freqWaveform[freqOffset + index] ?? 0;
         const combined = timeVal + freqVal;
         const wt = weight[index] ?? 1;
-        const outIdx = source * 2 + ch;
-        const arr = stemOutputs[outIdx];
-        if (arr) {
-          arr[segmentOffset + index] = (arr[segmentOffset + index] ?? 0) + combined * wt;
+        const outIdx = source * 2 + channel;
+        const stemOutput = stemOutputs[outIdx];
+        if (stemOutput) {
+          stemOutput[segmentOffset + index] = (stemOutput[segmentOffset + index] ?? 0) + combined * wt;
         }
       }
     }
@@ -36088,41 +36188,33 @@ var SEGMENT_SAMPLES = 343980;
 var OVERLAP = 0.25;
 var TRANSITION_POWER = 1;
 var CHUNK_FRAMES6 = 44100;
-var RESAMPLE_DRAIN_CHUNK2 = 16384;
 var STEM_OUTPUTS = 4 * 2;
 var HtdemucsStream = class extends BufferedTransformStream {
-  constructor() {
-    super(...arguments);
+  constructor(node, context) {
+    super(node, context);
     this.blockSize = WHOLE_FILE;
+    this.renderContext = context;
   }
-  _setup(_context) {
+  _setup(context) {
     this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: ["cpu"] }, (message, data) => this.log(message, data));
+    const composition = createResampleComposition({ context, streamContext: this.renderContext, ffmpegPath: this.properties.ffmpegPath, modelRate: HTDEMUCS_SAMPLE_RATE });
+    if (composition) {
+      this.upResample = composition.upResample;
+      this.downResample = composition.downResample;
+    }
+  }
+  _pipe(input) {
+    if (!this.upResample || !this.downResample) return super._pipe(input);
+    return this.downResample._pipe(super._pipe(this.upResample._pipe(input)));
   }
   async *_transform(buffered) {
     const originalFrames = buffered.frames;
     const channels = buffered.channels;
     if (originalFrames === 0 || channels === 0) return;
-    const sourceRate = this.sampleRate ?? HTDEMUCS_SAMPLE_RATE;
     const bitDepth = this.bitDepth;
-    const needsResample = sourceRate !== HTDEMUCS_SAMPLE_RATE;
     const stats = await computeStreamingStats(buffered, channels);
     this.log("streaming stats computed", { mean: stats.mean, std: stats.std });
     await buffered.reset();
-    let pair;
-    if (needsResample) {
-      pair = {
-        resampleIn: new ResampleStream(this.properties.ffmpegPath, {
-          sourceSampleRate: sourceRate,
-          targetSampleRate: HTDEMUCS_SAMPLE_RATE,
-          channels: 2
-        }),
-        resampleOut: new ResampleStream(this.properties.ffmpegPath, {
-          sourceSampleRate: HTDEMUCS_SAMPLE_RATE,
-          targetSampleRate: sourceRate,
-          channels: 2
-        })
-      };
-    }
     const output = new BlockBuffer();
     try {
       await this.runMainPass({
@@ -36130,26 +36222,19 @@ var HtdemucsStream = class extends BufferedTransformStream {
         output,
         channels,
         originalFrames,
-        sourceRate,
         bitDepth,
-        stats,
-        pair
+        stats
       });
       await output.reset();
       yield* output.iterate(CHUNK_FRAMES6);
     } finally {
-      if (pair) {
-        await Promise.all([pair.resampleIn.close(), pair.resampleOut.close()]);
-      }
       await output.close();
     }
   }
   async runMainPass(args) {
-    const { buffer, output, channels, originalFrames, sourceRate, bitDepth, stats, pair } = args;
+    const { buffer, output, channels, originalFrames, bitDepth, stats } = args;
     const stride = Math.round((1 - OVERLAP) * SEGMENT_SAMPLES);
     const writerState = { written: 0 };
-    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn2({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES6 }) : Promise.resolve();
-    const drainerDone = pair !== void 0 ? drainResampleOutToBuffer2({ resampleOut: pair.resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState }) : Promise.resolve();
     const weight = buildTriangularWeight(SEGMENT_SAMPLES, TRANSITION_POWER);
     const pad2 = Math.floor(HOP_SIZE2 / 2) * 3;
     const le = Math.ceil(SEGMENT_SAMPLES / HOP_SIZE2);
@@ -36187,14 +36272,13 @@ var HtdemucsStream = class extends BufferedTransformStream {
     const { stems } = this.properties;
     const stemGains = [stems.drums, stems.bass, stems.other, stems.vocals];
     const inv = 1 / (stats.std || 1);
-    const modelRateFrames = Math.round(originalFrames * HTDEMUCS_SAMPLE_RATE / sourceRate);
-    const progressGate = createProgressGate(modelRateFrames);
+    const progressGate = createProgressGate(originalFrames);
     let stableEmitted = 0;
     for (; ; ) {
       if (!inputExhausted) {
         while (segFilled < SEGMENT_SAMPLES) {
           const need = SEGMENT_SAMPLES - segFilled;
-          const got = await pullNextChunkAt441({ buffer, pair, channels, frames: Math.min(need, CHUNK_FRAMES6) });
+          const got = await pullNextChunkAt441({ buffer, channels, frames: Math.min(need, CHUNK_FRAMES6) });
           if (got === void 0 || got[0].length === 0) {
             inputExhausted = true;
             break;
@@ -36236,17 +36320,15 @@ var HtdemucsStream = class extends BufferedTransformStream {
         sumWeight,
         stats,
         stemGains,
-        pair,
         output,
         channels,
-        sourceRate,
         bitDepth,
         originalFrames,
         writerState
       });
       stableEmitted += nStable;
-      const doneFrames = Math.min(stableEmitted, modelRateFrames);
-      if (progressGate(doneFrames, Date.now())) this.emitProgress("process", doneFrames, modelRateFrames);
+      const doneFrames = Math.min(stableEmitted, originalFrames);
+      if (progressGate(doneFrames, Date.now())) this.emitProgress("process", doneFrames, originalFrames);
       if (!isFinalIter) {
         segLeft.copyWithin(0, nStable, SEGMENT_SAMPLES);
         segRight.copyWithin(0, nStable, SEGMENT_SAMPLES);
@@ -36257,35 +36339,26 @@ var HtdemucsStream = class extends BufferedTransformStream {
         break;
       }
     }
-    await pumpDone;
-    if (pair) {
-      await pair.resampleOut.end();
-    }
-    await drainerDone;
-    await padTail2(output, channels, originalFrames, writerState.written, sourceRate, bitDepth);
+    await padTail2(output, channels, originalFrames, writerState.written, HTDEMUCS_SAMPLE_RATE, bitDepth);
   }
   async emitStable(args) {
-    const { nStable, stemAccum, sumWeight, stats, stemGains, pair, output, channels, sourceRate, bitDepth, originalFrames, writerState } = args;
+    const { nStable, stemAccum, sumWeight, stats, stemGains, output, channels, bitDepth, originalFrames, writerState } = args;
     if (nStable <= 0) return;
     const { outLeft, outRight } = mixStemsToStereo(stemAccum, sumWeight, stemGains, stats, nStable);
     bandpass([outLeft, outRight], HTDEMUCS_SAMPLE_RATE, this.properties.highPass, this.properties.lowPass);
-    if (pair) {
-      await pair.resampleOut.write([outLeft, outRight]);
-    } else {
-      const writeChannels = buildWriteChannels(outLeft, outRight, channels);
-      const remaining = Math.max(0, originalFrames - writerState.written);
-      if (remaining > 0) {
-        const take = Math.min(nStable, remaining);
-        const sliced = take === nStable ? writeChannels : writeChannels.map((channel) => channel.subarray(0, take));
-        await output.write(sliced, sourceRate, bitDepth);
-        writerState.written += take;
-      }
+    const writeChannels = buildWriteChannels(outLeft, outRight, channels);
+    const remaining = Math.max(0, originalFrames - writerState.written);
+    if (remaining > 0) {
+      const take = Math.min(nStable, remaining);
+      const sliced = take === nStable ? writeChannels : writeChannels.map((channel) => channel.subarray(0, take));
+      await output.write(sliced, HTDEMUCS_SAMPLE_RATE, bitDepth);
+      writerState.written += take;
     }
     for (let stem = 0; stem < STEM_OUTPUTS; stem++) {
-      const arr = stemAccum[stem];
-      if (!arr) continue;
-      arr.copyWithin(0, nStable, SEGMENT_SAMPLES);
-      arr.fill(0, SEGMENT_SAMPLES - nStable, SEGMENT_SAMPLES);
+      const stemAccumulator = stemAccum[stem];
+      if (!stemAccumulator) continue;
+      stemAccumulator.copyWithin(0, nStable, SEGMENT_SAMPLES);
+      stemAccumulator.fill(0, SEGMENT_SAMPLES - nStable, SEGMENT_SAMPLES);
     }
     sumWeight.copyWithin(0, nStable, SEGMENT_SAMPLES);
     sumWeight.fill(0, SEGMENT_SAMPLES - nStable, SEGMENT_SAMPLES);
@@ -36341,59 +36414,14 @@ async function computeStreamingStats(buffer, channels) {
   return { mean, std };
 }
 async function pullNextChunkAt441(args) {
-  const { buffer, pair, channels, frames } = args;
-  if (!pair) {
-    const chunk = await buffer.read(frames);
-    const got2 = chunk.samples[0]?.length ?? 0;
-    if (got2 === 0) return void 0;
-    const left2 = chunk.samples[0] ?? new Float32Array(got2);
-    const right2 = channels >= 2 ? chunk.samples[1] ?? left2 : left2;
-    return [left2, right2];
-  }
-  const out = await pair.resampleIn.read(frames);
-  const got = out[0]?.length ?? 0;
+  const { buffer, channels, frames } = args;
+  const chunk = await buffer.read(frames);
+  const got = chunk.samples[0]?.length ?? 0;
   if (got === 0) return void 0;
-  const left = out[0] ?? new Float32Array(got);
-  const right = out[1] ?? left;
+  const left = chunk.samples[0] ?? new Float32Array(got);
+  const right = channels >= 2 ? chunk.samples[1] ?? left : left;
   return [left, right];
 }
-async function pumpSourceToResampleIn2(args) {
-  const { buffer, resampleIn, channels, chunkFrames } = args;
-  for (; ; ) {
-    const sourceChunk = await buffer.read(chunkFrames);
-    const sourceFrames = sourceChunk.samples[0]?.length ?? 0;
-    if (sourceFrames === 0) break;
-    const sourceLeft = sourceChunk.samples[0] ?? new Float32Array(sourceFrames);
-    const sourceRight = channels >= 2 ? sourceChunk.samples[1] ?? sourceLeft : sourceLeft;
-    await resampleIn.write([sourceLeft, sourceRight]);
-    if (sourceFrames < chunkFrames) break;
-  }
-  await resampleIn.end();
-}
-async function drainResampleOutToBuffer2(args) {
-  const { resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState } = args;
-  for (; ; ) {
-    const chunk = await resampleOut.read(RESAMPLE_DRAIN_CHUNK2);
-    const got = chunk[0]?.length ?? 0;
-    if (got === 0) return;
-    await commitResampledFrames2({ chunk, channels, output, sourceRate, bitDepth, originalFrames, writerState });
-  }
-}
-async function commitResampledFrames2(args) {
-  const { chunk, channels, output, sourceRate, bitDepth, originalFrames, writerState } = args;
-  const firstChannel = chunk[0];
-  const got = firstChannel?.length ?? 0;
-  if (got === 0 || !firstChannel) return;
-  const remaining = originalFrames - writerState.written;
-  if (remaining <= 0) return;
-  const take = Math.min(got, remaining);
-  const right = chunk[1] ?? firstChannel;
-  const writeLeft = take === got ? firstChannel : firstChannel.subarray(0, take);
-  const writeRight = take === got ? right : right.subarray(0, take);
-  const writeChannels = buildWriteChannels(writeLeft, writeRight, channels);
-  await output.write(writeChannels, sourceRate, bitDepth);
-  writerState.written += take;
-}
 function buildWriteChannels(left, right, channels) {
   const out = [];
   for (let channel = 0; channel < channels; channel++) {
@@ -36403,14 +36431,14 @@ function buildWriteChannels(left, right, channels) {
   }
   return out;
 }
-async function padTail2(output, channels, originalFrames, written, sourceRate, bitDepth) {
+async function padTail2(output, channels, originalFrames, written, sampleRate, bitDepth) {
   if (written >= originalFrames) return;
   const missing = originalFrames - written;
   const padChannels = [];
   for (let channel = 0; channel < Math.max(1, channels); channel++) {
     padChannels.push(new Float32Array(missing));
   }
-  await output.write(padChannels, sourceRate, bitDepth);
+  await output.write(padChannels, sampleRate, bitDepth);
 }
 var HtdemucsNode = class extends TransformNode {
 };
@@ -36570,39 +36598,31 @@ var SEGMENT_SAMPLES2 = N_FFT2 + (DIM_T3 - 1) * HOP_SIZE4;
 var OVERLAP2 = 0.25;
 var TRANSITION_POWER2 = 1;
 var CHUNK_FRAMES7 = 44100;
-var RESAMPLE_DRAIN_CHUNK3 = 16384;
 var KimVocal2Stream = class extends BufferedTransformStream {
   constructor(node, context) {
     super(node, context);
     this.blockSize = WHOLE_FILE;
     this.fftInstance = new MixedRadixFft(N_FFT2);
+    this.renderContext = context;
   }
   _setup(context) {
     this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: filterOnnxProviders(context.executionProviders) }, (message, data) => this.log(message, data));
+    const composition = createResampleComposition({ context, streamContext: this.renderContext, ffmpegPath: this.properties.ffmpegPath, modelRate: SAMPLE_RATE });
+    if (composition) {
+      this.upResample = composition.upResample;
+      this.downResample = composition.downResample;
+    }
+  }
+  _pipe(input) {
+    if (!this.upResample || !this.downResample) return super._pipe(input);
+    return this.downResample._pipe(super._pipe(this.upResample._pipe(input)));
   }
   async *_transform(buffered) {
     const originalFrames = buffered.frames;
     const channels = buffered.channels;
     if (originalFrames === 0 || channels === 0) return;
-    const sourceRate = this.sampleRate ?? SAMPLE_RATE;
     const bitDepth = this.bitDepth;
-    const needsResample = sourceRate !== SAMPLE_RATE;
     await buffered.reset();
-    let pair;
-    if (needsResample) {
-      pair = {
-        resampleIn: new ResampleStream(this.properties.ffmpegPath, {
-          sourceSampleRate: sourceRate,
-          targetSampleRate: SAMPLE_RATE,
-          channels: 2
-        }),
-        resampleOut: new ResampleStream(this.properties.ffmpegPath, {
-          sourceSampleRate: SAMPLE_RATE,
-          targetSampleRate: sourceRate,
-          channels: 2
-        })
-      };
-    }
     const output = new BlockBuffer();
     try {
       await this.runMainPass({
@@ -36610,26 +36630,19 @@ var KimVocal2Stream = class extends BufferedTransformStream {
         output,
         channels,
         originalFrames,
-        sourceRate,
-        bitDepth,
-        pair
+        bitDepth
       });
       await output.reset();
       yield* output.iterate(CHUNK_FRAMES7);
     } finally {
-      if (pair) {
-        await Promise.all([pair.resampleIn.close(), pair.resampleOut.close()]);
-      }
       await output.close();
     }
   }
   async runMainPass(args) {
-    const { buffer, output, channels, originalFrames, sourceRate, bitDepth, pair } = args;
+    const { buffer, output, channels, originalFrames, bitDepth } = args;
     const stride = Math.round((1 - OVERLAP2) * SEGMENT_SAMPLES2);
     const isMono = channels < 2;
     const writerState = { written: 0 };
-    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn3({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES7 }) : Promise.resolve();
-    const drainerDone = pair !== void 0 ? drainResampleOutToBuffer3({ resampleOut: pair.resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState }) : Promise.resolve();
     const weight = buildTransitionWindow(SEGMENT_SAMPLES2, TRANSITION_POWER2);
     const workspace = createSegmentWorkspace(SEGMENT_SAMPLES2);
     const segLeft = new Float32Array(SEGMENT_SAMPLES2);
@@ -36639,14 +36652,13 @@ var KimVocal2Stream = class extends BufferedTransformStream {
     const outAccumLeft = new Float32Array(SEGMENT_SAMPLES2);
     const outAccumRight = new Float32Array(SEGMENT_SAMPLES2);
     const sumWeight = new Float32Array(SEGMENT_SAMPLES2);
-    const modelRateFrames = Math.round(originalFrames * SAMPLE_RATE / sourceRate);
-    const progressGate = createProgressGate(modelRateFrames);
+    const progressGate = createProgressGate(originalFrames);
     let stableEmitted = 0;
     for (; ; ) {
       if (!inputExhausted) {
         while (segFilled < SEGMENT_SAMPLES2) {
           const need = SEGMENT_SAMPLES2 - segFilled;
-          const got = await pullNextChunkAt4412({ buffer, pair, channels, frames: Math.min(need, CHUNK_FRAMES7) });
+          const got = await pullNextChunkAt4412({ buffer, channels, frames: Math.min(need, CHUNK_FRAMES7) });
           if (got === void 0 || got[0].length === 0) {
             inputExhausted = true;
             break;
@@ -36679,17 +36691,15 @@ var KimVocal2Stream = class extends BufferedTransformStream {
         outAccumLeft,
         outAccumRight,
         sumWeight,
-        pair,
         output,
         channels,
-        sourceRate,
         bitDepth,
         originalFrames,
         writerState
       });
       stableEmitted += nStable;
-      const doneFrames = Math.min(stableEmitted, modelRateFrames);
-      if (progressGate(doneFrames, Date.now())) this.emitProgress("process", doneFrames, modelRateFrames);
+      const doneFrames = Math.min(stableEmitted, originalFrames);
+      if (progressGate(doneFrames, Date.now())) this.emitProgress("process", doneFrames, originalFrames);
       if (!isFinalIter) {
         segLeft.copyWithin(0, nStable, SEGMENT_SAMPLES2);
         segRight.copyWithin(0, nStable, SEGMENT_SAMPLES2);
@@ -36700,15 +36710,10 @@ var KimVocal2Stream = class extends BufferedTransformStream {
         break;
       }
     }
-    await pumpDone;
-    if (pair) {
-      await pair.resampleOut.end();
-    }
-    await drainerDone;
-    await padTail3(output, channels, originalFrames, writerState.written, sourceRate, bitDepth);
+    await padTail3(output, channels, originalFrames, writerState.written, SAMPLE_RATE, bitDepth);
   }
   async emitStable(args) {
-    const { nStable, outAccumLeft, outAccumRight, sumWeight, pair, output, channels, sourceRate, bitDepth, originalFrames, writerState } = args;
+    const { nStable, outAccumLeft, outAccumRight, sumWeight, output, channels, bitDepth, originalFrames, writerState } = args;
     if (nStable <= 0) return;
     const outLeft = new Float32Array(nStable);
     const outRight = new Float32Array(nStable);
@@ -36718,17 +36723,13 @@ var KimVocal2Stream = class extends BufferedTransformStream {
       outRight[index] = sw > 0 ? (outAccumRight[index] ?? 0) / sw : outAccumRight[index] ?? 0;
     }
     bandpass([outLeft, outRight], SAMPLE_RATE, this.properties.highPass, this.properties.lowPass);
-    if (pair) {
-      await pair.resampleOut.write([outLeft, outRight]);
-    } else {
-      const writeChannels = buildWriteChannels2(outLeft, outRight, channels);
-      const remaining = Math.max(0, originalFrames - writerState.written);
-      if (remaining > 0) {
-        const take = Math.min(nStable, remaining);
-        const sliced = take === nStable ? writeChannels : writeChannels.map((channel) => channel.subarray(0, take));
-        await output.write(sliced, sourceRate, bitDepth);
-        writerState.written += take;
-      }
+    const writeChannels = buildWriteChannels2(outLeft, outRight, channels);
+    const remaining = Math.max(0, originalFrames - writerState.written);
+    if (remaining > 0) {
+      const take = Math.min(nStable, remaining);
+      const sliced = take === nStable ? writeChannels : writeChannels.map((channel) => channel.subarray(0, take));
+      await output.write(sliced, SAMPLE_RATE, bitDepth);
+      writerState.written += take;
     }
     outAccumLeft.copyWithin(0, nStable, SEGMENT_SAMPLES2);
     outAccumLeft.fill(0, SEGMENT_SAMPLES2 - nStable, SEGMENT_SAMPLES2);
@@ -36739,59 +36740,14 @@ var KimVocal2Stream = class extends BufferedTransformStream {
   }
 };
 async function pullNextChunkAt4412(args) {
-  const { buffer, pair, channels, frames } = args;
-  if (!pair) {
-    const chunk = await buffer.read(frames);
-    const got2 = chunk.samples[0]?.length ?? 0;
-    if (got2 === 0) return void 0;
-    const left2 = chunk.samples[0] ?? new Float32Array(got2);
-    const right2 = channels >= 2 ? chunk.samples[1] ?? left2 : left2;
-    return [left2, right2];
-  }
-  const out = await pair.resampleIn.read(frames);
-  const got = out[0]?.length ?? 0;
+  const { buffer, channels, frames } = args;
+  const chunk = await buffer.read(frames);
+  const got = chunk.samples[0]?.length ?? 0;
   if (got === 0) return void 0;
-  const left = out[0] ?? new Float32Array(got);
-  const right = out[1] ?? left;
+  const left = chunk.samples[0] ?? new Float32Array(got);
+  const right = channels >= 2 ? chunk.samples[1] ?? left : left;
   return [left, right];
 }
-async function pumpSourceToResampleIn3(args) {
-  const { buffer, resampleIn, channels, chunkFrames } = args;
-  for (; ; ) {
-    const sourceChunk = await buffer.read(chunkFrames);
-    const sourceFrames = sourceChunk.samples[0]?.length ?? 0;
-    if (sourceFrames === 0) break;
-    const sourceLeft = sourceChunk.samples[0] ?? new Float32Array(sourceFrames);
-    const sourceRight = channels >= 2 ? sourceChunk.samples[1] ?? sourceLeft : sourceLeft;
-    await resampleIn.write([sourceLeft, sourceRight]);
-    if (sourceFrames < chunkFrames) break;
-  }
-  await resampleIn.end();
-}
-async function drainResampleOutToBuffer3(args) {
-  const { resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState } = args;
-  for (; ; ) {
-    const chunk = await resampleOut.read(RESAMPLE_DRAIN_CHUNK3);
-    const got = chunk[0]?.length ?? 0;
-    if (got === 0) return;
-    await commitResampledFrames3({ chunk, channels, output, sourceRate, bitDepth, originalFrames, writerState });
-  }
-}
-async function commitResampledFrames3(args) {
-  const { chunk, channels, output, sourceRate, bitDepth, originalFrames, writerState } = args;
-  const firstChannel = chunk[0];
-  const got = firstChannel?.length ?? 0;
-  if (got === 0 || !firstChannel) return;
-  const remaining = originalFrames - writerState.written;
-  if (remaining <= 0) return;
-  const take = Math.min(got, remaining);
-  const right = chunk[1] ?? firstChannel;
-  const writeLeft = take === got ? firstChannel : firstChannel.subarray(0, take);
-  const writeRight = take === got ? right : right.subarray(0, take);
-  const writeChannels = buildWriteChannels2(writeLeft, writeRight, channels);
-  await output.write(writeChannels, sourceRate, bitDepth);
-  writerState.written += take;
-}
 function buildWriteChannels2(left, right, channels) {
   const out = [];
   for (let channel = 0; channel < channels; channel++) {
@@ -36801,14 +36757,14 @@ function buildWriteChannels2(left, right, channels) {
   }
   return out;
 }
-async function padTail3(output, channels, originalFrames, written, sourceRate, bitDepth) {
+async function padTail3(output, channels, originalFrames, written, sampleRate, bitDepth) {
   if (written >= originalFrames) return;
   const missing = originalFrames - written;
   const padChannels = [];
   for (let channel = 0; channel < Math.max(1, channels); channel++) {
     padChannels.push(new Float32Array(missing));
   }
-  await output.write(padChannels, sourceRate, bitDepth);
+  await output.write(padChannels, sampleRate, bitDepth);
 }
 var KimVocal2Node = class extends TransformNode {
 };
@@ -36821,8 +36777,72 @@ function kimVocal2(options) {
   return new KimVocal2Node(options);
 }
 var CHUNK_FRAMES8 = 48e3;
+var TELEMETRY_PREFIX = "VST_HOST_EVENT ";
+var DIAGNOSTIC_TAIL_BYTES = 64 * 1024;
 var READY_LINE = "READY\n";
 var READY_TIMEOUT_MS = 3e5;
+var isFiniteNonnegativeNumber = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+var isUnknownRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseVstHostEvent(line) {
+  if (!line.startsWith(TELEMETRY_PREFIX)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(line.slice(TELEMETRY_PREFIX.length));
+  } catch {
+    return void 0;
+  }
+  if (!isUnknownRecord(parsed)) return void 0;
+  const record3 = parsed;
+  if (record3.type !== "liveness" || record3.phase !== "process") return void 0;
+  if (record3.state !== "active" && record3.state !== "idle") return void 0;
+  if (!isFiniteNonnegativeNumber(record3.elapsedMs)) return void 0;
+  if (!isFiniteNonnegativeNumber(record3.processCpuDeltaMs)) return void 0;
+  if (!isFiniteNonnegativeNumber(record3.processCpuMs)) return void 0;
+  return {
+    type: record3.type,
+    phase: record3.phase,
+    elapsedMs: record3.elapsedMs,
+    processCpuDeltaMs: record3.processCpuDeltaMs,
+    processCpuMs: record3.processCpuMs,
+    state: record3.state
+  };
+}
+function observeVstHostStderr(stderr, onLiveness) {
+  const decoder = new StringDecoder("utf8");
+  let pendingLine = "";
+  let diagnosticTail = Buffer.alloc(0);
+  const appendDiagnostic = (text) => {
+    if (text.length === 0) return;
+    const bytes = Buffer.from(text);
+    const combined = diagnosticTail.length === 0 ? bytes : Buffer.concat([diagnosticTail, bytes]);
+    diagnosticTail = combined.length <= DIAGNOSTIC_TAIL_BYTES ? combined : combined.subarray(combined.length - DIAGNOSTIC_TAIL_BYTES);
+  };
+  const consumeCompleteLines = () => {
+    for (; ; ) {
+      const newlineIndex = pendingLine.indexOf("\n");
+      if (newlineIndex === -1) return;
+      const line = pendingLine.slice(0, newlineIndex);
+      pendingLine = pendingLine.slice(newlineIndex + 1);
+      const event = parseVstHostEvent(line);
+      if (event !== void 0) {
+        onLiveness?.(event);
+      } else {
+        appendDiagnostic(`${line}
+`);
+      }
+    }
+  };
+  stderr.on("data", (chunk) => {
+    pendingLine += decoder.write(chunk);
+    consumeCompleteLines();
+  });
+  stderr.once("end", () => {
+    pendingLine += decoder.end();
+    appendDiagnostic(pendingLine);
+    pendingLine = "";
+  });
+  return () => diagnosticTail.toString("utf8");
+}
 var VstHostExitedBeforeReadyError = class extends Error {
   constructor(code, stderr) {
     super(`vst-host exited before READY (code ${code ?? "null"}): ${stderr}`);
@@ -36831,7 +36851,7 @@ var VstHostExitedBeforeReadyError = class extends Error {
     this.stderr = stderr;
   }
 };
-function spawnVstHost(binaryPath, args) {
+function spawnVstHost(binaryPath, args, options = {}) {
   const proc = spawn(binaryPath, [...args], {
     stdio: ["pipe", "pipe", "pipe"]
   });
@@ -36841,10 +36861,7 @@ function spawnVstHost(binaryPath, args) {
   const stdin = proc.stdin;
   const stdout = proc.stdout;
   const stderr = proc.stderr;
-  const stderrChunks = [];
-  stderr.on("data", (chunk) => {
-    stderrChunks.push(chunk);
-  });
+  const getStderrTail = observeVstHostStderr(stderr, options.onLiveness);
   const ready = new Promise((resolve, reject) => {
     const seen = [];
     const cleanup = () => {
@@ -36875,7 +36892,7 @@ function spawnVstHost(binaryPath, args) {
       fail(new Error(`vst-host failed to start: ${error50.message}`));
     };
     const onClose = (code) => {
-      const stderrOutput = Buffer.concat(stderrChunks).toString();
+      const stderrOutput = getStderrTail();
       fail(new VstHostExitedBeforeReadyError(code, stderrOutput));
     };
     const timer = setTimeout(() => {
@@ -36887,7 +36904,7 @@ function spawnVstHost(binaryPath, args) {
   });
   stdin.on("error", () => {
   });
-  return { proc, stdin, stdout, stderr, ready, stderrChunks };
+  return { proc, stdin, stdout, stderr, ready, getStderrTail };
 }
 var CLEAN_WRAPPER_EXIT_CODES = /* @__PURE__ */ new Set([0, 1, 2]);
 function isRetryableInitCrash(error50) {
@@ -36898,7 +36915,7 @@ async function spawnVstHostReady(binaryPath, args, options = {}) {
   const maxAttempts = options.maxAttempts ?? 5;
   const backoffMs = options.backoffMs ?? 750;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const handle = spawnVstHost(binaryPath, args);
+    const handle = spawnVstHost(binaryPath, args, { onLiveness: options.onLiveness });
     try {
       await handle.ready;
       return handle;
@@ -36922,9 +36939,11 @@ async function writeStagesJson(stages) {
     }
   };
 }
-async function processStreamingThroughVstHost(handle, buffer, channelCount, sampleRate, bitDepth) {
+async function processStreamingThroughVstHost(handle, buffer, options) {
+  const { channelCount, sampleRate, bitDepth, onInputProgress, onOutputProgress } = options;
   const inputFrames = buffer.frames;
   const expectedOutputBytes = inputFrames * channelCount * 4;
+  let inputFramesDone = 0;
   const stdoutEnd = new Promise((resolve) => {
     handle.stdout.once("end", () => resolve());
   });
@@ -36937,15 +36956,22 @@ async function processStreamingThroughVstHost(handle, buffer, channelCount, samp
     const chunkFrames = chunk.samples[0]?.length ?? 0;
     if (chunkFrames === 0) break;
     const channelArrays = [];
-    for (let ch = 0; ch < channelCount; ch++) {
-      channelArrays.push(chunk.samples[ch] ?? new Float32Array(chunkFrames));
+    for (let channel = 0; channel < channelCount; channel++) {
+      channelArrays.push(chunk.samples[channel] ?? new Float32Array(chunkFrames));
     }
     const interleaved = interleave(channelArrays, chunkFrames, channelCount);
-    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
-    const canWrite = handle.stdin.write(buf);
+    const interleavedBuffer = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
+    const canWrite = handle.stdin.write(interleavedBuffer);
     if (!canWrite) {
       await waitForDrain(handle.proc, handle.stdin);
     }
+    inputFramesDone = Math.min(inputFrames, inputFramesDone + chunkFrames);
+    onInputProgress?.({
+      framesDone: inputFramesDone,
+      framesTotal: inputFrames,
+      bytesDone: inputFramesDone * channelCount * 4,
+      bytesTotal: expectedOutputBytes
+    });
     if (chunkFrames < CHUNK_FRAMES8) break;
   }
   handle.stdin.end();
@@ -36954,6 +36980,7 @@ async function processStreamingThroughVstHost(handle, buffer, channelCount, samp
   let stdoutTail = Buffer.alloc(0);
   let stdoutError;
   const bytesPerFrame = channelCount * 4;
+  let outputFramesDone = 0;
   let writeChain = Promise.resolve();
   const onData = (chunk) => {
     if (stdoutError !== void 0) return;
@@ -36968,7 +36995,16 @@ async function processStreamingThroughVstHost(handle, buffer, channelCount, samp
     const aligned = combined.subarray(0, alignedBytes);
     stdoutTail = combined.length === alignedBytes ? Buffer.alloc(0) : combined.subarray(alignedBytes);
     const channels = deinterleaveBuffer(aligned, channelCount);
-    writeChain = writeChain.then(() => buffer.write(channels, sampleRate, bitDepth)).catch((error50) => {
+    writeChain = writeChain.then(async () => {
+      await buffer.write(channels, sampleRate, bitDepth);
+      outputFramesDone = Math.min(inputFrames, outputFramesDone + alignedFrames);
+      onOutputProgress?.({
+        framesDone: outputFramesDone,
+        framesTotal: inputFrames,
+        bytesDone: outputFramesDone * bytesPerFrame,
+        bytesTotal: expectedOutputBytes
+      });
+    }).catch((error50) => {
       stdoutError ?? (stdoutError = error50 instanceof Error ? error50 : new Error(String(error50)));
     });
   };
@@ -36978,7 +37014,7 @@ async function processStreamingThroughVstHost(handle, buffer, channelCount, samp
   const exit = await exited;
   if (stdoutError !== void 0) throw stdoutError;
   if (exit.code !== 0) {
-    const stderrOutput = Buffer.concat(handle.stderrChunks).toString();
+    const stderrOutput = handle.getStderrTail();
     throw new Error(`vst-host exited with code ${exit.code ?? "null"}${exit.signal ? ` (signal ${exit.signal})` : ""}: ${stderrOutput}`);
   }
   if (outputBytesReceived !== expectedOutputBytes) {
@@ -37019,6 +37055,8 @@ var Vst3Stream = class extends BufferedTransformStream {
     const channels = buffered.channels;
     const sampleRate = this.sampleRate ?? 44100;
     const bd = buffered.bitDepth;
+    const inputGate = createProgressGate(buffered.frames);
+    const outputGate = createProgressGate(buffered.frames);
     const args = [
       ...this.properties.extraArgs ?? [],
       "--stages-json",
@@ -37029,11 +37067,48 @@ var Vst3Stream = class extends BufferedTransformStream {
       String(channels)
     ];
     const handle = await spawnVstHostReady(this.properties.vstHostPath, args, {
+      onLiveness: (event) => {
+        this.log(
+          "vst-host liveness",
+          {
+            phase: event.phase,
+            elapsedMs: event.elapsedMs,
+            processCpuDeltaMs: event.processCpuDeltaMs,
+            processCpuMs: event.processCpuMs,
+            state: event.state
+          },
+          event.state === "idle" ? "warn" : "info"
+        );
+      },
       onRetry: (failedAttempt, error50) => {
         this.log("vst-host init crash, retrying", { attempt: failedAttempt, error: error50.message }, "warn");
       }
     });
-    await processStreamingThroughVstHost(handle, buffered, channels, sampleRate, bd);
+    await processStreamingThroughVstHost(handle, buffered, {
+      channelCount: channels,
+      sampleRate,
+      bitDepth: bd,
+      onInputProgress: (progress) => {
+        if (inputGate(progress.framesDone, Date.now())) {
+          this.log("vst-host input", {
+            framesDone: progress.framesDone,
+            framesTotal: progress.framesTotal,
+            bytesDone: progress.bytesDone,
+            bytesTotal: progress.bytesTotal
+          });
+        }
+      },
+      onOutputProgress: (progress) => {
+        if (outputGate(progress.framesDone, Date.now())) {
+          this.log("vst-host output", {
+            framesDone: progress.framesDone,
+            framesTotal: progress.framesTotal,
+            bytesDone: progress.bytesDone,
+            bytesTotal: progress.bytesTotal
+          });
+        }
+      }
+    });
     await buffered.reset();
     yield* buffered.iterate(44100);
   }