@kgdiff/layout 0.0.0-stage → 0.1.0

package/dist/union.js

@@ -0,0 +1,106 @@
+const byCodeUnit = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+function sortedById(items) {
+    for (let i = 1; i < items.length; i++) {
+        const prev = items[i - 1];
+        const cur = items[i];
+        if (prev !== undefined && cur !== undefined && byCodeUnit(prev.id, cur.id) > 0) {
+            return [...items].sort((a, b) => byCodeUnit(a.id, b.id));
+        }
+    }
+    return items;
+}
+/** Build CSR adjacency (ascending neighbour lists) from flat undirected pairs. */
+export function buildAdjacency(n, pairs) {
+    const offsets = new Int32Array(n + 1);
+    for (let k = 0; k < pairs.length; k++)
+        offsets[(pairs[k] ?? 0) + 1]++;
+    for (let i = 0; i < n; i++)
+        offsets[i + 1] += offsets[i];
+    const fill = offsets.slice(0, n);
+    const adjacency = new Int32Array(pairs.length);
+    for (let k = 0; k < pairs.length; k += 2) {
+        const a = pairs[k];
+        const b = pairs[k + 1];
+        adjacency[fill[a]++] = b;
+        adjacency[fill[b]++] = a;
+    }
+    for (let i = 0; i < n; i++)
+        adjacency.subarray(offsets[i], offsets[i + 1]).sort();
+    return { offsets, adjacency };
+}
+export function buildUnionGraph(diff) {
+    const nodes = sortedById(diff.nodes);
+    const n = nodes.length;
+    const indexOf = new Map();
+    for (let i = 0; i < n; i++)
+        indexOf.set(nodes[i].id, i);
+    const changed = new Uint8Array(n);
+    for (let i = 0; i < n; i++)
+        if (nodes[i].status !== 'unchanged')
+            changed[i] = 1;
+    const seen = new Set();
+    const flat = [];
+    const addPair = (a, b) => {
+        if (a === undefined || b === undefined || a === b)
+            return;
+        const lo = a < b ? a : b;
+        const hi = a < b ? b : a;
+        const key = lo * n + hi;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        flat.push(lo, hi);
+    };
+    for (const edge of sortedById(diff.edges)) {
+        const s = indexOf.get(edge.source);
+        const t = indexOf.get(edge.target);
+        addPair(s, t);
+        const sb = edge.sourceBefore === undefined ? s : indexOf.get(edge.sourceBefore);
+        const tb = edge.targetBefore === undefined ? t : indexOf.get(edge.targetBefore);
+        if (sb !== s || tb !== t)
+            addPair(sb, tb);
+        if (edge.status !== 'unchanged') {
+            for (const end of [s, t, sb, tb])
+                if (end !== undefined)
+                    changed[end] = 1;
+        }
+    }
+    const pairs = Int32Array.from(flat);
+    const { offsets, adjacency } = buildAdjacency(n, pairs);
+    const partners = [];
+    const partnerKeys = new Set();
+    const addPartner = (mover, anchor) => {
+        if (anchor === undefined || anchor === mover)
+            return;
+        const key = mover * n + anchor;
+        if (partnerKeys.has(key))
+            return;
+        partnerKeys.add(key);
+        partners.push({ mover, anchor });
+    };
+    for (let i = 0; i < n; i++) {
+        for (const facet of nodes[i].facets) {
+            if (facet.kind === 'mergedInto')
+                addPartner(i, indexOf.get(facet.target));
+            else if (facet.kind === 'splitFrom')
+                addPartner(i, indexOf.get(facet.source));
+            else if (facet.kind === 'mergeTarget') {
+                for (const source of facet.sources) {
+                    const s = indexOf.get(source);
+                    if (s !== undefined)
+                        addPartner(s, i);
+                }
+            }
+            else if (facet.kind === 'splitInto') {
+                for (const target of facet.targets) {
+                    const t = indexOf.get(target);
+                    if (t !== undefined)
+                        addPartner(t, i);
+                }
+            }
+        }
+    }
+    partners.sort((a, b) => a.mover - b.mover || a.anchor - b.anchor);
+    return { nodes, indexOf, pairs, offsets, adjacency, partners, changed };
+}
+//# sourceMappingURL=union.js.map

