@andespindola/brainlink 0.1.0-beta.115 → 0.1.0-beta.117

package/README.md

@@ -84,11 +84,11 @@ Legacy `.jsonl.gz` packs are upgraded to `.blpk` automatically on first search/c
 - Graph renderer optimized for large datasets with viewport-driven node culling and edge lookup by visible nodes.
 - Canvas graph rendering uses the same batched node and edge pipeline for every graph size, reducing per-frame draw calls while keeping selected and hovered items highlighted.
 - WebGL acceleration is used when available for dense node and edge drawing, with Canvas 2D preserved as the interaction and fallback layer.
-- Graph zoom-out keeps the same Bloom-like scene model for every graph size: nodes remain part of one flat exploration scene while rendering budgets decide how much visible detail is drawn.
+- Graph rendering uses a rebuilt Bloom-like flat scene: no macro galaxy, no recursive subgraphs, no cluster replacement layer and no synthetic 3D projection.
 - Large graph layout API automatically uses compact payload encoding with link-coverage-aware edge selection to reduce initial client load without hiding major relationships.
 - Large-segment layout spacing now grows logarithmically to keep initial visual density consistent between medium and very large vaults (for example, ~1k vs ~50k notes).
 - Graph coordinates are visually compacted across graph sizes so reset starts from a stable fitted scene and zoom-in progressively reveals local detail.
-- Zoomed-out graph LOD samples visible nodes and priority links without switching to nested subgraphs.
+- Zoomed-out graph LOD samples visible nodes and priority links without switching to nested subgraphs or cluster markers.
 - Graph reset fits the full graph scene instead of starting in a separate macro overview mode.
 - Graph filtering runs in a dedicated browser worker to keep the UI thread responsive during heavy datasets.
 - Edge rendering budgets adapt to zoom level to prevent frame spikes on large graph panoramas.
@@ -604,7 +604,7 @@ The graph UI shows:
 - graph rendering safeguards (batched canvas drawing across graph sizes, edge draw caps, lower redraw rate, zoom-aware interaction)
 - adaptive CPU safeguards for large graphs: idle frame pacing, throttled background physics updates and cached viewport dimensions to reduce redraw/layout overhead while preserving interaction responsiveness
 - WebGL node and edge acceleration when supported, falling back to Canvas 2D without changing graph behavior
-- large graph LOD keeps the same scene model as smaller graphs: visible nodes are sampled near the viewport/focus, real links are prioritized, and no recursive graph-of-graphs or synthetic 3D projection is applied
+- large graph LOD keeps the same scene model as smaller graphs: visible nodes are sampled near the viewport/focus, real links are prioritized, and no macro galaxy, recursive graph-of-graphs, cluster replacement layer or synthetic 3D projection is applied
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

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

@@ -6,30 +6,18 @@ const massiveGraphNodeThreshold = 20000
 const largeGraphEdgeRenderLimit = 120000
 const renderNodeBudget = 900
 const zoomedMassiveRenderNodeBudget = 2200
-const renderEdgeBudget = 2400
-const clusterActivationNodeThreshold = 600
-const clusterZoomThreshold = 0.18
-const macroGalaxyZoomThreshold = 0.012
-const macroGalaxyEnterHysteresis = 0.86
-const macroGalaxyExitHysteresis = 1.24
-const galaxyDiscoveryEnabled = false
+const massiveOverviewRenderNodeBudget = 1800
+const massiveOverviewScaleThreshold = 0.065
 const massiveAutoFitMacroScale = 0.018
-const defaultMacroScale = 0.018
-const clusterCellPixelSize = 64
 const minNodePixelRadius = 2.3
 const viewportPaddingPx = 280
 const worldCoordinateLimit = 5_000_000
 const transformCoordinateLimit = 20_000_000
 const hoverHitTestIntervalMs = 64
-const ecosystemLevelNodeCap = 999
-const ecosystemActivationNodeThreshold = 1000
-const ecosystemSubgraphScaleThreshold = 0.18
 const zoomRecoveryGuardMs = 4200
-const zoomCapTargetViewportShare = 0.72
 const meshEdgeScaleThreshold = 0.09
 const meshEdgeMinBudget = 140
 const meshEdgeMaxBudget = 1400
-const layeredCoreScaleThreshold = 0.55
 const dragNeighborhoodMaxAffected = 180
 const dragSettleRounds = 3
 const wheelZoomExponent = 0.0009
