@andespindola/brainlink 1.0.5 → 1.0.7

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;
+};

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

@@ -0,0 +1,135 @@
+import { hierarchyGroupNodeLimit } from './metrics.js';
+const layoutBounds = (nodes) => {
+    if (nodes.length === 0) {
+        return { x: 0, y: 0, radius: 1 };
+    }
+    const bounds = nodes.reduce((current, node) => ({
+        minX: Math.min(current.minX, node.x),
+        maxX: Math.max(current.maxX, node.x),
+        minY: Math.min(current.minY, node.y),
+        maxY: Math.max(current.maxY, node.y)
+    }), {
+        minX: Number.POSITIVE_INFINITY,
+        maxX: Number.NEGATIVE_INFINITY,
+        minY: Number.POSITIVE_INFINITY,
+        maxY: Number.NEGATIVE_INFINITY
+    });
+    const x = (bounds.minX + bounds.maxX) / 2;
+    const y = (bounds.minY + bounds.maxY) / 2;
+    const radius = nodes.reduce((largest, node) => Math.max(largest, Math.hypot(node.x - x, node.y - y)), 1);
+    return { x, y, radius: Math.max(radius + 72, 120) };
+};
+const edgeTouchesGroup = (edge, nodeIds) => nodeIds.has(edge.source) || Boolean(edge.target && nodeIds.has(edge.target));
+const edgeInsideGroup = (edge, nodeIds) => nodeIds.has(edge.source) && Boolean(edge.target && nodeIds.has(edge.target));
+const groupTitle = (segment, level, index, nodes) => nodes.length === 1
+    ? nodes[0]?.title ?? segment
+    : `${segment} ${level + 1}.${index + 1}`;
+const chunkNodes = (nodes, degrees, groupNodeLimit = hierarchyGroupNodeLimit) => {
+    const sortedNodes = [...nodes].sort((left, right) => {
+        const segmentDelta = left.segment.localeCompare(right.segment);
+        if (segmentDelta !== 0)
+            return segmentDelta;
+        const groupDelta = left.group.localeCompare(right.group);
+        if (groupDelta !== 0)
+            return groupDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    });
+    const groupCountTarget = Math.min(groupNodeLimit, sortedNodes.length);
+    const chunkSize = sortedNodes.length <= groupNodeLimit * groupNodeLimit
+        ? Math.max(1, Math.ceil(sortedNodes.length / groupCountTarget))
+        : groupNodeLimit;
+    const chunks = [];
+    for (let index = 0; index < sortedNodes.length; index += chunkSize) {
+        chunks.push(sortedNodes.slice(index, index + chunkSize));
+    }
+    return chunks;
+};
+const groupEdges = (edges, nodeIds) => ({
+    internalEdges: edges.filter((edge) => edgeInsideGroup(edge, nodeIds)),
+    externalEdges: edges.filter((edge) => edgeTouchesGroup(edge, nodeIds) && !edgeInsideGroup(edge, nodeIds))
+});
+const groupBounds = (groups) => {
+    if (groups.length === 0) {
+        return { x: 0, y: 0, radius: 1 };
+    }
+    const nodes = groups.map((group) => ({
+        x: group.x,
+        y: group.y,
+        radius: group.radius
+    }));
+    const x = nodes.reduce((sum, node) => sum + node.x, 0) / nodes.length;
+    const y = nodes.reduce((sum, node) => sum + node.y, 0) / nodes.length;
+    const radius = nodes.reduce((largest, node) => Math.max(largest, Math.hypot(node.x - x, node.y - y) + node.radius), 1);
+    return { x, y, radius: Math.max(radius + 120, 180) };
+};
+const descendantNodeIds = (groups) => groups.flatMap((group) => group.nodeIds);
+const createParentGroups = (groups, edges, level, groupNodeLimit) => {
+    if (groups.length <= groupNodeLimit) {
+        return groups;
+    }
+    const parentGroups = [];
+    for (let index = 0; index < groups.length; index += groupNodeLimit) {
+        const chunk = groups.slice(index, index + groupNodeLimit);
+        const nodeIds = new Set(descendantNodeIds(chunk));
+        const bounds = groupBounds(chunk);
+        const segment = chunk[0]?.segment ?? 'root';
+        const group = chunk[0]?.group ?? 'root';
+        const groupIndex = index / groupNodeLimit;
+        const id = ['root', level, groupIndex, chunk[0]?.id ?? 'empty', chunk.length].join(':');
+        const edgeGroups = groupEdges(edges, nodeIds);
+        parentGroups.push({
+            id,
+            level,
+            parentId: null,
+            title: `${segment} ${level + 1}.${Math.floor(groupIndex) + 1}`,
+            segment,
+            group,
+            x: bounds.x,
+            y: bounds.y,
+            radius: bounds.radius,
+            nodeIds: [],
+            childGroupIds: chunk.map((child) => child.id),
+            internalEdges: edgeGroups.internalEdges,
+            externalEdges: edgeGroups.externalEdges
+        });
+    }
+    const parentIdByChildId = new Map();
+    parentGroups.forEach((parent) => {
+        parent.childGroupIds.forEach((childId) => parentIdByChildId.set(childId, parent.id));
+    });
+    const relinkedChildren = groups.map((group) => {
+        const parentId = parentIdByChildId.get(group.id);
+        return parentId ? { ...group, parentId } : group;
+    });
+    return [...createParentGroups(parentGroups, edges, level + 1, groupNodeLimit), ...relinkedChildren];
+};
+export const createGraphLayoutHierarchy = (nodes, edges, degrees, groupNodeLimit = hierarchyGroupNodeLimit) => {
+    if (nodes.length <= groupNodeLimit) {
+        return [];
+    }
+    const leafGroups = chunkNodes(nodes, degrees, groupNodeLimit).map((chunk, index) => {
+        const nodeIds = new Set(chunk.map((node) => node.id));
+        const bounds = layoutBounds(chunk);
+        const segment = chunk[0]?.segment ?? 'root';
+        const group = chunk[0]?.group ?? 'root';
+        const id = ['leaf', 0, index, chunk[0]?.id ?? 'empty', chunk.length].join(':');
+        return {
+            id,
+            level: 0,
+            parentId: null,
+            title: groupTitle(segment, 0, index, chunk),
+            segment,
+            group,
+            x: bounds.x,
+            y: bounds.y,
+            radius: bounds.radius,
+            nodeIds: chunk.map((node) => node.id),
+            childGroupIds: [],
+            ...groupEdges(edges, nodeIds)
+        };
+    });
+    return createParentGroups(leafGroups, edges, 1, groupNodeLimit);
+};

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

