@remotion/cli 4.0.111 → 4.0.113

package/dist/preview-server/hot-middleware/types.d.ts

@@ -0,0 +1,27 @@
+import type { webpack } from '@remotion/bundler';
+export type HotMiddlewareMessage = {
+    action: 'building';
+    name?: string;
+} | {
+    action: 'built' | 'sync';
+    name: string;
+    time: number | undefined;
+    errors: unknown[];
+    warnings: unknown[];
+    hash: string | undefined;
+    modules: {
+        [key: string]: string;
+    };
+};
+export declare const hotMiddlewareOptions: {
+    path: string;
+    timeout: number;
+    reload: boolean;
+    warn: boolean;
+    heartbeat: number;
+};
+export type HotMiddlewareOptions = typeof hotMiddlewareOptions;
+export type WebpackStats = ReturnType<webpack.Stats['toJson']>;
+export type ModuleMap = {
+    [key: string]: string;
+};

package/dist/preview-server/hot-middleware/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hotMiddlewareOptions = void 0;
+exports.hotMiddlewareOptions = {
+    path: '/__webpack_hmr',
+    timeout: 20 * 1000,
+    reload: true,
+    warn: true,
+    heartbeat: 10 * 1000,
+};

package/dist/preview-server/live-events.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { EventSourceEvent } from '../event-source-events';
+export type LiveEventsServer = {
+    sendEventToClient: (event: EventSourceEvent) => void;
+    router: (request: IncomingMessage, response: ServerResponse) => void;
+};
+export declare const makeLiveEventsRouter: () => LiveEventsServer;
+export declare const waitForLiveEventsListener: () => Promise<LiveEventsServer>;
+export declare const setLiveEventsListener: (listener: LiveEventsServer) => void;

package/dist/preview-server/live-events.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLiveEventsListener = exports.waitForLiveEventsListener = exports.makeLiveEventsRouter = void 0;
+const server_ready_comment_1 = require("../server-ready-comment");
+const file_existence_watchers_1 = require("./file-existence-watchers");
+const serializeMessage = (message) => {
+    return `data: ${JSON.stringify(message)}\n\n`;
+};
+let printPortMessageTimeout = null;
+const makeLiveEventsRouter = () => {
+    let clients = [];
+    const router = (request, response) => {
+        const headers = {
+            'content-type': 'text/event-stream;charset=utf-8',
+            connection: 'keep-alive',
+            'cache-control': 'no-cache',
+        };
+        response.writeHead(200, headers);
+        response.write('\n');
+        if (request.method === 'OPTIONS') {
+            response.end();
+            return;
+        }
+        const clientId = String(Math.random());
+        response.write(serializeMessage({ type: 'init', clientId }));
+        const newClient = {
+            id: clientId,
+            response,
+        };
+        clients.push(newClient);
+        if (printPortMessageTimeout) {
+            clearTimeout(printPortMessageTimeout);
+        }
+        request.on('close', () => {
+            (0, file_existence_watchers_1.unsubscribeClientFileExistenceWatchers)(clientId);
+            clients = clients.filter((client) => client.id !== clientId);
+            // If all clients disconnected, print a comment so user can easily restart it.
+            if (clients.length === 0) {
+                if (printPortMessageTimeout) {
+                    clearTimeout(printPortMessageTimeout);
+                }
+                printPortMessageTimeout = setTimeout(() => {
+                    (0, server_ready_comment_1.printServerReadyComment)('To restart');
+                }, 2500);
+            }
+        });
+    };
+    const sendEventToClient = (event) => {
+        clients.forEach((client) => {
+            client.response.write(serializeMessage(event));
+        });
+    };
+    return {
+        sendEventToClient,
+        router,
+    };
+};
+exports.makeLiveEventsRouter = makeLiveEventsRouter;
+let liveEventsListener = null;
+const waiters = [];
+const waitForLiveEventsListener = () => {
+    if (liveEventsListener) {
+        return Promise.resolve(liveEventsListener);
+    }
+    return new Promise((resolve) => {
+        waiters.push((list) => {
+            resolve(list);
+        });
+    });
+};
+exports.waitForLiveEventsListener = waitForLiveEventsListener;
+const setLiveEventsListener = (listener) => {
+    liveEventsListener = listener;
+    waiters.forEach((w) => w(listener));
+};
+exports.setLiveEventsListener = setLiveEventsListener;

