@andespindola/brainlink 0.1.0-beta.104 → 0.1.0-beta.106

package/README.md

@@ -604,7 +604,7 @@ The graph UI shows:
 - WebGL node and edge acceleration when supported, falling back to Canvas 2D without changing graph behavior
 - compact macro-to-micro density progression so reset keeps the graph mass oriented and zoom-in separates local neighborhoods progressively
 - graph camera treats hub-centered navigation as structural only when the hub is dominant; diffuse stress graphs reset and zoom around the full graph mass
-- graph LOD progression: graphs up to 1000 notes render directly; larger graphs use one recursive model where each visible level targets up to 999 non-hub nodes, starts from a memory-hub-centered mesh, and each supernode can expand into another same-shape subgraph level (again up to 999 children) with latent fade-in, aggregated real links and local sibling mesh links so org-heavy and stress-50k follow the same structure at different depths; for massive graphs the first expansion starts much deeper in zoom, low-size child levels use slower easing, and expansion is additionally gated by focus readiness (screen-space isolation of the focused parent) so child levels open only when that subgraph is truly centered and separated in view
+- graph LOD progression: hierarchical rendering now follows one recursive graph-of-graphs standard whenever a graph has more than one hierarchy level; each level expands through intermediate subgraph sizes (instead of jumping directly to leaves), starts from a memory-hub-centered mesh, and each supernode can expand into another same-shape subgraph level (up to 999 children) with latent fade-in, aggregated real links and local sibling mesh links so org-heavy-like and stress-50k-like structures share the same layered behavior at different depths; layered clusters also receive perspective depth projection (Z-depth) so expansion reads as a true depth field instead of a flat 2D switch; for massive graphs the first expansion starts deeper in zoom and is additionally gated by focus readiness (screen-space isolation of the focused parent) so child levels open only when that subgraph is truly centered and separated in view
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

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

@@ -31,6 +31,10 @@ const massiveEcosystemClusterScaleThreshold = 4.2
 const ecosystemSubgraphScaleThreshold = 0.18
 const ecosystemMicroScaleThreshold = 0.08
 const ecosystemFocusedParentLimit = 2
+const ecosystemDepthNear = 36
+const ecosystemDepthFar = 560
+const ecosystemDepthPerspective = 1400
+const ecosystemDepthOpacityFloor = 0.42
 const zoomRecoveryGuardMs = 4200
 const zoomCapTargetViewportShare = 0.72
 const meshEdgeScaleThreshold = 0.09
@@ -596,7 +600,7 @@ const recomputeVisibility = () => {
       y: macroHub ? macroHub.y : (bounds.minY + bounds.maxY) / 2
     }
     : { x: 0, y: 0 }
