@remotion/renderer 4.0.255 → 4.0.257

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>;

package/dist/render-frame-with-option-to-reject.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFrameWithOptionToReject = void 0;
+const path_1 = __importDefault(require("path"));
+const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const compress_assets_1 = require("./compress-assets");
+const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const filter_asset_types_1 = require("./filter-asset-types");
+const get_frame_padded_index_1 = require("./get-frame-padded-index");
+const logger_1 = require("./logger");
+const perf_1 = require("./perf");
+const seek_to_frame_1 = require("./seek-to-frame");
+const take_frame_1 = require("./take-frame");
+const truthy_1 = require("./truthy");
+const renderFrameWithOptionToReject = async ({ 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, }) => {
+    const startTime = performance.now();
+    const index = framesToRender.indexOf(frame);
+    const assetsOnly = index === -1;
+    if (stoppedSignal.stopped) {
+        return Promise.reject(new Error('Render was stopped'));
+    }
+    const errorCallbackOnFrame = (err) => {
+        reject(err);
+    };
+    const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
+        page,
+        onError: errorCallbackOnFrame,
+        frame,
+    });
+    page.on('error', errorCallbackOnFrame);
+    const startSeeking = Date.now();
+    await (0, seek_to_frame_1.seekToFrame)({
+        frame,
+        page,
+        composition: compId,
+        timeoutInMilliseconds,
+        indent,
+        logLevel,
+        attempt,
+    });
+    const timeToSeek = Date.now() - startSeeking;
+    if (timeToSeek > 1000) {
+        logger_1.Log.verbose({ indent, logLevel }, `Seeking to frame ${frame} took ${timeToSeek}ms`);
+    }
+    if (!outputDir && !onFrameBuffer && imageFormat !== 'none') {
+        throw new Error('Called renderFrames() without specifying either `outputDir` or `onFrameBuffer`');
+    }
+    if (outputDir && onFrameBuffer && imageFormat !== 'none') {
+        throw new Error('Pass either `outputDir` or `onFrameBuffer` to renderFrames(), not both.');
+    }
+    const id = (0, perf_1.startPerfMeasure)('save');
+    const { buffer, collectedAssets } = await (0, take_frame_1.takeFrame)({
+        frame,
+        freePage: page,
+        height,
+        imageFormat: assetsOnly ? 'none' : imageFormat,
+        output: index === null
+            ? null
+            : path_1.default.join(frameDir, (0, get_frame_padded_index_1.getFrameOutputFileName)({
+                frame,
+                imageFormat,
+                index,
+                countType,
+                lastFrame,
+                totalFrames: framesToRender.length,
+            })),
+        jpegQuality,
+        width,
+        scale,
+        wantsBuffer: Boolean(onFrameBuffer),
+        timeoutInMilliseconds,
+    });
+    if (onFrameBuffer && !assetsOnly) {
+        if (!buffer) {
+            throw new Error('unexpected null buffer');
+        }
+        onFrameBuffer(buffer, frame);
+    }
+    (0, perf_1.stopPerfMeasure)(id);
+    const onlyAvailableAssets = assets.filter(truthy_1.truthy);
+    const previousAudioRenderAssets = onlyAvailableAssets
+        .map((a) => a.audioAndVideoAssets)
+        .flat(2);
+    const previousArtifactAssets = onlyAvailableAssets
+        .map((a) => a.artifactAssets)
+        .flat(2);
+    const audioAndVideoAssets = (0, filter_asset_types_1.onlyAudioAndVideoAssets)(collectedAssets);
+    const artifactAssets = (0, filter_asset_types_1.onlyArtifact)(collectedAssets);
+    for (const artifact of artifactAssets) {
+        for (const previousArtifact of previousArtifactAssets) {
+            if (artifact.filename === previousArtifact.filename) {
+                return Promise.reject(new Error(`An artifact with output "${artifact.filename}" was already registered at frame ${previousArtifact.frame}, but now registered again at frame ${artifact.frame}. Artifacts must have unique names. https://remotion.dev/docs/artifacts`));
+            }
+        }
+        onArtifact === null || onArtifact === void 0 ? void 0 : onArtifact(artifact);
+    }
+    const compressedAssets = audioAndVideoAssets.map((asset) => {
+        return (0, compress_assets_1.compressAsset)(previousAudioRenderAssets, asset);
+    });
+    assets.push({
+        audioAndVideoAssets: compressedAssets,
+        frame,
+        artifactAssets: artifactAssets.map((a) => {
+            return {
+                frame: a.frame,
+                filename: a.filename,
+            };
+        }),
+    });
+    for (const renderAsset of compressedAssets) {
+        (0, download_and_map_assets_to_file_1.downloadAndMapAssetsToFileUrl)({
+            renderAsset,
+            onDownload,
+            downloadMap,
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignalForAudioAnalysis: cancelSignal,
+            shouldAnalyzeAudioImmediately: true,
+        }).catch((err) => {
+            const truncateWithEllipsis = renderAsset.src.substring(0, 1000) +
+                (renderAsset.src.length > 1000 ? '...' : '');
+            onError(new Error(`Error while downloading ${truncateWithEllipsis}: ${err.stack}`));
+        });
+    }
+    cleanupPageError();
+    page.off('error', errorCallbackOnFrame);
+    if (!assetsOnly) {
+        framesRenderedObj.count++;
+        onFrameUpdate === null || onFrameUpdate === void 0 ? void 0 : onFrameUpdate(framesRenderedObj.count, frame, performance.now() - startTime);
+    }
+};
+exports.renderFrameWithOptionToReject = renderFrameWithOptionToReject;

