@mark1russell7/highways 0.6.0 → 0.8.0

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mark1russell7/layout-contract": "^0.2.7"
+    "@mark1russell7/layout-contract": "^0.2.8"
   },
   "devDependencies": {
     "@mark1russell7/cue": "github:mark1russell7/cue",

package/src/bench/screen/portfolio-pick.ts

@@ -1,5 +1,6 @@
 // The portfolio combinator (PORTFOLIO-API): `portfolio`, `selectBest` and `pickMoves` come from `@mark1russell7/layout-contract` 0.2.6 (PORTFOLIO-FIT).
-// The rules of the pick, the time limit and the trace are in `docs/PORTFOLIO.md` of the contract.
+// The option `hashes` of `PortfolioOptions` comes from the contract 0.2.8 (HASH-LAZY).
+// The rules of the pick, the time limit, the hashes and the trace are in `docs/PORTFOLIO.md` of the contract.
 export {
   pickMoves,
   portfolio,

package/src/compare.ts

@@ -0,0 +1,17 @@
+// The named comparators of the core (LANE-ORDER). `comparators.test.ts` checks that each one is a total order.
+// The package index does not export this module.
+
+/** This function compares two texts by their UTF-16 code units. It gives 0 only for equal texts. */
+export const byText = (a: string, b: string): number => (a < b ? -1 : a > b ? 1 : 0);
+
+/** An edge id with its hash. */
+export interface Hashed {
+  readonly h: number;
+  readonly e: { readonly id: string };
+}
+
+/** This function compares two edges by the hash of their ids, and then by their ids. Thus the order of two edges does not depend on the input. */
+export function byHash(a: Hashed, b: Hashed): number {
+  if (a.h !== b.h) return a.h - b.h;
+  return byText(a.e.id, b.e.id);
+}

package/src/lane-order.ts

@@ -0,0 +1,149 @@
+// The lane order of a run (LANE-ORDER): the relation of two lanes, and a total order from it. `orderLanes` of `segments.ts` uses this module.
+// The package index does not export this module.
+import { byText } from "./compare.ts";
+import { dist, type Point } from "./geom.ts";
+
+/** Two points nearer than this distance are the same point. The value is the same as in `segments.ts`. */
+const SAME = 1e-6;
+
+/** The place of a route on a run. The points go in the direction of the run. `s` and `e` are the indexes of the ends of the run. */
+export interface Placed {
+  readonly edge: string;
+  readonly p: readonly Point[];
+  readonly s: number;
+  readonly e: number;
+}
+
+/** The place where two routes part past one end of their common stretch, and the side of the first route there. */
+interface Parting {
+  /** The last common point. */
+  readonly at: Point;
+  /** This value is below 0 when the first route goes to the left of the second route. It is above 0 when it goes to the right. */
+  readonly side: number;
+}
+
+/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
+function turn(from: Point, base: Point, to: Point): number {
+  const dx = base.x - from.x;
+  const dy = base.y - from.y;
+  const vx = to.x - base.x;
+  const vy = to.y - base.y;
+  return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
+}
+
+/** This function gives the place where the routes `P` and `Q` part after the last point of the run, or nothing. */
+function partAfter(P: Placed, Q: Placed): Parting | undefined {
+  for (let j = 1; ; j++) {
+    const a = P.p[P.e + j];
+    const b = Q.p[Q.e + j];
+    if (a === undefined || b === undefined) return undefined;
+    if (dist(a, b) > SAME) {
+      const from = P.p[P.e + j - 2]!;
+      const at = P.p[P.e + j - 1]!;
+      const side = turn(from, at, a) - turn(from, at, b);
+      return side === 0 ? undefined : { at, side };
+    }
+  }
+}
+
+/** This function gives the place where the routes `P` and `Q` part before the first point of the run, or nothing. */
+function partBefore(P: Placed, Q: Placed): Parting | undefined {
+  for (let j = 1; ; j++) {
+    const a = P.p[P.s - j];
+    const b = Q.p[Q.s - j];
+    if (a === undefined || b === undefined) return undefined;
+    if (dist(a, b) > SAME) {
+      const from = P.p[P.s - j + 2]!;
+      const at = P.p[P.s - j + 1]!;
+      // Seen backward, the left side is the right side. Thus the order turns around.
+      const side = turn(from, at, b) - turn(from, at, a);
+      return side === 0 ? undefined : { at, side };
+    }
+  }
+}
+
+/** This function compares two placed routes by their edge ids. */
+export const byEdge = (P: Placed, Q: Placed): number => byText(P.edge, Q.edge);
+
+/** This function puts the point `a` before the point `b`: the smaller x first, then the smaller y. */
+const firstPoint = (a: Point, b: Point): boolean => a.x < b.x - SAME || (Math.abs(a.x - b.x) <= SAME && a.y < b.y);
+
+/**
+ * This function is the relation of the order `run`. The side after the run tells the order first, then the side before the run, then the edges.
+ * A value below 0 puts `P` before `Q`. The relation is not transitive: three lanes can make a cycle.
+ */
+export const byRun = (P: Placed, Q: Placed): number => partAfter(P, Q)?.side ?? partBefore(P, Q)?.side ?? byEdge(P, Q);
+
+/**
+ * This function is the relation of the order `bundle`. When the two ends disagree, the end with the smaller x, then the smaller y, tells the side.
+ * A value below 0 puts `P` before `Q`. The relation is not transitive: three lanes can make a cycle.
+ */
+export const byBundle = (P: Placed, Q: Placed): number => {
+  const after = partAfter(P, Q);
+  const before = partBefore(P, Q);
+  if (after && before && Math.sign(after.side) !== Math.sign(before.side)) return firstPoint(after.at, before.at) ? after.side : before.side;
+  return after?.side ?? before?.side ?? byEdge(P, Q);
+};
+
+/**
+ * This function sorts a list with a stable merge sort of the package, not with `Array.prototype.sort`.
+ * The pairs that it gives to `compare` depend only on the list and on the results of `compare`.
+ * Thus the result is the same on each JavaScript engine, also when `compare` is not a total order.
+ * A value of `compare(a, b)` above 0 puts `b` before `a`. Any other value (below 0, 0 or NaN) keeps `a` first.
+ */
+export function mergeSort<T>(list: readonly T[], compare: (a: T, b: T) => number): T[] {
+  if (list.length < 2) return [...list];
+  const mid = list.length >> 1;
+  const left = mergeSort(list.slice(0, mid), compare);
+  const right = mergeSort(list.slice(mid), compare);
+  const out: T[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length && j < right.length) {
+    if (compare(left[i]!, right[j]!) > 0) out.push(right[j++]!);
+    else out.push(left[i++]!);
+  }
+  while (i < left.length) out.push(left[i++]!);
+  while (j < right.length) out.push(right[j++]!);
+  return out;
+}
+
+/**
+ * This function gives true when the relation of `n` items has a cycle. For `i < j`, a value of `before(i, j)` above 0 puts `j` before `i`.
+ * Any other value puts `i` before `j`. The relation has no cycle when the counts of the items that each item comes before are all different.
+ */
+export function hasCycle(n: number, before: (i: number, j: number) => number): boolean {
+  const wins = new Int32Array(n);
+  for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) wins[before(i, j) > 0 ? j : i]!++;
+  const seen = new Uint8Array(n);
+  for (const w of wins) seen[w] = 1;
+  return seen.includes(0);
+}
+
+/**
+ * The function that `observeLanes` installs. It gets the lanes of each run in their start order, the relation, and the lane order.
+ * The measure scripts use it to compare the lane order with the sort of the engine.
+ */
+export type LaneObserver = <T>(start: readonly T[], compare: (a: T, b: T) => number, lanes: readonly T[]) => void;
+
+let observer: LaneObserver | undefined;
+
+/** This function installs an observer of the lane orders, or removes it with `undefined`. The measure scripts use it. The routes do not change. */
+export function observeLanes(fn: LaneObserver | undefined): void {
+  observer = fn;
+}
+
+/** This function gives the lane order of a run: the merge sort of `start` with the relation `compare`. It tells the observer of `observeLanes`. */
+export function orderRun<T>(start: readonly T[], compare: (a: T, b: T) => number): T[] {
+  const lanes = mergeSort(start, compare);
+  observer?.(start, compare, lanes);
+  return lanes;
+}
+
+/**
+ * This function gives the lane order of the placed routes of a run. `order` selects the relation.
+ * With `run`, the sort starts from the order of `placed`. With `bundle`, it starts from the order of the edges, so that each run sorts the same edges the same way.
+ */
+export function orderPlaced(placed: readonly Placed[], order: "run" | "bundle"): Placed[] {
+  return order === "run" ? orderRun(placed, byRun) : orderRun([...placed].sort(byEdge), byBundle);
+}

package/src/order/index.ts

@@ -1,14 +1,9 @@
 import { fnv1a32 } from "../bench/screen/hash.ts";
+import { byHash } from "../compare.ts";
 import { rng } from "../fixtures.ts";
-import type { Edge, Graph, Result, Router } from "../model.ts";
+import type { Graph, Result, Router } from "../model.ts";
 import { defineStrategy, type Strategy } from "../strategies/model.ts";
 
-/** This function compares two edges by the hash of their ids, and then by their ids. Thus the order of two edges does not depend on the input. */
-function byHash(a: { readonly h: number; readonly e: Edge }, b: { readonly h: number; readonly e: Edge }): number {
-  if (a.h !== b.h) return a.h - b.h;
-  return a.e.id < b.e.id ? -1 : a.e.id > b.e.id ? 1 : 0;
-}
-
 /**
  * This function gives the graph with its edges in the stable order of WILD-053: by the FNV-1a hash of the id, then by the id.
  * The nodes and the edges do not change. Two orders of the same edges give the same graph.

package/src/portfolio/fit.ts

@@ -1,41 +1,41 @@
 // This file is generated by `scripts/portfolio-sets.ts` (`pnpm portfolio:sets`). Do not edit it. The test `sets.test.ts` checks that it is current.
-// The times come from the CI run 40670252502 (the workflow `Portfolio`, `portfolio:time --members`).
+// The times come from the CI run 40681241949 (the workflow `Portfolio`, `portfolio:time --members`).
 import type { PortfolioCap, PortfolioRule } from "./bands.ts";
 
 /**
  * The fit of each rule, cap and size band, by the key `<rule>|<cap>|<band>`: the members of the default of the portfolio router, in their order.
- * Each member has a node limit: it runs only on an input with that many nodes or fewer. The limits keep the model time at or below 42 ms.
+ * Each member has a node limit: it runs only on an input with that many nodes or fewer. The limits keep the model time at or below 45 ms.
  * The base `shared` is not in a fit: the portfolio always runs it first.
  */
 export const PORTFOLIO_FIT: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly (readonly [string, number])[]>> = {
   "collection|1.1|n1-12": [["corners-side", 12], ["w2c:select+stretch", 12], ["trunks-gilbert-a05", 12], ["w3a:spiral-a15", 12], ["trunks-tree-bf08", 12], ["hw:zipper", 12], ["w2c:level-links+stretch-b1.1", 12], ["hw:stubs", 12]],
-  "collection|1.1|n13-24": [["w3e:crossbars+stretch", 24], ["trunks-tree-bf08", 24], ["corners-side", 24], ["shared-p2", 24], ["w2c:zipper+stretch-b1.1", 18]],
-  "collection|1.1|n25-40": [["w2a:shared-ways+breakeven", 40], ["w2b:weiszfeld-a1", 32]],
+  "collection|1.1|n13-24": [["w3e:crossbars+stretch", 24], ["trunks-tree-bf08", 24], ["corners-side", 24], ["shared-p2", 24], ["w2c:zipper+stretch-b1.1", 18], ["hw:weiszfeld", 18], ["trunks-gilbert-a07", 18]],
+  "collection|1.1|n25-40": [["w2a:shared-ways+breakeven", 40], ["w2b:weiszfeld-a1", 40]],
   "collection|1.1|n41-64": [],
   "collection|1.1|n65-128": [],
   "collection|1.25|n1-12": [["corners-side", 12], ["trunks-tree-bf06", 12], ["w3f:p-hub-a0.2", 12], ["hw:stubs", 12], ["hw:p-hub", 12], ["hw:spiral", 12], ["w2c:level-links+stretch", 12], ["w3f:spectral-c0.3", 12]],
-  "collection|1.25|n13-24": [["w2a:shared-ways+stretch", 24], ["shared-p3", 24], ["trunks-gilbert-a07", 24], ["w3e:crossbars+stretch", 24], ["trunks-tree-bf06", 24], ["w3c:hdbscan+stretch", 18], ["shared-wind-p2-r1-e2", 18]],
-  "collection|1.25|n25-40": [["w2a:shared-ways+stretch", 40], ["shared-p3", 40], ["shared-order-shortest", 32]],
+  "collection|1.25|n13-24": [["w2a:shared-ways+stretch", 24], ["shared-p3", 24], ["trunks-gilbert-a07", 24], ["w3e:crossbars+stretch", 24], ["trunks-tree-bf06", 24], ["w3c:hdbscan+stretch", 18], ["shared-wind-p2-r1-e2", 18], ["hw:stubs", 18]],
+  "collection|1.25|n25-40": [["w2a:shared-ways+stretch", 40], ["shared-p3", 40], ["shared-order-shortest", 40], ["w2b:weiszfeld-a1", 32]],
   "collection|1.25|n41-64": [],
   "collection|1.25|n65-128": [],
   "collection|1.5|n1-12": [["trunks-gilbert-a03", 12], ["w3e:areas-keys", 12], ["trunks-tree-bf02", 12], ["w3f:p-hub-a0.2", 12], ["w2b:zipper-a1", 12], ["w3a:spiral-a35", 12], ["w3f:spectral-c0.3", 12], ["w2c:level-links+stretch", 12]],
-  "collection|1.5|n13-24": [["shared-wind-p2-r0.5", 24], ["trunks-gilbert-a03", 24], ["w3e:crossbars+stretch", 24], ["shared-wind-p2-r1-e2", 24], ["trunks-tree-bf06", 24], ["shared-flow-a06-p3", 24], ["shared-wind-p3-r1", 18], ["trunks-gilbert-a07", 18]],
-  "collection|1.5|n25-40": [["shared-p3", 40], ["hw:lanes", 40], ["shared-wind-p2-r1-e2", 32]],
+  "collection|1.5|n13-24": [["shared-wind-p2-r0.5", 24], ["trunks-gilbert-a03", 24], ["w3e:crossbars+stretch", 24], ["shared-wind-p2-r1-e2", 24], ["trunks-tree-bf06", 24], ["shared-flow-a06-p3", 24], ["shared-wind-p3-r1", 24], ["trunks-gilbert-a07", 24]],
+  "collection|1.5|n25-40": [["shared-p3", 40], ["hw:lanes", 40], ["shared-wind-p2-r1-e2", 40], ["hw:crossbars", 32]],
   "collection|1.5|n41-64": [["shared-flow-a06-p3", 64]],
   "collection|1.5|n65-128": [],
-  "all|1.1|n1-12": [["w2b:zipper-p2", 12], ["hw:cubu", 12], ["w3d:kdeeb+stretch", 12], ["w3c:hough-wide", 12], ["w3d:kdeeb-routes", 12], ["hw:stubs", 10], ["hw:spiral", 10], ["w3b:growth-s0.7", 10]],
-  "all|1.1|n13-24": [["w3e:frechet-e0.5", 24], ["w3a:diffusion-wide", 24], ["w2c:zipper+stretch-b1.1", 24], ["w3d:cubu+stretch", 18]],
+  "all|1.1|n1-12": [["w2b:zipper-p2", 12], ["hw:cubu", 12], ["w3d:kdeeb+stretch", 12], ["w3c:hough-wide", 12], ["w3d:kdeeb-routes", 12], ["hw:stubs", 12], ["hw:spiral", 12], ["w3b:growth-s0.7", 10]],
+  "all|1.1|n13-24": [["w3e:frechet-e0.5", 24], ["w3a:diffusion-wide", 24], ["w2c:zipper+stretch-b1.1", 24], ["w3d:cubu+stretch", 18], ["w3a:spiral-a15", 18]],
   "all|1.1|n25-40": [["w2c:zipper+stretch-b1.1", 40], ["w3a:spiral-a15", 32]],
-  "all|1.1|n41-64": [],
+  "all|1.1|n41-64": [["hw:diffusion", 64]],
   "all|1.1|n65-128": [],
-  "all|1.25|n1-12": [["w3d:kdeeb-routes", 12], ["w3e:mlseb+stretch", 12], ["hw:growth", 12], ["hw:level-links", 10], ["w3b:growth-input", 10], ["w3e:confluent+stretch", 10]],
-  "all|1.25|n13-24": [["w3d:kdeeb-routes", 24], ["w3f:p-hub-a0.2", 18], ["w3d:kdeeb-nomask", 18]],
-  "all|1.25|n25-40": [],
+  "all|1.25|n1-12": [["w3d:kdeeb-routes", 12], ["w3e:mlseb+stretch", 12], ["hw:growth", 12], ["hw:level-links", 12], ["w3b:growth-input", 10], ["w3e:confluent+stretch", 10], ["w3d:kdeeb-nomask", 10]],
+  "all|1.25|n13-24": [["w3d:kdeeb-routes", 24], ["w3f:p-hub-a0.2", 24], ["w3d:kdeeb-nomask", 18], ["w3a:spiral-n3", 18]],
+  "all|1.25|n25-40": [["w3d:kdeeb-routes", 32]],
   "all|1.25|n41-64": [],
   "all|1.25|n65-128": [],
   "all|1.5|n1-12": [["w3b:growth-s0.3", 12], ["w3e:mlseb-a0", 12], ["w3e:mlseb-routes", 10], ["w3c:edge-paths-k1.5", 10], ["w3f:territories-r2", 10]],
   "all|1.5|n13-24": [["hw:growth", 24], ["w3b:growth-input", 24]],
-  "all|1.5|n25-40": [["hw:growth", 40], ["w3b:growth-s0.7", 40]],
+  "all|1.5|n25-40": [["hw:growth", 40], ["w3b:growth-s0.7", 40], ["w3b:growth-s0.3", 32]],
   "all|1.5|n41-64": [],
   "all|1.5|n65-128": [],
 };

package/src/portfolio/router.ts

@@ -30,8 +30,20 @@ export interface PortfolioRouterOptions {
   readonly maxMembers?: number;
   /** The clock in milliseconds. The default is `performance.now`. */
   readonly now?: () => number;
+  /**
+   * The members that get an output hash in the trace (HASH-LAZY). The pick does not use the hashes, so the winner and the output do not change.
+   * - With `pick` (the default), only the base and the winner get a hash, and only when the winner is not the base.
+   * - With `all`, each member that ran gets a hash, as before HASH-LAZY. Use it when you need the `outputHash` of each member.
+   */
+  readonly hashes?: PortfolioHashes;
 }
 
+/** The values of the option `hashes` of the portfolio router. */
+export type PortfolioHashes = "all" | "pick";
+
+/** The values of the option `hashes`, in order. The default is `pick`. */
+export const PORTFOLIO_HASHES: readonly PortfolioHashes[] = ["pick", "all"];
+
 /** The base member of each portfolio: the router `shared` with the rule `byCollection`. It is the fallback output above the cap. */
 export const PORTFOLIO_BASE_MEMBER = "shared";
 
@@ -49,14 +61,16 @@ export interface PortfolioRoute {
 }
 
 /** This function checks the options of the portfolio router, and gives them with their defaults. It throws a `RangeError` for a bad value. */
-function checked(o: PortfolioRouterOptions): { rule: PortfolioRule; cap: PortfolioCap; k: 3 | 5 | 8 | undefined } {
+function checked(o: PortfolioRouterOptions): { rule: PortfolioRule; cap: PortfolioCap; k: 3 | 5 | 8 | undefined; hashes: PortfolioHashes } {
   const rule = o.rule ?? "collection";
   const cap = o.cap ?? 1.5;
   const k = o.k;
+  const hashes = o.hashes ?? "pick";
   if (!PORTFOLIO_RULES.includes(rule)) throw new RangeError(`The portfolio router has the rule "${String(rule)}". It must be ${PORTFOLIO_RULES.join(" or ")}.`);
   if (!PORTFOLIO_CAPS.includes(cap)) throw new RangeError(`The portfolio router has the cap ${String(cap)}. It must be ${PORTFOLIO_CAPS.join(", ")}.`);
   if (k !== undefined && !PORTFOLIO_KS_API.includes(k)) throw new RangeError(`The portfolio router has the k ${String(k)}. It must be ${PORTFOLIO_KS_API.join(", ")}.`);
-  return { rule, cap, k };
+  if (!PORTFOLIO_HASHES.includes(hashes)) throw new RangeError(`The portfolio router has the hashes "${String(hashes)}". It must be ${PORTFOLIO_HASHES.join(" or ")}.`);
+  return { rule, cap, k, hashes };
 }
 
 /** This function gives the name of the portfolio router with the options `options`: `portfolio-<rule>-<cap>-k<k>`, or `portfolio-<rule>-<cap>-fit` without `k`. */
@@ -83,11 +97,12 @@ export function portfolioMembers(nodes: number, options: PortfolioRouterOptions
  * The key is `portfolioKey`: a member wins only when it passes the guard against the base. Of those members, the winner has the most ink saved.
  * A tie within the `minEffect` of B1 goes to the first member (`selectBest`). A member that throws does not win.
  * The result carries the trace of the pick and the move count `move.pick`.
+ * With the option `hashes` "pick" (the default), only the base and the winner get an `outputHash` in the trace. They get it only when the winner is not the base.
  */
 export function routePortfolio(graph: Graph, options: PortfolioRouterOptions = {}): PortfolioRoute {
   // A member with a node limit below the size of the graph does not run. The base `shared` has no such limit below the limit of the router.
   const names = portfolioMembers(graph.nodes.length, options).filter((name) => name === PORTFOLIO_BASE_MEMBER || (portfolioMember(name)?.maxNodes ?? Infinity) >= graph.nodes.length);
-  const { rule, cap } = checked(options);
+  const { rule, cap, hashes } = checked(options);
   // The key compares each member with the output of the base, so the run of the base keeps its output.
   let base: Result | undefined;
   const members: Member<Graph, Result>[] = names.map((name) => {
@@ -104,6 +119,7 @@ export function routePortfolio(graph: Graph, options: PortfolioRouterOptions = {
     };
   });
   const p = portfolio(portfolioName(options), members, portfolioKey(graph, rule, cap, () => base), {
+    hashes,
     ...(options.budgetMs === undefined ? {} : { budgetMs: options.budgetMs }),
     ...(options.maxMembers === undefined ? {} : { maxMembers: options.maxMembers }),
     ...(options.now === undefined ? {} : { now: options.now }),

package/src/routers/shared.ts

@@ -1,6 +1,8 @@
 import { center, dist, type Point } from "../geom.ts";
 import { nodeIndex, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { channelWidth } from "../channels.ts";
+import { orderRun } from "../lane-order.ts";
+import { byText } from "../compare.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { buildSections, type Section } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
@@ -85,8 +87,6 @@ interface Run {
   readonly ways: Way[];
 }
 
-const byText = (a: string, b: string): number => (a < b ? -1 : a > b ? 1 : 0);
-
 /** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
 function turn(from: Point, base: Point, to: Point): number {
   const dx = base.x - from.x;
@@ -376,5 +376,6 @@ function laneOrderOfRun(run: Run): string[] {
     }
     return byText(p.edge.id, q.edge.id);
   };
-  return [...run.ways].sort(compare).map((w) => w.edge.id);
+  // This relation is not transitive, so the merge sort of the package gives the same order on each engine (LANE-ORDER).
+  return orderRun(run.ways, compare).map((w) => w.edge.id);
 }

package/src/segments.ts

@@ -1,4 +1,5 @@
 import { dist, type Point } from "./geom.ts";
+import { orderPlaced, type Placed } from "./lane-order.ts";
 import type { Result, Route } from "./model.ts";
 
 /** A piece of drawn way. A shared segment carries several edges, in lane order. A private segment carries one edge. */
@@ -193,15 +194,6 @@ function lanePaths(graph: SegmentGraph, spacingOf: (s: Segment) => number): Rout
   return routes;
 }
 
-/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
-function turn(from: Point, base: Point, to: Point): number {
-  const dx = base.x - from.x;
-  const dy = base.y - from.y;
-  const vx = to.x - base.x;
-  const vy = to.y - base.y;
-  return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
-}
-
 /**
  * The lane order of the shared ways of a router.
  * With `bundle`, two edges keep one order on all the shared ways of their common stretch.
@@ -209,58 +201,6 @@ function turn(from: Point, base: Point, to: Point): number {
  */
 export type RunOrder = "bundle" | "run";
 
-/** The place of a route on a run. The points go in the direction of the run. `s` and `e` are the indexes of the ends of the run. */
-interface Placed {
-  readonly edge: string;
-  readonly p: readonly Point[];
-  readonly s: number;
-  readonly e: number;
-}
-
-/** The place where two routes part past one end of their common stretch, and the side of the first route there. */
-interface Parting {
-  /** The last common point. */
-  readonly at: Point;
-  /** This value is below 0 when the first route goes to the left of the second route. It is above 0 when it goes to the right. */
-  readonly side: number;
-}
-
-/** This function gives the place where the routes `P` and `Q` part after the last point of the run, or nothing. */
-function partAfter(P: Placed, Q: Placed): Parting | undefined {
-  for (let j = 1; ; j++) {
-    const a = P.p[P.e + j];
-    const b = Q.p[Q.e + j];
-    if (a === undefined || b === undefined) return undefined;
-    if (dist(a, b) > SAME) {
-      const from = P.p[P.e + j - 2]!;
-      const at = P.p[P.e + j - 1]!;
-      const side = turn(from, at, a) - turn(from, at, b);
-      return side === 0 ? undefined : { at, side };
-    }
-  }
-}
-
-/** This function gives the place where the routes `P` and `Q` part before the first point of the run, or nothing. */
-function partBefore(P: Placed, Q: Placed): Parting | undefined {
-  for (let j = 1; ; j++) {
-    const a = P.p[P.s - j];
-    const b = Q.p[Q.s - j];
-    if (a === undefined || b === undefined) return undefined;
-    if (dist(a, b) > SAME) {
-      const from = P.p[P.s - j + 2]!;
-      const at = P.p[P.s - j + 1]!;
-      // Seen backward, the left side is the right side. Thus the order turns around.
-      const side = turn(from, at, b) - turn(from, at, a);
-      return side === 0 ? undefined : { at, side };
-    }
-  }
-}
-
-const byEdge = (P: Placed, Q: Placed): number => (P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0);
-
-/** This function puts the point `a` before the point `b`: the smaller x first, then the smaller y. */
-const firstPoint = (a: Point, b: Point): boolean => a.x < b.x - SAME || (Math.abs(a.x - b.x) <= SAME && a.y < b.y);
-
 /**
  * This function gives the lane order of the edges on a shared way `run` (metro-line order).
  * The routes are polylines that hold the points of the run in a row, in either direction. A route that does not hold the run goes last.
@@ -271,6 +211,11 @@ const firstPoint = (a: Point, b: Point): boolean => a.x < b.x - SAME || (Math.ab
  * With the order `bundle`, two routes that part on one side at both ends keep that side.
  * When the two ends disagree, the two routes must cross. The end with the smaller x, then the smaller y, tells the side.
  * Thus each shared way of a common stretch gives two routes the same order, and the crossing is where they part.
+ *
+ * This relation of two lanes is not transitive, so three lanes can make a cycle. The sort of the engine then gives another order on another engine.
+ * Thus the function sorts with a merge sort of the package (LANE-ORDER). The order is the same on each JavaScript engine.
+ * On a run with no cycle, the order is the order of each correct sort, for each order of `routes`.
+ * On a run with a cycle, the order depends on the order of `routes`. The item LANE-STRETCH is to remove the cycles.
  */
 export function orderLanes(run: readonly Point[], routes: readonly Route[], order: RunOrder = "run"): string[] {
   const placed: Placed[] = [];
@@ -285,16 +230,6 @@ export function orderLanes(run: readonly Point[], routes: readonly Route[], orde
       else lost.push(r.edge);
     }
   }
-  if (order === "run") placed.sort((P, Q) => partAfter(P, Q)?.side ?? partBefore(P, Q)?.side ?? byEdge(P, Q));
-  else {
-    // The sort starts from the order of the edges, so that each run sorts the same edges the same way.
-    placed.sort(byEdge);
-    placed.sort((P, Q) => {
-      const after = partAfter(P, Q);
-      const before = partBefore(P, Q);
-      if (after && before && Math.sign(after.side) !== Math.sign(before.side)) return firstPoint(after.at, before.at) ? after.side : before.side;
-      return after?.side ?? before?.side ?? byEdge(P, Q);
-    });
-  }
-  return [...placed.map((x) => x.edge), ...lost.sort()];
+  const lanes = orderPlaced(placed, order);
+  return [...lanes.map((x) => x.edge), ...lost.sort()];
 }