@remotion/renderer 3.3.0 → 3.3.2

package/dist/assets/download-file.d.ts

@@ -1,3 +1,7 @@
+declare type Response = {
+    sizeInBytes: number;
+    to: string;
+};
 export declare const downloadFile: ({ onProgress, url, to: toFn, }: {
     url: string;
     to: (contentDisposition: string | null, contentType: string | null) => string;
@@ -6,7 +10,5 @@ export declare const downloadFile: ({ onProgress, url, to: toFn, }: {
         downloaded: number;
         totalSize: number | null;
     }) => void) | undefined;
-}) => Promise<{
-    sizeInBytes: number;
-    to: string;
-}>;
+}) => Promise<Response>;
+export {};

package/dist/assets/download-file.js

@@ -6,6 +6,35 @@ const ensure_output_directory_1 = require("../ensure-output-directory");
 const read_file_1 = require("./read-file");
 const downloadFile = ({ onProgress, url, to: toFn, }) => {
     return new Promise((resolve, reject) => {
+        let rejected = false;
+        let resolved = false;
+        let timeout;
+        const resolveAndFlag = (val) => {
+            resolved = true;
+            resolve(val);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        };
+        const rejectAndFlag = (err) => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            reject(err);
+            rejected = true;
+        };
+        const refreshTimeout = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            timeout = setTimeout(() => {
+                if (resolved) {
+                    return;
+                }
+                rejectAndFlag(new Error(`Tried to download file ${url}, but the server sent no data for 20 seconds`));
+            }, 20000);
+        };
+        refreshTimeout();
         (0, read_file_1.readFile)(url)
             .then((res) => {
             var _a, _b;
@@ -21,16 +50,20 @@ const downloadFile = ({ onProgress, url, to: toFn, }) => {
             // concise method to avoid this problem
             // https://github.com/remotion-dev/remotion/issues/384#issuecomment-844398183
             writeStream.on('close', () => {
+                if (rejected) {
+                    return;
+                }
                 onProgress === null || onProgress === void 0 ? void 0 : onProgress({
                     downloaded,
                     percent: 1,
                     totalSize: downloaded,
                 });
-                return resolve({ sizeInBytes: downloaded, to });
+                refreshTimeout();
+                return resolveAndFlag({ sizeInBytes: downloaded, to });
             });
-            writeStream.on('error', (err) => reject(err));
-            res.on('error', (err) => reject(err));
-            res.pipe(writeStream).on('error', (err) => reject(err));
+            writeStream.on('error', (err) => rejectAndFlag(err));
+            res.on('error', (err) => rejectAndFlag(err));
+            res.pipe(writeStream).on('error', (err) => rejectAndFlag(err));
             res.on('data', (d) => {
                 downloaded += d.length;
                 onProgress === null || onProgress === void 0 ? void 0 : onProgress({
@@ -39,9 +72,15 @@ const downloadFile = ({ onProgress, url, to: toFn, }) => {
                     totalSize,
                 });
             });
+            res.on('close', () => {
+                if (totalSize !== null && downloaded !== totalSize) {
+                    rejectAndFlag(new Error(`Download finished with ${downloaded} bytes, but expected ${totalSize} bytes from 'Content-Length'.`));
+                }
+                writeStream.close();
+            });
         })
             .catch((err) => {
-            reject(err);
+            rejectAndFlag(err);
         });
     });
 };

package/dist/assets/download-map.d.ts

@@ -7,9 +7,10 @@ declare type EncodingStatus = {
     src: string;
 } | undefined;
 export declare type SpecialVCodecForTransparency = 'vp9' | 'vp8' | 'none';
