@andespindola/brainlink 0.1.0-beta.63 → 0.1.0-beta.65

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

@@ -570,16 +570,17 @@ const nodeBudgetForScale = (scale) => {
   return renderNodeBudget
 }
 
-const layerWindowForScale = (scale) => {
+const layerFocusForScale = (scale) => {
   const normalized = Math.max(0, Math.min(1, (scale - 0.06) / 0.94))
-  const outer = Math.max(0.14, 1 - normalized * 0.86)
-  const band = Math.max(0.14, 0.26 - normalized * 0.12)
-  const inner = Math.max(0, outer - band)
+  const shellCenter = Math.max(0.08, 0.96 - normalized * 0.86)
+  const shellWidth = Math.max(0.16, 0.34 - normalized * 0.2)
+  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 { inner, outer }
+  return { shellCenter, shellWidth, coreRadius, coreRatio }
 }
 
-const selectLayeredNodesForScale = (sourceNodes) => {
+const selectLayeredNodesForScale = (sourceNodes, targetCount) => {
   const hub = state.primaryHub
   if (!hub || sourceNodes.length <= 1200 || state.visibleNodes.length <= massiveGraphNodeThreshold) {
     return sourceNodes
@@ -598,39 +599,58 @@ const selectLayeredNodesForScale = (sourceNodes) => {
     return sourceNodes
   }
 
-  const window = layerWindowForScale(state.transform.scale)
-  const inner = window.inner * maxDistance
-  const outer = window.outer * maxDistance
-  const layered = distances
-    .filter((item) => item.distance >= inner && item.distance <= outer)
-    .map((item) => item.node)
-
-  if (state.transform.scale >= layeredCoreScaleThreshold && !layered.some((node) => node.id === hub.id)) {
-    layered.push(hub)
-  }
+  const focus = layerFocusForScale(state.transform.scale)
+  const normalizedRows = distances.map((item) => ({
+    ...item,
+    normalized: item.distance / maxDistance
+  }))
+  const desired = Math.max(220, 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
 
-  if (layered.length > 0) {
-    return layered
-  }
+  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 midpoint = (window.inner + window.outer) / 2
-  const fallback = [...distances]
+  const shellNodes = normalizedRows
     .sort((left, right) => {
-      const leftNorm = left.distance / maxDistance
-      const rightNorm = right.distance / maxDistance
-      const leftDelta = Math.abs(leftNorm - midpoint)
-      const rightDelta = Math.abs(rightNorm - midpoint)
+      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, Math.min(900, sourceNodes.length))
+    .slice(0, shellTarget)
     .map((item) => item.node)
 
-  if (state.transform.scale >= layeredCoreScaleThreshold && !fallback.some((node) => node.id === hub.id)) {
-    fallback.push(hub)
+  const merged = []
+  const ids = new Set()
+  const pushUnique = (node) => {
+    if (!node || ids.has(node.id)) return
+    ids.add(node.id)
+    merged.push(node)
   }
 
-  return fallback
+  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 edgeIdentityKey = edge => {
@@ -1650,8 +1670,8 @@ const computeRenderVisibility = () => {
   if (state.visibleNodes.length > massiveGraphNodeThreshold) {
     const viewportNodes = viewportNodesFromSpatialIndex(viewport)
     const sourceNodes = viewportNodes.length > 0 ? viewportNodes : state.visibleNodes
-    const layeredNodes = selectLayeredNodesForScale(sourceNodes)
     const sampleLimit = nodeBudgetForScale(state.transform.scale)
+    const layeredNodes = selectLayeredNodesForScale(sourceNodes, sampleLimit)
     const sampled = layeredNodes.length > sampleLimit
       ? sampleVisibleNodes(Math.min(sampleLimit, renderNodeBudget), layeredNodes)
       : layeredNodes.slice(0, Math.min(layeredNodes.length, renderNodeBudget))
@@ -2113,6 +2133,13 @@ const bindEvents = () => {
   })
   canvas.addEventListener('wheel', handleWheelZoom, { passive: false })
   canvas.addEventListener('dblclick', event => {
+    const point = worldPoint(event)
+    const node = hitNode(point)
+    if (node) {
+      selectNode(node, { openContent: true })
+      return
+    }
+
     const rect = canvas.getBoundingClientRect()
     const cursorX = event.clientX - rect.left
     const cursorY = event.clientY - rect.top
@@ -2172,8 +2199,8 @@ const bindEvents = () => {
       settleNeighborhoodAroundNode(draggedNode)
       markRenderDirty()
     }
-    if (draggedNode && !state.pointer.moved) selectNode(draggedNode, { openContent: true })
-    if (!draggedNode && !state.pointer.moved) selectNode(state.hovered, { openContent: true })
+    if (draggedNode && !state.pointer.moved) selectNode(draggedNode, { openContent: false })
+    if (!draggedNode && !state.pointer.moved) selectNode(state.hovered, { openContent: false })
     state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
     canvas.releasePointerCapture(event.pointerId)
   })

package/package.json

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