@nodetool-ai/video-nodes 0.8.1

package/dist/nodes/video.js

@@ -0,0 +1,2672 @@
+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 { isRawRgbaImage } from "@nodetool-ai/protocol";
+import { loadMediaRefBytes, mapPromptAssetsToInputs, resolveEntities } from "@nodetool-ai/runtime";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { audioBytesAsync, toBytes } from "@nodetool-ai/audio-nodes";
+import { MissingBinaryError, execFfmpeg, execFfprobe, videoRef, defaultVideoRef, filePath, folderPath, dateName, uniqueTargetPath, parseFrameRate, ffprobeDuration, withTempFile, coerceProviderBytes, FFMPEG_MAX_BUFFER } from "./ffmpeg-helpers.js";
+import { isObjectLike, isString } from "@nodetool-ai/node-sdk";
+import { writeSavedFile, VISIBLE_WHEN_NOT_SAVING_TO_WORKSPACE, SAVE_TO_WORKSPACE_DESCRIPTION, SAVE_TO_WORKSPACE_TITLE } from "@nodetool-ai/nodes-utils";
+async function videoBytesAsync(video, context) {
+    if (!isObjectLike(video))
+        return new Uint8Array();
+    const bytes = await loadMediaRefBytes(video, context);
+    return bytes ?? new Uint8Array();
+}
+async function imageBytesAsync(image, context) {
+    if (!isObjectLike(image))
+        return new Uint8Array();
+    const bytes = await loadMediaRefBytes(image, context);
+    return bytes ?? new Uint8Array();
+}
+/**
+ * Whether an image ref already points at a source (wired upstream, a stored
+ * asset, or inline bytes) rather than the empty default — used to decide if an
+ * inline `asset://` mention in the prompt should supply the input.
+ */
+function imageRefHasSource(image) {
+    if (!isObjectLike(image))
+        return false;
+    const ref = image;
+    if (isString(ref.uri) && ref.uri.trim() !== "")
+        return true;
+    if (ref.data != null && ref.data !== "")
+        return true;
+    return ref.asset_id != null && ref.asset_id !== "";
+}
+/**
+ * Normalize an image input that may be a single ImageRef (legacy single-image
+ * wiring) or a list of refs into an array, dropping non-object entries.
+ */
+function normalizeImageList(value) {
+    const items = Array.isArray(value) ? value : value != null ? [value] : [];
+    return items.filter((item) => !!item && typeof item === "object");
+}
+/**
+ * Normalize a video input that may be a single VideoRef or a list of refs into
+ * an array, dropping non-object entries. Lets a concat input accept either a
+ * single wired video or a `list<video>` from an upstream loop/list node.
+ */
+function normalizeVideoList(value) {
+    const items = Array.isArray(value) ? value : value != null ? [value] : [];
+    return items.filter((item) => !!item && typeof item === "object");
+}
+/**
+ * Parse cropdetect's suggested crop from ffmpeg stderr. cropdetect logs one
+ * `crop=w:h:x:y` per analyzed frame; the last suggestion reflects the full
+ * analysis, so return that. Null when no suggestion is present.
+ */
+export function parseCropDetectCrop(stderr) {
+    const matches = stderr.match(/crop=(\d+:\d+:\d+:\d+)/g);
+    if (!matches || matches.length === 0)
+        return null;
+    const last = matches[matches.length - 1];
+    return last.slice("crop=".length);
+}
+/**
+ * Encode a sequence of frame refs into an H.264 MP4.
+ *
+ * Frames arrive in one of two shapes and the demuxer differs for each:
+ *   - In-flight **raw-RGBA** refs ({@link isRawRgbaImage}) carry uncompressed
+ *     pixels in `data` plus `width`/`height`. These are NOT a decodable image —
+ *     writing them to `frame_*.png` makes ffmpeg fail with "Invalid PNG
+ *     signature". They must be fed through the `rawvideo` demuxer instead.
+ *   - **Encoded** refs carry PNG/JPEG bytes (Uint8Array or base64 string),
+ *     which the `image2` demuxer reads from numbered files.
+ *
+ * A frame sequence from a single generator is homogeneous, so the encoding of
+ * the first usable frame selects the path; stray frames of the other kind (or
+ * with mismatched raw dimensions) are skipped.
+ */
+async function combineFramesToVideo(frames, fps) {
+    const isUsable = (f) => {
+        if (!isObjectLike(f))
+            return false;
+        if (isRawRgbaImage(f))
+            return f.data.length > 0;
+        return toBytes(f.data).length > 0;
+    };
+    const first = frames.find(isUsable);
+    if (!first)
+        return 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 {
+        if (isRawRgbaImage(first)) {
+            const { width, height } = first;
+            // Append each frame to the raw file as it is visited. 300 frames of 1080p
+            // RGBA is ~2.5 GB — Buffer.concat'ing them all would blow up memory.
+            const rawPath = path.join(inputDir, "frames.raw");
+            const handle = await fs.open(rawPath, "w");
+            let framesWritten = 0;
+            try {
+                for (const f of frames) {
+                    if (isRawRgbaImage(f) &&
+                        f.data.length > 0 &&
+                        f.width === width &&
+                        f.height === height) {
+                        await handle.write(Buffer.from(f.data.buffer, f.data.byteOffset, f.data.byteLength));
+                        framesWritten += 1;
+                    }
+                }
+            }
+            finally {
+                await handle.close();
+            }
+            if (framesWritten === 0)
+                return new Uint8Array();
+            await execFfmpeg([
+                "-y",
+                "-f", "rawvideo",
+                "-pixel_format", "rgba",
+                "-video_size", `${width}x${height}`,
+                "-framerate", String(fps),
+                "-i", rawPath,
+                "-c:v", "libx264",
+                "-pix_fmt", "yuv420p",
+                outputPath
+            ], { maxBuffer: 50 * 1024 * 1024 });
+        }
+        else {
+            // Contiguous counter so skipped frames don't leave gaps in the numbered
+            // sequence (ffmpeg's image2 demuxer stops at the first missing number).
+            let written = 0;
+            for (const f of frames) {
+                if (!isObjectLike(f) || isRawRgbaImage(f))
+                    continue;
+                const frameBytes = toBytes(f.data);
+                if (frameBytes.length === 0)
+                    continue;
+                written += 1;
+                await fs.writeFile(path.join(inputDir, `frame_${String(written).padStart(6, "0")}.png`), frameBytes);
+            }
+            if (written === 0)
+                return new Uint8Array();
+            await execFfmpeg([
+                "-y",
+                "-framerate", String(fps),
+                "-i", path.join(inputDir, "frame_%06d.png"),
+                "-c:v", "libx264",
+                "-pix_fmt", "yuv420p",
+                outputPath
+            ], { maxBuffer: 50 * 1024 * 1024 });
+        }
+        return new Uint8Array(await fs.readFile(outputPath));
+    }
+    finally {
+        // execFfmpeg already maps a missing binary to a clear error; a genuine
+        // fs error (writing frames / reading output) propagates as itself rather
+        // than being mislabeled.
+        await fs.rm(inputDir, { recursive: true, force: true });
+        await fs.rm(outputDir, { recursive: true, force: true });
+    }
+}
+function modelConfig(props) {
+    const model = (props.model ?? {});
+    return {
+        providerId: isString(model.provider) ? model.provider : "",
+        modelId: isString(model.id) ? 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, 10, 12, 15];
+async function ffmpegTransform(video, args, options = {}) {
+    if (video.length === 0)
+        return new Uint8Array();
+    const mainInput = await withTempFile(".mp4", video);
+    const others = await Promise.all((options.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", ...(options.preInputArgs ?? []), "-i", mainInput.path];
+        for (const other of others)
+            inputArgs.push("-i", other.path);
+        await execFfmpeg([...inputArgs, ...args, outputPath], {
+            maxBuffer: 10 * 1024 * 1024
+        });
+        return new Uint8Array(await fs.readFile(outputPath));
+    }
+    catch (error) {
+        // A missing binary is unrecoverable — surface it. A genuine ffmpeg failure
+        // returns null only when the caller allows a chained fallback; otherwise it
+        // throws with stderr rather than silently passing the input through.
+        if (error instanceof MissingBinaryError)
+            throw error;
+        if (options.allowFallback)
+            return null;
+        const stderr = error.stderr;
+        const detail = (isString(stderr) && stderr.trim()) || error.message;
+        throw new Error(`ffmpeg failed: ${detail}`);
+    }
+    finally {
+        await mainInput.cleanup();
+        for (const other of others)
+            await other.cleanup();
+        await fs.rm(outputDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Base for every ffmpeg-backed node. Carries only the runtime gate; each node
+ * declares its own props and `process()`.
+ */
+class VideoTransformNode extends BaseNode {
+    static requiredRuntimes = ["ffmpeg"];
+}
+export class TextToVideoNode extends BaseNode {
+    static nodeType = "nodetool.video.TextToVideo";
+    static body = "content_card";
+    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 inlineFields = [];
+    static inputFields = ["prompt"];
+    static autoSaveAsset = true;
+    async process(context) {
+        const text = String(this.prompt ?? "");
+        const { providerId, modelId } = modelConfig(this.serialize());
+        if (!canUseProvider(context, providerId, modelId)) {
+            throw new Error("No provider available for text-to-video generation.");
+        }
+        const output = coerceProviderBytes(await context.runProviderPrediction({
+            provider: providerId,
+            capability: "text_to_video",
+            model: modelId,
+            params: {
+                prompt: text,
+                negative_prompt: this.negative_prompt,
+                entities: await resolveEntities(this.entities, context),
+                duration_seconds: Number(this.duration ?? 0) || undefined,
+                aspect_ratio: this.aspect_ratio,
+                resolution: this.resolution,
+                timeout_seconds: Number(this.timeout_seconds ?? 0) || undefined
+            }
+        }), "Text To Video");
+        return { output: videoRef(output) };
+    }
+}
+__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: "list[entity]",
+        default: [],
+        title: "Entities",
+        description: "Consistency entities (characters, styles, locations) whose descriptors are injected into the prompt"
+    })
+], TextToVideoNode.prototype, "entities", 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 body = "content_card";
+    static title = "Image To Video";
+    static description = "Animate static images into video with AI-powered motion using any supported video provider.\n    video, image-to-video, i2v, animation, ai, generation, sora, veo";
+    static metadataOutputTypes = {
+        output: "video"
+    };
+    static inlineFields = [];
+    static inputFields = ["image", "prompt"];
+    static autoSaveAsset = true;
+    async process(context) {
+        let images = normalizeImageList(this.image);
+        let prompt = String(this.prompt ?? "");
+        // An `asset://` image mentioned inline in the prompt (e.g. from the Prompt
+        // composer's @-mention) supplies the source frame when none is wired in,
+        // and is stripped from the textual instruction. Same mechanism as the
+        // image-to-image / provider video nodes.
+        const overrides = await mapPromptAssetsToInputs([{ name: "prompt", value: prompt }], [
+            {
+                name: "image",
+                kind: "image",
+                hasSource: images.some(imageRefHasSource)
+            }
+        ], context);
+        if (isString(overrides.prompt))
+            prompt = overrides.prompt;
+        if (overrides.image && images.length === 0) {
+            images = [overrides.image];
+        }
+        let image = new Uint8Array();
+        for (const candidate of images) {
+            const bytes = await imageBytesAsync(candidate, context);
+            if (bytes.length > 0) {
+                image = bytes;
+                break;
+            }
+        }
+        if (image.length === 0) {
+            throw new Error("A non-empty input image is required for Image To Video.");
+        }
+        const { providerId, modelId } = modelConfig(this.serialize());
+        if (!canUseProvider(context, providerId, modelId)) {
+            throw new Error("No provider available for image-to-video generation.");
+        }
+        const output = coerceProviderBytes(await context.runProviderPrediction({
+            provider: providerId,
+            capability: "image_to_video",
+            model: modelId,
+            params: {
+                image,
+                prompt,
+                negative_prompt: this.negative_prompt,
+                entities: await resolveEntities(this.entities, context),
+                duration_seconds: Number(this.duration ?? 0) || undefined,
+                aspect_ratio: this.aspect_ratio,
+                resolution: this.resolution,
+                timeout_seconds: Number(this.timeout_seconds ?? 0) || undefined
+            }
+        }), "Image To Video");
+        return { output: videoRef(output) };
+    }
+}
+__decorate([
+    prop({
+        type: "list[image]",
+        default: [],
+        title: "Images",
+        description: "Input image(s) to animate. Only the first non-empty image is used as the start frame. Use Reference To Video for reference media."
+    })
+], 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: "Text prompt to guide the video animation. Veo animates an image without one; Kling refuses an empty one. Leaving it blank ties the graph to the models that treat it as optional."
+    })
+], 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: "list[entity]",
+        default: [],
+        title: "Entities",
+        description: "Consistency entities (characters, styles, locations) whose descriptors are injected into the prompt"
+    })
+], ImageToVideoNode.prototype, "entities", 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 ReferenceToVideoNode extends BaseNode {
+    static nodeType = "nodetool.video.ReferenceToVideo";
+    static body = "content_card";
+    static title = "Reference To Video";
+    static description = "Generate video using ordered image and video references for identity, style, scene, motion, or audio conditioning.\n    video, reference-to-video, r2v, generation, ai";
+    static metadataOutputTypes = { output: "video" };
+    static inlineFields = [];
+    static inputFields = ["reference_images", "reference_videos", "prompt"];
+    static autoSaveAsset = true;
+    async process(context) {
+        const images = normalizeImageList(this.reference_images);
+        const videos = normalizeVideoList(this.reference_videos);
+        const [imageBytes, videoBytes] = await Promise.all([
+            Promise.all(images.map((image) => imageBytesAsync(image, context))),
+            Promise.all(videos.map((video) => videoBytesAsync(video, context)))
+        ]);
+        const referenceImages = imageBytes.filter((bytes) => bytes.length > 0);
+        const referenceVideos = videoBytes.filter((bytes) => bytes.length > 0);
+        if (referenceImages.length === 0 && referenceVideos.length === 0) {
+            throw new Error("Reference To Video requires at least one reference image or video.");
+        }
+        const { providerId, modelId } = modelConfig(this.serialize());
+        if (!canUseProvider(context, providerId, modelId)) {
+            throw new Error("No provider available for reference-to-video generation.");
+        }
+        const output = coerceProviderBytes(await context.runProviderPrediction({
+            provider: providerId,
+            capability: "reference_to_video",
+            model: modelId,
+            params: {
+                reference_images: referenceImages,
+                reference_videos: referenceVideos,
+                prompt: String(this.prompt ?? ""),
+                use_reference_video_audio: this.use_reference_video_audio,
+                negative_prompt: this.negative_prompt,
+                entities: await resolveEntities(this.entities, context),
+                duration_seconds: Number(this.duration ?? 0) || undefined,
+                aspect_ratio: this.aspect_ratio,
+                resolution: this.resolution,
+                timeout_seconds: Number(this.timeout_seconds ?? 0) || undefined
+            }
+        }), "Reference To Video");
+        return { output: videoRef(output) };
+    }
+}
+__decorate([
+    prop({
+        type: "list[image]",
+        default: [],
+        title: "Reference Images",
+        description: "Ordered identity, style, subject, or scene image references."
+    })
+], ReferenceToVideoNode.prototype, "reference_images", void 0);
+__decorate([
+    prop({
+        type: "list[video]",
+        default: [],
+        title: "Reference Videos",
+        description: "Ordered motion, scene, edit, or soundtrack video references."
+    })
+], ReferenceToVideoNode.prototype, "reference_videos", void 0);
+__decorate([
+    prop({
+        type: "video_model",
+        default: {
+            type: "video_model",
+            provider: "",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "The reference-to-video model to use"
+    })
+], ReferenceToVideoNode.prototype, "model", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Prompt", description: "Describe the video using image 1, image 2, video 1, and video 2 numbering in list order." })
+], ReferenceToVideoNode.prototype, "prompt", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Use Reference Video Audio", description: "Use audio tracks carried by reference videos where supported." })
+], ReferenceToVideoNode.prototype, "use_reference_video_audio", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Negative Prompt", description: "Text prompt describing what to avoid in the video" })
+], ReferenceToVideoNode.prototype, "negative_prompt", void 0);
+__decorate([
+    prop({ type: "list[entity]", default: [], title: "Entities", description: "Consistency entities whose descriptors are injected into the prompt" })
+], ReferenceToVideoNode.prototype, "entities", 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" } })
+], ReferenceToVideoNode.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" } })
+], ReferenceToVideoNode.prototype, "resolution", void 0);
+__decorate([
+    prop({ type: "int", default: 5, title: "Duration", description: "Video duration in seconds", values: VIDEO_DURATION_VALUES, json_schema_extra: { type: "media_duration" } })
+], ReferenceToVideoNode.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 })
+], ReferenceToVideoNode.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"
+    };
+    static inlineFields = [];
+    static inputFields = [];
+    async process() {
+        const p = filePath(String(this.path ?? "").trim());
+        if (!p)
+            throw new Error("No file path provided to Load Video File.");
+        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);
+/**
+ * Resolve the destination folder for a save node. An explicit folder wins;
+ * otherwise fall back to the run's workspace directory rather than the server
+ * process cwd (`.`), which is rarely where a user wants their output. A
+ * workspace with no directory (cloud storage) leaves only the cwd — the nodes
+ * that can write through the workspace do so via `writeSavedFile` instead.
+ */
+function saveFolder(rawFolder, context) {
+    return (folderPath(rawFolder) ||
+        context?.workspace?.localDir ||
+        context?.workspaceDir ||
+        ".");
+}
+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"
+    };
+    static inlineFields = ["save_to_workspace"];
+    static inputFields = ["video"];
+    async process(context) {
+        // dateName resolves to second granularity, so two saves in the same second
+        // collide — resolveSaveTarget numbers them rather than overwriting.
+        const bytes = await videoBytesAsync(this.video, context);
+        const p = await writeSavedFile({
+            folder: this.folder,
+            filename: dateName(String(this.filename || "video.mp4")),
+            saveToWorkspace: this.save_to_workspace,
+            workspace: context?.workspace,
+            workspaceDir: context?.workspaceDir,
+            bytes
+        });
+        return { output: videoRef(bytes, { uri: `file://${p}` }) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        title: "Video",
+        description: "The video to save"
+    })
+], SaveVideoFileVideoNode.prototype, "video", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: SAVE_TO_WORKSPACE_TITLE,
+        description: SAVE_TO_WORKSPACE_DESCRIPTION
+    })
+], SaveVideoFileVideoNode.prototype, "save_to_workspace", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Folder",
+        description: "Folder where the file will be saved",
+        json_schema_extra: VISIBLE_WHEN_NOT_SAVING_TO_WORKSPACE
+    })
+], 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    load, video, file, import";
+    static metadataOutputTypes = {
+        video: "video",
+        name: "str",
+        videos: "list",
+        names: "list"
+    };
+    static inlineFields = [];
+    static inputFields = [];
+    static inputMode = "buffered";
+    static outputCorrelation = {
+        video: { kind: "iteration", source: "__execution__", group: "items" },
+        name: { kind: "iteration", source: "__execution__", group: "items" },
+        videos: { kind: "single", source: "__execution__" },
+        names: { kind: "single", source: "__execution__" }
+    };
+    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 folder = folderPath(this.folder);
+        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 };
+        }
+        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"
+    };
+    static inlineFields = [];
+    static inputFields = ["video"];
+    async process(context) {
+        const folder = saveFolder(this.folder, context);
+        const filename = dateName(String(this.name || "video.mp4"));
+        await fs.mkdir(path.resolve(folder), { recursive: true });
+        // dateName resolves to second granularity, so two saves in the same second
+        // collide — de-duplicate with a -1/-2/… suffix rather than overwrite.
+        const full = await uniqueTargetPath(path.resolve(folder, filename));
+        const bytes = await videoBytesAsync(this.video, context);
+        await fs.writeFile(full, bytes);
+        return { output: videoRef(bytes, { uri: `file://${full}` }) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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 ForEachFrameNode extends VideoTransformNode {
+    static nodeType = "nodetool.video.ForEachFrame";
+    static title = "For Each Frame";
+    static description = "Extract frames from a video file with ffmpeg.\n    video, frames, extract, sequence";
+    static metadataOutputTypes = {
+        frame: "image",
+        index: "int",
+        fps: "float"
+    };
+    static inlineFields = [];
+    static inputFields = ["video"];
+    static inputMode = "buffered";
+    static outputCorrelation = {
+        frame: { kind: "iteration", source: "video", group: "items" },
+        index: { kind: "iteration", source: "video", group: "items" },
+        fps: { kind: "single", source: "video" }
+    };
+    async process(context) {
+        // Buffered fallback: surface the first frame instead of nothing.
+        for await (const item of this.genProcess(context)) {
+            return item;
+        }
+        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 {
+            let fps = 24;
+            try {
+                const { stdout } = await execFfprobe([
+                    "-v", "error",
+                    "-select_streams", "v:0",
+                    "-show_entries", "stream=r_frame_rate",
+                    "-of", "csv=p=0",
+                    inputFile.path
+                ]);
+                const parsed = parseFrameRate(stdout);
+                if (parsed > 0)
+                    fps = parsed;
+            }
+            catch (error) {
+                // Missing ffprobe is actionable; a genuine probe failure falls back to
+                // 24 fps.
+                if (error instanceof MissingBinaryError)
+                    throw error;
+            }
+            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})'`;
+            // With a bounded range, cap decoding at the number of selected frames so
+            // ffmpeg stops early instead of scanning to the end of the video.
+            const frameLimit = end >= 0 ? ["-frames:v", String(end - start + 1)] : [];
+            await execFfmpeg([
+                "-y",
+                "-i", inputFile.path,
+                "-vf", vfFilter,
+                "-vsync", "vfr",
+                ...frameLimit,
+                path.join(outputDir, "frame_%d.png")
+            ], { maxBuffer: FFMPEG_MAX_BUFFER });
+            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: defaultVideoRef(),
+        title: "Video",
+        description: "The input video to extract frames from."
+    })
+], ForEachFrameNode.prototype, "video", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Start",
+        description: "The frame to start extracting from."
+    })
+], ForEachFrameNode.prototype, "start", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: -1,
+        title: "End",
+        description: "The frame to stop extracting from."
+    })
+], ForEachFrameNode.prototype, "end", void 0);
+export class FpsNode extends VideoTransformNode {
+    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"
+    };
+    static inlineFields = [];
+    static inputFields = ["video"];
+    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 execFfprobe([
+                "-v", "error",
+                "-select_streams", "v:0",
+                "-show_entries", "stream=r_frame_rate",
+                "-of", "csv=p=0",
+                inputFile.path
+            ]);
+            return { output: parseFrameRate(stdout) };
+        }
+        catch (error) {
+            // Missing ffprobe is actionable; a genuine probe failure degrades to 0.
+            if (error instanceof MissingBinaryError)
+                throw error;
+            return { output: 0 };
+        }
+        finally {
+            await inputFile.cleanup();
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        title: "Video",
+        description: "The input video to analyze for FPS."
+    })
+], FpsNode.prototype, "video", void 0);
+export class FrameToVideoNode extends VideoTransformNode {
+    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 inputMode = "stream";
+    static outputCorrelation = {
+        output: { kind: "aggregate", source: "frame", collapse: "innermost" }
+    };
+    static metadataOutputTypes = {
+        output: "video"
+    };
+    static inlineFields = [];
+    static inputFields = ["frame", "fps"];
+    async run(inputs, outputs, _context) {
+        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;
+        }
+        try {
+            const result = await combineFramesToVideo(frames, fps);
+            await outputs.emit("output", videoRef(result));
+        }
+        catch (error) {
+            throw new Error(`Combining frames into a video failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    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 fps = Math.max(1, Number(this.fps ?? 30));
+        try {
+            const result = await combineFramesToVideo(frames, fps);
+            return { output: videoRef(result) };
+        }
+        catch (error) {
+            throw new Error(`Combining frames into a video failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+__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);
+/** Probe a file's video codec/dimensions/fps and audio presence. */
+async function probeConcatMeta(file) {
+    const { stdout } = await execFfprobe([
+        "-v",
+        "error",
+        "-show_streams",
+        "-show_format",
+        "-of",
+        "json",
+        file
+    ]);
+    const info = JSON.parse(stdout);
+    const streams = info.streams ?? [];
+    const v = streams.find((s) => s.codec_type === "video");
+    return {
+        codec: v?.codec_name ?? "",
+        width: v?.width ?? 0,
+        height: v?.height ?? 0,
+        fps: v?.r_frame_rate ? parseFrameRate(v.r_frame_rate) : 0,
+        hasAudio: streams.some((s) => s.codec_type === "audio")
+    };
+}
+/**
+ * Scale + pad to a uniform frame, normalize fps/pixel format, re-encode to
+ * libx264 + AAC (adding silent audio when the source has none) so mismatched
+ * segments can be concatenated losslessly with `-c copy`.
+ */
+async function normalizeConcatSegment(srcPath, segPath, width, height, fps, hasAudio) {
+    const filter = `scale=${width}:${height}:force_original_aspect_ratio=decrease,` +
+        `pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:color=black,` +
+        `fps=${fps},format=yuv420p`;
+    const silent = [
+        "-f",
+        "lavfi",
+        "-i",
+        "anullsrc=channel_layout=stereo:sample_rate=48000"
+    ];
+    await execFfmpeg([
+        "-y",
+        "-i",
+        srcPath,
+        ...(hasAudio ? [] : silent),
+        "-filter_complex",
+        `[0:v]${filter}[v]`,
+        "-map",
+        "[v]",
+        "-map",
+        hasAudio ? "0:a" : "1:a",
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-c:a",
+        "aac",
+        "-ar",
+        "48000",
+        "-ac",
+        "2",
+        "-shortest",
+        segPath
+    ], { maxBuffer: FFMPEG_MAX_BUFFER });
+}
+export class ConcatVideoNode extends VideoTransformNode {
+    static nodeType = "nodetool.video.Concat";
+    static body = "content_card";
+    static title = "Concatenate Video";
+    static description = "Concatenate multiple video files into a single video, including audio when available. Add inputs dynamically with the “add video input” button, or wire a list of videos into a single input.\n    video, concat, merge, combine, audio, +";
+    static metadataOutputTypes = {
+        output: "video"
+    };
+    static inlineFields = [];
+    static inputFields = [];
+    static supportsDynamicInputs = true;
+    async process(context) {
+        const inputValues = Array.from(this.dynamicProps.values()).flatMap((value) => normalizeVideoList(value));
+        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 {
+            // Stream-copying heterogeneous inputs (different codec/size/fps) with the
+            // concat demuxer produces corrupt output. Probe every input; only take
+            // the fast `-c copy` path when they all match, else normalize each to a
+            // uniform segment (first input's resolution/fps) before concatenating.
+            const metas = await Promise.all(inputs.map((input) => probeConcatMeta(input.path)));
+            const first = metas[0];
+            const uniform = metas.every((m) => m.codec === first.codec &&
+                m.width === first.width &&
+                m.height === first.height &&
+                m.fps === first.fps &&
+                m.hasAudio === first.hasAudio);
+            let concatPaths;
+            if (uniform) {
+                concatPaths = inputs.map((input) => input.path);
+            }
+            else {
+                const width = first.width > 0 ? first.width : 1920;
+                const height = first.height > 0 ? first.height : 1080;
+                const fps = first.fps > 0 ? first.fps : 30;
+                concatPaths = [];
+                for (const [i, input] of inputs.entries()) {
+                    const segPath = path.join(concatDir, `seg_${i}.mp4`);
+                    await normalizeConcatSegment(input.path, segPath, width, height, fps, metas[i].hasAudio);
+                    concatPaths.push(segPath);
+                }
+            }
+            const listEntries = concatPaths.map((p) => `file '${p}'`).join("\n");
+            await fs.writeFile(listPath, `${listEntries}\n`);
+            await execFfmpeg(["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", outputPath], { maxBuffer: FFMPEG_MAX_BUFFER });
+            const result = new Uint8Array(await fs.readFile(outputPath));
+            return { output: videoRef(result) };
+        }
+        catch (error) {
+            if (error instanceof MissingBinaryError)
+                throw error;
+            throw new Error(`Concatenating videos failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            for (const input of inputs) {
+                await input.cleanup();
+            }
+            await fs.rm(concatDir, { recursive: true, force: true });
+        }
+    }
+}
+export class TrimVideoNode extends VideoTransformNode {
+    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 metadataOutputTypes = {
+        output: "video"
+    };
+    static inputFields = ["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);
+        if (this.accurate) {
+            // Output-side seek (after -i): ffmpeg decodes every frame up to `start`
+            // and re-encodes, so the cut lands on the exact requested time instead of
+            // the nearest keyframe. Slower, but frame-accurate.
+            const seekArgs = ["-ss", String(start)];
+            if (end >= 0) {
+                seekArgs.push("-to", String(end));
+            }
+            const transformed = await ffmpegTransform(bytes, seekArgs);
+            return { output: videoRef(transformed) };
+        }
+        // Input-side seek (before -i): ffmpeg jumps to the nearest keyframe instead
+        // of decoding from the start, so trimming a long clip is near-instant.
+        const preInputArgs = ["-ss", String(start)];
+        if (end >= 0) {
+            preInputArgs.push("-to", String(end));
+        }
+        const transformed = await ffmpegTransform(bytes, ["-c", "copy"], {
+            preInputArgs
+        });
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Accurate",
+        description: "Re-encode for frame-exact cuts. Off (default) stream-copies and snaps to the nearest keyframe — fast, but the cut points may be off by up to one GOP."
+    })
+], TrimVideoNode.prototype, "accurate", 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"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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 ?? 0);
+        const radians = (angle * Math.PI) / 180;
+        const transformed = (await ffmpegTransform(bytes, [
+            "-vf",
+            `rotate=${radians}:ow=rotw(${radians}):oh=roth(${radians})`,
+            "-c:a",
+            "copy"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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);
+        // First attempt retimes audio too (fails on videos with no audio stream);
+        // the video-only fallback is the terminal attempt and throws on failure.
+        const transformed = (await ffmpegTransform(bytes, [
+            "-filter_complex",
+            `[0:v]setpts=${1 / speed}*PTS[v];[0:a]${atempoChain}[a]`,
+            "-map",
+            "[v]",
+            "-map",
+            "[a]"
+        ], { allowFallback: true })) ??
+            (await ffmpegTransform(bytes, ["-vf", `setpts=${1 / speed}*PTS`]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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) };
+        if (mainVideo.length === 0)
+            return { output: videoRef(overlayVideo) };
+        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]"
+        ], {
+            extraInputs: [{ suffix: ".mp4", bytes: overlayVideo }],
+            allowFallback: true
+        })) ??
+            // Fallback: video-only overlay (one or both inputs may lack audio).
+            // Terminal attempt — throws with stderr if it also fails.
+            (await ffmpegTransform(mainVideo, [
+                "-filter_complex",
+                `[1:v]scale=iw*${scale}:ih*${scale}[ov];[0:v][ov]overlay=${x}:${y}`
+            ], { extraInputs: [{ suffix: ".mp4", bytes: overlayVideo }] }));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        title: "Main Video",
+        description: "The main (background) video."
+    })
+], OverlayVideoNode.prototype, "main_video", void 0);
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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);
+        if (bytes.length === 0)
+            return { output: videoRef(bytes) };
+        const smoothing = Math.max(1, Number(this.smoothing ?? 10));
+        const cropBlack = Boolean(this.crop_black ?? true);
+        // ffmpeg's `deshake` filter has no `smooth` option. Passing one fails the
+        // whole filtergraph with "Error applying option 'smooth' to filter
+        // 'deshake': Option not found", so this node could never run. `smooth`
+        // belongs to vidstabtransform, which needs a libvidstab-enabled ffmpeg we
+        // cannot assume is present. Map the smoothing dial onto deshake's actual
+        // control — the rx/ry search range, which sets how much motion it can
+        // track between frames. deshake rejects a range that is not a multiple of
+        // 16 ("rx must be a multiple of 16"), so snap to the nearest legal step and
+        // keep at least one: rx=0 disables the search entirely.
+        const searchRange = Math.min(64, Math.max(16, Math.round(smoothing / 16) * 16));
+        const deshake = `deshake=rx=${searchRange}:ry=${searchRange}`;
+        if (!cropBlack) {
+            const transformed = await ffmpegTransform(bytes, [
+                "-vf",
+                deshake,
+                "-c:a",
+                "copy"
+            ]);
+            return { output: videoRef(transformed) };
+        }
+        // Pass 1: run deshake + cropdetect to the null muxer and read cropdetect's
+        // suggested crop from stderr (a bare `crop` filter defaults to the full
+        // frame and removes nothing — cropdetect only logs, it never crops).
+        const probe = await withTempFile(".mp4", bytes);
+        let crop = null;
+        try {
+            const { stderr } = await execFfmpeg([
+                "-y",
+                "-i",
+                probe.path,
+                "-vf",
+                `${deshake},cropdetect=24:16:0`,
+                "-f",
+                "null",
+                "-"
+            ], { maxBuffer: FFMPEG_MAX_BUFFER });
+            crop = parseCropDetectCrop(stderr);
+        }
+        finally {
+            await probe.cleanup();
+        }
+        // Pass 2: apply the detected crop, or deshake alone when none was found.
+        const vf = crop ? `${deshake},crop=${crop}` : deshake;
+        const transformed = await ffmpegTransform(bytes, [
+            "-vf",
+            vf,
+            "-c:a",
+            "copy"
+        ]);
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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 = Number(this.strength ?? 5);
+        if (radius <= 0)
+            return { output: videoRef(bytes) };
+        const transformed = (await ffmpegTransform(bytes, [
+            "-vf",
+            `boxblur=${radius}:${radius}`,
+            "-c:a",
+            "copy"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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);
+        const transformed = (await ffmpegTransform(bytes, [
+            "-vf",
+            `eq=saturation=${saturation}`,
+            "-c:a",
+            "copy"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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");
+        // `||` (not `??`): the default font ref has name "", which must also
+        // fall back rather than producing drawtext's font=''. Strip filtergraph-
+        // significant characters \u2014 a font family name never contains them, and
+        // leaving them in would let a crafted name break the -vf argument.
+        const fontName = String(this.font?.name || "Sans").replace(/['\\:,;[\]%]/g, "");
+        const align = String(this.align ?? "bottom");
+        let yExpr;
+        if (align === "top") {
+            yExpr = "text_h";
+        }
+        else if (align === "center") {
+            yExpr = "(h-text_h)/2";
+        }
+        else {
+            // bottom
+            yExpr = "h-(text_h*2)";
+        }
+        // Write each chunk's text to a temp file and reference it with drawtext's
+        // `textfile=` option. Inline `text='...'` breaks on ordinary punctuation:
+        // a comma or semicolon ends the filter, `[`/`]` are stream-label syntax,
+        // and the two-level filtergraph escaping is easy to get subtly wrong. A
+        // file sidesteps all of it \u2014 arbitrary subtitle text stays literal.
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "nodetool-subs-"));
+        try {
+            const drawFilters = [];
+            let idx = 0;
+            for (const chunk of chunks) {
+                const text = String(chunk.text ?? chunk.content ?? "").trim();
+                if (!text)
+                    continue;
+                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 textPath = path.join(dir, `sub_${idx}.txt`);
+                await fs.writeFile(textPath, text, "utf8");
+                idx += 1;
+                drawFilters.push(`drawtext=textfile='${textPath}':expansion=none` +
+                    `:x=(w-text_w)/2:y=${yExpr}` +
+                    `:fontcolor=${fontColor}:fontsize=${fontSize}` +
+                    `:font='${fontName}'` +
+                    `:enable='between(t,${start},${end})'`);
+            }
+            if (drawFilters.length === 0)
+                return { output: videoRef(bytes) };
+            const vf = drawFilters.join(",");
+            const transformed = await ffmpegTransform(bytes, [
+                "-vf",
+                vf,
+                "-c:a",
+                "copy"
+            ]);
+            return { output: videoRef(transformed) };
+        }
+        finally {
+            await fs.rm(dir, { recursive: true, force: true });
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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 VideoTransformNode {
+    static nodeType = "nodetool.video.Reverse";
+    static title = "Reverse";
+    static description = "Reverse the playback of a video.\n    video, reverse, backwards, effect";
+    static metadataOutputTypes = {
+        output: "video"
+    };
+    static inputFields = ["video"];
+    async process(context) {
+        const bytes = await videoBytesAsync(this.video, context);
+        if (bytes.length === 0)
+            return { output: videoRef(bytes) };
+        // Reverse audio+video first (fails without an audio stream); the video-only
+        // fallback is terminal and throws on failure.
+        const transformed = (await ffmpegTransform(bytes, ["-vf", "reverse", "-af", "areverse"], {
+            allowFallback: true
+        })) ?? (await ffmpegTransform(bytes, ["-vf", "reverse"]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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) };
+        if (a.length === 0)
+            return { output: videoRef(b) };
+        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]"
+        ], { extraInputs: [{ suffix: ".mp4", bytes: b }], allowFallback: true })) ??
+            // Fallback: video-only xfade (inputs may lack audio). Terminal attempt —
+            // throws with stderr if it also fails.
+            (await ffmpegTransform(a, [
+                "-filter_complex",
+                `[0:v][1:v]xfade=transition=${transitionType}:duration=${duration}:offset=${offsetVal}`
+            ], { extraInputs: [{ suffix: ".mp4", bytes: b }] }));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        title: "Video A",
+        description: "The first video in the transition."
+    })
+], TransitionVideoNode.prototype, "video_a", void 0);
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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 VideoTransformNode {
+    static nodeType = "nodetool.video.AddAudio";
+    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"
+    };
+    static inputFields = ["video", "audio"];
+    async process(context) {
+        const v = await videoBytesAsync(this.video, context);
+        const a = await audioBytesAsync(this.audio, context);
+        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);
+            // Left to the muxer the file is as long as the *longer* stream, so a
+            // music model that ignores the requested duration turns a 25-second clip
+            // into a four-minute one. `apad` makes the audio endless and `-shortest`
+            // then ends the file with the picture, which also stops a short audio
+            // track from cutting the picture off.
+            const trimToVideo = String(this.output_length ?? "video") !== "longest";
+            const pad = trimToVideo ? ",apad" : "";
+            const buildArgs = (useMix) => {
+                const args = [
+                    "-y",
+                    "-i", videoInput.path,
+                    "-i", audioInput.path
+                ];
+                if (useMix) {
+                    args.push("-filter_complex", `[1:a]volume=${volume}[newaud];[0:a][newaud]amix=inputs=2:duration=longest${pad}[aout]`, "-map", "0:v:0", "-map", "[aout]", "-c:v", "copy");
+                }
+                else if (volume !== 1 || trimToVideo) {
+                    args.push("-filter_complex", `[1:a]volume=${volume}${pad}[aout]`, "-map", "0:v:0", "-map", "[aout]", "-c:v", "copy", "-c:a", "aac");
+                }
+                else {
+                    args.push("-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy", "-c:a", "aac");
+                }
+                if (trimToVideo)
+                    args.push("-shortest");
+                args.push(outputPath);
+                return args;
+            };
+            try {
+                await execFfmpeg(buildArgs(mix), { maxBuffer: FFMPEG_MAX_BUFFER });
+            }
+            catch (error) {
+                if (error instanceof MissingBinaryError)
+                    throw error;
+                // Mixing requires an existing audio stream ([0:a]); videos without one
+                // make ffmpeg fail. Fall back to plain replacement — the terminal
+                // attempt, which throws (with stderr) if it also fails.
+                if (!mix)
+                    throw error;
+                await execFfmpeg(buildArgs(false), { maxBuffer: FFMPEG_MAX_BUFFER });
+            }
+            const result = new Uint8Array(await fs.readFile(outputPath));
+            return { output: videoRef(result) };
+        }
+        finally {
+            await videoInput.cleanup();
+            await audioInput.cleanup();
+            await fs.rm(outputDir, { recursive: true, force: true });
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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);
+__decorate([
+    prop({
+        type: "enum",
+        default: "video",
+        title: "Output Length",
+        description: "How long the output is. 'video' matches the picture: a longer audio track is trimmed, a shorter one padded with silence. 'longest' keeps both streams whole, so a track that outruns the picture leaves the output playing over nothing.",
+        values: ["video", "longest"]
+    })
+], AddAudioVideoNode.prototype, "output_length", 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. The MP4 output has no alpha channel, so the keyed-out area renders black — composite it over a background with the Overlay node.\n    video, chroma key, green screen, compositing";
+    static metadataOutputTypes = {
+        output: "video"
+    };
+    async process(context) {
+        const bytes = await videoBytesAsync(this.video, context);
+        const keyColorObj = this.key_color;
+        const color = String(keyColorObj?.value ?? "#00FF00").replace("#", "0x");
+        const similarity = Number(this.similarity ?? 0.3);
+        const blend = Number(this.blend ?? 0.1);
+        const transformed = (await ffmpegTransform(bytes, [
+            "-vf",
+            `colorkey=${color}:${similarity}:${blend}`,
+            "-c:a",
+            "copy"
+        ]));
+        return { output: videoRef(transformed) };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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 VideoTransformNode {
+    static nodeType = "nodetool.video.ExtractAudio";
+    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"
+    };
+    static inputFields = ["video"];
+    async process(context) {
+        const bytes = await videoBytesAsync(this.video, context);
+        if (bytes.length === 0) {
+            return {
+                output: {
+                    type: "audio",
+                    data: null,
+                    uri: "",
+                    asset_id: null,
+                    metadata: 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 execFfmpeg(["-y", "-i", input.path, "-vn", "-acodec", "pcm_s16le", outputPath], { maxBuffer: FFMPEG_MAX_BUFFER });
+            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: defaultVideoRef(),
+        title: "Video",
+        description: "The input video to separate."
+    })
+], ExtractAudioVideoNode.prototype, "video", void 0);
+export class ExtractFrameVideoNode extends VideoTransformNode {
+    static nodeType = "nodetool.video.ExtractFrame";
+    static title = "Extract Video 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"
+    };
+    static inputFields = ["video"];
+    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 execFfmpeg([
+                "-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 (error) {
+            // A missing binary is unrecoverable — surface it. A genuine decode
+            // failure (e.g. seeking past the end) yields an empty frame.
+            if (error instanceof MissingBinaryError)
+                throw error;
+            return { output: { type: "image", data: null } };
+        }
+        finally {
+            await inputFile.cleanup();
+            await fs.rm(outputDir, { recursive: true, force: true });
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        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 VideoTransformNode {
+    static nodeType = "nodetool.video.GetVideoInfo";
+    static title = "Get Video Info";
+    static description = "Get metadata about a video file including 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"
+    };
+    static inputFields = ["video"];
+    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 execFfprobe([
+                "-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");
+            const fps = videoStream?.r_frame_rate
+                ? parseFrameRate(videoStream.r_frame_rate)
+                : 0;
+            const duration = Number(info.format?.duration ?? 0) || 0;
+            const frameCount = videoStream?.nb_frames
+                ? Number(videoStream.nb_frames) || 0
+                : 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 (error) {
+            // Missing ffprobe is actionable; a genuine probe failure on corrupt
+            // input degrades to the empty info result.
+            if (error instanceof MissingBinaryError)
+                throw error;
+            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: defaultVideoRef(),
+        title: "Video",
+        description: "The input video to analyze."
+    })
+], GetVideoInfoNode.prototype, "video", void 0);
+export class VideoToVideoNode extends BaseNode {
+    static nodeType = "nodetool.video.VideoToVideo";
+    static body = "content_card";
+    static title = "Video To Video";
+    static description = "Restyle or edit an existing video with a text prompt using any supported video provider.\n    video, video-to-video, v2v, restyle, style-transfer, AI";
+    static metadataOutputTypes = { output: "video" };
+    static inlineFields = [];
+    static inputFields = ["video", "prompt"];
+    static autoSaveAsset = true;
+    async process(context) {
+        const bytes = await videoBytesAsync(this.video, context);
+        if (bytes.length === 0)
+            throw new Error("The input video is empty.");
+        const { providerId, modelId } = modelConfig(this.serialize());
+        if (!canUseProvider(context, providerId, modelId)) {
+            throw new Error("No provider available for video-to-video generation.");
+        }
+        const output = coerceProviderBytes(await context.runProviderPrediction({
+            provider: providerId,
+            capability: "video_to_video",
+            model: modelId,
+            params: {
+                video: bytes,
+                prompt: String(this.prompt ?? ""),
+                negative_prompt: this.negative_prompt,
+                strength: Number(this.strength ?? 0.6)
+            }
+        }), "Video To Video");
+        return { output: videoRef(output) };
+    }
+}
+__decorate([
+    prop({
+        type: "video_model",
+        default: {
+            type: "video_model",
+            provider: "fal_ai",
+            id: "fal-ai/ltx-2-19b/distilled/video-to-video",
+            name: "LTX Video To Video",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "The video-to-video model to use"
+    })
+], VideoToVideoNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        title: "Video",
+        description: "The input video to transform"
+    })
+], VideoToVideoNode.prototype, "video", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "Text prompt describing the desired transformation"
+    })
+], VideoToVideoNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Negative Prompt",
+        description: "Text prompt describing what to avoid"
+    })
+], VideoToVideoNode.prototype, "negative_prompt", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0.6,
+        title: "Strength",
+        description: "How much to transform the input video",
+        min: 0,
+        max: 1
+    })
+], VideoToVideoNode.prototype, "strength", void 0);
+export class LipSyncNode extends BaseNode {
+    static nodeType = "nodetool.video.LipSync";
+    static body = "content_card";
+    static title = "Lip Sync";
+    static description = "Drive a face in a video to match speech in an audio track using any supported lip-sync provider.\n    video, lip-sync, lipsync, talking-head, dubbing, AI";
+    static metadataOutputTypes = { output: "video" };
+    static inlineFields = [];
+    static inputFields = ["video", "audio"];
+    static autoSaveAsset = true;
+    async process(context) {
+        const video = await videoBytesAsync(this.video, context);
+        if (video.length === 0)
+            throw new Error("The input video is empty.");
+        const audio = await audioBytesAsync(this.audio, context);
+        if (audio.length === 0)
+            throw new Error("The input audio is empty.");
+        const { providerId, modelId } = modelConfig(this.serialize());
+        if (!canUseProvider(context, providerId, modelId)) {
+            throw new Error("No provider available for lip sync.");
+        }
+        const output = coerceProviderBytes(await context.runProviderPrediction({
+            provider: providerId,
+            capability: "lip_sync",
+            model: modelId,
+            params: { video, audio }
+        }), "Lip Sync");
+        return { output: videoRef(output) };
+    }
+}
+__decorate([
+    prop({
+        type: "video_model",
+        default: {
+            type: "video_model",
+            provider: "fal_ai",
+            id: "fal-ai/sync-lipsync/v2",
+            name: "Sync Lipsync V2",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "The lip-sync model to use"
+    })
+], LipSyncNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "video",
+        default: defaultVideoRef(),
+        title: "Video",
+        description: "The input video containing the face to drive"
+    })
+], LipSyncNode.prototype, "video", void 0);
+__decorate([
+    prop({
+        type: "audio",
+        default: { type: "audio", uri: "", asset_id: null, data: null, metadata: null },
+        title: "Audio",
+        description: "The audio track the mouth motion should follow"
+    })
+], LipSyncNode.prototype, "audio", void 0);
+export const VIDEO_NODES = [
+    TextToVideoNode,
+    ImageToVideoNode,
+    ReferenceToVideoNode,
+    LoadVideoFileNode,
+    SaveVideoFileVideoNode,
+    LoadVideoAssetsNode,
+    SaveVideoNode,
+    ForEachFrameNode,
+    FpsNode,
+    FrameToVideoNode,
+    ConcatVideoNode,
+    TrimVideoNode,
+    ResizeVideoNode,
+    RotateVideoNode,
+    SetSpeedVideoNode,
+    OverlayVideoNode,
+    ColorBalanceVideoNode,
+    DenoiseVideoNode,
+    StabilizeVideoNode,
+    SharpnessVideoNode,
+    BlurVideoNode,
+    SaturationVideoNode,
+    AddSubtitlesVideoNode,
+    ReverseVideoNode,
+    TransitionVideoNode,
+    AddAudioVideoNode,
+    ChromaKeyVideoNode,
+    ExtractAudioVideoNode,
+    ExtractFrameVideoNode,
+    GetVideoInfoNode,
+    VideoToVideoNode,
+    LipSyncNode
+];
+//# sourceMappingURL=video.js.map