package/dist/preview-server/parse-body.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage } from 'node:http';
+export declare const parseRequestBody: (req: IncomingMessage) => Promise<unknown>;

package/dist/preview-server/parse-body.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRequestBody = void 0;
+const parseRequestBody = async (req) => {
+    const body = await new Promise((_resolve) => {
+        let data = '';
+        req.on('data', (chunk) => {
+            data += chunk;
+        });
+        req.on('end', () => {
+            _resolve(data.toString());
+        });
+    });
+    return JSON.parse(body);
+};
+exports.parseRequestBody = parseRequestBody;

package/dist/preview-server/project-info.d.ts

@@ -0,0 +1,5 @@
+export type ProjectInfo = {
+    videoFile: string | null;
+    relativeVideoFile: string | null;
+};
+export declare const getProjectInfo: (remotionRoot: string) => Promise<ProjectInfo>;

package/dist/preview-server/project-info.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectInfo = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const getProjectInfo = (remotionRoot) => {
+    var _a;
+    const pathsToLookFor = [
+        'src/Root.tsx',
+        'src/Root.jsx',
+        'remotion/Root.tsx',
+        'remotion/Root.jsx',
+        'app/remotion/Root.tsx',
+        'src/Video.tsx',
+        'src/Video.jsx',
+        'src/remotion/Root.tsx',
+        'src/remotion/Root.jsx',
+    ].map((p) => {
+        return node_path_1.default.join(remotionRoot, p);
+    });
+    const videoFile = (_a = pathsToLookFor.find((p) => (0, node_fs_1.existsSync)(p))) !== null && _a !== void 0 ? _a : null;
+    return Promise.resolve({
+        videoFile,
+        relativeVideoFile: videoFile
+            ? node_path_1.default.relative(remotionRoot, videoFile)
+            : null,
+    });
+};
+exports.getProjectInfo = getProjectInfo;

package/dist/preview-server/public-folder.d.ts

@@ -0,0 +1,12 @@
+import type { StaticFile } from 'remotion';
+export declare const initPublicFolderWatch: ({ publicDir, onUpdate, staticHash, }: {
+    publicDir: string;
+    remotionRoot: string;
+    onUpdate: () => void;
+    staticHash: string;
+}) => void;
+export declare const fetchFolder: ({ publicDir, staticHash, }: {
+    publicDir: string;
+    staticHash: string;
+}) => void;
+export declare const getFiles: () => StaticFile[];

package/dist/preview-server/public-folder.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFiles = exports.fetchFolder = exports.initPublicFolderWatch = void 0;
+const bundler_1 = require("@remotion/bundler");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const env_supports_fs_recursive_1 = require("./env-supports-fs-recursive");
+let files = [];
+const initPublicFolderWatch = ({ publicDir, onUpdate, staticHash, }) => {
+    (0, exports.fetchFolder)({ publicDir, staticHash });
+    watchPublicFolder({ publicDir, onUpdate, staticHash });
+};
+exports.initPublicFolderWatch = initPublicFolderWatch;
+const fetchFolder = ({ publicDir, staticHash, }) => {
+    files = bundler_1.BundlerInternals.readRecursively({
+        folder: '.',
+        startPath: publicDir,
+        staticHash,
+        limit: 10000,
+    }).map((f) => {
+        return {
+            ...f,
+            name: f.name.split(node_path_1.default.sep).join('/'),
+        };
+    });
+};
+exports.fetchFolder = fetchFolder;
+const watchPublicFolder = ({ publicDir, onUpdate, staticHash, }) => {
+    if (!(0, node_fs_1.existsSync)(publicDir)) {
+        const parentDir = node_path_1.default.dirname(publicDir);
+        const onDirChange = () => {
+            if ((0, node_fs_1.existsSync)(publicDir)) {
+                watchPublicFolder({
+                    publicDir,
+                    onUpdate,
+                    staticHash,
+                });
+                onUpdate();
+                watcher.close();
+            }
+        };
+        const watcher = (0, node_fs_1.watch)(parentDir, {}, onDirChange);
+        return;
+    }
+    // Known bug: If whole public folder is deleted, this will not be called on macOS.
+    // This is not severe, so a wontfix for now.
+    (0, node_fs_1.watch)(publicDir, { recursive: (0, env_supports_fs_recursive_1.envSupportsFsRecursive)() }, () => {
+        (0, exports.fetchFolder)({ publicDir, staticHash });
+        onUpdate();
+    });
+};
+const getFiles = () => {
+    return files;
+};
+exports.getFiles = getFiles;

