@remotion/renderer 4.0.22 → 4.0.24

package/dist/open-browser.d.ts

@@ -3,7 +3,7 @@ import type { HeadlessBrowser } from './browser/Browser';
 import type { Viewport } from './browser/PuppeteerViewport';
 import { type LogLevel } from './log-level';
 declare const validRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
-type OpenGlRenderer = typeof validRenderers[number];
+type OpenGlRenderer = (typeof validRenderers)[number];
 export type ChromiumOptions = {
     ignoreCertificateErrors?: boolean;
     disableWebSecurity?: boolean;

package/dist/options/audio-bitrate.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const audioBitrateOption: RemotionOption;
+export declare const audioBitrateOption: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: string;
+};

package/dist/options/audio-bitrate.js

@@ -8,4 +8,5 @@ exports.audioBitrateOption = {
     description: ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Specify the target bitrate for the generated video. The syntax for FFMPEGs", (0, jsx_runtime_1.jsx)("code", { children: "-b:a" }), " parameter should be used. FFMPEG may encode the video in a way that will not result in the exact audio bitrate specified. Example values: ", (0, jsx_runtime_1.jsx)("code", { children: "512K" }), " for 512 kbps, ", (0, jsx_runtime_1.jsx)("code", { children: "1M" }), " for 1 Mbps. Default: ", (0, jsx_runtime_1.jsx)("code", { children: "320k" })] })),
     ssrName: 'audioBitrate',
     docLink: 'https://www.remotion.dev/docs/renderer/render-media#audiobitrate-',
+    type: '0',
 };

package/dist/options/crf.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const crfOption: RemotionOption;
+export declare const crfOption: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: number;
+};

package/dist/options/crf.js

@@ -8,4 +8,5 @@ exports.crfOption = {
     description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "No matter which codec you end up using, there's always a tradeoff between file size and video quality. You can control it by setting the CRF (Constant Rate Factor). The lower the number, the better the quality, the higher the number, the smaller the file is \u2013 of course at the cost of quality." })),
     ssrName: 'crf',
     docLink: 'https://www.remotion.dev/docs/encoding/#controlling-quality-using-the-crf-setting',
+    type: 0,
 };

package/dist/options/enforce-audio.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const enforceAudioOption: RemotionOption;
+export declare const enforceAudioOption: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+};

package/dist/options/enforce-audio.js

@@ -8,4 +8,5 @@ exports.enforceAudioOption = {
     description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "Render a silent audio track if there would be none otherwise." })),
     ssrName: 'enforceAudioTrack',
     docLink: 'https://www.remotion.dev/docs/config#setenforceaudiotrack-',
+    type: false,
 };

package/dist/options/jpeg-quality.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const jpegQualityOption: RemotionOption;
+export declare const jpegQualityOption: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: number;
+};

package/dist/options/jpeg-quality.js

@@ -8,4 +8,5 @@ exports.jpegQualityOption = {
     description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "Sets the quality of the generated JPEG images. Must be an integer between 0 and 100. Default: 80." })),
     ssrName: 'jpegQuality',
     docLink: 'https://www.remotion.dev/docs/renderer/render-media#jpeg-quality',
+    type: 0,
 };

package/dist/options/mute.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const muteOption: RemotionOption;
+export declare const muteOption: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+};

package/dist/options/mute.js

@@ -8,4 +8,5 @@ exports.muteOption = {
     description: (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "The Audio of the video will be omitted." }),
     ssrName: 'muted',
     docLink: 'https://www.remotion.dev/docs/using-audio/#muted-property',
+    type: false,
 };

package/dist/options/offthreadvideo-cache-size.d.ts

@@ -0,0 +1,9 @@
+export declare const offthreadVideoCacheSizeInBytesOption: {
+    name: string;
+    cliFlag: "offthreadvideo-cache-size-in-bytes";
+    description: JSX.Element;
+    ssrName: "offthreadVideoCacheSizeInBytes";
+    docLink: string;
+    type: number | null;
+};
+export declare const validateOffthreadVideoCacheSizeInBytes: (option: unknown) => void;

