@remotion/renderer 4.0.356 → 4.0.358

package/package/dist/serve-static.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const get_port_1 = require("./get-port");
+const offthread_video_server_1 = require("./offthread-video-server");
+const port_config_1 = require("./port-config");
+const serve_handler_1 = require("./serve-handler");
+const serveStatic = async (path, options) => {
+    const { listener: offthreadRequest, close: closeCompositor, compositor, } = (0, offthread_video_server_1.startOffthreadVideoServer)({
+        downloadMap: options.downloadMap,
+        offthreadVideoThreads: options.offthreadVideoThreads,
+        logLevel: options.logLevel,
+        indent: options.indent,
+        offthreadVideoCacheSizeInBytes: options.offthreadVideoCacheSizeInBytes,
+        binariesDirectory: options.binariesDirectory,
+    });
+    const connections = {};
+    const server = node_http_1.default.createServer((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,
+        }).catch(() => {
+            if (!response.headersSent) {
+                response.writeHead(500);
+            }
+            response.end('Error serving file');
+        });
+    });
+    server.on('connection', (conn) => {
+        let key;
+        // Bun 1.0.43 fails on this
+        try {
+            key = conn.remoteAddress + ':' + conn.remotePort;
+        }
+        catch (_a) {
+            key = ':';
+        }
+        connections[key] = conn;
+        conn.on('close', () => {
+            delete connections[key];
+        });
+    });
+    let selectedPort = null;
+    const maxTries = 10;
+    const portConfig = (0, port_config_1.getPortConfig)(options.forceIPv4);
+    for (let i = 0; i < maxTries; i++) {
+        let unlock = () => { };
+        try {
+            selectedPort = await new Promise((resolve, reject) => {
+                var _a;
+                (0, get_port_1.getDesiredPort)({
+                    desiredPort: (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : undefined,
+                    from: 3000,
+                    to: 3100,
+                    hostsToTry: portConfig.hostsToTry,
+                })
+                    .then(({ port, unlockPort }) => {
+                    unlock = unlockPort;
+                    server.listen({ port, host: portConfig.host });
+                    server.on('listening', () => {
+                        resolve(port);
+                        return unlock();
+                    });
+                    server.on('error', (err) => {
+                        unlock();
+                        reject(err);
+                    });
+                })
+                    .catch((err) => {
+                    unlock();
+                    return reject(err);
+                });
+            });
+            const destroyConnections = function () {
+                for (const key in connections)
+                    connections[key].destroy();
+            };
+            const close = async () => {
+                await Promise.all([
+                    new Promise((resolve, reject) => {
+                        // compositor may have already quit before,
+                        // this is okay as we are in cleanup phase
+                        closeCompositor()
+                            .catch((err) => {
+                            if (err.message.includes('Compositor quit')) {
+                                resolve();
+                                return;
+                            }
+                            reject(err);
+                        })
+                            .finally(() => {
+                            resolve();
+                        });
+                    }),
+                    new Promise((resolve, reject) => {
+                        destroyConnections();
+                        server.close((err) => {
+                            if (err) {
+                                if (err.code ===
+                                    'ERR_SERVER_NOT_RUNNING') {
+                                    return resolve();
+                                }
+                                reject(err);
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    }),
+                ]);
+            };
+            return { port: selectedPort, close, compositor };
+        }
+        catch (err) {
+            if (!(err instanceof Error)) {
+                throw err;
+            }
+            const codedError = err;
+            if (codedError.code === 'EADDRINUSE') {
+                // Already in use, try another port
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    throw new Error(`Tried ${maxTries} times to find a free port. Giving up.`);
+};
+exports.serveStatic = serveStatic;

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

@@ -0,0 +1,22 @@
+import type { Page } from './browser/BrowserPage';
+import type { LogLevel } from './log-level';
+type SetPropsAndEnv = {
+    serializedInputPropsWithCustomSchema: string;
+    envVariables: Record<string, string> | undefined;
+    page: Page;
+    serveUrl: string;
+    initialFrame: number;
+    timeoutInMilliseconds: number | undefined;
+    proxyPort: number;
+    retriesRemaining: number;
+    audioEnabled: boolean;
+    videoEnabled: boolean;
+    indent: boolean;
+    logLevel: LogLevel;
+    onServeUrlVisited: () => void;
+    isMainTab: boolean;
+    mediaCacheSizeInBytes: number | null;
+    initialMemoryAvailable: number | null;
+};
+export declare const setPropsAndEnv: (params: SetPropsAndEnv) => Promise<unknown>;
+export {};

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

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPropsAndEnv = void 0;
+const version_1 = require("remotion/version");
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
+const goto_page_or_throw_1 = require("./goto-page-or-throw");
+const logger_1 = require("./logger");
+const normalize_serve_url_1 = require("./normalize-serve-url");
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const redirect_status_codes_1 = require("./redirect-status-codes");
+const truthy_1 = require("./truthy");
+const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
+const innerSetPropsAndEnv = async ({ serializedInputPropsWithCustomSchema, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, proxyPort, retriesRemaining, audioEnabled, videoEnabled, indent, logLevel, onServeUrlVisited, isMainTab, mediaCacheSizeInBytes, initialMemoryAvailable, }) => {
+    (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
+    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, mainTab, cacheSizeInBytes, initMemoryAvailable) => {
+        window.remotion_puppeteerTimeout = timeout;
+        window.remotion_isMainTab = mainTab;
+        window.remotion_mediaCacheSizeInBytes = cacheSizeInBytes;
+        window.remotion_initialMemoryAvailable = initMemoryAvailable;
+        // To make useRemotionEnvironment() work
+        if (window.process === undefined) {
+            // @ts-expect-error
+            window.process = {};
+        }
+        if (window.process.env === undefined) {
+            window.process.env = {};
+        }
+        window.process.env.NODE_ENV = 'production';
+    }, actualTimeout, isMainTab, mediaCacheSizeInBytes, initialMemoryAvailable);
+    await page.evaluateOnNewDocument('window.remotion_broadcastChannel = new BroadcastChannel("remotion-video-frame-extraction")');
+    if (envVariables) {
+        await page.evaluateOnNewDocument((input) => {
+            window.remotion_envVariables = input;
+        }, JSON.stringify(envVariables));
+    }
+    await page.evaluateOnNewDocument((input, key, port, audEnabled, vidEnabled, level) => {
+        window.remotion_inputProps = input;
+        window.remotion_initialFrame = key;
+        window.remotion_attempt = 1;
+        window.remotion_proxyPort = port;
+        window.remotion_audioEnabled = audEnabled;
+        window.remotion_videoEnabled = vidEnabled;
+        window.remotion_logLevel = level;
+        window.alert = (message) => {
+            if (message) {
+                window.window.remotion_cancelledError = new Error(`alert("${message}") was called. It cannot be called in a headless browser.`).stack;
+            }
+            else {
+                window.window.remotion_cancelledError = new Error('alert() was called. It cannot be called in a headless browser.').stack;
+            }
+        };
+        window.confirm = (message) => {
+            if (message) {
+                window.remotion_cancelledError = new Error(`confirm("${message}") was called. It cannot be called in a headless browser.`).stack;
+            }
+            else {
+                window.remotion_cancelledError = new Error('confirm() was called. It cannot be called in a headless browser.').stack;
+            }
+            return false;
+        };
+    }, serializedInputPropsWithCustomSchema, initialFrame, proxyPort, audioEnabled, videoEnabled, logLevel);
+    const retry = async () => {
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, 2000);
+        });
+        return innerSetPropsAndEnv({
+            envVariables,
+            initialFrame,
+            serializedInputPropsWithCustomSchema,
+            page,
+            proxyPort,
+            retriesRemaining: retriesRemaining - 1,
+            serveUrl,
+            timeoutInMilliseconds,
+            audioEnabled,
+            videoEnabled,
+            indent,
+            logLevel,
+            onServeUrlVisited,
+            isMainTab,
+            mediaCacheSizeInBytes,
+            initialMemoryAvailable,
+        });
+    };
+    const [pageRes, error] = await (0, goto_page_or_throw_1.gotoPageOrThrow)(page, urlToVisit, actualTimeout);
+    if (error !== null) {
+        if (error.message.includes('ECONNRESET') ||
+            error.message.includes('ERR_CONNECTION_TIMED_OUT')) {
+            return retry();
+        }
+        throw error;
+    }
+    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) {
+        return retry();
+    }
+    if (!redirect_status_codes_1.redirectStatusCodes.every((code) => code !== status)) {
+        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?`);
+    }
+    onServeUrlVisited();
+    const { value: isRemotionFn } = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        pageFunction: () => {
+            return window.getStaticCompositions;
+        },
+        args: [],
+        frame: null,
+        page,
+        timeoutInMilliseconds: actualTimeout,
+    });
+    if (typeof isRemotionFn === 'undefined') {
+        const { value: body } = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+            pageFunction: () => {
+                return document.body.innerHTML;
+            },
+            args: [],
+            frame: null,
+            page,
+            timeoutInMilliseconds: actualTimeout,
+        });
+        // AWS shakyness
+        if (body.includes('We encountered an internal error.')) {
+            return retry();
+        }
+        const errorMessage = [
+            `Error while getting compositions: Tried to go to ${urlToVisit} and verify that it is a Remotion project by checking if window.getStaticCompositions is defined.`,
+            'However, the function was undefined, which indicates that this is not a valid Remotion project. Please check the URL you passed.',
+            'The page loaded contained the following markup:',
+            body.substring(0, 500) + (body.length > 500 ? '...' : ''),
+            'Does this look like a foreign page? If so, try to stop this server.',
+        ].join('\n');
+        throw new Error(errorMessage);
+    }
+    const { value: siteVersion } = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        pageFunction: () => {
+            return window.siteVersion;
+        },
+        args: [],
+        frame: null,
+        page,
+        timeoutInMilliseconds: actualTimeout,
+    });
+    const { value: remotionVersion } = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        pageFunction: () => {
+            return window.remotion_version;
+        },
+        args: [],
+        frame: null,
+        page,
+        timeoutInMilliseconds: actualTimeout,
+    });
+    const requiredVersion = '11';
+    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:`,
+            'When using server-side rendering:',
+            ` ▸ Use 'bundle()' with '@remotion/bundler' of version ${version_1.VERSION} to create a compatible bundle.`,
+            'When using the Remotion Lambda:',
+            ' ▸ Use `npx remotion lambda sites create` to redeploy the site with the latest version.',
+            ' ℹ Use --site-name with the same name as before to overwrite your site.',
+            ' ▸ Use `deploySite()` if you are using the Node.JS APIs.',
+        ].join('\n'));
+    }
+    if (remotionVersion !== version_1.VERSION && process.env.NODE_ENV !== 'test') {
+        if (remotionVersion) {
+            logger_1.Log.warn({
+                indent,
+                logLevel,
+            }, [
+                `The site was bundled with version ${remotionVersion} of @remotion/bundler, while @remotion/renderer is on version ${version_1.VERSION}. You may not have the newest bugfixes and features.`,
+                `To resolve this warning:`,
+                '▸ Use `npx remotion lambda sites create` to redeploy the site with the latest version.',
+                '  ℹ Use --site-name with the same name as before to overwrite your site.',
+                '▸ Use `deploySite()` if you are using the Node.JS APIs.',
+            ].join('\n'));
+        }
+        else {
+            logger_1.Log.warn({
+                indent,
+                logLevel,
+            }, `The site was bundled with an old version of Remotion, while @remotion/renderer is on version ${version_1.VERSION}. You may not have the newest bugfixes and features. Re-bundle the site to fix this issue.`);
+        }
+    }
+};
+const setPropsAndEnv = async (params) => {
+    let timeout = null;
+    try {
+        const result = await Promise.race([
+            innerSetPropsAndEnv(params),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => {
+                    reject(new Error([
+                        `Timed out after ${params.timeoutInMilliseconds}ms while setting up the headless browser.`,
+                        'This could be because the you specified takes a long time to load (or network resources that it includes like fonts) or because the browser is not responding.',
+                        process.platform === 'linux'
+                            ? 'Make sure you have installed the Linux depdendencies: https://www.remotion.dev/docs/miscellaneous/linux-dependencies'
+                            : null,
+                    ]
+                        .filter(truthy_1.truthy)
+                        .join('\n')));
+                }, params.timeoutInMilliseconds);
+            }),
+        ]);
+        return result;
+    }
+    finally {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+    }
+};
+exports.setPropsAndEnv = setPropsAndEnv;

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

