@neta-art/cohub 9.0.1 → 11.0.0

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

@@ -0,0 +1,267 @@
+import { parseBoardItem as parseBoardItem$1 } from "../../protocol/dist/board-model.js";
+import { applyMatrix, createBoardLayout } from "../../protocol/dist/board-layout.js";
+import { applyBoardPatchToDocument, mergePatch } from "../../protocol/dist/board-patch.js";
+//#region src/board/model/script-scene.ts
+function parseBoardItem(value) {
+	const parsed = parseBoardItem$1(value);
+	if (!parsed.ok) throw new Error(parsed.diagnostics[0]?.message ?? "Invalid script item.");
+	return parsed.item;
+}
+const DISPLAY_FIELDS = /* @__PURE__ */ new Set([
+	"position",
+	"size",
+	"rotation",
+	"scale",
+	"opacity",
+	"style",
+	"props"
+]);
+function boardScriptScope(document, id) {
+	const scope = /* @__PURE__ */ new Set([id, ...Object.values(document.items[id]?.script?.targets ?? {}).filter((target) => Boolean(document.items[target]))]);
+	if (document.items[id]?.type !== "frame") return scope;
+	for (const candidate of Object.keys(document.items)) {
+		let parent = document.items[candidate]?.parent;
+		for (let depth = 0; parent && depth < 64; depth++) {
+			if (parent === id) {
+				scope.add(candidate);
+				break;
+			}
+			parent = document.items[parent]?.parent;
+		}
+	}
+	return scope;
+}
+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.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)) {
+			if (!spec || ![
+				"number",
+				"boolean",
+				"string",
+				"color"
+			].includes(spec.type)) throw new Error("Invalid script parameter type.");
+			if (spec.label !== void 0 && typeof spec.label !== "string") throw new Error("Invalid script parameter label.");
+			if ([
+				spec.min,
+				spec.max,
+				spec.step
+			].some((value) => value !== void 0 && !Number.isFinite(value))) throw new Error("Invalid script parameter range.");
+		}
+	}
+	if (Object.keys(output.items).length > 1e3 || Object.keys(output.hits).length > 1e3) throw new Error("A script may create at most 1000 temporary items or hit regions.");
+	for (const [id, patch] of Object.entries(output.patches)) {
+		if (!scope.has(id)) throw new Error(`Item is outside the script scope: ${id}`);
+		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.cursor && ![
+			"default",
+			"pointer",
+			"grab",
+			"grabbing",
+			"crosshair",
+			"text",
+			"move",
+			"ew-resize",
+			"ns-resize",
+			"not-allowed"
+		].includes(hit.cursor)) throw new Error("Invalid script cursor.");
+		if (![
+			hit.x,
+			hit.y,
+			hit.width,
+			hit.height
+		].every(Number.isFinite) || hit.width < 0 || hit.height < 0) throw new Error("Invalid script hit region.");
+	}
+}
+function validateBoardScriptCommit(document, id, patch) {
+	if (!patch || typeof patch !== "object" || Object.keys(patch).some((key) => key !== "items")) throw new Error("Scripts may only commit items in their scope.");
+	const scope = boardScriptScope(document, id);
+	for (const [target, value] of Object.entries(patch.items ?? {})) {
+		if (!scope.has(target)) {
+			if (document.items[target]) throw new Error(`Item is outside the script scope: ${target}`);
+			if (!value || typeof value !== "object" || !("parent" in value) || typeof value.parent !== "string" || !scope.has(value.parent) || document.items[value.parent]?.type !== "frame") throw new Error("New items must belong to a frame in the script scope.");
+			if ("script" in value) throw new Error("Scripts cannot start other scripts.");
+			continue;
+		}
+		if (value && typeof value === "object" && ("script" in value || "parent" in value || "type" in value)) throw new Error("A script cannot replace scripts, types, or parent relationships.");
+	}
+	const result = applyBoardPatchToDocument(document, patch);
+	if (!result.ok) throw new Error(result.diagnostics[0]?.message ?? "Invalid script commit.");
+}
+function scriptTemporaryPrefix(owner) {
+	let hash = 2166136261;
+	for (const char of owner) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619) >>> 0;
+	return `~script-${hash.toString(36)}-`;
+}
+const preparedOutputs = /* @__PURE__ */ new WeakMap();
+const preparedScopes = /* @__PURE__ */ new WeakMap();
+function prepareBoardScriptOutput(document, owner, output) {
+	const previous = preparedOutputs.get(output);
+	if (previous?.document === document && previous.owner === owner) return previous;
+	let scopes = preparedScopes.get(document);
+	if (!scopes) {
+		scopes = /* @__PURE__ */ new Map();
+		preparedScopes.set(document, scopes);
+	}
+	let scope = scopes.get(owner);
+	if (!scope) {
+		scope = boardScriptScope(document, owner);
+		scopes.set(owner, scope);
+	}
+	validateBoardScriptOutput(output, scope);
+	const presented = /* @__PURE__ */ new Map();
+	for (const [id, patch] of Object.entries(output.patches)) {
+		const base = document.items[id];
+		if (base) presented.set(id, {
+			base,
+			item: parseBoardItem(mergePatch(base, patch))
+		});
+	}
+	const prefix = scriptTemporaryPrefix(owner);
+	const rootId = `${prefix}root`;
+	if (document.items[rootId]) throw new Error("Temporary item ID conflicts with the document.");
+	const items = /* @__PURE__ */ new Map();
+	const parsed = new Map(Object.entries(output.items).map(([id, value]) => [id, parseBoardItem(value)]));
+	for (const [local, value] of parsed) {
+		if (!/^[a-zA-Z0-9_-]{1,80}$/.test(local) || local === "root") throw new Error("Temporary IDs must be 1–80 letters, digits, underscores or hyphens; root is reserved.");
+		if (value.script) throw new Error("Temporary items cannot start scripts.");
+		if (value.parent && !(value.parent in output.items)) throw new Error("Temporary parents must belong to the same instance.");
+		let cursor = value.parent;
+		const visited = /* @__PURE__ */ new Set([local]);
+		while (cursor) {
+			if (visited.has(cursor)) throw new Error("Temporary parents must not form a cycle.");
+			visited.add(cursor);
+			const parentItem = parsed.get(cursor);
+			if (!parentItem) throw new Error("Temporary parent is missing.");
+			if (parentItem.type !== "frame") throw new Error("Only frames can contain temporary items.");
+			cursor = parentItem.parent;
+		}
+		const id = `${prefix}${local}`;
+		if (document.items[id]) throw new Error("Temporary item ID conflicts with the document.");
+		const parent = value.parent ? `${prefix}${value.parent}` : rootId;
+		if (value.type === "arrow") {
+			const remap = (endpoint) => {
+				if (!("item" in endpoint)) return endpoint;
+				if (!(endpoint.item in output.items) && !scope.has(endpoint.item)) throw new Error("Arrow target is outside the script scope.");
+				return endpoint.item in output.items ? {
+					...endpoint,
+					item: `${prefix}${endpoint.item}`
+				} : endpoint;
+			};
+			items.set(id, {
+				...value,
+				parent,
+				props: {
+					...value.props,
+					start: remap(value.props.start),
+					end: remap(value.props.end)
+				}
+			});
+		} else items.set(id, {
+			...value,
+			parent
+		});
+	}
+	const prepared = {
+		document,
+		owner,
+		rootId,
+		items,
+		presented
+	};
+	preparedOutputs.set(output, prepared);
+	return prepared;
+}
+function composeBoardScriptItems(document, scene, outputs, incoming = /* @__PURE__ */ new Map(), screen, onError) {
+	const result = new Map(incoming);
+	const screenAnchors = /* @__PURE__ */ new Map();
+	if (outputs.size === 0) return result;
+	for (const owner of Object.keys(document.items)) {
+		const output = outputs.get(owner);
+		if (!output) continue;
+		try {
+			const changes = /* @__PURE__ */ new Map();
+			const prepared = prepareBoardScriptOutput(document, owner, output);
+			for (const [id, patch] of Object.entries(output.patches)) {
+				const base = result.get(id) ?? document.items[id];
+				if (!base) continue;
+				let cached = prepared.presented.get(id);
+				if (cached?.base !== base) {
+					cached = {
+						base,
+						item: parseBoardItem(mergePatch(base, patch))
+					};
+					prepared.presented.set(id, cached);
+				}
+				changes.set(id, cached.item);
+			}
+			if (!prepared.items.size || output.space === "screen" && !screen) {
+				for (const [id, item] of changes) result.set(id, item);
+				continue;
+			}
+			const rootId = prepared.rootId;
+			const item = changes.get(owner) ?? result.get(owner) ?? document.items[owner];
+			if (!item) continue;
+			const box = scene.layout.box(owner);
+			const overlay = output.space === "screen" && screen ? {
+				parent: void 0,
+				position: {
+					x: 0,
+					y: 0
+				},
+				scale: 1 / screen.zoom,
+				rotation: 0,
+				origin: {
+					x: 0,
+					y: 0
+				}
+			} : {};
+			changes.set(rootId, parseBoardItem({
+				type: "frame",
+				parent: item.parent,
+				position: item.position,
+				rotation: item.rotation,
+				scale: item.scale,
+				origin: item.origin,
+				opacity: item.opacity,
+				size: {
+					width: Math.max(1, box.width),
+					height: Math.max(1, box.height)
+				},
+				z: (item.z ?? 0) + .001,
+				props: {
+					decoration: "none",
+					clip: false
+				},
+				...overlay
+			}));
+			for (const [id, value] of prepared.items) changes.set(id, value);
+			for (const [id, item] of changes) result.set(id, item);
+			if (output.space === "screen") screenAnchors.set(owner, rootId);
+		} catch (error) {
+			if (!onError) throw error;
+			onError(owner, error);
+		}
+	}
+	if (screenAnchors.size) {
+		const layout = createBoardLayout((id) => result.get(id) ?? document.items[id]);
+		for (const [owner, rootId] of screenAnchors) {
+			const root = result.get(rootId);
+			if (root) result.set(rootId, {
+				...root,
+				position: applyMatrix(layout.matrix(owner), {
+					x: 0,
+					y: 0
+				})
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+export { boardScriptScope, composeBoardScriptItems, prepareBoardScriptOutput, scriptTemporaryPrefix, validateBoardScriptCommit, validateBoardScriptOutput };

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

@@ -0,0 +1,105 @@
+import { BoardItem, BoardPatch, BoardScript, BoardVec2 } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+//#region src/board/model/script.d.ts
+type BoardScriptEvent = {
+  type: string;
+  target?: string;
+  relatedTarget?: string;
+  relatedOwner?: string;
+  point?: BoardVec2;
+  pointerId?: number;
+  pointerType?: string;
+  buttons?: number;
+  key?: string;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  data?: unknown;
+};
+type BoardScriptFrame = {
+  t: number;
+  dt: number;
+  width: number;
+  height: number;
+  seed: string;
+  params: BoardScript["params"];
+  state: Record<string, unknown>;
+};
+type BoardScriptItemPatch = Partial<Pick<BoardItem, "position" | "scale" | "rotation" | "opacity" | "style">> & {
+  size?: {
+    width?: number;
+    height?: number;
+  };
+  props?: Record<string, unknown>;
+};
+type BoardScriptHit = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  label?: string;
+  cursor?: string;
+};
+type BoardScriptSnapshot = {
+  state: Record<string, unknown>;
+  time: number;
+  random: number;
+  configuration?: string;
+  effects?: Pick<BoardScriptOutput, "patches" | "items" | "hits" | "space">;
+};
+type BoardScriptParameter = {
+  type: "number" | "boolean" | "string" | "color";
+  label?: string;
+  default?: string | number | boolean;
+  min?: number;
+  max?: number;
+  step?: number;
+};
+type BoardScriptOutput = {
+  parameters?: Record<string, BoardScriptParameter>;
+  space?: "world" | "screen";
+  patches: Record<string, Record<string, unknown>>;
+  items: Record<string, unknown>;
+  hits: Record<string, BoardScriptHit>;
+  listens: string[];
+  animated: boolean;
+  updating?: boolean;
+  version: number;
+};
+type BoardScriptContext = {
+  readonly self: {
+    readonly id: string;
+    readonly base: BoardItem;
+    present(patch: BoardScriptItemPatch | null): void;
+  };
+  readonly params: BoardScript["params"];
+  readonly targets: Readonly<Record<string, string>>;
+  emit(target: string, type: string, data?: unknown): Promise<void>;
+  readonly state: Record<string, unknown>;
+  readonly frame: BoardScriptFrame;
+  random(): number;
+  on(type: string, handler: (event: BoardScriptEvent) => void): () => void;
+  onFrame(handler: (frame: BoardScriptFrame) => void): () => void;
+  onDispose(handler: () => void): void;
+  invalidate(): void;
+  get(id: string): BoardItem | undefined;
+  present(id: string, patch: BoardScriptItemPatch | null): void;
+  scene(items: Record<string, unknown>, options?: {
+    space?: "world" | "screen";
+  }): void;
+  hitRegions(hits: Record<string, BoardScriptHit>): void;
+  commit(patch: BoardPatch): Promise<void>;
+  capabilities: {
+    has(name: string): boolean;
+    call(name: string, input?: unknown): Promise<unknown>;
+  };
+};
+type BoardScriptModule = {
+  parameters?: Record<string, BoardScriptParameter>;
+  default?: ((context: BoardScriptContext) => void) | ((context: BoardScriptContext) => () => void);
+  draw?: (context: CanvasRenderingContext2D, frame: BoardScriptFrame) => void;
+  animated?: boolean;
+};
+//#endregion
+export { BoardScriptContext, BoardScriptEvent, BoardScriptFrame, BoardScriptHit, BoardScriptItemPatch, BoardScriptModule, BoardScriptOutput, BoardScriptParameter, BoardScriptSnapshot };

package/dist/board/model/script.js

@@ -0,0 +1 @@
+export {};

package/dist/board/model/shape-types.d.ts

@@ -0,0 +1,8 @@
+import { BoardShapeGeometry } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+//#region src/board/model/shape-types.d.ts
+type ShapeKind = Exclude<BoardShapeGeometry, "path">;
+declare const SHAPE_KINDS: ShapeKind[];
+declare function isShapeKind(value: unknown): value is ShapeKind;
+//#endregion
+export { SHAPE_KINDS, ShapeKind, isShapeKind };

package/dist/board/model/shape-types.js

@@ -0,0 +1,8 @@
+import { BOARD_SHAPE_GEOMETRIES } from "../../protocol/dist/board-model.js";
+//#region src/board/model/shape-types.ts
+const SHAPE_KINDS = BOARD_SHAPE_GEOMETRIES.filter((kind) => kind !== "path");
+function isShapeKind(value) {
+	return typeof value === "string" && SHAPE_KINDS.includes(value);
+}
+//#endregion
+export { SHAPE_KINDS, isShapeKind };

package/dist/board/{task.d.ts → model/task.d.ts}

@@ -1,7 +1,7 @@
-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
+import { BoardTaskArtifact, BoardTaskSnapshot } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { TaskRunRecord } from "../../types.js";
+//#region src/board/model/task.d.ts
 declare function taskArtifacts(blocks: Record<string, unknown>[]): BoardTaskArtifact[];
 declare function rankedTaskArtifacts(artifacts: readonly BoardTaskArtifact[]): BoardTaskArtifact[];
 declare function featuredTaskArtifact(artifacts: readonly BoardTaskArtifact[]): BoardTaskArtifact | undefined;

package/dist/board/{task.js → model/task.js}

@@ -1,6 +1,6 @@
-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
+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/model/task.ts
 function artifactId(base, used, suffix) {
 	const stem = cleanExcerpt(base, 220) ?? "output";
 	let candidate = suffix ? `${stem}-${suffix}` : stem;

package/dist/board/{core → model}/text-metrics.d.ts

@@ -1,6 +1,6 @@
 import { clampBoardFontSize } from "../../protocol/dist/board-layout.js";
 import "../../protocol/dist/index.js";
-//#region src/board/core/text-metrics.d.ts
+//#region src/board/model/text-metrics.d.ts
 declare const TEXT_FONT_FAMILY = "Geist";
 declare const TEXT_FONT_SIZE = 24;
 declare const TEXT_LINE_HEIGHT = 32;

package/dist/board/{core → model}/text-metrics.js

@@ -1,6 +1,6 @@
 import { BOARD_TEXT_FONT_FAMILY } from "../../protocol/dist/board-constants.js";
 import { clampBoardFontSize } from "../../protocol/dist/board-layout.js";
-//#region src/board/core/text-metrics.ts
+//#region src/board/model/text-metrics.ts
 const TEXT_FONT_FAMILY = BOARD_TEXT_FONT_FAMILY;
 const TEXT_FONT_SIZE = 24;
 const TEXT_LINE_HEIGHT = 32;

package/dist/board/{core → model}/tool-styles.d.ts

@@ -1,7 +1,7 @@
 import { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, clampBoardStrokeSize } from "../../protocol/dist/board-constants.js";
 import { BoardColorId } from "./palette.js";
 import { ShapeKind } from "./shape-types.js";
-//#region src/board/core/tool-styles.d.ts
+//#region src/board/model/tool-styles.d.ts
 type BoardToolStyleMap = {
   text: {
     color: BoardColorId;

package/dist/board/{core → model}/tool-styles.js

@@ -1,7 +1,7 @@
 import { BOARD_ARROW_STROKE_SIZE, BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, clampBoardStrokeSize } from "../../protocol/dist/board-constants.js";
 import { isBoardColorId } from "./palette.js";
 import { isShapeKind } from "./shape-types.js";
-//#region src/board/core/tool-styles.ts
+//#region src/board/model/tool-styles.ts
 const DEFAULT_BOARD_TOOL_STYLES = {
 	text: { color: "neutral" },
 	shape: {

package/dist/board/{runtime/board-player.d.ts → player/index.d.ts}

@@ -1,8 +1,8 @@
 import { BoardDocument, BoardItem } from "../../protocol/dist/board-model.js";
 import { BoardPlaybackCommand, BoardPlaybackSnapshot } from "../../protocol/dist/board.js";
 import "../../protocol/dist/index.js";
-import { BoardCameraOverride, BoardColorResolver } from "../animation.js";
-//#region src/board/runtime/board-player.d.ts
+import { BoardCameraOverride, BoardColorResolver } from "../model/animation.js";
+//#region src/board/player/index.d.ts
 type BoardPlayerFrame = {
   items: ReadonlyMap<string, BoardItem>;
   camera: BoardCameraOverride;

package/dist/board/{runtime/board-player.js → player/index.js}

@@ -1,6 +1,7 @@
-import { boardAnimationTime, compileBoardAnimations, evaluateBoardAnimations } from "../animation.js";
-import { boardPresetTracks, isBoardPresetName } from "../presets.js";
-//#region src/board/runtime/board-player.ts
+import { boardAnimationTime, compileBoardAnimations, evaluateBoardAnimations } from "../model/animation.js";
+import { boardPresetTracks, isBoardPresetName } from "../model/presets.js";
+import { createBoardEntityId } from "../model/items/id.js";
+//#region src/board/player/index.ts
 const ENTER_ANIMATION = "\0enter";
 const ENTER_STAGGER_MS = 45;
 const ENTER_MAX_ITEMS = 80;
@@ -118,7 +119,7 @@ function nextLocalPlayback(current, command, document, now = Date.now()) {
 	};
 	switch (command.type) {
 		case "play": return {
-			playbackId: crypto.randomUUID(),
+			playbackId: createBoardEntityId(),
 			animationId: command.animationId,
 			animationRevision: 0,
 			status: "playing",

package/dist/board/render/board-background.d.ts

@@ -1,6 +1,6 @@
 import { BoardSettings } from "../../protocol/dist/board-model.js";
 import "../../protocol/dist/index.js";
-import { BoardViewport } from "../geometry.js";
+import { BoardViewport } from "../model/geometry.js";
 import { BoardRenderPalette } from "./renderers/board-renderer-registry.js";
 import { Application, Container } from "pixi.js";
 //#region src/board/render/board-background.d.ts

package/dist/board/render/clip.d.ts

@@ -1,4 +1,4 @@
-import { BoardScene, BoardSceneItem } from "../core/scene.js";
+import { BoardScene, BoardSceneItem } from "../model/scene.js";
 import { Container, Graphics } from "pixi.js";
 //#region src/board/render/clip.d.ts
 declare function isClippingFrame(item: BoardSceneItem): boolean;

package/dist/board/render/css-color.d.ts

@@ -1,4 +1,9 @@
 //#region src/board/render/css-color.d.ts
+type BoardCssPaint = {
+  color: number;
+  alpha: number;
+};
+declare function parseBoardCssPaint(value: string): BoardCssPaint | null;
 declare function parseBoardCssColor(value: string): number | null;
 //#endregion
-export { parseBoardCssColor };
+export { BoardCssPaint, parseBoardCssColor, parseBoardCssPaint };

package/dist/board/render/css-color.js

@@ -1,36 +1,50 @@
 import { DOMAdapter } from "pixi.js";
 //#region src/board/render/css-color.ts
-const CACHE_LIMIT = 256;
 const cache = /* @__PURE__ */ new Map();
 let canvas = null;
-function parseBoardCssColor(value) {
+function parseBoardCssPaint(value) {
 	const key = value.trim();
 	if (!key) return null;
-	const cached = cache.get(key);
-	if (cached !== void 0 || cache.has(key)) return cached ?? null;
+	if (key.toLowerCase() === "transparent") return {
+		color: 0,
+		alpha: 0
+	};
+	const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(key)?.[1];
+	if (hex) {
+		const digits = hex.length <= 4 ? [...hex].map((digit) => digit + digit).join("") : hex;
+		return {
+			color: Number.parseInt(digits.slice(0, 6), 16),
+			alpha: digits.length === 8 ? Number.parseInt(digits.slice(6), 16) / 255 : 1
+		};
+	}
+	if (cache.has(key)) return cache.get(key) ?? null;
 	let result = null;
 	try {
-		const direct = /^#([0-9a-f]{6})$/i.exec(key);
-		if (direct?.[1]) result = Number.parseInt(direct[1], 16);
-		else {
-			canvas ??= DOMAdapter.get().createCanvas(1, 1);
-			const context = canvas.getContext("2d");
-			if (context) {
-				context.fillStyle = "#010203";
-				context.fillStyle = key;
-				const first = String(context.fillStyle);
-				context.fillStyle = "#040506";
-				context.fillStyle = key;
-				const match = first === String(context.fillStyle) ? /^#([0-9a-f]{6})$/i.exec(first) : null;
-				if (match?.[1]) result = Number.parseInt(match[1], 16);
-			}
+		canvas ??= DOMAdapter.get().createCanvas(1, 1);
+		const context = canvas.getContext("2d");
+		context.fillStyle = "#010203";
+		context.fillStyle = key;
+		const first = context.fillStyle;
+		context.fillStyle = "#040506";
+		context.fillStyle = key;
+		if (first === context.fillStyle) {
+			context.clearRect(0, 0, 1, 1);
+			context.fillRect(0, 0, 1, 1);
+			const [r = 0, g = 0, b = 0, a = 0] = context.getImageData(0, 0, 1, 1).data;
+			result = {
+				color: r << 16 | g << 8 | b,
+				alpha: a / 255
+			};
 		}
 	} catch {
 		result = null;
 	}
-	if (cache.size >= CACHE_LIMIT) cache.clear();
+	if (cache.size >= 256) cache.clear();
 	cache.set(key, result);
 	return result;
 }
+function parseBoardCssColor(value) {
+	return parseBoardCssPaint(value)?.color ?? null;
+}
 //#endregion
-export { parseBoardCssColor };
+export { parseBoardCssColor, parseBoardCssPaint };

package/dist/board/render/diagnostics.d.ts

@@ -0,0 +1,20 @@
+import { BoardTextItem } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { BoardScene } from "../model/scene.js";
+//#region src/board/render/diagnostics.d.ts
+type BoardRenderDiagnostic = {
+  code: "text-clipped" | "text-overlap" | "glyph-unavailable" | "effect-follow-unused";
+  item: string;
+  related?: string;
+  characters?: string;
+};
+declare function measureBoardText(props: BoardTextItem["props"]): {
+  width: number;
+  height: number;
+  lines: string[];
+  lineHeight: number;
+  missingCharacters: string;
+};
+declare function inspectBoardScene(scene: BoardScene, limit?: number): BoardRenderDiagnostic[];
+//#endregion
+export { BoardRenderDiagnostic, inspectBoardScene, measureBoardText };