@remotion/cli 4.0.111 → 4.0.113

package/dist/editor/state/sidebar.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export type SidebarCollapsedState = 'collapsed' | 'expanded' | 'responsive';
+type RightSidebarCollapsedState = Exclude<SidebarCollapsedState, 'responsive'>;
+type Context = {
+    sidebarCollapsedStateLeft: SidebarCollapsedState;
+    setSidebarCollapsedState: (options: {
+        left: null | React.SetStateAction<SidebarCollapsedState>;
+        right: null | React.SetStateAction<RightSidebarCollapsedState>;
+    }) => void;
+    sidebarCollapsedStateRight: RightSidebarCollapsedState;
+};
+export declare const SidebarContext: React.Context<Context>;
+export declare const SidebarContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/editor/state/sidebar.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SidebarContextProvider = exports.SidebarContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const storageKey = (sidebar) => {
+    if (sidebar === 'right') {
+        return 'remotion.sidebarRightCollapsing';
+    }
+    return 'remotion.sidebarCollapsing';
+};
+const getSavedCollapsedStateLeft = () => {
+    const state = window.localStorage.getItem(storageKey('left'));
+    if (state === 'collapsed') {
+        return 'collapsed';
+    }
+    if (state === 'expanded') {
+        return 'expanded';
+    }
+    return 'responsive';
+};
+const getSavedCollapsedStateRight = () => {
+    const state = window.localStorage.getItem(storageKey('right'));
+    if (state === 'expanded') {
+        return 'expanded';
+    }
+    return 'collapsed';
+};
+const saveCollapsedState = (type, sidebar) => {
+    window.localStorage.setItem(storageKey(sidebar), type);
+};
+exports.SidebarContext = (0, react_1.createContext)({
+    sidebarCollapsedStateLeft: 'collapsed',
+    setSidebarCollapsedState: () => {
+        throw new Error('sidebar collapsed state');
+    },
+    sidebarCollapsedStateRight: 'collapsed',
+});
+const SidebarContextProvider = ({ children }) => {
+    const [sidebarCollapsedState, setSidebarCollapsedState] = (0, react_1.useState)(() => ({
+        left: getSavedCollapsedStateLeft(),
+        right: getSavedCollapsedStateRight(),
+    }));
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            sidebarCollapsedStateLeft: sidebarCollapsedState.left,
+            sidebarCollapsedStateRight: sidebarCollapsedState.right,
+            setSidebarCollapsedState: (options) => {
+                const { left, right } = options;
+                setSidebarCollapsedState((f) => {
+                    const copied = { ...f };
+                    if (left) {
+                        const updatedLeft = typeof left === 'function' ? left(f.left) : left;
+                        saveCollapsedState(updatedLeft, 'left');
+                        copied.left = updatedLeft;
+                    }
+                    if (right) {
+                        const updatedRight = typeof right === 'function' ? right(f.right) : right;
+                        saveCollapsedState(updatedRight, 'right');
+                        copied.right = updatedRight;
+                    }
+                    return copied;
+                });
+            },
+        };
+    }, [sidebarCollapsedState]);
+    return ((0, jsx_runtime_1.jsx)(exports.SidebarContext.Provider, { value: value, children: children }));
+};
+exports.SidebarContextProvider = SidebarContextProvider;

package/dist/editor/state/timeline-ref.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+type TimelineRef = {
+    collapseAll: () => void;
+    expandAll: () => void;
+};
+export declare const timelineRef: import("react").RefObject<TimelineRef>;
+export {};

package/dist/editor/state/timeline-ref.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timelineRef = void 0;
+const react_1 = require("react");
+exports.timelineRef = (0, react_1.createRef)();

