@visualli/core 0.1.7 → 0.2.0

package/dist/index.js

@@ -9,42 +9,26 @@ import {
   setViewportCenter,
   worldToScreen,
   zoomViewport
-} from "./chunk-LJYSKSCE.js";
+} from "./chunk-W2CAOOJJ.js";
 import {
-  ANIMATION_DURATION,
-  ANIMATION_PHASES,
-  COOLDOWN,
-  OPACITY,
-  TARGET_ZOOM,
-  VIEWPORT_FRAMING,
-  ZOOM_THRESHOLDS,
-  createCubicBezier,
-  easeInCubic,
-  easeInOutCubic,
-  easeInOutQuart,
-  easeInOutSine,
-  easeOutCubic,
-  easeOutQuad,
-  easeZoomTransition
-} from "./chunk-F36SMC3K.js";
-import {
-  ACTIVE_BLOB_TYPES,
-  ALL_BLOB_SHAPES,
-  BLOB_LAYER_CONFIG,
-  BLOB_TEXT_OFFSETS,
-  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 "./chunk-LNTJTDB2.js";
+  BLOB_SHAPES,
+  MAX_RINGS,
+  RINGS,
+  SHAPE,
+  arrowPath,
+  blobPath,
+  blobRadius,
+  connectorGeometry,
+  drawBlob,
+  edgePath,
+  nodeBounds,
+  nodeRadii,
+  outlineRadius,
+  ringCount,
+  ringsFor,
+  shapeForLevel,
+  shapeOfLevel
+} from "./chunk-TPLJJKAU.js";
 import {
   DEFAULT_RENDER_CONFIG,
   FEATURE_FLAGS,
@@ -56,7 +40,7 @@ import {
   getRecommendedRenderConfig,
   getRenderConfigForQuality,
   isFeatureEnabled
-} from "./chunk-I75TMOE4.js";
+} from "./chunk-P6PKWVYF.js";
 import {
   checkCollision,
   getNodeBounds,
@@ -76,34 +60,26 @@ import {
   getChildLayers,
   getNodeConnections,
   getNodesForLayer,
+  getSemanticAnchors,
   getTopLevelConnections,
   getVisibleNodes,
   loadVisualliFileFromFile,
   parseVisualliFile,
   parseVisualliFromMongoDB,
   resolveNodeOverlaps
-} from "./chunk-6NXADJK2.js";
+} from "./chunk-7NJWM7ZE.js";
 import {
-  BRAND_COLORS,
-  CANVAS_COLORS,
-  DS_COLORS,
-  DS_RADII,
-  DS_TYPOGRAPHY,
-  FONTS,
-  FONT_SIZES,
-  LAYOUT_SPACING,
-  LEVEL_COLORS,
-  LEVEL_COLOR_ARRAY,
-  PARENT_FALLBACK_COLORS,
-  SEMANTIC_COLORS,
-  SPACING,
-  THEME_COLORS,
-  darkenHexColor,
-  getColorForLevel,
-  getThemeBackground,
-  getThemeBorder,
-  getThemeText
-} from "./chunk-G5H3P4YZ.js";
+  IDEA,
+  LABEL_GROWTH,
+  approximateMeasure,
+  ideaKindOf,
+  ideaSize,
+  labelGrowth,
+  wrapLines
+} from "./chunk-25AJTPMS.js";
+import {
+  LAYOUT_SPACING
+} from "./chunk-N7HCYULH.js";
 import {
   applyCircularLayout,
   applyLinearHorizontalLayout,
@@ -115,18 +91,10 @@ import {
   FPSMonitor,
   MemoryMonitor,
   PerformanceProfiler
-} from "./chunk-PDP5CVUL.js";
+} from "./chunk-LOQLNYB3.js";
 import {
-  BORDER_WIDTH_NORMAL,
-  BORDER_WIDTH_SELECTED,
-  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,
@@ -141,6 +109,8 @@ import {
   FPS_UPDATE_INTERVAL,
   FPS_UPGRADE_THRESHOLD,
   FPS_WARNING_THRESHOLD,
+  FRAME,
+  GESTURE,
   MAX_FRAME_TIME,
   MAX_NODES,
   MAX_VISIBLE_NODES,
@@ -150,9 +120,8 @@ import {
   MEMORY_TARGET_MB,
   MEMORY_WARNING_MB,
   NODE_COUNT_THRESHOLDS,
-  NODE_HEIGHT,
-  NODE_MIN_WIDTH,
-  NODE_PADDING,
+  PEEK,
+  PEEK_PLACEMENT,
   PERFORMANCE_TOAST_COOLDOWN,
   QUALITY_HIGH,
   QUALITY_LOW,
@@ -161,22 +130,57 @@ import {
   RESIZE_DEBOUNCE,
   SCROLL_THROTTLE,
   SEARCH_DEBOUNCE,
+  SHEET,
   SPATIAL_INDEX_BUILD_BUDGET,
   TARGET_FRAME_TIME,
-  TEXT_LABEL_HIDE_BELOW_ZOOM,
+  TERM,
   TIMING_THRESHOLDS,
-  TITLE_MAX_LENGTH,
+  TRAIL,
+  VIEW,
   VIEWPORT_CONFIG,
   VIEWPORT_MARGIN,
   ZOOM_DEFAULT,
   ZOOM_MAX,
   ZOOM_MIN,
-  ZOOM_NAV_IN_THRESHOLD,
-  ZOOM_NAV_OUT_THRESHOLD,
-  ZOOM_STEP,
-  ZOOM_WHEEL_SENSITIVITY
-} from "./chunk-LDJRGT2Q.js";
+  fitView,
+  hoverOpensTerm,
+  layerBounds,
+  peekPosition,
+  pinchZoom,
+  pointerModeFor,
+  zoomAround
+} from "./chunk-UAMEJG2C.js";
 import "./chunk-VLGR5PZX.js";
+import {
+  CUSTOM,
+  TOPIC_ORDER,
+  customColor,
+  getTokens,
+  ideaColor,
+  ideaStyle,
+  isContrastTheme,
+  isDarkTheme,
+  isFocusTheme,
+  isThemeName,
+  labelScale,
+  metricsFor,
+  resolveComfort,
+  resolveTheme,
+  token,
+  topicFor,
+  topicFromName,
+  topicStyle
+} from "./chunk-KVSM3APM.js";
+import {
+  CANVAS_STYLE,
+  DESIGN_SYSTEM_VERSION,
+  METRICS,
+  METRICS_REDUCED_MOTION,
+  THEME_NAMES,
+  TOKENS,
+  TOPICS,
+  TYPE_STYLES
+} from "./chunk-LV3EXUQY.js";
 
 // src/spatial/spatialIndex.ts
 import RBush from "rbush";
@@ -275,6 +279,73 @@ var renderConfigStore = createStore((set, get) => ({
   isFeatureEnabled: (feature) => isFeatureEnabled(feature, get())
 }));
 
+// src/generated/geometry/container.ts
+var HULL = { padX: 150, padY: 125, radius: 48 };
+var WEIGHT = { idea: 1e3, label: 1e3, connector: 60, preference: 1 };
+var HULL_CLEAR = { x: 50, y: 51 };
+function containerHull(members) {
+  if (!members.length) return null;
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const m of members) {
+    const px = Math.max(HULL.padX, (m.rx ?? 0) + HULL_CLEAR.x), py = Math.max(HULL.padY, (m.ry ?? 0) + HULL_CLEAR.y);
+    x0 = Math.min(x0, m.x - px);
+    x1 = Math.max(x1, m.x + px);
+    y0 = Math.min(y0, m.y - py);
+    y1 = Math.max(y1, m.y + py);
+  }
+  return { x0, x1, y0, y1, radius: HULL.radius };
+}
+function labelCandidates(hull, w, h) {
+  const { x0, x1, y0, y1, radius } = hull;
+  const cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+  const minX = x0 + radius + w / 2, maxX = x1 - radius - w / 2;
+  const minY = y0 + radius + h / 2, maxY = y1 - radius - h / 2;
+  const along = (lo, hi, f) => lo > hi ? (lo + hi) / 2 : lo + (hi - lo) * f;
+  const out = [
+    { x: cx, y: y1, side: "bottom" },
+    { x: cx, y: y0, side: "top" },
+    { x: along(minX, maxX, 0.2), y: y1, side: "bottom" },
+    { x: along(minX, maxX, 0.8), y: y1, side: "bottom" },
+    { x: along(minX, maxX, 0.2), y: y0, side: "top" },
+    { x: along(minX, maxX, 0.8), y: y0, side: "top" },
+    { x: x1, y: cy, side: "right" },
+    { x: x0, y: cy, side: "left" },
+    { x: x1, y: along(minY, maxY, 0.25), side: "right" },
+    { x: x1, y: along(minY, maxY, 0.75), side: "right" },
+    { x: x0, y: along(minY, maxY, 0.25), side: "left" },
+    { x: x0, y: along(minY, maxY, 0.75), side: "left" }
+  ];
+  out.push(
+    { x: along(minX, maxX, 0), y: y1, side: "bottom" },
+    { x: along(minX, maxX, 1), y: y1, side: "bottom" },
+    { x: along(minX, maxX, 0), y: y0, side: "top" },
+    { x: along(minX, maxX, 1), y: y0, side: "top" }
+  );
+  return out;
+}
+var overlap = (a, b) => Math.max(0, Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0)) * Math.max(0, Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0));
+function placeContainerLabel(hull, size, obstacles, gap = 10) {
+  const { w, h } = size;
+  let best = null;
+  labelCandidates(hull, w, h).forEach((c, i) => {
+    const box = { x0: c.x - w / 2 - gap, x1: c.x + w / 2 + gap, y0: c.y - h / 2 - gap, y1: c.y + h / 2 + gap };
+    const area = w * h;
+    let score = i * WEIGHT.preference;
+    for (const b of obstacles.ideas) score += overlap(box, b) / area * WEIGHT.idea;
+    for (const b of obstacles.labels || []) score += overlap(box, b) / area * WEIGHT.label;
+    for (const line of obstacles.connectors || []) if (line.some((p) => p.x > box.x0 && p.x < box.x1 && p.y > box.y0 && p.y < box.y1)) score += WEIGHT.connector;
+    if (!best || score < best.score) best = { x: c.x, y: c.y, side: c.side, score };
+  });
+  return best;
+}
+function connectorSamples(a, mid, b, n = 16) {
+  const c1 = { x: a.x + (mid.x - a.x) * 0.66, y: a.y + (mid.y - a.y) * 0.66 }, c2 = { x: b.x + (mid.x - b.x) * 0.66, y: b.y + (mid.y - b.y) * 0.66 };
+  return Array.from({ length: n + 1 }, (_, k) => {
+    const t = k / n, u = 1 - t;
+    return { x: u * u * u * a.x + 3 * u * u * t * c1.x + 3 * u * t * t * c2.x + t * t * t * b.x, y: u * u * u * a.y + 3 * u * u * t * c1.y + 3 * u * t * t * c2.y + t * t * t * b.y };
+  });
+}
+
 // src/utils/navigation.ts
 function getConnectionsForLayer(doc, layerId) {
   const layer = doc.layers.get(layerId);
@@ -283,7 +354,8 @@ function getConnectionsForLayer(doc, layerId) {
     from: c.from,
     to: c.to,
     level: layer.level,
-    label: c.data?.label
+    label: c.data?.label,
+    style: c.data?.style === "dashed" ? "dashed" : "solid"
   }));
 }
 function getChildLayerForNode(doc, nodeId, currentLayerId) {
@@ -297,53 +369,49 @@ function getChildLayerForNode(doc, nodeId, currentLayerId) {
 function getLayerForNavigation(doc, nodeId, currentLayerId) {
   return getChildLayerForNode(doc, nodeId, currentLayerId);
 }
-function calculateFitZoom(nodes, canvasWidth, canvasHeight, padding = 0.15) {
-  if (nodes.length === 0) return 1;
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const n of nodes) {
-    minX = Math.min(minX, n.x - n.width / 2);
-    minY = Math.min(minY, n.y - n.height / 2);
-    maxX = Math.max(maxX, n.x + n.width / 2);
-    maxY = Math.max(maxY, n.y + n.height / 2);
+function layerFrame(nodes, containers = []) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const hulls = [];
+  for (const c of containers) {
+    const hull = containerHull(c.nodeIds.flatMap((id) => {
+      const n = byId.get(id);
+      return n ? [{ x: n.x, y: n.y, rx: n.width / 2, ry: n.height / 2 }] : [];
+    }));
+    if (hull) hulls.push(hull);
   }
-  const rawW = maxX - minX;
-  const rawH = maxY - minY;
-  const spreadW = nodes.length === 1 ? Math.max(rawW, 600) : rawW;
-  const spreadH = nodes.length === 1 ? Math.max(rawH, 400) : rawH;
-  const zoomX = canvasWidth * (1 - padding) / spreadW;
-  const zoomY = canvasHeight * (1 - padding) / spreadH;
-  const z = Math.min(zoomX, zoomY);
-  return Math.max(z * 0.8, ZOOM_NAV_OUT_THRESHOLD);
+  return layerBounds(nodes.map((n) => ({ x: n.x, y: n.y, rx: n.width / 2, ry: n.height / 2 })), hulls);
+}
+function calculateFitZoom(nodes, canvasWidth, canvasHeight, containers = []) {
+  if (nodes.length === 0) return 1;
+  return fitView(layerFrame(nodes, containers), canvasWidth, canvasHeight).scale;
 }
-function calculateFitCenter(nodes) {
+function calculateFitCenter(nodes, containers = []) {
   if (nodes.length === 0) return { x: 0, y: 0 };
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const n of nodes) {
-    minX = Math.min(minX, n.x - n.width / 2);
-    minY = Math.min(minY, n.y - n.height / 2);
-    maxX = Math.max(maxX, n.x + n.width / 2);
-    maxY = Math.max(maxY, n.y + n.height / 2);
-  }
-  return { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+  const f = layerFrame(nodes, containers);
+  return { x: (f.x0 + f.x1) / 2, y: (f.y0 + f.y1) / 2 };
 }
 function getContainersForLayer(doc, layerId) {
   const layer = doc.layers.get(layerId);
   if (!layer) return [];
   const containers = layer.containers ?? [];
   if (!Array.isArray(containers)) return [];
-  return containers.map((c) => {
+  return containers.filter((c) => c.data?.style !== "none").map((c) => {
     const label = c.data?.label ?? c.id;
     return { id: c.id, label, nodeIds: c.nodes, level: layer.level };
   });
 }
-function calculateFitView(nodes, canvasWidth, canvasHeight) {
-  const center = calculateFitCenter(nodes);
-  const zoom = calculateFitZoom(nodes, canvasWidth, canvasHeight);
-  return { centerX: center.x, centerY: center.y, zoomLevel: zoom };
+function calculateFitView(nodes, canvasWidth, canvasHeight, containers = []) {
+  if (nodes.length === 0) return { centerX: 0, centerY: 0, zoomLevel: 1 };
+  const { scale, center } = fitView(layerFrame(nodes, containers), canvasWidth, canvasHeight);
+  return { centerX: center.x, centerY: center.y, zoomLevel: scale };
 }
 
 // src/rendering/culling.ts
 var DEFAULT_SPATIAL_INDEX_THRESHOLD = 200;
+function intersectsViewport(n, bounds) {
+  const b = nodeBounds(n);
+  return b.maxX >= bounds.minX && b.minX <= bounds.maxX && b.maxY >= bounds.minY && b.minY <= bounds.maxY;
+}
 function getViewportVisibleNodes(options) {
   const {
     nodes,
@@ -361,9 +429,7 @@ function getViewportVisibleNodes(options) {
   if (skipCulling || isDragging) return filtered;
   const bounds = calculateViewportBounds(viewport, canvasWidth, canvasHeight);
   if (filtered.length < spatialIndexThreshold) {
-    return filtered.filter(
-      (n) => n.x + n.width >= bounds.minX && n.x <= bounds.maxX && n.y + n.height >= bounds.minY && n.y <= bounds.maxY
-    );
+    return filtered.filter((n) => intersectsViewport(n, bounds));
   }
   if (spatialIndex) {
     const nodeIds = spatialIndex.query({
@@ -375,45 +441,191 @@ function getViewportVisibleNodes(options) {
     const idSet = new Set(nodeIds);
     return filtered.filter((n) => idSet.has(n.id));
   }
-  return filtered.filter(
-    (n) => n.x + n.width >= bounds.minX && n.x <= bounds.maxX && n.y + n.height >= bounds.minY && n.y <= bounds.maxY
-  );
+  return filtered.filter((n) => intersectsViewport(n, bounds));
+}
+
+// src/generated/geometry/motion.ts
+var EASE = {
+  /** ease-standard — UI and connector drawing. */
+  standard: [0.4, 0, 0.2, 1],
+  /** ease-zoom — diving into and out of layers. */
+  zoom: [0.2, 0.8, 0.2, 1],
+  /** ease-bloom — ideas arriving, with a little overshoot. */
+  bloom: [0.34, 1.4, 0.64, 1]
+};
+var MOTION = {
+  /** A layer arrives: ideas bloom one by one in sibling order, center first, then connectors draw. */
+  reveal: {
+    /** duration-reveal: each idea's bloom. */
+    duration: 420,
+    /** stagger-reveal: delay between consecutive ideas. */
+    stagger: 70,
+    /** An idea starts at this scale… */
+    fromScale: 0.55,
+    /** …and this fraction of the way from its place toward the layer's center. */
+    fromCenter: 0.5,
+    ease: EASE.bloom,
+    /** Settle time after the last bloom before the map is idle (interactive again). */
+    tail: 200
+  },
+  /** Connectors of an arriving layer: they start once the ideas are mostly in. */
+  connector: {
+    /** Lead time before the first connector, on top of the ideas' stagger. */
+    lead: 240,
+    /** Delay between consecutive connectors. */
+    stagger: 60,
+    /** A solid connector draws from source to target; a dashed one fades in instead. */
+    draw: 500,
+    /** The connector group's fade (duration-base). */
+    fade: 240,
+    ease: EASE.standard
+  },
+  /** Step inside: the current layer zooms toward the idea and fades; the inner layer then arrives (reveal). */
+  dive: {
+    /** The old layer's zoom, toward the idea's position. */
+    scale: 3.2,
+    /** duration-zoom. */
+    duration: 500,
+    /** It fades out after this delay, over `fade`. */
+    fadeDelay: 150,
+    fade: 160,
+    /** The layers swap (and the reveal starts) this long after the dive starts. */
+    swapAfter: 320,
+    ease: EASE.zoom
+  },
+  /** Back out (depth trail): the current layer shrinks toward the center and fades; the outer layer arrives. */
+  surface: {
+    scale: 0.6,
+    duration: 220,
+    fade: 200,
+    swapAfter: 220,
+    ease: EASE.zoom
+  },
+  /** The arriving layer as a whole settles from slightly small. */
+  settle: { fromScale: 0.94, duration: 260, ease: EASE.standard },
+  /** Hover (pointer) or select: the idea lifts; its rings turn and grow a touch — a nudge, not a wobble. */
+  hover: {
+    lift: 2,
+    ringRotate: -2,
+    ringScale: 1.015,
+    /** duration-base, for both the lift (ease-bloom) and the rings (ease-standard). */
+    duration: 240,
+    liftEase: EASE.bloom,
+    ringEase: EASE.standard
+  },
+  /** Reduced motion, or Gradual reveal off: everything appears together with a short fade; dives become cross-fades. */
+  reduced: { 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. */
+  largeLayer: { staggerSlots: 30, bloomMax: 150 }
+};
+function revealDelay(i) {
+  return i * MOTION.reveal.stagger;
+}
+function connectorDelay(i, nodeCount) {
+  return MOTION.connector.lead + nodeCount * MOTION.reveal.stagger + i * MOTION.connector.stagger;
+}
+function revealTotal(nodeCount, reduced = false) {
+  return reduced ? 0 : MOTION.reveal.duration + nodeCount * MOTION.reveal.stagger + MOTION.reveal.tail;
+}
+function bloomOffset(node, center) {
+  const k = MOTION.reveal.fromCenter;
+  return { x: (center.x - node.x) * k, y: (center.y - node.y) * k };
+}
+function swapDelay(dir, reduced = false) {
+  return reduced ? 0 : dir === "in" ? MOTION.dive.swapAfter : MOTION.surface.swapAfter;
+}
+function revealSlot(i, count) {
+  const slots = Math.min(count, MOTION.largeLayer.staggerSlots);
+  return count > slots ? Math.floor(i * slots / count) : i;
+}
+function layerBlooms(nodeCount) {
+  return nodeCount <= MOTION.largeLayer.bloomMax;
+}
+function layerReveal(nodeCount, connectorCount, reduced = false) {
+  const instant = reduced || !layerBlooms(nodeCount);
+  const slots = Math.min(nodeCount, MOTION.largeLayer.staggerSlots);
+  const edgeSlots = Math.min(connectorCount, MOTION.largeLayer.staggerSlots);
+  return {
+    /** Fades in together (reduced motion, Gradual reveal off, or a layer past `bloomMax`). */
+    instant,
+    ideaDelay: (i) => instant ? 0 : revealDelay(revealSlot(i, nodeCount)),
+    connectorDelay: (i) => instant ? 0 : connectorDelay(revealSlot(i, connectorCount), slots),
+    /** Until the map is idle again. */
+    total: instant ? reduced ? 0 : MOTION.reduced.fade : Math.max(revealTotal(slots), edgeSlots ? connectorDelay(edgeSlots - 1, slots) + MOTION.connector.draw : 0)
+  };
+}
+function cssEase(e) {
+  return `cubic-bezier(${e.join(", ")})`;
+}
+function ease(e, t) {
+  const [x1, y1, x2, y2] = e;
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  const bx = (u2) => 3 * x1 * u2 * (1 - u2) ** 2 + 3 * x2 * u2 * u2 * (1 - u2) + u2 ** 3;
+  const by = (u2) => 3 * y1 * u2 * (1 - u2) ** 2 + 3 * y2 * u2 * u2 * (1 - u2) + u2 ** 3;
+  let lo = 0, hi = 1, u = t;
+  for (let k = 0; k < 24; k++) {
+    u = (lo + hi) / 2;
+    if (bx(u) < t) lo = u;
+    else hi = u;
+  }
+  return by(u);
+}
+function motionVars() {
+  const m = MOTION;
+  return {
+    "--vi-bloom-from": String(m.reveal.fromScale),
+    "--vi-line-draw": `${m.connector.draw}ms`,
+    "--vi-dive-scale": String(m.dive.scale),
+    "--vi-dive-fade": `${m.dive.fade}ms`,
+    "--vi-dive-fade-delay": `${m.dive.fadeDelay}ms`,
+    "--vi-surface-scale": String(m.surface.scale),
+    "--vi-surface-dur": `${m.surface.duration}ms`,
+    "--vi-surface-fade": `${m.surface.fade}ms`,
+    "--vi-settle-from": String(m.settle.fromScale),
+    "--vi-settle-dur": `${m.settle.duration}ms`,
+    "--vi-reduced-fade": `${m.reduced.fade}ms`,
+    "--vi-lift": `${m.hover.lift}px`,
+    "--vi-ring-turn": `${m.hover.ringRotate}deg`,
+    "--vi-ring-grow": String(m.hover.ringScale)
+  };
+}
+
+// src/generated/geometry/detail.ts
+var DETAIL = {
+  /** Below this on-screen width an idea draws only its body: no rings, label or shadow. */
+  bodyOnlyBelow: 24,
+  /** Below this it may be drawn as a plain filled speck in its topic fill (no outline) — indistinguishable at this size. */
+  speckBelow: 12,
+  /** Above this many ideas in view, idea shadows are skipped (the costliest effect to draw). */
+  shadowsMaxVisible: 150
+};
+function ideaDetail(screenWidth, emphasised = false) {
+  if (emphasised || screenWidth >= DETAIL.bodyOnlyBelow) return "full";
+  return screenWidth < DETAIL.speckBelow ? "speck" : "body";
+}
+function shadowsShown(visibleIdeas) {
+  return visibleIdeas <= DETAIL.shadowsMaxVisible;
 }
 export {
-  ACTIVE_BLOB_TYPES,
-  ALL_BLOB_SHAPES,
-  ANIMATION_DURATION,
-  ANIMATION_PHASES,
-  BLOB_LAYER_CONFIG,
-  BLOB_TEXT_OFFSETS,
-  BORDER_WIDTH_NORMAL,
-  BORDER_WIDTH_SELECTED,
-  BRAND_COLORS,
-  CANVAS_COLORS,
-  CHAR_WIDTH,
+  BLOB_SHAPES,
+  CANVAS_STYLE,
   CIRCULAR_REFERENCE_MAX_DEPTH,
   CLICK_THRESHOLD,
-  COLOR_BORDER_DARK,
-  COLOR_BORDER_LIGHT,
-  COLOR_DEFAULT_NODE,
-  COLOR_SELECTED,
-  CONTAINER_LABEL_BASE_FONT_PX,
-  COOLDOWN,
-  CORNER_RADIUS,
   CULLING_QUERY_TIME_BUDGET,
+  CUSTOM,
   DEFAULT_CANVAS_HEIGHT,
   DEFAULT_CANVAS_WIDTH,
   DEFAULT_RENDER_CONFIG,
-  DESCRIPTION_TEXT_BASE_FONT_PX,
+  DESIGN_SYSTEM_VERSION,
+  DETAIL,
   DOUBLE_CLICK_DELAY,
   DRAG_START_DISTANCE,
-  DS_COLORS,
-  DS_RADII,
-  DS_TYPOGRAPHY,
-  EDGE_LABEL_BASE_FONT_PX,
+  EASE,
   FEATURE_FLAGS,
-  FONTS,
-  FONT_SIZES,
   FPSMonitor,
   FPS_CRITICAL_THRESHOLD,
   FPS_DOWNGRADE_THRESHOLD,
@@ -424,27 +636,29 @@ export {
   FPS_UPDATE_INTERVAL,
   FPS_UPGRADE_THRESHOLD,
   FPS_WARNING_THRESHOLD,
+  FRAME,
+  GESTURE,
+  HULL,
+  HULL_CLEAR,
+  IDEA,
+  LABEL_GROWTH,
   LAYOUT_SPACING,
-  LEVEL_COLORS,
-  LEVEL_COLOR_ARRAY,
   MAX_FRAME_TIME,
   MAX_NODES,
+  MAX_RINGS,
   MAX_VISIBLE_NODES,
   MEMORY_CHECK_INTERVAL,
   MEMORY_CRITICAL_MB,
   MEMORY_LIMITS,
   MEMORY_TARGET_MB,
   MEMORY_WARNING_MB,
+  METRICS,
+  METRICS_REDUCED_MOTION,
+  MOTION,
   MemoryMonitor,
   NODE_COUNT_THRESHOLDS,
-  NODE_HEIGHT,
-  NODE_LAYER_CONFIG,
-  NODE_MIN_WIDTH,
-  NODE_PADDING,
-  NODE_TEXT_BASE_FONT_PX,
-  OPACITY,
-  OVERLAY_FONT_UPPER_BOOST_PX,
-  PARENT_FALLBACK_COLORS,
+  PEEK,
+  PEEK_PLACEMENT,
   PERFORMANCE_TOAST_COOLDOWN,
   PerformanceProfiler,
   QUALITY_HIGH,
@@ -456,33 +670,37 @@ export {
   RBushSpatialIndex,
   RENDER_MODES,
   RESIZE_DEBOUNCE,
+  RINGS,
   SCROLL_THROTTLE,
   SEARCH_DEBOUNCE,
-  SEMANTIC_COLORS,
+  SHAPE,
+  SHEET,
   SIMPLIFIED_RENDER_CONFIG,
-  SPACING,
   SPATIAL_INDEX_BUILD_BUDGET,
   TARGET_FRAME_TIME,
-  TARGET_ZOOM,
-  TEXT_LABEL_HIDE_BELOW_ZOOM,
-  THEME_COLORS,
+  TERM,
+  THEME_NAMES,
   TIMING_THRESHOLDS,
-  TITLE_MAX_LENGTH,
+  TOKENS,
+  TOPICS,
+  TOPIC_ORDER,
+  TRAIL,
+  TYPE_STYLES,
+  VIEW,
   VIEWPORT_CONFIG,
-  VIEWPORT_FRAMING,
   VIEWPORT_MARGIN,
   VisualliParseError,
   ZOOM_DEFAULT,
   ZOOM_MAX,
   ZOOM_MIN,
-  ZOOM_NAV_IN_THRESHOLD,
-  ZOOM_NAV_OUT_THRESHOLD,
-  ZOOM_STEP,
-  ZOOM_THRESHOLDS,
-  ZOOM_WHEEL_SENSITIVITY,
   applyCircularLayout,
   applyLinearHorizontalLayout,
   applyLinearVerticalLayout,
+  approximateMeasure,
+  arrowPath,
+  blobPath,
+  blobRadius,
+  bloomOffset,
   calculateDistance,
   calculateFitCenter,
   calculateFitView,
@@ -492,32 +710,26 @@ export {
   calculateViewportBounds,
   checkCollision,
   clampZoom,
-  computeEdgeLabelScale,
-  computeNodeTextScreenScale,
-  computeNodeTextWorldScale,
-  computeOverlayScale,
+  connectorDelay,
+  connectorGeometry,
+  connectorSamples,
+  containerHull,
   convertLayerToFlatNodes,
   convertVisualliToFlatNodes,
   countLayersBeneath,
-  createCubicBezier,
   createMindMapConfig,
-  darkenHexColor,
-  drawBlobPath,
-  easeInCubic,
-  easeInOutCubic,
-  easeInOutQuart,
-  easeInOutSine,
-  easeOutCubic,
-  easeOutQuad,
-  easeZoomTransition,
+  cssEase,
+  customColor,
+  drawBlob,
+  ease as easeBezier,
+  edgePath,
   fetchAndParseVisualli,
+  fitView,
   flattenNodes,
   focusOnNode,
   generateSampleConfig,
-  getBlobTypeForLayer,
   getChildLayerForNode,
   getChildLayers,
-  getColorForLevel,
   getConnectionsForLayer,
   getContainersForLayer,
   getLayerForNavigation,
@@ -527,27 +739,70 @@ export {
   getOptimalQualityLevel,
   getRecommendedRenderConfig,
   getRenderConfigForQuality,
-  getThemeBackground,
-  getThemeBorder,
-  getThemeText,
+  getSemanticAnchors,
+  getTokens,
   getTopLevelConnections,
   getViewportVisibleNodes,
   getVisibleNodes,
+  hoverOpensTerm,
+  ideaColor,
+  ideaDetail,
+  ideaKindOf,
+  ideaSize,
+  ideaStyle,
+  intersectsViewport,
+  isContrastTheme,
+  isDarkTheme,
   isFeatureEnabled,
+  isFocusTheme,
   isNodeInViewport,
+  isThemeName,
+  labelCandidates,
+  labelGrowth,
+  labelScale,
+  layerBlooms,
+  layerBounds,
+  layerFrame,
+  layerReveal,
   loadVisualliFileFromFile,
+  metricsFor,
+  motionVars,
+  nodeBounds,
+  nodeRadii,
   optimizeLayout,
+  outlineRadius,
   panViewport,
   parseVisualliFile,
   parseVisualliFromMongoDB,
+  peekPosition,
+  pinchZoom,
+  placeContainerLabel,
+  pointerModeFor,
   recalculateViewportBounds,
   renderConfigStore,
   resolveCollisions,
+  resolveComfort,
   resolveNodeOverlaps,
+  resolveTheme,
+  revealDelay,
+  revealSlot,
+  revealTotal,
+  ringCount,
+  ringsFor,
   screenToWorld,
   selectionStore,
   setViewportCenter,
+  shadowsShown,
+  shapeForLevel,
+  shapeOfLevel,
+  swapDelay,
+  token,
+  topicFor,
+  topicFromName,
+  topicStyle,
   worldToScreen,
+  wrapLines,
+  zoomAround,
   zoomViewport
 };
 //# sourceMappingURL=index.js.map