package/dist/render-frame.d.ts

@@ -0,0 +1,43 @@
+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 { 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 { FrameAndAssets, OnArtifact } from './render-frames';
+export declare const renderFrame: ({ attempt, binariesDirectory, cancelSignal, imageFormat, indent, logLevel, assets, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, scale, composition, onError, outputDir, stoppedSignal, timeoutInMilliseconds, lastFrame, onFrameBuffer, onFrameUpdate, framesRenderedObj, frame, page, }: {
+    attempt: number;
+    indent: boolean;
+    logLevel: LogLevel;
+    imageFormat: VideoImageFormat;
+    cancelSignal: CancelSignal | undefined;
+    binariesDirectory: string | null;
+    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;
+    onFrameBuffer: null | ((buffer: Buffer, frame: number) => void) | undefined;
+    lastFrame: number;
+    onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
+    framesRenderedObj: {
+        count: number;
+    };
+    nextFrameToRender: NextFrameToRender;
+    frame: number;
+    page: Page;
+}) => Promise<void>;

package/dist/render-frame.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFrame = void 0;
+const render_frame_with_option_to_reject_1 = require("./render-frame-with-option-to-reject");
+const renderFrame = ({ attempt, binariesDirectory, cancelSignal, imageFormat, indent, logLevel, assets, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, scale, composition, onError, outputDir, stoppedSignal, timeoutInMilliseconds, lastFrame, onFrameBuffer, onFrameUpdate, framesRenderedObj, frame, page, }) => {
+    return new Promise((resolve, reject) => {
+        (0, render_frame_with_option_to_reject_1.renderFrameWithOptionToReject)({
+            reject,
+            width: composition.width,
+            height: composition.height,
+            compId: composition.id,
+            attempt,
+            indent,
+            logLevel,
+            stoppedSignal,
+            timeoutInMilliseconds,
+            imageFormat,
+            onFrameBuffer,
+            outputDir,
+            assets,
+            binariesDirectory,
+            cancelSignal,
+            countType,
+            downloadMap,
+            frameDir,
+            framesToRender,
+            jpegQuality,
+            lastFrame,
+            onArtifact,
+            onDownload,
+            onError,
+            scale,
+            framesRenderedObj,
+            onFrameUpdate,
+            frame,
+            page,
+        })
+            .then(() => {
+            resolve();
+        })
+            .catch((err) => {
+            reject(err);
+        });
+    });
+};
+exports.renderFrame = renderFrame;