package/dist/editor/state/timeline-zoom.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare const TIMELINE_MIN_ZOOM = 1;
+export declare const TIMELINE_MAX_ZOOM = 5;
+export declare const TimelineZoomCtx: React.Context<{
+    zoom: number;
+    setZoom: (prev: (prevZoom: number) => number) => void;
+}>;
+export declare const TimelineZoomContext: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/editor/state/timeline-zoom.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineZoomContext = exports.TimelineZoomCtx = exports.TIMELINE_MAX_ZOOM = exports.TIMELINE_MIN_ZOOM = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const imperative_state_1 = require("../components/Timeline/imperative-state");
+const timeline_scroll_logic_1 = require("../components/Timeline/timeline-scroll-logic");
+exports.TIMELINE_MIN_ZOOM = 1;
+exports.TIMELINE_MAX_ZOOM = 5;
+exports.TimelineZoomCtx = (0, react_1.createContext)({
+    zoom: -1,
+    setZoom: () => {
+        throw new Error('has no context');
+    },
+});
+const TimelineZoomContext = ({ children }) => {
+    const [zoom, setZoom] = (0, react_1.useState)(exports.TIMELINE_MIN_ZOOM);
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            zoom,
+            setZoom: (callback) => {
+                setZoom((prevZoom) => {
+                    const newZoomWithFloatingPointErrors = Math.min(exports.TIMELINE_MAX_ZOOM, Math.max(exports.TIMELINE_MIN_ZOOM, callback(prevZoom)));
+                    const newZoom = Math.round(newZoomWithFloatingPointErrors * 10) / 10;
+                    (0, timeline_scroll_logic_1.zoomAndPreserveCursor)({
+                        oldZoom: prevZoom,
+                        newZoom,
+                        currentDurationInFrames: (0, imperative_state_1.getCurrentDuration)(),
+                        currentFrame: (0, imperative_state_1.getCurrentFrame)(),
+                    });
+                    return newZoom;
+                });
+            },
+        };
+    }, [zoom]);
+    return ((0, jsx_runtime_1.jsx)(exports.TimelineZoomCtx.Provider, { value: value, children: children }));
+};
+exports.TimelineZoomContext = TimelineZoomContext;

package/dist/editor/state/timeline.d.ts

@@ -0,0 +1 @@
+export declare const useTimelineFlex: (id: string) => [number | null, (value: number) => void];

package/dist/editor/state/timeline.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTimelineFlex = void 0;
+const localStorageKey = (id) => `remotion.editor.timelineFlex.${id}`;
+const persistTimelineFlex = (value, id) => {
+    localStorage.setItem(localStorageKey(id), String(value));
+};
+const loadTimelineFlex = (id) => {
+    const item = localStorage.getItem(localStorageKey(id));
+    return item ? parseFloat(item) : null;
+};
+const useTimelineFlex = (id) => {
+    return [
+        loadTimelineFlex(id),
+        (value) => persistTimelineFlex(value, id),
+    ];
+};
+exports.useTimelineFlex = useTimelineFlex;

package/dist/editor/state/z-index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const HigherZIndex: React.FC<{
+    onEscape: () => void;
+    onOutsideClick: () => void;
+    children: React.ReactNode;
+}>;
+export declare const useZIndex: () => {
+    currentZIndex: number;
+    highestZIndex: number;
+    isHighestContext: boolean;
+    tabIndex: number;
+};

