@aelionsdk/export 0.1.0-beta.1

package/dist/webm-export.js

@@ -0,0 +1,408 @@
+import { AelionError, frameDurationUs, frameStartUs, throwIfAborted, } from '@aelionsdk/core';
+import { AudioSample, AudioSampleSource, Output, Mp4OutputFormat, StreamTarget, VideoSample, VideoSampleSource, WebMOutputFormat, } from 'mediabunny';
+import { av1CodecString, hevcCodecString, negotiateAvcCodecString, preferredAvcCodecString, } from './profiles.js';
+import { createSinkCompletionBarrier } from './sink-completion.js';
+const MAIN_THREAD_YIELD_INTERVAL_MS = 16;
+const audioEncoderRuntimeSupport = new Map();
+function nextMainThreadTask() {
+    return new Promise(resolve => globalThis.setTimeout(resolve, 0));
+}
+function verifyAudioEncoderRuntime(config) {
+    const key = JSON.stringify(config);
+    const existing = audioEncoderRuntimeSupport.get(key);
+    if (existing !== undefined)
+        return existing;
+    const verification = new Promise(resolve => {
+        let settled = false;
+        let encoder;
+        const finish = (supported) => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                encoder?.close();
+            }
+            catch {
+                // A codec error can close the encoder before the error callback.
+            }
+            resolve(supported);
+        };
+        try {
+            encoder = new AudioEncoder({
+                output: () => undefined,
+                error: () => finish(false),
+            });
+            encoder.configure(config);
+            for (let block = 0; block < 4; block += 1) {
+                const frameCount = 1_024;
+                const sample = new AudioData({
+                    format: 'f32',
+                    sampleRate: config.sampleRate,
+                    numberOfFrames: frameCount,
+                    numberOfChannels: config.numberOfChannels,
+                    timestamp: Math.round((block * frameCount * 1_000_000) / config.sampleRate),
+                    data: new Float32Array(frameCount * config.numberOfChannels),
+                });
+                try {
+                    encoder.encode(sample);
+                }
+                finally {
+                    sample.close();
+                }
+            }
+            void encoder.flush().then(() => finish(true), () => finish(false));
+        }
+        catch {
+            finish(false);
+        }
+    });
+    audioEncoderRuntimeSupport.set(key, verification);
+    return verification;
+}
+function exportFailure(stage, cause) {
+    const causeName = cause instanceof DOMException ? cause.name : '';
+    const causeMessage = cause instanceof Error ? cause.message : '';
+    if (causeName === 'QuotaExceededError' ||
+        /quota|storage|disk|write failed/iu.test(causeMessage)) {
+        return new AelionError([
+            {
+                code: 'EXPORT_STORAGE_WRITE_FAILED',
+                severity: 'error',
+                message: `Export sink write failed: ${causeMessage || 'unknown storage failure'}`,
+                recoverable: true,
+                cause,
+            },
+        ]);
+    }
+    const mapping = {
+        initialize: ['EXPORT_ENCODER_INIT_FAILED', 'Failed to initialize export encoders or muxer'],
+        'render-video': ['EXPORT_VIDEO_RENDER_FAILED', 'Failed to render an export video frame'],
+        'encode-video': ['EXPORT_VIDEO_ENCODER_FAILED', 'Video encoder rejected an export frame'],
+        'render-audio': ['EXPORT_AUDIO_RENDER_FAILED', 'Failed to render an export PCM block'],
+        'encode-audio': ['EXPORT_AUDIO_ENCODER_FAILED', 'Audio encoder rejected an export block'],
+        finalize: ['EXPORT_MUX_OR_SINK_FAILED', 'Failed to finalize muxed output or write the sink'],
+    };
+    const [code, prefix] = mapping[stage];
+    return new AelionError([
+        {
+            code,
+            severity: 'error',
+            message: `${prefix}: ${cause instanceof Error ? cause.message : 'unknown failure'}`,
+            recoverable: stage === 'finalize',
+            cause,
+        },
+    ]);
+}
+function assertPositiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new RangeError(`${name} must be a positive safe integer`);
+    }
+}
+export async function exportMuxed(options, profile, range) {
+    assertPositiveInteger(options.durationUs, 'durationUs');
+    assertPositiveInteger(options.width, 'width');
+    assertPositiveInteger(options.height, 'height');
+    assertPositiveInteger(options.sampleRate, 'sampleRate');
+    assertPositiveInteger(options.channelCount, 'channelCount');
+    const fullVideoFrameCount = Math.ceil((options.durationUs * options.frameRate.numerator) /
+        (1_000_000 * options.frameRate.denominator));
+    const fullAudioFrameCount = Math.floor((options.durationUs * options.sampleRate) / 1_000_000);
+    const videoStartFrame = range?.videoStartFrame ?? 0;
+    const videoEndFrameExclusive = range?.videoEndFrameExclusive ?? fullVideoFrameCount;
+    const audioStartFrame = range?.audioStartFrame ?? 0;
+    const audioEndFrameExclusive = range?.audioEndFrameExclusive ?? fullAudioFrameCount;
+    const rangeTimestampBaseUs = range?.timestampBase === 'range' ? frameStartUs(videoStartFrame, options.frameRate) : 0;
+    const rangeAudioBaseFrame = range?.timestampBase === 'range' ? audioStartFrame : 0;
+    for (const [value, name] of [
+        [videoStartFrame, 'videoStartFrame'],
+        [videoEndFrameExclusive, 'videoEndFrameExclusive'],
+        [audioStartFrame, 'audioStartFrame'],
+        [audioEndFrameExclusive, 'audioEndFrameExclusive'],
+    ]) {
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new RangeError(`${name} must be a non-negative safe integer`);
+        }
+    }
+    if (videoStartFrame >= videoEndFrameExclusive ||
+        videoEndFrameExclusive > fullVideoFrameCount ||
+        audioStartFrame >= audioEndFrameExclusive ||
+        audioEndFrameExclusive > fullAudioFrameCount) {
+        throw new RangeError('Muxed export range must be a non-empty subset of the timeline');
+    }
+    throwIfAborted(options.signal, profile.operationName);
+    if (profile.audioCodec === 'aac') {
+        const runtimeConfig = {
+            codec: options.audioCodecString ?? 'mp4a.40.2',
+            sampleRate: options.sampleRate,
+            numberOfChannels: options.channelCount,
+            bitrate: options.audioBitrate,
+            bitrateMode: 'variable',
+            ...{ aac: { format: 'aac' } },
+        };
+        const supported = await verifyAudioEncoderRuntime(runtimeConfig);
+        if (!supported) {
+            throw new AelionError([
+                {
+                    code: 'EXPORT_AUDIO_CONFIG_UNSUPPORTED',
+                    severity: 'error',
+                    message: 'AAC encoder configuration failed the runtime encode canary',
+                    recoverable: false,
+                },
+            ]);
+        }
+    }
+    // StreamTarget closes its writer during Output.finalize(). Some Firefox
+    // builds have resolved that close before the consumer sink's close callback
+    // became observable. Pipe through a barrier and await the pipe separately so
+    // a completed export always means the caller's sink is fully closed.
+    const sinkBarrier = createSinkCompletionBarrier(options.sink);
+    let output;
+    let videoFrames = 0;
+    let audioFrames = 0;
+    let stage = 'initialize';
+    let pendingRenderedFrame;
+    let lastMainThreadYieldMs = performance.now();
+    const yieldMainThreadWhenDue = async () => {
+        throwIfAborted(options.signal, 'WebM export');
+        if (performance.now() - lastMainThreadYieldMs < MAIN_THREAD_YIELD_INTERVAL_MS)
+            return;
+        await nextMainThreadTask();
+        lastMainThreadYieldMs = performance.now();
+        throwIfAborted(options.signal, 'WebM export');
+    };
+    try {
+        const target = new StreamTarget(sinkBarrier.writable, {
+            chunked: true,
+            chunkSize: 64 * 1_024,
+        });
+        output = new Output({
+            format: profile.format,
+            target,
+        });
+        const videoSource = new VideoSampleSource({
+            codec: profile.videoCodec,
+            fullCodecString: options.videoCodecString ?? profile.fullVideoCodecString,
+            bitrate: options.videoBitrate,
+            bitrateMode: 'variable',
+            keyFrameInterval: 1,
+            latencyMode: 'quality',
+            alpha: 'discard',
+        });
+        const audioSource = new AudioSampleSource({
+            codec: profile.audioCodec,
+            ...(options.audioCodecString === undefined
+                ? {}
+                : { fullCodecString: options.audioCodecString }),
+            bitrate: options.audioBitrate,
+            bitrateMode: 'variable',
+        });
+        output.addVideoTrack(videoSource, {
+            frameRate: options.frameRate.numerator / options.frameRate.denominator,
+        });
+        output.addAudioTrack(audioSource);
+        await output.start();
+        await yieldMainThreadWhenDue();
+        const rangedVideoFrames = videoEndFrameExclusive - videoStartFrame;
+        const beginRender = (frameIndex) => {
+            const timestampUs = frameStartUs(frameIndex, options.frameRate);
+            const durationUs = Math.min(frameDurationUs(frameIndex, options.frameRate), options.durationUs - timestampUs);
+            return Promise.resolve(options.renderFrame({ frameIndex, timestampUs, durationUs, width: options.width, height: options.height }, options.signal)).then(frame => ({ ok: true, frame }), (error) => ({ ok: false, error }));
+        };
+        pendingRenderedFrame = beginRender(videoStartFrame);
+        for (let frameIndex = videoStartFrame; frameIndex < videoEndFrameExclusive; frameIndex += 1) {
+            throwIfAborted(options.signal, 'WebM video export');
+            const timestampUs = frameStartUs(frameIndex, options.frameRate);
+            const durationUs = Math.min(frameDurationUs(frameIndex, options.frameRate), options.durationUs - timestampUs);
+            if (durationUs <= 0)
+                break;
+            stage = 'render-video';
+            const renderPromise = pendingRenderedFrame;
+            if (renderPromise === undefined)
+                throw new Error('Video render pipeline was not primed');
+            const rendered = await renderPromise;
+            pendingRenderedFrame =
+                frameIndex + 1 < videoEndFrameExclusive ? beginRender(frameIndex + 1) : undefined;
+            if (!rendered.ok)
+                throw rendered.error;
+            const frame = rendered.frame;
+            try {
+                stage = 'encode-video';
+                const sample = new VideoSample(frame, {
+                    timestamp: (timestampUs - rangeTimestampBaseUs) / 1_000_000,
+                    duration: durationUs / 1_000_000,
+                });
+                try {
+                    await videoSource.add(sample);
+                }
+                finally {
+                    sample.close();
+                }
+            }
+            finally {
+                frame.close();
+            }
+            videoFrames += 1;
+            options.onProgress?.(videoFrames / rangedVideoFrames / 2);
+            await yieldMainThreadWhenDue();
+        }
+        videoSource.close();
+        const totalAudioFrames = audioEndFrameExclusive - audioStartFrame;
+        const blockFrames = 1_024;
+        while (audioFrames < totalAudioFrames) {
+            throwIfAborted(options.signal, 'WebM audio export');
+            const frameCount = Math.min(blockFrames, totalAudioFrames - audioFrames);
+            stage = 'render-audio';
+            const pcm = await options.renderAudio({
+                startFrame: audioStartFrame + audioFrames,
+                frameCount,
+                sampleRate: options.sampleRate,
+                channelCount: options.channelCount,
+            }, options.signal);
+            if (pcm.length !== frameCount * options.channelCount) {
+                throw new RangeError('renderAudio returned an unexpected interleaved PCM length');
+            }
+            const sample = new AudioSample({
+                data: pcm,
+                format: 'f32',
+                numberOfChannels: options.channelCount,
+                sampleRate: options.sampleRate,
+                timestamp: (audioStartFrame + audioFrames - rangeAudioBaseFrame) / options.sampleRate,
+            });
+            try {
+                stage = 'encode-audio';
+                await audioSource.add(sample);
+            }
+            finally {
+                sample.close();
+            }
+            audioFrames += frameCount;
+            options.onProgress?.(Math.min(1 - Number.EPSILON, 0.5 + audioFrames / totalAudioFrames / 2));
+            await yieldMainThreadWhenDue();
+        }
+        audioSource.close();
+        stage = 'finalize';
+        await output.finalize();
+        await sinkBarrier.completion;
+        options.onProgress?.(1);
+        return {
+            mimeType: await output.getMimeType(),
+            videoFrames,
+            audioFrames,
+            durationUs: options.durationUs,
+            encoderConfiguration: {
+                profile: profile.id,
+                video: {
+                    codec: profile.videoCodec,
+                    codecString: options.videoCodecString ?? profile.fullVideoCodecString,
+                    width: options.width,
+                    height: options.height,
+                    frameRate: options.frameRate.numerator / options.frameRate.denominator,
+                    bitrateMode: 'variable',
+                    targetBitrate: options.videoBitrate,
+                },
+                audio: {
+                    codec: profile.audioCodec,
+                    sampleRate: options.sampleRate,
+                    channelCount: options.channelCount,
+                    bitrateMode: 'variable',
+                    targetBitrate: options.audioBitrate,
+                },
+            },
+        };
+    }
+    catch (error) {
+        if (pendingRenderedFrame !== undefined) {
+            const pending = await pendingRenderedFrame;
+            if (pending.ok)
+                pending.frame.close();
+            pendingRenderedFrame = undefined;
+        }
+        if (output !== undefined && output.state !== 'finalized' && output.state !== 'canceled') {
+            try {
+                await output.cancel();
+            }
+            catch {
+                // Preserve the first failure. Stream cancellation is best-effort cleanup.
+            }
+        }
+        sinkBarrier.abort(error);
+        await sinkBarrier.completion.catch(() => undefined);
+        try {
+            await options.cleanupSink?.(error);
+        }
+        catch {
+            // Cleanup errors are reported by the concrete sink; preserve the primary failure.
+        }
+        if (error instanceof AelionError)
+            throw error;
+        throw exportFailure(stage, error);
+    }
+}
+export function exportWebM(options) {
+    return exportMuxed(options, {
+        id: 'webm-vp9-opus',
+        operationName: 'WebM export',
+        format: new WebMOutputFormat(),
+        videoCodec: 'vp9',
+        fullVideoCodecString: 'vp09.00.10.08',
+        audioCodec: 'opus',
+    });
+}
+export async function exportMp4(options) {
+    const framerate = options.frameRate.numerator / options.frameRate.denominator;
+    const negotiated = options.videoCodecString === undefined
+        ? await negotiateAvcCodecString({
+            width: options.width,
+            height: options.height,
+            framerate,
+            bitrate: options.videoBitrate,
+        })
+        : undefined;
+    const videoCodecString = options.videoCodecString ??
+        negotiated?.selected ??
+        preferredAvcCodecString(options.width, options.height, framerate);
+    return exportMuxed({
+        ...options,
+        videoCodecString,
+        audioCodecString: options.audioCodecString ?? 'mp4a.40.2',
+    }, {
+        id: 'mp4-h264-aac',
+        operationName: 'MP4 export',
+        format: new Mp4OutputFormat({ fastStart: 'in-memory' }),
+        videoCodec: 'avc',
+        fullVideoCodecString: videoCodecString,
+        audioCodec: 'aac',
+    });
+}
+export function exportAv1Mp4(options) {
+    const framerate = options.frameRate.numerator / options.frameRate.denominator;
+    const videoCodecString = options.videoCodecString ?? av1CodecString(options.width, options.height, framerate);
+    return exportMuxed({
+        ...options,
+        videoCodecString,
+        audioCodecString: options.audioCodecString ?? 'mp4a.40.2',
+    }, {
+        id: 'mp4-av1-aac',
+        operationName: 'AV1 MP4 export',
+        format: new Mp4OutputFormat({ fastStart: 'in-memory' }),
+        videoCodec: 'av1',
+        fullVideoCodecString: videoCodecString,
+        audioCodec: 'aac',
+    });
+}
+export function exportHevcMp4(options) {
+    const framerate = options.frameRate.numerator / options.frameRate.denominator;
+    const videoCodecString = options.videoCodecString ?? hevcCodecString(options.width, options.height, framerate);
+    return exportMuxed({
+        ...options,
+        videoCodecString,
+        audioCodecString: options.audioCodecString ?? 'mp4a.40.2',
+    }, {
+        id: 'mp4-hevc-aac',
+        operationName: 'HEVC MP4 export',
+        format: new Mp4OutputFormat({ fastStart: 'in-memory' }),
+        videoCodec: 'hevc',
+        fullVideoCodecString: videoCodecString,
+        audioCodec: 'aac',
+    });
+}

