Function buildCalls

src/ui-server/api/filecode.ts:204–254

* Every outgoing edge from every symbol in the file, grouped twice over: by the * symbol that makes the call, and within that by the symbol it reaches. * * Grouping by the OWNER as well as the target is what separates this from the * Symbol view's rail. Across one body, a helper called from thre

(
  cg: CodeGraph,
  nodes: readonly Node[],
  posixPath: string
)

 * and the outline already draws it.
 */
function buildCalls(
  cg: CodeGraph,
  nodes: readonly Node[],
  posixPath: string
): { calls: WireFileCall[]; total: number; intraFileCalls: number } {
  const nodeIds = nodes.map((n) => n.id);
  const lineOf = new Map(nodes.map((n) => [n.id, n.startLine] as const));

  const edges = cg.getOutgoingEdgesFrom(nodeIds).filter((e) => e.kind !== 'contains');
  if (edges.length === 0) return { calls: [], total: 0, intraFileCalls: 0 };

  const bySource = new Map<string, Edge[]>();
  for (const edge of edges) {
    const bucket = bySource.get(edge.source);
    if (bucket) bucket.push(edge);
    else bySource.set(edge.source, [edge]);
  }

  // One batched lookup for every counterpart, never one per edge: the engine's
  // busiest file reaches several hundred distinct symbols.
  const endpoints = cg.getNodesByIds([...new Set(edges.map((e) => e.target))]);

  const all: WireFileCall[] = [];
  for (const [ownerId, group] of bySource) {
    for (const relation of groupRelations(group, (e) => e.target, endpoints)) {
      all.push({ ownerId, ownerLine: lineOf.get(ownerId) ?? 0, relation });
    }
  }

  // Source order — the only ordering this screen has. A row with no recorded
  // call site (an edge the extractor gave no line) sorts to the end, where it
  // is also what a cap trims first.
  all.sort(
    (a, b) =>
      firstLine(a.relation) - firstLine(b.relation) ||
      a.ownerLine - b.ownerLine ||
      a.relation.node.name.localeCompare(b.relation.node.name)
  );

  const calls = all.slice(0, MAX_FILE_CALL_GROUPS);

  // Arcs, counted over what was KEPT — see the module comment.
  let intraFileCalls = 0;
  for (const call of calls) {
    if (call.relation.node.file !== posixPath) continue;
    const target = call.relation.node.line;
    for (const line of call.relation.lines) if (line !== target) intraFileCalls++;
  }

  return { calls, total: all.length, intraFileCalls };
}

/**
 * The file's unresolved references, as line markers.