@remotion/renderer 4.0.278 → 4.0.279

package/dist/esm/index.mjs

@@ -4059,536 +4059,386 @@ var validCodecs = [
 ];
 var DEFAULT_CODEC = "h264";
 
-// src/combine-videos.ts
-import { rmSync as rmSync4 } from "node:fs";
-import { join as join4 } from "node:path";
-
-// src/combine-audio.ts
-import { rmSync as rmSync2, writeFileSync } from "fs";
-import { join as join2 } from "path";
-import { VERSION as VERSION2 } from "remotion/version";
-
-// src/options/separate-audio.tsx
-var DEFAULT = null;
-var cliFlag = "separate-audio-to";
-var separateAudioOption = {
-  cliFlag,
-  description: () => `If set, the audio will not be included in the main output but rendered as a separate file at the location you pass. It is recommended to use an absolute path. If a relative path is passed, it is relative to the Remotion Root.`,
-  docLink: "https://remotion.dev/docs/renderer/render-media",
-  getValue: ({ commandLine }) => {
-    if (commandLine[cliFlag]) {
-      return {
-        source: "cli",
-        value: commandLine[cliFlag]
-      };
-    }
-    return {
-      source: "default",
-      value: DEFAULT
-    };
-  },
-  name: "Separate audio to",
-  setConfig: () => {
-    throw new Error("Not implemented");
-  },
-  ssrName: "separateAudioTo",
-  type: "string"
+// src/convert-to-positive-frame-index.ts
+var convertToPositiveFrameIndex = ({
+  frame,
+  durationInFrames
+}) => {
+  return frame < 0 ? durationInFrames - frame : frame;
 };
 
-// src/options/audio-codec.tsx
-var validAudioCodecs = ["pcm-16", "aac", "mp3", "opus"];
-var supportedAudioCodecs = {
-  h264: ["aac", "pcm-16", "mp3"],
-  "h264-mkv": ["pcm-16", "mp3"],
-  "h264-ts": ["pcm-16", "aac"],
-  aac: ["aac", "pcm-16"],
-  avi: [],
-  gif: [],
-  h265: ["aac", "pcm-16"],
-  mp3: ["mp3", "pcm-16"],
-  prores: ["aac", "pcm-16"],
-  vp8: ["opus", "pcm-16"],
-  vp9: ["opus", "pcm-16"],
-  wav: ["pcm-16"]
-};
-var _satisfies = supportedAudioCodecs;
-if (_satisfies) {
-}
-var mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
-  if (audioCodec === "aac") {
-    return "libfdk_aac";
-  }
-  if (audioCodec === "mp3") {
-    return "libmp3lame";
-  }
-  if (audioCodec === "opus") {
-    return "libopus";
+// src/symbolicate-stacktrace.ts
+import { readFileSync } from "fs";
+import path6 from "path";
+import { SourceMapConsumer } from "source-map";
+function extractSourceMapUrl(fileContents) {
+  const regex = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/gm;
+  let match = null;
+  for (;; ) {
+    const next = regex.exec(fileContents);
+    if (next === null || next === undefined) {
+      break;
+    }
+    match = next;
   }
-  if (audioCodec === "pcm-16") {
-    return "pcm_s16le";
+  if (!match?.[1]) {
+    return null;
   }
-  throw new Error("unknown audio codec: " + audioCodec);
-};
-var cliFlag2 = "audio-codec";
-var ssrName = "audioCodec";
-var defaultAudioCodecs = {
-  "h264-mkv": {
-    lossless: "pcm-16",
-    compressed: "pcm-16"
-  },
-  "h264-ts": {
-    lossless: "pcm-16",
-    compressed: "aac"
-  },
-  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"
+  return match[1].toString();
+}
+var getSourceMapFromRemoteUrl = async (url) => {
+  if (!url.endsWith(".js.map")) {
+    throw new Error(`The URL ${url} does not seem to be a valid source map URL.`);
   }
+  const obj = await fetchUrl(url);
+  return new SourceMapConsumer(obj);
 };
-var extensionMap = {
-  aac: "aac",
-  mp3: "mp3",
-  opus: "opus",
-  "pcm-16": "wav"
-};
-var getExtensionFromAudioCodec = (audioCodec) => {
-  if (extensionMap[audioCodec]) {
-    return extensionMap[audioCodec];
+var getSourceMap = (filePath, fileContents, type) => {
+  const sm = extractSourceMapUrl(fileContents);
+  if (sm === null) {
+    return Promise.resolve(null);
   }
-  throw new Error(`Unsupported audio codec: ${audioCodec}`);
-};
-var resolveAudioCodec = ({
-  codec,
-  setting,
-  preferLossless,
-  separateAudioTo
-}) => {
-  let derivedFromSeparateAudioToExtension = null;
-  if (separateAudioTo) {
-    const extension = separateAudioTo.split(".").pop();
-    for (const [key, value] of Object.entries(extensionMap)) {
-      if (value === extension) {
-        derivedFromSeparateAudioToExtension = key;
-        if (!supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) && derivedFromSeparateAudioToExtension) {
-          throw new Error(`The codec is ${codec} but the audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${supportedAudioCodecs[codec].join(", ")}`);
-        }
-      }
+  if (sm.indexOf("data:") === 0) {
+    const base64 = /^data:application\/json;([\w=:"-]+;)*base64,/;
+    const match2 = sm.match(base64);
+    if (!match2) {
+      throw new Error("Sorry, non-base64 inline source-map encoding is not supported.");
     }
-  }
-  if (preferLossless) {
-    const selected = getDefaultAudioCodec({ codec, preferLossless });
-    if (derivedFromSeparateAudioToExtension && selected !== derivedFromSeparateAudioToExtension) {
-      throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from the "Prefer lossless" option (${selected}). Remove any conflicting options.`);
+    const converted = window.atob(sm.substring(match2[0].length));
+    try {
+      const sourceMapConsumer = new SourceMapConsumer(JSON.parse(converted));
+      return Promise.resolve(sourceMapConsumer);
+    } catch {
+      return Promise.resolve(null);
     }
-    return selected;
   }
-  if (setting === null) {
-    if (derivedFromSeparateAudioToExtension) {
-      return derivedFromSeparateAudioToExtension;
-    }
-    return getDefaultAudioCodec({ codec, preferLossless });
+  if (type === "local") {
+    const newFilePath = path6.join(path6.dirname(filePath), sm);
+    return Promise.resolve(new SourceMapConsumer(readFileSync(newFilePath, "utf8")));
   }
-  if (derivedFromSeparateAudioToExtension !== setting && derivedFromSeparateAudioToExtension) {
-    throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
+  const index = filePath.lastIndexOf("/");
+  const url = filePath.substring(0, index + 1) + sm;
+  return getSourceMapFromRemoteUrl(url);
+};
+var fetchUrl = async (url) => {
+  const res = await readFile(url);
+  return new Promise((resolve, reject) => {
+    let downloaded = "";
+    res.on("data", (d) => {
+      downloaded += d;
+    });
+    res.on("end", () => {
+      resolve(downloaded);
+    });
+    res.on("error", (err) => reject(err));
+  });
+};
+function getLinesAround(line, count, lines) {
+  const result = [];
+  for (let index = Math.max(0, line - 1 - count) + 1;index <= Math.min(lines.length - 1, line - 1 + count); ++index) {
+    result.push({
+      lineNumber: index + 1,
+      content: lines[index],
+      highlight: index + 1 === line
+    });
   }
-  return setting;
+  return result;
+}
+var getOriginalPosition = (source_map, line, column) => {
+  const result = source_map.originalPositionFor({
+    line,
+    column
+  });
+  return { line: result.line, column: result.column, source: result.source };
 };
-var getDefaultAudioCodec = ({
-  codec,
-  preferLossless
-}) => {
-  return defaultAudioCodecs[codec][preferLossless ? "lossless" : "compressed"];
+var symbolicateStackTraceFromRemoteFrames = async (frames) => {
+  const uniqueFileNames = [
+    ...new Set(frames.map((f) => f.fileName).filter((f) => f.startsWith("http://") || f.startsWith("https://")).filter(truthy))
+  ];
+  const maps = await Promise.all(uniqueFileNames.map((fileName) => {
+    return getSourceMapFromRemoteFile(fileName);
+  }));
+  const mapValues = {};
+  for (let i = 0;i < uniqueFileNames.length; i++) {
+    mapValues[uniqueFileNames[i]] = maps[i];
+  }
+  return symbolicateFromSources(frames, mapValues);
 };
-var _audioCodec = null;
-var audioCodecOption = {
-  cliFlag: cliFlag2,
-  setConfig: (audioCodec) => {
-    if (audioCodec === null) {
-      _audioCodec = null;
-      return;
-    }
-    if (!validAudioCodecs.includes(audioCodec)) {
-      throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${audioCodec}`);
-    }
-    _audioCodec = audioCodec;
-  },
-  getValue: ({ commandLine }) => {
-    if (commandLine[cliFlag2]) {
-      const codec = commandLine[cliFlag2];
-      if (!validAudioCodecs.includes(commandLine[cliFlag2])) {
-        throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${codec}`);
-      }
-      return {
-        source: "cli",
-        value: commandLine[cliFlag2]
-      };
-    }
-    if (_audioCodec !== null) {
-      return {
-        source: "config",
-        value: _audioCodec
-      };
+var symbolicateFromSources = (frames, mapValues) => {
+  return frames.map((frame) => {
+    const map = mapValues[frame.fileName];
+    if (!map) {
+      return null;
     }
-    return {
-      source: "default",
-      value: null
-    };
-  },
-  description: () => `Set the format of the audio that is embedded in the video. Not all codec and audio codec combinations are supported and certain combinations require a certain file extension and container format. See the table in the docs to see possible combinations.`,
-  docLink: "https://www.remotion.dev/docs/encoding/#audio-codec",
-  name: "Audio Codec",
-  ssrName,
-  type: "aac"
+    return symbolicateStackFrame(frame, map);
+  }).filter(truthy).filter((f) => f.originalScriptCode !== null);
 };
-
-// src/parse-ffmpeg-progress.ts
-var parseFfmpegProgress = (input, fps) => {
-  const match = input.match(/frame=(\s+)?([0-9]+)\s/);
-  if (match) {
-    return Number(match[2]);
-  }
-  const match2 = input.match(/time=(\d+):(\d+):(\d+).(\d+)\s/);
-  if (match2) {
-    const [, hours, minutes, seconds, hundreds] = match2;
-    return Number(hundreds) / 100 * fps + Number(seconds) * fps + Number(minutes) * fps * 60 + Number(hours) * fps * 60 * 60;
-  }
+var symbolicateStackFrame = (frame, map) => {
+  const pos = getOriginalPosition(map, frame.lineNumber, frame.columnNumber);
+  const hasSource = pos.source ? map.sourceContentFor(pos.source, false) : null;
+  const scriptCode = hasSource && pos.line ? getLinesAround(pos.line, 3, hasSource.split(`
+`)) : null;
+  return {
+    originalColumnNumber: pos.column,
+    originalFileName: pos.source,
+    originalFunctionName: frame.functionName,
+    originalLineNumber: pos.line,
+    originalScriptCode: scriptCode
+  };
+};
+var getSourceMapFromRemoteFile = async (fileName) => {
+  const fileContents = await fetchUrl(fileName);
+  return getSourceMap(fileName, fileContents, "remote");
+};
+var getSourceMapFromLocalFile = (fileName) => {
+  const fileContents = readFileSync(fileName, "utf8");
+  return getSourceMap(fileName, fileContents, "local");
 };
 
-// src/sample-rate.ts
-var DEFAULT_SAMPLE_RATE = 48000;
+// src/error-handling/handle-javascript-exception.ts
+import { NoReactInternals as NoReactInternals5 } from "remotion/no-react";
 
-// src/combine-audio.ts
-var durationOf1Frame = 1024 / DEFAULT_SAMPLE_RATE * 1e6;
-var getClosestAlignedTime = (targetTime) => {
-  const decimalFramesToTargetTime = targetTime * 1e6 / durationOf1Frame;
-  const nearestFrameIndexForTargetTime = Math.round(decimalFramesToTargetTime);
-  return nearestFrameIndexForTargetTime * durationOf1Frame / 1e6;
-};
-var encodeAudio = async ({
-  files,
-  resolvedAudioCodec,
-  audioBitrate,
-  filelistDir,
-  output,
-  indent,
-  logLevel,
-  addRemotionMetadata,
-  fps,
-  binariesDirectory,
-  cancelSignal,
-  onProgress
+// src/delay-render-embedded-stack.ts
+import { NoReactInternals as NoReactInternals4 } from "remotion/no-react";
+
+// src/parse-browser-error-stack.ts
+var regexValidFrame_Chrome = /^\s*(at|in)\s.+(:\d+)/;
+var regexValidFrame_FireFox = /(^|@)\S+:\d+|.+line\s+\d+\s+>\s+(eval|Function).+/;
+var regexExtractLocation = /\(?(.+?)(?::(\d+))?(?::(\d+))?\)?$/;
+function extractLocation(token) {
+  const execed = regexExtractLocation.exec(token);
+  if (!execed) {
+    throw new Error("Could not match in extractLocation");
+  }
+  return execed.slice(1).map((v) => {
+    const p = Number(v);
+    if (!isNaN(p)) {
+      return p;
+    }
+    return v;
+  });
+}
+var makeStackFrame = ({
+  functionName,
+  fileName,
+  lineNumber,
+  columnNumber
 }) => {
-  const fileList = files.map((p) => `file '${p}'`).join(`
-`);
-  const fileListTxt = join2(filelistDir, "audio-files.txt");
-  writeFileSync(fileListTxt, fileList);
-  const startCombining = Date.now();
-  const command = [
-    "-hide_banner",
-    "-f",
-    "concat",
-    "-safe",
-    "0",
-    "-i",
-    fileListTxt,
-    "-c:a",
-    mapAudioCodecToFfmpegAudioCodecName(resolvedAudioCodec),
-    resolvedAudioCodec === "aac" ? "-cutoff" : null,
-    resolvedAudioCodec === "aac" ? "18000" : null,
-    "-b:a",
-    audioBitrate ? audioBitrate : "320k",
-    "-vn",
-    addRemotionMetadata ? `-metadata` : null,
-    addRemotionMetadata ? `comment=Made with Remotion ${VERSION2}` : null,
-    "-y",
-    output
-  ];
-  Log.verbose({ indent, logLevel }, `Combining audio with re-encoding, command: ${command.join(" ")}`);
-  try {
-    const task = callFf({
-      args: command,
-      bin: "ffmpeg",
-      indent,
-      logLevel,
-      binariesDirectory,
-      cancelSignal
-    });
-    task.stderr?.on("data", (data) => {
-      const utf8 = data.toString("utf8");
-      const parsed = parseFfmpegProgress(utf8, fps);
-      if (parsed === undefined) {
-        Log.verbose({ indent, logLevel }, utf8);
-      } else {
-        onProgress(parsed);
-        Log.verbose({ indent, logLevel }, `Encoded ${parsed} audio frames`);
+  if (functionName && functionName.indexOf("Object.") === 0) {
+    functionName = functionName.slice("Object.".length);
+  }
+  if (functionName === "friendlySyntaxErrorLabel" || functionName === "exports.__esModule" || functionName === "<anonymous>" || !functionName) {
+    functionName = null;
+  }
+  return {
+    columnNumber,
+    fileName,
+    functionName,
+    lineNumber
+  };
+};
+var parseStack = (stack) => {
+  const frames = stack.filter((e) => regexValidFrame_Chrome.test(e) || regexValidFrame_FireFox.test(e)).map((e) => {
+    if (regexValidFrame_FireFox.test(e)) {
+      let isEval = false;
+      if (/ > (eval|Function)/.test(e)) {
+        e = e.replace(/ line (\d+)(?: > eval line \d+)* > (eval|Function):\d+:\d+/g, ":$1");
+        isEval = true;
+      }
+      const _data = e.split(/[@]/g);
+      const _last = _data.pop();
+      if (!_last) {
+        throw new Error("could not get last");
       }
+      const [_fileName, _lineNumber, _columnNumber] = extractLocation(_last);
+      return makeStackFrame({
+        functionName: _data.join("@") || (isEval ? "eval" : null),
+        fileName: _fileName,
+        lineNumber: _lineNumber,
+        columnNumber: _columnNumber
+      });
+    }
+    if (e.indexOf("(eval ") !== -1) {
+      e = e.replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
+    }
+    if (e.indexOf("(at ") !== -1) {
+      e = e.replace(/\(at /, "(");
+    }
+    const data = e.trim().split(/\s+/g).slice(1);
+    const last = data.pop();
+    if (!last) {
+      throw new Error("could not get last");
+    }
+    const [fileName, lineNumber, columnNumber] = extractLocation(last);
+    return makeStackFrame({
+      functionName: data.join(" ") || null,
+      fileName,
+      lineNumber,
+      columnNumber
     });
-    await task;
-    Log.verbose({ indent, logLevel }, `Encoded audio in ${Date.now() - startCombining}ms`);
-    return output;
-  } catch (e) {
-    rmSync2(fileListTxt, { recursive: true });
-    throw e;
+  });
+  return frames;
+};
+
+// src/delay-render-embedded-stack.ts
+var parseDelayRenderEmbeddedStack = (message) => {
+  const index = message.indexOf(NoReactInternals4.DELAY_RENDER_CALLSTACK_TOKEN);
+  if (index === -1) {
+    return null;
   }
-};
-var combineAudioSeamlessly = async ({
-  files,
-  filelistDir,
-  indent,
-  logLevel,
-  output,
-  chunkDurationInSeconds,
-  addRemotionMetadata,
-  fps,
-  binariesDirectory,
-  cancelSignal,
-  onProgress
-}) => {
-  const startConcatenating = Date.now();
-  const fileList = files.map((p, i) => {
-    const isLast = i === files.length - 1;
-    const targetStart = i * chunkDurationInSeconds;
-    const endStart = (i + 1) * chunkDurationInSeconds;
-    const startTime = getClosestAlignedTime(targetStart) * 1e6;
-    const endTime = getClosestAlignedTime(endStart) * 1e6;
-    const realDuration = endTime - startTime;
-    let inpoint = 0;
-    if (i > 0) {
-      inpoint = durationOf1Frame * 4;
-    }
-    const outpoint = (i === 0 ? durationOf1Frame * 2 : inpoint) + realDuration - (isLast ? 0 : durationOf1Frame);
-    return [`file '${p}'`, `inpoint ${inpoint}us`, `outpoint ${outpoint}us`].filter(truthy).join(`
-`);
-  }).join(`
-`);
-  const fileListTxt = join2(filelistDir, "audio-files.txt");
-  writeFileSync(fileListTxt, fileList);
-  const command = [
-    "-hide_banner",
-    "-f",
-    "concat",
-    "-safe",
-    "0",
-    "-i",
-    fileListTxt,
-    "-c:a",
-    "copy",
-    "-vn",
-    addRemotionMetadata ? `-metadata` : null,
-    addRemotionMetadata ? `comment=Made with Remotion ${VERSION2}` : null,
-    "-y",
-    output
-  ];
-  Log.verbose({ indent, logLevel }, `Combining AAC audio seamlessly, command: ${command.join(" ")}`);
-  try {
-    const task = callFf({
-      args: command,
-      bin: "ffmpeg",
-      indent,
-      logLevel,
-      binariesDirectory,
-      cancelSignal
-    });
-    task.stderr?.on("data", (data) => {
-      const utf8 = data.toString("utf8");
-      const parsed = parseFfmpegProgress(utf8, fps);
-      if (parsed !== undefined) {
-        onProgress(parsed);
-        Log.verbose({ indent, logLevel }, `Encoded ${parsed} audio frames`);
-      }
-    });
-    await task;
-    Log.verbose({ indent, logLevel }, `Combined audio seamlessly in ${Date.now() - startConcatenating}ms`);
-    return output;
-  } catch (e) {
-    rmSync2(fileListTxt, { recursive: true });
-    Log.error({ indent, logLevel }, e);
-    throw e;
-  }
-};
-var createCombinedAudio = ({
-  seamless,
-  filelistDir,
-  files,
-  indent,
-  logLevel,
-  audioBitrate,
-  resolvedAudioCodec,
-  output,
-  chunkDurationInSeconds,
-  addRemotionMetadata,
-  binariesDirectory,
-  fps,
-  cancelSignal,
-  onProgress
-}) => {
-  if (seamless) {
-    return combineAudioSeamlessly({
-      filelistDir,
-      files,
-      indent,
-      logLevel,
-      output,
-      chunkDurationInSeconds,
-      addRemotionMetadata,
-      binariesDirectory,
-      fps,
-      cancelSignal,
-      onProgress
-    });
-  }
-  return encodeAudio({
-    filelistDir,
-    files,
-    resolvedAudioCodec,
-    audioBitrate,
-    output,
-    indent,
-    logLevel,
-    addRemotionMetadata,
-    binariesDirectory,
-    fps,
-    cancelSignal,
-    onProgress
-  });
+  const msg = message.substring(index + NoReactInternals4.DELAY_RENDER_CALLSTACK_TOKEN.length).trim();
+  const parsed = parseStack(msg.split(`
+`));
+  return parsed;
 };
 
-// src/combine-video-streams.ts
-import { rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
-import { VERSION as VERSION3 } from "remotion/version";
+// src/error-handling/symbolicateable-error.ts
+class SymbolicateableError extends Error {
+  stackFrame;
+  delayRenderCall;
+  frame;
+  chunk;
+  constructor({
+    message,
+    stack,
+    stackFrame,
+    frame,
+    name,
+    chunk
+  }) {
+    super(message);
+    this.stack = stack;
+    this.stackFrame = stackFrame;
+    this.frame = frame;
+    this.chunk = chunk;
+    this.name = name;
+    this.delayRenderCall = stack ? parseDelayRenderEmbeddedStack(stack) : null;
+  }
+}
 
-// src/convert-number-of-gif-loops-to-ffmpeg.ts
-var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
-  if (loops === null) {
-    return "0";
+// src/error-handling/handle-javascript-exception.ts
+class ErrorWithStackFrame extends Error {
+  symbolicatedStackFrames;
+  frame;
+  chunk;
+  name;
+  delayRenderCall;
+  constructor({
+    message,
+    symbolicatedStackFrames,
+    frame,
+    name,
+    delayRenderCall,
+    stack,
+    chunk
+  }) {
+    super(message);
+    this.symbolicatedStackFrames = symbolicatedStackFrames;
+    this.frame = frame;
+    this.chunk = chunk;
+    this.name = name;
+    this.delayRenderCall = delayRenderCall;
+    this.stack = stack;
   }
-  if (loops === 0) {
-    return "-1";
+}
+var cleanUpErrorMessage = (exception) => {
+  let errorMessage = exception.exceptionDetails.exception?.description;
+  if (!errorMessage) {
+    return null;
   }
-  return String(loops);
-};
-
-// src/combine-video-streams.ts
-var combineVideoStreams = async ({
-  fps,
-  codec,
-  filelistDir,
-  numberOfGifLoops,
-  output,
-  indent,
-  logLevel,
-  onProgress,
-  files,
-  addRemotionMetadata,
-  binariesDirectory,
-  cancelSignal
-}) => {
-  const fileList = files.map((p) => `file '${p}'`).join(`
+  const errorType = exception.exceptionDetails.exception?.className;
+  const prefix = `${errorType}: `;
+  if (errorMessage.startsWith(prefix)) {
+    errorMessage = errorMessage.substring(prefix.length);
+  }
+  const frames = exception.exceptionDetails.stackTrace?.callFrames.length ?? 0;
+  const split = errorMessage.split(`
 `);
-  const fileListTxt = join3(filelistDir, "video-files.txt");
-  writeFileSync2(fileListTxt, fileList);
-  const encoder = codec === "gif" ? "gif" : "copy";
-  const command = [
-    "-hide_banner",
-    "-r",
-    String(fps),
-    "-f",
-    "concat",
-    "-safe",
-    "0",
-    "-i",
-    fileListTxt,
-    numberOfGifLoops === null ? null : "-loop",
-    numberOfGifLoops === null ? null : convertNumberOfGifLoopsToFfmpegSyntax(numberOfGifLoops),
-    codec === "gif" ? "-filter_complex" : null,
-    codec === "gif" ? "split[v],palettegen,[v]paletteuse" : null,
-    "-an",
-    "-c:v",
-    encoder,
-    codec === "h265" ? "-tag:v" : null,
-    codec === "h265" ? "hvc1" : null,
-    addRemotionMetadata ? `-metadata` : null,
-    addRemotionMetadata ? `comment=Made with Remotion ${VERSION3}` : null,
-    "-y",
-    output
-  ].filter(truthy);
-  const doesReencode = encoder !== "copy";
-  const startTime = Date.now();
-  Log.verbose({ indent, logLevel }, `Combining video ${doesReencode ? "with reencoding" : "without reencoding"}, command: ${command.join(" ")}`);
-  try {
-    const task = callFf({
-      args: command,
-      bin: "ffmpeg",
-      indent,
-      logLevel,
-      binariesDirectory,
-      cancelSignal
-    });
-    task.stderr?.on("data", (data) => {
-      const parsed = parseFfmpegProgress(data.toString("utf8"), fps);
-      if (parsed === undefined) {
-        Log.verbose({ indent, logLevel }, data.toString("utf8"));
-      } else {
-        Log.verbose({ indent, logLevel }, `Encoded ${parsed} video frames`);
-        onProgress(parsed);
-      }
-    });
-    await task;
-    Log.verbose({ indent, logLevel }, `Finished combining video in ${Date.now() - startTime}ms`);
-    return output;
-  } catch (e) {
-    rmSync3(fileListTxt, { recursive: true });
-    throw e;
+  return split.slice(0, Math.max(1, split.length - frames)).join(`
+`);
+};
+var removeDelayRenderStack = (message) => {
+  const index = message.indexOf(NoReactInternals5.DELAY_RENDER_CALLSTACK_TOKEN);
+  if (index === -1) {
+    return message;
   }
+  return message.substring(0, index);
 };
-
-// src/combine-video-streams-seamlessly.ts
-var combineVideoStreamsSeamlessly = ({ files }) => {
-  const fileList = `concat:${files.join("|")}`;
-  return fileList;
+var callFrameToStackFrame = (callFrame) => {
+  return {
+    columnNumber: callFrame.columnNumber,
+    fileName: callFrame.url,
+    functionName: callFrame.functionName,
+    lineNumber: callFrame.lineNumber
+  };
 };
-
-// src/file-extensions.ts
-var defaultFileExtensionMap = {
-  "h264-mkv": {
-    default: "mkv",
-    forAudioCodec: {
-      "pcm-16": { possible: ["mkv"], default: "mkv" },
-      mp3: { possible: ["mkv"], default: "mkv" }
-    }
+var handleJavascriptException = ({
+  page,
+  onError,
+  frame
+}) => {
+  const client = page._client();
+  const handler = (exception) => {
+    const rawErrorMessage = exception.exceptionDetails.exception?.description;
+    const cleanErrorMessage = cleanUpErrorMessage(exception);
+    if (!cleanErrorMessage) {
+      console.error(exception);
+      const err = new Error(rawErrorMessage);
+      err.stack = rawErrorMessage;
+      onError(err);
+      return;
+    }
+    if (!exception.exceptionDetails.stackTrace) {
+      const err = new Error(removeDelayRenderStack(cleanErrorMessage));
+      err.stack = rawErrorMessage;
+      onError(err);
+      return;
+    }
+    const errorType = exception.exceptionDetails.exception?.className;
+    const symbolicatedErr = new SymbolicateableError({
+      message: removeDelayRenderStack(cleanErrorMessage),
+      stackFrame: exception.exceptionDetails.stackTrace.callFrames.map((f) => callFrameToStackFrame(f)),
+      frame,
+      name: errorType,
+      stack: exception.exceptionDetails.exception?.description,
+      chunk: null
+    });
+    onError(symbolicatedErr);
+  };
+  client.on("Runtime.exceptionThrown", handler);
+  return () => {
+    client.off("Runtime.exceptionThrown", handler);
+    return Promise.resolve();
+  };
+};
+
+// src/error-handling/symbolicate-error.ts
+var symbolicateError = async (symbolicateableError) => {
+  const { delayRenderCall, stackFrame } = symbolicateableError;
+  const [mainErrorFrames, delayRenderFrames] = await Promise.all([
+    stackFrame ? symbolicateStackTraceFromRemoteFrames(stackFrame) : null,
+    delayRenderCall ? symbolicateStackTraceFromRemoteFrames(delayRenderCall) : null
+  ].filter(truthy));
+  const symbolicatedErr = new ErrorWithStackFrame({
+    message: symbolicateableError.message,
+    symbolicatedStackFrames: mainErrorFrames,
+    frame: symbolicateableError.frame,
+    name: symbolicateableError.name,
+    delayRenderCall: delayRenderFrames,
+    stack: symbolicateableError.stack,
+    chunk: symbolicateableError.chunk
+  });
+  return symbolicatedErr;
+};
+
+// src/file-extensions.ts
+var defaultFileExtensionMap = {
+  "h264-mkv": {
+    default: "mkv",
+    forAudioCodec: {
+      "pcm-16": { possible: ["mkv"], default: "mkv" },
+      mp3: { possible: ["mkv"], default: "mkv" }
+    }
   },
   "h264-ts": {
     default: "ts",
@@ -4665,1385 +4515,768 @@ var defaultFileExtensionMap = {
   }
 };
 
-// src/get-extension-from-codec.ts
-var getFileExtensionFromCodec = (codec, audioCodec) => {
-  if (!validCodecs.includes(codec)) {
-    throw new Error(`Codec must be one of the following: ${validCodecs.join(", ")}, but got ${codec}`);
-  }
-  const map = defaultFileExtensionMap[codec];
-  if (audioCodec === null) {
-    return map.default;
+// src/frame-range.ts
+var validateFrameRange = (frameRange) => {
+  if (frameRange === null) {
+    return;
   }
-  const typedAudioCodec = audioCodec;
-  if (!(typedAudioCodec in map.forAudioCodec)) {
-    throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
+  if (typeof frameRange === "number") {
+    if (frameRange < 0) {
+      throw new TypeError("Frame must be a non-negative number, got " + frameRange);
+    }
+    if (!Number.isFinite(frameRange)) {
+      throw new TypeError("Frame must be a finite number, got " + frameRange);
+    }
+    if (!Number.isInteger(frameRange)) {
+      throw new Error(`Frame must be an integer, but got a float (${frameRange})`);
+    }
+    return;
   }
-  return map.forAudioCodec[audioCodec].default;
-};
-var makeFileExtensionMap = () => {
-  const map = {};
-  Object.keys(defaultFileExtensionMap).forEach((_codec) => {
-    const codec = _codec;
-    const fileExtMap = defaultFileExtensionMap[codec];
-    const audioCodecs = Object.keys(fileExtMap.forAudioCodec);
-    const possibleExtensionsForAudioCodec = audioCodecs.map((audioCodec) => fileExtMap.forAudioCodec[audioCodec].possible);
-    const allPossibleExtensions = [
-      fileExtMap.default,
-      ...possibleExtensionsForAudioCodec.flat(1)
-    ];
-    for (const extension of allPossibleExtensions) {
-      if (!map[extension]) {
-        map[extension] = [];
+  if (Array.isArray(frameRange)) {
+    if (frameRange.length !== 2) {
+      throw new TypeError("Frame range must be a tuple, got an array with length " + frameRange.length);
+    }
+    for (const value of frameRange) {
+      if (typeof value !== "number") {
+        throw new Error(`Each value of frame range must be a number, but got ${typeof value} (${JSON.stringify(value)})`);
+      }
+      if (!Number.isFinite(value)) {
+        throw new TypeError("Each value of frame range must be finite, but got " + value);
       }
-      if (!map[extension].includes(codec)) {
-        map[extension].push(codec);
+      if (!Number.isInteger(value)) {
+        throw new Error(`Each value of frame range must be an integer, but got a float (${value})`);
+      }
+      if (value < 0) {
+        throw new Error(`Each value of frame range must be non-negative, but got ${value}`);
       }
     }
-  });
-  return map;
-};
-var defaultCodecsForFileExtension = {
-  "3gp": "aac",
-  aac: "aac",
-  gif: "gif",
-  hevc: "h265",
-  m4a: "aac",
-  m4b: "aac",
-  mkv: "h264-mkv",
-  mov: "prores",
-  mp3: "mp3",
-  mp4: "h264",
-  mpeg: "aac",
-  mpg: "aac",
-  mxf: "prores",
-  wav: "wav",
-  webm: "vp8",
-  ts: "h264-ts"
+    const [first, second] = frameRange;
+    if (second < first) {
+      throw new Error("The second value of frame range must be not smaller than the first one, but got " + frameRange.join("-"));
+    }
+    return;
+  }
+  throw new TypeError("Frame range must be a number or a tuple of numbers, but got object of type " + typeof frameRange);
 };
 
-// src/make-metadata-args.ts
-import { VERSION as VERSION4 } from "remotion/version";
-var makeMetadataArgs = (metadata) => {
-  const defaultComment = `Made with Remotion ${VERSION4}`;
-  const newMetadata = {
-    comment: defaultComment
+// src/get-compositions.ts
+import { NoReactInternals as NoReactInternals8 } from "remotion/no-react";
+
+// src/to-megabytes.ts
+function toMegabytes(bytes) {
+  const mb = bytes / 1024 / 1024;
+  return `${Math.round(mb * 10) / 10} Mb`;
+}
+
+// src/browser/browser-download-progress-bar.ts
+var defaultBrowserDownloadProgress = ({
+  indent,
+  logLevel,
+  api
+}) => ({ chromeMode }) => {
+  if (chromeMode === "chrome-for-testing") {
+    Log.info({ indent, logLevel }, "Downloading Chrome for Testing https://www.remotion.dev/chrome-for-testing");
+  } else {
+    Log.info({ indent, logLevel }, "Downloading Chrome Headless Shell https://www.remotion.dev/chrome-headless-shell");
+  }
+  Log.info({ indent, logLevel }, `Customize this behavior by adding a onBrowserDownload function to ${api}.`);
+  let lastProgress = 0;
+  return {
+    onProgress: (progress) => {
+      if (progress.downloadedBytes > lastProgress + 1e7 || progress.percent === 1) {
+        lastProgress = progress.downloadedBytes;
+        if (chromeMode === "chrome-for-testing") {
+          Log.info({ indent, logLevel }, `Downloading Chrome for Testing - ${toMegabytes(progress.downloadedBytes)}/${toMegabytes(progress.totalSizeInBytes)}`);
+        } else {
+          Log.info({ indent, logLevel }, `Downloading Chrome Headless Shell - ${toMegabytes(progress.downloadedBytes)}/${toMegabytes(progress.totalSizeInBytes)}`);
+        }
+      }
+    },
+    version: null
   };
-  Object.keys(metadata).forEach((key) => {
-    const lowercaseKey = key.toLowerCase();
-    if (lowercaseKey === "comment") {
-      newMetadata[lowercaseKey] = `${defaultComment}; ${metadata[key]}`;
-    } else {
-      newMetadata[lowercaseKey] = metadata[key];
-    }
-  });
-  const metadataArgs = Object.entries(newMetadata).map(([key, value]) => ["-metadata", `${key}=${value}`]);
-  return metadataArgs.flat(1);
 };
 
-// src/mux-video-and-audio.ts
-var muxVideoAndAudio = async ({
-  videoOutput,
-  audioOutput,
-  output,
+// src/open-browser.ts
+import fs9 from "node:fs";
+import os3 from "node:os";
+import path9 from "node:path";
+
+// src/browser/Launcher.ts
+var launchChrome = async ({
+  args,
+  executablePath,
+  defaultViewport,
   indent,
   logLevel,
-  onProgress,
-  binariesDirectory,
-  fps,
-  cancelSignal,
-  addFaststart,
-  metadata
+  userDataDir
 }) => {
-  const startTime = Date.now();
-  Log.verbose({ indent, logLevel }, "Muxing video and audio together");
-  const command = [
-    "-hide_banner",
-    videoOutput ? "-i" : null,
-    videoOutput,
-    audioOutput ? "-i" : null,
-    audioOutput,
-    videoOutput ? "-c:v" : null,
-    videoOutput ? "copy" : null,
-    audioOutput ? "-c:a" : null,
-    audioOutput ? "copy" : null,
-    addFaststart ? "-movflags" : null,
-    addFaststart ? "faststart" : null,
-    ...makeMetadataArgs(metadata ?? {}),
-    "-y",
-    output
-  ].filter(truthy);
-  Log.verbose({ indent, logLevel }, "Combining command: ", command);
-  const task = callFf({
-    bin: "ffmpeg",
-    args: command,
-    indent,
+  const timeout = 60000;
+  const browser = await HeadlessBrowser.create({
+    defaultViewport,
+    args,
+    executablePath,
+    timeout,
+    userDataDir,
     logLevel,
-    binariesDirectory,
-    cancelSignal
+    indent
   });
-  task.stderr?.on("data", (data) => {
-    const utf8 = data.toString("utf8");
-    const parsed = parseFfmpegProgress(utf8, fps);
-    if (parsed === undefined) {
-      if (!utf8.includes("Estimating duration from bitrate, this may be inaccurate")) {
-        Log.verbose({ indent, logLevel }, utf8);
-      }
-    } else {
-      Log.verbose({ indent, logLevel }, `Combined ${parsed} frames`);
-      onProgress(parsed);
-    }
-  });
-  await task;
-  Log.verbose({ indent, logLevel }, `Muxing done in ${Date.now() - startTime}ms`);
-};
-
-// src/combine-videos.ts
-var codecSupportsFastStart = {
-  "h264-mkv": false,
-  "h264-ts": false,
-  h264: true,
-  h265: true,
-  aac: false,
-  gif: false,
-  mp3: false,
-  prores: false,
-  vp8: false,
-  vp9: false,
-  wav: false
-};
-var combineChunks = async ({
-  files,
-  filelistDir,
-  output,
-  onProgress,
-  numberOfFrames,
-  codec,
-  fps,
-  numberOfGifLoops,
-  resolvedAudioCodec,
-  audioBitrate,
-  indent,
-  logLevel,
-  chunkDurationInSeconds,
-  binariesDirectory,
-  cancelSignal,
-  seamlessAudio,
-  seamlessVideo,
-  muted,
-  metadata
-}) => {
-  const shouldCreateAudio = resolvedAudioCodec !== null && !muted;
-  const shouldCreateVideo = !isAudioCodec(codec);
-  const videoOutput = shouldCreateVideo ? join4(filelistDir, `video.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`) : null;
-  const audioOutput = shouldCreateAudio ? join4(filelistDir, `audio.${getExtensionFromAudioCodec(resolvedAudioCodec)}`) : null;
-  const audioFiles = files.filter((f) => f.endsWith("audio"));
-  const videoFiles = files.filter((f) => f.endsWith("video"));
-  let concatenatedAudio = 0;
-  let concatenatedVideo = 0;
-  let muxing = 0;
-  const updateProgress = () => {
-    const totalFrames = (shouldCreateAudio ? numberOfFrames : 0) + (shouldCreateVideo ? numberOfFrames : 0) + numberOfFrames;
-    const actualProgress = concatenatedAudio + concatenatedVideo + muxing;
-    onProgress(actualProgress / totalFrames * numberOfFrames);
-  };
-  Log.verbose({ indent, logLevel }, `Combining chunks, audio = ${shouldCreateAudio === false ? "no" : seamlessAudio ? "seamlessly" : "normally"}, video = ${shouldCreateVideo === false ? "no" : seamlessVideo ? "seamlessly" : "normally"}`);
-  await Promise.all([
-    shouldCreateAudio && audioOutput ? createCombinedAudio({
-      audioBitrate,
-      filelistDir,
-      files: audioFiles,
-      indent,
-      logLevel,
-      output: audioOutput,
-      resolvedAudioCodec,
-      seamless: seamlessAudio,
-      chunkDurationInSeconds,
-      addRemotionMetadata: !shouldCreateVideo,
-      binariesDirectory,
-      fps,
-      cancelSignal,
-      onProgress: (frames) => {
-        concatenatedAudio = frames;
-        updateProgress();
-      }
-    }) : null,
-    shouldCreateVideo && !seamlessVideo && videoOutput ? combineVideoStreams({
-      codec,
-      filelistDir,
-      fps,
-      indent,
-      logLevel,
-      numberOfGifLoops,
-      output: videoOutput,
-      files: videoFiles,
-      addRemotionMetadata: !shouldCreateAudio,
-      binariesDirectory,
-      cancelSignal,
-      onProgress: (frames) => {
-        concatenatedVideo = frames;
-        updateProgress();
-      }
-    }) : null
-  ].filter(truthy));
   try {
-    await muxVideoAndAudio({
-      audioOutput,
-      indent,
-      logLevel,
-      onProgress: (frames) => {
-        muxing = frames;
-        updateProgress();
-      },
-      output,
-      videoOutput: seamlessVideo ? combineVideoStreamsSeamlessly({ files: videoFiles }) : videoOutput,
-      binariesDirectory,
-      fps,
-      cancelSignal,
-      addFaststart: codecSupportsFastStart[codec],
-      metadata
-    });
-    onProgress(numberOfFrames);
-    rmSync4(filelistDir, { recursive: true });
-  } catch (err) {
-    rmSync4(filelistDir, { recursive: true });
-    throw err;
+    await browser.waitForTarget((t) => {
+      return t.type() === "page";
+    }, { timeout });
+  } catch (error) {
+    await browser.close({ silent: false });
+    throw error;
   }
+  return browser;
 };
 
-// src/convert-to-positive-frame-index.ts
-var convertToPositiveFrameIndex = ({
-  frame,
-  durationInFrames
-}) => {
-  return frame < 0 ? durationInFrames - frame : frame;
-};
+// src/ensure-browser.ts
+import fs7 from "fs";
 
-// src/symbolicate-stacktrace.ts
-import { readFileSync } from "fs";
-import path6 from "path";
-import { SourceMapConsumer } from "source-map";
-function extractSourceMapUrl(fileContents) {
-  const regex = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/gm;
-  let match = null;
+// src/browser/BrowserFetcher.ts
+import * as fs6 from "node:fs";
+import * as os2 from "node:os";
+import * as path8 from "node:path";
+import extractZip from "extract-zip";
+import { promisify } from "node:util";
+
+// src/browser/get-download-destination.ts
+import fs5 from "node:fs";
+import path7 from "node:path";
+var getDownloadsCacheDir = () => {
+  const cwd = process.cwd();
+  let dir = cwd;
   for (;; ) {
-    const next = regex.exec(fileContents);
-    if (next === null || next === undefined) {
+    try {
+      if (fs5.statSync(path7.join(dir, "package.json")).isFile()) {
+        break;
+      }
+    } catch (e) {
+    }
+    const parent = path7.dirname(dir);
+    if (dir === parent) {
+      dir = undefined;
       break;
     }
-    match = next;
+    dir = parent;
   }
-  if (!match?.[1]) {
-    return null;
+  if (!dir) {
+    return path7.resolve(cwd, ".remotion");
   }
-  return match[1].toString();
-}
-var getSourceMapFromRemoteUrl = async (url) => {
-  if (!url.endsWith(".js.map")) {
-    throw new Error(`The URL ${url} does not seem to be a valid source map URL.`);
+  if (process.versions.pnp === "1") {
+    return path7.resolve(dir, ".pnp/.remotion");
   }
-  const obj = await fetchUrl(url);
-  return new SourceMapConsumer(obj);
-};
-var getSourceMap = (filePath, fileContents, type) => {
-  const sm = extractSourceMapUrl(fileContents);
-  if (sm === null) {
-    return Promise.resolve(null);
+  if (process.versions.pnp === "3") {
+    return path7.resolve(dir, ".yarn/.remotion");
   }
-  if (sm.indexOf("data:") === 0) {
-    const base64 = /^data:application\/json;([\w=:"-]+;)*base64,/;
-    const match2 = sm.match(base64);
-    if (!match2) {
-      throw new Error("Sorry, non-base64 inline source-map encoding is not supported.");
-    }
-    const converted = window.atob(sm.substring(match2[0].length));
-    try {
-      const sourceMapConsumer = new SourceMapConsumer(JSON.parse(converted));
-      return Promise.resolve(sourceMapConsumer);
-    } catch {
-      return Promise.resolve(null);
-    }
+  return path7.resolve(dir, "node_modules/.remotion");
+};
+
+// src/browser/BrowserFetcher.ts
+var TESTED_VERSION = "133.0.6943.0";
+var PLAYWRIGHT_VERSION = "1155";
+function getChromeDownloadUrl({
+  platform: platform2,
+  version,
+  chromeMode
+}) {
+  if (platform2 === "linux-arm64") {
+    return `https://playwright.azureedge.net/builds/chromium/${version ?? PLAYWRIGHT_VERSION}/chromium-headless-shell-linux-arm64.zip`;
   }
-  if (type === "local") {
-    const newFilePath = path6.join(path6.dirname(filePath), sm);
-    return Promise.resolve(new SourceMapConsumer(readFileSync(newFilePath, "utf8")));
+  if (chromeMode === "headless-shell") {
+    return `https://storage.googleapis.com/chrome-for-testing-public/${version ?? TESTED_VERSION}/${platform2}/chrome-headless-shell-${platform2}.zip`;
   }
-  const index = filePath.lastIndexOf("/");
-  const url = filePath.substring(0, index + 1) + sm;
-  return getSourceMapFromRemoteUrl(url);
-};
-var fetchUrl = async (url) => {
-  const res = await readFile(url);
-  return new Promise((resolve, reject) => {
-    let downloaded = "";
-    res.on("data", (d) => {
-      downloaded += d;
-    });
-    res.on("end", () => {
-      resolve(downloaded);
+  return `https://storage.googleapis.com/chrome-for-testing-public/${version ?? TESTED_VERSION}/${platform2}/chrome-${platform2}.zip`;
+}
+var mkdirAsync = fs6.promises.mkdir;
+var unlinkAsync = promisify(fs6.unlink.bind(fs6));
+function existsAsync(filePath) {
+  return new Promise((resolve2) => {
+    fs6.access(filePath, (err) => {
+      return resolve2(!err);
     });
-    res.on("error", (err) => reject(err));
   });
-};
-function getLinesAround(line, count, lines) {
-  const result = [];
-  for (let index = Math.max(0, line - 1 - count) + 1;index <= Math.min(lines.length - 1, line - 1 + count); ++index) {
-    result.push({
-      lineNumber: index + 1,
-      content: lines[index],
-      highlight: index + 1 === line
-    });
-  }
-  return result;
 }
-var getOriginalPosition = (source_map, line, column) => {
-  const result = source_map.originalPositionFor({
-    line,
-    column
-  });
-  return { line: result.line, column: result.column, source: result.source };
+var getPlatform = () => {
+  const platform2 = os2.platform();
+  switch (platform2) {
+    case "darwin":
+      return os2.arch() === "arm64" ? "mac-arm64" : "mac-x64";
+    case "linux":
+      return os2.arch() === "arm64" ? "linux-arm64" : "linux64";
+    case "win32":
+      return "win64";
+    default:
+      throw new Error("Unsupported platform: " + platform2);
+  }
 };
-var symbolicateStackTraceFromRemoteFrames = async (frames) => {
-  const uniqueFileNames = [
-    ...new Set(frames.map((f) => f.fileName).filter((f) => f.startsWith("http://") || f.startsWith("https://")).filter(truthy))
-  ];
-  const maps = await Promise.all(uniqueFileNames.map((fileName) => {
-    return getSourceMapFromRemoteFile(fileName);
-  }));
-  const mapValues = {};
-  for (let i = 0;i < uniqueFileNames.length; i++) {
-    mapValues[uniqueFileNames[i]] = maps[i];
+var getDownloadsFolder = (chromeMode) => {
+  const destination = chromeMode === "headless-shell" ? "chrome-headless-shell" : "chrome-for-testing";
+  return path8.join(getDownloadsCacheDir(), destination);
+};
+var downloadBrowser = async ({
+  logLevel,
+  indent,
+  onProgress,
+  version,
+  chromeMode
+}) => {
+  const platform2 = getPlatform();
+  const downloadURL = getChromeDownloadUrl({ platform: platform2, version, chromeMode });
+  const fileName = downloadURL.split("/").pop();
+  if (!fileName) {
+    throw new Error(`A malformed download URL was found: ${downloadURL}.`);
   }
-  return symbolicateFromSources(frames, mapValues);
+  const downloadsFolder = getDownloadsFolder(chromeMode);
+  const archivePath = path8.join(downloadsFolder, fileName);
+  const outputPath = getFolderPath(downloadsFolder, platform2);
+  if (await existsAsync(outputPath)) {
+    return getRevisionInfo(chromeMode);
+  }
+  if (!await existsAsync(downloadsFolder)) {
+    await mkdirAsync(downloadsFolder, {
+      recursive: true
+    });
+  }
+  if (os2.platform() !== "darwin" && os2.platform() !== "linux" && os2.arch() === "arm64") {
+    throw new Error([
+      "Chrome Headless Shell is not available for Windows for arm64 architecture."
+    ].join(`
+`));
+  }
+  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
+        });
+      },
+      indent,
+      logLevel
+    });
+    await extractZip(archivePath, { dir: outputPath });
+    const chromePath = path8.join(outputPath, "chrome-linux", "chrome");
+    const chromeHeadlessShellPath = path8.join(outputPath, "chrome-linux", "chrome-headless-shell");
+    if (fs6.existsSync(chromePath)) {
+      fs6.renameSync(chromePath, chromeHeadlessShellPath);
+    }
+    const chromeLinuxFolder = path8.join(outputPath, "chrome-linux");
+    if (fs6.existsSync(chromeLinuxFolder)) {
+      fs6.renameSync(chromeLinuxFolder, path8.join(outputPath, "chrome-headless-shell-linux-arm64"));
+    }
+  } catch (err) {
+    return Promise.reject(err);
+  } finally {
+    if (await existsAsync(archivePath)) {
+      await unlinkAsync(archivePath);
+    }
+  }
+  const revisionInfo = getRevisionInfo(chromeMode);
+  makeFileExecutableIfItIsNot(revisionInfo.executablePath);
+  return revisionInfo;
 };
-var symbolicateFromSources = (frames, mapValues) => {
-  return frames.map((frame) => {
-    const map = mapValues[frame.fileName];
-    if (!map) {
-      return null;
+var getFolderPath = (downloadsFolder, platform2) => {
+  return path8.resolve(downloadsFolder, platform2);
+};
+var getExecutablePath2 = (chromeMode) => {
+  const downloadsFolder = getDownloadsFolder(chromeMode);
+  const platform2 = getPlatform();
+  const folderPath = getFolderPath(downloadsFolder, platform2);
+  if (chromeMode === "chrome-for-testing") {
+    if (platform2 === "mac-arm64" || platform2 === "mac-x64") {
+      return path8.join(folderPath, `chrome-${platform2}`, "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing");
     }
-    return symbolicateStackFrame(frame, map);
-  }).filter(truthy).filter((f) => f.originalScriptCode !== null);
+    if (platform2 === "win64") {
+      return path8.join(folderPath, "chrome-win64", "chrome.exe");
+    }
+    if (platform2 === "linux64" || platform2 === "linux-arm64") {
+      return path8.join(folderPath, "chrome-linux64", "chrome");
+    }
+    throw new Error("unsupported platform" + platform2);
+  }
+  if (chromeMode === "headless-shell") {
+    return path8.join(folderPath, `chrome-headless-shell-${platform2}`, platform2 === "win64" ? "chrome-headless-shell.exe" : platform2 === "linux-arm64" ? "headless_shell" : "chrome-headless-shell");
+  }
+  throw new Error("unsupported chrome mode" + chromeMode);
 };
-var symbolicateStackFrame = (frame, map) => {
-  const pos = getOriginalPosition(map, frame.lineNumber, frame.columnNumber);
-  const hasSource = pos.source ? map.sourceContentFor(pos.source, false) : null;
-  const scriptCode = hasSource && pos.line ? getLinesAround(pos.line, 3, hasSource.split(`
-`)) : null;
+var getRevisionInfo = (chromeMode) => {
+  const executablePath = getExecutablePath2(chromeMode);
+  const downloadsFolder = getDownloadsFolder(chromeMode);
+  const platform2 = getPlatform();
+  const folderPath = getFolderPath(downloadsFolder, platform2);
+  const url = getChromeDownloadUrl({ platform: platform2, version: null, chromeMode });
+  const local = fs6.existsSync(folderPath);
   return {
-    originalColumnNumber: pos.column,
-    originalFileName: pos.source,
-    originalFunctionName: frame.functionName,
-    originalLineNumber: pos.line,
-    originalScriptCode: scriptCode
+    executablePath,
+    folderPath,
+    local,
+    url
   };
 };
-var getSourceMapFromRemoteFile = async (fileName) => {
-  const fileContents = await fetchUrl(fileName);
-  return getSourceMap(fileName, fileContents, "remote");
-};
-var getSourceMapFromLocalFile = (fileName) => {
-  const fileContents = readFileSync(fileName, "utf8");
-  return getSourceMap(fileName, fileContents, "local");
-};
-
-// src/error-handling/handle-javascript-exception.ts
-import { NoReactInternals as NoReactInternals5 } from "remotion/no-react";
 
-// src/delay-render-embedded-stack.ts
-import { NoReactInternals as NoReactInternals4 } from "remotion/no-react";
-
-// src/parse-browser-error-stack.ts
-var regexValidFrame_Chrome = /^\s*(at|in)\s.+(:\d+)/;
-var regexValidFrame_FireFox = /(^|@)\S+:\d+|.+line\s+\d+\s+>\s+(eval|Function).+/;
-var regexExtractLocation = /\(?(.+?)(?::(\d+))?(?::(\d+))?\)?$/;
-function extractLocation(token) {
-  const execed = regexExtractLocation.exec(token);
-  if (!execed) {
-    throw new Error("Could not match in extractLocation");
+// src/ensure-browser.ts
+var currentEnsureBrowserOperation = Promise.resolve();
+var internalEnsureBrowserUncapped = async ({
+  indent,
+  logLevel,
+  browserExecutable,
+  onBrowserDownload,
+  chromeMode
+}) => {
+  const status = getBrowserStatus({ browserExecutable, chromeMode });
+  if (status.type === "no-browser") {
+    const { onProgress, version } = onBrowserDownload({ chromeMode });
+    await downloadBrowser({ indent, logLevel, onProgress, version, chromeMode });
   }
-  return execed.slice(1).map((v) => {
-    const p = Number(v);
-    if (!isNaN(p)) {
-      return p;
+  const newStatus = getBrowserStatus({ browserExecutable, chromeMode });
+  return newStatus;
+};
+var internalEnsureBrowser = (options) => {
+  currentEnsureBrowserOperation = currentEnsureBrowserOperation.then(() => internalEnsureBrowserUncapped(options));
+  return currentEnsureBrowserOperation;
+};
+var getBrowserStatus = ({
+  browserExecutable,
+  chromeMode
+}) => {
+  if (browserExecutable) {
+    if (!fs7.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 v;
+    return { path: browserExecutable, type: "user-defined-path" };
+  }
+  const revision = getRevisionInfo(chromeMode);
+  if (revision.local && fs7.existsSync(revision.executablePath)) {
+    return { path: revision.executablePath, type: "local-puppeteer-browser" };
+  }
+  return { type: "no-browser" };
+};
+var ensureBrowser = (options) => {
+  const indent = false;
+  const logLevel = options?.logLevel ?? "info";
+  return internalEnsureBrowser({
+    browserExecutable: options?.browserExecutable ?? null,
+    indent,
+    logLevel: options?.logLevel ?? "info",
+    onBrowserDownload: options?.onBrowserDownload ?? defaultBrowserDownloadProgress({
+      api: "ensureBrowser()",
+      indent: false,
+      logLevel
+    }),
+    chromeMode: options?.chromeMode ?? "headless-shell"
   });
-}
-var makeStackFrame = ({
-  functionName,
-  fileName,
-  lineNumber,
-  columnNumber
+};
+
+// src/get-local-browser-executable.ts
+import fs8 from "node:fs";
+var getBrowserStatus2 = ({
+  browserExecutablePath,
+  indent,
+  logLevel,
+  chromeMode
 }) => {
-  if (functionName && functionName.indexOf("Object.") === 0) {
-    functionName = functionName.slice("Object.".length);
+  if (browserExecutablePath) {
+    if (!fs8.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" };
   }
-  if (functionName === "friendlySyntaxErrorLabel" || functionName === "exports.__esModule" || functionName === "<anonymous>" || !functionName) {
-    functionName = null;
+  const revision = getRevisionInfo(chromeMode);
+  if (revision.local && fs8.existsSync(revision.executablePath)) {
+    return { path: revision.executablePath, type: "local-puppeteer-browser" };
   }
-  return {
-    columnNumber,
-    fileName,
-    functionName,
-    lineNumber
-  };
+  return { type: "no-browser" };
 };
-var parseStack = (stack) => {
-  const frames = stack.filter((e) => regexValidFrame_Chrome.test(e) || regexValidFrame_FireFox.test(e)).map((e) => {
-    if (regexValidFrame_FireFox.test(e)) {
-      let isEval = false;
-      if (/ > (eval|Function)/.test(e)) {
-        e = e.replace(/ line (\d+)(?: > eval line \d+)* > (eval|Function):\d+:\d+/g, ":$1");
-        isEval = true;
-      }
-      const _data = e.split(/[@]/g);
-      const _last = _data.pop();
-      if (!_last) {
-        throw new Error("could not get last");
-      }
-      const [_fileName, _lineNumber, _columnNumber] = extractLocation(_last);
-      return makeStackFrame({
-        functionName: _data.join("@") || (isEval ? "eval" : null),
-        fileName: _fileName,
-        lineNumber: _lineNumber,
-        columnNumber: _columnNumber
-      });
-    }
-    if (e.indexOf("(eval ") !== -1) {
-      e = e.replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
-    }
-    if (e.indexOf("(at ") !== -1) {
-      e = e.replace(/\(at /, "(");
-    }
-    const data = e.trim().split(/\s+/g).slice(1);
-    const last = data.pop();
-    if (!last) {
-      throw new Error("could not get last");
-    }
-    const [fileName, lineNumber, columnNumber] = extractLocation(last);
-    return makeStackFrame({
-      functionName: data.join(" ") || null,
-      fileName,
-      lineNumber,
-      columnNumber
-    });
+var getLocalBrowserExecutable = ({
+  preferredBrowserExecutable,
+  logLevel,
+  indent,
+  chromeMode
+}) => {
+  const status = getBrowserStatus2({
+    browserExecutablePath: preferredBrowserExecutable,
+    indent,
+    logLevel,
+    chromeMode
   });
-  return frames;
-};
-
-// src/delay-render-embedded-stack.ts
-var parseDelayRenderEmbeddedStack = (message) => {
-  const index = message.indexOf(NoReactInternals4.DELAY_RENDER_CALLSTACK_TOKEN);
-  if (index === -1) {
-    return null;
+  if (status.type === "no-browser") {
+    throw new TypeError("No browser found for rendering frames! Please open a GitHub issue and describe " + "how you reached this error: https://remotion.dev/issue");
   }
-  const msg = message.substring(index + NoReactInternals4.DELAY_RENDER_CALLSTACK_TOKEN.length).trim();
-  const parsed = parseStack(msg.split(`
-`));
-  return parsed;
+  return status.path;
 };
 
-// src/error-handling/symbolicateable-error.ts
-class SymbolicateableError extends Error {
-  stackFrame;
-  delayRenderCall;
-  frame;
-  chunk;
-  constructor({
-    message,
-    stack,
-    stackFrame,
-    frame,
-    name,
-    chunk
-  }) {
-    super(message);
-    this.stack = stack;
-    this.stackFrame = stackFrame;
-    this.frame = frame;
-    this.chunk = chunk;
-    this.name = name;
-    this.delayRenderCall = stack ? parseDelayRenderEmbeddedStack(stack) : null;
+// src/get-available-memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { freemem } from "node:os";
+var getFreeMemoryFromProcMeminfo = () => {
+  const data = readFileSync2("/proc/meminfo", "utf-8");
+  const lines = data.split(`
+`);
+  const memAvailableLine = lines.find((line) => line.startsWith("MemAvailable"));
+  if (!memAvailableLine) {
+    throw new Error("MemAvailable not found in /proc/meminfo");
   }
-}
-
-// src/error-handling/handle-javascript-exception.ts
-class ErrorWithStackFrame extends Error {
-  symbolicatedStackFrames;
-  frame;
-  chunk;
-  name;
-  delayRenderCall;
-  constructor({
-    message,
-    symbolicatedStackFrames,
-    frame,
-    name,
-    delayRenderCall,
-    stack,
-    chunk
-  }) {
-    super(message);
-    this.symbolicatedStackFrames = symbolicatedStackFrames;
-    this.frame = frame;
-    this.chunk = chunk;
-    this.name = name;
-    this.delayRenderCall = delayRenderCall;
-    this.stack = stack;
+  const matches = memAvailableLine.match(/(\d+)\s+(\w+)/);
+  if (!matches || matches.length !== 3) {
+    throw new Error("Failed to parse MemAvailable value");
   }
-}
-var cleanUpErrorMessage = (exception) => {
-  let errorMessage = exception.exceptionDetails.exception?.description;
-  if (!errorMessage) {
-    return null;
+  const value = parseInt(matches[1], 10);
+  const unit = matches[2].toLowerCase();
+  switch (unit) {
+    case "kb":
+      return value * 1024;
+    case "mb":
+      return value * 1024 * 1024;
+    case "gb":
+      return value * 1024 * 1024 * 1024;
+    default:
+      throw new Error(`Unknown unit: ${unit}`);
   }
-  const errorType = exception.exceptionDetails.exception?.className;
-  const prefix = `${errorType}: `;
-  if (errorMessage.startsWith(prefix)) {
-    errorMessage = errorMessage.substring(prefix.length);
+};
+var maxLambdaMemory = () => {
+  if (process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) {
+    return parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE, 10) * 1024 * 1024;
   }
-  const frames = exception.exceptionDetails.stackTrace?.callFrames.length ?? 0;
-  const split = errorMessage.split(`
-`);
-  return split.slice(0, Math.max(1, split.length - frames)).join(`
-`);
+  return Infinity;
 };
-var removeDelayRenderStack = (message) => {
-  const index = message.indexOf(NoReactInternals5.DELAY_RENDER_CALLSTACK_TOKEN);
-  if (index === -1) {
-    return message;
+var getAvailableMemory = (logLevel) => {
+  const maxMemory = maxLambdaMemory();
+  if (existsSync3("/proc/meminfo")) {
+    try {
+      const val = getFreeMemoryFromProcMeminfo();
+      if (val !== null) {
+        return Math.min(val, maxMemory);
+      }
+    } catch (err) {
+      Log.warn({ indent: false, logLevel }, "Tried to get available memory from /proc/meminfo but failed. Falling back to os.freemem(). Error:");
+      Log.warn({ indent: false, logLevel }, err);
+    }
   }
-  return message.substring(0, index);
+  return Math.min(freemem(), maxMemory);
 };
-var callFrameToStackFrame = (callFrame) => {
-  return {
-    columnNumber: callFrame.columnNumber,
-    fileName: callFrame.url,
-    functionName: callFrame.functionName,
-    lineNumber: callFrame.lineNumber
-  };
+
+// src/get-cpu-count.ts
+import { execSync as execSync2 } from "node:child_process";
+import { cpus } from "node:os";
+var getConcurrencyFromNProc = () => {
+  try {
+    return parseInt(execSync2("nproc", { stdio: "pipe" }).toString().trim(), 10);
+  } catch {
+    return null;
+  }
 };
-var handleJavascriptException = ({
-  page,
-  onError,
-  frame
-}) => {
-  const client = page._client();
-  const handler = (exception) => {
-    const rawErrorMessage = exception.exceptionDetails.exception?.description;
-    const cleanErrorMessage = cleanUpErrorMessage(exception);
-    if (!cleanErrorMessage) {
-      console.error(exception);
-      const err = new Error(rawErrorMessage);
-      err.stack = rawErrorMessage;
-      onError(err);
-      return;
-    }
-    if (!exception.exceptionDetails.stackTrace) {
-      const err = new Error(removeDelayRenderStack(cleanErrorMessage));
-      err.stack = rawErrorMessage;
-      onError(err);
-      return;
-    }
-    const errorType = exception.exceptionDetails.exception?.className;
-    const symbolicatedErr = new SymbolicateableError({
-      message: removeDelayRenderStack(cleanErrorMessage),
-      stackFrame: exception.exceptionDetails.stackTrace.callFrames.map((f) => callFrameToStackFrame(f)),
-      frame,
-      name: errorType,
-      stack: exception.exceptionDetails.exception?.description,
-      chunk: null
-    });
-    onError(symbolicatedErr);
-  };
-  client.on("Runtime.exceptionThrown", handler);
-  return () => {
-    client.off("Runtime.exceptionThrown", handler);
-    return Promise.resolve();
-  };
+var getCpuCount = () => {
+  const node = cpus().length;
+  const nproc = getConcurrencyFromNProc();
+  if (nproc === null) {
+    return node;
+  }
+  return Math.min(nproc, node);
 };
 
-// src/error-handling/symbolicate-error.ts
-var symbolicateError = async (symbolicateableError) => {
-  const { delayRenderCall, stackFrame } = symbolicateableError;
-  const [mainErrorFrames, delayRenderFrames] = await Promise.all([
-    stackFrame ? symbolicateStackTraceFromRemoteFrames(stackFrame) : null,
-    delayRenderCall ? symbolicateStackTraceFromRemoteFrames(delayRenderCall) : null
-  ].filter(truthy));
-  const symbolicatedErr = new ErrorWithStackFrame({
-    message: symbolicateableError.message,
-    symbolicatedStackFrames: mainErrorFrames,
-    frame: symbolicateableError.frame,
-    name: symbolicateableError.name,
-    delayRenderCall: delayRenderFrames,
-    stack: symbolicateableError.stack,
-    chunk: symbolicateableError.chunk
-  });
-  return symbolicatedErr;
+// src/get-video-threads-flag.ts
+var MEMORY_USAGE_PER_THREAD = 400000000;
+var RESERVED_MEMORY = 2000000000;
+var getIdealVideoThreadsFlag = (logLevel) => {
+  const freeMemory = getAvailableMemory(logLevel);
+  const cpus2 = getCpuCount();
+  const maxRecommendedBasedOnCpus = cpus2 * 2 / 3;
+  const maxRecommendedBasedOnMemory = (freeMemory - RESERVED_MEMORY) / MEMORY_USAGE_PER_THREAD;
+  const maxRecommended = Math.min(maxRecommendedBasedOnCpus, maxRecommendedBasedOnMemory);
+  return Math.max(1, Math.round(maxRecommended));
 };
 
-// src/frame-range.ts
-var validateFrameRange = (frameRange) => {
-  if (frameRange === null) {
-    return;
-  }
-  if (typeof frameRange === "number") {
-    if (frameRange < 0) {
-      throw new TypeError("Frame must be a non-negative number, got " + frameRange);
-    }
-    if (!Number.isFinite(frameRange)) {
-      throw new TypeError("Frame must be a finite number, got " + frameRange);
-    }
-    if (!Number.isInteger(frameRange)) {
-      throw new Error(`Frame must be an integer, but got a float (${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);
-    }
-    for (const value of frameRange) {
-      if (typeof value !== "number") {
-        throw new Error(`Each value of frame range must be a number, but got ${typeof value} (${JSON.stringify(value)})`);
-      }
-      if (!Number.isFinite(value)) {
-        throw new TypeError("Each value of frame range must be finite, but got " + value);
-      }
-      if (!Number.isInteger(value)) {
-        throw new Error(`Each value of frame range must be an integer, but got a float (${value})`);
-      }
-      if (value < 0) {
-        throw new Error(`Each value of frame range must be non-negative, but got ${value}`);
-      }
-    }
-    const [first, second] = frameRange;
-    if (second < first) {
-      throw new Error("The second value of frame range must be not smaller than the first one, but got " + frameRange.join("-"));
-    }
-    return;
+// src/options/gl.tsx
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+var validOpenGlRenderers = [
+  "swangle",
+  "angle",
+  "egl",
+  "swiftshader",
+  "vulkan",
+  "angle-egl"
+];
+var DEFAULT_OPENGL_RENDERER = null;
+var validateOpenGlRenderer = (option) => {
+  if (option === null) {
+    return null;
   }
-  throw new TypeError("Frame range must be a number or a tuple of numbers, but got object of type " + typeof frameRange);
-};
-
-// src/get-compositions.ts
-import { NoReactInternals as NoReactInternals8 } from "remotion/no-react";
-
-// src/to-megabytes.ts
-function toMegabytes(bytes) {
-  const mb = bytes / 1024 / 1024;
-  return `${Math.round(mb * 10) / 10} Mb`;
-}
-
-// src/browser/browser-download-progress-bar.ts
-var defaultBrowserDownloadProgress = ({
-  indent,
-  logLevel,
-  api
-}) => ({ chromeMode }) => {
-  if (chromeMode === "chrome-for-testing") {
-    Log.info({ indent, logLevel }, "Downloading Chrome for Testing https://www.remotion.dev/chrome-for-testing");
-  } else {
-    Log.info({ indent, logLevel }, "Downloading Chrome Headless Shell https://www.remotion.dev/chrome-headless-shell");
+  if (!validOpenGlRenderers.includes(option)) {
+    throw new TypeError(`${option} is not a valid GL backend. Accepted values: ${validOpenGlRenderers.join(", ")}`);
   }
-  Log.info({ indent, logLevel }, `Customize this behavior by adding a onBrowserDownload function to ${api}.`);
-  let lastProgress = 0;
-  return {
-    onProgress: (progress) => {
-      if (progress.downloadedBytes > lastProgress + 1e7 || progress.percent === 1) {
-        lastProgress = progress.downloadedBytes;
-        if (chromeMode === "chrome-for-testing") {
-          Log.info({ indent, logLevel }, `Downloading Chrome for Testing - ${toMegabytes(progress.downloadedBytes)}/${toMegabytes(progress.totalSizeInBytes)}`);
-        } else {
-          Log.info({ indent, logLevel }, `Downloading Chrome Headless Shell - ${toMegabytes(progress.downloadedBytes)}/${toMegabytes(progress.totalSizeInBytes)}`);
-        }
-      }
-    },
-    version: null
-  };
+  return option;
 };
 
 // src/open-browser.ts
-import fs9 from "node:fs";
-import os3 from "node:os";
-import path9 from "node:path";
-
-// src/browser/Launcher.ts
-var launchChrome = async ({
-  args,
-  executablePath,
-  defaultViewport,
-  indent,
-  logLevel,
-  userDataDir
-}) => {
-  const timeout = 60000;
-  const browser = await HeadlessBrowser.create({
-    defaultViewport,
-    args,
-    executablePath,
-    timeout,
-    userDataDir,
-    logLevel,
-    indent
-  });
-  try {
-    await browser.waitForTarget((t) => {
-      return t.type() === "page";
-    }, { timeout });
-  } catch (error) {
-    await browser.close({ silent: false });
-    throw error;
-  }
-  return browser;
-};
-
-// src/ensure-browser.ts
-import fs7 from "fs";
-
-// src/browser/BrowserFetcher.ts
-import * as fs6 from "node:fs";
-import * as os2 from "node:os";
-import * as path8 from "node:path";
-import extractZip from "extract-zip";
-import { promisify } from "node:util";
-
-// src/browser/get-download-destination.ts
-import fs5 from "node:fs";
-import path7 from "node:path";
-var getDownloadsCacheDir = () => {
-  const cwd = process.cwd();
-  let dir = cwd;
-  for (;; ) {
-    try {
-      if (fs5.statSync(path7.join(dir, "package.json")).isFile()) {
-        break;
-      }
-    } catch (e) {
-    }
-    const parent = path7.dirname(dir);
-    if (dir === parent) {
-      dir = undefined;
-      break;
-    }
-    dir = parent;
-  }
-  if (!dir) {
-    return path7.resolve(cwd, ".remotion");
-  }
-  if (process.versions.pnp === "1") {
-    return path7.resolve(dir, ".pnp/.remotion");
+var featuresToEnable = (option) => {
+  const renderer = option ?? DEFAULT_OPENGL_RENDERER;
+  const enableAlways = ["NetworkService", "NetworkServiceInProcess"];
+  if (renderer === "vulkan") {
+    return [...enableAlways, "Vulkan", "UseSkiaRenderer"];
   }
-  if (process.versions.pnp === "3") {
-    return path7.resolve(dir, ".yarn/.remotion");
+  if (renderer === "angle-egl") {
+    return [...enableAlways, "VaapiVideoDecoder"];
   }
-  return path7.resolve(dir, "node_modules/.remotion");
+  return enableAlways;
 };
-
-// src/browser/BrowserFetcher.ts
-var TESTED_VERSION = "133.0.6943.0";
-var PLAYWRIGHT_VERSION = "1155";
-function getChromeDownloadUrl({
-  platform: platform2,
-  version,
-  chromeMode
-}) {
-  if (platform2 === "linux-arm64") {
-    return `https://playwright.azureedge.net/builds/chromium/${version ?? PLAYWRIGHT_VERSION}/chromium-headless-shell-linux-arm64.zip`;
+var getOpenGlRenderer = (option) => {
+  const renderer = option ?? DEFAULT_OPENGL_RENDERER;
+  validateOpenGlRenderer(renderer);
+  if (renderer === "swangle") {
+    return ["--use-gl=angle", "--use-angle=swiftshader"];
   }
-  if (chromeMode === "headless-shell") {
-    return `https://storage.googleapis.com/chrome-for-testing-public/${version ?? TESTED_VERSION}/${platform2}/chrome-headless-shell-${platform2}.zip`;
+  if (renderer === "angle-egl") {
+    return ["--use-gl=angle", "--use-angle=gl-egl"];
   }
-  return `https://storage.googleapis.com/chrome-for-testing-public/${version ?? TESTED_VERSION}/${platform2}/chrome-${platform2}.zip`;
-}
-var mkdirAsync = fs6.promises.mkdir;
-var unlinkAsync = promisify(fs6.unlink.bind(fs6));
-function existsAsync(filePath) {
-  return new Promise((resolve2) => {
-    fs6.access(filePath, (err) => {
-      return resolve2(!err);
-    });
-  });
-}
-var getPlatform = () => {
-  const platform2 = os2.platform();
-  switch (platform2) {
-    case "darwin":
-      return os2.arch() === "arm64" ? "mac-arm64" : "mac-x64";
-    case "linux":
-      return os2.arch() === "arm64" ? "linux-arm64" : "linux64";
-    case "win32":
-      return "win64";
-    default:
-      throw new Error("Unsupported platform: " + platform2);
+  if (renderer === "vulkan") {
+    return [
+      "--use-angle=vulkan",
+      "--use-vulkan=native",
+      "--disable-vulkan-fallback-to-gl-for-testing",
+      "--disable-vulkan-surface",
+      "--ignore-gpu-blocklist",
+      "--enable-gpu"
+    ];
   }
+  if (renderer === null) {
+    return [];
+  }
+  return [`--use-gl=${renderer}`];
 };
-var getDownloadsFolder = (chromeMode) => {
-  const destination = chromeMode === "headless-shell" ? "chrome-headless-shell" : "chrome-for-testing";
-  return path8.join(getDownloadsCacheDir(), destination);
-};
-var downloadBrowser = async ({
-  logLevel,
+var internalOpenBrowser = async ({
+  browser,
+  browserExecutable,
+  chromiumOptions,
+  forceDeviceScaleFactor,
   indent,
-  onProgress,
-  version,
+  viewport,
+  logLevel,
+  onBrowserDownload,
   chromeMode
 }) => {
-  const platform2 = getPlatform();
-  const downloadURL = getChromeDownloadUrl({ platform: platform2, version, chromeMode });
-  const fileName = downloadURL.split("/").pop();
-  if (!fileName) {
-    throw new Error(`A malformed download URL was found: ${downloadURL}.`);
-  }
-  const downloadsFolder = getDownloadsFolder(chromeMode);
-  const archivePath = path8.join(downloadsFolder, fileName);
-  const outputPath = getFolderPath(downloadsFolder, platform2);
-  if (await existsAsync(outputPath)) {
-    return getRevisionInfo(chromeMode);
-  }
-  if (!await existsAsync(downloadsFolder)) {
-    await mkdirAsync(downloadsFolder, {
-      recursive: true
-    });
-  }
-  if (os2.platform() !== "darwin" && os2.platform() !== "linux" && os2.arch() === "arm64") {
-    throw new Error([
-      "Chrome Headless Shell is not available for Windows for arm64 architecture."
-    ].join(`
-`));
+  if (browser === "firefox") {
+    throw new TypeError("Firefox supported is not yet turned on. Stay tuned for the future.");
   }
-  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
-        });
-      },
-      indent,
-      logLevel
-    });
-    await extractZip(archivePath, { dir: outputPath });
-    const chromePath = path8.join(outputPath, "chrome-linux", "chrome");
-    const chromeHeadlessShellPath = path8.join(outputPath, "chrome-linux", "chrome-headless-shell");
-    if (fs6.existsSync(chromePath)) {
-      fs6.renameSync(chromePath, chromeHeadlessShellPath);
-    }
-    const chromeLinuxFolder = path8.join(outputPath, "chrome-linux");
-    if (fs6.existsSync(chromeLinuxFolder)) {
-      fs6.renameSync(chromeLinuxFolder, path8.join(outputPath, "chrome-headless-shell-linux-arm64"));
-    }
-  } catch (err) {
-    return Promise.reject(err);
-  } finally {
-    if (await existsAsync(archivePath)) {
-      await unlinkAsync(archivePath);
-    }
-  }
-  const revisionInfo = getRevisionInfo(chromeMode);
-  makeFileExecutableIfItIsNot(revisionInfo.executablePath);
-  return revisionInfo;
-};
-var getFolderPath = (downloadsFolder, platform2) => {
-  return path8.resolve(downloadsFolder, platform2);
-};
-var getExecutablePath2 = (chromeMode) => {
-  const downloadsFolder = getDownloadsFolder(chromeMode);
-  const platform2 = getPlatform();
-  const folderPath = getFolderPath(downloadsFolder, platform2);
-  if (chromeMode === "chrome-for-testing") {
-    if (platform2 === "mac-arm64" || platform2 === "mac-x64") {
-      return path8.join(folderPath, `chrome-${platform2}`, "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing");
-    }
-    if (platform2 === "win64") {
-      return path8.join(folderPath, "chrome-win64", "chrome.exe");
-    }
-    if (platform2 === "linux64" || platform2 === "linux-arm64") {
-      return path8.join(folderPath, "chrome-linux64", "chrome");
-    }
-    throw new Error("unsupported platform" + platform2);
-  }
-  if (chromeMode === "headless-shell") {
-    return path8.join(folderPath, `chrome-headless-shell-${platform2}`, platform2 === "win64" ? "chrome-headless-shell.exe" : platform2 === "linux-arm64" ? "headless_shell" : "chrome-headless-shell");
+  await internalEnsureBrowser({
+    browserExecutable,
+    logLevel,
+    indent,
+    onBrowserDownload,
+    chromeMode
+  });
+  const executablePath = getLocalBrowserExecutable({
+    preferredBrowserExecutable: browserExecutable,
+    logLevel,
+    indent,
+    chromeMode
+  });
+  const customGlRenderer = getOpenGlRenderer(chromiumOptions.gl ?? null);
+  const enableMultiProcessOnLinux = chromiumOptions.enableMultiProcessOnLinux ?? true;
+  Log.verbose({ indent, logLevel, tag: "openBrowser()" }, `Opening browser: gl = ${chromiumOptions.gl}, executable = ${executablePath}, enableMultiProcessOnLinux = ${enableMultiProcessOnLinux}`);
+  if (chromiumOptions.userAgent) {
+    Log.verbose({ indent, logLevel: "verbose", tag: "openBrowser()" }, `Using custom user agent: ${chromiumOptions.userAgent}`);
   }
-  throw new Error("unsupported chrome mode" + chromeMode);
-};
-var getRevisionInfo = (chromeMode) => {
-  const executablePath = getExecutablePath2(chromeMode);
-  const downloadsFolder = getDownloadsFolder(chromeMode);
-  const platform2 = getPlatform();
-  const folderPath = getFolderPath(downloadsFolder, platform2);
-  const url = getChromeDownloadUrl({ platform: platform2, version: null, chromeMode });
-  const local = fs6.existsSync(folderPath);
-  return {
+  const userDataDir = await fs9.promises.mkdtemp(path9.join(os3.tmpdir(), "puppeteer_dev_chrome_profile-"));
+  const browserInstance = await launchChrome({
     executablePath,
-    folderPath,
-    local,
-    url
-  };
-};
-
-// src/ensure-browser.ts
-var currentEnsureBrowserOperation = Promise.resolve();
-var internalEnsureBrowserUncapped = async ({
-  indent,
-  logLevel,
-  browserExecutable,
-  onBrowserDownload,
-  chromeMode
-}) => {
-  const status = getBrowserStatus({ browserExecutable, chromeMode });
-  if (status.type === "no-browser") {
-    const { onProgress, version } = onBrowserDownload({ chromeMode });
-    await downloadBrowser({ indent, logLevel, onProgress, version, chromeMode });
-  }
-  const newStatus = getBrowserStatus({ browserExecutable, chromeMode });
-  return newStatus;
-};
-var internalEnsureBrowser = (options) => {
-  currentEnsureBrowserOperation = currentEnsureBrowserOperation.then(() => internalEnsureBrowserUncapped(options));
-  return currentEnsureBrowserOperation;
-};
-var getBrowserStatus = ({
-  browserExecutable,
-  chromeMode
-}) => {
-  if (browserExecutable) {
-    if (!fs7.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.`);
+    logLevel,
+    indent,
+    userDataDir,
+    args: [
+      "about:blank",
+      "--allow-pre-commit-input",
+      "--disable-background-networking",
+      `--enable-features=${featuresToEnable(chromiumOptions.gl).join(",")}`,
+      "--disable-background-timer-throttling",
+      "--disable-backgrounding-occluded-windows",
+      "--disable-breakpad",
+      "--disable-client-side-phishing-detection",
+      "--disable-component-extensions-with-background-pages",
+      "--disable-default-apps",
+      "--disable-dev-shm-usage",
+      "--no-proxy-server",
+      "--proxy-server='direct://'",
+      "--proxy-bypass-list=*",
+      "--force-gpu-mem-available-mb=4096",
+      "--disable-hang-monitor",
+      "--disable-extensions",
+      "--allow-chrome-scheme-url",
+      "--disable-ipc-flooding-protection",
+      "--disable-popup-blocking",
+      "--disable-prompt-on-repost",
+      "--disable-renderer-backgrounding",
+      "--disable-sync",
+      "--force-color-profile=srgb",
+      "--metrics-recording-only",
+      "--mute-audio",
+      "--no-first-run",
+      `--video-threads=${getIdealVideoThreadsFlag(logLevel)}`,
+      "--enable-automation",
+      "--password-store=basic",
+      "--use-mock-keychain",
+      "--enable-blink-features=IdleDetection",
+      "--export-tagged-pdf",
+      "--intensive-wake-up-throttling-policy=0",
+      chromiumOptions.headless ?? true ? chromeMode === "chrome-for-testing" ? "--headless=new" : "--headless=old" : null,
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      ...customGlRenderer,
+      "--disable-background-media-suspend",
+      process.platform === "linux" && chromiumOptions.gl !== "vulkan" && !enableMultiProcessOnLinux ? "--single-process" : null,
+      "--allow-running-insecure-content",
+      "--disable-component-update",
+      "--disable-domain-reliability",
+      "--disable-features=AudioServiceOutOfProcess,IsolateOrigins,site-per-process,Translate,BackForwardCache,AvoidUnnecessaryBeforeUnloadCheckSync,IntensiveWakeUpThrottling",
+      "--disable-print-preview",
+      "--disable-site-isolation-trials",
+      "--disk-cache-size=268435456",
+      "--hide-scrollbars",
+      "--no-default-browser-check",
+      "--no-pings",
+      "--font-render-hinting=none",
+      "--no-zygote",
+      "--ignore-gpu-blocklist",
+      "--enable-unsafe-webgpu",
+      typeof forceDeviceScaleFactor === "undefined" ? null : `--force-device-scale-factor=${forceDeviceScaleFactor}`,
+      chromiumOptions.ignoreCertificateErrors ? "--ignore-certificate-errors" : null,
+      ...chromiumOptions?.disableWebSecurity ? ["--disable-web-security"] : [],
+      chromiumOptions?.userAgent ? `--user-agent="${chromiumOptions.userAgent}"` : null,
+      "--remote-debugging-port=0",
+      `--user-data-dir=${userDataDir}`
+    ].filter(Boolean),
+    defaultViewport: viewport ?? {
+      height: 720,
+      width: 1280,
+      deviceScaleFactor: 1
     }
-    return { path: browserExecutable, type: "user-defined-path" };
-  }
-  const revision = getRevisionInfo(chromeMode);
-  if (revision.local && fs7.existsSync(revision.executablePath)) {
-    return { path: revision.executablePath, type: "local-puppeteer-browser" };
-  }
-  return { type: "no-browser" };
+  });
+  const pages = await browserInstance.pages();
+  await pages[0]?.close();
+  return browserInstance;
 };
-var ensureBrowser = (options) => {
+var openBrowser = (browser, options) => {
+  const { browserExecutable, chromiumOptions, forceDeviceScaleFactor } = options ?? {};
   const indent = false;
-  const logLevel = options?.logLevel ?? "info";
-  return internalEnsureBrowser({
-    browserExecutable: options?.browserExecutable ?? null,
+  const logLevel = options?.logLevel ?? (options?.shouldDumpIo ? "verbose" : "info");
+  return internalOpenBrowser({
+    browser,
+    browserExecutable: browserExecutable ?? null,
+    chromiumOptions: chromiumOptions ?? {},
+    forceDeviceScaleFactor,
     indent,
-    logLevel: options?.logLevel ?? "info",
-    onBrowserDownload: options?.onBrowserDownload ?? defaultBrowserDownloadProgress({
-      api: "ensureBrowser()",
-      indent: false,
-      logLevel
+    viewport: null,
+    logLevel,
+    onBrowserDownload: defaultBrowserDownloadProgress({
+      indent,
+      logLevel,
+      api: "openBrowser()"
     }),
     chromeMode: options?.chromeMode ?? "headless-shell"
   });
 };
 
-// src/get-local-browser-executable.ts
-import fs8 from "node:fs";
-var getBrowserStatus2 = ({
-  browserExecutablePath,
+// src/get-browser-instance.ts
+var getPageAndCleanupFn = async ({
+  passedInInstance,
+  browserExecutable,
+  chromiumOptions,
+  forceDeviceScaleFactor,
   indent,
   logLevel,
-  chromeMode
+  onBrowserDownload,
+  chromeMode,
+  pageIndex,
+  onBrowserLog
 }) => {
-  if (browserExecutablePath) {
-    if (!fs8.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 && fs8.existsSync(revision.executablePath)) {
-    return { path: revision.executablePath, type: "local-puppeteer-browser" };
-  }
-  return { type: "no-browser" };
-};
-var getLocalBrowserExecutable = ({
-  preferredBrowserExecutable,
-  logLevel,
-  indent,
-  chromeMode
-}) => {
-  const status = getBrowserStatus2({
-    browserExecutablePath: preferredBrowserExecutable,
+  if (passedInInstance) {
+    const page = await passedInInstance.newPage({
+      context: () => null,
+      logLevel,
+      indent,
+      pageIndex,
+      onBrowserLog
+    });
+    return {
+      page,
+      cleanupPage: () => {
+        page.close().catch((err) => {
+          if (!err.message.includes("Target closed")) {
+            Log.error({ indent, logLevel }, "Was not able to close puppeteer page", err);
+          }
+        });
+        return Promise.resolve();
+      }
+    };
+  }
+  const browserInstance = await internalOpenBrowser({
+    browser: DEFAULT_BROWSER,
+    browserExecutable,
+    chromiumOptions,
+    forceDeviceScaleFactor,
     indent,
+    viewport: null,
     logLevel,
+    onBrowserDownload,
     chromeMode
   });
-  if (status.type === "no-browser") {
-    throw new TypeError("No browser found for rendering frames! Please open a GitHub issue and describe " + "how you reached this error: https://remotion.dev/issue");
-  }
-  return status.path;
-};
-
-// src/get-available-memory.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { freemem } from "node:os";
-var getFreeMemoryFromProcMeminfo = () => {
-  const data = readFileSync2("/proc/meminfo", "utf-8");
-  const lines = data.split(`
-`);
-  const memAvailableLine = lines.find((line) => line.startsWith("MemAvailable"));
-  if (!memAvailableLine) {
-    throw new Error("MemAvailable not found in /proc/meminfo");
-  }
-  const matches = memAvailableLine.match(/(\d+)\s+(\w+)/);
-  if (!matches || matches.length !== 3) {
-    throw new Error("Failed to parse MemAvailable value");
-  }
-  const value = parseInt(matches[1], 10);
-  const unit = matches[2].toLowerCase();
-  switch (unit) {
-    case "kb":
-      return value * 1024;
-    case "mb":
-      return value * 1024 * 1024;
-    case "gb":
-      return value * 1024 * 1024 * 1024;
-    default:
-      throw new Error(`Unknown unit: ${unit}`);
-  }
-};
-var maxLambdaMemory = () => {
-  if (process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) {
-    return parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE, 10) * 1024 * 1024;
-  }
-  return Infinity;
-};
-var getAvailableMemory = (logLevel) => {
-  const maxMemory = maxLambdaMemory();
-  if (existsSync3("/proc/meminfo")) {
-    try {
-      const val = getFreeMemoryFromProcMeminfo();
-      if (val !== null) {
-        return Math.min(val, maxMemory);
-      }
-    } catch (err) {
-      Log.warn({ indent: false, logLevel }, "Tried to get available memory from /proc/meminfo but failed. Falling back to os.freemem(). Error:");
-      Log.warn({ indent: false, logLevel }, err);
+  const browserPage = await browserInstance.newPage({
+    context: () => null,
+    logLevel,
+    indent,
+    pageIndex,
+    onBrowserLog
+  });
+  return {
+    page: browserPage,
+    cleanupPage: () => {
+      browserInstance.close({ silent: true }).catch((err) => {
+        if (!err.message.includes("Target closed")) {
+          Log.error({ indent, logLevel }, "Was not able to close puppeteer page", err);
+        }
+      });
+      return Promise.resolve();
     }
-  }
-  return Math.min(freemem(), maxMemory);
+  };
 };
 
-// src/get-cpu-count.ts
-import { execSync as execSync2 } from "node:child_process";
-import { cpus } from "node:os";
-var getConcurrencyFromNProc = () => {
-  try {
-    return parseInt(execSync2("nproc", { stdio: "pipe" }).toString().trim(), 10);
-  } catch {
-    return null;
-  }
-};
-var getCpuCount = () => {
-  const node = cpus().length;
-  const nproc = getConcurrencyFromNProc();
-  if (nproc === null) {
-    return node;
-  }
-  return Math.min(nproc, node);
-};
+// src/options/offthreadvideo-threads.tsx
+import { jsx as jsx2, jsxs as jsxs2, Fragment as Fragment2 } from "react/jsx-runtime";
+var DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS = 2;
 
-// src/get-video-threads-flag.ts
-var MEMORY_USAGE_PER_THREAD = 400000000;
-var RESERVED_MEMORY = 2000000000;
-var getIdealVideoThreadsFlag = (logLevel) => {
-  const freeMemory = getAvailableMemory(logLevel);
-  const cpus2 = getCpuCount();
-  const maxRecommendedBasedOnCpus = cpus2 * 2 / 3;
-  const maxRecommendedBasedOnMemory = (freeMemory - RESERVED_MEMORY) / MEMORY_USAGE_PER_THREAD;
-  const maxRecommended = Math.min(maxRecommendedBasedOnCpus, maxRecommendedBasedOnMemory);
-  return Math.max(1, Math.round(maxRecommended));
-};
+// src/prepare-server.ts
+import { existsSync as existsSync4 } from "node:fs";
+import path18 from "node:path";
+import { NoReactInternals as NoReactInternals7 } from "remotion/no-react";
 
-// src/options/gl.tsx
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-var validOpenGlRenderers = [
-  "swangle",
-  "angle",
-  "egl",
-  "swiftshader",
-  "vulkan",
-  "angle-egl"
-];
-var DEFAULT_OPENGL_RENDERER = null;
-var validateOpenGlRenderer = (option) => {
-  if (option === null) {
-    return null;
-  }
-  if (!validOpenGlRenderers.includes(option)) {
-    throw new TypeError(`${option} is not a valid GL backend. Accepted values: ${validOpenGlRenderers.join(", ")}`);
-  }
-  return option;
-};
+// src/assets/download-and-map-assets-to-file.ts
+import fs10 from "node:fs";
+import path11, { extname as extname2 } from "node:path";
+import { random } from "remotion/no-react";
 
-// src/open-browser.ts
-var featuresToEnable = (option) => {
-  const renderer = option ?? DEFAULT_OPENGL_RENDERER;
-  const enableAlways = ["NetworkService", "NetworkServiceInProcess"];
-  if (renderer === "vulkan") {
-    return [...enableAlways, "Vulkan", "UseSkiaRenderer"];
+// src/compress-assets.ts
+var compressAsset = (previousRenderAssets, newRenderAsset) => {
+  if (newRenderAsset.src.length < 400) {
+    return newRenderAsset;
   }
-  if (renderer === "angle-egl") {
-    return [...enableAlways, "VaapiVideoDecoder"];
+  const assetWithSameSrc = previousRenderAssets.find((a) => a.src === newRenderAsset.src);
+  if (!assetWithSameSrc) {
+    return newRenderAsset;
   }
-  return enableAlways;
+  return {
+    ...newRenderAsset,
+    src: `same-as-${assetWithSameSrc.id}-${assetWithSameSrc.frame}`
+  };
 };
-var getOpenGlRenderer = (option) => {
-  const renderer = option ?? DEFAULT_OPENGL_RENDERER;
-  validateOpenGlRenderer(renderer);
-  if (renderer === "swangle") {
-    return ["--use-gl=angle", "--use-angle=swiftshader"];
-  }
-  if (renderer === "angle-egl") {
-    return ["--use-gl=angle", "--use-angle=gl-egl"];
-  }
-  if (renderer === "vulkan") {
-    return [
-      "--use-angle=vulkan",
-      "--use-vulkan=native",
-      "--disable-vulkan-fallback-to-gl-for-testing",
-      "--disable-vulkan-surface",
-      "--ignore-gpu-blocklist",
-      "--enable-gpu"
-    ];
-  }
-  if (renderer === null) {
-    return [];
-  }
-  return [`--use-gl=${renderer}`];
-};
-var internalOpenBrowser = async ({
-  browser,
-  browserExecutable,
-  chromiumOptions,
-  forceDeviceScaleFactor,
-  indent,
-  viewport,
-  logLevel,
-  onBrowserDownload,
-  chromeMode
-}) => {
-  if (browser === "firefox") {
-    throw new TypeError("Firefox supported is not yet turned on. Stay tuned for the future.");
-  }
-  await internalEnsureBrowser({
-    browserExecutable,
-    logLevel,
-    indent,
-    onBrowserDownload,
-    chromeMode
-  });
-  const executablePath = getLocalBrowserExecutable({
-    preferredBrowserExecutable: browserExecutable,
-    logLevel,
-    indent,
-    chromeMode
-  });
-  const customGlRenderer = getOpenGlRenderer(chromiumOptions.gl ?? null);
-  const enableMultiProcessOnLinux = chromiumOptions.enableMultiProcessOnLinux ?? true;
-  Log.verbose({ indent, logLevel, tag: "openBrowser()" }, `Opening browser: gl = ${chromiumOptions.gl}, executable = ${executablePath}, enableMultiProcessOnLinux = ${enableMultiProcessOnLinux}`);
-  if (chromiumOptions.userAgent) {
-    Log.verbose({ indent, logLevel: "verbose", tag: "openBrowser()" }, `Using custom user agent: ${chromiumOptions.userAgent}`);
-  }
-  const userDataDir = await fs9.promises.mkdtemp(path9.join(os3.tmpdir(), "puppeteer_dev_chrome_profile-"));
-  const browserInstance = await launchChrome({
-    executablePath,
-    logLevel,
-    indent,
-    userDataDir,
-    args: [
-      "about:blank",
-      "--allow-pre-commit-input",
-      "--disable-background-networking",
-      `--enable-features=${featuresToEnable(chromiumOptions.gl).join(",")}`,
-      "--disable-background-timer-throttling",
-      "--disable-backgrounding-occluded-windows",
-      "--disable-breakpad",
-      "--disable-client-side-phishing-detection",
-      "--disable-component-extensions-with-background-pages",
-      "--disable-default-apps",
-      "--disable-dev-shm-usage",
-      "--no-proxy-server",
-      "--proxy-server='direct://'",
-      "--proxy-bypass-list=*",
-      "--force-gpu-mem-available-mb=4096",
-      "--disable-hang-monitor",
-      "--disable-extensions",
-      "--allow-chrome-scheme-url",
-      "--disable-ipc-flooding-protection",
-      "--disable-popup-blocking",
-      "--disable-prompt-on-repost",
-      "--disable-renderer-backgrounding",
-      "--disable-sync",
-      "--force-color-profile=srgb",
-      "--metrics-recording-only",
-      "--mute-audio",
-      "--no-first-run",
-      `--video-threads=${getIdealVideoThreadsFlag(logLevel)}`,
-      "--enable-automation",
-      "--password-store=basic",
-      "--use-mock-keychain",
-      "--enable-blink-features=IdleDetection",
-      "--export-tagged-pdf",
-      "--intensive-wake-up-throttling-policy=0",
-      chromiumOptions.headless ?? true ? chromeMode === "chrome-for-testing" ? "--headless=new" : "--headless=old" : null,
-      "--no-sandbox",
-      "--disable-setuid-sandbox",
-      ...customGlRenderer,
-      "--disable-background-media-suspend",
-      process.platform === "linux" && chromiumOptions.gl !== "vulkan" && !enableMultiProcessOnLinux ? "--single-process" : null,
-      "--allow-running-insecure-content",
-      "--disable-component-update",
-      "--disable-domain-reliability",
-      "--disable-features=AudioServiceOutOfProcess,IsolateOrigins,site-per-process,Translate,BackForwardCache,AvoidUnnecessaryBeforeUnloadCheckSync,IntensiveWakeUpThrottling",
-      "--disable-print-preview",
-      "--disable-site-isolation-trials",
-      "--disk-cache-size=268435456",
-      "--hide-scrollbars",
-      "--no-default-browser-check",
-      "--no-pings",
-      "--font-render-hinting=none",
-      "--no-zygote",
-      "--ignore-gpu-blocklist",
-      "--enable-unsafe-webgpu",
-      typeof forceDeviceScaleFactor === "undefined" ? null : `--force-device-scale-factor=${forceDeviceScaleFactor}`,
-      chromiumOptions.ignoreCertificateErrors ? "--ignore-certificate-errors" : null,
-      ...chromiumOptions?.disableWebSecurity ? ["--disable-web-security"] : [],
-      chromiumOptions?.userAgent ? `--user-agent="${chromiumOptions.userAgent}"` : null,
-      "--remote-debugging-port=0",
-      `--user-data-dir=${userDataDir}`
-    ].filter(Boolean),
-    defaultViewport: viewport ?? {
-      height: 720,
-      width: 1280,
-      deviceScaleFactor: 1
-    }
-  });
-  const pages = await browserInstance.pages();
-  await pages[0]?.close();
-  return browserInstance;
-};
-var openBrowser = (browser, options) => {
-  const { browserExecutable, chromiumOptions, forceDeviceScaleFactor } = options ?? {};
-  const indent = false;
-  const logLevel = options?.logLevel ?? (options?.shouldDumpIo ? "verbose" : "info");
-  return internalOpenBrowser({
-    browser,
-    browserExecutable: browserExecutable ?? null,
-    chromiumOptions: chromiumOptions ?? {},
-    forceDeviceScaleFactor,
-    indent,
-    viewport: null,
-    logLevel,
-    onBrowserDownload: defaultBrowserDownloadProgress({
-      indent,
-      logLevel,
-      api: "openBrowser()"
-    }),
-    chromeMode: options?.chromeMode ?? "headless-shell"
-  });
-};
-
-// src/get-browser-instance.ts
-var getPageAndCleanupFn = async ({
-  passedInInstance,
-  browserExecutable,
-  chromiumOptions,
-  forceDeviceScaleFactor,
-  indent,
-  logLevel,
-  onBrowserDownload,
-  chromeMode,
-  pageIndex,
-  onBrowserLog
-}) => {
-  if (passedInInstance) {
-    const page = await passedInInstance.newPage({
-      context: () => null,
-      logLevel,
-      indent,
-      pageIndex,
-      onBrowserLog
-    });
-    return {
-      page,
-      cleanupPage: () => {
-        page.close().catch((err) => {
-          if (!err.message.includes("Target closed")) {
-            Log.error({ indent, logLevel }, "Was not able to close puppeteer page", err);
-          }
-        });
-        return Promise.resolve();
-      }
-    };
-  }
-  const browserInstance = await internalOpenBrowser({
-    browser: DEFAULT_BROWSER,
-    browserExecutable,
-    chromiumOptions,
-    forceDeviceScaleFactor,
-    indent,
-    viewport: null,
-    logLevel,
-    onBrowserDownload,
-    chromeMode
-  });
-  const browserPage = await browserInstance.newPage({
-    context: () => null,
-    logLevel,
-    indent,
-    pageIndex,
-    onBrowserLog
-  });
-  return {
-    page: browserPage,
-    cleanupPage: () => {
-      browserInstance.close({ silent: true }).catch((err) => {
-        if (!err.message.includes("Target closed")) {
-          Log.error({ indent, logLevel }, "Was not able to close puppeteer page", err);
-        }
-      });
-      return Promise.resolve();
-    }
-  };
-};
-
-// src/options/offthreadvideo-threads.tsx
-import { jsx as jsx2, jsxs as jsxs2, Fragment as Fragment2 } from "react/jsx-runtime";
-var DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS = 2;
-
-// src/prepare-server.ts
-import { existsSync as existsSync4 } from "node:fs";
-import path18 from "node:path";
-import { NoReactInternals as NoReactInternals7 } from "remotion/no-react";
-
-// src/assets/download-and-map-assets-to-file.ts
-import fs10 from "node:fs";
-import path11, { extname as extname2 } from "node:path";
-import { random } from "remotion/no-react";
-
-// src/compress-assets.ts
-var compressAsset = (previousRenderAssets, newRenderAsset) => {
-  if (newRenderAsset.src.length < 400) {
-    return newRenderAsset;
-  }
-  const assetWithSameSrc = previousRenderAssets.find((a) => a.src === newRenderAsset.src);
-  if (!assetWithSameSrc) {
-    return newRenderAsset;
-  }
-  return {
-    ...newRenderAsset,
-    src: `same-as-${assetWithSameSrc.id}-${assetWithSameSrc.frame}`
-  };
-};
-var isAssetCompressed = (src) => {
-  return src.startsWith("same-as");
+var isAssetCompressed = (src) => {
+  return src.startsWith("same-as");
 };
 
 // src/mime-types.ts
@@ -16738,7 +15971,7 @@ var seekToFrame = async ({
 };
 
 // src/set-props-and-env.ts
-import { VERSION as VERSION5 } from "remotion/version";
+import { VERSION as VERSION2 } from "remotion/version";
 
 // src/goto-page-or-throw.ts
 var gotoPageOrThrow = async (page, urlToVisit, actualTimeout) => {
@@ -16927,7 +16160,7 @@ var innerSetPropsAndEnv = async ({
     throw new Error([
       `Incompatible site: When visiting ${urlToVisit}, a bundle was found, but one that is not compatible with this version of Remotion. Found version: ${siteVersion} - Required version: ${requiredVersion}. To resolve this error:`,
       "When using server-side rendering:",
-      ` ▸ Use 'bundle()' with '@remotion/bundler' of version ${VERSION5} to create a compatible bundle.`,
+      ` ▸ Use 'bundle()' with '@remotion/bundler' of version ${VERSION2} to create a compatible bundle.`,
       "When using the Remotion Lambda:",
       " ▸ Use `npx remotion lambda sites create` to redeploy the site with the latest version.",
       " ℹ Use --site-name with the same name as before to overwrite your site.",
@@ -16935,13 +16168,13 @@ var innerSetPropsAndEnv = async ({
     ].join(`
 `));
   }
-  if (remotionVersion !== VERSION5 && true) {
+  if (remotionVersion !== VERSION2 && true) {
     if (remotionVersion) {
       Log.warn({
         indent,
         logLevel
       }, [
-        `The site was bundled with version ${remotionVersion} of @remotion/bundler, while @remotion/renderer is on version ${VERSION5}. You may not have the newest bugfixes and features.`,
+        `The site was bundled with version ${remotionVersion} of @remotion/bundler, while @remotion/renderer is on version ${VERSION2}. You may not have the newest bugfixes and features.`,
         `To resolve this warning:`,
         "▸ Use `npx remotion lambda sites create` to redeploy the site with the latest version.",
         "  ℹ Use --site-name with the same name as before to overwrite your site.",
@@ -16952,7 +16185,7 @@ var innerSetPropsAndEnv = async ({
       Log.warn({
         indent,
         logLevel
-      }, `The site was bundled with an old version of Remotion, while @remotion/renderer is on version ${VERSION5}. You may not have the newest bugfixes and features. Re-bundle the site to fix this issue.`);
+      }, `The site was bundled with an old version of Remotion, while @remotion/renderer is on version ${VERSION2}. You may not have the newest bugfixes and features. Re-bundle the site to fix this issue.`);
     }
   }
 };
@@ -17065,6 +16298,14 @@ var printUsefulErrorMessage = (err, logLevel, indent) => {
     Log.info({ indent, logLevel }, "\uD83D\uDCA1 On Lambda, one reason this could happen is that Chrome is rejecting an asset to be loaded when it is running low on disk space.");
     Log.info({ indent, logLevel }, "Try increasing the disk size of your Lambda function.");
   }
+  if (err.message.includes("Invalid value specified for cpu")) {
+    Log.info({ indent, logLevel });
+    Log.info({ indent, logLevel }, "\uD83D\uDCA1 This error indicates that your GCP account does have a limit. Try setting `--maxInstances=5` / `maxInstances: 5` when deploying this service.");
+    Log.info({
+      indent,
+      logLevel
+    });
+  }
 };
 
 // src/wrap-with-error-handling.ts
@@ -17311,332 +16552,810 @@ var resolveConcurrency = (userPreference) => {
   } else {
     rounded = Math.floor(userPreference);
   }
-  if (rounded > maxCpus) {
-    throw new Error(`Maximum for --concurrency is ${maxCpus} (number of cores on this system)`);
+  if (rounded > maxCpus) {
+    throw new Error(`Maximum for --concurrency is ${maxCpus} (number of cores on this system)`);
+  }
+  if (rounded < min) {
+    throw new Error(`Minimum for concurrency is ${min}.`);
+  }
+  return rounded;
+};
+
+// src/get-duration-from-frame-range.ts
+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];
+  }).filter((index) => {
+    return index % everyNthFrame === 0;
+  });
+};
+
+// src/get-extension-from-codec.ts
+var getFileExtensionFromCodec = (codec, audioCodec) => {
+  if (!validCodecs.includes(codec)) {
+    throw new Error(`Codec must be one of the following: ${validCodecs.join(", ")}, but got ${codec}`);
+  }
+  const map2 = defaultFileExtensionMap[codec];
+  if (audioCodec === null) {
+    return map2.default;
+  }
+  const typedAudioCodec = audioCodec;
+  if (!(typedAudioCodec in map2.forAudioCodec)) {
+    throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
+  }
+  return map2.forAudioCodec[audioCodec].default;
+};
+var makeFileExtensionMap = () => {
+  const map2 = {};
+  Object.keys(defaultFileExtensionMap).forEach((_codec) => {
+    const codec = _codec;
+    const fileExtMap = defaultFileExtensionMap[codec];
+    const audioCodecs = Object.keys(fileExtMap.forAudioCodec);
+    const possibleExtensionsForAudioCodec = audioCodecs.map((audioCodec) => fileExtMap.forAudioCodec[audioCodec].possible);
+    const allPossibleExtensions = [
+      fileExtMap.default,
+      ...possibleExtensionsForAudioCodec.flat(1)
+    ];
+    for (const extension of allPossibleExtensions) {
+      if (!map2[extension]) {
+        map2[extension] = [];
+      }
+      if (!map2[extension].includes(codec)) {
+        map2[extension].push(codec);
+      }
+    }
+  });
+  return map2;
+};
+var defaultCodecsForFileExtension = {
+  "3gp": "aac",
+  aac: "aac",
+  gif: "gif",
+  hevc: "h265",
+  m4a: "aac",
+  m4b: "aac",
+  mkv: "h264-mkv",
+  mov: "prores",
+  mp3: "mp3",
+  mp4: "h264",
+  mpeg: "aac",
+  mpg: "aac",
+  mxf: "prores",
+  wav: "wav",
+  webm: "vp8",
+  ts: "h264-ts"
+};
+
+// src/path-normalize.ts
+var SLASH = 47;
+var DOT = 46;
+var assertPath = (path19) => {
+  const t = typeof path19;
+  if (t !== "string") {
+    throw new TypeError(`Expected a string, got a ${t}`);
+  }
+};
+var posixNormalize = (path19, allowAboveRoot) => {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  for (let i = 0;i <= path19.length; ++i) {
+    if (i < path19.length) {
+      code = path19.charCodeAt(i);
+    } else if (code === SLASH) {
+      break;
+    } else {
+      code = SLASH;
+    }
+    if (code === SLASH) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = "";
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += "/..";
+          } else {
+            res = "..";
+          }
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += "/" + path19.slice(lastSlash + 1, i);
+        } else {
+          res = path19.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+};
+var decode = (s) => {
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s;
+  }
+};
+var pathNormalize = (p) => {
+  assertPath(p);
+  let path19 = p;
+  if (path19.length === 0) {
+    return ".";
+  }
+  const isAbsolute = path19.charCodeAt(0) === SLASH;
+  const trailingSeparator = path19.charCodeAt(path19.length - 1) === SLASH;
+  path19 = decode(path19);
+  path19 = posixNormalize(path19, !isAbsolute);
+  if (path19.length === 0 && !isAbsolute) {
+    path19 = ".";
+  }
+  if (path19.length > 0 && trailingSeparator) {
+    path19 += "/";
+  }
+  if (isAbsolute) {
+    return "/" + path19;
+  }
+  return path19;
+};
+
+// src/get-extension-of-filename.ts
+var getExtensionOfFilename = (filename) => {
+  if (filename === null) {
+    return null;
+  }
+  const filenameArr = pathNormalize(filename).split(".");
+  const hasExtension = filenameArr.length >= 2;
+  const filenameArrLength = filenameArr.length;
+  const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
+  return extension;
+};
+
+// src/get-frame-to-render.ts
+var getRealFrameRange = (durationInFrames, frameRange) => {
+  if (frameRange === null) {
+    return [0, durationInFrames - 1];
+  }
+  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}`);
+    }
+    return [frameRange, frameRange];
+  }
+  if (frameRange[1] >= durationInFrames || frameRange[0] < 0) {
+    throw new Error(`The "durationInFrames" of the <Composition /> was evaluated to be ${durationInFrames}, but frame range ${frameRange.join("-")} is not inbetween 0-${durationInFrames - 1}`);
+  }
+  return frameRange;
+};
+
+// src/image-format.ts
+var validVideoImageFormats = ["png", "jpeg", "none"];
+var validStillImageFormats = ["png", "jpeg", "pdf", "webp"];
+var DEFAULT_VIDEO_IMAGE_FORMAT = "jpeg";
+var DEFAULT_STILL_IMAGE_FORMAT = "png";
+var validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, videoImageFormat) => {
+  if (videoImageFormat === "none") {
+    return "none";
+  }
+  if (typeof pixelFormat === "undefined") {
+    return "valid";
+  }
+  if (!validVideoImageFormats.includes(videoImageFormat)) {
+    throw new TypeError(`Value ${videoImageFormat} is not valid as an image format.`);
+  }
+  if (pixelFormat !== "yuva420p" && pixelFormat !== "yuva444p10le") {
+    return "valid";
+  }
+  if (videoImageFormat !== "png") {
+    throw new TypeError(`Pixel format was set to '${pixelFormat}' but the image format is not PNG. To render transparent videos, you need to set PNG as the image format.`);
+  }
+  return "valid";
+};
+var validateStillImageFormat = (imageFormat) => {
+  if (!validStillImageFormats.includes(imageFormat)) {
+    throw new TypeError(String(`Image format should be one of: ${validStillImageFormats.map((v) => `"${v}"`).join(", ")}`));
+  }
+};
+
+// src/jpeg-quality.ts
+var DEFAULT_JPEG_QUALITY = 80;
+var validateJpegQuality = (q) => {
+  if (typeof q !== "undefined" && typeof q !== "number") {
+    throw new Error(`JPEG Quality option must be a number or undefined. Got ${typeof q} (${JSON.stringify(q)})`);
+  }
+  if (typeof q === "undefined") {
+    return;
+  }
+  if (!Number.isFinite(q)) {
+    throw new RangeError(`JPEG Quality must be a finite number, but is ${q}`);
+  }
+  if (Number.isNaN(q)) {
+    throw new RangeError(`JPEG Quality is NaN, but must be a real number`);
+  }
+  if (q > 100 || q < 0) {
+    throw new RangeError("JPEG Quality option must be between 0 and 100.");
+  }
+};
+
+// src/perf.ts
+var exports_perf = {};
+__export(exports_perf, {
+  stopPerfMeasure: () => stopPerfMeasure,
+  startPerfMeasure: () => startPerfMeasure,
+  getPerf: () => getPerf
+});
+var perf = {
+  "activate-target": [],
+  capture: [],
+  save: [],
+  "extract-frame": [],
+  piping: []
+};
+var map2 = {};
+var startPerfMeasure = (marker) => {
+  const id = Math.random();
+  map2[id] = {
+    id,
+    marker,
+    start: Date.now()
+  };
+  return id;
+};
+var stopPerfMeasure = (id) => {
+  const now = Date.now();
+  const diff = now - map2[id].start;
+  perf[map2[id].marker].push(diff);
+  delete map2[id];
+};
+var getPerf = () => {
+  return [
+    "Render performance:",
+    ...Object.keys(perf).filter((p) => perf[p].length).map((p) => {
+      return `  ${p} => ${Math.round(perf[p].reduce((a, b) => a + b, 0) / perf[p].length)}ms (n = ${perf[p].length})`;
+    })
+  ];
+};
+
+// src/pixel-format.ts
+var validPixelFormats = [
+  "yuv420p",
+  "yuva420p",
+  "yuv422p",
+  "yuv444p",
+  "yuv420p10le",
+  "yuv422p10le",
+  "yuv444p10le",
+  "yuva444p10le"
+];
+var DEFAULT_PIXEL_FORMAT = "yuv420p";
+var validPixelFormatsForCodec = (codec) => {
+  if (codec === "vp8" || codec === "vp9") {
+    return validPixelFormats;
+  }
+  return validPixelFormats.filter((format) => format !== "yuva420p");
+};
+var validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
+  if (typeof pixelFormat === "undefined") {
+    return pixelFormat;
+  }
+  if (!validPixelFormats.includes(pixelFormat)) {
+    throw new TypeError(`Value ${pixelFormat} is not valid as a pixel format.`);
+  }
+  if (pixelFormat !== "yuva420p") {
+    return;
   }
-  if (rounded < min) {
-    throw new Error(`Minimum for concurrency is ${min}.`);
+  const validFormats = validPixelFormatsForCodec(codec);
+  if (!validFormats.includes(pixelFormat)) {
+    throw new TypeError(`Pixel format was set to 'yuva420p' but codec ${codec} does not support it. Valid pixel formats for codec ${codec} are: ${validFormats.join(", ")}.`);
   }
-  return rounded;
 };
 
-// src/get-duration-from-frame-range.ts
-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];
-  }).filter((index) => {
-    return index % everyNthFrame === 0;
-  });
-};
+// src/render-frames.ts
+import fs14 from "node:fs";
+import path20 from "node:path";
+import { NoReactInternals as NoReactInternals12 } from "remotion/no-react";
 
-// src/path-normalize.ts
-var SLASH = 47;
-var DOT = 46;
-var assertPath = (path19) => {
-  const t = typeof path19;
-  if (t !== "string") {
-    throw new TypeError(`Expected a string, got a ${t}`);
+// src/cycle-browser-tabs.ts
+var cycleBrowserTabs = ({
+  puppeteerInstance,
+  concurrency,
+  logLevel,
+  indent
+}) => {
+  if (concurrency <= 1) {
+    return {
+      stopCycling: () => {
+        return;
+      }
+    };
   }
-};
-var posixNormalize = (path19, allowAboveRoot) => {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let code;
-  for (let i = 0;i <= path19.length; ++i) {
-    if (i < path19.length) {
-      code = path19.charCodeAt(i);
-    } else if (code === SLASH) {
-      break;
-    } else {
-      code = SLASH;
-    }
-    if (code === SLASH) {
-      if (lastSlash === i - 1 || dots === 1) {
-      } else if (lastSlash !== i - 1 && dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex !== res.length - 1) {
-              if (lastSlashIndex === -1) {
-                res = "";
-                lastSegmentLength = 0;
-              } else {
-                res = res.slice(0, lastSlashIndex);
-                lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-              }
-              lastSlash = i;
-              dots = 0;
-              continue;
-            }
-          } else if (res.length === 2 || res.length === 1) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = i;
-            dots = 0;
-            continue;
-          }
+  let interval = null;
+  let i = 0;
+  let stopped = false;
+  const set = () => {
+    interval = setTimeout(() => {
+      puppeteerInstance.getBrowser().pages().then((pages) => {
+        if (pages.length === 0) {
+          return;
         }
-        if (allowAboveRoot) {
-          if (res.length > 0) {
-            res += "/..";
-          } else {
-            res = "..";
-          }
-          lastSegmentLength = 2;
+        const currentPage = pages[i % pages.length];
+        i++;
+        if (!currentPage?.closed && !stopped && currentPage?.url() !== "about:blank") {
+          return currentPage.bringToFront();
         }
-      } else {
-        if (res.length > 0) {
-          res += "/" + path19.slice(lastSlash + 1, i);
-        } else {
-          res = path19.slice(lastSlash + 1, i);
+      }).catch((err) => Log.error({ indent, logLevel }, err)).finally(() => {
+        if (!stopped) {
+          set();
         }
-        lastSegmentLength = i - lastSlash - 1;
+      });
+    }, 200);
+  };
+  set();
+  return {
+    stopCycling: () => {
+      if (!interval) {
+        return;
       }
-      lastSlash = i;
-      dots = 0;
-    } else if (code === DOT && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
+      stopped = true;
+      return clearTimeout(interval);
     }
-  }
-  return res;
+  };
 };
-var decode = (s) => {
-  try {
-    return decodeURIComponent(s);
-  } catch {
-    return s;
-  }
+
+// src/combine-audio.ts
+import { rmSync as rmSync2, writeFileSync } from "fs";
+import { join as join3 } from "path";
+import { VERSION as VERSION3 } from "remotion/version";
+
+// src/options/separate-audio.tsx
+var DEFAULT = null;
+var cliFlag = "separate-audio-to";
+var separateAudioOption = {
+  cliFlag,
+  description: () => `If set, the audio will not be included in the main output but rendered as a separate file at the location you pass. It is recommended to use an absolute path. If a relative path is passed, it is relative to the Remotion Root.`,
+  docLink: "https://remotion.dev/docs/renderer/render-media",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag]) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag]
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT
+    };
+  },
+  name: "Separate audio to",
+  setConfig: () => {
+    throw new Error("Not implemented");
+  },
+  ssrName: "separateAudioTo",
+  type: "string"
 };
-var pathNormalize = (p) => {
-  assertPath(p);
-  let path19 = p;
-  if (path19.length === 0) {
-    return ".";
+
+// src/options/audio-codec.tsx
+var validAudioCodecs = ["pcm-16", "aac", "mp3", "opus"];
+var supportedAudioCodecs = {
+  h264: ["aac", "pcm-16", "mp3"],
+  "h264-mkv": ["pcm-16", "mp3"],
+  "h264-ts": ["pcm-16", "aac"],
+  aac: ["aac", "pcm-16"],
+  avi: [],
+  gif: [],
+  h265: ["aac", "pcm-16"],
+  mp3: ["mp3", "pcm-16"],
+  prores: ["aac", "pcm-16"],
+  vp8: ["opus", "pcm-16"],
+  vp9: ["opus", "pcm-16"],
+  wav: ["pcm-16"]
+};
+var _satisfies = supportedAudioCodecs;
+if (_satisfies) {
+}
+var mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+  if (audioCodec === "aac") {
+    return "libfdk_aac";
   }
-  const isAbsolute = path19.charCodeAt(0) === SLASH;
-  const trailingSeparator = path19.charCodeAt(path19.length - 1) === SLASH;
-  path19 = decode(path19);
-  path19 = posixNormalize(path19, !isAbsolute);
-  if (path19.length === 0 && !isAbsolute) {
-    path19 = ".";
+  if (audioCodec === "mp3") {
+    return "libmp3lame";
   }
-  if (path19.length > 0 && trailingSeparator) {
-    path19 += "/";
+  if (audioCodec === "opus") {
+    return "libopus";
   }
-  if (isAbsolute) {
-    return "/" + path19;
+  if (audioCodec === "pcm-16") {
+    return "pcm_s16le";
+  }
+  throw new Error("unknown audio codec: " + audioCodec);
+};
+var cliFlag2 = "audio-codec";
+var ssrName = "audioCodec";
+var defaultAudioCodecs = {
+  "h264-mkv": {
+    lossless: "pcm-16",
+    compressed: "pcm-16"
+  },
+  "h264-ts": {
+    lossless: "pcm-16",
+    compressed: "aac"
+  },
+  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"
   }
-  return path19;
 };
-
-// src/get-extension-of-filename.ts
-var getExtensionOfFilename = (filename) => {
-  if (filename === null) {
-    return null;
-  }
-  const filenameArr = pathNormalize(filename).split(".");
-  const hasExtension = filenameArr.length >= 2;
-  const filenameArrLength = filenameArr.length;
-  const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
-  return extension;
+var extensionMap = {
+  aac: "aac",
+  mp3: "mp3",
+  opus: "opus",
+  "pcm-16": "wav"
 };
-
-// src/get-frame-to-render.ts
-var getRealFrameRange = (durationInFrames, frameRange) => {
-  if (frameRange === null) {
-    return [0, durationInFrames - 1];
-  }
-  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}`);
-    }
-    return [frameRange, frameRange];
-  }
-  if (frameRange[1] >= durationInFrames || frameRange[0] < 0) {
-    throw new Error(`The "durationInFrames" of the <Composition /> was evaluated to be ${durationInFrames}, but frame range ${frameRange.join("-")} is not inbetween 0-${durationInFrames - 1}`);
+var getExtensionFromAudioCodec = (audioCodec) => {
+  if (extensionMap[audioCodec]) {
+    return extensionMap[audioCodec];
   }
-  return frameRange;
+  throw new Error(`Unsupported audio codec: ${audioCodec}`);
 };
-
-// src/image-format.ts
-var validVideoImageFormats = ["png", "jpeg", "none"];
-var validStillImageFormats = ["png", "jpeg", "pdf", "webp"];
-var DEFAULT_VIDEO_IMAGE_FORMAT = "jpeg";
-var DEFAULT_STILL_IMAGE_FORMAT = "png";
-var validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, videoImageFormat) => {
-  if (videoImageFormat === "none") {
-    return "none";
-  }
-  if (typeof pixelFormat === "undefined") {
-    return "valid";
+var resolveAudioCodec = ({
+  codec,
+  setting,
+  preferLossless,
+  separateAudioTo
+}) => {
+  let derivedFromSeparateAudioToExtension = null;
+  if (separateAudioTo) {
+    const extension = separateAudioTo.split(".").pop();
+    for (const [key, value] of Object.entries(extensionMap)) {
+      if (value === extension) {
+        derivedFromSeparateAudioToExtension = key;
+        if (!supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) && derivedFromSeparateAudioToExtension) {
+          throw new Error(`The codec is ${codec} but the audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${supportedAudioCodecs[codec].join(", ")}`);
+        }
+      }
+    }
   }
-  if (!validVideoImageFormats.includes(videoImageFormat)) {
-    throw new TypeError(`Value ${videoImageFormat} is not valid as an image format.`);
+  if (preferLossless) {
+    const selected = getDefaultAudioCodec({ codec, preferLossless });
+    if (derivedFromSeparateAudioToExtension && selected !== derivedFromSeparateAudioToExtension) {
+      throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from the "Prefer lossless" option (${selected}). Remove any conflicting options.`);
+    }
+    return selected;
   }
-  if (pixelFormat !== "yuva420p" && pixelFormat !== "yuva444p10le") {
-    return "valid";
+  if (setting === null) {
+    if (derivedFromSeparateAudioToExtension) {
+      return derivedFromSeparateAudioToExtension;
+    }
+    return getDefaultAudioCodec({ codec, preferLossless });
   }
-  if (videoImageFormat !== "png") {
-    throw new TypeError(`Pixel format was set to '${pixelFormat}' but the image format is not PNG. To render transparent videos, you need to set PNG as the image format.`);
+  if (derivedFromSeparateAudioToExtension !== setting && derivedFromSeparateAudioToExtension) {
+    throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
   }
-  return "valid";
+  return setting;
 };
-var validateStillImageFormat = (imageFormat) => {
-  if (!validStillImageFormats.includes(imageFormat)) {
-    throw new TypeError(String(`Image format should be one of: ${validStillImageFormats.map((v) => `"${v}"`).join(", ")}`));
-  }
+var getDefaultAudioCodec = ({
+  codec,
+  preferLossless
+}) => {
+  return defaultAudioCodecs[codec][preferLossless ? "lossless" : "compressed"];
+};
+var _audioCodec = null;
+var audioCodecOption = {
+  cliFlag: cliFlag2,
+  setConfig: (audioCodec) => {
+    if (audioCodec === null) {
+      _audioCodec = null;
+      return;
+    }
+    if (!validAudioCodecs.includes(audioCodec)) {
+      throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${audioCodec}`);
+    }
+    _audioCodec = audioCodec;
+  },
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag2]) {
+      const codec = commandLine[cliFlag2];
+      if (!validAudioCodecs.includes(commandLine[cliFlag2])) {
+        throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${codec}`);
+      }
+      return {
+        source: "cli",
+        value: commandLine[cliFlag2]
+      };
+    }
+    if (_audioCodec !== null) {
+      return {
+        source: "config",
+        value: _audioCodec
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  description: () => `Set the format of the audio that is embedded in the video. Not all codec and audio codec combinations are supported and certain combinations require a certain file extension and container format. See the table in the docs to see possible combinations.`,
+  docLink: "https://www.remotion.dev/docs/encoding/#audio-codec",
+  name: "Audio Codec",
+  ssrName,
+  type: "aac"
 };
 
-// src/jpeg-quality.ts
-var DEFAULT_JPEG_QUALITY = 80;
-var validateJpegQuality = (q) => {
-  if (typeof q !== "undefined" && typeof q !== "number") {
-    throw new Error(`JPEG Quality option must be a number or undefined. Got ${typeof q} (${JSON.stringify(q)})`);
-  }
-  if (typeof q === "undefined") {
-    return;
-  }
-  if (!Number.isFinite(q)) {
-    throw new RangeError(`JPEG Quality must be a finite number, but is ${q}`);
-  }
-  if (Number.isNaN(q)) {
-    throw new RangeError(`JPEG Quality is NaN, but must be a real number`);
+// src/parse-ffmpeg-progress.ts
+var parseFfmpegProgress = (input, fps) => {
+  const match = input.match(/frame=(\s+)?([0-9]+)\s/);
+  if (match) {
+    return Number(match[2]);
   }
-  if (q > 100 || q < 0) {
-    throw new RangeError("JPEG Quality option must be between 0 and 100.");
+  const match2 = input.match(/time=(\d+):(\d+):(\d+).(\d+)\s/);
+  if (match2) {
+    const [, hours, minutes, seconds, hundreds] = match2;
+    return Number(hundreds) / 100 * fps + Number(seconds) * fps + Number(minutes) * fps * 60 + Number(hours) * fps * 60 * 60;
   }
 };
 
-// src/perf.ts
-var exports_perf = {};
-__export(exports_perf, {
-  stopPerfMeasure: () => stopPerfMeasure,
-  startPerfMeasure: () => startPerfMeasure,
-  getPerf: () => getPerf
-});
-var perf = {
-  "activate-target": [],
-  capture: [],
-  save: [],
-  "extract-frame": [],
-  piping: []
-};
-var map2 = {};
-var startPerfMeasure = (marker) => {
-  const id = Math.random();
-  map2[id] = {
-    id,
-    marker,
-    start: Date.now()
-  };
-  return id;
-};
-var stopPerfMeasure = (id) => {
-  const now = Date.now();
-  const diff = now - map2[id].start;
-  perf[map2[id].marker].push(diff);
-  delete map2[id];
-};
-var getPerf = () => {
-  return [
-    "Render performance:",
-    ...Object.keys(perf).filter((p) => perf[p].length).map((p) => {
-      return `  ${p} => ${Math.round(perf[p].reduce((a, b) => a + b, 0) / perf[p].length)}ms (n = ${perf[p].length})`;
-    })
-  ];
-};
+// src/sample-rate.ts
+var DEFAULT_SAMPLE_RATE = 48000;
 
-// src/pixel-format.ts
-var validPixelFormats = [
-  "yuv420p",
-  "yuva420p",
-  "yuv422p",
-  "yuv444p",
-  "yuv420p10le",
-  "yuv422p10le",
-  "yuv444p10le",
-  "yuva444p10le"
-];
-var DEFAULT_PIXEL_FORMAT = "yuv420p";
-var validPixelFormatsForCodec = (codec) => {
-  if (codec === "vp8" || codec === "vp9") {
-    return validPixelFormats;
+// src/combine-audio.ts
+var durationOf1Frame = 1024 / DEFAULT_SAMPLE_RATE * 1e6;
+var getClosestAlignedTime = (targetTime) => {
+  const decimalFramesToTargetTime = targetTime * 1e6 / durationOf1Frame;
+  const nearestFrameIndexForTargetTime = Math.round(decimalFramesToTargetTime);
+  return nearestFrameIndexForTargetTime * durationOf1Frame / 1e6;
+};
+var encodeAudio = async ({
+  files,
+  resolvedAudioCodec,
+  audioBitrate,
+  filelistDir,
+  output,
+  indent,
+  logLevel,
+  addRemotionMetadata,
+  fps,
+  binariesDirectory,
+  cancelSignal,
+  onProgress
+}) => {
+  const fileList = files.map((p) => `file '${p}'`).join(`
+`);
+  const fileListTxt = join3(filelistDir, "audio-files.txt");
+  writeFileSync(fileListTxt, fileList);
+  const startCombining = Date.now();
+  const command = [
+    "-hide_banner",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    fileListTxt,
+    "-c:a",
+    mapAudioCodecToFfmpegAudioCodecName(resolvedAudioCodec),
+    resolvedAudioCodec === "aac" ? "-cutoff" : null,
+    resolvedAudioCodec === "aac" ? "18000" : null,
+    "-b:a",
+    audioBitrate ? audioBitrate : "320k",
+    "-vn",
+    addRemotionMetadata ? `-metadata` : null,
+    addRemotionMetadata ? `comment=Made with Remotion ${VERSION3}` : null,
+    "-y",
+    output
+  ];
+  Log.verbose({ indent, logLevel }, `Combining audio with re-encoding, command: ${command.join(" ")}`);
+  try {
+    const task = callFf({
+      args: command,
+      bin: "ffmpeg",
+      indent,
+      logLevel,
+      binariesDirectory,
+      cancelSignal
+    });
+    task.stderr?.on("data", (data) => {
+      const utf8 = data.toString("utf8");
+      const parsed = parseFfmpegProgress(utf8, fps);
+      if (parsed === undefined) {
+        Log.verbose({ indent, logLevel }, utf8);
+      } else {
+        onProgress(parsed);
+        Log.verbose({ indent, logLevel }, `Encoded ${parsed} audio frames`);
+      }
+    });
+    await task;
+    Log.verbose({ indent, logLevel }, `Encoded audio in ${Date.now() - startCombining}ms`);
+    return output;
+  } catch (e) {
+    rmSync2(fileListTxt, { recursive: true });
+    throw e;
   }
-  return validPixelFormats.filter((format) => format !== "yuva420p");
 };
-var validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
-  if (typeof pixelFormat === "undefined") {
-    return pixelFormat;
-  }
-  if (!validPixelFormats.includes(pixelFormat)) {
-    throw new TypeError(`Value ${pixelFormat} is not valid as a pixel format.`);
-  }
-  if (pixelFormat !== "yuva420p") {
-    return;
-  }
-  const validFormats = validPixelFormatsForCodec(codec);
-  if (!validFormats.includes(pixelFormat)) {
-    throw new TypeError(`Pixel format was set to 'yuva420p' but codec ${codec} does not support it. Valid pixel formats for codec ${codec} are: ${validFormats.join(", ")}.`);
+var combineAudioSeamlessly = async ({
+  files,
+  filelistDir,
+  indent,
+  logLevel,
+  output,
+  chunkDurationInSeconds,
+  addRemotionMetadata,
+  fps,
+  binariesDirectory,
+  cancelSignal,
+  onProgress
+}) => {
+  const startConcatenating = Date.now();
+  const fileList = files.map((p, i) => {
+    const isLast = i === files.length - 1;
+    const targetStart = i * chunkDurationInSeconds;
+    const endStart = (i + 1) * chunkDurationInSeconds;
+    const startTime = getClosestAlignedTime(targetStart) * 1e6;
+    const endTime = getClosestAlignedTime(endStart) * 1e6;
+    const realDuration = endTime - startTime;
+    let inpoint = 0;
+    if (i > 0) {
+      inpoint = durationOf1Frame * 4;
+    }
+    const outpoint = (i === 0 ? durationOf1Frame * 2 : inpoint) + realDuration - (isLast ? 0 : durationOf1Frame);
+    return [`file '${p}'`, `inpoint ${inpoint}us`, `outpoint ${outpoint}us`].filter(truthy).join(`
+`);
+  }).join(`
+`);
+  const fileListTxt = join3(filelistDir, "audio-files.txt");
+  writeFileSync(fileListTxt, fileList);
+  const command = [
+    "-hide_banner",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    fileListTxt,
+    "-c:a",
+    "copy",
+    "-vn",
+    addRemotionMetadata ? `-metadata` : null,
+    addRemotionMetadata ? `comment=Made with Remotion ${VERSION3}` : null,
+    "-y",
+    output
+  ];
+  Log.verbose({ indent, logLevel }, `Combining AAC audio seamlessly, command: ${command.join(" ")}`);
+  try {
+    const task = callFf({
+      args: command,
+      bin: "ffmpeg",
+      indent,
+      logLevel,
+      binariesDirectory,
+      cancelSignal
+    });
+    task.stderr?.on("data", (data) => {
+      const utf8 = data.toString("utf8");
+      const parsed = parseFfmpegProgress(utf8, fps);
+      if (parsed !== undefined) {
+        onProgress(parsed);
+        Log.verbose({ indent, logLevel }, `Encoded ${parsed} audio frames`);
+      }
+    });
+    await task;
+    Log.verbose({ indent, logLevel }, `Combined audio seamlessly in ${Date.now() - startConcatenating}ms`);
+    return output;
+  } catch (e) {
+    rmSync2(fileListTxt, { recursive: true });
+    Log.error({ indent, logLevel }, e);
+    throw e;
   }
 };
-
-// src/render-frames.ts
-import fs14 from "node:fs";
-import path20 from "node:path";
-import { NoReactInternals as NoReactInternals12 } from "remotion/no-react";
-
-// src/cycle-browser-tabs.ts
-var cycleBrowserTabs = ({
-  puppeteerInstance,
-  concurrency,
+var createCombinedAudio = ({
+  seamless,
+  filelistDir,
+  files,
+  indent,
   logLevel,
-  indent
+  audioBitrate,
+  resolvedAudioCodec,
+  output,
+  chunkDurationInSeconds,
+  addRemotionMetadata,
+  binariesDirectory,
+  fps,
+  cancelSignal,
+  onProgress
 }) => {
-  if (concurrency <= 1) {
-    return {
-      stopCycling: () => {
-        return;
-      }
-    };
+  if (seamless) {
+    return combineAudioSeamlessly({
+      filelistDir,
+      files,
+      indent,
+      logLevel,
+      output,
+      chunkDurationInSeconds,
+      addRemotionMetadata,
+      binariesDirectory,
+      fps,
+      cancelSignal,
+      onProgress
+    });
   }
-  let interval = null;
-  let i = 0;
-  let stopped = false;
-  const set = () => {
-    interval = setTimeout(() => {
-      puppeteerInstance.getBrowser().pages().then((pages) => {
-        if (pages.length === 0) {
-          return;
-        }
-        const currentPage = pages[i % pages.length];
-        i++;
-        if (!currentPage?.closed && !stopped && currentPage?.url() !== "about:blank") {
-          return currentPage.bringToFront();
-        }
-      }).catch((err) => Log.error({ indent, logLevel }, err)).finally(() => {
-        if (!stopped) {
-          set();
-        }
-      });
-    }, 200);
-  };
-  set();
-  return {
-    stopCycling: () => {
-      if (!interval) {
-        return;
-      }
-      stopped = true;
-      return clearTimeout(interval);
-    }
-  };
+  return encodeAudio({
+    filelistDir,
+    files,
+    resolvedAudioCodec,
+    audioBitrate,
+    output,
+    indent,
+    logLevel,
+    addRemotionMetadata,
+    binariesDirectory,
+    fps,
+    cancelSignal,
+    onProgress
+  });
 };
 
 // src/get-extra-frames-to-capture.ts
@@ -19604,14 +19323,20 @@ var validateEvenDimensionsWithCodec = ({
   indent,
   logLevel
 }) => {
+  let actualWidth = width * scale;
+  let actualHeight = height * scale;
   if (wantsImageSequence) {
-    return;
+    return {
+      actualWidth,
+      actualHeight
+    };
   }
   if (codec !== "h264-mkv" && codec !== "h264" && codec !== "h265" && codec !== "h264-ts") {
-    return;
+    return {
+      actualWidth,
+      actualHeight
+    };
   }
-  let actualWidth = width * scale;
-  let actualHeight = height * scale;
   if (actualWidth % 1 !== 0 && (actualWidth % 1 < 0.005 || actualWidth % 1 > 0.005)) {
     Log.verbose({ indent, logLevel }, `Rounding width to an even number from ${actualWidth} to ${Math.round(actualWidth)}`);
     actualWidth = Math.round(actualWidth);
@@ -19637,6 +19362,10 @@ var validateEvenDimensionsWithCodec = ({
     ].join(" ");
     throw new Error(message);
   }
+  return {
+    actualWidth,
+    actualHeight
+  };
 };
 
 // src/prespawn-ffmpeg.ts
@@ -19783,9 +19512,20 @@ var validateSelectedCodecAndProResCombination = ({
 };
 
 // src/stitch-frames-to-video.ts
-import { cpSync as cpSync2, promises as promises3, rmSync as rmSync5 } from "node:fs";
+import { cpSync as cpSync2, promises as promises3, rmSync as rmSync3 } from "node:fs";
 import path24 from "node:path";
 
+// src/convert-number-of-gif-loops-to-ffmpeg.ts
+var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
+  if (loops === null) {
+    return "0";
+  }
+  if (loops === 0) {
+    return "-1";
+  }
+  return String(loops);
+};
+
 // src/create-audio.ts
 import path23 from "path";
 
@@ -19880,7 +19620,6 @@ var calculateAssetPositions = (frames) => {
           trimLeft: asset.mediaFrame,
           volume: [],
           playbackRate: asset.playbackRate,
-          allowAmplificationDuringRender: asset.allowAmplificationDuringRender,
           toneFrequency: asset.toneFrequency,
           audioStartFrame: asset.audioStartFrame
         });
@@ -20282,28 +20021,25 @@ var ffmpegBuildVolumeExpression = ({
 var ffmpegVolumeExpression = ({
   volume,
   fps,
-  trimLeft,
-  allowAmplificationDuringRender
+  trimLeft
 }) => {
-  const maxVolume = allowAmplificationDuringRender ? Infinity : 1;
   if (typeof volume === "number") {
     return {
       eval: "once",
-      value: String(Math.min(maxVolume, volume))
+      value: String(volume)
     };
   }
   if ([...new Set(volume)].length === 1) {
     return ffmpegVolumeExpression({
       volume: volume[0],
       fps,
-      trimLeft,
-      allowAmplificationDuringRender
+      trimLeft
     });
   }
   const paddedVolume = [...volume, volume[volume.length - 1]];
   const volumeMap = {};
   paddedVolume.forEach((baseVolume, frame) => {
-    const actualVolume = roundVolumeToAvoidStackOverflow(Math.min(maxVolume, baseVolume));
+    const actualVolume = roundVolumeToAvoidStackOverflow(baseVolume);
     if (!volumeMap[actualVolume]) {
       volumeMap[actualVolume] = [];
     }
@@ -20445,8 +20181,7 @@ var stringifyFfmpegFilter = ({
   const volumeFilter = ffmpegVolumeExpression({
     volume,
     fps,
-    trimLeft: actualTrimLeft,
-    allowAmplificationDuringRender: asset.allowAmplificationDuringRender
+    trimLeft: actualTrimLeft
   });
   const padAtEnd = chunkLengthInSeconds - audibleDuration - startInVideoSeconds;
   const padStart = startInVideoSeconds + presentationTimeOffsetInSeconds;
@@ -20649,6 +20384,25 @@ var createAudio = async ({
   return outName;
 };
 
+// src/make-metadata-args.ts
+import { VERSION as VERSION4 } from "remotion/version";
+var makeMetadataArgs = (metadata) => {
+  const defaultComment = `Made with Remotion ${VERSION4}`;
+  const newMetadata = {
+    comment: defaultComment
+  };
+  Object.keys(metadata).forEach((key) => {
+    const lowercaseKey = key.toLowerCase();
+    if (lowercaseKey === "comment") {
+      newMetadata[lowercaseKey] = `${defaultComment}; ${metadata[key]}`;
+    } else {
+      newMetadata[lowercaseKey] = metadata[key];
+    }
+  });
+  const metadataArgs = Object.entries(newMetadata).map(([key, value]) => ["-metadata", `${key}=${value}`]);
+  return metadataArgs.flat(1);
+};
+
 // src/render-has-audio.ts
 var getShouldRenderAudio = ({
   codec,
@@ -20929,7 +20683,7 @@ var innerStitchFramesToVideo = async ({
     }
     const finalDestination = path24.resolve(remotionRoot, separateAudioTo);
     cpSync2(audio, finalDestination);
-    rmSync5(audio);
+    rmSync3(audio);
   }
   return new Promise((resolve2, reject) => {
     task.once("close", (code, signal) => {
@@ -21315,7 +21069,7 @@ var internalRenderMediaRaw = ({
   if (onCtrlCExit && workingDir) {
     onCtrlCExit(`Delete ${workingDir}`, () => deleteDirectory(workingDir));
   }
-  validateEvenDimensionsWithCodec({
+  const { actualWidth, actualHeight } = validateEvenDimensionsWithCodec({
     codec,
     height: composition.height,
     scale,
@@ -21351,8 +21105,8 @@ var internalRenderMediaRaw = ({
   const createPrestitcherIfNecessary = () => {
     if (preEncodedFileLocation) {
       preStitcher = prespawnFfmpeg({
-        width: composition.width * scale,
-        height: composition.height * scale,
+        width: actualWidth,
+        height: actualHeight,
         fps,
         outputLocation: preEncodedFileLocation,
         pixelFormat,
@@ -21511,8 +21265,8 @@ var internalRenderMediaRaw = ({
       }
       const stitchStart = Date.now();
       return internalStitchFramesToVideo({
-        width: composition.width * scale,
-        height: composition.height * scale,
+        width: actualWidth,
+        height: actualHeight,
         fps,
         outputLocation: absoluteOutputLocation,
         preEncodedFileLocation,
@@ -21668,7 +21422,8 @@ var renderMedia = ({
   metadata,
   hardwareAcceleration,
   chromeMode,
-  offthreadVideoThreads
+  offthreadVideoThreads,
+  compositionStart
 }) => {
   const indent = false;
   const logLevel = verbose || dumpBrowserLogs ? "verbose" : passedLogLevel ?? "info";
@@ -21749,7 +21504,7 @@ var renderMedia = ({
     }),
     onArtifact: onArtifact ?? null,
     metadata: metadata ?? null,
-    compositionStart: 0,
+    compositionStart: compositionStart ?? 0,
     hardwareAcceleration: hardwareAcceleration ?? "disable",
     chromeMode: chromeMode ?? "headless-shell"
   });
@@ -22388,6 +22143,312 @@ var getMaxConcurrency = () => {
   return getCpuCount();
 };
 var getMinConcurrency = () => 1;
+
+// src/combine-chunks.ts
+import { rmSync as rmSync5 } from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/can-concat-seamlessly.ts
+var canConcatAudioSeamlessly = (audioCodec, chunkDurationInFrames) => {
+  if (chunkDurationInFrames <= 4) {
+    return false;
+  }
+  return audioCodec === "aac";
+};
+var canConcatVideoSeamlessly = (codec) => {
+  return codec === "h264";
+};
+
+// src/combine-video-streams.ts
+import { rmSync as rmSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { VERSION as VERSION5 } from "remotion/version";
+var combineVideoStreams = async ({
+  fps,
+  codec,
+  filelistDir,
+  numberOfGifLoops,
+  output,
+  indent,
+  logLevel,
+  onProgress,
+  files,
+  addRemotionMetadata,
+  binariesDirectory,
+  cancelSignal
+}) => {
+  const fileList = files.map((p) => `file '${p}'`).join(`
+`);
+  const fileListTxt = join4(filelistDir, "video-files.txt");
+  writeFileSync2(fileListTxt, fileList);
+  const encoder = codec === "gif" ? "gif" : "copy";
+  const command = [
+    "-hide_banner",
+    "-r",
+    String(fps),
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    fileListTxt,
+    numberOfGifLoops === null ? null : "-loop",
+    numberOfGifLoops === null ? null : convertNumberOfGifLoopsToFfmpegSyntax(numberOfGifLoops),
+    codec === "gif" ? "-filter_complex" : null,
+    codec === "gif" ? "split[v],palettegen,[v]paletteuse" : null,
+    "-an",
+    "-c:v",
+    encoder,
+    codec === "h265" ? "-tag:v" : null,
+    codec === "h265" ? "hvc1" : null,
+    addRemotionMetadata ? `-metadata` : null,
+    addRemotionMetadata ? `comment=Made with Remotion ${VERSION5}` : null,
+    "-y",
+    output
+  ].filter(truthy);
+  const doesReencode = encoder !== "copy";
+  const startTime = Date.now();
+  Log.verbose({ indent, logLevel }, `Combining video ${doesReencode ? "with reencoding" : "without reencoding"}, command: ${command.join(" ")}`);
+  try {
+    const task = callFf({
+      args: command,
+      bin: "ffmpeg",
+      indent,
+      logLevel,
+      binariesDirectory,
+      cancelSignal
+    });
+    task.stderr?.on("data", (data) => {
+      const parsed = parseFfmpegProgress(data.toString("utf8"), fps);
+      if (parsed === undefined) {
+        Log.verbose({ indent, logLevel }, data.toString("utf8"));
+      } else {
+        Log.verbose({ indent, logLevel }, `Encoded ${parsed} video frames`);
+        onProgress(parsed);
+      }
+    });
+    await task;
+    Log.verbose({ indent, logLevel }, `Finished combining video in ${Date.now() - startTime}ms`);
+    return output;
+  } catch (e) {
+    rmSync4(fileListTxt, { recursive: true });
+    throw e;
+  }
+};
+
+// src/combine-video-streams-seamlessly.ts
+var combineVideoStreamsSeamlessly = ({ files }) => {
+  const fileList = `concat:${files.join("|")}`;
+  return fileList;
+};
+
+// src/mux-video-and-audio.ts
+var muxVideoAndAudio = async ({
+  videoOutput,
+  audioOutput,
+  output,
+  indent,
+  logLevel,
+  onProgress,
+  binariesDirectory,
+  fps,
+  cancelSignal,
+  addFaststart,
+  metadata
+}) => {
+  const startTime = Date.now();
+  Log.verbose({ indent, logLevel }, "Muxing video and audio together");
+  const command = [
+    "-hide_banner",
+    videoOutput ? "-i" : null,
+    videoOutput,
+    audioOutput ? "-i" : null,
+    audioOutput,
+    videoOutput ? "-c:v" : null,
+    videoOutput ? "copy" : null,
+    audioOutput ? "-c:a" : null,
+    audioOutput ? "copy" : null,
+    addFaststart ? "-movflags" : null,
+    addFaststart ? "faststart" : null,
+    ...makeMetadataArgs(metadata ?? {}),
+    "-y",
+    output
+  ].filter(truthy);
+  Log.verbose({ indent, logLevel }, "Combining command: ", command);
+  const task = callFf({
+    bin: "ffmpeg",
+    args: command,
+    indent,
+    logLevel,
+    binariesDirectory,
+    cancelSignal
+  });
+  task.stderr?.on("data", (data) => {
+    const utf8 = data.toString("utf8");
+    const parsed = parseFfmpegProgress(utf8, fps);
+    if (parsed === undefined) {
+      if (!utf8.includes("Estimating duration from bitrate, this may be inaccurate")) {
+        Log.verbose({ indent, logLevel }, utf8);
+      }
+    } else {
+      Log.verbose({ indent, logLevel }, `Combined ${parsed} frames`);
+      onProgress(parsed);
+    }
+  });
+  await task;
+  Log.verbose({ indent, logLevel }, `Muxing done in ${Date.now() - startTime}ms`);
+};
+
+// src/combine-chunks.ts
+var codecSupportsFastStart = {
+  "h264-mkv": false,
+  "h264-ts": false,
+  h264: true,
+  h265: true,
+  aac: false,
+  gif: false,
+  mp3: false,
+  prores: false,
+  vp8: false,
+  vp9: false,
+  wav: false
+};
+var REMOTION_FILELIST_TOKEN = "remotion-filelist";
+var internalCombineChunks = async ({
+  outputLocation: output,
+  onProgress,
+  codec,
+  fps,
+  numberOfGifLoops,
+  audioBitrate,
+  indent,
+  logLevel,
+  binariesDirectory,
+  cancelSignal,
+  metadata,
+  audioFiles,
+  videoFiles,
+  framesPerChunk,
+  audioCodec,
+  preferLossless,
+  everyNthFrame,
+  frameRange,
+  compositionDurationInFrames
+}) => {
+  const filelistDir = tmpDir(REMOTION_FILELIST_TOKEN);
+  const shouldCreateVideo = !isAudioCodec(codec);
+  const resolvedAudioCodec = resolveAudioCodec({
+    setting: audioCodec,
+    codec,
+    preferLossless,
+    separateAudioTo: null
+  });
+  const shouldCreateAudio = resolvedAudioCodec !== null && audioFiles.length > 0;
+  const seamlessVideo = canConcatVideoSeamlessly(codec);
+  const seamlessAudio = canConcatAudioSeamlessly(resolvedAudioCodec, framesPerChunk);
+  const realFrameRange = getRealFrameRange(compositionDurationInFrames, frameRange);
+  const numberOfFrames = getFramesToRender(realFrameRange, everyNthFrame).length;
+  const videoOutput = shouldCreateVideo ? join5(filelistDir, `video.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`) : null;
+  const audioOutput = shouldCreateAudio ? join5(filelistDir, `audio.${getExtensionFromAudioCodec(resolvedAudioCodec)}`) : null;
+  const chunkDurationInSeconds = framesPerChunk / fps;
+  let concatenatedAudio = 0;
+  let concatenatedVideo = 0;
+  let muxing = 0;
+  const updateProgress = () => {
+    const totalFrames = (shouldCreateAudio ? numberOfFrames : 0) + (shouldCreateVideo ? numberOfFrames : 0) + numberOfFrames;
+    const actualProgress = concatenatedAudio + concatenatedVideo + muxing;
+    onProgress({
+      frames: actualProgress / totalFrames * numberOfFrames,
+      totalProgress: actualProgress / totalFrames
+    });
+  };
+  Log.verbose({ indent, logLevel }, `Combining chunks, audio = ${shouldCreateAudio === false ? "no" : seamlessAudio ? "seamlessly" : "normally"}, video = ${shouldCreateVideo === false ? "no" : seamlessVideo ? "seamlessly" : "normally"}`);
+  await Promise.all([
+    shouldCreateAudio && audioOutput ? createCombinedAudio({
+      audioBitrate,
+      filelistDir,
+      files: audioFiles,
+      indent,
+      logLevel,
+      output: audioOutput,
+      resolvedAudioCodec,
+      seamless: seamlessAudio,
+      chunkDurationInSeconds,
+      addRemotionMetadata: !shouldCreateVideo,
+      binariesDirectory,
+      fps,
+      cancelSignal,
+      onProgress: (frames) => {
+        concatenatedAudio = frames;
+        updateProgress();
+      }
+    }) : null,
+    shouldCreateVideo && !seamlessVideo && videoOutput ? combineVideoStreams({
+      codec,
+      filelistDir,
+      fps,
+      indent,
+      logLevel,
+      numberOfGifLoops,
+      output: videoOutput,
+      files: videoFiles,
+      addRemotionMetadata: !shouldCreateAudio,
+      binariesDirectory,
+      cancelSignal,
+      onProgress: (frames) => {
+        concatenatedVideo = frames;
+        updateProgress();
+      }
+    }) : null
+  ].filter(truthy));
+  try {
+    await muxVideoAndAudio({
+      audioOutput,
+      indent,
+      logLevel,
+      onProgress: (frames) => {
+        muxing = frames;
+        updateProgress();
+      },
+      output,
+      videoOutput: seamlessVideo ? combineVideoStreamsSeamlessly({ files: videoFiles }) : videoOutput,
+      binariesDirectory,
+      fps,
+      cancelSignal,
+      addFaststart: codecSupportsFastStart[codec],
+      metadata
+    });
+    onProgress({ totalProgress: 1, frames: numberOfFrames });
+    rmSync5(filelistDir, { recursive: true });
+  } catch (err) {
+    rmSync5(filelistDir, { recursive: true });
+    throw err;
+  }
+};
+var combineChunks = (options) => {
+  return internalCombineChunks({
+    audioBitrate: options.audioBitrate ?? null,
+    numberOfGifLoops: options.numberOfGifLoops ?? null,
+    indent: false,
+    logLevel: options.logLevel ?? "info",
+    binariesDirectory: options.binariesDirectory ?? null,
+    cancelSignal: options.cancelSignal,
+    metadata: options.metadata ?? null,
+    audioCodec: options.audioCodec ?? null,
+    preferLossless: options.preferLossless,
+    audioFiles: options.audioFiles,
+    codec: options.codec,
+    fps: options.fps,
+    framesPerChunk: options.framesPerChunk,
+    outputLocation: options.outputLocation,
+    onProgress: options.onProgress ?? (() => {
+    }),
+    videoFiles: options.videoFiles,
+    everyNthFrame: options.everyNthFrame ?? 1,
+    frameRange: options.frameRange ?? null,
+    compositionDurationInFrames: options.compositionDurationInFrames
+  });
+};
 // src/extract-audio.ts
 var extractAudio = async (options) => {
   const compositor = startLongRunningCompositor({
@@ -22532,7 +22593,6 @@ var RenderInternals = {
   convertToPositiveFrameIndex,
   findRemotionRoot,
   validateBitrate,
-  combineChunks,
   getMinConcurrency,
   getMaxConcurrency,
   getDefaultAudioCodec,
@@ -22573,7 +22633,10 @@ var RenderInternals = {
   toMegabytes,
   internalEnsureBrowser,
   printUsefulErrorMessage,
-  DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS
+  DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS,
+  canConcatVideoSeamlessly,
+  canConcatAudioSeamlessly,
+  internalCombineChunks
 };
 checkRuntimeVersion("info", false);
 export {
@@ -22591,6 +22654,7 @@ export {
   getCompositions,
   extractAudio,
   ensureBrowser,
+  combineChunks,
   RenderInternals,
   ErrorWithStackFrame
 };