@andespindola/brainlink 0.1.0-beta.96 → 0.1.0-beta.98

package/README.md

@@ -602,7 +602,7 @@ The graph UI shows:
 - WebGL node and edge acceleration when supported, falling back to Canvas 2D without changing graph behavior
 - compact macro-to-micro density progression so reset keeps the graph mass oriented and zoom-in separates local neighborhoods progressively
 - graph camera treats hub-centered navigation as structural only when the hub is dominant; diffuse stress graphs reset and zoom around the full graph mass
-- graph LOD progression: graphs up to 1000 notes render directly; larger graphs use a compact memory-hub-centered mesh where each 1000-note point already carries a faint connected 500-note micro-structure, then zoom-in keeps focused child clusters latent at the parent position before fading and separating them through 250-note, 125-note, 60-note, 30-note, 15-note and 8-note subgraphs with aggregated real links plus local sibling mesh links, and in massive graphs keeps this subgraph mode active much longer with finer wheel steps so deep zoom does not abruptly switch to a broad sampled node cloud
+- graph LOD progression: graphs up to 1000 notes render directly; larger graphs use one recursive model where each visible level targets up to 999 non-hub nodes, starts from a memory-hub-centered mesh, and each supernode can expand into another same-shape subgraph level (again up to 999 children) with latent fade-in, aggregated real links and local sibling mesh links so org-heavy and stress-50k follow the same structure at different depths
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

package/dist/application/frontend/client-js.js

@@ -21,9 +21,8 @@ const viewportPaddingPx = 280
 const worldCoordinateLimit = 5_000_000
 const transformCoordinateLimit = 20_000_000
 const hoverHitTestIntervalMs = 64
-const ecosystemGroupSize = 1000
+const ecosystemLevelNodeCap = 999
 const ecosystemActivationNodeThreshold = 1000
-const ecosystemGroupSizes = [1000, 500, 250, 125, 60, 30, 15, 8]
 const ecosystemClusterEdgeLimit = 520
 const ecosystemHubEdgeLimit = 120
 const ecosystemSiblingEdgeLimit = 180
@@ -32,15 +31,6 @@ const massiveEcosystemClusterScaleThreshold = 4.2
 const ecosystemSubgraphScaleThreshold = 0.18
 const ecosystemMicroScaleThreshold = 0.08
 const ecosystemFocusedParentLimit = 2
-const ecosystemExpansionLevels = [
-  { parentSize: 1000, childSize: 500, start: 0.04, end: 0.62 },
-  { parentSize: 500, childSize: 250, start: 0.16, end: 0.72 },
-  { parentSize: 250, childSize: 125, start: 0.3, end: 0.78 },
-  { parentSize: 125, childSize: 60, start: 0.46, end: 0.86 },
-  { parentSize: 60, childSize: 30, start: 0.64, end: 1.06 },
-  { parentSize: 30, childSize: 15, start: 0.84, end: 1.38 },
-  { parentSize: 15, childSize: 8, start: 1.08, end: 1.82 }
-]
 const zoomRecoveryGuardMs = 4200
 const zoomCapTargetViewportShare = 0.72
 const meshEdgeScaleThreshold = 0.09
