@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha4

package/dist/index.d.ts

@@ -1,19 +1,24 @@
+/// <reference types="node" />
 import execa from 'execa';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
 import { mimeContentType, mimeLookup } from './mime-types';
 import * as perf from './perf';
 export type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 export type { DownloadMap } from './assets/download-map';
+export { AudioCodec } from './audio-codec';
 export { Browser } from './browser';
 export { BrowserExecutable } from './browser-executable';
 export { BrowserLog } from './browser-log';
 export { Codec, CodecOrUndefined } from './codec';
-export { combineVideos } from './combine-videos';
 export { Crf } from './crf';
+export { ensureFfmpeg, EnsureFfmpegOptions, ensureFfprobe, } from './ensure-ffmpeg';
 export { ErrorWithStackFrame } from './error-handling/handle-javascript-exception';
 export { FfmpegExecutable } from './ffmpeg-executable';
 export { FfmpegVersion } from './ffmpeg-flags';
+export type { FfmpegOverrideFn } from './ffmpeg-override';
+export { FileExtension } from './file-extensions';
 export { FrameRange } from './frame-range';
+export { getCanExtractFramesFast } from './get-can-extract-frames-fast';
 export { getCompositions } from './get-compositions';
 export { ImageFormat, StillImageFormat, validateSelectedPixelFormatAndImageFormatCombination, validImageFormats, } from './image-format';
 export type { LogLevel } from './log-level';
@@ -23,28 +28,22 @@ export type { ChromiumOptions } from './open-browser';
 export { PixelFormat } from './pixel-format';
 export { ProResProfile } from './prores-profile';
 export { renderFrames } from './render-frames';
-export { renderMedia, RenderMediaOnProgress, RenderMediaOptions, StitchingState, } from './render-media';
-export { renderStill } from './render-still';
+export { OnSlowestFrames, renderMedia, RenderMediaOnProgress, RenderMediaOptions, SlowFrame, StitchingState, } from './render-media';
+export { renderStill, RenderStillOptions } from './render-still';
 export { StitcherOptions, stitchFramesToVideo } from './stitch-frames-to-video';
 export { SymbolicatedStackFrame } from './symbolicate-stacktrace';
 export { OnStartData, RenderFramesOutput } from './types';
 export { OpenGlRenderer } from './validate-opengl-renderer';