+export declare type NeedsResize = [number, number] | null;
 export declare type Vp9Result = {
-    specialVcodec: SpecialVCodecForTransparency;
-    needsResize: [number, number] | null;
+    specialVcodecForTransparency: SpecialVCodecForTransparency;
+    needsResize: NeedsResize;
 };
 export declare type VideoDurationResult = {
     duration: number | null;

package/dist/assets/get-video-stream-duration.d.ts

@@ -1,4 +1,9 @@
 import type { FfmpegExecutable } from '../ffmpeg-executable';
 import type { DownloadMap, VideoDurationResult } from './download-map';
 export declare const parseVideoStreamDuration: (stdout: string) => VideoDurationResult;
+export declare function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<VideoDurationResult>;
 export declare const getVideoStreamDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<VideoDurationResult>;

package/dist/assets/get-video-stream-duration.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoStreamDuration = exports.parseVideoStreamDuration = void 0;
+exports.getVideoStreamDuration = exports.getVideoStreamDurationwithoutCache = exports.parseVideoStreamDuration = void 0;
 const execa_1 = __importDefault(require("execa"));
 const ffmpeg_flags_1 = require("../ffmpeg-flags");
 const p_limit_1 = require("../p-limit");
@@ -39,10 +39,7 @@ const parseVideoStreamDuration = (stdout) => {
     return result;
 };
 exports.parseVideoStreamDuration = parseVideoStreamDuration;
-async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
-    if (downloadMap.videoDurationResultCache[src]) {
-        return downloadMap.videoDurationResultCache[src];
-    }
+async function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }) {
     const args = [
         ['-v', 'error'],
         ['-select_streams', 'v:0'],
@@ -52,7 +49,21 @@ async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutab
         .reduce((acc, val) => acc.concat(val), [])
         .filter(Boolean);
     const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), args);
-    return (0, exports.parseVideoStreamDuration)(task.stdout);
+    const result = (0, exports.parseVideoStreamDuration)(task.stdout);
+    return result;
+}
+exports.getVideoStreamDurationwithoutCache = getVideoStreamDurationwithoutCache;
+async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (downloadMap.videoDurationResultCache[src]) {
+        return downloadMap.videoDurationResultCache[src];
+    }
+    const result = await getVideoStreamDurationwithoutCache({
+        src,
+        ffprobeExecutable,
+        remotionRoot,
+    });
+    downloadMap.videoDurationResultCache[src] = result;
+    return result;
 }
 const getVideoStreamDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
     return limit(() => getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));

package/dist/assets/read-file.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFile = void 0;
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
+const redirect_status_codes_1 = require("../redirect-status-codes");
 const getClient = (url) => {
     if (url.startsWith('https://')) {
         return https_1.default.get;
@@ -29,10 +30,7 @@ const readFile = async (url, redirectsSoFar = 0) => {
         throw new Error(`Too many redirects while downloading ${url}`);
     }
     const file = await readFileWithoutRedirect(url);
-    if (file.statusCode === 302 ||
-        file.statusCode === 301 ||
-        file.statusCode === 307 ||
-        file.statusCode === 308) {
+    if (redirect_status_codes_1.redirectStatusCodes.includes(file.statusCode)) {
         if (!file.headers.location) {
             throw new Error(`Received a status code ${file.statusCode} but no "Location" header while calling ${file.headers.location}`);
         }

package/dist/browser/Browser.js

@@ -135,7 +135,6 @@ class Browser extends EventEmitter_1.EventEmitter {
     async close(silent) {
         await __classPrivateFieldGet(this, _Browser_closeCallback, "f").call(null);
         (await this.pages()).forEach((page) => {
-            console.log('disposing', page.id);
             page.emit("disposed" /* PageEmittedEvents.Disposed */);
             page.closed = true;
         });

package/dist/determine-resize-params.d.ts

@@ -0,0 +1,4 @@
+export declare const determineResizeParams: (needsResize: [
+    number,
+    number
+] | null) => string[];

package/dist/determine-resize-params.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineResizeParams = void 0;
+const determineResizeParams = (needsResize) => {
+    if (needsResize === null) {
+        return [];
+    }
+    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
+};
+exports.determineResizeParams = determineResizeParams;

package/dist/determine-vcodec-ffmepg-flags.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+export declare const determineVcodecFfmepgFlags: (vcodecFlag: SpecialVCodecForTransparency) => string[];

package/dist/determine-vcodec-ffmepg-flags.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineVcodecFfmepgFlags = void 0;
+const truthy_1 = require("./truthy");
+const determineVcodecFfmepgFlags = (vcodecFlag) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(truthy_1.truthy);
+};
+exports.determineVcodecFfmepgFlags = determineVcodecFfmepgFlags;

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

@@ -1,5 +1,11 @@
 import type { DownloadMap } from './assets/download-map';
 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, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
     downloadMap: DownloadMap;
     src: string;

package/dist/ensure-presentation-timestamp.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensurePresentationTimestamps = void 0;
+exports.ensurePresentationTimestamps = exports.ensurePresentationTimestampWithoutCache = void 0;
 const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
@@ -30,20 +30,7 @@ const getTemporaryOutputName = async ({ src, remotionRoot, ffprobeBinary, }) =>
     })
         .join(path_1.default.sep);
 };
-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) => {
-            callbacks.push({
-                src,
-                fn: (newSrc) => resolve(newSrc),
-            });
-        });
-    }
-    if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'done') {
-        return elem.src;
-    }
-    downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
+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,
@@ -62,6 +49,29 @@ const ensurePresentationTimestamps = async ({ downloadMap, src, remotionRoot, ff
         output,
         '-y',
     ]);
