@buffered-audio/nodes 0.16.0 → 0.17.0

package/dist/index.d.ts

@@ -27,10 +27,10 @@ declare class ReadFfmpegStream<P extends ReadFfmpegProperties = ReadFfmpegProper
     private readBytes;
 }
 declare class ReadFfmpegNode extends SourceNode<ReadFfmpegProperties> {
-    static readonly moduleName = "Read FFmpeg";
+    static readonly nodeName = "Read FFmpeg";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Read audio from a file using FFmpeg";
+    static readonly nodeDescription = "Read audio from a file using FFmpeg";
     static readonly schema: z.ZodObject<{
         path: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -66,10 +66,10 @@ declare class ReadWavStream<P extends ReadWavProperties = ReadWavProperties> ext
     _teardown(): void;
 }
 declare class ReadWavNode extends SourceNode<ReadWavProperties> {
-    static readonly moduleName = "Read WAV";
+    static readonly nodeName = "Read WAV";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Read audio from a WAV file";
+    static readonly nodeDescription = "Read audio from a WAV file";
     static readonly schema: z.ZodObject<{
         path: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
@@ -90,10 +90,10 @@ interface ReadProperties extends z.infer<typeof schema$m>, SourceNodeProperties
     readonly channels?: ReadonlyArray<number>;
 }
 declare class ReadNode extends SourceNode<ReadProperties> {
-    static readonly moduleName = "Read";
+    static readonly nodeName = "Read";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Read audio from a file";
+    static readonly nodeDescription = "Read audio from a file";
     static readonly schema: z.ZodObject<{
         path: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -144,10 +144,10 @@ declare class LoudnessStatsStream extends BufferedTargetStream<LoudnessStatsProp
     _close(): Promise<void>;
 }
 declare class LoudnessStatsNode extends TargetNode<LoudnessStatsProperties> {
-    static readonly moduleName = "Loudness Stats";
+    static readonly nodeName = "Loudness Stats";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Measure integrated loudness, true peak, and loudness range per EBU R128, plus an amplitude-distribution histogram";
+    static readonly nodeDescription = "Measure integrated loudness, true peak, and loudness range per EBU R128, plus an amplitude-distribution histogram";
     static readonly schema: z.ZodObject<{
         bucketCount: z.ZodDefault<z.ZodNumber>;
         outputPath: z.ZodDefault<z.ZodString>;
@@ -209,10 +209,10 @@ declare class SpectrogramStream extends BufferedTargetStream<SpectrogramProperti
     private flushWriteBuffer;
 }
 declare class SpectrogramNode extends TargetNode<SpectrogramProperties> {
-    static readonly moduleName = "Spectrogram";
+    static readonly nodeName = "Spectrogram";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Generate spectrogram visualization data";
+    static readonly nodeDescription = "Generate spectrogram visualization data";
     static readonly schema: z.ZodObject<{
         outputPath: z.ZodDefault<z.ZodString>;
         fftSize: z.ZodDefault<z.ZodNumber>;
@@ -264,10 +264,10 @@ declare class WaveformStream extends BufferedTargetStream<WaveformProperties> {
     private flushWriteBuffer;
 }
 declare class WaveformNode extends TargetNode<WaveformProperties> {
-    static readonly moduleName = "Waveform";
+    static readonly nodeName = "Waveform";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Generate waveform visualization data";
+    static readonly nodeDescription = "Generate waveform visualization data";
     static readonly schema: z.ZodObject<{
         outputPath: z.ZodDefault<z.ZodString>;
         resolution: z.ZodDefault<z.ZodNumber>;
@@ -316,10 +316,10 @@ declare class WriteStream extends BufferedTargetStream<WriteProperties> {
     private writeToStdin;
 }
 declare class WriteNode extends TargetNode<WriteProperties> {
-    static readonly moduleName = "Write";
+    static readonly nodeName = "Write";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Write audio to a file";
+    static readonly nodeDescription = "Write audio to a file";
     static readonly schema: z.ZodObject<{
         path: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -371,10 +371,10 @@ declare class CutStream extends BufferedTransformStream<CutProperties> {
     _unbuffer(chunk: AudioChunk): AudioChunk | undefined;
 }
 declare class CutNode extends TransformNode<CutProperties> {
-    static readonly moduleName = "Cut";
+    static readonly nodeName = "Cut";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Remove a region of audio";
+    static readonly nodeDescription = "Remove a region of audio";
     static readonly schema: z.ZodObject<{
         regions: z.ZodDefault<z.ZodArray<z.ZodObject<{
             start: z.ZodNumber;
@@ -402,10 +402,10 @@ declare class DitherStream extends BufferedTransformStream<DitherProperties> {
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class DitherNode extends TransformNode<DitherProperties> {
-    static readonly moduleName = "Dither";
+    static readonly nodeName = "Dither";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Add shaped noise to reduce quantization distortion";
+    static readonly nodeDescription = "Add shaped noise to reduce quantization distortion";
     static readonly schema: z.ZodObject<{
         bitDepth: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<16>, z.ZodLiteral<24>]>>;
         noiseShaping: z.ZodDefault<z.ZodBoolean>;
@@ -433,10 +433,10 @@ declare class NormalizeStream extends BufferedTransformStream<NormalizePropertie
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class NormalizeNode extends TransformNode<NormalizeProperties> {
-    static readonly moduleName = "Normalize";
+    static readonly nodeName = "Normalize";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Adjust peak or loudness level to a target ceiling";
+    static readonly nodeDescription = "Adjust peak or loudness level to a target ceiling";
     static readonly schema: z.ZodObject<{
         ceiling: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
@@ -458,13 +458,19 @@ declare const schema$f: z.ZodObject<{
 interface PadProperties extends z.infer<typeof schema$f>, TransformNodeProperties {
 }
 declare class PadStream extends BufferedTransformStream<PadProperties> {
-    _process(buffer: ChunkBuffer): Promise<void>;
+    private seenChunk;
+    private capturedSampleRate;
+    private capturedBitDepth;
+    private capturedChannels;
+    private outputOffset;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+    _flush(): Array<AudioChunk> | undefined;
 }
 declare class PadNode extends TransformNode<PadProperties> {
-    static readonly moduleName = "Pad";
+    static readonly nodeName = "Pad";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Add silence to start or end of audio";
+    static readonly nodeDescription = "Add silence to start or end of audio";
     static readonly schema: z.ZodObject<{
         before: z.ZodDefault<z.ZodNumber>;
         after: z.ZodDefault<z.ZodNumber>;
@@ -494,10 +500,10 @@ declare class PhaseStream extends BufferedTransformStream<PhaseProperties> {
     private applyPhaseRotation;
 }
 declare class PhaseNode extends TransformNode<PhaseProperties> {
-    static readonly moduleName = "Phase";
+    static readonly nodeName = "Phase";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Invert or rotate signal phase";
+    static readonly nodeDescription = "Invert or rotate signal phase";
     static readonly schema: z.ZodObject<{
         invert: z.ZodDefault<z.ZodBoolean>;
         angle: z.ZodOptional<z.ZodNumber>;
@@ -520,10 +526,10 @@ declare class ReverseStream extends BufferedTransformStream {
     _process(buffer: ChunkBuffer): Promise<void>;
 }
 declare class ReverseNode extends TransformNode {
-    static readonly moduleName = "Reverse";
+    static readonly nodeName = "Reverse";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Reverse audio playback direction";
+    static readonly nodeDescription = "Reverse audio playback direction";
     static readonly schema: z.ZodObject<{}, z.core.$strip>;
     static is(value: unknown): value is ReverseNode;
     readonly type: readonly ["buffered-audio-node", "transform", "reverse"];
@@ -551,10 +557,10 @@ declare class SpliceStream extends BufferedTransformStream<SpliceProperties> {
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class SpliceNode extends TransformNode<SpliceProperties> {
-    static readonly moduleName = "Splice";
+    static readonly nodeName = "Splice";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Replace a region of audio with processed content";
+    static readonly nodeDescription = "Replace a region of audio with processed content";
     static readonly schema: z.ZodObject<{
         insertPath: z.ZodDefault<z.ZodString>;
         insertAt: z.ZodDefault<z.ZodNumber>;
@@ -577,13 +583,20 @@ declare const schema$c: z.ZodObject<{
 interface TrimProperties extends z.infer<typeof schema$c>, TransformNodeProperties {
 }
 declare class TrimStream extends BufferedTransformStream<TrimProperties> {
+    private firstAbove;
+    private lastAbove;
+    private scanOffset;
+    private startFrame;
+    private endFrame;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
     _process(buffer: ChunkBuffer): Promise<void>;
+    _unbuffer(chunk: AudioChunk): AudioChunk | undefined;
 }
 declare class TrimNode extends TransformNode<TrimProperties> {
-    static readonly moduleName = "Trim";
+    static readonly nodeName = "Trim";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Remove silence from start and end";
+    static readonly nodeDescription = "Remove silence from start and end";
     static readonly schema: z.ZodObject<{
         threshold: z.ZodDefault<z.ZodNumber>;
         margin: z.ZodDefault<z.ZodNumber>;
@@ -604,17 +617,14 @@ declare function trim(options?: {
     id?: string;
 }): TrimNode;
 
-/**
- * Downmix N channels to 1 by averaging all channels equally.
- */
 declare class DownmixMonoStream extends BufferedTransformStream {
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class DownmixMonoNode extends TransformNode {
-    static readonly moduleName = "Downmix Mono";
+    static readonly nodeName = "Downmix Mono";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Mix all input channels to a single mono channel by averaging";
+    static readonly nodeDescription = "Mix all input channels to a single mono channel by averaging";
     static readonly schema: z.ZodObject<{}, z.core.$strip>;
     static is(value: unknown): value is DownmixMonoNode;
     readonly type: readonly ["buffered-audio-node", "transform", "downmix-mono"];
@@ -630,18 +640,14 @@ declare const schema$b: z.ZodObject<{
 }, z.core.$strip>;
 interface DuplicateChannelsProperties extends z.infer<typeof schema$b>, TransformNodeProperties {
 }
-/**
- * Duplicate a single mono channel into N identical output channels.
- * Requires exactly 1 input channel; throws for any other channel count.
- */
 declare class DuplicateChannelsStream extends BufferedTransformStream<DuplicateChannelsProperties> {
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class DuplicateChannelsNode extends TransformNode<DuplicateChannelsProperties> {
-    static readonly moduleName = "Duplicate Channels";
+    static readonly nodeName = "Duplicate Channels";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Duplicate a mono signal into multiple identical output channels";
+    static readonly nodeDescription = "Duplicate a mono signal into multiple identical output channels; requires exactly 1 input channel, throws otherwise";
     static readonly schema: z.ZodObject<{
         channels: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
@@ -664,10 +670,10 @@ declare class GainStream extends BufferedTransformStream<GainProperties> {
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class GainNode extends TransformNode<GainProperties> {
-    static readonly moduleName = "Gain";
+    static readonly nodeName = "Gain";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Adjust signal level by a fixed amount in dB";
+    static readonly nodeDescription = "Adjust signal level by a fixed amount in dB";
     static readonly schema: z.ZodObject<{
         gain: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
@@ -686,22 +692,14 @@ declare const schema$9: z.ZodObject<{
 }, z.core.$strip>;
 interface PanProperties extends z.infer<typeof schema$9>, TransformNodeProperties {
 }
-/**
- * Pan transform.
- * - Mono input (1 ch): equal-power pan to stereo.
- * - Stereo input (2 ch): balance (pan shifts gain between existing L/R).
- * - More than 2 channels: throws (unsupported).
- *
- * Equal-power law: L = cos(θ), R = sin(θ), where θ = (pan + 1) / 2 * π/2.
- */
 declare class PanStream extends BufferedTransformStream<PanProperties> {
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class PanNode extends TransformNode<PanProperties> {
-    static readonly moduleName = "Pan";
+    static readonly nodeName = "Pan";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Position mono signal in stereo field or adjust stereo balance";
+    static readonly nodeDescription = "Position mono signal in stereo field or adjust stereo balance; throws for inputs with more than 2 channels";
     static readonly schema: z.ZodObject<{
         pan: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
@@ -744,10 +742,10 @@ declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extend
     _teardown(): Promise<void>;
 }
 declare class FfmpegNode<P extends FfmpegProperties = FfmpegProperties> extends TransformNode<P> {
-    static readonly moduleName: string;
+    static readonly nodeName: string;
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription: string;
+    static readonly nodeDescription: string;
     static readonly schema: z.ZodType;
     static is(value: unknown): value is FfmpegNode;
     readonly type: ReadonlyArray<string>;
@@ -762,56 +760,6 @@ declare function ffmpeg(options: {
     id?: string;
 }): FfmpegNode;
 
-/**
- * Schema for the loudnessTarget node.
- *
- * Fits a source to a `(LUFS, true-peak)` target pair via a single
- * level-indexed gain curve with a peak-respecting smoothed gain
- * envelope. The curve carries an upper-arm peak anchor that gives
- * structural control over `targetTp` in the same envelope that lands
- * LUFS. See design-loudness-target §"Parameters" for the parameter
- * rationale and §"Two-pass node structure" for the stream structure.
- *
- * `pivot` is optional; when undefined the node derives it from
- * `median(considered LRA blocks)` (BS.1770 / EBU R128 two-stage gate)
- * on the pass-1 measurement — see design-loudness-target §"Pivot
- * semantic — lower bound of the gain-riding zone". `floor` is
- * optional; when undefined the curve has no pass-through region and
- * applies uniform body gain B below pivot. The `.refine()` enforces
- * `floor < pivot` only when both are set; per-field `.lt(0)` still
- * constrains each to dB < 0 when supplied.
- *
- * Iteration is 2D joint on `(B, peakGainDb)`. `limitDb` is set ONCE
- * from the measurement (or an explicit override) and is constant across
- * attempts. Initial `B` is seeded by a histogram-based LUFS predictor
- * (per `plan-loudness-target-deterministic` 2026-05-13 revert) so
- * attempt 1 lands close to target and the secant converges in fewer
- * attempts. Initial `peakGainDb` is the closed-form `effectiveTargetTp
- * − limitDb`; per-attempt proportional feedback on TP overshoot moves
- * it from there. LRA falls out as a consequence of the resulting
- * geometry — there is no LRA target axis.
- *
- * `targetTp` is the do-no-harm-default peak axis:
- *   - `targetTp` undefined → `effectiveTargetTp = sourcePeakDb` and
- *     `peakGainDb` collapses to 0; peaks track body lift unchanged.
- *
- * `limitDb` is the limit-anchor override. Default behaviour:
- *   - unset → top-down percentile walk over the source's 4×-rate
- *     detection-envelope histogram (`measureSource`'s `limitAutoDb`),
- *     parameterised by `limitPercentile`.
- *   - set → fix the limit anchor at this value (clamped to the per-
- *     source feasible window inside the iterator).
- *
- * `limitPercentile` selects the brick-wall threshold's statistical
- * quantile on the detection histogram: with default `0.995` the top
- * 0.5 % of detection samples sit above `limitAutoDb` and brick-wall at
- * the target ceiling. Higher values → less limiting (tighter quantile);
- * lower values → more aggressive limiting.
- *
- * `smoothing` is the peak-respecting envelope time constant in ms;
- * collapses `K = W` window-half-width and bidirectional IIR time
- * constant into one user parameter.
- */
 declare const schema$8: z.ZodObject<{
     targetLufs: z.ZodDefault<z.ZodNumber>;
     pivot: z.ZodOptional<z.ZodNumber>;
@@ -827,79 +775,29 @@ declare const schema$8: z.ZodObject<{
 interface LoudnessTargetProperties extends z.infer<typeof schema$8>, TransformNodeProperties {
 }
 declare class LoudnessTargetStream extends BufferedTransformStream<LoudnessTargetProperties> {
-    /**
-     * 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).
-     */
     private winningSmoothedEnvelopeBuffer;
-    /**
-     * 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.
-     */
     private winningB;
-    /**
-     * 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.
-     */
     private winningLimitDb;
-    /**
-     * `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.
-     */
     private winningPeakGainDb;
-    /**
-     * 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.
-     */
     private unbufferCursorsReady;
-    /**
-     * 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.
-     */
+    private measurementAccumulator?;
+    private capturedDetectionEnvelope;
     unbufferElapsedMs: number;
-    /**
-     * 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`.
-     */
     learnTimingMs: {
         sourceMeasurement: number;
         detection: number;
         iteration: number;
     };
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
     _process(buffer: ChunkBuffer): Promise<void>;
     _teardown(): Promise<void>;
     _unbuffer(chunk: AudioChunk): Promise<AudioChunk>;
 }
 declare class LoudnessTargetNode extends TransformNode<LoudnessTargetProperties> {
-    static readonly moduleName = "Loudness Target";
+    static readonly nodeName = "Loudness Target";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly 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.";
+    static readonly 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.";
     static readonly schema: z.ZodObject<{
         targetLufs: z.ZodDefault<z.ZodNumber>;
         pivot: z.ZodOptional<z.ZodNumber>;
@@ -939,14 +837,16 @@ interface LoudnessNormalizeProperties extends z.infer<typeof schema$7>, Transfor
 }
 declare class LoudnessNormalizeStream extends BufferedTransformStream<LoudnessNormalizeProperties> {
     private gain;
-    _process(buffer: ChunkBuffer): Promise<void>;
+    private accumulator?;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
+    _process(_buffer: ChunkBuffer): void;
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class LoudnessNormalizeNode extends TransformNode<LoudnessNormalizeProperties> {
-    static readonly moduleName = "Loudness Normalize";
+    static readonly nodeName = "Loudness Normalize";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Measure integrated loudness (BS.1770) and apply a single linear gain to hit a target LUFS \u2014 no limiting, no dynamics";
+    static readonly nodeDescription = "Measure integrated loudness (BS.1770) and apply a single linear gain to hit a target LUFS \u2014 no limiting, no dynamics";
     static readonly schema: z.ZodObject<{
         target: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
@@ -968,14 +868,16 @@ interface TruePeakNormalizeProperties extends z.infer<typeof schema$6>, Transfor
 }
 declare class TruePeakNormalizeStream extends BufferedTransformStream<TruePeakNormalizeProperties> {
     private gain;
-    _process(buffer: ChunkBuffer): Promise<void>;
+    private accumulator?;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
+    _process(_buffer: ChunkBuffer): void;
     _unbuffer(chunk: AudioChunk): AudioChunk;
 }
 declare class TruePeakNormalizeNode extends TransformNode<TruePeakNormalizeProperties> {
-    static readonly moduleName = "True Peak Normalize";
+    static readonly nodeName = "True Peak Normalize";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Measure source true peak (4\u00D7 upsampled, BS.1770-4 style) and apply a single linear gain to hit a target dBTP";
+    static readonly nodeDescription = "Measure source true peak (4\u00D7 upsampled, BS.1770-4 style) and apply a single linear gain to hit a target dBTP";
     static readonly schema: z.ZodObject<{
         target: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
@@ -1001,149 +903,22 @@ interface CrestReduceProperties extends z.infer<typeof schema$5>, TransformNodeP
 declare class CrestReduceStream extends BufferedTransformStream<CrestReduceProperties> {
     private fftBackend?;
     private fftAddonOptions?;
-    /**
-     * 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).
-     */
-    private outputBuffer;
-    /**
-     * 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).
-     */
-    private unbufferCursorReady;
+    private truePeakAccumulator?;
+    private smoothedTrajectory?;
+    private applyOrder;
+    private applyHopSize;
+    private applyState?;
     _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
     private get hopSize();
-    /**
-     * 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.
-     */
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
     _process(buffer: ChunkBuffer): Promise<void>;
-    /**
-     * 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).
-     */
-    _unbuffer(chunk: AudioChunk): Promise<AudioChunk | undefined>;
-    /**
-     * 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.
-     */
-    _teardown(): Promise<void>;
+    _unbuffer(chunk: AudioChunk): AudioChunk | undefined;
 }
 declare class CrestReduceNode extends TransformNode<CrestReduceProperties> {
-    static readonly moduleName = "Crest Reduce";
+    static readonly nodeName = "Crest Reduce";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly 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";
+    static readonly 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";
     static readonly schema: z.ZodObject<{
         smoothing: z.ZodDefault<z.ZodNumber>;
         frameSize: z.ZodDefault<z.ZodNumber>;
@@ -1182,42 +957,6 @@ declare const schema$4: z.ZodObject<{
 }, z.core.$strip>;
 interface DeBleedProperties extends z.infer<typeof schema$4>, TransformNodeProperties {
 }
-/**
- * Adaptive de-bleed node — MEF FDAF Kalman + MWF + Lukin-Todd post-filter.
- *
- * Pipeline per design-de-bleed.md "2026-05-01: Replace stages 1+2 with MEF":
- *
- *   - **Stage 0 (MSAD)**: per-band SNR thresholding to gate Kalman update and
- *     trigger ISP restoration.
- *   - **Stage 1 (FDAF Kalman)**: per-frame frequency-domain Kalman update
- *     on `Ĥ_{m,μ}(ℓ,k)` per (target, reference) pair.
- *   - **Stage 2 (MWF)**: per-frame Wiener gain mask with per-interferer PSD
- *     `Φ̂_{D̂D̂,m} = |D̂_m^total|²` smoothed temporally (β = 0.5 MEF default).
- *   - **Stage 3 (NLM + DFTT)**: Lukin-Todd 2D smoothing of the gain mask.
- *   - **Stage 4 (synthesis)**: iSTFT of the masked target STFT.
- *
- * **IO pattern** (post chunk-buffer-sequential-api refactor): the target
- * `buffer` is treated as read-only during `_process`; a fresh `outputBuffer`
- * is allocated, all processed audio is streamed sequentially into it, then the
- * input buffer is cleared and the output is stream-copied back. The
- * `WindowReader` helper maintains a per-buffer sample-domain scratch that
- * advances in lockstep with the outer chunk loop — replacing the prior
- * offset-based reads against the input buffer. References use the same
- * `WindowReader` pattern, driven in lockstep with the target.
- *
- * **Outer-loop ordering**: all channels processed in lockstep per chunk
- * (option A from the Phase 6 plan). The per-channel algorithmic state
- * (Kalman, MWF PSD, MSAD, ISP) has no cross-channel coupling, so reordering
- * the inherent two nested loops from `for ch: for chunk` to
- * `for chunk: for ch` is a pure refactor with no algorithmic effect. This is
- * required by the new sequential ChunkBuffer API: `outputBuffer.write` stores
- * all channels at each frame position, so we must produce all channels'
- * samples for a given output frame range in one go.
- *
- * **Hard "do not extend" boundary** (Kokkinis): per-interferer PSD is
- * `|D̂^WF|²` from the Kalman bleed estimate ONLY. No PSD envelope of target,
- * no dominant-bin selection, no coherence-based interferer-PSD estimator.
- */
 declare class DeBleedStream extends BufferedTransformStream<DeBleedProperties> {
     private fftBackend?;
     private fftAddonOptions?;
@@ -1228,28 +967,14 @@ declare class DeBleedStream extends BufferedTransformStream<DeBleedProperties> {
     private numBins;
     _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
     _teardown(): Promise<void>;
-    /**
-     * 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`.
-     */
     private warmupSeedsAllChannels;
     _process(buffer: ChunkBuffer): Promise<void>;
 }
 declare class DeBleedNode extends TransformNode<DeBleedProperties> {
-    static readonly moduleName = "De-Bleed Adaptive";
+    static readonly nodeName = "De-Bleed Adaptive";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly 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.";
+    static readonly 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.";
     static readonly schema: z.ZodObject<{
         references: z.ZodDefault<z.ZodArray<z.ZodString>>;
         reductionStrength: z.ZodDefault<z.ZodNumber>;
@@ -1301,10 +1026,10 @@ declare class DeepFilterNet3Stream extends BufferedTransformStream<DeepFilterNet
     _teardown(): void;
 }
 declare class DeepFilterNet3Node extends TransformNode<DeepFilterNet3Properties> {
-    static readonly moduleName = "DeepFilterNet3 (Denoiser)";
+    static readonly nodeName = "DeepFilterNet3 (Denoiser)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Remove background noise from speech using DeepFilterNet3 (48 kHz full-band CRN)";
+    static readonly nodeDescription = "Remove background noise from speech using DeepFilterNet3 (48 kHz full-band CRN)";
     static readonly schema: z.ZodObject<{
         modelPath: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -1347,10 +1072,10 @@ declare class DtlnStream extends BufferedTransformStream<DtlnProperties> {
     private runMainPass;
 }
 declare class DtlnNode extends TransformNode<DtlnProperties> {
-    static readonly moduleName = "DTLN (Denoiser)";
+    static readonly nodeName = "DTLN (Denoiser)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Remove background noise from speech using DTLN neural network";
+    static readonly nodeDescription = "Remove background noise from speech using DTLN neural network";
     static readonly schema: z.ZodObject<{
         modelPath1: z.ZodDefault<z.ZodString>;
         modelPath2: z.ZodDefault<z.ZodString>;
@@ -1399,10 +1124,10 @@ declare class HtdemucsStream extends BufferedTransformStream<HtdemucsProperties>
     private emitStable;
 }
 declare class HtdemucsNode extends TransformNode<HtdemucsProperties> {
-    static readonly moduleName = "HTDemucs (Stem Separator)";
+    static readonly nodeName = "HTDemucs (Stem Separator)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Rebalance stem volumes using HTDemucs source separation";
+    static readonly nodeDescription = "Rebalance stem volumes using HTDemucs source separation";
     static readonly schema: z.ZodObject<{
         modelPath: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -1441,10 +1166,10 @@ declare class KimVocal2Stream extends BufferedTransformStream<KimVocal2Propertie
     private emitStable;
 }
 declare class KimVocal2Node extends TransformNode<KimVocal2Properties> {
-    static readonly moduleName = "Kim Vocal 2 (Stem Separator)";
+    static readonly nodeName = "Kim Vocal 2 (Stem Separator)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription = "Isolate dialogue from background using MDX-Net vocal separation";
+    static readonly nodeDescription = "Isolate dialogue from background using MDX-Net vocal separation";
     static readonly schema: z.ZodObject<{
         modelPath: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -1471,47 +1196,14 @@ interface VstStage {
     readonly pluginPath: string;
     readonly pluginName?: string;
     readonly presetPath?: string;
-    /**
-     * Optional parameter overrides applied after `presetPath` loads. Keys map
-     * to Pedalboard parameter names exposed by the plugin (lowercase / snake-
-     * cased identifiers — see `plugin.parameters` in Pedalboard). Useful for
-     * plugins whose on-disk preset format Pedalboard's `load_preset` rejects
-     * (e.g. Waves XPst inside a VST3 wrapper) but whose parameter surface is
-     * reachable directly.
-     */
-    readonly parameters?: Readonly<Record<string, number | string | boolean>>;
 }
 
 interface Vst3Properties extends TransformNodeProperties {
     readonly vstHostPath: string;
     readonly stages: ReadonlyArray<VstStage>;
     readonly bypass?: boolean;
-    /**
-     * Extra args appended after the canonical CLI args. Test-only; allows the
-     * unit tests to spawn `node <stub.mjs>` by passing `node` as `vstHostPath`
-     * and `[stub.mjs]` here.
-     */
     readonly extraArgs?: ReadonlyArray<string>;
 }
-/**
- * Whole-file VST3 chain stream. The framework drives `_process` exactly once
- * (after the upstream EOF flushes the accumulated buffer at `bufferSize:
- * WHOLE_FILE`). The buffer is streamed through a `vst-host` subprocess that
- * runs Pedalboard's offline mode (`reset=True`) over the configured chain;
- * Pedalboard handles plugin delay compensation internally so the returned
- * audio is sample-aligned with the input — no leading silence, no tail loss.
- *
- * Memory discipline: although `bufferSize: WHOLE_FILE` schedules the
- * `_process` call after EOF, the JS-side memory cost is bounded.
- * `processStreamingThroughVstHost` drains the buffer to subprocess stdin in
- * `CHUNK_FRAMES`-sized chunks, then `clear()`s the buffer (Pedalboard's
- * offline mode has captured the full input internally by then), then drains
- * subprocess stdout chunk-by-chunk back into the SAME buffer. No temp
- * ChunkBuffer, no stream-copy phase. Disk usage stays at 1× source size.
- * The subprocess holds the full interleaved input in its own RAM
- * (Pedalboard's offline-mode constraint), but that's not part of the Node
- * heap.
- */
 declare class Vst3Stream<P extends Vst3Properties = Vst3Properties> extends BufferedTransformStream<P> {
     private streamContext?;
     private stagesJsonPath?;
@@ -1521,10 +1213,10 @@ declare class Vst3Stream<P extends Vst3Properties = Vst3Properties> extends Buff
     _teardown(): Promise<void>;
 }
 declare class Vst3Node<P extends Vst3Properties = Vst3Properties> extends TransformNode<P> {
-    static readonly moduleName: string;
+    static readonly nodeName: string;
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly moduleDescription: string;
+    static readonly nodeDescription: string;
     static readonly schema: z.ZodType;
     static is(value: unknown): value is Vst3Node;
     readonly type: ReadonlyArray<string>;