package/dist/worker-export.d.ts

@@ -0,0 +1,25 @@
+import { type Disposable } from '@aelionsdk/core';
+import type { WebMExportOptions, WebMExportResult } from './webm-export.js';
+export interface WorkerMuxedExportOptions extends WebMExportOptions {
+    readonly profile: 'webm' | 'mp4' | 'mp4-av1' | 'mp4-hevc';
+    readonly workerUrl?: string | URL;
+}
+export interface WorkerMuxedExporterSnapshot {
+    readonly disposed: boolean;
+    readonly running: boolean;
+    readonly pendingHostRequests: number;
+}
+export interface WorkerMuxedExporterOptions {
+    readonly workerUrl?: string | URL;
+    readonly workerFactory?: () => Worker;
+}
+export declare class WorkerMuxedExporter implements Disposable {
+    #private;
+    constructor(options?: WorkerMuxedExporterOptions);
+    get disposed(): boolean;
+    snapshot(): WorkerMuxedExporterSnapshot;
+    run(options: WorkerMuxedExportOptions): Promise<WebMExportResult>;
+    dispose(): void;
+}
+export declare function exportMuxedInWorker(options: WorkerMuxedExportOptions): Promise<WebMExportResult>;
+//# sourceMappingURL=worker-export.d.ts.map