package/dist/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../src/union.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@kgdiff/layout",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Stable, deterministic, label-aware layout for graph diffs: both versions share one mental map.",
+  "keywords": [
+    "kgdiff",
+    "layout",
+    "force-directed"
+  ],
+  "homepage": "https://github.com/iiwish/kgdiff/tree/main/packages/layout#readme",
+  "bugs": {
+    "url": "https://github.com/iiwish/kgdiff/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iiwish/kgdiff.git",
+    "directory": "packages/layout"
+  },
+  "license": "MIT",
+  "author": "iiwish",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@kgdiff/core": "0.1.0",
+    "d3-force": "3.0.0",
+    "d3-quadtree": "3.0.1"
+  },
+  "devDependencies": {
+    "@types/d3-force": "3.0.10",
+    "@types/d3-quadtree": "3.0.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
 }

package/src/components.ts

@@ -0,0 +1,56 @@
+/**
+ * Connected components over links AND merge / split partners (a merge source with no edges of
+ * its own still belongs next to its target).
+ */
+import type { LayoutGraph } from './graph.js';
+
+function find(parent: Int32Array, i: number): number {
+  let root = i;
+  while (parent[root]! !== root) root = parent[root]!;
+  let cur = i;
+  while (parent[cur]! !== root) {
+    const next = parent[cur]!;
+    parent[cur] = root;
+    cur = next;
+  }
+  return root;
+}
+
+function union(parent: Int32Array, a: number, b: number): void {
+  const ra = find(parent, a);
+  const rb = find(parent, b);
+  // Smaller index becomes the root: the result does not depend on edge order.
+  if (ra < rb) parent[rb] = ra;
+  else if (rb < ra) parent[ra] = rb;
+}
+
+/**
+ * Components as ascending index lists, largest first (ties: smallest first index, i.e. id order).
+ * `members` restricts the computation to a subset (others are ignored).
+ */
+export function connectedComponents(graph: LayoutGraph, members?: Uint8Array): number[][] {
+  const { n } = graph;
+  const parent = new Int32Array(n);
+  for (let i = 0; i < n; i++) parent[i] = i;
+  const inSet = (i: number): boolean => members === undefined || members[i] === 1;
+  for (let k = 0; k < graph.pairs.length; k += 2) {
+    const a = graph.pairs[k]!;
+    const b = graph.pairs[k + 1]!;
+    if (inSet(a) && inSet(b)) union(parent, a, b);
+  }
+  for (const { mover, anchor } of graph.partners) {
+    if (inSet(mover) && inSet(anchor)) union(parent, mover, anchor);
+  }
+  const byRoot = new Map<number, number[]>();
+  for (let i = 0; i < n; i++) {
+    if (!inSet(i)) continue;
+    const root = find(parent, i);
+    let list = byRoot.get(root);
+    if (list === undefined) {
+      list = [];
+      byRoot.set(root, list);
+    }
+    list.push(i);
+  }
+  return [...byRoot.values()].sort((a, b) => b.length - a.length || a[0]! - b[0]!);
+}

package/src/engine.ts