package/dist/editor/state/z-index.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useZIndex = exports.HigherZIndex = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const use_keybinding_1 = require("../helpers/use-keybinding");
+const highest_z_index_1 = require("./highest-z-index");
+const input_dragger_click_lock_1 = require("./input-dragger-click-lock");
+const ZIndexContext = (0, react_1.createContext)({
+    currentIndex: 0,
+});
+const margin = {
+    margin: 'auto',
+};
+const EscapeHook = ({ onEscape }) => {
+    const keybindings = (0, use_keybinding_1.useKeybinding)();
+    (0, react_1.useEffect)(() => {
+        const escape = keybindings.registerKeybinding({
+            event: 'keydown',
+            key: 'Escape',
+            callback: onEscape,
+            commandCtrlKey: false,
+            preventDefault: true,
+            // To dismiss the Quick Switcher menu if input is focused
+            triggerIfInputFieldFocused: true,
+            keepRegisteredWhenNotHighestContext: false,
+        });
+        return () => {
+            escape.unregister();
+        };
+    }, [keybindings, onEscape]);
+    return null;
+};
+const HigherZIndex = ({ children, onEscape, onOutsideClick }) => {
+    const context = (0, react_1.useContext)(ZIndexContext);
+    const highestContext = (0, react_1.useContext)(highest_z_index_1.HighestZIndexContext);
+    const containerRef = (0, react_1.useRef)(null);
+    const currentIndex = context.currentIndex + 1;
+    (0, react_1.useEffect)(() => {
+        highestContext.registerZIndex(currentIndex);
+        return () => highestContext.unregisterZIndex(currentIndex);
+    }, [currentIndex, highestContext]);
+    (0, react_1.useEffect)(() => {
+        let onUp = null;
+        const listener = (downEvent) => {
+            var _a;
+            const outsideClick = !((_a = containerRef.current) === null || _a === void 0 ? void 0 : _a.contains(downEvent.target));
+            if (!outsideClick) {
+                return;
+            }
+            onUp = (upEvent) => {
+                if (outsideClick &&
+                    highestContext.highestIndex === currentIndex &&
+                    !(0, input_dragger_click_lock_1.getClickLock)() &&
+                    // Don't trigger if that click removed that node
+                    document.contains(upEvent.target)) {
+                    upEvent.stopPropagation();
+                    onOutsideClick();
+                }
+            };
+            window.addEventListener('pointerup', onUp, { once: true });
+        };
+        // If a menu is opened, then this component will also still receive the pointerdown event.
+        // However we may not interpret it as a outside click, so we need to wait for the next tick
+        requestAnimationFrame(() => {
+            window.addEventListener('pointerdown', listener);
+        });
+        return () => {
+            onUp = null;
+            if (onUp) {
+                // @ts-expect-error
+                window.removeEventListener('pointerup', onUp, { once: true });
+            }
+            return window.removeEventListener('pointerdown', listener);
+        };
+    }, [currentIndex, highestContext.highestIndex, onOutsideClick]);
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            currentIndex,
+        };
+    }, [currentIndex]);
+    return ((0, jsx_runtime_1.jsxs)(ZIndexContext.Provider, { value: value, children: [(0, jsx_runtime_1.jsx)(EscapeHook, { onEscape: onEscape }), (0, jsx_runtime_1.jsx)("div", { ref: containerRef, style: margin, children: children })] }));
+};
+exports.HigherZIndex = HigherZIndex;
+const useZIndex = () => {
+    const context = (0, react_1.useContext)(ZIndexContext);
+    const highestContext = (0, react_1.useContext)(highest_z_index_1.HighestZIndexContext);
+    const isHighestContext = highestContext.highestIndex === context.currentIndex;
+    return (0, react_1.useMemo)(() => ({
+        currentZIndex: context.currentIndex,
+        highestZIndex: highestContext.highestIndex,
+        isHighestContext,
+        tabIndex: isHighestContext ? 0 : -1,
+    }), [context.currentIndex, highestContext.highestIndex, isHighestContext]);
+};
+exports.useZIndex = useZIndex;

package/dist/event-source-events.d.ts

@@ -0,0 +1,31 @@
+import type { StaticFile } from 'remotion';
+import type { RenderJob } from './preview-server/render-queue/job';
+export type EventSourceEvent = {
+    type: 'new-input-props';
+    newProps: object;
+} | {
+    type: 'init';
+    clientId: string;
+} | {
+    type: 'new-env-variables';
+    newEnvVariables: Record<string, string>;
+} | {
+    type: 'root-file-changed';
+} | {
+    type: 'render-queue-updated';
+    queue: RenderJob[];
+} | {
+    type: 'render-job-failed';
+    compositionId: string;
+    error: Error;
+} | {
+    type: 'watched-file-undeleted';
+    file: string;
+} | {
+    type: 'watched-file-deleted';
+    file: string;
+} | {
+    type: 'new-public-folder';
+    files: StaticFile[];
+    folderExists: string | null;
+};

