framefields 2.6.2 → 2.7.0

package/dist/{dist-CL5JOMSp.mjs → dist-BRXsfWKQ.mjs}

@@ -10,6 +10,7 @@ var ProgrammaticSignal = class ProgrammaticSignal$1 {
 	_fps;
 	_durationFrames;
 	_cachedFrame = -1;
+	_cachedContext;
 	_cachedValue = 0;
 	_seekedFrame = -1;
 	_subscribers = /* @__PURE__ */ new Set();
@@ -49,20 +50,25 @@ var ProgrammaticSignal = class ProgrammaticSignal$1 {
 		registerSignalDependency(this._subscribers);
 		frameSignal.get();
 		const currentFrame = ctx?.frame ?? (this._seekedFrame >= 0 ? this._seekedFrame : frameSignal.value);
-		if (this._cachedFrame === currentFrame) return this._cachedValue;
 		const fps$1 = ctx?.fps ?? this._fps;
 		const time = ctx?.time ?? (fps$1 > 0 ? currentFrame / fps$1 : 0);
 		const duration = ctx?.duration ?? this._durationFrames ?? 100;
+		const durationMs = ctx?.durationMs ?? duration / fps$1 * 1e3;
+		const progress = ctx?.progress ?? (duration > 0 ? currentFrame / duration : 0);
+		const deltaTime = ctx?.deltaTime ?? (fps$1 > 0 ? 1 / fps$1 : .0416);
 		const resolvedCtx = {
 			frame: currentFrame,
 			fps: fps$1,
 			time,
 			duration,
-			durationMs: ctx?.durationMs ?? duration / fps$1 * 1e3,
-			progress: duration > 0 ? currentFrame / duration : 0,
-			deltaTime: ctx?.deltaTime ?? (fps$1 > 0 ? 1 / fps$1 : .0416)
+			durationMs,
+			progress,
+			deltaTime
 		};
+		const cached = this._cachedContext;
+		if (this._cachedFrame === currentFrame && cached && cached.fps === fps$1 && cached.time === time && cached.duration === duration && cached.durationMs === durationMs && cached.progress === progress && cached.deltaTime === deltaTime) return this._cachedValue;
 		this._cachedFrame = currentFrame;
+		this._cachedContext = resolvedCtx;
 		this._cachedValue = this._evaluator(resolvedCtx);
 		return this._cachedValue;
 	}
@@ -437,6 +443,7 @@ var FrameArraySignalImpl = class {
 	fps;
 	_samples;
 	_cachedFrame = -1;
+	_cachedFps = 0;
 	_cachedValue = 0;
 	_seekedFrame = -1;
 	_subscribers = /* @__PURE__ */ new Set();
@@ -456,13 +463,14 @@ var FrameArraySignalImpl = class {
 		}
 		frameSignal.get();
 		const currentFrame = ctx?.frame ?? (this._seekedFrame >= 0 ? this._seekedFrame : frameSignal.value);
-		if (this._cachedFrame === currentFrame) return this._cachedValue;
+		const compFps = ctx?.fps ?? this.fps;
+		if (this._cachedFrame === currentFrame && this._cachedFps === compFps) return this._cachedValue;
 		this._cachedFrame = currentFrame;
+		this._cachedFps = compFps;
 		if (!this._samples || this._samples.length === 0) {
 			this._cachedValue = 0;
 			return 0;
 		}
-		const compFps = ctx?.fps ?? this.fps;
 		const targetFrame = compFps !== this.fps && compFps > 0 ? currentFrame / compFps * this.fps : currentFrame;
 		const idx = Math.max(0, Math.min(this._samples.length - 1, Math.round(targetFrame)));
 		this._cachedValue = Number(this._samples[idx]) || 0;
@@ -474,6 +482,7 @@ var FrameArraySignalImpl = class {
 	seekFrame(frame$1) {
 		this._seekedFrame = frame$1;
 		this._cachedFrame = frame$1;
+		this._cachedFps = this.fps;
 		if (!this._samples || this._samples.length === 0) this._cachedValue = 0;
 		else {
 			const idx = Math.max(0, Math.min(this._samples.length - 1, Math.round(frame$1)));
@@ -733,6 +742,413 @@ var ModerationUnrefundableError = class extends Error {
 const generateId = (size) => {
 	return nanoid(size);
 };
+/**
+* Sample a signal at every composition-frame boundary in layer order.
+* Values between boundaries are linearly interpolated; speeds are integrated
+* analytically, so picture and audio can query the same fractional frame.
+*/
+function sampleMediaSignal(options) {
+	const recorder = new MediaSignalRecorder(options);
+	for (let i = 0; i <= options.durationFrames; i++) {
+		const frame$1 = options.startFrame + i;
+		recorder.record(frame$1, options.sample(frame$1));
+	}
+	return recorder.finish();
+}
+/** Sample an engine signal with its composition clock and full frame context. */
+function sampleFrameMediaSignal(options) {
+	const { fps: fps$1, compositionDurationFrames, signal: signal$1 } = options;
+	if (!Number.isInteger(compositionDurationFrames) || compositionDurationFrames <= 0) throw new Error("Invalid composition duration");
+	return sampleMediaSignal({
+		...options,
+		sample: (frame$1) => signal$1.get(compositionFrameContext(frame$1, fps$1, compositionDurationFrames))
+	});
+}
+/** The frame context a composition-clock signal sees at a composition frame. */
+function compositionFrameContext(frame$1, fps$1, compositionDurationFrames) {
+	return {
+		frame: frame$1,
+		fps: fps$1,
+		time: frame$1 / fps$1,
+		duration: compositionDurationFrames / fps$1,
+		durationMs: compositionDurationFrames / fps$1 * 1e3,
+		progress: Math.min(1, frame$1 / compositionDurationFrames),
+		deltaTime: 1 / fps$1
+	};
+}
+/** Evaluate at any fractional local frame, independent of query order. */
+function sampledMediaSourceTime(map, frame$1) {
+	if (!Number.isFinite(frame$1)) throw new Error("Invalid media signal frame");
+	const max = map.values.length - 1;
+	const f = Math.max(0, Math.min(max, frame$1));
+	const i = Math.min(Math.floor(f), max - 1);
+	const t = f - i;
+	const a = map.values[i];
+	const b = map.values[i + 1];
+	if (map.mode === "source-time") return a * (1 - t) + b * t;
+	return map.positions[i] + (a * (t - t * t / 2) + b * (t * t / 2)) / map.fps;
+}
+/** Range includes direction changes inside a speed-signal interval. */
+function sampledMediaSourceRange(map, from, to) {
+	if (!Number.isFinite(from) || !Number.isFinite(to)) throw new Error("Invalid media signal range");
+	const endFrame = map.values.length - 1;
+	const start = Math.max(0, Math.min(endFrame, Math.min(from, to)));
+	const end = Math.max(0, Math.min(endFrame, Math.max(from, to)));
+	let min = sampledMediaSourceTime(map, start);
+	let max = min;
+	let maxIncluded = start < end;
+	const add = (frame$1) => {
+		const value = sampledMediaSourceTime(map, frame$1);
+		min = Math.min(min, value);
+		if (value > max) {
+			max = value;
+			maxIncluded = frame$1 < end;
+		} else if (value === max && frame$1 < end) maxIncluded = true;
+	};
+	add(end);
+	for (let i = Math.floor(start); i < end; i++) {
+		if (i > start) add(i);
+		if (map.mode === "speed") {
+			const a = map.values[i], b = map.values[i + 1];
+			if (a < 0 && b > 0 || a > 0 && b < 0) {
+				const halfA = Math.abs(a) / 2;
+				const turn = i + halfA / (halfA + Math.abs(b) / 2);
+				if (turn > start && turn < end) add(turn);
+			}
+		}
+	}
+	return {
+		min,
+		max,
+		maxIncluded
+	};
+}
+/**
+* Records a live signal at each composition-frame boundary, so its history can
+* be replayed for audio, seeks and vision without evaluating it a second time.
+* With a sampler, boundaries are evaluated on demand, but never past the
+* frame the composition has reached ({@link advance}): no look-ahead.
+*/
+var MediaSignalRecorder = class {
+	values;
+	positions;
+	recorded = 0;
+	evaluating = false;
+	horizon = -1;
+	sampler;
+	check;
+	startFrame;
+	durationFrames;
+	fps;
+	mode;
+	constructor(options) {
+		if (!Number.isFinite(options.fps) || options.fps <= 0 || !Number.isInteger(options.startFrame) || options.startFrame < 0 || !Number.isInteger(options.durationFrames) || options.durationFrames <= 0) throw new Error("Invalid media signal timing");
+		const start = options.sourceStartSec ?? 0;
+		if (!Number.isFinite(start) || start < 0) throw new Error("Invalid media signal source start");
+		this.mode = options.mode;
+		this.fps = options.fps;
+		this.startFrame = options.startFrame;
+		this.durationFrames = options.durationFrames;
+		this.sampler = options.sample;
+		this.values = new Float64Array(options.durationFrames + 1);
+		if (options.mode === "speed") {
+			this.positions = new Float64Array(options.durationFrames + 1);
+			this.positions[0] = start;
+		}
+	}
+	/** The first composition frame whose boundary is not yet recorded. */
+	get nextFrame() {
+		return this.startFrame + this.recorded;
+	}
+	get complete() {
+		return this.recorded === this.values.length;
+	}
+	/** Allow on-demand sampling through a composition frame the clock has reached. */
+	advance(frame$1) {
+		if (frame$1 > this.horizon) this.horizon = frame$1;
+	}
+	/**
+	* Validate source bounds as history arrives: the recorded part now, each
+	* further interval as it is recorded.
+	*/
+	checkRange(check) {
+		this.check = check;
+		if (this.recorded > 1) check(this.range(0, this.recorded - 1));
+	}
+	/** Each boundary is recorded once in composition-frame order. */
+	record(frame$1, value) {
+		const index = frame$1 - this.startFrame;
+		if (!Number.isInteger(frame$1) || index < 0 || index > this.durationFrames) throw new Error(`Media signal frame ${frame$1} is outside the layer`);
+		if (!Number.isFinite(value)) throw new Error(`Non-finite media signal at composition frame ${frame$1}`);
+		if (index < this.recorded) {
+			if (this.values[index] !== value) throw new Error(`Media signal frame ${frame$1} was already recorded with a different value`);
+			return;
+		}
+		if (index !== this.recorded) throw new Error(`Media signal frame ${frame$1} was recorded out of order`);
+		this.values[index] = value;
+		if (this.positions && index > 0) {
+			const position = this.positions[index - 1] + (this.values[index - 1] / 2 + value / 2) / this.fps;
+			if (!Number.isFinite(position)) throw new Error(`Media signal integration overflow at composition frame ${frame$1}`);
+			this.positions[index] = position;
+		}
+		if (this.check && index > 0) this.check(this.interval(index - 1));
+		this.recorded++;
+	}
+	/**
+	* Evaluate a boundary once, reporting recursive time dependencies. A
+	* boundary already recorded is kept, and `sample` is not called again.
+	*/
+	recordFrom(frame$1, sample) {
+		if (this.evaluating) throw new Error(`Circular media signal dependency at composition frame ${frame$1}`);
+		if (frame$1 - this.startFrame < this.recorded) return;
+		this.evaluating = true;
+		try {
+			this.record(frame$1, sample());
+		} finally {
+			this.evaluating = false;
+		}
+	}
+	/** Sample every boundary through `frame` that the clock has reached. */
+	ensure(frame$1) {
+		const sampler = this.sampler;
+		if (!sampler) return;
+		const last = Math.min(frame$1, this.horizon, this.startFrame + this.durationFrames);
+		if (this.evaluating && frame$1 >= this.nextFrame) throw new Error(`Circular media signal dependency at composition frame ${this.nextFrame}`);
+		for (let f = this.nextFrame; f <= last; f++) this.recordFrom(f, () => sampler(f));
+	}
+	/**
+	* Close a layer that outlives the clock: the boundaries past the last
+	* rendered frame hold the last recorded value.
+	*/
+	close() {
+		if (this.recorded === 0) throw new Error("Media signal history has no recorded frames");
+		const last = this.values[this.recorded - 1];
+		while (!this.complete) this.record(this.nextFrame, last);
+	}
+	/** The known source position at an already-recorded frame boundary. */
+	at(frame$1) {
+		this.ensure(frame$1);
+		const index = frame$1 - this.startFrame;
+		if (!Number.isInteger(frame$1) || index < 0 || index >= this.recorded) throw new Error(`Media signal frame ${frame$1} has not been recorded`);
+		return this.positions ? this.positions[index] : this.values[index];
+	}
+	/** Read a recorded local frame, including fractional audio sample positions. */
+	sourceTime(localFrame) {
+		if (Number.isFinite(localFrame)) this.ensure(this.startFrame + Math.ceil(localFrame));
+		if (!Number.isFinite(localFrame) || localFrame < 0 || localFrame > this.recorded - 1) throw new Error(`Media signal local frame ${localFrame} has not been recorded`);
+		if (Number.isInteger(localFrame)) return this.at(this.startFrame + localFrame);
+		const i = Math.floor(localFrame);
+		const t = localFrame - i;
+		const a = this.values[i];
+		const b = this.values[i + 1];
+		return this.positions ? this.positions[i] + (a * (t - t * t / 2) + b * (t * t / 2)) / this.fps : a * (1 - t) + b * t;
+	}
+	/** Read the instantaneous speed for an interval whose endpoints are known. */
+	rate(localFrame) {
+		const i = this.knownInterval(localFrame);
+		const a = this.values[i];
+		const b = this.values[i + 1];
+		const t = localFrame - i;
+		return this.positions ? a * (1 - t) + b * t : (b - a) * this.fps;
+	}
+	isHold(localFrame) {
+		const i = this.knownInterval(localFrame);
+		return this.positions ? this.values[i] === 0 && this.values[i + 1] === 0 : this.values[i] === this.values[i + 1];
+	}
+	range(from, to) {
+		if (Number.isFinite(from) && Number.isFinite(to)) this.ensure(this.startFrame + Math.ceil(Math.max(from, to)));
+		if (!Number.isFinite(from) || !Number.isFinite(to) || from < 0 || to < 0 || Math.max(from, to) > this.recorded - 1) throw new Error("Media signal range has not been recorded");
+		if (this.recorded === 1) {
+			const value = this.sourceTime(0);
+			return {
+				min: value,
+				max: value,
+				maxIncluded: false
+			};
+		}
+		return sampledMediaSourceRange(this.history(0, this.recorded), from, to);
+	}
+	/** A self-contained snapshot, available only when every boundary was recorded. */
+	finish() {
+		if (!this.complete) throw new Error("Media signal history is incomplete");
+		const values = this.values.slice();
+		return this.positions ? {
+			mode: "speed",
+			fps: this.fps,
+			values,
+			positions: this.positions.slice()
+		} : {
+			mode: "source-time",
+			fps: this.fps,
+			values
+		};
+	}
+	knownInterval(localFrame) {
+		const i = Math.floor(localFrame);
+		if (Number.isFinite(localFrame)) this.ensure(this.startFrame + i + 1);
+		if (!Number.isFinite(localFrame) || i < 0 || i + 1 >= this.recorded) throw new Error(`Media signal interval ${localFrame} has not been recorded`);
+		return i;
+	}
+	/** Bounds of the interval starting at boundary `i`, its end exclusive. */
+	interval(i) {
+		return sampledMediaSourceRange(this.history(i, i + 2), 0, 1);
+	}
+	history(from, to) {
+		const values = this.values.subarray(from, to);
+		return this.positions ? {
+			mode: "speed",
+			fps: this.fps,
+			values,
+			positions: this.positions.subarray(from, to)
+		} : {
+			mode: "source-time",
+			fps: this.fps,
+			values
+		};
+	}
+};
+/** Maps layer-local frames to absolute source seconds. */
+const MediaTimeRemapSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("rate"),
+	sourceStartSec: z.number().finite().nonnegative(),
+	rate: z.number().finite().refine((v) => v !== 0, "rate must not be zero")
+}).strict(), z.object({
+	kind: z.literal("keyframes"),
+	keyframes: z.array(z.object({
+		frame: z.number().int().nonnegative(),
+		sourceSec: z.number().finite().nonnegative(),
+		interpolation: z.enum([
+			"linear",
+			"ease-in",
+			"ease-out",
+			"smooth"
+		]).optional()
+	}).strict()).min(2)
+}).strict()]);
+const MediaTimeSignalRemapSchema = z.object({
+	kind: z.literal("signal"),
+	mode: z.enum(["speed", "source-time"]),
+	signal: z.union([z.string().min(1), z.custom(isSignal, "signal must be a Signal or the name of a composition signal")]),
+	sourceStartSec: z.number().finite().nonnegative().optional()
+}).strict();
+const MediaTimeRemapInputSchema = z.discriminatedUnion("kind", [...MediaTimeRemapSchema.options, MediaTimeSignalRemapSchema]);
+function assertSampledFps(history, fps$1) {
+	if (history.fps !== fps$1) throw new Error(`Media signal history fps ${history.fps} does not match composition fps ${fps$1}`);
+}
+/** Validate the map against its explicit, exclusive layer duration. */
+function validateMediaTimeRemap(map, durationFrames) {
+	if (!Number.isInteger(durationFrames) || durationFrames <= 0) return "durationFrames must be a positive integer";
+	if (map.kind === "signal") return map.mode === "source-time" && map.sourceStartSec !== void 0 ? "sourceStartSec applies only to speed signals" : void 0;
+	if (map.kind === "rate") return;
+	const keys = map.keyframes;
+	if (keys.length < 2 || keys[0].frame !== 0 || keys[keys.length - 1].frame !== durationFrames) return "time remap keyframes must start at frame 0 and end at durationFrames";
+	for (let i = 1; i < keys.length; i++) if (keys[i].frame <= keys[i - 1].frame) return "time remap keyframes must have strictly increasing frames";
+}
+/** Find the segment containing a layer-local frame. */
+function segmentIndex(map, frame$1) {
+	let lo = 0;
+	let hi = map.keyframes.length - 1;
+	while (hi - lo > 1) {
+		const mid = Math.floor((lo + hi) / 2);
+		if (map.keyframes[mid].frame <= frame$1) lo = mid;
+		else hi = mid;
+	}
+	return lo;
+}
+/** Evaluate the monotonic easing assigned to the starting keyframe. */
+function shapeTime(t, interpolation) {
+	switch (interpolation) {
+		case "ease-in": return t * t;
+		case "ease-out": return 1 - (1 - t) * (1 - t);
+		case "smooth": return t * t * (3 - 2 * t);
+		default: return t;
+	}
+}
+/** Absolute source seconds at a fractional layer-local frame. */
+function mediaSourceTime(map, localFrame, fps$1) {
+	if (!Number.isFinite(localFrame) || !Number.isFinite(fps$1) || fps$1 <= 0) throw new Error("Invalid media time or fps");
+	if (map.kind === "recorded") {
+		if (map.recorder.fps !== fps$1) throw new Error("Media signal recorder fps does not match composition fps");
+		return map.recorder.sourceTime(localFrame);
+	}
+	if (map.kind === "sampled") {
+		assertSampledFps(map.history, fps$1);
+		return sampledMediaSourceTime(map.history, localFrame);
+	}
+	if (map.kind === "rate") return map.sourceStartSec + localFrame / fps$1 * map.rate;
+	const keys = map.keyframes;
+	if (keys.length < 2) throw new Error("Time remap needs at least two keyframes");
+	if (localFrame <= keys[0].frame) return keys[0].sourceSec;
+	if (localFrame >= keys[keys.length - 1].frame) return keys[keys.length - 1].sourceSec;
+	const i = segmentIndex(map, localFrame);
+	const a = keys[i];
+	const b = keys[i + 1];
+	const t = (localFrame - a.frame) / (b.frame - a.frame);
+	return a.sourceSec + (b.sourceSec - a.sourceSec) * shapeTime(t, a.interpolation ?? "linear");
+}
+/** True only for a constant source-time interval, not a ramp with zero instantaneous velocity. */
+function mediaSourceIsHold(map, frame$1) {
+	if (map.kind === "rate") return false;
+	if (map.kind === "recorded") return map.recorder.isHold(frame$1);
+	if (map.kind === "sampled") {
+		const values = map.history.values;
+		const i$1 = Math.max(0, Math.min(values.length - 2, Math.floor(frame$1)));
+		return map.history.mode === "speed" ? values[i$1] === 0 && values[i$1 + 1] === 0 : values[i$1] === values[i$1 + 1];
+	}
+	const i = segmentIndex(map, frame$1);
+	return map.keyframes[i].sourceSec === map.keyframes[i + 1].sourceSec;
+}
+/** Source seconds per output second at a layer-local frame. */
+function mediaSourceRate(map, frame$1, fps$1) {
+	if (map.kind === "rate") return map.rate;
+	if (map.kind === "recorded") {
+		if (map.recorder.fps !== fps$1) throw new Error("Media signal recorder fps does not match composition fps");
+		return map.recorder.rate(frame$1);
+	}
+	if (map.kind === "sampled") {
+		assertSampledFps(map.history, fps$1);
+		const values = map.history.values;
+		const i$1 = Math.max(0, Math.min(values.length - 2, Math.floor(frame$1)));
+		const t$1 = Math.max(0, Math.min(1, frame$1 - i$1));
+		return map.history.mode === "speed" ? values[i$1] * (1 - t$1) + values[i$1 + 1] * t$1 : (values[i$1 + 1] - values[i$1]) * map.history.fps;
+	}
+	const i = segmentIndex(map, frame$1);
+	const a = map.keyframes[i];
+	const b = map.keyframes[i + 1];
+	const t = Math.max(0, Math.min(1, (frame$1 - a.frame) / (b.frame - a.frame)));
+	const derivative = a.interpolation === "ease-in" ? 2 * t : a.interpolation === "ease-out" ? 2 * (1 - t) : a.interpolation === "smooth" ? 6 * t * (1 - t) : 1;
+	return (b.sourceSec - a.sourceSec) / (b.frame - a.frame) * fps$1 * derivative;
+}
+/** Bounds over a local-frame interval, including intermediate turns. */
+function mediaSourceRange(map, fromFrame, toFrame, fps$1) {
+	if (map.kind === "recorded") {
+		if (map.recorder.fps !== fps$1) throw new Error("Media signal recorder fps does not match composition fps");
+		return map.recorder.range(fromFrame, toFrame);
+	}
+	if (map.kind === "sampled") {
+		assertSampledFps(map.history, fps$1);
+		return sampledMediaSourceRange(map.history, fromFrame, toFrame);
+	}
+	const start = Math.min(fromFrame, toFrame), end = Math.max(fromFrame, toFrame);
+	const first = mediaSourceTime(map, start, fps$1);
+	const last = mediaSourceTime(map, end, fps$1);
+	let min = Math.min(first, last);
+	let max = Math.max(first, last);
+	let maxIncluded = start < end && first === max;
+	if (map.kind === "keyframes") for (const key of map.keyframes) {
+		if (key.frame <= start || key.frame >= end) continue;
+		min = Math.min(min, key.sourceSec);
+		if (key.sourceSec > max) {
+			max = key.sourceSec;
+			maxIncluded = true;
+		} else if (key.sourceSec === max) maxIncluded = true;
+	}
+	return {
+		min,
+		max,
+		maxIncluded
+	};
+}
 const HandleDefinitionSchema = z$1.object({
 	dataTypes: z$1.custom(),
 	label: z$1.string(),
@@ -2640,5 +3056,5 @@ function extractSvgDimensions(buffer) {
 }
 
 //#endregion
-export { TimelineTransformSchema as $, parseCssColor as $t, MIME_TYPES as A, getFileDataMetadata as At, OutputItemSchema as B, isEqual as Bt, FileDataSchema as C, formatHex as Ct, HandleTypeVal as D, frameSignal as Dt, Gradient as E, frameArraySignal as Et, ModerationUnrefundableError as F, gradientStopsToOklab as Ft, SignalGateDataSchema as G, isVirtualMediaData as Gt, Signal as H, isNormalized as Ht, MultiOutputGenericSchema as I, handleId as It, SingleOutputGenericSchema as J, ms as Jt, SignalMathDataSchema as K, limitGradientStops as Kt, NodeMetadataSchema as L, handleLabel as Lt, MediaOperationSchema as M, getLeafMediaType as Mt, MediaSourceSchema as N, getMediaType as Nt, JsonValueSchema as O, generateId as Ot, ModerationError as P, getRenderFingerprint as Pt, TimelineSegmentSchema as Q, oklabToRgb as Qt, NodeResultSchema as R, hasOnlySingleSource as Rt, FileAssetSchema as S, updateClockSignals as Sn, findSourceAsset as St, GlobalCompositeOperation as T, frame as Tt, SignalChannelMetaSchema as U, isSignal as Ut, ProgrammaticSignal as V, isFrameIndex as Vt, SignalDataSchema as W, isValueSignal as Wt, TEXT_LAYER_DEFAULTS as X, normalizeColorStops as Xt, SourceOperationSchema as Y, nodeId as Yt, TextOperationSchema as Z, normalized as Zt, DataTypeVal as _, signalBuilder as _n, dataTypeColors as _t, BaseVideoLayerPropsSchema as a, registerSignalDependency as an, VideoStylePropsSchema as at, ExportResultSchema as b, takeRenderDiagnostics as bn, emojiPresentation as bt, COMPOSITOR_DEFAULTS as c, resolveMediaMimeType as cn, VirtualMediaDataSchema as ct, ConfigSchemaRegistry as d, resolveString as dn, checkNodeResultCache as dt, parseCssGradient as en, TransitionSchema as et, DATA_TYPE_EXTENSIONS as f, rgbToOklab as fn, computeVideoCropRenderProps as ft, DataType as g, signal as gn, createVirtualMedia as gt, DEFAULT_MEDIA_DIMENSION as h, serializeSignalData as hn, createOutputItemSchema as ht, BaseMediaOperationPropsSchema as i, radians as in, VideoSpatialPropsSchema as it, MediaMetadataSchema as j, getFingerprint as jt, MAX_GRADIENT_STOPS as k, getActiveMediaMetadata as kt, Color as l, resolveNumber as ln, appendOperation as lt, DEFAULT_FPS as m, seconds as mn, cosineSignal as mt, AnyOutputUnionSchema as n, programmaticSignal as nn, VideoAnimationSchema as nt, CAPTION_LAYER_DEFAULTS as o, reportRenderDiagnostic as on, VideoTextPropsSchema as ot, DEFAULT_DURATION_MS as p, sampleColorStops as pn, computed as pt, SignalStatsSchema as q, mixColors as qt, AudioExtractorSignalDataSchema as r, progressSignal as rn, VideoLayerTypeSchema as rt, COMPOSITE_OPERATIONS as s, resolveBoolean as sn, VideoTimingPropsSchema as st, AnimationTypeSchema as t, pixels as tn, TransitionTypeSchema as tt, ConfigHandleSchema as u, resolveParam as un, assertNever as ut, DataTypes as v, sineSignal as vn, degrees as vt, GeneratorSignalDataSchema as w, fps as wt, ExtendedLayerSchema as x, timeSignal as xn, extractSvgDimensions as xt, Effect as y, stampResult as yn, deserializeSignalData as yt, NodeVisualConfigSchema as z, isCssGradient as zt };
-//# sourceMappingURL=dist-CL5JOMSp.mjs.map
+export { SourceOperationSchema as $, mediaSourceRange as $t, MIME_TYPES as A, signalBuilder as An, frame as At, MultiOutputGenericSchema as B, gradientStopsToOklab as Bt, FileDataSchema as C, sampleFrameMediaSignal as Cn, degrees as Ct, HandleTypeVal as D, seconds as Dn, findSourceAsset as Dt, Gradient as E, sampledMediaSourceTime as En, extractSvgDimensions as Et, MediaTimeRemapInputSchema as F, updateClockSignals as Fn, getFileDataMetadata as Ft, ProgrammaticSignal as G, isEqual as Gt, NodeResultSchema as H, handleLabel as Ht, MediaTimeRemapSchema as I, validateMediaTimeRemap as In, getFingerprint as It, SignalDataSchema as J, isSignal as Jt, Signal as K, isFrameIndex as Kt, MediaTimeSignalRemapSchema as L, getLeafMediaType as Lt, MediaOperationSchema as M, stampResult as Mn, frameSignal as Mt, MediaSignalRecorder as N, takeRenderDiagnostics as Nn, generateId as Nt, JsonValueSchema as O, serializeSignalData as On, formatHex as Ot, MediaSourceSchema as P, timeSignal as Pn, getActiveMediaMetadata as Pt, SingleOutputGenericSchema as Q, mediaSourceIsHold as Qt, ModerationError as R, getMediaType as Rt, FileAssetSchema as S, sampleColorStops as Sn, dataTypeColors as St, GlobalCompositeOperation as T, sampledMediaSourceRange as Tn, emojiPresentation as Tt, NodeVisualConfigSchema as U, hasOnlySingleSource as Ut, NodeMetadataSchema as V, handleId as Vt, OutputItemSchema as W, isCssGradient as Wt, SignalMathDataSchema as X, isVirtualMediaData as Xt, SignalGateDataSchema as Y, isValueSignal as Yt, SignalStatsSchema as Z, limitGradientStops as Zt, DataTypeVal as _, resolveMediaMimeType as _n, computeVideoCropRenderProps as _t, BaseVideoLayerPropsSchema as a, normalizeColorStops as an, TransitionTypeSchema as at, ExportResultSchema as b, resolveString as bn, createOutputItemSchema as bt, COMPOSITOR_DEFAULTS as c, parseCssColor as cn, VideoSpatialPropsSchema as ct, ConfigSchemaRegistry as d, programmaticSignal as dn, VideoTimingPropsSchema as dt, mediaSourceRate as en, TEXT_LAYER_DEFAULTS as et, DATA_TYPE_EXTENSIONS as f, progressSignal as fn, VirtualMediaDataSchema as ft, DataType as g, resolveBoolean as gn, compositionFrameContext as gt, DEFAULT_MEDIA_DIMENSION as h, reportRenderDiagnostic as hn, checkNodeResultCache as ht, BaseMediaOperationPropsSchema as i, nodeId as in, TransitionSchema as it, MediaMetadataSchema as j, sineSignal as jn, frameArraySignal as jt, MAX_GRADIENT_STOPS as k, signal as kn, fps as kt, Color as l, parseCssGradient as ln, VideoStylePropsSchema as lt, DEFAULT_FPS as m, registerSignalDependency as mn, assertNever as mt, AnyOutputUnionSchema as n, mixColors as nn, TimelineSegmentSchema as nt, CAPTION_LAYER_DEFAULTS as o, normalized as on, VideoAnimationSchema as ot, DEFAULT_DURATION_MS as p, radians as pn, appendOperation as pt, SignalChannelMetaSchema as q, isNormalized as qt, AudioExtractorSignalDataSchema as r, ms as rn, TimelineTransformSchema as rt, COMPOSITE_OPERATIONS as s, oklabToRgb as sn, VideoLayerTypeSchema as st, AnimationTypeSchema as t, mediaSourceTime as tn, TextOperationSchema as tt, ConfigHandleSchema as u, pixels as un, VideoTextPropsSchema as ut, DataTypes as v, resolveNumber as vn, computed as vt, GeneratorSignalDataSchema as w, sampleMediaSignal as wn, deserializeSignalData as wt, ExtendedLayerSchema as x, rgbToOklab as xn, createVirtualMedia as xt, Effect as y, resolveParam as yn, cosineSignal as yt, ModerationUnrefundableError as z, getRenderFingerprint as zt };
+//# sourceMappingURL=dist-BRXsfWKQ.mjs.map