@remotion/renderer 4.0.0-alpha13 → 4.0.0-alpha14

package/dist/get-compositions.d.ts

@@ -1,10 +1,24 @@
 import type { AnyCompMetadata } from 'remotion';
-import type { DownloadMap } from './assets/download-map';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
 import type { HeadlessBrowser } from './browser/Browser';
 import type { ChromiumOptions } from './open-browser';
-declare type GetCompositionsConfig = {
+import type { RemotionServer } from './prepare-server';
+type InternalGetCompositionsOptions = {
+    inputProps: Record<string, unknown>;
+    envVariables: Record<string, string>;
+    puppeteerInstance: HeadlessBrowser | undefined;
+    onBrowserLog: null | ((log: BrowserLog) => void);
+    browserExecutable: BrowserExecutable | null;
+    timeoutInMilliseconds: number;
+    chromiumOptions: ChromiumOptions;
+    port: number | null;
+    server: RemotionServer | undefined;
+    indent: boolean;
+    verbose: boolean;
+    serveUrlOrWebpackUrl: string;
+};
+export type GetCompositionsOptions = {
     inputProps?: Record<string, unknown> | null;
     envVariables?: Record<string, string>;
     puppeteerInstance?: HeadlessBrowser;
@@ -13,19 +27,12 @@ declare type GetCompositionsConfig = {
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
     port?: number | null;
-    /**
-     * @deprecated Only for Remotion internal usage
-     */
-    downloadMap?: DownloadMap;
-    /**
-     * @deprecated Only for Remotion internal usage
-     */
-    indent?: boolean;
     verbose?: boolean;
 };
+export declare const internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }: InternalGetCompositionsOptions) => Promise<AnyCompMetadata[]>;
 /**
  * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
  */
-export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<AnyCompMetadata[]>;
+export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsOptions) => Promise<AnyCompMetadata[]>;
 export {};

package/dist/get-compositions.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCompositions = void 0;
-const download_map_1 = require("./assets/download-map");
+exports.getCompositions = exports.internalGetCompositions = void 0;
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
 const find_closest_package_json_1 = require("./find-closest-package-json");
 const get_browser_instance_1 = require("./get-browser-instance");
