@neta-art/cohub 8.23.0 → 9.0.0

package/dist/board/animation.js

@@ -1,249 +1,403 @@
-import { BOARD_BUILTIN_CAPABILITIES, DEFAULT_BOARD_RENDER_LIMITS } from "../protocol/dist/board-constants.js";
-import { BOARD_ANIMATION_CHANNELS, BoardCompositionSchema, BoardProceduralClipSchema, BoardTrackSchema } from "../protocol/dist/board-composition.js";
-import { estimateBuiltinBoardClipCost, estimateBuiltinBoardEffectCost, validateBuiltinBoardClip, validateBuiltinBoardEffect } from "../protocol/dist/board-capability-registry.js";
+import { BOARD_CAMERA_TARGET } from "../protocol/dist/board-model.js";
+import { resolveBoardProperty } from "../protocol/dist/board-patch.js";
 //#region src/board/animation.ts
-function track(input) {
-	return BoardTrackSchema.parse(input);
+const linear = (x) => x;
+function cubicBezier(x1, y1, x2, y2) {
+	const cx = 3 * x1;
+	const bx = 3 * (x2 - x1) - cx;
+	const ax = 1 - cx - bx;
+	const cy = 3 * y1;
+	const by = 3 * (y2 - y1) - cy;
+	const ay = 1 - cy - by;
+	const sampleX = (t) => ((ax * t + bx) * t + cx) * t;
+	const sampleY = (t) => ((ay * t + by) * t + cy) * t;
+	const slopeX = (t) => (3 * ax * t + 2 * bx) * t + cx;
+	return (x) => {
+		if (x <= 0) return 0;
+		if (x >= 1) return 1;
+		let t = x;
+		for (let index = 0; index < 8; index += 1) {
+			const error = sampleX(t) - x;
+			if (Math.abs(error) < 1e-6) return sampleY(t);
+			const slope = slopeX(t);
+			if (Math.abs(slope) < 1e-6) break;
+			t -= error / slope;
+		}
+		let low = 0;
+		let high = 1;
+		t = x;
+		for (let index = 0; index < 32; index += 1) {
+			const value = sampleX(t);
+			if (Math.abs(value - x) < 1e-6) break;
+			if (value < x) low = t;
+			else high = t;
+			t = (low + high) / 2;
+		}
+		return sampleY(t);
+	};
 }
-function proceduralClip(input) {
-	return BoardProceduralClipSchema.parse({
-		...input,
-		kindVersion: input.kindVersion ?? 1
-	});
+function steps(count, position) {
+	const jumps = position === "jump-none" ? count - 1 : position === "jump-both" ? count + 1 : count;
+	const start = position === "start" || position === "jump-start" || position === "jump-both";
+	return (x) => {
+		if (x >= 1) return 1;
+		const step = Math.floor(x * count) + (start ? 1 : 0);
+		return Math.min(1, Math.max(0, step / Math.max(1, jumps)));
+	};
 }
-function composition(input) {
-	return BoardCompositionSchema.parse(input);
-}
-function compileComposition(input) {
-	return composition({
-		id: input.id,
-		name: input.name,
-		timeline: {
-			duration: input.duration,
-			tracks: (input.tracks ?? []).map(track),
-			clips: (input.clips ?? []).map(proceduralClip),
-			markers: input.markers ?? []
-		},
-		playback: input.playback ?? {
-			loop: false,
-			endBehavior: "hold",
-			reducedMotion: { mode: "base" }
-		},
-		metadata: input.metadata ?? {},
-		revision: 0
+const KEYWORD_EASES = {
+	linear,
+	ease: cubicBezier(.25, .1, .25, 1),
+	"ease-in": cubicBezier(.42, 0, 1, 1),
+	"ease-out": cubicBezier(0, 0, .58, 1),
+	"ease-in-out": cubicBezier(.42, 0, .58, 1),
+	"step-start": steps(1, "start"),
+	"step-end": steps(1, "end")
+};
+const easeCache = /* @__PURE__ */ new Map();
+function boardEase(ease) {
+	if (!ease) return linear;
+	const key = ease.trim();
+	const keyword = KEYWORD_EASES[key];
+	if (keyword) return keyword;
+	const cached = easeCache.get(key);
+	if (cached) return cached;
+	let fn = linear;
+	const bezier = /^cubic-bezier\(([^)]+)\)$/.exec(key);
+	const stepped = /^steps\(\s*(\d+)\s*(?:,\s*([a-z-]+)\s*)?\)$/.exec(key);
+	if (bezier?.[1]) {
+		const [x1 = 0, y1 = 0, x2 = 1, y2 = 1] = bezier[1].split(",").map(Number);
+		fn = cubicBezier(x1, y1, x2, y2);
+	} else if (stepped?.[1]) fn = steps(Number(stepped[1]), stepped[2] ?? "end");
+	if (easeCache.size > 512) easeCache.clear();
+	easeCache.set(key, fn);
+	return fn;
+}
+function boardAnimationTime(header, elapsed) {
+	const local = Math.max(0, elapsed - header.delay);
+	if (header.loop || header.play === "always") return header.duration > 0 ? local % header.duration : 0;
+	if (local <= header.duration) return local;
+	return header.end === "reset" ? null : header.duration;
+}
+function compileTrack(animationId, id, track, targetType) {
+	const resolved = resolveBoardProperty(targetType, track.property);
+	if (!resolved.ok) return null;
+	const { spec } = resolved;
+	const times = new Float64Array(track.keyframes.length);
+	const values = [];
+	const eases = [];
+	track.keyframes.forEach((keyframe, index) => {
+		times[index] = keyframe.at;
+		values.push(keyframe.value);
+		eases.push(boardEase(keyframe.ease));
 	});
+	return {
+		id,
+		animationId,
+		target: track.target,
+		property: track.property,
+		path: track.property.split("."),
+		kind: spec.kind,
+		multiplicative: Boolean(spec.multiplicative),
+		composite: track.composite,
+		spline: track.interpolation === "spline" && spec.kind === "vec2",
+		step: track.interpolation === "step" || spec.kind === "discrete",
+		orient: Boolean(track.orient) && spec.kind === "vec2" && track.property === "position",
+		times,
+		values,
+		eases,
+		start: times[0] ?? 0
+	};
 }
-const clamp01 = (value) => Math.max(0, Math.min(1, value));
-function sampleEasing(easing, value) {
-	const t = clamp01(value);
-	switch (easing) {
-		case "ease-in-quad": return t * t;
-		case "ease-out-quad": return 1 - (1 - t) ** 2;
-		case "ease-in-out-quad": return t < .5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
-		case "ease-in-cubic": return t ** 3;
-		case "ease-out-cubic": return 1 - (1 - t) ** 3;
-		case "ease-in-out-cubic": return t < .5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2;
-		case "ease-out-quart": return 1 - (1 - t) ** 4;
-		case "ease-out-expo": return t === 1 ? 1 : 1 - 2 ** (-10 * t);
-		default: return t;
+function compileBoardAnimations(document) {
+	const animations = /* @__PURE__ */ new Map();
+	for (const [animationId, animation] of Object.entries(document.animations)) animations.set(animationId, compileAnimation(animationId, animation, document));
+	const incoming = new Map([...animations.keys()].map((id) => [id, 0]));
+	for (const animation of animations.values()) for (const track of animation.children) incoming.set(track.target, (incoming.get(track.target) ?? 0) + 1);
+	const order = [...animations.keys()].filter((id) => incoming.get(id) === 0).sort();
+	for (let index = 0; index < order.length; index += 1) {
+		const animation = animations.get(order[index]);
+		for (const track of animation?.children ?? []) {
+			const count = (incoming.get(track.target) ?? 1) - 1;
+			incoming.set(track.target, count);
+			if (count === 0) order.push(track.target);
+		}
 	}
+	if (order.length !== animations.size) throw new Error("Animation graph contains a cycle");
+	return {
+		animations,
+		document,
+		order
+	};
 }
-function interpolate(left, right, progress) {
-	if (typeof left === "number" && typeof right === "number") return left + (right - left) * progress;
-	if (left && right && typeof left === "object" && typeof right === "object" && !Array.isArray(left) && !Array.isArray(right)) {
-		const a = left;
-		const b = right;
-		const result = {};
-		for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) result[key] = interpolate(a[key], b[key], progress);
-		return result;
-	}
-	return progress < 1 ? left : right;
-}
-/** Deterministically sample one validated Track without touching scene state. */
-function sampleTrack(trackValue, time) {
-	const frames = trackValue.keyframes;
-	const first = frames[0];
-	const last = frames.at(-1);
-	if (!first || !last) return null;
-	if (time < first.time) {
-		if (trackValue.fill !== "backwards" && trackValue.fill !== "both") return null;
-		return {
-			target: trackValue.target,
-			channel: trackValue.channel,
-			value: first.value
-		};
-	}
-	if (time > last.time) {
-		if (trackValue.fill !== "forwards" && trackValue.fill !== "both") return null;
-		return {
-			target: trackValue.target,
-			channel: trackValue.channel,
-			value: last.value
-		};
+function compileAnimation(animationId, animation, document) {
+	const { tracks, ...header } = animation;
+	const compiled = [];
+	const children = [];
+	for (const [id, track] of Object.entries(tracks).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+		const targetType = track.target === "camera" ? BOARD_CAMERA_TARGET : document.animations[track.target] ? "animation" : document.items[track.target]?.type;
+		if (!targetType) continue;
+		const entry = compileTrack(animationId, id, track, targetType);
+		if (!entry) continue;
+		(targetType === "animation" ? children : compiled).push(entry);
 	}
+	return {
+		id: animationId,
+		header,
+		tracks: compiled,
+		children
+	};
+}
+function keyframeIndex(times, time) {
 	let low = 0;
-	let high = frames.length;
+	let high = times.length - 1;
+	if (time < times[0]) return -1;
+	if (time >= times[high]) return high;
 	while (low < high) {
-		const middle = low + high >>> 1;
-		if ((frames[middle]?.time ?? Number.POSITIVE_INFINITY) <= time) low = middle + 1;
-		else high = middle;
+		const mid = low + high + 1 >> 1;
+		if (times[mid] <= time) low = mid;
+		else high = mid - 1;
 	}
-	const left = frames[Math.max(0, low - 1)] ?? first;
-	const right = frames[Math.min(frames.length - 1, low)] ?? last;
-	if (left === right || trackValue.interpolation === "step") return {
-		target: trackValue.target,
-		channel: trackValue.channel,
-		value: left.value
+	return low;
+}
+function isVec(value) {
+	return Boolean(value) && typeof value === "object" && typeof value.x === "number" && typeof value.y === "number";
+}
+function toVec(value) {
+	if (typeof value === "number") return {
+		x: value,
+		y: value
 	};
-	const span = Math.max(Number.EPSILON, right.time - left.time);
-	const progress = sampleEasing(right.easing ?? "linear", (time - left.time) / span);
-	return {
-		target: trackValue.target,
-		channel: trackValue.channel,
-		value: interpolate(left.value, right.value, progress)
+	return isVec(value) ? value : {
+		x: 0,
+		y: 0
 	};
 }
-function sampleCompositionTracks(value, time) {
-	const position = Math.max(0, Math.min(value.timeline.duration, time));
-	return value.timeline.tracks.flatMap((item) => {
-		const sampled = sampleTrack(item, position);
-		return sampled ? [sampled] : [];
-	});
+const lerp = (a, b, t) => a + (b - a) * t;
+function catmullRom(p0, p1, p2, p3, t) {
+	const t2 = t * t;
+	const t3 = t2 * t;
+	return .5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3 * p1 - 3 * p2 + p3) * t3);
 }
-const ZERO_COST = {
-	particles: 0,
-	vertices: 0,
-	dynamicVertices: 0,
-	drawCalls: 0,
-	filterPasses: 0,
-	renderTexturePixels: 0,
-	textureBytes: 0,
-	bufferBytes: 0,
-	simulationSteps: 0
-};
-const DEFAULT_BOARD_LIMITS = DEFAULT_BOARD_RENDER_LIMITS;
-function builtinDefinition(capability) {
-	return {
-		...capability,
-		validate() {
-			return [];
-		},
-		estimateCost(params) {
-			return estimateBuiltinBoardClipCost({
-				kind: capability.id,
-				params
-			});
-		}
-	};
+function hex(color) {
+	return `#${Math.max(0, Math.min(16777215, Math.round(color))).toString(16).padStart(6, "0")}`;
 }
-var BoardExtensionRegistry = class {
-	#extensions = /* @__PURE__ */ new Map();
-	#presets = /* @__PURE__ */ new Map();
-	constructor() {
-		for (const capability of BOARD_BUILTIN_CAPABILITIES) this.register(builtinDefinition(capability));
-	}
-	register(definition) {
-		const key = `${definition.kind}:${definition.id}@${definition.version}`;
-		const target = definition.kind === "preset" ? this.#presets : this.#extensions;
-		if (target.has(key)) throw new Error(`Board extension is already registered: ${key}`);
-		target.set(key, definition);
-		return this;
+function mixColor(a, b, t, resolve) {
+	const from = resolve(a);
+	const to = resolve(b);
+	if (from === null || to === null) return t < 1 ? a : b;
+	const channel = (shift) => Math.round(lerp(from >> shift & 255, to >> shift & 255, t));
+	return hex(channel(16) << 16 | channel(8) << 8 | channel(0));
+}
+function parseHexColor(color) {
+	if (typeof color !== "string") return null;
+	const match = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(color.trim());
+	if (!match?.[1]) return null;
+	const digits = match[1].length === 3 ? [...match[1]].map((digit) => digit + digit).join("") : match[1];
+	return Number.parseInt(digits, 16);
+}
+function blend(track, index, time, resolveColor) {
+	const { times, values } = track;
+	const from = values[index];
+	const to = values[index + 1];
+	const t0 = times[index];
+	const t1 = times[index + 1];
+	if (to === void 0 || t1 <= t0) return from;
+	const progress = track.eases[index + 1]((time - t0) / (t1 - t0));
+	if (track.step) return progress >= 1 ? to : from;
+	switch (track.kind) {
+		case "number": return typeof from === "number" && typeof to === "number" ? lerp(from, to, progress) : from;
+		case "vec2":
+		case "scale": {
+			if (track.kind === "scale" && typeof from === "number" && typeof to === "number") return lerp(from, to, progress);
+			const a = toVec(from);
+			const b = toVec(to);
+			if (track.spline) {
+				const before = toVec(values[index - 1] ?? from);
+				const after = toVec(values[index + 2] ?? to);
+				return {
+					x: catmullRom(before.x, a.x, b.x, after.x, progress),
+					y: catmullRom(before.y, a.y, b.y, after.y, progress)
+				};
+			}
+			return {
+				x: lerp(a.x, b.x, progress),
+				y: lerp(a.y, b.y, progress)
+			};
+		}
+		case "color": return mixColor(from, to, progress, resolveColor);
+		default: return progress >= 1 ? to : from;
 	}
-	capabilities() {
-		return [...this.#extensions.values(), ...this.#presets.values()].map((definition) => ({
-			kind: definition.kind,
-			id: definition.id,
-			version: definition.version,
-			...definition.digest ? { digest: definition.digest } : {},
-			...definition.renderers ? { renderers: definition.renderers } : {},
-			...definition.fallbackId ? { fallbackId: definition.fallbackId } : {},
-			...definition.schema ? { schema: definition.schema } : {}
-		}));
+}
+function sampleBoardTrack(track, time, resolveColor = parseHexColor) {
+	const index = keyframeIndex(track.times, time);
+	if (index < 0) return track.values[0];
+	return blend(track, index, time, resolveColor);
+}
+function orientation(track, time, resolveColor) {
+	const span = Math.max(1, (track.times[track.times.length - 1] - track.start) / 1e3);
+	const a = toVec(sampleBoardTrack(track, Math.max(track.start, time - span), resolveColor));
+	const b = toVec(sampleBoardTrack(track, time + span, resolveColor));
+	if (Math.hypot(b.x - a.x, b.y - a.y) < 1e-6) return null;
+	return Math.atan2(b.y - a.y, b.x - a.x) * 180 / Math.PI;
+}
+function readPath(value, path) {
+	let current = value;
+	for (const segment of path) {
+		if (typeof current === "number" && (segment === "x" || segment === "y")) return current;
+		if (!current || typeof current !== "object") return void 0;
+		current = current[segment];
 	}
-	compilePreset(id, version, params) {
-		const preset = this.#presets.get(`preset:${id}@${version}`);
-		if (!preset) throw new Error(`Unknown Board preset: ${id}@${version}`);
-		return preset.compile(params);
+	return current;
+}
+function writePath(value, path, next, depth = 0) {
+	const key = path[depth];
+	if (depth === path.length - 1) return {
+		...value,
+		[key]: next
+	};
+	let child = value[key];
+	if (typeof child === "number") child = {
+		x: child,
+		y: child
+	};
+	const base = child && typeof child === "object" ? child : {};
+	return {
+		...value,
+		[key]: writePath(base, path, next, depth + 1)
+	};
+}
+function combine(track, base, value) {
+	if (track.composite !== "add") return value;
+	if (track.kind === "number") {
+		if (typeof base !== "number" || typeof value !== "number") return value;
+		return track.multiplicative ? base * value : base + value;
 	}
-	validate(input) {
-		const parsed = BoardCompositionSchema.safeParse(input.composition);
-		if (!parsed.success) return {
-			valid: false,
-			diagnostics: parsed.error.issues.map((issue) => ({
-				severity: "error",
-				code: "INVALID_COMPOSITION",
-				message: issue.message,
-				path: issue.path.join(".")
-			})),
-			peakCost: { ...ZERO_COST }
+	if (track.kind === "vec2" || track.kind === "scale") {
+		if (track.multiplicative) {
+			if (typeof base === "number" && typeof value === "number") return base * value;
+			const a = toVec(base ?? 1);
+			const b = toVec(value);
+			return {
+				x: a.x * b.x,
+				y: a.y * b.y
+			};
+		}
+		const a = toVec(base);
+		const b = toVec(value);
+		return {
+			x: a.x + b.x,
+			y: a.y + b.y
 		};
-		const diagnostics = [];
-		const composition = parsed.data;
-		const cost = { ...ZERO_COST };
-		for (const effect of input.effects ?? []) {
-			diagnostics.push(...validateBuiltinBoardEffect(effect, `effects.${effect.id}`));
-			if (!this.#extensions.has(`effect:${effect.kind}@${effect.kindVersion}`)) diagnostics.push({
-				severity: "warning",
-				code: "UNKNOWN_EFFECT",
-				message: `No renderer is registered for ${effect.kind}@${effect.kindVersion}`,
-				path: `effects.${effect.id}`
-			});
+	}
+	return value;
+}
+function outranks(track, time, other, otherTime) {
+	const elapsed = time - track.start;
+	const otherElapsed = otherTime - other.start;
+	if (elapsed >= 0 !== otherElapsed >= 0) return elapsed >= 0;
+	const distance = Math.abs(elapsed);
+	const otherDistance = Math.abs(otherElapsed);
+	if (distance !== otherDistance) return distance < otherDistance;
+	return track.id > other.id;
+}
+function evaluateBoardAnimations(compiled, times, options = {}) {
+	const resolveColor = options.resolveColor ?? parseHexColor;
+	const local = new Map(times instanceof Map ? times : Object.entries(times));
+	for (const id of compiled.order) {
+		const animation = compiled.animations.get(id);
+		const time = local.get(id);
+		if (!animation || time === void 0) continue;
+		for (const track of animation.children) {
+			const value = sampleBoardTrack(track, time, resolveColor);
+			if (typeof value === "number") local.set(track.target, Math.max(0, value));
 		}
-		const events = [];
-		for (const clip of composition.timeline.clips) {
-			const definition = this.#extensions.get(`clip:${clip.kind}@${clip.kindVersion}`);
-			if (!definition) {
-				diagnostics.push({
-					severity: "warning",
-					code: "UNKNOWN_CLIP",
-					message: `No renderer is registered for ${clip.kind}@${clip.kindVersion}`
-				});
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const [id, time] of local) {
+		const animation = compiled.animations.get(id);
+		if (!animation) continue;
+		for (const track of animation.tracks) {
+			const key = `${track.target}\u0000${track.property}`;
+			let group = groups.get(key);
+			if (!group) {
+				group = {
+					target: track.target,
+					path: track.path,
+					winnerTime: 0,
+					adds: []
+				};
+				groups.set(key, group);
+			}
+			if (track.composite === "add") {
+				group.adds.push([track, time]);
 				continue;
 			}
-			diagnostics.push(...validateBuiltinBoardClip(clip, `composition.timeline.clips.${clip.id}`));
-			diagnostics.push(...definition.validate?.(clip.params) ?? []);
-			const estimate = definition.estimateCost(clip.params, input.profile ?? "high");
-			const clipCost = { ...ZERO_COST };
-			for (const key of Object.keys(clipCost)) clipCost[key] = estimate[key] ?? 0;
-			events.push({
-				at: clip.start,
-				direction: 1,
-				cost: clipCost
-			});
-			events.push({
-				at: clip.start + clip.duration,
-				direction: -1,
-				cost: clipCost
-			});
+			if (!group.winner || outranks(track, time, group.winner, group.winnerTime)) {
+				group.winner = track;
+				group.winnerTime = time;
+			}
 		}
-		events.sort((left, right) => left.at - right.at || left.direction - right.direction);
-		const active = { ...ZERO_COST };
-		for (const event of events) for (const key of Object.keys(active)) {
-			active[key] += event.cost[key] * event.direction;
-			cost[key] = Math.max(cost[key], active[key]);
+	}
+	const items = /* @__PURE__ */ new Map();
+	const camera = {};
+	const ordered = [...groups.values()].sort((a, b) => a.path.length - b.path.length);
+	for (const group of ordered) {
+		const isCamera = group.target === BOARD_CAMERA_TARGET;
+		const base = isCamera ? void 0 : items.get(group.target) ?? compiled.document.items[group.target];
+		if (!isCamera && !base) continue;
+		let value = isCamera ? camera[group.path[0]] : readPath(base, group.path);
+		let orientTrack = null;
+		if (group.winner) {
+			value = sampleBoardTrack(group.winner, group.winnerTime, resolveColor);
+			if (group.winner.orient) orientTrack = [group.winner, group.winnerTime];
 		}
-		for (const effect of input.effects ?? []) {
-			const estimate = estimateBuiltinBoardEffectCost(effect);
-			for (const key of Object.keys(cost)) cost[key] += estimate[key] ?? 0;
+		for (const [track, time] of group.adds) {
+			value = combine(track, value, sampleBoardTrack(track, time, resolveColor));
+			if (track.orient && !orientTrack) orientTrack = [track, time];
 		}
-		const limits = input.limits ?? DEFAULT_BOARD_LIMITS;
-		for (const key of Object.keys(cost)) if (cost[key] > limits[key]) diagnostics.push({
-			severity: "warning",
-			code: "RENDER_BUDGET_EXCEEDED",
-			message: `${key} peaks at ${cost[key]}, above ${limits[key]}`,
-			path: key,
-			adaptation: { quality: "lower" }
-		});
-		return {
-			valid: !diagnostics.some((item) => item.severity === "error"),
-			diagnostics,
-			peakCost: cost
-		};
+		if (isCamera) {
+			camera[group.path[0]] = value;
+			continue;
+		}
+		let next = writePath(base, group.path, value);
+		if (orientTrack) {
+			const angle = orientation(orientTrack[0], orientTrack[1], resolveColor);
+			if (angle !== null) next = {
+				...next,
+				rotation: base.rotation + angle
+			};
+		}
+		items.set(group.target, next);
 	}
-};
-function createBoardExtensionRegistry() {
-	return new BoardExtensionRegistry();
+	return {
+		items,
+		camera,
+		times: local
+	};
+}
+function applyBoardEvaluation(document, evaluation) {
+	if (evaluation.items.size === 0) return document;
+	const items = { ...document.items };
+	for (const [id, item] of evaluation.items) items[id] = item;
+	return {
+		...document,
+		items
+	};
+}
+function boardDocumentAt(document, animationId, time, options = {}) {
+	const compiled = compileBoardAnimations(document);
+	const times = /* @__PURE__ */ new Map();
+	for (const [id, animation] of compiled.animations) if (animation.header.play === "always") times.set(id, boardAnimationTime(animation.header, time) ?? 0);
+	if (animationId) {
+		const animation = compiled.animations.get(animationId);
+		if (animation) times.set(animationId, Math.min(Math.max(0, time), animation.header.duration));
+	}
+	const evaluation = evaluateBoardAnimations(compiled, times, options);
+	return {
+		document: applyBoardEvaluation(document, evaluation),
+		evaluation
+	};
 }
-const BOARD_CHANNELS = BOARD_ANIMATION_CHANNELS;
 //#endregion
-export { BOARD_CHANNELS, BoardExtensionRegistry, DEFAULT_BOARD_LIMITS, compileComposition, composition, createBoardExtensionRegistry, proceduralClip, sampleCompositionTracks, sampleEasing, sampleTrack, track };
+export { applyBoardEvaluation, boardAnimationTime, boardDocumentAt, boardEase, compileBoardAnimations, evaluateBoardAnimations, parseHexColor, sampleBoardTrack };