@lee-jisoo/n8n-nodes-mediafx 1.6.0 → 1.6.1

package/dist/nodes/MediaFX/operations/addSubtitle.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAddSubtitle = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+/**
+ * Escape special characters in file path for FFmpeg subtitles filter.
+ * FFmpeg subtitles filter requires escaping: \ : [ ] '
+ */
+function escapeSubtitlePath(filePath) {
+    return filePath
+        .replace(/\\/g, '\\\\\\\\') // Backslash (Windows paths)
+        .replace(/:/g, '\\:') // Colon
+        .replace(/\[/g, '\\[') // Square brackets
+        .replace(/\]/g, '\\]')
+        .replace(/'/g, "\\'"); // Single quote
+}
+/**
+ * Build ASS/SSA style string for subtitles filter force_style option.
+ * This converts our style options to FFmpeg's force_style format.
+ */
+function buildForceStyle(fontName, fontSize, fontColor, horizontalAlign, verticalAlign, marginV) {
+    // Convert color from CSS format to ASS format (AABBGGRR)
+    // Default white = &H00FFFFFF
+    let assColor = '&H00FFFFFF';
+    if (fontColor && fontColor.startsWith('#') && fontColor.length === 7) {
+        // Convert #RRGGBB to &H00BBGGRR (ASS uses BGR order with alpha prefix)
+        const r = fontColor.substring(1, 3);
+        const g = fontColor.substring(3, 5);
+        const b = fontColor.substring(5, 7);
+        assColor = `&H00${b}${g}${r}`.toUpperCase();
+    }
+    else if (fontColor === 'white') {
+        assColor = '&H00FFFFFF';
+    }
+    else if (fontColor === 'black') {
+        assColor = '&H00000000';
+    }
+    else if (fontColor === 'yellow') {
+        assColor = '&H0000FFFF';
+    }
+    else if (fontColor === 'red') {
+        assColor = '&H000000FF';
+    }
+    // Alignment mapping for ASS (numpad style)
+    // 1=bottom-left, 2=bottom-center, 3=bottom-right
+    // 4=middle-left, 5=middle-center, 6=middle-right
+    // 7=top-left, 8=top-center, 9=top-right
+    let alignment = 2; // default: bottom-center
+    if (verticalAlign === 'top') {
+        alignment = horizontalAlign === 'left' ? 7 : horizontalAlign === 'right' ? 9 : 8;
+    }
+    else if (verticalAlign === 'middle') {
+        alignment = horizontalAlign === 'left' ? 4 : horizontalAlign === 'right' ? 6 : 5;
+    }
+    else {
+        // bottom (default)
+        alignment = horizontalAlign === 'left' ? 1 : horizontalAlign === 'right' ? 3 : 2;
+    }
+    const styleParams = [
+        `FontName=${fontName}`,
+        `FontSize=${fontSize}`,
+        `PrimaryColour=${assColor}`,
+        `OutlineColour=&H00000000`,
+        `BackColour=&H80000000`,
+        `Bold=0`,
+        `Italic=0`,
+        `BorderStyle=4`,
+        `Outline=1`,
+        `Shadow=0`,
+        `Alignment=${alignment}`,
+        `MarginV=${marginV}`,
+    ];
+    return styleParams.join(',');
+}
+async function executeAddSubtitle(video, subtitleFile, style, itemIndex) {
+    var _a, _b;
+    const outputPath = (0, utils_1.getTempFile)(path.extname(video));
+    // 1. Get Font from fontKey
+    const allFonts = (0, utils_1.getAvailableFonts)();
+    const fontKey = style.fontKey || 'noto-sans-kr';
+    const font = allFonts[fontKey];
+    if (!font || !font.path) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+    }
+    const fontName = font.name || 'Sans';
+    const fontSize = style.size || 48;
+    const fontColor = style.color || 'white';
+    // 2. Handle position based on position type
+    const positionType = style.positionType || 'alignment';
+    let horizontalAlign = 'center';
+    let verticalAlign = 'bottom';
+    let marginV = 20;
+    if (positionType === 'alignment') {
+        horizontalAlign = style.horizontalAlign || 'center';
+        verticalAlign = style.verticalAlign || 'bottom';
+        marginV = (_b = (_a = style.paddingY) !== null && _a !== void 0 ? _a : style.padding) !== null && _b !== void 0 ? _b : 20;
+    }
+    // 3. Build force_style for subtitles filter
+    const forceStyle = buildForceStyle(fontName, fontSize, fontColor, horizontalAlign, verticalAlign, marginV);
+    // 4. Escape subtitle file path for FFmpeg
+    const escapedSubtitlePath = escapeSubtitlePath(subtitleFile);
+    // 5. Build subtitles filter (much more reliable than drawtext chain)
+    // Using subtitles filter processes the entire SRT file at once
+    const subtitlesFilter = `subtitles='${escapedSubtitlePath}':force_style='${forceStyle}'`;
+    const command = ffmpeg(video)
+        .videoFilters([subtitlesFilter])
+        .audioCodec('copy')
+        .save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error adding subtitles to video. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeAddSubtitle = executeAddSubtitle;

package/dist/nodes/MediaFX/operations/addText.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, IDataObject } from 'n8n-workflow';
+export declare function executeAddText(this: IExecuteFunctions, video: string, text: string, options: IDataObject, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/addText.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAddText = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+function getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY) {
+    let x;
+    let y;
+    // Set X position based on horizontal alignment
+    switch (horizontalAlign) {
+        case 'left':
+            x = `${paddingX}`;
+            break;
+        case 'right':
+            x = `w-text_w-${paddingX}`;
+            break;
+        case 'center':
+        default:
+            x = '(w-text_w)/2';
+            break;
+    }
+    // Set Y position based on vertical alignment
+    switch (verticalAlign) {
+        case 'top':
+            y = `${paddingY}`;
+            break;
+        case 'bottom':
+            y = `h-th-${paddingY}`;
+            break;
+        case 'middle':
+        default:
+            y = '(h-text_h)/2';
+            break;
+    }
+    return { x, y };
+}
+async function executeAddText(video, text, options, itemIndex) {
+    var _a, _b, _c, _d;
+    const allFonts = (0, utils_1.getAvailableFonts)();
+    const fontKey = options.fontKey || 'noto-sans-kr';
+    const font = allFonts[fontKey];
+    if (!font || !font.path) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+    }
+    const fontPath = font.path;
+    // Set default values for text options
+    const fontSize = options.size || 48;
+    const fontColor = options.color || 'white';
+    const startTime = options.startTime || 0;
+    const endTime = options.endTime || 5;
+    // Handle position based on position type
+    let positionX;
+    let positionY;
+    const positionType = options.positionType || 'alignment';
+    if (positionType === 'alignment') {
+        const horizontalAlign = options.horizontalAlign || 'center';
+        const verticalAlign = options.verticalAlign || 'bottom';
+        const paddingX = (_b = (_a = options.paddingX) !== null && _a !== void 0 ? _a : options.padding) !== null && _b !== void 0 ? _b : 20;
+        const paddingY = (_d = (_c = options.paddingY) !== null && _c !== void 0 ? _c : options.padding) !== null && _d !== void 0 ? _d : 20;
+        const position = getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY);
+        positionX = position.x;
+        positionY = position.y;
+    }
+    else {
+        // Custom position
+        positionX = options.x || '(w-text_w)/2';
+        positionY = options.y || 'h-th-10';
+    }
+    const outputPath = (0, utils_1.getTempFile)(path.extname(video));
+    const drawtext = `drawtext=fontfile=${fontPath}:text='${text.replace(/'/g, `''`)}':fontsize=${fontSize}:fontcolor=${fontColor}:x=${positionX}:y=${positionY}:enable='between(t,${startTime},${endTime})'`;
+    const command = ffmpeg(video).videoFilters(drawtext).audioCodec('copy').save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error adding text to video. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeAddText = executeAddText;

