@buffered-audio/nodes 0.15.2 → 0.17.0

package/dist/index.js

@@ -1,8 +1,9 @@
 import path, { extname, join } from 'path';
 import { randomUUID } from 'crypto';
 import { createWriteStream, createReadStream } from 'fs';
-import { open, stat, unlink, readFile, mkdtemp, writeFile, rm } from 'fs/promises';
+import { open, stat, readFile, unlink, mkdtemp, writeFile, rm } from 'fs/promises';
 import { tmpdir } from 'os';
+import { Readable } from 'stream';
 import { EventEmitter } from 'events';
 import { spawn } from 'child_process';
 import { createRequire } from 'module';
@@ -15575,6 +15576,66 @@ var __export2 = (target, all) => {
     __defProp2(target, name, { get: all[name], enumerable: true });
 };
 var HIGH_WATER_MARK = 10 * 1024 * 1024;
+var REVERSE_STRIPE_BYTES = 10 * 1024 * 1024;
+function deinterleave(buf, channels) {
+  const bytesPerFrame = channels * 4;
+  const frames = Math.floor(buf.length / bytesPerFrame);
+  const interleaved = new Float32Array(buf.buffer, buf.byteOffset, frames * channels);
+  const out = [];
+  for (let ch = 0; ch < channels; ch++) out.push(new Float32Array(frames));
+  for (let frame = 0; frame < frames; frame++) {
+    const base = frame * channels;
+    for (let ch = 0; ch < channels; ch++) {
+      out[ch][frame] = interleaved[base + ch];
+    }
+  }
+  return out;
+}
+function buildAudioChunk(samples, offset, sampleRate, bitDepth) {
+  return { samples, offset, sampleRate: sampleRate ?? 0, bitDepth: bitDepth ?? 0 };
+}
+async function pullBytes(rs, isEnded, bytesNeeded) {
+  const chunks = [];
+  let collected = 0;
+  while (collected < bytesNeeded) {
+    const chunk = rs.read();
+    if (chunk !== null) {
+      const remaining = bytesNeeded - collected;
+      if (chunk.length <= remaining) {
+        chunks.push(chunk);
+        collected += chunk.length;
+      } else {
+        chunks.push(chunk.subarray(0, remaining));
+        collected += remaining;
+        rs.unshift(chunk.subarray(remaining));
+      }
+      continue;
+    }
+    if (isEnded()) break;
+    await new Promise((resolve) => {
+      const wake = () => {
+        rs.off("readable", wake);
+        rs.off("end", wake);
+        rs.off("error", wake);
+        rs.off("close", wake);
+        resolve();
+      };
+      rs.once("readable", wake);
+      rs.once("end", wake);
+      rs.once("error", wake);
+      rs.once("close", wake);
+    });
+  }
+  if (chunks.length === 0) return Buffer.alloc(0);
+  if (chunks.length === 1) return chunks[0];
+  return Buffer.concat(chunks);
+}
+async function awaitStreamClose(stream) {
+  if (stream.closed) return;
+  await new Promise((resolve) => {
+    stream.once("close", () => resolve());
+  });
+}
 var ChunkBuffer = class {
   constructor() {
     this._frames = 0;
@@ -15583,6 +15644,7 @@ var ChunkBuffer = class {
     this.writePositionByte = 0;
     this.readStreamEnded = false;
     this.framesReadInSession = 0;
+    this.reverseReaders = /* @__PURE__ */ new Set();
   }
   get frames() {
     return this._frames;
@@ -15628,28 +15690,47 @@ var ChunkBuffer = class {
   async flushWrites() {
     await this.endWriteStream();
   }
+  // Opens a read-only reverse view over this buffer's temp file. Flushes pending writes first, then
+  // snapshots frames/channels/sampleRate/bitDepth so the reader is stable against later reads on the
+  // source. The reader is registered here and closed by clear()/close() (Windows blocks unlink while a
+  // handle is open — same EBUSY guard the forward read stream uses in endReadStream). See the
+  // ReverseChunkReader class comment for the full borrow contract.
+  async openReverseReader() {
+    await this.flushWrites();
+    const reader = new ReverseChunkReader(
+      this.tempPath,
+      { frames: this._frames, channels: this._channels, sampleRate: this._sampleRate, bitDepth: this._bitDepth },
+      REVERSE_STRIPE_BYTES,
+      this
+    );
+    this.reverseReaders.add(reader);
+    return reader;
+  }
+  // Called by a factory-created reader from its close() so it deregisters itself. Idempotent.
+  deregisterReverseReader(reader) {
+    this.reverseReaders.delete(reader);
+  }
+  async closeReverseReaders() {
+    const readers = [...this.reverseReaders];
+    this.reverseReaders.clear();
+    for (const reader of readers) {
+      await reader.close().catch(() => void 0);
+    }
+  }
   async read(frames) {
     const channels = this._channels;
     const startFrame = this.framesReadInSession;
     if (channels === 0 || frames <= 0 || this._frames === 0) {
-      return this.buildAudioChunk([], startFrame);
+      return buildAudioChunk([], startFrame, this._sampleRate, this._bitDepth);
     }
     const bytesPerFrame = channels * 4;
-    const bytesNeeded = frames * bytesPerFrame;
-    const buf = await this.pullBytes(bytesNeeded);
+    const rs = this.ensureReadStream();
+    const buf = await pullBytes(rs, () => rs.destroyed || this.readStreamEnded, frames * bytesPerFrame);
     const actualFrames = Math.floor(buf.length / bytesPerFrame);
-    if (actualFrames <= 0) return this.buildAudioChunk([], startFrame);
+    if (actualFrames <= 0) return buildAudioChunk([], startFrame, this._sampleRate, this._bitDepth);
     this.framesReadInSession += actualFrames;
-    const interleaved = new Float32Array(buf.buffer, buf.byteOffset, actualFrames * channels);
-    const out = [];
-    for (let ch = 0; ch < channels; ch++) out.push(new Float32Array(actualFrames));
-    for (let frame = 0; frame < actualFrames; frame++) {
-      const base = frame * channels;
-      for (let ch = 0; ch < channels; ch++) {
-        out[ch][frame] = interleaved[base + ch];
-      }
-    }
-    return this.buildAudioChunk(out, startFrame);
+    const out = deinterleave(buf, channels);
+    return buildAudioChunk(out, startFrame, this._sampleRate, this._bitDepth);
   }
   async reset() {
     await this.endWriteStream();
@@ -15659,6 +15740,7 @@ var ChunkBuffer = class {
   async clear() {
     await this.endWriteStream();
     await this.endReadStream();
+    await this.closeReverseReaders();
     if (this.tempPath) {
       await unlink(this.tempPath).catch(() => void 0);
       this.tempPath = void 0;
@@ -15670,6 +15752,7 @@ var ChunkBuffer = class {
   async close() {
     await this.endWriteStream();
     await this.endReadStream();
+    await this.closeReverseReaders();
     if (this.tempPath) {
       await unlink(this.tempPath).catch(() => void 0);
       this.tempPath = void 0;
@@ -15679,9 +15762,6 @@ var ChunkBuffer = class {
     this._frames = 0;
     this._channels = 0;
   }
-  tempFilePath() {
-    return this.tempPath;
-  }
   validateAndSetMetadata(sampleRate, bitDepth) {
     if (sampleRate !== void 0) {
       if (this._sampleRate === void 0) {
@@ -15705,9 +15785,6 @@ var ChunkBuffer = class {
       throw new Error(`ChunkBuffer: channel count mismatch \u2014 buffer has ${String(this._channels)}, write supplied ${String(target)}`);
     }
   }
-  buildAudioChunk(samples, offset) {
-    return { samples, offset, sampleRate: this._sampleRate ?? 0, bitDepth: this._bitDepth ?? 0 };
-  }
   ensureTempPath() {
     this.tempPath ?? (this.tempPath = join(tmpdir(), `chunk-buffer-${randomUUID()}.bin`));
     return this.tempPath;
@@ -15760,47 +15837,140 @@ var ChunkBuffer = class {
     this.readStreamEnded = false;
     this.framesReadInSession = 0;
     rs.destroy();
-    if (!rs.closed) {
-      await new Promise((resolve) => {
-        rs.once("close", () => resolve());
-      });
+    await awaitStreamClose(rs);
+  }
+};
+var ReverseChunkReader = class {
+  constructor(path2, meta32, stripeBytes = REVERSE_STRIPE_BYTES, parent) {
+    this.framesReturned = 0;
+    this.closed = false;
+    this.path = path2;
+    this.frames = path2 === void 0 ? 0 : meta32.frames;
+    this.channels = meta32.channels;
+    this.sampleRate = meta32.sampleRate;
+    this.bitDepth = meta32.bitDepth;
+    this.bytesPerFrame = meta32.channels * 4;
+    this.windowBytes = meta32.channels === 0 ? stripeBytes : Math.max(this.bytesPerFrame, Math.floor(stripeBytes / this.bytesPerFrame) * this.bytesPerFrame);
+    this.parent = parent;
+  }
+  async read(frames) {
+    if (this.closed) {
+      throw new Error("ReverseChunkReader: read() after close()");
+    }
+    const offset = this.framesReturned;
+    const remaining = this.frames - this.framesReturned;
+    if (this.path === void 0 || this.channels === 0 || frames <= 0 || remaining <= 0) {
+      return buildAudioChunk([], offset, this.sampleRate, this.bitDepth);
     }
+    const count = Math.min(frames, remaining);
+    const rs = this.ensureStream();
+    const buf = await pullBytes(rs, () => rs.destroyed || rs.readableEnded, count * this.bytesPerFrame);
+    const actualFrames = Math.floor(buf.length / this.bytesPerFrame);
+    if (actualFrames < count) {
+      throw this.streamError ?? new Error("ReverseChunkReader: unexpected end of reverse stream");
+    }
+    this.framesReturned += actualFrames;
+    const out = deinterleave(buf, this.channels);
+    return buildAudioChunk(out, offset, this.sampleRate, this.bitDepth);
   }
-  async pullBytes(bytesNeeded) {
-    const rs = this.ensureReadStream();
-    const chunks = [];
-    let collected = 0;
-    while (collected < bytesNeeded) {
-      const chunk = rs.read();
-      if (chunk !== null) {
-        const remaining = bytesNeeded - collected;
-        if (chunk.length <= remaining) {
-          chunks.push(chunk);
-          collected += chunk.length;
-        } else {
-          chunks.push(chunk.subarray(0, remaining));
-          collected += remaining;
-          rs.unshift(chunk.subarray(remaining));
-        }
-        continue;
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const stream = this.stream;
+    this.stream = void 0;
+    if (stream) {
+      stream.destroy();
+      await awaitStreamClose(stream);
+    }
+    this.parent?.deregisterReverseReader(this);
+  }
+  ensureStream() {
+    if (this.stream) return this.stream;
+    if (this.path === void 0) {
+      throw new Error("ReverseChunkReader: no source file");
+    }
+    const totalBytes = this.frames * this.bytesPerFrame;
+    const stream = new ReverseReadable(this.path, totalBytes, this.bytesPerFrame, this.windowBytes);
+    stream.once("error", (error482) => {
+      this.streamError = error482;
+    });
+    this.stream = stream;
+    return stream;
+  }
+};
+var ReverseReadable = class extends Readable {
+  constructor(path2, totalBytes, bytesPerFrame, windowBytes) {
+    super({ highWaterMark: windowBytes });
+    this.path = path2;
+    this.bytesPerFrame = bytesPerFrame;
+    this.windowBytes = windowBytes;
+    this.pos = totalBytes;
+  }
+  // Emits the next backward window [max(0, pos - windowBytes), pos), with the frame order reversed in
+  // place (channel order INSIDE each frame preserved — interleaved layout intact), then walks pos toward
+  // 0 and pushes null at start-of-file. Node does not consume a rejected _read promise — an uncaught
+  // throw becomes an unhandled rejection and the stream never errors — so any failure is routed to
+  // destroy(err), which fires the 'error'/'close' events pullBytes waits on.
+  _read() {
+    void this.readWindow();
+  }
+  async readWindow() {
+    try {
+      if (this.pos <= 0) {
+        this.push(null);
+        return;
       }
-      if (this.readStreamEnded) break;
-      await new Promise((resolve) => {
-        const onReadable = () => {
-          rs.off("end", onEnd);
-          resolve();
-        };
-        const onEnd = () => {
-          rs.off("readable", onReadable);
-          resolve();
-        };
-        rs.once("readable", onReadable);
-        rs.once("end", onEnd);
-      });
+      const startByte = Math.max(0, this.pos - this.windowBytes);
+      const length = this.pos - startByte;
+      const buf = Buffer.alloc(length);
+      await this.readFully(buf, startByte);
+      this.reverseFramesInPlace(buf);
+      this.pos = startByte;
+      this.push(buf);
+    } catch (error482) {
+      this.destroy(error482);
+    }
+  }
+  // Reverse the frame order within the window in place: frame i swaps with frame (frameCount - 1 - i),
+  // each frame being one bytesPerFrame-wide slice. Channel order inside a frame is untouched, so the
+  // interleaved layout survives — only the time order flips.
+  reverseFramesInPlace(buf) {
+    const frameCount = Math.floor(buf.length / this.bytesPerFrame);
+    const scratch = Buffer.alloc(this.bytesPerFrame);
+    for (let low = 0, high = frameCount - 1; low < high; low++, high--) {
+      const lowByte = low * this.bytesPerFrame;
+      const highByte = high * this.bytesPerFrame;
+      buf.copy(scratch, 0, lowByte, lowByte + this.bytesPerFrame);
+      buf.copy(buf, lowByte, highByte, highByte + this.bytesPerFrame);
+      scratch.copy(buf, highByte, 0, this.bytesPerFrame);
+    }
+  }
+  // The one centralized positioned read-fully helper. Loops on handle.read and throws on a zero-byte
+  // read (unexpected EOF) — the shared guard against the former unchecked-bytesRead short-read bug.
+  async readFully(target, position) {
+    const handle = await this.ensureHandle();
+    let filled = 0;
+    while (filled < target.length) {
+      const { bytesRead } = await handle.read(target, filled, target.length - filled, position + filled);
+      if (bytesRead === 0) {
+        throw new Error(`ReverseReadable: unexpected EOF at byte ${position + filled}`);
+      }
+      filled += bytesRead;
+    }
+  }
+  async ensureHandle() {
+    if (this.handle) return this.handle;
+    this.handle = await open(this.path, "r");
+    return this.handle;
+  }
+  _destroy(error482, callback) {
+    const handle = this.handle;
+    this.handle = void 0;
+    if (!handle) {
+      callback(error482);
+      return;
     }
-    if (chunks.length === 0) return Buffer.alloc(0);
-    if (chunks.length === 1) return chunks[0];
-    return Buffer.concat(chunks);
+    handle.close().then(() => callback(error482)).catch((closeError) => callback(error482 ?? closeError));
   }
 };
 var external_exports2 = {};
@@ -29413,6 +29583,54 @@ function date42(params) {
   return /* @__PURE__ */ _coercedDate2(ZodDate2, params);
 }
 config2(en_default2());
+var UNKNOWN_TOTAL_QUANTUM_FRAMES = 48e4;
+var DEFAULT_PROGRESS_QUANTUM = 0.1;
+var BufferedStream = class {
+  constructor(properties) {
+    this.events = new EventEmitter();
+    this.quantumFraction = DEFAULT_PROGRESS_QUANTUM;
+    this.lastBoundaryByPhase = /* @__PURE__ */ new Map();
+    this.properties = properties;
+  }
+  emitProgress(phase2, framesDone, framesTotal, options) {
+    const total = framesTotal !== void 0 && framesTotal > 0 ? framesTotal : void 0;
+    if (options?.force) {
+      this.lastBoundaryByPhase.set(phase2, framesDone);
+      this.events.emit("progress", { phase: phase2, framesDone, framesTotal: total });
+      return;
+    }
+    const quantum = total ? Math.max(1, Math.floor(total * this.quantumFraction)) : UNKNOWN_TOTAL_QUANTUM_FRAMES;
+    const boundary = Math.floor(framesDone / quantum) * quantum;
+    const last = this.lastBoundaryByPhase.get(phase2);
+    if (last !== void 0 && boundary <= last) return;
+    this.lastBoundaryByPhase.set(phase2, boundary);
+    this.events.emit("progress", { phase: phase2, framesDone, framesTotal: total });
+  }
+  log(message, data, level = "info") {
+    this.events.emit("log", { level, message, data });
+  }
+  progress(framesDone, framesTotal) {
+    this.emitProgress("process", framesDone, framesTotal);
+  }
+  async teardown() {
+    await this._teardown();
+  }
+  _teardown() {
+    return;
+  }
+};
+function wireStreamEvents(stream, identity, onEvent) {
+  stream.events.on("started", () => onEvent(identity, { kind: "started" }));
+  stream.events.on("finished", (payload) => onEvent(identity, { kind: "finished", ...payload }));
+  stream.events.on("progress", (payload) => onEvent(identity, { kind: "progress", ...payload }));
+  stream.events.on("log", (payload) => onEvent(identity, { kind: "log", ...payload }));
+}
+function wireStream(node, stream, context) {
+  stream.quantumFraction = context.progressQuantum ?? DEFAULT_PROGRESS_QUANTUM;
+  if (!context.onEvent) return;
+  const identity = { nodeName: node.constructor.nodeName, id: node.id, type: node.type };
+  wireStreamEvents(stream, identity, context.onEvent);
+}
 var BufferedAudioNode = class {
   constructor(properties) {
     this.streams = [];
@@ -29462,20 +29680,8 @@ var BufferedAudioNode = class {
   }
 };
 BufferedAudioNode.packageVersion = "0.0.0";
-BufferedAudioNode.moduleDescription = "";
+BufferedAudioNode.nodeDescription = "";
 BufferedAudioNode.schema = external_exports2.object({});
-var BufferedStream = class {
-  constructor(properties) {
-    this.events = new EventEmitter();
-    this.properties = properties;
-  }
-  async teardown() {
-    await this._teardown();
-  }
-  _teardown() {
-    return;
-  }
-};
 var BufferedTargetStream = class extends BufferedStream {
   constructor() {
     super(...arguments);
@@ -29500,11 +29706,12 @@ var BufferedTargetStream = class extends BufferedStream {
         }
         await this._write(chunk);
         this.framesWritten += chunk.samples[0]?.length ?? 0;
-        this.events.emit("progress", { framesProcessed: this.framesWritten, sourceTotalFrames: this.sourceTotalFrames });
+        this.emitProgress("write", this.framesWritten, this.sourceTotalFrames);
       },
       close: async () => {
         await this._close();
-        this.events.emit("finished");
+        this.emitProgress("write", this.framesWritten, this.sourceTotalFrames, { force: true });
+        this.events.emit("finished", { framesDone: this.framesWritten });
       }
     });
   }
@@ -29516,6 +29723,7 @@ var TargetNode = class extends BufferedAudioNode {
   setup(readable, context) {
     const stream = this.createStream();
     this.streams.push(stream);
+    wireStream(this, stream, context);
     return Promise.resolve([stream.setup(readable, context)]);
   }
 };
@@ -29539,6 +29747,8 @@ var BufferedTransformStream = class extends BufferedStream {
     super(properties);
     this.processingMs = 0;
     this.framesProcessed = 0;
+    this.framesBuffered = 0;
+    this.framesEmitted = 0;
     this.bufferOffset = 0;
     this.hasStarted = false;
     this.bufferSize = properties.bufferSize ?? 0;
@@ -29589,7 +29799,8 @@ var BufferedTransformStream = class extends BufferedStream {
       }
       this.processingMs += performance.now() - start;
       this.framesProcessed += samplesIn;
-      this.events.emit("progress", { framesProcessed: this.framesProcessed, sourceTotalFrames: this.sourceTotalFrames });
+      this.framesBuffered += samplesIn;
+      this.emitProgress("buffer", this.framesBuffered, this.sourceTotalFrames);
       return;
     }
     let offset = 0;
@@ -29610,16 +29821,22 @@ var BufferedTransformStream = class extends BufferedStream {
     }
     this.processingMs += performance.now() - start;
     this.framesProcessed += samplesIn;
-    this.events.emit("progress", { framesProcessed: this.framesProcessed, sourceTotalFrames: this.sourceTotalFrames });
+    this.framesBuffered += samplesIn;
+    this.emitProgress("buffer", this.framesBuffered, this.sourceTotalFrames);
   }
   async handleFlush(controller) {
+    this.emitProgress("buffer", this.framesBuffered, this.sourceTotalFrames, { force: true });
     if (!this.chunkBuffer || this.chunkBuffer.frames === 0) {
-      this.events.emit("finished");
+      await this.emitFlushChunks(controller);
+      this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames, { force: true });
+      this.events.emit("finished", { framesDone: this.framesBuffered, processingMs: this.processingMs });
       return;
     }
     if (this.bufferSize === 0) {
       await this.chunkBuffer.close();
-      this.events.emit("finished");
+      await this.emitFlushChunks(controller);
+      this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames, { force: true });
+      this.events.emit("finished", { framesDone: this.framesBuffered, processingMs: this.processingMs });
       return;
     }
     try {
@@ -29628,14 +29845,27 @@ var BufferedTransformStream = class extends BufferedStream {
       await this.chunkBuffer.close();
       this.chunkBuffer = void 0;
     }
-    this.events.emit("finished");
+    await this.emitFlushChunks(controller);
+    this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames, { force: true });
+    this.events.emit("finished", { framesDone: this.framesBuffered, processingMs: this.processingMs });
+  }
+  async emitFlushChunks(controller) {
+    const chunks = await this._flush();
+    if (!chunks) return;
+    for (const chunk of chunks) {
+      controller.enqueue(chunk);
+      this.framesEmitted += chunk.samples[0]?.length ?? 0;
+    }
   }
   async processAndEmit(controller) {
     if (!this.chunkBuffer) return;
     const samplesBeforeProcess = this.chunkBuffer.frames;
     const start = performance.now();
+    const wholeFile = this.bufferSize === WHOLE_FILE;
     await this.chunkBuffer.flushWrites();
+    if (wholeFile) this.emitProgress("process", 0, void 0, { force: true });
     await this._process(this.chunkBuffer);
+    if (wholeFile) this.emitProgress("process", samplesBeforeProcess, samplesBeforeProcess, { force: true });
     await this.emitBuffer(controller);
     this.processingMs += performance.now() - start;
     this.framesProcessed += samplesBeforeProcess;
@@ -29664,6 +29894,8 @@ var BufferedTransformStream = class extends BufferedStream {
       };
       const result = await this._unbuffer(adjusted);
       if (result) controller.enqueue(result);
+      this.framesEmitted += chunkFrames;
+      this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames);
       if (overlapScratch) {
         if (chunkFrames >= overlap) {
           for (let ch = 0; ch < channels; ch++) {
@@ -29714,6 +29946,9 @@ var BufferedTransformStream = class extends BufferedStream {
   _unbuffer(chunk) {
     return chunk;
   }
+  _flush() {
+    return void 0;
+  }
 };
 var TransformNode = class _TransformNode extends BufferedAudioNode {
   static is(value) {
@@ -29725,6 +29960,7 @@ var TransformNode = class _TransformNode extends BufferedAudioNode {
   async setup(readable, context) {
     const stream = this.createStream();
     this.streams.push(stream);
+    wireStream(this, stream, context);
     const output = await stream.setup(readable, context);
     return this.setupChildren(output, context);
   }
@@ -29746,6 +29982,7 @@ var BufferedSourceStream = class extends BufferedStream {
   constructor() {
     super(...arguments);
     this.framesRead = 0;
+    this.hasStarted = false;
   }
   setup(context) {
     return this._setup(context);
@@ -29754,6 +29991,7 @@ var BufferedSourceStream = class extends BufferedStream {
   async _setup(context) {
     let done = false;
     this.framesRead = 0;
+    this.hasStarted = false;
     const { signal, durationFrames: sourceTotalFrames, highWaterMark } = context;
     return new ReadableStream(
       {
@@ -29765,16 +30003,22 @@ var BufferedSourceStream = class extends BufferedStream {
             return;
           }
           try {
+            if (!this.hasStarted) {
+              this.hasStarted = true;
+              this.events.emit("started");
+            }
             const chunk = await this._read();
             if (!chunk) {
               done = true;
+              this.emitProgress("read", this.framesRead, sourceTotalFrames, { force: true });
               await this._flush();
+              this.events.emit("finished", { framesDone: this.framesRead });
               controller.close();
               return;
             }
             this.framesRead += chunk.samples[0]?.length ?? 0;
             controller.enqueue(chunk);
-            this.events.emit("progress", { framesProcessed: this.framesRead, sourceTotalFrames });
+            this.emitProgress("read", this.framesRead, sourceTotalFrames);
           } catch (error482) {
             done = true;
             controller.error(error482);
@@ -29805,6 +30049,7 @@ var SourceNode = class extends BufferedAudioNode {
   async setup(context) {
     const stream = this.createStream();
     this.streams.push(stream);
+    wireStream(this, stream, context);
     const readable = await stream.setup(context);
     const promises = await this.setupChildren(readable, context);
     await Promise.all(promises);
@@ -29836,7 +30081,9 @@ var SourceNode = class extends BufferedAudioNode {
       durationFrames: meta32.durationFrames,
       highWaterMark: options?.highWaterMark ?? computedHighWaterMark,
       signal: options?.signal,
-      visited: /* @__PURE__ */ new Set()
+      visited: /* @__PURE__ */ new Set(),
+      onEvent: options?.onEvent,
+      progressQuantum: options?.progressQuantum
     };
     const start = performance.now();
     try {
@@ -29905,39 +30152,24 @@ external_exports2.object({
 });
 var STRIPE_BYTES = 10 * 1024 * 1024;
 async function reverseBuffer(source, dest) {
-  await source.flushWrites();
   const out = dest ?? new ChunkBuffer();
   const channels = source.channels;
   const totalFrames = source.frames;
   if (channels === 0 || totalFrames === 0) return out;
-  const sourcePath = source.tempFilePath();
-  if (!sourcePath) return out;
   const sampleRate = source.sampleRate;
   const bitDepth = source.bitDepth;
   const bytesPerFrame = channels * 4;
   const stripeFramesCap = Math.max(1, Math.floor(STRIPE_BYTES / bytesPerFrame));
-  const handle = await open(sourcePath, "r");
+  const reader = await source.openReverseReader();
   try {
-    let endFrame = totalFrames;
-    while (endFrame > 0) {
-      const stripeFrames = Math.min(stripeFramesCap, endFrame);
-      const startFrame = endFrame - stripeFrames;
-      const buf = Buffer.alloc(stripeFrames * bytesPerFrame);
-      await handle.read(buf, 0, buf.length, startFrame * bytesPerFrame);
-      const interleaved = new Float32Array(buf.buffer, buf.byteOffset, stripeFrames * channels);
-      const reversed = [];
-      for (let ch = 0; ch < channels; ch++) reversed.push(new Float32Array(stripeFrames));
-      for (let frame = 0; frame < stripeFrames; frame++) {
-        const sourceBase = (stripeFrames - 1 - frame) * channels;
-        for (let ch = 0; ch < channels; ch++) {
-          reversed[ch][frame] = interleaved[sourceBase + ch];
-        }
-      }
-      await out.write(reversed, sampleRate, bitDepth);
-      endFrame = startFrame;
+    for (; ; ) {
+      const chunk = await reader.read(stripeFramesCap);
+      const frames = chunk.samples[0]?.length ?? 0;
+      if (frames === 0) break;
+      await out.write(chunk.samples, sampleRate, bitDepth);
     }
   } finally {
-    await handle.close();
+    await reader.close();
   }
   await out.flushWrites();
   return out;
@@ -29946,7 +30178,7 @@ async function reverseBuffer(source, dest) {
 // package.json
 var package_default = {
   name: "@buffered-audio/nodes",
-  version: "0.15.2"};
+  version: "0.17.0"};
 
 // src/package-metadata.ts
 var PACKAGE_NAME = package_default.name;
@@ -29963,11 +30195,7 @@ var AmplitudeHistogramAccumulator = class {
     this.bucketCount = bucketCount;
     this.buckets = new Uint32Array(bucketCount);
   }
-  /**
-   * Consume `frames` samples from each channel. Throws if any channel
-   * has fewer than `frames` samples or if {@link finalize} has already
-   * been called.
-   */
+  // Consumes `frames` samples per channel; throws if any channel has fewer than `frames` samples or if `finalize` was already called.
   push(channels, frames) {
     if (this.finalized) {
       throw new Error("AmplitudeHistogramAccumulator: push() called after finalize()");
@@ -30008,13 +30236,6 @@ var AmplitudeHistogramAccumulator = class {
       }
     }
   }
-  /**
-   * Returns the histogram with linearly-interpolated median. Idempotent
-   * — subsequent calls return the same cached result object.
-   *
-   * Empty / all-zero input yields `bucketMax = 0`, `median = 0`, and an
-   * all-zero `buckets` array, matching the one-shot utility's edge case.
-   */
   finalize() {
     if (this.cachedResult !== void 0) return this.cachedResult;
     this.finalized = true;
@@ -30039,17 +30260,6 @@ var AmplitudeHistogramAccumulator = class {
     this.cachedResult = { buckets: this.buckets, bucketMax: this.bucketMax, median };
     return this.cachedResult;
   }
-  /**
-   * Rebin existing counts into a wider range. Each old bucket's count is
-   * deposited entirely into the new bucket whose interval contains the
-   * old bucket's center. Faster than a proportional split and accuracy
-   * difference is sub-bucket — with 1024 buckets the resolution is
-   * already finer than any practical percentile precision requirement.
-   *
-   * Sample-count invariant: `sum(newBuckets) === sum(oldBuckets)`. This
-   * follows trivially from each old bucket being deposited into exactly
-   * one new bucket.
-   */
   rebucket(newMax) {
     if (this.bucketMax === 0) {
       if (this.pendingZeros > 0) {
@@ -30182,11 +30392,6 @@ var BidirectionalIir = class {
     const tauCausal = this.smoothingMs / 1e3;
     this.alphaCausal = tauCausal > 0 ? 1 - Math.exp(-samplePeriod / tauCausal) : 1;
   }
-  /**
-   * Bidirectional one-pole IIR with sqrt(2)*tau compensation.
-   * Returns a fresh array; input is not mutated. Identity when
-   * smoothingMs <= 0.
-   */
   applyBidirectional(input) {
     const output = Float32Array.from(input);
     if (this.smoothingMs <= 0) return output;
@@ -30206,13 +30411,6 @@ var BidirectionalIir = class {
     }
     return output;
   }
-  /**
-   * Forward-only one-pole IIR, single pass, no compensation. State is
-   * carried by the caller via `{ value: number }` so chunked use can
-   * be continuous. Identity when smoothingMs <= 0 (the input is
-   * returned as a fresh copy so callers can rely on a fresh buffer
-   * regardless).
-   */
   applyCausal(input, state) {
     const output = Float32Array.from(input);
     if (this.smoothingMs <= 0) return output;
@@ -30227,22 +30425,6 @@ var BidirectionalIir = class {
     state.value = y;
     return output;
   }
-  /**
-   * Forward HALF of the bidirectional cascade, chunked. Same loop body
-   * as `applyCausal`, but uses `alphaBidirectional` (the sqrt(2)-
-   * compensated alpha) so the output, after a subsequent
-   * `applyBackwardPassInPlace` on the concatenated forward result,
-   * matches `applyBidirectional`'s output byte-for-byte.
-   *
-   * State is carried by the caller via `{ value: number }`. For the
-   * very first chunk the caller must seed `state.value = input[0]`
-   * (matching `applyBidirectional`'s "init from first sample" rule);
-   * for subsequent chunks `state.value` carries the previous chunk's
-   * trailing forward state.
-   *
-   * Identity when smoothingMs <= 0 (returns a fresh copy of the
-   * input).
-   */
   applyForwardPass(input, state) {
     const output = Float32Array.from(input);
     if (this.smoothingMs <= 0) return output;
@@ -30257,21 +30439,6 @@ var BidirectionalIir = class {
     state.value = y;
     return output;
   }
-  /**
-   * Backward HALF of the bidirectional cascade, run IN PLACE on a
-   * whole-array buffer. The buffer is expected to hold the result of
-   * the forward HALF (e.g. produced by chunked `applyForwardPass`
-   * calls concatenated together). Overwrites `buffer` with the final
-   * smoothed result.
-   *
-   * Init from `buffer[buffer.length - 1]`, matching the second pass of
-   * `applyBidirectional`. Uses `alphaBidirectional`.
-   *
-   * Whole-array (not chunked) — backward IIR cannot stream forward
-   * because it must walk end-to-start.
-   *
-   * Identity (no-op) when smoothingMs <= 0.
-   */
   applyBackwardPassInPlace(buffer) {
     if (this.smoothingMs <= 0) return;
     if (buffer.length === 0) return;
@@ -30304,12 +30471,7 @@ var BlockSumAccumulator = class {
     this.ringSize = computeRingSize(blockSize, blockStep);
     this.activeBlockSums = new Float64Array(this.ringSize);
   }
-  /**
-   * Consume `frames` per-frame sums starting at `perFrameSums[0]`.
-   * `perFrameSums.length` must be at least `frames`. Block boundary
-   * accounting advances exactly as if these values were appended to a
-   * single contiguous stream.
-   */
+  // 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()");
@@ -30322,34 +30484,35 @@ var BlockSumAccumulator = class {
     const blockStep = this.blockStep;
     const ringSize = this.ringSize;
     const activeBlockSums = this.activeBlockSums;
+    let samplesProcessed = this.samplesProcessed;
+    let nextBlockToOpen = this.nextBlockToOpen;
+    let nextBlockToClose = this.nextBlockToClose;
+    let nextOpenAt = nextBlockToOpen * blockStep;
+    let nextCloseAt = nextBlockToClose * blockStep + blockSize;
     for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
-      const globalSampleIndex = this.samplesProcessed;
       const sampleContribution = perFrameSums[frameIndex] ?? 0;
-      const rawMinBlock = Math.ceil((globalSampleIndex - blockSize + 1) / blockStep);
-      const minBlock = rawMinBlock < 0 ? 0 : rawMinBlock;
-      const maxBlock = Math.floor(globalSampleIndex / blockStep);
-      while (this.nextBlockToOpen <= maxBlock) {
-        activeBlockSums[this.nextBlockToOpen % ringSize] = 0;
-        this.nextBlockToOpen++;
-      }
-      for (let blockIndex = minBlock; blockIndex <= maxBlock; blockIndex++) {
-        const slot = blockIndex % ringSize;
+      while (samplesProcessed >= nextOpenAt) {
+        activeBlockSums[nextBlockToOpen % ringSize] = 0;
+        nextBlockToOpen++;
+        nextOpenAt += blockStep;
+      }
+      let slot = nextBlockToClose % ringSize;
+      for (let blockIndex = nextBlockToClose; blockIndex < nextBlockToOpen; blockIndex++) {
         activeBlockSums[slot] = (activeBlockSums[slot] ?? 0) + sampleContribution;
+        slot++;
+        if (slot === ringSize) slot = 0;
       }
-      this.samplesProcessed = globalSampleIndex + 1;
-      while (this.samplesProcessed >= this.nextBlockToClose * blockStep + blockSize) {
-        const closingIndex = this.nextBlockToClose;
-        const slot = closingIndex % ringSize;
-        this.closedBlockSums.push(activeBlockSums[slot] ?? 0);
-        this.nextBlockToClose++;
+      samplesProcessed++;
+      while (samplesProcessed >= nextCloseAt) {
+        this.closedBlockSums.push(activeBlockSums[nextBlockToClose % ringSize] ?? 0);
+        nextBlockToClose++;
+        nextCloseAt += blockStep;
       }
     }
+    this.samplesProcessed = samplesProcessed;
+    this.nextBlockToOpen = nextBlockToOpen;
+    this.nextBlockToClose = nextBlockToClose;
   }
-  /**
-   * Return the raw closed block sums in block-index order. Idempotent —
-   * additional calls return the same array. Subsequent {@link push}
-   * calls throw.
-   */
   finalize() {
     this.finalized = true;
     return this.closedBlockSums;
@@ -30475,14 +30638,7 @@ var KWeightedSquaredSum = class {
       this.weights[channelIndex] = weights[channelIndex] ?? 1;
     }
   }
-  /**
-   * Consume `frames` of audio. `channels[c]` must have at least `frames`
-   * valid samples starting at index 0; oversized buffers are fine.
-   * `output` must have at least `frames` entries — `output[i]` receives
-   * the K-weighted, channel-weighted, squared sum at frame `i`. Biquad
-   * state advances exactly as if the samples were appended to a single
-   * contiguous buffer.
-   */
+  // `channels[c]` and `output` need >= `frames` entries from index 0 (oversized OK); `output[i]` gets the K-weighted channel-weighted squared sum at frame `i`; biquad state advances as if appended contiguously.
   push(channels, frames, output) {
     if (channels.length !== this.channelCount) {
       throw new Error(`KWeightedSquaredSum: push got ${channels.length} channels, expected ${this.channelCount}`);
@@ -30509,40 +30665,56 @@ var KWeightedSquaredSum = class {
     const rlbB2 = this.rlbB2;
     const rlbA1 = this.rlbA1;
     const rlbA2 = this.rlbA2;
-    const preX1 = this.preX1;
-    const preX2 = this.preX2;
-    const preY1 = this.preY1;
-    const preY2 = this.preY2;
-    const rlbX1 = this.rlbX1;
-    const rlbX2 = this.rlbX2;
-    const rlbY1 = this.rlbY1;
-    const rlbY2 = this.rlbY2;
-    for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
-      let sampleContribution = 0;
-      for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
-        const channel = channels[channelIndex] ?? channels[0] ?? new Float32Array(0);
-        const x0 = channel[frameIndex] ?? 0;
-        const px1 = preX1[channelIndex] ?? 0;
-        const px2 = preX2[channelIndex] ?? 0;
-        const py1 = preY1[channelIndex] ?? 0;
-        const py2 = preY2[channelIndex] ?? 0;
-        const preY = preB0 * x0 + preB1 * px1 + preB2 * px2 - preA1 * py1 - preA2 * py2;
-        preX2[channelIndex] = px1;
-        preX1[channelIndex] = x0;
-        preY2[channelIndex] = py1;
-        preY1[channelIndex] = preY;
-        const rx1 = rlbX1[channelIndex] ?? 0;
-        const rx2 = rlbX2[channelIndex] ?? 0;
-        const ry1 = rlbY1[channelIndex] ?? 0;
-        const ry2 = rlbY2[channelIndex] ?? 0;
-        const rlbY = rlbB0 * preY + rlbB1 * rx1 + rlbB2 * rx2 - rlbA1 * ry1 - rlbA2 * ry2;
-        rlbX2[channelIndex] = rx1;
-        rlbX1[channelIndex] = preY;
-        rlbY2[channelIndex] = ry1;
-        rlbY1[channelIndex] = rlbY;
-        sampleContribution += (weights[channelIndex] ?? 1) * rlbY * rlbY;
-      }
-      output[frameIndex] = sampleContribution;
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+      const channel = channels[channelIndex] ?? channels[0] ?? new Float32Array(0);
+      const weight = weights[channelIndex] ?? 1;
+      let px1 = this.preX1[channelIndex] ?? 0;
+      let px2 = this.preX2[channelIndex] ?? 0;
+      let py1 = this.preY1[channelIndex] ?? 0;
+      let py2 = this.preY2[channelIndex] ?? 0;
+      let rx1 = this.rlbX1[channelIndex] ?? 0;
+      let rx2 = this.rlbX2[channelIndex] ?? 0;
+      let ry1 = this.rlbY1[channelIndex] ?? 0;
+      let ry2 = this.rlbY2[channelIndex] ?? 0;
+      if (channelIndex === 0) {
+        for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
+          const x0 = channel[frameIndex] ?? 0;
+          const preY = preB0 * x0 + preB1 * px1 + preB2 * px2 - preA1 * py1 - preA2 * py2;
+          px2 = px1;
+          px1 = x0;
+          py2 = py1;
+          py1 = preY;
+          const rlbY = rlbB0 * preY + rlbB1 * rx1 + rlbB2 * rx2 - rlbA1 * ry1 - rlbA2 * ry2;
+          rx2 = rx1;
+          rx1 = preY;
+          ry2 = ry1;
+          ry1 = rlbY;
+          output[frameIndex] = weight * rlbY * rlbY;
+        }
+      } else {
+        for (let frameIndex = 0; frameIndex < frames; frameIndex++) {
+          const x0 = channel[frameIndex] ?? 0;
+          const preY = preB0 * x0 + preB1 * px1 + preB2 * px2 - preA1 * py1 - preA2 * py2;
+          px2 = px1;
+          px1 = x0;
+          py2 = py1;
+          py1 = preY;
+          const rlbY = rlbB0 * preY + rlbB1 * rx1 + rlbB2 * rx2 - rlbA1 * ry1 - rlbA2 * ry2;
+          rx2 = rx1;
+          rx1 = preY;
+          ry2 = ry1;
+          ry1 = rlbY;
+          output[frameIndex] = (output[frameIndex] ?? 0) + weight * rlbY * rlbY;
+        }
+      }
+      this.preX1[channelIndex] = px1;
+      this.preX2[channelIndex] = px2;
+      this.preY1[channelIndex] = py1;
+      this.preY2[channelIndex] = py2;
+      this.rlbX1[channelIndex] = rx1;
+      this.rlbX2[channelIndex] = rx2;
+      this.rlbY1[channelIndex] = ry1;
+      this.rlbY2[channelIndex] = ry2;
     }
   }
 };
@@ -30602,13 +30774,7 @@ var IntegratedLufsAccumulator = class {
     this.kw = new KWeightedSquaredSum(sampleRate, channelCount, channelWeights);
     this.blocks = new BlockSumAccumulator(this.blockSize, blockStep);
   }
-  /**
-   * Consume `frames` of audio. `channels[c]` must have at least
-   * `frames` valid samples starting at index 0; oversized buffers are
-   * fine and avoid the need for caller-side slicing. The accumulator
-   * advances biquad state and block accounting exactly as if these
-   * samples were appended to a single contiguous buffer.
-   */
+  // `channels[c]` needs >= `frames` valid samples from index 0 (oversized OK); state advances as if appended to one contiguous buffer.
   push(channels, frames) {
     if (this.finalized) {
       throw new Error("IntegratedLufsAccumulator: push() called after finalize()");
@@ -30620,12 +30786,6 @@ var IntegratedLufsAccumulator = class {
     this.kw.push(channels, frames, this.outputBuffer);
     this.blocks.push(this.outputBuffer, frames);
   }
-  /**
-   * Apply the BS.1770 two-stage gating to all completed blocks and
-   * return integrated LUFS. Returns -Infinity if no blocks completed
-   * (signal shorter than one 400 ms block) or if every block fails the
-   * absolute or relative gate.
-   */
   finalize() {
     this.finalized = true;
     return applyBs1770Gating(this.blocks.finalize(), this.blockSize);
@@ -30709,11 +30869,6 @@ var LoudnessAccumulator = class {
     this.blocks400 = new BlockSumAccumulator(this.blockSize400, blockStep);
     this.blocks3s = new BlockSumAccumulator(this.blockSize3s, blockStep);
   }
-  /**
-   * Consume `frames` of audio, advancing the K-weighting state and both
-   * block-sum accumulators in lockstep. Identical chunk-boundary
-   * semantics to {@link IntegratedLufsAccumulator.push}.
-   */
   push(channels, frames) {
     if (this.finalized) {
       throw new Error("LoudnessAccumulator: push() called after finalize()");
@@ -30726,11 +30881,6 @@ var LoudnessAccumulator = class {
     this.blocks400.push(this.outputBuffer, frames);
     this.blocks3s.push(this.outputBuffer, frames);
   }
-  /**
-   * Finalize and return all four metrics. Idempotent — additional calls
-   * return the same cached result object reference. Subsequent
-   * {@link push} calls throw.
-   */
   finalize() {
     if (this.cachedResult !== void 0) return this.cachedResult;
     this.finalized = true;
@@ -31193,20 +31343,6 @@ var SlidingWindowMaxStream = class {
     this.lookAhead = new Float32Array(ringCapacity);
     this.deque = new Int32Array(ringCapacity);
   }
-  /**
-   * Ingest the next chunk of input. Returns the next chunk of output
-   * (deferred by `halfWidth` on the leading edge). When `isFinal` is
-   * `true`, the trailing-edge outputs are flushed with the right-edge
-   * clamped to the last ingested input index.
-   *
-   * The return value's length depends on the leading-edge fill state:
-   *   - Until total ingested ≥ `halfWidth + 1`, output length is 0
-   *     unless `isFinal` is true.
-   *   - Steady state: output length equals input chunk length.
-   *   - On the final chunk: output length equals input chunk length
-   *     plus any trailing-edge outputs not yet emitted (so total
-   *     across all calls equals total input length).
-   */
   push(chunk, isFinal) {
     const chunkLength = chunk.length;
     const halfWidth = this.halfWidth;
@@ -31276,12 +31412,6 @@ var SlidingWindowMinStream = class {
     this.lookAhead = new Float32Array(ringCapacity);
     this.deque = new Int32Array(ringCapacity);
   }
-  /**
-   * Ingest the next chunk of input. Returns the next chunk of output
-   * (deferred by `halfWidth` on the leading edge). When `isFinal` is
-   * `true`, the trailing-edge outputs are flushed with the right-edge
-   * clamped to the last ingested input index.
-   */
   push(chunk, isFinal) {
     const chunkLength = chunk.length;
     const halfWidth = this.halfWidth;
@@ -31578,119 +31708,144 @@ function butterflyStages(re, im, size) {
 }
 var TAPS_PER_PHASE_4X = 12;
 var HISTORY_LENGTH_4X = TAPS_PER_PHASE_4X;
-var COEFFICIENTS_4X = [
-  // Phase 0 — identity tap (output sample = input sample).
-  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  // Phase 1
-  [
-    0.001708984375,
-    0.010986328125,
-    -0.0196533203125,
-    0.033203125,
-    -0.0594482421875,
-    0.1373291015625,
-    0.97216796875,
-    -0.102294921875,
-    0.047607421875,
-    -0.026611328125,
-    0.014892578125,
-    -0.00830078125
-  ],
-  // Phase 2
-  [
-    -0.0291748046875,
-    0.029296875,
-    -0.0517578125,
-    0.089111328125,
-    -0.16650390625,
-    0.465087890625,
-    0.77978515625,
-    -0.2003173828125,
-    0.1015625,
-    -0.0582275390625,
-    0.0330810546875,
-    -0.0189208984375
-  ],
-  // Phase 3
-  [
-    -0.0189208984375,
-    0.0330810546875,
-    -0.0582275390625,
-    0.1015625,
-    -0.2003173828125,
-    0.77978515625,
-    0.465087890625,
-    -0.16650390625,
-    0.089111328125,
-    -0.0517578125,
-    0.029296875,
-    -0.0291748046875
-  ]
-];
+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 TruePeakUpsampler = class {
   constructor(factor = 4) {
-    this.writeIndex = 0;
+    this.work = new Float64Array(0);
     if (factor !== 4) {
       throw new Error(`TruePeakUpsampler: factor ${factor} is not yet implemented; only 4\xD7 (BS.1770-4 Annex 1) is supported`);
     }
     this.factor = factor;
     this.history = new Float64Array(HISTORY_LENGTH_4X);
   }
-  /**
-   * Push one chunk of input samples and return the upsampled chunk.
-   * Output length is `input.length * factor`. State carries across
-   * calls — feeding the same source in any chunk pattern produces
-   * the same upsampled samples (modulo float ordering, which is
-   * deterministic).
-   *
-   * The first 11 output frames after a {@link reset} (or after
-   * construction) are coloured by the cold filter history (zeros).
-   * For true-peak measurement this is harmless — the max-tracking
-   * downstream sees only values ≤ the actual settled peak during
-   * that ramp-up.
-   */
-  upsample(input) {
+  // `outputScratch` (>= input.length × factor) avoids the per-call allocation; the returned view aliases it.
+  upsample(input, outputScratch) {
     const factor = this.factor;
     const inputLength = input.length;
-    const output = new Float32Array(inputLength * factor);
+    const outputLength = inputLength * factor;
+    const output = outputScratch !== void 0 && outputScratch.length >= outputLength ? outputScratch.subarray(0, outputLength) : new Float32Array(outputLength);
     const history = this.history;
     const historyLength = HISTORY_LENGTH_4X;
-    let writeIndex = this.writeIndex;
+    const workLength = historyLength + inputLength;
+    if (this.work.length < workLength) {
+      this.work = new Float64Array(workLength);
+    }
+    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 sample = input[inIdx] ?? 0;
-      history[writeIndex] = sample;
-      writeIndex = (writeIndex + 1) % historyLength;
+      const currentIdx = historyLength + inIdx;
       const outOffset = inIdx * factor;
-      output[outOffset] = sample;
-      for (let phase2 = 1; phase2 < factor; phase2++) {
-        const taps = COEFFICIENTS_4X[phase2];
-        if (taps === void 0) continue;
-        let acc = 0;
-        let readIndex = writeIndex - 1;
-        if (readIndex < 0) readIndex += historyLength;
-        for (let tap = 0; tap < historyLength; tap++) {
-          acc += (taps[tap] ?? 0) * (history[readIndex] ?? 0);
-          readIndex -= 1;
-          if (readIndex < 0) readIndex += historyLength;
-        }
-        output[outOffset + phase2] = acc;
-      }
-    }
-    this.writeIndex = writeIndex;
+      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;
+    }
+    if (inputLength >= historyLength) {
+      history.set(work.subarray(workLength - historyLength, workLength), 0);
+    } else if (inputLength > 0) {
+      history.copyWithin(0, inputLength);
+      history.set(work.subarray(historyLength, workLength), historyLength - inputLength);
+    }
     return output;
   }
-  /**
-   * Reset the 12-sample input history to zeros. Use when starting a
-   * new render / stream / measurement on the same instance.
-   */
   reset() {
     this.history.fill(0);
-    this.writeIndex = 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;
     if (channelCount <= 0) {
       throw new Error(`TruePeakAccumulator: channelCount must be positive, got ${channelCount}`);
@@ -31702,18 +31857,7 @@ var TruePeakAccumulator = class {
     }
     this.upsamplers = upsamplers;
   }
-  /**
-   * Consume `frames` of audio. `channels[c]` must have at least
-   * `frames` valid samples starting at index 0; oversized buffers are
-   * fine and avoid the need for caller-side slicing. The accumulator
-   * advances per-channel upsampler state exactly as if the samples
-   * were appended to a single contiguous buffer.
-   *
-   * The `frames` argument is accepted for symmetry with
-   * {@link IntegratedLufsAccumulator} even though
-   * {@link TruePeakUpsampler.upsample} derives length from the input
-   * slice.
-   */
+  // `channels[c]` needs >= `frames` valid samples from index 0 (oversized OK); advances per-channel upsampler state as if appended contiguously.
   push(channels, frames) {
     if (channels.length !== this.channelCount) {
       throw new Error(`TruePeakAccumulator: push got ${channels.length} channels, expected ${this.channelCount}`);
@@ -31729,7 +31873,10 @@ var TruePeakAccumulator = class {
         throw new Error(`TruePeakAccumulator: missing upsampler for channel ${channelIndex}`);
       }
       const slice = channel.length === frames ? channel : channel.subarray(0, frames);
-      const upsampled = upsampler.upsample(slice);
+      if (this.upsampleScratch.length < frames * upsampler.factor) {
+        this.upsampleScratch = new Float32Array(frames * upsampler.factor);
+      }
+      const upsampled = upsampler.upsample(slice, this.upsampleScratch);
       for (let index = 0; index < upsampled.length; index++) {
         const sample = upsampled[index] ?? 0;
         const magnitude = sample < 0 ? -sample : sample;
@@ -31737,11 +31884,6 @@ var TruePeakAccumulator = class {
       }
     }
   }
-  /**
-   * Return the linear amplitude max(|x|) across all upsampled samples
-   * and all channels. Idempotent — additional calls return the same
-   * value. Returns 0 when no samples have been pushed.
-   */
   finalize() {
     return this.runningMax;
   }
@@ -32244,10 +32386,10 @@ var _ReadFfmpegNode = class _ReadFfmpegNode extends SourceNode {
     return new _ReadFfmpegNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_ReadFfmpegNode.moduleName = "Read FFmpeg";
+_ReadFfmpegNode.nodeName = "Read FFmpeg";
 _ReadFfmpegNode.packageName = PACKAGE_NAME;
 _ReadFfmpegNode.packageVersion = PACKAGE_VERSION;
-_ReadFfmpegNode.moduleDescription = "Read audio from a file using FFmpeg";
+_ReadFfmpegNode.nodeDescription = "Read audio from a file using FFmpeg";
 _ReadFfmpegNode.schema = ffmpegSchema;
 var ReadFfmpegNode = _ReadFfmpegNode;
 function readFfmpeg(path2, options) {
@@ -32427,10 +32569,10 @@ var _ReadWavNode = class _ReadWavNode extends SourceNode {
     return new _ReadWavNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_ReadWavNode.moduleName = "Read WAV";
+_ReadWavNode.nodeName = "Read WAV";
 _ReadWavNode.packageName = PACKAGE_NAME;
 _ReadWavNode.packageVersion = PACKAGE_VERSION;
-_ReadWavNode.moduleDescription = "Read audio from a WAV file";
+_ReadWavNode.nodeDescription = "Read audio from a WAV file";
 _ReadWavNode.schema = wavSchema;
 var ReadWavNode = _ReadWavNode;
 function readWav(path2, options) {
@@ -32462,10 +32604,10 @@ var _ReadNode = class _ReadNode extends SourceNode {
     return new _ReadNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_ReadNode.moduleName = "Read";
+_ReadNode.nodeName = "Read";
 _ReadNode.packageName = PACKAGE_NAME;
 _ReadNode.packageVersion = PACKAGE_VERSION;
-_ReadNode.moduleDescription = "Read audio from a file";
+_ReadNode.nodeDescription = "Read audio from a file";
 _ReadNode.schema = schema;
 var ReadNode = _ReadNode;
 function read(path2, options) {
@@ -32599,10 +32741,10 @@ var _LoudnessStatsNode = class _LoudnessStatsNode extends TargetNode {
     return new _LoudnessStatsNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_LoudnessStatsNode.moduleName = "Loudness Stats";
+_LoudnessStatsNode.nodeName = "Loudness Stats";
 _LoudnessStatsNode.packageName = PACKAGE_NAME;
 _LoudnessStatsNode.packageVersion = PACKAGE_VERSION;
-_LoudnessStatsNode.moduleDescription = "Measure integrated loudness, true peak, and loudness range per EBU R128, plus an amplitude-distribution histogram";
+_LoudnessStatsNode.nodeDescription = "Measure integrated loudness, true peak, and loudness range per EBU R128, plus an amplitude-distribution histogram";
 _LoudnessStatsNode.schema = schema2;
 var LoudnessStatsNode = _LoudnessStatsNode;
 function loudnessStats(options) {
@@ -32942,10 +33084,10 @@ var _SpectrogramNode = class _SpectrogramNode extends TargetNode {
     return new _SpectrogramNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_SpectrogramNode.moduleName = "Spectrogram";
+_SpectrogramNode.nodeName = "Spectrogram";
 _SpectrogramNode.packageName = PACKAGE_NAME;
 _SpectrogramNode.packageVersion = PACKAGE_VERSION;
-_SpectrogramNode.moduleDescription = "Generate spectrogram visualization data";
+_SpectrogramNode.nodeDescription = "Generate spectrogram visualization data";
 _SpectrogramNode.schema = schema3;
 var SpectrogramNode = _SpectrogramNode;
 function spectrogram(outputPath, options) {
@@ -33093,10 +33235,10 @@ var _WaveformNode = class _WaveformNode extends TargetNode {
     return new _WaveformNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_WaveformNode.moduleName = "Waveform";
+_WaveformNode.nodeName = "Waveform";
 _WaveformNode.packageName = PACKAGE_NAME;
 _WaveformNode.packageVersion = PACKAGE_VERSION;
-_WaveformNode.moduleDescription = "Generate waveform visualization data";
+_WaveformNode.nodeDescription = "Generate waveform visualization data";
 _WaveformNode.schema = schema4;
 var WaveformNode = _WaveformNode;
 function waveform(outputPath, options) {
@@ -33411,10 +33553,10 @@ var _WriteNode = class _WriteNode extends TargetNode {
     return new _WriteNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_WriteNode.moduleName = "Write";
+_WriteNode.nodeName = "Write";
 _WriteNode.packageName = PACKAGE_NAME;
 _WriteNode.packageVersion = PACKAGE_VERSION;
-_WriteNode.moduleDescription = "Write audio to a file";
+_WriteNode.nodeDescription = "Write audio to a file";
 _WriteNode.schema = schema5;
 var WriteNode = _WriteNode;
 function write(path2, options) {
@@ -33502,10 +33644,10 @@ var _CutNode = class _CutNode extends TransformNode {
     return new _CutNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_CutNode.moduleName = "Cut";
+_CutNode.nodeName = "Cut";
 _CutNode.packageName = PACKAGE_NAME;
 _CutNode.packageVersion = PACKAGE_VERSION;
-_CutNode.moduleDescription = "Remove a region of audio";
+_CutNode.nodeDescription = "Remove a region of audio";
 _CutNode.schema = schema6;
 var CutNode = _CutNode;
 function cut(regions, options) {
@@ -33567,10 +33709,10 @@ var _DitherNode = class _DitherNode extends TransformNode {
     return new _DitherNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_DitherNode.moduleName = "Dither";
+_DitherNode.nodeName = "Dither";
 _DitherNode.packageName = PACKAGE_NAME;
 _DitherNode.packageVersion = PACKAGE_VERSION;
-_DitherNode.moduleDescription = "Add shaped noise to reduce quantization distortion";
+_DitherNode.nodeDescription = "Add shaped noise to reduce quantization distortion";
 _DitherNode.schema = schema7;
 var DitherNode = _DitherNode;
 function dither(bitDepth, options) {
@@ -33629,10 +33771,10 @@ var _NormalizeNode = class _NormalizeNode extends TransformNode {
     return new _NormalizeNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_NormalizeNode.moduleName = "Normalize";
+_NormalizeNode.nodeName = "Normalize";
 _NormalizeNode.packageName = PACKAGE_NAME;
 _NormalizeNode.packageVersion = PACKAGE_VERSION;
-_NormalizeNode.moduleDescription = "Adjust peak or loudness level to a target ceiling";
+_NormalizeNode.nodeDescription = "Adjust peak or loudness level to a target ceiling";
 _NormalizeNode.schema = schema8;
 var NormalizeNode = _NormalizeNode;
 function normalize(options) {
@@ -33646,53 +33788,57 @@ var schema9 = external_exports.object({
   after: external_exports.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;
-    if (channels === 0) return;
-    const sr = buffer.sampleRate ?? 44100;
-    const bd = buffer.bitDepth;
-    const leading = Math.round(before * sr);
-    const trailing = Math.round(after * sr);
-    if (leading === 0 && trailing === 0) return;
-    const output = new ChunkBuffer();
-    try {
-      await writeSilence(output, leading, channels, CHUNK_FRAMES, sr, bd);
-      for (; ; ) {
-        const chunk = await buffer.read(CHUNK_FRAMES);
-        const chunkFrames = chunk.samples[0]?.length ?? 0;
-        if (chunkFrames === 0) break;
-        await output.write(chunk.samples, sr, bd);
-        if (chunkFrames < CHUNK_FRAMES) break;
-      }
-      await writeSilence(output, trailing, channels, CHUNK_FRAMES, sr, bd);
-      await buffer.clear();
-      await output.reset();
-      for (; ; ) {
-        const chunk = await output.read(CHUNK_FRAMES);
-        const chunkFrames = chunk.samples[0]?.length ?? 0;
-        if (chunkFrames === 0) break;
-        await buffer.write(chunk.samples, sr, bd);
-        if (chunkFrames < CHUNK_FRAMES) break;
+  constructor() {
+    super(...arguments);
+    this.seenChunk = false;
+    this.capturedSampleRate = 44100;
+    this.capturedBitDepth = 32;
+    this.capturedChannels = 0;
+    this.outputOffset = 0;
+  }
+  _unbuffer(chunk) {
+    const frames = chunk.samples[0]?.length ?? 0;
+    if (!this.seenChunk) {
+      this.seenChunk = true;
+      this.capturedSampleRate = chunk.sampleRate;
+      this.capturedBitDepth = chunk.bitDepth;
+      this.capturedChannels = chunk.samples.length;
+      const leading = Math.round(this.properties.before * chunk.sampleRate);
+      if (leading > 0) {
+        const samples = chunk.samples.map((channel) => {
+          const padded = new Float32Array(leading + frames);
+          padded.set(channel, leading);
+          return padded;
+        });
+        const offset2 = this.outputOffset;
+        this.outputOffset += leading + frames;
+        return { samples, offset: offset2, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
       }
-    } finally {
-      await output.close();
     }
+    const offset = this.outputOffset;
+    this.outputOffset += frames;
+    return { samples: chunk.samples, offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
   }
-};
-async function writeSilence(target, frames, channels, chunkSize, sampleRate, bitDepth) {
-  let remaining = frames;
-  while (remaining > 0) {
-    const take = Math.min(chunkSize, remaining);
-    const silence = [];
-    for (let ch = 0; ch < channels; ch++) silence.push(new Float32Array(take));
-    await target.write(silence, sampleRate, bitDepth);
-    remaining -= take;
+  _flush() {
+    if (!this.seenChunk) return void 0;
+    const trailing = Math.round(this.properties.after * this.capturedSampleRate);
+    if (trailing === 0) return void 0;
+    const chunks = [];
+    let remaining = trailing;
+    while (remaining > 0) {
+      const take = Math.min(CHUNK_FRAMES, remaining);
+      const samples = Array.from({ length: this.capturedChannels }, () => new Float32Array(take));
+      const offset = this.outputOffset;
+      this.outputOffset += take;
+      chunks.push({ samples, offset, sampleRate: this.capturedSampleRate, bitDepth: this.capturedBitDepth });
+      remaining -= take;
+    }
+    return chunks;
   }
-}
+};
 var _PadNode = class _PadNode extends TransformNode {
   constructor(properties) {
-    super({ bufferSize: WHOLE_FILE, latency: WHOLE_FILE, ...properties });
+    super({ bufferSize: 0, latency: 0, ...properties });
     this.type = ["buffered-audio-node", "transform", "pad"];
   }
   static is(value) {
@@ -33705,10 +33851,10 @@ var _PadNode = class _PadNode extends TransformNode {
     return new _PadNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_PadNode.moduleName = "Pad";
+_PadNode.nodeName = "Pad";
 _PadNode.packageName = PACKAGE_NAME;
 _PadNode.packageVersion = PACKAGE_VERSION;
-_PadNode.moduleDescription = "Add silence to start or end of audio";
+_PadNode.nodeDescription = "Add silence to start or end of audio";
 _PadNode.schema = schema9;
 var PadNode = _PadNode;
 function pad(options) {
@@ -33782,10 +33928,10 @@ var _PhaseNode = class _PhaseNode extends TransformNode {
     return new _PhaseNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_PhaseNode.moduleName = "Phase";
+_PhaseNode.nodeName = "Phase";
 _PhaseNode.packageName = PACKAGE_NAME;
 _PhaseNode.packageVersion = PACKAGE_VERSION;
-_PhaseNode.moduleDescription = "Invert or rotate signal phase";
+_PhaseNode.nodeDescription = "Invert or rotate signal phase";
 _PhaseNode.schema = schema10;
 var PhaseNode = _PhaseNode;
 function phase(options) {
@@ -33839,10 +33985,10 @@ var _ReverseNode = class _ReverseNode extends TransformNode {
     return new _ReverseNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_ReverseNode.moduleName = "Reverse";
+_ReverseNode.nodeName = "Reverse";
 _ReverseNode.packageName = PACKAGE_NAME;
 _ReverseNode.packageVersion = PACKAGE_VERSION;
-_ReverseNode.moduleDescription = "Reverse audio playback direction";
+_ReverseNode.nodeDescription = "Reverse audio playback direction";
 _ReverseNode.schema = schema11;
 var ReverseNode = _ReverseNode;
 function reverse(options) {
@@ -33970,10 +34116,10 @@ var _SpliceNode = class _SpliceNode extends TransformNode {
     return new _SpliceNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_SpliceNode.moduleName = "Splice";
+_SpliceNode.nodeName = "Splice";
 _SpliceNode.packageName = PACKAGE_NAME;
 _SpliceNode.packageVersion = PACKAGE_VERSION;
-_SpliceNode.moduleDescription = "Replace a region of audio with processed content";
+_SpliceNode.nodeDescription = "Replace a region of audio with processed content";
 _SpliceNode.schema = schema12;
 var SpliceNode = _SpliceNode;
 function splice(insertPath, insertAt, options) {
@@ -34003,7 +34149,6 @@ function findLastAbove(samples, frames, threshold) {
 }
 
 // src/transforms/trim/index.ts
-var CHUNK_FRAMES3 = 44100;
 var schema13 = external_exports.object({
   threshold: external_exports.number().min(0).max(1).multipleOf(1e-3).default(1e-3).describe("Threshold"),
   margin: external_exports.number().min(0).max(1).multipleOf(1e-3).default(0.01).describe("Margin"),
@@ -34011,93 +34156,66 @@ var schema13 = external_exports.object({
   end: external_exports.boolean().default(true).describe("End")
 });
 var TrimStream = class extends BufferedTransformStream {
+  constructor() {
+    super(...arguments);
+    this.firstAbove = Infinity;
+    this.lastAbove = -1;
+    this.scanOffset = 0;
+    this.startFrame = 0;
+    this.endFrame = 0;
+  }
+  async _buffer(chunk, buffer) {
+    await super._buffer(chunk, buffer);
+    const chunkFrames = chunk.samples[0]?.length ?? 0;
+    if (chunkFrames === 0) return;
+    const threshold = this.properties.threshold;
+    const localFirst = findFirstAbove(chunk.samples, chunkFrames, threshold);
+    if (localFirst < chunkFrames) {
+      const abs = this.scanOffset + localFirst;
+      if (abs < this.firstAbove) this.firstAbove = abs;
+      this.lastAbove = Math.max(this.lastAbove, this.scanOffset + findLastAbove(chunk.samples, chunkFrames, threshold));
+    }
+    this.scanOffset += chunkFrames;
+  }
   async _process(buffer) {
     const frames = buffer.frames;
     const channels = buffer.channels;
     if (channels === 0 || frames === 0) return;
-    const threshold = this.properties.threshold;
-    const sr = buffer.sampleRate ?? 44100;
-    const bd = buffer.bitDepth;
-    const marginFrames = Math.round(this.properties.margin * sr);
-    const trimStart = this.properties.start;
-    const trimEnd = this.properties.end;
-    await buffer.reset();
-    let firstAbove = frames;
-    let lastAbove = -1;
-    let scanOffset = 0;
-    for (; ; ) {
-      const chunk = await buffer.read(CHUNK_FRAMES3);
-      const chunkFrames = chunk.samples[0]?.length ?? 0;
-      if (chunkFrames === 0) break;
-      const localFirst = findFirstAbove(chunk.samples, chunkFrames, threshold);
-      if (localFirst < chunkFrames) {
-        const abs = scanOffset + localFirst;
-        if (abs < firstAbove) firstAbove = abs;
-        lastAbove = Math.max(lastAbove, scanOffset + findLastAbove(chunk.samples, chunkFrames, threshold));
-      }
-      scanOffset += chunkFrames;
-      if (chunkFrames < CHUNK_FRAMES3) break;
-    }
-    if (firstAbove >= frames) {
+    if (this.firstAbove >= frames) {
       await buffer.clear();
       return;
     }
+    const sr = buffer.sampleRate ?? 44100;
+    const marginFrames = Math.round(this.properties.margin * sr);
     let startFrame = 0;
     let endFrame = frames;
-    if (trimStart) {
-      startFrame = Math.max(0, firstAbove - marginFrames);
-    }
-    if (trimEnd) {
-      endFrame = Math.min(frames, lastAbove + 1 + marginFrames);
-    }
+    if (this.properties.start) startFrame = Math.max(0, this.firstAbove - marginFrames);
+    if (this.properties.end) endFrame = Math.min(frames, this.lastAbove + 1 + marginFrames);
     if (startFrame >= endFrame) {
       await buffer.clear();
       return;
     }
-    if (startFrame === 0 && endFrame === frames) return;
-    const output = new ChunkBuffer();
-    try {
-      await buffer.reset();
-      let copyOffset = 0;
-      for (; ; ) {
-        const chunk = await buffer.read(CHUNK_FRAMES3);
-        const chunkFrames = chunk.samples[0]?.length ?? 0;
-        if (chunkFrames === 0) break;
-        const chunkStart = copyOffset;
-        const chunkEnd = copyOffset + chunkFrames;
-        const overlapStart = Math.max(chunkStart, startFrame);
-        const overlapEnd = Math.min(chunkEnd, endFrame);
-        if (overlapEnd > overlapStart) {
-          const sliceStart = overlapStart - chunkStart;
-          const sliceEnd = overlapEnd - chunkStart;
-          if (sliceStart === 0 && sliceEnd === chunkFrames) {
-            await output.write(chunk.samples, sr, bd);
-          } else {
-            const sliced = [];
-            for (let ch = 0; ch < channels; ch++) {
-              const source = chunk.samples[ch];
-              if (source) sliced.push(source.subarray(sliceStart, sliceEnd));
-              else sliced.push(new Float32Array(sliceEnd - sliceStart));
-            }
-            await output.write(sliced, sr, bd);
-          }
-        }
-        copyOffset = chunkEnd;
-        if (copyOffset >= endFrame) break;
-        if (chunkFrames < CHUNK_FRAMES3) break;
-      }
-      await buffer.clear();
-      await output.reset();
-      for (; ; ) {
-        const chunk = await output.read(CHUNK_FRAMES3);
-        const chunkFrames = chunk.samples[0]?.length ?? 0;
-        if (chunkFrames === 0) break;
-        await buffer.write(chunk.samples, sr, bd);
-        if (chunkFrames < CHUNK_FRAMES3) break;
-      }
-    } finally {
-      await output.close();
-    }
+    this.startFrame = startFrame;
+    this.endFrame = endFrame;
+  }
+  _unbuffer(chunk) {
+    const frames = chunk.samples[0]?.length ?? 0;
+    const chunkStart = chunk.offset;
+    const chunkEnd = chunkStart + frames;
+    const overlapStart = Math.max(chunkStart, this.startFrame);
+    const overlapEnd = Math.min(chunkEnd, this.endFrame);
+    if (overlapEnd <= overlapStart) return void 0;
+    if (overlapStart === chunkStart && overlapEnd === chunkEnd) {
+      return { samples: chunk.samples, offset: chunkStart - this.startFrame, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
+    }
+    const sliceStart = overlapStart - chunkStart;
+    const sliceEnd = overlapEnd - chunkStart;
+    return {
+      samples: chunk.samples.map((channel) => channel.subarray(sliceStart, sliceEnd)),
+      offset: overlapStart - this.startFrame,
+      sampleRate: chunk.sampleRate,
+      bitDepth: chunk.bitDepth
+    };
   }
 };
 var _TrimNode = class _TrimNode extends TransformNode {
@@ -34115,10 +34233,10 @@ var _TrimNode = class _TrimNode extends TransformNode {
     return new _TrimNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_TrimNode.moduleName = "Trim";
+_TrimNode.nodeName = "Trim";
 _TrimNode.packageName = PACKAGE_NAME;
 _TrimNode.packageVersion = PACKAGE_VERSION;
-_TrimNode.moduleDescription = "Remove silence from start and end";
+_TrimNode.nodeDescription = "Remove silence from start and end";
 _TrimNode.schema = schema13;
 var TrimNode = _TrimNode;
 function trim(options) {
@@ -34160,10 +34278,10 @@ var _DownmixMonoNode = class _DownmixMonoNode extends TransformNode {
     return new _DownmixMonoNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_DownmixMonoNode.moduleName = "Downmix Mono";
+_DownmixMonoNode.nodeName = "Downmix Mono";
 _DownmixMonoNode.packageName = PACKAGE_NAME;
 _DownmixMonoNode.packageVersion = PACKAGE_VERSION;
-_DownmixMonoNode.moduleDescription = "Mix all input channels to a single mono channel by averaging";
+_DownmixMonoNode.nodeDescription = "Mix all input channels to a single mono channel by averaging";
 _DownmixMonoNode.schema = schema14;
 var DownmixMonoNode = _DownmixMonoNode;
 function downmixMono(options) {
@@ -34204,10 +34322,10 @@ var _DuplicateChannelsNode = class _DuplicateChannelsNode extends TransformNode
     return new _DuplicateChannelsNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_DuplicateChannelsNode.moduleName = "Duplicate Channels";
+_DuplicateChannelsNode.nodeName = "Duplicate Channels";
 _DuplicateChannelsNode.packageName = PACKAGE_NAME;
 _DuplicateChannelsNode.packageVersion = PACKAGE_VERSION;
-_DuplicateChannelsNode.moduleDescription = "Duplicate a mono signal into multiple identical output channels";
+_DuplicateChannelsNode.nodeDescription = "Duplicate a mono signal into multiple identical output channels; requires exactly 1 input channel, throws otherwise";
 _DuplicateChannelsNode.schema = schema15;
 var DuplicateChannelsNode = _DuplicateChannelsNode;
 function duplicateChannels(options) {
@@ -34248,10 +34366,10 @@ var _GainNode = class _GainNode extends TransformNode {
     return new _GainNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_GainNode.moduleName = "Gain";
+_GainNode.nodeName = "Gain";
 _GainNode.packageName = PACKAGE_NAME;
 _GainNode.packageVersion = PACKAGE_VERSION;
-_GainNode.moduleDescription = "Adjust signal level by a fixed amount in dB";
+_GainNode.nodeDescription = "Adjust signal level by a fixed amount in dB";
 _GainNode.schema = schema16;
 var GainNode = _GainNode;
 function gain(options) {
@@ -34314,10 +34432,10 @@ var _PanNode = class _PanNode extends TransformNode {
     return new _PanNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_PanNode.moduleName = "Pan";
+_PanNode.nodeName = "Pan";
 _PanNode.packageName = PACKAGE_NAME;
 _PanNode.packageVersion = PACKAGE_VERSION;
-_PanNode.moduleDescription = "Position mono signal in stereo field or adjust stereo balance";
+_PanNode.nodeDescription = "Position mono signal in stereo field or adjust stereo balance; throws for inputs with more than 2 channels";
 _PanNode.schema = schema17;
 var PanNode = _PanNode;
 function pan(options) {
@@ -34434,6 +34552,7 @@ var FfmpegStream = class extends BufferedTransformStream {
     };
     controller.enqueue(audioChunk);
     this.outputOffset += frameCount;
+    this.emitProgress("emit", this.outputOffset);
     this.stdoutStash = merged.subarray(completeBytes);
   }
   async handleChunk(chunk, controller) {
@@ -34464,12 +34583,14 @@ var FfmpegStream = class extends BufferedTransformStream {
       });
     }
     this.framesProcessed += frames;
-    this.events.emit("progress", { framesProcessed: this.framesProcessed, sourceTotalFrames: this._sourceTotalFrames });
+    this.emitProgress("buffer", this.framesProcessed, this._sourceTotalFrames);
   }
   async handleFlushStream(controller) {
     const child = this.child;
     if (!child) {
-      this.events.emit("finished");
+      this.emitProgress("buffer", this.framesProcessed, this._sourceTotalFrames, { force: true });
+      this.emitProgress("emit", this.outputOffset, void 0, { force: true });
+      this.events.emit("finished", { framesDone: this.framesProcessed });
       return;
     }
     if (this.pendingDrain) {
@@ -34486,7 +34607,9 @@ var FfmpegStream = class extends BufferedTransformStream {
     if (this.stdoutStash.length >= this.inputChannels * 4) {
       this.handleStdoutBytes(Buffer.alloc(0), controller);
     }
-    this.events.emit("finished");
+    this.emitProgress("buffer", this.framesProcessed, this._sourceTotalFrames, { force: true });
+    this.emitProgress("emit", this.outputOffset, void 0, { force: true });
+    this.events.emit("finished", { framesDone: this.framesProcessed });
   }
   async _teardown() {
     const child = this.child;
@@ -34516,10 +34639,10 @@ var _FfmpegNode = class _FfmpegNode extends TransformNode {
     return new _FfmpegNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_FfmpegNode.moduleName = "FFmpeg";
+_FfmpegNode.nodeName = "FFmpeg";
 _FfmpegNode.packageName = PACKAGE_NAME;
 _FfmpegNode.packageVersion = PACKAGE_VERSION;
-_FfmpegNode.moduleDescription = "Process audio through FFmpeg filters";
+_FfmpegNode.nodeDescription = "Process audio through FFmpeg filters";
 _FfmpegNode.schema = schema18;
 var FfmpegNode = _FfmpegNode;
 function ffmpeg(options) {
@@ -34581,22 +34704,6 @@ function applyBaseRateChunk(args) {
   return output;
 }
 
-// src/transforms/loudness-target/utils/curve.ts
-function gainDbAt(absXDb, anchors) {
-  const { floorDb, pivotDb, limitDb, B: boost, peakGainDb } = anchors;
-  if (floorDb !== null && absXDb <= floorDb) return 0;
-  if (absXDb < pivotDb) {
-    if (floorDb === null) return boost;
-    const position = (absXDb - floorDb) / (pivotDb - floorDb);
-    return position * boost;
-  }
-  if (absXDb < limitDb) {
-    const position = (absXDb - pivotDb) / (limitDb - pivotDb);
-    return boost + position * (peakGainDb - boost);
-  }
-  return limitDb + peakGainDb - absXDb;
-}
-
 // src/transforms/loudness-target/utils/envelope.ts
 function windowSamplesFromMs(smoothingMs, sampleRate) {
   return Math.max(1, Math.round(smoothingMs * sampleRate / 1e3));
@@ -34615,61 +34722,75 @@ async function applyBackwardPassOverChunkBuffer(args) {
   }
   const sr = sourceBuffer.sampleRate;
   const bd = sourceBuffer.bitDepth;
-  const reversedSource = await reverseBuffer(sourceBuffer);
   const filteredReversed = new ChunkBuffer();
-  const iirForwardOrder = minHeldBuffer === void 0 ? void 0 : new ChunkBuffer();
   try {
-    await reversedSource.reset();
-    const seedChunk = await reversedSource.read(1);
-    const backwardState = { value: seedChunk.samples[0]?.[0] ?? 0 };
-    await reversedSource.reset();
-    for (; ; ) {
-      const chunk = await reversedSource.read(chunkSize);
-      const data = chunk.samples[0];
-      const chunkLength = data?.length ?? 0;
-      if (data === void 0 || chunkLength === 0) break;
-      const filtered = iir.applyForwardPass(data, backwardState);
-      await filteredReversed.write([filtered], sr, bd);
-      if (chunkLength < chunkSize) break;
-    }
-    await filteredReversed.flushWrites();
-    if (iirForwardOrder === void 0) {
-      await reverseBuffer(filteredReversed, destBuffer);
-    } else {
-      await reverseBuffer(filteredReversed, iirForwardOrder);
-      await iirForwardOrder.flushWrites();
-      await iirForwardOrder.reset();
-      await minHeldBuffer.reset();
+    const backwardState = { value: 0 };
+    let seeded = false;
+    const sourceReader = await sourceBuffer.openReverseReader();
+    try {
       for (; ; ) {
-        const iirChunk = await iirForwardOrder.read(chunkSize);
-        const iirData = iirChunk.samples[0];
-        const chunkLength = iirData?.length ?? 0;
-        if (iirData === void 0 || chunkLength === 0) break;
-        const minChunk = await minHeldBuffer.read(chunkLength);
-        const minData = minChunk.samples[0];
-        if (minData?.length !== chunkLength) {
-          throw new Error(
-            `applyBackwardPassOverChunkBuffer: minHeldBuffer returned ${minData?.length ?? 0} samples; expected ${chunkLength}`
-          );
+        const chunk = await sourceReader.read(chunkSize);
+        const reversed = chunk.samples[0];
+        if (reversed === void 0 || reversed.length === 0) break;
+        if (!seeded) {
+          backwardState.value = reversed[0] ?? 0;
+          seeded = true;
         }
-        const clamped = new Float32Array(chunkLength);
-        for (let sampleIdx = 0; sampleIdx < chunkLength; sampleIdx++) {
-          const iirValue = iirData[sampleIdx] ?? 0;
-          const minValue = minData[sampleIdx] ?? 0;
-          clamped[sampleIdx] = iirValue < minValue ? iirValue : minValue;
+        const filtered = iir.applyForwardPass(reversed, backwardState);
+        await filteredReversed.write([filtered], sr, bd);
+      }
+    } finally {
+      await sourceReader.close();
+    }
+    if (minHeldBuffer !== void 0) await minHeldBuffer.reset();
+    const filteredReader = await filteredReversed.openReverseReader();
+    try {
+      for (; ; ) {
+        const chunk = await filteredReader.read(chunkSize);
+        const forwardOrder = chunk.samples[0];
+        if (forwardOrder === void 0 || forwardOrder.length === 0) break;
+        const stripeFrames = forwardOrder.length;
+        if (minHeldBuffer !== void 0) {
+          const minChunk = await minHeldBuffer.read(stripeFrames);
+          const minData = minChunk.samples[0];
+          if (minData?.length !== stripeFrames) {
+            throw new Error(
+              `applyBackwardPassOverChunkBuffer: minHeldBuffer returned ${minData?.length ?? 0} samples; expected ${stripeFrames}`
+            );
+          }
+          for (let sampleIdx = 0; sampleIdx < stripeFrames; sampleIdx++) {
+            const iirValue = forwardOrder[sampleIdx] ?? 0;
+            const minValue = minData[sampleIdx] ?? 0;
+            forwardOrder[sampleIdx] = iirValue < minValue ? iirValue : minValue;
+          }
         }
-        await destBuffer.write([clamped], sr, bd);
-        if (chunkLength < chunkSize) break;
+        await destBuffer.write([forwardOrder], sr, bd);
       }
-      await destBuffer.flushWrites();
+    } finally {
+      await filteredReader.close();
     }
+    await destBuffer.flushWrites();
   } finally {
-    await reversedSource.close();
     await filteredReversed.close();
-    if (iirForwardOrder !== void 0) await iirForwardOrder.close();
   }
 }
 
+// src/transforms/loudness-target/utils/curve.ts
+function gainDbAt(absXDb, anchors) {
+  const { floorDb, pivotDb, limitDb, B: boost, peakGainDb } = anchors;
+  if (floorDb !== null && absXDb <= floorDb) return 0;
+  if (absXDb < pivotDb) {
+    if (floorDb === null) return boost;
+    const position = (absXDb - floorDb) / (pivotDb - floorDb);
+    return position * boost;
+  }
+  if (absXDb < limitDb) {
+    const position = (absXDb - pivotDb) / (limitDb - pivotDb);
+    return boost + position * (peakGainDb - boost);
+  }
+  return limitDb + peakGainDb - absXDb;
+}
+
 // src/transforms/loudness-target/utils/source-caches.ts
 async function buildBaseRateDetectionCache(args) {
   const { buffer, sampleRate, channelCount, frames, halfWidth } = args;
@@ -34683,12 +34804,14 @@ async function buildBaseRateDetectionCache(args) {
     upsamplers.push(new TruePeakUpsampler(OVERSAMPLE_FACTOR));
   }
   const slidingWindow = new SlidingWindowMaxStream(halfWidth);
-  const detectScratch4x = new Float32Array(CHUNK_FRAMES4 * OVERSAMPLE_FACTOR);
-  const detectScratchBase = new Float32Array(CHUNK_FRAMES4);
+  const detectScratch4x = new Float32Array(CHUNK_FRAMES3 * OVERSAMPLE_FACTOR);
+  const detectScratchBase = new Float32Array(CHUNK_FRAMES3);
+  let dbScratch = null;
+  const upsampleScratches = [];
   let consumedBaseFrames = 0;
   await buffer.reset();
   for (; ; ) {
-    const chunk = await buffer.read(CHUNK_FRAMES4);
+    const chunk = await buffer.read(CHUNK_FRAMES3);
     const channels = chunk.samples;
     const chunkFrames = channels[0]?.length ?? 0;
     if (chunkFrames === 0) break;
@@ -34702,7 +34825,12 @@ async function buildBaseRateDetectionCache(args) {
         continue;
       }
       const slice = channel.length === chunkFrames ? channel : channel.subarray(0, chunkFrames);
-      upChannels.push(upsampler.upsample(slice));
+      let scratch = upsampleScratches[channelIdx];
+      if (scratch === void 0 || scratch.length < chunkFrames * OVERSAMPLE_FACTOR) {
+        scratch = new Float32Array(chunkFrames * OVERSAMPLE_FACTOR);
+        upsampleScratches[channelIdx] = scratch;
+      }
+      upChannels.push(upsampler.upsample(slice, scratch));
     }
     const detect4xChunk = detectScratch4x.subarray(0, upChunkLength);
     for (let upIdx = 0; upIdx < upChunkLength; upIdx++) {
@@ -34729,9 +34857,16 @@ async function buildBaseRateDetectionCache(args) {
     const isFinal = consumedBaseFrames >= frames;
     const pooled = slidingWindow.push(detectBaseChunk, isFinal);
     if (pooled.length > 0) {
-      await detectionEnvelope.write([pooled], sampleRate, sourceBitDepth);
+      if (dbScratch === null || dbScratch.length < pooled.length) {
+        dbScratch = new Float32Array(pooled.length);
+      }
+      const dbChunk = dbScratch.subarray(0, pooled.length);
+      for (let sampleIdx = 0; sampleIdx < pooled.length; sampleIdx++) {
+        dbChunk[sampleIdx] = linearToDb(pooled[sampleIdx] ?? 0);
+      }
+      await detectionEnvelope.write([dbChunk], sampleRate, sourceBitDepth);
     }
-    if (chunkFrames < CHUNK_FRAMES4) break;
+    if (chunkFrames < CHUNK_FRAMES3) break;
   }
   await detectionEnvelope.flushWrites();
   return detectionEnvelope;
@@ -34739,7 +34874,7 @@ async function buildBaseRateDetectionCache(args) {
 
 // src/transforms/loudness-target/utils/iterate.ts
 var OVERSAMPLE_FACTOR = 4;
-var CHUNK_FRAMES4 = 44100;
+var CHUNK_FRAMES3 = 44100;
 var BOOST_LOWER_BOUND = -30;
 var BOOST_UPPER_BOUND = 30;
 var LIMIT_EPSILON_DB = 0.01;
@@ -34748,6 +34883,30 @@ var PEAK_GAIN_DB_FLOOR = -60;
 var MIN_SECANT_SLOPE = 0.05;
 var DEFAULT_MAX_ATTEMPTS = 10;
 var DEFAULT_TOLERANCE = 0.5;
+var GAIN_LUT_MIN_DB = -80;
+var GAIN_LUT_MAX_DB = 40;
+var GAIN_LUT_STEP_DB = 0.01;
+var GAIN_LUT_INV_STEP = 1 / GAIN_LUT_STEP_DB;
+var GAIN_LUT_SIZE = Math.round((GAIN_LUT_MAX_DB - GAIN_LUT_MIN_DB) / GAIN_LUT_STEP_DB) + 1;
+var GAIN_LUT_STORED_SILENCE_DB = -200;
+function buildGainLut() {
+  const lut = new Float64Array(GAIN_LUT_SIZE);
+  for (let entryIdx = 0; entryIdx < GAIN_LUT_SIZE; entryIdx++) {
+    lut[entryIdx] = Math.pow(10, (GAIN_LUT_MIN_DB + entryIdx * GAIN_LUT_STEP_DB) / 20);
+  }
+  return lut;
+}
+function gainLutLerp(lut, gainDb) {
+  if (gainDb < GAIN_LUT_MIN_DB || gainDb >= GAIN_LUT_MAX_DB) {
+    return Math.pow(10, gainDb / 20);
+  }
+  const pos = (gainDb - GAIN_LUT_MIN_DB) * GAIN_LUT_INV_STEP;
+  const lutIdx = pos | 0;
+  const frac = pos - lutIdx;
+  const lo = lut[lutIdx] ?? 0;
+  const hi = lut[lutIdx + 1] ?? 0;
+  return lo + (hi - lo) * frac;
+}
 async function iterateForTargets(args) {
   const {
     buffer,
@@ -34768,13 +34927,18 @@ async function iterateForTargets(args) {
   const channelCount = buffer.channels;
   const frames = buffer.frames;
   if (channelCount === 0 || frames === 0) {
+    if (args.detectionEnvelope !== void 0) await args.detectionEnvelope.close();
     return {
       bestSmoothedEnvelopeBuffer: new ChunkBuffer(),
       bestB: 0,
       bestLimitDb: sourcePeakDb,
       bestPeakGainDb: 0,
       attempts: [],
-      converged: false
+      converged: false,
+      detectionCacheBuildMs: 0,
+      winnerOutputLufs: null,
+      winnerOutputTruePeakDb: null,
+      winnerOutputLra: null
     };
   }
   const effectiveTargetTp = targetTp ?? sourcePeakDb;
@@ -34789,13 +34953,15 @@ async function iterateForTargets(args) {
   let currentPeakGainDb = effectiveTargetTp - currentLimit;
   const halfWidth = windowSamplesFromMs(smoothingMs, sampleRate);
   const iir = new BidirectionalIir({ smoothingMs, sampleRate });
-  const detectionEnvelope = await buildBaseRateDetectionCache({
+  const tCacheBuild0 = Date.now();
+  const detectionEnvelope = args.detectionEnvelope ?? await buildBaseRateDetectionCache({
     buffer,
     sampleRate,
     channelCount,
     frames,
     halfWidth
   });
+  const detectionCacheBuildMs = args.detectionEnvelope !== void 0 ? 0 : Date.now() - tCacheBuild0;
   const forwardEnvelopeBuffer = new ChunkBuffer();
   const minHeldEnvelopeBuffer = new ChunkBuffer();
   const activeBufferA = new ChunkBuffer();
@@ -34812,8 +34978,14 @@ async function iterateForTargets(args) {
     let bestBoost = currentBoost;
     let bestPeakGainDb = currentPeakGainDb;
     let bestScore = Infinity;
+    let winnerOutputLufs = null;
+    let winnerOutputTruePeakDb = null;
+    let winnerOutputLra = null;
+    let winnerLufsErr = Infinity;
+    let winnerPeakErr = Infinity;
     let previousStepMagnitude = Infinity;
     for (let attemptIdx = 0; attemptIdx < maxAttempts; attemptIdx++) {
+      const tAttempt0 = Date.now();
       const anchors = {
         floorDb: anchorBase.floorDb,
         pivotDb: anchorBase.pivotDb,
@@ -34833,31 +35005,35 @@ async function iterateForTargets(args) {
         sourceBuffer: forwardEnvelopeBuffer,
         destBuffer: activeRef,
         iir,
-        chunkSize: CHUNK_FRAMES4,
+        chunkSize: CHUNK_FRAMES3,
         minHeldBuffer: minHeldEnvelopeBuffer
       });
-      const measured = await measureAttemptOutput({
-        source: buffer,
-        sampleRate,
-        channelCount,
-        gSmoothed: activeRef
-      });
+      const measured = await measureAttemptOutput({ source: buffer, sampleRate, channelCount, gSmoothed: activeRef });
       const lufsErr = measured.outputLufs - targetLufs;
       const peakErr = measured.outputTruePeakDb - effectiveTargetTp;
       attempts.push({
         boost: currentBoost,
         limitDb: currentLimit,
         lufsErr,
+        outputLufs: measured.outputLufs,
+        outputTruePeakDb: measured.outputTruePeakDb,
         outputLra: measured.outputLra,
         peakGainDb: currentPeakGainDb,
-        peakErr
+        peakErr,
+        elapsedMs: Date.now() - tAttempt0
       });
-      const peakScoreTerm = skipPeak ? 0 : peakErr * peakErr;
-      const score = Math.sqrt(lufsErr * lufsErr + peakScoreTerm);
+      const lufsScoreTerm = Math.abs(lufsErr) / tolerance;
+      const peakScoreTerm = skipPeak ? 0 : Math.abs(peakErr) / peakTolerance;
+      const score = Math.max(lufsScoreTerm, peakScoreTerm);
       if (score < bestScore) {
         bestScore = score;
         bestBoost = currentBoost;
         bestPeakGainDb = currentPeakGainDb;
+        winnerOutputLufs = measured.outputLufs;
+        winnerOutputTruePeakDb = measured.outputTruePeakDb;
+        winnerOutputLra = measured.outputLra;
+        winnerLufsErr = lufsErr;
+        winnerPeakErr = peakErr;
         const previousActive = activeRef;
         activeRef = winningRef;
         winningRef = previousActive;
@@ -34869,28 +35045,9 @@ async function iterateForTargets(args) {
       await forwardEnvelopeBuffer.clear();
       await minHeldEnvelopeBuffer.clear();
       const matchesToTwoDp = Math.round(Math.abs(lufsErr) * 100) === 0 && (skipPeak || Math.round(Math.abs(peakErr) * 100) === 0);
-      if (matchesToTwoDp) {
-        return {
-          bestSmoothedEnvelopeBuffer: winningRef,
-          bestB: bestBoost,
-          bestLimitDb: currentLimit,
-          bestPeakGainDb,
-          attempts,
-          converged: true
-        };
-      }
       const lufsConverged = Math.abs(lufsErr) < tolerance;
       const peakConverged = skipPeak || Math.abs(peakErr) < peakTolerance;
-      if (lufsConverged && peakConverged) {
-        return {
-          bestSmoothedEnvelopeBuffer: winningRef,
-          bestB: bestBoost,
-          bestLimitDb: currentLimit,
-          bestPeakGainDb,
-          attempts,
-          converged: true
-        };
-      }
+      if (matchesToTwoDp || lufsConverged && peakConverged) break;
       if (attemptIdx === maxAttempts - 1) break;
       const next = computeBoostStep(attempts, previousStepMagnitude);
       currentBoost = clampBoost(next.boost);
@@ -34902,13 +35059,18 @@ async function iterateForTargets(args) {
         );
       }
     }
+    const converged = winningPopulated && (Math.round(Math.abs(winnerLufsErr) * 100) === 0 && (skipPeak || Math.round(Math.abs(winnerPeakErr) * 100) === 0) || Math.abs(winnerLufsErr) < tolerance && (skipPeak || Math.abs(winnerPeakErr) < peakTolerance));
     return {
       bestSmoothedEnvelopeBuffer: winningRef,
       bestB: bestBoost,
       bestLimitDb: currentLimit,
       bestPeakGainDb,
       attempts,
-      converged: false
+      converged,
+      detectionCacheBuildMs,
+      winnerOutputLufs,
+      winnerOutputTruePeakDb,
+      winnerOutputLra
     };
   } finally {
     await detectionEnvelope.close();
@@ -34932,20 +35094,21 @@ async function streamCurveAndForwardIir(args) {
   const forwardState = { value: 0 };
   let forwardSeeded = false;
   const minStream = new SlidingWindowMinStream(halfWidth);
-  const gWindowScratch = new Float32Array(CHUNK_FRAMES4);
+  const gWindowScratch = new Float32Array(CHUNK_FRAMES3);
+  const gainLut = buildGainLut();
   const detectionSampleRate = detectionEnvelope.sampleRate;
   const detectionBitDepth = detectionEnvelope.bitDepth;
   let consumedFrames = 0;
   for (; ; ) {
-    const chunk = await detectionEnvelope.read(CHUNK_FRAMES4);
+    const chunk = await detectionEnvelope.read(CHUNK_FRAMES3);
     const windowChunk = chunk.samples[0];
     const chunkLength = windowChunk?.length ?? 0;
     if (windowChunk === void 0 || chunkLength === 0) break;
     const gWindowChunk = gWindowScratch.subarray(0, chunkLength);
     for (let outputIdx = 0; outputIdx < chunkLength; outputIdx++) {
-      const levelDb = linearToDb(windowChunk[outputIdx] ?? 0);
+      const levelDb = windowChunk[outputIdx] ?? GAIN_LUT_STORED_SILENCE_DB;
       const gainDb = gainDbAt(levelDb, anchors);
-      gWindowChunk[outputIdx] = Math.pow(10, gainDb / 20);
+      gWindowChunk[outputIdx] = gainLutLerp(gainLut, gainDb);
     }
     consumedFrames += chunkLength;
     const isFinal = consumedFrames >= totalFrames;
@@ -34959,7 +35122,7 @@ async function streamCurveAndForwardIir(args) {
       await forwardEnvelopeBuffer.write([forwardChunk], detectionSampleRate, detectionBitDepth);
       await minHeldEnvelopeBuffer.write([minHeldChunk], detectionSampleRate, detectionBitDepth);
     }
-    if (chunkLength < CHUNK_FRAMES4) break;
+    if (chunkLength < CHUNK_FRAMES3) break;
   }
   await forwardEnvelopeBuffer.flushWrites();
   await minHeldEnvelopeBuffer.flushWrites();
@@ -34970,12 +35133,12 @@ async function measureAttemptOutput(args) {
   const truePeakAccumulator = new TruePeakAccumulator(sampleRate, channelCount);
   const applyOutputScratch = [];
   for (let channelIdx = 0; channelIdx < channelCount; channelIdx++) {
-    applyOutputScratch.push(new Float32Array(CHUNK_FRAMES4));
+    applyOutputScratch.push(new Float32Array(CHUNK_FRAMES3));
   }
   await source.reset();
   await gSmoothed.reset();
   for (; ; ) {
-    const sourceChunk = await source.read(CHUNK_FRAMES4);
+    const sourceChunk = await source.read(CHUNK_FRAMES3);
     const chunkFrames = sourceChunk.samples[0]?.length ?? 0;
     if (chunkFrames === 0) break;
     const envelopeChunk = await gSmoothed.read(chunkFrames);
@@ -34995,7 +35158,7 @@ async function measureAttemptOutput(args) {
     });
     accumulator.push(transformed, chunkFrames);
     truePeakAccumulator.push(transformed, chunkFrames);
-    if (chunkFrames < CHUNK_FRAMES4) break;
+    if (chunkFrames < CHUNK_FRAMES3) break;
   }
   const result = accumulator.finalize();
   const truePeakLinear = truePeakAccumulator.finalize();
@@ -35042,60 +35205,70 @@ function clampLimit(limitDb, pivotDb, sourcePeakDb) {
 }
 
 // src/transforms/loudness-target/utils/measurement.ts
-var CHUNK_FRAMES5 = 44100;
+var CHUNK_FRAMES4 = 44100;
 var HISTOGRAM_BUCKETS = 1024;
 var PIVOT_FALLBACK_DB = -40;
-async function measureSource(buffer, sampleRate, limitPercentile, halfWidth) {
-  const frames = buffer.frames;
-  const channelCount = buffer.channels;
-  if (frames === 0 || channelCount === 0) {
-    return {
-      integratedLufs: -Infinity,
-      lra: 0,
-      truePeakDb: -Infinity,
-      pivotAutoDb: Number.POSITIVE_INFINITY,
-      floorAutoDb: Number.POSITIVE_INFINITY,
-      limitAutoDb: Number.POSITIVE_INFINITY,
-      shortTermLufs: [],
-      detectionHistogram: { buckets: new Uint32Array(0), bucketMax: 0, totalSamples: 0 }
-    };
-  }
-  const loudness = new LoudnessAccumulator(sampleRate, channelCount);
-  const truePeak = new TruePeakAccumulator(sampleRate, channelCount);
-  const detectionHistogram = new AmplitudeHistogramAccumulator(HISTOGRAM_BUCKETS);
-  const upsamplers = [];
-  for (let channelIdx = 0; channelIdx < channelCount; channelIdx++) {
-    upsamplers.push(new TruePeakUpsampler(OVERSAMPLE_FACTOR));
-  }
-  const slidingWindow = new SlidingWindowMaxStream(halfWidth);
-  let levelsScratch = null;
-  let baseScratch = null;
-  await buffer.reset();
-  for (; ; ) {
-    const chunk = await buffer.read(CHUNK_FRAMES5);
-    const chunkFrames = chunk.samples[0]?.length ?? 0;
-    if (chunkFrames === 0) break;
-    loudness.push(chunk.samples, chunkFrames);
-    truePeak.push(chunk.samples, chunkFrames);
+function emptyMeasurement() {
+  return {
+    integratedLufs: -Infinity,
+    lra: 0,
+    truePeakDb: -Infinity,
+    pivotAutoDb: Number.POSITIVE_INFINITY,
+    floorAutoDb: Number.POSITIVE_INFINITY,
+    limitAutoDb: Number.POSITIVE_INFINITY,
+    shortTermLufs: [],
+    detectionHistogram: { buckets: new Uint32Array(0), bucketMax: 0, totalSamples: 0 }
+  };
+}
+var SourceMeasurementAccumulator = class {
+  constructor(sampleRate, channelCount, limitPercentile, halfWidth, detectionEnvelope = null, persistBitDepth) {
+    this.levelsScratch = null;
+    this.baseScratch = null;
+    this.dbScratch = null;
+    // see toDbScratch
+    this.upsampleScratches = [];
+    this.pushedFrames = 0;
+    this.limitPercentile = limitPercentile;
+    this.sampleRate = sampleRate;
+    this.loudness = new LoudnessAccumulator(sampleRate, channelCount);
+    this.truePeak = new TruePeakAccumulator(sampleRate, channelCount);
+    this.detectionHistogram = new AmplitudeHistogramAccumulator(HISTOGRAM_BUCKETS);
+    this.upsamplers = [];
+    for (let channelIdx = 0; channelIdx < channelCount; channelIdx++) {
+      this.upsamplers.push(new TruePeakUpsampler(OVERSAMPLE_FACTOR));
+    }
+    this.slidingWindow = new SlidingWindowMaxStream(halfWidth);
+    this.detectionEnvelope = detectionEnvelope;
+    this.persistBitDepth = persistBitDepth;
+  }
+  async push(channels, frames) {
+    if (frames === 0) return;
+    this.loudness.push(channels, frames);
+    this.truePeak.push(channels, frames);
     const upChannels = [];
-    for (let channelIdx = 0; channelIdx < chunk.samples.length; channelIdx++) {
-      const channel = chunk.samples[channelIdx];
-      const upsampler = upsamplers[channelIdx];
+    for (let channelIdx = 0; channelIdx < channels.length; channelIdx++) {
+      const channel = channels[channelIdx];
+      const upsampler = this.upsamplers[channelIdx];
       if (channel === void 0 || upsampler === void 0) {
-        upChannels.push(new Float32Array(chunkFrames * OVERSAMPLE_FACTOR));
+        upChannels.push(new Float32Array(frames * OVERSAMPLE_FACTOR));
         continue;
       }
-      const slice = channel.length === chunkFrames ? channel : channel.subarray(0, chunkFrames);
-      upChannels.push(upsampler.upsample(slice));
+      const slice = channel.length === frames ? channel : channel.subarray(0, frames);
+      let scratch = this.upsampleScratches[channelIdx];
+      if (scratch === void 0 || scratch.length < frames * OVERSAMPLE_FACTOR) {
+        scratch = new Float32Array(frames * OVERSAMPLE_FACTOR);
+        this.upsampleScratches[channelIdx] = scratch;
+      }
+      upChannels.push(upsampler.upsample(slice, scratch));
     }
-    const upChunkLength = chunkFrames * OVERSAMPLE_FACTOR;
-    if (levelsScratch === null || levelsScratch.length < upChunkLength) {
-      levelsScratch = new Float32Array(upChunkLength);
+    const upChunkLength = frames * OVERSAMPLE_FACTOR;
+    if (this.levelsScratch === null || this.levelsScratch.length < upChunkLength) {
+      this.levelsScratch = new Float32Array(upChunkLength);
     }
-    if (baseScratch === null || baseScratch.length < chunkFrames) {
-      baseScratch = new Float32Array(chunkFrames);
+    if (this.baseScratch === null || this.baseScratch.length < frames) {
+      this.baseScratch = new Float32Array(frames);
     }
-    const levels = levelsScratch;
+    const levels = this.levelsScratch;
     for (let upIdx = 0; upIdx < upChunkLength; upIdx++) {
       let max = 0;
       for (let channelIdx = 0; channelIdx < upChannels.length; channelIdx++) {
@@ -35105,8 +35278,8 @@ async function measureSource(buffer, sampleRate, limitPercentile, halfWidth) {
       }
       levels[upIdx] = max;
     }
-    const baseChunk = baseScratch.subarray(0, chunkFrames);
-    for (let baseIdx = 0; baseIdx < chunkFrames; baseIdx++) {
+    const baseChunk = this.baseScratch.subarray(0, frames);
+    for (let baseIdx = 0; baseIdx < frames; baseIdx++) {
       const upOffset = baseIdx * OVERSAMPLE_FACTOR;
       const s0 = levels[upOffset] ?? 0;
       const s1 = levels[upOffset + 1] ?? 0;
@@ -35116,43 +35289,79 @@ async function measureSource(buffer, sampleRate, limitPercentile, halfWidth) {
       const m23 = s2 > s3 ? s2 : s3;
       baseChunk[baseIdx] = m01 > m23 ? m01 : m23;
     }
-    const isLastChunk = chunkFrames < CHUNK_FRAMES5;
-    const pooled = slidingWindow.push(baseChunk, isLastChunk);
+    this.pushedFrames += frames;
+    const pooled = this.slidingWindow.push(baseChunk, false);
     if (pooled.length > 0) {
-      detectionHistogram.push([pooled], pooled.length);
+      this.detectionHistogram.push([pooled], pooled.length);
+      if (this.detectionEnvelope !== null) {
+        await this.detectionEnvelope.write([this.toDbScratch(pooled)], this.sampleRate, this.persistBitDepth);
+      }
     }
-    if (isLastChunk) break;
   }
-  const loudnessResult = loudness.finalize();
-  const truePeakLin = truePeak.finalize();
-  const histogramResult = detectionHistogram.finalize();
-  const stats = getLraConsideredStats(loudnessResult.shortTerm);
-  const limitAutoDb = computeLimitAutoDb(histogramResult.buckets, histogramResult.bucketMax, stats.median, limitPercentile);
-  let totalSamples = 0;
-  for (let bucketIdx = 0; bucketIdx < histogramResult.buckets.length; bucketIdx++) {
-    totalSamples += histogramResult.buckets[bucketIdx] ?? 0;
+  // LINEAR pooled slider output -> dB, into a reused scratch. The histogram keeps the linear axis; only the
+  // detection-envelope buffer stores dB (never converts `pooled`/`trailing` in place — an axis mixup silently
+  // corrupts limitAutoDb / the predictor).
+  toDbScratch(linear) {
+    if (this.dbScratch === null || this.dbScratch.length < linear.length) {
+      this.dbScratch = new Float32Array(linear.length);
+    }
+    const out = this.dbScratch.subarray(0, linear.length);
+    for (let sampleIdx = 0; sampleIdx < linear.length; sampleIdx++) {
+      out[sampleIdx] = linearToDb(linear[sampleIdx] ?? 0);
+    }
+    return out;
   }
-  return {
-    integratedLufs: loudnessResult.integrated,
-    lra: loudnessResult.range,
-    truePeakDb: linearToDb(truePeakLin),
-    pivotAutoDb: stats.median,
-    floorAutoDb: stats.min,
-    limitAutoDb,
-    shortTermLufs: loudnessResult.shortTerm,
-    // Pooled base-rate detection histogram — same axis the apply
-    // path's `buildBaseRateDetectionCache` produces, feeding the
-    // curve's per-sample `gainDbAt`. `limitAutoDb`'s percentile
-    // walk and `predictOutputLufs` both consume this histogram
-    // (per the 2026-05-13 histogram-axis fix; the prior raw-4× axis
-    // under-estimated typical curve-input levels and produced an
-    // over-aggressive `limitAutoDb`).
-    detectionHistogram: {
-      buckets: histogramResult.buckets,
-      bucketMax: histogramResult.bucketMax,
-      totalSamples
+  async finalize() {
+    if (this.pushedFrames === 0) return emptyMeasurement();
+    const trailing = this.slidingWindow.push(new Float32Array(0), true);
+    if (trailing.length > 0) {
+      this.detectionHistogram.push([trailing], trailing.length);
+      if (this.detectionEnvelope !== null) {
+        await this.detectionEnvelope.write([this.toDbScratch(trailing)], this.sampleRate, this.persistBitDepth);
+      }
     }
-  };
+    if (this.detectionEnvelope !== null) {
+      await this.detectionEnvelope.flushWrites();
+    }
+    const loudnessResult = this.loudness.finalize();
+    const truePeakLin = this.truePeak.finalize();
+    const histogramResult = this.detectionHistogram.finalize();
+    const stats = getLraConsideredStats(loudnessResult.shortTerm);
+    const limitAutoDb = computeLimitAutoDb(histogramResult.buckets, histogramResult.bucketMax, stats.median, this.limitPercentile);
+    let totalSamples = 0;
+    for (let bucketIdx = 0; bucketIdx < histogramResult.buckets.length; bucketIdx++) {
+      totalSamples += histogramResult.buckets[bucketIdx] ?? 0;
+    }
+    return {
+      integratedLufs: loudnessResult.integrated,
+      lra: loudnessResult.range,
+      truePeakDb: linearToDb(truePeakLin),
+      pivotAutoDb: stats.median,
+      floorAutoDb: stats.min,
+      limitAutoDb,
+      shortTermLufs: loudnessResult.shortTerm,
+      detectionHistogram: {
+        buckets: histogramResult.buckets,
+        bucketMax: histogramResult.bucketMax,
+        totalSamples
+      }
+    };
+  }
+};
+async function measureSource(buffer, sampleRate, limitPercentile, halfWidth) {
+  const frames = buffer.frames;
+  const channelCount = buffer.channels;
+  if (frames === 0 || channelCount === 0) return emptyMeasurement();
+  const accumulator = new SourceMeasurementAccumulator(sampleRate, channelCount, limitPercentile, halfWidth);
+  await buffer.reset();
+  for (; ; ) {
+    const chunk = await buffer.read(CHUNK_FRAMES4);
+    const chunkFrames = chunk.samples[0]?.length ?? 0;
+    if (chunkFrames === 0) break;
+    await accumulator.push(chunk.samples, chunkFrames);
+    if (chunkFrames < CHUNK_FRAMES4) break;
+  }
+  return await accumulator.finalize();
 }
 function computeLimitAutoDb(buckets, bucketMax, pivotAutoDb, limitPercentile) {
   if (bucketMax === 0) return Number.POSITIVE_INFINITY;
@@ -35287,84 +35496,63 @@ var schema19 = external_exports.object({
 var LoudnessTargetStream = class extends BufferedTransformStream {
   constructor() {
     super(...arguments);
-    /**
-     * BASE-rate peak-respecting smoothed gain envelope produced by the
-     * winning iteration attempt, held as a disk-backed single-channel
-     * `ChunkBuffer` of size `frames` (post the 2026-05-13 base-rate-
-     * downstream rewrite; no `× OVERSAMPLE_FACTOR` factor). The
-     * envelope is read chunk-by-chunk in `_unbuffer` rather than held
-     * as a flat `Float32Array` — keeps RAM at ~10 MB regardless of
-     * source length. `null` when the stream passes through (silent /
-     * sub-block-length source).
-     */
     this.winningSmoothedEnvelopeBuffer = null;
-    /**
-     * Body gain `B` from the winning iteration attempt. `null` when the
-     * stream passes through (no curve was learned). Diagnostic only —
-     * the apply pass uses the materialised envelope, not `B` directly.
-     */
     this.winningB = null;
-    /**
-     * Limit anchor `limitDb` used for this source — constant across
-     * iteration attempts. Sourced from `limitDbOverride` when explicit,
-     * else from the percentile-derived `limitAutoDb` on the source's
-     * detection-envelope histogram, else `sourcePeakDb` (no limiting).
-     * `null` when the stream passes through. Diagnostic only.
-     */
     this.winningLimitDb = null;
-    /**
-     * `peakGainDb` from the winning attempt — the upper-segment right-
-     * endpoint anchor gain. Starts at the closed-form
-     * `effectiveTargetTp − limitDb` and adjusts via proportional
-     * feedback on observed signed TP error. `null` when the stream
-     * passes through.
-     */
     this.winningPeakGainDb = null;
-    /**
-     * Set to `true` by the first `_unbuffer` call so the
-     * `winningSmoothedEnvelopeBuffer`'s read cursor is rewound exactly
-     * once. The envelope is read-only in `_unbuffer` and consumed
-     * forward in chunk-cadence lockstep with upstream chunks; this
-     * lazy-reset pattern keeps the cursor management out of `_setup`.
-     * Post the 2026-05-13 base-rate-downstream rewrite the
-     * upsampled-source cache no longer exists — `_unbuffer` reads
-     * source samples directly from the framework-provided chunk.
-     */
     this.unbufferCursorsReady = false;
-    /**
-     * Per-chunk wall-clock time spent in `_unbuffer`. Post the
-     * 2026-05-13 base-rate-downstream rewrite, `_unbuffer` is a pure
-     * base-rate multiply per chunk (no upsample, no downsample, no
-     * AA filter — the smoothed envelope is bandlimited far below
-     * base-rate Nyquist, so the multiply introduces no high-frequency
-     * content). Accumulated across all `_unbuffer` calls.
-     */
+    this.capturedDetectionEnvelope = null;
     this.unbufferElapsedMs = 0;
-    /**
-     * Wall-clock breakdown of the learn pass. `iteration` is the wall
-     * time spent inside `iterateForTargets`. `detection` stays at 0 for
-     * QA-driver log parity — detection-envelope build cost is folded
-     * into `iteration`.
-     */
     this.learnTimingMs = {
       sourceMeasurement: 0,
       detection: 0,
       iteration: 0
     };
   }
+  async _buffer(chunk, buffer) {
+    await super._buffer(chunk, buffer);
+    const frames = chunk.samples[0]?.length ?? 0;
+    const channelCount = chunk.samples.length;
+    if (frames === 0 || channelCount === 0) return;
+    const tPush0 = Date.now();
+    if (this.measurementAccumulator === void 0) {
+      this.capturedDetectionEnvelope = new ChunkBuffer();
+      this.measurementAccumulator = new SourceMeasurementAccumulator(
+        chunk.sampleRate,
+        channelCount,
+        this.properties.limitPercentile,
+        windowSamplesFromMs(this.properties.smoothing, chunk.sampleRate),
+        this.capturedDetectionEnvelope,
+        chunk.bitDepth
+      );
+    }
+    await this.measurementAccumulator.push(chunk.samples, frames);
+    this.learnTimingMs.sourceMeasurement += Date.now() - tPush0;
+  }
   async _process(buffer) {
     const frames = buffer.frames;
     const channelCount = buffer.channels;
     const sampleRate = buffer.sampleRate ?? this.sampleRate ?? 44100;
     if (frames === 0 || channelCount === 0) return;
     const { targetLufs, targetTp, limitDb: limitDbOverride, limitPercentile, smoothing, tolerance, peakTolerance, maxAttempts } = this.properties;
-    const measurementHalfWidth = windowSamplesFromMs(smoothing, sampleRate);
     const tMeasure0 = Date.now();
-    const measurement = await measureSource(buffer, sampleRate, limitPercentile, measurementHalfWidth);
-    this.learnTimingMs.sourceMeasurement = Date.now() - tMeasure0;
+    const measurement = this.measurementAccumulator !== void 0 ? await this.measurementAccumulator.finalize() : await measureSource(buffer, sampleRate, limitPercentile, windowSamplesFromMs(smoothing, sampleRate));
+    this.learnTimingMs.sourceMeasurement += Date.now() - tMeasure0;
+    const capturedDetectionEnvelope = this.capturedDetectionEnvelope;
+    this.capturedDetectionEnvelope = null;
+    const detectionEnvelope = capturedDetectionEnvelope !== null && capturedDetectionEnvelope.frames === frames ? capturedDetectionEnvelope : void 0;
+    if (detectionEnvelope === void 0 && capturedDetectionEnvelope !== null) {
+      this.log(
+        "captured detection envelope frames mismatch; rebuilding at barrier",
+        { capturedFrames: capturedDetectionEnvelope.frames, bufferFrames: frames },
+        "warn"
+      );
+      await capturedDetectionEnvelope.close();
+    }
     const { integratedLufs: sourceLufs, lra: sourceLra, truePeakDb: sourcePeakDb } = measurement;
     if (!Number.isFinite(sourceLufs)) {
-      console.log(`[loudness-target] source has no measurable loudness (LUFS=${String(sourceLufs)}); pass-through.`);
+      if (detectionEnvelope !== void 0) await detectionEnvelope.close();
+      this.log("source has no measurable loudness; pass-through", { sourceLufs });
       return;
     }
     const userPivot = this.properties.pivot;
@@ -35373,13 +35561,13 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
       effectivePivotDb = userPivot;
     } else if (Number.isFinite(measurement.pivotAutoDb)) {
       effectivePivotDb = measurement.pivotAutoDb;
-      console.log(
-        `[loudness-target] pivot auto-derived to ${effectivePivotDb.toFixed(2)} dBFS (median(considered LRA blocks))`
-      );
+      this.log("pivot auto-derived (median(considered LRA blocks))", { pivotDb: effectivePivotDb });
     } else {
       effectivePivotDb = -40;
-      console.warn(
-        `[loudness-target] pivot auto-derivation produced no considered LRA blocks; falling back to ${effectivePivotDb} dBFS. Supply 'pivot' explicitly for tighter control on short or near-silent sources.`
+      this.log(
+        "pivot auto-derivation produced no considered LRA blocks; falling back. Supply 'pivot' explicitly for tighter control on short or near-silent sources.",
+        { fallbackPivotDb: effectivePivotDb },
+        "warn"
       );
     }
     const userFloor = this.properties.floor;
@@ -35388,16 +35576,15 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
       effectiveFloorDb = userFloor;
     } else if (Number.isFinite(measurement.floorAutoDb)) {
       effectiveFloorDb = measurement.floorAutoDb;
-      console.log(
-        `[loudness-target] floor auto-derived to ${effectiveFloorDb.toFixed(2)} dBFS (min(considered LRA blocks))`
-      );
+      this.log("floor auto-derived (min(considered LRA blocks))", { floorDb: effectiveFloorDb });
     } else {
       effectiveFloorDb = null;
     }
     if (effectiveFloorDb !== null && effectiveFloorDb >= effectivePivotDb) {
       const clampedFloorDb = effectivePivotDb - FLOOR_PIVOT_EPSILON_DB;
-      console.log(
-        `[loudness-target] floor (${effectiveFloorDb.toFixed(2)} dBFS) >= pivot (${effectivePivotDb.toFixed(2)} dBFS); clamping floor to ${clampedFloorDb.toFixed(3)} dBFS (pivot - ${FLOOR_PIVOT_EPSILON_DB} dB).`
+      this.log(
+        "floor >= pivot; clamping floor to (pivot - epsilon)",
+        { floorDb: effectiveFloorDb, pivotDb: effectivePivotDb, clampedFloorDb, epsilonDb: FLOOR_PIVOT_EPSILON_DB }
       );
       effectiveFloorDb = clampedFloorDb;
     }
@@ -35436,19 +35623,20 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
       maxAttempts,
       tolerance,
       peakTolerance,
-      seedB
+      seedB,
+      detectionEnvelope
     });
     this.learnTimingMs.iteration = Date.now() - tIterate0;
+    this.learnTimingMs.detection = result.detectionCacheBuildMs;
     this.winningSmoothedEnvelopeBuffer = result.bestSmoothedEnvelopeBuffer;
     this.winningB = result.bestB;
     this.winningLimitDb = result.bestLimitDb;
     this.winningPeakGainDb = result.bestPeakGainDb;
-    const lastAttempt = result.attempts[result.attempts.length - 1];
-    const outputLufsRepr = lastAttempt ? (targetLufs + lastAttempt.lufsErr).toFixed(2) : "n/a";
-    const outputLraRepr = lastAttempt ? lastAttempt.outputLra.toFixed(2) : "n/a";
-    const lufsDeltaRepr = lastAttempt ? lastAttempt.lufsErr.toFixed(2) : "n/a";
-    const outputTruePeakRepr = lastAttempt ? (effectiveTargetTp + lastAttempt.peakErr).toFixed(2) : "n/a";
-    const peakDeltaRepr = lastAttempt ? lastAttempt.peakErr.toFixed(2) : "n/a";
+    const outputLufsRepr = result.winnerOutputLufs !== null ? result.winnerOutputLufs.toFixed(2) : "n/a";
+    const outputLraRepr = result.winnerOutputLra !== null ? result.winnerOutputLra.toFixed(2) : "n/a";
+    const lufsDeltaRepr = result.winnerOutputLufs !== null ? (result.winnerOutputLufs - targetLufs).toFixed(2) : "n/a";
+    const outputTruePeakRepr = result.winnerOutputTruePeakDb !== null ? result.winnerOutputTruePeakDb.toFixed(2) : "n/a";
+    const peakDeltaRepr = result.winnerOutputTruePeakDb !== null ? (result.winnerOutputTruePeakDb - effectiveTargetTp).toFixed(2) : "n/a";
     const bestPeakGainDbRepr = result.bestPeakGainDb.toFixed(4);
     const bestLimitDbRepr = result.bestLimitDb.toFixed(4);
     const pivotRepr = userPivot === void 0 ? `${effectivePivotDb.toFixed(2)} (auto)` : String(userPivot);
@@ -35463,21 +35651,53 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
     }
     const limitDbRepr = `${bestLimitDbRepr} (${limitDbSource})`;
     const expansiveGeometry = result.bestPeakGainDb > result.bestB;
-    const expansionSuffix = expansiveGeometry ? " EXPANSIVE_UPPER_SEGMENT" : "";
     for (let attemptIdx = 0; attemptIdx < result.attempts.length; attemptIdx++) {
       const attempt = result.attempts[attemptIdx];
       if (attempt === void 0) continue;
-      console.log(
-        `[loudness-target] attempt ${(attemptIdx + 1).toString().padStart(2)}: B=${attempt.boost.toFixed(4).padStart(9)} peakGainDb=${attempt.peakGainDb.toFixed(4).padStart(9)} lufsErr=${attempt.lufsErr.toFixed(4).padStart(8)} peakErr=${attempt.peakErr.toFixed(4).padStart(8)} outputLra=${attempt.outputLra.toFixed(4).padStart(7)}`
-      );
+      this.log("attempt", {
+        attempt: attemptIdx + 1,
+        B: attempt.boost,
+        peakGainDb: attempt.peakGainDb,
+        lufsErr: attempt.lufsErr,
+        peakErr: attempt.peakErr,
+        outputLra: attempt.outputLra,
+        elapsedMs: attempt.elapsedMs
+      });
+      this.progress(attemptIdx + 1, maxAttempts);
     }
     const fmt = (x) => x === void 0 ? "off" : String(x);
-    console.log(
-      `[loudness-target] iteration: attempts=${result.attempts.length} converged=${String(result.converged)} seedB=${seedB.toFixed(4)} bestB=${result.bestB.toFixed(4)} bestLimitDb=${bestLimitDbRepr} bestPeakGainDb=${bestPeakGainDbRepr} outputLufs=${outputLufsRepr} (\u0394${lufsDeltaRepr}) outputLra=${outputLraRepr} outputTruePeakDb=${outputTruePeakRepr} (\u0394${peakDeltaRepr}) targetLufs=${targetLufs.toFixed(2)} targetTp=${targetTp === void 0 ? "source" : String(targetTp)} limitDb=${limitDbRepr} limitPercentile=${limitPercentile} sourceLufs=${sourceLufs.toFixed(2)} sourcePeakDb=${sourcePeakDb.toFixed(2)} sourceLra=${sourceLra.toFixed(2)} pivot=${pivotRepr} floor=${floorRepr} smoothing=${smoothing} tolerance=${fmt(tolerance)} peakTolerance=${fmt(peakTolerance)} maxAttempts=${fmt(maxAttempts)}` + expansionSuffix
-    );
+    this.log("iteration", {
+      attempts: result.attempts.length,
+      converged: result.converged,
+      seedB,
+      bestB: result.bestB,
+      bestLimitDb: bestLimitDbRepr,
+      bestPeakGainDb: bestPeakGainDbRepr,
+      outputLufs: outputLufsRepr,
+      lufsDelta: lufsDeltaRepr,
+      outputLra: outputLraRepr,
+      outputTruePeakDb: outputTruePeakRepr,
+      peakDelta: peakDeltaRepr,
+      targetLufs,
+      targetTp: targetTp === void 0 ? "source" : String(targetTp),
+      limitDb: limitDbRepr,
+      limitPercentile,
+      sourceLufs,
+      sourcePeakDb,
+      sourceLra,
+      pivot: pivotRepr,
+      floor: floorRepr,
+      smoothing,
+      tolerance: fmt(tolerance),
+      peakTolerance: fmt(peakTolerance),
+      maxAttempts: fmt(maxAttempts),
+      expansiveUpperSegment: expansiveGeometry
+    });
     if (expansiveGeometry) {
-      console.warn(
-        `[loudness-target] peakGainDb (${bestPeakGainDbRepr}) > B (${result.bestB.toFixed(4)}); upper segment of curve is expansive between pivot and limit. Brick-wall above limit still caps output at targetTp \u2014 note for listening QA.`
+      this.log(
+        "peakGainDb > B; upper segment of curve is expansive between pivot and limit. Brick-wall above limit still caps output at targetTp \u2014 note for listening QA.",
+        { peakGainDb: bestPeakGainDbRepr, B: result.bestB },
+        "warn"
       );
     }
   }
@@ -35487,14 +35707,25 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
       const bRepr = this.winningB === null ? "n/a" : this.winningB.toFixed(4);
       const limitDbRepr = this.winningLimitDb === null ? "n/a" : this.winningLimitDb.toFixed(4);
       const peakGainDbRepr = this.winningPeakGainDb === null ? "n/a" : this.winningPeakGainDb.toFixed(4);
-      console.log(
-        `[loudness-target timing] sourceMeasurement=${this.learnTimingMs.sourceMeasurement}ms detection=${this.learnTimingMs.detection}ms iteration=${this.learnTimingMs.iteration}ms unbufferApply=${this.unbufferElapsedMs}ms total=${total}ms winningB=${bRepr} winningLimitDb=${limitDbRepr} winningPeakGainDb=${peakGainDbRepr}`
-      );
+      this.log("timing", {
+        sourceMeasurementMs: this.learnTimingMs.sourceMeasurement,
+        detectionMs: this.learnTimingMs.detection,
+        iterationMs: this.learnTimingMs.iteration,
+        unbufferApplyMs: this.unbufferElapsedMs,
+        totalMs: total,
+        winningB: bRepr,
+        winningLimitDb: limitDbRepr,
+        winningPeakGainDb: peakGainDbRepr
+      });
     }
     if (this.winningSmoothedEnvelopeBuffer !== null) {
       await this.winningSmoothedEnvelopeBuffer.close();
       this.winningSmoothedEnvelopeBuffer = null;
     }
+    if (this.capturedDetectionEnvelope !== null) {
+      await this.capturedDetectionEnvelope.close();
+      this.capturedDetectionEnvelope = null;
+    }
   }
   async _unbuffer(chunk) {
     const envelopeBuffer = this.winningSmoothedEnvelopeBuffer;
@@ -35541,10 +35772,10 @@ var _LoudnessTargetNode = class _LoudnessTargetNode extends TransformNode {
     return new _LoudnessTargetNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_LoudnessTargetNode.moduleName = "Loudness Target";
+_LoudnessTargetNode.nodeName = "Loudness Target";
 _LoudnessTargetNode.packageName = PACKAGE_NAME;
 _LoudnessTargetNode.packageVersion = PACKAGE_VERSION;
-_LoudnessTargetNode.moduleDescription = "Peak-aware content-adaptive curve fitting (LUFS, true-peak, LRA) via a single combined gain envelope with a peak-respecting two-stage smoother. The upper-arm peak anchor jointly iterates with the body gain to land both LUFS and true-peak targets in one envelope.";
+_LoudnessTargetNode.nodeDescription = "Peak-aware content-adaptive curve fitting (LUFS, true-peak, LRA) via a single combined gain envelope with a peak-respecting two-stage smoother. The upper-arm peak anchor jointly iterates with the body gain to land both LUFS and true-peak targets in one envelope.";
 _LoudnessTargetNode.schema = schema19;
 var LoudnessTargetNode = _LoudnessTargetNode;
 function loudnessTarget(options) {
@@ -35552,24 +35783,6 @@ function loudnessTarget(options) {
   return new LoudnessTargetNode({ ...parsed, id: options.id });
 }
 
-// src/transforms/loudness-normalize/utils/measurement.ts
-var CHUNK_FRAMES6 = 44100;
-async function measureIntegratedLufs(buffer, sampleRate) {
-  const frames = buffer.frames;
-  const channelCount = buffer.channels;
-  if (frames === 0 || channelCount === 0) return -Infinity;
-  const accumulator = new IntegratedLufsAccumulator(sampleRate, channelCount);
-  await buffer.reset();
-  for (; ; ) {
-    const chunk = await buffer.read(CHUNK_FRAMES6);
-    const chunkFrames = chunk.samples[0]?.length ?? 0;
-    if (chunkFrames === 0) break;
-    accumulator.push(chunk.samples, chunkFrames);
-    if (chunkFrames < CHUNK_FRAMES6) break;
-  }
-  return accumulator.finalize();
-}
-
 // src/transforms/loudness-normalize/index.ts
 var schema20 = external_exports.object({
   target: external_exports.number().min(-50).max(0).multipleOf(0.1).default(-16).describe("Target integrated loudness (LUFS)")
@@ -35579,9 +35792,16 @@ var LoudnessNormalizeStream = class extends BufferedTransformStream {
     super(...arguments);
     this.gain = 1;
   }
-  async _process(buffer) {
-    const sampleRate = buffer.sampleRate ?? this.sampleRate ?? 44100;
-    const integrated = await measureIntegratedLufs(buffer, sampleRate);
+  async _buffer(chunk, buffer) {
+    await super._buffer(chunk, buffer);
+    const frames = chunk.samples[0]?.length ?? 0;
+    const channelCount = chunk.samples.length;
+    if (frames === 0 || channelCount === 0) return;
+    this.accumulator ?? (this.accumulator = new IntegratedLufsAccumulator(chunk.sampleRate, channelCount));
+    this.accumulator.push(chunk.samples, frames);
+  }
+  _process(_buffer) {
+    const integrated = this.accumulator === void 0 ? -Infinity : this.accumulator.finalize();
     if (!Number.isFinite(integrated)) {
       this.gain = 1;
       return;
@@ -35616,10 +35836,10 @@ var _LoudnessNormalizeNode = class _LoudnessNormalizeNode extends TransformNode
     return new _LoudnessNormalizeNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_LoudnessNormalizeNode.moduleName = "Loudness Normalize";
+_LoudnessNormalizeNode.nodeName = "Loudness Normalize";
 _LoudnessNormalizeNode.packageName = PACKAGE_NAME;
 _LoudnessNormalizeNode.packageVersion = PACKAGE_VERSION;
-_LoudnessNormalizeNode.moduleDescription = "Measure integrated loudness (BS.1770) and apply a single linear gain to hit a target LUFS \u2014 no limiting, no dynamics";
+_LoudnessNormalizeNode.nodeDescription = "Measure integrated loudness (BS.1770) and apply a single linear gain to hit a target LUFS \u2014 no limiting, no dynamics";
 _LoudnessNormalizeNode.schema = schema20;
 var LoudnessNormalizeNode = _LoudnessNormalizeNode;
 function loudnessNormalize(options) {
@@ -35628,7 +35848,6 @@ function loudnessNormalize(options) {
 }
 
 // src/transforms/true-peak-normalize/index.ts
-var CHUNK_FRAMES7 = 44100;
 var schema21 = external_exports.object({
   target: external_exports.number().lt(0).default(-1).describe("Target true peak (dBTP). Must be < 0.")
 });
@@ -35637,32 +35856,28 @@ var TruePeakNormalizeStream = class extends BufferedTransformStream {
     super(...arguments);
     this.gain = 1;
   }
-  async _process(buffer) {
-    const sampleRate = buffer.sampleRate ?? this.sampleRate ?? 44100;
-    const channelCount = buffer.channels;
-    const frames = buffer.frames;
-    if (frames === 0 || channelCount === 0) {
+  async _buffer(chunk, buffer) {
+    await super._buffer(chunk, buffer);
+    const frames = chunk.samples[0]?.length ?? 0;
+    const channelCount = chunk.samples.length;
+    if (frames === 0 || channelCount === 0) return;
+    this.accumulator ?? (this.accumulator = new TruePeakAccumulator(chunk.sampleRate, channelCount));
+    this.accumulator.push(chunk.samples, frames);
+  }
+  _process(_buffer) {
+    if (this.accumulator === void 0) {
       this.gain = 1;
       return;
     }
-    const accumulator = new TruePeakAccumulator(sampleRate, channelCount);
-    await buffer.reset();
-    for (; ; ) {
-      const chunk = await buffer.read(CHUNK_FRAMES7);
-      const chunkFrames = chunk.samples[0]?.length ?? 0;
-      if (chunkFrames === 0) break;
-      accumulator.push(chunk.samples, chunkFrames);
-      if (chunkFrames < CHUNK_FRAMES7) break;
-    }
-    const sourcePeakLinear = accumulator.finalize();
+    const sourcePeakLinear = this.accumulator.finalize();
     if (sourcePeakLinear <= 0) {
       this.gain = 1;
-      console.log(`[true-peak-normalize] sourceTP=-Infinity target=${this.properties.target} gain=1`);
+      this.log("true peak measured", { sourceTpDb: -Infinity, targetDb: this.properties.target, gain: 1 });
       return;
     }
     const sourcePeakDb = 20 * Math.log10(sourcePeakLinear);
     this.gain = Math.pow(10, (this.properties.target - sourcePeakDb) / 20);
-    console.log(`[true-peak-normalize] sourceTP=${sourcePeakDb} target=${this.properties.target} gain=${this.gain}`);
+    this.log("true peak measured", { sourceTpDb: sourcePeakDb, targetDb: this.properties.target, gain: this.gain });
   }
   _unbuffer(chunk) {
     const gain2 = this.gain;
@@ -35692,10 +35907,10 @@ var _TruePeakNormalizeNode = class _TruePeakNormalizeNode extends TransformNode
     return new _TruePeakNormalizeNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_TruePeakNormalizeNode.moduleName = "True Peak Normalize";
+_TruePeakNormalizeNode.nodeName = "True Peak Normalize";
 _TruePeakNormalizeNode.packageName = PACKAGE_NAME;
 _TruePeakNormalizeNode.packageVersion = PACKAGE_VERSION;
-_TruePeakNormalizeNode.moduleDescription = "Measure source true peak (4\xD7 upsampled, BS.1770-4 style) and apply a single linear gain to hit a target dBTP";
+_TruePeakNormalizeNode.nodeDescription = "Measure source true peak (4\xD7 upsampled, BS.1770-4 style) and apply a single linear gain to hit a target dBTP";
 _TruePeakNormalizeNode.schema = schema21;
 var TruePeakNormalizeNode = _TruePeakNormalizeNode;
 function truePeakNormalize(options) {
@@ -35745,8 +35960,8 @@ function betaForBand(_bandIndex) {
 }
 function schroederTargetToDelay(magnitude, amount = 1) {
   const binCount = magnitude.length;
-  const delay = new Float32Array(binCount);
-  if (binCount < 2) return delay;
+  const delay2 = new Float32Array(binCount);
+  if (binCount < 2) return delay2;
   const phase2 = schroederTargetPhase(magnitude);
   const dOmega = Math.PI / (binCount - 1);
   const scale = Math.max(0, Math.min(1, amount));
@@ -35756,9 +35971,9 @@ function schroederTargetToDelay(magnitude, amount = 1) {
     const dPhi = (phase2[hi] ?? 0) - (phase2[lo] ?? 0);
     const span = (hi - lo) * dOmega;
     const tau = span > 0 ? -dPhi / span : 0;
-    delay[bin] = scale * Math.max(0, tau);
+    delay2[bin] = scale * Math.max(0, tau);
   }
-  return delay;
+  return delay2;
 }
 function poleRadius(halfWidth, beta) {
   const delta = Math.max(0, halfWidth);
@@ -35773,14 +35988,14 @@ function poleRadius(halfWidth, beta) {
   if (!Number.isFinite(rho)) return 0;
   return Math.max(0, Math.min(MAX_POLE_RADIUS, rho));
 }
-function designDispersionAllpass(delay, order) {
-  const binCount = delay.length;
+function designDispersionAllpass(delay2, order) {
+  const binCount = delay2.length;
   const poles = [];
   if (binCount < 2 || order <= 0) return { denominator: Float32Array.from([1]), poles };
   const dOmega = Math.PI / (binCount - 1);
   let rawHalfArea = 0;
   for (let bin = 0; bin < binCount - 1; bin++) {
-    rawHalfArea += 0.5 * ((delay[bin] ?? 0) + (delay[bin + 1] ?? 0)) * dOmega;
+    rawHalfArea += 0.5 * ((delay2[bin] ?? 0) + (delay2[bin + 1] ?? 0)) * dOmega;
   }
   let naturalOrder = Math.round(rawHalfArea / Math.PI);
   if (naturalOrder < 0) naturalOrder = 0;
@@ -35792,9 +36007,9 @@ function designDispersionAllpass(delay, order) {
   }
   if (rawHalfArea > bandOrder * Math.PI && rawHalfArea > 0) {
     const areaScale = bandOrder * Math.PI / rawHalfArea;
-    for (let bin = 0; bin < binCount; bin++) scaled[bin] = areaScale * (delay[bin] ?? 0);
+    for (let bin = 0; bin < binCount; bin++) scaled[bin] = areaScale * (delay2[bin] ?? 0);
   } else {
-    for (let bin = 0; bin < binCount; bin++) scaled[bin] = delay[bin] ?? 0;
+    for (let bin = 0; bin < binCount; bin++) scaled[bin] = delay2[bin] ?? 0;
     constantDelay = Math.max(0, (bandOrder * Math.PI - rawHalfArea) / Math.PI);
   }
   const omegaAt = (bin) => bin * dOmega;
@@ -35968,9 +36183,6 @@ function searchBindingPeak(channelWindows, reflectionRow, order, lambda, targetP
   if (identityPower <= targetPeakPower || lambda <= 0) {
     return {
       scale: 0,
-      // One objective evaluation was performed (the identity / c=0
-      // `truePeakPower4x` above) — `iterations` is the deterministic
-      // evaluation count, so the skip path is 1, not 0.
       iterations: 1,
       committedPeakPower: identityPower,
       identityPeakPower: identityPower,
@@ -36125,42 +36337,41 @@ function stftFrameCount(signalLength, frameSize, hopSize) {
   if (signalLength < frameSize || hopSize <= 0) return 0;
   return Math.floor((signalLength - frameSize) / hopSize) + 1;
 }
-async function measureBufferTruePeakWithArgmax(buffer, _sampleRate) {
-  const channelCount = buffer.channels;
-  const totalFrames = buffer.frames;
-  if (channelCount === 0 || totalFrames === 0) return { db: linearToDb(0), peakInputSample: 0 };
-  await buffer.reset();
-  const upsamplers = [];
-  for (let channel = 0; channel < channelCount; channel++) upsamplers.push(new TruePeakUpsampler(4));
-  let runningMax = 0;
-  let peakInputSample = 0;
-  let inputBase = 0;
-  let toRead = totalFrames;
-  while (toRead > 0) {
-    const want = Math.min(WALK_CHUNK_FRAMES, toRead);
-    const chunk = await buffer.read(want);
-    const got = chunk.samples[0]?.length ?? 0;
-    if (got === 0) break;
-    for (let channel = 0; channel < channelCount; channel++) {
-      const samples = chunk.samples[channel];
-      const upsampler = upsamplers[channel];
+var TruePeakArgmaxAccumulator = class {
+  constructor(channelCount, _sampleRate) {
+    this.channelCount = channelCount;
+    this.runningMax = 0;
+    this.peakInputSample = 0;
+    this.inputBase = 0;
+    this.upsamplers = [];
+    for (let channel = 0; channel < channelCount; channel++) this.upsamplers.push(new TruePeakUpsampler(4));
+  }
+  push(channels, frames) {
+    if (frames <= 0) {
+      this.inputBase += frames > 0 ? frames : 0;
+      return;
+    }
+    for (let channel = 0; channel < this.channelCount; channel++) {
+      const samples = channels[channel];
+      const upsampler = this.upsamplers[channel];
       if (samples === void 0 || upsampler === void 0) continue;
-      const slice = samples.length === got ? samples : samples.subarray(0, got);
+      const slice = samples.length === frames ? samples : samples.subarray(0, frames);
       const upsampled = upsampler.upsample(slice);
       for (let index = 0; index < upsampled.length; index++) {
         const value = upsampled[index] ?? 0;
         const magnitude = value < 0 ? -value : value;
-        if (magnitude > runningMax) {
-          runningMax = magnitude;
-          peakInputSample = inputBase + Math.floor(index / 4);
+        if (magnitude > this.runningMax) {
+          this.runningMax = magnitude;
+          this.peakInputSample = this.inputBase + Math.floor(index / 4);
         }
       }
     }
-    inputBase += got;
-    toRead -= got;
+    this.inputBase += frames;
   }
-  return { db: linearToDb(runningMax), peakInputSample };
-}
+  finalize() {
+    return { db: linearToDb(this.runningMax), peakInputSample: this.peakInputSample };
+  }
+};
 async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addonOptions, search) {
   const channelCount = buffer.channels;
   const signalLength = buffer.frames;
@@ -36243,8 +36454,8 @@ async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addo
         }
         windowPeaks[nextFrame] = { peakMagnitude: windowPeak, headroom: amount };
         peakSampleIndex[nextFrame] = start + peakPos;
-        const delay = schroederTargetToDelay(sumMagnitude, amount);
-        const { denominator } = designDispersionAllpass(delay, order);
+        const delay2 = schroederTargetToDelay(sumMagnitude, amount);
+        const { denominator } = designDispersionAllpass(delay2, order);
         const reflection = stepDownToReflection(denominator);
         const row = new Float32Array(order);
         for (let section = 0; section < order; section++) row[section] = reflection[section] ?? 0;
@@ -36277,40 +36488,40 @@ async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addo
   }
   return { trajectory, frameCount, signalLength, windowPeaks, bindingMask };
 }
-async function streamLatticeApply(buffer, smoothedTrajectory, scale, order, hopSize, onChunk) {
-  const channelCount = buffer.channels;
-  const signalLength = buffer.frames;
-  if (channelCount === 0 || signalLength === 0) return;
-  const rows = smoothedTrajectory.rows;
-  const frameCount = rows.length;
-  const state = Array.from({ length: channelCount }, () => new Float32Array(order));
-  await buffer.reset();
-  let sample = 0;
-  let toRead = signalLength;
-  const MAX_REFLECTION2 = 0.95;
-  while (toRead > 0) {
-    const want = Math.min(WALK_CHUNK_FRAMES, toRead);
-    const chunk = await buffer.read(want);
-    const got = chunk.samples[0]?.length ?? 0;
-    if (got === 0) break;
-    const out = Array.from({ length: channelCount }, () => new Float32Array(got));
-    for (let index = 0; index < got; index++) {
-      const framePos = hopSize > 0 ? sample / hopSize : 0;
+var _LatticeApplyState = class _LatticeApplyState {
+  constructor(trajectory, order, hopSize, channelCount) {
+    this.trajectory = trajectory;
+    this.order = order;
+    this.hopSize = hopSize;
+    this.sample = 0;
+    this.rows = trajectory.rows;
+    this.frameCount = this.rows.length;
+    this.state = Array.from({ length: channelCount }, () => new Float32Array(order));
+  }
+  apply(channels, frames) {
+    const channelCount = this.state.length;
+    const order = this.order;
+    const hopSize = this.hopSize;
+    const frameCount = this.frameCount;
+    const rows = this.rows;
+    const out = Array.from({ length: channelCount }, () => new Float32Array(frames));
+    for (let index = 0; index < frames; index++) {
+      const framePos = hopSize > 0 ? this.sample / hopSize : 0;
       const frame0 = Math.min(frameCount - 1, Math.max(0, Math.floor(framePos)));
       const frame1 = Math.min(frameCount - 1, frame0 + 1);
       const fraction = framePos - frame0;
-      const row0 = rows[frame0] ?? smoothedTrajectory.identity;
-      const row1 = rows[frame1] ?? smoothedTrajectory.identity;
+      const row0 = rows[frame0] ?? this.trajectory.identity;
+      const row1 = rows[frame1] ?? this.trajectory.identity;
       for (let ch = 0; ch < channelCount; ch++) {
-        const inputValue = chunk.samples[ch]?.[index] ?? 0;
+        const inputValue = channels[ch]?.[index] ?? 0;
         const outChannel = out[ch];
-        const chState = state[ch] ?? new Float32Array(order);
+        const chState = this.state[ch] ?? new Float32Array(order);
         let signalValue = inputValue;
         for (let section = 0; section < order; section++) {
           const interpolated = (row0[section] ?? 0) + fraction * ((row1[section] ?? 0) - (row0[section] ?? 0));
-          let kCoeff = scale * interpolated;
-          if (kCoeff > MAX_REFLECTION2) kCoeff = MAX_REFLECTION2;
-          else if (kCoeff < -MAX_REFLECTION2) kCoeff = -MAX_REFLECTION2;
+          let kCoeff = _LatticeApplyState.SCALE * interpolated;
+          if (kCoeff > _LatticeApplyState.MAX_REFLECTION) kCoeff = _LatticeApplyState.MAX_REFLECTION;
+          else if (kCoeff < -_LatticeApplyState.MAX_REFLECTION) kCoeff = -_LatticeApplyState.MAX_REFLECTION;
           const cCoeff = Math.sqrt(Math.max(0, 1 - kCoeff * kCoeff));
           const delayed = chState[section] ?? 0;
           const toDelay = cCoeff * signalValue + kCoeff * delayed;
@@ -36320,12 +36531,15 @@ async function streamLatticeApply(buffer, smoothedTrajectory, scale, order, hopS
         }
         if (outChannel) outChannel[index] = signalValue;
       }
-      sample += 1;
+      this.sample += 1;
     }
-    await onChunk(out, got);
-    toRead -= got;
+    return out;
   }
-}
+};
+// Mirrors lattice.ts MAX_REFLECTION (module-private there); both sides must clamp identically.
+_LatticeApplyState.MAX_REFLECTION = 0.95;
+_LatticeApplyState.SCALE = 1;
+var LatticeApplyState = _LatticeApplyState;
 
 // src/transforms/crest-reduce/index.ts
 function isPowerOfTwo(value) {
@@ -36342,28 +36556,8 @@ var schema22 = external_exports.object({
 var CrestReduceStream = class extends BufferedTransformStream {
   constructor() {
     super(...arguments);
-    /**
-     * Whole-file transformed output as a node-owned, disk-backed
-     * `ChunkBuffer` (the `loudnessTarget` `winningSmoothedEnvelopeBuffer`
-     * precedent — NOT a stream-resident full-length `Float32Array`, which
-     * was the design-streaming.md materialization anti-pattern Phase 2
-     * removes). `_process` writes the produced output here at flush;
-     * `_unbuffer` serves it chunk-by-chunk. `null` when the stream passes
-     * through (no audio or a sub-frame input — there is no `strength`
-     * bypass after the 2026-05-17 keystone; the node always runs the
-     * gate/search/lattice path), in which case `_unbuffer` emits the
-     * input verbatim (the length-preserving passthrough fallback).
-     */
-    this.outputBuffer = null;
-    /**
-     * Set `true` by the first `_unbuffer` call so `outputBuffer`'s read
-     * cursor is rewound exactly once (it is at end-of-buffer after
-     * `_process`'s streaming production write). Rewound lazily in
-     * `_unbuffer` — after `_process` finished — not eagerly, so a stable
-     * cursor state exists (the `loudnessTarget` `unbufferCursorsReady`
-     * precedent).
-     */
-    this.unbufferCursorReady = false;
+    this.applyOrder = LATTICE_ORDER;
+    this.applyHopSize = 0;
   }
   async _setup(input, context) {
     const fft2 = initFftBackend(context.executionProviders, this.properties);
@@ -36374,98 +36568,13 @@ var CrestReduceStream = class extends BufferedTransformStream {
   get hopSize() {
     return this.properties.frameSize / 4;
   }
-  /**
-   * Whole-file processing at flush (the `loudnessTarget` accumulate-then-
-   * process precedent — `bufferSize === WHOLE_FILE`, so the framework hands
-   * the ENTIRE accumulated signal in one `_process` call). The SINGLE
-   * realization (2026-05-16 FUNDAMENTAL REFRAME — the normalized
-   * Gray–Markel lossless-lattice phase rotator; `spectral` and the
-   * `realization` parameter removed):
-   *
-   * The 2026-05-17 KEYSTONE rework — SINGLE-PASS, per-binding-peak
-   * Item-7 search over a TP-DRIVEN gate and a TP-DRIVEN commit
-   * objective; NO `strength` (the node always applies the optimal
-   * value); NO whole-signal never-worsen veto (the only never-worsen
-   * is the per-window commit-only-if-better intrinsic to the Item-7
-   * search):
-   *
-   *   1. WHOLE-SIGNAL 4× true peak + its input-sample index measured
-   *      ONCE — a SEQUENTIAL CHUNKED WALK driving per-channel BS.1770-4
-   *      4× `TruePeakUpsampler`s directly
-   *      (`measureBufferTruePeakWithArgmax`; 12-tap history carries
-   *      across `upsample` so chunk boundaries are invisible). The dBTP
-   *      is the gate's proximity reference; `peakInputSample`
-   *      force-binds the analysis frame containing the file's global
-   *      4× true peak.
-   *   2. EXTRACT + TP-DRIVEN GATE + ITEM-7 SEARCH, one streaming
-   *      sliding-window pass — `streamLatticeTrajectory(buffer, …,
-   *      { globalTruePeakDb, peakInputSample, sampleRate, lambda })`: a
-   *      `frameSize` ring of the linked-stereo sum + ONE per channel,
-   *      computed on the fly (NO whole-signal array). Per hop the
-   *      grounded Abel & Smith (Item 9) + RMV §III step-down (Item 8)
-   *      reflection row is fitted VERBATIM; the frame is classified by
-   *      the TP-DRIVEN gate predicate (`isBindingPeak` —
-   *      `peakPriorityAmount` headroom AND ( the window's OWN
-   *      per-channel 4× true peak within BINDING_DELTA_DB of the global
-   *      4× true peak, SAME true-peak domain — OR the global-4×-TP
-   *      frame, force-bound ); `binding.ts` UNFROZEN); an ACTIVE-band
-   *      peak frame runs the §Algorithm Specification Item-7 search
-   *      (`searchBindingPeak`, Hong/Kim/Har 2011 §3; `search.ts`
-   *      UNFROZEN — its COMMIT OBJECTIVE is the cross-channel 4×
-   *      true-peak power, the Eq. 7–9 φ′ raw-sample recurrence kept as
-   *      the candidate-proposal direction only) over the PER-CHANNEL
-   *      windows with the FULL group-delay-ceiling λ — its committed
-   *      scale (commit-only-if-better on the 4× TP power; identity
-   *      `c=0` is the guaranteed floor) is the per-active-peak OPTIMAL
-   *      decorrelation value; a NON-active frame's envelope value is 0.
-   *      There is NO `strength` (λ is ALWAYS the full ceiling,
-   *      `groupDelayLambda`). The O(frames) trajectory IS the
-   *      decorrelation envelope (the ONLY resident product besides
-   *      bounded scratch).
-   *   2b. COMBINE the envelope (the 2026-05-17 PER-PEAK-EXACT model):
-   *      `smoothControlTrajectory` = `max` of a per-peak EXACT-OPTIMAL
-   *      flat hold centered on the PEAK SAMPLE `n_i` (half-width
-   *      `exactHoldHalfWidthFrames(sampleRate, hopSize)` — the
-   *      group-delay span, NEVER `smoothing`) that pins the EXACT
-   *      Item-7 optimal at every binding peak so whole-signal
-   *      true-peak reduction is `smoothing`-INVARIANT, and a
-   *      `smoothing`-driven bidirectional zero-phase SPILL
-   *      (transient-asymmetry pullback pre-pass THEN forward+backward
-   *      `BidirectionalIir` on the trajectory's FRAME-RATE axis,
-   *      τ = (ms/1000)·√2 internal to `BidirectionalIir`) whose ONLY
-   *      effect is decorrelation spill into the gated gaps + easing
-   *      between active values. HARD RULE (design §Rejected
-   *      Approaches): both passes are on the CONTROL trajectory ONLY —
-   *      NEVER the audio.
-   *   3. ONE streaming PRODUCTION pass over the committed
-   *      per-peak-exact + bidirectionally-SMOOTHED decorrelation
-   *      envelope. `streamLatticeApply` is the byte-faithful
-   *      `processLatticeChannel` transcription (lattice.ts BYTE-FROZEN)
-   *      and is called with the literal `1` for its internal
-   *      transcribed scalar (an identity no-op at the call site — an
-   *      internal arg of the verbatim transcription, NOT a public
-   *      surface; there is no `strength`). There is NO whole-signal
-   *      never-worsen veto (removed — the per-window
-   *      commit-only-if-better in the Item-7 search is the only
-   *      never-worsen) and NO per-sample binding gate / edge crossfade:
-   *      a non-active segment is the lattice at eased-to-zero
-   *      coefficients (a crest-invariant pure delay). Each output chunk
-   *      is written straight into the node-owned output `ChunkBuffer`
-   *      (served chunk-by-chunk by `_unbuffer`). The streamed lattice
-   *      output is BIT-IDENTICAL to processing one contiguous array.
-   *
-   * NO whole-signal `Float32Array` exists anywhere — the
-   * design-streaming.md materialization anti-pattern is GENUINELY
-   * eliminated (not relocated). Resident state: the O(frames) trajectory
-   * + mask + bounded ring (sum + per-channel) / accumulator / chunk
-   * scratch.
-   *
-   * There is NO node-level bypass (the `strength` parameter and its
-   * `strength <= 0` early-return were removed by the 2026-05-17
-   * keystone). The only passthrough is the length-preserving fallback
-   * for no audio / a sub-frame input (no analysis frame fits) —
-   * `_unbuffer` then emits the input verbatim.
-   */
+  async _buffer(chunk, buffer) {
+    await super._buffer(chunk, buffer);
+    const frames = chunk.samples[0]?.length ?? 0;
+    if (frames === 0 || chunk.samples.length === 0) return;
+    this.truePeakAccumulator ?? (this.truePeakAccumulator = new TruePeakArgmaxAccumulator(chunk.samples.length, chunk.sampleRate));
+    this.truePeakAccumulator.push(chunk.samples, frames);
+  }
   async _process(buffer) {
     const { frameSize, smoothing } = this.properties;
     const channelCount = buffer.channels;
@@ -36474,7 +36583,7 @@ var CrestReduceStream = class extends BufferedTransformStream {
     const sampleRate = buffer.sampleRate ?? this.sampleRate ?? 48e3;
     const order = LATTICE_ORDER;
     const hopSize = this.hopSize;
-    const { db: inputTpDb, peakInputSample } = await measureBufferTruePeakWithArgmax(buffer);
+    const { db: inputTpDb, peakInputSample } = this.truePeakAccumulator?.finalize() ?? { db: linearToDb(0), peakInputSample: 0 };
     const lambda = groupDelayLambda(sampleRate, order);
     const { trajectory, frameCount } = await streamLatticeTrajectory(buffer, frameSize, hopSize, this.fftBackend, this.fftAddonOptions, {
       globalTruePeakDb: inputTpDb,
@@ -36482,58 +36591,21 @@ var CrestReduceStream = class extends BufferedTransformStream {
       sampleRate,
       lambda
     });
-    if (frameCount === 0) {
-      return;
-    }
-    const smoothed = smoothControlTrajectory(trajectory, smoothing, trajectoryFrameRate(sampleRate, hopSize), exactHoldHalfWidthFrames(sampleRate, hopSize), hopSize);
-    const out = new ChunkBuffer();
-    await streamLatticeApply(buffer, smoothed, 1, order, hopSize, async (channels, got) => {
-      await out.write(
-        channels.map((channel) => channel.length === got ? channel : channel.subarray(0, got)),
-        sampleRate
-      );
-    });
-    await out.flushWrites();
-    if (out.frames > 0) this.outputBuffer = out;
-    else await out.close();
+    if (frameCount === 0) return;
+    this.smoothedTrajectory = smoothControlTrajectory(trajectory, smoothing, trajectoryFrameRate(sampleRate, hopSize), exactHoldHalfWidthFrames(sampleRate, hopSize), hopSize);
+    this.applyOrder = order;
+    this.applyHopSize = hopSize;
   }
-  /**
-   * Serve the whole-file transformed output sequentially in chunk cadence
-   * from the node-owned disk-backed `ChunkBuffer` (the `loudnessTarget`
-   * `_unbuffer` precedent — read forward in chunk-cadence lockstep with
-   * upstream chunks; NO overlap re-feed since `bufferSize === WHOLE_FILE`).
-   * When no transform was produced (no audio or a sub-frame input —
-   * there is no `strength` bypass after the 2026-05-17 keystone) the
-   * input chunk is emitted VERBATIM — the length-preserving passthrough
-   * fallback (nothing mutated, same backing arrays).
-   */
-  async _unbuffer(chunk) {
-    const output = this.outputBuffer;
-    const length = chunk.samples[0]?.length ?? 0;
-    if (output === null || output.frames === 0 || length === 0) return chunk;
-    if (!this.unbufferCursorReady) {
-      await output.reset();
-      this.unbufferCursorReady = true;
-    }
-    const transformedChunk = await output.read(length);
-    const transformed = transformedChunk.samples;
+  _unbuffer(chunk) {
+    const trajectory = this.smoothedTrajectory;
+    const frames = chunk.samples[0]?.length ?? 0;
+    const channelCount = chunk.samples.length;
+    if (trajectory === void 0 || frames === 0 || channelCount === 0) return chunk;
+    this.applyState ?? (this.applyState = new LatticeApplyState(trajectory, this.applyOrder, this.applyHopSize, channelCount));
+    const transformed = this.applyState.apply(chunk.samples, frames);
     const samples = chunk.samples.map((inputChannel, ch) => transformed[ch] ?? inputChannel);
     return { samples, offset: chunk.offset, sampleRate: chunk.sampleRate, bitDepth: chunk.bitDepth };
   }
-  /**
-   * Idempotent cleanup of the node-owned output `ChunkBuffer` so its
-   * backing temp file is released on EVERY exit path — not only graceful
-   * end-of-stream (the 2026-05-12 `_teardown`-guaranteed-cleanup
-   * Decision; the `loudnessTarget` precedent). `BufferedTransformStream`
-   * already closes its own accumulation `chunkBuffer` in `teardown()`;
-   * this node-owned extra buffer needs its own release.
-   */
-  async _teardown() {
-    if (this.outputBuffer !== null) {
-      await this.outputBuffer.close();
-      this.outputBuffer = null;
-    }
-  }
 };
 var _CrestReduceNode = class _CrestReduceNode extends TransformNode {
   constructor(properties) {
@@ -36550,10 +36622,10 @@ var _CrestReduceNode = class _CrestReduceNode extends TransformNode {
     return new _CrestReduceNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_CrestReduceNode.moduleName = "Crest Reduce";
+_CrestReduceNode.nodeName = "Crest Reduce";
 _CrestReduceNode.packageName = PACKAGE_NAME;
 _CrestReduceNode.packageVersion = PACKAGE_VERSION;
-_CrestReduceNode.moduleDescription = "Content-adaptive, magnitude-preserving, phase-only crest-factor reducer \u2014 a pre-limiter headroom stage that rearranges signal phase to flatten true-peak excursions without changing the magnitude spectrum, never increasing crest factor";
+_CrestReduceNode.nodeDescription = "Content-adaptive, magnitude-preserving, phase-only crest-factor reducer \u2014 a pre-limiter headroom stage that rearranges signal phase to flatten true-peak excursions without changing the magnitude spectrum, never increasing crest factor";
 _CrestReduceNode.schema = schema22;
 var CrestReduceNode = _CrestReduceNode;
 function crestReduce(options) {
@@ -37045,7 +37117,6 @@ var WindowReader = class {
   getScratch() {
     return this.scratch;
   }
-  /** Fill the leading `edgePadSamples` of the virtual signal with zeros and load the rest of the first window from `buffer`. */
   async preload(buffer, edgePadSamples) {
     for (let ch = 0; ch < this.channels; ch++) this.scratch[ch].fill(0);
     this.virtualCursor = 0;
@@ -37055,7 +37126,6 @@ var WindowReader = class {
     if (remainingInWindow > 0) await this.readInto(buffer, headPad, remainingInWindow);
     this.virtualCursor = this.windowSamples;
   }
-  /** Slide scratch left by `step` samples; append `step` new samples from `buffer` (zero-filled past end). */
   async advance(buffer, step) {
     if (step <= 0) return;
     const keep = this.windowSamples - step;
@@ -37169,20 +37239,6 @@ var DeBleedStream = class extends BufferedTransformStream {
     }
     this.referenceBuffers = [];
   }
-  /**
-   * Run the first-N-seconds warm-up scan across all target channels and all
-   * references in a single sequential pass over each buffer.
-   *
-   * Each buffer is rewound to its start, then sequentially read for
-   * `warmupSamples` real samples. STFTs are computed once per buffer (one
-   * STFT per channel for the multi-channel target, one STFT per reference
-   * for the references). Per-channel cross-spectral accumulators then
-   * consume the pre-computed STFTs.
-   *
-   * Returns a `channels × refCount` array of `TransferFunction` seeds:
-   * `seedsByChannel[ch][refIndex]`. Degeneracy validation and cold-start
-   * fallback per `validateTransferSeed`.
-   */
   async warmupSeedsAllChannels(buffer, channels, warmupFrames, fftSize, hopSize) {
     const { numBins, referenceBuffers } = this;
     const refCount = referenceBuffers.length;
@@ -37229,7 +37285,7 @@ var DeBleedStream = class extends BufferedTransformStream {
       const validated = seeds.map((seed) => {
         const validation = validateTransferSeed(seed);
         if (validation.degenerate) {
-          console.warn(`de-bleed: warm-up seed degenerate (${validation.reason}); falling back to cold-start \u0124(\u2113=0) = 0.`);
+          this.log("warm-up seed degenerate; falling back to cold-start \u0124(\u2113=0) = 0", { reason: validation.reason }, "warn");
           return coldStartSeed(numBins);
         }
         return seed;
@@ -37493,17 +37549,18 @@ var DeBleedStream = class extends BufferedTransformStream {
     if (profileEnabled) {
       const total = profileMs.warmup + profileMs.stftRead + profileMs.msad + profileMs.kalman + profileMs.mwf + profileMs.nlm + profileMs.dftt + profileMs.applyMaskIstft + profileMs.write;
       const pct = (key) => `${(profileMs[key] / 1e3).toFixed(2)}s (${(profileMs[key] / total * 100).toFixed(1)}%)`;
-      console.log(`[deBleed profile]
-  warmup        : ${pct("warmup")}
-  stft+read     : ${pct("stftRead")}
-  msad          : ${pct("msad")}
-  kalman+isp    : ${pct("kalman")}
-  mwf           : ${pct("mwf")}
-  nlm           : ${pct("nlm")}
-  dftt          : ${pct("dftt")}
-  applyMask+istft: ${pct("applyMaskIstft")}
-  write         : ${pct("write")}
-  TOTAL         : ${(total / 1e3).toFixed(2)}s`);
+      this.log("profile", {
+        warmup: pct("warmup"),
+        stftRead: pct("stftRead"),
+        msad: pct("msad"),
+        kalman: pct("kalman"),
+        mwf: pct("mwf"),
+        nlm: pct("nlm"),
+        dftt: pct("dftt"),
+        applyMaskIstft: pct("applyMaskIstft"),
+        write: pct("write"),
+        totalS: (total / 1e3).toFixed(2)
+      });
     }
   }
 };
@@ -37522,10 +37579,10 @@ var _DeBleedNode = class _DeBleedNode extends TransformNode {
     return new _DeBleedNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_DeBleedNode.moduleName = "De-Bleed Adaptive";
+_DeBleedNode.nodeName = "De-Bleed Adaptive";
 _DeBleedNode.packageName = PACKAGE_NAME;
 _DeBleedNode.packageVersion = PACKAGE_VERSION;
-_DeBleedNode.moduleDescription = "Adaptive (MEF FDAF Kalman + MWF + MSAD) reference-based microphone bleed reduction. Stages 1+2 are MEF Meyer-Elshamy-Fingscheidt 2020; Stage 3 is Lukin-Todd 2D NLM+DFTT post-filter.";
+_DeBleedNode.nodeDescription = "Adaptive (MEF FDAF Kalman + MWF + MSAD) reference-based microphone bleed reduction. Stages 1+2 are MEF Meyer-Elshamy-Fingscheidt 2020; Stage 3 is Lukin-Todd 2D NLM+DFTT post-filter.";
 _DeBleedNode.schema = schema23;
 var DeBleedNode = _DeBleedNode;
 function deBleed(references, options) {
@@ -37544,7 +37601,7 @@ function deBleed(references, options) {
   });
 }
 var require3 = createRequire(import.meta.url);
-function createOnnxSession(addonPath, modelPath, options) {
+function createOnnxSession(addonPath, modelPath, options, log) {
   let addon;
   try {
     addon = require3(addonPath);
@@ -37566,7 +37623,7 @@ function createOnnxSession(addonPath, modelPath, options) {
   } catch (error50) {
     provider = `<unknown> (getProvider() threw: ${error50 instanceof Error ? error50.message : String(error50)})`;
   }
-  console.log(`[onnx-runtime] session created for ${modelName} using ${provider}`);
+  log?.("onnx session created", { modelName, provider });
   return {
     run(inputs) {
       return session.run(inputs);
@@ -37638,14 +37695,10 @@ var schema24 = external_exports.object({
 var DeepFilterNet3Stream = class extends BufferedTransformStream {
   constructor() {
     super(...arguments);
-    // One DfnState per channel — DFN3's recurrent state is per-source, so stereo input
-    // needs two independent states (matches DTLN's per-channel handling).
-    // Allocated lazily on the first `_process` call so we can size to the actual chunk
-    // channel count rather than guessing.
     this.dfnStates = [];
   }
   async _setup(input, context) {
-    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: ["cpu"] });
+    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: ["cpu"] }, (message, data) => this.log(message, data));
     const sourceRate = this.properties.sampleRate;
     if (sourceRate === DFN3_SAMPLE_RATE) {
       return super._setup(input, context);
@@ -37719,10 +37772,10 @@ var _DeepFilterNet3Node = class _DeepFilterNet3Node extends TransformNode {
     return new _DeepFilterNet3Node({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_DeepFilterNet3Node.moduleName = "DeepFilterNet3 (Denoiser)";
+_DeepFilterNet3Node.nodeName = "DeepFilterNet3 (Denoiser)";
 _DeepFilterNet3Node.packageName = PACKAGE_NAME;
 _DeepFilterNet3Node.packageVersion = PACKAGE_VERSION;
-_DeepFilterNet3Node.moduleDescription = "Remove background noise from speech using DeepFilterNet3 (48 kHz full-band CRN)";
+_DeepFilterNet3Node.nodeDescription = "Remove background noise from speech using DeepFilterNet3 (48 kHz full-band CRN)";
 _DeepFilterNet3Node.schema = schema24;
 var DeepFilterNet3Node = _DeepFilterNet3Node;
 function deepFilterNet3(options) {
@@ -37791,11 +37844,6 @@ var DtlnBlockStream = class {
     };
     this.stftOutput = { real: this.stftRealScratch, imag: this.stftImagScratch };
   }
-  /**
-   * Feed `BLOCK_SHIFT` samples; return `BLOCK_SHIFT` samples of output (from the
-   * stable left edge of the OLA accumulator). The first `WARMUP_SHIFTS` calls
-   * return zeros (the sliding window is not yet full of real samples).
-   */
   step(inputBlock) {
     if (inputBlock.length !== BLOCK_SHIFT) {
       throw new Error(`DtlnBlockStream.step: expected ${String(BLOCK_SHIFT)} samples, got ${String(inputBlock.length)}`);
@@ -37817,11 +37865,6 @@ var DtlnBlockStream = class {
     this.olaScratch.fill(0, BLOCK_LEN - BLOCK_SHIFT, BLOCK_LEN);
     return out;
   }
-  /**
-   * Drain the OLA accumulator's remaining stable samples
-   * (`BLOCK_LEN - BLOCK_SHIFT = 384` samples). After this, the stream's state
-   * is exhausted but no new inference has run.
-   */
   flush() {
     const remaining = BLOCK_LEN - BLOCK_SHIFT;
     const out = new Float32Array(remaining);
@@ -37872,15 +37915,15 @@ var schema25 = external_exports.object({
   fftwAddonPath: external_exports.string().default("").meta({ input: "file", mode: "open", binary: "fftw-addon", download: "https://github.com/visionsofparadise/fftw-addon" }).describe("FFTW native addon \u2014 CPU FFT acceleration")
 });
 var DTLN_SAMPLE_RATE = 16e3;
-var CHUNK_FRAMES8 = 16e3;
+var CHUNK_FRAMES5 = 16e3;
 var RESAMPLE_DRAIN_CHUNK = 16384;
 var STEP_BATCH_SIZE = 16e3;
 var WARMUP_SAMPLES = WARMUP_SHIFTS * BLOCK_SHIFT;
 var DtlnStream = 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 });
+    this.session1 = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath1, { executionProviders: onnxProviders }, (message, data) => this.log(message, data));
+    this.session2 = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath2, { executionProviders: onnxProviders }, (message, data) => this.log(message, data));
     const cpuProviders = context.executionProviders.filter((ep) => ep !== "gpu");
     const fft2 = initFftBackend(cpuProviders.length > 0 ? cpuProviders : ["cpu"], this.properties);
     this.fftBackend = fft2.backend;
@@ -37924,11 +37967,11 @@ var DtlnStream = class extends BufferedTransformStream {
       await buffer.clear();
       await output.reset();
       for (; ; ) {
-        const chunk = await output.read(CHUNK_FRAMES8);
+        const chunk = await output.read(CHUNK_FRAMES5);
         const got = chunk.samples[0]?.length ?? 0;
         if (got === 0) break;
         await buffer.write(chunk.samples, sourceRate, bitDepth);
-        if (got < CHUNK_FRAMES8) break;
+        if (got < CHUNK_FRAMES5) break;
       }
     } finally {
       if (pair) {
@@ -37952,10 +37995,10 @@ var DtlnStream = class extends BufferedTransformStream {
     let samplesFed = 0;
     let warmupRemaining = WARMUP_SAMPLES;
     const writerState = { written: 0 };
-    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES8 }) : Promise.resolve();
+    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES5 }) : Promise.resolve();
     const drainerDone = pair !== void 0 ? drainResampleOutToBuffer({ resampleOut: pair.resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState }) : Promise.resolve();
     for (; ; ) {
-      const got16k = await pullNextChunkAt16k({ buffer, pair, channels, frames: CHUNK_FRAMES8 });
+      const got16k = await pullNextChunkAt16k({ buffer, pair, channels, frames: CHUNK_FRAMES5 });
       if (got16k === void 0) break;
       const firstChannel = got16k[0];
       const chunkFrames = firstChannel?.length ?? 0;
@@ -38168,10 +38211,10 @@ var _DtlnNode = class _DtlnNode extends TransformNode {
     return new _DtlnNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_DtlnNode.moduleName = "DTLN (Denoiser)";
+_DtlnNode.nodeName = "DTLN (Denoiser)";
 _DtlnNode.packageName = PACKAGE_NAME;
 _DtlnNode.packageVersion = PACKAGE_VERSION;
-_DtlnNode.moduleDescription = "Remove background noise from speech using DTLN neural network";
+_DtlnNode.nodeDescription = "Remove background noise from speech using DTLN neural network";
 _DtlnNode.schema = schema25;
 var DtlnNode = _DtlnNode;
 function dtln(options) {
@@ -38315,12 +38358,12 @@ var HOP_SIZE2 = 1024;
 var SEGMENT_SAMPLES = 343980;
 var OVERLAP = 0.25;
 var TRANSITION_POWER = 1;
-var CHUNK_FRAMES9 = 44100;
+var CHUNK_FRAMES6 = 44100;
 var RESAMPLE_DRAIN_CHUNK2 = 16384;
 var STEM_OUTPUTS = 4 * 2;
 var HtdemucsStream = class extends BufferedTransformStream {
   async _setup(input, context) {
-    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: ["cpu"] });
+    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: ["cpu"] }, (message, data) => this.log(message, data));
     return super._setup(input, context);
   }
   async _process(buffer) {
@@ -38362,11 +38405,11 @@ var HtdemucsStream = class extends BufferedTransformStream {
       await buffer.clear();
       await output.reset();
       for (; ; ) {
-        const chunk = await output.read(CHUNK_FRAMES9);
+        const chunk = await output.read(CHUNK_FRAMES6);
         const got = chunk.samples[0]?.length ?? 0;
         if (got === 0) break;
         await buffer.write(chunk.samples, sourceRate, bitDepth);
-        if (got < CHUNK_FRAMES9) break;
+        if (got < CHUNK_FRAMES6) break;
       }
     } finally {
       if (pair) {
@@ -38379,7 +38422,7 @@ var HtdemucsStream = class extends BufferedTransformStream {
     const { buffer, output, channels, originalFrames, sourceRate, bitDepth, stats, pair } = args;
     const stride = Math.round((1 - OVERLAP) * SEGMENT_SAMPLES);
     const writerState = { written: 0 };
-    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn2({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES9 }) : Promise.resolve();
+    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn2({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES6 }) : Promise.resolve();
     const drainerDone = pair !== void 0 ? drainResampleOutToBuffer2({ resampleOut: pair.resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState }) : Promise.resolve();
     const weight = new Float32Array(SEGMENT_SAMPLES);
     const half = SEGMENT_SAMPLES / 2;
@@ -38425,7 +38468,7 @@ var HtdemucsStream = class extends BufferedTransformStream {
       if (!inputExhausted) {
         while (segFilled < SEGMENT_SAMPLES) {
           const need = SEGMENT_SAMPLES - segFilled;
-          const got = await pullNextChunkAt441({ buffer, pair, channels, frames: Math.min(need, CHUNK_FRAMES9) });
+          const got = await pullNextChunkAt441({ buffer, pair, channels, frames: Math.min(need, CHUNK_FRAMES6) });
           if (got === void 0 || got[0].length === 0) {
             inputExhausted = true;
             break;
@@ -38540,7 +38583,7 @@ async function computeStreamingStats(buffer, channels) {
   let sum = 0;
   let count = 0;
   for (; ; ) {
-    const chunk = await buffer.read(CHUNK_FRAMES9);
+    const chunk = await buffer.read(CHUNK_FRAMES6);
     const frames = chunk.samples[0]?.length ?? 0;
     if (frames === 0) break;
     const left = chunk.samples[0];
@@ -38553,14 +38596,14 @@ async function computeStreamingStats(buffer, channels) {
       for (let index = 0; index < frames; index++) sum += right[index] ?? 0;
       count += frames;
     }
-    if (frames < CHUNK_FRAMES9) break;
+    if (frames < CHUNK_FRAMES6) break;
   }
   const mean = count > 0 ? sum / count : 0;
   await buffer.reset();
   let variance = 0;
   let varCount = 0;
   for (; ; ) {
-    const chunk = await buffer.read(CHUNK_FRAMES9);
+    const chunk = await buffer.read(CHUNK_FRAMES6);
     const frames = chunk.samples[0]?.length ?? 0;
     if (frames === 0) break;
     const left = chunk.samples[0];
@@ -38579,7 +38622,7 @@ async function computeStreamingStats(buffer, channels) {
       }
       varCount += frames;
     }
-    if (frames < CHUNK_FRAMES9) break;
+    if (frames < CHUNK_FRAMES6) break;
   }
   const std = varCount > 0 ? Math.sqrt(variance / varCount) || 1 : 1;
   return { mean, std };
@@ -38671,10 +38714,10 @@ var _HtdemucsNode = class _HtdemucsNode extends TransformNode {
     return new _HtdemucsNode({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_HtdemucsNode.moduleName = "HTDemucs (Stem Separator)";
+_HtdemucsNode.nodeName = "HTDemucs (Stem Separator)";
 _HtdemucsNode.packageName = PACKAGE_NAME;
 _HtdemucsNode.packageVersion = PACKAGE_VERSION;
-_HtdemucsNode.moduleDescription = "Rebalance stem volumes using HTDemucs source separation";
+_HtdemucsNode.nodeDescription = "Rebalance stem volumes using HTDemucs source separation";
 _HtdemucsNode.schema = schema26;
 var HtdemucsNode = _HtdemucsNode;
 function htdemucs(modelPath, stems, options) {
@@ -38830,7 +38873,7 @@ var COMPENSATE = 1.009;
 var SEGMENT_SAMPLES2 = N_FFT2 + (DIM_T3 - 1) * HOP_SIZE4;
 var OVERLAP2 = 0.25;
 var TRANSITION_POWER2 = 1;
-var CHUNK_FRAMES10 = 44100;
+var CHUNK_FRAMES7 = 44100;
 var RESAMPLE_DRAIN_CHUNK3 = 16384;
 var KimVocal2Stream = class extends BufferedTransformStream {
   constructor(properties) {
@@ -38838,7 +38881,7 @@ var KimVocal2Stream = class extends BufferedTransformStream {
     this.fftInstance = new MixedRadixFft(N_FFT2);
   }
   async _setup(input, context) {
-    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: filterOnnxProviders(context.executionProviders) });
+    this.session = createOnnxSession(this.properties.onnxAddonPath, this.properties.modelPath, { executionProviders: filterOnnxProviders(context.executionProviders) }, (message, data) => this.log(message, data));
     return super._setup(input, context);
   }
   async _process(buffer) {
@@ -38878,11 +38921,11 @@ var KimVocal2Stream = class extends BufferedTransformStream {
       await buffer.clear();
       await output.reset();
       for (; ; ) {
-        const chunk = await output.read(CHUNK_FRAMES10);
+        const chunk = await output.read(CHUNK_FRAMES7);
         const got = chunk.samples[0]?.length ?? 0;
         if (got === 0) break;
         await buffer.write(chunk.samples, sourceRate, bitDepth);
-        if (got < CHUNK_FRAMES10) break;
+        if (got < CHUNK_FRAMES7) break;
       }
     } finally {
       if (pair) {
@@ -38896,7 +38939,7 @@ var KimVocal2Stream = class extends BufferedTransformStream {
     const stride = Math.round((1 - OVERLAP2) * SEGMENT_SAMPLES2);
     const isMono = channels < 2;
     const writerState = { written: 0 };
-    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn3({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES10 }) : Promise.resolve();
+    const pumpDone = pair !== void 0 ? pumpSourceToResampleIn3({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES7 }) : Promise.resolve();
     const drainerDone = pair !== void 0 ? drainResampleOutToBuffer3({ resampleOut: pair.resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState }) : Promise.resolve();
     const weight = buildTransitionWindow(SEGMENT_SAMPLES2, TRANSITION_POWER2);
     const workspace = createSegmentWorkspace(SEGMENT_SAMPLES2);
@@ -38911,7 +38954,7 @@ var KimVocal2Stream = class extends BufferedTransformStream {
       if (!inputExhausted) {
         while (segFilled < SEGMENT_SAMPLES2) {
           const need = SEGMENT_SAMPLES2 - segFilled;
-          const got = await pullNextChunkAt4412({ buffer, pair, channels, frames: Math.min(need, CHUNK_FRAMES10) });
+          const got = await pullNextChunkAt4412({ buffer, pair, channels, frames: Math.min(need, CHUNK_FRAMES7) });
           if (got === void 0 || got[0].length === 0) {
             inputExhausted = true;
             break;
@@ -39087,10 +39130,10 @@ var _KimVocal2Node = class _KimVocal2Node extends TransformNode {
     return new _KimVocal2Node({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_KimVocal2Node.moduleName = "Kim Vocal 2 (Stem Separator)";
+_KimVocal2Node.nodeName = "Kim Vocal 2 (Stem Separator)";
 _KimVocal2Node.packageName = PACKAGE_NAME;
 _KimVocal2Node.packageVersion = PACKAGE_VERSION;
-_KimVocal2Node.moduleDescription = "Isolate dialogue from background using MDX-Net vocal separation";
+_KimVocal2Node.nodeDescription = "Isolate dialogue from background using MDX-Net vocal separation";
 _KimVocal2Node.schema = schema27;
 var KimVocal2Node = _KimVocal2Node;
 function kimVocal2(options) {
@@ -39103,9 +39146,17 @@ function kimVocal2(options) {
     id: options.id
   });
 }
-var CHUNK_FRAMES11 = 48e3;
+var CHUNK_FRAMES8 = 48e3;
 var READY_LINE = "READY\n";
 var READY_TIMEOUT_MS = 3e5;
+var VstHostExitedBeforeReadyError = class extends Error {
+  constructor(code, stderr) {
+    super(`vst-host exited before READY (code ${code ?? "null"}): ${stderr}`);
+    this.name = "VstHostExitedBeforeReadyError";
+    this.code = code;
+    this.stderr = stderr;
+  }
+};
 function spawnVstHost(binaryPath, args) {
   const proc = spawn(binaryPath, [...args], {
     stdio: ["pipe", "pipe", "pipe"]
@@ -39151,7 +39202,7 @@ function spawnVstHost(binaryPath, args) {
     };
     const onClose = (code) => {
       const stderrOutput = Buffer.concat(stderrChunks).toString();
-      fail(new Error(`vst-host exited before READY (code ${code ?? "null"}): ${stderrOutput}`));
+      fail(new VstHostExitedBeforeReadyError(code, stderrOutput));
     };
     const timer = setTimeout(() => {
       fail(new Error(`vst-host did not emit READY within ${READY_TIMEOUT_MS}ms`));
@@ -39164,6 +39215,28 @@ function spawnVstHost(binaryPath, args) {
   });
   return { proc, stdin, stdout, stderr, ready, stderrChunks };
 }
+var CLEAN_WRAPPER_EXIT_CODES = /* @__PURE__ */ new Set([0, 1, 2]);
+function isRetryableInitCrash(error50) {
+  return error50 instanceof VstHostExitedBeforeReadyError && !CLEAN_WRAPPER_EXIT_CODES.has(error50.code ?? -1);
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function spawnVstHostReady(binaryPath, args, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 5;
+  const backoffMs = options.backoffMs ?? 750;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const handle = spawnVstHost(binaryPath, args);
+    try {
+      await handle.ready;
+      return handle;
+    } catch (error50) {
+      handle.proc.kill();
+      if (attempt >= maxAttempts || !isRetryableInitCrash(error50)) throw error50;
+      options.onRetry?.(attempt, error50);
+      await delay(backoffMs);
+    }
+  }
+  throw new Error(`spawnVstHostReady: exhausted ${maxAttempts} attempts without a result`);
+}
 async function writeStagesJson(stages) {
   const dir = await mkdtemp(join(tmpdir(), "vst-host-stages-"));
   const path2 = join(dir, "stages.json");
@@ -39186,7 +39259,7 @@ async function processStreamingThroughVstHost(handle, buffer, channelCount, samp
   });
   await buffer.reset();
   for (; ; ) {
-    const chunk = await buffer.read(CHUNK_FRAMES11);
+    const chunk = await buffer.read(CHUNK_FRAMES8);
     const chunkFrames = chunk.samples[0]?.length ?? 0;
     if (chunkFrames === 0) break;
     const channelArrays = [];
@@ -39199,7 +39272,7 @@ async function processStreamingThroughVstHost(handle, buffer, channelCount, samp
     if (!canWrite) {
       await waitForDrain(handle.proc, handle.stdin);
     }
-    if (chunkFrames < CHUNK_FRAMES11) break;
+    if (chunkFrames < CHUNK_FRAMES8) break;
   }
   handle.stdin.end();
   await buffer.reset();
@@ -39247,8 +39320,7 @@ async function processStreamingThroughVstHost(handle, buffer, channelCount, samp
 var stageSchema = external_exports.object({
   pluginPath: external_exports.string().meta({ input: "file", mode: "open", accept: ".vst3" }).describe("VST3 plugin file or bundle"),
   pluginName: external_exports.string().optional().describe("Sub-plugin name when pluginPath is a multi-plugin shell (e.g. WaveShell)"),
-  presetPath: external_exports.string().optional().meta({ input: "file", mode: "open", accept: ".vstpreset" }).describe("Optional .vstpreset state file applied after the plugin loads"),
-  parameters: external_exports.record(external_exports.string(), external_exports.union([external_exports.number(), external_exports.string(), external_exports.boolean()])).optional().describe("Optional parameter overrides applied after presetPath. Keys map to Pedalboard parameter names exposed by the plugin.")
+  presetPath: external_exports.string().optional().meta({ input: "file", mode: "open", accept: ".vstpreset" }).describe("Optional .vstpreset state file applied after the plugin loads")
 });
 var schema28 = external_exports.object({
   vstHostPath: external_exports.string().default("").meta({ input: "file", mode: "open", binary: "vst-host", download: "https://github.com/visionsofparadise/vst-host" }).describe("vst-host \u2014 Pedalboard-based VST3 host CLI"),
@@ -39283,13 +39355,11 @@ var Vst3Stream = class extends BufferedTransformStream {
       "--channels",
       String(channels)
     ];
-    const handle = spawnVstHost(this.properties.vstHostPath, args);
-    try {
-      await handle.ready;
-    } catch (error50) {
-      handle.proc.kill();
-      throw error50;
-    }
+    const handle = await spawnVstHostReady(this.properties.vstHostPath, args, {
+      onRetry: (failedAttempt, error50) => {
+        this.log("vst-host init crash, retrying", { attempt: failedAttempt, error: error50.message }, "warn");
+      }
+    });
     await processStreamingThroughVstHost(handle, buffer, channels, sampleRate, bd);
   }
   async _teardown() {
@@ -39323,10 +39393,10 @@ var _Vst3Node = class _Vst3Node extends TransformNode {
     return new _Vst3Node({ ...this.properties, previousProperties: this.properties, ...overrides });
   }
 };
-_Vst3Node.moduleName = "VST3";
+_Vst3Node.nodeName = "VST3";
 _Vst3Node.packageName = PACKAGE_NAME;
 _Vst3Node.packageVersion = PACKAGE_VERSION;
-_Vst3Node.moduleDescription = "Host a chain of VST3 effect plugins via Pedalboard (whole-file offline mode)";
+_Vst3Node.nodeDescription = "Host a chain of VST3 effect plugins via Pedalboard (whole-file offline mode)";
 _Vst3Node.schema = schema28;
 var Vst3Node = _Vst3Node;
 function vst3(options) {