+    return output;
+};
+exports.ensurePresentationTimestampWithoutCache = ensurePresentationTimestampWithoutCache;
+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) => {
+            callbacks.push({
+                src,
+                fn: (newSrc) => resolve(newSrc),
+            });
+        });
+    }
+    if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'done') {
+        return elem.src;
+    }
+    downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
+    const output = await (0, exports.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable,
+        ffprobeExecutable,
+        remotionRoot,
+        src,
+    });
     callbacks = callbacks.filter((c) => {
         if (c.src === src) {
             c.fn(output);

package/dist/extract-frame-from-video.js

@@ -6,91 +6,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFrameFromVideo = exports.getLastFrameOfVideo = void 0;
 const execa_1 = __importDefault(require("execa"));
 const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmepg_flags_1 = require("./determine-vcodec-ffmepg-flags");
 const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
+const get_can_extract_frames_fast_1 = require("./get-can-extract-frames-fast");
+const get_frame_of_video_slow_1 = require("./get-frame-of-video-slow");
 const get_video_info_1 = require("./get-video-info");
 const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
 const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
 const p_limit_1 = require("./p-limit");
 const perf_1 = require("./perf");
 const truthy_1 = require("./truthy");
+const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
 const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
-const determineVcodecFfmepgFlags = (vcodecFlag) => {
-    return [
-        vcodecFlag === 'vp9' ? '-vcodec' : null,
-        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
-        vcodecFlag === 'vp8' ? '-vcodec' : null,
-        vcodecFlag === 'vp8' ? 'libvpx' : null,
-    ].filter(truthy_1.truthy);
-};
-const determineResizeParams = (needsResize) => {
-    if (needsResize === null) {
-        return [];
-    }
-    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
-};
-// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
-// if the video is corrupted
-const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }) => {
-    console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
-    const actualOffset = `-${duration * 1000 - offset}ms`;
-    const command = [
-        '-itsoffset',
-        actualOffset,
-        ...determineVcodecFfmepgFlags(specialVCodecForTransparency),
-        '-i',
-        src,
-        '-frames:v',
-        '1',
-        '-c:v',
-        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
-        '-f',
-        'image2pipe',
-        ...determineResizeParams(needsResize),
-        '-',
-    ].filter(truthy_1.truthy);
-    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), command);
-    if (!stderr) {
-        throw new Error('unexpectedly did not get stderr');
-    }
-    if (!stdout) {
-        throw new Error('unexpectedly did not get stdout');
-    }
-    const stderrChunks = [];
-    const stdoutChunks = [];
-    const stdErrString = new Promise((resolve, reject) => {
-        stderr.on('data', (d) => stderrChunks.push(d));
-        stderr.on('error', (err) => reject(err));
-        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
-    });
-    const stdoutChunk = new Promise((resolve, reject) => {
-        stdout.on('data', (d) => stdoutChunks.push(d));
-        stdout.on('error', (err) => reject(err));
-        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
-    });
-    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
-    const isEmpty = stdErr.includes('Output file is empty');
-    if (isEmpty) {
-        if (offset > 70) {
-            throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
-        }
-        return getFrameOfVideoSlow({
-            ffmpegExecutable,
-            duration,
-            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
-            offset: offset + (fps === null ? 10 : 1000 / fps),
-            src,
-            imageFormat,
-            specialVCodecForTransparency,
-            needsResize,
-            fps,
-            remotionRoot,
-        });
-    }
-    return stdoutBuffer;
-};
 const getLastFrameOfVideoFastUnlimited = async (options) => {
     const { ffmpegExecutable, ffprobeExecutable, offset, src, downloadMap } = options;
     const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)({ ...options, offset: 0 });
