@neta-art/cohub 8.23.0 → 9.0.0

package/dist/board/runtime/board-player.js

@@ -0,0 +1,161 @@
+import { boardAnimationTime, compileBoardAnimations, evaluateBoardAnimations } from "../animation.js";
+import { boardPresetTracks, isBoardPresetName } from "../presets.js";
+//#region src/board/runtime/board-player.ts
+const ENTER_ANIMATION = "\0enter";
+const ENTER_STAGGER_MS = 45;
+const ENTER_MAX_ITEMS = 80;
+function playbackTimeAt(playback, document, now) {
+	const animation = document.animations[playback.animationId];
+	if (!animation || playback.status === "stopped") return null;
+	if (playback.status !== "playing") return Math.min(playback.position, animation.duration);
+	let position = playback.position + Math.max(0, now - playback.effectiveAt) * playback.timeScale;
+	const pause = animation.markers.find((marker) => marker.pause && marker.at > playback.position && marker.at <= position);
+	if (pause) return pause.at;
+	if (animation.loop || animation.play === "always") return animation.duration > 0 ? position % animation.duration : 0;
+	position = Math.min(position, animation.duration);
+	return animation.end === "reset" && position >= animation.duration ? null : position;
+}
+function createBoardPlayer(options = {}) {
+	let document = null;
+	let compiled = null;
+	let openedAt = performance.now();
+	let entrance = null;
+	function compile(next) {
+		if (document?.animations === next.animations && document?.items === next.items && compiled) return compiled;
+		document = next;
+		let source = next;
+		const preset = next.board.enter?.preset;
+		if (entrance && preset && isBoardPresetName(preset)) {
+			const tracks = boardPresetTracks(preset, {
+				targets: entrance.ids,
+				stagger: ENTER_STAGGER_MS,
+				...next.board.enter?.duration ? { duration: next.board.enter.duration } : {}
+			});
+			source = {
+				...next,
+				animations: {
+					...next.animations,
+					[ENTER_ANIMATION]: {
+						duration: entrance.duration,
+						play: "manual",
+						delay: 0,
+						loop: false,
+						end: "reset",
+						markers: [],
+						tracks
+					}
+				}
+			};
+		}
+		compiled = compileBoardAnimations(source);
+		return compiled;
+	}
+	return {
+		reset() {
+			openedAt = performance.now();
+			entrance = null;
+			compiled = null;
+		},
+		enter(ids, current) {
+			if (!current.board.enter?.preset || ids.length === 0 || ids.length > ENTER_MAX_ITEMS) return;
+			const duration = (current.board.enter?.duration ?? 700) + ENTER_STAGGER_MS * ids.length;
+			entrance = {
+				ids: [...ids],
+				startedAt: performance.now(),
+				duration
+			};
+			compiled = null;
+		},
+		frame(current, playback, now, wallNow, exclude) {
+			if (entrance && now - entrance.startedAt > entrance.duration) {
+				entrance = null;
+				compiled = null;
+			}
+			const animations = compile(current);
+			const times = /* @__PURE__ */ new Map();
+			let running = false;
+			for (const [id, animation] of animations.animations) {
+				if (id === exclude) continue;
+				const header = animation.header;
+				if (header.play === "always") {
+					times.set(id, boardAnimationTime(header, wallNow) ?? 0);
+					running = true;
+				} else if (header.play === "auto") {
+					const time = boardAnimationTime(header, now - openedAt);
+					if (time !== null) times.set(id, time);
+					if (time !== null && time < header.duration) running = true;
+				}
+			}
+			let playbackTime = null;
+			if (playback && playback.animationId !== exclude) {
+				playbackTime = playbackTimeAt(playback, current, wallNow);
+				if (playbackTime !== null) {
+					times.set(playback.animationId, playbackTime);
+					if (playback.status === "playing") running = true;
+				}
+			}
+			if (entrance) {
+				times.set(ENTER_ANIMATION, now - entrance.startedAt);
+				running = true;
+			}
+			const evaluation = times.size ? evaluateBoardAnimations(animations, times, options) : null;
+			return {
+				items: evaluation?.items ?? /* @__PURE__ */ new Map(),
+				camera: evaluation?.camera ?? {},
+				time: playbackTime ?? now - openedAt,
+				playbackTime,
+				running
+			};
+		}
+	};
+}
+function nextLocalPlayback(current, command, document, now = Date.now()) {
+	const position = current ? playbackTimeAt(current, document, now) ?? 0 : 0;
+	const base = {
+		effectiveAt: now,
+		commandId: command.commandId,
+		revision: (current?.revision ?? 0) + 1
+	};
+	switch (command.type) {
+		case "play": return {
+			playbackId: crypto.randomUUID(),
+			animationId: command.animationId,
+			animationRevision: 0,
+			status: "playing",
+			position: command.position ?? 0,
+			timeScale: command.timeScale ?? 1,
+			seed: command.seed ?? "local",
+			...base
+		};
+		case "pause": return current ? {
+			...current,
+			...base,
+			status: "paused",
+			position
+		} : null;
+		case "resume": return current ? {
+			...current,
+			...base,
+			status: "playing",
+			position
+		} : null;
+		case "seek": return current ? {
+			...current,
+			...base,
+			position: command.position
+		} : null;
+		case "next": {
+			if (!current) return null;
+			const after = (document.animations[current.animationId]?.markers ?? []).find((marker) => marker.pause && marker.at > position + 1);
+			return {
+				...current,
+				...base,
+				status: "playing",
+				position: after ? position + 1 : position
+			};
+		}
+		case "stop": return null;
+	}
+}
+//#endregion
+export { createBoardPlayer, nextLocalPlayback, playbackTimeAt };

