@andespindola/brainlink 0.1.0-beta.114 → 0.1.0-beta.116

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

@@ -7,61 +7,13 @@ const largeGraphEdgeRenderLimit = 120000
 const renderNodeBudget = 900
 const zoomedMassiveRenderNodeBudget = 2200
 const renderEdgeBudget = 2400
-const clusterActivationNodeThreshold = 600
-const clusterZoomThreshold = 0.18
-const macroGalaxyZoomThreshold = 0.012
-const macroGalaxyEnterHysteresis = 0.86
-const macroGalaxyExitHysteresis = 1.24
-const galaxyDiscoveryEnabled = false
 const massiveAutoFitMacroScale = 0.018
-const defaultMacroScale = 0.018
-const clusterCellPixelSize = 64
 const minNodePixelRadius = 2.3
 const viewportPaddingPx = 280
 const worldCoordinateLimit = 5_000_000
 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
 const meshEdgeMinBudget = 140
 const meshEdgeMaxBudget = 1400
@@ -77,11 +29,6 @@ const zoomAnimationSlowLerp = 0.18
 const zoomAnimationFastLerp = 0.36
 const zoomAnimationScaleSnap = 0.00008
 const zoomAnimationPositionSnap = 0.14
-const bloomZoomFocusMaxScreenDistance = 260
-const bloomZoomFocusFarStrength = 0.66
-const bloomZoomFocusNearStrength = 0.34
-const bloomCameraParallaxNearStrength = 0.2
-const bloomCameraParallaxFarStrength = 0.06
 const physicsDragFrameIntervalMs = 16
 const physicsIdleFrameIntervalMs = 78
 const physicsLargeGraphIdleFrameIntervalMs = 108
