@buffered-audio/nodes 0.23.0 → 0.24.2

package/dist/{chunk-YJWZP2OD.js → chunk-BKEMKXGG.js}

@@ -1,5 +1,4 @@
 import { createRequire } from 'module';
-import { spawn } from 'child_process';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -229,15 +228,30 @@ function bandpass(channels, sampleRate, highPass, lowPass) {
     }
   }
 }
+function getBidirectionalIirAlphas(sampleRate, smoothingMs) {
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+    throw new Error(`BidirectionalIir: sampleRate must be positive and finite, got ${sampleRate}`);
+  }
+  if (!Number.isFinite(smoothingMs)) {
+    throw new Error(`BidirectionalIir: smoothingMs must be finite, got ${smoothingMs}`);
+  }
+  if (smoothingMs <= 0) return { causal: 1, bidirectional: 1 };
+  const ratio = 1e3 / sampleRate / smoothingMs;
+  const causalPole = Math.exp(-ratio);
+  const causal = -Math.expm1(-ratio);
+  const omega = Math.min(ratio, Math.PI);
+  const sinHalf = Math.sin(omega / 2);
+  const causalMagnitude = causal / Math.hypot(causal, 2 * Math.sqrt(causalPole) * sinHalf);
+  const transformedFrequency = 2 * sinHalf * Math.sqrt(causalMagnitude / (1 - causalMagnitude));
+  const bidirectional = -Math.expm1(-2 * Math.asinh(transformedFrequency / 2));
+  return { causal, bidirectional };
+}
 var BidirectionalIir = class {
   constructor(options) {
     this.smoothingMs = options.smoothingMs;
-    this.sampleRate = options.sampleRate;
-    const samplePeriod = 1 / this.sampleRate;
-    const tauBidirectional = this.smoothingMs / 1e3 * Math.SQRT2;
-    this.alphaBidirectional = tauBidirectional > 0 ? 1 - Math.exp(-samplePeriod / tauBidirectional) : 1;
-    const tauCausal = this.smoothingMs / 1e3;
-    this.alphaCausal = tauCausal > 0 ? 1 - Math.exp(-samplePeriod / tauCausal) : 1;
+    const alphas = getBidirectionalIirAlphas(options.sampleRate, options.smoothingMs);
+    this.alphaBidirectional = alphas.bidirectional;
+    this.alphaCausal = alphas.causal;
   }
   applyBidirectional(input) {
     const output = Float32Array.from(input);
@@ -318,7 +332,6 @@ var BlockSumAccumulator = class {
     this.ringSize = computeRingSize(blockSize, blockStep);
     this.activeBlockSums = new Float64Array(this.ringSize);
   }
-  // Consumes `frames` per-frame sums from `perFrameSums[0]` (needs length >= `frames`); block-boundary accounting advances as if appended to one contiguous stream.
   push(perFrameSums, frames) {
     if (this.finalized) {
       throw new Error("BlockSumAccumulator: push() called after finalize()");
@@ -425,8 +438,8 @@ function getFftAddon(backend, options) {
 function interleave(samples, frames, channels) {
   const interleaved = new Float32Array(frames * channels);
   for (let frame = 0; frame < frames; frame++) {
-    for (let ch = 0; ch < channels; ch++) {
-      interleaved[frame * channels + ch] = samples[ch]?.[frame] ?? 0;
+    for (let channel = 0; channel < channels; channel++) {
+      interleaved[frame * channels + channel] = samples[channel]?.[frame] ?? 0;
     }
   }
   return interleaved;
@@ -435,14 +448,14 @@ function deinterleaveBuffer(buffer, channels) {
   const totalSamples = buffer.length / 4;
   const frames = Math.floor(totalSamples / channels);
   const result = [];
-  for (let ch = 0; ch < channels; ch++) {
+  for (let channel = 0; channel < channels; channel++) {
     result.push(new Float32Array(frames));
   }
   const view = new Float32Array(buffer.buffer, buffer.byteOffset, totalSamples);
   for (let frame = 0; frame < frames; frame++) {
-    for (let ch = 0; ch < channels; ch++) {
-      const channelArray = result[ch];
-      const value = view[frame * channels + ch];
+    for (let channel = 0; channel < channels; channel++) {
+      const channelArray = result[channel];
+      const value = view[frame * channels + channel];
       if (channelArray && value !== void 0) {
         channelArray[frame] = value;
       }
@@ -565,21 +578,61 @@ var KWeightedSquaredSum = class {
     }
   }
 };
-var LUFS_OFFSET = -0.691;
 var ABSOLUTE_GATE_LUFS = -70;
-var RELATIVE_GATE_OFFSET_LU = -10;
+var RELATIVE_GATE_OFFSET_LU = -20;
+var LOW_PERCENTILE = 0.1;
+var HIGH_PERCENTILE = 0.95;
+function getConsideredLoudness(shortTerm) {
+  const absoluteGated = [];
+  for (let index = 0; index < shortTerm.length; index++) {
+    const value = shortTerm[index] ?? 0;
+    if (value >= ABSOLUTE_GATE_LUFS) absoluteGated.push(value);
+  }
+  if (absoluteGated.length === 0) return [];
+  let absoluteSum = 0;
+  for (let index = 0; index < absoluteGated.length; index++) {
+    absoluteSum += Math.pow(10, (absoluteGated[index] ?? 0) / 10);
+  }
+  const relativeThreshold = 10 * Math.log10(absoluteSum / absoluteGated.length) + RELATIVE_GATE_OFFSET_LU;
+  const considered = [];
+  for (let index = 0; index < absoluteGated.length; index++) {
+    const value = absoluteGated[index] ?? 0;
+    if (value >= relativeThreshold) considered.push(value);
+  }
+  return considered;
+}
+function computeLoudnessRange(shortTerm) {
+  const considered = getConsideredLoudness(shortTerm);
+  if (considered.length < 2) return 0;
+  considered.sort((left, right) => left - right);
+  const lowIndex = Math.round((considered.length - 1) * LOW_PERCENTILE);
+  const highIndex = Math.round((considered.length - 1) * HIGH_PERCENTILE);
+  return (considered[highIndex] ?? 0) - (considered[lowIndex] ?? 0);
+}
+function getLraConsideredStats(shortTerm) {
+  const considered = getConsideredLoudness(shortTerm);
+  if (considered.length === 0) {
+    return { min: Number.POSITIVE_INFINITY, median: Number.POSITIVE_INFINITY };
+  }
+  considered.sort((left, right) => left - right);
+  const min = considered[0] ?? Number.POSITIVE_INFINITY;
+  const middleIndex = considered.length >> 1;
+  const median = considered.length % 2 === 1 ? considered[middleIndex] ?? Number.POSITIVE_INFINITY : ((considered[middleIndex - 1] ?? 0) + (considered[middleIndex] ?? 0)) / 2;
+  return { min, median };
+}
+var LUFS_OFFSET = -0.691;
+var ABSOLUTE_GATE_LUFS2 = -70;
+var RELATIVE_GATE_OFFSET_LU2 = -10;
 var BLOCK_DURATION_SECONDS = 0.4;
 var BLOCK_STEP_SECONDS = 0.1;
 var SHORT_TERM_BLOCK_DURATION_SECONDS = 3;
+var FILE_LRA_TAIL_SECONDS = 1.5;
+var FILE_LRA_TAIL_CHUNK_FRAMES = 8192;
 var POWER_FLOOR = 1e-10;
-var LRA_ABSOLUTE_GATE_LUFS = -70;
-var LRA_RELATIVE_GATE_OFFSET_LU = -20;
-var LRA_LOW_PERCENTILE = 0.1;
-var LRA_HIGH_PERCENTILE = 0.95;
 function applyBs1770Gating(closedBlockSums, blockSize) {
   const blockCount = closedBlockSums.length;
   if (blockCount === 0) return -Infinity;
-  const absoluteThresholdPower = Math.pow(10, (ABSOLUTE_GATE_LUFS - LUFS_OFFSET) / 10);
+  const absoluteThresholdPower = Math.pow(10, (ABSOLUTE_GATE_LUFS2 - LUFS_OFFSET) / 10);
   let absoluteSurvivorCount = 0;
   let absoluteSum = 0;
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
@@ -591,7 +644,7 @@ function applyBs1770Gating(closedBlockSums, blockSize) {
   }
   if (absoluteSurvivorCount === 0) return -Infinity;
   const absoluteMean = absoluteSum / absoluteSurvivorCount;
-  const relativeThresholdLufs = LUFS_OFFSET + 10 * Math.log10(absoluteMean) + RELATIVE_GATE_OFFSET_LU;
+  const relativeThresholdLufs = LUFS_OFFSET + 10 * Math.log10(absoluteMean) + RELATIVE_GATE_OFFSET_LU2;
   const relativeThresholdPower = Math.pow(10, (relativeThresholdLufs - LUFS_OFFSET) / 10);
   let relativeSurvivorCount = 0;
   let relativeSum = 0;
@@ -638,71 +691,11 @@ var IntegratedLufsAccumulator = class {
     return applyBs1770Gating(this.blocks.finalize(), this.blockSize);
   }
 };
-function computeLraFromShortTerm(shortTermLoudness) {
-  const absoluteGated = [];
-  for (let index = 0; index < shortTermLoudness.length; index++) {
-    const value = shortTermLoudness[index] ?? 0;
-    if (value > LRA_ABSOLUTE_GATE_LUFS) {
-      absoluteGated.push(value);
-    }
-  }
-  if (absoluteGated.length < 2) return 0;
-  let absoluteSum = 0;
-  for (let index = 0; index < absoluteGated.length; index++) {
-    absoluteSum += Math.pow(10, (absoluteGated[index] ?? 0) / 10);
-  }
-  const absoluteMean = absoluteSum / absoluteGated.length;
-  const relativeThreshold = 10 * Math.log10(absoluteMean) + LRA_RELATIVE_GATE_OFFSET_LU;
-  const relativeGated = [];
-  for (let index = 0; index < absoluteGated.length; index++) {
-    const value = absoluteGated[index] ?? 0;
-    if (value > relativeThreshold) {
-      relativeGated.push(value);
-    }
-  }
-  if (relativeGated.length < 2) return 0;
-  relativeGated.sort((lhs, rhs) => lhs - rhs);
-  const lowIndex = Math.floor(relativeGated.length * LRA_LOW_PERCENTILE);
-  const highIndex = Math.min(Math.ceil(relativeGated.length * LRA_HIGH_PERCENTILE) - 1, relativeGated.length - 1);
-  return (relativeGated[highIndex] ?? 0) - (relativeGated[lowIndex] ?? 0);
-}
-function getLraConsideredStats(shortTerm) {
-  const aboveAbsolute = [];
-  for (let index = 0; index < shortTerm.length; index++) {
-    const lufs = shortTerm[index] ?? 0;
-    if (lufs > LRA_ABSOLUTE_GATE_LUFS) {
-      aboveAbsolute.push(lufs);
-    }
-  }
-  if (aboveAbsolute.length === 0) {
-    return { min: Number.POSITIVE_INFINITY, median: Number.POSITIVE_INFINITY };
-  }
-  let absoluteSum = 0;
-  for (let index = 0; index < aboveAbsolute.length; index++) {
-    absoluteSum += Math.pow(10, (aboveAbsolute[index] ?? 0) / 10);
-  }
-  const absoluteMean = absoluteSum / aboveAbsolute.length;
-  const relativeThreshold = 10 * Math.log10(absoluteMean) + LRA_RELATIVE_GATE_OFFSET_LU;
-  const considered = [];
-  for (let index = 0; index < aboveAbsolute.length; index++) {
-    const lufs = aboveAbsolute[index] ?? 0;
-    if (lufs > relativeThreshold) {
-      considered.push(lufs);
-    }
-  }
-  if (considered.length === 0) {
-    return { min: Number.POSITIVE_INFINITY, median: Number.POSITIVE_INFINITY };
-  }
-  considered.sort((left, right) => left - right);
-  const min = considered[0] ?? Number.POSITIVE_INFINITY;
-  const middleIndex = considered.length >> 1;
-  const median = considered.length % 2 === 1 ? considered[middleIndex] ?? Number.POSITIVE_INFINITY : ((considered[middleIndex - 1] ?? 0) + (considered[middleIndex] ?? 0)) / 2;
-  return { min, median };
-}
 var LoudnessAccumulator = class {
   constructor(sampleRate, channelCount, channelWeights) {
     this.outputBuffer = new Float64Array(0);
     this.finalized = false;
+    this.sourceFrames = 0;
     if (channelCount <= 0) {
       throw new Error(`LoudnessAccumulator: channelCount must be positive, got ${channelCount}`);
     }
@@ -711,10 +704,12 @@ var LoudnessAccumulator = class {
     }
     this.blockSize400 = Math.round(BLOCK_DURATION_SECONDS * sampleRate);
     this.blockSize3s = Math.round(SHORT_TERM_BLOCK_DURATION_SECONDS * sampleRate);
-    const blockStep = Math.round(BLOCK_STEP_SECONDS * sampleRate);
+    this.blockStep = Math.round(BLOCK_STEP_SECONDS * sampleRate);
+    this.sampleRate = sampleRate;
+    this.channelCount = channelCount;
     this.kw = new KWeightedSquaredSum(sampleRate, channelCount, channelWeights);
-    this.blocks400 = new BlockSumAccumulator(this.blockSize400, blockStep);
-    this.blocks3s = new BlockSumAccumulator(this.blockSize3s, blockStep);
+    this.blocks400 = new BlockSumAccumulator(this.blockSize400, this.blockStep);
+    this.blocks3s = new BlockSumAccumulator(this.blockSize3s, this.blockStep);
   }
   push(channels, frames) {
     if (this.finalized) {
@@ -727,10 +722,23 @@ var LoudnessAccumulator = class {
     this.kw.push(channels, frames, this.outputBuffer);
     this.blocks400.push(this.outputBuffer, frames);
     this.blocks3s.push(this.outputBuffer, frames);
+    this.sourceFrames += frames;
   }
   finalize() {
     if (this.cachedResult !== void 0) return this.cachedResult;
     this.finalized = true;
+    const sourceShortTermCount = this.sourceFrames < this.blockSize3s ? 0 : Math.floor((this.sourceFrames - this.blockSize3s) / this.blockStep) + 1;
+    const tailFrames = Math.round(FILE_LRA_TAIL_SECONDS * this.sampleRate);
+    const tailChunkFrames = Math.min(FILE_LRA_TAIL_CHUNK_FRAMES, tailFrames);
+    const zeroChannels = Array.from({ length: this.channelCount }, () => new Float32Array(tailChunkFrames));
+    let remainingTailFrames = tailFrames;
+    while (remainingTailFrames > 0) {
+      const frames = Math.min(remainingTailFrames, tailChunkFrames);
+      if (this.outputBuffer.length < frames) this.outputBuffer = new Float64Array(frames);
+      this.kw.push(zeroChannels, frames, this.outputBuffer);
+      this.blocks3s.push(this.outputBuffer, frames);
+      remainingTailFrames -= frames;
+    }
     const closed400 = this.blocks400.finalize();
     const closed3s = this.blocks3s.finalize();
     const blockSize400 = this.blockSize400;
@@ -740,19 +748,23 @@ var LoudnessAccumulator = class {
       const sum = closed400[index] ?? 0;
       momentary[index] = LUFS_OFFSET + 10 * Math.log10(Math.max(sum / blockSize400, POWER_FLOOR));
     }
-    const shortTerm = new Array(closed3s.length);
+    const fileShortTerm = new Array(closed3s.length);
     for (let index = 0; index < closed3s.length; index++) {
       const sum = closed3s[index] ?? 0;
-      shortTerm[index] = LUFS_OFFSET + 10 * Math.log10(Math.max(sum / blockSize3s, POWER_FLOOR));
+      fileShortTerm[index] = LUFS_OFFSET + 10 * Math.log10(Math.max(sum / blockSize3s, POWER_FLOOR));
     }
+    const shortTerm = fileShortTerm.slice(0, sourceShortTermCount);
     const integrated = applyBs1770Gating(closed400, blockSize400);
-    const range = computeLraFromShortTerm(shortTerm);
+    const range = computeLoudnessRange(fileShortTerm);
     this.cachedResult = { integrated, momentary, shortTerm, range };
     return this.cachedResult;
   }
 };
 var MixedRadixFft = class {
   constructor(size) {
+    if (!Number.isSafeInteger(size) || size <= 0) {
+      throw new Error(`MixedRadixFft: size must be a positive integer, got ${size}`);
+    }
     this.size = size;
     this.radices = factorize(size);
     this.frameRe = new Float32Array(size);
@@ -766,6 +778,7 @@ var MixedRadixFft = class {
     this.twiddleIm = twiddleIm;
   }
   fft(xRe, xIm, outRe, outIm) {
+    this.assertArrayCapacities(xRe, xIm, outRe, outIm);
     const perm = this.permutation;
     const nn = this.size;
     for (let index = 0; index < nn; index++) {
@@ -788,6 +801,7 @@ var MixedRadixFft = class {
     }
   }
   ifft(xRe, xIm, outRe, outIm) {
+    this.assertArrayCapacities(xRe, xIm, outRe, outIm);
     const auxIm = this.auxIm;
     const nn = this.size;
     for (let index = 0; index < nn; index++) {
@@ -799,6 +813,17 @@ var MixedRadixFft = class {
       outIm[index] = -(outIm[index] ?? 0) / nn;
     }
   }
+  assertArrayCapacities(xRe, xIm, outRe, outIm) {
+    this.assertArrayCapacity("xRe", xRe);
+    this.assertArrayCapacity("xIm", xIm);
+    this.assertArrayCapacity("outRe", outRe);
+    this.assertArrayCapacity("outIm", outIm);
+  }
+  assertArrayCapacity(name, values) {
+    if (values.length < this.size) {
+      throw new Error(`MixedRadixFft: ${name} capacity must be at least ${this.size}, got ${values.length}`);
+    }
+  }
   radix2(outRe, outIm, nn, groupSize, subSize, twOffset) {
     for (let group = 0; group < nn; group += groupSize) {
       for (let ni = 0; ni < subSize; ni++) {
@@ -936,11 +961,11 @@ function factorize(size) {
   if (remaining !== 1) {
     throw new Error(`MixedRadixFft: size ${size} has unsupported prime factor ${remaining} (only 2, 3, 5 supported)`);
   }
-  factors.sort((lhs, rhs) => lhs - rhs);
+  factors.sort((firstFactor, secondFactor) => firstFactor - secondFactor);
   return factors;
 }
 function computePermutation(size, radices) {
-  const permutation = new Uint16Array(size);
+  const permutation = new Uint32Array(size);
   for (let index = 0; index < size; index++) {
     let remainder = index;
     let permuted = 0;
@@ -980,202 +1005,6 @@ function computeTwiddles(radices) {
   }
   return { twiddleRe, twiddleIm };
 }
-var STDERR_CAP_BYTES = 64 * 1024;
-var ResampleStream = class {
-  constructor(ffmpegPath, options) {
-    this.chunks = [];
-    this.chunkedBytes = 0;
-    this.stdoutEnded = false;
-    this.exited = false;
-    this.stderr = "";
-    this.closed = false;
-    const { sourceSampleRate, targetSampleRate, channels } = options;
-    if (channels <= 0) throw new Error(`ResampleStream: channels must be > 0, got ${String(channels)}`);
-    if (sourceSampleRate <= 0) throw new Error(`ResampleStream: sourceSampleRate must be > 0, got ${String(sourceSampleRate)}`);
-    if (targetSampleRate <= 0) throw new Error(`ResampleStream: targetSampleRate must be > 0, got ${String(targetSampleRate)}`);
-    this.channels = channels;
-    this.bytesPerFrame = channels * 4;
-    const args = [
-      "-f",
-      "f32le",
-      "-ar",
-      String(sourceSampleRate),
-      "-ac",
-      String(channels),
-      "-i",
-      "pipe:0",
-      "-af",
-      `aresample=${String(targetSampleRate)}:resampler=soxr:dither_method=triangular`,
-      "-f",
-      "f32le",
-      "-ar",
-      String(targetSampleRate),
-      "-ac",
-      String(channels),
-      "pipe:1"
-    ];
-    this.child = spawn(ffmpegPath, args, { stdio: ["pipe", "pipe", "pipe"] });
-    this.child.stdout.on("data", (bytes) => this.onStdoutData(bytes));
-    this.child.stdout.once("end", () => this.onStdoutEnd());
-    this.child.stderr.on("data", (bytes) => this.onStderrData(bytes));
-    this.child.on("error", (error) => this.onExit(error));
-    this.child.once("exit", (code) => {
-      if (code !== null && code !== 0) {
-        const detail = this.stderr ? `: ${this.stderr.slice(0, 1024)}` : "";
-        this.onExit(new Error(`ffmpeg exited ${String(code)}${detail}`));
-        return;
-      }
-      this.onExit();
-    });
-    this.child.stdin.on("error", (error) => {
-      if (error.code === "EPIPE") return;
-      this.exitError ?? (this.exitError = error);
-    });
-  }
-  async write(samples) {
-    if (this.closed) throw new Error("ResampleStream: write after close");
-    if (this.exitError) throw this.exitError;
-    const frames = samples[0]?.length ?? 0;
-    if (frames === 0) return;
-    const interleaved = interleave(samples, frames, this.channels);
-    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
-    if (this.pendingDrain) await this.pendingDrain;
-    const ok = this.child.stdin.write(buf);
-    if (!ok) {
-      this.pendingDrain = new Promise((resolve) => {
-        this.child.stdin.once("drain", () => {
-          this.pendingDrain = void 0;
-          resolve();
-        });
-      });
-    }
-  }
-  async read(frames) {
-    if (this.closed) throw new Error("ResampleStream: read after close");
-    if (frames <= 0) return this.emptyChannels();
-    if (this.pendingRead) throw new Error("ResampleStream: concurrent read");
-    if (this.chunkedBytes >= this.bytesPerFrame) return this.drainOutput(frames);
-    if (this.exitError) throw this.exitError;
-    if (this.stdoutEnded && this.exited) return this.emptyChannels();
-    return new Promise((resolve, reject) => {
-      this.pendingRead = { resolve, reject, frames };
-      this.maybeSatisfyPendingRead();
-    });
-  }
-  async end() {
-    if (this.closed) return;
-    if (this.pendingDrain) await this.pendingDrain;
-    if (!this.child.stdin.writableEnded) this.child.stdin.end();
-  }
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    if (this.pendingRead) {
-      this.pendingRead.reject(new Error("ResampleStream: close while read pending"));
-      this.pendingRead = void 0;
-    }
-    try {
-      if (!this.child.stdin.writableEnded) {
-        try {
-          this.child.stdin.end();
-        } catch {
-        }
-      }
-    } finally {
-      if (!this.exited && this.child.exitCode === null && !this.child.killed) {
-        this.child.kill("SIGTERM");
-      }
-    }
-    if (!this.exited) {
-      await new Promise((resolve) => {
-        let settled = false;
-        const settle = () => {
-          if (!settled) {
-            settled = true;
-            resolve();
-          }
-        };
-        const timeout = setTimeout(() => {
-          this.child.kill("SIGKILL");
-          settle();
-        }, 5e3);
-        this.child.once("exit", () => {
-          clearTimeout(timeout);
-          settle();
-        });
-      });
-    }
-  }
-  onStdoutData(bytes) {
-    if (bytes.length > 0) {
-      this.chunks.push(bytes);
-      this.chunkedBytes += bytes.length;
-    }
-    this.maybeSatisfyPendingRead();
-  }
-  onStdoutEnd() {
-    this.stdoutEnded = true;
-    this.maybeSatisfyPendingRead();
-  }
-  onStderrData(bytes) {
-    if (this.stderr.length >= STDERR_CAP_BYTES) return;
-    const remaining = STDERR_CAP_BYTES - this.stderr.length;
-    const text = bytes.toString("utf8");
-    this.stderr += text.length > remaining ? text.slice(0, remaining) : text;
-  }
-  onExit(error) {
-    this.exited = true;
-    if (error) this.exitError ?? (this.exitError = error);
-    this.maybeSatisfyPendingRead();
-  }
-  maybeSatisfyPendingRead() {
-    if (!this.pendingRead) return;
-    const { frames, resolve, reject } = this.pendingRead;
-    if (this.chunkedBytes >= this.bytesPerFrame) {
-      this.pendingRead = void 0;
-      resolve(this.drainOutput(frames));
-      return;
-    }
-    if (this.stdoutEnded && this.exited) {
-      this.pendingRead = void 0;
-      if (this.exitError) {
-        reject(this.exitError);
-        return;
-      }
-      resolve(this.emptyChannels());
-    }
-  }
-  drainOutput(frames) {
-    const wantBytes = frames * this.bytesPerFrame;
-    const available = Math.min(this.chunkedBytes, wantBytes);
-    const completeFrames = Math.floor(available / this.bytesPerFrame);
-    if (completeFrames === 0) return this.emptyChannels();
-    const completeBytes = completeFrames * this.bytesPerFrame;
-    const aligned = Buffer.allocUnsafe(completeBytes);
-    let written = 0;
-    while (written < completeBytes) {
-      const head = this.chunks[0];
-      if (!head) break;
-      const remaining = completeBytes - written;
-      if (head.length <= remaining) {
-        head.copy(aligned, written, 0, head.length);
-        written += head.length;
-        this.chunks.shift();
-        continue;
-      }
-      head.copy(aligned, written, 0, remaining);
-      this.chunks[0] = head.subarray(remaining);
-      written += remaining;
-    }
-    this.chunkedBytes -= completeBytes;
-    return deinterleaveBuffer(aligned, this.channels);
-  }
-  emptyChannels() {
-    const out = [];
-    for (let ch = 0; ch < this.channels; ch++) out.push(new Float32Array(0));
-    return out;
-  }
-};
 var SlidingWindowMaxStream = class {
   constructor(halfWidth) {
     this.dequeHead = 0;
@@ -1314,48 +1143,111 @@ var SlidingWindowMinStream = class {
     return output;
   }
 };
-var batchInputCache = /* @__PURE__ */ new Map();
-function getBatchInput(fftSize, numFrames) {
-  const needed = fftSize * numFrames;
-  const cached = batchInputCache.get(fftSize);
-  if (cached && cached.length >= needed) return cached;
-  const grown = new Float32Array(needed);
-  batchInputCache.set(fftSize, grown);
-  return grown;
+var ByteBoundedCache = class {
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+    this.entries = /* @__PURE__ */ new Map();
+    this.currentBytes = 0;
+    assertPositiveInteger(maxBytes, "ByteBoundedCache maxBytes");
+  }
+  get bytes() {
+    return this.currentBytes;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(key) {
+    return this.entries.get(key)?.value;
+  }
+  set(key, value, bytes) {
+    assertPositiveInteger(bytes, "ByteBoundedCache entry bytes");
+    const replaced = this.entries.get(key);
+    if (replaced !== void 0) {
+      this.entries.delete(key);
+      this.currentBytes -= replaced.bytes;
+    }
+    if (bytes > this.maxBytes) return;
+    while (this.currentBytes + bytes > this.maxBytes) {
+      const oldest = this.entries.entries().next();
+      if (oldest.done) break;
+      const [oldestKey, oldestEntry] = oldest.value;
+      this.entries.delete(oldestKey);
+      this.currentBytes -= oldestEntry.bytes;
+    }
+    this.entries.set(key, { value, bytes });
+    this.currentBytes += bytes;
+  }
+};
+function assertPositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive finite integer, got ${value}`);
+  }
+}
+function assertRadix2Size(size) {
+  if (!Number.isSafeInteger(size) || size <= 0 || !Number.isInteger(Math.log2(size))) {
+    throw new Error(`FFT size must be a positive power-of-two integer, got ${size}`);
+  }
+}
+function assertPositiveInteger2(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer, got ${value}`);
+  }
 }
-var batchTimeCache = /* @__PURE__ */ new Map();
-function getBatchTime(fftSize, numFrames) {
-  const needed = fftSize * numFrames;
-  const cached = batchTimeCache.get(fftSize);
-  if (cached && cached.length >= needed) return cached;
-  const grown = new Float32Array(needed);
-  batchTimeCache.set(fftSize, grown);
-  return grown;
+function assertNonnegativeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${name} must be a nonnegative integer, got ${value}`);
+  }
 }
+var STFT_BATCH_SCRATCH_BYTES = 8 * 1024 * 1024;
+var HANN_WINDOW_CACHE_BYTES = 1024 * 1024;
+var TWIDDLE_CACHE_BYTES = 8 * 1024 * 1024;
 function stft(signal, fftSize, hopSize, output, backend, fftAddonOptions) {
-  const window = hanningWindow(fftSize);
-  const numFrames = Math.floor((signal.length - fftSize) / hopSize) + 1;
-  const halfSize = fftSize / 2 + 1;
-  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
-  const real = output?.real ?? (numFrames > 0 ? new Float32Array(halfSize * numFrames) : new Float32Array(0));
-  const imag = output?.imag ?? (numFrames > 0 ? new Float32Array(halfSize * numFrames) : new Float32Array(0));
+  assertRadix2Size(fftSize);
+  assertPositiveInteger2(hopSize, "STFT hopSize");
+  const numFrames = signal.length < fftSize ? 0 : Math.floor((signal.length - fftSize) / hopSize) + 1;
+  const halfSize = Math.floor(fftSize / 2) + 1;
+  const outputLength = halfSize * numFrames;
+  if (output !== void 0 && (output.real.length < outputLength || output.imag.length < outputLength)) {
+    throw new Error(`STFT output capacity must be at least ${outputLength} values per component`);
+  }
   if (numFrames <= 0) {
-    return { real, imag, frames: 0, fftSize };
+    const real2 = output?.real ?? new Float32Array(0);
+    const imag2 = output?.imag ?? new Float32Array(0);
+    return { real: real2, imag: imag2, frames: 0, fftSize };
   }
+  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
+  let slabFrameCapacity = 0;
   if (addon) {
-    const batchInput = getBatchInput(fftSize, numFrames);
-    for (let frame = 0; frame < numFrames; frame++) {
-      const offset = frame * hopSize;
-      for (let index = 0; index < fftSize; index++) {
-        batchInput[frame * fftSize + index] = (signal[offset + index] ?? 0) * (window[index] ?? 0);
-      }
+    const bytesPerFrame = Float32Array.BYTES_PER_ELEMENT * (fftSize + 2 * halfSize);
+    if (bytesPerFrame > STFT_BATCH_SCRATCH_BYTES) {
+      throw new Error(`STFT fftSize ${fftSize} exceeds the ${STFT_BATCH_SCRATCH_BYTES}-byte native scratch budget`);
     }
-    if (typeof addon.batchFftInto === "function") {
-      addon.batchFftInto(batchInput.subarray(0, fftSize * numFrames), real.subarray(0, halfSize * numFrames), imag.subarray(0, halfSize * numFrames), fftSize, numFrames);
-    } else {
-      const { re: batchRe, im: batchIm } = addon.batchFft(batchInput.subarray(0, fftSize * numFrames), fftSize, numFrames);
-      real.set(batchRe.subarray(0, halfSize * numFrames));
-      imag.set(batchIm.subarray(0, halfSize * numFrames));
+    slabFrameCapacity = Math.max(1, Math.floor(STFT_BATCH_SCRATCH_BYTES / bytesPerFrame));
+  }
+  const real = output?.real ?? new Float32Array(outputLength);
+  const imag = output?.imag ?? new Float32Array(outputLength);
+  const window = hanningWindow(fftSize);
+  if (addon) {
+    for (let firstFrame = 0; firstFrame < numFrames; firstFrame += slabFrameCapacity) {
+      const slabFrames = Math.min(slabFrameCapacity, numFrames - firstFrame);
+      const batchInput = new Float32Array(fftSize * slabFrames);
+      for (let slabFrame = 0; slabFrame < slabFrames; slabFrame++) {
+        const offset = (firstFrame + slabFrame) * hopSize;
+        for (let index = 0; index < fftSize; index++) {
+          batchInput[slabFrame * fftSize + index] = (signal[offset + index] ?? 0) * (window[index] ?? 0);
+        }
+      }
+      const outputStart = firstFrame * halfSize;
+      const outputEnd = outputStart + slabFrames * halfSize;
+      const realSlab = real.subarray(outputStart, outputEnd);
+      const imagSlab = imag.subarray(outputStart, outputEnd);
+      if (typeof addon.batchFftInto === "function") {
+        addon.batchFftInto(batchInput, realSlab, imagSlab, fftSize, slabFrames);
+      } else {
+        const { re: batchReal, im: batchImag } = addon.batchFft(batchInput, fftSize, slabFrames);
+        realSlab.set(batchReal.subarray(0, realSlab.length));
+        imagSlab.set(batchImag.subarray(0, imagSlab.length));
+      }
     }
     return { real, imag, frames: numFrames, fftSize };
   }
@@ -1377,29 +1269,49 @@ function stft(signal, fftSize, hopSize, output, backend, fftAddonOptions) {
 }
 function istft(result, hopSize, outputLength, backend, fftAddonOptions) {
   const { real, imag, frames, fftSize } = result;
+  assertRadix2Size(fftSize);
+  assertPositiveInteger2(hopSize, "ISTFT hopSize");
+  assertNonnegativeInteger(outputLength, "ISTFT outputLength");
+  assertNonnegativeInteger(frames, "ISTFT frames");
+  const halfSize = Math.floor(fftSize / 2) + 1;
+  const spectrumLength = halfSize * frames;
+  if (!Number.isSafeInteger(spectrumLength) || real.length < spectrumLength || imag.length < spectrumLength) {
+    throw new Error(`ISTFT spectrum capacity must be at least ${spectrumLength} values per component`);
+  }
+  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
+  let slabFrameCapacity = 0;
+  if (addon && frames > 0) {
+    const bytesPerFrame = Float32Array.BYTES_PER_ELEMENT * fftSize;
+    if (bytesPerFrame > STFT_BATCH_SCRATCH_BYTES) {
+      throw new Error(`ISTFT fftSize ${fftSize} exceeds the ${STFT_BATCH_SCRATCH_BYTES}-byte native scratch budget`);
+    }
+    slabFrameCapacity = Math.max(1, Math.floor(STFT_BATCH_SCRATCH_BYTES / bytesPerFrame));
+  }
   const window = hanningWindow(fftSize);
   const output = new Float32Array(outputLength);
   const windowSum = new Float32Array(outputLength);
-  const halfSize = fftSize / 2 + 1;
-  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
   if (addon && frames > 0) {
-    const reView = real.subarray(0, halfSize * frames);
-    const imView = imag.subarray(0, halfSize * frames);
-    let timeDomainBatch;
-    if (typeof addon.batchIfftInto === "function") {
-      const batchTime = getBatchTime(fftSize, frames);
-      addon.batchIfftInto(reView, imView, batchTime.subarray(0, fftSize * frames), fftSize, frames);
-      timeDomainBatch = batchTime;
-    } else {
-      timeDomainBatch = addon.batchIfft(reView, imView, fftSize, frames);
-    }
-    for (let frame = 0; frame < frames; frame++) {
-      const offset = frame * hopSize;
-      for (let index = 0; index < fftSize; index++) {
-        const pos = offset + index;
-        if (pos < outputLength) {
-          output[pos] = (output[pos] ?? 0) + (timeDomainBatch[frame * fftSize + index] ?? 0) * (window[index] ?? 0);
-          windowSum[pos] = (windowSum[pos] ?? 0) + (window[index] ?? 0) * (window[index] ?? 0);
+    for (let firstFrame = 0; firstFrame < frames; firstFrame += slabFrameCapacity) {
+      const slabFrames = Math.min(slabFrameCapacity, frames - firstFrame);
+      const spectrumStart = firstFrame * halfSize;
+      const spectrumEnd = spectrumStart + slabFrames * halfSize;
+      const realSlab = real.subarray(spectrumStart, spectrumEnd);
+      const imagSlab = imag.subarray(spectrumStart, spectrumEnd);
+      let timeDomainSlab;
+      if (typeof addon.batchIfftInto === "function") {
+        timeDomainSlab = new Float32Array(fftSize * slabFrames);
+        addon.batchIfftInto(realSlab, imagSlab, timeDomainSlab, fftSize, slabFrames);
+      } else {
+        timeDomainSlab = addon.batchIfft(realSlab, imagSlab, fftSize, slabFrames);
+      }
+      for (let slabFrame = 0; slabFrame < slabFrames; slabFrame++) {
+        const offset = (firstFrame + slabFrame) * hopSize;
+        for (let index = 0; index < fftSize; index++) {
+          const position = offset + index;
+          if (position < outputLength) {
+            output[position] = (output[position] ?? 0) + (timeDomainSlab[slabFrame * fftSize + index] ?? 0) * (window[index] ?? 0);
+            windowSum[position] = (windowSum[position] ?? 0) + (window[index] ?? 0) * (window[index] ?? 0);
+          }
         }
       }
     }
@@ -1438,20 +1350,27 @@ function istft(result, hopSize, outputLength, backend, fftAddonOptions) {
   }
   return output;
 }
-var hanningWindowCache = /* @__PURE__ */ new Map();
+var hanningWindowCache = new ByteBoundedCache(HANN_WINDOW_CACHE_BYTES);
 function hanningWindow(size, periodic = true) {
+  assertPositiveInteger2(size, "Hann window size");
   const key = `${size}:${periodic ? "p" : "s"}`;
   const cached = hanningWindowCache.get(key);
   if (cached) return cached;
   const window = new Float32Array(size);
+  if (size === 1) {
+    window[0] = 1;
+    hanningWindowCache.set(key, window, window.byteLength);
+    return window;
+  }
   const denominator = periodic ? size : size - 1;
   for (let index = 0; index < size; index++) {
     window[index] = 0.5 * (1 - Math.cos(2 * Math.PI * index / denominator));
   }
-  hanningWindowCache.set(key, window);
+  hanningWindowCache.set(key, window, window.byteLength);
   return window;
 }
 function createFftWorkspace(size) {
+  assertRadix2Size(size);
   return {
     re: new Float32Array(size),
     im: new Float32Array(size),
@@ -1461,6 +1380,8 @@ function createFftWorkspace(size) {
 }
 function fft(input, workspace) {
   const size = input.length;
+  assertRadix2Size(size);
+  if (workspace !== void 0) assertWorkspaceCapacity(workspace, size);
   const re = workspace ? workspace.re : new Float32Array(size);
   const im = workspace ? workspace.im : new Float32Array(size);
   re.set(input);
@@ -1472,6 +1393,9 @@ function fft(input, workspace) {
 }
 function ifft(re, im, workspace) {
   const size = re.length;
+  assertRadix2Size(size);
+  if (im.length !== size) throw new Error(`IFFT real and imaginary lengths must match, got ${size} and ${im.length}`);
+  if (workspace !== void 0) assertWorkspaceCapacity(workspace, size);
   const outRe = workspace ? workspace.outRe : Float32Array.from(re);
   const outIm = workspace ? workspace.outIm : new Float32Array(size);
   if (workspace) outRe.set(re);
@@ -1486,6 +1410,8 @@ function ifft(re, im, workspace) {
   return outRe;
 }
 function bitReverse(re, im, size) {
+  assertRadix2Size(size);
+  assertComplexCapacity(re, im, size, "bitReverse");
   let rev = 0;
   for (let index = 0; index < size - 1; index++) {
     if (index < rev) {
@@ -1504,11 +1430,11 @@ function bitReverse(re, im, size) {
     rev += bit;
   }
 }
-var twiddleCache = /* @__PURE__ */ new Map();
+var twiddleCache = new ByteBoundedCache(TWIDDLE_CACHE_BYTES);
 function getTwiddleFactors(size) {
   let cached = twiddleCache.get(size);
   if (cached) return cached;
-  const totalFactors = size / 2 * Math.log2(size);
+  const totalFactors = size - 1;
   const twRe = new Float32Array(totalFactors);
   const twIm = new Float32Array(totalFactors);
   let offset = 0;
@@ -1522,10 +1448,14 @@ function getTwiddleFactors(size) {
     offset += halfStep;
   }
   cached = { re: twRe, im: twIm };
-  twiddleCache.set(size, cached);
+  if (twRe.byteLength > 0) {
+    twiddleCache.set(size, cached, twRe.byteLength + twIm.byteLength);
+  }
   return cached;
 }
 function butterflyStages(re, im, size) {
+  assertRadix2Size(size);
+  assertComplexCapacity(re, im, size, "butterflyStages");
   const twiddle = getTwiddleFactors(size);
   const twRe = twiddle.re;
   const twIm = twiddle.im;
@@ -1553,55 +1483,99 @@ function butterflyStages(re, im, size) {
     twOffset += halfStep;
   }
 }
+function assertWorkspaceCapacity(workspace, size) {
+  assertWorkspaceArrayCapacity("re", workspace.re, size);
+  assertWorkspaceArrayCapacity("im", workspace.im, size);
+  assertWorkspaceArrayCapacity("outRe", workspace.outRe, size);
+  assertWorkspaceArrayCapacity("outIm", workspace.outIm, size);
+}
+function assertWorkspaceArrayCapacity(name, values, size) {
+  if (values.length < size) {
+    throw new Error(`FFT workspace ${name} capacity must be at least ${size}, got ${values.length}`);
+  }
+}
+function assertComplexCapacity(re, im, size, operation) {
+  if (re.length < size || im.length < size) {
+    throw new Error(`${operation} complex-array capacity must be at least ${size}`);
+  }
+}
 var TAPS_PER_PHASE_4X = 12;
 var HISTORY_LENGTH_4X = TAPS_PER_PHASE_4X;
-var P1T0 = 0.001708984375;
-var P1T1 = 0.010986328125;
-var P1T2 = -0.0196533203125;
-var P1T3 = 0.033203125;
-var P1T4 = -0.0594482421875;
-var P1T5 = 0.1373291015625;
-var P1T6 = 0.97216796875;
-var P1T7 = -0.102294921875;
-var P1T8 = 0.047607421875;
-var P1T9 = -0.026611328125;
-var P1T10 = 0.014892578125;
-var P1T11 = -0.00830078125;
-var P2T0 = -0.0291748046875;
-var P2T1 = 0.029296875;
-var P2T2 = -0.0517578125;
-var P2T3 = 0.089111328125;
-var P2T4 = -0.16650390625;
-var P2T5 = 0.465087890625;
-var P2T6 = 0.77978515625;
-var P2T7 = -0.2003173828125;
-var P2T8 = 0.1015625;
-var P2T9 = -0.0582275390625;
-var P2T10 = 0.0330810546875;
-var P2T11 = -0.0189208984375;
-var P3T0 = -0.0189208984375;
-var P3T1 = 0.0330810546875;
-var P3T2 = -0.0582275390625;
-var P3T3 = 0.1015625;
-var P3T4 = -0.2003173828125;
-var P3T5 = 0.77978515625;
-var P3T6 = 0.465087890625;
-var P3T7 = -0.16650390625;
-var P3T8 = 0.089111328125;
-var P3T9 = -0.0517578125;
-var P3T10 = 0.029296875;
-var P3T11 = -0.0291748046875;
+var FLUSH_INPUT_4X = new Float32Array(TAPS_PER_PHASE_4X - 1);
+var P0T0 = 0.001708984375;
+var P0T1 = 0.010986328125;
+var P0T2 = -0.0196533203125;
+var P0T3 = 0.033203125;
+var P0T4 = -0.0594482421875;
+var P0T5 = 0.1373291015625;
+var P0T6 = 0.97216796875;
+var P0T7 = -0.102294921875;
+var P0T8 = 0.047607421875;
+var P0T9 = -0.026611328125;
+var P0T10 = 0.014892578125;
+var P0T11 = -0.00830078125;
+var P1T0 = -0.0291748046875;
+var P1T1 = 0.029296875;
+var P1T2 = -0.0517578125;
+var P1T3 = 0.089111328125;
+var P1T4 = -0.16650390625;
+var P1T5 = 0.465087890625;
+var P1T6 = 0.77978515625;
+var P1T7 = -0.2003173828125;
+var P1T8 = 0.1015625;
+var P1T9 = -0.0582275390625;
+var P1T10 = 0.0330810546875;
+var P1T11 = -0.0189208984375;
+var P2T0 = -0.0189208984375;
+var P2T1 = 0.0330810546875;
+var P2T2 = -0.0582275390625;
+var P2T3 = 0.1015625;
+var P2T4 = -0.2003173828125;
+var P2T5 = 0.77978515625;
+var P2T6 = 0.465087890625;
+var P2T7 = -0.16650390625;
+var P2T8 = 0.089111328125;
+var P2T9 = -0.0517578125;
+var P2T10 = 0.029296875;
+var P2T11 = -0.0291748046875;
+var P3T0 = -0.00830078125;
+var P3T1 = 0.014892578125;
+var P3T2 = -0.026611328125;
+var P3T3 = 0.047607421875;
+var P3T4 = -0.102294921875;
+var P3T5 = 0.97216796875;
+var P3T6 = 0.1373291015625;
+var P3T7 = -0.0594482421875;
+var P3T8 = 0.033203125;
+var P3T9 = -0.0196533203125;
+var P3T10 = 0.010986328125;
+var P3T11 = 0.001708984375;
 var TruePeakUpsampler = class {
   constructor(factor = 4) {
     this.work = new Float64Array(0);
+    this.flushed = false;
     if (factor !== 4) {
-      throw new Error(`TruePeakUpsampler: factor ${factor} is not yet implemented; only 4\xD7 (BS.1770-4 Annex 1) is supported`);
+      throw new Error(`TruePeakUpsampler: factor ${factor} is not yet implemented; only 4\xD7 (BS.1770-5 Annex 2) is supported`);
     }
     this.factor = factor;
     this.history = new Float64Array(HISTORY_LENGTH_4X);
   }
-  // `outputScratch` (>= input.length × factor) avoids the per-call allocation; the returned view aliases it.
   upsample(input, outputScratch) {
+    if (this.flushed) throw new Error("TruePeakUpsampler: upsample after flush; call reset() first");
+    return this.process(input, outputScratch);
+  }
+  flush(outputScratch) {
+    if (this.flushed) return new Float32Array(0);
+    const output = this.process(FLUSH_INPUT_4X, outputScratch);
+    this.flushed = true;
+    return output;
+  }
+  reset() {
+    this.history.fill(0);
+    this.work = new Float64Array(0);
+    this.flushed = false;
+  }
+  process(input, outputScratch) {
     const factor = this.factor;
     const inputLength = input.length;
     const outputLength = inputLength * factor;
@@ -1614,67 +1588,80 @@ var TruePeakUpsampler = class {
     }
     const work = this.work;
     work.set(history, 0);
-    for (let inIdx = 0; inIdx < inputLength; inIdx++) {
-      work[historyLength + inIdx] = input[inIdx] ?? 0;
-    }
-    for (let inIdx = 0; inIdx < inputLength; inIdx++) {
-      const currentIdx = historyLength + inIdx;
-      const outOffset = inIdx * factor;
-      output[outOffset] = input[inIdx] ?? 0;
-      const v0 = work[currentIdx] ?? 0;
-      const v1 = work[currentIdx - 1] ?? 0;
-      const v2 = work[currentIdx - 2] ?? 0;
-      const v3 = work[currentIdx - 3] ?? 0;
-      const v4 = work[currentIdx - 4] ?? 0;
-      const v5 = work[currentIdx - 5] ?? 0;
-      const v6 = work[currentIdx - 6] ?? 0;
-      const v7 = work[currentIdx - 7] ?? 0;
-      const v8 = work[currentIdx - 8] ?? 0;
-      const v9 = work[currentIdx - 9] ?? 0;
-      const v10 = work[currentIdx - 10] ?? 0;
-      const v11 = work[currentIdx - 11] ?? 0;
-      let acc1 = 0;
-      acc1 += P1T0 * v0;
-      acc1 += P1T1 * v1;
-      acc1 += P1T2 * v2;
-      acc1 += P1T3 * v3;
-      acc1 += P1T4 * v4;
-      acc1 += P1T5 * v5;
-      acc1 += P1T6 * v6;
-      acc1 += P1T7 * v7;
-      acc1 += P1T8 * v8;
-      acc1 += P1T9 * v9;
-      acc1 += P1T10 * v10;
-      acc1 += P1T11 * v11;
-      let acc2 = 0;
-      acc2 += P2T0 * v0;
-      acc2 += P2T1 * v1;
-      acc2 += P2T2 * v2;
-      acc2 += P2T3 * v3;
-      acc2 += P2T4 * v4;
-      acc2 += P2T5 * v5;
-      acc2 += P2T6 * v6;
-      acc2 += P2T7 * v7;
-      acc2 += P2T8 * v8;
-      acc2 += P2T9 * v9;
-      acc2 += P2T10 * v10;
-      acc2 += P2T11 * v11;
-      let acc3 = 0;
-      acc3 += P3T0 * v0;
-      acc3 += P3T1 * v1;
-      acc3 += P3T2 * v2;
-      acc3 += P3T3 * v3;
-      acc3 += P3T4 * v4;
-      acc3 += P3T5 * v5;
-      acc3 += P3T6 * v6;
-      acc3 += P3T7 * v7;
-      acc3 += P3T8 * v8;
-      acc3 += P3T9 * v9;
-      acc3 += P3T10 * v10;
-      acc3 += P3T11 * v11;
-      output[outOffset + 1] = acc1;
-      output[outOffset + 2] = acc2;
-      output[outOffset + 3] = acc3;
+    for (let inputIndex = 0; inputIndex < inputLength; inputIndex++) {
+      work[historyLength + inputIndex] = input[inputIndex] ?? 0;
+    }
+    for (let inputIndex = 0; inputIndex < inputLength; inputIndex++) {
+      const currentIndex = historyLength + inputIndex;
+      const outputOffset = inputIndex * factor;
+      const value0 = work[currentIndex] ?? 0;
+      const value1 = work[currentIndex - 1] ?? 0;
+      const value2 = work[currentIndex - 2] ?? 0;
+      const value3 = work[currentIndex - 3] ?? 0;
+      const value4 = work[currentIndex - 4] ?? 0;
+      const value5 = work[currentIndex - 5] ?? 0;
+      const value6 = work[currentIndex - 6] ?? 0;
+      const value7 = work[currentIndex - 7] ?? 0;
+      const value8 = work[currentIndex - 8] ?? 0;
+      const value9 = work[currentIndex - 9] ?? 0;
+      const value10 = work[currentIndex - 10] ?? 0;
+      const value11 = work[currentIndex - 11] ?? 0;
+      let phase0 = 0;
+      phase0 += P0T0 * value0;
+      phase0 += P0T1 * value1;
+      phase0 += P0T2 * value2;
+      phase0 += P0T3 * value3;
+      phase0 += P0T4 * value4;
+      phase0 += P0T5 * value5;
+      phase0 += P0T6 * value6;
+      phase0 += P0T7 * value7;
+      phase0 += P0T8 * value8;
+      phase0 += P0T9 * value9;
+      phase0 += P0T10 * value10;
+      phase0 += P0T11 * value11;
+      let phase1 = 0;
+      phase1 += P1T0 * value0;
+      phase1 += P1T1 * value1;
+      phase1 += P1T2 * value2;
+      phase1 += P1T3 * value3;
+      phase1 += P1T4 * value4;
+      phase1 += P1T5 * value5;
+      phase1 += P1T6 * value6;
+      phase1 += P1T7 * value7;
+      phase1 += P1T8 * value8;
+      phase1 += P1T9 * value9;
+      phase1 += P1T10 * value10;
+      phase1 += P1T11 * value11;
+      let phase2 = 0;
+      phase2 += P2T0 * value0;
+      phase2 += P2T1 * value1;
+      phase2 += P2T2 * value2;
+      phase2 += P2T3 * value3;
+      phase2 += P2T4 * value4;
+      phase2 += P2T5 * value5;
+      phase2 += P2T6 * value6;
+      phase2 += P2T7 * value7;
+      phase2 += P2T8 * value8;
+      phase2 += P2T9 * value9;
+      phase2 += P2T10 * value10;
+      phase2 += P2T11 * value11;
+      let phase3 = 0;
+      phase3 += P3T0 * value0;
+      phase3 += P3T1 * value1;
+      phase3 += P3T2 * value2;
+      phase3 += P3T3 * value3;
+      phase3 += P3T4 * value4;
+      phase3 += P3T5 * value5;
+      phase3 += P3T6 * value6;
+      phase3 += P3T7 * value7;
+      phase3 += P3T8 * value8;
+      phase3 += P3T9 * value9;
+      phase3 += P3T10 * value10;
+      phase3 += P3T11 * value11;
+      output[outputOffset] = phase0;
+      output[outputOffset + 1] = phase1;
+      output[outputOffset + 2] = phase2;
+      output[outputOffset + 3] = phase3;
     }
     if (inputLength >= historyLength) {
       history.set(work.subarray(workLength - historyLength, workLength), 0);
@@ -1684,16 +1671,13 @@ var TruePeakUpsampler = class {
     }
     return output;
   }
-  reset() {
-    this.history.fill(0);
-    this.work = new Float64Array(0);
-  }
 };
 var DEFAULT_OVERSAMPLE_FACTOR = 4;
 var TruePeakAccumulator = class {
   constructor(_sampleRate, channelCount, oversampleFactor = DEFAULT_OVERSAMPLE_FACTOR) {
     this.upsampleScratch = new Float32Array(0);
-    this.runningMax = 0;
+    this.interpolatedMax = 0;
+    this.rawMax = 0;
     if (channelCount <= 0) {
       throw new Error(`TruePeakAccumulator: channelCount must be positive, got ${channelCount}`);
     }
@@ -1706,6 +1690,7 @@ var TruePeakAccumulator = class {
   }
   // `channels[c]` needs >= `frames` valid samples from index 0 (oversized OK); advances per-channel upsampler state as if appended contiguously.
   push(channels, frames) {
+    if (this.finalizedResult !== void 0) throw new Error("TruePeakAccumulator: push after finalize");
     if (channels.length !== this.channelCount) {
       throw new Error(`TruePeakAccumulator: push got ${channels.length} channels, expected ${this.channelCount}`);
     }
@@ -1720,6 +1705,11 @@ var TruePeakAccumulator = class {
         throw new Error(`TruePeakAccumulator: missing upsampler for channel ${channelIndex}`);
       }
       const slice = channel.length === frames ? channel : channel.subarray(0, frames);
+      for (let index = 0; index < slice.length; index++) {
+        const sample = slice[index] ?? 0;
+        const magnitude = sample < 0 ? -sample : sample;
+        if (magnitude > this.rawMax) this.rawMax = magnitude;
+      }
       if (this.upsampleScratch.length < frames * upsampler.factor) {
         this.upsampleScratch = new Float32Array(frames * upsampler.factor);
       }
@@ -1727,14 +1717,46 @@ var TruePeakAccumulator = class {
       for (let index = 0; index < upsampled.length; index++) {
         const sample = upsampled[index] ?? 0;
         const magnitude = sample < 0 ? -sample : sample;
-        if (magnitude > this.runningMax) this.runningMax = magnitude;
+        if (magnitude > this.interpolatedMax) this.interpolatedMax = magnitude;
       }
     }
   }
   finalize() {
-    return this.runningMax;
+    if (this.finalizedResult !== void 0) return this.finalizedResult;
+    for (const upsampler of this.upsamplers) {
+      const flushLength = 11 * upsampler.factor;
+      if (this.upsampleScratch.length < flushLength) {
+        this.upsampleScratch = new Float32Array(flushLength);
+      }
+      const tail = upsampler.flush(this.upsampleScratch);
+      for (let index = 0; index < tail.length; index++) {
+        const sample = tail[index] ?? 0;
+        const magnitude = sample < 0 ? -sample : sample;
+        if (magnitude > this.interpolatedMax) this.interpolatedMax = magnitude;
+      }
+    }
+    this.finalizedResult = Math.max(this.rawMax, this.interpolatedMax);
+    return this.finalizedResult;
   }
 };
+var MAX_DFTT_BATCH_BYTES = 32 * 1024 * 1024;
+function getDfttBatchBlockCount(blockSize, complexBlockSize, maxBatchBytes) {
+  if (!Number.isSafeInteger(blockSize) || blockSize <= 0 || !Number.isSafeInteger(complexBlockSize) || complexBlockSize <= 0) {
+    throw new Error("DFTT block sizes must be positive integers");
+  }
+  if (!Number.isFinite(maxBatchBytes) || maxBatchBytes <= 0 || maxBatchBytes > MAX_DFTT_BATCH_BYTES) {
+    throw new Error(`DFTT maxBatchBytes must be finite and in (0, ${MAX_DFTT_BATCH_BYTES}]`);
+  }
+  const bytesPerBlock = Float32Array.BYTES_PER_ELEMENT * (3 * blockSize + 4 * complexBlockSize);
+  if (!Number.isSafeInteger(bytesPerBlock)) {
+    throw new Error("DFTT block geometry exceeds the safe integer range");
+  }
+  const blockCount = Math.floor(maxBatchBytes / bytesPerBlock);
+  if (blockCount < 1) {
+    throw new Error(`One DFTT block requires ${bytesPerBlock} bytes, exceeding the ${maxBatchBytes}-byte batch budget`);
+  }
+  return blockCount;
+}
 function complexFft(inRe, inIm, outRe, outIm, workspaceA, workspaceB) {
   const { re: reOfRe, im: imOfRe } = fft(inRe, workspaceA);
   const { re: reOfIm, im: imOfIm } = fft(inIm, workspaceB);
@@ -1744,9 +1766,51 @@ function complexFft(inRe, inIm, outRe, outIm, workspaceA, workspaceB) {
     outIm[ii] = imOfRe[ii] + reOfIm[ii];
   }
 }
-function applyDfttSmoothing(nlmSmoothed, rawMask, numFrames, numBins, dfttOptions, output, fftBackend, fftAddonOptions, profileMs) {
+function complexIfft(inRe, inIm, outRe, outIm, negativeReal, workspaceA, workspaceB) {
+  const realResult = ifft(inRe, inIm, workspaceA);
+  outRe.set(realResult);
+  for (let index = 0; index < inRe.length; index++) negativeReal[index] = -inRe[index];
+  const imaginaryResult = ifft(inIm, negativeReal, workspaceB);
+  outIm.set(imaginaryResult);
+}
+function getWienerGain(signalMagnitudeSquared, noiseMagnitudeSquared) {
+  if (noiseMagnitudeSquared === 0) return signalMagnitudeSquared === 0 ? 0 : 1;
+  return signalMagnitudeSquared / (signalMagnitudeSquared + noiseMagnitudeSquared);
+}
+function applyDfttSmoothing(nlmSmoothed, rawMask, numFrames, numBins, dfttOptions, output, fftBackend, fftAddonOptions, profileMs, executionOptions) {
+  const { blockFreq, blockTime, hopFreq, hopTime, threshold } = dfttOptions;
+  const maskLength = numFrames * numBins;
+  assertPositiveSafeInteger(numFrames, "DFTT numFrames");
+  assertPositiveSafeInteger(numBins, "DFTT numBins");
+  if (!Number.isSafeInteger(maskLength)) {
+    throw new Error("DFTT mask dimensions exceed the safe integer range");
+  }
+  if (nlmSmoothed.length !== maskLength || rawMask.length !== maskLength || output.length !== maskLength) {
+    throw new Error(`DFTT input and output lengths must equal ${maskLength}`);
+  }
+  assertPowerOfTwo(blockFreq, "DFTT blockFreq");
+  assertPowerOfTwo(blockTime, "DFTT blockTime");
+  assertPositiveSafeInteger(hopFreq, "DFTT hopFreq");
+  assertPositiveSafeInteger(hopTime, "DFTT hopTime");
+  if (hopFreq > blockFreq || hopTime > blockTime) {
+    throw new Error("DFTT hops must be no larger than their block dimensions");
+  }
+  if (!Number.isFinite(threshold) || threshold < 0) {
+    throw new Error(`DFTT threshold must be finite and nonnegative, got ${threshold}`);
+  }
+  const blockSize = blockTime * blockFreq;
+  const complexBlockSize = blockTime * (Math.floor(blockFreq / 2) + 1);
+  const maxBatchBytes = executionOptions?.maxBatchBytes ?? MAX_DFTT_BATCH_BYTES;
+  const batchBlockCapacity = getDfttBatchBlockCount(blockSize, complexBlockSize, maxBatchBytes);
+  if (threshold === 0) {
+    output.set(rawMask);
+    return;
+  }
+  if (typedArraysOverlap(output, rawMask) || typedArraysOverlap(output, nlmSmoothed)) {
+    throw new Error("DFTT output must not overlap either input for non-bypass processing");
+  }
   const addon = fftBackend ? getFftAddon(fftBackend, fftAddonOptions) : null;
-  if (!addon || typeof addon.batchFft2D !== "function") {
+  if (!addon || typeof addon.batchFft2D !== "function" || typeof addon.batchIfft2D !== "function") {
     applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOptions, output);
     return;
   }
@@ -1757,10 +1821,9 @@ function applyDfttSmoothing(nlmSmoothed, rawMask, numFrames, numBins, dfttOption
     profileMs[key] += now - profileMark;
     profileMark = now;
   };
-  const { blockFreq, blockTime, hopFreq, hopTime, threshold } = dfttOptions;
   const winFreq = hanningWindow(blockFreq, false);
   const winTime = hanningWindow(blockTime, false);
-  const win2d = new Float32Array(blockTime * blockFreq);
+  const win2d = new Float32Array(blockSize);
   for (let tf = 0; tf < blockTime; tf++) {
     for (let bf = 0; bf < blockFreq; bf++) {
       win2d[tf * blockFreq + bf] = winTime[tf] * winFreq[bf];
@@ -1769,82 +1832,83 @@ function applyDfttSmoothing(nlmSmoothed, rawMask, numFrames, numBins, dfttOption
   const blocksPerFrame = Math.ceil(numFrames / hopTime);
   const blocksPerBin = Math.ceil(numBins / hopFreq);
   const totalBlocks = blocksPerFrame * blocksPerBin;
-  const blockSize = blockTime * blockFreq;
-  const complexBinsPerRow = blockFreq / 2 + 1;
-  const complexBlockSize = blockTime * complexBinsPerRow;
-  const rawBatch = new Float32Array(totalBlocks * blockSize);
-  const nlmBatch = new Float32Array(totalBlocks * blockSize);
-  for (let frameIdx = 0; frameIdx < blocksPerFrame; frameIdx++) {
-    const frameStart = frameIdx * hopTime;
-    for (let binIdx = 0; binIdx < blocksPerBin; binIdx++) {
-      const binStart = binIdx * hopFreq;
-      const blockIdx = frameIdx * blocksPerBin + binIdx;
-      const blockOffset = blockIdx * blockSize;
+  const sigmaSq = threshold * threshold;
+  const windowSumSq = new Float32Array(maskLength);
+  output.fill(0);
+  for (let firstGlobalBlock = 0; firstGlobalBlock < totalBlocks; firstGlobalBlock += batchBlockCapacity) {
+    const batchCount = Math.min(batchBlockCapacity, totalBlocks - firstGlobalBlock);
+    const rawBatch = new Float32Array(batchCount * blockSize);
+    const nlmBatch = new Float32Array(batchCount * blockSize);
+    for (let localBlock = 0; localBlock < batchCount; localBlock++) {
+      const globalBlock = firstGlobalBlock + localBlock;
+      const frameIndex = Math.floor(globalBlock / blocksPerBin);
+      const binIndex = globalBlock % blocksPerBin;
+      const frameStart = frameIndex * hopTime;
+      const binStart = binIndex * hopFreq;
+      const blockOffset = localBlock * blockSize;
       for (let tf = 0; tf < blockTime; tf++) {
-        const srcFrame = frameStart + tf < numFrames ? frameStart + tf : numFrames - 1;
+        const srcFrame = Math.min(frameStart + tf, numFrames - 1);
         for (let bf = 0; bf < blockFreq; bf++) {
-          const srcBin = binStart + bf < numBins ? binStart + bf : numBins - 1;
-          const winVal = win2d[tf * blockFreq + bf];
-          const srcPos = srcFrame * numBins + srcBin;
-          const dstPos = blockOffset + tf * blockFreq + bf;
-          rawBatch[dstPos] = rawMask[srcPos] * winVal;
-          nlmBatch[dstPos] = nlmSmoothed[srcPos] * winVal;
+          const srcBin = Math.min(binStart + bf, numBins - 1);
+          const windowValue = win2d[tf * blockFreq + bf];
+          const sourcePosition = srcFrame * numBins + srcBin;
+          const batchPosition = blockOffset + tf * blockFreq + bf;
+          rawBatch[batchPosition] = rawMask[sourcePosition] * windowValue;
+          nlmBatch[batchPosition] = nlmSmoothed[sourcePosition] * windowValue;
         }
       }
     }
-  }
-  profileAdd("fill");
-  const rawFft = addon.batchFft2D(rawBatch, blockTime, blockFreq, totalBlocks);
-  const nlmFft = addon.batchFft2D(nlmBatch, blockTime, blockFreq, totalBlocks);
-  profileAdd("forward");
-  const sigmaSq = threshold * threshold;
-  const totalComplex = totalBlocks * complexBlockSize;
-  const rawRe = rawFft.re;
-  const rawIm = rawFft.im;
-  const nlmRe = nlmFft.re;
-  const nlmIm = nlmFft.im;
-  for (let flatIdx = 0; flatIdx < totalComplex; flatIdx++) {
-    const nRe = nlmRe[flatIdx];
-    const nIm = nlmIm[flatIdx];
-    const nMagSq = nRe * nRe + nIm * nIm;
-    const gain = nMagSq / (nMagSq + sigmaSq);
-    rawRe[flatIdx] = rawRe[flatIdx] * gain;
-    rawIm[flatIdx] = rawIm[flatIdx] * gain;
-  }
-  profileAdd("gain");
-  const synth = addon.batchIfft2D(rawRe, rawIm, blockTime, blockFreq, totalBlocks);
-  profileAdd("inverse");
-  const accumulator = new Float32Array(numFrames * numBins);
-  const windowSumSq = new Float32Array(numFrames * numBins);
-  for (let frameIdx = 0; frameIdx < blocksPerFrame; frameIdx++) {
-    const frameStart = frameIdx * hopTime;
-    for (let binIdx = 0; binIdx < blocksPerBin; binIdx++) {
-      const binStart = binIdx * hopFreq;
-      const blockIdx = frameIdx * blocksPerBin + binIdx;
-      const blockOffset = blockIdx * blockSize;
+    profileAdd("fill");
+    const rawFft = addon.batchFft2D(rawBatch, blockTime, blockFreq, batchCount);
+    const nlmFft = addon.batchFft2D(nlmBatch, blockTime, blockFreq, batchCount);
+    const batchComplexLength = batchCount * complexBlockSize;
+    assertArrayLength(rawFft.re, batchComplexLength, "DFTT addon raw real output");
+    assertArrayLength(rawFft.im, batchComplexLength, "DFTT addon raw imaginary output");
+    assertArrayLength(nlmFft.re, batchComplexLength, "DFTT addon NLM real output");
+    assertArrayLength(nlmFft.im, batchComplexLength, "DFTT addon NLM imaginary output");
+    profileAdd("forward");
+    for (let flatIndex = 0; flatIndex < batchComplexLength; flatIndex++) {
+      const nlmReal = nlmFft.re[flatIndex];
+      const nlmImaginary = nlmFft.im[flatIndex];
+      const nlmMagnitudeSquared = nlmReal * nlmReal + nlmImaginary * nlmImaginary;
+      const gain = getWienerGain(nlmMagnitudeSquared, sigmaSq);
+      rawFft.re[flatIndex] = rawFft.re[flatIndex] * gain;
+      rawFft.im[flatIndex] = rawFft.im[flatIndex] * gain;
+    }
+    profileAdd("gain");
+    const synth = addon.batchIfft2D(rawFft.re, rawFft.im, blockTime, blockFreq, batchCount);
+    assertArrayLength(synth, batchCount * blockSize, "DFTT addon inverse output");
+    profileAdd("inverse");
+    for (let localBlock = 0; localBlock < batchCount; localBlock++) {
+      const globalBlock = firstGlobalBlock + localBlock;
+      const frameIndex = Math.floor(globalBlock / blocksPerBin);
+      const binIndex = globalBlock % blocksPerBin;
+      const frameStart = frameIndex * hopTime;
+      const binStart = binIndex * hopFreq;
+      const blockOffset = localBlock * blockSize;
       for (let tf = 0; tf < blockTime; tf++) {
-        const destFrame = frameStart + tf;
-        if (destFrame >= numFrames) break;
+        const destinationFrame = frameStart + tf;
+        if (destinationFrame >= numFrames) break;
         for (let bf = 0; bf < blockFreq; bf++) {
-          const destBin = binStart + bf;
-          if (destBin >= numBins) break;
-          const winVal = win2d[tf * blockFreq + bf];
-          const destPos = destFrame * numBins + destBin;
-          const srcVal = synth[blockOffset + tf * blockFreq + bf];
-          accumulator[destPos] = accumulator[destPos] + srcVal * winVal;
-          windowSumSq[destPos] = windowSumSq[destPos] + winVal * winVal;
+          const destinationBin = binStart + bf;
+          if (destinationBin >= numBins) break;
+          const windowValue = win2d[tf * blockFreq + bf];
+          const destinationPosition = destinationFrame * numBins + destinationBin;
+          const sourceValue = synth[blockOffset + tf * blockFreq + bf];
+          output[destinationPosition] = output[destinationPosition] + sourceValue * windowValue;
+          windowSumSq[destinationPosition] = windowSumSq[destinationPosition] + windowValue * windowValue;
         }
       }
     }
+    profileAdd("ola");
   }
-  profileAdd("ola");
-  for (let flatIdx = 0; flatIdx < numFrames * numBins; flatIdx++) {
-    const ws = windowSumSq[flatIdx];
-    if (ws > 1e-8) {
-      const normalisedVal = accumulator[flatIdx] / ws;
-      output[flatIdx] = normalisedVal < 0 ? 0 : normalisedVal > 1 ? 1 : normalisedVal;
+  for (let flatIndex = 0; flatIndex < maskLength; flatIndex++) {
+    const windowWeight = windowSumSq[flatIndex];
+    if (windowWeight > 1e-8) {
+      const normalizedValue = output[flatIndex] / windowWeight;
+      output[flatIndex] = normalizedValue < 0 ? 0 : normalizedValue > 1 ? 1 : normalizedValue;
     } else {
-      output[flatIdx] = rawMask[flatIdx];
+      output[flatIndex] = rawMask[flatIndex];
     }
   }
   profileAdd("normalize");
@@ -1859,8 +1923,8 @@ function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOpti
       win2d[tf * blockFreq + bf] = winTime[tf] * winFreq[bf];
     }
   }
-  const accumulator = new Float32Array(numFrames * numBins);
   const windowSumSq = new Float32Array(numFrames * numBins);
+  output.fill(0);
   const blockRaw = new Float32Array(blockTime * blockFreq);
   const blockNlm = new Float32Array(blockTime * blockFreq);
   const rawRowRe = new Float32Array(blockTime * blockFreq);
@@ -1879,6 +1943,7 @@ function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOpti
   const scratchIm = new Float32Array(blockTime);
   const scratchOutRe = new Float32Array(blockTime);
   const scratchOutIm = new Float32Array(blockTime);
+  const scratchNegativeReal = new Float32Array(blockTime);
   const rowScratch = new Float32Array(blockFreq);
   const rowScratchRe = new Float32Array(blockFreq);
   const rowScratchIm = new Float32Array(blockFreq);
@@ -1886,7 +1951,8 @@ function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOpti
   const rowFwdWorkspace = createFftWorkspace(blockFreq);
   const colFwdWorkspaceA = createFftWorkspace(blockTime);
   const colFwdWorkspaceB = createFftWorkspace(blockTime);
-  const colInvWorkspace = createFftWorkspace(blockTime);
+  const colInvWorkspaceA = createFftWorkspace(blockTime);
+  const colInvWorkspaceB = createFftWorkspace(blockTime);
   const rowInvWorkspace = createFftWorkspace(blockFreq);
   for (let frameStart = 0; frameStart < numFrames; frameStart += hopTime) {
     for (let binStart = 0; binStart < numBins; binStart += hopFreq) {
@@ -1961,7 +2027,7 @@ function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOpti
           const nlmRe = nlmColRe[flatIdx];
           const nlmIm = nlmColIm[flatIdx];
           const nlmMagSq = nlmRe * nlmRe + nlmIm * nlmIm;
-          const gain = nlmMagSq / (nlmMagSq + sigmaSq);
+          const gain = getWienerGain(nlmMagSq, sigmaSq);
           gainColRe[flatIdx] = rawColRe[flatIdx] * gain;
           gainColIm[flatIdx] = rawColIm[flatIdx] * gain;
         }
@@ -1971,15 +2037,24 @@ function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOpti
           scratchRe[tf] = gainColRe[bf * blockTime + tf];
           scratchIm[tf] = gainColIm[bf * blockTime + tf];
         }
-        const icolResult = ifft(scratchRe, scratchIm, colInvWorkspace);
+        complexIfft(
+          scratchRe,
+          scratchIm,
+          scratchOutRe,
+          scratchOutIm,
+          scratchNegativeReal,
+          colInvWorkspaceA,
+          colInvWorkspaceB
+        );
         for (let tf = 0; tf < blockTime; tf++) {
-          colInRe[bf * blockTime + tf] = icolResult[tf];
+          colInRe[bf * blockTime + tf] = scratchOutRe[tf];
+          colInIm[bf * blockTime + tf] = scratchOutIm[tf];
         }
       }
       for (let tf = 0; tf < blockTime; tf++) {
         for (let bf = 0; bf < blockFreq; bf++) {
           rowScratchRe[bf] = colInRe[bf * blockTime + tf];
-          rowScratchIm[bf] = 0;
+          rowScratchIm[bf] = colInIm[bf * blockTime + tf];
         }
         const irowResult = ifft(rowScratchRe, rowScratchIm, rowInvWorkspace);
         for (let bf = 0; bf < blockFreq; bf++) {
@@ -1994,7 +2069,7 @@ function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOpti
           if (destBin >= numBins) break;
           const winVal = win2d[tf * blockFreq + bf];
           const destPos = destFrame * numBins + destBin;
-          accumulator[destPos] = accumulator[destPos] + synthBlock[tf * blockFreq + bf] * winVal;
+          output[destPos] = output[destPos] + synthBlock[tf * blockFreq + bf] * winVal;
           windowSumSq[destPos] = windowSumSq[destPos] + winVal * winVal;
         }
       }
@@ -2003,15 +2078,73 @@ function applyDfttSmoothingJs(nlmSmoothed, rawMask, numFrames, numBins, dfttOpti
   for (let flatIdx = 0; flatIdx < numFrames * numBins; flatIdx++) {
     const ws = windowSumSq[flatIdx];
     if (ws > 1e-8) {
-      const normalisedVal = accumulator[flatIdx] / ws;
+      const normalisedVal = output[flatIdx] / ws;
       output[flatIdx] = normalisedVal < 0 ? 0 : normalisedVal > 1 ? 1 : normalisedVal;
     } else {
       output[flatIdx] = rawMask[flatIdx];
     }
   }
 }
+function assertPositiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer, got ${value}`);
+  }
+}
+function assertPowerOfTwo(value, name) {
+  assertPositiveSafeInteger(value, name);
+  if (!Number.isInteger(Math.log2(value))) {
+    throw new Error(`${name} must be a power of two, got ${value}`);
+  }
+}
+function typedArraysOverlap(left, right) {
+  if (left.buffer !== right.buffer) return false;
+  const leftEnd = left.byteOffset + left.byteLength;
+  const rightEnd = right.byteOffset + right.byteLength;
+  return left.byteOffset < rightEnd && right.byteOffset < leftEnd;
+}
+function assertArrayLength(values, expectedLength, name) {
+  if (values.length !== expectedLength) {
+    throw new Error(`${name} length must equal ${expectedLength}, got ${values.length}`);
+  }
+}
 function applyNlmSmoothingRange(mask, numFrames, numBins, nlmOptions, output, blockFrameStart, blockFrameEnd) {
   const { patchSize, searchFreqRadius, searchTimePre, searchTimePost, pasteBlockSize, threshold } = nlmOptions;
+  const maskLength = numFrames * numBins;
+  assertNonnegativeSafeInteger(numFrames, "NLM numFrames");
+  assertNonnegativeSafeInteger(numBins, "NLM numBins");
+  if (!Number.isSafeInteger(maskLength)) {
+    throw new Error("NLM mask dimensions exceed the safe integer range");
+  }
+  if (mask.length !== maskLength || output.length !== maskLength) {
+    throw new Error(`NLM mask and output lengths must equal ${maskLength}`);
+  }
+  if (!Number.isSafeInteger(patchSize) || patchSize <= 0 || patchSize % 2 !== 0) {
+    throw new Error(`NLM patchSize must be a positive even integer, got ${patchSize}`);
+  }
+  assertNonnegativeSafeInteger(searchFreqRadius, "NLM searchFreqRadius");
+  assertNonnegativeSafeInteger(searchTimePre, "NLM searchTimePre");
+  assertNonnegativeSafeInteger(searchTimePost, "NLM searchTimePost");
+  if (!Number.isSafeInteger(pasteBlockSize) || pasteBlockSize <= 0) {
+    throw new Error(`NLM pasteBlockSize must be a positive integer, got ${pasteBlockSize}`);
+  }
+  if (!Number.isFinite(threshold) || threshold < 0) {
+    throw new Error(`NLM threshold must be finite and nonnegative, got ${threshold}`);
+  }
+  assertNonnegativeSafeInteger(blockFrameStart, "NLM blockFrameStart");
+  assertNonnegativeSafeInteger(blockFrameEnd, "NLM blockFrameEnd");
+  if (blockFrameStart > blockFrameEnd || blockFrameEnd > numFrames || blockFrameStart % pasteBlockSize !== 0 || blockFrameEnd !== numFrames && blockFrameEnd % pasteBlockSize !== 0) {
+    throw new Error("NLM frame range must be ordered, in bounds, and aligned to pasteBlockSize");
+  }
+  if (threshold === 0) {
+    if (blockFrameStart === 0 && blockFrameEnd === numFrames) {
+      output.set(mask);
+    } else {
+      const outputStart = blockFrameStart * numBins;
+      const outputEnd = blockFrameEnd * numBins;
+      output.set(mask.subarray(outputStart, outputEnd), outputStart);
+    }
+    return;
+  }
   const hSq = threshold * threshold;
   const halfPatch = Math.floor(patchSize / 2);
   for (let blockFrame = blockFrameStart; blockFrame < blockFrameEnd; blockFrame += pasteBlockSize) {
@@ -2050,18 +2183,26 @@ function applyNlmSmoothingRange(mask, numFrames, numBins, nlmOptions, output, bl
           valueSum += weight * mask[clampedCandFrame * numBins + clampedCandBin];
         }
       }
-      const smoothed = weightSum > 0 ? valueSum / weightSum : mask[centreFrame * numBins + centreBin];
+      const clampedCentreFrame = Math.min(centreFrame, numFrames - 1);
+      const clampedCentreBin = Math.min(centreBin, numBins - 1);
+      const smoothed = weightSum > 0 ? valueSum / weightSum : mask[clampedCentreFrame * numBins + clampedCentreBin];
+      const clampedSmoothed = smoothed < 0 ? 0 : smoothed > 1 ? 1 : smoothed;
       for (let pf = 0; pf < pasteBlockSize; pf++) {
         const outFrame = blockFrame + pf;
         if (outFrame >= numFrames) break;
         for (let pb = 0; pb < pasteBlockSize; pb++) {
           const outBin = blockBin + pb;
           if (outBin >= numBins) break;
-          output[outFrame * numBins + outBin] = smoothed;
+          output[outFrame * numBins + outBin] = clampedSmoothed;
         }
       }
     }
   }
 }
+function assertNonnegativeSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${name} must be a nonnegative integer, got ${value}`);
+  }
+}
 
-export { AmplitudeHistogramAccumulator, BidirectionalIir, IntegratedLufsAccumulator, LoudnessAccumulator, MixedRadixFft, ResampleStream, SlidingWindowMaxStream, SlidingWindowMinStream, TruePeakAccumulator, TruePeakUpsampler, __commonJS, __export, __toESM, applyDfttSmoothing, applyNlmSmoothingRange, bandpass, createFftWorkspace, dbToLinear, deinterleaveBuffer, detectFftBackend, fft, getFftAddon, getLraConsideredStats, hanningWindow, initFftBackend, interleave, istft, linearToDb, stft };
+export { AmplitudeHistogramAccumulator, BidirectionalIir, IntegratedLufsAccumulator, LoudnessAccumulator, MixedRadixFft, SlidingWindowMaxStream, SlidingWindowMinStream, TruePeakAccumulator, TruePeakUpsampler, __commonJS, __export, __toESM, applyDfttSmoothing, applyNlmSmoothingRange, bandpass, createFftWorkspace, dbToLinear, deinterleaveBuffer, detectFftBackend, fft, getFftAddon, getLraConsideredStats, hanningWindow, initFftBackend, interleave, istft, linearToDb, stft };