package/dist/board/task.d.ts

@@ -1,19 +1,11 @@
-import { BoardTaskArtifact, BoardTaskSnapshot } from "../protocol/dist/board-document.js";
+import { BoardTaskArtifact, BoardTaskSnapshot } from "../protocol/dist/board-model.js";
+import "../protocol/dist/index.js";
 import { TaskRunRecord } from "../types.js";
 //#region src/board/task.d.ts
-/**
- * Group provider blocks into user-facing works. A cover belongs to the media
- * it depicts (see `generationCovers`) instead of becoming a competing image.
- */
 declare function taskArtifacts(blocks: Record<string, unknown>[]): BoardTaskArtifact[];
-/** Highest-value artifact first, with provider order as the stable final tie. */
 declare function rankedTaskArtifacts(artifacts: readonly BoardTaskArtifact[]): BoardTaskArtifact[];
 declare function featuredTaskArtifact(artifacts: readonly BoardTaskArtifact[]): BoardTaskArtifact | undefined;
 declare function taskArtifactPreviewUrl(artifact: BoardTaskArtifact | undefined): string | undefined;
-/**
- * Project an authoritative TaskRun into a small, replaceable Board display cache.
- * Raw payloads, complete results and inline media are never copied into the Board.
- */
 declare function taskRunToBoardTaskSnapshot(run: TaskRunRecord): BoardTaskSnapshot;
 //#endregion
 export { featuredTaskArtifact, rankedTaskArtifacts, taskArtifactPreviewUrl, taskArtifacts, taskRunToBoardTaskSnapshot };

package/dist/board/task.js

@@ -1,4 +1,4 @@
-import "../protocol/dist/board-document.js";
+import "../protocol/dist/board-model.js";
 import { blockDurationMs, blockIdentity, blockMimeType, blockNaturalSize, blockPreviewUrl, blockText, blockTitle, blockUrl, cleanExcerpt, generationCovers, generationOutput, generationPrompt, taskData } from "../generation-blocks.js";
 //#region src/board/task.ts
 function artifactId(base, used, suffix) {
@@ -12,10 +12,6 @@ function artifactId(base, used, suffix) {
 	used.add(candidate);
 	return candidate;
 }
-/**
-* Group provider blocks into user-facing works. A cover belongs to the media
-* it depicts (see `generationCovers`) instead of becoming a competing image.
-*/
 function taskArtifacts(blocks) {
 	const covers = new Map([...generationCovers(blocks)].filter(([media]) => Boolean(blockUrl(blocks[media] ?? {}))));
 	const coverIndexes = new Set(covers.values());
@@ -123,7 +119,6 @@ function compareArtifacts(a, b) {
 	}
 	return 0;
 }
-/** Highest-value artifact first, with provider order as the stable final tie. */
 function rankedTaskArtifacts(artifacts) {
 	return artifacts.map((artifact, index) => ({
 		artifact,
@@ -142,10 +137,6 @@ function taskArtifactPreviewUrl(artifact) {
 function taskTypeTitle(taskType) {
 	return taskType.replace(/[._-]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
 }
-/**
-* Project an authoritative TaskRun into a small, replaceable Board display cache.
-* Raw payloads, complete results and inline media are never copied into the Board.
-*/
 function taskRunToBoardTaskSnapshot(run) {
 	const data = taskData(run);
 	const blocks = run.taskType === "generation" ? generationOutput(run) : [];