@remotion/renderer 4.0.357 → 4.0.360

package/package/dist/client.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserSafeApis = void 0;
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
+const codec_1 = require("./codec");
+const codec_supports_media_1 = require("./codec-supports-media");
+const crf_1 = require("./crf");
+const file_extensions_1 = require("./file-extensions");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const image_format_1 = require("./image-format");
+const jpeg_quality_1 = require("./jpeg-quality");
+const log_level_1 = require("./log-level");
+const options_1 = require("./options");
+const audio_codec_1 = require("./options/audio-codec");
+const chrome_mode_1 = require("./options/chrome-mode");
+const color_space_1 = require("./options/color-space");
+const gl_1 = require("./options/gl");
+const hardware_acceleration_1 = require("./options/hardware-acceleration");
+const options_map_1 = require("./options/options-map");
+const video_codec_1 = require("./options/video-codec");
+const x264_preset_1 = require("./options/x264-preset");
+const pixel_format_1 = require("./pixel-format");
+const prores_profile_1 = require("./prores-profile");
+const validate_output_filename_1 = require("./validate-output-filename");
+exports.BrowserSafeApis = {
+    getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
+    validCodecs: codec_1.validCodecs,
+    validAudioCodecs: audio_codec_1.validAudioCodecs,
+    getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
+    getValidCrfRanges: crf_1.getValidCrfRanges,
+    proResProfileOptions: prores_profile_1.proResProfileOptions,
+    x264PresetOptions: x264_preset_1.x264PresetOptions,
+    hardwareAccelerationOptions: hardware_acceleration_1.hardwareAccelerationOptions,
+    validPixelFormats: pixel_format_1.validPixelFormats,
+    validOpenGlRenderers: gl_1.validOpenGlRenderers,
+    validPixelFormatsForCodec: pixel_format_1.validPixelFormatsForCodec,
+    validVideoImageFormats: image_format_1.validVideoImageFormats,
+    validStillImageFormats: image_format_1.validStillImageFormats,
+    DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
+    DEFAULT_TIMEOUT: TimeoutSettings_1.DEFAULT_TIMEOUT,
+    DEFAULT_JPEG_QUALITY: jpeg_quality_1.DEFAULT_JPEG_QUALITY,
+    DEFAULT_COLOR_SPACE: color_space_1.DEFAULT_COLOR_SPACE,
+    supportedAudioCodecs: audio_codec_1.supportedAudioCodecs,
+    defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
+    defaultAudioCodecs: audio_codec_1.defaultAudioCodecs,
+    defaultCodecsForFileExtension: get_extension_from_codec_1.defaultCodecsForFileExtension,
+    validateOutputFilename: validate_output_filename_1.validateOutputFilename,
+    options: options_1.allOptions,
+    validColorSpaces: color_space_1.validColorSpaces,
+    optionsMap: options_map_1.optionsMap,
+    codecSupportsCrf: codec_supports_media_1.codecSupportsCrf,
+    codecSupportsVideoBitrate: codec_supports_media_1.codecSupportsVideoBitrate,
+    logLevels: log_level_1.logLevels,
+    getOutputCodecOrUndefined: video_codec_1.getOutputCodecOrUndefined,
+    getExtensionFromAudioCodec: audio_codec_1.getExtensionFromAudioCodec,
+    validChromeModeOptions: chrome_mode_1.validChromeModeOptions,
+};

package/package/dist/codec-supports-media.d.ts

@@ -0,0 +1,9 @@
+import type { Codec } from './codec';
+type MediaSupport = {
+    video: boolean;
+    audio: boolean;
+};
+export declare const codecSupportsMedia: (codec: Codec) => MediaSupport;
+export declare const codecSupportsCrf: (codec: Codec) => boolean;
+export declare const codecSupportsVideoBitrate: (codec: Codec) => boolean;
+export {};