@@ -101,8 +32,9 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     if (duration === null) {
         throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
     }
-    if (options.specialVCodecForTransparency === 'vp8' || offset > 40) {
-        const last = await getFrameOfVideoSlow({
+    if (options.specialVCodecForTransparency === 'vp8' ||
+        offset > get_can_extract_frames_fast_1.ACCEPTABLE_OFFSET_THRESHOLD) {
+        const last = await (0, get_frame_of_video_slow_1.getFrameOfVideoSlow)({
             duration,
             ffmpegExecutable,
             src,
@@ -116,46 +48,15 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
         return last;
     }
     const actualOffset = `${duration * 1000 - offset}ms`;
-    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, options.remotionRoot, 'ffmpeg'), [
-        '-ss',
+    const [stdErr, stdoutBuffer] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
         actualOffset,
-        ...determineVcodecFfmepgFlags(options.specialVCodecForTransparency),
-        '-i',
+        ffmpegExecutable,
+        imageFormat: options.imageFormat,
+        needsResize: options.needsResize,
+        remotionRoot: options.remotionRoot,
+        specialVCodecForTransparency: options.specialVCodecForTransparency,
         src,
-        '-frames:v',
-        '1',
-        '-c:v',
-        options.imageFormat === 'jpeg' ? 'mjpeg' : 'png',
-        '-f',
-        'image2pipe',
-        ...determineResizeParams(options.needsResize),
-        '-',
-    ].filter(truthy_1.truthy));
-    if (!stderr) {
-        throw new Error('unexpectedly did not get stderr');
-    }
-    if (!stdout) {
-        throw new Error('unexpectedly did not get stdout');
-    }
-    const stderrChunks = [];
-    const stdoutChunks = [];
-    const stdErrString = new Promise((resolve, reject) => {
-        stderr.on('data', (d) => stderrChunks.push(d));
-        stderr.on('error', (err) => reject(err));
-        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
-    });
-    const stdoutChunk = new Promise((resolve, reject) => {
-        stdout.on('data', (d) => {
-            stdoutChunks.push(d);
-        });
-        stdout.on('error', (err) => {
-            reject(err);
-        });
-        stdout.on('end', () => {
-            resolve(Buffer.concat(stdoutChunks));
-        });
     });
-    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
     const isEmpty = stdErr.includes('Output file is empty');
     if (isEmpty) {
         const unlimited = await getLastFrameOfVideoFastUnlimited({
@@ -190,10 +91,10 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
         ffmpegExecutable,
         ffprobeExecutable,
     });
-    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable, remotionRoot);
+    const { specialVcodecForTransparency: specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable, remotionRoot);
     if (specialVcodec === 'vp8') {
         const { fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable, remotionRoot);
-        return getFrameOfVideoSlow({
+        return (0, get_frame_of_video_slow_1.getFrameOfVideoSlow)({
             ffmpegExecutable,
             imageFormat,
             specialVCodecForTransparency: specialVcodec,
@@ -223,7 +124,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
     const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-ss',
         ffmpegTimestamp,
-        ...determineVcodecFfmepgFlags(specialVcodec),
+        ...(0, determine_vcodec_ffmepg_flags_1.determineVcodecFfmepgFlags)(specialVcodec),
         '-i',
         src,
         '-frames:v',
@@ -232,7 +133,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
         'image2pipe',
         '-vcodec',
         imageFormat === 'jpeg' ? 'mjpeg' : 'png',
-        ...determineResizeParams(needsResize),
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
         '-',
     ].filter(truthy_1.truthy), {
         buffer: false,

package/dist/ffmpeg-flags.js

@@ -105,7 +105,7 @@ const waitForFfmpegToBeDownloaded = (url) => {
     });
 };
 const onProgress = (downloadedBytes, totalBytesToDownload, binary) => {
-    console.log('Downloading ', [binary], `${toMegabytes(downloadedBytes)}/${toMegabytes(totalBytesToDownload)}`);
+    console.log('Downloading ', binary, `${toMegabytes(downloadedBytes)}/${toMegabytes(totalBytesToDownload)}`);
 };
 const downloadBinary = async (remotionRoot, url, binary) => {
     const destinationPath = getFfmpegAbsolutePath(remotionRoot, binary);

package/dist/get-can-extract-frames-fast.d.ts

@@ -0,0 +1,10 @@
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const ACCEPTABLE_OFFSET_THRESHOLD = 40;
+export declare const getCanExtractFramesFast: ({ src, ffmpegExecutable, ffprobeExecutable, }: {
+    src: string;
+    ffmpegExecutable?: FfmpegExecutable | undefined;
+    ffprobeExecutable?: FfmpegExecutable | undefined;
+}) => Promise<{
+    canExtractFramesFast: boolean;
+    shouldReencode: boolean;
+}>;

package/dist/get-can-extract-frames-fast.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCanExtractFramesFast = exports.ACCEPTABLE_OFFSET_THRESHOLD = void 0;
+const fs_1 = __importDefault(require("fs"));
+const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
+const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const find_closest_package_json_1 = require("./find-closest-package-json");
+const get_video_info_1 = require("./get-video-info");
+const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
+exports.ACCEPTABLE_OFFSET_THRESHOLD = 40;
+const getCanExtractFramesFast = async ({ src, ffmpegExecutable, ffprobeExecutable, }) => {
+    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
+    const out = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src,
+    });
+    const { specialVcodecForTransparency: specialVcodec } = await (0, get_video_info_1.getVideoInfoUncached)({
+        src: out,
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+    });
+    if (specialVcodec === 'vp8') {
+        fs_1.default.unlinkSync(out);
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: false,
+        };
+    }
+    const { duration } = await (0, get_video_stream_duration_1.getVideoStreamDurationwithoutCache)({
+        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
+        remotionRoot,
+        src: out,
+    });
+    if (duration === null) {
+        fs_1.default.unlinkSync(out);
+        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
+    }
+    const actualOffset = `${duration * 1000 - exports.ACCEPTABLE_OFFSET_THRESHOLD}ms`;
+    const [stdErr] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
+        actualOffset,
+        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
+        imageFormat: 'jpeg',
+        // Intentionally leaving needsResize as null, because we don't need to resize
+        needsResize: null,
+        remotionRoot,
+        specialVCodecForTransparency: specialVcodec,
+        src: out,
+    });
+    fs_1.default.unlinkSync(out);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        return {
+            canExtractFramesFast: false,
+            shouldReencode: true,
+        };
+    }
+    return {
+        canExtractFramesFast: true,
+        shouldReencode: false,
+    };
+};
+exports.getCanExtractFramesFast = getCanExtractFramesFast;

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,2 @@
 import type { Codec } from './codec';
-export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
+export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";

package/dist/get-frame-of-video-slow.d.ts

@@ -0,0 +1,17 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const getFrameOfVideoSlow: ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    src: string;
+    duration: number;
+    imageFormat: OffthreadVideoImageFormat;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    needsResize: [
+        number,
+        number
+    ] | null;
+    offset: number;
+    fps: number | null;
+    remotionRoot: string;
+}) => Promise<Buffer>;

