@neta-art/cohub 8.23.0 → 9.0.0

package/dist/board/core/draw-geometry.js

@@ -1,15 +1,8 @@
-import { boardDrawBounds, boardDrawSampleRadius } from "../../protocol/dist/board-geometry.js";
+import { drawPointsBounds, drawSampleRadius } from "../../protocol/dist/board-layout.js";
 import { getStroke } from "perfect-freehand";
 //#region src/board/core/draw-geometry.ts
-/** Radius of a sample in world units given the stroke size and pressure. */
-const sampleRadius = boardDrawSampleRadius;
-/** Axis-aligned bounds of a stroke in its local space, padded by stroke width. */
-const computeDrawBounds = boardDrawBounds;
-/**
-* Ramer–Douglas–Peucker simplification. Reduces point count for low-zoom
-* rendering without touching the persisted raw samples. Returns indices into
-* the input so callers can keep pressure alongside the simplified path.
-*/
+const sampleRadius = drawSampleRadius;
+const computeDrawBounds = drawPointsBounds;
 function simplifyDrawIndices(points, tolerance) {
 	const n = points.length;
 	if (n <= 2 || tolerance <= 0) return points.map((_, i) => i);
@@ -54,11 +47,36 @@ function perpendicularDistance(point, a, b) {
 	const projY = a.y + t * dy;
 	return Math.hypot(point.x - projX, point.y - projY);
 }
-/**
-* Build a closed outline for callers that need a path representation.
-* Interactive rendering uses `buildStrokeRibbonGeometry` below because a single
-* outline is unsafe when a freehand path folds back over itself.
-*/
+function trimDrawPoints(points, trim) {
+	if (trim === void 0 || trim >= 1) return points;
+	if (trim <= 0) return [];
+	if (points.length < 2) return points;
+	let total = 0;
+	for (let i = 1; i < points.length; i += 1) {
+		const a = points[i - 1];
+		const b = points[i];
+		total += Math.hypot(b.x - a.x, b.y - a.y);
+	}
+	let remaining = total * trim;
+	const out = [points[0]];
+	for (let i = 1; i < points.length; i += 1) {
+		const a = points[i - 1];
+		const b = points[i];
+		const length = Math.hypot(b.x - a.x, b.y - a.y);
+		if (length >= remaining) {
+			const t = length > 0 ? remaining / length : 0;
+			out.push({
+				x: a.x + (b.x - a.x) * t,
+				y: a.y + (b.y - a.y) * t,
+				p: a.p + (b.p - a.p) * t
+			});
+			return out;
+		}
+		out.push(b);
+		remaining -= length;
+	}
+	return out;
+}
 function buildStrokeOutline(points, size) {
 	const n = points.length;
 	if (n === 0) return [];
@@ -122,7 +140,6 @@ function buildStrokeOutline(points, size) {
 	}));
 }
 const RIBBON_CIRCLE_SIDES = 8;
