@visualli/core 0.1.7 → 0.2.0

package/dist/index.d.ts

@@ -1,17 +1,21 @@
-import { R as RenderConfig, N as NodeSelection, F as FlatNode, M as MindMapConnection, V as ViewportState } from './mindmap-DWS0WZT_.js';
-export { a as MindMapConfig, b as MindMapData, c as MindMapNode, d as NodeMap, S as SpatialBounds, T as TopLevelConnection } from './mindmap-DWS0WZT_.js';
-import { V as VisualliDocument, a as VisualliLayer } from './document-B3hnNr-F.js';
-export { L as LayerConnection, b as LayerContainer, c as LayerNode, d as VisualliMeta, e as VisualliRenderConnection, f as VisualliRenderNode } from './document-B3hnNr-F.js';
+import { R as RenderConfig, N as NodeSelection, F as FlatNode, M as MindMapConnection, V as ViewportState } from './mindmap-DHeVa86G.js';
+export { a as IDEA, I as IdeaKind, L as LABEL_GROWTH, b as MindMapConfig, c as MindMapData, d as MindMapNode, e as NodeMap, S as SpatialBounds, T as TopLevelConnection, i as ideaSize, l as labelGrowth, w as wrapLines } from './mindmap-DHeVa86G.js';
+import { V as VisualliDocument } from './document-BFBwn93X.js';
+export { S as SemanticAnchor, a as VisualliMeta } from './document-BFBwn93X.js';
+import { V as VisualliLayer } from './layer-B2A3Ki48.js';
+export { L as LayerConnection, a as LayerContainer, b as LayerNode, c as VisualliRenderConnection, d as VisualliRenderNode } from './layer-B2A3Ki48.js';
 export { VisualliFragment } from './types/index.js';
 export { CircularLayoutOptions, CollisionBox, LinearLayoutOptions, applyCircularLayout, applyLinearHorizontalLayout, applyLinearVerticalLayout, calculateMinimumRadius, calculateOptimalRadiusPercentage, checkCollision, getNodeBounds, optimizeLayout, resolveCollisions } from './layout/index.js';
-export { VisualliParseError, calculateDistance, convertLayerToFlatNodes, convertVisualliToFlatNodes, countLayersBeneath, createMindMapConfig, fetchAndParseVisualli, flattenNodes, generateSampleConfig, getChildLayers, getNodeConnections, getNodesForLayer, getTopLevelConnections, getVisibleNodes, loadVisualliFileFromFile, parseVisualliFile, parseVisualliFromMongoDB, resolveNodeOverlaps } from './parser/index.js';
+export { ConvertOptions, VisualliParseError, calculateDistance, convertLayerToFlatNodes, convertVisualliToFlatNodes, countLayersBeneath, createMindMapConfig, fetchAndParseVisualli, flattenNodes, generateSampleConfig, getChildLayers, getNodeConnections, getNodesForLayer, getSemanticAnchors, getTopLevelConnections, getVisibleNodes, loadVisualliFileFromFile, parseVisualliFile, parseVisualliFromMongoDB, resolveNodeOverlaps } from './parser/index.js';
 import { FEATURE_FLAGS } from './constants/index.js';