package/dist/preview-server/render-queue/copy-still-to-clipboard.d.ts

@@ -0,0 +1 @@
+export declare const copyStillToClipBoard: (img: string) => Promise<void>;

package/dist/preview-server/render-queue/copy-still-to-clipboard.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyStillToClipBoard = void 0;
+const renderer_1 = require("@remotion/renderer");
+const copyStillToClipBoard = (img) => {
+    return renderer_1.RenderInternals.copyImageToClipboard(img, 'info');
+};
+exports.copyStillToClipBoard = copyStillToClipBoard;

package/dist/preview-server/render-queue/get-default-video-contexts.d.ts

@@ -0,0 +1,14 @@
+import type { AudioCodec, Codec } from '@remotion/renderer';
+import type { RenderType } from '../../editor/components/RenderModal/RenderModalAdvanced';
+export declare const getDefaultCodecs: ({ defaultConfigurationVideoCodec, compositionDefaultVideoCodec, renderType, defaultConfigurationAudioCodec, }: {
+    defaultConfigurationVideoCodec: Codec | null;
+    defaultConfigurationAudioCodec: AudioCodec | null;
+    compositionDefaultVideoCodec: Codec | null;
+    renderType: RenderType;
+}) => {
+    initialAudioCodec: AudioCodec;
+    initialVideoCodec: Codec;
+    initialRenderType: RenderType;
+    initialVideoCodecForAudioTab: Codec;
+    initialVideoCodecForVideoTab: Codec;
+};

package/dist/preview-server/render-queue/get-default-video-contexts.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultCodecs = void 0;
+const client_1 = require("@remotion/renderer/client");
+const getDefaultCodecs = ({ defaultConfigurationVideoCodec, compositionDefaultVideoCodec, renderType, defaultConfigurationAudioCodec, }) => {
+    var _a;
+    const userPreferredVideoCodec = (_a = compositionDefaultVideoCodec !== null && compositionDefaultVideoCodec !== void 0 ? compositionDefaultVideoCodec : defaultConfigurationVideoCodec) !== null && _a !== void 0 ? _a : 'h264';
+    const isVideoCodecAnAudioCodec = client_1.BrowserSafeApis.isAudioCodec(userPreferredVideoCodec);
+    if (isVideoCodecAnAudioCodec) {
+        return {
+            initialAudioCodec: userPreferredVideoCodec,
+            initialRenderType: 'audio',
+            initialVideoCodec: userPreferredVideoCodec,
+            initialVideoCodecForAudioTab: userPreferredVideoCodec,
+            initialVideoCodecForVideoTab: client_1.BrowserSafeApis.isAudioCodec(defaultConfigurationVideoCodec)
+                ? 'h264'
+                : defaultConfigurationVideoCodec,
+        };
+    }
+    const suitableAudioCodecForVideoCodec = client_1.BrowserSafeApis.defaultAudioCodecs[userPreferredVideoCodec].compressed;
+    return {
+        initialAudioCodec: defaultConfigurationAudioCodec !== null && defaultConfigurationAudioCodec !== void 0 ? defaultConfigurationAudioCodec : suitableAudioCodecForVideoCodec,
+        initialVideoCodec: userPreferredVideoCodec,
+        initialRenderType: renderType,
+        initialVideoCodecForAudioTab: userPreferredVideoCodec,
+        initialVideoCodecForVideoTab: userPreferredVideoCodec,
+    };
+};
+exports.getDefaultCodecs = getDefaultCodecs;

package/dist/preview-server/render-queue/job.d.ts

