framefields 2.12.0 → 2.13.1

package/dist/{dist-BSqeChht.mjs → dist-CCrYOkcc.mjs}

@@ -1,6 +1,6 @@
-import { Bt as getMediaType, It as getActiveMediaMetadata, Rn as updateClockSignals, Xt as isSignal, bn as resolveMediaMimeType, en as mediaSourceIsHold, p as DEFAULT_DURATION_MS, rn as mediaSourceTime, tn as mediaSourceRange } from "./dist-Bf2_efYP.mjs";
-import { f as webgpuRegistry, t as audioRegistry } from "./renderer-BOg8i8eF.mjs";
-import { A as emojiGraphemes, Bn as signalRegistry, C as drawGifNode, D as drawSignalNode, E as drawParagraphNode, I as getRegisteredFontSource, O as drawSvgNode, P as getHeadlessFontPath, S as drawCaptionNode, T as drawLottieNode, dt as resolveMediaSourceUrl, et as registerHeadlessFont, it as shaderStore, k as drawVideoNode, m as SlugGeometry, p as SlugFontCache, ut as GetFontAssetUrl, w as drawImageNode, z as inputStore } from "./dist-B-OPY7Cs.mjs";
+import { Bt as getMediaType, It as getActiveMediaMetadata, Rn as updateClockSignals, Xt as isSignal, bn as resolveMediaMimeType, en as mediaSourceIsHold, p as DEFAULT_DURATION_MS, rn as mediaSourceTime, tn as mediaSourceRange } from "./dist-C8XSqfTx.mjs";
+import { f as webgpuRegistry, t as audioRegistry } from "./renderer-BuvKGwk3.mjs";
+import { A as emojiGraphemes, C as drawGifNode, D as drawSignalNode, E as drawParagraphNode, Hn as signalRegistry, I as getRegisteredFontSource, O as drawSvgNode, P as getHeadlessFontPath, S as drawCaptionNode, T as drawLottieNode, ft as GetFontAssetUrl, g as WebGPUAudioProcessor, k as drawVideoNode, m as SlugGeometry, nt as resolveInputUrl, ot as shaderStore, p as SlugFontCache, pt as resolveMediaSourceUrl, tt as registerHeadlessFont, w as drawImageNode, z as inputStore } from "./dist-DtPPPsZV.mjs";
 import { AudioSampleSink } from "mediabunny";
 
 //#region ../renderers/dist/index.mjs
