@remotion/renderer 4.0.0-alpha13 → 4.0.0-alpha14

package/dist/prepare-server.d.ts

@@ -1,19 +1,31 @@
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
 import type { Compositor } from './compositor/compositor';
-export declare const prepareServer: ({ onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, remotionRoot, concurrency, verbose, indent, }: {
+import type { OffthreadVideoServerEmitter } from './offthread-video-server';
+import type { AnySourceMapConsumer } from './symbolicate-stacktrace';
+export type RemotionServer = {
+    serveUrl: string;
+    closeServer: (force: boolean) => Promise<unknown>;
+    offthreadPort: number;
+    compositor: Compositor;
+    sourceMap: AnySourceMapConsumer | null;
+    events: OffthreadVideoServerEmitter;
+    downloadMap: DownloadMap;
+};
+type PrepareServerOptions = {
     webpackConfigOrServeUrl: string;
-    onDownload: RenderMediaOnDownload;
-    onError: (err: Error) => void;
     port: number | null;
-    downloadMap: DownloadMap;
     remotionRoot: string;
     concurrency: number;
     verbose: boolean;
     indent: boolean;
+};
+export declare const prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }: PrepareServerOptions) => Promise<RemotionServer>;
+export declare const makeOrReuseServer: (server: RemotionServer | undefined, config: PrepareServerOptions, { onDownload, onError, }: {
+    onError: (err: Error) => void;
+    onDownload: RenderMediaOnDownload | null;
 }) => Promise<{
-    serveUrl: string;
-    closeServer: (force: boolean) => Promise<unknown>;
-    offthreadPort: number;
-    compositor: Compositor;
+    server: RemotionServer;
+    cleanupServer: (force: boolean) => Promise<unknown>;
 }>;
+export {};

package/dist/prepare-server.js

@@ -3,17 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareServer = void 0;
+exports.makeOrReuseServer = exports.prepareServer = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const remotion_1 = require("remotion");
+const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const download_map_1 = require("./assets/download-map");
 const is_serve_url_1 = require("./is-serve-url");
