@neta-art/cohub 9.0.0 → 10.0.0

package/dist/board/editor/snapping.js

@@ -0,0 +1,75 @@
+//#region src/board/editor/snapping.ts
+/** The three snap positions (near/center/far) of a bounds rect on one axis. */
+function axisPositions(rect, axis) {
+	const origin = axis === "x" ? rect.x : rect.y;
+	const size = axis === "x" ? rect.width : rect.height;
+	return [
+		origin,
+		origin + size / 2,
+		origin + size
+	];
+}
+function axisExtent(rect, axis) {
+	if (axis === "x") return [rect.y, rect.y + rect.height];
+	return [rect.x, rect.x + rect.width];
+}
+/**
+* Compute the snap for a moving selection bounds against candidate target
+* bounds. Each axis is solved independently: the nearest matching edge/center
+* within `threshold` wins. Grid lines are included as targets when enabled.
+*/
+function computeSnap(moving, targets, options) {
+	const { threshold } = options;
+	const guides = [];
+	let dx = 0;
+	let dy = 0;
+	for (const axis of ["x", "y"]) {
+		const movingPositions = axisPositions(moving, axis);
+		const candidates = [];
+		for (const target of targets) {
+			const [from, to] = axisExtent(target, axis);
+			for (const at of axisPositions(target, axis)) candidates.push({
+				at,
+				from,
+				to
+			});
+		}
+		if (options.gridSize && options.gridSize > 0) {
+			const [from, to] = axisExtent(moving, axis);
+			for (const pos of movingPositions) {
+				const grid = Math.round(pos / options.gridSize) * options.gridSize;
+				candidates.push({
+					at: grid,
+					from,
+					to
+				});
+			}
+		}
+		let best = null;
+		for (const movingPos of movingPositions) for (const candidate of candidates) {
+			const delta = candidate.at - movingPos;
+			if (Math.abs(delta) > threshold) continue;
+			if (!best || Math.abs(delta) < Math.abs(best.delta)) best = {
+				delta,
+				...candidate
+			};
+		}
+		if (!best) continue;
+		if (axis === "x") dx = best.delta;
+		else dy = best.delta;
+		const [movingFrom, movingTo] = axisExtent(moving, axis);
+		guides.push({
+			axis,
+			at: best.at,
+			from: Math.min(best.from, movingFrom),
+			to: Math.max(best.to, movingTo)
+		});
+	}
+	return {
+		dx,
+		dy,
+		guides
+	};
+}
+//#endregion
+export { computeSnap };

package/dist/board/editor/snapshots.d.ts

@@ -0,0 +1,27 @@
+import { BoardTaskSnapshot } from "../../protocol/dist/board-model.js";
+import { BoardFileSnapshotFacts } from "../model/file-snapshot.js";
+import "../model/index.js";
+import { EditorContext } from "./context.js";
+//#region src/board/editor/snapshots.d.ts
+type BoardNaturalSize = {
+  id: string;
+  width: number;
+  height: number;
+};
+declare function createSnapshotsModule(ctx: EditorContext): {
+  applyMediaFileChange: (path: string, change: {
+    size?: number;
+    mtimeMs?: number;
+    removed?: boolean;
+  }) => void;
+  adoptMediaNaturalSizes: (sizes: BoardNaturalSize[]) => void;
+  applyFileSnapshots: (snapshots: Array<{
+    id: string;
+    snapshot: BoardFileSnapshotFacts;
+    replace?: boolean;
+  }>) => void;
+  applyTaskSnapshots: (snapshots: ReadonlyMap<string, BoardTaskSnapshot>) => void;
+};
+type SnapshotsModule = ReturnType<typeof createSnapshotsModule>;
+//#endregion
+export { BoardNaturalSize, SnapshotsModule, createSnapshotsModule };

package/dist/board/editor/snapshots.js