@@ -87,6 +77,9 @@ const state = {
   ecosystemClusters: [],
   ecosystemClustersBySize: new Map(),
   ecosystemNodeClusterBySize: new Map(),
+  ecosystemLevelSizes: [],
+  ecosystemExpansionLevels: [],
+  ecosystemBaseSize: ecosystemLevelNodeCap,
   ecosystemHubCluster: null,
   macroCenter: { x: 0, y: 0 },
   macroRepresentative: null,
@@ -597,10 +590,21 @@ const recomputeVisibility = () => {
     : { x: 0, y: 0 }
   const ecosystemGraph = nodes.length > ecosystemActivationNodeThreshold
     ? buildEcosystemGraph(nodes, state.macroCenter, primaryHub)
-    : { clusters: [], clustersBySize: new Map(), nodeClusterBySize: new Map(), hubCluster: null }
+    : {
+        clusters: [],
+        clustersBySize: new Map(),
+        nodeClusterBySize: new Map(),
+        levelSizes: [],
+        expansionLevels: [],
+        baseSize: ecosystemLevelNodeCap,
+        hubCluster: null
+      }
   state.ecosystemClusters = ecosystemGraph.clusters
   state.ecosystemClustersBySize = ecosystemGraph.clustersBySize
   state.ecosystemNodeClusterBySize = ecosystemGraph.nodeClusterBySize
+  state.ecosystemLevelSizes = ecosystemGraph.levelSizes
+  state.ecosystemExpansionLevels = ecosystemGraph.expansionLevels
+  state.ecosystemBaseSize = ecosystemGraph.baseSize
   state.ecosystemHubCluster = ecosystemGraph.hubCluster
   state.macroRepresentative = resolveMacroRepresentative(nodes)
   markRenderDirty()
@@ -747,14 +751,56 @@ const selectEcosystemRepresentative = nodes => {
 }
 
 const ecosystemLayoutSpacingForSize = size => {
-  if (size >= 1000) return 260
-  if (size >= 500) return 92
-  if (size >= 250) return 52
-  if (size >= 125) return 28
-  if (size >= 60) return 16
-  if (size >= 30) return 11
-  if (size >= 15) return 7
-  return 5
+  if (size >= ecosystemLevelNodeCap) return 260
+  if (size >= 320) return 110
+  if (size >= 120) return 64
+  if (size >= 48) return 34
+  if (size >= 18) return 18
+  if (size >= 8) return 11
+  return 7
+}
+
+const buildEcosystemLevelSizes = nodeCount => {
+  if (nodeCount <= 0) return []
+  const sizes = []
+  let currentSize = Math.max(1, Math.ceil(nodeCount / ecosystemLevelNodeCap))
+  while (currentSize >= 1) {
+    sizes.push(currentSize)
+    if (currentSize === 1) {
+      break
+    }
+    const nextSize = Math.max(1, Math.ceil(currentSize / ecosystemLevelNodeCap))
+    if (nextSize === currentSize) {
+      break
+    }
+    currentSize = nextSize
+  }
+  return sizes
+}
+
+const buildEcosystemExpansionLevels = (levelSizes, nodeCount) => {
+  if (levelSizes.length <= 1) {
+    return []
+  }
+  const maxScale = nodeCount > massiveGraphNodeThreshold
+    ? massiveEcosystemClusterScaleThreshold
+    : ecosystemClusterScaleThreshold
+  const startScale = 0.04
+  const transitionCount = levelSizes.length - 1
+  const usableScale = Math.max(0.08, maxScale - startScale)
+  const step = usableScale / transitionCount
+  const levels = []
+  for (let index = 0; index < transitionCount; index += 1) {
+    const start = startScale + step * index * 0.72
+    const end = Math.min(maxScale, start + step * 1.85)
+    levels.push({
+      parentSize: levelSizes[index],
+      childSize: levelSizes[index + 1],
+      start,
+      end
+    })
+  }
+  return levels
 }
 
 const ecosystemCompactPoint = (index, total, center, spacing) => {
@@ -837,19 +883,30 @@ const buildEcosystemLevel = (sortedNodes, size, parentLookup, center) => {
 
 const buildEcosystemGraph = (nodes, center, hub) => {
   if (nodes.length === 0) {
-    return { clusters: [], clustersBySize: new Map(), nodeClusterBySize: new Map(), hubCluster: null }
+    return {
+      clusters: [],
+      clustersBySize: new Map(),
+      nodeClusterBySize: new Map(),
+      levelSizes: [],
+      expansionLevels: [],
+      baseSize: ecosystemLevelNodeCap,
+      hubCluster: null
+    }
   }
 
   const hubCluster = buildEcosystemHubCluster(hub, center)
   const sortedNodes = nodes
     .filter(node => node.id !== hub?.id)
     .sort(compareNodesForEcosystem)
+  const levelSizes = buildEcosystemLevelSizes(sortedNodes.length)
+  const expansionLevels = buildEcosystemExpansionLevels(levelSizes, nodes.length)
+  const baseSize = levelSizes[0] ?? ecosystemLevelNodeCap
   const clustersBySize = new Map()
   const nodeClusterBySize = new Map()
   let parentLookup = null
 
-  for (let index = 0; index < ecosystemGroupSizes.length; index += 1) {
-    const size = ecosystemGroupSizes[index]
+  for (let index = 0; index < levelSizes.length; index += 1) {
+    const size = levelSizes[index]
     const level = buildEcosystemLevel(sortedNodes, size, parentLookup, center)
     clustersBySize.set(size, level.clusters)
     nodeClusterBySize.set(size, level.clusterByNodeId)
@@ -857,9 +914,12 @@ const buildEcosystemGraph = (nodes, center, hub) => {
   }
 
   return {
-    clusters: clustersBySize.get(ecosystemGroupSize) ?? [],
+    clusters: clustersBySize.get(baseSize) ?? [],
     clustersBySize,
     nodeClusterBySize,
+    levelSizes,
+    expansionLevels,
+    baseSize,
     hubCluster
   }
 }
@@ -876,6 +936,10 @@ const filterEcosystemClustersByViewport = (clusters, viewport) => {
 }
 
 const ecosystemFocusPoint = () => {
+  const cursorPoint = cursorWorldPoint()
+  if (cursorPoint) {
+    return cursorPoint
+  }
   const now = performance.now()
   if (now - state.lastZoomFocus.at <= 1800) {
     return { x: state.lastZoomFocus.x, y: state.lastZoomFocus.y }
@@ -887,7 +951,11 @@ const nearestEcosystemParentIds = (clusters, focusPoint, limit) =>
   clusters
     .map(cluster => ({
       cluster,
-      distance: Math.hypot(cluster.x - focusPoint.x, cluster.y - focusPoint.y)
+      distance: Math.max(
+        0,
+        Math.hypot(cluster.x - focusPoint.x, cluster.y - focusPoint.y) -
+          clusterRadiusPx(cluster) / Math.max(state.transform.scale, 0.0001)
+      )
     }))
     .sort((left, right) => left.distance - right.distance)
     .slice(0, limit)
@@ -903,7 +971,7 @@ const zoomProgress = (scale, start, end) =>
 
 const semanticZoomSpread = (progress, childSize) => {
   const curve = Math.pow(progress, 4.2)
-  if (childSize >= 500) {
+  if (childSize >= Math.ceil(ecosystemLevelNodeCap / 2)) {
     return 0.12 + curve * 0.88
   }
   return curve
@@ -911,7 +979,7 @@ const semanticZoomSpread = (progress, childSize) => {
 
 const opacityForProgress = (progress, childSize) => {
   const eased = Math.pow(progress, 2.1)
-  if (childSize >= 500) {
+  if (childSize >= Math.ceil(ecosystemLevelNodeCap / 2)) {
     return 0.22 + eased * 0.78
   }
   return eased
@@ -953,13 +1021,13 @@ const spreadChildClusterFromParent = (cluster, childSize, progress, spread) => {
 }
 
 const selectHierarchicalEcosystemClusters = viewport => {
-  const baseClusters = state.ecosystemClustersBySize.get(ecosystemGroupSize) ?? state.ecosystemClusters
+  const baseClusters = state.ecosystemClustersBySize.get(state.ecosystemBaseSize) ?? state.ecosystemClusters
   const visibleBaseClusters = filterEcosystemClustersByViewport(baseClusters, viewport)
   const hubClusters = state.ecosystemHubCluster ? [state.ecosystemHubCluster] : []
   const visibleClusters = [...visibleBaseClusters]
 
-  for (let index = 0; index < ecosystemExpansionLevels.length; index += 1) {
-    const level = ecosystemExpansionLevels[index]
+  for (let index = 0; index < state.ecosystemExpansionLevels.length; index += 1) {
+    const level = state.ecosystemExpansionLevels[index]
     const parentClusters = visibleClusters.filter(cluster => cluster.size === level.parentSize)
     if (parentClusters.length === 0) {
       continue
@@ -1233,6 +1301,29 @@ const viewportCenterWorldPoint = () => {
   }
 }
 
+const screenToWorldPoint = (screenX, screenY) => ({
+  x: (screenX - state.transform.x) / state.transform.scale,
+  y: (screenY - state.transform.y) / state.transform.scale
+})
+
+const cursorWorldPoint = () => {
+  if (!state.cursor.inCanvas) {
+    return null
+  }
+  const rect = canvas.getBoundingClientRect()
+  const screenX = state.cursor.x - rect.left
+  const screenY = state.cursor.y - rect.top
+  const width = Math.max(rect.width, 320)
+  const height = Math.max(rect.height, 320)
+  if (!Number.isFinite(screenX) || !Number.isFinite(screenY)) {
+    return null
+  }
+  if (screenX < 0 || screenX > width || screenY < 0 || screenY > height) {
+    return null
+  }
+  return screenToWorldPoint(screenX, screenY)
+}
+
 const visibilityScaleBucket = (scale) => {
   const safeScale = Math.max(zoomRange.min, scale)
   if (safeScale < 0.01) return Math.round(safeScale * 300_000)
@@ -1288,11 +1379,12 @@ const selectStableSampleNodes = (sourceNodes, limit) => {
   }
 
   const now = performance.now()
+  const cursorPoint = cursorWorldPoint()
   const recentZoomFocus =
     now - state.lastZoomFocus.at <= 1500
       ? { x: state.lastZoomFocus.x, y: state.lastZoomFocus.y }
       : null
-  const anchor = recentZoomFocus ?? viewportCenterWorldPoint()
+  const anchor = cursorPoint ?? recentZoomFocus ?? viewportCenterWorldPoint()
   const previousIds = new Set(state.renderNodes.map((node) => node.id))
   const preferAnchorDistance = state.visibleNodes.length > massiveGraphNodeThreshold && state.transform.scale >= 0.28
 
@@ -1326,11 +1418,12 @@ const selectAccessBridgeNodes = (sourceNodes, limit) => {
   }
 
   const now = performance.now()
+  const cursorPoint = cursorWorldPoint()
   const recentZoomFocus =
     now - state.lastZoomFocus.at <= 1200
       ? { x: state.lastZoomFocus.x, y: state.lastZoomFocus.y }
       : null
-  const anchor = recentZoomFocus ?? viewportCenterWorldPoint()
+  const anchor = cursorPoint ?? recentZoomFocus ?? viewportCenterWorldPoint()
   return [...sourceNodes]
     .sort((left, right) => {
       const leftDistance = Math.hypot(left.x - anchor.x, left.y - anchor.y)
@@ -2408,10 +2501,7 @@ const tick = delta => {
 
 const worldPoint = event => {
   const rect = canvas.getBoundingClientRect()
-  return {
-    x: (event.clientX - rect.left - state.transform.x) / state.transform.scale,
-    y: (event.clientY - rect.top - state.transform.y) / state.transform.scale
-  }
+  return screenToWorldPoint(event.clientX - rect.left, event.clientY - rect.top)
 }
 
 const connectedNodeIdsFor = (nodeId) => {
@@ -2550,22 +2640,10 @@ const clusterRadiusPx = cluster => {
     return 3.8
   }
   if (String(cluster.id).startsWith('ecosystem-')) {
-    const base = cluster.size >= 1000
-      ? 0.96
-      : cluster.size >= 500
-        ? 0.9
-        : cluster.size >= 250
-          ? 0.82
-          : cluster.size >= 125
-            ? 0.74
-            : cluster.size >= 60
-              ? 0.66
-              : cluster.size >= 30
-                ? 0.62
-                : cluster.size >= 15
-                  ? 0.74
-                  : 0.9
-    return Math.max(0.62, Math.min(2.2, base + Math.log10(cluster.count + 1) * 0.14))
+    const size = Math.max(1, Math.min(ecosystemLevelNodeCap, cluster.size || cluster.count || 1))
+    const sizeBias = 0.56 + Math.log10(size + 1) * 0.28
+    const densityBias = Math.log10((cluster.count || 1) + 1) * 0.12
+    return Math.max(0.62, Math.min(2.4, sizeBias + densityBias))
   }
   return Math.max(8, Math.min(28, 8 + Math.log2(cluster.count + 1) * 3))
 }
@@ -3170,8 +3248,9 @@ const zoomAtPoint = (screenX, screenY, factor, source = 'generic') => {
   if (nextScale === state.transform.scale) {
     return
   }
-  const worldX = (screenX - state.transform.x) / state.transform.scale
-  const worldY = (screenY - state.transform.y) / state.transform.scale
+  const worldPointAtCursor = screenToWorldPoint(screenX, screenY)
+  const worldX = worldPointAtCursor.x
+  const worldY = worldPointAtCursor.y
   state.lastZoomFocus = {
     x: worldX,
     y: worldY,
@@ -3218,6 +3297,7 @@ const handleWheelZoom = event => {
   const rawCursorY = Number.isFinite(event.offsetY) ? event.offsetY : event.clientY - rect.top
   const cursorX = Math.max(0, Math.min(Math.max(rect.width, 320), rawCursorX))
   const cursorY = Math.max(0, Math.min(Math.max(rect.height, 320), rawCursorY))
+  state.cursor = { x: event.clientX, y: event.clientY, inCanvas: true }
   const factor = wheelZoomFactor(event)
 
   if (!Number.isFinite(factor) || factor <= 0 || factor === 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/brainlink",
-  "version": "0.1.0-beta.96",
+  "version": "0.1.0-beta.98",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",