package/dist/event-source-events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/event-source.d.ts

@@ -0,0 +1,3 @@
+import type { EventSourceEvent } from './event-source-events';
+export declare const subscribeToEvent: (type: EventSourceEvent['type'], listener: (event: EventSourceEvent) => void) => () => void;
+export declare const openEventSource: () => void;

package/dist/event-source.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openEventSource = exports.subscribeToEvent = void 0;
+const remotion_1 = require("remotion");
+const NotificationCenter_1 = require("./editor/components/Notifications/NotificationCenter");
+const context_1 = require("./editor/components/RenderQueue/context");
+const client_id_1 = require("./editor/helpers/client-id");
+let source = null;
+let listeners = [];
+const subscribeToEvent = (type, listener) => {
+    listeners.push({ type, listener });
+    return () => {
+        listeners = listeners.filter((l) => l.type !== type || l.listener !== listener);
+    };
+};
+exports.subscribeToEvent = subscribeToEvent;
+const openEventSource = () => {
+    source = new EventSource('/events');
+    source.addEventListener('message', (event) => {
+        var _a, _b;
+        const newEvent = JSON.parse(event.data);
+        if (newEvent.type === 'new-input-props' ||
+            newEvent.type === 'new-env-variables') {
+            window.location.reload();
+        }
+        if (newEvent.type === 'init') {
+            (_a = client_id_1.studioServerConnectionRef.current) === null || _a === void 0 ? void 0 : _a.set({
+                type: 'connected',
+                clientId: newEvent.clientId,
+            });
+        }
+        if (newEvent.type === 'render-queue-updated') {
+            (_b = context_1.renderJobsRef.current) === null || _b === void 0 ? void 0 : _b.updateRenderJobs(newEvent.queue);
+        }
+        if (newEvent.type === 'render-job-failed') {
+            (0, NotificationCenter_1.sendErrorNotification)(`Rendering "${newEvent.compositionId}" failed`);
+        }
+        if (newEvent.type === 'new-public-folder') {
+            const payload = {
+                files: newEvent.files,
+            };
+            window.dispatchEvent(new CustomEvent(remotion_1.Internals.WATCH_REMOTION_STATIC_FILES, {
+                detail: payload,
+            }));
+            window.remotion_staticFiles = newEvent.files;
+            window.remotion_publicFolderExists = newEvent.folderExists;
+        }
+        listeners.forEach((l) => {
+            if (l.type === newEvent.type) {
+                l.listener(newEvent);
+            }
+        });
+    });
+    source.addEventListener('open', () => {
+        source.addEventListener('error', () => {
+            var _a;
+            (_a = client_id_1.studioServerConnectionRef.current) === null || _a === void 0 ? void 0 : _a.set({ type: 'disconnected' });
+            // Display an error message that the studio server has disconnected.
+            source === null || source === void 0 ? void 0 : source.close();
+            // Retry later
+            setTimeout(() => {
+                (0, exports.openEventSource)();
+            }, 1000);
+        }, { once: true });
+    });
+};
+exports.openEventSource = openEventSource;

package/dist/file-watcher.d.ts

@@ -0,0 +1,9 @@
+type FileChangeType = 'created' | 'deleted' | 'changed';
+export declare const installFileWatcher: ({ file, onChange, }: {
+    file: string;
+    onChange: (type: FileChangeType) => void;
+}) => {
+    exists: boolean;
+    unwatch: () => void;
+};
+export {};

