@remotion/webcodecs 4.0.226 → 4.0.228

package/dist/event-emitter.d.ts

@@ -0,0 +1,25 @@
+type Input = {
+    timestamp: number;
+    keyframe: boolean;
+};
+type Output = {
+    timestamp: number;
+};
+type IoEventMap = {
+    input: Input;
+    output: Output;
+};
+export type IoEventTypes = keyof IoEventMap;
+export type CallbackListener<T extends IoEventTypes> = (data: {
+    detail: IoEventMap[T];
+}) => void;
+type IoListeners = {
+    [EventType in IoEventTypes]: CallbackListener<EventType>[];
+};
+export declare class IoEventEmitter {
+    listeners: IoListeners;
+    addEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    dispatchEvent<T extends IoEventTypes>(dispatchName: T, context: IoEventMap[T]): void;
+}
+export {};

package/dist/event-emitter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoEventEmitter = void 0;
+class IoEventEmitter {
+    constructor() {
+        this.listeners = {
+            input: [],
+            output: [],
+        };
+    }
+    addEventListener(name, callback) {
+        this.listeners[name].push(callback);
+    }
+    removeEventListener(name, callback) {
+        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
+    }
+    dispatchEvent(dispatchName, context) {
+        this.listeners[dispatchName].forEach((callback) => {
+            callback({ detail: context });
+        });
+    }
+}
+exports.IoEventEmitter = IoEventEmitter;

package/dist/io-manager/event-emitter.d.ts

@@ -0,0 +1,27 @@
+type Input = {
+    timestamp: number;
+    keyFrame: boolean;
+};
+type Output = {
+    timestamp: number;
+};
+type Processed = {};
+type IoEventMap = {
+    input: Input;
+    output: Output;
+    processed: Processed;
+};
+export type IoEventTypes = keyof IoEventMap;
+export type CallbackListener<T extends IoEventTypes> = (data: {
+    detail: IoEventMap[T];
+}) => void;
+type IoListeners = {
+    [EventType in IoEventTypes]: CallbackListener<EventType>[];
+};
+export declare class IoEventEmitter {
+    listeners: IoListeners;
+    addEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    dispatchEvent<T extends IoEventTypes>(dispatchName: T, context: IoEventMap[T]): void;
+}
+export {};

package/dist/io-manager/event-emitter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoEventEmitter = void 0;
+class IoEventEmitter {
+    constructor() {
+        this.listeners = {
+            input: [],
+            output: [],
+            processed: [],
+        };
+    }
+    addEventListener(name, callback) {
+        this.listeners[name].push(callback);
+    }
+    removeEventListener(name, callback) {
+        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
+    }
+    dispatchEvent(dispatchName, context) {
+        this.listeners[dispatchName].forEach((callback) => {
+            callback({ detail: context });
+        });
+    }
+}
+exports.IoEventEmitter = IoEventEmitter;

package/dist/io-manager/io-synchronizer.d.ts

@@ -0,0 +1,12 @@
+import type { LogLevel } from '../log';
+export declare const makeIoSynchronizer: (logLevel: LogLevel, label: string) => {
+    inputItem: (timestamp: number, keyFrame: boolean) => void;
+    onOutput: (timestamp: number) => void;
+    waitFor: ({ _unprocessed, unemitted, }: {
+        unemitted: number;
+        _unprocessed: number;
+    }) => Promise<void>;
+    waitForFinish: () => Promise<void>;
+    onProcessed: () => void;
+    getUnprocessed: () => number;
+};

