@neta-art/cohub 3.1.0 → 4.0.0

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

@@ -0,0 +1,140 @@
+import { BoardFrame } from "../../protocol/dist/board-document.js";
+import { Rect, WorldPoint } from "../geometry.js";
+//#region src/board/core/shape-types.d.ts
+/**
+ * A shape's geometry, expressed in the shape's local space (origin at the
+ * frame's top-left, unrotated). Hit testing and handles are derived from this,
+ * so a shape only declares its outline once.
+ */
+type ShapeGeometry = {
+  /** Axis-aligned bounds in local space (usually the full frame). */
+  bounds: Rect;
+  /**
+   * Exact point containment test in *world* space. Receives the shape frame so
+   * it can account for rotation. Defaults to the rotated-rect test when absent.
+   */
+  containsWorldPoint?: (frame: BoardFrame, point: WorldPoint) => boolean;
+};
+type ShapeHandleId = string;
+type ShapeHandle = {
+  id: ShapeHandleId;
+  /** Position in the shape's local (unrotated, frame-origin) space. */
+  x: number;
+  y: number;
+  /** Visual + hit radius hint in screen px; the stage scales by zoom. */
+  radius?: number;
+};
+/** Result of dragging a handle: a patched frame and/or shape props. */
+type HandleDragResult = {
+  frame?: BoardFrame;
+  props?: Record<string, unknown>;
+};
+/**
+ * What a shape supports. The editor, selection toolbar and tools read these so
+ * behaviour is data-driven: adding a shape never requires editing the editor.
+ */
+type ShapeCapabilities = {
+  /** Can be moved by dragging. */
+  canMove: boolean;
+  /** Shows resize handles. */
+  canResize: boolean;
+  /**
+   * Resize always preserves the shape's aspect ratio, regardless of Shift.
+   * True for shapes whose content has a single intrinsic scale (text font size,
+   * media pixels, stroke geometry) — distorting the frame would either letterbox
+   * the content or have no representation in the data model.
+   */
+  aspectLocked: boolean;
+  /** Shows the rotation handle. */
+  canRotate: boolean;
+  /** Supports double-click inline editing. */
+  canEdit: boolean;
+  /** Can be a binding target for arrows. */
+  canBind: boolean;
+  /** Participates in snapping as a target. */
+  canSnap: boolean;
+  /** Can be locked against accidental edits. */
+  canLock: boolean;
+};
+/**
+ * Effective resize behaviour derived from the backwards-compatible capability
+ * flags. Consumers should use this mode instead of repeating the flag matrix.
+ */
+type ShapeResizeMode = "none" | "uniform" | "free";
+declare function resizeModeForCapabilities(capabilities: ShapeCapabilities): ShapeResizeMode;
+declare const FULL_CAPABILITIES: ShapeCapabilities;
+/**
+ * A single raw input sample of a freehand stroke. We persist the *raw* samples
+ * (not just a simplified path) so strokes can be re-smoothed, re-simplified or
+ * re-rendered at any LOD later without losing information — data first.
+ */
+type DrawPoint = {
+  x: number;
+  y: number;
+  /** Pen pressure 0..1; 0.5 when unavailable (mouse). */
+  p: number;
+};
+type DrawShapeProps = {
+  /** Raw samples in the shape's local space. */
+  points: DrawPoint[];
+  color: string;
+  /** Stroke width in world units. */
+  size: number;
+};
+type GeoKind = "rectangle" | "ellipse" | "diamond" | "triangle" | "rounded";
+declare const GEO_KINDS: readonly GeoKind[];
+declare function isGeoKind(value: unknown): value is GeoKind;
+type GeoShapeProps = {
+  geo: GeoKind;
+  /** Optional label rendered centered inside the shape. */
+  text: string;
+  color: string;
+  /** Fill opacity 0..1 (0 = outline only). */
+  fillOpacity: number;
+};
+/**
+ * An arrow endpoint: either a free point (local space) or a binding to another
+ * shape. Bindings use a normalized anchor (0..1 of the target's frame) so the
+ * arrow tracks the target through move/resize without storing absolute coords.
+ */
+type ArrowEndpoint = {
+  kind: "point";
+  x: number;
+  y: number;
+} | {
+  kind: "binding";
+  /** Target shape id. */
+  target: string;
+  /** Normalized anchor on the target frame (0..1). */
+  nx: number;
+  ny: number;
+  /** Whether the binding snaps to the nearest edge/center. */
+  precise: boolean;
+};
+type ArrowShapeProps = {
+  start: ArrowEndpoint;
+  end: ArrowEndpoint;
+  /** Bend of a curved arrow, as a fraction of the length (-0.5..0.5). */
+  bend: number;
+  color: string;
+  size: number;
+  /** Arrowhead placement. */
+  arrowStart: boolean;
+  arrowEnd: boolean;
+  label: string;
+};
+type TextShapeProps = {
+  text: string;
+  color: string;
+  fontSize: number;
+};
+type ImageShapeProps = {
+  path: string;
+  mimeType?: string;
+};
+type VideoShapeProps = {
+  path: string;
+  mimeType?: string;
+};
+//#endregion
+export { ArrowEndpoint, ArrowShapeProps, DrawPoint, DrawShapeProps, FULL_CAPABILITIES, GEO_KINDS, GeoKind, GeoShapeProps, HandleDragResult, ImageShapeProps, ShapeCapabilities, ShapeGeometry, ShapeHandle, ShapeHandleId, ShapeResizeMode, TextShapeProps, VideoShapeProps, isGeoKind, resizeModeForCapabilities };

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