@@ -0,0 +1,444 @@
+/**
+ * Placement strategies over a `LayoutGraph` (docs/algorithms.md §12 "Strategy", "Components").
+ *
+ * - `placeFree`: every component laid out on its own, packed, centered at the origin.
+ * - `placeAnchored`: known nodes never move; unknown nodes connected to them are seeded next to
+ *   their placed neighbours and refined by a simulation in which the known nodes are fixed;
+ *   components without any known node are laid out freely and packed beside the anchored region.
+ */
+import { type QuadtreeLeaf, quadtree } from 'd3-quadtree';
+import { connectedComponents } from './components.js';
+import { type CollisionBoxes, removeOverlaps } from './forces/collide-rect.js';
+import { settleOverlapping } from './forces/free-spot.js';
+import {
+  anchoredChargeRange,
+  CHARGE_RANGE,
+  chargeStrength,
+  gravityFor,
+  linkDistance,
+  linkStrength,
+} from './forces/params.js';
+import type { Spring } from './forces/springs.js';
+import { BOX_PADDING, type Extent, extentOf, isEmpty } from './geometry.js';
+import type { LayoutGraph } from './graph.js';
+import { partnerLists, placeAroundFixed, placeOnSpiral } from './init.js';
+import { defaultIterations, type ResolvedLayoutOptions } from './options.js';
+import { pack } from './pack.js';
+import { mulberry32, type Random } from './prng.js';
+import { type SimLink, type SimNode, simulate } from './simulate.js';
+
+/** Merge / split partner springs (docs/algorithms.md §12), rest length 0.5·L. */
+const SPRING_STRENGTH = 0.08;
+const SPRING_LENGTH_RATIO = 0.5;
+/** Spiral spacing relative to the link distance: starts a bit denser than the final layout. */
+const SPIRAL_SPACING_RATIO = 0.4;
+const TARGET_ASPECT = 1.6;
+/** Pushing passes before wedged nodes are moved to free spots instead. */
+const SETTLE_PASSES = 24;
+
+export interface EngineContext {
+  readonly graph: LayoutGraph;
+  readonly options: ResolvedLayoutOptions;
+  /** Positions by layout index, filled in place. */
+  readonly x: Float64Array;
+  readonly y: Float64Array;
+}
+
+interface Workspace {
+  readonly partners: readonly (readonly number[])[];
+  /** layout index → sim index, −1 outside the current simulation. */
+  readonly slot: Int32Array;
+  readonly random: Random;
+}
+
+const workspace = (ctx: EngineContext): Workspace => ({
+  partners: partnerLists(ctx.graph),
+  slot: new Int32Array(ctx.graph.n).fill(-1),
+  random: mulberry32(ctx.options.seed),
+});
+
+/** Ticks for a simulation over `size` nodes: the option, else `defaultIterations(size)`. */
+const ticksFor = (ctx: EngineContext, size: number): number =>
+  ctx.options.iterations ?? defaultIterations(size);
+
+/**
+ * Lay out everything freely. Returns the ticks of the largest simulation run (0 when none ran,
+ * e.g. only isolated nodes).
+ */
+export function placeFree(ctx: EngineContext): number {
+  const ws = workspace(ctx);
+  const components = connectedComponents(ctx.graph);
+  const block = layoutBlock(ctx, ws, components);
+  const all = components.flat();
+  const e = extentOf(ctx.graph, all, ctx.x, ctx.y);
+  if (!isEmpty(e)) translate(ctx, all, -(e.minX + e.maxX) / 2, -(e.minY + e.maxY) / 2);
+  return block.ticks;
+}
+
+/**
+ * Lay out around `fixed` nodes, whose positions must already be in `ctx.x` / `ctx.y`.
+ * Returns the ticks of the largest simulation run (0 when none ran).
+ */
+export function placeAnchored(ctx: EngineContext, fixed: Uint8Array): number {
+  const { graph } = ctx;
+  const ws = workspace(ctx);
+  const components = connectedComponents(graph);
+  const anchoredComponents: number[][] = [];
+  const freeComponents: number[][] = [];
+  for (const component of components) {
+    (component.some((i) => fixed[i] === 1) ? anchoredComponents : freeComponents).push(component);
+  }
+
+  const members = anchoredComponents.flat().sort((a, b) => a - b);
+  const placed = Uint8Array.from(fixed);
+  placeAroundFixed(
+    graph,
+    ws.partners,
+    members,
+    placed,
+    ctx.x,
+    ctx.y,
+    ctx.options.linkDistance,
+    ctx.options.seed,
+  );
+
+  const free = members.filter((i) => fixed[i] !== 1);
+  let ticks = 0;
+  let largest = 0;
+  if (free.length > 0) {
+    // Refine with an energy (and a charge range) matching how much of the picture is new.
+    const share = free.length / members.length;
+    const window = simulationWindow(ctx, members, free, fixed);
+    ticks = ticksFor(ctx, window.length);
+    largest = window.length;
+    runSimulation(
+      ctx,
+      ws,
+      window,
+      fixed,
+      ticks,
+      0.3 + 0.7 * share,
+      false,
+      0,
+      anchoredChargeRange(share, ctx.options.linkDistance),
+    );
+    settle(ctx, members, fixed);
+  }
+
+  if (freeComponents.length > 0) {
+    const block = layoutBlock(ctx, ws, freeComponents);
+    if (block.largest > largest) ticks = block.ticks;
+    const anchoredExtent = extentOf(graph, members, ctx.x, ctx.y);
+    const nodes = freeComponents.flat();
+    const gap = ctx.options.componentGap;
+    const right = { dx: anchoredExtent.maxX + gap, dy: anchoredExtent.minY };
+    const below = { dx: anchoredExtent.minX, dy: anchoredExtent.maxY + gap };
+    const cost = (dx: number, dy: number): number => {
+      const w = Math.max(anchoredExtent.maxX, dx + block.width) - Math.min(anchoredExtent.minX, dx);
+      const h =
+        Math.max(anchoredExtent.maxY, dy + block.height) - Math.min(anchoredExtent.minY, dy);
+      const side = Math.max(w, h * TARGET_ASPECT);
+      return side * side;
+    };
+    const at = cost(below.dx, below.dy) < cost(right.dx, right.dy) - 1e-6 ? below : right;
+    translate(ctx, nodes, at.dx, at.dy);
+  }
+  return ticks;
+}
+
+/**
+ * The nodes worth simulating around `free` ones: all of them, their graph neighbours, and the
+ * fixed nodes within reach of where any of them starts (a quadtree range query per free node).
+ * Far-away fixed nodes cannot interact with the new ones in a refinement run, and skipping them
+ * keeps `extendLayout` interactive on large graphs.
+ */
+function simulationWindow(
+  ctx: EngineContext,
+  members: readonly number[],
+  free: readonly number[],
+  fixed: Uint8Array,
+): number[] {
+  const { graph, x, y } = ctx;
+  if (free.length * 2 >= members.length) return [...members];
+  const inWindow = new Uint8Array(graph.n);
+  let reach = 4 * ctx.options.linkDistance;
+  for (const i of free) {
+    reach = Math.max(reach, 2 * graph.boxHalfWidth[i]!, 2 * graph.boxBottom[i]!);
+    inWindow[i] = 1;
+    for (let k = graph.offsets[i]!; k < graph.offsets[i + 1]!; k++)
+      inWindow[graph.adjacency[k]!] = 1;
+  }
+  const tree = quadtree<number>()
+    .x((i) => x[i]!)
+    .y((i) => y[i]!)
+    .addAll(members.filter((i) => fixed[i] === 1));
+  for (const i of free) {
+    const x0 = x[i]! - reach;
+    const x1 = x[i]! + reach;
+    const y0 = y[i]! - reach;
+    const y1 = y[i]! + reach;
+    tree.visit((cell, cx0, cy0, cx1, cy1) => {
+      if (!cell.length) {
+        let leaf: QuadtreeLeaf<number> | undefined = cell as QuadtreeLeaf<number>;
+        while (leaf !== undefined) {
+          const j = leaf.data;
+          if (x[j]! >= x0 && x[j]! <= x1 && y[j]! >= y0 && y[j]! <= y1) inWindow[j] = 1;
+          leaf = leaf.next;
+        }
+      }
+      return cx0 > x1 || cx1 < x0 || cy0 > y1 || cy1 < y0;
+    });
+  }
+  return members.filter((i) => inWindow[i] === 1);
+}
+
+interface Block {
+  readonly width: number;
+  readonly height: number;
+  /** Ticks of the largest component simulated (0 when none was). */
+  readonly ticks: number;
+  /** Size of that component. */
+  readonly largest: number;
+}
+
+/**
+ * Simulate each multi-node component around the origin, then pack all of them (and the
+ * isolated nodes) into one block whose visual extent starts at (0, 0).
+ */
+function layoutBlock(ctx: EngineContext, ws: Workspace, components: readonly number[][]): Block {
+  const { graph, x, y, options } = ctx;
+  const visited = new Uint8Array(graph.n);
+  const groups: number[][] = [];
+  const isolated: number[] = [];
+  const extents: Extent[] = [];
+  let ticks = 0;
+  let largest = 0;
+
+  for (const component of components) {
+    if (component.length === 1) {
+      isolated.push(component[0]!);
+      continue;
+    }
+    placeOnSpiral(
+      graph,
+      ws.partners,
+      component,
+      options.linkDistance * SPIRAL_SPACING_RATIO,
+      ws.random,
+      visited,
+      x,
+      y,
+    );
+    const componentTicks = ticksFor(ctx, component.length);
+    // Components come largest first.
+    if (component.length > largest) {
+      largest = component.length;
+      ticks = componentTicks;
+    }
+    runSimulation(
+      ctx,
+      ws,
+      component,
+      undefined,
+      componentTicks,
+      1,
+      true,
+      gravityFor(component.length),
+      CHARGE_RANGE,
+    );
+    groups.push(component);
+    extents.push(extentOf(graph, component, x, y));
+  }
+
+  isolated.sort((a, b) => a - b);
+  const packed = pack({
+    components: extents.map((e) => ({ width: e.maxX - e.minX, height: e.maxY - e.minY })),
+    isolated: isolated.map((i) => ({
+      halfWidth: graph.boxHalfWidth[i]!,
+      top: graph.boxTop[i]!,
+      bottom: graph.boxBottom[i]!,
+    })),
+    componentGap: options.componentGap,
+    gridGapX: options.fontSize * 1.5,
+    gridGapY: options.fontSize,
+    aspect: TARGET_ASPECT,
+  });
+  for (let c = 0; c < groups.length; c++) {
+    const at = packed.components[c]!;
+    const e = extents[c]!;
+    translate(ctx, groups[c]!, at.x - e.minX, at.y - e.minY);
+  }
+  for (let k = 0; k < isolated.length; k++) {
+    const i = isolated[k]!;
+    const at = packed.isolated[k]!;
+    x[i] = at.x;
+    y[i] = at.y;
+  }
+  return { width: packed.width, height: packed.height, ticks, largest };
+}
+
+function translate(ctx: EngineContext, nodes: readonly number[], dx: number, dy: number): void {
+  for (const i of nodes) {
+    ctx.x[i]! += dx;
+    ctx.y[i]! += dy;
+  }
+}
+
+interface SimSetup {
+  readonly nodes: SimNode[];
+  readonly nodeBoxes: CollisionBoxes;
+  readonly labelBoxes: CollisionBoxes;
+  readonly charge: Float64Array;
+}
+
+/** Sim nodes (index k ↔ `list[k]`), collision boxes and charges for a list of layout indices. */
+function setup(
+  ctx: EngineContext,
+  list: readonly number[],
+  fixed: Uint8Array | undefined,
+): SimSetup {
+  const { graph, x, y, options } = ctx;
+  const m = list.length;
+  const nodeBoxes: CollisionBoxes = {
+    halfWidth: new Float64Array(m),
+    halfHeight: new Float64Array(m),
+    offsetY: new Float64Array(m),
+    invMass: new Float64Array(m),
+  };
+  const labelBoxes: CollisionBoxes = options.labelAware
+    ? {
+        halfWidth: new Float64Array(m),
+        halfHeight: new Float64Array(m),
+        offsetY: new Float64Array(m),
+        invMass: nodeBoxes.invMass,
+      }
+    : nodeBoxes;
+  const charge = new Float64Array(m);
+  const nodes: SimNode[] = [];
+  for (let k = 0; k < m; k++) {
+    const i = list[k]!;
+    const r = graph.radius[i]!;
+    const isFixed = fixed !== undefined && fixed[i] === 1;
+    const node: SimNode = { index: k, x: x[i]!, y: y[i]!, vx: 0, vy: 0 };
+    if (isFixed) {
+      node.fx = node.x;
+      node.fy = node.y;
+    }
+    nodes.push(node);
+    nodeBoxes.halfWidth[k] = r;
+    nodeBoxes.halfHeight[k] = r;
+    // Hubs are heavy: in a collision the leaf steps aside. Fixed nodes never move.
+    nodeBoxes.invMass[k] = isFixed ? 0 : 1 / (1 + graph.degree[i]!);
+    if (labelBoxes !== nodeBoxes) {
+      labelBoxes.halfWidth[k] = graph.boxHalfWidth[i]!;
+      labelBoxes.halfHeight[k] = (graph.boxBottom[i]! - graph.boxTop[i]!) / 2;
+      labelBoxes.offsetY[k] = (graph.boxBottom[i]! + graph.boxTop[i]!) / 2;
+    }
+    charge[k] = chargeStrength(graph, i, options.linkDistance, options.labelAware);
+  }
+  return { nodes, nodeBoxes, labelBoxes, charge };
+}
+
+function writeBack(ctx: EngineContext, list: readonly number[], nodes: readonly SimNode[]): void {
+  for (let k = 0; k < list.length; k++) {
+    const node = nodes[k]!;
+    if (node.fx == null) {
+      ctx.x[list[k]!] = node.x;
+      ctx.y[list[k]!] = node.y;
+    }
+  }
+}
+
+/** Simulate `list` (ascending layout indices) in place; fixed nodes keep their position. */
+function runSimulation(
+  ctx: EngineContext,
+  ws: Workspace,
+  list: readonly number[],
+  fixed: Uint8Array | undefined,
+  ticks: number,
+  alpha: number,
+  orient: boolean,
+  gravity: number,
+  chargeRange: number,
+): void {
+  const { graph, options } = ctx;
+  const { slot } = ws;
+  for (let k = 0; k < list.length; k++) slot[list[k]!] = k;
+  const { nodes, nodeBoxes, labelBoxes, charge } = setup(ctx, list, fixed);
+  const isFixed = (i: number): boolean => fixed !== undefined && fixed[i] === 1;
+
+  const L = options.linkDistance;
+  const links: SimLink[] = [];
+  for (let k = 0; k < list.length; k++) {
+    const i = list[k]!;
+    for (let e = graph.offsets[i]!; e < graph.offsets[i + 1]!; e++) {
+      const v = graph.adjacency[e]!;
+      const kv = slot[v]!;
+      if (v <= i || kv < 0 || (isFixed(i) && isFixed(v))) continue;
+      const distance = linkDistance(L, Math.max(1, Math.min(graph.degree[i]!, graph.degree[v]!)));
+      links.push({
+        source: nodes[k]!,
+        target: nodes[kv]!,
+        distance,
+        strength: linkStrength(graph, i, v, distance, options.labelAware),
+      });
+    }
+  }
+  const springs: Spring[] = [];
+  for (const { mover, anchor } of graph.partners) {
+    const km = slot[mover]!;
+    const ka = slot[anchor]!;
+    if (km >= 0 && ka >= 0) springs.push({ mover: km, anchor: ka });
+  }
+  for (const i of list) slot[i] = -1;
+
+  simulate({
+    nodes,
+    links,
+    springs,
+    charge,
+    nodeBoxes,
+    labelBoxes,
+    ticks,
+    alpha,
+    gravity,
+    orient,
+    springStrength: SPRING_STRENGTH,
+    springLength: L * SPRING_LENGTH_RATIO,
+    dockDistance: L,
+    chargeRange,
+    padding: BOX_PADDING,
+    random: ws.random,
+  });
+  writeBack(ctx, list, nodes);
+}
+
+/**
+ * Final overlap removal over the whole anchored region (`list`), fixed nodes being immovable
+ * obstacles: pushes first (new nodes may have drifted next to fixed nodes outside the simulation
+ * window), then free spots for nodes that pushing cannot free.
+ */
+function settle(ctx: EngineContext, list: readonly number[], fixed: Uint8Array): void {
+  const { graph, x, y } = ctx;
+  const { nodes, labelBoxes } = setup(ctx, list, fixed);
+  removeOverlaps(nodes, labelBoxes, BOX_PADDING, SETTLE_PASSES);
+  const slotOf = new Map<number, number>();
+  list.forEach((i, k) => {
+    slotOf.set(i, k);
+  });
+  settleOverlapping(nodes, labelBoxes, BOX_PADDING, (k) => {
+    const i = list[k]!;
+    let sx = 0;
+    let sy = 0;
+    let count = 0;
+    for (let e = graph.offsets[i]!; e < graph.offsets[i + 1]!; e++) {
+      const node = nodes[slotOf.get(graph.adjacency[e]!) ?? -1];
+      if (node === undefined) continue;
+      sx += node.x;
+      sy += node.y;
+      count++;
+    }
+    return count > 0 ? { x: sx / count, y: sy / count } : { x: x[i]!, y: y[i]! };
+  });
+  writeBack(ctx, list, nodes);
+}