@@ -0,0 +1,111 @@
+export const hierarchyGroupNodeLimit = 1000;
+const groupLabels = {
+    '00-maps': 'maps',
+    '10-agent-memory': 'agent-memory',
+    '20-concepts': 'concepts',
+    '30-architecture': 'architecture',
+    '40-agents': 'agents',
+    '50-retrieval': 'retrieval',
+    '60-operations': 'operations',
+    '70-evaluation': 'evaluation',
+    '80-sessions': 'sessions',
+    '90-security': 'security',
+    root: 'root'
+};
+const segmentAngles = {
+    Brainlink: -1.58,
+    Architecture: -0.74,
+    Agents: -0.05,
+    Retrieval: 0.68,
+    Operations: 1.34,
+    Evaluation: 2.08,
+    Security: 2.82
+};
+const hubTitlePattern = /\b(memory\s*hub|knowledge\s*root|moc|map)\b/i;
+export const hashText = (value) => Array.from(value).reduce((hash, char) => ((hash << 5) - hash + char.charCodeAt(0)) | 0, 0);
+export const jitter = (value, range) => {
+    const normalized = Math.abs(hashText(value) % 1000) / 1000;
+    return (normalized - 0.5) * range;
+};
+const pathSegments = (path) => path.split('/').filter(Boolean);
+export const groupKey = (node) => {
+    const segments = pathSegments(node.path);
+    if (segments[0] === 'agents') {
+        return segments[2] ?? 'root';
+    }
+    return segments[0] ?? 'root';
+};
+export const groupLabel = (key) => groupLabels[key] ?? key;
+const incrementDegreeBy = (degrees, id, amount) => {
+    degrees.set(id, (degrees.get(id) ?? 0) + amount);
+    return degrees;
+};
+const edgeDegreeWeight = (edge) => Math.max(1, Math.min(edge.weight, 8));
+export const countDegrees = (edges) => edges.reduce((degrees, edge) => {
+    const weight = edgeDegreeWeight(edge);
+    return edge.target
+        ? incrementDegreeBy(incrementDegreeBy(degrees, edge.source, weight), edge.target, weight)
+        : incrementDegreeBy(degrees, edge.source, weight);
+}, new Map());
+export const createAdjacency = (nodes, edges) => {
+    const nodeIds = new Set(nodes.map((node) => node.id));
+    const adjacency = new Map(nodes.map((node) => [node.id, new Set()]));
+    edges.forEach((edge) => {
+        if (!edge.target || !nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+            return;
+        }
+        adjacency.get(edge.source)?.add(edge.target);
+        adjacency.get(edge.target)?.add(edge.source);
+    });
+    return new Map(Array.from(adjacency.entries(), ([id, neighbors]) => [id, Array.from(neighbors)]));
+};
+export const byTitle = (left, right) => left.title.localeCompare(right.title);
+export const byDegreeThenTitle = (degrees) => (left, right) => {
+    const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+    return degreeDelta === 0 ? byTitle(left, right) : degreeDelta;
+};
+export const hubScore = (node) => {
+    const title = node.title.trim().toLowerCase();
+    if (title === 'memory hub')
+        return 5;
+    if (title === 'knowledge root')
+        return 4;
+    if (/\bmoc\b/i.test(node.title))
+        return 3;
+    return hubTitlePattern.test(node.title) ? 2 : 0;
+};
+export const selectPrimaryHubId = (nodes, degrees) => {
+    const ranked = [...nodes]
+        .filter((node) => hubScore(node) > 0)
+        .sort((left, right) => {
+        const scoreDelta = hubScore(right) - hubScore(left);
+        if (scoreDelta !== 0)
+            return scoreDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    });
+    return ranked[0]?.id ?? null;
+};
+export const selectHighestDegreeNodeId = (nodes, degrees) => [...nodes].sort((left, right) => {
+    const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+    return degreeDelta === 0 ? left.title.localeCompare(right.title) : degreeDelta;
+})[0]?.id ?? null;
+export const centerLayoutByNode = (nodes, nodeId) => {
+    if (!nodeId) {
+        return nodes;
+    }
+    const anchor = nodes.find((node) => node.id === nodeId);
+    if (!anchor) {
+        return nodes;
+    }
+    return nodes.map((node) => ({
+        ...node,
+        x: node.x - anchor.x,
+        y: node.y - anchor.y
+    }));
+};
+export const segmentAngle = (segment, index, count) => segmentAngles[segment] ?? (Math.PI * 2 * index) / Math.max(count, 1) - Math.PI / 2;
+const distanceBetween = (left, right) => Math.hypot(right.x - left.x, right.y - left.y);
+export const getMinimumLayoutDistance = (nodes) => nodes.reduce((minimumDistance, leftNode, leftIndex) => nodes.slice(leftIndex + 1).reduce((innerMinimum, rightNode) => Math.min(innerMinimum, distanceBetween(leftNode, rightNode)), minimumDistance), Number.POSITIVE_INFINITY);

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