@@ -0,0 +1,132 @@
+import { mergeFileSnapshot } from "../model/file-preview.js";
+import { featuredTaskArtifact } from "../model/task.js";
+import { sameJson } from "./document-edits.js";
+//#region src/board/editor/snapshots.ts
+function fitHeight(item, natural) {
+	const height = item.size.width * natural.height / natural.width;
+	if (!Number.isFinite(height) || height <= 0) return null;
+	return {
+		...item,
+		position: {
+			x: item.position.x,
+			y: item.position.y + (item.size.height - height) / 2
+		},
+		size: {
+			...item.size,
+			height
+		}
+	};
+}
+function createSnapshotsModule(ctx) {
+	const { state } = ctx;
+	const commit = (changes) => ctx.document.commitItems(changes, false);
+	function applyMediaFileChange(path, change) {
+		if (change.removed) return;
+		const changes = /* @__PURE__ */ new Map();
+		for (const id of ctx.query.mediaIdsForPath(path)) {
+			const item = state.base.items[id];
+			if (!item || item.type !== "image" && item.type !== "video" && item.type !== "audio") continue;
+			const snapshot = { ...item.props.snapshot };
+			if (change.size !== void 0) snapshot.size = change.size;
+			if (change.mtimeMs !== void 0) snapshot.mtimeMs = change.mtimeMs;
+			delete snapshot.naturalWidth;
+			delete snapshot.naturalHeight;
+			if (item.type === "audio") delete snapshot.durationMs;
+			if (!sameJson(snapshot, item.props.snapshot ?? {})) changes.set(id, {
+				...item,
+				props: {
+					...item.props,
+					snapshot
+				}
+			});
+		}
+		commit(changes);
+	}
+	function adoptMediaNaturalSizes(sizes) {
+		const changes = /* @__PURE__ */ new Map();
+		for (const natural of sizes) {
+			const item = state.base.items[natural.id];
+			if (!item || natural.width <= 0 || natural.height <= 0) continue;
+			const dimensions = {
+				naturalWidth: natural.width,
+				naturalHeight: natural.height
+			};
+			if (item.type === "task") {
+				const artifact = featuredTaskArtifact(item.props.snapshot.artifacts);
+				if (artifact?.type !== "image" && artifact?.type !== "video" || artifact.naturalWidth && artifact.naturalHeight) continue;
+				const fitted = fitHeight(item, natural);
+				if (!fitted) continue;
+				const artifacts = item.props.snapshot.artifacts.map((entry) => entry.id === artifact.id ? {
+					...entry,
+					...dimensions
+				} : entry);
+				changes.set(natural.id, {
+					...fitted,
+					props: {
+						...item.props,
+						snapshot: {
+							...item.props.snapshot,
+							artifacts
+						}
+					}
+				});
+				continue;
+			}
+			if (item.type !== "image" && item.type !== "video") continue;
+			if (item.props.snapshot?.naturalWidth && item.props.snapshot.naturalHeight) continue;
+			const fitted = fitHeight(item, natural);
+			if (!fitted) continue;
+			changes.set(natural.id, {
+				...fitted,
+				props: {
+					...item.props,
+					snapshot: {
+						...item.props.snapshot,
+						...dimensions
+					}
+				}
+			});
+		}
+		commit(changes);
+	}
+	function applyFileSnapshots(snapshots) {
+		const changes = /* @__PURE__ */ new Map();
+		for (const entry of snapshots) {
+			const item = state.base.items[entry.id];
+			if (item?.type !== "file") continue;
+			const merged = mergeFileSnapshot(item.props.snapshot, entry.snapshot, entry.replace === true);
+			if (!sameJson(merged, item.props.snapshot ?? {})) changes.set(entry.id, {
+				...item,
+				props: {
+					...item.props,
+					snapshot: merged
+				}
+			});
+		}
+		commit(changes);
+	}
+	function applyTaskSnapshots(snapshots) {
+		if (snapshots.size === 0) return;
+		const changes = /* @__PURE__ */ new Map();
+		for (const [id, item] of Object.entries(state.base.items)) {
+			if (item.type !== "task") continue;
+			const snapshot = snapshots.get(item.props.taskRunId);
+			if (snapshot && !sameJson(snapshot, item.props.snapshot)) changes.set(id, {
+				...item,
+				props: {
+					...item.props,
+					snapshot
+				}
+			});
+		}
+		commit(changes);
+	}
+	return {
+		applyMediaFileChange,
+		adoptMediaNaturalSizes,
+		applyFileSnapshots,
+		applyTaskSnapshots
+	};
+}
+//#endregion
+export { createSnapshotsModule };

