@remotion/renderer 4.0.294 → 4.0.296

package/dist/compositor/compositor.js

@@ -93,6 +93,7 @@ const startCompositor = ({ type, payload, logLevel, indent, binariesDirectory =
             const errorMessage = Buffer.concat(stderrChunks).toString('utf-8') +
                 new TextDecoder('utf-8').decode(getOutputBuffer());
             runningStatus = { type: 'quit-with-error', error: errorMessage, signal };
+            logger_1.Log.verbose({ indent, logLevel }, `Compositor exited with code ${code} and signal ${signal}`);
             const error = code === null
                 ? new Error(`Compositor exited with signal ${signal}`)
                 : new Error(`Compositor exited with code ${code}: ${errorMessage}`);

package/dist/download-behavior.d.ts

@@ -0,0 +1,6 @@
+export type DownloadBehavior = {
+    type: 'play-in-browser';
+} | {
+    type: 'download';
+    fileName: string | null;
+};

package/dist/download-behavior.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/index.mjs

@@ -4951,56 +4951,6 @@ var getLocalBrowserExecutable = ({
   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);
-    }
-  }
-  return Math.min(freemem(), maxMemory);
-};
-
 // src/get-cpu-count.ts
 import { execSync as execSync2 } from "node:child_process";
 import { cpus } from "node:os";
@@ -5026,6 +4976,142 @@ var getCpuCount = () => {
   return Math.min(nproc, node);
 };
 
+// src/memory/get-available-memory.ts
+import { freemem } from "node:os";
+
+// src/memory/from-docker-cgroup.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+var getMaxMemoryFromCgroupV2 = () => {
+  try {
+    const data = readFileSync2("/sys/fs/cgroup/memory.max", "utf-8");
+    if (data.trim() === "max") {
+      return Infinity;
+    }
+    return parseInt(data, 10);
+  } catch {
+    return null;
+  }
+};
+var getAvailableMemoryFromCgroupV2 = () => {
+  try {
+    const data = readFileSync2("/sys/fs/cgroup/memory.current", "utf-8");
+    return parseInt(data, 10);
+  } catch {
+    return null;
+  }
+};
+var getMaxMemoryFromCgroupV1 = () => {
+  try {
+    const data = readFileSync2("/sys/fs/cgroup/memory/memory.limit_in_bytes", "utf-8");
+    if (data.trim() === "max") {
+      return Infinity;
+    }
+    return parseInt(data, 10);
+  } catch {
+    return null;
+  }
+};
+var getAvailableMemoryFromCgroupV1 = () => {
+  try {
+    const data = readFileSync2("/sys/fs/cgroup/memory/memory.usage_in_bytes", "utf-8");
+    return parseInt(data, 10);
+  } catch {
+    return null;
+  }
+};
+var getAvailableMemoryFromCgroup = () => {
+  const maxMemoryV2 = getMaxMemoryFromCgroupV2();
+  if (maxMemoryV2 !== null) {
+    const availableMemoryV2 = getAvailableMemoryFromCgroupV2();
+    if (availableMemoryV2 !== null) {
+      return maxMemoryV2 - availableMemoryV2;
+    }
+  }
+  const maxMemoryV1 = getMaxMemoryFromCgroupV1();
+  if (maxMemoryV1 !== null) {
+    const availableMemoryV1 = getAvailableMemoryFromCgroupV1();
+    if (availableMemoryV1 !== null) {
+      return maxMemoryV1 - availableMemoryV1;
+    }
+  }
+  return null;
+};
+
+// src/memory/from-lambda-env.ts
+var getMaxLambdaMemory = () => {
+  if (process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) {
+    return parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE, 10) * 1024 * 1024;
+  }
+  return null;
+};
+
+// src/memory/from-proc-meminfo.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+var getFreeMemoryFromProcMeminfo = (logLevel) => {
+  if (!existsSync3("/proc/meminfo")) {
+    return null;
+  }
+  try {
+    const data = readFileSync3("/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}`);
+    }
+  } catch (err) {
+    Log.warn({ indent: false, logLevel }, "/proc/meminfo exists but failed to get memory info. Error:");
+    Log.warn({ indent: false, logLevel }, err);
+    return null;
+  }
+};
+
+// src/memory/get-available-memory.ts
+var getAvailableMemory = (logLevel) => {
+  const maxMemory = getMaxLambdaMemory();
+  if (maxMemory !== null) {
+    const nodeMemory = freemem();
+    return Math.min(nodeMemory, maxMemory);
+  }
+  const cgroupMemory = getAvailableMemoryFromCgroup();
+  if (cgroupMemory !== null) {
+    const nodeMemory = freemem();
+    const _procInfo = getFreeMemoryFromProcMeminfo(logLevel);
+    if (cgroupMemory > nodeMemory * 1.25) {
+      Log.warn({ indent: false, logLevel }, "Detected differing memory amounts:");
+      Log.warn({ indent: false, logLevel }, `Memory reported by CGroup: ${(cgroupMemory / 1024 / 1024).toFixed(2)} MB`);
+      if (_procInfo !== null) {
+        Log.warn({ indent: false, logLevel }, `Memory reported by /proc/meminfo: ${(_procInfo / 1024 / 1024).toFixed(2)} MB`);
+      }
+      Log.warn({ indent: false, logLevel }, `Memory reported by Node: ${(nodeMemory / 1024 / 1024).toFixed(2)} MB`);
+      Log.warn({ indent: false, logLevel }, "You might have inadvertenly set the --memory flag of `docker run` to a value that is higher than the global Docker memory limit.");
+      Log.warn({ indent: false, logLevel }, "Using the lower amount of memory for calculation.");
+    }
+    return Math.min(nodeMemory, cgroupMemory);
+  }
+  const procInfo = getFreeMemoryFromProcMeminfo(logLevel);
+  if (procInfo !== null) {
+    return Math.min(freemem(), procInfo);
+  }
+  return freemem();
+};
+
 // src/get-video-threads-flag.ts
 var MEMORY_USAGE_PER_THREAD = 400000000;
 var RESERVED_MEMORY = 2000000000;