package/dist/file-watcher.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installFileWatcher = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const installFileWatcher = ({ file, onChange, }) => {
+    const existedAtBeginning = node_fs_1.default.existsSync(file);
+    let existedBefore = existedAtBeginning;
+    const listener = () => {
+        const existsNow = node_fs_1.default.existsSync(file);
+        if (!existedBefore && existsNow) {
+            onChange('created');
+            existedBefore = true;
+            return;
+        }
+        if (existedBefore && !existsNow) {
+            onChange('deleted');
+            existedBefore = false;
+            return;
+        }
+        if (existsNow) {
+            onChange('changed');
+        }
+    };
+    node_fs_1.default.watchFile(file, { interval: 100 }, listener);
+    return {
+        exists: existedAtBeginning,
+        unwatch: () => {
+            node_fs_1.default.unwatchFile(file, listener);
+        },
+    };
+};
+exports.installFileWatcher = installFileWatcher;

package/dist/format-bytes.d.ts

@@ -0,0 +1,6 @@
+export declare const formatBytes: (number: number, options?: Intl.NumberFormatOptions & {
+    locale: string;
+    bits?: boolean;
+    binary?: boolean;
+    signed: boolean;
+}) => string;

package/dist/format-bytes.js

@@ -0,0 +1,103 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = void 0;
+const BYTE_UNITS = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+const BIBYTE_UNITS = [
+    'B',
+    'kiB',
+    'MiB',
+    'GiB',
+    'TiB',
+    'PiB',
+    'EiB',
+    'ZiB',
+    'YiB',
+];
+const BIT_UNITS = [
+    'b',
+    'kbit',
+    'Mbit',
+    'Gbit',
+    'Tbit',
+    'Pbit',
+    'Ebit',
+    'Zbit',
+    'Ybit',
+];
+const BIBIT_UNITS = [
+    'b',
+    'kibit',
+    'Mibit',
+    'Gibit',
+    'Tibit',
+    'Pibit',
+    'Eibit',
+    'Zibit',
+    'Yibit',
+];
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/
+const toLocaleString = (number, locale, options) => {
+    if (typeof locale === 'string' || Array.isArray(locale)) {
+        return number.toLocaleString(locale, options);
+    }
+    if (locale === true || options !== undefined) {
+        return number.toLocaleString(undefined, options);
+    }
+    return String(number);
+};
+const formatBytes = (number, options = {
+    locale: 'en-US',
+    signed: false,
+    maximumFractionDigits: 1,
+}) => {
+    if (!Number.isFinite(number)) {
+        throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+    }
+    options = { bits: false, binary: false, ...options };
+    const UNITS = options.bits
+        ? options.binary
+            ? BIBIT_UNITS
+            : BIT_UNITS
+        : options.binary
+            ? BIBYTE_UNITS
+            : BYTE_UNITS;
+    if (options.signed && number === 0) {
+        return `0 $ {
+            UNITS[0]
+        }`;
+    }
+    const isNegative = number < 0;
+    const prefix = isNegative ? '-' : options.signed ? '+' : '';
+    if (isNegative) {
+        number = -number;
+    }
+    let localeOptions;
+    if (options.minimumFractionDigits !== undefined) {
+        localeOptions = {
+            minimumFractionDigits: options.minimumFractionDigits,
+        };
+    }
+    if (options.maximumFractionDigits !== undefined) {
+        localeOptions = {
+            maximumFractionDigits: options.maximumFractionDigits,
+            ...localeOptions,
+        };
+    }
+    if (number < 1) {
+        const numString = toLocaleString(number, options.locale, localeOptions);
+        return prefix + numString + ' ' + UNITS[0];
+    }
+    const exponent = Math.min(Math.floor(options.binary
+        ? Math.log(number) / Math.log(1024)
+        : Math.log10(number) / 3), UNITS.length - 1);
+    number /= (options.binary ? 1024 : 1000) ** exponent;
+    const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+    const unit = UNITS[exponent];
+    return prefix + numberString + ' ' + unit;
+};
+exports.formatBytes = formatBytes;

