@knowvah/dot-engine 0.1.0

package/src/model/rankEntry.ts

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * RankEntry and RankTable — one rank in a dot-layout ranked graph.
+ * Ported from lib/common/types.h:rank_t.
+ *
+ * @see lib/common/types.h:rank_t
+ */
+
+import type { Node } from './node.js';
+
+// ---------------------------------------------------------------------------
+// AdjMatrix — @see lib/dotgen/mincross.c:adjmatrix_t
+// ---------------------------------------------------------------------------
+
+/**
+ * Bit-packed flat-edge adjacency matrix for one rank.
+ * Bit (r,c) = data[(r*ncols+c)>>3] >> ((r*ncols+c)&7) & 1.
+ * Dynamically expands on matrixSet.
+ * @see lib/dotgen/mincross.c:adjmatrix_t
+ */
+export interface AdjMatrix {
+  nrows: number;
+  ncols: number;
+  data: Uint8Array;
+}
+
+// ---------------------------------------------------------------------------
+// rank_t — @see lib/common/types.h:rank_t
+// ---------------------------------------------------------------------------
+
+/**
+ * One rank in a dot-layout ranked graph.
+ *
+ * @see lib/common/types.h:rank_t
+ */
+export interface RankEntry {
+  /** Number of nodes in this rank. @see lib/common/types.h:rank_t.n */
+  n: number;
+  /** Ordered list of nodes in rank. @see lib/common/types.h:rank_t.v */
+  v: Node[];
+  /**
+   * Globally allocated number of nodes.
+   * @see lib/common/types.h:rank_t.an
+   */
+  an: number;
+  /** Allocated list of nodes in rank. @see lib/common/types.h:rank_t.av */
+  av: Node[];
+  /** Height below centerline. @see lib/common/types.h:rank_t.ht1 */
+  ht1: number;
+  /** Height above centerline. @see lib/common/types.h:rank_t.ht2 */
+  ht2: number;
+  /**
+   * Height below centerline (primitive nodes only).
+   * @see lib/common/types.h:rank_t.pht1
+   */
+  pht1: number;
+  /**
+   * Height above centerline (primitive nodes only).
+   * @see lib/common/types.h:rank_t.pht2
+   */
+  pht2: number;
+  /** For transpose(). @see lib/common/types.h:rank_t.candidate */
+  candidate: boolean;
+  /** Whether rank is valid. @see lib/common/types.h:rank_t.valid */
+  valid: boolean;
+  /**
+   * Cached crossing count.
+   * C type is int64_t; JS number is safe up to 2^53.
+   * @see lib/common/types.h:rank_t.cache_nc
+   */
+  cache_nc: number;
+
+  /**
+   * Flat-edge adjacency matrix for cycle-breaking. Allocated per-rank by
+   * flatBreakcycles when any flat edges exist; freed in cleanup2.
+   * @see lib/dotgen/mincross.c:GD_rank(g)[r].flat
+   */
+  flat?: AdjMatrix;
+
+  /**
+   * Offset into av[] for the current connected component's slice.
+   * Simulates C pointer arithmetic: C's `rank[r].v = rank[r].av + offset`
+   * becomes TypeScript's `vStart`.
+   * @see lib/dotgen/mincross.c:init_mccomp
+   */
+  vStart?: number;
+}
+
+/**
+ * Array of rank entries for a ranked (dot) graph layout.
+ *
+ * @see lib/common/types.h:rank_t
+ */
+export type RankTable = RankEntry[];

package/src/ortho/chan-dict.ts

