@dxos/diagram 0.11.1 → 0.13.0

package/src/objective.ts

@@ -112,6 +112,22 @@ export const crossings: CostTerm = {
   measure: ({ report }) => report.metrics.crossings,
 };
 
+/** Labels overlapping other labels or boxes; as costly as a crossing, since either hides what the reader needs. */
+export const textOverlaps: CostTerm = {
+  id: 'text-overlaps',
+  description: 'Labels overlapping another label or a box.',
+  weight: 3,
+  measure: ({ report }) => report.metrics.textOverlaps,
+};
+
+/** Connector pairs sharing a stretch of line; as costly as a crossing, since the reader cannot pair their ends. */
+export const edgeOverlaps: CostTerm = {
+  id: 'edge-overlaps',
+  description: 'Connector pairs that run along the same line.',
+  weight: 3,
+  measure: ({ report }) => report.metrics.edgeOverlaps,
+};
+
 export const bends: CostTerm = {
   id: 'bends',
   description: 'Turns taken by connectors.',
@@ -153,5 +169,5 @@ export const compactness: CostTerm = {
 
 export const DEFAULT: Objective = {
   constraints: [noHardDefects, framesApart()],
-  costs: [crossings, bends, connectorLength, unevenFrameGaps, compactness],
+  costs: [crossings, edgeOverlaps, textOverlaps, bends, connectorLength, unevenFrameGaps, compactness],
 };

package/src/ortho-router.ts

@@ -27,11 +27,98 @@ type Point = Scene.Point;
 const DX = [1, 0, -1, 0];
 const DY = [0, 1, 0, -1];
 
+/** Offsets past this distance turn the same way as at it, so the table clamps to it. */
+const TURN_RADIUS = 4;
+const TURN_SPAN = TURN_RADIUS * 2 + 1;
+
+/**
+ * Fewest turns from a cell heading `dir` to a target `(dx, dy)` away, entered heading `endDir` or
+ * paying the search's one-turn penalty for entering off-axis — on an empty grid, so an admissible
+ * and consistent lower bound for the search, indexed `[endDir][dir][dx][dy]`. It is exact where the
+ * old estimate ignored the arrival heading, which sent every search sweeping the cells behind its
+ * target. Computed once, by one backward search per arrival heading over the moves the search makes.
+ */
+const TURN_TABLE = (() => {
+  const table = new Uint8Array(4 * 4 * TURN_SPAN * TURN_SPAN);
+  // The board leaves room around the radius for the detours an off-axis approach takes.
+  const board = TURN_RADIUS + 4;
+  const side = board * 2 + 1;
+  const stateOf = (x: number, y: number, dir: number) => ((y + board) * side + (x + board)) * 4 + dir;
+  const turns = new Uint8Array(side * side * 4);
+  // Label-correcting relaxation: steps cost 0, 1 or 2 turns, and a state re-enters the queue
+  // whenever it improves, so the queue holds at most a few passes over a small board.
+  const queue = new Int32Array(side * side * 4 * 8);
+  for (let endDir = 0; endDir < 4; endDir++) {
+    turns.fill(255);
+    let head = 0;
+    let tail = 0;
+    // Arriving at the target ends the search whatever the heading.
+    for (let dir = 0; dir < 4; dir++) {
+      turns[stateOf(0, 0, dir)] = 0;
+      queue[tail++] = stateOf(0, 0, dir);
+    }
+    while (head < tail) {
+      const state = queue[head++ % queue.length];
+      const arrivedDir = state % 4;
+      const cell = (state - arrivedDir) / 4;
+      const x = (cell % side) - board;
+      const y = Math.floor(cell / side) - board;
+      // Every state that steps into (x, y) heading `arrivedDir`, and what that step costs.
+      const px = x - DX[arrivedDir];
+      const py = y - DY[arrivedDir];
+      if (Math.abs(px) > board || Math.abs(py) > board || (px === 0 && py === 0)) {
+        continue;
+      }
+      const arrival = x === 0 && y === 0 && arrivedDir !== endDir ? 1 : 0;
+      for (let dir = 0; dir < 4; dir++) {
+        if ((arrivedDir + 2) % 4 === dir) {
+          continue;
+        }
+        const previous = stateOf(px, py, dir);
+        const total = turns[state] + (arrivedDir === dir ? 0 : 1) + arrival;
+        if (total < turns[previous]) {
+          turns[previous] = total;
+          queue[tail++ % queue.length] = previous;
+        }
+      }
+    }
+    for (let dir = 0; dir < 4; dir++) {
+      for (let dx = -TURN_RADIUS; dx <= TURN_RADIUS; dx++) {
+        for (let dy = -TURN_RADIUS; dy <= TURN_RADIUS; dy++) {
+          const at = ((endDir * 4 + dir) * TURN_SPAN + dx + TURN_RADIUS) * TURN_SPAN + dy + TURN_RADIUS;
+          table[at] = dx === 0 && dy === 0 ? 0 : turns[stateOf(-dx, -dy, dir)];
+        }
+      }
+    }
+  }
+  return table;
+})();
+
+const clampTurnOffset = (offset: number) => Math.max(-TURN_RADIUS, Math.min(TURN_RADIUS, offset));
+
+const turnsBetween = (dx: number, dy: number, dir: number, endDir: number): number =>
+  TURN_TABLE[
+    ((endDir * 4 + dir) * TURN_SPAN + clampTurnOffset(dx) + TURN_RADIUS) * TURN_SPAN + clampTurnOffset(dy) + TURN_RADIUS
+  ];
+
 export type AvoidingRouterOptions = {
   /** Search-cell size (scene px): a fraction of the layout grid, so routes can hug node borders. */
   step: number;
 };
 
+/** Paths an avoiding router marked as used, so a later router can replay them; weak, so it holds nothing alive. */
+const marked = new WeakSet<readonly Point[]>();
+
+/** The avoiding router plus a way to replay an earlier route's footprint without searching again. */
+export type AvoidingRouter = Router & {
+  /**
+   * Marks the cells of a path an avoiding router over the same obstacles returned before as used, as
+   * routing it did; a path that marked nothing (a fallback route) marks nothing, so a replayed prefix
+   * leaves the same state.
+   */
+  reserve: (points: readonly Point[]) => void;
+};
+
 /**
  * Creates a router that avoids the given node rects. Stateful across edges: earlier routes
  * penalize (not block) the cells they occupy, spreading parallel runs apart. `fallback` handles
@@ -42,7 +129,7 @@ export const makeAvoidingRouter = (
   obstacles: Rect[],
   fallback: Router,
   { step: STEP }: AvoidingRouterOptions,
-): Router => {
+): AvoidingRouter => {
   const xs = obstacles.flatMap((rect) => [rect.x, rect.x + rect.w]);
   const ys = obstacles.flatMap((rect) => [rect.y, rect.y + rect.h]);
   const bounds = {
@@ -51,14 +138,25 @@ export const makeAvoidingRouter = (
     x1: Math.ceil(Math.max(...xs) / STEP) + MARGIN,
     y1: Math.ceil(Math.max(...ys) / STEP) + MARGIN,
   };
-  const width = bounds.x1 - bounds.x0 + 1;
-  const height = bounds.y1 - bounds.y0 + 1;
+  // The grids carry a one-cell blocked border, so the search's blocked test also keeps it in bounds.
+  const width = bounds.x1 - bounds.x0 + 3;
+  const height = bounds.y1 - bounds.y0 + 3;
   const inBounds = (x: number, y: number) => x >= bounds.x0 && x <= bounds.x1 && y >= bounds.y0 && y <= bounds.y1;
-  const cellIndex = (x: number, y: number) => (y - bounds.y0) * width + (x - bounds.x0);
+  const cellIndex = (x: number, y: number) => (y - bounds.y0 + 1) * width + (x - bounds.x0 + 1);
+  /** Cell offsets per direction, matching `DX` and `DY`. */
+  const STEPS = [1, width, -1, -width];
 
   // Flat grids in place of per-cell string keys: the search touches every cell many times over and
   // the string building was half its running time.
   const blockedGrid = new Uint8Array(width * height);
+  for (let x = 0; x < width; x++) {
+    blockedGrid[x] = 1;
+    blockedGrid[(height - 1) * width + x] = 1;
+  }
+  for (let y = 0; y < height; y++) {
+    blockedGrid[y * width] = 1;
+    blockedGrid[y * width + width - 1] = 1;
+  }
   for (const rect of obstacles) {
     const x0 = Math.floor(rect.x / STEP) - CLEARANCE;
     const y0 = Math.floor(rect.y / STEP) - CLEARANCE;
@@ -84,140 +182,204 @@ export const makeAvoidingRouter = (
   const settledGen = new Int32Array(width * height * 4);
   let generation = 0;
 
-  /** `f` is cost + estimate, the heap's key. */
-  type State = { x: number; y: number; dir: number; cost: number; f: number; prev?: State };
   type Terminal = { point: Point; dir: number };
   type Found = { cost: number; cells: Point[] };
 
+  // Search states live in a pool of parallel typed arrays, addressed by slot, and the heap holds
+  // slots: a search pushes millions of states, and one object per state made GC a third of the run.
+  let capacity = 1 << 16;
+  let stateKey = new Int32Array(capacity);
+  let stateCost = new Float64Array(capacity);
+  let statePrev = new Int32Array(capacity);
+  let heap = new Int32Array(capacity);
+  // Each heap entry's key beside its slot, so sifting compares without chasing the slot into the pool.
+  let heapF = new Float64Array(capacity);
+  let poolSize = 0;
+  let heapSize = 0;
+
+  const grow = () => {
+    capacity *= 2;
+    const widen = <T extends Int32Array | Float64Array>(array: T, make: (size: number) => T): T => {
+      const next = make(capacity);
+      next.set(array);
+      return next;
+    };
+    stateKey = widen(stateKey, (size) => new Int32Array(size));
+    stateCost = widen(stateCost, (size) => new Float64Array(size));
+    statePrev = widen(statePrev, (size) => new Int32Array(size));
+    heap = widen(heap, (size) => new Int32Array(size));
+    heapF = widen(heapF, (size) => new Float64Array(size));
+  };
+
   /** Binary min-heap on cost + estimate, so each pop is O(log n) instead of a frontier scan. */
-  const heapPush = (heap: State[], state: State) => {
-    heap.push(state);
-    let index = heap.length - 1;
+  const heapPush = (key: number, cost: number, f: number, prev: number) => {
+    if (poolSize === capacity) {
+      grow();
+    }
+    const slot = poolSize++;
+    stateKey[slot] = key;
+    stateCost[slot] = cost;
+    statePrev[slot] = prev;
+    let index = heapSize++;
     while (index > 0) {
       const parent = (index - 1) >> 1;
-      if (heap[parent].f <= heap[index].f) {
+      if (heapF[parent] <= f) {
         break;
       }
-      [heap[parent], heap[index]] = [heap[index], heap[parent]];
+      heap[index] = heap[parent];
+      heapF[index] = heapF[parent];
       index = parent;
     }
+    heap[index] = slot;
+    heapF[index] = f;
   };
-  const heapPop = (heap: State[]): State => {
+  const heapPop = (): number => {
     const top = heap[0];
-    const last = heap.pop()!;
-    if (heap.length > 0) {
-      heap[0] = last;
+    const last = heap[--heapSize];
+    if (heapSize > 0) {
+      const lastF = heapF[heapSize];
       let index = 0;
       for (;;) {
         const left = index * 2 + 1;
         const right = left + 1;
         let smallest = index;
-        if (left < heap.length && heap[left].f < heap[smallest].f) {
+        let smallestF = lastF;
+        if (left < heapSize && heapF[left] < smallestF) {
           smallest = left;
+          smallestF = heapF[left];
         }
-        if (right < heap.length && heap[right].f < heap[smallest].f) {
+        if (right < heapSize && heapF[right] < smallestF) {
           smallest = right;
+          smallestF = heapF[right];
         }
         if (smallest === index) {
           break;
         }
-        [heap[smallest], heap[index]] = [heap[index], heap[smallest]];
+        heap[index] = heap[smallest];
+        heapF[index] = smallestF;
         index = smallest;
       }
+      heap[index] = last;
+      heapF[index] = lastF;
     }
     return top;
   };
 
-  /**
-   * Fewest turns any path from (x, y) heading `dir` needs to reach the target: none while aligned
-   * and heading at it, two when heading away along its axis, otherwise one. Admissible, and since
-   * a turn costs as much as a thousand steps it is what makes the search converge on a diagram
-   * hundreds of cells across — distance alone leaves it exploring almost uniformly.
-   */
-  const turnsNeeded = (x: number, y: number, dir: number, target: Point): number => {
+  const estimateFrom = (x: number, y: number, dir: number, target: Point, endDir: number): number => {
     const dx = target.x - x;
     const dy = target.y - y;
-    if (dx !== 0 && dy !== 0) {
-      return 1;
-    }
-    if (dx === 0 && dy === 0) {
-      return 0;
-    }
-    const towards = dx !== 0 ? (dx > 0 ? 0 : 2) : dy > 0 ? 1 : 3;
-    return dir === towards ? 0 : (dir + 2) % 4 === towards ? 2 : 1;
+    return Math.abs(dx) + Math.abs(dy) + turnsBetween(dx, dy, dir, endDir) * TURN_COST;
   };
 
-  const estimateFrom = (x: number, y: number, dir: number, target: Point): number =>
-    Math.abs(target.x - x) + Math.abs(target.y - y) + turnsNeeded(x, y, dir, target) * TURN_COST;
-
   // Every cell in every heading, so a reachable target is never abandoned on a large diagram.
   const budget = Math.max(50_000, (bounds.x1 - bounds.x0) * (bounds.y1 - bounds.y0) * 4);
 
   /**
    * Bounded A* between two stub ends (grid coordinates). Successors already dominated by a
-   * settled state are pruned before pushing; undefined when the target is unreachable.
+   * settled state are pruned before pushing; undefined when the target is unreachable or no path
+   * costs less than `bound`.
    */
-  const search = (source: Point, startDir: number, target: Point, endDir: number): Found | undefined => {
-    const open: State[] = [
-      { x: source.x, y: source.y, dir: startDir, cost: 0, f: estimateFrom(source.x, source.y, startDir, target) },
-    ];
+  const search = (
+    source: Point,
+    startDir: number,
+    target: Point,
+    endDir: number,
+    bound = Infinity,
+  ): Found | undefined => {
+    poolSize = 0;
+    heapSize = 0;
+    heapPush(
+      cellIndex(source.x, source.y) * 4 + startDir,
+      0,
+      estimateFrom(source.x, source.y, startDir, target, endDir),
+      -1,
+    );
     generation++;
-    const settledAt = (index: number) => (settledGen[index] === generation ? settledCost[index] : undefined);
-    let found: State | undefined;
+    const targetCell = inBounds(target.x, target.y) ? cellIndex(target.x, target.y) : -1;
+    // Coordinates relative to the padded grid, so the estimate needs no conversion per state.
+    const targetX = target.x - bounds.x0 + 1;
+    const targetY = target.y - bounds.y0 + 1;
+    let found = -1;
 
-    for (let iterations = 0; open.length > 0 && iterations < budget; iterations++) {
-      const current = heapPop(open);
-      if (current.x === target.x && current.y === target.y) {
+    for (let iterations = 0; heapSize > 0 && iterations < budget; iterations++) {
+      // The estimate is admissible, so once the cheapest frontier key reaches the bound no path
+      // can beat it; without this a losing configuration explores every state up to its own optimum.
+      if (heapF[0] >= bound) {
+        break;
+      }
+      const current = heapPop();
+      const stateIndex = stateKey[current];
+      const currentDir = stateIndex & 3;
+      const currentCell = stateIndex >> 2;
+      const currentCost = stateCost[current];
+      if (currentCell === targetCell) {
         found = current;
         break;
       }
-      const stateIndex = cellIndex(current.x, current.y) * 4 + current.dir;
-      const seen = settledAt(stateIndex);
-      if (seen !== undefined && seen <= current.cost) {
+      if (settledGen[stateIndex] === generation && settledCost[stateIndex] <= currentCost) {
         continue;
       }
       settledGen[stateIndex] = generation;
-      settledCost[stateIndex] = current.cost;
+      settledCost[stateIndex] = currentCost;
+      const currentY = Math.floor(currentCell / width);
+      const currentX = currentCell - currentY * width;
 
       for (let dir = 0; dir < 4; dir++) {
-        if ((dir + 2) % 4 === current.dir) {
-          continue;
-        }
-        const x = current.x + DX[dir];
-        const y = current.y + DY[dir];
-        if (!inBounds(x, y)) {
+        if ((dir + 2) % 4 === currentDir) {
           continue;
         }
-        const cell = cellIndex(x, y);
+        const cell = currentCell + STEPS[dir];
         if (blockedGrid[cell] !== 0) {
           continue;
         }
         const cost =
-          current.cost +
+          currentCost +
           1 +
-          (dir === current.dir ? 0 : TURN_COST) +
+          (dir === currentDir ? 0 : TURN_COST) +
           (usedGrid[cell] !== 0 ? USED_COST : 0) +
           // Entering the target off-axis forces one more bend at arrival; fold it in.
-          (x === target.x && y === target.y && dir !== endDir ? TURN_COST : 0);
-        const dominated = settledAt(cell * 4 + dir);
-        if (dominated !== undefined && dominated <= cost) {
+          (cell === targetCell && dir !== endDir ? TURN_COST : 0);
+        const next = cell * 4 + dir;
+        if (settledGen[next] === generation && settledCost[next] <= cost) {
           continue;
         }
-        heapPush(open, { x, y, dir, cost, f: cost + estimateFrom(x, y, dir, target), prev: current });
+        const dx = targetX - (currentX + DX[dir]);
+        const dy = targetY - (currentY + DY[dir]);
+        heapPush(
+          next,
+          cost,
+          cost + (Math.abs(dx) + Math.abs(dy) + turnsBetween(dx, dy, dir, endDir) * TURN_COST),
+          current,
+        );
       }
     }
 
-    if (!found) {
+    if (found < 0) {
       return undefined;
     }
     const cells: Point[] = [];
-    for (let state: State | undefined = found; state; state = state.prev) {
-      cells.unshift({ x: state.x, y: state.y });
+    for (let slot = found; slot >= 0; slot = statePrev[slot]) {
+      const cell = stateKey[slot] >> 2;
+      cells.unshift({ x: (cell % width) + bounds.x0 - 1, y: Math.floor(cell / width) + bounds.y0 - 1 });
     }
-    return { cost: found.cost, cells };
+    return { cost: stateCost[found], cells };
   };
 
-  return (edge: RoutedRelation): Point[] => {
+  const markPath = (path: readonly Point[]) => {
+    for (let index = 0; index < path.length - 1; index++) {
+      const a = path[index];
+      const b = path[index + 1];
+      const ax = Math.round(a.x / STEP);
+      const ay = Math.round(a.y / STEP);
+      const steps = Math.max(Math.abs(Math.round(b.x / STEP) - ax), Math.abs(Math.round(b.y / STEP) - ay));
+      const dx = Math.sign(b.x - a.x);
+      const dy = Math.sign(b.y - a.y);
+      for (let step = 0; step <= steps; step++) {
+        markUsed(ax + dx * step, ay + dy * step);
+      }
+    }
+  };
+  const route = (edge: RoutedRelation): Point[] => {
     const { from, to, horizontal, ports } = edge;
     // Flow-axis faces mirror the Z-router (and the port assignment in `emit`).
     const sameLane = horizontal ? from.x === to.x : from.y === to.y;
@@ -270,6 +432,7 @@ export const makeAvoidingRouter = (
         startTerminal.dir,
         stub(endTerminal.point, endTerminal.dir, false),
         endTerminal.dir,
+        best?.cost,
       );
       if (result && (!best || result.cost < best.cost)) {
         best = result;
@@ -355,18 +518,15 @@ export const makeAvoidingRouter = (
     }
 
     // Mark the final path's cells so later edges route (and center) around it.
-    for (let index = 0; index < simplified.length - 1; index++) {
-      const a = simplified[index];
-      const b = simplified[index + 1];
-      const ax = Math.round(a.x / STEP);
-      const ay = Math.round(a.y / STEP);
-      const steps = Math.max(Math.abs(Math.round(b.x / STEP) - ax), Math.abs(Math.round(b.y / STEP) - ay));
-      const dx = Math.sign(b.x - a.x);
-      const dy = Math.sign(b.y - a.y);
-      for (let step = 0; step <= steps; step++) {
-        markUsed(ax + dx * step, ay + dy * step);
-      }
-    }
+    markPath(simplified);
+    marked.add(simplified);
     return simplified;
   };
+
+  const reserve = (points: readonly Point[]) => {
+    if (marked.has(points)) {
+      markPath(points);
+    }
+  };
+  return Object.assign(route, { reserve });
 };

package/src/ports.test.ts

@@ -0,0 +1,157 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { type PortPath, assign, keyOf } from './ports.ts';
+import type * as Scene from './scene.ts';
+import { GRID, type Rect, zRouter } from './uml-grid.ts';
+
+const STEP = GRID / 2;
+
+type Segment = readonly [Scene.Point, Scene.Point];
+
+const segmentsOf = (points: readonly Scene.Point[]): Segment[] =>
+  points.slice(1).map((end, index) => [points[index], end] as const);
+
+/** Whether two orthogonal polylines cross at a point interior to a segment of each. */
+const crosses = (first: readonly Scene.Point[], second: readonly Scene.Point[]) =>
+  segmentsOf(first).some(([a0, a1]) =>
+    segmentsOf(second).some(([b0, b1]) => {
+      const [vertical, horizontal] =
+        a0.x === a1.x
+          ? [
+              [a0, a1],
+              [b0, b1],
+            ]
+          : [
+              [b0, b1],
+              [a0, a1],
+            ];
+      if (vertical[0].x !== vertical[1].x || horizontal[0].y !== horizontal[1].y) {
+        return false;
+      }
+      const x = vertical[0].x;
+      const y = horizontal[0].y;
+      return (
+        x > Math.min(horizontal[0].x, horizontal[1].x) &&
+        x < Math.max(horizontal[0].x, horizontal[1].x) &&
+        y > Math.min(vertical[0].y, vertical[1].y) &&
+        y < Math.max(vertical[0].y, vertical[1].y)
+      );
+    }),
+  );
+
+describe('ports', () => {
+  // One box above two targets that sit far apart below it, on its left and its right.
+  const source: Rect = { x: 384, y: 0, w: 192, h: 96 };
+  const left: Rect = { x: 0, y: 384, w: 192, h: 96 };
+  const right: Rect = { x: 768, y: 384, w: 192, h: 96 };
+
+  /**
+   * Routes both edges off the bottom face as Zs whose cross runs sit at different heights, as two
+   * routes that share a side do once the second steers off the first.
+   */
+  const routeBoth = (toLeft: number, toRight: number) => {
+    const route = (target: Rect, start: number, offset: number) =>
+      zRouter({
+        relation: { from: 'source', to: target === left ? 'left' : 'right' },
+        from: source,
+        to: target,
+        horizontal: false,
+        offset,
+        ports: { start, end: target.x + target.w / 2 },
+      });
+    return [route(left, toLeft, 0), route(right, toRight, 1)];
+  };
+
+  test('two edges leaving one side in crossed order are reordered so they no longer cross', ({ expect }) => {
+    // Crossed: the edge to the left target leaves from the right of the side and vice versa.
+    const crossed = routeBoth(source.x + source.w - STEP * 2, source.x + STEP * 2);
+    expect(crossed.every((points) => points[0].y === source.y + source.h)).toBe(true);
+    expect(crosses(crossed[0], crossed[1])).toBe(true);
+
+    const paths: PortPath[] = [
+      { points: crossed[0], source, target: left },
+      { points: crossed[1], source, target: right },
+    ];
+    const [toLeft, toRight] = assign(paths, { step: STEP });
+    expect(toLeft.start).toBeDefined();
+    expect(toRight.start).toBeDefined();
+    const [leftStart, rightStart] = [toLeft.start ?? 0, toRight.start ?? 0];
+    expect(leftStart).toBeLessThan(rightStart);
+    for (const coord of [leftStart, rightStart]) {
+      expect(coord % STEP).toBe(0);
+      expect(coord).toBeGreaterThanOrEqual(source.x + STEP);
+      expect(coord).toBeLessThanOrEqual(source.x + source.w - STEP);
+    }
+    // The far ends were not asked to move.
+    expect(toLeft.end).toBeUndefined();
+    expect(toRight.end).toBeUndefined();
+
+    const ordered = routeBoth(leftStart, rightStart);
+    expect(crosses(ordered[0], ordered[1])).toBe(false);
+  });
+
+  test('a side already in order is left alone', ({ expect }) => {
+    const ordered = routeBoth(source.x + STEP * 2, source.x + source.w - STEP * 2);
+    expect(crosses(ordered[0], ordered[1])).toBe(false);
+    const assigned = assign(
+      [
+        { points: ordered[0], source, target: left },
+        { points: ordered[1], source, target: right },
+      ],
+      { step: STEP },
+    );
+    expect(assigned).toEqual([{}, {}]);
+  });
+
+  test('free ports are placed around a fixed one in key order', ({ expect }) => {
+    const below: Rect = { x: 384, y: 384, w: 192, h: 96 };
+    const center = source.x + source.w / 2;
+    const straight = [
+      { x: center, y: source.y + source.h },
+      { x: center, y: below.y },
+    ];
+    // Both turning edges start left of the straight one, though one of them heads right.
+    const turningRight = [
+      { x: center - STEP, y: 96 },
+      { x: center - STEP, y: 160 },
+      { x: right.x + right.w / 2, y: 160 },
+      { x: right.x + right.w / 2, y: right.y },
+    ];
+    const turningLeft = [
+      { x: center - STEP * 2, y: 96 },
+      { x: center - STEP * 2, y: 192 },
+      { x: left.x + left.w / 2, y: 192 },
+      { x: left.x + left.w / 2, y: left.y },
+    ];
+    const [first, second, third] = assign(
+      [
+        { points: straight, source, target: below, fixed: { start: true, end: true } },
+        { points: turningRight, source, target: right },
+        { points: turningLeft, source, target: left },
+      ],
+      { step: STEP },
+    );
+    expect(first).toEqual({});
+    expect(second.start).toBeGreaterThanOrEqual(center + STEP);
+    expect(third.start).toBeLessThanOrEqual(center - STEP);
+  });
+
+  test('keys order turning routes so neither turn-off cuts the other', ({ expect }) => {
+    const out = (run: number, towards: number) => [
+      { x: 0, y: 0 },
+      { x: 0, y: run },
+      { x: towards, y: run },
+    ];
+    // Of two routes turning to the high end, the one running out farther belongs nearer the low end.
+    expect(keyOf(out(64, 100), 'bottom')).toBeLessThan(keyOf(out(32, 100), 'bottom'));
+    // Of two turning to the low end, the one turning sooner belongs nearer the low end.
+    expect(keyOf(out(32, -100), 'bottom')).toBeLessThan(keyOf(out(64, -100), 'bottom'));
+    // A route that does not turn sits between the two fans.
+    expect(keyOf(out(64, -100), 'bottom')).toBeLessThan(keyOf(out(64, 0).slice(0, 2), 'bottom'));
+    expect(keyOf(out(64, 0).slice(0, 2), 'bottom')).toBeLessThan(keyOf(out(64, 100), 'bottom'));
+  });
+});