@buffered-audio/nodes 0.18.1 → 0.19.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { SourceNode, SourceNodeProperties, BufferedSourceStream, SourceMetadata, Block, TargetNode, TargetNodeProperties, BufferedTargetStream, StreamContext, TransformNode, TransformNodeProperties, UnbufferedTransformStream, BufferedAudioNode, BufferedTransformStream, BlockBuffer, Composition } from '@buffered-audio/core';
+import { SourceNode, SourceNodeProperties, BufferedSourceStream, SourceMetadata, Block, TargetNode, TargetNodeProperties, BufferedTargetStream, StreamSetupContext, TransformNode, TransformNodeProperties, UnbufferedTransformStream, StreamContext, BufferedTransformStream, BlockBuffer, Composition, BufferedAudioNode } from '@buffered-audio/core';
 
 declare const ffmpegSchema: z.ZodObject<{
     path: z.ZodDefault<z.ZodString>;
@@ -9,7 +9,7 @@ declare const ffmpegSchema: z.ZodObject<{
 interface ReadFfmpegProperties extends z.infer<typeof ffmpegSchema>, SourceNodeProperties {
     readonly channels?: ReadonlyArray<number>;
 }
-declare class ReadFfmpegStream<P extends ReadFfmpegProperties = ReadFfmpegProperties> extends BufferedSourceStream<P> {
+declare class ReadFfmpegStream extends BufferedSourceStream<ReadFfmpegNode> {
     private ffmpegProcess?;
     private stdout?;
     private frameOffset;
@@ -28,15 +28,13 @@ declare class ReadFfmpegNode extends SourceNode<ReadFfmpegProperties> {
     static readonly nodeName = "Read FFmpeg";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Read audio from a file using FFmpeg";
+    static readonly description = "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>;
-    static readonly streamClass: typeof ReadFfmpegStream;
-    readonly type: readonly ["buffered-audio-node", "source", "read-ffmpeg"];
-    clone(overrides?: Partial<ReadFfmpegProperties>): ReadFfmpegNode;
+    static readonly Stream: typeof ReadFfmpegStream;
 }
 declare function readFfmpeg(path: string, options: {
     channels?: ReadonlyArray<number>;
@@ -50,7 +48,7 @@ declare const wavSchema: z.ZodObject<{
 interface ReadWavProperties extends z.infer<typeof wavSchema>, SourceNodeProperties {
     readonly channels?: ReadonlyArray<number>;
 }
-declare class ReadWavStream<P extends ReadWavProperties = ReadWavProperties> extends BufferedSourceStream<P> {
+declare class ReadWavStream extends BufferedSourceStream<ReadWavNode> {
     private fileHandle?;
     private format?;
     private bytesRead;
@@ -65,13 +63,11 @@ declare class ReadWavNode extends SourceNode<ReadWavProperties> {
     static readonly nodeName = "Read WAV";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Read audio from a WAV file";
+    static readonly description = "Read audio from a WAV file";
     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"];
-    clone(overrides?: Partial<ReadWavProperties>): ReadWavNode;
+    static readonly Stream: typeof ReadWavStream;
 }
 declare function readWav(path: string, options?: {
     channels?: ReadonlyArray<number>;
@@ -104,7 +100,7 @@ interface LoudnessStats {
     readonly range: number;
     readonly amplitude: AmplitudeDistribution;
 }
-declare class LoudnessStatsStream extends BufferedTargetStream<LoudnessStatsProperties> {
+declare class LoudnessStatsStream extends BufferedTargetStream<LoudnessStatsNode> {
     private channels;
     private sampleRate;
     private truePeakAccumulator;
@@ -114,24 +110,21 @@ declare class LoudnessStatsStream extends BufferedTargetStream<LoudnessStatsProp
     private statsInitialized;
     private fileHandle?;
     get stats(): LoudnessStats | undefined;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamSetupContext): Promise<void>;
     private ensureInit;
-    _write(chunk: Block): Promise<void>;
+    _write(chunk: Block): void;
     _close(): Promise<void>;
 }
 declare class LoudnessStatsNode extends TargetNode<LoudnessStatsProperties> {
     static readonly nodeName = "Loudness Stats";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Measure integrated loudness, true peak, and loudness range per EBU R128, plus an amplitude-distribution histogram";
+    static readonly description = "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 readonly streamClass: typeof LoudnessStatsStream;
-    static is(value: unknown): value is LoudnessStatsNode;
-    readonly type: readonly ["buffered-audio-node", "target", "loudness-stats"];
-    clone(overrides?: Partial<LoudnessStatsProperties>): LoudnessStatsNode;
+    static readonly Stream: typeof LoudnessStatsStream;
 }
 declare function loudnessStats(options?: {
     id?: string;
@@ -152,7 +145,7 @@ interface SpectrogramProperties extends z.infer<typeof schema$k>, TargetNodeProp
     readonly minFrequency?: number;
     readonly maxFrequency?: number;
 }
-declare class SpectrogramStream extends BufferedTargetStream<SpectrogramProperties> {
+declare class SpectrogramStream extends BufferedTargetStream<SpectrogramNode> {
     private fileHandle?;
     private channels;
     private linearBins;
@@ -172,7 +165,7 @@ declare class SpectrogramStream extends BufferedTargetStream<SpectrogramProperti
     private writeBufferFileOffset;
     private readonly WRITE_BATCH_FRAMES;
     private initialized;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamSetupContext): Promise<void>;
     private initialize;
     _write(chunk: Block): Promise<void>;
     _close(): Promise<void>;
@@ -184,17 +177,14 @@ declare class SpectrogramNode extends TargetNode<SpectrogramProperties> {
     static readonly nodeName = "Spectrogram";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Generate spectrogram visualization data";
+    static readonly description = "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 readonly streamClass: typeof SpectrogramStream;
-    static is(value: unknown): value is SpectrogramNode;
-    readonly type: readonly ["buffered-audio-node", "target", "spectrogram"];
-    clone(overrides?: Partial<SpectrogramProperties>): SpectrogramNode;
+    static readonly Stream: typeof SpectrogramStream;
 }
 declare function spectrogram(outputPath: string, options?: {
     fftSize?: number;
@@ -212,7 +202,7 @@ declare const schema$j: z.ZodObject<{
 }, z.core.$strip>;
 interface WaveformProperties extends z.infer<typeof schema$j>, TargetNodeProperties {
 }
-declare class WaveformStream extends BufferedTargetStream<WaveformProperties> {
+declare class WaveformStream extends BufferedTargetStream<WaveformNode> {
     private fileHandle?;
     private channels;
     private samplesPerPoint;
@@ -226,7 +216,7 @@ declare class WaveformStream extends BufferedTargetStream<WaveformProperties> {
     private writeBufferFileOffset;
     private readonly WRITE_BATCH_POINTS;
     private initialized;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamSetupContext): Promise<void>;
     private initialize;
     private writeHeader;
     _write(chunk: Block): Promise<void>;
@@ -238,15 +228,12 @@ declare class WaveformNode extends TargetNode<WaveformProperties> {
     static readonly nodeName = "Waveform";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Generate waveform visualization data";
+    static readonly description = "Generate waveform visualization data";
     static readonly schema: z.ZodObject<{
         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"];
-    clone(overrides?: Partial<WaveformProperties>): WaveformNode;
+    static readonly Stream: typeof WaveformStream;
 }
 declare function waveform(outputPath: string, options?: {
     resolution?: number;
@@ -265,7 +252,7 @@ interface WriteProperties extends TargetNodeProperties {
     readonly bitDepth: WavBitDepth;
     readonly encoding?: EncodingOptions;
 }
-declare class WriteStream extends BufferedTargetStream<WriteProperties> {
+declare class WriteStream extends BufferedTargetStream<WriteNode> {
     private fileHandle?;
     private ffmpegProcess?;
     private ffmpegStdin?;
@@ -275,7 +262,7 @@ declare class WriteStream extends BufferedTargetStream<WriteProperties> {
     private bytesWritten;
     private useEncoding;
     private initialized;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<void>;
+    _setup(input: ReadableStream<Block>, context: StreamSetupContext): Promise<void>;
     private initialize;
     private spawnFfmpeg;
     _write(chunk: Block): Promise<void>;
@@ -289,7 +276,7 @@ declare class WriteNode extends TargetNode<WriteProperties> {
     static readonly nodeName = "Write";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Write audio to a file";
+    static readonly description = "Write audio to a file";
     static readonly schema: z.ZodObject<{
         path: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -311,9 +298,7 @@ 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"];
-    clone(overrides?: Partial<WriteProperties>): WriteNode;
+    static readonly Stream: typeof WriteStream;
 }
 declare function write(path: string, options?: {
     bitDepth?: WavBitDepth;
@@ -334,27 +319,24 @@ 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 UnbufferedTransformStream<CutProperties> {
+declare class CutStream extends UnbufferedTransformStream<CutNode> {
     private sortedRegions;
     private removedFrames;
-    constructor(node: BufferedAudioNode);
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
+    constructor(node: CutNode, context: StreamContext);
+    _transform(chunk: Block): Generator<Block>;
 }
 declare class CutNode extends TransformNode<CutProperties> {
     static readonly nodeName = "Cut";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Remove a region of audio";
+    static readonly description = "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 readonly streamClass: typeof CutStream;
-    static is(value: unknown): value is CutNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "cut"];
-    clone(overrides?: Partial<CutProperties>): CutNode;
+    static readonly Stream: typeof CutStream;
 }
 declare function cut(regions: Array<CutRegion>, options?: {
     id?: string;
@@ -366,23 +348,20 @@ declare const schema$h: z.ZodObject<{
 }, z.core.$strip>;
 interface DitherProperties extends z.infer<typeof schema$h>, TransformNodeProperties {
 }
-declare class DitherStream extends UnbufferedTransformStream<DitherProperties> {
+declare class DitherStream extends UnbufferedTransformStream<DitherNode> {
     private lastError;
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
+    _transform(chunk: Block): Generator<Block>;
 }
 declare class DitherNode extends TransformNode<DitherProperties> {
     static readonly nodeName = "Dither";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Add shaped noise to reduce quantization distortion";
+    static readonly description = "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 readonly streamClass: typeof DitherStream;
-    static is(value: unknown): value is DitherNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "dither"];
-    clone(overrides?: Partial<DitherProperties>): DitherNode;
+    static readonly Stream: typeof DitherStream;
 }
 declare function dither(bitDepth: 16 | 24, options?: {
     noiseShaping?: boolean;
@@ -394,24 +373,21 @@ declare const schema$g: z.ZodObject<{
 }, z.core.$strip>;
 interface NormalizeProperties extends z.infer<typeof schema$g>, TransformNodeProperties {
 }
-declare class NormalizeStream extends BufferedTransformStream<NormalizeProperties> {
+declare class NormalizeStream extends BufferedTransformStream<NormalizeNode> {
     blockSize: number;
     private peak;
-    prepare(block: Block): Block;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _prepare(block: Block): Block;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
 }
 declare class NormalizeNode extends TransformNode<NormalizeProperties> {
     static readonly nodeName = "Normalize";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Adjust peak or loudness level to a target ceiling";
+    static readonly description = "Adjust peak or loudness level to a target ceiling";
     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"];
-    clone(overrides?: Partial<NormalizeProperties>): NormalizeNode;
+    static readonly Stream: typeof NormalizeStream;
 }
 declare function normalize(options?: {
     ceiling?: number;
@@ -424,28 +400,25 @@ declare const schema$f: z.ZodObject<{
 }, z.core.$strip>;
 interface PadProperties extends z.infer<typeof schema$f>, TransformNodeProperties {
 }
-declare class PadStream extends UnbufferedTransformStream<PadProperties> {
+declare class PadStream extends UnbufferedTransformStream<PadNode> {
     private seenChunk;
     private capturedSampleRate;
     private capturedBitDepth;
     private capturedChannels;
     private outputOffset;
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
-    flush(enqueue: (block: Block) => void): void;
+    _transform(chunk: Block): Generator<Block>;
+    _flush(): Generator<Block>;
 }
 declare class PadNode extends TransformNode<PadProperties> {
     static readonly nodeName = "Pad";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Add silence to start or end of audio";
+    static readonly description = "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 readonly streamClass: typeof PadStream;
-    static is(value: unknown): value is PadNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "pad"];
-    clone(overrides?: Partial<PadProperties>): PadNode;
+    static readonly Stream: typeof PadStream;
 }
 declare function pad(options: {
     before?: number;
@@ -459,9 +432,9 @@ declare const schema$e: z.ZodObject<{
 }, z.core.$strip>;
 interface PhaseProperties extends z.infer<typeof schema$e>, TransformNodeProperties {
 }
-declare class PhaseStream extends UnbufferedTransformStream<PhaseProperties> {
+declare class PhaseStream extends UnbufferedTransformStream<PhaseNode> {
     private allpassState;
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
+    _transform(chunk: Block): Generator<Block>;
     private applyInvert;
     private applyPhaseRotation;
 }
@@ -469,15 +442,12 @@ declare class PhaseNode extends TransformNode<PhaseProperties> {
     static readonly nodeName = "Phase";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Invert or rotate signal phase";
+    static readonly description = "Invert or rotate signal phase";
     static readonly schema: z.ZodObject<{
         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"];
-    clone(overrides?: Partial<PhaseProperties>): PhaseNode;
+    static readonly Stream: typeof PhaseStream;
 }
 declare function phase(options?: {
     invert?: boolean;
@@ -490,18 +460,15 @@ declare function invert(options?: {
 
 declare class ReverseStream extends BufferedTransformStream {
     blockSize: number;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
 }
 declare class ReverseNode extends TransformNode {
     static readonly nodeName = "Reverse";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Reverse audio playback direction";
+    static readonly description = "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"];
-    clone(overrides?: Partial<TransformNodeProperties>): ReverseNode;
+    static readonly Stream: typeof ReverseStream;
 }
 declare function reverse(options?: {
     id?: string;
@@ -514,27 +481,24 @@ declare const schema$d: z.ZodObject<{
 interface SpliceProperties extends z.infer<typeof schema$d>, TransformNodeProperties {
     readonly channels?: ReadonlyArray<number>;
 }
-declare class SpliceStream extends UnbufferedTransformStream<SpliceProperties> {
+declare class SpliceStream extends UnbufferedTransformStream<SpliceNode> {
     private insertSamples;
     private insertSampleRate;
     private insertLength;
     private sampleRateChecked;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
+    _setup(_context: StreamSetupContext): Promise<void>;
+    _transform(chunk: Block): Generator<Block>;
 }
 declare class SpliceNode extends TransformNode<SpliceProperties> {
     static readonly nodeName = "Splice";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Replace a region of audio with processed content";
+    static readonly description = "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 readonly streamClass: typeof SpliceStream;
-    static is(value: unknown): value is SpliceNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "splice"];
-    clone(overrides?: Partial<SpliceProperties>): SpliceNode;
+    static readonly Stream: typeof SpliceStream;
 }
 declare function splice(insertPath: string, insertAt: number, options?: {
     channels?: ReadonlyArray<number>;
@@ -548,29 +512,26 @@ declare const schema$c: z.ZodObject<{
 }, z.core.$strip>;
 interface TrimProperties extends z.infer<typeof schema$c>, TransformNodeProperties {
 }
-declare class TrimStream extends BufferedTransformStream<TrimProperties> {
+declare class TrimStream extends BufferedTransformStream<TrimNode> {
     blockSize: number;
     private firstAbove;
     private lastAbove;
     private scanOffset;
-    prepare(block: Block): Block;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _prepare(block: Block): Block;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
 }
 declare class TrimNode extends TransformNode<TrimProperties> {
     static readonly nodeName = "Trim";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Remove silence from start and end";
+    static readonly description = "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 readonly streamClass: typeof TrimStream;
-    static is(value: unknown): value is TrimNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "trim"];
-    clone(overrides?: Partial<TrimProperties>): TrimNode;
+    static readonly Stream: typeof TrimStream;
 }
 declare function trim(options?: {
     threshold?: number;
@@ -581,18 +542,15 @@ declare function trim(options?: {
 }): TrimNode;
 
 declare class DownmixMonoStream extends UnbufferedTransformStream {
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
+    _transform(chunk: Block): Generator<Block>;
 }
 declare class DownmixMonoNode extends TransformNode {
     static readonly nodeName = "Downmix Mono";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Mix all input channels to a single mono channel by averaging";
+    static readonly description = "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"];
-    clone(overrides?: Partial<TransformNodeProperties>): DownmixMonoNode;
+    static readonly Stream: typeof DownmixMonoStream;
 }
 declare function downmixMono(options?: {
     id?: string;
@@ -603,21 +561,18 @@ declare const schema$b: z.ZodObject<{
 }, z.core.$strip>;
 interface DuplicateChannelsProperties extends z.infer<typeof schema$b>, TransformNodeProperties {
 }
-declare class DuplicateChannelsStream extends UnbufferedTransformStream<DuplicateChannelsProperties> {
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
+declare class DuplicateChannelsStream extends UnbufferedTransformStream<DuplicateChannelsNode> {
+    _transform(chunk: Block): Generator<Block>;
 }
 declare class DuplicateChannelsNode extends TransformNode<DuplicateChannelsProperties> {
     static readonly nodeName = "Duplicate Channels";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Duplicate a mono signal into multiple identical output channels; requires exactly 1 input channel, throws otherwise";
+    static readonly description = "Duplicate a mono signal into multiple identical output channels; requires exactly 1 input channel, throws otherwise";
     static readonly schema: z.ZodObject<{
         channels: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
-    static readonly streamClass: typeof DuplicateChannelsStream;
-    static is(value: unknown): value is DuplicateChannelsNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "duplicate-channels"];
-    clone(overrides?: Partial<DuplicateChannelsProperties>): DuplicateChannelsNode;
+    static readonly Stream: typeof DuplicateChannelsStream;
 }
 declare function duplicateChannels(options?: {
     channels?: number;
@@ -629,21 +584,18 @@ declare const schema$a: z.ZodObject<{
 }, z.core.$strip>;
 interface GainProperties extends z.infer<typeof schema$a>, TransformNodeProperties {
 }
-declare class GainStream extends UnbufferedTransformStream<GainProperties> {
-    transform(block: Block, enqueue: (block: Block) => void): void;
+declare class GainStream extends UnbufferedTransformStream<GainNode> {
+    _transform(block: Block): Generator<Block>;
 }
 declare class GainNode extends TransformNode<GainProperties> {
     static readonly nodeName = "Gain";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Adjust signal level by a fixed amount in dB";
+    static readonly description = "Adjust signal level by a fixed amount in dB";
     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"];
-    clone(overrides?: Partial<GainProperties>): GainNode;
+    static readonly Stream: typeof GainStream;
 }
 declare function gain(options?: {
     gain?: number;
@@ -655,21 +607,18 @@ declare const schema$9: z.ZodObject<{
 }, z.core.$strip>;
 interface PanProperties extends z.infer<typeof schema$9>, TransformNodeProperties {
 }
-declare class PanStream extends UnbufferedTransformStream<PanProperties> {
-    transform(chunk: Block, enqueue: (block: Block) => void): void;
+declare class PanStream extends UnbufferedTransformStream<PanNode> {
+    _transform(chunk: Block): Generator<Block>;
 }
 declare class PanNode extends TransformNode<PanProperties> {
     static readonly nodeName = "Pan";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Position mono signal in stereo field or adjust stereo balance; throws for inputs with more than 2 channels";
+    static readonly description = "Position mono signal in stereo field or adjust stereo balance; throws for inputs with more than 2 channels";
     static readonly schema: z.ZodObject<{
         pan: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
-    static readonly streamClass: typeof PanStream;
-    static is(value: unknown): value is PanNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "pan"];
-    clone(overrides?: Partial<PanProperties>): PanNode;
+    static readonly Stream: typeof PanStream;
 }
 declare function pan(options?: {
     pan?: number;
@@ -678,13 +627,13 @@ declare function pan(options?: {
 
 interface FfmpegProperties extends TransformNodeProperties {
     readonly ffmpegPath: string;
-    readonly args?: Array<string> | ((context: StreamContext) => Array<string>);
+    readonly args?: Array<string> | ((context: StreamSetupContext) => Array<string>);
     readonly outputSampleRate?: number;
 }
-declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extends UnbufferedTransformStream<P> {
+declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extends UnbufferedTransformStream<FfmpegNode<P>> {
     private streamContext?;
     private child?;
-    private enqueueBlock?;
+    private readonly pending;
     private stdoutStash;
     private outputOffset;
     private stderr;
@@ -694,28 +643,25 @@ declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extend
     private pendingDrain?;
     private inputSampleRate;
     private inputChannels;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
-    protected _buildArgs(context: StreamContext): Array<string>;
+    _setup(context: StreamSetupContext): void;
+    protected _buildArgs(context: StreamSetupContext): Array<string>;
     private spawnChild;
     private handleStdoutBytes;
-    transform(block: Block, enqueue: (block: Block) => void): Promise<void>;
-    flush(enqueue: (block: Block) => void): Promise<void>;
+    _transform(block: Block): AsyncGenerator<Block>;
+    _flush(): AsyncGenerator<Block>;
     _destroy(): Promise<void>;
 }
 declare class FfmpegNode<P extends FfmpegProperties = FfmpegProperties> extends TransformNode<P> {
     static readonly nodeName: string;
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription: string;
+    static readonly description: string;
     static readonly schema: z.ZodType;
-    static readonly streamClass: typeof FfmpegStream;
-    static is(value: unknown): value is FfmpegNode;
-    readonly type: ReadonlyArray<string>;
-    clone(overrides?: Partial<P>): FfmpegNode<P>;
+    static readonly Stream: typeof FfmpegStream;
 }
 declare function ffmpeg(options: {
     ffmpegPath: string;
-    args: Array<string> | ((context: StreamContext) => Array<string>);
+    args: Array<string> | ((context: StreamSetupContext) => Array<string>);
     outputSampleRate?: number;
     id?: string;
 }): FfmpegNode;
@@ -734,7 +680,7 @@ declare const schema$8: z.ZodObject<{
 }, z.core.$strip>;
 interface LoudnessTargetProperties extends z.infer<typeof schema$8>, TransformNodeProperties {
 }
-declare class LoudnessTargetStream extends BufferedTransformStream<LoudnessTargetProperties> {
+declare class LoudnessTargetStream extends BufferedTransformStream<LoudnessTargetNode> {
     blockSize: number;
     private winningSmoothedEnvelopeBuffer;
     private winningB;
@@ -748,8 +694,8 @@ declare class LoudnessTargetStream extends BufferedTransformStream<LoudnessTarge
         detection: number;
         iteration: number;
     };
-    prepare(block: Block): Promise<Block>;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _prepare(block: Block): Promise<Block>;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
     private finalize;
     _destroy(): Promise<void>;
     private emitApplied;
@@ -758,7 +704,7 @@ declare class LoudnessTargetNode extends TransformNode<LoudnessTargetProperties>
     static readonly nodeName = "Loudness Target";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Peak-aware content-adaptive curve fitting (LUFS, true-peak, LRA) via a single combined gain envelope with a peak-respecting two-stage smoother. The upper-arm peak anchor jointly iterates with the body gain to land both LUFS and true-peak targets in one envelope.";
+    static readonly description = "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>;
@@ -771,10 +717,7 @@ 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"];
-    clone(overrides?: Partial<LoudnessTargetProperties>): LoudnessTargetNode;
+    static readonly Stream: typeof LoudnessTargetStream;
 }
 declare function loudnessTarget(options: {
     targetLufs?: number;
@@ -795,24 +738,21 @@ declare const schema$7: z.ZodObject<{
 }, z.core.$strip>;
 interface LoudnessNormalizeProperties extends z.infer<typeof schema$7>, TransformNodeProperties {
 }
-declare class LoudnessNormalizeStream extends BufferedTransformStream<LoudnessNormalizeProperties> {
+declare class LoudnessNormalizeStream extends BufferedTransformStream<LoudnessNormalizeNode> {
     blockSize: number;
     private accumulator?;
-    prepare(block: Block): Block;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _prepare(block: Block): Block;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
 }
 declare class LoudnessNormalizeNode extends TransformNode<LoudnessNormalizeProperties> {
     static readonly nodeName = "Loudness Normalize";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Measure integrated loudness (BS.1770) and apply a single linear gain to hit a target LUFS \u2014 no limiting, no dynamics";
+    static readonly description = "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 readonly streamClass: typeof LoudnessNormalizeStream;
-    static is(value: unknown): value is LoudnessNormalizeNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "loudness-normalize"];
-    clone(overrides?: Partial<LoudnessNormalizeProperties>): LoudnessNormalizeNode;
+    static readonly Stream: typeof LoudnessNormalizeStream;
 }
 declare function loudnessNormalize(options?: {
     target?: number;
@@ -824,25 +764,22 @@ declare const schema$6: z.ZodObject<{
 }, z.core.$strip>;
 interface TruePeakNormalizeProperties extends z.infer<typeof schema$6>, TransformNodeProperties {
 }
-declare class TruePeakNormalizeStream extends BufferedTransformStream<TruePeakNormalizeProperties> {
+declare class TruePeakNormalizeStream extends BufferedTransformStream<TruePeakNormalizeNode> {
     blockSize: number;
     private accumulator?;
-    prepare(block: Block): Block;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _prepare(block: Block): Block;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
     private resolveGain;
 }
 declare class TruePeakNormalizeNode extends TransformNode<TruePeakNormalizeProperties> {
     static readonly nodeName = "True Peak Normalize";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Measure source true peak (4\u00D7 upsampled, BS.1770-4 style) and apply a single linear gain to hit a target dBTP";
+    static readonly description = "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 readonly streamClass: typeof TruePeakNormalizeStream;
-    static is(value: unknown): value is TruePeakNormalizeNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "true-peak-normalize"];
-    clone(overrides?: Partial<TruePeakNormalizeProperties>): TruePeakNormalizeNode;
+    static readonly Stream: typeof TruePeakNormalizeStream;
 }
 declare function truePeakNormalize(options?: {
     target?: number;
@@ -857,31 +794,28 @@ declare const schema$5: z.ZodObject<{
 }, z.core.$strip>;
 interface CrestReduceProperties extends z.infer<typeof schema$5>, TransformNodeProperties {
 }
-declare class CrestReduceStream extends BufferedTransformStream<CrestReduceProperties> {
+declare class CrestReduceStream extends BufferedTransformStream<CrestReduceNode> {
     blockSize: number;
     private fftBackend?;
     private fftAddonOptions?;
     private truePeakAccumulator?;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    _setup(context: StreamSetupContext): void;
     private get hopSize();
-    prepare(block: Block): Block;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _prepare(block: Block): Block;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
 }
 declare class CrestReduceNode extends TransformNode<CrestReduceProperties> {
     static readonly nodeName = "Crest Reduce";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Content-adaptive, magnitude-preserving, phase-only crest-factor reducer \u2014 a pre-limiter headroom stage that rearranges signal phase to flatten true-peak excursions without changing the magnitude spectrum, never increasing crest factor";
+    static readonly description = "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 readonly streamClass: typeof CrestReduceStream;
-    static is(value: unknown): value is CrestReduceNode;
-    readonly type: readonly ["buffered-audio-node", "transform", "crest-reduce"];
-    clone(overrides?: Partial<CrestReduceProperties>): CrestReduceNode;
+    static readonly Stream: typeof CrestReduceStream;
 }
 declare function crestReduce(options?: {
     smoothing?: number;
@@ -909,7 +843,7 @@ declare const schema$4: z.ZodObject<{
 }, z.core.$strip>;
 interface DeBleedProperties extends z.infer<typeof schema$4>, TransformNodeProperties {
 }
-declare class DeBleedStream extends BufferedTransformStream<DeBleedProperties> {
+declare class DeBleedStream extends BufferedTransformStream<DeBleedNode> {
     blockSize: number;
     private fftBackend?;
     private fftAddonOptions?;
@@ -918,16 +852,17 @@ declare class DeBleedStream extends BufferedTransformStream<DeBleedProperties> {
     private referenceBuffers;
     private chunkFrames;
     private numBins;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
+    private nlmPool?;
+    _setup(context: StreamSetupContext): Promise<void>;
     _destroy(): Promise<void>;
     private warmupSeedsAllChannels;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
 }
 declare class DeBleedNode extends TransformNode<DeBleedProperties> {
     static readonly nodeName = "De-Bleed Adaptive";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Adaptive (MEF FDAF Kalman + MWF + MSAD) reference-based microphone bleed reduction. Stages 1+2 are MEF Meyer-Elshamy-Fingscheidt 2020; Stage 3 is Lukin-Todd 2D NLM+DFTT post-filter.";
+    static readonly description = "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>;
@@ -944,10 +879,7 @@ 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"];
-    clone(overrides?: Partial<DeBleedProperties>): DeBleedNode;
+    static readonly Stream: typeof DeBleedStream;
 }
 declare function deBleed(references: string | ReadonlyArray<string>, options?: {
     reductionStrength?: number;
@@ -970,19 +902,24 @@ declare const schema$3: z.ZodObject<{
 }, z.core.$strip>;
 interface DeepFilterNet3Properties extends z.infer<typeof schema$3>, TransformNodeProperties {
 }
-declare class DeepFilterNet3Stream extends BufferedTransformStream<DeepFilterNet3Properties> {
+declare class DeepFilterNet3Stream extends BufferedTransformStream<DeepFilterNet3Node> {
     blockSize: number;
     private session?;
     private dfnStates;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    private readonly renderContext;
+    private upResample?;
+    private downResample?;
+    constructor(node: DeepFilterNet3Node, context: StreamContext);
+    _setup(context: StreamSetupContext): void;
+    _pipe(input: ReadableStream<Block>): ReadableStream<Block>;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
     _destroy(): void;
 }
 declare class DeepFilterNet3Node extends TransformNode<DeepFilterNet3Properties> {
     static readonly nodeName = "DeepFilterNet3 (Denoiser)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Remove background noise from speech using DeepFilterNet3 (48 kHz full-band CRN)";
+    static readonly description = "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>;
@@ -990,10 +927,7 @@ 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"];
-    clone(overrides?: Partial<DeepFilterNet3Properties>): DeepFilterNet3Node;
+    static readonly Stream: typeof DeepFilterNet3Stream;
 }
 declare function deepFilterNet3(options: {
     modelPath: string;
@@ -1014,21 +948,21 @@ declare const schema$2: z.ZodObject<{
 }, z.core.$strip>;
 interface DtlnProperties extends z.infer<typeof schema$2>, TransformNodeProperties {
 }
-declare class DtlnStream extends BufferedTransformStream<DtlnProperties> {
+declare class DtlnStream extends BufferedTransformStream<DtlnNode> {
     blockSize: number;
     private session1;
     private session2;
     private fftBackend?;
     private fftAddonOptions?;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _setup(context: StreamSetupContext): void;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
     private runMainPass;
 }
 declare class DtlnNode extends TransformNode<DtlnProperties> {
     static readonly nodeName = "DTLN (Denoiser)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Remove background noise from speech using DTLN neural network";
+    static readonly description = "Remove background noise from speech using DTLN neural network";
     static readonly schema: z.ZodObject<{
         modelPath1: z.ZodDefault<z.ZodString>;
         modelPath2: z.ZodDefault<z.ZodString>;
@@ -1037,10 +971,7 @@ 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"];
-    clone(overrides?: Partial<DtlnProperties>): DtlnNode;
+    static readonly Stream: typeof DtlnStream;
 }
 declare function dtln(options: {
     modelPath1: string;
@@ -1068,11 +999,11 @@ declare const schema$1: z.ZodObject<{
 interface HtdemucsProperties extends z.infer<typeof schema$1>, TransformNodeProperties {
     readonly stems: StemGains;
 }
-declare class HtdemucsStream extends BufferedTransformStream<HtdemucsProperties> {
+declare class HtdemucsStream extends BufferedTransformStream<HtdemucsNode> {
     blockSize: number;
     private session;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _setup(_context: StreamSetupContext): void;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
     private runMainPass;
     private emitStable;
 }
@@ -1080,7 +1011,7 @@ declare class HtdemucsNode extends TransformNode<HtdemucsProperties> {
     static readonly nodeName = "HTDemucs (Stem Separator)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Rebalance stem volumes using HTDemucs source separation";
+    static readonly description = "Rebalance stem volumes using HTDemucs source separation";
     static readonly schema: z.ZodObject<{
         modelPath: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -1088,10 +1019,7 @@ 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"];
-    clone(overrides?: Partial<HtdemucsProperties>): HtdemucsNode;
+    static readonly Stream: typeof HtdemucsStream;
 }
 declare function htdemucs(modelPath: string, stems: Partial<StemGains>, options?: {
     ffmpegPath?: string;
@@ -1108,13 +1036,13 @@ declare const schema: z.ZodObject<{
 }, z.core.$strip>;
 interface KimVocal2Properties extends z.infer<typeof schema>, TransformNodeProperties {
 }
-declare class KimVocal2Stream extends BufferedTransformStream<KimVocal2Properties> {
+declare class KimVocal2Stream extends BufferedTransformStream<KimVocal2Node> {
     blockSize: number;
     private session;
     private fftInstance;
-    constructor(node: BufferedAudioNode);
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    constructor(node: KimVocal2Node, context: StreamContext);
+    _setup(context: StreamSetupContext): void;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
     private runMainPass;
     private emitStable;
 }
@@ -1122,7 +1050,7 @@ declare class KimVocal2Node extends TransformNode<KimVocal2Properties> {
     static readonly nodeName = "Kim Vocal 2 (Stem Separator)";
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription = "Isolate dialogue from background using MDX-Net vocal separation";
+    static readonly description = "Isolate dialogue from background using MDX-Net vocal separation";
     static readonly schema: z.ZodObject<{
         modelPath: z.ZodDefault<z.ZodString>;
         ffmpegPath: z.ZodDefault<z.ZodString>;
@@ -1130,10 +1058,7 @@ 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"];
-    clone(overrides?: Partial<KimVocal2Properties>): KimVocal2Node;
+    static readonly Stream: typeof KimVocal2Stream;
 }
 declare function kimVocal2(options: {
     modelPath: string;
@@ -1156,25 +1081,22 @@ interface Vst3Properties extends TransformNodeProperties {
     readonly bypass?: boolean;
     readonly extraArgs?: ReadonlyArray<string>;
 }
-declare class Vst3Stream<P extends Vst3Properties = Vst3Properties> extends BufferedTransformStream<P> {
+declare class Vst3Stream<P extends Vst3Properties = Vst3Properties> extends BufferedTransformStream<Vst3Node<P>> {
     blockSize: number;
     private streamContext?;
     private stagesJsonPath?;
     private stagesJsonCleanup?;
-    _setup(input: ReadableStream<Block>, context: StreamContext): Promise<ReadableStream<Block>>;
-    transform(buffered: BlockBuffer, enqueue: (block: Block) => void): Promise<void>;
+    _setup(context: StreamSetupContext): Promise<void>;
+    _transform(buffered: BlockBuffer): AsyncGenerator<Block>;
     _destroy(): Promise<void>;
 }
 declare class Vst3Node<P extends Vst3Properties = Vst3Properties> extends TransformNode<P> {
     static readonly nodeName: string;
     static readonly packageName: string;
     static readonly packageVersion: string;
-    static readonly nodeDescription: string;
+    static readonly description: string;
     static readonly schema: z.ZodType;
-    static readonly streamClass: typeof Vst3Stream;
-    static is(value: unknown): value is Vst3Node;
-    readonly type: ReadonlyArray<string>;
-    clone(overrides?: Partial<P>): Vst3Node<P>;
+    static readonly Stream: typeof Vst3Stream;
 }
 declare function vst3(options: {
     vstHostPath: string;