@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -0,0 +1,534 @@
+/**
+ * Adjacent-pair exchange rounds after each sweep. The pass stops as soon as a round changes
+ * nothing, so this only bounds a pathological case.
+ * @type {number}
+ */
+const EXCHANGE_ROUNDS = 4;
+
+/**
+ * Decide the order of boxes within each column.
+ *
+ * Two heuristics alternating, then a local fix-up, and the best arrangement any of them reaches is
+ * what is kept — a sweep can leave the drawing worse than it found it, and there is no reason to
+ * keep the last one rather than the best one. Best means fewest crossings, and between
+ * arrangements that cross equally often, the one whose links reach least far up and down.
+ *
+ * - **Sweeps.** Every box moves to the average, or to the median, of where its neighbours in the
+ *   adjacent column sit. Median wins where a box's neighbours fall into groups, average where they
+ *   are spread evenly, and alternating them escapes the local minimum either one alone settles
+ *   into. Exact crossing minimisation is NP-hard and nobody reading a graph is counting crossings.
+ * - **Exchanges.** After each sweep, adjacent pairs swap wherever that removes crossings. A sweep
+ *   moves a box to where its neighbours are on average; an exchange fixes the case where two boxes
+ *   simply want each other's place, which no average will ever tell them.
+ *
+ * Every link spans exactly one column boundary by this point — {@link layout_insert_lanes} saw to
+ * that — so the crossing count here is the number of crossings the drawing will actually show,
+ * counted rather than estimated.
+ *
+ * **Ports are positions, not just boxes.** A link does not meet a box, it meets a port on it, and
+ * a box with three inputs fed by three boxes of the column before is drawn with three wires that
+ * cross each other whenever those three are stacked in the wrong order — an order that looks
+ * perfect to anything comparing boxes alone, since all three links arrive at the same box. So
+ * wherever this compares where a link's far end sits, it uses the box's rank plus how far down the
+ * box the port is, and two links into one box are as in or out of order as the ports they meet.
+ * Two links leaving one port are the exception: they fan out from a single point and cannot cross,
+ * whichever way round their targets are.
+ *
+ * @param {LayoutBoxGraph} graph adjacency must be current
+ * @param {number} layer_count
+ * @param {number} sweeps
+ * @returns {{order: Int32Array, rank: Int32Array, layer_start: Int32Array, crossings: number}}
+ *          `order` holds box indices grouped by column, `layer_start` where each column begins in
+ *          it, and `rank` where each box sits within its own column.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function layout_order_layers(graph, layer_count, sweeps) {
+    const box_count = graph.box_count;
+
+    const layer_start = new Int32Array(layer_count + 1);
+    const order = new Int32Array(box_count);
+    const rank = new Int32Array(box_count);
+
+    for (let box = 0; box < box_count; box++) {
+        layer_start[graph.box_layer[box] + 1]++;
+    }
+
+    for (let i = 0; i < layer_count; i++) {
+        layer_start[i + 1] += layer_start[i];
+    }
+
+    {
+        const cursor = layer_start.slice(0, layer_count);
+
+        for (let box = 0; box < box_count; box++) {
+            const at = cursor[graph.box_layer[box]]++;
+
+            order[at] = box;
+            rank[box] = at - layer_start[graph.box_layer[box]];
+        }
+    }
+
+    if (layer_count < 2) {
+        return { order, rank, layer_start, crossings: 0 };
+    }
+
+    // links grouped by the boundary they cross, which is the column their source sits in
+    const boundary_start = new Int32Array(layer_count + 1);
+    const boundary_link = new Int32Array(graph.link_count);
+
+    for (let i = 0; i < graph.link_count; i++) {
+        boundary_start[graph.box_layer[graph.link_from[i]] + 1]++;
+    }
+
+    for (let i = 0; i < layer_count; i++) {
+        boundary_start[i + 1] += boundary_start[i];
+    }
+
+    {
+        const cursor = boundary_start.slice(0, layer_count);
+
+        for (let i = 0; i < graph.link_count; i++) {
+            boundary_link[cursor[graph.box_layer[graph.link_from[i]]]++] = i;
+        }
+    }
+
+    // Sized by links rather than by boxes: two ports of one node can both be joined to two ports of
+    // the next, and then a box has more neighbours than the adjacent column has boxes.
+    let widest_degree = 0;
+
+    for (let box = 0; box < box_count; box++) {
+        const in_degree = graph.in_offset[box + 1] - graph.in_offset[box];
+        const out_degree = graph.out_offset[box + 1] - graph.out_offset[box];
+
+        if (in_degree > widest_degree) {
+            widest_degree = in_degree;
+        }
+
+        if (out_degree > widest_degree) {
+            widest_degree = out_degree;
+        }
+    }
+
+    // Positions carry a fraction for the port, so nothing here is an integer any more.
+    const scratch = {
+        weight: new Float64Array(box_count),
+        neighbours: new Float64Array(widest_degree),
+        sequence: new Float64Array(graph.link_count),
+        merge: new Float64Array(graph.link_count)
+    };
+
+    // Sorted by comparator rather than by one of the `array_quick_sort_by_lookup_*` helpers: those
+    // alias the shared traversal scratch stack, and neither can carry the tie-break, which is what
+    // makes this run give the same answer as the last one.
+    const compare = (a, b) => (scratch.weight[a] - scratch.weight[b]) || (rank[a] - rank[b]);
+
+    // links across one boundary, in order of where they leave and then of where they arrive
+    const by_endpoints = (a, b) =>
+        (rank[graph.link_from[a]] - rank[graph.link_from[b]])
+        || (graph.link_from_y[a] - graph.link_from_y[b])
+        || (rank[graph.link_to[a]] - rank[graph.link_to[b]])
+        || (graph.link_to_y[a] - graph.link_to_y[b]);
+
+    let best = order.slice();
+    let best_cost = count_crossings(graph, rank, layer_count, boundary_start, boundary_link, by_endpoints, scratch);
+    let best_reach = reach(graph, order, layer_start, layer_count, scratch.weight);
+
+    for (let sweep = 0; sweep < sweeps; sweep++) {
+        const downward = sweep % 2 === 0;
+        const median = (sweep >> 1) % 2 === 0;
+
+        for (let i = 0; i < layer_count; i++) {
+            // A downward sweep looks at what feeds each box, so it has to visit the columns in the
+            // order they were themselves settled; upward is the mirror of that.
+            const at = downward ? i : layer_count - 1 - i;
+
+            reweigh(graph, order, rank, layer_start, at, downward, median, scratch);
+
+            const start = layer_start[at];
+            const end = layer_start[at + 1];
+
+            order.subarray(start, end).sort(compare);
+
+            for (let k = start; k < end; k++) {
+                rank[order[k]] = k - start;
+            }
+        }
+
+        exchange(graph, order, rank, layer_start, layer_count);
+
+        const cost = count_crossings(graph, rank, layer_count, boundary_start, boundary_link, by_endpoints, scratch);
+
+        // Fewer crossings wins; the same number of crossings wins if the links reach less far.
+        // The second half matters more than it looks: the order the boxes arrive in has the lanes
+        // after every node, and a sweep that brings each lane up beside the wire it belongs to
+        // regularly crosses exactly as often as leaving it at the bottom of the column did — the
+        // crossings merely move from where the lane meets its wire to where it leaves its port.
+        // Without the tie-break the arrival order is kept, and the wire is drawn to the bottom of
+        // the column and back.
+        if (cost > best_cost) {
+            continue;
+        }
+
+        // the weights are spent by now, so their array can hold the box tops
+        const wander = reach(graph, order, layer_start, layer_count, scratch.weight);
+
+        if (cost < best_cost || wander < best_reach) {
+            best_cost = cost;
+            best_reach = wander;
+            best.set(order);
+        }
+    }
+
+    order.set(best);
+
+    for (let i = 0; i < layer_count; i++) {
+        for (let k = layer_start[i]; k < layer_start[i + 1]; k++) {
+            rank[order[k]] = k - layer_start[i];
+        }
+    }
+
+    return { order, rank, layer_start, crossings: best_cost };
+}
+
+/**
+ * Where a link meets a box, as a position down the column: the box's rank, and then how far down
+ * the box the port is as a fraction of its height.
+ *
+ * A port sits strictly inside its box, so this is strictly less than the rank after. A lane has no
+ * height and no ports, and is simply its rank.
+ *
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} rank
+ * @param {number} box
+ * @param {number} y offset down the box at which the link meets it
+ * @returns {number}
+ */
+function position_of(graph, rank, box, y) {
+    const height = graph.box_h[box];
+
+    return height > 0 ? rank[box] + y / height : rank[box];
+}
+
+/**
+ * Where a link meets its source box, as a position down the column. See {@link position_of}.
+ *
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} rank
+ * @param {number} link
+ * @returns {number}
+ */
+function source_position(graph, rank, link) {
+    return position_of(graph, rank, graph.link_from[link], graph.link_from_y[link]);
+}
+
+/**
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} rank
+ * @param {number} link
+ * @returns {number}
+ */
+function target_position(graph, rank, link) {
+    return position_of(graph, rank, graph.link_to[link], graph.link_to_y[link]);
+}
+
+/**
+ * Give every box in one column a position to be sorted by, taken from where its neighbours in the
+ * adjacent column sit — where on them, that is: a box fed from the top port of a neighbour belongs
+ * above a box fed from its bottom one, and three boxes feeding one neighbour belong in the order
+ * of the ports they feed.
+ *
+ * A box with no neighbours on the side being looked at keeps the position it has. Otherwise a
+ * source or a sink drifts to the top of its column on every single sweep, having nothing to hold
+ * it anywhere.
+ *
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} order
+ * @param {Int32Array} rank
+ * @param {Int32Array} layer_start
+ * @param {number} at column index
+ * @param {boolean} downward look at what feeds each box, rather than what it feeds
+ * @param {boolean} median take the median rather than the average
+ * @param {object} scratch
+ * @returns {void}
+ */
+function reweigh(graph, order, rank, layer_start, at, downward, median, scratch) {
+    const weight = scratch.weight;
+    const neighbours = scratch.neighbours;
+
+    for (let k = layer_start[at]; k < layer_start[at + 1]; k++) {
+        const box = order[k];
+
+        const start = downward ? graph.in_offset[box] : graph.out_offset[box];
+        const end = downward ? graph.in_offset[box + 1] : graph.out_offset[box + 1];
+
+        const count = end - start;
+
+        if (count === 0) {
+            weight[box] = rank[box];
+
+            continue;
+        }
+
+        for (let i = 0; i < count; i++) {
+            const link = downward ? graph.in_link[start + i] : graph.out_link[start + i];
+
+            neighbours[i] = downward ? source_position(graph, rank, link) : target_position(graph, rank, link);
+        }
+
+        if (!median) {
+            let total = 0;
+
+            for (let i = 0; i < count; i++) {
+                total += neighbours[i];
+            }
+
+            weight[box] = total / count;
+
+            continue;
+        }
+
+        const window = neighbours.subarray(0, count);
+
+        window.sort();
+
+        const middle = count >> 1;
+
+        // Not `computeStatisticalPartialMedian`: that copies the array it is given, and this runs
+        // once per box per sweep. It also takes the lower of the two middles, where what is wanted
+        // here is the point between them — a box with two neighbours belongs between them, not
+        // level with the upper one.
+        weight[box] = count % 2 === 1
+            ? window[middle]
+            : (window[middle - 1] + window[middle]) / 2;
+    }
+}
+
+/**
+ * Swap adjacent boxes wherever it removes crossings.
+ *
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} order
+ * @param {Int32Array} rank
+ * @param {Int32Array} layer_start
+ * @param {number} layer_count
+ * @returns {void}
+ */
+function exchange(graph, order, rank, layer_start, layer_count) {
+    for (let round = 0; round < EXCHANGE_ROUNDS; round++) {
+        let swapped = false;
+
+        for (let at = 0; at < layer_count; at++) {
+            const start = layer_start[at];
+            const end = layer_start[at + 1];
+
+            for (let k = start; k + 1 < end; k++) {
+                const a = order[k];
+                const b = order[k + 1];
+
+                if (pair_crossings(graph, rank, b, a) >= pair_crossings(graph, rank, a, b)) {
+                    continue;
+                }
+
+                order[k] = b;
+                order[k + 1] = a;
+
+                rank[b] = k - start;
+                rank[a] = k + 1 - start;
+
+                swapped = true;
+            }
+        }
+
+        if (!swapped) {
+            return;
+        }
+    }
+}
+
+/**
+ * Crossings between the links of two boxes sharing a column, given `first` sits above `second`.
+ *
+ * Only the far ends matter. Where on `first` and `second` their own links attach decides nothing
+ * about whether swapping the two helps, since it is the same either way round.
+ *
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} rank
+ * @param {number} first
+ * @param {number} second
+ * @returns {number}
+ */
+function pair_crossings(graph, rank, first, second) {
+    let total = 0;
+
+    for (let side = 0; side < 2; side++) {
+        const offset = side === 0 ? graph.in_offset : graph.out_offset;
+        const list = side === 0 ? graph.in_link : graph.out_link;
+        const position = side === 0 ? source_position : target_position;
+
+        const first_start = offset[first];
+        const first_end = offset[first + 1];
+
+        const second_start = offset[second];
+        const second_end = offset[second + 1];
+
+        for (let i = first_start; i < first_end; i++) {
+            const a = position(graph, rank, list[i]);
+
+            for (let k = second_start; k < second_end; k++) {
+                if (a > position(graph, rank, list[k])) {
+                    total++;
+                }
+            }
+        }
+    }
+
+    return total;
+}
+
+/**
+ * How many times two links cross, over every column boundary.
+ *
+ * Links leaving one port are gathered in ascending order of where they arrive, so two of them never
+ * register as a crossing — they start at the same point and cannot cross. What is left is counted
+ * by inversions.
+ *
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} rank
+ * @param {number} layer_count
+ * @param {Int32Array} boundary_start
+ * @param {Int32Array} boundary_link
+ * @param {function(number, number): number} by_endpoints
+ * @param {object} scratch
+ * @returns {number}
+ */
+function count_crossings(graph, rank, layer_count, boundary_start, boundary_link, by_endpoints, scratch) {
+    const sequence = scratch.sequence;
+
+    let total = 0;
+
+    for (let boundary = 0; boundary + 1 < layer_count; boundary++) {
+        const start = boundary_start[boundary];
+        const end = boundary_start[boundary + 1];
+
+        const count = end - start;
+
+        if (count < 2) {
+            continue;
+        }
+
+        for (let i = 0; i < count; i++) {
+            sequence[i] = boundary_link[start + i];
+        }
+
+        const window = sequence.subarray(0, count);
+
+        window.sort(by_endpoints);
+
+        for (let i = 0; i < count; i++) {
+            window[i] = target_position(graph, rank, window[i]);
+        }
+
+        total += inversions(window, scratch.merge);
+    }
+
+    return total;
+}
+
+/**
+ * How far the links reach up and down the drawing, all told: the sum over every link of the
+ * vertical distance between its two ends, with every column packed tight from the top.
+ *
+ * What separates two arrangements that cross equally often. Crossings are blind to distance — a
+ * dozen wires from one port to a dozen boxes cross the same things whether those boxes are next
+ * to the port or at the far end of the column — and an arrangement that is no better in crossings
+ * but keeps linked boxes together is the one to draw. Heights rather than ranks, because a lane is
+ * a rank like any other and a box is not: three lanes stacked under three boxes are the height of
+ * a wire, and counting them as three more boxes would call a wire to the bottom of that column
+ * and back as short as one to the box beside it.
+ *
+ * @param {LayoutBoxGraph} graph
+ * @param {Int32Array} order
+ * @param {Int32Array} layer_start
+ * @param {number} layer_count
+ * @param {Float64Array} top scratch, one per box: written with where each box's top would be
+ * @returns {number}
+ */
+function reach(graph, order, layer_start, layer_count, top) {
+    for (let layer = 0; layer < layer_count; layer++) {
+        let y = 0;
+
+        for (let k = layer_start[layer]; k < layer_start[layer + 1]; k++) {
+            const box = order[k];
+
+            top[box] = y;
+
+            y += graph.box_h[box];
+        }
+    }
+
+    let total = 0;
+
+    for (let i = 0; i < graph.link_count; i++) {
+        const from = top[graph.link_from[i]] + graph.link_from_y[i];
+        const to = top[graph.link_to[i]] + graph.link_to_y[i];
+
+        total += Math.abs(from - to);
+    }
+
+    return total;
+}
+
+/**
+ * Pairs out of order, by merge sort.
+ *
+ * @param {Float64Array} values consumed; left sorted
+ * @param {Float64Array} buffer at least as long as `values`
+ * @returns {number}
+ */
+function inversions(values, buffer) {
+    const length = values.length;
+
+    let total = 0;
+
+    for (let width = 1; width < length; width *= 2) {
+        for (let low = 0; low < length; low += width * 2) {
+            const middle = low + width < length ? low + width : length;
+            const high = low + width * 2 < length ? low + width * 2 : length;
+
+            if (middle === high) {
+                continue;
+            }
+
+            let left = low;
+            let right = middle;
+            let at = low;
+
+            while (left < middle && right < high) {
+                if (values[left] <= values[right]) {
+                    buffer[at++] = values[left++];
+                } else {
+                    // everything still waiting on the left is greater than this one
+                    total += middle - left;
+
+                    buffer[at++] = values[right++];
+                }
+            }
+
+            while (left < middle) {
+                buffer[at++] = values[left++];
+            }
+
+            while (right < high) {
+                buffer[at++] = values[right++];
+            }
+
+            for (let i = low; i < high; i++) {
+                values[i] = buffer[i];
+            }
+        }
+    }
+
+    return total;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Turn every backwards link around, so that what is left is a directed acyclic graph.
+ *
+ * Every stage after this one — layering, ordering, coordinates — is written against a graph that
+ * flows one way, and none of them has a sensible answer for a cycle. Reversing the links the
+ * ordering stage identified as backwards is what makes that assumption true, and it is the whole
+ * reason {@link layout_break_cycles} runs first.
+ *
+ * The reversal is only a placement fiction. Nothing is drawn from the links: a wire is drawn
+ * between the two ports of its connection, which are unchanged, and it simply runs right to left.
+ * Which links were turned is therefore not worth recording — nothing downstream asks.
+ *
+ * @param {LayoutBoxGraph} graph mutated in place; adjacency is invalidated
+ * @param {Int32Array} position from {@link layout_break_cycles}
+ * @returns {number} how many links were turned
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function layout_orient_links(graph: LayoutBoxGraph, position: Int32Array): number;
+//# sourceMappingURL=layout_orient_links.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout_orient_links.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_orient_links.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qEANW,UAAU,GACR,MAAM,CAkClB"}

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

@@ -0,0 +1,49 @@
+/**
+ * Turn every backwards link around, so that what is left is a directed acyclic graph.
+ *
+ * Every stage after this one — layering, ordering, coordinates — is written against a graph that
+ * flows one way, and none of them has a sensible answer for a cycle. Reversing the links the
+ * ordering stage identified as backwards is what makes that assumption true, and it is the whole
+ * reason {@link layout_break_cycles} runs first.
+ *
+ * The reversal is only a placement fiction. Nothing is drawn from the links: a wire is drawn
+ * between the two ports of its connection, which are unchanged, and it simply runs right to left.
+ * Which links were turned is therefore not worth recording — nothing downstream asks.
+ *
+ * @param {LayoutBoxGraph} graph mutated in place; adjacency is invalidated
+ * @param {Int32Array} position from {@link layout_break_cycles}
+ * @returns {number} how many links were turned
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function layout_orient_links(graph, position) {
+    const link_count = graph.link_count;
+
+    let reversed = 0;
+
+    for (let i = 0; i < link_count; i++) {
+        const from = graph.link_from[i];
+        const to = graph.link_to[i];
+
+        if (position[from] <= position[to]) {
+            continue;
+        }
+
+        graph.link_from[i] = to;
+        graph.link_to[i] = from;
+
+        const from_y = graph.link_from_y[i];
+
+        graph.link_from_y[i] = graph.link_to_y[i];
+        graph.link_to_y[i] = from_y;
+
+        reversed++;
+    }
+
+    if (reversed > 0) {
+        graph.build_adjacency();
+    }
+
+    return reversed;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * Route every wire, letting them argue over the space until they stop.
+ *
+ * This is negotiated congestion routing — PathFinder. Every wire is routed as if the lines other
+ * wires are on merely cost a little extra rather than being forbidden, and then the whole set is
+ * ripped up and routed again with the price raised. A wire that had somewhere else to go moves; a
+ * wire with nowhere else stays and the others give way around it. Repeat until nothing is shared.
+ *
+ * The reason to do it this way rather than routing wires one at a time and forbidding what is
+ * already taken is that forbidding makes the *order* decide the drawing. The first wire routed gets
+ * the straight line through the middle and everything after it detours, whether or not it was the
+ * one that needed it. Negotiation asks each wire how much it wants the space, by seeing which of
+ * them finds an alternative when the price goes up, and that question has an answer that does not
+ * depend on who was asked first.
+ *
+ * **History is what makes it settle.** Charging only for what is currently occupied makes two wires
+ * swap routes every round for ever, each taking the one the other has just left. A line that has
+ * been fought over stays expensive after it is vacated, so the second time round the pair separates
+ * instead of trading.
+ *
+ * **Only the wires in an argument are asked again.** After the first round, a wire whose route
+ * shares nothing with anybody has already got what it wanted and is left alone; the rounds after
+ * the first cost what the remaining conflicts cost rather than what the whole graph costs. Without
+ * this a graph whose wires nearly all fit spends five further rounds re-deriving the same routes,
+ * and the work grows as the square of the graph rather than with the trouble in it.
+ *
+ * **The wires leaving one port are one net, and share lines with each other for nothing.** They
+ * are one signal, and they leave the port along one stub whatever anybody does; charging them for
+ * running along the same line after it prices up the one thing they cannot help, every round,
+ * until they are pushed onto whichever line is left and pulled apart there in an order nobody
+ * chose — which is how a fan of six wires came to be drawn crossing itself. Left to share, they
+ * run out of the port as one line and fork where each of them leaves, which is a bus, and is what
+ * a fan of wires from one port looks like in any drawing done by hand. See
+ * {@link RouteGrid#owner_h}.
+ *
+ * **A long wire is routed through its lanes.** The placement gave every wire that crosses a column
+ * a lane in it — a point the ordering stage put where it crosses the fewest other wires and the
+ * coordinate stage lined up with the lanes either side of it — and a wire with lanes is routed as
+ * a chain of short searches, one per lane, each ending where the lane is and going through it
+ * horizontally. That is the placement's crossing-minimised order drawn, rather than left for the
+ * router to rediscover one wire at a time; and it is what makes a wire forty columns long cheap to
+ * route, where one search across the whole drawing floods the grid and gives up. A wire whose
+ * lanes cannot be reached is routed free, as a wire with no lanes always is.
+ *
+ * **Crossings are not an argument, and are settled afterwards.** Sharing a line is something the
+ * negotiation can price up until one wire leaves; crossing is allowed, merely costed, and a wire
+ * that crosses six others may have had no way not to. But the order the wires are first routed in
+ * hides most of the crossings from the wires that make them: a wire routed early sees an empty
+ * grid, takes whichever of its equal routes surfaces first, and is then crossed by everything
+ * routed after it — and since it shares nothing it is never asked again. So once nothing is shared,
+ * every wire something has been done to is asked once more, with all the others present, and moves
+ * only if the route it finds is cheaper than the one it has. That is a descent on the total cost
+ * of the drawing — a crossing costs both wires the same, so a wire making itself cheaper makes the
+ * whole cheaper — and it stops on its own when a round moves nothing.
+ *
+ * @see McMurchie, Ebeling — *PathFinder: A Negotiation-Based Performance-Driven Router for FPGAs*
+ *      (1995)
+ *
+ * @param {LayoutProblem} problem placement must be finished
+ * @param {RouteGrid} grid
+ * @param {NodeGraphLayoutOptions} options
+ * @returns {RouteSet}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function route_connections(problem: LayoutProblem, grid: RouteGrid, options: NodeGraphLayoutOptions): RouteSet;
+import { NodeGraphLayoutOptions } from "./NodeGraphLayoutOptions.js";
+import { RouteSet } from "./RouteSet.js";
+//# sourceMappingURL=route_connections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"route_connections.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/route_connections.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,oFANW,sBAAsB,GACpB,QAAQ,CA0GpB;uCA3KsC,6BAA6B;yBAE3C,eAAe"}