-  const ecosystemGraph = nodes.length > ecosystemActivationNodeThreshold
+  const ecosystemGraph = nodes.length > 1
     ? buildEcosystemGraph(nodes, state.macroCenter, primaryHub)
     : {
         clusters: [],
@@ -768,12 +772,29 @@ const ecosystemLayoutSpacingForSize = size => {
   return 7
 }
 
+const buildIntermediateEcosystemSizes = (fromSize, toSize) => {
+  if (fromSize <= toSize + 1) {
+    return []
+  }
+  const intermediate = []
+  let current = fromSize
+  while (current > toSize + 1) {
+    const stepped = Math.max(toSize + 1, Math.ceil(current / 3))
+    if (stepped >= current) {
+      break
+    }
+    intermediate.push(stepped)
+    current = stepped
+  }
+  return intermediate
+}
+
 const buildEcosystemLevelSizes = nodeCount => {
   if (nodeCount <= 0) return []
-  const sizes = []
+  const primarySizes = []
   let currentSize = Math.max(1, Math.ceil(nodeCount / ecosystemLevelNodeCap))
   while (currentSize >= 1) {
-    sizes.push(currentSize)
+    primarySizes.push(currentSize)
     if (currentSize === 1) {
       break
     }
@@ -783,7 +804,28 @@ const buildEcosystemLevelSizes = nodeCount => {
     }
     currentSize = nextSize
   }
-  return sizes
+  const expandedSizes = []
+  for (let index = 0; index < primarySizes.length; index += 1) {
+    const size = primarySizes[index]
+    if (expandedSizes.length === 0 || expandedSizes[expandedSizes.length - 1] !== size) {
+      expandedSizes.push(size)
+    }
+    const nextSize = primarySizes[index + 1]
+    if (!Number.isFinite(nextSize)) {
+      continue
+    }
+    const intermediate = buildIntermediateEcosystemSizes(size, nextSize)
+    for (let intermediateIndex = 0; intermediateIndex < intermediate.length; intermediateIndex += 1) {
+      const candidate = intermediate[intermediateIndex]
+      if (expandedSizes[expandedSizes.length - 1] !== candidate) {
+        expandedSizes.push(candidate)
+      }
+    }
+  }
+  if (expandedSizes[expandedSizes.length - 1] !== 1) {
+    expandedSizes.push(1)
+  }
+  return expandedSizes
 }
 
 const buildEcosystemExpansionLevels = (levelSizes, nodeCount) => {
@@ -794,12 +836,12 @@ const buildEcosystemExpansionLevels = (levelSizes, nodeCount) => {
   const maxScale = isMassive
     ? massiveEcosystemClusterScaleThreshold
     : ecosystemClusterScaleThreshold
-  const startScale = isMassive ? 0.82 : 0.18
+  const startScale = isMassive ? 1.12 : 0.24
   const transitionCount = levelSizes.length - 1
   const usableScale = Math.max(0.08, maxScale - startScale)
   const step = usableScale / transitionCount
-  const stride = isMassive ? 0.9 : 0.78
-  const overlap = isMassive ? 1.28 : 1.75
+  const stride = isMassive ? 0.93 : 0.82
+  const overlap = isMassive ? 1.22 : 1.62
   const levels = []
   for (let index = 0; index < transitionCount; index += 1) {
     const start = startScale + step * index * stride
@@ -1115,6 +1157,81 @@ const selectHierarchicalEcosystemClusters = viewport => {
   return [...hubClusters, ...visibleClusters]
 }
 
+const ecosystemLevelIndexBySize = () => {
+  const indexBySize = new Map()
+  for (let index = 0; index < state.ecosystemLevelSizes.length; index += 1) {
+    indexBySize.set(state.ecosystemLevelSizes[index], index)
+  }
+  return indexBySize
+}
+
+const ecosystemDepthForCluster = (cluster, levelIndexMap) => {
+  if (cluster.isHub) {
+    return ecosystemDepthNear
+  }
+  const maxLevelIndex = Math.max(state.ecosystemLevelSizes.length - 1, 0)
+  const levelIndex = levelIndexMap.get(cluster.size) ?? 0
+  const reverseIndex = Math.max(0, maxLevelIndex - levelIndex)
+  const normalized = maxLevelIndex === 0 ? 0 : reverseIndex / maxLevelIndex
+  return ecosystemDepthNear + normalized * (ecosystemDepthFar - ecosystemDepthNear)
+}
+
+const projectEcosystemPoint = (x, y, depth, anchor) => {
+  const factor = ecosystemDepthPerspective / (ecosystemDepthPerspective + Math.max(0, depth))
+  return {
+    x: anchor.x + (x - anchor.x) * factor,
+    y: anchor.y + (y - anchor.y) * factor,
+    factor
+  }
+}
+
+const applyEcosystemDepthProjection = (clusters, edges, anchor) => {
+  const levelIndexMap = ecosystemLevelIndexBySize()
+  const projectedClusters = []
+  const clusterById = new Map()
+
+  for (let index = 0; index < clusters.length; index += 1) {
+    const cluster = clusters[index]
+    const depth = ecosystemDepthForCluster(cluster, levelIndexMap)
+    const projected = projectEcosystemPoint(cluster.x, cluster.y, depth, anchor)
+    const baseOpacity = Number.isFinite(cluster.lodOpacity) ? cluster.lodOpacity : 1
+    const depthOpacity = Math.max(
+      ecosystemDepthOpacityFloor,
+      Math.min(1, 0.58 + projected.factor * 0.62)
+    )
+    const projectedCluster = {
+      ...cluster,
+      x: projected.x,
+      y: projected.y,
+      lodOpacity: baseOpacity * depthOpacity,
+      depth,
+      depthScale: projected.factor
+    }
+    projectedClusters.push(projectedCluster)
+    clusterById.set(projectedCluster.id, projectedCluster)
+  }
+
+  const projectedEdges = edges
+    .map((edge) => {
+      const sourceCluster = clusterById.get(edge.sourceCluster.id)
+      const targetCluster = clusterById.get(edge.targetCluster.id)
+      if (!sourceCluster || !targetCluster) {
+        return null
+      }
+      return {
+        ...edge,
+        sourceCluster,
+        targetCluster
+      }
+    })
+    .filter(Boolean)
+
+  return {
+    clusters: projectedClusters,
+    edges: projectedEdges
+  }
+}
+
 const ecosystemSiblingEdgesForClusters = (clusters, existingEdges) => {
   const byParent = new Map()
   for (let index = 0; index < clusters.length; index += 1) {
@@ -2813,7 +2930,9 @@ const clusterRadiusPx = cluster => {
     const size = Math.max(1, Math.min(ecosystemLevelNodeCap, cluster.size || cluster.count || 1))
     const sizeBias = 0.56 + Math.log10(size + 1) * 0.28
     const densityBias = Math.log10((cluster.count || 1) + 1) * 0.12
-    return Math.max(0.62, Math.min(2.4, sizeBias + densityBias))
+    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))
 }
@@ -2985,14 +3104,17 @@ const computeRenderVisibility = () => {
     ? massiveEcosystemClusterScaleThreshold
     : ecosystemClusterScaleThreshold
   if (
-    state.visibleNodes.length > ecosystemActivationNodeThreshold &&
+    state.ecosystemExpansionLevels.length > 0 &&
     state.transform.scale <= ecosystemScaleThreshold &&
     state.ecosystemClusters.length > 0
   ) {
     const clusters = selectHierarchicalEcosystemClusters(viewport)
       .sort((left, right) => right.count - left.count)
-    state.renderClusters = clusters
-    state.renderClusterEdges = ecosystemEdgesForClusters(clusters)
+    const edges = ecosystemEdgesForClusters(clusters)
+    const projectionAnchor = ecosystemFocusPoint()
+    const projected = applyEcosystemDepthProjection(clusters, edges, projectionAnchor)
+    state.renderClusters = projected.clusters
+    state.renderClusterEdges = projected.edges
     state.renderNodes = []
     state.renderEdges = []
     return

package/package.json

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