@remotion/renderer 4.0.404 → 4.0.406

package/dist/codec-supports-media.d.ts

@@ -1,9 +1,8 @@
-import type { Codec } from './codec';
 type MediaSupport = {
     video: boolean;
     audio: boolean;
 };
-export declare const codecSupportsMedia: (codec: Codec) => MediaSupport;
-export declare const codecSupportsCrf: (codec: Codec) => boolean;
-export declare const codecSupportsVideoBitrate: (codec: Codec) => boolean;
+export declare const codecSupportsMedia: (codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav") => MediaSupport;
+export declare const codecSupportsCrf: (codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav") => boolean;
+export declare const codecSupportsVideoBitrate: (codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav") => boolean;
 export {};

package/dist/collect-assets.d.ts

@@ -4,4 +4,4 @@ export declare const collectAssets: ({ frame, freePage, timeoutInMilliseconds, }
     frame: number;
     freePage: Page;
     timeoutInMilliseconds: number;
-}) => Promise<(import("remotion/no-react").AudioOrVideoAsset | ArtifactAsset | import("remotion/no-react").InlineAudioAsset)[]>;
+}) => Promise<(import("remotion/no-react").AudioOrVideoAsset | import("remotion/no-react").InlineAudioAsset | ArtifactAsset)[]>;

package/dist/combine-audio.d.ts

