@remotion/renderer 4.1.0-alpha1 → 4.1.0-alpha11

package/dist/client.d.ts

@@ -12,7 +12,7 @@ export declare const BrowserSafeApis: {
         readonly h264: readonly ["aac", "pcm-16"];
         readonly 'h264-mkv': readonly ["pcm-16"];
         readonly aac: readonly ["aac", "pcm-16"];
-        readonly gif: const[];
+        readonly gif: readonly [];
         readonly h265: readonly ["aac", "pcm-16"];
         readonly mp3: readonly ["mp3", "pcm-16"];
         readonly prores: readonly ["aac", "pcm-16"];
@@ -132,12 +132,7 @@ export declare const BrowserSafeApis: {
         };
         gif: {
             default: import("./file-extensions").FileExtension;
-            forAudioCodec: {
-                [x: string]: {
-                    possible: import("./file-extensions").FileExtension[];
-                    default: import("./file-extensions").FileExtension;
-                };
-            };
+            forAudioCodec: {};
         };
     };
     defaultAudioCodecs: {
@@ -178,8 +173,8 @@ export declare const BrowserSafeApis: {
             lossless: "pcm-16" | null;
         };
         gif: {
-            compressed: any;
-            lossless: any;
+            compressed: null;
+            lossless: null;
         };
     };
     defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">;

package/dist/combine-videos.js

@@ -7,6 +7,7 @@ const node_path_1 = require("node:path");
 const audio_codec_1 = require("./audio-codec");
 const call_ffmpeg_1 = require("./call-ffmpeg");
 const is_audio_codec_1 = require("./is-audio-codec");
+const logger_1 = require("./logger");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const truthy_1 = require("./truthy");
 const combineVideos = async (options) => {
@@ -49,7 +50,10 @@ const combineVideos = async (options) => {
         (_a = task.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
             if (onProgress) {
                 const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(data.toString('utf8'));
-                if (parsed !== undefined) {
+                if (parsed === undefined) {
+                    logger_1.Log.verbose(data.toString('utf8'));
+                }
+                else {
                     onProgress(parsed);
                 }
             }

package/dist/compositor/compose.js

@@ -71,10 +71,15 @@ const callCompositor = (payload) => {
                     reject(err);
                 }
                 catch (err) {
-                    reject(new Error(`Compositor panicked: ${message}`));
+                    reject(new Error(`Compositor panicked with code ${code}: ${message}`));
                 }
             }
         });
+        if (child.stdin.closed) {
+            reject(new Error('Compositor stdin closed unexpectedly,' +
+                Buffer.concat(stderrChunks).toString('utf-8')));
+            return;
+        }
         child.stdin.write(payload);
         child.stdin.end();
     });

package/dist/compositor/compositor.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import type { LogLevel } from '../log-level';
 import type { CompositorCommand } from './payloads';
 export type Compositor = {
     finishCommands: () => void;
@@ -7,5 +8,5 @@ export type Compositor = {
     pid: number | null;
 };
 export declare const getIdealMaximumFrameCacheItems: () => number;
-export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, verbose: boolean, indent: boolean) => Compositor;
-export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], indent: boolean) => Compositor;
+export declare const startLongRunningCompositor: (maximumFrameCacheItems: number, logLevel: LogLevel, indent: boolean) => Compositor;
+export declare const startCompositor: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T], logLevel: LogLevel, indent: boolean) => Compositor;

package/dist/compositor/compositor.js

@@ -9,29 +9,31 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = __importDefault(require("node:os"));
 const call_ffmpeg_1 = require("../call-ffmpeg");
 const get_concurrency_1 = require("../get-concurrency");
+const log_level_1 = require("../log-level");
 const logger_1 = require("../logger");
 const compose_1 = require("./compose");
 const get_executable_path_1 = require("./get-executable-path");
 const make_nonce_1 = require("./make-nonce");
 const getIdealMaximumFrameCacheItems = () => {
     const freeMemory = node_os_1.default.freemem();
-    // Assuming 1 frame is approximately 6MB
+    // Assuming 1 frame is approximately 24MB
+    // (4K video)
     // Assuming only half the available memory should be used
-    const max = Math.floor(freeMemory / (1024 * 1024 * 6));
-    // Never store more than 1000 frames
-    // But 100 is needed even if it's going to swap
-    return Math.max(100, Math.min(max, 1000));
+    const max = Math.floor(freeMemory / (1024 * 1024 * 24));
+    // Never store more than 2000 frames
+    // But 60 is needed even if it's going to swap
+    return Math.max(60, Math.min(max, 2000));
 };
 exports.getIdealMaximumFrameCacheItems = getIdealMaximumFrameCacheItems;
