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

package/README.md

@@ -84,12 +84,12 @@ 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 renders hierarchical ecosystem subgraphs only above 1000 notes: the memory hub stays centered, 1000-note groups stay as compact sand-like points, and focused groups gradually expand into smaller graph meshes before individual notes are rendered.
+- 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.
 - 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 macro mass and zoom-in progressively expands toward local detail.
-- Zoomed-out graph LOD renders nested subgraphs and progressively expands only the focused cluster as zoom increases, including very large vaults.
-- Graph reset starts in macro "galaxy" overview mode and progressively reveals nearby nodes as zoom increases, including smaller vaults.
+- 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.
+- 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.
 
@@ -595,21 +595,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 LOD jumps while keeping cursor-anchored focus
-- zoom-out floor for large and massive graphs, plus reset macro floor tied to hub-neighbor distance and first-level cluster spacing, with a tighter initial camera so the first graph appears as a closer cell instead of a distant mesh
+- continuous target-scale interpolation for wheel/button zoom to avoid abrupt jumps while keeping cursor-anchored focus
+- Bloom-like scene navigation: reset fits the current graph scene, wheel zoom stays anchored to the cursor, and WebGL acceleration is used only to draw the same flat graph 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
 - double-click on 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
-- hierarchical hot-path optimizations reduce per-frame allocations and repeated scans during layered cluster expansion and edge projection
-- hierarchical edge projection now caches hub membership and node-to-cluster resolution per frame to keep large recursive subgraph rendering smooth during continuous zoom and pan
-- hierarchical projection now uses stronger perspective yaw/pitch and depth-based render ordering so layered subgraphs read as a true 3D field instead of a flat expansion
-- node rendering also applies depth projection cues on large visible sets (position, scale, opacity and edge depth weighting) so the graph keeps 3D perception when leaving cluster-only LOD layers
 - 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: 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 stronger perspective depth projection (Z-depth) with vertical camera tilt/parallax 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
+- 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
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

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

@@ -23,43 +23,7 @@ const transformCoordinateLimit = 20_000_000
 const hoverHitTestIntervalMs = 64
 const ecosystemLevelNodeCap = 999
 const ecosystemActivationNodeThreshold = 1000
-const ecosystemClusterEdgeLimit = 520
-const ecosystemHubEdgeLimit = 120
-const ecosystemSiblingEdgeLimit = 180
-const ecosystemClusterScaleThreshold = 0.78
-const massiveEcosystemClusterScaleThreshold = 4.2
-const ecosystemClusterEnterHysteresis = 0.94
-const ecosystemClusterExitHysteresis = 1.1
 const ecosystemSubgraphScaleThreshold = 0.18
-const ecosystemMicroScaleThreshold = 0.08
-const ecosystemFocusedParentLimit = 2
-const ecosystemDepthNear = 80
-const ecosystemDepthFar = 2600
-const ecosystemDepthPerspective = 560
-const ecosystemDepthTiltY = 0.3
-const ecosystemDepthYaw = 0.3
-const ecosystemDepthPitch = 0.24
-const ecosystemDepthRadialGain = 0.13
-const ecosystemDepthOrbitalMaxOffset = 160
-const ecosystemDepthMinScale = 0.2
-const ecosystemDepthOpacityFloor = 0.16
-const graphDepthNear = 40
-const graphDepthFar = 1320
-const graphDepthPerspective = 430
-const graphDepthYaw = 0.42
-const graphDepthPitch = 0.3
-const graphDepthRadialGain = 0.24
-const graphDepthMinScale = 0.34
-const graphDepthOpacityFloor = 0.22
-const graphDepthEdgeOpacityFloor = 0.12
-const graphDepthProjectionNodeThreshold = 40
-const graphDepthProjectionNodeCap = 2600
-const graphDepthProjectionMinScale = 0.03
-const graphDepthProjectionMaxScale = 1.7
-const graphDepthProjectionEnterMinScale = graphDepthProjectionMinScale * 1.08
-const graphDepthProjectionExitMinScale = graphDepthProjectionMinScale * 0.88
-const graphDepthProjectionEnterMaxScale = graphDepthProjectionMaxScale * 0.92
-const graphDepthProjectionExitMaxScale = graphDepthProjectionMaxScale * 1.16
 const zoomRecoveryGuardMs = 4200
 const zoomCapTargetViewportShare = 0.72
 const meshEdgeScaleThreshold = 0.09
@@ -645,29 +609,15 @@ const recomputeVisibility = () => {
       y: macroHub ? macroHub.y : (bounds.minY + bounds.maxY) / 2
     }
     : { x: 0, y: 0 }
-  const ecosystemGraph = nodes.length > 1
-    ? buildEcosystemGraph(nodes, state.macroCenter, primaryHub)
-    : {
-        clusters: [],
-        clustersBySize: new Map(),
-        nodeClusterBySize: new Map(),
-        levelSizes: [],
-        expansionLevels: [],
-        baseSize: ecosystemLevelNodeCap,
-        hubCluster: null
-      }
-  state.ecosystemClusters = ecosystemGraph.clusters
-  state.ecosystemClustersBySize = ecosystemGraph.clustersBySize
-  state.ecosystemNodeClusterBySize = ecosystemGraph.nodeClusterBySize
-  state.ecosystemLevelSizes = ecosystemGraph.levelSizes
-  state.ecosystemLevelIndexBySize = ecosystemGraph.levelSizes.reduce((map, size, index) => {
-    map.set(size, index)
-    return map
-  }, new Map())
-  state.ecosystemHubNodeIds = new Set(ecosystemGraph.hubCluster?.nodeIds ?? [])
-  state.ecosystemExpansionLevels = ecosystemGraph.expansionLevels
-  state.ecosystemBaseSize = ecosystemGraph.baseSize
-  state.ecosystemHubCluster = ecosystemGraph.hubCluster
+  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()
 }
