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

package/dist/render-frames.js

@@ -4,63 +4,54 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderFrames = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const perf_hooks_1 = require("perf_hooks");
 const remotion_1 = require("remotion");
 const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
 const download_map_1 = require("./assets/download-map");
 const browser_1 = require("./browser");
+const is_target_closed_err_1 = require("./browser/is-target-closed-err");
 const compress_assets_1 = require("./compress-assets");
 const cycle_browser_tabs_1 = require("./cycle-browser-tabs");
 const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const get_concurrency_1 = require("./get-concurrency");
 const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
 const get_frame_padded_index_1 = require("./get-frame-padded-index");
 const get_frame_to_render_1 = require("./get-frame-to-render");
 const image_format_1 = require("./image-format");
-const legacy_webpack_config_1 = require("./legacy-webpack-config");
+const jpeg_quality_1 = require("./jpeg-quality");
+const make_cancel_signal_1 = require("./make-cancel-signal");
 const open_browser_1 = require("./open-browser");
 const perf_1 = require("./perf");
 const pool_1 = require("./pool");
 const prepare_server_1 = require("./prepare-server");
-const provide_screenshot_1 = require("./provide-screenshot");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
-const quality_1 = require("./quality");
+const replace_browser_1 = require("./replace-browser");
 const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
+const take_frame_and_compose_1 = require("./take-frame-and-compose");
 const truthy_1 = require("./truthy");
 const validate_scale_1 = require("./validate-scale");
-const getComposition = (others) => {
-    if ('composition' in others) {
-        return others.composition;
-    }
-    if ('config' in others) {
-        return others.config;
-    }
-    return undefined;
-};
-const getPool = async (pages) => {
-    const puppeteerPages = await Promise.all(pages);
-    const pool = new pool_1.Pool(puppeteerPages);
-    return pool;
-};
-const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, quality, imageFormat = image_format_1.DEFAULT_IMAGE_FORMAT, frameRange, puppeteerInstance, onError, envVariables, onBrowserLog, onFrameBuffer, onDownload, pagesArray, serveUrl, composition, timeoutInMilliseconds, scale, actualParallelism, everyNthFrame = 1, proxyPort, cancelSignal, downloadMap, }) => {
-    if (!puppeteerInstance) {
-        throw new Error('no puppeteer instance passed to innerRenderFrames - internal error');
-    }
+const MAX_RETRIES_PER_FRAME = 1;
+const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, jpegQuality, quality, imageFormat = image_format_1.DEFAULT_VIDEO_IMAGE_FORMAT, frameRange, onError, envVariables, onBrowserLog, onFrameBuffer, onDownload, pagesArray, serveUrl, composition, timeoutInMilliseconds, scale = 1, actualConcurrency, everyNthFrame = 1, proxyPort, cancelSignal, downloadMap, muted, makeBrowser, browserReplacer, compositor, }) => {
     if (outputDir) {
-        if (!fs_1.default.existsSync(outputDir)) {
-            fs_1.default.mkdirSync(outputDir, {
+        if (!node_fs_1.default.existsSync(outputDir)) {
+            node_fs_1.default.mkdirSync(outputDir, {
                 recursive: true,
             });
         }
     }
+    if (quality) {
+        throw new Error(`The "quality" option has been renamed. Use "jpegQuality" instead.`);
+    }
     const downloadPromises = [];
     const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange !== null && frameRange !== void 0 ? frameRange : null);
     const framesToRender = (0, get_duration_from_frame_range_1.getFramesToRender)(realFrameRange, everyNthFrame);
     const lastFrame = framesToRender[framesToRender.length - 1];
-    const pages = new Array(actualParallelism).fill(true).map(async () => {
-        const page = await puppeteerInstance.newPage();
+    const makePage = async () => {
+        const page = await browserReplacer.getBrowser().newPage();
         pagesArray.push(page);
         await page.setViewport({
             width: composition.width,
@@ -87,21 +78,42 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
             timeoutInMilliseconds,
             proxyPort,
             retriesRemaining: 2,
+            audioEnabled: !muted,
+            videoEnabled: imageFormat !== 'none',
         });
         await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
-            pageFunction: (id) => {
+            // eslint-disable-next-line max-params
+            pageFunction: (id, defaultProps, durationInFrames, fps, height, width) => {
                 window.setBundleMode({
                     type: 'composition',
                     compositionName: id,
+                    compositionDefaultProps: defaultProps,
+                    compositionDurationInFrames: durationInFrames,
+                    compositionFps: fps,
+                    compositionHeight: height,
+                    compositionWidth: width,
                 });
             },
-            args: [composition.id],
+            args: [
+                composition.id,
+                composition.defaultProps,
+                composition.durationInFrames,
+                composition.fps,
+                composition.height,
+                composition.width,
+            ],
             frame: null,
             page,
         });
         page.off('console', logCallback);
         return page;
-    });
+    };
+    const getPool = async () => {
+        const pages = new Array(actualConcurrency).fill(true).map(() => makePage());
+        const puppeteerPages = await Promise.all(pages);
+        const pool = new pool_1.Pool(puppeteerPages);
+        return pool;
+    };
     // If rendering a GIF and skipping frames, we must ensure it starts from 0
     // and then is consecutive so FFMPEG recognizes the sequence
     const countType = everyNthFrame === 1 ? 'actual-frames' : 'from-zero';
@@ -111,7 +123,7 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         countType,
     });
     let framesRendered = 0;