package/dist/io-manager/io-synchronizer.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIoSynchronizer = void 0;
+const log_1 = require("../log");
+const with_resolvers_1 = require("../with-resolvers");
+const event_emitter_1 = require("./event-emitter");
+const makeIoSynchronizer = (logLevel, label) => {
+    const eventEmitter = new event_emitter_1.IoEventEmitter();
+    let lastInput = 0;
+    let lastInputKeyframe = 0;
+    let lastOutput = 0;
+    let inputsSinceLastOutput = 0;
+    let inputs = [];
+    let keyframes = [];
+    // Once WebCodecs emits items, the user has to handle them
+    // Let's keep count of how many items are unprocessed
+    let unprocessed = 0;
+    const getUnprocessed = () => unprocessed;
+    const getUnemittedItems = () => {
+        inputs = inputs.filter((input) => input > lastOutput);
+        return inputs.length;
+    };
+    const getUnemittedKeyframes = () => {
+        keyframes = keyframes.filter((keyframe) => keyframe > lastOutput);
+        return keyframes.length;
+    };
+    const printState = (prefix) => {
+        log_1.Log.trace(logLevel, `[${label}] ${prefix}, state: Last input = ${lastInput} Last input keyframe = ${lastInputKeyframe} Last output = ${lastOutput} Inputs since last output = ${inputsSinceLastOutput}, Queue = ${getUnemittedItems()} (${getUnemittedKeyframes()} keyframes), Unprocessed = ${getUnprocessed()}`);
+    };
+    const inputItem = (timestamp, keyFrame) => {
+        lastInput = timestamp;
+        if (keyFrame) {
+            lastInputKeyframe = timestamp;
+            keyframes.push(timestamp);
+        }
+        inputsSinceLastOutput++;
+        inputs.push(timestamp);
+        eventEmitter.dispatchEvent('input', {
+            timestamp,
+            keyFrame,
+        });
+        printState('Input item');
+    };
+    const onOutput = (timestamp) => {
+        lastOutput = timestamp;
+        inputsSinceLastOutput = 0;
+        eventEmitter.dispatchEvent('output', {
+            timestamp,
+        });
+        unprocessed++;
+        printState('Got output');
+    };
+    const waitForOutput = () => {
+        const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+        const on = () => {
+            eventEmitter.removeEventListener('output', on);
+            resolve();
+        };
+        eventEmitter.addEventListener('output', on);
+        return promise;
+    };
+    const waitForProcessed = () => {
+        const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+        const on = () => {
+            eventEmitter.removeEventListener('processed', on);
+            resolve();
+        };
+        eventEmitter.addEventListener('processed', on);
+        return promise;
+    };
+    const waitFor = async ({ _unprocessed, unemitted, }) => {
+        while (getUnemittedItems() > unemitted) {
+            await waitForOutput();
+        }
+        while (getUnprocessed() > _unprocessed) {
+            await waitForProcessed();
+        }
+    };
+    const waitForFinish = async () => {
+        await waitFor({ _unprocessed: 0, unemitted: 0 });
+    };
+    const onProcessed = () => {
+        eventEmitter.dispatchEvent('processed', {});
+        unprocessed--;
+    };
+    return {
+        inputItem,
+        onOutput,
+        waitFor,
+        waitForFinish,
+        onProcessed,
+        getUnprocessed,
+    };
+};
+exports.makeIoSynchronizer = makeIoSynchronizer;

package/dist/log.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from '@remotion/media-parser';
+declare const Log: {
+    trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    verbose: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    info: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    warn: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    error: (...args: Parameters<typeof console.log>) => void;
+};
+export { Log };
+export type { LogLevel };

package/dist/log.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const { Log } = media_parser_1.MediaParserInternals;
+exports.Log = Log;

package/dist/on-audio-track.d.ts

@@ -1,9 +1,9 @@
-import type { MediaFn, OnAudioTrack } from '@remotion/media-parser';
+import type { LogLevel, MediaFn, OnAudioTrack } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec } from './codec-id';
 import type { ConvertMediaState } from './convert-media';
 import Error from './error-cause';
 import type { ResolveAudioActionFn } from './resolve-audio-action';