@@ -1082,42 +1082,54 @@ async function decodeAudioSource(url) {
 */
 const DECODE_PREROLL_SEC = .5;
 /**
+* A source this runtime can't decode at all (a codec WebCodecs lacks, in a
+* worker without AudioContext). Thrown, not mixed as silence, so the caller
+* can mix where it can be decoded.
+*/
+var AudioDecodeUnavailable = class extends Error {
+	name = "AudioDecodeUnavailable";
+};
+/**
+* The browser's whole-file decoder, for codecs WebCodecs can't decode
+* (mediabunny reads byte ranges and decodes with WebCodecs first).
+*/
+async function decodeWithAudioContext(url) {
+	const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+	if (!AudioContextClass) throw new AudioDecodeUnavailable(`No decoder here for ${url}: WebCodecs can't decode it and there is no AudioContext (a worker).`);
+	const audioCtx = new AudioContextClass();
+	try {
+		const response = await fetch(resolveInputUrl(url, false));
+		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,
+			startIndex: 0,
+			validFromSec: 0,
+			validToSec: Number.POSITIVE_INFINITY
+		};
+	} finally {
+		audioCtx.close();
+		mediaLogger.debug(`[AudioExtractor] AudioContext closed for ${url}`);
+	}
+}
+/**
 * Decodes [range.startSec, range.endSec) of a source (the whole file without
 * a range), so a short clip from a long file decodes only what it plays.
 */
 async function decodeAudioRange(url, range) {
 	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,
-					startIndex: 0,
-					validFromSec: 0,
-					validToSec: Number.POSITIVE_INFINITY
-				};
-			} finally {
-				audioCtx.close();
-				mediaLogger.debug(`[AudioExtractor] AudioContext closed for ${url}`);
-			}
-		}
+		const isBrowser = !(typeof process !== "undefined" && process.versions?.node);
 		let inputAcquired = false;
 		try {
-			mediaLogger.debug(`[AudioExtractor] Server / Node.js detected. Acquiring from inputStore for ${url}...`);
+			mediaLogger.debug(`[AudioExtractor] Acquiring from inputStore for ${url}...`);
 			const input = await inputStore.acquire(url);
 			inputAcquired = true;
 			mediaLogger.debug(`[AudioExtractor] inputStore acquired. Retrieving primary audio track...`);
@@ -1208,6 +1220,7 @@ async function decodeAudioRange(url, range) {
 			};
 		} catch (err) {
 			if (err instanceof Error && err.message.includes("Cannot open local media file")) throw err;
+			if (isBrowser) return decodeWithAudioContext(url);
 			if (typeof process !== "undefined" && process.versions?.node) try {
 				const { execFileSync } = await import("node:child_process");
 				const ffStartIndex = range ? Math.round(Math.max(0, range.startSec) * 48e3) : 0;
@@ -1253,7 +1266,7 @@ async function decodeAudioRange(url, range) {
 			if (inputAcquired) inputStore.release(url);
 		}
 	} catch (err) {
-		if (err instanceof Error && err.message.includes("Cannot open local media file")) throw err;
+		if (err instanceof AudioDecodeUnavailable || err instanceof Error && err.message.includes("Cannot open local media file")) throw err;
 		mediaLogger.error({ err }, `[AudioExtractor] Failed to decode source ${url}`);
 		return null;
 	}
@@ -1278,13 +1291,13 @@ async function resampleMappedPCM(input, sourceRate, outputRate, length, inputSta
 * `trimOffsetSamples` is a whole-file index; `inputStartIndex` is the
 * whole-file index of `inputChannel[0]` when it holds only a range.
 */
-async function resampleAndStretchPCM(inputChannel, sourceSampleRate, targetSampleRate, speed, outputLength, trimOffsetSamples, inputStartIndex = 0) {
+async function resampleAndStretchPCM(inputChannel, sourceSampleRate, targetSampleRate, speed, outputLength, trimOffsetSamples, inputStartIndex = 0, firstOutputSample = 0) {
 	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 - inputStartIndex;
+		const srcIndex = trimOffsetSamples + (firstOutputSample + i) * factor - inputStartIndex;
 		const indexFloor = Math.floor(srcIndex);
 		const indexCeil = Math.ceil(srcIndex);
 		if (indexFloor < 0) {
@@ -1304,6 +1317,19 @@ const RANGE_MARGIN_SEC = .05;
 /** Processors that only scale what is already there, so silence stays silence. */
 const GAIN_ONLY_PROCESSORS = new Set(["Compositor", "CompositorLayer"]);
 /** Adds `src` into `dest` starting at `destStart` (which may be negative). */
+/**
+* Which of a layer's gain props (`volume`, `muted`) it keys. Those the mix
+* leaves to the layer's audio processor, which reads them per sample; the
+* rest are applied as constants. Shared so both sides agree on the split.
+*/
+function keyedGain(operation) {
+	const tracks = operation?.animation?.tracks ?? [];
+	const keys = (prop) => tracks.some((t) => t.prop === prop && (t.keyframes?.length ?? 0) > 0);
+	return {
+		volume: keys("volume"),
+		muted: keys("muted")
+	};
+}
 function addInto(dest, src, destStart) {
 	const from = Math.max(0, -destStart);
 	const to = Math.min(src.length, dest.length - destStart);
@@ -1339,6 +1365,22 @@ var MixBus = class {
 		for (let c = 0; c < 2; c++) addInto(dest[c], src[c], start);
 	}
 };
+/**
+* The master stage, in place: `gain` (the automatic ceiling: a mix whose
+* summed tracks exceed -0.5 dB, 0.95, is scaled down smoothly), then soft
+* limiting and non-finite sanitation (transparent saturation instead of
+* harsh square-wave clipping).
+*/
+function applyMaster(channels, gain) {
+	for (const channel of channels) for (let i = 0; i < channel.length; i++) {
+		const v = (channel[i] ?? 0) * gain;
+		channel[i] = Number.isFinite(v) ? Math.tanh(v) : 0;
+	}
+}
+/** The master stage's gain for a mix whose loudest sample is `peak`. */
+function masterGain(peak) {
+	return peak > .95 ? .92 / peak : 1;
+}
 /** A clip's file name for progress, without paths or signed-URL queries. */
 function sourceLabel(url) {
 	if (url.startsWith("data:")) return "inline audio";
@@ -1359,10 +1401,19 @@ function decodeURIComponentSafe(s) {
 async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device, renderId, options = {}) {
 	mediaLogger.debug(`[AudioExtractor] mixAudioTracks started. FPS: ${fps}, targetSampleRate: ${targetSampleRate}`);
 	await waitForDelayRender();
+	if (device && !options.continue) WebGPUAudioProcessor.resetState(renderId ?? "global", device);
 	shaderStore.registerSignalsFromComposition(renderId, virtualMedia);
 	const durationMs = getActiveMediaMetadata(virtualMedia)?.durationMs || 1e3;
 	const totalDurationSec = durationMs / 1e3;
 	const totalTargetSamples = Math.ceil(totalDurationSec * targetSampleRate);
+	const winStart = options.window ? Math.max(0, Math.round(options.window.startSec * targetSampleRate)) : 0;
+	const winEnd = options.window ? Math.min(totalTargetSamples, Math.round(options.window.endSec * targetSampleRate)) : Number.POSITIVE_INFINITY;
+	const outputSamples = options.window ? Math.max(0, winEnd - winStart) : totalTargetSamples;
+	/** The part [lo, hi) of a node's local samples that the window covers. */
+	const visible = (absStart, length) => ({
+		lo: Math.max(0, winStart - absStart),
+		hi: Math.min(length, winEnd - absStart)
+	});
 	mediaLogger.debug(`[AudioExtractor] Composition total duration: ${durationMs}ms (${totalDurationSec}s). Total mixed samples to allocate: ${totalTargetSamples}`);
 	const decodedCache = /* @__PURE__ */ new Map();
 	const undecodable = /* @__PURE__ */ new Set();
@@ -1387,11 +1438,11 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 		ranges.push(decoded);
 		return decoded;
 	}
-	async function mappedChannels(url, length, map, startFrame) {
+	async function mappedChannels(url, length, map, startFrame, skip = 0) {
 		const left = new Float32Array(length), right = new Float32Array(length);
 		for (let offset = 0; offset < length;) {
 			let count = Math.min(length - offset, targetSampleRate * 2);
-			const first = startFrame + offset / targetSampleRate * fps;
+			const first = startFrame + (skip + offset) / targetSampleRate * fps;
 			let range = mediaSourceRange(map, first, first + (count - 1) / targetSampleRate * fps, fps);
 			while (range.max - range.min > 3 && count > 1) {
 				count = Math.max(1, Math.floor(count / 2));
@@ -1421,7 +1472,7 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 		audibleCache.set(node, audible);
 		return audible;
 	}
-	async function traverse(node, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, inheritedDurationFrames, inheritedRemap) {
+	async function traverse(node, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, inheritedDurationFrames, inheritedRemap, absStart = 0) {
 		if (!node || !isAudible(node)) return null;
 		const op = node.operation;
 		if (!op) {
@@ -1430,19 +1481,20 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 			const actualDurationFrames = inheritedRemap && inheritedDurationFrames !== null ? inheritedDurationFrames : 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 bus$1 = new MixBus(localSamplesCount$1);
+			const { lo: lo$1, hi: hi$1 } = visible(absStart, localSamplesCount$1);
+			if (hi$1 <= lo$1) return null;
+			const bus$1 = new MixBus(hi$1 - lo$1);
 			for (const child of node.children) {
-				const childChannels = await traverse(child, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, actualDurationFrames, inheritedRemap);
-				if (childChannels) {
-					const childOp = child.operation;
-					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
-					const childStartSample = Math.round(childStartFrame / fps * targetSampleRate);
-					bus$1.add(childChannels, childStartSample);
-				}
+				const childOp = child.operation;
+				const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
+				const childStartSample = Math.round(childStartFrame / fps * targetSampleRate);
+				const childChannels = await traverse(child, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, actualDurationFrames, inheritedRemap, absStart + childStartSample);
+				if (childChannels) bus$1.add(childChannels, Math.max(childStartSample, lo$1) - lo$1);
 			}
 			return bus$1.channels;
 		}
-		const volume = inheritedVolume * (op.volume ?? 1) * (op.opacity === 0 ? 0 : 1) * (op.muted ? 0 : 1);
+		const keyed = keyedGain(op);
+		const volume = inheritedVolume * (keyed.volume ? 1 : op.volume ?? 1) * (op.opacity === 0 ? 0 : 1) * (!keyed.muted && op.muted ? 0 : 1);
 		const speedMultiplier = inheritedSpeed;
 		const nodeStartFrame = op.startFrame ?? op.timeline?.startFrame ?? 0;
 		const ownRemap = op.timeRemap;
@@ -1462,7 +1514,9 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 		const nodeActualDurationFrames = inheritedRemap && !ownRemap && inheritedDurationFrames !== null ? inheritedDurationFrames : inheritedDurationFrames !== null ? nodeDurationFrames > 0 ? Math.min(inheritedDurationFrames, nodeDurationFrames) : inheritedDurationFrames : nodeDurationFrames;
 		const localSamplesCount = Math.ceil(nodeActualDurationFrames / fps * targetSampleRate);
 		if (localSamplesCount <= 0) return null;
-		const bus = new MixBus(localSamplesCount);
+		const { lo, hi } = visible(absStart, localSamplesCount);
+		if (hi <= lo) return null;
+		const bus = new MixBus(hi - lo);
 		const processSegment = async (seg, windowStartFrameOffset) => {
 			const segSeekSec = seg ? seg.startSec : 0;
 			const totalSeekSec = inheritedSeekSec + layerTrimSec + segSeekSec;
@@ -1480,28 +1534,32 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 					const effectiveTrimSec = Math.max(0, (Number(params.trimStartSec) || 0) + totalSeekSec);
 					const clipDurationSec = actualDurationFrames / fps;
 					const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
-					const mapped = remap && clipSamplesCount > 0 ? await mappedChannels(params.sourceUrl, clipSamplesCount, remap.map, remap.offsetFrames + windowStartFrameOffset) : null;
-					const decoded = !remap && clipSamplesCount > 0 && segmentStartSample < localSamplesCount ? await getDecodedRange(params.sourceUrl, effectiveTrimSec, effectiveTrimSec + clipSamplesCount / targetSampleRate * finalSpeed + RANGE_MARGIN_SEC) : null;
+					const clipFrom = Math.max(segmentStartSample, lo);
+					const count = Math.min(segmentStartSample + clipSamplesCount, hi) - clipFrom;
+					const skip = clipFrom - segmentStartSample;
+					const writeAt = clipFrom - lo;
+					const mapped = remap && count > 0 ? await mappedChannels(params.sourceUrl, count, remap.map, remap.offsetFrames + windowStartFrameOffset, skip) : null;
+					const decoded = !remap && count > 0 && segmentStartSample < localSamplesCount ? await getDecodedRange(params.sourceUrl, effectiveTrimSec + skip / targetSampleRate * finalSpeed, effectiveTrimSec + (skip + count) / targetSampleRate * finalSpeed + RANGE_MARGIN_SEC) : null;
 					if (mapped || decoded) {
 						let stretchedLeft;
 						let stretchedRight;
 						if (mapped) [stretchedLeft, stretchedRight] = mapped;
 						else if (decoded) {
 							const trimOffsetSamples = Math.round(effectiveTrimSec * decoded.sampleRate);
-							stretchedLeft = await resampleAndStretchPCM(decoded.channels[0], decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples, decoded.startIndex);
-							stretchedRight = decoded.channels.length > 1 ? await resampleAndStretchPCM(decoded.channels[1], decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples, decoded.startIndex) : stretchedLeft;
+							stretchedLeft = await resampleAndStretchPCM(decoded.channels[0], decoded.sampleRate, targetSampleRate, finalSpeed, count, trimOffsetSamples, decoded.startIndex, skip);
+							stretchedRight = decoded.channels.length > 1 ? await resampleAndStretchPCM(decoded.channels[1], decoded.sampleRate, targetSampleRate, finalSpeed, count, trimOffsetSamples, decoded.startIndex, skip) : stretchedLeft;
 						} else throw new Error("No decoded audio");
 						const stretched = [stretchedLeft, stretchedRight];
-						if (bus.canAdopt(stretched, segmentStartSample)) {
+						if (bus.canAdopt(stretched, writeAt)) {
 							if (volume !== 1) {
-								for (let i = 0; i < clipSamplesCount; i++) stretchedLeft[i] *= volume;
-								if (stretchedRight !== stretchedLeft) for (let i = 0; i < clipSamplesCount; i++) stretchedRight[i] *= volume;
+								for (let i = 0; i < count; i++) stretchedLeft[i] *= volume;
+								if (stretchedRight !== stretchedLeft) for (let i = 0; i < count; i++) stretchedRight[i] *= volume;
 							}
 							bus.channels = [stretchedLeft, stretchedRight === stretchedLeft ? stretchedLeft.slice() : stretchedRight];
 						} else {
 							const [localLeft, localRight] = bus.get();
-							for (let i = 0; i < clipSamplesCount; i++) {
-								const outIndex = segmentStartSample + i;
+							for (let i = 0; i < count; i++) {
+								const outIndex = writeAt + i;
 								localLeft[outIndex] += stretchedLeft[i] * volume;
 								localRight[outIndex] += stretchedRight[i] * volume;
 							}
@@ -1519,27 +1577,35 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 				}
 			}
 			if (node.children) for (const child of node.children) {
-				const childChannels = await traverse(child, totalSeekSec, totalClockFrames, volume, speedMultiplier, actualDurationFrames, remap);
-				if (childChannels) {
-					const childOp = child.operation;
-					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
-					const relativeStartFrame = op.op === "CompositorLayer" && childOp?.op === "CompositorLayer" ? childStartFrame - nodeStartFrame : childStartFrame;
-					const childStartSample = Math.round(relativeStartFrame / fps * targetSampleRate);
-					bus.add(childChannels, segmentStartSample + childStartSample);
-				}
+				const childOp = child.operation;
+				const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
+				const relativeStartFrame = op.op === "CompositorLayer" && childOp?.op === "CompositorLayer" ? childStartFrame - nodeStartFrame : childStartFrame;
+				const childStart = segmentStartSample + Math.round(relativeStartFrame / fps * targetSampleRate);
+				const childChannels = await traverse(child, totalSeekSec, totalClockFrames, volume, speedMultiplier, actualDurationFrames, remap, absStart + childStart);
+				if (childChannels) bus.add(childChannels, Math.max(childStart, lo) - lo);
 			}
 			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(bus.get().map((ch) => ch.subarray(segmentStartSample, segmentStartSample + clipSamplesCount)), targetSampleRate, node, {
-					device,
-					frame: totalClockFrames,
-					fps,
-					renderId,
-					elapsedMs: ((totalClockFrames - (op.op === "CompositorLayer" ? localClockFrames : 0)) / fps + totalSeekSec - layerTrimSec) * 1e3,
-					durationMs: getActiveMediaMetadata(node)?.durationMs ?? void 0
-				});
+				const from = Math.max(segmentStartSample, lo);
+				const to = Math.min(segmentStartSample + clipSamplesCount, hi);
+				const skip = from - segmentStartSample;
+				if (to > from && segmentStartSample < localSamplesCount && segmentStartSample >= 0) {
+					const slicedChannels = bus.get().map((ch) => ch.subarray(from - lo, to - lo));
+					const layerClockFrames = op.op === "CompositorLayer" ? localClockFrames : 0;
+					const skipSec = skip / targetSampleRate;
+					const elapsedMs = ((totalClockFrames - layerClockFrames) / fps + totalSeekSec - layerTrimSec + skipSec) * 1e3;
+					const durationMs$1 = getActiveMediaMetadata(node)?.durationMs ?? void 0;
+					await pluginProcessor(slicedChannels, targetSampleRate, node, {
+						device,
+						frame: totalClockFrames + skipSec * fps,
+						fps,
+						renderId,
+						elapsedMs,
+						durationMs: durationMs$1
+					});
+				}
 			} catch (pluginErr) {
 				mediaLogger.error({ err: pluginErr }, `[AudioExtractor] Custom plugin for operation '${op.op}' failed`);
 			}
@@ -1575,7 +1641,7 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 		});
 	}
 	const rootChannels = await traverse(normalized, 0, 0, 1, 1, null);
-	const mixedChannels = rootChannels?.every((ch) => ch.length === totalTargetSamples) && rootChannels[0] !== rootChannels[1] ? rootChannels : [new Float32Array(totalTargetSamples), new Float32Array(totalTargetSamples)];
+	const mixedChannels = rootChannels?.every((ch) => ch.length === outputSamples) && rootChannels[0] !== rootChannels[1] ? rootChannels : [new Float32Array(outputSamples), new Float32Array(outputSamples)];
 	const [outputLeft, outputRight] = mixedChannels;
 	if (rootChannels && mixedChannels !== rootChannels) for (let c = 0; c < 2; c++) {
 		const dest = mixedChannels[c];
@@ -1585,22 +1651,17 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 	}
 	decodedCache.clear();
 	let mixPeak = 0;
-	for (let i = 0; i < totalTargetSamples; i++) {
+	for (let i = 0; i < outputSamples; 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;
-	}
+	if (options.master !== false) applyMaster(mixedChannels, masterGain(mixPeak));
 	return {
 		channels: mixedChannels,
-		sampleRate: targetSampleRate
+		sampleRate: targetSampleRate,
+		peak: mixPeak
 	};
 }
 /** Resolve the source bound to a compositor layer, including effect wrappers. */
@@ -1647,5 +1708,5 @@ async function preflightMediaTime(root, fps) {
 }
 
 //#endregion
-export { requiresIsolation as _, preflightMediaTime as a, bezier as c, mapBlendModeToSkia as d, measureSpring as f, preloadFont as g, preloadCompositionFonts as h, mixAudioTracks as i, computeStrokeRect as l, measureTextAsync as m, decodeAudioSource as n, resolveLayerDuration as o, measureText as p, drawCompositionTree as r, Easing as s, compositionStateStore as t, interpolate as u, spring as v, springCalculation as y };
-//# sourceMappingURL=dist-BSqeChht.mjs.map
+export { preloadFont as _, mixAudioTracks as a, springCalculation as b, Easing as c, interpolate as d, mapBlendModeToSkia as f, preloadCompositionFonts as g, measureTextAsync as h, keyedGain as i, bezier as l, measureText as m, decodeAudioSource as n, preflightMediaTime as o, measureSpring as p, drawCompositionTree as r, resolveLayerDuration as s, compositionStateStore as t, computeStrokeRect as u, requiresIsolation as v, spring as y };
+//# sourceMappingURL=dist-CCrYOkcc.mjs.map