-export { BORDER_WIDTH_NORMAL, BORDER_WIDTH_SELECTED, BRAND_COLORS, CANVAS_COLORS, CHAR_WIDTH, CIRCULAR_REFERENCE_MAX_DEPTH, CLICK_THRESHOLD, COLOR_BORDER_DARK, COLOR_BORDER_LIGHT, COLOR_DEFAULT_NODE, COLOR_SELECTED, CORNER_RADIUS, CULLING_QUERY_TIME_BUDGET, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_RENDER_CONFIG, DOUBLE_CLICK_DELAY, DRAG_START_DISTANCE, DS_COLORS, DS_RADII, DS_TYPOGRAPHY, FONTS, FONT_SIZES, FPS_CRITICAL_THRESHOLD, FPS_DOWNGRADE_THRESHOLD, FPS_SAMPLE_WINDOW, FPS_STABILIZATION_FRAMES, FPS_TARGET, FPS_TARGETS, FPS_UPDATE_INTERVAL, FPS_UPGRADE_THRESHOLD, FPS_WARNING_THRESHOLD, LAYOUT_SPACING, LEVEL_COLORS, LEVEL_COLOR_ARRAY, MAX_FRAME_TIME, MAX_NODES, MAX_VISIBLE_NODES, MEMORY_CHECK_INTERVAL, MEMORY_CRITICAL_MB, MEMORY_LIMITS, MEMORY_TARGET_MB, MEMORY_WARNING_MB, NODE_COUNT_THRESHOLDS, NODE_HEIGHT, NODE_MIN_WIDTH, NODE_PADDING, PARENT_FALLBACK_COLORS, PERFORMANCE_TOAST_COOLDOWN, QUALITY_HIGH, QUALITY_LEVELS, QUALITY_LOW, QUALITY_MEDIUM, QUALITY_SETTINGS, QualityLevel, RBUSH_MAX_ENTRIES, RENDER_MODES, RESIZE_DEBOUNCE, RenderMode, SCROLL_THROTTLE, SEARCH_DEBOUNCE, SEMANTIC_COLORS, SIMPLIFIED_RENDER_CONFIG, SPACING, SPATIAL_INDEX_BUILD_BUDGET, TARGET_FRAME_TIME, TEXT_LABEL_HIDE_BELOW_ZOOM, THEME_COLORS, TIMING_THRESHOLDS, TITLE_MAX_LENGTH, VIEWPORT_CONFIG, VIEWPORT_MARGIN, ZOOM_DEFAULT, ZOOM_MAX, ZOOM_MIN, ZOOM_NAV_IN_THRESHOLD, ZOOM_NAV_OUT_THRESHOLD, ZOOM_STEP, ZOOM_WHEEL_SENSITIVITY, darkenHexColor, getColorForLevel, getOptimalQualityLevel, getRecommendedRenderConfig, getRenderConfigForQuality, getThemeBackground, getThemeBorder, getThemeText, isFeatureEnabled } from './constants/index.js';
+export { CIRCULAR_REFERENCE_MAX_DEPTH, CLICK_THRESHOLD, CULLING_QUERY_TIME_BUDGET, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_RENDER_CONFIG, DOUBLE_CLICK_DELAY, DRAG_START_DISTANCE, FPS_CRITICAL_THRESHOLD, FPS_DOWNGRADE_THRESHOLD, FPS_SAMPLE_WINDOW, FPS_STABILIZATION_FRAMES, FPS_TARGET, FPS_TARGETS, FPS_UPDATE_INTERVAL, FPS_UPGRADE_THRESHOLD, FPS_WARNING_THRESHOLD, LAYOUT_SPACING, MAX_FRAME_TIME, MAX_NODES, MAX_VISIBLE_NODES, MEMORY_CHECK_INTERVAL, MEMORY_CRITICAL_MB, MEMORY_LIMITS, MEMORY_TARGET_MB, MEMORY_WARNING_MB, NODE_COUNT_THRESHOLDS, PERFORMANCE_TOAST_COOLDOWN, QUALITY_HIGH, QUALITY_LEVELS, QUALITY_LOW, QUALITY_MEDIUM, QUALITY_SETTINGS, QualityLevel, RBUSH_MAX_ENTRIES, RENDER_MODES, RESIZE_DEBOUNCE, RenderMode, SCROLL_THROTTLE, SEARCH_DEBOUNCE, SIMPLIFIED_RENDER_CONFIG, SPATIAL_INDEX_BUILD_BUDGET, TARGET_FRAME_TIME, TIMING_THRESHOLDS, VIEWPORT_CONFIG, VIEWPORT_MARGIN, ZOOM_DEFAULT, ZOOM_MAX, ZOOM_MIN, getOptimalQualityLevel, getRecommendedRenderConfig, getRenderConfigForQuality, isFeatureEnabled } from './constants/index.js';
 export { WorldBounds, calculateViewportBounds, clampZoom, focusOnNode, isNodeInViewport, panViewport, recalculateViewportBounds, screenToWorld, setViewportCenter, worldToScreen, zoomViewport } from './viewport/index.js';
 export { FPSMonitor, MemoryMonitor, MemoryStats, PerformanceProfiler } from './performance/index.js';