package/dist/get-frame-of-video-slow.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFrameOfVideoSlow = void 0;
+// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
+// if the video is corrupted
+const execa_1 = __importDefault(require("execa"));
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmepg_flags_1 = require("./determine-vcodec-ffmepg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const truthy_1 = require("./truthy");
+const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${duration * 1000 - offset}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        ...(0, determine_vcodec_ffmepg_flags_1.determineVcodecFfmepgFlags)(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
+        '-',
+    ].filter(truthy_1.truthy);
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), command);
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => stdoutChunks.push(d));
+        stdout.on('error', (err) => reject(err));
+        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        if (offset > 70) {
+            throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
+        }
+        return (0, exports.getFrameOfVideoSlow)({
+            ffmpegExecutable,
+            duration,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + (fps === null ? 10 : 1000 / fps),
+            src,
+            imageFormat,
+            specialVCodecForTransparency,
+            needsResize,
+            fps,
+            remotionRoot,
+        });
+    }
+    return stdoutBuffer;
+};
+exports.getFrameOfVideoSlow = getFrameOfVideoSlow;

package/dist/get-video-info.d.ts

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

package/dist/get-video-info.js

@@ -3,17 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoInfo = void 0;
+exports.getVideoInfo = exports.getVideoInfoUncached = void 0;
 const execa_1 = __importDefault(require("execa"));
 const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const p_limit_1 = require("./p-limit");
 const limit = (0, p_limit_1.pLimit)(1);
