@knowvah/dot-engine 0.1.0

package/src/ortho/ortho-parallel.ts

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Parallel-segment precedence edges for orthogonal track assignment.
+ *
+ * When two segments occupy the exact same channel position (`is_parallel`),
+ * `top_sort`'s default ordering is unconstrained — C resolves the tie by
+ * walking outward along each segment's route until the two chains diverge,
+ * then propagating the divergent pair's `seg_cmp` precedence back along the
+ * parallel run as explicit graph edges. Skipping this (as an earlier port
+ * revision did — see corpus 1447_1) leaves parallel tracks in whatever order
+ * `top_sort` picks by construction, which does not match the C oracle.
+ *
+ * Faithful port of `lib/ortho/ortho.c:780-1010`.
+ *
+ * @see lib/ortho/ortho.c:next_seg
+ * @see lib/ortho/ortho.c:is_parallel
+ * @see lib/ortho/ortho.c:propagate_prec
+ * @see lib/ortho/ortho.c:decide_point
+ * @see lib/ortho/ortho.c:set_parallel_edges
+ * @see lib/ortho/ortho.c:removeEdge
+ * @see lib/ortho/ortho.c:addPEdges
+ * @see lib/ortho/ortho.c:add_p_edges
+ */
+
+import type { OrthoSegment, Channel, ChanDict, Maze } from "./types.js";
+import { Bend } from "./types.js";
+import { chanSearch, chansInOrder } from "./maze-channels.js";
+import { insertEdge, edgeExists, removeRedge } from "./rawgraph.js";
+import { segCmp } from "./ortho-route.js";
+
+/** @see lib/ortho/ortho.c:next_seg */
+function nextSeg(seg: OrthoSegment, dir: number): OrthoSegment | null {
+  if (!dir) return seg.prev;
+  return seg.next;
+}
+
+/** @see lib/ortho/ortho.c:is_parallel */
+function isParallel(s1: OrthoSegment, s2: OrthoSegment): boolean {
+  return s1.p.p1 === s2.p.p1 && s1.p.p2 === s2.p.p2 &&
+    s1.l1 === s2.l1 && s1.l2 === s2.l2;
+}
+
+/** @see lib/ortho/ortho.c:propagate_prec */
+function propagatePrec(seg: OrthoSegment, prec: number, hops: number, dir: number): number {
+  let ans = prec;
+  let current = seg;
+  for (let x = 1; x <= hops; x++) {
+    const next = nextSeg(current, dir)!;
+    if (!current.isVert) {
+      if (next.commCoord === current.p.p1) {
+        if (current.l1 === Bend.B_UP) ans *= -1;
+      } else {
+        if (current.l2 === Bend.B_DOWN) ans *= -1;
+      }
+    } else {
+      if (next.commCoord === current.p.p1) {
+        if (current.l1 === Bend.B_RIGHT) ans *= -1;
+      } else {
+        if (current.l2 === Bend.B_LEFT) ans *= -1;
+      }
+    }
+    current = next;
+  }
+  return ans;
+}
+
+/** @see lib/ortho/ortho.c:decide_point */
+function decidePoint(
+  ret: { a: number; b: number },
+  si: OrthoSegment, sj: OrthoSegment, dir1: number, dir2: number,
+): number {
+  let prec = 0;
+  let ans = 0;
+  let np1: OrthoSegment | null;
+  let np2: OrthoSegment | null = null;
+  while ((np1 = nextSeg(si, dir1)) !== null &&
+         (np2 = nextSeg(sj, dir2)) !== null &&
+         isParallel(np1, np2)) {
+    ans++;
+    si = np1; // eslint-disable-line no-param-reassign
+    sj = np2; // eslint-disable-line no-param-reassign
+  }
+  if (np1 === null) prec = 0;
+  else if (np2 === null) throw new Error("decide_point: np2 null (C assert(0))");
+  else {
+    const temp = segCmp(np1, np2);
+    if (temp === -2) return -1;
+    prec = propagatePrec(np1, temp, ans + 1, 1 - dir1);
+  }
+  ret.a = ans;
+  ret.b = prec;
+  return 0;
+}
+
+/**
+ * Truth table for `set_parallel_edges`'s four nested branches
+ * (`ortho.c:797-849`), keyed by (isVert, commCoordMatchesP1, lDirMatchesTarget)
+ * where `lDirMatchesTarget` is `l1===B_UP`/`l2===B_UP` for the horizontal axis
+ * and `l1===B_LEFT`/`l2===B_LEFT` for the vertical axis (the two `l1`-vs-`l2`
+ * arms are selected by `commCoordMatchesP1`, mirroring `ortho.c`'s
+ * `prev1->comm_coord==seg1->p.p1` test). The value is `flip`: whether
+ * `edge_exists(chan, seg1, seg2)` being true means the new edge is inserted
+ * as `(prev2, prev1)` (flip) rather than `(prev1, prev2)`.
+ *
+ * Table derived by exhaustive enumeration of the 8 C branches (4 per axis,
+ * 2 truth values of `edge_exists` each collapse to one `flip` bit) — see
+ * `ortho-parallel.test.ts` for the pinned truth-table regression.
+ *
+ * @see lib/ortho/ortho.c:780-849 set_parallel_edges
+ */
+const SPE_FLIP_TABLE: Record<string, boolean> = {
+  "h,A,dir": true,
+  "h,A,!dir": false,
+  "h,!A,dir": false,
+  "h,!A,!dir": true,
+  "v,A,dir": false,
+  "v,A,!dir": true,
+  "v,!A,dir": true,
+  "v,!A,!dir": false,
+};
+
+function speFlip(isVert: boolean, commCoordMatchesP1: boolean, lDirMatchesTarget: boolean): boolean {
+  const axis = isVert ? "v" : "h";
+  const a = commCoordMatchesP1 ? "A" : "!A";
+  const d = lDirMatchesTarget ? "dir" : "!dir";
+  return SPE_FLIP_TABLE[`${axis},${a},${d}`];
+}
+
+/** @see lib/ortho/ortho.c:set_parallel_edges */
+function setParallelEdges(
+  seg1: OrthoSegment, seg2: OrthoSegment, dir1: number, dir2: number,
+  hops: number, mp: Maze,
+): void {
+  let chan = seg1.isVert
+    ? chanSearch(mp.vchans, seg1.commCoord, seg1.p)!
+    : chanSearch(mp.hchans, seg1.commCoord, seg1.p)!;
+  insertEdge(chan.G!, seg1.indNo!, seg2.indNo!);
+
+  for (let x = 1; x <= hops; x++) {
+    const prev1 = nextSeg(seg1, dir1)!;
+    const prev2 = nextSeg(seg2, dir2)!;
+    const nchan = seg1.isVert
+      ? chanSearch(mp.hchans, prev1.commCoord, prev1.p)!
+      : chanSearch(mp.vchans, prev1.commCoord, prev1.p)!;
+    const commCoordMatchesP1 = prev1.commCoord === seg1.p.p1;
+    const lDir = commCoordMatchesP1 ? seg1.l1 : seg1.l2;
+    const target = seg1.isVert ? Bend.B_LEFT : Bend.B_UP;
+    const flip = speFlip(seg1.isVert, commCoordMatchesP1, lDir === target);
+    const edgeSeen = edgeExists(chan.G!, seg1.indNo!, seg2.indNo!);
+    if (edgeSeen === flip) insertEdge(nchan.G!, prev2.indNo!, prev1.indNo!);
+    else insertEdge(nchan.G!, prev1.indNo!, prev2.indNo!);
+
+    chan = nchan;
+    seg1 = prev1; // eslint-disable-line no-param-reassign
+    seg2 = prev2; // eslint-disable-line no-param-reassign
+  }
+}
+
+/** @see lib/ortho/ortho.c:removeEdge */
+function removeEdgeParallel(
+  seg1: OrthoSegment, seg2: OrthoSegment, dir: number, mp: Maze,
+): void {
+  let ptr1 = seg1;
+  let ptr2 = seg2;
+  while (isParallel(ptr1, ptr2)) {
+    ptr1 = nextSeg(ptr1, 1)!;
+    ptr2 = nextSeg(ptr2, dir)!;
+  }
+  const chan = ptr1.isVert
+    ? chanSearch(mp.vchans, ptr1.commCoord, ptr1.p)!
+    : chanSearch(mp.hchans, ptr1.commCoord, ptr1.p)!;
+  removeRedge(chan.G!, ptr1.indNo!, ptr2.indNo!);
+}
+
+/**
+ * Which of `prev`'s two segments to walk (0 : decrease, 1 : increase) when
+ * resolving segment `i` vs `j` — the inline "get_directions" comment block at
+ * the top of `addPEdges`.
+ * @see lib/ortho/ortho.c:918
+ */
+function getDirections(segI: OrthoSegment, segJ: OrthoSegment): number {
+  if (segI.prev === null) return segJ.prev === null ? 0 : 1;
+  if (segJ.prev === null) return 1;
+  return segI.prev.commCoord === segJ.prev.commCoord ? 0 : 1;
+}
+
+/**
+ * Dispatch on the two deciding-point precedences (`prec1`/`prec2`, each in
+ * {-1,0,1} using the `seg_cmp` sign convention) to add or remove the
+ * constraint edges for one parallel segment pair.
+ * @see lib/ortho/ortho.c:963-989 (the `if (prec1 == ...)` chain in addPEdges)
+ */
+function resolveParallelPrecedence(
+  prec1: number, prec2: number, segI: OrthoSegment, segJ: OrthoSegment,
+  dir: number, hopsA: number, hopsB: number, mp: Maze,
+): void {
+  if (prec1 === -1) {
+    setParallelEdges(segJ, segI, dir, 0, hopsA, mp);
+    setParallelEdges(segJ, segI, 1 - dir, 1, hopsB, mp);
+    if (prec2 === 1) removeEdgeParallel(segI, segJ, 1 - dir, mp);
+  } else if (prec1 === 0) {
+    if (prec2 === -1) {
+      setParallelEdges(segJ, segI, dir, 0, hopsA, mp);
+      setParallelEdges(segJ, segI, 1 - dir, 1, hopsB, mp);
+    } else if (prec2 === 0) {
+      setParallelEdges(segI, segJ, 0, dir, hopsA, mp);
+      setParallelEdges(segI, segJ, 1, 1 - dir, hopsB, mp);
+    } else if (prec2 === 1) {
+      setParallelEdges(segI, segJ, 0, dir, hopsA, mp);
+      setParallelEdges(segI, segJ, 1, 1 - dir, hopsB, mp);
+    }
+  } else if (prec1 === 1) {
+    setParallelEdges(segI, segJ, 0, dir, hopsA, mp);
+    setParallelEdges(segI, segJ, 1, 1 - dir, hopsB, mp);
+    if (prec2 === -1) removeEdgeParallel(segI, segJ, 1 - dir, mp);
+  }
+}
+
+/** @see lib/ortho/ortho.c:addPEdges */
+function addPEdges(cp: Channel, mp: Maze): number {
+  const G = cp.G!;
+  const segs = cp.segList;
+  for (let i = 0; i + 1 < segs.length; i++) {
+    for (let j = i + 1; j < segs.length; j++) {
+      if (!edgeExists(G, i, j) && !edgeExists(G, j, i)) {
+        if (isParallel(segs[i], segs[j])) {
+          const dir = getDirections(segs[i], segs[j]);
+
+          const p = { a: 0, b: 0 };
+          if (decidePoint(p, segs[i], segs[j], 0, dir) !== 0) return -1;
+          const hopsA = p.a;
+          const prec1 = p.b;
+          if (decidePoint(p, segs[i], segs[j], 1, 1 - dir) !== 0) return -1;
+          const hopsB = p.a;
+          const prec2 = p.b;
+
+          resolveParallelPrecedence(prec1, prec2, segs[i], segs[j], dir, hopsA, hopsB, mp);
+        }
+      }
+    }
+  }
+  return 0;
+}
+
+/** @see lib/ortho/ortho.c:add_p_edges */
+export function addPEdgesAll(chans: ChanDict, mp: Maze): number {
+  // C walks the Dtoset channel dicts via dtflatten = sorted order; addPEdges
+  // inserts edges into OTHER channels' graphs and skips already-connected
+  // pairs, so this iteration order is load-bearing (corpus 1447_1 osage).
+  for (const [, cp] of chansInOrder(chans)) {
+    if (addPEdges(cp, mp) !== 0) return -1;
+  }
+  return 0;
+}

