@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-forcepublish.7

package/dist/screenshot-task.js

@@ -5,37 +5,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._screenshotTask = void 0;
 const fs_1 = __importDefault(require("fs"));
-const remotion_1 = require("remotion");
+const perf_1 = require("./perf");
 const _screenshotTask = async (page, format, options) => {
-    const client = page._client;
-    const target = page._target;
-    const perfTarget = remotion_1.Internals.perf.startPerfMeasure('activate-target');
+    var _a;
+    const client = page._client();
+    const target = page.target();
+    const perfTarget = (0, perf_1.startPerfMeasure)('activate-target');
     await client.send('Target.activateTarget', {
         targetId: target._targetId,
     });
-    remotion_1.Internals.perf.stopPerfMeasure(perfTarget);
+    (0, perf_1.stopPerfMeasure)(perfTarget);
     const shouldSetDefaultBackground = options.omitBackground && format === 'png';
     if (shouldSetDefaultBackground)
         await client.send('Emulation.setDefaultBackgroundColorOverride', {
             color: { r: 0, g: 0, b: 0, a: 0 },
         });
-    const cap = remotion_1.Internals.perf.startPerfMeasure('capture');
-    const result = await client.send('Page.captureScreenshot', {
-        format,
-        quality: options.quality,
-        clip: undefined,
-        captureBeyondViewport: true,
-    });
-    remotion_1.Internals.perf.stopPerfMeasure(cap);
-    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');
-    if (options.path)
-        await fs_1.default.promises.writeFile(options.path, buffer);
-    remotion_1.Internals.perf.stopPerfMeasure(saveMarker);
-    return buffer;
+    const cap = (0, perf_1.startPerfMeasure)('capture');
+    try {
+        const result = await client.send('Page.captureScreenshot', {
+            format,
+            quality: options.quality,
+            clip: undefined,
+            captureBeyondViewport: true,
+        });
+        (0, perf_1.stopPerfMeasure)(cap);
+        if (shouldSetDefaultBackground)
+            await client.send('Emulation.setDefaultBackgroundColorOverride');
+        const saveMarker = (0, perf_1.startPerfMeasure)('save');
+        const buffer = Buffer.from(result.data, 'base64');
+        if (options.path)
+            await fs_1.default.promises.writeFile(options.path, buffer);
+        (0, perf_1.stopPerfMeasure)(saveMarker);
+        return buffer;
+    }
+    catch (err) {
+        if (err.message.includes('Unable to capture screenshot')) {
+            const errMessage = [
+                'Could not take a screenshot because Google Chrome ran out of memory or disk space.',
+                ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.REMOTION_LAMBDA)
+                    ? 'Deploy a new Lambda function with more memory or disk space.'
+                    : 'Decrease the concurrency to use less RAM.',
+            ].join(' ');
+            throw new Error(errMessage);
+        }
+        throw err;
+    }
 };
 exports._screenshotTask = _screenshotTask;

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

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

package/dist/seek-to-frame.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.seekToFrame = void 0;
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const seekToFrame = async ({ frame, page, }) => {
-    await page.waitForFunction('window.ready === true');
+    await page.waitForFunction(page.browser, 'window.ready === true');
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         pageFunction: (f) => {
             window.remotion_setFrame(f);
@@ -12,7 +12,7 @@ const seekToFrame = async ({ frame, page, }) => {
         frame,
         page,
     });
-    await page.waitForFunction('window.ready === true');
+    await page.waitForFunction(page.browser, 'window.ready === true');
     await page.evaluateHandle('document.fonts.ready');
 };
 exports.seekToFrame = seekToFrame;

package/dist/serve-handler/index.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+export declare const serveHandler: (request: IncomingMessage, response: ServerResponse, config: {
+    public: string;
+}) => Promise<void>;