package/dist/board/editor/spatial.d.ts

@@ -0,0 +1,41 @@
+import { Point, Rect } from "../model/geometry.js";
+import "../model/index.js";
+//#region src/board/editor/spatial.d.ts
+/**
+ * An indexed board item: its stable id, z-order (array index, higher = on
+ * top), and an axis-aligned bounding box. The AABB already accounts for
+ * rotation (see itemBounds), so the tree operates in world space and never
+ * reasons about rotation directly — callers refine rotated hits themselves.
+ */
+type SpatialEntry = {
+  id: string;
+  order: number;
+  rect: Rect;
+};
+type SpatialIndex = {
+  /** Rebuild the tree from scratch. */
+  rebuild: (entries: SpatialEntry[]) => void;
+  /**
+   * Apply a set of dirty entries: remove-then-insert each (or remove if
+   * absent from the map). Falls back to a full rebuild when the dirty set is
+   * large or when new entries fall outside the current root bounds.
+   */
+  upsert: (entries: Map<string, SpatialEntry | null>) => void;
+  /** Ids whose AABB intersects the range, in no particular order. */
+  idsInRect: (range: Rect) => string[];
+  /**
+   * Ids whose AABB contains the point, ordered topmost-first (highest
+   * z-order first) so callers can refine with an exact rotated hit test and
+   * take the first match.
+   */
+  idsAtPoint: (point: Point) => string[];
+  readonly size: number;
+};
+/**
+ * A point quadtree over item bounding boxes. Supports both wholesale rebuild
+ * (document load / large batch changes) and dirty-entry upsert (gesture frames)
+ * so a drag never pays a full O(n) rebuild every frame.
+ */
+declare function createSpatialIndex(): SpatialIndex;
+//#endregion
+export { SpatialEntry, SpatialIndex, createSpatialIndex };

package/dist/board/editor/spatial.js

