@neta-art/cohub 5.10.0 → 7.0.0

package/dist/board/animation.js

@@ -1,282 +1,147 @@
 import { BOARD_BUILTIN_CAPABILITIES, DEFAULT_BOARD_RENDER_LIMITS } from "../protocol/dist/board-constants.js";
-import { BoardCameraFocusParamsSchema } from "../protocol/dist/board.js";
-import "../protocol/dist/index.js";
+import { BOARD_ANIMATION_CHANNELS, BoardCompositionSchema, BoardProceduralClipSchema, BoardTrackSchema } from "../protocol/dist/board-composition.js";
+import { estimateBuiltinBoardClipCost, validateBuiltinBoardClip } from "../protocol/dist/board-capability-registry.js";
 //#region src/board/animation.ts
-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;
-const BUILTIN_CAPABILITIES = BOARD_BUILTIN_CAPABILITIES;
-function numericParam(params, key, fallback) {
-	const value = params[key];
-	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+function track(input) {
+	return BoardTrackSchema.parse(input);
 }
-function builtinDefinition(capability) {
-	return {
-		...capability,
-		validate(params) {
-			const diagnostics = [];
-			if (capability.id === "effects.particles") {
-				const count = params.count;
-				const bounds = params.bounds;
-				if (!Number.isSafeInteger(count) || count < 1 || count > DEFAULT_BOARD_LIMITS.particles) diagnostics.push({
-					severity: "error",
-					code: "INVALID_PARTICLE_COUNT",
-					message: `count must be an integer between 1 and ${DEFAULT_BOARD_LIMITS.particles}`,
-					path: "params.count"
-				});
-				if (!bounds || typeof bounds !== "object" || Array.isArray(bounds)) diagnostics.push({
-					severity: "error",
-					code: "PARTICLE_BOUNDS_REQUIRED",
-					message: "particles require finite world bounds",
-					path: "params.bounds",
-					coordinateSpace: "world"
-				});
-				else {
-					const value = bounds;
-					if (![
-						value.x,
-						value.y,
-						value.width,
-						value.height
-					].every((item) => typeof item === "number" && Number.isFinite(item)) || value.width <= 0 || value.height <= 0) diagnostics.push({
-						severity: "error",
-						code: "INVALID_PARTICLE_BOUNDS",
-						message: "particle bounds must have a positive finite size",
-						path: "params.bounds",
-						coordinateSpace: "world"
-					});
-				}
-			}
-			if (capability.id === "motion.path") {
-				const points = params.points;
-				if (!Array.isArray(points) || points.length < 2 || points.length > 1e4) diagnostics.push({
-					severity: "error",
-					code: "INVALID_MOTION_PATH",
-					message: "motion path must contain 2 to 10000 world-offset points",
-					path: "params.points",
-					coordinateSpace: "world-offset"
-				});
-			}
-			if (capability.id === "camera.focus") {
-				const parsed = BoardCameraFocusParamsSchema.safeParse(params);
-				if (!parsed.success) diagnostics.push({
-					severity: "error",
-					code: "INVALID_CAMERA_FOCUS",
-					message: parsed.error.issues[0]?.message ?? "invalid camera focus",
-					path: "params",
-					coordinateSpace: "world"
-				});
-			}
-			return diagnostics;
+function proceduralClip(input) {
+	return BoardProceduralClipSchema.parse({
+		...input,
+		kindVersion: input.kindVersion ?? 1
+	});
+}
+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 ?? []
 		},
-		getBounds(params) {
-			const bounds = params.bounds;
-			if (!bounds || typeof bounds !== "object" || Array.isArray(bounds)) return null;
-			const value = bounds;
-			return [
-				value.x,
-				value.y,
-				value.width,
-				value.height
-			].every((item) => typeof item === "number" && Number.isFinite(item)) ? value : null;
+		playback: input.playback ?? {
+			loop: false,
+			endBehavior: "hold",
+			reducedMotion: { mode: "base" }
 		},
-		estimateCost(params) {
-			switch (capability.id) {
-				case "effects.particles": {
-					const particles = Math.max(0, Math.floor(numericParam(params, "count", 0)));
-					return {
-						particles,
-						vertices: particles * 4,
-						dynamicVertices: particles * 4,
-						drawCalls: 1,
-						bufferBytes: particles * 48,
-						simulationSteps: particles
-					};
-				}
-				case "effects.trail": return {
-					vertices: 32,
-					dynamicVertices: 32,
-					drawCalls: 1,
-					bufferBytes: 1024,
-					simulationSteps: 16
-				};
-				case "effects.impact":
-				case "effects.flash": return {
-					vertices: 64,
-					drawCalls: 1
-				};
-				case "effects.color": return {
-					drawCalls: 1,
-					filterPasses: 1
-				};
-				case "draw.reveal":
-				case "draw.handwrite": return {
-					drawCalls: 1,
-					dynamicVertices: 1
-				};
-				default: return {};
-			}
-		}
-	};
+		metadata: input.metadata ?? {},
+		revision: 0
+	});
 }
