@woosh/meep-engine 3.16.0 → 3.17.0

package/src/core/model/node-graph/visual/layout/RouteSearch.d.ts

@@ -68,13 +68,29 @@ export class RouteSearch {
      * @type {number}
      */
     path_length: number;
+    /**
+     * What the route just found costs, under the grid as it stood when it was found. This is the
+     * same number {@link cost_of} gives for it, and is what a route it replaces is compared with.
+     * @type {number}
+     */
+    cost: number;
+    /**
+     * States the last search took off the queue before it found the goal or gave up. What the
+     * search cost, for anybody tuning it.
+     * @type {number}
+     */
+    expansions: number;
     /**
      * Find a wire's way from one vertex to another.
      *
-     * The cost being minimised is length, plus a fixed price per turn, plus what the grid charges
-     * for lines other wires are already on. The estimate driving the search is the straight
-     * rectilinear distance remaining, which never exceeds what the route will actually cost — turns
-     * and congestion only ever add — so the first route found is the cheapest one.
+     * The cost being minimised is length, plus a fixed price per turn, plus a fixed price for every
+     * wire crossed, plus what the grid charges for lines other wires are already on. The estimate
+     * driving the search is the straight rectilinear distance remaining, which never exceeds what
+     * the route will actually cost — turns, crossings and congestion only ever add — so the first
+     * route found is the cheapest one.
+     *
+     * A crossing is charged where it happens: on going straight through a vertex, for every wire
+     * already going straight through it the other way. See {@link RouteGrid#through_h}.
      *
      * @param {number} start vertex
      * @param {number} start_axis the axis the wire is already travelling on as it arrives here,
@@ -82,9 +98,14 @@ export class RouteSearch {
      * @param {number} goal vertex
      * @param {number} goal_axis the axis the wire must be on to meet the port it is heading for
      * @param {NodeGraphLayoutOptions} options
+     * @param {boolean} [through_goal] whether arriving at the goal along its axis is going straight
+     *        through it. True at a port, where the wire carries on into its stub; false at a
+     *        waypoint the wire will leave by another search, which charges for the leaving.
+     * @param {number} [net] the net the wire belongs to, whose other wires it may share a line
+     *        with for nothing — see {@link RouteGrid#owner_h}. -1 for a wire of no net.
      * @returns {boolean} whether a route was found. The route is left in {@link path}.
      */
-    find(start: number, start_axis: number, goal: number, goal_axis: number, options: NodeGraphLayoutOptions): boolean;
+    find(start: number, start_axis: number, goal: number, goal_axis: number, options: NodeGraphLayoutOptions, through_goal?: boolean, net?: number): boolean;
     /**
      * @param {number} from state
      * @param {number} from_cost
@@ -93,6 +114,7 @@ export class RouteSearch {
      * @param {number} axis being moved along
      * @param {number} goal
      * @param {number} goal_axis
+     * @param {boolean} through_goal
      * @param {number} bend
      * @param {NodeGraphLayoutOptions} options
      * @param {number} step what the move itself costs
@@ -102,6 +124,29 @@ export class RouteSearch {
      * @private
      */
     private __relax;
+    /**
+     * What a route costs under the grid as it stands now.
+     *
+     * The same sum {@link find} minimises, added up along a route that already exists: length, a
+     * turn wherever the axis changes — counting the stubs at either end, which fix the axis the
+     * route starts and finishes on — a crossing wherever it goes straight through a vertex some
+     * other wire goes straight through the other way, and the grid's charge for every line it
+     * shares. The route's own occupancy must have been taken off the grid first, or it is charged
+     * for sharing lines with itself.
+     *
+     * Kept exactly in step with {@link find}, because it exists to be compared with it: a route
+     * found now is worth taking over the one it replaces only if this says the old one costs more.
+     *
+     * @param {Int32Array} path grid vertices, start to goal
+     * @param {number} length how many of `path` to read
+     * @param {number} start_axis
+     * @param {number} goal_axis
+     * @param {NodeGraphLayoutOptions} options
+     * @param {boolean} [through_goal] as for {@link find}
+     * @param {number} [net] as for {@link find}
+     * @returns {number}
+     */
+    cost_of(path: Int32Array, length: number, start_axis: number, goal_axis: number, options: NodeGraphLayoutOptions, through_goal?: boolean, net?: number): number;
     /**
      * @param {number} state the goal, reached
      * @returns {boolean}

package/src/core/model/node-graph/visual/layout/RouteSearch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RouteSearch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/RouteSearch.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,2BAFU,MAAM,CAEc;AAE9B;;;GAGG;AACH,2BAFU,MAAM,CAEc;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH;IAiDI;;OAEG;IACH,6BAeC;IAjED;;OAEG;IACH,gBAAY;IAEZ;;OAEG;IACH,MAFU,UAAU,CAEQ;IAE5B;;OAEG;IACH,QAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,UAAU,CAEd;IAEN;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,MAFU,UAAU,CAEf;IAEL;;OAEG;IACH,aAFU,MAAM,CAEA;IAsBhB;;;;;;;;;;;;;;;OAeG;IACH,YARW,MAAM,cACN,MAAM,QAEN,MAAM,aACN,MAAM,oCAEJ,OAAO,CAyGnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBA8BC;IAED;;;;OAIG;IACH,iBAuBC;CACJ;2BA1S0B,2CAA2C;uBAD/C,8BAA8B"}
+{"version":3,"file":"RouteSearch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/RouteSearch.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,2BAFU,MAAM,CAEc;AAE9B;;;GAGG;AACH,2BAFU,MAAM,CAEc;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH;IA+DI;;OAEG;IACH,6BAeC;IA/ED;;OAEG;IACH,gBAAY;IAEZ;;OAEG;IACH,MAFU,UAAU,CAEQ;IAE5B;;OAEG;IACH,QAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,UAAU,CAEd;IAEN;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,MAFU,UAAU,CAEf;IAEL;;OAEG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,YAFU,MAAM,CAED;IAsBf;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,YAbW,MAAM,cACN,MAAM,QAEN,MAAM,aACN,MAAM,kDAEN,OAAO,QAGP,MAAM,GAEJ,OAAO,CAiHnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,gBAkDC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,cATW,UAAU,UACV,MAAM,cACN,MAAM,aACN,MAAM,kDAEN,OAAO,QACP,MAAM,GACJ,MAAM,CA4DlB;IAED;;;;OAIG;IACH,iBAyBC;CACJ;2BAlb0B,2CAA2C;uBAD/C,8BAA8B"}

package/src/core/model/node-graph/visual/layout/RouteSearch.js

@@ -79,6 +79,20 @@ export class RouteSearch {
      */
     path_length = 0;
 
+    /**
+     * What the route just found costs, under the grid as it stood when it was found. This is the
+     * same number {@link cost_of} gives for it, and is what a route it replaces is compared with.
+     * @type {number}
+     */
+    cost = 0;
+
+    /**
+     * States the last search took off the queue before it found the goal or gave up. What the
+     * search cost, for anybody tuning it.
+     * @type {number}
+     */
+    expansions = 0;
+
     /**
      * @param {RouteGrid} grid
      */
@@ -102,10 +116,14 @@ export class RouteSearch {
     /**
      * Find a wire's way from one vertex to another.
      *
-     * The cost being minimised is length, plus a fixed price per turn, plus what the grid charges
-     * for lines other wires are already on. The estimate driving the search is the straight
-     * rectilinear distance remaining, which never exceeds what the route will actually cost — turns
-     * and congestion only ever add — so the first route found is the cheapest one.
+     * The cost being minimised is length, plus a fixed price per turn, plus a fixed price for every
+     * wire crossed, plus what the grid charges for lines other wires are already on. The estimate
+     * driving the search is the straight rectilinear distance remaining, which never exceeds what
+     * the route will actually cost — turns, crossings and congestion only ever add — so the first
+     * route found is the cheapest one.
+     *
+     * A crossing is charged where it happens: on going straight through a vertex, for every wire
+     * already going straight through it the other way. See {@link RouteGrid#through_h}.
      *
      * @param {number} start vertex
      * @param {number} start_axis the axis the wire is already travelling on as it arrives here,
@@ -113,9 +131,14 @@ export class RouteSearch {
      * @param {number} goal vertex
      * @param {number} goal_axis the axis the wire must be on to meet the port it is heading for
      * @param {NodeGraphLayoutOptions} options
+     * @param {boolean} [through_goal] whether arriving at the goal along its axis is going straight
+     *        through it. True at a port, where the wire carries on into its stub; false at a
+     *        waypoint the wire will leave by another search, which charges for the leaving.
+     * @param {number} [net] the net the wire belongs to, whose other wires it may share a line
+     *        with for nothing — see {@link RouteGrid#owner_h}. -1 for a wire of no net.
      * @returns {boolean} whether a route was found. The route is left in {@link path}.
      */
-    find(start, start_axis, goal, goal_axis, options) {
+    find(start, start_axis, goal, goal_axis, options, through_goal = true, net = -1) {
         const grid = this.grid;
 
         const nx = grid.nx;
@@ -125,6 +148,7 @@ export class RouteSearch {
         const ys = grid.ys;
 
         this.path_length = 0;
+        this.cost = 0;
 
         if (start === goal) {
             this.path[0] = start;
@@ -151,7 +175,7 @@ export class RouteSearch {
 
         this.open.insert(start_state, Math.abs(xs[start % nx] - goal_x) + Math.abs(ys[(start / nx) | 0] - goal_y));
 
-        let expansions = 0;
+        this.expansions = 0;
 
         while (!this.open.is_empty()) {
             const state = this.open.pop_min();
@@ -169,7 +193,7 @@ export class RouteSearch {
 
             this.closed.set(state, true);
 
-            if (++expansions > options.max_route_expansions) {
+            if (++this.expansions > options.max_route_expansions) {
                 break;
             }
 
@@ -180,37 +204,44 @@ export class RouteSearch {
 
             const cost = this.score[state];
 
-            if (i + 1 < nx && !grid.blocked_h.get(vertex)) {
+            // A wire never doubles back along the line it arrived by. The axis alone would allow
+            // it — out along a line and straight back is two moves on one axis, with no turn to
+            // pay for — and a wire could then dodge the charge for crossing another at a vertex by
+            // arriving at it along a different axis, having made a spike out of the side and
+            // back. The spike is no less a crossing; it is merely one the count cannot see.
+            const previous = this.came_from[state] === -1 ? -1 : this.came_from[state] >> 1;
+
+            if (i + 1 < nx && vertex + 1 !== previous && !grid.blocked_h.get(vertex)) {
                 this.__relax(
-                    state, cost, axis, vertex + 1, ROUTE_AXIS_H, goal, goal_axis, bend, options,
-                    xs[i + 1] - xs[i] + grid.use_h[vertex] * options.present_cost + grid.history_h[vertex],
+                    state, cost, axis, vertex + 1, ROUTE_AXIS_H, goal, goal_axis, through_goal, bend, options,
+                    xs[i + 1] - xs[i] + grid.foreign_h(vertex, net) * options.present_cost + grid.history_h[vertex],
                     Math.abs(xs[i + 1] - goal_x) + Math.abs(ys[j] - goal_y),
                     generation
                 );
             }
 
-            if (i > 0 && !grid.blocked_h.get(vertex - 1)) {
+            if (i > 0 && vertex - 1 !== previous && !grid.blocked_h.get(vertex - 1)) {
                 this.__relax(
-                    state, cost, axis, vertex - 1, ROUTE_AXIS_H, goal, goal_axis, bend, options,
-                    xs[i] - xs[i - 1] + grid.use_h[vertex - 1] * options.present_cost + grid.history_h[vertex - 1],
+                    state, cost, axis, vertex - 1, ROUTE_AXIS_H, goal, goal_axis, through_goal, bend, options,
+                    xs[i] - xs[i - 1] + grid.foreign_h(vertex - 1, net) * options.present_cost + grid.history_h[vertex - 1],
                     Math.abs(xs[i - 1] - goal_x) + Math.abs(ys[j] - goal_y),
                     generation
                 );
             }
 
-            if (j + 1 < ny && !grid.blocked_v.get(vertex)) {
+            if (j + 1 < ny && vertex + nx !== previous && !grid.blocked_v.get(vertex)) {
                 this.__relax(
-                    state, cost, axis, vertex + nx, ROUTE_AXIS_V, goal, goal_axis, bend, options,
-                    ys[j + 1] - ys[j] + grid.use_v[vertex] * options.present_cost + grid.history_v[vertex],
+                    state, cost, axis, vertex + nx, ROUTE_AXIS_V, goal, goal_axis, through_goal, bend, options,
+                    ys[j + 1] - ys[j] + grid.foreign_v(vertex, net) * options.present_cost + grid.history_v[vertex],
                     Math.abs(xs[i] - goal_x) + Math.abs(ys[j + 1] - goal_y),
                     generation
                 );
             }
 
-            if (j > 0 && !grid.blocked_v.get(vertex - nx)) {
+            if (j > 0 && vertex - nx !== previous && !grid.blocked_v.get(vertex - nx)) {
                 this.__relax(
-                    state, cost, axis, vertex - nx, ROUTE_AXIS_V, goal, goal_axis, bend, options,
-                    ys[j] - ys[j - 1] + grid.use_v[vertex - nx] * options.present_cost + grid.history_v[vertex - nx],
+                    state, cost, axis, vertex - nx, ROUTE_AXIS_V, goal, goal_axis, through_goal, bend, options,
+                    ys[j] - ys[j - 1] + grid.foreign_v(vertex - nx, net) * options.present_cost + grid.history_v[vertex - nx],
                     Math.abs(xs[i] - goal_x) + Math.abs(ys[j - 1] - goal_y),
                     generation
                 );
@@ -228,6 +259,7 @@ export class RouteSearch {
      * @param {number} axis being moved along
      * @param {number} goal
      * @param {number} goal_axis
+     * @param {boolean} through_goal
      * @param {number} bend
      * @param {NodeGraphLayoutOptions} options
      * @param {number} step what the move itself costs
@@ -236,7 +268,7 @@ export class RouteSearch {
      * @returns {void}
      * @private
      */
-    __relax(from, from_cost, from_axis, vertex, axis, goal, goal_axis, bend, options, step, remaining, generation) {
+    __relax(from, from_cost, from_axis, vertex, axis, goal, goal_axis, through_goal, bend, options, step, remaining, generation) {
         const state = vertex * 2 + axis;
 
         if (this.closed.get(state)) {
@@ -245,14 +277,34 @@ export class RouteSearch {
 
         let cost = from_cost + step;
 
+        const grid = this.grid;
+
         if (axis !== from_axis) {
             cost += bend;
+        } else {
+            // carrying straight on through the vertex being left crosses every wire going straight
+            // through it the other way
+            const through = axis === ROUTE_AXIS_H ? grid.through_v[from >> 1] : grid.through_h[from >> 1];
+
+            if (through > 0) {
+                cost += through * options.crossing_penalty;
+            }
         }
 
-        if (vertex === goal && axis !== goal_axis) {
-            // meeting a port along the wrong axis means one more turn than the route shows, made
-            // in the stub between the grid and the port itself
-            cost += bend;
+        if (vertex === goal) {
+            if (axis !== goal_axis) {
+                // meeting a port along the wrong axis means one more turn than the route shows,
+                // made in the stub between the grid and the port itself
+                cost += bend;
+            } else if (through_goal) {
+                // and meeting it along the right one means going straight through the goal vertex
+                // into that stub
+                const through = axis === ROUTE_AXIS_H ? grid.through_v[goal] : grid.through_h[goal];
+
+                if (through > 0) {
+                    cost += through * options.crossing_penalty;
+                }
+            }
         }
 
         if (this.stamp[state] === generation && this.score[state] <= cost) {
@@ -268,12 +320,96 @@ export class RouteSearch {
         this.open.insert(state, cost + remaining);
     }
 
+    /**
+     * What a route costs under the grid as it stands now.
+     *
+     * The same sum {@link find} minimises, added up along a route that already exists: length, a
+     * turn wherever the axis changes — counting the stubs at either end, which fix the axis the
+     * route starts and finishes on — a crossing wherever it goes straight through a vertex some
+     * other wire goes straight through the other way, and the grid's charge for every line it
+     * shares. The route's own occupancy must have been taken off the grid first, or it is charged
+     * for sharing lines with itself.
+     *
+     * Kept exactly in step with {@link find}, because it exists to be compared with it: a route
+     * found now is worth taking over the one it replaces only if this says the old one costs more.
+     *
+     * @param {Int32Array} path grid vertices, start to goal
+     * @param {number} length how many of `path` to read
+     * @param {number} start_axis
+     * @param {number} goal_axis
+     * @param {NodeGraphLayoutOptions} options
+     * @param {boolean} [through_goal] as for {@link find}
+     * @param {number} [net] as for {@link find}
+     * @returns {number}
+     */
+    cost_of(path, length, start_axis, goal_axis, options, through_goal = true, net = -1) {
+        if (length < 2) {
+            // a route that is one vertex is the two stubs meeting, which find() prices at nothing
+            return 0;
+        }
+
+        const grid = this.grid;
+
+        const nx = grid.nx;
+
+        const xs = grid.xs;
+        const ys = grid.ys;
+
+        const bend = options.bend_penalty;
+        const crossing = options.crossing_penalty;
+        const present = options.present_cost;
+
+        let cost = 0;
+        let axis = start_axis;
+
+        for (let k = 0; k + 1 < length; k++) {
+            const a = path[k];
+            const b = path[k + 1];
+
+            let step_axis;
+
+            if (b === a + 1) {
+                step_axis = ROUTE_AXIS_H;
+                cost += xs[b % nx] - xs[a % nx] + grid.foreign_h(a, net) * present + grid.history_h[a];
+            } else if (a === b + 1) {
+                step_axis = ROUTE_AXIS_H;
+                cost += xs[a % nx] - xs[b % nx] + grid.foreign_h(b, net) * present + grid.history_h[b];
+            } else if (b === a + nx) {
+                step_axis = ROUTE_AXIS_V;
+                cost += ys[(b / nx) | 0] - ys[(a / nx) | 0] + grid.foreign_v(a, net) * present + grid.history_v[a];
+            } else {
+                step_axis = ROUTE_AXIS_V;
+                cost += ys[(a / nx) | 0] - ys[(b / nx) | 0] + grid.foreign_v(b, net) * present + grid.history_v[b];
+            }
+
+            if (step_axis !== axis) {
+                cost += bend;
+            } else {
+                cost += (step_axis === ROUTE_AXIS_H ? grid.through_v[a] : grid.through_h[a]) * crossing;
+            }
+
+            axis = step_axis;
+        }
+
+        const goal = path[length - 1];
+
+        if (axis !== goal_axis) {
+            cost += bend;
+        } else if (through_goal) {
+            cost += (axis === ROUTE_AXIS_H ? grid.through_v[goal] : grid.through_h[goal]) * crossing;
+        }
+
+        return cost;
+    }
+
     /**
      * @param {number} state the goal, reached
      * @returns {boolean}
      * @private
      */
     __unwind(state) {
+        this.cost = this.score[state];
+
         let length = 0;
 
         for (let at = state; at !== -1; at = this.came_from[at]) {

package/src/core/model/node-graph/visual/layout/RouteSet.d.ts

@@ -35,6 +35,13 @@ export class RouteSet {
      * @type {Float64Array}
      */
     y: Float64Array;
+    /**
+     * Net of each route: routes leaving one port together share a number here, and a stage that
+     * pulls overlapping routes apart leaves those together — they are one line that forks. Null
+     * when nobody has said; every route is then its own net.
+     * @type {Int32Array|null}
+     */
+    net: Int32Array | null;
     /**
      * @type {number}
      * @private

package/src/core/model/node-graph/visual/layout/RouteSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RouteSet.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/RouteSet.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH;IAoCI;;;OAGG;IACH,mBAHW,MAAM,aACN,MAAM,EAShB;IA7CD;;OAEG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,UAAU,CAEb;IAEP;;OAEG;IACH,GAFU,YAAY,CAEpB;IAEF;;OAEG;IACH,GAFU,YAAY,CAEpB;IAEF;;;OAGG;IACH,iBAAa;IAEb;;;;OAIG;IACH,gBAAY;IAeZ;;;OAGG;IACH,SAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;;;OAMG;IACH,QAJW,MAAM,KACN,MAAM,GACJ,IAAI,CAiChB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,iBAmBC;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ"}
+{"version":3,"file":"RouteSet.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/RouteSet.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH;IA4CI;;;OAGG;IACH,mBAHW,MAAM,aACN,MAAM,EAShB;IArDD;;OAEG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,UAAU,CAEb;IAEP;;OAEG;IACH,GAFU,YAAY,CAEpB;IAEF;;OAEG;IACH,GAFU,YAAY,CAEpB;IAEF;;;;;OAKG;IACH,KAFU,UAAU,GAAC,IAAI,CAEd;IAEX;;;OAGG;IACH,iBAAa;IAEb;;;;OAIG;IACH,gBAAY;IAeZ;;;OAGG;IACH,SAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;;;OAMG;IACH,QAJW,MAAM,KACN,MAAM,GACJ,IAAI,CAiChB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,iBAmBC;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ"}

package/src/core/model/node-graph/visual/layout/RouteSet.js

@@ -35,6 +35,14 @@ export class RouteSet {
      */
     y;
 
+    /**
+     * Net of each route: routes leaving one port together share a number here, and a stage that
+     * pulls overlapping routes apart leaves those together — they are one line that forks. Null
+     * when nobody has said; every route is then its own net.
+     * @type {Int32Array|null}
+     */
+    net = null;
+
     /**
      * @type {number}
      * @private

package/src/core/model/node-graph/visual/layout/layout_assign_coordinates.js

@@ -376,15 +376,21 @@ function compact(graph, order, rank, layer_start, block, options) {
         sink[box] = box;
     }
 
+    // A lane is a wire. Next to another wire it keeps a wire's gap; next to a box it keeps the
+    // clearance as well, because the line a clearance outside a box is the nearest a wire is ever
+    // drawn to it, and a lane closer than that is inside the space the router treats as the box.
+    const lane_to_box = Math.max(options.wire_gap, options.clearance);
+
     /**
      * @param {number} above
      * @param {number} below
      * @returns {number} smallest distance from the top of `above` to the top of `below`
      */
     function separation(above, below) {
-        const gap = graph.box_kind[above] === LAYOUT_BOX_LANE || graph.box_kind[below] === LAYOUT_BOX_LANE
-            ? options.wire_gap
-            : options.node_gap;
+        const lanes = (graph.box_kind[above] === LAYOUT_BOX_LANE ? 1 : 0)
+            + (graph.box_kind[below] === LAYOUT_BOX_LANE ? 1 : 0);
+
+        const gap = lanes === 2 ? options.wire_gap : lanes === 1 ? lane_to_box : options.node_gap;
 
         return graph.box_h[above] + gap;
     }

package/src/core/model/node-graph/visual/layout/layout_build_problem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout_build_problem.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_build_problem.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qFALa,aAAa,CA+GzB;8BAtI6C,oBAAoB"}
+{"version":3,"file":"layout_build_problem.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_build_problem.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qFALa,aAAa,CAsHzB;8BA7I6C,oBAAoB"}

package/src/core/model/node-graph/visual/layout/layout_build_problem.js

@@ -87,6 +87,11 @@ export function layout_build_problem(graph, visual) {
     problem.to_dy = new Float64Array(connection_count);
     problem.from_side = new Uint8Array(connection_count);
     problem.to_side = new Uint8Array(connection_count);
+    problem.link_of_connection = new Int32Array(connection_count).fill(-1);
+
+    // no lanes until placement decides them
+    problem.lane_start = new Int32Array(connection_count + 1);
+    problem.lane_box = new Int32Array(0);
 
     let link_count = 0;
 
@@ -127,6 +132,8 @@ export function layout_build_problem(graph, visual) {
         write_endpoint(problem, i, false, visual, node_ids[to_box], connection.target.port.id, boxes, to_box);
 
         if (from_box !== to_box) {
+            problem.link_of_connection[i] = link;
+
             boxes.set_link(link++, from_box, to_box, problem.from_dy[i], problem.to_dy[i]);
         }
     }

package/src/core/model/node-graph/visual/layout/layout_insert_lanes.d.ts

@@ -15,15 +15,21 @@
  * - **Straightness.** A chain of lane boxes is a chain of links the coordinate stage will try to
  *   align, and aligning them is what makes a long wire straight rather than a slow diagonal.
  *
- * The router is never told which lane belongs to which wire. It does not need to be: the lanes put
- * empty horizontal space where wires want to go, and a router minimising length and bends finds it.
+ * The router is told which lanes belong to which wire, and routes the wire through them. That is
+ * the fourth job, and the one the other three exist for: the ordering stage decided where each
+ * long wire crosses each column so that as few wires cross as it could manage, and a wire routed
+ * through its lanes is that decision drawn. A router left to find the empty space on its own does
+ * so one wire at a time, and what it rediscovers is the order the wires happened to be routed in.
  *
  * @param {LayoutBoxGraph} graph mutated in place; adjacency is rebuilt. Layers must be assigned, and
  *        every link must point forwards by at least one column.
+ * @param {Int32Array} [lane_offset] written when given, one entry per link as the graph stood on
+ *        entry plus one: the lanes of link `i` are the boxes `lane_offset[i]` up to but not
+ *        including `lane_offset[i + 1]`, in the order the wire passes through them
  * @returns {number} how many lane boxes were added
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function layout_insert_lanes(graph: LayoutBoxGraph): number;
+export function layout_insert_lanes(graph: LayoutBoxGraph, lane_offset?: Int32Array): number;
 //# sourceMappingURL=layout_insert_lanes.d.ts.map

package/src/core/model/node-graph/visual/layout/layout_insert_lanes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout_insert_lanes.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_insert_lanes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4DALa,MAAM,CAsElB"}
+{"version":3,"file":"layout_insert_lanes.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_insert_lanes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,yEARW,UAAU,GAGR,MAAM,CA8ElB"}

package/src/core/model/node-graph/visual/layout/layout_insert_lanes.js

@@ -17,17 +17,23 @@ import { LAYOUT_BOX_LANE } from "./LayoutBoxGraph.js";
  * - **Straightness.** A chain of lane boxes is a chain of links the coordinate stage will try to
  *   align, and aligning them is what makes a long wire straight rather than a slow diagonal.
  *
- * The router is never told which lane belongs to which wire. It does not need to be: the lanes put
- * empty horizontal space where wires want to go, and a router minimising length and bends finds it.
+ * The router is told which lanes belong to which wire, and routes the wire through them. That is
+ * the fourth job, and the one the other three exist for: the ordering stage decided where each
+ * long wire crosses each column so that as few wires cross as it could manage, and a wire routed
+ * through its lanes is that decision drawn. A router left to find the empty space on its own does
+ * so one wire at a time, and what it rediscovers is the order the wires happened to be routed in.
  *
  * @param {LayoutBoxGraph} graph mutated in place; adjacency is rebuilt. Layers must be assigned, and
  *        every link must point forwards by at least one column.
+ * @param {Int32Array} [lane_offset] written when given, one entry per link as the graph stood on
+ *        entry plus one: the lanes of link `i` are the boxes `lane_offset[i]` up to but not
+ *        including `lane_offset[i + 1]`, in the order the wire passes through them
  * @returns {number} how many lane boxes were added
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function layout_insert_lanes(graph) {
+export function layout_insert_lanes(graph, lane_offset) {
     const old_link_count = graph.link_count;
 
     let extra_boxes = 0;
@@ -36,10 +42,18 @@ export function layout_insert_lanes(graph) {
     for (let i = 0; i < old_link_count; i++) {
         const span = graph.box_layer[graph.link_to[i]] - graph.box_layer[graph.link_from[i]];
 
+        if (lane_offset !== undefined) {
+            lane_offset[i] = graph.box_count + extra_boxes;
+        }
+
         extra_boxes += span - 1;
         new_link_count += span;
     }
 
+    if (lane_offset !== undefined) {
+        lane_offset[old_link_count] = graph.box_count + extra_boxes;
+    }
+
     if (extra_boxes === 0) {
         return 0;
     }

package/src/core/model/node-graph/visual/layout/layout_node_graph.d.ts

@@ -11,12 +11,15 @@
  * not because anything measured how related they are, but because being joined is what put them in
  * neighbouring columns and being joined to the same things is what put them next to each other.
  *
- * **Routing** decides where the wires go, which the placement has deliberately left open. Each wire
- * finds its own way through the space between the boxes, avoiding them and, as far as it can, each
- * other. This is where the drawing stops looking like a diagram of the algorithm and starts looking
- * like something somebody drew: wires that run alongside each other rather than through each other,
- * that go around a node instead of behind it, and that leave and arrive square to the ports they
- * belong to.
+ * **Routing** decides where the wires go, which the placement has left open within the columns it
+ * decided. A wire that crosses a column is taken through the lane the placement reserved for it
+ * there — which is how the placement's crossing-minimised order reaches the drawing — and between
+ * one lane and the next each wire finds its own way, avoiding the boxes and, as far as it can, the
+ * other wires: sharing a line with one costs it something, and so does crossing one. This is where
+ * the drawing stops looking like a diagram of the algorithm and starts looking like something
+ * somebody drew: wires that run alongside each other rather than through each other, that go
+ * around a node instead of behind it, that do not cross what they could as easily have gone round,
+ * and that leave and arrive square to the ports they belong to.
  *
  * The two halves are separate on purpose. Placement can be re-run without re-routing when only the
  * structure changed, and routing can be re-run without re-placing when somebody has dragged a node

package/src/core/model/node-graph/visual/layout/layout_node_graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout_node_graph.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_node_graph.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,2FANW,sBAAsB;WACZ,MAAM;YAAU,MAAM;eAAa,MAAM;EA+C7D;AAED;;;;;;;;;;;GAWG;AACH,sGAHW,sBAAsB,GACpB,IAAI,CA2BhB;uCA3HsC,6BAA6B"}
+{"version":3,"file":"layout_node_graph.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_node_graph.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2FANW,sBAAsB;WACZ,MAAM;YAAU,MAAM;eAAa,MAAM;EAmD7D;AAqCD;;;;;;;;;;;GAWG;AACH,sGAHW,sBAAsB,GACpB,IAAI,CA2BhB;uCArKsC,6BAA6B"}