@@ -0,0 +1,191 @@
+import { rectContainsPoint, rectsIntersect } from "../model/geometry.js";
+//#region src/board/editor/spatial.ts
+/** Max entries in a leaf before it subdivides. */
+const NODE_CAPACITY = 8;
+/** Deepest the tree may subdivide (bounds get tiny; stop splitting). */
+const MAX_DEPTH = 10;
+/** Subdivision stops once a cell is smaller than this (degenerate bounds). */
+const MIN_CELL_SIZE = 1;
+/**
+* When dirty entries exceed this fraction of the tree (or this absolute count),
+* a full rebuild is cheaper and more compact than many surgical removes.
+*/
+const REBUILD_DIRTY_RATIO = .25;
+const REBUILD_DIRTY_MIN = 32;
+function rectContainsRect(outer, inner) {
+	return inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.width <= outer.x + outer.width && inner.y + inner.height <= outer.y + outer.height;
+}
+function quadrantBounds(bounds) {
+	const halfW = bounds.width / 2;
+	const halfH = bounds.height / 2;
+	const { x, y } = bounds;
+	return [
+		{
+			x,
+			y,
+			width: halfW,
+			height: halfH
+		},
+		{
+			x: x + halfW,
+			y,
+			width: halfW,
+			height: halfH
+		},
+		{
+			x,
+			y: y + halfH,
+			width: halfW,
+			height: halfH
+		},
+		{
+			x: x + halfW,
+			y: y + halfH,
+			width: halfW,
+			height: halfH
+		}
+	];
+}
+function createNode(bounds, depth) {
+	return {
+		bounds,
+		depth,
+		entries: [],
+		children: null
+	};
+}
+function canSubdivide(node) {
+	return node.depth < MAX_DEPTH && node.bounds.width > MIN_CELL_SIZE && node.bounds.height > MIN_CELL_SIZE;
+}
+function insertEntry(node, entry) {
+	if (node.children) {
+		for (const child of node.children) if (rectContainsRect(child.bounds, entry.rect)) {
+			insertEntry(child, entry);
+			return;
+		}
+		node.entries.push(entry);
+		return;
+	}
+	node.entries.push(entry);
+	if (node.entries.length <= NODE_CAPACITY || !canSubdivide(node)) return;
+	node.children = quadrantBounds(node.bounds).map((bounds) => createNode(bounds, node.depth + 1));
+	const kept = [];
+	for (const existing of node.entries) {
+		let placed = false;
+		for (const child of node.children) if (rectContainsRect(child.bounds, existing.rect)) {
+			insertEntry(child, existing);
+			placed = true;
+			break;
+		}
+		if (!placed) kept.push(existing);
+	}
+	node.entries = kept;
+}
+/** Remove an entry by id. Returns true if found. */
+function removeEntry(node, id) {
+	const index = node.entries.findIndex((entry) => entry.id === id);
+	if (index >= 0) {
+		node.entries.splice(index, 1);
+		return true;
+	}
+	if (!node.children) return false;
+	for (const child of node.children) if (removeEntry(child, id)) return true;
+	return false;
+}
+function queryRect(node, range, out) {
+	if (!rectsIntersect(node.bounds, range)) return;
+	for (const entry of node.entries) if (rectsIntersect(entry.rect, range)) out.push(entry);
+	if (!node.children) return;
+	for (const child of node.children) queryRect(child, range, out);
+}
+function queryPoint(node, point, out) {
+	if (!rectContainsPoint(node.bounds, point)) return;
+	for (const entry of node.entries) if (rectContainsPoint(entry.rect, point)) out.push(entry);
+	if (!node.children) return;
+	for (const child of node.children) queryPoint(child, point, out);
+}
+/**
+* A point quadtree over item bounding boxes. Supports both wholesale rebuild
+* (document load / large batch changes) and dirty-entry upsert (gesture frames)
+* so a drag never pays a full O(n) rebuild every frame.
+*/
+function createSpatialIndex() {
+	let root = null;
+	/** Authoritative entry map — source of truth for rebuilds. */
+	const byId = /* @__PURE__ */ new Map();
+	function rebuildFromMap() {
+		const entries = [...byId.values()];
+		if (entries.length === 0) {
+			root = null;
+			return;
+		}
+		let minX = Number.POSITIVE_INFINITY;
+		let minY = Number.POSITIVE_INFINITY;
+		let maxX = Number.NEGATIVE_INFINITY;
+		let maxY = Number.NEGATIVE_INFINITY;
+		for (const entry of entries) {
+			minX = Math.min(minX, entry.rect.x);
+			minY = Math.min(minY, entry.rect.y);
+			maxX = Math.max(maxX, entry.rect.x + entry.rect.width);
+			maxY = Math.max(maxY, entry.rect.y + entry.rect.height);
+		}
+		const width = Math.max(maxX - minX, MIN_CELL_SIZE);
+		const height = Math.max(maxY - minY, MIN_CELL_SIZE);
+		const pad = Math.max(width, height) * .05;
+		root = createNode({
+			x: minX - pad,
+			y: minY - pad,
+			width: width + pad * 2,
+			height: height + pad * 2
+		}, 0);
+		for (const entry of entries) insertEntry(root, entry);
+	}
+	function rebuild(entries) {
+		byId.clear();
+		for (const entry of entries) byId.set(entry.id, entry);
+		rebuildFromMap();
+	}
+	function upsert(entries) {
+		if (entries.size === 0) return;
+		const dirtyCount = entries.size;
+		const total = Math.max(byId.size, 1);
+		const shouldRebuild = dirtyCount >= REBUILD_DIRTY_MIN && dirtyCount / total >= REBUILD_DIRTY_RATIO;
+		let expandsRoot = false;
+		for (const [id, entry] of entries) if (entry) {
+			byId.set(id, entry);
+			if (root && !rectContainsRect(root.bounds, entry.rect)) expandsRoot = true;
+		} else byId.delete(id);
+		if (!root || shouldRebuild || expandsRoot) {
+			rebuildFromMap();
+			return;
+		}
+		for (const [id, entry] of entries) {
+			removeEntry(root, id);
+			if (entry) insertEntry(root, entry);
+		}
+	}
+	function idsInRect(range) {
+		if (!root) return [];
+		const hits = [];
+		queryRect(root, range, hits);
+		return hits.map((entry) => entry.id);
+	}
+	function idsAtPoint(point) {
+		if (!root) return [];
+		const hits = [];
+		queryPoint(root, point, hits);
+		hits.sort((a, b) => b.order - a.order);
+		return hits.map((entry) => entry.id);
+	}
+	return {
+		rebuild,
+		upsert,
+		idsInRect,
+		idsAtPoint,
+		get size() {
+			return byId.size;
+		}
+	};
+}
+//#endregion
+export { createSpatialIndex };

