@remotion/renderer 4.0.135 → 4.0.137

package/dist/audio-codec.d.ts

@@ -0,0 +1,28 @@
+import type { Codec } from './codec';
+export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+export type AudioCodec = (typeof validAudioCodecs)[number];
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16", "mp3"];
+    readonly 'h264-mkv': readonly ["pcm-16", "mp3"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["aac", "pcm-16"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+declare const audioCodecNames: readonly ["pcm_s16le", "libfdk_aac", "libmp3lame", "libopus"];
+type FfmpegAudioCodecName = (typeof audioCodecNames)[number];
+export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: AudioCodec) => FfmpegAudioCodecName;
+export declare const defaultAudioCodecs: {
+    [key in Codec]: {
+        [k in 'compressed' | 'lossless']: (typeof supportedAudioCodecs)[key][number] | null;
+    };
+};
+export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {
+    codec: Codec;
+    preferLossless: boolean;
+}) => AudioCodec | null;
+export {};

package/dist/audio-codec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultAudioCodec = exports.defaultAudioCodecs = exports.mapAudioCodecToFfmpegAudioCodecName = exports.supportedAudioCodecs = exports.validAudioCodecs = void 0;
+exports.validAudioCodecs = ['pcm-16', 'aac', 'mp3', 'opus'];
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16', 'mp3'],
+    'h264-mkv': ['pcm-16', 'mp3'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['aac', 'pcm-16'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+const _satisfies = exports.supportedAudioCodecs;
+if (_satisfies) {
+    // Just for type checking
+}
+const audioCodecNames = [
+    'pcm_s16le',
+    'libfdk_aac',
+    'libmp3lame',
+    'libopus',
+];
+const mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+    if (audioCodec === 'aac') {
+        return 'libfdk_aac';
+    }
+    if (audioCodec === 'mp3') {
+        return 'libmp3lame';
+    }
+    if (audioCodec === 'opus') {
+        return 'libopus';
+    }
+    if (audioCodec === 'pcm-16') {
+        return 'pcm_s16le';
+    }
+    throw new Error('unknown audio codec: ' + audioCodec);
+};
+exports.mapAudioCodecToFfmpegAudioCodecName = mapAudioCodecToFfmpegAudioCodecName;
+exports.defaultAudioCodecs = {
+    'h264-mkv': {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    aac: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    gif: {
+        lossless: null,
+        compressed: null,
+    },
+    h264: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    h265: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    mp3: {
+        lossless: 'pcm-16',
+        compressed: 'mp3',
+    },
+    prores: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    vp8: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    vp9: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    wav: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+};
+const getDefaultAudioCodec = ({ codec, preferLossless, }) => {
+    return exports.defaultAudioCodecs[codec][preferLossless ? 'lossless' : 'compressed'];
+};
+exports.getDefaultAudioCodec = getDefaultAudioCodec;

package/dist/browser/BrowserFetcher.d.ts

@@ -14,15 +14,18 @@
  * limitations under the License.
  */
 import type { LogLevel } from '../log-level';
+import type { DownloadBrowserProgressFn } from '../options/on-browser-download';
 interface BrowserFetcherRevisionInfo {
     folderPath: string;
     executablePath: string;
     url: string;
     local: boolean;
 }
-export declare const downloadBrowser: (options: {
+export declare const downloadBrowser: ({ logLevel, indent, onProgress, version, }: {
     logLevel: LogLevel;
     indent: boolean;
+    onProgress: DownloadBrowserProgressFn;
+    version: string | null;
 }) => Promise<BrowserFetcherRevisionInfo | undefined>;
 export declare const getRevisionInfo: () => BrowserFetcherRevisionInfo;
 export {};

package/dist/browser/BrowserFetcher.js

@@ -42,29 +42,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRevisionInfo = exports.downloadBrowser = void 0;
-const childProcess = __importStar(require("node:child_process"));
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const extract_zip_1 = __importDefault(require("extract-zip"));
 const node_util_1 = require("node:util");
-const assert_1 = require("./assert");
 const download_file_1 = require("../assets/download-file");
+const make_file_executable_1 = require("../compositor/make-file-executable");
 const logger_1 = require("../logger");
 const get_download_destination_1 = require("./get-download-destination");
-const downloadURLs = {
-    linux: 'https://github.com/Alex313031/thorium/releases/download/M117.0.5938.157/thorium-browser_117.0.5938.157_amd64.zip',
-    mac: 'https://github.com/Alex313031/Thorium-MacOS/releases/download/M116.0.5845.169/Thorium_MacOS_X64.dmg',
-    mac_arm: 'https://github.com/Alex313031/Thorium-MacOS/releases/download/M116.0.5845.169/Thorium_MacOS_ARM.dmg',
-    win64: 'https://github.com/Alex313031/Thorium-Win/releases/download/M117.0.5938.157/Thorium_117.0.5938.157.zip',
-};
-function getThoriumDownloadUrl(platform) {
-    return downloadURLs[platform];
+const TESTED_VERSION = '123.0.6312.86';
+function getChromeDownloadUrl({ platform, version, }) {
+    return `https://storage.googleapis.com/chrome-for-testing-public/${version !== null && version !== void 0 ? version : TESTED_VERSION}/${platform}/chrome-headless-shell-${platform}.zip`;
 }
-const readdirAsync = fs.promises.readdir;
 const mkdirAsync = fs.promises.mkdir;
 const unlinkAsync = (0, node_util_1.promisify)(fs.unlink.bind(fs));
-const chmodAsync = (0, node_util_1.promisify)(fs.chmod.bind(fs));
 function existsAsync(filePath) {
     return new Promise((resolve) => {
         fs.access(filePath, (err) => {
@@ -76,24 +68,26 @@ const getPlatform = () => {
     const platform = os.platform();
     switch (platform) {
         case 'darwin':
-            return os.arch() === 'arm64' ? 'mac_arm' : 'mac';
+            return os.arch() === 'arm64' ? 'mac-arm64' : 'mac-x64';
         case 'linux':
-            return 'linux';
+            return 'linux64';
         case 'win32':
             return 'win64';
         default:
-            (0, assert_1.assert)(false, 'Unsupported platform: ' + platform);
+            throw new Error('Unsupported platform: ' + platform);
     }
 };
-const destination = '.thorium';
+const destination = 'chrome-headless-shell';
 const getDownloadsFolder = () => {
     return path.join((0, get_download_destination_1.getDownloadsCacheDir)(), destination);
 };
-const downloadBrowser = async (options) => {
+const downloadBrowser = async ({ logLevel, indent, onProgress, version, }) => {
     const platform = getPlatform();
-    const downloadURL = getThoriumDownloadUrl(platform);
+    const downloadURL = getChromeDownloadUrl({ platform, version });
     const fileName = downloadURL.split('/').pop();
-    (0, assert_1.assert)(fileName, `A malformed download URL was found: ${downloadURL}.`);
+    if (!fileName) {
+        throw new Error(`A malformed download URL was found: ${downloadURL}.`);
+    }
     const downloadsFolder = getDownloadsFolder();
     const archivePath = path.join(downloadsFolder, fileName);
     const outputPath = getFolderPath(downloadsFolder, platform);
@@ -107,26 +101,32 @@ const downloadBrowser = async (options) => {
     }
     // Use system Chromium builds on Linux ARM devices
     if (os.platform() !== 'darwin' && os.arch() === 'arm64') {
-        throw new Error('The chromium binary is not available for arm64.' +
-            '\nIf you are on Ubuntu, you can install with: ' +
-            '\n\n sudo apt install chromium\n' +
-            '\n\n sudo apt install chromium-browser\n');
+        throw new Error([
+            'Chrome Headless Shell is not available for Linux for arm64 architecture.',
+            'If you are on Ubuntu, you can install with:',
+            'sudo apt install chromium',
+            'sudo apt install chromium-browser',
+        ].join('\n'));
     }
     try {
-        let lastProgress = 0;
         await (0, download_file_1.downloadFile)({
             url: downloadURL,
             to: () => archivePath,
             onProgress: (progress) => {
-                if (progress.downloaded > lastProgress + 10000000) {
-                    lastProgress = progress.downloaded;
-                    logger_1.Log.info({ indent: options.indent, logLevel: options.logLevel }, `Downloading Thorium - ${toMegabytes(progress.downloaded)}/${toMegabytes(progress.totalSize)}`);
+                if (progress.totalSize === null || progress.percent === null) {
+                    throw new Error('Expected totalSize and percent to be defined');
                 }
+                onProgress({
+                    downloadedBytes: progress.downloaded,
+                    totalSizeInBytes: progress.totalSize,
+                    percent: progress.percent,
+                });
             },
-            indent: options.indent,
-            logLevel: options.logLevel,
+            indent,
+            logLevel,
         });
-        await install({ archivePath, folderPath: outputPath });
+        logger_1.Log.info({ indent, logLevel });
+        await (0, extract_zip_1.default)(archivePath, { dir: outputPath });
     }
     finally {
         if (await existsAsync(archivePath)) {
@@ -134,7 +134,7 @@ const downloadBrowser = async (options) => {
         }
     }
     const revisionInfo = (0, exports.getRevisionInfo)();
-    await chmodAsync(revisionInfo.executablePath, 0o755);
+    (0, make_file_executable_1.makeFileExecutableIfItIsNot)(revisionInfo.executablePath);
     return revisionInfo;
 };
 exports.downloadBrowser = downloadBrowser;
@@ -145,23 +145,16 @@ const getExecutablePath = () => {
     const downloadsFolder = getDownloadsFolder();
     const platform = getPlatform();
     const folderPath = getFolderPath(downloadsFolder, platform);
-    if (platform === 'mac' || platform === 'mac_arm') {
-        return path.join(folderPath, 'Thorium.app', 'Contents', 'MacOS', 'Thorium');
-    }
-    if (platform === 'linux') {
-        return path.join(folderPath, 'thorium');
-    }
-    if (platform === 'win64') {
-        return path.join(folderPath, 'BIN', 'thorium.exe');
-    }
-    throw new Error('Can not download browser for platform: ' + platform);
+    return path.join(folderPath, `chrome-headless-shell-${platform}`, platform === 'win64'
+        ? 'chrome-headless-shell.exe'
+        : 'chrome-headless-shell');
 };
 const getRevisionInfo = () => {
     const executablePath = getExecutablePath();
     const downloadsFolder = getDownloadsFolder();
     const platform = getPlatform();
     const folderPath = getFolderPath(downloadsFolder, platform);
-    const url = getThoriumDownloadUrl(platform);
+    const url = getChromeDownloadUrl({ platform, version: null });
     const local = fs.existsSync(folderPath);
     return {
         executablePath,
@@ -171,66 +164,3 @@ const getRevisionInfo = () => {
     };
 };
 exports.getRevisionInfo = getRevisionInfo;
-async function install({ archivePath, folderPath, }) {
-    if (archivePath.endsWith('.zip')) {
-        return (0, extract_zip_1.default)(archivePath, { dir: folderPath });
-    }
-    if (archivePath.endsWith('.dmg')) {
-        await mkdirAsync(folderPath);
-        return _installDMG(archivePath, folderPath);
-    }
-    throw new Error(`Unsupported archive format: ${archivePath}`);
-}
-function _installDMG(dmgPath, folderPath) {
-    let mountPath;
-    return new Promise((fulfill, reject) => {
-        const mountCommand = `hdiutil attach -nobrowse -noautoopen "${dmgPath}"`;
-        childProcess.exec(mountCommand, (err, stdout) => {
-            if (err) {
-                return reject(err);
-            }
-            const volumes = stdout.match(/\/Volumes\/(.*)/m);
-            if (!volumes) {
-                return reject(new Error(`Could not find volume path in ${stdout}`));
-            }
-            mountPath = volumes[0];
-            readdirAsync(mountPath)
-                .then((fileNames) => {
-                const appName = fileNames.find((item) => {
-                    return typeof item === 'string' && item.endsWith('.app');
-                });
-                if (!appName) {
-                    return reject(new Error(`Cannot find app in ${mountPath}`));
-                }
-                const copyPath = path.join(mountPath, appName);
-                childProcess.exec(`cp -R "${copyPath}" "${folderPath}"`, (_err) => {
-                    if (_err) {
-                        reject(_err);
-                    }
-                    else {
-                        fulfill();
-                    }
-                });
-            })
-                .catch(reject);
-        });
-    })
-        .catch((error) => {
-        console.error(error);
-    })
-        .finally(() => {
-        if (!mountPath) {
-            return;
-        }
-        const unmountCommand = `hdiutil detach "${mountPath}" -quiet`;
-        childProcess.exec(unmountCommand, (err) => {
-            if (err) {
-                console.error(`Error unmounting dmg: ${err}`);
-            }
-        });
-    });
-}
-function toMegabytes(bytes) {
-    const mb = bytes / 1024 / 1024;
-    return `${Math.round(mb * 10) / 10} Mb`;
-}

package/dist/browser/browser-download-progress-bar.d.ts

@@ -0,0 +1,7 @@
+import type { LogLevel } from '../log-level';
+import type { OnBrowserDownload } from '../options/on-browser-download';
+export declare const defaultBrowserDownloadProgress: ({ indent, logLevel, api, }: {
+    indent: boolean;
+    logLevel: LogLevel;
+    api: string;
+}) => OnBrowserDownload;

package/dist/browser/browser-download-progress-bar.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBrowserDownloadProgress = void 0;
+const logger_1 = require("../logger");
+const to_megabytes_1 = require("../to-megabytes");
+const defaultBrowserDownloadProgress = ({ indent, logLevel, api, }) => () => {
+    logger_1.Log.info({ indent, logLevel }, 'No local browser could be found.');
+    logger_1.Log.info({ indent, logLevel }, 'Downloading Chrome Headless Shell https://www.remotion.dev/docs/miscellaneous/chrome-headless-shell');
+    logger_1.Log.info({ indent, logLevel }, `Customize this behavior by adding a onBrowserDownload function to ${api}.`);
+    return {
+        onProgress: (progress) => {
+            let lastProgress = 0;
+            if (progress.downloadedBytes > lastProgress + 10000000) {
+                lastProgress = progress.downloadedBytes;
+                logger_1.Log.info({ indent, logLevel }, `Downloading Chrome Headless Shell - ${(0, to_megabytes_1.toMegabytes)(progress.downloadedBytes)}/${(0, to_megabytes_1.toMegabytes)(progress.totalSizeInBytes)}`);
+            }
+        },
+        version: null,
+    };
+};
+exports.defaultBrowserDownloadProgress = defaultBrowserDownloadProgress;

package/dist/check-apple-silicon.d.ts

@@ -0,0 +1 @@
+export declare const checkNodeVersionAndWarnAboutRosetta: () => void;

package/dist/check-apple-silicon.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNodeVersionAndWarnAboutRosetta = void 0;
+const checkNodeVersionAndWarnAboutRosetta = () => {
+    const version = process.version.replace('v', '').split('.');
+    const majorVersion = Number(version[0]);
+    const requiredNodeVersion = 16;
+    if (majorVersion < 16) {
+        throw new Error(`Remotion requires at least Node ${requiredNodeVersion}. You currently have ${process.version}. Update your node version to ${requiredNodeVersion} to use Remotion.`);
+    }
+};
+exports.checkNodeVersionAndWarnAboutRosetta = checkNodeVersionAndWarnAboutRosetta;

package/dist/check-version-requirements.js

@@ -38,8 +38,13 @@ exports.gLibCErrorMessage = gLibCErrorMessage;
 const checkLibCRequirement = (logLevel, indent) => {
     const { report } = process;
     if (report) {
+        const rep = report.getReport();
+        if (typeof rep === 'string') {
+            logger_1.Log.warn({ logLevel, indent }, 'Bun limitation: process.report.getReport() ' + rep);
+            return;
+        }
         // @ts-expect-error no types
-        const { glibcVersionRuntime } = report.getReport().header;
+        const { glibcVersionRuntime } = rep.header;
         if (!glibcVersionRuntime) {
             return;
         }

package/dist/client.d.ts

@@ -464,19 +464,19 @@ export declare const BrowserSafeApis: {
             cliFlag: "gl";
             docLink: string;
             name: string;
-            type: "angle" | "swangle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
+            type: "swangle" | "angle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
             ssrName: string;
             description: () => import("react/jsx-runtime").JSX.Element;
             getValue: ({ commandLine }: {
                 commandLine: Record<string, unknown>;
             }) => {
-                value: "angle" | "swangle" | "egl" | "swiftshader" | "vulkan" | "angle-egl";
+                value: "swangle" | "angle" | "egl" | "swiftshader" | "vulkan" | "angle-egl";
                 source: string;
             } | {
                 value: null;
                 source: string;
             };
-            setConfig: (value: "angle" | "swangle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null) => void;
+            setConfig: (value: "swangle" | "angle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null) => void;
         };
         enableLambdaInsights: {
             name: string;
@@ -760,6 +760,16 @@ export declare const BrowserSafeApis: {
             setConfig: (value: string | null) => void;
             type: string | null;
         };
+        onBrowserDownloadOption: {
+            name: string;
+            cliFlag: "on-browser-download";
+            description: () => import("react/jsx-runtime").JSX.Element;
+            ssrName: "onBrowserDownload";
+            docLink: string;
+            type: import(".").OnBrowserDownload;
+            getValue: () => never;
+            setConfig: () => never;
+        };
     };
     validColorSpaces: readonly ["default", "bt709", "bt2020-ncl"];
     optionsMap: {
@@ -1067,6 +1077,16 @@ export declare const BrowserSafeApis: {
                 ssrName: "audioCodec";
                 type: "mp3" | "aac" | "pcm-16" | "opus";
             };
+            readonly onBrowserDownload: {
+                name: string;
+                cliFlag: "on-browser-download";
+                description: () => import("react/jsx-runtime").JSX.Element;
+                ssrName: "onBrowserDownload";
+                docLink: string;
+                type: import(".").OnBrowserDownload;
+                getValue: () => never;
+                setConfig: () => never;
+            };
         };
         readonly stitchFramesToVideo: {
             readonly separateAudioTo: {
@@ -1167,6 +1187,16 @@ export declare const BrowserSafeApis: {
                 };
                 setConfig: (value: string | null) => void;
             };
+            readonly onBrowserDownload: {
+                name: string;
+                cliFlag: "on-browser-download";
+                description: () => import("react/jsx-runtime").JSX.Element;
+                ssrName: "onBrowserDownload";
+                docLink: string;
+                type: import(".").OnBrowserDownload;
+                getValue: () => never;
+                setConfig: () => never;
+            };
         };
         readonly getCompositions: {
             readonly offthreadVideoCacheSizeInBytes: {
@@ -1232,6 +1262,16 @@ export declare const BrowserSafeApis: {
                 };
                 setConfig: (value: string | null) => void;
             };
+            readonly onBrowserDownload: {
+                name: string;
+                cliFlag: "on-browser-download";
+                description: () => import("react/jsx-runtime").JSX.Element;
+                ssrName: "onBrowserDownload";
+                docLink: string;
+                type: import(".").OnBrowserDownload;
+                getValue: () => never;
+                setConfig: () => never;
+            };
         };
         readonly selectComposition: {
             readonly offthreadVideoCacheSizeInBytes: {
@@ -1297,6 +1337,16 @@ export declare const BrowserSafeApis: {
                 };
                 setConfig: (value: string | null) => void;
             };
+            readonly onBrowserDownload: {
+                name: string;
+                cliFlag: "on-browser-download";
+                description: () => import("react/jsx-runtime").JSX.Element;
+                ssrName: "onBrowserDownload";
+                docLink: string;
+                type: import(".").OnBrowserDownload;
+                getValue: () => never;
+                setConfig: () => never;
+            };
         };
         readonly renderFrames: {
             readonly forSeamlessAacConcatenation: {
@@ -1395,6 +1445,16 @@ export declare const BrowserSafeApis: {
                 };
                 setConfig: (value: string | null) => void;
             };
+            readonly onBrowserDownload: {
+                name: string;
+                cliFlag: "on-browser-download";
+                description: () => import("react/jsx-runtime").JSX.Element;
+                ssrName: "onBrowserDownload";
+                docLink: string;
+                type: import(".").OnBrowserDownload;
+                getValue: () => never;
+                setConfig: () => never;
+            };
         };
         readonly renderMediaOnLambda: {
             readonly offthreadVideoCacheSizeInBytes: {
@@ -2111,6 +2171,33 @@ export declare const BrowserSafeApis: {
                 setConfig: (value: number) => void;
             };
         };
+        readonly ensureBrowser: {
+            readonly logLevel: {
+                cliFlag: "log";
+                name: string;
+                ssrName: string;
+                description: () => import("react/jsx-runtime").JSX.Element;
+                docLink: string;
+                getValue: ({ commandLine }: {
+                    commandLine: Record<string, unknown>;
+                }) => {
+                    value: "verbose" | "info" | "warn" | "error";
+                    source: string;
+                };
+                setConfig: (newLogLevel: "verbose" | "info" | "warn" | "error") => void;
+                type: "verbose" | "info" | "warn" | "error";
+            };
+            readonly onBrowserDownload: {
+                name: string;
+                cliFlag: "on-browser-download";
+                description: () => import("react/jsx-runtime").JSX.Element;
+                ssrName: "onBrowserDownload";
+                docLink: string;
+                type: import(".").OnBrowserDownload;
+                getValue: () => never;
+                setConfig: () => never;
+            };
+        };
     };
     codecSupportsCrf: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "h264-ts" | "gif") => boolean;
     codecSupportsVideoBitrate: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "h264-ts" | "gif") => boolean;

package/dist/compositor/get-executable-path.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const logger_1 = require("../logger");
 let warned = false;
 function isMusl({ indent, logLevel, }) {
+    var _a;
     // @ts-expect-error bun no types
     if (!process.report && typeof Bun !== 'undefined') {
         if (!warned) {
@@ -17,8 +18,16 @@ function isMusl({ indent, logLevel, }) {
         warned = true;
         return false;
     }
+    const report = (_a = process.report) === null || _a === void 0 ? void 0 : _a.getReport();
+    if (report && typeof report === 'string') {
+        if (!warned) {
+            logger_1.Log.warn({ indent, logLevel }, 'Bun limitation: Could not determine if your Windows is using musl or glibc. Assuming glibc.');
+        }
+        warned = true;
+        return false;
+    }
     // @ts-expect-error no types
-    const { glibcVersionRuntime } = process.report.getReport().header;
+    const { glibcVersionRuntime } = report.header;
     return !glibcVersionRuntime;
 }
 exports.isMusl = isMusl;

package/dist/create-combined-video.d.ts

@@ -0,0 +1,18 @@
+import type { Codec } from './codec';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+export declare const createCombinedVideo: ({ addRemotionMetadata, binariesDirectory, cancelSignal, codec, filelistDir, files, fps, indent, logLevel, numberOfGifLoops, onProgress, output, seamless, }: {
+    fps: number;
+    codec: Codec;
+    filelistDir: string;
+    numberOfGifLoops: number | null;
+    output: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    onProgress: (p: number) => void;
+    files: string[];
+    addRemotionMetadata: boolean;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    seamless: boolean;
+}) => Promise<string | undefined>;

package/dist/create-combined-video.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCombinedVideo = void 0;
+const combine_video_streams_1 = require("./combine-video-streams");
+const combine_video_streams_seamlessly_1 = require("./combine-video-streams-seamlessly");
+const createCombinedVideo = async ({ addRemotionMetadata, binariesDirectory, cancelSignal, codec, filelistDir, files, fps, indent, logLevel, numberOfGifLoops, onProgress, output, seamless, }) => {
+    if (seamless) {
+        return (0, combine_video_streams_seamlessly_1.combineVideoStreamsSeamlessly)({
+            files,
+        });
+    }
+    await (0, combine_video_streams_1.combineVideoStreams)({
+        addRemotionMetadata,
+        binariesDirectory,
+        cancelSignal,
+        codec,
+        filelistDir,
+        files,
+        fps,
+        indent,
+        logLevel,
+        numberOfGifLoops,
+        onProgress,
+        output,
+    });
+};
+exports.createCombinedVideo = createCombinedVideo;

package/dist/does-have-m2-bug.d.ts

@@ -0,0 +1,3 @@
+import type { Codec } from './codec';
+import type { PixelFormat } from './pixel-format';
+export declare const warnAboutM2Bug: (codec: Codec | null, pixelFormat: PixelFormat | null) => void;

package/dist/does-have-m2-bug.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnAboutM2Bug = void 0;
+const node_os_1 = require("node:os");
+const warnAboutM2Bug = (codec, pixelFormat) => {
+    const isM2 = (0, node_os_1.cpus)().find((c) => c.model.includes('Apple M2'));
+    if (codec === 'prores' && pixelFormat === 'yuv422p10le' && isM2) {
+        console.warn();
+        console.warn('⚠️ Known issue: Apple M2 CPUs currently suffer from a bug where transparent ProRes videos have flickering. https://github.com/remotion-dev/remotion/issues/1929');
+    }
+};
+exports.warnAboutM2Bug = warnAboutM2Bug;