@@ -773,271 +723,12 @@ const createVisibleEdgeLookup = edges => {
   return lookup
 }
 
-const ecosystemKeyForNode = node => {
-  if (typeof node.segment === 'string' && node.segment.trim()) {
-    return node.segment.trim()
-  }
-  if (typeof node.group === 'string' && node.group.trim()) {
-    return node.group.trim()
-  }
-  const pathParts = String(node.path || '')
-    .split('/')
-    .filter(part => part.trim())
-    .slice(0, 2)
-  return pathParts.length > 0 ? pathParts.join('/') : 'root'
-}
-
-const compareNodesForEcosystem = (left, right) => {
-  const keyComparison = ecosystemKeyForNode(left).localeCompare(ecosystemKeyForNode(right))
-  if (keyComparison !== 0) return keyComparison
-  const leftDegree = state.nodeDegrees.get(left.id) ?? 0
-  const rightDegree = state.nodeDegrees.get(right.id) ?? 0
-  if (leftDegree !== rightDegree) return rightDegree - leftDegree
-  return String(left.title || left.id).localeCompare(String(right.title || right.id))
-}
-
-const selectEcosystemRepresentative = nodes => {
-  let representative = nodes[0] ?? null
-  let representativeScore = Number.NEGATIVE_INFINITY
-
-  for (let index = 0; index < nodes.length; index += 1) {
-    const node = nodes[index]
-    const score = (state.nodeDegrees.get(node.id) ?? 0) + hubNodeScore(node) * 1000
-    if (score > representativeScore) {
-      representative = node
-      representativeScore = score
-    }
-  }
-
-  return representative
-}
-
-const ecosystemLayoutSpacingForSize = size => {
-  if (size >= ecosystemLevelNodeCap) return 260
-  if (size >= 320) return 110
-  if (size >= 120) return 64
-  if (size >= 48) return 34
-  if (size >= 18) return 18
-  if (size >= 8) return 11
-  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 primarySizes = []
-  let currentSize = Math.max(1, Math.ceil(nodeCount / ecosystemLevelNodeCap))
-  while (currentSize >= 1) {
-    primarySizes.push(currentSize)
-    if (currentSize === 1) {
-      break
-    }
-    const nextSize = Math.max(1, Math.ceil(currentSize / ecosystemLevelNodeCap))
-    if (nextSize === currentSize) {
-      break
-    }
-    currentSize = nextSize
-  }
-  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) => {
-  if (levelSizes.length <= 1) {
-    return []
-  }
-  const isMassive = nodeCount > massiveGraphNodeThreshold
-  const maxScale = isMassive
-    ? massiveEcosystemClusterScaleThreshold
-    : ecosystemClusterScaleThreshold
-  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.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
-    const end = Math.min(maxScale, start + step * overlap)
-    levels.push({
-      parentSize: levelSizes[index],
-      childSize: levelSizes[index + 1],
-      start,
-      end
-    })
-  }
-  return levels
-}
-
-const ecosystemCompactPoint = (index, total, center, spacing) => {
-  if (total <= 1) {
-    return { x: center.x, y: center.y }
-  }
-  const angle = index * 2.399963229728653
-  const radius = spacing * Math.sqrt(index + 1)
-  return {
-    x: center.x + Math.cos(angle) * radius,
-    y: center.y + Math.sin(angle) * radius
-  }
-}
-
-const buildEcosystemCluster = (nodes, index, point) => {
-  const count = Math.max(nodes.length, 1)
-  const representative = selectEcosystemRepresentative(nodes)
-
-  return {
-    id: 'ecosystem-' + index,
-    x: point.x,
-    y: point.y,
-    count,
-    nodeIds: nodes.map(node => node.id),
-    representative,
-    label: ecosystemKeyForNode(nodes[0] ?? representative ?? { path: '' })
-  }
-}
-
-const buildEcosystemHubCluster = (hub, center) => hub
-  ? {
-      id: 'ecosystem-hub',
-      x: center.x,
-      y: center.y,
-      count: 1,
-      size: 1,
-      nodeIds: [hub.id],
-      representative: hub,
-      label: hub.title || 'Memory Hub',
-      parentId: null,
-      parentX: null,
-      parentY: null,
-      isHub: true
-    }
-  : null
-
-const buildEcosystemLevel = (sortedNodes, size, parentLookup, center) => {
-  const clusters = []
-  const clusterByNodeId = new Map()
-  const parentChildIndex = new Map()
-
-  for (let offset = 0; offset < sortedNodes.length; offset += size) {
-    const clusterNodes = sortedNodes.slice(offset, offset + size)
-    const parentCluster = parentLookup?.get(clusterNodes[0]?.id)
-    const siblingIndex = parentCluster
-      ? (parentChildIndex.get(parentCluster.id) ?? 0)
-      : clusters.length
-    if (parentCluster) {
-      parentChildIndex.set(parentCluster.id, siblingIndex + 1)
-    }
-    const point = parentCluster
-      ? ecosystemCompactPoint(siblingIndex, Math.ceil((parentCluster.count || size) / size), parentCluster, ecosystemLayoutSpacingForSize(size))
-      : ecosystemCompactPoint(clusters.length, Math.ceil(sortedNodes.length / size), center, ecosystemLayoutSpacingForSize(size))
-    const cluster = {
-      ...buildEcosystemCluster(clusterNodes, clusters.length, point),
-      id: 'ecosystem-' + size + '-' + clusters.length,
-      size,
-      parentId: parentCluster?.id ?? null,
-      parentX: parentCluster?.x ?? null,
-      parentY: parentCluster?.y ?? null
-    }
-    clusters.push(cluster)
-    for (let index = 0; index < clusterNodes.length; index += 1) {
-      clusterByNodeId.set(clusterNodes[index].id, cluster)
-    }
-  }
-
-  return { clusters, clusterByNodeId }
-}
-
-const buildEcosystemGraph = (nodes, center, hub) => {
-  if (nodes.length === 0) {
-    return {
-      clusters: [],
-      clustersBySize: new Map(),
-      nodeClusterBySize: new Map(),
-      levelSizes: [],
-      expansionLevels: [],
-      baseSize: ecosystemLevelNodeCap,
-      hubCluster: null
-    }
-  }
-
-  const hubCluster = buildEcosystemHubCluster(hub, center)
-  const sortedNodes = nodes
-    .filter(node => node.id !== hub?.id)
-    .sort(compareNodesForEcosystem)
-  const levelSizes = buildEcosystemLevelSizes(sortedNodes.length)
-  const expansionLevels = buildEcosystemExpansionLevels(levelSizes, nodes.length)
-  const baseSize = levelSizes[0] ?? ecosystemLevelNodeCap
-  const clustersBySize = new Map()
-  const nodeClusterBySize = new Map()
-  let parentLookup = null
-
-  for (let index = 0; index < levelSizes.length; index += 1) {
-    const size = levelSizes[index]
-    const level = buildEcosystemLevel(sortedNodes, size, parentLookup, center)
-    clustersBySize.set(size, level.clusters)
-    nodeClusterBySize.set(size, level.clusterByNodeId)
-    parentLookup = level.clusterByNodeId
-  }
-
-  return {
-    clusters: clustersBySize.get(baseSize) ?? [],
-    clustersBySize,
-    nodeClusterBySize,
-    levelSizes,
-    expansionLevels,
-    baseSize,
-    hubCluster
-  }
-}
-
 const isClusterInViewport = (cluster, viewport) =>
   cluster.x >= viewport.minX &&
   cluster.x <= viewport.maxX &&
   cluster.y >= viewport.minY &&
   cluster.y <= viewport.maxY
 