@@ -0,0 +1,187 @@
+import type { AudioCodec, Codec, ColorSpace, LogLevel, makeCancelSignal, PixelFormat, ProResProfile, StillImageFormat, VideoImageFormat, X264Preset } from '@remotion/renderer';
+import type { EnumPath } from '../../editor/components/RenderModal/SchemaEditor/extract-enum-json-paths';
+import type { AggregateRenderProgress } from '../../progress-types';
+import type { RequiredChromiumOptions } from '../../required-chromium-options';
+import type { PackageManager } from '../get-package-manager';
+type BaseRenderProgress = {
+    message: string;
+    value: number;
+};
+type RenderJobDynamicStatus = {
+    status: 'done';
+    progress: BaseRenderProgress & AggregateRenderProgress;
+} | {
+    status: 'running';
+    progress: BaseRenderProgress & AggregateRenderProgress;
+} | {
+    status: 'idle';
+} | {
+    status: 'failed';
+    error: {
+        message: string;
+        stack: string | undefined;
+    };
+};
+export type JobProgressCallback = (options: BaseRenderProgress & AggregateRenderProgress) => void;
+type RenderJobDynamicFields = ({
+    type: 'still';
+    imageFormat: StillImageFormat;
+    jpegQuality: number;
+    frame: number;
+    scale: number;
+    offthreadVideoCacheSizeInBytes: number | null;
+} & RenderJobDynamicStatus) | ({
+    type: 'sequence';
+    imageFormat: VideoImageFormat;
+    jpegQuality: number | null;
+    scale: number;
+    concurrency: number;
+    startFrame: number;
+    endFrame: number;
+    offthreadVideoCacheSizeInBytes: number | null;
+} & RenderJobDynamicStatus) | ({
+    type: 'video';
+    imageFormat: VideoImageFormat;
+    jpegQuality: number | null;
+    scale: number;
+    codec: Codec;
+    audioCodec: AudioCodec;
+    concurrency: number;
+    crf: number | null;
+    startFrame: number;
+    endFrame: number;
+    muted: boolean;
+    enforceAudioTrack: boolean;
+    proResProfile: ProResProfile | null;
+    x264Preset: X264Preset | null;
+    pixelFormat: PixelFormat;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    disallowParallelEncoding: boolean;
+    offthreadVideoCacheSizeInBytes: number | null;
+    colorSpace: ColorSpace;
+} & RenderJobDynamicStatus);
+export type RenderJob = {
+    startedAt: number;
+    compositionId: string;
+    id: string;
+    outName: string;
+    deletedOutputLocation: boolean;
+    logLevel: LogLevel;
+    delayRenderTimeout: number;
+    cancelToken: ReturnType<typeof makeCancelSignal>;
+    chromiumOptions: RequiredChromiumOptions;
+    envVariables: Record<string, string>;
+    serializedInputPropsWithCustomSchema: string;
+    multiProcessOnLinux: boolean;
+} & RenderJobDynamicFields;
+export type RenderJobWithCleanup = RenderJob & {
+    cleanup: (() => void)[];
+};
+type AddRenderRequestDynamicFields = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    jpegQuality: number;
+    frame: number;
+    scale: number;
+    logLevel: LogLevel;
+} | {
+    type: 'sequence';
+    imageFormat: VideoImageFormat;
+    jpegQuality: number | null;
+    scale: number;
+    logLevel: LogLevel;
+    concurrency: number;
+    startFrame: number;
+    endFrame: number;
+    disallowParallelEncoding: boolean;
+} | {
+    type: 'video';
+    codec: Codec;
+    audioCodec: AudioCodec;
+    imageFormat: VideoImageFormat;
+    jpegQuality: number | null;
+    scale: number;
+    logLevel: LogLevel;
+    concurrency: number;
+    crf: number | null;
+    startFrame: number;
+    endFrame: number;
+    muted: boolean;
+    enforceAudioTrack: boolean;
+    proResProfile: ProResProfile | null;
+    x264Preset: X264Preset | null;
+    pixelFormat: PixelFormat;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    disallowParallelEncoding: boolean;
+    colorSpace: ColorSpace;
+};
+export type CancelRenderRequest = {
+    jobId: string;
+};
+export type CancelRenderResponse = {};
+export type AddRenderRequest = {
+    compositionId: string;
+    outName: string;
+    chromiumOptions: RequiredChromiumOptions;
+    delayRenderTimeout: number;
+    envVariables: Record<string, string>;
+    serializedInputPropsWithCustomSchema: string;
+    offthreadVideoCacheSizeInBytes: number | null;
+    multiProcessOnLinux: boolean;
+} & AddRenderRequestDynamicFields;
+export type RemoveRenderRequest = {
+    jobId: string;
+};
+export type OpenInFileExplorerRequest = {
+    directory: string;
+};
+export type CopyStillToClipboardRequest = {
+    outName: string;
+};
+export type SubscribeToFileExistenceRequest = {
+    file: string;
+    clientId: string;
+};
+export type SubscribeToFileExistenceResponse = {
+    exists: boolean;
+};
+export type UnsubscribeFromFileExistenceRequest = {
+    file: string;
+    clientId: string;
+};
+export type UpdateDefaultPropsRequest = {
+    compositionId: string;
+    defaultProps: string;
+    enumPaths: EnumPath[];
+};
+export type UpdateDefaultPropsResponse = {
+    success: true;
+} | {
+    success: false;
+    reason: string;
+    stack: string;
+};
+export type CanUpdateDefaultPropsRequest = {
+    compositionId: string;
+};
+export type CanUpdateDefaultPropsResponse = {
+    canUpdate: true;
+} | {
+    canUpdate: false;
+    reason: string;
+};
+export type UpdateAvailableRequest = {};
+export type UpdateAvailableResponse = {
+    currentVersion: string;
+    latestVersion: string;
+    updateAvailable: boolean;
+    timedOut: boolean;
+    packageManager: PackageManager | 'unknown';
+};
+export {};