-export declare const makeAudioTrackHandler: ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, bitrate, }: {
+export declare const makeAudioTrackHandler: ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, bitrate, logLevel, }: {
     state: MediaFn;
     audioCodec: ConvertMediaAudioCodec;
     convertMediaState: ConvertMediaState;
@@ -12,4 +12,5 @@ export declare const makeAudioTrackHandler: ({ state, audioCodec, convertMediaSt
     onMediaStateUpdate: null | ((state: ConvertMediaState) => void);
     onAudioTrack: ResolveAudioActionFn;
     bitrate: number;
+    logLevel: LogLevel;
 }) => OnAudioTrack;

package/dist/on-audio-track.js

@@ -10,7 +10,7 @@ const audio_encoder_1 = require("./audio-encoder");
 const audio_encoder_config_1 = require("./audio-encoder-config");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const resolve_audio_action_1 = require("./resolve-audio-action");
-const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, bitrate, }) => async (track) => {
+const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, bitrate, logLevel, }) => async (track) => {
     const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
         codec: audioCodec,
         numberOfChannels: track.numberOfChannels,
@@ -76,6 +76,7 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
         codec: audioCodec,
         signal: controller.signal,
         config: audioEncoderConfig,
+        logLevel,
     });
     const audioDecoder = (0, audio_decoder_1.createAudioDecoder)({
         onFrame: async (frame) => {
@@ -91,6 +92,7 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
         },
         signal: controller.signal,
         config: audioDecoderConfig,
+        logLevel,
     });
     state.addWaitForFinishPromise(async () => {
         await audioDecoder.waitForFinish();

package/dist/on-video-track.d.ts

@@ -1,9 +1,9 @@
-import type { MediaFn, OnVideoTrack, VideoTrack } from '@remotion/media-parser';
+import type { LogLevel, MediaFn, OnVideoTrack, VideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaVideoCodec } from './codec-id';
 import type { ConvertMediaState } from './convert-media';
 import Error from './error-cause';
 import type { ResolveVideoActionFn } from './resolve-video-action';
-export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, onVideoTrack, }: {
+export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, onVideoTrack, logLevel, }: {
     state: MediaFn;
     onVideoFrame: null | ((frame: VideoFrame, track: VideoTrack) => Promise<void>);
     onMediaStateUpdate: null | ((state: ConvertMediaState) => void);
@@ -12,4 +12,5 @@ export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaState
     controller: AbortController;
     videoCodec: ConvertMediaVideoCodec;
     onVideoTrack: ResolveVideoActionFn;
+    logLevel: LogLevel;
 }) => OnVideoTrack;

package/dist/on-video-track.js

@@ -10,7 +10,10 @@ const video_decoder_1 = require("./video-decoder");
 const video_decoder_config_1 = require("./video-decoder-config");
 const video_encoder_1 = require("./video-encoder");
 const video_encoder_config_1 = require("./video-encoder-config");
-const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, onVideoTrack, }) => async (track) => {
+const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, onVideoTrack, logLevel, }) => async (track) => {
+    if (controller.signal.aborted) {
+        throw new error_cause_1.default('Aborted');
+    }
     const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
         codec: videoCodec === 'vp9' ? 'vp09.00.10.08' : videoCodec,
         height: track.displayAspectHeight,
@@ -36,8 +39,8 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
             codec: track.codecWithoutConfig,
             codecPrivate: track.codecPrivate,
         });
-        return (sample) => {
-            state.addSample(new EncodedVideoChunk(sample), videoTrack.trackNumber, true);
+        return async (sample) => {
+            await state.addSample(new EncodedVideoChunk(sample), videoTrack.trackNumber, true);
             convertMediaState.decodedVideoFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         };
@@ -71,6 +74,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         },
         signal: controller.signal,
         config: videoEncoderConfig,
+        logLevel,
     });
     const videoDecoder = (0, video_decoder_1.createVideoDecoder)({
         config: videoDecoderConfig,
@@ -87,6 +91,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
             }));
         },
         signal: controller.signal,