@@ -0,0 +1,27 @@
+//#region src/board/core/shape-types.ts
+function resizeModeForCapabilities(capabilities) {
+	if (!capabilities.canResize) return "none";
+	return capabilities.aspectLocked ? "uniform" : "free";
+}
+const FULL_CAPABILITIES = {
+	canMove: true,
+	canResize: true,
+	aspectLocked: false,
+	canRotate: true,
+	canEdit: false,
+	canBind: true,
+	canSnap: true,
+	canLock: true
+};
+const GEO_KINDS = [
+	"rectangle",
+	"rounded",
+	"ellipse",
+	"diamond",
+	"triangle"
+];
+function isGeoKind(value) {
+	return typeof value === "string" && GEO_KINDS.includes(value);
+}
+//#endregion
+export { FULL_CAPABILITIES, GEO_KINDS, isGeoKind, resizeModeForCapabilities };

package/dist/board/core/text-metrics.d.ts

@@ -0,0 +1,18 @@
+//#region src/board/core/text-metrics.d.ts
+declare const TEXT_FONT_FAMILY = "Geist";
+declare const TEXT_FONT_SIZE = 24;
+declare const TEXT_LINE_HEIGHT = 32;
+declare const TEXT_MIN_FONT_SIZE = 2;
+declare const TEXT_MAX_FONT_SIZE = 512;
+type BoardTextMeasurer = (text: string, fontSize: number) => number | null;
+/** Install the renderer's text measurer, or clear it for environment-free fallback metrics. */
+declare function setBoardTextMeasurer(measurer?: BoardTextMeasurer): void;
+declare function clampBoardTextFontSize(fontSize: number): number;
+declare function boardTextLineHeight(fontSize: number): number;
+/** Measure unwrapped plain text into scalable world-space bounds. */
+declare function measureBoardText(text: string, fontSize?: number): {
+  width: number;
+  height: number;
+};
+//#endregion
+export { TEXT_FONT_FAMILY, TEXT_FONT_SIZE, TEXT_LINE_HEIGHT, TEXT_MAX_FONT_SIZE, TEXT_MIN_FONT_SIZE, boardTextLineHeight, clampBoardTextFontSize, measureBoardText, setBoardTextMeasurer };

package/dist/board/core/text-metrics.js