-    const poolPromise = getPool(pages);
+    const poolPromise = getPool();
     onStart({
         frameCount: framesToRender.length,
     });
@@ -120,14 +132,15 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
     cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
         stopped = true;
     });
-    const progress = Promise.all(framesToRender.map(async (frame, index) => {
+    const renderFrameWithOptionToReject = async ({ frame, index, reject, width, height, }) => {
         const pool = await poolPromise;
         const freePage = await pool.acquire();
         if (stopped) {
-            throw new Error('Render was stopped');
+            return reject(new Error('Render was stopped'));
         }
+        const startTime = perf_hooks_1.performance.now();
         const errorCallbackOnFrame = (err) => {
-            onError(err);
+            reject(err);
         };
         const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
             page: freePage,
@@ -136,52 +149,41 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         });
         freePage.on('error', errorCallbackOnFrame);
         await (0, seek_to_frame_1.seekToFrame)({ frame, page: freePage });
-        if (imageFormat !== 'none') {
-            if (onFrameBuffer) {
-                const id = (0, perf_1.startPerfMeasure)('save');
-                const buffer = await (0, provide_screenshot_1.provideScreenshot)({
-                    page: freePage,
-                    imageFormat,
-                    quality,
-                    options: {
-                        frame,
-                        output: null,
-                    },
-                });
-                (0, perf_1.stopPerfMeasure)(id);
-                onFrameBuffer(buffer, frame);
-            }
-            else {
-                if (!outputDir) {
-                    throw new Error('Called renderFrames() without specifying either `outputDir` or `onFrameBuffer`');
-                }
-                const output = path_1.default.join(outputDir, (0, get_frame_padded_index_1.getFrameOutputFileName)({
-                    frame,
-                    imageFormat,
-                    index,
-                    countType,
-                    lastFrame,
-                    totalFrames: framesToRender.length,
-                }));
-                await (0, provide_screenshot_1.provideScreenshot)({
-                    page: freePage,
-                    imageFormat,
-                    quality,
-                    options: {
-                        frame,
-                        output,
-                    },
-                });
-            }
+        if (!outputDir && !onFrameBuffer && imageFormat !== 'none') {
+            throw new Error('Called renderFrames() without specifying either `outputDir` or `onFrameBuffer`');
         }
-        const collectedAssets = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
-            pageFunction: () => {
-                return window.remotion_collectAssets();
-            },
-            args: [],
+        if (outputDir && onFrameBuffer && imageFormat !== 'none') {
+            throw new Error('Pass either `outputDir` or `onFrameBuffer` to renderFrames(), not both.');
+        }
+        const id = (0, perf_1.startPerfMeasure)('save');
+        const frameDir = outputDir !== null && outputDir !== void 0 ? outputDir : downloadMap.compositingDir;
+        const { buffer, collectedAssets } = await (0, take_frame_and_compose_1.takeFrameAndCompose)({
             frame,
-            page: freePage,
+            freePage,
+            height,
+            imageFormat,
+            output: node_path_1.default.join(frameDir, (0, get_frame_padded_index_1.getFrameOutputFileName)({
+                frame,
+                imageFormat,
+                index,
+                countType,
+                lastFrame,
+                totalFrames: framesToRender.length,
+            })),
+            jpegQuality,
+            width,
+            scale,
+            downloadMap,
+            wantsBuffer: Boolean(onFrameBuffer),
+            compositor,
         });
+        if (onFrameBuffer) {
+            if (!buffer) {
+                throw new Error('unexpected null buffer');
+            }
+            onFrameBuffer(buffer, frame);
+        }
+        (0, perf_1.stopPerfMeasure)(id);
         const compressedAssets = collectedAssets.map((asset) => (0, compress_assets_1.compressAsset)(assets.filter(truthy_1.truthy).flat(1), asset));
         assets[index] = compressedAssets;
         compressedAssets.forEach((asset) => {
@@ -193,19 +195,86 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
                 onError(new Error(`Error while downloading asset: ${err.stack}`));
             });
         });
-        pool.release(freePage);
         framesRendered++;
-        onFrameUpdate(framesRendered, frame);
+        onFrameUpdate(framesRendered, frame, perf_hooks_1.performance.now() - startTime);
         cleanupPageError();
         freePage.off('error', errorCallbackOnFrame);
-        return compressedAssets;
-    }));
+        pool.release(freePage);
+    };
+    const renderFrame = (frame, index) => {
+        return new Promise((resolve, reject) => {
+            renderFrameWithOptionToReject({
+                frame,
+                index,
+                reject,
+                width: composition.width,
+                height: composition.height,
+            })
+                .then(() => {
+                resolve();
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+    };
+    const renderFrameAndRetryTargetClose = async ({ frame, index, retriesLeft, attempt, }) => {
+        try {
+            await Promise.race([
+                renderFrame(frame, index),
+                new Promise((_, reject) => {
+                    cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+                        reject(new Error(make_cancel_signal_1.cancelErrorMessages.renderFrames));
+                    });
+                }),
+            ]);
+        }
+        catch (err) {
+            if ((0, make_cancel_signal_1.isUserCancelledRender)(err)) {
+                throw err;
+            }
+            if (!(0, is_target_closed_err_1.isTargetClosedErr)(err)) {
+                throw err;
+            }
+            if (stopped) {
+                return;
+            }
+            if (retriesLeft === 0) {
+                console.warn(`The browser crashed ${attempt} times while rendering frame ${frame}. Not retrying anymore. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
+                throw err;
+            }
+            console.warn(`The browser crashed while rendering frame ${frame}, retrying ${retriesLeft} more times. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
+            await browserReplacer.replaceBrowser(makeBrowser, async () => {
+                const pages = new Array(actualConcurrency)
+                    .fill(true)
+                    .map(() => makePage());
+                const puppeteerPages = await Promise.all(pages);
+                const pool = await poolPromise;
+                for (const newPage of puppeteerPages) {
+                    pool.release(newPage);
+                }
+            });
+            await renderFrameAndRetryTargetClose({
+                frame,
+                index,
+                retriesLeft: retriesLeft - 1,
+                attempt: attempt + 1,
+            });
+        }
+    };
+    const progress = Promise.all(framesToRender.map((frame, index) => renderFrameAndRetryTargetClose({
+        frame,
+        index,
+        retriesLeft: MAX_RETRIES_PER_FRAME,
+        attempt: 1,
+    })));
     const happyPath = progress.then(() => {
+        const firstFrameIndex = countType === 'from-zero' ? 0 : framesToRender[0];
         const returnValue = {
             assetsInfo: {
                 assets,
                 imageSequenceName: `element-%0${filePadLength}d.${imageFormat}`,
-                firstFrameIndex: framesToRender[0],
+                firstFrameIndex,
                 downloadMap,
             },
             frameCount: framesToRender.length,
@@ -218,35 +287,50 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
     })
         .then(() => happyPath);
 };
+/**
+ * @description Renders a series of images using Puppeteer and computes information for mixing audio.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/render-frames)
+ */
 const renderFrames = (options) => {
-    var _a, _b, _c, _d, _e;
-    const composition = getComposition(options);
+    var _a, _b, _c;
+    const { composition, concurrency } = options;
     if (!composition) {
         throw new Error('No `composition` option has been specified for renderFrames()');
     }
     remotion_1.Internals.validateDimension(composition.height, 'height', 'in the `config` object passed to `renderFrames()`');
     remotion_1.Internals.validateDimension(composition.width, 'width', 'in the `config` object passed to `renderFrames()`');
     remotion_1.Internals.validateFps(composition.fps, 'in the `config` object of `renderFrames()`', false);
-    remotion_1.Internals.validateDurationInFrames(composition.durationInFrames, 'in the `config` object passed to `renderFrames()`');
-    if (options.quality !== undefined && options.imageFormat !== 'jpeg') {
-        throw new Error("You can only pass the `quality` option if `imageFormat` is 'jpeg'.");
+    remotion_1.Internals.validateDurationInFrames({
+        durationInFrames: composition.durationInFrames,
+        component: 'in the `config` object passed to `renderFrames()`',
+        allowFloats: false,
+    });
+    if (options.jpegQuality !== undefined && options.imageFormat !== 'jpeg') {
+        throw new Error("You can only pass the `jpegQuality` option if `imageFormat` is 'jpeg'.");
     }
-    const selectedServeUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
-    (0, quality_1.validateQuality)(options.quality);
+    (0, jpeg_quality_1.validateJpegQuality)(options.jpegQuality);
     (0, validate_scale_1.validateScale)(options.scale);
-    const browserInstance = (_a = options.puppeteerInstance) !== null && _a !== void 0 ? _a : (0, open_browser_1.openBrowser)(browser_1.DEFAULT_BROWSER, {
-        shouldDumpIo: options.dumpBrowserLogs,
-        browserExecutable: options.browserExecutable,
-        chromiumOptions: options.chromiumOptions,
-        forceDeviceScaleFactor: (_b = options.scale) !== null && _b !== void 0 ? _b : 1,
-    });
-    const downloadMap = (_c = options.downloadMap) !== null && _c !== void 0 ? _c : (0, download_map_1.makeDownloadMap)();
-    const onDownload = (_d = options.onDownload) !== null && _d !== void 0 ? _d : (() => () => undefined);
-    const actualParallelism = (0, get_concurrency_1.getActualConcurrency)((_e = options.parallelism) !== null && _e !== void 0 ? _e : null);
+    const makeBrowser = () => {
+        var _a, _b;
+        return (0, open_browser_1.openBrowser)(browser_1.DEFAULT_BROWSER, {
+            shouldDumpIo: options.dumpBrowserLogs,
+            browserExecutable: options.browserExecutable,
+            chromiumOptions: options.chromiumOptions,
+            forceDeviceScaleFactor: (_a = options.scale) !== null && _a !== void 0 ? _a : 1,
+            indent: (_b = options.indent) !== null && _b !== void 0 ? _b : false,
+        });
+    };
+    const browserInstance = (_a = options.puppeteerInstance) !== null && _a !== void 0 ? _a : makeBrowser();
+    const downloadMap = (_b = options.downloadMap) !== null && _b !== void 0 ? _b : (0, download_map_1.makeDownloadMap)();
+    const onDownload = (_c = options.onDownload) !== null && _c !== void 0 ? _c : (() => () => undefined);
+    const actualConcurrency = (0, get_concurrency_1.getActualConcurrency)(concurrency !== null && concurrency !== void 0 ? concurrency : null);
     const openedPages = [];
     return new Promise((resolve, reject) => {
         var _a, _b, _c;
         const cleanup = [];
+        if (!options.downloadMap) {
+            cleanup.push(() => (0, download_map_1.cleanDownloadMap)(downloadMap));
+        }
         const onError = (err) => {
             reject(err);
         };
@@ -254,24 +338,27 @@ const renderFrames = (options) => {
             new Promise((_, rej) => {
                 var _a;
                 (_a = options.cancelSignal) === null || _a === void 0 ? void 0 : _a.call(options, () => {
-                    rej(new Error('renderFrames() got cancelled'));
+                    rej(new Error(make_cancel_signal_1.cancelErrorMessages.renderFrames));
                 });
             }),
             Promise.all([
                 (0, prepare_server_1.prepareServer)({
-                    webpackConfigOrServeUrl: selectedServeUrl,
+                    webpackConfigOrServeUrl: options.serveUrl,
                     onDownload,
                     onError,
-                    ffmpegExecutable: (_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
-                    ffprobeExecutable: (_b = options.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
-                    port: (_c = options.port) !== null && _c !== void 0 ? _c : null,
+                    port: (_a = options.port) !== null && _a !== void 0 ? _a : null,
                     downloadMap,
+                    remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+                    concurrency: actualConcurrency,
+                    verbose: (_b = options.verbose) !== null && _b !== void 0 ? _b : false,
+                    indent: (_c = options.indent) !== null && _c !== void 0 ? _c : false,
                 }),
                 browserInstance,
-            ]).then(([{ serveUrl, closeServer, offthreadPort }, puppeteerInstance]) => {
-                const { stopCycling } = (0, cycle_browser_tabs_1.cycleBrowserTabs)(puppeteerInstance, actualParallelism);
+            ]).then(([{ serveUrl, closeServer, offthreadPort, compositor }, puppeteerInstance,]) => {
+                const browserReplacer = (0, replace_browser_1.handleBrowserCrash)(puppeteerInstance);
+                const { stopCycling } = (0, cycle_browser_tabs_1.cycleBrowserTabs)(browserReplacer, actualConcurrency);
                 cleanup.push(stopCycling);
-                cleanup.push(closeServer);
+                cleanup.push(() => closeServer(false));
                 return innerRenderFrames({
                     ...options,
                     puppeteerInstance,
@@ -279,10 +366,13 @@ const renderFrames = (options) => {
                     pagesArray: openedPages,
                     serveUrl,
                     composition,
-                    actualParallelism,
+                    actualConcurrency,
                     onDownload,
                     proxyPort: offthreadPort,
                     downloadMap,
+                    makeBrowser,
+                    browserReplacer,
+                    compositor,
                 });
             }),
         ])
@@ -296,16 +386,21 @@ const renderFrames = (options) => {
             // If new browser was opened, then closing the browser as a cleanup.
             if (options.puppeteerInstance) {
                 Promise.all(openedPages.map((p) => p.close())).catch((err) => {
+                    if ((0, is_target_closed_err_1.isTargetClosedErr)(err)) {
+                        return;
+                    }
                     console.log('Unable to close browser tab', err);
                 });
             }
             else {
                 Promise.resolve(browserInstance)
                     .then((puppeteerInstance) => {
-                    return puppeteerInstance.close();
+                    return puppeteerInstance.close(true);
                 })
                     .catch((err) => {
-                    console.log('Unable to close browser', err);
+                    if (!(err === null || err === void 0 ? void 0 : err.message.includes('Target closed'))) {
+                        console.log('Unable to close browser', err);
+                    }
                 });
             }
             cleanup.forEach((c) => {

package/dist/render-media.d.ts

@@ -1,43 +1,51 @@
-import type { SmallTCompMetadata } from 'remotion';
+/// <reference types="node" />
+import type { AnySmallCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
+import type { AudioCodec } from './audio-codec';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
-import type { Browser as PuppeteerBrowser } from './browser/Browser';
+import type { HeadlessBrowser } from './browser/Browser';
 import type { Codec } from './codec';
-import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { FfmpegOverrideFn } from './ffmpeg-override';
 import type { FrameRange } from './frame-range';
-import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
+import type { VideoImageFormat } from './image-format';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
 import type { PixelFormat } from './pixel-format';
 import type { ProResProfile } from './prores-profile';
 import type { OnStartData } from './types';
 export declare type StitchingState = 'encoding' | 'muxing';
+export declare type SlowFrame = {
+    frame: number;
+    time: number;
+};
 export declare type RenderMediaOnProgress = (progress: {
     renderedFrames: number;
     encodedFrames: number;
     encodedDoneIn: number | null;
     renderedDoneIn: number | null;
+    progress: number;
     stitchStage: StitchingState;
 }) => void;
 export declare type RenderMediaOptions = {
     outputLocation?: string | null;
     codec: Codec;
-    composition: SmallTCompMetadata;
-    inputProps?: unknown;
-    parallelism?: number | null;
+    composition: AnySmallCompMetadata;
+    inputProps?: Record<string, unknown>;
     crf?: number | null;
-    imageFormat?: 'png' | 'jpeg' | 'none';
-    ffmpegExecutable?: FfmpegExecutable;
-    ffprobeExecutable?: FfmpegExecutable;
+    imageFormat?: VideoImageFormat;
     pixelFormat?: PixelFormat;
     envVariables?: Record<string, string>;
-    quality?: number;
+    /**
+     * @deprecated Renamed to `jpegQuality`
+     */
+    quality?: never;
+    jpegQuality?: number;
     frameRange?: FrameRange | null;
     everyNthFrame?: number;
     numberOfGifLoops?: number | null;
-    puppeteerInstance?: PuppeteerBrowser;
+    puppeteerInstance?: HeadlessBrowser;
     overwrite?: boolean;
     onProgress?: RenderMediaOnProgress;
     onDownload?: RenderMediaOnDownload;
@@ -52,14 +60,39 @@ export declare type RenderMediaOptions = {
     cancelSignal?: CancelSignal;
     browserExecutable?: BrowserExecutable;
     verbose?: boolean;
-    /**
-     * @deprecated Only for Remotion internal usage
-     */
-    downloadMap?: DownloadMap;
-} & ServeUrlOrWebpackBundle;
+    internal?: {
+        /**
+         * @deprecated Only for Remotion internal usage
+         */
+        downloadMap?: DownloadMap;
+        /**
+         * @deprecated Only for Remotion internal usage
+         */
+        onCtrlCExit?: (fn: () => void) => void;
+        /**
+         * @deprecated Only for Remotion internal usage
+         */
+        indent?: boolean;
+    };
+    preferLossless?: boolean;
+    muted?: boolean;
+    enforceAudioTrack?: boolean;
+    ffmpegOverride?: FfmpegOverrideFn;
+    audioBitrate?: string | null;
+    videoBitrate?: string | null;
+    disallowParallelEncoding?: boolean;
+    audioCodec?: AudioCodec | null;
+    serveUrl: string;
+    concurrency?: number | string | null;
+};
+declare type RenderMediaResult = {
+    buffer: Buffer | null;
+    slowestFrames: SlowFrame[];
+};
 /**
  *
  * @description Render a video from a composition
- * @link https://www.remotion.dev/docs/renderer/render-media
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/render-media)
  */
-export declare const renderMedia: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<Buffer | null>;
+export declare const renderMedia: ({ proResProfile, crf, composition, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, ...options }: RenderMediaOptions) => Promise<RenderMediaResult>;
+export {};