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

package/dist/nodes/audio.js

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