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

package/dist/nodes/video.js

@@ -1,2383 +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 { execFile as execFileCb } from "node:child_process";
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-import { audioBytes, toBytes } from "../lib/audio-wav.js";
-const execFile = promisify(execFileCb);
-function videoBytes(video) {
-    if (!video || typeof video !== "object")
-        return new Uint8Array();
-    return toBytes(video.data);
-}
-async function videoBytesAsync(video, context) {
-    if (!video || typeof video !== "object")
-        return new Uint8Array();
-    const ref = video;
-    if (ref.data)
-        return toBytes(ref.data);
-    if (typeof ref.uri === "string" && ref.uri) {
-        if (context?.storage) {
-            const stored = await context.storage.retrieve(ref.uri);
-            if (stored !== null)
-                return new Uint8Array(stored);
-        }
-        if (ref.uri.startsWith("file://")) {
-            return new Uint8Array(await fs.readFile(filePath(ref.uri)));
-        }
-        if (ref.uri.startsWith("http://") || ref.uri.startsWith("https://")) {
-            const response = await fetch(ref.uri);
-            return new Uint8Array(await response.arrayBuffer());
-        }
-    }
-    return new Uint8Array();
-}
-async function imageBytesAsync(image, context) {
-    if (!image || typeof image !== "object")
-        return new Uint8Array();
-    const ref = image;
-    if (ref.data)
-        return toBytes(ref.data);
-    if (typeof ref.uri === "string" && ref.uri) {
-        const uri = ref.uri;
-        const dataUriMatch = uri.match(/^data:[^;]*;base64,(.+)$/s);
-        if (dataUriMatch) {
-            return new Uint8Array(Buffer.from(dataUriMatch[1], "base64"));
-        }
-        if (context?.storage) {
-            const stored = await context.storage.retrieve(uri);
-            if (stored !== null)
-                return new Uint8Array(stored);
-        }
-        if (uri.startsWith("file://")) {
-            return new Uint8Array(await fs.readFile(filePath(uri)));
-        }
-        if (uri.startsWith("http://") || uri.startsWith("https://")) {
-            const response = await fetch(uri);
-            return new Uint8Array(await response.arrayBuffer());
-        }
-    }
-    return new Uint8Array();
-}
-function filePath(uriOrPath) {
-    if (uriOrPath.startsWith("file://")) {
-        try {
-            return fileURLToPath(new URL(uriOrPath));
-        }
-        catch {
-            // Fallback for non-standard URIs like file://C:\path
-            return uriOrPath.slice("file://".length);
-        }
-    }
-    return uriOrPath;
-}
-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 bytesConcat(parts) {
-    const total = parts.reduce((s, p) => s + p.length, 0);
-    const out = new Uint8Array(total);
-    let off = 0;
-    for (const p of parts) {
-        out.set(p, off);
-        off += p.length;
-    }
-    return out;
-}
-async function ffprobeDuration(filePath) {
-    try {
-        const { stdout } = await execFile("ffprobe", [
-            "-v",
-            "error",
-            "-show_entries",
-            "format=duration",
-            "-of",
-            "default=noprint_wrappers=1:nokey=1",
-            filePath
-        ]);
-        const val = parseFloat(stdout.trim());
-        return isNaN(val) ? 0 : val;
-    }
-    catch {
-        return 0;
-    }
-}
-function videoRef(data, extras = {}) {
-    return {
-        type: "video",
-        data: Buffer.from(data).toString("base64"),
-        ...extras
-    };
-}
-function modelConfig(props) {
-    const model = (props.model ?? {});
-    return {
-        providerId: typeof model.provider === "string" ? model.provider : "",
-        modelId: typeof model.id === "string" ? model.id : ""
-    };
-}
-function canUseProvider(context, providerId, modelId) {
-    return (!!context &&
-        typeof context.runProviderPrediction === "function" &&
-        !!providerId &&
-        !!modelId);
-}
-const VIDEO_ASPECT_RATIO_VALUES = [
-    "21:9",
-    "16:9",
-    "4:3",
-    "1:1",
-    "9:16",
-    "3:4"
-];
-const VIDEO_RESOLUTION_VALUES = ["720p", "1080p", "1440p", "4K"];
-const VIDEO_DURATION_VALUES = [2, 3, 4, 5, 6, 8];
-async function withTempFile(suffix, bytes) {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-video-"));
-    const file = path.join(dir, `input${suffix}`);
-    await fs.writeFile(file, bytes);
-    return {
-        path: file,
-        cleanup: async () => {
-            await fs.rm(dir, { recursive: true, force: true });
-        }
-    };
-}
-async function ffmpegTransform(video, args, extraInputs = []) {
-    if (video.length === 0)
-        return new Uint8Array();
-    const mainInput = await withTempFile(".mp4", video);
-    const others = await Promise.all(extraInputs.map((item) => withTempFile(item.suffix, item.bytes)));
-    const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-video-out-"));
-    const outputPath = path.join(outputDir, "output.mp4");
-    try {
-        const inputArgs = ["-y", "-i", mainInput.path];
-        for (const other of others)
-            inputArgs.push("-i", other.path);
-        await execFile("ffmpeg", [...inputArgs, ...args, outputPath], {
-            maxBuffer: 10 * 1024 * 1024
-        });
-        return new Uint8Array(await fs.readFile(outputPath));
-    }
-    catch {
-        return null;
-    }
-    finally {
-        await mainInput.cleanup();
-        for (const other of others)
-            await other.cleanup();
-        await fs.rm(outputDir, { recursive: true, force: true });
-    }
-}
-export class TextToVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.TextToVideo";
-    static title = "Text To Video";
-    static description = "Generate videos from text prompts using any supported video provider. Automatically routes to the appropriate backend (Gemini Veo, HuggingFace).\n    video, generation, AI, text-to-video, t2v";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    static basicFields = [
-        "model",
-        "prompt",
-        "aspect_ratio",
-        "resolution",
-        "duration"
-    ];
-    static exposeAsTool = true;
-    async process(context) {
-        const text = String(this.prompt ?? "");
-        const { providerId, modelId } = modelConfig(this.serialize());
-        if (canUseProvider(context, providerId, modelId)) {
-            const output = (await context.runProviderPrediction({
-                provider: providerId,
-                capability: "text_to_video",
-                model: modelId,
-                params: {
-                    prompt: text,
-                    negative_prompt: this.negative_prompt,
-                    duration_seconds: Number(this.duration ?? 0) || undefined,
-                    aspect_ratio: this.aspect_ratio,
-                    resolution: this.resolution
-                }
-            }));
-            return { output: videoRef(output) };
-        }
-        const bytes = Uint8Array.from(Buffer.from(text, "utf8"));
-        return { output: videoRef(bytes) };
-    }
-}
-__decorate([
-    prop({
-        type: "video_model",
-        default: {
-            type: "video_model",
-            provider: "gemini",
-            id: "veo-3.1-generate-preview",
-            name: "Veo 3.1 Preview",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "The video generation model to use"
-    })
-], TextToVideoNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "A cat playing with a ball of yarn",
-        title: "Prompt",
-        description: "Text prompt describing the desired video"
-    })
-], TextToVideoNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Negative Prompt",
-        description: "Text prompt describing what to avoid in the video"
-    })
-], TextToVideoNode.prototype, "negative_prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "16:9",
-        title: "Aspect Ratio",
-        description: "Aspect ratio for the video",
-        values: VIDEO_ASPECT_RATIO_VALUES,
-        json_schema_extra: { type: "media_aspect_ratio_video" }
-    })
-], TextToVideoNode.prototype, "aspect_ratio", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "1080p",
-        title: "Resolution",
-        description: "Video resolution",
-        values: VIDEO_RESOLUTION_VALUES,
-        json_schema_extra: { type: "media_resolution_video" }
-    })
-], TextToVideoNode.prototype, "resolution", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 8,
-        title: "Duration",
-        description: "Video duration in seconds",
-        values: VIDEO_DURATION_VALUES,
-        json_schema_extra: { type: "media_duration" }
-    })
-], TextToVideoNode.prototype, "duration", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Timeout Seconds",
-        description: "Timeout in seconds for API calls (0 = use provider default)",
-        min: 0,
-        max: 7200
-    })
-], TextToVideoNode.prototype, "timeout_seconds", void 0);
-export class ImageToVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.ImageToVideo";
-    static title = "Image To Video";
-    static description = "Generate videos from input images using any supported video provider.\n    Animates static images into dynamic video content with AI-powered motion.\n    video, image-to-video, i2v, animation, AI, generation, sora, veo";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    static basicFields = [
-        "image",
-        "model",
-        "prompt",
-        "aspect_ratio",
-        "resolution",
-        "duration"
-    ];
-    static exposeAsTool = true;
-    async process(context) {
-        const img = await imageBytesAsync(this.image, context);
-        const prompt = String(this.prompt ?? "");
-        const { providerId, modelId } = modelConfig(this.serialize());
-        if (canUseProvider(context, providerId, modelId)) {
-            const output = (await context.runProviderPrediction({
-                provider: providerId,
-                capability: "image_to_video",
-                model: modelId,
-                params: {
-                    image: img,
-                    prompt,
-                    negative_prompt: this.negative_prompt,
-                    duration_seconds: Number(this.duration ?? 0) || undefined,
-                    aspect_ratio: this.aspect_ratio,
-                    resolution: this.resolution
-                }
-            }));
-            return { output: videoRef(output) };
-        }
-        return {
-            output: videoRef(bytesConcat([img, Uint8Array.from(Buffer.from(prompt))]))
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The input image to animate into a video"
-    })
-], ImageToVideoNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "video_model",
-        default: {
-            type: "video_model",
-            provider: "gemini",
-            id: "veo-3.1-generate-preview",
-            name: "Veo 3.1 Preview",
-            path: null,
-            supported_tasks: []
-        },
-        title: "Model",
-        description: "The video generation model to use"
-    })
-], ImageToVideoNode.prototype, "model", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Prompt",
-        description: "Optional text prompt to guide the video animation"
-    })
-], ImageToVideoNode.prototype, "prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Negative Prompt",
-        description: "Text prompt describing what to avoid in the video"
-    })
-], ImageToVideoNode.prototype, "negative_prompt", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "16:9",
-        title: "Aspect Ratio",
-        description: "Aspect ratio for the video",
-        values: VIDEO_ASPECT_RATIO_VALUES,
-        json_schema_extra: { type: "media_aspect_ratio_video" }
-    })
-], ImageToVideoNode.prototype, "aspect_ratio", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "1080p",
-        title: "Resolution",
-        description: "Video resolution",
-        values: VIDEO_RESOLUTION_VALUES,
-        json_schema_extra: { type: "media_resolution_video" }
-    })
-], ImageToVideoNode.prototype, "resolution", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 4,
-        title: "Duration",
-        description: "Video duration in seconds",
-        values: VIDEO_DURATION_VALUES,
-        json_schema_extra: { type: "media_duration" }
-    })
-], ImageToVideoNode.prototype, "duration", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Timeout Seconds",
-        description: "Timeout in seconds for API calls (0 = use provider default)",
-        min: 0,
-        max: 7200
-    })
-], ImageToVideoNode.prototype, "timeout_seconds", void 0);
-export class LoadVideoFileNode extends BaseNode {
-    static nodeType = "nodetool.video.LoadVideoFile";
-    static title = "Load Video File";
-    static description = "Read a video file from disk.\n    video, input, load, file";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process() {
-        const p = filePath(String(this.path ?? ""));
-        const data = new Uint8Array(await fs.readFile(p));
-        return { output: videoRef(data, { uri: `file://${p}` }) };
-    }
-}
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Path",
-        description: "Path to the video file to read"
-    })
-], LoadVideoFileNode.prototype, "path", void 0);
-export class SaveVideoFileVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.SaveVideoFile";
-    static title = "Save Video File";
-    static description = "Write a video file to disk.\n    video, 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";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const folder = String(this.folder ?? ".");
-        const fname = dateName(String(this.filename ?? "video.mp4"));
-        const p = path.resolve(folder, fname);
-        await fs.mkdir(path.dirname(p), { recursive: true });
-        await fs.writeFile(p, await videoBytesAsync(this.video, context));
-        return { output: p };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The video to save"
-    })
-], SaveVideoFileVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Folder",
-        description: "Folder where the file will be saved"
-    })
-], SaveVideoFileVideoNode.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        "
-    })
-], SaveVideoFileVideoNode.prototype, "filename", void 0);
-export class LoadVideoAssetsNode extends BaseNode {
-    static nodeType = "nodetool.video.LoadVideoAssets";
-    static title = "Load Video Folder";
-    static description = "Load video files from an asset folder.\n\n    video, assets, load";
-    static metadataOutputTypes = {
-        video: "video",
-        name: "str",
-        videos: "list",
-        names: "list"
-    };
-    static isStreamingOutput = true;
-    async process() {
-        const allVideos = [];
-        const allNames = [];
-        for await (const item of this._loadVideos()) {
-            allVideos.push(item.video);
-            allNames.push(item.name);
-        }
-        return {
-            video: allVideos[0] ?? null,
-            name: allNames[0] ?? "",
-            videos: allVideos,
-            names: allNames
-        };
-    }
-    async *_loadVideos() {
-        const raw = this.folder;
-        const folder = typeof raw === "string" && raw.length > 0
-            ? raw.startsWith("file:")
-                ? filePath(raw)
-                : raw
-            : typeof raw === "object" && raw !== null && typeof raw.uri === "string" && raw.uri.length > 0
-                ? filePath(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 (![".mp4", ".mov", ".webm", ".mkv", ".avi"].includes(ext))
-                continue;
-            const full = path.join(folder, entry.name);
-            const data = new Uint8Array(await fs.readFile(full));
-            yield {
-                video: videoRef(data, { uri: `file://${full}` }),
-                name: entry.name
-            };
-        }
-    }
-    async *genProcess() {
-        const allVideos = [];
-        const allNames = [];
-        for await (const item of this._loadVideos()) {
-            allVideos.push(item.video);
-            allNames.push(item.name);
-            yield { video: item.video, name: item.name };
-        }
-        // Emit collected lists as final output
-        yield { videos: allVideos, names: allNames };
-    }
-}
-__decorate([
-    prop({
-        type: "folder",
-        default: {
-            type: "folder",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Folder",
-        description: "The asset folder to load the video files from."
-    })
-], LoadVideoAssetsNode.prototype, "folder", void 0);
-export class SaveVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.SaveVideo";
-    static title = "Save Video Asset";
-    static description = "Save a video to an asset folder.\n    video, save, file, output";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const folder = String(this.folder ?? ".");
-        const filename = dateName(String(this.name ?? "video.mp4"));
-        const full = path.resolve(folder, filename);
-        await fs.mkdir(path.dirname(full), { recursive: true });
-        const bytes = await videoBytesAsync(this.video, context);
-        await fs.writeFile(full, bytes);
-        return { output: videoRef(bytes, { uri: `file://${full}` }) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The video to save."
-    })
-], SaveVideoNode.prototype, "video", 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 video in."
-    })
-], SaveVideoNode.prototype, "folder", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "%Y-%m-%d-%H-%M-%S.mp4",
-        title: "Name",
-        description: "\n        Name of the output video.\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        "
-    })
-], SaveVideoNode.prototype, "name", void 0);
-export class FrameIteratorNode extends BaseNode {
-    static nodeType = "nodetool.video.FrameIterator";
-    static title = "Frame Iterator";
-    static description = "Extract frames from a video file using OpenCV.\n    video, frames, extract, sequence";
-    static metadataOutputTypes = {
-        frame: "image",
-        index: "int",
-        fps: "float"
-    };
-    static isStreamingOutput = true;
-    async process() {
-        return {};
-    }
-    async *genProcess(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        if (bytes.length === 0)
-            return;
-        const inputFile = await withTempFile(".mp4", bytes);
-        const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-frames-out-"));
-        try {
-            // Get FPS from the video for output metadata
-            let fps = 24;
-            try {
-                const { stdout } = await execFile("ffprobe", [
-                    "-v", "error",
-                    "-select_streams", "v:0",
-                    "-show_entries", "stream=r_frame_rate",
-                    "-of", "csv=p=0",
-                    inputFile.path
-                ]);
-                const parts = stdout.trim().split("/");
-                if (parts.length === 2) {
-                    fps = Number(parts[0]) / Number(parts[1]);
-                }
-                else if (parts.length === 1 && Number(parts[0]) > 0) {
-                    fps = Number(parts[0]);
-                }
-            }
-            catch {
-                // fall back to 24 fps
-            }
-            const start = Math.max(0, Number(this.start ?? 0));
-            const end = Number(this.end ?? -1);
-            const vfFilter = end >= 0
-                ? `select='between(n,${start},${end})'`
-                : `select='gte(n,${start})'`;
-            await execFile("ffmpeg", [
-                "-y",
-                "-i", inputFile.path,
-                "-vf", vfFilter,
-                "-vsync", "vfr",
-                path.join(outputDir, "frame_%d.png")
-            ], { maxBuffer: 50 * 1024 * 1024 });
-            // Read extracted frames in order
-            const entries = await fs.readdir(outputDir);
-            const frameFiles = entries
-                .filter((f) => f.startsWith("frame_") && f.endsWith(".png"))
-                .sort((a, b) => {
-                const numA = parseInt(a.replace("frame_", "").replace(".png", ""), 10);
-                const numB = parseInt(b.replace("frame_", "").replace(".png", ""), 10);
-                return numA - numB;
-            });
-            for (let i = 0; i < frameFiles.length; i++) {
-                const frameData = new Uint8Array(await fs.readFile(path.join(outputDir, frameFiles[i])));
-                yield {
-                    frame: {
-                        type: "image",
-                        data: Buffer.from(frameData).toString("base64")
-                    },
-                    index: start + i,
-                    fps
-                };
-            }
-        }
-        finally {
-            await inputFile.cleanup();
-            await fs.rm(outputDir, { recursive: true, force: true });
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to extract frames from."
-    })
-], FrameIteratorNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start",
-        description: "The frame to start extracting from."
-    })
-], FrameIteratorNode.prototype, "start", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End",
-        description: "The frame to stop extracting from."
-    })
-], FrameIteratorNode.prototype, "end", void 0);
-export class FpsNode extends BaseNode {
-    static nodeType = "nodetool.video.Fps";
-    static title = "Fps";
-    static description = "Get the frames per second (FPS) of a video file.\n    video, analysis, frames, fps";
-    static metadataOutputTypes = {
-        output: "float"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        if (bytes.length === 0)
-            return { output: 0 };
-        const inputFile = await withTempFile(".mp4", bytes);
-        try {
-            const { stdout } = await execFile("ffprobe", [
-                "-v", "error",
-                "-select_streams", "v:0",
-                "-show_entries", "stream=r_frame_rate",
-                "-of", "csv=p=0",
-                inputFile.path
-            ]);
-            const parts = stdout.trim().split("/");
-            let fps = 0;
-            if (parts.length === 2) {
-                fps = Number(parts[0]) / Number(parts[1]);
-            }
-            else if (parts.length === 1 && Number(parts[0]) > 0) {
-                fps = Number(parts[0]);
-            }
-            return { output: fps };
-        }
-        catch {
-            return { output: 0 };
-        }
-        finally {
-            await inputFile.cleanup();
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to analyze for FPS."
-    })
-], FpsNode.prototype, "video", void 0);
-export class FrameToVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.FrameToVideo";
-    static title = "Frame To Video";
-    static description = "Combine a sequence of frames into a single video file.\n    video, frames, combine, sequence";
-    static isStreamingInput = true;
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async run(inputs, outputs, _context) {
-        // Collect all frames from the streaming input
-        const frames = [];
-        let fps = Math.max(1, Number(this.fps ?? 30));
-        for await (const [handle, item] of inputs.any()) {
-            if (handle === "frame") {
-                frames.push(item);
-            }
-            else if (handle === "fps") {
-                fps = Math.max(1, Number(item ?? 30));
-            }
-        }
-        if (frames.length === 0) {
-            await outputs.emit("output", videoRef(new Uint8Array()));
-            return;
-        }
-        const inputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-ftv-in-"));
-        const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-ftv-out-"));
-        const outputPath = path.join(outputDir, "output.mp4");
-        try {
-            // Write each frame as a numbered PNG file
-            for (let i = 0; i < frames.length; i++) {
-                const f = frames[i];
-                if (!f || typeof f !== "object")
-                    continue;
-                const frameBytes = toBytes(f.data);
-                if (frameBytes.length === 0)
-                    continue;
-                await fs.writeFile(path.join(inputDir, `frame_${String(i + 1).padStart(6, "0")}.png`), frameBytes);
-            }
-            await execFile("ffmpeg", [
-                "-y",
-                "-framerate", String(fps),
-                "-i", path.join(inputDir, "frame_%06d.png"),
-                "-c:v", "libx264",
-                "-pix_fmt", "yuv420p",
-                outputPath
-            ], { maxBuffer: 50 * 1024 * 1024 });
-            const result = new Uint8Array(await fs.readFile(outputPath));
-            await outputs.emit("output", videoRef(result));
-        }
-        catch {
-            // Fallback: concatenate raw frame bytes
-            const parts = frames.map((f) => {
-                if (!f || typeof f !== "object")
-                    return new Uint8Array();
-                return toBytes(f.data);
-            });
-            await outputs.emit("output", videoRef(bytesConcat(parts)));
-        }
-        finally {
-            await fs.rm(inputDir, { recursive: true, force: true });
-            await fs.rm(outputDir, { recursive: true, force: true });
-        }
-    }
-    async process() {
-        // Legacy fallback for non-streaming usage (e.g., direct array input)
-        const frames = Array.isArray(this.frame) ? this.frame : [];
-        if (frames.length === 0)
-            return { output: videoRef(new Uint8Array()) };
-        const inputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-ftv-in-"));
-        const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-ftv-out-"));
-        const outputPath = path.join(outputDir, "output.mp4");
-        try {
-            for (let i = 0; i < frames.length; i++) {
-                const f = frames[i];
-                if (!f || typeof f !== "object")
-                    continue;
-                const frameBytes = toBytes(f.data);
-                if (frameBytes.length === 0)
-                    continue;
-                await fs.writeFile(path.join(inputDir, `frame_${String(i + 1).padStart(6, "0")}.png`), frameBytes);
-            }
-            const fps = Math.max(1, Number(this.fps ?? 30));
-            await execFile("ffmpeg", [
-                "-y",
-                "-framerate", String(fps),
-                "-i", path.join(inputDir, "frame_%06d.png"),
-                "-c:v", "libx264",
-                "-pix_fmt", "yuv420p",
-                outputPath
-            ], { maxBuffer: 50 * 1024 * 1024 });
-            const result = new Uint8Array(await fs.readFile(outputPath));
-            return { output: videoRef(result) };
-        }
-        catch {
-            const parts = frames.map((f) => {
-                if (!f || typeof f !== "object")
-                    return new Uint8Array();
-                return toBytes(f.data);
-            });
-            return { output: videoRef(bytesConcat(parts)) };
-        }
-        finally {
-            await fs.rm(inputDir, { recursive: true, force: true });
-            await fs.rm(outputDir, { recursive: true, force: true });
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Frame",
-        description: "Collect input frames"
-    })
-], FrameToVideoNode.prototype, "frame", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 30,
-        title: "Fps",
-        description: "The FPS of the output video."
-    })
-], FrameToVideoNode.prototype, "fps", void 0);
-class VideoTransformNode extends BaseNode {
-    static requiredRuntimes = ["ffmpeg"];
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        return { output: videoRef(bytes) };
-    }
-}
-export class ConcatVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.Concat";
-    static title = "Concat";
-    static description = "Concatenate multiple video files into a single video, including audio when available.\n    video, concat, merge, combine, audio, +";
-    static requiredRuntimes = ["ffmpeg"];
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    static isDynamic = true;
-    async process(context) {
-        const inputValues = [
-            this.video_a,
-            this.video_b,
-            ...Array.from(this.dynamicProps.values())
-        ];
-        const parts = [];
-        for (const input of inputValues) {
-            const bytes = await videoBytesAsync(input, context);
-            if (bytes.length > 0) {
-                parts.push(bytes);
-            }
-        }
-        if (parts.length === 0)
-            return { output: videoRef(new Uint8Array()) };
-        if (parts.length === 1)
-            return { output: videoRef(parts[0]) };
-        const inputs = await Promise.all(parts.map((bytes) => withTempFile(".mp4", bytes)));
-        const concatDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-concat-"));
-        const listPath = path.join(concatDir, "list.txt");
-        const outputPath = path.join(concatDir, "output.mp4");
-        try {
-            const listEntries = inputs
-                .map((input) => `file '${input.path}'`)
-                .join("\n");
-            await fs.writeFile(listPath, `${listEntries}\n`);
-            await execFile("ffmpeg", ["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", outputPath], { maxBuffer: 50 * 1024 * 1024 });
-            const result = new Uint8Array(await fs.readFile(outputPath));
-            return { output: videoRef(result) };
-        }
-        catch {
-            return { output: videoRef(bytesConcat(parts)) };
-        }
-        finally {
-            for (const input of inputs) {
-                await input.cleanup();
-            }
-            await fs.rm(concatDir, { recursive: true, force: true });
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video A",
-        description: "The first video to concatenate."
-    })
-], ConcatVideoNode.prototype, "video_a", void 0);
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video B",
-        description: "The second video to concatenate."
-    })
-], ConcatVideoNode.prototype, "video_b", void 0);
-export class TrimVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.Trim";
-    static title = "Trim";
-    static description = "Trim a video to a specific start and end time.\n    video, trim, cut, segment";
-    static requiredRuntimes = ["ffmpeg"];
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        if (bytes.length === 0)
-            return { output: videoRef(bytes) };
-        const start = Math.max(0, Number(this.start_time ?? 0));
-        const end = Number(this.end_time ?? -1);
-        const args = ["-ss", String(start)];
-        if (end >= 0) {
-            args.push("-to", String(end));
-        }
-        args.push("-c", "copy");
-        const transformed = (await ffmpegTransform(bytes, args)) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to trim."
-    })
-], TrimVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0,
-        title: "Start Time",
-        description: "The start time in seconds for the trimmed video."
-    })
-], TrimVideoNode.prototype, "start_time", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: -1,
-        title: "End Time",
-        description: "The end time in seconds for the trimmed video. Use -1 for the end of the video."
-    })
-], TrimVideoNode.prototype, "end_time", void 0);
-export class ResizeVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Resize";
-    static title = "Resize";
-    static description = "Resize a video to a specific width and height.\n    video, resize, scale, dimensions";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const width = Number(this.width ?? -1);
-        const height = Number(this.height ?? -1);
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `scale=${width}:${height}`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to resize."
-    })
-], ResizeVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "Width",
-        description: "The target width. Use -1 to maintain aspect ratio."
-    })
-], ResizeVideoNode.prototype, "width", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "Height",
-        description: "The target height. Use -1 to maintain aspect ratio."
-    })
-], ResizeVideoNode.prototype, "height", void 0);
-export class RotateVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Rotate";
-    static title = "Rotate";
-    static description = "Rotate a video by a specified angle.\n    video, rotate, orientation, transform";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const angle = Number(this.angle ?? 90);
-        const radians = (angle * Math.PI) / 180;
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `rotate=${radians}:ow=rotw(${radians}):oh=roth(${radians})`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to rotate."
-    })
-], RotateVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0,
-        title: "Angle",
-        description: "The angle of rotation in degrees.",
-        min: -360,
-        max: 360
-    })
-], RotateVideoNode.prototype, "angle", void 0);
-export class SetSpeedVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.SetSpeed";
-    static title = "Set Speed";
-    static description = "Adjust the playback speed of a video.\n    video, speed, tempo, time";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const speed = Math.max(0.1, Number(this.speed_factor ?? 1));
-        // Build chained atempo filters for values outside 0.5-2.0 range
-        // Each atempo filter is limited to 0.5-2.0, so we chain them
-        const buildAtempo = (s) => {
-            const parts = [];
-            let remaining = s;
-            if (remaining > 1) {
-                while (remaining > 2) {
-                    parts.push("atempo=2.0");
-                    remaining /= 2;
-                }
-                parts.push(`atempo=${remaining}`);
-            }
-            else {
-                while (remaining < 0.5) {
-                    parts.push("atempo=0.5");
-                    remaining /= 0.5;
-                }
-                parts.push(`atempo=${remaining}`);
-            }
-            return parts.join(",");
-        };
-        const atempoChain = buildAtempo(speed);
-        const transformed = (await ffmpegTransform(bytes, [
-            "-filter_complex",
-            `[0:v]setpts=${1 / speed}*PTS[v];[0:a]${atempoChain}[a]`,
-            "-map",
-            "[v]",
-            "-map",
-            "[a]"
-        ])) ??
-            (await ffmpegTransform(bytes, ["-vf", `setpts=${1 / speed}*PTS`])) ??
-            bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to adjust speed."
-    })
-], SetSpeedVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Speed Factor",
-        description: "The speed adjustment factor. Values > 1 speed up, < 1 slow down."
-    })
-], SetSpeedVideoNode.prototype, "speed_factor", void 0);
-export class OverlayVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Overlay";
-    static title = "Overlay";
-    static description = "Overlay one video on top of another, including audio overlay when available.\n    video, overlay, composite, picture-in-picture, audio";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const mainVideo = await videoBytesAsync(this.main_video, context);
-        const overlayVideo = await videoBytesAsync(this.overlay_video, context);
-        if (overlayVideo.length === 0)
-            return { output: videoRef(mainVideo) };
-        const x = Number(this.x ?? 0);
-        const y = Number(this.y ?? 0);
-        const scale = Math.max(0.01, Number(this.scale ?? 1));
-        const vol = Math.max(0, Math.min(1, Number(this.overlay_audio_volume ?? 0.5)));
-        // Try with audio mixing first, fall back to video-only overlay
-        const filterWithAudio = `[1:v]scale=iw*${scale}:ih*${scale}[ov];[0:v][ov]overlay=${x}:${y}[outv];` +
-            `[0:a]volume=1.0[a0];[1:a]volume=${vol}[a1];[a0][a1]amix=inputs=2:duration=first[outa]`;
-        const transformed = (await ffmpegTransform(mainVideo, [
-            "-filter_complex",
-            filterWithAudio,
-            "-map",
-            "[outv]",
-            "-map",
-            "[outa]"
-        ], [{ suffix: ".mp4", bytes: overlayVideo }])) ??
-            // Fallback: video-only overlay (one or both inputs may lack audio)
-            (await ffmpegTransform(mainVideo, [
-                "-filter_complex",
-                `[1:v]scale=iw*${scale}:ih*${scale}[ov];[0:v][ov]overlay=${x}:${y}`
-            ], [{ suffix: ".mp4", bytes: overlayVideo }])) ??
-            mainVideo;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Main Video",
-        description: "The main (background) video."
-    })
-], OverlayVideoNode.prototype, "main_video", void 0);
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Overlay Video",
-        description: "The video to overlay on top."
-    })
-], OverlayVideoNode.prototype, "overlay_video", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "X",
-        description: "X-coordinate for overlay placement."
-    })
-], OverlayVideoNode.prototype, "x", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Y",
-        description: "Y-coordinate for overlay placement."
-    })
-], OverlayVideoNode.prototype, "y", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Scale",
-        description: "Scale factor for the overlay video."
-    })
-], OverlayVideoNode.prototype, "scale", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0.5,
-        title: "Overlay Audio Volume",
-        description: "Volume of the overlay audio relative to the main audio.",
-        min: 0,
-        max: 1
-    })
-], OverlayVideoNode.prototype, "overlay_audio_volume", void 0);
-export class ColorBalanceVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.ColorBalance";
-    static title = "Color Balance";
-    static description = "Adjust the color balance of a video.\n    video, color, balance, adjustment";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        // Props are 0-2 range where 1.0 = neutral; colorbalance expects -1 to 1
-        const rs = Number(this.red_adjust ?? 1) - 1;
-        const gs = Number(this.green_adjust ?? 1) - 1;
-        const bs = Number(this.blue_adjust ?? 1) - 1;
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `colorbalance=rs=${rs}:gs=${gs}:bs=${bs}`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to adjust color balance."
-    })
-], ColorBalanceVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Red Adjust",
-        description: "Red channel adjustment factor.",
-        min: 0,
-        max: 2
-    })
-], ColorBalanceVideoNode.prototype, "red_adjust", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Green Adjust",
-        description: "Green channel adjustment factor.",
-        min: 0,
-        max: 2
-    })
-], ColorBalanceVideoNode.prototype, "green_adjust", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Blue Adjust",
-        description: "Blue channel adjustment factor.",
-        min: 0,
-        max: 2
-    })
-], ColorBalanceVideoNode.prototype, "blue_adjust", void 0);
-export class DenoiseVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Denoise";
-    static title = "Denoise";
-    static description = "Apply noise reduction to a video.\n    video, denoise, clean, enhance";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const strength = Number(this.strength ?? 5);
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `nlmeans=s=${strength}`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to denoise."
-    })
-], DenoiseVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 5,
-        title: "Strength",
-        description: "Strength of the denoising effect. Higher values mean more denoising.",
-        min: 0,
-        max: 20
-    })
-], DenoiseVideoNode.prototype, "strength", void 0);
-export class StabilizeVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Stabilize";
-    static title = "Stabilize";
-    static description = "Apply video stabilization to reduce camera shake and jitter.\n    video, stabilize, smooth, shake-reduction";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const smoothing = Math.max(1, Number(this.smoothing ?? 10));
-        const cropBlack = Boolean(this.crop_black ?? true);
-        // deshake with smoothing parameter
-        let vf = `deshake=smooth=${smoothing}`;
-        // If crop_black is enabled, chain cropdetect and crop to remove black borders
-        if (cropBlack) {
-            vf += ",cropdetect=24:16:0,crop";
-        }
-        const transformed = (await ffmpegTransform(bytes, ["-vf", vf, "-c:a", "copy"])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to stabilize."
-    })
-], StabilizeVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 10,
-        title: "Smoothing",
-        description: "Smoothing strength. Higher values result in smoother but potentially more cropped video.",
-        min: 1,
-        max: 100
-    })
-], StabilizeVideoNode.prototype, "smoothing", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: true,
-        title: "Crop Black",
-        description: "Whether to crop black borders that may appear after stabilization."
-    })
-], StabilizeVideoNode.prototype, "crop_black", void 0);
-export class SharpnessVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Sharpness";
-    static title = "Sharpness";
-    static description = "Adjust the sharpness of a video.\n    video, sharpen, enhance, detail";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const lumaAmount = Number(this.luma_amount ?? 1);
-        const chromaAmount = Number(this.chroma_amount ?? 0.5);
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `unsharp=5:5:${lumaAmount}:5:5:${chromaAmount}`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to sharpen."
-    })
-], SharpnessVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Luma Amount",
-        description: "Amount of sharpening to apply to luma (brightness) channel.",
-        min: 0,
-        max: 3
-    })
-], SharpnessVideoNode.prototype, "luma_amount", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0.5,
-        title: "Chroma Amount",
-        description: "Amount of sharpening to apply to chroma (color) channels.",
-        min: 0,
-        max: 3
-    })
-], SharpnessVideoNode.prototype, "chroma_amount", void 0);
-export class BlurVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Blur";
-    static title = "Blur";
-    static description = "Apply a blur effect to a video.\n    video, blur, smooth, soften";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const radius = Math.max(1, Number(this.strength ?? 2));
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `boxblur=${radius}:${radius}`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to apply blur effect."
-    })
-], BlurVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 5,
-        title: "Strength",
-        description: "The strength of the blur effect. Higher values create a stronger blur.",
-        min: 0,
-        max: 20
-    })
-], BlurVideoNode.prototype, "strength", void 0);
-export class SaturationVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Saturation";
-    static title = "Saturation";
-    static description = "Adjust the color saturation of a video.\n    video, saturation, color, enhance";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const saturation = Number(this.saturation ?? 1.2);
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `eq=saturation=${saturation}`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to adjust saturation."
-    })
-], SaturationVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Saturation",
-        description: "Saturation level. 1.0 is original, <1 decreases saturation, >1 increases saturation.",
-        min: 0,
-        max: 3
-    })
-], SaturationVideoNode.prototype, "saturation", void 0);
-export class AddSubtitlesVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.AddSubtitles";
-    static title = "Add Subtitles";
-    static description = "Add subtitles to a video.\n    video, subtitles, text, caption";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const chunks = Array.isArray(this.chunks) ? this.chunks : [];
-        if (chunks.length === 0)
-            return { output: videoRef(bytes) };
-        const fontSize = Math.max(1, Number(this.font_size ?? 24));
-        const fontColorObj = this.font_color;
-        const fontColor = String(fontColorObj?.value ?? "#FFFFFF").replace("#", "0x");
-        const fontName = String(this.font?.name ?? "Sans");
-        const align = String(this.align ?? "bottom");
-        // Compute y position based on alignment
-        let yExpr;
-        if (align === "top") {
-            yExpr = "text_h";
-        }
-        else if (align === "center") {
-            yExpr = "(h-text_h)/2";
-        }
-        else {
-            // bottom
-            yExpr = "h-(text_h*2)";
-        }
-        // Build chained drawtext filters, one per chunk with enable=between(t,start,end)
-        const drawFilters = chunks
-            .map((chunk) => {
-            const text = String(chunk.text ?? chunk.content ?? "").trim();
-            if (!text)
-                return null;
-            const ts = Array.isArray(chunk.timestamp) ? chunk.timestamp : [];
-            const start = Number(ts[0] ?? chunk.start ?? 0);
-            const end = Number(ts[1] ?? chunk.end ?? start + 5);
-            const escaped = text
-                .replaceAll("\\", "\\\\")
-                .replaceAll(":", "\\:")
-                .replaceAll("'", "\u2019")
-                .replaceAll("%", "%%");
-            return (`drawtext=text='${escaped}'` +
-                `:x=(w-text_w)/2:y=${yExpr}` +
-                `:fontcolor=${fontColor}:fontsize=${fontSize}` +
-                `:font='${fontName}'` +
-                `:enable='between(t,${start},${end})'`);
-        })
-            .filter(Boolean);
-        if (drawFilters.length === 0)
-            return { output: videoRef(bytes) };
-        const vf = drawFilters.join(",");
-        const transformed = (await ffmpegTransform(bytes, ["-vf", vf, "-c:a", "copy"])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to add subtitles to."
-    })
-], AddSubtitlesVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "list[audio_chunk]",
-        default: [],
-        title: "Chunks",
-        description: "Audio chunks to add as subtitles."
-    })
-], AddSubtitlesVideoNode.prototype, "chunks", void 0);
-__decorate([
-    prop({
-        type: "font",
-        default: {
-            type: "font",
-            name: "",
-            source: "system",
-            url: "",
-            weight: "regular"
-        },
-        title: "Font",
-        description: "The font to use."
-    })
-], AddSubtitlesVideoNode.prototype, "font", void 0);
-__decorate([
-    prop({
-        type: "enum",
-        default: "bottom",
-        title: "Align",
-        description: "Vertical alignment of subtitles.",
-        values: ["top", "center", "bottom"]
-    })
-], AddSubtitlesVideoNode.prototype, "align", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 24,
-        title: "Font Size",
-        description: "The font size.",
-        min: 1,
-        max: 72
-    })
-], AddSubtitlesVideoNode.prototype, "font_size", void 0);
-__decorate([
-    prop({
-        type: "color",
-        default: {
-            type: "color",
-            value: "#FFFFFF"
-        },
-        title: "Font Color",
-        description: "The font color."
-    })
-], AddSubtitlesVideoNode.prototype, "font_color", void 0);
-export class ReverseVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.Reverse";
-    static requiredRuntimes = ["ffmpeg"];
-    static title = "Reverse";
-    static description = "Reverse the playback of a video.\n    video, reverse, backwards, effect";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        if (bytes.length === 0)
-            return { output: videoRef(bytes) };
-        // Try with both video and audio reverse, fall back to video-only
-        const transformed = (await ffmpegTransform(bytes, ["-vf", "reverse", "-af", "areverse"])) ??
-            (await ffmpegTransform(bytes, ["-vf", "reverse"])) ??
-            bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to reverse."
-    })
-], ReverseVideoNode.prototype, "video", void 0);
-export class TransitionVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.Transition";
-    static title = "Transition";
-    static description = "Create a transition effect between two videos, including audio transition when available.\n    video, transition, effect, merge, audio";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const a = await videoBytesAsync(this.video_a, context);
-        const b = await videoBytesAsync(this.video_b, context);
-        if (b.length === 0)
-            return { output: videoRef(a) };
-        const duration = Math.max(0.1, Number(this.duration ?? 1));
-        const transitionType = String(this.transition_type ?? "fade");
-        // Probe video_a duration to compute offset (transition starts at end of video_a)
-        const tempA = await withTempFile(".mp4", a);
-        let offsetVal;
-        try {
-            const aDuration = await ffprobeDuration(tempA.path);
-            offsetVal = Math.max(0, aDuration - duration);
-        }
-        finally {
-            await tempA.cleanup();
-        }
-        // Try with audio crossfade first, then fall back to video-only
-        const filterWithAudio = `[0:v][1:v]xfade=transition=${transitionType}:duration=${duration}:offset=${offsetVal}[outv];` +
-            `[0:a][1:a]acrossfade=d=${duration}[outa]`;
-        const transformed = (await ffmpegTransform(a, [
-            "-filter_complex",
-            filterWithAudio,
-            "-map",
-            "[outv]",
-            "-map",
-            "[outa]"
-        ], [{ suffix: ".mp4", bytes: b }])) ??
-            // Fallback: video-only xfade (inputs may lack audio)
-            (await ffmpegTransform(a, [
-                "-filter_complex",
-                `[0:v][1:v]xfade=transition=${transitionType}:duration=${duration}:offset=${offsetVal}`
-            ], [{ suffix: ".mp4", bytes: b }])) ??
-            videoBytes({ data: Buffer.from(bytesConcat([a, b])).toString("base64") });
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video A",
-        description: "The first video in the transition."
-    })
-], TransitionVideoNode.prototype, "video_a", void 0);
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video B",
-        description: "The second video in the transition."
-    })
-], TransitionVideoNode.prototype, "video_b", void 0);
-__decorate([
-    prop({
-        type: "enum",
-        default: "fade",
-        title: "Transition Type",
-        description: "Type of transition effect",
-        values: [
-            "fade",
-            "wipeleft",
-            "wiperight",
-            "wipeup",
-            "wipedown",
-            "slideleft",
-            "slideright",
-            "slideup",
-            "slidedown",
-            "circlecrop",
-            "rectcrop",
-            "distance",
-            "fadeblack",
-            "fadewhite",
-            "radial",
-            "smoothleft",
-            "smoothright",
-            "smoothup",
-            "smoothdown",
-            "circleopen",
-            "circleclose",
-            "vertopen",
-            "vertclose",
-            "horzopen",
-            "horzclose",
-            "dissolve",
-            "pixelize",
-            "diagtl",
-            "diagtr",
-            "diagbl",
-            "diagbr",
-            "hlslice",
-            "hrslice",
-            "vuslice",
-            "vdslice",
-            "hblur",
-            "fadegrays",
-            "wipetl",
-            "wipetr",
-            "wipebl",
-            "wipebr",
-            "squeezeh",
-            "squeezev",
-            "zoomin",
-            "fadefast",
-            "fadeslow",
-            "hlwind",
-            "hrwind",
-            "vuwind",
-            "vdwind",
-            "coverleft",
-            "coverright",
-            "coverup",
-            "coverdown",
-            "revealleft",
-            "revealright",
-            "revealup",
-            "revealdown"
-        ]
-    })
-], TransitionVideoNode.prototype, "transition_type", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Duration",
-        description: "Duration of the transition effect in seconds.",
-        min: 0.1,
-        max: 5
-    })
-], TransitionVideoNode.prototype, "duration", void 0);
-export class AddAudioVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.AddAudio";
-    static requiredRuntimes = ["ffmpeg"];
-    static title = "Add Audio";
-    static description = "Add an audio track to a video, replacing or mixing with existing audio.\n    video, audio, soundtrack, merge";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const v = await videoBytesAsync(this.video, context);
-        const a = audioBytes(this.audio);
-        if (v.length === 0)
-            return { output: videoRef(v) };
-        if (a.length === 0)
-            return { output: videoRef(v) };
-        const videoInput = await withTempFile(".mp4", v);
-        const audioInput = await withTempFile(".wav", a);
-        const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-addaudio-out-"));
-        const outputPath = path.join(outputDir, "output.mp4");
-        try {
-            const volume = Math.max(0, Number(this.volume ?? 1));
-            const mix = Boolean(this.mix);
-            const args = [
-                "-y",
-                "-i", videoInput.path,
-                "-i", audioInput.path
-            ];
-            if (mix) {
-                // Mix new audio with existing audio
-                args.push("-filter_complex", `[1:a]volume=${volume}[newaud];[0:a][newaud]amix=inputs=2:duration=first[aout]`, "-map", "0:v:0", "-map", "[aout]", "-c:v", "copy");
-            }
-            else {
-                // Replace existing audio
-                args.push("-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy", "-c:a", "aac");
-                if (volume !== 1) {
-                    // Insert volume filter before output
-                    args.splice(args.length, 0);
-                    // Re-build with filter
-                    args.length = 0;
-                    args.push("-y", "-i", videoInput.path, "-i", audioInput.path, "-filter_complex", `[1:a]volume=${volume}[aout]`, "-map", "0:v:0", "-map", "[aout]", "-c:v", "copy", "-c:a", "aac");
-                }
-            }
-            args.push(outputPath);
-            await execFile("ffmpeg", args, { maxBuffer: 50 * 1024 * 1024 });
-            const result = new Uint8Array(await fs.readFile(outputPath));
-            return { output: videoRef(result) };
-        }
-        catch {
-            return { output: videoRef(v) };
-        }
-        finally {
-            await videoInput.cleanup();
-            await audioInput.cleanup();
-            await fs.rm(outputDir, { recursive: true, force: true });
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to add audio to."
-    })
-], AddAudioVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "audio",
-        default: {
-            type: "audio",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Audio",
-        description: "The audio file to add to the video."
-    })
-], AddAudioVideoNode.prototype, "audio", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 1,
-        title: "Volume",
-        description: "Volume adjustment for the added audio. 1.0 is original volume.",
-        min: 0,
-        max: 2
-    })
-], AddAudioVideoNode.prototype, "volume", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: false,
-        title: "Mix",
-        description: "If True, mix new audio with existing. If False, replace existing audio."
-    })
-], AddAudioVideoNode.prototype, "mix", void 0);
-export class ChromaKeyVideoNode extends VideoTransformNode {
-    static nodeType = "nodetool.video.ChromaKey";
-    static title = "Chroma Key";
-    static description = "Apply chroma key (green screen) effect to a video.\n    video, chroma key, green screen, compositing";
-    static metadataOutputTypes = {
-        output: "video"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        const color = String(this.key_color ?? "0x00FF00");
-        const similarity = Number(this.similarity ?? 0.1);
-        const blend = Number(this.blend ?? 0.0);
-        const transformed = (await ffmpegTransform(bytes, [
-            "-vf",
-            `colorkey=${color}:${similarity}:${blend}`,
-            "-c:a",
-            "copy"
-        ])) ?? bytes;
-        return { output: videoRef(transformed) };
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to apply chroma key effect."
-    })
-], ChromaKeyVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "color",
-        default: {
-            type: "color",
-            value: "#00FF00"
-        },
-        title: "Key Color",
-        description: "The color to key out (e.g., '#00FF00' for green)."
-    })
-], ChromaKeyVideoNode.prototype, "key_color", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0.3,
-        title: "Similarity",
-        description: "Similarity threshold for the key color.",
-        min: 0,
-        max: 1
-    })
-], ChromaKeyVideoNode.prototype, "similarity", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0.1,
-        title: "Blend",
-        description: "Blending of the keyed area edges.",
-        min: 0,
-        max: 1
-    })
-], ChromaKeyVideoNode.prototype, "blend", void 0);
-export class ExtractAudioVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.ExtractAudio";
-    static requiredRuntimes = ["ffmpeg"];
-    static title = "Extract Audio";
-    static description = "Separate and extract audio track from a video file.\n    video, audio, extract, separate, split";
-    static metadataOutputTypes = {
-        output: "audio"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        if (bytes.length === 0)
-            return { output: { data: null } };
-        const input = await withTempFile(".mp4", bytes);
-        const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-audio-out-"));
-        const outputPath = path.join(outputDir, "output.wav");
-        try {
-            await execFile("ffmpeg", ["-y", "-i", input.path, "-vn", "-acodec", "pcm_s16le", outputPath], { maxBuffer: 50 * 1024 * 1024 });
-            const audioBytes = new Uint8Array(await fs.readFile(outputPath));
-            const b64 = Buffer.from(audioBytes).toString("base64");
-            return {
-                output: {
-                    type: "audio",
-                    data: b64,
-                    uri: "",
-                    asset_id: null,
-                    metadata: null
-                }
-            };
-        }
-        finally {
-            await input.cleanup();
-            await fs.rm(outputDir, { recursive: true, force: true });
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to separate."
-    })
-], ExtractAudioVideoNode.prototype, "video", void 0);
-export class ExtractFrameVideoNode extends BaseNode {
-    static nodeType = "nodetool.video.ExtractFrame";
-    static requiredRuntimes = ["ffmpeg"];
-    static title = "Extract Frame";
-    static description = "Extract a single frame from a video at a specific time position.\n    video, frame, extract, screenshot, thumbnail, capture";
-    static metadataOutputTypes = {
-        output: "image"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        if (bytes.length === 0) {
-            return { output: { type: "image", data: null } };
-        }
-        const inputFile = await withTempFile(".mp4", bytes);
-        const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-extract-frame-"));
-        const outputPath = path.join(outputDir, "frame.png");
-        try {
-            const time = Math.max(0, Number(this.time ?? 0));
-            await execFile("ffmpeg", [
-                "-y",
-                "-ss", String(time),
-                "-i", inputFile.path,
-                "-frames:v", "1",
-                "-f", "image2",
-                outputPath
-            ], { maxBuffer: 10 * 1024 * 1024 });
-            const frameData = new Uint8Array(await fs.readFile(outputPath));
-            return {
-                output: {
-                    type: "image",
-                    data: Buffer.from(frameData).toString("base64")
-                }
-            };
-        }
-        catch {
-            return { output: { type: "image", data: null } };
-        }
-        finally {
-            await inputFile.cleanup();
-            await fs.rm(outputDir, { recursive: true, force: true });
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to extract a frame from."
-    })
-], ExtractFrameVideoNode.prototype, "video", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 0,
-        title: "Time",
-        description: "Time position in seconds to extract the frame from.",
-        min: 0
-    })
-], ExtractFrameVideoNode.prototype, "time", void 0);
-export class GetVideoInfoNode extends BaseNode {
-    static nodeType = "nodetool.video.GetVideoInfo";
-    static title = "Get Video Info";
-    static description = "Get metadata information about a video file.\n    Includes duration, resolution, frame rate, and codec.\n    video, info, metadata, duration, resolution, fps, codec, analysis";
-    static metadataOutputTypes = {
-        duration: "float",
-        width: "int",
-        height: "int",
-        fps: "float",
-        frame_count: "int",
-        codec: "str",
-        has_audio: "bool"
-    };
-    async process(context) {
-        const bytes = await videoBytesAsync(this.video, context);
-        if (bytes.length === 0) {
-            return {
-                duration: 0,
-                width: 0,
-                height: 0,
-                fps: 0,
-                frame_count: 0,
-                codec: "",
-                has_audio: false
-            };
-        }
-        const inputFile = await withTempFile(".mp4", bytes);
-        try {
-            const { stdout } = await execFile("ffprobe", [
-                "-v", "error",
-                "-show_streams",
-                "-show_format",
-                "-of", "json",
-                inputFile.path
-            ]);
-            const info = JSON.parse(stdout);
-            const videoStream = (info.streams ?? []).find((s) => s.codec_type === "video");
-            const hasAudio = (info.streams ?? []).some((s) => s.codec_type === "audio");
-            let fps = 0;
-            if (videoStream?.r_frame_rate) {
-                const parts = videoStream.r_frame_rate.split("/");
-                if (parts.length === 2) {
-                    fps = Number(parts[0]) / Number(parts[1]);
-                }
-                else if (parts.length === 1) {
-                    fps = Number(parts[0]);
-                }
-            }
-            const duration = Number(info.format?.duration ?? 0);
-            const frameCount = videoStream?.nb_frames
-                ? Number(videoStream.nb_frames)
-                : Math.round(duration * fps);
-            return {
-                duration,
-                width: videoStream?.width ?? 0,
-                height: videoStream?.height ?? 0,
-                fps,
-                frame_count: frameCount,
-                codec: videoStream?.codec_name ?? "",
-                has_audio: hasAudio
-            };
-        }
-        catch {
-            return {
-                duration: 0,
-                width: 0,
-                height: 0,
-                fps: 0,
-                frame_count: 0,
-                codec: "",
-                has_audio: false
-            };
-        }
-        finally {
-            await inputFile.cleanup();
-        }
-    }
-}
-__decorate([
-    prop({
-        type: "video",
-        default: {
-            type: "video",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null,
-            duration: null,
-            format: null
-        },
-        title: "Video",
-        description: "The input video to analyze."
-    })
-], GetVideoInfoNode.prototype, "video", void 0);
-export const VIDEO_NODES = [
-    TextToVideoNode,
-    ImageToVideoNode,
-    LoadVideoFileNode,
-    SaveVideoFileVideoNode,
-    LoadVideoAssetsNode,
-    SaveVideoNode,
-    FrameIteratorNode,
-    FpsNode,
-    FrameToVideoNode,
-    ConcatVideoNode,
-    TrimVideoNode,
-    ResizeVideoNode,
-    RotateVideoNode,
-    SetSpeedVideoNode,
-    OverlayVideoNode,
-    ColorBalanceVideoNode,
-    DenoiseVideoNode,
-    StabilizeVideoNode,
-    SharpnessVideoNode,
-    BlurVideoNode,
-    SaturationVideoNode,
-    AddSubtitlesVideoNode,
-    ReverseVideoNode,
-    TransitionVideoNode,
-    AddAudioVideoNode,
-    ChromaKeyVideoNode,
-    ExtractAudioVideoNode,
-    ExtractFrameVideoNode,
-    GetVideoInfoNode
-];
-//# sourceMappingURL=video.js.map