@buffered-audio/nodes 0.0.0 → 0.15.1

package/dist/index.d.ts

@@ -0,0 +1,1557 @@
+import { z } from 'zod';
+import { SourceNode, SourceNodeProperties, BufferedSourceStream, SourceMetadata, AudioChunk, TargetNode, TargetNodeProperties, BufferedTargetStream, StreamContext, TransformNode, TransformNodeProperties, BufferedTransformStream, ChunkBuffer, CompositeNode, BufferedAudioNode } from '@buffered-audio/core';
+export { CompositeNode } from '@buffered-audio/core';
+
+declare const ffmpegSchema: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    ffprobePath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface ReadFfmpegProperties extends z.infer<typeof ffmpegSchema>, SourceNodeProperties {
+    readonly channels?: ReadonlyArray<number>;
+}
+declare class ReadFfmpegStream<P extends ReadFfmpegProperties = ReadFfmpegProperties> extends BufferedSourceStream<P> {
+    private ffmpegProcess?;
+    private stdout?;
+    private frameOffset;
+    private remainder?;
+    private outputChannels;
+    private sourceSampleRate;
+    private sourceBitDepth;
+    getMetadata(): Promise<SourceMetadata>;
+    private ensureInitialized;
+    _read(): Promise<AudioChunk | undefined>;
+    _flush(): Promise<void>;
+    _teardown(): void;
+    private probe;
+    private readBytes;
+}
+declare class ReadFfmpegNode extends SourceNode<ReadFfmpegProperties> {
+    static readonly moduleName = "Read FFmpeg";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Read audio from a file using FFmpeg";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        ffprobePath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "source", "read-ffmpeg"];
+    protected createStream(): ReadFfmpegStream;
+    clone(overrides?: Partial<ReadFfmpegProperties>): ReadFfmpegNode;
+}
+declare function readFfmpeg(path: string, options: {
+    channels?: ReadonlyArray<number>;
+    ffmpegPath: string;
+    ffprobePath: string;
+}): ReadFfmpegNode;
+
+declare const wavSchema: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface ReadWavProperties extends z.infer<typeof wavSchema>, SourceNodeProperties {
+    readonly channels?: ReadonlyArray<number>;
+}
+declare function readSample(data: Buffer, offset: number, bitsPerSample: number, audioFormat: number): number;
+declare class ReadWavStream<P extends ReadWavProperties = ReadWavProperties> extends BufferedSourceStream<P> {
+    private fileHandle?;
+    private format?;
+    private bytesRead;
+    private sourceSampleRate;
+    private sourceBitDepth;
+    getMetadata(): Promise<SourceMetadata>;
+    private ensureInitialized;
+    _read(): Promise<AudioChunk | undefined>;
+    _flush(): Promise<void>;
+    _teardown(): void;
+}
+declare class ReadWavNode extends SourceNode<ReadWavProperties> {
+    static readonly moduleName = "Read WAV";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Read audio from a WAV file";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "source", "read-wav"];
+    protected createStream(): ReadWavStream;
+    clone(overrides?: Partial<ReadWavProperties>): ReadWavNode;
+}
+declare function readWav(path: string, options?: {
+    channels?: ReadonlyArray<number>;
+}): ReadWavNode;
+
+declare const schema$m: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    ffprobePath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+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 packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Read audio from a file";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        ffprobePath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "source", "read"];
+    protected createStream(): ReadWavStream<ReadProperties> | ReadFfmpegStream<ReadProperties>;
+    clone(overrides?: Partial<ReadProperties>): ReadNode;
+}
+declare function read(path: string, options?: {
+    channels?: ReadonlyArray<number>;
+    ffmpegPath?: string;
+    ffprobePath?: string;
+}): ReadNode;
+
+declare const schema$l: z.ZodObject<{
+    bucketCount: z.ZodDefault<z.ZodNumber>;
+    outputPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface LoudnessStatsProperties extends z.infer<typeof schema$l>, TargetNodeProperties {
+}
+interface AmplitudeDistribution {
+    readonly buckets: Uint32Array;
+    readonly bucketMax: number;
+    readonly totalSamples: number;
+    readonly median: number;
+    percentile(p: number): number;
+}
+interface LoudnessStats {
+    readonly integrated: number;
+    readonly truePeak: number;
+    readonly range: number;
+    readonly amplitude: AmplitudeDistribution;
+}
+declare class LoudnessStatsStream extends BufferedTargetStream<LoudnessStatsProperties> {
+    private channels;
+    private sampleRate;
+    private truePeakAccumulator;
+    private loudnessAccumulator;
+    private histogramAccumulator;
+    private _stats?;
+    private statsInitialized;
+    private fileHandle?;
+    get stats(): LoudnessStats | undefined;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    private ensureInit;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+}
+declare class LoudnessStatsNode extends TargetNode<LoudnessStatsProperties> {
+    static readonly moduleName = "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 schema: z.ZodObject<{
+        bucketCount: z.ZodDefault<z.ZodNumber>;
+        outputPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is LoudnessStatsNode;
+    readonly type: readonly ["buffered-audio-node", "target", "loudness-stats"];
+    private cachedStats?;
+    constructor(properties: LoudnessStatsProperties);
+    get stats(): LoudnessStats | undefined;
+    _teardown(): void;
+    createStream(): LoudnessStatsStream;
+    clone(overrides?: Partial<LoudnessStatsProperties>): LoudnessStatsNode;
+}
+declare function loudnessStats(options?: {
+    id?: string;
+    bucketCount?: number;
+    outputPath?: string;
+}): LoudnessStatsNode;
+
+declare const schema$k: z.ZodObject<{
+    outputPath: z.ZodDefault<z.ZodString>;
+    fftSize: z.ZodDefault<z.ZodNumber>;
+    hopSize: z.ZodDefault<z.ZodNumber>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type FrequencyScale = "linear" | "log" | "mel" | "erb";
+interface SpectrogramProperties extends z.infer<typeof schema$k>, TargetNodeProperties {
+    readonly frequencyScale?: FrequencyScale;
+    readonly numBands?: number;
+    readonly minFrequency?: number;
+    readonly maxFrequency?: number;
+}
+declare class SpectrogramStream extends BufferedTargetStream<SpectrogramProperties> {
+    private fileHandle?;
+    private channels;
+    private linearBins;
+    private outputBins;
+    private numFrames;
+    private fileOffset;
+    private windowCoefficients;
+    private workspace?;
+    private addon;
+    private bandMappings?;
+    private magnitudes;
+    private sampleBuffers;
+    private sampleBufferOffset;
+    private sampleBufferCapacity;
+    private writeBuffer?;
+    private writeBufferOffset;
+    private writeBufferFileOffset;
+    private readonly WRITE_BATCH_FRAMES;
+    private initialized;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    private initialize;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+    private processAccumulatedSamples;
+    private writeFrame;
+    private flushWriteBuffer;
+}
+declare class SpectrogramNode extends TargetNode<SpectrogramProperties> {
+    static readonly moduleName = "Spectrogram";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Generate spectrogram visualization data";
+    static readonly schema: z.ZodObject<{
+        outputPath: z.ZodDefault<z.ZodString>;
+        fftSize: z.ZodDefault<z.ZodNumber>;
+        hopSize: z.ZodDefault<z.ZodNumber>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is SpectrogramNode;
+    readonly type: readonly ["buffered-audio-node", "target", "spectrogram"];
+    constructor(properties: SpectrogramProperties);
+    createStream(): SpectrogramStream;
+    clone(overrides?: Partial<SpectrogramProperties>): SpectrogramNode;
+}
+declare function spectrogram(outputPath: string, options?: {
+    fftSize?: number;
+    hopSize?: number;
+    frequencyScale?: FrequencyScale;
+    numBands?: number;
+    minFrequency?: number;
+    maxFrequency?: number;
+    fftwAddonPath?: string;
+}): SpectrogramNode;
+
+declare const schema$j: z.ZodObject<{
+    outputPath: z.ZodDefault<z.ZodString>;
+    resolution: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface WaveformProperties extends z.infer<typeof schema$j>, TargetNodeProperties {
+}
+declare class WaveformStream extends BufferedTargetStream<WaveformProperties> {
+    private fileHandle?;
+    private channels;
+    private samplesPerPoint;
+    private totalPoints;
+    private fileOffset;
+    private samplesInCurrentWindow;
+    private currentMin;
+    private currentMax;
+    private writeBuffer;
+    private writeBufferOffset;
+    private writeBufferFileOffset;
+    private readonly WRITE_BATCH_POINTS;
+    private initialized;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    private initialize;
+    private writeHeader;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+    private flushPoint;
+    private flushWriteBuffer;
+}
+declare class WaveformNode extends TargetNode<WaveformProperties> {
+    static readonly moduleName = "Waveform";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Generate waveform visualization data";
+    static readonly schema: z.ZodObject<{
+        outputPath: z.ZodDefault<z.ZodString>;
+        resolution: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is WaveformNode;
+    readonly type: readonly ["buffered-audio-node", "target", "waveform"];
+    constructor(properties: WaveformProperties);
+    createStream(): WaveformStream;
+    clone(overrides?: Partial<WaveformProperties>): WaveformNode;
+}
+declare function waveform(outputPath: string, options?: {
+    resolution?: number;
+}): WaveformNode;
+
+type WavBitDepth = "16" | "24" | "32" | "32f";
+interface EncodingOptions {
+    readonly format: "wav" | "flac" | "mp3" | "aac";
+    readonly bitrate?: string;
+    readonly vbr?: number;
+    readonly sampleRate?: number;
+}
+interface WriteProperties extends TargetNodeProperties {
+    readonly path: string;
+    readonly ffmpegPath?: string;
+    readonly bitDepth: WavBitDepth;
+    readonly encoding?: EncodingOptions;
+}
+declare class WriteStream extends BufferedTargetStream<WriteProperties> {
+    private fileHandle?;
+    private ffmpegProcess?;
+    private ffmpegStdin?;
+    private ffmpegDone?;
+    private sampleRate;
+    private channels;
+    private bytesWritten;
+    private useEncoding;
+    private initialized;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    private initialize;
+    private spawnFfmpeg;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+    _teardown(): Promise<void>;
+    private convertChunk;
+    private buildFfmpegArgs;
+    private writeToStdin;
+}
+declare class WriteNode extends TargetNode<WriteProperties> {
+    static readonly moduleName = "Write";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Write audio to a file";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        bitDepth: z.ZodDefault<z.ZodEnum<{
+            16: "16";
+            24: "24";
+            32: "32";
+            "32f": "32f";
+        }>>;
+        encoding: z.ZodOptional<z.ZodObject<{
+            format: z.ZodEnum<{
+                wav: "wav";
+                flac: "flac";
+                mp3: "mp3";
+                aac: "aac";
+            }>;
+            bitrate: z.ZodOptional<z.ZodString>;
+            vbr: z.ZodOptional<z.ZodNumber>;
+            sampleRate: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "target", "write"];
+    createStream(): WriteStream;
+    clone(overrides?: Partial<WriteProperties>): WriteNode;
+}
+declare function write(path: string, options?: {
+    bitDepth?: WavBitDepth;
+    ffmpegPath?: string;
+    encoding?: EncodingOptions;
+}): WriteNode;
+
+declare const cutRegionSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strip>;
+declare const schema$i: z.ZodObject<{
+    regions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CutRegion = z.infer<typeof cutRegionSchema>;
+interface CutProperties extends z.infer<typeof schema$i>, TransformNodeProperties {
+}
+declare class CutStream extends BufferedTransformStream<CutProperties> {
+    private sortedRegions;
+    private removedFrames;
+    constructor(properties: CutProperties);
+    _unbuffer(chunk: AudioChunk): AudioChunk | undefined;
+}
+declare class CutNode extends TransformNode<CutProperties> {
+    static readonly moduleName = "Cut";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Remove a region of audio";
+    static readonly schema: z.ZodObject<{
+        regions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is CutNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "cut"];
+    createStream(): CutStream;
+    clone(overrides?: Partial<CutProperties>): CutNode;
+}
+declare function cut(regions: Array<CutRegion>, options?: {
+    id?: string;
+}): CutNode;
+
+declare const schema$h: z.ZodObject<{
+    bitDepth: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<16>, z.ZodLiteral<24>]>>;
+    noiseShaping: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+interface DitherProperties extends z.infer<typeof schema$h>, TransformNodeProperties {
+}
+declare class DitherStream extends BufferedTransformStream<DitherProperties> {
+    private lastError;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class DitherNode extends TransformNode<DitherProperties> {
+    static readonly moduleName = "Dither";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "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>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DitherNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "dither"];
+    createStream(): DitherStream;
+    clone(overrides?: Partial<DitherProperties>): DitherNode;
+}
+declare function dither(bitDepth: 16 | 24, options?: {
+    noiseShaping?: boolean;
+    id?: string;
+}): DitherNode;
+
+declare const schema$g: z.ZodObject<{
+    ceiling: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface NormalizeProperties extends z.infer<typeof schema$g>, TransformNodeProperties {
+}
+declare class NormalizeStream extends BufferedTransformStream<NormalizeProperties> {
+    private peak;
+    private scale;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
+    _process(_buffer: ChunkBuffer): void;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class NormalizeNode extends TransformNode<NormalizeProperties> {
+    static readonly moduleName = "Normalize";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Adjust peak or loudness level to a target ceiling";
+    static readonly schema: z.ZodObject<{
+        ceiling: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is NormalizeNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "normalize"];
+    constructor(properties: NormalizeProperties);
+    createStream(): NormalizeStream;
+    clone(overrides?: Partial<NormalizeProperties>): NormalizeNode;
+}
+declare function normalize(options?: {
+    ceiling?: number;
+    id?: string;
+}): NormalizeNode;
+
+declare const schema$f: z.ZodObject<{
+    before: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface PadProperties extends z.infer<typeof schema$f>, TransformNodeProperties {
+}
+declare class PadStream extends BufferedTransformStream<PadProperties> {
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class PadNode extends TransformNode<PadProperties> {
+    static readonly moduleName = "Pad";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Add silence to start or end of audio";
+    static readonly schema: z.ZodObject<{
+        before: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is PadNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "pad"];
+    constructor(properties: PadProperties);
+    createStream(): PadStream;
+    clone(overrides?: Partial<PadProperties>): PadNode;
+}
+declare function pad(options: {
+    before?: number;
+    after?: number;
+    id?: string;
+}): PadNode;
+
+declare const schema$e: z.ZodObject<{
+    invert: z.ZodDefault<z.ZodBoolean>;
+    angle: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface PhaseProperties extends z.infer<typeof schema$e>, TransformNodeProperties {
+}
+declare class PhaseStream extends BufferedTransformStream<PhaseProperties> {
+    private allpassState;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+    private applyInvert;
+    private applyPhaseRotation;
+}
+declare class PhaseNode extends TransformNode<PhaseProperties> {
+    static readonly moduleName = "Phase";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Invert or rotate signal phase";
+    static readonly schema: z.ZodObject<{
+        invert: z.ZodDefault<z.ZodBoolean>;
+        angle: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is PhaseNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "phase"];
+    createStream(): PhaseStream;
+    clone(overrides?: Partial<PhaseProperties>): PhaseNode;
+}
+declare function phase(options?: {
+    invert?: boolean;
+    angle?: number;
+    id?: string;
+}): PhaseNode;
+declare function invert(options?: {
+    id?: string;
+}): PhaseNode;
+
+declare class ReverseStream extends BufferedTransformStream {
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class ReverseNode extends TransformNode {
+    static readonly moduleName = "Reverse";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "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"];
+    constructor(properties?: TransformNodeProperties);
+    createStream(): ReverseStream;
+    clone(overrides?: Partial<TransformNodeProperties>): ReverseNode;
+}
+declare function reverse(options?: {
+    id?: string;
+}): ReverseNode;
+
+declare const schema$d: z.ZodObject<{
+    insertPath: z.ZodDefault<z.ZodString>;
+    insertAt: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface SpliceProperties extends z.infer<typeof schema$d>, TransformNodeProperties {
+    readonly channels?: ReadonlyArray<number>;
+}
+declare class SpliceStream extends BufferedTransformStream<SpliceProperties> {
+    private insertSamples;
+    private insertSampleRate;
+    private insertLength;
+    private sampleRateChecked;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class SpliceNode extends TransformNode<SpliceProperties> {
+    static readonly moduleName = "Splice";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Replace a region of audio with processed content";
+    static readonly schema: z.ZodObject<{
+        insertPath: z.ZodDefault<z.ZodString>;
+        insertAt: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is SpliceNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "splice"];
+    createStream(): SpliceStream;
+    clone(overrides?: Partial<SpliceProperties>): SpliceNode;
+}
+declare function splice(insertPath: string, insertAt: number, options?: {
+    channels?: ReadonlyArray<number>;
+}): SpliceNode;
+
+declare const schema$c: z.ZodObject<{
+    threshold: z.ZodDefault<z.ZodNumber>;
+    margin: z.ZodDefault<z.ZodNumber>;
+    start: z.ZodDefault<z.ZodBoolean>;
+    end: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+interface TrimProperties extends z.infer<typeof schema$c>, TransformNodeProperties {
+}
+declare class TrimStream extends BufferedTransformStream<TrimProperties> {
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class TrimNode extends TransformNode<TrimProperties> {
+    static readonly moduleName = "Trim";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Remove silence from start and end";
+    static readonly schema: z.ZodObject<{
+        threshold: z.ZodDefault<z.ZodNumber>;
+        margin: z.ZodDefault<z.ZodNumber>;
+        start: z.ZodDefault<z.ZodBoolean>;
+        end: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is TrimNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "trim"];
+    constructor(properties: TrimProperties);
+    createStream(): TrimStream;
+    clone(overrides?: Partial<TrimProperties>): TrimNode;
+}
+declare function trim(options?: {
+    threshold?: number;
+    margin?: number;
+    start?: boolean;
+    end?: boolean;
+    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 packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "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"];
+    createStream(): DownmixMonoStream;
+    clone(overrides?: Partial<TransformNodeProperties>): DownmixMonoNode;
+}
+declare function downmixMono(options?: {
+    id?: string;
+}): DownmixMonoNode;
+
+declare const schema$b: z.ZodObject<{
+    channels: z.ZodDefault<z.ZodNumber>;
+}, 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 packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Duplicate a mono signal into multiple identical output channels";
+    static readonly schema: z.ZodObject<{
+        channels: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DuplicateChannelsNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "duplicate-channels"];
+    createStream(): DuplicateChannelsStream;
+    clone(overrides?: Partial<DuplicateChannelsProperties>): DuplicateChannelsNode;
+}
+declare function duplicateChannels(options?: {
+    channels?: number;
+    id?: string;
+}): DuplicateChannelsNode;
+
+declare const schema$a: z.ZodObject<{
+    gain: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface GainProperties extends z.infer<typeof schema$a>, TransformNodeProperties {
+}
+declare class GainStream extends BufferedTransformStream<GainProperties> {
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class GainNode extends TransformNode<GainProperties> {
+    static readonly moduleName = "Gain";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Adjust signal level by a fixed amount in dB";
+    static readonly schema: z.ZodObject<{
+        gain: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is GainNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "gain"];
+    createStream(): GainStream;
+    clone(overrides?: Partial<GainProperties>): GainNode;
+}
+declare function gain(options?: {
+    gain?: number;
+    id?: string;
+}): GainNode;
+
+declare const schema$9: z.ZodObject<{
+    pan: z.ZodDefault<z.ZodNumber>;
+}, 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 packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Position mono signal in stereo field or adjust stereo balance";
+    static readonly schema: z.ZodObject<{
+        pan: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is PanNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "pan"];
+    createStream(): PanStream;
+    clone(overrides?: Partial<PanProperties>): PanNode;
+}
+declare function pan(options?: {
+    pan?: number;
+    id?: string;
+}): PanNode;
+
+interface FfmpegProperties extends TransformNodeProperties {
+    readonly ffmpegPath: string;
+    readonly args?: Array<string> | ((context: StreamContext) => Array<string>);
+    readonly outputSampleRate?: number;
+}
+declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extends BufferedTransformStream<P> {
+    private streamContext?;
+    private _sourceTotalFrames?;
+    private child?;
+    private stdoutStash;
+    private outputOffset;
+    private stderr;
+    private exitPromise?;
+    private stdoutEndPromise?;
+    private pendingDrain?;
+    private inputSampleRate;
+    private inputChannels;
+    private hasStartedEvent;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    protected _buildArgs(_context: StreamContext): Array<string>;
+    protected _buildOutputArgs(_context: StreamContext): Array<string>;
+    createTransformStream(): TransformStream<AudioChunk, AudioChunk>;
+    private spawnChild;
+    private handleStdoutBytes;
+    private handleChunk;
+    private handleFlushStream;
+    _teardown(): Promise<void>;
+}
+declare class FfmpegNode<P extends FfmpegProperties = FfmpegProperties> extends TransformNode<P> {
+    static readonly moduleName: string;
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription: string;
+    static readonly schema: z.ZodType;
+    static is(value: unknown): value is FfmpegNode;
+    readonly type: ReadonlyArray<string>;
+    constructor(properties: P);
+    createStream(): FfmpegStream<P>;
+    clone(overrides?: Partial<P>): FfmpegNode<P>;
+}
+declare function ffmpeg(options: {
+    ffmpegPath: string;
+    args: Array<string> | ((context: StreamContext) => Array<string>);
+    outputSampleRate?: number;
+    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>;
+    floor: z.ZodOptional<z.ZodNumber>;
+    limitPercentile: z.ZodDefault<z.ZodNumber>;
+    limitDb: z.ZodOptional<z.ZodNumber>;
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    targetTp: z.ZodOptional<z.ZodNumber>;
+    smoothing: z.ZodDefault<z.ZodNumber>;
+    tolerance: z.ZodDefault<z.ZodNumber>;
+    peakTolerance: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+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.
+     */
+    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;
+    };
+    _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 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 schema: z.ZodObject<{
+        targetLufs: z.ZodDefault<z.ZodNumber>;
+        pivot: z.ZodOptional<z.ZodNumber>;
+        floor: z.ZodOptional<z.ZodNumber>;
+        limitPercentile: z.ZodDefault<z.ZodNumber>;
+        limitDb: z.ZodOptional<z.ZodNumber>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        targetTp: z.ZodOptional<z.ZodNumber>;
+        smoothing: z.ZodDefault<z.ZodNumber>;
+        tolerance: z.ZodDefault<z.ZodNumber>;
+        peakTolerance: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is LoudnessTargetNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "loudness-target"];
+    constructor(properties: LoudnessTargetProperties);
+    createStream(): LoudnessTargetStream;
+    clone(overrides?: Partial<LoudnessTargetProperties>): LoudnessTargetNode;
+}
+declare function loudnessTarget(options: {
+    targetLufs?: number;
+    pivot?: number;
+    floor?: number;
+    targetTp?: number;
+    limitPercentile?: number;
+    limitDb?: number;
+    smoothing?: number;
+    tolerance?: number;
+    peakTolerance?: number;
+    maxAttempts?: number;
+    id?: string;
+}): LoudnessTargetNode;
+
+declare const schema$7: z.ZodObject<{
+    target: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface LoudnessNormalizeProperties extends z.infer<typeof schema$7>, TransformNodeProperties {
+}
+declare class LoudnessNormalizeStream extends BufferedTransformStream<LoudnessNormalizeProperties> {
+    private gain;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class LoudnessNormalizeNode extends TransformNode<LoudnessNormalizeProperties> {
+    static readonly moduleName = "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 schema: z.ZodObject<{
+        target: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is LoudnessNormalizeNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "loudness-normalize"];
+    constructor(properties: LoudnessNormalizeProperties);
+    createStream(): LoudnessNormalizeStream;
+    clone(overrides?: Partial<LoudnessNormalizeProperties>): LoudnessNormalizeNode;
+}
+declare function loudnessNormalize(options?: {
+    target?: number;
+    id?: string;
+}): LoudnessNormalizeNode;
+
+declare const schema$6: z.ZodObject<{
+    target: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface TruePeakNormalizeProperties extends z.infer<typeof schema$6>, TransformNodeProperties {
+}
+declare class TruePeakNormalizeStream extends BufferedTransformStream<TruePeakNormalizeProperties> {
+    private gain;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class TruePeakNormalizeNode extends TransformNode<TruePeakNormalizeProperties> {
+    static readonly moduleName = "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 schema: z.ZodObject<{
+        target: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is TruePeakNormalizeNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "true-peak-normalize"];
+    constructor(properties: TruePeakNormalizeProperties);
+    createStream(): TruePeakNormalizeStream;
+    clone(overrides?: Partial<TruePeakNormalizeProperties>): TruePeakNormalizeNode;
+}
+declare function truePeakNormalize(options?: {
+    target?: number;
+    id?: string;
+}): TruePeakNormalizeNode;
+
+declare const schema$5: z.ZodObject<{
+    smoothing: z.ZodDefault<z.ZodNumber>;
+    frameSize: z.ZodDefault<z.ZodNumber>;
+    vkfftAddonPath: z.ZodDefault<z.ZodString>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface CrestReduceProperties extends z.infer<typeof schema$5>, TransformNodeProperties {
+}
+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;
+    _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.
+     */
+    _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>;
+}
+declare class CrestReduceNode extends TransformNode<CrestReduceProperties> {
+    static readonly moduleName = "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 schema: z.ZodObject<{
+        smoothing: z.ZodDefault<z.ZodNumber>;
+        frameSize: z.ZodDefault<z.ZodNumber>;
+        vkfftAddonPath: z.ZodDefault<z.ZodString>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is CrestReduceNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "crest-reduce"];
+    constructor(properties: CrestReduceProperties);
+    createStream(): CrestReduceStream;
+    clone(overrides?: Partial<CrestReduceProperties>): CrestReduceNode;
+}
+declare function crestReduce(options?: {
+    smoothing?: number;
+    frameSize?: number;
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+    id?: string;
+}): CrestReduceNode;
+
+declare const schema$4: z.ZodObject<{
+    references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    reductionStrength: z.ZodDefault<z.ZodNumber>;
+    artifactSmoothing: z.ZodDefault<z.ZodNumber>;
+    adaptationSpeed: z.ZodDefault<z.ZodNumber>;
+    fftSize: z.ZodDefault<z.ZodNumber>;
+    hopSize: z.ZodDefault<z.ZodNumber>;
+    vkfftAddonPath: z.ZodDefault<z.ZodString>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+    dfttBackend: z.ZodDefault<z.ZodEnum<{
+        "": "";
+        vkfft: "vkfft";
+        fftw: "fftw";
+        js: "js";
+    }>>;
+}, 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?;
+    private dfttFftBackend?;
+    private dfttFftAddonOptions?;
+    private referenceBuffers;
+    private chunkFrames;
+    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 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 schema: z.ZodObject<{
+        references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reductionStrength: z.ZodDefault<z.ZodNumber>;
+        artifactSmoothing: z.ZodDefault<z.ZodNumber>;
+        adaptationSpeed: z.ZodDefault<z.ZodNumber>;
+        fftSize: z.ZodDefault<z.ZodNumber>;
+        hopSize: z.ZodDefault<z.ZodNumber>;
+        vkfftAddonPath: z.ZodDefault<z.ZodString>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+        dfttBackend: z.ZodDefault<z.ZodEnum<{
+            "": "";
+            vkfft: "vkfft";
+            fftw: "fftw";
+            js: "js";
+        }>>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DeBleedNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "de-bleed"];
+    constructor(properties: DeBleedProperties);
+    createStream(): DeBleedStream;
+    clone(overrides?: Partial<DeBleedProperties>): DeBleedNode;
+}
+declare function deBleed(references: string | ReadonlyArray<string>, options?: {
+    reductionStrength?: number;
+    artifactSmoothing?: number;
+    adaptationSpeed?: number;
+    fftSize?: number;
+    hopSize?: number;
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+    dfttBackend?: "" | "js" | "fftw" | "vkfft";
+    id?: string;
+}): DeBleedNode;
+
+declare const schema$3: z.ZodObject<{
+    modelPath: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    onnxAddonPath: z.ZodDefault<z.ZodString>;
+    sampleRate: z.ZodNumber;
+    attenuation: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface DeepFilterNet3Properties extends z.infer<typeof schema$3>, TransformNodeProperties {
+}
+declare class DeepFilterNet3Stream extends BufferedTransformStream<DeepFilterNet3Properties> {
+    private session?;
+    private dfnStates;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    _teardown(): void;
+}
+declare class DeepFilterNet3Node extends TransformNode<DeepFilterNet3Properties> {
+    static readonly moduleName = "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 schema: z.ZodObject<{
+        modelPath: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        onnxAddonPath: z.ZodDefault<z.ZodString>;
+        sampleRate: z.ZodNumber;
+        attenuation: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DeepFilterNet3Node;
+    readonly type: readonly ["buffered-audio-node", "transform", "deep-filter-net-3"];
+    constructor(properties: DeepFilterNet3Properties);
+    createStream(): DeepFilterNet3Stream;
+    clone(overrides?: Partial<DeepFilterNet3Properties>): DeepFilterNet3Node;
+}
+declare function deepFilterNet3(options: {
+    modelPath: string;
+    sampleRate: number;
+    ffmpegPath?: string;
+    onnxAddonPath?: string;
+    attenuation?: number;
+    id?: string;
+}): DeepFilterNet3Node;
+
+declare const schema$2: z.ZodObject<{
+    modelPath1: z.ZodDefault<z.ZodString>;
+    modelPath2: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    onnxAddonPath: z.ZodDefault<z.ZodString>;
+    vkfftAddonPath: z.ZodDefault<z.ZodString>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface DtlnProperties extends z.infer<typeof schema$2>, TransformNodeProperties {
+}
+declare class DtlnStream extends BufferedTransformStream<DtlnProperties> {
+    private session1;
+    private session2;
+    private fftBackend?;
+    private fftAddonOptions?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    private runMainPass;
+}
+declare class DtlnNode extends TransformNode<DtlnProperties> {
+    static readonly moduleName = "DTLN (Denoiser)";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Remove background noise from speech using DTLN neural network";
+    static readonly schema: z.ZodObject<{
+        modelPath1: z.ZodDefault<z.ZodString>;
+        modelPath2: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        onnxAddonPath: z.ZodDefault<z.ZodString>;
+        vkfftAddonPath: z.ZodDefault<z.ZodString>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DtlnNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "dtln"];
+    constructor(properties: DtlnProperties);
+    createStream(): DtlnStream;
+    clone(overrides?: Partial<DtlnProperties>): DtlnNode;
+}
+declare function dtln(options: {
+    modelPath1: string;
+    modelPath2: string;
+    ffmpegPath: string;
+    onnxAddonPath?: string;
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+    id?: string;
+}): DtlnNode;
+
+interface StemGains {
+    readonly vocals: number;
+    readonly drums: number;
+    readonly bass: number;
+    readonly other: number;
+}
+declare const schema$1: z.ZodObject<{
+    modelPath: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    onnxAddonPath: z.ZodDefault<z.ZodString>;
+    highPass: z.ZodDefault<z.ZodNumber>;
+    lowPass: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface HtdemucsProperties extends z.infer<typeof schema$1>, TransformNodeProperties {
+    readonly stems: StemGains;
+}
+declare class HtdemucsStream extends BufferedTransformStream<HtdemucsProperties> {
+    private session;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    private runMainPass;
+    private emitStable;
+}
+declare class HtdemucsNode extends TransformNode<HtdemucsProperties> {
+    static readonly moduleName = "HTDemucs (Stem Separator)";
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription = "Rebalance stem volumes using HTDemucs source separation";
+    static readonly schema: z.ZodObject<{
+        modelPath: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        onnxAddonPath: z.ZodDefault<z.ZodString>;
+        highPass: z.ZodDefault<z.ZodNumber>;
+        lowPass: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is HtdemucsNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "htdemucs"];
+    constructor(properties: HtdemucsProperties);
+    createStream(): HtdemucsStream;
+    clone(overrides?: Partial<HtdemucsProperties>): HtdemucsNode;
+}
+declare function htdemucs(modelPath: string, stems: Partial<StemGains>, options?: {
+    ffmpegPath?: string;
+    onnxAddonPath?: string;
+    id?: string;
+}): HtdemucsNode;
+
+declare const schema: z.ZodObject<{
+    modelPath: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    onnxAddonPath: z.ZodDefault<z.ZodString>;
+    highPass: z.ZodDefault<z.ZodNumber>;
+    lowPass: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface KimVocal2Properties extends z.infer<typeof schema>, TransformNodeProperties {
+}
+declare class KimVocal2Stream extends BufferedTransformStream<KimVocal2Properties> {
+    private session;
+    private fftInstance;
+    constructor(properties: KimVocal2Properties);
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    private runMainPass;
+    private emitStable;
+}
+declare class KimVocal2Node extends TransformNode<KimVocal2Properties> {
+    static readonly moduleName = "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 schema: z.ZodObject<{
+        modelPath: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        onnxAddonPath: z.ZodDefault<z.ZodString>;
+        highPass: z.ZodDefault<z.ZodNumber>;
+        lowPass: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is KimVocal2Node;
+    readonly type: readonly ["buffered-audio-node", "transform", "kim-vocal-2"];
+    constructor(properties: KimVocal2Properties);
+    createStream(): KimVocal2Stream;
+    clone(overrides?: Partial<KimVocal2Properties>): KimVocal2Node;
+}
+declare function kimVocal2(options: {
+    modelPath: string;
+    ffmpegPath: string;
+    onnxAddonPath?: string;
+    highPass?: number;
+    lowPass?: number;
+    id?: string;
+}): KimVocal2Node;
+
+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?;
+    private stagesJsonCleanup?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    _teardown(): Promise<void>;
+}
+declare class Vst3Node<P extends Vst3Properties = Vst3Properties> extends TransformNode<P> {
+    static readonly moduleName: string;
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    static readonly moduleDescription: string;
+    static readonly schema: z.ZodType;
+    static is(value: unknown): value is Vst3Node;
+    readonly type: ReadonlyArray<string>;
+    constructor(properties: P);
+    createStream(): BufferedTransformStream<P>;
+    clone(overrides?: Partial<P>): Vst3Node<P>;
+}
+declare function vst3(options: {
+    vstHostPath: string;
+    stages: ReadonlyArray<VstStage>;
+    bypass?: boolean;
+    id?: string;
+    extraArgs?: ReadonlyArray<string>;
+}): Vst3Node;
+
+declare class ChainNode extends CompositeNode {
+    static readonly packageName: string;
+    static readonly packageVersion: string;
+    readonly type: readonly ["buffered-audio-node", "transform", "composite", "chain"];
+    private readonly _head;
+    private readonly _tail;
+    constructor(head: BufferedAudioNode, tail: BufferedAudioNode);
+    get head(): BufferedAudioNode;
+    get tail(): BufferedAudioNode;
+    createStream(): BufferedTransformStream;
+    clone(): ChainNode;
+}
+declare function chain(...nodes: Array<BufferedAudioNode | CompositeNode>): ChainNode;
+
+export { ChainNode, CrestReduceNode, type CrestReduceProperties, CrestReduceStream, CutNode, type CutProperties, type CutRegion, CutStream, DeBleedNode, type DeBleedProperties, DeBleedStream, DeepFilterNet3Node, type DeepFilterNet3Properties, DeepFilterNet3Stream, DitherNode, type DitherProperties, DitherStream, DownmixMonoNode, DownmixMonoStream, DtlnNode, type DtlnProperties, DtlnStream, DuplicateChannelsNode, type DuplicateChannelsProperties, DuplicateChannelsStream, type EncodingOptions, FfmpegNode, type FfmpegProperties, FfmpegStream, type FrequencyScale, GainNode, type GainProperties, GainStream, HtdemucsNode, type HtdemucsProperties, HtdemucsStream, KimVocal2Node, type KimVocal2Properties, KimVocal2Stream, LoudnessNormalizeNode, type LoudnessNormalizeProperties, LoudnessNormalizeStream, type LoudnessStats, LoudnessStatsNode, LoudnessStatsStream, LoudnessTargetNode, type LoudnessTargetProperties, LoudnessTargetStream, NormalizeNode, type NormalizeProperties, NormalizeStream, PadNode, type PadProperties, PadStream, PanNode, type PanProperties, PanStream, PhaseNode, type PhaseProperties, PhaseStream, ReadFfmpegNode, type ReadFfmpegProperties, ReadFfmpegStream, ReadNode, type ReadProperties, ReadWavNode, type ReadWavProperties, ReadWavStream, ReverseNode, ReverseStream, SpectrogramNode, type SpectrogramProperties, SpectrogramStream, SpliceNode, type SpliceProperties, SpliceStream, type StemGains, TrimNode, type TrimProperties, TrimStream, TruePeakNormalizeNode, type TruePeakNormalizeProperties, TruePeakNormalizeStream, Vst3Node, type Vst3Properties, Vst3Stream, type WavBitDepth, WaveformNode, type WaveformProperties, WaveformStream, WriteNode, type WriteProperties, WriteStream, chain, crestReduce, cut, deBleed, deepFilterNet3, dither, downmixMono, dtln, duplicateChannels, ffmpeg, ffmpegSchema, gain, htdemucs, invert, kimVocal2, loudnessNormalize, loudnessStats, loudnessTarget, normalize, pad, pan, phase, read, readFfmpeg, readSample, readWav, reverse, spectrogram, splice, trim, truePeakNormalize, vst3, wavSchema, waveform, write };