@@ -14635,6 +14721,7 @@ ${parsed.backtrace}`));
     } else {
       const errorMessage = Buffer.concat(stderrChunks).toString("utf-8") + new TextDecoder("utf-8").decode(getOutputBuffer());
       runningStatus = { type: "quit-with-error", error: errorMessage, signal };
+      Log.verbose({ indent, logLevel }, `Compositor exited with code ${code} and signal ${signal}`);
       const error = code === null ? new Error(`Compositor exited with signal ${signal}`) : new Error(`Compositor exited with code ${code}: ${errorMessage}`);
       for (const waiter of waitersToKill) {
         waiter.reject(error);
@@ -17749,7 +17836,8 @@ var onlyArtifact = ({
       return {
         frame: artifact.frame,
         content: artifact.content,
-        filename: artifact.filename
+        filename: artifact.filename,
+        downloadBehavior: artifact.downloadBehavior
       };
     }
     if (artifact.contentType === "thumbnail") {
@@ -17759,7 +17847,8 @@ var onlyArtifact = ({
       return {
         frame: artifact.frame,
         content: new Uint8Array(frameBuffer),
-        filename: artifact.filename
+        filename: artifact.filename,
+        downloadBehavior: artifact.downloadBehavior
       };
     }
     throw new Error("Unknown artifact type: " + artifact);

package/dist/filter-asset-types.js

@@ -16,6 +16,7 @@ const onlyArtifact = ({ assets, frameBuffer, }) => {
                 frame: artifact.frame,
                 content: artifact.content,
                 filename: artifact.filename,
+                downloadBehavior: artifact.downloadBehavior,
             };
         }
         if (artifact.contentType === 'thumbnail') {
@@ -29,6 +30,7 @@ const onlyArtifact = ({ assets, frameBuffer, }) => {
                 frame: artifact.frame,
                 content: new Uint8Array(frameBuffer),
                 filename: artifact.filename,
+                downloadBehavior: artifact.downloadBehavior,
             };
         }
         throw new Error('Unknown artifact type: ' + artifact);

package/dist/get-video-threads-flag.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIdealVideoThreadsFlag = void 0;
-const get_available_memory_1 = require("./get-available-memory");
 const get_cpu_count_1 = require("./get-cpu-count");
+const get_available_memory_1 = require("./memory/get-available-memory");
 const MEMORY_USAGE_PER_THREAD = 400000000; // 400MB
 const RESERVED_MEMORY = 2000000000;
 const getIdealVideoThreadsFlag = (logLevel) => {

package/dist/memory/from-docker-cgroup.d.ts

@@ -0,0 +1 @@
+export declare const getAvailableMemoryFromCgroup: () => number | null;

package/dist/memory/from-docker-cgroup.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableMemoryFromCgroup = void 0;
+const node_fs_1 = require("node:fs");
+const getMaxMemoryFromCgroupV2 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory.max', 'utf-8');
+        // If --memory=[num] flag of "docker run" is not set, the value will be "max"
+        if (data.trim() === 'max') {
+            return Infinity;
+        }
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getAvailableMemoryFromCgroupV2 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory.current', 'utf-8');
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getMaxMemoryFromCgroupV1 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf-8');
+        // If --memory=[num] flag of "docker run" is not set, the value will be "max"
+        if (data.trim() === 'max') {
+            return Infinity;
+        }
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getAvailableMemoryFromCgroupV1 = () => {
+    try {
+        const data = (0, node_fs_1.readFileSync)('/sys/fs/cgroup/memory/memory.usage_in_bytes', 'utf-8');
+        return parseInt(data, 10);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const getAvailableMemoryFromCgroup = () => {
+    const maxMemoryV2 = getMaxMemoryFromCgroupV2();
+    if (maxMemoryV2 !== null) {
+        const availableMemoryV2 = getAvailableMemoryFromCgroupV2();
+        if (availableMemoryV2 !== null) {
+            return maxMemoryV2 - availableMemoryV2;
+        }
+    }
+    const maxMemoryV1 = getMaxMemoryFromCgroupV1();
+    if (maxMemoryV1 !== null) {
+        const availableMemoryV1 = getAvailableMemoryFromCgroupV1();
+        if (availableMemoryV1 !== null) {
+            return maxMemoryV1 - availableMemoryV1;
+        }
+    }
+    return null;
+};
+exports.getAvailableMemoryFromCgroup = getAvailableMemoryFromCgroup;

package/dist/memory/from-lambda-env.d.ts

@@ -0,0 +1 @@
+export declare const getMaxLambdaMemory: () => number | null;

package/dist/memory/from-lambda-env.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxLambdaMemory = void 0;
+const getMaxLambdaMemory = () => {
+    if (process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) {
+        return (parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE, 10) * 1024 * 1024);
+    }
+    return null;
+};
+exports.getMaxLambdaMemory = getMaxLambdaMemory;

package/dist/memory/from-proc-meminfo.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from '../log-level';
+export declare const getFreeMemoryFromProcMeminfo: (logLevel: LogLevel) => number | null;

package/dist/memory/from-proc-meminfo.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFreeMemoryFromProcMeminfo = void 0;
+const node_fs_1 = require("node:fs");
+const logger_1 = require("../logger");
+const getFreeMemoryFromProcMeminfo = (logLevel) => {
+    if (!(0, node_fs_1.existsSync)('/proc/meminfo')) {
+        return null;
+    }
+    try {
+        const data = (0, node_fs_1.readFileSync)('/proc/meminfo', 'utf-8');
+        // Split the file by lines and find the line with MemFree
+        const lines = data.split('\n');
+        const memAvailableLine = lines.find((line) => line.startsWith('MemAvailable'));
+        // If we couldn't find MemAvailable, return an error
+        if (!memAvailableLine) {
+            throw new Error('MemAvailable not found in /proc/meminfo');
+        }
+        // Extract the value and unit from the line
+        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();
+        // Convert the value to bytes based on its unit
+        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}`);
+        }
+    }
+    catch (err) {
+        logger_1.Log.warn({ indent: false, logLevel }, '/proc/meminfo exists but failed to get memory info. Error:');
+        logger_1.Log.warn({ indent: false, logLevel }, err);
+        return null;
+    }
+};
+exports.getFreeMemoryFromProcMeminfo = getFreeMemoryFromProcMeminfo;

