@remotion/renderer 4.1.0-alpha1 → 4.1.0-alpha11

package/dist/offthread-video-server.js

@@ -4,6 +4,8 @@ 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 logger_1 = require("./logger");
 const extractUrlAndSourceFromUrl = (url) => {
     const parsed = new URL(url, 'http://localhost');
     const query = parsed.search;
@@ -27,71 +29,114 @@ const extractUrlAndSourceFromUrl = (url) => {
     };
 };
 exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
-const startOffthreadVideoServer = ({ downloadMap, concurrency, verbose, indent, }) => {
-    const events = new OffthreadVideoServerEmitter();
+const REQUEST_CLOSED_TOKEN = 'Request closed';
+const startOffthreadVideoServer = ({ downloadMap, concurrency, logLevel, indent, }) => {
     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();
-            return compositor.waitForDone();
+            // Note: This is being used as a promise:
+            //     .close().then()
+            // but if finishCommands() fails, it acts like a sync function,
+            // therefore we have to catch an error and put a promise rejection
+            try {
+                compositor.finishCommands();
+                return compositor.waitForDone();
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
         },
-        listener: (req, res) => {
+        listener: (req, response) => {
             if (!req.url) {
                 throw new Error('Request came in without URL');
             }
             if (!req.url.startsWith('/proxy')) {
-                res.writeHead(404);
-                res.end();
+                response.writeHead(404);
+                response.end();
                 return;
             }
             const { src, time, transparent } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
-            res.setHeader('access-control-allow-origin', '*');
+            response.setHeader('access-control-allow-origin', '*');
             if (transparent) {
-                res.setHeader('content-type', `image/png`);
+                response.setHeader('content-type', `image/png`);
             }
             else {
-                res.setHeader('content-type', `image/bmp`);
+                response.setHeader('content-type', `image/bmp`);
             }
             // Handling this case on Lambda:
             // https://support.google.com/chrome/a/answer/7679408?hl=en
             // Chrome sends Private Network Access preflights for subresources
             if (req.method === 'OPTIONS') {
-                res.statusCode = 200;
+                response.statusCode = 200;
                 if (req.headers['access-control-request-private-network']) {
-                    res.setHeader('Access-Control-Allow-Private-Network', 'true');
+                    response.setHeader('Access-Control-Allow-Private-Network', 'true');
                 }
-                res.end();
+                response.end();
                 return;
             }
-            (0, download_and_map_assets_to_file_1.downloadAsset)({ src, emitter: events, downloadMap })
+            let closed = false;
+            req.on('close', () => {
+                closed = true;
+            });
+            let extractStart = Date.now();
+            (0, download_and_map_assets_to_file_1.downloadAsset)({ src, downloadMap })
                 .then((to) => {
-                return compositor.executeCommand('ExtractFrame', {
-                    input: to,
-                    time,
-                    transparent,
+                return new Promise((resolve, reject) => {
+                    if (closed) {
+                        reject(Error(REQUEST_CLOSED_TOKEN));
+                        return;
+                    }
+                    extractStart = Date.now();
+                    resolve(compositor.executeCommand('ExtractFrame', {
+                        src: to,
+                        original_src: src,
+                        time,
+                        transparent,
+                    }));
                 });
             })
                 .then((readable) => {
-                if (!readable) {
-                    throw new Error('no readable from ffmpeg');
-                }
-                res.writeHead(200);
-                res.write(readable);
-                res.end();
+                return new Promise((resolve, reject) => {
+                    if (closed) {
+                        reject(Error(REQUEST_CLOSED_TOKEN));
+                        return;
+                    }
+                    if (!readable) {
+                        reject(new Error('no readable from compositor'));
+                        return;
+                    }
+                    const extractEnd = Date.now();
+                    const timeToExtract = extractEnd - extractStart;
+                    if (timeToExtract > 1000) {
+                        logger_1.Log.verbose(`Took ${timeToExtract}ms to extract frame from ${src} at ${time}`);
+                    }
+                    response.writeHead(200);
+                    response.write(readable, (err) => {
+                        response.end();
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
             })
                 .catch((err) => {
-                res.writeHead(500);
-                res.end();
-                events.dispatchError(err);
-                console.log('Error occurred', err);
+                response.writeHead(500);
+                response.end();
+                // Any errors occurred due to the render being aborted don't need to be logged.
+                if (err.message !== REQUEST_CLOSED_TOKEN) {
+                    downloadMap.emitter.dispatchError(err);
+                    console.log('Error occurred', err);
+                }
             });
         },
         compositor,
-        events,
     };
 };
 exports.startOffthreadVideoServer = startOffthreadVideoServer;

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/options/crf.js

@@ -5,7 +5,7 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 exports.crfOption = {
     name: 'CRF',
     cliFlag: '--crf',
-    description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "No matter which codec you end up using, there's always a tradeoff between file size and video quality. You can control it by setting the so called CRF (Constant Rate Factor). The lower the number, the better the quality, the higher the number, the smaller the file is \u2013 of course at the cost of quality." })),
+    description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "No matter which codec you end up using, there's always a tradeoff between file size and video quality. You can control it by setting the CRF (Constant Rate Factor). The lower the number, the better the quality, the higher the number, the smaller the file is \u2013 of course at the cost of quality." })),
     ssrName: 'crf',
     docLink: 'https://www.remotion.dev/docs/encoding/#controlling-quality-using-the-crf-setting',
 };

package/dist/options/video-codec.js

@@ -5,7 +5,7 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 exports.videoCodecOption = {
     name: 'Codec',
     cliFlag: '--codec',
-    description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "H264 works well in most cases, sometimes it's worth going for a different codec. WebM achieves higher compression but is slower to render. WebM and ProRes support transparency." })),
+    description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "H264 works well in most cases, but sometimes it's worth going for a different codec. WebM achieves higher compression but is slower to render. WebM and ProRes support transparency." })),
     ssrName: 'codec',
     docLink: 'https://www.remotion.dev/docs/encoding/#choosing-a-codec',
 };

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