@@ -95,8 +42,6 @@ const state = {
   visibleEdges: [],
   renderNodes: [],
   renderEdges: [],
-  renderClusters: [],
-  renderClusterEdges: [],
   renderNodeDepthProjectionById: new Map(),
   nodeDegrees: new Map(),
   selected: null,
@@ -122,26 +67,12 @@ const state = {
   lastViewportKey: '',
   visibleNodeSpatial: { cellSize: 220, minX: 0, minY: 0, maxX: 0, maxY: 0, buckets: new Map() },
   visibleEdgeByNode: new Map(),
-  ecosystemClusters: [],
-  ecosystemClustersBySize: new Map(),
-  ecosystemNodeClusterBySize: new Map(),
-  ecosystemLevelSizes: [],
-  ecosystemLevelIndexBySize: new Map(),
-  ecosystemHubNodeIds: new Set(),
-  ecosystemExpansionLevels: [],
-  ecosystemBaseSize: ecosystemLevelNodeCap,
-  ecosystemHubCluster: null,
-  macroCenter: { x: 0, y: 0 },
-  macroRepresentative: null,
   primaryHub: null,
-  hubNeighborDistance: Number.POSITIVE_INFINITY,
   filterWorker: null,
   filterReady: false,
   lastHoverHitAt: 0,
   lastManualZoomAt: 0,
   lastZoomFocus: { x: 0, y: 0, at: 0 },
-  macroViewActive: false,
-  ecosystemViewActive: false,
   depthProjectionActive: false,
   zoomTransition: {
     active: false,
@@ -573,47 +504,6 @@ const filteredNodes = () => {
   return withPersistentHubNodes(localFilteredNodes(query))
 }
 
-const resolveMacroRepresentative = (nodes) => {
-  if (nodes.length === 0) {
-    return null
-  }
-
-  const hubCandidate = state.primaryHub && nodes.some(node => node.id === state.primaryHub.id)
-    ? state.primaryHub
-    : null
-  let best = hubCandidate ?? nodes[0]
-  let bestDegree = state.nodeDegrees.get(best.id) ?? 0
-
-  for (let index = 1; index < nodes.length; index += 1) {
-    const node = nodes[index]
-    const degree = state.nodeDegrees.get(node.id) ?? 0
-    if (degree > bestDegree) {
-      best = node
-      bestDegree = degree
-    }
-  }
-
-  return best
-}
-
-const nearestHubNeighborDistance = (hub, nodes) => {
-  if (!hub || nodes.length <= 1) {
-    return Number.POSITIVE_INFINITY
-  }
-
-  let minimum = Number.POSITIVE_INFINITY
-  for (let index = 0; index < nodes.length; index += 1) {
-    const node = nodes[index]
-    if (node.id === hub.id) continue
-    const distance = Math.hypot(node.x - hub.x, node.y - hub.y)
-    if (distance < minimum) {
-      minimum = distance
-    }
-  }
-
-  return minimum
-}
-
 const isDominantHub = (hub, nodeCount = state.visibleNodes.length) => {
   if (!hub || nodeCount <= 0) {
     return false
@@ -641,39 +531,6 @@ const recomputeVisibility = () => {
   state.visibleEdgeByNode = createVisibleEdgeLookup(limitedEdges)
   const primaryHub = rankedHubNodes()[0] ?? null
   state.primaryHub = primaryHub
-  state.hubNeighborDistance = nearestHubNeighborDistance(primaryHub, nodes)
-  const bounds = graphBounds(nodes)
-  const macroHub = isDominantHub(primaryHub, nodes.length) ? primaryHub : null
-  state.macroCenter = bounds
-    ? {
-      x: macroHub ? macroHub.x : (bounds.minX + bounds.maxX) / 2,
-      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.macroRepresentative = resolveMacroRepresentative(nodes)
   markRenderDirty()
 }
 
@@ -778,700 +635,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) {
-    return cursorPoint
-  }
-  const now = performance.now()
-  if (now - state.lastZoomFocus.at <= 1800) {
-    return { x: state.lastZoomFocus.x, y: state.lastZoomFocus.y }
-  }
-  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 effectiveAnchor = applyBloomCameraParallax(anchor)
-  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 - effectiveAnchor.x, cluster.y - effectiveAnchor.y)
-    const radialOffset = cluster.isHub ? 0 : Math.min(320, radialDistance * ecosystemDepthRadialGain)
-    const orbitalOffset = cluster.isHub
-      ? 0
-      : Math.sin(Math.atan2(cluster.y - effectiveAnchor.y, cluster.x - effectiveAnchor.x) * 2.2) * ecosystemDepthOrbitalMaxOffset
-    const depth = Math.max(0, baseDepth + radialOffset + orbitalOffset)
-    const projected = projectEcosystemPoint(cluster.x, cluster.y, depth, effectiveAnchor)
-    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
@@ -1620,128 +789,13 @@ const cursorWorldPoint = () => {
   return screenToWorldPoint(screenX, screenY)
 }
 
-const bloomZoomFocusStrength = (scale) => {
-  if (scale <= 0.08) return bloomZoomFocusFarStrength
-  if (scale <= 0.2) return 0.58
-  if (scale <= 0.45) return 0.5
-  if (scale <= 0.9) return 0.42
-  return bloomZoomFocusNearStrength
-}
-
-const bloomCameraParallaxStrength = (scale) => {
-  if (scale <= 0.08) return bloomCameraParallaxNearStrength
-  if (scale <= 0.2) return 0.16
-  if (scale <= 0.45) return 0.12
-  return bloomCameraParallaxFarStrength
-}
-
-const screenPointForWorld = (worldX, worldY) => ({
-  x: worldX * state.transform.scale + state.transform.x,
-  y: worldY * state.transform.scale + state.transform.y
-})
-
-const bloomZoomFocusCandidate = (screenX, screenY) => {
-  const candidates = [state.hovered, state.selected, state.primaryHub].filter(Boolean)
-  if (candidates.length === 0) {
-    return null
-  }
-
-  let bestNode = null
-  let bestDistance = Number.POSITIVE_INFINITY
-  for (let index = 0; index < candidates.length; index += 1) {
-    const node = candidates[index]
-    const point = screenPointForWorld(nodeRenderX(node), nodeRenderY(node))
-    const distance = Math.hypot(point.x - screenX, point.y - screenY)
-    if (distance < bestDistance) {
-      bestDistance = distance
-      bestNode = node
-    }
-  }
-
-  if (!bestNode) {
-    return null
-  }
-
-  const scale = state.transform.scale
-  const allowDistance = scale <= 0.16 ? bloomZoomFocusMaxScreenDistance * 1.7 : bloomZoomFocusMaxScreenDistance
-  if (bestDistance > allowDistance) {
-    return null
-  }
-
-  return {
-    x: nodeRenderX(bestNode),
-    y: nodeRenderY(bestNode)
-  }
-}
-
-const resolveZoomAnchorWorldPoint = (screenX, screenY, source) => {
-  const cursorPoint = screenToWorldPoint(screenX, screenY)
-  if (source !== 'wheel') {
-    return cursorPoint
-  }
-
-  const focusCandidate = bloomZoomFocusCandidate(screenX, screenY)
-  if (!focusCandidate) {
-    return cursorPoint
-  }
-
-  const strength = bloomZoomFocusStrength(state.transform.scale)
-  return {
-    x: cursorPoint.x + (focusCandidate.x - cursorPoint.x) * strength,
-    y: cursorPoint.y + (focusCandidate.y - cursorPoint.y) * strength
-  }
-}
-
-const applyBloomCameraParallax = (anchor) => {
-  const cursorPoint = cursorWorldPoint()
-  if (!cursorPoint) {
-    return anchor
-  }
-
-  const strength = bloomCameraParallaxStrength(state.transform.scale)
-  return {
-    x: anchor.x + (cursorPoint.x - anchor.x) * strength,
-    y: anchor.y + (cursorPoint.y - anchor.y) * strength
-  }
-}
+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
-}
-
-const shouldRenderMacroGalaxyView = () => {
-  if (!galaxyDiscoveryEnabled) {
-    state.macroViewActive = false
-    return false
-  }
-  if (state.visibleNodes.length <= 1) {
-    state.macroViewActive = false
-    return false
-  }
-
-  const enterThreshold = macroGalaxyZoomThreshold * macroGalaxyEnterHysteresis
-  const exitThreshold = macroGalaxyZoomThreshold * macroGalaxyExitHysteresis
-  const shouldRender = state.macroViewActive
-    ? state.transform.scale <= exitThreshold
-    : state.transform.scale <= enterThreshold
-  state.macroViewActive = shouldRender
-  return shouldRender
-}
-
 const mergeUniqueNodes = (leftNodes, rightNodes, limit) => {
   const merged = []
   const ids = new Set()
@@ -1917,20 +971,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) => {
@@ -2113,10 +1158,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) {
@@ -2193,7 +1234,7 @@ const drawGraphLabels = nodes => {
 }
 
 const drawAcceleratedGraph = (width, height, drawEdges) => {
-  if (!webGlRenderer || state.renderClusters.length > 0 || shouldProjectRenderNodesInDepth()) {
+  if (!webGlRenderer) {
     return false
   }
 
@@ -2563,32 +1604,15 @@ const zoomCapByNodeCount = (nodeCount) => {
   return zoomRange.max
 }
 
-const zoomCapByHubDistance = (distance) => {
-  if (!Number.isFinite(distance) || distance <= 0) {
-    return zoomRange.max
-  }
-
-  const rect = canvas.getBoundingClientRect()
-  const viewportWidth = Math.max(rect.width, 320)
-  const viewportHeight = Math.max(rect.height, 320)
-  const reference = Math.max(220, Math.min(viewportWidth, viewportHeight) * zoomCapTargetViewportShare)
-  return Math.max(0.3, Math.min(zoomRange.max, reference / 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) => {
   if (nodeCount > massiveGraphNodeThreshold) return 0.018
   if (nodeCount > largeGraphNodeThreshold) return 0.0032
-  if (nodeCount > ecosystemActivationNodeThreshold) return 0.001
+  if (nodeCount > 1000) return 0.001
   return zoomRange.min
 }
 
@@ -2700,56 +1724,6 @@ const autoFitScaleRangeByNodeCount = nodeCount => {
   return { min: 0.0085, max: 0.36 }
 }
 
-const macroFaceToFaceScale = (nodeCount, hubDistance) => {
-  if (!Number.isFinite(hubDistance) || hubDistance <= 0 || nodeCount <= ecosystemActivationNodeThreshold) {
-    return 0
-  }
-
-  const rect = canvas.getBoundingClientRect()
-  const viewportReference = Math.max(320, Math.min(rect.width, rect.height))
-  const share = nodeCount > massiveGraphNodeThreshold ? 0.2 : 0.17
-  const targetPx = Math.max(24, viewportReference * share)
-  return targetPx / hubDistance
-}
-
-const nearestClusterNeighborDistance = (clusters) => {
-  if (!Array.isArray(clusters) || clusters.length < 2) {
-    return Number.POSITIVE_INFINITY
-  }
-
-  let nearestDistance = Number.POSITIVE_INFINITY
-  for (let index = 0; index < clusters.length; index += 1) {
-    const source = clusters[index]
-    for (let neighborIndex = index + 1; neighborIndex < clusters.length; neighborIndex += 1) {
-      const target = clusters[neighborIndex]
-      const distance = Math.hypot(source.x - target.x, source.y - target.y)
-      if (distance > 0 && distance < nearestDistance) {
-        nearestDistance = distance
-      }
-    }
-  }
-
-  return nearestDistance
-}
-
-const macroEcosystemFaceScale = (nodeCount) => {
-  if (nodeCount <= ecosystemActivationNodeThreshold) {
-    return 0
-  }
-
-  const baseClusters = state.ecosystemClustersBySize.get(state.ecosystemBaseSize) ?? state.ecosystemClusters
-  const siblingClusters = baseClusters.filter(cluster => !cluster.isHub)
-  const nearestDistance = nearestClusterNeighborDistance(siblingClusters)
-  if (!Number.isFinite(nearestDistance) || nearestDistance <= 0) {
-    return 0
-  }
-
-  const rect = canvas.getBoundingClientRect()
-  const viewportReference = Math.max(320, Math.min(rect.width, rect.height))
-  const targetShare = nodeCount > massiveGraphNodeThreshold ? 0.28 : 0.24
-  const targetPx = Math.max(30, viewportReference * targetShare)
-  return targetPx / nearestDistance
-}
 const fitView = (options = { useFiltered: true, macro: false, preferHubCenter: true }) => {
   const rect = canvas.getBoundingClientRect()
   const width = Math.max(rect.width, 320)
@@ -2782,21 +1756,9 @@ const fitView = (options = { useFiltered: true, macro: false, preferHubCenter: t
   const biasedScale = clampScale(fitScale * fitScaleBiasByNodeCount(nodes.length))
   const scaleRange = autoFitScaleRangeByNodeCount(nodes.length)
   const baselineScale = clampScale(Math.min(scaleRange.max, Math.max(scaleRange.min, biasedScale)))
-  const macroScale = nodes.length > massiveGraphNodeThreshold ? massiveAutoFitMacroScale : defaultMacroScale
-  const scale = options.macro && nodes.length > 1
-    ? clampScale(Math.min(baselineScale, macroScale))
-    : nodes.length > massiveGraphNodeThreshold
-      ? clampScale(Math.min(baselineScale, massiveAutoFitMacroScale))
-      : baselineScale
-  const macroFloorScale = options.macro
-    ? clampScale(Math.max(
-      macroFaceToFaceScale(nodes.length, state.hubNeighborDistance),
-      macroEcosystemFaceScale(nodes.length)
-    ))
-    : 0
-  const resolvedScale = options.macro
-    ? clampScale(Math.max(scale, macroFloorScale))
-    : scale
+  const resolvedScale = nodes.length > massiveGraphNodeThreshold
+    ? clampScale(Math.min(baselineScale, massiveAutoFitMacroScale))
+    : baselineScale
   const hubCenter =
     options.preferHubCenter && isDominantHub(state.primaryHub, nodes.length) && nodes.some((node) => node.id === state.primaryHub.id)
       ? state.primaryHub
@@ -2815,7 +1777,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
@@ -3187,9 +2149,6 @@ const settleNeighborhoodAroundNode = (dragNode) => {
 
 const hitNode = point => {
   computeRenderVisibility()
-  if (state.renderClusters.length > 0) {
-    return null
-  }
   const hitScaleFloor = state.nodes.length > massiveGraphNodeThreshold
     ? 0.2
     : state.nodes.length > largeGraphNodeThreshold
@@ -3217,124 +2176,13 @@ const baseNodeRadius = node => {
 
 const nodeRadius = node => Math.max(baseNodeRadius(node), minNodePixelRadius / Math.max(state.transform.scale, 0.0001))
 
-const clusterRadiusPx = cluster => {
-  if (cluster.id === 'macro-galaxy') {
-    return 10
-  }
-  if (cluster.isHub) {
-    return 3.8
-  }
-  if (String(cluster.id).startsWith('ecosystem-')) {
-    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
-    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))
-}
-
-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 = applyBloomCameraParallax(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 = () => {
@@ -3390,68 +2238,6 @@ const viewportNodeStride = () => {
   return 8
 }
 
-const shouldRenderClusters = viewportNodes =>
-  state.transform.scale <= clusterZoomThreshold && viewportNodes.length >= clusterActivationNodeThreshold
-
-const clusterViewportNodes = viewportNodes => {
-  if (!shouldRenderClusters(viewportNodes)) {
-    return []
-  }
-
-  const worldCellSize = Math.max(clusterCellPixelSize / Math.max(state.transform.scale, 0.0001), 1)
-  const buckets = new Map()
-
-  for (let index = 0; index < viewportNodes.length; index += 1) {
-    const node = viewportNodes[index]
-    const keyX = Math.floor(node.x / worldCellSize)
-    const keyY = Math.floor(node.y / worldCellSize)
-    const key = keyX + ':' + keyY
-    const current = buckets.get(key)
-    if (current) {
-      current.count += 1
-      current.sumX += node.x
-      current.sumY += node.y
-      if ((state.nodeDegrees.get(node.id) ?? 0) > current.degree) {
-        current.representative = node
-        current.degree = state.nodeDegrees.get(node.id) ?? 0
-      }
-      continue
-    }
-
-    buckets.set(key, {
-      id: key,
-      count: 1,
-      sumX: node.x,
-      sumY: node.y,
-      representative: node,
-      degree: state.nodeDegrees.get(node.id) ?? 0
-    })
-  }
-
-  return Array.from(buckets.values())
-    .sort((left, right) => right.count - left.count)
-    .slice(0, Math.min(renderNodeBudget, 900))
-    .map((cluster) => ({
-      id: cluster.id,
-      x: cluster.sumX / Math.max(cluster.count, 1),
-      y: cluster.sumY / Math.max(cluster.count, 1),
-      count: cluster.count,
-      representative: cluster.representative
-    }))
-}
-
-const representativeNodesFromClusters = (clusters, limit) => {
-  const representatives = clusters
-    .map((cluster) => cluster.representative)
-    .filter((node) => Boolean(node))
-  const merged = mergeUniqueNodes(
-    representatives,
-    state.renderNodes ?? [],
-    Math.max(1, limit)
-  )
-  return ensureHubNodesInRenderedSet(merged)
-}
-
 const computeRenderVisibility = () => {
   if (!hasValidTransform()) {
     fitView({ useFiltered: true })
@@ -3469,56 +2255,9 @@ const computeRenderVisibility = () => {
   }
   state.lastViewportKey = viewportKey
   state.renderVisibilityDirty = false
-  state.renderClusterEdges = []
-
-  const shouldRenderMacroGalaxy = shouldRenderMacroGalaxyView()
-
-  if (shouldRenderMacroGalaxy) {
-    const viewportNodes = viewportNodesFromSpatialIndex(viewport)
-    const sourceNodes = viewportNodes.length > 0 ? viewportNodes : state.visibleNodes
-    const representative = state.primaryHub ?? state.macroRepresentative ?? sourceNodes[0] ?? null
-    if (representative) {
-      state.renderClusters = [
-        {
-          id: 'macro-galaxy',
-          x: state.macroCenter.x,
-          y: state.macroCenter.y,
-          count: sourceNodes.length,
-          representative
-        }
-      ]
-      state.renderNodes = [representative]
-    } else {
-      state.renderClusters = []
-      state.renderNodes = []
-    }
-    state.renderEdges = []
-    state.renderClusterEdges = []
-    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) {
     state.renderNodes = state.visibleNodes
-    state.renderClusters = []
-    state.renderClusterEdges = []
     const ids = new Set(state.renderNodes.map((node) => node.id))
     state.renderEdges = withMeshEdges(state.renderNodes, collectVisibleEdgesForNodes(ids))
     return
@@ -3569,9 +2308,6 @@ const computeRenderVisibility = () => {
       const sampledWithHubsIds = new Set(sampledNodes.map((node) => node.id))
       sampledEdges = collectVisibleEdgesForNodes(sampledWithHubsIds)
     }
-
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderNodes = sampledNodes
     state.renderEdges = withMeshEdges(sampledNodes, sampledEdges)
     return
@@ -3580,24 +2316,12 @@ const computeRenderVisibility = () => {
   if (state.transform.scale <= 0.0015) {
     const sampled = sampleVisibleNodes(Math.min(renderNodeBudget, 900))
     const sampledIds = new Set(sampled.map((node) => node.id))
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderNodes = sampled
     state.renderEdges = withMeshEdges(sampled, collectVisibleEdgesForNodes(sampledIds))
     return
   }
 
   const viewportNodes = viewportNodesFromSpatialIndex(viewport)
-  const clusters = clusterViewportNodes(viewportNodes)
-  if (clusters.length > 0) {
-    state.renderClusters = []
-    state.renderClusterEdges = []
-    state.renderNodes = representativeNodesFromClusters(clusters, Math.min(renderNodeBudget, 900))
-    state.renderEdges = []
-    return
-  }
-  state.renderClusters = []
-  state.renderClusterEdges = []
   const stride = viewportNodeStride()
   const picked = []
 
@@ -3620,8 +2344,6 @@ const computeRenderVisibility = () => {
     const fallbackNodes = fallbackViewportNodes()
     const fallbackIds = new Set(fallbackNodes.map((node) => node.id))
     state.renderNodes = fallbackNodes
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderEdges = withMeshEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
     return
   }
@@ -3636,8 +2358,6 @@ const computeRenderVisibility = () => {
   if (state.renderNodes.length === 0 && state.visibleNodes.length > 0) {
     const fallbackNodes = sampleVisibleNodes(Math.min(renderNodeBudget, 260))
     const fallbackIds = new Set(fallbackNodes.map((node) => node.id))
-    state.renderClusters = []
-    state.renderClusterEdges = []
     state.renderNodes = fallbackNodes
     state.renderEdges = withMeshEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
   }
@@ -3748,71 +2468,9 @@ const render = now => {
           : state.renderNodes.length > 500
             ? 0.05
             : 0
-  const drawEdges =
-    state.renderClusters.length === 0 &&
-    state.transform.scale >= minimumEdgeScale
+  const drawEdges = state.transform.scale >= minimumEdgeScale
   if (drawAcceleratedGraph(width, height, drawEdges)) {
     // WebGL handles the dense node/edge layer; the 2D canvas remains the interaction overlay.
-  } else if (state.renderClusters.length > 0) {
-    ctx.save()
-    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) {
-        const edge = state.renderClusterEdges[index]
-        const edgeOpacity = Math.min(clusterOpacity(edge.sourceCluster), clusterOpacity(edge.targetCluster))
-        if (edgeOpacity <= 0.01) {
-          continue
-        }
-        const depthScale = Math.min(clusterDepthScale(edge.sourceCluster), clusterDepthScale(edge.targetCluster))
-        const widthScale = 0.6 + depthScale * 0.9
-        ctx.beginPath()
-        ctx.moveTo(edge.sourceCluster.x, edge.sourceCluster.y)
-        ctx.lineTo(edge.targetCluster.x, edge.targetCluster.y)
-        ctx.lineWidth = (1.2 * widthScale) / safeScale
-        ctx.strokeStyle = 'rgba(153, 165, 181, ' + (edge.inferred ? 0.14 : 0.22) * edgeOpacity + ')'
-        ctx.stroke()
-      }
-    }
-    orderedClusters.forEach(cluster => {
-      const isMacro = cluster.id === 'macro-galaxy'
-      const isEcosystem = String(cluster.id).startsWith('ecosystem-')
-      const isHub = Boolean(cluster.isHub)
-      const opacity = clusterOpacity(cluster)
-      if (opacity <= 0.01) {
-        return
-      }
-      const radiusPx = clusterRadiusPx(cluster)
-      const radius = radiusPx / safeScale
-      const haloRadius = (radiusPx + (isMacro ? 8 : isHub ? 4 : isEcosystem ? 1.1 : 4)) / safeScale
-      ctx.globalAlpha = opacity
-      if (isHub || !isEcosystem || state.transform.scale >= ecosystemSubgraphScaleThreshold) {
-        ctx.beginPath()
-        ctx.arc(cluster.x, cluster.y, haloRadius, 0, Math.PI * 2)
-        ctx.fillStyle = isMacro ? 'rgba(243, 247, 251, 0.28)' : graphTheme.nodeHalo
-        ctx.fill()
-      }
-      ctx.beginPath()
-      ctx.arc(cluster.x, cluster.y, radius, 0, Math.PI * 2)
-      ctx.fillStyle = isMacro ? '#f3f7fb' : graphTheme.node
-      ctx.fill()
-      ctx.lineWidth = (isEcosystem && !isHub ? 0.7 : 1.4) / safeScale
-      ctx.strokeStyle = isMacro ? '#ffffff' : graphTheme.nodeStroke
-      ctx.stroke()
-      if (isMacro && cluster.representative?.title) {
-        ctx.fillStyle = '#edf2f7'
-        ctx.font = 12 / safeScale + 'px Inter, system-ui, sans-serif'
-        ctx.textAlign = 'center'
-        ctx.textBaseline = 'top'
-        ctx.fillText(cluster.representative.title.slice(0, 28), cluster.x, cluster.y + (radiusPx + 9) / safeScale)
-      }
-      ctx.globalAlpha = 1
-      // Keep cluster markers minimal and faster to draw on large graphs.
-    })
-    ctx.restore()
   } else {
     ctx.save()
     ctx.translate(state.transform.x, state.transform.y)
@@ -3823,7 +2481,7 @@ const render = now => {
     drawGraphNodes()
     ctx.restore()
   }
-  if (state.renderNodes.length === 0 && state.renderClusters.length === 0) {
+  if (state.renderNodes.length === 0) {
     ctx.fillStyle = '#99a5b5'
     ctx.font = '12px Inter, system-ui, sans-serif'
     ctx.textAlign = 'center'
@@ -3953,7 +2611,7 @@ const zoomAtPoint = (screenX, screenY, factor, source = 'generic') => {
     state.zoomTransition.screenX === screenX &&
     state.zoomTransition.screenY === screenY
       ? { x: state.zoomTransition.worldX, y: state.zoomTransition.worldY }
-      : resolveZoomAnchorWorldPoint(screenX, screenY, source)
+      : resolveZoomAnchorWorldPoint(screenX, screenY)
   const worldX = worldPointAtCursor.x
   const worldY = worldPointAtCursor.y
   state.lastZoomFocus = {
@@ -3983,18 +2641,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)