@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * C-exact cdt Dtoset for the ortho channel dictionaries.
+ *
+ * The ortho maze keeps its channels in two-level cdt Dtoset splay trees and
+ * walks them with `dtflatten` + `dtlink` (following raw `->right` pointers).
+ * Crucially, `add_p_edges` calls `chanSearch` (a `dtmatch`) WHILE walking the
+ * flattened dicts: the first search UNFLATTENs the dict (the sorted right-
+ * spine chain simply becomes the tree again) and every search top-down-splays
+ * the tree, rewriting the very `->right` pointers the walker is following.
+ * The walk therefore silently skips every channel that a splay rotation moves
+ * into a left subtree — under 1447_1/osage C visits only 157 of 294 channels
+ * in the parallel pass. This behavior is deterministic and LOAD-BEARING: the
+ * final precedence graphs (and thus track assignments) depend on exactly
+ * which channels the corrupted walk reaches.
+ *
+ * The repo's generic DtSplay deliberately deviates from dttree.c in the
+ * not-found reassembly and insert attachment (documented in splay-core.ts),
+ * which changes tree SHAPE — harmless for its users, fatal here where shape
+ * drives the walk. Hence this separate byte-faithful implementation.
+ *
+ * Ports exactly:
+ *   - dttree.c do_search loop + found (has_root) and not-found (no_root)
+ *     reassembly, DT_MATCH and DT_INSERT flavours (DT_OSET only).
+ *   - dtflatten.c right-linearisation (RROTATE loop) + DT_FLATTEN flag.
+ *   - dthdr.h UNFLATTEN: any tree op clears the flag; for DT_OSET the
+ *     flattened chain IS a valid (degenerate) tree, so no restructuring.
+ *
+ * @see lib/cdt/dttree.c:dttree
+ * @see lib/cdt/dtflatten.c:dtflatten
+ * @see lib/cdt/dtrestore.c:dtrestore
+ * @see lib/ortho/ortho.c:chanSearch, assignTracks (dtflatten walks)
+ */
+
+/** Dtlink_t analogue. Walkers follow `.right` live, exactly like dtlink(). */
+export interface CdtNode<T> {
+  left: CdtNode<T> | null;
+  right: CdtNode<T> | null;
+  obj: T;
+}
+
+/** RROTATE(x,y): x.left = y.right; y.right = x. @see lib/cdt/dthdr.h */
+function rrotate<T>(x: CdtNode<T>, y: CdtNode<T>): void {
+  x.left = y.right;
+  y.right = x;
+}
+
+/** LROTATE(x,y): x.right = y.left; y.left = x. @see lib/cdt/dthdr.h */
+function lrotate<T>(x: CdtNode<T>, y: CdtNode<T>): void {
+  x.right = y.left;
+  y.left = x;
+}
+
+/**
+ * Ordered set (DT_OSET) with C-exact splay + flatten semantics.
+ * K is the search-key type; the comparator receives (searchKey, nodeKey).
+ */
+export class CdtOset<T, K> {
+  /** dt->data.here — current root (or flattened-list head). */
+  here: CdtNode<T> | null = null;
+  /** DT_FLATTEN flag. */
+  private flattened = false;
+
+  constructor(
+    private readonly keyOf: (obj: T) => K,
+    private readonly cmp: (a: K, b: K) => number,
+  ) {}
+
+  /** UNFLATTEN(dt): clear the flag. For DT_OSET dtrestore leaves `here`
+   *  pointing at the chain head — the right-spine chain IS the tree. */
+  private unflatten(): void {
+    this.flattened = false;
+  }
+
+  /**
+   * The dttree.c do_search loop. Returns the stopped-at node (`root` in C,
+   * null when the key fell off the tree) plus the partition state.
+   * link.right = LEFT partition head, link.left = RIGHT partition head
+   * (names inverted in C — preserved). l/r are the partition tails.
+   * @see lib/cdt/dttree.c:dttree (do_search)
+   */
+  private search(key: K): {
+    root: CdtNode<T> | null;
+    link: CdtNode<T>;
+    l: CdtNode<T>;
+    r: CdtNode<T>;
+  } {
+    const link: CdtNode<T> = { left: null, right: null, obj: undefined as T };
+    let l = link;
+    let r = link;
+    let root: CdtNode<T> | null = this.here;
+
+    while (root !== null) {
+      const cmp = this.cmp(key, this.keyOf(root.obj));
+      if (cmp === 0) break;
+      if (cmp < 0) {
+        const t: CdtNode<T> | null = root.left;
+        if (t !== null) {
+          const cmp2 = this.cmp(key, this.keyOf(t.obj));
+          if (cmp2 < 0) {
+            rrotate(root, t);
+            r.left = t; r = t; // rlink(r, t)
+            root = t.left;
+            if (root === null) break;
+          } else if (cmp2 === 0) {
+            r.left = root; r = root; // rlink(r, root)
+            root = t;
+            break;
+          } else {
+            l.right = t; l = t;      // llink(l, t)
+            r.left = root; r = root; // rlink(r, root)
+            root = t.right;
+            if (root === null) break;
+          }
+        } else {
+          r.left = root; r = root; // rlink(r, root)
+          root = null;
+          break;
+        }
+      } else {
+        const t: CdtNode<T> | null = root.right;
+        if (t !== null) {
+          const cmp2 = this.cmp(key, this.keyOf(t.obj));
+          if (cmp2 > 0) {
+            lrotate(root, t);
+            l.right = t; l = t; // llink(l, t)
+            root = t.right;
+            if (root === null) break;
+          } else if (cmp2 === 0) {
+            l.right = root; l = root; // llink(l, root)
+            root = t;
+            break;
+          } else {
+            r.left = t; r = t;       // rlink(r, t)
+            l.right = root; l = root; // llink(l, root)
+            root = t.left;
+            if (root === null) break;
+          }
+        } else {
+          l.right = root; l = root; // llink(l, root)
+          root = null;
+          break;
+        }
+      }
+    }
+    return { root, link, l, r };
+  }
+
+  /**
+   * dtmatch: search by key, splaying. Returns the object or null.
+   * Found: has_root reassembly. Not found: no_root reassembly.
+   * @see lib/cdt/dttree.c:dttree (DT_MATCH)
+   */
+  match(key: K): T | null {
+    this.unflatten();
+    if (this.here === null) return null;
+    const { root, link, l, r } = this.search(key);
+    if (root !== null) {
+      // found it, now isolate it (has_root)
+      l.right = root.left;
+      r.left = root.right;
+      root.left = link.right;
+      root.right = link.left;
+      this.here = root;
+      return root.obj;
+    }
+    // not found (no_root): r->left=NULL; l->right=NULL;
+    // then r->left = link.right (LEFT partition under RIGHT tail),
+    // here = link.left (RIGHT partition head).
+    r.left = null;
+    l.right = null;
+    r.left = link.right;
+    this.here = link.left;
+    return null;
+  }
+
+  /**
+   * dtinsert (DT_OSET): if an equal object exists, splay it to root and
+   * return IT (the caller must discard its own copy — C frees it). Otherwise
+   * the new node becomes root with the raw partitions as its subtrees.
+   * @see lib/cdt/dttree.c:dttree (DT_INSERT)
+   */
+  insert(obj: T): T {
+    this.unflatten();
+    if (this.here === null) {
+      this.here = { left: null, right: null, obj };
+      return obj;
+    }
+    const key = this.keyOf(obj);
+    const { root, link, l, r } = this.search(key);
+    if (root !== null) {
+      // duplicate: DT_OSET goto has_root — return the existing object.
+      l.right = root.left;
+      r.left = root.right;
+      root.left = link.right;
+      root.right = link.left;
+      this.here = root;
+      return root.obj;
+    }
+    // not found: close partitions, then dt_insert -> has_root with new node.
+    r.left = null;
+    l.right = null;
+    const node: CdtNode<T> = { left: link.right, right: link.left, obj };
+    this.here = node;
+    return obj;
+  }
+
+  /**
+   * dtflatten: right-linearise the tree into a sorted chain (returns head).
+   * Early-returns the existing chain when already flattened.
+   * @see lib/cdt/dtflatten.c:dtflatten
+   */
+  flatten(): CdtNode<T> | null {
+    if (this.flattened) return this.here;
+    let r = this.here;
+    let list: CdtNode<T> | null = null;
+    if (r !== null) {
+      let t: CdtNode<T> | null;
+      while ((t = r.left) !== null) rrotate(r, t), (r = t);
+      let last = r;
+      list = r;
+      for (r = r.right; r !== null; last = r, r = r.right) {
+        if ((t = r.left) !== null) {
+          do {
+            rrotate(r, t);
+            r = t;
+          } while ((t = r.left) !== null);
+          last.right = r;
+        }
+      }
+    }
+    this.here = list;
+    this.flattened = true;
+    return list;
+  }
+}