@@ -1,15 +1,14 @@
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
 import type { Compositor } from './compositor/compositor';
-import type { OffthreadVideoServerEmitter } from './offthread-video-server';
+import type { LogLevel } from './log-level';
 import type { AnySourceMapConsumer } from './symbolicate-stacktrace';
 export type RemotionServer = {
     serveUrl: string;
     closeServer: (force: boolean) => Promise<unknown>;
     offthreadPort: number;
     compositor: Compositor;
-    sourceMap: AnySourceMapConsumer | null;
-    events: OffthreadVideoServerEmitter;
+    sourceMap: Promise<AnySourceMapConsumer | null>;
     downloadMap: DownloadMap;
 };
 type PrepareServerOptions = {
@@ -17,10 +16,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

@@ -9,21 +9,22 @@ const node_path_1 = __importDefault(require("node:path"));
 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 get_bundle_url_from_serve_url_1 = require("./get-bundle-url-from-serve-url");
 const is_serve_url_1 = require("./is-serve-url");
 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, {
+        const { port: offthreadPort, close: closeProxy, compositor: comp, } = await (0, serve_static_1.serveStatic)(null, {
             port,
             downloadMap,
             remotionRoot,
             concurrency,
-            verbose,
+            logLevel,
             indent,
         });
         return Promise.resolve({
@@ -34,8 +35,10 @@ const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, conc
             },
             offthreadPort,
             compositor: comp,
-            sourceMap: null,
-            events,
+            sourceMap: (0, symbolicate_stacktrace_1.getSourceMapFromRemoteUrl)((0, get_bundle_url_from_serve_url_1.getBundleMapUrlFromServeUrl)(webpackConfigOrServeUrl)).catch((err) => {
+                logger_1.Log.verbose('Could not fetch sourcemap for ', webpackConfigOrServeUrl, err);
+                return null;
+            }),
             downloadMap,
         });
     }
