@e9g/buffered-audio-nodes 0.2.0

package/dist/index.js

@@ -0,0 +1,4479 @@
+import { SourceNode, TargetNode, WHOLE_FILE, TransformNode, BufferedSourceStream, BufferedTargetStream, BufferedTransformStream, FileChunkBuffer } from 'buffered-audio-nodes-core';
+export * from 'buffered-audio-nodes-core';
+import { deinterleaveBuffer, hanningWindow, createFftWorkspace, detectFftBackend, getFftAddon, replaceChannel, lowPassCoefficients, zeroPhaseBiquadFilter, initFftBackend, stft, istft, MixedRadixFft, resampleDirect, applyBandpass, fft, bandPassCoefficients, biquadFilter, smoothEnvelope, preFilterCoefficients, rlbFilterCoefficients, interleave } from 'buffered-audio-nodes-utils';
+export * from 'buffered-audio-nodes-utils';
+import { extname } from 'path';
+import { z } from 'zod';
+import { spawn } from 'child_process';
+import { open, stat, readFile } from 'fs/promises';
+import { WaveFile } from 'wavefile';
+import { createRequire } from 'module';
+
+// src/index.ts
+var ffmpegSchema = z.object({
+  path: z.string().default("").meta({ input: "file", mode: "open" }),
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  ffprobePath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffprobe", download: "https://ffmpeg.org/download.html" }).describe("FFprobe \u2014 media file analyzer (included with FFmpeg)")
+});
+var DEFAULT_CHUNK_SIZE = 44100;
+var ReadFfmpegStream = class extends BufferedSourceStream {
+  constructor() {
+    super(...arguments);
+    this.frameOffset = 0;
+    this.outputChannels = 0;
+    this.sourceSampleRate = 0;
+    this.sourceBitDepth = 0;
+  }
+  async getMetadata() {
+    const probe = await this.probe(this.properties.ffprobePath, this.properties.path);
+    const selectedChannels = this.properties.channels;
+    const channels = selectedChannels ? selectedChannels.length : probe.channels;
+    return {
+      sampleRate: probe.sampleRate,
+      channels,
+      durationFrames: Math.round(probe.duration * probe.sampleRate)
+    };
+  }
+  async ensureInitialized() {
+    if (this.ffmpegProcess) return;
+    const probe = await this.probe(this.properties.ffprobePath, this.properties.path);
+    const selectedChannels = this.properties.channels;
+    this.outputChannels = selectedChannels ? selectedChannels.length : probe.channels;
+    this.sourceSampleRate = probe.sampleRate;
+    this.sourceBitDepth = 32;
+    const args = ["-i", this.properties.path, "-f", "f32le", "-acodec", "pcm_f32le", "-ar", String(probe.sampleRate)];
+    if (selectedChannels) {
+      const panParts = selectedChannels.map((srcCh, outCh) => `c${outCh}=c${srcCh}`);
+      const layout = this.outputChannels === 1 ? "mono" : `${this.outputChannels}c`;
+      args.push("-af", `pan=${layout}|${panParts.join("|")}`);
+      args.push("-ac", String(this.outputChannels));
+    } else {
+      args.push("-ac", String(probe.channels));
+    }
+    args.push("pipe:1");
+    const proc = spawn(this.properties.ffmpegPath, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.ffmpegProcess = proc;
+    this.stdout = proc.stdout;
+    this.remainder = void 0;
+    this.frameOffset = 0;
+    proc.stderr.resume();
+  }
+  async _read() {
+    await this.ensureInitialized();
+    const bytesPerFrame = this.outputChannels * 4;
+    const targetBytes = DEFAULT_CHUNK_SIZE * bytesPerFrame;
+    const data = await this.readBytes(targetBytes);
+    if (!data || data.length === 0) {
+      return void 0;
+    }
+    const usableBytes = Math.floor(data.length / bytesPerFrame) * bytesPerFrame;
+    if (usableBytes === 0) {
+      return void 0;
+    }
+    const leftover = data.length - usableBytes;
+    if (leftover > 0) {
+      this.remainder = Buffer.from(data.buffer, data.byteOffset + usableBytes, leftover);
+    }
+    const frames = usableBytes / bytesPerFrame;
+    const sampleBuffer = Buffer.from(data.buffer, data.byteOffset, usableBytes);
+    const samples = deinterleaveBuffer(sampleBuffer, this.outputChannels);
+    const offset = this.frameOffset;
+    this.frameOffset += frames;
+    return {
+      samples,
+      offset,
+      sampleRate: this.sourceSampleRate,
+      bitDepth: this.sourceBitDepth
+    };
+  }
+  async _flush() {
+    const proc = this.ffmpegProcess;
+    if (proc) {
+      proc.kill();
+      await new Promise((resolve) => {
+        proc.on("close", () => resolve());
+        if (proc.exitCode !== null) resolve();
+      });
+      this.ffmpegProcess = void 0;
+    }
+    this.stdout = void 0;
+    this.remainder = void 0;
+  }
+  _teardown() {
+    if (this.ffmpegProcess) {
+      this.ffmpegProcess.kill();
+      this.ffmpegProcess = void 0;
+    }
+    this.stdout = void 0;
+    this.remainder = void 0;
+  }
+  async probe(ffprobePath, filePath) {
+    const proc = spawn(ffprobePath, ["-v", "quiet", "-print_format", "json", "-show_streams", "-select_streams", "a:0", filePath], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const chunks = [];
+    proc.stdout.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    proc.stderr.resume();
+    await new Promise((resolve, reject) => {
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`ffprobe exited with code ${code} for "${filePath}"`));
+        } else {
+          resolve();
+        }
+      });
+      proc.on("error", (error) => {
+        reject(new Error(`Failed to spawn ffprobe: ${error.message}`));
+      });
+    });
+    const json = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+    const stream = json.streams?.[0];
+    if (!stream) {
+      throw new Error(`No audio stream found in "${filePath}"`);
+    }
+    return {
+      sampleRate: Number(stream.sample_rate) || 44100,
+      channels: stream.channels ?? 1,
+      duration: Number(stream.duration) || 0
+    };
+  }
+  readBytes(targetBytes) {
+    return new Promise((resolve) => {
+      const stdout = this.stdout;
+      if (!stdout) {
+        resolve(void 0);
+        return;
+      }
+      const existing = this.remainder;
+      this.remainder = void 0;
+      const read2 = () => {
+        const raw = stdout.read(targetBytes - (existing?.length ?? 0));
+        if (raw) {
+          resolve(existing ? Buffer.concat([existing, raw]) : raw);
+          return;
+        }
+        if (stdout.readableEnded) {
+          resolve(existing && existing.length > 0 ? existing : void 0);
+          return;
+        }
+        const onReadable = () => {
+          cleanup();
+          read2();
+        };
+        const onEnd = () => {
+          cleanup();
+          resolve(existing && existing.length > 0 ? existing : void 0);
+        };
+        const cleanup = () => {
+          stdout.removeListener("readable", onReadable);
+          stdout.removeListener("end", onEnd);
+        };
+        stdout.once("readable", onReadable);
+        stdout.once("end", onEnd);
+      };
+      read2();
+    });
+  }
+};
+var _ReadFfmpegNode = class _ReadFfmpegNode extends SourceNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "source", "read-ffmpeg"];
+  }
+  createStream() {
+    return new ReadFfmpegStream(this.properties);
+  }
+  clone(overrides) {
+    return new _ReadFfmpegNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_ReadFfmpegNode.moduleName = "ReadFfmpeg";
+_ReadFfmpegNode.moduleDescription = "Read audio from a file using FFmpeg";
+_ReadFfmpegNode.schema = ffmpegSchema;
+var ReadFfmpegNode = _ReadFfmpegNode;
+function readFfmpeg(path, options) {
+  return new ReadFfmpegNode({ path, channels: options.channels, ffmpegPath: options.ffmpegPath, ffprobePath: options.ffprobePath });
+}
+var wavSchema = z.object({
+  path: z.string().default("").meta({ input: "file", mode: "open" })
+});
+var DEFAULT_CHUNK_SIZE2 = 44100;
+function readSample(data, offset, bitsPerSample, audioFormat) {
+  if (audioFormat === 3) {
+    if (bitsPerSample === 32) return data.readFloatLE(offset);
+    if (bitsPerSample === 64) return data.readDoubleLE(offset);
+  }
+  if (bitsPerSample === 16) return data.readInt16LE(offset) / 32768;
+  if (bitsPerSample === 24) {
+    const byte0 = data[offset] ?? 0;
+    const byte1 = data[offset + 1] ?? 0;
+    const byte2 = data[offset + 2] ?? 0;
+    const raw = byte0 | byte1 << 8 | byte2 << 16;
+    return (raw > 8388607 ? raw - 16777216 : raw) / 8388608;
+  }
+  if (bitsPerSample === 32) return data.readInt32LE(offset) / 2147483648;
+  if (bitsPerSample === 8) return ((data[offset] ?? 128) - 128) / 128;
+  return 0;
+}
+async function parseWavFormat(fh, path) {
+  const fileInfo = await stat(path);
+  const header = Buffer.alloc(12);
+  await fh.read(header, 0, 12, 0);
+  const magic = header.toString("ascii", 0, 4);
+  const wave = header.toString("ascii", 8, 12);
+  if (magic !== "RIFF" && magic !== "RF64" || wave !== "WAVE") {
+    throw new Error(`Not a WAV file: "${path}"`);
+  }
+  const isRf64 = magic === "RF64";
+  let ds64DataSize;
+  let offset = 12;
+  const fileSize = fileInfo.size;
+  let format;
+  const chunkHeader = Buffer.alloc(8);
+  while (offset < fileSize) {
+    await fh.read(chunkHeader, 0, 8, offset);
+    const chunkId = chunkHeader.toString("ascii", 0, 4);
+    const chunkSize = chunkHeader.readUInt32LE(4);
+    if (chunkId === "ds64") {
+      const ds64Data = Buffer.alloc(Math.min(chunkSize, 28));
+      await fh.read(ds64Data, 0, ds64Data.length, offset + 8);
+      ds64DataSize = Number(ds64Data.readBigUInt64LE(8));
+    } else if (chunkId === "JUNK") ; else if (chunkId === "fmt ") {
+      if (chunkSize < 16) throw new Error("WAV fmt chunk too small");
+      const fmtData = Buffer.alloc(chunkSize);
+      await fh.read(fmtData, 0, chunkSize, offset + 8);
+      const audioFormat = fmtData.readUInt16LE(0);
+      const channels = fmtData.readUInt16LE(2);
+      const sampleRate = fmtData.readUInt32LE(4);
+      const blockAlign = fmtData.readUInt16LE(12);
+      const bitsPerSample = fmtData.readUInt16LE(14);
+      format = { sampleRate, channels, bitsPerSample, audioFormat, blockAlign, dataOffset: 0, dataSize: 0 };
+    } else if (chunkId === "data") {
+      if (!format) throw new Error("WAV file has data chunk before fmt chunk");
+      const dataSize = isRf64 && ds64DataSize !== void 0 ? ds64DataSize : chunkSize;
+      format = { ...format, dataOffset: offset + 8, dataSize };
+      break;
+    }
+    offset += 8 + chunkSize;
+    if (chunkSize % 2 !== 0) offset++;
+  }
+  if (!format || format.dataOffset === 0) {
+    throw new Error(`Invalid WAV file: "${path}"`);
+  }
+  return format;
+}
+var ReadWavStream = class extends BufferedSourceStream {
+  constructor() {
+    super(...arguments);
+    this.bytesRead = 0;
+    this.sourceSampleRate = 0;
+    this.sourceBitDepth = 0;
+  }
+  async getMetadata() {
+    const fh = await open(this.properties.path, "r");
+    try {
+      const format = await parseWavFormat(fh, this.properties.path);
+      const selectedChannels = this.properties.channels;
+      const outputChannels = selectedChannels ? selectedChannels.length : format.channels;
+      const totalFrames = Math.floor(format.dataSize / format.blockAlign);
+      return {
+        sampleRate: format.sampleRate,
+        channels: outputChannels,
+        durationFrames: totalFrames
+      };
+    } finally {
+      await fh.close();
+    }
+  }
+  async ensureInitialized() {
+    if (this.format) return;
+    this.fileHandle = await open(this.properties.path, "r");
+    const format = await parseWavFormat(this.fileHandle, this.properties.path);
+    this.format = format;
+    this.bytesRead = 0;
+    this.sourceSampleRate = format.sampleRate;
+    this.sourceBitDepth = format.bitsPerSample;
+  }
+  async _read() {
+    await this.ensureInitialized();
+    const fh = this.fileHandle;
+    const format = this.format;
+    if (!fh || !format) {
+      return void 0;
+    }
+    const remaining = format.dataSize - this.bytesRead;
+    if (remaining <= 0) {
+      return void 0;
+    }
+    const framesWanted = DEFAULT_CHUNK_SIZE2;
+    const bytesWanted = Math.min(framesWanted * format.blockAlign, remaining);
+    const chunk = Buffer.alloc(bytesWanted);
+    const { bytesRead } = await fh.read(chunk, 0, bytesWanted, format.dataOffset + this.bytesRead);
+    if (bytesRead === 0) {
+      return void 0;
+    }
+    const frames = Math.floor(bytesRead / format.blockAlign);
+    this.bytesRead += frames * format.blockAlign;
+    const fileChannels = format.channels;
+    const selectedChannels = this.properties.channels;
+    const allChannels = [];
+    for (let ch = 0; ch < fileChannels; ch++) {
+      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];
+        if (channel) {
+          channel[frame] = readSample(chunk, byteOffset, format.bitsPerSample, format.audioFormat);
+        }
+      }
+    }
+    let samples;
+    if (selectedChannels) {
+      samples = selectedChannels.map((srcCh) => allChannels[srcCh] ?? new Float32Array(frames));
+    } else {
+      samples = allChannels;
+    }
+    const frameOffset = Math.floor((this.bytesRead - frames * format.blockAlign) / format.blockAlign);
+    return {
+      samples,
+      offset: frameOffset,
+      sampleRate: this.sourceSampleRate,
+      bitDepth: this.sourceBitDepth
+    };
+  }
+  async _flush() {
+    if (this.fileHandle) {
+      await this.fileHandle.close();
+      this.fileHandle = void 0;
+    }
+  }
+  _teardown() {
+    if (this.fileHandle) {
+      this.fileHandle.close().catch(() => void 0);
+      this.fileHandle = void 0;
+    }
+  }
+};
+var _ReadWavNode = class _ReadWavNode extends SourceNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "source", "read-wav"];
+  }
+  createStream() {
+    return new ReadWavStream(this.properties);
+  }
+  clone(overrides) {
+    return new _ReadWavNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_ReadWavNode.moduleName = "ReadWav";
+_ReadWavNode.moduleDescription = "Read audio from a WAV file";
+_ReadWavNode.schema = wavSchema;
+var ReadWavNode = _ReadWavNode;
+function readWav(path, options) {
+  return new ReadWavNode({ path, channels: options?.channels });
+}
+
+// src/sources/read/index.ts
+var schema = z.object({
+  path: z.string().default("").meta({ input: "file", mode: "open" }),
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  ffprobePath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffprobe", download: "https://ffmpeg.org/download.html" }).describe("FFprobe \u2014 media file analyzer (included with FFmpeg)")
+});
+var _ReadNode = class _ReadNode extends SourceNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "source", "read"];
+  }
+  createStream() {
+    const ext = extname(this.properties.path).toLowerCase();
+    if (ext === ".wav") {
+      return new ReadWavStream(this.properties);
+    }
+    if (!this.properties.ffmpegPath || !this.properties.ffprobePath) {
+      throw new Error(`Non-WAV file requires ffmpegPath and ffprobePath: "${this.properties.path}"`);
+    }
+    return new ReadFfmpegStream(this.properties);
+  }
+  clone(overrides) {
+    return new _ReadNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_ReadNode.moduleName = "Read";
+_ReadNode.moduleDescription = "Read audio from a file";
+_ReadNode.schema = schema;
+var ReadNode = _ReadNode;
+function read(path, options) {
+  return new ReadNode({ path, channels: options?.channels, ffmpegPath: options?.ffmpegPath ?? "", ffprobePath: options?.ffprobePath ?? "" });
+}
+function flattenBuffers(chunks, totalFrames) {
+  const result = new Float32Array(totalFrames);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function applyKWeighting(channelBuffers, channels, frames, sampleRate) {
+  const result = [];
+  for (let ch = 0; ch < channels; ch++) {
+    const buffers = channelBuffers[ch];
+    if (!buffers) continue;
+    const channelData = flattenBuffers(buffers, frames);
+    const filtered = applyPreFilter(channelData, sampleRate);
+    const rlbFiltered = applyRlbFilter(filtered, sampleRate);
+    result.push(rlbFiltered);
+  }
+  return result;
+}
+function applyPreFilter(samples, sampleRate) {
+  const { fb, fa } = preFilterCoefficients(sampleRate);
+  return biquadFilter(samples, fb, fa);
+}
+function applyRlbFilter(samples, sampleRate) {
+  const { fb, fa } = rlbFilterCoefficients(sampleRate);
+  return biquadFilter(samples, fb, fa);
+}
+function computeBlockLoudness(kWeighted, channels, frames, blockSize, stepSize) {
+  const results = [];
+  for (let start = 0; start + blockSize <= frames; start += stepSize) {
+    let sumMeanSquare = 0;
+    for (let ch = 0; ch < channels; ch++) {
+      const channel = kWeighted[ch];
+      if (!channel) continue;
+      let sum = 0;
+      for (let index = start; index < start + blockSize; index++) {
+        const sample = channel[index] ?? 0;
+        sum += sample * sample;
+      }
+      sumMeanSquare += sum / blockSize;
+    }
+    const loudness2 = -0.691 + 10 * Math.log10(Math.max(sumMeanSquare, 1e-10));
+    results.push(loudness2);
+  }
+  return results;
+}
+function computeIntegratedLoudness(kWeighted, channels, frames, blockSize, stepSize) {
+  const blockLoudness = computeBlockLoudness(kWeighted, channels, frames, blockSize, stepSize);
+  if (blockLoudness.length === 0) return -Infinity;
+  const absoluteGated = blockLoudness.filter((value) => value > -70);
+  if (absoluteGated.length === 0) return -Infinity;
+  const absoluteMean = absoluteGated.reduce((sum, value) => sum + Math.pow(10, value / 10), 0) / absoluteGated.length;
+  const relativeThreshold = 10 * Math.log10(absoluteMean) - 10;
+  const relativeGated = absoluteGated.filter((value) => value > relativeThreshold);
+  if (relativeGated.length === 0) return -Infinity;
+  const relativeMean = relativeGated.reduce((sum, value) => sum + Math.pow(10, value / 10), 0) / relativeGated.length;
+  return 10 * Math.log10(relativeMean);
+}
+function computeLra(shortTermLoudness) {
+  const absoluteGated = shortTermLoudness.filter((value) => value > -70);
+  if (absoluteGated.length < 2) return 0;
+  const absoluteMean = absoluteGated.reduce((sum, value) => sum + Math.pow(10, value / 10), 0) / absoluteGated.length;
+  const relativeThreshold = 10 * Math.log10(absoluteMean) - 20;
+  const relativeGated = absoluteGated.filter((value) => value > relativeThreshold);
+  if (relativeGated.length < 2) return 0;
+  relativeGated.sort((lhs, rhs) => lhs - rhs);
+  const p10Index = Math.floor(relativeGated.length * 0.1);
+  const p95Index = Math.min(Math.ceil(relativeGated.length * 0.95) - 1, relativeGated.length - 1);
+  return (relativeGated[p95Index] ?? 0) - (relativeGated[p10Index] ?? 0);
+}
+
+// src/targets/loudness-stats/index.ts
+var schema2 = z.object({});
+var LoudnessStatsStream = class extends BufferedTargetStream {
+  constructor() {
+    super(...arguments);
+    this.channels = 0;
+    this.sampleRate = 0;
+    this.truePeakValue = 0;
+    this.channelBuffers = [];
+    this.totalFrames = 0;
+    this.statsInitialized = false;
+  }
+  get stats() {
+    return this._stats;
+  }
+  ensureInit(chunk) {
+    if (this.statsInitialized) return;
+    this.statsInitialized = true;
+    this.channels = chunk.samples.length;
+    this.sampleRate = chunk.sampleRate;
+    for (let ch = 0; ch < this.channels; ch++) {
+      this.channelBuffers.push([]);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async _write(chunk) {
+    this.ensureInit(chunk);
+    for (let ch = 0; ch < this.channels; ch++) {
+      const samples = chunk.samples[ch];
+      if (!samples) continue;
+      const channelBuffer = this.channelBuffers[ch];
+      if (channelBuffer) channelBuffer.push(new Float32Array(samples));
+      for (const sample of samples) {
+        const abs = Math.abs(sample);
+        if (abs > this.truePeakValue) {
+          this.truePeakValue = abs;
+        }
+      }
+    }
+    this.totalFrames += chunk.samples[0]?.length ?? 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async _close() {
+    const channels = this.channels;
+    const frames = this.totalFrames;
+    const sampleRate = this.sampleRate;
+    const kWeighted = applyKWeighting(this.channelBuffers, channels, frames, sampleRate);
+    const blockSize400ms = Math.round(sampleRate * 0.4);
+    const stepSize = Math.round(sampleRate * 0.1);
+    const blockSize3s = sampleRate * 3;
+    const momentary = computeBlockLoudness(kWeighted, channels, frames, blockSize400ms, stepSize);
+    const shortTerm = computeBlockLoudness(kWeighted, channels, frames, blockSize3s, stepSize);
+    const integrated = computeIntegratedLoudness(kWeighted, channels, frames, blockSize400ms, stepSize);
+    const truePeak = 20 * Math.log10(Math.max(this.truePeakValue, 1e-10));
+    const range = computeLra(shortTerm);
+    this._stats = { integrated, shortTerm, momentary, truePeak, range };
+    this.channelBuffers = [];
+  }
+};
+var _LoudnessStatsNode = class _LoudnessStatsNode extends TargetNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "target", "loudness-stats"];
+  }
+  static is(value) {
+    return TargetNode.is(value) && value.type[2] === "loudness-stats";
+  }
+  get stats() {
+    const last = this.streams[this.streams.length - 1];
+    return last instanceof LoudnessStatsStream ? last.stats : this.cachedStats;
+  }
+  _teardown() {
+    const last = this.streams[this.streams.length - 1];
+    if (last instanceof LoudnessStatsStream && last.stats) {
+      this.cachedStats = last.stats;
+    }
+  }
+  createStream() {
+    return new LoudnessStatsStream(this.properties);
+  }
+  clone(overrides) {
+    return new _LoudnessStatsNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_LoudnessStatsNode.moduleName = "Loudness Stats";
+_LoudnessStatsNode.moduleDescription = "Measure integrated loudness, true peak, loudness range, and short-term/momentary loudness per EBU R128";
+_LoudnessStatsNode.schema = schema2;
+var LoudnessStatsNode = _LoudnessStatsNode;
+function loudnessStats(options) {
+  return new LoudnessStatsNode({
+    id: options?.id
+  });
+}
+function computeFrameMagnitudes(re, im, reOffset, linearBins, magScale, outputBins, bandMappings, magnitudeBuffer) {
+  const result = new Float32Array(outputBins);
+  if (bandMappings) {
+    for (let bin = 0; bin < linearBins; bin++) {
+      const real = re[reOffset + bin];
+      const imag = im[reOffset + bin];
+      magnitudeBuffer[bin] = Math.sqrt(real * real + imag * imag) * magScale;
+    }
+    for (let band = 0; band < outputBins; band++) {
+      const mapping = bandMappings[band];
+      if (!mapping) continue;
+      let sum = 0;
+      let weightSum = 0;
+      for (let bin = mapping.binStart; bin <= mapping.binEnd; bin++) {
+        let weight = 1;
+        if (bin === mapping.binStart) weight = mapping.weightStart;
+        else if (bin === mapping.binEnd) weight = mapping.weightEnd;
+        sum += magnitudeBuffer[bin] * weight;
+        weightSum += weight;
+      }
+      result[band] = weightSum > 0 ? sum / weightSum : 0;
+    }
+  } else {
+    for (let bin = 0; bin < outputBins; bin++) {
+      const real = re[reOffset + bin];
+      const imag = im[reOffset + bin];
+      result[bin] = Math.sqrt(real * real + imag * imag) * magScale;
+    }
+  }
+  return result;
+}
+function computeSpectrogramFrames(samples, batchFrames, fftSize, hopSize, linearBins, magScale, outputBins, windowCoefficients, workspace, addon, bandMappings, magnitudeBuffer) {
+  const frames = [];
+  if (addon) {
+    const batchInput = new Float32Array(fftSize * batchFrames);
+    for (let fi = 0; fi < batchFrames; fi++) {
+      const offset = fi * hopSize;
+      const destOffset = fi * fftSize;
+      for (let si = 0; si < fftSize; si++) {
+        batchInput[destOffset + si] = samples[offset + si] * windowCoefficients[si];
+      }
+    }
+    const { re: batchRe, im: batchIm } = addon.batchFft(batchInput, fftSize, batchFrames);
+    for (let fi = 0; fi < batchFrames; fi++) {
+      frames.push(computeFrameMagnitudes(batchRe, batchIm, fi * linearBins, linearBins, magScale, outputBins, bandMappings, magnitudeBuffer));
+    }
+  } else {
+    const windowed = new Float32Array(fftSize);
+    for (let fi = 0; fi < batchFrames; fi++) {
+      const offset = fi * hopSize;
+      for (let si = 0; si < fftSize; si++) {
+        windowed[si] = samples[offset + si] * windowCoefficients[si];
+      }
+      const { re, im } = fft(windowed, workspace);
+      frames.push(computeFrameMagnitudes(re, im, 0, linearBins, magScale, outputBins, bandMappings, magnitudeBuffer));
+    }
+  }
+  return frames;
+}
+
+// src/targets/spectrogram/utils/frequency.ts
+var FREQUENCY_SCALE_BYTE = { linear: 0, log: 1, mel: 2, erb: 3 };
+function freqToMel(freq) {
+  return 2595 * Math.log10(1 + freq / 700);
+}
+function melToFreq(mel) {
+  return 700 * (Math.pow(10, mel / 2595) - 1);
+}
+function freqToErb(freq) {
+  return 21.4 * Math.log10(1 + 437e-5 * freq);
+}
+function erbToFreq(erb) {
+  return (Math.pow(10, erb / 21.4) - 1) / 437e-5;
+}
+function computeScaledBandMappings(numBands, minFreq, maxFreq, sampleRate, fftSize, toScale, fromScale) {
+  const scaleMin = toScale(minFreq);
+  const scaleMax = toScale(maxFreq);
+  const scaleStep = (scaleMax - scaleMin) / numBands;
+  const binWidth = sampleRate / fftSize;
+  const numLinearBins = fftSize / 2 + 1;
+  const mappings = [];
+  for (let band = 0; band < numBands; band++) {
+    const freqLow = fromScale(scaleMin + band * scaleStep);
+    const freqHigh = fromScale(scaleMin + (band + 1) * scaleStep);
+    const exactBinLow = freqLow / binWidth;
+    const exactBinHigh = freqHigh / binWidth;
+    const binStart = Math.max(0, Math.floor(exactBinLow));
+    const binEnd = Math.min(numLinearBins - 1, Math.ceil(exactBinHigh));
+    const weightStart = 1 - (exactBinLow - binStart);
+    const weightEnd = 1 - (binEnd - exactBinHigh);
+    mappings.push({
+      binStart,
+      binEnd: Math.max(binStart, binEnd),
+      weightStart: Math.max(0, Math.min(1, weightStart)),
+      weightEnd: Math.max(0, Math.min(1, weightEnd))
+    });
+  }
+  return mappings;
+}
+function computeMelBandMappings(numBands, minFreq, maxFreq, sampleRate, fftSize) {
+  return computeScaledBandMappings(numBands, minFreq, maxFreq, sampleRate, fftSize, freqToMel, melToFreq);
+}
+function computeErbBandMappings(numBands, minFreq, maxFreq, sampleRate, fftSize) {
+  return computeScaledBandMappings(numBands, minFreq, maxFreq, sampleRate, fftSize, freqToErb, erbToFreq);
+}
+function computeLogBandMappings(numBands, minFreq, maxFreq, sampleRate, fftSize) {
+  const logMin = Math.log(minFreq);
+  const logMax = Math.log(maxFreq);
+  const logStep = (logMax - logMin) / numBands;
+  const binWidth = sampleRate / fftSize;
+  const numLinearBins = fftSize / 2 + 1;
+  const mappings = [];
+  for (let band = 0; band < numBands; band++) {
+    const freqLow = Math.exp(logMin + band * logStep);
+    const freqHigh = Math.exp(logMin + (band + 1) * logStep);
+    const exactBinLow = freqLow / binWidth;
+    const exactBinHigh = freqHigh / binWidth;
+    const binStart = Math.max(0, Math.floor(exactBinLow));
+    const binEnd = Math.min(numLinearBins - 1, Math.ceil(exactBinHigh));
+    const weightStart = 1 - (exactBinLow - binStart);
+    const weightEnd = 1 - (binEnd - exactBinHigh);
+    mappings.push({
+      binStart,
+      binEnd: Math.max(binStart, binEnd),
+      weightStart: Math.max(0, Math.min(1, weightStart)),
+      weightEnd: Math.max(0, Math.min(1, weightEnd))
+    });
+  }
+  return mappings;
+}
+
+// src/targets/spectrogram/index.ts
+var schema3 = z.object({
+  outputPath: z.string().default("").meta({ input: "file", mode: "save" }).describe("Output Path"),
+  fftSize: z.number().min(256).max(8192).multipleOf(256).default(2048).describe("FFT Size"),
+  hopSize: z.number().min(64).max(8192).multipleOf(64).default(512).describe("Hop Size"),
+  fftwAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "fftw-addon" }).describe("FFTW Addon")
+});
+var HEADER_SIZE = 33;
+var SpectrogramStream = class extends BufferedTargetStream {
+  constructor() {
+    super(...arguments);
+    this.channels = 0;
+    this.linearBins = 0;
+    this.outputBins = 0;
+    this.numFrames = 0;
+    this.fileOffset = HEADER_SIZE;
+    this.windowCoefficients = new Float32Array(0);
+    this.addon = null;
+    this.magnitudes = new Float32Array(0);
+    this.sampleBuffers = [];
+    this.sampleBufferOffset = 0;
+    this.sampleBufferCapacity = 0;
+    this.writeBufferOffset = 0;
+    this.writeBufferFileOffset = HEADER_SIZE;
+    this.WRITE_BATCH_FRAMES = 1e3;
+    this.initialized = false;
+  }
+  async _setup(input, context) {
+    this.linearBins = this.properties.fftSize / 2 + 1;
+    this.windowCoefficients = hanningWindow(this.properties.fftSize);
+    this.workspace = createFftWorkspace(this.properties.fftSize);
+    const fftAddonOptions = { fftwPath: this.properties.fftwAddonPath || void 0 };
+    const fftBackend = detectFftBackend(context.executionProviders, fftAddonOptions);
+    this.addon = getFftAddon(fftBackend, fftAddonOptions);
+    this.magnitudes = new Float32Array(this.linearBins);
+    this.numFrames = 0;
+    this.fileOffset = HEADER_SIZE;
+    this.sampleBufferOffset = 0;
+    this.sampleBufferCapacity = this.properties.fftSize + 8 * 1024 * 1024 / 4;
+    this.fileHandle = await open(this.properties.outputPath, "w");
+    return super._setup(input, context);
+  }
+  async initialize(chunk) {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.channels = chunk.samples.length;
+    const scale = this.properties.frequencyScale ?? "log";
+    const numBands = this.properties.numBands ?? 512;
+    const minFreq = this.properties.minFrequency ?? 20;
+    const maxFreq = this.properties.maxFrequency ?? chunk.sampleRate / 2;
+    if (scale === "linear") {
+      this.bandMappings = void 0;
+      this.outputBins = this.linearBins;
+    } else {
+      const computeFn = scale === "mel" ? computeMelBandMappings : scale === "erb" ? computeErbBandMappings : computeLogBandMappings;
+      this.bandMappings = computeFn(numBands, minFreq, maxFreq, chunk.sampleRate, this.properties.fftSize);
+      this.outputBins = numBands;
+    }
+    this.sampleBuffers = [];
+    for (let ch = 0; ch < this.channels; ch++) {
+      this.sampleBuffers.push(new Float32Array(this.sampleBufferCapacity));
+    }
+    if (!this.fileHandle) return;
+    const header = Buffer.alloc(HEADER_SIZE);
+    header.writeUInt32LE(chunk.sampleRate, 0);
+    header.writeUInt32LE(this.channels, 4);
+    header.writeUInt32LE(this.properties.fftSize, 8);
+    header.writeUInt32LE(this.properties.hopSize, 12);
+    header.writeUInt32LE(0, 16);
+    header.writeUInt32LE(this.outputBins, 20);
+    header.writeUInt8(FREQUENCY_SCALE_BYTE[scale], 24);
+    header.writeFloatLE(minFreq, 25);
+    header.writeFloatLE(maxFreq, 29);
+    await this.fileHandle.write(header, 0, HEADER_SIZE, 0);
+  }
+  async _write(chunk) {
+    await this.initialize(chunk);
+    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++) {
+        const newBuf = new Float32Array(newCapacity);
+        newBuf.set(this.sampleBuffers[ch].subarray(0, this.sampleBufferOffset));
+        this.sampleBuffers[ch] = 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);
+    }
+    this.sampleBufferOffset += frames;
+    await this.processAccumulatedSamples(false);
+  }
+  async _close() {
+    await this.processAccumulatedSamples(true);
+    if (this.writeBuffer && this.writeBufferOffset > 0) {
+      await this.fileHandle.write(this.writeBuffer, 0, this.writeBufferOffset, this.writeBufferFileOffset);
+      this.writeBufferOffset = 0;
+    }
+    this.writeBuffer = void 0;
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(this.numFrames, 0);
+    await this.fileHandle.write(header, 0, 4, 16);
+    await this.fileHandle.close();
+    this.fileHandle = void 0;
+  }
+  async processAccumulatedSamples(flush) {
+    const { fftSize, hopSize } = this.properties;
+    const { addon } = this;
+    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);
+      }
+      this.sampleBufferOffset = fftSize;
+    }
+    if (this.sampleBufferOffset < fftSize) return;
+    const batchFrames = Math.floor((this.sampleBufferOffset - fftSize) / hopSize) + 1;
+    if (batchFrames === 0) return;
+    const frameByteSize = this.outputBins * this.channels * 4;
+    const batchBytes = this.WRITE_BATCH_FRAMES * frameByteSize;
+    if (!this.writeBuffer) {
+      this.writeBuffer = Buffer.alloc(batchBytes);
+      this.writeBufferOffset = 0;
+      this.writeBufferFileOffset = this.fileOffset;
+    }
+    for (let ch = 0; ch < this.channels; ch++) {
+      const frames = computeSpectrogramFrames(
+        this.sampleBuffers[ch],
+        batchFrames,
+        fftSize,
+        hopSize,
+        halfSize,
+        magScale,
+        this.outputBins,
+        this.windowCoefficients,
+        this.workspace,
+        addon,
+        this.bandMappings,
+        this.magnitudes
+      );
+      for (const frame of frames) {
+        await this.writeFrame(ch, 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);
+      }
+    }
+    this.sampleBufferOffset = keepCount > 0 ? keepCount : 0;
+  }
+  async writeFrame(ch, 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 offset = this.writeBufferOffset;
+    for (let bin = 0; bin < this.outputBins; bin++) {
+      buf.writeFloatLE(frame[bin], offset + (ch * this.outputBins + bin) * 4);
+    }
+    this.writeBufferOffset += frameByteSize;
+    this.fileOffset += frameByteSize;
+    this.numFrames++;
+  }
+  async flushWriteBuffer() {
+    if (!this.writeBuffer || this.writeBufferOffset === 0) return;
+    await this.fileHandle.write(this.writeBuffer, 0, this.writeBufferOffset, this.writeBufferFileOffset);
+    this.writeBufferFileOffset += this.writeBufferOffset;
+    this.writeBufferOffset = 0;
+  }
+};
+var _SpectrogramNode = class _SpectrogramNode extends TargetNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "target", "spectrogram"];
+  }
+  static is(value) {
+    return TargetNode.is(value) && value.type[2] === "spectrogram";
+  }
+  createStream() {
+    return new SpectrogramStream(this.properties);
+  }
+  clone(overrides) {
+    return new _SpectrogramNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_SpectrogramNode.moduleName = "Spectrogram";
+_SpectrogramNode.moduleDescription = "Generate spectrogram visualization data";
+_SpectrogramNode.schema = schema3;
+var SpectrogramNode = _SpectrogramNode;
+function spectrogram(outputPath, options) {
+  return new SpectrogramNode({
+    outputPath,
+    fftSize: options?.fftSize ?? 2048,
+    hopSize: options?.hopSize ?? 512,
+    frequencyScale: options?.frequencyScale,
+    numBands: options?.numBands,
+    minFrequency: options?.minFrequency,
+    maxFrequency: options?.maxFrequency,
+    fftwAddonPath: options?.fftwAddonPath ?? ""
+  });
+}
+
+// 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;
+  }
+}
+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);
+  }
+}
+
+// src/targets/waveform/index.ts
+var schema4 = z.object({
+  outputPath: z.string().default("").meta({ input: "file", mode: "save" }).describe("Output Path"),
+  resolution: z.number().min(100).max(1e4).multipleOf(100).default(1e3).describe("Resolution")
+});
+var HEADER_SIZE2 = 16;
+var WaveformStream = class extends BufferedTargetStream {
+  constructor() {
+    super(...arguments);
+    this.channels = 0;
+    this.samplesPerPoint = 1;
+    this.totalPoints = 0;
+    this.fileOffset = HEADER_SIZE2;
+    this.samplesInCurrentWindow = 0;
+    this.currentMin = new Float32Array(0);
+    this.currentMax = new Float32Array(0);
+    this.writeBuffer = Buffer.alloc(0);
+    this.writeBufferOffset = 0;
+    this.writeBufferFileOffset = HEADER_SIZE2;
+    this.WRITE_BATCH_POINTS = 1e3;
+    this.initialized = false;
+  }
+  async _setup(input, context) {
+    this.writeBufferOffset = 0;
+    this.writeBufferFileOffset = HEADER_SIZE2;
+    this.totalPoints = 0;
+    this.fileOffset = HEADER_SIZE2;
+    this.samplesInCurrentWindow = 0;
+    this.fileHandle = await open(this.properties.outputPath, "w");
+    return super._setup(input, context);
+  }
+  initialize(chunk) {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.channels = chunk.samples.length;
+    this.samplesPerPoint = Math.max(1, Math.round(chunk.sampleRate / this.properties.resolution));
+    this.currentMin = new Float32Array(this.channels).fill(1);
+    this.currentMax = new Float32Array(this.channels).fill(-1);
+    const pointByteSize = this.channels * 8;
+    this.writeBuffer = Buffer.alloc(this.WRITE_BATCH_POINTS * pointByteSize);
+  }
+  async writeHeader(chunk) {
+    if (!this.fileHandle) return;
+    const header = Buffer.alloc(HEADER_SIZE2);
+    header.writeUInt32LE(chunk.sampleRate, 0);
+    header.writeUInt32LE(this.channels, 4);
+    header.writeUInt32LE(this.properties.resolution, 8);
+    header.writeUInt32LE(0, 12);
+    await this.fileHandle.write(header, 0, HEADER_SIZE2, 0);
+  }
+  async _write(chunk) {
+    if (!this.initialized) {
+      this.initialize(chunk);
+      await this.writeHeader(chunk);
+    }
+    const frames = chunk.samples[0]?.length ?? 0;
+    for (let frame = 0; frame < frames; frame++) {
+      updateMinMax(chunk.samples, frame, this.channels, this.currentMin, this.currentMax);
+      this.samplesInCurrentWindow++;
+      if (this.samplesInCurrentWindow >= this.samplesPerPoint) {
+        await this.flushPoint();
+      }
+    }
+  }
+  async _close() {
+    if (this.samplesInCurrentWindow > 0) {
+      await this.flushPoint();
+    }
+    const fh = this.fileHandle;
+    if (!fh) return;
+    if (this.writeBufferOffset > 0) {
+      await fh.write(this.writeBuffer, 0, this.writeBufferOffset, this.writeBufferFileOffset);
+      this.writeBufferOffset = 0;
+    }
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(this.totalPoints, 0);
+    await fh.write(header, 0, 4, 12);
+    await fh.close();
+    this.fileHandle = void 0;
+  }
+  async flushPoint() {
+    const pointByteSize = this.channels * 8;
+    if (this.writeBufferOffset + pointByteSize > this.writeBuffer.length) {
+      await this.flushWriteBuffer();
+    }
+    writeMinMaxPoint(this.currentMin, this.currentMax, this.channels, this.writeBuffer, this.writeBufferOffset);
+    this.writeBufferOffset += pointByteSize;
+    this.fileOffset += pointByteSize;
+    this.totalPoints++;
+    this.samplesInCurrentWindow = 0;
+    this.currentMin.fill(1);
+    this.currentMax.fill(-1);
+  }
+  async flushWriteBuffer() {
+    if (this.writeBufferOffset === 0 || !this.fileHandle) return;
+    await this.fileHandle.write(this.writeBuffer, 0, this.writeBufferOffset, this.writeBufferFileOffset);
+    this.writeBufferFileOffset += this.writeBufferOffset;
+    this.writeBufferOffset = 0;
+  }
+};
+var _WaveformNode = class _WaveformNode extends TargetNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "target", "waveform"];
+  }
+  static is(value) {
+    return TargetNode.is(value) && value.type[2] === "waveform";
+  }
+  createStream() {
+    return new WaveformStream(this.properties);
+  }
+  clone(overrides) {
+    return new _WaveformNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_WaveformNode.moduleName = "Waveform";
+_WaveformNode.moduleDescription = "Generate waveform visualization data";
+_WaveformNode.schema = schema4;
+var WaveformNode = _WaveformNode;
+function waveform(outputPath, options) {
+  return new WaveformNode({
+    outputPath,
+    resolution: options?.resolution ?? 1e3
+  });
+}
+
+// src/utils/ffmpeg.ts
+function waitForDrain(proc, stdin) {
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      stdin.removeListener("drain", onDrain);
+      proc.removeListener("error", onError);
+      proc.removeListener("close", onClose);
+    };
+    const onDrain = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onClose = (code) => {
+      cleanup();
+      reject(new Error(`ffmpeg exited with code ${code} while writing stdin`));
+    };
+    stdin.once("drain", onDrain);
+    proc.once("error", onError);
+    proc.once("close", onClose);
+  });
+}
+
+// src/targets/write/utils/wav.ts
+var UINT32_MAX = 4294967295;
+function getBytesPerSample(bitDepth) {
+  switch (bitDepth) {
+    case "16":
+      return 2;
+    case "24":
+      return 3;
+    case "32":
+    case "32f":
+      return 4;
+  }
+}
+function writeSample(buffer, offset, sample, bitDepth) {
+  switch (bitDepth) {
+    case "16": {
+      const clamped = Math.max(-1, Math.min(1, sample));
+      const value = clamped < 0 ? clamped * 32768 : clamped * 32767;
+      buffer.writeInt16LE(Math.round(value), offset);
+      return offset + 2;
+    }
+    case "24": {
+      const clamped = Math.max(-1, Math.min(1, sample));
+      const value = Math.round(clamped < 0 ? clamped * 8388608 : clamped * 8388607);
+      buffer[offset] = value & 255;
+      buffer[offset + 1] = value >> 8 & 255;
+      buffer[offset + 2] = value >> 16 & 255;
+      return offset + 3;
+    }
+    case "32": {
+      const clamped = Math.max(-1, Math.min(1, sample));
+      const value = clamped < 0 ? clamped * 2147483648 : clamped * 2147483647;
+      buffer.writeInt32LE(Math.round(value), offset);
+      return offset + 4;
+    }
+    case "32f": {
+      buffer.writeFloatLE(sample, offset);
+      return offset + 4;
+    }
+  }
+}
+function writeFmtAndDataChunks(header, offset, sampleRate, channels, bitDepth, dataSize) {
+  const bytesPerSample = getBytesPerSample(bitDepth);
+  const blockAlign = channels * bytesPerSample;
+  const byteRate = sampleRate * blockAlign;
+  const bitsPerSample = bytesPerSample * 8;
+  const audioFormat = bitDepth === "32f" ? 3 : 1;
+  header.write("fmt ", offset);
+  header.writeUInt32LE(16, offset + 4);
+  header.writeUInt16LE(audioFormat, offset + 8);
+  header.writeUInt16LE(channels, offset + 10);
+  header.writeUInt32LE(sampleRate, offset + 12);
+  header.writeUInt32LE(byteRate, offset + 16);
+  header.writeUInt16LE(blockAlign, offset + 20);
+  header.writeUInt16LE(bitsPerSample, offset + 22);
+  header.write("data", offset + 24);
+  header.writeUInt32LE(dataSize, offset + 28);
+}
+function buildWavHeader(dataSize, sampleRate, channels, bitDepth) {
+  const WAV_HEADER_SIZE2 = 80;
+  const header = Buffer.alloc(WAV_HEADER_SIZE2);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(WAV_HEADER_SIZE2 - 8 + dataSize, 4);
+  header.write("WAVE", 8);
+  header.write("JUNK", 12);
+  header.writeUInt32LE(28, 16);
+  writeFmtAndDataChunks(header, 48, sampleRate, channels, bitDepth, dataSize);
+  return header;
+}
+function buildRf64Header(dataSize, sampleRate, channels, bitDepth) {
+  const WAV_HEADER_SIZE2 = 80;
+  const header = Buffer.alloc(WAV_HEADER_SIZE2);
+  const bytesPerSample = getBytesPerSample(bitDepth);
+  const blockAlign = channels * bytesPerSample;
+  const sampleCount = Math.floor(dataSize / blockAlign);
+  header.write("RF64", 0);
+  header.writeUInt32LE(UINT32_MAX, 4);
+  header.write("WAVE", 8);
+  header.write("ds64", 12);
+  header.writeUInt32LE(28, 16);
+  writeBigUInt64LE(header, 20, WAV_HEADER_SIZE2 - 8 + dataSize);
+  writeBigUInt64LE(header, 28, dataSize);
+  writeBigUInt64LE(header, 36, sampleCount);
+  header.writeUInt32LE(0, 44);
+  writeFmtAndDataChunks(header, 48, sampleRate, channels, bitDepth, UINT32_MAX);
+  return header;
+}
+function writeBigUInt64LE(buffer, offset, value) {
+  buffer.writeBigUInt64LE(BigInt(Math.floor(value)), offset);
+}
+
+// src/targets/write/index.ts
+var schema5 = z.object({
+  path: z.string().default("").meta({ input: "file", mode: "save" }),
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  bitDepth: z.enum(["16", "24", "32", "32f"]).default("16")
+});
+var WAV_HEADER_SIZE = 80;
+var UINT32_MAX2 = 4294967295;
+var WriteStream = class extends BufferedTargetStream {
+  constructor() {
+    super(...arguments);
+    this.sampleRate = 0;
+    this.channels = 0;
+    this.bytesWritten = 0;
+    this.useEncoding = false;
+    this.headerWritten = false;
+    this.initialized = false;
+  }
+  async _setup(input, context) {
+    this.bytesWritten = 0;
+    this.headerWritten = false;
+    this.initialized = false;
+    const encoding = this.properties.encoding;
+    if (encoding && encoding.format !== "wav" && !this.properties.ffmpegPath) {
+      throw new Error(`Encoding to ${encoding.format} requires ffmpegPath`);
+    }
+    this.useEncoding = encoding !== void 0 && encoding.format !== "wav" && !!this.properties.ffmpegPath;
+    if (this.useEncoding && encoding) {
+      const ffmpegPath = this.properties.ffmpegPath;
+      if (!ffmpegPath) throw new Error("ffmpegPath is required for encoding");
+      const args = this.buildFfmpegArgs(encoding);
+      const proc = spawn(ffmpegPath, args, {
+        stdio: ["pipe", "ignore", "pipe"]
+      });
+      this.ffmpegProcess = proc;
+      this.ffmpegStdin = proc.stdin;
+      this.ffmpegStdin.on("error", () => {
+      });
+      this.ffmpegDone = new Promise((resolve, reject) => {
+        proc.on("close", (code) => {
+          if (code !== 0) {
+            reject(new Error(`ffmpeg exited with code ${code}`));
+          } else {
+            resolve();
+          }
+        });
+        proc.on("error", (error) => {
+          reject(new Error(`Failed to spawn ffmpeg: ${error.message}`));
+        });
+      });
+    } else {
+      this.fileHandle = await open(this.properties.path, "w");
+    }
+    return super._setup(input, context);
+  }
+  async initialize(chunk) {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.sampleRate = chunk.sampleRate;
+    this.channels = chunk.samples.length;
+    if (!this.useEncoding && this.fileHandle) {
+      const header = buildWavHeader(0, this.sampleRate, this.channels, this.properties.bitDepth);
+      await this.fileHandle.write(header, 0, WAV_HEADER_SIZE, 0);
+    }
+  }
+  async _write(chunk) {
+    await this.initialize(chunk);
+    const bytes = this.convertChunk(chunk);
+    if (this.useEncoding && this.ffmpegStdin) {
+      if (!this.headerWritten) {
+        const header = buildWavHeader(4294967295, this.sampleRate, this.channels, this.properties.bitDepth);
+        await this.writeToStdin(header);
+        this.headerWritten = true;
+      }
+      await this.writeToStdin(bytes);
+    } else if (this.fileHandle) {
+      await this.fileHandle.write(bytes, 0, bytes.length, WAV_HEADER_SIZE + this.bytesWritten);
+    }
+    this.bytesWritten += bytes.length;
+  }
+  async _close() {
+    if (this.useEncoding) {
+      if (this.ffmpegStdin) {
+        this.ffmpegStdin.end();
+      }
+      if (this.ffmpegDone) {
+        await this.ffmpegDone;
+      }
+      this.ffmpegProcess = void 0;
+      this.ffmpegStdin = void 0;
+      this.ffmpegDone = void 0;
+    } else if (this.fileHandle) {
+      const header = this.bytesWritten > UINT32_MAX2 ? buildRf64Header(this.bytesWritten, this.sampleRate, this.channels, this.properties.bitDepth) : buildWavHeader(this.bytesWritten, this.sampleRate, this.channels, this.properties.bitDepth);
+      await this.fileHandle.write(header, 0, WAV_HEADER_SIZE, 0);
+      await this.fileHandle.close();
+      this.fileHandle = void 0;
+    }
+  }
+  convertChunk(chunk) {
+    const frames = chunk.samples[0]?.length ?? 0;
+    const channels = chunk.samples.length;
+    const bytesPerSample = getBytesPerSample(this.properties.bitDepth);
+    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;
+        offset = writeSample(buffer, offset, sample, this.properties.bitDepth);
+      }
+    }
+    return buffer;
+  }
+  buildFfmpegArgs(encoding) {
+    const args = ["-f", "wav", "-i", "pipe:0"];
+    switch (encoding.format) {
+      case "flac":
+        args.push("-codec:a", "flac");
+        break;
+      case "mp3":
+        args.push("-codec:a", "libmp3lame");
+        if (encoding.vbr !== void 0) {
+          args.push("-q:a", String(encoding.vbr));
+        } else {
+          args.push("-b:a", encoding.bitrate ?? "192k");
+        }
+        break;
+      case "aac":
+        args.push("-codec:a", "aac", "-b:a", encoding.bitrate ?? "192k");
+        break;
+    }
+    args.push("-y", this.properties.path);
+    return args;
+  }
+  writeToStdin(data) {
+    const stdin = this.ffmpegStdin;
+    const proc = this.ffmpegProcess;
+    if (!stdin || !proc) return Promise.resolve();
+    const canWrite = stdin.write(data);
+    if (!canWrite) {
+      return waitForDrain(proc, stdin);
+    }
+    return Promise.resolve();
+  }
+};
+var _WriteNode = class _WriteNode extends TargetNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "target", "write"];
+  }
+  createStream() {
+    return new WriteStream(this.properties);
+  }
+  clone(overrides) {
+    return new _WriteNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_WriteNode.moduleName = "Write";
+_WriteNode.moduleDescription = "Write audio to a file";
+_WriteNode.schema = schema5;
+var WriteNode = _WriteNode;
+function write(path, options) {
+  return new WriteNode({
+    path,
+    bitDepth: options?.bitDepth ?? "16",
+    ffmpegPath: options?.ffmpegPath ?? "",
+    encoding: options?.encoding
+  });
+}
+var cutRegionSchema = z.object({
+  start: z.number().min(0).describe("Start (seconds)"),
+  end: z.number().min(0).describe("End (seconds)")
+});
+var schema6 = z.object({
+  regions: z.array(cutRegionSchema).default([]).describe("Regions")
+});
+var CutStream = class extends BufferedTransformStream {
+  constructor(properties) {
+    super(properties);
+    this.removedFrames = 0;
+    this.sortedRegions = [...this.properties.regions].sort((left, right) => left.start - right.start);
+  }
+  _unbuffer(chunk) {
+    const sampleRate = chunk.sampleRate;
+    const chunkFrames = chunk.samples[0]?.length ?? 0;
+    const chunkStartSec = chunk.offset / sampleRate;
+    const keepRanges = [];
+    let cursor = 0;
+    for (const region of this.sortedRegions) {
+      const cutStart = Math.max(0, Math.round((region.start - chunkStartSec) * sampleRate));
+      const cutEnd = Math.min(chunkFrames, Math.round((region.end - chunkStartSec) * sampleRate));
+      if (cutEnd <= 0 || cutStart >= chunkFrames) continue;
+      const clampedStart = Math.max(cursor, 0);
+      const clampedEnd = Math.max(clampedStart, cutStart);
+      if (clampedEnd > clampedStart) {
+        keepRanges.push({ start: clampedStart, end: clampedEnd });
+      }
+      cursor = Math.max(cursor, cutEnd);
+    }
+    if (cursor < chunkFrames) {
+      keepRanges.push({ start: cursor, end: chunkFrames });
+    }
+    if (keepRanges.length === 0) return void 0;
+    const totalKept = keepRanges.reduce((sum, range) => sum + (range.end - range.start), 0);
+    const removedFrames = chunkFrames - totalKept;
+    const adjustedOffset = chunk.offset - this.removedFrames;
+    this.removedFrames += removedFrames;
+    if (totalKept === chunkFrames) {
+      return { samples: chunk.samples, offset: adjustedOffset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+    }
+    const channels = chunk.samples.length;
+    const output = [];
+    for (let ch = 0; ch < channels; ch++) {
+      const channel = chunk.samples[ch];
+      if (!channel) {
+        output.push(new Float32Array(totalKept));
+        continue;
+      }
+      const out = new Float32Array(totalKept);
+      let writeOffset = 0;
+      for (const range of keepRanges) {
+        out.set(channel.subarray(range.start, range.end), writeOffset);
+        writeOffset += range.end - range.start;
+      }
+      output.push(out);
+    }
+    return { samples: output, offset: adjustedOffset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+  }
+};
+var _CutNode = class _CutNode extends TransformNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "cut"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "cut";
+  }
+  createStream() {
+    return new CutStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _CutNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_CutNode.moduleName = "Cut";
+_CutNode.moduleDescription = "Remove a region of audio";
+_CutNode.schema = schema6;
+var CutNode = _CutNode;
+function cut(regions, options) {
+  return new CutNode({ regions, id: options?.id });
+}
+var schema7 = z.object({
+  bitDepth: z.union([z.literal(16), z.literal(24)]).default(16).describe("Bit Depth"),
+  noiseShaping: z.boolean().default(false).describe("Noise Shaping")
+});
+var DitherStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this.lastError = [];
+  }
+  async _buffer(chunk, buffer) {
+    await buffer.append(chunk.samples, chunk.sampleRate, this.properties.bitDepth);
+  }
+  _unbuffer(chunk) {
+    const { bitDepth, noiseShaping } = this.properties;
+    const quantizationLevels = Math.pow(2, bitDepth - 1);
+    const lsb = 1 / quantizationLevels;
+    while (this.lastError.length < chunk.samples.length) {
+      this.lastError.push(0);
+    }
+    const samples = chunk.samples.map((channel, ch) => {
+      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;
+        }
+        const quantized = Math.round(dithered * quantizationLevels) / quantizationLevels;
+        if (noiseShaping) {
+          this.lastError[ch] = dithered - quantized;
+        }
+        output[index] = quantized;
+      }
+      return output;
+    });
+    return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: this.properties.bitDepth };
+  }
+};
+var _DitherNode = class _DitherNode extends TransformNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "dither"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "dither";
+  }
+  createStream() {
+    return new DitherStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _DitherNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DitherNode.moduleName = "Dither";
+_DitherNode.moduleDescription = "Add shaped noise to reduce quantization distortion";
+_DitherNode.schema = schema7;
+var DitherNode = _DitherNode;
+function dither(bitDepth, options) {
+  const parsed = schema7.parse({ bitDepth, noiseShaping: options?.noiseShaping });
+  return new DitherNode({ ...parsed, id: options?.id });
+}
+var schema8 = z.object({
+  ceiling: z.number().min(0).max(1).multipleOf(0.01).default(1).describe("Ceiling")
+});
+var NormalizeStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this.peak = 0;
+    this.scale = 1;
+  }
+  async _buffer(chunk, buffer) {
+    await super._buffer(chunk, buffer);
+    for (let ch = 0; ch < chunk.samples.length; ch++) {
+      const channel = chunk.samples[ch] ?? new Float32Array(0);
+      for (let si = 0; si < channel.length; si++) {
+        const absolute = Math.abs(channel[si] ?? 0);
+        if (Number.isFinite(absolute) && absolute > this.peak) this.peak = absolute;
+      }
+    }
+  }
+  _process(_buffer) {
+    const raw = this.peak === 0 ? 1 : this.properties.ceiling / this.peak;
+    this.scale = Number.isFinite(raw) ? raw : 1;
+  }
+  _unbuffer(chunk) {
+    if (this.scale === 1) return chunk;
+    const scaledSamples = chunk.samples.map((channel) => {
+      const scaled = new Float32Array(channel.length);
+      for (let index = 0; index < channel.length; index++) {
+        scaled[index] = (channel[index] ?? 0) * this.scale;
+      }
+      return scaled;
+    });
+    return { samples: scaledSamples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+  }
+};
+var _NormalizeNode = class _NormalizeNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "normalize"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "normalize";
+  }
+  createStream() {
+    return new NormalizeStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _NormalizeNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_NormalizeNode.moduleName = "Normalize";
+_NormalizeNode.moduleDescription = "Adjust peak or loudness level to a target ceiling";
+_NormalizeNode.schema = schema8;
+var NormalizeNode = _NormalizeNode;
+function normalize(options) {
+  return new NormalizeNode({ ceiling: options?.ceiling ?? 1, id: options?.id });
+}
+var schema9 = z.object({
+  before: z.number().min(0).multipleOf(1e-3).default(0).describe("Before"),
+  after: z.number().min(0).multipleOf(1e-3).default(0).describe("After")
+});
+var PadStream = class extends BufferedTransformStream {
+  async _process(buffer) {
+    const { before, after } = this.properties;
+    const channels = buffer.channels;
+    const sr = this.sampleRate ?? 44100;
+    if (before > 0) {
+      const silenceFrames = Math.round(before * sr);
+      const frames = buffer.frames;
+      const allAudio = await buffer.read(0, frames);
+      const padded = [];
+      for (let ch = 0; ch < channels; ch++) {
+        const original = allAudio.samples[ch] ?? new Float32Array(0);
+        const withPad = new Float32Array(silenceFrames + original.length);
+        withPad.set(original, silenceFrames);
+        padded.push(withPad);
+      }
+      await buffer.truncate(0);
+      await buffer.append(padded);
+    }
+    if (after > 0) {
+      const silenceFrames = Math.round(after * sr);
+      const silence = [];
+      for (let ch = 0; ch < channels; ch++) {
+        silence.push(new Float32Array(silenceFrames));
+      }
+      await buffer.append(silence);
+    }
+  }
+};
+var _PadNode = class _PadNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "pad"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "pad";
+  }
+  createStream() {
+    return new PadStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _PadNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_PadNode.moduleName = "Pad";
+_PadNode.moduleDescription = "Add silence to start or end of audio";
+_PadNode.schema = schema9;
+var PadNode = _PadNode;
+function pad(options) {
+  const parsed = schema9.parse(options);
+  return new PadNode({ ...parsed, id: options.id });
+}
+var schema10 = z.object({
+  invert: z.boolean().default(true).describe("Invert"),
+  angle: z.number().min(-180).max(180).multipleOf(1).optional().describe("Angle")
+});
+var PhaseStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this.allpassState = [];
+  }
+  _unbuffer(chunk) {
+    const { invert: invert2, angle } = this.properties;
+    if (angle !== void 0) {
+      return this.applyPhaseRotation(chunk, angle);
+    }
+    if (invert2) {
+      return this.applyInvert(chunk);
+    }
+    return chunk;
+  }
+  applyInvert(chunk) {
+    const samples = chunk.samples.map((channel) => {
+      const output = new Float32Array(channel.length);
+      for (let index = 0; index < channel.length; index++) {
+        output[index] = -(channel[index] ?? 0);
+      }
+      return output;
+    });
+    return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+  }
+  applyPhaseRotation(chunk, angle) {
+    const radians = angle * Math.PI / 180;
+    const coefficient = Math.tan((radians - Math.PI) / 4);
+    while (this.allpassState.length < chunk.samples.length) {
+      this.allpassState.push(0);
+    }
+    const samples = chunk.samples.map((channel, ch) => {
+      const output = new Float32Array(channel.length);
+      let state = this.allpassState[ch] ?? 0;
+      for (let index = 0; index < channel.length; index++) {
+        const input = channel[index] ?? 0;
+        const allpassOut = coefficient * input + state;
+        state = input - coefficient * allpassOut;
+        output[index] = allpassOut;
+      }
+      this.allpassState[ch] = state;
+      return output;
+    });
+    return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+  }
+};
+var _PhaseNode = class _PhaseNode extends TransformNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "phase"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "phase";
+  }
+  createStream() {
+    return new PhaseStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _PhaseNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_PhaseNode.moduleName = "Phase";
+_PhaseNode.moduleDescription = "Invert or rotate signal phase";
+_PhaseNode.schema = schema10;
+var PhaseNode = _PhaseNode;
+function phase(options) {
+  return new PhaseNode({
+    invert: options?.invert ?? true,
+    angle: options?.angle,
+    id: options?.id
+  });
+}
+function invert(options) {
+  return phase({ invert: true, id: options?.id });
+}
+var schema11 = z.object({});
+var ReverseStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this.spareChunkSize = 44100;
+    this.spareInitialized = false;
+  }
+  async _setup(input, context) {
+    this.reverseMemoryLimit = context.memoryLimit;
+    return super._setup(input, context);
+  }
+  ensureSpareBuffer(chunk) {
+    if (this.spareInitialized) return;
+    this.spareInitialized = true;
+    this.spareChunkSize = chunk.sampleRate;
+    this.spareBuffer = new FileChunkBuffer(Infinity, chunk.samples.length, this.reverseMemoryLimit);
+  }
+  async _buffer(chunk, buffer) {
+    this.ensureSpareBuffer(chunk);
+    await super._buffer(chunk, buffer);
+    await this.spareBuffer?.append(chunk.samples);
+  }
+  async _process(buffer) {
+    if (!this.spareBuffer) return;
+    await buffer.truncate(0);
+    let remaining = this.spareBuffer.frames;
+    while (remaining > 0) {
+      const frames = Math.min(this.spareChunkSize, remaining);
+      const offset = remaining - frames;
+      const chunk = await this.spareBuffer.read(offset, frames);
+      for (const channel of chunk.samples) {
+        channel.reverse();
+      }
+      await buffer.append(chunk.samples);
+      remaining = offset;
+    }
+    await this.spareBuffer.close();
+    this.spareBuffer = void 0;
+  }
+};
+var _ReverseNode = class _ReverseNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "reverse"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "reverse";
+  }
+  createStream() {
+    return new ReverseStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _ReverseNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_ReverseNode.moduleName = "Reverse";
+_ReverseNode.moduleDescription = "Reverse audio playback direction";
+_ReverseNode.schema = schema11;
+var ReverseNode = _ReverseNode;
+function reverse(options) {
+  return new ReverseNode({ id: options?.id });
+}
+async function readWavSamples(path) {
+  const data = await readFile(path);
+  const wav = new WaveFile(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  wav.toBitDepth("32f");
+  const fmt = wav.fmt;
+  const rawSamples = wav.getSamples(false, Float64Array);
+  const sampleRate = fmt.sampleRate;
+  const channels = fmt.numChannels;
+  let samples;
+  if (channels === 1) {
+    samples = [new Float32Array(rawSamples)];
+  } else {
+    samples = rawSamples.map((channel) => new Float32Array(channel));
+  }
+  const durationFrames = samples[0]?.length ?? 0;
+  return { samples, sampleRate, channels, durationFrames };
+}
+async function readToBuffer(path) {
+  const { samples, sampleRate, channels, durationFrames } = await readWavSamples(path);
+  const buffer = new FileChunkBuffer(durationFrames, channels);
+  await buffer.append(samples);
+  return { buffer, context: { sampleRate, channels, durationFrames } };
+}
+
+// src/transforms/splice/index.ts
+var schema12 = z.object({
+  insertPath: z.string().default("").meta({ input: "file", mode: "open", accept: ".wav" }).describe("Insert File Path"),
+  insertAt: z.number().min(0).default(0).describe("Insert At (frames)")
+});
+var SpliceStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this.insertSampleRate = 0;
+    this.insertLength = 0;
+    this.sampleRateChecked = false;
+  }
+  async _setup(input, context) {
+    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`);
+        }
+      }
+    }
+    this.insertSamples = samples;
+    this.insertSampleRate = sampleRate;
+    this.insertLength = samples[0]?.length ?? 0;
+    return super._setup(input, context);
+  }
+  _unbuffer(chunk) {
+    if (!this.sampleRateChecked) {
+      this.sampleRateChecked = true;
+      if (this.sampleRate !== void 0 && this.insertSampleRate !== this.sampleRate) {
+        throw new Error(`Splice: insert file sample rate ${this.insertSampleRate} does not match stream sample rate ${this.sampleRate}`);
+      }
+    }
+    const chunkFrames = chunk.samples[0]?.length ?? 0;
+    const chunkStart = chunk.offset;
+    const chunkEnd = chunkStart + chunkFrames;
+    const insertEnd = this.properties.insertAt + this.insertLength;
+    if (chunkEnd <= this.properties.insertAt || chunkStart >= insertEnd) {
+      return chunk;
+    }
+    const samples = chunk.samples.map((channel) => new Float32Array(channel));
+    const overlapStart = Math.max(0, this.properties.insertAt - chunkStart);
+    const overlapEnd = Math.min(chunkFrames, insertEnd - chunkStart);
+    const insertOffset = Math.max(0, chunkStart - this.properties.insertAt);
+    const targetChannels = this.properties.channels;
+    if (targetChannels) {
+      for (let insertCh = 0; insertCh < targetChannels.length; insertCh++) {
+        const primaryCh = targetChannels[insertCh];
+        if (primaryCh === void 0) continue;
+        const channelSamples = samples[primaryCh];
+        const insertChannel = this.insertSamples[insertCh];
+        if (!channelSamples || !insertChannel) continue;
+        for (let frame = overlapStart; frame < overlapEnd; frame++) {
+          const insertIndex = insertOffset + frame - overlapStart;
+          const insertSample = insertChannel[insertIndex];
+          if (insertSample !== void 0) {
+            channelSamples[frame] = insertSample;
+          }
+        }
+      }
+    } else {
+      for (let ch = 0; ch < samples.length; ch++) {
+        const channelSamples = samples[ch];
+        const insertChannel = this.insertSamples[ch];
+        if (!channelSamples || !insertChannel) continue;
+        for (let frame = overlapStart; frame < overlapEnd; frame++) {
+          const insertIndex = insertOffset + frame - overlapStart;
+          const insertSample = insertChannel[insertIndex];
+          if (insertSample !== void 0) {
+            channelSamples[frame] = insertSample;
+          }
+        }
+      }
+    }
+    return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+  }
+};
+var _SpliceNode = class _SpliceNode extends TransformNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "splice"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "splice";
+  }
+  createStream() {
+    return new SpliceStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _SpliceNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_SpliceNode.moduleName = "Splice";
+_SpliceNode.moduleDescription = "Replace a region of audio with processed content";
+_SpliceNode.schema = schema12;
+var SpliceNode = _SpliceNode;
+function splice(insertPath, insertAt, options) {
+  return new SpliceNode({ insertPath, insertAt, channels: options?.channels });
+}
+
+// src/transforms/trim/utils/silence.ts
+function findFirstAbove(samples, frames, threshold) {
+  for (let index = 0; index < frames; index++) {
+    for (const channel of samples) {
+      if (Math.abs(channel[index] ?? 0) > threshold) {
+        return index;
+      }
+    }
+  }
+  return frames;
+}
+function findLastAbove(samples, frames, threshold) {
+  for (let index = frames - 1; index >= 0; index--) {
+    for (const channel of samples) {
+      if (Math.abs(channel[index] ?? 0) > threshold) {
+        return index;
+      }
+    }
+  }
+  return 0;
+}
+
+// src/transforms/trim/index.ts
+var schema13 = z.object({
+  threshold: z.number().min(0).max(1).multipleOf(1e-3).default(1e-3).describe("Threshold"),
+  margin: z.number().min(0).max(1).multipleOf(1e-3).default(0.01).describe("Margin"),
+  start: z.boolean().default(true).describe("Start"),
+  end: z.boolean().default(true).describe("End")
+});
+var TrimStream = class extends BufferedTransformStream {
+  async _process(buffer) {
+    const frames = buffer.frames;
+    const allAudio = await buffer.read(0, frames);
+    const channels = allAudio.samples.length;
+    if (channels === 0 || frames === 0) return;
+    const threshold = this.properties.threshold;
+    const marginSeconds = this.properties.margin;
+    const marginFrames = Math.round(marginSeconds * (this.sampleRate ?? 44100));
+    const trimStart = this.properties.start;
+    const trimEnd = this.properties.end;
+    const firstAbove = findFirstAbove(allAudio.samples, frames, threshold);
+    if (firstAbove >= frames) {
+      await buffer.truncate(0);
+      return;
+    }
+    let startFrame = 0;
+    let endFrame = frames;
+    if (trimStart) {
+      startFrame = Math.max(0, firstAbove - marginFrames);
+    }
+    if (trimEnd) {
+      endFrame = findLastAbove(allAudio.samples, frames, threshold) + 1;
+      endFrame = Math.min(frames, endFrame + marginFrames);
+    }
+    if (startFrame >= endFrame) return;
+    if (startFrame === 0 && endFrame === frames) return;
+    const trimmedLength = endFrame - startFrame;
+    const trimmed = [];
+    for (let ch = 0; ch < channels; ch++) {
+      const channel = allAudio.samples[ch];
+      if (!channel) {
+        trimmed.push(new Float32Array(trimmedLength));
+        continue;
+      }
+      trimmed.push(channel.subarray(startFrame, endFrame));
+    }
+    await buffer.truncate(0);
+    await buffer.append(trimmed);
+  }
+};
+var _TrimNode = class _TrimNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "trim"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "trim";
+  }
+  createStream() {
+    return new TrimStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _TrimNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_TrimNode.moduleName = "Trim";
+_TrimNode.moduleDescription = "Remove silence from start and end";
+_TrimNode.schema = schema13;
+var TrimNode = _TrimNode;
+function trim(options) {
+  const parsed = schema13.parse(options ?? {});
+  return new TrimNode({ ...parsed, id: options?.id });
+}
+function runFfmpegWithFile(binaryPath, args, channels) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(binaryPath, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (!proc.stdout || !proc.stderr) {
+      reject(new Error("Failed to create ffmpeg stdio streams"));
+      return;
+    }
+    const outputChunks = [];
+    const stderrChunks = [];
+    proc.stdout.on("data", (chunk) => {
+      outputChunks.push(chunk);
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    proc.on("error", (error) => {
+      reject(new Error(`Failed to spawn ffmpeg: ${error.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        const stderrOutput = Buffer.concat(stderrChunks).toString();
+        reject(new Error(`ffmpeg exited with code ${code}: ${stderrOutput}`));
+        return;
+      }
+      const outputBuffer = Buffer.concat(outputChunks);
+      const samples = deinterleaveBuffer(outputBuffer, channels);
+      resolve(samples);
+    });
+  });
+}
+function runFfmpeg(binaryPath, args, buffer, channels) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(binaryPath, args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (!proc.stdout || !proc.stderr || !proc.stdin) {
+      reject(new Error("Failed to create ffmpeg stdio streams"));
+      return;
+    }
+    const stdout = proc.stdout;
+    const stderr = proc.stderr;
+    const stdin = proc.stdin;
+    const outputChunks = [];
+    const stderrChunks = [];
+    stdout.on("data", (chunk) => {
+      outputChunks.push(chunk);
+    });
+    stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    proc.on("error", (error) => {
+      reject(new Error(`Failed to spawn ffmpeg: ${error.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        const stderrOutput = Buffer.concat(stderrChunks).toString();
+        reject(new Error(`ffmpeg exited with code ${code}: ${stderrOutput}`));
+        return;
+      }
+      const outputBuffer = Buffer.concat(outputChunks);
+      const samples = deinterleaveBuffer(outputBuffer, channels);
+      resolve(samples);
+    });
+    stdin.on("error", () => {
+    });
+    void writeBufferToStdin(proc, stdin, buffer).catch(() => {
+    });
+  });
+}
+async function writeBufferToStdin(proc, stdin, buffer) {
+  const chunkSize = 44100;
+  for await (const chunk of buffer.iterate(chunkSize)) {
+    const interleaved = interleave(chunk.samples, chunk.samples[0]?.length ?? 0, chunk.samples.length);
+    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
+    const canWrite = stdin.write(buf);
+    if (!canWrite) {
+      await waitForDrain(proc, stdin);
+    }
+  }
+  stdin.end();
+}
+
+// src/transforms/ffmpeg/index.ts
+var schema14 = z.object({
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  args: z.array(z.string()).default([])
+});
+var FfmpegStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this._ffmpegChannels = 1;
+  }
+  async _setup(input, context) {
+    this.streamContext = context;
+    return super._setup(input, context);
+  }
+  _buildArgs(_context) {
+    const { args } = this.properties;
+    if (!args) return [];
+    return typeof args === "function" ? args(_context) : args;
+  }
+  _buildOutputArgs(_context) {
+    return ["-f", "f32le", "-ar", String(this.sampleRate ?? 44100), "-ac", String(this.ffmpegChannels), "pipe:1"];
+  }
+  get ffmpegChannels() {
+    return this._ffmpegChannels;
+  }
+  async _process(buffer) {
+    if (!this.streamContext) throw new Error("FfmpegStream._process called before setup()");
+    this._ffmpegChannels = buffer.channels;
+    const sr = this.sampleRate ?? 44100;
+    const channels = buffer.channels;
+    const filterArgs = this._buildArgs(this.streamContext);
+    const outputArgs = this._buildOutputArgs(this.streamContext);
+    const filePath = buffer instanceof FileChunkBuffer ? buffer.filePath : void 0;
+    const inputArgs = ["-f", "f32le", "-ar", String(sr), "-ac", String(channels), "-i", filePath ?? "pipe:0"];
+    const result = filePath ? await runFfmpegWithFile(this.properties.ffmpegPath, [...inputArgs, ...filterArgs, ...outputArgs], channels) : await runFfmpeg(this.properties.ffmpegPath, [...inputArgs, ...filterArgs, ...outputArgs], buffer, channels);
+    await buffer.truncate(0);
+    const frames = result[0]?.length ?? 0;
+    if (frames > 0) {
+      await buffer.append(result);
+    }
+  }
+};
+var _FfmpegNode = class _FfmpegNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "ffmpeg"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "ffmpeg";
+  }
+  createStream() {
+    return new FfmpegStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _FfmpegNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_FfmpegNode.moduleName = "FFmpeg";
+_FfmpegNode.moduleDescription = "Process audio through FFmpeg filters";
+_FfmpegNode.schema = schema14;
+var FfmpegNode = _FfmpegNode;
+function ffmpeg(options) {
+  return new FfmpegNode({
+    ffmpegPath: options.ffmpegPath,
+    args: options.args,
+    id: options.id
+  });
+}
+async function measureLoudness(buffer, sampleRate, channels, properties) {
+  const binaryPath = properties.ffmpegPath;
+  const parts = [`I=${properties.target}`, `TP=${properties.truePeak}`, properties.lra !== void 0 ? `LRA=${properties.lra}` : "", "print_format=json"].filter(Boolean);
+  const args = ["-f", "f32le", "-ar", String(sampleRate), "-ac", String(channels), "-i", "pipe:0", "-af", `loudnorm=${parts.join(":")}`, "-f", "null", "-"];
+  return new Promise((resolve, reject) => {
+    const proc = spawn(binaryPath, args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdin = proc.stdin;
+    const stderrStream = proc.stderr;
+    const stderrChunks = [];
+    stderrStream.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    proc.on("error", (error) => {
+      reject(new Error(`Failed to spawn ffmpeg: ${error.message}`));
+    });
+    proc.on("close", (code) => {
+      const stderr = Buffer.concat(stderrChunks).toString();
+      if (code !== 0) {
+        reject(new Error(`ffmpeg measurement pass exited with code ${code}: ${stderr}`));
+        return;
+      }
+      const jsonMatch = /\{[^}]*"input_i"[^}]*\}/s.exec(stderr);
+      if (!jsonMatch) {
+        reject(new Error("Failed to parse loudnorm measurement output"));
+        return;
+      }
+      const measured = JSON.parse(jsonMatch[0]);
+      resolve({
+        inputI: measured.input_i ?? "0",
+        inputTp: measured.input_tp ?? "0",
+        inputLra: measured.input_lra ?? "0",
+        inputThresh: measured.input_thresh ?? "0",
+        targetOffset: measured.target_offset ?? "0"
+      });
+    });
+    void writeToStdin(stdin, buffer, channels);
+  });
+}
+async function writeToStdin(stdin, buffer, channels) {
+  for await (const chunk of buffer.iterate(44100)) {
+    const interleaved = interleave(chunk.samples, chunk.samples[0]?.length ?? 0, channels);
+    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
+    const canWrite = stdin.write(buf);
+    if (!canWrite) {
+      await new Promise((resolve) => {
+        stdin.once("drain", resolve);
+      });
+    }
+  }
+  stdin.end();
+}
+
+// src/transforms/loudness/index.ts
+var schema15 = z.object({
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  target: z.number().min(-50).max(0).multipleOf(0.1).default(-14).describe("Target"),
+  truePeak: z.number().min(-10).max(0).multipleOf(0.1).default(-1).describe("True Peak"),
+  lra: z.number().min(0).max(20).multipleOf(0.1).default(0).describe("LRA")
+});
+var LoudnessStream = class extends FfmpegStream {
+  _buildArgs(_context) {
+    return this.buildArgsWithMeasurement();
+  }
+  async _process(buffer) {
+    const sr = this.sampleRate ?? 44100;
+    const ch = buffer.channels;
+    this.measuredValues = await measureLoudness(buffer, sr, ch, this.properties);
+    await super._process(buffer);
+    this.measuredValues = void 0;
+  }
+  buildArgsWithMeasurement() {
+    const { target, truePeak, lra } = this.properties;
+    if (this.measuredValues) {
+      const { inputI, inputTp, inputLra, inputThresh, targetOffset } = this.measuredValues;
+      const parts2 = [
+        `I=${target}`,
+        `TP=${truePeak}`,
+        lra !== void 0 ? `LRA=${lra}` : "",
+        `measured_I=${inputI}`,
+        `measured_TP=${inputTp}`,
+        `measured_LRA=${inputLra}`,
+        `measured_thresh=${inputThresh}`,
+        `offset=${targetOffset}`,
+        "linear=true"
+      ].filter(Boolean);
+      return ["-af", `loudnorm=${parts2.join(":")}`];
+    }
+    const parts = [`I=${target}`, `TP=${truePeak}`, lra !== void 0 ? `LRA=${lra}` : ""].filter(Boolean);
+    return ["-af", `loudnorm=${parts.join(":")}`];
+  }
+};
+var _LoudnessNode = class _LoudnessNode extends FfmpegNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "ffmpeg", "loudness"];
+  }
+  static is(value) {
+    return FfmpegNode.is(value) && value.type[3] === "loudness";
+  }
+  createStream() {
+    return new LoudnessStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _LoudnessNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_LoudnessNode.moduleName = "Loudness";
+_LoudnessNode.moduleDescription = "Measure integrated, short-term, and momentary loudness";
+_LoudnessNode.schema = schema15;
+var LoudnessNode = _LoudnessNode;
+function loudness(ffmpegPath, options) {
+  return new LoudnessNode({
+    ffmpegPath,
+    target: options?.target ?? -14,
+    truePeak: options?.truePeak ?? -1,
+    lra: options?.lra,
+    id: options?.id
+  });
+}
+var schema16 = z.object({
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  sampleRate: z.number().min(8e3).max(192e3).multipleOf(100).default(44100).describe("Sample Rate"),
+  dither: z.enum(["triangular", "lipshitz", "none"]).default("triangular").describe("Dither")
+});
+var ResampleStream = class extends FfmpegStream {
+  async _process(buffer) {
+    await super._process(buffer);
+    buffer.setSampleRate(this.properties.sampleRate);
+  }
+  _buildArgs(_context) {
+    const { sampleRate, dither: dither2 } = this.properties;
+    const ditherMethod = dither2 ?? "triangular";
+    return ["-af", `aresample=${sampleRate}:resampler=soxr:dither_method=${ditherMethod}`];
+  }
+  _buildOutputArgs(_context) {
+    return ["-f", "f32le", "-ar", String(this.properties.sampleRate), "-ac", String(this.ffmpegChannels), "pipe:1"];
+  }
+};
+var _ResampleNode = class _ResampleNode extends FfmpegNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "ffmpeg", "resample"];
+  }
+  static is(value) {
+    return FfmpegNode.is(value) && value.type[3] === "resample";
+  }
+  createStream() {
+    return new ResampleStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _ResampleNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_ResampleNode.moduleName = "Resample";
+_ResampleNode.moduleDescription = "Change sample rate";
+_ResampleNode.schema = schema16;
+var ResampleNode = _ResampleNode;
+function resample(ffmpegPath, sampleRate, options) {
+  return new ResampleNode({
+    ffmpegPath,
+    sampleRate,
+    dither: options?.dither,
+    id: options?.id
+  });
+}
+function computeBreathEnvelopes(channel, sampleRate, breathBandLow, breathBandHigh) {
+  const frames = channel.length;
+  const envSmooth = Math.round(sampleRate * 0.01);
+  const wideband = new Float32Array(frames);
+  const breathBand = new Float32Array(frames);
+  for (let index = 0; index < frames; index++) {
+    wideband[index] = (channel[index] ?? 0) ** 2;
+  }
+  const centerFreq = Math.sqrt(breathBandLow * breathBandHigh);
+  const quality = centerFreq / (breathBandHigh - breathBandLow);
+  const { fb, fa } = bandPassCoefficients(sampleRate, centerFreq, quality);
+  const breathBandSignal = biquadFilter(channel, fb, fa);
+  for (let index = 0; index < frames; index++) {
+    breathBand[index] = (breathBandSignal[index] ?? 0) ** 2;
+  }
+  const scratch = new Float32Array(frames);
+  smoothEnvelope(wideband, envSmooth, scratch);
+  smoothEnvelope(breathBand, envSmooth, scratch);
+  for (let index = 0; index < frames; index++) {
+    wideband[index] = Math.sqrt(wideband[index] ?? 0);
+    breathBand[index] = Math.sqrt(breathBand[index] ?? 0);
+  }
+  return { wideband, breathBand };
+}
+function expandBreathRegions(regions, widebandEnvelope, speechThreshold) {
+  const frames = widebandEnvelope.length;
+  const noiseFloor = speechThreshold * 0.3;
+  for (const region of regions) {
+    while (region.start > 0 && (widebandEnvelope[region.start - 1] ?? 0) < speechThreshold) {
+      region.start--;
+    }
+    while (region.end < frames && (widebandEnvelope[region.end] ?? 0) < speechThreshold) {
+      region.end++;
+    }
+    while (region.start < region.end && (widebandEnvelope[region.start] ?? 0) < noiseFloor) {
+      region.start++;
+    }
+    while (region.end > region.start && (widebandEnvelope[region.end - 1] ?? 0) < noiseFloor) {
+      region.end--;
+    }
+  }
+}
+function buildGainEnvelope(regions, length, fadeInSamples, fadeOutSamples, targetGain) {
+  const envelope = new Float32Array(length);
+  envelope.fill(1);
+  for (const region of regions) {
+    for (let index = region.start; index < region.end; index++) {
+      envelope[index] = targetGain;
+    }
+    for (let index = 0; index < fadeInSamples; index++) {
+      const pos = region.start - fadeInSamples + index;
+      if (pos >= 0 && pos < length) {
+        const fade = (index + 1) / (fadeInSamples + 1);
+        envelope[pos] = 1 + (targetGain - 1) * fade;
+      }
+    }
+    for (let index = 0; index < fadeOutSamples; index++) {
+      const pos = region.end + index;
+      if (pos >= 0 && pos < length) {
+        const fade = 1 - (index + 1) / (fadeOutSamples + 1);
+        envelope[pos] = 1 + (targetGain - 1) * fade;
+      }
+    }
+  }
+  return envelope;
+}
+
+// src/transforms/breath-control/utils/regions.ts
+function findRegions(mask, minDuration, length) {
+  const regions = [];
+  let regionStart = -1;
+  for (let index = 0; index <= length; index++) {
+    const active = index < length && (mask[index] ?? 0) > 0;
+    if (active && regionStart === -1) {
+      regionStart = index;
+    } else if (!active && regionStart !== -1) {
+      if (index - regionStart >= minDuration) {
+        regions.push({ start: regionStart, end: index });
+      }
+      regionStart = -1;
+    }
+  }
+  return regions;
+}
+
+// src/transforms/breath-control/index.ts
+var schema17 = z.object({
+  sensitivity: z.number().min(0).max(1).multipleOf(0.01).default(0.5).describe("Sensitivity"),
+  reduction: z.number().min(-60).max(0).multipleOf(1).default(-12).describe("Reduction"),
+  mode: z.enum(["remove", "attenuate"]).default("attenuate").describe("Mode")
+});
+var BreathControlStream = class extends BufferedTransformStream {
+  async _process(buffer) {
+    const frames = buffer.frames;
+    const channels = buffer.channels;
+    const sampleRate = this.sampleRate ?? 44100;
+    const { sensitivity, reduction, mode } = this.properties;
+    const gainDb = mode === "remove" ? -96 : reduction;
+    const gainLinear = Math.pow(10, gainDb / 20);
+    const allAudio = await buffer.read(0, frames);
+    const channel = allAudio.samples[0];
+    if (!channel) return;
+    const { wideband, breathBand } = computeBreathEnvelopes(channel, sampleRate, 1e3, 6e3);
+    const speechThreshold = 0.015 * (1 - sensitivity * 0.5);
+    const breathThreshold = 2e-3 * sensitivity;
+    const isBreath = new Uint8Array(frames);
+    for (let index = 0; index < frames; index++) {
+      const isSpeechGap = (wideband[index] ?? 0) < speechThreshold;
+      const isBreathy = (breathBand[index] ?? 0) > breathThreshold;
+      isBreath[index] = isSpeechGap && isBreathy ? 1 : 0;
+    }
+    const minBreathDuration = Math.round(sampleRate * 0.08);
+    const regions = findRegions(isBreath, minBreathDuration, frames);
+    expandBreathRegions(regions, wideband, speechThreshold);
+    const fadeLength = Math.round(sampleRate * 0.015);
+    const gainEnvelope = buildGainEnvelope(regions, frames, fadeLength, fadeLength, gainLinear);
+    for (let ch = 0; ch < channels; ch++) {
+      const chData = allAudio.samples[ch];
+      if (!chData) continue;
+      for (let index = 0; index < frames; index++) {
+        chData[index] = (chData[index] ?? 0) * (gainEnvelope[index] ?? 1);
+      }
+    }
+    await buffer.truncate(0);
+    await buffer.append(allAudio.samples);
+  }
+};
+var _BreathControlNode = class _BreathControlNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "breath-control"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "breath-control";
+  }
+  createStream() {
+    return new BreathControlStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _BreathControlNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_BreathControlNode.moduleName = "Breath Control";
+_BreathControlNode.moduleDescription = "Attenuate or remove breath sounds between phrases";
+_BreathControlNode.schema = schema17;
+var BreathControlNode = _BreathControlNode;
+function breathControl(options) {
+  return new BreathControlNode({
+    sensitivity: options?.sensitivity ?? 0.5,
+    reduction: options?.reduction ?? -12,
+    mode: options?.mode ?? "attenuate",
+    id: options?.id
+  });
+}
+
+// src/transforms/de-bleed/utils/nlms.ts
+function nlmsAdaptiveFilter(signal, reference, filterLength, stepSize, output) {
+  const frames = signal.length;
+  const coeffs = new Float32Array(filterLength);
+  let refPower = 0;
+  for (let index = 0; index < frames; index++) {
+    const newRef = index < reference.length ? reference[index] : 0;
+    refPower += newRef * newRef;
+    const droppedIndex = index - filterLength;
+    if (droppedIndex >= 0 && droppedIndex < reference.length) {
+      refPower -= reference[droppedIndex] * reference[droppedIndex];
+    }
+    if (refPower < 0) refPower = 0;
+    let predicted = 0;
+    for (let tap = 0; tap < filterLength; tap++) {
+      const refIndex = index - tap;
+      if (refIndex >= 0 && refIndex < reference.length) {
+        predicted += coeffs[tap] * reference[refIndex];
+      }
+    }
+    const error = signal[index] - predicted;
+    output[index] = error;
+    const mu = refPower > 1e-10 ? stepSize / (refPower + 1e-10) : 0;
+    for (let tap = 0; tap < filterLength; tap++) {
+      const refIndex = index - tap;
+      if (refIndex >= 0 && refIndex < reference.length) {
+        coeffs[tap] = coeffs[tap] + mu * error * reference[refIndex];
+      }
+    }
+  }
+}
+
+// src/transforms/de-bleed/index.ts
+var schema18 = z.object({
+  referencePath: z.string().default("").describe("Reference Path"),
+  filterLength: z.number().min(64).max(8192).multipleOf(64).default(1024).describe("Filter Length"),
+  stepSize: z.number().min(1e-3).max(1).multipleOf(1e-3).default(0.1).describe("Step Size")
+});
+var DeBleedStream = class extends BufferedTransformStream {
+  async _setup(input, context) {
+    const { buffer: refBuffer } = await readToBuffer(this.properties.referencePath);
+    const chunk = await refBuffer.read(0, refBuffer.frames);
+    const channel = chunk.samples[0];
+    this.referenceSignal = channel ? Float32Array.from(channel) : new Float32Array(0);
+    await refBuffer.close();
+    return super._setup(input, context);
+  }
+  async _process(buffer) {
+    const frames = buffer.frames;
+    const channels = buffer.channels;
+    const { filterLength, stepSize } = this.properties;
+    const reference = this.referenceSignal;
+    const output = new Float32Array(frames);
+    for (let ch = 0; ch < channels; ch++) {
+      const chunk = await buffer.read(0, frames);
+      const channel = chunk.samples[ch];
+      if (!channel) continue;
+      output.fill(0);
+      nlmsAdaptiveFilter(channel, reference, filterLength, stepSize, output);
+      await buffer.write(0, replaceChannel(chunk, ch, output, channels));
+    }
+  }
+};
+var _DeBleedNode = class _DeBleedNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "de-bleed"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "de-bleed";
+  }
+  createStream() {
+    return new DeBleedStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _DeBleedNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DeBleedNode.moduleName = "De-Bleed";
+_DeBleedNode.moduleDescription = "Reduce microphone bleed between channels";
+_DeBleedNode.schema = schema18;
+var DeBleedNode = _DeBleedNode;
+function deBleed(referencePath, options) {
+  return new DeBleedNode({
+    referencePath,
+    filterLength: options?.filterLength ?? 1024,
+    stepSize: options?.stepSize ?? 0.1,
+    id: options?.id
+  });
+}
+function detectClickMask(signal, sampleRate, sensitivity, maxClickDuration) {
+  const mask = new Uint8Array(signal.length);
+  const hpCutoff = 4e3;
+  const rc = 1 / (2 * Math.PI * hpCutoff);
+  const dt = 1 / sampleRate;
+  const alpha = rc / (rc + dt);
+  const highPassed = new Float32Array(signal.length);
+  let prevSample = 0;
+  let prevHP = 0;
+  for (let index = 0; index < signal.length; index++) {
+    const sample = signal[index] ?? 0;
+    highPassed[index] = alpha * (prevHP + sample - prevSample);
+    prevSample = sample;
+    prevHP = highPassed[index] ?? 0;
+  }
+  const envSmooth = Math.round(sampleRate * 5e-4);
+  const envelope = new Float32Array(signal.length);
+  for (let index = 0; index < signal.length; index++) {
+    envelope[index] = (highPassed[index] ?? 0) * (highPassed[index] ?? 0);
+  }
+  smoothEnvelope(envelope, envSmooth);
+  for (let index = 0; index < signal.length; index++) {
+    envelope[index] = Math.sqrt(envelope[index] ?? 0);
+  }
+  const median = approximateMedian(envelope);
+  const threshold = median * (5 + 20 * (1 - sensitivity));
+  for (let index = 0; index < signal.length; index++) {
+    if ((envelope[index] ?? 0) > threshold) {
+      mask[index] = 1;
+    }
+  }
+  let regionStart = -1;
+  for (let index = 0; index <= signal.length; index++) {
+    const active = index < signal.length && (mask[index] ?? 0) > 0;
+    if (active && regionStart === -1) {
+      regionStart = index;
+    } else if (!active && regionStart !== -1) {
+      if (index - regionStart > maxClickDuration) {
+        for (let clear = regionStart; clear < index; clear++) {
+          mask[clear] = 0;
+        }
+      }
+      regionStart = -1;
+    }
+  }
+  return mask;
+}
+function buildBlendEnvelope(mask, length, fadeSamples) {
+  const envelope = new Float32Array(length);
+  for (let index = 0; index < length; index++) {
+    if ((mask[index] ?? 0) > 0) {
+      envelope[index] = 1;
+    }
+  }
+  for (let index = 0; index < length; index++) {
+    if ((mask[index] ?? 0) === 0) continue;
+    const start = index;
+    let end = index;
+    while (end < length && (mask[end] ?? 0) > 0) {
+      end++;
+    }
+    for (let fade = 0; fade < fadeSamples; fade++) {
+      const pos = start - fadeSamples + fade;
+      if (pos >= 0 && (envelope[pos] ?? 0) < 1) {
+        const fadeIn = (fade + 1) / (fadeSamples + 1);
+        envelope[pos] = Math.max(envelope[pos] ?? 0, fadeIn);
+      }
+    }
+    for (let fade = 0; fade < fadeSamples; fade++) {
+      const pos = end + fade;
+      if (pos < length && (envelope[pos] ?? 0) < 1) {
+        const fadeOut = 1 - (fade + 1) / (fadeSamples + 1);
+        envelope[pos] = Math.max(envelope[pos] ?? 0, fadeOut);
+      }
+    }
+    index = end - 1;
+  }
+  return envelope;
+}
+function approximateMedian(values) {
+  const len = values.length;
+  if (len === 0) return 0;
+  let min = values[0] ?? 0;
+  let max = values[0] ?? 0;
+  for (let si = 1; si < len; si++) {
+    const sample = values[si] ?? 0;
+    if (sample < min) min = sample;
+    if (sample > max) max = sample;
+  }
+  if (min === max) return min;
+  const numBins = 1024;
+  const bins = new Uint32Array(numBins);
+  const scale = (numBins - 1) / (max - min);
+  for (let si = 0; si < len; si++) {
+    const bin = Math.floor(((values[si] ?? 0) - min) * scale);
+    bins[bin] = (bins[bin] ?? 0) + 1;
+  }
+  const target = len >>> 1;
+  let count = 0;
+  for (let bi = 0; bi < numBins; bi++) {
+    count += bins[bi] ?? 0;
+    if (count > target) {
+      return min + (bi + 0.5) / scale;
+    }
+  }
+  return max;
+}
+
+// src/transforms/de-click/index.ts
+var schema19 = z.object({
+  sensitivity: z.number().min(0).max(1).multipleOf(0.01).default(0.5).describe("Sensitivity"),
+  maxClickDuration: z.number().min(1).max(1e3).multipleOf(1).default(200).describe("Max Click Duration")
+});
+var DeClickStream = class extends BufferedTransformStream {
+  async _process(buffer) {
+    const frames = buffer.frames;
+    const channels = buffer.channels;
+    const sampleRate = this.sampleRate ?? 44100;
+    const { sensitivity, maxClickDuration } = this.properties;
+    const allAudio = await buffer.read(0, frames);
+    const refChannel = allAudio.samples[0];
+    if (!refChannel) return;
+    const clickMask = detectClickMask(refChannel, sampleRate, sensitivity, maxClickDuration);
+    const fadeSamples = Math.round(sampleRate * 1e-3);
+    const blendEnv = buildBlendEnvelope(clickMask, frames, fadeSamples);
+    let hasClicks = false;
+    for (let index = 0; index < frames; index++) {
+      if ((blendEnv[index] ?? 0) > 0) {
+        hasClicks = true;
+        break;
+      }
+    }
+    if (!hasClicks) return;
+    const lpfCutoff = 2500;
+    const lpfCoeffs = lowPassCoefficients(sampleRate, lpfCutoff);
+    for (let ch = 0; ch < channels; ch++) {
+      const channel = allAudio.samples[ch];
+      if (!channel) continue;
+      const filtered = Float32Array.from(channel);
+      zeroPhaseBiquadFilter(filtered, lpfCoeffs);
+      for (let index = 0; index < frames; index++) {
+        const blend = blendEnv[index] ?? 0;
+        if (blend > 0) {
+          channel[index] = (channel[index] ?? 0) * (1 - blend) + (filtered[index] ?? 0) * blend;
+        }
+      }
+    }
+    await buffer.truncate(0);
+    await buffer.append(allAudio.samples);
+  }
+};
+var _DeClickNode = class _DeClickNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties, ...schema19.encode(properties) });
+    this.type = ["buffered-audio-node", "transform", "de-click"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "de-click";
+  }
+  createStream() {
+    return new DeClickStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _DeClickNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DeClickNode.moduleName = "De-Click";
+_DeClickNode.moduleDescription = "Remove clicks, pops, and impulse artifacts";
+_DeClickNode.schema = schema19;
+var DeClickNode = _DeClickNode;
+function deClick(options) {
+  const parsed = schema19.parse(options ?? {});
+  return new DeClickNode({ ...parsed, id: options?.id });
+}
+var schema20 = z.object({
+  sensitivity: z.number().min(0).max(1).multipleOf(0.01).default(0.5).describe("Sensitivity"),
+  maxClickDuration: z.number().min(1).max(1e3).multipleOf(1).default(20).describe("Max Click Duration")
+});
+var _DeCrackleNode = class _DeCrackleNode extends DeClickNode {
+  constructor(properties) {
+    super({ ...properties, ...schema20.encode(properties) });
+    this.type = ["buffered-audio-node", "transform", "de-click", "de-crackle"];
+  }
+  static is(value) {
+    return DeClickNode.is(value) && value.type[3] === "de-crackle";
+  }
+  clone(overrides) {
+    return new _DeCrackleNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DeCrackleNode.moduleName = "De-Crackle";
+_DeCrackleNode.schema = schema20;
+var DeCrackleNode = _DeCrackleNode;
+function deCrackle(options) {
+  const parsed = schema20.parse(options ?? {});
+  return new DeCrackleNode({ ...parsed, id: options?.id });
+}
+var mouthDeClickSchema = z.object({
+  sensitivity: z.number().min(0).max(1).multipleOf(0.01).default(0.7).describe("Sensitivity"),
+  maxClickDuration: z.number().min(1).max(1e3).multipleOf(1).default(50).describe("Max Click Duration")
+});
+var _MouthDeClickNode = class _MouthDeClickNode extends DeClickNode {
+  constructor(properties) {
+    super({ ...properties, ...mouthDeClickSchema.encode(properties) });
+    this.type = ["buffered-audio-node", "transform", "de-click", "mouth-de-click"];
+  }
+  static is(value) {
+    return DeClickNode.is(value) && value.type[3] === "mouth-de-click";
+  }
+  clone(overrides) {
+    return new _MouthDeClickNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_MouthDeClickNode.moduleName = "Mouth De-Click";
+_MouthDeClickNode.schema = mouthDeClickSchema;
+var MouthDeClickNode = _MouthDeClickNode;
+function mouthDeClick(options) {
+  const parsed = mouthDeClickSchema.parse(options ?? {});
+  return new MouthDeClickNode({ ...parsed, id: options?.id });
+}
+
+// src/transforms/de-clip/utils/clip-detection.ts
+function detectClippedRegions(signal, threshold) {
+  const regions = [];
+  let regionStart = -1;
+  for (let index = 0; index < signal.length; index++) {
+    const isClipped = Math.abs(signal[index] ?? 0) >= threshold;
+    if (isClipped && regionStart === -1) {
+      regionStart = index;
+    } else if (!isClipped && regionStart !== -1) {
+      regions.push({ start: regionStart, end: index });
+      regionStart = -1;
+    }
+  }
+  if (regionStart !== -1) {
+    regions.push({ start: regionStart, end: signal.length });
+  }
+  return regions;
+}
+function reconstructClippedRegion(signal, start, end, threshold) {
+  const arOrder = 16;
+  const contextBefore = Math.max(0, start - arOrder * 4);
+  const contextAfter = Math.min(signal.length, end + arOrder * 4);
+  const contextSignal = signal.slice(contextBefore, contextAfter);
+  const arCoeffs = fitArModelForDeclip(contextSignal, arOrder);
+  const iterations = 5;
+  const localStart = start - contextBefore;
+  const localEnd = end - contextBefore;
+  for (let iter = 0; iter < iterations; iter++) {
+    for (let index = localStart; index < localEnd; index++) {
+      let predicted = 0;
+      for (let coeff = 0; coeff < arOrder; coeff++) {
+        const sampleIdx = index - 1 - coeff;
+        if (sampleIdx >= 0) {
+          predicted += (arCoeffs[coeff] ?? 0) * (contextSignal[sampleIdx] ?? 0);
+        }
+      }
+      const sign = (contextSignal[index] ?? 0) >= 0 ? 1 : -1;
+      const constrained = Math.abs(predicted) >= threshold ? predicted : sign * threshold;
+      contextSignal[index] = constrained;
+    }
+  }
+  for (let index = localStart; index < localEnd; index++) {
+    signal[contextBefore + index] = contextSignal[index] ?? 0;
+  }
+}
+function fitArModelForDeclip(signal, order) {
+  const autocorr = new Float32Array(order + 1);
+  for (let lag = 0; lag <= order; lag++) {
+    let sum = 0;
+    for (let index = lag; index < signal.length; index++) {
+      sum += (signal[index] ?? 0) * (signal[index - lag] ?? 0);
+    }
+    autocorr[lag] = sum / signal.length;
+  }
+  return levinsonDurbin(autocorr, order);
+}
+function levinsonDurbin(autocorr, order) {
+  const coeffs = new Float32Array(order);
+  const prev = new Float32Array(order);
+  const r0 = autocorr[0] ?? 1;
+  if (r0 === 0) return coeffs;
+  const firstCoeff = (autocorr[1] ?? 0) / r0;
+  coeffs[0] = firstCoeff;
+  let error = r0 * (1 - firstCoeff * firstCoeff);
+  for (let step = 1; step < order; step++) {
+    let lambda = 0;
+    for (let index = 0; index < step; index++) {
+      lambda += (coeffs[index] ?? 0) * (autocorr[step - index] ?? 0);
+    }
+    lambda = ((autocorr[step + 1] ?? 0) - lambda) / Math.max(error, 1e-10);
+    prev.set(coeffs);
+    for (let index = 0; index < step; index++) {
+      coeffs[index] = (prev[index] ?? 0) - lambda * (prev[step - 1 - index] ?? 0);
+    }
+    coeffs[step] = lambda;
+    error *= 1 - lambda * lambda;
+    if (error <= 0) break;
+  }
+  return coeffs;
+}
+
+// src/transforms/de-clip/index.ts
+var schema21 = z.object({
+  threshold: z.number().min(0).max(1).multipleOf(0.01).default(0.99).describe("Threshold"),
+  method: z.enum(["ar", "sparse"]).default("ar").describe("Method")
+});
+var DeClipStream = class extends BufferedTransformStream {
+  _buffer(chunk, buffer) {
+    if (this.bufferSize === 0) {
+      this.bufferSize = Math.round(chunk.sampleRate * 0.05);
+    }
+    return super._buffer(chunk, buffer);
+  }
+  async _process(buffer) {
+    for await (const chunk of buffer.iterate(this.bufferSize)) {
+      const samples = chunk.samples.map((channel) => {
+        const output = new Float32Array(channel);
+        const regions = detectClippedRegions(channel, this.properties.threshold);
+        for (const region of regions) {
+          reconstructClippedRegion(output, region.start, region.end, this.properties.threshold);
+        }
+        return output;
+      });
+      await buffer.write(chunk.offset, samples);
+    }
+  }
+};
+var _DeClipNode = class _DeClipNode extends TransformNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "de-clip"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "de-clip";
+  }
+  createStream() {
+    return new DeClipStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _DeClipNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DeClipNode.moduleName = "De-Clip";
+_DeClipNode.moduleDescription = "Restore clipped audio peaks";
+_DeClipNode.schema = schema21;
+var DeClipNode = _DeClipNode;
+function deClip(options) {
+  const parsed = schema21.parse(options ?? {});
+  return new DeClipNode({ ...parsed, id: options?.id });
+}
+
+// src/transforms/de-plosive/utils/plosive.ts
+function detectPlosive(channel, cutoffCoeff, threshold, initialLpState) {
+  let lpVal = initialLpState;
+  let lowEnergy = 0;
+  let totalEnergy = 0;
+  for (const sample of channel) {
+    lpVal = lpVal * cutoffCoeff + sample * (1 - cutoffCoeff);
+    lowEnergy += lpVal * lpVal;
+    totalEnergy += sample * sample;
+  }
+  const lowRatio = totalEnergy > 0 ? lowEnergy / totalEnergy : 0;
+  const isPlosive = lowRatio > 0.5 && Math.sqrt(lowEnergy / channel.length) > threshold;
+  return { isPlosive, lpState: lpVal };
+}
+function removePlosive(channel, cutoffCoeff, initialLpState, fadeLength) {
+  const output = new Float32Array(channel.length);
+  let lpVal = initialLpState;
+  for (let index = 0; index < channel.length; index++) {
+    const sample = channel[index] ?? 0;
+    lpVal = lpVal * cutoffCoeff + sample * (1 - cutoffCoeff);
+    const filtered = sample - lpVal * 0.8;
+    let fade = 1;
+    if (index < fadeLength) {
+      fade = index / fadeLength;
+    } else if (index > channel.length - fadeLength) {
+      fade = (channel.length - index) / fadeLength;
+    }
+    output[index] = sample * (1 - fade) + filtered * fade;
+  }
+  return output;
+}
+
+// src/transforms/de-plosive/index.ts
+var schema22 = z.object({
+  sensitivity: z.number().min(0).max(1).multipleOf(0.01).default(0.5).describe("Sensitivity"),
+  frequency: z.number().min(50).max(500).multipleOf(10).default(200).describe("Frequency")
+});
+var DePlosiveStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this.lpState = [];
+  }
+  _buffer(chunk, buffer) {
+    if (this.bufferSize === 0) {
+      const blockSize = Math.round(chunk.sampleRate * 0.02);
+      this.bufferSize = blockSize;
+      this.streamChunkSize = blockSize;
+    }
+    return super._buffer(chunk, buffer);
+  }
+  _unbuffer(chunk) {
+    const { sensitivity, frequency } = this.properties;
+    const cutoffCoeff = Math.exp(-2 * Math.PI * frequency / chunk.sampleRate);
+    const threshold = 0.1 * (1 - sensitivity);
+    while (this.lpState.length < chunk.samples.length) {
+      this.lpState.push(0);
+    }
+    const samples = chunk.samples.map((channel, ch) => {
+      const detection = detectPlosive(channel, cutoffCoeff, threshold, this.lpState[ch] ?? 0);
+      this.lpState[ch] = detection.lpState;
+      if (detection.isPlosive) {
+        const fadeLength = Math.min(channel.length, Math.round(chunk.sampleRate * 5e-3));
+        return removePlosive(channel, cutoffCoeff, detection.lpState, fadeLength);
+      }
+      return Float32Array.from(channel);
+    });
+    return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+  }
+};
+var _DePlosiveNode = class _DePlosiveNode extends TransformNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "de-plosive"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "de-plosive";
+  }
+  createStream() {
+    return new DePlosiveStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _DePlosiveNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DePlosiveNode.moduleName = "De-Plosive";
+_DePlosiveNode.moduleDescription = "Reduce plosive bursts (p, b, t, d sounds)";
+_DePlosiveNode.schema = schema22;
+var DePlosiveNode = _DePlosiveNode;
+function dePlosive(options) {
+  return new DePlosiveNode({
+    sensitivity: options?.sensitivity ?? 0.5,
+    frequency: options?.frequency ?? 200,
+    id: options?.id
+  });
+}
+
+// src/transforms/de-reverb/utils/transpose.ts
+function transposeToBinMajor(stftReal, stftImag, numFrames, numBins, realT, imagT) {
+  for (let frame = 0; frame < numFrames; frame++) {
+    const re = stftReal[frame];
+    const im = stftImag[frame];
+    if (!re || !im) continue;
+    for (let bin = 0; bin < numBins; bin++) {
+      realT[bin * numFrames + frame] = re[bin];
+      imagT[bin * numFrames + frame] = im[bin];
+    }
+  }
+}
+function transposeToFrameMajor(realT, imagT, stftReal, stftImag, numFrames, numBins) {
+  for (let frame = 0; frame < numFrames; frame++) {
+    const re = stftReal[frame];
+    const im = stftImag[frame];
+    if (!re || !im) continue;
+    for (let bin = 0; bin < numBins; bin++) {
+      re[bin] = realT[bin * numFrames + frame];
+      im[bin] = imagT[bin * numFrames + frame];
+    }
+  }
+}
+
+// src/transforms/de-reverb/utils/wpe.ts
+function computeBinPowerAndEnergy(realT, imagT, numBins, numFrames, powerT, binEnergy) {
+  const usedSize = numBins * numFrames;
+  for (let pos = 0; pos < usedSize; pos++) {
+    powerT[pos] = Math.max(realT[pos] * realT[pos] + imagT[pos] * imagT[pos], 1e-10);
+  }
+  for (let bin = 0; bin < numBins; bin++) {
+    const offset = bin * numFrames;
+    let energy = 0;
+    for (let frame = 0; frame < numFrames; frame++) {
+      energy += powerT[offset + frame];
+    }
+    binEnergy[bin] = energy;
+  }
+}
+function applyWpePrediction(realT, imagT, originalPowerT, binOffset, numFrames, predictionDelay, filterLen, filterReal, filterImag) {
+  for (let frame = predictionDelay + filterLen; frame < numFrames; frame++) {
+    let predR = 0;
+    let predI = 0;
+    for (let tap = 0; tap < filterLen; tap++) {
+      const pastOffset = binOffset + frame - predictionDelay - tap - 1;
+      const pR = realT[pastOffset];
+      const pI = imagT[pastOffset];
+      predR += filterReal[tap] * pR - filterImag[tap] * pI;
+      predI += filterReal[tap] * pI + filterImag[tap] * pR;
+    }
+    const pos = binOffset + frame;
+    const newR = realT[pos] - predR;
+    const newI = imagT[pos] - predI;
+    const newPow = newR * newR + newI * newI;
+    const origPow = originalPowerT[pos];
+    if (newPow > origPow) {
+      const scale = Math.sqrt(origPow / newPow);
+      realT[pos] = newR * scale;
+      imagT[pos] = newI * scale;
+    } else {
+      realT[pos] = newR;
+      imagT[pos] = newI;
+    }
+  }
+}
+function solveWpeFilter(realT, imagT, powerT, binOffset, numFrames, predictionDelay, filterLength, outReal, outImag, corrReal, corrImag, crossReal, crossImag, arWork, aiWork, brWork, biWork) {
+  corrReal.fill(0);
+  corrImag.fill(0);
+  crossReal.fill(0);
+  crossImag.fill(0);
+  const filterLen = filterLength;
+  const delay = predictionDelay;
+  for (let frame = delay + filterLen; frame < numFrames; frame++) {
+    const weight = 1 / powerT[binOffset + frame];
+    const targetR = realT[binOffset + frame];
+    const targetI = imagT[binOffset + frame];
+    for (let tap1 = 0; tap1 < filterLen; tap1++) {
+      const pastIdx1 = binOffset + frame - delay - tap1 - 1;
+      const pR1 = realT[pastIdx1];
+      const pI1 = imagT[pastIdx1];
+      crossReal[tap1] = (crossReal[tap1] ?? 0) + weight * (pR1 * targetR + pI1 * targetI);
+      crossImag[tap1] = (crossImag[tap1] ?? 0) + weight * (pR1 * targetI - pI1 * targetR);
+      for (let tap2 = tap1; tap2 < filterLen; tap2++) {
+        const pastIdx2 = binOffset + frame - delay - tap2 - 1;
+        const pR2 = realT[pastIdx2];
+        const pI2 = imagT[pastIdx2];
+        corrReal[tap1 * filterLen + tap2] = (corrReal[tap1 * filterLen + tap2] ?? 0) + weight * (pR1 * pR2 + pI1 * pI2);
+        corrImag[tap1 * filterLen + tap2] = (corrImag[tap1 * filterLen + tap2] ?? 0) + weight * (pR1 * pI2 - pI1 * pR2);
+      }
+    }
+  }
+  for (let tap1 = 1; tap1 < filterLen; tap1++) {
+    for (let tap2 = 0; tap2 < tap1; tap2++) {
+      corrReal[tap1 * filterLen + tap2] = corrReal[tap2 * filterLen + tap1];
+      corrImag[tap1 * filterLen + tap2] = -corrImag[tap2 * filterLen + tap1];
+    }
+  }
+  for (let tap = 0; tap < filterLen; tap++) {
+    corrReal[tap * filterLen + tap] = (corrReal[tap * filterLen + tap] ?? 0) + 1e-6;
+  }
+  solveLinearSystem(corrReal, corrImag, crossReal, crossImag, filterLen, outReal, outImag, arWork, aiWork, brWork, biWork);
+}
+function solveLinearSystem(aReal, aImag, bReal, bImag, size, outReal, outImag, ar, ai, br, bi) {
+  ar.set(aReal);
+  ai.set(aImag);
+  br.set(bReal);
+  bi.set(bImag);
+  for (let col = 0; col < size; col++) {
+    let maxMag = 0;
+    let maxRow = col;
+    for (let row = col; row < size; row++) {
+      const re = ar[row * size + col] ?? 0;
+      const im = ai[row * size + col] ?? 0;
+      const mag = re * re + im * im;
+      if (mag > maxMag) {
+        maxMag = mag;
+        maxRow = row;
+      }
+    }
+    if (maxMag < 1e-20) continue;
+    if (maxRow !== col) {
+      for (let sc = col; sc < size; sc++) {
+        const tmpR = ar[col * size + sc] ?? 0;
+        const tmpI = ai[col * size + sc] ?? 0;
+        ar[col * size + sc] = ar[maxRow * size + sc] ?? 0;
+        ai[col * size + sc] = ai[maxRow * size + sc] ?? 0;
+        ar[maxRow * size + sc] = tmpR;
+        ai[maxRow * size + sc] = tmpI;
+      }
+      const tmpBr = br[col] ?? 0;
+      const tmpBi = bi[col] ?? 0;
+      br[col] = br[maxRow] ?? 0;
+      bi[col] = bi[maxRow] ?? 0;
+      br[maxRow] = tmpBr;
+      bi[maxRow] = tmpBi;
+    }
+    const pivR = ar[col * size + col] ?? 0;
+    const pivI = ai[col * size + col] ?? 0;
+    const pivMag2 = pivR * pivR + pivI * pivI;
+    for (let row = col + 1; row < size; row++) {
+      const elemR = ar[row * size + col] ?? 0;
+      const elemI = ai[row * size + col] ?? 0;
+      const factR = (elemR * pivR + elemI * pivI) / pivMag2;
+      const factI = (elemI * pivR - elemR * pivI) / pivMag2;
+      for (let ec = col + 1; ec < size; ec++) {
+        const ajR = ar[col * size + ec] ?? 0;
+        const ajI = ai[col * size + ec] ?? 0;
+        ar[row * size + ec] = (ar[row * size + ec] ?? 0) - (factR * ajR - factI * ajI);
+        ai[row * size + ec] = (ai[row * size + ec] ?? 0) - (factR * ajI + factI * ajR);
+      }
+      br[row] = (br[row] ?? 0) - (factR * (br[col] ?? 0) - factI * (bi[col] ?? 0));
+      bi[row] = (bi[row] ?? 0) - (factR * (bi[col] ?? 0) + factI * (br[col] ?? 0));
+      ar[row * size + col] = 0;
+      ai[row * size + col] = 0;
+    }
+  }
+  for (let row = size - 1; row >= 0; row--) {
+    let sumR = br[row] ?? 0;
+    let sumI = bi[row] ?? 0;
+    for (let bc = row + 1; bc < size; bc++) {
+      const ajR = ar[row * size + bc] ?? 0;
+      const ajI = ai[row * size + bc] ?? 0;
+      const xjR = outReal[bc] ?? 0;
+      const xjI = outImag[bc] ?? 0;
+      sumR -= ajR * xjR - ajI * xjI;
+      sumI -= ajR * xjI + ajI * xjR;
+    }
+    const diagR = ar[row * size + row] ?? 0;
+    const diagI = ai[row * size + row] ?? 0;
+    const diagMag2 = diagR * diagR + diagI * diagI;
+    if (diagMag2 > 1e-20) {
+      outReal[row] = (sumR * diagR + sumI * diagI) / diagMag2;
+      outImag[row] = (sumI * diagR - sumR * diagI) / diagMag2;
+    }
+  }
+}
+
+// src/transforms/de-reverb/index.ts
+var schema23 = z.object({
+  predictionDelay: z.number().min(1).max(10).multipleOf(1).default(4).describe("Prediction Delay"),
+  filterLength: z.number().min(5).max(30).multipleOf(1).default(12).describe("Filter Length"),
+  iterations: z.number().min(1).max(10).multipleOf(1).default(4).describe("Iterations"),
+  vkfftAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "vkfft-addon", download: "https://github.com/visionsofparadise/vkfft-addon" }).describe("VkFFT native addon \u2014 GPU FFT acceleration"),
+  fftwAddonPath: z.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 DeReverbStream = class extends BufferedTransformStream {
+  async _setup(input, context) {
+    const fft2 = initFftBackend(context.executionProviders, this.properties);
+    this.fftBackend = fft2.backend;
+    this.fftAddonOptions = fft2.addonOptions;
+    return super._setup(input, context);
+  }
+  async _process(buffer) {
+    const { frames, channels } = buffer;
+    const fftSize = 1024;
+    const hopSize = fftSize / 4;
+    const numBins = fftSize / 2 + 1;
+    const paddedLength = Math.max(frames, fftSize);
+    const numStftFrames = Math.floor((paddedLength - fftSize) / hopSize) + 1;
+    const stftOutput = {
+      real: Array.from({ length: numStftFrames }, () => new Float32Array(numBins)),
+      imag: Array.from({ length: numStftFrames }, () => new Float32Array(numBins))
+    };
+    const chunk = await buffer.read(0, frames);
+    const flatSize = numBins * numStftFrames;
+    const realT = new Float32Array(flatSize);
+    const imagT = new Float32Array(flatSize);
+    const originalPowerT = new Float32Array(flatSize);
+    const iterPowerT = new Float32Array(flatSize);
+    const binEnergy = new Float32Array(numBins);
+    const { predictionDelay, filterLength, iterations } = this.properties;
+    const filterLen = filterLength;
+    const corrReal = new Float32Array(filterLen * filterLen);
+    const corrImag = new Float32Array(filterLen * filterLen);
+    const crossReal = new Float32Array(filterLen);
+    const crossImag = new Float32Array(filterLen);
+    const filterReal = new Float32Array(filterLen);
+    const filterImag = new Float32Array(filterLen);
+    const arWork = new Float32Array(filterLen * filterLen);
+    const aiWork = new Float32Array(filterLen * filterLen);
+    const brWork = new Float32Array(filterLen);
+    const biWork = new Float32Array(filterLen);
+    for (let ch = 0; ch < channels; ch++) {
+      let channel = chunk.samples[ch];
+      if (!channel) continue;
+      if (channel.length < fftSize) {
+        const padded = new Float32Array(fftSize);
+        padded.set(channel);
+        channel = padded;
+      }
+      const stftResult = stft(channel, fftSize, hopSize, stftOutput, this.fftBackend, this.fftAddonOptions);
+      const numFrames = stftResult.frames;
+      transposeToBinMajor(stftResult.real, stftResult.imag, numFrames, numBins, realT, imagT);
+      computeBinPowerAndEnergy(realT, imagT, numBins, numFrames, originalPowerT, binEnergy);
+      const meanEnergy = binEnergy.reduce((sum, sample) => sum + sample, 0) / numBins;
+      const energyThreshold = meanEnergy * 1e-4;
+      const usedSize = numBins * numFrames;
+      for (let iter = 0; iter < iterations; iter++) {
+        let powerT;
+        if (iter === 0) {
+          powerT = originalPowerT;
+        } else {
+          for (let ci = 0; ci < usedSize; ci++) {
+            iterPowerT[ci] = Math.max(realT[ci] * realT[ci] + imagT[ci] * imagT[ci], 1e-10);
+          }
+          powerT = iterPowerT;
+        }
+        for (let bin = 0; bin < numBins; bin++) {
+          if (binEnergy[bin] < energyThreshold) continue;
+          const bo = bin * numFrames;
+          filterReal.fill(0);
+          filterImag.fill(0);
+          solveWpeFilter(realT, imagT, powerT, bo, numFrames, predictionDelay, filterLen, filterReal, filterImag, corrReal, corrImag, crossReal, crossImag, arWork, aiWork, brWork, biWork);
+          applyWpePrediction(realT, imagT, originalPowerT, bo, numFrames, predictionDelay, filterLen, filterReal, filterImag);
+        }
+      }
+      transposeToFrameMajor(realT, imagT, stftResult.real, stftResult.imag, numFrames, numBins);
+      const dereverberated = istft(stftResult, hopSize, paddedLength, this.fftBackend, this.fftAddonOptions).subarray(0, frames);
+      await buffer.write(0, replaceChannel(chunk, ch, dereverberated, channels));
+    }
+  }
+};
+var _DeReverbNode = class _DeReverbNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "de-reverb"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "de-reverb";
+  }
+  createStream() {
+    return new DeReverbStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _DeReverbNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DeReverbNode.moduleName = "De-Reverb (WPE)";
+_DeReverbNode.moduleDescription = "Reduce room reverb using Weighted Prediction Error \u2014 classical DSP, fully tunable, no model required";
+_DeReverbNode.schema = schema23;
+var DeReverbNode = _DeReverbNode;
+function deReverb(options) {
+  const sensitivity = Math.max(0, Math.min(1, options?.sensitivity ?? 0.5));
+  return new DeReverbNode({
+    predictionDelay: options?.predictionDelay ?? Math.round(2 + (1 - sensitivity) * 4),
+    filterLength: options?.filterLength ?? Math.round(5 + sensitivity * 15),
+    iterations: options?.iterations ?? Math.round(2 + sensitivity * 4),
+    vkfftAddonPath: options?.vkfftAddonPath ?? "",
+    fftwAddonPath: options?.fftwAddonPath ?? "",
+    id: options?.id
+  });
+}
+
+// src/utils/onnx-providers.ts
+function filterOnnxProviders(providers) {
+  const filtered = providers.filter((ep) => ep !== "gpu" && ep !== "cpu-native");
+  return filtered.length > 0 ? filtered : ["cpu"];
+}
+var require2 = createRequire(import.meta.url);
+function createOnnxSession(addonPath, modelPath, options) {
+  let addon;
+  try {
+    addon = require2(addonPath);
+  } catch (error) {
+    throw new Error(`Failed to load ONNX Runtime addon from "${addonPath}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let session;
+  try {
+    session = addon.createSession(modelPath, {
+      executionProviders: options?.executionProviders ? [...options.executionProviders] : ["cuda", "cpu"]
+    });
+  } catch (error) {
+    throw new Error(`Failed to create ONNX session for model "${modelPath}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return {
+    run(inputs) {
+      return session.run(inputs);
+    },
+    dispose() {
+      session.dispose();
+    }
+  };
+}
+var N_FFT = 7680;
+var HOP_SIZE = 1024;
+var DIM_F = 3072;
+var DIM_T = 256;
+var NB_BINS = N_FFT / 2 + 1;
+function stft7680IntoTensor(fft2, signal, tensor, realOffset, imagOffset) {
+  const win = hanningWindow(N_FFT);
+  const windowed = fft2.frameRe;
+  const zeros = fft2.frameIm;
+  zeros.fill(0);
+  let frame = 0;
+  for (let start = 0; start + N_FFT <= signal.length; start += HOP_SIZE) {
+    for (let index = 0; index < N_FFT; index++) {
+      windowed[index] = (signal[start + index] ?? 0) * (win[index] ?? 0);
+    }
+    fft2.fft(windowed, zeros, fft2.outRe, fft2.outIm);
+    for (let freq = 0; freq < DIM_F; freq++) {
+      tensor[realOffset + freq * DIM_T + frame] = fft2.outRe[freq] ?? 0;
+      tensor[imagOffset + freq * DIM_T + frame] = fft2.outIm[freq] ?? 0;
+    }
+    frame++;
+  }
+}
+function istft7680FromTensor(fft2, tensor, realOffset, imagOffset, numFrames, scale, output, windowSum) {
+  const win = hanningWindow(N_FFT);
+  const fullRe = fft2.frameRe;
+  const fullIm = fft2.frameIm;
+  const outputLength = output.length;
+  for (let frame = 0; frame < numFrames; frame++) {
+    fullRe.fill(0);
+    fullIm.fill(0);
+    for (let freq = 0; freq < DIM_F; freq++) {
+      fullRe[freq] = (tensor[realOffset + freq * DIM_T + frame] ?? 0) * scale;
+      fullIm[freq] = (tensor[imagOffset + freq * DIM_T + frame] ?? 0) * scale;
+    }
+    for (let index = 1; index < NB_BINS - 1; index++) {
+      fullRe[N_FFT - index] = fullRe[index] ?? 0;
+      fullIm[N_FFT - index] = -(fullIm[index] ?? 0);
+    }
+    fft2.ifft(fullRe, fullIm, fft2.outRe, fft2.outIm);
+    const frameOffset = frame * HOP_SIZE;
+    for (let index = 0; index < N_FFT; index++) {
+      const pos = frameOffset + index;
+      if (pos < outputLength) {
+        const wt = win[index] ?? 0;
+        output[pos] = (output[pos] ?? 0) + (fft2.outRe[index] ?? 0) * wt;
+        windowSum[pos] = (windowSum[pos] ?? 0) + wt * wt;
+      }
+    }
+  }
+  for (let index = 0; index < outputLength; index++) {
+    const ws = windowSum[index] ?? 0;
+    if (ws > 1e-8) {
+      output[index] = (output[index] ?? 0) / ws;
+    }
+  }
+}
+
+// src/transforms/dialogue-isolate/utils/segment.ts
+var DIM_F2 = 3072;
+var DIM_T2 = 256;
+var CHANNEL_STRIDE = DIM_F2 * DIM_T2;
+function buildTransitionWindow(segmentLength, transitionPower) {
+  const window = new Float32Array(segmentLength);
+  const half = segmentLength / 2;
+  for (let index = 0; index < half; index++) {
+    const value = Math.pow((index + 1) / half, transitionPower);
+    window[index] = value;
+    window[segmentLength - 1 - index] = value;
+  }
+  return window;
+}
+function createSegmentWorkspace(segmentLength) {
+  return {
+    segLeft: new Float32Array(segmentLength),
+    segRight: new Float32Array(segmentLength),
+    inputData: new Float32Array(4 * CHANNEL_STRIDE),
+    segOutLeft: new Float32Array(segmentLength),
+    segOutRight: new Float32Array(segmentLength),
+    istftWindowSum: new Float32Array(segmentLength)
+  };
+}
+function processSegment(left, right, offset, chunkLen, isMono, workspace, fft2, session, compensate) {
+  const { segLeft, segRight, inputData, segOutLeft, segOutRight, istftWindowSum } = workspace;
+  segLeft.fill(0);
+  for (let index = 0; index < chunkLen; index++) {
+    segLeft[index] = left[offset + index] ?? 0;
+  }
+  inputData.fill(0);
+  stft7680IntoTensor(fft2, segLeft, inputData, 0 * CHANNEL_STRIDE, 2 * CHANNEL_STRIDE);
+  if (isMono) {
+    inputData.copyWithin(1 * CHANNEL_STRIDE, 0 * CHANNEL_STRIDE, 1 * CHANNEL_STRIDE);
+    inputData.copyWithin(3 * CHANNEL_STRIDE, 2 * CHANNEL_STRIDE, 3 * CHANNEL_STRIDE);
+  } else {
+    segRight.fill(0);
+    for (let index = 0; index < chunkLen; index++) {
+      segRight[index] = right[offset + index] ?? 0;
+    }
+    stft7680IntoTensor(fft2, segRight, inputData, 1 * CHANNEL_STRIDE, 3 * CHANNEL_STRIDE);
+  }
+  const result = session.run({
+    input: { data: inputData, dims: [1, 4, DIM_F2, DIM_T2] }
+  });
+  const modelOutput = result.output;
+  if (!modelOutput) return void 0;
+  segOutLeft.fill(0);
+  istftWindowSum.fill(0);
+  istft7680FromTensor(fft2, modelOutput.data, 0 * CHANNEL_STRIDE, 2 * CHANNEL_STRIDE, DIM_T2, compensate, segOutLeft, istftWindowSum);
+  if (isMono) {
+    segOutRight.set(segOutLeft);
+  } else {
+    segOutRight.fill(0);
+    istftWindowSum.fill(0);
+    istft7680FromTensor(fft2, modelOutput.data, 1 * CHANNEL_STRIDE, 3 * CHANNEL_STRIDE, DIM_T2, compensate, segOutRight, istftWindowSum);
+  }
+  return { left: segOutLeft, right: segOutRight };
+}
+function normalizeOverlapAdd(output, weights, length) {
+  for (let index = 0; index < length; index++) {
+    const sw = weights[index] ?? 1;
+    if (sw > 0) {
+      output[index] = (output[index] ?? 0) / sw;
+    }
+  }
+}
+
+// src/transforms/dialogue-isolate/index.ts
+var schema24 = z.object({
+  modelPath: z.string().default("").meta({ input: "file", mode: "open", accept: ".onnx", binary: "Kim_Vocal_2", download: "https://huggingface.co/seanghay/uvr_models" }).describe("MDX-Net vocal isolation model (.onnx)"),
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  onnxAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "onnx-addon", download: "https://github.com/visionsofparadise/onnx-runtime-addon" }).describe("ONNX Runtime native addon"),
+  highPass: z.number().min(20).max(500).multipleOf(10).default(80).describe("High Pass"),
+  lowPass: z.number().min(1e3).max(22050).multipleOf(100).default(2e4).describe("Low Pass")
+});
+var SAMPLE_RATE = 44100;
+var N_FFT2 = 7680;
+var HOP_SIZE2 = 1024;
+var DIM_T3 = 256;
+var COMPENSATE = 1.009;
+var SEGMENT_SAMPLES = N_FFT2 + (DIM_T3 - 1) * HOP_SIZE2;
+var OVERLAP = 0.25;
+var TRANSITION_POWER = 1;
+var DialogueIsolateStream = class extends BufferedTransformStream {
+  constructor(properties) {
+    super(properties);
+    this.fftInstance = new MixedRadixFft(N_FFT2);
+  }
+  async _setup(input, context) {
+    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: filterOnnxProviders(context.executionProviders) });
+    return super._setup(input, context);
+  }
+  async _process(buffer) {
+    const frames = buffer.frames;
+    const channels = buffer.channels;
+    const chunk = await buffer.read(0, frames);
+    const left = chunk.samples[0] ?? new Float32Array(frames);
+    const right = channels >= 2 ? chunk.samples[1] ?? left : left;
+    const isMono = left === right;
+    let left44k = left;
+    let right44k = right;
+    if ((this.sampleRate ?? 44100) !== SAMPLE_RATE) {
+      const resampled = await resampleDirect(this.properties.ffmpegPath, [left, right], this.sampleRate ?? 44100, SAMPLE_RATE);
+      left44k = resampled[0] ?? left;
+      right44k = resampled[1] ?? right;
+    }
+    const samples44k = left44k.length;
+    const stride = Math.round((1 - OVERLAP) * SEGMENT_SAMPLES);
+    const outputLeft = new Float32Array(samples44k);
+    const outputRight = new Float32Array(samples44k);
+    const sumWeight = new Float32Array(samples44k);
+    const weight = buildTransitionWindow(SEGMENT_SAMPLES, TRANSITION_POWER);
+    const workspace = createSegmentWorkspace(SEGMENT_SAMPLES);
+    for (let offset = 0; offset < samples44k; offset += stride) {
+      const chunkLen = Math.min(SEGMENT_SAMPLES, samples44k - offset);
+      const processed = processSegment(left44k, right44k, offset, chunkLen, isMono, workspace, this.fftInstance, this.session, COMPENSATE);
+      if (!processed) continue;
+      for (let index = 0; index < chunkLen; index++) {
+        const wt = weight[index] ?? 1;
+        outputLeft[offset + index] = (outputLeft[offset + index] ?? 0) + (processed.left[index] ?? 0) * wt;
+        outputRight[offset + index] = (outputRight[offset + index] ?? 0) + (processed.right[index] ?? 0) * wt;
+        sumWeight[offset + index] = (sumWeight[offset + index] ?? 0) + wt;
+      }
+    }
+    normalizeOverlapAdd(outputLeft, sumWeight, samples44k);
+    normalizeOverlapAdd(outputRight, sumWeight, samples44k);
+    let finalLeft = outputLeft;
+    let finalRight = outputRight;
+    if ((this.sampleRate ?? 44100) !== SAMPLE_RATE) {
+      const resampled = await resampleDirect(this.properties.ffmpegPath, [outputLeft, outputRight], SAMPLE_RATE, this.sampleRate ?? 44100);
+      finalLeft = resampled[0] ?? outputLeft;
+      finalRight = resampled[1] ?? outputRight;
+    }
+    const outputChannels = [];
+    for (let ch = 0; ch < channels; ch++) {
+      const out = new Float32Array(frames);
+      const srcCh = Math.min(ch, 1);
+      const src = srcCh === 0 ? finalLeft : finalRight;
+      out.set(src.subarray(0, Math.min(src.length, frames)));
+      outputChannels.push(out);
+    }
+    applyBandpass(outputChannels, this.sampleRate ?? 44100, this.properties.highPass, this.properties.lowPass);
+    await buffer.write(0, outputChannels);
+  }
+};
+var _DialogueIsolateNode = class _DialogueIsolateNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "dialogue-isolate"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "dialogue-isolate";
+  }
+  createStream() {
+    return new DialogueIsolateStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _DialogueIsolateNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_DialogueIsolateNode.moduleName = "Dialogue Isolate";
+_DialogueIsolateNode.moduleDescription = "Isolate dialogue from background using MDX-Net vocal separation";
+_DialogueIsolateNode.schema = schema24;
+var DialogueIsolateNode = _DialogueIsolateNode;
+function dialogueIsolate(options) {
+  return new DialogueIsolateNode({
+    modelPath: options.modelPath,
+    ffmpegPath: options.ffmpegPath,
+    onnxAddonPath: options.onnxAddonPath ?? "",
+    highPass: options.highPass ?? 80,
+    lowPass: options.lowPass ?? 2e4,
+    id: options.id
+  });
+}
+function computeAverageSpectrum(signal, _sampleRate) {
+  const fftSize = 2048;
+  const hopSize = fftSize / 4;
+  const result = stft(signal, fftSize, hopSize);
+  const halfSize = fftSize / 2 + 1;
+  const avgMagnitude = new Float32Array(halfSize);
+  for (let frame = 0; frame < result.frames; frame++) {
+    const re = result.real[frame];
+    const im = result.imag[frame];
+    if (!re || !im) continue;
+    for (let bin = 0; bin < halfSize; bin++) {
+      const rVal = re[bin] ?? 0;
+      const iVal = im[bin] ?? 0;
+      avgMagnitude[bin] = (avgMagnitude[bin] ?? 0) + Math.sqrt(rVal * rVal + iVal * iVal);
+    }
+  }
+  if (result.frames > 0) {
+    for (let bin = 0; bin < halfSize; bin++) {
+      avgMagnitude[bin] = (avgMagnitude[bin] ?? 0) / result.frames;
+    }
+  }
+  return avgMagnitude;
+}
+function averageSpectrumFromStft(result, halfSize) {
+  const avgMagnitude = new Float32Array(halfSize);
+  for (let frame = 0; frame < result.frames; frame++) {
+    const re = result.real[frame];
+    const im = result.imag[frame];
+    if (!re || !im) continue;
+    for (let bin = 0; bin < halfSize; bin++) {
+      const rVal = re[bin] ?? 0;
+      const iVal = im[bin] ?? 0;
+      avgMagnitude[bin] = (avgMagnitude[bin] ?? 0) + Math.sqrt(rVal * rVal + iVal * iVal);
+    }
+  }
+  if (result.frames > 0) {
+    for (let bin = 0; bin < halfSize; bin++) {
+      avgMagnitude[bin] = (avgMagnitude[bin] ?? 0) / result.frames;
+    }
+  }
+  return avgMagnitude;
+}
+function computeCorrection(reference, input, smoothingOctaves) {
+  const size = Math.min(reference.length, input.length);
+  const correctionDb = new Float32Array(size);
+  for (let bin = 0; bin < size; bin++) {
+    const refDb = 20 * Math.log10(Math.max(reference[bin] ?? 0, 1e-10));
+    const inDb = 20 * Math.log10(Math.max(input[bin] ?? 0, 1e-10));
+    correctionDb[bin] = refDb - inDb;
+  }
+  return smoothSpectrum(correctionDb, smoothingOctaves);
+}
+function smoothSpectrum(spectrum, octaves) {
+  const smoothed = new Float32Array(spectrum.length);
+  for (let bin = 1; bin < spectrum.length; bin++) {
+    const lowerBin = Math.max(1, Math.round(bin / Math.pow(2, octaves / 2)));
+    const upperBin = Math.min(spectrum.length - 1, Math.round(bin * Math.pow(2, octaves / 2)));
+    let sum = 0;
+    let count = 0;
+    for (let neighbor = lowerBin; neighbor <= upperBin; neighbor++) {
+      sum += spectrum[neighbor] ?? 0;
+      count++;
+    }
+    smoothed[bin] = count > 0 ? sum / count : spectrum[bin] ?? 0;
+  }
+  smoothed[0] = spectrum[0] ?? 0;
+  return smoothed;
+}
+
+// src/transforms/eq-match/index.ts
+var schema25 = z.object({
+  referencePath: z.string().default("").describe("Reference Path"),
+  smoothing: z.number().min(0).max(1).multipleOf(0.01).default(1 / 3).describe("Smoothing"),
+  vkfftAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "vkfft-addon", download: "https://github.com/visionsofparadise/vkfft-addon" }).describe("VkFFT native addon \u2014 GPU FFT acceleration"),
+  fftwAddonPath: z.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 EqMatchStream = class extends BufferedTransformStream {
+  async _setup(input, context) {
+    const fft2 = initFftBackend(context.executionProviders, this.properties);
+    this.fftBackend = fft2.backend;
+    this.fftAddonOptions = fft2.addonOptions;
+    const { buffer: refBuffer } = await readToBuffer(this.properties.referencePath);
+    const refFrames = refBuffer.frames;
+    const chunk = await refBuffer.read(0, refFrames);
+    const channel = chunk.samples[0];
+    if (channel) {
+      this.referenceSpectrum = computeAverageSpectrum(channel, this.sampleRate ?? 44100);
+    }
+    await refBuffer.close();
+    return super._setup(input, context);
+  }
+  async _process(buffer) {
+    if (!this.referenceSpectrum) return;
+    const frames = buffer.frames;
+    const channels = buffer.channels;
+    const fftSize = 2048;
+    const hopSize = fftSize / 4;
+    const halfSize = fftSize / 2 + 1;
+    const paddedLength = Math.max(frames, fftSize);
+    const numStftFrames = Math.floor((paddedLength - fftSize) / hopSize) + 1;
+    const stftOutput = {
+      real: Array.from({ length: numStftFrames }, () => new Float32Array(halfSize)),
+      imag: Array.from({ length: numStftFrames }, () => new Float32Array(halfSize))
+    };
+    const chunk = await buffer.read(0, frames);
+    for (let ch = 0; ch < channels; ch++) {
+      let channel = chunk.samples[ch];
+      if (!channel) continue;
+      if (channel.length < fftSize) {
+        const padded = new Float32Array(fftSize);
+        padded.set(channel);
+        channel = padded;
+      }
+      const stftResult = stft(channel, fftSize, hopSize, stftOutput, this.fftBackend, this.fftAddonOptions);
+      const inputSpectrum = averageSpectrumFromStft(stftResult, halfSize);
+      const correctionDb = computeCorrection(this.referenceSpectrum, inputSpectrum, this.properties.smoothing);
+      const correctionLinear = correctionDb.map((db) => Math.pow(10, db / 20));
+      for (let frame = 0; frame < stftResult.frames; frame++) {
+        const realFrame = stftResult.real[frame];
+        const imagFrame = stftResult.imag[frame];
+        if (!realFrame || !imagFrame) continue;
+        for (let bin = 0; bin < realFrame.length; bin++) {
+          const correctionIdx = Math.min(bin, correctionLinear.length - 1);
+          const gain = correctionLinear[correctionIdx] ?? 1;
+          realFrame[bin] = (realFrame[bin] ?? 0) * gain;
+          imagFrame[bin] = (imagFrame[bin] ?? 0) * gain;
+        }
+      }
+      const matched = istft(stftResult, hopSize, paddedLength, this.fftBackend, this.fftAddonOptions).subarray(0, frames);
+      await buffer.write(0, replaceChannel(chunk, ch, matched, channels));
+    }
+  }
+};
+var _EqMatchNode = class _EqMatchNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "eq-match"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "eq-match";
+  }
+  createStream() {
+    return new EqMatchStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _EqMatchNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_EqMatchNode.moduleName = "EQ Match";
+_EqMatchNode.moduleDescription = "Match frequency response to a reference profile";
+_EqMatchNode.schema = schema25;
+var EqMatchNode = _EqMatchNode;
+function eqMatch(referencePath, options) {
+  return new EqMatchNode({
+    referencePath,
+    smoothing: options?.smoothing ?? 1 / 3,
+    vkfftAddonPath: options?.vkfftAddonPath ?? "",
+    fftwAddonPath: options?.fftwAddonPath ?? "",
+    id: options?.id
+  });
+}
+
+// src/transforms/leveler/utils/rms.ts
+var GATE_THRESHOLD_DB = -60;
+function computeRms(samples) {
+  let sum = 0;
+  let count = 0;
+  for (const channel of samples) {
+    for (const sample of channel) {
+      sum += sample * sample;
+      count++;
+    }
+  }
+  return count > 0 ? Math.sqrt(sum / count) : 0;
+}
+function computeTargetGain(rms, targetLoudness, maxGain, minGain) {
+  const rmsDb = 20 * Math.log10(Math.max(rms, 1e-10));
+  if (rmsDb <= GATE_THRESHOLD_DB) return void 0;
+  const targetGainDb = targetLoudness - rmsDb;
+  return Math.max(-minGain, Math.min(maxGain, targetGainDb));
+}
+
+// src/transforms/leveler/index.ts
+var schema26 = z.object({
+  target: z.number().min(-60).max(0).multipleOf(1).default(-20).describe("Target"),
+  window: z.number().min(0.01).max(5).multipleOf(0.01).default(0.5).describe("Window"),
+  speed: z.number().min(0.01).max(1).multipleOf(0.01).default(0.1).describe("Speed"),
+  maxGain: z.number().min(0).max(40).multipleOf(1).default(12).describe("Max Gain"),
+  maxCut: z.number().min(0).max(40).multipleOf(1).default(12).describe("Max Cut")
+});
+var LevelerStream = class extends BufferedTransformStream {
+  constructor(properties) {
+    super(properties);
+    this.windowSamples = 0;
+    this.currentGainDb = 0;
+    this.windowSeconds = this.properties.window;
+  }
+  _buffer(chunk, buffer) {
+    if (this.bufferSize === 0) {
+      this.bufferSize = Math.round(chunk.sampleRate * this.properties.window);
+    }
+    return super._buffer(chunk, buffer);
+  }
+  _process(_buffer) {
+  }
+  _unbuffer(chunk) {
+    if (this.windowSamples === 0) {
+      this.windowSamples = Math.round(this.properties.window * chunk.sampleRate);
+    }
+    const { target, speed, maxGain, maxCut } = this.properties;
+    const rms = computeRms(chunk.samples);
+    const targetGainDb = computeTargetGain(rms, target, maxGain, maxCut);
+    if (targetGainDb !== void 0) {
+      const alpha = 1 - Math.exp(-1 / (speed * (this.windowSamples / this.windowSeconds)));
+      this.currentGainDb += alpha * (targetGainDb - this.currentGainDb);
+    }
+    const gainLinear = Math.pow(10, this.currentGainDb / 20);
+    const samples = chunk.samples.map((channel) => {
+      const output = new Float32Array(channel.length);
+      for (let index = 0; index < channel.length; index++) {
+        output[index] = (channel[index] ?? 0) * gainLinear;
+      }
+      return output;
+    });
+    return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+  }
+};
+var _LevelerNode = class _LevelerNode extends TransformNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "leveler"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "leveler";
+  }
+  createStream() {
+    return new LevelerStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _LevelerNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_LevelerNode.moduleName = "Leveler";
+_LevelerNode.moduleDescription = "Smooth volume variations for consistent loudness";
+_LevelerNode.schema = schema26;
+var LevelerNode = _LevelerNode;
+function leveler(options) {
+  return new LevelerNode({
+    target: options?.target ?? -20,
+    window: options?.window ?? 0.5,
+    speed: options?.speed ?? 0.1,
+    maxGain: options?.maxGain ?? 12,
+    maxCut: options?.maxCut ?? 12,
+    id: options?.id
+  });
+}
+var FFT_SIZE = 4096;
+var HOP_SIZE3 = 1024;
+function reflectPad(signal, padLeft, padRight, totalLen) {
+  const result = new Float32Array(totalLen);
+  result.set(signal, padLeft);
+  for (let index = 0; index < padLeft; index++) {
+    result[padLeft - 1 - index] = result[padLeft + index] ?? 0;
+  }
+  const signalEnd = padLeft + signal.length - 1;
+  for (let index = 0; index < padRight; index++) {
+    result[signalEnd + index + 1] = result[signalEnd - index] ?? 0;
+  }
+  return result;
+}
+function computeStftScaled(signal) {
+  const scale = 1 / Math.sqrt(FFT_SIZE);
+  const result = stft(signal, FFT_SIZE, HOP_SIZE3);
+  for (const frame of result.real) {
+    for (let index = 0; index < frame.length; index++) {
+      frame[index] = (frame[index] ?? 0) * scale;
+    }
+  }
+  for (const frame of result.imag) {
+    for (let index = 0; index < frame.length; index++) {
+      frame[index] = (frame[index] ?? 0) * scale;
+    }
+  }
+  return result;
+}
+function computeIstftScaled(real, imag, outputLength) {
+  const scale = Math.sqrt(FFT_SIZE);
+  for (const frame of real) {
+    for (let index = 0; index < frame.length; index++) {
+      frame[index] = (frame[index] ?? 0) * scale;
+    }
+  }
+  for (const frame of imag) {
+    for (let index = 0; index < frame.length; index++) {
+      frame[index] = (frame[index] ?? 0) * scale;
+    }
+  }
+  return istft({ real, imag, frames: real.length, fftSize: FFT_SIZE }, HOP_SIZE3, outputLength);
+}
+
+// src/transforms/music-rebalance/utils/stems.ts
+function normalizeAudio(left, right, frames) {
+  const stereo = new Float32Array(2 * frames);
+  stereo.set(left, 0);
+  stereo.set(right, frames);
+  let sum = 0;
+  for (const sample of stereo) {
+    sum += sample;
+  }
+  const mean = sum / stereo.length;
+  let variance = 0;
+  for (const sample of stereo) {
+    const diff = sample - mean;
+    variance += diff * diff;
+  }
+  const std = Math.sqrt(variance / stereo.length) || 1;
+  const normalizedLeft = new Float32Array(frames);
+  const normalizedRight = new Float32Array(frames);
+  for (let index = 0; index < frames; index++) {
+    normalizedLeft[index] = ((left[index] ?? 0) - mean) / std;
+    normalizedRight[index] = ((right[index] ?? 0) - mean) / std;
+  }
+  return { normalizedLeft, normalizedRight, stats: { mean, std } };
+}
+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 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 srcFrame = frame + 2;
+        xData[realIdx] = stftCh.real[srcFrame]?.[freq] ?? 0;
+        xData[imagIdx] = stftCh.imag[srcFrame]?.[freq] ?? 0;
+      }
+    }
+  }
+  const inputData = new Float32Array(2 * segmentLength);
+  inputData.set(segLeft, 0);
+  inputData.set(segRight, segmentLength);
+  return { inputData, xData };
+}
+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 frame = 0; frame < nbFrames; frame++) {
+        freqRealBuffers[frame]?.fill(0);
+        freqImagBuffers[frame]?.fill(0);
+      }
+      if (xOut) {
+        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 destFrame = frame + 2;
+            const realArr = freqRealBuffers[destFrame];
+            const imagArr = freqImagBuffers[destFrame];
+            if (realArr && imagArr) {
+              realArr[freq] = xOut.data[realIdx] ?? 0;
+              imagArr[freq] = xOut.data[imagIdx] ?? 0;
+            }
+          }
+        }
+      }
+      const freqWaveform = computeIstftScaled(freqRealBuffers, freqImagBuffers, stftLen);
+      const freqOffset = stftPad + pad2;
+      for (let index = 0; index < chunkLength; index++) {
+        const timeVal = xtOut ? xtOut.data[xtIndex + index] ?? 0 : 0;
+        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;
+        }
+      }
+    }
+  }
+}
+function mixStems(stemOutputs, sumWeight, stemGains, stats, frames, channels) {
+  const outputChannels = [];
+  for (let ch = 0; ch < channels; ch++) {
+    const output = new Float32Array(frames);
+    const srcCh = Math.min(ch, 1);
+    for (let index = 0; index < frames; index++) {
+      const sw = sumWeight[index] ?? 1;
+      let normalizedSum = 0;
+      for (let source = 0; source < 4; source++) {
+        const gain = stemGains[source] ?? 1;
+        if (gain === 0) continue;
+        const arr = stemOutputs[source * 2 + srcCh];
+        normalizedSum += (arr ? (arr[index] ?? 0) / sw : 0) * gain;
+      }
+      output[index] = normalizedSum * stats.std + stats.mean;
+    }
+    outputChannels.push(output);
+  }
+  return outputChannels;
+}
+
+// src/transforms/music-rebalance/index.ts
+var schema27 = z.object({
+  modelPath: z.string().default("").meta({ input: "file", mode: "open", accept: ".onnx", binary: "htdemucs", download: "https://github.com/facebookresearch/demucs" }).describe("HTDemucs source separation model (.onnx) \u2014 requires .onnx.data file alongside"),
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  onnxAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "onnx-addon", download: "https://github.com/visionsofparadise/onnx-runtime-addon" }).describe("ONNX Runtime native addon"),
+  highPass: z.number().min(0).max(500).multipleOf(10).default(0).describe("High Pass"),
+  lowPass: z.number().min(0).max(22050).multipleOf(100).default(0).describe("Low Pass")
+});
+var HTDEMUCS_SAMPLE_RATE = 44100;
+var FFT_SIZE2 = 4096;
+var HOP_SIZE4 = 1024;
+var SEGMENT_SAMPLES2 = 343980;
+var OVERLAP2 = 0.25;
+var TRANSITION_POWER2 = 1;
+var MusicRebalanceStream = class extends BufferedTransformStream {
+  async _setup(input, context) {
+    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: filterOnnxProviders(context.executionProviders) });
+    return super._setup(input, context);
+  }
+  async _process(buffer) {
+    const originalFrames = buffer.frames;
+    const channels = buffer.channels;
+    const chunk = await buffer.read(0, originalFrames);
+    let left = chunk.samples[0] ?? new Float32Array(originalFrames);
+    let right = channels >= 2 ? chunk.samples[1] ?? left : left;
+    if ((this.sampleRate ?? 44100) !== HTDEMUCS_SAMPLE_RATE) {
+      const resampled = await resampleDirect(this.properties.ffmpegPath, [left, right], this.sampleRate ?? 44100, HTDEMUCS_SAMPLE_RATE);
+      left = resampled[0] ?? left;
+      right = resampled[1] ?? right;
+    }
+    const frames = left.length;
+    const { normalizedLeft, normalizedRight, stats } = normalizeAudio(left, right, frames);
+    const stridesamples = Math.round((1 - OVERLAP2) * SEGMENT_SAMPLES2);
+    const stemOutputs = new Array(4 * 2);
+    for (let si = 0; si < 8; si++) {
+      stemOutputs[si] = new Float32Array(frames);
+    }
+    const sumWeight = new Float32Array(frames);
+    const weight = new Float32Array(SEGMENT_SAMPLES2);
+    const half = SEGMENT_SAMPLES2 / 2;
+    for (let index = 0; index < half; index++) {
+      weight[index] = Math.pow((index + 1) / half, TRANSITION_POWER2);
+    }
+    for (let index = 0; index < half; index++) {
+      weight[SEGMENT_SAMPLES2 - 1 - index] = weight[index] ?? 0;
+    }
+    const pad2 = Math.floor(HOP_SIZE4 / 2) * 3;
+    const le = Math.ceil(SEGMENT_SAMPLES2 / HOP_SIZE4);
+    const padEnd = pad2 + le * HOP_SIZE4 - SEGMENT_SAMPLES2;
+    const paddedLen = SEGMENT_SAMPLES2 + pad2 + padEnd;
+    const stftPadConst = FFT_SIZE2 / 2;
+    const stftLenConst = paddedLen + FFT_SIZE2;
+    const nbBinsConst = FFT_SIZE2 / 2 + 1;
+    const nbFramesConst = Math.floor((stftLenConst - FFT_SIZE2) / HOP_SIZE4) + 1;
+    const xBinsConst = nbBinsConst - 1;
+    const xFramesConst = nbFramesConst - 4;
+    const segLeft = new Float32Array(SEGMENT_SAMPLES2);
+    const segRight = new Float32Array(SEGMENT_SAMPLES2);
+    const freqRealBuffers = [];
+    const freqImagBuffers = [];
+    for (let frame = 0; frame < nbFramesConst; frame++) {
+      freqRealBuffers.push(new Float32Array(nbBinsConst));
+      freqImagBuffers.push(new Float32Array(nbBinsConst));
+    }
+    const workspace = {
+      freqRealBuffers,
+      freqImagBuffers,
+      nbFrames: nbFramesConst,
+      stftLen: stftLenConst,
+      stftPad: stftPadConst,
+      pad: pad2,
+      xBins: xBinsConst,
+      xFrames: xFramesConst
+    };
+    for (let segmentOffset = 0; segmentOffset < frames; segmentOffset += stridesamples) {
+      const chunkLength = Math.min(SEGMENT_SAMPLES2, frames - segmentOffset);
+      segLeft.fill(0);
+      segRight.fill(0);
+      for (let index = 0; index < chunkLength; index++) {
+        segLeft[index] = normalizedLeft[segmentOffset + index] ?? 0;
+        segRight[index] = normalizedRight[segmentOffset + index] ?? 0;
+      }
+      const paddedLeft = reflectPad(segLeft, pad2, padEnd, paddedLen);
+      const paddedRight = reflectPad(segRight, pad2, padEnd, paddedLen);
+      const stftInputLeft = reflectPad(paddedLeft, stftPadConst, stftPadConst, stftLenConst);
+      const stftInputRight = reflectPad(paddedRight, stftPadConst, stftPadConst, stftLenConst);
+      const stftLeft = computeStftScaled(stftInputLeft);
+      const stftRight = computeStftScaled(stftInputRight);
+      const { inputData, xData } = buildModelInput(segLeft, segRight, stftLeft, stftRight, SEGMENT_SAMPLES2, xBinsConst, xFramesConst);
+      const result = this.session.run({
+        input: { data: inputData, dims: [1, 2, SEGMENT_SAMPLES2] },
+        x: { data: xData, dims: [1, 4, xBinsConst, xFramesConst] }
+      });
+      const xtOut = result.add_67 ?? result[Object.keys(result).pop() ?? ""];
+      const xOut = result.output ?? result[Object.keys(result)[0] ?? ""];
+      extractStems(xtOut, xOut, workspace, stemOutputs, weight, segmentOffset, chunkLength, SEGMENT_SAMPLES2);
+      for (let index = 0; index < chunkLength; index++) {
+        sumWeight[segmentOffset + index] = (sumWeight[segmentOffset + index] ?? 0) + (weight[index] ?? 0);
+      }
+    }
+    const { stems } = this.properties;
+    const stemGains = [stems.drums, stems.bass, stems.other, stems.vocals];
+    const outputChannels = mixStems(stemOutputs, sumWeight, stemGains, stats, frames, channels);
+    applyBandpass(outputChannels, HTDEMUCS_SAMPLE_RATE, this.properties.highPass, this.properties.lowPass);
+    if ((this.sampleRate ?? 44100) !== HTDEMUCS_SAMPLE_RATE) {
+      const resampled = await resampleDirect(this.properties.ffmpegPath, outputChannels, HTDEMUCS_SAMPLE_RATE, this.sampleRate ?? 44100);
+      for (let ch = 0; ch < outputChannels.length; ch++) {
+        const resampledCh = resampled[ch];
+        if (!resampledCh) continue;
+        const finalCh = new Float32Array(originalFrames);
+        finalCh.set(resampledCh.subarray(0, Math.min(resampledCh.length, originalFrames)));
+        outputChannels[ch] = finalCh;
+      }
+    }
+    await buffer.write(0, outputChannels);
+  }
+};
+var _MusicRebalanceNode = class _MusicRebalanceNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "music-rebalance"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "music-rebalance";
+  }
+  createStream() {
+    return new MusicRebalanceStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _MusicRebalanceNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_MusicRebalanceNode.moduleName = "Music Rebalance";
+_MusicRebalanceNode.moduleDescription = "Rebalance stem volumes using HTDemucs source separation";
+_MusicRebalanceNode.schema = schema27;
+var MusicRebalanceNode = _MusicRebalanceNode;
+function musicRebalance(modelPath, stems, options) {
+  const parsed = schema27.parse({
+    modelPath,
+    ffmpegPath: options?.ffmpegPath,
+    onnxAddonPath: options?.onnxAddonPath
+  });
+  return new MusicRebalanceNode({
+    ...parsed,
+    stems: {
+      vocals: stems.vocals ?? 1,
+      drums: stems.drums ?? 1,
+      bass: stems.bass ?? 1,
+      other: stems.other ?? 1
+    },
+    id: options?.id
+  });
+}
+var schema28 = z.object({
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  semitones: z.number().min(-24).max(24).multipleOf(1).default(0).describe("Semitones"),
+  cents: z.number().min(-100).max(100).multipleOf(1).default(0).describe("Cents")
+});
+var PitchShiftStream = class extends FfmpegStream {
+  _buildArgs(_context) {
+    const { semitones, cents } = this.properties;
+    const totalSemitones = semitones + (cents ?? 0) / 100;
+    const pitchRatio = Math.pow(2, totalSemitones / 12);
+    return ["-af", `rubberband=pitch=${pitchRatio}`];
+  }
+};
+var _PitchShiftNode = class _PitchShiftNode extends FfmpegNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "ffmpeg", "pitch-shift"];
+  }
+  static is(value) {
+    return FfmpegNode.is(value) && value.type[3] === "pitch-shift";
+  }
+  createStream() {
+    return new PitchShiftStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _PitchShiftNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_PitchShiftNode.moduleName = "Pitch Shift";
+_PitchShiftNode.moduleDescription = "Change pitch without affecting duration";
+_PitchShiftNode.schema = schema28;
+var PitchShiftNode = _PitchShiftNode;
+function pitchShift(ffmpegPath, semitones, options) {
+  return new PitchShiftNode({
+    ffmpegPath,
+    semitones,
+    cents: options?.cents,
+    id: options?.id
+  });
+}
+
+// src/transforms/spectral-repair/utils/interpolation.ts
+function interpolateTfRegion(real, imag, startFrame, endFrame, startBin, endBin) {
+  const iterations = 5;
+  const clampedStart = Math.max(0, startFrame);
+  const clampedEnd = Math.min(real.length, endFrame);
+  if (clampedStart >= clampedEnd) return;
+  const halfSize = real[0]?.length ?? 0;
+  const clampedStartBin = Math.max(0, startBin);
+  const clampedEndBin = Math.min(halfSize, endBin);
+  const regionFrames = clampedEnd - clampedStart;
+  const regionBins = clampedEndBin - clampedStartBin;
+  const writeReal = new Float32Array(regionFrames * regionBins);
+  const writeImag = new Float32Array(regionFrames * regionBins);
+  for (let iter = 0; iter < iterations; iter++) {
+    for (let frame = clampedStart; frame < clampedEnd; frame++) {
+      const realFrame = real[frame];
+      const imagFrame = imag[frame];
+      if (!realFrame || !imagFrame) continue;
+      for (let bin = clampedStartBin; bin < clampedEndBin; bin++) {
+        let realSum = 0;
+        let imagSum = 0;
+        let count = 0;
+        const prevFrame = real[frame - 1];
+        const nextFrame = real[frame + 1];
+        const prevImag = imag[frame - 1];
+        const nextImag = imag[frame + 1];
+        if (prevFrame && prevImag) {
+          realSum += prevFrame[bin] ?? 0;
+          imagSum += prevImag[bin] ?? 0;
+          count++;
+        }
+        if (nextFrame && nextImag) {
+          realSum += nextFrame[bin] ?? 0;
+          imagSum += nextImag[bin] ?? 0;
+          count++;
+        }
+        if (bin > 0) {
+          realSum += realFrame[bin - 1] ?? 0;
+          imagSum += imagFrame[bin - 1] ?? 0;
+          count++;
+        }
+        if (bin < halfSize - 1) {
+          realSum += realFrame[bin + 1] ?? 0;
+          imagSum += imagFrame[bin + 1] ?? 0;
+          count++;
+        }
+        if (count > 0) {
+          const bufferIndex = (frame - clampedStart) * regionBins + (bin - clampedStartBin);
+          writeReal[bufferIndex] = realSum / count;
+          writeImag[bufferIndex] = imagSum / count;
+        }
+      }
+    }
+    for (let frame = clampedStart; frame < clampedEnd; frame++) {
+      const realFrame = real[frame];
+      const imagFrame = imag[frame];
+      if (!realFrame || !imagFrame) continue;
+      for (let bin = clampedStartBin; bin < clampedEndBin; bin++) {
+        const bufferIndex = (frame - clampedStart) * regionBins + (bin - clampedStartBin);
+        realFrame[bin] = writeReal[bufferIndex] ?? 0;
+        imagFrame[bin] = writeImag[bufferIndex] ?? 0;
+      }
+    }
+  }
+}
+
+// src/transforms/spectral-repair/index.ts
+var schema29 = z.object({
+  method: z.enum(["ar", "nmf"]).default("ar").describe("Method"),
+  vkfftAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "vkfft-addon", download: "https://github.com/visionsofparadise/vkfft-addon" }).describe("VkFFT native addon \u2014 GPU FFT acceleration"),
+  fftwAddonPath: z.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 SpectralRepairStream = class extends BufferedTransformStream {
+  async _setup(input, context) {
+    const fft2 = initFftBackend(context.executionProviders, this.properties);
+    this.fftBackend = fft2.backend;
+    this.fftAddonOptions = fft2.addonOptions;
+    return super._setup(input, context);
+  }
+  async _process(buffer) {
+    const sampleRate = this.sampleRate ?? 44100;
+    const channels = buffer.channels;
+    const frames = buffer.frames;
+    const fftSize = 2048;
+    const hopSize = fftSize / 4;
+    const halfSize = fftSize / 2 + 1;
+    const paddedLength = Math.max(frames, fftSize);
+    const numStftFrames = Math.floor((paddedLength - fftSize) / hopSize) + 1;
+    const stftOutput = {
+      real: Array.from({ length: numStftFrames }, () => new Float32Array(halfSize)),
+      imag: Array.from({ length: numStftFrames }, () => new Float32Array(halfSize))
+    };
+    const chunk = await buffer.read(0, frames);
+    for (let ch = 0; ch < channels; ch++) {
+      let channel = chunk.samples[ch];
+      if (!channel) continue;
+      if (channel.length < fftSize) {
+        const padded = new Float32Array(fftSize);
+        padded.set(channel);
+        channel = padded;
+      }
+      const stftResult = stft(channel, fftSize, hopSize, stftOutput, this.fftBackend, this.fftAddonOptions);
+      const freqPerBin = sampleRate / fftSize;
+      const timePerFrame = hopSize / sampleRate;
+      for (const region of this.properties.regions) {
+        const startFrame = Math.floor(region.startTime / timePerFrame);
+        const endFrame = Math.ceil(region.endTime / timePerFrame);
+        const startBin = Math.floor(region.startFreq / freqPerBin);
+        const endBin = Math.ceil(region.endFreq / freqPerBin);
+        interpolateTfRegion(stftResult.real, stftResult.imag, startFrame, endFrame, startBin, endBin);
+      }
+      const repaired = istft(stftResult, hopSize, paddedLength, this.fftBackend, this.fftAddonOptions).subarray(0, frames);
+      await buffer.write(0, replaceChannel(chunk, ch, repaired, channels));
+    }
+  }
+};
+var _SpectralRepairNode = class _SpectralRepairNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "spectral-repair"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "spectral-repair";
+  }
+  createStream() {
+    return new SpectralRepairStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _SpectralRepairNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_SpectralRepairNode.moduleName = "Spectral Repair";
+_SpectralRepairNode.moduleDescription = "Repair spectral artifacts by interpolating from surrounding content";
+_SpectralRepairNode.schema = schema29;
+var SpectralRepairNode = _SpectralRepairNode;
+function spectralRepair(regions, options) {
+  return new SpectralRepairNode({
+    regions,
+    method: options?.method ?? "ar",
+    vkfftAddonPath: options?.vkfftAddonPath ?? "",
+    fftwAddonPath: options?.fftwAddonPath ?? "",
+    id: options?.id
+  });
+}
+var schema30 = z.object({
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  rate: z.number().min(0.25).max(4).multipleOf(0.01).default(1).describe("Rate")
+});
+var TimeStretchStream = class extends FfmpegStream {
+  _buildArgs(_context) {
+    const filters = buildAtempoChain(this.properties.rate);
+    return ["-af", filters.join(",")];
+  }
+};
+var _TimeStretchNode = class _TimeStretchNode extends FfmpegNode {
+  constructor() {
+    super(...arguments);
+    this.type = ["buffered-audio-node", "transform", "ffmpeg", "time-stretch"];
+  }
+  static is(value) {
+    return FfmpegNode.is(value) && value.type[3] === "time-stretch";
+  }
+  createStream() {
+    return new TimeStretchStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _TimeStretchNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_TimeStretchNode.moduleName = "Time Stretch";
+_TimeStretchNode.moduleDescription = "Change duration without affecting pitch";
+_TimeStretchNode.schema = schema30;
+var TimeStretchNode = _TimeStretchNode;
+function buildAtempoChain(rate) {
+  const filters = [];
+  let remaining = rate;
+  while (remaining > 2) {
+    filters.push("atempo=2.0");
+    remaining /= 2;
+  }
+  while (remaining < 0.5) {
+    filters.push("atempo=0.5");
+    remaining /= 0.5;
+  }
+  filters.push(`atempo=${remaining}`);
+  return filters;
+}
+function timeStretch(ffmpegPath, rate, options) {
+  return new TimeStretchNode({
+    ffmpegPath,
+    rate,
+    id: options?.id
+  });
+}
+var BLOCK_LEN = 512;
+var BLOCK_SHIFT = 128;
+var FFT_BINS = BLOCK_LEN / 2 + 1;
+var LSTM_UNITS = 128;
+function processDtlnFrames(signal, session1, session2, fftBackend, fftAddonOptions) {
+  const originalLength = signal.length;
+  if (originalLength < BLOCK_LEN) {
+    const padded = new Float32Array(BLOCK_LEN);
+    padded.set(signal);
+    signal = padded;
+  }
+  const totalFrames = signal.length;
+  const output = new Float32Array(totalFrames);
+  const stateSize = 1 * 2 * LSTM_UNITS * 2;
+  let states1 = new Float32Array(stateSize);
+  let states2 = new Float32Array(stateSize);
+  const inputBuffer = new Float32Array(BLOCK_LEN);
+  const magnitude = new Float32Array(FFT_BINS);
+  const maskedReal = new Float32Array(FFT_BINS);
+  const maskedImag = new Float32Array(FFT_BINS);
+  const maskedStft = {
+    real: [maskedReal],
+    imag: [maskedImag],
+    frames: 1,
+    fftSize: BLOCK_LEN
+  };
+  const stftOutput = { real: [new Float32Array(FFT_BINS)], imag: [new Float32Array(FFT_BINS)] };
+  for (let offset = 0; offset + BLOCK_LEN <= totalFrames; offset += BLOCK_SHIFT) {
+    inputBuffer.set(signal.subarray(offset, offset + BLOCK_LEN));
+    const stftResult = stft(inputBuffer, BLOCK_LEN, BLOCK_LEN, stftOutput, fftBackend, fftAddonOptions);
+    const realFrame = stftResult.real[0];
+    const imagFrame = stftResult.imag[0];
+    if (!realFrame || !imagFrame) continue;
+    for (let bin = 0; bin < FFT_BINS; bin++) {
+      const re = realFrame[bin] ?? 0;
+      const im = imagFrame[bin] ?? 0;
+      magnitude[bin] = Math.log(Math.sqrt(re * re + im * im) + 1e-7);
+    }
+    const result1 = session1.run({
+      input_2: { data: magnitude, dims: [1, 1, FFT_BINS] },
+      input_3: { data: states1, dims: [1, 2, LSTM_UNITS, 2] }
+    });
+    const mask = result1.activation_2;
+    states1 = result1.tf_op_layer_stack_2 ? new Float32Array(result1.tf_op_layer_stack_2.data) : states1;
+    if (!mask) continue;
+    for (let bin = 0; bin < FFT_BINS; bin++) {
+      const maskVal = mask.data[bin] ?? 0;
+      maskedReal[bin] = (realFrame[bin] ?? 0) * maskVal;
+      maskedImag[bin] = (imagFrame[bin] ?? 0) * maskVal;
+    }
+    const maskedTimeDomain = istft(maskedStft, BLOCK_LEN, BLOCK_LEN, fftBackend, fftAddonOptions);
+    const result2 = session2.run({
+      input_4: { data: maskedTimeDomain, dims: [1, 1, BLOCK_LEN] },
+      input_5: { data: states2, dims: [1, 2, LSTM_UNITS, 2] }
+    });
+    const denoisedFrame = result2.conv1d_3;
+    states2 = result2.tf_op_layer_stack_5 ? new Float32Array(result2.tf_op_layer_stack_5.data) : states2;
+    if (!denoisedFrame) continue;
+    for (let index = 0; index < BLOCK_LEN; index++) {
+      const outIdx = offset + index;
+      if (outIdx < totalFrames) {
+        output[outIdx] = (output[outIdx] ?? 0) + (denoisedFrame.data[index] ?? 0);
+      }
+    }
+  }
+  return originalLength < output.length ? output.subarray(0, originalLength) : output;
+}
+
+// src/transforms/voice-denoise/index.ts
+var schema31 = z.object({
+  modelPath1: z.string().default("").meta({ input: "file", mode: "open", accept: ".onnx", binary: "dtln-model_1", download: "https://github.com/breizhn/DTLN" }).describe("DTLN magnitude mask model (.onnx)"),
+  modelPath2: z.string().default("").meta({ input: "file", mode: "open", accept: ".onnx", binary: "dtln-model_2", download: "https://github.com/breizhn/DTLN" }).describe("DTLN time-domain model (.onnx)"),
+  ffmpegPath: z.string().default("").meta({ input: "file", mode: "open", binary: "ffmpeg", download: "https://ffmpeg.org/download.html" }).describe("FFmpeg \u2014 audio/video processing tool"),
+  onnxAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "onnx-addon", download: "https://github.com/visionsofparadise/onnx-runtime-addon" }).describe("ONNX Runtime native addon"),
+  vkfftAddonPath: z.string().default("").meta({ input: "file", mode: "open", binary: "vkfft-addon", download: "https://github.com/visionsofparadise/vkfft-addon" }).describe("VkFFT native addon \u2014 GPU FFT acceleration"),
+  fftwAddonPath: z.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 DTLN_SAMPLE_RATE = 16e3;
+var VoiceDenoiseStream = class extends BufferedTransformStream {
+  async _setup(input, context) {
+    const onnxProviders = filterOnnxProviders(context.executionProviders);
+    this.session1 = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath1, { executionProviders: onnxProviders });
+    this.session2 = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath2, { executionProviders: onnxProviders });
+    const cpuProviders = context.executionProviders.filter((ep) => ep !== "gpu");
+    const fft2 = initFftBackend(cpuProviders.length > 0 ? cpuProviders : ["cpu"], this.properties);
+    this.fftBackend = fft2.backend;
+    this.fftAddonOptions = fft2.addonOptions;
+    return super._setup(input, context);
+  }
+  async _process(buffer) {
+    const frames = buffer.frames;
+    const channels = buffer.channels;
+    for (let ch = 0; ch < channels; ch++) {
+      const chunk = await buffer.read(0, frames);
+      const channel = chunk.samples[ch];
+      if (!channel) continue;
+      let input16k = channel;
+      if ((this.sampleRate ?? 44100) !== DTLN_SAMPLE_RATE) {
+        const resampled = await resampleDirect(this.properties.ffmpegPath, [channel], this.sampleRate ?? 44100, DTLN_SAMPLE_RATE);
+        input16k = resampled[0] ?? channel;
+      }
+      const denoised16k = processDtlnFrames(input16k, this.session1, this.session2, this.fftBackend, this.fftAddonOptions);
+      let output = denoised16k;
+      if ((this.sampleRate ?? 44100) !== DTLN_SAMPLE_RATE) {
+        const resampled = await resampleDirect(this.properties.ffmpegPath, [denoised16k], DTLN_SAMPLE_RATE, this.sampleRate ?? 44100);
+        output = resampled[0] ?? denoised16k;
+      }
+      const finalOutput = new Float32Array(frames);
+      finalOutput.set(output.subarray(0, Math.min(output.length, frames)));
+      const allChannels = [];
+      for (let writeCh = 0; writeCh < channels; writeCh++) {
+        allChannels.push(writeCh === ch ? finalOutput : chunk.samples[writeCh] ?? new Float32Array(frames));
+      }
+      await buffer.write(0, allChannels);
+    }
+  }
+};
+var _VoiceDenoiseNode = class _VoiceDenoiseNode extends TransformNode {
+  constructor(properties) {
+    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    this.type = ["buffered-audio-node", "transform", "voice-denoise"];
+  }
+  static is(value) {
+    return TransformNode.is(value) && value.type[2] === "voice-denoise";
+  }
+  createStream() {
+    return new VoiceDenoiseStream({ ...this.properties, bufferSize: this.bufferSize, overlap: this.properties.overlap ?? 0 });
+  }
+  clone(overrides) {
+    return new _VoiceDenoiseNode({ ...this.properties, previousProperties: this.properties, ...overrides });
+  }
+};
+_VoiceDenoiseNode.moduleName = "Voice Denoise";
+_VoiceDenoiseNode.moduleDescription = "Remove background noise from speech using DTLN neural network";
+_VoiceDenoiseNode.schema = schema31;
+var VoiceDenoiseNode = _VoiceDenoiseNode;
+function voiceDenoise(options) {
+  return new VoiceDenoiseNode({
+    modelPath1: options.modelPath1,
+    modelPath2: options.modelPath2,
+    ffmpegPath: options.ffmpegPath,
+    onnxAddonPath: options.onnxAddonPath ?? "",
+    vkfftAddonPath: options.vkfftAddonPath ?? "",
+    fftwAddonPath: options.fftwAddonPath ?? "",
+    id: options.id
+  });
+}
+
+export { BreathControlNode, BreathControlStream, CutNode, CutStream, DeBleedNode, DeBleedStream, DeClickNode, DeClickStream, DeClipNode, DeClipStream, DeCrackleNode, DePlosiveNode, DePlosiveStream, DeReverbNode, DeReverbStream, DialogueIsolateNode, DialogueIsolateStream, DitherNode, DitherStream, EqMatchNode, EqMatchStream, FfmpegNode, FfmpegStream, LevelerNode, LevelerStream, LoudnessNode, LoudnessStatsNode, LoudnessStatsStream, LoudnessStream, MouthDeClickNode, MusicRebalanceNode, MusicRebalanceStream, NormalizeNode, NormalizeStream, PadNode, PadStream, PhaseNode, PhaseStream, PitchShiftNode, ReadFfmpegNode, ReadFfmpegStream, ReadNode, ReadWavNode, ReadWavStream, ResampleNode, ReverseNode, ReverseStream, SpectralRepairNode, SpectralRepairStream, SpectrogramNode, SpectrogramStream, SpliceNode, SpliceStream, TimeStretchNode, TrimNode, TrimStream, VoiceDenoiseNode, VoiceDenoiseStream, WaveformNode, WaveformStream, WriteNode, WriteStream, breathControl, cut, deBleed, deClick, deClip, deCrackle, dePlosive, deReverb, dialogueIsolate, dither, eqMatch, ffmpeg, ffmpegSchema, invert, leveler, loudness, loudnessStats, mouthDeClick, musicRebalance, normalize, pad, phase, pitchShift, read, readFfmpeg, readSample, readWav, resample, reverse, spectralRepair, spectrogram, splice, timeStretch, trim, voiceDenoise, wavSchema, waveform, write };