@neta-art/cohub 10.0.0 → 11.1.0

package/dist/board/model/replay.d.ts

@@ -3,7 +3,7 @@ import { RequestSource } from "../../protocol/dist/provenance.js";
 import { BoardHistoryPage } from "../../protocol/dist/board.js";
 import "../../protocol/dist/index.js";
 //#region src/board/model/replay.d.ts
-type BoardReplayActorKind = "human" | "cli" | "agent";
+type BoardReplayActorKind = "human" | "cli" | "agent" | "task";
 type BoardReplayEntry = {
   version: number;
   actorId: string;

package/dist/board/model/replay.js

@@ -3,6 +3,7 @@ import { applyBoardDelta } from "../../protocol/dist/board-patch.js";
 function boardReplayActorKind(source) {
 	if (!source) return "human";
 	if (source.toolCallId) return "agent";
+	if (source.via === "task") return "task";
 	return source.via === "cli" ? "cli" : "human";
 }
 function entryOf(transaction) {

package/dist/board/model/sampling.d.ts

@@ -0,0 +1,19 @@
+import { BoardDocument } from "../../protocol/dist/board-model.js";
+import { BoardFrame } from "../../protocol/dist/board-layout.js";
+import "../../protocol/dist/index.js";
+import { BoardViewport, Size } from "./geometry.js";
+import { BoardScene } from "./scene.js";
+import { BoardCameraOverride, BoardEvaluateOptions, BoardEvaluation } from "./animation.js";
+//#region src/board/model/sampling.d.ts
+declare function createBoardAnimationSampler(document: BoardDocument, animation: string | null, options?: BoardEvaluateOptions): {
+  frameAt(id: string, time: number): BoardFrame | undefined;
+  at(time: number): {
+    document: BoardDocument;
+    evaluation: BoardEvaluation;
+    scene: BoardScene;
+  };
+};
+type BoardAnimationSampler = ReturnType<typeof createBoardAnimationSampler>;
+declare function resolveBoardAnimationCamera(override: BoardCameraOverride, bounds: (id: string) => BoardFrame | undefined, surface: Size, time: number, base?: BoardViewport): BoardViewport;
+//#endregion
+export { BoardAnimationSampler, createBoardAnimationSampler, resolveBoardAnimationCamera };

package/dist/board/model/sampling.js

@@ -0,0 +1,96 @@
+import { arrowBindings } from "../../protocol/dist/board-layout.js";
+import { cameraForFocus, cameraForState } from "./geometry.js";
+import { applyBoardEvaluation, boardAnimationTime, compileBoardAnimations, evaluateBoardAnimations } from "./animation.js";
+import { buildBoardScene } from "./scene.js";
+//#region src/board/model/sampling.ts
+function createBoardAnimationSampler(document, animation, options = {}) {
+	const selected = animation ? document.animations[animation] : void 0;
+	if (animation && !selected) throw new Error(`Animation ${animation} does not exist.`);
+	const compiled = compileBoardAnimations(document);
+	const cache = /* @__PURE__ */ new Map();
+	const geometry = /* @__PURE__ */ new Map();
+	function sample(time) {
+		const times = /* @__PURE__ */ new Map();
+		for (const [id, entry] of compiled.animations) if (entry.header.play === "always") times.set(id, boardAnimationTime(entry.header, time) ?? 0);
+		if (animation && selected) times.set(animation, Math.min(time, selected.duration));
+		const evaluation = evaluateBoardAnimations(compiled, times, options);
+		return {
+			document: applyBoardEvaluation(document, evaluation),
+			evaluation
+		};
+	}
+	function stateAt(time) {
+		if (!Number.isFinite(time) || time < 0) throw new Error("Animation time must be finite and non-negative.");
+		let value = cache.get(time);
+		if (!value) {
+			value = sample(time);
+			const oldest = cache.keys().next().value;
+			if (cache.size >= 64 && oldest !== void 0) cache.delete(oldest);
+			cache.set(time, value);
+		}
+		return value;
+	}
+	let current;
+	return {
+		frameAt(id, time) {
+			const key = `${time}:${id}`;
+			if (geometry.has(key)) return geometry.get(key);
+			const sampled = stateAt(time).document;
+			const items = {};
+			const pending = [id];
+			while (pending.length) {
+				const next = pending.pop();
+				if (!next || items[next]) continue;
+				const item = sampled.items[next];
+				if (!item) continue;
+				items[next] = item;
+				if (item.parent) pending.push(item.parent);
+				pending.push(...arrowBindings(item));
+			}
+			const frame = buildBoardScene({
+				...sampled,
+				items
+			}).get(id)?.frame;
+			if (geometry.size >= 2048) geometry.clear();
+			geometry.set(key, frame);
+			return frame;
+		},
+		at(time) {
+			if (current?.time === time) return current.value;
+			const sampled = stateAt(time);
+			const value = {
+				...sampled,
+				scene: buildBoardScene(sampled.document)
+			};
+			current = {
+				time,
+				value
+			};
+			return value;
+		}
+	};
+}
+function resolveBoardAnimationCamera(override, bounds, surface, time, base = {
+	x: 0,
+	y: 0,
+	zoom: 1
+}) {
+	let camera = override.focus === void 0 ? base : cameraForFocus(override.focus, bounds, surface, { padding: 48 }) ?? base;
+	if (override.zoom !== void 0) camera = {
+		...camera,
+		zoom: override.zoom
+	};
+	if (override.center) camera = cameraForState({
+		centerX: override.center.x,
+		centerY: override.center.y,
+		zoom: camera.zoom
+	}, surface);
+	if (override.shake) camera = {
+		...camera,
+		x: camera.x + Math.sin(time / 1e3 * 91.3) * override.shake,
+		y: camera.y + Math.cos(time / 1e3 * 77.9) * override.shake
+	};
+	return camera;
+}
+//#endregion
+export { createBoardAnimationSampler, resolveBoardAnimationCamera };

package/dist/board/model/script-example.d.ts

@@ -0,0 +1,4 @@
+//#region src/board/model/script-example.d.ts
+declare const BOARD_SCRIPT_DRAWING_EXAMPLE = "export const animated = true;\n\nexport const parameters = {\n  amplitude: { type: \"number\", label: \"Amplitude\", default: 40, min: 0, max: 120 }\n};\n\nexport function draw(ctx, { t, width, height, params }) {\n  ctx.strokeStyle = \"#e67845\";\n  ctx.lineWidth = 3;\n  ctx.beginPath();\n  for (let x = 0; x <= width; x += 2) {\n    const y = height / 2 + Math.sin(x / 40 - t / 800) * params.amplitude;\n    if (x === 0) ctx.moveTo(x, y);\n    else ctx.lineTo(x, y);\n  }\n  ctx.stroke();\n}\n";
+//#endregion
+export { BOARD_SCRIPT_DRAWING_EXAMPLE };

package/dist/board/model/script-example.js

@@ -0,0 +1,21 @@
+//#region src/board/model/script-example.ts
+const BOARD_SCRIPT_DRAWING_EXAMPLE = `export const animated = true;
+
+export const parameters = {
+  amplitude: { type: "number", label: "Amplitude", default: 40, min: 0, max: 120 }
+};
+
+export function draw(ctx, { t, width, height, params }) {
+  ctx.strokeStyle = "#e67845";
+  ctx.lineWidth = 3;
+  ctx.beginPath();
+  for (let x = 0; x <= width; x += 2) {
+    const y = height / 2 + Math.sin(x / 40 - t / 800) * params.amplitude;
+    if (x === 0) ctx.moveTo(x, y);
+    else ctx.lineTo(x, y);
+  }
+  ctx.stroke();
+}
+`;
+//#endregion
+export { BOARD_SCRIPT_DRAWING_EXAMPLE };

package/dist/board/model/script-hit.d.ts

@@ -0,0 +1,27 @@
+import { BoardViewport, WorldPoint } from "./geometry.js";
+import { BoardScriptHit, BoardScriptOutput } from "./script.js";
+import { BoardScene, BoardSceneItem } from "./scene.js";
+//#region src/board/model/script-hit.d.ts
+declare function resolveBoardScriptHit(scene: BoardScene, owner: string, hit: BoardScriptHit): {
+  id: string;
+  item: BoardSceneItem;
+  rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  } & {
+    label?: string;
+    cursor?: string;
+  };
+} | null;
+declare function boardScriptHitVisible(scene: BoardScene, hit: NonNullable<ReturnType<typeof resolveBoardScriptHit>>, camera: BoardViewport, surface: {
+  width: number;
+  height: number;
+}): boolean;
+declare function boardScriptTarget(scene: BoardScene, candidates: readonly string[], point: WorldPoint, outputs: ReadonlyMap<string, BoardScriptOutput>, hitTest: (item: BoardSceneItem, point: WorldPoint) => boolean): {
+  owner: string;
+  target: string;
+} | null;
+//#endregion
+export { boardScriptHitVisible, boardScriptTarget, resolveBoardScriptHit };

package/dist/board/model/script-hit.js

@@ -0,0 +1,109 @@
+import { applyMatrix, invertMatrix } from "../../protocol/dist/board-layout.js";
+import { frameContainsPoint } from "./geometry.js";
+import { scriptTemporaryPrefix } from "./script-scene.js";
+//#region src/board/model/script-hit.ts
+function resolveBoardScriptHit(scene, owner, hit) {
+	const id = "item" in hit ? `${scriptTemporaryPrefix(owner)}${hit.item}` : owner;
+	const item = scene.get(id);
+	if (!item || scene.opacity(id) <= 0) return null;
+	const box = scene.layout.box(id);
+	return {
+		id,
+		item,
+		rect: "x" in hit ? hit : {
+			x: 0,
+			y: 0,
+			width: box.width,
+			height: box.height
+		}
+	};
+}
+function boardScriptHitVisible(scene, hit, camera, surface) {
+	const { x, y, width, height } = hit.rect;
+	if (width <= 0 || height <= 0) return false;
+	const matrix = scene.layout.matrix(hit.id);
+	const corners = [
+		applyMatrix(matrix, {
+			x,
+			y
+		}),
+		applyMatrix(matrix, {
+			x: x + width,
+			y
+		}),
+		applyMatrix(matrix, {
+			x,
+			y: y + height
+		}),
+		applyMatrix(matrix, {
+			x: x + width,
+			y: y + height
+		})
+	];
+	const xs = corners.map((point) => point.x * camera.zoom + camera.x);
+	const ys = corners.map((point) => point.y * camera.zoom + camera.y);
+	return Math.max(...xs) > 0 && Math.min(...xs) < surface.width && Math.max(...ys) > 0 && Math.min(...ys) < surface.height;
+}
+const bindings = /* @__PURE__ */ new WeakMap();
+function bindingsFor(owner, output) {
+	const cached = bindings.get(output);
+	if (cached?.owner === owner) return cached.byItem;
+	const byItem = /* @__PURE__ */ new Map();
+	for (const [target, hit] of Object.entries(output.hits)) {
+		const id = "item" in hit ? `${scriptTemporaryPrefix(owner)}${hit.item}` : owner;
+		const list = byItem.get(id) ?? [];
+		list.push({
+			owner,
+			target,
+			hit
+		});
+		byItem.set(id, list);
+	}
+	bindings.set(output, {
+		owner,
+		byItem
+	});
+	return byItem;
+}
+function boardScriptTarget(scene, candidates, point, outputs, hitTest) {
+	const declared = [...outputs].map(([owner, output]) => bindingsFor(owner, output));
+	const prefixes = [...outputs.keys()].map(scriptTemporaryPrefix);
+	for (const id of [...candidates].sort((a, b) => scene.indexOf(b) - scene.indexOf(a))) {
+		const item = scene.get(id);
+		if (!item || scene.opacity(id) <= 0) continue;
+		let parent = item.parent;
+		let clipped = false;
+		for (let depth = 0; parent && depth < 64; depth++) {
+			const ancestor = scene.get(parent);
+			if (!ancestor) break;
+			if (ancestor.type === "frame" && ancestor.props.clip && !frameContainsPoint(ancestor.frame, point)) {
+				clipped = true;
+				break;
+			}
+			parent = ancestor.parent;
+		}
+		if (clipped) continue;
+		for (const byItem of declared) {
+			const hits = byItem.get(id);
+			if (!hits) continue;
+			const local = applyMatrix(invertMatrix(scene.layout.matrix(id)), point);
+			for (let i = hits.length - 1; i >= 0; i--) {
+				const binding = hits[i];
+				if (!binding) continue;
+				const resolved = resolveBoardScriptHit(scene, binding.owner, binding.hit);
+				if (!resolved) continue;
+				const r = resolved.rect;
+				if (local.x >= r.x && local.y >= r.y && local.x <= r.x + r.width && local.y <= r.y + r.height && ("x" in binding.hit || hitTest(item, point))) return {
+					owner: binding.owner,
+					target: binding.target
+				};
+			}
+		}
+		if (prefixes.some((prefix) => id.startsWith(prefix))) continue;
+		if (item.type === "frame" && item.props.decoration === "none") continue;
+		if (hitTest(item, point)) return null;
+	}
+	return null;
+}
+//#endregion
+export { boardScriptHitVisible, boardScriptTarget, resolveBoardScriptHit };

package/dist/board/model/script-index.d.ts

@@ -0,0 +1,7 @@
+import { BoardDocument, BoardItem } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+//#region src/board/model/script-index.d.ts
+declare function boardScriptItems(document: Pick<BoardDocument, "items">): readonly (readonly [string, BoardItem])[];
+declare function hasBoardScripts(document: Pick<BoardDocument, "items">): boolean;
+//#endregion
+export { boardScriptItems, hasBoardScripts };

package/dist/board/model/script-index.js

@@ -0,0 +1,15 @@
+//#region src/board/model/script-index.ts
+const scriptsByItems = /* @__PURE__ */ new WeakMap();
+function boardScriptItems(document) {
+	let scripts = scriptsByItems.get(document.items);
+	if (!scripts) {
+		scripts = Object.entries(document.items).filter(([, item]) => item.script?.enabled);
+		scriptsByItems.set(document.items, scripts);
+	}
+	return scripts;
+}
+function hasBoardScripts(document) {
+	return boardScriptItems(document).length > 0;
+}
+//#endregion
+export { boardScriptItems, hasBoardScripts };

package/dist/board/model/script-observers.d.ts

@@ -0,0 +1,18 @@
+import { BoardDocument } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { BoardScriptEvent, BoardScriptOutput, BoardScriptView } from "./script.js";
+//#region src/board/model/script-observers.d.ts
+declare function createBoardScriptObservers(send: (owner: string, event: BoardScriptEvent) => void): {
+  readonly size: number;
+  readonly transforms: boolean;
+  update(owner: string, output: BoardScriptOutput | null): void;
+  sync(document: BoardDocument, selection: readonly string[], readView: () => BoardScriptView): void;
+  transform(document: BoardDocument, event: {
+    ids: readonly string[];
+    operation: string;
+    cancelled: boolean;
+  }): void;
+  clear(): void;
+};
+//#endregion
+export { createBoardScriptObservers };

package/dist/board/model/script-observers.js

@@ -0,0 +1,92 @@
+import { boardScriptScope } from "./script-scene.js";
+//#region src/board/model/script-observers.ts
+const EVENTS = [
+	"viewchange",
+	"selectionchange",
+	"transformend"
+];
+function createBoardScriptObservers(send) {
+	const subscribers = /* @__PURE__ */ new Map();
+	function scope(owner, entry, document) {
+		if (entry.document !== document) {
+			entry.scope = boardScriptScope(document, owner);
+			entry.document = document;
+			entry.selection = void 0;
+		}
+		return entry.scope;
+	}
+	return {
+		get size() {
+			return subscribers.size;
+		},
+		get transforms() {
+			return [...subscribers.values()].some((entry) => entry.listens.has("transformend"));
+		},
+		update(owner, output) {
+			const listens = new Set(EVENTS.filter((type) => output?.listens.includes(type)));
+			if (!listens.size) {
+				subscribers.delete(owner);
+				return;
+			}
+			const entry = subscribers.get(owner) ?? {
+				listens,
+				scope: /* @__PURE__ */ new Set()
+			};
+			if (!listens.has("viewchange")) entry.view = void 0;
+			if (!listens.has("selectionchange")) {
+				entry.selection = void 0;
+				entry.selected = void 0;
+			}
+			entry.listens = listens;
+			subscribers.set(owner, entry);
+		},
+		sync(document, selection, readView) {
+			let view;
+			let key;
+			for (const [owner, entry] of subscribers) {
+				if (entry.listens.has("viewchange")) {
+					view ??= readView();
+					key ??= JSON.stringify(view);
+					if (entry.view !== key) {
+						entry.view = key;
+						send(owner, {
+							type: "viewchange",
+							data: view
+						});
+					}
+				}
+				if (entry.listens.has("selectionchange")) {
+					const allowed = scope(owner, entry, document);
+					if (entry.selection === selection) continue;
+					entry.selection = selection;
+					const ids = selection.filter((id) => allowed.has(id));
+					if (entry.selected && ids.length === entry.selected.length && ids.every((id, i) => id === entry.selected?.[i])) continue;
+					entry.selected = ids;
+					send(owner, {
+						type: "selectionchange",
+						data: { ids }
+					});
+				}
+			}
+		},
+		transform(document, event) {
+			for (const [owner, entry] of subscribers) {
+				if (!entry.listens.has("transformend")) continue;
+				const allowed = scope(owner, entry, document);
+				const ids = event.ids.filter((id) => allowed.has(id));
+				if (ids.length) send(owner, {
+					type: "transformend",
+					data: {
+						...event,
+						ids
+					}
+				});
+			}
+		},
+		clear() {
+			subscribers.clear();
+		}
+	};
+}
+//#endregion
+export { createBoardScriptObservers };

package/dist/board/model/script-scene.d.ts

@@ -0,0 +1,24 @@
+import { BoardDocument, BoardItem, BoardPatch } from "../../protocol/dist/board-model.js";
+import { BoardScriptOutput } from "./script.js";
+import { BoardScene } from "./scene.js";
+//#region src/board/model/script-scene.d.ts
+declare function boardScriptScope(document: Pick<BoardDocument, "items">, id: string): Set<string>;
+declare function validateBoardScriptOutput(output: BoardScriptOutput, scope: ReadonlySet<string>): void;
+declare function validateBoardScriptCommit(document: BoardDocument, id: string, patch: BoardPatch): void;
+declare function scriptTemporaryPrefix(owner: string): string;
+type PreparedOutput = {
+  document: BoardDocument;
+  owner: string;
+  rootId: string;
+  items: Map<string, BoardItem>;
+  presented: Map<string, {
+    base: BoardItem;
+    item: BoardItem;
+  }>;
+};
+declare function prepareBoardScriptOutput(document: BoardDocument, owner: string, output: BoardScriptOutput): PreparedOutput;
+declare function composeBoardScriptItems(document: BoardDocument, scene: BoardScene, outputs: ReadonlyMap<string, BoardScriptOutput>, incoming?: ReadonlyMap<string, BoardItem>, screen?: {
+  zoom: number;
+}, onError?: (owner: string, error: unknown) => void, gestureLayout?: BoardScene["layout"]): Map<string, BoardItem>;
+//#endregion
+export { boardScriptScope, composeBoardScriptItems, prepareBoardScriptOutput, scriptTemporaryPrefix, validateBoardScriptCommit, validateBoardScriptOutput };