@andespindola/brainlink 0.1.0-beta.139 → 0.1.0-beta.140

package/README.md

@@ -82,13 +82,13 @@ Legacy `.jsonl.gz` packs are upgraded to `.blpk` automatically on first search/c
 - Built-in MCP stdio server for agent tool integration.
 - Local HTTP API.
 - Realtime graph UI with agent selector and colored knowledge groups.
-- Graph renderer optimized for large datasets with viewport-driven node culling and edge lookup by visible nodes.
+- Graph renderer keeps the full filtered graph visible during zoom/pan, rendering every visible node and edge without viewport culling.
 - Canvas graph rendering uses the same batched node and edge pipeline for every graph size, reducing per-frame draw calls while keeping selected and hovered items highlighted.
 - WebGL acceleration is used when available for dense node and edge drawing, with Canvas 2D preserved as the interaction and fallback layer.
 - Large graph layout API automatically uses compact payload encoding with link-coverage-aware edge selection to reduce initial client load without hiding major relationships.
 - Large-segment layout spacing now grows logarithmically to keep initial visual density consistent between medium and very large vaults (for example, ~1k vs ~50k notes).
 - Graph coordinates are visually compacted across graph sizes so reset starts from a stable fitted scene and zoom-in progressively reveals local detail.
-- Zoomed-out graph LOD keeps a single flat graph scene, with viewport-driven node sampling and edge coverage safeguards to preserve visible relationships without switching to nested subgraphs.
+- Zoomed-out graph keeps the same flat graph scene and preserves complete filtered relationships without switching to nested subgraphs.
 - Graph reset fits the full graph scene instead of starting in a separate macro overview mode.
 - Graph filtering runs in a dedicated browser worker to keep the UI thread responsive during heavy datasets.
 - Edge rendering budgets adapt to zoom level to prevent frame spikes on large graph panoramas.
@@ -606,7 +606,7 @@ The graph UI shows:
 - graph rendering safeguards (batched canvas drawing across graph sizes, edge draw caps, lower redraw rate, zoom-aware interaction)
 - adaptive CPU safeguards for large graphs: idle frame pacing, throttled background physics updates and cached viewport dimensions to reduce redraw/layout overhead while preserving interaction responsiveness
 - WebGL node and edge acceleration when supported, falling back to Canvas 2D without changing graph behavior
-- large graph LOD keeps a single-level graph model across zoom levels, preserving visual continuity while adjusting node/edge density from the active viewport
+- large graph view keeps a single-level graph model across zoom levels and renders the full filtered scene instead of viewport-sampled subsets
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

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

@@ -2775,133 +2775,8 @@ const computeRenderVisibility = () => {
   state.lastViewportKey = viewportKey
   state.renderVisibilityDirty = false
 
-  if (state.visibleNodes.length <= 2000) {
-    state.renderNodes = state.visibleNodes
-    const ids = new Set(state.renderNodes.map((node) => node.id))
-    state.renderEdges = limitRenderEdges(state.renderNodes, collectVisibleEdgesForNodes(ids, { preferComplete: true }))
-    return
-  }
-
-  if (state.visibleNodes.length > massiveGraphNodeThreshold) {
-    const sampleLimit = nodeBudgetForScale(state.transform.scale)
-    if (state.transform.scale < massiveOverviewScaleThreshold) {
-      const overviewNodes = sampleMassiveOverviewNodes(sampleLimit)
-      const overviewIds = new Set(overviewNodes.map((node) => node.id))
-      state.renderNodes = overviewNodes
-      state.renderEdges = limitRenderEdges(overviewNodes, collectVisibleEdgesForNodes(overviewIds))
-      return
-    }
-
-    const viewportNodes = viewportNodesFromSpatialIndex(viewport)
-    const segmentedNodes =
-      state.transform.scale < massiveSegmentedScaleThreshold
-        ? sampleMassiveSegmentedNodes(sampleLimit, viewport)
-        : []
-    const sourceNodes =
-      segmentedNodes.length > 0
-        ? segmentedNodes
-        : viewportNodes.length > 0
-          ? viewportNodes
-          : sampleMassiveOverviewNodes(sampleLimit)
-    const shouldCarryOverNodes = state.transform.scale < 0.18
-    const carryMargin = Math.max(180, Math.min(640, 260 / Math.max(state.transform.scale, 0.0001)))
-    const carryViewport = expandViewportBounds(viewport, carryMargin)
-    const carryOverLimit = shouldCarryOverNodes
-      ? Math.max(80, Math.min(sampleLimit, Math.floor(sampleLimit * 0.24)))
-      : 0
-    const carryOverNodes = shouldCarryOverNodes
-      ? (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.renderNodes = sampledNodes
-    state.renderEdges = limitRenderEdges(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.renderNodes = sampled
-    state.renderEdges = limitRenderEdges(sampled, collectVisibleEdgesForNodes(sampledIds))
-    return
-  }
-
-  const viewportNodes = viewportNodesFromSpatialIndex(viewport)
-  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.renderEdges = limitRenderEdges(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 = limitRenderEdges(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.renderNodes = fallbackNodes
-    state.renderEdges = limitRenderEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
-  }
+  state.renderNodes = state.visibleNodes
+  state.renderEdges = state.visibleEdges.filter((edge) => edge.targetNode)
 }
 
 const isNodeVisibleOnScreen = (node, width, height) => {

package/docs/AGENT_USAGE.md

@@ -607,7 +607,7 @@ Without `--vault`, the graph UI serves `$HOME/.brainlink/vault`.
 
 The frontend includes an agent selector that shows only the agent id. Selecting an agent calls the same read APIs with `agent=<agent-id>` and renders that namespace instead of merging every agent into one graph.
 
-Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor and applied immediately without delayed focus interpolation. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on empty canvas zooms in at cursor position. Clicking a node opens its details panel. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open in a non-modal side panel (tags, outgoing links, backlinks and Markdown content), so zoom and pan remain available during inspection. Vaults above 1000 notes keep the same single graph scene and use viewport-driven LOD sampling with edge-coverage safeguards to preserve visible relationships without switching into nested subgraph views.
+Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor and applied immediately without delayed focus interpolation. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on empty canvas zooms in at cursor position. Clicking a node opens its details panel. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open in a non-modal side panel (tags, outgoing links, backlinks and Markdown content), so zoom and pan remain available during inspection. Vaults above 1000 notes keep the same single graph scene and render the full filtered node/edge set during navigation, without viewport-sampled subgraph switching.
 During graph filtering, Brainlink keeps hub context nodes visible (`Memory Hub`/`MOC`/high-degree fallback) so filtered views still show relationship anchors.
 
 The command reindexes by default, then serves:

package/package.json

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