@remotion/renderer 4.0.347 → 4.0.348

package/dist/esm/index.mjs

@@ -5389,7 +5389,7 @@ 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 path19 from "node:path";
 import { NoReactInternals as NoReactInternals7 } from "remotion/no-react";
 
 // src/assets/download-and-map-assets-to-file.ts
@@ -14624,7 +14624,7 @@ var attachDownloadListenerToEmitter = (downloadMap, onDownload) => {
 
 // src/assets/download-map.ts
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 import { VERSION as VERSION2 } from "remotion/version";
 
 // src/offthread-video-server.ts
@@ -15050,9 +15050,126 @@ var tmpDir = (str) => {
   return newDir;
 };
 
+// src/assets/inline-audio-mixing.ts
+import fs12, { writeSync } from "node:fs";
+import path14 from "node:path";
+
+// src/sample-rate.ts
+var DEFAULT_SAMPLE_RATE = 48000;
+
+// src/assets/inline-audio-mixing.ts
+var numberTo32BiIntLittleEndian = (num) => {
+  return new Uint8Array([
+    num & 255,
+    num >> 8 & 255,
+    num >> 16 & 255,
+    num >> 24 & 255
+  ]);
+};
+var numberTo16BitLittleEndian = (num) => {
+  return new Uint8Array([num & 255, num >> 8 & 255]);
+};
+var BIT_DEPTH = 16;
+var BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+var makeInlineAudioMixing = (dir) => {
+  const folderToAdd = makeAndReturn(dir, "remotion-inline-audio-mixing");
+  const openFiles = {};
+  const writtenHeaders = {};
+  const cleanup = () => {
+    for (const fd of Object.values(openFiles)) {
+      try {
+        fs12.closeSync(fd);
+      } catch {}
+    }
+    deleteDirectory(folderToAdd);
+  };
+  const getListOfAssets = () => {
+    return Object.keys(openFiles);
+  };
+  const getFilePath = (asset) => {
+    return path14.join(folderToAdd, `${asset.id}.wav`);
+  };
+  const ensureAsset = ({
+    asset,
+    fps,
+    totalNumberOfFrames,
+    trimLeftOffset,
+    trimRightOffset
+  }) => {
+    const filePath = getFilePath(asset);
+    if (!openFiles[filePath]) {
+      openFiles[filePath] = fs12.openSync(filePath, "w");
+    }
+    if (writtenHeaders[filePath]) {
+      return;
+    }
+    writtenHeaders[filePath] = true;
+    const expectedDataSize = Math.round((totalNumberOfFrames / fps - trimLeftOffset + trimRightOffset) * asset.numberOfChannels * DEFAULT_SAMPLE_RATE * BYTES_PER_SAMPLE);
+    const expectedSize = 40 + expectedDataSize;
+    const { numberOfChannels } = asset;
+    const fd = openFiles[filePath];
+    writeSync(fd, new Uint8Array([82, 73, 70, 70]), 0, 4, 0);
+    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedSize)), 0, 4, 4);
+    writeSync(fd, new Uint8Array([87, 65, 86, 69]), 0, 4, 8);
+    writeSync(fd, new Uint8Array([102, 109, 116, 32]), 0, 4, 12);
+    writeSync(fd, new Uint8Array([BIT_DEPTH, 0, 0, 0]), 0, 4, 16);
+    writeSync(fd, new Uint8Array([1, 0]), 0, 2, 20);
+    writeSync(fd, new Uint8Array([numberOfChannels, 0]), 0, 2, 22);
+    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(DEFAULT_SAMPLE_RATE)), 0, 4, 24);
+    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(DEFAULT_SAMPLE_RATE * numberOfChannels * BYTES_PER_SAMPLE)), 0, 4, 28);
+    writeSync(fd, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)), 0, 2, 32);
+    writeSync(fd, numberTo16BitLittleEndian(BIT_DEPTH), 0, 2, 34);
+    writeSync(fd, new Uint8Array([100, 97, 116, 97]), 0, 4, 36);
+    writeSync(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedDataSize)), 0, 4, 40);
+  };
+  const addAsset = ({
+    asset,
+    fps,
+    totalNumberOfFrames,
+    firstFrame,
+    trimLeftOffset,
+    trimRightOffset
+  }) => {
+    ensureAsset({
+      asset,
+      fps,
+      totalNumberOfFrames,
+      trimLeftOffset,
+      trimRightOffset
+    });
+    const filePath = getFilePath(asset);
+    const fileDescriptor = openFiles[filePath];
+    let arr = new Int16Array(asset.audio);
+    const isFirst = asset.frame === firstFrame;
+    const isLast = asset.frame === totalNumberOfFrames + firstFrame - 1;
+    const samplesToShaveFromStart = trimLeftOffset * DEFAULT_SAMPLE_RATE;
+    const samplesToShaveFromEnd = trimRightOffset * DEFAULT_SAMPLE_RATE;
+    if (Math.abs(Math.round(samplesToShaveFromEnd) - samplesToShaveFromEnd) > 0.00000001) {
+      throw new Error("samplesToShaveFromEnd should be approximately an integer");
+    }
+    if (Math.abs(Math.round(samplesToShaveFromStart) - samplesToShaveFromStart) > 0.00000001) {
+      throw new Error("samplesToShaveFromStart should be approximately an integer");
+    }
+    if (isFirst) {
+      arr = arr.slice(Math.round(samplesToShaveFromStart) * asset.numberOfChannels);
+    }
+    if (isLast) {
+      arr = arr.slice(0, arr.length + Math.round(samplesToShaveFromEnd) * asset.numberOfChannels);
+    }
+    const positionInSeconds = (asset.frame - firstFrame) / fps - (isFirst ? 0 : trimLeftOffset);
+    const position = Math.round(positionInSeconds * asset.numberOfChannels * DEFAULT_SAMPLE_RATE * BYTES_PER_SAMPLE);
+    writeSync(fileDescriptor, arr, 0, arr.byteLength, 44 + position);
+  };
+  return {
+    cleanup,
+    addAsset,
+    getListOfAssets
+  };
+};
+
 // src/assets/download-map.ts
 var makeAndReturn = (dir, name) => {
-  const p = path14.join(dir, name);
+  const p = path15.join(dir, name);
   mkdirSync2(p);
   return p;
 };
