@remotion/cli 3.3.18 → 3.3.19

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processJobIfPossible = exports.removeJob = exports.addJob = exports.processJob = exports.notifyClientsOfJobUpdate = exports.getRenderQueue = void 0;
-const bundler_1 = require("@remotion/bundler");
 const renderer_1 = require("@remotion/renderer");
+const config_1 = require("../../config");
+const get_cli_options_1 = require("../../get-cli-options");
+const setup_cache_1 = require("../../setup-cache");
 const live_events_1 = require("../live-events");
 let jobQueue = [];
 const updateJob = (id, updater) => {
@@ -27,14 +29,35 @@ const notifyClientsOfJobUpdate = () => {
     });
 };
 exports.notifyClientsOfJobUpdate = notifyClientsOfJobUpdate;
-const processJob = async (job, entryPoint) => {
+const processJob = async ({ job, remotionRoot, entryPoint, }) => {
     if (job.type === 'still') {
-        const serveUrl = await (0, bundler_1.bundle)({
-            entryPoint,
-            // TODO: Accept CLI options
+        const { publicDir, browserExecutable, ffmpegExecutable, ffprobeExecutable, chromiumOptions, envVariables, inputProps, port, scale, browser, puppeteerTimeout, } = await (0, get_cli_options_1.getCliOptions)({
+            isLambda: false,
+            type: 'get-compositions',
+            remotionRoot,
+        });
+        const browserInstance = (0, renderer_1.openBrowser)(browser, {
+            browserExecutable,
+            chromiumOptions,
+            shouldDumpIo: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+            forceDeviceScaleFactor: scale,
+        });
+        const serveUrl = await (0, setup_cache_1.bundleOnCli)({
+            fullPath: entryPoint,
+            publicDir,
+            remotionRoot,
+            steps: ['bundling'],
         });
         const compositions = await (0, renderer_1.getCompositions)(serveUrl, {
-        // TODO: Accept CLI option
+            browserExecutable,
+            chromiumOptions,
+            envVariables,
+            ffmpegExecutable,
+            ffprobeExecutable,
+            inputProps,
+            port,
+            puppeteerInstance: await browserInstance,
+            timeoutInMilliseconds: puppeteerTimeout,
         });
         const composition = compositions.find((c) => {
             return c.id === job.compositionId;
@@ -46,15 +69,33 @@ const processJob = async (job, entryPoint) => {
             composition,
             output: job.outputLocation,
             serveUrl,
+            browserExecutable,
+            chromiumOptions,
+            envVariables,
+            ffmpegExecutable,
+            ffprobeExecutable,
+            scale,
+            timeoutInMilliseconds: puppeteerTimeout,
+            // TODO: Write download progress to CLI
+            overwrite: false,
+            // TODO: Allow user to overwrite file
+            port,
+            inputProps,
+            puppeteerInstance: await browserInstance,
+            // TODO: Allow to specify quality
+            // TODO: Allow to customize image format
+            imageFormat: 'png',
+            // TODO: Allow specific frame
+            // TODO: Allow cancel signal
             // TODO: Accept CLI options
         });
     }
     throw new TypeError(`Could not process job of type ${job.type}`);
 };
 exports.processJob = processJob;
-const addJob = (job, entryPoint) => {
+const addJob = ({ job, entryPoint, remotionRoot, }) => {
     jobQueue.push(job);
-    (0, exports.processJobIfPossible)(entryPoint);
+    (0, exports.processJobIfPossible)({ entryPoint, remotionRoot });
     (0, exports.notifyClientsOfJobUpdate)();
 };
 exports.addJob = addJob;
@@ -63,7 +104,7 @@ const removeJob = (jobId) => {
     (0, exports.notifyClientsOfJobUpdate)();
 };
 exports.removeJob = removeJob;
-const processJobIfPossible = async (entryPoint) => {
+const processJobIfPossible = async ({ remotionRoot, entryPoint, }) => {
     const nextJob = jobQueue.find((q) => {
         return q.status === 'idle';
     });
@@ -77,7 +118,7 @@ const processJobIfPossible = async (entryPoint) => {
                 status: 'running',
             };
         });
-        await (0, exports.processJob)(nextJob, entryPoint);
+        await (0, exports.processJob)({ job: nextJob, entryPoint, remotionRoot });
         updateJob(nextJob.id, (job) => {
             return {
                 ...job,

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

@@ -1,29 +1,79 @@
+import type { Codec, StillImageFormat } from '@remotion/renderer';
 declare type RenderJobDynamicStatus = {
     status: 'done';
 } | {
     status: 'running';
+    progress: number;
+    message: string;
 } | {
     status: 'idle';
 } | {
     status: 'failed';
-    error: Error;
+    error: {
+        message: string;
+        stack: string | undefined;
+    };
+};
+export declare type JobProgressCallback = (options: {
+    progress: number;
+    message: string;
+}) => void;
+declare type RenderJobDynamicFields = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    frame: number;
+    scale: number;
+} | {
+    type: 'video';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    scale: number;
+    codec: Codec;
 };
 export declare type RenderJob = {
     startedAt: number;
     compositionId: string;
-    type: 'still' | 'composition';
     id: string;
-    outputLocation: string;
-} & RenderJobDynamicStatus;
+    outName: string;
+    deletedOutputLocation: boolean;
+    verbose: boolean;
+} & RenderJobDynamicStatus & RenderJobDynamicFields;
+export declare type RenderJobWithCleanup = RenderJob & {
+    cleanup: (() => void)[];
+};
+declare type AddRenderRequestDynamicFields = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    frame: number;
+    scale: number;
+    verbose: boolean;
+} | {
+    type: 'video';
+    codec: Codec;
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    scale: number;
+    verbose: boolean;
+};
 export declare type AddRenderRequest = {
     compositionId: string;
-    type: 'still' | 'composition';
     outName: string;
-};
+} & AddRenderRequestDynamicFields;
 export declare type RemoveRenderRequest = {
     jobId: string;
 };
 export declare type OpenInFileExplorerRequest = {
     directory: string;
 };
+export declare type SubscribeToFileExistenceRequest = {
+    file: string;
+};
+export declare type SubscribeToFileExistenceResponse = {
+    exists: boolean;
+};
+export declare type UnsubscribeFromFileExistenceRequest = {
+    file: string;
+};
 export {};

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,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRetryPayload = void 0;
+const makeRetryPayload = (job) => {
+    if (job.type === 'still') {
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialFrame: job.frame,
+            initialImageFormat: job.imageFormat,
+            initialQuality: job.quality,
+            initialOutName: job.outName,
+            initialScale: job.scale,
+            initialVerbose: job.verbose,
+        };
+    }
+    if (job.type === 'video') {
+        // TODO: Implement correct retry mechanism for video
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialImageFormat: job.imageFormat,
+            initialQuality: job.quality,
+            initialOutName: job.outName,
+            initialScale: job.scale,
+            initialVerbose: job.verbose,
+            initialFrame: 0,
+        };
+    }
+    throw new Error(`Job ${JSON.stringify(job)} Not implemented`);
+};
+exports.makeRetryPayload = makeRetryPayload;

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

@@ -3,22 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.openDirectoryInFinder = void 0;
 const child_process_1 = require("child_process");
 const os_1 = require("os");
+const truthy_1 = require("../../truthy");
 const openDirectoryInFinder = (dirToOpen) => {
     const command = (0, os_1.platform)() === 'darwin'
         ? 'open'
         : (0, os_1.platform)() === 'linux'
             ? 'xdg-open'
-            : 'explorer';
-    // TODO: What if file was deleted in the meanwhile?
-    // TODO: '-R' only works on macOS
-    const p = (0, child_process_1.spawn)(command, ['-R', dirToOpen]);
+            : 'start';
+    const p = (0, child_process_1.spawn)(command, [(0, os_1.platform)() === 'darwin' ? '-R' : null, dirToOpen].filter(truthy_1.truthy));
+    const stderrChunks = [];
+    p.stderr.on('data', (d) => stderrChunks.push(d));
     return new Promise((resolve, reject) => {
         p.on('exit', (code) => {
             if (code === 0) {
                 resolve();
             }
             else {
-                reject(new Error(`Exited with code ${code}`));
+                const message = Buffer.concat(stderrChunks).toString('utf-8');
+                reject(new Error(message));
             }
         });
         p.on('error', (err) => {

package/dist/preview-server/render-queue/open-in-file-explorer.js

@@ -7,6 +7,7 @@ const handleOpenInFileExplorer = async (req, res) => {
     if (req.method === 'OPTIONS') {
         res.statusCode = 200;
         res.end();
+        return;
     }
     try {
         const body = (await (0, parse_body_1.parseRequestBody)(req));

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

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

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStill = void 0;
+const convert_entry_point_to_serve_url_1 = require("../../convert-entry-point-to-serve-url");
+const get_cli_options_1 = require("../../get-cli-options");
+const still_1 = require("../../render-flows/still");
+const processStill = async ({ job, remotionRoot, entryPoint, onProgress, }) => {
+    var _a;
+    if (job.type !== 'still') {
+        throw new Error('Expected still job');
+    }
+    const { publicDir, browserExecutable, ffmpegExecutable, ffprobeExecutable, chromiumOptions, envVariables, inputProps, port, browser, puppeteerTimeout, } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'still',
+        remotionRoot,
+    });
+    const fullEntryPoint = (0, convert_entry_point_to_serve_url_1.convertEntryPointToServeUrl)(entryPoint);
+    await (0, still_1.renderStillFlow)({
+        remotionRoot,
+        browser,
+        browserExecutable,
+        chromiumOptions,
+        entryPointReason: 'same as preview',
+        envVariables,
+        ffmpegExecutable,
+        ffprobeExecutable,
+        height: null,
+        fullEntryPoint,
+        inputProps,
+        overwrite: true,
+        port,
+        publicDir,
+        puppeteerTimeout,
+        quality: (_a = job.quality) !== null && _a !== void 0 ? _a : undefined,
+        remainingArgs: [],
+        scale: job.scale,
+        stillFrame: job.frame,
+        width: null,
+        compositionIdFromUi: job.compositionId,
+        imageFormatFromUi: job.imageFormat,
+        configFileImageFormat: undefined,
+        logLevel: job.verbose ? 'verbose' : 'info',
+        onProgress,
+        indentOutput: true,
+    });
+    // TODO: Allow cancel signal
+    // TODO: Accept CLI options
+};
+exports.processStill = processStill;

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

@@ -0,0 +1,7 @@
+import type { JobProgressCallback, RenderJob } from './job';
+export declare const processVideoJob: ({ job, remotionRoot, entryPoint, onProgress, }: {
+    job: RenderJob;
+    remotionRoot: string;
+    entryPoint: string;
+    onProgress: JobProgressCallback;
+}) => Promise<void>;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processVideoJob = void 0;
+const convert_entry_point_to_serve_url_1 = require("../../convert-entry-point-to-serve-url");
+const get_cli_options_1 = require("../../get-cli-options");
+const render_1 = require("../../render-flows/render");
+const processVideoJob = async ({ job, remotionRoot, entryPoint, onProgress, }) => {
+    var _a;
+    if (job.type !== 'video') {
+        throw new Error('Expected still job');
+    }
+    const { publicDir, browserExecutable, ffmpegExecutable, ffprobeExecutable, chromiumOptions, envVariables, inputProps, port, browser, puppeteerTimeout, } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'still',
+        remotionRoot,
+    });
+    const fullEntryPoint = (0, convert_entry_point_to_serve_url_1.convertEntryPointToServeUrl)(entryPoint);
+    await (0, render_1.renderCompFlow)({
+        remotionRoot,
+        browser,
+        browserExecutable,
+        chromiumOptions,
+        entryPointReason: 'same as preview',
+        envVariables,
+        ffmpegExecutable,
+        ffprobeExecutable,
+        height: null,
+        fullEntryPoint,
+        inputProps,
+        overwrite: true,
+        port,
+        publicDir,
+        puppeteerTimeout,
+        quality: (_a = job.quality) !== null && _a !== void 0 ? _a : undefined,
+        remainingArgs: [],
+        scale: job.scale,
+        width: null,
+        compositionIdFromUi: job.compositionId,
+        configFileImageFormat: undefined,
+        logLevel: job.verbose ? 'verbose' : 'info',
+        onProgress,
+        indentOutput: true,
+        // TODO: Make configurable
+        concurrency: null,
+        // TODO: Make configurable
+        everyNthFrame: 1,
+        // TODO: Make configurable
+        frameRange: null,
+        quiet: false,
+        shouldOutputImageSequence: false,
+    });
+    // TODO: Allow cancel signal
+    // TODO: Accept CLI options
+};
+exports.processVideoJob = processVideoJob;

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

@@ -0,0 +1,19 @@
+import type { JobProgressCallback, RenderJob, RenderJobWithCleanup } from './job';
+export declare const getRenderQueue: () => RenderJob[];
+export declare const notifyClientsOfJobUpdate: () => void;
+export declare const processJob: ({ job, remotionRoot, entryPoint, onProgress, }: {
+    job: RenderJob;
+    remotionRoot: string;
+    entryPoint: string;
+    onProgress: JobProgressCallback;
+}) => Promise<void>;
+export declare const addJob: ({ job, entryPoint, remotionRoot, }: {
+    job: RenderJobWithCleanup;
+    entryPoint: string;
+    remotionRoot: string;
+}) => void;
+export declare const removeJob: (jobId: string) => void;
+export declare const processJobIfPossible: ({ remotionRoot, entryPoint, }: {
+    remotionRoot: string;
+    entryPoint: string;
+}) => Promise<void>;

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

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processJobIfPossible = exports.removeJob = exports.addJob = exports.processJob = exports.notifyClientsOfJobUpdate = exports.getRenderQueue = void 0;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = require("../../chalk");
+const file_watcher_1 = require("../../file-watcher");
+const log_1 = require("../../log");
+const live_events_1 = require("../live-events");
+const process_still_1 = require("./process-still");
+const process_video_1 = require("./process-video");
+let jobQueue = [];
+const updateJob = (id, updater) => {
+    jobQueue = jobQueue.map((j) => {
+        if (id === j.id) {
+            return updater(j);
+        }
+        return j;
+    });
+    (0, exports.notifyClientsOfJobUpdate)();
+};
+const getRenderQueue = () => {
+    return jobQueue.map((j) => {
+        const { cleanup, ...rest } = j;
+        return rest;
+    });
+};
+exports.getRenderQueue = getRenderQueue;
+const notifyClientsOfJobUpdate = () => {
+    (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+        listener.sendEventToClient({
+            type: 'render-queue-updated',
+            queue: (0, exports.getRenderQueue)(),
+        });
+    });
+};
+exports.notifyClientsOfJobUpdate = notifyClientsOfJobUpdate;
+const processJob = async ({ job, remotionRoot, entryPoint, onProgress, }) => {
+    if (job.type === 'still') {
+        await (0, process_still_1.processStill)({ job, remotionRoot, entryPoint, onProgress });
+        return;
+    }
+    if (job.type === 'video') {
+        await (0, process_video_1.processVideoJob)({ job, remotionRoot, entryPoint, onProgress });
+        return;
+    }
+    throw new Error(`Unknown job ${JSON.stringify(job)}`);
+};
+exports.processJob = processJob;
+const addJob = ({ job, entryPoint, remotionRoot, }) => {
+    jobQueue.push(job);
+    (0, exports.processJobIfPossible)({ entryPoint, remotionRoot });
+    (0, exports.notifyClientsOfJobUpdate)();
+};
+exports.addJob = addJob;
+const removeJob = (jobId) => {
+    jobQueue = jobQueue.filter((job) => {
+        if (job.id === jobId) {
+            job.cleanup.forEach((c) => {
+                c();
+            });
+            return false;
+        }
+        return true;
+    });
+    (0, exports.notifyClientsOfJobUpdate)();
+};
+exports.removeJob = removeJob;
+const processJobIfPossible = async ({ remotionRoot, entryPoint, }) => {
+    const nextJob = jobQueue.find((q) => {
+        return q.status === 'idle';
+    });
+    if (!nextJob) {
+        return;
+    }
+    try {
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'running',
+                progress: 0,
+                message: 'Starting job...',
+            };
+        });
+        const startTime = Date.now();
+        log_1.Log.info(chalk_1.chalk.gray('╭─ Starting render '));
+        await (0, exports.processJob)({
+            job: nextJob,
+            entryPoint,
+            remotionRoot,
+            onProgress: ({ message, progress }) => {
+                updateJob(nextJob.id, (job) => {
+                    return {
+                        ...job,
+                        status: 'running',
+                        progress,
+                        message,
+                    };
+                });
+            },
+        });
+        log_1.Log.info(chalk_1.chalk.gray('╰─ Done in ' + (Date.now() - startTime) + 'ms.'));
+        const { unwatch } = (0, file_watcher_1.installFileWatcher)({
+            file: path_1.default.resolve(remotionRoot, nextJob.outName),
+            onChange: (type) => {
+                if (type === 'created') {
+                    updateJob(nextJob.id, (job) => ({
+                        ...job,
+                        deletedOutputLocation: false,
+                    }));
+                }
+                if (type === 'deleted') {
+                    updateJob(nextJob.id, (job) => ({
+                        ...job,
+                        deletedOutputLocation: true,
+                    }));
+                }
+            },
+        });
+        updateJob(nextJob.id, (job) => ({
+            ...job,
+            status: 'done',
+            cleanup: [...job.cleanup, unwatch],
+        }));
+    }
+    catch (err) {
+        // TODO: Tell to look in preview to find the error
+        log_1.Log.error(chalk_1.chalk.gray('╰─ Render failed:'), err);
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'failed',
+                error: {
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        });
+        (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+            listener.sendEventToClient({
+                type: 'render-job-failed',
+                compositionId: nextJob.compositionId,
+                error: err,
+            });
+        });
+    }
+};
+exports.processJobIfPossible = processJobIfPossible;

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

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleRemoveRender = void 0;
-const _1 = require(".");
 const parse_body_1 = require("../parse-body");