package/dist/memory/get-available-memory.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from '../log-level';
+export declare const getAvailableMemory: (logLevel: LogLevel) => number;

package/dist/memory/get-available-memory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableMemory = void 0;
+const node_os_1 = require("node:os");
+const logger_1 = require("../logger");
+const from_docker_cgroup_1 = require("./from-docker-cgroup");
+const from_lambda_env_1 = require("./from-lambda-env");
+const from_proc_meminfo_1 = require("./from-proc-meminfo");
+const getAvailableMemory = (logLevel) => {
+    // If we are in Lambda, the most reliable way is to read the environment variable
+    // This is also pretty much free
+    const maxMemory = (0, from_lambda_env_1.getMaxLambdaMemory)();
+    if (maxMemory !== null) {
+        const nodeMemory = (0, node_os_1.freemem)();
+        return Math.min(nodeMemory, maxMemory);
+    }
+    // If cgroup memory data is available, we are in Docker, and we should respect it
+    const cgroupMemory = (0, from_docker_cgroup_1.getAvailableMemoryFromCgroup)();
+    if (cgroupMemory !== null) {
+        // There are 2 Docker memory configurations:
+        // 1. --memory=[num]
+        // 2. Global Docker memory limit
+        // If cgroup limit is higher than global memory, the global memory limit still applies
+        const nodeMemory = (0, node_os_1.freemem)();
+        const _procInfo = (0, from_proc_meminfo_1.getFreeMemoryFromProcMeminfo)(logLevel);
+        if (cgroupMemory > nodeMemory * 1.25) {
+            logger_1.Log.warn({ indent: false, logLevel }, 'Detected differing memory amounts:');
+            logger_1.Log.warn({ indent: false, logLevel }, `Memory reported by CGroup: ${(cgroupMemory / 1024 / 1024).toFixed(2)} MB`);
+            if (_procInfo !== null) {
+                logger_1.Log.warn({ indent: false, logLevel }, `Memory reported by /proc/meminfo: ${(_procInfo / 1024 / 1024).toFixed(2)} MB`);
+            }
+            logger_1.Log.warn({ indent: false, logLevel }, `Memory reported by Node: ${(nodeMemory / 1024 / 1024).toFixed(2)} MB`);
+            logger_1.Log.warn({ indent: false, logLevel }, 'You might have inadvertenly set the --memory flag of `docker run` to a value that is higher than the global Docker memory limit.');
+            logger_1.Log.warn({ indent: false, logLevel }, 'Using the lower amount of memory for calculation.');
+        }
+        return Math.min(nodeMemory, cgroupMemory);
+    }
+    const procInfo = (0, from_proc_meminfo_1.getFreeMemoryFromProcMeminfo)(logLevel);
+    if (procInfo !== null) {
+        return Math.min((0, node_os_1.freemem)(), procInfo);
+    }
+    return (0, node_os_1.freemem)();
+};
+exports.getAvailableMemory = getAvailableMemory;