package/src/ortho/fpq.ts

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Max-heap priority queue for Dijkstra shortest path.
+ *
+ * Faithful port of lib/ortho/fPQ.c.
+ * Values stored NEGATED — larger negative = lower priority.
+ * The guard node at index 0 has nVal = 0, so upheap stops at root.
+ *
+ * @see lib/ortho/fPQ.c
+ * @see lib/ortho/fPQ.h
+ */
+
+import type { SNode } from "./types.js";
+
+/**
+ * Priority queue state.
+ * @see lib/ortho/fPQ.c:struct pq
+ */
+export interface Pq {
+  pq: (SNode | null)[];
+  cnt: number;
+  guard: SNode; // sentinel at index 0 (nVal = 0)
+  size: number;
+}
+
+/**
+ * Allocate a priority queue for up to sz nodes.
+ * @see lib/ortho/fPQ.c:PQgen
+ */
+export function pqGen(sz: number): Pq {
+  const guard: SNode = {
+    nVal: 0,
+    nIdx: 0,
+    nDad: null,
+    nEdge: null,
+    nAdj: 0,
+    saveNAdj: 0,
+    cells: [null, null],
+    adjEdgeList: [],
+    index: -1,
+    isVert: false,
+    x: 0,
+    y: 0,
+  };
+  const pq: (SNode | null)[] = new Array<SNode | null>(sz + 1).fill(null);
+  pq[0] = guard;
+  return { pq, cnt: 0, guard, size: sz };
+}
+
+/**
+ * Free the priority queue. (No-op in TS.)
+ * @see lib/ortho/fPQ.c:PQfree
+ */
+export function pqFree(_pq: Pq): void {
+  // GC handled
+}
+
+/**
+ * Reset the priority queue to empty.
+ * @see lib/ortho/fPQ.c:PQinit
+ */
+export function pqInit(pq: Pq): void {
+  pq.cnt = 0;
+}
+
+/** Move node at position k up the heap. @see lib/ortho/fPQ.c:PQupheap */
+function pqUpheap(pq: Pq, k: number): void {
+  const x = pq.pq[k] as SNode;
+  const v = x.nVal;
+  let pos = k;
+  let next = pos >> 1;
+  let n = pq.pq[next] as SNode;
+  while (n.nVal < v) {
+    pq.pq[pos] = n;
+    n.nIdx = pos;
+    pos = next;
+    next = pos >> 1;
+    n = pq.pq[next] as SNode;
+  }
+  pq.pq[pos] = x;
+  x.nIdx = pos;
+}
+
+/**
+ * Insert node np into the queue.
+ * Returns 1 on overflow, 0 on success.
+ * @see lib/ortho/fPQ.c:PQ_insert
+ */
+export function pqInsert(pq: Pq, np: SNode): number {
+  if (pq.cnt === pq.size) {
+    return 1; // heap overflow
+  }
+  pq.cnt++;
+  pq.pq[pq.cnt] = np;
+  pqUpheap(pq, pq.cnt);
+  return 0;
+}
+
+/** Move node at position k down the heap. @see lib/ortho/fPQ.c:PQdownheap */
+function pqDownheap(pq: Pq, k: number): void {
+  const x = pq.pq[k] as SNode;
+  const v = x.nVal;
+  const lim = pq.cnt >> 1;
+  let pos = k;
+  while (pos <= lim) {
+    let j = pos + pos;
+    let n = pq.pq[j] as SNode;
+    if (j < pq.cnt) {
+      const nj1 = pq.pq[j + 1] as SNode;
+      if (n.nVal < nj1.nVal) {
+        j++;
+        n = nj1;
+      }
+    }
+    if (v >= n.nVal) break;
+    pq.pq[pos] = n;
+    n.nIdx = pos;
+    pos = j;
+  }
+  pq.pq[pos] = x;
+  x.nIdx = pos;
+}
+
+/**
+ * Remove and return the node with the highest nVal (most-negative distance).
+ * Returns null when queue is empty.
+ * @see lib/ortho/fPQ.c:PQremove
+ */
+export function pqRemove(pq: Pq): SNode | null {
+  if (pq.cnt > 0) {
+    const n = pq.pq[1] as SNode;
+    pq.pq[1] = pq.pq[pq.cnt];
+    pq.cnt--;
+    if (pq.cnt > 0) {
+      pqDownheap(pq, 1);
+    }
+    return n;
+  }
+  return null;
+}
+
+/**
+ * Update the priority of node n to d and restore heap.
+ * @see lib/ortho/fPQ.c:PQupdate
+ */
+export function pqUpdate(pq: Pq, n: SNode, d: number): void {
+  n.nVal = d;
+  pqUpheap(pq, n.nIdx);
+}

