@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.1

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

@@ -1,905 +0,0 @@
-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