@andespindola/brainlink 0.1.0-beta.4 → 0.1.0-beta.40

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

@@ -1,18 +1,36 @@
 export const createClientJs = () => `const canvas = document.getElementById('graph')
 const ctx = canvas.getContext('2d')
+const largeGraphNodeThreshold = 4000
+const largeGraphEdgeRenderLimit = 16000
+const renderNodeBudget = 1800
+const minNodePixelRadius = 1.8
+const viewportPaddingPx = 280
+const worldCoordinateLimit = 5_000_000
+const transformCoordinateLimit = 20_000_000
 const state = {
   graph: { nodes: [], edges: [] },
   nodes: [],
   edges: [],
+  visibleNodes: [],
+  visibleEdges: [],
+  renderNodes: [],
+  renderEdges: [],
+  nodeDegrees: new Map(),
   selected: null,
   hovered: null,
   query: '',
+  contentFilter: { query: '', ids: null, token: 0, timer: null },
   agentId: '',
   agentsSignature: '',
+  nodeDetails: new Map(),
   transform: { x: 0, y: 0, scale: 1 },
   pointer: { x: 0, y: 0, down: false, dragNode: null, moved: false },
+  cursor: { x: 0, y: 0, inCanvas: false },
   graphSignature: '',
-  last: performance.now()
+  graphStatus: '',
+  last: performance.now(),
+  offscreenFrameCount: 0,
+  recoveringViewport: false
 }
 
 const byId = id => document.getElementById(id)
@@ -23,25 +41,39 @@ const escapeHtml = value => String(value)
   .replaceAll('"', '"')
   .replaceAll("'", ''')
 const elements = {
-  stats: byId('stats'),
   search: byId('search'),
   agent: byId('agent'),
-  title: byId('title'),
-  path: byId('path'),
-  tags: byId('tags'),
-  notes: byId('notes'),
-  content: byId('content'),
-  outgoing: byId('outgoing'),
-  incoming: byId('incoming'),
   nodeCount: byId('nodeCount'),
   edgeCount: byId('edgeCount'),
   tagCount: byId('tagCount'),
   zoomIn: byId('zoomIn'),
   zoomOut: byId('zoomOut'),
-  reset: byId('reset')
+  fit: byId('fit'),
+  reset: byId('reset'),
+  contentDialog: byId('contentDialog'),
+  contentTitle: byId('contentTitle'),
+  contentPath: byId('contentPath'),
+  contentTags: byId('contentTags'),
+  contentOutgoing: byId('contentOutgoing'),
+  contentIncoming: byId('contentIncoming'),
+  contentBody: byId('contentBody'),
+  contentClose: byId('contentClose')
 }
 
-const agentQuery = () => state.agentId ? '?agent=' + encodeURIComponent(state.agentId) : ''
+const zoomRange = {
+  min: 0.05,
+  max: 4.5
+}
+
+const agentQuery = (separator = '?') => state.agentId ? separator + 'agent=' + encodeURIComponent(state.agentId) : ''
+
+const setGraphStatus = text => {
+  state.graphStatus = text
+}
+
+const handleGraphRefreshError = error => {
+  console.error(error)
+}
 
 const graphTheme = {
   node: '#aeb8c5',
@@ -66,35 +98,178 @@ const resize = () => {
   ctx.setTransform(ratio, 0, 0, ratio, 0, 0)
 }
 
-const filteredNodes = () => {
-  const query = state.query.trim().toLowerCase()
-  if (!query) return state.nodes
-  return state.nodes.filter(node =>
+const normalizeQuery = value => value.trim().toLowerCase()
+const hubNodeRetentionLimit = 2
+const hubNodePattern = /\b(memory\s*hub|knowledge\s*hub|hub|moc|map|memory\s*map|mapa)\b/i
+
+const localFilteredNodes = query =>
+  state.nodes.filter(node =>
     node.title.toLowerCase().includes(query) ||
     node.path.toLowerCase().includes(query) ||
     node.tags.some(tag => tag.toLowerCase().includes(query))
   )
+
+const rankedHubNodes = () => {
+  if (state.nodes.length === 0) {
+    return []
+  }
+
+  const byTitleAndDegree = [...state.nodes]
+    .filter(node => hubNodePattern.test(node.title) || hubNodePattern.test(node.path) || node.tags.some(tag => hubNodePattern.test(tag)))
+    .sort((left, right) => {
+      const byDegree = (state.nodeDegrees.get(right.id) ?? 0) - (state.nodeDegrees.get(left.id) ?? 0)
+      if (byDegree !== 0) return byDegree
+      return left.title.localeCompare(right.title)
+    })
+
+  if (byTitleAndDegree.length > 0) {
+    return byTitleAndDegree.slice(0, hubNodeRetentionLimit)
+  }
+
+  return [...state.nodes]
+    .sort((left, right) => {
+      const byDegree = (state.nodeDegrees.get(right.id) ?? 0) - (state.nodeDegrees.get(left.id) ?? 0)
+      if (byDegree !== 0) return byDegree
+      return left.title.localeCompare(right.title)
+    })
+    .slice(0, 1)
+}
+
+const withPersistentHubNodes = nodes => {
+  if (nodes.length === 0) {
+    return rankedHubNodes()
+  }
+
+  const ids = new Set(nodes.map(node => node.id))
+  const hubsToKeep = rankedHubNodes().filter(node => !ids.has(node.id))
+  return nodes.concat(hubsToKeep)
+}
+
+const filteredNodes = () => {
+  const query = normalizeQuery(state.query)
+  if (!query) return state.nodes
+  if (state.contentFilter.query === query && state.contentFilter.ids instanceof Set) {
+    const matched = state.nodes.filter(node => state.contentFilter.ids.has(node.id))
+    return withPersistentHubNodes(matched)
+  }
+
+  return withPersistentHubNodes(localFilteredNodes(query))
 }
 
-const visibleIds = () => new Set(filteredNodes().map(node => node.id))
+const recomputeVisibility = () => {
+  const nodes = filteredNodes()
+  const ids = new Set(nodes.map(node => node.id))
+  const edges = state.edges.filter(edge => ids.has(edge.source) && edge.target && ids.has(edge.target))
+  const limitedEdges = state.nodes.length > largeGraphNodeThreshold
+    ? [...edges]
+      .sort((left, right) => edgeWeight(right) - edgeWeight(left))
+      .slice(0, largeGraphEdgeRenderLimit)
+    : edges
 
-const visibleEdges = () => {
-  const ids = visibleIds()
-  return state.edges.filter(edge => ids.has(edge.source) && edge.target && ids.has(edge.target))
+  state.visibleNodes = nodes
+  state.visibleEdges = limitedEdges
 }
 
 const edgeWeight = edge => Number.isFinite(edge.weight) ? Math.max(1, edge.weight) : 1
 
-const resetView = () => {
+const clampScale = value => Math.max(zoomRange.min, Math.min(zoomRange.max, value))
+const isFiniteNumber = value => Number.isFinite(value)
+const isReasonableCoordinate = value => isFiniteNumber(value) && Math.abs(value) <= worldCoordinateLimit
+
+const graphBounds = nodes => {
+  if (nodes.length === 0) return null
+  let minX = Number.POSITIVE_INFINITY
+  let maxX = Number.NEGATIVE_INFINITY
+  let minY = Number.POSITIVE_INFINITY
+  let maxY = Number.NEGATIVE_INFINITY
+
+  nodes.forEach(node => {
+    const radius = baseNodeRadius(node)
+    minX = Math.min(minX, node.x - radius)
+    maxX = Math.max(maxX, node.x + radius)
+    minY = Math.min(minY, node.y - radius)
+    maxY = Math.max(maxY, node.y + radius)
+  })
+
+  return {
+    minX,
+    maxX,
+    minY,
+    maxY,
+    width: Math.max(maxX - minX, 1),
+    height: Math.max(maxY - minY, 1)
+  }
+}
+
+const fitScaleBiasByNodeCount = nodeCount => {
+  if (nodeCount <= 6) return 1.22
+  if (nodeCount <= 20) return 1.12
+  if (nodeCount <= 60) return 1.04
+  if (nodeCount <= 180) return 1
+  if (nodeCount <= 600) return 0.94
+  if (nodeCount <= 2000) return 0.82
+  if (nodeCount <= 6000) return 0.68
+  return 0.56
+}
+
+const autoFitScaleRangeByNodeCount = nodeCount => {
+  if (nodeCount <= 6) return { min: 0.4, max: 2.2 }
+  if (nodeCount <= 20) return { min: 0.34, max: 1.65 }
+  if (nodeCount <= 60) return { min: 0.25, max: 1.22 }
+  if (nodeCount <= 180) return { min: 0.18, max: 0.92 }
+  if (nodeCount <= 600) return { min: 0.12, max: 0.72 }
+  if (nodeCount <= 2000) return { min: 0.08, max: 0.52 }
+  if (nodeCount <= 6000) return { min: 0.06, max: 0.32 }
+  return { min: zoomRange.min, max: 0.24 }
+}
+
+const fitView = (options = { useFiltered: true }) => {
   const rect = canvas.getBoundingClientRect()
-  state.transform = { x: Math.max(rect.width, 320) / 2, y: Math.max(rect.height, 320) / 2, scale: 1 }
+  const width = Math.max(rect.width, 320)
+  const height = Math.max(rect.height, 320)
+  const nodes = options.useFiltered ? filteredNodes() : state.nodes
+  const bounds = graphBounds(nodes)
+
+  if (!bounds) {
+    state.transform = { x: width / 2, y: height / 2, scale: 1 }
+    return
+  }
+
+  const paddingByNodeCount = nodeCount => {
+    if (nodeCount <= 6) return 28
+    if (nodeCount <= 20) return 44
+    if (nodeCount <= 60) return 68
+    if (nodeCount <= 180) return 86
+    if (nodeCount <= 600) return 110
+    if (nodeCount <= 2000) return 140
+    return 180
+  }
+  const padding = paddingByNodeCount(nodes.length)
+  const scaleX = width / (bounds.width + padding * 2)
+  const scaleY = height / (bounds.height + padding * 2)
+  const fitScale = Math.min(scaleX, scaleY)
+  const biasedScale = clampScale(fitScale * fitScaleBiasByNodeCount(nodes.length))
+  const scaleRange = autoFitScaleRangeByNodeCount(nodes.length)
+  const scale = clampScale(Math.min(scaleRange.max, Math.max(scaleRange.min, biasedScale)))
+  const centerX = (bounds.minX + bounds.maxX) / 2
+  const centerY = (bounds.minY + bounds.maxY) / 2
+
+  state.transform = {
+    x: width / 2 - centerX * scale,
+    y: height / 2 - centerY * scale,
+    scale
+  }
 }
 
+const resetView = () => fitView({ useFiltered: false })
+
 const createLayout = graph => {
   const nodes = graph.nodes.map(node => ({
     ...node,
     x: Number.isFinite(node.x) ? node.x : 0,
-    y: Number.isFinite(node.y) ? node.y : 0
+    y: Number.isFinite(node.y) ? node.y : 0,
+    vx: Number.isFinite(node.vx) ? node.vx : 0,
+    vy: Number.isFinite(node.vy) ? node.vy : 0
   }))
   const nodeMap = new Map(nodes.map(node => [node.id, node]))
   const edges = graph.edges
@@ -111,29 +286,94 @@ const encodeEntityTag = (value) => {
     binary += String.fromCharCode(utf8[index])
   }
 
-  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '')
+  return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/g, '')
 }
 
 const graphSignature = graph => JSON.stringify({
-  nodes: graph.nodes.map(node => [node.id, node.title, node.path, node.content, node.tags]),
+  nodes: graph.nodes.map(node => [node.id, node.title, node.path, node.tags]),
   edges: graph.edges.map(edge => [edge.source, edge.target, edge.targetTitle, edge.weight, edge.priority])
 })
 
+const resetContentFilter = () => {
+  if (state.contentFilter.timer) {
+    clearTimeout(state.contentFilter.timer)
+  }
+  state.contentFilter = {
+    query: '',
+    ids: null,
+    token: state.contentFilter.token + 1,
+    timer: null
+  }
+  recomputeVisibility()
+}
+
+const syncContentFilter = async (query, token) => {
+  const response = await fetch(
+      '/api/graph-filter?q=' +
+      encodeURIComponent(query) +
+      '&limit=' +
+      encodeURIComponent(String(Math.max(state.nodes.length, 1))) +
+      agentQuery('&')
+  )
+
+  if (!response.ok || token !== state.contentFilter.token) {
+    return
+  }
+
+  const payload = await response.json()
+  const nodeIds = Array.isArray(payload?.nodeIds) ? payload.nodeIds.filter(id => typeof id === 'string') : []
+  if (token !== state.contentFilter.token) {
+    return
+  }
+
+  state.contentFilter.query = query
+  state.contentFilter.ids = new Set(nodeIds)
+  recomputeVisibility()
+}
+
+const scheduleContentFilterSync = () => {
+  const query = normalizeQuery(state.query)
+  if (!query) {
+    resetContentFilter()
+    return
+  }
+
+  if (state.contentFilter.timer) {
+    clearTimeout(state.contentFilter.timer)
+  }
+
+  const token = state.contentFilter.token + 1
+  state.contentFilter = {
+    query: state.contentFilter.query,
+    ids: state.contentFilter.ids,
+    token,
+    timer: setTimeout(() => {
+      syncContentFilter(query, token).catch(() => {})
+    }, 180)
+  }
+}
+
 const tick = delta => {
-  const nodes = filteredNodes()
-  const ids = new Set(nodes.map(node => node.id))
-  const edges = state.edges.filter(edge => ids.has(edge.source) && edge.target && ids.has(edge.target))
+  const nodes = state.renderNodes.length > 0 ? state.renderNodes : state.visibleNodes
+  const edges = state.renderEdges.length > 0 ? state.renderEdges : state.visibleEdges
+  if (nodes.length > 1200) {
+    return
+  }
   const strength = Math.min(delta / 16, 2)
 
   edges.forEach(edge => {
     const source = edge.sourceNode
     const target = edge.targetNode
+    source.vx = Number.isFinite(source.vx) ? source.vx : 0
+    source.vy = Number.isFinite(source.vy) ? source.vy : 0
+    target.vx = Number.isFinite(target.vx) ? target.vx : 0
+    target.vy = Number.isFinite(target.vy) ? target.vy : 0
     const dx = target.x - source.x
     const dy = target.y - source.y
     const distance = Math.max(Math.hypot(dx, dy), 1)
     const force = (distance - 150) * 0.002 * strength
-    const fx = dx * force
-    const fy = dy * force
+    const fx = (dx / distance) * force
+    const fy = (dy / distance) * force
     source.vx += fx
     source.vy += fy
     target.vx -= fx
@@ -144,6 +384,10 @@ const tick = delta => {
     for (let j = i + 1; j < nodes.length; j += 1) {
       const a = nodes[i]
       const b = nodes[j]
+      a.vx = Number.isFinite(a.vx) ? a.vx : 0
+      a.vy = Number.isFinite(a.vy) ? a.vy : 0
+      b.vx = Number.isFinite(b.vx) ? b.vx : 0
+      b.vy = Number.isFinite(b.vy) ? b.vy : 0
       const dx = b.x - a.x
       const dy = b.y - a.y
       const distance = Math.max(Math.hypot(dx, dy), 1)
@@ -158,6 +402,10 @@ const tick = delta => {
   }
 
   nodes.forEach(node => {
+    node.vx = Number.isFinite(node.vx) ? node.vx : 0
+    node.vy = Number.isFinite(node.vy) ? node.vy : 0
+    node.x = Number.isFinite(node.x) ? node.x : 0
+    node.y = Number.isFinite(node.y) ? node.y : 0
     if (state.pointer.dragNode === node) {
       node.vx = 0
       node.vy = 0
@@ -181,7 +429,11 @@ const worldPoint = event => {
 }
 
 const hitNode = point => {
-  const nodes = filteredNodes()
+  if (state.nodes.length > largeGraphNodeThreshold && state.transform.scale < 0.55) {
+    return null
+  }
+
+  const nodes = state.renderNodes
   for (let index = nodes.length - 1; index >= 0; index -= 1) {
     const node = nodes[index]
     const radius = nodeRadius(node)
@@ -190,17 +442,159 @@ const hitNode = point => {
   return null
 }
 
-const nodeRadius = node => {
-  const degree = state.edges.filter(edge => edge.source === node.id || edge.target === node.id).length
+const baseNodeRadius = node => {
+  const degree = state.nodeDegrees.get(node.id) ?? 0
   return 9 + Math.min(degree, 8) * 1.6
 }
 
+const nodeRadius = node => Math.max(baseNodeRadius(node), minNodePixelRadius / Math.max(state.transform.scale, 0.0001))
+
+const worldViewportBounds = () => {
+  const rect = canvas.getBoundingClientRect()
+  const width = Math.max(rect.width, 320)
+  const height = Math.max(rect.height, 320)
+  const padding = viewportPaddingPx
+
+  return {
+    minX: (-state.transform.x - padding) / state.transform.scale,
+    maxX: (width - state.transform.x + padding) / state.transform.scale,
+    minY: (-state.transform.y - padding) / state.transform.scale,
+    maxY: (height - state.transform.y + padding) / state.transform.scale
+  }
+}
+
+const isNodeInViewport = (node, viewport) =>
+  node.x >= viewport.minX &&
+  node.x <= viewport.maxX &&
+  node.y >= viewport.minY &&
+  node.y <= viewport.maxY
+
+const viewportNodeStride = () => {
+  if (state.nodes.length <= largeGraphNodeThreshold) {
+    return 1
+  }
+
+  if (state.transform.scale >= 0.95) {
+    return 1
+  }
+  if (state.transform.scale >= 0.7) {
+    return 2
+  }
+  if (state.transform.scale >= 0.48) {
+    return 3
+  }
+  if (state.transform.scale >= 0.28) {
+    return 5
+  }
+
+  return 8
+}
+
+const computeRenderVisibility = () => {
+  if (state.visibleNodes.length <= 2000) {
+    state.renderNodes = state.visibleNodes
+    const ids = new Set(state.renderNodes.map((node) => node.id))
+    state.renderEdges = state.visibleEdges.filter((edge) => ids.has(edge.source) && edge.target && ids.has(edge.target))
+    return
+  }
+
+  const viewport = worldViewportBounds()
+  const stride = viewportNodeStride()
+  const picked = []
+
+  for (let index = 0; index < state.visibleNodes.length; index += 1) {
+    const node = state.visibleNodes[index]
+    if (!isNodeInViewport(node, viewport)) {
+      continue
+    }
+
+    const isPriority =
+      node.id === state.selected?.id ||
+      node.id === state.hovered?.id ||
+      node.id === state.pointer.dragNode?.id
+    if (isPriority || index % stride === 0) {
+      picked.push(node)
+    }
+  }
+
+  const nodes = picked.length > renderNodeBudget
+    ? picked.slice(0, renderNodeBudget)
+    : picked
+  if (nodes.length === 0 && state.visibleNodes.length > 0) {
+    const centerX = (viewport.minX + viewport.maxX) / 2
+    const centerY = (viewport.minY + viewport.maxY) / 2
+    const closest = [...state.visibleNodes]
+      .sort((left, right) => {
+        const leftDistance = (left.x - centerX) ** 2 + (left.y - centerY) ** 2
+        const rightDistance = (right.x - centerX) ** 2 + (right.y - centerY) ** 2
+        return leftDistance - rightDistance
+      })
+      .slice(0, Math.min(renderNodeBudget, 180))
+    const closestIds = new Set(closest.map((node) => node.id))
+
+    state.renderNodes = closest
+    state.renderEdges = state.visibleEdges.filter(
+      (edge) => closestIds.has(edge.source) && edge.target && closestIds.has(edge.target)
+    )
+    return
+  }
+
+  const nodeIds = new Set(nodes.map((node) => node.id))
+  const edges = state.visibleEdges.filter((edge) => nodeIds.has(edge.source) && edge.target && nodeIds.has(edge.target))
+
+  state.renderNodes = nodes
+  state.renderEdges = edges
+}
+
+const isNodeVisibleOnScreen = (node, width, height) => {
+  const radius = nodeRadius(node) * state.transform.scale
+  const screenX = node.x * state.transform.scale + state.transform.x
+  const screenY = node.y * state.transform.scale + state.transform.y
+
+  return (
+    screenX + radius >= 0 &&
+    screenX - radius <= width &&
+    screenY + radius >= 0 &&
+    screenY - radius <= height
+  )
+}
+
+const hasValidTransform = () =>
+  isFiniteNumber(state.transform.x) &&
+  isFiniteNumber(state.transform.y) &&
+  isFiniteNumber(state.transform.scale) &&
+  Math.abs(state.transform.x) <= transformCoordinateLimit &&
+  Math.abs(state.transform.y) <= transformCoordinateLimit &&
+  state.transform.scale > 0
+
+const sanitizeNodePosition = node => {
+  if (!isReasonableCoordinate(node.x)) node.x = 0
+  if (!isReasonableCoordinate(node.y)) node.y = 0
+  if (!isFiniteNumber(node.vx) || Math.abs(node.vx) > worldCoordinateLimit) node.vx = 0
+  if (!isFiniteNumber(node.vy) || Math.abs(node.vy) > worldCoordinateLimit) node.vy = 0
+}
+
+const sanitizeGraphState = () => {
+  state.nodes.forEach(sanitizeNodePosition)
+  state.visibleNodes.forEach(sanitizeNodePosition)
+  state.renderNodes.forEach(sanitizeNodePosition)
+}
+
 const render = now => {
   const delta = now - state.last
   state.last = now
+  const minFrameIntervalMs = state.nodes.length > largeGraphNodeThreshold ? 48 : 16
+  if (delta < minFrameIntervalMs) {
+    requestAnimationFrame(render)
+    return
+  }
   const rect = canvas.getBoundingClientRect()
   const width = Math.max(rect.width, 320)
   const height = Math.max(rect.height, 320)
+  sanitizeGraphState()
+  if (!hasValidTransform()) {
+    resetView()
+  }
   ctx.clearRect(0, 0, width, height)
   if (state.nodes.length === 0) {
     ctx.fillStyle = '#99a5b5'
@@ -214,7 +608,25 @@ const render = now => {
   ctx.translate(state.transform.x, state.transform.y)
   ctx.scale(state.transform.scale, state.transform.scale)
 
-  visibleEdges().forEach(edge => {
+  computeRenderVisibility()
+  tick(delta)
+  const hasVisibleNodeOnScreen = state.renderNodes.some((node) => isNodeVisibleOnScreen(node, width, height))
+  if (!hasVisibleNodeOnScreen && state.renderNodes.length > 0) {
+    state.offscreenFrameCount += 1
+    if (state.offscreenFrameCount >= 6 && !state.recoveringViewport) {
+      state.recoveringViewport = true
+      fitView({ useFiltered: true })
+      state.offscreenFrameCount = 0
+      requestAnimationFrame(() => {
+        state.recoveringViewport = false
+      })
+    }
+  } else {
+    state.offscreenFrameCount = 0
+  }
+  const drawEdges = !(state.nodes.length > largeGraphNodeThreshold && state.transform.scale < 0.22)
+  if (drawEdges) {
+    state.renderEdges.forEach(edge => {
     const selectedEdge = state.selected && (edge.source === state.selected.id || edge.target === state.selected.id)
     ctx.beginPath()
     ctx.moveTo(edge.sourceNode.x, edge.sourceNode.y)
@@ -222,9 +634,10 @@ const render = now => {
     ctx.strokeStyle = selectedEdge ? graphTheme.edgeActive : graphTheme.edge
     ctx.lineWidth = (selectedEdge ? 1.8 : 1) + Math.min(edgeWeight(edge) - 1, 8) * 0.22
     ctx.stroke()
-  })
+    })
+  }
 
-  filteredNodes().forEach(node => {
+  state.renderNodes.forEach(node => {
     const radius = nodeRadius(node)
     const isSelected = state.selected?.id === node.id
     const isHovered = state.hovered?.id === node.id
@@ -240,7 +653,11 @@ const render = now => {
     ctx.strokeStyle = isSelected ? graphTheme.nodeStrokeActive : graphTheme.nodeStroke
     ctx.stroke()
 
-    if (isSelected || isHovered || state.transform.scale > 1.18 || state.nodes.length <= 25) {
+    const shouldDrawLabels =
+      isSelected ||
+      isHovered ||
+      (state.nodes.length <= largeGraphNodeThreshold && (state.transform.scale > 1.18 || state.nodes.length <= 25))
+    if (shouldDrawLabels) {
       ctx.fillStyle = graphTheme.label
       ctx.font = '12px Inter, system-ui, sans-serif'
       ctx.textAlign = 'center'
@@ -250,6 +667,12 @@ const render = now => {
   })
 
   ctx.restore()
+  if (state.renderNodes.length === 0) {
+    ctx.fillStyle = '#99a5b5'
+    ctx.font = '12px Inter, system-ui, sans-serif'
+    ctx.textAlign = 'center'
+    ctx.fillText('Move or zoom to reveal nearby notes', width / 2, height / 2)
+  }
   requestAnimationFrame(render)
 }
 
@@ -257,22 +680,7 @@ const list = items => items.length
   ? items.map(item => '<li>' + (item.id ? '<button type="button" data-node-id="' + escapeHtml(item.id) + '">' + escapeHtml(item.title) + '</button>' : escapeHtml(item.title)) + '<small>' + escapeHtml(item.path) + (item.weight ? ' · weight ' + escapeHtml(item.weight) + ' · ' + escapeHtml(item.priority || 'normal') : '') + '</small></li>').join('')
   : '<li><small>No links found.</small></li>'
 
-const allNotesList = () => state.nodes.length
-  ? state.nodes.map(node => '<li><button type="button" data-node-id="' + escapeHtml(node.id) + '">' + escapeHtml(node.title) + '</button><small>' + escapeHtml(node.path) + '</small></li>').join('')
-  : '<li><small>No notes indexed.</small></li>'
-
-const selectNode = node => {
-  state.selected = node
-  if (!node) {
-    elements.title.textContent = 'Graph Overview'
-    elements.path.textContent = state.nodes.length + ' notes and ' + state.graph.edges.length + ' links indexed.'
-    elements.tags.innerHTML = ''
-    elements.notes.innerHTML = allNotesList()
-    elements.content.textContent = 'Selecione uma nota no grafo ou na lista para ver o Markdown completo, backlinks e links de saida.'
-    elements.outgoing.innerHTML = '<li><small>Select a note to inspect outgoing links.</small></li>'
-    elements.incoming.innerHTML = '<li><small>Select a note to inspect backlinks.</small></li>'
-    return
-  }
+const linkedNodes = node => {
   const nodeById = new Map(state.nodes.map(item => [item.id, item]))
   const withEdgeMeta = (linkedNode, edge) => linkedNode ? {
     ...linkedNode,
@@ -288,57 +696,172 @@ const selectNode = node => {
     .map(edge => withEdgeMeta(nodeById.get(edge.source), edge))
     .filter(Boolean)
 
-  elements.title.textContent = node.title
-  elements.path.textContent = node.path
-  elements.tags.innerHTML = node.tags.length
+  return { outgoing, incoming }
+}
+
+const fetchNodeDetails = async node => {
+  const cached = state.nodeDetails.get(node.id)
+  if (cached) {
+    return cached
+  }
+
+  const response = await fetch('/api/graph-node?id=' + encodeURIComponent(node.id) + agentQuery('&'))
+  if (!response.ok) {
+    throw new Error('Failed to load graph node details')
+  }
+
+  const payload = await response.json()
+  const detail = payload?.node
+  if (!detail || !detail.id) {
+    throw new Error('Invalid graph node payload')
+  }
+  state.nodeDetails.set(detail.id, detail)
+  return detail
+}
+
+const openContentDialog = async node => {
+  if (!node) return
+  const { outgoing, incoming } = linkedNodes(node)
+  elements.contentTitle.textContent = node.title
+  elements.contentPath.textContent = node.path
+  elements.contentTags.innerHTML = node.tags.length
     ? node.tags.map(tag => '<span>#' + escapeHtml(tag) + '</span>').join('')
     : '<span>No tags</span>'
-  elements.notes.innerHTML = allNotesList()
-  elements.content.textContent = node.content
-  elements.outgoing.innerHTML = list(outgoing)
-  elements.incoming.innerHTML = list(incoming)
+  elements.contentOutgoing.innerHTML = list(outgoing)
+  elements.contentIncoming.innerHTML = list(incoming)
+  elements.contentBody.textContent = 'Loading note content...'
+  if (!elements.contentDialog.open) {
+    elements.contentDialog.showModal()
+  }
+
+  try {
+    const detailedNode = await fetchNodeDetails(node)
+    if (state.selected?.id !== node.id) {
+      return
+    }
+    elements.contentBody.textContent = detailedNode.content
+  } catch {
+    elements.contentBody.textContent = 'Unable to load note content.'
+  }
+}
+
+const selectNode = (node, options = { openContent: false }) => {
+  state.selected = node
+  if (node && options.openContent) {
+    openContentDialog(node).catch(() => {
+      elements.contentBody.textContent = 'Unable to load note content.'
+    })
+  }
 }
 
 const selectNodeById = id => {
   const node = state.nodes.find(item => item.id === id)
-  if (node) selectNode(node)
+  if (node) selectNode(node, { openContent: true })
+}
+
+const zoomAtPoint = (screenX, screenY, factor) => {
+  const nextScale = clampScale(state.transform.scale * factor)
+  if (nextScale === state.transform.scale) return
+  const worldX = (screenX - state.transform.x) / state.transform.scale
+  const worldY = (screenY - state.transform.y) / state.transform.scale
+  state.transform.scale = nextScale
+  state.transform.x = screenX - worldX * nextScale
+  state.transform.y = screenY - worldY * nextScale
 }
 
-const zoom = factor => {
-  state.transform.scale = Math.max(0.25, Math.min(3.5, state.transform.scale * factor))
+const wheelZoomFactor = event => {
+  const isModifierZoom = event.metaKey || event.ctrlKey
+  const deltaModeFactor = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? 120 : 1
+  const absoluteDelta = Math.min(Math.abs(event.deltaY * deltaModeFactor), 1600)
+
+  if (absoluteDelta <= 0.0001) {
+    return 1
+  }
+
+  const baseStep = Math.max(0.06, Math.min(0.45, absoluteDelta / 480))
+  const adjustedStep = baseStep * (isModifierZoom ? 1.4 : 1)
+
+  return event.deltaY < 0 ? 1 + adjustedStep : 1 / (1 + adjustedStep)
+}
+
+const isScreenPointInsideCanvas = (screenX, screenY) => {
+  const rect = canvas.getBoundingClientRect()
+
+  return screenX >= rect.left && screenX <= rect.right && screenY >= rect.top && screenY <= rect.bottom
+}
+
+const handleWheelZoom = event => {
+  if (elements.contentDialog?.open) {
+    return
+  }
+
+  if (!isScreenPointInsideCanvas(event.clientX, event.clientY)) {
+    return
+  }
+
+  event.preventDefault()
+  const rect = canvas.getBoundingClientRect()
+  const cursorX = event.clientX - rect.left
+  const cursorY = event.clientY - rect.top
+  const factor = wheelZoomFactor(event)
+
+  if (!Number.isFinite(factor) || factor <= 0 || factor === 1) {
+    return
+  }
+
+  zoomAtPoint(cursorX, cursorY, factor)
 }
 
 const bindEvents = () => {
   window.addEventListener('resize', resize)
   elements.search.addEventListener('input', event => {
     state.query = event.target.value
-    elements.stats.textContent = state.query
-      ? filteredNodes().length + ' filtered notes'
-      : state.nodes.length + ' notes · ' + state.edges.length + ' links'
+    recomputeVisibility()
+    scheduleContentFilterSync()
   })
   elements.agent.addEventListener('change', event => {
     state.agentId = event.target.value
     state.selected = null
+    state.nodeDetails = new Map()
+    resetContentFilter()
+    recomputeVisibility()
+    scheduleContentFilterSync()
     loadGraph({ reset: true }).catch(error => {
-      elements.stats.textContent = 'Failed to load agent graph'
       console.error(error)
     })
   })
-  elements.zoomIn.addEventListener('click', () => zoom(1.18))
-  elements.zoomOut.addEventListener('click', () => zoom(0.84))
-  elements.reset.addEventListener('click', resetView)
-  ;[elements.notes, elements.outgoing, elements.incoming].forEach(element => {
-    element.addEventListener('click', event => {
-      const target = event.target
-      if (!(target instanceof HTMLElement)) return
-      const nodeId = target.dataset.nodeId
-      if (nodeId) selectNodeById(nodeId)
+  elements.zoomIn.addEventListener('click', () => {
+    const rect = canvas.getBoundingClientRect()
+    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.3)
+  })
+  elements.zoomOut.addEventListener('click', () => {
+    const rect = canvas.getBoundingClientRect()
+    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.77)
+  })
+  if (elements.fit) {
+    elements.fit.addEventListener('click', () => {
+      fitView({ useFiltered: true })
     })
+  }
+  elements.reset.addEventListener('click', () => {
+    resetView()
+  })
+  elements.contentClose.addEventListener('click', () => elements.contentDialog.close())
+  elements.contentDialog.addEventListener('click', event => {
+    const target = event.target
+    if (target instanceof HTMLElement && target.dataset.nodeId) {
+      selectNodeById(target.dataset.nodeId)
+      return
+    }
+    if (event.target === elements.contentDialog) elements.contentDialog.close()
+  })
+  window.addEventListener('wheel', handleWheelZoom, { passive: false })
+  canvas.addEventListener('dblclick', event => {
+    const rect = canvas.getBoundingClientRect()
+    const cursorX = event.clientX - rect.left
+    const cursorY = event.clientY - rect.top
+    zoomAtPoint(cursorX, cursorY, 1.25)
   })
-  canvas.addEventListener('wheel', event => {
-    event.preventDefault()
-    zoom(event.deltaY < 0 ? 1.08 : 0.92)
-  }, { passive: false })
   canvas.addEventListener('pointerdown', event => {
     const point = worldPoint(event)
     const node = hitNode(point)
@@ -352,6 +875,7 @@ const bindEvents = () => {
   canvas.addEventListener('pointermove', event => {
     const point = worldPoint(event)
     state.hovered = hitNode(point)
+    state.cursor = { x: event.clientX, y: event.clientY, inCanvas: true }
     if (!state.pointer.down) return
     const dx = event.clientX - state.pointer.x
     const dy = event.clientY - state.pointer.y
@@ -367,11 +891,40 @@ const bindEvents = () => {
     state.transform.y += dy
   })
   canvas.addEventListener('pointerup', event => {
-    if (state.pointer.dragNode && !state.pointer.moved) selectNode(state.pointer.dragNode)
-    if (!state.pointer.dragNode && !state.pointer.moved) selectNode(state.hovered)
+    if (state.pointer.dragNode && !state.pointer.moved) selectNode(state.pointer.dragNode, { openContent: true })
+    if (!state.pointer.dragNode && !state.pointer.moved) selectNode(state.hovered, { openContent: true })
     state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
     canvas.releasePointerCapture(event.pointerId)
   })
+  canvas.addEventListener('pointercancel', () => {
+    state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
+  })
+  canvas.addEventListener('pointerenter', event => {
+    state.cursor = { x: event.clientX, y: event.clientY, inCanvas: true }
+  })
+  canvas.addEventListener('pointerleave', event => {
+    state.cursor = { x: event.clientX, y: event.clientY, inCanvas: false }
+  })
+  window.addEventListener('keydown', event => {
+    if (event.key === '+' || event.key === '=') {
+      event.preventDefault()
+      const rect = canvas.getBoundingClientRect()
+      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.25)
+      return
+    }
+
+    if (event.key === '-' || event.key === '_') {
+      event.preventDefault()
+      const rect = canvas.getBoundingClientRect()
+      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.8)
+      return
+    }
+
+    if (event.key === '0') {
+      event.preventDefault()
+      resetView()
+    }
+  })
 }
 
 const loadAgents = async () => {
@@ -386,9 +939,10 @@ const loadAgents = async () => {
 
   state.agentId = selected
   if (signature !== state.agentsSignature) {
+    const formatAgentLabel = (agent) => agent.id
     elements.agent.innerHTML = agents.length
-      ? agents.map(agent => '<option value="' + escapeHtml(agent.id) + '">' + escapeHtml(agent.id) + ' · ' + agent.documentCount + '</option>').join('')
-      : '<option value="shared">shared · 0</option>'
+      ? agents.map(agent => '<option value="' + escapeHtml(agent.id) + '">' + escapeHtml(formatAgentLabel(agent)) + '</option>').join('')
+      : '<option value="shared">shared</option>'
     state.agentsSignature = signature
   }
   elements.agent.value = selected
@@ -417,14 +971,29 @@ const loadGraph = async (options = { reset: false }) => {
   state.graph = graph
   state.nodes = layout.nodes
   state.edges = layout.edges
+  state.nodeDegrees = state.edges.reduce((degrees, edge) => {
+    degrees.set(edge.source, (degrees.get(edge.source) ?? 0) + edgeWeight(edge))
+    if (edge.target) {
+      degrees.set(edge.target, (degrees.get(edge.target) ?? 0) + edgeWeight(edge))
+    }
+    return degrees
+  }, new Map())
+  state.nodeDetails = new Map()
+  resetContentFilter()
+  recomputeVisibility()
+  scheduleContentFilterSync()
   const tags = new Set(graph.nodes.flatMap(node => node.tags))
-  elements.stats.textContent = state.agentId + ' · ' + graph.nodes.length + ' notes · ' + graph.edges.length + ' links · live'
+  setGraphStatus(state.agentId + ' · ' + graph.nodes.length + ' notes · ' + graph.edges.length + ' links · live')
   elements.nodeCount.textContent = graph.nodes.length
   elements.edgeCount.textContent = graph.edges.length
   elements.tagCount.textContent = tags.size
   resize()
   if (options.reset) resetView()
-  selectNode(state.nodes.find(node => node.id === selectedId) ?? null)
+  const selectedNode = state.nodes.find(node => node.id === selectedId) ?? null
+  selectNode(selectedNode, { openContent: Boolean(selectedNode && elements.contentDialog.open) })
+  if (!selectedNode && elements.contentDialog.open) {
+    elements.contentDialog.close()
+  }
 }
 
 bindEvents()
@@ -441,10 +1010,7 @@ const refreshGraphLoop = () => {
     return
   }
 
-  loadGraph().catch((error) => {
-    elements.stats.textContent = 'Failed to refresh graph'
-    console.error(error)
-  })
+  loadGraph().catch(handleGraphRefreshError)
 
   tickCounter += 1
   if (tickCounter % 3 === 0) {
@@ -461,7 +1027,6 @@ loadAgents()
     setInterval(refreshGraphLoop, pollIntervalMs)
   })
   .catch(error => {
-    elements.stats.textContent = 'Failed to load graph'
     console.error(error)
   })
 
@@ -470,9 +1035,6 @@ document.addEventListener('visibilitychange', () => {
     return
   }
 
-  loadGraph({ reset: true }).catch(error => {
-    elements.stats.textContent = 'Failed to refresh graph'
-    console.error(error)
-  })
+  loadGraph({ reset: true }).catch(handleGraphRefreshError)
 })
 `;