package/dist/serve-handler/index.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveHandler = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+const mime_types_1 = require("../mime-types");
+// Packages
+const is_path_inside_1 = require("./is-path-inside");
+const range_parser_1 = require("./range-parser");
+const getHeaders = (absolutePath, stats) => {
+    const { base } = path_1.default.parse(absolutePath);
+    let defaultHeaders = {};
+    if (stats) {
+        defaultHeaders = {
+            'Content-Length': String(stats.size),
+            'Accept-Ranges': 'bytes',
+        };
+        defaultHeaders['Last-Modified'] = stats.mtime.toUTCString();
+        const _contentType = (0, mime_types_1.mimeContentType)(base);
+        if (_contentType) {
+            defaultHeaders['Content-Type'] = _contentType;
+        }
+    }
+    return defaultHeaders;
+};
+const getPossiblePaths = (relativePath, extension) => [
+    path_1.default.join(relativePath, `index${extension}`),
+    relativePath.endsWith('/')
+        ? relativePath.replace(/\/$/g, extension)
+        : relativePath + extension,
+].filter((item) => path_1.default.basename(item) !== extension);
+const findRelated = async (current, relativePath) => {
+    const possible = getPossiblePaths(relativePath, '.html');
+    let stats = null;
+    for (let index = 0; index < possible.length; index++) {
+        const related = possible[index];
+        const absolutePath = path_1.default.join(current, related);
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                throw err;
+            }
+        }
+        if (stats) {
+            return {
+                stats,
+                absolutePath,
+            };
+        }
+    }
+    return null;
+};
+const sendError = (absolutePath, response, spec) => {
+    const { message, statusCode } = spec;
+    response.statusCode = statusCode;
+    const headers = getHeaders(absolutePath, null);
+    response.writeHead(statusCode, headers);
+    response.setHeader('content-type', 'application/json');
+    response.end(JSON.stringify({ statusCode, message }));
+};
+const internalError = (absolutePath, response) => {
+    return sendError(absolutePath, response, {
+        statusCode: 500,
+        code: 'internal_server_error',
+        message: 'A server error has occurred',
+    });
+};
+const serveHandler = async (request, response, config) => {
+    const cwd = process.cwd();
+    const current = path_1.default.resolve(cwd, config.public);
+    let relativePath = null;
+    try {
+        relativePath = decodeURIComponent(url_1.default.parse(request.url).pathname);
+    }
+    catch (err) {
+        return sendError('/', response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let absolutePath = path_1.default.join(current, relativePath);
+    // Prevent path traversal vulnerabilities. We could do this
+    // by ourselves, but using the package covers all the edge cases.
+    if (!(0, is_path_inside_1.isPathInside)(absolutePath, current)) {
+        return sendError(absolutePath, response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let stats = null;
+    // It's extremely important that we're doing multiple stat calls. This one
+    // right here could technically be removed, but then the program
+    // would be slower. Because for directories, we always want to see if a related file
+    // exists and then (after that), fetch the directory itself if no
+    // related file was found. However (for files, of which most have extensions), we should
+    // always stat right away.
+    //
+    // When simulating a file system without directory indexes, calculating whether a
+    // directory exists requires loading all the file paths and then checking if
+    // one of them includes the path of the directory. As that's a very
+    // performance-expensive thing to do, we need to ensure it's not happening if not really necessary.
+    if (path_1.default.extname(relativePath) !== '') {
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (!stats) {
+        try {
+            const related = await findRelated(current, relativePath);
+            if (related) {
+                ({ stats, absolutePath } = related);
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (stats === null || stats === void 0 ? void 0 : stats.isDirectory()) {
+        const directory = null;
+        const singleFile = null;
+        if (directory) {
+            const _contentType = 'text/html; charset=utf-8';
+            response.statusCode = 200;
+            response.setHeader('Content-Type', _contentType);
+            response.end('Is a directory');
+            return;
+        }
+        if (!singleFile) {
+            // The directory listing is disabled, so we want to
+            // render a 404 error.
+            stats = null;
+        }
+    }
+    const isSymLink = stats === null || stats === void 0 ? void 0 : stats.isSymbolicLink();
+    // There are two scenarios in which we want to reply with
+    // a 404 error: Either the path does not exist, or it is a
+    // symlink while the `symlinks` option is disabled (which it is by default).
+    if (!stats || isSymLink) {
+        // allow for custom 404 handling
+        return sendError(absolutePath, response, {
+            statusCode: 404,
+            code: 'not_found',
+            message: 'The requested path could not be found',
+        });
+    }
+    let streamOpts = null;
+    if (request.headers.range && stats.size) {
+        const range = (0, range_parser_1.rangeParser)(stats.size, request.headers.range);
+        if (typeof range === 'object' && range.type === 'bytes') {
+            const { start, end } = range.ranges[0];
+            streamOpts = {
+                start,
+                end,
+            };
+            response.statusCode = 206;
+        }
+        else {
+            response.statusCode = 416;
+            response.setHeader('Content-Range', `bytes */${stats.size}`);
+        }
+    }
+    let stream = null;
+    try {
+        stream = (0, fs_1.createReadStream)(absolutePath, streamOpts !== null && streamOpts !== void 0 ? streamOpts : {});
+    }
+    catch (err) {
+        return internalError(absolutePath, response);
+    }
+    const headers = getHeaders(absolutePath, stats);
+    if (streamOpts !== null) {
+        headers['Content-Range'] = `bytes ${streamOpts.start}-${streamOpts.end}/${stats.size}`;
+        headers['Content-Length'] = String(streamOpts.end - streamOpts.start + 1);
+    }
+    response.writeHead(response.statusCode || 200, headers);
+    stream.pipe(response);
+};
+exports.serveHandler = serveHandler;

package/dist/serve-handler/is-path-inside.d.ts

@@ -0,0 +1 @@
+export declare const isPathInside: (thePath: string, potentialParent: string) => boolean;

package/dist/serve-handler/is-path-inside.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathInside = void 0;
+const path_1 = __importDefault(require("path"));
+const isPathInside = function (thePath, potentialParent) {
+    // For inside-directory checking, we want to allow trailing slashes, so normalize.
+    thePath = stripTrailingSep(thePath);
+    potentialParent = stripTrailingSep(potentialParent);
+    // Node treats only Windows as case-insensitive in its path module; we follow those conventions.
+    if (process.platform === 'win32') {
+        thePath = thePath.toLowerCase();
+        potentialParent = potentialParent.toLowerCase();
+    }
+    return (thePath.lastIndexOf(potentialParent, 0) === 0 &&
+        (thePath[potentialParent.length] === path_1.default.sep ||
+            thePath[potentialParent.length] === undefined));
+};
+exports.isPathInside = isPathInside;
+function stripTrailingSep(thePath) {
+    if (thePath[thePath.length - 1] === path_1.default.sep) {
+        return thePath.slice(0, -1);
+    }
+    return thePath;
+}

package/dist/serve-handler/range-parser.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+export declare const rangeParser: (size: number, str: string) => -1 | {
+    type: string;
+    ranges: {
+        start: number;
+        end: number;
+    }[];
+} | -2;

package/dist/serve-handler/range-parser.js

@@ -0,0 +1,57 @@
+"use strict";
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeParser = void 0;
+const rangeParser = (size, str) => {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const index = str.indexOf('=');
+    if (index === -1) {
+        return -2;
+    }
+    // split the range string
+    const arr = str.slice(index + 1).split(',');
+    const ranges = [];
+    // add ranges type
+    const type = str.slice(0, index);
+    // parse all ranges
+    for (let i = 0; i < arr.length; i++) {
+        const range = arr[i].split('-');
+        let start = parseInt(range[0], 10);
+        let end = parseInt(range[1], 10);
+        // -nnn
+        if (isNaN(start)) {
+            start = size - end;
+            end = size - 1;
+            // nnn-
+        }
+        else if (isNaN(end)) {
+            end = size - 1;
+        }
+        // limit last-byte-pos to current length
+        if (end > size - 1) {
+            end = size - 1;
+        }
+        // invalid or unsatisifiable
+        if (isNaN(start) || isNaN(end) || start > end || start < 0) {
+            continue;
+        }
+        // add range
+        ranges.push({
+            start,
+            end,
+        });
+    }
+    if (ranges.length < 1) {
+        // unsatisifiable
+        return -1;
+    }
+    return { ranges, type };
+};
+exports.rangeParser = rangeParser;

package/dist/serve-static.d.ts

@@ -1,6 +1,14 @@
-export declare const serveStatic: (path: string, options?: {
-    port?: number | undefined;
-} | undefined) => Promise<{
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const serveStatic: (path: string | null, options: {
+    port: number | null;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+    onDownload: RenderMediaOnDownload;
+    onError: (err: Error) => void;
+    downloadMap: DownloadMap;
+}) => Promise<{
     port: number;
     close: () => Promise<void>;
 }>;

package/dist/serve-static.js

@@ -5,29 +5,59 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serveStatic = void 0;
 const http_1 = __importDefault(require("http"));
-const remotion_1 = require("remotion");
-const serve_handler_1 = __importDefault(require("serve-handler"));
 const get_port_1 = require("./get-port");
+const offthread_video_server_1 = require("./offthread-video-server");
+const serve_handler_1 = require("./serve-handler");
 const serveStatic = async (path, options) => {
-    var _a, _b;
-    const port = await (0, get_port_1.getDesiredPort)((_b = (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : remotion_1.Internals.getServerPort()) !== null && _b !== void 0 ? _b : undefined, 3000, 3100);
+    var _a;
+    const port = await (0, get_port_1.getDesiredPort)((_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : undefined, 3000, 3100);
+    const offthreadRequest = (0, offthread_video_server_1.startOffthreadVideoServer)({
+        ffmpegExecutable: options.ffmpegExecutable,
+        ffprobeExecutable: options.ffprobeExecutable,
+        onDownload: options.onDownload,
+        onError: options.onError,
+        downloadMap: options.downloadMap,
+    });
     try {
+        const connections = {};
         const server = http_1.default
             .createServer((request, response) => {
-            (0, serve_handler_1.default)(request, response, {
+            var _a;
+            if ((_a = request.url) === null || _a === void 0 ? void 0 : _a.startsWith('/proxy')) {
+                return offthreadRequest(request, response);
+            }
+            if (path === null) {
+                response.writeHead(404);
+                response.end('Server only supports /proxy');
+                return;
+            }
+            (0, serve_handler_1.serveHandler)(request, response, {
                 public: path,
-                directoryListing: false,
-                cleanUrls: false,
             }).catch(() => {
                 response.statusCode = 500;
                 response.end('Error serving file');
             });
         })
             .listen(port);
+        server.on('connection', (conn) => {
+            const key = conn.remoteAddress + ':' + conn.remotePort;
+            connections[key] = conn;
+            conn.on('close', () => {
+                delete connections[key];
+            });
+        });
+        const destroyConnections = function () {
+            for (const key in connections)
+                connections[key].destroy();
+        };
         const close = () => {
             return new Promise((resolve, reject) => {
+                destroyConnections();
                 server.close((err) => {
                     if (err) {
+                        if (err.code === 'ERR_SERVER_NOT_RUNNING') {
+                            return resolve();
+                        }
                         reject(err);
                     }
                     else {

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

@@ -1,9 +1,13 @@
-import { Page } from 'puppeteer-core';
-export declare const setPropsAndEnv: ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, }: {
+import type { Page } from './browser/BrowserPage';
+export declare const setPropsAndEnv: ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, proxyPort, retriesRemaining, audioEnabled, videoEnabled, }: {
     inputProps: unknown;
     envVariables: Record<string, string> | undefined;
     page: Page;
     serveUrl: string;
     initialFrame: number;
     timeoutInMilliseconds: number | undefined;
+    proxyPort: number;
+    retriesRemaining: number;
+    audioEnabled: boolean;
+    videoEnabled: boolean;
 }) => Promise<void>;

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

@@ -1,39 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setPropsAndEnv = void 0;
-const remotion_1 = require("remotion");
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const normalize_serve_url_1 = require("./normalize-serve-url");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
-const setPropsAndEnv = async ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, }) => {
+const setPropsAndEnv = async ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, proxyPort, retriesRemaining, audioEnabled, videoEnabled, }) => {
     (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
-    const actualTimeout = timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : remotion_1.Internals.DEFAULT_PUPPETEER_TIMEOUT;
+    const actualTimeout = timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT;
     page.setDefaultTimeout(actualTimeout);
     page.setDefaultNavigationTimeout(actualTimeout);
     const urlToVisit = (0, normalize_serve_url_1.normalizeServeUrl)(serveUrl);
     await page.evaluateOnNewDocument((timeout) => {
         window.remotion_puppeteerTimeout = timeout;
-    }, [actualTimeout]);
+    }, actualTimeout);
     if (inputProps) {
         await page.evaluateOnNewDocument((input) => {
             window.remotion_inputProps = input;
-        }, [JSON.stringify(inputProps)]);
+        }, JSON.stringify(inputProps));
     }
     if (envVariables) {
         await page.evaluateOnNewDocument((input) => {
             window.remotion_envVariables = input;
-        }, [JSON.stringify(envVariables)]);
+        }, JSON.stringify(envVariables));
     }
-    await page.evaluateOnNewDocument((key, value) => {
-        window.localStorage.setItem(key, value);
-    }, [remotion_1.Internals.INITIAL_FRAME_LOCAL_STORAGE_KEY, initialFrame]);
+    await page.evaluateOnNewDocument((key) => {
+        window.remotion_initialFrame = key;
+    }, initialFrame);
+    await page.evaluateOnNewDocument((port) => {
+        window.remotion_proxyPort = port;
+    }, proxyPort);
+    await page.evaluateOnNewDocument((enabled) => {
+        window.remotion_audioEnabled = enabled;
+    }, audioEnabled);
+    await page.evaluateOnNewDocument((enabled) => {
+        window.remotion_videoEnabled = enabled;
+    }, videoEnabled);
     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.
+    if (status >= 500 && status <= 504 && retriesRemaining > 0) {
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, 2000);
+        });
+        return (0, exports.setPropsAndEnv)({
+            envVariables,
+            initialFrame,
+            inputProps,
+            page,
+            proxyPort,
+            retriesRemaining: retriesRemaining - 1,
+            serveUrl,
+            timeoutInMilliseconds,
+            audioEnabled,
+            videoEnabled,
+        });
+    }
     if (status !== 200 &&
         status !== 301 &&
         status !== 302 &&
         status !== 303 &&
-        status !== 304) {
+        status !== 304 &&
+        status !== 307 &&
+        status !== 308) {
         throw new Error(`Error while getting compositions: Tried to go to ${urlToVisit} but the status code was ${status} instead of 200. Does the site you specified exist?`);
     }
     const isRemotionFn = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
@@ -55,8 +90,9 @@ const setPropsAndEnv = async ({ inputProps, envVariables, page, serveUrl, initia
         frame: null,
         page,
     });
-    if (siteVersion !== '2') {
-        throw new Error(`Incompatible site: When visiting ${urlToVisit}, a bundle was found, but one that is not compatible with this version of Remotion. The bundle format changed in versions from March 2022 onwards. To resolve this error, please bundle and deploy again.`);
+    const requiredVersion = '4';
+    if (siteVersion !== requiredVersion) {
+        throw new Error(`Incompatible site: When visiting ${urlToVisit}, a bundle was found, but one that is not compatible with this version of Remotion. Found version: ${siteVersion} - Required version: ${requiredVersion}. To resolve this error, please bundle and deploy again.`);
     }
 };
 exports.setPropsAndEnv = setPropsAndEnv;

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

@@ -1,13 +1,21 @@
-import { Codec, FfmpegExecutable, ImageFormat, PixelFormat, ProResProfile, RenderAssetInfo } from 'remotion';
-import { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+/// <reference types="node" />
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { RenderAssetInfo } from './assets/download-map';
+import type { Codec } from './codec';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { ImageFormat } from './image-format';
+import type { CancelSignal } from './make-cancel-signal';
+import type { PixelFormat } from './pixel-format';
+import type { ProResProfile } from './prores-profile';
 export declare type StitcherOptions = {
     fps: number;
     width: number;
     height: number;
-    outputLocation: string;
+    outputLocation?: string | null;
     force: boolean;
     assetsInfo: RenderAssetInfo;
     pixelFormat?: PixelFormat;
+    numberOfGifLoops?: number | null;
     codec?: Codec;
     crf?: number | null;
     onProgress?: (progress: number) => void;
@@ -15,16 +23,20 @@ export declare type StitcherOptions = {
     proResProfile?: ProResProfile;
     verbose?: boolean;
     ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
     dir?: string;
+    cancelSignal?: CancelSignal;
     internalOptions?: {
         preEncodedFileLocation: string | null;
         imageFormat: ImageFormat;
     };
+    muted?: boolean;
+    enforceAudioTrack?: boolean;
 };
 declare type ReturnType = {
-    task: Promise<unknown>;
+    task: Promise<Buffer | null>;
     getLogs: () => string;
 };
 export declare const spawnFfmpeg: (options: StitcherOptions) => Promise<ReturnType>;
-export declare const stitchFramesToVideo: (options: StitcherOptions) => Promise<void>;
+export declare const stitchFramesToVideo: (options: StitcherOptions) => Promise<Buffer | null>;
 export {};