@buffered-audio/nodes 0.17.0 → 0.18.1

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 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';
+import { SourceNode, SourceNodeProperties, BufferedSourceStream, SourceMetadata, Block, TargetNode, TargetNodeProperties, BufferedTargetStream, StreamContext, TransformNode, TransformNodeProperties, UnbufferedTransformStream, BufferedAudioNode, BufferedTransformStream, BlockBuffer, Composition } from '@buffered-audio/core';
 
 declare const ffmpegSchema: z.ZodObject<{
     path: z.ZodDefault<z.ZodString>;
@@ -20,9 +19,8 @@ declare class ReadFfmpegStream<P extends ReadFfmpegProperties = ReadFfmpegProper
     private sourceBitDepth;
     getMetadata(): Promise<SourceMetadata>;
     private ensureInitialized;
-    _read(): Promise<AudioChunk | undefined>;
-    _flush(): Promise<void>;
-    _teardown(): void;
+    _read(): Promise<Block | undefined>;
+    _destroy(): Promise<void>;
     private probe;
     private readBytes;
 }
@@ -36,8 +34,8 @@ declare class ReadFfmpegNode extends SourceNode<ReadFfmpegProperties> {
         ffmpegPath: z.ZodDefault<z.ZodString>;
         ffprobePath: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof ReadFfmpegStream;
     readonly type: readonly ["buffered-audio-node", "source", "read-ffmpeg"];
-    protected createStream(): ReadFfmpegStream;
     clone(overrides?: Partial<ReadFfmpegProperties>): ReadFfmpegNode;
 }
 declare function readFfmpeg(path: string, options: {
@@ -52,7 +50,6 @@ declare const wavSchema: z.ZodObject<{
 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?;
@@ -61,9 +58,8 @@ declare class ReadWavStream<P extends ReadWavProperties = ReadWavProperties> ext
     private sourceBitDepth;
     getMetadata(): Promise<SourceMetadata>;
     private ensureInitialized;
-    _read(): Promise<AudioChunk | undefined>;
-    _flush(): Promise<void>;
-    _teardown(): void;
+    _read(): Promise<Block | undefined>;
+    _destroy(): Promise<void>;
 }
 declare class ReadWavNode extends SourceNode<ReadWavProperties> {
     static readonly nodeName = "Read WAV";
@@ -73,41 +69,21 @@ declare class ReadWavNode extends SourceNode<ReadWavProperties> {
     static readonly schema: z.ZodObject<{
         path: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof ReadWavStream;
     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 nodeName = "Read";
-    static readonly packageName: string;
-    static readonly packageVersion: string;
-    static readonly nodeDescription = "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;
+}): ReadWavNode | ReadFfmpegNode;
+
+declare function readSample(data: Buffer, offset: number, bitsPerSample: number, audioFormat: number): number;
 
 declare const schema$l: z.ZodObject<{
     bucketCount: z.ZodDefault<z.ZodNumber>;
@@ -138,9 +114,9 @@ declare class LoudnessStatsStream extends BufferedTargetStream<LoudnessStatsProp
     private statsInitialized;
     private fileHandle?;
     get stats(): LoudnessStats | undefined;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
     private ensureInit;
-    _write(chunk: AudioChunk): Promise<void>;
+    _write(chunk: Block): Promise<void>;
     _close(): Promise<void>;
 }
 declare class LoudnessStatsNode extends TargetNode<LoudnessStatsProperties> {
@@ -152,13 +128,9 @@ declare class LoudnessStatsNode extends TargetNode<LoudnessStatsProperties> {
         bucketCount: z.ZodDefault<z.ZodNumber>;
         outputPath: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof LoudnessStatsStream;
     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?: {
@@ -200,9 +172,9 @@ declare class SpectrogramStream extends BufferedTargetStream<SpectrogramProperti
     private writeBufferFileOffset;
     private readonly WRITE_BATCH_FRAMES;
     private initialized;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
     private initialize;
-    _write(chunk: AudioChunk): Promise<void>;
+    _write(chunk: Block): Promise<void>;
     _close(): Promise<void>;
     private processAccumulatedSamples;
     private writeFrame;
@@ -219,10 +191,9 @@ declare class SpectrogramNode extends TargetNode<SpectrogramProperties> {
         hopSize: z.ZodDefault<z.ZodNumber>;
         fftwAddonPath: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof SpectrogramStream;
     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?: {
@@ -255,10 +226,10 @@ declare class WaveformStream extends BufferedTargetStream<WaveformProperties> {
     private writeBufferFileOffset;
     private readonly WRITE_BATCH_POINTS;
     private initialized;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
     private initialize;
     private writeHeader;
-    _write(chunk: AudioChunk): Promise<void>;
+    _write(chunk: Block): Promise<void>;
     _close(): Promise<void>;
     private flushPoint;
     private flushWriteBuffer;
@@ -272,10 +243,9 @@ declare class WaveformNode extends TargetNode<WaveformProperties> {
         outputPath: z.ZodDefault<z.ZodString>;
         resolution: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof WaveformStream;
     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?: {
@@ -305,12 +275,12 @@ declare class WriteStream extends BufferedTargetStream<WriteProperties> {
     private bytesWritten;
     private useEncoding;
     private initialized;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
     private initialize;
     private spawnFfmpeg;
-    _write(chunk: AudioChunk): Promise<void>;
+    _write(chunk: Block): Promise<void>;
     _close(): Promise<void>;
-    _teardown(): Promise<void>;
+    _destroy(): Promise<void>;
     private convertChunk;
     private buildFfmpegArgs;
     private writeToStdin;
@@ -341,8 +311,8 @@ declare class WriteNode extends TargetNode<WriteProperties> {
             sampleRate: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof WriteStream;
     readonly type: readonly ["buffered-audio-node", "target", "write"];
-    createStream(): WriteStream;
     clone(overrides?: Partial<WriteProperties>): WriteNode;
 }
 declare function write(path: string, options?: {
@@ -364,11 +334,11 @@ declare const schema$i: z.ZodObject<{
 type CutRegion = z.infer<typeof cutRegionSchema>;
 interface CutProperties extends z.infer<typeof schema$i>, TransformNodeProperties {
 }
-declare class CutStream extends BufferedTransformStream<CutProperties> {
+declare class CutStream extends UnbufferedTransformStream<CutProperties> {
     private sortedRegions;
     private removedFrames;
-    constructor(properties: CutProperties);
-    _unbuffer(chunk: AudioChunk): AudioChunk | undefined;
+    constructor(node: BufferedAudioNode);
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
 }
 declare class CutNode extends TransformNode<CutProperties> {
     static readonly nodeName = "Cut";
@@ -381,9 +351,9 @@ declare class CutNode extends TransformNode<CutProperties> {
             end: z.ZodNumber;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof CutStream;
     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?: {
@@ -396,10 +366,9 @@ declare const schema$h: z.ZodObject<{
 }, z.core.$strip>;
 interface DitherProperties extends z.infer<typeof schema$h>, TransformNodeProperties {
 }
-declare class DitherStream extends BufferedTransformStream<DitherProperties> {
+declare class DitherStream extends UnbufferedTransformStream<DitherProperties> {
     private lastError;
-    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
 }
 declare class DitherNode extends TransformNode<DitherProperties> {
     static readonly nodeName = "Dither";
@@ -410,9 +379,9 @@ declare class DitherNode extends TransformNode<DitherProperties> {
         bitDepth: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<16>, z.ZodLiteral<24>]>>;
         noiseShaping: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof DitherStream;
     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?: {
@@ -426,11 +395,10 @@ declare const schema$g: z.ZodObject<{
 interface NormalizeProperties extends z.infer<typeof schema$g>, TransformNodeProperties {
 }
 declare class NormalizeStream extends BufferedTransformStream<NormalizeProperties> {
+    blockSize: number;
     private peak;
-    private scale;
-    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
-    _process(_buffer: ChunkBuffer): void;
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+    prepare(block: Block): Block;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
 }
 declare class NormalizeNode extends TransformNode<NormalizeProperties> {
     static readonly nodeName = "Normalize";
@@ -440,10 +408,9 @@ declare class NormalizeNode extends TransformNode<NormalizeProperties> {
     static readonly schema: z.ZodObject<{
         ceiling: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof NormalizeStream;
     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?: {
@@ -457,14 +424,14 @@ declare const schema$f: z.ZodObject<{
 }, z.core.$strip>;
 interface PadProperties extends z.infer<typeof schema$f>, TransformNodeProperties {
 }
-declare class PadStream extends BufferedTransformStream<PadProperties> {
+declare class PadStream extends UnbufferedTransformStream<PadProperties> {
     private seenChunk;
     private capturedSampleRate;
     private capturedBitDepth;
     private capturedChannels;
     private outputOffset;
-    _unbuffer(chunk: AudioChunk): AudioChunk;
-    _flush(): Array<AudioChunk> | undefined;
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
+    flush(enqueue: (block: Block) => void): void;
 }
 declare class PadNode extends TransformNode<PadProperties> {
     static readonly nodeName = "Pad";
@@ -475,10 +442,9 @@ declare class PadNode extends TransformNode<PadProperties> {
         before: z.ZodDefault<z.ZodNumber>;
         after: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof PadStream;
     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: {
@@ -493,9 +459,9 @@ declare const schema$e: z.ZodObject<{
 }, z.core.$strip>;
 interface PhaseProperties extends z.infer<typeof schema$e>, TransformNodeProperties {
 }
-declare class PhaseStream extends BufferedTransformStream<PhaseProperties> {
+declare class PhaseStream extends UnbufferedTransformStream<PhaseProperties> {
     private allpassState;
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
     private applyInvert;
     private applyPhaseRotation;
 }
@@ -508,9 +474,9 @@ declare class PhaseNode extends TransformNode<PhaseProperties> {
         invert: z.ZodDefault<z.ZodBoolean>;
         angle: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof PhaseStream;
     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?: {
@@ -523,7 +489,8 @@ declare function invert(options?: {
 }): PhaseNode;
 
 declare class ReverseStream extends BufferedTransformStream {
-    _process(buffer: ChunkBuffer): Promise<void>;
+    blockSize: number;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
 }
 declare class ReverseNode extends TransformNode {
     static readonly nodeName = "Reverse";
@@ -531,10 +498,9 @@ declare class ReverseNode extends TransformNode {
     static readonly packageVersion: string;
     static readonly nodeDescription = "Reverse audio playback direction";
     static readonly schema: z.ZodObject<{}, z.core.$strip>;
+    static readonly streamClass: typeof ReverseStream;
     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?: {
@@ -548,13 +514,13 @@ declare const schema$d: z.ZodObject<{
 interface SpliceProperties extends z.infer<typeof schema$d>, TransformNodeProperties {
     readonly channels?: ReadonlyArray<number>;
 }
-declare class SpliceStream extends BufferedTransformStream<SpliceProperties> {
+declare class SpliceStream extends UnbufferedTransformStream<SpliceProperties> {
     private insertSamples;
     private insertSampleRate;
     private insertLength;
     private sampleRateChecked;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
 }
 declare class SpliceNode extends TransformNode<SpliceProperties> {
     static readonly nodeName = "Splice";
@@ -565,9 +531,9 @@ declare class SpliceNode extends TransformNode<SpliceProperties> {
         insertPath: z.ZodDefault<z.ZodString>;
         insertAt: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof SpliceStream;
     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?: {
@@ -583,14 +549,12 @@ declare const schema$c: z.ZodObject<{
 interface TrimProperties extends z.infer<typeof schema$c>, TransformNodeProperties {
 }
 declare class TrimStream extends BufferedTransformStream<TrimProperties> {
+    blockSize: number;
     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;
+    prepare(block: Block): Block;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
 }
 declare class TrimNode extends TransformNode<TrimProperties> {
     static readonly nodeName = "Trim";
@@ -603,10 +567,9 @@ declare class TrimNode extends TransformNode<TrimProperties> {
         start: z.ZodDefault<z.ZodBoolean>;
         end: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof TrimStream;
     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?: {
@@ -617,8 +580,8 @@ declare function trim(options?: {
     id?: string;
 }): TrimNode;
 
-declare class DownmixMonoStream extends BufferedTransformStream {
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+declare class DownmixMonoStream extends UnbufferedTransformStream {
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
 }
 declare class DownmixMonoNode extends TransformNode {
     static readonly nodeName = "Downmix Mono";
@@ -626,9 +589,9 @@ declare class DownmixMonoNode extends TransformNode {
     static readonly packageVersion: string;
     static readonly nodeDescription = "Mix all input channels to a single mono channel by averaging";
     static readonly schema: z.ZodObject<{}, z.core.$strip>;
+    static readonly streamClass: typeof DownmixMonoStream;
     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?: {
@@ -640,8 +603,8 @@ declare const schema$b: z.ZodObject<{
 }, z.core.$strip>;
 interface DuplicateChannelsProperties extends z.infer<typeof schema$b>, TransformNodeProperties {
 }
-declare class DuplicateChannelsStream extends BufferedTransformStream<DuplicateChannelsProperties> {
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+declare class DuplicateChannelsStream extends UnbufferedTransformStream<DuplicateChannelsProperties> {
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
 }
 declare class DuplicateChannelsNode extends TransformNode<DuplicateChannelsProperties> {
     static readonly nodeName = "Duplicate Channels";
@@ -651,9 +614,9 @@ declare class DuplicateChannelsNode extends TransformNode<DuplicateChannelsPrope
     static readonly schema: z.ZodObject<{
         channels: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof DuplicateChannelsStream;
     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?: {
@@ -666,8 +629,8 @@ declare const schema$a: z.ZodObject<{
 }, z.core.$strip>;
 interface GainProperties extends z.infer<typeof schema$a>, TransformNodeProperties {
 }
-declare class GainStream extends BufferedTransformStream<GainProperties> {
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+declare class GainStream extends UnbufferedTransformStream<GainProperties> {
+    transform(block: Block, enqueue: (block: Block) => void): void;
 }
 declare class GainNode extends TransformNode<GainProperties> {
     static readonly nodeName = "Gain";
@@ -677,9 +640,9 @@ declare class GainNode extends TransformNode<GainProperties> {
     static readonly schema: z.ZodObject<{
         gain: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof GainStream;
     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?: {
@@ -692,8 +655,8 @@ declare const schema$9: z.ZodObject<{
 }, z.core.$strip>;
 interface PanProperties extends z.infer<typeof schema$9>, TransformNodeProperties {
 }
-declare class PanStream extends BufferedTransformStream<PanProperties> {
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+declare class PanStream extends UnbufferedTransformStream<PanProperties> {
+    transform(chunk: Block, enqueue: (block: Block) => void): void;
 }
 declare class PanNode extends TransformNode<PanProperties> {
     static readonly nodeName = "Pan";
@@ -703,9 +666,9 @@ declare class PanNode extends TransformNode<PanProperties> {
     static readonly schema: z.ZodObject<{
         pan: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof PanStream;
     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?: {
@@ -718,28 +681,26 @@ interface FfmpegProperties extends TransformNodeProperties {
     readonly args?: Array<string> | ((context: StreamContext) => Array<string>);
     readonly outputSampleRate?: number;
 }
-declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extends BufferedTransformStream<P> {
+declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extends UnbufferedTransformStream<P> {
     private streamContext?;
-    private _sourceTotalFrames?;
     private child?;
+    private enqueueBlock?;
     private stdoutStash;
     private outputOffset;
     private stderr;
+    private stdinError?;
     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>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    protected _buildArgs(context: StreamContext): Array<string>;
     private spawnChild;
     private handleStdoutBytes;
-    private handleChunk;
-    private handleFlushStream;
-    _teardown(): Promise<void>;
+    transform(block: Block, enqueue: (block: Block) => void): Promise<void>;
+    flush(enqueue: (block: Block) => void): Promise<void>;
+    _destroy(): Promise<void>;
 }
 declare class FfmpegNode<P extends FfmpegProperties = FfmpegProperties> extends TransformNode<P> {
     static readonly nodeName: string;
@@ -747,10 +708,9 @@ declare class FfmpegNode<P extends FfmpegProperties = FfmpegProperties> extends
     static readonly packageVersion: string;
     static readonly nodeDescription: string;
     static readonly schema: z.ZodType;
+    static readonly streamClass: typeof FfmpegStream;
     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: {
@@ -775,11 +735,11 @@ declare const schema$8: z.ZodObject<{
 interface LoudnessTargetProperties extends z.infer<typeof schema$8>, TransformNodeProperties {
 }
 declare class LoudnessTargetStream extends BufferedTransformStream<LoudnessTargetProperties> {
+    blockSize: number;
     private winningSmoothedEnvelopeBuffer;
     private winningB;
     private winningLimitDb;
     private winningPeakGainDb;
-    private unbufferCursorsReady;
     private measurementAccumulator?;
     private capturedDetectionEnvelope;
     unbufferElapsedMs: number;
@@ -788,10 +748,11 @@ declare class LoudnessTargetStream extends BufferedTransformStream<LoudnessTarge
         detection: number;
         iteration: number;
     };
-    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
-    _process(buffer: ChunkBuffer): Promise<void>;
-    _teardown(): Promise<void>;
-    _unbuffer(chunk: AudioChunk): Promise<AudioChunk>;
+    prepare(block: Block): Promise<Block>;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    private finalize;
+    _destroy(): Promise<void>;
+    private emitApplied;
 }
 declare class LoudnessTargetNode extends TransformNode<LoudnessTargetProperties> {
     static readonly nodeName = "Loudness Target";
@@ -810,10 +771,9 @@ declare class LoudnessTargetNode extends TransformNode<LoudnessTargetProperties>
         tolerance: z.ZodDefault<z.ZodNumber>;
         peakTolerance: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof LoudnessTargetStream;
     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: {
@@ -836,11 +796,10 @@ declare const schema$7: z.ZodObject<{
 interface LoudnessNormalizeProperties extends z.infer<typeof schema$7>, TransformNodeProperties {
 }
 declare class LoudnessNormalizeStream extends BufferedTransformStream<LoudnessNormalizeProperties> {
-    private gain;
+    blockSize: number;
     private accumulator?;
-    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
-    _process(_buffer: ChunkBuffer): void;
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+    prepare(block: Block): Block;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
 }
 declare class LoudnessNormalizeNode extends TransformNode<LoudnessNormalizeProperties> {
     static readonly nodeName = "Loudness Normalize";
@@ -850,10 +809,9 @@ declare class LoudnessNormalizeNode extends TransformNode<LoudnessNormalizePrope
     static readonly schema: z.ZodObject<{
         target: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof LoudnessNormalizeStream;
     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?: {
@@ -867,11 +825,11 @@ declare const schema$6: z.ZodObject<{
 interface TruePeakNormalizeProperties extends z.infer<typeof schema$6>, TransformNodeProperties {
 }
 declare class TruePeakNormalizeStream extends BufferedTransformStream<TruePeakNormalizeProperties> {
-    private gain;
+    blockSize: number;
     private accumulator?;
-    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
-    _process(_buffer: ChunkBuffer): void;
-    _unbuffer(chunk: AudioChunk): AudioChunk;
+    prepare(block: Block): Block;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    private resolveGain;
 }
 declare class TruePeakNormalizeNode extends TransformNode<TruePeakNormalizeProperties> {
     static readonly nodeName = "True Peak Normalize";
@@ -881,10 +839,9 @@ declare class TruePeakNormalizeNode extends TransformNode<TruePeakNormalizePrope
     static readonly schema: z.ZodObject<{
         target: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof TruePeakNormalizeStream;
     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?: {
@@ -901,18 +858,14 @@ declare const schema$5: z.ZodObject<{
 interface CrestReduceProperties extends z.infer<typeof schema$5>, TransformNodeProperties {
 }
 declare class CrestReduceStream extends BufferedTransformStream<CrestReduceProperties> {
+    blockSize: number;
     private fftBackend?;
     private fftAddonOptions?;
     private truePeakAccumulator?;
-    private smoothedTrajectory?;
-    private applyOrder;
-    private applyHopSize;
-    private applyState?;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
     private get hopSize();
-    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
-    _process(buffer: ChunkBuffer): Promise<void>;
-    _unbuffer(chunk: AudioChunk): AudioChunk | undefined;
+    prepare(block: Block): Block;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
 }
 declare class CrestReduceNode extends TransformNode<CrestReduceProperties> {
     static readonly nodeName = "Crest Reduce";
@@ -925,10 +878,9 @@ declare class CrestReduceNode extends TransformNode<CrestReduceProperties> {
         vkfftAddonPath: z.ZodDefault<z.ZodString>;
         fftwAddonPath: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof CrestReduceStream;
     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?: {
@@ -958,6 +910,7 @@ declare const schema$4: z.ZodObject<{
 interface DeBleedProperties extends z.infer<typeof schema$4>, TransformNodeProperties {
 }
 declare class DeBleedStream extends BufferedTransformStream<DeBleedProperties> {
+    blockSize: number;
     private fftBackend?;
     private fftAddonOptions?;
     private dfttFftBackend?;
@@ -965,10 +918,10 @@ declare class DeBleedStream extends BufferedTransformStream<DeBleedProperties> {
     private referenceBuffers;
     private chunkFrames;
     private numBins;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
-    _teardown(): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    _destroy(): Promise<void>;
     private warmupSeedsAllChannels;
-    _process(buffer: ChunkBuffer): Promise<void>;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
 }
 declare class DeBleedNode extends TransformNode<DeBleedProperties> {
     static readonly nodeName = "De-Bleed Adaptive";
@@ -991,10 +944,9 @@ declare class DeBleedNode extends TransformNode<DeBleedProperties> {
             js: "js";
         }>>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof DeBleedStream;
     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?: {
@@ -1019,11 +971,12 @@ declare const schema$3: z.ZodObject<{
 interface DeepFilterNet3Properties extends z.infer<typeof schema$3>, TransformNodeProperties {
 }
 declare class DeepFilterNet3Stream extends BufferedTransformStream<DeepFilterNet3Properties> {
+    blockSize: number;
     private session?;
     private dfnStates;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
-    _process(buffer: ChunkBuffer): Promise<void>;
-    _teardown(): void;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _destroy(): void;
 }
 declare class DeepFilterNet3Node extends TransformNode<DeepFilterNet3Properties> {
     static readonly nodeName = "DeepFilterNet3 (Denoiser)";
@@ -1037,10 +990,9 @@ declare class DeepFilterNet3Node extends TransformNode<DeepFilterNet3Properties>
         sampleRate: z.ZodNumber;
         attenuation: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof DeepFilterNet3Stream;
     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: {
@@ -1063,12 +1015,13 @@ declare const schema$2: z.ZodObject<{
 interface DtlnProperties extends z.infer<typeof schema$2>, TransformNodeProperties {
 }
 declare class DtlnStream extends BufferedTransformStream<DtlnProperties> {
+    blockSize: number;
     private session1;
     private session2;
     private fftBackend?;
     private fftAddonOptions?;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
-    _process(buffer: ChunkBuffer): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
     private runMainPass;
 }
 declare class DtlnNode extends TransformNode<DtlnProperties> {
@@ -1084,10 +1037,9 @@ declare class DtlnNode extends TransformNode<DtlnProperties> {
         vkfftAddonPath: z.ZodDefault<z.ZodString>;
         fftwAddonPath: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof DtlnStream;
     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: {
@@ -1117,9 +1069,10 @@ interface HtdemucsProperties extends z.infer<typeof schema$1>, TransformNodeProp
     readonly stems: StemGains;
 }
 declare class HtdemucsStream extends BufferedTransformStream<HtdemucsProperties> {
+    blockSize: number;
     private session;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
-    _process(buffer: ChunkBuffer): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
     private runMainPass;
     private emitStable;
 }
@@ -1135,10 +1088,9 @@ declare class HtdemucsNode extends TransformNode<HtdemucsProperties> {
         highPass: z.ZodDefault<z.ZodNumber>;
         lowPass: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof HtdemucsStream;
     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?: {
@@ -1157,11 +1109,12 @@ declare const schema: z.ZodObject<{
 interface KimVocal2Properties extends z.infer<typeof schema>, TransformNodeProperties {
 }
 declare class KimVocal2Stream extends BufferedTransformStream<KimVocal2Properties> {
+    blockSize: number;
     private session;
     private fftInstance;
-    constructor(properties: KimVocal2Properties);
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
-    _process(buffer: ChunkBuffer): Promise<void>;
+    constructor(node: BufferedAudioNode);
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
     private runMainPass;
     private emitStable;
 }
@@ -1177,10 +1130,9 @@ declare class KimVocal2Node extends TransformNode<KimVocal2Properties> {
         highPass: z.ZodDefault<z.ZodNumber>;
         lowPass: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
+    static readonly streamClass: typeof KimVocal2Stream;
     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: {
@@ -1205,12 +1157,13 @@ interface Vst3Properties extends TransformNodeProperties {
     readonly extraArgs?: ReadonlyArray<string>;
 }
 declare class Vst3Stream<P extends Vst3Properties = Vst3Properties> extends BufferedTransformStream<P> {
+    blockSize: number;
     private streamContext?;
     private stagesJsonPath?;
     private stagesJsonCleanup?;
-    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
-    _process(buffer: ChunkBuffer): Promise<void>;
-    _teardown(): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _destroy(): Promise<void>;
 }
 declare class Vst3Node<P extends Vst3Properties = Vst3Properties> extends TransformNode<P> {
     static readonly nodeName: string;
@@ -1218,10 +1171,9 @@ declare class Vst3Node<P extends Vst3Properties = Vst3Properties> extends Transf
     static readonly packageVersion: string;
     static readonly nodeDescription: string;
     static readonly schema: z.ZodType;
+    static readonly streamClass: typeof Vst3Stream;
     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: {
@@ -1232,18 +1184,9 @@ declare function vst3(options: {
     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;
+interface Chain extends Composition {
+    to(child: BufferedAudioNode | Composition): void;
+}
+declare function chain(...items: Array<BufferedAudioNode | Composition>): Chain;
 
-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 };
+export { type Chain, 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, 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 };