+const queue_1 = require("./queue");
 const handleRemoveRender = async (req, res) => {
     if (req.method === 'OPTIONS') {
         res.statusCode = 200;
         res.end();
+        return;
     }
     try {
         const body = (await (0, parse_body_1.parseRequestBody)(req));
-        (0, _1.removeJob)(body.jobId);
+        (0, queue_1.removeJob)(body.jobId);
         res.setHeader('content-type', 'application/json');
         res.writeHead(200);
         res.end(JSON.stringify({

package/dist/preview-server/routes/add-render.d.ts

@@ -0,0 +1,3 @@
+import type { ApiHandler } from '../api-types';
+import type { AddRenderRequest } from '../render-queue/job';
+export declare const handleAddRender: ApiHandler<AddRenderRequest, undefined>;

package/dist/preview-server/routes/add-render.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAddRender = void 0;
+const queue_1 = require("../render-queue/queue");
+const handleAddRender = ({ input, entryPoint, remotionRoot, }) => {
+    const id = String(Math.random()).replace('0.', '');
+    if (input.type === 'video') {
+        (0, queue_1.addJob)({
+            entryPoint,
+            remotionRoot,
+            job: {
+                cleanup: [],
+                // TODO: Allow to change codec
+                codec: 'h264',
+                compositionId: input.compositionId,
+                deletedOutputLocation: false,
+                type: 'video',
+                status: 'idle',
+                id,
+                imageFormat: input.imageFormat,
+                outName: input.outName,
+                quality: input.quality,
+                scale: input.scale,
+                startedAt: Date.now(),
+                verbose: input.verbose,
+            },
+        });
+    }
+    if (input.type === 'still') {
+        (0, queue_1.addJob)({
+            job: {
+                compositionId: input.compositionId,
+                id: String(Math.random()).replace('0.', ''),
+                startedAt: Date.now(),
+                type: 'still',
+                outName: input.outName,
+                status: 'idle',
+                imageFormat: input.imageFormat,
+                quality: input.quality,
+                frame: input.frame,
+                scale: input.scale,
+                cleanup: [],
+                deletedOutputLocation: false,
+                verbose: input.verbose,
+            },
+            entryPoint,
+            remotionRoot,
+        });
+    }
+    return Promise.resolve(undefined);
+};
+exports.handleAddRender = handleAddRender;

package/dist/preview-server/routes/open-in-file-explorer.d.ts

@@ -0,0 +1,3 @@
+import type { ApiHandler } from '../api-types';
+import type { OpenInFileExplorerRequest } from '../render-queue/job';
+export declare const handleOpenInFileExplorer: ApiHandler<OpenInFileExplorerRequest, void>;

package/dist/preview-server/routes/open-in-file-explorer.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOpenInFileExplorer = void 0;
+const path_1 = __importDefault(require("path"));
+const open_directory_in_finder_1 = require("../render-queue/open-directory-in-finder");
+const handleOpenInFileExplorer = ({ input: { directory }, remotionRoot }) => {
+    const actualDirectory = path_1.default.resolve(remotionRoot, directory);
+    // TODO: Disallow opening file that is not in Remotion CWD
+    return (0, open_directory_in_finder_1.openDirectoryInFinder)(actualDirectory);
+};
+exports.handleOpenInFileExplorer = handleOpenInFileExplorer;

package/dist/preview-server/routes/remove-render.d.ts

@@ -0,0 +1,3 @@
+import type { ApiHandler } from '../api-types';
+import type { RemoveRenderRequest } from '../render-queue/job';
+export declare const handleRemoveRender: ApiHandler<RemoveRenderRequest, undefined>;