package/src/ortho/index.ts

@@ -0,0 +1,206 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Public entry point for orthogonal edge routing.
+ *
+ * Faithful port of lib/ortho/ortho.c:orthoEdges.
+ *
+ * @see lib/ortho/ortho.c:orthoEdges
+ */
+
+import type {
+  OrthoGraph, OrthoEdge, OrthoNode, OrthoPoint,
+  Route,
+} from "./types.js";
+import type { ClipAndInstallFn } from "./types.js";
+import { mkMaze, freeMaze } from "./maze.js";
+import { extractHChans, extractVChans } from "./maze-channels.js";
+import {
+  shortPath, pqGenForGraph, pqFree,
+  addNodeEdges, addLoop, reset,
+} from "./sgraph.js";
+import { convertSPtoRoute, assignSegs, assignTracks, vtrack, htrack } from "./ortho-route.js";
+import { gvQsort } from "../util/bsd-qsort.js";
+
+export type { OrthoGraph, OrthoEdge, OrthoNode, OrthoPoint, ClipAndInstallFn };
+export { SEED } from "./partition.js";
+
+// ─── Edge length / sorting ────────────────────────────────────────────────────
+
+interface EdgePair {
+  e: OrthoEdge;
+  d: number;
+}
+
+/**
+ * Squared distance between the two endpoints' CENTERS — used only to order
+ * edges for routing. C uses `DIST2(ND_coord(tail), ND_coord(head))`, i.e. the
+ * node centres, NOT the bb corners: for nodes of differing width the corner-to-
+ * corner length reorders near-equal-length edges, and routing order drives maze
+ * channel occupancy (and thus corridor selection). Squared vs sqrt is immaterial
+ * to the ordering but kept squared to match C exactly.
+ *
+ * Read `coord` directly when the caller plumbed it (same fallback pattern as
+ * mkMaze's gcell derivation, maze.ts:267-268) rather than re-deriving the
+ * centre from `bb` — the bb round-trip ((c-lw)+(c+rw))/2 loses low bits versus
+ * C's raw ND_coord read and can flip a qsort tie-order on other graphs. Falls
+ * back to the bb centre only for port-less callers that don't model coord.
+ * @see lib/ortho/ortho.c:1124 (edgeLen)
+ */
+export function edgeLen(e: OrthoEdge): number {
+  const tcx = e.tail.coord ? e.tail.coord.x : (e.tail.bb.LL.x + e.tail.bb.UR.x) / 2;
+  const tcy = e.tail.coord ? e.tail.coord.y : (e.tail.bb.LL.y + e.tail.bb.UR.y) / 2;
+  const hcx = e.head.coord ? e.head.coord.x : (e.head.bb.LL.x + e.head.bb.UR.x) / 2;
+  const hcy = e.head.coord ? e.head.coord.y : (e.head.bb.LL.y + e.head.bb.UR.y) / 2;
+  const dx = tcx - hcx;
+  const dy = tcy - hcy;
+  return dx * dx + dy * dy;
+}
+
+function edgeCmp(a: EdgePair, b: EdgePair): number {
+  if (a.d < b.d) return -1;
+  if (a.d > b.d) return 1;
+  return 0;
+}
+
+// ─── Spline assembly ──────────────────────────────────────────────────────────
+
+function buildSpline(
+  e: OrthoEdge,
+  rte: Route,
+  mp: ReturnType<typeof mkMaze>,
+): OrthoPoint[] {
+  const pts: OrthoPoint[] = [];
+  if (rte.segs.length === 0) return pts;
+
+  // C: p1 = ND_coord(tail) + ED_tail_port(e).p, q1 = ND_coord(head) +
+  // ED_head_port(e).p (ortho.c:1075-1076). Callers that model ports plumb
+  // tailPoint/headPoint through OrthoEdge; a port-less edge (or a caller that
+  // does not model ports) has no offset, so fall back to the node's bb centre
+  // (= ND_coord for a port-less edge, since the port itself defaults to 0).
+  const p1 = e.tailPoint ?? {
+    x: (e.tail.bb.LL.x + e.tail.bb.UR.x) / 2,
+    y: (e.tail.bb.LL.y + e.tail.bb.UR.y) / 2,
+  };
+  const q1 = e.headPoint ?? {
+    x: (e.head.bb.LL.x + e.head.bb.UR.x) / 2,
+    y: (e.head.bb.LL.y + e.head.bb.UR.y) / 2,
+  };
+
+  let seg = rte.segs[0];
+  let p: OrthoPoint;
+  if (seg.isVert) {
+    p = { x: vtrack(seg, mp), y: p1.y };
+  } else {
+    p = { x: p1.x, y: htrack(seg, mp) };
+  }
+  pts.push({ ...p });
+  pts.push({ ...p });
+
+  for (let i = 1; i < rte.segs.length; i++) {
+    seg = rte.segs[i];
+    if (seg.isVert) p = { x: vtrack(seg, mp), y: p.y };
+    else p = { x: p.x, y: htrack(seg, mp) };
+    pts.push({ ...p });
+    pts.push({ ...p });
+    pts.push({ ...p });
+  }
+
+  if (seg.isVert) {
+    p = { x: vtrack(seg, mp), y: q1.y };
+  } else {
+    p = { x: q1.x, y: htrack(seg, mp) };
+  }
+  pts.push({ ...p });
+  pts.push({ ...p });
+
+  return pts;
+}
+
+// ─── orthoEdges ───────────────────────────────────────────────────────────────
+
+/**
+ * For edges without position information, construct an orthogonal routing.
+ * If useLbls is true, issues a warning and sets useLbls=false.
+ *
+ * @see lib/ortho/ortho.c:orthoEdges
+ */
+export function orthoEdges(
+  g: OrthoGraph,
+  useLbls: boolean,
+  clipAndInstall?: ClipAndInstallFn,
+): void {
+  if (useLbls) {
+    console.warn(
+      "Orthogonal edges do not currently handle edge labels. Try using xlabels.\n",
+    );
+    useLbls = false; // eslint-disable-line no-param-reassign
+  }
+  void useLbls; // suppress lint on intentional reassign
+
+  const mp = mkMaze(g);
+  const sg = mp.sg;
+
+  // collect and sort edges by length. C ortho.c sorts via qsort(edgecmp), which
+  // is UNSTABLE and returns 0 on equal length, so equal-length edges' routing
+  // order is qsort's, not insertion order. @see util/bsd-qsort.ts · ortho.c:1231
+  const es: EdgePair[] = g.edges.map((e) => ({ e, d: edgeLen(e) }));
+  gvQsort(es, edgeCmp);
+  const nEdges = es.length;
+
+  const routeList: Route[] = new Array(nEdges).fill(null).map(() => ({ segs: [] }));
+  const gstart = sg.nnodes;
+  const pq = pqGenForGraph(sg);
+  const sn = sg.nodes[gstart];
+  const dn = sg.nodes[gstart + 1];
+
+  // ensure the two dummy nodes exist
+  while (sg.nodes.length < gstart + 2) {
+    sg.nodes.push({
+      nVal: 0, nIdx: 0, nDad: null, nEdge: null,
+      nAdj: 0, saveNAdj: 0, cells: [null, null],
+      adjEdgeList: [], index: sg.nodes.length, isVert: false, x: 0, y: 0,
+    });
+  }
+
+  for (let i = 0; i < nEdges; i++) {
+    const e = es[i].e;
+    const start = mp.gcells[g.nodes.indexOf(e.tail)];
+    const dest = mp.gcells[g.nodes.indexOf(e.head)];
+
+    if (start === dest) {
+      addLoop(sg, start, dn, sn);
+    } else {
+      addNodeEdges(sg, dest, dn);
+      addNodeEdges(sg, start, sn);
+    }
+
+    if (shortPath(pq, sg, dn, sn) !== 0) {
+      pqFree(pq);
+      freeMaze(mp);
+      return;
+    }
+
+    routeList[i] = convertSPtoRoute(sg, sn, dn);
+    reset(sg);
+  }
+  pqFree(pq);
+
+  mp.hchans = extractHChans(mp);
+  mp.vchans = extractVChans(mp);
+  assignSegs(routeList, mp);
+  if (assignTracks(mp) !== 0) {
+    freeMaze(mp);
+    return;
+  }
+
+  if (clipAndInstall) {
+    for (let i = 0; i < nEdges; i++) {
+      const pts = buildSpline(es[i].e, routeList[i], mp);
+      if (pts.length > 0) {
+        clipAndInstall(g, es[i].e, pts, true);
+      }
+    }
+  }
+
+  freeMaze(mp);
+}