@remotion/renderer 4.0.0-webhook.27 → 4.1.0-alpha2

package/dist/pixel-format.js

@@ -13,6 +13,9 @@ exports.validPixelFormats = [
 ];
 exports.DEFAULT_PIXEL_FORMAT = 'yuv420p';
 const validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
+    if (typeof pixelFormat === 'undefined') {
+        return pixelFormat;
+    }
     if (!exports.validPixelFormats.includes(pixelFormat)) {
         throw new TypeError(`Value ${pixelFormat} is not valid as a pixel format.`);
     }

package/dist/prepare-server.d.ts

@@ -1,16 +1,31 @@
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
-import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const prepareServer: ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, }: {
+import type { Compositor } from './compositor/compositor';
+import type { OffthreadVideoServerEmitter } from './offthread-video-server';
+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;
+    downloadMap: DownloadMap;
+};
+type PrepareServerOptions = {
     webpackConfigOrServeUrl: string;
-    onDownload: RenderMediaOnDownload;
-    onError: (err: Error) => void;
-    ffmpegExecutable: FfmpegExecutable;
-    ffprobeExecutable: FfmpegExecutable;
     port: number | null;
-    downloadMap: DownloadMap;
+    remotionRoot: string;
+    concurrency: number;
+    verbose: boolean;
+    indent: boolean;
+};
+export declare const prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }: PrepareServerOptions) => Promise<RemotionServer>;
+export declare const makeOrReuseServer: (server: RemotionServer | undefined, config: PrepareServerOptions, { onDownload, onError, }: {
+    onError: (err: Error) => void;
+    onDownload: RenderMediaOnDownload | null;
 }) => Promise<{
-    serveUrl: string;
-    closeServer: () => Promise<unknown>;
-    offthreadPort: number;
+    server: RemotionServer;
+    cleanupServer: (force: boolean) => Promise<unknown>;
 }>;
+export {};

package/dist/prepare-server.js

@@ -3,50 +3,103 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareServer = void 0;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
+exports.makeOrReuseServer = exports.prepareServer = void 0;
+const node_fs_1 = require("node:fs");
+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 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 ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, }) => {
+const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }) => {
+    const downloadMap = (0, download_map_1.makeDownloadMap)();
+    logger_1.Log.verboseAdvanced({ indent, logLevel: verbose ? 'verbose' : 'info' }, 'Created directory for temporary files', downloadMap.assetDir);
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
-        const { port: offthreadPort, close: closeProxy } = await (0, serve_static_1.serveStatic)(null, {
-            onDownload,
-            onError,
-            ffmpegExecutable,
-            ffprobeExecutable,
+        const { port: offthreadPort, close: closeProxy, compositor: comp, events, } = await (0, serve_static_1.serveStatic)(null, {
             port,
             downloadMap,
+            remotionRoot,
+            concurrency,
+            verbose,
+            indent,
         });
         return Promise.resolve({
             serveUrl: webpackConfigOrServeUrl,
             closeServer: () => {
+                (0, download_map_1.cleanDownloadMap)(downloadMap);
                 return closeProxy();
             },
             offthreadPort,
+            compositor: comp,
+            sourceMap: null,
+            events,
+            downloadMap,
         });
     }
     // Check if the path has a `index.html` file
-    const indexFile = path_1.default.join(webpackConfigOrServeUrl, 'index.html');
-    const exists = (0, fs_1.existsSync)(indexFile);
+    const indexFile = node_path_1.default.join(webpackConfigOrServeUrl, 'index.html');
+    const exists = (0, node_fs_1.existsSync)(indexFile);
     if (!exists) {
         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 { port: serverPort, close } = await (0, serve_static_1.serveStatic)(webpackConfigOrServeUrl, {
-        onDownload,
-        onError,
-        ffmpegExecutable,
-        ffprobeExecutable,
+    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, {
         port,
         downloadMap,
+        remotionRoot,
+        concurrency,
+        verbose,
+        indent,
     });
     return Promise.resolve({
-        closeServer: () => {
-            return (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)().then(() => close());
+        closeServer: async (force) => {
+            sourceMap.then((s) => s === null || s === void 0 ? void 0 : s.destroy());
+            (0, download_map_1.cleanDownloadMap)(downloadMap);
+            if (!force) {
+                await (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)();
+            }
+            return close();
         },
         serveUrl: `http://localhost:${serverPort}`,
         offthreadPort: serverPort,
+        compositor,
+        sourceMap: await sourceMap,
+        events: newEvents,
+        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 } }) => {
+            onError(error);
+        });
+        return {
+            server,
+            cleanupServer: () => {
+                cleanupOnDownload();
+                cleanupError();
+                return Promise.resolve();
+            },
+        };
+    }
+    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 } }) => {
+        onError(error);
+    });
+    return {
+        server: newServer,
+        cleanupServer: (force) => {
+            newServer.closeServer(force);
+            cleanupOnDownloadNew();
+            cleanupErrorNew();
+            return Promise.resolve();
+        },
+    };
+};
+exports.makeOrReuseServer = makeOrReuseServer;

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

