@remotion/renderer 4.0.0-alpha.217 → 4.0.0-alpha10

package/dist/combine-videos.js

@@ -2,8 +2,8 @@
 // Combine multiple video chunks, useful for decentralized rendering
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.combineVideos = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const audio_codec_1 = require("./audio-codec");
 const call_ffmpeg_1 = require("./call-ffmpeg");
 const is_audio_codec_1 = require("./is-audio-codec");
@@ -13,8 +13,8 @@ const combineVideos = async (options) => {
     var _a;
     const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, audioCodec, } = options;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
-    const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
-    (0, fs_1.writeFileSync)(fileListTxt, fileList);
+    const fileListTxt = (0, node_path_1.join)(filelistDir, 'files.txt');
+    (0, node_fs_1.writeFileSync)(fileListTxt, fileList);
     const resolvedAudioCodec = audioCodec !== null && audioCodec !== void 0 ? audioCodec : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: false });
     try {
         const task = (0, call_ffmpeg_1.callFf)('ffmpeg', [
@@ -56,10 +56,10 @@ const combineVideos = async (options) => {
         });
         await task;
         onProgress(numberOfFrames);
-        (0, fs_1.rmSync)(filelistDir, { recursive: true });
+        (0, node_fs_1.rmSync)(filelistDir, { recursive: true });
     }
     catch (err) {
-        (0, fs_1.rmSync)(filelistDir, { recursive: true });
+        (0, node_fs_1.rmSync)(filelistDir, { recursive: true });
         throw err;
     }
 };

package/dist/compositor/compose.d.ts

@@ -1,13 +1,17 @@
 import type { DownloadMap } from '../assets/download-map';
-import type { CompositorImageFormat, Layer } from './payloads';
+import type { Compositor } from './compositor';
+import type { CompositorCommand, CompositorCommandSerialized, CompositorImageFormat, Layer } from './payloads';
 declare type CompositorInput = {
     height: number;
     width: number;
     layers: Layer[];
     imageFormat: CompositorImageFormat;
 };
-export declare const compose: ({ height, width, layers, output, downloadMap, imageFormat, }: CompositorInput & {
+export declare const serializeCommand: <Type extends keyof CompositorCommand>(command: Type, params: CompositorCommand[Type]) => CompositorCommandSerialized<Type>;
+export declare const compose: ({ height, width, layers, output, downloadMap, imageFormat, compositor, }: CompositorInput & {
     downloadMap: DownloadMap;
     output: string;
+    compositor: Compositor;
 }) => Promise<void>;
+export declare const callCompositor: (payload: string) => Promise<void>;
 export {};

package/dist/compositor/compose.js

@@ -1,33 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compose = void 0;
-const child_process_1 = require("child_process");
-const crypto_1 = require("crypto");
-const promises_1 = require("fs/promises");
+exports.callCompositor = exports.compose = exports.serializeCommand = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const call_ffmpeg_1 = require("../call-ffmpeg");
 const get_executable_path_1 = require("./get-executable-path");
+const make_nonce_1 = require("./make-nonce");
 const getCompositorHash = ({ ...input }) => {
-    return (0, crypto_1.createHash)('sha256').update(JSON.stringify(input)).digest('base64');
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(input)).digest('base64');
 };
-const compose = async ({ height, width, layers, output, downloadMap, imageFormat, }) => {
-    const bin = (0, get_executable_path_1.getExecutablePath)('compositor');
+const serializeCommand = (command, params) => {
+    return {
+        nonce: (0, make_nonce_1.makeNonce)(),
+        payload: {
+            type: command,
+            params,
+        },
+    };
+};
+exports.serializeCommand = serializeCommand;
+const compose = async ({ height, width, layers, output, downloadMap, imageFormat, compositor, }) => {
     const hash = getCompositorHash({ height, width, layers, imageFormat });
     if (downloadMap.compositorCache[hash]) {
         await (0, promises_1.copyFile)(downloadMap.compositorCache[hash], output);
         return;
     }
-    const payload = {
-        v: 1,
+    await compositor.executeCommand('Compose', {
         height,
         width,
         layers,
         output,
         output_format: imageFormat,
-    };
-    await new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)(bin, { ...(0, call_ffmpeg_1.callFfExtraOptions)() });
-        child.stdin.write(JSON.stringify(payload));
-        child.stdin.end();
+    });
+    downloadMap.compositorCache[hash] = output;
+};
+exports.compose = compose;
+const callCompositor = (payload) => {
+    return new Promise((resolve, reject) => {
+        const execPath = (0, get_executable_path_1.getExecutablePath)('compositor');
+        if (!process.env.READ_ONLY_FS) {
+            (0, node_fs_1.chmodSync)(execPath, 0o755);
+        }
+        const child = (0, node_child_process_1.spawn)(execPath, [payload], (0, call_ffmpeg_1.dynamicLibraryPathOptions)());
         const stderrChunks = [];
         child.stderr.on('data', (d) => stderrChunks.push(d));
         child.on('close', (code) => {
@@ -36,13 +52,20 @@ const compose = async ({ height, width, layers, output, downloadMap, imageFormat
             }
             else {
                 const message = Buffer.concat(stderrChunks).toString('utf-8');
-                const parsed = JSON.parse(message);
-                const err = new Error(parsed.error);
-                err.stack = parsed.error + '\n' + parsed.backtrace;
-                reject(err);
+                try {
+                    // Try to see if the error is a JSON
+                    const parsed = JSON.parse(message);
+                    const msg = `Compositor error: ${parsed.error}`;
+                    const err = new Error(`${msg}\n${parsed.backtrace}`);
+                    reject(err);
+                }
+                catch (err) {
+                    reject(new Error(`Compositor panicked: ${message}`));
+                }
             }
         });
+        child.stdin.write(payload);
+        child.stdin.end();
     });
-    downloadMap.compositorCache[hash] = output;
 };
-exports.compose = compose;
+exports.callCompositor = callCompositor;

package/dist/compositor/compositor.d.ts

@@ -4,12 +4,8 @@ export declare type Compositor = {
     finishCommands: () => void;
     executeCommand: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T]) => Promise<Buffer>;
     waitForDone: () => Promise<void>;
+    pid: number | null;
 };
