@remotion/renderer 4.0.501 → 4.0.502

package/dist/assets/calculate-asset-positions.d.ts

@@ -1,3 +1,3 @@
 import type { AudioOrVideoAsset } from 'remotion/no-react';
 import type { Assets } from './types';
-export declare const calculateAssetPositions: (frames: AudioOrVideoAsset[][]) => Assets;
+export declare const calculateAssetPositions: (frames: AudioOrVideoAsset[][], sourceFrames?: number[]) => Assets;

package/dist/assets/calculate-asset-positions.js

@@ -40,7 +40,7 @@ const indexUncompressedAssets = (renderAssets) => {
     }
     return assetsByReference;
 };
-const calculateAssetPositions = (frames) => {
+const calculateAssetPositions = (frames, sourceFrames = frames.map((_, index) => index)) => {
     const assets = [];
     // Assets that have started but not yet ended, keyed by asset id.
     // Since assets are deduplicated by id within a frame, at most one
@@ -49,6 +49,12 @@ const calculateAssetPositions = (frames) => {
     const flattened = frames.flat(1);
     const uncompressedAssets = indexUncompressedAssets(flattened);
     for (let frame = 0; frame < frames.length; frame++) {
+        if (frame > 0 && sourceFrames[frame] !== sourceFrames[frame - 1] + 1) {
+            for (const openAsset of openAssets.values()) {
+                openAsset.duration = frame - openAsset.startInVideo;
+            }
+            openAssets.clear();
+        }
         const current = deduplicateAssets(frames[frame]);
         const currentIds = new Set(current.map((a) => a.id));
         for (const [id, openAsset] of openAssets) {

package/dist/browser/BrowserFetcher.js

@@ -55,6 +55,7 @@ const path = __importStar(require("node:path"));
 const node_util_1 = require("node:util");
 const download_file_1 = require("../assets/download-file");
 const make_file_executable_1 = require("../compositor/make-file-executable");
+const browser_download_lock_1 = require("./browser-download-lock");
 const extract_zip_archive_1 = require("./extract-zip-archive");
 const get_chrome_download_url_1 = require("./get-chrome-download-url");
 Object.defineProperty(exports, "TESTED_VERSION", { enumerable: true, get: function () { return get_chrome_download_url_1.TESTED_VERSION; } });
@@ -127,8 +128,6 @@ const downloadBrowser = async ({ logLevel, indent, onProgress, version, chromeMo
         if (installedVersion === expectedVersion) {
             return (0, exports.getRevisionInfo)(chromeMode);
         }
-        // VERSION file missing or mismatched - delete and re-download
-        fs.rmSync(outputPath, { recursive: true, force: true });
     }
     if (!(await existsAsync(downloadsFolder))) {
         await mkdirAsync(downloadsFolder, {
@@ -142,60 +141,74 @@ const downloadBrowser = async ({ logLevel, indent, onProgress, version, chromeMo
             'Chrome Headless Shell is not available for Windows for arm64 architecture.',
         ].join('\n'));
     }
-    (0, get_chrome_download_url_1.logDownloadUrl)({ url: downloadURL, logLevel, indent });
+    const releaseLock = await (0, browser_download_lock_1.acquireBrowserDownloadLock)(path.join(downloadsFolder, 'download.lock'));
     try {
-        await (0, download_file_1.downloadFile)({
-            url: downloadURL,
-            to: () => archivePath,
-            onProgress: (progress) => {
-                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,
-                    alreadyAvailable: false,
-                });
-            },
-            indent,
-            logLevel,
-            abortSignal: new AbortController().signal,
-        });
-        await (0, extract_zip_archive_1.extractZipArchive)(archivePath, outputPath);
-        const possibleSubdirs = [
-            'chrome-linux',
-            'chrome-headless-shell-linux64',
-            'chromium-headless-shell-amazon-linux2023-arm64',
-            'chromium-headless-shell-amazon-linux2023-x64',
-        ];
-        for (const subdir of possibleSubdirs) {
-            const chromeLinuxFolder = path.join(outputPath, subdir);
-            const chromePath = path.join(chromeLinuxFolder, 'chrome');
-            if (fs.existsSync(chromePath)) {
-                const chromeHeadlessShellPath = path.join(chromeLinuxFolder, 'chrome-headless-shell');
-                fs.renameSync(chromePath, chromeHeadlessShellPath);
+        if (await existsAsync(outputPath)) {
+            const installedVersion = (0, exports.readVersionFile)(chromeMode);
+            if (installedVersion === expectedVersion) {
+                return (0, exports.getRevisionInfo)(chromeMode);
             }
-            if (fs.existsSync(chromeLinuxFolder)) {
-                const targetFolder = path.join(outputPath, 'chrome-headless-shell-' + platform);
-                if (chromeLinuxFolder !== targetFolder) {
-                    fs.renameSync(chromeLinuxFolder, targetFolder);
+            // VERSION file missing or mismatched - delete and re-download
+            fs.rmSync(outputPath, { recursive: true, force: true });
+        }
+        (0, get_chrome_download_url_1.logDownloadUrl)({ url: downloadURL, logLevel, indent });
+        try {
+            await (0, download_file_1.downloadFile)({
+                url: downloadURL,
+                to: () => archivePath,
+                onProgress: (progress) => {
+                    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,
+                        alreadyAvailable: false,
+                    });
+                },
+                indent,
+                logLevel,
+                abortSignal: new AbortController().signal,
+            });
+            await (0, extract_zip_archive_1.extractZipArchive)(archivePath, outputPath);
+            const possibleSubdirs = [
+                'chrome-linux',
+                'chrome-headless-shell-linux64',
+                'chromium-headless-shell-amazon-linux2023-arm64',
+                'chromium-headless-shell-amazon-linux2023-x64',
+            ];
+            for (const subdir of possibleSubdirs) {
+                const chromeLinuxFolder = path.join(outputPath, subdir);
+                const chromePath = path.join(chromeLinuxFolder, 'chrome');
+                if (fs.existsSync(chromePath)) {
+                    const chromeHeadlessShellPath = path.join(chromeLinuxFolder, 'chrome-headless-shell');
+                    fs.renameSync(chromePath, chromeHeadlessShellPath);
+                }
+                if (fs.existsSync(chromeLinuxFolder)) {
+                    const targetFolder = path.join(outputPath, 'chrome-headless-shell-' + platform);
+                    if (chromeLinuxFolder !== targetFolder) {
+                        fs.renameSync(chromeLinuxFolder, targetFolder);
+                    }
                 }
             }
         }
-    }
-    catch (err) {
-        return Promise.reject(err);
+        catch (err) {
+            return Promise.reject(err);
+        }
+        finally {
+            if (await existsAsync(archivePath)) {
+                await unlinkAsync(archivePath);
+            }
+        }
+        writeVersionFile(chromeMode, expectedVersion);
+        const revisionInfo = (0, exports.getRevisionInfo)(chromeMode);
+        (0, make_file_executable_1.makeFileExecutableIfItIsNot)(revisionInfo.executablePath);
+        return revisionInfo;
     }
     finally {
-        if (await existsAsync(archivePath)) {
-            await unlinkAsync(archivePath);
-        }
+        await releaseLock();
     }
-    writeVersionFile(chromeMode, expectedVersion);
-    const revisionInfo = (0, exports.getRevisionInfo)(chromeMode);
-    (0, make_file_executable_1.makeFileExecutableIfItIsNot)(revisionInfo.executablePath);
-    return revisionInfo;
 };
 exports.downloadBrowser = downloadBrowser;
 const getFolderPath = (downloadsFolder, platform) => {

package/dist/browser/browser-download-lock.d.ts

@@ -0,0 +1 @@
+export declare const acquireBrowserDownloadLock: (lockPath: string) => Promise<() => Promise<void>>;

package/dist/browser/browser-download-lock.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireBrowserDownloadLock = void 0;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const RETRY_INTERVAL_IN_MS = 100;
+const STALE_LOCK_IN_MS = 30000;
+const HEARTBEAT_INTERVAL_IN_MS = 5000;
+const wait = (timeoutInMilliseconds) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeoutInMilliseconds);
+    });
+};
+const isErrorWithCode = (error, code) => {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === code);
+};
+const readLock = async (lockPath) => {
+    try {
+        const parsed = JSON.parse(await fs.promises.readFile(lockPath, 'utf8'));
+        if (typeof parsed.hostname !== 'string' ||
+            typeof parsed.pid !== 'number' ||
+            typeof parsed.token !== 'string') {
+            return null;
+        }
+        return parsed;
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const isProcessRunning = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !isErrorWithCode(error, 'ESRCH');
+    }
+};
+const removeStaleLock = async (lockPath) => {
+    let stats;
+    try {
+        stats = await fs.promises.stat(lockPath);
+    }
+    catch (error) {
+        if (isErrorWithCode(error, 'ENOENT')) {
+            return;
+        }
+        throw error;
+    }
+    const lock = await readLock(lockPath);
+    if ((lock === null || lock === void 0 ? void 0 : lock.hostname) === node_os_1.default.hostname()) {
+        if (isProcessRunning(lock.pid)) {
+            return;
+        }
+    }
+    else if (Date.now() - stats.mtimeMs < STALE_LOCK_IN_MS) {
+        return;
+    }
+    try {
+        await fs.promises.unlink(lockPath);
+    }
+    catch (error) {
+        if (!isErrorWithCode(error, 'ENOENT')) {
+            throw error;
+        }
+    }
+};
+const acquireBrowserDownloadLock = async (lockPath) => {
+    // Browser archives and extraction directories are shared by every Remotion
+    // process in a project, so the whole installation must be cross-process safe.
+    for (;;) {
+        const token = (0, node_crypto_1.randomUUID)();
+        let lockFile;
+        try {
+            lockFile = await fs.promises.open(lockPath, 'wx');
+        }
+        catch (error) {
+            if (!isErrorWithCode(error, 'EEXIST')) {
+                throw error;
+            }
+            await removeStaleLock(lockPath);
+            await wait(RETRY_INTERVAL_IN_MS);
+            continue;
+        }
+        try {
+            await lockFile.writeFile(JSON.stringify({
+                hostname: node_os_1.default.hostname(),
+                pid: process.pid,
+                token,
+            }));
+        }
+        catch (error) {
+            await lockFile.close();
+            await fs.promises.rm(lockPath, { force: true });
+            throw error;
+        }
+        const heartbeat = setInterval(async () => {
+            const currentLock = await readLock(lockPath);
+            if ((currentLock === null || currentLock === void 0 ? void 0 : currentLock.token) !== token) {
+                return;
+            }
+            const now = new Date();
+            try {
+                await fs.promises.utimes(lockPath, now, now);
+            }
+            catch (_a) {
+                // The lock may have been cleaned up while the heartbeat was pending.
+            }
+        }, HEARTBEAT_INTERVAL_IN_MS);
+        heartbeat.unref();
+        return async () => {
+            clearInterval(heartbeat);
+            const currentLock = await readLock(lockPath);
+            await lockFile.close();
+            if ((currentLock === null || currentLock === void 0 ? void 0 : currentLock.token) === token) {
+                await fs.promises.rm(lockPath, { force: true });
+            }
+        };
+    }
+};
+exports.acquireBrowserDownloadLock = acquireBrowserDownloadLock;

package/dist/client.d.ts

@@ -1364,14 +1364,14 @@ export declare const BrowserSafeApis: {
             description: () => import("react/jsx-runtime").JSX.Element;
             ssrName: "frameRange";
             docLink: string;
-            type: import("./frame-range").FrameRange | null;
+            type: import("./frame-range").FrameSelection;
             getValue: ({ commandLine }: {
                 commandLine: Record<string, unknown>;
             }) => {
                 source: string;
-                value: import("./frame-range").FrameRange | null;
+                value: import("./frame-range").FrameSelection;
             };
-            setConfig: (value: import("./frame-range").FrameRange | null) => void;
+            setConfig: (value: import("./frame-range").FrameSelection) => void;
             id: "frames";
         };
         forceNewStudioOption: {
@@ -1565,7 +1565,7 @@ export declare const BrowserSafeApis: {
         };
         rspackOption: {
             name: string;
-            cliFlag: "experimental-rspack";
+            cliFlag: "rspack";
             description: () => import("react/jsx-runtime").JSX.Element;
             ssrName: null;
             docLink: null;
@@ -1577,7 +1577,7 @@ export declare const BrowserSafeApis: {
                 source: string;
             };
             setConfig(value: boolean): void;
-            id: "experimental-rspack";
+            id: "rspack";
         };
         outDirOption: {
             name: string;

package/dist/combine-chunks.d.ts

@@ -1,5 +1,5 @@
 import type { Codec } from './codec';
-import type { FrameRange } from './frame-range';
+import type { SingleFrameRange } from './frame-range';
 import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 import type { AudioCodec } from './options/audio-codec';
@@ -27,7 +27,7 @@ type OptionalCombineChunksOptions = {
     audioCodec: AudioCodec | null;
     cancelSignal: CancelSignal | undefined;
     metadata: Record<string, string> | null;
-    frameRange: FrameRange | null;
+    frameRange: SingleFrameRange | null;
     everyNthFrame: number;
     sampleRate: number;
 };

package/dist/combine-chunks.js

@@ -45,8 +45,8 @@ const internalCombineChunks = async ({ outputLocation: output, onProgress, codec
     });
     const shouldCreateAudio = resolvedAudioCodec !== null && audioFiles.length > 0;
     const seamlessVideo = (0, can_concat_seamlessly_1.canConcatVideoSeamlessly)(codec);
-    const seamlessAudio = (0, can_concat_seamlessly_1.canConcatAudioSeamlessly)(resolvedAudioCodec, framesPerChunk);
     const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(compositionDurationInFrames, frameRange);
+    const seamlessAudio = (0, can_concat_seamlessly_1.canConcatAudioSeamlessly)(resolvedAudioCodec, framesPerChunk);
     const numberOfFrames = (0, get_duration_from_frame_range_1.getFramesToRender)(realFrameRange, everyNthFrame).length;
     const videoOutput = shouldCreateVideo
         ? (0, node_path_1.join)(filelistDir, `video.${(0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, resolvedAudioCodec)}`)

package/dist/create-audio.js

@@ -25,7 +25,7 @@ const createAudio = async ({ assets, onDownload, fps, logLevel, onProgress, down
         binariesDirectory,
     });
     (0, download_and_map_assets_to_file_1.markAllAssetsAsDownloaded)(downloadMap);
-    const assetPositions = (0, calculate_asset_positions_1.calculateAssetPositions)(fileUrlAssets);
+    const assetPositions = (0, calculate_asset_positions_1.calculateAssetPositions)(fileUrlAssets, assets.map((asset) => asset.frame));
     logger_1.Log.verbose({ indent, logLevel, tag: 'audio' }, 'asset positions', JSON.stringify(assetPositions));
     const preprocessProgress = new Array(assetPositions.length).fill(0);
     let mergeProgress = 0;