@@ -46,12 +49,12 @@ const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, conc
         throw new Error(`Tried to serve the Webpack bundle on a HTTP server, but the file ${indexFile} does not exist. Is this a valid path to a Webpack bundle?`);
     }
     const sourceMap = (0, symbolicate_stacktrace_1.getSourceMapFromLocalFile)(node_path_1.default.join(webpackConfigOrServeUrl, remotion_1.Internals.bundleName));
-    const { port: serverPort, close, compositor, events: newEvents, } = await (0, serve_static_1.serveStatic)(webpackConfigOrServeUrl, {
+    const { port: serverPort, close, compositor, } = await (0, serve_static_1.serveStatic)(webpackConfigOrServeUrl, {
         port,
         downloadMap,
         remotionRoot,
         concurrency,
-        verbose,
+        logLevel,
         indent,
     });
     return Promise.resolve({
@@ -66,16 +69,15 @@ const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, conc
         serveUrl: `http://localhost:${serverPort}`,
         offthreadPort: serverPort,
         compositor,
-        sourceMap: await sourceMap,
-        events: newEvents,
+        sourceMap,
         downloadMap,
     });
 };
 exports.prepareServer = prepareServer;
 const makeOrReuseServer = async (server, config, { onDownload, onError, }) => {
     if (server) {
-        const cleanupOnDownload = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(server.events, onDownload);
-        const cleanupError = server.events.addEventListener('error', ({ detail: { error } }) => {
+        const cleanupOnDownload = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(server.downloadMap, onDownload);
+        const cleanupError = server.downloadMap.emitter.addEventListener('error', ({ detail: { error } }) => {
             onError(error);
         });
         return {
@@ -88,8 +90,8 @@ const makeOrReuseServer = async (server, config, { onDownload, onError, }) => {
         };
     }
     const newServer = await (0, exports.prepareServer)(config);
-    const cleanupOnDownloadNew = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(newServer.events, onDownload);
-    const cleanupErrorNew = newServer.events.addEventListener('error', ({ detail: { error } }) => {
+    const cleanupOnDownloadNew = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(newServer.downloadMap, onDownload);
+    const cleanupErrorNew = newServer.downloadMap.emitter.addEventListener('error', ({ detail: { error } }) => {
         onError(error);
     });
     return {

package/dist/prespawn-ffmpeg.d.ts

@@ -1,6 +1,7 @@
 import type { Codec } from './codec';
 import type { FfmpegOverrideFn } from './ffmpeg-override';
 import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 import type { PixelFormat } from './pixel-format';
 import type { ProResProfile } from './prores-profile';
@@ -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,37 +29,9 @@ 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)],
+        ['-r', options.fps],
         ...[
             ['-f', 'image2pipe'],
             ['-s', `${options.width}x${options.height}`],
@@ -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/puppeteer-evaluate.d.ts

@@ -4,4 +4,7 @@ export declare function puppeteerEvaluateWithCatch<ReturnType>({ page, pageFunct
     pageFunction: Function | string;
     frame: number | null;
     args: unknown[];
-}): Promise<ReturnType>;
+}): Promise<{
+    value: ReturnType;
+    size: number;
+}>;

package/dist/puppeteer-evaluate.js

@@ -39,13 +39,13 @@ async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, })
         const expressionWithSourceUrl = SOURCE_URL_REGEX.test(expression)
             ? expression
             : expression + '\n' + suffix;
-        const { exceptionDetails: exceptDetails, result: remotObject } = (await client.send('Runtime.evaluate', {
+        const { value: { exceptionDetails: exceptDetails, result: remotObject }, size, } = await client.send('Runtime.evaluate', {
             expression: expressionWithSourceUrl,
             contextId,
             returnByValue: true,
             awaitPromise: true,
             userGesture: true,
-        }));
+        });
         if (exceptDetails === null || exceptDetails === void 0 ? void 0 : exceptDetails.exception) {
             const err = new symbolicateable_error_1.SymbolicateableError({
                 stack: exceptDetails.exception.description,
@@ -56,7 +56,7 @@ async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, })
             });
             throw err;
         }
-        return valueFromRemoteObject(remotObject);
+        return { value: valueFromRemoteObject(remotObject), size };
     }
     if (typeof pageFunction !== 'function')
         throw new Error(`Expected to get |string| or |function| as the first argument, but got "${pageFunction}" instead.`);