package/dist/options/offthreadvideo-cache-size.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOffthreadVideoCacheSizeInBytes = exports.offthreadVideoCacheSizeInBytesOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+exports.offthreadVideoCacheSizeInBytesOption = {
+    name: 'OffthreadVideo cache size',
+    cliFlag: 'offthreadvideo-cache-size-in-bytes',
+    description: ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["From v4.0, Remotion has a cache for", ' ', (0, jsx_runtime_1.jsx)("a", { href: "https://remotion.dev/docs/offthreadvideo", children: (0, jsx_runtime_1.jsx)("code", { children: "<OffthreadVideo>" }) }), ' ', "frames. The default is ", (0, jsx_runtime_1.jsx)("code", { children: "null" }), ", corresponding to half of the system memory available when the render starts.", (0, jsx_runtime_1.jsx)("br", {}), " This option allows to override the size of the cache. The higher it is, the faster the render will be, but the more memory will be used.", (0, jsx_runtime_1.jsx)("br", {}), "The used value will be printed when running in verbose mode.", (0, jsx_runtime_1.jsx)("br", {}), "Default: ", (0, jsx_runtime_1.jsx)("code", { children: "null" })] })),
+    ssrName: 'offthreadVideoCacheSizeInBytes',
+    docLink: 'https://www.remotion.dev/docs/offthreadvideo',
+    type: 0,
+};
+const validateOffthreadVideoCacheSizeInBytes = (option) => {
+    if (option === undefined || option === null) {
+        return;
+    }
+    if (typeof option !== 'number') {
+        throw new Error('Expected a number');
+    }
+    if (option < 0) {
+        throw new Error('Expected a positive number');
+    }
+    if (Number.isNaN(option)) {
+        throw new Error('Expected a number');
+    }
+    if (!Number.isFinite(option)) {
+        throw new Error('Expected a finite number');
+    }
+    if (option % 1 !== 0) {
+        throw new Error('Expected a whole number');
+    }
+};
+exports.validateOffthreadVideoCacheSizeInBytes = validateOffthreadVideoCacheSizeInBytes;

package/dist/options/option.d.ts

@@ -1,8 +1,13 @@
 import type React from 'react';
-export type RemotionOption = {
+export type RemotionOption<SsrName extends string, Type> = {
     name: string;
     cliFlag: string;
-    ssrName: string;
+    ssrName: SsrName;
     description: React.ReactNode;
     docLink: string;
+    type: Type;
+};
+export type AnyRemotionOption = RemotionOption<string, unknown>;
+export type ToOptions<T extends readonly AnyRemotionOption[]> = {
+    [K in T[number]['ssrName']]: T[number]['type'];
 };

package/dist/options/options-map.d.ts

@@ -0,0 +1,82 @@
+export declare const optionsMap: {
+    readonly renderMedia: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly renderStill: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly getCompositions: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly selectComposition: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly renderFrames: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly renderMediaOnLambda: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly renderStillOnLambda: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly getCompositionsOnLambda: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly renderMediaOnCloudRun: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+    readonly renderStillOnCloudRun: readonly [{
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+    }];
+};

package/dist/options/options-map.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionsMap = void 0;
+const offthreadvideo_cache_size_1 = require("./offthreadvideo-cache-size");
+exports.optionsMap = {
+    renderMedia: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    renderStill: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    getCompositions: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    selectComposition: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    renderFrames: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    renderMediaOnLambda: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    renderStillOnLambda: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    getCompositionsOnLambda: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    renderMediaOnCloudRun: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+    renderStillOnCloudRun: [offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption],
+};

package/dist/options/scale.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const scaleOption: RemotionOption;
+export declare const scaleOption: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: number;
+};

package/dist/options/scale.js

@@ -8,4 +8,5 @@ exports.scaleOption = {
     description: ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Scales the output by a factor. For example, a 1280x720px frame will become a 1920x1080px frame with a scale factor of ", (0, jsx_runtime_1.jsx)("code", { children: "1.5" }), ". Vector elements like fonts and HTML markups will be rendered with extra details."] })),
     ssrName: 'scale',
     docLink: 'https://www.remotion.dev/docs/scaling',
+    type: 0,
 };

package/dist/options/video-bitrate.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const videoBitrate: RemotionOption;
+export declare const videoBitrate: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: string;
+};

package/dist/options/video-bitrate.js