@@ -0,0 +1,43 @@
+import { BOARD_TEXT_FONT_FAMILY } from "../../protocol/dist/board-constants.js";
+//#region src/board/core/text-metrics.ts
+const TEXT_FONT_FAMILY = BOARD_TEXT_FONT_FAMILY;
+const TEXT_FONT_SIZE = 24;
+const TEXT_LINE_HEIGHT = 32;
+const TEXT_MIN_FONT_SIZE = 2;
+const TEXT_MAX_FONT_SIZE = 512;
+const TEXT_LINE_HEIGHT_RATIO = TEXT_LINE_HEIGHT / TEXT_FONT_SIZE;
+const TEXT_MIN_WIDTH_RATIO = 16 / TEXT_FONT_SIZE;
+const TEXT_HORIZONTAL_PADDING_RATIO = 2 / TEXT_FONT_SIZE;
+const FALLBACK_CHARACTER_RATIO = .52;
+let textMeasurer;
+/** Install the renderer's text measurer, or clear it for environment-free fallback metrics. */
+function setBoardTextMeasurer(measurer) {
+	textMeasurer = measurer;
+}
+function clampBoardTextFontSize(fontSize) {
+	return Math.min(TEXT_MAX_FONT_SIZE, Math.max(TEXT_MIN_FONT_SIZE, fontSize));
+}
+function boardTextLineHeight(fontSize) {
+	return clampBoardTextFontSize(fontSize) * TEXT_LINE_HEIGHT_RATIO;
+}
+/** Measure unwrapped plain text into scalable world-space bounds. */
+function measureBoardText(text, fontSize = TEXT_FONT_SIZE) {
+	const size = clampBoardTextFontSize(fontSize);
+	const lines = (text || " ").split("\n");
+	const minWidth = size * TEXT_MIN_WIDTH_RATIO;
+	const horizontalPadding = size * TEXT_HORIZONTAL_PADDING_RATIO;
+	const lineHeight = boardTextLineHeight(size);
+	const characterWidth = size * FALLBACK_CHARACTER_RATIO;
+	let width = minWidth;
+	for (const line of lines) {
+		const value = line || " ";
+		const measured = textMeasurer?.(value, size);
+		width = Math.max(width, (measured ?? Math.max(1, value.length) * characterWidth) + horizontalPadding);
+	}
+	return {
+		width,
+		height: Math.max(lineHeight, lines.length * lineHeight)
+	};
+}
+//#endregion
+export { TEXT_FONT_FAMILY, TEXT_FONT_SIZE, TEXT_LINE_HEIGHT, TEXT_MAX_FONT_SIZE, TEXT_MIN_FONT_SIZE, boardTextLineHeight, clampBoardTextFontSize, measureBoardText, setBoardTextMeasurer };

package/dist/board/core/tool-styles.d.ts

@@ -0,0 +1,52 @@
+import { BoardColorId } from "./palette.js";
+import { GeoKind } from "./shape-types.js";
+//#region src/board/core/tool-styles.d.ts
+declare const BOARD_STROKE_MIN_SIZE = 1;
+declare const BOARD_STROKE_MAX_SIZE = 64;
+type BoardToolStyleMap = {
+  text: {
+    color: BoardColorId;
+  };
+  geo: {
+    color: BoardColorId;
+    geo: GeoKind;
+  };
+  draw: {
+    color: BoardColorId;
+    size: number;
+  };
+  arrow: {
+    color: BoardColorId;
+    size: number;
+  };
+  frame: {
+    color: BoardColorId;
+  };
+};
+type BoardStyledToolId = keyof BoardToolStyleMap;
+type BoardToolStylePatch = { [K in BoardStyledToolId]?: Partial<BoardToolStyleMap[K]>; };
+declare const DEFAULT_BOARD_TOOL_STYLES: {
+  readonly text: {
+    readonly color: "neutral";
+  };
+  readonly geo: {
+    readonly color: "brand";
+    readonly geo: "rectangle";
+  };
+  readonly draw: {
+    readonly color: "brand";
+    readonly size: 4;
+  };
+  readonly arrow: {
+    readonly color: "brand";
+    readonly size: 2.5;
+  };
+  readonly frame: {
+    readonly color: "neutral";
+  };
+};
+declare function clampBoardStrokeSize(size: number): number;
+/** Return a mutable, validated style map for an editor or another Board client. */
+declare function createBoardToolStyles(patch?: BoardToolStylePatch): BoardToolStyleMap;
+//#endregion
+export { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, BoardStyledToolId, BoardToolStyleMap, BoardToolStylePatch, DEFAULT_BOARD_TOOL_STYLES, clampBoardStrokeSize, createBoardToolStyles };

package/dist/board/core/tool-styles.js