@@ -10,26 +10,24 @@ const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
-const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
-    var _a;
-    if (config === null || config === void 0 ? void 0 : config.onBrowserLog) {
+const innerGetCompositions = async ({ envVariables, inputProps, onBrowserLog, page, proxyPort, serveUrl, timeoutInMilliseconds, }) => {
+    if (onBrowserLog) {
         page.on('console', (log) => {
-            var _a;
-            (_a = config.onBrowserLog) === null || _a === void 0 ? void 0 : _a.call(config, {
+            onBrowserLog({
                 stackTrace: log.stackTrace(),
                 text: log.text,
                 type: log.type,
             });
         });
     }
-    (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds);
+    (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
     await (0, set_props_and_env_1.setPropsAndEnv)({
-        inputProps: (_a = config === null || config === void 0 ? void 0 : config.inputProps) !== null && _a !== void 0 ? _a : {},
-        envVariables: config === null || config === void 0 ? void 0 : config.envVariables,
+        inputProps,
+        envVariables,
         page,
         serveUrl,
         initialFrame: 0,
-        timeoutInMilliseconds: config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds,
+        timeoutInMilliseconds,
         proxyPort,
         retriesRemaining: 2,
         audioEnabled: false,
@@ -38,7 +36,7 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         page,
         pageFunction: () => {
-            window.setBundleMode({
+            window.remotion_setBundleMode({
                 type: 'evaluation',
             });
         },
@@ -56,62 +54,81 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     });
     return result;
 };
-/**
- * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
- * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
- */
-const getCompositions = async (serveUrlOrWebpackUrl, config) => {
-    var _a, _b, _c;
-    const downloadMap = (_a = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _a !== void 0 ? _a : (0, download_map_1.makeDownloadMap)();
-    const { page, cleanup } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
-        passedInInstance: config === null || config === void 0 ? void 0 : config.puppeteerInstance,
-        browserExecutable: (_b = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _b !== void 0 ? _b : null,
-        chromiumOptions: (_c = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _c !== void 0 ? _c : {},
+const internalGetCompositions = async ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }) => {
+    const { page, cleanup: cleanupPage } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
+        passedInInstance: puppeteerInstance,
+        browserExecutable,
+        chromiumOptions,
+        context: null,
+        forceDeviceScaleFactor: undefined,
+        indent,
+        shouldDumpIo: verbose,
     });
+    const cleanup = [cleanupPage];
     return new Promise((resolve, reject) => {
-        var _a, _b, _c;
         const onError = (err) => reject(err);
-        const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
+        cleanup.push((0, handle_javascript_exception_1.handleJavascriptException)({
             page,
             frame: null,
             onError,
-        });
-        let close = null;
-        (0, prepare_server_1.prepareServer)({
+        }));
+        (0, prepare_server_1.makeOrReuseServer)(server, {
             webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
-            onDownload: () => undefined,
-            onError,
-            port: (_a = config === null || config === void 0 ? void 0 : config.port) !== null && _a !== void 0 ? _a : null,
-            downloadMap,
+            port,
             remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
             concurrency: 1,
-            verbose: (_b = config === null || config === void 0 ? void 0 : config.verbose) !== null && _b !== void 0 ? _b : false,
-            indent: (_c = config === null || config === void 0 ? void 0 : config.indent) !== null && _c !== void 0 ? _c : false,
+            verbose,
+            indent,
+        }, {
+            onDownload: () => undefined,
+            onError,
         })
-            .then(({ serveUrl, closeServer, offthreadPort }) => {
-            close = closeServer;
-            return innerGetCompositions(serveUrl, page, config !== null && config !== void 0 ? config : {}, offthreadPort);
+            .then(({ server: { serveUrl, offthreadPort, sourceMap }, cleanupServer }) => {
+            page.setBrowserSourceMapContext(sourceMap);
+            cleanup.push(() => cleanupServer(true));
+            return innerGetCompositions({
+                envVariables,
+                inputProps,
+                onBrowserLog,
+                page,
+                proxyPort: offthreadPort,
+                serveUrl,
+                timeoutInMilliseconds,
+            });
         })
             .then((comp) => {
-            if (close) {
-                return Promise.all([comp, close(true)]);
-            }
-            return Promise.resolve([comp, null]);
-        })
-            .then(([comp]) => {
             return resolve(comp);
         })
             .catch((err) => {
             reject(err);
         })
             .finally(() => {
-            cleanup();
-            cleanupPageError();
-            // Clean download map if it was not passed in
-            if (!(config === null || config === void 0 ? void 0 : config.downloadMap)) {
-                (0, download_map_1.cleanDownloadMap)(downloadMap);
-            }
+            cleanup.forEach((c) => {
+                c();
+            });
         });
     });
 };
+exports.internalGetCompositions = internalGetCompositions;
+/**
+ * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
+ */
+const getCompositions = (serveUrlOrWebpackUrl, config) => {
+    const { browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, verbose, } = config !== null && config !== void 0 ? config : {};
+    return (0, exports.internalGetCompositions)({
+        browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
+        chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
+        envVariables: envVariables !== null && envVariables !== void 0 ? envVariables : {},
+        inputProps: inputProps !== null && inputProps !== void 0 ? inputProps : {},
+        indent: false,
+        onBrowserLog: onBrowserLog !== null && onBrowserLog !== void 0 ? onBrowserLog : null,
+        port: port !== null && port !== void 0 ? port : null,
+        puppeteerInstance: puppeteerInstance !== null && puppeteerInstance !== void 0 ? puppeteerInstance : undefined,
+        serveUrlOrWebpackUrl,
+        server: undefined,
+        timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
+        verbose: verbose !== null && verbose !== void 0 ? verbose : false,
+    });
+};
 exports.getCompositions = getCompositions;

package/dist/get-frame-of-video-slow.d.ts

@@ -0,0 +1,17 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const getFrameOfVideoSlow: ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    src: string;
+    duration: number;
+    imageFormat: OffthreadVideoImageFormat;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    needsResize: [
+        number,
+        number
+    ] | null;
+    offset: number;
+    fps: number | null;
+    remotionRoot: string;
+}) => Promise<Buffer>;

package/dist/get-frame-of-video-slow.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFrameOfVideoSlow = void 0;
+// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
+// if the video is corrupted
+const execa_1 = __importDefault(require("execa"));
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const truthy_1 = require("./truthy");
+const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${duration * 1000 - offset}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
+        '-',
+    ].filter(truthy_1.truthy);
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), command);
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => stdoutChunks.push(d));
+        stdout.on('error', (err) => reject(err));
+        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        if (offset > 70) {
+            throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
+        }
+        return (0, exports.getFrameOfVideoSlow)({
+            ffmpegExecutable,
+            duration,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + (fps === null ? 10 : 1000 / fps),
+            src,
+            imageFormat,
+            specialVCodecForTransparency,
+            needsResize,
+            fps,
+            remotionRoot,
+        });
+    }
+    return stdoutBuffer;
+};
+exports.getFrameOfVideoSlow = getFrameOfVideoSlow;

