@andespindola/brainlink 0.1.0-beta.137 → 0.1.0-beta.139

package/README.md

@@ -85,11 +85,10 @@ 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 rendering keeps the flat node scene and adds stable hierarchical mesh groups for vaults above 1000 notes, with every visible graph level filled toward 1000 nodes, each group capped at 1000 child nodes, and recursive parent groups when a level itself exceeds 1000 groups.
 - 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 renders hierarchy groups as sparse relationship graph nodes and expands a group from the focused node's current viewport position only after it is framed, progressively hiding sibling groups in micro view.
+- Zoomed-out graph LOD keeps a single flat graph scene, with viewport-driven node sampling and edge coverage safeguards to preserve visible relationships without switching to nested subgraphs.
 - 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.
@@ -598,16 +597,16 @@ The graph UI shows:
 - realtime refresh while `--watch` is enabled
 - graph controls for zoom in, zoom out, fit visible nodes and reset-to-fit-all
 - wheel zoom (including `cmd+scroll` and `ctrl+scroll`) anchored to cursor position for faster navigation in large graphs
-- continuous target-scale interpolation for wheel/button zoom to avoid abrupt jumps while keeping cursor-anchored focus
+- wheel/button zoom updates immediately at the cursor anchor without delayed focus-transition interpolation
 - Bloom-like scene navigation: reset fits the current graph scene, wheel zoom stays anchored to the cursor, and WebGL acceleration draws the dense node and edge layer faster
 - zoom-out floor for large and massive graphs to keep the scene reachable without switching into a separate macro graph mode
 - keyboard shortcuts: `+` zoom in, `-` zoom out, `0` reset fit
-- click on a hierarchy group expands that group from the same world position; clicking the same focused group again opens its details panel; double-click on empty canvas zooms in at cursor position
+- click on a node opens its details panel; double-click on empty canvas zooms in at cursor position
 - floating graph totals (notes, links, tags) below the Brainlink title
 - 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 a recursive graph-of-graphs model: zoom-out fills the projected macro level toward 1000 lightweight group nodes with every aggregated link between visible groups, zoom-in grows the focused node into a local child graph anchored at the same point, once the child graph is framed the sibling groups stop rendering, groups with child groups open another graph level instead of jumping to leaf notes, and zoom-out restores sibling groups
+- large graph LOD keeps a single-level graph model across zoom levels, preserving visual continuity while adjusting node/edge density from the active viewport
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

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

@@ -749,13 +749,7 @@ const selectStableSampleNodes = (sourceNodes, limit) => {
     return sourceNodes
   }
 
-  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 = cursorPoint ?? recentZoomFocus ?? viewportCenterWorldPoint()
+  const anchor = viewportCenterWorldPoint()
   const previousIds = new Set(state.renderNodes.map((node) => node.id))
   const preferAnchorDistance = state.visibleNodes.length > massiveGraphNodeThreshold && state.transform.scale >= 0.28
 
@@ -815,14 +809,17 @@ const edgeRelevanceScore = edge => {
   return score
 }
 
