@andespindola/brainlink 0.1.0-beta.11 → 0.1.0-beta.111

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

@@ -1,13 +1,86 @@
 export const createClientJs = () => `const canvas = document.getElementById('graph')
+const glCanvas = document.getElementById('graphGl')
 const ctx = canvas.getContext('2d')
 const largeGraphNodeThreshold = 4000
-const largeGraphEdgeRenderLimit = 16000
+const massiveGraphNodeThreshold = 20000
+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.006
+const defaultMacroScale = 0.006
+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 ecosystemSubgraphScaleThreshold = 0.18
+const ecosystemMicroScaleThreshold = 0.08
+const ecosystemFocusedParentLimit = 2
+const ecosystemDepthNear = 80
+const ecosystemDepthFar = 2600
+const ecosystemDepthPerspective = 620
+const ecosystemDepthTiltY = 0.24
+const ecosystemDepthYaw = 0.22
+const ecosystemDepthPitch = 0.16
+const ecosystemDepthRadialGain = 0.09
+const ecosystemDepthOrbitalMaxOffset = 160
+const ecosystemDepthMinScale = 0.24
+const ecosystemDepthOpacityFloor = 0.2
+const graphDepthNear = 40
+const graphDepthFar = 560
+const graphDepthPerspective = 760
+const graphDepthYaw = 0.2
+const graphDepthPitch = 0.12
+const graphDepthRadialGain = 0.08
+const graphDepthMinScale = 0.58
+const graphDepthOpacityFloor = 0.42
+const graphDepthEdgeOpacityFloor = 0.24
+const graphDepthProjectionNodeThreshold = 120
+const graphDepthProjectionNodeCap = 980
+const graphDepthProjectionMinScale = 0.08
+const graphDepthProjectionMaxScale = 0.95
+const zoomRecoveryGuardMs = 4200
+const zoomCapTargetViewportShare = 0.72
+const meshEdgeScaleThreshold = 0.09
+const meshEdgeMinBudget = 140
+const meshEdgeMaxBudget = 1400
+const layeredCoreScaleThreshold = 0.55
+const dragNeighborhoodMaxAffected = 180
+const dragSettleRounds = 3
+const wheelZoomExponent = 0.0009
+const wheelZoomExponentCap = 0.035
+const wheelZoomModifierBoost = 1.08
+const physicsDragFrameIntervalMs = 16
+const physicsIdleFrameIntervalMs = 78
+const physicsLargeGraphIdleFrameIntervalMs = 108
+const physicsStepDeltaCapMs = 96
 const state = {
   graph: { nodes: [], edges: [] },
   nodes: [],
+  nodeById: new Map(),
   edges: [],
   visibleNodes: [],
   visibleEdges: [],
+  renderNodes: [],
+  renderEdges: [],
+  renderClusters: [],
+  renderClusterEdges: [],
+  renderNodeDepthProjectionById: new Map(),
   nodeDegrees: new Map(),
   selected: null,
   hovered: null,
@@ -18,9 +91,39 @@ const state = {
   nodeDetails: new Map(),
   transform: { x: 0, y: 0, scale: 1 },
   pointer: { x: 0, y: 0, down: false, dragNode: null, moved: false },
+  cursor: { x: 0, y: 0, inCanvas: false },
   graphSignature: '',
   graphStatus: '',
-  last: performance.now()
+  graphTotals: { nodes: 0, edges: 0 },
+  viewport: { width: 320, height: 320 },
+  last: performance.now(),
+  lastPhysicsAt: performance.now(),
+  physicsRestFrames: 0,
+  offscreenFrameCount: 0,
+  recoveringViewport: false,
+  renderVisibilityDirty: true,
+  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
 }
 
 const byId = id => document.getElementById(id)
@@ -51,11 +154,54 @@ const elements = {
 }
 
 const zoomRange = {
-  min: 0.05,
+  min: 0.0002,
   max: 4.5
 }
 
-const agentQuery = () => state.agentId ? '?agent=' + encodeURIComponent(state.agentId) : ''
+const initialAgentFromUrl = (() => {
+  try {
+    const raw = new URL(window.location.href).searchParams.get('agent')
+    const value = raw?.trim() ?? ''
+    return value.length > 0 ? value : ''
+  } catch {
+    return ''
+  }
+})()
+
+const selectedAgentStorageKey = 'brainlink:selected-agent'
+
+const readStoredAgent = () => {
+  try {
+    const value = window.localStorage.getItem(selectedAgentStorageKey)?.trim() ?? ''
+    return value.length > 0 ? value : ''
+  } catch {
+    return ''
+  }
+}
+
+const writeStoredAgent = (agentId) => {
+  try {
+    if (!agentId) {
+      window.localStorage.removeItem(selectedAgentStorageKey)
+      return
+    }
+    window.localStorage.setItem(selectedAgentStorageKey, agentId)
+  } catch {}
+}
+
+const syncAgentInUrl = (agentId) => {
+  try {
+    const url = new URL(window.location.href)
+    if (agentId && agentId.trim().length > 0) {
+      url.searchParams.set('agent', agentId)
+    } else {
+      url.searchParams.delete('agent')
+    }
+    window.history.replaceState({}, '', url.toString())
+  } catch {}
+}
+
+const agentQuery = (separator = '?') => state.agentId ? separator + 'agent=' + encodeURIComponent(state.agentId) : ''
 
 const setGraphStatus = text => {
   state.graphStatus = text
@@ -78,6 +224,238 @@ const graphTheme = {
   label: '#edf2f7'
 }
 
+const parseRgb = color => {
+  const normalized = color.trim()
+  if (normalized.startsWith('#')) {
+    const value = normalized.slice(1)
+    const expanded = value.length === 3
+      ? value.split('').map(char => char + char).join('')
+      : value
+    const parsed = Number.parseInt(expanded, 16)
+    return [
+      ((parsed >> 16) & 255) / 255,
+      ((parsed >> 8) & 255) / 255,
+      (parsed & 255) / 255
+    ]
+  }
+
+  const match = normalized.match(/rgba?\\(([^)]+)\\)/)
+  if (!match) return [1, 1, 1]
+  const parts = match[1].split(',').map(part => Number.parseFloat(part.trim()))
+  return [
+    Math.max(0, Math.min(1, (parts[0] ?? 255) / 255)),
+    Math.max(0, Math.min(1, (parts[1] ?? 255) / 255)),
+    Math.max(0, Math.min(1, (parts[2] ?? 255) / 255))
+  ]
+}
+
+const rgba = (color, alpha = 1) => {
+  const [red, green, blue] = parseRgb(color)
+  return [red, green, blue, Math.max(0, Math.min(1, alpha))]
+}
+
+const createShader = (gl, type, source) => {
+  const shader = gl.createShader(type)
+  if (!shader) return null
+  gl.shaderSource(shader, source)
+  gl.compileShader(shader)
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    gl.deleteShader(shader)
+    return null
+  }
+  return shader
+}
+
+const createProgram = (gl, vertexSource, fragmentSource) => {
+  const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexSource)
+  const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentSource)
+  if (!vertexShader || !fragmentShader) return null
+  const program = gl.createProgram()
+  if (!program) return null
+  gl.attachShader(program, vertexShader)
+  gl.attachShader(program, fragmentShader)
+  gl.linkProgram(program)
+  gl.deleteShader(vertexShader)
+  gl.deleteShader(fragmentShader)
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    gl.deleteProgram(program)
+    return null
+  }
+  return program
+}
+
+const createWebGlRenderer = targetCanvas => {
+  if (!targetCanvas) return null
+
+  const gl = targetCanvas.getContext('webgl2', { alpha: true, antialias: true }) ||
+    targetCanvas.getContext('webgl', { alpha: true, antialias: true })
+  if (!gl) return null
+
+  const lineProgram = createProgram(
+    gl,
+    'attribute vec2 a_position; uniform vec2 u_resolution; void main() { vec2 zeroToOne = a_position / u_resolution; vec2 clip = zeroToOne * 2.0 - 1.0; gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0); }',
+    'precision mediump float; uniform vec4 u_color; void main() { gl_FragColor = u_color; }'
+  )
+  const pointProgram = createProgram(
+    gl,
+    'attribute vec2 a_position; attribute float a_size; uniform vec2 u_resolution; void main() { vec2 zeroToOne = a_position / u_resolution; vec2 clip = zeroToOne * 2.0 - 1.0; gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0); gl_PointSize = a_size; }',
+    'precision mediump float; uniform vec4 u_color; void main() { vec2 center = gl_PointCoord - vec2(0.5); float distanceFromCenter = length(center); if (distanceFromCenter > 0.5) discard; float edge = smoothstep(0.5, 0.42, distanceFromCenter); gl_FragColor = vec4(u_color.rgb, u_color.a * edge); }'
+  )
+
+  if (!lineProgram || !pointProgram) return null
+
+  const lineBuffer = gl.createBuffer()
+  const pointPositionBuffer = gl.createBuffer()
+  const pointSizeBuffer = gl.createBuffer()
+  if (!lineBuffer || !pointPositionBuffer || !pointSizeBuffer) return null
+
+  const linePositionLocation = gl.getAttribLocation(lineProgram, 'a_position')
+  const lineResolutionLocation = gl.getUniformLocation(lineProgram, 'u_resolution')
+  const lineColorLocation = gl.getUniformLocation(lineProgram, 'u_color')
+  const pointPositionLocation = gl.getAttribLocation(pointProgram, 'a_position')
+  const pointSizeLocation = gl.getAttribLocation(pointProgram, 'a_size')
+  const pointResolutionLocation = gl.getUniformLocation(pointProgram, 'u_resolution')
+  const pointColorLocation = gl.getUniformLocation(pointProgram, 'u_color')
+
+  gl.enable(gl.BLEND)
+  gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
+
+  const setViewport = (width, height) => {
+    gl.viewport(0, 0, targetCanvas.width, targetCanvas.height)
+    return [targetCanvas.width / Math.max(width, 1), targetCanvas.height / Math.max(height, 1)]
+  }
+
+  const screenPoint = (node, ratioX, ratioY) => [
+    (node.x * state.transform.scale + state.transform.x) * ratioX,
+    (node.y * state.transform.scale + state.transform.y) * ratioY
+  ]
+
+  const clear = (width, height) => {
+    setViewport(width, height)
+    gl.clearColor(0, 0, 0, 0)
+    gl.clear(gl.COLOR_BUFFER_BIT)
+  }
+
+  const drawLines = (edges, color, width, height) => {
+    if (edges.length === 0) return
+    const [ratioX, ratioY] = setViewport(width, height)
+    const positions = new Float32Array(edges.length * 4)
+    for (let index = 0; index < edges.length; index += 1) {
+      const edge = edges[index]
+      const source = screenPoint(edge.sourceNode, ratioX, ratioY)
+      const target = screenPoint(edge.targetNode, ratioX, ratioY)
+      const offset = index * 4
+      positions[offset] = source[0]
+      positions[offset + 1] = source[1]
+      positions[offset + 2] = target[0]
+      positions[offset + 3] = target[1]
+    }
+
+    gl.useProgram(lineProgram)
+    gl.bindBuffer(gl.ARRAY_BUFFER, lineBuffer)
+    gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STREAM_DRAW)
+    gl.enableVertexAttribArray(linePositionLocation)
+    gl.vertexAttribPointer(linePositionLocation, 2, gl.FLOAT, false, 0, 0)
+    gl.uniform2f(lineResolutionLocation, targetCanvas.width, targetCanvas.height)
+    gl.uniform4fv(lineColorLocation, color)
+    gl.lineWidth(1)
+    gl.drawArrays(gl.LINES, 0, edges.length * 2)
+  }
+
+  const drawPoints = (nodes, color, sizeForNode, width, height) => {
+    if (nodes.length === 0) return
+    const [ratioX, ratioY] = setViewport(width, height)
+    const positions = new Float32Array(nodes.length * 2)
+    const sizes = new Float32Array(nodes.length)
+    for (let index = 0; index < nodes.length; index += 1) {
+      const node = nodes[index]
+      const point = screenPoint(node, ratioX, ratioY)
+      const offset = index * 2
+      positions[offset] = point[0]
+      positions[offset + 1] = point[1]
+      sizes[index] = sizeForNode(node) * ((ratioX + ratioY) / 2)
+    }
+
+    gl.useProgram(pointProgram)
+    gl.bindBuffer(gl.ARRAY_BUFFER, pointPositionBuffer)
+    gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STREAM_DRAW)
+    gl.enableVertexAttribArray(pointPositionLocation)
+    gl.vertexAttribPointer(pointPositionLocation, 2, gl.FLOAT, false, 0, 0)
+    gl.bindBuffer(gl.ARRAY_BUFFER, pointSizeBuffer)
+    gl.bufferData(gl.ARRAY_BUFFER, sizes, gl.STREAM_DRAW)
+    gl.enableVertexAttribArray(pointSizeLocation)
+    gl.vertexAttribPointer(pointSizeLocation, 1, gl.FLOAT, false, 0, 0)
+    gl.uniform2f(pointResolutionLocation, targetCanvas.width, targetCanvas.height)
+    gl.uniform4fv(pointColorLocation, color)
+    gl.drawArrays(gl.POINTS, 0, nodes.length)
+  }
+
+  return { clear, drawLines, drawPoints }
+}
+
+const webGlRenderer = createWebGlRenderer(glCanvas)
+
+const initFilterWorker = () => {
+  if (typeof Worker === 'undefined') {
+    return
+  }
+  try {
+    const worker = new Worker('/app-worker.js')
+    worker.onmessage = event => {
+      const payload = event.data
+      if (!payload || typeof payload !== 'object') return
+
+      if (payload.type === 'ready') {
+        state.filterReady = true
+        if (state.nodes.length > 0) {
+          worker.postMessage({
+            type: 'load-nodes',
+            nodes: state.nodes.map(node => ({
+              id: node.id,
+              title: node.title,
+              path: node.path || '',
+              tags: Array.isArray(node.tags) ? node.tags : []
+            }))
+          })
+        }
+        return
+      }
+
+      if (payload.type === 'filter-result') {
+        const token = payload.token
+        if (token !== state.contentFilter.token) {
+          return
+        }
+
+        const ids = Array.isArray(payload.ids) ? payload.ids.filter(id => typeof id === 'string') : []
+        state.contentFilter.query = normalizeQuery(state.query)
+        state.contentFilter.ids = new Set(ids)
+        recomputeVisibility()
+      }
+    }
+    state.filterWorker = worker
+  } catch {
+    state.filterWorker = null
+    state.filterReady = false
+  }
+}
+
+const pushNodesToFilterWorker = () => {
+  if (!state.filterWorker || !state.filterReady) {
+    return
+  }
+
+  state.filterWorker.postMessage({
+    type: 'load-nodes',
+    nodes: state.nodes.map(node => ({
+      id: node.id,
+      title: node.title,
+      path: node.path || '',
+      tags: Array.isArray(node.tags) ? node.tags : []
+    }))
+  })
+}
+
 const resize = () => {
   const rect = canvas.getBoundingClientRect()
   const width = Math.max(rect.width, 320)
@@ -85,26 +463,138 @@ const resize = () => {
   const ratio = window.devicePixelRatio || 1
   canvas.width = Math.floor(width * ratio)
   canvas.height = Math.floor(height * ratio)
+  if (glCanvas) {
+    glCanvas.width = Math.floor(width * ratio)
+    glCanvas.height = Math.floor(height * ratio)
+  }
+  state.viewport = { width, height }
   ctx.setTransform(ratio, 0, 0, ratio, 0, 0)
+  markRenderDirty()
 }
 
 const normalizeQuery = value => value.trim().toLowerCase()
+const hubNodeRetentionLimit = 2
+const hubNodePattern = /\b(memory\s*hub|knowledge\s*hub|hub|moc|map|memory\s*map|mapa)\b/i
+const memoryHubPathPattern = /\bmemory[-_\s]*hub\b/i
+
+const hubNodeScore = node => {
+  const title = node.title.trim().toLowerCase()
+  if (title === 'memory hub') return 6
+  if (title === 'knowledge hub') return 5
+  if (memoryHubPathPattern.test(node.path || '')) return 4
+  if (node.tags.some(tag => tag.trim().toLowerCase() === 'memory-hub')) return 3
+  if (/\bmoc\b/i.test(node.title)) return 2
+  return hubNodePattern.test(node.title) || hubNodePattern.test(node.path || '') || node.tags.some(tag => hubNodePattern.test(tag))
+    ? 1
+    : 0
+}
 
 const localFilteredNodes = query =>
   state.nodes.filter(node =>
     node.title.toLowerCase().includes(query) ||
-    node.path.toLowerCase().includes(query) ||
+    (node.path || '').toLowerCase().includes(query) ||
     node.tags.some(tag => tag.toLowerCase().includes(query))
   )
 
+const rankedHubNodes = () => {
+  if (state.nodes.length === 0) {
+    return []
+  }
+
+  const byTitleAndDegree = [...state.nodes]
+    .filter(node => hubNodeScore(node) > 0)
+    .sort((left, right) => {
+      const byHubScore = hubNodeScore(right) - hubNodeScore(left)
+      if (byHubScore !== 0) return byHubScore
+      const byDegree = (state.nodeDegrees.get(right.id) ?? 0) - (state.nodeDegrees.get(left.id) ?? 0)
+      if (byDegree !== 0) return byDegree
+      return left.title.localeCompare(right.title)
+    })
+
+  if (byTitleAndDegree.length > 0) {
+    return byTitleAndDegree.slice(0, hubNodeRetentionLimit)
+  }
+
+  return [...state.nodes]
+    .sort((left, right) => {
+      const byDegree = (state.nodeDegrees.get(right.id) ?? 0) - (state.nodeDegrees.get(left.id) ?? 0)
+      if (byDegree !== 0) return byDegree
+      return left.title.localeCompare(right.title)
+    })
+    .slice(0, 1)
+}
+
+const withPersistentHubNodes = nodes => {
+  if (nodes.length === 0) {
+    return rankedHubNodes()
+  }
+
+  const ids = new Set(nodes.map(node => node.id))
+  const hubsToKeep = rankedHubNodes().filter(node => !ids.has(node.id))
+  return nodes.concat(hubsToKeep)
+}
+
 const filteredNodes = () => {
   const query = normalizeQuery(state.query)
   if (!query) return state.nodes
   if (state.contentFilter.query === query && state.contentFilter.ids instanceof Set) {
-    return state.nodes.filter(node => state.contentFilter.ids.has(node.id))
+    const matched = state.nodes.filter(node => state.contentFilter.ids.has(node.id))
+    return withPersistentHubNodes(matched)
+  }
+
+  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
   }
 
-  return localFilteredNodes(query)
+  const degree = state.nodeDegrees.get(hub.id) ?? 0
+  const minimumDegree = Math.max(18, Math.sqrt(nodeCount) * 1.8)
+  const degreeRatio = degree / Math.max(nodeCount, 1)
+  return degree >= minimumDegree || degreeRatio >= 0.035
 }
 
 const recomputeVisibility = () => {
@@ -117,13 +607,1881 @@ const recomputeVisibility = () => {
       .slice(0, largeGraphEdgeRenderLimit)
     : edges
 
-  state.visibleNodes = nodes
-  state.visibleEdges = limitedEdges
+  state.visibleNodes = nodes
+  state.visibleEdges = limitedEdges
+  state.visibleNodeSpatial = createSpatialIndex(nodes)
+  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()
+}
+
+const edgeWeight = edge => Number.isFinite(edge.weight) ? Math.max(1, edge.weight) : 1
+const markRenderDirty = () => {
+  state.renderVisibilityDirty = true
+}
+
+const createSpatialIndex = nodes => {
+  if (nodes.length === 0) {
+    return { cellSize: 220, minX: 0, minY: 0, maxX: 0, maxY: 0, buckets: new Map() }
+  }
+
+  const bounds = graphBounds(nodes)
+  if (!bounds) {
+    return { cellSize: 220, minX: 0, minY: 0, maxX: 0, maxY: 0, buckets: new Map() }
+  }
+
+  const targetNodesPerCell = 18
+  const approximateCellArea = Math.max((bounds.width * bounds.height) / Math.max(nodes.length / targetNodesPerCell, 1), 1)
+  const cellSize = Math.max(90, Math.min(2200, Math.sqrt(approximateCellArea)))
+  const buckets = new Map()
+
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index]
+    const cellX = Math.floor((node.x - bounds.minX) / cellSize)
+    const cellY = Math.floor((node.y - bounds.minY) / cellSize)
+    const key = cellX + ':' + cellY
+    const bucket = buckets.get(key)
+    if (bucket) {
+      bucket.push(node)
+      continue
+    }
+    buckets.set(key, [node])
+  }
+
+  return {
+    cellSize,
+    minX: bounds.minX,
+    minY: bounds.minY,
+    maxX: bounds.maxX,
+    maxY: bounds.maxY,
+    buckets
+  }
+}
+
+const viewportNodesFromSpatialIndex = viewport => {
+  if (state.visibleNodes.length <= 2500) {
+    return state.visibleNodes.filter(node => isNodeInViewport(node, viewport))
+  }
+
+  const spatial = state.visibleNodeSpatial
+  if (!spatial || spatial.buckets.size === 0) {
+    return state.visibleNodes.filter(node => isNodeInViewport(node, viewport))
+  }
+
+  const minCellX = Math.floor((viewport.minX - spatial.minX) / spatial.cellSize)
+  const maxCellX = Math.floor((viewport.maxX - spatial.minX) / spatial.cellSize)
+  const minCellY = Math.floor((viewport.minY - spatial.minY) / spatial.cellSize)
+  const maxCellY = Math.floor((viewport.maxY - spatial.minY) / spatial.cellSize)
+  const nodes = []
+
+  for (let cellX = minCellX; cellX <= maxCellX; cellX += 1) {
+    for (let cellY = minCellY; cellY <= maxCellY; cellY += 1) {
+      const bucket = spatial.buckets.get(cellX + ':' + cellY)
+      if (!bucket) continue
+
+      for (let index = 0; index < bucket.length; index += 1) {
+        const node = bucket[index]
+        if (isNodeInViewport(node, viewport)) {
+          nodes.push(node)
+        }
+      }
+    }
+  }
+
+  return nodes
+}
+
+const createVisibleEdgeLookup = edges => {
+  const lookup = new Map()
+
+  for (let index = 0; index < edges.length; index += 1) {
+    const edge = edges[index]
+    if (!edge.target) continue
+
+    const sourceList = lookup.get(edge.source)
+    if (sourceList) {
+      sourceList.push(edge)
+    } else {
+      lookup.set(edge.source, [edge])
+    }
+
+    const targetList = lookup.get(edge.target)
+    if (targetList) {
+      targetList.push(edge)
+    } else {
+      lookup.set(edge.target, [edge])
+    }
+  }
+
+  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 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
+  if (zoom < 0.18) return 900
+  if (zoom < 0.28) return 1700
+  if (zoom < 0.45) return 2800
+  if (zoom < 0.7) return 4200
+  if (zoom < 1.05) return 5600
+  return 7600
+}
+
+const clusterBudgetForScale = (scale) => {
+  if (scale < 0.008) return 90
+  if (scale < 0.014) return 150
+  if (scale < 0.022) return 240
+  if (scale < 0.035) return 360
+  return 520
+}
+
+const nodeBudgetForScale = (scale) => {
+  if (scale < 0.035) return 220
+  if (scale < 0.06) return 360
+  if (scale < 0.09) return 520
+  if (scale < 0.14) return 720
+  if (state.visibleNodes.length > massiveGraphNodeThreshold) {
+    if (scale < 0.28) return renderNodeBudget
+    if (scale < 0.45) return 1100
+    if (scale < 0.7) return 1400
+    if (scale < 1.05) return 1800
+    return zoomedMassiveRenderNodeBudget
+  }
+  return renderNodeBudget
+}
+
+const layerFocusForScale = (scale) => {
+  const normalized = Math.max(0, Math.min(1, (scale - 0.06) / 0.94))
+  const shellCenter = Math.max(0.08, 0.96 - normalized * 0.86)
+  const shellWidth = Math.max(0.24, 0.46 - normalized * 0.16)
+  const coreRadius = Math.max(0.06, 0.1 + normalized * 0.22)
+  const coreRatio = Math.max(0.2, Math.min(0.72, 0.24 + normalized * 0.48))
+
+  return { shellCenter, shellWidth, coreRadius, coreRatio }
+}
+
+const selectLayeredNodesForScale = (sourceNodes, targetCount) => {
+  const hub = state.primaryHub
+  if (!hub || sourceNodes.length <= 1200 || state.visibleNodes.length <= massiveGraphNodeThreshold) {
+    return sourceNodes
+  }
+
+  let maxDistance = 0
+  const distances = sourceNodes.map((node) => {
+    const distance = Math.hypot(node.x - hub.x, node.y - hub.y)
+    if (distance > maxDistance) {
+      maxDistance = distance
+    }
+    return { node, distance }
+  })
+
+  if (maxDistance <= 0.001) {
+    return sourceNodes
+  }
+
+  const focus = layerFocusForScale(state.transform.scale)
+  const normalizedRows = distances.map((item) => ({
+    ...item,
+    normalized: item.distance / maxDistance
+  }))
+  const desired = Math.max(260, Math.min(sourceNodes.length, targetCount * 2))
+  const coreTarget = Math.max(36, Math.min(desired - 8, Math.floor(desired * focus.coreRatio)))
+  const shellTarget = Math.max(12, desired - coreTarget)
+  const shellHalf = focus.shellWidth / 2
+
+  const coreNodes = normalizedRows
+    .filter((item) => item.normalized <= focus.coreRadius)
+    .sort((left, right) => {
+      const leftScore = state.nodeDegrees.get(left.node.id) ?? 0
+      const rightScore = state.nodeDegrees.get(right.node.id) ?? 0
+      if (leftScore !== rightScore) return rightScore - leftScore
+      return left.node.id.localeCompare(right.node.id)
+    })
+    .slice(0, coreTarget)
+    .map((item) => item.node)
+
+  const shellNodes = normalizedRows
+    .sort((left, right) => {
+      const leftDelta = Math.abs(left.normalized - focus.shellCenter)
+      const rightDelta = Math.abs(right.normalized - focus.shellCenter)
+      const leftInside = leftDelta <= shellHalf ? 0 : 1
+      const rightInside = rightDelta <= shellHalf ? 0 : 1
+      if (leftInside !== rightInside) return leftInside - rightInside
+      if (leftDelta !== rightDelta) return leftDelta - rightDelta
+      const leftScore = state.nodeDegrees.get(left.node.id) ?? 0
+      const rightScore = state.nodeDegrees.get(right.node.id) ?? 0
+      if (leftScore !== rightScore) return rightScore - leftScore
+      return left.node.id.localeCompare(right.node.id)
+    })
+    .slice(0, shellTarget)
+    .map((item) => item.node)
+
+  const merged = []
+  const ids = new Set()
+  const pushUnique = (node) => {
+    if (!node || ids.has(node.id)) return
+    ids.add(node.id)
+    merged.push(node)
+  }
+
+  if (state.transform.scale >= layeredCoreScaleThreshold) {
+    pushUnique(hub)
+  }
+  for (let index = 0; index < coreNodes.length; index += 1) pushUnique(coreNodes[index])
+  for (let index = 0; index < shellNodes.length; index += 1) pushUnique(shellNodes[index])
+
+  return merged.length > 0 ? merged : sourceNodes
+}
+
+const viewportCenterWorldPoint = () => {
+  const viewport = worldViewportBounds()
+  return {
+    x: (viewport.minX + viewport.maxX) / 2,
+    y: (viewport.minY + viewport.maxY) / 2
+  }
+}
+
+const screenToWorldPoint = (screenX, screenY) => ({
+  x: (screenX - state.transform.x) / state.transform.scale,
+  y: (screenY - state.transform.y) / state.transform.scale
+})
+
+const cursorWorldPoint = () => {
+  if (!state.cursor.inCanvas) {
+    return null
+  }
+  const rect = canvas.getBoundingClientRect()
+  const screenX = state.cursor.x - rect.left
+  const screenY = state.cursor.y - rect.top
+  const width = Math.max(rect.width, 320)
+  const height = Math.max(rect.height, 320)
+  if (!Number.isFinite(screenX) || !Number.isFinite(screenY)) {
+    return null
+  }
+  if (screenX < 0 || screenX > width || screenY < 0 || screenY > height) {
+    return null
+  }
+  return screenToWorldPoint(screenX, screenY)
+}
+
+const visibilityScaleBucket = (scale) => {
+  const safeScale = Math.max(zoomRange.min, scale)
+  if (safeScale < 0.01) return Math.round(safeScale * 300_000)
+  if (safeScale < 0.05) return Math.round(safeScale * 120_000)
+  if (safeScale < 0.2) return Math.round(safeScale * 40_000)
+  return Math.round(safeScale * 8_000)
+}
+
+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()
+
+  const push = (node) => {
+    if (!node || ids.has(node.id) || merged.length >= limit) {
+      return
+    }
+    ids.add(node.id)
+    merged.push(node)
+  }
+
+  for (let index = 0; index < leftNodes.length && merged.length < limit; index += 1) {
+    push(leftNodes[index])
+  }
+  for (let index = 0; index < rightNodes.length && merged.length < limit; index += 1) {
+    push(rightNodes[index])
+  }
+
+  return merged
+}
+
+const selectStableSampleNodes = (sourceNodes, limit) => {
+  if (sourceNodes.length <= limit) {
+    return sourceNodes
+  }
+
+  const now = performance.now()
+  const cursorPoint = cursorWorldPoint()
+  const recentZoomFocus =
+    now - state.lastZoomFocus.at <= 1500
+      ? { x: state.lastZoomFocus.x, y: state.lastZoomFocus.y }
+      : null
+  const anchor = cursorPoint ?? recentZoomFocus ?? viewportCenterWorldPoint()
+  const previousIds = new Set(state.renderNodes.map((node) => node.id))
+  const preferAnchorDistance = state.visibleNodes.length > massiveGraphNodeThreshold && state.transform.scale >= 0.28
+
+  return [...sourceNodes]
+    .sort((left, right) => {
+      const leftWasVisible = previousIds.has(left.id) ? 1 : 0
+      const rightWasVisible = previousIds.has(right.id) ? 1 : 0
+      const leftDistance = Math.hypot(left.x - anchor.x, left.y - anchor.y)
+      const rightDistance = Math.hypot(right.x - anchor.x, right.y - anchor.y)
+
+      if (preferAnchorDistance) {
+        if (leftDistance !== rightDistance) return leftDistance - rightDistance
+        if (leftWasVisible !== rightWasVisible) return rightWasVisible - leftWasVisible
+      } else {
+        if (leftWasVisible !== rightWasVisible) return rightWasVisible - leftWasVisible
+        if (leftDistance !== rightDistance) return leftDistance - rightDistance
+      }
+
+      const leftDegree = state.nodeDegrees.get(left.id) ?? 0
+      const rightDegree = state.nodeDegrees.get(right.id) ?? 0
+      if (leftDegree !== rightDegree) return rightDegree - leftDegree
+
+      return left.id.localeCompare(right.id)
+    })
+    .slice(0, limit)
+}
+
+const selectAccessBridgeNodes = (sourceNodes, limit) => {
+  if (limit <= 0 || sourceNodes.length === 0) {
+    return []
+  }
+
+  const now = performance.now()
+  const cursorPoint = cursorWorldPoint()
+  const recentZoomFocus =
+    now - state.lastZoomFocus.at <= 1200
+      ? { x: state.lastZoomFocus.x, y: state.lastZoomFocus.y }
+      : null
+  const anchor = cursorPoint ?? recentZoomFocus ?? viewportCenterWorldPoint()
+  return [...sourceNodes]
+    .sort((left, right) => {
+      const leftDistance = Math.hypot(left.x - anchor.x, left.y - anchor.y)
+      const rightDistance = Math.hypot(right.x - anchor.x, right.y - anchor.y)
+      if (leftDistance !== rightDistance) return leftDistance - rightDistance
+      const leftDegree = state.nodeDegrees.get(left.id) ?? 0
+      const rightDegree = state.nodeDegrees.get(right.id) ?? 0
+      if (leftDegree !== rightDegree) return rightDegree - leftDegree
+      return left.id.localeCompare(right.id)
+    })
+    .slice(0, limit)
+}
+
+const edgeIdentityKey = edge => {
+  if (!edge.target) return ''
+  const pair = edge.source < edge.target
+    ? edge.source + '|' + edge.target
+    : edge.target + '|' + edge.source
+  return pair + '|' + (edge.inferred ? 'mesh' : 'real')
+}
+
+const edgeRelevanceScore = edge => {
+  let score = edgeWeight(edge) * 10
+  if (!edge.inferred) {
+    score += 8
+  }
+
+  const selectedId = state.selected?.id
+  if (selectedId && (edge.source === selectedId || edge.target === selectedId)) {
+    score += 120
+  }
+
+  const hoveredId = state.hovered?.id
+  if (hoveredId && (edge.source === hoveredId || edge.target === hoveredId)) {
+    score += 70
+  }
+
+  const hubId = state.primaryHub?.id
+  if (hubId && (edge.source === hubId || edge.target === hubId)) {
+    score += 42
+  }
+
+  return score
+}
+
+const collectVisibleEdgesForNodes = nodeIds => {
+  if (nodeIds.size === 0) {
+    return []
+  }
+
+  const seen = new Set()
+  const candidates = []
+  const limit = edgeBudgetForCurrentFrame()
+
+  nodeIds.forEach(nodeId => {
+    const candidateEdges = state.visibleEdgeByNode.get(nodeId) ?? []
+    for (let index = 0; index < candidateEdges.length; index += 1) {
+      const edge = candidateEdges[index]
+      if (!edge.target || !nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+        continue
+      }
+      const key = edgeIdentityKey(edge)
+      if (seen.has(key)) continue
+
+      seen.add(key)
+      candidates.push(edge)
+    }
+  })
+
+  if (candidates.length <= limit) {
+    return candidates
+  }
+
+  return candidates
+    .sort((left, right) => {
+      const scoreDelta = edgeRelevanceScore(right) - edgeRelevanceScore(left)
+      if (scoreDelta !== 0) {
+        return scoreDelta
+      }
+      const leftKey = edgeIdentityKey(left)
+      const rightKey = edgeIdentityKey(right)
+      return leftKey.localeCompare(rightKey)
+    })
+    .slice(0, limit)
+}
+
+const edgeOpacityForScale = (edge, scale) => {
+  if (edge.inferred) {
+    if (scale < 0.2) return 0.06
+    if (scale < 0.4) return 0.08
+    if (scale < 0.7) return 0.1
+    return 0.14
+  }
+
+  if (scale < 0.2) return 0.14
+  if (scale < 0.4) return 0.2
+  if (scale < 0.7) return 0.28
+  if (scale < 1.05) return 0.36
+  return 0.46
+}
+
+const edgeDepthOpacity = edge => {
+  if (!shouldProjectRenderNodesInDepth()) {
+    return 1
+  }
+  return Math.max(
+    graphDepthEdgeOpacityFloor,
+    Math.min(nodeRenderOpacity(edge.sourceNode), nodeRenderOpacity(edge.targetNode))
+  )
+}
+
+const edgeDepthScale = edge => {
+  if (!shouldProjectRenderNodesInDepth()) {
+    return 1
+  }
+  return Math.max(0.62, Math.min(1.18, Math.min(nodeRenderScale(edge.sourceNode), nodeRenderScale(edge.targetNode))))
+}
+
+const edgeStrokeFor = (edge, selectedEdge) => {
+  if (selectedEdge) {
+    return graphTheme.edgeActive
+  }
+
+  const opacity = edgeOpacityForScale(edge, state.transform.scale) * edgeDepthOpacity(edge)
+  return edge.inferred
+    ? 'rgba(203, 213, 225, ' + opacity + ')'
+    : 'rgba(153, 165, 181, ' + opacity + ')'
+}
+
+const edgeWidthFor = (edge, selectedEdge) => {
+  if (edge.inferred) {
+    const width = selectedEdge ? 1.22 : 0.84
+    return width * edgeDepthScale(edge)
+  }
+
+  const width = (selectedEdge ? 1.9 : 1.05) + Math.min(edgeWeight(edge) - 1, 8) * 0.24
+  return width * edgeDepthScale(edge)
+}
+
+const drawGraphEdge = (edge) => {
+  const selectedEdge = state.selected && (edge.source === state.selected.id || edge.target === state.selected.id)
+  ctx.beginPath()
+  ctx.moveTo(nodeRenderX(edge.sourceNode), nodeRenderY(edge.sourceNode))
+  ctx.lineTo(nodeRenderX(edge.targetNode), nodeRenderY(edge.targetNode))
+  ctx.strokeStyle = edgeStrokeFor(edge, selectedEdge)
+  ctx.lineWidth = edgeWidthFor(edge, selectedEdge)
+  ctx.stroke()
+}
+
+const drawEdgeBatch = (edges, options) => {
+  if (edges.length === 0) {
+    return
+  }
+
+  ctx.beginPath()
+  for (let index = 0; index < edges.length; index += 1) {
+    const edge = edges[index]
+    ctx.moveTo(nodeRenderX(edge.sourceNode), nodeRenderY(edge.sourceNode))
+    ctx.lineTo(nodeRenderX(edge.targetNode), nodeRenderY(edge.targetNode))
+  }
+  ctx.strokeStyle = options.strokeStyle
+  ctx.lineWidth = options.lineWidth
+  ctx.stroke()
+}
+
+const regularEdgeBatchOptions = (edge) => ({
+  strokeStyle: edgeStrokeFor(edge, false),
+  lineWidth: edgeWidthFor(edge, false)
+})
+
+const regularEdgeBatchKey = (edge) => {
+  const options = regularEdgeBatchOptions(edge)
+  return options.strokeStyle + '|' + options.lineWidth.toFixed(2)
+}
+
+const drawGraphEdges = () => {
+  const edgeBatches = new Map()
+  const selectedEdges = []
+
+  for (let index = 0; index < state.renderEdges.length; index += 1) {
+    const edge = state.renderEdges[index]
+    const isSelected = state.selected && (edge.source === state.selected.id || edge.target === state.selected.id)
+    if (isSelected) {
+      selectedEdges.push(edge)
+      continue
+    }
+
+    const key = regularEdgeBatchKey(edge)
+    const batch = edgeBatches.get(key)
+    if (batch) {
+      batch.edges.push(edge)
+    } else {
+      edgeBatches.set(key, {
+        edges: [edge],
+        options: regularEdgeBatchOptions(edge)
+      })
+    }
+  }
+
+  edgeBatches.forEach((batch) => drawEdgeBatch(batch.edges, batch.options))
+
+  for (let index = 0; index < selectedEdges.length; index += 1) {
+    drawGraphEdge(selectedEdges[index])
+  }
+}
+
+const shouldDrawNodeLabels = (node, isSelected, isHovered) =>
+  isSelected ||
+  isHovered ||
+  (state.nodes.length > largeGraphNodeThreshold && state.transform.scale >= 0.62 && state.renderNodes.length <= 1200) ||
+  (state.nodes.length <= largeGraphNodeThreshold && (state.transform.scale > 1.18 || state.nodes.length <= 25))
+
+const drawSingleNode = (node, options = { drawLabel: true }) => {
+  const radius = nodeRadius(node) * nodeRenderScale(node)
+  const x = nodeRenderX(node)
+  const y = nodeRenderY(node)
+  const opacity = nodeRenderOpacity(node)
+  const isSelected = state.selected?.id === node.id
+  const isHovered = state.hovered?.id === node.id
+  ctx.globalAlpha = opacity
+  ctx.beginPath()
+  ctx.arc(x, y, radius + (isSelected ? 7 : isHovered ? 4 : 0), 0, Math.PI * 2)
+  ctx.fillStyle = isSelected || isHovered ? graphTheme.nodeHaloActive : graphTheme.nodeHalo
+  ctx.fill()
+  ctx.beginPath()
+  ctx.arc(x, y, radius, 0, Math.PI * 2)
+  ctx.fillStyle = isSelected ? graphTheme.nodeSelected : isHovered ? graphTheme.nodeHover : graphTheme.node
+  ctx.fill()
+  ctx.lineWidth = isSelected ? 2.6 : 1.5
+  ctx.strokeStyle = isSelected ? graphTheme.nodeStrokeActive : graphTheme.nodeStroke
+  ctx.stroke()
+
+  if (options.drawLabel && shouldDrawNodeLabels(node, isSelected, isHovered)) {
+    ctx.globalAlpha = Math.max(0.58, opacity)
+    ctx.fillStyle = graphTheme.label
+    ctx.font = '12px Inter, system-ui, sans-serif'
+    ctx.textAlign = 'center'
+    ctx.textBaseline = 'top'
+    ctx.fillText(node.title.slice(0, 34), x, y + radius + 8)
+  }
+  ctx.globalAlpha = 1
+}
+
+const drawNodeBatch = (nodes) => {
+  if (nodes.length === 0) {
+    return
+  }
+
+  const drawHalos = state.renderNodes.length <= 1200 || state.transform.scale >= 0.45
+  if (drawHalos) {
+    for (let index = 0; index < nodes.length; index += 1) {
+      const node = nodes[index]
+      const radius = nodeRadius(node) * nodeRenderScale(node)
+      const x = nodeRenderX(node)
+      const y = nodeRenderY(node)
+      ctx.globalAlpha = Math.max(0.2, nodeRenderOpacity(node) * 0.5)
+      ctx.beginPath()
+      ctx.arc(x, y, radius + 3, 0, Math.PI * 2)
+      ctx.fillStyle = graphTheme.nodeHalo
+      ctx.fill()
+    }
+    ctx.globalAlpha = 1
+  }
+
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index]
+    const radius = nodeRadius(node) * nodeRenderScale(node)
+    const x = nodeRenderX(node)
+    const y = nodeRenderY(node)
+    const opacity = nodeRenderOpacity(node)
+    ctx.globalAlpha = opacity
+    ctx.beginPath()
+    ctx.arc(x, y, radius, 0, Math.PI * 2)
+    ctx.fillStyle = graphTheme.node
+    ctx.fill()
+    ctx.lineWidth = 1.25
+    ctx.strokeStyle = graphTheme.nodeStroke
+    ctx.stroke()
+  }
+  ctx.globalAlpha = 1
+}
+
+const drawGraphNodes = () => {
+  const regularNodes = []
+  const priorityNodes = []
+
+  for (let index = 0; index < state.renderNodes.length; index += 1) {
+    const node = state.renderNodes[index]
+    const isPriority =
+      state.selected?.id === node.id ||
+      state.hovered?.id === node.id
+    if (isPriority) {
+      priorityNodes.push(node)
+    } else {
+      regularNodes.push(node)
+    }
+  }
+
+  if (shouldProjectRenderNodesInDepth()) {
+    regularNodes.sort((left, right) => nodeRenderDepth(right) - nodeRenderDepth(left))
+  }
+
+  drawNodeBatch(regularNodes)
+
+  if (state.transform.scale >= 0.62 && state.renderNodes.length <= 1200) {
+    ctx.fillStyle = graphTheme.label
+    ctx.font = '12px Inter, system-ui, sans-serif'
+    ctx.textAlign = 'center'
+    ctx.textBaseline = 'top'
+    for (let index = 0; index < regularNodes.length; index += 1) {
+      const node = regularNodes[index]
+      const x = nodeRenderX(node)
+      const y = nodeRenderY(node)
+      const radius = nodeRadius(node) * nodeRenderScale(node)
+      ctx.globalAlpha = Math.max(0.6, nodeRenderOpacity(node))
+      ctx.fillText(node.title.slice(0, 34), x, y + radius + 8)
+    }
+    ctx.globalAlpha = 1
+  }
+
+  priorityNodes.forEach(node => drawSingleNode(node))
+}
+
+const partitionGraphForAcceleratedRenderer = () => {
+  const regularNodes = []
+  const priorityNodes = []
+  const regularEdges = []
+  const inferredEdges = []
+  const selectedEdges = []
+
+  for (let index = 0; index < state.renderNodes.length; index += 1) {
+    const node = state.renderNodes[index]
+    const isPriority =
+      state.selected?.id === node.id ||
+      state.hovered?.id === node.id
+    if (isPriority) {
+      priorityNodes.push(node)
+    } else {
+      regularNodes.push(node)
+    }
+  }
+
+  for (let index = 0; index < state.renderEdges.length; index += 1) {
+    const edge = state.renderEdges[index]
+    const isSelected = state.selected && (edge.source === state.selected.id || edge.target === state.selected.id)
+    if (isSelected) {
+      selectedEdges.push(edge)
+    } else if (edge.inferred) {
+      inferredEdges.push(edge)
+    } else {
+      regularEdges.push(edge)
+    }
+  }
+
+  return { regularNodes, priorityNodes, regularEdges, inferredEdges, selectedEdges }
+}
+
+const drawGraphLabels = nodes => {
+  if (!(state.transform.scale >= 0.62 && state.renderNodes.length <= 1200)) {
+    return
+  }
+
+  ctx.fillStyle = graphTheme.label
+  ctx.font = '12px Inter, system-ui, sans-serif'
+  ctx.textAlign = 'center'
+  ctx.textBaseline = 'top'
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index]
+    const x = nodeRenderX(node)
+    const y = nodeRenderY(node)
+    const radius = nodeRadius(node) * nodeRenderScale(node)
+    ctx.globalAlpha = Math.max(0.6, nodeRenderOpacity(node))
+    ctx.fillText(node.title.slice(0, 34), x, y + radius + 8)
+  }
+  ctx.globalAlpha = 1
+}
+
+const drawAcceleratedGraph = (width, height, drawEdges) => {
+  if (!webGlRenderer || state.renderClusters.length > 0 || shouldProjectRenderNodesInDepth()) {
+    return false
+  }
+
+  const graphParts = partitionGraphForAcceleratedRenderer()
+  const scale = state.transform.scale
+  webGlRenderer.clear(width, height)
+  if (drawEdges) {
+    webGlRenderer.drawLines(
+      graphParts.regularEdges,
+      rgba('rgb(153, 165, 181)', edgeOpacityForScale({ inferred: false }, scale)),
+      width,
+      height
+    )
+    webGlRenderer.drawLines(
+      graphParts.inferredEdges,
+      rgba('rgb(203, 213, 225)', edgeOpacityForScale({ inferred: true }, scale)),
+      width,
+      height
+    )
+  }
+  webGlRenderer.drawPoints(
+    graphParts.regularNodes,
+    rgba(graphTheme.nodeHalo, 0.28),
+    node => Math.max((nodeRadius(node) + 3) * state.transform.scale * 2, 1.5),
+    width,
+    height
+  )
+  webGlRenderer.drawPoints(
+    graphParts.regularNodes,
+    rgba(graphTheme.node, 1),
+    node => Math.max(nodeRadius(node) * state.transform.scale * 2, 1.2),
+    width,
+    height
+  )
+
+  ctx.save()
+  ctx.translate(state.transform.x, state.transform.y)
+  ctx.scale(state.transform.scale, state.transform.scale)
+  if (drawEdges) {
+    graphParts.selectedEdges.forEach(edge => drawGraphEdge(edge))
+  }
+  drawGraphLabels(graphParts.regularNodes)
+  graphParts.priorityNodes.forEach(node => drawSingleNode(node))
+  ctx.restore()
+
+  return true
+}
+
+const edgePairKey = (source, target) =>
+  source < target ? source + '|' + target : target + '|' + source
+
+const meshNeighborBuckets = (nodes, cellSize) => {
+  const buckets = new Map()
+
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index]
+    const cellX = Math.floor(node.x / cellSize)
+    const cellY = Math.floor(node.y / cellSize)
+    const key = cellX + ':' + cellY
+    const bucket = buckets.get(key)
+    if (bucket) {
+      bucket.push(node)
+    } else {
+      buckets.set(key, [node])
+    }
+  }
+
+  return buckets
+}
+
+const meshCandidatesForNode = (node, buckets, cellSize) => {
+  const cellX = Math.floor(node.x / cellSize)
+  const cellY = Math.floor(node.y / cellSize)
+  const candidates = []
+
+  for (let offsetX = -1; offsetX <= 1; offsetX += 1) {
+    for (let offsetY = -1; offsetY <= 1; offsetY += 1) {
+      const bucket = buckets.get((cellX + offsetX) + ':' + (cellY + offsetY))
+      if (!bucket) continue
+      for (let index = 0; index < bucket.length; index += 1) {
+        const candidate = bucket[index]
+        if (candidate.id !== node.id) {
+          candidates.push(candidate)
+        }
+      }
+    }
+  }
+
+  return candidates
+}
+
+const buildMeshEdgesForNodes = (nodes, existingEdges) => {
+  if (nodes.length < 2 || state.transform.scale < meshEdgeScaleThreshold) {
+    return []
+  }
+
+  const existingKeys = new Set()
+  for (let index = 0; index < existingEdges.length; index += 1) {
+    const edge = existingEdges[index]
+    if (edge.target) {
+      existingKeys.add(edgePairKey(edge.source, edge.target))
+    }
+  }
+
+  const desiredBudget = Math.min(
+    meshEdgeMaxBudget,
+    Math.max(meshEdgeMinBudget, Math.floor(edgeBudgetForCurrentFrame() * 0.62))
+  )
+  const perNodeNeighborCount =
+    state.transform.scale >= 1.05 ? 4
+      : state.transform.scale >= 0.62 ? 3
+        : 2
+  const cellSize = Math.max(120, 280 / Math.max(state.transform.scale, 0.0001))
+  const maxDistance = 980
+  const maxDistanceSquared = maxDistance * maxDistance
+  const buckets = meshNeighborBuckets(nodes, cellSize)
+  const meshEdges = []
+  const meshKeys = new Set()
+
+  for (let index = 0; index < nodes.length && meshEdges.length < desiredBudget; index += 1) {
+    const node = nodes[index]
+    const candidates = meshCandidatesForNode(node, buckets, cellSize)
+      .map((candidate) => ({
+        node: candidate,
+        distanceSquared: (candidate.x - node.x) ** 2 + (candidate.y - node.y) ** 2
+      }))
+      .filter((candidate) => candidate.distanceSquared <= maxDistanceSquared)
+      .sort((left, right) => left.distanceSquared - right.distanceSquared)
+
+    let linked = 0
+    for (let candidateIndex = 0; candidateIndex < candidates.length && linked < perNodeNeighborCount && meshEdges.length < desiredBudget; candidateIndex += 1) {
+      const candidate = candidates[candidateIndex].node
+      const key = edgePairKey(node.id, candidate.id)
+      if (existingKeys.has(key) || meshKeys.has(key)) {
+        continue
+      }
+
+      meshKeys.add(key)
+      meshEdges.push({
+        source: node.id,
+        target: candidate.id,
+        targetTitle: candidate.title,
+        weight: 1,
+        priority: 'normal',
+        sourceNode: node,
+        targetNode: candidate,
+        inferred: true
+      })
+      linked += 1
+    }
+  }
+
+  return meshEdges
+}
+
+const withMeshEdges = (nodes, edges) => {
+  if (nodes.length === 0 || state.visibleNodes.length <= largeGraphNodeThreshold || state.transform.scale < meshEdgeScaleThreshold) {
+    return edges
+  }
+
+  const meshEdges = buildMeshEdgesForNodes(nodes, edges)
+  return meshEdges.length > 0 ? edges.concat(meshEdges) : edges
+}
+
+const fallbackViewportNodes = () => {
+  const nodes = []
+  const maxNodes = Math.min(renderNodeBudget, 220)
+  const step = Math.max(1, Math.ceil(state.visibleNodes.length / maxNodes))
+
+  for (let index = 0; index < state.visibleNodes.length && nodes.length < maxNodes; index += step) {
+    nodes.push(state.visibleNodes[index])
+  }
+
+  if (state.selected && !nodes.find(node => node.id === state.selected.id)) {
+    nodes.push(state.selected)
+  }
+
+  return nodes
+}
+
+const sampleVisibleNodes = (limit = renderNodeBudget, sourceNodes = state.visibleNodes) => {
+  if (sourceNodes.length === 0 || limit <= 0) {
+    return []
+  }
+
+  const nodes = []
+  const maxNodes = Math.min(Math.max(limit, 1), sourceNodes.length)
+  const step = Math.max(1, Math.ceil(sourceNodes.length / maxNodes))
+
+  for (let index = 0; index < sourceNodes.length && nodes.length < maxNodes; index += step) {
+    nodes.push(sourceNodes[index])
+  }
+
+  if (state.selected && !nodes.find(node => node.id === state.selected.id)) {
+    nodes.push(state.selected)
+  }
+
+  return nodes
+}
+
+const enrichSampleWithNeighbors = (nodes) => {
+  if (nodes.length === 0) {
+    return {
+      nodes,
+      edges: []
+    }
+  }
+
+  const maxNodes = Math.min(renderNodeBudget, nodes.length + 200)
+  const expanded = [...nodes]
+  const ids = new Set(expanded.map((node) => node.id))
+
+  for (let index = 0; index < nodes.length && expanded.length < maxNodes; index += 1) {
+    const node = nodes[index]
+    const candidates = [...(state.visibleEdgeByNode.get(node.id) ?? [])]
+      .filter((edge) => edge.target)
+      .sort((left, right) => edgeWeight(right) - edgeWeight(left))
+      .slice(0, 3)
+
+    for (let candidateIndex = 0; candidateIndex < candidates.length && expanded.length < maxNodes; candidateIndex += 1) {
+      const edge = candidates[candidateIndex]
+      const otherId = edge.source === node.id ? edge.target : edge.source
+
+      if (!otherId || ids.has(otherId)) {
+        continue
+      }
+
+      const otherNode = state.nodeById.get(otherId)
+      if (!otherNode) {
+        continue
+      }
+
+      ids.add(otherId)
+      expanded.push(otherNode)
+    }
+  }
+
+  const edges = collectVisibleEdgesForNodes(ids)
+
+  return {
+    nodes: expanded,
+    edges
+  }
+}
+
+const includeHubPreviewNeighborhood = (nodes, limit) => {
+  const hub = state.primaryHub
+  if (!hub) {
+    return nodes
+  }
+
+  const maxNodes = Math.max(1, Math.min(renderNodeBudget, limit))
+  const merged = [...nodes]
+  const ids = new Set(merged.map((node) => node.id))
+  const protectedIds = new Set()
+
+  if (!ids.has(hub.id)) {
+    if (merged.length < maxNodes) {
+      merged.push(hub)
+      ids.add(hub.id)
+    } else {
+      const replaceIndex = merged.findIndex((node) => node.id !== hub.id)
+      if (replaceIndex >= 0) {
+        ids.delete(merged[replaceIndex].id)
+        merged[replaceIndex] = hub
+        ids.add(hub.id)
+      }
+    }
+  }
+  protectedIds.add(hub.id)
+
+  const hubEdges = [...(state.visibleEdgeByNode.get(hub.id) ?? [])]
+    .filter((edge) => edge.target && (edge.source === hub.id || edge.target === hub.id))
+    .sort((left, right) => {
+      const byWeight = edgeWeight(right) - edgeWeight(left)
+      if (byWeight !== 0) return byWeight
+
+      const leftOtherId = left.source === hub.id ? left.target : left.source
+      const rightOtherId = right.source === hub.id ? right.target : right.source
+      const leftDegree = state.nodeDegrees.get(leftOtherId ?? '') ?? 0
+      const rightDegree = state.nodeDegrees.get(rightOtherId ?? '') ?? 0
+      if (leftDegree !== rightDegree) return rightDegree - leftDegree
+
+      return edgeIdentityKey(left).localeCompare(edgeIdentityKey(right))
+    })
+
+  for (let index = 0; index < hubEdges.length && merged.length < maxNodes; index += 1) {
+    const edge = hubEdges[index]
+    const otherId = edge.source === hub.id ? edge.target : edge.source
+    if (!otherId || ids.has(otherId)) {
+      continue
+    }
+
+    const otherNode = state.nodeById.get(otherId)
+    if (!otherNode) {
+      continue
+    }
+
+    if (merged.length < maxNodes) {
+      ids.add(otherId)
+      merged.push(otherNode)
+      protectedIds.add(otherId)
+      continue
+    }
+
+    const replaceIndex = (() => {
+      for (let cursor = merged.length - 1; cursor >= 0; cursor -= 1) {
+        const candidateId = merged[cursor]?.id
+        if (candidateId && !protectedIds.has(candidateId)) {
+          return cursor
+        }
+      }
+      return -1
+    })()
+    if (replaceIndex >= 0) {
+      const replacedId = merged[replaceIndex]?.id
+      if (replacedId) {
+        ids.delete(replacedId)
+      }
+      merged[replaceIndex] = otherNode
+      ids.add(otherId)
+      protectedIds.add(otherId)
+    }
+  }
+
+  return merged
+}
+
+const ensureHubNodesInRenderedSet = (nodes) => {
+  if (nodes.length === 0) {
+    return nodes
+  }
+
+  const maxNodes = Math.max(Math.min(renderNodeBudget, nodes.length), 1)
+  const ids = new Set(nodes.map((node) => node.id))
+  const hubs = rankedHubNodes()
+  const merged = [...nodes]
+
+  for (let index = 0; index < hubs.length; index += 1) {
+    const hub = hubs[index]
+    if (ids.has(hub.id)) {
+      continue
+    }
+
+    if (merged.length < maxNodes) {
+      merged.push(hub)
+      ids.add(hub.id)
+      continue
+    }
+
+    const replacementIndex = merged.findIndex((node) => !hubs.some((candidate) => candidate.id === node.id))
+    if (replacementIndex >= 0) {
+      ids.delete(merged[replacementIndex].id)
+      merged[replacementIndex] = hub
+      ids.add(hub.id)
+    }
+  }
+
+  return merged
+}
+
+const zoomCapByNodeCount = (nodeCount) => {
+  if (nodeCount > 50000) return 5.4
+  if (nodeCount > 20000) return 4.8
+  if (nodeCount > 6000) return 4.2
+  if (nodeCount > 2000) return 4
+  return zoomRange.max
 }
 
-const edgeWeight = edge => Number.isFinite(edge.weight) ? Math.max(1, edge.weight) : 1
+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)
+}
+
+const zoomFloorByNodeCount = (nodeCount) => {
+  if (nodeCount > massiveGraphNodeThreshold) return 0.0042
+  if (nodeCount > largeGraphNodeThreshold) return 0.0021
+  if (nodeCount > ecosystemActivationNodeThreshold) return 0.001
+  return zoomRange.min
+}
+
+const currentZoomMin = () => {
+  const nodeCount = state.visibleNodes.length > 0 ? state.visibleNodes.length : state.nodes.length
+  return Math.max(zoomRange.min, zoomFloorByNodeCount(nodeCount))
+}
 
-const clampScale = value => Math.max(zoomRange.min, Math.min(zoomRange.max, value))
+const clampScale = value => Math.max(currentZoomMin(), Math.min(currentZoomMax(), value))
+const isFiniteNumber = value => Number.isFinite(value)
+const isReasonableCoordinate = value => isFiniteNumber(value) && Math.abs(value) <= worldCoordinateLimit
+const clampTransformCoordinate = value => {
+  if (!isFiniteNumber(value)) return 0
+  if (value > transformCoordinateLimit) return transformCoordinateLimit
+  if (value < -transformCoordinateLimit) return -transformCoordinateLimit
+  return value
+}
 
 const graphBounds = nodes => {
   if (nodes.length === 0) return null
@@ -133,7 +2491,7 @@ const graphBounds = nodes => {
   let maxY = Number.NEGATIVE_INFINITY
 
   nodes.forEach(node => {
-    const radius = nodeRadius(node)
+    const radius = baseNodeRadius(node)
     minX = Math.min(minX, node.x - radius)
     maxX = Math.max(maxX, node.x + radius)
     minY = Math.min(minY, node.y - radius)
@@ -150,7 +2508,79 @@ const graphBounds = nodes => {
   }
 }
 
-const fitView = (options = { useFiltered: true }) => {
+const fitScaleBiasByNodeCount = nodeCount => {
+  if (nodeCount <= 6) return 1.22
+  if (nodeCount <= 20) return 1.12
+  if (nodeCount <= 60) return 1.04
+  if (nodeCount <= 180) return 1
+  if (nodeCount <= 600) return 0.94
+  if (nodeCount <= 2000) return 0.82
+  if (nodeCount <= 6000) return 0.68
+  return 0.56
+}
+
+const autoFitScaleRangeByNodeCount = nodeCount => {
+  if (nodeCount <= 6) return { min: 0.4, max: 2.2 }
+  if (nodeCount <= 20) return { min: 0.34, max: 1.65 }
+  if (nodeCount <= 60) return { min: 0.25, max: 1.22 }
+  if (nodeCount <= 180) return { min: 0.18, max: 0.92 }
+  if (nodeCount <= 600) return { min: 0.12, max: 0.72 }
+  if (nodeCount <= 2000) return { min: 0.08, max: 0.52 }
+  if (nodeCount <= 6000) return { min: 0.06, max: 0.32 }
+  return { min: 0.0012, max: 0.24 }
+}
+
+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.082 : 0.068
+  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.114 : 0.096
+  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)
   const height = Math.max(rect.height, 320)
@@ -159,33 +2589,141 @@ const fitView = (options = { useFiltered: true }) => {
 
   if (!bounds) {
     state.transform = { x: width / 2, y: height / 2, scale: 1 }
+    state.offscreenFrameCount = 0
+    state.recoveringViewport = false
+    markRenderDirty()
     return
   }
 
-  const padding = 100
+  const paddingByNodeCount = nodeCount => {
+    if (nodeCount <= 6) return 28
+    if (nodeCount <= 20) return 44
+    if (nodeCount <= 60) return 68
+    if (nodeCount <= 180) return 86
+    if (nodeCount <= 600) return 110
+    if (nodeCount <= 2000) return 140
+    return 180
+  }
+  const padding = paddingByNodeCount(nodes.length)
   const scaleX = width / (bounds.width + padding * 2)
   const scaleY = height / (bounds.height + padding * 2)
-  const scale = clampScale(Math.min(scaleX, scaleY))
-  const centerX = (bounds.minX + bounds.maxX) / 2
-  const centerY = (bounds.minY + bounds.maxY) / 2
+  const fitScale = Math.min(scaleX, scaleY)
+  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 hubCenter =
+    options.preferHubCenter && isDominantHub(state.primaryHub, nodes.length) && nodes.some((node) => node.id === state.primaryHub.id)
+      ? state.primaryHub
+      : null
+  const centerX = hubCenter ? hubCenter.x : (bounds.minX + bounds.maxX) / 2
+  const centerY = hubCenter ? hubCenter.y : (bounds.minY + bounds.maxY) / 2
+
+  state.transform = {
+    x: clampTransformCoordinate(width / 2 - centerX * resolvedScale),
+    y: clampTransformCoordinate(height / 2 - centerY * resolvedScale),
+    scale: clampScale(resolvedScale)
+  }
+  state.offscreenFrameCount = 0
+  state.recoveringViewport = false
+  markRenderDirty()
+}
+
+const resetView = () => fitView({ useFiltered: false, macro: true, preferHubCenter: true })
+
+const focusPrimaryHub = () => {
+  const hub = state.primaryHub
+  if (!hub) {
+    fitView({ useFiltered: true, macro: false, preferHubCenter: true })
+    return
+  }
+
+  const rect = canvas.getBoundingClientRect()
+  const width = Math.max(rect.width, 320)
+  const height = Math.max(rect.height, 320)
+  const targetScale = clampScale(Math.max(0.78, state.transform.scale))
 
   state.transform = {
-    x: width / 2 - centerX * scale,
-    y: height / 2 - centerY * scale,
-    scale
+    x: clampTransformCoordinate(width / 2 - hub.x * targetScale),
+    y: clampTransformCoordinate(height / 2 - hub.y * targetScale),
+    scale: targetScale
   }
+  state.offscreenFrameCount = 0
+  markRenderDirty()
 }
 
-const resetView = () => fitView({ useFiltered: false })
+const layoutDensityScaleForNodeCount = (nodeCount) => {
+  if (nodeCount > 50000) return 0.26
+  if (nodeCount > 20000) return 0.3
+  if (nodeCount > 6000) return 0.36
+  if (nodeCount > 2000) return 0.42
+  if (nodeCount > 600) return 0.5
+  if (nodeCount > 180) return 0.58
+  if (nodeCount > 60) return 0.68
+  if (nodeCount > 20) return 0.78
+  return 0.88
+}
 
 const createLayout = graph => {
-  const nodes = graph.nodes.map(node => ({
-    ...node,
-    x: Number.isFinite(node.x) ? node.x : 0,
-    y: Number.isFinite(node.y) ? node.y : 0
-  }))
+  const nodeRows = Array.isArray(graph.nodes) ? graph.nodes : []
+  const edgeRows = Array.isArray(graph.edges) ? graph.edges : []
+  const densityScale = layoutDensityScaleForNodeCount(nodeRows.length)
+  const nodes = nodeRows.map(node => {
+    if (Array.isArray(node)) {
+      const [id, title, x, y, group, segment] = node
+      return {
+        id: typeof id === 'string' ? id : '',
+        title: typeof title === 'string' ? title : 'Untitled',
+        path: '',
+        tags: [],
+        group: typeof group === 'string' ? group : 'root',
+        segment: typeof segment === 'string' ? segment : 'root',
+        x: Number.isFinite(x) ? x * densityScale : 0,
+        y: Number.isFinite(y) ? y * densityScale : 0,
+        vx: 0,
+        vy: 0
+      }
+    }
+
+    return {
+      ...node,
+      path: typeof node.path === 'string' ? node.path : '',
+      tags: Array.isArray(node.tags) ? node.tags : [],
+      x: Number.isFinite(node.x) ? node.x * densityScale : 0,
+      y: Number.isFinite(node.y) ? node.y * densityScale : 0,
+      vx: Number.isFinite(node.vx) ? node.vx : 0,
+      vy: Number.isFinite(node.vy) ? node.vy : 0
+    }
+  })
   const nodeMap = new Map(nodes.map(node => [node.id, node]))
-  const edges = graph.edges
+  const edges = edgeRows
+    .map(edge => {
+      if (Array.isArray(edge)) {
+        const [source, target, weight, priority] = edge
+        return {
+          source: typeof source === 'string' ? source : '',
+          target: typeof target === 'string' ? target : null,
+          targetTitle: '',
+          weight: Number.isFinite(weight) ? weight : 1,
+          priority: typeof priority === 'string' ? priority : 'normal'
+        }
+      }
+      return edge
+    })
     .filter(edge => edge.target && nodeMap.has(edge.source) && nodeMap.has(edge.target))
     .map(edge => ({ ...edge, sourceNode: nodeMap.get(edge.source), targetNode: nodeMap.get(edge.target) }))
   return { nodes, edges }
@@ -222,11 +2760,11 @@ const resetContentFilter = () => {
 
 const syncContentFilter = async (query, token) => {
   const response = await fetch(
-    '/api/graph-filter?q=' +
+      '/api/graph-filter?q=' +
       encodeURIComponent(query) +
       '&limit=' +
       encodeURIComponent(String(Math.max(state.nodes.length, 1))) +
-      agentQuery()
+      agentQuery('&')
   )
 
   if (!response.ok || token !== state.contentFilter.token) {
@@ -240,7 +2778,8 @@ const syncContentFilter = async (query, token) => {
   }
 
   state.contentFilter.query = query
-  state.contentFilter.ids = new Set(nodeIds)
+  const merged = new Set([...(state.contentFilter.ids instanceof Set ? state.contentFilter.ids : []), ...nodeIds])
+  state.contentFilter.ids = merged
   recomputeVisibility()
 }
 
@@ -261,28 +2800,59 @@ const scheduleContentFilterSync = () => {
     ids: state.contentFilter.ids,
     token,
     timer: setTimeout(() => {
+      if (state.filterWorker && state.filterReady) {
+        state.filterWorker.postMessage({
+          type: 'filter',
+          query,
+          token,
+          limit: Math.max(state.nodes.length, 1)
+        })
+      }
       syncContentFilter(query, token).catch(() => {})
     }, 180)
   }
 }
 
-const tick = delta => {
-  const nodes = state.visibleNodes
-  const edges = state.visibleEdges
-  if (nodes.length > 1200) {
+const tick = (delta, now) => {
+  const nodes = state.renderNodes.length > 0 ? state.renderNodes : state.visibleNodes
+  const edges = state.renderEdges.length > 0 ? state.renderEdges : state.visibleEdges
+  const shouldRunPhysics =
+    state.nodes.length <= 8000 &&
+    nodes.length <= 320 &&
+    state.transform.scale >= 0.08
+  if (!shouldRunPhysics) {
+    state.physicsRestFrames = 0
+    return
+  }
+  const isDragging = Boolean(state.pointer.dragNode)
+  const intervalMs = isDragging
+    ? physicsDragFrameIntervalMs
+    : state.nodes.length > largeGraphNodeThreshold
+      ? physicsLargeGraphIdleFrameIntervalMs
+      : physicsIdleFrameIntervalMs
+  if (!isDragging && state.physicsRestFrames >= 18) {
+    return
+  }
+  const elapsedSincePhysics = now - state.lastPhysicsAt
+  if (elapsedSincePhysics < intervalMs) {
     return
   }
-  const strength = Math.min(delta / 16, 2)
+  state.lastPhysicsAt = now
+  const strength = Math.min(Math.max(elapsedSincePhysics, delta, 16) / 16, physicsStepDeltaCapMs / 16)
 
   edges.forEach(edge => {
     const source = edge.sourceNode
     const target = edge.targetNode
+    source.vx = Number.isFinite(source.vx) ? source.vx : 0
+    source.vy = Number.isFinite(source.vy) ? source.vy : 0
+    target.vx = Number.isFinite(target.vx) ? target.vx : 0
+    target.vy = Number.isFinite(target.vy) ? target.vy : 0
     const dx = target.x - source.x
     const dy = target.y - source.y
     const distance = Math.max(Math.hypot(dx, dy), 1)
     const force = (distance - 150) * 0.002 * strength
-    const fx = dx * force
-    const fy = dy * force
+    const fx = (dx / distance) * force
+    const fy = (dy / distance) * force
     source.vx += fx
     source.vy += fy
     target.vx -= fx
@@ -293,6 +2863,10 @@ const tick = delta => {
     for (let j = i + 1; j < nodes.length; j += 1) {
       const a = nodes[i]
       const b = nodes[j]
+      a.vx = Number.isFinite(a.vx) ? a.vx : 0
+      a.vy = Number.isFinite(a.vy) ? a.vy : 0
+      b.vx = Number.isFinite(b.vx) ? b.vx : 0
+      b.vy = Number.isFinite(b.vy) ? b.vy : 0
       const dx = b.x - a.x
       const dy = b.y - a.y
       const distance = Math.max(Math.hypot(dx, dy), 1)
@@ -306,7 +2880,12 @@ const tick = delta => {
     }
   }
 
+  let kinetic = 0
   nodes.forEach(node => {
+    node.vx = Number.isFinite(node.vx) ? node.vx : 0
+    node.vy = Number.isFinite(node.vy) ? node.vy : 0
+    node.x = Number.isFinite(node.x) ? node.x : 0
+    node.y = Number.isFinite(node.y) ? node.y : 0
     if (state.pointer.dragNode === node) {
       node.vx = 0
       node.vy = 0
@@ -318,40 +2897,620 @@ const tick = delta => {
     node.vy *= 0.88
     node.x += node.vx * strength
     node.y += node.vy * strength
+    kinetic += Math.abs(node.vx) + Math.abs(node.vy)
   })
+  if (isDragging) {
+    state.physicsRestFrames = 0
+    return
+  }
+  const kineticFloor = Math.max(0.16, nodes.length * 0.01)
+  state.physicsRestFrames = kinetic <= kineticFloor
+    ? state.physicsRestFrames + 1
+    : 0
 }
 
 const worldPoint = event => {
   const rect = canvas.getBoundingClientRect()
-  return {
-    x: (event.clientX - rect.left - state.transform.x) / state.transform.scale,
-    y: (event.clientY - rect.top - state.transform.y) / state.transform.scale
+  return screenToWorldPoint(event.clientX - rect.left, event.clientY - rect.top)
+}
+
+const connectedNodeIdsFor = (nodeId) => {
+  const edges = state.visibleEdgeByNode.get(nodeId) ?? []
+  const ids = new Set()
+
+  for (let index = 0; index < edges.length; index += 1) {
+    const edge = edges[index]
+    if (!edge.target) continue
+    if (edge.source === nodeId) {
+      ids.add(edge.target)
+    } else if (edge.target === nodeId) {
+      ids.add(edge.source)
+    }
+  }
+
+  return ids
+}
+
+const applyDragNeighborhoodAdjustment = (dragNode, deltaX, deltaY) => {
+  if (!dragNode) return
+  if (!Number.isFinite(deltaX) || !Number.isFinite(deltaY)) return
+  if (Math.abs(deltaX) + Math.abs(deltaY) <= 0.001) return
+
+  const scale = Math.max(state.transform.scale, 0.0001)
+  const influenceRadius = Math.max(220, Math.min(920, 440 / scale))
+  const influenceRadiusSquared = influenceRadius * influenceRadius
+  const connectedIds = connectedNodeIdsFor(dragNode.id)
+  const candidates = state.renderNodes.length > 0 ? state.renderNodes : state.visibleNodes
+  let adjusted = 0
+
+  for (let index = 0; index < candidates.length && adjusted < dragNeighborhoodMaxAffected; index += 1) {
+    const node = candidates[index]
+    if (node.id === dragNode.id) continue
+
+    const isConnected = connectedIds.has(node.id)
+    const dx = node.x - dragNode.x
+    const dy = node.y - dragNode.y
+    const distanceSquared = dx * dx + dy * dy
+    const withinRadius = distanceSquared <= influenceRadiusSquared
+    if (!isConnected && !withinRadius) continue
+
+    const distance = Math.max(Math.sqrt(distanceSquared), 0.0001)
+    const proximity = withinRadius ? 1 - (distance / influenceRadius) : 0
+    const coupledStrength = isConnected ? 0.28 : 0.12
+    const influence = Math.min(0.46, coupledStrength + proximity * 0.34)
+    node.x += deltaX * influence
+    node.y += deltaY * influence
+    node.vx = (Number.isFinite(node.vx) ? node.vx : 0) + deltaX * influence * 0.06
+    node.vy = (Number.isFinite(node.vy) ? node.vy : 0) + deltaY * influence * 0.06
+    adjusted += 1
+  }
+}
+
+const settleNeighborhoodAroundNode = (dragNode) => {
+  if (!dragNode) return
+
+  const scale = Math.max(state.transform.scale, 0.0001)
+  const settleRadius = Math.max(240, Math.min(980, 520 / scale))
+  const settleRadiusSquared = settleRadius * settleRadius
+  const connectedIds = connectedNodeIdsFor(dragNode.id)
+  const candidates = (state.renderNodes.length > 0 ? state.renderNodes : state.visibleNodes)
+    .filter((node) => {
+      if (node.id === dragNode.id) return true
+      const dx = node.x - dragNode.x
+      const dy = node.y - dragNode.y
+      const distanceSquared = dx * dx + dy * dy
+      return connectedIds.has(node.id) || distanceSquared <= settleRadiusSquared
+    })
+    .slice(0, dragNeighborhoodMaxAffected)
+
+  if (candidates.length <= 1) return
+
+  for (let round = 0; round < dragSettleRounds; round += 1) {
+    for (let leftIndex = 0; leftIndex < candidates.length; leftIndex += 1) {
+      const left = candidates[leftIndex]
+      for (let rightIndex = leftIndex + 1; rightIndex < candidates.length; rightIndex += 1) {
+        const right = candidates[rightIndex]
+        const dx = right.x - left.x
+        const dy = right.y - left.y
+        const distance = Math.max(Math.hypot(dx, dy), 0.001)
+        const minDistance = baseNodeRadius(left) + baseNodeRadius(right) + 10
+        if (distance >= minDistance) continue
+
+        const push = (minDistance - distance) * 0.36
+        const ux = dx / distance
+        const uy = dy / distance
+        if (left.id !== dragNode.id) {
+          left.x -= ux * push
+          left.y -= uy * push
+        }
+        if (right.id !== dragNode.id) {
+          right.x += ux * push
+          right.y += uy * push
+        }
+      }
+    }
   }
 }
 
 const hitNode = point => {
-  if (state.nodes.length > largeGraphNodeThreshold && state.transform.scale < 0.55) {
+  computeRenderVisibility()
+  if (state.renderClusters.length > 0) {
+    return null
+  }
+  const hitScaleFloor = state.nodes.length > massiveGraphNodeThreshold
+    ? 0.2
+    : state.nodes.length > largeGraphNodeThreshold
+      ? 0.34
+      : 0
+  if (state.transform.scale < hitScaleFloor) {
     return null
   }
 
-  const nodes = state.visibleNodes
+  const nodes = state.renderNodes
   for (let index = nodes.length - 1; index >= 0; index -= 1) {
     const node = nodes[index]
-    const radius = nodeRadius(node)
-    if (Math.hypot(point.x - node.x, point.y - node.y) <= radius + 5) return node
+    const radius = nodeRadius(node) * nodeRenderScale(node)
+    const x = nodeRenderX(node)
+    const y = nodeRenderY(node)
+    if (Math.hypot(point.x - x, point.y - y) <= radius + 5) return node
   }
   return null
 }
 
-const nodeRadius = node => {
+const baseNodeRadius = node => {
   const degree = state.nodeDegrees.get(node.id) ?? 0
   return 9 + Math.min(degree, 8) * 1.6
 }
 
+const nodeRadius = node => Math.max(baseNodeRadius(node), minNodePixelRadius / Math.max(state.transform.scale, 0.0001))
+
+const 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 = () =>
+  state.renderClusters.length === 0 &&
+  state.renderNodes.length >= graphDepthProjectionNodeThreshold &&
+  state.renderNodes.length <= graphDepthProjectionNodeCap &&
+  state.transform.scale >= graphDepthProjectionMinScale &&
+  state.transform.scale <= graphDepthProjectionMaxScale &&
+  !state.pointer.down
+
+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
+}
+
+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 = () => {
+  const width = Math.max(state.viewport.width, 320)
+  const height = Math.max(state.viewport.height, 320)
+  const paddingMultiplier =
+    state.nodes.length > massiveGraphNodeThreshold
+      ? (state.transform.scale >= 0.6 ? 2.8 : state.transform.scale >= 0.25 ? 2.35 : 1.9)
+      : state.nodes.length > largeGraphNodeThreshold
+        ? 1.45
+        : 1
+  const padding = viewportPaddingPx * paddingMultiplier
+
+  return {
+    minX: (-state.transform.x - padding) / state.transform.scale,
+    maxX: (width - state.transform.x + padding) / state.transform.scale,
+    minY: (-state.transform.y - padding) / state.transform.scale,
+    maxY: (height - state.transform.y + padding) / state.transform.scale
+  }
+}
+
+const isNodeInViewport = (node, viewport) =>
+  node.x >= viewport.minX &&
+  node.x <= viewport.maxX &&
+  node.y >= viewport.minY &&
+  node.y <= viewport.maxY
+
+const expandViewportBounds = (viewport, worldMargin) => ({
+  minX: viewport.minX - worldMargin,
+  maxX: viewport.maxX + worldMargin,
+  minY: viewport.minY - worldMargin,
+  maxY: viewport.maxY + worldMargin
+})
+
+const viewportNodeStride = () => {
+  if (state.nodes.length <= largeGraphNodeThreshold) {
+    return 1
+  }
+
+  if (state.transform.scale >= 0.95) {
+    return 1
+  }
+  if (state.transform.scale >= 0.7) {
+    return 2
+  }
+  if (state.transform.scale >= 0.48) {
+    return 3
+  }
+  if (state.transform.scale >= 0.28) {
+    return 5
+  }
+
+  return 8
+}
+
+const 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 })
+  }
+  const viewport = worldViewportBounds()
+  const viewportKey =
+    Math.round(viewport.minX * 10) + ':' +
+    Math.round(viewport.maxX * 10) + ':' +
+    Math.round(viewport.minY * 10) + ':' +
+    Math.round(viewport.maxY * 10) + ':' +
+    visibilityScaleBucket(state.transform.scale)
+
+  if (!state.renderVisibilityDirty && viewportKey === state.lastViewportKey) {
+    return
+  }
+  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
+  }
+
+  const ecosystemScaleThreshold = state.visibleNodes.length > massiveGraphNodeThreshold
+    ? massiveEcosystemClusterScaleThreshold
+    : ecosystemClusterScaleThreshold
+  if (
+    state.ecosystemExpansionLevels.length > 0 &&
+    state.transform.scale <= ecosystemScaleThreshold &&
+    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
+  }
+
+  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
+  }
+
+  if (state.visibleNodes.length > massiveGraphNodeThreshold) {
+    const viewportNodes = viewportNodesFromSpatialIndex(viewport)
+    const sourceNodes = viewportNodes.length > 0 ? viewportNodes : state.visibleNodes
+    const sampleLimit = nodeBudgetForScale(state.transform.scale)
+    const carryMargin = Math.max(240, Math.min(1200, 340 / Math.max(state.transform.scale, 0.0001)))
+    const carryViewport = expandViewportBounds(viewport, carryMargin)
+    const carryOverLimit = Math.max(180, Math.min(sampleLimit, Math.floor(sampleLimit * 0.5)))
+    const carryOverNodes = (state.renderNodes ?? [])
+      .filter((node) => isNodeInViewport(node, carryViewport))
+      .slice(0, carryOverLimit)
+    const sourceWithCarry = mergeUniqueNodes(
+      sourceNodes,
+      carryOverNodes,
+      Math.max(sampleLimit * 7, carryOverLimit)
+    )
+    const sourceWithCarryIds = new Set(sourceWithCarry.map((node) => node.id))
+    const sampledRaw = selectStableSampleNodes(
+      sourceWithCarry,
+      sampleLimit
+    )
+    const continuityBudget = Math.max(24, Math.min(sampleLimit - 8, Math.floor(sampleLimit * 0.42)))
+    const previousVisibleNodes = (state.renderNodes ?? [])
+      .filter((node) => sourceWithCarryIds.has(node.id))
+    const continuityNodes = selectStableSampleNodes(previousVisibleNodes, continuityBudget)
+    const sampled = mergeUniqueNodes(
+      continuityNodes,
+      sampledRaw,
+      sampleLimit
+    )
+    let sampledNodes = ensureHubNodesInRenderedSet(sampled)
+    if (state.transform.scale < 0.035) {
+      sampledNodes = includeHubPreviewNeighborhood(
+        sampledNodes,
+        Math.min(renderNodeBudget, sampleLimit + 160)
+      )
+    }
+    const sampledIds = new Set(sampledNodes.map((node) => node.id))
+    let sampledEdges = collectVisibleEdgesForNodes(sampledIds)
+
+    if (state.transform.scale >= 0.035 && sampledEdges.length === 0) {
+      const enriched = enrichSampleWithNeighbors(sampledNodes)
+      sampledNodes = ensureHubNodesInRenderedSet(enriched.nodes)
+      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
+  }
+
+  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 = []
+
+  for (let index = 0; index < viewportNodes.length; index += 1) {
+    const node = viewportNodes[index]
+
+    const isPriority =
+      node.id === state.selected?.id ||
+      node.id === state.hovered?.id ||
+      node.id === state.pointer.dragNode?.id
+    if (isPriority || index % stride === 0) {
+      picked.push(node)
+    }
+  }
+
+  const nodes = picked.length > renderNodeBudget
+    ? picked.slice(0, renderNodeBudget)
+    : picked
+  if (nodes.length === 0 && state.visibleNodes.length > 0) {
+    const 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
+  }
+
+  const normalizedNodes = ensureHubNodesInRenderedSet(nodes)
+  const nodeIds = new Set(normalizedNodes.map((node) => node.id))
+  const edges = collectVisibleEdgesForNodes(nodeIds)
+
+  state.renderNodes = normalizedNodes
+  state.renderEdges = withMeshEdges(normalizedNodes, edges)
+
+  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))
+  }
+}
+
+const isNodeVisibleOnScreen = (node, width, height) => {
+  const radius = nodeRadius(node) * state.transform.scale
+  const screenX = node.x * state.transform.scale + state.transform.x
+  const screenY = node.y * state.transform.scale + state.transform.y
+
+  return (
+    screenX + radius >= 0 &&
+    screenX - radius <= width &&
+    screenY + radius >= 0 &&
+    screenY - radius <= height
+  )
+}
+
+const hasValidTransform = () =>
+  isFiniteNumber(state.transform.x) &&
+  isFiniteNumber(state.transform.y) &&
+  isFiniteNumber(state.transform.scale) &&
+  Math.abs(state.transform.x) <= transformCoordinateLimit &&
+  Math.abs(state.transform.y) <= transformCoordinateLimit &&
+  state.transform.scale > 0
+
+const sanitizeNodePosition = node => {
+  if (!isReasonableCoordinate(node.x)) node.x = 0
+  if (!isReasonableCoordinate(node.y)) node.y = 0
+  if (!isFiniteNumber(node.vx) || Math.abs(node.vx) > worldCoordinateLimit) node.vx = 0
+  if (!isFiniteNumber(node.vy) || Math.abs(node.vy) > worldCoordinateLimit) node.vy = 0
+}
+
+const sanitizeAllNodePositions = () => {
+  state.nodes.forEach(sanitizeNodePosition)
+  state.visibleNodes.forEach(sanitizeNodePosition)
+}
+
+const sanitizeGraphState = () => {
+  state.renderNodes.forEach(sanitizeNodePosition)
+}
+
 const render = now => {
   const delta = now - state.last
   state.last = now
-  const minFrameIntervalMs = state.nodes.length > largeGraphNodeThreshold ? 180 : 16
+  const backgroundFrameIntervalMs =
+    state.nodes.length > massiveGraphNodeThreshold
+      ? (state.transform.scale < 0.035 ? 156 : state.transform.scale < 0.08 ? 128 : 98)
+      : state.nodes.length > largeGraphNodeThreshold
+        ? 72
+        : 18
+  const isInteracting =
+    state.pointer.down ||
+    state.renderVisibilityDirty ||
+    state.recoveringViewport
+  const minFrameIntervalMs = isInteracting ? 16 : backgroundFrameIntervalMs
   if (delta < minFrameIntervalMs) {
     requestAnimationFrame(render)
     return
@@ -359,7 +3518,13 @@ const render = now => {
   const rect = canvas.getBoundingClientRect()
   const width = Math.max(rect.width, 320)
   const height = Math.max(rect.height, 320)
+  state.viewport = { width, height }
+  sanitizeGraphState()
+  if (!hasValidTransform()) {
+    resetView()
+  }
   ctx.clearRect(0, 0, width, height)
+  webGlRenderer?.clear(width, height)
   if (state.nodes.length === 0) {
     ctx.fillStyle = '#99a5b5'
     ctx.font = '14px Inter, system-ui, sans-serif'
@@ -368,54 +3533,117 @@ const render = now => {
     requestAnimationFrame(render)
     return
   }
-  ctx.save()
-  ctx.translate(state.transform.x, state.transform.y)
-  ctx.scale(state.transform.scale, state.transform.scale)
 
-  tick(delta)
-  const drawEdges = !(state.nodes.length > largeGraphNodeThreshold && state.transform.scale < 0.22)
-  if (drawEdges) {
-    state.visibleEdges.forEach(edge => {
-    const selectedEdge = state.selected && (edge.source === state.selected.id || edge.target === state.selected.id)
-    ctx.beginPath()
-    ctx.moveTo(edge.sourceNode.x, edge.sourceNode.y)
-    ctx.lineTo(edge.targetNode.x, edge.targetNode.y)
-    ctx.strokeStyle = selectedEdge ? graphTheme.edgeActive : graphTheme.edge
-    ctx.lineWidth = (selectedEdge ? 1.8 : 1) + Math.min(edgeWeight(edge) - 1, 8) * 0.22
-    ctx.stroke()
-    })
+  computeRenderVisibility()
+  tick(delta, now)
+  refreshRenderNodeDepthProjection()
+  const hasVisibleNodeOnScreen = state.renderNodes.some((node) => isNodeVisibleOnScreen(node, width, height))
+  const manualZoomGuardActive = now - state.lastManualZoomAt < zoomRecoveryGuardMs
+  const allowViewportAutoRecovery = state.nodes.length <= massiveGraphNodeThreshold
+  if (allowViewportAutoRecovery && !hasVisibleNodeOnScreen && state.renderNodes.length > 0 && !manualZoomGuardActive) {
+    state.offscreenFrameCount += 1
+    if (state.offscreenFrameCount >= 22 && !state.recoveringViewport) {
+      state.recoveringViewport = true
+      fitView({ useFiltered: true })
+      state.offscreenFrameCount = 0
+      requestAnimationFrame(() => {
+        state.recoveringViewport = false
+      })
+    }
+  } else {
+    state.offscreenFrameCount = 0
   }
-
-  state.visibleNodes.forEach(node => {
-    const radius = nodeRadius(node)
-    const isSelected = state.selected?.id === node.id
-    const isHovered = state.hovered?.id === node.id
-    ctx.beginPath()
-    ctx.arc(node.x, node.y, radius + (isSelected ? 7 : isHovered ? 4 : 0), 0, Math.PI * 2)
-    ctx.fillStyle = isSelected || isHovered ? graphTheme.nodeHaloActive : graphTheme.nodeHalo
-    ctx.fill()
-    ctx.beginPath()
-    ctx.arc(node.x, node.y, radius, 0, Math.PI * 2)
-    ctx.fillStyle = isSelected ? graphTheme.nodeSelected : isHovered ? graphTheme.nodeHover : graphTheme.node
-    ctx.fill()
-    ctx.lineWidth = isSelected ? 2.6 : 1.5
-    ctx.strokeStyle = isSelected ? graphTheme.nodeStrokeActive : graphTheme.nodeStroke
-    ctx.stroke()
-
-    const shouldDrawLabels =
-      isSelected ||
-      isHovered ||
-      (state.nodes.length <= largeGraphNodeThreshold && (state.transform.scale > 1.18 || state.nodes.length <= 25))
-    if (shouldDrawLabels) {
-      ctx.fillStyle = graphTheme.label
-      ctx.font = '12px Inter, system-ui, sans-serif'
-      ctx.textAlign = 'center'
-      ctx.textBaseline = 'top'
-      ctx.fillText(node.title.slice(0, 34), node.x, node.y + radius + 8)
+  const minimumEdgeScale =
+    state.nodes.length > massiveGraphNodeThreshold
+      ? 0
+      : state.renderNodes.length > 1300
+        ? 0.12
+        : state.renderNodes.length > 900
+          ? 0.085
+          : state.renderNodes.length > 500
+            ? 0.05
+            : 0
+  const drawEdges =
+    state.renderClusters.length === 0 &&
+    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()
+      }
     }
-  })
-
-  ctx.restore()
+    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)
+    ctx.scale(state.transform.scale, state.transform.scale)
+    if (drawEdges) {
+      drawGraphEdges()
+    }
+    drawGraphNodes()
+    ctx.restore()
+  }
+  if (state.renderNodes.length === 0 && state.renderClusters.length === 0) {
+    ctx.fillStyle = '#99a5b5'
+    ctx.font = '12px Inter, system-ui, sans-serif'
+    ctx.textAlign = 'center'
+    ctx.fillText('Move or zoom to reveal nearby notes', width / 2, height / 2)
+  }
   requestAnimationFrame(render)
 }
 
@@ -430,11 +3658,11 @@ const linkedNodes = node => {
     weight: edge.weight,
     priority: edge.priority
   } : null
-  const outgoing = state.graph.edges
+  const outgoing = state.edges
     .filter(edge => edge.source === node.id)
-    .map(edge => withEdgeMeta(edge.target ? nodeById.get(edge.target) : { title: edge.targetTitle + ' (unresolved)', path: 'Missing note' }, edge))
+    .map(edge => withEdgeMeta(edge.target ? nodeById.get(edge.target) : { title: (edge.targetTitle || 'Unknown') + ' (unresolved)', path: 'Missing note' }, edge))
     .filter(Boolean)
-  const incoming = state.graph.edges
+  const incoming = state.edges
     .filter(edge => edge.target === node.id)
     .map(edge => withEdgeMeta(nodeById.get(edge.source), edge))
     .filter(Boolean)
@@ -448,7 +3676,7 @@ const fetchNodeDetails = async node => {
     return cached
   }
 
-  const response = await fetch('/api/graph-node?id=' + encodeURIComponent(node.id) + agentQuery())
+  const response = await fetch('/api/graph-node?id=' + encodeURIComponent(node.id) + agentQuery('&'))
   if (!response.ok) {
     throw new Error('Failed to load graph node details')
   }
@@ -462,29 +3690,49 @@ const fetchNodeDetails = async node => {
   return detail
 }
 
+const wait = async (milliseconds) => new Promise(resolve => setTimeout(resolve, milliseconds))
+
 const openContentDialog = async node => {
   if (!node) return
-  const { outgoing, incoming } = linkedNodes(node)
-  elements.contentTitle.textContent = node.title
-  elements.contentPath.textContent = node.path
-  elements.contentTags.innerHTML = node.tags.length
+  elements.contentTitle.textContent = node.title || 'Loading...'
+  elements.contentPath.textContent = node.path || 'Loading...'
+  elements.contentTags.innerHTML = Array.isArray(node.tags) && node.tags.length
     ? node.tags.map(tag => '<span>#' + escapeHtml(tag) + '</span>').join('')
     : '<span>No tags</span>'
-  elements.contentOutgoing.innerHTML = list(outgoing)
-  elements.contentIncoming.innerHTML = list(incoming)
+  const initialLinks = linkedNodes(node)
+  elements.contentOutgoing.innerHTML = list(initialLinks.outgoing)
+  elements.contentIncoming.innerHTML = list(initialLinks.incoming)
   elements.contentBody.textContent = 'Loading note content...'
   if (!elements.contentDialog.open) {
     elements.contentDialog.showModal()
   }
 
+  const applyDetailToDialog = detail => {
+    elements.contentTitle.textContent = detail.title
+    elements.contentPath.textContent = detail.path
+    elements.contentTags.innerHTML = detail.tags.length
+      ? detail.tags.map(tag => '<span>#' + escapeHtml(tag) + '</span>').join('')
+      : '<span>No tags</span>'
+    elements.contentBody.textContent = detail.content
+  }
+
   try {
     const detailedNode = await fetchNodeDetails(node)
     if (state.selected?.id !== node.id) {
       return
     }
-    elements.contentBody.textContent = detailedNode.content
+    applyDetailToDialog(detailedNode)
   } catch {
-    elements.contentBody.textContent = 'Unable to load note content.'
+    try {
+      await wait(120)
+      const retriedNode = await fetchNodeDetails(node)
+      if (state.selected?.id !== node.id) {
+        return
+      }
+      applyDetailToDialog(retriedNode)
+    } catch {
+      elements.contentBody.textContent = 'Unable to load note content.'
+    }
   }
 }
 
@@ -502,14 +3750,70 @@ const selectNodeById = id => {
   if (node) selectNode(node, { openContent: true })
 }
 
-const zoomAtPoint = (screenX, screenY, factor) => {
-  const nextScale = clampScale(state.transform.scale * factor)
-  if (nextScale === state.transform.scale) return
-  const worldX = (screenX - state.transform.x) / state.transform.scale
-  const worldY = (screenY - state.transform.y) / state.transform.scale
-  state.transform.scale = nextScale
-  state.transform.x = screenX - worldX * nextScale
-  state.transform.y = screenY - worldY * nextScale
+const zoomAtPoint = (screenX, screenY, factor, source = 'generic') => {
+  state.lastManualZoomAt = performance.now()
+  const effectiveFactor = factor
+  const nextScale = clampScale(state.transform.scale * effectiveFactor)
+  if (nextScale === state.transform.scale) {
+    return
+  }
+  const worldPointAtCursor = screenToWorldPoint(screenX, screenY)
+  const worldX = worldPointAtCursor.x
+  const worldY = worldPointAtCursor.y
+  state.lastZoomFocus = {
+    x: worldX,
+    y: worldY,
+    at: performance.now()
+  }
+  state.transform.scale = clampScale(nextScale)
+  state.transform.x = clampTransformCoordinate(screenX - worldX * nextScale)
+  state.transform.y = clampTransformCoordinate(screenY - worldY * nextScale)
+  state.offscreenFrameCount = 0
+  markRenderDirty()
+}
+
+const wheelZoomFactor = event => {
+  const isModifierZoom = event.metaKey || event.ctrlKey
+  const deltaModeFactor = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? 120 : 1
+  const normalizedDelta = event.deltaY * deltaModeFactor
+
+  if (!Number.isFinite(normalizedDelta) || Math.abs(normalizedDelta) <= 0.0001) {
+    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 sensitivity = wheelZoomExponent * (isModifierZoom ? wheelZoomModifierBoost : 1) * sensitivityMultiplier
+  const exponentCap = wheelZoomExponentCap * capMultiplier
+  const exponent = Math.max(
+    -exponentCap,
+    Math.min(exponentCap, -normalizedDelta * sensitivity)
+  )
+  return Math.exp(exponent)
+}
+
+const handleWheelZoom = event => {
+  if (elements.contentDialog?.open) {
+    return
+  }
+
+  event.preventDefault()
+  const rect = canvas.getBoundingClientRect()
+  const rawCursorX = Number.isFinite(event.offsetX) ? event.offsetX : event.clientX - rect.left
+  const rawCursorY = Number.isFinite(event.offsetY) ? event.offsetY : event.clientY - rect.top
+  const cursorX = Math.max(0, Math.min(Math.max(rect.width, 320), rawCursorX))
+  const cursorY = Math.max(0, Math.min(Math.max(rect.height, 320), rawCursorY))
+  state.cursor = { x: event.clientX, y: event.clientY, inCanvas: true }
+  const factor = wheelZoomFactor(event)
+
+  if (!Number.isFinite(factor) || factor <= 0 || factor === 1) {
+    return
+  }
+
+  zoomAtPoint(cursorX, cursorY, factor, 'wheel')
 }
 
 const bindEvents = () => {
@@ -521,6 +3825,8 @@ const bindEvents = () => {
   })
   elements.agent.addEventListener('change', event => {
     state.agentId = event.target.value
+    writeStoredAgent(state.agentId)
+    syncAgentInUrl(state.agentId)
     state.selected = null
     state.nodeDetails = new Map()
     resetContentFilter()
@@ -532,15 +3838,15 @@ const bindEvents = () => {
   })
   elements.zoomIn.addEventListener('click', () => {
     const rect = canvas.getBoundingClientRect()
-    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.18)
+    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.055, 'button')
   })
   elements.zoomOut.addEventListener('click', () => {
     const rect = canvas.getBoundingClientRect()
-    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.84)
+    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.948, 'button')
   })
   if (elements.fit) {
     elements.fit.addEventListener('click', () => {
-      fitView({ useFiltered: true })
+      focusPrimaryHub()
     })
   }
   elements.reset.addEventListener('click', () => {
@@ -555,14 +3861,20 @@ const bindEvents = () => {
     }
     if (event.target === elements.contentDialog) elements.contentDialog.close()
   })
-  canvas.addEventListener('wheel', event => {
-    event.preventDefault()
+  canvas.addEventListener('wheel', handleWheelZoom, { passive: false })
+  canvas.addEventListener('dblclick', event => {
+    const point = worldPoint(event)
+    const node = hitNode(point)
+    if (node) {
+      selectNode(node, { openContent: true })
+      return
+    }
+
     const rect = canvas.getBoundingClientRect()
     const cursorX = event.clientX - rect.left
     const cursorY = event.clientY - rect.top
-    const factor = event.deltaY < 0 ? 1.08 : 0.92
-    zoomAtPoint(cursorX, cursorY, factor)
-  }, { passive: false })
+    zoomAtPoint(cursorX, cursorY, 1.055)
+  })
   canvas.addEventListener('pointerdown', event => {
     const point = worldPoint(event)
     const node = hitNode(point)
@@ -570,12 +3882,24 @@ const bindEvents = () => {
     if (node) {
       node.x = point.x
       node.y = point.y
+      markRenderDirty()
     }
     canvas.setPointerCapture(event.pointerId)
   })
   canvas.addEventListener('pointermove', event => {
     const point = worldPoint(event)
-    state.hovered = hitNode(point)
+    const now = performance.now()
+    const canHoverHitTest =
+      !(state.nodes.length > massiveGraphNodeThreshold && state.transform.scale < 0.06)
+    const shouldHitTest = canHoverHitTest &&
+      (state.pointer.down || now - state.lastHoverHitAt >= hoverHitTestIntervalMs)
+    if (shouldHitTest) {
+      state.hovered = hitNode(point)
+      state.lastHoverHitAt = now
+    } else if (!canHoverHitTest) {
+      state.hovered = null
+    }
+    state.cursor = { x: event.clientX, y: event.clientY, inCanvas: true }
     if (!state.pointer.down) return
     const dx = event.clientX - state.pointer.x
     const dy = event.clientY - state.pointer.y
@@ -583,36 +3907,83 @@ const bindEvents = () => {
     state.pointer.y = event.clientY
     state.pointer.moved = state.pointer.moved || Math.abs(dx) + Math.abs(dy) > 3
     if (state.pointer.dragNode) {
-      state.pointer.dragNode.x = point.x
-      state.pointer.dragNode.y = point.y
+      const dragNode = state.pointer.dragNode
+      const previousX = dragNode.x
+      const previousY = dragNode.y
+      dragNode.x = point.x
+      dragNode.y = point.y
+      applyDragNeighborhoodAdjustment(dragNode, dragNode.x - previousX, dragNode.y - previousY)
+      markRenderDirty()
       return
     }
     state.transform.x += dx
     state.transform.y += dy
+    state.transform.x = clampTransformCoordinate(state.transform.x)
+    state.transform.y = clampTransformCoordinate(state.transform.y)
+    state.offscreenFrameCount = 0
+    markRenderDirty()
   })
   canvas.addEventListener('pointerup', event => {
-    if (state.pointer.dragNode && !state.pointer.moved) selectNode(state.pointer.dragNode, { openContent: true })
-    if (!state.pointer.dragNode && !state.pointer.moved) selectNode(state.hovered, { openContent: true })
+    const draggedNode = state.pointer.dragNode
+    if (draggedNode && state.pointer.moved) {
+      settleNeighborhoodAroundNode(draggedNode)
+      markRenderDirty()
+    }
+    if (draggedNode && !state.pointer.moved) selectNode(draggedNode, { openContent: false })
+    if (!draggedNode && !state.pointer.moved) selectNode(state.hovered, { openContent: false })
     state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
     canvas.releasePointerCapture(event.pointerId)
   })
+  canvas.addEventListener('pointercancel', () => {
+    state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
+  })
+  canvas.addEventListener('pointerenter', event => {
+    state.cursor = { x: event.clientX, y: event.clientY, inCanvas: true }
+  })
+  canvas.addEventListener('pointerleave', event => {
+    state.cursor = { x: event.clientX, y: event.clientY, inCanvas: false }
+  })
+  window.addEventListener('keydown', event => {
+    if (event.key === '+' || event.key === '=') {
+      event.preventDefault()
+      const rect = canvas.getBoundingClientRect()
+      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.05)
+      return
+    }
+
+    if (event.key === '-' || event.key === '_') {
+      event.preventDefault()
+      const rect = canvas.getBoundingClientRect()
+      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.952)
+      return
+    }
+
+    if (event.key === '0') {
+      event.preventDefault()
+      resetView()
+    }
+  })
 }
 
 const loadAgents = async () => {
   const response = await fetch('/api/agents')
   const payload = await response.json()
   const agents = Array.isArray(payload.agents) ? payload.agents : []
-  const currentExists = agents.some(agent => agent.id === state.agentId)
+  const preferredAgent = state.agentId || initialAgentFromUrl || readStoredAgent()
+  const currentExists = agents.some(agent => agent.id === preferredAgent)
   const selected = currentExists
-    ? state.agentId
+    ? preferredAgent
     : (agents.find(agent => agent.id === 'shared')?.id ?? agents[0]?.id ?? 'shared')
   const signature = JSON.stringify(agents.map(agent => [agent.id, agent.documentCount]))
 
   state.agentId = selected
+  writeStoredAgent(selected)
+  syncAgentInUrl(selected)
   if (signature !== state.agentsSignature) {
+    const formatAgentLabel = (agent) => agent.id
     elements.agent.innerHTML = agents.length
-      ? agents.map(agent => '<option value="' + escapeHtml(agent.id) + '">' + escapeHtml(agent.id) + ' · ' + agent.documentCount + '</option>').join('')
-      : '<option value="shared">shared · 0</option>'
+      ? agents.map(agent => '<option value="' + escapeHtml(agent.id) + '">' + escapeHtml(formatAgentLabel(agent)) + '</option>').join('')
+      : '<option value="shared">shared</option>'
     state.agentsSignature = signature
   }
   elements.agent.value = selected
@@ -633,6 +4004,10 @@ const loadGraph = async (options = { reset: false }) => {
 
   const payload = await response.json()
   const graph = payload?.layout ?? payload
+  state.graphTotals = {
+    nodes: Number.isFinite(payload?.totals?.nodes) ? payload.totals.nodes : (Array.isArray(graph.nodes) ? graph.nodes.length : 0),
+    edges: Number.isFinite(payload?.totals?.edges) ? payload.totals.edges : (Array.isArray(graph.edges) ? graph.edges.length : 0)
+  }
   const signature = payload?.signature ?? graphSignature(graph)
   if (!options.reset && signature === state.graphSignature) return
   const selectedId = state.selected?.id
@@ -640,6 +4015,7 @@ const loadGraph = async (options = { reset: false }) => {
   state.graphSignature = signature
   state.graph = graph
   state.nodes = layout.nodes
+  state.nodeById = new Map(state.nodes.map((node) => [node.id, node]))
   state.edges = layout.edges
   state.nodeDegrees = state.edges.reduce((degrees, edge) => {
     degrees.set(edge.source, (degrees.get(edge.source) ?? 0) + edgeWeight(edge))
@@ -649,13 +4025,15 @@ const loadGraph = async (options = { reset: false }) => {
     return degrees
   }, new Map())
   state.nodeDetails = new Map()
+  pushNodesToFilterWorker()
   resetContentFilter()
+  sanitizeAllNodePositions()
   recomputeVisibility()
   scheduleContentFilterSync()
-  const tags = new Set(graph.nodes.flatMap(node => node.tags))
-  setGraphStatus(state.agentId + ' · ' + graph.nodes.length + ' notes · ' + graph.edges.length + ' links · live')
-  elements.nodeCount.textContent = graph.nodes.length
-  elements.edgeCount.textContent = graph.edges.length
+  const tags = new Set(state.nodes.flatMap(node => node.tags))
+  setGraphStatus(state.agentId + ' · ' + state.graphTotals.nodes + ' notes · ' + state.graphTotals.edges + ' links · live')
+  elements.nodeCount.textContent = state.graphTotals.nodes
+  elements.edgeCount.textContent = state.graphTotals.edges
   elements.tagCount.textContent = tags.size
   resize()
   if (options.reset) resetView()
@@ -667,6 +4045,7 @@ const loadGraph = async (options = { reset: false }) => {
 }
 
 bindEvents()
+initFilterWorker()
 requestAnimationFrame(() => {
   resize()
   resetView()