-const filterEcosystemClustersByViewport = (clusters, viewport) => {
-  const visible = clusters.filter(cluster => isClusterInViewport(cluster, viewport))
-  return visible.length > 0 ? visible : [...clusters]
-}
-
 const ecosystemFocusPoint = () => {
   const cursorPoint = cursorWorldPoint()
   if (cursorPoint) {
@@ -1050,422 +741,6 @@ const ecosystemFocusPoint = () => {
   return viewportCenterWorldPoint()
 }
 
-const nearestEcosystemParentIds = (clusters, focusPoint, limit) =>
-  clusters
-    .map(cluster => ({
-      cluster,
-      distance: Math.max(
-        0,
-        Math.hypot(cluster.x - focusPoint.x, cluster.y - focusPoint.y) -
-          clusterRadiusPx(cluster) / Math.max(state.transform.scale, 0.0001)
-      )
-    }))
-    .sort((left, right) => left.distance - right.distance)
-    .slice(0, limit)
-    .map(item => item.cluster.id)
-
-const focusedParentCluster = (clusters, focusPoint) => {
-  if (clusters.length === 0) {
-    return null
-  }
-  let focused = clusters[0]
-  let nearestDistance = Number.POSITIVE_INFINITY
-  for (let index = 0; index < clusters.length; index += 1) {
-    const cluster = clusters[index]
-    const distance = Math.max(
-      0,
-      Math.hypot(cluster.x - focusPoint.x, cluster.y - focusPoint.y) -
-        clusterRadiusPx(cluster) / Math.max(state.transform.scale, 0.0001)
-    )
-    if (distance < nearestDistance) {
-      nearestDistance = distance
-      focused = cluster
-    }
-  }
-  return focused
-}
-
-const nearestSiblingScreenDistancePx = (focusedCluster, clusters) => {
-  let nearestDistancePx = Number.POSITIVE_INFINITY
-  for (let index = 0; index < clusters.length; index += 1) {
-    const cluster = clusters[index]
-    if (cluster.id === focusedCluster.id) continue
-    const distancePx = Math.hypot(
-      (cluster.x - focusedCluster.x) * state.transform.scale,
-      (cluster.y - focusedCluster.y) * state.transform.scale
-    )
-    if (distancePx < nearestDistancePx) {
-      nearestDistancePx = distancePx
-    }
-  }
-  return nearestDistancePx
-}
-
-const ecosystemFocusReadiness = (parentClusters, focusPoint, childSize) => {
-  if (parentClusters.length <= 1) {
-    return 1
-  }
-  const focusedCluster = focusedParentCluster(parentClusters, focusPoint)
-  if (!focusedCluster) {
-    return 0
-  }
-  const nearestDistancePx = nearestSiblingScreenDistancePx(focusedCluster, parentClusters)
-  const sizeHalfCap = Math.ceil(ecosystemLevelNodeCap / 2)
-  const sizeEighthCap = Math.ceil(ecosystemLevelNodeCap / 8)
-  const focusDistanceTargetPx = childSize >= sizeHalfCap
-    ? 680
-    : childSize >= sizeEighthCap
-      ? 520
-      : 380
-  const focusDistanceRangePx = childSize >= sizeHalfCap ? 260 : 220
-  return smoothStep((nearestDistancePx - focusDistanceTargetPx) / focusDistanceRangePx)
-}
-const smoothStep = value => {
-  const clamped = Math.max(0, Math.min(1, value))
-  return clamped * clamped * (3 - clamped * 2)
-}
-
-const zoomProgress = (scale, start, end) =>
-  smoothStep((scale - start) / Math.max(end - start, 0.0001))
-
-const semanticZoomSpread = (progress, childSize) => {
-  const spreadExponent = childSize <= Math.ceil(ecosystemLevelNodeCap / 12) ? 5.6 : 4.2
-  const curve = Math.pow(progress, spreadExponent)
-  if (childSize >= Math.ceil(ecosystemLevelNodeCap / 2)) {
-    return 0.12 + curve * 0.88
-  }
-  return curve
-}
-
-const opacityForProgress = (progress, childSize) => {
-  const opacityExponent = childSize <= Math.ceil(ecosystemLevelNodeCap / 12) ? 2.8 : 2.1
-  const eased = Math.pow(progress, opacityExponent)
-  if (childSize >= Math.ceil(ecosystemLevelNodeCap / 2)) {
-    return 0.22 + eased * 0.78
-  }
-  return eased
-}
-
-const expandFocusedClusters = (parentClusters, focusPoint, childSize, progress, spread, viewport) => {
-  const expandedParentIds = new Set(nearestEcosystemParentIds(
-    parentClusters,
-    focusPoint,
-    ecosystemFocusedParentLimit
-  ))
-  const childClusters = state.ecosystemClustersBySize.get(childSize) ?? []
-  const visibleChildClusters = []
-  for (let index = 0; index < childClusters.length; index += 1) {
-    const cluster = childClusters[index]
-    if (!expandedParentIds.has(cluster.parentId)) {
-      continue
-    }
-    const spreadCluster = spreadChildClusterFromParent(cluster, childSize, progress, spread)
-    if (!isClusterInViewport(spreadCluster, viewport)) {
-      continue
-    }
-    visibleChildClusters.push(spreadCluster)
-  }
-
-  return {
-    expandedParentIds,
-    childClusters: visibleChildClusters
-  }
-}
-
-const spreadChildClusterFromParent = (cluster, childSize, progress, spread) => {
-  if (!Number.isFinite(cluster.parentX) || !Number.isFinite(cluster.parentY)) {
-    return {
-      ...cluster,
-      lodOpacity: opacityForProgress(progress, childSize)
-    }
-  }
-
-  return {
-    ...cluster,
-    x: cluster.parentX + (cluster.x - cluster.parentX) * spread,
-    y: cluster.parentY + (cluster.y - cluster.parentY) * spread,
-    lodOpacity: opacityForProgress(progress, childSize)
-  }
-}
-
-const selectHierarchicalEcosystemClusters = viewport => {
-  const baseClusters = state.ecosystemClustersBySize.get(state.ecosystemBaseSize) ?? state.ecosystemClusters
-  const visibleBaseClusters = filterEcosystemClustersByViewport(baseClusters, viewport)
-  const hubClusters = state.ecosystemHubCluster ? [state.ecosystemHubCluster] : []
-  const visibleClusters = [...visibleBaseClusters]
-  const clustersBySize = new Map()
-  for (let index = 0; index < visibleBaseClusters.length; index += 1) {
-    const cluster = visibleBaseClusters[index]
-    const levelClusters = clustersBySize.get(cluster.size)
-    if (levelClusters) {
-      levelClusters.push(cluster)
-    } else {
-      clustersBySize.set(cluster.size, [cluster])
-    }
-  }
-  const focusPoint = ecosystemFocusPoint()
-
-  for (let index = 0; index < state.ecosystemExpansionLevels.length; index += 1) {
-    const level = state.ecosystemExpansionLevels[index]
-    const parentClusters = clustersBySize.get(level.parentSize) ?? []
-    if (parentClusters.length === 0) {
-      continue
-    }
-    const zoomLevelProgress = zoomProgress(state.transform.scale, level.start, level.end)
-    const focusReadiness = ecosystemFocusReadiness(parentClusters, focusPoint, level.childSize)
-    const progress = zoomLevelProgress * focusReadiness
-    if (progress <= 0.002) {
-      continue
-    }
-    const spread = semanticZoomSpread(progress, level.childSize)
-    const expansion = expandFocusedClusters(parentClusters, focusPoint, level.childSize, progress, spread, viewport)
-    visibleClusters.push(...expansion.childClusters)
-    if (expansion.childClusters.length > 0) {
-      const levelClusters = clustersBySize.get(level.childSize)
-      if (levelClusters) {
-        levelClusters.push(...expansion.childClusters)
-      } else {
-        clustersBySize.set(level.childSize, [...expansion.childClusters])
-      }
-    }
-  }
-
-  return [...hubClusters, ...visibleClusters]
-}
-
-const ecosystemLevelIndexBySize = () => state.ecosystemLevelIndexBySize
-
-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 safeDepth = Math.max(0, depth)
-  const dx = x - anchor.x
-  const dy = y - anchor.y
-  const yawSin = Math.sin(ecosystemDepthYaw)
-  const yawCos = Math.cos(ecosystemDepthYaw)
-  const pitchSin = Math.sin(ecosystemDepthPitch)
-  const pitchCos = Math.cos(ecosystemDepthPitch)
-  const rotatedX = dx * yawCos + safeDepth * yawSin
-  const rotatedZ = Math.max(0, safeDepth * yawCos - dx * yawSin)
-  const rotatedY = dy * pitchCos - rotatedZ * pitchSin
-  const projectedDepth = Math.max(0, rotatedZ + Math.max(0, dy * pitchSin))
-  const factor = ecosystemDepthPerspective / (ecosystemDepthPerspective + projectedDepth)
-  const verticalTilt = projectedDepth * ecosystemDepthTiltY
-  return {
-    x: anchor.x + rotatedX * factor,
-    y: anchor.y + rotatedY * factor - verticalTilt,
-    factor,
-    projectedDepth
-  }
-}
-
-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 baseDepth = ecosystemDepthForCluster(cluster, levelIndexMap)
-    const radialDistance = Math.hypot(cluster.x - anchor.x, cluster.y - anchor.y)
-    const radialOffset = cluster.isHub ? 0 : Math.min(320, radialDistance * ecosystemDepthRadialGain)
-    const orbitalOffset = cluster.isHub
-      ? 0
-      : Math.sin(Math.atan2(cluster.y - anchor.y, cluster.x - anchor.x) * 2.2) * ecosystemDepthOrbitalMaxOffset
-    const depth = Math.max(0, baseDepth + radialOffset + orbitalOffset)
-    const projected = projectEcosystemPoint(cluster.x, cluster.y, depth, anchor)
-    const baseOpacity = Number.isFinite(cluster.lodOpacity) ? cluster.lodOpacity : 1
-    const depthScale = ecosystemDepthMinScale + (1 - ecosystemDepthMinScale) * projected.factor
-    const depthOpacity = Math.max(
-      ecosystemDepthOpacityFloor,
-      Math.min(1, depthScale * 1.08)
-    )
-    const projectedCluster = {
-      ...cluster,
-      x: projected.x,
-      y: projected.y,
-      lodOpacity: baseOpacity * depthOpacity,
-      depth: projected.projectedDepth,
-      depthScale
-    }
-    projectedClusters.push(projectedCluster)
-    clusterById.set(projectedCluster.id, projectedCluster)
-  }
-
-  const projectedEdges = []
-  for (let index = 0; index < edges.length; index += 1) {
-    const edge = edges[index]
-    const sourceCluster = clusterById.get(edge.sourceCluster.id)
-    const targetCluster = clusterById.get(edge.targetCluster.id)
-    if (!sourceCluster || !targetCluster) {
-      continue
-    }
-    projectedEdges.push({
-      ...edge,
-      sourceCluster,
-      targetCluster
-    })
-  }
-
-  return {
-    clusters: projectedClusters,
-    edges: projectedEdges
-  }
-}
-
-const ecosystemSiblingEdgesForClusters = (clusters, existingEdges) => {
-  const byParent = new Map()
-  for (let index = 0; index < clusters.length; index += 1) {
-    const cluster = clusters[index]
-    if (cluster.isHub || !cluster.parentId) {
-      continue
-    }
-    const siblings = byParent.get(cluster.parentId)
-    if (siblings) {
-      siblings.push(cluster)
-    } else {
-      byParent.set(cluster.parentId, [cluster])
-    }
-  }
-
-  const edges = []
-  for (const siblings of byParent.values()) {
-    const ordered = [...siblings]
-      .sort((left, right) => Math.atan2(left.y - (left.parentY ?? 0), left.x - (left.parentX ?? 0)) - Math.atan2(right.y - (right.parentY ?? 0), right.x - (right.parentX ?? 0)))
-    for (let index = 0; index < ordered.length && edges.length < ecosystemSiblingEdgeLimit; index += 1) {
-      const sourceCluster = ordered[index]
-      const targetCluster = ordered[(index + 1) % ordered.length]
-      if (!targetCluster || sourceCluster.id === targetCluster.id) {
-        continue
-      }
-      const orderedIds = sourceCluster.id < targetCluster.id
-        ? [sourceCluster.id, targetCluster.id]
-        : [targetCluster.id, sourceCluster.id]
-      const key = orderedIds.join(':')
-      if (existingEdges.has(key)) {
-        continue
-      }
-      const edge = {
-        id: key,
-        sourceCluster,
-        targetCluster,
-        weight: 0.7,
-        inferred: true
-      }
-      existingEdges.set(key, edge)
-      edges.push(edge)
-    }
-  }
-
-  return edges
-}
-
-const ecosystemEdgesForClusters = clusters => {
-  const edgeClusters = clusters.filter(cluster => cluster.isHub || clusterOpacity(cluster) > 0.018)
-  const clusterById = new Map(edgeClusters.map(cluster => [cluster.id, cluster]))
-  const clusterIds = new Set(clusterById.keys())
-  const levelsBySize = []
-  const seenSizes = new Set()
-  for (let index = 0; index < edgeClusters.length; index += 1) {
-    const cluster = edgeClusters[index]
-    if (!cluster.size || cluster.isHub) continue
-    if (seenSizes.has(cluster.size)) continue
-    seenSizes.add(cluster.size)
-    levelsBySize.push({
-      size: cluster.size,
-      lookup: state.ecosystemNodeClusterBySize.get(cluster.size) ?? new Map()
-    })
-  }
-  levelsBySize.sort((left, right) => left.size - right.size)
-  const resolvedNodeClusterById = new Map()
-  const resolveClusterForNode = nodeId => {
-    if (resolvedNodeClusterById.has(nodeId)) {
-      return resolvedNodeClusterById.get(nodeId)
-    }
-    if (state.ecosystemHubNodeIds.has(nodeId) && state.ecosystemHubCluster && clusterIds.has(state.ecosystemHubCluster.id)) {
-      resolvedNodeClusterById.set(nodeId, state.ecosystemHubCluster)
-      return state.ecosystemHubCluster
-    }
-    for (let index = 0; index < levelsBySize.length; index += 1) {
-      const lookup = levelsBySize[index].lookup
-      const cluster = lookup.get(nodeId)
-      if (cluster && clusterIds.has(cluster.id)) {
-        const resolvedCluster = clusterById.get(cluster.id) ?? cluster
-        resolvedNodeClusterById.set(nodeId, resolvedCluster)
-        return resolvedCluster
-      }
-    }
-    resolvedNodeClusterById.set(nodeId, null)
-    return null
-  }
-
-  const edgeByClusterPair = new Map()
-  for (let index = 0; index < state.visibleEdges.length; index += 1) {
-    const edge = state.visibleEdges[index]
-    const sourceCluster = resolveClusterForNode(edge.source)
-    const targetCluster = resolveClusterForNode(edge.target)
-    if (!sourceCluster || !targetCluster || sourceCluster.id === targetCluster.id) {
-      continue
-    }
-
-    const orderedIds = sourceCluster.id < targetCluster.id
-      ? [sourceCluster.id, targetCluster.id]
-      : [targetCluster.id, sourceCluster.id]
-    const key = orderedIds.join(':')
-    const current = edgeByClusterPair.get(key)
-    if (current) {
-      current.weight += edgeWeight(edge)
-      continue
-    }
-
-    edgeByClusterPair.set(key, {
-      id: key,
-      sourceCluster,
-      targetCluster,
-      weight: edgeWeight(edge)
-    })
-  }
-
-  ecosystemSiblingEdgesForClusters(edgeClusters, edgeByClusterPair)
-  const edges = Array.from(edgeByClusterPair.values())
-    .sort((left, right) => right.weight - left.weight)
-    .slice(0, ecosystemClusterEdgeLimit)
-  const hubCluster = state.ecosystemHubCluster && clusterIds.has(state.ecosystemHubCluster.id)
-    ? state.ecosystemHubCluster
-    : null
-  if (!hubCluster) {
-    return edges
-  }
-
-  const existingHubTargets = new Set(edges.flatMap(edge =>
-    edge.sourceCluster.id === hubCluster.id
-      ? [edge.targetCluster.id]
-      : edge.targetCluster.id === hubCluster.id
-        ? [edge.sourceCluster.id]
-        : []
-  ))
-  const syntheticHubEdges = edgeClusters
-    .filter(cluster => cluster.id !== hubCluster.id && !existingHubTargets.has(cluster.id))
-    .slice(0, ecosystemHubEdgeLimit)
-    .map(cluster => ({
-      id: hubCluster.id + ':' + cluster.id,
-      sourceCluster: hubCluster,
-      targetCluster: cluster,
-      weight: 1,
-      inferred: true
-    }))
-  return edges.concat(syntheticHubEdges)
-}
-
 const edgeBudgetForCurrentFrame = () => {
   const zoom = state.transform.scale
   if (zoom < 0.12) return 380
@@ -1614,22 +889,16 @@ const cursorWorldPoint = () => {
   return screenToWorldPoint(screenX, screenY)
 }
 
+const resolveZoomAnchorWorldPoint = (screenX, screenY) => screenToWorldPoint(screenX, screenY)
+
 const visibilityScaleBucket = (scale) => {
   const safeScale = Math.max(zoomRange.min, scale)
   return Math.round(safeScale * 180_000)
 }
 
 const shouldRenderEcosystemClusterView = (nodeCount, scale) => {
-  const baseThreshold = nodeCount > massiveGraphNodeThreshold
-    ? massiveEcosystemClusterScaleThreshold
-    : ecosystemClusterScaleThreshold
-  const enterThreshold = baseThreshold * ecosystemClusterEnterHysteresis
-  const exitThreshold = baseThreshold * ecosystemClusterExitHysteresis
-  const shouldRender = state.ecosystemViewActive
-    ? scale <= exitThreshold
-    : scale <= enterThreshold
-  state.ecosystemViewActive = shouldRender
-  return shouldRender
+  state.ecosystemViewActive = false
+  return false
 }
 
 const shouldRenderMacroGalaxyView = () => {
@@ -1826,20 +1095,11 @@ const edgeOpacityForScale = (edge, scale) => {
 }
 
 const edgeDepthOpacity = edge => {
-  if (!shouldProjectRenderNodesInDepth()) {
-    return 1
-  }
-  return Math.max(
-    graphDepthEdgeOpacityFloor,
-    Math.min(nodeRenderOpacity(edge.sourceNode), nodeRenderOpacity(edge.targetNode))
-  )
+  return 1
 }
 
 const edgeDepthScale = edge => {
-  if (!shouldProjectRenderNodesInDepth()) {
-    return 1
-  }
-  return Math.max(0.62, Math.min(1.18, Math.min(nodeRenderScale(edge.sourceNode), nodeRenderScale(edge.targetNode))))
+  return 1
 }
 
 const edgeStrokeFor = (edge, selectedEdge) => {
@@ -2022,10 +1282,6 @@ const drawGraphNodes = () => {
     }
   }
 
-  if (shouldProjectRenderNodesInDepth()) {
-    regularNodes.sort((left, right) => nodeRenderDepth(right) - nodeRenderDepth(left))
-  }
-
   drawNodeBatch(regularNodes)
 
   if (state.transform.scale >= 0.62 && state.renderNodes.length <= 1200) {
@@ -2102,7 +1358,7 @@ const drawGraphLabels = nodes => {
 }
 
 const drawAcceleratedGraph = (width, height, drawEdges) => {
-  if (!webGlRenderer || state.renderClusters.length > 0 || shouldProjectRenderNodesInDepth()) {
+  if (!webGlRenderer || state.renderClusters.length > 0) {
     return false
   }
 
@@ -2486,12 +1742,7 @@ const zoomCapByHubDistance = (distance) => {
 
 const currentZoomMax = () => {
   const nodeCount = state.visibleNodes.length > 0 ? state.visibleNodes.length : state.nodes.length
-  const hubDistanceCap = isDominantHub(state.primaryHub, nodeCount)
-    ? zoomCapByHubDistance(state.hubNeighborDistance)
-    : zoomRange.max
-  const minimumUsefulCap = nodeCount > massiveGraphNodeThreshold ? 1.9 : nodeCount > largeGraphNodeThreshold ? 1.35 : 0.8
-  const capped = Math.min(zoomCapByNodeCount(nodeCount), Math.max(minimumUsefulCap, hubDistanceCap))
-  return Math.max(zoomRange.min * 2, capped)
+  return Math.max(zoomRange.min * 2, zoomCapByNodeCount(nodeCount))
 }
 
 const zoomFloorByNodeCount = (nodeCount) => {
@@ -2724,7 +1975,7 @@ const fitView = (options = { useFiltered: true, macro: false, preferHubCenter: t
   markRenderDirty()
 }
 
-const resetView = () => fitView({ useFiltered: false, macro: true, preferHubCenter: true })
+const resetView = () => fitView({ useFiltered: false, macro: false, preferHubCenter: false })
 
 const focusPrimaryHub = () => {
   const hub = state.primaryHub
@@ -3147,103 +2398,13 @@ const clusterRadiusPx = cluster => {
 const clusterOpacity = cluster =>
   Math.max(0, Math.min(1, Number.isFinite(cluster.lodOpacity) ? cluster.lodOpacity : 1))
 
-const clusterDepth = cluster => Number.isFinite(cluster.depth) ? cluster.depth : ecosystemDepthNear
-const clusterDepthScale = cluster => Number.isFinite(cluster.depthScale) ? cluster.depthScale : 1
-
-const shouldProjectRenderNodesInDepth = () => {
-  const withinNodeCountWindow =
-    state.renderClusters.length === 0 &&
-    state.renderNodes.length >= graphDepthProjectionNodeThreshold &&
-    state.renderNodes.length <= graphDepthProjectionNodeCap &&
-    !state.pointer.down
-
-  if (!withinNodeCountWindow) {
-    state.depthProjectionActive = false
-    return false
-  }
-
-  const scale = state.transform.scale
-  const shouldProject = state.depthProjectionActive
-    ? scale >= graphDepthProjectionExitMinScale && scale <= graphDepthProjectionExitMaxScale
-    : scale >= graphDepthProjectionEnterMinScale && scale <= graphDepthProjectionEnterMaxScale
-  state.depthProjectionActive = shouldProject
-  return shouldProject
-}
-
-const nodeProjectionAnchor = () => {
-  const hub = state.primaryHub
-  if (hub) {
-    return { x: hub.x, y: hub.y }
-  }
-  if (state.macroRepresentative) {
-    return { x: state.macroRepresentative.x, y: state.macroRepresentative.y }
-  }
-  return ecosystemFocusPoint()
-}
-
-const projectGraphNodePoint = (x, y, depth, anchor) => {
-  const safeDepth = Math.max(0, depth)
-  const dx = x - anchor.x
-  const dy = y - anchor.y
-  const yawSin = Math.sin(graphDepthYaw)
-  const yawCos = Math.cos(graphDepthYaw)
-  const pitchSin = Math.sin(graphDepthPitch)
-  const pitchCos = Math.cos(graphDepthPitch)
-  const rotatedX = dx * yawCos + safeDepth * yawSin
-  const rotatedZ = Math.max(0, safeDepth * yawCos - dx * yawSin)
-  const rotatedY = dy * pitchCos - rotatedZ * pitchSin
-  const projectedDepth = Math.max(0, rotatedZ + Math.max(0, dy * pitchSin))
-  const factor = graphDepthPerspective / (graphDepthPerspective + projectedDepth)
-  return {
-    x: anchor.x + rotatedX * factor,
-    y: anchor.y + rotatedY * factor,
-    depth: projectedDepth,
-    scale: graphDepthMinScale + (1 - graphDepthMinScale) * factor
-  }
-}
-
 const refreshRenderNodeDepthProjection = () => {
-  if (!shouldProjectRenderNodesInDepth()) {
-    state.renderNodeDepthProjectionById = new Map()
-    return
-  }
-
-  const anchor = nodeProjectionAnchor()
-  let maxDistance = 1
-  for (let index = 0; index < state.renderNodes.length; index += 1) {
-    const node = state.renderNodes[index]
-    const distance = Math.hypot(node.x - anchor.x, node.y - anchor.y)
-    if (distance > maxDistance) {
-      maxDistance = distance
-    }
-  }
-
-  const projectionById = new Map()
-  for (let index = 0; index < state.renderNodes.length; index += 1) {
-    const node = state.renderNodes[index]
-    const radialDistance = Math.hypot(node.x - anchor.x, node.y - anchor.y)
-    const radialRatio = radialDistance / maxDistance
-    const degree = state.nodeDegrees.get(node.id) ?? 0
-    const degreeLift = Math.min(60, degree * 2.2)
-    const radialDepth = radialRatio * graphDepthFar * graphDepthRadialGain
-    const depth = Math.max(0, graphDepthNear + radialDepth - degreeLift)
-    const projected = projectGraphNodePoint(node.x, node.y, depth, anchor)
-    const opacity = Math.max(graphDepthOpacityFloor, Math.min(1, projected.scale * 1.08))
-    projectionById.set(node.id, {
-      x: projected.x,
-      y: projected.y,
-      depth: projected.depth,
-      scale: projected.scale,
-      opacity
-    })
-  }
-  state.renderNodeDepthProjectionById = projectionById
+  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 nodeRenderDepth = node => projectedNode(node)?.depth ?? graphDepthNear
 const nodeRenderScale = node => projectedNode(node)?.scale ?? 1
 const nodeRenderOpacity = node => projectedNode(node)?.opacity ?? 1
 const worldViewportBounds = () => {
@@ -3406,22 +2567,6 @@ const computeRenderVisibility = () => {
     return
   }
 
-  if (
-    state.ecosystemExpansionLevels.length > 0 &&
-    shouldRenderEcosystemClusterView(state.visibleNodes.length, state.transform.scale) &&
-    state.ecosystemClusters.length > 0
-  ) {
-    const clusters = selectHierarchicalEcosystemClusters(viewport)
-      .sort((left, right) => right.count - left.count)
-    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
-  }
   state.ecosystemViewActive = false
 
   if (state.visibleNodes.length <= 2000) {
@@ -3667,7 +2812,6 @@ const render = now => {
     ctx.translate(state.transform.x, state.transform.y)
     ctx.scale(state.transform.scale, state.transform.scale)
     const orderedClusters = [...state.renderClusters]
-      .sort((left, right) => clusterDepth(right) - clusterDepth(left))
     const safeScale = Math.max(state.transform.scale, 0.0001)
     if (state.renderClusterEdges.length > 0) {
       for (let index = 0; index < state.renderClusterEdges.length; index += 1) {
@@ -3676,8 +2820,7 @@ const render = now => {
         if (edgeOpacity <= 0.01) {
           continue
         }
-        const depthScale = Math.min(clusterDepthScale(edge.sourceCluster), clusterDepthScale(edge.targetCluster))
-        const widthScale = 0.6 + depthScale * 0.9
+        const widthScale = 1
         ctx.beginPath()
         ctx.moveTo(edge.sourceCluster.x, edge.sourceCluster.y)
         ctx.lineTo(edge.targetCluster.x, edge.targetCluster.y)
@@ -3862,7 +3005,7 @@ const zoomAtPoint = (screenX, screenY, factor, source = 'generic') => {
     state.zoomTransition.screenX === screenX &&
     state.zoomTransition.screenY === screenY
       ? { x: state.zoomTransition.worldX, y: state.zoomTransition.worldY }
-      : screenToWorldPoint(screenX, screenY)
+      : resolveZoomAnchorWorldPoint(screenX, screenY)
   const worldX = worldPointAtCursor.x
   const worldY = worldPointAtCursor.y
   state.lastZoomFocus = {
@@ -3892,18 +3035,13 @@ const wheelZoomFactor = event => {
     return 1
   }
 
-  const isMassiveEcosystemZoom =
-    state.visibleNodes.length > massiveGraphNodeThreshold &&
-    state.transform.scale <= massiveEcosystemClusterScaleThreshold
-  const sensitivityMultiplier = isMassiveEcosystemZoom ? 0.48 : 1
-  const capMultiplier = isMassiveEcosystemZoom ? 0.34 : 1
   const isZoomOut = normalizedDelta > 0
   const currentScale = state.transform.scale
   const zoomOutDamping = isZoomOut
     ? (currentScale <= 0.03 ? 0.38 : currentScale <= 0.08 ? 0.52 : 0.68)
     : 1
-  const sensitivity = wheelZoomExponent * (isModifierZoom ? wheelZoomModifierBoost : 1) * sensitivityMultiplier * zoomOutDamping
-  const exponentCap = wheelZoomExponentCap * capMultiplier * (isZoomOut ? 0.74 : 1)
+  const sensitivity = wheelZoomExponent * (isModifierZoom ? wheelZoomModifierBoost : 1) * zoomOutDamping
+  const exponentCap = wheelZoomExponentCap * (isZoomOut ? 0.74 : 1)
   const exponent = Math.max(
     -exponentCap,
     Math.min(exponentCap, -normalizedDelta * sensitivity)

package/package.json

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