-export { ANIMATION_DURATION, ANIMATION_PHASES, COOLDOWN, EasingFunction, OPACITY, TARGET_ZOOM, VIEWPORT_FRAMING, ZOOM_THRESHOLDS, createCubicBezier, easeInCubic, easeInOutCubic, easeInOutQuart, easeInOutSine, easeOutCubic, easeOutQuad, easeZoomTransition } from './animations/index.js';
 import * as zustand_vanilla from 'zustand/vanilla';
-export { ACTIVE_BLOB_TYPES, ALL_BLOB_SHAPES, BLOB_LAYER_CONFIG, BLOB_TEXT_OFFSETS, BlobPoint, BlobShape, CONTAINER_LABEL_BASE_FONT_PX, DESCRIPTION_TEXT_BASE_FONT_PX, EDGE_LABEL_BASE_FONT_PX, NODE_LAYER_CONFIG, NODE_TEXT_BASE_FONT_PX, OVERLAY_FONT_UPPER_BOOST_PX, computeEdgeLabelScale, computeNodeTextScreenScale, computeNodeTextWorldScale, computeOverlayScale, drawBlobPath, getBlobTypeForLayer } from './config/index.js';
+export { BLOB_SHAPES, ConnectorGeometry, MAX_RINGS, NodeLike, RINGS, SHAPE, arrowPath, blobPath, blobRadius, connectorGeometry, drawBlob, edgePath, nodeBounds, nodeRadii, outlineRadius, ringCount, ringsFor, shapeForLevel, shapeOfLevel } from './config/index.js';
+export { I as IdeaMeasure, a as approximateMeasure, i as ideaKindOf } from './ideaSize-DxxGy2E8.js';
+export { C as CUSTOM, a as Comfort, I as IdeaColor, M as Metrics, R as ResolvedComfort, T as TOPIC_ORDER, b as ThemeEnv, c as ThemeFamily, d as ThemeInput, e as TopicStyle, f as customColor, g as getTokens, i as ideaColor, h as ideaStyle, j as isContrastTheme, k as isDarkTheme, l as isFocusTheme, m as isThemeName, n as labelScale, o as metricsFor, r as resolveComfort, p as resolveTheme, t as token, q as topicFor, s as topicFromName, u as topicStyle } from './index-CcPRwVUL.js';
+export { C as CANVAS_STYLE, D as DESIGN_SYSTEM_VERSION, M as METRICS, b as METRICS_REDUCED_MOTION, c as THEME_NAMES, d as TOKENS, e as TOPICS, f as TYPE_STYLES, a as ThemeName, T as TopicName } from './designSystem-BOrZHfEq.js';
 export { Connection, Container, Extension, Layer, Meta, Node } from '@visualli/bindings';
 
 interface BoundingBox {
@@ -75,6 +79,143 @@ interface IRenderConfigStore extends RenderConfig {
 }
 declare const renderConfigStore: zustand_vanilla.StoreApi<IRenderConfigStore>;
 
+/** Terms (semantic anchors) in a peek's text. */
+declare const TERM: {
+    /** Hovering the term this long opens its definition card… */ readonly hoverOpen: 250;
+    /** …which closes this long after the pointer leaves both the term and the card (moving between them keeps it open). */ readonly hoverClose: 300;
+    /** Only a mouse opens on hover; touch and pen open on tap. */ readonly hoverPointers: readonly string[];
+    /** A click, tap, Enter or Space pins the card open (hovering away doesn't close it); pressing again unpins and closes. */ readonly clickPins: true;
+    /** Escape closes the card and returns focus to the term; a press anywhere outside the term and its card closes it. */ readonly escapeCloses: true;
+    readonly pressOutsideCloses: true;
+    /** Opening by click or keyboard moves focus to the card's first link or button. */ readonly focusCardOnOpen: true;
+    /** The card is kept this far inside the viewport's left and right edges. */ readonly viewportMargin: 8;
+    /** The card's link to a source about the term. */ readonly learnMoreLabel: "Learn more";
+};
+/** The peek: an idea's summary card on hover (pointer) or tap (touch). */
+declare const PEEK: {
+    /** Hovering an idea opens its peek at once; it stays this long after the pointer leaves the idea (and while the
+     *  pointer is over the peek itself), so the pointer can travel from the idea onto the card. */ readonly hoverClose: 180;
+};
+/** The touch peek: a bottom sheet with a grip. */
+declare const SHEET: {
+    /** Dragging the grip down this far closes the sheet (or collapses it when expanded); up this far expands it. */ readonly dismissDrag: 80;
+    readonly expandDrag: 40;
+    /** Its height: this share of the map, at most `maxHeight` px; the map pans the chosen idea into the space above it. */ readonly heightRatio: 0.42;
+    readonly maxHeight: 300;
+};
+/** Zoom, pan and fit. */
+declare const VIEW: {
+    /** Each zoom step multiplies or divides the zoom by this. */ readonly zoomStep: 1.2;
+    /** Zoom limits (the zoom-min / zoom-max tokens; the build checks they agree). */ readonly zoomMin: 0.3;
+    readonly zoomMax: 5;
+    /** Fit to view never enlarges a layer beyond this. */ readonly fitMax: 1.1;
+};
+/** Touch gestures on the map (any touch input — phones, tablets and touchscreen laptops alike; it follows the pointer
+ *  in use, not the device, so a mouse or trackpad on the same laptop isn't affected). */
+declare const GESTURE: {
+    /** Two fingers pinch to zoom the map's contents — ideas, connectors, containers and their labels — around the
+     *  point between the fingers, within VIEW's limits. Controls, the depth trail, the peek, chat and the page never scale. */ readonly pinchZoom: true;
+    /** Moving both fingers pans the contents. */ readonly twoFingerPan: true;
+    /** The pointers that pinch (PointerEvent.pointerType). */ readonly pointers: readonly string[];
+    /** Where the map is the page (an app: AppShell, the mobile app), it takes every touch gesture (touch-action: none),
+     *  so the browser never zooms the page. Embedded on a scrolling page (website, docs), one finger still scrolls the
+     *  page (touch-action: pan-x pan-y); two fingers that land together pinch the map. */ readonly appTouchAction: "none";
+    readonly embeddedTouchAction: "pan-x pan-y";
+    /** Zoom never navigates: stepping inside and backing out stay explicit (tap an idea / Step inside, the depth trail,
+     *  Escape or Backspace). */ readonly zoomNavigates: false;
+};
+/** The zoom after a pinch: the zoom at the start, scaled by how far the fingers spread, within VIEW's limits. */
+declare function pinchZoom(startZoom: number, startDistance: number, distance: number): number;
+/** Keeps the map point that was under `from` under `to` when the scale changes from `s0` to `s1`: the new
+ *  translation, given the old one (screen = world × s + t). Used to zoom around the fingers. */
+declare function zoomAround(t0: {
+    x: number;
+    y: number;
+}, s0: number, s1: number, from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+/** Framing a layer (fit to view): its ideas with room around them, and its container hulls with room for the name pill. */
+declare const FRAME: {
+    /** Room beyond each idea's outline (at least `minPadX` / `minPadY` from its centre). */ readonly clearX: 50;
+    readonly clearY: 46;
+    readonly minPadX: 150;
+    readonly minPadY: 120;
+    /** Room beyond each container hull for its dashed line and the name pill straddling it. */ readonly hullX: 24;
+    readonly hullY: 40;
+};
+type FrameBox = {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/** The box a layer is framed by: every idea (`rx` / `ry` its half size) and every container hull. */
+declare function layerBounds(ideas: ReadonlyArray<{
+    x: number;
+    y: number;
+    rx: number;
+    ry: number;
+}>, hulls?: ReadonlyArray<FrameBox>): FrameBox;
+/** Fit to view: the scale that shows `bounds` in an area of `width` × `height` (never beyond VIEW.fitMax), and the
+ *  world point to centre. */
+declare function fitView(bounds: FrameBox, width: number, height: number): {
+    scale: number;
+    center: {
+        x: number;
+        y: number;
+    };
+};
+/** Where the peek card sits (pointer): beside the idea — right of it if it fits, else left — and level with it. */
+declare const PEEK_PLACEMENT: {
+    /** Gap between the idea's outermost ring and the card. */ readonly gap: 16;
+    /** The card's width and the height kept clear below it. */ readonly cardWidth: 300;
+    readonly cardHeight: 220;
+    /** The card is raised this much above the idea's centre. */ readonly raise: 70;
+    /** Kept this far inside the map's edges. */ readonly margin: 12;
+};
+/** The peek card's top-left, in map (screen) pixels. `idea`: the idea's centre on screen and its on-screen half
+ *  width with its outermost ring (`half`); `box`: the map's size. */
+declare function peekPosition(idea: {
+    x: number;
+    y: number;
+    half: number;
+}, box: {
+    w: number;
+    h: number;
+}, card?: {
+    w: number;
+    h: number;
+}): {
+    left: number;
+    top: number;
+    side: "right" | "left";
+};
+/** The depth trail: each entry shows the idea that was stepped into — its title and a dot in its color (the same
+ *  topic or custom color the idea is drawn in, including the sibling-order topic of an uncolored idea). The first
+ *  entry is the map itself: a `stone` dot and the home glyph only (`rootLabel: 'icon'`) — no text, since a map's title
+ *  usually repeats its centre idea's, which the next entry shows; its accessible name and tooltip are the map's title.
+ *  The dot is the idea shape (shapeForLevel). */
+declare const TRAIL: {
+    readonly rootTopic: "stone";
+    readonly rootLabel: "icon";
+    readonly homeIconSize: 12;
+    readonly dotBox: 16;
+    readonly dotRadius: 6.4;
+    readonly stroke: 1.25;
+    readonly currentStroke: 1.75;
+};
+/** How an input answers: a mouse hovers (peeks and terms open on hover); touch and pen tap. Null for unknown pointers. */
+declare function pointerModeFor(pointerType: string): 'hover' | 'touch' | null;
+/** Whether a pointer of this type opens a term on hover (PointerEvent.pointerType). */
+declare function hoverOpensTerm(pointerType: string): boolean;
+
 /**
  * Returns all top-level connections that originate from the given layer.
  * A "top-level connection" links two nodes that both live in `layerId`.
@@ -94,21 +235,18 @@ interface FitResult {
     centerY: number;
     zoomLevel: number;
 }
-/**
- * Calculates the zoom level needed to fit all `nodes` inside a canvas of
- * `(canvasWidth, canvasHeight)`.
- *
- * @param paddingFraction - Fractional padding on each side (0.15 = 15%).
- *   Pixel-padding variant still available when a value >=1 is passed.
- */
-declare function calculateFitZoom(nodes: FlatNode[], canvasWidth: number, canvasHeight: number, padding?: number): number;
-/**
- * Calculates the world-space center point that puts all `nodes` in the middle
- * of the viewport. Matches the visualli.ai `calculateFitCenter` approach:
- * uses bounding-box midpoint rather than centroid so the layout is always
- * geometrically centred.
- */
-declare function calculateFitCenter(nodes: FlatNode[]): {
+/** The box a layer is framed by: its ideas (their real sizes) and the hulls of its `containers`. */
+declare function layerFrame(nodes: ReadonlyArray<FlatNode>, containers?: ReadonlyArray<{
+    nodeIds: string[];
+}>): FrameBox;
+/** The zoom that fits a layer's ideas (and container hulls) into a canvas of `canvasWidth` × `canvasHeight`. */
+declare function calculateFitZoom(nodes: FlatNode[], canvasWidth: number, canvasHeight: number, containers?: ReadonlyArray<{
+    nodeIds: string[];
+}>): number;
+/** The world point a fitted layer is centred on: the middle of its frame. */
+declare function calculateFitCenter(nodes: FlatNode[], containers?: ReadonlyArray<{
+    nodeIds: string[];
+}>): {
     x: number;
     y: number;
 };
@@ -119,12 +257,14 @@ interface ContainerGroupInfo {
     level: number;
 }
 /**
- * Returns the container groups for the given layer, normalising both the
+ * Returns the container groups the given layer draws, normalising both the
  * nested-data format `{data:{label,formation}}` and the flat format `{label}`.
  */
 declare function getContainersForLayer(doc: VisualliDocument, layerId: string): ContainerGroupInfo[];
-/** Convenience: returns both center and zoom for a single `fitView` call. */
-declare function calculateFitView(nodes: FlatNode[], canvasWidth: number, canvasHeight: number): FitResult;
+/** Fit to view: centre and zoom for a layer in one call (the design system's fitView). */
+declare function calculateFitView(nodes: FlatNode[], canvasWidth: number, canvasHeight: number, containers?: ReadonlyArray<{
+    nodeIds: string[];
+}>): FitResult;
 
 interface CullingOptions {
     nodes: FlatNode[];
@@ -137,10 +277,193 @@ interface CullingOptions {
     spatialIndex?: RBushSpatialIndex | null;
     spatialIndexThreshold?: number;
 }
+/**
+ * True when anything drawn for the node touches the viewport. Nodes are drawn
+ * CENTRED on (x, y) with rings and stroke around them, so the test uses the
+ * node's real visual bounds (not a top-left rectangle).
+ */
+declare function intersectsViewport(n: FlatNode, bounds: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}): boolean;
 /**
  * Returns the subset of nodes currently visible in the viewport.
  * Framework-agnostic logic for culling and spatial indexing.
  */
 declare function getViewportVisibleNodes(options: CullingOptions): FlatNode[];
 
-export { type BoundingBox, type ContainerGroupInfo, type CullingOptions, FEATURE_FLAGS, type FitResult, FlatNode, type IRenderConfigStore, type ISelectionStore, type ISpatialIndex, MindMapConnection, NodeSelection, RBushSpatialIndex, RenderConfig, ViewportState, VisualliDocument, VisualliLayer, calculateFitCenter, calculateFitView, calculateFitZoom, getChildLayerForNode, getConnectionsForLayer, getContainersForLayer, getLayerForNavigation, getViewportVisibleNodes, renderConfigStore, selectionStore };
+type Bezier = readonly [number, number, number, number];
+declare const EASE: {
+    /** ease-standard — UI and connector drawing. */ standard: Bezier;
+    /** ease-zoom — diving into and out of layers. */ zoom: Bezier;
+    /** ease-bloom — ideas arriving, with a little overshoot. */ bloom: Bezier;
+};
+declare const MOTION: {
+    /** A layer arrives: ideas bloom one by one in sibling order, center first, then connectors draw. */
+    readonly reveal: {
+        /** duration-reveal: each idea's bloom. */ readonly duration: 420;
+        /** stagger-reveal: delay between consecutive ideas. */ readonly stagger: 70;
+        /** An idea starts at this scale… */ readonly fromScale: 0.55;
+        /** …and this fraction of the way from its place toward the layer's center. */ readonly fromCenter: 0.5;
+        readonly ease: Bezier;
+        /** Settle time after the last bloom before the map is idle (interactive again). */ readonly tail: 200;
+    };
+    /** Connectors of an arriving layer: they start once the ideas are mostly in. */
+    readonly connector: {
+        /** Lead time before the first connector, on top of the ideas' stagger. */ readonly lead: 240;
+        /** Delay between consecutive connectors. */ readonly stagger: 60;
+        /** A solid connector draws from source to target; a dashed one fades in instead. */ readonly draw: 500;
+        /** The connector group's fade (duration-base). */ readonly fade: 240;
+        readonly ease: Bezier;
+    };
+    /** Step inside: the current layer zooms toward the idea and fades; the inner layer then arrives (reveal). */
+    readonly dive: {
+        /** The old layer's zoom, toward the idea's position. */ readonly scale: 3.2;
+        /** duration-zoom. */ readonly duration: 500;
+        /** It fades out after this delay, over `fade`. */ readonly fadeDelay: 150;
+        readonly fade: 160;
+        /** The layers swap (and the reveal starts) this long after the dive starts. */ readonly swapAfter: 320;
+        readonly ease: Bezier;
+    };
+    /** Back out (depth trail): the current layer shrinks toward the center and fades; the outer layer arrives. */
+    readonly surface: {
+        readonly scale: 0.6;
+        readonly duration: 220;
+        readonly fade: 200;
+        readonly swapAfter: 220;
+        readonly ease: Bezier;
+    };
+    /** The arriving layer as a whole settles from slightly small. */
+    readonly settle: {
+        readonly fromScale: 0.94;
+        readonly duration: 260;
+        readonly ease: Bezier;
+    };
+    /** Hover (pointer) or select: the idea lifts; its rings turn and grow a touch — a nudge, not a wobble. */
+    readonly hover: {
+        readonly lift: 2;
+        readonly ringRotate: -2;
+        readonly ringScale: 1.015;
+        /** duration-base, for both the lift (ease-bloom) and the rings (ease-standard). */ readonly duration: 240;
+        readonly liftEase: Bezier;
+        readonly ringEase: Bezier;
+    };
+    /** Reduced motion, or Gradual reveal off: everything appears together with a short fade; dives become cross-fades. */
+    readonly reduced: {
+        readonly fade: 120;
+    };
+    /** Large layers. The stagger is written for a dozen ideas; a layer of hundreds would take minutes to arrive and
+     *  every frame of a bloom repaints the whole layer. Above `staggerSlots` ideas (and connectors), they share that many
+     *  slots, so a layer never takes longer to arrive than `staggerSlots` ideas would. Above `bloomMax` ideas the layer
+     *  fades in together (the reduced fade) and hover lifts snap instead of easing. */
+    readonly largeLayer: {
+        readonly staggerSlots: 30;
+        readonly bloomMax: 150;
+    };
+};
+type Point = {
+    x: number;
+    y: number;
+};
+/** Delay before idea `i` (sibling order) starts to bloom. */
+declare function revealDelay(i: number): number;
+/** Delay before connector `i` starts, in a layer of `nodeCount` ideas. */
+declare function connectorDelay(i: number, nodeCount: number): number;
+/** How long a layer's arrival takes, until the map is idle again. 0 with reduced motion. */
+declare function revealTotal(nodeCount: number, reduced?: boolean): number;
+/** Where an idea starts its bloom, as an offset from its final position: part of the way toward the layer's center. */
+declare function bloomOffset(node: Point, center: Point): Point;
+/** When the layers swap after Step inside ('in') or Back out ('out'). 0 with reduced motion (a cross-fade). */
+declare function swapDelay(dir: 'in' | 'out', reduced?: boolean): number;
+/** The stagger slot of item `i` of `count` (ideas or connectors): its own index up to `staggerSlots`, then shared. */
+declare function revealSlot(i: number, count: number): number;
+/** Whether a layer of `nodeCount` ideas blooms in one by one (else it fades in together and hover lifts snap). */
+declare function layerBlooms(nodeCount: number): boolean;
+/** A layer's whole arrival, large layers included: when idea `i` and connector `i` start, and when the layer is idle. */
+declare function layerReveal(nodeCount: number, connectorCount: number, reduced?: boolean): {
+    /** Fades in together (reduced motion, Gradual reveal off, or a layer past `bloomMax`). */ instant: boolean;
+    ideaDelay: (i: number) => number;
+    connectorDelay: (i: number) => number;
+    /** Until the map is idle again. */
+    total: number;
+};
+/** CSS form of an easing. */
+declare function cssEase(e: Bezier): string;
+/** Evaluate an easing at progress t (0–1), for renderers that animate in their own loop. */
+declare function ease(e: Bezier, t: number): number;
+/** The CSS variables VisualMap sets on its root, so its stylesheet animates with exactly these values. */
+declare function motionVars(): Record<string, string>;
+
+type Pt = {
+    x: number;
+    y: number;
+};
+type Box = {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+type Hull = Box & {
+    radius: number;
+};
+type LabelSide = 'bottom' | 'top' | 'left' | 'right';
+type LabelPlacement = {
+    x: number;
+    y: number;
+    side: LabelSide;
+    score: number;
+};
+/** The hull reaches this far beyond its ideas' centers, and rounds its corners this much. */
+declare const HULL: {
+    padX: number;
+    padY: number;
+    radius: number;
+};
+/** Room kept between a member's outline and the hull, for ideas larger than the base size. */
+declare const HULL_CLEAR: {
+    readonly x: 50;
+    readonly y: 51;
+};
+/** The hull around a group's ideas: `padX` / `padY` beyond their centres, or more for an idea that has grown to show
+ *  its label (`rx` / `ry`, its half size: then its outline plus HULL_CLEAR). */
+declare function containerHull(members: ReadonlyArray<Pt & {
+    rx?: number;
+    ry?: number;
+}>): Hull | null;
+/** Candidate spots for a w × h pill, in preference order: bottom center (the default look), top center, the thirds of
+ *  bottom and top, then the sides. Spots keep the whole pill on the straight part of an edge, clear of the corners. */
+declare function labelCandidates(hull: Hull, w: number, h: number): {
+    x: number;
+    y: number;
+    side: LabelSide;
+}[];
+/** Where a container's name goes. `ideas`: the boxes of every idea on the layer (outermost ring included);
+ *  `connectors`: points sampled along every connector; `labels`: the pills already placed on this layer.
+ *  `gap` keeps a little air between the pill and what it avoids. */
+declare function placeContainerLabel(hull: Hull, size: {
+    w: number;
+    h: number;
+}, obstacles: {
+    ideas: Box[];
+    connectors?: Pt[][];
+    labels?: Box[];
+}, gap?: number): LabelPlacement;
+/** Points along a connector, for `connectors`: the same cubic edgePath draws (control points two-thirds of the way
+ *  from each end to the bowed midpoint `mid`, which edgePath returns). */
+declare function connectorSamples(a: Pt, mid: Pt, b: Pt, n?: number): Pt[];
+
+declare const DETAIL: {
+    /** Below this on-screen width an idea draws only its body: no rings, label or shadow. */ readonly bodyOnlyBelow: 24;
+    /** Below this it may be drawn as a plain filled speck in its topic fill (no outline) — indistinguishable at this size. */ readonly speckBelow: 12;
+    /** Above this many ideas in view, idea shadows are skipped (the costliest effect to draw). */ readonly shadowsMaxVisible: 150;
+};
+type IdeaDetail = 'full' | 'body' | 'speck';
+/** What an idea of this on-screen width draws. A selected, focused or hovered idea always draws in full. */
+declare function ideaDetail(screenWidth: number, emphasised?: boolean): IdeaDetail;
+/** Whether idea shadows are drawn with this many ideas in view. */
+declare function shadowsShown(visibleIdeas: number): boolean;
+
+export { type Bezier, type BoundingBox, type ContainerGroupInfo, type CullingOptions, DETAIL, EASE, FEATURE_FLAGS, FRAME, type FitResult, FlatNode, type FrameBox, GESTURE, HULL, HULL_CLEAR, type Hull, type IRenderConfigStore, type ISelectionStore, type ISpatialIndex, type IdeaDetail, type Box as LabelBox, type LabelPlacement, type LabelSide, MOTION, MindMapConnection, NodeSelection, PEEK, PEEK_PLACEMENT, type Pt, RBushSpatialIndex, RenderConfig, SHEET, TERM, TRAIL, VIEW, ViewportState, VisualliDocument, VisualliLayer, bloomOffset, calculateFitCenter, calculateFitView, calculateFitZoom, connectorDelay, connectorSamples, containerHull, cssEase, ease as easeBezier, fitView, getChildLayerForNode, getConnectionsForLayer, getContainersForLayer, getLayerForNavigation, getViewportVisibleNodes, hoverOpensTerm, ideaDetail, intersectsViewport, labelCandidates, layerBlooms, layerBounds, layerFrame, layerReveal, motionVars, peekPosition, pinchZoom, placeContainerLabel, pointerModeFor, renderConfigStore, revealDelay, revealSlot, revealTotal, selectionStore, shadowsShown, swapDelay, zoomAround };