+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 ({ onDownload, onError, webpackConfigOrServeUrl, port, downloadMap, remotionRoot, concurrency, verbose, indent, }) => {
+const prepareServer = async ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }) => {
+    const downloadMap = (0, download_map_1.makeDownloadMap)();
+    logger_1.Log.verboseAdvanced({ indent, logLevel: verbose ? 'verbose' : 'info' }, 'Created directory for temporary files', downloadMap.assetDir);
     if ((0, is_serve_url_1.isServeUrl)(webpackConfigOrServeUrl)) {
-        const { port: offthreadPort, close: closeProxy, compositor: comp, } = await (0, serve_static_1.serveStatic)(null, {
-            onDownload,
-            onError,
+        const { port: offthreadPort, close: closeProxy, compositor: comp, events, } = await (0, serve_static_1.serveStatic)(null, {
             port,
             downloadMap,
             remotionRoot,
@@ -24,10 +29,14 @@ const prepareServer = async ({ onDownload, onError, webpackConfigOrServeUrl, por
         return Promise.resolve({
             serveUrl: webpackConfigOrServeUrl,
             closeServer: () => {
+                (0, download_map_1.cleanDownloadMap)(downloadMap);
                 return closeProxy();
             },
             offthreadPort,
             compositor: comp,
+            sourceMap: null,
+            events,
+            downloadMap,
         });
     }
     // Check if the path has a `index.html` file
@@ -36,9 +45,8 @@ const prepareServer = async ({ onDownload, onError, webpackConfigOrServeUrl, por
     if (!exists) {
         throw new Error(`Tried to serve the Webpack bundle on a HTTP server, but the file ${indexFile} does not exist. Is this a valid path to a Webpack bundle?`);
     }
-    const { port: serverPort, close, compositor, } = await (0, serve_static_1.serveStatic)(webpackConfigOrServeUrl, {
-        onDownload,
-        onError,
+    const sourceMap = (0, symbolicate_stacktrace_1.getSourceMapFromLocalFile)(node_path_1.default.join(webpackConfigOrServeUrl, remotion_1.Internals.bundleName));
+    const { port: serverPort, close, compositor, events: newEvents, } = await (0, serve_static_1.serveStatic)(webpackConfigOrServeUrl, {
         port,
         downloadMap,
         remotionRoot,
@@ -48,6 +56,8 @@ const prepareServer = async ({ onDownload, onError, webpackConfigOrServeUrl, por
     });
     return Promise.resolve({
         closeServer: async (force) => {
+            sourceMap.then((s) => s === null || s === void 0 ? void 0 : s.destroy());
+            (0, download_map_1.cleanDownloadMap)(downloadMap);
             if (!force) {
                 await (0, wait_for_symbolication_error_to_be_done_1.waitForSymbolicationToBeDone)();
             }
@@ -56,6 +66,40 @@ const prepareServer = async ({ onDownload, onError, webpackConfigOrServeUrl, por
         serveUrl: `http://localhost:${serverPort}`,
         offthreadPort: serverPort,
         compositor,
+        sourceMap: await sourceMap,
+        events: newEvents,
+        downloadMap,
     });
 };
 exports.prepareServer = prepareServer;
+const makeOrReuseServer = async (server, config, { onDownload, onError, }) => {
+    if (server) {
+        const cleanupOnDownload = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(server.events, onDownload);
+        const cleanupError = server.events.addEventListener('error', ({ detail: { error } }) => {
+            onError(error);
+        });
+        return {
+            server,
+            cleanupServer: () => {
+                cleanupOnDownload();
+                cleanupError();
+                return Promise.resolve();
+            },
+        };
+    }
+    const newServer = await (0, exports.prepareServer)(config);
+    const cleanupOnDownloadNew = (0, download_and_map_assets_to_file_1.attachDownloadListenerToEmitter)(newServer.events, onDownload);
+    const cleanupErrorNew = newServer.events.addEventListener('error', ({ detail: { error } }) => {
+        onError(error);
+    });
+    return {
+        server: newServer,
+        cleanupServer: (force) => {
+            newServer.closeServer(force);
+            cleanupOnDownloadNew();
+            cleanupErrorNew();
+            return Promise.resolve();
+        },
+    };
+};
+exports.makeOrReuseServer = makeOrReuseServer;

package/dist/preprocess-audio-track.d.ts

@@ -1,14 +1,14 @@
 import type { DownloadMap } from './assets/download-map';
 import type { MediaAsset } from './assets/types';
 import type { ProcessedTrack } from './stringify-ffmpeg-filter';
-declare type Options = {
+type Options = {
     outName: string;
     asset: MediaAsset;
     expectedFrames: number;
     fps: number;
     downloadMap: DownloadMap;
 };
-export declare type PreprocessedAudioTrack = {
+export type PreprocessedAudioTrack = {
     outName: string;
     filter: ProcessedTrack;
 };

package/dist/prespawn-ffmpeg.d.ts

@@ -4,7 +4,7 @@ import type { VideoImageFormat } from './image-format';
 import type { CancelSignal } from './make-cancel-signal';
 import type { PixelFormat } from './pixel-format';
 import type { ProResProfile } from './prores-profile';
-declare type PreStitcherOptions = {
+type PreStitcherOptions = {
     fps: number;
     width: number;
     height: number;

package/dist/prespawn-ffmpeg.js

@@ -33,29 +33,29 @@ const prespawnFfmpeg = (options) => {
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
         logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'encoder',
+        tag: 'prespawnFfmpeg()',
     }, 'encoder', encoderName);
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
         logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'encoder',
+        tag: 'prespawnFfmpeg()',
     }, 'pixelFormat', pixelFormat);
     if (supportsCrf) {
         logger_1.Log.verboseAdvanced({
             indent: options.indent,
             logLevel: options.verbose ? 'verbose' : 'info',
-            tag: 'encoder',
+            tag: 'prespawnFfmpeg()',
         }, 'pixelFormat', options.crf);
     }
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
         logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'encoder',
+        tag: 'prespawnFfmpeg()',
     }, 'codec', codec);
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
         logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'encoder',
+        tag: 'prespawnFfmpeg()',
     }, 'proResProfileName', proResProfileName);
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
     const ffmpegArgs = [
@@ -87,12 +87,12 @@ const prespawnFfmpeg = (options) => {
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
         logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'encoder',
+        tag: 'prespawnFfmpeg()',
     }, 'Generated FFMPEG command:');
     logger_1.Log.verboseAdvanced({
         indent: options.indent,
         logLevel: options.verbose ? 'verbose' : 'info',
-        tag: 'encoder',
+        tag: 'prespawnFfmpeg()',
     }, ffmpegArgs.join(' '));
     const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
     const finalFfmpegString = options.ffmpegOverride

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 declare 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/puppeteer-screenshot.js

@@ -28,7 +28,6 @@ const assert = __importStar(require("node:assert"));
 const screenshot_task_1 = require("./screenshot-task");
 const screenshot = (options) => {
     if (options.jpegQuality) {
-        assert.ok(options.type === 'jpeg', `options.quality is unsupported for the ${options.type} screenshots`);
         assert.ok(typeof options.jpegQuality === 'number', 'Expected options.quality to be a number but found ' +
             typeof options.jpegQuality);
         assert.ok(Number.isInteger(options.jpegQuality), 'Expected options.quality to be an integer');
@@ -42,7 +41,7 @@ const screenshot = (options) => {
         width: options.width,
         omitBackground: options.omitBackground,
         path: options.path,
-        jpegQuality: options.jpegQuality,
+        jpegQuality: options.type === 'jpeg' ? options.jpegQuality : undefined,
         clipRegion: options.clipRegion,
     }));
 };

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

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import type { AnySmallCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-import type { DownloadMap } from './assets/download-map';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
 import type { HeadlessBrowser } from './browser/Browser';
@@ -9,8 +8,38 @@ import type { FrameRange } from './frame-range';
 import type { VideoImageFormat } from './image-format';
 import type { CancelSignal } from './make-cancel-signal';
 import type { ChromiumOptions } from './open-browser';
+import type { RemotionServer } from './prepare-server';
 import type { OnStartData, RenderFramesOutput } from './types';
-declare type RenderFramesOptions = {
+export type InternalRenderFramesOptions = {
+    onStart: null | ((data: OnStartData) => void);
+    onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
+    outputDir: string | null;
+    inputProps: Record<string, unknown>;
+    envVariables: Record<string, string>;
+    imageFormat: VideoImageFormat;
+    jpegQuality: number;
+    frameRange: FrameRange | null;
+    everyNthFrame: number;
+    dumpBrowserLogs: boolean;
+    puppeteerInstance: HeadlessBrowser | undefined;
+    browserExecutable: BrowserExecutable | null;
+    onBrowserLog: null | ((log: BrowserLog) => void);
+    onFrameBuffer: null | ((buffer: Buffer, frame: number) => void);
+    onDownload: RenderMediaOnDownload | null;
+    timeoutInMilliseconds: number;
+    chromiumOptions: ChromiumOptions;
+    scale: number;
+    port: number | null;
+    cancelSignal: CancelSignal | undefined;
+    composition: AnySmallCompMetadata;
+    indent: boolean;
+    server: RemotionServer | undefined;
+    muted: boolean;
+    concurrency: number | string | null;
+    webpackBundleOrServeUrl: string;
+    verbose: boolean;
+};
+export type RenderFramesOptions = {
     onStart: (data: OnStartData) => void;
     onFrameUpdate: (framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void;
     outputDir: string | null;
@@ -36,22 +65,14 @@ declare type RenderFramesOptions = {
     port?: number | null;
     cancelSignal?: CancelSignal;
     composition: AnySmallCompMetadata;
-    /**
-     * @deprecated Only for Remotion internal usage
-     */
-    downloadMap?: DownloadMap;
-    /**
-     * @deprecated Only for Remotion internal usage
-     */
-    indent?: boolean;
     muted?: boolean;
     concurrency?: number | string | null;
     serveUrl: string;
     verbose?: boolean;
 };
+export declare const internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, dumpBrowserLogs, envVariables, everyNthFrame, frameRange, imageFormat, indent, inputProps, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, verbose, webpackBundleOrServeUrl, }: 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)
  */
 export declare const renderFrames: (options: RenderFramesOptions) => Promise<RenderFramesOutput>;
-export {};