@remotion/renderer 3.0.23 → 3.0.24

package/dist/puppeteer-evaluate.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from 'puppeteer-core';
+import type { Page } from './browser/Page';
 export declare function puppeteerEvaluateWithCatch<ReturnType>({ page, pageFunction, frame, args, }: {
     page: Page;
     pageFunction: Function | string;

package/dist/puppeteer-evaluate.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.puppeteerEvaluateWithCatch = void 0;
-const puppeteer_core_1 = require("puppeteer-core");
+const JSHandle_1 = require("./browser/JSHandle");
 const symbolicateable_error_1 = require("./error-handling/symbolicateable-error");
 const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
 const EVALUATION_SCRIPT_URL = '__puppeteer_evaluation_script__';
@@ -32,7 +32,7 @@ function isString(obj) {
 async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, }) {
     var _a, _b, _c, _d, _e, _f, _g;
     const contextId = (await page.mainFrame().executionContext())._contextId;
-    const client = page._client;
+    const client = page._client();
     const suffix = `//# sourceURL=${EVALUATION_SCRIPT_URL}`;
     if (isString(pageFunction)) {
         const expression = pageFunction;
@@ -139,7 +139,7 @@ function convertArgument(arg) {
         return { unserializableValue: '-Infinity' };
     if (Object.is(arg, NaN))
         return { unserializableValue: 'NaN' };
-    const objectHandle = arg && arg instanceof puppeteer_core_1.JSHandle ? arg : null;
+    const objectHandle = arg && arg instanceof JSHandle_1.JSHandle ? arg : null;
     if (objectHandle) {
         if (objectHandle._disposed)
             throw new Error('JSHandle is disposed!');

package/dist/puppeteer-screenshot.d.ts

@@ -1,2 +1,3 @@
-import type { Page, ScreenshotOptions } from 'puppeteer-core';
-export declare const screenshot: (page: Page, options?: ScreenshotOptions) => Promise<Buffer | string | void>;
+import type { Page } from './browser/Page';
+import type { ScreenshotOptions } from './browser/ScreenshotOptions';
+export declare const screenshot: (page: Page, options: ScreenshotOptions) => Promise<Buffer | string | void>;

package/dist/puppeteer-screenshot.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.screenshot = void 0;
 const assert = __importStar(require("assert"));
 const screenshot_task_1 = require("./screenshot-task");
-const screenshot = (page, options = {}) => {
+const screenshot = (page, options) => {
     let screenshotType = null;
     // options.type takes precedence over inferring the type from options.path
     // because it may be a 0-length file with no extension created beforehand
@@ -58,7 +58,6 @@ const screenshot = (page, options = {}) => {
         assert.ok(options.quality >= 0 && options.quality <= 100, 'Expected options.quality to be between 0 and 100 (inclusive), got ' +
             options.quality);
     }
-    assert.ok(!options.clip || !options.fullPage, 'options.clip and options.fullPage are exclusive');
     if (options.clip) {
         assert.ok(typeof options.clip.x === 'number', 'Expected options.clip.x to be a number but found ' +
             typeof options.clip.x);
@@ -71,7 +70,6 @@ const screenshot = (page, options = {}) => {
         assert.ok(options.clip.width !== 0, 'Expected options.clip.width not to be 0.');
         assert.ok(options.clip.height !== 0, 'Expected options.clip.height not to be 0.');
     }
-    // @ts-expect-error
-    return page._screenshotTaskQueue.postTask(() => (0, screenshot_task_1._screenshotTask)(page, screenshotType, options));
+    return page.screenshotTaskQueue.postTask(() => (0, screenshot_task_1._screenshotTask)(page, screenshotType, options));
 };
 exports.screenshot = screenshot;

package/dist/render-frames.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import type { Browser as PuppeteerBrowser } from 'puppeteer-core';
 import type { BrowserExecutable, FfmpegExecutable, FrameRange, ImageFormat, SmallTCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { BrowserLog } from './browser-log';
+import type { Browser } from './browser/Browser';
 import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
@@ -26,7 +26,7 @@ declare type RenderFramesOptions = {
     quality?: number;
     frameRange?: FrameRange | null;
     dumpBrowserLogs?: boolean;
-    puppeteerInstance?: PuppeteerBrowser;
+    puppeteerInstance?: Browser;
     browserExecutable?: BrowserExecutable;
     onBrowserLog?: (log: BrowserLog) => void;
     onFrameBuffer?: (buffer: Buffer, frame: number) => void;

package/dist/render-frames.js

@@ -49,6 +49,7 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
             });
         }
     }
+    const downloadPromises = [];
     const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange !== null && frameRange !== void 0 ? frameRange : null);
     const frameCount = (0, get_duration_from_frame_range_1.getDurationFromFrameRange)(realFrameRange, composition.durationInFrames);
     const pages = new Array(actualParallelism).fill(true).map(async () => {
@@ -62,8 +63,8 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         const logCallback = (log) => {
             onBrowserLog === null || onBrowserLog === void 0 ? void 0 : onBrowserLog({
                 stackTrace: log.stackTrace(),
-                text: log.text(),
-                type: log.type(),
+                text: log.text,
+                type: log.type,
             });
         };
         if (onBrowserLog) {
@@ -142,7 +143,7 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
                     quality,
                     options: {
                         frame,
-                        output: undefined,
+                        output: null,
                     },
                 });
                 remotion_1.Internals.perf.stopPerfMeasure(id);
@@ -175,13 +176,13 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         const compressedAssets = collectedAssets.map((asset) => remotion_1.Internals.AssetCompression.compressAsset(assets.filter(remotion_1.Internals.truthy).flat(1), asset));
         assets[index] = compressedAssets;
         compressedAssets.forEach((asset) => {
-            (0, download_and_map_assets_to_file_1.downloadAndMapAssetsToFileUrl)({
+            downloadPromises.push((0, download_and_map_assets_to_file_1.downloadAndMapAssetsToFileUrl)({
                 asset,
                 downloadDir,
                 onDownload,
             }).catch((err) => {
                 onError(new Error(`Error while downloading asset: ${err.stack}`));
-            });
+            }));
         });
         pool.release(freePage);
         framesRendered++;
@@ -203,7 +204,11 @@ const innerRenderFrames = ({ onFrameUpdate, outputDir, onStart, inputProps, qual
         return returnValue;
     });
     return Promise.race([
-        happyPath,
+        happyPath
+            .then(() => {
+            return Promise.all(downloadPromises);
+        })
+            .then(() => happyPath),
         new Promise((_resolve, reject) => {
             cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
                 reject(new Error('renderFrames() got cancelled'));
@@ -240,7 +245,9 @@ const renderFrames = (options) => {
     return new Promise((resolve, reject) => {
         var _a, _b, _c;
         const cleanup = [];
-        const onError = (err) => reject(err);
+        const onError = (err) => {
+            reject(err);
+        };
         Promise.all([
             (0, prepare_server_1.prepareServer)({
                 webpackConfigOrServeUrl: selectedServeUrl,
@@ -262,7 +269,7 @@ const renderFrames = (options) => {
                 closeServer();
             });
             cleanup.push(closeServer);
-            const renderFramesProm = innerRenderFrames({
+            return innerRenderFrames({
                 ...options,
                 puppeteerInstance,
                 onError,
@@ -274,9 +281,10 @@ const renderFrames = (options) => {
                 downloadDir,
                 proxyPort: offthreadPort,
             });
-            return renderFramesProm;
         })
-            .then((res) => resolve(res))
+            .then((res) => {
+            return resolve(res);
+        })
             .catch((err) => reject(err))
             .finally(() => {
             // If browser instance was passed in, we close all the pages

package/dist/render-gif.d.ts

@@ -0,0 +1,2 @@
+import { RenderMediaOptions } from './render-media';
+export declare const renderGif: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, loop, skipNFrames, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<void>;

package/dist/render-gif.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGif = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
+const ensure_frames_in_order_1 = require("./ensure-frames-in-order");
+const ensure_output_directory_1 = require("./ensure-output-directory");
+const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const get_extension_of_filename_1 = require("./get-extension-of-filename");
+const get_frame_to_render_1 = require("./get-frame-to-render");
+const legacy_webpack_config_1 = require("./legacy-webpack-config");
+const make_cancel_signal_1 = require("./make-cancel-signal");
+const prespawn_ffmpeg_1 = require("./prespawn-ffmpeg");
+const render_frames_1 = require("./render-frames");
+const stitch_frames_to_gif_1 = require("./stitch-frames-to-gif");
+const tmp_dir_1 = require("./tmp-dir");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const validate_output_filename_1 = require("./validate-output-filename");
+const validate_scale_1 = require("./validate-scale");
+const renderGif = ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, loop, skipNFrames, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }) => {
+    remotion_1.Internals.validateQuality(quality);
+    if (typeof crf !== 'undefined' && crf !== null) {
+        remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
+    }
+    (0, validate_output_filename_1.validateOutputFilename)(codec, (0, get_extension_of_filename_1.getExtensionOfFilename)(outputLocation));
+    (0, validate_scale_1.validateScale)(scale);
+    const serveUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
+    let stitchStage = 'encoding';
+    let stitcherFfmpeg;
+    let preStitcher = null;
+    let encodedFrames = 0;
+    let renderedFrames = 0;
+    let renderedDoneIn = null;
+    let encodedDoneIn = null;
+    let cancelled = false;
+    const renderStart = Date.now();
+    const tmpdir = (0, tmp_dir_1.tmpDir)('pre-encode');
+    const parallelEncoding = (0, can_use_parallel_encoding_1.canUseParallelEncoding)(codec);
+    const actualImageFormat = imageFormat !== null && imageFormat !== void 0 ? imageFormat : 'jpeg';
+    const preEncodedFileLocation = parallelEncoding
+        ? path_1.default.join(tmpdir, 'pre-encode.' + (0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, 'chunk'))
+        : null;
+    const outputDir = parallelEncoding
+        ? null
+        : fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'react-motion-render'));
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        codec,
+        height: composition.height,
+        scale: scale !== null && scale !== void 0 ? scale : 1,
+        width: composition.width,
+    });
+    const callUpdate = () => {
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+            encodedDoneIn,
+            encodedFrames,
+            renderedDoneIn,
+            renderedFrames,
+            stitchStage,
+        });
+    };
+    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange !== null && frameRange !== void 0 ? frameRange : null);
+    const cancelRenderFrames = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelPrestitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelStitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+        cancelRenderFrames.cancel();
+    });
+    const { waitForRightTimeOfFrameToBeInserted, setFrameToStitch, waitForFinish } = (0, ensure_frames_in_order_1.ensureFramesInOrder)(realFrameRange);
+    const actualGifFps = Math.floor(composition.fps / (skipNFrames + 1));
+    const createPrestitcherIfNecessary = async () => {
+        if (preEncodedFileLocation) {
+            preStitcher = await (0, prespawn_ffmpeg_1.prespawnFfmpeg)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation: preEncodedFileLocation,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                onProgress: (frame) => {
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                ffmpegExecutable,
+                imageFormat: actualImageFormat,
+                signal: cancelPrestitcher.cancelSignal,
+            });
+            stitcherFfmpeg = preStitcher.task;
+        }
+    };
+    const waitForPrestitcherIfNecessary = async () => {
+        var _a;
+        if (stitcherFfmpeg) {
+            await waitForFinish();
+            (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.end();
+            try {
+                await stitcherFfmpeg;
+            }
+            catch (err) {
+                throw new Error(preStitcher === null || preStitcher === void 0 ? void 0 : preStitcher.getLogs());
+            }
+        }
+    };
+    const happyPath = createPrestitcherIfNecessary()
+        .then(() => {
+        const renderFramesProc = (0, render_frames_1.renderFrames)({
+            config: composition,
+            onFrameUpdate: (frame) => {
+                stitchStage = 'gif';
+                renderedFrames = frame;
+                callUpdate();
+            },
+            parallelism,
+            outputDir,
+            skipNFrames,
+            onStart: (data) => {
+                renderedFrames = 0;
+                callUpdate();
+                onStart === null || onStart === void 0 ? void 0 : onStart(data);
+            },
+            inputProps,
+            envVariables,
+            imageFormat: actualImageFormat,
+            quality,
+            frameRange: frameRange !== null && frameRange !== void 0 ? frameRange : null,
+            puppeteerInstance,
+            onFrameBuffer: parallelEncoding
+                ? async (buffer, frame) => {
+                    var _a;
+                    await waitForRightTimeOfFrameToBeInserted(frame);
+                    if (cancelled) {
+                        return;
+                    }
+                    (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.write(buffer);
+                    setFrameToStitch(frame + 1);
+                }
+                : undefined,
+            serveUrl,
+            dumpBrowserLogs,
+            onBrowserLog,
+            onDownload,
+            timeoutInMilliseconds,
+            chromiumOptions,
+            scale,
+            ffmpegExecutable,
+            browserExecutable,
+            port,
+            cancelSignal: cancelRenderFrames.cancelSignal,
+        });
+        return renderFramesProc;
+    })
+        .then((renderFramesReturn) => {
+        return Promise.all([renderFramesReturn, waitForPrestitcherIfNecessary()]);
+    })
+        .then(([{ assetsInfo }]) => {
+        renderedDoneIn = Date.now() - renderStart;
+        callUpdate();
+        (0, ensure_output_directory_1.ensureOutputDirectory)(outputLocation);
+        const stitchStart = Date.now();
+        return Promise.all([
+            (0, stitch_frames_to_gif_1.stitchFramesToGif)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation,
+                internalOptions: {
+                    preEncodedFileLocation,
+                    imageFormat: actualImageFormat,
+                },
+                force: overwrite !== null && overwrite !== void 0 ? overwrite : remotion_1.Internals.DEFAULT_OVERWRITE,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                loop,
+                assetsInfo,
+                ffmpegExecutable,
+                onProgress: (frame) => {
+                    stitchStage = 'gif';
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                dir: outputDir !== null && outputDir !== void 0 ? outputDir : undefined,
+                cancelSignal: cancelStitcher.cancelSignal,
+            }),
+            stitchStart,
+        ]);
+    })
+        .then(([, stitchStart]) => {
+        encodedFrames = (0, get_duration_from_frame_range_1.getDurationFromFrameRange)(frameRange !== null && frameRange !== void 0 ? frameRange : null, composition.durationInFrames, skipNFrames);
+        encodedDoneIn = Date.now() - stitchStart;
+        callUpdate();
+    })
+        .catch((err) => {
+        /**
+         * When an error is thrown in renderFrames(...) (e.g., when delayRender() is used incorrectly), fs.unlinkSync(...) throws an error that the file is locked because ffmpeg is still running, and renderMedia returns it.
+         * Therefore we first kill the FFMPEG process before deleting the file
+         */
+        cancelled = true;
+        cancelRenderFrames.cancel();
+        cancelStitcher.cancel();
+        cancelPrestitcher.cancel();
+        if (stitcherFfmpeg !== undefined && stitcherFfmpeg.exitCode === null) {
+            const promise = new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                }, 2000);
+                stitcherFfmpeg.on('close', resolve);
+            });
+            stitcherFfmpeg.kill();
+            return promise.then(() => {
+                throw err;
+            });
+        }
+        throw err;
+    })
+        .finally(() => {
+        if (preEncodedFileLocation !== null &&
+            fs_1.default.existsSync(preEncodedFileLocation)) {
+            fs_1.default.unlinkSync(preEncodedFileLocation);
+        }
+    });
+    return Promise.race([
+        happyPath,
+        new Promise((_resolve, reject) => {
+            cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+                reject(new Error('renderMedia() got cancelled'));
+            });
+        }),
+    ]);
+};
+exports.renderGif = renderGif;

package/dist/render-media.d.ts

@@ -1,7 +1,7 @@
-import type { Browser as PuppeteerBrowser } from 'puppeteer-core';
 import type { BrowserExecutable, Codec, FfmpegExecutable, FrameRange, PixelFormat, ProResProfile, SmallTCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { BrowserLog } from './browser-log';
+import type { Browser as PuppeteerBrowser } from './browser/Browser';
 import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';

package/dist/render-still.d.ts

@@ -1,6 +1,6 @@
-import type { Browser as PuppeteerBrowser } from 'puppeteer-core';
 import type { BrowserExecutable, FfmpegExecutable, SmallTCompMetadata, StillImageFormat } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { Browser as PuppeteerBrowser } from './browser/Browser';
 import type { ServeUrlOrWebpackBundle } from './legacy-webpack-config';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';

package/dist/screenshot-dom-element.d.ts

@@ -1,11 +1,10 @@
-import type puppeteer from 'puppeteer-core';
 import type { ImageFormat } from 'remotion';
+import type { Page } from './browser/Page';
 export declare const screenshotDOMElement: ({ page, imageFormat, quality, opts, }: {
-    page: puppeteer.Page;
+    page: Page;
     imageFormat: ImageFormat;
     quality: number | undefined;
-    opts?: {
-        path?: string | undefined;
-        selector?: string | undefined;
-    } | undefined;
+    opts: {
+        path: string | null;
+    };
 }) => Promise<Buffer>;

package/dist/screenshot-dom-element.js

@@ -3,11 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.screenshotDOMElement = void 0;
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const puppeteer_screenshot_1 = require("./puppeteer-screenshot");
-const screenshotDOMElement = async ({ page, imageFormat, quality, opts = {}, }) => {
-    const path = 'path' in opts ? opts.path : undefined;
-    const { selector } = opts;
-    if (!selector)
-        throw Error('Please provide a selector.');
+const screenshotDOMElement = async ({ page, imageFormat, quality, opts, }) => {
+    const { path } = opts;
     if (imageFormat === 'png') {
         await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
             pageFunction: () => {
@@ -33,7 +30,7 @@ const screenshotDOMElement = async ({ page, imageFormat, quality, opts = {}, })
     }
     return (0, puppeteer_screenshot_1.screenshot)(page, {
         omitBackground: imageFormat === 'png',
-        path,
+        path: path !== null && path !== void 0 ? path : undefined,
         type: imageFormat,
         quality,
     });

package/dist/screenshot-task.d.ts

@@ -1,3 +1,4 @@
-import type { Page, ScreenshotOptions } from 'puppeteer-core';
 import type { StillImageFormat } from 'remotion';
+import type { Page } from './browser/Page';
+import type { ScreenshotOptions } from './browser/ScreenshotOptions';
 export declare const _screenshotTask: (page: Page, format: StillImageFormat, options: ScreenshotOptions) => Promise<Buffer | string>;

package/dist/screenshot-task.js

@@ -7,8 +7,8 @@ exports._screenshotTask = void 0;
 const fs_1 = __importDefault(require("fs"));
 const remotion_1 = require("remotion");
 const _screenshotTask = async (page, format, options) => {
-    const client = page._client;
-    const target = page._target;
+    const client = page._client();
+    const target = page.target();
     const perfTarget = remotion_1.Internals.perf.startPerfMeasure('activate-target');
     await client.send('Target.activateTarget', {
         targetId: target._targetId,
@@ -30,9 +30,7 @@ const _screenshotTask = async (page, format, options) => {
     if (shouldSetDefaultBackground)
         await client.send('Emulation.setDefaultBackgroundColorOverride');
     const saveMarker = remotion_1.Internals.perf.startPerfMeasure('save');
-    const buffer = options.encoding === 'base64'
-        ? result.data
-        : Buffer.from(result.data, 'base64');
+    const buffer = Buffer.from(result.data, 'base64');
     if (options.path)
         await fs_1.default.promises.writeFile(options.path, buffer);
     remotion_1.Internals.perf.stopPerfMeasure(saveMarker);

package/dist/seek-to-frame.d.ts

@@ -1,5 +1,5 @@
-import type puppeteer from 'puppeteer-core';
+import type { Page } from './browser/Page';
 export declare const seekToFrame: ({ frame, page, }: {
     frame: number;
-    page: puppeteer.Page;
+    page: Page;
 }) => Promise<void>;

package/dist/set-props-and-env.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from 'puppeteer-core';
+import type { Page } from './browser/Page';
 export declare const setPropsAndEnv: ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, proxyPort, retriesRemaining, }: {
     inputProps: unknown;
     envVariables: Record<string, string> | undefined;

package/dist/set-props-and-env.js

@@ -31,6 +31,9 @@ const setPropsAndEnv = async ({ inputProps, envVariables, page, serveUrl, initia
         window.remotion_proxyPort = port;
     }, [proxyPort]);
     const pageRes = await page.goto(urlToVisit);
+    if (pageRes === null) {
+        throw new Error(`Visited "${urlToVisit}" but got no response.`);
+    }
     const status = pageRes.status();
     // S3 in rare occasions returns a 500 or 503 error code for GET operations.
     // Usually it is fixed by retrying.

package/dist/should-use-vp9-decoder.js

@@ -0,0 +1 @@
+"use strict";

package/dist/stitch-frames-to-gif.d.ts

@@ -0,0 +1,8 @@
+import { StitcherOptions } from './stitch-frames-to-video';
+declare type ReturnType = {
+    task: Promise<unknown>;
+    getLogs: () => string;
+};
+export declare const spawnFfmpeg: (options: StitcherOptions) => Promise<ReturnType>;
+export declare const stitchFramesToGif: (options: StitcherOptions) => Promise<void>;
+export {};