package/dist/board/editor/state.d.ts

@@ -0,0 +1,12 @@
+//#region src/board/editor/state.d.ts
+type BoardEditorChannel = "document" | "scene" | "selection" | "camera" | "tool" | "interaction" | "hover" | "editing" | "playback" | "history" | "status";
+type BoardEditorListener = () => void;
+type BoardEditorChannels = {
+  emit(channel: BoardEditorChannel): void;
+  subscribe(channels: BoardEditorChannel | readonly BoardEditorChannel[], listener: BoardEditorListener): () => void;
+};
+declare function createChannels(): BoardEditorChannels;
+declare function observable<T extends Record<string, unknown>>(initial: T, channelOf: { readonly [K in keyof T]: BoardEditorChannel; }, channels: BoardEditorChannels): T;
+declare function memo<const D extends readonly unknown[], R>(inputs: () => D, compute: (...inputs: D) => R): () => R;
+//#endregion
+export { BoardEditorChannel, BoardEditorChannels, BoardEditorListener, createChannels, memo, observable };

package/dist/board/editor/state.js

@@ -0,0 +1,49 @@
+//#region src/board/editor/state.ts
+function createChannels() {
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		emit(channel) {
+			const subscribed = listeners.get(channel);
+			if (subscribed) for (const listener of [...subscribed]) listener();
+		},
+		subscribe(channels, listener) {
+			const list = typeof channels === "string" ? [channels] : channels;
+			for (const channel of list) {
+				const set = listeners.get(channel) ?? /* @__PURE__ */ new Set();
+				set.add(listener);
+				listeners.set(channel, set);
+			}
+			return () => {
+				for (const channel of list) listeners.get(channel)?.delete(listener);
+			};
+		}
+	};
+}
+function observable(initial, channelOf, channels) {
+	const values = { ...initial };
+	const state = {};
+	for (const key of Object.keys(initial)) Object.defineProperty(state, key, {
+		enumerable: true,
+		get: () => values[key],
+		set: (value) => {
+			if (Object.is(values[key], value)) return;
+			values[key] = value;
+			channels.emit(channelOf[key]);
+		}
+	});
+	return state;
+}
+function memo(inputs, compute) {
+	let previous = null;
+	let value;
+	return () => {
+		const next = inputs();
+		if (previous === null || next.length !== previous.length || next.some((input, index) => !Object.is(input, previous?.[index]))) {
+			previous = next;
+			value = compute(...next);
+		}
+		return value;
+	};
+}
+//#endregion
+export { createChannels, memo, observable };

package/dist/board/editor/tool.d.ts

