@visualli/core 0.1.5 → 0.1.6

package/dist/layout/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/layout/index.ts","../../src/layout/circularLayout.ts","../../src/layout/linearLayout.ts","../../src/layout/layoutUtils.ts"],"sourcesContent":["export * from './circularLayout.js';\nexport * from './linearLayout.js';\nexport * from './layoutUtils.js';\n","// ─── Circular Layout Algorithm ────────────────────────────────────────────────\n//\n// Positions nodes in a uniform circle with equal angular spacing.\n// PATTERN : Uniform circular distribution (polar coordinates)\n// SPACING : Equal angular intervals (2π/n)\n// ORIGIN  : Configurable center (default 0, 0)\n// RADIUS  : Configurable percentage of container (default 13.5%)\n\nimport type { FlatNode } from '../types/mindmap.js';\n\nexport interface CircularLayoutOptions {\n  /** Radius as a fraction of the container's minimum dimension (0–1). Default: 0.135 */\n  radiusPercentage?: number;\n  /** Container width used to calculate absolute radius. Default: 2000 */\n  containerWidth?: number;\n  /** Container height used to calculate absolute radius. Default: 2000 */\n  containerHeight?: number;\n  /** World-space X of the circle centre. Default: 0 */\n  centerX?: number;\n  /** World-space Y of the circle centre. Default: 0 */\n  centerY?: number;\n}\n\n/**\n * Apply circular layout to a set of nodes.\n * Mutates the `x` / `y` properties of each node and returns the same array.\n */\nexport function applyCircularLayout(\n  nodes: FlatNode[],\n  options: CircularLayoutOptions = {},\n): FlatNode[] {\n  const {\n    radiusPercentage = 0.135,\n    containerWidth = 2000,\n    containerHeight = 2000,\n    centerX = 0,\n    centerY = 0,\n  } = options;\n\n  if (nodes.length === 0) return nodes;\n\n  if (nodes.length === 1) {\n    nodes[0].x = centerX;\n    nodes[0].y = centerY;\n    return nodes;\n  }\n\n  const radius = Math.min(containerWidth, containerHeight) * radiusPercentage;\n\n  // n=2 → horizontal; n≥3 → start at 12 o'clock\n  const startAngle = nodes.length === 2 ? 0 : -Math.PI / 2;\n  const angleStep = (2 * Math.PI) / nodes.length;\n\n  for (let i = 0; i < nodes.length; i++) {\n    const angle = startAngle + i * angleStep;\n    nodes[i].x = centerX + radius * Math.cos(angle);\n    nodes[i].y = centerY + radius * Math.sin(angle);\n  }\n\n  return nodes;\n}\n\n/**\n * Calculate the minimum radius needed to prevent node boxes from overlapping.\n *\n * Uses the chord-length formula: `chord = 2r · sin(θ/2)`, solved for `r`.\n */\nexport function calculateMinimumRadius(\n  nodeCount: number,\n  nodeWidth = 200,\n  nodePadding = 150,\n): number {\n  if (nodeCount <= 1) return 0;\n  const angleStep = (2 * Math.PI) / nodeCount;\n  const minChordLength = nodeWidth + nodePadding;\n  return minChordLength / (2 * Math.sin(angleStep / 2));\n}\n\n/**\n * Calculate the optimal radius percentage for a given node count,\n * ensuring sufficient spacing for edge labels.\n *\n * @returns A value in [0.135, 0.45]\n */\nexport function calculateOptimalRadiusPercentage(\n  nodeCount: number,\n  containerWidth = 2000,\n  containerHeight = 2000,\n  nodeWidth = 200,\n  nodePadding = 120,\n): number {\n  const minRadius = calculateMinimumRadius(nodeCount, nodeWidth, nodePadding);\n  const minDimension = Math.min(containerWidth, containerHeight);\n  return Math.min(0.45, Math.max(0.135, minRadius / minDimension));\n}\n","// ─── Linear Layout Algorithms ─────────────────────────────────────────────────\n//\n// Positions nodes in a straight line without overlap, with enough gap between\n// node edges for edge-label text to render cleanly.\n//\n//   linear-horizontal  → left-to-right along X-axis\n//   linear-vertical    → top-to-bottom along Y-axis\n\nimport type { FlatNode } from '../types/mindmap.js';\n\nexport interface LinearLayoutOptions {\n  /** Logical node width (px). Default: 200 */\n  nodeWidth?: number;\n  /** Logical node height (px). Default: 80 */\n  nodeHeight?: number;\n  /** Gap between node edges for horizontal layout (px). Default: 180 */\n  hGap?: number;\n  /** Gap between node edges for vertical layout (px). Default: 220 */\n  vGap?: number;\n  /** World X of the layout midpoint. Default: 0 */\n  centerX?: number;\n  /** World Y of the layout midpoint. Default: 0 */\n  centerY?: number;\n}\n\n/**\n * Arrange nodes in a horizontal row (shared Y, varying X).\n * Row is centred on (`centerX`, `centerY`).\n */\nexport function applyLinearHorizontalLayout(\n  nodes: FlatNode[],\n  options: LinearLayoutOptions = {},\n): FlatNode[] {\n  const { nodeWidth = 200, hGap = 180, centerX = 0, centerY = 0 } = options;\n\n  if (nodes.length === 0) return nodes;\n\n  if (nodes.length === 1) {\n    nodes[0].x = centerX;\n    nodes[0].y = centerY;\n    return nodes;\n  }\n\n  const spacing = nodeWidth + hGap;\n  const totalWidth = (nodes.length - 1) * spacing;\n  const startX = centerX - totalWidth / 2;\n\n  for (let i = 0; i < nodes.length; i++) {\n    nodes[i].x = startX + i * spacing;\n    nodes[i].y = centerY;\n  }\n\n  return nodes;\n}\n\n/**\n * Arrange nodes in a vertical column (shared X, varying Y).\n * Column is centred on (`centerX`, `centerY`).\n */\nexport function applyLinearVerticalLayout(\n  nodes: FlatNode[],\n  options: LinearLayoutOptions = {},\n): FlatNode[] {\n  const { nodeHeight = 80, vGap = 220, centerX = 0, centerY = 0 } = options;\n\n  if (nodes.length === 0) return nodes;\n\n  if (nodes.length === 1) {\n    nodes[0].x = centerX;\n    nodes[0].y = centerY;\n    return nodes;\n  }\n\n  const spacing = nodeHeight + vGap;\n  const totalHeight = (nodes.length - 1) * spacing;\n  const startY = centerY - totalHeight / 2;\n\n  for (let i = 0; i < nodes.length; i++) {\n    nodes[i].x = centerX;\n    nodes[i].y = startY + i * spacing;\n  }\n\n  return nodes;\n}\n","// ─── Layout Utilities ─────────────────────────────────────────────────────────\n//\n// Collision detection and force-based positioning for MindMapNode trees.\n\nimport type { MindMapNode } from '../types/mindmap.js';\n\nexport interface CollisionBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Axis-aligned bounding box for a node, expanded by a fixed padding. */\nexport function getNodeBounds(node: MindMapNode): CollisionBox {\n  const baseWidth = Math.max(120, node.title.length * 8 + 40);\n  const baseHeight = Math.max(40, 32 + 16);\n  const padding = 20;\n  return {\n    x: node.x - baseWidth / 2 - padding,\n    y: node.y - baseHeight / 2 - padding,\n    width: baseWidth + padding * 2,\n    height: baseHeight + padding * 2,\n  };\n}\n\nexport function checkCollision(box1: CollisionBox, box2: CollisionBox): boolean {\n  return !(\n    box1.x + box1.width < box2.x ||\n    box2.x + box2.width < box1.x ||\n    box1.y + box1.height < box2.y ||\n    box2.y + box2.height < box1.y\n  );\n}\n\n/**\n * Iteratively resolve bounding-box collisions within each level.\n * Nodes are pushed apart symmetrically until no overlaps remain\n * or `maxIterations` is reached.\n */\nexport function resolveCollisions(nodes: MindMapNode[], maxIterations = 10): MindMapNode[] {\n  const result = [...nodes];\n\n  for (let iter = 0; iter < maxIterations; iter++) {\n    let hasCollisions = false;\n\n    const byLevel = result.reduce<Record<number, MindMapNode[]>>((acc, n) => {\n      (acc[n.level] ??= []).push(n);\n      return acc;\n    }, {});\n\n    for (const levelNodes of Object.values(byLevel)) {\n      for (let i = 0; i < levelNodes.length; i++) {\n        for (let j = i + 1; j < levelNodes.length; j++) {\n          const n1 = levelNodes[i];\n          const n2 = levelNodes[j];\n          if (!checkCollision(getNodeBounds(n1), getNodeBounds(n2))) continue;\n\n          hasCollisions = true;\n          const dx = n2.x - n1.x;\n          const dy = n2.y - n1.y;\n          const dist = Math.sqrt(dx * dx + dy * dy);\n\n          if (dist < 1) {\n            n2.x += 100;\n          } else {\n            const b1 = getNodeBounds(n1);\n            const b2 = getNodeBounds(n2);\n            const minSep = (b1.width + b2.width) / 2;\n            const overlap = minSep - dist + 20;\n            if (overlap > 0) {\n              const move = overlap / 2;\n              n1.x -= (dx / dist) * move;\n              n1.y -= (dy / dist) * move;\n              n2.x += (dx / dist) * move;\n              n2.y += (dy / dist) * move;\n            }\n          }\n        }\n      }\n    }\n\n    if (!hasCollisions) break;\n  }\n\n  return result;\n}\n\n/**\n * Apply a lightweight repulsive force between same-level nodes that are\n * closer than 300 px, then resolve remaining collisions.\n */\nexport function optimizeLayout(nodes: MindMapNode[]): MindMapNode[] {\n  const result = [...nodes];\n  const iterations = 5;\n  const repulsion = 1000;\n  const damp = 0.8;\n\n  for (let iter = 0; iter < iterations; iter++) {\n    const forces = new Map<string, { x: number; y: number }>();\n    result.forEach(n => forces.set(n.id, { x: 0, y: 0 }));\n\n    for (let i = 0; i < result.length; i++) {\n      for (let j = i + 1; j < result.length; j++) {\n        const n1 = result[i];\n        const n2 = result[j];\n        if (n1.level !== n2.level) continue;\n\n        const dx = n2.x - n1.x;\n        const dy = n2.y - n1.y;\n        const dist = Math.sqrt(dx * dx + dy * dy);\n        if (dist <= 0 || dist >= 300) continue;\n\n        const force = repulsion / (dist * dist);\n        const f1 = forces.get(n1.id)!;\n        const f2 = forces.get(n2.id)!;\n        f1.x -= (dx / dist) * force;\n        f1.y -= (dy / dist) * force;\n        f2.x += (dx / dist) * force;\n        f2.y += (dy / dist) * force;\n      }\n    }\n\n    result.forEach(n => {\n      const f = forces.get(n.id)!;\n      n.x += f.x * damp;\n      n.y += f.y * damp;\n    });\n  }\n\n  return resolveCollisions(result);\n}\n"],"mappings":"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","names":[]}