@@ -54,9 +42,6 @@ const state = {
   visibleEdges: [],
   renderNodes: [],
   renderEdges: [],
-  renderClusters: [],
-  renderClusterEdges: [],
-  renderNodeDepthProjectionById: new Map(),
   nodeDegrees: new Map(),
   selected: null,
   hovered: null,
@@ -81,27 +66,12 @@ const state = {
   lastViewportKey: '',
   visibleNodeSpatial: { cellSize: 220, minX: 0, minY: 0, maxX: 0, maxY: 0, buckets: new Map() },
   visibleEdgeByNode: new Map(),
-  ecosystemClusters: [],
-  ecosystemClustersBySize: new Map(),
-  ecosystemNodeClusterBySize: new Map(),
-  ecosystemLevelSizes: [],
-  ecosystemLevelIndexBySize: new Map(),
-  ecosystemHubNodeIds: new Set(),
-  ecosystemExpansionLevels: [],
-  ecosystemBaseSize: ecosystemLevelNodeCap,
-  ecosystemHubCluster: null,
-  macroCenter: { x: 0, y: 0 },
-  macroRepresentative: null,
   primaryHub: null,
-  hubNeighborDistance: Number.POSITIVE_INFINITY,
   filterWorker: null,
   filterReady: false,
   lastHoverHitAt: 0,
   lastManualZoomAt: 0,
   lastZoomFocus: { x: 0, y: 0, at: 0 },
-  macroViewActive: false,
-  ecosystemViewActive: false,
-  depthProjectionActive: false,
   zoomTransition: {
     active: false,
     source: 'generic',
@@ -532,47 +502,6 @@ const filteredNodes = () => {
   return withPersistentHubNodes(localFilteredNodes(query))
 }
 
-const resolveMacroRepresentative = (nodes) => {
-  if (nodes.length === 0) {
-    return null
-  }
-
-  const hubCandidate = state.primaryHub && nodes.some(node => node.id === state.primaryHub.id)
-    ? state.primaryHub
-    : null
-  let best = hubCandidate ?? nodes[0]
-  let bestDegree = state.nodeDegrees.get(best.id) ?? 0
-
-  for (let index = 1; index < nodes.length; index += 1) {
-    const node = nodes[index]
-    const degree = state.nodeDegrees.get(node.id) ?? 0
-    if (degree > bestDegree) {
-      best = node
-      bestDegree = degree
-    }
-  }
-
-  return best
-}
-
-const nearestHubNeighborDistance = (hub, nodes) => {
-  if (!hub || nodes.length <= 1) {
-    return Number.POSITIVE_INFINITY
-  }
-
-  let minimum = Number.POSITIVE_INFINITY
-  for (let index = 0; index < nodes.length; index += 1) {
-    const node = nodes[index]
-    if (node.id === hub.id) continue
-    const distance = Math.hypot(node.x - hub.x, node.y - hub.y)
-    if (distance < minimum) {
-      minimum = distance
-    }
-  }
-
-  return minimum
-}
-
 const isDominantHub = (hub, nodeCount = state.visibleNodes.length) => {
   if (!hub || nodeCount <= 0) {
     return false
@@ -600,25 +529,6 @@ const recomputeVisibility = () => {
   state.visibleEdgeByNode = createVisibleEdgeLookup(limitedEdges)
   const primaryHub = rankedHubNodes()[0] ?? null
   state.primaryHub = primaryHub
-  state.hubNeighborDistance = nearestHubNeighborDistance(primaryHub, nodes)
-  const bounds = graphBounds(nodes)
-  const macroHub = isDominantHub(primaryHub, nodes.length) ? primaryHub : null
-  state.macroCenter = bounds
-    ? {
-      x: macroHub ? macroHub.x : (bounds.minX + bounds.maxX) / 2,
-      y: macroHub ? macroHub.y : (bounds.minY + bounds.maxY) / 2
-    }
-    : { x: 0, y: 0 }
-  state.ecosystemClusters = []
-  state.ecosystemClustersBySize = new Map()
-  state.ecosystemNodeClusterBySize = new Map()
-  state.ecosystemLevelSizes = []
-  state.ecosystemLevelIndexBySize = new Map()
-  state.ecosystemHubNodeIds = new Set()
-  state.ecosystemExpansionLevels = []
-  state.ecosystemBaseSize = ecosystemLevelNodeCap
-  state.ecosystemHubCluster = null
-  state.macroRepresentative = resolveMacroRepresentative(nodes)
   markRenderDirty()
 }
 
@@ -723,24 +633,6 @@ const createVisibleEdgeLookup = edges => {
   return lookup
 }
 
-const isClusterInViewport = (cluster, viewport) =>
-  cluster.x >= viewport.minX &&
-  cluster.x <= viewport.maxX &&
-  cluster.y >= viewport.minY &&
-  cluster.y <= viewport.maxY
-
-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 }
-  }
-  return viewportCenterWorldPoint()
-}
-
 const edgeBudgetForCurrentFrame = () => {
   const zoom = state.transform.scale
   if (zoom < 0.12) return 380
@@ -752,112 +644,24 @@ const edgeBudgetForCurrentFrame = () => {
   return 7600
 }
 
-const clusterBudgetForScale = (scale) => {
-  if (scale < 0.008) return 90
-  if (scale < 0.014) return 150
-  if (scale < 0.022) return 240
-  if (scale < 0.035) return 360
-  return 520
-}
-
 const nodeBudgetForScale = (scale) => {
-  if (scale < 0.035) return 220
-  if (scale < 0.06) return 360
-  if (scale < 0.09) return 520
-  if (scale < 0.14) return 720
   if (state.visibleNodes.length > massiveGraphNodeThreshold) {
+    if (scale < massiveOverviewScaleThreshold) return massiveOverviewRenderNodeBudget
+    if (scale < 0.09) return 1600
+    if (scale < 0.14) return 1800
     if (scale < 0.28) return renderNodeBudget
     if (scale < 0.45) return 1100
     if (scale < 0.7) return 1400
     if (scale < 1.05) return 1800
     return zoomedMassiveRenderNodeBudget
   }
+  if (scale < 0.035) return 220
+  if (scale < 0.06) return 360
+  if (scale < 0.09) return 520
+  if (scale < 0.14) return 720
   return renderNodeBudget
 }
 
-const layerFocusForScale = (scale) => {
-  const normalized = Math.max(0, Math.min(1, (scale - 0.06) / 0.94))
-  const shellCenter = Math.max(0.08, 0.96 - normalized * 0.86)
-  const shellWidth = Math.max(0.24, 0.46 - normalized * 0.16)
-  const coreRadius = Math.max(0.06, 0.1 + normalized * 0.22)
-  const coreRatio = Math.max(0.2, Math.min(0.72, 0.24 + normalized * 0.48))
-
-  return { shellCenter, shellWidth, coreRadius, coreRatio }
-}
-
-const selectLayeredNodesForScale = (sourceNodes, targetCount) => {
-  const hub = state.primaryHub
-  if (!hub || sourceNodes.length <= 1200 || state.visibleNodes.length <= massiveGraphNodeThreshold) {
-    return sourceNodes
-  }
-
-  let maxDistance = 0
-  const distances = sourceNodes.map((node) => {
-    const distance = Math.hypot(node.x - hub.x, node.y - hub.y)
-    if (distance > maxDistance) {
-      maxDistance = distance
-    }
-    return { node, distance }
-  })
-
-  if (maxDistance <= 0.001) {
-    return sourceNodes
-  }
-
-  const focus = layerFocusForScale(state.transform.scale)
-  const normalizedRows = distances.map((item) => ({
-    ...item,
-    normalized: item.distance / maxDistance
-  }))
-  const desired = Math.max(260, Math.min(sourceNodes.length, targetCount * 2))
-  const coreTarget = Math.max(36, Math.min(desired - 8, Math.floor(desired * focus.coreRatio)))
-  const shellTarget = Math.max(12, desired - coreTarget)
-  const shellHalf = focus.shellWidth / 2
-
-  const coreNodes = normalizedRows
-    .filter((item) => item.normalized <= focus.coreRadius)
-    .sort((left, right) => {
-      const leftScore = state.nodeDegrees.get(left.node.id) ?? 0
-      const rightScore = state.nodeDegrees.get(right.node.id) ?? 0
-      if (leftScore !== rightScore) return rightScore - leftScore
-      return left.node.id.localeCompare(right.node.id)
-    })
-    .slice(0, coreTarget)
-    .map((item) => item.node)
-
-  const shellNodes = normalizedRows
-    .sort((left, right) => {
-      const leftDelta = Math.abs(left.normalized - focus.shellCenter)
-      const rightDelta = Math.abs(right.normalized - focus.shellCenter)
-      const leftInside = leftDelta <= shellHalf ? 0 : 1
-      const rightInside = rightDelta <= shellHalf ? 0 : 1
-      if (leftInside !== rightInside) return leftInside - rightInside
-      if (leftDelta !== rightDelta) return leftDelta - rightDelta
-      const leftScore = state.nodeDegrees.get(left.node.id) ?? 0
-      const rightScore = state.nodeDegrees.get(right.node.id) ?? 0
-      if (leftScore !== rightScore) return rightScore - leftScore
-      return left.node.id.localeCompare(right.node.id)
-    })
-    .slice(0, shellTarget)
-    .map((item) => item.node)
-
-  const merged = []
-  const ids = new Set()
-  const pushUnique = (node) => {
-    if (!node || ids.has(node.id)) return
-    ids.add(node.id)
-    merged.push(node)
-  }
-
-  if (state.transform.scale >= layeredCoreScaleThreshold) {
-    pushUnique(hub)
-  }
-  for (let index = 0; index < coreNodes.length; index += 1) pushUnique(coreNodes[index])
-  for (let index = 0; index < shellNodes.length; index += 1) pushUnique(shellNodes[index])
-
-  return merged.length > 0 ? merged : sourceNodes
-}
-
 const viewportCenterWorldPoint = () => {
   const viewport = worldViewportBounds()
   return {
@@ -896,30 +700,6 @@ const visibilityScaleBucket = (scale) => {
   return Math.round(safeScale * 180_000)
 }
 
-const shouldRenderEcosystemClusterView = (nodeCount, scale) => {
-  state.ecosystemViewActive = false
-  return false
-}
-
-const shouldRenderMacroGalaxyView = () => {
-  if (!galaxyDiscoveryEnabled) {
-    state.macroViewActive = false
-    return false
-  }
-  if (state.visibleNodes.length <= 1) {
-    state.macroViewActive = false
-    return false
-  }
-
-  const enterThreshold = macroGalaxyZoomThreshold * macroGalaxyEnterHysteresis
-  const exitThreshold = macroGalaxyZoomThreshold * macroGalaxyExitHysteresis
-  const shouldRender = state.macroViewActive
-    ? state.transform.scale <= exitThreshold
-    : state.transform.scale <= enterThreshold
-  state.macroViewActive = shouldRender
-  return shouldRender
-}
-
 const mergeUniqueNodes = (leftNodes, rightNodes, limit) => {
   const merged = []
   const ids = new Set()
@@ -981,31 +761,6 @@ const selectStableSampleNodes = (sourceNodes, limit) => {
     .slice(0, limit)
 }
 
-const selectAccessBridgeNodes = (sourceNodes, limit) => {
-  if (limit <= 0 || sourceNodes.length === 0) {
-    return []
-  }
-
-  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 = cursorPoint ?? recentZoomFocus ?? viewportCenterWorldPoint()
-  return [...sourceNodes]
-    .sort((left, right) => {
-      const leftDistance = Math.hypot(left.x - anchor.x, left.y - anchor.y)
-      const rightDistance = Math.hypot(right.x - anchor.x, right.y - anchor.y)
-      if (leftDistance !== rightDistance) return leftDistance - rightDistance
-      const leftDegree = state.nodeDegrees.get(left.id) ?? 0
-      const rightDegree = state.nodeDegrees.get(right.id) ?? 0
-      if (leftDegree !== rightDegree) return rightDegree - leftDegree
-      return left.id.localeCompare(right.id)
-    })
-    .slice(0, limit)
-}
-
 const edgeIdentityKey = edge => {
   if (!edge.target) return ''
   const pair = edge.source < edge.target
@@ -1126,8 +881,8 @@ const edgeWidthFor = (edge, selectedEdge) => {
 const drawGraphEdge = (edge) => {
   const selectedEdge = state.selected && (edge.source === state.selected.id || edge.target === state.selected.id)
   ctx.beginPath()
-  ctx.moveTo(nodeRenderX(edge.sourceNode), nodeRenderY(edge.sourceNode))
-  ctx.lineTo(nodeRenderX(edge.targetNode), nodeRenderY(edge.targetNode))
+  ctx.moveTo(edge.sourceNode.x, edge.sourceNode.y)
+  ctx.lineTo(edge.targetNode.x, edge.targetNode.y)
   ctx.strokeStyle = edgeStrokeFor(edge, selectedEdge)
   ctx.lineWidth = edgeWidthFor(edge, selectedEdge)
   ctx.stroke()
@@ -1141,8 +896,8 @@ const drawEdgeBatch = (edges, options) => {
   ctx.beginPath()
   for (let index = 0; index < edges.length; index += 1) {
     const edge = edges[index]
-    ctx.moveTo(nodeRenderX(edge.sourceNode), nodeRenderY(edge.sourceNode))
-    ctx.lineTo(nodeRenderX(edge.targetNode), nodeRenderY(edge.targetNode))
+    ctx.moveTo(edge.sourceNode.x, edge.sourceNode.y)
+    ctx.lineTo(edge.targetNode.x, edge.targetNode.y)
   }
   ctx.strokeStyle = options.strokeStyle
   ctx.lineWidth = options.lineWidth
@@ -1197,13 +952,11 @@ const shouldDrawNodeLabels = (node, isSelected, isHovered) =>
   (state.nodes.length <= largeGraphNodeThreshold && (state.transform.scale > 1.18 || state.nodes.length <= 25))
 
 const drawSingleNode = (node, options = { drawLabel: true }) => {
-  const radius = nodeRadius(node) * nodeRenderScale(node)
-  const x = nodeRenderX(node)
-  const y = nodeRenderY(node)
-  const opacity = nodeRenderOpacity(node)
+  const radius = nodeRadius(node)
+  const x = node.x
+  const y = node.y
   const isSelected = state.selected?.id === node.id
   const isHovered = state.hovered?.id === node.id
-  ctx.globalAlpha = opacity
   ctx.beginPath()
   ctx.arc(x, y, radius + (isSelected ? 7 : isHovered ? 4 : 0), 0, Math.PI * 2)
   ctx.fillStyle = isSelected || isHovered ? graphTheme.nodeHaloActive : graphTheme.nodeHalo
@@ -1217,7 +970,7 @@ const drawSingleNode = (node, options = { drawLabel: true }) => {
   ctx.stroke()
 
   if (options.drawLabel && shouldDrawNodeLabels(node, isSelected, isHovered)) {
-    ctx.globalAlpha = Math.max(0.58, opacity)
+    ctx.globalAlpha = 1
     ctx.fillStyle = graphTheme.label
     ctx.font = '12px Inter, system-ui, sans-serif'
     ctx.textAlign = 'center'
@@ -1236,10 +989,10 @@ const drawNodeBatch = (nodes) => {
   if (drawHalos) {
     for (let index = 0; index < nodes.length; index += 1) {
       const node = nodes[index]
-      const radius = nodeRadius(node) * nodeRenderScale(node)
-      const x = nodeRenderX(node)
-      const y = nodeRenderY(node)
-      ctx.globalAlpha = Math.max(0.2, nodeRenderOpacity(node) * 0.5)
+      const radius = nodeRadius(node)
+      const x = node.x
+      const y = node.y
+      ctx.globalAlpha = 0.5
       ctx.beginPath()
       ctx.arc(x, y, radius + 3, 0, Math.PI * 2)
       ctx.fillStyle = graphTheme.nodeHalo
@@ -1250,11 +1003,10 @@ const drawNodeBatch = (nodes) => {
 
   for (let index = 0; index < nodes.length; index += 1) {
     const node = nodes[index]
-    const radius = nodeRadius(node) * nodeRenderScale(node)
-    const x = nodeRenderX(node)
-    const y = nodeRenderY(node)
-    const opacity = nodeRenderOpacity(node)
-    ctx.globalAlpha = opacity
+    const radius = nodeRadius(node)
+    const x = node.x
+    const y = node.y
+    ctx.globalAlpha = 1
     ctx.beginPath()
     ctx.arc(x, y, radius, 0, Math.PI * 2)
     ctx.fillStyle = graphTheme.node
@@ -1291,10 +1043,10 @@ const drawGraphNodes = () => {
     ctx.textBaseline = 'top'
     for (let index = 0; index < regularNodes.length; index += 1) {
       const node = regularNodes[index]
-      const x = nodeRenderX(node)
-      const y = nodeRenderY(node)
-      const radius = nodeRadius(node) * nodeRenderScale(node)
-      ctx.globalAlpha = Math.max(0.6, nodeRenderOpacity(node))
+      const x = node.x
+      const y = node.y
+      const radius = nodeRadius(node)
+      ctx.globalAlpha = 1
       ctx.fillText(node.title.slice(0, 34), x, y + radius + 8)
     }
     ctx.globalAlpha = 1
@@ -1348,17 +1100,17 @@ const drawGraphLabels = nodes => {
   ctx.textBaseline = 'top'
   for (let index = 0; index < nodes.length; index += 1) {
     const node = nodes[index]
-    const x = nodeRenderX(node)
-    const y = nodeRenderY(node)
-    const radius = nodeRadius(node) * nodeRenderScale(node)
-    ctx.globalAlpha = Math.max(0.6, nodeRenderOpacity(node))
+    const x = node.x
+    const y = node.y
+    const radius = nodeRadius(node)
+    ctx.globalAlpha = 1
     ctx.fillText(node.title.slice(0, 34), x, y + radius + 8)
   }
   ctx.globalAlpha = 1
 }
 
 const drawAcceleratedGraph = (width, height, drawEdges) => {
-  if (!webGlRenderer || state.renderClusters.length > 0) {
+  if (!webGlRenderer) {
     return false
   }
 
@@ -1559,6 +1311,11 @@ const sampleVisibleNodes = (limit = renderNodeBudget, sourceNodes = state.visibl
   return nodes
 }
 
+const sampleMassiveOverviewNodes = (limit) => {
+  const sampled = sampleVisibleNodes(limit, state.visibleNodes)
+  return ensureHubNodesInRenderedSet(sampled)
+}
+
 const enrichSampleWithNeighbors = (nodes) => {
   if (nodes.length === 0) {
     return {
@@ -1728,18 +1485,6 @@ const zoomCapByNodeCount = (nodeCount) => {
   return zoomRange.max
 }
 
-const zoomCapByHubDistance = (distance) => {
-  if (!Number.isFinite(distance) || distance <= 0) {
-    return zoomRange.max
-  }
-
-  const rect = canvas.getBoundingClientRect()
-  const viewportWidth = Math.max(rect.width, 320)
-  const viewportHeight = Math.max(rect.height, 320)
-  const reference = Math.max(220, Math.min(viewportWidth, viewportHeight) * zoomCapTargetViewportShare)
-  return Math.max(0.3, Math.min(zoomRange.max, reference / distance))
-}
-
 const currentZoomMax = () => {
   const nodeCount = state.visibleNodes.length > 0 ? state.visibleNodes.length : state.nodes.length
   return Math.max(zoomRange.min * 2, zoomCapByNodeCount(nodeCount))
@@ -1748,7 +1493,7 @@ const currentZoomMax = () => {
 const zoomFloorByNodeCount = (nodeCount) => {
   if (nodeCount > massiveGraphNodeThreshold) return 0.018
   if (nodeCount > largeGraphNodeThreshold) return 0.0032
-  if (nodeCount > ecosystemActivationNodeThreshold) return 0.001
+  if (nodeCount > 1000) return 0.001
   return zoomRange.min
 }
 
@@ -1860,57 +1605,7 @@ const autoFitScaleRangeByNodeCount = nodeCount => {
   return { min: 0.0085, max: 0.36 }
 }
 
-const macroFaceToFaceScale = (nodeCount, hubDistance) => {
-  if (!Number.isFinite(hubDistance) || hubDistance <= 0 || nodeCount <= ecosystemActivationNodeThreshold) {
-    return 0
-  }
-
-  const rect = canvas.getBoundingClientRect()
-  const viewportReference = Math.max(320, Math.min(rect.width, rect.height))
-  const share = nodeCount > massiveGraphNodeThreshold ? 0.2 : 0.17
-  const targetPx = Math.max(24, viewportReference * share)
-  return targetPx / hubDistance
-}
-
-const nearestClusterNeighborDistance = (clusters) => {
-  if (!Array.isArray(clusters) || clusters.length < 2) {
-    return Number.POSITIVE_INFINITY
-  }
-
-  let nearestDistance = Number.POSITIVE_INFINITY
-  for (let index = 0; index < clusters.length; index += 1) {
-    const source = clusters[index]
-    for (let neighborIndex = index + 1; neighborIndex < clusters.length; neighborIndex += 1) {
-      const target = clusters[neighborIndex]
-      const distance = Math.hypot(source.x - target.x, source.y - target.y)
-      if (distance > 0 && distance < nearestDistance) {
-        nearestDistance = distance
-      }
-    }
-  }
-
-  return nearestDistance
-}
-
-const macroEcosystemFaceScale = (nodeCount) => {
-  if (nodeCount <= ecosystemActivationNodeThreshold) {
-    return 0
-  }
-
-  const baseClusters = state.ecosystemClustersBySize.get(state.ecosystemBaseSize) ?? state.ecosystemClusters
-  const siblingClusters = baseClusters.filter(cluster => !cluster.isHub)
-  const nearestDistance = nearestClusterNeighborDistance(siblingClusters)
-  if (!Number.isFinite(nearestDistance) || nearestDistance <= 0) {
-    return 0
-  }
-
-  const rect = canvas.getBoundingClientRect()
-  const viewportReference = Math.max(320, Math.min(rect.width, rect.height))
-  const targetShare = nodeCount > massiveGraphNodeThreshold ? 0.28 : 0.24
-  const targetPx = Math.max(30, viewportReference * targetShare)
-  return targetPx / nearestDistance
-}
-const fitView = (options = { useFiltered: true, macro: false, preferHubCenter: true }) => {
+const fitView = (options = { useFiltered: true, preferHubCenter: true }) => {
   const rect = canvas.getBoundingClientRect()
   const width = Math.max(rect.width, 320)
   const height = Math.max(rect.height, 320)
@@ -1942,21 +1637,9 @@ const fitView = (options = { useFiltered: true, macro: false, preferHubCenter: t
   const biasedScale = clampScale(fitScale * fitScaleBiasByNodeCount(nodes.length))
   const scaleRange = autoFitScaleRangeByNodeCount(nodes.length)
   const baselineScale = clampScale(Math.min(scaleRange.max, Math.max(scaleRange.min, biasedScale)))
-  const macroScale = nodes.length > massiveGraphNodeThreshold ? massiveAutoFitMacroScale : defaultMacroScale
-  const scale = options.macro && nodes.length > 1
-    ? clampScale(Math.min(baselineScale, macroScale))
-    : nodes.length > massiveGraphNodeThreshold
-      ? clampScale(Math.min(baselineScale, massiveAutoFitMacroScale))
-      : baselineScale
-  const macroFloorScale = options.macro
-    ? clampScale(Math.max(
-      macroFaceToFaceScale(nodes.length, state.hubNeighborDistance),
-      macroEcosystemFaceScale(nodes.length)
-    ))
-    : 0
-  const resolvedScale = options.macro
-    ? clampScale(Math.max(scale, macroFloorScale))
-    : scale
+  const resolvedScale = nodes.length > massiveGraphNodeThreshold
+    ? clampScale(Math.min(baselineScale, massiveAutoFitMacroScale))
+    : baselineScale
   const hubCenter =
     options.preferHubCenter && isDominantHub(state.primaryHub, nodes.length) && nodes.some((node) => node.id === state.primaryHub.id)
       ? state.primaryHub
@@ -1975,12 +1658,12 @@ const fitView = (options = { useFiltered: true, macro: false, preferHubCenter: t
   markRenderDirty()
 }
 
-const resetView = () => fitView({ useFiltered: false, macro: false, preferHubCenter: false })
+const resetView = () => fitView({ useFiltered: false, preferHubCenter: false })
 
 const focusPrimaryHub = () => {
   const hub = state.primaryHub
   if (!hub) {
-    fitView({ useFiltered: true, macro: false, preferHubCenter: true })
+    fitView({ useFiltered: true, preferHubCenter: true })
     return
   }
 
@@ -2347,9 +2030,6 @@ const settleNeighborhoodAroundNode = (dragNode) => {
 
 const hitNode = point => {
   computeRenderVisibility()
-  if (state.renderClusters.length > 0) {
-    return null
-  }
   const hitScaleFloor = state.nodes.length > massiveGraphNodeThreshold
     ? 0.2
     : state.nodes.length > largeGraphNodeThreshold
@@ -2362,9 +2042,9 @@ const hitNode = point => {
   const nodes = state.renderNodes
   for (let index = nodes.length - 1; index >= 0; index -= 1) {
     const node = nodes[index]
-    const radius = nodeRadius(node) * nodeRenderScale(node)
-    const x = nodeRenderX(node)
-    const y = nodeRenderY(node)
+    const radius = nodeRadius(node)
+    const x = node.x
+    const y = node.y
     if (Math.hypot(point.x - x, point.y - y) <= radius + 5) return node
   }
   return null
@@ -2377,36 +2057,6 @@ const baseNodeRadius = node => {
 
 const nodeRadius = node => Math.max(baseNodeRadius(node), minNodePixelRadius / Math.max(state.transform.scale, 0.0001))
 
-const clusterRadiusPx = cluster => {
-  if (cluster.id === 'macro-galaxy') {
-    return 10
-  }
-  if (cluster.isHub) {
-    return 3.8
-  }
-  if (String(cluster.id).startsWith('ecosystem-')) {
-    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
-    const radius = Math.max(0.62, Math.min(2.4, sizeBias + densityBias))
-    const depthScale = Number.isFinite(cluster.depthScale) ? cluster.depthScale : 1
-    return Math.max(0.56, Math.min(3.2, radius * depthScale))
-  }
-  return Math.max(8, Math.min(28, 8 + Math.log2(cluster.count + 1) * 3))
-}
-
-const clusterOpacity = cluster =>
-  Math.max(0, Math.min(1, Number.isFinite(cluster.lodOpacity) ? cluster.lodOpacity : 1))
-
-const refreshRenderNodeDepthProjection = () => {
-  state.renderNodeDepthProjectionById = new Map()
-}
-
-const projectedNode = node => state.renderNodeDepthProjectionById.get(node.id) ?? null
-const nodeRenderX = node => projectedNode(node)?.x ?? node.x
-const nodeRenderY = node => projectedNode(node)?.y ?? node.y
-const nodeRenderScale = node => projectedNode(node)?.scale ?? 1
-const nodeRenderOpacity = node => projectedNode(node)?.opacity ?? 1
 const worldViewportBounds = () => {
   const width = Math.max(state.viewport.width, 320)
   const height = Math.max(state.viewport.height, 320)
@@ -2460,68 +2110,6 @@ const viewportNodeStride = () => {
   return 8
 }
 
-const shouldRenderClusters = viewportNodes =>
-  state.transform.scale <= clusterZoomThreshold && viewportNodes.length >= clusterActivationNodeThreshold
-
-const clusterViewportNodes = viewportNodes => {
-  if (!shouldRenderClusters(viewportNodes)) {
-    return []
-  }
-
-  const worldCellSize = Math.max(clusterCellPixelSize / Math.max(state.transform.scale, 0.0001), 1)
-  const buckets = new Map()
-
-  for (let index = 0; index < viewportNodes.length; index += 1) {
-    const node = viewportNodes[index]
-    const keyX = Math.floor(node.x / worldCellSize)
-    const keyY = Math.floor(node.y / worldCellSize)
-    const key = keyX + ':' + keyY
-    const current = buckets.get(key)
-    if (current) {
-      current.count += 1
-      current.sumX += node.x
-      current.sumY += node.y
-      if ((state.nodeDegrees.get(node.id) ?? 0) > current.degree) {
-        current.representative = node
-        current.degree = state.nodeDegrees.get(node.id) ?? 0
-      }
-      continue
-    }
-
-    buckets.set(key, {
-      id: key,
-      count: 1,
-      sumX: node.x,
-      sumY: node.y,
-      representative: node,
-      degree: state.nodeDegrees.get(node.id) ?? 0
-    })
-  }
-
-  return Array.from(buckets.values())
-    .sort((left, right) => right.count - left.count)
-    .slice(0, Math.min(renderNodeBudget, 900))
-    .map((cluster) => ({
-      id: cluster.id,
-      x: cluster.sumX / Math.max(cluster.count, 1),
-      y: cluster.sumY / Math.max(cluster.count, 1),
-      count: cluster.count,
-      representative: cluster.representative
-    }))
-}
-
-const representativeNodesFromClusters = (clusters, limit) => {
-  const representatives = clusters
-    .map((cluster) => cluster.representative)
-    .filter((node) => Boolean(node))
-  const merged = mergeUniqueNodes(
-    representatives,
-    state.renderNodes ?? [],
-    Math.max(1, limit)
-  )
-  return ensureHubNodesInRenderedSet(merged)
-}
-
 const computeRenderVisibility = () => {
   if (!hasValidTransform()) {
     fitView({ useFiltered: true })
@@ -2539,49 +2127,26 @@ const computeRenderVisibility = () => {
   }
   state.lastViewportKey = viewportKey
   state.renderVisibilityDirty = false
-  state.renderClusterEdges = []
-
-  const shouldRenderMacroGalaxy = shouldRenderMacroGalaxyView()
-
-  if (shouldRenderMacroGalaxy) {
-    const viewportNodes = viewportNodesFromSpatialIndex(viewport)
-    const sourceNodes = viewportNodes.length > 0 ? viewportNodes : state.visibleNodes
-    const representative = state.primaryHub ?? state.macroRepresentative ?? sourceNodes[0] ?? null
-    if (representative) {
-      state.renderClusters = [
-        {
-          id: 'macro-galaxy',
-          x: state.macroCenter.x,
-          y: state.macroCenter.y,
-          count: sourceNodes.length,
-          representative
-        }
-      ]
-      state.renderNodes = [representative]
-    } else {
-      state.renderClusters = []
-      state.renderNodes = []
-    }
-    state.renderEdges = []
-    state.renderClusterEdges = []
-    return
-  }
-
-  state.ecosystemViewActive = false
 
   if (state.visibleNodes.length <= 2000) {
     state.renderNodes = state.visibleNodes
-    state.renderClusters = []
-    state.renderClusterEdges = []
     const ids = new Set(state.renderNodes.map((node) => node.id))
     state.renderEdges = withMeshEdges(state.renderNodes, collectVisibleEdgesForNodes(ids))
     return
   }
 
   if (state.visibleNodes.length > massiveGraphNodeThreshold) {
-    const viewportNodes = viewportNodesFromSpatialIndex(viewport)
-    const sourceNodes = viewportNodes.length > 0 ? viewportNodes : state.visibleNodes
     const sampleLimit = nodeBudgetForScale(state.transform.scale)
+    if (state.transform.scale < massiveOverviewScaleThreshold) {
+      const overviewNodes = sampleMassiveOverviewNodes(sampleLimit)
+      const overviewIds = new Set(overviewNodes.map((node) => node.id))
+      state.renderNodes = overviewNodes
+      state.renderEdges = withMeshEdges(overviewNodes, collectVisibleEdgesForNodes(overviewIds))
+      return
+    }
+
+    const viewportNodes = viewportNodesFromSpatialIndex(viewport)
+    const sourceNodes = viewportNodes.length > 0 ? viewportNodes : sampleMassiveOverviewNodes(sampleLimit)
     const carryMargin = Math.max(240, Math.min(1200, 340 / Math.max(state.transform.scale, 0.0001)))
     const carryViewport = expandViewportBounds(viewport, carryMargin)
     const carryOverLimit = Math.max(180, Math.min(sampleLimit, Math.floor(sampleLimit * 0.5)))
@@ -2623,9 +2188,6 @@ const computeRenderVisibility = () => {
       const sampledWithHubsIds = new Set(sampledNodes.map((node) => node.id))
       sampledEdges = collectVisibleEdgesForNodes(sampledWithHubsIds)
     }
-
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderNodes = sampledNodes
     state.renderEdges = withMeshEdges(sampledNodes, sampledEdges)
     return
@@ -2634,24 +2196,12 @@ const computeRenderVisibility = () => {
   if (state.transform.scale <= 0.0015) {
     const sampled = sampleVisibleNodes(Math.min(renderNodeBudget, 900))
     const sampledIds = new Set(sampled.map((node) => node.id))
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderNodes = sampled
     state.renderEdges = withMeshEdges(sampled, collectVisibleEdgesForNodes(sampledIds))
     return
   }
 
   const viewportNodes = viewportNodesFromSpatialIndex(viewport)
-  const clusters = clusterViewportNodes(viewportNodes)
-  if (clusters.length > 0) {
-    state.renderClusters = []
-    state.renderClusterEdges = []
-    state.renderNodes = representativeNodesFromClusters(clusters, Math.min(renderNodeBudget, 900))
-    state.renderEdges = []
-    return
-  }
-  state.renderClusters = []
-  state.renderClusterEdges = []
   const stride = viewportNodeStride()
   const picked = []
 
@@ -2674,8 +2224,6 @@ const computeRenderVisibility = () => {
     const fallbackNodes = fallbackViewportNodes()
     const fallbackIds = new Set(fallbackNodes.map((node) => node.id))
     state.renderNodes = fallbackNodes
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderEdges = withMeshEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
     return
   }
@@ -2690,8 +2238,6 @@ const computeRenderVisibility = () => {
   if (state.renderNodes.length === 0 && state.visibleNodes.length > 0) {
     const fallbackNodes = sampleVisibleNodes(Math.min(renderNodeBudget, 260))
     const fallbackIds = new Set(fallbackNodes.map((node) => node.id))
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderNodes = fallbackNodes
     state.renderEdges = withMeshEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
   }
@@ -2775,10 +2321,11 @@ const render = now => {
 
   computeRenderVisibility()
   tick(delta, now)
-  refreshRenderNodeDepthProjection()
   const hasVisibleNodeOnScreen = state.renderNodes.some((node) => isNodeVisibleOnScreen(node, width, height))
   const manualZoomGuardActive = now - state.lastManualZoomAt < zoomRecoveryGuardMs
-  const allowViewportAutoRecovery = state.nodes.length <= massiveGraphNodeThreshold
+  const allowViewportAutoRecovery =
+    state.nodes.length <= massiveGraphNodeThreshold ||
+    state.transform.scale >= massiveOverviewScaleThreshold
   if (allowViewportAutoRecovery && !hasVisibleNodeOnScreen && state.renderNodes.length > 0 && !manualZoomGuardActive) {
     state.offscreenFrameCount += 1
     if (state.offscreenFrameCount >= 22 && !state.recoveringViewport) {
@@ -2802,69 +2349,9 @@ const render = now => {
           : state.renderNodes.length > 500
             ? 0.05
             : 0
-  const drawEdges =
-    state.renderClusters.length === 0 &&
-    state.transform.scale >= minimumEdgeScale
+  const drawEdges = state.transform.scale >= minimumEdgeScale
   if (drawAcceleratedGraph(width, height, drawEdges)) {
     // WebGL handles the dense node/edge layer; the 2D canvas remains the interaction overlay.
-  } else if (state.renderClusters.length > 0) {
-    ctx.save()
-    ctx.translate(state.transform.x, state.transform.y)
-    ctx.scale(state.transform.scale, state.transform.scale)
-    const orderedClusters = [...state.renderClusters]
-    const safeScale = Math.max(state.transform.scale, 0.0001)
-    if (state.renderClusterEdges.length > 0) {
-      for (let index = 0; index < state.renderClusterEdges.length; index += 1) {
-        const edge = state.renderClusterEdges[index]
-        const edgeOpacity = Math.min(clusterOpacity(edge.sourceCluster), clusterOpacity(edge.targetCluster))
-        if (edgeOpacity <= 0.01) {
-          continue
-        }
-        const widthScale = 1
-        ctx.beginPath()
-        ctx.moveTo(edge.sourceCluster.x, edge.sourceCluster.y)
-        ctx.lineTo(edge.targetCluster.x, edge.targetCluster.y)
-        ctx.lineWidth = (1.2 * widthScale) / safeScale
-        ctx.strokeStyle = 'rgba(153, 165, 181, ' + (edge.inferred ? 0.14 : 0.22) * edgeOpacity + ')'
-        ctx.stroke()
-      }
-    }
-    orderedClusters.forEach(cluster => {
-      const isMacro = cluster.id === 'macro-galaxy'
-      const isEcosystem = String(cluster.id).startsWith('ecosystem-')
-      const isHub = Boolean(cluster.isHub)
-      const opacity = clusterOpacity(cluster)
-      if (opacity <= 0.01) {
-        return
-      }
-      const radiusPx = clusterRadiusPx(cluster)
-      const radius = radiusPx / safeScale
-      const haloRadius = (radiusPx + (isMacro ? 8 : isHub ? 4 : isEcosystem ? 1.1 : 4)) / safeScale
-      ctx.globalAlpha = opacity
-      if (isHub || !isEcosystem || state.transform.scale >= ecosystemSubgraphScaleThreshold) {
-        ctx.beginPath()
-        ctx.arc(cluster.x, cluster.y, haloRadius, 0, Math.PI * 2)
-        ctx.fillStyle = isMacro ? 'rgba(243, 247, 251, 0.28)' : graphTheme.nodeHalo
-        ctx.fill()
-      }
-      ctx.beginPath()
-      ctx.arc(cluster.x, cluster.y, radius, 0, Math.PI * 2)
-      ctx.fillStyle = isMacro ? '#f3f7fb' : graphTheme.node
-      ctx.fill()
-      ctx.lineWidth = (isEcosystem && !isHub ? 0.7 : 1.4) / safeScale
-      ctx.strokeStyle = isMacro ? '#ffffff' : graphTheme.nodeStroke
-      ctx.stroke()
-      if (isMacro && cluster.representative?.title) {
-        ctx.fillStyle = '#edf2f7'
-        ctx.font = 12 / safeScale + 'px Inter, system-ui, sans-serif'
-        ctx.textAlign = 'center'
-        ctx.textBaseline = 'top'
-        ctx.fillText(cluster.representative.title.slice(0, 28), cluster.x, cluster.y + (radiusPx + 9) / safeScale)
-      }
-      ctx.globalAlpha = 1
-      // Keep cluster markers minimal and faster to draw on large graphs.
-    })
-    ctx.restore()
   } else {
     ctx.save()
     ctx.translate(state.transform.x, state.transform.y)
@@ -2875,7 +2362,7 @@ const render = now => {
     drawGraphNodes()
     ctx.restore()
   }
-  if (state.renderNodes.length === 0 && state.renderClusters.length === 0) {
+  if (state.renderNodes.length === 0) {
     ctx.fillStyle = '#99a5b5'
     ctx.font = '12px Inter, system-ui, sans-serif'
     ctx.textAlign = 'center'

package/package.json

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