@@ -8,4 +8,5 @@ exports.videoBitrate = {
     description: ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Specify the target bitrate for the generated video. The syntax for FFMPEGs", (0, jsx_runtime_1.jsx)("code", { children: "-b:v" }), " parameter should be used. FFMPEG may encode the video in a way that will not result in the exact video bitrate specified. Example values: ", (0, jsx_runtime_1.jsx)("code", { children: "512K" }), " for 512 kbps, ", (0, jsx_runtime_1.jsx)("code", { children: "1M" }), " for 1 Mbps."] })),
     ssrName: 'videoBitrate',
     docLink: 'https://www.remotion.dev/docs/renderer/render-media#videobitrate-',
+    type: '',
 };

package/dist/options/video-codec.d.ts

@@ -1,2 +1,8 @@
-import type { RemotionOption } from './option';
-export declare const videoCodecOption: RemotionOption;
+export declare const videoCodecOption: {
+    name: string;
+    cliFlag: string;
+    description: JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: string;
+};

package/dist/options/video-codec.js

@@ -8,4 +8,5 @@ exports.videoCodecOption = {
     description: ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "H264 works well in most cases, but sometimes it's worth going for a different codec. WebM achieves higher compression but is slower to render. WebM and ProRes support transparency." })),
     ssrName: 'codec',
     docLink: 'https://www.remotion.dev/docs/encoding/#choosing-a-codec',
+    type: '',
 };

package/dist/pixel-format.d.ts

@@ -1,5 +1,5 @@
 import type { Codec } from './codec';
 export declare const validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
-export type PixelFormat = typeof validPixelFormats[number];
+export type PixelFormat = (typeof validPixelFormats)[number];
 export declare const DEFAULT_PIXEL_FORMAT: PixelFormat;
 export declare const validateSelectedPixelFormatAndCodecCombination: (pixelFormat: PixelFormat | undefined, codec: Codec) => undefined;

package/dist/prepare-server.d.ts

@@ -18,8 +18,9 @@ type PrepareServerOptions = {
     concurrency: number;
     logLevel: LogLevel;
     indent: boolean;
+    offthreadVideoCacheSizeInBytes: number | null;
 };