@@ -0,0 +1,77 @@
+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 { FfmpegOverrideFn } from './ffmpeg-override';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { AudioCodec } from './options/audio-codec';
+import { type ColorSpace } from './options/color-space';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
+import type { X264Preset } from './options/x264-preset';
+import type { PixelFormat } from './pixel-format';
+import type { ProResProfile } from './prores-profile';
+type InternalStitchFramesToVideoOptions = {
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    maxRate: string | null;
+    bufferSize: string | null;
+    fps: number;
+    width: number;
+    height: number;
+    outputLocation: string | null;
+    force: boolean;
+    assetsInfo: RenderAssetInfo;
+    pixelFormat: PixelFormat;
+    numberOfGifLoops: number | null;
+    codec: Codec;
+    audioCodec: AudioCodec | null;
+    crf: number | null;
+    onProgress?: null | ((progress: number) => void);
+    onDownload: undefined | RenderMediaOnDownload;
+    proResProfile: undefined | ProResProfile;
+    logLevel: LogLevel;
+    cancelSignal: CancelSignal | null;
+    preEncodedFileLocation: string | null;
+    preferLossless: boolean;
+    indent: boolean;
+    muted: boolean;
+    x264Preset: X264Preset | null;
+    enforceAudioTrack: boolean;
+    ffmpegOverride: null | FfmpegOverrideFn;
+    colorSpace: ColorSpace | null;
+    binariesDirectory: string | null;
+    metadata: Record<string, string> | null;
+} & ToOptions<typeof optionsMap.stitchFramesToVideo>;
+export type StitchFramesToVideoOptions = {
+    fps: number;
+    width: number;
+    height: number;
+    assetsInfo: RenderAssetInfo;
+    force?: boolean;
+    audioBitrate?: string | null;
+    videoBitrate?: string | null;
+    maxRate?: string | null;
+    bufferSize?: string | null;
+    outputLocation?: string | null;
+    pixelFormat?: PixelFormat;
+    numberOfGifLoops?: number | null;
+    codec?: Codec;
+    audioCodec?: AudioCodec | null;
+    crf?: number | null;
+    onProgress?: (progress: number) => void;
+    onDownload?: RenderMediaOnDownload;
+    proResProfile?: ProResProfile;
+    verbose?: boolean;
+    cancelSignal?: CancelSignal;
+    muted?: boolean;
+    enforceAudioTrack?: boolean;
+    ffmpegOverride?: FfmpegOverrideFn;
+    x264Preset?: X264Preset | null;
+    colorSpace?: ColorSpace;
+    binariesDirectory?: string | null;
+    metadata?: Record<string, string> | null;
+} & Partial<ToOptions<typeof optionsMap.stitchFramesToVideo>>;
+export declare const internalStitchFramesToVideo: (options: InternalStitchFramesToVideoOptions) => Promise<Buffer | null>;
+export declare const stitchFramesToVideo: ({ assetsInfo, force, fps, height, width, audioBitrate, audioCodec, cancelSignal, codec, crf, enforceAudioTrack, ffmpegOverride, muted, numberOfGifLoops, onDownload, onProgress, outputLocation, pixelFormat, proResProfile, verbose, videoBitrate, maxRate, bufferSize, x264Preset, colorSpace, binariesDirectory, separateAudioTo, metadata, hardwareAcceleration, }: StitchFramesToVideoOptions) => Promise<Buffer | null>;
+export {};