@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/layout/sugiyama/sugiyama.js

@@ -1,797 +0,0 @@
-"use strict";
-// Wave 7 (Auto-layout) — Card 1: the zero-config layered (Sugiyama) default.
-//
-// ---------------------------------------------------------------------------
-// WHY WE OWN THIS INSTEAD OF WRAPPING DAGRE
-// ---------------------------------------------------------------------------
-//
-// Card 1 asks for a clean layered DAG with no configuration, and says "wrap the
-// real dagre and ELK 'layered' engines behind it". We do keep those — dagre is
-// still registered and still the fastest path for a plain graph. But the DEFAULT
-// is this implementation, for one reason that Card 5 makes unavoidable:
-//
-//   SEMANTIC CONSTRAINTS CANNOT BE BOLTED ON FROM OUTSIDE.
-//
-// Today's constraint system (`ConstraintManager.applyConstraints`) takes a node id
-// and an ALREADY-COMPUTED position and clamps it. That is not a constraint system;
-// it is a post-hoc correction. A pinned node has no influence whatsoever on where
-// anything else goes — the layout runs as if it were free, and then the pin snaps
-// it back on top of whatever landed there. "Same rank as B", "left of C", "keep
-// this cluster together" cannot even be expressed that way: they are decisions
-// taken DURING ranking and ordering, and by the time you have coordinates the
-// information needed to honour them is gone.
-//
-// So the layered pipeline is ours, and constraints enter at the phase where they
-// belong. Everything here is pure, deterministic, and free of DOM/time/randomness.
-//
-// ---------------------------------------------------------------------------
-// THE PIPELINE (Sugiyama's four phases, plus the two everyone forgets)
-// ---------------------------------------------------------------------------
-//
-//   1. CYCLE BREAKING     DFS; reverse back-edges, remember them, restore at the end.
-//   2. RANK ASSIGNMENT    longest-path ranking, then tightened; same-rank constraints
-//                         are applied by contracting the graph BEFORE ranking (union-
-//                         find), which is the only way "A and B share a rank" can be
-//                         honoured rather than approximated.
-//   3. NORMALISATION      insert dummy nodes so every edge spans exactly one rank.
-//                         (The phase people skip — without it, crossing minimisation
-//                         cannot see long edges and coordinate assignment has no way
-//                         to bend them.)
-//   4. ORDERING           median heuristic sweeps + adjacent-transpose, keeping the
-//                         best crossing count seen. Relative-order constraints are
-//                         re-imposed after every sweep, so they survive the heuristic.
-//   5. COORDINATES        priority/median method: dummy chains are straightened first
-//                         (they are the long edges — a bent long edge is the ugliest
-//                         thing in a layered drawing), then real nodes pulled toward
-//                         the median of their neighbours, all within non-overlap.
-//   6. ORIENTATION        computed in TB space, then transformed for LR/BT/RL — one
-//                         algorithm, four directions, no duplicated maths.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sugiyama = sugiyama;
-exports.inferDirection = inferDirection;
-const DEFAULTS = {
-    direction: 'TB',
-    nodeSpacing: 50,
-    rankSpacing: 80,
-    iterations: 8,
-};
-function buildGraph(nodes, edges) {
-    const g = { nodes: new Map(), out: new Map(), in: new Map() };
-    // Sorted insert: the whole pipeline must be order-independent (Card 0's lesson —
-    // a seeded RNG does nothing if the graph is consumed in insertion order).
-    for (const n of [...nodes].sort((a, b) => (a.id < b.id ? -1 : 1))) {
-        g.nodes.set(n.id, n);
-        g.out.set(n.id, []);
-        g.in.set(n.id, []);
-    }
-    for (const e of [...edges].sort((a, b) => (a.id < b.id ? -1 : 1))) {
-        if (!g.nodes.has(e.source) || !g.nodes.has(e.target))
-            continue;
-        if (e.source === e.target)
-            continue; // self-loops do not participate in layering
-        g.out.get(e.source).push(e.target);
-        g.in.get(e.target).push(e.source);
-    }
-    return g;
-}
-/**
- * Phase 1 — cycle breaking.
- *
- * DFS; any edge back to a node on the current stack is a back-edge. Reverse it,
- * remember it, restore the direction at the end. (Reversing rather than deleting
- * matters: the edge still constrains the layout, it just constrains it the other
- * way, which is what makes a cyclic graph layer sensibly instead of losing edges.)
- */
-function breakCycles(g) {
-    var _a;
-    const reversed = new Set();
-    const state = new Map(); // 0 unseen, 1 on stack, 2 done
-    const visit = (v) => {
-        var _a;
-        state.set(v, 1);
-        for (const w of [...g.out.get(v)]) {
-            const s = (_a = state.get(w)) !== null && _a !== void 0 ? _a : 0;
-            if (s === 1) {
-                // back-edge: reverse it
-                reversed.add(`${v}->${w}`);
-                g.out.set(v, g.out.get(v).filter((x) => x !== w));
-                g.in.set(w, g.in.get(w).filter((x) => x !== v));
-                g.out.get(w).push(v);
-                g.in.get(v).push(w);
-            }
-            else if (s === 0) {
-                visit(w);
-            }
-        }
-        state.set(v, 2);
-    };
-    for (const id of g.nodes.keys())
-        if (((_a = state.get(id)) !== null && _a !== void 0 ? _a : 0) === 0)
-            visit(id);
-    return reversed;
-}
-/** Union-find, for same-rank contraction. */
-class UnionFind {
-    constructor() {
-        this.parent = new Map();
-    }
-    find(x) {
-        const p = this.parent.get(x);
-        if (p === undefined || p === x) {
-            this.parent.set(x, x);
-            return x;
-        }
-        const root = this.find(p);
-        this.parent.set(x, root);
-        return root;
-    }
-    union(a, b) {
-        const ra = this.find(a);
-        const rb = this.find(b);
-        if (ra !== rb)
-            this.parent.set(ra, rb);
-    }
-}
-/**
- * Phase 2 — rank assignment, with same-rank constraints honoured by CONTRACTION.
- *
- * This is the part a post-hoc clamp can never do. "A and B are on the same rank"
- * is a statement about the ranking, so the graph is contracted (A and B become one
- * super-node), the quotient graph is ranked, and every member of a class inherits
- * its class's rank. Rank them separately and then "correct" it afterwards and you
- * either break edge monotonicity or shove nodes on top of each other.
- *
- * Ranking itself is longest-path (every node sits one below its deepest
- * predecessor), which is O(V+E), always valid, and — unlike network simplex —
- * short enough to be obviously correct. It can leave slack on some edges; the
- * tightening pass below pulls sources down toward their consumers, which removes
- * most of the ugly ones.
- */
-function assignRanks(g, constraints) {
-    var _a, _b, _c;
-    const uf = new UnionFind();
-    for (const id of g.nodes.keys())
-        uf.find(id);
-    for (const group of (_a = constraints === null || constraints === void 0 ? void 0 : constraints.sameRank) !== null && _a !== void 0 ? _a : []) {
-        for (let i = 1; i < group.length; i++) {
-            if (g.nodes.has(group[0]) && g.nodes.has(group[i]))
-                uf.union(group[0], group[i]);
-        }
-    }
-    // quotient graph
-    const classOf = (id) => uf.find(id);
-    const classes = new Set([...g.nodes.keys()].map(classOf));
-    const qOut = new Map();
-    const qIn = new Map();
-    for (const c of classes) {
-        qOut.set(c, new Set());
-        qIn.set(c, new Set());
-    }
-    for (const [v, targets] of g.out) {
-        for (const w of targets) {
-            const cv = classOf(v);
-            const cw = classOf(w);
-            if (cv === cw)
-                continue; // an edge inside a same-rank class cannot constrain rank
-            qOut.get(cv).add(cw);
-            qIn.get(cw).add(cv);
-        }
-    }
-    // longest-path ranking over the quotient DAG (it IS a DAG: cycles were broken,
-    // and contraction of a DAG can only create cycles between classes if the user
-    // asked for something impossible — guarded below).
-    const rank = new Map();
-    const sorted = topoSort(classes, qOut, qIn);
-    for (const c of sorted) {
-        let r = 0;
-        for (const p of qIn.get(c))
-            r = Math.max(r, ((_b = rank.get(p)) !== null && _b !== void 0 ? _b : 0) + 1);
-        rank.set(c, r);
-    }
-    // Tightening: pull each node down to just above its tightest successor, so a
-    // source with one far-away consumer does not float at rank 0 for no reason.
-    for (const c of [...sorted].reverse()) {
-        const succ = [...qOut.get(c)];
-        if (succ.length === 0)
-            continue;
-        const minSucc = Math.min(...succ.map((s) => rank.get(s)));
-        if (minSucc - 1 > rank.get(c)) {
-            const preds = [...qIn.get(c)];
-            const maxPred = preds.length ? Math.max(...preds.map((p) => rank.get(p))) : -1;
-            rank.set(c, Math.max(maxPred + 1, minSucc - 1));
-        }
-    }
-    const out = new Map();
-    for (const id of g.nodes.keys())
-        out.set(id, (_c = rank.get(classOf(id))) !== null && _c !== void 0 ? _c : 0);
-    return out;
-}
-function topoSort(nodes, out, inn) {
-    const indeg = new Map();
-    for (const n of nodes)
-        indeg.set(n, inn.get(n).size);
-    // deterministic queue: always take the smallest id available
-    const ready = [...nodes].filter((n) => indeg.get(n) === 0).sort();
-    const order = [];
-    while (ready.length) {
-        const v = ready.shift();
-        order.push(v);
-        for (const w of [...out.get(v)].sort()) {
-            indeg.set(w, indeg.get(w) - 1);
-            if (indeg.get(w) === 0) {
-                ready.push(w);
-                ready.sort();
-            }
-        }
-    }
-    // A contracted cycle (the user demanded same-rank for nodes with a path between
-    // them) leaves nodes unranked. Rather than hang or silently drop them, append
-    // them in id order: the constraint is unsatisfiable and the layout degrades
-    // predictably instead of mysteriously.
-    for (const n of [...nodes].sort())
-        if (!order.includes(n))
-            order.push(n);
-    return order;
-}
-/**
- * Phase 3 — normalisation: no edge may span more than one rank.
- *
- * The phase most naive implementations skip, and the reason their long edges cut
- * through nodes: crossing minimisation only sees edges BETWEEN ADJACENT layers, so
- * an unsplit rank-0-to-rank-4 edge is invisible to it, and coordinate assignment
- * has nowhere to bend it.
- */
-function normalise(g, ranks, edges) {
-    const maxRank = Math.max(0, ...ranks.values());
-    const layers = Array.from({ length: maxRank + 1 }, () => []);
-    for (const [id, node] of g.nodes) {
-        layers[ranks.get(id)].push({ id, width: node.width, height: node.height, isDummy: false });
-    }
-    const chains = new Map();
-    let dummySeq = 0;
-    for (const e of [...edges].sort((a, b) => (a.id < b.id ? -1 : 1))) {
-        if (!g.nodes.has(e.source) || !g.nodes.has(e.target) || e.source === e.target)
-            continue;
-        const r1 = ranks.get(e.source);
-        const r2 = ranks.get(e.target);
-        const lo = Math.min(r1, r2);
-        const hi = Math.max(r1, r2);
-        if (hi - lo <= 1)
-            continue;
-        const chain = [];
-        for (let r = lo + 1; r < hi; r++) {
-            const did = `__dummy_${dummySeq++}`;
-            layers[r].push({ id: did, edgeId: e.id, width: 1, height: 1, isDummy: true });
-            chain.push(did);
-        }
-        chains.set(e.id, chain);
-    }
-    for (const layer of layers)
-        layer.sort((a, b) => (a.id < b.id ? -1 : 1));
-    return { layers, chains };
-}
-/** Adjacency between consecutive layers, including through dummy chains. */
-function layerAdjacency(g, ranks, edges, chains) {
-    var _a;
-    const adj = new Map();
-    const push = (a, b) => {
-        if (!adj.has(a))
-            adj.set(a, []);
-        if (!adj.has(b))
-            adj.set(b, []);
-        adj.get(a).push(b);
-        adj.get(b).push(a);
-    };
-    for (const e of [...edges].sort((a, b) => (a.id < b.id ? -1 : 1))) {
-        if (!g.nodes.has(e.source) || !g.nodes.has(e.target) || e.source === e.target)
-            continue;
-        const r1 = ranks.get(e.source);
-        const r2 = ranks.get(e.target);
-        const [top, bottom] = r1 <= r2 ? [e.source, e.target] : [e.target, e.source];
-        const chain = (_a = chains.get(e.id)) !== null && _a !== void 0 ? _a : [];
-        if (chain.length === 0) {
-            push(top, bottom);
-        }
-        else {
-            push(top, chain[0]);
-            for (let i = 1; i < chain.length; i++)
-                push(chain[i - 1], chain[i]);
-            push(chain[chain.length - 1], bottom);
-        }
-    }
-    return adj;
-}
-/**
- * Crossings between two adjacent layers, given their orders.
- *
- * Inversion counting via a Fenwick tree — O(k log w) for k inter-layer edge
- * endpoints. The obvious O(k²) double loop is exactly what melted down on the
- * sparse-DAG benchmark: ~1000-wide layers put thousands of endpoints between a
- * single pair of layers, and this function used to be called from inside the
- * per-swap loop of transpose. The count is exact and identical to the naive one.
- */
-function countCrossings(upper, lower, adj, stats) {
-    var _a;
-    const posLower = new Map(lower.map((n, i) => [n.id, i]));
-    const pairs = [];
-    for (const u of upper) {
-        const targets = ((_a = adj.get(u.id)) !== null && _a !== void 0 ? _a : [])
-            .filter((t) => posLower.has(t))
-            .map((t) => posLower.get(t))
-            .sort((a, b) => a - b);
-        pairs.push(...targets);
-    }
-    if (stats)
-        stats.crossingCountOps += pairs.length;
-    // count inversions: for each element, how many already-seen elements exceed it
-    const size = lower.length + 1;
-    const bit = new Array(size + 1).fill(0);
-    let crossings = 0;
-    let seen = 0;
-    for (const p of pairs) {
-        let leq = 0;
-        for (let idx = p + 1; idx > 0; idx -= idx & -idx)
-            leq += bit[idx];
-        crossings += seen - leq;
-        seen++;
-        for (let idx = p + 1; idx <= size; idx += idx & -idx)
-            bit[idx]++;
-    }
-    return crossings;
-}
-function totalCrossings(layers, adj, stats) {
-    let total = 0;
-    for (let i = 0; i + 1 < layers.length; i++)
-        total += countCrossings(layers[i], layers[i + 1], adj, stats);
-    return total;
-}
-/**
- * Phase 4 — ordering: median heuristic with adjacent transpose.
- *
- * Card 5's ORDER and KEEP-TOGETHER constraints are re-imposed after every sweep.
- * That is deliberate: the heuristic is free to explore, but it never gets to
- * publish an ordering that violates what the user asked for. (Imposing them only
- * once at the start would let the first sweep undo them.)
- */
-function orderLayers(layers, adj, constraints, iterations, stats) {
-    let best = layers.map((l) => [...l]);
-    enforceOrdering(best, constraints);
-    let bestCount = totalCrossings(best, adj, stats);
-    let current = best.map((l) => [...l]);
-    for (let iter = 0; iter < iterations; iter++) {
-        const downward = iter % 2 === 0;
-        const range = downward
-            ? [...Array(current.length).keys()].slice(1)
-            : [...Array(current.length).keys()].slice(0, -1).reverse();
-        for (const i of range) {
-            const fixed = downward ? current[i - 1] : current[i + 1];
-            const pos = new Map(fixed.map((n, idx) => [n.id, idx]));
-            const median = (n) => {
-                var _a;
-                const ns = ((_a = adj.get(n.id)) !== null && _a !== void 0 ? _a : []).filter((x) => pos.has(x)).map((x) => pos.get(x));
-                if (ns.length === 0)
-                    return -1; // keep un-connected nodes where they are
-                ns.sort((a, b) => a - b);
-                const m = ns.length >> 1;
-                return ns.length % 2 ? ns[m] : (ns[m - 1] + ns[m]) / 2;
-            };
-            const keyed = current[i].map((n, idx) => ({ n, m: median(n), idx }));
-            keyed.sort((a, b) => {
-                if (a.m === -1 && b.m === -1)
-                    return a.idx - b.idx;
-                if (a.m === -1)
-                    return -1;
-                if (b.m === -1)
-                    return 1;
-                return a.m - b.m || a.idx - b.idx; // stable: index breaks ties deterministically
-            });
-            current[i] = keyed.map((k) => k.n);
-        }
-        transpose(current, adj, stats);
-        enforceOrdering(current, constraints);
-        const count = totalCrossings(current, adj, stats);
-        if (count < bestCount) {
-            bestCount = count;
-            best = current.map((l) => [...l]);
-        }
-        current = best.map((l) => [...l]); // restart from the best, not from a worse local
-    }
-    return { layers: best, crossings: bestCount };
-}
-/**
- * Swap adjacent pairs while it reduces crossings — the cheap local fix the median misses.
- *
- * The decision for each candidate swap is INCREMENTAL, and that is the fix that
- * took the sparse-DAG benchmark from killed-at-25s to tens of milliseconds:
- * swapping adjacent u,v within a layer changes no pair of edges except those
- * between u's and v's own neighbours in the fixed lower layer, so
- *
- *   after - before = cross(v,u) - cross(u,v)
- *
- * where cross(a,b) = |{(p,q) : p ∈ pos(adj a), q ∈ pos(adj b), p > q}|. The old
- * code recounted EVERY crossing between the two layers twice per candidate
- * (O(E²) each, with E in the thousands on 1000-wide dummy-filled layers); this
- * computes the same accept/reject decision from the two nodes' sorted neighbour
- * positions in O(deg u + deg v). Same swaps, same final ordering, bounded work.
- */
-function transpose(layers, adj, stats) {
-    var _a;
-    let improved = true;
-    let guard = 0;
-    while (improved && guard++ < 8) {
-        improved = false;
-        stats.transposePasses++;
-        for (let i = 0; i + 1 < layers.length; i++) {
-            const upper = layers[i];
-            if (upper.length < 2)
-                continue;
-            const lower = layers[i + 1];
-            const posLower = new Map(lower.map((n, idx) => [n.id, idx]));
-            // Sorted lower-layer positions per upper node. Computed once per pass over
-            // this pair: the lower layer does not move while the upper one is being
-            // transposed, and swapping within `upper` cannot change them.
-            const down = new Map();
-            for (const u of upper) {
-                down.set(u.id, ((_a = adj.get(u.id)) !== null && _a !== void 0 ? _a : [])
-                    .filter((t) => posLower.has(t))
-                    .map((t) => posLower.get(t))
-                    .sort((a, b) => a - b));
-            }
-            for (let j = 0; j + 1 < upper.length; j++) {
-                stats.transposeSwapsEvaluated++;
-                const pu = down.get(upper[j].id);
-                const pv = down.get(upper[j + 1].id);
-                if (pu.length === 0 || pv.length === 0)
-                    continue; // swap cannot change crossings
-                // uv = crossings these two contribute with u left of v; vu = swapped.
-                // Two-pointer merge over the sorted position lists; ties (a shared
-                // neighbour) cross in neither order, exactly as in a full recount.
-                let uv = 0;
-                let vu = 0;
-                let below = 0; // pu entries strictly below the current q
-                let belowOrEq = 0; // pu entries at or below the current q
-                for (const q of pv) {
-                    while (below < pu.length && pu[below] < q)
-                        below++;
-                    while (belowOrEq < pu.length && pu[belowOrEq] <= q)
-                        belowOrEq++;
-                    vu += below;
-                    uv += pu.length - belowOrEq;
-                }
-                if (vu < uv) {
-                    [upper[j], upper[j + 1]] = [upper[j + 1], upper[j]];
-                    improved = true;
-                    stats.transposeSwapsApplied++;
-                }
-            }
-        }
-    }
-}
-/**
- * Card 5: re-impose relative order and keep-together, in place.
- *
- * Order constraints: a topological pass within each layer (a must precede b).
- * Keep-together: members of a cluster are gathered to the position of their
- * earliest member, preserving their relative order — the sweeps may reorder a
- * cluster internally, but may not split it.
- */
-function enforceOrdering(layers, constraints) {
-    var _a, _b;
-    if (!constraints)
-        return;
-    for (const layer of layers) {
-        const index = new Map(layer.map((n, i) => [n.id, i]));
-        // keep-together: pull cluster members adjacent to their earliest member
-        for (const cluster of (_a = constraints.keepTogether) !== null && _a !== void 0 ? _a : []) {
-            const present = cluster.filter((id) => index.has(id));
-            if (present.length < 2)
-                continue;
-            const anchor = Math.min(...present.map((id) => index.get(id)));
-            const members = present
-                .map((id) => layer[index.get(id)])
-                .sort((a, b) => index.get(a.id) - index.get(b.id));
-            const rest = layer.filter((n) => !present.includes(n.id));
-            const head = rest.slice(0, anchor);
-            const tail = rest.slice(anchor);
-            layer.length = 0;
-            layer.push(...head, ...members, ...tail);
-            index.clear();
-            layer.forEach((n, i) => index.set(n.id, i));
-        }
-        // relative order: bubble until every (a before b) holds. Bounded — an
-        // unsatisfiable cycle of constraints degrades rather than hangs.
-        const pairs = ((_b = constraints.order) !== null && _b !== void 0 ? _b : []).filter(([a, b]) => index.has(a) && index.has(b));
-        for (let guard = 0; guard < pairs.length * layer.length + 1; guard++) {
-            let violated = false;
-            for (const [a, b] of pairs) {
-                const ia = layer.findIndex((n) => n.id === a);
-                const ib = layer.findIndex((n) => n.id === b);
-                if (ia > ib) {
-                    const [moved] = layer.splice(ia, 1);
-                    layer.splice(ib, 0, moved);
-                    violated = true;
-                }
-            }
-            if (!violated)
-                break;
-        }
-    }
-}
-/**
- * Phase 5 — coordinate assignment (priority / median method).
- *
- * Dummy chains get the HIGHEST priority, and that is the single most important
- * decision in this function: a dummy chain IS a long edge, and a long edge that
- * zig-zags is the ugliest artefact a layered drawing can have. Straighten those
- * first, then let real nodes drift toward the median of their neighbours in
- * whatever room is left.
- *
- * Card 5's ANCHORS enter here with priority above everything: an anchored node
- * does not move, and — crucially, unlike the old clamp — everything else is laid
- * out AROUND it, because the non-overlap pass sees the anchor as an immovable
- * obstacle rather than discovering it afterwards.
- */
-function assignCoordinates(layers, adj, nodeSpacing, constraints, iterations) {
-    var _a, _b;
-    const x = new Map();
-    // initial packing, left to right
-    for (const layer of layers) {
-        let cx = 0;
-        for (const n of layer) {
-            x.set(n.id, cx + n.width / 2);
-            cx += n.width + nodeSpacing;
-        }
-    }
-    const anchors = (_a = constraints === null || constraints === void 0 ? void 0 : constraints.anchors) !== null && _a !== void 0 ? _a : {};
-    const isAnchored = (id) => { var _a; return ((_a = anchors[id]) === null || _a === void 0 ? void 0 : _a.x) !== undefined; };
-    for (const [id, a] of Object.entries(anchors)) {
-        if (a.x !== undefined)
-            x.set(id, a.x);
-    }
-    const priority = (n) => {
-        var _a;
-        if (isAnchored(n.id))
-            return 1e9; // immovable
-        if (n.isDummy)
-            return 1e6; // straighten long edges before anything else
-        return ((_a = adj.get(n.id)) !== null && _a !== void 0 ? _a : []).length; // then by degree
-    };
-    // Layer ORDER is frozen in this phase (only x moves), so membership sets,
-    // in-layer indices and the priority order are computed once, not per sweep —
-    // the `some()`/`findIndex()` scans they replace were O(width²) per layer per
-    // iteration, which a 1000-wide dummy-filled layer turns into real seconds.
-    const idSet = layers.map((l) => new Set(l.map((n) => n.id)));
-    const indexIn = layers.map((l) => new Map(l.map((n, i) => [n.id, i])));
-    const byPriorityIn = layers.map((l) => [...l].sort((a, b) => priority(b) - priority(a) || (a.id < b.id ? -1 : 1)));
-    for (let iter = 0; iter < iterations; iter++) {
-        const downward = iter % 2 === 0;
-        const order = downward
-            ? [...Array(layers.length).keys()]
-            : [...Array(layers.length).keys()].reverse();
-        for (const li of order) {
-            const layer = layers[li];
-            const ni = downward ? li - 1 : li + 1;
-            const neighbourLayer = layers[ni];
-            if (!neighbourLayer)
-                continue;
-            const neighbourIds = idSet[ni];
-            const desired = new Map();
-            for (const n of layer) {
-                const ns = ((_b = adj.get(n.id)) !== null && _b !== void 0 ? _b : []).filter((m) => neighbourIds.has(m));
-                if (ns.length === 0)
-                    continue;
-                const xs = ns.map((m) => x.get(m)).sort((a, b) => a - b);
-                const mid = xs.length >> 1;
-                desired.set(n.id, xs.length % 2 ? xs[mid] : (xs[mid - 1] + xs[mid]) / 2);
-            }
-            // Move nodes toward their desired x in priority order, never violating
-            // non-overlap with already-placed (higher-priority) neighbours.
-            const byPriority = byPriorityIn[li];
-            const placed = new Set();
-            for (const n of byPriority) {
-                placed.add(n.id);
-                if (isAnchored(n.id))
-                    continue;
-                const want = desired.get(n.id);
-                if (want === undefined)
-                    continue;
-                const idx = indexIn[li].get(n.id);
-                // left bound: the nearest placed node to the left
-                let lo = -Infinity;
-                for (let k = idx - 1; k >= 0; k--) {
-                    if (placed.has(layer[k].id)) {
-                        lo = x.get(layer[k].id) + layer[k].width / 2 + nodeSpacing + n.width / 2;
-                        break;
-                    }
-                }
-                let hi = Infinity;
-                for (let k = idx + 1; k < layer.length; k++) {
-                    if (placed.has(layer[k].id)) {
-                        hi = x.get(layer[k].id) - layer[k].width / 2 - nodeSpacing - n.width / 2;
-                        break;
-                    }
-                }
-                x.set(n.id, Math.max(lo, Math.min(hi, want)));
-            }
-            // A final left-to-right sweep guarantees non-overlap even where the bounds
-            // above were both infinite (a layer whose nodes all wanted the same spot).
-            for (let k = 1; k < layer.length; k++) {
-                const prev = layer[k - 1];
-                const cur = layer[k];
-                const minX = x.get(prev.id) + prev.width / 2 + nodeSpacing + cur.width / 2;
-                if (x.get(cur.id) < minX && !isAnchored(cur.id))
-                    x.set(cur.id, minX);
-            }
-        }
-    }
-    return x;
-}
-// ---------------------------------------------------------------------------
-/**
- * Lay out a graph in layers. Pure, deterministic, no DOM, no time, no randomness.
- */
-function sugiyama(nodes, edges, options = {}) {
-    var _a, _b, _c, _d, _e, _f;
-    const direction = (_a = options.direction) !== null && _a !== void 0 ? _a : DEFAULTS.direction;
-    const nodeSpacing = (_b = options.nodeSpacing) !== null && _b !== void 0 ? _b : DEFAULTS.nodeSpacing;
-    const rankSpacing = (_c = options.rankSpacing) !== null && _c !== void 0 ? _c : DEFAULTS.rankSpacing;
-    const iterations = (_d = options.iterations) !== null && _d !== void 0 ? _d : DEFAULTS.iterations;
-    const constraints = options.constraints;
-    const stats = {
-        dummyCount: 0,
-        layerCount: 0,
-        maxLayerWidth: 0,
-        transposePasses: 0,
-        transposeSwapsEvaluated: 0,
-        transposeSwapsApplied: 0,
-        crossingCountOps: 0,
-    };
-    if (nodes.length === 0) {
-        return { positions: new Map(), ranks: new Map(), bends: new Map(), crossings: 0, stats };
-    }
-    // In LR/RL the roles of the axes swap. Rather than write the algorithm twice,
-    // lay out in TB space using the node's CROSS-AXIS extent as its "width", then
-    // transform at the end.
-    const vertical = direction === 'TB' || direction === 'BT';
-    const measured = nodes.map((n) => ({
-        id: n.id,
-        width: vertical ? n.width : n.height,
-        height: vertical ? n.height : n.width,
-    }));
-    // ANCHORS LIVE IN WORLD SPACE; the pipeline runs in TB space.
-    //
-    // The algorithm has exactly one free axis — the IN-LAYER coordinate — because the
-    // other one IS the rank, and rank comes from the graph, not from the caller. In TB
-    // the in-layer axis is world-x; in LR it is world-y. Handing `anchor.x` straight to
-    // the coordinate pass therefore pins the wrong axis the moment direction inference
-    // picks LR — and it does that for exactly the graphs (long chains) where a user is
-    // most likely to be nudging nodes around. Caught by the region test: the x anchors
-    // held perfectly and every node still slid 385px down the page.
-    const tbConstraints = constraints
-        ? Object.assign(Object.assign({}, constraints), { anchors: Object.fromEntries(Object.entries((_e = constraints.anchors) !== null && _e !== void 0 ? _e : {}).map(([id, a]) => [
-                id,
-                vertical ? { x: a.x, y: a.y } : { x: a.y, y: a.x },
-            ])) }) : undefined;
-    const g = buildGraph(measured, edges);
-    const reversed = breakCycles(g);
-    const ranks = assignRanks(g, tbConstraints);
-    const { layers, chains } = normalise(g, ranks, edges);
-    const adj = layerAdjacency(g, ranks, edges, chains);
-    stats.dummyCount = [...chains.values()].reduce((s, c) => s + c.length, 0);
-    stats.layerCount = layers.length;
-    stats.maxLayerWidth = Math.max(0, ...layers.map((l) => l.length));
-    const { layers: ordered, crossings } = orderLayers(layers, adj, tbConstraints, iterations, stats);
-    const xs = assignCoordinates(ordered, adj, nodeSpacing, tbConstraints, iterations);
-    // rank -> y (TB space).
-    //
-    // Normally a layer is stacked below the previous one by its tallest node plus the
-    // rank spacing. But an ANCHORED node also pins the RANK axis, and honouring that
-    // is what makes "pin these nodes" exact rather than approximate:
-    //
-    //   The in-layer axis is the only one coordinate assignment is free to choose —
-    //   the other one IS the rank, derived from the graph. So without this, a pinned
-    //   node keeps its in-layer coordinate and still slides along the rank axis
-    //   whenever the layer heights or the rank spacing differ by a pixel — which they
-    //   always do the moment a different engine produced the previous layout. The
-    //   nodes were "pinned" and moved anyway, which reads as the pins not working.
-    //
-    // So: if a layer contains anchored nodes, the LAYER sits where they say it does
-    // (their median rank-axis coordinate). Monotonicity and non-overlap between layers
-    // are then re-imposed, because an anchor may not reorder the ranks — rank is the
-    // graph's decision, not the caller's.
-    const anchorY = (_f = tbConstraints === null || tbConstraints === void 0 ? void 0 : tbConstraints.anchors) !== null && _f !== void 0 ? _f : {};
-    const rawLayerY = ordered.map((layer) => {
-        const pinned = layer
-            .map((n) => { var _a; return (_a = anchorY[n.id]) === null || _a === void 0 ? void 0 : _a.y; })
-            .filter((v) => typeof v === 'number');
-        if (pinned.length === 0)
-            return undefined;
-        pinned.sort((a, b) => a - b);
-        return pinned[pinned.length >> 1];
-    });
-    const layerY = [];
-    let y = 0;
-    ordered.forEach((layer, i) => {
-        const h = Math.max(0, ...layer.map((n) => n.height));
-        const pinnedY = rawLayerY[i];
-        const stacked = y + h / 2;
-        // A pinned layer sits where its anchors say — but never above the layer before
-        // it, because that would invert the ranking the graph demands.
-        const chosen = pinnedY !== undefined ? Math.max(pinnedY, stacked) : stacked;
-        layerY.push(chosen);
-        y = chosen + h / 2 + rankSpacing;
-    });
-    const totalHeight = Math.max(0, y - rankSpacing);
-    const positions = new Map();
-    const bends = new Map();
-    const place = (id, tx, ty) => {
-        // Transform TB-space (tx, ty) into the requested direction.
-        switch (direction) {
-            case 'TB':
-                return { x: tx, y: ty };
-            case 'BT':
-                return { x: tx, y: totalHeight - ty };
-            case 'LR':
-                return { x: ty, y: tx };
-            case 'RL':
-                return { x: totalHeight - ty, y: tx };
-        }
-    };
-    // first-match maps, mirroring the .find() semantics they replace
-    const nodeById = new Map();
-    for (const n of nodes)
-        if (!nodeById.has(n.id))
-            nodeById.set(n.id, n);
-    ordered.forEach((layer, li) => {
-        var _a;
-        for (const n of layer) {
-            const p = place(n.id, xs.get(n.id), layerY[li]);
-            if (n.isDummy) {
-                const list = (_a = bends.get(n.edgeId)) !== null && _a !== void 0 ? _a : [];
-                list.push(p);
-                bends.set(n.edgeId, list);
-            }
-            else {
-                const original = nodeById.get(n.id);
-                // positions are TOP-LEFT (the model's convention), not centres
-                positions.set(n.id, { x: p.x - original.width / 2, y: p.y - original.height / 2 });
-            }
-        }
-    });
-    // Restore the edges we reversed for cycle-breaking, so bend chains read in the
-    // author's direction rather than the algorithm's.
-    const edgeById = new Map();
-    for (const e of edges)
-        if (!edgeById.has(e.id))
-            edgeById.set(e.id, e);
-    for (const [edgeId, list] of bends) {
-        const e = edgeById.get(edgeId);
-        if (e && reversed.has(`${e.target}->${e.source}`))
-            bends.set(edgeId, [...list].reverse());
-    }
-    return { positions, ranks, bends, crossings, stats };
-}
-/**
- * Card 1: DIRECTION INFERENCE — "TB for trees, LR for pipelines".
- *
- * The heuristic, stated so it can be argued with: a graph that is deep and narrow
- * reads better across the page (a pipeline: A → B → C → D as a row, not a column),
- * and a graph that is wide and shallow reads better down it (a tree fans out).
- * The threshold is the aspect of the LAYER structure, not of the node count.
- */
-function inferDirection(nodes, edges) {
-    var _a;
-    if (nodes.length === 0)
-        return 'TB';
-    const g = buildGraph(nodes, edges);
-    breakCycles(g);
-    const ranks = assignRanks(g, undefined);
-    const depth = Math.max(0, ...ranks.values()) + 1;
-    const widths = new Map();
-    for (const r of ranks.values())
-        widths.set(r, ((_a = widths.get(r)) !== null && _a !== void 0 ? _a : 0) + 1);
-    const maxWidth = Math.max(1, ...widths.values());
-    // Deep and narrow => a chain/pipeline => lay it out left-to-right.
-    return depth >= 4 && maxWidth <= 2 ? 'LR' : 'TB';
-}
-//# sourceMappingURL=sugiyama.js.map