@mcut/media 0.1.0-alpha.0

package/dist/export-core-B8z3duRc.js

@@ -0,0 +1,605 @@
+import { ALL_FORMATS, AudioSample, AudioSampleSource, BlobSource, BufferTarget, CanvasSource, Input, MkvOutputFormat, Mp4OutputFormat, Output, QUALITY_HIGH, QUALITY_MEDIUM, UrlSource, VideoSampleSink, WebMOutputFormat, canEncodeAudio, getFirstEncodableAudioCodec, getFirstEncodableVideoCodec } from "mediabunny";
+import { createAssetId, getFrameRequests, getProjectDurationMs, getRenderableElements } from "@mcut/timeline";
+import { renderFrame } from "@mcut/compositor";
+//#region src/media-store.ts
+/**
+* Content-addressed media persistence on OPFS (the OpenCut pattern: media
+* blobs live in the Origin Private File System keyed by content hash;
+* project JSON stores `asset.hash` and re-binds `src` on load). Hash-keyed
+* storage dedupes repeated imports and gives relink a stable identity.
+*
+* Callers fall back to their own storage (e.g. IndexedDB keyed by asset id)
+* when OPFS is unavailable or a file was imported without a hash.
+*/
+const MEDIA_DIR = "mcut-media";
+/** Largest file we hash/persist (WebCrypto digest needs the full buffer). */
+const MAX_HASHABLE_BYTES = 512 * 1024 * 1024;
+function isMediaStoreSupported() {
+	return typeof navigator !== "undefined" && typeof navigator.storage?.getDirectory === "function" && typeof crypto !== "undefined" && !!crypto.subtle;
+}
+/** SHA-256 hex of a blob's content, or null when too large to hash. */
+async function hashBlob(blob) {
+	if (!isMediaStoreSupported() || blob.size > 536870912) return null;
+	const digest = await crypto.subtle.digest("SHA-256", await blob.arrayBuffer());
+	return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function mediaDir(create) {
+	if (!isMediaStoreSupported()) return null;
+	try {
+		return await (await navigator.storage.getDirectory()).getDirectoryHandle(MEDIA_DIR, { create });
+	} catch {
+		return null;
+	}
+}
+/** Persist a blob under its hash. No-op when already stored (same content). */
+async function saveMediaBlob(hash, blob) {
+	const dir = await mediaDir(true);
+	if (!dir) return false;
+	try {
+		try {
+			if ((await (await dir.getFileHandle(hash)).getFile()).size === blob.size) return true;
+		} catch {}
+		const writable = await (await dir.getFileHandle(hash, { create: true })).createWritable();
+		await writable.write(blob);
+		await writable.close();
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function loadMediaBlob(hash) {
+	const dir = await mediaDir(false);
+	if (!dir) return null;
+	try {
+		return await (await dir.getFileHandle(hash)).getFile();
+	} catch {
+		return null;
+	}
+}
+/** Delete stored blobs whose hash is not in `keep`. Returns removed count. */
+async function pruneMediaBlobs(keep) {
+	const dir = await mediaDir(false);
+	if (!dir) return 0;
+	let removed = 0;
+	try {
+		const names = [];
+		for await (const [name] of dir) if (!keep.has(name)) names.push(name);
+		for (const name of names) try {
+			await dir.removeEntry(name);
+			removed++;
+		} catch {}
+	} catch {}
+	return removed;
+}
+//#endregion
+//#region src/probe.ts
+/** Open a Mediabunny input over a Blob/File or a (blob:/http:) URL. */
+function inputFor(src) {
+	return new Input({
+		formats: ALL_FORMATS,
+		source: typeof src === "string" ? new UrlSource(src) : new BlobSource(src)
+	});
+}
+function isMatroskaFile(name, mimeType) {
+	const lowerName = name.toLowerCase();
+	const lowerMime = mimeType?.toLowerCase() ?? "";
+	return lowerName.endsWith(".mkv") || lowerName.endsWith(".mk3d") || lowerName.endsWith(".mka") || lowerMime.includes("matroska") || lowerMime === "video/x-matroska";
+}
+function finiteDurationMs(duration) {
+	return Number.isFinite(duration) && duration > 0 ? Math.round(duration * 1e3) : null;
+}
+function loadNativeMetadata(tag, src) {
+	return new Promise((resolve) => {
+		const media = document.createElement(tag);
+		let settled = false;
+		const settle = (metadata) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			media.removeAttribute("src");
+			media.load();
+			resolve(metadata);
+		};
+		const timer = setTimeout(() => settle(null), 15e3);
+		media.preload = "metadata";
+		media.muted = true;
+		media.onloadedmetadata = () => {
+			const durationMs = finiteDurationMs(media.duration);
+			if (durationMs === null) return settle(null);
+			const video = media instanceof HTMLVideoElement ? media : null;
+			const width = video?.videoWidth ?? 0;
+			const height = video?.videoHeight ?? 0;
+			const audioTracks = media.audioTracks?.length;
+			settle({
+				durationMs,
+				...width > 0 && height > 0 ? {
+					width,
+					height
+				} : {},
+				...audioTracks !== void 0 ? { audioTracks } : {}
+			});
+		};
+		media.onerror = () => settle(null);
+		media.src = src;
+	});
+}
+/**
+* Browser-native metadata fallback for files the browser can play but
+* Mediabunny cannot parse, e.g. MP4s with an extra unsupported first stream.
+*/
+async function probeNativeMedia(src) {
+	if (typeof document === "undefined") return null;
+	const mimeType = typeof src === "string" ? void 0 : src.type || void 0;
+	const url = typeof src === "string" ? src : URL.createObjectURL(src);
+	try {
+		const video = await loadNativeMetadata("video", url);
+		if (video?.width && video.height) return {
+			durationMs: video.durationMs,
+			hasVideo: true,
+			hasAudio: video.audioTracks === void 0 ? true : video.audioTracks > 0,
+			width: video.width,
+			height: video.height,
+			...mimeType ? { mimeType } : {}
+		};
+		const audio = await loadNativeMetadata("audio", url);
+		if (audio) return {
+			durationMs: audio.durationMs,
+			hasVideo: false,
+			hasAudio: true,
+			...mimeType ? { mimeType } : {}
+		};
+		return null;
+	} finally {
+		if (typeof src !== "string") URL.revokeObjectURL(url);
+	}
+}
+/** Resolve true once a throwaway `<video>` decodes the file's first frame. */
+function canDecodeNatively(file) {
+	return new Promise((resolve) => {
+		const url = URL.createObjectURL(file);
+		const video = document.createElement("video");
+		const settle = (result) => {
+			video.removeAttribute("src");
+			video.load();
+			URL.revokeObjectURL(url);
+			resolve(result);
+		};
+		const timer = setTimeout(() => settle(false), 5e3);
+		video.preload = "auto";
+		video.muted = true;
+		video.onloadeddata = () => {
+			clearTimeout(timer);
+			settle(video.videoWidth > 0);
+		};
+		video.onerror = () => {
+			clearTimeout(timer);
+			settle(false);
+		};
+		video.src = url;
+	});
+}
+/** Whether a video can use native `<video>` preview instead of decoded frames. */
+async function hasNativeVideoPreview(file, mimeType) {
+	if (isMatroskaFile(file.name, mimeType || file.type)) return false;
+	if (typeof document === "undefined") return true;
+	const type = mimeType || file.type;
+	if (!type) return true;
+	if (document.createElement("video").canPlayType(type) !== "") return true;
+	return canDecodeNatively(file);
+}
+/** Read duration, dimensions, and track layout of an audio/video file. */
+async function probeMedia(src) {
+	const input = inputFor(src);
+	try {
+		const [durationSeconds, video, audio, mimeType] = await Promise.all([
+			input.computeDuration(),
+			input.getPrimaryVideoTrack(),
+			input.getPrimaryAudioTrack(),
+			input.getMimeType().catch(() => void 0)
+		]);
+		return {
+			durationMs: Math.round(durationSeconds * 1e3),
+			hasVideo: video !== null,
+			hasAudio: audio !== null,
+			...video ? {
+				width: video.displayWidth,
+				height: video.displayHeight
+			} : {},
+			...mimeType ? { mimeType } : {}
+		};
+	} catch (error) {
+		const nativeProbe = await probeNativeMedia(src);
+		if (nativeProbe) return nativeProbe;
+		throw error;
+	} finally {
+		input.dispose();
+	}
+}
+/** Read intrinsic dimensions of an image URL (browser only). */
+function probeImage(src) {
+	return new Promise((resolve, reject) => {
+		const image = new Image();
+		image.onload = () => resolve({
+			width: image.naturalWidth,
+			height: image.naturalHeight
+		});
+		image.onerror = () => reject(/* @__PURE__ */ new Error(`failed to load image: ${src}`));
+		image.src = src;
+	});
+}
+/**
+* Turn a dropped/picked file into a probed {@link AssetRef} ready for the
+* `addAsset` command. Creates an object URL for `src` — callers own its
+* lifetime (revoke when the asset is removed). `hash` (SHA-256) is the
+* asset's stable identity for persistence/relink; very large files skip it.
+*/
+async function createAssetFromFile(file) {
+	const src = URL.createObjectURL(file);
+	const hash = await hashBlob(file).catch(() => null);
+	const base = {
+		id: createAssetId(),
+		src,
+		...hash ? { hash } : {},
+		name: file.name,
+		mimeType: file.type || void 0
+	};
+	try {
+		if (file.type.startsWith("image/")) {
+			const { width, height } = await probeImage(src);
+			return {
+				...base,
+				kind: "image",
+				width,
+				height
+			};
+		}
+		const probe = await probeMedia(file);
+		if (probe.hasVideo) return {
+			...base,
+			kind: "video",
+			durationMs: probe.durationMs,
+			width: probe.width,
+			height: probe.height,
+			nativePreview: await hasNativeVideoPreview(file, probe.mimeType)
+		};
+		if (probe.hasAudio) return {
+			...base,
+			kind: "audio",
+			durationMs: probe.durationMs
+		};
+		throw new Error(`"${file.name}" has no playable audio or video tracks`);
+	} catch (error) {
+		URL.revokeObjectURL(src);
+		throw error;
+	}
+}
+//#endregion
+//#region src/encoders.ts
+let ready = null;
+/**
+* Register WASM fallback encoders for codecs the runtime cannot encode
+* natively — today that's AAC on Firefox (no AudioEncoder AAC support), via
+* `@mediabunny/aac-encoder` (FFmpeg-based). The import is dynamic so
+* browsers with native AAC never download the WASM. Idempotent; export
+* paths await it before probing codecs.
+*/
+function ensureFallbackAudioEncoders() {
+	ready ??= (async () => {
+		try {
+			if (!await canEncodeAudio("aac")) {
+				const { registerAacEncoder } = await import("@mediabunny/aac-encoder");
+				registerAacEncoder();
+			}
+		} catch {}
+	})();
+	return ready;
+}
+//#endregion
+//#region src/export-types.ts
+const AUDIO_SAMPLE_RATE = 48e3;
+//#endregion
+//#region src/container-formats.ts
+const registry = /* @__PURE__ */ new Map();
+function registerContainerFormat(entry) {
+	if (registry.has(entry.id)) throw new Error(`container format "${entry.id}" is already registered`);
+	registry.set(entry.id, entry);
+}
+function getContainerFormat(id) {
+	return registry.get(id);
+}
+/** Every registered container format, in registration order (built-ins first). */
+function listContainerFormats() {
+	return [...registry.values()];
+}
+registerContainerFormat({
+	id: "mp4",
+	label: "MP4",
+	extension: "mp4",
+	mimeType: "video/mp4",
+	createOutputFormat: () => new Mp4OutputFormat()
+});
+registerContainerFormat({
+	id: "webm",
+	label: "WebM",
+	extension: "webm",
+	mimeType: "video/webm",
+	createOutputFormat: () => new WebMOutputFormat()
+});
+registerContainerFormat({
+	id: "mkv",
+	label: "MKV",
+	extension: "mkv",
+	mimeType: "video/x-matroska",
+	createOutputFormat: () => new MkvOutputFormat()
+});
+//#endregion
+//#region src/export-core.ts
+/**
+* The decode→composite→encode→mux pipeline. Everything here is worker-safe:
+* no `OfflineAudioContext`, no `AudioBuffer`, no DOM — the audio mix arrives
+* pre-rendered as planar PCM and is encoded via `AudioSampleSource`.
+*/
+function resolveContainerFormat(id = "mp4") {
+	const entry = getContainerFormat(id);
+	if (!entry) throw new Error(`unknown container format "${id}" (register it with registerContainerFormat)`);
+	return entry;
+}
+/** Can this browser encode video (and audio) for the given format? */
+async function getExportSupport(format = "mp4") {
+	if (typeof OffscreenCanvas === "undefined" || typeof VideoEncoder === "undefined") return {
+		video: false,
+		audio: false
+	};
+	await ensureFallbackAudioEncoders();
+	const outputFormat = resolveContainerFormat(format).createOutputFormat();
+	const [video, audio] = await Promise.all([getFirstEncodableVideoCodec(outputFormat.getSupportedVideoCodecs(), {
+		width: 1920,
+		height: 1080
+	}), getFirstEncodableAudioCodec(outputFormat.getSupportedAudioCodecs(), {
+		numberOfChannels: 2,
+		sampleRate: AUDIO_SAMPLE_RATE
+	})]);
+	return {
+		video: video !== null,
+		audio: audio !== null
+	};
+}
+/** ~1s encode chunks: bounded AudioData allocations, steady backpressure. */
+const AUDIO_CHUNK_FRAMES = 48e3;
+/**
+* Slice planar stereo PCM into `[left|right]` chunks for `AudioSample`
+* (f32-planar layout = each channel contiguous within a chunk).
+*/
+function* planarAudioChunks(mixed, chunkFrames = AUDIO_CHUNK_FRAMES) {
+	const total = Math.min(mixed.left.length, mixed.right.length);
+	for (let start = 0; start < total; start += chunkFrames) {
+		const frames = Math.min(chunkFrames, total - start);
+		const data = new Float32Array(frames * 2);
+		data.set(mixed.left.subarray(start, start + frames), 0);
+		data.set(mixed.right.subarray(start, start + frames), frames);
+		yield {
+			data,
+			frames,
+			timestamp: start / mixed.sampleRate
+		};
+	}
+}
+/**
+* Render a project to a video file, fully client-side and deterministically:
+* exact decoded samples per output frame (no `<video>` seeking), WebCodecs
+* encoding, Mediabunny muxing. Runs in the export worker (or inline as the
+* main-thread fallback).
+*/
+async function runExportPipeline(project, options) {
+	const { onProgress, signal, mixedAudio } = options;
+	const durationMs = getProjectDurationMs(project);
+	if (durationMs <= 0) throw new Error("Cannot export an empty project");
+	await ensureFallbackAudioEncoders();
+	const fps = project.fps;
+	const totalFrames = Math.max(1, Math.round(durationMs / 1e3 * fps));
+	const container = resolveContainerFormat(options.format);
+	const format = container.createOutputFormat();
+	const target = new BufferTarget();
+	const output = new Output({
+		format,
+		target
+	});
+	const videoCodec = await getFirstEncodableVideoCodec(format.getSupportedVideoCodecs(), {
+		width: project.width,
+		height: project.height
+	});
+	if (!videoCodec) throw new Error("This browser cannot encode video (WebCodecs unavailable or no supported codec)");
+	const canvas = new OffscreenCanvas(project.width, project.height);
+	const ctx = canvas.getContext("2d", { alpha: false });
+	if (!ctx) throw new Error("Could not create export canvas context");
+	const videoSource = new CanvasSource(canvas, {
+		codec: videoCodec,
+		bitrate: options.videoBitrate ?? QUALITY_HIGH
+	});
+	output.addVideoTrack(videoSource, { frameRate: fps });
+	let audioSource = null;
+	if (mixedAudio) {
+		const audioCodec = await getFirstEncodableAudioCodec(format.getSupportedAudioCodecs(), {
+			numberOfChannels: 2,
+			sampleRate: mixedAudio.sampleRate
+		});
+		if (audioCodec) {
+			audioSource = new AudioSampleSource({
+				codec: audioCodec,
+				bitrate: QUALITY_MEDIUM
+			});
+			output.addAudioTrack(audioSource);
+		}
+	}
+	const frameSource = new ExportFrameSource(project);
+	try {
+		await output.start();
+		if (audioSource && mixedAudio) {
+			for (const chunk of planarAudioChunks(mixedAudio)) {
+				signal?.throwIfAborted();
+				const sample = new AudioSample({
+					data: chunk.data,
+					format: "f32-planar",
+					numberOfChannels: 2,
+					sampleRate: mixedAudio.sampleRate,
+					timestamp: chunk.timestamp
+				});
+				await audioSource.add(sample);
+				sample.close();
+			}
+			audioSource.close();
+		}
+		for (let frame = 0; frame < totalFrames; frame++) {
+			signal?.throwIfAborted();
+			const midMs = (frame + .5) * 1e3 / fps;
+			await frameSource.prepare(midMs);
+			renderFrame(ctx, project, midMs, {
+				source: frameSource,
+				motionBlurSamples: 16
+			});
+			await videoSource.add(frame / fps, 1 / fps);
+			frameSource.releaseFrameTemporaries();
+			onProgress?.({
+				phase: "video",
+				progress: .1 + .85 * ((frame + 1) / totalFrames)
+			});
+		}
+		videoSource.close();
+		onProgress?.({
+			phase: "finalize",
+			progress: .97
+		});
+		await output.finalize();
+	} catch (error) {
+		await output.cancel().catch(() => {});
+		throw error;
+	} finally {
+		frameSource.dispose();
+	}
+	if (!target.buffer) throw new Error("Export produced no data");
+	return {
+		buffer: target.buffer,
+		mimeType: format.mimeType,
+		extension: container.extension
+	};
+}
+const frameKey = (assetId, sourceTimeMs) => `${assetId}@${Math.round(sourceTimeMs * 1e3)}`;
+/**
+* The exact {@link FrameSource} for export: per-element decoded sample
+* iterators (monotonic within an element), advanced frame-by-frame. The
+* async `prepare()` populates a per-frame cache that the synchronous
+* compositor then reads.
+*/
+var ExportFrameSource = class {
+	project;
+	inputs = /* @__PURE__ */ new Map();
+	states = /* @__PURE__ */ new Map();
+	images = /* @__PURE__ */ new Map();
+	frameCache = /* @__PURE__ */ new Map();
+	temporaries = [];
+	constructor(project) {
+		this.project = project;
+	}
+	async prepare(timeMs) {
+		this.frameCache.clear();
+		for (const { track, element } of getRenderableElements(this.project, timeMs)) {
+			if (track.hidden) continue;
+			if (element.type === "image") {
+				const bitmap = await this.ensureImage(element.assetId);
+				if (bitmap) this.frameCache.set(frameKey(element.assetId, 0), bitmap);
+			} else if (element.type === "video" || element.type === "multicam") for (const request of getFrameRequests(this.project, element, timeMs)) {
+				const sample = await this.advance(`${element.id}:${request.assetId}`, request.assetId, request.sourceTimeMs / 1e3);
+				if (sample) {
+					const image = sample.toCanvasImageSource();
+					if (typeof VideoFrame !== "undefined" && image instanceof VideoFrame) this.temporaries.push(image);
+					this.frameCache.set(frameKey(request.assetId, request.sourceTimeMs), image);
+				}
+			}
+		}
+	}
+	getFrame(assetId, sourceTimeMs) {
+		return this.frameCache.get(frameKey(assetId, sourceTimeMs)) ?? null;
+	}
+	/** Close per-frame `VideoFrame`s after the frame has been encoded. */
+	releaseFrameTemporaries() {
+		for (const frame of this.temporaries) frame.close();
+		this.temporaries = [];
+	}
+	dispose() {
+		this.releaseFrameTemporaries();
+		for (const state of this.states.values()) {
+			state.current?.close();
+			state.pending?.close();
+			state.iterator.return(void 0);
+		}
+		this.states.clear();
+		for (const { input } of this.inputs.values()) input.dispose();
+		this.inputs.clear();
+		for (const bitmap of this.images.values()) bitmap?.close();
+		this.images.clear();
+	}
+	async ensureSink(assetId) {
+		const existing = this.inputs.get(assetId);
+		if (existing) return existing.sink;
+		const asset = this.project.assets[assetId];
+		if (!asset) return null;
+		const input = inputFor(asset.src);
+		const track = await input.getPrimaryVideoTrack();
+		const sink = track ? new VideoSampleSink(track) : null;
+		this.inputs.set(assetId, {
+			input,
+			sink
+		});
+		return sink;
+	}
+	async ensureImage(assetId) {
+		if (this.images.has(assetId)) return this.images.get(assetId) ?? null;
+		const asset = this.project.assets[assetId];
+		if (!asset) return null;
+		try {
+			const response = await fetch(asset.src);
+			const bitmap = await createImageBitmap(await response.blob());
+			this.images.set(assetId, bitmap);
+			return bitmap;
+		} catch {
+			this.images.set(assetId, null);
+			return null;
+		}
+	}
+	async advance(stateKey, assetId, targetS) {
+		let state = this.states.get(stateKey);
+		if (state && targetS < state.lastTargetS) {
+			state.current?.close();
+			state.pending?.close();
+			state.iterator.return(void 0);
+			state = void 0;
+			this.states.delete(stateKey);
+		}
+		if (!state) {
+			const sink = await this.ensureSink(assetId);
+			if (!sink) return null;
+			state = {
+				iterator: sink.samples(Math.max(0, targetS)),
+				current: null,
+				pending: null,
+				done: false,
+				lastTargetS: targetS
+			};
+			this.states.set(stateKey, state);
+		}
+		state.lastTargetS = targetS;
+		while (!state.done) if (state.pending) if (state.pending.timestamp <= targetS) {
+			state.current?.close();
+			state.current = state.pending;
+			state.pending = null;
+		} else break;
+		else {
+			const result = await state.iterator.next();
+			if (result.done) state.done = true;
+			else state.pending = result.value;
+		}
+		return state.current;
+	}
+};
+//#endregion
+export { pruneMediaBlobs as _, listContainerFormats as a, ensureFallbackAudioEncoders as c, probeImage as d, probeMedia as f, loadMediaBlob as g, isMediaStoreSupported as h, getContainerFormat as i, createAssetFromFile as l, hashBlob as m, resolveContainerFormat as n, registerContainerFormat as o, MAX_HASHABLE_BYTES as p, runExportPipeline as r, AUDIO_SAMPLE_RATE as s, getExportSupport as t, inputFor as u, saveMediaBlob as v };

package/dist/export-worker.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/export-worker.js

@@ -0,0 +1,87 @@
+import { g as loadMediaBlob, r as runExportPipeline } from "./export-core-B8z3duRc.js";
+//#region src/export-worker.ts
+const scope = globalThis;
+const post = (message, transfer) => transfer ? scope.postMessage(message, transfer) : scope.postMessage(message);
+/**
+* Workers have their own `FontFaceSet` — faces loaded into `document.fonts`
+* on the main thread are invisible here, and canvas text silently falls back
+* without them. Best-effort: a face that fails to load degrades to the
+* fallback font exactly like the main-thread renderer does.
+*/
+async function registerFonts(fonts) {
+	const fontSet = scope.fonts;
+	if (!fontSet || typeof FontFace === "undefined") return;
+	await Promise.allSettled(fonts.map(async (init) => {
+		const source = typeof init.source === "string" ? `url(${JSON.stringify(init.source)})` : init.source;
+		const face = new FontFace(init.family, source, {
+			...init.weight ? { weight: init.weight } : {},
+			...init.style ? { style: init.style } : {},
+			...init.unicodeRange ? { unicodeRange: init.unicodeRange } : {}
+		});
+		await face.load();
+		fontSet.add(face);
+	}));
+}
+/**
+* Re-bind asset srcs for this worker: main-thread blob URLs are fetchable
+* from a worker, but OPFS by content hash is both faster and immune to a
+* revoked URL — prefer it when the asset carries a hash.
+*/
+async function resolveAssets(project) {
+	const urls = [];
+	const assets = { ...project.assets };
+	for (const [id, asset] of Object.entries(assets)) {
+		if (!asset.hash) continue;
+		const blob = await loadMediaBlob(asset.hash).catch(() => null);
+		if (!blob) continue;
+		const src = URL.createObjectURL(blob);
+		urls.push(src);
+		assets[id] = {
+			...asset,
+			src
+		};
+	}
+	return {
+		project: {
+			...project,
+			assets
+		},
+		revoke: () => urls.forEach((url) => URL.revokeObjectURL(url))
+	};
+}
+scope.onmessage = async (event) => {
+	const message = event.data;
+	if (message.type !== "start") return;
+	try {
+		await registerFonts(message.fonts);
+		const { project, revoke } = await resolveAssets(message.project);
+		try {
+			const result = await runExportPipeline(project, {
+				...message.options.format ? { format: message.options.format } : {},
+				...message.options.videoBitrate !== void 0 ? { videoBitrate: message.options.videoBitrate } : {},
+				mixedAudio: message.mixedAudio,
+				onProgress: ({ progress, phase }) => post({
+					type: "progress",
+					progress,
+					phase
+				})
+			});
+			post({
+				type: "done",
+				buffer: result.buffer,
+				mimeType: result.mimeType,
+				extension: result.extension
+			}, [result.buffer]);
+		} finally {
+			revoke();
+		}
+	} catch (error) {
+		post({
+			type: "error",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+};
+post({ type: "ready" });
+//#endregion
+export {};