@nodetool-ai/base-nodes 0.7.0-rc.11

package/dist/nodes/lib-audio-effects.js

@@ -0,0 +1,905 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseNode, prop } from "@nodetool-ai/node-sdk";
+import { audioRefFromWav, decodeWav, encodeWav } from "../lib/audio-wav.js";
+// ── DSP helpers ────────────────────────────────────────────────────
+function processPerChannel(wav, fn) {
+    const { samples, sampleRate, numChannels } = wav;
+    const frameSamples = Math.floor(samples.length / numChannels);
+    const channels = [];
+    for (let ch = 0; ch < numChannels; ch++) {
+        const channelData = new Float32Array(frameSamples);
+        for (let i = 0; i < frameSamples; i++) {
+            channelData[i] = samples[i * numChannels + ch];
+        }
+        channels.push(fn(channelData, sampleRate));
+    }
+    const outFrames = channels[0].length;
+    const outSamples = new Float32Array(outFrames * numChannels);
+    for (let ch = 0; ch < numChannels; ch++) {
+        for (let i = 0; i < outFrames; i++) {
+            outSamples[i * numChannels + ch] = channels[ch][i];
+        }
+    }
+    return { samples: outSamples, sampleRate, numChannels };
+}
+// ── Bitcrush ──────────────────────────────────────────────────────
+export class BitcrushNode extends BaseNode {
+    static nodeType = "lib.audio.Bitcrush";
+    static title = "Bitcrush";
+    static description = "Applies a bitcrushing effect to an audio file, reducing bit depth and/or sample rate.\n    audio, effect, distortion\n\n    Use cases:\n    - Create lo-fi or retro-style audio effects\n    - Simulate vintage digital audio equipment\n    - Add digital distortion and artifacts to sounds";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const bitDepth = Number(this.bit_depth ?? 8);
+        const srrFactor = Number(this.sample_rate_reduction ?? 1);
+        if (!audio.data)
+            return { output: audio };
+        const wav = decodeWav(audio);
+        const result = processPerChannel(wav, (ch) => {
+            const levels = Math.pow(2, bitDepth - 1) - 1;
+            const out = new Float32Array(ch.length);
+            for (let i = 0; i < ch.length; i++) {
+                const idx = Math.floor(i / srrFactor) * srrFactor;
+                const srcIdx = Math.min(idx, ch.length - 1);
+                out[i] = Math.round(ch[srcIdx] * levels) / levels;
+            }
+            return out;
+        });
+        return {
+            output: audioRefFromWav(encodeWav(result.samples, result.sampleRate, result.numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], BitcrushNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 8,
+        title: "Bit Depth",
+        description: "The bit depth to reduce the audio to. Lower values create more distortion.",
+        min: 1,
+        max: 16
+    })
+], BitcrushNode.prototype, "bit_depth", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Sample Rate Reduction",
+        description: "Factor by which to reduce the sample rate. Higher values create more aliasing.",
+        min: 1,
+        max: 100
+    })
+], BitcrushNode.prototype, "sample_rate_reduction", void 0);
+// ── Compress ──────────────────────────────────────────────────────
+export class CompressNode extends BaseNode {
+    static nodeType = "lib.audio.Compress";
+    static title = "Compress";
+    static description = "Applies dynamic range compression to an audio file.\n    audio, effect, dynamics\n\n    Use cases:\n    - Even out volume levels in a recording\n    - Increase perceived loudness of audio\n    - Control peaks in audio signals";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const thresholdDb = Number(this.threshold ?? -20);
+        const ratio = Number(this.ratio ?? 4);
+        const attackMs = Number(this.attack ?? 5);
+        const releaseMs = Number(this.release ?? 50);
+        if (!audio.data)
+            return { output: audio };
+        const wav = decodeWav(audio);
+        const result = processPerChannel(wav, (ch, sr) => {
+            const out = new Float32Array(ch.length);
+            const attackCoeff = Math.exp(-1 / ((sr * attackMs) / 1000));
+            const releaseCoeff = Math.exp(-1 / ((sr * releaseMs) / 1000));
+            const thresholdLin = Math.pow(10, thresholdDb / 20);
+            let envelope = 0;
+            for (let i = 0; i < ch.length; i++) {
+                const absVal = Math.abs(ch[i]);
+                if (absVal > envelope) {
+                    envelope = attackCoeff * envelope + (1 - attackCoeff) * absVal;
+                }
+                else {
+                    envelope = releaseCoeff * envelope + (1 - releaseCoeff) * absVal;
+                }
+                if (envelope > thresholdLin) {
+                    const dbOver = 20 * Math.log10(envelope / thresholdLin);
+                    const dbReduction = dbOver * (1 - 1 / ratio);
+                    const gainReduction = Math.pow(10, -dbReduction / 20);
+                    out[i] = ch[i] * gainReduction;
+                }
+                else {
+                    out[i] = ch[i];
+                }
+            }
+            return out;
+        });
+        return {
+            output: audioRefFromWav(encodeWav(result.samples, result.sampleRate, result.numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], CompressNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: -20,
+        title: "Threshold",
+        description: "Threshold in dB above which compression is applied.",
+        min: -60,
+        max: 0
+    })
+], CompressNode.prototype, "threshold", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 4,
+        title: "Ratio",
+        description: "Compression ratio. Higher values result in more compression.",
+        min: 1,
+        max: 20
+    })
+], CompressNode.prototype, "ratio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 5,
+        title: "Attack",
+        description: "Attack time in milliseconds.",
+        min: 0.1,
+        max: 100
+    })
+], CompressNode.prototype, "attack", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 50,
+        title: "Release",
+        description: "Release time in milliseconds.",
+        min: 5,
+        max: 1000
+    })
+], CompressNode.prototype, "release", void 0);
+// ── Distortion ────────────────────────────────────────────────────
+export class DistortionNode extends BaseNode {
+    static nodeType = "lib.audio.Distortion";
+    static title = "Distortion";
+    static description = "Applies a distortion effect to an audio file.\n    audio, effect, distortion\n\n    Use cases:\n    - Add grit and character to instruments\n    - Create aggressive sound effects\n    - Simulate overdriven amplifiers";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const driveDb = Number(this.drive_db ?? 25);
+        if (!audio.data)
+            return { output: audio };
+        const wav = decodeWav(audio);
+        const drive = Math.pow(10, driveDb / 20);
+        const result = processPerChannel(wav, (ch) => {
+            const out = new Float32Array(ch.length);
+            for (let i = 0; i < ch.length; i++) {
+                const driven = ch[i] * drive;
+                out[i] = (2 / Math.PI) * Math.atan(driven);
+            }
+            return out;
+        });
+        return {
+            output: audioRefFromWav(encodeWav(result.samples, result.sampleRate, result.numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], DistortionNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 25,
+        title: "Drive Db",
+        description: "Amount of distortion to apply in decibels.",
+        min: 0,
+        max: 100
+    })
+], DistortionNode.prototype, "drive_db", void 0);
+// ── Limiter ───────────────────────────────────────────────────────
+export class LimiterNode extends BaseNode {
+    static nodeType = "lib.audio.Limiter";
+    static title = "Limiter";
+    static description = "Applies a limiter effect to an audio file.\n    audio, effect, dynamics\n\n    Use cases:\n    - Prevent audio clipping\n    - Increase perceived loudness without distortion\n    - Control dynamic range of audio";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const thresholdDb = Number(this.threshold_db ?? -2);
+        const releaseMs = Number(this.release_ms ?? 250);
+        if (!audio.data)
+            return { output: audio };
+        const wav = decodeWav(audio);
+        const threshold = Math.pow(10, thresholdDb / 20);
+        const result = processPerChannel(wav, (ch, sr) => {
+            const out = new Float32Array(ch.length);
+            const releaseCoeff = Math.exp(-1 / ((sr * releaseMs) / 1000));
+            let gainReduction = 1;
+            for (let i = 0; i < ch.length; i++) {
+                const absVal = Math.abs(ch[i]);
+                if (absVal > threshold) {
+                    const targetGain = threshold / absVal;
+                    if (targetGain < gainReduction) {
+                        gainReduction = targetGain;
+                    }
+                }
+                else {
+                    gainReduction =
+                        releaseCoeff * gainReduction + (1 - releaseCoeff) * 1.0;
+                }
+                out[i] = ch[i] * gainReduction;
+            }
+            return out;
+        });
+        return {
+            output: audioRefFromWav(encodeWav(result.samples, result.sampleRate, result.numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], LimiterNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: -2,
+        title: "Threshold Db",
+        description: "Threshold in dB above which the limiter is applied.",
+        min: -60,
+        max: 0
+    })
+], LimiterNode.prototype, "threshold_db", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 250,
+        title: "Release Ms",
+        description: "Release time in milliseconds.",
+        min: 1,
+        max: 1000
+    })
+], LimiterNode.prototype, "release_ms", void 0);
+// ── Reverb (Schroeder) ───────────────────────────────────────────
+export class ReverbNode extends BaseNode {
+    static nodeType = "lib.audio.Reverb";
+    static title = "Reverb";
+    static description = "Applies a reverb effect to an audio file.\n    audio, effect, reverb\n\n    Use cases:\n    - Add spatial depth to dry recordings\n    - Simulate different room acoustics\n    - Create atmospheric sound effects";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const roomScale = Number(this.room_scale ?? 0.5);
+        const damping = Number(this.damping ?? 0.5);
+        const wetLevel = Number(this.wet_level ?? 0.15);
+        const dryLevel = Number(this.dry_level ?? 0.5);
+        if (!audio.data)
+            return { output: audio };
+        const wav = decodeWav(audio);
+        const result = processPerChannel(wav, (ch, sr) => {
+            // Schroeder reverb: 4 parallel comb filters -> 2 series allpass filters
+            const baseCombDelays = [1557, 1617, 1491, 1422];
+            const baseAllpassDelays = [225, 556];
+            const scale = sr / 44100;
+            // Comb filter
+            function combFilter(input, delaySamples, feedback, damp) {
+                const out = new Float32Array(input.length);
+                const buf = new Float32Array(delaySamples);
+                let bufIdx = 0;
+                let filterStore = 0;
+                for (let i = 0; i < input.length; i++) {
+                    const delayed = buf[bufIdx];
+                    filterStore = delayed * (1 - damp) + filterStore * damp;
+                    buf[bufIdx] = input[i] + filterStore * feedback;
+                    out[i] = delayed;
+                    bufIdx = (bufIdx + 1) % delaySamples;
+                }
+                return out;
+            }
+            // Allpass filter
+            function allpassFilter(input, delaySamples, feedback) {
+                const out = new Float32Array(input.length);
+                const buf = new Float32Array(delaySamples);
+                let bufIdx = 0;
+                for (let i = 0; i < input.length; i++) {
+                    const delayed = buf[bufIdx];
+                    buf[bufIdx] = input[i] + delayed * feedback;
+                    out[i] = delayed - input[i] * feedback;
+                    bufIdx = (bufIdx + 1) % delaySamples;
+                }
+                return out;
+            }
+            const feedback = roomScale * 0.28 + 0.7;
+            // Sum comb filters
+            const combOut = new Float32Array(ch.length);
+            for (const baseDelay of baseCombDelays) {
+                const delay = Math.round(baseDelay * scale);
+                const filtered = combFilter(ch, delay, feedback, damping);
+                for (let i = 0; i < ch.length; i++) {
+                    combOut[i] += filtered[i];
+                }
+            }
+            // Series allpass filters
+            let apOut = combOut;
+            for (const baseDelay of baseAllpassDelays) {
+                const delay = Math.round(baseDelay * scale);
+                apOut = allpassFilter(apOut, delay, 0.5);
+            }
+            // Mix dry/wet
+            const out = new Float32Array(ch.length);
+            for (let i = 0; i < ch.length; i++) {
+                out[i] = ch[i] * dryLevel + apOut[i] * wetLevel;
+            }
+            return out;
+        });
+        return {
+            output: audioRefFromWav(encodeWav(result.samples, result.sampleRate, result.numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], ReverbNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.5,
+        title: "Room Scale",
+        description: "Size of the simulated room. Higher values create larger spaces.",
+        min: 0,
+        max: 1
+    })
+], ReverbNode.prototype, "room_scale", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.5,
+        title: "Damping",
+        description: "Amount of high frequency absorption. Higher values create a duller sound.",
+        min: 0,
+        max: 1
+    })
+], ReverbNode.prototype, "damping", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.15,
+        title: "Wet Level",
+        description: "Level of the reverb effect in the output.",
+        min: 0,
+        max: 1
+    })
+], ReverbNode.prototype, "wet_level", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.5,
+        title: "Dry Level",
+        description: "Level of the original signal in the output.",
+        min: 0,
+        max: 1
+    })
+], ReverbNode.prototype, "dry_level", void 0);
+// ── PitchShift (rubberband WASM) ─────────────────────────────────
+export class PitchShiftNode extends BaseNode {
+    static nodeType = "lib.audio.PitchShift";
+    static title = "Pitch Shift";
+    static description = "Shifts the pitch of an audio file without changing its duration.\n    audio, effect, pitch\n\n    Use cases:\n    - Transpose audio to a different key\n    - Create harmonies or vocal effects\n    - Adjust instrument tuning";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const semitones = Number(this.semitones ?? 0);
+        if (!audio.data)
+            return { output: audio };
+        if (semitones === 0) {
+            return { output: audio };
+        }
+        const { createRubberbandWrapper } = await import("@k13engineering/rubberband");
+        const wav = decodeWav(audio);
+        const { samples, sampleRate, numChannels } = wav;
+        const frameSamples = Math.floor(samples.length / numChannels);
+        const CHUNK_SIZE = 8192;
+        const rb = createRubberbandWrapper({
+            sampleRate,
+            channelCount: numChannels,
+            maxBufferSizeInFrames: CHUNK_SIZE,
+            options: {
+                processMode: "realtime",
+                engineMode: "finer",
+                pitchMode: "highquality"
+            }
+        });
+        rb.requestPitchScale({ pitchScale: Math.pow(2, semitones / 12) });
+        // Deinterleave into per-channel planes
+        const planes = [];
+        for (let ch = 0; ch < numChannels; ch++) {
+            const plane = new Float32Array(frameSamples);
+            for (let i = 0; i < frameSamples; i++) {
+                plane[i] = samples[i * numChannels + ch];
+            }
+            planes.push(plane);
+        }
+        // Process in chunks, collecting output
+        const outputParts = [];
+        const collectAvailable = () => {
+            let avail = rb.available();
+            while (avail > 0) {
+                const count = Math.min(avail, CHUNK_SIZE);
+                outputParts.push(rb.retrieve({ sampleCount: count }).planes);
+                avail = rb.available();
+            }
+        };
+        for (let offset = 0; offset < frameSamples; offset += CHUNK_SIZE) {
+            const end = Math.min(offset + CHUNK_SIZE, frameSamples);
+            const chunkPlanes = planes.map((p) => p.slice(offset, end));
+            rb.process({ audioData: { planes: chunkPlanes } });
+            collectAvailable();
+        }
+        rb.end();
+        collectAvailable();
+        // Concatenate output per channel
+        const totalOutFrames = outputParts.reduce((s, p) => s + p[0].length, 0);
+        const outPlanes = [];
+        for (let ch = 0; ch < numChannels; ch++) {
+            const plane = new Float32Array(totalOutFrames);
+            let pos = 0;
+            for (const part of outputParts) {
+                plane.set(part[ch], pos);
+                pos += part[ch].length;
+            }
+            outPlanes.push(plane);
+        }
+        // Trim processing latency — pitch shift preserves duration
+        const latency = rb.latencyInSamples();
+        const trimStart = Math.min(latency, totalOutFrames);
+        const trimEnd = Math.min(trimStart + frameSamples, totalOutFrames);
+        const outFrames = trimEnd - trimStart;
+        // Re-interleave trimmed output
+        const outSamples = new Float32Array(outFrames * numChannels);
+        for (let i = 0; i < outFrames; i++) {
+            for (let ch = 0; ch < numChannels; ch++) {
+                outSamples[i * numChannels + ch] = outPlanes[ch][trimStart + i];
+            }
+        }
+        return {
+            output: audioRefFromWav(encodeWav(outSamples, sampleRate, numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], PitchShiftNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Semitones",
+        description: "Number of semitones to shift the pitch. Positive values shift up, negative values shift down.",
+        min: -12,
+        max: 12
+    })
+], PitchShiftNode.prototype, "semitones", void 0);
+// ── TimeStretch (rubberband WASM) ────────────────────────────────
+export class TimeStretchNode extends BaseNode {
+    static nodeType = "lib.audio.TimeStretch";
+    static title = "Time Stretch";
+    static description = "Changes the speed of an audio file without altering its pitch.\n    audio, transform, time\n\n    Use cases:\n    - Adjust audio duration to fit video length\n    - Create slow-motion or fast-motion audio effects\n    - Synchronize audio tracks of different lengths";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const rate = Number(this.rate ?? 1.0);
+        if (!audio.data)
+            return { output: audio };
+        if (rate === 1.0) {
+            return { output: audio };
+        }
+        const { createRubberbandWrapper } = await import("@k13engineering/rubberband");
+        const wav = decodeWav(audio);
+        const { samples, sampleRate, numChannels } = wav;
+        const frameSamples = Math.floor(samples.length / numChannels);
+        const CHUNK_SIZE = 8192;
+        const rb = createRubberbandWrapper({
+            sampleRate,
+            channelCount: numChannels,
+            maxBufferSizeInFrames: CHUNK_SIZE,
+            options: {
+                processMode: "realtime",
+                engineMode: "finer"
+            }
+        });
+        // Rubber Band timeRatio = output_duration / input_duration
+        // rate > 1 means faster (shorter output), so timeRatio = 1 / rate
+        rb.requestTimeRatio({ timeRatio: 1 / rate });
+        // Deinterleave into per-channel planes
+        const planes = [];
+        for (let ch = 0; ch < numChannels; ch++) {
+            const plane = new Float32Array(frameSamples);
+            for (let i = 0; i < frameSamples; i++) {
+                plane[i] = samples[i * numChannels + ch];
+            }
+            planes.push(plane);
+        }
+        // Process in chunks, collecting output
+        const outputParts = [];
+        const collectAvailable = () => {
+            let avail = rb.available();
+            while (avail > 0) {
+                const count = Math.min(avail, CHUNK_SIZE);
+                outputParts.push(rb.retrieve({ sampleCount: count }).planes);
+                avail = rb.available();
+            }
+        };
+        for (let offset = 0; offset < frameSamples; offset += CHUNK_SIZE) {
+            const end = Math.min(offset + CHUNK_SIZE, frameSamples);
+            const chunkPlanes = planes.map((p) => p.slice(offset, end));
+            rb.process({ audioData: { planes: chunkPlanes } });
+            collectAvailable();
+        }
+        rb.end();
+        collectAvailable();
+        // Concatenate output per channel
+        const totalOutFrames = outputParts.reduce((s, p) => s + p[0].length, 0);
+        const outPlanes = [];
+        for (let ch = 0; ch < numChannels; ch++) {
+            const plane = new Float32Array(totalOutFrames);
+            let pos = 0;
+            for (const part of outputParts) {
+                plane.set(part[ch], pos);
+                pos += part[ch].length;
+            }
+            outPlanes.push(plane);
+        }
+        // Trim processing latency — expected output = input / rate
+        const latency = rb.latencyInSamples();
+        const expectedFrames = Math.round(frameSamples / rate);
+        const trimStart = Math.min(latency, totalOutFrames);
+        const trimEnd = Math.min(trimStart + expectedFrames, totalOutFrames);
+        const outFrames = trimEnd - trimStart;
+        // Re-interleave trimmed output
+        const outSamples = new Float32Array(outFrames * numChannels);
+        for (let i = 0; i < outFrames; i++) {
+            for (let ch = 0; ch < numChannels; ch++) {
+                outSamples[i * numChannels + ch] = outPlanes[ch][trimStart + i];
+            }
+        }
+        return {
+            output: audioRefFromWav(encodeWav(outSamples, sampleRate, numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], TimeStretchNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1,
+        title: "Rate",
+        description: "Time stretch factor. Values > 1 speed up, < 1 slow down.",
+        min: 0.5,
+        max: 2
+    })
+], TimeStretchNode.prototype, "rate", void 0);
+// ── NoiseGate ─────────────────────────────────────────────────────
+export class NoiseGateNode extends BaseNode {
+    static nodeType = "lib.audio.NoiseGate";
+    static title = "Noise Gate";
+    static description = "Applies a noise gate effect to an audio file.\n    audio, effect, dynamics\n\n    Use cases:\n    - Reduce background noise in recordings\n    - Clean up audio tracks with unwanted low-level sounds\n    - Create rhythmic effects by gating sustained sounds";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const thresholdDb = Number(this.threshold_db ?? -50);
+        const attackMs = Math.max(0.1, Number(this.attack_ms ?? 1));
+        const releaseMs = Math.max(1, Number(this.release_ms ?? 100));
+        if (!audio.data)
+            return { output: audio };
+        const wav = decodeWav(audio);
+        const thresholdLin = Math.pow(10, thresholdDb / 20);
+        const result = processPerChannel(wav, (ch, sr) => {
+            const out = new Float32Array(ch.length);
+            const attackCoeff = Math.exp(-1 / ((sr * attackMs) / 1000));
+            const releaseCoeff = Math.exp(-1 / ((sr * releaseMs) / 1000));
+            let envelope = 0;
+            let gain = 0;
+            for (let i = 0; i < ch.length; i++) {
+                const absVal = Math.abs(ch[i]);
+                // Envelope follower: fast attack, slow release
+                if (absVal > envelope) {
+                    envelope = attackCoeff * envelope + (1 - attackCoeff) * absVal;
+                }
+                else {
+                    envelope = releaseCoeff * envelope + (1 - releaseCoeff) * absVal;
+                }
+                // Gate: open when above threshold, close when below
+                const targetGain = envelope >= thresholdLin ? 1 : 0;
+                gain = releaseCoeff * gain + (1 - releaseCoeff) * targetGain;
+                out[i] = ch[i] * gain;
+            }
+            return out;
+        });
+        return {
+            output: audioRefFromWav(encodeWav(result.samples, result.sampleRate, result.numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], NoiseGateNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: -50,
+        title: "Threshold Db",
+        description: "Threshold in dB below which the gate is active.",
+        min: -90,
+        max: 0
+    })
+], NoiseGateNode.prototype, "threshold_db", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1,
+        title: "Attack Ms",
+        description: "Attack time in milliseconds.",
+        min: 0.1,
+        max: 100
+    })
+], NoiseGateNode.prototype, "attack_ms", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 100,
+        title: "Release Ms",
+        description: "Release time in milliseconds.",
+        min: 5,
+        max: 1000
+    })
+], NoiseGateNode.prototype, "release_ms", void 0);
+// ── Phaser ────────────────────────────────────────────────────────
+export class PhaserNode extends BaseNode {
+    static nodeType = "lib.audio.Phaser";
+    static title = "Phaser";
+    static description = "Applies a phaser effect to an audio file.\n    audio, effect, modulation\n\n    Use cases:\n    - Create sweeping, swooshing sounds\n    - Add movement to static sounds\n    - Produce psychedelic or space-like effects";
+    static metadataOutputTypes = {
+        output: "audio"
+    };
+    async process() {
+        const audio = (this.audio ?? {});
+        const rateHz = Number(this.rate_hz ?? 1);
+        const depth = Number(this.depth ?? 0.5);
+        const centreFreqHz = Number(this.centre_frequency_hz ?? 1300);
+        const feedback = Number(this.feedback ?? 0);
+        const mix = Number(this.mix ?? 0.5);
+        if (!audio.data)
+            return { output: audio };
+        const wav = decodeWav(audio);
+        const result = processPerChannel(wav, (ch, sr) => {
+            const out = new Float32Array(ch.length);
+            // 4-stage first-order all-pass phaser
+            const numStages = 4;
+            // Delay buffers: x[n-1] and y[n-1] for each stage
+            const xPrev = new Float32Array(numStages);
+            const yPrev = new Float32Array(numStages);
+            // Feedback delay
+            let feedbackSample = 0;
+            let lfoPhase = 0;
+            const lfoIncrement = (2 * Math.PI * rateHz) / sr;
+            for (let i = 0; i < ch.length; i++) {
+                // LFO modulates centre frequency
+                const lfo = Math.sin(lfoPhase) * depth;
+                lfoPhase += lfoIncrement;
+                if (lfoPhase > 2 * Math.PI)
+                    lfoPhase -= 2 * Math.PI;
+                // Modulated frequency (centre ± depth range)
+                const modFreq = Math.max(20, Math.min(sr / 2 - 1, centreFreqHz * (1 + lfo)));
+                const tanVal = Math.tan((Math.PI * modFreq) / sr);
+                const a = (tanVal - 1) / (tanVal + 1);
+                // Input with feedback
+                const signal = ch[i] + feedbackSample * feedback;
+                // Apply all-pass filter stages
+                let apOut = signal;
+                for (let s = 0; s < numStages; s++) {
+                    const newOut = a * apOut + xPrev[s] - a * yPrev[s];
+                    xPrev[s] = apOut;
+                    yPrev[s] = newOut;
+                    apOut = newOut;
+                }
+                feedbackSample = apOut;
+                // Mix dry and wet
+                out[i] = ch[i] * (1 - mix) + apOut * mix;
+            }
+            return out;
+        });
+        return {
+            output: audioRefFromWav(encodeWav(result.samples, result.sampleRate, result.numChannels))
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio file to process."
+    })
+], PhaserNode.prototype, "audio", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1,
+        title: "Rate Hz",
+        description: "Rate of the phaser effect in Hz.",
+        min: 0.1,
+        max: 10
+    })
+], PhaserNode.prototype, "rate_hz", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.5,
+        title: "Depth",
+        description: "Depth of the phaser effect.",
+        min: 0,
+        max: 1
+    })
+], PhaserNode.prototype, "depth", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1300,
+        title: "Centre Frequency Hz",
+        description: "Centre frequency of the phaser in Hz.",
+        min: 100,
+        max: 5000
+    })
+], PhaserNode.prototype, "centre_frequency_hz", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Feedback",
+        description: "Feedback of the phaser effect. Negative values invert the phase.",
+        min: -1,
+        max: 1
+    })
+], PhaserNode.prototype, "feedback", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.5,
+        title: "Mix",
+        description: "Mix between the dry (original) and wet (effected) signals.",
+        min: 0,
+        max: 1
+    })
+], PhaserNode.prototype, "mix", void 0);
+// ── Export ────────────────────────────────────────────────────────
+export const LIB_PEDALBOARD_EXTRA_NODES = [
+    BitcrushNode,
+    CompressNode,
+    DistortionNode,
+    LimiterNode,
+    ReverbNode,
+    PitchShiftNode,
+    TimeStretchNode,
+    NoiseGateNode,
+    PhaserNode
+];
+//# sourceMappingURL=lib-audio-effects.js.map