@mcut/media 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1384 @@
+import { _ as pruneMediaBlobs, a as listContainerFormats, c as ensureFallbackAudioEncoders, d as probeImage, f as probeMedia, g as loadMediaBlob, h as isMediaStoreSupported, i as getContainerFormat, l as createAssetFromFile, m as hashBlob, n as resolveContainerFormat, o as registerContainerFormat, p as MAX_HASHABLE_BYTES, r as runExportPipeline, s as AUDIO_SAMPLE_RATE, t as getExportSupport, u as inputFor, v as saveMediaBlob } from "./export-core-B8z3duRc.js";
+import { AudioBufferSink, BufferTarget, CanvasSink, Conversion, Output, WavOutputFormat } from "mediabunny";
+import { getEffectiveVolume, getMulticamAudioSource, getMulticamSourceTimeMs, getProjectDurationMs, getRenderableElements, getSourceSpanMs, getSourceTimeMs, getSpeedAt, hasFades, hasKeyframes, interpolateTrack, isElementActiveAt } from "@mcut/timeline";
+//#region src/thumbnails.ts
+/** Extract a single poster frame from a video. Returns `null` for audio-only files. */
+async function getVideoThumbnail(src, options = {}) {
+	const input = inputFor(src);
+	try {
+		const track = await input.getPrimaryVideoTrack();
+		if (!track) return null;
+		return (await new CanvasSink(track, { width: options.width ?? 160 }).getCanvas((options.timeMs ?? 0) / 1e3))?.canvas ?? null;
+	} finally {
+		input.dispose();
+	}
+}
+/** A poster frame as a data URL (handy for `<img>` in media bins). */
+async function getVideoThumbnailUrl(src, options = {}) {
+	const canvas = await getVideoThumbnail(src, options);
+	if (!canvas) return null;
+	if (canvas instanceof OffscreenCanvas) {
+		const blob = await canvas.convertToBlob({
+			type: "image/jpeg",
+			quality: .7
+		});
+		return URL.createObjectURL(blob);
+	}
+	return canvas.toDataURL("image/jpeg", .7);
+}
+//#endregion
+//#region src/extract-audio.ts
+/** The file's audio exists but this browser has no decoder for its codec. */
+var AudioNotDecodableError = class extends Error {
+	constructor(codec) {
+		super(`This browser cannot decode the clip's audio${codec ? ` (${codec})` : ""}. Try re-encoding the file as MP4/AAC.`);
+		this.name = "AudioNotDecodableError";
+	}
+};
+async function runWavConversion(src, audio, onProgress) {
+	const input = inputFor(src);
+	try {
+		const target = new BufferTarget();
+		const output = new Output({
+			format: new WavOutputFormat(),
+			target
+		});
+		const conversion = await Conversion.init({
+			input,
+			output,
+			video: { discard: true },
+			audio,
+			showWarnings: false
+		});
+		if (!conversion.isValid) {
+			const audioDiscard = conversion.discardedTracks.find((d) => d.track.type === "audio");
+			if (audioDiscard?.reason === "undecodable_source_codec") throw new AudioNotDecodableError(audioDiscard.track.codec ?? void 0);
+			throw new Error(`Audio conversion is not possible for this file` + (audioDiscard ? ` (${audioDiscard.reason})` : ""));
+		}
+		if (onProgress) conversion.onProgress = onProgress;
+		await conversion.execute();
+		if (!target.buffer) return null;
+		return new Blob([target.buffer], { type: "audio/wav" });
+	} finally {
+		input.dispose();
+	}
+}
+/**
+* Extract a file's audio track to a PCM WAV blob, fully client-side.
+* Returns `null` when the file has no audio track. The default
+* 16 kHz/mono output keeps uploads to transcription APIs small.
+*
+* Resilience: when the resampled conversion fails (Mediabunny's resampler /
+* channel mixer can throw "Assertion failed." on unusual source layouts),
+* retry once WITHOUT resampling — the WAV is bigger but transcription APIs
+* accept any PCM rate. Undecodable codecs fail fast with a clear error.
+*/
+async function extractAudioToWav(src, options = {}) {
+	const probe = inputFor(src);
+	try {
+		if (!await probe.getPrimaryAudioTrack()) return null;
+	} finally {
+		probe.dispose();
+	}
+	try {
+		return await runWavConversion(src, {
+			codec: "pcm-s16",
+			sampleRate: options.sampleRate ?? 16e3,
+			numberOfChannels: options.numberOfChannels ?? 1
+		}, options.onProgress);
+	} catch (error) {
+		if (error instanceof AudioNotDecodableError) throw error;
+		return await runWavConversion(src, { codec: "pcm-s16" }, options.onProgress);
+	}
+}
+//#endregion
+//#region src/scrub-cache.ts
+/** ≈576² area cap per cached frame — small enough to keep 150 around. */
+const MAX_FRAME_AREA = 331776;
+var ScrubFrameCache = class {
+	maxFrames;
+	minGapMs;
+	/** Sorted by timeMs for binary search. */
+	frames = [];
+	/** Insertion order for FIFO eviction. */
+	order = [];
+	constructor(maxFrames = 150, minGapMs = 90) {
+		this.maxFrames = maxFrames;
+		this.minGapMs = minGapMs;
+	}
+	/** Capture the element's current frame if this instant isn't cached yet. */
+	capture(source, timeMs) {
+		if (typeof OffscreenCanvas === "undefined") return;
+		const sw = source.videoWidth;
+		const sh = source.videoHeight;
+		if (sw <= 0 || sh <= 0) return;
+		const index = this.indexAtOrAfter(timeMs);
+		const before = this.frames[index - 1];
+		const at = this.frames[index];
+		if (before && timeMs - before.timeMs < this.minGapMs || at && at.timeMs - timeMs < this.minGapMs) return;
+		const scale = Math.min(1, Math.sqrt(MAX_FRAME_AREA / (sw * sh)));
+		const canvas = new OffscreenCanvas(Math.max(1, Math.round(sw * scale)), Math.max(1, Math.round(sh * scale)));
+		const ctx = canvas.getContext("2d");
+		if (!ctx) return;
+		try {
+			ctx.drawImage(source, 0, 0, canvas.width, canvas.height);
+		} catch {
+			return;
+		}
+		const frame = {
+			timeMs,
+			canvas
+		};
+		this.frames.splice(index, 0, frame);
+		this.order.push(frame);
+		if (this.order.length > this.maxFrames) {
+			const evicted = this.order.shift();
+			const i = this.frames.indexOf(evicted);
+			if (i !== -1) this.frames.splice(i, 1);
+		}
+	}
+	/** The cached frame nearest `timeMs`, or null when the cache is empty. */
+	nearest(timeMs) {
+		if (this.frames.length === 0) return null;
+		const index = this.indexAtOrAfter(timeMs);
+		const before = this.frames[index - 1];
+		const at = this.frames[index];
+		if (!before) return at.canvas;
+		if (!at) return before.canvas;
+		return timeMs - before.timeMs <= at.timeMs - timeMs ? before.canvas : at.canvas;
+	}
+	get size() {
+		return this.frames.length;
+	}
+	clear() {
+		this.frames = [];
+		this.order = [];
+	}
+	/** First index whose frame time is >= timeMs. */
+	indexAtOrAfter(timeMs) {
+		let lo = 0;
+		let hi = this.frames.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (this.frames[mid].timeMs < timeMs) lo = mid + 1;
+			else hi = mid;
+		}
+		return lo;
+	}
+};
+//#endregion
+//#region src/preview-pool.ts
+const SAME_SOURCE_TOLERANCE_MS = 40;
+const SAME_RATE_TOLERANCE = .001;
+function hasSameMediaClock(a, b) {
+	return Math.abs(a.sourceTimeMs - b.sourceTimeMs) <= SAME_SOURCE_TOLERANCE_MS && Math.abs(a.rate - b.rate) <= SAME_RATE_TOLERANCE && Boolean(a.reversed) === Boolean(b.reversed);
+}
+function mergeActiveMediaItems(current, next) {
+	const kind = current.kind === "video" || next.kind === "video" ? "video" : "audio";
+	const currentAudible = current.volume > 0;
+	const nextAudible = next.volume > 0;
+	if (currentAudible && nextAudible) return {
+		...next.volume > current.volume ? next : current,
+		kind,
+		volume: hasSameMediaClock(current, next) ? current.volume + next.volume : Math.max(current.volume, next.volume)
+	};
+	if (nextAudible && !currentAudible) return {
+		...next,
+		kind
+	};
+	if (currentAudible && !nextAudible) return {
+		...current,
+		kind
+	};
+	if (current.kind !== "video" && next.kind === "video") return {
+		...next,
+		kind
+	};
+	return {
+		...current,
+		kind
+	};
+}
+/**
+* The pool has one native media element per asset. Collapse duplicate active
+* references so muted transition/visual items do not fight audible timeline
+* items over volume, rate, and currentTime in the same animation frame.
+*/
+function coalesceActiveMediaItems(items) {
+	const byAsset = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const current = byAsset.get(item.assetId);
+		byAsset.set(item.assetId, current ? mergeActiveMediaItems(current, item) : item);
+	}
+	return [...byAsset.values()];
+}
+/** The media items the preview pool should have live at `timeMs`. */
+function getActiveMediaItems(project, timeMs) {
+	const items = [];
+	for (const { track, element } of getRenderableElements(project, timeMs)) {
+		if (element.type === "multicam") {
+			const audible = isElementActiveAt(element, timeMs);
+			const speedShim = {
+				startMs: element.startMs,
+				durationMs: element.durationMs,
+				trimStartMs: 0,
+				timeMap: element.timeMap
+			};
+			for (const source of element.sources) {
+				const isAudio = source.key === element.audioSource;
+				items.push({
+					assetId: source.assetId,
+					kind: "video",
+					sourceTimeMs: getMulticamSourceTimeMs(element, source, timeMs),
+					rate: getSpeedAt(speedShim, timeMs - element.startMs),
+					volume: isAudio && audible && !track.muted && !element.muted ? getEffectiveVolume(element, timeMs) : 0
+				});
+			}
+			continue;
+		}
+		if (element.type !== "video" && element.type !== "audio") continue;
+		if (element.type === "video" && track.hidden && (track.muted || element.muted)) continue;
+		const localMs = timeMs - element.startMs;
+		const audible = isElementActiveAt(element, timeMs);
+		if (element.type === "audio" && !audible) continue;
+		items.push({
+			assetId: element.assetId,
+			kind: element.type,
+			sourceTimeMs: Math.max(0, getSourceTimeMs(element, localMs)),
+			rate: getSpeedAt(element, localMs),
+			volume: !audible || track.muted || element.muted || element.reversed ? 0 : getEffectiveVolume(element, timeMs),
+			...element.reversed ? { reversed: true } : {}
+		});
+	}
+	return items;
+}
+/**
+* Playing drift the rate bias absorbs; beyond this we re-seek. Re-seeking a
+* long-GOP source decodes from the previous keyframe, so chasing the playhead
+* with seeks degrades playback to blurry scrub-cache frames — within this
+* window a speed bias converges without ever interrupting decode.
+*/
+const MAX_CATCHUP_DRIFT_S = 1;
+/** Drift below this is noise (≈1 frame); don't bias the rate for it. */
+const MIN_CATCHUP_DRIFT_S = .05;
+const CATCHUP_RATE_MAX_BIAS = 1.5;
+const CATCHUP_RATE_MIN_BIAS = .75;
+/** Drift beyond which a paused media element gets re-seeked (scrubbing). */
+const PAUSED_DRIFT_TOLERANCE_S = .04;
+const DECODED_FRAME_STEP_MS = 100;
+const DECODED_FRAME_NEARBY_MS = 750;
+/** Upper bound on the predictive seek lead (runaway-estimate guard). */
+const MAX_SEEK_LEAD_S = 2;
+/** A seek in flight this long is wedged (lost decoder, dead src); re-issue. */
+const STUCK_SEEK_MS = 4e3;
+/** Minimum spacing between load() recovery attempts on an errored element. */
+const RECOVERY_INTERVAL_MS = 3e3;
+/** Back-off before re-trying a failed decoded-path (CanvasSink) init. */
+const DECODED_INIT_RETRY_MS = 3e3;
+function matroskaLike(asset) {
+	const name = asset.name?.toLowerCase() ?? "";
+	const mime = asset.mimeType?.toLowerCase() ?? "";
+	return name.endsWith(".mkv") || name.endsWith(".mk3d") || mime.includes("matroska") || mime === "video/x-matroska";
+}
+/** canPlayType per mimeType — this runs on every getFrame/sync call. */
+const canPlayTypeCache = /* @__PURE__ */ new Map();
+function canUseNativeVideoPreview(asset) {
+	if (asset.nativePreview === false || matroskaLike(asset)) return false;
+	if (asset.nativePreview === true) return true;
+	if (typeof document === "undefined") return true;
+	const mimeType = asset.mimeType;
+	if (!mimeType?.startsWith("video/")) return true;
+	let playable = canPlayTypeCache.get(mimeType);
+	if (playable === void 0) {
+		playable = document.createElement("video").canPlayType(mimeType) !== "";
+		canPlayTypeCache.set(mimeType, playable);
+	}
+	return playable;
+}
+function decodedFrameKey(sourceTimeMs) {
+	return Math.max(0, Math.round(sourceTimeMs / DECODED_FRAME_STEP_MS) * DECODED_FRAME_STEP_MS);
+}
+/**
+* The approximate, low-latency {@link FrameSource} used for interactive
+* preview: one pooled `<video>`/`<audio>` element per media asset, kept in
+* sync with the playback clock, plus decoded `ImageBitmap`s for images.
+* Audio plays through the media elements themselves (no Web Audio graph);
+* the deterministic export pipeline is a separate implementation.
+*
+* Known approximation: two simultaneously-active elements sharing one asset
+* share one media element, so they render the same source frame.
+*/
+var PreviewMediaPool = class {
+	resolveAsset;
+	media = /* @__PURE__ */ new Map();
+	images = /* @__PURE__ */ new Map();
+	scrubCaches = /* @__PURE__ */ new Map();
+	decodedVideos = /* @__PURE__ */ new Map();
+	disposed = false;
+	/** Transport state from the last sync(); steers mid-seek frame choice. */
+	playing = false;
+	constructor(resolveAsset) {
+		this.resolveAsset = resolveAsset;
+	}
+	getFrame(assetId, sourceTimeMs) {
+		const asset = this.resolveAsset(assetId);
+		if (!asset) return null;
+		if (asset.kind === "image") {
+			const cached = this.images.get(assetId);
+			if (cached === void 0) {
+				this.loadImage(assetId, asset.src);
+				return null;
+			}
+			return cached instanceof ImageBitmap ? cached : null;
+		}
+		if (asset.kind === "video") {
+			if (!canUseNativeVideoPreview(asset)) return this.getDecodedVideoFrame(assetId, asset, sourceTimeMs);
+			const element = this.media.get(assetId)?.el;
+			if (!(element instanceof HTMLVideoElement)) return null;
+			const cache = this.ensureScrubCache(assetId);
+			if (element.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA && !element.seeking) {
+				cache.capture(element, element.currentTime * 1e3);
+				return element;
+			}
+			if (element.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA && this.playing) return element;
+			const nearby = cache.nearest(sourceTimeMs);
+			if (nearby) return nearby;
+			return element.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA ? element : null;
+		}
+		return null;
+	}
+	/**
+	* Reconcile pooled media elements with the items active under the
+	* playhead. Called by the playback loop every frame and on seeks.
+	*/
+	sync(items, options) {
+		if (this.disposed) return;
+		this.playing = options.isPlaying && options.playbackRate > 0;
+		const activeItems = coalesceActiveMediaItems(items);
+		const activeIds = new Set(activeItems.map((item) => item.assetId));
+		for (const [assetId, pooled] of this.media) {
+			this.settleSeek(pooled);
+			if (!activeIds.has(assetId) && !pooled.el.paused) pooled.el.pause();
+		}
+		for (const item of activeItems) {
+			const pooled = this.ensureMediaElement(item.assetId, item.kind);
+			if (!pooled) continue;
+			const element = pooled.el;
+			if (element.error) {
+				this.recoverMediaElement(item.assetId, pooled);
+				continue;
+			}
+			const targetSeconds = item.sourceTimeMs / 1e3;
+			element.volume = Math.max(0, Math.min(1, item.volume * options.masterVolume));
+			element.muted = options.muted || item.volume <= 0;
+			const frozen = item.rate <= .01;
+			const forwardRate = Math.max(.0625, options.playbackRate * (frozen ? 1 : item.rate));
+			if (options.isPlaying && options.playbackRate > 0 && !frozen && !item.reversed) {
+				const drift = targetSeconds - element.currentTime;
+				let rate = forwardRate;
+				if (Math.abs(drift) > MAX_CATCHUP_DRIFT_S) {
+					const lead = drift > 0 ? Math.min(MAX_SEEK_LEAD_S, pooled.seekLatencyS * forwardRate) : 0;
+					this.requestSeek(pooled, targetSeconds + lead);
+				} else if (Math.abs(drift) > MIN_CATCHUP_DRIFT_S && !element.seeking) rate = forwardRate * Math.min(CATCHUP_RATE_MAX_BIAS, Math.max(CATCHUP_RATE_MIN_BIAS, 1 + drift));
+				if (element.playbackRate !== rate) element.playbackRate = rate;
+				if (element.paused) element.play().catch(() => {});
+			} else {
+				if (options.playbackRate > 0 && element.playbackRate !== forwardRate) element.playbackRate = forwardRate;
+				if (!element.paused) element.pause();
+				if (Math.abs(element.currentTime - targetSeconds) > PAUSED_DRIFT_TOLERANCE_S) this.requestSeek(pooled, targetSeconds);
+			}
+		}
+	}
+	/** Reload an errored element from the asset's current src, rate-limited. */
+	recoverMediaElement(assetId, pooled) {
+		const now = performance.now();
+		if (now - pooled.lastRecoveryAt < RECOVERY_INTERVAL_MS) return;
+		pooled.lastRecoveryAt = now;
+		const asset = this.resolveAsset(assetId);
+		if (!asset) return;
+		if (pooled.src !== asset.src) {
+			pooled.src = asset.src;
+			pooled.el.src = asset.src;
+		}
+		pooled.el.load();
+		pooled.seekStartedAt = null;
+	}
+	/**
+	* Seek unless one is already in flight. Restarting an in-flight seek aborts
+	* its decode, and on long-GOP sources (seek latency above the drift
+	* tolerance) that loops forever: no seek ever completes, playback degrades
+	* to scrub-cache frames, and a paused preview can stay black. Letting the
+	* seek land also coalesces scrubbing to the latest playhead position.
+	*/
+	requestSeek(pooled, targetSeconds) {
+		if (pooled.el.seeking) {
+			const startedAt = pooled.seekStartedAt;
+			if (startedAt !== null && performance.now() - startedAt < STUCK_SEEK_MS) return;
+		}
+		pooled.seekStartedAt = performance.now();
+		pooled.el.currentTime = Math.max(0, targetSeconds);
+	}
+	/** Fold a completed seek into the element's latency estimate. */
+	settleSeek(pooled) {
+		if (pooled.seekStartedAt === null || pooled.el.seeking) return;
+		const latency = (performance.now() - pooled.seekStartedAt) / 1e3;
+		pooled.seekLatencyS = pooled.seekLatencyS === 0 ? latency : pooled.seekLatencyS * .5 + latency * .5;
+		pooled.seekStartedAt = null;
+	}
+	/** Pause everything (e.g. when the player unmounts a project). */
+	pauseAll() {
+		for (const { el } of this.media.values()) if (!el.paused) el.pause();
+	}
+	dispose() {
+		this.disposed = true;
+		for (const { el } of this.media.values()) {
+			el.pause();
+			el.removeAttribute("src");
+			el.load();
+		}
+		this.media.clear();
+		for (const cache of this.scrubCaches.values()) cache.clear();
+		this.scrubCaches.clear();
+		for (const image of this.images.values()) if (image instanceof ImageBitmap) image.close();
+		this.images.clear();
+		for (const state of this.decodedVideos.values()) {
+			state.input?.dispose();
+			for (const frame of state.frames.values()) if (typeof ImageBitmap !== "undefined" && frame instanceof ImageBitmap) frame.close();
+		}
+		this.decodedVideos.clear();
+	}
+	ensureScrubCache(assetId) {
+		let cache = this.scrubCaches.get(assetId);
+		if (!cache) {
+			cache = new ScrubFrameCache();
+			this.scrubCaches.set(assetId, cache);
+		}
+		return cache;
+	}
+	ensureMediaElement(assetId, kind) {
+		const asset = this.resolveAsset(assetId);
+		if (!asset) return null;
+		let existing = this.media.get(assetId);
+		const audioOnly = kind === "video" && !canUseNativeVideoPreview(asset);
+		const wantsVideoElement = kind === "video" && !audioOnly;
+		if (existing) {
+			const existingIsVideo = existing.el instanceof HTMLVideoElement;
+			if (wantsVideoElement && !existingIsVideo || audioOnly && existingIsVideo) {
+				existing.el.pause();
+				existing.el.removeAttribute("src");
+				existing.el.load();
+				this.media.delete(assetId);
+				existing = void 0;
+			}
+		}
+		if (existing) {
+			if (existing.src !== asset.src) {
+				existing.src = asset.src;
+				existing.el.src = asset.src;
+				existing.el.load();
+				existing.seekStartedAt = null;
+			}
+			return existing;
+		}
+		const element = kind === "video" && !audioOnly ? document.createElement("video") : document.createElement("audio");
+		element.src = asset.src;
+		element.preload = "auto";
+		element.crossOrigin = "anonymous";
+		if (element instanceof HTMLVideoElement) {
+			element.playsInline = true;
+			element.muted = true;
+		}
+		const pooled = {
+			el: element,
+			src: asset.src,
+			seekStartedAt: null,
+			seekLatencyS: 0,
+			lastRecoveryAt: 0
+		};
+		this.media.set(assetId, pooled);
+		return pooled;
+	}
+	getDecodedVideoFrame(assetId, asset, sourceTimeMs) {
+		const state = this.ensureDecodedVideoState(assetId, asset);
+		if (state.failed) return null;
+		const key = decodedFrameKey(sourceTimeMs);
+		const exact = state.frames.get(key);
+		if (exact) return exact;
+		this.requestDecodedVideoFrame(assetId, asset, key);
+		let nearest = null;
+		for (const [frameKey, frame] of state.frames) {
+			const distance = Math.abs(frameKey - sourceTimeMs);
+			if (distance > DECODED_FRAME_NEARBY_MS) continue;
+			if (!nearest || distance < nearest.distance) nearest = {
+				distance,
+				frame
+			};
+		}
+		return nearest?.frame ?? null;
+	}
+	ensureDecodedVideoState(assetId, asset) {
+		let state = this.decodedVideos.get(assetId);
+		if (state && asset && state.src !== null && state.src !== asset.src) {
+			state.input?.dispose();
+			for (const frame of state.frames.values()) if (typeof ImageBitmap !== "undefined" && frame instanceof ImageBitmap) frame.close();
+			state = void 0;
+		}
+		if (!state) {
+			state = {
+				src: asset?.src ?? null,
+				input: null,
+				sink: null,
+				frames: /* @__PURE__ */ new Map(),
+				pendingKey: null,
+				failed: false,
+				lastInitFailureAt: 0
+			};
+			this.decodedVideos.set(assetId, state);
+		}
+		return state;
+	}
+	requestDecodedVideoFrame(assetId, asset, key) {
+		const state = this.ensureDecodedVideoState(assetId, asset);
+		if (state.failed || state.pendingKey === key || state.frames.has(key)) return;
+		if (!state.sink && performance.now() - state.lastInitFailureAt < DECODED_INIT_RETRY_MS) return;
+		state.pendingKey = key;
+		this.decodeVideoFrame(asset, key).then((frame) => {
+			if (this.disposed) return;
+			const current = this.decodedVideos.get(assetId);
+			if (!current) return;
+			if (frame) {
+				current.frames.set(key, frame);
+				this.trimDecodedVideoFrames(current, key);
+			}
+		}).catch(() => {}).finally(() => {
+			const current = this.decodedVideos.get(assetId);
+			if (current?.pendingKey === key) current.pendingKey = null;
+		});
+	}
+	async decodeVideoFrame(asset, sourceTimeMs) {
+		const state = this.ensureDecodedVideoState(asset.id, asset);
+		if (!state.sink) {
+			const input = inputFor(asset.src);
+			try {
+				const track = await input.getPrimaryVideoTrack();
+				if (!track || !await track.canDecode()) {
+					state.failed = true;
+					console.warn(`[mcut] no WebCodecs decoder for "${asset.name ?? asset.id}" (${track?.codec ?? "no video track"}); preview frames unavailable`);
+					input.dispose();
+					return null;
+				}
+				state.sink = new CanvasSink(track, {
+					width: Math.min(1280, asset.width ?? 1280),
+					fit: "contain"
+				});
+				state.input = input;
+			} catch (error) {
+				state.lastInitFailureAt = performance.now();
+				input.dispose();
+				throw error;
+			}
+		}
+		return (await state.sink.getCanvas(sourceTimeMs / 1e3))?.canvas ?? null;
+	}
+	trimDecodedVideoFrames(state, centerKey) {
+		if (state.frames.size <= 80) return;
+		const keep = new Set([...state.frames.keys()].sort((a, b) => Math.abs(a - centerKey) - Math.abs(b - centerKey)).slice(0, 60));
+		for (const key of state.frames.keys()) if (!keep.has(key)) state.frames.delete(key);
+	}
+	loadImage(assetId, src) {
+		this.images.set(assetId, "loading");
+		fetch(src).then((response) => response.blob()).then((blob) => createImageBitmap(blob)).then((bitmap) => {
+			if (this.disposed) {
+				bitmap.close();
+				return;
+			}
+			this.images.set(assetId, bitmap);
+		}).catch(() => {
+			this.images.set(assetId, "error");
+		});
+	}
+};
+//#endregion
+//#region src/signalsmith-offline.ts
+/**
+* Offline buffer driver for signalsmith-stretch.
+*
+* The official npm build only ships an AudioWorklet wrapper, but export is
+* offline: we want the stretch as a pure samples-in/samples-out call that
+* works anywhere — main thread, dedicated workers (no OfflineAudioContext),
+* and Bun tests (no Web Audio at all). The worklet file detects its scope by
+* looking for `AudioWorkletProcessor`/`registerProcessor` globals, so we
+* shim those for the import, capture the registered processor class, and
+* pump its `process()` blocks ourselves instead of letting an AudioContext
+* drive it. The WASM engine and scheduling logic are untouched — only the
+* realtime callback is replaced with a loop.
+*
+* The processor reads the worklet globals `sampleRate` and `currentTime` as
+* free variables, so renders are serialized through a queue while those sit
+* on `globalThis`.
+*/
+/** Worklets process audio in fixed 128-frame quanta; the processor assumes the same. */
+const BLOCK_FRAMES = 128;
+/** A same-realm MessageChannel stand-in delivering on microtasks. */
+function createPortPair() {
+	const node = {
+		onmessage: null,
+		postMessage: (data) => queueMicrotask(() => processor.onmessage?.({ data }))
+	};
+	const processor = {
+		onmessage: null,
+		postMessage: (data) => queueMicrotask(() => node.onmessage?.({ data }))
+	};
+	return {
+		node,
+		processor
+	};
+}
+const globals = globalThis;
+/** Port handed to the next FakeAudioWorkletProcessor constructed. */
+let nextProcessorPort = null;
+let processorClassPromise = null;
+function loadProcessorClass() {
+	processorClassPromise ??= (async () => {
+		let captured;
+		const hadProcessor = "AudioWorkletProcessor" in globals;
+		const hadRegister = "registerProcessor" in globals;
+		const previousProcessor = globals.AudioWorkletProcessor;
+		const previousRegister = globals.registerProcessor;
+		globals.AudioWorkletProcessor = class FakeAudioWorkletProcessor {
+			port;
+			constructor() {
+				const port = nextProcessorPort;
+				nextProcessorPort = null;
+				if (!port) throw new Error("FakeAudioWorkletProcessor constructed without a port");
+				this.port = port;
+			}
+		};
+		globals.registerProcessor = (_name, cls) => {
+			captured = cls;
+		};
+		try {
+			await import("signalsmith-stretch");
+		} finally {
+			if (hadProcessor) globals.AudioWorkletProcessor = previousProcessor;
+			else delete globals.AudioWorkletProcessor;
+			if (hadRegister) globals.registerProcessor = previousRegister;
+			else delete globals.registerProcessor;
+		}
+		if (!captured) throw new Error("signalsmith-stretch did not register its worklet processor");
+		return captured;
+	})();
+	return processorClassPromise;
+}
+/** Renders are serialized: the processor reads sampleRate/currentTime off globalThis. */
+let renderQueue = Promise.resolve();
+/**
+* Stretch `channels` (equal-length planar PCM) by `tempo` (2 = twice as
+* fast), pitch preserved, producing exactly `outputFrames` frames per
+* channel. Same scheduling as the realtime node: play from input 0 at
+* `tempo` starting at output time 0.
+*/
+function renderStretchOffline(channels, sampleRate, tempo, outputFrames) {
+	const run = renderQueue.then(() => doRender(channels, sampleRate, tempo, outputFrames));
+	renderQueue = run.catch(() => {});
+	return run;
+}
+async function doRender(channels, sampleRate, tempo, outputFrames) {
+	if (channels.length === 0 || outputFrames <= 0) return channels.map(() => new Float32Array(0));
+	const Processor = await loadProcessorClass();
+	const hadSampleRate = "sampleRate" in globals;
+	const hadCurrentTime = "currentTime" in globals;
+	const previousSampleRate = globals.sampleRate;
+	const previousCurrentTime = globals.currentTime;
+	globals.sampleRate = sampleRate;
+	globals.currentTime = 0;
+	try {
+		const { node, processor } = createPortPair();
+		const pending = /* @__PURE__ */ new Map();
+		let readyResolve;
+		const ready = new Promise((resolve) => {
+			readyResolve = resolve;
+		});
+		node.onmessage = ({ data }) => {
+			const [id, value] = data;
+			if (id === "ready") readyResolve();
+			else if (typeof id === "number") {
+				pending.get(id)?.(value);
+				pending.delete(id);
+			}
+		};
+		nextProcessorPort = processor;
+		const instance = new Processor({
+			numberOfInputs: 0,
+			numberOfOutputs: 1,
+			outputChannelCount: [channels.length]
+		});
+		await ready;
+		let idCounter = 0;
+		const call = (method, ...args) => new Promise((resolve) => {
+			const id = idCounter++;
+			pending.set(id, resolve);
+			node.postMessage([
+				id,
+				method,
+				...args
+			]);
+		});
+		await call("addBuffers", channels);
+		await call("schedule", {
+			active: true,
+			input: 0,
+			output: 0,
+			rate: tempo
+		});
+		const out = channels.map(() => new Float32Array(outputFrames));
+		const block = channels.map(() => new Float32Array(BLOCK_FRAMES));
+		let written = 0;
+		while (written < outputFrames) {
+			globals.currentTime = written / sampleRate;
+			instance.process([[]], [block], {});
+			const take = Math.min(BLOCK_FRAMES, outputFrames - written);
+			for (let c = 0; c < channels.length; c++) {
+				const source = take === BLOCK_FRAMES ? block[c] : block[c].subarray(0, take);
+				out[c].set(source, written);
+			}
+			written += take;
+		}
+		return out;
+	} finally {
+		if (hadSampleRate) globals.sampleRate = previousSampleRate;
+		else delete globals.sampleRate;
+		if (hadCurrentTime) globals.currentTime = previousCurrentTime;
+		else delete globals.currentTime;
+	}
+}
+//#endregion
+//#region src/time-stretch.ts
+/** The constant speed a timeMap encodes, or null when it's a ramp/freeze. */
+function constantSpeedOf(timeMap) {
+	if (!timeMap || timeMap.length !== 2) return null;
+	const [from, to] = [timeMap[0], timeMap[1]];
+	if (from.timeMs !== 0) return null;
+	if (from.easing !== void 0 && from.easing !== "linear") return null;
+	const sourceSpanMs = to.value - from.value;
+	const outputMs = to.timeMs - from.timeMs;
+	if (sourceSpanMs <= 0 || outputMs <= 0) return null;
+	return {
+		rate: sourceSpanMs / outputMs,
+		sourceStartOffsetMs: from.value,
+		sourceSpanMs
+	};
+}
+/**
+* Stretch stereo PCM by `tempo` (2 = twice as fast, half as long) with
+* pitch preserved. Output length ≈ input / tempo.
+*/
+async function stretchStereo(data, tempo) {
+	const inputFrames = data.left.length;
+	const expectedFrames = Math.max(1, Math.round(inputFrames / tempo));
+	const [left, right] = await renderStretchOffline([data.left, data.right], data.sampleRate, tempo, expectedFrames);
+	return {
+		left,
+		right,
+		sampleRate: data.sampleRate
+	};
+}
+//#endregion
+//#region src/export-audio.ts
+function buildRemapPlan(timeMap, durationMs) {
+	const stepMs = 10;
+	const steps = Math.max(2, Math.ceil(durationMs / stepMs) + 1);
+	const grid = new Float64Array(steps);
+	for (let i = 0; i < steps; i++) grid[i] = interpolateTrack(timeMap, Math.min(durationMs, i * stepMs));
+	return {
+		grid,
+		stepMs
+	};
+}
+/**
+* Where (output ms) and how fast (source-ms per output-ms) a source offset
+* plays. Returns null inside freezes — frozen spans consume no source audio.
+*/
+function remapSourceToOutput(plan, sourceOffsetMs) {
+	const { grid, stepMs } = plan;
+	const last = grid.length - 1;
+	if (sourceOffsetMs >= grid[last]) {
+		const seg = grid[last] - grid[last - 1];
+		if (seg <= 1e-6) return null;
+		return {
+			outputMs: last * stepMs,
+			rate: seg / stepMs
+		};
+	}
+	let lo = 0;
+	let hi = last;
+	while (hi - lo > 1) {
+		const mid = lo + hi >> 1;
+		if (grid[mid] <= sourceOffsetMs) lo = mid;
+		else hi = mid;
+	}
+	const seg = grid[hi] - grid[lo];
+	if (seg <= 1e-6) return null;
+	const frac = (sourceOffsetMs - grid[lo]) / seg;
+	return {
+		outputMs: (lo + frac) * stepMs,
+		rate: seg / stepMs
+	};
+}
+/** Sample an armed volume track into a Web Audio value curve (~50ms steps). */
+function sampleVolumeCurve(element, getValue) {
+	const steps = Math.min(2e3, Math.max(2, Math.ceil(element.durationMs / 50) + 1));
+	const curve = new Float32Array(steps);
+	for (let i = 0; i < steps; i++) {
+		const timelineMs = element.startMs + i / (steps - 1) * element.durationMs;
+		curve[i] = Math.max(0, getValue(timelineMs));
+	}
+	return curve;
+}
+function collectAudibleSegments(project) {
+	const segments = [];
+	for (const track of project.tracks) {
+		if (track.muted) continue;
+		for (const element of track.elements) {
+			if (element.type === "multicam" && !element.muted) {
+				const source = getMulticamAudioSource(element);
+				const asset = source ? project.assets[source.assetId] : void 0;
+				if (!source || !asset) continue;
+				const curved = hasKeyframes(element, "volume") || hasFades(element);
+				if (element.volume <= 0 && !curved) continue;
+				segments.push({
+					src: asset.src,
+					startMs: element.startMs,
+					durationMs: element.durationMs,
+					trimStartMs: source.trimStartMs,
+					sourceSpanMs: getSourceSpanMs(element),
+					...element.timeMap ? { timeMap: element.timeMap } : {},
+					volume: element.volume,
+					...curved ? { volumeCurve: sampleVolumeCurve(element, (timelineMs) => getEffectiveVolume(element, timelineMs)) } : {}
+				});
+				continue;
+			}
+			if (element.type !== "video" && element.type !== "audio" || element.muted) continue;
+			const curved = hasKeyframes(element, "volume") || hasFades(element);
+			if (element.volume <= 0 && !curved) continue;
+			const asset = project.assets[element.assetId];
+			if (!asset) continue;
+			segments.push({
+				src: asset.src,
+				startMs: element.startMs,
+				durationMs: element.durationMs,
+				trimStartMs: element.trimStartMs,
+				sourceSpanMs: getSourceSpanMs(element),
+				...element.timeMap ? { timeMap: element.timeMap } : {},
+				...element.reversed ? { reversed: true } : {},
+				volume: element.volume,
+				...curved ? { volumeCurve: sampleVolumeCurve(element, (timelineMs) => getEffectiveVolume(element, timelineMs)) } : {}
+			});
+		}
+	}
+	return segments;
+}
+/**
+* Mix every audible segment offline and return transferable planar stereo
+* PCM, or null when the project has no audible segments. Main-thread only.
+*/
+async function mixProjectAudio(project, totalDurationMs, signal) {
+	const segments = collectAudibleSegments(project);
+	if (segments.length === 0) return null;
+	const buffer = await mixAudioSegments(segments, totalDurationMs, signal);
+	return {
+		left: buffer.getChannelData(0),
+		right: buffer.numberOfChannels > 1 ? buffer.getChannelData(1) : buffer.getChannelData(0),
+		sampleRate: buffer.sampleRate
+	};
+}
+async function mixAudioSegments(segments, totalDurationMs, signal) {
+	const length = Math.ceil(totalDurationMs / 1e3 * AUDIO_SAMPLE_RATE);
+	const offline = new OfflineAudioContext(2, length, AUDIO_SAMPLE_RATE);
+	for (const segment of segments) {
+		signal?.throwIfAborted();
+		const input = inputFor(segment.src);
+		try {
+			const track = await input.getPrimaryAudioTrack();
+			if (!track) continue;
+			const sink = new AudioBufferSink(track);
+			const segmentStartS = segment.startMs / 1e3;
+			const segmentEndS = (segment.startMs + segment.durationMs) / 1e3;
+			const trimS = segment.trimStartMs / 1e3;
+			const gain = offline.createGain();
+			if (segment.volumeCurve) gain.gain.setValueCurveAtTime(segment.volumeCurve, segmentStartS, segment.durationMs / 1e3);
+			else gain.gain.value = segment.volume;
+			gain.connect(offline.destination);
+			if (segment.reversed) {
+				await scheduleReversedSegment(offline, gain, sink, segment, signal);
+				continue;
+			}
+			const constant = constantSpeedOf(segment.timeMap);
+			if (constant && Math.abs(constant.rate - 1) > 1e-6) {
+				if (await scheduleStretchedSegment(offline, gain, sink, segment, constant, signal)) continue;
+			}
+			const plan = segment.timeMap ? buildRemapPlan(segment.timeMap, segment.durationMs) : null;
+			for await (const { buffer, timestamp } of sink.buffers(trimS, trimS + segment.sourceSpanMs / 1e3)) {
+				signal?.throwIfAborted();
+				let rate = 1;
+				let when;
+				if (plan) {
+					const remapped = remapSourceToOutput(plan, (timestamp - trimS) * 1e3);
+					if (!remapped || remapped.rate <= .01) continue;
+					rate = remapped.rate;
+					when = segmentStartS + remapped.outputMs / 1e3;
+				} else when = segmentStartS + (timestamp - trimS);
+				let offset = 0;
+				if (when < segmentStartS) {
+					offset = (segmentStartS - when) * rate;
+					when = segmentStartS;
+				}
+				const playDuration = Math.min(buffer.duration - offset, (segmentEndS - when) * rate);
+				if (playDuration <= 0) continue;
+				const node = offline.createBufferSource();
+				node.buffer = buffer;
+				node.playbackRate.value = rate;
+				node.connect(gain);
+				node.start(when, offset, playDuration);
+			}
+		} finally {
+			input.dispose();
+		}
+	}
+	return offline.startRendering();
+}
+/** Source-frame ceiling for whole-segment stretching (~11 min at 48kHz). */
+const MAX_STRETCH_SOURCE_FRAMES = 32e6;
+/**
+* Decode a contiguous source range into one stereo buffer. Returns null when
+* the range is too large (see {@link MAX_STRETCH_SOURCE_FRAMES}) or yields
+* no buffers.
+*/
+async function decodeCompositeRange(sink, startS, spanS, signal) {
+	let composite = null;
+	for await (const { buffer, timestamp } of sink.buffers(startS, startS + spanS)) {
+		signal?.throwIfAborted();
+		if (!composite) {
+			const sampleRate = buffer.sampleRate;
+			const frames = Math.ceil(spanS * sampleRate);
+			if (frames > MAX_STRETCH_SOURCE_FRAMES) return null;
+			composite = {
+				left: new Float32Array(frames),
+				right: new Float32Array(frames),
+				sampleRate
+			};
+		}
+		const offset = Math.max(0, Math.round((timestamp - startS) * composite.sampleRate));
+		if (offset >= composite.left.length) continue;
+		const left = buffer.getChannelData(0);
+		const right = buffer.numberOfChannels > 1 ? buffer.getChannelData(1) : left;
+		const count = Math.min(left.length, composite.left.length - offset);
+		composite.left.set(count === left.length ? left : left.subarray(0, count), offset);
+		composite.right.set(count === right.length ? right : right.subarray(0, count), offset);
+	}
+	return composite;
+}
+/** Wrap a composite in an AudioBuffer and schedule it across the segment. */
+function scheduleComposite(offline, gain, segment, left, right, sampleRate) {
+	const out = offline.createBuffer(2, left.length, sampleRate);
+	out.getChannelData(0).set(left);
+	out.getChannelData(1).set(right);
+	const node = offline.createBufferSource();
+	node.buffer = out;
+	node.connect(gain);
+	node.start(segment.startMs / 1e3, 0, Math.min(out.duration, segment.durationMs / 1e3));
+}
+/**
+* Decode a constant-speed segment's full source range, time-stretch it with
+* pitch preserved, and schedule it as one node. Returns false (caller falls
+* back to per-buffer playbackRate) when the range is too large or decoding
+* misbehaves.
+*/
+async function scheduleStretchedSegment(offline, gain, sink, segment, constant, signal) {
+	try {
+		const composite = await decodeCompositeRange(sink, (segment.trimStartMs + constant.sourceStartOffsetMs) / 1e3, constant.sourceSpanMs / 1e3, signal);
+		if (!composite) return false;
+		const stretched = await stretchStereo(composite, constant.rate);
+		if (stretched.left.length === 0) return false;
+		scheduleComposite(offline, gain, segment, stretched.left, stretched.right, composite.sampleRate);
+		return true;
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return false;
+	}
+}
+/**
+* Decode a reversed segment's full source span, flip the samples, and
+* schedule it as one node — pitch-preserving stretch when the clip is also
+* speed-changed. Speed RAMPS on reversed clips render at their average rate
+* (a v1 limit). Returns false when decoding misbehaves; the caller leaves
+* the segment silent rather than playing it forward.
+*/
+async function scheduleReversedSegment(offline, gain, sink, segment, signal) {
+	try {
+		const composite = await decodeCompositeRange(sink, segment.trimStartMs / 1e3, segment.sourceSpanMs / 1e3, signal);
+		if (!composite) return false;
+		composite.left.reverse();
+		composite.right.reverse();
+		const rate = segment.sourceSpanMs / Math.max(1, segment.durationMs);
+		let { left, right } = composite;
+		if (Math.abs(rate - 1) > 1e-6) {
+			const stretched = await stretchStereo(composite, rate);
+			if (stretched.left.length === 0) return false;
+			left = stretched.left;
+			right = stretched.right;
+		}
+		scheduleComposite(offline, gain, segment, left, right, composite.sampleRate);
+		return true;
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return false;
+	}
+}
+//#endregion
+//#region src/export.ts
+/** How the last `exportProject` call ran — observability for tests/debugging. */
+function noteExportMode(mode) {
+	globalThis.__mcutLastExportMode = mode;
+}
+/** Worker spawn → first message budget (dev bundlers compile on demand). */
+const WORKER_READY_TIMEOUT_MS = 15e3;
+/** The worker failed before its 'ready' handshake — safe to run locally. */
+var WorkerStartError = class extends Error {};
+/**
+* Render a project to a video file, fully client-side and deterministically.
+*
+* The audio mix renders first on the main thread (`OfflineAudioContext` and
+* the time-stretch worklet don't exist in workers), then the frame
+* decode→composite→encode→mux pipeline runs in a dedicated worker so the
+* editor stays responsive; environments without workers (Node/Bun, spawn
+* failure) fall back to running the same pipeline in-context.
+*/
+async function exportProject(project, options = {}) {
+	const { onProgress, signal } = options;
+	signal?.throwIfAborted();
+	const durationMs = getProjectDurationMs(project);
+	if (durationMs <= 0) throw new Error("Cannot export an empty project");
+	const container = resolveContainerFormat(options.format);
+	let mixedAudio = null;
+	if ((await getExportSupport(options.format)).audio) {
+		onProgress?.({
+			phase: "audio",
+			progress: 0
+		});
+		mixedAudio = await mixProjectAudio(project, durationMs, signal);
+		onProgress?.({
+			phase: "audio",
+			progress: .1
+		});
+	}
+	const worker = options.videoBitrate === void 0 || typeof options.videoBitrate === "number" ? spawnExportWorker() : null;
+	if (worker) try {
+		noteExportMode("worker");
+		return await runInWorker(worker, project, options, mixedAudio, container.extension);
+	} catch (error) {
+		if (!(error instanceof WorkerStartError)) throw error;
+		console.warn(`mcut export: ${error.message}; falling back to main-thread export`);
+	} finally {
+		worker.terminate();
+	}
+	noteExportMode("local");
+	const result = await runExportPipeline(project, {
+		...options.format ? { format: options.format } : {},
+		...options.videoBitrate !== void 0 ? { videoBitrate: options.videoBitrate } : {},
+		mixedAudio,
+		...onProgress ? { onProgress } : {},
+		...signal ? { signal } : {}
+	});
+	return {
+		blob: new Blob([result.buffer], { type: result.mimeType }),
+		extension: result.extension
+	};
+}
+/**
+* Spawn the export worker, or null where workers can't run the pipeline
+* (Node/Bun, no Worker global, spawn throws). The `new Worker(new URL(...))`
+* form is load-bearing: bundlers (Turbopack/webpack/Vite) statically detect
+* it and emit `export-worker.js` as a worker entry.
+*/
+function spawnExportWorker() {
+	if (typeof Worker === "undefined" || typeof window === "undefined") return null;
+	try {
+		return new Worker(new URL("./export-worker.js", import.meta.url), { type: "module" });
+	} catch {
+		return null;
+	}
+}
+function runInWorker(worker, project, options, mixedAudio, extension) {
+	const { onProgress, signal } = options;
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let started = false;
+		const settle = (fn) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(readyTimer);
+			signal?.removeEventListener("abort", onAbort);
+			fn();
+		};
+		const onAbort = () => settle(() => reject(signal?.reason ?? new DOMException("Aborted", "AbortError")));
+		signal?.addEventListener("abort", onAbort);
+		const readyTimer = setTimeout(() => settle(() => reject(new WorkerStartError("export worker did not start in time"))), WORKER_READY_TIMEOUT_MS);
+		worker.onerror = (event) => settle(() => {
+			const detail = event.message || "unknown error";
+			reject(started ? /* @__PURE__ */ new Error(`Export worker crashed: ${detail}`) : new WorkerStartError(`export worker failed to load (${detail})`));
+		});
+		worker.onmessage = (event) => {
+			const message = event.data;
+			switch (message.type) {
+				case "ready": {
+					clearTimeout(readyTimer);
+					started = true;
+					const start = {
+						type: "start",
+						project,
+						options: {
+							...options.format ? { format: options.format } : {},
+							...typeof options.videoBitrate === "number" ? { videoBitrate: options.videoBitrate } : {}
+						},
+						mixedAudio,
+						fonts: options.fonts ?? []
+					};
+					worker.postMessage(start, collectTransfers(mixedAudio, options.fonts));
+					break;
+				}
+				case "progress":
+					if (!settled) onProgress?.({
+						progress: message.progress,
+						phase: message.phase
+					});
+					break;
+				case "done":
+					settle(() => {
+						onProgress?.({
+							phase: "finalize",
+							progress: 1
+						});
+						resolve({
+							blob: new Blob([message.buffer], { type: message.mimeType }),
+							extension: message.extension || extension
+						});
+					});
+					break;
+				case "error":
+					settle(() => reject(new Error(message.message)));
+					break;
+			}
+		};
+	});
+}
+function collectTransfers(mixedAudio, fonts) {
+	const transfers = /* @__PURE__ */ new Set();
+	if (mixedAudio) {
+		transfers.add(mixedAudio.left.buffer);
+		transfers.add(mixedAudio.right.buffer);
+	}
+	for (const font of fonts ?? []) if (typeof font.source !== "string") transfers.add(font.source);
+	return [...transfers];
+}
+//#endregion
+//#region src/filmstrip.ts
+function createCanvas(width, height) {
+	if (typeof document !== "undefined") {
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		return canvas;
+	}
+	return new OffscreenCanvas(width, height);
+}
+/**
+* Sample evenly spaced poster frames into one horizontal strip — the
+* filmstrip background of timeline video clips. Returns `null` for files
+* without a video track.
+*/
+async function getFilmstrip(src, options) {
+	const frameWidth = options.frameWidth ?? 80;
+	const frameCount = Math.max(1, Math.round(options.frameCount));
+	const input = inputFor(src);
+	try {
+		const track = await input.getPrimaryVideoTrack();
+		if (!track) return null;
+		const durationMs = options.endMs ?? await input.computeDuration() * 1e3;
+		const startMs = options.startMs ?? 0;
+		const spanMs = Math.max(1, durationMs - startMs);
+		const timestampsMs = Array.from({ length: frameCount }, (_, i) => startMs + (i + .5) / frameCount * spanMs);
+		const sink = new CanvasSink(track, {
+			width: frameWidth,
+			fit: "cover"
+		});
+		let strip = null;
+		let ctx = null;
+		let frameHeight = 0;
+		let index = 0;
+		for await (const wrapped of sink.canvasesAtTimestamps(timestampsMs.map((ms) => ms / 1e3))) {
+			if (wrapped) {
+				if (!strip) {
+					frameHeight = wrapped.canvas.height;
+					strip = createCanvas(frameWidth * frameCount, frameHeight);
+					ctx = strip.getContext("2d");
+				}
+				ctx?.drawImage(wrapped.canvas, index * frameWidth, 0);
+			}
+			index++;
+		}
+		if (!strip) return null;
+		return {
+			canvas: strip,
+			frameWidth,
+			frameHeight,
+			frameCount,
+			timestampsMs
+		};
+	} finally {
+		input.dispose();
+	}
+}
+//#endregion
+//#region src/audio-peaks.ts
+/** Fold samples into `buckets` max-|amplitude| bins (pure; unit-tested). */
+function bucketPeaks(samples, buckets) {
+	const peaks = new Float32Array(Math.max(1, buckets));
+	if (samples.length === 0) return peaks;
+	const perBucket = samples.length / peaks.length;
+	for (let i = 0; i < samples.length; i++) {
+		const bucket = Math.min(peaks.length - 1, Math.floor(i / perBucket));
+		const value = Math.abs(samples[i]);
+		if (value > peaks[bucket]) peaks[bucket] = value;
+	}
+	return peaks;
+}
+/**
+* Decode a file's audio and reduce it to waveform peaks for timeline clip
+* rendering. Returns `null` when the file has no audio track. Browser-only
+* (WebCodecs decode via Mediabunny).
+*/
+async function extractAudioPeaks(src, options = {}) {
+	const bucketCount = options.buckets ?? 256;
+	const input = inputFor(src);
+	try {
+		const track = await input.getPrimaryAudioTrack();
+		if (!track) return null;
+		const durationMs = options.endMs ?? await input.computeDuration() * 1e3;
+		const startMs = options.startMs ?? 0;
+		const spanMs = Math.max(1, durationMs - startMs);
+		const peaks = new Float32Array(bucketCount);
+		const sink = new AudioBufferSink(track);
+		for await (const { buffer, timestamp } of sink.buffers(startMs / 1e3, durationMs / 1e3)) {
+			const channel = buffer.getChannelData(0);
+			const bufferStartMs = timestamp * 1e3;
+			const msPerSample = 1e3 / buffer.sampleRate;
+			const stride = Math.max(1, Math.floor(channel.length / 4096));
+			for (let i = 0; i < channel.length; i += stride) {
+				const timeMs = bufferStartMs + i * msPerSample;
+				const bucket = Math.floor((timeMs - startMs) / spanMs * bucketCount);
+				if (bucket < 0 || bucket >= bucketCount) continue;
+				const value = Math.abs(channel[i]);
+				if (value > peaks[bucket]) peaks[bucket] = value;
+			}
+		}
+		return {
+			peaks,
+			durationMs: spanMs
+		};
+	} finally {
+		input.dispose();
+	}
+}
+//#endregion
+//#region src/audio-sync.ts
+/**
+* Normalized cross-correlation of two zero-meaned envelopes. Returns the lag
+* (in buckets) that best aligns `b` to `a`: positive lag means b's content
+* happens LATER in its own file, i.e. b started recording earlier.
+* Pure — unit-testable without decoding.
+*/
+function crossCorrelateEnvelopes(a, b, maxLagBuckets) {
+	const center = (env) => {
+		let mean = 0;
+		for (const v of env) mean += v;
+		mean /= env.length || 1;
+		const out = new Float32Array(env.length);
+		for (let i = 0; i < env.length; i++) out[i] = env[i] - mean;
+		return out;
+	};
+	const ca = center(a);
+	const cb = center(b);
+	let bestLag = 0;
+	let best = -Infinity;
+	let secondBest = -Infinity;
+	for (let lag = -maxLagBuckets; lag <= maxLagBuckets; lag++) {
+		let dot = 0;
+		let na = 0;
+		let nb = 0;
+		for (let i = 0; i < ca.length; i++) {
+			const j = i + lag;
+			if (j < 0 || j >= cb.length) continue;
+			dot += ca[i] * cb[j];
+			na += ca[i] * ca[i];
+			nb += cb[j] * cb[j];
+		}
+		const score = na > 0 && nb > 0 ? dot / Math.sqrt(na * nb) : 0;
+		if (score > best) {
+			if (Math.abs(lag - bestLag) > 4) secondBest = best;
+			best = score;
+			bestLag = lag;
+		} else if (score > secondBest && Math.abs(lag - bestLag) > 4) secondBest = score;
+	}
+	const confidence = secondBest > 0 ? best / secondBest : best > 0 ? 99 : 0;
+	return {
+		lag: bestLag,
+		confidence
+	};
+}
+/** RMS envelope of the first `windowS` seconds at `rateHz` buckets/second. */
+async function extractEnvelope(src, { windowS = 60, rateHz = 100, signal } = {}) {
+	const input = inputFor(src);
+	try {
+		const track = await input.getPrimaryAudioTrack();
+		if (!track) return null;
+		const buckets = Math.ceil(windowS * rateHz);
+		const sums = new Float64Array(buckets);
+		const counts = new Float64Array(buckets);
+		const sink = new AudioBufferSink(track);
+		for await (const { buffer, timestamp } of sink.buffers(0, windowS)) {
+			signal?.throwIfAborted();
+			const data = buffer.getChannelData(0);
+			const sampleRate = buffer.sampleRate;
+			for (let i = 0; i < data.length; i += 4) {
+				const t = timestamp + i / sampleRate;
+				const bucket = Math.floor(t * rateHz);
+				if (bucket < 0 || bucket >= buckets) continue;
+				sums[bucket] += data[i] * data[i];
+				counts[bucket] += 1;
+			}
+		}
+		const envelope = new Float32Array(buckets);
+		for (let i = 0; i < buckets; i++) envelope[i] = counts[i] > 0 ? Math.sqrt(sums[i] / counts[i]) : 0;
+		return envelope;
+	} finally {
+		input.dispose();
+	}
+}
+/**
+* The sync offset between two recordings: how many ms after A's recording
+* started did B's start. Null when either source has no audio.
+*/
+async function findSyncOffsetMs(a, b, options = {}) {
+	const rateHz = options.rateHz ?? 100;
+	const maxLagS = options.maxLagS ?? 30;
+	const [envA, envB] = await Promise.all([extractEnvelope(a, options), extractEnvelope(b, options)]);
+	if (!envA || !envB) return null;
+	const { lag, confidence } = crossCorrelateEnvelopes(envA, envB, Math.round(maxLagS * rateHz));
+	return {
+		offsetMs: Math.round(-lag * 1e3 / rateHz),
+		confidence
+	};
+}
+//#endregion
+export { AudioNotDecodableError, MAX_HASHABLE_BYTES, PreviewMediaPool, ScrubFrameCache, bucketPeaks, constantSpeedOf, createAssetFromFile, crossCorrelateEnvelopes, ensureFallbackAudioEncoders, exportProject, extractAudioPeaks, extractAudioToWav, extractEnvelope, findSyncOffsetMs, getActiveMediaItems, getContainerFormat, getExportSupport, getFilmstrip, getVideoThumbnail, getVideoThumbnailUrl, hashBlob, inputFor, isMediaStoreSupported, listContainerFormats, loadMediaBlob, probeImage, probeMedia, pruneMediaBlobs, registerContainerFormat, saveMediaBlob, stretchStereo };