-export declare const prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, }: PrepareServerOptions) => Promise<RemotionServer>;
+export declare const prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, offthreadVideoCacheSizeInBytes, }: PrepareServerOptions) => Promise<RemotionServer>;
 export declare const makeOrReuseServer: (server: RemotionServer | undefined, config: PrepareServerOptions, { onDownload, onError, }: {
     onError: (err: Error) => void;
     onDownload: RenderMediaOnDownload | null;

package/dist/prepare-server.js

@@ -15,7 +15,7 @@ const logger_1 = require("./logger");
 const serve_static_1 = require("./serve-static");
 const symbolicate_stacktrace_1 = require("./symbolicate-stacktrace");
 const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
-const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, }) => {
+const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, logLevel, indent, offthreadVideoCacheSizeInBytes, }) => {
     const downloadMap = (0, download_map_1.makeDownloadMap)();
     logger_1.Log.verboseAdvanced({ indent, logLevel }, 'Created directory for temporary files', downloadMap.assetDir);
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
@@ -26,6 +26,7 @@ const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, conc
             concurrency,
             logLevel,
             indent,
+            offthreadVideoCacheSizeInBytes,
         });
         return Promise.resolve({
             serveUrl: webpackConfigOrServeUrl,
@@ -56,6 +57,7 @@ const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, conc
         concurrency,
         logLevel,
         indent,
+        offthreadVideoCacheSizeInBytes,
     });
     return Promise.resolve({
         closeServer: async (force) => {

package/dist/prores-profile.d.ts

@@ -1,6 +1,6 @@
 import type { Codec } from './codec';
 export declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
-export type ProResProfile = typeof proResProfileOptions[number];
+export type ProResProfile = (typeof proResProfileOptions)[number];
 export declare const validateSelectedCodecAndProResCombination: ({ codec, proResProfile, }: {
     codec: Codec;
     proResProfile: ProResProfile | undefined;

package/dist/provide-screenshot.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
 import type { StillImageFormat } from './image-format';

package/dist/puppeteer-screenshot.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { ClipRegion } from 'remotion';
 import type { Page } from './browser/BrowserPage';
 import type { StillImageFormat } from './image-format';

package/dist/quality.d.ts

@@ -0,0 +1 @@
+export declare const validateQuality: (q: number | undefined) => void;

package/dist/quality.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQuality = void 0;
+const validateQuality = (q) => {
+    if (typeof q !== 'undefined' && typeof q !== 'number') {
+        throw new Error(`Quality option must be a number or undefined. Got ${typeof q} (${JSON.stringify(q)})`);
+    }
+    if (typeof q === 'undefined') {
+        return;
+    }
+    if (!Number.isFinite(q)) {
+        throw new RangeError(`Quality must be a finite number, but is ${q}`);
+    }
+    if (Number.isNaN(q)) {
+        throw new RangeError(`Quality is NaN, but must be a real number`);
+    }
+    if (q > 100 || q < 0) {
+        throw new RangeError('Quality option must be between 0 and 100.');
+    }
+};
+exports.validateQuality = validateQuality;

package/dist/render-frames.d.ts

@@ -9,6 +9,8 @@ import type { VideoImageFormat } from './image-format';
 import { type LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
 import type { RemotionServer } from './prepare-server';
 import type { OnStartData, RenderFramesOutput } from './types';
 export type InternalRenderFramesOptions = {
@@ -39,7 +41,7 @@ export type InternalRenderFramesOptions = {
     logLevel: LogLevel;
     serializedInputPropsWithCustomSchema: string;
     serializedResolvedPropsWithCustomSchema: string;
-};
+} & ToOptions<typeof optionsMap.renderFrames>;
 export type RenderFramesOptions = {
     onStart: (data: OnStartData) => void;
     onFrameUpdate: (framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void;
@@ -77,8 +79,9 @@ export type RenderFramesOptions = {
     muted?: boolean;
     concurrency?: number | string | null;
     serveUrl: string;
+    offthreadVideoCacheSizeInBytes?: number | null;
 };
-export declare const internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, }: InternalRenderFramesOptions) => Promise<RenderFramesOutput>;
+export declare const internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, offthreadVideoCacheSizeInBytes, }: InternalRenderFramesOptions) => Promise<RenderFramesOutput>;
 /**
  * @description Renders a series of images using Puppeteer and computes information for mixing audio.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/render-frames)

package/dist/render-frames.js

@@ -299,7 +299,7 @@ const innerRenderFrames = async ({ onFrameUpdate, outputDir, onStart, serialized
     await Promise.all(downloadPromises);
     return result;
 };
-const internalRenderFrames = ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, }) => {
+const internalRenderFrames = ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, envVariables, everyNthFrame, frameRange, imageFormat, indent, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, logLevel, webpackBundleOrServeUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, offthreadVideoCacheSizeInBytes, }) => {
     remotion_1.Internals.validateDimension(composition.height, 'height', 'in the `config` object passed to `renderFrames()`');
     remotion_1.Internals.validateDimension(composition.width, 'width', 'in the `config` object passed to `renderFrames()`');
     remotion_1.Internals.validateFps(composition.fps, 'in the `config` object of `renderFrames()`', false);
@@ -340,6 +340,7 @@ const internalRenderFrames = ({ browserExecutable, cancelSignal, chromiumOptions
                     concurrency: actualConcurrency,
                     logLevel,
                     indent,
+                    offthreadVideoCacheSizeInBytes,
                 }, {
                     onDownload,
                     onError,
@@ -425,7 +426,7 @@ exports.internalRenderFrames = internalRenderFrames;
  * @see [Documentation](https://www.remotion.dev/docs/renderer/render-frames)
  */
 const renderFrames = (options) => {
-    const { composition, inputProps, onFrameUpdate, onStart, outputDir, serveUrl, browserExecutable, cancelSignal, chromiumOptions, concurrency, dumpBrowserLogs, envVariables, everyNthFrame, frameRange, imageFormat, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, port, puppeteerInstance, scale, timeoutInMilliseconds, verbose, quality, logLevel, } = options;
+    const { composition, inputProps, onFrameUpdate, onStart, outputDir, serveUrl, browserExecutable, cancelSignal, chromiumOptions, concurrency, dumpBrowserLogs, envVariables, everyNthFrame, frameRange, imageFormat, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, port, puppeteerInstance, scale, timeoutInMilliseconds, verbose, quality, logLevel, offthreadVideoCacheSizeInBytes, } = options;
     if (!composition) {
         throw new Error('No `composition` option has been specified for renderFrames()');
     }
@@ -471,6 +472,7 @@ const renderFrames = (options) => {
         timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
         webpackBundleOrServeUrl: serveUrl,
         server: undefined,
+        offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : null,
     });
 };
 exports.renderFrames = renderFrames;

package/dist/render-media.d.ts

@@ -12,6 +12,8 @@ import type { VideoImageFormat } from './image-format';
 import { type LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
 import type { PixelFormat } from './pixel-format';
 import type { RemotionServer } from './prepare-server';
 import type { ProResProfile } from './prores-profile';
@@ -72,7 +74,7 @@ export type InternalRenderMediaOptions = {
     audioCodec: AudioCodec | null;
     serveUrl: string;
     concurrency: number | string | null;
-};
+} & ToOptions<typeof optionsMap.renderMedia>;
 export type RenderMediaOptions = {
     outputLocation?: string | null;
     codec: Codec;
@@ -123,16 +125,17 @@ export type RenderMediaOptions = {
     serveUrl: string;
     concurrency?: number | string | null;
     logLevel?: LogLevel;
+    offthreadVideoCacheSizeInBytes?: number | null;
 };
 type RenderMediaResult = {
     buffer: Buffer | null;
     slowestFrames: SlowFrame[];
 };
-export declare const internalRenderMedia: ({ proResProfile, x264Preset, crf, composition, serializedInputPropsWithCustomSchema, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, logLevel, serializedResolvedPropsWithCustomSchema, }: InternalRenderMediaOptions) => Promise<RenderMediaResult>;
+export declare const internalRenderMedia: ({ proResProfile, x264Preset, crf, composition, serializedInputPropsWithCustomSchema, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, logLevel, serializedResolvedPropsWithCustomSchema, offthreadVideoCacheSizeInBytes, }: InternalRenderMediaOptions) => Promise<RenderMediaResult>;
 /**
  *
  * @description Render a video from a composition
  * @see [Documentation](https://www.remotion.dev/docs/renderer/render-media)
  */
-export declare const renderMedia: ({ proResProfile, x264Preset, crf, composition, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, jpegQuality, concurrency, serveUrl, disallowParallelEncoding, everyNthFrame, imageFormat, numberOfGifLoops, dumpBrowserLogs, preferLossless, verbose, quality, logLevel, }: RenderMediaOptions) => Promise<RenderMediaResult>;
+export declare const renderMedia: ({ proResProfile, x264Preset, crf, composition, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, jpegQuality, concurrency, serveUrl, disallowParallelEncoding, everyNthFrame, imageFormat, numberOfGifLoops, dumpBrowserLogs, preferLossless, verbose, quality, logLevel, offthreadVideoCacheSizeInBytes, }: RenderMediaOptions) => Promise<RenderMediaResult>;
 export {};

package/dist/render-media.js

@@ -44,7 +44,7 @@ const validate_scale_1 = require("./validate-scale");
 const validate_videobitrate_1 = require("./validate-videobitrate");
 const x264_preset_1 = require("./x264-preset");
 const SLOWEST_FRAME_COUNT = 10;
-const internalRenderMedia = ({ proResProfile, x264Preset, crf, composition, serializedInputPropsWithCustomSchema, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, logLevel, serializedResolvedPropsWithCustomSchema, }) => {
+const internalRenderMedia = ({ proResProfile, x264Preset, crf, composition, serializedInputPropsWithCustomSchema, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, logLevel, serializedResolvedPropsWithCustomSchema, offthreadVideoCacheSizeInBytes, }) => {
     (0, jpeg_quality_1.validateJpegQuality)(jpegQuality);
     (0, crf_1.validateQualitySettings)({ crf, codec, videoBitrate });
     (0, validate_videobitrate_1.validateBitrate)(audioBitrate, 'audioBitrate');
@@ -235,6 +235,7 @@ const internalRenderMedia = ({ proResProfile, x264Preset, crf, composition, seri
                 remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
                 logLevel,
                 webpackConfigOrServeUrl: serveUrl,
+                offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : null,
             }, {
                 onDownload,
                 onError: (err) => reject(err),
@@ -298,6 +299,7 @@ const internalRenderMedia = ({ proResProfile, x264Preset, crf, composition, seri
                 indent,
                 server,
                 serializedResolvedPropsWithCustomSchema,
+                offthreadVideoCacheSizeInBytes,
             });
             return renderFramesProc;
         })
@@ -417,7 +419,7 @@ exports.internalRenderMedia = internalRenderMedia;
  * @description Render a video from a composition
  * @see [Documentation](https://www.remotion.dev/docs/renderer/render-media)
  */
-const renderMedia = ({ proResProfile, x264Preset, crf, composition, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, jpegQuality, concurrency, serveUrl, disallowParallelEncoding, everyNthFrame, imageFormat, numberOfGifLoops, dumpBrowserLogs, preferLossless, verbose, quality, logLevel, }) => {
+const renderMedia = ({ proResProfile, x264Preset, crf, composition, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, jpegQuality, concurrency, serveUrl, disallowParallelEncoding, everyNthFrame, imageFormat, numberOfGifLoops, dumpBrowserLogs, preferLossless, verbose, quality, logLevel, offthreadVideoCacheSizeInBytes, }) => {
     var _a, _b;
     if (quality !== undefined) {
         console.warn(`The "quality" option has been renamed. Please use "jpegQuality" instead.`);
@@ -472,6 +474,7 @@ const renderMedia = ({ proResProfile, x264Preset, crf, composition, inputProps,
             staticBase: null,
             data: (_b = composition.props) !== null && _b !== void 0 ? _b : {},
         }).serializedString,
+        offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : null,
     });
 };
 exports.renderMedia = renderMedia;

package/dist/render-still.d.ts

@@ -8,6 +8,8 @@ import type { StillImageFormat } from './image-format';
 import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
 import type { RemotionServer } from './prepare-server';
 type InternalRenderStillOptions = {
     composition: VideoConfig;
@@ -32,7 +34,8 @@ type InternalRenderStillOptions = {
     logLevel: LogLevel;
     serveUrl: string;
     port: number | null;
-};
+    offthreadVideoCacheSizeInBytes: number | null;
+} & ToOptions<typeof optionsMap.renderStill>;
 export type RenderStillOptions = {
     port?: number | null;
     composition: VideoConfig;
@@ -64,6 +67,7 @@ export type RenderStillOptions = {
      * @deprecated Renamed to `jpegQuality`
      */
     quality?: never;
+    offthreadVideoCacheSizeInBytes?: number | null;
 };
 type RenderStillReturnValue = {
     buffer: Buffer | null;

package/dist/render-still.js

@@ -204,6 +204,7 @@ const internalRenderStill = (options) => {
             concurrency: 1,
             logLevel: options.logLevel,
             indent: options.indent,
+            offthreadVideoCacheSizeInBytes: options.offthreadVideoCacheSizeInBytes,
         }, {
             onDownload: options.onDownload,
             onError,
@@ -247,7 +248,7 @@ exports.internalRenderStill = internalRenderStill;
  */
 const renderStill = (options) => {
     var _a, _b;
-    const { composition, serveUrl, browserExecutable, cancelSignal, chromiumOptions, dumpBrowserLogs, envVariables, frame, imageFormat, inputProps, jpegQuality, onBrowserLog, onDownload, output, overwrite, port, puppeteerInstance, scale, timeoutInMilliseconds, verbose, quality, } = options;
+    const { composition, serveUrl, browserExecutable, cancelSignal, chromiumOptions, dumpBrowserLogs, envVariables, frame, imageFormat, inputProps, jpegQuality, onBrowserLog, onDownload, output, overwrite, port, puppeteerInstance, scale, timeoutInMilliseconds, verbose, quality, offthreadVideoCacheSizeInBytes, } = options;
     if (typeof jpegQuality !== 'undefined' && imageFormat !== 'jpeg') {
         throw new Error("You can only pass the `quality` option if `imageFormat` is 'jpeg'.");
     }
@@ -285,6 +286,7 @@ const renderStill = (options) => {
             staticBase: null,
             data: (_b = composition.props) !== null && _b !== void 0 ? _b : {},
         }).serializedString,
+        offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : null,
     });
 };
 exports.renderStill = renderStill;