@remotion/renderer 4.1.0-alpha2 → 4.1.0-alpha4

package/dist/index.d.ts

@@ -43,7 +43,7 @@ export declare const RenderInternals: {
         downloadMap: import("./assets/download-map").DownloadMap;
         remotionRoot: string;
         concurrency: number;
-        verbose: boolean;
+        logLevel: "verbose" | "info" | "warn" | "error";
         indent: boolean;
     }) => Promise<{
         port: number;
@@ -114,8 +114,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;
@@ -123,7 +123,7 @@ 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" | "info" | "warn" | "error", level: "verbose" | "info" | "warn" | "error") => boolean;
     isValidLogLevel: (level: string) => boolean;
     perf: typeof perf;
     convertToPositiveFrameIndex: ({ frame, durationInFrames, }: {
@@ -300,8 +300,8 @@ 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: "none" | "png" | "jpeg";
     DEFAULT_JPEG_QUALITY: number;
     chalk: {
         enabled: boolean;
@@ -356,34 +356,33 @@ export declare const RenderInternals: {
         verbose: (message?: any, ...optionalParams: any[]) => void;
         verboseAdvanced: (options: {
             indent: boolean;
-            logLevel: "error" | "verbose" | "info" | "warn";
+            logLevel: "verbose" | "info" | "warn" | "error";
         } & {
             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" | "info" | "warn" | "error";
         }, message?: any, ...optionalParams: any[]) => void;
         warn: (message?: any, ...optionalParams: any[]) => void;
         warnAdvanced: (options: {
             indent: boolean;
-            logLevel: "error" | "verbose" | "info" | "warn";
+            logLevel: "verbose" | "info" | "warn" | "error";
         }, 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" | "info" | "warn" | "error";
+    setLogLevel: (newLogLevel: "verbose" | "info" | "warn" | "error") => void;
     INDENT_TOKEN: string;
     isColorSupported: boolean;
     HeadlessBrowser: typeof HeadlessBrowser;
-    prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }: {
+    prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, }: {
         webpackConfigOrServeUrl: string;
         port: number | null;
         remotionRoot: string;
         concurrency: number;
-        verbose: boolean;
+        logLevel: "verbose" | "info" | "warn" | "error";
         indent: boolean;
     }) => Promise<import("./prepare-server").RemotionServer>;
     makeOrReuseServer: (server: import("./prepare-server").RemotionServer | undefined, config: {
@@ -391,7 +390,7 @@ export declare const RenderInternals: {
         port: number | null;
         remotionRoot: string;
         concurrency: number;
-        verbose: boolean;
+        logLevel: "verbose" | "info" | "warn" | "error";
         indent: boolean;
     }, { onDownload, onError, }: {
         onError: (err: Error) => void;
@@ -405,10 +404,9 @@ export declare const RenderInternals: {
         output: string | null;
         frame: number;
         inputProps: Record<string, unknown>;
-        imageFormat: "jpeg" | "png" | "webp" | "pdf";
+        imageFormat: "png" | "jpeg" | "pdf" | "webp";
         jpegQuality: number;
         puppeteerInstance: HeadlessBrowser | null;
-        dumpBrowserLogs: boolean;
         envVariables: Record<string, string>;
         overwrite: boolean;
         browserExecutable: import("./browser-executable").BrowserExecutable;
@@ -420,20 +418,20 @@ export declare const RenderInternals: {
         cancelSignal: import("./make-cancel-signal").CancelSignal | null;
         indent: boolean;
         server: import("./prepare-server").RemotionServer | undefined;
-        verbose: boolean;
+        logLevel: "verbose" | "info" | "warn" | "error";
         serveUrl: string;
         port: number | null;
     }) => Promise<{
         buffer: Buffer | null;
     }>;
-    internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, shouldDumpIo, viewport, }: {
-        shouldDumpIo: boolean;
+    internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, }: {
         browserExecutable: string | null;
         chromiumOptions: import("./open-browser").ChromiumOptions;
         forceDeviceScaleFactor: number | undefined;
         viewport: import("./browser/PuppeteerViewport").Viewport | null;
         indent: boolean;
         browser: import("./browser").Browser;
+        logLevel: "verbose" | "info" | "warn" | "error";
     }) => Promise<HeadlessBrowser>;
     internalSelectComposition: (options: {
         inputProps: Record<string, unknown>;
@@ -446,11 +444,11 @@ export declare const RenderInternals: {
         port: number | null;
         indent: boolean;
         server: import("./prepare-server").RemotionServer | undefined;
-        verbose: boolean;
+        logLevel: "verbose" | "info" | "warn" | "error";
         serveUrl: string;
         id: string;
     }) => Promise<import("remotion").AnyCompMetadata>;
-    internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }: {
+    internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, }: {
         inputProps: Record<string, unknown>;
         envVariables: Record<string, string>;
         puppeteerInstance: HeadlessBrowser | undefined;
@@ -461,11 +459,11 @@ export declare const RenderInternals: {
         port: number | null;
         server: import("./prepare-server").RemotionServer | undefined;
         indent: boolean;
-        verbose: boolean;
+        logLevel: "verbose" | "info" | "warn" | "error";
         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<{
+    internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, inputProps, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, }: import("./render-frames").InternalRenderFramesOptions) => Promise<import("./types").RenderFramesOutput>;
+    internalRenderMedia: ({ proResProfile, crf, composition, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, 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, logLevel, }: import("./render-media").InternalRenderMediaOptions) => Promise<{
         buffer: Buffer | null;
         slowestFrames: import("./render-media").SlowFrame[];
     }>;

package/dist/is-beyond-last-frame.d.ts

@@ -0,0 +1,3 @@
+import type { DownloadMap } from './assets/download-map';
+export declare const isBeyondLastFrame: (downloadMap: DownloadMap, src: string, time: number) => boolean | 0;
+export declare const markAsBeyondLastFrame: (downloadMap: DownloadMap, src: string, time: number) => void;

package/dist/is-beyond-last-frame.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markAsBeyondLastFrame = exports.isBeyondLastFrame = void 0;
+const isBeyondLastFrame = (downloadMap, src, time) => {
+    return (downloadMap.isBeyondLastFrameMap[src] &&
+        time >= downloadMap.isBeyondLastFrameMap[src]);
+};
+exports.isBeyondLastFrame = isBeyondLastFrame;
+const markAsBeyondLastFrame = (downloadMap, src, time) => {
+    downloadMap.isBeyondLastFrameMap[src] = time;
+};
+exports.markAsBeyondLastFrame = markAsBeyondLastFrame;

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

@@ -0,0 +1,17 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { DownloadMap, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export type LastFrameOptions = {
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+    offset: number;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    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;
+export declare const clearLastFileCache: (downloadMap: DownloadMap) => void;

package/dist/last-frame-from-video-cache.js

@@ -0,0 +1,55 @@
+"use strict";
+// OffthreadVideo requires sometimes that the last frame of a video gets extracted, however, this can be slow. We allocate a cache for it but that can be garbage collected
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearLastFileCache = exports.getLastFrameFromCache = exports.setLastFrameInCache = void 0;
+const MAX_CACHE_SIZE = 50 * 1024 * 1024; // 50MB
+let bufferSize = 0;
+const makeLastFrameCacheKey = (options) => {
+    return [
+        options.ffmpegExecutable,
+        options.offset,
+        options.src,
+        options.imageFormat,
+        options.downloadMap.id,
+    ].join('-');
+};
+const setLastFrameInCache = (options, data) => {
+    const key = makeLastFrameCacheKey(options);
+    if (options.downloadMap.lastFrameMap[key]) {
+        bufferSize -= options.downloadMap.lastFrameMap[key].data.byteLength;
+    }
+    options.downloadMap.lastFrameMap[key] = { data, lastAccessed: Date.now() };
+    bufferSize += data.byteLength;
+    ensureMaxSize(options.downloadMap);
+};
+exports.setLastFrameInCache = setLastFrameInCache;
+const getLastFrameFromCache = (options) => {
+    var _a;
+    const key = makeLastFrameCacheKey(options);
+    if (!options.downloadMap.lastFrameMap[key]) {
+        return null;
+    }
+    options.downloadMap.lastFrameMap[key].lastAccessed = Date.now();
+    return (_a = options.downloadMap.lastFrameMap[key].data) !== null && _a !== void 0 ? _a : null;
+};
+exports.getLastFrameFromCache = getLastFrameFromCache;
+const removedLastFrameFromCache = (key, downloadMap) => {
+    if (!downloadMap.lastFrameMap[key]) {
+        return;
+    }
+    bufferSize -= downloadMap.lastFrameMap[key].data.byteLength;
+    delete downloadMap.lastFrameMap[key];
+};
+const ensureMaxSize = (downloadMap) => {
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (bufferSize > MAX_CACHE_SIZE) {
+        const earliest = Object.entries(downloadMap.lastFrameMap).sort((a, b) => {
+            return a[1].lastAccessed - b[1].lastAccessed;
+        })[0];
+        removedLastFrameFromCache(earliest[0], downloadMap);
+    }
+};
+const clearLastFileCache = (downloadMap) => {
+    downloadMap.lastFrameMap = {};
+};
+exports.clearLastFileCache = clearLastFileCache;

package/dist/legacy-webpack-config.d.ts

@@ -0,0 +1,9 @@
+export type ServeUrlOrWebpackBundle = {
+    serveUrl: string;
+} | {
+    /**
+     * @deprecated Renamed to `serveUrl`
+     */
+    webpackBundle: string;
+};
+export declare const getServeUrlWithFallback: (serve: ServeUrlOrWebpackBundle) => string;

package/dist/legacy-webpack-config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServeUrlWithFallback = void 0;
+const getServeUrlWithFallback = (serve) => {
+    if ('webpackBundle' in serve) {
+        return serve.webpackBundle;
+    }
+    if ('serveUrl' in serve) {
+        return serve.serveUrl;
+    }
+    throw new Error('You must pass the `serveUrl` parameter');
+};
+exports.getServeUrlWithFallback = getServeUrlWithFallback;

package/dist/logger.d.ts

@@ -6,7 +6,6 @@ type LogOptions = {
 };
 type VerboseLogOptions = LogOptions & {
     tag?: string;
-    secondTag?: string;
 };
 export declare const verboseTag: (str: string) => string;
 export declare const secondverboseTag: (str: string) => string;
@@ -19,6 +18,6 @@ export declare const Log: {
     warnAdvanced: (options: LogOptions, message?: any, ...optionalParams: any[]) => void;
     error: (message?: any, ...optionalParams: any[]) => void;
 };
-export declare const getLogLevel: () => "error" | "verbose" | "info" | "warn";
+export declare const getLogLevel: () => "verbose" | "info" | "warn" | "error";
 export declare const setLogLevel: (newLogLevel: LogLevel) => void;
 export {};

package/dist/logger.js

@@ -22,12 +22,7 @@ exports.Log = {
         if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'verbose')) {
             return console.log(...[
                 options.indent ? exports.INDENT_TOKEN : null,
-                [
-                    options.tag ? (0, exports.verboseTag)(options.tag) : null,
-                    options.secondTag ? (0, exports.secondverboseTag)(options.secondTag) : null,
-                ]
-                    .filter(truthy_1.truthy)
-                    .join(''),
+                options.tag ? (0, exports.verboseTag)(options.tag) : null,
                 ...args.map((a) => chalk_1.chalk.gray(a)),
             ].filter(truthy_1.truthy));
         }
@@ -36,12 +31,12 @@ exports.Log = {
         exports.Log.infoAdvanced({ indent: false, logLevel: (0, exports.getLogLevel)() }, ...args);
     },
     infoAdvanced: (options, ...args) => {
-        if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'info')) {
-            return console.log(...[options.indent ? exports.INDENT_TOKEN : null, ...args].filter(truthy_1.truthy));
-        }
+        return console.log(...[options.indent ? exports.INDENT_TOKEN : null, ...args].filter(truthy_1.truthy));
     },
     warn: (...args) => {
-        exports.Log.warnAdvanced({ indent: false, logLevel: (0, exports.getLogLevel)() }, ...args);
+        if ((0, log_level_1.isEqualOrBelowLogLevel)((0, exports.getLogLevel)(), 'warn')) {
+            exports.Log.warnAdvanced({ indent: false, logLevel: (0, exports.getLogLevel)() }, ...args);
+        }
     },
     warnAdvanced: (options, ...args) => {
         if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'warn')) {

package/dist/offthread-video-server.d.ts

@@ -1,15 +1,16 @@
 import type { RequestListener } from 'node:http';
 import type { DownloadMap } from './assets/download-map';
 import type { Compositor } from './compositor/compositor';
+import type { LogLevel } from './log-level';
 export declare const extractUrlAndSourceFromUrl: (url: string) => {
     src: string;
     time: number;
     transparent: boolean;
 };
-export declare const startOffthreadVideoServer: ({ downloadMap, concurrency, verbose, indent, }: {
+export declare const startOffthreadVideoServer: ({ downloadMap, concurrency, logLevel, indent, }: {
     downloadMap: DownloadMap;
     concurrency: number;
-    verbose: boolean;
+    logLevel: LogLevel;
     indent: boolean;
 }) => {
     listener: RequestListener;

package/dist/offthread-video-server.js

@@ -4,6 +4,7 @@ exports.OffthreadVideoServerEmitter = exports.startOffthreadVideoServer = export
 const node_url_1 = require("node:url");
 const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
 const compositor_1 = require("./compositor/compositor");
+const log_level_1 = require("./log-level");
 const extractUrlAndSourceFromUrl = (url) => {
     const parsed = new URL(url, 'http://localhost');
     const query = parsed.search;
@@ -27,13 +28,13 @@ const extractUrlAndSourceFromUrl = (url) => {
     };
 };
 exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
-const startOffthreadVideoServer = ({ downloadMap, concurrency, verbose, indent, }) => {
+const startOffthreadVideoServer = ({ downloadMap, concurrency, logLevel, indent, }) => {
     const events = new OffthreadVideoServerEmitter();
     const compositor = (0, compositor_1.startCompositor)('StartLongRunningProcess', {
         concurrency,
         maximum_frame_cache_items: (0, compositor_1.getIdealMaximumFrameCacheItems)(),
-        verbose,
-    }, indent);
+        verbose: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
+    }, logLevel, indent);
     return {
         close: () => {
             compositor.finishCommands();

package/dist/open-browser.d.ts

@@ -1,6 +1,7 @@
 import type { Browser } from './browser';
 import type { HeadlessBrowser } from './browser/Browser';
 import type { Viewport } from './browser/PuppeteerViewport';
+import { type LogLevel } from './log-level';
 declare const validRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
 type OpenGlRenderer = typeof validRenderers[number];
 export type ChromiumOptions = {
@@ -12,13 +13,13 @@ export type ChromiumOptions = {
 };
 export declare const killAllBrowsers: () => Promise<void>;
 type InternalOpenBrowserOptions = {
-    shouldDumpIo: boolean;
     browserExecutable: string | null;
     chromiumOptions: ChromiumOptions;
     forceDeviceScaleFactor: number | undefined;
     viewport: Viewport | null;
     indent: boolean;
     browser: Browser;
+    logLevel: LogLevel;
 };
 export type OpenBrowserOptions = {
     shouldDumpIo?: boolean;
@@ -26,7 +27,7 @@ export type OpenBrowserOptions = {
     chromiumOptions?: ChromiumOptions;
     forceDeviceScaleFactor?: number;
 };
-export declare const internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, shouldDumpIo, viewport, }: InternalOpenBrowserOptions) => Promise<HeadlessBrowser>;
+export declare const internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, }: InternalOpenBrowserOptions) => Promise<HeadlessBrowser>;
 /**
  * @description Opens a Chrome or Chromium browser instance.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/open-browser)

package/dist/open-browser.js

@@ -4,6 +4,7 @@ exports.openBrowser = exports.internalOpenBrowser = exports.killAllBrowsers = vo
 const node_1 = require("./browser/node");
 const get_local_browser_executable_1 = require("./get-local-browser-executable");
 const get_video_threads_flag_1 = require("./get-video-threads-flag");
+const log_level_1 = require("./log-level");
 const validate_opengl_renderer_1 = require("./validate-opengl-renderer");
 const validRenderers = ['swangle', 'angle', 'egl', 'swiftshader'];
 const getOpenGlRenderer = (option) => {
@@ -21,13 +22,13 @@ const browserInstances = [];
 const killAllBrowsers = async () => {
     for (const browser of browserInstances) {
         try {
-            await browser.close(true);
+            await browser.close(true, 'info', false);
         }
         catch (err) { }
     }
 };
 exports.killAllBrowsers = killAllBrowsers;
-const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, shouldDumpIo, viewport, }) => {
+const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, }) => {
     var _a, _b;
     if (browser === 'firefox') {
         throw new TypeError('Firefox supported is not yet turned on. Stay tuned for the future.');
@@ -38,7 +39,8 @@ const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions
     const browserInstance = await node_1.puppeteer.launch({
         executablePath,
         product: browser,
-        dumpio: shouldDumpIo,
+        dumpio: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
+        logLevel,
         indent,
         args: [
             'about:blank',
@@ -109,7 +111,7 @@ const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions
             deviceScaleFactor: 1,
         },
     });
-    const pages = await browserInstance.pages();
+    const pages = await browserInstance.pages(logLevel, indent);
     await pages[0].close();
     browserInstances.push(browserInstance);
     return browserInstance;
@@ -127,8 +129,8 @@ const openBrowser = (browser, options) => {
         chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
         forceDeviceScaleFactor,
         indent: false,
-        shouldDumpIo: shouldDumpIo !== null && shouldDumpIo !== void 0 ? shouldDumpIo : false,
         viewport: null,
+        logLevel: shouldDumpIo ? 'verbose' : 'info',
     });
 };
 exports.openBrowser = openBrowser;

package/dist/perf.js

@@ -29,8 +29,10 @@ exports.stopPerfMeasure = stopPerfMeasure;
 const getPerf = () => {
     return [
         'Render performance:',
-        ...Object.keys(perf).map((p) => {
-            return `  ${p} => ${perf[p].reduce((a, b) => a + b, 0) / perf[p].length} (n = ${perf[p].length})`;
+        ...Object.keys(perf)
+            .filter((p) => perf[p].length)
+            .map((p) => {
+            return `  ${p} => ${perf[p].reduce((a, b) => a + b, 0) / perf[p].length}ms (n = ${perf[p].length})`;
         }),
     ];
 };

package/dist/prepare-server.d.ts

@@ -3,6 +3,7 @@ import type { DownloadMap } from './assets/download-map';
 import type { Compositor } from './compositor/compositor';
 import type { OffthreadVideoServerEmitter } from './offthread-video-server';
 import type { AnySourceMapConsumer } from './symbolicate-stacktrace';
+import type { LogLevel } from './log-level';
 export type RemotionServer = {
     serveUrl: string;
     closeServer: (force: boolean) => Promise<unknown>;
@@ -17,10 +18,10 @@ type PrepareServerOptions = {
     port: number | null;
     remotionRoot: string;
     concurrency: number;
-    verbose: boolean;
+    logLevel: LogLevel;
     indent: boolean;
 };
-export declare const prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }: PrepareServerOptions) => Promise<RemotionServer>;
+export declare const prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, }: PrepareServerOptions) => Promise<RemotionServer>;
 export declare const makeOrReuseServer: (server: RemotionServer | undefined, config: PrepareServerOptions, { onDownload, onError, }: {
     onError: (err: Error) => void;
     onDownload: RenderMediaOnDownload | null;

package/dist/prepare-server.js

@@ -14,16 +14,16 @@ const logger_1 = require("./logger");
 const serve_static_1 = require("./serve-static");
 const symbolicate_stacktrace_1 = require("./symbolicate-stacktrace");
 const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
-const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }) => {
+const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, }) => {
     const downloadMap = (0, download_map_1.makeDownloadMap)();
-    logger_1.Log.verboseAdvanced({ indent, logLevel: verbose ? 'verbose' : 'info' }, 'Created directory for temporary files', downloadMap.assetDir);
+    logger_1.Log.verboseAdvanced({ indent, logLevel }, 'Created directory for temporary files', downloadMap.assetDir);
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
         const { port: offthreadPort, close: closeProxy, compositor: comp, events, } = await (0, serve_static_1.serveStatic)(null, {
             port,
             downloadMap,
             remotionRoot,
             concurrency,
-            verbose,
+            logLevel,
             indent,
         });
         return Promise.resolve({
@@ -51,7 +51,7 @@ const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, conc
         downloadMap,
         remotionRoot,
         concurrency,
-        verbose,
+        logLevel,
         indent,
     });
     return Promise.resolve({

package/dist/prespawn-ffmpeg.d.ts

@@ -4,6 +4,7 @@ import type { VideoImageFormat } from './image-format';
 import type { CancelSignal } from './make-cancel-signal';
 import type { PixelFormat } from './pixel-format';
 import type { ProResProfile } from './prores-profile';
+import type { LogLevel } from './log-level';
 type RunningStatus = {
     type: 'running';
 } | {
@@ -24,7 +25,7 @@ type PreStitcherOptions = {
     crf: number | null | undefined;
     onProgress: (progress: number) => void;
     proResProfile: ProResProfile | undefined;
-    verbose: boolean;
+    logLevel: LogLevel;
     imageFormat: VideoImageFormat;
     ffmpegOverride: FfmpegOverrideFn;
     signal: CancelSignal;

package/dist/prespawn-ffmpeg.js

@@ -29,34 +29,6 @@ const prespawnFfmpeg = (options) => {
     if (encoderName === null) {
         throw new TypeError('encoderName is null: ' + JSON.stringify(options));
     }
-    const supportsCrf = codec !== 'prores';
-    logger_1.Log.verboseAdvanced({
-        indent: options.indent,
-        logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'prespawnFfmpeg()',
-    }, 'encoder', encoderName);
-    logger_1.Log.verboseAdvanced({
-        indent: options.indent,
-        logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'prespawnFfmpeg()',
-    }, 'pixelFormat', pixelFormat);
-    if (supportsCrf) {
-        logger_1.Log.verboseAdvanced({
-            indent: options.indent,
-            logLevel: options.verbose ? 'verbose' : 'info',
-            tag: 'prespawnFfmpeg()',
-        }, 'pixelFormat', options.crf);
-    }
-    logger_1.Log.verboseAdvanced({
-        indent: options.indent,
-        logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'prespawnFfmpeg()',
-    }, 'codec', codec);
-    logger_1.Log.verboseAdvanced({
-        indent: options.indent,
-        logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'prespawnFfmpeg()',
-    }, 'proResProfileName', proResProfileName);
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
     const ffmpegArgs = [
         ['-r', options.fps.toFixed(2)],
@@ -86,12 +58,12 @@ const prespawnFfmpeg = (options) => {
     ];
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
-        logLevel: options.verbose ? 'verbose' : 'info',
+        logLevel: options.logLevel,
         tag: 'prespawnFfmpeg()',
     }, 'Generated FFMPEG command:');
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
-        logLevel: options.verbose ? 'verbose' : 'info',
+        logLevel: options.logLevel,
         tag: 'prespawnFfmpeg()',
     }, ffmpegArgs.join(' '));
     const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);

package/dist/quality.d.ts

@@ -0,0 +1 @@
+export declare const validateQuality: (q: number | undefined) => void;

package/dist/quality.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQuality = void 0;
+const validateQuality = (q) => {
+    if (typeof q !== 'undefined' && typeof q !== 'number') {
+        throw new Error(`Quality option must be a number or undefined. Got ${typeof q} (${JSON.stringify(q)})`);
+    }
+    if (typeof q === 'undefined') {
+        return;
+    }
+    if (!Number.isFinite(q)) {
+        throw new RangeError(`Quality must be a finite number, but is ${q}`);
+    }
+    if (Number.isNaN(q)) {
+        throw new RangeError(`Quality is NaN, but must be a real number`);
+    }
+    if (q > 100 || q < 0) {
+        throw new RangeError('Quality option must be between 0 and 100.');
+    }
+};
+exports.validateQuality = validateQuality;