@remotion/renderer 4.0.357 → 4.0.358

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

@@ -0,0 +1,179 @@
+"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, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }) => {
+    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)({
+                trimLeftOffset,
+                trimRightOffset,
+                allFramesAndExtraFrames,
+                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,
+                imageSequencePattern,
+            }),
+            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);
+            nextFrameToRender.returnFrame(frame);
+            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,
+                imageSequencePattern,
+                trimLeftOffset,
+                trimRightOffset,
+                allFramesAndExtraFrames,
+            });
+        }
+        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);
+            }
+        });
+        nextFrameToRender.returnFrame(frame);
+        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,
+            imageSequencePattern,
+            trimLeftOffset,
+            trimRightOffset,
+            allFramesAndExtraFrames,
+        });
+    }
+};
+exports.renderFrameAndRetryTargetClose = renderFrameAndRetryTargetClose;

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

@@ -0,0 +1,48 @@
+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, imageSequencePattern, fps, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }: {
+    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;
+    imageSequencePattern: string | null;
+    fps: number;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    allFramesAndExtraFrames: number[];
+}) => Promise<undefined>;

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

@@ -0,0 +1,156 @@
+"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 collect_assets_1 = require("./collect-assets");
+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 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, imageSequencePattern, fps, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }) => {
+    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 [buffer, collectedAssets] = await Promise.all([
+        (0, take_frame_1.takeFrame)({
+            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,
+                    imageSequencePattern,
+                })),
+            jpegQuality,
+            width,
+            scale,
+            wantsBuffer: Boolean(onFrameBuffer),
+            timeoutInMilliseconds,
+        }),
+        (0, collect_assets_1.collectAssets)({
+            frame,
+            freePage: page,
+            timeoutInMilliseconds,
+        }),
+    ]);
+    if (onFrameBuffer && !assetsOnly) {
+        if (!buffer) {
+            throw new Error('unexpected null buffer');
+        }
+        onFrameBuffer(buffer, frame);
+    }
+    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)({
+        assets: collectedAssets,
+        frameBuffer: buffer,
+    });
+    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);
+    });
+    const inlineAudioAssets = (0, filter_asset_types_1.onlyInlineAudio)(collectedAssets);
+    assets.push({
+        audioAndVideoAssets: compressedAssets,
+        frame,
+        artifactAssets: artifactAssets.map((a) => {
+            return {
+                frame: a.frame,
+                filename: a.filename,
+            };
+        }),
+        inlineAudioAssets,
+    });
+    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}`));
+        });
+    }
+    for (const renderAsset of inlineAudioAssets) {
+        downloadMap.inlineAudioMixing.addAsset({
+            asset: renderAsset,
+            fps,
+            totalNumberOfFrames: allFramesAndExtraFrames.length,
+            firstFrame: allFramesAndExtraFrames[0],
+            trimLeftOffset,
+            trimRightOffset,
+        });
+    }
+    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/package/dist/render-frame.d.ts

@@ -0,0 +1,47 @@
+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, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }: {
+    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;
+    imageSequencePattern: string | null;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    allFramesAndExtraFrames: number[];
+}) => Promise<void>;

package/package/dist/render-frame.js

@@ -0,0 +1,51 @@
+"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, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }) => {
+    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,
+            imageSequencePattern,
+            fps: composition.fps,
+            trimLeftOffset,
+            trimRightOffset,
+            allFramesAndExtraFrames,
+        })
+            .then(() => {
+            resolve();
+        })
+            .catch((err) => {
+            reject(err);
+        });
+    });
+};
+exports.renderFrame = renderFrame;

package/package/dist/render-frames.d.ts

@@ -0,0 +1,97 @@
+import type { AudioOrVideoAsset, InlineAudioAsset, VideoConfig } from 'remotion/no-react';
+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 { OnLog } from './browser/BrowserPage';
+import type { FrameRange } from './frame-range';
+import type { VideoImageFormat } from './image-format';
+import type { CancelSignal } from './make-cancel-signal';
+import type { ChromiumOptions } from './open-browser';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
+import type { RemotionServer } from './prepare-server';
+import type { EmittedArtifact } from './serialize-artifact';
+import type { OnStartData, RenderFramesOutput } from './types';
+export type OnArtifact = (asset: EmittedArtifact) => void;
+type InternalRenderFramesOptions = {
+    onStart: null | ((data: OnStartData) => void);
+    onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
+    outputDir: string | null;
+    envVariables: Record<string, string>;
+    imageFormat: VideoImageFormat;
+    jpegQuality: number;
+    frameRange: FrameRange | null;
+    everyNthFrame: number;
+    puppeteerInstance: HeadlessBrowser | undefined;
+    browserExecutable: BrowserExecutable | null;
+    onBrowserLog: null | ((log: BrowserLog) => void);
+    onFrameBuffer: null | ((buffer: Buffer, frame: number) => void);
+    onDownload: RenderMediaOnDownload | null;
+    chromiumOptions: ChromiumOptions;
+    scale: number;
+    port: number | null;
+    cancelSignal: CancelSignal | undefined;
+    composition: Omit<VideoConfig, 'props' | 'defaultProps'>;
+    indent: boolean;
+    server: RemotionServer | undefined;
+    muted: boolean;
+    concurrency: number | string | null;
+    webpackBundleOrServeUrl: string;
+    serializedInputPropsWithCustomSchema: string;
+    serializedResolvedPropsWithCustomSchema: string;
+    parallelEncodingEnabled: boolean;
+    compositionStart: number;
+    onArtifact: OnArtifact | null;
+    onLog: OnLog;
+} & ToOptions<typeof optionsMap.renderFrames>;
+type ArtifactWithoutContent = {
+    frame: number;
+    filename: string;
+};
+export type FrameAndAssets = {
+    frame: number;
+    audioAndVideoAssets: AudioOrVideoAsset[];
+    artifactAssets: ArtifactWithoutContent[];
+    inlineAudioAssets: InlineAudioAsset[];
+};
+export type RenderFramesOptions = {
+    onStart: (data: OnStartData) => void;
+    onFrameUpdate: (framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void;
+    outputDir: string | null;
+    inputProps: Record<string, unknown>;
+    envVariables?: Record<string, string>;
+    imageFormat?: VideoImageFormat;
+    /**
+     * @deprecated Renamed to "jpegQuality"
+     */
+    quality?: never;
+    frameRange?: FrameRange | null;
+    everyNthFrame?: number;
+    /**
+     * @deprecated Use "logLevel": "verbose" instead
+     */
+    dumpBrowserLogs?: boolean;
+    /**
+     * @deprecated Use "logLevel" instead
+     */
+    verbose?: boolean;
+    puppeteerInstance?: HeadlessBrowser;
+    browserExecutable?: BrowserExecutable;
+    onBrowserLog?: (log: BrowserLog) => void;
+    onFrameBuffer?: (buffer: Buffer, frame: number) => void;
+    onDownload?: RenderMediaOnDownload;
+    timeoutInMilliseconds?: number;
+    chromiumOptions?: ChromiumOptions;
+    scale?: number;
+    port?: number | null;
+    cancelSignal?: CancelSignal;
+    composition: VideoConfig;
+    muted?: boolean;
+    concurrency?: number | string | null;
+    onArtifact?: OnArtifact | null;
+    serveUrl: string;
+} & Partial<ToOptions<typeof optionsMap.renderFrames>>;
+export declare const internalRenderFrames: (args_0: InternalRenderFramesOptions) => Promise<RenderFramesOutput>;
+export declare const renderFrames: (options: RenderFramesOptions) => Promise<RenderFramesOutput>;
+export {};