package/dist/worker-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-export.d.ts","sourceRoot":"","sources":["../src/worker-export.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAQ5E,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,UAAU,CAAC;IAC1D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;CACnC;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,MAAM,CAAC;CACvC;AAQD,qBAAa,mBAAoB,YAAW,UAAU;;gBAMjC,OAAO,GAAE,0BAA+B;IAS3D,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAEM,QAAQ,IAAI,2BAA2B;IAQvC,GAAG,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAiKjE,OAAO,IAAI,IAAI;CAWvB;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAS3B"}

package/dist/worker-export.js

@@ -0,0 +1,202 @@
+import { AelionError } from '@aelionsdk/core';
+import { createSinkCompletionBarrier } from './sink-completion.js';
+function copiedPcm(pcm) {
+    const copy = new Float32Array(pcm.length);
+    copy.set(pcm);
+    return copy;
+}
+export class WorkerMuxedExporter {
+    #worker;
+    #pendingHostRequests = new Set();
+    #disposed = false;
+    #running = false;
+    constructor(options = {}) {
+        this.#worker =
+            options.workerFactory?.() ??
+                new Worker(options.workerUrl ?? new URL('./mux-export-worker.js', import.meta.url), {
+                    type: 'module',
+                    name: 'aelion-export-mux',
+                });
+    }
+    get disposed() {
+        return this.#disposed;
+    }
+    snapshot() {
+        return {
+            disposed: this.#disposed,
+            running: this.#running,
+            pendingHostRequests: this.#pendingHostRequests.size,
+        };
+    }
+    run(options) {
+        if (this.#disposed)
+            return Promise.reject(new ReferenceError('Export Worker is disposed'));
+        if (this.#running)
+            return Promise.reject(new TypeError('EXPORT_WORKER_BUSY'));
+        if (options.signal?.aborted === true) {
+            return Promise.reject(new DOMException('Export cancelled', 'AbortError'));
+        }
+        const sinkBarrier = createSinkCompletionBarrier(options.sink);
+        this.#running = true;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (operation) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.#running = false;
+                options.signal?.removeEventListener('abort', onAbort);
+                this.#worker.removeEventListener('message', onMessage);
+                this.#worker.removeEventListener('error', onError);
+                operation();
+            };
+            const respondFrame = (request) => {
+                this.#pendingHostRequests.add(request.id);
+                void options.renderFrame(request.request, options.signal).then(frame => {
+                    this.#pendingHostRequests.delete(request.id);
+                    if (!this.#running) {
+                        frame.close();
+                        return;
+                    }
+                    this.#post({ type: 'frame-response', id: request.id, frame }, [frame]);
+                }, (error) => {
+                    this.#pendingHostRequests.delete(request.id);
+                    this.#post({
+                        type: 'frame-response',
+                        id: request.id,
+                        error: error instanceof Error ? error.message : 'Frame rendering failed',
+                    });
+                });
+            };
+            const respondAudio = (request) => {
+                this.#pendingHostRequests.add(request.id);
+                void options.renderAudio(request.request, options.signal).then(value => {
+                    this.#pendingHostRequests.delete(request.id);
+                    if (!this.#running)
+                        return;
+                    const pcm = copiedPcm(value);
+                    this.#post({ type: 'audio-response', id: request.id, pcm }, [pcm.buffer]);
+                }, (error) => {
+                    this.#pendingHostRequests.delete(request.id);
+                    this.#post({
+                        type: 'audio-response',
+                        id: request.id,
+                        error: error instanceof Error ? error.message : 'Audio rendering failed',
+                    });
+                });
+            };
+            const onMessage = (event) => {
+                const response = event.data;
+                if (response.type === 'render-frame')
+                    respondFrame(response);
+                else if (response.type === 'render-audio')
+                    respondAudio(response);
+                else if (response.type === 'progress')
+                    options.onProgress?.(response.value);
+                else if (response.type === 'completed') {
+                    void sinkBarrier.completion.then(() => settle(() => resolve(response.result)), (cause) => {
+                        const error = cause instanceof AelionError
+                            ? cause
+                            : new AelionError([
+                                {
+                                    code: 'EXPORT_STORAGE_WRITE_FAILED',
+                                    severity: 'error',
+                                    message: `Export sink did not finalize: ${cause instanceof Error ? cause.message : 'unknown storage failure'}`,
+                                    recoverable: true,
+                                    cause,
+                                },
+                            ]);
+                        settle(() => {
+                            void Promise.resolve(options.cleanupSink?.(error)).then(() => reject(error), () => reject(error));
+                        });
+                    });
+                }
+                else {
+                    const error = response.aborted
+                        ? new DOMException(response.message, 'AbortError')
+                        : new AelionError([
+                            {
+                                code: response.code,
+                                severity: 'error',
+                                message: response.message,
+                                recoverable: true,
+                            },
+                        ]);
+                    settle(() => {
+                        sinkBarrier.abort(error);
+                        void sinkBarrier.completion
+                            .catch(() => undefined)
+                            .then(() => options.cleanupSink?.(error))
+                            .then(() => reject(error), () => reject(error));
+                    });
+                }
+            };
+            const onError = (event) => {
+                const error = new Error(event.message || 'Export Worker crashed');
+                settle(() => {
+                    sinkBarrier.abort(error);
+                    void sinkBarrier.completion
+                        .catch(() => undefined)
+                        .then(() => options.cleanupSink?.(error))
+                        .then(() => reject(error), () => reject(error));
+                });
+            };
+            const onAbort = () => {
+                this.#post({
+                    type: 'cancel',
+                    reason: options.signal?.reason instanceof Error
+                        ? options.signal.reason.message
+                        : 'Export cancelled',
+                });
+            };
+            this.#worker.addEventListener('message', onMessage);
+            this.#worker.addEventListener('error', onError);
+            options.signal?.addEventListener('abort', onAbort, { once: true });
+            const start = {
+                type: 'start',
+                profile: options.profile,
+                config: {
+                    durationUs: options.durationUs,
+                    width: options.width,
+                    height: options.height,
+                    frameRate: options.frameRate,
+                    sampleRate: options.sampleRate,
+                    channelCount: options.channelCount,
+                    videoBitrate: options.videoBitrate,
+                    audioBitrate: options.audioBitrate,
+                    ...(options.videoCodecString === undefined
+                        ? {}
+                        : { videoCodecString: options.videoCodecString }),
+                    ...(options.audioCodecString === undefined
+                        ? {}
+                        : { audioCodecString: options.audioCodecString }),
+                },
+                sink: sinkBarrier.writable,
+            };
+            this.#post(start, [sinkBarrier.writable]);
+        });
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#running = false;
+        this.#pendingHostRequests.clear();
+        this.#worker.terminate();
+    }
+    #post(request, transfer = []) {
+        if (!this.#disposed)
+            this.#worker.postMessage(request, transfer);
+    }
+}
+export async function exportMuxedInWorker(options) {
+    const exporter = new WorkerMuxedExporter({
+        ...(options.workerUrl === undefined ? {} : { workerUrl: options.workerUrl }),
+    });
+    try {
+        return await exporter.run(options);
+    }
+    finally {
+        exporter.dispose();
+    }
+}