package/dist/prestitcher-memory-usage.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldUseParallelEncoding = void 0;
-const get_available_memory_1 = require("./get-available-memory");
+const get_available_memory_1 = require("./memory/get-available-memory");
 const estimateMemoryUsageForPrestitcher = ({ width, height, }) => {
     // Empirically we detected that per 1 million pixels, FFMPEG uses around 1GB of memory, relatively independent of
     // the duration of the video.

package/dist/serialize-artifact.d.ts

@@ -1,5 +1,7 @@
+import type { DownloadBehavior } from 'remotion';
 export type EmittedArtifact = {
     filename: string;
     content: string | Uint8Array;
     frame: number;
+    downloadBehavior: DownloadBehavior | null;
 };

package/package.json

@@ -3,7 +3,7 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/renderer"
   },
   "name": "@remotion/renderer",
-  "version": "4.0.294",
+  "version": "4.0.296",
   "description": "Render Remotion videos using Node.js or Bun",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,8 @@
     "extract-zip": "2.0.1",
     "source-map": "^0.8.0-beta.0",
     "ws": "8.17.1",
-    "remotion": "4.0.294",
-    "@remotion/streaming": "4.0.294"
+    "remotion": "4.0.296",
+    "@remotion/streaming": "4.0.296"
   },
   "peerDependencies": {
     "react": ">=16.8.0",
@@ -33,17 +33,17 @@
     "react-dom": "19.0.0",
     "@types/ws": "8.5.10",
     "eslint": "9.19.0",
-    "@remotion/eslint-config-internal": "4.0.294",
-    "@remotion/example-videos": "4.0.294"
+    "@remotion/example-videos": "4.0.296",
+    "@remotion/eslint-config-internal": "4.0.296"
   },
   "optionalDependencies": {
-    "@remotion/compositor-darwin-arm64": "4.0.294",
-    "@remotion/compositor-darwin-x64": "4.0.294",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.294",
-    "@remotion/compositor-linux-x64-gnu": "4.0.294",
-    "@remotion/compositor-linux-x64-musl": "4.0.294",
-    "@remotion/compositor-win32-x64-msvc": "4.0.294",
-    "@remotion/compositor-linux-arm64-musl": "4.0.294"
+    "@remotion/compositor-darwin-x64": "4.0.296",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.296",
+    "@remotion/compositor-linux-arm64-musl": "4.0.296",
+    "@remotion/compositor-win32-x64-msvc": "4.0.296",
+    "@remotion/compositor-darwin-arm64": "4.0.296",
+    "@remotion/compositor-linux-x64-gnu": "4.0.296",
+    "@remotion/compositor-linux-x64-musl": "4.0.296"
   },
   "keywords": [
     "remotion",