-async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+async function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }) {
     var _a;
-    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
-        return downloadMap.isVp9VideoCache[src];
-    }
     const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), [src]);
     const isVp9 = task.stderr.includes('Video: vp9');
     const isVp8 = task.stderr.includes('Video: vp8');
@@ -38,9 +35,21 @@ async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remoti
         }
     }
     const result = {
-        specialVcodec: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
+        specialVcodecForTransparency: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
         needsResize,
     };
+    return result;
+}
+exports.getVideoInfoUncached = getVideoInfoUncached;
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
+        return downloadMap.isVp9VideoCache[src];
+    }
+    const result = await getVideoInfoUncached({
+        ffprobeExecutable,
+        remotionRoot,
+        src,
+    });
     downloadMap.isVp9VideoCache[src] = result;
     return downloadMap.isVp9VideoCache[src];
 }

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import execa from 'execa';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
 import { mimeContentType, mimeLookup } from './mime-types';
@@ -17,6 +16,7 @@ export { FfmpegExecutable } from './ffmpeg-executable';
 export { FfmpegVersion } from './ffmpeg-flags';
 export type { FfmpegOverrideFn } from './ffmpeg-override';
 export { FrameRange } from './frame-range';
+export { getCanExtractFramesFast } from './get-can-extract-frames-fast';
 export { getCompositions } from './get-compositions';
 export { ImageFormat, StillImageFormat, validateSelectedPixelFormatAndImageFormatCombination, validImageFormats, } from './image-format';
 export type { LogLevel } from './log-level';

package/dist/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderInternals = exports.validateOutputFilename = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.validImageFormats = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.getCompositions = exports.ErrorWithStackFrame = exports.ensureFfprobe = exports.ensureFfmpeg = exports.combineVideos = void 0;
+exports.RenderInternals = exports.validateOutputFilename = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.validImageFormats = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.getCompositions = exports.getCanExtractFramesFast = exports.ErrorWithStackFrame = exports.ensureFfprobe = exports.ensureFfmpeg = exports.combineVideos = void 0;
 const execa_1 = __importDefault(require("execa"));
 const download_file_1 = require("./assets/download-file");
 const download_map_1 = require("./assets/download-map");