package/dist/get-default-out-name.d.ts

@@ -0,0 +1,5 @@
+export declare const getDefaultOutLocation: ({ compositionName, defaultExtension, type, }: {
+    compositionName: string;
+    defaultExtension: string;
+    type: 'asset' | 'sequence';
+}) => string;

package/dist/get-default-out-name.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultOutLocation = void 0;
+const getDefaultOutLocation = ({ compositionName, defaultExtension, type, }) => {
+    if (type === 'sequence') {
+        return `out/${compositionName}`;
+    }
+    return `out/${compositionName}.${defaultExtension}`;
+};
+exports.getDefaultOutLocation = getDefaultOutLocation;

package/dist/get-latest-remotion-version.d.ts

@@ -0,0 +1 @@
+export declare const getLatestRemotionVersion: () => Promise<any>;

package/dist/get-latest-remotion-version.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestRemotionVersion = void 0;
+const https_1 = __importDefault(require("https"));
+const getPackageJsonForRemotion = () => {
+    return new Promise((resolve, reject) => {
+        const req = https_1.default.get('https://registry.npmjs.org/remotion', {
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*',
+            },
+        }, (res) => {
+            let data = '';
+            res.on('data', (d) => {
+                data += d;
+            });
+            res.on('end', () => resolve(data));
+        });
+        req.on('error', (error) => {
+            reject(error);
+        });
+        req.end();
+    });
+};
+const getLatestRemotionVersion = async () => {
+    const pkgJson = await getPackageJsonForRemotion();
+    return JSON.parse(pkgJson)['dist-tags'].latest;
+};
+exports.getLatestRemotionVersion = getLatestRemotionVersion;

package/dist/get-network-address.d.ts

@@ -0,0 +1 @@
+export declare const getNetworkAddress: () => string | undefined;

package/dist/get-network-address.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNetworkAddress = void 0;
+const node_os_1 = require("node:os");
+const getNetworkAddress = () => {
+    for (const interfaceDetails of Object.values((0, node_os_1.networkInterfaces)())) {
+        if (!interfaceDetails)
+            continue;
+        for (const details of interfaceDetails) {
+            const { address, family, internal } = details;
+            if (family === 'IPv4' && !internal)
+                return address;
+        }
+    }
+};
+exports.getNetworkAddress = getNetworkAddress;

package/dist/index.d.ts

@@ -124,7 +124,7 @@ export declare const CliInternals: {
     parsedCli: {
         "browser-executable": import("@remotion/renderer").BrowserExecutable;
         "pixel-format": "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
-        "image-format": "png" | "jpeg" | "pdf" | "webp" | "none";
+        "image-format": "png" | "jpeg" | "none" | "pdf" | "webp";
         "prores-profile": "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy";
         "x264-preset": "ultrafast" | "superfast" | "veryfast" | "faster" | "fast" | "medium" | "slow" | "slower" | "veryslow" | "placebo";
         "bundle-cache": string;
@@ -194,7 +194,7 @@ export declare const CliInternals: {
         downloadName: string | null;
         outName: string | null;
         configImageFormat: "png" | "jpeg" | "pdf" | "webp" | null;
-        cliFlag: "png" | "jpeg" | "pdf" | "webp" | "none" | null;
+        cliFlag: "png" | "jpeg" | "none" | "pdf" | "webp" | null;
         isLambda: boolean;
         fromUi: "png" | "jpeg" | "pdf" | "webp" | null;
     }) => {

package/dist/preview-server/api-routes.d.ts

@@ -0,0 +1,4 @@
+import type { ApiHandler, ApiRoutes } from './api-types';
+export declare const allApiRoutes: {
+    [key in keyof ApiRoutes]: ApiHandler<ApiRoutes[key]['Request'], ApiRoutes[key]['Response']>;
+};