@framefields/compositions 0.0.0-stage → 2.0.2

package/dist/index.mjs

@@ -0,0 +1,898 @@
+import { a as framesToSeconds, c as getFontUrl, i as formatTimecode, n as isStaticVisualMedia, o as secondsToFrames, r as resolveLayerDuration, s as computeRenderParams, t as calculateLayerTransform } from "./layer-logic-DBs4NHoi.mjs";
+import { getActiveMediaMetadata, getMediaType, isSignal, updateClockSignals } from "@framefields/core";
+import { audioRegistry, webgpuRegistry } from "@framefields/node-sdk";
+import { drawCaptionNode, drawGifNode, drawImageNode, drawLottieNode, drawParagraphNode, drawSignalNode, drawSvgNode, drawVideoNode, inputStore, shaderStore, signalRegistry } from "@framefields/webgpu-renderers";
+import { AudioSampleSink } from "mediabunny";
+
+//#region src/compositions/canvas-composition.ts
+const segmentRangeCache = /* @__PURE__ */ new WeakMap();
+function getCachedSegmentRanges(segments, fps) {
+	const cached = segmentRangeCache.get(segments);
+	if (cached && cached.fps === fps) return cached.ranges;
+	let currentStart = 0;
+	const ranges = segments.map((seg) => {
+		const durSec = (seg.endSec ?? 0) - seg.startSec;
+		const durFrames = Math.max(1, Math.round(durSec * fps));
+		const start = currentStart;
+		currentStart += durFrames;
+		return {
+			seg,
+			start,
+			duration: durFrames
+		};
+	});
+	segmentRangeCache.set(segments, {
+		fps,
+		ranges
+	});
+	return ranges;
+}
+const frameCtxPool = [];
+function acquireFrameContext() {
+	return frameCtxPool.pop() ?? {};
+}
+/**
+* Effect operations carry every config field as a signal. Hand node renderers
+* the plain value for this frame (nested objects/arrays included), keeping only
+* GPU-bound signals intact since those are consumed as textures.
+*/
+function resolveSignalOperation(virtualMedia, frameCtx) {
+	const op = virtualMedia.operation;
+	const resolved = { ...op };
+	for (const [key, sig] of Object.entries(op.signals)) if (isSignal(sig) && !sig.gpuBinding) resolved[key] = sig.get(frameCtx);
+	return {
+		...virtualMedia,
+		operation: resolved
+	};
+}
+async function drawCompositionTree(ctx, encoder, targetView, targetTexture, targetWidth, targetHeight, virtualMedia, props, inheritedSeekOffset = 0, inheritedClockOffset = 0) {
+	const fps = props.fps ?? 24;
+	const op = virtualMedia.operation;
+	if (!op) return;
+	const isCompositor = op.op === "Compositor";
+	const frame = props.frame ?? 0;
+	const segments = op.timeline?.segments || [];
+	const localFrame = frame - (op.startFrame ?? op.timeline?.startFrame ?? 0);
+	const isTimelineProvider = op.timeline !== void 0 || op.startFrame !== void 0 || op.op === "compose";
+	const resolvedDurationMs = isTimelineProvider ? getActiveMediaMetadata(virtualMedia)?.durationMs ?? props.durationMs ?? void 0 : props.durationMs ?? getActiveMediaMetadata(virtualMedia)?.durationMs ?? void 0;
+	if (!(op.op === "source" || op.op === "text" || op.op === "caption")) updateClockSignals(frame, fps, resolvedDurationMs);
+	const frameCtx = acquireFrameContext();
+	frameCtx.frame = frame;
+	frameCtx.fps = fps;
+	frameCtx.time = fps > 0 ? frame / fps : 0;
+	frameCtx.duration = (resolvedDurationMs ?? 0) / 1e3;
+	frameCtx.durationMs = resolvedDurationMs ?? 0;
+	frameCtx.progress = resolvedDurationMs && resolvedDurationMs > 0 ? Math.max(0, Math.min(1, frame / fps * 1e3 / resolvedDurationMs)) : 0;
+	frameCtx.deltaTime = fps > 0 ? 1 / fps : 0;
+	const resolvedElapsedMs = isTimelineProvider ? (localFrame !== void 0 && fps !== void 0 ? localFrame / fps * 1e3 : void 0) ?? props.elapsedMs : props.elapsedMs ?? (localFrame !== void 0 && fps !== void 0 ? localFrame / fps * 1e3 : void 0);
+	const effectiveLocalFrame = localFrame + Math.round(inheritedSeekOffset * fps);
+	let activeSeg = null;
+	let windowStartFrame = 0;
+	if (segments.length > 0) {
+		const active = getCachedSegmentRanges(segments, fps).find(({ start, duration }) => effectiveLocalFrame >= start && effectiveLocalFrame < start + duration);
+		if (active) {
+			activeSeg = active.seg;
+			windowStartFrame = active.start;
+		} else return;
+	}
+	const segmentLocalFrame = localFrame - windowStartFrame;
+	const accumulatedSeekOffsetSec = inheritedSeekOffset + (activeSeg ? activeSeg.startSec - windowStartFrame / fps : 0);
+	const accumulatedClockOffsetSec = inheritedClockOffset + windowStartFrame / fps;
+	if (typeof op.onRequestFrame === "function") op.onRequestFrame(frameCtx);
+	else if (op.effect && typeof op.effect.notifyFrame === "function") op.effect.notifyFrame(frameCtx);
+	const CustomRenderer = webgpuRegistry.get(op.op);
+	if (CustomRenderer) {
+		if (op.signals) virtualMedia = resolveSignalOperation(virtualMedia, frameCtx);
+		const inputs = op?.inputs;
+		if (inputs) {
+			for (const entry of Object.values(inputs)) if (entry?.connectionValid && entry?.outputItem?.type === "LUT") {
+				const lutVirtualMedia = entry.outputItem.data;
+				if (lutVirtualMedia && typeof lutVirtualMedia === "object" && lutVirtualMedia.operation) {
+					const lutW = lutVirtualMedia.metadata?.width ?? targetWidth;
+					const lutH = lutVirtualMedia.metadata?.height ?? targetHeight;
+					const dummyTex = ctx.renderer.getTemporaryTexture(lutW, lutH);
+					await drawCompositionTree(ctx, encoder, dummyTex.createView(), dummyTex, lutW, lutH, lutVirtualMedia, {
+						...props,
+						virtualMedia: lutVirtualMedia
+					}, accumulatedSeekOffsetSec, accumulatedClockOffsetSec);
+				}
+			} else if (entry?.connectionValid && entry?.outputItem?.type === "Signal") {
+				const sigData = entry.outputItem.data;
+				if (sigData && typeof sigData === "object") await signalRegistry.ensureAudioSourcesExtracted(ctx.device, sigData.signalConfig ?? sigData, fps, props.renderId);
+			}
+		}
+		const pass = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "load");
+		let passEnded = false;
+		const originalEnd = pass.end.bind(pass);
+		pass.end = () => {
+			if (!passEnded) {
+				originalEnd();
+				passEnded = true;
+			}
+		};
+		const renderArgs = {
+			ctx,
+			encoder,
+			pass,
+			targetView,
+			targetTexture,
+			targetWidth,
+			targetHeight,
+			props: {
+				...props,
+				virtualMedia,
+				inheritedSeekOffset: accumulatedSeekOffsetSec,
+				inheritedClockOffset: accumulatedClockOffsetSec,
+				durationMs: resolvedDurationMs,
+				elapsedMs: resolvedElapsedMs
+			},
+			drawChild: async (child, overrides, targetViewOverride, targetTextureOverride, targetWidthOverride, targetHeightOverride) => {
+				await drawCompositionTree(ctx, encoder, targetViewOverride ?? targetView, targetTextureOverride ?? targetTexture, targetWidthOverride ?? targetWidth, targetHeightOverride ?? targetHeight, child, {
+					...props,
+					durationMs: resolvedDurationMs,
+					elapsedMs: resolvedElapsedMs,
+					virtualMedia: child,
+					...overrides,
+					excludeTextures: [
+						...props.excludeTextures || [],
+						...overrides?.excludeTextures || [],
+						targetTextureOverride ?? targetTexture
+					]
+				}, isCompositor ? 0 : accumulatedSeekOffsetSec, accumulatedClockOffsetSec);
+			}
+		};
+		await CustomRenderer(renderArgs);
+		renderArgs.pass.end();
+		return;
+	}
+	if (op.op === "LUT") return;
+	if (op.op === "Signal" || op.op === "SignalMath" || op.dataType === "Signal") {
+		const pass = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "load");
+		await drawSignalNode(ctx, encoder, pass, {
+			nodeId: op.nodeId || op.signalConfig?.nodeId || props.renderId,
+			func: op.func,
+			amplitude: Number(op.amplitude ?? 1),
+			frequency: Number(op.frequency ?? 1),
+			phase: Number(op.phase ?? 0),
+			offset: Number(op.offset ?? 0),
+			signalConfig: {
+				...op.signalConfig,
+				...op
+			},
+			frame,
+			fps,
+			elapsedMs: resolvedElapsedMs,
+			durationMs: resolvedDurationMs ?? 0,
+			width: targetWidth,
+			height: targetHeight,
+			drawChild: async (child, childProps, childView, childTex, childW, childH) => {
+				await drawCompositionTree(ctx, encoder, childView, childTex, childW, childH, child, {
+					...props,
+					durationMs: resolvedDurationMs,
+					elapsedMs: resolvedElapsedMs,
+					...childProps,
+					excludeTextures: [
+						...props.excludeTextures || [],
+						...childProps?.excludeTextures || [],
+						childTex
+					]
+				});
+			}
+		});
+		pass.end();
+		return;
+	}
+	if (op.op === "source" || op.op === "text" || op.op === "caption") {
+		const pass = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "load");
+		if (op.op === "source") {
+			const mediaType = getMediaType(virtualMedia);
+			const params = computeRenderParams(virtualMedia);
+			if (params.sourceUrl) {
+				const containerWidth = props.containerWidth ?? ctx.surface.width;
+				const containerHeight = props.containerHeight ?? ctx.surface.height;
+				if (mediaType === "Image") await drawImageNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "SVG") await drawSvgNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					opacity: Number(op.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "Lottie") await drawLottieNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					frame: segmentLocalFrame + Math.round(accumulatedSeekOffsetSec * fps),
+					fps,
+					opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "GIF") await drawGifNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					frame: segmentLocalFrame + Math.round(accumulatedSeekOffsetSec * fps),
+					fps,
+					opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "Text") {
+					const opText = { ...op };
+					drawParagraphNode(ctx, pass, {
+						text: opText.text || "",
+						dstRect: {
+							x: Number(opText.x ?? 0),
+							y: Number(opText.y ?? 0),
+							width: Number(opText.width ?? containerWidth),
+							height: Number(opText.height ?? containerHeight)
+						},
+						fontFamily: opText.fontFamily,
+						fontSize: Number(opText.fontSize ?? 48),
+						color: opText.fill ?? opText.color ?? "white",
+						width: opText.width ? Number(opText.width) : void 0,
+						height: opText.height ? Number(opText.height) : void 0,
+						lineHeight: Number(opText.lineHeight ?? 1.2),
+						align: opText.align,
+						verticalAlign: opText.verticalAlign,
+						fontWeight: opText.fontWeight,
+						fontStyle: opText.fontStyle,
+						letterSpacing: opText.letterSpacing,
+						shadows: opText.shadows,
+						textBackgroundColor: opText.textBackgroundColor,
+						borderRadius: opText.borderRadius != null ? Number(opText.borderRadius) : void 0,
+						padding: opText.padding != null ? Number(opText.padding) : void 0,
+						stroke: opText.stroke,
+						strokeWidth: opText.strokeWidth ?? opText.strokeThickness ? Number(opText.strokeWidth ?? opText.strokeThickness) : void 0,
+						strokeAlign: opText.strokeAlign,
+						opacity: Number(opText.opacity ?? 1) * Number(props.opacity ?? 1),
+						isHeadless: props.isHeadless,
+						animation: opText.animation ?? opText.textAnimation,
+						animators: opText.animators,
+						pathOptions: opText.pathOptions,
+						typewriter: opText.typewriter,
+						marquee: opText.marquee,
+						textProgress: opText.textProgress != null ? Number(opText.textProgress) : void 0,
+						signals: props.signals ?? opText.signals,
+						firstMargin: opText.firstMargin != null ? Number(opText.firstMargin) : void 0,
+						lastMargin: opText.lastMargin != null ? Number(opText.lastMargin) : void 0,
+						baselineShift: opText.baselineShift != null ? Number(opText.baselineShift) : void 0,
+						frame: localFrame,
+						fps,
+						durationMs: resolvedDurationMs,
+						elapsedMs: resolvedElapsedMs,
+						isVideoMode: props.isVideoMode
+					});
+				} else if (mediaType === "Video") {
+					const finalPlaybackRate = Math.max(.01, (Number(props.playbackRateOverride) || 1) * (Number(params.speed) || 1));
+					const effectiveTrimSec = Math.max(0, (Number(props.trimStartOverride) || 0) + (Number(params.trimStartSec) || 0) + accumulatedSeekOffsetSec);
+					const rawTimestampSec = segmentLocalFrame / fps * finalPlaybackRate + effectiveTrimSec;
+					const timestampSec = Math.max(0, Number.isFinite(rawTimestampSec) ? rawTimestampSec : 0);
+					await drawVideoNode(ctx, pass, {
+						nodeId: props.renderId,
+						frameKey: `${props.renderId ?? "video"}-${params.sourceUrl}-${Math.round(timestampSec * fps)}`,
+						sourceUrl: params.sourceUrl,
+						timestampSec,
+						dstRect: {
+							x: 0,
+							y: 0,
+							width: containerWidth,
+							height: containerHeight
+						},
+						opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+						isHeadless: props.isHeadless,
+						isPlaying: props.isPlaying,
+						forceWait: props.forceWait
+					});
+				} else if (mediaType === "Caption") {
+					const opCap = {
+						...op,
+						...props
+					};
+					await drawCaptionNode(ctx, pass, {
+						renderId: props.renderId,
+						src: params.sourceUrl,
+						dstRect: {
+							x: 0,
+							y: 0,
+							width: containerWidth,
+							height: containerHeight
+						},
+						frame: localFrame,
+						fps,
+						fontFamily: opCap.fontFamily,
+						fontSize: Number(opCap.fontSize ?? 48),
+						color: opCap.fill ?? opCap.color ?? "white",
+						lineHeight: Number(opCap.lineHeight ?? 1.2),
+						align: opCap.align === "start" ? "left" : opCap.align === "end" ? "right" : opCap.align ?? "center",
+						textAlignVertical: opCap.verticalAlign ?? opCap.textAlignVertical,
+						fontWeight: opCap.fontWeight,
+						fontStyle: opCap.fontStyle,
+						letterSpacing: opCap.letterSpacing,
+						shadows: opCap.shadows,
+						textBackgroundColor: opCap.background ?? opCap.textBackgroundColor,
+						borderRadius: (opCap.borderRadius ?? opCap.strokeRadius) != null ? Number(opCap.borderRadius ?? opCap.strokeRadius) : void 0,
+						strokeRadius: (opCap.strokeRadius ?? opCap.borderRadius) != null ? Number(opCap.strokeRadius ?? opCap.borderRadius) : void 0,
+						stroke: opCap.stroke,
+						strokeWidth: (opCap.strokeWidth ?? opCap.strokeThickness) != null ? Number(opCap.strokeWidth ?? opCap.strokeThickness) : void 0,
+						maxWidth: opCap.maxWidth,
+						padding: opCap.padding != null ? Number(opCap.padding) : void 0,
+						opacity: Number(opCap.opacity ?? 1) * Number(props.opacity ?? 1),
+						isHeadless: props.isHeadless,
+						isVideoMode: props.isVideoMode
+					});
+				}
+			}
+		} else if (op.op === "text") {
+			const opText = { ...op };
+			const containerWidth = props.containerWidth ?? ctx.surface.width;
+			const containerHeight = props.containerHeight ?? ctx.surface.height;
+			drawParagraphNode(ctx, pass, {
+				renderId: props.renderId,
+				text: opText.text || "",
+				dstRect: {
+					x: Number(opText.x ?? 0),
+					y: Number(opText.y ?? 0),
+					width: Number(opText.width ?? containerWidth),
+					height: Number(opText.height ?? containerHeight)
+				},
+				spans: opText.spans,
+				fontFamily: opText.fontFamily,
+				fontSize: Number(opText.fontSize ?? 48),
+				color: opText.fill ?? opText.color ?? "white",
+				width: opText.width ? Number(opText.width) : void 0,
+				height: opText.height ? Number(opText.height) : void 0,
+				lineHeight: Number(opText.lineHeight ?? 1.2),
+				align: opText.align,
+				verticalAlign: opText.verticalAlign,
+				fontWeight: opText.fontWeight,
+				fontStyle: opText.fontStyle,
+				letterSpacing: opText.letterSpacing,
+				shadows: opText.shadows,
+				textBackgroundColor: opText.textBackgroundColor,
+				borderRadius: (opText.borderRadius ?? opText.strokeRadius) != null ? Number(opText.borderRadius ?? opText.strokeRadius) : void 0,
+				strokeRadius: (opText.strokeRadius ?? opText.borderRadius) != null ? Number(opText.strokeRadius ?? opText.borderRadius) : void 0,
+				padding: opText.padding != null ? Number(opText.padding) : void 0,
+				stroke: opText.stroke,
+				strokeWidth: opText.strokeWidth ?? opText.strokeThickness ? Number(opText.strokeWidth ?? opText.strokeThickness) : void 0,
+				strokeAlign: opText.strokeAlign,
+				opacity: Number(opText.opacity ?? 1) * Number(props.opacity ?? 1),
+				isHeadless: props.isHeadless,
+				animation: opText.animation ?? opText.textAnimation,
+				animators: opText.animators,
+				pathOptions: opText.pathOptions,
+				typewriter: opText.typewriter,
+				marquee: opText.marquee,
+				signals: props.signals ?? opText.signals,
+				firstMargin: opText.firstMargin != null ? Number(opText.firstMargin) : void 0,
+				lastMargin: opText.lastMargin != null ? Number(opText.lastMargin) : void 0,
+				baselineShift: opText.baselineShift != null ? Number(opText.baselineShift) : void 0,
+				frame: localFrame,
+				fps,
+				durationMs: resolvedDurationMs,
+				elapsedMs: resolvedElapsedMs,
+				isVideoMode: props.isVideoMode
+			});
+		}
+		pass.end();
+	}
+	if (virtualMedia.children && virtualMedia.children.length > 0) for (let i = 0; i < virtualMedia.children.length; i++) {
+		const child = virtualMedia.children[i];
+		if (child) await drawCompositionTree(ctx, encoder, targetView, targetTexture, targetWidth, targetHeight, child, {
+			...props,
+			durationMs: resolvedDurationMs,
+			elapsedMs: resolvedElapsedMs,
+			virtualMedia: child,
+			renderId: `${props.renderId}-c${i}`
+		}, isCompositor ? 0 : accumulatedSeekOffsetSec, accumulatedClockOffsetSec);
+	}
+}
+
+//#endregion
+//#region src/compositions/composition-state.ts
+const DEFAULT_STATE = {
+	frame: 0,
+	fps: 30,
+	isPlaying: false
+};
+var CompositionStateStore = class {
+	states = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Map();
+	setState(key, frame, fps, isPlaying) {
+		const current = this.states.get(key);
+		const resolvedPlaying = isPlaying !== void 0 ? isPlaying : current?.isPlaying ?? false;
+		if (current?.frame === frame && current?.fps === fps && current?.isPlaying === resolvedPlaying) return;
+		this.states.set(key, {
+			frame,
+			fps,
+			isPlaying: resolvedPlaying
+		});
+		this.notify(key);
+	}
+	getState(key) {
+		if (this.states.has(key)) return this.states.get(key);
+		for (const [storeKey, value] of this.states.entries()) if (key.startsWith(storeKey)) return value;
+		return DEFAULT_STATE;
+	}
+	subscribe(key, listener) {
+		if (!this.listeners.has(key)) this.listeners.set(key, /* @__PURE__ */ new Set());
+		this.listeners.get(key).add(listener);
+		return () => {
+			const set = this.listeners.get(key);
+			set?.delete(listener);
+			if (set?.size === 0) {
+				this.listeners.delete(key);
+				this.states.delete(key);
+			}
+		};
+	}
+	clearKey(key) {
+		this.states.delete(key);
+	}
+	notify(key) {
+		for (const [listenerKey, set] of this.listeners.entries()) if (listenerKey === key || listenerKey.startsWith(key)) set.forEach((l) => l());
+	}
+};
+const compositionStateStore = new CompositionStateStore();
+
+//#endregion
+//#region src/utils/normalization.ts
+/**
+* normalizeTimeline recurses through the virtual media tree and "absorbs"
+* generic timeline-shifting operations into standard properties
+* of their children.
+*/
+function normalizeTimeline(vv, fps, context = { timeOffsetSec: 0 }) {
+	if (!vv) return vv;
+	const { operation, metadata = {}, children = [] } = vv;
+	const { timeOffsetSec, durationLimitMs } = context;
+	if (!operation) return {
+		...vv,
+		children: (children || []).map((child) => normalizeTimeline(child, fps, context))
+	};
+	const timeline = operation.timeline;
+	const segments = timeline?.segments || [];
+	let totalDurationMs = getActiveMediaMetadata(vv)?.durationMs ?? 0;
+	if (segments.length > 0) {
+		const totalSegmentsFrames = segments.reduce((acc, seg) => {
+			const durSec = seg.endSec != null ? seg.endSec - seg.startSec : 0;
+			return acc + Math.max(1, Math.round(durSec * fps));
+		}, 0);
+		if (totalSegmentsFrames > 0) totalDurationMs = totalSegmentsFrames / fps * 1e3;
+	}
+	const newOperation = { ...operation };
+	const rawStartFrame = timeline?.startFrame ?? newOperation.startFrame;
+	if (typeof rawStartFrame === "number") newOperation.startFrame = rawStartFrame - secondsToFrames(timeOffsetSec, fps);
+	const newMetadata = {
+		...metadata,
+		durationMs: totalDurationMs
+	};
+	const childContext = typeof rawStartFrame === "number" || newOperation.op === "compose" ? {
+		timeOffsetSec: 0,
+		durationLimitMs: void 0
+	} : {
+		timeOffsetSec,
+		durationLimitMs
+	};
+	return {
+		metadata: newMetadata,
+		operation: newOperation,
+		children: (children || []).map((child) => normalizeTimeline(child, fps, childContext))
+	};
+}
+
+//#endregion
+//#region src/utils/audio-extractor.ts
+const verbose = typeof process !== "undefined" && /^(debug|trace)$/i.test(process.env?.LOG_LEVEL ?? "");
+let mediaLogger = {
+	debug: (msg, ...args) => {
+		if (!verbose) return;
+		if (typeof msg === "object" && msg !== null) console.info("[AudioExtractor]", msg, ...args);
+		else console.info(`[AudioExtractor] ${msg}`, ...args);
+	},
+	warn: (msg, ...args) => {
+		if (typeof msg === "object" && msg !== null) console.warn("[AudioExtractor]", msg, ...args);
+		else console.warn(`[AudioExtractor] ${msg}`, ...args);
+	},
+	error: (msg, ...args) => {
+		if (typeof msg === "object" && msg !== null) console.error("[AudioExtractor]", msg, ...args);
+		else console.error(`[AudioExtractor] ${msg}`, ...args);
+	}
+};
+if (typeof window === "undefined" || typeof process !== "undefined" && process.versions?.node) import(
+	/* webpackIgnore: true */
+	/* @vite-ignore */
+	"@framefields/server-utils"
+).then((m) => {
+	if (m.mediaLogger) mediaLogger = m.mediaLogger;
+}).catch(() => {});
+const yieldToMain = () => {
+	if (typeof window === "undefined") return Promise.resolve();
+	const sched = globalThis.scheduler;
+	return typeof sched?.yield === "function" ? sched.yield() : new Promise((resolve) => setTimeout(resolve, 0));
+};
+const waitForDelayRender = async (timeoutMs = 3e4) => {
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	const start = Date.now();
+	return new Promise((resolve) => {
+		const check = () => {
+			const browserHandles = typeof window !== "undefined" && window.renderer_delayRenderHandles ? window.renderer_delayRenderHandles : [];
+			const globalDelays = typeof globalThis !== "undefined" ? globalThis.__GATEWAI_DELAYS__ : null;
+			const hasBrowserDelays = browserHandles.length > 0;
+			const hasGlobalDelays = globalDelays instanceof Set && globalDelays.size > 0;
+			if (!hasBrowserDelays && !hasGlobalDelays) {
+				resolve();
+				return;
+			}
+			if (Date.now() - start > timeoutMs) {
+				mediaLogger.warn(`[AudioExtractor] waitForDelayRender timed out waiting for handles: ${JSON.stringify({
+					browserHandles,
+					globalDelays: globalDelays ? Array.from(globalDelays) : []
+				})}`);
+				resolve();
+				return;
+			}
+			setTimeout(check, 50);
+		};
+		check();
+	});
+};
+/**
+* Decodes all audio samples from a given source URL into raw Float32 mono/stereo channel buffers.
+*/
+async function decodeAudioSource(url) {
+	mediaLogger.debug(`[AudioExtractor] decodeAudioSource started for url: ${url}`);
+	try {
+		if (typeof window !== "undefined" && typeof window.document !== "undefined" && !(typeof process !== "undefined" && process.versions && process.versions.node)) {
+			mediaLogger.debug(`[AudioExtractor] Browser detected. Fetching arrayBuffer for ${url}...`);
+			const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+			if (!AudioContextClass) throw new Error("AudioContext is not supported in this browser");
+			const audioCtx = new AudioContextClass();
+			try {
+				const response = await fetch(url);
+				mediaLogger.debug(`[AudioExtractor] Fetch response status for ${url}: ${response.status} (${response.statusText})`);
+				if (!response.ok) throw new Error(`Failed to fetch audio source: ${response.statusText}`);
+				const arrayBuffer = await response.arrayBuffer();
+				mediaLogger.debug(`[AudioExtractor] Fetched ${arrayBuffer.byteLength} bytes. Decoding audio data...`);
+				const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);
+				mediaLogger.debug(`[AudioExtractor] Decoded successfully: ${audioBuffer.numberOfChannels} channels, sampleRate: ${audioBuffer.sampleRate}, duration: ${audioBuffer.duration}s`);
+				const channels = [];
+				for (let c = 0; c < audioBuffer.numberOfChannels; c++) channels.push(new Float32Array(audioBuffer.getChannelData(c)));
+				return {
+					channels,
+					sampleRate: audioBuffer.sampleRate
+				};
+			} finally {
+				audioCtx.close();
+				mediaLogger.debug(`[AudioExtractor] AudioContext closed for ${url}`);
+			}
+		}
+		let inputAcquired = false;
+		try {
+			mediaLogger.debug(`[AudioExtractor] Server / Node.js detected. Acquiring from inputStore for ${url}...`);
+			const input = await inputStore.acquire(url);
+			inputAcquired = true;
+			mediaLogger.debug(`[AudioExtractor] inputStore acquired. Retrieving primary audio track...`);
+			const track = await input.getPrimaryAudioTrack();
+			if (!track) {
+				mediaLogger.warn(`[AudioExtractor] No primary audio track found in input for ${url}`);
+				return null;
+			}
+			const generator = new AudioSampleSink(track).samples(0);
+			const decodedPlanes = [];
+			let totalFrames = 0;
+			let sampleRate = 48e3;
+			let numChannels = 1;
+			mediaLogger.debug(`[AudioExtractor] Starting mediabunny generator loop for ${url}...`);
+			for await (const sample of generator) {
+				sampleRate = sample.sampleRate;
+				numChannels = sample.numberOfChannels;
+				const sampleFrames = sample.numberOfFrames;
+				if (decodedPlanes.length === 0) for (let c = 0; c < numChannels; c++) decodedPlanes.push([]);
+				for (let c = 0; c < numChannels; c++) {
+					let planeBuffer;
+					try {
+						const allocSize = sample.allocationSize({
+							planeIndex: c,
+							format: "f32-planar"
+						});
+						planeBuffer = new Float32Array(allocSize / 4);
+						sample.copyTo(planeBuffer, {
+							planeIndex: c,
+							format: "f32-planar"
+						});
+					} catch {
+						const allocSize = sample.allocationSize({ planeIndex: c });
+						if (sample.format === "s16" || sample.format === "s16-planar") {
+							const int16Buffer = new Int16Array(allocSize / 2);
+							sample.copyTo(int16Buffer, { planeIndex: c });
+							planeBuffer = new Float32Array(int16Buffer.length);
+							for (let i = 0; i < int16Buffer.length; i++) planeBuffer[i] = (int16Buffer[i] ?? 0) / 32768;
+						} else if (sample.format === "s32" || sample.format === "s32-planar") {
+							const int32Buffer = new Int32Array(allocSize / 4);
+							sample.copyTo(int32Buffer, { planeIndex: c });
+							planeBuffer = new Float32Array(int32Buffer.length);
+							for (let i = 0; i < int32Buffer.length; i++) planeBuffer[i] = (int32Buffer[i] ?? 0) / 2147483648;
+						} else if (sample.format === "u8" || sample.format === "u8-planar") {
+							const u8Buffer = new Uint8Array(allocSize);
+							sample.copyTo(u8Buffer, { planeIndex: c });
+							planeBuffer = new Float32Array(u8Buffer.length);
+							for (let i = 0; i < u8Buffer.length; i++) planeBuffer[i] = ((u8Buffer[i] ?? 128) - 128) / 128;
+						} else {
+							planeBuffer = new Float32Array(allocSize / 4);
+							sample.copyTo(planeBuffer, { planeIndex: c });
+						}
+					}
+					decodedPlanes[c].push(planeBuffer);
+				}
+				totalFrames += sampleFrames;
+				sample.close();
+			}
+			mediaLogger.debug(`[AudioExtractor] Generator loop finished. Decoded total frames: ${totalFrames}`);
+			if (totalFrames === 0 || decodedPlanes.length === 0) return null;
+			return {
+				channels: decodedPlanes.map((planes) => {
+					const merged = new Float32Array(totalFrames);
+					let offset = 0;
+					for (const plane of planes) {
+						merged.set(plane, offset);
+						offset += plane.length;
+					}
+					return merged;
+				}),
+				sampleRate
+			};
+		} catch (err) {
+			if (typeof process !== "undefined" && process.versions?.node) try {
+				const { execSync } = await import("node:child_process");
+				const stdout = execSync(`ffmpeg -v error -i "${url}" -f f32le -ar 48000 -ac 2 pipe:1`, { maxBuffer: 100 * 1024 * 1024 });
+				const totalSamples = stdout.byteLength / 4;
+				const numFrames = totalSamples / 2;
+				const interleaved = new Float32Array(stdout.buffer, stdout.byteOffset, totalSamples);
+				const left = new Float32Array(numFrames);
+				const right = new Float32Array(numFrames);
+				for (let i = 0; i < numFrames; i++) {
+					left[i] = interleaved[i * 2];
+					right[i] = interleaved[i * 2 + 1];
+				}
+				return {
+					channels: [left, right],
+					sampleRate: 48e3
+				};
+			} catch (ffmpegErr) {
+				mediaLogger.warn({ ffmpegErr }, `[AudioExtractor] ffmpeg fallback decode failed for ${url}`);
+			}
+			mediaLogger.error({ err }, `[AudioExtractor] Failed to decode source ${url}`);
+			return null;
+		} finally {
+			if (inputAcquired) inputStore.release(url);
+		}
+	} catch (err) {
+		mediaLogger.error({ err }, `[AudioExtractor] Failed to decode source ${url}`);
+		return null;
+	}
+}
+/**
+* Resamples a PCM buffer using linear interpolation to target sample rate & speed.
+*/
+async function resampleAndStretchPCM(inputChannel, sourceSampleRate, targetSampleRate, speed, outputLength, trimOffsetSamples) {
+	const output = new Float32Array(outputLength);
+	const factor = sourceSampleRate / targetSampleRate * speed;
+	const YIELD_INTERVAL = 1e5;
+	for (let i = 0; i < outputLength; i++) {
+		if (i > 0 && i % YIELD_INTERVAL === 0) await yieldToMain();
+		const srcIndex = trimOffsetSamples + i * factor;
+		const indexFloor = Math.floor(srcIndex);
+		const indexCeil = Math.ceil(srcIndex);
+		if (indexFloor < 0) {
+			output[i] = 0;
+			continue;
+		}
+		if (indexFloor >= inputChannel.length) break;
+		const weight = srcIndex - indexFloor;
+		const sampleFloor = inputChannel[indexFloor] ?? 0;
+		const val = sampleFloor + weight * ((indexCeil >= 0 && indexCeil < inputChannel.length ? inputChannel[indexCeil] ?? sampleFloor : sampleFloor) - sampleFloor);
+		output[i] = Number.isFinite(val) ? val : 0;
+	}
+	return output;
+}
+/**
+* Recursively parses the VirtualMediaData tree and mixes all active audio tracks
+* into a single unified stereo PCM stream (Float32Array channels).
+*/
+async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device, renderId) {
+	mediaLogger.debug(`[AudioExtractor] mixAudioTracks started. FPS: ${fps}, targetSampleRate: ${targetSampleRate}`);
+	await waitForDelayRender();
+	shaderStore.registerSignalsFromComposition(renderId, virtualMedia);
+	const durationMs = getActiveMediaMetadata(virtualMedia)?.durationMs || 1e3;
+	const totalDurationSec = durationMs / 1e3;
+	const totalTargetSamples = Math.ceil(totalDurationSec * targetSampleRate);
+	mediaLogger.debug(`[AudioExtractor] Composition total duration: ${durationMs}ms (${totalDurationSec}s). Total mixed samples to allocate: ${totalTargetSamples}`);
+	const outputLeft = new Float32Array(totalTargetSamples);
+	const outputRight = new Float32Array(totalTargetSamples);
+	const mixedChannels = [outputLeft, outputRight];
+	const decodedCache = /* @__PURE__ */ new Map();
+	async function traverse(node, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, inheritedDurationFrames) {
+		if (!node) return null;
+		const op = node.operation;
+		if (!op) {
+			const durationMs$1 = getActiveMediaMetadata(node)?.durationMs ?? 0;
+			const durationFrames = Math.round(durationMs$1 / 1e3 * fps);
+			const actualDurationFrames = inheritedDurationFrames !== null ? durationFrames > 0 ? Math.min(inheritedDurationFrames, durationFrames) : inheritedDurationFrames : durationFrames;
+			const localSamplesCount$1 = Math.ceil(actualDurationFrames / fps * targetSampleRate);
+			if (localSamplesCount$1 <= 0) return null;
+			const localChannels$1 = [new Float32Array(localSamplesCount$1), new Float32Array(localSamplesCount$1)];
+			for (const child of node.children) {
+				const childChannels = await traverse(child, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, actualDurationFrames);
+				if (childChannels) {
+					const childOp = child.operation;
+					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
+					const childStartSample = Math.round(childStartFrame / fps * targetSampleRate);
+					for (let c = 0; c < 2; c++) {
+						const dest = localChannels$1[c];
+						const src = childChannels[c];
+						const len = Math.min(src.length, dest.length - childStartSample);
+						for (let i = 0; i < len; i++) if (childStartSample + i >= 0) dest[childStartSample + i] += src[i];
+					}
+				}
+			}
+			return localChannels$1;
+		}
+		const volume = inheritedVolume * (op.volume ?? 1) * (op.opacity === 0 ? 0 : 1) * (op.muted ? 0 : 1);
+		const speedMultiplier = inheritedSpeed;
+		const localClockFrames = inheritedClockFrames + (op.startFrame ?? op.timeline?.startFrame ?? 0);
+		const segments = op.timeline?.segments || [];
+		const nodeDurationMs = getActiveMediaMetadata(node)?.durationMs ?? 0;
+		const nodeDurationFrames = Math.round(nodeDurationMs / 1e3 * fps);
+		const nodeActualDurationFrames = inheritedDurationFrames !== null ? nodeDurationFrames > 0 ? Math.min(inheritedDurationFrames, nodeDurationFrames) : inheritedDurationFrames : nodeDurationFrames;
+		const localSamplesCount = Math.ceil(nodeActualDurationFrames / fps * targetSampleRate);
+		if (localSamplesCount <= 0) return null;
+		const localLeft = new Float32Array(localSamplesCount);
+		const localRight = new Float32Array(localSamplesCount);
+		const localChannels = [localLeft, localRight];
+		const processSegment = async (seg, windowStartFrameOffset) => {
+			const totalSeekSec = inheritedSeekSec + (seg ? seg.startSec : 0);
+			const totalClockFrames = localClockFrames + windowStartFrameOffset;
+			let segDurationFrames = 0;
+			if (seg) segDurationFrames = Math.max(1, Math.round(((seg.endSec ?? 0) - seg.startSec) * fps));
+			else segDurationFrames = nodeDurationFrames;
+			const actualDurationFrames = inheritedDurationFrames !== null ? Math.min(inheritedDurationFrames, segDurationFrames) : segDurationFrames;
+			const segmentStartSample = Math.round(windowStartFrameOffset / fps * targetSampleRate);
+			if (op.op === "source") {
+				const mediaType = getMediaType(node);
+				const params = computeRenderParams(node);
+				if (params.sourceUrl && (mediaType === "Audio" || mediaType === "Video") && volume > 0) {
+					const finalSpeed = Math.max(.5, speedMultiplier * (Number(params.speed) || 1));
+					const effectiveTrimSec = Math.max(0, (Number(params.trimStartSec) || 0) + totalSeekSec);
+					let decoded = decodedCache.get(params.sourceUrl);
+					if (decoded === void 0) {
+						decoded = await decodeAudioSource(params.sourceUrl);
+						decodedCache.set(params.sourceUrl, decoded);
+					}
+					if (decoded) {
+						const clipDurationSec = actualDurationFrames / fps;
+						const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
+						if (clipSamplesCount > 0 && segmentStartSample < localSamplesCount) {
+							const trimOffsetSamples = Math.round(effectiveTrimSec * decoded.sampleRate);
+							const srcLeft = decoded.channels[0];
+							const srcRight = decoded.channels.length > 1 ? decoded.channels[1] : decoded.channels[0];
+							const stretchedLeft = await resampleAndStretchPCM(srcLeft, decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples);
+							const stretchedRight = await resampleAndStretchPCM(srcRight, decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples);
+							for (let i = 0; i < clipSamplesCount; i++) {
+								const outIndex = segmentStartSample + i;
+								localLeft[outIndex] += stretchedLeft[i] * volume;
+								localRight[outIndex] += stretchedRight[i] * volume;
+							}
+						}
+					}
+					await yieldToMain();
+				}
+			}
+			if (node.children) for (const child of node.children) {
+				const childChannels = await traverse(child, totalSeekSec, totalClockFrames, volume, speedMultiplier, actualDurationFrames);
+				if (childChannels) {
+					const childOp = child.operation;
+					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
+					const destStartSample = segmentStartSample + Math.round(childStartFrame / fps * targetSampleRate);
+					for (let c = 0; c < 2; c++) {
+						const dest = localChannels[c];
+						const src = childChannels[c];
+						const len = Math.min(src.length, dest.length - destStartSample);
+						for (let i = 0; i < len; i++) if (destStartSample + i >= 0) dest[destStartSample + i] += src[i];
+					}
+				}
+			}
+			const pluginProcessor = audioRegistry.get(op.op);
+			if (pluginProcessor) try {
+				const clipDurationSec = actualDurationFrames / fps;
+				const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
+				if (clipSamplesCount > 0 && segmentStartSample < localSamplesCount && segmentStartSample >= 0) await pluginProcessor(localChannels.map((ch) => ch.subarray(segmentStartSample, segmentStartSample + clipSamplesCount)), targetSampleRate, node, {
+					device,
+					frame: totalClockFrames,
+					fps,
+					renderId,
+					elapsedMs: (totalClockFrames / fps + totalSeekSec) * 1e3,
+					durationMs: getActiveMediaMetadata(node)?.durationMs ?? void 0
+				});
+			} catch (pluginErr) {
+				mediaLogger.error({ err: pluginErr }, `[AudioExtractor] Custom plugin for operation '${op.op}' failed`);
+			}
+		};
+		if (segments.length > 0) {
+			let currentStart = 0;
+			for (const seg of segments) {
+				const durSec = (seg.endSec ?? 0) - seg.startSec;
+				const durFrames = Math.max(1, Math.round(durSec * fps));
+				await processSegment(seg, currentStart);
+				currentStart += durFrames;
+			}
+		} else await processSegment(null, 0);
+		return localChannels;
+	}
+	const rootChannels = await traverse(normalizeTimeline(virtualMedia, fps), 0, 0, 1, 1, null);
+	if (rootChannels) for (let c = 0; c < 2; c++) {
+		const dest = mixedChannels[c];
+		const src = rootChannels[c];
+		const len = Math.min(src.length, dest.length);
+		for (let i = 0; i < len; i++) dest[i] = src[i];
+	}
+	decodedCache.clear();
+	let mixPeak = 0;
+	for (let i = 0; i < totalTargetSamples; i++) {
+		const l = Math.abs(outputLeft[i] ?? 0);
+		const r = Math.abs(outputRight[i] ?? 0);
+		if (l > mixPeak) mixPeak = l;
+		if (r > mixPeak) mixPeak = r;
+	}
+	const autoGain = mixPeak > .95 ? .92 / mixPeak : 1;
+	for (let i = 0; i < totalTargetSamples; i++) {
+		const l = (outputLeft[i] ?? 0) * autoGain;
+		const r = (outputRight[i] ?? 0) * autoGain;
+		outputLeft[i] = Number.isFinite(l) ? Math.tanh(l) : 0;
+		outputRight[i] = Number.isFinite(r) ? Math.tanh(r) : 0;
+	}
+	return {
+		channels: mixedChannels,
+		sampleRate: targetSampleRate
+	};
+}
+
+//#endregion
+export { calculateLayerTransform, compositionStateStore, computeRenderParams, decodeAudioSource, drawCompositionTree, formatTimecode, framesToSeconds, getFontUrl, isStaticVisualMedia, mixAudioTracks, normalizeTimeline, resolveLayerDuration, secondsToFrames };
+//# sourceMappingURL=index.mjs.map