-/** Whether a sample needs a round join rather than the neighboring segment caps. */
 function isStrokeCorner(points, index) {
 	if (index === 0 || index === points.length - 1) return true;
 	const before = points[index - 1];
@@ -138,83 +155,129 @@ function isStrokeCorner(points, index) {
 	if (aLength < 1e-6 || bLength < 1e-6) return true;
 	return (ax * bx + ay * by) / (aLength * bLength) < .92;
 }
-/**
-* Tessellate a freehand stroke as independent, convex primitives.
-*
-* A whole-path polygon is deliberately avoided: a path that folds back can make
-* its outline self-intersect, and GPU polygon triangulation then creates a large
-* accidental fill. Segment quads plus round point joins overlap safely instead.
-*/
-function buildStrokeRibbonGeometry(points, size) {
-	const positions = [];
-	const indices = [];
-	const uvs = [];
-	const progress = [];
-	if (points.length === 0) return {
-		positions: /* @__PURE__ */ new Float32Array(),
-		indices: /* @__PURE__ */ new Uint32Array(),
-		uvs: /* @__PURE__ */ new Float32Array(),
-		progress: /* @__PURE__ */ new Float32Array()
+const SAMPLE_VERTICES = 13;
+function segmentNormal(points, index) {
+	const from = points[index];
+	const to = points[index + 1];
+	if (!from || !to) return null;
+	const length = Math.hypot(to.x - from.x, to.y - from.y);
+	return length < 1e-6 ? null : {
+		x: -(to.y - from.y) / length,
+		y: (to.x - from.x) / length
 	};
-	const lengths = new Array(points.length).fill(0);
-	for (let i = 1; i < points.length; i += 1) {
-		const from = points[i - 1];
-		const to = points[i];
-		if (from && to) lengths[i] = (lengths[i - 1] ?? 0) + Math.hypot(to.x - from.x, to.y - from.y);
-	}
-	const total = Math.max(lengths.at(-1) ?? 0, 1e-6);
-	const addVertex = (x, y, at) => {
-		const normalized = at / total;
-		positions.push(x, y);
-		uvs.push(normalized, 0);
-		progress.push(normalized);
-		return positions.length / 2 - 1;
+}
+function edgeOffset(points, index, own) {
+	if (isStrokeCorner(points, index)) return own;
+	const before = segmentNormal(points, index - 1);
+	const after = segmentNormal(points, index);
+	if (!before || !after) return own;
+	const x = before.x + after.x;
+	const y = before.y + after.y;
+	const length = Math.hypot(x, y);
+	if (length < 1e-6) return own;
+	const scale = 1 / Math.max(.5, (x * own.x + y * own.y) / length);
+	return {
+		x: x / length * scale,
+		y: y / length * scale
 	};
-	const addTriangle = (a, b, c) => indices.push(a, b, c);
-	const addRoundPoint = (point, at) => {
+}
+/** A growing stroke re-emits only its last two samples. */
+function createStrokeRibbonBuilder(size) {
+	let positions = /* @__PURE__ */ new Float32Array(1664);
+	let distances = /* @__PURE__ */ new Float32Array(832);
+	let indices = /* @__PURE__ */ new Uint32Array(1920);
+	let lengths = /* @__PURE__ */ new Float64Array(64);
+	let marks = /* @__PURE__ */ new Uint32Array(128);
+	let source = null;
+	let built = 0;
+	let vertexCount = 0;
+	let indexCount = 0;
+	function grow(buffer, needed) {
+		if (buffer.length >= needed) return buffer;
+		const next = new buffer.constructor(Math.max(needed, buffer.length * 2));
+		next.set(buffer);
+		return next;
+	}
+	function vertex(x, y, at) {
+		positions[vertexCount * 2] = x;
+		positions[vertexCount * 2 + 1] = y;
+		distances[vertexCount] = at;
+		return vertexCount++;
+	}
+	function triangle(a, b, c) {
+		indices[indexCount++] = a;
+		indices[indexCount++] = b;
+		indices[indexCount++] = c;
+	}
+	function emit(points, index) {
+		positions = grow(positions, (vertexCount + SAMPLE_VERTICES) * 2);
+		distances = grow(distances, vertexCount + SAMPLE_VERTICES);
+		indices = grow(indices, indexCount + 30);
+		const point = points[index];
+		const at = lengths[index] ?? 0;
 		const radius = sampleRadius(size, point.p);
-		const center = addVertex(point.x, point.y, at);
-		const circle = [];
-		for (let side = 0; side < RIBBON_CIRCLE_SIDES; side += 1) {
-			const angle = side / RIBBON_CIRCLE_SIDES * Math.PI * 2;
-			circle.push(addVertex(point.x + Math.cos(angle) * radius, point.y + Math.sin(angle) * radius, at));
+		if (isStrokeCorner(points, index)) {
+			const center = vertex(point.x, point.y, at);
+			for (let side = 0; side < RIBBON_CIRCLE_SIDES; side += 1) {
+				const angle = side / RIBBON_CIRCLE_SIDES * Math.PI * 2;
+				vertex(point.x + Math.cos(angle) * radius, point.y + Math.sin(angle) * radius, at);
+			}
+			for (let side = 0; side < RIBBON_CIRCLE_SIDES; side += 1) triangle(center, center + 1 + side, center + 1 + (side + 1) % RIBBON_CIRCLE_SIDES);
 		}
-		for (let side = 0; side < RIBBON_CIRCLE_SIDES; side += 1) addTriangle(center, circle[side], circle[(side + 1) % RIBBON_CIRCLE_SIDES]);
-	};
-	for (let i = 0; i < points.length; i += 1) {
-		const point = points[i];
-		if (!point) continue;
-		if (isStrokeCorner(points, i)) addRoundPoint(point, lengths[i] ?? 0);
-		if (i === points.length - 1) continue;
-		const next = points[i + 1];
-		if (!next) continue;
-		const dx = next.x - point.x;
-		const dy = next.y - point.y;
-		const length = Math.hypot(dx, dy);
-		if (length < 1e-6) continue;
-		const normalX = -dy / length;
-		const normalY = dx / length;
-		const radius = sampleRadius(size, point.p);
-		const leftA = addVertex(point.x + normalX * radius, point.y + normalY * radius, lengths[i] ?? 0);
-		const rightA = addVertex(point.x - normalX * radius, point.y - normalY * radius, lengths[i] ?? 0);
+		const next = points[index + 1];
+		const normal = segmentNormal(points, index);
+		if (!next || !normal) return;
+		const start = edgeOffset(points, index, normal);
+		const end = edgeOffset(points, index + 1, normal);
+		const nextAt = lengths[index + 1] ?? at;
 		const nextRadius = sampleRadius(size, next.p);
-		const leftB = addVertex(next.x + normalX * nextRadius, next.y + normalY * nextRadius, lengths[i + 1] ?? 0);
-		const rightB = addVertex(next.x - normalX * nextRadius, next.y - normalY * nextRadius, lengths[i + 1] ?? 0);
-		addTriangle(leftA, rightA, leftB);
-		addTriangle(rightA, rightB, leftB);
+		const leftA = vertex(point.x + start.x * radius, point.y + start.y * radius, at);
+		const rightA = vertex(point.x - start.x * radius, point.y - start.y * radius, at);
+		const leftB = vertex(next.x + end.x * nextRadius, next.y + end.y * nextRadius, nextAt);
+		const rightB = vertex(next.x - end.x * nextRadius, next.y - end.y * nextRadius, nextAt);
+		triangle(leftA, rightA, leftB);
+		triangle(rightA, rightB, leftB);
 	}
+	return { build(points) {
+		const count = points.length;
+		const from = points === source && count >= built ? Math.max(0, built - 2) : 0;
+		source = points;
+		built = count;
+		lengths = grow(lengths, count);
+		marks = grow(marks, count * 2);
+		vertexCount = from > 0 ? marks[from * 2] : 0;
+		indexCount = from > 0 ? marks[from * 2 + 1] : 0;
+		for (let index = from; index < count; index += 1) {
+			const before = points[index - 1];
+			const point = points[index];
+			lengths[index] = before ? lengths[index - 1] + Math.hypot(point.x - before.x, point.y - before.y) : 0;
+		}
+		for (let index = from; index < count; index += 1) {
+			marks[index * 2] = vertexCount;
+			marks[index * 2 + 1] = indexCount;
+			emit(points, index);
+		}
+		return {
+			positions: positions.subarray(0, vertexCount * 2),
+			indices: indices.subarray(0, indexCount),
+			distances: distances.subarray(0, vertexCount),
+			length: count ? lengths[count - 1] : 0
+		};
+	} };
+}
+function buildStrokeRibbonGeometry(points, size) {
+	const mesh = createStrokeRibbonBuilder(size).build(points);
+	const total = Math.max(mesh.length, 1e-6);
+	const progress = mesh.distances.map((at) => at / total);
+	const uvs = new Float32Array(progress.length * 2);
+	for (let index = 0; index < progress.length; index += 1) uvs[index * 2] = progress[index];
 	return {
-		positions: new Float32Array(positions),
-		indices: new Uint32Array(indices),
-		uvs: new Float32Array(uvs),
-		progress: new Float32Array(progress)
+		positions: mesh.positions.slice(),
+		indices: mesh.indices.slice(),
+		uvs,
+		progress
 	};
 }
-/**
-* Distance from a world point to the stroke's polyline, in the shape's local
-* space. Used for hit testing: a hit registers within half the stroke width plus
-* a small tolerance. `local` is the point expressed in the draw item's frame.
-*/
 function distanceToStroke(points, local) {
 	if (points.length === 0) return Number.POSITIVE_INFINITY;
 	const first = points[0];
@@ -235,4 +298,4 @@ function distanceToStroke(points, local) {
 	return min;
 }
 //#endregion
-export { buildStrokeOutline, buildStrokeRibbonGeometry, computeDrawBounds, distanceToStroke, isStrokeCorner, sampleRadius, simplifyDrawIndices };
+export { buildStrokeOutline, buildStrokeRibbonGeometry, computeDrawBounds, createStrokeRibbonBuilder, distanceToStroke, isStrokeCorner, sampleRadius, simplifyDrawIndices, trimDrawPoints };

package/dist/board/core/export-assets.d.ts

@@ -1,14 +1,11 @@
-import { BoardItem } from "../../protocol/dist/board-document.js";
+import { BoardSceneItem } from "./scene.js";
 //#region src/board/core/export-assets.d.ts
-/** Bound source textures independently from the final output bitmap budget. */
 declare const BOARD_EXPORT_MAX_TEXTURES = 64;
 type BoardExportAssetSelection = {
-  /** One representative item for each selected preview key. */
-  items: BoardItem[];
+  items: BoardSceneItem[];
   keys: string[];
   omittedKeys: string[];
 };
-/** Select a stable, document-ordered set of unique preview assets to load. */
-declare function selectBoardExportAssets(items: BoardItem[], assetKey: (item: BoardItem) => string | null, maxTextures?: number): BoardExportAssetSelection;
+declare function selectBoardExportAssets(items: BoardSceneItem[], assetKey: (item: BoardSceneItem) => string | null, maxTextures?: number): BoardExportAssetSelection;
 //#endregion
 export { BOARD_EXPORT_MAX_TEXTURES, BoardExportAssetSelection, selectBoardExportAssets };

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

@@ -1,7 +1,5 @@
 //#region src/board/core/export-assets.ts
-/** Bound source textures independently from the final output bitmap budget. */
 const BOARD_EXPORT_MAX_TEXTURES = 64;
-/** Select a stable, document-ordered set of unique preview assets to load. */
 function selectBoardExportAssets(items, assetKey, maxTextures = 64) {
 	const limit = Number.isSafeInteger(maxTextures) ? Math.max(0, maxTextures) : 64;
 	const selected = /* @__PURE__ */ new Map();

package/dist/board/core/export-plan.d.ts

@@ -1,95 +1,44 @@
-import { BoardConnection } from "../../protocol/dist/board-connection.js";
-import { BoardDocument, BoardItem } from "../../protocol/dist/board-document.js";
+import { BoardDocument } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
 import { Rect } from "../geometry.js";
-import { FrameLookup } from "./connections.js";
+import { BoardScene, BoardSceneItem } from "./scene.js";
 //#region src/board/core/export-plan.d.ts
-/** What part of the board to capture. */
-type BoardExportRegion =
-/** Everything in the document. */
-{
+type BoardExportRegion = {
   kind: "all";
-} |
-/** Exactly these items, whatever else overlaps them. */
-{
+} | {
   kind: "items";
   ids: string[];
-} |
-/** A frame item's rect, treated as a page: its chrome is excluded. */
-{
+} | {
   kind: "frame";
   id: string;
-} |
-/** An explicit world-space rect. */
-{
+} | {
   kind: "rect";
   rect: Rect;
 };
 type BoardExportPlanInput = {
-  document: BoardDocument;
+  scene: BoardScene;
   region: BoardExportRegion;
-  /** Output pixels per world unit. Defaults to 2 (retina-grade). */
   scale?: number;
-  /** World-space breathing room around the content. Frames use 0. */
   padding?: number;
   maxEdge?: number;
   maxPixels?: number;
 };
 type BoardExportPlan = {
-  /** World-space rect captured, padding included. */
   world: Rect;
-  /** Scale actually used, after clamping. */
   scale: number;
-  /** Scale asked for, before clamping. */
   requestedScale: number;
-  /** Output size in pixels. */
   width: number;
   height: number;
-  /** Items to draw, in document order. */
-  items: BoardItem[];
-  /**
-   * Connections to draw.
-   *
-   * A relation is only included when both of its nodes are in `items`: half a
-   * connection would render as a line into empty space, which reads as a defect
-   * rather than as a clipped edge.
-   */
-  connections: BoardConnection[];
-  /** True when `scale` had to be reduced to fit the size budget. */
+  items: BoardSceneItem[];
   clamped: boolean;
 };
-/**
- * Normalise a document before it reaches the renderers.
- *
- * Renderers read shape fields directly and assume schema defaults have been
- * applied — a hand-built or partially-migrated document would otherwise reach
- * them with missing fields. Parsing here means every entry point (CLI, web,
- * tests) gets the same guarantee, and an invalid document fails with a schema
- * error instead of a render-time crash.
- */
-declare function normalizeBoardDocument(document: BoardDocument): BoardDocument;
-/**
- * Hard ceilings.
- *
- * `MAX_EDGE` stays under the 8192 texture limit that essentially every WebGL2
- * and Canvas2D backend guarantees. `MAX_PIXELS` bounds peak memory instead of
- * edge length — a 8192×8192 RGBA buffer alone is 256MB, which is enough to kill
- * a browser tab, so the total is capped well below the square of the edge.
- */
+declare function normalizeBoardDocument(document: unknown): BoardDocument;
 declare const BOARD_EXPORT_MAX_EDGE = 8192;
 declare const BOARD_EXPORT_MAX_PIXELS = 32000000;
 declare const BOARD_EXPORT_DEFAULT_SCALE = 2;
 declare const BOARD_EXPORT_DEFAULT_PADDING = 32;
-/** Above this, an export is still produced but the caller is warned. */
 declare const BOARD_EXPORT_ITEM_WARN_THRESHOLD = 2000;
-declare function boardFrameLookup(document: BoardDocument): FrameLookup;
-/** Bounds of a single item. Arrows resolve through their own curve geometry. */
-declare function exportItemBounds(item: BoardItem, _getFrame?: FrameLookup): Rect;
-/** Bounds of a connection, resolved against the document's node frames. */
-declare function exportConnectionBounds(connection: BoardConnection, getFrame: FrameLookup): Rect | null;
-/**
- * Resolve a region into a concrete capture plan, or null when there is nothing
- * to draw. Callers treat null as "empty selection", not as an error.
- */
+declare function exportItemBounds(item: BoardSceneItem, scene: BoardScene): Rect | null;
 declare function planBoardExport(input: BoardExportPlanInput): BoardExportPlan | null;
 //#endregion
-export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, BoardExportPlan, BoardExportPlanInput, BoardExportRegion, boardFrameLookup, exportConnectionBounds, exportItemBounds, normalizeBoardDocument, planBoardExport };
+export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, BoardExportPlan, BoardExportPlanInput, BoardExportRegion, exportItemBounds, normalizeBoardDocument, planBoardExport };

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

@@ -1,141 +1,103 @@
-import { parseBoardDocument } from "../../protocol/dist/board-document.js";
+import { arrowBindings } from "../../protocol/dist/board-layout.js";
+import { parseBoardDocument } from "../../protocol/dist/board-patch.js";
 import { itemBounds, rectsIntersect, unionRects } from "../geometry.js";
-import { arrowBounds } from "./arrow-geometry.js";
-import { connectionBounds, resolveConnection } from "./connections.js";
+import { arrowPathBounds, resolveSceneArrow } from "./arrow-geometry.js";
 //#region src/board/core/export-plan.ts
-/**
-* Export planning — pure geometry, no renderer.
-*
-* Every platform (browser, CLI) resolves *what* to capture and *how large* the
-* result may be through this module, so a `--scale 4` on a huge board behaves
-* identically everywhere and no caller can accidentally ask the GPU for a
-* texture it cannot allocate.
-*/
-/**
-* Normalise a document before it reaches the renderers.
-*
-* Renderers read shape fields directly and assume schema defaults have been
-* applied — a hand-built or partially-migrated document would otherwise reach
-* them with missing fields. Parsing here means every entry point (CLI, web,
-* tests) gets the same guarantee, and an invalid document fails with a schema
-* error instead of a render-time crash.
-*/
 function normalizeBoardDocument(document) {
-	return parseBoardDocument(document);
+	const parsed = parseBoardDocument(document);
+	if (!parsed.ok) throw new Error(`Invalid Board document: ${parsed.diagnostics.map((entry) => `${entry.path}: ${entry.message}`).join("; ")}`);
+	return parsed.document;
 }
-/**
-* Hard ceilings.
-*
-* `MAX_EDGE` stays under the 8192 texture limit that essentially every WebGL2
-* and Canvas2D backend guarantees. `MAX_PIXELS` bounds peak memory instead of
-* edge length — a 8192×8192 RGBA buffer alone is 256MB, which is enough to kill
-* a browser tab, so the total is capped well below the square of the edge.
-*/
 const BOARD_EXPORT_MAX_EDGE = 8192;
 const BOARD_EXPORT_MAX_PIXELS = 32e6;
 const BOARD_EXPORT_DEFAULT_SCALE = 2;
 const BOARD_EXPORT_DEFAULT_PADDING = 32;
-/** Above this, an export is still produced but the caller is warned. */
 const BOARD_EXPORT_ITEM_WARN_THRESHOLD = 2e3;
-function boardFrameLookup(document) {
-	const frames = new Map(document.items.map((item) => [item.id, item.frame]));
-	return (id) => frames.get(id);
-}
-/** Bounds of a single item. Arrows resolve through their own curve geometry. */
-function exportItemBounds(item, _getFrame) {
-	if (item.type === "arrow") return arrowBounds(item);
-	return itemBounds(item.frame);
-}
-/** Bounds of a connection, resolved against the document's node frames. */
-function exportConnectionBounds(connection, getFrame) {
-	const resolved = resolveConnection(connection, getFrame);
-	return resolved ? connectionBounds(resolved, connection.style.size) : null;
+function exportItemBounds(item, scene) {
+	let bounds = item.type === "arrow" ? arrowPathBounds(resolveSceneArrow(item, scene), item.style.strokeWidth) : itemBounds(item.frame);
+	let cursor = item.parent;
+	for (let depth = 0; cursor && bounds && depth < 64; depth += 1) {
+		const parent = scene.get(cursor);
+		if (!parent) break;
+		if (parent.type === "frame" && parent.props.clip !== false) bounds = intersectRects(bounds, itemBounds(parent.frame));
+		cursor = parent.parent;
+	}
+	return bounds;
 }
-/** Connections whose endpoints are both inside the given item set. */
-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.itemId) && present.has(connection.target.itemId));
+function intersectRects(a, b) {
+	const x = Math.max(a.x, b.x);
+	const y = Math.max(a.y, b.y);
+	const right = Math.min(a.x + a.width, b.x + b.width);
+	const bottom = Math.min(a.y + a.height, b.y + b.height);
+	return right > x && bottom > y ? {
+		x,
+		y,
+		width: right - x,
+		height: bottom - y
+	} : null;
 }
-function resolveRegion(document, region, getFrame) {
+function resolveRegion(scene, region) {
+	const boundsOf = /* @__PURE__ */ new Map();
+	const bounds = (item) => {
+		if (!boundsOf.has(item.id)) boundsOf.set(item.id, exportItemBounds(item, scene));
+		return boundsOf.get(item.id) ?? null;
+	};
+	const visible = (item, rect) => {
+		const box = bounds(item);
+		return box !== null && rectsIntersect(box, rect);
+	};
+	const union = (items) => unionRects(items.flatMap((item) => bounds(item) ?? []));
 	switch (region.kind) {
-		case "all": {
-			const connections = document.connections;
-			return {
-				items: document.items,
-				connections,
-				rect: unionRects([...document.items.map((item) => exportItemBounds(item)), ...connectionBoundsList(connections, getFrame)]),
-				padding: null
-			};
-		}
+		case "all": return {
+			items: [...scene.items],
+			rect: union(scene.items),
+			padding: null
+		};
 		case "items": {
-			const wanted = new Set(region.ids);
-			const items = document.items.filter((item) => wanted.has(item.id));
-			const connections = connectionsWithin(document, items);
+			const wanted = new Set(region.ids.flatMap((id) => scene.get(id) ? [id, ...scene.descendants(id)] : []));
+			for (const id of [...wanted]) for (const arrowId of scene.binders(id)) {
+				const arrow = scene.get(arrowId);
+				if (arrow && arrowBindings(arrow).every((bound) => wanted.has(bound))) wanted.add(arrowId);
+			}
+			const items = scene.items.filter((item) => wanted.has(item.id));
 			return {
 				items,
-				connections,
-				rect: unionRects([...items.map((item) => exportItemBounds(item)), ...connectionBoundsList(connections, getFrame)]),
+				rect: union(items),
 				padding: null
 			};
 		}
 		case "frame": {
-			const frame = document.items.find((item) => item.id === region.id);
+			const frame = scene.get(region.id);
 			if (!frame) return {
 				items: [],
-				connections: [],
 				rect: null,
 				padding: null
 			};
 			const rect = itemBounds(frame.frame);
-			const items = document.items.filter((item) => item.id !== region.id && rectsIntersect(exportItemBounds(item), rect));
 			return {
-				items,
-				connections: connectionsWithin(document, items),
+				items: scene.items.filter((item) => item.id !== region.id && visible(item, rect)),
 				rect,
 				padding: 0
 			};
 		}
 		case "rect": {
 			const rect = region.rect;
-			const items = document.items.filter((item) => rectsIntersect(exportItemBounds(item), rect));
 			return {
-				items,
-				connections: connectionsWithin(document, items),
+				items: scene.items.filter((item) => visible(item, rect)),
 				rect,
 				padding: 0
 			};
 		}
 	}
 }
-function connectionBoundsList(connections, getFrame) {
-	const rects = [];
-	for (const connection of connections) {
-		const bounds = exportConnectionBounds(connection, getFrame);
-		if (bounds) rects.push(bounds);
-	}
-	return rects;
-}
-/**
-* Largest scale that keeps the output inside both the edge and pixel budgets.
-*
-* There is deliberately no lower bound: a floor here would silently let a very
-* large world exceed the budgets it exists to enforce (a 1e6×1e6 region at a
-* 0.01 floor is 1e8 pixels). Callers see the reduction via `plan.clamped`.
-*/
 function clampScale(requested, world, maxEdge, maxPixels) {
 	const byEdge = Math.min(maxEdge / world.width, maxEdge / world.height);
 	const byArea = Math.sqrt(maxPixels / (world.width * world.height));
 	return Math.min(requested, byEdge, byArea);
 }
-/**
-* Resolve a region into a concrete capture plan, or null when there is nothing
-* to draw. Callers treat null as "empty selection", not as an error.
-*/
 function planBoardExport(input) {
 	const { region, scale: requestedScale = 2, maxEdge = BOARD_EXPORT_MAX_EDGE, maxPixels = BOARD_EXPORT_MAX_PIXELS } = input;
-	const document = normalizeBoardDocument(input.document);
-	const resolved = resolveRegion(document, region, boardFrameLookup(document));
+	const resolved = resolveRegion(input.scene, region);
 	if (!resolved.rect) return null;
 	const padding = input.padding ?? resolved.padding ?? 32;
 	const world = {
@@ -153,9 +115,8 @@ function planBoardExport(input) {
 		width: Math.max(1, Math.floor(world.width * scale)),
 		height: Math.max(1, Math.floor(world.height * scale)),
 		items: resolved.items,
-		connections: resolved.connections,
 		clamped: scale < safeRequest - 1e-6
 	};
 }
 //#endregion
-export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, boardFrameLookup, exportConnectionBounds, exportItemBounds, normalizeBoardDocument, planBoardExport };
+export { BOARD_EXPORT_DEFAULT_PADDING, BOARD_EXPORT_DEFAULT_SCALE, BOARD_EXPORT_ITEM_WARN_THRESHOLD, BOARD_EXPORT_MAX_EDGE, BOARD_EXPORT_MAX_PIXELS, exportItemBounds, normalizeBoardDocument, planBoardExport };

package/dist/board/core/palette.d.ts

@@ -1,22 +1,10 @@
-import { BoardColorId } from "../../protocol/dist/board-node.js";
+import { BoardColor, BoardColorToken } from "../../protocol/dist/board-model.js";
 import "../../protocol/dist/index.js";
 //#region src/board/core/palette.d.ts
-/**
- * Board color palette — a small, named set of shape colors shared by text,
- * geo, draw and arrow shapes. Colors are stored by id in shape props (never
- * raw hex), so themes and space `.cohub/theme.css` can remap them via CSS
- * tokens while persisted data stays compact and forward-compatible.
- *
- * Concrete values are resolved from CSS variables at render time:
- *   --board-color-{id}-stroke | -fill | -label
- * with hard-coded light/dark tables as offline / export fallbacks.
- */
+type BoardColorId = BoardColorToken;
 type BoardColorValue = {
-  /** Stroke / accent color (sRGB hex). */
   stroke: number;
-  /** Translucent fill used behind shapes (sRGB hex). */
   fill: number;
-  /** Readable label color on top of the fill. */
   label: number;
 };
 type BoardColorEntry = {
@@ -29,15 +17,10 @@ declare const BOARD_COLORS: readonly BoardColorEntry[];
 declare const DEFAULT_BOARD_COLOR: BoardColorId;
 declare function isBoardColorId(value: unknown): value is BoardColorId;
 declare function boardColorCssVar(id: BoardColorId, part: keyof BoardColorValue): string;
-/** Resolve a color id to concrete values for a color mode. Unknown → brand. */
 declare function resolveBoardColor(id: unknown, mode: "dark" | "light"): BoardColorValue;
 type BoardShapeColors = Record<BoardColorId, BoardColorValue>;
-/** Build a full shape-color table from hard-coded fallbacks (export / SSR). */
 declare function buildFallbackShapeColors(mode: "dark" | "light"): BoardShapeColors;
-/**
- * Pick a concrete color from a live shape-color table, falling back to the
- * default brand entry when the id is unknown.
- */
 declare function pickBoardColor(colors: BoardShapeColors | null | undefined, id: unknown, mode?: "dark" | "light"): BoardColorValue;
+declare function resolveItemColor(color: BoardColor | undefined, fallback: BoardColorId, colors: BoardShapeColors | null | undefined, mode: "dark" | "light", parseCss: (value: string) => number | null, part?: keyof BoardColorValue): number;
 //#endregion
-export { BOARD_COLORS, BoardColorEntry, type BoardColorId, BoardColorValue, BoardShapeColors, DEFAULT_BOARD_COLOR, boardColorCssVar, buildFallbackShapeColors, isBoardColorId, pickBoardColor, resolveBoardColor };
+export { BOARD_COLORS, BoardColorEntry, BoardColorId, BoardColorValue, BoardShapeColors, DEFAULT_BOARD_COLOR, boardColorCssVar, buildFallbackShapeColors, isBoardColorId, pickBoardColor, resolveBoardColor, resolveItemColor };