@remotion/renderer 4.0.255 → 4.0.256

package/dist/get-codec-name.d.ts

@@ -9,7 +9,7 @@ export declare const hasSpecifiedUnsupportedHardwareQualifySettings: ({ encoding
     encodingMaxRate: string | null;
     encodingBufferSize: string | null;
     crf: unknown;
-}) => "crf" | "encodingBufferSize" | "encodingMaxRate" | null;
+}) => "encodingMaxRate" | "encodingBufferSize" | "crf" | null;
 export declare const getCodecName: ({ codec, encodingMaxRate, encodingBufferSize, crf, hardwareAcceleration, logLevel, indent, }: {
     codec: Codec;
     hardwareAcceleration: HardwareAccelerationOption;

package/dist/get-compositions.js

@@ -91,6 +91,7 @@ const internalGetCompositionsRaw = async ({ browserExecutable, chromiumOptions,
         logLevel,
         onBrowserDownload,
         chromeMode,
+        pageIndex: 0,
     });
     const cleanup = [cleanupPage];
     return new Promise((resolve, reject) => {

package/dist/get-local-browser.d.ts

@@ -0,0 +1 @@
+export declare const getLocalBrowser: () => null;

package/dist/get-local-browser.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalBrowser = void 0;
+const fs_1 = __importDefault(require("fs"));
+const getSearchPathsForProduct = () => {
+    return [];
+};
+const getLocalBrowser = () => {
+    for (const p of getSearchPathsForProduct()) {
+        if (fs_1.default.existsSync(p)) {
+            return p;
+        }
+    }
+    return null;
+};
+exports.getLocalBrowser = getLocalBrowser;

package/dist/index.d.ts

@@ -140,7 +140,7 @@ export declare const RenderInternals: {
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_BROWSER: "chrome";
     validateFrameRange: (frameRange: import("./frame-range").FrameRange | null) => void;
-    DEFAULT_OPENGL_RENDERER: "angle" | "swangle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
+    DEFAULT_OPENGL_RENDERER: "swangle" | "angle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
     validateOpenGlRenderer: (option: unknown) => import("./options/gl").OpenGlRenderer | null;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "h264-ts", "gif"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
@@ -353,8 +353,8 @@ export declare const RenderInternals: {
     }) => execa.ExecaChildProcess<string>;
     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;

package/dist/make-page.d.ts

@@ -0,0 +1,27 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { BrowserLog } from './browser-log';
+import type { Page } from './browser/BrowserPage';
+import type { SourceMapGetter } from './browser/source-map-getter';
+import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { BrowserReplacer } from './replace-browser';
+export declare const makePage: ({ context, initialFrame, browserReplacer, logLevel, indent, pagesArray, onBrowserLog, scale, timeoutInMilliseconds, composition, proxyPort, serveUrl, muted, envVariables, serializedInputPropsWithCustomSchema, imageFormat, serializedResolvedPropsWithCustomSchema, pageIndex, }: {
+    context: SourceMapGetter;
+    initialFrame: number;
+    browserReplacer: BrowserReplacer;
+    logLevel: LogLevel;
+    indent: boolean;
+    pagesArray: Page[];
+    onBrowserLog: ((log: BrowserLog) => void) | undefined | null;
+    scale: number;
+    timeoutInMilliseconds: number;
+    composition: Omit<VideoConfig, "defaultProps" | "props">;
+    proxyPort: number;
+    serveUrl: string;
+    muted: boolean;
+    envVariables: Record<string, string>;
+    serializedInputPropsWithCustomSchema: string;
+    serializedResolvedPropsWithCustomSchema: string;
+    imageFormat: VideoImageFormat;
+    pageIndex: number;
+}) => Promise<Page>;

package/dist/make-page.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePage = void 0;
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const set_props_and_env_1 = require("./set-props-and-env");
+const makePage = async ({ context, initialFrame, browserReplacer, logLevel, indent, pagesArray, onBrowserLog, scale, timeoutInMilliseconds, composition, proxyPort, serveUrl, muted, envVariables, serializedInputPropsWithCustomSchema, imageFormat, serializedResolvedPropsWithCustomSchema, pageIndex, }) => {
+    const page = await browserReplacer
+        .getBrowser()
+        .newPage({ context, logLevel, indent, pageIndex });
+    pagesArray.push(page);
+    await page.setViewport({
+        width: composition.width,
+        height: composition.height,
+        deviceScaleFactor: scale,
+    });
+    const logCallback = (log) => {
+        onBrowserLog === null || onBrowserLog === void 0 ? void 0 : onBrowserLog({
+            stackTrace: log.stackTrace(),
+            text: log.text,
+            type: log.type,
+        });
+    };
+    if (onBrowserLog) {
+        page.on('console', logCallback);
+    }
+    await (0, set_props_and_env_1.setPropsAndEnv)({
+        serializedInputPropsWithCustomSchema,
+        envVariables,
+        page,
+        serveUrl,
+        initialFrame,
+        timeoutInMilliseconds,
+        proxyPort,
+        retriesRemaining: 2,
+        audioEnabled: !muted,
+        videoEnabled: imageFormat !== 'none',
+        indent,
+        logLevel,
+        onServeUrlVisited: () => undefined,
+    });
+    await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        // eslint-disable-next-line max-params
+        pageFunction: (id, props, durationInFrames, fps, height, width, defaultCodec) => {
+            window.remotion_setBundleMode({
+                type: 'composition',
+                compositionName: id,
+                serializedResolvedPropsWithSchema: props,
+                compositionDurationInFrames: durationInFrames,
+                compositionFps: fps,
+                compositionHeight: height,
+                compositionWidth: width,
+                compositionDefaultCodec: defaultCodec,
+            });
+        },
+        args: [
+            composition.id,
+            serializedResolvedPropsWithCustomSchema,
+            composition.durationInFrames,
+            composition.fps,
+            composition.height,
+            composition.width,
+            composition.defaultCodec,
+        ],
+        frame: null,
+        page,
+        timeoutInMilliseconds,
+    });
+    page.off('console', logCallback);
+    return page;
+};
+exports.makePage = makePage;

package/dist/next-frame-to-render.d.ts

@@ -0,0 +1,10 @@
+export declare const nextFrameToRenderState: ({ allFramesAndExtraFrames, concurrencyOrFramesToRender: _concurrency, }: {
+    allFramesAndExtraFrames: number[];
+    concurrencyOrFramesToRender: number;
+}) => {
+    getNextFrame: (_pageIndex: number) => number;
+};
+type Fn = typeof nextFrameToRenderState;
+export type NextFrameToRender = ReturnType<Fn>;
+export declare const partitionedNextFrameToRenderState: Fn;
+export {};

package/dist/next-frame-to-render.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partitionedNextFrameToRenderState = exports.nextFrameToRenderState = void 0;
+const render_partitions_1 = require("./render-partitions");
+const nextFrameToRenderState = ({ allFramesAndExtraFrames, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+concurrencyOrFramesToRender: _concurrency, }) => {
+    const rendered = new Map();
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        getNextFrame: (_pageIndex) => {
+            const nextFrame = allFramesAndExtraFrames.find((frame) => {
+                return !rendered.has(frame);
+            });
+            if (nextFrame === undefined) {
+                throw new Error('No more frames to render');
+            }
+            rendered.set(nextFrame, true);
+            return nextFrame;
+        },
+    };
+};
+exports.nextFrameToRenderState = nextFrameToRenderState;
+const partitionedNextFrameToRenderState = ({ allFramesAndExtraFrames, concurrencyOrFramesToRender: concurrency, }) => {
+    const partitions = (0, render_partitions_1.renderPartitions)({
+        frames: allFramesAndExtraFrames,
+        concurrency,
+    });
+    return {
+        getNextFrame: (pageIndex) => {
+            return partitions.getNextFrame(pageIndex);
+        },
+    };
+};
+exports.partitionedNextFrameToRenderState = partitionedNextFrameToRenderState;

package/dist/open-browser.js

@@ -51,7 +51,7 @@ const getOpenGlRenderer = (option) => {
     return [`--use-gl=${renderer}`];
 };
 const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, onBrowserDownload, chromeMode, }) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     // @ts-expect-error Firefox
     if (browser === 'firefox') {
         throw new TypeError('Firefox supported is not yet turned on. Stay tuned for the future.');
@@ -165,8 +165,8 @@ const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions
             deviceScaleFactor: 1,
         },
     });