@@ -0,0 +1,10 @@
+//#region src/board/editor/tool.d.ts
+type BoardToolId = "select" | "hand" | "text" | "shape" | "draw" | "arrow" | "frame";
+declare const BOARD_HAND_TAP_SLOP = 8;
+declare function defaultBoardTool(isMobile: boolean): BoardToolId;
+declare function canTapSelectWithHand(pointerType: string): boolean;
+declare function isWithinHandTapSlop(dx: number, dy: number): boolean;
+declare function isContinuousBoardTool(tool: BoardToolId): boolean;
+declare function isCreationBoardTool(tool: BoardToolId): boolean;
+//#endregion
+export { BOARD_HAND_TAP_SLOP, BoardToolId, canTapSelectWithHand, defaultBoardTool, isContinuousBoardTool, isCreationBoardTool, isWithinHandTapSlop };

package/dist/board/editor/tool.js

@@ -0,0 +1,19 @@
+//#region src/board/editor/tool.ts
+const BOARD_HAND_TAP_SLOP = 8;
+function defaultBoardTool(isMobile) {
+	return isMobile ? "hand" : "select";
+}
+function canTapSelectWithHand(pointerType) {
+	return pointerType === "touch" || pointerType === "pen";
+}
+function isWithinHandTapSlop(dx, dy) {
+	return Number.isFinite(dx) && Number.isFinite(dy) && Math.hypot(dx, dy) <= 8;
+}
+function isContinuousBoardTool(tool) {
+	return tool === "draw";
+}
+function isCreationBoardTool(tool) {
+	return tool === "text" || tool === "shape" || tool === "draw" || tool === "arrow" || tool === "frame";
+}
+//#endregion
+export { BOARD_HAND_TAP_SLOP, canTapSelectWithHand, defaultBoardTool, isContinuousBoardTool, isCreationBoardTool, isWithinHandTapSlop };

package/dist/board/editor/wheel.d.ts

@@ -0,0 +1,5 @@
+//#region src/board/editor/wheel.d.ts
+declare function normalizeWheelDelta(delta: number, deltaMode?: number): number;
+declare function wheelZoomFactor(deltaY: number, deltaMode?: number): number;
+//#endregion
+export { normalizeWheelDelta, wheelZoomFactor };

package/dist/board/editor/wheel.js

@@ -0,0 +1,17 @@
+//#region src/board/editor/wheel.ts
+const WHEEL_ZOOM_INTENSITY = .012;
+const MAX_WHEEL_ZOOM_FACTOR = 1.35;
+const LINE_DELTA_PX = 16;
+const PAGE_DELTA_PX = 80;
+function normalizeWheelDelta(delta, deltaMode = 0) {
+	if (!Number.isFinite(delta)) return 0;
+	if (deltaMode === 1) return delta * LINE_DELTA_PX;
+	if (deltaMode === 2) return delta * PAGE_DELTA_PX;
+	return delta;
+}
+function wheelZoomFactor(deltaY, deltaMode = 0) {
+	const factor = Math.exp(-normalizeWheelDelta(deltaY, deltaMode) * WHEEL_ZOOM_INTENSITY);
+	return Math.min(MAX_WHEEL_ZOOM_FACTOR, Math.max(1 / MAX_WHEEL_ZOOM_FACTOR, factor));
+}
+//#endregion
+export { normalizeWheelDelta, wheelZoomFactor };

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

@@ -1,9 +1,9 @@
 import { BoardDocument } from "../../protocol/dist/board-model.js";
 import "../../protocol/dist/index.js";