package/dist/nodes/MediaFX/operations/extractAudio.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeExtractAudio(this: IExecuteFunctions, input: string, format: string, codec: string, bitrate: string, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/extractAudio.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeExtractAudio = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+async function executeExtractAudio(input, format, codec, bitrate, itemIndex) {
+    const outputPath = (0, utils_1.getTempFile)(`.${format}`);
+    let finalCodec = codec;
+    // If stream copy ('copy') is selected for a format that requires a specific
+    // codec (like mp3), we must override it to prevent an FFmpeg error.
+    if (finalCodec === 'copy' && format === 'mp3') {
+        // Cannot stream copy a non-mp3 stream (e.g., aac) into an mp3 container.
+        // Default to a high-quality mp3 encoder.
+        finalCodec = 'libmp3lame';
+    }
+    const command = ffmpeg(input)
+        .output(outputPath)
+        .noVideo()
+        .audioCodec(finalCodec)
+        .audioBitrate(bitrate)
+        .outputOptions('-map', '0:a:0'); // Select first audio stream
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error extracting audio. Please ensure the source video contains an audio track. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeExtractAudio = executeExtractAudio;

package/dist/nodes/MediaFX/operations/imageToVideo.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeImageToVideo(this: IExecuteFunctions, imagePath: string, duration: number, videoSize: {
+    width?: number;
+    height?: number;
+}, outputFormat: string, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/imageToVideo.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeImageToVideo = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../utils");
+const ffmpeg = require("fluent-ffmpeg");
+const fs = __importStar(require("fs-extra"));
+async function executeImageToVideo(imagePath, duration, videoSize, outputFormat, itemIndex) {
+    const outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+    const command = ffmpeg()
+        .input(imagePath)
+        .loop(duration)
+        // Add a silent audio track for compatibility
+        .input('anullsrc')
+        .inputFormat('lavfi')
+        // Use libx264 codec for broad compatibility
+        .videoCodec('libx264')
+        // Set pixel format
+        .outputOptions('-pix_fmt', 'yuv420p')
+        .audioCodec('aac')
+        .outputOptions('-shortest'); // End when the shortest input ends.
+    if (videoSize.width && videoSize.height) {
+        // Many codecs require even dimensions, but we'll let the user decide.
+        // For more robustness, we could add validation or rounding logic here.
+        command.videoFilters(`scale=${videoSize.width}:${videoSize.height}`);
+    }
+    else {
+        // Default behavior: ensure even dimensions for compatibility
+        command.videoFilters('scale=trunc(iw/2)*2:trunc(ih/2)*2');
+    }
+    command.save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error converting image to video. Please ensure the source image is valid. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeImageToVideo = executeImageToVideo;

package/dist/nodes/MediaFX/operations/index.d.ts

@@ -0,0 +1,13 @@
+export * from './merge';
+export * from './trim';
+export * from './speed';
+export * from './mixAudio';
+export * from './addSubtitle';
+export * from './addText';
+export * from './extractAudio';
+export * from './separateAudio';
+export * from './multiVideoTransition';
+export * from './singleVideoFade';
+export * from './imageToVideo';
+export * from './stampImage';
+export * from './overlayVideo';

package/dist/nodes/MediaFX/operations/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./merge"), exports);
+__exportStar(require("./trim"), exports);
+__exportStar(require("./speed"), exports);
+__exportStar(require("./mixAudio"), exports);
+__exportStar(require("./addSubtitle"), exports);
+__exportStar(require("./addText"), exports);
+__exportStar(require("./extractAudio"), exports);
+__exportStar(require("./separateAudio"), exports);
+__exportStar(require("./multiVideoTransition"), exports);
+__exportStar(require("./singleVideoFade"), exports);
+__exportStar(require("./imageToVideo"), exports);
+__exportStar(require("./stampImage"), exports);
+__exportStar(require("./overlayVideo"), exports);

package/dist/nodes/MediaFX/operations/merge.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeMerge(this: IExecuteFunctions, inputs: string[], outputFormat: string, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/merge.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeMerge = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const fs = __importStar(require("fs-extra"));
+const utils_1 = require("../utils");
+async function normalizeVideo(inputPath, refInfo) {
+    const normalizedPath = (0, utils_1.getTempFile)('.ts');
+    const mainCleanup = () => fs.remove(normalizedPath);
+    let silentAudioCleanup = null;
+    const hasAudio = await (0, utils_1.fileHasAudio)(inputPath);
+    const command = ffmpeg(inputPath);
+    if (!hasAudio) {
+        const duration = await (0, utils_1.getDuration)(inputPath);
+        const { filePath: silentAudioPath, cleanup } = await (0, utils_1.createSilentAudio)(duration);
+        command.addInput(silentAudioPath);
+        silentAudioCleanup = cleanup;
+    }
+    const targetWidth = refInfo.width;
+    const targetHeight = refInfo.height;
+    const targetSar = (refInfo.sample_aspect_ratio && refInfo.sample_aspect_ratio !== 'N/A') ? refInfo.sample_aspect_ratio : '1:1';
+    const targetFrameRate = refInfo.r_frame_rate || '30';
+    const targetPixFmt = 'yuv420p';
+    const videoFilter = `[0:v]scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease,pad=${targetWidth}:${targetHeight}:-1:-1:color=black,setsar=${targetSar},format=${targetPixFmt},fps=${targetFrameRate},setpts=PTS-STARTPTS[v_out]`;
+    const audioFilter = hasAudio
+        ? `[0:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,asetpts=PTS-STARTPTS[a_out]`
+        : `[1:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,asetpts=PTS-STARTPTS[a_out]`;
+    command
+        .complexFilter([videoFilter, audioFilter])
+        .outputOptions(['-map', '[v_out]', '-map', '[a_out]'])
+        .videoCodec('libx264')
+        .audioCodec('aac')
+        .save(normalizedPath);
+    await (0, utils_1.runFfmpeg)(command);
+    const combinedCleanup = async () => {
+        await mainCleanup();
+        if (silentAudioCleanup) {
+            await silentAudioCleanup();
+        }
+    };
+    return { normalizedPath, cleanup: combinedCleanup };
+}
+async function executeMerge(inputs, outputFormat, itemIndex) {
+    // Verify FFmpeg is available before proceeding
+    try {
+        (0, utils_1.verifyFfmpegAvailability)();
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `FFmpeg is not available: ${error.message}`, { itemIndex });
+    }
+    if (inputs.length < 1) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Merge operation requires at least one source.', {
+            itemIndex,
+        });
+    }
+    const intermediateFiles = [];
+    let outputPath = null;
+    const finalCleanup = async () => {
+        for (const file of intermediateFiles) {
+            await file.cleanup();
+        }
+    };
+    try {
+        const videoInfos = await Promise.all(inputs.map(utils_1.getVideoStreamInfo));
+        const refInfo = videoInfos.find((info) => info !== undefined);
+        if (!refInfo || !refInfo.width || !refInfo.height) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Could not determine reference video properties for merging. At least one input must be a valid video.', { itemIndex });
+        }
+        // 1. Normalization Stage
+        for (const inputPath of inputs) {
+            const { normalizedPath, cleanup } = await normalizeVideo.call(this, inputPath, refInfo);
+            intermediateFiles.push({ path: normalizedPath, cleanup });
+        }
+        // 2. Merging Stage - Using the concat protocol for stability
+        outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+        const normalizedPaths = intermediateFiles.map((f) => f.path);
+        const concatString = `concat:${normalizedPaths.join('|')}`;
+        const command = ffmpeg()
+            .input(concatString)
+            .outputOptions('-c', 'copy')
+            .save(outputPath);
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        if (outputPath) {
+            await fs.remove(outputPath).catch(() => { });
+        }
+        await finalCleanup();
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error merging videos. Please ensure all source videos are valid. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+    finally {
+        await finalCleanup();
+    }
+}
+exports.executeMerge = executeMerge;

package/dist/nodes/MediaFX/operations/mixAudio.d.ts

@@ -0,0 +1,2 @@
+import { IDataObject, IExecuteFunctions } from 'n8n-workflow';
+export declare function executeMixAudio(this: IExecuteFunctions, videoPath: string, audioPath: string, videoVolume: number, audioVolume: number, matchLength: 'shortest' | 'longest' | 'first', advancedMixing: IDataObject, itemIndex: number): Promise<string>;