@remotion/renderer 4.0.501 → 4.0.503

package/dist/esm/index.mjs

@@ -68,7 +68,7 @@ var require_pend = __commonJS((exports, module) => {
 
 // vendor/yauzl-patched/fd-slicer.js
 var require_fd_slicer = __commonJS((exports) => {
-  var fs5 = __require("fs");
+  var fs6 = __require("fs");
   var util = __require("util");
   var stream = __require("stream");
   var Readable = stream.Readable;
@@ -93,7 +93,7 @@ var require_fd_slicer = __commonJS((exports) => {
   FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
     var self = this;
     self.pend.go(function(cb) {
-      fs5.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+      fs6.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
         cb();
         callback(err, bytesRead, buffer2);
       });
@@ -102,7 +102,7 @@ var require_fd_slicer = __commonJS((exports) => {
   FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
     var self = this;
     self.pend.go(function(cb) {
-      fs5.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
+      fs6.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
         cb();
         callback(err, written, buffer2);
       });
@@ -125,7 +125,7 @@ var require_fd_slicer = __commonJS((exports) => {
     if (self.refCount < 0)
       throw new Error("invalid unref");
     if (self.autoClose) {
-      fs5.close(self.fd, onCloseDone);
+      fs6.close(self.fd, onCloseDone);
     }
     function onCloseDone(err) {
       if (err) {
@@ -164,7 +164,7 @@ var require_fd_slicer = __commonJS((exports) => {
       if (self._destroyed)
         return cb();
       var buffer = Buffer.allocUnsafe(toRead);
-      fs5.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+      fs6.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
         if (self._destroyed)
           return cb();
         if (err) {
@@ -221,7 +221,7 @@ var require_fd_slicer = __commonJS((exports) => {
     self.context.pend.go(function(cb) {
       if (self._destroyed)
         return cb();
-      fs5.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+      fs6.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
         if (err2) {
           self.destroy();
           cb();
@@ -5372,6 +5372,45 @@ var defaultFileExtensionMap = {
 };
 
 // src/frame-range.ts
+var isMultipleFrameRanges = (frameRange) => {
+  return Array.isArray(frameRange) && Array.isArray(frameRange[0]);
+};
+var validateFrameRangeTuple = (frameRange) => {
+  if (frameRange.length !== 2) {
+    throw new TypeError("Frame range must be a tuple, got an array with length " + frameRange.length);
+  }
+  const [first, second] = frameRange;
+  if (typeof first !== "number") {
+    throw new Error(`The first value of frame range must be a number, but got ${typeof first} (${JSON.stringify(first)})`);
+  }
+  if (!Number.isFinite(first)) {
+    throw new TypeError("The first value of frame range must be finite, but got " + first);
+  }
+  if (!Number.isInteger(first)) {
+    throw new Error(`The first value of frame range must be an integer, but got a float (${first})`);
+  }
+  if (first < 0) {
+    throw new Error(`The first value of frame range must be non-negative, but got ${first}`);
+  }
+  if (second === null) {
+    return;
+  }
+  if (typeof second !== "number") {
+    throw new Error(`The second value of frame range must be a number or null, but got ${typeof second} (${JSON.stringify(second)})`);
+  }
+  if (!Number.isFinite(second)) {
+    throw new TypeError("The second value of frame range must be finite, but got " + second);
+  }
+  if (!Number.isInteger(second)) {
+    throw new Error(`The second value of frame range must be an integer, but got a float (${second})`);
+  }
+  if (second < 0) {
+    throw new Error(`The second value of frame range must be non-negative, but got ${second}`);
+  }
+  if (second < first) {
+    throw new Error("The second value of frame range must be not smaller than the first one, but got " + frameRange.join("-"));
+  }
+};
 var validateFrameRange = (frameRange) => {
   if (frameRange === null) {
     return;
@@ -5388,43 +5427,27 @@ var validateFrameRange = (frameRange) => {
     }
     return;
   }
-  if (Array.isArray(frameRange)) {
-    if (frameRange.length !== 2) {
-      throw new TypeError("Frame range must be a tuple, got an array with length " + frameRange.length);
-    }
-    const [first, second] = frameRange;
-    if (typeof first !== "number") {
-      throw new Error(`The first value of frame range must be a number, but got ${typeof first} (${JSON.stringify(first)})`);
-    }
-    if (!Number.isFinite(first)) {
-      throw new TypeError("The first value of frame range must be finite, but got " + first);
-    }
-    if (!Number.isInteger(first)) {
-      throw new Error(`The first value of frame range must be an integer, but got a float (${first})`);
-    }
-    if (first < 0) {
-      throw new Error(`The first value of frame range must be non-negative, but got ${first}`);
-    }
-    if (second === null) {
-      return;
+  if (isMultipleFrameRanges(frameRange)) {
+    if (frameRange.length === 0) {
+      throw new TypeError("Multiple frame ranges must not be empty.");
     }
-    if (typeof second !== "number") {
-      throw new Error(`The second value of frame range must be a number or null, but got ${typeof second} (${JSON.stringify(second)})`);
-    }
-    if (!Number.isFinite(second)) {
-      throw new TypeError("The second value of frame range must be finite, but got " + second);
-    }
-    if (!Number.isInteger(second)) {
-      throw new Error(`The second value of frame range must be an integer, but got a float (${second})`);
-    }
-    if (second < 0) {
-      throw new Error(`The second value of frame range must be non-negative, but got ${second}`);
-    }
-    if (second < first) {
-      throw new Error("The second value of frame range must be not smaller than the first one, but got " + frameRange.join("-"));
+    for (let index = 0;index < frameRange.length; index++) {
+      const range = frameRange[index];
+      validateFrameRangeTuple(range);
+      if (range[1] === null && index !== frameRange.length - 1) {
+        throw new Error("An open-ended frame range must be the last range.");
+      }
+      const previous = frameRange[index - 1];
+      if (previous && previous[1] !== null && range[0] <= previous[1]) {
+        throw new Error(`Frame ranges must be ordered and non-overlapping, but got ${previous.join("-")} followed by ${range.join("-")}.`);
+      }
     }
     return;
   }
+  if (Array.isArray(frameRange)) {
+    validateFrameRangeTuple(frameRange);
+    return;
+  }
   throw new TypeError("Frame range must be a number or a tuple of numbers, but got object of type " + typeof frameRange);
 };
 
@@ -5471,8 +5494,8 @@ var defaultOnLog = ({ logLevel, tag, previewString }) => {
 };
 
 // src/open-browser.ts
-import fs11 from "node:fs";
-import os6 from "node:os";
+import fs12 from "node:fs";
+import os7 from "node:os";
 import path10 from "node:path";
 import { NoReactInternals as NoReactInternals7 } from "remotion/no-react";
 
@@ -5507,14 +5530,121 @@ var launchChrome = async ({
 };
 
 // src/ensure-browser.ts
-import fs9 from "fs";
+import fs10 from "fs";
 
 // src/browser/BrowserFetcher.ts
-import * as fs8 from "node:fs";
-import * as os4 from "node:os";
+import * as fs9 from "node:fs";
+import * as os5 from "node:os";
 import * as path9 from "node:path";
 import { promisify as promisify2 } from "node:util";
 
+// src/browser/browser-download-lock.ts
+import { randomUUID } from "node:crypto";
+import * as fs5 from "node:fs";
+import os3 from "node:os";
+var RETRY_INTERVAL_IN_MS = 100;
+var STALE_LOCK_IN_MS = 30000;
+var HEARTBEAT_INTERVAL_IN_MS = 5000;
+var wait = (timeoutInMilliseconds) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeoutInMilliseconds);
+  });
+};
+var isErrorWithCode = (error, code) => {
+  return error instanceof Error && "code" in error && error.code === code;
+};
+var readLock = async (lockPath) => {
+  try {
+    const parsed = JSON.parse(await fs5.promises.readFile(lockPath, "utf8"));
+    if (typeof parsed.hostname !== "string" || typeof parsed.pid !== "number" || typeof parsed.token !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var isProcessRunning = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !isErrorWithCode(error, "ESRCH");
+  }
+};
+var removeStaleLock = async (lockPath) => {
+  let stats;
+  try {
+    stats = await fs5.promises.stat(lockPath);
+  } catch (error) {
+    if (isErrorWithCode(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+  const lock = await readLock(lockPath);
+  if (lock?.hostname === os3.hostname()) {
+    if (isProcessRunning(lock.pid)) {
+      return;
+    }
+  } else if (Date.now() - stats.mtimeMs < STALE_LOCK_IN_MS) {
+    return;
+  }
+  try {
+    await fs5.promises.unlink(lockPath);
+  } catch (error) {
+    if (!isErrorWithCode(error, "ENOENT")) {
+      throw error;
+    }
+  }
+};
+var acquireBrowserDownloadLock = async (lockPath) => {
+  for (;; ) {
+    const token = randomUUID();
+    let lockFile;
+    try {
+      lockFile = await fs5.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: os3.hostname(),
+        pid: process.pid,
+        token
+      }));
+    } catch (error) {
+      await lockFile.close();
+      await fs5.promises.rm(lockPath, { force: true });
+      throw error;
+    }
+    const heartbeat = setInterval(async () => {
+      const currentLock = await readLock(lockPath);
+      if (currentLock?.token !== token) {
+        return;
+      }
+      const now = new Date;
+      try {
+        await fs5.promises.utimes(lockPath, now, now);
+      } catch {}
+    }, HEARTBEAT_INTERVAL_IN_MS);
+    heartbeat.unref();
+    return async () => {
+      clearInterval(heartbeat);
+      const currentLock = await readLock(lockPath);
+      await lockFile.close();
+      if (currentLock?.token === token) {
+        await fs5.promises.rm(lockPath, { force: true });
+      }
+    };
+  }
+};
+
 // src/browser/extract-zip-archive.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir, realpath, symlink } from "node:fs/promises";
@@ -5524,7 +5654,7 @@ import { pipeline } from "node:stream/promises";
 import { promisify } from "node:util";
 
 // vendor/yauzl-patched/index.js
-var fs5 = __require("fs");
+var fs6 = __require("fs");
 var zlib = __require("zlib");
 var fd_slicer = require_fd_slicer();
 var crc32 = require_buffer_crc32();
@@ -5553,12 +5683,12 @@ function open(path7, options2, callback) {
     options2.strictFileNames = false;
   if (callback == null)
     callback = defaultCallback;
-  fs5.open(path7, "r", function(err, fd) {
+  fs6.open(path7, "r", function(err, fd) {
     if (err)
       return callback(err);
     fromFd(fd, options2, function(err2, zipfile) {
       if (err2)
-        fs5.close(fd, defaultCallback);
+        fs6.close(fd, defaultCallback);
       callback(err2, zipfile);
     });
   });
@@ -5582,7 +5712,7 @@ function fromFd(fd, options2, callback) {
     options2.strictFileNames = false;
   if (callback == null)
     callback = defaultCallback;
-  fs5.fstat(fd, function(err, stats) {
+  fs6.fstat(fd, function(err, stats) {
     if (err)
       return callback(err);
     var reader = fd_slicer.createFromFd(fd, { autoClose: true });
@@ -6409,16 +6539,16 @@ var extractZipArchive = async (archivePath, dir) => {
 };
 
 // src/browser/get-chrome-download-url.ts
-import * as fs6 from "node:fs";
-import * as os3 from "node:os";
+import * as fs7 from "node:fs";
+import * as os4 from "node:os";
 var TESTED_VERSION = "149.0.7790.0";
 var PLAYWRIGHT_VERSION = "1421";
 var isAmazonLinux2023 = () => {
-  if (os3.platform() !== "linux") {
+  if (os4.platform() !== "linux") {
     return false;
   }
   try {
-    const osRelease = fs6.readFileSync("/etc/os-release", "utf-8");
+    const osRelease = fs7.readFileSync("/etc/os-release", "utf-8");
     return osRelease.includes("Amazon Linux") && osRelease.includes('VERSION="2023"');
   } catch {
     return false;
@@ -6511,14 +6641,14 @@ var logDownloadUrl = ({
 };
 
 // src/browser/get-download-destination.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path8 from "node:path";
 var getDownloadsCacheDir = () => {
   const cwd = process.cwd();
   let dir = cwd;
   for (;; ) {
     try {
-      if (fs7.statSync(path8.join(dir, "package.json")).isFile()) {
+      if (fs8.statSync(path8.join(dir, "package.json")).isFile()) {
         break;
       }
     } catch (e) {}
@@ -6542,22 +6672,22 @@ var getDownloadsCacheDir = () => {
 };
 
 // src/browser/BrowserFetcher.ts
-var mkdirAsync = fs8.promises.mkdir;
-var unlinkAsync = promisify2(fs8.unlink.bind(fs8));
+var mkdirAsync = fs9.promises.mkdir;
+var unlinkAsync = promisify2(fs9.unlink.bind(fs9));
 function existsAsync(filePath) {
   return new Promise((resolve2) => {
-    fs8.access(filePath, (err) => {
+    fs9.access(filePath, (err) => {
       return resolve2(!err);
     });
   });
 }
 var getPlatform = () => {
-  const platform3 = os4.platform();
+  const platform3 = os5.platform();
   switch (platform3) {
     case "darwin":
-      return os4.arch() === "arm64" ? "mac-arm64" : "mac-x64";
+      return os5.arch() === "arm64" ? "mac-arm64" : "mac-x64";
     case "linux":
-      return os4.arch() === "arm64" ? "linux-arm64" : "linux64";
+      return os5.arch() === "arm64" ? "linux-arm64" : "linux64";
     case "win32":
       return "win64";
     default:
@@ -6581,14 +6711,14 @@ var getExpectedVersion = (version, _chromeMode) => {
 var readVersionFile = (chromeMode) => {
   const versionFilePath = getVersionFilePath(chromeMode);
   try {
-    return fs8.readFileSync(versionFilePath, "utf-8").trim();
+    return fs9.readFileSync(versionFilePath, "utf-8").trim();
   } catch {
     return null;
   }
 };
 var writeVersionFile = (chromeMode, version) => {
   const versionFilePath = getVersionFilePath(chromeMode);
-  fs8.writeFileSync(versionFilePath, version);
+  fs9.writeFileSync(versionFilePath, version);
 };
 var downloadBrowser = async ({
   logLevel,
@@ -6612,71 +6742,82 @@ var downloadBrowser = async ({
     if (installedVersion === expectedVersion) {
       return getRevisionInfo(chromeMode);
     }
-    fs8.rmSync(outputPath, { recursive: true, force: true });
   }
   if (!await existsAsync(downloadsFolder)) {
     await mkdirAsync(downloadsFolder, {
       recursive: true
     });
   }
-  if (os4.platform() !== "darwin" && os4.platform() !== "linux" && os4.arch() === "arm64") {
+  if (os5.platform() !== "darwin" && os5.platform() !== "linux" && os5.arch() === "arm64") {
     throw new Error([
       "Chrome Headless Shell is not available for Windows for arm64 architecture."
     ].join(`
 `));
   }
-  logDownloadUrl({ url: downloadURL, logLevel, indent });
+  const releaseLock = await acquireBrowserDownloadLock(path9.join(downloadsFolder, "download.lock"));
   try {
-    await 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 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 = path9.join(outputPath, subdir);
-      const chromePath = path9.join(chromeLinuxFolder, "chrome");
-      if (fs8.existsSync(chromePath)) {
-        const chromeHeadlessShellPath = path9.join(chromeLinuxFolder, "chrome-headless-shell");
-        fs8.renameSync(chromePath, chromeHeadlessShellPath);
+    if (await existsAsync(outputPath)) {
+      const installedVersion = readVersionFile(chromeMode);
+      if (installedVersion === expectedVersion) {
+        return getRevisionInfo(chromeMode);
       }
-      if (fs8.existsSync(chromeLinuxFolder)) {
-        const targetFolder = path9.join(outputPath, "chrome-headless-shell-" + platform3);
-        if (chromeLinuxFolder !== targetFolder) {
-          fs8.renameSync(chromeLinuxFolder, targetFolder);
+      fs9.rmSync(outputPath, { recursive: true, force: true });
+    }
+    logDownloadUrl({ url: downloadURL, logLevel, indent });
+    try {
+      await 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 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 = path9.join(outputPath, subdir);
+        const chromePath = path9.join(chromeLinuxFolder, "chrome");
+        if (fs9.existsSync(chromePath)) {
+          const chromeHeadlessShellPath = path9.join(chromeLinuxFolder, "chrome-headless-shell");
+          fs9.renameSync(chromePath, chromeHeadlessShellPath);
         }
+        if (fs9.existsSync(chromeLinuxFolder)) {
+          const targetFolder = path9.join(outputPath, "chrome-headless-shell-" + platform3);
+          if (chromeLinuxFolder !== targetFolder) {
+            fs9.renameSync(chromeLinuxFolder, targetFolder);
+          }
+        }
+      }
+    } catch (err) {
+      return Promise.reject(err);
+    } finally {
+      if (await existsAsync(archivePath)) {
+        await unlinkAsync(archivePath);
       }
     }
-  } catch (err) {
-    return Promise.reject(err);
+    writeVersionFile(chromeMode, expectedVersion);
+    const revisionInfo = getRevisionInfo(chromeMode);
+    makeFileExecutableIfItIsNot(revisionInfo.executablePath);
+    return revisionInfo;
   } finally {
-    if (await existsAsync(archivePath)) {
-      await unlinkAsync(archivePath);
-    }
+    await releaseLock();
   }
-  writeVersionFile(chromeMode, expectedVersion);
-  const revisionInfo = getRevisionInfo(chromeMode);
-  makeFileExecutableIfItIsNot(revisionInfo.executablePath);
-  return revisionInfo;
 };
 var getFolderPath = (downloadsFolder, platform3) => {
   return path9.resolve(downloadsFolder, platform3);
@@ -6708,7 +6849,7 @@ var getRevisionInfo = (chromeMode) => {
   const platform3 = getPlatform();
   const folderPath = getFolderPath(downloadsFolder, platform3);
   const url = getChromeDownloadUrl({ platform: platform3, version: null, chromeMode });
-  const local = fs8.existsSync(folderPath);
+  const local = fs9.existsSync(folderPath);
   return {
     executablePath,
     folderPath,
@@ -6747,13 +6888,13 @@ var getBrowserStatus = ({
   chromeMode
 }) => {
   if (browserExecutable) {
-    if (!fs9.existsSync(browserExecutable)) {
+    if (!fs10.existsSync(browserExecutable)) {
       throw new Error(`"browserExecutable" was specified as '${browserExecutable}' but the path doesn't exist. Pass "null" for "browserExecutable" to download a browser automatically.`);
     }
     return { path: browserExecutable, type: "user-defined-path" };
   }
   const revision = getRevisionInfo(chromeMode);
-  if (revision.local && fs9.existsSync(revision.executablePath)) {
+  if (revision.local && fs10.existsSync(revision.executablePath)) {
     const actualVersion = readVersionFile(chromeMode);
     if (actualVersion === TESTED_VERSION) {
       return { path: revision.executablePath, type: "local-puppeteer-browser" };
@@ -6779,7 +6920,7 @@ var ensureBrowser = (options2) => {
 };
 
 // src/get-local-browser-executable.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 var getBrowserStatus2 = ({
   browserExecutablePath,
   indent,
@@ -6787,13 +6928,13 @@ var getBrowserStatus2 = ({
   chromeMode
 }) => {
   if (browserExecutablePath) {
-    if (!fs10.existsSync(browserExecutablePath)) {
+    if (!fs11.existsSync(browserExecutablePath)) {
       Log.warn({ indent, logLevel }, `Browser executable was specified as '${browserExecutablePath}' but the path doesn't exist.`);
     }
     return { path: browserExecutablePath, type: "user-defined-path" };
   }
   const revision = getRevisionInfo(chromeMode);
-  if (revision.local && fs10.existsSync(revision.executablePath)) {
+  if (revision.local && fs11.existsSync(revision.executablePath)) {
     return { path: revision.executablePath, type: "local-puppeteer-browser" };
   }
   return { type: "no-browser" };
@@ -6818,7 +6959,7 @@ var getLocalBrowserExecutable = ({
 
 // src/get-cpu-count.ts
 import { execSync as execSync3 } from "node:child_process";
-import os5 from "node:os";
+import os6 from "node:os";
 var nprocCount;
 var getConcurrencyFromNProc = () => {
   if (nprocCount !== undefined) {
@@ -6833,10 +6974,10 @@ var getConcurrencyFromNProc = () => {
   }
 };
 var getNodeCpuCount = () => {
-  if (typeof os5.availableParallelism === "function") {
-    return os5.availableParallelism();
+  if (typeof os6.availableParallelism === "function") {
+    return os6.availableParallelism();
   }
-  return os5.cpus().length;
+  return os6.cpus().length;
 };
 var getCpuCount = () => {
   const node = getNodeCpuCount();
@@ -7101,7 +7242,7 @@ var internalOpenBrowser = async ({
   if (chromiumOptions.userAgent) {
     Log.verbose({ indent, logLevel, tag: "openBrowser()" }, `Using custom user agent: ${chromiumOptions.userAgent}`);
   }
-  const userDataDir = await fs11.promises.mkdtemp(path10.join(os6.tmpdir(), "puppeteer_dev_chrome_profile-"));
+  const userDataDir = await fs12.promises.mkdtemp(path10.join(os7.tmpdir(), "puppeteer_dev_chrome_profile-"));
   const browserInstance = await launchChrome({
     executablePath,
     logLevel,
@@ -7278,7 +7419,7 @@ import path20 from "node:path";
 import { NoReactInternals as NoReactInternals9 } from "remotion/no-react";
 
 // src/assets/download-and-map-assets-to-file.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import path12, { extname as extname2 } from "node:path";
 import { random } from "remotion/no-react";
 
@@ -16314,7 +16455,7 @@ var downloadAsset = async ({
   const { downloadDir } = downloadMap;
   if (downloadMap.hasBeenDownloadedMap[src]?.[downloadDir]) {
     const claimedDownloadLocation = downloadMap.hasBeenDownloadedMap[src]?.[downloadDir];
-    if (fs12.existsSync(claimedDownloadLocation)) {
+    if (fs13.existsSync(claimedDownloadLocation)) {
       return claimedDownloadLocation;
     }
     downloadMap.hasBeenDownloadedMap[src][downloadDir] = null;
@@ -16353,7 +16494,7 @@ var downloadAsset = async ({
     });
     ensureOutputDirectory(output);
     const buff = Buffer.from(assetData, encoding);
-    await fs12.promises.writeFile(output, buff);
+    await fs13.promises.writeFile(output, buff);
     notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to: output });
     return output;
   }
@@ -16939,8 +17080,8 @@ class OffthreadVideoServerEmitter {
 }
 
 // src/tmp-dir.ts
-import fs13, { mkdirSync } from "node:fs";
-import os7 from "node:os";
+import fs14, { mkdirSync } from "node:fs";
+import os8 from "node:os";
 import path14 from "node:path";
 var alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
 var randomHash = () => {
@@ -16949,9 +17090,9 @@ var randomHash = () => {
   }).join("");
 };
 var tmpDir = (str) => {
-  const newDir = path14.join(os7.tmpdir(), str + randomHash());
-  if (fs13.existsSync(newDir)) {
-    fs13.rmSync(newDir, {
+  const newDir = path14.join(os8.tmpdir(), str + randomHash());
+  if (fs14.existsSync(newDir)) {
+    fs14.rmSync(newDir, {
       recursive: true,
       force: true
     });
@@ -16961,7 +17102,7 @@ var tmpDir = (str) => {
 };
 
 // src/assets/inline-audio-mixing.ts
-import fs14, { writeSync } from "node:fs";
+import fs15, { writeSync } from "node:fs";
 import path15 from "node:path";
 
 // src/assets/apply-tone-frequency.ts
@@ -17032,7 +17173,7 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
   const cleanup = () => {
     for (const fileName of Object.keys(openFiles)) {
       try {
-        fs14.closeSync(openFiles[fileName]);
+        fs15.closeSync(openFiles[fileName]);
         delete openFiles[fileName];
       } catch {}
     }
@@ -17053,7 +17194,7 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
   }) => {
     const filePath = getFilePath(asset);
     if (!openFiles[filePath]) {
-      openFiles[filePath] = fs14.openSync(filePath, "w");
+      openFiles[filePath] = fs15.openSync(filePath, "w");
     }
     if (writtenHeaders[filePath]) {
       return;
@@ -17100,9 +17241,9 @@ var makeInlineAudioMixing = (dir, sampleRate) => {
         sampleRate: finishSampleRate
       });
       try {
-        fs14.closeSync(openFiles[fileName]);
+        fs15.closeSync(openFiles[fileName]);
       } catch {}
-      fs14.renameSync(tmpFile, fileName);
+      fs15.renameSync(tmpFile, fileName);
     }
   };
   const addAsset = ({
@@ -17396,13 +17537,13 @@ var makeRange = (from, to) => {
 };
 
 // src/port-config.ts
-import os8 from "os";
+import os9 from "os";
 var cached = null;
 var getPortConfig = (preferIpv4) => {
   if (cached) {
     return cached;
   }
-  const networkInterfaces = os8.networkInterfaces();
+  const networkInterfaces = os9.networkInterfaces();
   const flattened = flattenNetworkInterfaces(networkInterfaces);
   const host = getHostToBind(flattened, preferIpv4);
   const hostsToTry = getHostsToTry(flattened);
@@ -17459,7 +17600,7 @@ var hasIpv4LoopbackAddress = (flattened) => {
 };
 
 // src/serve-handler/index.ts
-import { createReadStream, promises as promises2 } from "node:fs";
+import { createReadStream, promises as promises3 } from "node:fs";
 import path19 from "node:path";
 
 // src/serve-handler/is-path-inside.ts
@@ -17553,7 +17694,7 @@ var findRelated = async (current, relativePath) => {
     const related = possible[index];
     const absolutePath = path19.join(current, related);
     try {
-      stats = await promises2.lstat(absolutePath);
+      stats = await promises3.lstat(absolutePath);
     } catch (err) {
       if (err.code !== "ENOENT" && err.code !== "ENOTDIR") {
         throw err;
@@ -17609,7 +17750,7 @@ var serveHandler = async (request, response, config) => {
   let stats = null;
   if (path19.extname(relativePath) !== "") {
     try {
-      stats = await promises2.lstat(absolutePath);
+      stats = await promises3.lstat(absolutePath);
     } catch (err) {
       if (err.code !== "ENOENT" && err.code !== "ENOTDIR") {
         return internalError(absolutePath, response);
@@ -17629,7 +17770,7 @@ var serveHandler = async (request, response, config) => {
       }
     }
     try {
-      stats = await promises2.lstat(absolutePath);
+      stats = await promises3.lstat(absolutePath);
     } catch (err) {
       if (err.code !== "ENOENT" && err.code !== "ENOTDIR") {
         return internalError(absolutePath, response);
@@ -18901,11 +19042,12 @@ var getFramesToRender = (frameRange, everyNthFrame) => {
   if (everyNthFrame === 0) {
     throw new Error("everyNthFrame cannot be 0");
   }
-  return new Array(frameRange[1] - frameRange[0] + 1).fill(true).map((_, index) => {
-    return index + frameRange[0];
+  const ranges = Array.isArray(frameRange[0]) ? frameRange : [frameRange];
+  return ranges.flatMap((range) => new Array(range[1] - range[0] + 1).fill(true).map((_, index) => {
+    return index + range[0];
   }).filter((frame) => {
-    return (frame - frameRange[0]) % everyNthFrame === 0;
-  });
+    return (frame - range[0]) % everyNthFrame === 0;
+  }));
 };
 
 // src/get-extension-from-codec.ts
@@ -19080,10 +19222,7 @@ var getExtensionOfFilename = (filename) => {
 };
 
 // src/get-frame-to-render.ts
-var getRealFrameRange = (durationInFrames, frameRange) => {
-  if (frameRange === null) {
-    return [0, durationInFrames - 1];
-  }
+var resolveFrameRange = (durationInFrames, frameRange) => {
   if (typeof frameRange === "number") {
     if (frameRange < 0 || frameRange >= durationInFrames) {
       throw new Error(`Frame number is out of range, must be between 0 and ${durationInFrames - 1} but got ${frameRange}`);
@@ -19099,6 +19238,23 @@ var getRealFrameRange = (durationInFrames, frameRange) => {
   }
   return resolved;
 };
+var getRealFrameRanges = (durationInFrames, frameRange) => {
+  if (frameRange === null) {
+    return [[0, durationInFrames - 1]];
+  }
+  validateFrameRange(frameRange);
+  if (isMultipleFrameRanges(frameRange)) {
+    return frameRange.map((range) => resolveFrameRange(durationInFrames, range));
+  }
+  return [resolveFrameRange(durationInFrames, frameRange)];
+};
+var getRealFrameRange = (durationInFrames, frameRange) => {
+  const ranges = getRealFrameRanges(durationInFrames, frameRange);
+  if (ranges.length !== 1) {
+    throw new Error("Expected a single frame range, but received multiple frame ranges.");
+  }
+  return ranges[0];
+};
 
 // src/image-format.ts
 var validVideoImageFormats = ["png", "jpeg", "none"];
@@ -19221,7 +19377,7 @@ var validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
 };
 
 // src/render-frames.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import path22 from "node:path";
 import { NoReactInternals as NoReactInternals14 } from "remotion/no-react";
 
@@ -20154,7 +20310,7 @@ var onlyInlineAudio = (assets) => {
 import * as assert2 from "node:assert";
 
 // src/screenshot-task.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 var screenshotTask = async ({
   format: format2,
   height,
@@ -20215,7 +20371,7 @@ var screenshotTask = async ({
     }
     const buffer2 = Buffer.from(result.data, "base64");
     if (path21) {
-      await fs15.promises.writeFile(path21, buffer2);
+      await fs16.promises.writeFile(path21, buffer2);
     }
     return buffer2;
   } catch (err) {
@@ -20422,6 +20578,7 @@ var renderFrameWithOptionToReject = async ({
     return compressAsset(previousAudioRenderAssets, asset);
   });
   const inlineAudioAssets = onlyInlineAudio(collectedAssets);
+  const outputFrame = allFramesAndExtraFrames[0] + allFramesAndExtraFrames.indexOf(frame);
   assets.push({
     audioAndVideoAssets: compressedAssets,
     frame,
@@ -20450,7 +20607,7 @@ var renderFrameWithOptionToReject = async ({
   }
   for (const renderAsset of inlineAudioAssets) {
     downloadMap.inlineAudioMixing.addAsset({
-      asset: renderAsset,
+      asset: { ...renderAsset, frame: outputFrame },
       fps,
       totalNumberOfFrames: allFramesAndExtraFrames.length,
       firstFrame: allFramesAndExtraFrames[0],
@@ -20810,6 +20967,41 @@ var validateScale = (scale) => {
   }
 };
 
+// src/validate-selected-frames.ts
+var validateSelectedFrames = ({
+  frames,
+  durationInFrames
+}) => {
+  if (!Array.isArray(frames)) {
+    throw new TypeError("The `frames` option must be an array of frame numbers.");
+  }
+  if (frames.length === 0) {
+    throw new TypeError("The `frames` option must contain at least one frame.");
+  }
+  for (const frame of frames) {
+    if (typeof frame !== "number") {
+      throw new TypeError(`The \`frames\` option must contain only numbers, but got ${typeof frame}.`);
+    }
+    if (!Number.isFinite(frame)) {
+      throw new TypeError(`The \`frames\` option must contain only finite numbers, but got ${frame}.`);
+    }
+    if (!Number.isInteger(frame)) {
+      throw new TypeError(`The \`frames\` option must contain only integers, but got ${frame}.`);
+    }
+    if (frame < 0) {
+      throw new TypeError(`The \`frames\` option must contain only non-negative numbers, but got ${frame}.`);
+    }
+    if (durationInFrames !== null && frame >= durationInFrames) {
+      throw new RangeError(`Frame ${frame} is out of range, must be between 0 and ${durationInFrames - 1}.`);
+    }
+  }
+  const uniqueFrames = new Set(frames);
+  if (uniqueFrames.size !== frames.length) {
+    throw new TypeError("The `frames` option must not contain duplicate frames.");
+  }
+  return [...frames].sort((a, b) => a - b);
+};
+
 // src/render-frames.ts
 var MAX_RETRIES_PER_FRAME = 1;
 var innerRenderFrames = async ({
@@ -20821,6 +21013,8 @@ var innerRenderFrames = async ({
   jpegQuality,
   imageFormat,
   frameRange,
+  frames,
+  outputFramesInSequence,
   onError,
   envVariables,
   onBrowserLog,
@@ -20854,18 +21048,25 @@ var innerRenderFrames = async ({
   sampleRate
 }) => {
   if (outputDir) {
-    if (!fs16.existsSync(outputDir)) {
-      fs16.mkdirSync(outputDir, {
+    if (!fs17.existsSync(outputDir)) {
+      fs17.mkdirSync(outputDir, {
         recursive: true
       });
     }
   }
   const downloadPromises = [];
-  const realFrameRange = getRealFrameRange(composition.durationInFrames, frameRange);
+  const framesToRender = frames ? validateSelectedFrames({
+    frames,
+    durationInFrames: composition.durationInFrames
+  }) : getFramesToRender(getRealFrameRanges(composition.durationInFrames, frameRange), everyNthFrame);
+  const realFrameRange = [
+    framesToRender[0],
+    framesToRender[framesToRender.length - 1]
+  ];
   const {
     extraFramesToCaptureAssetsBackend,
     extraFramesToCaptureAssetsFrontend,
-    chunkLengthInSeconds,
+    chunkLengthInSeconds: seamlessChunkLengthInSeconds,
     trimLeftOffset,
     trimRightOffset
   } = getExtraFramesToCapture({
@@ -20875,7 +21076,7 @@ var innerRenderFrames = async ({
     forSeamlessAacConcatenation,
     sampleRate
   });
-  const framesToRender = getFramesToRender(realFrameRange, everyNthFrame);
+  const chunkLengthInSeconds = forSeamlessAacConcatenation ? seamlessChunkLengthInSeconds : framesToRender.length / composition.fps;
   const lastFrame = framesToRender[framesToRender.length - 1];
   const concurrencyOrFramesToRender = Math.min(framesToRender.length, resolvedConcurrency);
   const makeNewPage = (frame, pageIndex) => {
@@ -20911,7 +21112,7 @@ var innerRenderFrames = async ({
     const pool = new Pool(puppeteerPages);
     return pool;
   };
-  const countType = everyNthFrame === 1 ? "actual-frames" : "from-zero";
+  const countType = outputFramesInSequence ? "from-zero" : everyNthFrame === 1 ? "actual-frames" : "from-zero";
   const filePadLength = getFilePadLength({
     lastFrame,
     totalFrames: framesToRender.length,
@@ -21016,6 +21217,8 @@ var internalRenderFramesRaw = ({
   envVariables,
   everyNthFrame,
   frameRange,
+  frames,
+  outputFramesInSequence,
   imageFormat,
   indent,
   jpegQuality,
@@ -21129,6 +21332,8 @@ var internalRenderFramesRaw = ({
           envVariables,
           everyNthFrame,
           frameRange,
+          frames,
+          outputFramesInSequence,
           imageFormat,
           jpegQuality,
           muted,
@@ -21205,6 +21410,7 @@ var renderFrames = (options2) => {
     envVariables,
     everyNthFrame,
     frameRange,
+    frames,
     imageFormat,
     jpegQuality,
     muted,
@@ -21231,6 +21437,16 @@ var renderFrames = (options2) => {
   if (!composition) {
     throw new Error("No `composition` option has been specified for renderFrames()");
   }
+  if (frames !== undefined && frameRange !== undefined && frameRange !== null) {
+    throw new Error("The `frames` and `frameRange` options are mutually exclusive.");
+  }
+  if (frames !== undefined && everyNthFrame !== undefined) {
+    throw new Error("The `frames` and `everyNthFrame` options are mutually exclusive.");
+  }
+  const validatedFrames = frames === undefined ? null : validateSelectedFrames({
+    frames,
+    durationInFrames: composition.durationInFrames
+  });
   if (typeof jpegQuality !== "undefined" && imageFormat !== "jpeg") {
     throw new Error("You can only pass the `quality` option if `imageFormat` is 'jpeg'.");
   }
@@ -21248,6 +21464,8 @@ var renderFrames = (options2) => {
     envVariables: envVariables ?? {},
     everyNthFrame: everyNthFrame ?? 1,
     frameRange: frameRange ?? null,
+    frames: validatedFrames,
+    outputFramesInSequence: frameRange !== undefined && frameRange !== null && isMultipleFrameRanges(frameRange),
     imageFormat: imageFormat ?? "jpeg",
     indent,
     jpegQuality: jpegQuality ?? DEFAULT_JPEG_QUALITY,
@@ -21292,8 +21510,8 @@ var renderFrames = (options2) => {
 };
 
 // src/render-media.ts
-import fs18 from "node:fs";
-import os9 from "node:os";
+import fs19 from "node:fs";
+import os10 from "node:os";
 import path28 from "node:path";
 import { LicensingInternals } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals17 } from "remotion/no-react";
@@ -22062,7 +22280,7 @@ var validateSelectedCodecAndProResCombination = ({
 };
 
 // src/stitch-frames-to-video.ts
-import { cpSync as cpSync2, promises as promises3, rmSync as rmSync4 } from "node:fs";
+import { cpSync as cpSync2, promises as promises4, rmSync as rmSync4 } from "node:fs";
 import path27 from "node:path";
 
 // src/convert-number-of-gif-loops-to-ffmpeg.ts
@@ -22166,12 +22384,18 @@ var indexUncompressedAssets = (renderAssets) => {
   }
   return assetsByReference;
 };
-var calculateAssetPositions = (frames) => {
+var calculateAssetPositions = (frames, sourceFrames = frames.map((_, index) => index)) => {
   const assets = [];
   const openAssets = new Map;
   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) {
@@ -22331,7 +22555,7 @@ var createFfmpegMergeFilter = ({
 };
 
 // src/ffmpeg-filter-file.ts
-import fs17, { existsSync as existsSync5 } from "node:fs";
+import fs18, { existsSync as existsSync5 } from "node:fs";
 import path24 from "node:path";
 var makeFfmpegFilterFile = (complexFilter, downloadMap) => {
   if (complexFilter.filter === null) {
@@ -22348,13 +22572,13 @@ var makeFfmpegFilterFileStr = async (complexFilter, downloadMap) => {
   const random2 = Math.random().toString().replace(".", "");
   const filterFile = path24.join(downloadMap.complexFilter, "complex-filter-" + random2 + ".txt");
   if (!existsSync5(downloadMap.complexFilter)) {
-    fs17.mkdirSync(downloadMap.complexFilter, { recursive: true });
+    fs18.mkdirSync(downloadMap.complexFilter, { recursive: true });
   }
-  await fs17.promises.writeFile(filterFile, complexFilter);
+  await fs18.promises.writeFile(filterFile, complexFilter);
   return {
     file: filterFile,
     cleanup: () => {
-      fs17.unlinkSync(filterFile);
+      fs18.unlinkSync(filterFile);
     }
   };
 };
@@ -22907,7 +23131,7 @@ var createAudio = async ({
     binariesDirectory
   });
   markAllAssetsAsDownloaded(downloadMap);
-  const assetPositions = calculateAssetPositions(fileUrlAssets);
+  const assetPositions = calculateAssetPositions(fileUrlAssets, assets.map((asset) => asset.frame));
   Log.verbose({ indent, logLevel, tag: "audio" }, "asset positions", JSON.stringify(assetPositions));
   const preprocessProgress = new Array(assetPositions.length).fill(0);
   let mergeProgress = 0;
@@ -23223,7 +23447,7 @@ var innerStitchFramesToVideo = async ({
     deleteDirectory(path27.dirname(audio));
     const file = await new Promise((resolve2, reject) => {
       if (tempFile) {
-        promises3.readFile(tempFile).then((f) => {
+        promises4.readFile(tempFile).then((f) => {
           return resolve2(f);
         }).catch((e) => reject(e));
       } else {
@@ -23331,7 +23555,7 @@ var innerStitchFramesToVideo = async ({
           cleanDownloadMap(assetsInfo.downloadMap);
           return resolve2(null);
         }
-        promises3.readFile(tempFile).then((f) => {
+        promises4.readFile(tempFile).then((f) => {
           resolve2(f);
         }).catch((e) => {
           reject(e);
@@ -23720,7 +23944,7 @@ var internalRenderMediaRaw = ({
   }
   const imageFormat = isAudioCodec(codec) ? "none" : provisionalImageFormat ?? compositionWithPossibleUnevenDimensions.defaultVideoImageFormat ?? DEFAULT_VIDEO_IMAGE_FORMAT;
   validateSelectedPixelFormatAndImageFormatCombination(pixelFormat, imageFormat);
-  const workingDir = fs18.mkdtempSync(path28.join(os9.tmpdir(), "react-motion-render"));
+  const workingDir = fs19.mkdtempSync(path28.join(os10.tmpdir(), "react-motion-render"));
   const preEncodedFileLocation = parallelEncoding ? path28.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
   if (onCtrlCExit && workingDir) {
     onCtrlCExit(`Delete ${workingDir}`, () => deleteDirectory(workingDir));
@@ -23741,9 +23965,11 @@ var internalRenderMediaRaw = ({
     height: heightEvenDimensions,
     width: widthEvenDimensions
   };
-  const realFrameRange = getRealFrameRange(composition.durationInFrames, frameRange);
-  const totalFramesToRender = getFramesToRender(realFrameRange, everyNthFrame).length;
-  Log.verbose({ indent, logLevel, tag: "renderMedia()" }, `Rendering frames ${realFrameRange.join("-")}`);
+  const realFrameRanges = getRealFrameRanges(composition.durationInFrames, frameRange);
+  const framesToRender = getFramesToRender(realFrameRanges, everyNthFrame);
+  const totalFramesToRender = framesToRender.length;
+  const lastFrameToRender = framesToRender[framesToRender.length - 1];
+  Log.verbose({ indent, logLevel, tag: "renderMedia()" }, `Rendering frames ${realFrameRanges.map((range) => range.join("-")).join(", ")}`);
   const callUpdate = () => {
     const encoded = Math.round(0.8 * encodedFrames + 0.2 * muxedFrames);
     onProgress?.({
@@ -23762,7 +23988,7 @@ var internalRenderMediaRaw = ({
   cancelSignal?.(() => {
     cancelRenderFrames.cancel();
   });
-  const { waitForRightTimeOfFrameToBeInserted, setFrameToStitch, waitForFinish } = ensureFramesInOrder(realFrameRange);
+  const { waitForRightTimeOfFrameToBeInserted, setFrameToStitch, waitForFinish } = ensureFramesInOrder(framesToRender);
   const fps = composition.fps / everyNthFrame;
   validateFps(fps, 'in "renderMedia()"', codec === "gif");
   const createPrestitcherIfNecessary = () => {
@@ -23881,6 +24107,8 @@ var internalRenderMediaRaw = ({
         imageFormat,
         jpegQuality,
         frameRange,
+        frames: null,
+        outputFramesInSequence: true,
         puppeteerInstance,
         everyNthFrame,
         onFrameBuffer: parallelEncoding ? async (buffer2, frame) => {
@@ -23898,7 +24126,8 @@ var internalRenderMediaRaw = ({
           }
           stitcherFfmpeg?.stdin?.write(buffer2);
           stopPerfMeasure(id);
-          setFrameToStitch(Math.min(realFrameRange[1] + 1, frame + everyNthFrame));
+          const frameIndex = framesToRender.indexOf(frame);
+          setFrameToStitch(framesToRender[frameIndex + 1] ?? lastFrameToRender + 1);
         } : null,
         webpackBundleOrServeUrl: serveUrl,
         onBrowserLog,
@@ -24051,10 +24280,10 @@ var internalRenderMediaRaw = ({
       }
       reject(err);
     }).finally(() => {
-      if (preEncodedFileLocation !== null && fs18.existsSync(preEncodedFileLocation)) {
+      if (preEncodedFileLocation !== null && fs19.existsSync(preEncodedFileLocation)) {
         deleteDirectory(path28.dirname(preEncodedFileLocation));
       }
-      if (workingDir && fs18.existsSync(workingDir)) {
+      if (workingDir && fs19.existsSync(workingDir)) {
         deleteDirectory(workingDir);
       }
       cleanupServerFn?.(false).catch((err) => {
@@ -24225,7 +24454,7 @@ var renderMedia = ({
 };
 
 // src/render-still.ts
-import fs19, { statSync as statSync2 } from "node:fs";
+import fs20, { statSync as statSync2 } from "node:fs";
 import path29 from "node:path";
 import { LicensingInternals as LicensingInternals2 } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals18 } from "remotion/no-react";
@@ -24280,7 +24509,7 @@ var innerRenderStill = async ({
   output = typeof output === "string" ? path29.resolve(process.cwd(), output) : null;
   validateJpegQuality(jpegQuality);
   if (output) {
-    if (fs19.existsSync(output)) {
+    if (fs20.existsSync(output)) {
       if (!overwrite) {
         throw new Error(`Cannot render still - "overwrite" option was set to false, but the output destination ${output} already exists.`);
       }
@@ -25154,8 +25383,8 @@ var internalCombineChunks = async ({
   });
   const shouldCreateAudio = resolvedAudioCodec !== null && audioFiles.length > 0;
   const seamlessVideo = canConcatVideoSeamlessly(codec);
-  const seamlessAudio = canConcatAudioSeamlessly(resolvedAudioCodec, framesPerChunk);
   const realFrameRange = getRealFrameRange(compositionDurationInFrames, frameRange);
+  const seamlessAudio = canConcatAudioSeamlessly(resolvedAudioCodec, framesPerChunk);
   const numberOfFrames = getFramesToRender(realFrameRange, everyNthFrame).length;
   const videoOutput = shouldCreateVideo ? join6(filelistDir, `video.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`) : null;
   const audioOutput = shouldCreateAudio ? join6(filelistDir, `audio.${getExtensionFromAudioCodec(resolvedAudioCodec)}`) : null;
@@ -25379,10 +25608,24 @@ var getVideoMetadata = async (videoSource, options2) => {
 };
 // src/options/chrome-mode.tsx
 import { jsx as jsx7, jsxs as jsxs7, Fragment as Fragment7 } from "react/jsx-runtime";
-// src/options/number-of-gif-loops.tsx
+// src/options/default-editor.tsx
 import { jsx as jsx8, jsxs as jsxs8, Fragment as Fragment8 } from "react/jsx-runtime";
-// src/options/on-browser-download.tsx
+var defaultEditorIds = [
+  "vscode",
+  "cursor",
+  "windsurf",
+  "zed",
+  "vscodium",
+  "webstorm",
+  "sublime-text"
+];
+var customEditorTargetPathPlaceholder = "%TARGET_PATH%";
+var customEditorLineNumberPlaceholder = "%LINE_NUMBER%";
+var customEditorColumnNumberPlaceholder = "%COLUMN_NUMBER%";
+// src/options/number-of-gif-loops.tsx
 import { jsx as jsx9, jsxs as jsxs9, Fragment as Fragment9 } from "react/jsx-runtime";
+// src/options/on-browser-download.tsx
+import { jsx as jsx10, jsxs as jsxs10, Fragment as Fragment10 } from "react/jsx-runtime";
 // src/index.ts
 var RenderInternals = {
   resolveConcurrency,
@@ -25394,6 +25637,7 @@ var RenderInternals = {
   isServeUrl,
   ensureOutputDirectory,
   getRealFrameRange,
+  getRealFrameRanges,
   validatePuppeteerTimeout,
   downloadFile,
   parseStack,
@@ -25416,6 +25660,7 @@ var RenderInternals = {
   validPixelFormats,
   DEFAULT_BROWSER,
   validateFrameRange,
+  validateSelectedFrames,
   DEFAULT_OPENGL_RENDERER,
   validateOpenGlRenderer,
   validCodecs,
@@ -25492,6 +25737,10 @@ export {
   getCompositions,
   extractAudio,
   ensureBrowser,
+  defaultEditorIds,
+  customEditorTargetPathPlaceholder,
+  customEditorLineNumberPlaceholder,
+  customEditorColumnNumberPlaceholder,
   combineChunks,
   RenderInternals,
   ErrorWithStackFrame