package/dist/layout/index.d.cts

@@ -0,0 +1,80 @@
+import { F as FlatNode, c as MindMapNode } from '../mindmap-DWS0WZT_.cjs';
+
+interface CircularLayoutOptions {
+    /** Radius as a fraction of the container's minimum dimension (0–1). Default: 0.135 */
+    radiusPercentage?: number;
+    /** Container width used to calculate absolute radius. Default: 2000 */
+    containerWidth?: number;
+    /** Container height used to calculate absolute radius. Default: 2000 */
+    containerHeight?: number;
+    /** World-space X of the circle centre. Default: 0 */
+    centerX?: number;
+    /** World-space Y of the circle centre. Default: 0 */
+    centerY?: number;
+}
+/**
+ * Apply circular layout to a set of nodes.
+ * Mutates the `x` / `y` properties of each node and returns the same array.
+ */
+declare function applyCircularLayout(nodes: FlatNode[], options?: CircularLayoutOptions): FlatNode[];
+/**
+ * Calculate the minimum radius needed to prevent node boxes from overlapping.
+ *
+ * Uses the chord-length formula: `chord = 2r · sin(θ/2)`, solved for `r`.
+ */
+declare function calculateMinimumRadius(nodeCount: number, nodeWidth?: number, nodePadding?: number): number;
+/**
+ * Calculate the optimal radius percentage for a given node count,
+ * ensuring sufficient spacing for edge labels.
+ *
+ * @returns A value in [0.135, 0.45]
+ */
+declare function calculateOptimalRadiusPercentage(nodeCount: number, containerWidth?: number, containerHeight?: number, nodeWidth?: number, nodePadding?: number): number;
+
+interface LinearLayoutOptions {
+    /** Logical node width (px). Default: 200 */
+    nodeWidth?: number;
+    /** Logical node height (px). Default: 80 */
+    nodeHeight?: number;
+    /** Gap between node edges for horizontal layout (px). Default: 180 */
+    hGap?: number;
+    /** Gap between node edges for vertical layout (px). Default: 220 */
+    vGap?: number;
+    /** World X of the layout midpoint. Default: 0 */
+    centerX?: number;
+    /** World Y of the layout midpoint. Default: 0 */
+    centerY?: number;
+}
+/**
+ * Arrange nodes in a horizontal row (shared Y, varying X).
+ * Row is centred on (`centerX`, `centerY`).
+ */
+declare function applyLinearHorizontalLayout(nodes: FlatNode[], options?: LinearLayoutOptions): FlatNode[];
+/**
+ * Arrange nodes in a vertical column (shared X, varying Y).
+ * Column is centred on (`centerX`, `centerY`).
+ */
+declare function applyLinearVerticalLayout(nodes: FlatNode[], options?: LinearLayoutOptions): FlatNode[];
+
+interface CollisionBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Axis-aligned bounding box for a node, expanded by a fixed padding. */
+declare function getNodeBounds(node: MindMapNode): CollisionBox;
+declare function checkCollision(box1: CollisionBox, box2: CollisionBox): boolean;
+/**
+ * Iteratively resolve bounding-box collisions within each level.
+ * Nodes are pushed apart symmetrically until no overlaps remain
+ * or `maxIterations` is reached.
+ */
+declare function resolveCollisions(nodes: MindMapNode[], maxIterations?: number): MindMapNode[];
+/**
+ * Apply a lightweight repulsive force between same-level nodes that are
+ * closer than 300 px, then resolve remaining collisions.
+ */
+declare function optimizeLayout(nodes: MindMapNode[]): MindMapNode[];
+
+export { type CircularLayoutOptions, type CollisionBox, type LinearLayoutOptions, applyCircularLayout, applyLinearHorizontalLayout, applyLinearVerticalLayout, calculateMinimumRadius, calculateOptimalRadiusPercentage, checkCollision, getNodeBounds, optimizeLayout, resolveCollisions };

