Function createSimulation

dashboard/graph/src/simulation.ts:60–226

(
  nodes: GraphNode[],
  edges: GraphEdge[],
  previous?: Simulation | null,
  anchorId?: string | null,
)

 * already exist in `previous` so progressive expansion feels stable.
 */
export function createSimulation(
  nodes: GraphNode[],
  edges: GraphEdge[],
  previous?: Simulation | null,
  anchorId?: string | null,
): Simulation {
  const prevById = new Map<string, SimNode>();
  if (previous) {
    for (const node of previous.nodes) prevById.set(node.id, node);
  }
  const anchor = anchorId ? prevById.get(anchorId) : undefined;
  const cx = anchor ? anchor.x : 0;
  const cy = anchor ? anchor.y : 0;

  const visibleDegree = new Map<string, number>();
  for (const edge of edges) {
    visibleDegree.set(edge.source, (visibleDegree.get(edge.source) || 0) + 1);
    visibleDegree.set(edge.target, (visibleDegree.get(edge.target) || 0) + 1);
  }

  const simNodes: SimNode[] = nodes.map((node, index) => {
    const prev = prevById.get(node.id);
    const angle = (index / Math.max(1, nodes.length)) * Math.PI * 2;
    const jitter = 60 + (index % 7) * 26;
    return {
      ...node,
      x: prev ? prev.x : cx + Math.cos(angle) * jitter,
      y: prev ? prev.y : cy + Math.sin(angle) * jitter,
      vx: prev ? prev.vx : 0,
      vy: prev ? prev.vy : 0,
      fx: prev ? prev.fx : null,
      fy: prev ? prev.fy : null,
      radius: nodeRadius(node.degree || 0),
      visibleDegree: visibleDegree.get(node.id) || 0,
    };
  });

  const byId = new Map(simNodes.map((node) => [node.id, node]));
  const simEdges: SimEdge[] = [];
  for (const edge of edges) {
    const sourceNode = byId.get(edge.source);
    const targetNode = byId.get(edge.target);
    if (sourceNode && targetNode) simEdges.push({ ...edge, sourceNode, targetNode });
  }

  let alpha = 1;

  function applyRepulsion() {
    // Spatial grid keeps repulsion ~O(n * neighbors) instead of O(n²).
    const grid = new Map<string, SimNode[]>();
    for (const node of simNodes) {
      const key = `${Math.floor(node.x / GRID_CELL)}:${Math.floor(node.y / GRID_CELL)}`;
      const cell = grid.get(key);
      if (cell) cell.push(node);
      else grid.set(key, [node]);
    }
    for (const node of simNodes) {
      const gx = Math.floor(node.x / GRID_CELL);