@remotion/cli 4.0.77 → 4.0.81

package/dist/preview-server/routes.js

@@ -67,6 +67,8 @@ const handleFallback = async ({ remotionRoot, hash, response, getCurrentInputPro
     const x264Preset = (_b = config_1.ConfigInternals.getPresetProfile()) !== null && _b !== void 0 ? _b : 'medium';
     const audioBitrate = config_1.ConfigInternals.getAudioBitrate();
     const videoBitrate = config_1.ConfigInternals.getVideoBitrate();
+    const encodingBufferSize = config_1.ConfigInternals.getEncodingBufferSize();
+    const encodingMaxRate = config_1.ConfigInternals.getEncodingMaxRate();
     const everyNthFrame = config_1.ConfigInternals.getEveryNthFrame();
     const numberOfGifLoops = config_1.ConfigInternals.getNumberOfGifLoops();
     const delayRenderTimeout = config_1.ConfigInternals.getCurrentPuppeteerTimeout();
@@ -79,6 +81,7 @@ const handleFallback = async ({ remotionRoot, hash, response, getCurrentInputPro
     const openGlRenderer = config_1.ConfigInternals.getChromiumOpenGlRenderer();
     const offthreadVideoCacheSizeInBytes = config_1.ConfigInternals.getOffthreadVideoCacheSizeInBytes();
     const colorSpace = config_1.ConfigInternals.getColorSpace();
+    const userAgent = config_1.ConfigInternals.getChromiumUserAgent();
     const maxConcurrency = renderer_1.RenderInternals.getMaxConcurrency();
     const minConcurrency = renderer_1.RenderInternals.getMinConcurrency();
     const multiProcessOnLinux = config_1.ConfigInternals.getChromiumMultiProcessOnLinux();
@@ -116,6 +119,8 @@ const handleFallback = async ({ remotionRoot, hash, response, getCurrentInputPro
             pixelFormat,
             audioBitrate,
             videoBitrate,
+            encodingBufferSize,
+            encodingMaxRate,
             everyNthFrame,
             numberOfGifLoops,
             delayRenderTimeout,
@@ -127,6 +132,7 @@ const handleFallback = async ({ remotionRoot, hash, response, getCurrentInputPro
             offthreadVideoCacheSizeInBytes,
             colorSpace,
             multiProcessOnLinux,
+            userAgent,
         },
         publicFolderExists: (0, node_fs_1.existsSync)(publicDir) ? publicDir : null,
     }));

package/dist/progress-bar.d.ts

@@ -1,5 +1,5 @@
 import type { CancelSignal } from '@remotion/renderer';
-import type { AggregateRenderProgress } from './progress-types';
+import type { AggregateRenderProgress, BundlingState, CopyingState } from '@remotion/studio';
 export type OverwriteableCliOutput = {
     update: (up: string, newline: boolean) => boolean;
 };
@@ -9,14 +9,6 @@ export declare const createOverwriteableCliOutput: (options: {
     updatesDontOverwrite: boolean;
     indent: boolean;
 }) => OverwriteableCliOutput;
-export type CopyingState = {
-    bytes: number;
-    doneIn: number | null;
-};
-export type BundlingState = {
-    progress: number;
-    doneIn: number | null;
-};
 export type SymbolicLinksState = {
     symlinks: string[];
 };

package/dist/progress-bar.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeRenderingAndStitchingProgress = exports.makeBundlingAndCopyProgress = exports.createOverwriteableCliOutput = void 0;
 const renderer_1 = require("@remotion/renderer");
-const ansi_diff_1 = require("./ansi/ansi-diff");
+const studio_1 = require("@remotion/studio");
 const chalk_1 = require("./chalk");
 const download_progress_1 = require("./download-progress");
-const format_bytes_1 = require("./format-bytes");
 const make_progress_bar_1 = require("./make-progress-bar");
 const truthy_1 = require("./truthy");
 const createOverwriteableCliOutput = (options) => {
@@ -34,7 +33,7 @@ const createOverwriteableCliOutput = (options) => {
             },
         };
     }
-    const diff = new ansi_diff_1.AnsiDiff();
+    const diff = new studio_1.StudioInternals.AnsiDiff();
     (_a = options.cancelSignal) === null || _a === void 0 ? void 0 : _a.call(options, () => {
         process.stdout.write(diff.finish());
     });
@@ -173,7 +172,7 @@ const getGuiProgressSubtitle = (progress) => {
         return `Bundling ${Math.round(progress.bundling.progress * 100)}%`;
     }
     if (progress.copyingState.doneIn === null) {
-        return `Copying public dir ${(0, format_bytes_1.formatBytes)(progress.copyingState.bytes)}`;
+        return `Copying public dir ${studio_1.StudioInternals.formatBytes(progress.copyingState.bytes)}`;
     }
     if (!progress.rendering) {
         return `Getting compositions`;

package/dist/progress-types.d.ts

@@ -1,32 +1,2 @@
-import type { Codec, StitchingState } from '@remotion/renderer';
-import type { BundlingState, CopyingState } from './progress-bar';
-import type { RenderStep } from './step';
-export type DownloadProgress = {
-    name: string;
-    id: number;
-    progress: number | null;
-    totalBytes: number | null;
-    downloaded: number;
-};
-export type RenderingProgressInput = {
-    frames: number;
-    totalFrames: number;
-    steps: RenderStep[];
-    concurrency: number;
-    doneIn: number | null;
-};
-export type StitchingProgressInput = {
-    frames: number;
-    totalFrames: number;
-    doneIn: number | null;
-    stage: StitchingState;
-    codec: Codec;
-};
-export type AggregateRenderProgress = {
-    rendering: RenderingProgressInput | null;
-    stitching: StitchingProgressInput | null;
-    downloads: DownloadProgress[];
-    bundling: BundlingState;
-    copyingState: CopyingState;
-};
+import type { AggregateRenderProgress } from '@remotion/studio';
 export declare const initialAggregateRenderProgress: () => AggregateRenderProgress;

package/dist/render-flows/render.d.ts

@@ -1,7 +1,7 @@
 import type { AudioCodec, Browser, BrowserExecutable, CancelSignal, ChromiumOptions, Codec, ColorSpace, Crf, FfmpegOverrideFn, FrameRange, LogLevel, PixelFormat, ProResProfile, VideoImageFormat, X264Preset } from '@remotion/renderer';
+import type { JobProgressCallback } from '@remotion/studio';
 import type { Loop } from '../config/number-of-gif-loops';
-import type { JobProgressCallback } from '../preview-server/render-queue/job';
-export declare const renderVideoFlow: ({ remotionRoot, fullEntryPoint, indent, logLevel, browserExecutable, browser, chromiumOptions, scale, shouldOutputImageSequence, publicDir, envVariables, puppeteerTimeout, port, height, width, remainingArgs, compositionIdFromUi, entryPointReason, overwrite, quiet, concurrency, frameRange, everyNthFrame, outputLocationFromUI, jpegQuality, onProgress, addCleanupCallback, cancelSignal, crf, uiCodec, uiImageFormat, ffmpegOverride, audioBitrate, muted, enforceAudioTrack, proResProfile, x264Preset, pixelFormat, videoBitrate, numberOfGifLoops, audioCodec, serializedInputPropsWithCustomSchema, disallowParallelEncoding, offthreadVideoCacheSizeInBytes, colorSpace, }: {
+export declare const renderVideoFlow: ({ remotionRoot, fullEntryPoint, indent, logLevel, browserExecutable, browser, chromiumOptions, scale, shouldOutputImageSequence, publicDir, envVariables, puppeteerTimeout, port, height, width, remainingArgs, compositionIdFromUi, entryPointReason, overwrite, quiet, concurrency, frameRange, everyNthFrame, outputLocationFromUI, jpegQuality, onProgress, addCleanupCallback, cancelSignal, crf, uiCodec, uiImageFormat, ffmpegOverride, audioBitrate, muted, enforceAudioTrack, proResProfile, x264Preset, pixelFormat, videoBitrate, encodingMaxRate, encodingBufferSize, numberOfGifLoops, audioCodec, serializedInputPropsWithCustomSchema, disallowParallelEncoding, offthreadVideoCacheSizeInBytes, colorSpace, }: {
     remotionRoot: string;
     fullEntryPoint: string;
     entryPointReason: string;
@@ -37,6 +37,8 @@ export declare const renderVideoFlow: ({ remotionRoot, fullEntryPoint, indent, l
     ffmpegOverride: FfmpegOverrideFn;
     audioBitrate: string | null;
     videoBitrate: string | null;
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
     muted: boolean;
     enforceAudioTrack: boolean;
     proResProfile: ProResProfile | undefined;

package/dist/render-flows/render.js

@@ -47,7 +47,7 @@ const setup_cache_1 = require("../setup-cache");
 const should_use_non_overlaying_logger_1 = require("../should-use-non-overlaying-logger");
 const truthy_1 = require("../truthy");
 const user_passed_output_location_1 = require("../user-passed-output-location");
-const renderVideoFlow = async ({ remotionRoot, fullEntryPoint, indent, logLevel, browserExecutable, browser, chromiumOptions, scale, shouldOutputImageSequence, publicDir, envVariables, puppeteerTimeout, port, height, width, remainingArgs, compositionIdFromUi, entryPointReason, overwrite, quiet, concurrency, frameRange, everyNthFrame, outputLocationFromUI, jpegQuality, onProgress, addCleanupCallback, cancelSignal, crf, uiCodec, uiImageFormat, ffmpegOverride, audioBitrate, muted, enforceAudioTrack, proResProfile, x264Preset, pixelFormat, videoBitrate, numberOfGifLoops, audioCodec, serializedInputPropsWithCustomSchema, disallowParallelEncoding, offthreadVideoCacheSizeInBytes, colorSpace, }) => {
+const renderVideoFlow = async ({ remotionRoot, fullEntryPoint, indent, logLevel, browserExecutable, browser, chromiumOptions, scale, shouldOutputImageSequence, publicDir, envVariables, puppeteerTimeout, port, height, width, remainingArgs, compositionIdFromUi, entryPointReason, overwrite, quiet, concurrency, frameRange, everyNthFrame, outputLocationFromUI, jpegQuality, onProgress, addCleanupCallback, cancelSignal, crf, uiCodec, uiImageFormat, ffmpegOverride, audioBitrate, muted, enforceAudioTrack, proResProfile, x264Preset, pixelFormat, videoBitrate, encodingMaxRate, encodingBufferSize, numberOfGifLoops, audioCodec, serializedInputPropsWithCustomSchema, disallowParallelEncoding, offthreadVideoCacheSizeInBytes, colorSpace, }) => {
     var _a;
     const downloads = [];
     const browserInstance = renderer_1.RenderInternals.internalOpenBrowser({
@@ -294,6 +294,8 @@ const renderVideoFlow = async ({ remotionRoot, fullEntryPoint, indent, logLevel,
         codec,
         audioBitrate,
         videoBitrate,
+        encodingMaxRate,
+        encodingBufferSize,
         onProgress: (update) => {
             stitchingProgress.doneIn =
                 update.encodedDoneIn;

package/dist/render-flows/still.d.ts

@@ -1,5 +1,5 @@
 import type { Browser, BrowserExecutable, CancelSignal, ChromiumOptions, LogLevel, StillImageFormat } from '@remotion/renderer';
-import type { JobProgressCallback } from '../preview-server/render-queue/job';
+import type { JobProgressCallback } from '@remotion/studio';
 export declare const renderStillFlow: ({ remotionRoot, fullEntryPoint, entryPointReason, remainingArgs, browser, browserExecutable, chromiumOptions, envVariables, height, serializedInputPropsWithCustomSchema, overwrite, port, publicDir, puppeteerTimeout, jpegQuality, scale, stillFrame, width, compositionIdFromUi, imageFormatFromUi, logLevel, onProgress, indent, addCleanupCallback, cancelSignal, outputLocationFromUi, offthreadVideoCacheSizeInBytes, }: {
     remotionRoot: string;
     fullEntryPoint: string;

package/dist/render-queue/process-still.d.ts

@@ -0,0 +1,8 @@
+import type { JobProgressCallback, RenderJob } from '@remotion/studio';
+export declare const processStill: ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, }: {
+    job: RenderJob;
+    remotionRoot: string;
+    entryPoint: string;
+    onProgress: JobProgressCallback;
+    addCleanupCallback: (cb: () => void) => void;
+}) => Promise<void>;

package/dist/render-queue/process-still.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStill = void 0;
+const preview_server_1 = require("../config/preview-server");
+const convert_entry_point_to_serve_url_1 = require("../convert-entry-point-to-serve-url");
+const get_cli_options_1 = require("../get-cli-options");
+const still_1 = require("../render-flows/still");
+const processStill = async ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, }) => {
+    if (job.type !== 'still') {
+        throw new Error('Expected still job');
+    }
+    const { publicDir, browserExecutable, browser, puppeteerTimeout } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'still',
+        remotionRoot,
+        logLevel: job.logLevel,
+    });
+    const fullEntryPoint = (0, convert_entry_point_to_serve_url_1.convertEntryPointToServeUrl)(entryPoint);
+    await (0, still_1.renderStillFlow)({
+        remotionRoot,
+        browser,
+        browserExecutable,
+        chromiumOptions: job.chromiumOptions,
+        entryPointReason: 'same as Studio',
+        envVariables: job.envVariables,
+        height: null,
+        fullEntryPoint,
+        serializedInputPropsWithCustomSchema: job.serializedInputPropsWithCustomSchema,
+        overwrite: true,
+        port: (0, preview_server_1.getRendererPortFromConfigFile)(),
+        publicDir,
+        puppeteerTimeout,
+        jpegQuality: job.jpegQuality,
+        remainingArgs: [],
+        scale: job.scale,
+        stillFrame: job.frame,
+        width: null,
+        compositionIdFromUi: job.compositionId,
+        imageFormatFromUi: job.imageFormat,
+        logLevel: job.logLevel,
+        onProgress,
+        indent: true,
+        addCleanupCallback,
+        cancelSignal: job.cancelToken.cancelSignal,
+        outputLocationFromUi: job.outName,
+        offthreadVideoCacheSizeInBytes: job.offthreadVideoCacheSizeInBytes,
+    });
+};
+exports.processStill = processStill;

package/dist/render-queue/process-video.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { JobProgressCallback, RenderJob } from '@remotion/studio';
+export declare const processVideoJob: ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, logLevel, }: {
+    job: RenderJob;
+    remotionRoot: string;
+    entryPoint: string;
+    onProgress: JobProgressCallback;
+    addCleanupCallback: (cb: () => void) => void;
+    logLevel: LogLevel;
+}) => Promise<void>;

package/dist/render-queue/process-video.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processVideoJob = void 0;
+const preview_server_1 = require("../config/preview-server");
+const convert_entry_point_to_serve_url_1 = require("../convert-entry-point-to-serve-url");
+const get_cli_options_1 = require("../get-cli-options");
+const render_1 = require("../render-flows/render");
+const processVideoJob = async ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, logLevel, }) => {
+    var _a, _b, _c;
+    if (job.type !== 'video' && job.type !== 'sequence') {
+        throw new Error('Expected video job');
+    }
+    const { publicDir, browserExecutable, browser, ffmpegOverride } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'still',
+        remotionRoot,
+        logLevel,
+    });
+    const fullEntryPoint = (0, convert_entry_point_to_serve_url_1.convertEntryPointToServeUrl)(entryPoint);
+    await (0, render_1.renderVideoFlow)({
+        remotionRoot,
+        browser,
+        browserExecutable,
+        chromiumOptions: job.chromiumOptions,
+        entryPointReason: 'same as Studio',
+        envVariables: job.envVariables,
+        height: null,
+        fullEntryPoint,
+        serializedInputPropsWithCustomSchema: job.serializedInputPropsWithCustomSchema,
+        overwrite: true,
+        port: (0, preview_server_1.getRendererPortFromConfigFile)(),
+        publicDir,
+        puppeteerTimeout: job.delayRenderTimeout,
+        jpegQuality: (_a = job.jpegQuality) !== null && _a !== void 0 ? _a : undefined,
+        remainingArgs: [],
+        scale: job.scale,
+        width: null,
+        compositionIdFromUi: job.compositionId,
+        logLevel: job.logLevel,
+        onProgress,
+        indent: true,
+        concurrency: job.concurrency,
+        everyNthFrame: job.type === 'video' ? job.everyNthFrame : 1,
+        frameRange: [job.startFrame, job.endFrame],
+        quiet: false,
+        shouldOutputImageSequence: job.type === 'sequence',
+        addCleanupCallback,
+        outputLocationFromUI: job.outName,
+        uiCodec: job.type === 'video' ? job.codec : null,
+        uiImageFormat: job.imageFormat,
+        cancelSignal: job.cancelToken.cancelSignal,
+        crf: job.type === 'video' ? job.crf : null,
+        ffmpegOverride,
+        audioBitrate: job.type === 'video' ? job.audioBitrate : null,
+        muted: job.type === 'video' ? job.muted : true,
+        enforceAudioTrack: job.type === 'video' ? job.enforceAudioTrack : false,
+        proResProfile: job.type === 'video' ? (_b = job.proResProfile) !== null && _b !== void 0 ? _b : undefined : undefined,
+        x264Preset: job.type === 'video' ? (_c = job.x264Preset) !== null && _c !== void 0 ? _c : undefined : undefined,
+        pixelFormat: job.type === 'video' ? job.pixelFormat : 'yuv420p',
+        videoBitrate: job.type === 'video' ? job.videoBitrate : null,
+        encodingBufferSize: job.type === 'video' ? job.encodingBufferSize : null,
+        encodingMaxRate: job.type === 'video' ? job.encodingMaxRate : null,
+        numberOfGifLoops: job.type === 'video' ? job.numberOfGifLoops : null,
+        audioCodec: job.type === 'video' ? job.audioCodec : null,
+        disallowParallelEncoding: job.type === 'video' ? job.disallowParallelEncoding : false,
+        offthreadVideoCacheSizeInBytes: job.offthreadVideoCacheSizeInBytes,
+        colorSpace: job.type === 'video' ? job.colorSpace : 'default',
+    });
+};
+exports.processVideoJob = processVideoJob;

package/dist/render-queue/queue.d.ts

@@ -0,0 +1,11 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { RenderJob, RenderJobWithCleanup } from '@remotion/studio';
+export declare const getRenderQueue: () => RenderJob[];
+export declare const addJob: ({ job, entryPoint, remotionRoot, logLevel, }: {
+    job: RenderJobWithCleanup;
+    entryPoint: string;
+    remotionRoot: string;
+    logLevel: LogLevel;
+}) => void;
+export declare const removeJob: (jobId: string) => void;
+export declare const cancelJob: (jobId: string) => void;

package/dist/render-queue/queue.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelJob = exports.removeJob = exports.addJob = exports.getRenderQueue = void 0;
+const studio_1 = require("@remotion/studio");
+const node_path_1 = __importDefault(require("node:path"));
+const chalk_1 = require("../chalk");
+const config_1 = require("../config");
+const log_1 = require("../log");
+const print_error_1 = require("../print-error");
+const progress_types_1 = require("../progress-types");
+const process_still_1 = require("./process-still");
+const process_video_1 = require("./process-video");
+let jobQueue = [];
+const updateJob = (id, updater) => {
+    jobQueue = jobQueue.map((j) => {
+        if (id === j.id) {
+            return updater(j);
+        }
+        return j;
+    });
+    notifyClientsOfJobUpdate();
+};
+const getRenderQueue = () => {
+    return jobQueue.map((j) => {
+        const { cleanup, ...rest } = j;
+        return rest;
+    });
+};
+exports.getRenderQueue = getRenderQueue;
+const notifyClientsOfJobUpdate = () => {
+    studio_1.StudioInternals.waitForLiveEventsListener().then((listener) => {
+        listener.sendEventToClient({
+            type: 'render-queue-updated',
+            queue: (0, exports.getRenderQueue)(),
+        });
+    });
+};
+const processJob = async ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, logLevel, }) => {
+    if (job.type === 'still') {
+        await (0, process_still_1.processStill)({
+            job,
+            remotionRoot,
+            entryPoint,
+            onProgress,
+            addCleanupCallback,
+        });
+        return;
+    }
+    if (job.type === 'video' || job.type === 'sequence') {
+        await (0, process_video_1.processVideoJob)({
+            job,
+            remotionRoot,
+            entryPoint,
+            onProgress,
+            addCleanupCallback,
+            logLevel,
+        });
+        return;
+    }
+    throw new Error(`Unknown job ${JSON.stringify(job)}`);
+};
+const addJob = ({ job, entryPoint, remotionRoot, logLevel, }) => {
+    jobQueue.push(job);
+    processJobIfPossible({ entryPoint, remotionRoot, logLevel });
+    notifyClientsOfJobUpdate();
+};
+exports.addJob = addJob;
+const removeJob = (jobId) => {
+    jobQueue = jobQueue.filter((job) => {
+        if (job.id === jobId) {
+            job.cleanup.forEach((c) => {
+                c();
+            });
+            return false;
+        }
+        return true;
+    });
+    notifyClientsOfJobUpdate();
+};
+exports.removeJob = removeJob;
+const cancelJob = (jobId) => {
+    for (const job of jobQueue) {
+        if (job.id === jobId) {
+            if (job.status !== 'running') {
+                throw new Error('Job is not running');
+            }
+            job.cancelToken.cancel();
+            break;
+        }
+    }
+};
+exports.cancelJob = cancelJob;
+const processJobIfPossible = async ({ remotionRoot, entryPoint, logLevel, }) => {
+    const runningJob = jobQueue.find((q) => {
+        return q.status === 'running';
+    });
+    if (runningJob) {
+        return;
+    }
+    const nextJob = jobQueue.find((q) => {
+        return q.status === 'idle';
+    });
+    if (!nextJob) {
+        return;
+    }
+    const jobCleanups = [];
+    try {
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'running',
+                progress: {
+                    value: 0,
+                    message: 'Starting job...',
+                    ...(0, progress_types_1.initialAggregateRenderProgress)(),
+                },
+            };
+        });
+        const startTime = Date.now();
+        log_1.Log.info(chalk_1.chalk.gray('╭─ Starting render '));
+        let lastProgress = null;
+        await processJob({
+            job: nextJob,
+            entryPoint,
+            remotionRoot,
+            onProgress: (progress) => {
+                updateJob(nextJob.id, (job) => {
+                    lastProgress = progress;
+                    // Ignore late callbacks of progress updates after cancelling
+                    if (job.status === 'failed' || job.status === 'done') {
+                        return job;
+                    }
+                    if (job.type === 'still') {
+                        return {
+                            ...job,
+                            status: 'running',
+                            progress,
+                        };
+                    }
+                    if (job.type === 'video') {
+                        return {
+                            ...job,
+                            status: 'running',
+                            progress,
+                        };
+                    }
+                    if (job.type === 'sequence') {
+                        return {
+                            ...job,
+                            status: 'running',
+                            progress,
+                        };
+                    }
+                    throw new Error('Unknown job type');
+                });
+            },
+            addCleanupCallback: (cleanup) => {
+                jobCleanups.push(cleanup);
+            },
+            logLevel,
+        });
+        log_1.Log.info(chalk_1.chalk.gray('╰─ Done in ' + (Date.now() - startTime) + 'ms.'));
+        const { unwatch } = studio_1.StudioInternals.installFileWatcher({
+            file: node_path_1.default.resolve(remotionRoot, nextJob.outName),
+            onChange: (type) => {
+                if (type === 'created') {
+                    updateJob(nextJob.id, (job) => ({
+                        ...job,
+                        deletedOutputLocation: false,
+                    }));
+                }
+                if (type === 'deleted') {
+                    updateJob(nextJob.id, (job) => ({
+                        ...job,
+                        deletedOutputLocation: true,
+                    }));
+                }
+            },
+        });
+        updateJob(nextJob.id, (job) => {
+            if (!lastProgress) {
+                throw new Error('expected progress');
+            }
+            return {
+                ...job,
+                status: 'done',
+                cleanup: [...job.cleanup, unwatch],
+                progress: { message: 'Done', value: 1, ...lastProgress },
+            };
+        });
+    }
+    catch (err) {
+        log_1.Log.error(chalk_1.chalk.gray('╰─ '), chalk_1.chalk.red('Failed to render'));
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'failed',
+                error: {
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        });
+        await (0, print_error_1.printError)(err, config_1.ConfigInternals.Logging.getLogLevel());
+        studio_1.StudioInternals.waitForLiveEventsListener().then((listener) => {
+            listener.sendEventToClient({
+                type: 'render-job-failed',
+                compositionId: nextJob.compositionId,
+                error: err,
+            });
+        });
+    }
+    finally {
+        await Promise.all(jobCleanups.map((c) => c()));
+    }
+    processJobIfPossible({ remotionRoot, entryPoint, logLevel });
+};

package/dist/render.js

@@ -25,7 +25,7 @@ const render = async (remotionRoot, args, logLevel) => {
         log_1.Log.error('--frame flag was passed to the `render` command. This flag only works with the `still` command. Did you mean `--frames`? See reference: https://www.remotion.dev/docs/cli/');
         process.exit(1);
     }
-    const { concurrency, frameRange, shouldOutputImageSequence, overwrite, inputProps, envVariables, jpegQuality, browser, browserExecutable, scale, chromiumOptions, everyNthFrame, puppeteerTimeout, publicDir, height, width, crf, ffmpegOverride, audioBitrate, muted, enforceAudioTrack, proResProfile, x264Preset, pixelFormat, videoBitrate, numberOfGifLoops, offthreadVideoCacheSizeInBytes, colorSpace, } = await (0, get_cli_options_1.getCliOptions)({
+    const { concurrency, frameRange, shouldOutputImageSequence, overwrite, inputProps, envVariables, jpegQuality, browser, browserExecutable, scale, chromiumOptions, everyNthFrame, puppeteerTimeout, publicDir, height, width, crf, ffmpegOverride, audioBitrate, muted, enforceAudioTrack, proResProfile, x264Preset, pixelFormat, videoBitrate, encodingMaxRate, encodingBufferSize, numberOfGifLoops, offthreadVideoCacheSizeInBytes, colorSpace, } = await (0, get_cli_options_1.getCliOptions)({
         isLambda: false,
         type: 'series',
         remotionRoot,
@@ -79,6 +79,8 @@ const render = async (remotionRoot, args, logLevel) => {
         x264Preset,
         pixelFormat,
         videoBitrate,
+        encodingMaxRate,
+        encodingBufferSize,
         numberOfGifLoops,
         audioCodec,
         disallowParallelEncoding: false,

package/dist/setup-cache.d.ts

@@ -1,5 +1,5 @@
 import type { LogLevel } from '@remotion/renderer';
-import type { BundlingState, CopyingState } from './progress-bar';
+import type { BundlingState, CopyingState } from '@remotion/studio';
 export declare const bundleOnCliOrTakeServeUrl: ({ fullPath, remotionRoot, publicDir, onProgress, indentOutput, logLevel, bundlingStep, steps, onDirectoryCreated, quietProgress, }: {
     fullPath: string;
     remotionRoot: string;