@@ -1,14 +1,16 @@
 import type { DownloadMap } from './assets/download-map';
 import type { MediaAsset } from './assets/types';
-import type { FfmpegExecutable } from './ffmpeg-executable';
-declare type Options = {
-    ffmpegExecutable: FfmpegExecutable;
-    ffprobeExecutable: FfmpegExecutable;
+import type { ProcessedTrack } from './stringify-ffmpeg-filter';
+type Options = {
     outName: string;
     asset: MediaAsset;
     expectedFrames: number;
     fps: number;
     downloadMap: DownloadMap;
 };
-export declare const preprocessAudioTrack: (options: Options) => Promise<string | null>;
+export type PreprocessedAudioTrack = {
+    outName: string;
+    filter: ProcessedTrack;
+};
+export declare const preprocessAudioTrack: (options: Options) => Promise<PreprocessedAudioTrack | null>;
 export {};

package/dist/preprocess-audio-track.js

@@ -1,17 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preprocessAudioTrack = void 0;
-const execa_1 = __importDefault(require("execa"));
 const get_audio_channels_1 = require("./assets/get-audio-channels");
 const calculate_ffmpeg_filters_1 = require("./calculate-ffmpeg-filters");
+const call_ffmpeg_1 = require("./call-ffmpeg");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
 const p_limit_1 = require("./p-limit");
 const resolve_asset_src_1 = require("./resolve-asset-src");
-const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutable, outName, asset, expectedFrames, fps, downloadMap, }) => {
-    const { channels, duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)(downloadMap, (0, resolve_asset_src_1.resolveAssetSrc)(asset.src), ffprobeExecutable);
+const sample_rate_1 = require("./sample-rate");
+const preprocessAudioTrackUnlimited = async ({ outName, asset, expectedFrames, fps, downloadMap, }) => {
+    const { channels, duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)(downloadMap, (0, resolve_asset_src_1.resolveAssetSrc)(asset.src));
     const filter = (0, calculate_ffmpeg_filters_1.calculateFfmpegFilter)({
         asset,
         durationInFrames: expectedFrames,
@@ -28,11 +26,12 @@ const preprocessAudioTrackUnlimited = async ({ ffmpegExecutable, ffprobeExecutab
         ['-ac', '2'],
         ['-filter_script:a', file],
         ['-c:a', 'pcm_s16le'],
+        ['-ar', String(sample_rate_1.DEFAULT_SAMPLE_RATE)],
         ['-y', outName],
     ].flat(2);
-    await (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', args);
+    await (0, call_ffmpeg_1.callFf)('ffmpeg', args);
     cleanup();
-    return outName;
+    return { outName, filter };
 };
 const limit = (0, p_limit_1.pLimit)(2);
 const preprocessAudioTrack = (options) => {

package/dist/prespawn-ffmpeg.d.ts

@@ -1,12 +1,20 @@
-import execa from 'execa';
 import type { Codec } from './codec';
-import type { FfmpegExecutable } from './ffmpeg-executable';
 import type { FfmpegOverrideFn } from './ffmpeg-override';
-import type { ImageFormat } from './image-format';
+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';
-declare type PreSticherOptions = {
+type RunningStatus = {
+    type: 'running';
+} | {
+    type: 'quit-successfully';
+    stderr: string;
+} | {
+    type: 'quit-with-error';
+    exitCode: number;
+    stderr: string;
+};
+type PreStitcherOptions = {
     fps: number;
     width: number;
     height: number;
@@ -17,13 +25,15 @@ declare type PreSticherOptions = {
     onProgress: (progress: number) => void;
     proResProfile: ProResProfile | undefined;
     verbose: boolean;
-    ffmpegExecutable: FfmpegExecutable | undefined;
-    imageFormat: ImageFormat;
-    ffmpegOverride?: FfmpegOverrideFn;
+    imageFormat: VideoImageFormat;
+    ffmpegOverride: FfmpegOverrideFn;
     signal: CancelSignal;
+    videoBitrate: string | null;
+    indent: boolean;
 };
-export declare const prespawnFfmpeg: (options: PreSticherOptions) => Promise<{
-    task: execa.ExecaChildProcess<string>;
+export declare const prespawnFfmpeg: (options: PreStitcherOptions) => {
+    task: import("execa").ExecaChildProcess<string>;
     getLogs: () => string;
-}>;
+    getExitStatus: () => RunningStatus;
+};
 export {};

package/dist/prespawn-ffmpeg.js

@@ -1,21 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prespawnFfmpeg = void 0;
-const execa_1 = __importDefault(require("execa"));
 const remotion_1 = require("remotion");
+const call_ffmpeg_1 = require("./call-ffmpeg");
 const codec_1 = require("./codec");
 const crf_1 = require("./crf");
 const get_codec_name_1 = require("./get-codec-name");
 const get_prores_profile_name_1 = require("./get-prores-profile-name");
+const logger_1 = require("./logger");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const pixel_format_1 = require("./pixel-format");
 const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
-const validate_ffmpeg_1 = require("./validate-ffmpeg");
-const prespawnFfmpeg = async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g;
+const prespawnFfmpeg = (options) => {
+    var _a, _b, _c;
     remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
     remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
     const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : codec_1.DEFAULT_CODEC;
@@ -26,26 +23,40 @@ const prespawnFfmpeg = async (options) => {
         codec,
         scale: 1,
     });
-    const crf = (_b = options.crf) !== null && _b !== void 0 ? _b : (0, crf_1.getDefaultCrfForCodec)(codec);
-    const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : pixel_format_1.DEFAULT_PIXEL_FORMAT;
-    await (0, validate_ffmpeg_1.validateFfmpeg)((_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : null);
+    const pixelFormat = (_b = options.pixelFormat) !== null && _b !== void 0 ? _b : pixel_format_1.DEFAULT_PIXEL_FORMAT;
     const encoderName = (0, get_codec_name_1.getCodecName)(codec);
     const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
     if (encoderName === null) {
         throw new TypeError('encoderName is null: ' + JSON.stringify(options));
     }
     const supportsCrf = codec !== 'prores';
-    if (options.verbose) {
-        console.log('[verbose] ffmpeg', (_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : 'ffmpeg in PATH');
-        console.log('[verbose] encoder', encoderName);
-        console.log('[verbose] pixelFormat', pixelFormat);
-        if (supportsCrf) {
-            console.log('[verbose] crf', crf);
-        }
-        console.log('[verbose] codec', codec);
-        console.log('[verbose] proResProfileName', proResProfileName);
+    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);
     }
-    (0, crf_1.validateSelectedCrfAndCodecCombination)(crf, codec);
+    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)],
@@ -61,29 +72,38 @@ const prespawnFfmpeg = async (options) => {
         // and specified the video codec.
         ['-c:v', encoderName],
         proResProfileName ? ['-profile:v', proResProfileName] : null,
-        supportsCrf ? ['-crf', String(crf)] : null,
         ['-pix_fmt', pixelFormat],
         // Without explicitly disabling auto-alt-ref,
         // transparent WebM generation doesn't work
         pixelFormat === 'yuva420p' ? ['-auto-alt-ref', '0'] : null,
-        ['-b:v', '1M'],
+        ...(0, crf_1.validateQualitySettings)({
+            crf: options.crf,
+            videoBitrate: options.videoBitrate,
+            codec,
+        }),
         '-y',
         options.outputLocation,
     ];
-    if (options.verbose) {
-        console.log('Generated FFMPEG command:');
-        console.log(ffmpegArgs);
-    }
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'prespawnFfmpeg()',
+    }, 'Generated FFMPEG command:');
+    logger_1.Log.verboseAdvanced({
+        indent: options.indent,
+        logLevel: options.verbose ? 'verbose' : 'info',
+        tag: 'prespawnFfmpeg()',
+    }, ffmpegArgs.join(' '));
     const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
     const finalFfmpegString = options.ffmpegOverride
         ? options.ffmpegOverride({ type: 'pre-stitcher', args: ffmpegString })
         : ffmpegString;
-    const task = (0, execa_1.default)((_f = options.ffmpegExecutable) !== null && _f !== void 0 ? _f : 'ffmpeg', finalFfmpegString);
+    const task = (0, call_ffmpeg_1.callFf)('ffmpeg', finalFfmpegString);
     options.signal(() => {
         task.kill();
     });
     let ffmpegOutput = '';
-    (_g = task.stderr) === null || _g === void 0 ? void 0 : _g.on('data', (data) => {
+    (_c = task.stderr) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
         const str = data.toString();
         ffmpegOutput += str;
         if (options.onProgress) {
@@ -93,6 +113,24 @@ const prespawnFfmpeg = async (options) => {
             }
         }
     });
-    return { task, getLogs: () => ffmpegOutput };
+    let exitCode = {
+        type: 'running',
+    };
+    task.on('exit', (code) => {
+        if (typeof code === 'number' && code > 0) {
+            exitCode = {
+                type: 'quit-with-error',
+                exitCode: code,
+                stderr: ffmpegOutput,
+            };
+        }
+        else {
+            exitCode = {
+                type: 'quit-successfully',
+                stderr: ffmpegOutput,
+            };
+        }
+    });
+    return { task, getLogs: () => ffmpegOutput, getExitStatus: () => exitCode };
 };
 exports.prespawnFfmpeg = prespawnFfmpeg;

package/dist/prestitcher-memory-usage.d.ts

@@ -1,7 +1,3 @@
-export declare const estimateMemoryUsageForPrestitcher: ({ width, height, }: {
-    width: number;
-    height: number;
-}) => number;
 export declare const shouldUseParallelEncoding: ({ width, height, }: {
     width: number;
     height: number;

package/dist/prestitcher-memory-usage.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldUseParallelEncoding = exports.estimateMemoryUsageForPrestitcher = void 0;
-const os_1 = __importDefault(require("os"));
+exports.shouldUseParallelEncoding = void 0;
+const node_os_1 = __importDefault(require("node:os"));
 const estimateMemoryUsageForPrestitcher = ({ width, height, }) => {
     // Empirically we detected that per 1 million pixels, FFMPEG uses around 1GB of memory, relatively independent of
     // the duration of the video.
@@ -12,10 +12,9 @@ const estimateMemoryUsageForPrestitcher = ({ width, height, }) => {
     const memoryUsageOfPixel = memoryUsageFor4K / 1000000;
     return memoryUsageOfPixel * width * height;
 };
-exports.estimateMemoryUsageForPrestitcher = estimateMemoryUsageForPrestitcher;
 const shouldUseParallelEncoding = ({ width, height, }) => {
-    const freeMemory = os_1.default.freemem();
-    const estimatedUsage = (0, exports.estimateMemoryUsageForPrestitcher)({
+    const freeMemory = node_os_1.default.freemem();
+    const estimatedUsage = estimateMemoryUsageForPrestitcher({
         height,
         width,
     });

package/dist/prores-profile.d.ts

@@ -1,5 +1,7 @@
 import type { Codec } from './codec';
-declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
-export declare type ProResProfile = typeof proResProfileOptions[number];
-export declare const validateSelectedCodecAndProResCombination: (actualCodec: Codec, actualProResProfile: ProResProfile | undefined) => void;
-export {};
+export declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
+export type ProResProfile = typeof proResProfileOptions[number];
+export declare const validateSelectedCodecAndProResCombination: ({ codec, proResProfile, }: {
+    codec: Codec;
+    proResProfile: ProResProfile | undefined;
+}) => void;

package/dist/prores-profile.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSelectedCodecAndProResCombination = void 0;
-const proResProfileOptions = [
+exports.validateSelectedCodecAndProResCombination = exports.proResProfileOptions = void 0;
+exports.proResProfileOptions = [
     '4444-xq',
     '4444',
     'hq',
@@ -9,13 +9,13 @@ const proResProfileOptions = [
     'light',
     'proxy',
 ];
-const validateSelectedCodecAndProResCombination = (actualCodec, actualProResProfile) => {
-    if (typeof actualProResProfile !== 'undefined' && actualCodec !== 'prores') {
-        throw new TypeError('You have set a ProRes profile but the codec is not "prores". Set the codec to "prores" or remove the ProRes profile.');
+const validateSelectedCodecAndProResCombination = ({ codec, proResProfile, }) => {
+    if (typeof proResProfile !== 'undefined' && codec !== 'prores') {
+        throw new TypeError(`You have set a ProRes profile but the codec is "${codec}". Set the codec to "prores" or remove the ProRes profile.`);
     }
-    if (actualProResProfile !== undefined &&
-        !proResProfileOptions.includes(actualProResProfile)) {
-        throw new TypeError(`The ProRes profile "${actualProResProfile}" is not valid. Valid options are ${proResProfileOptions
+    if (proResProfile !== undefined &&
+        !exports.proResProfileOptions.includes(proResProfile)) {
+        throw new TypeError(`The ProRes profile "${proResProfile}" is not valid. Valid options are ${exports.proResProfileOptions
             .map((p) => `"${p}"`)
             .join(', ')}`);
     }

package/dist/provide-screenshot.d.ts

@@ -1,12 +1,16 @@
 /// <reference types="node" />
+import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
-import type { ImageFormat } from './image-format';
-export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {
+import type { StillImageFormat } from './image-format';
+export declare const provideScreenshot: ({ page, imageFormat, options, jpegQuality, height, width, clipRegion, }: {
     page: Page;
-    imageFormat: ImageFormat;
-    quality: number | undefined;
+    imageFormat: StillImageFormat;
+    jpegQuality: number | undefined;
     options: {
         frame: number;
         output: string | null;
     };
+    height: number;
+    width: number;
+    clipRegion: ClipRegion | null;
 }) => Promise<Buffer>;

package/dist/provide-screenshot.js

@@ -2,14 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.provideScreenshot = void 0;
 const screenshot_dom_element_1 = require("./screenshot-dom-element");
-const provideScreenshot = ({ page, imageFormat, options, quality, }) => {
+const provideScreenshot = ({ page, imageFormat, options, jpegQuality, height, width, clipRegion, }) => {
     return (0, screenshot_dom_element_1.screenshotDOMElement)({
         page,
         opts: {
             path: options.output,
         },
         imageFormat,
-        quality,
+        jpegQuality,
+        height,
+        width,
+        clipRegion,
     });
 };
 exports.provideScreenshot = provideScreenshot;

package/dist/puppeteer-evaluate.js

@@ -30,7 +30,7 @@ function isString(obj) {
     return typeof obj === 'string' || obj instanceof String;
 }
 async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, }) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const contextId = (await page.mainFrame().executionContext())._contextId;
     const client = page._client();
     const suffix = `//# sourceURL=${EVALUATION_SCRIPT_URL}`;
@@ -99,18 +99,26 @@ async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, })
             error.message += ' Are you passing a nested JSHandle?';
         throw error;
     }
-    const { exceptionDetails, result: remoteObject } = await callFunctionOnPromise;
-    if (exceptionDetails) {
-        const err = new symbolicateable_error_1.SymbolicateableError({
-            stack: (_c = exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,
-            name: (_d = exceptionDetails.exception) === null || _d === void 0 ? void 0 : _d.className,
-            message: (_f = (_e = exceptionDetails.exception) === null || _e === void 0 ? void 0 : _e.description) === null || _f === void 0 ? void 0 : _f.split('\n')[0],
-            frame,
-            stackFrame: (0, parse_browser_error_stack_1.parseStack)(((_g = exceptionDetails.exception) === null || _g === void 0 ? void 0 : _g.description).split('\n')),
-        });
-        throw err;
+    try {
+        const { exceptionDetails, result: remoteObject } = await callFunctionOnPromise;
+        if (exceptionDetails) {
+            const err = new symbolicateable_error_1.SymbolicateableError({
+                stack: (_c = exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,
+                name: (_d = exceptionDetails.exception) === null || _d === void 0 ? void 0 : _d.className,
+                message: (_f = (_e = exceptionDetails.exception) === null || _e === void 0 ? void 0 : _e.description) === null || _f === void 0 ? void 0 : _f.split('\n')[0],
+                frame,
+                stackFrame: (0, parse_browser_error_stack_1.parseStack)(((_g = exceptionDetails.exception) === null || _g === void 0 ? void 0 : _g.description).split('\n')),
+            });
+            throw err;
+        }
+        return 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")) {
+            throw new Error('Could not serialize the return value of the function. Did you pass non-serializable values to defaultProps?');
+        }
+        throw error;
     }
-    return valueFromRemoteObject(remoteObject);
 }
 exports.puppeteerEvaluateWithCatch = puppeteerEvaluateWithCatch;
 /**

package/dist/puppeteer-screenshot.d.ts

@@ -1,4 +1,14 @@
 /// <reference types="node" />
+import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
-import type { ScreenshotOptions } from './browser/ScreenshotOptions';
-export declare const screenshot: (page: Page, options: ScreenshotOptions) => Promise<Buffer | string | void>;
+import type { StillImageFormat } from './image-format';
+export declare const screenshot: (options: {
+    page: Page;
+    type: StillImageFormat;
+    path?: string;
+    jpegQuality?: number;
+    omitBackground: boolean;
+    width: number;
+    height: number;
+    clipRegion: ClipRegion | null;
+}) => Promise<Buffer | string>;