@neta-art/cohub 11.0.0 → 11.1.0

package/dist/board/model/items/create.js

@@ -1,11 +1,11 @@
-import { parseBoardItem } from "../../../protocol/dist/board-model.js";
+import { BoardMediaOriginSchema, parseBoardItem } from "../../../protocol/dist/board-model.js";
 import { pointsRect } from "../../../protocol/dist/board-layout.js";
+import { featuredTaskArtifact } from "../../../protocol/dist/board-task.js";
 import { quantizeDrawCoordinate } from "../draw-input.js";
 import { getMediaResourceTitle, inferBoardMediaKind } from "../media.js";
 import { fileStem } from "../file-snapshot.js";
 import { filePreviewKind } from "../file-preview.js";
 import { DEFAULT_BOARD_TOOL_STYLES } from "../tool-styles.js";
-import { featuredTaskArtifact } from "../task.js";
 import { createBoardItemId } from "./id.js";
 //#region src/board/model/items/create.ts
 const DEFAULT_MEDIA_SIZE = {
@@ -122,14 +122,14 @@ function createMediaBoardItem(path, x, y, snapshot = {}, id = createBoardItemId(
 	};
 }
 const createFileNodeForPath = createMediaBoardItem;
-function createTaskBoardItem(taskRunId, snapshot, x, y, metadata, id = createBoardItemId()) {
+function createTaskBoardItem(taskRunId, snapshot, x, y, metadata, id = createBoardItemId(), aspect) {
 	const artifact = featuredTaskArtifact(snapshot.artifacts);
 	const visual = artifact?.type === "image" || artifact?.type === "video" ? artifact : null;
 	return {
 		id,
 		item: item({
 			type: "task",
-			...centered(x, y, visual ? mediaFrameSize(visual.naturalWidth, visual.naturalHeight, 480, DEFAULT_TASK_MEDIA_SIZE) : artifact?.type === "audio" ? DEFAULT_TASK_MEDIA_SIZE : DEFAULT_TASK_SIZE),
+			...centered(x, y, visual ? mediaFrameSize(visual.naturalWidth, visual.naturalHeight, 480, DEFAULT_TASK_MEDIA_SIZE) : artifact?.type === "audio" ? DEFAULT_TASK_MEDIA_SIZE : expectedTaskSize(aspect)),
 			...metadata ? { metadata } : {},
 			props: {
 				taskRunId,
@@ -138,6 +138,15 @@ function createTaskBoardItem(taskRunId, snapshot, x, y, metadata, id = createBoa
 		})
 	};
 }
+function expectedTaskSize(aspect) {
+	if (!aspect || !Number.isFinite(aspect) || aspect <= 0) return { ...DEFAULT_TASK_SIZE };
+	const width = DEFAULT_TASK_MEDIA_SIZE.width;
+	const height = Math.round(width / aspect);
+	return height > 0 && height <= width * 4 ? {
+		width,
+		height
+	} : { ...DEFAULT_TASK_SIZE };
+}
 function createTextBoardItem(text, x, y, color = DEFAULT_BOARD_TOOL_STYLES.text.color, id = createBoardItemId()) {
 	return {
 		id,
@@ -268,5 +277,116 @@ function titleForBoardItem(value) {
 		default: return value.type;
 	}
 }
+const RESULT_GAP = 24;
+const RESULT_COLUMNS = 4;
+const RESULT_TEXT_WIDTH = 320;
+const RESULT_MIN_HEIGHT = 120;
+const RESULT_MAX_HEIGHT = 480;
+function boardItemOrigin(item) {
+	if (item.type === "image" || item.type === "video" || item.type === "audio") return item.props.origin ?? null;
+	if (item.type !== "text") return null;
+	const parsed = BoardMediaOriginSchema.safeParse(item.metadata?.origin);
+	return parsed.success ? parsed.data : null;
+}
+const boardOriginKey = (origin) => `${origin.taskRunId}/${origin.artifactId}`;
+function createTaskResultItems(input) {
+	const rowHeight = Math.min(RESULT_MAX_HEIGHT, Math.max(RESULT_MIN_HEIGHT, input.frame.height));
+	const left = input.frame.x + input.frame.width + 48;
+	const entries = [];
+	let column = 0;
+	let x = left;
+	let y = input.frame.y;
+	let tallest = 0;
+	for (const artifact of input.artifacts) {
+		if (input.existing?.has(boardOriginKey({
+			taskRunId: input.taskRunId,
+			artifactId: artifact.id
+		}))) continue;
+		if (column === RESULT_COLUMNS) {
+			column = 0;
+			x = left;
+			y += tallest + RESULT_GAP;
+			tallest = 0;
+		}
+		const entry = taskResultItem(input.taskRunId, artifact, x, y, rowHeight);
+		const size = "size" in entry.item && entry.item.size ? entry.item.size : {
+			width: RESULT_TEXT_WIDTH,
+			height: rowHeight
+		};
+		entries.push(entry);
+		x += size.width + RESULT_GAP;
+		tallest = Math.max(tallest, size.height);
+		column += 1;
+	}
+	return entries;
+}
+function taskResultItem(taskRunId, artifact, x, y, rowHeight) {
+	const id = createBoardItemId();
+	const origin = {
+		taskRunId,
+		artifactId: artifact.id
+	};
+	if (artifact.type === "text") return {
+		id,
+		item: item({
+			type: "text",
+			position: {
+				x,
+				y
+			},
+			metadata: { origin },
+			props: {
+				text: artifact.textExcerpt,
+				width: RESULT_TEXT_WIDTH
+			}
+		})
+	};
+	const snapshot = cleanSnapshot({
+		title: artifact.title,
+		mimeType: artifact.mimeType,
+		...artifact.type !== "audio" ? {
+			naturalWidth: artifact.naturalWidth,
+			naturalHeight: artifact.naturalHeight
+		} : {},
+		...artifact.type !== "image" ? { durationMs: artifact.durationMs } : {}
+	});
+	if (artifact.type === "audio") return {
+		id,
+		item: item({
+			type: "audio",
+			position: {
+				x,
+				y
+			},
+			size: DEFAULT_AUDIO_SIZE,
+			props: {
+				src: artifact.url,
+				snapshot,
+				origin
+			}
+		})
+	};
+	const fallback = artifact.type === "video" ? DEFAULT_VIDEO_SIZE : DEFAULT_MEDIA_SIZE;
+	const ratio = artifact.naturalWidth && artifact.naturalHeight ? artifact.naturalWidth / artifact.naturalHeight : fallback.width / fallback.height;
+	return {
+		id,
+		item: item({
+			type: artifact.type,
+			position: {
+				x,
+				y
+			},
+			size: {
+				width: Math.round(rowHeight * ratio),
+				height: rowHeight
+			},
+			props: {
+				src: artifact.url,
+				snapshot,
+				origin
+			}
+		})
+	};
+}
 //#endregion
-export { createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem };
+export { boardItemOrigin, boardOriginKey, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTaskResultItems, createTextBoardItem, mediaFrameSize, titleForBoardItem };

package/dist/board/model/items/index.d.ts

@@ -1,6 +1,6 @@
 import { BoardItemCapabilities, BoardItemDefinition, BoardItemOf, BoardItemResizeMode, FULL_CAPABILITIES, defineBoardItem } from "./definition.js";
 import { builtinBoardItems } from "./builtin.js";
-import { BoardAppMetadata, BoardItemEntry, BoardMediaItemKind, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem } from "./create.js";
+import { BoardAppMetadata, BoardItemEntry, BoardMediaItemKind, boardItemOrigin, boardOriginKey, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTaskResultItems, createTextBoardItem, mediaFrameSize, titleForBoardItem } from "./create.js";
 import { createBoardEntityId, createBoardItemId } from "./id.js";
 import { BoardItemInput, BoardRegistry, createBoardRegistry, defaultBoardRegistry } from "./registry.js";
-export { BoardAppMetadata, BoardItemCapabilities, BoardItemDefinition, BoardItemEntry, BoardItemInput, BoardItemOf, BoardItemResizeMode, BoardMediaItemKind, BoardRegistry, FULL_CAPABILITIES, builtinBoardItems, createAppBoardItem, createArrowBoardItem, createBoardEntityId, createBoardItemId, createBoardRegistry, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, defaultBoardRegistry, defineBoardItem, mediaFrameSize, titleForBoardItem };
+export { BoardAppMetadata, BoardItemCapabilities, BoardItemDefinition, BoardItemEntry, BoardItemInput, BoardItemOf, BoardItemResizeMode, BoardMediaItemKind, BoardRegistry, FULL_CAPABILITIES, boardItemOrigin, boardOriginKey, builtinBoardItems, createAppBoardItem, createArrowBoardItem, createBoardEntityId, createBoardItemId, createBoardRegistry, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTaskResultItems, createTextBoardItem, defaultBoardRegistry, defineBoardItem, mediaFrameSize, titleForBoardItem };

package/dist/board/model/items/index.js

@@ -1,6 +1,6 @@
 import { FULL_CAPABILITIES, defineBoardItem } from "./definition.js";
 import { builtinBoardItems } from "./builtin.js";
 import { createBoardEntityId, createBoardItemId } from "./id.js";
-import { createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, mediaFrameSize, titleForBoardItem } from "./create.js";
+import { boardItemOrigin, boardOriginKey, createAppBoardItem, createArrowBoardItem, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTaskResultItems, createTextBoardItem, mediaFrameSize, titleForBoardItem } from "./create.js";
 import { createBoardRegistry, defaultBoardRegistry } from "./registry.js";
-export { FULL_CAPABILITIES, builtinBoardItems, createAppBoardItem, createArrowBoardItem, createBoardEntityId, createBoardItemId, createBoardRegistry, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTextBoardItem, defaultBoardRegistry, defineBoardItem, mediaFrameSize, titleForBoardItem };
+export { FULL_CAPABILITIES, boardItemOrigin, boardOriginKey, builtinBoardItems, createAppBoardItem, createArrowBoardItem, createBoardEntityId, createBoardItemId, createBoardRegistry, createDrawBoardItem, createFileNodeForPath, createFrameBoardItem, createMediaBoardItem, createShapeBoardItem, createTaskBoardItem, createTaskResultItems, createTextBoardItem, defaultBoardRegistry, defineBoardItem, mediaFrameSize, titleForBoardItem };

package/dist/board/model/media-playback.js

@@ -1,6 +1,6 @@
 import { parseBoardMediaSource } from "../../protocol/dist/board-model.js";
+import { rankedTaskArtifacts } from "../../protocol/dist/board-task.js";
 import { getMediaResourceTitle } from "./media.js";
-import { rankedTaskArtifacts } from "./task.js";
 //#region src/board/model/media-playback.ts
 function resolveBoardMediaUrl(src, source, purpose = "preview") {
 	const parsed = parseBoardMediaSource(src);

package/dist/board/model/overlay-placement.d.ts

@@ -0,0 +1,25 @@
+import { Rect } from "./geometry.js";
+//#region src/board/model/overlay-placement.d.ts
+type BoardPlacement = "right" | "left" | "bottom" | "top";
+declare function placeBoardOverlay(input: {
+  anchor: Rect;
+  size: {
+    width: number;
+    height: number;
+  };
+  safeRect: Rect;
+  placements?: readonly BoardPlacement[];
+  gap?: number;
+}): {
+  placement: BoardPlacement;
+  position: {
+    x: number;
+    y: number;
+  };
+  availableSize: {
+    width: number;
+    height: number;
+  };
+};
+//#endregion
+export { BoardPlacement, placeBoardOverlay };

package/dist/board/model/overlay-placement.js

@@ -0,0 +1,35 @@
+//#region src/board/model/overlay-placement.ts
+function placeBoardOverlay(input) {
+	const { anchor: a, size, safeRect: safe, gap = 12 } = input;
+	const placements = input.placements?.length ? input.placements : [
+		"right",
+		"left",
+		"bottom",
+		"top"
+	];
+	const width = Math.min(size.width, safe.width);
+	const height = Math.min(size.height, safe.height);
+	const best = placements.map((placement) => {
+		const x = placement === "right" ? a.x + a.width + gap : placement === "left" ? a.x - width - gap : a.x + (a.width - width) / 2;
+		const y = placement === "bottom" ? a.y + a.height + gap : placement === "top" ? a.y - height - gap : a.y + (a.height - height) / 2;
+		return {
+			placement,
+			x,
+			y,
+			overflow: Math.max(0, safe.x - x) + Math.max(0, x + width - safe.x - safe.width) + Math.max(0, safe.y - y) + Math.max(0, y + height - safe.y - safe.height)
+		};
+	}).reduce((best, next) => next.overflow < best.overflow ? next : best);
+	return {
+		placement: best.placement,
+		position: {
+			x: Math.max(safe.x, Math.min(best.x, safe.x + safe.width - width)),
+			y: Math.max(safe.y, Math.min(best.y, safe.y + safe.height - height))
+		},
+		availableSize: {
+			width,
+			height
+		}
+	};
+}
+//#endregion
+export { placeBoardOverlay };

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/script-hit.d.ts

@@ -1,10 +1,27 @@
-import { BoardScriptOutput } from "./script.js";
-import { WorldPoint } from "./geometry.js";
+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 { boardScriptTarget };
+export { boardScriptHitVisible, boardScriptTarget, resolveBoardScriptHit };

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

@@ -2,11 +2,75 @@ 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 owners = new Map([...outputs.keys()].map((id) => [scriptTemporaryPrefix(id), id]));
+	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 || id.endsWith("root") && owners.has(id.slice(0, -4))) continue;
+		if (!item || scene.opacity(id) <= 0) continue;
 		let parent = item.parent;
 		let clipped = false;
 		for (let depth = 0; parent && depth < 64; depth++) {
@@ -19,34 +83,27 @@ function boardScriptTarget(scene, candidates, point, outputs, hitTest) {
 			parent = ancestor.parent;
 		}
 		if (clipped) continue;
-		const output = outputs.get(id);
-		if (output) {
+		for (const byItem of declared) {
+			const hits = byItem.get(id);
+			if (!hits) continue;
 			const local = applyMatrix(invertMatrix(scene.layout.matrix(id)), point);
-			for (const [target, region] of Object.entries(output.hits).reverse()) if (local.x >= region.x && local.y >= region.y && local.x <= region.x + region.width && local.y <= region.y + region.height) return {
-				owner: id,
-				target
-			};
-		}
-		if (!hitTest(item, point)) continue;
-		let current = item;
-		for (let depth = 0; current && depth < 64; depth++) {
-			if (outputs.has(current.id)) return {
-				owner: current.id,
-				target: id
-			};
-			for (const [prefix, owner] of owners) {
-				if (current.id === `${prefix}root`) break;
-				if (current.id.startsWith(prefix)) return {
-					owner,
-					target: current.id.slice(prefix.length)
+			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
 				};
 			}
-			current = current.parent ? scene.get(current.parent) : void 0;
 		}
+		if (prefixes.some((prefix) => id.startsWith(prefix))) continue;
 		if (item.type === "frame" && item.props.decoration === "none") continue;
-		return null;
+		if (hitTest(item, point)) return null;
 	}
 	return null;
 }
 //#endregion
-export { boardScriptTarget };
+export { boardScriptHitVisible, boardScriptTarget, resolveBoardScriptHit };

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

@@ -19,6 +19,6 @@ type PreparedOutput = {
 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): Map<string, BoardItem>;
+}, onError?: (owner: string, error: unknown) => void, gestureLayout?: BoardScene["layout"]): Map<string, BoardItem>;
 //#endregion
 export { boardScriptScope, composeBoardScriptItems, prepareBoardScriptOutput, scriptTemporaryPrefix, validateBoardScriptCommit, validateBoardScriptOutput };

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

@@ -35,6 +35,10 @@ function validateBoardScriptOutput(output, scope) {
 	if (!output || typeof output !== "object" || !output.patches || !output.items || !output.hits || !Array.isArray(output.listens)) throw new Error("Invalid script output.");
 	if (JSON.stringify(output).length > 1e6) throw new Error("Script output exceeds the 1 MB limit.");
 	if (output.space !== void 0 && output.space !== "world" && output.space !== "screen") throw new Error("Invalid script scene space.");
+	if (output.anchor) {
+		const { item, point } = output.anchor;
+		if (output.space !== "screen" || typeof item !== "string" || !item || point && ![point.x, point.y].every((n) => Number.isFinite(n) && n >= 0 && n <= 1)) throw new Error("Invalid screen scene anchor.");
+	}
 	if (output.parameters) {
 		if (Object.keys(output.parameters).length > 64) throw new Error("A script may declare at most 64 parameters.");
 		for (const spec of Object.values(output.parameters)) {
@@ -58,6 +62,7 @@ function validateBoardScriptOutput(output, scope) {
 		if (!patch || typeof patch !== "object" || Object.keys(patch).some((key) => !DISPLAY_FIELDS.has(key))) throw new Error("Scripts may only present display properties.");
 	}
 	for (const hit of Object.values(output.hits)) {
+		if (!hit || typeof hit !== "object") throw new Error("Invalid script hit region.");
 		if (hit.cursor && ![
 			"default",
 			"pointer",
@@ -70,7 +75,11 @@ function validateBoardScriptOutput(output, scope) {
 			"ns-resize",
 			"not-allowed"
 		].includes(hit.cursor)) throw new Error("Invalid script cursor.");
-		if (![
+		if ("target" in hit) {
+			if (hit.target !== "self" || "item" in hit || "x" in hit) throw new Error("Invalid script hit target.");
+		} else if ("item" in hit) {
+			if (typeof hit.item !== "string" || !Object.hasOwn(output.items, hit.item) || "x" in hit) throw new Error("Hit items must belong to the temporary scene.");
+		} else if (![
 			hit.x,
 			hit.y,
 			hit.width,
@@ -100,6 +109,15 @@ function scriptTemporaryPrefix(owner) {
 }
 const preparedOutputs = /* @__PURE__ */ new WeakMap();
 const preparedScopes = /* @__PURE__ */ new WeakMap();
+const itemOrders = /* @__PURE__ */ new WeakMap();
+function orderedScriptOwners(document, outputs) {
+	let order = itemOrders.get(document.items);
+	if (!order) {
+		order = new Map(Object.keys(document.items).map((id, index) => [id, index]));
+		itemOrders.set(document.items, order);
+	}
+	return [...outputs.keys()].filter((id) => order.has(id)).sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+}
 function prepareBoardScriptOutput(document, owner, output) {
 	const previous = preparedOutputs.get(output);
 	if (previous?.document === document && previous.owner === owner) return previous;
@@ -113,6 +131,7 @@ function prepareBoardScriptOutput(document, owner, output) {
 		scope = boardScriptScope(document, owner);
 		scopes.set(owner, scope);
 	}
+	if (output.anchor && document.items[output.anchor.item] && !scope.has(output.anchor.item)) throw new Error("Scene anchor is outside the script scope.");
 	validateBoardScriptOutput(output, scope);
 	const presented = /* @__PURE__ */ new Map();
 	for (const [id, patch] of Object.entries(output.patches)) {
@@ -177,11 +196,11 @@ function prepareBoardScriptOutput(document, owner, output) {
 	preparedOutputs.set(output, prepared);
 	return prepared;
 }
-function composeBoardScriptItems(document, scene, outputs, incoming = /* @__PURE__ */ new Map(), screen, onError) {
+function composeBoardScriptItems(document, scene, outputs, incoming = /* @__PURE__ */ new Map(), screen, onError, gestureLayout) {
 	const result = new Map(incoming);
 	const screenAnchors = /* @__PURE__ */ new Map();
 	if (outputs.size === 0) return result;
-	for (const owner of Object.keys(document.items)) {
+	for (const owner of orderedScriptOwners(document, outputs)) {
 		const output = outputs.get(owner);
 		if (!output) continue;
 		try {
@@ -249,15 +268,23 @@ function composeBoardScriptItems(document, scene, outputs, incoming = /* @__PURE
 		}
 	}
 	if (screenAnchors.size) {
-		const layout = createBoardLayout((id) => result.get(id) ?? document.items[id]);
+		const layout = gestureLayout ?? createBoardLayout((id) => result.get(id) ?? document.items[id]);
 		for (const [owner, rootId] of screenAnchors) {
 			const root = result.get(rootId);
+			const anchor = outputs.get(owner)?.anchor;
+			const target = anchor?.item ?? owner;
+			const exists = Boolean(document.items[target]);
+			const box = exists ? layout.box(target) : {
+				width: 0,
+				height: 0
+			};
 			if (root) result.set(rootId, {
 				...root,
-				position: applyMatrix(layout.matrix(owner), {
-					x: 0,
-					y: 0
-				})
+				opacity: exists ? root.opacity : 0,
+				position: exists ? applyMatrix(layout.matrix(target), {
+					x: (anchor?.point?.x ?? 0) * box.width,
+					y: (anchor?.point?.y ?? 0) * box.height
+				}) : root.position
 			});
 		}
 	}