@@ -15083,7 +15200,8 @@ var makeDownloadMap = () => {
     },
     isPreventedFromCleanup: () => {
       return prevented;
-    }
+    },
+    inlineAudioMixing: makeInlineAudioMixing(dir)
   };
 };
 var cleanDownloadMap = (downloadMap) => {
@@ -15093,11 +15211,12 @@ var cleanDownloadMap = (downloadMap) => {
   deleteDirectory(downloadMap.downloadDir);
   deleteDirectory(downloadMap.complexFilter);
   deleteDirectory(downloadMap.compositingDir);
+  downloadMap.inlineAudioMixing.cleanup();
   deleteDirectory(downloadMap.assetDir);
 };
 
 // src/get-bundle-url-from-serve-url.ts
-import path15 from "path";
+import path16 from "path";
 import { NoReactInternals as NoReactInternals6 } from "remotion/no-react";
 var map = (webpackBundleOrServeUrl, suffix) => {
   if (isServeUrl(webpackBundleOrServeUrl)) {
@@ -15108,7 +15227,7 @@ var map = (webpackBundleOrServeUrl, suffix) => {
     }
     return parsed.origin + parsed.pathname.substring(0, idx + 1) + suffix;
   }
-  const index = webpackBundleOrServeUrl.lastIndexOf(path15.sep);
+  const index = webpackBundleOrServeUrl.lastIndexOf(path16.sep);
   const url = webpackBundleOrServeUrl.substring(0, index + 1) + suffix;
   return url;
 };
@@ -15339,10 +15458,10 @@ var hasIpv4LoopbackAddress = (flattened) => {
 
 // src/serve-handler/index.ts
 import { createReadStream, promises as promises2 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // src/serve-handler/is-path-inside.ts
-import path16 from "node:path";
+import path17 from "node:path";
 var isPathInside = function(thePath, potentialParent) {
   thePath = stripTrailingSep(thePath);
   potentialParent = stripTrailingSep(potentialParent);
@@ -15350,10 +15469,10 @@ var isPathInside = function(thePath, potentialParent) {
     thePath = thePath.toLowerCase();
     potentialParent = potentialParent.toLowerCase();
   }
-  return thePath.lastIndexOf(potentialParent, 0) === 0 && (thePath[potentialParent.length] === path16.sep || thePath[potentialParent.length] === undefined);
+  return thePath.lastIndexOf(potentialParent, 0) === 0 && (thePath[potentialParent.length] === path17.sep || thePath[potentialParent.length] === undefined);
 };
 function stripTrailingSep(thePath) {
-  if (thePath[thePath.length - 1] === path16.sep) {
+  if (thePath[thePath.length - 1] === path17.sep) {
     return thePath.slice(0, -1);
   }
   return thePath;
@@ -15406,7 +15525,7 @@ var rangeParser = (size, str) => {
 
 // src/serve-handler/index.ts
 var getHeaders = (absolutePath, stats) => {
-  const { base } = path17.parse(absolutePath);
+  const { base } = path18.parse(absolutePath);
   let defaultHeaders = {};
   if (stats) {
     defaultHeaders = {
@@ -15422,15 +15541,15 @@ var getHeaders = (absolutePath, stats) => {
   return defaultHeaders;
 };
 var getPossiblePaths = (relativePath, extension) => [
-  path17.join(relativePath, `index${extension}`),
+  path18.join(relativePath, `index${extension}`),
   relativePath.endsWith("/") ? relativePath.replace(/\/$/g, extension) : relativePath + extension
-].filter((item) => path17.basename(item) !== extension);
+].filter((item) => path18.basename(item) !== extension);
 var findRelated = async (current, relativePath) => {
   const possible = getPossiblePaths(relativePath, ".html");
   let stats = null;
   for (let index = 0;index < possible.length; index++) {
     const related = possible[index];
-    const absolutePath = path17.join(current, related);
+    const absolutePath = path18.join(current, related);
     try {
       stats = await promises2.lstat(absolutePath);
     } catch (err) {
@@ -15465,7 +15584,7 @@ var internalError = (absolutePath, response) => {
 };
 var serveHandler = async (request, response, config) => {
   const cwd = process.cwd();
-  const current = path17.resolve(cwd, config.public);
+  const current = path18.resolve(cwd, config.public);
   let relativePath = null;
   try {
     const parsedUrl = new URL(request.url, `http://${request.headers.host}`);
@@ -15477,7 +15596,7 @@ var serveHandler = async (request, response, config) => {
       message: "Bad Request"
     });
   }
-  let absolutePath = path17.join(current, relativePath);
+  let absolutePath = path18.join(current, relativePath);
   if (!isPathInside(absolutePath, current)) {
     return sendError(absolutePath, response, {
       statusCode: 400,
@@ -15486,7 +15605,7 @@ var serveHandler = async (request, response, config) => {
     });
   }
   let stats = null;
-  if (path17.extname(relativePath) !== "") {
+  if (path18.extname(relativePath) !== "") {
     try {
       stats = await promises2.lstat(absolutePath);
     } catch (err) {
@@ -15569,7 +15688,7 @@ var serveHandler = async (request, response, config) => {
 };
 
 // src/serve-static.ts
-var serveStatic = async (path18, options) => {
+var serveStatic = async (path19, options) => {
   const {
     listener: offthreadRequest,
     close: closeCompositor,
@@ -15587,13 +15706,13 @@ var serveStatic = async (path18, options) => {
     if (request.url?.startsWith("/proxy")) {
       return offthreadRequest(request, response);
     }
-    if (path18 === null) {
+    if (path19 === null) {
       response.writeHead(404);
       response.end("Server only supports /proxy");
       return;
     }
     serveHandler(request, response, {
-      public: path18
+      public: path19
     }).catch(() => {
       if (!response.headersSent) {
         response.writeHead(500);
@@ -15744,13 +15863,13 @@ var prepareServer = async ({
       downloadMap
     });
   }
-  const indexFile = path18.join(webpackConfigOrServeUrl, "index.html");
+  const indexFile = path19.join(webpackConfigOrServeUrl, "index.html");
   const exists = existsSync4(indexFile);
   if (!exists) {
     throw new Error(`Tried to serve the Webpack bundle on a HTTP server, but the file ${indexFile} does not exist. Is this a valid path to a Webpack bundle?`);
   }
   let localSourceMap = null;
-  getSourceMapFromLocalFile(path18.join(webpackConfigOrServeUrl, NoReactInternals7.bundleName)).then((s) => {
+  getSourceMapFromLocalFile(path19.join(webpackConfigOrServeUrl, NoReactInternals7.bundleName)).then((s) => {
     localSourceMap = s;
   }).catch((err) => {
     Log.verbose({ indent, logLevel }, "Could not fetch sourcemap for ", webpackConfigOrServeUrl, err);
@@ -16785,21 +16904,21 @@ var defaultCodecsForFileExtension = {
 // src/path-normalize.ts
 var SLASH = 47;
 var DOT = 46;
-var assertPath = (path19) => {
-  const t = typeof path19;
+var assertPath = (path20) => {
+  const t = typeof path20;
   if (t !== "string") {
     throw new TypeError(`Expected a string, got a ${t}`);
   }
 };
-var posixNormalize = (path19, allowAboveRoot) => {
+var posixNormalize = (path20, 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);
+  for (let i = 0;i <= path20.length; ++i) {
+    if (i < path20.length) {
+      code = path20.charCodeAt(i);
     } else if (code === SLASH) {
       break;
     } else {
@@ -16840,9 +16959,9 @@ var posixNormalize = (path19, allowAboveRoot) => {
         }
       } else {
         if (res.length > 0) {
-          res += "/" + path19.slice(lastSlash + 1, i);
+          res += "/" + path20.slice(lastSlash + 1, i);
         } else {
-          res = path19.slice(lastSlash + 1, i);
+          res = path20.slice(lastSlash + 1, i);
         }
         lastSegmentLength = i - lastSlash - 1;
       }
@@ -16865,24 +16984,24 @@ var decode = (s) => {
 };
 var pathNormalize = (p) => {
   assertPath(p);
-  let path19 = p;
-  if (path19.length === 0) {
+  let path20 = p;
+  if (path20.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 = ".";
+  const isAbsolute = path20.charCodeAt(0) === SLASH;
+  const trailingSeparator = path20.charCodeAt(path20.length - 1) === SLASH;
+  path20 = decode(path20);
+  path20 = posixNormalize(path20, !isAbsolute);
+  if (path20.length === 0 && !isAbsolute) {
+    path20 = ".";
   }
-  if (path19.length > 0 && trailingSeparator) {
-    path19 += "/";
+  if (path20.length > 0 && trailingSeparator) {
+    path20 += "/";
   }
   if (isAbsolute) {
-    return "/" + path19;
+    return "/" + path20;
   }
-  return path19;
+  return path20;
 };
 
 // src/get-extension-of-filename.ts
@@ -17035,8 +17154,8 @@ var validateSelectedPixelFormatAndCodecCombination = (pixelFormat, codec) => {
 };
 
 // src/render-frames.ts
-import fs13 from "node:fs";
-import path20 from "node:path";
+import fs14 from "node:fs";
+import path21 from "node:path";
 import { NoReactInternals as NoReactInternals12 } from "remotion/no-react";
 
 // src/cycle-browser-tabs.ts
@@ -17308,9 +17427,6 @@ var parseFfmpegProgress = (input, fps) => {
   }
 };
 
-// src/sample-rate.ts
-var DEFAULT_SAMPLE_RATE = 48000;
-
 // src/combine-audio.ts
 var durationOf1Frame = 1024 / DEFAULT_SAMPLE_RATE * 1e6;
 var getClosestAlignedTime = (targetTime) => {
@@ -17862,40 +17978,7 @@ var getRetriesLeftFromError = (error) => {
 };
 
 // src/render-frame-with-option-to-reject.ts
-import path19 from "path";
-
-// src/filter-asset-types.ts
-var onlyAudioAndVideoAssets = (assets) => {
-  return assets.filter((asset) => asset.type === "audio" || asset.type === "video");
-};
-var onlyArtifact = ({
-  assets,
-  frameBuffer
-}) => {
-  const artifacts = assets.filter((asset) => asset.type === "artifact");
-  return artifacts.map((artifact) => {
-    if (artifact.contentType === "binary" || artifact.contentType === "text") {
-      return {
-        frame: artifact.frame,
-        content: artifact.content,
-        filename: artifact.filename,
-        downloadBehavior: artifact.downloadBehavior
-      };
-    }
-    if (artifact.contentType === "thumbnail") {
-      if (frameBuffer === null) {
-        return null;
-      }
-      return {
-        frame: artifact.frame,
-        content: new Uint8Array(frameBuffer),
-        filename: artifact.filename,
-        downloadBehavior: artifact.downloadBehavior
-      };
-    }
-    throw new Error("Unknown artifact type: " + artifact);
-  }).filter(truthy);
-};
+import path20 from "path";
 
 // src/collect-assets.ts
 var collectAssets = async ({
@@ -17934,18 +18017,54 @@ var collectAssets = async ({
   return fixedArtifacts;
 };
 
+// src/filter-asset-types.ts
+var onlyAudioAndVideoAssets = (assets) => {
+  return assets.filter((asset) => asset.type === "audio" || asset.type === "video");
+};
+var onlyArtifact = ({
+  assets,
+  frameBuffer
+}) => {
+  const artifacts = assets.filter((asset) => asset.type === "artifact");
+  return artifacts.map((artifact) => {
+    if (artifact.contentType === "binary" || artifact.contentType === "text") {
+      return {
+        frame: artifact.frame,
+        content: artifact.content,
+        filename: artifact.filename,
+        downloadBehavior: artifact.downloadBehavior
+      };
+    }
+    if (artifact.contentType === "thumbnail") {
+      if (frameBuffer === null) {
+        return null;
+      }
+      return {
+        frame: artifact.frame,
+        content: new Uint8Array(frameBuffer),
+        filename: artifact.filename,
+        downloadBehavior: artifact.downloadBehavior
+      };
+    }
+    throw new Error("Unknown artifact type: " + artifact);
+  }).filter(truthy);
+};
+var onlyInlineAudio = (assets) => {
+  return assets.filter((asset) => asset.type === "inline-audio");
+};
+
 // src/puppeteer-screenshot.ts
 import * as assert2 from "node:assert";
 
 // src/screenshot-task.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 var screenshotTask = async ({
   format,
   height,
   omitBackground,
   page,
   width,
-  path: path19,
+  path: path20,
   jpegQuality,
   scale
 }) => {
@@ -17998,8 +18117,8 @@ var screenshotTask = async ({
       await client.send("Emulation.setDefaultBackgroundColorOverride");
     }
     const buffer = Buffer.from(result.data, "base64");
-    if (path19) {
-      await fs12.promises.writeFile(path19, buffer);
+    if (path20) {
+      await fs13.promises.writeFile(path20, buffer);
     }
     return buffer;
   } catch (err) {
@@ -18038,7 +18157,6 @@ var takeFrame = async ({
   freePage,
   imageFormat,
   jpegQuality,
-  frame,
   width,
   height,
   output,
@@ -18046,13 +18164,8 @@ var takeFrame = async ({
   wantsBuffer,
   timeoutInMilliseconds
 }) => {
-  const collectedAssets = await collectAssets({
-    frame,
-    freePage,
-    timeoutInMilliseconds
-  });
   if (imageFormat === "none") {
-    return { buffer: null, collectedAssets };
+    return null;
   }
   if (imageFormat === "png" || imageFormat === "pdf" || imageFormat === "webp") {
     await puppeteerEvaluateWithCatch({
@@ -18085,7 +18198,7 @@ var takeFrame = async ({
     height,
     scale
   });
-  return { buffer: buf, collectedAssets };
+  return buf;
 };
 
 // src/render-frame-with-option-to-reject.ts
@@ -18119,7 +18232,11 @@ var renderFrameWithOptionToReject = async ({
   onFrameUpdate,
   frame,
   page,
-  imageSequencePattern
+  imageSequencePattern,
+  fps,
+  trimLeftOffset,
+  trimRightOffset,
+  allFramesAndExtraFrames
 }) => {
   const startTime = performance.now();
   const index = framesToRender.indexOf(frame);
@@ -18156,26 +18273,32 @@ var renderFrameWithOptionToReject = async ({
   if (outputDir && onFrameBuffer && imageFormat !== "none") {
     throw new Error("Pass either `outputDir` or `onFrameBuffer` to renderFrames(), not both.");
   }
-  const { buffer, collectedAssets } = await takeFrame({
-    frame,
-    freePage: page,
-    height,
-    imageFormat: assetsOnly ? "none" : imageFormat,
-    output: index === null ? null : path19.join(frameDir, getFrameOutputFileName({
+  const [buffer, collectedAssets] = await Promise.all([
+    takeFrame({
+      freePage: page,
+      height,
+      imageFormat: assetsOnly ? "none" : imageFormat,
+      output: index === null ? null : path20.join(frameDir, getFrameOutputFileName({
+        frame,
+        imageFormat,
+        index,
+        countType,
+        lastFrame,
+        totalFrames: framesToRender.length,
+        imageSequencePattern
+      })),
+      jpegQuality,
+      width,
+      scale,
+      wantsBuffer: Boolean(onFrameBuffer),
+      timeoutInMilliseconds
+    }),
+    collectAssets({
       frame,
-      imageFormat,
-      index,
-      countType,
-      lastFrame,
-      totalFrames: framesToRender.length,
-      imageSequencePattern
-    })),
-    jpegQuality,
-    width,
-    scale,
-    wantsBuffer: Boolean(onFrameBuffer),
-    timeoutInMilliseconds
-  });
+      freePage: page,
+      timeoutInMilliseconds
+    })
+  ]);
   if (onFrameBuffer && !assetsOnly) {
     if (!buffer) {
       throw new Error("unexpected null buffer");
@@ -18201,6 +18324,7 @@ var renderFrameWithOptionToReject = async ({
   const compressedAssets = audioAndVideoAssets.map((asset) => {
     return compressAsset(previousAudioRenderAssets, asset);
   });
+  const inlineAudioAssets = onlyInlineAudio(collectedAssets);
   assets.push({
     audioAndVideoAssets: compressedAssets,
     frame,
@@ -18209,7 +18333,8 @@ var renderFrameWithOptionToReject = async ({
         frame: a.frame,
         filename: a.filename
       };
-    })
+    }),
+    inlineAudioAssets
   });
   for (const renderAsset of compressedAssets) {
     downloadAndMapAssetsToFileUrl({
@@ -18226,6 +18351,16 @@ var renderFrameWithOptionToReject = async ({
       onError(new Error(`Error while downloading ${truncateWithEllipsis}: ${err.stack}`));
     });
   }
+  for (const renderAsset of inlineAudioAssets) {
+    downloadMap.inlineAudioMixing.addAsset({
+      asset: renderAsset,
+      fps,
+      totalNumberOfFrames: allFramesAndExtraFrames.length,
+      firstFrame: allFramesAndExtraFrames[0],
+      trimLeftOffset,
+      trimRightOffset
+    });
+  }
   cleanupPageError();
   page.off("error", errorCallbackOnFrame);
   if (!assetsOnly) {
@@ -18262,7 +18397,10 @@ var renderFrame = ({
   framesRenderedObj,
   frame,
   page,
-  imageSequencePattern
+  imageSequencePattern,
+  trimLeftOffset,
+  trimRightOffset,
+  allFramesAndExtraFrames
 }) => {
   return new Promise((resolve2, reject) => {
     renderFrameWithOptionToReject({
@@ -18295,7 +18433,11 @@ var renderFrame = ({
       onFrameUpdate,
       frame,
       page,
-      imageSequencePattern
+      imageSequencePattern,
+      fps: composition.fps,
+      trimLeftOffset,
+      trimRightOffset,
+      allFramesAndExtraFrames
     }).then(() => {
       resolve2();
     }).catch((err) => {
@@ -18337,7 +18479,10 @@ var renderFrameAndRetryTargetClose = async ({
   onFrameBuffer,
   onFrameUpdate,
   nextFrameToRender,
-  imageSequencePattern
+  imageSequencePattern,
+  trimLeftOffset,
+  trimRightOffset,
+  allFramesAndExtraFrames
 }) => {
   const currentPool = await poolPromise;
   if (stoppedSignal.stopped) {
@@ -18348,6 +18493,9 @@ var renderFrameAndRetryTargetClose = async ({
   try {
     await Promise.race([
       renderFrame({
+        trimLeftOffset,
+        trimRightOffset,
+        allFramesAndExtraFrames,
         attempt,
         assets,
         binariesDirectory,
@@ -18443,7 +18591,10 @@ var renderFrameAndRetryTargetClose = async ({
         onFrameBuffer,
         onFrameUpdate,
         nextFrameToRender,
-        imageSequencePattern
+        imageSequencePattern,
+        trimLeftOffset,
+        trimRightOffset,
+        allFramesAndExtraFrames
       });
     }
     Log.warn({ indent, logLevel }, `The browser crashed while rendering frame ${frame}, retrying ${retriesLeft} more times. Learn more about this error under https://www.remotion.dev/docs/target-closed`);
@@ -18488,7 +18639,10 @@ var renderFrameAndRetryTargetClose = async ({
       onFrameBuffer,
       onFrameUpdate,
       nextFrameToRender,
-      imageSequencePattern
+      imageSequencePattern,
+      trimLeftOffset,
+      trimRightOffset,
+      allFramesAndExtraFrames
     });
   }
 };
@@ -18599,8 +18753,8 @@ var innerRenderFrames = async ({
   imageSequencePattern
 }) => {
   if (outputDir) {
-    if (!fs13.existsSync(outputDir)) {
-      fs13.mkdirSync(outputDir, {
+    if (!fs14.existsSync(outputDir)) {
+      fs14.mkdirSync(outputDir, {
         recursive: true
       });
     }
@@ -18723,7 +18877,10 @@ var innerRenderFrames = async ({
       onFrameBuffer,
       onFrameUpdate,
       nextFrameToRender,
-      imageSequencePattern: pattern
+      imageSequencePattern: pattern,
+      trimLeftOffset,
+      trimRightOffset,
+      allFramesAndExtraFrames
     });
   }));
   const firstFrameIndex = countType === "from-zero" ? 0 : framesToRender[0];
@@ -18733,7 +18890,7 @@ var innerRenderFrames = async ({
       assets: assets.sort((a, b) => {
         return a.frame - b.frame;
       }),
-      imageSequenceName: path20.join(frameDir, imageSequenceName),
+      imageSequenceName: path21.join(frameDir, imageSequenceName),
       firstFrameIndex,
       downloadMap,
       trimLeftOffset,
@@ -19016,9 +19173,9 @@ var renderFrames = (options) => {
 };
 
 // src/render-media.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import os6 from "node:os";
-import path25 from "node:path";
+import path26 from "node:path";
 import { NoReactInternals as NoReactInternals14 } from "remotion/no-react";
 
 // src/crf.ts
@@ -19651,7 +19808,7 @@ var validateSelectedCodecAndProResCombination = ({
 
 // src/stitch-frames-to-video.ts
 import { cpSync as cpSync2, promises as promises3, rmSync as rmSync3 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/convert-number-of-gif-loops-to-ffmpeg.ts
 var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
@@ -19665,7 +19822,7 @@ var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
 };
 
 // src/create-audio.ts
-import path23 from "path";
+import path24 from "path";
 
 // src/resolve-asset-src.ts
 import url from "node:url";
@@ -19866,7 +20023,7 @@ var compressAudio = async ({
 };
 
 // src/merge-audio-track.ts
-import path22 from "node:path";
+import path23 from "node:path";
 
 // src/chunk.ts
 var chunk2 = (input, size) => {
@@ -19897,22 +20054,30 @@ var createFfmpegMergeFilter = ({
 };
 
 // src/ffmpeg-filter-file.ts
-import fs14, { existsSync as existsSync5 } from "node:fs";
-import path21 from "node:path";
+import fs15, { existsSync as existsSync5 } from "node:fs";
+import path22 from "node:path";
 var makeFfmpegFilterFile = (complexFilter, downloadMap) => {
+  if (complexFilter.filter === null) {
+    return {
+      file: null,
+      cleanup: () => {
+        return;
+      }
+    };
+  }
   return makeFfmpegFilterFileStr(complexFilter.filter, downloadMap);
 };
 var makeFfmpegFilterFileStr = async (complexFilter, downloadMap) => {
   const random2 = Math.random().toString().replace(".", "");
-  const filterFile = path21.join(downloadMap.complexFilter, "complex-filter-" + random2 + ".txt");
+  const filterFile = path22.join(downloadMap.complexFilter, "complex-filter-" + random2 + ".txt");
   if (!existsSync5(downloadMap.complexFilter)) {
-    fs14.mkdirSync(downloadMap.complexFilter, { recursive: true });
+    fs15.mkdirSync(downloadMap.complexFilter, { recursive: true });
   }
-  await fs14.promises.writeFile(filterFile, complexFilter);
+  await fs15.promises.writeFile(filterFile, complexFilter);
   return {
     file: filterFile,
     cleanup: () => {
-      fs14.unlinkSync(filterFile);
+      fs15.unlinkSync(filterFile);
     }
   };
 };
@@ -20011,7 +20176,7 @@ var mergeAudioTrackUnlimited = async ({
         onProgress(combinedProgress);
       };
       const chunkNames = await Promise.all(chunked.map(async (chunkFiles, i) => {
-        const chunkOutname = path22.join(tempPath, `chunk-${i}.wav`);
+        const chunkOutname = path23.join(tempPath, `chunk-${i}.wav`);
         await mergeAudioTrack({
           files: chunkFiles,
           chunkLengthInSeconds,
@@ -20196,6 +20361,32 @@ var ffmpegVolumeExpression = ({
   };
 };
 
+// src/seamless-aac-trim.ts
+var getActualTrimLeft = ({
+  fps,
+  trimLeftOffset,
+  seamless,
+  assetDuration,
+  audioStartFrame,
+  trimLeft,
+  playbackRate
+}) => {
+  const sinceStart = trimLeft - audioStartFrame;
+  if (!seamless) {
+    return {
+      trimLeft: audioStartFrame / fps + sinceStart / fps * playbackRate + trimLeftOffset,
+      maxTrim: assetDuration
+    };
+  }
+  if (seamless) {
+    return {
+      trimLeft: audioStartFrame / fps / playbackRate + sinceStart / fps + trimLeftOffset,
+      maxTrim: assetDuration ? assetDuration / playbackRate : null
+    };
+  }
+  throw new Error("This should never happen");
+};
+
 // src/stringify-ffmpeg-filter.ts
 var cleanUpFloatingPointError = (value) => {
   if (value % 1 < 0.0000001) {
@@ -20214,28 +20405,6 @@ var stringifyTrim = (trim) => {
   }
   return asString;
 };
-var getActualTrimLeft = ({
-  asset,
-  fps,
-  trimLeftOffset,
-  seamless,
-  assetDuration
-}) => {
-  const sinceStart = asset.trimLeft - asset.audioStartFrame;
-  if (!seamless) {
-    return {
-      trimLeft: asset.audioStartFrame / fps + sinceStart / fps * asset.playbackRate + trimLeftOffset,
-      maxTrim: assetDuration
-    };
-  }
-  if (seamless) {
-    return {
-      trimLeft: asset.audioStartFrame / fps / asset.playbackRate + sinceStart / fps + trimLeftOffset,
-      maxTrim: assetDuration ? assetDuration / asset.playbackRate : null
-    };
-  }
-  throw new Error("This should never happen");
-};
 var trimAndSetTempo = ({
   assetDuration,
   asset,
@@ -20246,11 +20415,13 @@ var trimAndSetTempo = ({
   logLevel
 }) => {
   const { trimLeft, maxTrim } = getActualTrimLeft({
-    asset,
+    trimLeft: asset.trimLeft,
     fps,
     trimLeftOffset,
     seamless: true,
-    assetDuration
+    assetDuration,
+    audioStartFrame: asset.audioStartFrame,
+    playbackRate: asset.playbackRate
   });
   const trimRight = trimLeft + asset.duration / fps - trimLeftOffset + trimRightOffset;
   let trimRightOrAssetDuration = maxTrim ? Math.min(trimRight, maxTrim) : trimRight;
@@ -20292,11 +20463,13 @@ var stringifyFfmpegFilter = ({
   const { toneFrequency, startInVideo } = asset;
   const startInVideoSeconds = startInVideo / fps;
   const { trimLeft, maxTrim } = getActualTrimLeft({
-    asset,
+    trimLeft: asset.trimLeft,
     fps,
     trimLeftOffset,
     seamless: forSeamlessAacConcatenation,
-    assetDuration
+    assetDuration,
+    audioStartFrame: asset.audioStartFrame,
+    playbackRate: asset.playbackRate
   });
   if (maxTrim && trimLeft >= maxTrim) {
     return null;
@@ -20386,11 +20559,11 @@ var preprocessAudioTrackUnlimited = async ({
     ["-i", resolveAssetSrc(asset.src)],
     audioStreamIndex ? ["-map", `0:a:${audioStreamIndex}`] : [],
     ["-ac", "2"],
-    ["-filter_script:a", file],
+    file ? ["-filter_script:a", file] : null,
     ["-c:a", "pcm_s16le"],
     ["-ar", String(DEFAULT_SAMPLE_RATE)],
     ["-y", outName]
-  ].flat(2);
+  ].flat(2).filter(truthy);
   Log.verbose({ indent, logLevel }, "Preprocessing audio track:", JSON.stringify(args.join(" ")), "Filter:", filter.filter);
   const startTimestamp = Date.now();
   const task = callFf({
@@ -20459,7 +20632,7 @@ var createAudio = async ({
     onProgress(totalProgress);
   };
   const audioTracks = await Promise.all(assetPositions.map(async (asset, index) => {
-    const filterFile = path23.join(downloadMap.audioMixing, `${index}.wav`);
+    const filterFile = path24.join(downloadMap.audioMixing, `${index}.wav`);
     const result = await preprocessAudioTrack({
       outName: filterFile,
       asset,
@@ -20483,10 +20656,21 @@ var createAudio = async ({
     updateProgress();
     return result;
   }));
-  const preprocessed = audioTracks.filter(truthy);
-  const merged = path23.join(downloadMap.audioPreprocessing, "merged.wav");
+  const inlinedAudio = downloadMap.inlineAudioMixing.getListOfAssets();
+  const preprocessed = [
+    ...audioTracks.filter(truthy),
+    ...inlinedAudio.map((asset) => ({
+      outName: asset,
+      filter: {
+        filter: null,
+        pad_start: null,
+        pad_end: null
+      }
+    }))
+  ];
+  const merged = path24.join(downloadMap.audioPreprocessing, "merged.wav");
   const extension = getExtensionFromAudioCodec(audioCodec);
-  const outName = path23.join(downloadMap.audioPreprocessing, `audio.${extension}`);
+  const outName = path24.join(downloadMap.audioPreprocessing, `audio.${extension}`);
   await mergeAudioTrack({
     files: preprocessed,
     outName: merged,
@@ -20662,7 +20846,7 @@ var innerStitchFramesToVideo = async ({
     setting: audioCodecSetting,
     separateAudioTo
   });
-  const tempFile = outputLocation ? null : path24.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
+  const tempFile = outputLocation ? null : path25.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
   Log.verbose({
     indent,
     logLevel,
@@ -20736,7 +20920,7 @@ var innerStitchFramesToVideo = async ({
     }
     cpSync2(audio, outputLocation ?? tempFile);
     onProgress?.(Math.round(assetsInfo.chunkLengthInSeconds * fps));
-    deleteDirectory(path24.dirname(audio));
+    deleteDirectory(path25.dirname(audio));
     const file = await new Promise((resolve2, reject) => {
       if (tempFile) {
         promises3.readFile(tempFile).then((f) => {
@@ -20747,6 +20931,7 @@ var innerStitchFramesToVideo = async ({
       }
     });
     deleteDirectory(assetsInfo.downloadMap.stitchFrames);
+    assetsInfo.downloadMap.allowCleanup();
     return Promise.resolve(file);
   }
   const ffmpegArgs = [
@@ -20824,14 +21009,13 @@ var innerStitchFramesToVideo = async ({
     if (!audio) {
       throw new Error(`\`separateAudioTo\` was set to ${JSON.stringify(separateAudioTo)}, but this render included no audio`);
     }
-    const finalDestination = path24.resolve(remotionRoot, separateAudioTo);
+    const finalDestination = path25.resolve(remotionRoot, separateAudioTo);
     cpSync2(audio, finalDestination);
     rmSync3(audio);
   }
-  return new Promise((resolve2, reject) => {
+  const result = await new Promise((resolve2, reject) => {
     task.once("close", (code, signal) => {
       if (code === 0) {
-        assetsInfo.downloadMap.allowCleanup();
         if (tempFile === null) {
           cleanDownloadMap(assetsInfo.downloadMap);
           return resolve2(null);
@@ -20848,6 +21032,8 @@ var innerStitchFramesToVideo = async ({
       }
     });
   });
+  assetsInfo.downloadMap.allowCleanup();
+  return result;
 };
 var internalStitchFramesToVideo = (options) => {
   const remotionRoot = findRemotionRoot();
@@ -21145,7 +21331,7 @@ var internalRenderMediaRaw = ({
       separateAudioTo
     });
   }
-  const absoluteOutputLocation = outputLocation ? path25.resolve(process.cwd(), outputLocation) : null;
+  const absoluteOutputLocation = outputLocation ? path26.resolve(process.cwd(), outputLocation) : null;
   validateScale(scale);
   validateFfmpegOverride(ffmpegOverride);
   validateEveryNthFrame(everyNthFrame);
@@ -21211,8 +21397,8 @@ var internalRenderMediaRaw = ({
   }
   const imageFormat = isAudioCodec(codec) ? "none" : provisionalImageFormat ?? compositionWithPossibleUnevenDimensions.defaultVideoImageFormat ?? DEFAULT_VIDEO_IMAGE_FORMAT;
   validateSelectedPixelFormatAndImageFormatCombination(pixelFormat, imageFormat);
-  const workingDir = fs15.mkdtempSync(path25.join(os6.tmpdir(), "react-motion-render"));
-  const preEncodedFileLocation = parallelEncoding ? path25.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
+  const workingDir = fs16.mkdtempSync(path26.join(os6.tmpdir(), "react-motion-render"));
+  const preEncodedFileLocation = parallelEncoding ? path26.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
   if (onCtrlCExit && workingDir) {
     onCtrlCExit(`Delete ${workingDir}`, () => deleteDirectory(workingDir));
   }
@@ -21515,10 +21701,10 @@ var internalRenderMediaRaw = ({
       }
       reject(err);
     }).finally(() => {
-      if (preEncodedFileLocation !== null && fs15.existsSync(preEncodedFileLocation)) {
-        deleteDirectory(path25.dirname(preEncodedFileLocation));
+      if (preEncodedFileLocation !== null && fs16.existsSync(preEncodedFileLocation)) {
+        deleteDirectory(path26.dirname(preEncodedFileLocation));
       }
-      if (workingDir && fs15.existsSync(workingDir)) {
+      if (workingDir && fs16.existsSync(workingDir)) {
         deleteDirectory(workingDir);
       }
       cleanupServerFn?.(false).catch((err) => {
@@ -21676,8 +21862,8 @@ var renderMedia = ({
 };
 
 // src/render-still.ts
-import fs16, { statSync as statSync2 } from "node:fs";
-import path26 from "node:path";
+import fs17, { statSync as statSync2 } from "node:fs";
+import path27 from "node:path";
 import { NoReactInternals as NoReactInternals15 } from "remotion/no-react";
 var innerRenderStill = async ({
   composition,
@@ -21725,10 +21911,10 @@ var innerRenderStill = async ({
   });
   validatePuppeteerTimeout(timeoutInMilliseconds);
   validateScale(scale);
-  output = typeof output === "string" ? path26.resolve(process.cwd(), output) : null;
+  output = typeof output === "string" ? path27.resolve(process.cwd(), output) : null;
   validateJpegQuality(jpegQuality);
   if (output) {
-    if (fs16.existsSync(output)) {
+    if (fs17.existsSync(output)) {
       if (!overwrite) {
         throw new Error(`Cannot render still - "overwrite" option was set to false, but the output destination ${output} already exists.`);
       }
@@ -21843,18 +22029,24 @@ var innerRenderStill = async ({
     logLevel,
     attempt: 0
   });
-  const { buffer, collectedAssets } = await takeFrame({
-    frame: stillFrame,
-    freePage: page,
-    height: composition.height,
-    width: composition.width,
-    imageFormat,
-    scale,
-    output,
-    jpegQuality,
-    wantsBuffer: !output,
-    timeoutInMilliseconds
-  });
+  const [buffer, collectedAssets] = await Promise.all([
+    takeFrame({
+      freePage: page,
+      height: composition.height,
+      width: composition.width,
+      imageFormat,
+      scale,
+      output,
+      jpegQuality,
+      wantsBuffer: !output,
+      timeoutInMilliseconds
+    }),
+    collectAssets({
+      frame,
+      freePage: page,
+      timeoutInMilliseconds
+    })
+  ]);
   const artifactAssets = onlyArtifact({
     assets: collectedAssets,
     frameBuffer: buffer