@@ -0,0 +1,76 @@
+import { deriveVisualContextRules, inferExplicitVisualGraphContext } from '../graph-contexts.js';
+import { byDegreeThenTitle, byTitle, createAdjacency, groupKey, groupLabel } from './metrics.js';
+const naturalSegmentSeed = (node) => groupKey(node) === '00-maps' || /\b(moc|map)\b/i.test(node.title);
+const segmentName = (node) => node.title.replace(/^MOC\s+/i, '').replace(/\s+Memory Map$/i, '').trim() || node.title;
+const collectComponent = (adjacency, startId, visited) => {
+    const queue = [startId];
+    const component = [];
+    visited.add(startId);
+    for (let index = 0; index < queue.length; index += 1) {
+        const id = queue[index];
+        component.push(id);
+        (adjacency.get(id) ?? []).forEach((nextId) => {
+            if (!visited.has(nextId)) {
+                visited.add(nextId);
+                queue.push(nextId);
+            }
+        });
+    }
+    return component;
+};
+const connectedComponents = (nodes, adjacency) => {
+    const visited = new Set();
+    return [...nodes].sort(byTitle).reduce((components, node) => (visited.has(node.id) ? components : [...components, collectComponent(adjacency, node.id, visited)]), []);
+};
+const selectSegmentSeeds = (nodes, edges, degrees) => {
+    const adjacency = createAdjacency(nodes, edges);
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    return connectedComponents(nodes, adjacency).flatMap((component) => {
+        const componentNodes = component.map((id) => nodeById.get(id)).filter((node) => Boolean(node));
+        const naturalSeeds = componentNodes.filter(naturalSegmentSeed).sort(byDegreeThenTitle(degrees));
+        return naturalSeeds.length > 0 ? naturalSeeds : componentNodes.sort(byDegreeThenTitle(degrees)).slice(0, 1);
+    });
+};
+export const assignSegments = (nodes, edges, degrees) => {
+    const adjacency = createAdjacency(nodes, edges);
+    const seeds = selectSegmentSeeds(nodes, edges, degrees);
+    const rules = deriveVisualContextRules(nodes);
+    const assignments = new Map(nodes.flatMap((node) => {
+        const visualContext = inferExplicitVisualGraphContext(node, rules);
+        return visualContext ? [[node.id, visualContext.title]] : [];
+    }));
+    const queue = seeds.map((seed) => seed.id);
+    seeds.forEach((seed) => {
+        if (!assignments.has(seed.id)) {
+            assignments.set(seed.id, segmentName(seed));
+        }
+    });
+    for (let index = 0; index < queue.length; index += 1) {
+        const id = queue[index];
+        const segment = assignments.get(id);
+        if (!segment) {
+            continue;
+        }
+        ;
+        (adjacency.get(id) ?? []).forEach((nextId) => {
+            if (!assignments.has(nextId)) {
+                assignments.set(nextId, segment);
+                queue.push(nextId);
+            }
+        });
+    }
+    return new Map(nodes.map((node) => [node.id, assignments.get(node.id) ?? groupLabel(groupKey(node))]));
+};
+export const groupNodesBySegment = (nodes, segments) => {
+    const groups = new Map();
+    nodes.forEach((node) => {
+        const segment = segments.get(node.id) ?? groupLabel(groupKey(node));
+        const bucket = groups.get(segment);
+        if (bucket) {
+            bucket.push(node);
+            return;
+        }
+        groups.set(segment, [node]);
+    });
+    return new Map(groups);
+};

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