-const startLongRunningCompositor = (maximumFrameCacheItems, verbose, indent) => {
+const startLongRunningCompositor = (maximumFrameCacheItems, logLevel, indent) => {
     return (0, exports.startCompositor)('StartLongRunningProcess', {
         concurrency: (0, get_concurrency_1.getActualConcurrency)(null),
         maximum_frame_cache_items: maximumFrameCacheItems,
-        verbose,
-    }, indent);
+        verbose: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
+    }, logLevel, indent);
 };
 exports.startLongRunningCompositor = startLongRunningCompositor;
-const startCompositor = (type, payload, indent) => {
+const startCompositor = (type, payload, logLevel, indent) => {
     var _a;
     const bin = (0, get_executable_path_1.getExecutablePath)('compositor');
     if (!process.env.READ_ONLY_FS) {
@@ -45,7 +47,7 @@ const startCompositor = (type, payload, indent) => {
     const waiters = new Map();
     const onMessage = (statusType, nonce, data) => {
         if (nonce === '0') {
-            logger_1.Log.verboseAdvanced({ indent, logLevel: (0, logger_1.getLogLevel)(), tag: 'compositor' }, data.toString('utf8'));
+            logger_1.Log.verboseAdvanced({ indent, logLevel, tag: 'compositor' }, data.toString('utf8'));
         }
         if (waiters.has(nonce)) {
             if (statusType === 'error') {
@@ -144,7 +146,7 @@ const startCompositor = (type, payload, indent) => {
     });
     let resolve = null;
     let reject = null;
-    child.on('close', (code) => {
+    child.on('close', (code, signal) => {
         const waitersToKill = Array.from(waiters.values());
         if (code === 0) {
             runningStatus = { type: 'quit-without-error' };
@@ -155,9 +157,12 @@ const startCompositor = (type, payload, indent) => {
             waiters.clear();
         }
         else {
-            const errorMessage = Buffer.concat(stderrChunks).toString('utf-8');
+            const errorMessage = Buffer.concat(stderrChunks).toString('utf-8') +
+                outputBuffer.toString('utf-8');
             runningStatus = { type: 'quit-with-error', error: errorMessage };
-            const error = new Error(`Compositor panicked: ${errorMessage}`);
+            const error = code === null
+                ? new Error(`Compositor exited with signal ${signal}`)
+                : new Error(`Compositor panicked with code ${code}: ${errorMessage}`);
             for (const waiter of waitersToKill) {
                 waiter.reject(error);
             }
@@ -205,7 +210,6 @@ const startCompositor = (type, payload, indent) => {
                         params,
                     },
                 };
-                // TODO: Should have a way to error out a single task
                 child.stdin.write(JSON.stringify(composed) + '\n');
                 waiters.set(nonce, {
                     resolve: _resolve,

package/dist/compositor/payloads.d.ts

@@ -27,6 +27,15 @@ export type Layer = {
     };
 };
 export type CompositorImageFormat = 'Png' | 'Jpeg';
+export type VideoMetadata = {
+    fps: number;
+    width: number;
+    height: number;
+    durationInSeconds: number;
+    codec: 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores' | 'unknown';
+    canPlayInVideoTag: boolean;
+    supportsSeeking: boolean;
+};
 export type CompositorCommand = {
     Compose: {
         output: string;
@@ -36,7 +45,8 @@ export type CompositorCommand = {
         output_format: CompositorImageFormat;
     };
     ExtractFrame: {
-        input: string;
+        src: string;
+        original_src: string;
         time: number;
         transparent: boolean;
     };
@@ -54,6 +64,10 @@ export type CompositorCommand = {
     FreeUpMemory: {
         percent_of_memory: number;
     };
+    GetVideoMetadata: {
+        src: string;
+    };
+    VideoMetadata: VideoMetadata;
 };
 export type CompositorCommandSerialized<T extends keyof CompositorCommand> = {
     nonce: string;

package/dist/create-ffmpeg-merge-filter.js

@@ -12,7 +12,6 @@ const createFfmpegMergeFilter = ({ inputs, }) => {
         ];
         return `[${index}:a]${filters.filter(truthy_1.truthy).join(',')}[padded${index}]`;
     });
-    const normalize = ':normalize=0';
     return [
         ...pads,
         `${new Array(inputs.length)
@@ -20,7 +19,7 @@ const createFfmpegMergeFilter = ({ inputs, }) => {
             .map((_, i) => {
             return `[padded${i}]`;
         })
-            .join('')}amix=inputs=${inputs.length}:dropout_transition=0${normalize}[${exports.OUTPUT_FILTER_NAME}]`,
+            .join('')}amix=inputs=${inputs.length}:dropout_transition=0:normalize=0[${exports.OUTPUT_FILTER_NAME}]`,
     ].join(';');
 };
 exports.createFfmpegMergeFilter = createFfmpegMergeFilter;

package/dist/cycle-browser-tabs.d.ts

@@ -1,4 +1,5 @@
+import type { LogLevel } from './log-level';
 import type { BrowserReplacer } from './replace-browser';
-export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number) => {
+export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number, logLevel: LogLevel, indent: boolean) => {
     stopCycling: () => void;
 };

package/dist/cycle-browser-tabs.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cycleBrowserTabs = void 0;
-const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
+const cycleBrowserTabs = (puppeteerInstance, concurrency, logLevel, indent) => {
     if (concurrency <= 1) {
         return {
             stopCycling: () => undefined,
@@ -14,7 +14,7 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
         interval = setTimeout(() => {
             puppeteerInstance
                 .getBrowser()
-                .pages()
+                .pages(logLevel, indent)
                 .then((pages) => {
                 if (pages.length === 0) {
                     return;

package/dist/format-logs.d.ts

@@ -0,0 +1,3 @@
+import type { DevtoolsRemoteObject, ObjectPreview } from './browser/devtools-types';
+export declare const formatRemoteObject: (remoteObject: DevtoolsRemoteObject) => string;
+export declare const formatObjectPreview: (preview: ObjectPreview) => string;

package/dist/format-logs.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatObjectPreview = exports.formatRemoteObject = void 0;
+const chalk_1 = require("./chalk");
+const formatRemoteObject = (remoteObject) => {
+    if (remoteObject.preview) {
+        return (0, exports.formatObjectPreview)(remoteObject.preview);
+    }
+    if (remoteObject.type === 'string') {
+        return chalk_1.chalk.reset(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'number') {
+        return chalk_1.chalk.yellow(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'bigint') {
+        return chalk_1.chalk.yellow(`${remoteObject.description}`);
+    }
+    if (remoteObject.type === 'boolean') {
+        return chalk_1.chalk.yellow(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'function') {
+        return chalk_1.chalk.cyan(String(remoteObject.description));
+    }
+    if (remoteObject.type === 'object') {
+        if (remoteObject.subtype === 'null') {
+            return chalk_1.chalk.white(`null`);
+        }
+        return chalk_1.chalk.reset(`Object`);
+    }
+    if (remoteObject.type === 'symbol') {
+        return chalk_1.chalk.green(`${remoteObject.description}`);
+    }
+    if (remoteObject.type === 'undefined') {
+        return chalk_1.chalk.gray(`undefined`);
+    }
+    throw new Error('unhandled remote object');
+};
+exports.formatRemoteObject = formatRemoteObject;
+const formatObjectPreview = (preview) => {
+    if (typeof preview === 'undefined') {
+        return '';
+    }
+    if (preview.type === 'object') {
+        if (preview.subtype === 'date') {
+            return chalk_1.chalk.reset(`Date { ${chalk_1.chalk.magenta(String(preview.description))} }`);
+        }
+        const properties = preview.properties.map((property) => {
+            return chalk_1.chalk.reset(`${property.name}: ${formatProperty(property)}`);
+        });
+        if (preview.subtype === 'array') {
+            if (preview.overflow) {
+                return chalk_1.chalk.reset(`[ ${preview.properties.map((p) => formatProperty(p)).join(', ')}, …]`);
+            }
+            return chalk_1.chalk.reset(`[ ${preview.properties.map((p) => formatProperty(p)).join(', ')} ]`);
+        }
+        if (preview.subtype === 'arraybuffer') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'dataview') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'generator') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'iterator') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'map') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'node') {
+            return chalk_1.chalk.magenta(`<${preview.description}>`);
+        }
+        if (preview.subtype === 'null') {
+            return chalk_1.chalk.white(String(preview.description));
+        }
+        if (preview.subtype === 'promise') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'proxy') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'regexp') {
+            return chalk_1.chalk.red(String(preview.description));
+        }
+        if (preview.subtype === 'set') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'typedarray') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'error') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'wasmvalue') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'weakmap') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'weakset') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'webassemblymemory') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (properties.length === 0) {
+            return chalk_1.chalk.reset('{}');
+        }
+        if (preview.overflow) {
+            return chalk_1.chalk.reset(`{ ${properties.join(', ')}, …}`);
+        }
+        return chalk_1.chalk.reset(`{ ${properties.join(', ')} }`);
+    }
+    return '';
+};
+exports.formatObjectPreview = formatObjectPreview;
+const formatProperty = (property) => {
+    if (property.type === 'string') {
+        return chalk_1.chalk.green(`"${property.value}"`);
+    }
+    if (property.type === 'object') {
+        if (!property.subtype && property.value === 'Object') {
+            return chalk_1.chalk.reset(`{…}`);
+        }
+        if (property.subtype === 'date') {
+            return chalk_1.chalk.reset(`Date { ${chalk_1.chalk.magenta(String(property.value))} }`);
+        }
+        if (property.subtype === 'arraybuffer') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'array') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'dataview') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'error') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'generator') {
+            return chalk_1.chalk.reset(`[generator ${property.value}]`);
+        }
+        if (property.subtype === 'iterator') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'map') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'node') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'null') {
+            return chalk_1.chalk.white(`${property.value}`);
+        }
+        if (property.subtype === 'promise') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'proxy') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'regexp') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'set') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'typedarray') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'wasmvalue') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'webassemblymemory') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'weakmap') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'weakset') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        return chalk_1.chalk.reset(`${property.value}`);
+    }
+    if (property.type === 'accessor') {
+        return chalk_1.chalk.gray(`get()`);
+    }
+    if (property.type === 'bigint') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'boolean') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'function') {
+        return chalk_1.chalk.cyan(`Function`);
+    }
+    if (property.type === 'number') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'symbol') {
+        return chalk_1.chalk.green(`${property.value}`);
+    }
+    if (property.type === 'undefined') {
+        return chalk_1.chalk.gray(`undefined`);
+    }
+    throw new Error('unexpected property type ' + JSON.stringify(property));
+};

package/dist/get-browser-instance.d.ts

@@ -1,16 +1,17 @@
 import type { BrowserExecutable } from './browser-executable';
 import type { HeadlessBrowser } from './browser/Browser';
 import type { Page } from './browser/BrowserPage';
+import type { LogLevel } from './log-level';
 import type { ChromiumOptions } from './open-browser';
 import type { AnySourceMapConsumer } from './symbolicate-stacktrace';
-export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, shouldDumpIo, }: {
+export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, logLevel, }: {
     passedInInstance: HeadlessBrowser | undefined;
     browserExecutable: BrowserExecutable | null;
     chromiumOptions: ChromiumOptions;
     context: AnySourceMapConsumer | null;
     indent: boolean;
     forceDeviceScaleFactor: number | undefined;
-    shouldDumpIo: boolean;
+    logLevel: LogLevel;
 }) => Promise<{
     cleanup: () => void;
     page: Page;

package/dist/get-browser-instance.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageAndCleanupFn = void 0;
 const browser_1 = require("./browser");
 const open_browser_1 = require("./open-browser");
-const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, shouldDumpIo, }) => {
+const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, context, forceDeviceScaleFactor, indent, logLevel, }) => {
     if (passedInInstance) {
-        const page = await passedInInstance.newPage(context);
+        const page = await passedInInstance.newPage(Promise.resolve(context), logLevel, indent);
         return {
             page,
             cleanup: () => {
@@ -23,15 +23,15 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
         chromiumOptions,
         forceDeviceScaleFactor,
         indent,
-        shouldDumpIo,
         viewport: null,
+        logLevel,
     });
-    const browserPage = await browserInstance.newPage(context);
+    const browserPage = await browserInstance.newPage(Promise.resolve(context), logLevel, indent);
     return {
         page: browserPage,
         cleanup: () => {
             // Close whole browser that was just created and don't wait for it to finish.
-            browserInstance.close(true).catch((err) => {
+            browserInstance.close(true, logLevel, indent).catch((err) => {
                 console.error('Was not able to close puppeteer page', err);
             });
         },

package/dist/get-bundle-url-from-serve-url.d.ts

@@ -0,0 +1,2 @@
+export declare const getBundleUrlFromServeUrl: (serveUrl: string) => string;
+export declare const getBundleMapUrlFromServeUrl: (serveUrl: string) => string;

package/dist/get-bundle-url-from-serve-url.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBundleMapUrlFromServeUrl = exports.getBundleUrlFromServeUrl = void 0;
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const is_serve_url_1 = require("./is-serve-url");
+const map = (webpackBundleOrServeUrl, suffix) => {
+    if ((0, is_serve_url_1.isServeUrl)(webpackBundleOrServeUrl)) {
+        const parsed = new URL(webpackBundleOrServeUrl);
+        const idx = parsed.pathname.lastIndexOf('/');
+        if (idx === -1) {
+            return parsed.origin + '/' + suffix;
+        }
+        return parsed.origin + parsed.pathname.substring(0, idx + 1) + suffix;
+    }
+    const index = webpackBundleOrServeUrl.lastIndexOf(path_1.default.sep);
+    const url = webpackBundleOrServeUrl.substring(0, index + 1) + suffix;
+    return url;
+};
+const getBundleUrlFromServeUrl = (serveUrl) => {
+    return map(serveUrl, remotion_1.Internals.bundleName);
+};
+exports.getBundleUrlFromServeUrl = getBundleUrlFromServeUrl;
+const getBundleMapUrlFromServeUrl = (serveUrl) => {
+    return map(serveUrl, remotion_1.Internals.bundleMapName);
+};
+exports.getBundleMapUrlFromServeUrl = getBundleMapUrlFromServeUrl;

package/dist/get-compositions.d.ts

@@ -1,11 +1,12 @@
-import type { AnyCompMetadata } from 'remotion';
+import { type VideoConfig } from 'remotion';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
 import type { HeadlessBrowser } from './browser/Browser';
+import { type LogLevel } from './log-level';
 import type { ChromiumOptions } from './open-browser';
 import type { RemotionServer } from './prepare-server';
 type InternalGetCompositionsOptions = {
-    inputProps: Record<string, unknown>;
+    serializedInputPropsWithCustomSchema: string;
     envVariables: Record<string, string>;
     puppeteerInstance: HeadlessBrowser | undefined;
     onBrowserLog: null | ((log: BrowserLog) => void);
@@ -15,7 +16,7 @@ type InternalGetCompositionsOptions = {
     port: number | null;
     server: RemotionServer | undefined;
     indent: boolean;
-    verbose: boolean;
+    logLevel: LogLevel;
     serveUrlOrWebpackUrl: string;
 };
 export type GetCompositionsOptions = {
@@ -27,12 +28,12 @@ export type GetCompositionsOptions = {
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
     port?: number | null;
-    verbose?: boolean;
+    logLevel?: LogLevel;
 };
-export declare const internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }: InternalGetCompositionsOptions) => Promise<AnyCompMetadata[]>;
+export declare const internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, serializedInputPropsWithCustomSchema, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, logLevel, }: InternalGetCompositionsOptions) => Promise<VideoConfig[]>;
 /**
  * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
  * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
  */
-export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsOptions) => Promise<AnyCompMetadata[]>;
+export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsOptions) => Promise<VideoConfig[]>;
 export {};