@remotion/renderer 4.0.0-lambda.3 → 4.0.0-newpaths.13

package/dist/browser/devtools-types.js

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

package/dist/browser/is-target-closed-err.d.ts

@@ -0,0 +1 @@
+export declare const isTargetClosedErr: (error: Error | undefined) => boolean | undefined;

package/dist/browser/is-target-closed-err.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTargetClosedErr = void 0;
+const isTargetClosedErr = (error) => {
+    var _a, _b;
+    return (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('Target closed')) ||
+        ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('Session closed')));
+};
+exports.isTargetClosedErr = isTargetClosedErr;

package/dist/browser/revisions.d.ts

@@ -15,7 +15,6 @@
  */
 declare type Revisions = Readonly<{
     readonly chromium: string;
-    readonly firefox: string;
 }>;
 export declare const PUPPETEER_REVISIONS: Revisions;
 export {};

package/dist/browser/revisions.js

@@ -18,5 +18,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PUPPETEER_REVISIONS = void 0;
 exports.PUPPETEER_REVISIONS = {
     chromium: '1002410',
-    firefox: 'latest',
 };

package/dist/browser/util.d.ts

@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 /// <reference types="node" />
-import { Protocol } from 'devtools-protocol';
-import { CDPSession } from './Connection';
-import { CommonEventEmitter } from './EventEmitter';
-export declare function getExceptionMessage(exceptionDetails: Protocol.Runtime.ExceptionDetails): string;
-export declare function valueFromRemoteObject(remoteObject: Protocol.Runtime.RemoteObject): any;
-export declare function releaseObject(client: CDPSession, remoteObject: Protocol.Runtime.RemoteObject): Promise<void>;
+import type { Browser } from './Browser';
+import type { CDPSession } from './Connection';
+import type { DevtoolsRemoteObject, ExceptionDetails } from './devtools-types';
+import type { CommonEventEmitter } from './EventEmitter';
+export declare function getExceptionMessage(exceptionDetails: ExceptionDetails): string;
+export declare function valueFromRemoteObject(remoteObject: DevtoolsRemoteObject): any;
+export declare function releaseObject(client: CDPSession, remoteObject: DevtoolsRemoteObject): Promise<void>;
 export interface PuppeteerEventListener {
     emitter: CommonEventEmitter;
     eventName: string | symbol;
@@ -36,7 +37,7 @@ export declare function evaluationString(fun: Function | string, ...args: unknow
 export declare function pageBindingDeliverResultString(name: string, seq: number, result: unknown): string;
 export declare function pageBindingDeliverErrorString(name: string, seq: number, message: string, stack?: string): string;
 export declare function pageBindingDeliverErrorValueString(name: string, seq: number, value: unknown): string;
-export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number): Promise<T>;
+export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number, browser: Browser): Promise<T>;
 interface ErrorLike extends Error {
     name: string;
     message: string;

package/dist/browser/util.js

@@ -79,7 +79,7 @@ function addEventListener(emitter, eventName, handler) {
 exports.addEventListener = addEventListener;
 function removeEventListeners(listeners) {
     for (const listener of listeners) {
-        listener.emitter.removeListener(listener.eventName, listener.handler);
+        listener.emitter.off(listener.eventName, listener.handler);
     }
     listeners.length = 0;
 }
@@ -128,7 +128,7 @@ function pageBindingDeliverErrorValueString(name, seq, value) {
     return evaluationString(deliverErrorValue, name, seq, value);
 }
 exports.pageBindingDeliverErrorValueString = pageBindingDeliverErrorValueString;
-async function waitWithTimeout(promise, taskName, timeout) {
+async function waitWithTimeout(promise, taskName, timeout, browser) {
     let reject;
     const timeoutError = new Errors_1.TimeoutError(`waiting for ${taskName} failed: timeout ${timeout}ms exceeded`);
     const timeoutPromise = new Promise((_res, rej) => {
@@ -141,7 +141,15 @@ async function waitWithTimeout(promise, taskName, timeout) {
         }, timeout);
     }
     try {
-        return await Promise.race([promise, timeoutPromise]);
+        return await Promise.race([
+            new Promise((_, rej) => {
+                browser.once("closed" /* BrowserEmittedEvents.Closed */, () => {
+                    return rej();
+                });
+            }),
+            promise,
+            timeoutPromise,
+        ]);
     }
     finally {
         if (timeoutTimer) {

package/dist/browser-executable.d.ts

@@ -0,0 +1 @@
+export declare type BrowserExecutable = string | null;

package/dist/browser-log.d.ts

@@ -1,4 +1,4 @@
-import { ConsoleMessageLocation, ConsoleMessageType } from 'puppeteer-core';
+import type { ConsoleMessageLocation, ConsoleMessageType } from './browser/ConsoleMessage';
 export declare type BrowserLog = {
     text: string;
     stackTrace: ConsoleMessageLocation[];

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+export declare type Browser = 'chrome' | 'firefox';
+export declare const DEFAULT_BROWSER: Browser;

package/dist/browser.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BROWSER = void 0;
+exports.DEFAULT_BROWSER = 'chrome';

package/dist/calculate-ffmpeg-filters.d.ts

@@ -1,4 +1,4 @@
-import { MediaAsset } from './assets/types';
+import type { MediaAsset } from './assets/types';
 export declare const calculateFfmpegFilter: ({ asset, fps, durationInFrames, channels, assetDuration, }: {
     asset: MediaAsset;
     fps: number;

package/dist/calculate-ffmpeg-filters.js

@@ -19,6 +19,7 @@ const calculateFfmpegFilter = ({ asset, fps, durationInFrames, channels, assetDu
         playbackRate: asset.playbackRate,
         durationInFrames,
         assetDuration,
+        allowAmplificationDuringRender: asset.allowAmplificationDuringRender,
     });
 };
 exports.calculateFfmpegFilter = calculateFfmpegFilter;

package/dist/calculate-sar-dar-pixels.d.ts

@@ -0,0 +1,9 @@
+export declare const calculateDisplayVideoSize: ({ darX, darY, x, y, }: {
+    x: number;
+    y: number;
+    darX: number;
+    darY: number;
+}) => {
+    width: number;
+    height: number;
+};

package/dist/calculate-sar-dar-pixels.js

@@ -0,0 +1,19 @@
+"use strict";
+// https://superuser.com/questions/907933/correct-aspect-ratio-without-re-encoding-video-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDisplayVideoSize = void 0;
+const calculateDisplayVideoSize = ({ darX, darY, x, y, }) => {
+    // We know two equations:
+    //   newWidth / newHeight = darX / darY
+    // and:
+    //   x * y = (newWidth * newHeight)
+    // I solved it then on pen and paper and simplified the formula:
+    const dimensions = x * y;
+    const newWidth = Math.sqrt(dimensions * (darX / darY));
+    const newHeight = dimensions / newWidth;
+    return {
+        height: Math.round(newHeight),
+        width: Math.round(newWidth),
+    };
+};
+exports.calculateDisplayVideoSize = calculateDisplayVideoSize;

package/dist/can-use-parallel-encoding.d.ts

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
+import type { Codec } from './codec';
 export declare const canUseParallelEncoding: (codec: Codec) => boolean;

package/dist/can-use-parallel-encoding.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canUseParallelEncoding = void 0;
-const remotion_1 = require("remotion");
+const is_audio_codec_1 = require("./is-audio-codec");
 const canUseParallelEncoding = (codec) => {
-    if (remotion_1.Internals.isAudioCodec(codec)) {
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
         return false;
     }
     return codec === 'h264' || codec === 'h264-mkv' || codec === 'h265';

package/dist/check-apple-silicon.d.ts

@@ -0,0 +1 @@
+export declare const checkNodeVersionAndWarnAboutRosetta: () => void;

package/dist/check-apple-silicon.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNodeVersionAndWarnAboutRosetta = void 0;
+const os = __importStar(require("os"));
+const checkNodeVersionAndWarnAboutRosetta = () => {
+    // see https://github.com/nodejs/node/issues/41900#issuecomment-1113511254
+    const cpus = os.cpus();
+    const isAppleSilicon = cpus[0].model.includes('Apple');
+    const isArm64 = os.arch() === 'arm64';
+    const version = process.version.replace('v', '').split('.');
+    const majorVersion = Number(version[0]);
+    const requiredNodeVersion = 14;
+    if (majorVersion < 13) {
+        throw new Error(`Remotion requires at least Node ${requiredNodeVersion}. You currently have ${process.version}. Update your node version to ${requiredNodeVersion} to use Remotion.`);
+    }
+    if (isAppleSilicon && !isArm64) {
+        const recommendedNodeVersion = 16;
+        const recommendNodeUpgrade = majorVersion < recommendedNodeVersion;
+        console.warn([
+            `⚠️  Apple Silicon detected but Node.JS running under Rosetta. This will cause performance issues.\n`,
+            `Recommended actions:\n`,
+            recommendNodeUpgrade
+                ? ` - Upgrade to Node ${recommendedNodeVersion} or later\n`
+                : ' - Run Node using `arch -arm64` architecture\n',
+            'See https://remotion.dev/docs/troubleshooting/rosetta for more information.',
+            '---',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+    }
+};
+exports.checkNodeVersionAndWarnAboutRosetta = checkNodeVersionAndWarnAboutRosetta;

package/dist/client.d.ts

@@ -0,0 +1,3 @@
+export declare const BrowserSafeApis: {
+    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";
+};

package/dist/client.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserSafeApis = void 0;
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+exports.BrowserSafeApis = {
+    getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
+};

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

@@ -0,0 +1,8 @@
+import type { Codec } from './codec';
+declare type MediaSupport = {
+    video: boolean;
+    audio: boolean;
+};
+export declare const codecSupportsMedia: (codec: Codec) => MediaSupport;
+export declare const codecSupportsCrf: (codec: Codec) => boolean | "" | null;
+export {};

package/dist/codec-supports-media.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codecSupportsCrf = exports.codecSupportsMedia = void 0;
+const get_codec_name_1 = require("./get-codec-name");
+const support = {
+    'h264-mkv': {
+        audio: true,
+        video: true,
+    },
+    aac: {
+        audio: true,
+        video: false,
+    },
+    gif: {
+        video: true,
+        audio: false,
+    },
+    h264: {
+        video: true,
+        audio: true,
+    },
+    h265: {
+        video: true,
+        audio: true,
+    },
+    mp3: {
+        audio: true,
+        video: false,
+    },
+    prores: {
+        audio: true,
+        video: true,
+    },
+    vp8: {
+        audio: true,
+        video: true,
+    },
+    vp9: {
+        audio: true,
+        video: true,
+    },
+    wav: {
+        audio: true,
+        video: false,
+    },
+};
+const codecSupportsMedia = (codec) => {
+    return support[codec];
+};
+exports.codecSupportsMedia = codecSupportsMedia;
+const codecSupportsCrf = (codec) => {
+    const encoderName = (0, get_codec_name_1.getCodecName)(codec);
+    const supportsCrf = encoderName && codec !== 'prores';
+    return supportsCrf;
+};
+exports.codecSupportsCrf = codecSupportsCrf;

package/dist/codec.d.ts

@@ -0,0 +1,4 @@
+export declare const validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
+export declare type Codec = typeof validCodecs[number];
+export declare type CodecOrUndefined = Codec | undefined;
+export declare const DEFAULT_CODEC: Codec;

package/dist/codec.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CODEC = exports.validCodecs = void 0;
+exports.validCodecs = [
+    'h264',
+    'h265',
+    'vp8',
+    'vp9',
+    'mp3',
+    'aac',
+    'wav',
+    'prores',
+    'h264-mkv',
+    'gif',
+];
+exports.DEFAULT_CODEC = 'h264';

package/dist/combine-videos.d.ts

@@ -1,5 +1,6 @@
-import { Codec } from 'remotion';
-export declare const combineVideos: ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }: {
+import type { Codec } from './codec';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+declare type Options = {
     files: string[];
     filelistDir: string;
     output: string;
@@ -7,4 +8,9 @@ export declare const combineVideos: ({ files, filelistDir, output, onProgress, n
     numberOfFrames: number;
     codec: Codec;
     fps: number;
-}) => Promise<void>;
+    numberOfGifLoops: number | null;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+};
+export declare const combineVideos: (options: Options) => Promise<void>;
+export {};

package/dist/combine-videos.js

@@ -8,37 +8,45 @@ exports.combineVideos = void 0;
 const execa_1 = __importDefault(require("execa"));
 const fs_1 = require("fs");
 const path_1 = require("path");
-const remotion_1 = require("remotion");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const get_audio_codec_name_1 = require("./get-audio-codec-name");
+const is_audio_codec_1 = require("./is-audio-codec");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
-const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }) => {
+const truthy_1 = require("./truthy");
+const combineVideos = async (options) => {
     var _a;
+    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, } = options;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
     const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
     (0, fs_1.writeFileSync)(fileListTxt, fileList);
     try {
-        const task = (0, execa_1.default)('ffmpeg', [
-            remotion_1.Internals.isAudioCodec(codec) ? null : '-r',
-            remotion_1.Internals.isAudioCodec(codec) ? null : String(fps),
+        const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-r',
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : String(fps),
             '-f',
             'concat',
             '-safe',
             '0',
             '-i',
             fileListTxt,
-            remotion_1.Internals.isAudioCodec(codec) ? null : '-c:v',
-            remotion_1.Internals.isAudioCodec(codec) ? null : 'copy',
+            numberOfGifLoops === null ? null : '-loop',
+            numberOfGifLoops === null
+                ? null
+                : typeof numberOfGifLoops === 'number'
+                    ? String(numberOfGifLoops)
+                    : '-1',
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-c:v',
+            (0, is_audio_codec_1.isAudioCodec)(codec) ? null : codec === 'gif' ? 'gif' : 'copy',
             '-c:a',
             (0, get_audio_codec_name_1.getAudioCodecName)(codec),
-            // Set max bitrate up to 1024kbps, will choose lower if that's too much
+            // Set max bitrate up to 512kbps, will choose lower if that's too much
             '-b:a',
             '512K',
             codec === 'h264' ? '-movflags' : null,
             codec === 'h264' ? 'faststart' : null,
-            '-shortest',
             '-y',
             output,
-        ].filter(remotion_1.Internals.truthy));
+        ].filter(truthy_1.truthy));
         (_a = task.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
             if (onProgress) {
                 const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(data.toString());

package/dist/compositor/compose.d.ts

@@ -0,0 +1,13 @@
+import type { DownloadMap } from '../assets/download-map';
+import type { CompositorImageFormat, Layer } from './payloads';
+declare type CompositorInput = {
+    height: number;
+    width: number;
+    layers: Layer[];
+    imageFormat: CompositorImageFormat;
+};
+export declare const compose: ({ height, width, layers, output, downloadMap, imageFormat, }: CompositorInput & {
+    downloadMap: DownloadMap;
+    output: string;
+}) => Promise<void>;
+export {};

package/dist/compositor/compose.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const get_executable_path_1 = require("./get-executable-path");
+const getCompositorHash = ({ ...input }) => {
+    return (0, crypto_1.createHash)('sha256').update(JSON.stringify(input)).digest('base64');
+};
+const compose = async ({ height, width, layers, output, downloadMap, imageFormat, }) => {
+    const bin = (0, get_executable_path_1.getExecutablePath)();
+    const hash = getCompositorHash({ height, width, layers, imageFormat });
+    if (downloadMap.compositorCache[hash]) {
+        await (0, promises_1.copyFile)(downloadMap.compositorCache[hash], output);
+        return;
+    }
+    const payload = {
+        v: 1,
+        height,
+        width,
+        layers,
+        output,
+        output_format: imageFormat,
+    };
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(bin);
+        child.stdin.write(JSON.stringify(payload));
+        child.stdin.end();
+        const stderrChunks = [];
+        child.stderr.on('data', (d) => stderrChunks.push(d));
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                const message = Buffer.concat(stderrChunks).toString('utf-8');
+                const parsed = JSON.parse(message);
+                const err = new Error(parsed.error);
+                err.stack = parsed.error + '\n' + parsed.backtrace;
+                reject(err);
+            }
+        });
+    });
+    downloadMap.compositorCache[hash] = output;
+};
+exports.compose = compose;

package/dist/compositor/compositor.d.ts

@@ -0,0 +1,12 @@
+import type { CompositorCommand, CompositorInitiatePayload } from './payloads';
+export declare type Compositor = {
+    finishCommands: () => void;
+    executeCommand: (payload: Omit<CompositorCommand, 'nonce'>) => Promise<void>;
+    waitForDone: () => Promise<void>;
+};
+export declare const spawnCompositorOrReuse: ({ initiatePayload, renderId, }: {
+    initiatePayload: CompositorInitiatePayload;
+    renderId: string;
+}) => Compositor;
+export declare const releaseCompositorWithId: (renderId: string) => void;
+export declare const waitForCompositorWithIdToQuit: (renderId: string) => Promise<void>;

package/dist/compositor/compositor.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForCompositorWithIdToQuit = exports.releaseCompositorWithId = exports.spawnCompositorOrReuse = void 0;
+const child_process_1 = require("child_process");
+const get_executable_path_1 = require("./get-executable-path");
+const compositorMap = {};
+const spawnCompositorOrReuse = ({ initiatePayload, renderId, }) => {
+    if (!compositorMap[renderId]) {
+        compositorMap[renderId] = startCompositor(initiatePayload);
+    }
+    return compositorMap[renderId];
+};
+exports.spawnCompositorOrReuse = spawnCompositorOrReuse;
+const releaseCompositorWithId = (renderId) => {
+    if (compositorMap[renderId]) {
+        compositorMap[renderId].finishCommands();
+    }
+};
+exports.releaseCompositorWithId = releaseCompositorWithId;
+const waitForCompositorWithIdToQuit = (renderId) => {
+    if (!compositorMap[renderId]) {
+        throw new TypeError('No compositor with that id');
+    }
+    return compositorMap[renderId].waitForDone();
+};
+exports.waitForCompositorWithIdToQuit = waitForCompositorWithIdToQuit;
+const startCompositor = (compositorInitiatePayload) => {
+    const bin = (0, get_executable_path_1.getExecutablePath)();
+    const child = (0, child_process_1.spawn)(`${bin}`, [JSON.stringify(compositorInitiatePayload)]);
+    const stderrChunks = [];
+    let stdoutListeners = [];
+    // TODO: Without this the render gets stuck!! :O
+    child.stderr.on('data', (d) => {
+        console.log('stderr', d.toString('utf-8'));
+    });
+    child.stdout.on('data', (d) => {
+        const str = d.toString('utf-8');
+        try {
+            const payloads = str
+                .split('--debug-end--')
+                .map((t) => t.trim())
+                .filter(Boolean);
+            for (const payload of payloads) {
+                const p = JSON.parse(payload.replace('--debug-start--', ''));
+                if (p.msg_type === 'debug') {
+                    console.log('Rust debug', p.msg);
+                }
+                stdoutListeners.forEach((s) => s(p));
+            }
+        }
+        catch (e) {
+            console.log({ str });
+        }
+    });
+    let nonce = 0;
+    return {
+        waitForDone: () => {
+            return new Promise((resolve, reject) => {
+                child.on('exit', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(Buffer.concat(stderrChunks).toString('utf-8'));
+                    }
+                });
+            });
+        },
+        finishCommands: () => {
+            child.stdin.write('EOF\n');
+        },
+        executeCommand: (payload) => {
+            const actualPayload = {
+                ...payload,
+                nonce,
+            };
+            nonce++;
+            return new Promise((resolve, reject) => {
+                child.stdin.write(JSON.stringify(actualPayload) + '\n');
+                const onStdout = (p) => {
+                    if (p.msg_type === 'finish' && p.nonce === actualPayload.nonce) {
+                        resolve();
+                        stdoutListeners = stdoutListeners.filter((s) => s !== onStdout);
+                    }
+                    if (p.msg_type === 'error') {
+                        const err = new Error(p.error);
+                        err.stack = p.error + '\n' + p.backtrace;
+                        reject(err);
+                        stdoutListeners = stdoutListeners.filter((s) => s !== onStdout);
+                    }
+                };
+                stdoutListeners.push(onStdout);
+            });
+        },
+    };
+};

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

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