-    const pages = await browserInstance.pages(logLevel, indent);
-    await pages[0].close();
+    const pages = await browserInstance.pages();
+    await ((_d = pages[0]) === null || _d === void 0 ? void 0 : _d.close());
     (0, browser_instances_1.addHeadlessBrowser)(browserInstance);
     return browserInstance;
 };

package/dist/options/gl.d.ts

@@ -1,7 +1,7 @@
 export declare const validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader", "vulkan", "angle-egl"];
 export type OpenGlRenderer = (typeof validOpenGlRenderers)[number];
 export declare const DEFAULT_OPENGL_RENDERER: OpenGlRenderer | null;
-export declare const getChromiumOpenGlRenderer: () => "angle" | "swangle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
+export declare const getChromiumOpenGlRenderer: () => "swangle" | "angle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
 export declare const setChromiumOpenGlRenderer: (renderer: OpenGlRenderer) => void;
 export declare const glOption: {
     cliFlag: "gl";

package/dist/options/index.d.ts

@@ -171,7 +171,7 @@ export declare const allOptions: {
     webhookCustomDataOption: {
         name: string;
         cliFlag: "webhook-custom-data";
-        description: (type: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+        description: (type: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
         ssrName: "customData";
         docLink: string;
         type: Record<string, unknown> | null;
@@ -584,7 +584,7 @@ export declare const allOptions: {
     metadataOption: {
         name: string;
         cliFlag: "metadata";
-        description: (mode: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+        description: (mode: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
         docLink: string;
         type: import("./metadata").Metadata;
         getValue: ({ commandLine }: {

package/dist/options/metadata.d.ts

@@ -2,7 +2,7 @@ export type Metadata = Record<string, string>;
 export declare const metadataOption: {
     name: string;
     cliFlag: "metadata";
-    description: (mode: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+    description: (mode: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
     docLink: string;
     type: Metadata;
     getValue: ({ commandLine }: {

package/dist/options/webhook-custom-data.d.ts

@@ -1,7 +1,7 @@
 export declare const webhookCustomDataOption: {
     name: string;
     cliFlag: "webhook-custom-data";
-    description: (type: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+    description: (type: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
     ssrName: "customData";
     docLink: string;
     type: Record<string, unknown> | null;

package/dist/pool.d.ts

@@ -1,7 +1,8 @@
-export declare class Pool<T> {
-    resources: T[];
-    waiters: ((r: T) => void)[];
-    constructor(resources: T[]);
-    acquire(): Promise<T>;
-    release(resource: T): void;
+import type { Page } from './browser/BrowserPage';
+export declare class Pool {
+    resources: Page[];
+    waiters: ((r: Page) => void)[];
+    constructor(resources: Page[]);
+    acquire(): Promise<Page>;
+    release(resource: Page): void;
 }

package/dist/render-frame-and-retry-target-close.d.ts

@@ -0,0 +1,50 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { HeadlessBrowser } from './browser/Browser';
+import type { Page } from './browser/BrowserPage';
+import type { CountType } from './get-frame-padded-index';
+import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { NextFrameToRender } from './next-frame-to-render';
+import type { Pool } from './pool';
+import type { FrameAndAssets, OnArtifact } from './render-frames';
+import type { BrowserReplacer } from './replace-browser';
+export declare const renderFrameAndRetryTargetClose: ({ retriesLeft, attempt, assets, imageFormat, binariesDirectory, cancelSignal, composition, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, onError, outputDir, poolPromise, scale, stoppedSignal, timeoutInMilliseconds, indent, logLevel, makeBrowser, makeNewPage, browserReplacer, concurrencyOrFramesToRender, framesRenderedObj, lastFrame, onFrameBuffer, onFrameUpdate, nextFrameToRender, }: {
+    retriesLeft: number;
+    attempt: number;
+    imageFormat: VideoImageFormat;
+    cancelSignal: CancelSignal | undefined;
+    binariesDirectory: string | null;
+    poolPromise: Promise<Pool>;
+    jpegQuality: number;
+    frameDir: string;
+    scale: number;
+    countType: CountType;
+    assets: FrameAndAssets[];
+    framesToRender: number[];
+    onArtifact: OnArtifact | null;
+    onDownload: RenderMediaOnDownload | null;
+    downloadMap: DownloadMap;
+    composition: Omit<VideoConfig, "defaultProps" | "props">;
+    onError: (err: Error) => void;
+    stoppedSignal: {
+        stopped: boolean;
+    };
+    timeoutInMilliseconds: number;
+    outputDir: string | null;
+    indent: boolean;
+    logLevel: LogLevel;
+    makeBrowser: () => Promise<HeadlessBrowser>;
+    makeNewPage: (frame: number, pageIndex: number) => Promise<Page>;
+    browserReplacer: BrowserReplacer;
+    concurrencyOrFramesToRender: number;
+    lastFrame: number;
+    framesRenderedObj: {
+        count: number;
+    };
+    onFrameBuffer: null | ((buffer: Buffer, frame: number) => void) | undefined;
+    onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
+    nextFrameToRender: NextFrameToRender;
+}) => Promise<void>;

package/dist/render-frame-and-retry-target-close.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFrameAndRetryTargetClose = void 0;
+const no_react_1 = require("remotion/no-react");
+const flaky_errors_1 = require("./browser/flaky-errors");
+const is_delay_render_error_with_retry_1 = require("./is-delay-render-error-with-retry");
+const logger_1 = require("./logger");
+const make_cancel_signal_1 = require("./make-cancel-signal");
+const render_frame_1 = require("./render-frame");
+const renderFrameAndRetryTargetClose = async ({ retriesLeft, attempt, assets, imageFormat, binariesDirectory, cancelSignal, composition, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, onError, outputDir, poolPromise, scale, stoppedSignal, timeoutInMilliseconds, indent, logLevel, makeBrowser, makeNewPage, browserReplacer, concurrencyOrFramesToRender, framesRenderedObj, lastFrame, onFrameBuffer, onFrameUpdate, nextFrameToRender, }) => {
+    var _a;
+    const currentPool = await poolPromise;
+    if (stoppedSignal.stopped) {
+        return;
+    }
+    const freePage = await currentPool.acquire();
+    const frame = nextFrameToRender.getNextFrame(freePage.pageIndex);
+    try {
+        await Promise.race([
+            (0, render_frame_1.renderFrame)({
+                attempt,
+                assets,
+                binariesDirectory,
+                cancelSignal,
+                countType,
+                downloadMap,
+                frameDir,
+                framesToRender,
+                imageFormat,
+                indent,
+                jpegQuality,
+                logLevel,
+                onArtifact,
+                onDownload,
+                scale,
+                composition,
+                framesRenderedObj,
+                lastFrame,
+                onError,
+                onFrameBuffer,
+                onFrameUpdate,
+                outputDir,
+                stoppedSignal,
+                timeoutInMilliseconds,
+                nextFrameToRender,
+                frame,
+                page: freePage,
+            }),
+            new Promise((_, reject) => {
+                cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+                    reject(new Error(make_cancel_signal_1.cancelErrorMessages.renderFrames));
+                });
+            }),
+        ]);
+        currentPool.release(freePage);
+    }
+    catch (err) {
+        const isTargetClosedError = (0, flaky_errors_1.isTargetClosedErr)(err);
+        const shouldRetryError = (_a = err.stack) === null || _a === void 0 ? void 0 : _a.includes(no_react_1.NoReactInternals.DELAY_RENDER_RETRY_TOKEN);
+        const flakyNetworkError = (0, flaky_errors_1.isFlakyNetworkError)(err);
+        if ((0, make_cancel_signal_1.isUserCancelledRender)(err) && !shouldRetryError) {
+            throw err;
+        }
+        if (!isTargetClosedError && !shouldRetryError && !flakyNetworkError) {
+            throw err;
+        }
+        if (stoppedSignal.stopped) {
+            return;
+        }
+        if (retriesLeft === 0) {
+            logger_1.Log.warn({
+                indent,
+                logLevel,
+            }, `The browser crashed ${attempt} times while rendering frame ${frame}. Not retrying anymore. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
+            throw err;
+        }
+        if (shouldRetryError) {
+            const pool = await poolPromise;
+            // Replace the closed page
+            const newPage = await makeNewPage(frame, freePage.pageIndex);
+            pool.release(newPage);
+            logger_1.Log.warn({ indent, logLevel }, `delayRender() timed out while rendering frame ${frame}: ${err.message}`);
+            const actualRetriesLeft = (0, is_delay_render_error_with_retry_1.getRetriesLeftFromError)(err);
+            return (0, exports.renderFrameAndRetryTargetClose)({
+                retriesLeft: actualRetriesLeft,
+                attempt: attempt + 1,
+                assets,
+                imageFormat,
+                binariesDirectory,
+                cancelSignal,
+                composition,
+                countType,
+                downloadMap,
+                frameDir,
+                framesToRender,
+                indent,
+                jpegQuality,
+                logLevel,
+                onArtifact,
+                onDownload,
+                onError,
+                outputDir,
+                poolPromise,
+                scale,
+                stoppedSignal,
+                timeoutInMilliseconds,
+                makeBrowser,
+                makeNewPage,
+                browserReplacer,
+                concurrencyOrFramesToRender,
+                framesRenderedObj,
+                lastFrame,
+                onFrameBuffer,
+                onFrameUpdate,
+                nextFrameToRender,
+            });
+        }
+        logger_1.Log.warn({ indent, logLevel }, `The browser crashed while rendering frame ${frame}, retrying ${retriesLeft} more times. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
+        // Replace the entire browser
+        await browserReplacer.replaceBrowser(makeBrowser, async () => {
+            const pages = new Array(concurrencyOrFramesToRender)
+                .fill(true)
+                .map((_, i) => makeNewPage(frame, i));
+            const puppeteerPages = await Promise.all(pages);
+            const pool = await poolPromise;
+            for (const newPage of puppeteerPages) {
+                pool.release(newPage);
+            }
+        });
+        await (0, exports.renderFrameAndRetryTargetClose)({
+            retriesLeft: retriesLeft - 1,
+            attempt: attempt + 1,
+            assets,
+            binariesDirectory,
+            cancelSignal,
+            composition,
+            countType,
+            downloadMap,
+            frameDir,
+            framesToRender,
+            imageFormat,
+            indent,
+            jpegQuality,
+            logLevel,
+            onArtifact,
+            makeBrowser,
+            onDownload,
+            onError,
+            outputDir,
+            poolPromise,
+            scale,
+            stoppedSignal,
+            timeoutInMilliseconds,
+            browserReplacer,
+            makeNewPage,
+            concurrencyOrFramesToRender,
+            framesRenderedObj,
+            lastFrame,
+            onFrameBuffer,
+            onFrameUpdate,
+            nextFrameToRender,
+        });
+    }
+};
+exports.renderFrameAndRetryTargetClose = renderFrameAndRetryTargetClose;

package/dist/render-frame-with-option-to-reject.d.ts

@@ -0,0 +1,43 @@
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { Page } from './browser/BrowserPage';
+import type { CountType } from './get-frame-padded-index';
+import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { FrameAndAssets, OnArtifact } from './render-frames';
+export declare const renderFrameWithOptionToReject: ({ reject, width, height, compId, attempt, stoppedSignal, indent, logLevel, timeoutInMilliseconds, outputDir, onFrameBuffer, imageFormat, onError, lastFrame, jpegQuality, frameDir, scale, countType, assets, framesToRender, onArtifact, onDownload, downloadMap, binariesDirectory, cancelSignal, framesRenderedObj, onFrameUpdate, frame, page, }: {
+    reject: (err: Error) => void;
+    width: number;
+    height: number;
+    compId: string;
+    attempt: number;
+    stoppedSignal: {
+        stopped: boolean;
+    };
+    timeoutInMilliseconds: number;
+    indent: boolean;
+    logLevel: LogLevel;
+    outputDir: string | null;
+    onFrameBuffer: null | ((buffer: Buffer, frame: number) => void) | undefined;
+    imageFormat: VideoImageFormat;
+    onError: (err: Error) => void;
+    lastFrame: number;
+    jpegQuality: number;
+    frameDir: string;
+    scale: number;
+    countType: CountType;
+    assets: FrameAndAssets[];
+    framesToRender: number[];
+    onArtifact: OnArtifact | null;
+    onDownload: RenderMediaOnDownload | null;
+    downloadMap: DownloadMap;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    framesRenderedObj: {
+        count: number;
+    };
+    onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
+    frame: number;
+    page: Page;
+}) => Promise<undefined>;