-function stableHash(value) {
-	let hash = 2166136261;
-	for (let index = 0; index < value.length; index += 1) {
-		hash ^= value.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
+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;
 	}
-	return (hash >>> 0).toString(36).padStart(7, "0");
-}
-function stableId(prefix, seed, path) {
-	return `${prefix}_${stableHash(`${seed}:${path}`)}`;
-}
-function assertDuration(value, field) {
-	if (!Number.isFinite(value) || value < 0) throw new TypeError(`${field} must be a finite non-negative number`);
 }
-const timeline = {
-	clip(clip) {
-		return {
-			type: "clip",
-			clip
-		};
-	},
-	parallel(...children) {
-		return {
-			type: "parallel",
-			children
-		};
-	},
-	sequence(...children) {
-		return {
-			type: "sequence",
-			children
-		};
-	},
-	stagger(each, ...children) {
-		assertDuration(each, "stagger each");
-		return {
-			type: "stagger",
-			each,
-			children
-		};
-	},
-	delay(duration, child) {
-		assertDuration(duration, "delay duration");
-		return {
-			type: "delay",
-			duration,
-			child
-		};
-	},
-	repeat(count, child) {
-		if (!Number.isSafeInteger(count) || count < 1 || count > 1e3) throw new TypeError("repeat count must be an integer between 1 and 1000");
-		return {
-			type: "repeat",
-			count,
-			child
-		};
+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;
 	}
-};
-function clip(input) {
-	assertDuration(input.duration, "clip duration");
-	if (input.duration === 0) throw new TypeError("clip duration must be greater than zero");
-	return timeline.clip({
-		id: input.id,
-		kind: input.kind,
-		kindVersion: input.kindVersion ?? 1,
-		target: input.target,
-		duration: input.duration,
-		layer: input.layer ?? "content",
-		fill: input.fill ?? "none",
-		easing: input.easing ?? "linear",
-		params: input.params ?? {},
-		keyframes: input.keyframes ?? [],
-		assetRefs: input.assetRefs ?? [],
-		seed: input.seed,
-		metadata: input.metadata ?? {}
-	});
+	return progress < 1 ? left : right;
 }
-function flatten(input, offset, sequenceSeed, path) {
-	if (input.type === "clip") {
-		const clipSeed = input.clip.seed ?? `${sequenceSeed}:${path}`;
+/** 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 {
-			duration: input.clip.duration,
-			clips: [{
-				...input.clip,
-				id: input.clip.id ?? stableId("clip", sequenceSeed, path),
-				start: offset,
-				seed: clipSeed
-			}]
+			target: trackValue.target,
+			channel: trackValue.channel,
+			value: first.value
 		};
 	}
-	if (input.type === "delay") {
-		const nested = flatten(input.child, offset + input.duration, sequenceSeed, `${path}.child`);
+	if (time > last.time) {
+		if (trackValue.fill !== "forwards" && trackValue.fill !== "both") return null;
 		return {
-			duration: input.duration + nested.duration,
-			clips: nested.clips
+			target: trackValue.target,
+			channel: trackValue.channel,
+			value: last.value
 		};
 	}
-	if (input.type === "repeat") {
-		const clips = [];
-		let cursor = offset;
-		let total = 0;
-		for (let index = 0; index < input.count; index += 1) {
-			const nested = flatten(input.child, cursor, sequenceSeed, `${path}.${index}`);
-			clips.push(...nested.clips);
-			cursor += nested.duration;
-			total += nested.duration;
-		}
-		return {
-			duration: total,
-			clips
-		};
-	}
-	const clips = [];
-	let duration = 0;
-	for (const [index, child] of input.children.entries()) {
-		const childOffset = input.type === "sequence" ? duration : input.type === "stagger" ? input.each * index : 0;
-		const nested = flatten(child, offset + childOffset, sequenceSeed, `${path}.${index}`);
-		clips.push(...nested.clips);
-		duration = input.type === "sequence" ? duration + nested.duration : Math.max(duration, childOffset + nested.duration);
+	let low = 0;
+	let high = frames.length;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if ((frames[middle]?.time ?? Number.POSITIVE_INFINITY) <= time) low = middle + 1;
+		else high = middle;
 	}
+	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
+	};
+	const span = Math.max(Number.EPSILON, right.time - left.time);
+	const progress = sampleEasing(right.easing ?? "linear", (time - left.time) / span);
 	return {
-		duration,
-		clips
+		target: trackValue.target,
+		channel: trackValue.channel,
+		value: interpolate(left.value, right.value, progress)
 	};
 }
-function compileSequence(input) {
-	const flattened = flatten(input.timeline, 0, input.seed, "root");
-	flattened.clips.sort((left, right) => left.start - right.start || left.id.localeCompare(right.id));
-	const refs = /* @__PURE__ */ new Map();
-	for (const item of flattened.clips) for (const ref of item.assetRefs) refs.set(`${ref.type}:${ref.ref}:${ref.digest ?? ""}`, ref);
+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 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 {
-		sequence: {
-			id: input.id,
-			name: input.name,
-			duration: flattened.duration,
-			seed: input.seed,
-			restPose: input.restPose ?? {},
-			metadata: input.metadata ?? {}
+		...capability,
+		validate() {
+			return [];
 		},
-		clips: flattened.clips,
-		assetRefs: [...refs.values()]
+		estimateCost(params) {
+			return estimateBuiltinBoardClipCost({
+				kind: capability.id,
+				params
+			});
+		}
 	};
 }
-function addCost(target, source) {
-	for (const key of Object.keys(target)) target[key] += source[key] ?? 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;
@@ -285,9 +150,15 @@ var BoardExtensionRegistry = class {
 		return this;
 	}
 	capabilities() {
-		const extensions = [...this.#extensions.values()].map(({ validate: _validate, getBounds: _bounds, getAssetRefs: _refs, estimateCost: _cost, ...definition }) => definition);
-		const presets = [...this.#presets.values()].map(({ compile: _compile, ...definition }) => definition);
-		return [...extensions, ...presets];
+		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 } : {}
+		}));
 	}
 	compilePreset(id, version, params) {
 		const preset = this.#presets.get(`preset:${id}@${version}`);
@@ -295,88 +166,72 @@ var BoardExtensionRegistry = class {
 		return preset.compile(params);
 	}
 	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 }
+		};
 		const diagnostics = [];