package/dist/preview-server/render-queue/job.js

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

package/dist/preview-server/render-queue/make-retry-payload.d.ts

@@ -0,0 +1,3 @@
+import type { RenderModalState } from '../../editor/state/modals';
+import type { RenderJob } from './job';
+export declare const makeRetryPayload: (job: RenderJob) => RenderModalState;

package/dist/preview-server/render-queue/make-retry-payload.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRetryPayload = void 0;
+const no_react_1 = require("remotion/no-react");
+const makeRetryPayload = (job) => {
+    var _a, _b, _c, _d, _e;
+    const defaults = window.remotion_renderDefaults;
+    if (!defaults) {
+        throw new Error('defaults not set');
+    }
+    if (job.type === 'still') {
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialFrame: job.frame,
+            initialStillImageFormat: job.imageFormat,
+            initialVideoImageFormat: defaults.videoImageFormat,
+            initialJpegQuality: (_a = job.jpegQuality) !== null && _a !== void 0 ? _a : defaults.jpegQuality,
+            initialScale: job.scale,
+            initialLogLevel: job.logLevel,
+            initialConcurrency: defaults.concurrency,
+            maxConcurrency: defaults.maxConcurrency,
+            minConcurrency: defaults.minConcurrency,
+            initialMuted: defaults.muted,
+            initialEnforceAudioTrack: defaults.enforceAudioTrack,
+            initialProResProfile: defaults.proResProfile,
+            initialx264Preset: defaults.x264Preset,
+            initialPixelFormat: defaults.pixelFormat,
+            initialAudioBitrate: defaults.audioBitrate,
+            initialVideoBitrate: defaults.videoBitrate,
+            initialEveryNthFrame: defaults.everyNthFrame,
+            initialNumberOfGifLoops: defaults.numberOfGifLoops,
+            initialDelayRenderTimeout: job.delayRenderTimeout,
+            defaultConfigurationAudioCodec: defaults.audioCodec,
+            initialEnvVariables: job.envVariables,
+            initialDisableWebSecurity: job.chromiumOptions.disableWebSecurity,
+            initialOpenGlRenderer: job.chromiumOptions.gl,
+            initialHeadless: job.chromiumOptions.headless,
+            initialIgnoreCertificateErrors: job.chromiumOptions.ignoreCertificateErrors,
+            defaultProps: no_react_1.NoReactInternals.deserializeJSONWithCustomFields(job.serializedInputPropsWithCustomSchema),
+            inFrameMark: null,
+            outFrameMark: null,
+            initialOffthreadVideoCacheSizeInBytes: job.offthreadVideoCacheSizeInBytes,
+            initialColorSpace: defaults.colorSpace,
+            initialMultiProcessOnLinux: job.multiProcessOnLinux,
+            defaultConfigurationVideoCodec: defaults.codec,
+        };
+    }
+    if (job.type === 'sequence') {
+        return {
+            type: 'render',
+            initialFrame: 0,
+            compositionId: job.compositionId,
+            initialVideoImageFormat: defaults.videoImageFormat,
+            initialJpegQuality: (_b = job.jpegQuality) !== null && _b !== void 0 ? _b : defaults.jpegQuality,
+            initialScale: job.scale,
+            initialLogLevel: job.logLevel,
+            initialConcurrency: defaults.concurrency,
+            maxConcurrency: defaults.maxConcurrency,
+            minConcurrency: defaults.minConcurrency,
+            initialMuted: defaults.muted,
+            initialEnforceAudioTrack: defaults.enforceAudioTrack,
+            initialProResProfile: defaults.proResProfile,
+            initialx264Preset: defaults.x264Preset,
+            initialPixelFormat: defaults.pixelFormat,
+            initialAudioBitrate: defaults.audioBitrate,
+            initialVideoBitrate: defaults.videoBitrate,
+            initialEveryNthFrame: defaults.everyNthFrame,
+            initialNumberOfGifLoops: defaults.numberOfGifLoops,
+            initialDelayRenderTimeout: job.delayRenderTimeout,
+            initialEnvVariables: job.envVariables,
+            initialDisableWebSecurity: job.chromiumOptions.disableWebSecurity,
+            initialOpenGlRenderer: job.chromiumOptions.gl,
+            initialHeadless: job.chromiumOptions.headless,
+            initialIgnoreCertificateErrors: job.chromiumOptions.ignoreCertificateErrors,
+            defaultProps: no_react_1.NoReactInternals.deserializeJSONWithCustomFields(job.serializedInputPropsWithCustomSchema),
+            initialStillImageFormat: defaults.stillImageFormat,
+            inFrameMark: job.startFrame,
+            outFrameMark: job.endFrame,
+            initialOffthreadVideoCacheSizeInBytes: job.offthreadVideoCacheSizeInBytes,
+            initialColorSpace: defaults.colorSpace,
+            initialMultiProcessOnLinux: job.multiProcessOnLinux,
+            defaultConfigurationVideoCodec: defaults.codec,
+            defaultConfigurationAudioCodec: defaults.audioCodec,
+        };
+    }
+    if (job.type === 'video') {
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialStillImageFormat: defaults.stillImageFormat,
+            initialVideoImageFormat: job.imageFormat,
+            initialJpegQuality: (_c = job.jpegQuality) !== null && _c !== void 0 ? _c : defaults.jpegQuality,
+            initialScale: job.scale,
+            initialLogLevel: job.logLevel,
+            initialFrame: 0,
+            initialConcurrency: job.concurrency,
+            maxConcurrency: defaults.maxConcurrency,
+            minConcurrency: defaults.minConcurrency,
+            initialMuted: job.muted,
+            initialEnforceAudioTrack: job.enforceAudioTrack,
+            initialProResProfile: (_d = job.proResProfile) !== null && _d !== void 0 ? _d : defaults.proResProfile,
+            initialx264Preset: (_e = job.x264Preset) !== null && _e !== void 0 ? _e : defaults.x264Preset,
+            initialPixelFormat: job.pixelFormat,
+            initialAudioBitrate: job.audioBitrate,
+            initialVideoBitrate: job.videoBitrate,
+            initialEveryNthFrame: job.everyNthFrame,
+            initialNumberOfGifLoops: job.numberOfGifLoops,
+            initialDelayRenderTimeout: job.delayRenderTimeout,
+            initialEnvVariables: job.envVariables,
+            initialDisableWebSecurity: job.chromiumOptions.disableWebSecurity,
+            initialOpenGlRenderer: job.chromiumOptions.gl,
+            initialHeadless: job.chromiumOptions.headless,
+            initialIgnoreCertificateErrors: job.chromiumOptions.ignoreCertificateErrors,
+            defaultProps: no_react_1.NoReactInternals.deserializeJSONWithCustomFields(job.serializedInputPropsWithCustomSchema),
+            inFrameMark: job.startFrame,
+            outFrameMark: job.endFrame,
+            initialOffthreadVideoCacheSizeInBytes: job.offthreadVideoCacheSizeInBytes,
+            initialColorSpace: job.colorSpace,
+            initialMultiProcessOnLinux: job.multiProcessOnLinux,
+            defaultConfigurationVideoCodec: defaults.codec,
+            defaultConfigurationAudioCodec: job.audioCodec,
+        };
+    }
+    throw new Error(`Job ${JSON.stringify(job)} Not implemented`);
+};
+exports.makeRetryPayload = makeRetryPayload;

package/dist/preview-server/render-queue/open-directory-in-finder.d.ts

@@ -0,0 +1 @@
+export declare const openDirectoryInFinder: (dirToOpen: string, allowedDirectory: string) => Promise<void>;