+        logLevel,
     });
     state.addWaitForFinishPromise(async () => {
         await videoDecoder.waitForFinish();

package/dist/video-decoder.d.ts

@@ -1,14 +1,14 @@
-import type { VideoSample } from '@remotion/media-parser';
+import type { LogLevel, VideoSample } from '@remotion/media-parser';
 export type WebCodecsVideoDecoder = {
     processSample: (videoSample: VideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
-    getQueueSize: () => number;
     flush: () => Promise<void>;
 };
-export declare const createVideoDecoder: ({ onFrame, onError, signal, config, }: {
+export declare const createVideoDecoder: ({ onFrame, onError, signal, config, logLevel, }: {
     onFrame: (frame: VideoFrame) => Promise<void>;
     onError: (error: DOMException) => void;
     signal: AbortSignal;
     config: VideoDecoderConfig;
+    logLevel: LogLevel;
 }) => WebCodecsVideoDecoder;

package/dist/video-decoder.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoDecoder = void 0;
-const createVideoDecoder = ({ onFrame, onError, signal, config, }) => {
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const createVideoDecoder = ({ onFrame, onError, signal, config, logLevel, }) => {
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Video decoder');
     let outputQueue = Promise.resolve();
-    let outputQueueSize = 0;
-    let dequeueResolver = () => { };
     const videoDecoder = new VideoDecoder({
         output(inputFrame) {
-            outputQueueSize++;
+            ioSynchronizer.onOutput(inputFrame.timestamp);
+            const abortHandler = () => {
+                inputFrame.close();
+            };
+            signal.addEventListener('abort', abortHandler, { once: true });
             outputQueue = outputQueue
-                .then(() => onFrame(inputFrame))
                 .then(() => {
-                outputQueueSize--;
-                dequeueResolver();
+                if (signal.aborted) {
+                    return;
+                }
+                return onFrame(inputFrame);
+            })
+                .then(() => {
+                ioSynchronizer.onProcessed();
+                signal.removeEventListener('abort', abortHandler);
                 return Promise.resolve();
+            })
+                .catch((err) => {
+                inputFrame.close();
+                onError(err);
             });
         },
         error(error) {
@@ -32,38 +45,21 @@ const createVideoDecoder = ({ onFrame, onError, signal, config, }) => {
         close();
     };
     signal.addEventListener('abort', onAbort);
-    const getQueueSize = () => {
-        return videoDecoder.decodeQueueSize + outputQueueSize;
-    };
     videoDecoder.configure(config);
-    const waitForDequeue = async () => {
-        await new Promise((r) => {
-            dequeueResolver = r;
-            videoDecoder.addEventListener('dequeue', () => r(), {
-                once: true,
-            });
-        });
-    };
-    const waitForFinish = async () => {
-        while (getQueueSize() > 0) {
-            await waitForDequeue();
-        }
-    };
     const processSample = async (sample) => {
         if (videoDecoder.state === 'closed') {
             return;
         }
-        while (getQueueSize() > 10) {
-            await waitForDequeue();
-        }
         // @ts-expect-error - can have changed in the meanwhile
         if (videoDecoder.state === 'closed') {
             return;
         }
+        await ioSynchronizer.waitFor({ unemitted: 20, _unprocessed: 2 });
         if (sample.type === 'key') {
             await videoDecoder.flush();
         }
         videoDecoder.decode(new EncodedVideoChunk(sample));
+        ioSynchronizer.inputItem(sample.timestamp, sample.type === 'key');
     };
     let inputQueue = Promise.resolve();
     return {
@@ -73,12 +69,11 @@ const createVideoDecoder = ({ onFrame, onError, signal, config, }) => {
         },
         waitForFinish: async () => {
             await videoDecoder.flush();
-            await waitForFinish();
+            await ioSynchronizer.waitForFinish();
             await outputQueue;
             await inputQueue;
         },
         close,
-        getQueueSize,
         flush: async () => {
             await videoDecoder.flush();
         },

package/dist/video-encoder.d.ts

@@ -1,13 +1,14 @@
+import type { LogLevel } from '@remotion/media-parser';
 export type WebCodecsVideoEncoder = {
     encodeFrame: (videoFrame: VideoFrame) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
-    getQueueSize: () => number;
     flush: () => Promise<void>;
 };
-export declare const createVideoEncoder: ({ onChunk, onError, signal, config, }: {
+export declare const createVideoEncoder: ({ onChunk, onError, signal, config, logLevel, }: {
     onChunk: (chunk: EncodedVideoChunk) => Promise<void>;
     onError: (error: DOMException) => void;
     signal: AbortSignal;
     config: VideoEncoderConfig;
+    logLevel: LogLevel;
 }) => WebCodecsVideoEncoder;

package/dist/video-encoder.js

@@ -1,25 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoEncoder = void 0;
-const createVideoEncoder = ({ onChunk, onError, signal, config, }) => {
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, }) => {
     if (signal.aborted) {
         throw new Error('Not creating video encoder, already aborted');
     }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Video encoder');
     let outputQueue = Promise.resolve();
-    let outputQueueSize = 0;
-    let dequeueResolver = () => { };
     const encoder = new VideoEncoder({
         error(error) {
             onError(error);
         },
         output(chunk) {
-            outputQueueSize++;
+            if (chunk.duration === null) {
+                throw new Error('Duration is null');
+            }
+            const timestamp = chunk.timestamp + chunk.duration;
+            ioSynchronizer.onOutput(timestamp);
             outputQueue = outputQueue
-                .then(() => onChunk(chunk))
                 .then(() => {
-                outputQueueSize--;
-                dequeueResolver();
+                if (signal.aborted) {
+                    return;
+                }
+                return onChunk(chunk);
+            })
+                .then(() => {
+                ioSynchronizer.onProcessed();
                 return Promise.resolve();
+            })
+                .catch((err) => {
+                onError(err);
             });
         },
     });
@@ -35,38 +46,25 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, }) => {
         close();
     };
     signal.addEventListener('abort', onAbort);
-    const getQueueSize = () => {
-        return encoder.encodeQueueSize + outputQueueSize;
-    };
     encoder.configure(config);
     let framesProcessed = 0;
-    const waitForDequeue = async () => {
-        await new Promise((r) => {
-            dequeueResolver = r;
-            encoder.addEventListener('dequeue', () => r(), {
-                once: true,
-            });
-        });
-    };
-    const waitForFinish = async () => {
-        while (getQueueSize() > 0) {
-            await waitForDequeue();
-        }
-    };
     const encodeFrame = async (frame) => {
         if (encoder.state === 'closed') {
             return;
         }
-        while (getQueueSize() > 10) {
-            await waitForDequeue();
-        }
+        await ioSynchronizer.waitFor({
+            unemitted: 2,
+            _unprocessed: 2,
+        });
         // @ts-expect-error - can have changed in the meanwhile
         if (encoder.state === 'closed') {
             return;
         }
+        const keyFrame = framesProcessed % 40 === 0;
         encoder.encode(frame, {
-            keyFrame: framesProcessed % 40 === 0,
+            keyFrame,
         });
+        ioSynchronizer.inputItem(frame.timestamp, keyFrame);
         framesProcessed++;
     };
     let inputQueue = Promise.resolve();
@@ -78,10 +76,9 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, }) => {
         waitForFinish: async () => {
             await encoder.flush();
             await outputQueue;
-            await waitForFinish();
+            await ioSynchronizer.waitForFinish();
         },
         close,
-        getQueueSize,
         flush: async () => {
             await encoder.flush();
         },

package/dist/wait-until-return.d.ts

@@ -0,0 +1,4 @@
+export declare const waitUntilReturn: () => {
+    waitForReturn: () => any;
+    isReturning: () => void;
+};

package/dist/wait-until-return.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilReturn = void 0;
+const with_resolvers_1 = require("./with-resolvers");
+const waitUntilReturn = () => {
+    const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+    return {
+        waitForReturn: () => promise,
+        isReturning: () => {
+            resolve(undefined);
+        },
+    };
+};
+exports.waitUntilReturn = waitUntilReturn;

package/dist/with-resolvers.d.ts

@@ -3,3 +3,8 @@ export declare const withResolvers: <T>() => {
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
 };
+export declare const withResolversAndWaitForReturn: <T>() => {
+    getPromiseToImmediatelyReturn: () => Promise<T>;
+    reject: (reason: unknown) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+};

package/dist/with-resolvers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withResolvers = void 0;
+exports.withResolversAndWaitForReturn = exports.withResolvers = void 0;
 const withResolvers = function () {
     let resolve;
     let reject;
@@ -11,3 +11,18 @@ const withResolvers = function () {
     return { promise, resolve: resolve, reject: reject };
 };
 exports.withResolvers = withResolvers;
+const withResolversAndWaitForReturn = () => {
+    const { promise, reject, resolve } = (0, exports.withResolvers)();
+    const { promise: returnPromise, resolve: resolveReturn } = (0, exports.withResolvers)();
+    return {
+        getPromiseToImmediatelyReturn: () => {
+            resolveReturn(undefined);
+            return promise;
+        },
+        reject: (reason) => {
+            returnPromise.then(() => reject(reason));
+        },
+        resolve,
+    };
+};
+exports.withResolversAndWaitForReturn = withResolversAndWaitForReturn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.226",
+  "version": "4.0.228",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -17,11 +17,13 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@remotion/media-parser": "4.0.226"
+    "@remotion/media-parser": "4.0.228"
   },
   "peerDependencies": {},
   "devDependencies": {
-    "@types/dom-webcodecs": "0.1.11"
+    "@types/dom-webcodecs": "0.1.11",
+    "eslint": "9.14.0",
+    "@remotion/eslint-config-internal": "4.0.228"
   },
   "keywords": [],
   "publishConfig": {
@@ -30,8 +32,8 @@
   "description": "Media conversion in the browser",
   "scripts": {
     "formatting": "prettier src --check",
-    "lint": "eslint src --ext ts,tsx",
-    "make": "tsc -d && bun --env-file=../.env.bundle bundle.ts",
-    "watch": "tsc -w"
+    "lint": "eslint src",
+    "watch": "tsc -w",
+    "make": "tsc -d && bun --env-file=../.env.bundle bundle.ts"
   }
 }