@@ -100,7 +100,7 @@ async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, })
         throw error;
     }
     try {
-        const { exceptionDetails, result: remoteObject } = await callFunctionOnPromise;
+        const { value: { exceptionDetails, result: remoteObject }, size, } = await callFunctionOnPromise;
         if (exceptionDetails) {
             const err = new symbolicateable_error_1.SymbolicateableError({
                 stack: (_c = exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,
@@ -111,7 +111,7 @@ async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, })
             });
             throw err;
         }
-        return valueFromRemoteObject(remoteObject);
+        return { size, value: valueFromRemoteObject(remoteObject) };
     }
     catch (error) {
         if ((_h = error === null || error === void 0 ? void 0 : error.originalMessage) === null || _h === void 0 ? void 0 : _h.startsWith("Object couldn't be returned by value")) {

package/dist/render-frames.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" />
-import type { AnySmallCompMetadata } from 'remotion';
+import type { VideoConfig } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
 import type { HeadlessBrowser } from './browser/Browser';
 import type { FrameRange } from './frame-range';
 import type { VideoImageFormat } from './image-format';
+import { type LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
 import type { RemotionServer } from './prepare-server';
@@ -14,13 +15,11 @@ export type InternalRenderFramesOptions = {
     onStart: null | ((data: OnStartData) => void);
     onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
     outputDir: string | null;
-    inputProps: Record<string, unknown>;
     envVariables: Record<string, string>;
     imageFormat: VideoImageFormat;
     jpegQuality: number;
     frameRange: FrameRange | null;
     everyNthFrame: number;
-    dumpBrowserLogs: boolean;
     puppeteerInstance: HeadlessBrowser | undefined;
     browserExecutable: BrowserExecutable | null;
     onBrowserLog: null | ((log: BrowserLog) => void);
@@ -31,13 +30,15 @@ export type InternalRenderFramesOptions = {
     scale: number;
     port: number | null;
     cancelSignal: CancelSignal | undefined;
-    composition: AnySmallCompMetadata;
+    composition: Omit<VideoConfig, 'props' | 'defaultProps'>;
     indent: boolean;
     server: RemotionServer | undefined;
     muted: boolean;
     concurrency: number | string | null;
     webpackBundleOrServeUrl: string;
-    verbose: boolean;
+    logLevel: LogLevel;
+    serializedInputPropsWithCustomSchema: string;
+    serializedResolvedPropsWithCustomSchema: string;
 };
 export type RenderFramesOptions = {
     onStart: (data: OnStartData) => void;
@@ -53,7 +54,15 @@ export type RenderFramesOptions = {
     jpegQuality?: number;
     frameRange?: FrameRange | null;
     everyNthFrame?: number;
+    /**
+     * @deprecated Use "logLevel": "verbose" instead
+     */
     dumpBrowserLogs?: boolean;
+    /**
+     * @deprecated Use "logLevel" instead
+     */
+    verbose?: boolean;
+    logLevel?: LogLevel;
     puppeteerInstance?: HeadlessBrowser;
     browserExecutable?: BrowserExecutable;
     onBrowserLog?: (log: BrowserLog) => void;
@@ -64,13 +73,12 @@ export type RenderFramesOptions = {
     scale?: number;
     port?: number | null;
     cancelSignal?: CancelSignal;
-    composition: AnySmallCompMetadata;
+    composition: VideoConfig;
     muted?: boolean;
     concurrency?: number | string | null;
     serveUrl: string;
-    verbose?: boolean;
 };
-export declare const 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, }: InternalRenderFramesOptions) => Promise<RenderFramesOutput>;
+export declare const internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, }: InternalRenderFramesOptions) => Promise<RenderFramesOutput>;
 /**
  * @description Renders a series of images using Puppeteer and computes information for mixing audio.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/render-frames)