+		const composition = parsed.data;
+		const cost = { ...ZERO_COST };
 		const events = [];
-		const profile = input.profile ?? "high";
-		const persistentCost = { ...ZERO_COST };
-		for (const [index, effect] of (input.effects ?? []).entries()) {
-			const definition = this.#extensions.get(`effect:${effect.kind}@${effect.kindVersion}`);
-			if (!definition) {
-				diagnostics.push({
-					severity: "warning",
-					code: "UNKNOWN_EFFECT",
-					message: `No renderer is registered for ${effect.kind}@${effect.kindVersion}`,
-					path: `effects.${index}`
-				});
-				continue;
-			}
-			diagnostics.push(...definition.validate?.(effect.params) ?? []);
-			addCost(persistentCost, definition.estimateCost(effect.params, profile));
-		}
-		for (const [index, clip] of input.clips.entries()) {
+		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}`,
-					path: `clips.${index}`
+					message: `No renderer is registered for ${clip.kind}@${clip.kindVersion}`
 				});
 				continue;
 			}
+			diagnostics.push(...validateBuiltinBoardClip(clip, `composition.timeline.clips.${clip.id}`));
 			diagnostics.push(...definition.validate?.(clip.params) ?? []);
-			const cost = { ...ZERO_COST };
-			addCost(cost, definition.estimateCost(clip.params, profile));
+			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
-			}, {
+				cost: clipCost
+			});
+			events.push({
 				at: clip.start + clip.duration,
 				direction: -1,
-				cost
-			});
-		}
-		const cameraFocusClips = input.clips.map((clip, index) => ({
-			clip,
-			index
-		})).filter(({ clip }) => clip.kind === "camera.focus").sort((left, right) => left.clip.start - right.clip.start);
-		for (let index = 1; index < cameraFocusClips.length; index += 1) {
-			const previous = cameraFocusClips[index - 1];
-			const currentFocus = cameraFocusClips[index];
-			if (previous && currentFocus && currentFocus.clip.start < previous.clip.start + previous.clip.duration) diagnostics.push({
-				severity: "error",
-				code: "OVERLAPPING_CAMERA_FOCUS",
-				message: "camera.focus clips must not overlap",
-				path: `clips.${currentFocus.index}.start`
+				cost: clipCost
 			});
 		}
 		events.sort((left, right) => left.at - right.at || left.direction - right.direction);
-		const current = { ...persistentCost };
-		const peak = { ...persistentCost };
-		for (const event of events) for (const key of Object.keys(current)) {
-			current[key] += event.cost[key] * event.direction;
-			peak[key] = Math.max(peak[key], current[key]);
+		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]);
 		}
+		for (const effect of input.effects ?? []) if (effect.kind === "effects.pulse" || effect.kind === "effects.float") cost.drawCalls += 1;
 		const limits = input.limits ?? DEFAULT_BOARD_LIMITS;
-		for (const key of Object.keys(limits)) if (peak[key] > limits[key]) diagnostics.push({
+		for (const key of Object.keys(cost)) if (cost[key] > limits[key]) diagnostics.push({
 			severity: "warning",
 			code: "RENDER_BUDGET_EXCEEDED",
-			message: `${key} peaks at ${peak[key]}, above ${limits[key]}`,
+			message: `${key} peaks at ${cost[key]}, above ${limits[key]}`,
 			path: key,
 			adaptation: { quality: "lower" }
 		});
 		return {
 			valid: !diagnostics.some((item) => item.severity === "error"),
 			diagnostics,
-			peakCost: peak
+			peakCost: cost
 		};
 	}
 };
-function createBoardExtensionRegistry(input = {}) {
-	const registry = new BoardExtensionRegistry();
-	if (input.builtins !== false) for (const capability of BUILTIN_CAPABILITIES) registry.register(builtinDefinition(capability));
-	return registry;
+function createBoardExtensionRegistry() {
+	return new BoardExtensionRegistry();
 }
+const BOARD_CHANNELS = BOARD_ANIMATION_CHANNELS;
 //#endregion
-export { BoardExtensionRegistry, DEFAULT_BOARD_LIMITS, clip, compileSequence, createBoardExtensionRegistry, timeline };
+export { BOARD_CHANNELS, BoardExtensionRegistry, DEFAULT_BOARD_LIMITS, compileComposition, composition, createBoardExtensionRegistry, proceduralClip, sampleCompositionTracks, sampleEasing, sampleTrack, track };

package/dist/board/core/connections.js

@@ -238,11 +238,11 @@ const CURVE_SEGMENTS = 20;
 * fetched.
 */
 function resolveConnection(connection, getFrame, options = {}) {
-	const sourceFrame = getFrame(connection.source.nodeId);
-	const targetFrame = getFrame(connection.target.nodeId);
+	const sourceFrame = getFrame(connection.source.itemId);
+	const targetFrame = getFrame(connection.target.itemId);
 	if (!sourceFrame || !targetFrame) return null;
 	const gap = options.gap ?? 4;
-	if (connection.source.nodeId === connection.target.nodeId) {
+	if (connection.source.itemId === connection.target.itemId) {
 		const path = selfLoopPath(sourceFrame, gap);
 		const first = path[0];
 		const last = path[path.length - 1];
@@ -398,7 +398,7 @@ function createConnectionIndex(connections) {
 	const byId = /* @__PURE__ */ new Map();
 	for (const connection of connections) {
 		byId.set(connection.id, connection);
-		for (const nodeId of /* @__PURE__ */ new Set([connection.source.nodeId, connection.target.nodeId])) {
+		for (const nodeId of /* @__PURE__ */ new Set([connection.source.itemId, connection.target.itemId])) {
 			const list = byNode.get(nodeId);
 			if (list) list.push(connection.id);
 			else byNode.set(nodeId, [connection.id]);

package/dist/board/core/export-plan.js

@@ -55,7 +55,7 @@ function exportConnectionBounds(connection, getFrame) {
 function connectionsWithin(document, items) {
 	if (document.connections.length === 0) return [];
 	const present = new Set(items.map((item) => item.id));
-	return document.connections.filter((connection) => present.has(connection.source.nodeId) && present.has(connection.target.nodeId));
+	return document.connections.filter((connection) => present.has(connection.source.itemId) && present.has(connection.target.itemId));
 }
 function resolveRegion(document, region, getFrame) {
 	switch (region.kind) {

package/dist/board/core/shape-types.js

@@ -1,5 +1,4 @@
 import { BOARD_GEO_KINDS } from "../../protocol/dist/board-node.js";
-import "../../protocol/dist/index.js";
 //#region src/board/core/shape-types.ts
 function resizeModeForCapabilities(capabilities) {
 	if (!capabilities.canResize) return "none";

package/dist/board/geometry.js

@@ -538,19 +538,19 @@ function cameraForRect(content, surface, options = {
 }
 function rectForCameraFocus(focus, getFrame) {
 	if (focus.type === "rect") return focus.rect;
-	if (focus.type === "node") {
-		const frame = getFrame(focus.nodeId);
+	if (focus.type === "item") {
+		const frame = getFrame(focus.itemId);
 		return frame ? itemBounds(frame) : null;
 	}
 	if (focus.type === "frame") {
 		const frame = getFrame(focus.frameId);
 		return frame ? itemBounds(frame) : null;
 	}
-	const frames = focus.nodeIds.flatMap((id) => {
+	const frames = focus.itemIds.flatMap((id) => {
 		const frame = getFrame(id);
 		return frame ? [frame] : [];
 	});
-	return frames.length === focus.nodeIds.length ? selectionBounds(frames) : null;
+	return frames.length === focus.itemIds.length ? selectionBounds(frames) : null;
 }
 function cameraForFocus(params, getFrame, surface) {
 	const rect = rectForCameraFocus(params.focus, getFrame);