package/package/dist/codec-supports-media.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codecSupportsVideoBitrate = exports.codecSupportsCrf = exports.codecSupportsMedia = void 0;
+const crf_1 = require("./crf");
+const support = {
+    'h264-mkv': {
+        audio: true,
+        video: true,
+    },
+    aac: {
+        audio: true,
+        video: false,
+    },
+    gif: {
+        video: true,
+        audio: false,
+    },
+    h264: {
+        video: true,
+        audio: true,
+    },
+    'h264-ts': {
+        video: true,
+        audio: true,
+    },
+    h265: {
+        video: true,
+        audio: true,
+    },
+    mp3: {
+        audio: true,
+        video: false,
+    },
+    prores: {
+        audio: true,
+        video: true,
+    },
+    vp8: {
+        audio: true,
+        video: true,
+    },
+    vp9: {
+        audio: true,
+        video: true,
+    },
+    wav: {
+        audio: true,
+        video: false,
+    },
+};
+const codecSupportsMedia = (codec) => {
+    return support[codec];
+};
+exports.codecSupportsMedia = codecSupportsMedia;
+const codecSupportsVideoBitrateMap = {
+    'h264-mkv': true,
+    'h264-ts': true,
+    aac: false,
+    gif: false,
+    h264: true,
+    h265: true,
+    mp3: false,
+    prores: false,
+    vp8: true,
+    vp9: true,
+    wav: false,
+};
+const codecSupportsCrf = (codec) => {
+    const range = (0, crf_1.getValidCrfRanges)(codec);
+    return range[0] !== range[1];
+};
+exports.codecSupportsCrf = codecSupportsCrf;
+const codecSupportsVideoBitrate = (codec) => {
+    return codecSupportsVideoBitrateMap[codec];
+};
+exports.codecSupportsVideoBitrate = codecSupportsVideoBitrate;

package/package/dist/codec.d.ts

@@ -0,0 +1,4 @@
+export declare const validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "h264-ts", "gif"];
+export type Codec = (typeof validCodecs)[number];
+export type CodecOrUndefined = Codec | undefined;
+export declare const DEFAULT_CODEC: Codec;

package/package/dist/codec.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CODEC = exports.validCodecs = void 0;
+exports.validCodecs = [
+    'h264',
+    'h265',
+    'vp8',
+    'vp9',
+    'mp3',
+    'aac',
+    'wav',
+    'prores',
+    'h264-mkv',
+    'h264-ts',
+    'gif',
+];
+exports.DEFAULT_CODEC = 'h264';

package/package/dist/collect-assets.d.ts

@@ -0,0 +1,7 @@
+import type { ArtifactAsset } from 'remotion/no-react';
+import type { Page } from './browser/BrowserPage';
+export declare const collectAssets: ({ frame, freePage, timeoutInMilliseconds, }: {
+    frame: number;
+    freePage: Page;
+    timeoutInMilliseconds: number;
+}) => Promise<(import("remotion/no-react").AudioOrVideoAsset | ArtifactAsset | import("remotion/no-react").InlineAudioAsset)[]>;

package/package/dist/collect-assets.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectAssets = void 0;
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const collectAssets = async ({ frame, freePage, timeoutInMilliseconds, }) => {
+    const { value } = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        pageFunction: () => {
+            return window.remotion_collectAssets();
+        },
+        args: [],
+        frame,
+        page: freePage,
+        timeoutInMilliseconds,
+    });
+    const fixedArtifacts = value.map((asset) => {
+        if (asset.type !== 'artifact') {
+            return asset;
+        }
+        if (asset.contentType === 'binary' || asset.contentType === 'text') {
+            if (typeof asset.content !== 'string') {
+                throw new Error(`Expected string content for artifact ${asset.id}, but got ${asset.content}`);
+            }
+            const stringOrUintArray = asset.contentType === 'binary'
+                ? new TextEncoder().encode(atob(asset.content))
+                : asset.content;
+            return {
+                ...asset,
+                content: stringOrUintArray,
+            };
+        }
+        if (asset.contentType === 'thumbnail') {
+            return asset;
+        }
+        return asset;
+    });
+    return fixedArtifacts;
+};
+exports.collectAssets = collectAssets;

package/package/dist/combine-audio.d.ts

@@ -0,0 +1,21 @@
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { AudioCodec } from './options/audio-codec';
+export declare const durationOf1Frame: number;
+export declare const getClosestAlignedTime: (targetTime: number) => number;
+export declare const createCombinedAudio: ({ seamless, filelistDir, files, indent, logLevel, audioBitrate, resolvedAudioCodec, output, chunkDurationInSeconds, addRemotionMetadata, binariesDirectory, fps, cancelSignal, onProgress, }: {
+    seamless: boolean;
+    filelistDir: string;
+    files: string[];
+    indent: boolean;
+    logLevel: LogLevel;
+    audioBitrate: string | null;
+    resolvedAudioCodec: AudioCodec;
+    output: string;
+    chunkDurationInSeconds: number;
+    addRemotionMetadata: boolean;
+    binariesDirectory: string | null;
+    fps: number;
+    cancelSignal: CancelSignal | undefined;
+    onProgress: (frames: number) => void;
+}) => Promise<string>;