package/src/ortho/ortho-route.ts

@@ -0,0 +1,349 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Orthogonal edge routing pipeline — track assignment, segment comparison,
+ * and route conversion.
+ *
+ * Faithful port of the non-trivial helpers in lib/ortho/ortho.c.
+ *
+ * @see lib/ortho/ortho.c
+ */
+
+import type {
+  OrthoSegment, Route, Cell, SGraph, SNode, SEdge,
+  Channel, ChanDict, Maze,
+} from "./types.js";
+import { Bend, M_LEFT, M_RIGHT, M_TOP, M_BOTTOM } from "./types.js";
+import { chanSearch, chansInOrder } from "./maze-channels.js";
+import { makeGraph } from "./rawgraph.js";
+import { insertEdge, edgeExists, removeRedge, topSort } from "./rawgraph.js";
+import { updateWts } from "./maze.js";
+import { addPEdgesAll } from "./ortho-parallel.js";
+import { cround } from "../common/arith.js";
+
+// ─── weight constants ─────────────────────────────────────────────────────────
+
+const delta = 1;   // weight per unit length
+const mu = 500;    // bend penalty per bend edge
+export const BIG = 16384;  // near-infinite weight
+
+// ─── Segment construction ─────────────────────────────────────────────────────
+
+/** @see lib/ortho/ortho.c:setSeg */
+export function setSeg(
+  dir: boolean,
+  fix: number,
+  b1: number,
+  b2: number,
+  l1: Bend,
+  l2: Bend,
+): OrthoSegment {
+  const sp: OrthoSegment = {
+    isVert: dir, commCoord: fix,
+    p: b1 < b2 ? { p1: b1, p2: b2 } : { p1: b2, p2: b1 },
+    l1: b1 < b2 ? l1 : l2,
+    l2: b1 < b2 ? l2 : l1,
+    indNo: null, trackNo: null, prev: null, next: null,
+  };
+  return sp;
+}
+
+// ─── Route conversion ─────────────────────────────────────────────────────────
+
+function midPt(cp: Cell): { x: number; y: number } {
+  return {
+    x: (cp.bb.LL.x + cp.bb.UR.x) / 2,
+    y: (cp.bb.LL.y + cp.bb.UR.y) / 2,
+  };
+}
+
+function sidePt(ptr: SNode, cp: Cell): { x: number; y: number } {
+  const mid = (a: number, b: number) => (a + b) / 2;
+  if (cp === ptr.cells[1]) {
+    return ptr.isVert
+      ? { x: cp.bb.LL.x, y: mid(cp.bb.LL.y, cp.bb.UR.y) }
+      : { x: mid(cp.bb.LL.x, cp.bb.UR.x), y: cp.bb.LL.y };
+  }
+  return ptr.isVert
+    ? { x: cp.bb.UR.x, y: mid(cp.bb.LL.y, cp.bb.UR.y) }
+    : { x: mid(cp.bb.LL.x, cp.bb.UR.x), y: cp.bb.UR.y };
+}
+
+function cellOf(p: SNode, q: SNode): Cell {
+  const cp = p.cells[0];
+  if (cp === q.cells[0] || cp === q.cells[1]) return cp as Cell;
+  return p.cells[1] as Cell;
+}
+
+function isNodeCell(cp: Cell): boolean {
+  return (cp.flags & 1) !== 0; // MZ_ISNODE = 1
+}
+
+/**
+ * Convert a shortest-path result to a sequence of routing segments.
+ * @see lib/ortho/ortho.c:convertSPtoRoute
+ */
+export function convertSPtoRoute(
+  g: SGraph,
+  fst: SNode,
+  lst: SNode,
+): Route {
+  const segs: OrthoSegment[] = [];
+  let ptr = fst.nDad as SNode;
+  let prev: SNode = ptr;
+  let next = ptr.nDad as SNode;
+  let cp = isNodeCell(ptr.cells[0] as Cell) ? ptr.cells[1] as Cell : ptr.cells[0] as Cell;
+  let bp1 = sidePt(ptr, cp);
+  let prevbp = { x: 0, y: 0 };
+
+  while (next.nDad !== null) {
+    const ncp = cellOf(prev, next);
+    updateWts(g, ncp, ptr.nEdge as SEdge);
+
+    if (ptr.isVert !== next.isVert || next.nDad === lst) {
+      const bp2 = ptr.isVert !== next.isVert ? midPt(ncp) : sidePt(next, ncp);
+      const seg = buildSeg(ptr, next, cp, ncp, bp1, prevbp, segs.length === 0, lst);
+      segs.push(seg);
+
+      // C advances cp/prevbp/bp1 BEFORE the bend-at-end extra segment
+      // (ortho.c:182-184), so that segment's channel is the bend cell
+      // (cp == ncp) and its direction bendpoints are the shifted pair.
+      // Calling with the stale values put the final segment in the
+      // pre-bend channel — corpus 2183 m->e rendered a dangling end 63pt
+      // from its head. @see lib/ortho/ortho.c:180-203
+      cp = ncp; prevbp = bp1; bp1 = bp2;
+      if (ptr.isVert !== next.isVert && next.nDad === lst) {
+        segs.push(buildLastSeg(next, cp, ncp, bp1, prevbp));
+      }
+      ptr = next;
+    }
+    prev = next;
+    next = next.nDad as SNode;
+  }
+
+  for (let i = 0; i < segs.length; i++) {
+    if (i > 0) segs[i].prev = segs[i - 1];
+    if (i < segs.length - 1) segs[i].next = segs[i + 1];
+  }
+  return { segs };
+}
+
+function buildSeg(
+  ptr: SNode, next: SNode, cp: Cell, ncp: Cell,
+  bp1: { x: number; y: number }, prevbp: { x: number; y: number },
+  isFirst: boolean, lst: SNode,
+): OrthoSegment {
+  let l1: Bend; let l2: Bend;
+  let fix: number; let b1: number; let b2: number;
+
+  if (ptr.isVert) {
+    l1 = isFirst ? Bend.B_NODE : prevbp.y > bp1.y ? Bend.B_UP : Bend.B_DOWN;
+    if (ptr.isVert !== next.isVert) l2 = next.cells[0] === ncp ? Bend.B_UP : Bend.B_DOWN;
+    else l2 = Bend.B_NODE;
+    fix = cp.bb.LL.y; b1 = cp.bb.LL.x; b2 = ncp.bb.LL.x;
+  } else {
+    l1 = isFirst ? Bend.B_NODE : prevbp.x > bp1.x ? Bend.B_RIGHT : Bend.B_LEFT;
+    if (ptr.isVert !== next.isVert) l2 = next.cells[0] === ncp ? Bend.B_RIGHT : Bend.B_LEFT;
+    else l2 = Bend.B_NODE;
+    fix = cp.bb.LL.x; b1 = cp.bb.LL.y; b2 = ncp.bb.LL.y;
+  }
+  return setSeg(!ptr.isVert, fix, b1, b2, l1, l2);
+}
+
+function buildLastSeg(
+  next: SNode, cp: Cell, ncp: Cell,
+  bp1: { x: number; y: number }, prevbp: { x: number; y: number },
+): OrthoSegment {
+  let l1: Bend; let fix: number; let b1: number; let b2: number;
+  const l2 = Bend.B_NODE;
+  if (next.isVert) {
+    l1 = prevbp.y > bp1.y ? Bend.B_UP : Bend.B_DOWN;
+    fix = cp.bb.LL.y; b1 = cp.bb.LL.x; b2 = ncp.bb.LL.x;
+  } else {
+    l1 = prevbp.x > bp1.x ? Bend.B_RIGHT : Bend.B_LEFT;
+    fix = cp.bb.LL.x; b1 = cp.bb.LL.y; b2 = ncp.bb.LL.y;
+  }
+  return setSeg(!next.isVert, fix, b1, b2, l1, l2);
+}
+
+// ─── assignSegs ──────────────────────────────────────────────────────────────
+
+/** @see lib/ortho/ortho.c:insertChan */
+function insertChan(chan: Channel, seg: OrthoSegment): void {
+  seg.indNo = chan.segList.length;
+  chan.segList.push(seg);
+}
+
+/** @see lib/ortho/ortho.c:assignSegs */
+export function assignSegs(
+  routes: Route[],
+  mp: Maze,
+): void {
+  for (const rte of routes) {
+    for (const seg of rte.segs) {
+      const chans = seg.isVert ? mp.vchans : mp.hchans;
+      const chan = chanSearch(chans, seg.commCoord, seg.p);
+      if (chan) insertChan(chan, seg);
+    }
+  }
+}
+
+// ─── Track assignment ─────────────────────────────────────────────────────────
+
+/** @see lib/ortho/ortho.c:vtrack */
+export function vtrack(seg: OrthoSegment, mp: Maze): number {
+  const chp = chanSearch(mp.vchans, seg.commCoord, seg.p);
+  if (!chp) return seg.commCoord;
+  const f = (seg.trackNo ?? 1) / (chp.segList.length + 1);
+  return chp.cp!.bb.LL.x + f * (chp.cp!.bb.UR.x - chp.cp!.bb.LL.x);
+}
+
+/** @see lib/ortho/ortho.c:htrack */
+export function htrack(seg: OrthoSegment, mp: Maze): number {
+  const chp = chanSearch(mp.hchans, seg.commCoord, seg.p);
+  if (!chp) return seg.commCoord;
+  const f = 1.0 - (seg.trackNo ?? 1) / (chp.segList.length + 1);
+  const lo = chp.cp!.bb.LL.y;
+  const hi = chp.cp!.bb.UR.y;
+  // C htrack uses libm round() (half away from zero), NOT Math.round (half
+  // toward +inf). The maze routes in a frame whose bottom/left gutter cells sit
+  // at negative coordinates (LL.y as low as -36), so an evenly-spaced track can
+  // land on an exact negative half-integer (e.g. -4.5): C round(-4.5) = -5 but
+  // Math.round(-4.5) = -4, shifting the whole horizontal segment +1 after the
+  // final origin translate. @see lib/ortho/ortho.c:1065 (htrack round)
+  return cround(lo + f * (hi - lo));
+}
+
+// ─── seg_cmp and helpers ──────────────────────────────────────────────────────
+
+function eqEndSeg(s1l2: Bend, s2l2: Bend, t1: Bend, t2: Bend): number {
+  if ((s1l2 === t2 && s2l2 !== t2) || (s1l2 === Bend.B_NODE && s2l2 === t1)) return 0;
+  return -1;
+}
+
+function overlapSeg(s1: OrthoSegment, s2: OrthoSegment, t1: Bend, t2: Bend): number {
+  if (s1.p.p2 < s2.p.p2) {
+    if (s1.l2 === t1 && s2.l1 === t2) return -1;
+    if (s1.l2 === t2 && s2.l1 === t1) return 1;
+    return 0;
+  }
+  if (s1.p.p2 > s2.p.p2) {
+    if (s2.l1 === t2 && s2.l2 === t2) return -1;
+    if (s2.l1 === t1 && s2.l2 === t1) return 1;
+    return 0;
+  }
+  if (s2.l1 === t2) return eqEndSeg(s1.l2, s2.l2, t1, t2);
+  return -1 * eqEndSeg(s2.l2, s1.l2, t1, t2);
+}
+
+function ellSeg(s1l1: Bend, s1l2: Bend, t: Bend): number {
+  if (s1l1 === t) return s1l2 === t ? -1 : 0;
+  return 1;
+}
+
+function segCmpEqualP1(s1: OrthoSegment, s2: OrthoSegment, t1: Bend, t2: Bend): number {
+  if (s1.p.p2 < s2.p.p2) {
+    return s1.l2 === t1 ? eqEndSeg(s2.l1, s1.l1, t1, t2) : -1 * eqEndSeg(s2.l1, s1.l1, t1, t2);
+  }
+  if (s1.p.p2 > s2.p.p2) {
+    return s2.l2 === t2 ? eqEndSeg(s1.l1, s2.l1, t1, t2) : -1 * eqEndSeg(s1.l1, s2.l1, t1, t2);
+  }
+  return segCmpSameEnds(s1, s2, t1, t2);
+}
+
+function segCmpSameEnds(s1: OrthoSegment, s2: OrthoSegment, t1: Bend, t2: Bend): number {
+  if (s1.l1 === s2.l1 && s1.l2 === s2.l2) return 0;
+  if (s2.l1 === s2.l2) {
+    if (s2.l1 === t1) return 1;
+    if (s2.l1 === t2) return -1;
+    if (s1.l1 !== t1 && s1.l2 !== t1) return 1;
+    if (s1.l1 !== t2 && s1.l2 !== t2) return -1;
+    return 0;
+  }
+  if (s2.l1 === t1 && s2.l2 === t2) {
+    if (s1.l1 !== t1 && s1.l2 === t2) return 1;
+    if (s1.l1 === t1 && s1.l2 !== t2) return -1;
+    return 0;
+  }
+  if (s2.l2 === t1 && s2.l1 === t2) {
+    if (s1.l2 !== t1 && s1.l1 === t2) return 1;
+    if (s1.l2 === t1 && s1.l1 !== t2) return -1;
+    return 0;
+  }
+  if (s2.l1 === Bend.B_NODE && s2.l2 === t1) return ellSeg(s1.l1, s1.l2, t1);
+  if (s2.l1 === Bend.B_NODE && s2.l2 === t2) return -1 * ellSeg(s1.l1, s1.l2, t2);
+  if (s2.l1 === t1 && s2.l2 === Bend.B_NODE) return ellSeg(s1.l2, s1.l1, t1);
+  return -1 * ellSeg(s1.l2, s1.l1, t2);
+}
+
+function segCmpInner(s1: OrthoSegment, s2: OrthoSegment, t1: Bend, t2: Bend): number {
+  if (s1.p.p2 < s2.p.p1 || s1.p.p1 > s2.p.p2) return 0;
+  if (s1.p.p1 < s2.p.p1 && s2.p.p1 < s1.p.p2) return overlapSeg(s1, s2, t1, t2);
+  if (s2.p.p1 < s1.p.p1 && s1.p.p1 < s2.p.p2) return -1 * overlapSeg(s2, s1, t1, t2);
+  if (s1.p.p1 === s2.p.p1) return segCmpEqualP1(s1, s2, t1, t2);
+  if (s1.p.p2 === s2.p.p1) { if (s1.l2 === s2.l1) return 0; return s1.l2 === t2 ? 1 : -1; }
+  if (s1.l1 === s2.l2) return 0;
+  return s1.l1 === t2 ? 1 : -1;
+}
+
+/** @see lib/ortho/ortho.c:seg_cmp */
+export function segCmp(s1: OrthoSegment, s2: OrthoSegment): number {
+  if (s1.isVert !== s2.isVert || s1.commCoord !== s2.commCoord) return -2;
+  return s1.isVert
+    ? segCmpInner(s1, s2, Bend.B_RIGHT, Bend.B_LEFT)
+    : segCmpInner(s1, s2, Bend.B_DOWN, Bend.B_UP);
+}
+
+// ─── Graph edge management for channels ───────────────────────────────────────
+
+function addEdgesInG(cp: Channel): number {
+  const size = cp.segList.length;
+  const G = cp.G!;
+  for (let x = 0; x + 1 < size; x++) {
+    for (let y = x + 1; y < size; y++) {
+      const cmp = segCmp(cp.segList[x], cp.segList[y]);
+      if (cmp === -2) return -1;
+      if (cmp > 0) insertEdge(G, x, y);
+      else if (cmp === -1) insertEdge(G, y, x);
+    }
+  }
+  return 0;
+}
+
+function addNpEdges(chans: ChanDict): number {
+  for (const [, cp] of chansInOrder(chans)) {
+    if (cp.segList.length > 0 && addEdgesInG(cp) !== 0) return -1;
+  }
+  return 0;
+}
+
+function createGraphs(chans: ChanDict): void {
+  for (const [, cp] of chansInOrder(chans)) {
+    cp.G = makeGraph(cp.segList.length);
+  }
+}
+
+function assignTrackNo(chans: ChanDict): void {
+  for (const [, cp] of chansInOrder(chans)) {
+    if (cp.segList.length > 0 && cp.G) {
+      topSort(cp.G);
+      for (let k = 0; k < cp.segList.length; k++) {
+        cp.segList[k].trackNo = cp.G.vertices[k].topsortOrder + 1;
+      }
+    }
+  }
+}
+
+/** @see lib/ortho/ortho.c:assignTracks */
+export function assignTracks(mp: Maze): number {
+  createGraphs(mp.hchans);
+  createGraphs(mp.vchans);
+  if (addNpEdges(mp.hchans) !== 0) return -1;
+  if (addNpEdges(mp.vchans) !== 0) return -1;
+  if (addPEdgesAll(mp.hchans, mp) !== 0) return -1;
+  if (addPEdgesAll(mp.vchans, mp) !== 0) return -1;
+  assignTrackNo(mp.hchans);
+  assignTrackNo(mp.vchans);
+  return 0;
+}
+
+export { insertEdge, edgeExists, removeRedge };