package/dist/get-frame-padded-index.d.ts

@@ -1,5 +1,5 @@
 import type { VideoImageFormat } from './image-format';
-export declare type CountType = 'from-zero' | 'actual-frames';
+export type CountType = 'from-zero' | 'actual-frames';
 export declare const getFrameOutputFileName: ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }: {
     index: number;
     frame: number;

package/dist/get-video-info.d.ts

@@ -0,0 +1,8 @@
+import type { DownloadMap, Vp9Result } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<Vp9Result>;
+export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<Vp9Result>;

package/dist/get-video-info.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoInfo = exports.getVideoInfoUncached = void 0;
+const execa_1 = __importDefault(require("execa"));
+const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const p_limit_1 = require("./p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+async function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }) {
+    var _a;
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), [src]);
+    const isVp9 = task.stderr.includes('Video: vp9');
+    const isVp8 = task.stderr.includes('Video: vp8');
+    const dimensions = (_a = task.stderr
+        .split('\n')
+        .find((n) => n.trim().startsWith('Stream #'))) === null || _a === void 0 ? void 0 : _a.match(/([0-9]{2,6})x([0-9]{2,6})/);
+    const dar = task.stderr.match(/DAR\s([0-9]+):([0-9]+)/);
+    let needsResize = null;
+    if (dimensions && dar) {
+        const width = parseInt(dimensions[1], 10);
+        const height = parseInt(dimensions[2], 10);
+        const darWidth = parseInt(dar[1], 10);
+        const darHeight = parseInt(dar[2], 10);
+        const { width: actualWidth, height: actualHeight } = (0, calculate_sar_dar_pixels_1.calculateDisplayVideoSize)({
+            darX: darWidth,
+            darY: darHeight,
+            x: width,
+            y: height,
+        });
+        if (actualWidth !== width || actualHeight !== height) {
+            needsResize = [actualWidth, actualHeight];
+        }
+    }
+    const result = {
+        specialVcodecForTransparency: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
+        needsResize,
+    };
+    return result;
+}
+exports.getVideoInfoUncached = getVideoInfoUncached;
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
+        return downloadMap.isVp9VideoCache[src];
+    }
+    const result = await getVideoInfoUncached({
+        ffprobeExecutable,
+        remotionRoot,
+        src,
+    });
+    downloadMap.isVp9VideoCache[src] = result;
+    return downloadMap.isVp9VideoCache[src];
+}
+const getVideoInfo = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoInfo = getVideoInfo;

package/dist/image-format.d.ts

