@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha4

package/dist/ffmpeg-flags.js

@@ -3,31 +3,81 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFfmpegVersion = exports.parseFfmpegVersion = exports.ffmpegHasFeature = exports.getFfmpegBuildInfo = void 0;
+exports.warnAboutFfmpegVersion = exports.getBinaryDownloadUrl = exports.getExecutableBinary = exports.lambdaFfmpegPaths = exports.downloadBinary = exports.getFfmpegVersion = exports.parseFfmpegVersion = exports.ffmpegHasFeature = exports.ffmpegInNodeModules = exports.getFfmpegBuildInfo = void 0;
 const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const BrowserFetcher_1 = require("./browser/BrowserFetcher");
 const validate_ffmpeg_1 = require("./validate-ffmpeg");
 let buildConfig = null;
+const listeners = {};
+const isDownloading = {};
 const getFfmpegBuildInfo = async (options) => {
-    var _a;
     if (buildConfig !== null) {
         return buildConfig;
     }
-    const data = await (0, execa_1.default)((_a = options.ffmpegExecutable) !== null && _a !== void 0 ? _a : 'ffmpeg', ['-buildconf'], {
+    const data = await (0, execa_1.default)(await (0, exports.getExecutableBinary)(options.ffmpegExecutable, options.remotionRoot, 'ffmpeg'), ['-buildconf'], {
         reject: false,
     });
     buildConfig = data.stderr;
     return buildConfig;
 };
 exports.getFfmpegBuildInfo = getFfmpegBuildInfo;
-const ffmpegHasFeature = async ({ ffmpegExecutable, feature, isLambda, }) => {
-    if (isLambda) {
-        // When rendering in the cloud, we don't need a local binary
-        return true;
+const getFfmpegFolderName = (remotionRoot) => {
+    return path_1.default.resolve(remotionRoot, 'node_modules/.ffmpeg');
+};
+const binaryPrefix = { ffmpeg: 'ffmpeg-', ffprobe: 'ffprobe-' };
+const randomFfmpegRuntimeId = String(Math.random()).replace('0.', '');
+const ffmpegInNodeModules = (remotionRoot, binary) => {
+    const folderName = getFfmpegFolderName(remotionRoot);
+    if (!fs_1.default.existsSync(folderName)) {
+        fs_1.default.mkdirSync(folderName, {
+            recursive: true,
+        });
+    }
+    // Check if a version of FFMPEG is already installed.
+    // To qualify, it must have the expected file size
+    // to avoid finding binaries that are still being downloaded
+    // A random ID is being assigned to the download to avoid conflicts when multiple Remotion processes are running
+    const ffmpegInstalled = fs_1.default.readdirSync(folderName).find((filename) => {
+        if (!filename.startsWith(binaryPrefix[binary])) {
+            return false;
+        }
+        const dlUrl = (0, exports.getBinaryDownloadUrl)(binary);
+        if (!dlUrl) {
+            return false;
+        }
+        const expectedLength = dlUrl.contentLength;
+        if (fs_1.default.statSync(path_1.default.join(folderName, filename)).size === expectedLength) {
+            return true;
+        }
+        return false;
+    });
+    if (ffmpegInstalled) {
+        return path_1.default.join(folderName, ffmpegInstalled);
+    }
+    return null;
+};
+exports.ffmpegInNodeModules = ffmpegInNodeModules;
+const getFfmpegAbsolutePath = (remotionRoot, binary) => {
+    const folderName = getFfmpegFolderName(remotionRoot);
+    if (!fs_1.default.existsSync(folderName)) {
+        fs_1.default.mkdirSync(folderName);
+    }
+    if (os_1.default.platform() === 'win32') {
+        return path_1.default.resolve(folderName, `${binaryPrefix[binary]}${randomFfmpegRuntimeId}.exe`);
+    }
+    return path_1.default.resolve(folderName, `${binaryPrefix[binary]}${randomFfmpegRuntimeId}`);
+};
+const ffmpegHasFeature = async ({ ffmpegExecutable, feature, remotionRoot, }) => {
+    if (ffmpegExecutable && !(0, validate_ffmpeg_1.customExecutableExists)(ffmpegExecutable)) {
+        return false;
     }
-    if (!(await (0, validate_ffmpeg_1.binaryExists)('ffmpeg', ffmpegExecutable))) {
+    if (!(0, validate_ffmpeg_1.binaryExists)('ffmpeg')) {
         return false;
     }
-    const config = await (0, exports.getFfmpegBuildInfo)({ ffmpegExecutable });
+    const config = await (0, exports.getFfmpegBuildInfo)({ ffmpegExecutable, remotionRoot });
     return config.includes(feature);
 };
 exports.ffmpegHasFeature = ffmpegHasFeature;
@@ -43,7 +93,153 @@ exports.parseFfmpegVersion = parseFfmpegVersion;
 const getFfmpegVersion = async (options) => {
     const buildInfo = await (0, exports.getFfmpegBuildInfo)({
         ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
     });
     return (0, exports.parseFfmpegVersion)(buildInfo);
 };
 exports.getFfmpegVersion = getFfmpegVersion;
+const waitForFfmpegToBeDownloaded = (url) => {
+    return new Promise((resolve) => {
+        if (!listeners[url]) {
+            listeners[url] = [];
+        }
+        listeners[url].push((src) => resolve(src));
+    });
+};
+const onProgress = (downloadedBytes, totalBytesToDownload, binary) => {
+    console.log('Downloading ', binary, `${toMegabytes(downloadedBytes)}/${toMegabytes(totalBytesToDownload)}`);
+};
+const downloadBinary = async (remotionRoot, url, binary) => {
+    const destinationPath = getFfmpegAbsolutePath(remotionRoot, binary);
+    const onProgressCallback = (downloadedBytes, _totalBytes) => {
+        onProgress(downloadedBytes, _totalBytes, binary);
+    };
+    isDownloading[url] = true;
+    const totalBytes = await (0, BrowserFetcher_1._downloadFile)(url, destinationPath, onProgressCallback);
+    onProgress(totalBytes, totalBytes, binary);
+    if (os_1.default.platform() !== 'win32') {
+        fs_1.default.chmodSync(destinationPath, '777');
+    }
+    isDownloading[url] = false;
+    if (!listeners[url]) {
+        listeners[url] = [];
+    }
+    listeners[url].forEach((listener) => listener(destinationPath));
+    listeners[url] = [];
+    return destinationPath;
+};
+exports.downloadBinary = downloadBinary;
+exports.lambdaFfmpegPaths = {
+    ffmpeg: '/opt/bin/ffmpeg',
+    ffprobe: '/opt/bin/ffprobe',
+};
+const getExecutableBinary = (ffmpegExecutable, remotionRoot, binary) => {
+    if (fs_1.default.existsSync(exports.lambdaFfmpegPaths[binary])) {
+        return exports.lambdaFfmpegPaths[binary];
+    }
+    if (ffmpegExecutable && (0, validate_ffmpeg_1.customExecutableExists)(ffmpegExecutable)) {
+        return ffmpegExecutable;
+    }
+    if ((0, validate_ffmpeg_1.binaryExists)(binary)) {
+        return binary;
+    }
+    const dlUrl = (0, exports.getBinaryDownloadUrl)(binary);
+    if (dlUrl && isDownloading[dlUrl.url]) {
+        return waitForFfmpegToBeDownloaded(dlUrl.url);
+    }
+    const inNodeMod = (0, exports.ffmpegInNodeModules)(remotionRoot, binary);
+    if (inNodeMod) {
+        return inNodeMod;
+    }
+    if (!dlUrl) {
+        throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+    }
+    return (0, exports.downloadBinary)(remotionRoot, dlUrl.url, binary);
+};
+exports.getExecutableBinary = getExecutableBinary;
+function toMegabytes(bytes) {
+    const mb = bytes / 1024 / 1024;
+    return `${Math.round(mb * 10) / 10} Mb`;
+}
+const getBinaryDownloadUrl = (binary) => {
+    if (os_1.default.platform() === 'win32' && process.arch === 'x64') {
+        return binary === 'ffmpeg'
+            ? {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-win-x86.exe',
+                contentLength: 127531008,
+            }
+            : {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-win-x86.exe',
+                contentLength: 127425536,
+            };
+    }
+    if (os_1.default.platform() === 'darwin' && process.arch === 'arm64') {
+        return binary === 'ffmpeg'
+            ? {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-macos-arm64',
+                contentLength: 42093320,
+            }
+            : {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-macos-arm64-v2',
+                contentLength: 46690008,
+            };
+    }
+    if (os_1.default.platform() === 'darwin' && process.arch === 'x64') {
+        return binary === 'ffmpeg'
+            ? {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-macos-x86',
+                contentLength: 78380700,
+            }
+            : {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-macos-x86',
+                contentLength: 77364284,
+            };
+    }
+    if (os_1.default.platform() === 'linux' && process.arch === 'x64') {
+        return binary === 'ffmpeg'
+            ? {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-linux-amd64',
+                contentLength: 78502560,
+            }
+            : {
+                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-linux-amd64',
+                contentLength: 78400704,
+            };
+    }
+    return null;
+};
+exports.getBinaryDownloadUrl = getBinaryDownloadUrl;
+const printMessage = (ffmpegVersion) => {
+    console.warn('⚠️Old FFMPEG version detected: ' + ffmpegVersion.join('.'));
+    console.warn('   You need at least version 4.1.0.');
+    console.warn('   Upgrade FFMPEG to get rid of this warning.');
+};
+const printBuildConfMessage = () => {
+    console.error('⚠️  Unsupported FFMPEG version detected.');
+    console.error("   Your version doesn't support the -buildconf flag");
+    console.error('   Audio will not be supported and you may experience other issues.');
+    console.error('   Upgrade FFMPEG to at least v4.1.0 to get rid of this warning.');
+};
+const warnAboutFfmpegVersion = ({ ffmpegVersion, buildConf, }) => {
+    if (buildConf === null) {
+        printBuildConfMessage();
+        return;
+    }
+    if (ffmpegVersion === null) {
+        return null;
+    }
+    const [major, minor] = ffmpegVersion;
+    // 3.x and below definitely is too old
+    if (major < 4) {
+        printMessage(ffmpegVersion);
+        return;
+    }
+    // 5.x will be all good
+    if (major > 4) {
+        return;
+    }
+    if (minor < 1) {
+        printMessage(ffmpegVersion);
+    }
+};
+exports.warnAboutFfmpegVersion = warnAboutFfmpegVersion;

package/dist/ffmpeg-override.d.ts

@@ -0,0 +1,4 @@
+export declare type FfmpegOverrideFn = (info: {
+    type: 'pre-stitcher' | 'stitcher';
+    args: string[];
+}) => string[];

package/dist/ffmpeg-override.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/file-extensions.d.ts

@@ -0,0 +1,25 @@
+import type { Codec } from './codec';
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16"];
+    readonly 'h264-mkv': readonly ["pcm-16"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["pcm-16", "aac"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+export declare type FileExtension = 'aac' | '3gp' | 'm4a' | 'm4b' | 'mpg' | 'mpeg' | 'mkv' | 'mp4' | 'gif' | 'hevc' | 'mp3' | 'mov' | 'mxf' | 'wav' | 'webm';
+export declare const defaultFileExtensionMap: {
+    [key in Codec]: {
+        default: FileExtension;
+        forAudioCodec: {
+            [k in typeof supportedAudioCodecs[key][number]]: {
+                possible: FileExtension[];
+                default: FileExtension;
+            };
+        };
+    };
+};

package/dist/file-extensions.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFileExtensionMap = exports.supportedAudioCodecs = void 0;
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16'],
+    'h264-mkv': ['pcm-16'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['pcm-16', 'aac'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+exports.defaultFileExtensionMap = {
+    'h264-mkv': {
+        default: 'mkv',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    aac: {
+        default: 'aac',
+        forAudioCodec: {
+            aac: {
+                possible: ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'],
+                default: 'aac',
+            },
+            'pcm-16': {
+                possible: ['wav'],
+                default: 'wav',
+            },
+        },
+    },
+    gif: {
+        default: 'gif',
+        forAudioCodec: {},
+    },
+    h264: {
+        default: 'mp4',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv', 'mov'], default: 'mkv' },
+            aac: { possible: ['mp4', 'mkv', 'mov'], default: 'mp4' },
+        },
+    },
+    h265: {
+        default: 'mp4',
+        forAudioCodec: {
+            aac: { possible: ['mp4', 'mkv', 'hevc'], default: 'mp4' },
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    mp3: {
+        default: 'mp3',
+        forAudioCodec: {
+            mp3: { possible: ['mp3'], default: 'mp3' },
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+    prores: {
+        default: 'mov',
+        forAudioCodec: {
+            aac: { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+            'pcm-16': { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+        },
+    },
+    vp8: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    vp9: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    wav: {
+        default: 'wav',
+        forAudioCodec: {
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+};

package/dist/find-closest-package-json.d.ts

@@ -0,0 +1,2 @@
+export declare const findClosestPackageJson: () => string | null;
+export declare const findRemotionRoot: () => string;

package/dist/find-closest-package-json.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRemotionRoot = exports.findClosestPackageJson = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const recursionLimit = 5;
+const findClosestPackageJson = () => {
+    let currentDir = process.cwd();
+    let possiblePackageJson = '';
+    for (let i = 0; i < recursionLimit; i++) {
+        possiblePackageJson = path_1.default.join(currentDir, 'package.json');
+        const exists = fs_1.default.existsSync(possiblePackageJson);
+        if (exists) {
+            return possiblePackageJson;
+        }
+        currentDir = path_1.default.dirname(currentDir);
+    }
+    return null;
+};
+exports.findClosestPackageJson = findClosestPackageJson;
+const findRemotionRoot = () => {
+    const closestPackageJson = (0, exports.findClosestPackageJson)();
+    if (closestPackageJson === null) {
+        return process.cwd();
+    }
+    return path_1.default.dirname(closestPackageJson);
+};
+exports.findRemotionRoot = findRemotionRoot;

package/dist/get-browser-instance.js

@@ -26,7 +26,7 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
         page: browserPage,
         cleanup: () => {
             // Close whole browser that was just created and don't wait for it to finish.
-            browserInstance.close().catch((err) => {
+            browserInstance.close(true).catch((err) => {
                 console.error('Was not able to close puppeteer page', err);
             });
         },

package/dist/get-can-extract-frames-fast.d.ts

@@ -0,0 +1,14 @@
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const ACCEPTABLE_OFFSET_THRESHOLD = 50;
+/**
+ * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
+ */
+export declare const getCanExtractFramesFast: ({ src, ffmpegExecutable, ffprobeExecutable, }: {
+    src: string;
+    ffmpegExecutable?: FfmpegExecutable | undefined;
+    ffprobeExecutable?: FfmpegExecutable | undefined;
+}) => Promise<{
+    canExtractFramesFast: boolean;
+    shouldReencode: boolean;
+}>;

package/dist/get-can-extract-frames-fast.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCanExtractFramesFast = exports.ACCEPTABLE_OFFSET_THRESHOLD = void 0;
+const fs_1 = __importDefault(require("fs"));
+const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
+const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const find_closest_package_json_1 = require("./find-closest-package-json");
+const get_video_info_1 = require("./get-video-info");
+const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
+exports.ACCEPTABLE_OFFSET_THRESHOLD = 50;
+/**
+ * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
+ */
+const getCanExtractFramesFast = async ({ src, ffmpegExecutable, ffprobeExecutable, }) => {
+    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
+    const out = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src,
+    });
+    const { specialVcodecForTransparency: specialVcodec } = await (0, get_video_info_1.getVideoInfoUncached)({
+        src: out,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+    });
+    if (specialVcodec === 'vp8') {
+        fs_1.default.unlinkSync(out);
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: false,
+        };
+    }
+    const { duration } = await (0, get_video_stream_duration_1.getVideoStreamDurationwithoutCache)({
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src: out,
+    });
+    if (duration === null) {
+        fs_1.default.unlinkSync(out);
+        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
+    }
+    const actualOffset = `${duration * 1000 - exports.ACCEPTABLE_OFFSET_THRESHOLD}ms`;
+    const [stdErr] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
+        actualOffset,
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        imageFormat: 'jpeg',
+        // Intentionally leaving needsResize as null, because we don't need to resize
+        needsResize: null,
+        remotionRoot,
+        specialVCodecForTransparency: specialVcodec,
+        src: out,
+    });
+    fs_1.default.unlinkSync(out);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: true,
+        };
+    }
+    return {
+        canExtractFramesFast: true,
+        shouldReencode: false,
+    };
+};
+exports.getCanExtractFramesFast = getCanExtractFramesFast;

package/dist/get-compositions.d.ts

@@ -21,5 +21,9 @@ declare type GetCompositionsConfig = {
      */
     downloadMap?: DownloadMap;
 };
+/**
+ * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
+ */
 export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<TCompMetadata[]>;
 export {};

package/dist/get-compositions.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCompositions = void 0;
 const download_map_1 = require("./assets/download-map");
 const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const get_browser_instance_1 = require("./get-browser-instance");
 const prepare_server_1 = require("./prepare-server");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     if (config === null || config === void 0 ? void 0 : config.onBrowserLog) {
@@ -29,6 +32,8 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
         timeoutInMilliseconds: config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds,
         proxyPort,
         retriesRemaining: 2,
+        audioEnabled: false,
+        videoEnabled: false,
     });
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         page,
@@ -40,7 +45,7 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
         frame: null,
         args: [],
     });
-    await page.waitForFunction(page.browser, 'window.ready === true');
+    await (0, seek_to_frame_1.waitForReady)(page);
     const result = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         pageFunction: () => {
             return window.getStaticCompositions();
@@ -51,13 +56,19 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     });
     return result;
 };
+/**
+ * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
+ */
 const getCompositions = async (serveUrlOrWebpackUrl, config) => {
-    var _a, _b, _c;
-    const downloadMap = (_a = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _a !== void 0 ? _a : (0, download_map_1.makeDownloadMap)();
+    var _a, _b, _c, _d, _e;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null, (0, find_closest_package_json_1.findRemotionRoot)(), 'ffmpeg');
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null, (0, find_closest_package_json_1.findRemotionRoot)(), 'ffprobe');
+    const downloadMap = (_c = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _c !== void 0 ? _c : (0, download_map_1.makeDownloadMap)();
     const { page, cleanup } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
         passedInInstance: config === null || config === void 0 ? void 0 : config.puppeteerInstance,
-        browserExecutable: (_b = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _b !== void 0 ? _b : null,
-        chromiumOptions: (_c = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _c !== void 0 ? _c : {},
+        browserExecutable: (_d = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _d !== void 0 ? _d : null,
+        chromiumOptions: (_e = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _e !== void 0 ? _e : {},
     });
     return new Promise((resolve, reject) => {
         var _a, _b, _c;
@@ -76,18 +87,26 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
             ffprobeExecutable: (_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
             port: (_c = config === null || config === void 0 ? void 0 : config.port) !== null && _c !== void 0 ? _c : null,
             downloadMap,
+            remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
         })
             .then(({ serveUrl, closeServer, offthreadPort }) => {
             close = closeServer;
             return innerGetCompositions(serveUrl, page, config !== null && config !== void 0 ? config : {}, offthreadPort);
         })
-            .then((comp) => resolve(comp))
+            .then((comp) => {
+            if (close) {
+                return Promise.all([comp, close(true)]);
+            }
+            return Promise.resolve([comp, null]);
+        })
+            .then(([comp]) => {
+            return resolve(comp);
+        })
             .catch((err) => {
             reject(err);
         })
             .finally(() => {
             cleanup();
-            close === null || close === void 0 ? void 0 : close();
             cleanupPageError();
             // Clean download map if it was not passed in
             if (!(config === null || config === void 0 ? void 0 : config.downloadMap)) {

package/dist/get-concurrency.d.ts

@@ -1 +1 @@
-export declare const getActualConcurrency: (userPreference: number | null) => number;
+export declare const getActualConcurrency: (userPreference: number | string | null) => number;

package/dist/get-concurrency.js

@@ -9,9 +9,16 @@ const getActualConcurrency = (userPreference) => {
     if (userPreference === null) {
         return Math.round(Math.min(8, Math.max(1, os_1.default.cpus().length / 2)));
     }
-    const rounded = Math.floor(userPreference);
     const max = os_1.default.cpus().length;
     const min = 1;
+    let rounded;
+    if (typeof userPreference === 'string') {
+        const percentage = parseInt(userPreference.slice(0, -1), 10);
+        rounded = Math.floor((percentage / 100) * max);
+    }
+    else {
+        rounded = Math.floor(userPreference);
+    }
     if (rounded > max) {
         throw new Error(`Maximum for --concurrency is ${max} (number of cores on this system)`);
     }

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,6 @@
+import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
-export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
+import type { FileExtension } from './file-extensions';
+export declare const getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: AudioCodec | null) => FileExtension;
+export declare const makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+export declare const defaultCodecsForFileExtension: Record<FileExtension, Codec>;