@@ -0,0 +1,51 @@
+import { BOARD_ARROW_STROKE_SIZE } from "../../protocol/dist/board-constants.js";
+import { isBoardColorId } from "./palette.js";
+import { isGeoKind } from "./shape-types.js";
+//#region src/board/core/tool-styles.ts
+const BOARD_STROKE_MIN_SIZE = 1;
+const BOARD_STROKE_MAX_SIZE = 64;
+const DEFAULT_BOARD_TOOL_STYLES = {
+	text: { color: "neutral" },
+	geo: {
+		color: "brand",
+		geo: "rectangle"
+	},
+	draw: {
+		color: "brand",
+		size: 4
+	},
+	arrow: {
+		color: "brand",
+		size: BOARD_ARROW_STROKE_SIZE
+	},
+	frame: { color: "neutral" }
+};
+function finiteOr(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function clampBoardStrokeSize(size) {
+	return Math.min(64, Math.max(1, size));
+}
+/** Return a mutable, validated style map for an editor or another Board client. */
+function createBoardToolStyles(patch = {}) {
+	const drawSize = clampBoardStrokeSize(finiteOr(patch.draw?.size, DEFAULT_BOARD_TOOL_STYLES.draw.size));
+	const arrowSize = clampBoardStrokeSize(finiteOr(patch.arrow?.size, DEFAULT_BOARD_TOOL_STYLES.arrow.size));
+	return {
+		text: { color: isBoardColorId(patch.text?.color) ? patch.text.color : DEFAULT_BOARD_TOOL_STYLES.text.color },
+		geo: {
+			color: isBoardColorId(patch.geo?.color) ? patch.geo.color : DEFAULT_BOARD_TOOL_STYLES.geo.color,
+			geo: isGeoKind(patch.geo?.geo) ? patch.geo.geo : DEFAULT_BOARD_TOOL_STYLES.geo.geo
+		},
+		draw: {
+			color: isBoardColorId(patch.draw?.color) ? patch.draw.color : DEFAULT_BOARD_TOOL_STYLES.draw.color,
+			size: drawSize
+		},
+		arrow: {
+			color: isBoardColorId(patch.arrow?.color) ? patch.arrow.color : DEFAULT_BOARD_TOOL_STYLES.arrow.color,
+			size: arrowSize
+		},
+		frame: { color: isBoardColorId(patch.frame?.color) ? patch.frame.color : DEFAULT_BOARD_TOOL_STYLES.frame.color }
+	};
+}
+//#endregion
+export { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, DEFAULT_BOARD_TOOL_STYLES, clampBoardStrokeSize, createBoardToolStyles };

package/dist/board/export/index.d.ts

@@ -0,0 +1,56 @@
+import { BoardDocument, BoardItem } from "../../protocol/dist/board-document.js";
+import { BoardExportPlan, BoardExportPlanInput, BoardExportRegion } from "../core/export-plan.js";
+import { BoardShapeColors } from "../core/palette.js";
+import { BoardRenderPalette } from "../render/renderers/board-renderer-registry.js";
+import "../render/index.js";
+import { BoardExportScene, BoardExportSceneInput, createBoardExportScene } from "./scene.js";
+import { ICanvas, Renderer, Texture } from "pixi.js";
+//#region src/board/export/index.d.ts
+/** Paper behind the content: the theme's page color, or none at all. */
+type BoardExportBackground = "paper" | "transparent" | number;
+type BoardExportOptions = {
+  region?: BoardExportRegion;
+  /** Output pixels per world unit. Defaults to 2. */
+  scale?: number;
+  /** World-space padding. Frame and rect regions default to 0, others to 32. */
+  padding?: number;
+  colorScheme?: "dark" | "light";
+  /** Defaults to "paper" — a transparent PNG surprises people who paste it. */
+  background?: BoardExportBackground;
+  palette?: Partial<BoardRenderPalette>;
+  colors?: BoardShapeColors;
+  /** Resolved textures by preview key; unresolved keys become placeholders. */
+  textures?: Map<string, Texture>;
+  /** Preview-key strategy supplied by the host; defaults to still images only. */
+  assetKey?: (item: BoardItem) => string | null;
+  maxEdge?: number;
+  maxPixels?: number;
+};
+type BoardExportWarning = {
+  kind: "scale-clamped";
+  requested: number;
+  applied: number;
+} | {
+  kind: "images-missing";
+  keys: string[];
+} | {
+  kind: "many-items";
+  count: number;
+};
+type BoardExportResult = {
+  canvas: ICanvas;
+  plan: BoardExportPlan;
+  warnings: BoardExportWarning[];
+};
+/**
+ * Capture a board region as a canvas.
+ *
+ * Returns null when the region is empty — an empty selection is a no-op, not a
+ * failure. The scene is always destroyed, so a throwing renderer cannot leak
+ * GPU resources.
+ */
+declare function renderBoardExport(renderer: Renderer, input: BoardDocument, options?: BoardExportOptions): BoardExportResult | null;
+/** Human-readable form of a warning, shared by the CLI and the web UI. */
+declare function describeBoardExportWarning(warning: BoardExportWarning): string;
+//#endregion
+export { BoardExportBackground, BoardExportOptions, type BoardExportPlan, type BoardExportPlanInput, type BoardExportRegion, BoardExportResult, type BoardExportScene, type BoardExportSceneInput, BoardExportWarning, createBoardExportScene, describeBoardExportWarning, renderBoardExport };

package/dist/board/export/index.js

@@ -0,0 +1,86 @@
+import { normalizeBoardDocument, planBoardExport } from "../core/export-plan.js";
+import { defaultBoardPalette } from "../render/palette.js";
+import { createBoardExportScene } from "./scene.js";
+import { Rectangle } from "pixi.js";
+//#region src/board/export/index.ts
+function resolveBackground(background, palette) {
+	if (background === "transparent") return null;
+	if (typeof background === "number") return background;
+	return palette.bg;
+}
+/**
+* Capture a board region as a canvas.
+*
+* Returns null when the region is empty — an empty selection is a no-op, not a
+* failure. The scene is always destroyed, so a throwing renderer cannot leak
+* GPU resources.
+*/
+function renderBoardExport(renderer, input, options = {}) {
+	const document = normalizeBoardDocument(input);
+	const plan = planBoardExport({
+		document,
+		region: options.region ?? { kind: "all" },
+		scale: options.scale,
+		padding: options.padding,
+		maxEdge: options.maxEdge,
+		maxPixels: options.maxPixels
+	});
+	if (!plan) return null;
+	const colorScheme = options.colorScheme ?? "dark";
+	const palette = {
+		...defaultBoardPalette(colorScheme),
+		...options.palette
+	};
+	const scene = createBoardExportScene({
+		document,
+		items: plan.items,
+		world: plan.world,
+		scale: plan.scale,
+		colorScheme,
+		palette,
+		colors: options.colors,
+		textures: options.textures,
+		assetKey: options.assetKey,
+		background: resolveBackground(options.background, palette)
+	});
+	try {
+		const canvas = renderer.extract.canvas({
+			target: scene.root,
+			frame: new Rectangle(0, 0, plan.width, plan.height),
+			resolution: 1,
+			antialias: true,
+			clearColor: options.background === "transparent" ? void 0 : palette.bg
+		});
+		const warnings = [];
+		if (plan.clamped) warnings.push({
+			kind: "scale-clamped",
+			requested: plan.requestedScale,
+			applied: plan.scale
+		});
+		if (scene.missingImageKeys.length > 0) warnings.push({
+			kind: "images-missing",
+			keys: scene.missingImageKeys
+		});
+		if (plan.items.length > 2e3) warnings.push({
+			kind: "many-items",
+			count: plan.items.length
+		});
+		return {
+			canvas,
+			plan,
+			warnings
+		};
+	} finally {
+		scene.destroy();
+	}
+}
+/** Human-readable form of a warning, shared by the CLI and the web UI. */
+function describeBoardExportWarning(warning) {
+	switch (warning.kind) {
+		case "scale-clamped": return `Scale reduced from ${warning.requested}x to ${warning.applied.toFixed(2)}x to stay within the size limit.`;
+		case "images-missing": return warning.keys.length === 1 ? "1 image could not be loaded and was drawn as a placeholder." : `${warning.keys.length} images could not be loaded and were drawn as placeholders.`;
+		case "many-items": return `${warning.count} items exported; this may take a moment.`;
+	}
+}
+//#endregion
+export { createBoardExportScene, describeBoardExportWarning, renderBoardExport };

package/dist/board/export/scene.d.ts

@@ -0,0 +1,35 @@
+import { BoardDocument, BoardItem } from "../../protocol/dist/board-document.js";
+import { Rect } from "../geometry.js";
+import { BoardShapeColors } from "../core/palette.js";
+import { BoardRenderPalette } from "../render/renderers/board-renderer-registry.js";
+import "../render/index.js";
+import { Container, Texture } from "pixi.js";
+//#region src/board/export/scene.d.ts
+type BoardExportSceneInput = {
+  document: BoardDocument;
+  /** Items to draw, in document (z) order. */
+  items: BoardItem[];
+  /** World rect being captured; content is translated so it starts at 0,0. */
+  world: Rect;
+  /** Output pixels per world unit. Drives text rasterisation resolution. */
+  scale: number;
+  colorScheme: "dark" | "light";
+  palette?: Partial<BoardRenderPalette>;
+  colors?: BoardShapeColors;
+  /** Resolved textures by preview key. Missing keys render as placeholders. */
+  textures?: Map<string, Texture>;
+  /** Preview-key strategy supplied by the host; defaults to still images only. */
+  assetKey?: (item: BoardItem) => string | null;
+  /** Opaque paper behind the content, or null for transparency. */
+  background?: number | null;
+};
+type BoardExportScene = {
+  /** Root to hand to the renderer; already positioned and scaled. */
+  root: Container;
+  /** Image keys the scene wanted but could not resolve. */
+  missingImageKeys: string[];
+  destroy: () => void;
+};
+declare function createBoardExportScene(input: BoardExportSceneInput): BoardExportScene;
+//#endregion
+export { BoardExportScene, BoardExportSceneInput, createBoardExportScene };

package/dist/board/export/scene.js

@@ -0,0 +1,69 @@
+import { imageAssetKey } from "../image-key.js";
+import { buildFallbackShapeColors } from "../core/palette.js";
+import { defaultBoardPalette } from "../render/palette.js";
+import { getBoardCardRenderer } from "../render/renderers/board-renderer-registry.js";
+import { Container, Graphics } from "pixi.js";
+//#region src/board/export/scene.ts
+/**
+* Render context for an export.
+*
+* Interaction state is empty by construction: nothing is selected, hovered or
+* resizing, so no editor chrome (outlines, handles) can leak into the image.
+*/
+function buildContext(input) {
+	const missing = /* @__PURE__ */ new Set();
+	const byId = new Map(input.document.items.map((item) => [item.id, item]));
+	const textures = input.textures ?? /* @__PURE__ */ new Map();
+	return {
+		context: {
+			document: input.document,
+			getItem: (id) => byId.get(id) ?? null,
+			selectedIds: /* @__PURE__ */ new Set(),
+			hoveredId: null,
+			resizingIds: /* @__PURE__ */ new Set(),
+			palette: {
+				...defaultBoardPalette(input.colorScheme),
+				...input.palette
+			},
+			colors: input.colors ?? buildFallbackShapeColors(input.colorScheme),
+			colorScheme: input.colorScheme,
+			zoom: input.scale,
+			assetKey: input.assetKey ?? imageAssetKey,
+			getTexture: (key) => textures.get(key) ?? null,
+			hasError: (key) => {
+				if (!textures.has(key)) missing.add(key);
+				return false;
+			},
+			fileState: () => "ok",
+			acquireTexture: () => {},
+			releaseTexture: () => {}
+		},
+		missing
+	};
+}
+function createBoardExportScene(input) {
+	const { context, missing } = buildContext(input);
+	const root = new Container({ label: "board-export-root" });
+	if (input.background != null) root.addChild(new Graphics().rect(0, 0, input.world.width * input.scale, input.world.height * input.scale).fill({
+		color: input.background,
+		alpha: 1
+	}));
+	const world = new Container({
+		isRenderGroup: true,
+		label: "board-export-world"
+	});
+	world.scale.set(input.scale);
+	world.position.set(-input.world.x * input.scale, -input.world.y * input.scale);
+	for (const item of input.items) {
+		const renderer = getBoardCardRenderer(item, context);
+		world.addChild(renderer.create(item, context));
+	}
+	root.addChild(world);
+	return {
+		root,
+		missingImageKeys: [...missing],
+		destroy: () => root.destroy({ children: true })
+	};
+}
+//#endregion
+export { createBoardExportScene };