package/package/dist/combine-audio.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCombinedAudio = exports.getClosestAlignedTime = exports.durationOf1Frame = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const version_1 = require("remotion/version");
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const logger_1 = require("./logger");
+const audio_codec_1 = require("./options/audio-codec");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const sample_rate_1 = require("./sample-rate");
+const truthy_1 = require("./truthy");
+exports.durationOf1Frame = (1024 / sample_rate_1.DEFAULT_SAMPLE_RATE) * 1000000;
+const getClosestAlignedTime = (targetTime) => {
+    const decimalFramesToTargetTime = (targetTime * 1000000) / exports.durationOf1Frame;
+    const nearestFrameIndexForTargetTime = Math.round(decimalFramesToTargetTime);
+    return (nearestFrameIndexForTargetTime * exports.durationOf1Frame) / 1000000;
+};
+exports.getClosestAlignedTime = getClosestAlignedTime;
+const encodeAudio = async ({ files, resolvedAudioCodec, audioBitrate, filelistDir, output, indent, logLevel, addRemotionMetadata, fps, binariesDirectory, cancelSignal, onProgress, }) => {
+    var _a;
+    const fileList = files.map((p) => `file '${p}'`).join('\n');
+    const fileListTxt = (0, path_1.join)(filelistDir, 'audio-files.txt');
+    (0, fs_1.writeFileSync)(fileListTxt, fileList);
+    const startCombining = Date.now();
+    const command = [
+        '-hide_banner',
+        '-f',
+        'concat',
+        '-safe',
+        '0',
+        '-i',
+        fileListTxt,
+        '-c:a',
+        (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec),
+        resolvedAudioCodec === 'aac' ? '-cutoff' : null,
+        resolvedAudioCodec === 'aac' ? '18000' : null,
+        '-b:a',
+        audioBitrate ? audioBitrate : '320k',
+        '-vn',
+        addRemotionMetadata ? `-metadata` : null,
+        addRemotionMetadata ? `comment=Made with Remotion ${version_1.VERSION}` : null,
+        '-y',
+        output,
+    ];
+    logger_1.Log.verbose({ indent, logLevel }, `Combining audio with re-encoding, command: ${command.join(' ')}`);
+    try {
+        const task = (0, call_ffmpeg_1.callFf)({
+            args: command,
+            bin: 'ffmpeg',
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignal,
+        });
+        (_a = task.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+            const utf8 = data.toString('utf8');
+            const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(utf8, fps);
+            if (parsed === undefined) {
+                logger_1.Log.verbose({ indent, logLevel }, utf8);
+            }
+            else {
+                onProgress(parsed);
+                logger_1.Log.verbose({ indent, logLevel }, `Encoded ${parsed} audio frames`);
+            }
+        });
+        await task;
+        logger_1.Log.verbose({ indent, logLevel }, `Encoded audio in ${Date.now() - startCombining}ms`);
+        return output;
+    }
+    catch (e) {
+        (0, fs_1.rmSync)(fileListTxt, { recursive: true });
+        throw e;
+    }
+};
+const combineAudioSeamlessly = async ({ files, filelistDir, indent, logLevel, output, chunkDurationInSeconds, addRemotionMetadata, fps, binariesDirectory, cancelSignal, onProgress, }) => {
+    var _a;
+    const startConcatenating = Date.now();
+    const fileList = files
+        .map((p, i) => {
+        const isLast = i === files.length - 1;
+        const targetStart = i * chunkDurationInSeconds;
+        const endStart = (i + 1) * chunkDurationInSeconds;
+        const startTime = (0, exports.getClosestAlignedTime)(targetStart) * 1000000;
+        const endTime = (0, exports.getClosestAlignedTime)(endStart) * 1000000;
+        const realDuration = endTime - startTime;
+        let inpoint = 0;
+        if (i > 0) {
+            // Although we only asked for two frames of padding, ffmpeg will add an
+            // additional 2 frames of silence at the start of the segment. When we slice out
+            // our real data with inpoint and outpoint, we'll want remove both the silence
+            // and the extra frames we asked for.
+            inpoint = exports.durationOf1Frame * 4;
+        }
+        // inpoint is inclusive and outpoint is exclusive. To avoid overlap, we subtract
+        // the duration of one frame from the outpoint.
+        // we don't have to subtract a frame if this is the last segment.
+        const outpoint = (i === 0 ? exports.durationOf1Frame * 2 : inpoint) +
+            realDuration -
+            (isLast ? 0 : exports.durationOf1Frame);
+        return [`file '${p}'`, `inpoint ${inpoint}us`, `outpoint ${outpoint}us`]
+            .filter(truthy_1.truthy)
+            .join('\n');
+    })
+        .join('\n');
+    const fileListTxt = (0, path_1.join)(filelistDir, 'audio-files.txt');
+    (0, fs_1.writeFileSync)(fileListTxt, fileList);
+    const command = [
+        '-hide_banner',
+        '-f',
+        'concat',
+        '-safe',
+        '0',
+        '-i',
+        fileListTxt,
+        '-c:a',
+        'copy',
+        '-vn',
+        addRemotionMetadata ? `-metadata` : null,
+        addRemotionMetadata ? `comment=Made with Remotion ${version_1.VERSION}` : null,
+        '-y',
+        output,
+    ];
+    logger_1.Log.verbose({ indent, logLevel }, `Combining AAC audio seamlessly, command: ${command.join(' ')}`);
+    try {
+        const task = (0, call_ffmpeg_1.callFf)({
+            args: command,
+            bin: 'ffmpeg',
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignal,
+        });
+        (_a = task.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+            const utf8 = data.toString('utf8');
+            const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(utf8, fps);
+            if (parsed !== undefined) {
+                onProgress(parsed);
+                logger_1.Log.verbose({ indent, logLevel }, `Encoded ${parsed} audio frames`);
+            }
+        });
+        await task;
+        logger_1.Log.verbose({ indent, logLevel }, `Combined audio seamlessly in ${Date.now() - startConcatenating}ms`);
+        return output;
+    }
+    catch (e) {
+        (0, fs_1.rmSync)(fileListTxt, { recursive: true });
+        logger_1.Log.error({ indent, logLevel }, e);
+        throw e;
+    }
+};
+const createCombinedAudio = ({ seamless, filelistDir, files, indent, logLevel, audioBitrate, resolvedAudioCodec, output, chunkDurationInSeconds, addRemotionMetadata, binariesDirectory, fps, cancelSignal, onProgress, }) => {
+    if (seamless) {
+        return combineAudioSeamlessly({
+            filelistDir,
+            files,
+            indent,
+            logLevel,
+            output,
+            chunkDurationInSeconds,
+            addRemotionMetadata,
+            binariesDirectory,
+            fps,
+            cancelSignal,
+            onProgress,
+        });
+    }
+    return encodeAudio({
+        filelistDir,
+        files,
+        resolvedAudioCodec,
+        audioBitrate,
+        output,
+        indent,
+        logLevel,
+        addRemotionMetadata,
+        binariesDirectory,
+        fps,
+        cancelSignal,
+        onProgress,
+    });
+};
+exports.createCombinedAudio = createCombinedAudio;