+export { validateOutputFilename } from './validate-output-filename';
 export declare const RenderInternals: {
     ensureLocalBrowser: (browser: import("./browser").Browser, preferredBrowserExecutable: import("./browser-executable").BrowserExecutable) => Promise<void>;
-    ffmpegHasFeature: ({ ffmpegExecutable, feature, isLambda, }: {
+    ffmpegHasFeature: ({ ffmpegExecutable, feature, remotionRoot, }: {
         ffmpegExecutable: string | null;
         feature: "enable-gpl" | "enable-libx265" | "enable-libvpx";
-        isLambda: boolean;
+        remotionRoot: string;
     }) => Promise<boolean>;
-    getActualConcurrency: (userPreference: number | null) => number;
-    getFfmpegVersion: (options: {
-        ffmpegExecutable: string | null;
-    }) => Promise<import("./ffmpeg-flags").FfmpegVersion>;
-    validateFfmpeg: (customFfmpegBinary: string | null) => Promise<void>;
-    binaryExists: (name: "ffmpeg" | "brew", localFFmpeg: string | null) => Promise<boolean>;
-    getFfmpegBuildInfo: (options: {
-        ffmpegExecutable: string | null;
-    }) => Promise<string>;
+    getActualConcurrency: (userPreference: string | number | null) => number;
+    validateFfmpeg: (customFfmpegBinary: string | null, remotionRoot: string, binary: "ffmpeg" | "ffprobe") => Promise<void>;
     serveStatic: (path: string | null, options: {
         port: number | null;
         ffmpegExecutable: import("./ffmpeg-executable").FfmpegExecutable;
@@ -52,6 +51,7 @@ export declare const RenderInternals: {
         onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload;
         onError: (err: Error) => void;
         downloadMap: import("./assets/download-map").DownloadMap;
+        remotionRoot: string;
     }) => Promise<{
         port: number;
         close: () => Promise<void>;
@@ -60,23 +60,18 @@ export declare const RenderInternals: {
         width: number;
         height: number;
         scale: number;
-        codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
     }) => void;
-    normalizeServeUrl: (unnormalized: string) => string;
-    spawnFfmpeg: (options: import("./stitch-frames-to-video").StitcherOptions) => Promise<{
-        task: Promise<Buffer | null>;
-        getLogs: () => string;
-    }>;
-    getFileExtensionFromCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";
+    getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => import("./file-extensions").FileExtension;
     tmpDir: (str: string) => string;
-    deleteDirectory: (directory: string) => Promise<void>;
+    deleteDirectory: (directory: string) => void;
     isServeUrl: (potentialUrl: string) => boolean;
     ensureOutputDirectory: (outputLocation: string) => void;
     getRealFrameRange: (durationInFrames: number, frameRange: import("./frame-range").FrameRange | null) => [number, number];
     validatePuppeteerTimeout: (timeoutInMilliseconds: unknown) => void;
     downloadFile: ({ onProgress, url, to: toFn, }: {
         url: string;
-        to: (contentDisposition: string | null) => string;
+        to: (contentDisposition: string | null, contentType: string | null) => string;
         onProgress: ((progress: {
             percent: number | null;
             downloaded: number;
@@ -86,14 +81,16 @@ export declare const RenderInternals: {
         sizeInBytes: number;
         to: string;
     }>;
-    validateScale: (scale: unknown) => void;
     killAllBrowsers: () => Promise<void>;
     parseStack: (stack: string[]) => import("./parse-browser-error-stack").UnsymbolicatedStackFrame[];
     symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<import("./error-handling/handle-javascript-exception").ErrorWithStackFrame>;
     SymbolicateableError: typeof SymbolicateableError;
     getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];
     getExtensionOfFilename: (filename: string | null) => string | null;
-    getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
+    getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<{
+        port: number;
+        didUsePort: () => void;
+    }>;
     isPathInside: (thePath: string, potentialParent: string) => boolean;
     execa: {
         (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
@@ -115,35 +112,184 @@ export declare const RenderInternals: {
     };
     registerErrorSymbolicationLock: () => number;
     unlockErrorSymbolicationLock: (id: number) => void;
-    canUseParallelEncoding: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+    canUseParallelEncoding: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
     mimeContentType: typeof mimeContentType;
     mimeLookup: typeof mimeLookup;
     validateConcurrency: (value: unknown, setting: string) => void;
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_BROWSER: import("./browser").Browser;
     validateFrameRange: (frameRange: import("./frame-range").FrameRange | null) => void;
-    DEFAULT_OPENGL_RENDERER: "swangle" | "angle" | "egl" | "swiftshader" | null;
-    validateOpenGlRenderer: (option: "swangle" | "angle" | "egl" | "swiftshader" | null) => "swangle" | "angle" | "egl" | "swiftshader" | null;
-    getDefaultCrfForCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
-    validateSelectedCrfAndCodecCombination: (crf: unknown, codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
+    DEFAULT_OPENGL_RENDERER: "angle" | "swangle" | "egl" | "swiftshader" | null;
+    validateOpenGlRenderer: (option: "angle" | "swangle" | "egl" | "swiftshader" | null) => "angle" | "swangle" | "egl" | "swiftshader" | null;
     validImageFormats: readonly ["png", "jpeg", "none"];
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
-    DEFAULT_OVERWRITE: boolean;
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
     validateQuality: (q: number | undefined) => void;
-    validateFrame: (frame: number, durationInFrames: number) => void;
     DEFAULT_TIMEOUT: number;
-    getValidCrfRanges: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
-    validateSelectedPixelFormatAndCodecCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
-    validateSelectedCodecAndProResCombination: (actualCodec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", actualProResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | undefined) => void;
-    validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", imageFormat: "none" | "png" | "jpeg") => "none" | "valid";
-    DEFAULT_CODEC: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
-    isAudioCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
+    DEFAULT_CODEC: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    isAudioCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
     logLevels: readonly ["verbose", "info", "warn", "error"];
-    isEqualOrBelowLogLevel: (currentLevel: "verbose" | "info" | "warn" | "error", level: "verbose" | "info" | "warn" | "error") => boolean;
+    isEqualOrBelowLogLevel: (currentLevel: "error" | "verbose" | "info" | "warn", level: "error" | "verbose" | "info" | "warn") => boolean;
     isValidLogLevel: (level: string) => boolean;
-    validateEveryNthFrame: (everyNthFrame: unknown) => void;
     perf: typeof perf;
     makeDownloadMap: () => import("./assets/download-map").DownloadMap;
-    cleanDownloadMap: (downloadMap: import("./assets/download-map").DownloadMap) => Promise<void>;
+    cleanDownloadMap: (downloadMap: import("./assets/download-map").DownloadMap) => void;
+    convertToPositiveFrameIndex: ({ frame, durationInFrames, }: {
+        frame: number;
+        durationInFrames: number;
+    }) => number;
+    findRemotionRoot: () => string;
+    getExecutableBinary: (ffmpegExecutable: import("./ffmpeg-executable").FfmpegExecutable, remotionRoot: string, binary: "ffmpeg" | "ffprobe") => string | Promise<string>;
+    validateBitrate: (bitrate: unknown, name: string) => void;
+    getFfmpegVersion: (options: {
+        ffmpegExecutable: string | null;
+        remotionRoot: string;
+    }) => Promise<import("./ffmpeg-flags").FfmpegVersion>;
+    combineVideos: (options: {
+        files: string[];
+        filelistDir: string;
+        output: string;
+        onProgress: (p: number) => void;
+        numberOfFrames: number;
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        fps: number;
+        numberOfGifLoops: number | null;
+        remotionRoot: string;
+        ffmpegExecutable: import("./ffmpeg-executable").FfmpegExecutable;
+        audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
+    }) => Promise<void>;
+    getDefaultAudioCodec: ({ codec, preferLossless, }: {
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        preferLossless: boolean;
+    }) => "mp3" | "aac" | "pcm-16" | "opus" | null;
+    validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+    defaultFileExtensionMap: {
+        h264: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp8: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp9: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        wav: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        prores: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        "h264-mkv": {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        gif: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {};
+        };
+    };
+    supportedAudioCodecs: {
+        readonly h264: readonly ["aac", "pcm-16"];
+        readonly 'h264-mkv': readonly ["pcm-16"];
+        readonly aac: readonly ["aac", "pcm-16"];
+        readonly gif: readonly [];
+        readonly h265: readonly ["aac", "pcm-16"];
+        readonly mp3: readonly ["mp3", "pcm-16"];
+        readonly prores: readonly ["pcm-16", "aac"];
+        readonly vp8: readonly ["opus", "pcm-16"];
+        readonly vp9: readonly ["opus", "pcm-16"];
+        readonly wav: readonly ["pcm-16"];
+    };
+    makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">;
 };

package/dist/index.js

@@ -26,20 +26,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderInternals = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.validImageFormats = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.getCompositions = exports.ErrorWithStackFrame = exports.combineVideos = void 0;
+exports.RenderInternals = exports.validateOutputFilename = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.validImageFormats = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.getCompositions = exports.getCanExtractFramesFast = exports.ErrorWithStackFrame = exports.ensureFfprobe = exports.ensureFfmpeg = void 0;
 const execa_1 = __importDefault(require("execa"));
 const download_file_1 = require("./assets/download-file");
 const download_map_1 = require("./assets/download-map");
+const audio_codec_1 = require("./audio-codec");
 const browser_1 = require("./browser");
 const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
+const check_apple_silicon_1 = require("./check-apple-silicon");
 const codec_1 = require("./codec");
-const crf_1 = require("./crf");
+const combine_videos_1 = require("./combine-videos");
+const convert_to_positive_frame_index_1 = require("./convert-to-positive-frame-index");
 const delete_directory_1 = require("./delete-directory");
 const ensure_output_directory_1 = require("./ensure-output-directory");
 const symbolicate_error_1 = require("./error-handling/symbolicate-error");
 const symbolicateable_error_1 = require("./error-handling/symbolicateable-error");
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const file_extensions_1 = require("./file-extensions");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const frame_range_1 = require("./frame-range");
 const get_concurrency_1 = require("./get-concurrency");
 const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
@@ -53,31 +58,28 @@ const is_audio_codec_1 = require("./is-audio-codec");
 const is_serve_url_1 = require("./is-serve-url");
 const log_level_1 = require("./log-level");
 const mime_types_1 = require("./mime-types");
-const normalize_serve_url_1 = require("./normalize-serve-url");
 const open_browser_1 = require("./open-browser");
-const overwrite_1 = require("./overwrite");
 const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
 const perf = __importStar(require("./perf"));
 const pixel_format_1 = require("./pixel-format");
-const prores_profile_1 = require("./prores-profile");
 const quality_1 = require("./quality");
 const is_path_inside_1 = require("./serve-handler/is-path-inside");
 const serve_static_1 = require("./serve-static");
-const stitch_frames_to_video_1 = require("./stitch-frames-to-video");
 const tmp_dir_1 = require("./tmp-dir");
 const validate_concurrency_1 = require("./validate-concurrency");
 const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
-const validate_every_nth_frame_1 = require("./validate-every-nth-frame");
 const validate_ffmpeg_1 = require("./validate-ffmpeg");
-const validate_frame_1 = require("./validate-frame");
 const validate_opengl_renderer_1 = require("./validate-opengl-renderer");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
-const validate_scale_1 = require("./validate-scale");
+const validate_videobitrate_1 = require("./validate-videobitrate");
 const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
-var combine_videos_1 = require("./combine-videos");
-Object.defineProperty(exports, "combineVideos", { enumerable: true, get: function () { return combine_videos_1.combineVideos; } });
+var ensure_ffmpeg_1 = require("./ensure-ffmpeg");
+Object.defineProperty(exports, "ensureFfmpeg", { enumerable: true, get: function () { return ensure_ffmpeg_1.ensureFfmpeg; } });
+Object.defineProperty(exports, "ensureFfprobe", { enumerable: true, get: function () { return ensure_ffmpeg_1.ensureFfprobe; } });
 var handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
 Object.defineProperty(exports, "ErrorWithStackFrame", { enumerable: true, get: function () { return handle_javascript_exception_1.ErrorWithStackFrame; } });
+var get_can_extract_frames_fast_1 = require("./get-can-extract-frames-fast");
+Object.defineProperty(exports, "getCanExtractFramesFast", { enumerable: true, get: function () { return get_can_extract_frames_fast_1.getCanExtractFramesFast; } });
 var get_compositions_1 = require("./get-compositions");
 Object.defineProperty(exports, "getCompositions", { enumerable: true, get: function () { return get_compositions_1.getCompositions; } });
 var image_format_2 = require("./image-format");
@@ -93,20 +95,17 @@ var render_media_1 = require("./render-media");
 Object.defineProperty(exports, "renderMedia", { enumerable: true, get: function () { return render_media_1.renderMedia; } });
 var render_still_1 = require("./render-still");
 Object.defineProperty(exports, "renderStill", { enumerable: true, get: function () { return render_still_1.renderStill; } });
-var stitch_frames_to_video_2 = require("./stitch-frames-to-video");
-Object.defineProperty(exports, "stitchFramesToVideo", { enumerable: true, get: function () { return stitch_frames_to_video_2.stitchFramesToVideo; } });
+var stitch_frames_to_video_1 = require("./stitch-frames-to-video");
+Object.defineProperty(exports, "stitchFramesToVideo", { enumerable: true, get: function () { return stitch_frames_to_video_1.stitchFramesToVideo; } });
+var validate_output_filename_1 = require("./validate-output-filename");
+Object.defineProperty(exports, "validateOutputFilename", { enumerable: true, get: function () { return validate_output_filename_1.validateOutputFilename; } });
 exports.RenderInternals = {
     ensureLocalBrowser: get_local_browser_executable_1.ensureLocalBrowser,
     ffmpegHasFeature: ffmpeg_flags_1.ffmpegHasFeature,
     getActualConcurrency: get_concurrency_1.getActualConcurrency,
-    getFfmpegVersion: ffmpeg_flags_1.getFfmpegVersion,
     validateFfmpeg: validate_ffmpeg_1.validateFfmpeg,
-    binaryExists: validate_ffmpeg_1.binaryExists,
-    getFfmpegBuildInfo: ffmpeg_flags_1.getFfmpegBuildInfo,
     serveStatic: serve_static_1.serveStatic,
     validateEvenDimensionsWithCodec: validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec,
-    normalizeServeUrl: normalize_serve_url_1.normalizeServeUrl,
-    spawnFfmpeg: stitch_frames_to_video_1.spawnFfmpeg,
     getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
     tmpDir: tmp_dir_1.tmpDir,
     deleteDirectory: delete_directory_1.deleteDirectory,
@@ -115,7 +114,6 @@ exports.RenderInternals = {
     getRealFrameRange: get_frame_to_render_1.getRealFrameRange,
     validatePuppeteerTimeout: validate_puppeteer_timeout_1.validatePuppeteerTimeout,
     downloadFile: download_file_1.downloadFile,
-    validateScale: validate_scale_1.validateScale,
     killAllBrowsers: open_browser_1.killAllBrowsers,
     parseStack: parse_browser_error_stack_1.parseStack,
     symbolicateError: symbolicate_error_1.symbolicateError,
@@ -136,26 +134,31 @@ exports.RenderInternals = {
     validateFrameRange: frame_range_1.validateFrameRange,
     DEFAULT_OPENGL_RENDERER: validate_opengl_renderer_1.DEFAULT_OPENGL_RENDERER,
     validateOpenGlRenderer: validate_opengl_renderer_1.validateOpenGlRenderer,
-    getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
-    validateSelectedCrfAndCodecCombination: crf_1.validateSelectedCrfAndCodecCombination,
     validImageFormats: image_format_1.validImageFormats,
     validCodecs: codec_1.validCodecs,
-    DEFAULT_OVERWRITE: overwrite_1.DEFAULT_OVERWRITE,
     DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
     validateQuality: quality_1.validateQuality,
-    validateFrame: validate_frame_1.validateFrame,
     DEFAULT_TIMEOUT: TimeoutSettings_1.DEFAULT_TIMEOUT,
-    getValidCrfRanges: crf_1.getValidCrfRanges,
-    validateSelectedPixelFormatAndCodecCombination: pixel_format_1.validateSelectedPixelFormatAndCodecCombination,
-    validateSelectedCodecAndProResCombination: prores_profile_1.validateSelectedCodecAndProResCombination,
-    validateSelectedPixelFormatAndImageFormatCombination: image_format_1.validateSelectedPixelFormatAndImageFormatCombination,
     DEFAULT_CODEC: codec_1.DEFAULT_CODEC,
     isAudioCodec: is_audio_codec_1.isAudioCodec,
     logLevels: log_level_1.logLevels,
     isEqualOrBelowLogLevel: log_level_1.isEqualOrBelowLogLevel,
     isValidLogLevel: log_level_1.isValidLogLevel,
-    validateEveryNthFrame: validate_every_nth_frame_1.validateEveryNthFrame,
     perf,
     makeDownloadMap: download_map_1.makeDownloadMap,
     cleanDownloadMap: download_map_1.cleanDownloadMap,
+    convertToPositiveFrameIndex: convert_to_positive_frame_index_1.convertToPositiveFrameIndex,
+    findRemotionRoot: find_closest_package_json_1.findRemotionRoot,
+    getExecutableBinary: ffmpeg_flags_1.getExecutableBinary,
+    validateBitrate: validate_videobitrate_1.validateBitrate,
+    getFfmpegVersion: ffmpeg_flags_1.getFfmpegVersion,
+    combineVideos: combine_videos_1.combineVideos,
+    getDefaultAudioCodec: audio_codec_1.getDefaultAudioCodec,
+    validAudioCodecs: audio_codec_1.validAudioCodecs,
+    defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
+    supportedAudioCodecs: file_extensions_1.supportedAudioCodecs,
+    makeFileExtensionMap: get_extension_from_codec_1.makeFileExtensionMap,
+    defaultCodecsForFileExtension: get_extension_from_codec_1.defaultCodecsForFileExtension,
 };
+// Warn of potential performance issues with Apple Silicon (M1 chip under Rosetta)
+(0, check_apple_silicon_1.checkNodeVersionAndWarnAboutRosetta)();

package/dist/last-frame-from-video-cache.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { OffthreadVideoImageFormat } from 'remotion';
 import type { DownloadMap, SpecialVCodecForTransparency } from './assets/download-map';
 import type { FfmpegExecutable } from './ffmpeg-executable';
@@ -10,6 +11,7 @@ export declare type LastFrameOptions = {
     imageFormat: OffthreadVideoImageFormat;
     needsResize: [number, number] | null;
     downloadMap: DownloadMap;
+    remotionRoot: string;
 };
 export declare const setLastFrameInCache: (options: LastFrameOptions, data: Buffer) => void;
 export declare const getLastFrameFromCache: (options: LastFrameOptions) => Buffer | null;

package/dist/locks.d.ts

@@ -0,0 +1,7 @@
+export declare const createLock: ({ timeout }: {
+    timeout: number | null;
+}) => {
+    lock: () => number;
+    unlock: (id: number) => void;
+    waitForAllToBeDone: () => Promise<unknown>;
+};

package/dist/locks.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLock = void 0;
+const createLock = ({ timeout }) => {
+    let locks = [];
+    const waiters = [];
+    const lock = () => {
+        const id = Math.random();
+        locks.push(id);
+        return id;
+    };
+    const unlock = (id) => {
+        locks = locks.filter((l) => l !== id);
+        resolveWaiters();
+    };
+    const resolveWaiters = () => {
+        if (locks.length === 0) {
+            waiters.forEach((w) => w());
+        }
+    };
+    const waitForAllToBeDone = () => {
+        const success = new Promise((resolve) => {
+            waiters.push(() => {
+                resolve();
+            });
+        });
+        resolveWaiters();
+        if (timeout === null) {
+            return success;
+        }
+        const timeoutFn = new Promise((resolve) => {
+            setTimeout(() => {
+                return resolve();
+            }, timeout);
+        });
+        return Promise.race([success, timeoutFn]);
+    };
+    return {
+        lock,
+        unlock,
+        waitForAllToBeDone,
+    };
+};
+exports.createLock = createLock;

package/dist/make-cancel-signal.d.ts

@@ -1,7 +1,18 @@
 declare type Callback = () => void;
 export declare type CancelSignal = (callback: Callback) => void;
+/**
+ * @description Returns a signal and a cancel function that allows to you cancel a render triggered using renderMedia(), renderStill(), renderFrames() or stitchFramesToVideo().
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/make-cancel-signal)
+ */
 export declare const makeCancelSignal: () => {
     cancelSignal: CancelSignal;
     cancel: () => void;
 };
+export declare const cancelErrorMessages: {
+    renderMedia: string;
+    renderFrames: string;
+    renderStill: string;
+    stitchFramesToVideo: string;
+};
+export declare const isUserCancelledRender: (err: unknown) => boolean;
 export {};

package/dist/make-cancel-signal.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeCancelSignal = void 0;
+exports.isUserCancelledRender = exports.cancelErrorMessages = exports.makeCancelSignal = void 0;
+/**
+ * @description Returns a signal and a cancel function that allows to you cancel a render triggered using renderMedia(), renderStill(), renderFrames() or stitchFramesToVideo().
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/make-cancel-signal)
+ */
 const makeCancelSignal = () => {
     const callbacks = [];
     let cancelled = false;
@@ -23,3 +27,22 @@ const makeCancelSignal = () => {
     };
 };
 exports.makeCancelSignal = makeCancelSignal;
+exports.cancelErrorMessages = {
+    renderMedia: 'renderMedia() got cancelled',
+    renderFrames: 'renderFrames() got cancelled',
+    renderStill: 'renderStill() got cancelled',
+    stitchFramesToVideo: 'stitchFramesToVideo() got cancelled',
+};
+const isUserCancelledRender = (err) => {
+    if (typeof err === 'object' &&
+        err !== null &&
+        'message' in err &&
+        typeof err.message === 'string') {
+        return (err.message.includes(exports.cancelErrorMessages.renderMedia) ||
+            err.message.includes(exports.cancelErrorMessages.renderFrames) ||
+            err.message.includes(exports.cancelErrorMessages.renderStill) ||
+            err.message.includes(exports.cancelErrorMessages.stitchFramesToVideo));
+    }
+    return false;
+};
+exports.isUserCancelledRender = isUserCancelledRender;

package/dist/merge-audio-track.d.ts

@@ -1,11 +1,13 @@
 import type { DownloadMap } from './assets/download-map';
 import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
 declare type Options = {
     ffmpegExecutable: FfmpegExecutable;
-    files: string[];
+    files: PreprocessedAudioTrack[];
     outName: string;
     numberOfSeconds: number;
     downloadMap: DownloadMap;
+    remotionRoot: string;
 };
 export declare const mergeAudioTrack: (options: Options) => Promise<void>;
 export {};