@lupinum/board-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Lupinum OG and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+<p align="center"><img src="https://raw.githubusercontent.com/lupinum-dev/nuxt-board/main/docs/public/app-icon.svg" width="128" alt="Nuxt Board icon"></p>
+
+<h1 align="center">@lupinum/board-core</h1>
+
+<p align="center">Own board state and commands without a framework dependency.</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@lupinum/board-core"><img src="https://img.shields.io/npm/v/@lupinum/board-core?label=npm" alt="npm version"></a>
+  <a href="https://github.com/lupinum-dev/nuxt-board/actions/workflows/ci.yml"><img src="https://github.com/lupinum-dev/nuxt-board/actions/workflows/ci.yml/badge.svg" alt="CI status"></a>
+  <a href="https://github.com/lupinum-dev/nuxt-board/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT license"></a>
+</p>
+
+> [!WARNING]
+> This package has not reached a stable release. Review the changelog before each upgrade.
+
+## Purpose
+
+Use this package for board state, commands, selection, grouping, camera control, snapping, guards, events, and first-party plugin hooks.
+
+## Requirements
+
+The package is framework independent. Use `@lupinum/vue-board` or `@lupinum/nuxt-board` when you need rendering.
+
+## Installation
+
+```bash
+pnpm add @lupinum/board-core
+```
+
+## Quick start
+
+```ts
+import { createBoardEngine } from '@lupinum/board-core'
+
+const engine = createBoardEngine({ grid: { size: 20, snap: true } })
+const node = engine.createNode({ type: 'text', x: 80, y: 80, text: 'Node' })
+
+engine.select(node.id)
+```
+
+## Exports
+
+The `@lupinum/board-core/internal` subpath is only for separately published first-party packages. Applications must use the top-level API and supported plugins.
+
+## Documentation
+
+Read the [board core reference](https://nuxt-board.lupinum.com/docs/reference/board-core).
+
+## Support and security
+
+Open a [GitHub issue](https://github.com/lupinum-dev/nuxt-board/issues) for support. Report vulnerabilities through the [private security process](https://github.com/lupinum-dev/nuxt-board/security/policy).
+
+## License
+
+This package uses the [MIT License](https://github.com/lupinum-dev/nuxt-board/blob/main/LICENSE).

package/dist/chunk-5JZXHZWR.js

@@ -0,0 +1,68 @@
+// src/errors.ts
+var BoardError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var BoardInputError = class extends BoardError {
+};
+var BoardNotFoundError = class extends BoardError {
+};
+var BoardConflictError = class extends BoardError {
+};
+var BoardDestroyedError = class extends BoardError {
+  constructor() {
+    super("Board engine has been destroyed.");
+  }
+};
+
+// src/engine/interaction-adapter.ts
+var adapterKey = /* @__PURE__ */ Symbol.for("@lupinum/board-core/interaction-adapter");
+function registerBoardInteractionAdapter(engine, adapter) {
+  Object.defineProperty(engine, adapterKey, {
+    configurable: true,
+    value: adapter,
+    enumerable: false
+  });
+}
+function getRegisteredBoardInteractionAdapter(engine) {
+  const adapter = Reflect.get(engine, adapterKey);
+  if (!adapter) {
+    throw new BoardInputError(
+      "The supplied engine was not created by createBoardEngine()."
+    );
+  }
+  return adapter;
+}
+
+// src/internal.ts
+function getBoardInteractionAdapter(engine) {
+  return getRegisteredBoardInteractionAdapter(engine);
+}
+function defineInternalBoardPlugin(plugin) {
+  return plugin;
+}
+function assertInternalBoardPlugin(plugin) {
+  const candidate = plugin;
+  if (typeof candidate.name !== "string" || candidate.name.length === 0) {
+    throw new Error("Invalid board plugin: expected a named plugin token.");
+  }
+  if (typeof candidate.install !== "function") {
+    throw new Error(
+      `Invalid board plugin "${candidate.name}": expected a token created by a first-party plugin factory.`
+    );
+  }
+}
+
+export {
+  BoardError,
+  BoardInputError,
+  BoardNotFoundError,
+  BoardConflictError,
+  BoardDestroyedError,
+  registerBoardInteractionAdapter,
+  getBoardInteractionAdapter,
+  defineInternalBoardPlugin,
+  assertInternalBoardPlugin
+};

package/dist/colors.d.ts

@@ -0,0 +1,9 @@
+import type { BoardColorPreset } from './types.js';
+export interface BoardColorOption {
+    preset: BoardColorPreset;
+    hex: string;
+    label: string;
+}
+export declare const BOARD_COLOR_PRESETS: readonly BoardColorOption[];
+export declare function isBoardColorPreset(value: unknown): value is BoardColorPreset;
+export declare function colorForPreset(preset: BoardColorPreset | undefined): string;

package/dist/engine/camera-session.d.ts

@@ -0,0 +1,14 @@
+import type { BoardNode, Camera, NodeId, Point, ZoomSettings } from '../types.js';
+interface CameraSessionDeps {
+    getCamera(): Camera;
+    getNodes(): Iterable<BoardNode>;
+    getViewportSize(): Point;
+    setCamera(camera: Camera): void;
+    zoom: ZoomSettings;
+}
+export declare function createCameraSession(deps: CameraSessionDeps): {
+    animateTo: (target: Camera) => Promise<void>;
+    cancelAnimations: () => void;
+    computeFit: (ids: readonly NodeId[] | null, padding?: number) => Camera | null;
+};
+export {};

package/dist/engine/command-runtime.d.ts

@@ -0,0 +1,31 @@
+import type { BatchController } from '../subscribable.js';
+import type { BoardState, CommandGuard, CommandMetadata, GridSettings, ValidationFailure } from '../types.js';
+interface CommandGuardRegistry {
+    add(fn: CommandGuard): () => void;
+    run(name: string, args: unknown[], metadata: CommandMetadata): string | null;
+    clear(): void;
+}
+interface BatchDeps {
+    batchCtrl: BatchController;
+    emitCommandBefore: (name: string, args: unknown[], metadata: CommandMetadata) => void;
+    emitCommandAfter: (name: string, args: unknown[], duration: number, metadata: CommandMetadata) => void;
+    validate: (context: string) => void;
+}
+interface BatchCommandController {
+    isBatching(): boolean;
+    markValidationPending(): void;
+    begin(): void;
+    end(beforePublish?: () => void): void;
+    batch(fn: () => void, beforePublish?: () => void): void;
+    flushBatchNotifications(): void;
+    rollbackBatchNotifications(): void;
+}
+interface ValidationDeps {
+    getState: () => BoardState;
+    getGrid: () => GridSettings;
+    emitFailure: (failure: ValidationFailure) => void;
+}
+export declare function createCommandGuardRegistry(): CommandGuardRegistry;
+export declare function createValidator(deps: ValidationDeps): (context: string) => void;
+export declare function createBatchCommandController(deps: BatchDeps): BatchCommandController;
+export {};

package/dist/engine/events.d.ts

@@ -0,0 +1,21 @@
+import type { BoardEventMap, BoardUnhandledErrorContext, TraceEntry } from '../types.js';
+interface EventBusOptions {
+    diagnosticsEnabled: boolean;
+    traceLimit: number;
+    onUnhandledError?: (error: unknown, context: BoardUnhandledErrorContext) => void;
+}
+interface EventBus {
+    emit<K extends keyof BoardEventMap>(event: K, ...args: Parameters<BoardEventMap[K]>): void;
+    emitImmediate<K extends keyof BoardEventMap>(event: K, ...args: Parameters<BoardEventMap[K]>): void;
+    on<K extends keyof BoardEventMap>(event: K, handler: BoardEventMap[K]): () => void;
+    once<K extends keyof BoardEventMap>(event: K, handler: BoardEventMap[K]): () => void;
+    off<K extends keyof BoardEventMap>(event: K, handler: BoardEventMap[K]): void;
+    exportTrace(): TraceEntry[];
+    beginTransaction(): void;
+    commitTransaction(): void;
+    rollbackTransaction(): void;
+    reportUnhandledError(error: unknown, context: BoardUnhandledErrorContext): void;
+    clear(): void;
+}
+export declare function createEventBus(opts: EventBusOptions): EventBus;
+export {};

package/dist/engine/interaction-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { BoardEngine, InternalInteractionAdapter } from '../types.js';
+export declare function registerBoardInteractionAdapter(engine: BoardEngine, adapter: InternalInteractionAdapter): void;
+export declare function getRegisteredBoardInteractionAdapter(engine: BoardEngine): InternalInteractionAdapter;

package/dist/engine/node-shape.d.ts

@@ -0,0 +1,16 @@
+import type { BoardNode, GridSettings, NodeConstraints, NodeId, NodeInput, NodePatch } from '../types.js';
+interface NodeShapeContext {
+    nodes: ReadonlyMap<NodeId, BoardNode>;
+    grid: GridSettings;
+    constraints: NodeConstraints;
+}
+export declare function assertValidNodeGeometry(id: NodeId, geometry: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>): void;
+export declare function assertValidParentLink(nodes: ReadonlyMap<NodeId, BoardNode>, id: NodeId, parentId: NodeId | undefined): void;
+export declare function normalizeNodeInput(input: NodeInput, context: NodeShapeContext & {
+    nextZIndex: number;
+}): {
+    node: BoardNode;
+    nextZIndex: number;
+};
+export declare function applyNodePatchToNode(node: BoardNode, patch: NodePatch, context: NodeShapeContext): BoardNode;
+export {};

package/dist/engine/options.d.ts

@@ -0,0 +1,17 @@
+import type { BoardEngineOptions, BoardPlugin, BoxSelectBehavior, Camera, GridSettings, NodeConstraints, ZoomSettings } from '../types.js';
+interface ResolvedBoardConfiguration {
+    camera: Camera;
+    zoom: ZoomSettings;
+    grid: GridSettings;
+    nodeConstraints: NodeConstraints;
+    plugins: readonly BoardPlugin[];
+    diagnostics: BoardEngineOptions['diagnostics'];
+    boxSelectBehavior: BoxSelectBehavior;
+}
+/** Validate a camera before it becomes observable runtime state. */
+export declare function validateCamera(camera: Camera): void;
+/** Validate the complete runtime grid contract used by constructor and updates. */
+export declare function validateGridSettings(grid: GridSettings): void;
+/** Validate resolved constructor options before the engine allocates mutable resources. */
+export declare function validateBoardConfiguration(config: ResolvedBoardConfiguration): void;
+export {};

package/dist/engine/persistence.d.ts

@@ -0,0 +1,18 @@
+import type { BoardNode, InternalBoardSnapshot, JsonCanvasDocument, JsonCanvasNodeType } from '../types.js';
+export declare function normalizeNodeType(value: unknown): JsonCanvasNodeType;
+export declare function withNodeFields(base: Pick<BoardNode, 'id' | 'x' | 'y' | 'width' | 'height' | 'color' | 'zIndex' | 'locked' | 'visible' | 'parentId'> & {
+    type: JsonCanvasNodeType;
+}, input: {
+    type?: string;
+    text?: string;
+    file?: string;
+    subpath?: string;
+    url?: string;
+    label?: string;
+    background?: string;
+    backgroundStyle?: string;
+}): BoardNode;
+export declare function toPersistedDocument(snapshot: InternalBoardSnapshot, featureDocuments: Partial<JsonCanvasDocument>[]): JsonCanvasDocument;
+export declare function normalizeDocumentForImport(raw: unknown): JsonCanvasDocument;
+export declare function materializeSnapshotNodes(snapshot: InternalBoardSnapshot): BoardNode[];
+export declare function documentToSnapshot(document: JsonCanvasDocument): InternalBoardSnapshot;

package/dist/engine/subscribables.d.ts

@@ -0,0 +1,34 @@
+import type { BatchController } from '../subscribable.js';
+import type { BoardEventMap, BoardNode, Camera, GridSettings, InteractionState, NodeId, SnapGuide, Subscribable } from '../types.js';
+import type { MutableBoardState } from '../state/types.js';
+interface ReactiveLayer {
+    batchCtrl: BatchController;
+    $camera: Subscribable<Camera>;
+    $grid: Subscribable<GridSettings>;
+    $nodes: Subscribable<ReadonlyMap<NodeId, BoardNode>>;
+    $selection: Subscribable<ReadonlySet<NodeId>>;
+    $interaction: Subscribable<InteractionState>;
+    $snapGuides: Subscribable<readonly SnapGuide[]>;
+    getPublicNodeMap: () => ReadonlyMap<NodeId, BoardNode>;
+    invalidateNodeCache: () => void;
+    notifyNodesChanged: () => void;
+    notifyCameraChanged: () => void;
+    notifyGridChanged: () => void;
+    notifySelectionChanged: () => void;
+    notifyInteractionChanged: () => void;
+    notifySnapGuidesChanged: () => void;
+    setCamera: (next: Camera) => void;
+    setSelection: (next: Iterable<NodeId>) => void;
+    setInteraction: (next: InteractionState) => void;
+    setSnapGuides: (next: SnapGuide[]) => void;
+    destroy: () => void;
+}
+interface ReactiveLayerDeps {
+    getState: () => MutableBoardState;
+    getGrid: () => GridSettings;
+    getEffectiveNodes: () => Map<NodeId, BoardNode>;
+    emit: <K extends keyof BoardEventMap>(event: K, ...args: Parameters<BoardEventMap[K]>) => void;
+    reportSubscriberError: (channel: string, error: unknown) => void;
+}
+export declare function createReactiveLayer(deps: ReactiveLayerDeps): ReactiveLayer;
+export {};

package/dist/engine/transaction.d.ts

@@ -0,0 +1,56 @@
+import type { MutableBoardState } from '../state/types.js';
+import type { InternalHistoryRoot } from '../state/types.js';
+import type { CommandMetadata, GridSettings } from '../types.js';
+export type MutablePluginStates = Map<string, {
+    state: unknown;
+}>;
+export interface PersistentRoots {
+    state: MutableBoardState;
+    grid: GridSettings;
+    pluginStates: MutablePluginStates;
+}
+export type RuntimeCommandMetadata = CommandMetadata & {
+    validate?: false;
+};
+interface TransactionExecutorDeps<TRoot> {
+    assertAlive: () => void;
+    runGuard: (name: string, args: unknown[], metadata: CommandMetadata) => string | null;
+    emitBlocked: (name: string, args: unknown[], metadata: CommandMetadata) => void;
+    emitBefore: (name: string, args: unknown[], metadata: CommandMetadata) => void;
+    emitAfter: (name: string, args: unknown[], duration: number, metadata: CommandMetadata) => void;
+    createBlockedError: (name: string, args: unknown[], reason: string) => Error;
+    isBatching: () => boolean;
+    canOwnEffects: () => boolean;
+    beginEffects: () => void;
+    commitEffects: () => void;
+    rollbackEffects: () => void;
+    markValidationPending: () => void;
+    captureHistoryRoot: () => InternalHistoryRoot;
+    beginPersistentTransaction: () => TRoot;
+    rollbackPersistentTransaction: (checkpoint: TRoot) => void;
+    beforeExecute: (name: string, metadata: CommandMetadata, historyBefore: InternalHistoryRoot | null) => InternalHistoryRoot | null;
+    prepareCommit: (label: string, metadata: CommandMetadata, before: InternalHistoryRoot) => PreparedCommit | null;
+    reportCommitError: (label: string, error: unknown) => void;
+    validate: (context: string) => void;
+    isCancellation: (error: unknown) => boolean;
+}
+interface CommitOverride {
+    before: InternalHistoryRoot;
+    label: string;
+    metadata: CommandMetadata;
+}
+export interface PreparedCommit {
+    readonly label: string;
+    readonly finalize: () => readonly unknown[];
+}
+/** Own guarded command staging, validation, publication, and rollback order. */
+export declare function createTransactionExecutor<TRoot>(deps: TransactionExecutorDeps<TRoot>): {
+    runCommand: <T>(name: string, args: unknown[], fn: () => T, metadata?: RuntimeCommandMetadata, commitOverride?: CommitOverride) => T;
+    runAsyncCommand: <T>(name: string, args: unknown[], fn: () => Promise<T>, metadata?: RuntimeCommandMetadata) => Promise<T>;
+};
+/**
+ * Create an isolated candidate for one outer persistent command.
+ * Node records and plugin slices remain shared until a command replaces them.
+ */
+export declare function stagePersistentRoots(roots: PersistentRoots): PersistentRoots;
+export {};

package/dist/engine.d.ts

@@ -0,0 +1,17 @@
+import { BoardError } from './errors.js';
+import type { BoardEngine, BoardEngineOptions, InstalledPluginApis, InstalledPluginEvents, BoardPlugin } from './types.js';
+export declare class CommandBlockedError extends BoardError {
+    readonly command: string;
+    readonly args: readonly unknown[];
+    readonly reason: string;
+    constructor(command: string, args: readonly unknown[], reason: string);
+}
+/**
+ * Create a headless board engine with commands, reactive state, and internal plugin hooks.
+ *
+ * @example
+ * const engine = createBoardEngine({
+ *   initialNodes: [{ id: asNodeId('a'), type: 'text', x: 0, y: 0, width: 160, height: 80, text: 'Hello', zIndex: 1, locked: false, visible: true }],
+ * })
+ */
+export declare function createBoardEngine<const TPlugins extends readonly BoardPlugin[] = readonly []>(options?: BoardEngineOptions<TPlugins>): BoardEngine<InstalledPluginApis<TPlugins>, InstalledPluginEvents<TPlugins>>;

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+/** Base error for failures raised by the board engine. */
+export declare class BoardError extends Error {
+    constructor(message: string);
+}
+/** The caller supplied a value that cannot form a valid board state. */
+export declare class BoardInputError extends BoardError {
+}
+/** The requested entity does not exist. */
+export declare class BoardNotFoundError extends BoardError {
+}
+/** The requested mutation conflicts with existing canonical state. */
+export declare class BoardConflictError extends BoardError {
+}
+/** The engine has been destroyed and can no longer be used. */
+export declare class BoardDestroyedError extends BoardError {
+    constructor();
+}

package/dist/helpers/animation.d.ts

@@ -0,0 +1,9 @@
+interface AnimationFrameDriver {
+    raf: (cb: FrameRequestCallback) => number;
+    caf: (handle: number) => void;
+}
+export declare function getAnimationFrameDriver(): AnimationFrameDriver;
+export declare class AnimationCancelled extends Error {
+    constructor();
+}
+export {};

package/dist/helpers/clone.d.ts

@@ -0,0 +1,6 @@
+export declare function freezeClone<T>(value: T): T;
+export declare function sameArray(a: string[], b: string[]): boolean;
+/** Expose collection reads without leaking mutation methods or the source. */
+export declare function readonlyMapView<K, V>(source: ReadonlyMap<K, V>): ReadonlyMap<K, V>;
+/** Expose set reads without leaking mutation methods or the source. */
+export declare function readonlySetView<T>(source: ReadonlySet<T>): ReadonlySet<T>;

package/dist/helpers/ids.d.ts

@@ -0,0 +1,2 @@
+import type { NodeId } from '../types.js';
+export declare function createNodeId(): NodeId;

package/dist/helpers/node-shape.d.ts

@@ -0,0 +1,2 @@
+import type { BoardNode } from '../types.js';
+export declare function materializeNode(node: BoardNode): BoardNode;

package/dist/helpers/selection-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { BoardNode, GridSettings, NodeId, Point } from '../types.js';
+import type { MutableBoardState } from '../state/types.js';
+export declare function getSelectionNodes(state: MutableBoardState): BoardNode[];
+export declare function getCopyClosureNodes(state: MutableBoardState): BoardNode[];
+export declare function duplicateForest(state: MutableBoardState, grid: GridSettings, nodes: BoardNode[], offset: Point): {
+    nodes: BoardNode[];
+    idMap: ReadonlyMap<NodeId, NodeId>;
+};

package/dist/hierarchy.d.ts

@@ -0,0 +1,16 @@
+import type { Bounds, BoardNode, NodeId } from './types.js';
+export declare function getBoundsFromNode(node: Pick<BoardNode, 'x' | 'y' | 'width' | 'height'>): Bounds;
+export declare function groupArea(node: BoardNode): number;
+/** Add every descendant of `rootId` into `out` (recursive; includes nested groups). */
+export declare function addDescendants(rootId: NodeId, nodes: Map<NodeId, BoardNode>, out: Set<NodeId>): void;
+export declare function expandGroupDragSeeds(seedIds: Iterable<NodeId>, nodes: Map<NodeId, BoardNode>): Set<NodeId>;
+export declare function collectSubtreeIds(rootId: NodeId, nodes: Map<NodeId, BoardNode>, into: Set<NodeId>): void;
+/**
+ * Seeds expanded with group descendants, then union of subtrees rooted at nodes whose parent is outside the expanded set.
+ * Each node appears once; applying the same delta to all ids moves a coherent forest.
+ */
+export declare function collectUniformTranslationTargets(seedIds: Iterable<NodeId>, nodes: Map<NodeId, BoardNode>): NodeId[];
+/** True if `maybeDescendant` is reachable by following parentId from `maybeDescendant` up to `ancestorId`. */
+export declare function isStrictDescendantOf(maybeDescendant: NodeId, ancestorId: NodeId, nodes: Map<NodeId, BoardNode>): boolean;
+export declare function findContainingGroup(node: BoardNode, nodes: Map<NodeId, BoardNode>): NodeId | undefined;
+export declare function sortIdsByZIndex(ids: NodeId[], nodes: Map<NodeId, BoardNode>): NodeId[];

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/** Create a headless board engine with commands and events. */
+export { CommandBlockedError, createBoardEngine } from './engine.js';
+/** Stable error classes surfaced by public engine boundaries. */
+export { BoardConflictError, BoardDestroyedError, BoardError, BoardInputError, BoardNotFoundError, } from './errors.js';
+/** Identifier branding helpers for nodes and edges. */
+export { asEdgeId, asNodeId } from './types.js';
+/** Shared Obsidian-compatible node color presets. */
+export { BOARD_COLOR_PRESETS, colorForPreset, isBoardColorPreset, type BoardColorOption, } from './colors.js';
+/** Selection helpers that operate on the public board engine state. */
+export { getSelectionBounds, getSelectionNodes, toggleIds, } from './selection.js';
+/** Geometry helpers used by renderers and framework adapters. */
+export { boundsIntersect, clamp, getBoundsFromPoints, getVisibleBounds, } from './math.js';
+/** Core engine, document, geometry, and node model types. */
+export type { BoxSelectBehavior, BoxSelectMode, BoxSelectSettings, BoardColorPreset, BoardState, Bounds, Camera, CanvasColor, BoardEngine, BoardEngineOptions, BoardUnhandledErrorContext, BoardEventMap, BoardPlugin, BoardNode, EdgeId, DuplicateNodesResult, GridPattern, GridSettings, InteractionMode, InteractionState, ValidationFailure, BoardPluginApis, JsonCanvasBackgroundStyle, JsonCanvasDocument, JsonCanvasEdge, JsonCanvasEdgeEnd, JsonCanvasFileNode, JsonCanvasGroupNode, JsonCanvasLinkNode, JsonCanvasNode, JsonCanvasNodeType, JsonCanvasSide, JsonCanvasTextNode, NodeConstraints, NodeId, NodeInput, NodePatch, Point, ResizeHandle, SelectionMode, SnapAxis, SnapGuide, Subscribable, TraceEntry, Unsubscribe, VueBoardDocumentMetadata, VueBoardEdgeMetadata, VueBoardNodeMetadata, ZoomSettings, } from './types.js';