package/package/dist/combine-chunks.d.ts

@@ -0,0 +1,39 @@
+import type { Codec } from './codec';
+import type { FrameRange } from './frame-range';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { AudioCodec } from './options/audio-codec';
+type MandatoryCombineChunksOptions = {
+    outputLocation: string;
+    audioFiles: string[];
+    codec: Codec;
+    videoFiles: string[];
+    fps: number;
+    framesPerChunk: number;
+    preferLossless: boolean;
+    compositionDurationInFrames: number;
+};
+type CombineChunksProgress = {
+    totalProgress: number;
+    frames: number;
+};
+export type CombineChunksOnProgress = (options: CombineChunksProgress) => void;
+type OptionalCombineChunksOptions = {
+    onProgress: CombineChunksOnProgress;
+    audioBitrate: string | null;
+    numberOfGifLoops: number | null;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    audioCodec: AudioCodec | null;
+    cancelSignal: CancelSignal | undefined;
+    metadata: Record<string, string> | null;
+    frameRange: FrameRange | null;
+    everyNthFrame: number;
+};
+type AllCombineChunksOptions = MandatoryCombineChunksOptions & OptionalCombineChunksOptions;
+export type CombineChunksOptions = MandatoryCombineChunksOptions & Partial<OptionalCombineChunksOptions>;
+export declare const internalCombineChunks: ({ outputLocation: output, onProgress, codec, fps, numberOfGifLoops, audioBitrate, indent, logLevel, binariesDirectory, cancelSignal, metadata, audioFiles, videoFiles, framesPerChunk, audioCodec, preferLossless, everyNthFrame, frameRange, compositionDurationInFrames, }: AllCombineChunksOptions & {
+    indent: boolean;
+}) => Promise<void>;
+export declare const combineChunks: (options: CombineChunksOptions) => Promise<void>;
+export {};

