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

package/dist/nodes/audio.js

@@ -1,1274 +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 { promises as fs } from "node:fs";
-import path from "node:path";
-import { audioBytes, audioBytesAsync, audioRefFromBytes, audioRefFromWav, concatBytes, encodePcm16Wav, encodeWav, toBytes, tryDecodeWav, uriToPath } from "../lib/audio-wav.js";
-function dateName(name) {
-    const now = new Date();
-    const pad = (v) => String(v).padStart(2, "0");
-    return name
-        .replaceAll("%Y", String(now.getFullYear()))
-        .replaceAll("%m", pad(now.getMonth() + 1))
-        .replaceAll("%d", pad(now.getDate()))
-        .replaceAll("%H", pad(now.getHours()))
-        .replaceAll("%M", pad(now.getMinutes()))
-        .replaceAll("%S", pad(now.getSeconds()));
-}
-function getModelConfig(props) {
-    const model = (props.model ?? {});
-    if (typeof model === "string") {
-        return { providerId: "", modelId: model };
-    }
-    return {
-        providerId: typeof model.provider === "string" ? model.provider : "",
-        modelId: typeof model.id === "string" ? model.id : ""
-    };
-}
-function hasProviderSupport(context, providerId, modelId) {
-    return (!!context &&
-        typeof context.runProviderPrediction === "function" &&
-        typeof context.streamProviderPrediction === "function" &&
-        !!providerId &&
-        !!modelId);
-}
-export class LoadAudioAssetsNode extends BaseNode {
-    static nodeType = "nodetool.audio.LoadAudioAssets";
-    static title = "Load Audio Assets";
-    static description = "Load audio files from an asset folder.\n    load, audio, file, import";
-    static metadataOutputTypes = {
-        audio: "audio",
-        name: "str",
-        audios: "list"
-    };
-    static isStreamingOutput = true;
-    async process() {
-        const collected = [];
-        for await (const item of this._loadAudios()) {
-            collected.push(item.audio);
-        }
-        return {
-            audio: collected[0] ?? {},
-            name: "",
-            audios: collected
-        };
-    }
-    async *_loadAudios() {
-        const raw = this.folder;
-        const folder = typeof raw === "string" && raw.length > 0
-            ? raw.startsWith("file:")
-                ? uriToPath(raw)
-                : raw
-            : typeof raw === "object" && raw !== null && typeof raw.uri === "string" && raw.uri.length > 0
-                ? uriToPath(raw.uri)
-                : "";
-        if (!folder)
-            return;
-        let entries;
-        try {
-            entries = await fs.readdir(folder, { withFileTypes: true });
-        }
-        catch {
-            // folder does not exist or is not accessible
-            return;
-        }
-        for (const entry of entries) {
-            if (!entry.isFile())
-                continue;
-            const ext = path.extname(entry.name).toLowerCase();
-            if (![".wav", ".mp3", ".m4a", ".flac", ".ogg"].includes(ext))
-                continue;
-            const full = path.join(folder, entry.name);
-            const data = new Uint8Array(await fs.readFile(full));
-            yield {
-                audio: audioRefFromBytes(data, `file://${full}`),
-                name: entry.name
-            };
-        }
-    }
-    async *genProcess() {
-        const collected = [];
-        for await (const item of this._loadAudios()) {
-            collected.push(item.audio);
-            yield item;
-        }
-        yield { audios: collected };
-    }
-}
-__decorate([
-    prop({
-        type: "folder",
-        default: {
-            type: "folder",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Folder",
-        description: "The asset folder to load the audio files from."
-    })
-], LoadAudioAssetsNode.prototype, "folder", void 0);
-export class LoadAudioFileNode extends BaseNode {
-    static nodeType = "nodetool.audio.LoadAudioFile";
-    static title = "Load Audio File";
-    static description = "Read an audio file from disk.\n    audio, input, load, file";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    async process() {
-        const p = uriToPath(String(this.path ?? ""));
-        const data = new Uint8Array(await fs.readFile(p));
-        return { output: audioRefFromBytes(data, `file://${p}`) };
-    }
-}
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Path",
-        description: "Path to the audio file to read"
-    })
-], LoadAudioFileNode.prototype, "path", void 0);
-export class LoadAudioFolderNode extends BaseNode {
-    static nodeType = "nodetool.audio.LoadAudioFolder";
-    static title = "Load Audio Folder";
-    static description = "Load all audio files from a folder, optionally including subfolders.\n    audio, load, folder, files";
-    static metadataOutputTypes = {
-        audio: "audio",
-        path: "str",
-        audios: "list"
-    };
-    static isStreamingOutput = true;
-    async process() {
-        const loader = new LoadAudioAssetsNode();
-        loader.assign({ folder: this.folder ?? "." });
-        const result = await loader.process();
-        return result;
-    }
-    async *genProcess() {
-        const loader = new LoadAudioAssetsNode();
-        loader.assign({ folder: this.folder ?? "." });
-        for await (const item of loader.genProcess()) {
-            yield item;
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Folder",
-        description: "Folder to scan for audio files"
-    })
-], LoadAudioFolderNode.prototype, "folder", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: false,
-        title: "Include Subdirectories",
-        description: "Include audio in subfolders"
-    })
-], LoadAudioFolderNode.prototype, "include_subdirectories", void 0);
-__decorate([
-    prop({
-        type: "list[str]",
-        default: [".mp3", ".wav", ".flac", ".ogg", ".m4a", ".aac"],
-        title: "Extensions",
-        description: "Audio file extensions to include"
-    })
-], LoadAudioFolderNode.prototype, "extensions", void 0);
-export class SaveAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.SaveAudio";
-    static title = "Save Audio Asset";
-    static description = "Save an audio file to a specified asset folder.\n    audio, folder, name";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const audio = this.audio;
-        const folder = String(this.folder ?? ".");
-        const name = dateName(String(this.name ?? "audio.wav"));
-        const full = path.resolve(folder, name);
-        await fs.mkdir(path.dirname(full), { recursive: true });
-        await fs.writeFile(full, audioBytes(audio));
-        return { output: audioRefFromBytes(audioBytes(audio), `file://${full}`) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio"
-    })
-], SaveAudioNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "folder",
-        default: {
-            type: "folder",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Folder",
-        description: "The asset folder to save the audio file to. "
-    })
-], SaveAudioNode.prototype, "folder", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "%Y-%m-%d-%H-%M-%S.opus",
-        title: "Name",
-        description: "\n        The name of the audio file.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
-    })
-], SaveAudioNode.prototype, "name", void 0);
-export class SaveAudioFileNode extends BaseNode {
-    static nodeType = "nodetool.audio.SaveAudioFile";
-    static title = "Save Audio File";
-    static description = "Write an audio file to disk.\n    audio, output, save, file\n\n    The filename can include time and date variables:\n    %Y - Year, %m - Month, %d - Day\n    %H - Hour, %M - Minute, %S - Second\n\n    Supported formats: mp3, wav, ogg, flac, aac, m4a";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    async process() {
-        const audio = this.audio;
-        const folder = String(this.folder ?? ".");
-        const fname = dateName(String(this.filename ?? "audio.wav"));
-        const p = path.resolve(folder, fname);
-        await fs.mkdir(path.dirname(p), { recursive: true });
-        await fs.writeFile(p, audioBytes(audio));
-        return { output: p };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio to save"
-    })
-], SaveAudioFileNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Folder",
-        description: "Folder where the file will be saved"
-    })
-], SaveAudioFileNode.prototype, "folder", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Filename",
-        description: "\n        Name of the file to save.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
-    })
-], SaveAudioFileNode.prototype, "filename", void 0);
-__decorate([
-    prop({
-        type: "dict[str, str]",
-        default: {
-            ".mp3": "mp3",
-            ".wav": "wav",
-            ".ogg": "ogg",
-            ".flac": "flac",
-            ".aac": "adts",
-            ".m4a": "ipod"
-        },
-        title: "Format Map"
-    })
-], SaveAudioFileNode.prototype, "FORMAT_MAP", void 0);
-export class NormalizeAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.Normalize";
-    static title = "Normalize";
-    static description = "Normalizes the volume of an audio file.\n    audio, fix, dynamics, volume";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process(context) {
-        const bytes = await audioBytesAsync(this.audio, context);
-        const wav = tryDecodeWav({ data: bytes });
-        if (!wav || wav.samples.length === 0) {
-            return { output: audioRefFromBytes(bytes) };
-        }
-        let peak = 0;
-        for (const sample of wav.samples)
-            peak = Math.max(peak, Math.abs(sample));
-        if (peak === 0)
-            return { output: audioRefFromBytes(bytes) };
-        const gain = 1 / peak;
-        const normalized = new Float32Array(wav.samples.length);
-        for (let i = 0; i < wav.samples.length; i += 1) {
-            normalized[i] = wav.samples[i] * gain;
-        }
-        return {
-            output: audioRefFromWav(encodeWav(normalized, wav.sampleRate, wav.numChannels))
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to normalize."
-    })
-], NormalizeAudioNode.prototype, "audio", void 0);
-export class OverlayAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.OverlayAudio";
-    static title = "Overlay Audio";
-    static description = "Overlays two audio files together.\n    audio, edit, transform";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const a = audioBytes(this.a);
-        const b = audioBytes(this.b);
-        const len = Math.max(a.length, b.length);
-        const out = new Uint8Array(len);
-        for (let i = 0; i < len; i += 1) {
-            out[i] = Math.max(a[i] ?? 0, b[i] ?? 0);
-        }
-        return { output: audioRefFromBytes(out) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "A",
-        description: "The first audio file."
-    })
-], OverlayAudioNode.prototype, "a", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "B",
-        description: "The second audio file."
-    })
-], OverlayAudioNode.prototype, "b", void 0);
-export class RemoveSilenceNode extends BaseNode {
-    static nodeType = "nodetool.audio.RemoveSilence";
-    static title = "Remove Silence";
-    static description = "Removes or shortens silence in an audio file with smooth transitions.\n    audio, edit, clean";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const data = audioBytes(this.audio);
-        const filtered = data.filter((v) => v !== 0);
-        return { output: audioRefFromBytes(filtered) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to process."
-    })
-], RemoveSilenceNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 200,
-        title: "Min Length",
-        description: "Minimum length of silence to be processed (in milliseconds).",
-        min: 0,
-        max: 10000
-    })
-], RemoveSilenceNode.prototype, "min_length", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -40,
-        title: "Threshold",
-        description: "Silence threshold in dB (relative to full scale). Higher values detect more silence.",
-        min: -60,
-        max: 0
-    })
-], RemoveSilenceNode.prototype, "threshold", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Reduction Factor",
-        description: "Factor to reduce silent parts (0.0 to 1.0). 0.0 keeps silence as is, 1.0 removes it completely.",
-        min: 0,
-        max: 1
-    })
-], RemoveSilenceNode.prototype, "reduction_factor", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 10,
-        title: "Crossfade",
-        description: "Duration of crossfade in milliseconds to apply between segments for smooth transitions.",
-        min: 0,
-        max: 50
-    })
-], RemoveSilenceNode.prototype, "crossfade", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 100,
-        title: "Min Silence Between Parts",
-        description: "Minimum silence duration in milliseconds to maintain between non-silent segments",
-        min: 0,
-        max: 500
-    })
-], RemoveSilenceNode.prototype, "min_silence_between_parts", void 0);
-export class SliceAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.SliceAudio";
-    static title = "Slice Audio";
-    static description = "Extracts a section of an audio file.\n    audio, edit, trim";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const data = audioBytes(this.audio);
-        const start = Number(this.start ?? 0);
-        let end = Number(this.end ?? -1);
-        if (end < 0)
-            end = data.length;
-        return { output: audioRefFromBytes(data.slice(start, end)) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file."
-    })
-], SliceAudioNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0,
-        title: "Start",
-        description: "The start time in seconds.",
-        min: 0
-    })
-], SliceAudioNode.prototype, "start", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "End",
-        description: "The end time in seconds.",
-        min: 0
-    })
-], SliceAudioNode.prototype, "end", void 0);
-export class MonoToStereoNode extends BaseNode {
-    static nodeType = "nodetool.audio.MonoToStereo";
-    static title = "Mono To Stereo";
-    static description = "Converts a mono audio signal to stereo.\n    audio, convert, channels";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const mono = audioBytes(this.audio);
-        const out = new Uint8Array(mono.length * 2);
-        for (let i = 0; i < mono.length; i += 1) {
-            out[i * 2] = mono[i];
-            out[i * 2 + 1] = mono[i];
-        }
-        return { output: audioRefFromBytes(out) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The mono audio file to convert."
-    })
-], MonoToStereoNode.prototype, "audio", void 0);
-export class StereoToMonoNode extends BaseNode {
-    static nodeType = "nodetool.audio.StereoToMono";
-    static title = "Stereo To Mono";
-    static description = "Converts a stereo audio signal to mono.\n    audio, convert, channels";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const stereo = audioBytes(this.audio);
-        const out = new Uint8Array(Math.ceil(stereo.length / 2));
-        for (let i = 0, j = 0; i < stereo.length; i += 2, j += 1) {
-            out[j] = stereo[i];
-        }
-        return { output: audioRefFromBytes(out) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The stereo audio file to convert."
-    })
-], StereoToMonoNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "average",
-        title: "Method",
-        description: "Method to use for conversion: 'average', 'left', or 'right'."
-    })
-], StereoToMonoNode.prototype, "method", void 0);
-export class ReverseAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.Reverse";
-    static title = "Reverse";
-    static description = "Reverses an audio file.\n    audio, edit, transform";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const data = audioBytes(this.audio);
-        return { output: audioRefFromBytes(new Uint8Array([...data].reverse())) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to reverse."
-    })
-], ReverseAudioNode.prototype, "audio", void 0);
-export class FadeInAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.FadeIn";
-    static title = "Fade In";
-    static description = "Applies a fade-in effect to the beginning of an audio file.\n    audio, edit, transition";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const data = new Uint8Array(audioBytes(this.audio));
-        const duration = Math.max(1, Number(this.duration ?? 1024));
-        for (let i = 0; i < Math.min(duration, data.length); i += 1) {
-            data[i] = Math.floor(data[i] * (i / duration));
-        }
-        return { output: audioRefFromBytes(data) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to apply fade-in to."
-    })
-], FadeInAudioNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Duration",
-        description: "Duration of the fade-in effect in seconds.",
-        min: 0
-    })
-], FadeInAudioNode.prototype, "duration", void 0);
-export class FadeOutAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.FadeOut";
-    static title = "Fade Out";
-    static description = "Applies a fade-out effect to the end of an audio file.\n    audio, edit, transition";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const data = new Uint8Array(audioBytes(this.audio));
-        const duration = Math.max(1, Number(this.duration ?? 1024));
-        const start = Math.max(0, data.length - duration);
-        for (let i = start; i < data.length; i += 1) {
-            const factor = (data.length - i) / Math.max(1, data.length - start);
-            data[i] = Math.floor(data[i] * factor);
-        }
-        return { output: audioRefFromBytes(data) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to apply fade-out to."
-    })
-], FadeOutAudioNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Duration",
-        description: "Duration of the fade-out effect in seconds.",
-        min: 0
-    })
-], FadeOutAudioNode.prototype, "duration", void 0);
-export class RepeatAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.Repeat";
-    static title = "Repeat";
-    static description = "Loops an audio file a specified number of times.\n    audio, edit, repeat";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const data = audioBytes(this.audio);
-        const count = Math.max(1, Number(this.loops ?? 2));
-        return {
-            output: audioRefFromBytes(concatBytes(Array.from({ length: count }, () => data)))
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to loop."
-    })
-], RepeatAudioNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 2,
-        title: "Loops",
-        description: "Number of times to loop the audio. Minimum 1 (plays once), maximum 100.",
-        min: 1,
-        max: 100
-    })
-], RepeatAudioNode.prototype, "loops", void 0);
-export class AudioMixerNode extends BaseNode {
-    static nodeType = "nodetool.audio.AudioMixer";
-    static title = "Audio Mixer";
-    static description = "Mix up to 5 audio tracks together with individual volume controls.\n    audio, mix, volume, combine, blend, layer, add, overlay";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    async process() {
-        const entries = [
-            { track: this.track1, volume: this.volume1 },
-            { track: this.track2, volume: this.volume2 },
-            { track: this.track3, volume: this.volume3 },
-            { track: this.track4, volume: this.volume4 },
-            { track: this.track5, volume: this.volume5 }
-        ];
-        const filtered = entries.filter((e) => e.track && typeof e.track === "object");
-        const tracks = (await Promise.all(filtered.map(async (e) => ({
-            bytes: await audioBytesAsync(e.track),
-            volume: Number.isFinite(Number(e.volume)) ? Number(e.volume) : 1
-        })))).filter((t) => t.bytes.length > 0);
-        if (tracks.length === 0)
-            return { output: audioRefFromBytes(new Uint8Array()) };
-        // If every track is a valid WAV file, mix in Float32 sample space and
-        // emit a valid WAV so downstream nodes receive a playable file.
-        const parsed = tracks.map((t) => ({
-            wav: tryDecodeWav({ data: t.bytes }),
-            bytes: t.bytes,
-            volume: t.volume
-        }));
-        if (parsed.every((p) => p.wav !== null)) {
-            const wavs = parsed;
-            const len = Math.max(...wavs.map((p) => p.wav.samples.length));
-            const mixed = new Float32Array(len);
-            for (let i = 0; i < len; i += 1) {
-                let total = 0;
-                for (const p of wavs)
-                    total += (p.wav.samples[i] ?? 0) * p.volume;
-                mixed[i] = total / wavs.length;
-            }
-            return {
-                output: audioRefFromWav(encodeWav(mixed, wavs[0].wav.sampleRate, wavs[0].wav.numChannels))
-            };
-        }
-        // Fallback: byte-level averaging with volume scaling (preserves
-        // backward-compatible behavior for non-WAV / headerless byte streams).
-        const len = Math.max(...tracks.map((t) => t.bytes.length));
-        const out = new Uint8Array(len);
-        for (let i = 0; i < len; i += 1) {
-            let total = 0;
-            for (const t of tracks)
-                total += (t.bytes[i] ?? 0) * t.volume;
-            const avg = total / tracks.length;
-            out[i] = Math.max(0, Math.min(255, Math.round(avg)));
-        }
-        return { output: audioRefFromBytes(out) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Track1",
-        description: "First audio track to mix."
-    })
-], AudioMixerNode.prototype, "track1", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Track2",
-        description: "Second audio track to mix."
-    })
-], AudioMixerNode.prototype, "track2", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Track3",
-        description: "Third audio track to mix."
-    })
-], AudioMixerNode.prototype, "track3", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Track4",
-        description: "Fourth audio track to mix."
-    })
-], AudioMixerNode.prototype, "track4", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Track5",
-        description: "Fifth audio track to mix."
-    })
-], AudioMixerNode.prototype, "track5", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Volume1",
-        description: "Volume for track 1. 1.0 is original volume.",
-        min: 0,
-        max: 2
-    })
-], AudioMixerNode.prototype, "volume1", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Volume2",
-        description: "Volume for track 2. 1.0 is original volume.",
-        min: 0,
-        max: 2
-    })
-], AudioMixerNode.prototype, "volume2", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Volume3",
-        description: "Volume for track 3. 1.0 is original volume.",
-        min: 0,
-        max: 2
-    })
-], AudioMixerNode.prototype, "volume3", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Volume4",
-        description: "Volume for track 4. 1.0 is original volume.",
-        min: 0,
-        max: 2
-    })
-], AudioMixerNode.prototype, "volume4", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Volume5",
-        description: "Volume for track 5. 1.0 is original volume.",
-        min: 0,
-        max: 2
-    })
-], AudioMixerNode.prototype, "volume5", void 0);
-export class TrimAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.Trim";
-    static title = "Trim";
-    static description = "Trim an audio file to a specified duration.\n    audio, trim, cut";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const data = audioBytes(this.audio);
-        const start = Math.max(0, Number(this.start ?? 0));
-        const end = Math.max(0, Number(this.end ?? 0));
-        return {
-            output: audioRefFromBytes(data.slice(start, Math.max(start, data.length - end)))
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to trim."
-    })
-], TrimAudioNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0,
-        title: "Start",
-        description: "The start time of the trimmed audio in seconds.",
-        min: 0
-    })
-], TrimAudioNode.prototype, "start", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0,
-        title: "End",
-        description: "The end time of the trimmed audio in seconds.",
-        min: 0
-    })
-], TrimAudioNode.prototype, "end", void 0);
-export class CreateSilenceNode extends BaseNode {
-    static nodeType = "nodetool.audio.CreateSilence";
-    static title = "Create Silence";
-    static description = "Creates a silent audio file with a specified duration.\n    audio, silence, empty";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    async process() {
-        const length = Math.max(0, Number(this.duration ?? 16000));
-        return { output: audioRefFromBytes(new Uint8Array(length)) };
-    }
-}
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Duration",
-        description: "The duration of the silence in seconds.",
-        min: 0
-    })
-], CreateSilenceNode.prototype, "duration", void 0);
-export class ConcatAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.Concat";
-    static title = "Concat";
-    static description = "Concatenates audio files together.\n    audio, edit, join, +";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    static isDynamic = true;
-    async process() {
-        const parts = [this.a, this.b, ...Array.from(this.dynamicProps.values())].map((value) => audioBytes(value));
-        return { output: audioRefFromBytes(concatBytes(parts)) };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "A",
-        description: "The first audio file."
-    })
-], ConcatAudioNode.prototype, "a", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "B",
-        description: "The second audio file."
-    })
-], ConcatAudioNode.prototype, "b", void 0);
-export class ConcatAudioListNode extends BaseNode {
-    static nodeType = "nodetool.audio.ConcatList";
-    static title = "Concat List";
-    static description = "Concatenates multiple audio files together in sequence.\n    audio, edit, join, multiple, +";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    static exposeAsTool = true;
-    async process() {
-        const audios = Array.isArray(this.audio_files)
-            ? this.audio_files
-            : [];
-        const merged = concatBytes(audios.map((a) => audioBytes(a)));
-        return { output: audioRefFromBytes(merged) };
-    }
-}
-__decorate([
-    prop({
-        type: "list[audio]",
-        default: [],
-        title: "Audio Files",
-        description: "List of audio files to concatenate in sequence."
-    })
-], ConcatAudioListNode.prototype, "audio_files", void 0);
-export class TextToSpeechNode extends BaseNode {
-    static nodeType = "nodetool.audio.TextToSpeech";
-    static title = "Text To Speech";
-    static description = "Generate speech audio from text using any supported TTS provider. Automatically routes to the appropriate backend (OpenAI, HuggingFace, MLX).\n    audio, generation, AI, text-to-speech, tts, voice";
-    static metadataOutputTypes = {
-        audio: "audio",
-        chunk: "chunk"
-    };
-    static basicFields = ["model", "text", "voice", "speed"];
-    static autoSaveAsset = true;
-    static exposeAsTool = true;
-    static isStreamingOutput = true;
-    async process(context) {
-        const text = String(this.text ?? "");
-        const { providerId, modelId } = getModelConfig(this.serialize());
-        const modelObj = (this.model ?? {});
-        const explicitVoice = typeof modelObj.selected_voice === "string"
-            ? modelObj.selected_voice
-            : "";
-        const voiceList = Array.isArray(modelObj.voices)
-            ? modelObj.voices
-            : [];
-        const voice = explicitVoice || voiceList[0] || "";
-        if (hasProviderSupport(context, providerId, modelId)) {
-            const chunks = [];
-            let sampleRate = 24000;
-            for await (const item of context.streamProviderPrediction({
-                provider: providerId,
-                capability: "text_to_speech",
-                model: modelId,
-                params: {
-                    text,
-                    voice,
-                    speed: this.speed
-                }
-            })) {
-                const piece = item;
-                if (typeof piece.sampleRate === "number" && piece.sampleRate > 0) {
-                    sampleRate = piece.sampleRate;
-                }
-                if (piece.samples instanceof Int16Array) {
-                    chunks.push(new Uint8Array(piece.samples.buffer.slice(piece.samples.byteOffset, piece.samples.byteOffset + piece.samples.byteLength)));
-                }
-            }
-            const wav = encodePcm16Wav(concatBytes(chunks), sampleRate, 1);
-            return { output: audioRefFromWav(wav) };
-        }
-        const bytes = Uint8Array.from(Buffer.from(text, "utf8"));
-        return { output: audioRefFromBytes(bytes) };
-    }
-}
-__decorate([
-    prop({
-        type: "tts_model",
-        default: {
-            type: "tts_model",
-            provider: "openai",
-            id: "tts-1",
-            name: "TTS 1",
-            path: null,
-            voices: ["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
-            selected_voice: "alloy"
-        },
-        title: "Model",
-        description: "The text-to-speech model to use"
-    })
-], TextToSpeechNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "Hello! This is a text-to-speech demonstration.",
-        title: "Text",
-        description: "Text to convert to speech"
-    })
-], TextToSpeechNode.prototype, "text", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Speed",
-        description: "Speech speed multiplier (0.25 to 4.0)",
-        min: 0.25,
-        max: 4
-    })
-], TextToSpeechNode.prototype, "speed", void 0);
-export class ChunkToAudioNode extends BaseNode {
-    static nodeType = "nodetool.audio.ChunkToAudio";
-    static title = "Chunk To Audio";
-    static description = "Aggregates audio chunks from an input stream into AudioRef objects.\n    audio, stream, chunk, aggregate, collect, batch";
-    static metadataOutputTypes = {
-        audio: "audio"
-    };
-    async process() {
-        const chunk = this.chunk ?? {};
-        if (chunk && typeof chunk === "object") {
-            const image = chunk;
-            if (image.data || image.uri) {
-                return { output: audioRefFromBytes(toBytes(image.data)) };
-            }
-        }
-        return { output: audioRefFromBytes(new Uint8Array()) };
-    }
-}
-__decorate([
-    prop({
-        type: "chunk",
-        default: {
-            type: "chunk",
-            node_id: null,
-            thread_id: null,
-            workflow_id: null,
-            content_type: "text",
-            content: "",
-            content_metadata: {},
-            done: false,
-            thinking: false
-        },
-        title: "Chunk",
-        description: "Stream of audio chunks"
-    })
-], ChunkToAudioNode.prototype, "chunk", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 50,
-        title: "Batch Size",
-        description: "Number of chunks to aggregate per output"
-    })
-], ChunkToAudioNode.prototype, "batch_size", void 0);
-export class GetAudioInfoNode extends BaseNode {
-    static nodeType = "nodetool.audio.GetAudioInfo";
-    static title = "Get Audio Info";
-    static description = "Extract metadata from an audio file: duration, sample rate, channels, format.\n    audio, info, metadata, duration, sample_rate, channels, format";
-    static metadataOutputTypes = {
-        duration: "float",
-        sample_rate: "int",
-        channels: "int",
-        format: "str",
-        size_bytes: "int"
-    };
-    async process(context) {
-        const bytes = await audioBytesAsync(this.audio, context);
-        if (bytes.length === 0) {
-            return { duration: 0, sample_rate: 0, channels: 0, format: "unknown", size_bytes: 0 };
-        }
-        let format = "unknown";
-        let sampleRate = 0;
-        let channels = 0;
-        let duration = 0;
-        if (bytes.length >= 44) {
-            const header = Buffer.from(bytes);
-            const riff = header.toString("ascii", 0, 4);
-            const wave = header.toString("ascii", 8, 12);
-            if (riff === "RIFF" && wave === "WAVE") {
-                format = "wav";
-                channels = header.readUInt16LE(22);
-                sampleRate = header.readUInt32LE(24);
-                const bitsPerSample = header.readUInt16LE(34);
-                const dataSize = header.readUInt32LE(40);
-                if (sampleRate > 0 && channels > 0 && bitsPerSample > 0) {
-                    duration = dataSize / (sampleRate * channels * (bitsPerSample / 8));
-                }
-            }
-        }
-        if (format === "unknown" && bytes.length >= 4) {
-            if (bytes[0] === 0xff && (bytes[1] & 0xe0) === 0xe0) {
-                format = "mp3";
-            }
-            else if (bytes[0] === 0x66 && bytes[1] === 0x4c &&
-                bytes[2] === 0x61 && bytes[3] === 0x43) {
-                format = "flac";
-            }
-            else if (bytes[0] === 0x4f && bytes[1] === 0x67 &&
-                bytes[2] === 0x67 && bytes[3] === 0x53) {
-                format = "ogg";
-            }
-        }
-        return {
-            duration: Math.round(duration * 1000) / 1000,
-            sample_rate: sampleRate,
-            channels,
-            format,
-            size_bytes: bytes.length
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio to inspect."
-    })
-], GetAudioInfoNode.prototype, "audio", void 0);
-export const AUDIO_NODES = [
-    LoadAudioAssetsNode,
-    LoadAudioFileNode,
-    LoadAudioFolderNode,
-    SaveAudioNode,
-    SaveAudioFileNode,
-    NormalizeAudioNode,
-    OverlayAudioNode,
-    RemoveSilenceNode,
-    SliceAudioNode,
-    MonoToStereoNode,
-    StereoToMonoNode,
-    ReverseAudioNode,
-    FadeInAudioNode,
-    FadeOutAudioNode,
-    RepeatAudioNode,
-    AudioMixerNode,
-    TrimAudioNode,
-    CreateSilenceNode,
-    ConcatAudioNode,
-    ConcatAudioListNode,
-    TextToSpeechNode,
-    ChunkToAudioNode,
-    GetAudioInfoNode
-];
-//# sourceMappingURL=audio.js.map