-const collectVisibleEdgesForNodes = nodeIds => {
+const collectVisibleEdgesForNodes = (nodeIds, options = { preferComplete: false }) => {
   if (nodeIds.size === 0) {
     return []
   }
 
   const seen = new Set()
   const candidates = []
-  const limit = edgeBudgetForCurrentFrame()
+  const bestEdgeByNode = new Map()
+  const limit = options.preferComplete
+    ? hierarchyAbsoluteEdgeSafetyCap
+    : edgeBudgetForCurrentFrame()
 
   nodeIds.forEach(nodeId => {
     const candidateEdges = state.visibleEdgeByNode.get(nodeId) ?? []
@@ -836,6 +833,15 @@ const collectVisibleEdgesForNodes = nodeIds => {
 
       seen.add(key)
       candidates.push(edge)
+      const score = edgeRelevanceScore(edge)
+      const currentSource = bestEdgeByNode.get(edge.source)
+      if (!currentSource || score > currentSource.score) {
+        bestEdgeByNode.set(edge.source, { edge, score })
+      }
+      const currentTarget = bestEdgeByNode.get(edge.target)
+      if (!currentTarget || score > currentTarget.score) {
+        bestEdgeByNode.set(edge.target, { edge, score })
+      }
     }
   })
 
@@ -843,7 +849,7 @@ const collectVisibleEdgesForNodes = nodeIds => {
     return candidates
   }
 
-  return candidates
+  const ranked = candidates
     .sort((left, right) => {
       const scoreDelta = edgeRelevanceScore(right) - edgeRelevanceScore(left)
       if (scoreDelta !== 0) {
@@ -853,7 +859,38 @@ const collectVisibleEdgesForNodes = nodeIds => {
       const rightKey = edgeIdentityKey(right)
       return leftKey.localeCompare(rightKey)
     })
-    .slice(0, limit)
+
+  if (options.preferComplete) {
+    return ranked.slice(0, limit)
+  }
+
+  const coverageFloor = Math.min(4_200, Math.max(limit, Math.floor(nodeIds.size * 1.6)))
+  const resolvedLimit = Math.min(coverageFloor, ranked.length)
+  const selected = []
+  const selectedKeys = new Set()
+
+  nodeIds.forEach(nodeId => {
+    const edge = bestEdgeByNode.get(nodeId)?.edge
+    if (!edge) return
+    const key = edgeIdentityKey(edge)
+    if (selectedKeys.has(key)) return
+    selectedKeys.add(key)
+    selected.push(edge)
+  })
+
+  if (selected.length >= resolvedLimit) {
+    return selected.slice(0, resolvedLimit)
+  }
+
+  for (let index = 0; index < ranked.length && selected.length < resolvedLimit; index += 1) {
+    const edge = ranked[index]
+    const key = edgeIdentityKey(edge)
+    if (selectedKeys.has(key)) continue
+    selectedKeys.add(key)
+    selected.push(edge)
+  }
+
+  return selected
 }
 
 const edgeOpacityForScale = (edge, scale) => {
@@ -1119,10 +1156,7 @@ const partitionGraphForAcceleratedRenderer = () => {
 }
 
 const drawGraphLabels = nodes => {
-  const isRenderingHierarchyChildGraph = state.groups.length > 0 && state.renderNodes.some(node => !node.isGroupNode)
-  const shouldDrawLabels = isRenderingHierarchyChildGraph
-    ? false
-    : state.nodes.length > largeGraphNodeThreshold
+  const shouldDrawLabels = state.nodes.length > largeGraphNodeThreshold
     ? state.transform.scale >= 1.25 && state.renderNodes.length <= 420
     : state.transform.scale >= 0.62 && state.renderNodes.length <= 1200
 
@@ -1358,10 +1392,18 @@ const projectNodesIntoChildGraph = (nodes, focusRenderNode, group) => {
 
   const centerX = (minX + maxX) / 2
   const centerY = (minY + maxY) / 2
-  const spanX = Math.max(1, maxX - minX)
-  const spanY = Math.max(1, maxY - minY)
-  const targetDiameter = Math.max(1, childGraphRenderRadius(group) * 2 * 0.9)
-  const scale = targetDiameter / Math.max(spanX, spanY)
+  const maxDistanceFromCenter = nodes.reduce((maxDistance, node) => {
+    const distance = Math.hypot(node.x - centerX, node.y - centerY)
+    return Math.max(maxDistance, distance)
+  }, 1)
+  const subgraphFillByNodeCount = (nodeCount) => {
+    if (nodeCount <= 24) return 0.62
+    if (nodeCount <= 80) return 0.7
+    if (nodeCount <= 200) return 0.78
+    return 0.84
+  }
+  const targetRadius = Math.max(1, childGraphRenderRadius(group) * subgraphFillByNodeCount(nodes.length))
+  const scale = targetRadius / Math.max(maxDistanceFromCenter, 1)
 
   return nodes.map(node => ({
     ...node,
@@ -1715,7 +1757,7 @@ const computeHierarchyRenderVisibility = (viewport) => {
   const childEdges = (isMicroView || revealProgress > 0)
     ? focusChildGroups.length > 0
       ? groupEdgesForRenderedGroups(childNodes)
-      : collectVisibleEdgesForNodes(childIds).map(edge => ({
+      : collectVisibleEdgesForNodes(childIds, { preferComplete: true }).map(edge => ({
         ...edge,
         sourceNode: childById.get(edge.source) ?? edge.sourceNode,
         targetNode: childById.get(edge.target) ?? edge.targetNode
@@ -2138,10 +2180,7 @@ const fitView = (options = { useFiltered: true, preferHubCenter: true }) => {
   const width = Math.max(rect.width, 320)
   const height = Math.max(rect.height, 320)
   const nodes = options.useFiltered ? filteredNodes() : state.nodes
-  const hierarchyFitNodes = state.groups.length > 0 && nodes.length > 1000
-    ? arrangeGraphLevelNodes(parentHierarchyGroups(), groupRenderRadius).map(createGroupRenderNode)
-    : null
-  const fitNodes = hierarchyFitNodes ?? nodes
+  const fitNodes = nodes
   const bounds = graphBounds(fitNodes)
 
   if (!bounds) {
@@ -2169,14 +2208,10 @@ const fitView = (options = { useFiltered: true, preferHubCenter: true }) => {
   const biasedScale = clampScale(fitScale * fitScaleBiasByNodeCount(fitNodes.length))
   const scaleRange = autoFitScaleRangeByNodeCount(fitNodes.length)
   const baselineScale = clampScale(Math.min(scaleRange.max, Math.max(scaleRange.min, biasedScale)))
-  const resolvedScale = nodes.length > massiveGraphNodeThreshold && !hierarchyFitNodes
+  const resolvedScale = nodes.length > massiveGraphNodeThreshold
     ? clampScale(Math.min(baselineScale, massiveAutoFitMacroScale))
     : baselineScale
-  const hubCenter =
-    hierarchyFitNodes
-      ? null
-      :
-    options.preferHubCenter && isDominantHub(state.primaryHub, nodes.length) && nodes.some((node) => node.id === state.primaryHub.id)
+  const hubCenter = options.preferHubCenter && isDominantHub(state.primaryHub, nodes.length) && nodes.some((node) => node.id === state.primaryHub.id)
       ? state.primaryHub
       : null
   const centerX = hubCenter ? hubCenter.x : (bounds.minX + bounds.maxX) / 2
@@ -2740,14 +2775,10 @@ const computeRenderVisibility = () => {
   state.lastViewportKey = viewportKey
   state.renderVisibilityDirty = false
 
-  if (computeHierarchyRenderVisibility(viewport)) {
-    return
-  }
-
   if (state.visibleNodes.length <= 2000) {
     state.renderNodes = state.visibleNodes
     const ids = new Set(state.renderNodes.map((node) => node.id))
-    state.renderEdges = limitRenderEdges(state.renderNodes, collectVisibleEdgesForNodes(ids))
+    state.renderEdges = limitRenderEdges(state.renderNodes, collectVisibleEdgesForNodes(ids, { preferComplete: true }))
     return
   }
 
@@ -2772,12 +2803,17 @@ const computeRenderVisibility = () => {
         : viewportNodes.length > 0
           ? viewportNodes
           : sampleMassiveOverviewNodes(sampleLimit)
-    const carryMargin = Math.max(240, Math.min(1200, 340 / Math.max(state.transform.scale, 0.0001)))
+    const shouldCarryOverNodes = state.transform.scale < 0.18
+    const carryMargin = Math.max(180, Math.min(640, 260 / 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)))
-    const carryOverNodes = (state.renderNodes ?? [])
-      .filter((node) => isNodeInViewport(node, carryViewport))
-      .slice(0, carryOverLimit)
+    const carryOverLimit = shouldCarryOverNodes
+      ? Math.max(80, Math.min(sampleLimit, Math.floor(sampleLimit * 0.24)))
+      : 0
+    const carryOverNodes = shouldCarryOverNodes
+      ? (state.renderNodes ?? [])
+        .filter((node) => isNodeInViewport(node, carryViewport))
+        .slice(0, carryOverLimit)
+      : []
     const sourceWithCarry = mergeUniqueNodes(
       sourceNodes,
       carryOverNodes,
@@ -3276,23 +3312,15 @@ const selectNodeById = id => {
 
 const zoomAtPoint = (screenX, screenY, factor, source = 'generic') => {
   state.lastManualZoomAt = performance.now()
-  const baseScale = state.zoomTransition.active
-    ? state.zoomTransition.targetScale
-    : state.transform.scale
+  const baseScale = state.transform.scale
   const boundedFactor = source === 'wheel'
     ? Math.max(wheelZoomInputFloorCap, Math.min(wheelZoomInputCeilCap, factor))
     : factor
   const nextScale = clampScale(baseScale * boundedFactor)
-  if (nextScale === baseScale && !state.zoomTransition.active) {
+  if (nextScale === baseScale) {
     return
   }
-  const worldPointAtCursor =
-    state.zoomTransition.active &&
-    state.zoomTransition.source === source &&
-    state.zoomTransition.screenX === screenX &&
-    state.zoomTransition.screenY === screenY
-      ? { x: state.zoomTransition.worldX, y: state.zoomTransition.worldY }
-      : resolveZoomAnchorWorldPoint(screenX, screenY)
+  const worldPointAtCursor = resolveZoomAnchorWorldPoint(screenX, screenY)
   const worldX = worldPointAtCursor.x
   const worldY = worldPointAtCursor.y
   state.lastZoomFocus = {
@@ -3300,15 +3328,10 @@ const zoomAtPoint = (screenX, screenY, factor, source = 'generic') => {
     y: worldY,
     at: performance.now()
   }
-  state.zoomTransition = {
-    active: true,
-    source,
-    screenX,
-    screenY,
-    worldX,
-    worldY,
-    targetScale: nextScale
-  }
+  state.transform.scale = nextScale
+  state.transform.x = clampTransformCoordinate(screenX - worldX * nextScale)
+  state.transform.y = clampTransformCoordinate(screenY - worldY * nextScale)
+  clearZoomTransition()
   state.offscreenFrameCount = 0
   markRenderDirty()
 }
@@ -3388,7 +3411,7 @@ const bindEvents = () => {
   if (elements.fit) {
     elements.fit.addEventListener('click', () => {
       resetHierarchyFocus()
-      focusPrimaryHub()
+      fitView({ useFiltered: true, preferHubCenter: false })
     })
   }
   elements.reset.addEventListener('click', () => {
@@ -3477,13 +3500,7 @@ const bindEvents = () => {
     }
     if (!state.pointer.moved) {
       const clickedNode = draggedNode ?? state.hovered
-      if (clickedNode?.isGroupNode) {
-        handleGroupNodePrimaryClick(clickedNode)
-      } else if (clickedNode && state.hierarchyFocusGroupId) {
-        handleLeafNodePrimaryClick(clickedNode)
-      } else {
-        selectNode(clickedNode, { openContent: true })
-      }
+      selectNode(clickedNode, { openContent: true })
     }
     state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
     canvas.releasePointerCapture(event.pointerId)

package/docs/AGENT_USAGE.md

@@ -607,7 +607,7 @@ Without `--vault`, the graph UI serves `$HOME/.brainlink/vault`.
 
 The frontend includes an agent selector that shows only the agent id. Selecting an agent calls the same read APIs with `agent=<agent-id>` and renders that namespace instead of merging every agent into one graph.
 
-Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on empty canvas zooms in at cursor position. Clicking a hierarchy group expands that group from the same world position; clicking the same focused group again opens its details panel. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open in a non-modal side panel (tags, outgoing links, backlinks and Markdown content), so zoom and pan remain available during inspection. Vaults above 1000 notes also expose stable hierarchy groups that fill each visible graph level toward 1000 nodes while keeping every group capped at 1000 child nodes; zoom-out renders the macro level with every aggregated link between visible group nodes, zoom-in grows the focused node into a local child graph anchored at the same point, once the child graph is framed the sibling groups stop rendering, and groups with child groups open another graph level instead of jumping directly to leaf notes.
+Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor and applied immediately without delayed focus interpolation. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on empty canvas zooms in at cursor position. Clicking a node opens its details panel. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open in a non-modal side panel (tags, outgoing links, backlinks and Markdown content), so zoom and pan remain available during inspection. Vaults above 1000 notes keep the same single graph scene and use viewport-driven LOD sampling with edge-coverage safeguards to preserve visible relationships without switching into nested subgraph views.
 During graph filtering, Brainlink keeps hub context nodes visible (`Memory Hub`/`MOC`/high-degree fallback) so filtered views still show relationship anchors.
 
 The command reindexes by default, then serves:

package/package.json

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