-export declare const spawnCompositorOrReuse: <T extends keyof CompositorCommand>({ initiatePayload, renderId, type, }: {
-    type: T;
-    initiatePayload: CompositorCommand[T];
-    renderId: string;
-}) => Compositor;
-export declare const releaseCompositorWithId: (renderId: string) => void;
-export declare const waitForCompositorWithIdToQuit: (renderId: string) => Promise<void>;
-export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T]) => Compositor;
+export declare const getIdealMaximumFrameCacheItems: () => number;
+export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, verbose: boolean, indent: boolean) => Compositor;
+export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], indent: boolean) => Compositor;

package/dist/compositor/compositor.js

@@ -1,54 +1,57 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startCompositor = exports.waitForCompositorWithIdToQuit = exports.releaseCompositorWithId = exports.spawnCompositorOrReuse = void 0;
-const child_process_1 = require("child_process");
+exports.startCompositor = exports.startLongRunningCompositor = exports.getIdealMaximumFrameCacheItems = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
 const call_ffmpeg_1 = require("../call-ffmpeg");
+const get_concurrency_1 = require("../get-concurrency");
+const logger_1 = require("../logger");
+const compose_1 = require("./compose");
 const get_executable_path_1 = require("./get-executable-path");
 const make_nonce_1 = require("./make-nonce");
