@neta-art/cohub 2.14.1 → 3.0.0

package/dist/chunks/board.js

@@ -0,0 +1,392 @@
+//#region ../protocol/dist/board-constants.js
+const DEFAULT_BOARD_RENDER_LIMITS = {
+	particles: 2e4,
+	vertices: 5e5,
+	dynamicVertices: 15e4,
+	drawCalls: 400,
+	filterPasses: 24,
+	renderTexturePixels: 16777216,
+	textureBytes: 512 * 1024 * 1024,
+	bufferBytes: 256 * 1024 * 1024,
+	simulationSteps: 1e5
+};
+const BOARD_BUILTIN_CLIP_KINDS = [
+	"motion.keyframes",
+	"motion.path",
+	"draw.reveal",
+	"draw.handwrite",
+	"text.reveal",
+	"effects.particles",
+	"effects.trail",
+	"effects.impact",
+	"effects.flash",
+	"effects.color",
+	"camera.pan",
+	"camera.zoom",
+	"camera.shake"
+];
+const BOARD_BUILTIN_EFFECT_KINDS = ["effects.pulse", "effects.float"];
+const BOARD_BUILTIN_CAPABILITIES = [...BOARD_BUILTIN_CLIP_KINDS.map((id) => ({
+	kind: "clip",
+	id,
+	version: 1,
+	renderers: ["webgpu", "webgl"]
+})), ...BOARD_BUILTIN_EFFECT_KINDS.map((id) => ({
+	kind: "effect",
+	id,
+	version: 1,
+	renderers: ["webgpu", "webgl"]
+}))];
+//#endregion
+//#region src/board.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 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 bounds",
+					path: "params.bounds"
+				});
+				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"
+					});
+				}
+			}
+			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 points",
+					path: "params.points"
+				});
+			}
+			return diagnostics;
+		},
+		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;
+		},
+		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 {};
+			}
+		}
+	};
+}
+function stableHash(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	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 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 ?? {}
+	});
+}
+function flatten(input, offset, sequenceSeed, path) {
+	if (input.type === "clip") {
+		const clipSeed = input.clip.seed ?? `${sequenceSeed}:${path}`;
+		return {
+			duration: input.clip.duration,
+			clips: [{
+				...input.clip,
+				id: input.clip.id ?? stableId("clip", sequenceSeed, path),
+				start: offset,
+				seed: clipSeed
+			}]
+		};
+	}
+	if (input.type === "delay") {
+		const nested = flatten(input.child, offset + input.duration, sequenceSeed, `${path}.child`);
+		return {
+			duration: input.duration + nested.duration,
+			clips: nested.clips
+		};
+	}
+	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 (let index = 0; index < input.children.length; index += 1) {
+		const childOffset = input.type === "sequence" ? duration : input.type === "stagger" ? input.each * index : 0;
+		const nested = flatten(input.children[index], offset + childOffset, sequenceSeed, `${path}.${index}`);
+		clips.push(...nested.clips);
+		duration = input.type === "sequence" ? duration + nested.duration : Math.max(duration, childOffset + nested.duration);
+	}
+	return {
+		duration,
+		clips
+	};
+}
+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);
+	return {
+		sequence: {
+			id: input.id,
+			name: input.name,
+			duration: flattened.duration,
+			seed: input.seed,
+			restPose: input.restPose ?? {},
+			metadata: input.metadata ?? {}
+		},
+		clips: flattened.clips,
+		assetRefs: [...refs.values()]
+	};
+}
+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();
+	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;
+	}
+	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];
+	}
+	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);
+	}
+	validate(input) {
+		const diagnostics = [];
+		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()) {
+			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}`
+				});
+				continue;
+			}
+			diagnostics.push(...definition.validate?.(clip.params) ?? []);
+			const cost = { ...ZERO_COST };
+			addCost(cost, definition.estimateCost(clip.params, profile));
+			events.push({
+				at: clip.start,
+				direction: 1,
+				cost
+			}, {
+				at: clip.start + clip.duration,
+				direction: -1,
+				cost
+			});
+		}
+		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 limits = input.limits ?? DEFAULT_BOARD_LIMITS;
+		for (const key of Object.keys(limits)) if (peak[key] > limits[key]) diagnostics.push({
+			severity: "warning",
+			code: "RENDER_BUDGET_EXCEEDED",
+			message: `${key} peaks at ${peak[key]}, above ${limits[key]}`,
+			path: key,
+			adaptation: { quality: "lower" }
+		});
+		return {
+			valid: !diagnostics.some((item) => item.severity === "error"),
+			diagnostics,
+			peakCost: peak
+		};
+	}
+};
+function createBoardExtensionRegistry(input = {}) {
+	const registry = new BoardExtensionRegistry();
+	if (input.builtins !== false) for (const capability of BUILTIN_CAPABILITIES) registry.register(builtinDefinition(capability));
+	return registry;
+}
+//#endregion
+export { createBoardExtensionRegistry as a, compileSequence as i, DEFAULT_BOARD_LIMITS as n, timeline as o, clip as r, BoardExtensionRegistry as t };