framefields 2.6.1 → 2.7.0

package/dist/{dist-D021IFfp.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(),
@@ -2162,6 +2578,26 @@ const Color = {
 	}
 };
 /**
+* How a grapheme presents, after Unicode's emoji presentation rules
+* (UTS #51): as a color emoji, as text, or as text when the text font has
+* the glyph. Layout and the emoji preload use it, and so does the
+* `missing_emoji_font` lint, so they agree on which characters need the
+* color emoji font.
+*/
+/** Default emoji presentation (✅ ⚡ 🚀), a skin tone, or a keycap. */
+const EMOJI_STYLE = /\p{Emoji_Presentation}|\p{Emoji_Modifier}|⃣/u;
+/** Pictographs that can be emoji (❤ ✈ © ™ ✔): emoji only when asked for. */
+const PICTOGRAPHIC = /\p{Extended_Pictographic}/u;
+/** A pictograph followed by VS16 asks for emoji presentation (❤️). */
+const VS16_AFTER_PICTOGRAPH = /\p{Extended_Pictographic}️/u;
+const VS15 = "︎";
+const ZWJ = "‍";
+function emojiPresentation(grapheme) {
+	if (grapheme.includes(VS15)) return "text";
+	if (EMOJI_STYLE.test(grapheme) || VS16_AFTER_PICTOGRAPH.test(grapheme) || grapheme.includes(ZWJ) && PICTOGRAPHIC.test(grapheme)) return "emoji";
+	return PICTOGRAPHIC.test(grapheme) ? "either" : "text";
+}
+/**
 * CSS gradients (`linear-gradient`, `radial-gradient`, `conic-gradient`) as
 * values for any `background` or shape `fill`, plus `Gradient` helpers that
 * write them. Colors blend perceptually (OKLab), not through muddy sRGB.
@@ -2620,5 +3056,5 @@ function extractSvgDimensions(buffer) {
 }
 
 //#endregion
-export { TimelineTransformSchema as $, parseCssGradient as $t, MIME_TYPES as A, getFingerprint as At, OutputItemSchema as B, isFrameIndex as Bt, FileDataSchema as C, fps as Ct, HandleTypeVal as D, generateId as Dt, Gradient as E, frameSignal as Et, ModerationUnrefundableError as F, handleId as Ft, SignalGateDataSchema as G, limitGradientStops as Gt, Signal as H, isSignal as Ht, MultiOutputGenericSchema as I, handleLabel as It, SingleOutputGenericSchema as J, nodeId as Jt, SignalMathDataSchema as K, mixColors as Kt, NodeMetadataSchema as L, hasOnlySingleSource as Lt, MediaOperationSchema as M, getMediaType as Mt, MediaSourceSchema as N, getRenderFingerprint as Nt, JsonValueSchema as O, getActiveMediaMetadata as Ot, ModerationError as P, gradientStopsToOklab as Pt, TimelineSegmentSchema as Q, parseCssColor as Qt, NodeResultSchema as R, isCssGradient as Rt, FileAssetSchema as S, formatHex as St, GlobalCompositeOperation as T, frameArraySignal as Tt, SignalChannelMetaSchema as U, isValueSignal as Ut, ProgrammaticSignal as V, isNormalized as Vt, SignalDataSchema as W, isVirtualMediaData as Wt, TEXT_LAYER_DEFAULTS as X, normalized as Xt, SourceOperationSchema as Y, normalizeColorStops as Yt, TextOperationSchema as Z, oklabToRgb as Zt, DataTypeVal as _, sineSignal as _n, dataTypeColors as _t, BaseVideoLayerPropsSchema as a, reportRenderDiagnostic as an, VideoStylePropsSchema as at, ExportResultSchema as b, timeSignal as bn, extractSvgDimensions as bt, COMPOSITOR_DEFAULTS as c, resolveNumber as cn, VirtualMediaDataSchema as ct, ConfigSchemaRegistry as d, rgbToOklab as dn, checkNodeResultCache as dt, pixels as en, TransitionSchema as et, DATA_TYPE_EXTENSIONS as f, sampleColorStops as fn, computeVideoCropRenderProps as ft, DataType as g, signalBuilder as gn, createVirtualMedia as gt, DEFAULT_MEDIA_DIMENSION as h, signal as hn, createOutputItemSchema as ht, BaseMediaOperationPropsSchema as i, registerSignalDependency as in, VideoSpatialPropsSchema as it, MediaMetadataSchema as j, getLeafMediaType as jt, MAX_GRADIENT_STOPS as k, getFileDataMetadata as kt, Color as l, resolveParam as ln, appendOperation as lt, DEFAULT_FPS as m, serializeSignalData as mn, cosineSignal as mt, AnyOutputUnionSchema as n, progressSignal as nn, VideoAnimationSchema as nt, CAPTION_LAYER_DEFAULTS as o, resolveBoolean as on, VideoTextPropsSchema as ot, DEFAULT_DURATION_MS as p, seconds as pn, computed as pt, SignalStatsSchema as q, ms as qt, AudioExtractorSignalDataSchema as r, radians as rn, VideoLayerTypeSchema as rt, COMPOSITE_OPERATIONS as s, resolveMediaMimeType as sn, VideoTimingPropsSchema as st, AnimationTypeSchema as t, programmaticSignal as tn, TransitionTypeSchema as tt, ConfigHandleSchema as u, resolveString as un, assertNever as ut, DataTypes as v, stampResult as vn, degrees as vt, GeneratorSignalDataSchema as w, frame as wt, ExtendedLayerSchema as x, updateClockSignals as xn, findSourceAsset as xt, Effect as y, takeRenderDiagnostics as yn, deserializeSignalData as yt, NodeVisualConfigSchema as z, isEqual as zt };
-//# sourceMappingURL=dist-D021IFfp.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