-const compositorMap = {};
-const spawnCompositorOrReuse = ({ initiatePayload, renderId, type, }) => {
-    if (!compositorMap[renderId]) {
-        compositorMap[renderId] = (0, exports.startCompositor)(type, initiatePayload);
-    }
-    return compositorMap[renderId];
-};
-exports.spawnCompositorOrReuse = spawnCompositorOrReuse;
-const releaseCompositorWithId = (renderId) => {
-    if (compositorMap[renderId]) {
-        compositorMap[renderId].finishCommands();
-    }
+const getIdealMaximumFrameCacheItems = () => {
+    const freeMemory = node_os_1.default.freemem();
+    // Assuming 1 frame is approximately 6MB
+    // Assuming only half the available memory should be used
+    const max = Math.floor(freeMemory / (1024 * 1024 * 6));
+    // Never store more than 1000 frames
+    // But 100 is needed even if it's going to swap
+    return Math.max(100, Math.min(max, 1000));
 };
-exports.releaseCompositorWithId = releaseCompositorWithId;
-const waitForCompositorWithIdToQuit = (renderId) => {
-    if (!compositorMap[renderId]) {
-        throw new TypeError('No compositor with that id');
-    }
-    return compositorMap[renderId].waitForDone();
+exports.getIdealMaximumFrameCacheItems = getIdealMaximumFrameCacheItems;
+const startLongRunningCompositor = (maximumFrameCacheItems, verbose, indent) => {
+    return (0, exports.startCompositor)('StartLongRunningProcess', {
+        concurrency: (0, get_concurrency_1.getActualConcurrency)(null),
+        maximum_frame_cache_items: maximumFrameCacheItems,
+        verbose,
+    }, indent);
 };
-exports.waitForCompositorWithIdToQuit = waitForCompositorWithIdToQuit;
-const startCompositor = (type, payload) => {
+exports.startLongRunningCompositor = startLongRunningCompositor;
+const startCompositor = (type, payload, indent) => {
+    var _a;
     const bin = (0, get_executable_path_1.getExecutablePath)('compositor');
-    const fullCommand = {
-        nonce: (0, make_nonce_1.makeNonce)(),
-        payload: {
-            type,
-            params: payload,
-        },
-    };
-    const child = (0, child_process_1.spawn)(bin, [JSON.stringify(fullCommand)], (0, call_ffmpeg_1.dynamicLibraryPathOptions)());
+    if (!process.env.READ_ONLY_FS) {
+        (0, node_fs_1.chmodSync)(bin, 0o755);
+    }
+    const fullCommand = (0, compose_1.serializeCommand)(type, payload);
+    const child = (0, node_child_process_1.spawn)(bin, [JSON.stringify(fullCommand)], (0, call_ffmpeg_1.dynamicLibraryPathOptions)());
     const stderrChunks = [];
     let outputBuffer = Buffer.from('');
     const separator = Buffer.from('remotion_buffer:');
     const waiters = new Map();
     const onMessage = (statusType, nonce, data) => {
         if (nonce === '0') {
-            console.log(data.toString('utf8'));
+            logger_1.Log.verboseAdvanced({ indent, logLevel: (0, logger_1.getLogLevel)(), tag: 'COMPOSITOR' }, data.toString('utf8'));
         }
         if (waiters.has(nonce)) {
             if (statusType === 'error') {
                 try {
                     const parsed = JSON.parse(data.toString('utf8'));
-                    waiters.get(nonce).reject(new Error(`Compositor error: ${parsed.error}`));
+                    waiters.get(nonce).reject(new Error(`Compositor error: ${parsed.error}\n${parsed.backtrace}`));
                 }
                 catch (err) {
                     waiters.get(nonce).reject(new Error(data.toString('utf8')));
@@ -137,28 +140,38 @@ const startCompositor = (type, payload) => {
         processInput();
     });
     child.stderr.on('data', (data) => {
-        if (data.toString('utf-8').includes('No accelerated colorspace conversion')) {
-            return;
+        stderrChunks.push(data);
+    });
+    let resolve = null;
+    let reject = null;
+    child.on('close', (code) => {
+        quit = true;
+        const waitersToKill = Array.from(waiters.values());
+        if (code === 0) {
+            resolve === null || resolve === void 0 ? void 0 : resolve();
+            for (const waiter of waitersToKill) {
+                waiter.reject(new Error(`Compositor already quit`));
+            }
+            waiters.clear();
+        }
+        else {
+            const error = new Error(`Compositor panicked: ${Buffer.concat(stderrChunks).toString('utf-8')}`);
+            for (const waiter of waitersToKill) {
+                waiter.reject(error);
+            }
+            waiters.clear();
+            reject === null || reject === void 0 ? void 0 : reject(error);
         }
-        console.log(data.toString('utf-8'));
     });
     return {
         waitForDone: () => {
-            return new Promise((resolve, reject) => {
-                child.on('close', (code) => {
-                    quit = true;
-                    const waitersToKill = Array.from(waiters.values());
-                    for (const waiter of waitersToKill) {
-                        waiter.reject(new Error(`Compositor quit with code ${code}`));
-                    }
-                    waiters.clear();
-                    if (code === 0) {
-                        resolve();
-                    }
-                    else {
-                        reject(Buffer.concat(stderrChunks).toString('utf-8'));
-                    }
-                });
+            return new Promise((res, rej) => {
+                if (quit) {
+                    rej(new Error('Compositor already quit'));
+                    return;
+                }
+                resolve = res;
+                reject = rej;
             });
         },
         finishCommands: () => {
@@ -171,7 +184,7 @@ const startCompositor = (type, payload) => {
             if (quit) {
                 throw new Error('Compositor already quit');
             }
-            return new Promise((resolve, reject) => {
+            return new Promise((_resolve, _reject) => {
                 const nonce = (0, make_nonce_1.makeNonce)();
                 const composed = {
                     nonce,
@@ -183,11 +196,12 @@ const startCompositor = (type, payload) => {
                 // TODO: Should have a way to error out a single task
                 child.stdin.write(JSON.stringify(composed) + '\n');
                 waiters.set(nonce, {
-                    resolve,
-                    reject,
+                    resolve: _resolve,
+                    reject: _reject,
                 });
             });
         },
+        pid: (_a = child.pid) !== null && _a !== void 0 ? _a : null,
     };
 };
 exports.startCompositor = startCompositor;

package/dist/compositor/get-executable-path.js

@@ -8,6 +8,9 @@ function isMusl() {
     return !glibcVersionRuntime;
 }
 const getExecutablePath = (type) => {
+    if (type === 'compositor' && process.env.COMPOSITOR_PATH) {
+        return process.env.COMPOSITOR_PATH;
+    }
     const key = type === 'compositor'
         ? 'binaryPath'
         : type === 'ffmpeg'

package/dist/compositor/payloads.d.ts

@@ -27,13 +27,40 @@ export declare type Layer = {
     };
 };
 export declare type CompositorImageFormat = 'Png' | 'Jpeg';
-export declare type CliInput = {
-    v: number;
-    output: string;
-    width: number;
-    height: number;
-    layers: Layer[];
-    output_format: CompositorImageFormat;
+export declare type CompositorCommand = {
+    Compose: {
+        output: string;
+        width: number;
+        height: number;
+        layers: Layer[];
+        output_format: CompositorImageFormat;
+    };
+    ExtractFrame: {
+        input: string;
+        time: number;
+        transparent: boolean;
+    };
+    Echo: {
+        message: string;
+    };
+    StartLongRunningProcess: {
+        concurrency: number;
+        maximum_frame_cache_items: number;
+        verbose: boolean;
+    };
+    GetOpenVideoStats: {};
+    DeliberatePanic: {};
+    CloseAllVideos: {};
+    FreeUpMemory: {
+        percent_of_memory: number;
+    };
+};
+export declare type CompositorCommandSerialized<T extends keyof CompositorCommand> = {
+    nonce: string;
+    payload: {
+        type: T;
+        params: CompositorCommand[T];
+    };
 };
 export declare type ErrorPayload = {
     error: string;

package/dist/crf.js

@@ -9,7 +9,7 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'h264' || codec === 'h264-mkv') {
         return 18; // FFMPEG default 23
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return 23; // FFMPEG default 28
     }
     if (codec === 'vp8') {
@@ -21,6 +21,9 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'prores') {
         return 0;
     }
+    if (codec === 'gif') {
+        return 0;
+    }
     throw new TypeError(`Got unexpected codec "${codec}"`);
 };
 exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
@@ -31,10 +34,13 @@ const getValidCrfRanges = (codec) => {
     if (codec === 'prores') {
         return [0, 0];
     }
+    if (codec === 'gif') {
+        return [0, 0];
+    }
     if (codec === 'h264' || codec === 'h264-mkv') {
         return [1, 51];
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return [0, 51];
     }
     if (codec === 'vp8') {

package/dist/delete-directory.js

@@ -24,13 +24,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteDirectory = void 0;
-const fs_1 = __importStar(require("fs"));
+const node_fs_1 = __importStar(require("node:fs"));
 const is_serve_url_1 = require("./is-serve-url");
 const deleteDirectory = (directory) => {
     if ((0, is_serve_url_1.isServeUrl)(directory)) {
         return;
     }
-    if (!(0, fs_1.existsSync)(directory)) {
+    if (!(0, node_fs_1.existsSync)(directory)) {
         return;
     }
     // Working around a bug with NodeJS 16 on Windows:
@@ -41,7 +41,7 @@ const deleteDirectory = (directory) => {
     let retries = 2;
     while (retries >= 0) {
         try {
-            fs_1.default.rmSync(directory, {
+            node_fs_1.default.rmSync(directory, {
                 maxRetries: 2,
                 recursive: true,
                 force: true,

package/dist/does-have-m2-bug.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.warnAboutM2Bug = void 0;
-const os_1 = require("os");
+const node_os_1 = require("node:os");
 const warnAboutM2Bug = (codec, pixelFormat) => {
-    const isM2 = (0, os_1.cpus)().find((c) => c.model.includes('Apple M2'));
+    const isM2 = (0, node_os_1.cpus)().find((c) => c.model.includes('Apple M2'));
     if (codec === 'prores' && pixelFormat === 'yuv422p10le' && isM2) {
         console.warn();
         console.warn('⚠️ Known issue: Apple M2 CPUs currently suffer from a bug where transparent ProRes videos have flickering. https://github.com/remotion-dev/remotion/issues/1929');

package/dist/ensure-output-directory.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureOutputDirectory = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const ensureOutputDirectory = (outputLocation) => {
-    const dirName = path_1.default.dirname(outputLocation);
-    if (!fs_1.default.existsSync(dirName)) {
-        fs_1.default.mkdirSync(dirName, {
+    const dirName = node_path_1.default.dirname(outputLocation);
+    if (!node_fs_1.default.existsSync(dirName)) {
+        node_fs_1.default.mkdirSync(dirName, {
             recursive: true,
         });
     }

package/dist/ensure-presentation-timestamp.d.ts

@@ -1,8 +1,15 @@
 import type { DownloadMap } from './assets/download-map';
-export declare const ensurePresentationTimestampWithoutCache: ({ src, }: {
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const ensurePresentationTimestampWithoutCache: ({ src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
     src: string;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
 }) => Promise<string>;
-export declare const ensurePresentationTimestamps: ({ downloadMap, src, }: {
+export declare const ensurePresentationTimestamps: ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
     downloadMap: DownloadMap;
     src: string;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
 }) => Promise<string>;

package/dist/ensure-presentation-timestamp.js

@@ -4,12 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensurePresentationTimestamps = exports.ensurePresentationTimestampWithoutCache = void 0;
+const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
-const call_ffmpeg_1 = require("./call-ffmpeg");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const guess_extension_for_media_1 = require("./guess-extension-for-media");
 const truthy_1 = require("./truthy");
 let callbacks = [];
-const getTemporaryOutputName = async ({ src }) => {
+const getTemporaryOutputName = async ({ src, remotionRoot, ffprobeBinary, }) => {
     const parts = src.split(path_1.default.sep);
     // If there is no file extension for the video, then we need to temporarily add an extension
     const lastPart = parts[parts.length - 1];
@@ -17,6 +18,8 @@ const getTemporaryOutputName = async ({ src }) => {
         ? null
         : await (0, guess_extension_for_media_1.guessExtensionForVideo)({
             src,
+            remotionRoot,
+            ffprobeBinary,
         });
     return parts
         .map((p, i) => {
@@ -27,12 +30,14 @@ const getTemporaryOutputName = async ({ src }) => {
     })
         .join(path_1.default.sep);
 };
-const ensurePresentationTimestampWithoutCache = async ({ src, }) => {
+const ensurePresentationTimestampWithoutCache = async ({ src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }) => {
     // If there is no file extension for the video, then we need to tempoa
     const output = await getTemporaryOutputName({
         src,
+        remotionRoot,
+        ffprobeBinary: ffprobeExecutable,
     });
-    await (0, call_ffmpeg_1.callFf)('ffmpeg', [
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-i',
         src,
         '-fflags',
@@ -47,7 +52,7 @@ const ensurePresentationTimestampWithoutCache = async ({ src, }) => {
     return output;
 };
 exports.ensurePresentationTimestampWithoutCache = ensurePresentationTimestampWithoutCache;
-const ensurePresentationTimestamps = async ({ downloadMap, src, }) => {
+const ensurePresentationTimestamps = async ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }) => {
     const elem = downloadMap.ensureFileHasPresentationTimestamp[src];
     if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'encoding') {
         return new Promise((resolve) => {
@@ -62,6 +67,9 @@ const ensurePresentationTimestamps = async ({ downloadMap, src, }) => {
     }
     downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
     const output = await (0, exports.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable,
+        ffprobeExecutable,
+        remotionRoot,
         src,
     });
     callbacks = callbacks.filter((c) => {

package/dist/extract-frame-from-video.d.ts

@@ -1,11 +1,13 @@
-/// <reference types="node" />
 import type { OffthreadVideoImageFormat } from 'remotion';
 import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 import type { LastFrameOptions } from './last-frame-from-video-cache';
 export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
 declare type Options = {
     time: number;
     src: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
     imageFormat: OffthreadVideoImageFormat;
     downloadMap: DownloadMap;
     remotionRoot: string;