@@ -1,12 +1,12 @@
 import type { PixelFormat } from './pixel-format';
 export declare const validVideoImageFormats: readonly ["png", "jpeg", "none"];
 export declare const validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
-export declare type VideoImageFormat = typeof validVideoImageFormats[number];
-export declare type StillImageFormat = typeof validStillImageFormats[number];
+export type VideoImageFormat = typeof validVideoImageFormats[number];
+export type StillImageFormat = typeof validStillImageFormats[number];
 /**
  * @deprecated Use VideoImageFormat or StillImageFormat instead
  */
-export declare type ImageFormat = 'This type is deprecated, use VideoImageFormat or StillImageFormat instead';
+export type ImageFormat = 'This type is deprecated, use VideoImageFormat or StillImageFormat instead';
 export declare const DEFAULT_VIDEO_IMAGE_FORMAT: VideoImageFormat;
 export declare const DEFAULT_STILL_IMAGE_FORMAT: StillImageFormat;
 export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat | undefined, videoImageFormat: VideoImageFormat) => 'none' | 'valid';

package/dist/index.d.ts

@@ -1,11 +1,9 @@
-/// <reference types="node" />
 import execa from 'execa';
 import { HeadlessBrowser } from './browser/Browser';
 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';
@@ -17,7 +15,7 @@ export { ErrorWithStackFrame } from './error-handling/handle-javascript-exceptio
 export type { FfmpegOverrideFn } from './ffmpeg-override';
 export { FileExtension } from './file-extensions';
 export { FrameRange } from './frame-range';
-export { getCompositions } from './get-compositions';
+export { getCompositions, GetCompositionsOptions } from './get-compositions';
 export { ImageFormat, StillImageFormat, validateSelectedPixelFormatAndImageFormatCombination, VideoImageFormat, } from './image-format';
 export type { LogLevel } from './log-level';
 export { CancelSignal, makeCancelSignal } from './make-cancel-signal';
@@ -25,12 +23,13 @@ export { openBrowser } from './open-browser';
 export type { ChromiumOptions } from './open-browser';
 export { RemotionOption } from './options/option';
 export { PixelFormat } from './pixel-format';
+export { RemotionServer } from './prepare-server';
 export { ProResProfile } from './prores-profile';
-export { renderFrames } from './render-frames';
-export { renderMedia, RenderMediaOnProgress, RenderMediaOptions, SlowFrame, StitchingState, } from './render-media';
+export { renderFrames, RenderFramesOptions } from './render-frames';
+export { InternalRenderMediaOptions, renderMedia, RenderMediaOnProgress, RenderMediaOptions, SlowFrame, StitchingState, } from './render-media';
 export { renderStill, RenderStillOptions } from './render-still';
-export { selectComposition } from './select-composition';
-export { StitcherOptions, stitchFramesToVideo } from './stitch-frames-to-video';
+export { selectComposition, SelectCompositionOptions, } from './select-composition';
+export { stitchFramesToVideo, StitchFramesToVideoOptions, } from './stitch-frames-to-video';
 export { SymbolicatedStackFrame } from './symbolicate-stacktrace';
 export { OnStartData, RenderFramesOutput } from './types';
 export { OpenGlRenderer } from './validate-opengl-renderer';