package/package/dist/combine-chunks.js

@@ -0,0 +1,171 @@
+"use strict";
+// Combine multiple video chunks, useful for decentralized rendering
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineChunks = exports.internalCombineChunks = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const can_concat_seamlessly_1 = require("./can-concat-seamlessly");
+const combine_audio_1 = require("./combine-audio");
+const combine_video_streams_1 = require("./combine-video-streams");
+const combine_video_streams_seamlessly_1 = require("./combine-video-streams-seamlessly");
+const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const get_frame_to_render_1 = require("./get-frame-to-render");
+const is_audio_codec_1 = require("./is-audio-codec");
+const logger_1 = require("./logger");
+const mux_video_and_audio_1 = require("./mux-video-and-audio");
+const audio_codec_1 = require("./options/audio-codec");
+const tmp_dir_1 = require("./tmp-dir");
+const truthy_1 = require("./truthy");
+const codecSupportsFastStart = {
+    'h264-mkv': false,
+    'h264-ts': false,
+    h264: true,
+    h265: true,
+    aac: false,
+    gif: false,
+    mp3: false,
+    prores: false,
+    vp8: false,
+    vp9: false,
+    wav: false,
+};
+const REMOTION_FILELIST_TOKEN = 'remotion-filelist';
+const internalCombineChunks = async ({ outputLocation: output, onProgress, codec, fps, numberOfGifLoops, audioBitrate, indent, logLevel, binariesDirectory, cancelSignal, metadata, audioFiles, videoFiles, framesPerChunk, audioCodec, preferLossless, everyNthFrame, frameRange, compositionDurationInFrames, }) => {
+    const filelistDir = (0, tmp_dir_1.tmpDir)(REMOTION_FILELIST_TOKEN);
+    const shouldCreateVideo = !(0, is_audio_codec_1.isAudioCodec)(codec);
+    const resolvedAudioCodec = (0, audio_codec_1.resolveAudioCodec)({
+        setting: audioCodec,
+        codec,
+        preferLossless,
+        separateAudioTo: null,
+    });
+    const shouldCreateAudio = resolvedAudioCodec !== null && audioFiles.length > 0;
+    const seamlessVideo = (0, can_concat_seamlessly_1.canConcatVideoSeamlessly)(codec);
+    const seamlessAudio = (0, can_concat_seamlessly_1.canConcatAudioSeamlessly)(resolvedAudioCodec, framesPerChunk);
+    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(compositionDurationInFrames, frameRange);
+    const numberOfFrames = (0, get_duration_from_frame_range_1.getFramesToRender)(realFrameRange, everyNthFrame).length;
+    const videoOutput = shouldCreateVideo
+        ? (0, node_path_1.join)(filelistDir, `video.${(0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, resolvedAudioCodec)}`)
+        : null;
+    const audioOutput = shouldCreateAudio
+        ? (0, node_path_1.join)(filelistDir, `audio.${(0, audio_codec_1.getExtensionFromAudioCodec)(resolvedAudioCodec)}`)
+        : null;
+    const chunkDurationInSeconds = framesPerChunk / fps;
+    let concatenatedAudio = 0;
+    let concatenatedVideo = 0;
+    let muxing = 0;
+    const updateProgress = () => {
+        const totalFrames = (shouldCreateAudio ? numberOfFrames : 0) +
+            (shouldCreateVideo ? numberOfFrames : 0) +
+            numberOfFrames;
+        const actualProgress = concatenatedAudio + concatenatedVideo + muxing;
+        onProgress({
+            frames: (actualProgress / totalFrames) * numberOfFrames,
+            totalProgress: actualProgress / totalFrames,
+        });
+    };
+    logger_1.Log.verbose({ indent, logLevel }, `Combining chunks, audio = ${shouldCreateAudio === false
+        ? 'no'
+        : seamlessAudio
+            ? 'seamlessly'
+            : 'normally'}, video = ${shouldCreateVideo === false
+        ? 'no'
+        : seamlessVideo
+            ? 'seamlessly'
+            : 'normally'}`);
+    await Promise.all([
+        shouldCreateAudio && audioOutput
+            ? (0, combine_audio_1.createCombinedAudio)({
+                audioBitrate,
+                filelistDir,
+                files: audioFiles,
+                indent,
+                logLevel,
+                output: audioOutput,
+                resolvedAudioCodec,
+                seamless: seamlessAudio,
+                chunkDurationInSeconds,
+                addRemotionMetadata: !shouldCreateVideo,
+                binariesDirectory,
+                fps,
+                cancelSignal,
+                onProgress: (frames) => {
+                    concatenatedAudio = frames;
+                    updateProgress();
+                },
+            })
+            : null,
+        shouldCreateVideo && !seamlessVideo && videoOutput
+            ? (0, combine_video_streams_1.combineVideoStreams)({
+                codec,
+                filelistDir,
+                fps,
+                indent,
+                logLevel,
+                numberOfGifLoops,
+                output: videoOutput,
+                files: videoFiles,
+                addRemotionMetadata: !shouldCreateAudio,
+                binariesDirectory,
+                cancelSignal,
+                onProgress: (frames) => {
+                    concatenatedVideo = frames;
+                    updateProgress();
+                },
+            })
+            : null,
+    ].filter(truthy_1.truthy));
+    try {
+        await (0, mux_video_and_audio_1.muxVideoAndAudio)({
+            audioOutput,
+            indent,
+            logLevel,
+            onProgress: (frames) => {
+                muxing = frames;
+                updateProgress();
+            },
+            output,
+            videoOutput: seamlessVideo
+                ? (0, combine_video_streams_seamlessly_1.combineVideoStreamsSeamlessly)({ files: videoFiles })
+                : videoOutput,
+            binariesDirectory,
+            fps,
+            cancelSignal,
+            addFaststart: codecSupportsFastStart[codec],
+            metadata,
+        });
+        onProgress({ totalProgress: 1, frames: numberOfFrames });
+        (0, node_fs_1.rmSync)(filelistDir, { recursive: true });
+    }
+    catch (err) {
+        (0, node_fs_1.rmSync)(filelistDir, { recursive: true });
+        throw err;
+    }
+};
+exports.internalCombineChunks = internalCombineChunks;
+const combineChunks = (options) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return (0, exports.internalCombineChunks)({
+        audioBitrate: (_a = options.audioBitrate) !== null && _a !== void 0 ? _a : null,
+        numberOfGifLoops: (_b = options.numberOfGifLoops) !== null && _b !== void 0 ? _b : null,
+        indent: false,
+        logLevel: (_c = options.logLevel) !== null && _c !== void 0 ? _c : 'info',
+        binariesDirectory: (_d = options.binariesDirectory) !== null && _d !== void 0 ? _d : null,
+        cancelSignal: options.cancelSignal,
+        metadata: (_e = options.metadata) !== null && _e !== void 0 ? _e : null,
+        audioCodec: (_f = options.audioCodec) !== null && _f !== void 0 ? _f : null,
+        preferLossless: options.preferLossless,
+        audioFiles: options.audioFiles,
+        codec: options.codec,
+        fps: options.fps,
+        framesPerChunk: options.framesPerChunk,
+        outputLocation: options.outputLocation,
+        onProgress: (_g = options.onProgress) !== null && _g !== void 0 ? _g : (() => { }),
+        videoFiles: options.videoFiles,
+        everyNthFrame: (_h = options.everyNthFrame) !== null && _h !== void 0 ? _h : 1,
+        frameRange: (_j = options.frameRange) !== null && _j !== void 0 ? _j : null,
+        compositionDurationInFrames: options.compositionDurationInFrames,
+    });
+};
+exports.combineChunks = combineChunks;

package/package/dist/combine-video-streams-seamlessly.d.ts

@@ -0,0 +1,3 @@
+export declare const combineVideoStreamsSeamlessly: ({ files }: {
+    files: string[];
+}) => string;

package/package/dist/combine-video-streams-seamlessly.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineVideoStreamsSeamlessly = void 0;
+const combineVideoStreamsSeamlessly = ({ files }) => {
+    const fileList = `concat:${files.join('|')}`;
+    return fileList;
+};
+exports.combineVideoStreamsSeamlessly = combineVideoStreamsSeamlessly;

package/package/dist/combine-video-streams.d.ts

@@ -0,0 +1,17 @@
+import type { Codec } from './codec';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+export declare const combineVideoStreams: ({ fps, codec, filelistDir, numberOfGifLoops, output, indent, logLevel, onProgress, files, addRemotionMetadata, binariesDirectory, cancelSignal, }: {
+    fps: number;
+    codec: Codec;
+    filelistDir: string;
+    numberOfGifLoops: number | null;
+    output: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    onProgress: (p: number) => void;
+    files: string[];
+    addRemotionMetadata: boolean;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+}) => Promise<string>;