@@ -0,0 +1,110 @@
+import { centerLayoutByNode, countDegrees, createAdjacency, groupKey, groupLabel, jitter, segmentAngle, selectHighestDegreeNodeId, selectPrimaryHubId } from './metrics.js';
+import { assignSegments } from './segments.js';
+import { relaxCollisions } from './collisions.js';
+import { createGraphLayoutHierarchy } from './hierarchy.js';
+const compareByStarOrder = (levels, degrees, segmentIndexByName, segments) => (left, right) => {
+    const levelDelta = (levels.get(left.id) ?? 1) - (levels.get(right.id) ?? 1);
+    if (levelDelta !== 0)
+        return levelDelta;
+    const leftSegment = segments.get(left.id) ?? groupLabel(groupKey(left));
+    const rightSegment = segments.get(right.id) ?? groupLabel(groupKey(right));
+    const segmentDelta = (segmentIndexByName.get(leftSegment) ?? 0) - (segmentIndexByName.get(rightSegment) ?? 0);
+    if (segmentDelta !== 0)
+        return segmentDelta;
+    const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+    return degreeDelta === 0 ? left.title.localeCompare(right.title) : degreeDelta;
+};
+const assignStarLevels = (nodes, edges, hubId) => {
+    if (!hubId) {
+        return new Map(nodes.map((node) => [node.id, 1]));
+    }
+    const adjacency = createAdjacency(nodes, edges);
+    const levels = new Map([[hubId, 0]]);
+    const queue = [hubId];
+    for (let index = 0; index < queue.length; index += 1) {
+        const id = queue[index];
+        const nextLevel = (levels.get(id) ?? 0) + 1;
+        (adjacency.get(id) ?? []).forEach((nextId) => {
+            if (!levels.has(nextId)) {
+                levels.set(nextId, nextLevel);
+                queue.push(nextId);
+            }
+        });
+    }
+    nodes.forEach((node) => {
+        if (!levels.has(node.id)) {
+            levels.set(node.id, 2);
+        }
+    });
+    return levels;
+};
+const createStarNodes = (nodes, segments, degrees, hubId, levels) => {
+    const segmentNames = Array.from(new Set(nodes.map((node) => segments.get(node.id) ?? groupLabel(groupKey(node)))))
+        .sort((left, right) => segmentAngle(left, 0, 1) - segmentAngle(right, 0, 1) || left.localeCompare(right));
+    const segmentIndexByName = new Map(segmentNames.map((segment, index) => [segment, index]));
+    const sortedNodes = [...nodes].sort(compareByStarOrder(levels, degrees, segmentIndexByName, segments));
+    const nodesByLevel = sortedNodes.reduce((state, node) => {
+        const level = node.id === hubId ? 0 : Math.max(1, levels.get(node.id) ?? 1);
+        const levelNodes = state.get(level) ?? [];
+        levelNodes.push(node);
+        state.set(level, levelNodes);
+        return state;
+    }, new Map());
+    return Array.from(nodesByLevel.entries())
+        .sort(([left], [right]) => left - right)
+        .flatMap(([level, levelNodes]) => {
+        if (level === 0) {
+            return levelNodes.map((node) => ({
+                ...node,
+                group: groupLabel(groupKey(node)),
+                segment: segments.get(node.id) ?? groupLabel(groupKey(node)),
+                x: 0,
+                y: 0
+            }));
+        }
+        const levelNodesBySegment = segmentNames
+            .map((segment) => ({
+            segment,
+            nodes: levelNodes.filter((node) => (segments.get(node.id) ?? groupLabel(groupKey(node))) === segment)
+        }))
+            .filter((group) => group.nodes.length > 0);
+        const totalNodes = levelNodesBySegment.reduce((total, group) => total + group.nodes.length, 0);
+        const baseRadius = Math.max(360 + (level - 1) * 460, (levelNodes.length * 156) / (Math.PI * 2));
+        let arcCursor = -Math.PI / 2;
+        return levelNodesBySegment.flatMap((group) => {
+            const arcSize = (Math.PI * 2 * group.nodes.length) / Math.max(totalNodes, 1);
+            const arcPadding = Math.min(0.22, arcSize * 0.18);
+            const arcStart = arcCursor + arcPadding;
+            const arcEnd = arcCursor + arcSize - arcPadding;
+            const usableArc = Math.max(0.001, arcEnd - arcStart);
+            const segmentRadius = Math.max(baseRadius, (group.nodes.length * 156) / usableArc);
+            arcCursor += arcSize;
+            return group.nodes.map((node, index) => {
+                const lane = index % 3 - 1;
+                const angle = arcStart + usableArc * ((index + 0.5) / Math.max(group.nodes.length, 1)) + jitter(node.title, 0.035);
+                const radialJitter = jitter(node.id, 34);
+                return {
+                    ...node,
+                    group: groupLabel(groupKey(node)),
+                    segment: group.segment,
+                    x: Math.cos(angle) * (segmentRadius + lane * 52 + radialJitter) + jitter(node.title, 16),
+                    y: Math.sin(angle) * (segmentRadius + lane * 52 + radialJitter) + jitter(node.path, 16)
+                };
+            });
+        });
+    });
+};
+export const createStarGraphLayout = (graph) => {
+    const degrees = countDegrees(graph.edges);
+    const hubId = selectPrimaryHubId(graph.nodes, degrees) ?? selectHighestDegreeNodeId(graph.nodes, degrees);
+    const segments = assignSegments(graph.nodes, graph.edges, degrees);
+    const levels = assignStarLevels(graph.nodes, graph.edges, hubId);
+    const nodes = relaxCollisions(createStarNodes(graph.nodes, segments, degrees, hubId, levels), 156, 22);
+    const centeredNodes = centerLayoutByNode(nodes, hubId);
+    const groups = createGraphLayoutHierarchy(centeredNodes, graph.edges, degrees);
+    return {
+        nodes: centeredNodes,
+        edges: graph.edges,
+        ...(groups.length > 0 ? { groups } : {})
+    };
+};