@@ -40,8 +39,6 @@ export declare const RenderInternals: {
     getActualConcurrency: (userPreference: string | number | null) => number;
     serveStatic: (path: string | null, options: {
         port: number | null;
-        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload;
-        onError: (err: Error) => void;
         downloadMap: import("./assets/download-map").DownloadMap;
         remotionRoot: string;
         concurrency: number;
@@ -51,6 +48,7 @@ export declare const RenderInternals: {
         port: number;
         close: () => Promise<void>;
         compositor: import("./compositor/compositor").Compositor;
+        events: import("./offthread-video-server").OffthreadVideoServerEmitter;
     }>;
     validateEvenDimensionsWithCodec: ({ width, height, codec, scale, }: {
         width: number;
@@ -115,8 +113,8 @@ export declare const RenderInternals: {
     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: "angle" | "swangle" | "egl" | "swiftshader" | null;
-    validateOpenGlRenderer: (option: "angle" | "swangle" | "egl" | "swiftshader" | null) => "angle" | "swangle" | "egl" | "swiftshader" | null;
+    DEFAULT_OPENGL_RENDERER: "swangle" | "angle" | "egl" | "swiftshader" | null;
+    validateOpenGlRenderer: (option: "swangle" | "angle" | "egl" | "swiftshader" | null) => "swangle" | "angle" | "egl" | "swiftshader" | null;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
     validateJpegQuality: (q: number | undefined) => void;
@@ -124,11 +122,9 @@ export declare const RenderInternals: {
     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: "error" | "verbose" | "info" | "warn", level: "error" | "verbose" | "info" | "warn") => boolean;
+    isEqualOrBelowLogLevel: (currentLevel: "verbose" | "error" | "info" | "warn", level: "verbose" | "error" | "info" | "warn") => boolean;
     isValidLogLevel: (level: string) => boolean;
     perf: typeof perf;
-    makeDownloadMap: () => import("./assets/download-map").DownloadMap;
-    cleanDownloadMap: (downloadMap: import("./assets/download-map").DownloadMap) => void;
     convertToPositiveFrameIndex: ({ frame, durationInFrames, }: {
         frame: number;
         durationInFrames: number;
@@ -303,8 +299,9 @@ export declare const RenderInternals: {
     };
     validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
     validVideoImageFormats: readonly ["png", "jpeg", "none"];
-    DEFAULT_STILL_IMAGE_FORMAT: "jpeg" | "png" | "webp" | "pdf";
-    DEFAULT_VIDEO_IMAGE_FORMAT: "jpeg" | "png" | "none";
+    DEFAULT_STILL_IMAGE_FORMAT: "png" | "jpeg" | "pdf" | "webp";
+    DEFAULT_VIDEO_IMAGE_FORMAT: "png" | "jpeg" | "none";
+    DEFAULT_JPEG_QUALITY: number;
     chalk: {
         enabled: boolean;
         visible: boolean;
@@ -358,25 +355,117 @@ export declare const RenderInternals: {
         verbose: (message?: any, ...optionalParams: any[]) => void;
         verboseAdvanced: (options: {
             indent: boolean;
-            logLevel: "error" | "verbose" | "info" | "warn";
+            logLevel: "verbose" | "error" | "info" | "warn";
         } & {
             tag?: string | undefined;
+            secondTag?: string | undefined;
         }, message?: any, ...optionalParams: any[]) => void;
         info: (message?: any, ...optionalParams: any[]) => void;
         infoAdvanced: (options: {
             indent: boolean;
-            logLevel: "error" | "verbose" | "info" | "warn";
+            logLevel: "verbose" | "error" | "info" | "warn";
         }, message?: any, ...optionalParams: any[]) => void;
         warn: (message?: any, ...optionalParams: any[]) => void;
         warnAdvanced: (options: {
             indent: boolean;
-            logLevel: "error" | "verbose" | "info" | "warn";
+            logLevel: "verbose" | "error" | "info" | "warn";
         }, message?: any, ...optionalParams: any[]) => void;
         error: (message?: any, ...optionalParams: any[]) => void;
     };
-    getLogLevel: () => "error" | "verbose" | "info" | "warn";
-    setLogLevel: (newLogLevel: "error" | "verbose" | "info" | "warn") => void;
+    getLogLevel: () => "verbose" | "error" | "info" | "warn";
+    setLogLevel: (newLogLevel: "verbose" | "error" | "info" | "warn") => void;
     INDENT_TOKEN: string;
     isColorSupported: boolean;
     HeadlessBrowser: typeof HeadlessBrowser;
+    prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }: {
+        webpackConfigOrServeUrl: string;
+        port: number | null;
+        remotionRoot: string;
+        concurrency: number;
+        verbose: boolean;
+        indent: boolean;
+    }) => Promise<import("./prepare-server").RemotionServer>;
+    makeOrReuseServer: (server: import("./prepare-server").RemotionServer | undefined, config: {
+        webpackConfigOrServeUrl: string;
+        port: number | null;
+        remotionRoot: string;
+        concurrency: number;
+        verbose: boolean;
+        indent: boolean;
+    }, { onDownload, onError, }: {
+        onError: (err: Error) => void;
+        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload | null;
+    }) => Promise<{
+        server: import("./prepare-server").RemotionServer;
+        cleanupServer: (force: boolean) => Promise<unknown>;
+    }>;
+    internalRenderStill: (options: {
+        composition: import("remotion").AnySmallCompMetadata;
+        output: string | null;
+        frame: number;
+        inputProps: Record<string, unknown>;
+        imageFormat: "png" | "jpeg" | "pdf" | "webp";
+        jpegQuality: number;
+        puppeteerInstance: HeadlessBrowser | null;
+        dumpBrowserLogs: boolean;
+        envVariables: Record<string, string>;
+        overwrite: boolean;
+        browserExecutable: import("./browser-executable").BrowserExecutable;
+        onBrowserLog: ((log: import("./browser-log").BrowserLog) => void) | null;
+        timeoutInMilliseconds: number;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        scale: number;
+        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload | null;
+        cancelSignal: import("./make-cancel-signal").CancelSignal | null;
+        indent: boolean;
+        server: import("./prepare-server").RemotionServer | undefined;
+        verbose: boolean;
+        serveUrl: string;
+        port: number | null;
+    }) => Promise<{
+        buffer: Buffer | null;
+    }>;
+    internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, shouldDumpIo, viewport, }: {
+        shouldDumpIo: boolean;
+        browserExecutable: string | null;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        forceDeviceScaleFactor: number | undefined;
+        viewport: import("./browser/PuppeteerViewport").Viewport | null;
+        indent: boolean;
+        browser: import("./browser").Browser;
+    }) => Promise<HeadlessBrowser>;
+    internalSelectComposition: (options: {
+        inputProps: Record<string, unknown>;
+        envVariables: Record<string, string>;
+        puppeteerInstance: HeadlessBrowser | undefined;
+        onBrowserLog: ((log: import("./browser-log").BrowserLog) => void) | null;
+        browserExecutable: import("./browser-executable").BrowserExecutable;
+        timeoutInMilliseconds: number;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        port: number | null;
+        indent: boolean;
+        server: import("./prepare-server").RemotionServer | undefined;
+        verbose: boolean;
+        serveUrl: string;
+        id: string;
+    }) => Promise<import("remotion").AnyCompMetadata>;
+    internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }: {
+        inputProps: Record<string, unknown>;
+        envVariables: Record<string, string>;
+        puppeteerInstance: HeadlessBrowser | undefined;
+        onBrowserLog: ((log: import("./browser-log").BrowserLog) => void) | null;
+        browserExecutable: import("./browser-executable").BrowserExecutable;
+        timeoutInMilliseconds: number;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        port: number | null;
+        server: import("./prepare-server").RemotionServer | undefined;
+        indent: boolean;
+        verbose: boolean;
+        serveUrlOrWebpackUrl: string;
+    }) => Promise<import("remotion").AnyCompMetadata[]>;
+    internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, dumpBrowserLogs, envVariables, everyNthFrame, frameRange, imageFormat, indent, inputProps, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, verbose, webpackBundleOrServeUrl, }: import("./render-frames").InternalRenderFramesOptions) => Promise<import("./types").RenderFramesOutput>;
+    internalRenderMedia: ({ 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, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, verbose, }: import("./render-media").InternalRenderMediaOptions) => Promise<{
+        buffer: Buffer | null;
+        slowestFrames: import("./render-media").SlowFrame[];
+    }>;
 };