@@ -78,6 +78,8 @@ Object.defineProperty(exports, "ensureFfmpeg", { enumerable: true, get: function
 Object.defineProperty(exports, "ensureFfprobe", { enumerable: true, get: function () { return ensure_ffmpeg_1.ensureFfprobe; } });
 var handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
 Object.defineProperty(exports, "ErrorWithStackFrame", { enumerable: true, get: function () { return handle_javascript_exception_1.ErrorWithStackFrame; } });
+var get_can_extract_frames_fast_1 = require("./get-can-extract-frames-fast");
+Object.defineProperty(exports, "getCanExtractFramesFast", { enumerable: true, get: function () { return get_can_extract_frames_fast_1.getCanExtractFramesFast; } });
 var get_compositions_1 = require("./get-compositions");
 Object.defineProperty(exports, "getCompositions", { enumerable: true, get: function () { return get_compositions_1.getCompositions; } });
 var image_format_2 = require("./image-format");

package/dist/redirect-status-codes.d.ts

@@ -0,0 +1 @@
+export declare const redirectStatusCodes: number[];

package/dist/redirect-status-codes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectStatusCodes = void 0;
+exports.redirectStatusCodes = [301, 302, 303, 304, 307, 308];

package/dist/set-props-and-env.js

@@ -5,6 +5,7 @@ const version_1 = require("remotion/version");
 const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const normalize_serve_url_1 = require("./normalize-serve-url");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const redirect_status_codes_1 = require("./redirect-status-codes");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const setPropsAndEnv = async ({ inputProps, envVariables, page, serveUrl, initialFrame, timeoutInMilliseconds, proxyPort, retriesRemaining, audioEnabled, videoEnabled, }) => {
     (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
@@ -63,13 +64,7 @@ const setPropsAndEnv = async ({ inputProps, envVariables, page, serveUrl, initia
             videoEnabled,
         });
     }
-    if (status !== 200 &&
-        status !== 301 &&
-        status !== 302 &&
-        status !== 303 &&
-        status !== 304 &&
-        status !== 307 &&
-        status !== 308) {
+    if (!redirect_status_codes_1.redirectStatusCodes.every((code) => code !== status)) {
         throw new Error(`Error while getting compositions: Tried to go to ${urlToVisit} but the status code was ${status} instead of 200. Does the site you specified exist?`);
     }
     const isRemotionFn = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({

package/dist/stitch-frames-to-video.js

@@ -1,12 +1,34 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stitchFramesToVideo = exports.spawnFfmpeg = void 0;
 const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
-const promises_1 = require("fs/promises");
+const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const remotion_1 = require("remotion");
 const calculate_asset_positions_1 = require("./assets/calculate-asset-positions");
@@ -182,7 +204,8 @@ const spawnFfmpeg = async (options, remotionRoot) => {
         }
         const file = await new Promise((resolve, reject) => {
             if (tempFile) {
-                (0, promises_1.readFile)(tempFile)
+                fs_1.promises
+                    .readFile(tempFile)
                     .then((f) => {
                     return resolve(f);
                 })
@@ -295,7 +318,8 @@ const spawnFfmpeg = async (options, remotionRoot) => {
                 (0, delete_directory_1.deleteDirectory)(options.assetsInfo.downloadMap.stitchFrames);
                 return null;
             }
-            return (0, promises_1.readFile)(tempFile)
+            return fs_1.promises
+                .readFile(tempFile)
                 .then((file) => {
                 return Promise.all([
                     file,

package/dist/try-to-extract-frame-of-video-fast.d.ts

@@ -0,0 +1,12 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { NeedsResize, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const tryToExtractFrameOfVideoFast: ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    remotionRoot: string;
+    imageFormat: OffthreadVideoImageFormat;
+    needsResize: NeedsResize;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    actualOffset: string;
+}) => Promise<readonly [string, Buffer]>;

package/dist/try-to-extract-frame-of-video-fast.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryToExtractFrameOfVideoFast = void 0;
+const execa_1 = __importDefault(require("execa"));
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmepg_flags_1 = require("./determine-vcodec-ffmepg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const truthy_1 = require("./truthy");
+const tryToExtractFrameOfVideoFast = async ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }) => {
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+        '-ss',
+        actualOffset,
+        ...(0, determine_vcodec_ffmepg_flags_1.determineVcodecFfmepgFlags)(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
+        '-',
+    ].filter(truthy_1.truthy));
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => {
+            stdoutChunks.push(d);
+        });
+        stdout.on('error', (err) => {
+            reject(err);
+        });
+        stdout.on('end', () => {
+            resolve(Buffer.concat(stdoutChunks));
+        });
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    return [stdErr, stdoutBuffer];
+};
+exports.tryToExtractFrameOfVideoFast = tryToExtractFrameOfVideoFast;

package/dist/validate-ffmpeg.js

@@ -69,7 +69,7 @@ const validateFfmpeg = async (customFfmpegBinary, remotionRoot, binary) => {
     }
     const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
     if (binaryUrl) {
-        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, 'ffmpeg');
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
         return (0, exports.validateFfmpeg)(customFfmpegBinary, remotionRoot, binary);
     }
     throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/renderer",
-	"version": "3.3.0",
+	"version": "3.3.2",
 	"description": "Renderer for Remotion",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
 	"dependencies": {
 		"execa": "5.1.1",
 		"extract-zip": "2.0.1",
-		"remotion": "3.3.0",
+		"remotion": "3.3.2",
 		"source-map": "^0.8.0-beta.0",
 		"ws": "8.7.0"
 	},
@@ -57,5 +57,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "29322c95729df0229eecc5f674d019145a783b46"
+	"gitHead": "d7422b5d86e4766a4cdb0bc4e291e462a6bf8bb6"
 }