@andespindola/brainlink 1.0.4 → 1.0.6

package/dist/cli/main.js

@@ -3,17 +3,52 @@ import { Command } from 'commander';
 import { readFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { checkPackageUpdate } from '../application/check-package-update.js';
+import { loadBrainlinkConfig } from '../infrastructure/config.js';
 import { registerAgentCommands } from './commands/agent-commands.js';
 import { registerConfigCommands } from './commands/config-commands.js';
 import { registerPracticalCommands } from './commands/practical-commands.js';
 import { registerReadCommands } from './commands/read-commands.js';
 import { registerVaultCommands } from './commands/vault-commands.js';
 import { registerWriteCommands } from './commands/write-commands.js';
-const readPackageVersion = () => {
+const readPackageMetadata = () => {
     const packagePath = join(dirname(fileURLToPath(import.meta.url)), '../../package.json');
     const metadata = JSON.parse(readFileSync(packagePath, 'utf8'));
-    return metadata.version ?? '0.0.0';
+    return {
+        name: metadata.name ?? 'brainlink',
+        version: metadata.version ?? '0.0.0'
+    };
 };
+const shouldSkipUpdateCheck = () => process.env.BRAINLINK_NO_UPDATE_CHECK === '1' ||
+    process.env.BRAINLINK_NO_UPDATE_CHECK === 'true' ||
+    process.env.CI === 'true' ||
+    process.env.VITEST === 'true' ||
+    process.env.NODE_ENV === 'test' ||
+    process.argv.includes('--version') ||
+    process.argv.includes('-V') ||
+    process.argv.includes('--help') ||
+    process.argv.includes('-h');
+const maybePrintUpdateNotice = async (metadata) => {
+    if (shouldSkipUpdateCheck()) {
+        return;
+    }
+    try {
+        const config = await loadBrainlinkConfig();
+        const status = await checkPackageUpdate({
+            packageName: metadata.name,
+            currentVersion: metadata.version,
+            enabled: config.autoUpdateCheck,
+            intervalMs: config.updateCheckIntervalMs
+        });
+        if (!status.skipped && status.updateAvailable && status.latestVersion) {
+            console.error(`Brainlink ${status.latestVersion} is available. Current version: ${status.currentVersion}. Update with: ${status.installCommand}`);
+        }
+    }
+    catch {
+        // Update checks must never block normal CLI execution.
+    }
+};
+const packageMetadata = readPackageMetadata();
 const program = new Command();
 const cliName = basename(process.argv[1] ?? 'brainlink');
 const displayName = cliName === 'blink' ? 'blink' : 'brainlink';
@@ -22,13 +57,14 @@ program
     .name(displayName)
     .alias(aliasName)
     .description('Local-first knowledge memory for agents')
-    .version(readPackageVersion());
+    .version(packageMetadata.version);
 registerWriteCommands(program);
 registerReadCommands(program);
 registerPracticalCommands(program);
 registerConfigCommands(program);
 registerVaultCommands(program);
 registerAgentCommands(program);
+await maybePrintUpdateNotice(packageMetadata);
 program.parseAsync().catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(message);

package/dist/domain/context.js

@@ -1,5 +1,21 @@
 import { middleOutIndices } from './middle-out.js';
 const maxSectionsPerDocument = 3;
+const charsPerToken = 4;
+const sectionSeparatorTokens = 1;
+const headerReserveTokens = 8;
+const estimateTokens = (text) => Math.ceil(text.length / charsPerToken);
+const truncateToTokens = (text, maxTokens) => {
+    const maxChars = Math.max(0, maxTokens) * charsPerToken;
+    return text.length <= maxChars ? text : text.slice(0, maxChars);
+};
+// Mirror the per-section framing that formatContextPackage renders (heading,
+// Source/Tags/Score/Mode lines and the trailing separator) so the budget
+// reflects the package the agent actually receives, not just chunk content.
+const estimateSectionTokens = (result) => {
+    const tagsLine = result.tags.length > 0 ? `Tags: ${result.tags.map((tag) => `#${tag}`).join(' ')}\n` : '';
+    const framing = `## . ${result.title}\nSource: ${result.path}\n${tagsLine}Score: 0.000\nMode: ${result.searchMode}\n\n`;
+    return estimateTokens(result.content) + estimateTokens(framing) + sectionSeparatorTokens;
+};
 const byScore = (left, right) => right.score - left.score || left.title.localeCompare(right.title);
 const byOrdinal = (left, right) => (left.chunkOrdinal ?? Number.MAX_SAFE_INTEGER) - (right.chunkOrdinal ?? Number.MAX_SAFE_INTEGER);
 const middleOutDocumentResults = (results) => {
@@ -38,7 +54,7 @@ export const selectContextSections = (results, maxTokens) => {
             if (seenChunks.has(result.chunkId)) {
                 continue;
             }
-            const tokenCost = Math.ceil(result.content.length / 4);
+            const tokenCost = estimateSectionTokens(result);
             if (usedTokens + tokenCost > maxTokens) {
                 break;
             }
@@ -62,11 +78,31 @@ export const selectContextSections = (results, maxTokens) => {
             seenChunks
         };
     }, {
-        usedTokens: 0,
+        usedTokens: headerReserveTokens,
         sections: [],
         seenChunks: new Set()
     });
-    return selected.sections;
+    if (selected.sections.length > 0 || results.length === 0) {
+        return selected.sections;
+    }
+    // Retrieval found matches but every chunk overflowed the token budget. Never
+    // surface an empty context in that case: include the highest-scored chunk,
+    // truncated so the rendered package still respects the budget. This keeps
+    // brainlink_context consistent with brainlink_search instead of reporting
+    // "No relevant context found." whenever the strongest chunk is large.
+    const topResult = [...results].sort(byScore)[0];
+    const framingTokens = estimateSectionTokens({ ...topResult, content: '' });
+    const contentTokenBudget = maxTokens - headerReserveTokens - framingTokens;
+    return [
+        {
+            title: topResult.title,
+            path: topResult.path,
+            content: truncateToTokens(topResult.content, contentTokenBudget),
+            score: topResult.score,
+            searchMode: topResult.searchMode,
+            tags: topResult.tags
+        }
+    ];
 };
 export const formatContextPackage = (query, sections) => {
     const body = sections

package/dist/domain/embeddings.js

@@ -67,8 +67,16 @@ const featureHash = (feature) => {
     const sign = value & 1 ? 1 : -1;
     return [index, sign];
 };
+const vectorMagnitude = (vector) => {
+    let sumSquares = 0;
+    for (let index = 0; index < vector.length; index += 1) {
+        const value = vector[index];
+        sumSquares += value * value;
+    }
+    return Math.sqrt(sumSquares);
+};
 const normalizeVector = (vector) => {
-    const magnitude = Math.hypot(...vector);
+    const magnitude = vectorMagnitude(vector);
     return magnitude === 0 ? vector : vector.map((value) => value / magnitude);
 };
 const applyFeature = (vector, feature, weight) => {
@@ -86,15 +94,33 @@ export const createLocalEmbedding = (input) => {
     const weighted = tokenFeatures(tokens).reduce((vector, feature) => applyFeature(vector, feature, feature.startsWith('b:') ? 0.65 : 1), initial);
     return normalizeVector(weighted);
 };
+// Dot product over the shared prefix. For L2-normalized vectors (every vector
+// from createLocalEmbedding is normalized) this equals cosine similarity, so
+// the hot retrieval loop can skip the per-comparison magnitude recompute.
+export const dotProduct = (left, right) => {
+    const length = Math.min(left.length, right.length);
+    let total = 0;
+    for (let index = 0; index < length; index += 1) {
+        total += left[index] * right[index];
+    }
+    return total;
+};
 export const cosineSimilarity = (left, right) => {
     const length = Math.min(left.length, right.length);
     if (length === 0) {
         return 0;
     }
-    const dot = left.slice(0, length).reduce((total, value, index) => total + value * (right[index] ?? 0), 0);
-    const leftMagnitude = Math.hypot(...left.slice(0, length));
-    const rightMagnitude = Math.hypot(...right.slice(0, length));
-    return leftMagnitude === 0 || rightMagnitude === 0 ? 0 : dot / (leftMagnitude * rightMagnitude);
+    let dot = 0;
+    let leftSumSquares = 0;
+    let rightSumSquares = 0;
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = left[index];
+        const rightValue = right[index];
+        dot += leftValue * rightValue;
+        leftSumSquares += leftValue * leftValue;
+        rightSumSquares += rightValue * rightValue;
+    }
+    return leftSumSquares === 0 || rightSumSquares === 0 ? 0 : dot / Math.sqrt(leftSumSquares * rightSumSquares);
 };
 const bucketKey = (index, value) => `${value >= 0 ? 'p' : 'n'}:${index}`;
 export const createEmbeddingBuckets = (vector, bucketCount = defaultEmbeddingBucketCount) => vector

package/dist/domain/graph-contexts.js

@@ -8,7 +8,59 @@ const context = (title) => ({
 const byTitle = (left, right) => left.title.localeCompare(right.title);
 const edgeKey = (source, target) => source < target ? `${source}|${target}` : `${target}|${source}`;
 const nodeSearchText = (node) => normalize([node.title, node.path, ...node.tags].join(' '));
-export const inferExplicitVisualGraphContext = (node) => {
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+// Hub notes name their context as "<Context> Hub". These reserved hubs are
+// structural anchors of the graph, not visual contexts, so they never become
+// keyword rules.
+const reservedHubTitles = new Set(['memory hub', 'knowledge root']);
+const hubContextPattern = /^(.+?)\s+hub$/i;
+// Extra keywords can be declared in a hub note body via a "Keywords: a, b, c"
+// line so a context can match terms beyond its own name.
+const parseHubKeywords = (content) => {
+    const match = content.match(/^\s*keywords?\s*:\s*(.+)$/im);
+    if (!match) {
+        return [];
+    }
+    return match[1]
+        .split(',')
+        .map((keyword) => normalize(keyword))
+        .filter((keyword) => keyword.length > 0);
+};
+// Derive content-classification rules from the hub notes present in the graph.
+// A "<Context> Hub" note contributes the context, keyed by its normalized name
+// plus any declared extra keywords. This keeps vault-specific taxonomy in the
+// vault instead of hardcoding it in the engine.
+export const deriveVisualContextRules = (nodes) => {
+    const rules = new Map();
+    nodes.forEach((node) => {
+        const match = node.title.trim().match(hubContextPattern);
+        if (!match) {
+            return;
+        }
+        if (reservedHubTitles.has(normalize(node.title))) {
+            return;
+        }
+        const contextTitle = match[1].trim();
+        if (contextTitle.length === 0) {
+            return;
+        }
+        const keywords = rules.get(contextTitle) ?? new Set();
+        keywords.add(normalize(contextTitle));
+        parseHubKeywords(node.content).forEach((keyword) => keywords.add(keyword));
+        rules.set(contextTitle, keywords);
+    });
+    return Array.from(rules.entries(), ([contextTitle, keywords]) => ({
+        context: contextTitle,
+        keywords: Array.from(keywords)
+    }));
+};
+const matchRule = (text, rules) => {
+    const matched = rules.find((rule) => rule.keywords.some((keyword) => new RegExp(`\\b${escapeRegExp(keyword)}\\b`).test(text)));
+    return matched ? context(matched.context) : null;
+};
+// Structural, vault-agnostic classification. Named-hub phrases and path layout
+// are generic conventions; vault-specific contexts come from `rules`.
+export const inferExplicitVisualGraphContext = (node, rules = []) => {
     const text = nodeSearchText(node);
     const path = normalize(node.path);
     if (includesAny(text, [/\bgithub repositories hub\b/]))
@@ -25,80 +77,32 @@ export const inferExplicitVisualGraphContext = (node) => {
         return context('Git Workflow');
     if (includesAny(text, [/\bagent memory hub\b/]))
         return context('Agent Memory');
-    if (includesAny(text, [/pingu_ai_codding_pair_programming/, /\bpingu\b/]))
-        return context('Pingu');
     if (path.startsWith('github-repos/'))
         return context('GitHub Repositories');
     if (path.startsWith('github-org-repos/'))
         return context('GitHub Organizations');
     if (path.startsWith('machine-config/'))
         return context('Machine Configuration');
-    if (includesAny(text, [/\bbrainlink\b/]))
-        return context('Brainlink');
-    if (includesAny(text, [/\banonspace\b/]))
-        return context('AnonSpace');
-    if (includesAny(text, [/\bsubstructa\b/]))
-        return context('Substructa');
-    if (includesAny(text, [/\bnebula\b/]))
-        return context('Nebula');
-    if (includesAny(text, [/\bsnippets?\b/, /\bupgrader\b/, /\bversion-map\b/]))
-        return context('Snippets');
-    if (includesAny(text, [
-        /\bpreference\b/,
-        /\bpreferences\b/,
-        /\bpreferencia\b/,
-        /\bpreferencias\b/,
-        /\bpreferência\b/,
-        /\bpreferências\b/,
-        /\bplaybook\b/,
-        /\bdirective\b/,
-        /\bdirectives\b/,
-        /\bdiretiva\b/,
-        /\bdiretivas\b/,
-        /\bengineering-style\b/,
-        /\bglobal-engineering\b/,
-        /\bcoding-identity\b/,
-        /\bagents\.md\b/,
-        /\bagents-md\b/,
-        /\bordem direta\b/,
-        /\bordem-direta\b/,
-        /\bman-in-the-loop\b/,
-        /\bconfig geral\b/,
-        /\bconfig-geral\b/,
-        /\bsync config_files\b/,
-        /\bsync-config-files\b/,
-        /\bregra operacional\b/,
-        /\bregras operacionais\b/,
-        /\boperational rule\b/,
-        /\boperational rules\b/,
-        /\boperational policy\b/
-    ])) {
-        return context('User Preferences');
+    const ruleMatch = matchRule(text, rules);
+    if (ruleMatch) {
+        return ruleMatch;
     }
-    if (includesAny(text, [/\binkdrop\b/]))
-        return context('Inkdrop');
-    if (includesAny(text, [/\blazyvim\b/, /\bneovim\b/, /\bnvim\b/, /\bmason\b/, /\bwrapper\b/]))
-        return context('Neovim LazyVim');
-    if (includesAny(text, [/\bgit-flow\b/, /\borigin-sync\b/, /\bgit-identidade\b/, /\bcommit\b/, /\bpush\b/]))
-        return context('Git Workflow');
-    if (includesAny(text, [/\bdocker\b/, /\bkubernetes\b/, /\bdeploy\b/, /\bredeploy\b/]))
-        return context('Operations');
     if (path.startsWith('agents/'))
         return context('Agent Memory');
     return null;
 };
-export const inferVisualGraphContext = (node) => {
-    const explicit = inferExplicitVisualGraphContext(node);
+export const inferVisualGraphContext = (node, rules = []) => {
+    const explicit = inferExplicitVisualGraphContext(node, rules);
     if (explicit) {
         return explicit;
     }
     const [root] = node.path.split('/').filter(Boolean);
     return context(root ? root.replace(/[-_]+/g, ' ') : 'Root');
 };
-export const groupNodesByVisualContext = (nodes) => {
+export const groupNodesByVisualContext = (nodes, rules = deriveVisualContextRules(nodes)) => {
     const groups = new Map();
     nodes.forEach((node) => {
-        const visualContext = inferVisualGraphContext(node);
+        const visualContext = inferVisualGraphContext(node, rules);
         const bucket = groups.get(visualContext.title);
         if (bucket) {
             bucket.push(node);
@@ -147,8 +151,9 @@ export const addVisualContextEdges = (graph) => {
         .filter((edge) => Boolean(edge.target))
         .map((edge) => edgeKey(edge.source, edge.target)));
     const degrees = countDegrees(graph.edges);
+    const rules = deriveVisualContextRules(graph.nodes);
     const derivedEdges = [];
-    for (const [contextTitle, nodes] of groupNodesByVisualContext(graph.nodes).entries()) {
+    for (const [contextTitle, nodes] of groupNodesByVisualContext(graph.nodes, rules).entries()) {
         if (nodes.length <= 1) {
             continue;
         }

package/dist/domain/graph-layout/cauliflower-layout.js

@@ -0,0 +1,116 @@
+import { byDegreeThenTitle, centerLayoutByNode, countDegrees, groupKey, groupLabel, hubScore, jitter, segmentAngle, selectHighestDegreeNodeId, selectPrimaryHubId } from './metrics.js';
+import { assignSegments, groupNodesBySegment } from './segments.js';
+import { relaxCollisions } from './collisions.js';
+import { createGraphLayoutHierarchy } from './hierarchy.js';
+const petalRadiusForSegmentSize = (size) => {
+    const safeSize = Math.max(size, 1);
+    return Math.max(260, Math.sqrt(safeSize) * 96);
+};
+const selectSegmentHub = (nodes, degrees, primaryHubId) => {
+    const primary = nodes.find((node) => node.id === primaryHubId);
+    if (primary) {
+        return primary;
+    }
+    return [...nodes].sort((left, right) => {
+        const hubDelta = hubScore(right) - hubScore(left);
+        if (hubDelta !== 0)
+            return hubDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    })[0] ?? null;
+};
+const segmentCenterRadius = (segments) => {
+    if (segments.length <= 1) {
+        return 0;
+    }
+    const circumference = segments.reduce((total, [, nodes]) => total + petalRadiusForSegmentSize(nodes.length) * 2 + 180, 0);
+    return Math.max(520, circumference / (Math.PI * 2));
+};
+const createCauliflowerSegmentNodes = (segments, degrees, rootHubId, segmentGroups) => ([segment, nodes], segmentIndex) => {
+    const sortedNodes = [...nodes].sort(byDegreeThenTitle(degrees));
+    const segmentHub = selectSegmentHub(sortedNodes, degrees, rootHubId);
+    const angle = segmentAngle(segment, segmentIndex, segmentGroups.length);
+    const globalRadius = segmentCenterRadius(segmentGroups);
+    const petalRadius = petalRadiusForSegmentSize(sortedNodes.length);
+    const isPrimarySegment = Boolean(segmentHub && segmentHub.id === rootHubId);
+    const centerX = isPrimarySegment || globalRadius === 0 ? 0 : Math.cos(angle) * globalRadius;
+    const centerY = isPrimarySegment || globalRadius === 0 ? 0 : Math.sin(angle) * (globalRadius * 0.86);
+    const nonHubNodes = sortedNodes.filter((node) => node.id !== segmentHub?.id);
+    const hubNode = segmentHub
+        ? [{
+                ...segmentHub,
+                group: groupLabel(groupKey(segmentHub)),
+                segment: segments.get(segmentHub.id) ?? segment,
+                x: centerX,
+                y: centerY
+            }]
+        : [];
+    const petalNodes = nonHubNodes.map((node, index) => {
+        const localAngle = index * 2.399963 + jitter(node.title, 0.5);
+        const radialLayer = Math.sqrt(index + 1) / Math.sqrt(Math.max(nonHubNodes.length, 1));
+        const localRadius = 150 + radialLayer * petalRadius + jitter(node.id, 34);
+        const degreePull = Math.min(degrees.get(node.id) ?? 0, 16) * 8;
+        const radius = Math.max(126, localRadius - degreePull);
+        return {
+            ...node,
+            group: groupLabel(groupKey(node)),
+            segment: segments.get(node.id) ?? segment,
+            x: centerX + Math.cos(localAngle) * radius + jitter(node.title, 20),
+            y: centerY + Math.sin(localAngle) * radius * 0.84 + jitter(node.path, 20)
+        };
+    });
+    return [...hubNode, ...petalNodes];
+};
+const createVisualEdge = (source, target, weight, priority) => ({
+    source: source.id,
+    target: target.id,
+    targetTitle: target.title,
+    weight,
+    priority
+});
+const createCauliflowerVisualEdges = (segmentGroups, degrees, rootHubId) => {
+    const nodeById = new Map(segmentGroups.flatMap(([, nodes]) => nodes.map((node) => [node.id, node])));
+    const rootHub = rootHubId ? nodeById.get(rootHubId) ?? null : null;
+    const edges = new Map();
+    const addEdge = (edge) => {
+        if (!edge.target || edge.source === edge.target) {
+            return;
+        }
+        edges.set(`${edge.source}|${edge.target}`, edge);
+    };
+    segmentGroups.forEach(([, nodes]) => {
+        const segmentHub = selectSegmentHub(nodes, degrees, rootHubId);
+        const parent = segmentHub ?? rootHub;
+        if (!parent) {
+            return;
+        }
+        if (rootHub && parent.id !== rootHub.id) {
+            addEdge(createVisualEdge(rootHub, parent, 6, 'high'));
+        }
+        nodes.forEach((node) => {
+            if (node.id === parent.id || node.id === rootHub?.id) {
+                return;
+            }
+            addEdge(createVisualEdge(parent, node, 1, 'low'));
+        });
+    });
+    return Array.from(edges.values());
+};
+export const createCauliflowerGraphLayout = (graph) => {
+    const degrees = countDegrees(graph.edges);
+    const segments = assignSegments(graph.nodes, graph.edges, degrees);
+    const segmentGroups = Array.from(groupNodesBySegment(graph.nodes, segments).entries())
+        .sort(([left], [right]) => left.localeCompare(right));
+    const rootHubId = selectPrimaryHubId(graph.nodes, degrees) ?? selectHighestDegreeNodeId(graph.nodes, degrees);
+    const nodes = relaxCollisions(segmentGroups.flatMap(createCauliflowerSegmentNodes(segments, degrees, rootHubId, segmentGroups)), 156, 28);
+    const centeredNodes = centerLayoutByNode(nodes, rootHubId);
+    const visualEdges = createCauliflowerVisualEdges(segmentGroups, degrees, rootHubId);
+    const groups = createGraphLayoutHierarchy(centeredNodes, visualEdges, degrees);
+    return {
+        nodes: centeredNodes,
+        edges: visualEdges,
+        ...(groups.length > 0 ? { groups } : {})
+    };
+};

package/dist/domain/graph-layout/collisions.js

@@ -0,0 +1,100 @@
+import { hashText } from './metrics.js';
+const resolveCollisionPair = (left, right, minDistance) => {
+    const dx = right.x - left.x;
+    const dy = right.y - left.y;
+    const distance = Math.max(Math.hypot(dx, dy), 0.001);
+    if (distance >= minDistance) {
+        return false;
+    }
+    const push = (minDistance - distance) / 2;
+    const fallbackAngle = Math.PI * 2 * (Math.abs(hashText(`${left.id}:${right.id}`) % 1000) / 1000);
+    const ux = Math.abs(dx) + Math.abs(dy) < 0.001 ? Math.cos(fallbackAngle) : dx / distance;
+    const uy = Math.abs(dx) + Math.abs(dy) < 0.001 ? Math.sin(fallbackAngle) : dy / distance;
+    left.x -= ux * push;
+    left.y -= uy * push;
+    right.x += ux * push;
+    right.y += uy * push;
+    return true;
+};
+const buildCollisionGrid = (nodes, cellSize) => {
+    const grid = new Map();
+    nodes.forEach((node, index) => {
+        const x = Math.floor(node.x / cellSize);
+        const y = Math.floor(node.y / cellSize);
+        const key = `${x},${y}`;
+        const bucket = grid.get(key);
+        if (bucket) {
+            bucket.push(index);
+            return;
+        }
+        grid.set(key, [index]);
+    });
+    return grid;
+};
+const neighborCellKeys = (x, y) => [
+    `${x - 1},${y - 1}`,
+    `${x},${y - 1}`,
+    `${x + 1},${y - 1}`,
+    `${x - 1},${y}`,
+    `${x},${y}`,
+    `${x + 1},${y}`,
+    `${x - 1},${y + 1}`,
+    `${x},${y + 1}`,
+    `${x + 1},${y + 1}`
+];
+const resolveCollisionsSpatial = (nodes, minDistance) => {
+    const gridCellSize = minDistance * 1.05;
+    const grid = buildCollisionGrid(nodes, gridCellSize);
+    let moved = false;
+    for (let index = 0; index < nodes.length; index += 1) {
+        const left = nodes[index];
+        const leftCellX = Math.floor(left.x / gridCellSize);
+        const leftCellY = Math.floor(left.y / gridCellSize);
+        neighborCellKeys(leftCellX, leftCellY).forEach((key) => {
+            const candidateIndices = grid.get(key) ?? [];
+            candidateIndices.forEach((candidateIndex) => {
+                if (candidateIndex <= index) {
+                    return;
+                }
+                moved = resolveCollisionPair(left, nodes[candidateIndex], minDistance) || moved;
+            });
+        });
+    }
+    return moved;
+};
+const resolveCollisionsBrute = (nodes, minDistance) => {
+    let moved = false;
+    for (let leftIndex = 0; leftIndex < nodes.length; leftIndex += 1) {
+        const left = nodes[leftIndex];
+        for (let rightIndex = leftIndex + 1; rightIndex < nodes.length; rightIndex += 1) {
+            moved = resolveCollisionPair(left, nodes[rightIndex], minDistance) || moved;
+        }
+    }
+    return moved;
+};
+export const relaxCollisions = (nodes, minDistance = 132, rounds = 32) => {
+    if (nodes.length <= 1) {
+        return nodes;
+    }
+    const effectiveRounds = nodes.length > 1000
+        ? Math.min(rounds, 12)
+        : nodes.length > 500
+            ? Math.min(rounds, 20)
+            : Math.min(rounds, 26);
+    const layoutNodes = nodes.map((node) => ({
+        ...node,
+        x: Number.isFinite(node.x) ? node.x : 0,
+        y: Number.isFinite(node.y) ? node.y : 0
+    }));
+    for (let round = 0; round < effectiveRounds; round += 1) {
+        const moved = nodes.length <= 250
+            ? resolveCollisionsBrute(layoutNodes, minDistance)
+            : resolveCollisionsSpatial(layoutNodes, minDistance);
+        // Once a full round resolves no overlap the layout is collision-free and
+        // further rounds are no-ops, so the result is identical with fewer rounds.
+        if (!moved) {
+            break;
+        }
+    }
+    return layoutNodes;
+};