package/dist/layout/index.d.ts

@@ -0,0 +1,80 @@
+import { F as FlatNode, c as MindMapNode } from '../mindmap-DWS0WZT_.js';
+
+interface CircularLayoutOptions {
+    /** Radius as a fraction of the container's minimum dimension (0–1). Default: 0.135 */
+    radiusPercentage?: number;
+    /** Container width used to calculate absolute radius. Default: 2000 */
+    containerWidth?: number;
+    /** Container height used to calculate absolute radius. Default: 2000 */
+    containerHeight?: number;
+    /** World-space X of the circle centre. Default: 0 */
+    centerX?: number;
+    /** World-space Y of the circle centre. Default: 0 */
+    centerY?: number;
+}
+/**
+ * Apply circular layout to a set of nodes.
+ * Mutates the `x` / `y` properties of each node and returns the same array.
+ */
+declare function applyCircularLayout(nodes: FlatNode[], options?: CircularLayoutOptions): FlatNode[];
+/**
+ * Calculate the minimum radius needed to prevent node boxes from overlapping.
+ *
+ * Uses the chord-length formula: `chord = 2r · sin(θ/2)`, solved for `r`.
+ */
+declare function calculateMinimumRadius(nodeCount: number, nodeWidth?: number, nodePadding?: number): number;
+/**
+ * Calculate the optimal radius percentage for a given node count,
+ * ensuring sufficient spacing for edge labels.
+ *
+ * @returns A value in [0.135, 0.45]
+ */
+declare function calculateOptimalRadiusPercentage(nodeCount: number, containerWidth?: number, containerHeight?: number, nodeWidth?: number, nodePadding?: number): number;
+
+interface LinearLayoutOptions {
+    /** Logical node width (px). Default: 200 */
+    nodeWidth?: number;
+    /** Logical node height (px). Default: 80 */
+    nodeHeight?: number;
+    /** Gap between node edges for horizontal layout (px). Default: 180 */
+    hGap?: number;
+    /** Gap between node edges for vertical layout (px). Default: 220 */
+    vGap?: number;
+    /** World X of the layout midpoint. Default: 0 */
+    centerX?: number;
+    /** World Y of the layout midpoint. Default: 0 */
+    centerY?: number;
+}
+/**
+ * Arrange nodes in a horizontal row (shared Y, varying X).
+ * Row is centred on (`centerX`, `centerY`).
+ */
+declare function applyLinearHorizontalLayout(nodes: FlatNode[], options?: LinearLayoutOptions): FlatNode[];
+/**
+ * Arrange nodes in a vertical column (shared X, varying Y).
+ * Column is centred on (`centerX`, `centerY`).
+ */
+declare function applyLinearVerticalLayout(nodes: FlatNode[], options?: LinearLayoutOptions): FlatNode[];
+
+interface CollisionBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Axis-aligned bounding box for a node, expanded by a fixed padding. */
+declare function getNodeBounds(node: MindMapNode): CollisionBox;
+declare function checkCollision(box1: CollisionBox, box2: CollisionBox): boolean;
+/**
+ * Iteratively resolve bounding-box collisions within each level.
+ * Nodes are pushed apart symmetrically until no overlaps remain
+ * or `maxIterations` is reached.
+ */
+declare function resolveCollisions(nodes: MindMapNode[], maxIterations?: number): MindMapNode[];
+/**
+ * Apply a lightweight repulsive force between same-level nodes that are
+ * closer than 300 px, then resolve remaining collisions.
+ */
+declare function optimizeLayout(nodes: MindMapNode[]): MindMapNode[];
+
+export { type CircularLayoutOptions, type CollisionBox, type LinearLayoutOptions, applyCircularLayout, applyLinearHorizontalLayout, applyLinearVerticalLayout, calculateMinimumRadius, calculateOptimalRadiusPercentage, checkCollision, getNodeBounds, optimizeLayout, resolveCollisions };