-import { BoardSceneItem } from "../core/scene.js";
-import { BoardExportPlan, BoardExportPlanInput, BoardExportRegion } from "../core/export-plan.js";
-import { BoardShapeColors } from "../core/palette.js";
-import { BoardRenderPalette, BoardSketchHost } from "../render/renderers/board-renderer-registry.js";
+import { BoardSceneItem } from "../model/scene.js";
+import { BoardExportPlan, BoardExportPlanInput, BoardExportRegion } from "../model/export-plan.js";
+import { BoardShapeColors } from "../model/palette.js";
+import { BoardCardRendererResolver, BoardRenderPalette, BoardSketchHost } 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";
@@ -24,6 +24,7 @@ type BoardExportOptions = {
   textures?: Map<string, Texture>;
   sketches?: BoardSketchHost;
   assetKey?: (item: BoardSceneItem) => string | null;
+  renderers?: BoardCardRendererResolver;
   backgroundImage?: {
     texture: Texture;
     fit: "cover" | "contain" | "repeat";

package/dist/board/export/index.js

@@ -1,6 +1,6 @@
-import { boardDocumentAt } from "../animation.js";
-import { normalizeBoardDocument, planBoardExport } from "../core/export-plan.js";
-import { buildBoardScene } from "../core/scene.js";
+import { boardDocumentAt } from "../model/animation.js";
+import { normalizeBoardDocument, planBoardExport } from "../model/export-plan.js";
+import { buildBoardScene } from "../model/scene.js";
 import { parseBoardCssColor } from "../render/css-color.js";
 import { defaultBoardPalette } from "../render/palette.js";
 import { ensureBoardTextMeasurement } from "../render/text-measurement.js";
@@ -46,6 +46,7 @@ function renderBoardExport(renderer, input, options = {}) {
 		textures: options.textures,
 		sketches: options.sketches,
 		assetKey: options.assetKey,
+		renderers: options.renderers,
 		background: resolveBackground(options.background, palette, document, colorScheme),
 		backgroundImage: options.backgroundImage
 	});

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

@@ -0,0 +1,55 @@
+import { BoardDocument } from "../../../protocol/dist/board-model.js";
+import "../../../protocol/dist/index.js";
+import { BoardSketchHost } from "../../render/renderers/board-renderer-registry.js";
+import { BoardExportOptions, BoardExportResult } from "../index.js";
+import { createNodeBoardSketchHost } from "./sketch.js";
+import { Renderer } from "pixi.js";
+//#region src/board/export/node/index.d.ts
+type NodeCanvasModule = {
+  createCanvas: (width: number, height: number) => unknown;
+  Image: new () => unknown;
+  GlobalFonts: {
+    registerFromPath: (path: string, name?: string) => unknown;
+    has: (name: string) => boolean;
+    setAlias?: (fontName: string, alias: string) => boolean;
+  };
+};
+type BoardNodeFont = {
+  path: string;
+  family?: string;
+};
+type BoardNodeRendererOptions = {
+  fonts?: BoardNodeFont[];
+  canvasModule?: NodeCanvasModule;
+};
+type BoardNodeTexture = {
+  readonly __boardTexture: unique symbol;
+};
+type BoardNodeRenderer = {
+  renderer: Renderer;
+  canvasModule: NodeCanvasModule;
+  decodeImage: (bytes: Uint8Array, mimeType?: string) => Promise<BoardNodeTexture>;
+  destroy: () => void;
+};
+declare function createNodeBoardRenderer(options?: BoardNodeRendererOptions): Promise<BoardNodeRenderer>;
+type BoardNodeExportFormat = "png" | "jpeg" | "webp";
+type BoardNodeExportOptions = Omit<BoardExportOptions, "textures" | "backgroundImage"> & {
+  textures?: Map<string, BoardNodeTexture>;
+  backgroundImage?: {
+    texture: BoardNodeTexture;
+    fit: "cover" | "contain" | "repeat";
+    position: "center" | "top" | "bottom" | "left" | "right";
+    opacity: number;
+  };
+  sketches?: BoardSketchHost;
+  format?: BoardNodeExportFormat;
+  quality?: number;
+};
+type BoardNodeExportResult = Omit<BoardExportResult, "canvas"> & {
+  bytes: Uint8Array;
+  format: BoardNodeExportFormat;
+};
+declare function boardImageMimeType(format: BoardNodeExportFormat): string;
+declare function exportBoardImageBytes(renderer: BoardNodeRenderer, document: BoardDocument, options?: BoardNodeExportOptions): BoardNodeExportResult | null;
+//#endregion
+export { BoardNodeExportFormat, BoardNodeExportOptions, BoardNodeExportResult, BoardNodeFont, BoardNodeRenderer, BoardNodeRendererOptions, BoardNodeTexture, NodeCanvasModule, boardImageMimeType, createNodeBoardRenderer, createNodeBoardSketchHost, exportBoardImageBytes };