@@ -1,6 +1,4 @@
-import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
-import type { AudioCodec } from './options/audio-codec';
 export declare const durationOf1Frame: number;
 export declare const getClosestAlignedTime: (targetTime: number) => number;
 export declare const createCombinedAudio: ({ seamless, filelistDir, files, indent, logLevel, audioBitrate, resolvedAudioCodec, output, chunkDurationInSeconds, addRemotionMetadata, binariesDirectory, fps, cancelSignal, onProgress, }: {
@@ -8,9 +6,9 @@ export declare const createCombinedAudio: ({ seamless, filelistDir, files, inden
     filelistDir: string;
     files: string[];
     indent: boolean;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     audioBitrate: string | null;
-    resolvedAudioCodec: AudioCodec;
+    resolvedAudioCodec: "aac" | "mp3" | "opus" | "pcm-16";
     output: string;
     chunkDurationInSeconds: number;
     addRemotionMetadata: boolean;

package/dist/combine-chunks.d.ts

@@ -30,9 +30,8 @@ type OptionalCombineChunksOptions = {
     frameRange: FrameRange | null;
     everyNthFrame: number;
 };
-type AllCombineChunksOptions = MandatoryCombineChunksOptions & OptionalCombineChunksOptions;
 export type CombineChunksOptions = MandatoryCombineChunksOptions & Partial<OptionalCombineChunksOptions>;
-export declare const internalCombineChunks: ({ outputLocation: output, onProgress, codec, fps, numberOfGifLoops, audioBitrate, indent, logLevel, binariesDirectory, cancelSignal, metadata, audioFiles, videoFiles, framesPerChunk, audioCodec, preferLossless, everyNthFrame, frameRange, compositionDurationInFrames, }: AllCombineChunksOptions & {
+export declare const internalCombineChunks: ({ outputLocation: output, onProgress, codec, fps, numberOfGifLoops, audioBitrate, indent, logLevel, binariesDirectory, cancelSignal, metadata, audioFiles, videoFiles, framesPerChunk, audioCodec, preferLossless, everyNthFrame, frameRange, compositionDurationInFrames, }: MandatoryCombineChunksOptions & OptionalCombineChunksOptions & {
     indent: boolean;
 }) => Promise<void>;
 export declare const combineChunks: (options: CombineChunksOptions) => Promise<void>;

package/dist/combine-video-streams.d.ts

@@ -1,14 +1,12 @@
-import type { Codec } from './codec';
-import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 export declare const combineVideoStreams: ({ fps, codec, filelistDir, numberOfGifLoops, output, indent, logLevel, onProgress, files, addRemotionMetadata, binariesDirectory, cancelSignal, }: {
     fps: number;
-    codec: Codec;
+    codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
     filelistDir: string;
     numberOfGifLoops: number | null;
     output: string;
     indent: boolean;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     onProgress: (p: number) => void;
     files: string[];
     addRemotionMetadata: boolean;

package/dist/compositor/compositor.d.ts

@@ -1,6 +1,6 @@
-import type { LogLevel } from '../log-level';
 import type { CompositorCommand } from './payloads';
 export type Compositor = {
+    shutDownOrKill: () => Promise<void>;
     finishCommands: () => Promise<void>;
     executeCommand: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T]) => Promise<Uint8Array>;
     waitForDone: () => Promise<void>;
@@ -8,7 +8,7 @@ export type Compositor = {
 };
 export declare const startLongRunningCompositor: ({ maximumFrameCacheItemsInBytes, logLevel, indent, binariesDirectory, extraThreads, }: {
     maximumFrameCacheItemsInBytes: number | null;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     indent: boolean;
     binariesDirectory: string | null;
     extraThreads: number;
@@ -16,7 +16,7 @@ export declare const startLongRunningCompositor: ({ maximumFrameCacheItemsInByte
 export declare const startCompositor: <T extends keyof CompositorCommand>({ type, payload, logLevel, indent, binariesDirectory, }: {
     type: T;
     payload: CompositorCommand[T];
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     indent: boolean;
     binariesDirectory: string | null;
 }) => Compositor;

package/dist/compositor/compositor.js

@@ -107,42 +107,61 @@ const startCompositor = ({ type, payload, logLevel, indent, binariesDirectory =
         clear();
         stderrChunks = [];
     });
-    return {
-        waitForDone: () => {
-            return new Promise((res, rej) => {
-                if (runningStatus.type === 'quit-without-error') {
-                    rej(new Error(`Compositor quit${runningStatus.signal
-                        ? ` with signal ${runningStatus.signal}`
-                        : ''}`));
-                    return;
-                }
-                if (runningStatus.type === 'quit-with-error') {
-                    rej(new Error(`Compositor quit${runningStatus.signal
-                        ? ` with signal ${runningStatus.signal}`
-                        : ''}: ${runningStatus.error}`));
+    const waitForDone = () => {
+        return new Promise((res, rej) => {
+            if (runningStatus.type === 'quit-without-error') {
+                rej(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}`));
+                return;
+            }
+            if (runningStatus.type === 'quit-with-error') {
+                rej(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}: ${runningStatus.error}`));
+                return;
+            }
+            resolve = res;
+            reject = rej;
+        });
+    };
+    const finishCommands = async () => {
+        // Prevent this function from throwing an error if instead a rejected promise should be returned
+        await Promise.resolve();
+        if (runningStatus.type === 'quit-with-error') {
+            return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}: ${runningStatus.error}`));
+        }
+        if (runningStatus.type === 'quit-without-error') {
+            return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}`));
+        }
+        return new Promise((res, rej) => {
+            child.stdin.write('EOF\n', (e) => {
+                if (e) {
+                    rej(e);
                     return;
                 }
-                resolve = res;
-                reject = rej;
+                res();
             });
-        },
-        finishCommands: () => {
-            if (runningStatus.type === 'quit-with-error') {
-                return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}: ${runningStatus.error}`));
-            }
-            if (runningStatus.type === 'quit-without-error') {
-                return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ''}`));
-            }
-            return new Promise((res, rej) => {
-                child.stdin.write('EOF\n', (e) => {
-                    if (e) {
-                        rej(e);
-                        return;
-                    }
-                    res();
-                });
+        });
+    };
+    const shutDownOrKill = () => {
+        const shutDownCase = async () => {
+            await finishCommands();
+            await waitForDone();
+        };
+        let timeout = null;
+        const killCase = async () => {
+            await new Promise((res) => {
+                timeout = setTimeout(res, 5000);
             });
-        },
+            child.kill('SIGKILL');
+        };
+        return Promise.race([shutDownCase(), killCase()]).finally(() => {
+            if (timeout !== null) {
+                clearTimeout(timeout);
+            }
+        });
+    };
+    return {
+        shutDownOrKill,
+        waitForDone,
+        finishCommands,
         executeCommand: (command, params) => {
             return new Promise((_resolve, _reject) => {
                 if (runningStatus.type === 'quit-without-error') {

package/dist/compositor/get-executable-path.d.ts

@@ -1,12 +1,12 @@
 import type { LogLevel } from '../log-level';
-export declare function isMusl({ indent, logLevel, }: {
+export declare function isMusl({ indent, logLevel }: {
     indent: boolean;
     logLevel: LogLevel;
 }): boolean;
 export declare const getExecutablePath: ({ indent, logLevel, type, binariesDirectory, }: {
     type: "compositor" | "ffmpeg" | "ffprobe";
     indent: boolean;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     binariesDirectory: string | null;
 }) => string;
-export declare const getExecutableDir: (indent: boolean, logLevel: LogLevel) => string;
+export declare const getExecutableDir: (indent: boolean, logLevel: "error" | "info" | "trace" | "verbose" | "warn") => string;

package/dist/compress-audio.d.ts

@@ -1,11 +1,9 @@
-import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
-import type { AudioCodec } from './options/audio-codec';
 export declare const compressAudio: ({ audioCodec, outName, binariesDirectory, indent, logLevel, audioBitrate, cancelSignal, inName, onProgress, chunkLengthInSeconds, fps, }: {
-    audioCodec: AudioCodec;
+    audioCodec: "aac" | "mp3" | "opus" | "pcm-16";
     outName: string;
     indent: boolean;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     binariesDirectory: string | null;
     audioBitrate: string | null;
     cancelSignal: CancelSignal | undefined;

package/dist/create-audio.d.ts

@@ -1,8 +1,6 @@
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
-import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
-import type { AudioCodec } from './options/audio-codec';
 import type { FrameAndAssets } from './render-frames';
 export type SeamlessAudioInfo = {
     chunkLengthInSeconds: number;
@@ -13,14 +11,14 @@ export declare const createAudio: ({ assets, onDownload, fps, logLevel, onProgre
     assets: FrameAndAssets[];
     onDownload: RenderMediaOnDownload | undefined;
     fps: number;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     onProgress: (progress: number) => void;
     downloadMap: DownloadMap;
     remotionRoot: string;
     indent: boolean;
     binariesDirectory: string | null;
     audioBitrate: string | null;
-    audioCodec: AudioCodec;
+    audioCodec: "aac" | "mp3" | "opus" | "pcm-16";
     cancelSignal: CancelSignal | undefined;
     chunkLengthInSeconds: number;
     trimLeftOffset: number;

package/dist/create-silent-audio.d.ts

@@ -1,10 +1,9 @@
-import type { LogLevel } from './log-level';
 import type { CancelSignal } from './make-cancel-signal';
 export declare const createSilentAudio: ({ outName, indent, logLevel, binariesDirectory, cancelSignal, chunkLengthInSeconds, }: {
     chunkLengthInSeconds: number;
     outName: string;
     indent: boolean;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     binariesDirectory: string | null;
     cancelSignal: CancelSignal | undefined;
 }) => Promise<void>;

package/dist/crf.d.ts

@@ -1,13 +1,11 @@
-import type { HardwareAccelerationOption } from './client';
-import type { Codec } from './codec';
 export type Crf = number | undefined;
-export declare const getDefaultCrfForCodec: (codec: Codec) => number | null;
-export declare const getValidCrfRanges: (codec: Codec) => [number, number];
+export declare const getDefaultCrfForCodec: (codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav") => number | null;
+export declare const getValidCrfRanges: (codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav") => [number, number];
 export declare const validateQualitySettings: ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }: {
     crf: unknown;
-    codec: Codec;
+    codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
     videoBitrate: string | null;
     encodingMaxRate: string | null;
     encodingBufferSize: string | null;
-    hardwareAcceleration: HardwareAccelerationOption;
+    hardwareAcceleration: "disable" | "if-possible" | "required";
 }) => string[];

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

@@ -1,9 +1,8 @@
-import type { LogLevel } from './log-level';
 import type { BrowserReplacer } from './replace-browser';
 export declare const cycleBrowserTabs: ({ puppeteerInstance, concurrency, logLevel, indent, }: {
     puppeteerInstance: BrowserReplacer;
     concurrency: number;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     indent: boolean;
 }) => {
     stopCycling: () => void;

package/dist/ensure-browser.d.ts

@@ -20,5 +20,48 @@ export type EnsureBrowserOptions = Partial<{
     browserExecutable: BrowserExecutable;
 } & ToOptions<typeof BrowserSafeApis.optionsMap.ensureBrowser>>;
 export declare const internalEnsureBrowser: (options: InternalEnsureBrowserOptions) => Promise<BrowserStatus>;
-export declare const ensureBrowser: (options?: EnsureBrowserOptions) => Promise<BrowserStatus>;
+export declare const ensureBrowser: (options?: Partial<{
+    browserExecutable: BrowserExecutable;
+} & ToOptions<{
+    readonly logLevel: {
+        cliFlag: "log";
+        name: string;
+        ssrName: string;
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: "error" | "info" | "trace" | "verbose" | "warn";
+            source: string;
+        };
+        setConfig: (newLogLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
+        type: "error" | "info" | "trace" | "verbose" | "warn";
+    };
+    readonly onBrowserDownload: {
+        name: string;
+        cliFlag: "on-browser-download";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "onBrowserDownload";
+        docLink: string;
+        type: import(".").OnBrowserDownload;
+        getValue: () => never;
+        setConfig: () => never;
+    };
+    readonly chromeMode: {
+        cliFlag: "chrome-mode";
+        name: string;
+        ssrName: string;
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: "chrome-for-testing" | "headless-shell";
+            source: string;
+        };
+        setConfig: (newChromeMode: "chrome-for-testing" | "headless-shell") => void;
+        type: "chrome-for-testing" | "headless-shell";
+    };
+}>> | undefined) => Promise<BrowserStatus>;
 export {};

package/dist/error-handling/handle-javascript-exception.d.ts

@@ -6,7 +6,7 @@ export declare class ErrorWithStackFrame extends Error {
     chunk: number | null;
     name: string;
     delayRenderCall: SymbolicatedStackFrame[] | null;
-    constructor({ message, symbolicatedStackFrames, frame, name, delayRenderCall, stack, chunk, }: {
+    constructor({ message, symbolicatedStackFrames, frame, name, delayRenderCall, stack, chunk }: {
         message: string;
         symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
         frame: number | null;

package/dist/error-handling/handle-javascript-exception.js

@@ -4,6 +4,11 @@ exports.handleJavascriptException = exports.ErrorWithStackFrame = void 0;
 const no_react_1 = require("remotion/no-react");
 const symbolicateable_error_1 = require("./symbolicateable-error");
 class ErrorWithStackFrame extends Error {
+    symbolicatedStackFrames;
+    frame;
+    chunk;
+    name;
+    delayRenderCall;
     constructor({ message, symbolicatedStackFrames, frame, name, delayRenderCall, stack, chunk, }) {
         super(message);
         this.symbolicatedStackFrames = symbolicatedStackFrames;
@@ -17,7 +22,8 @@ class ErrorWithStackFrame extends Error {
 }
 exports.ErrorWithStackFrame = ErrorWithStackFrame;
 const cleanUpErrorMessage = (exception) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
+    var _d;
     let errorMessage = (_a = exception.exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description;
     if (!errorMessage) {
         return null;

package/dist/error-handling/symbolicateable-error.d.ts

@@ -7,7 +7,7 @@ export declare class SymbolicateableError extends Error {
     delayRenderCall: UnsymbolicatedStackFrame[] | null;
     frame: number | null;
     chunk: number | null;
-    constructor({ message, stack, stackFrame, frame, name, chunk, }: {
+    constructor({ message, stack, stackFrame, frame, name, chunk }: {
         message: string;
         stack: string | undefined;
         frame: number | null;

package/dist/error-handling/symbolicateable-error.js

@@ -6,6 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SymbolicateableError = void 0;
 const delay_render_embedded_stack_1 = require("../delay-render-embedded-stack");
 class SymbolicateableError extends Error {
+    stackFrame;
+    delayRenderCall;
+    frame;
+    chunk;
     constructor({ message, stack, stackFrame, frame, name, chunk, }) {
         super(message);
         this.stack = stack;

package/dist/error-handling.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapWithErrorHandling = void 0;
-var wrap_with_error_handling_1 = require("./wrap-with-error-handling");
+const wrap_with_error_handling_1 = require("./wrap-with-error-handling");
 Object.defineProperty(exports, "wrapWithErrorHandling", { enumerable: true, get: function () { return wrap_with_error_handling_1.wrapWithErrorHandling; } });

package/dist/esm/client.mjs

@@ -2529,11 +2529,16 @@ var scaleOption = {
   cliFlag: cliFlag42,
   description: () => /* @__PURE__ */ jsxs31(Fragment38, {
     children: [
-      "Scales the output by a factor. For example, a 1280x720px frame will become a 1920x1080px frame with a scale factor of ",
+      "Scales the output dimensions by a factor. For example, a 1280x720px frame will become a 1920x1080px frame with a scale factor of ",
       /* @__PURE__ */ jsx38("code", {
         children: "1.5"
       }),
-      ". Vector elements like fonts and HTML markups will be rendered with extra details."
+      ". See ",
+      /* @__PURE__ */ jsx38("a", {
+        href: "https://www.remotion.dev/docs/scaling",
+        children: "Scaling"
+      }),
+      " for more details."
     ]
   }),
   ssrName: "scale",

package/dist/esm/index.mjs

@@ -542,8 +542,14 @@ var tryToObtainBody = async (file) => {
 };
 
 // src/assets/download-file.ts
+var CANCELLED_ERROR = "cancelled";
 var incorrectContentLengthToken = "Download finished with";
-var downloadFileWithoutRetries = ({ onProgress, url, to: toFn }) => {
+var downloadFileWithoutRetries = ({
+  onProgress,
+  url,
+  to: toFn,
+  abortSignal
+}) => {
   return new Promise((resolve, reject) => {
     let rejected = false;
     let resolved = false;
@@ -578,11 +584,20 @@ var downloadFileWithoutRetries = ({ onProgress, url, to: toFn }) => {
     let closeConnection = () => {
       return;
     };
+    const onAbort = () => {
+      rejectAndFlag(new Error(CANCELLED_ERROR));
+      closeConnection();
+    };
+    abortSignal.addEventListener("abort", onAbort);
     readFile(url).then(({ response, request }) => {
       closeConnection = () => {
         request.destroy();
         response.destroy();
       };
+      if (abortSignal.aborted) {
+        onAbort();
+        return;
+      }
       const contentDisposition = response.headers["content-disposition"] ?? null;
       const contentType = response.headers["content-type"] ?? null;
       const to = toFn(contentDisposition, contentType);
@@ -634,6 +649,8 @@ var downloadFileWithoutRetries = ({ onProgress, url, to: toFn }) => {
       });
     }).catch((err) => {
       rejectAndFlag(err);
+    }).finally(() => {
+      abortSignal.removeEventListener("abort", onAbort);
     });
   });
 };
@@ -643,6 +660,9 @@ var downloadFile = async (options, retries = 2, attempt = 1) => {
     return res;
   } catch (err) {
     const { message } = err;
+    if (message === CANCELLED_ERROR) {
+      throw err;
+    }
     if (message === "aborted" || message.includes("ECONNRESET") || message.includes(incorrectContentLengthToken) || message.includes("503") || message.includes("502") || message.includes("504") || message.includes("500")) {
       if (retries === 0) {
         throw err;
@@ -4855,7 +4875,8 @@ var downloadBrowser = async ({
         });
       },
       indent,
-      logLevel
+      logLevel,
+      abortSignal: new AbortController().signal
     });
     await extractZip(archivePath, { dir: outputPath });
     const chromePath = path8.join(outputPath, "chrome-linux", "chrome");
@@ -14541,7 +14562,8 @@ var downloadAsset = async ({
       contentType
     }),
     indent,
-    logLevel
+    logLevel,
+    abortSignal: downloadMap.cleanupController.signal
   });
   notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to });
   if (shouldAnalyzeAudioImmediately) {
@@ -14801,39 +14823,61 @@ ${parsed.backtrace}`));
     clear();
     stderrChunks = [];
   });
-  return {
-    waitForDone: () => {
-      return new Promise((res, rej) => {
-        if (runningStatus.type === "quit-without-error") {
-          rej(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}`));
-          return;
-        }
-        if (runningStatus.type === "quit-with-error") {
-          rej(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}: ${runningStatus.error}`));
-          return;
-        }
-        resolve2 = res;
-        reject = rej;
-      });
-    },
-    finishCommands: () => {
-      if (runningStatus.type === "quit-with-error") {
-        return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}: ${runningStatus.error}`));
-      }
+  const waitForDone = () => {
+    return new Promise((res, rej) => {
       if (runningStatus.type === "quit-without-error") {
-        return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}`));
+        rej(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}`));
+        return;
       }
-      return new Promise((res, rej) => {
-        child.stdin.write(`EOF
+      if (runningStatus.type === "quit-with-error") {
+        rej(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}: ${runningStatus.error}`));
+        return;
+      }
+      resolve2 = res;
+      reject = rej;
+    });
+  };
+  const finishCommands = async () => {
+    await Promise.resolve();
+    if (runningStatus.type === "quit-with-error") {
+      return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}: ${runningStatus.error}`));
+    }
+    if (runningStatus.type === "quit-without-error") {
+      return Promise.reject(new Error(`Compositor quit${runningStatus.signal ? ` with signal ${runningStatus.signal}` : ""}`));
+    }
+    return new Promise((res, rej) => {
+      child.stdin.write(`EOF
 `, (e) => {
-          if (e) {
-            rej(e);
-            return;
-          }
-          res();
-        });
+        if (e) {
+          rej(e);
+          return;
+        }
+        res();
       });
-    },
+    });
+  };
+  const shutDownOrKill = () => {
+    const shutDownCase = async () => {
+      await finishCommands();
+      await waitForDone();
+    };
+    let timeout = null;
+    const killCase = async () => {
+      await new Promise((res) => {
+        timeout = setTimeout(res, 5000);
+      });
+      child.kill("SIGKILL");
+    };
+    return Promise.race([shutDownCase(), killCase()]).finally(() => {
+      if (timeout !== null) {
+        clearTimeout(timeout);
+      }
+    });
+  };
+  return {
+    shutDownOrKill,
+    waitForDone,
+    finishCommands,
     executeCommand: (command, params) => {
       return new Promise((_resolve, _reject) => {
         if (runningStatus.type === "quit-without-error") {
@@ -14941,13 +14985,8 @@ var startOffthreadVideoServer = ({
     binariesDirectory
   });
   return {
-    close: async () => {
-      try {
-        await compositor.finishCommands();
-        return compositor.waitForDone();
-      } catch (err) {
-        return Promise.reject(err);
-      }
+    close: () => {
+      return compositor.shutDownOrKill();
     },
     listener: (req, response) => {
       if (!req.url) {
@@ -15320,13 +15359,15 @@ var makeDownloadMap = () => {
     isPreventedFromCleanup: () => {
       return prevented;
     },
-    inlineAudioMixing: makeInlineAudioMixing(dir)
+    inlineAudioMixing: makeInlineAudioMixing(dir),
+    cleanupController: new AbortController
   };
 };
 var cleanDownloadMap = (downloadMap) => {
   if (downloadMap.isPreventedFromCleanup()) {
     return;
   }
+  downloadMap.cleanupController.abort();
   deleteDirectory(downloadMap.downloadDir);
   deleteDirectory(downloadMap.complexFilter);
   deleteDirectory(downloadMap.compositingDir);

package/dist/extract-audio.d.ts

@@ -1,7 +1,6 @@
-import type { LogLevel } from './log-level';
 export declare const extractAudio: (options: {
     videoSource: string;
     audioOutput: string;
-    logLevel?: LogLevel;
-    binariesDirectory?: string | null;
+    logLevel?: "error" | "info" | "trace" | "verbose" | "warn" | undefined;
+    binariesDirectory?: string | null | undefined;
 }) => Promise<void>;