package/dist/layout/index.js

@@ -0,0 +1,25 @@
+import {
+  checkCollision,
+  getNodeBounds,
+  optimizeLayout,
+  resolveCollisions
+} from "../chunk-LI3BVD6H.js";
+import {
+  applyCircularLayout,
+  applyLinearHorizontalLayout,
+  applyLinearVerticalLayout,
+  calculateMinimumRadius,
+  calculateOptimalRadiusPercentage
+} from "../chunk-GQMFBYLK.js";
+export {
+  applyCircularLayout,
+  applyLinearHorizontalLayout,
+  applyLinearVerticalLayout,
+  calculateMinimumRadius,
+  calculateOptimalRadiusPercentage,
+  checkCollision,
+  getNodeBounds,
+  optimizeLayout,
+  resolveCollisions
+};
+//# sourceMappingURL=index.js.map

package/dist/layout/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/mindmap-DWS0WZT_.d.cts

@@ -0,0 +1,118 @@
+interface MindMapNode {
+    id: string;
+    title: string;
+    level: number;
+    x: number;
+    y: number;
+    children?: MindMapNode[];
+    parent?: string;
+    color?: string;
+    relationshipLabel?: string;
+}
+/** Flat structure for performance-optimised storage (10K+ nodes). */
+interface FlatNode {
+    id: string;
+    parentId: string | null;
+    /** IDs of child nodes for quick tree traversal */
+    childrenIds?: string[];
+    x: number;
+    y: number;
+    /** Alternative position format for compatibility */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Depth in tree hierarchy */
+    level: number;
+    title: string;
+    description?: string;
+    /** Label describing relationship to parent */
+    relationshipLabel?: string;
+    color: string;
+    width: number;
+    height: number;
+    /** Whether this node's children are visible */
+    isExpanded?: boolean;
+    branchCount?: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Map-based node storage for O(1) lookups. */
+type NodeMap = Map<string, FlatNode>;
+/** Spatial bounds for RBush indexing. */
+interface SpatialBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    nodeId: string;
+}
+/** Viewport state for camera position and zoom. */
+interface ViewportState {
+    centerX: number;
+    centerY: number;
+    zoomLevel: number;
+    rotation: number;
+    visibleBounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+/** Single-selection node state. */
+interface NodeSelection {
+    selectedId: string | null;
+}
+/** Render configuration flags. */
+interface RenderConfig {
+    renderMode: 'canvas' | 'simplified';
+    qualityLevel: 'high' | 'medium' | 'low';
+    cullingEnabled: boolean;
+    fpsTarget: number;
+    memoryLimit: number;
+}
+interface MindMapData {
+    nodes: MindMapNode[];
+    connections: MindMapConnection[];
+}
+/** Simplified connection type for mindmap rendering (not to be confused with schema Connection) */
+interface MindMapConnection {
+    from: string;
+    to: string;
+    level: number;
+    label?: string;
+}
+interface TopLevelConnection {
+    from: string;
+    to: string;
+    label: string;
+}
+/** Complete mindmap configuration schema. */
+interface MindMapConfig {
+    metadata: {
+        id?: string;
+        title: string;
+        description?: string;
+        version: string;
+        created: string;
+        lastModified: string;
+    };
+    nodes: MindMapNode[];
+    topLevelConnections: TopLevelConnection[];
+    settings?: {
+        defaultColors?: {
+            level0: string;
+            level1: string;
+            level2: string;
+            level3: string;
+            [key: `level${number}`]: string;
+        };
+        layout?: {
+            nodeSpacing: number;
+            levelSpacing: number;
+        };
+    };
+}
+
+export type { FlatNode as F, MindMapConnection as M, NodeSelection as N, RenderConfig as R, SpatialBounds as S, TopLevelConnection as T, ViewportState as V, MindMapConfig as a, MindMapData as b, MindMapNode as c, NodeMap as d };

package/dist/mindmap-DWS0WZT_.d.ts

@@ -0,0 +1,118 @@
+interface MindMapNode {
+    id: string;
+    title: string;
+    level: number;
+    x: number;
+    y: number;
+    children?: MindMapNode[];
+    parent?: string;
+    color?: string;
+    relationshipLabel?: string;
+}
+/** Flat structure for performance-optimised storage (10K+ nodes). */
+interface FlatNode {
+    id: string;
+    parentId: string | null;
+    /** IDs of child nodes for quick tree traversal */
+    childrenIds?: string[];
+    x: number;
+    y: number;
+    /** Alternative position format for compatibility */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Depth in tree hierarchy */
+    level: number;
+    title: string;
+    description?: string;
+    /** Label describing relationship to parent */
+    relationshipLabel?: string;
+    color: string;
+    width: number;
+    height: number;
+    /** Whether this node's children are visible */
+    isExpanded?: boolean;
+    branchCount?: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Map-based node storage for O(1) lookups. */
+type NodeMap = Map<string, FlatNode>;
+/** Spatial bounds for RBush indexing. */
+interface SpatialBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    nodeId: string;
+}
+/** Viewport state for camera position and zoom. */
+interface ViewportState {
+    centerX: number;
+    centerY: number;
+    zoomLevel: number;
+    rotation: number;
+    visibleBounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+/** Single-selection node state. */
+interface NodeSelection {
+    selectedId: string | null;
+}
+/** Render configuration flags. */
+interface RenderConfig {
+    renderMode: 'canvas' | 'simplified';
+    qualityLevel: 'high' | 'medium' | 'low';
+    cullingEnabled: boolean;
+    fpsTarget: number;
+    memoryLimit: number;
+}
+interface MindMapData {
+    nodes: MindMapNode[];
+    connections: MindMapConnection[];
+}
+/** Simplified connection type for mindmap rendering (not to be confused with schema Connection) */
+interface MindMapConnection {
+    from: string;
+    to: string;
+    level: number;
+    label?: string;
+}
+interface TopLevelConnection {
+    from: string;
+    to: string;
+    label: string;
+}
+/** Complete mindmap configuration schema. */
+interface MindMapConfig {
+    metadata: {
+        id?: string;
+        title: string;
+        description?: string;
+        version: string;
+        created: string;
+        lastModified: string;
+    };
+    nodes: MindMapNode[];
+    topLevelConnections: TopLevelConnection[];
+    settings?: {
+        defaultColors?: {
+            level0: string;
+            level1: string;
+            level2: string;
+            level3: string;
+            [key: `level${number}`]: string;
+        };
+        layout?: {
+            nodeSpacing: number;
+            levelSpacing: number;
+        };
+    };
+}
+
+export type { FlatNode as F, MindMapConnection as M, NodeSelection as N, RenderConfig as R, SpatialBounds as S, TopLevelConnection as T, ViewportState as V, MindMapConfig as a, MindMapData as b, MindMapNode as c, NodeMap as d };