@woosh/meep-engine 3.28.0 → 3.29.0

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.d.ts

@@ -0,0 +1,22 @@
+/**
+ * How many wedges a mesh still has — how many vertices it would ship.
+ *
+ * Not `vertices.count()`, and the difference is the whole of what a wedge is for: a vertex whose
+ * corners shade two ways is two vertices to anything that carries a value per vertex, which is every
+ * meshlet, every vertex buffer and every renderer ever written. A caller sizing against that limit
+ * has to ask this rather than the pool.
+ *
+ * Counted off the per-vertex lists rather than from {@link BtWedgeSet#count}, because that one
+ * includes every id ever handed out and a collapse merges them away. Vertices the pool has released
+ * are skipped, so a sweep that removed faceless vertices without touching the wedge set is accounted
+ * for.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {BtWedgeSet} wedges
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_live_count(mesh: BinaryTopology, wedges: BtWedgeSet): number;
+//# sourceMappingURL=bt_wedges_live_count.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_wedges_live_count.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gFALa,MAAM,CA4BlB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.js

@@ -0,0 +1,46 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * How many wedges a mesh still has — how many vertices it would ship.
+ *
+ * Not `vertices.count()`, and the difference is the whole of what a wedge is for: a vertex whose
+ * corners shade two ways is two vertices to anything that carries a value per vertex, which is every
+ * meshlet, every vertex buffer and every renderer ever written. A caller sizing against that limit
+ * has to ask this rather than the pool.
+ *
+ * Counted off the per-vertex lists rather than from {@link BtWedgeSet#count}, because that one
+ * includes every id ever handed out and a collapse merges them away. Vertices the pool has released
+ * are skipped, so a sweep that removed faceless vertices without touching the wedge set is accounted
+ * for.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {BtWedgeSet} wedges
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_live_count(mesh, wedges) {
+    const vertex_pool = mesh.vertices;
+
+    const first_of_vertex = wedges.first_of_vertex;
+    const next_of_wedge = wedges.next_of_wedge;
+
+    let count = 0;
+
+    for (let vertex = 0; vertex < vertex_pool.size; vertex++) {
+        if (!vertex_pool.is_allocated(vertex)) {
+            continue;
+        }
+
+        for (
+            let wedge = first_of_vertex[vertex];
+            wedge !== NULL_POINTER;
+            wedge = next_of_wedge[wedge]
+        ) {
+            count++;
+        }
+    }
+
+    return count;
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The wedge set of a mesh with no appearance seams: one wedge per vertex, and its id *is* the
+ * vertex id.
+ *
+ * The degenerate case, and worth having a name because it is what everything that does not carry
+ * appearance wants. A caller whose per-vertex arrays are indexed by vertex id can hand this to
+ * {@link bt_mesh_simplify_with_quadrics} and keep indexing them by vertex id, because here the two
+ * are the same number. Nothing requires wedge ids to be dense — only to be distinct — which is what
+ * lets that be true.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {BtWedgeSet}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_per_vertex(mesh: BinaryTopology): BtWedgeSet;
+import { BtWedgeSet } from "../BtWedgeSet.js";
+//# sourceMappingURL=bt_wedges_per_vertex.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_wedges_per_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,4DALa,UAAU,CAkCtB;2BA/C0B,kBAAkB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.js

@@ -0,0 +1,49 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { BtWedgeSet } from "../BtWedgeSet.js";
+
+/**
+ * The wedge set of a mesh with no appearance seams: one wedge per vertex, and its id *is* the
+ * vertex id.
+ *
+ * The degenerate case, and worth having a name because it is what everything that does not carry
+ * appearance wants. A caller whose per-vertex arrays are indexed by vertex id can hand this to
+ * {@link bt_mesh_simplify_with_quadrics} and keep indexing them by vertex id, because here the two
+ * are the same number. Nothing requires wedge ids to be dense — only to be distinct — which is what
+ * lets that be true.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {BtWedgeSet}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_per_vertex(mesh) {
+    const vertex_pool = mesh.vertices;
+    const loop_pool = mesh.loops;
+
+    const result = new BtWedgeSet();
+
+    result.count = vertex_pool.size;
+
+    result.parent = new Uint32Array(vertex_pool.size);
+    result.next_of_wedge = new Uint32Array(vertex_pool.size).fill(NULL_POINTER);
+    result.first_of_vertex = new Uint32Array(vertex_pool.size).fill(NULL_POINTER);
+
+    for (let vertex = 0; vertex < vertex_pool.size; vertex++) {
+        result.parent[vertex] = vertex;
+
+        if (vertex_pool.is_allocated(vertex)) {
+            result.first_of_vertex[vertex] = vertex;
+        }
+    }
+
+    result.of_loop = new Uint32Array(loop_pool.size).fill(NULL_POINTER);
+
+    for (let loop = 0; loop < loop_pool.size; loop++) {
+        if (loop_pool.is_allocated(loop)) {
+            result.of_loop[loop] = mesh.loop_read_vertex(loop);
+        }
+    }
+
+    return result;
+}

package/src/core/graph/layout/layered/BoxLayoutOptions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Every number the placement is allowed to be tuned by.
+ *
+ * They live in one place because they are not independent: the room a wire lane has in a column is
+ * set against the gap between two boxes, and the room every wire crossing a column boundary has to
+ * share is `layer_gap`. Somebody changing one of these needs to see the others.
+ *
+ * What is *not* here is anything about the thing being drawn. These are the spacings a drawing is
+ * laid out at — how far apart two boxes have to be before they read as separate — which is the one
+ * part of a layout the display legitimately decides. Everything else the layout works out for
+ * itself.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BoxLayoutOptions {
+    /**
+     * @template {BoxLayoutOptions} T
+     * @this {function(new: T)}
+     * @param {Partial<T>} [overrides]
+     * @returns {T}
+     */
+    static from<T extends BoxLayoutOptions>(this: new () => T, overrides?: Partial<T>): T;
+    /**
+     * Horizontal gap between one column of boxes and the next.
+     *
+     * This is the width of the channel every edge crossing that boundary has to share, so it is
+     * also what limits how many wires can run side by side without one of them having to detour.
+     *
+     * @type {number}
+     */
+    layer_gap: number;
+    /**
+     * Vertical gap between two node boxes sharing a column.
+     * @type {number}
+     */
+    node_gap: number;
+    /**
+     * Vertical room reserved for one wire passing through a column it does not stop at.
+     *
+     * An edge spanning several columns gets a lane of this height in each one it crosses, which is
+     * what keeps a long edge from being drawn over the boxes it passes.
+     *
+     * @type {number}
+     */
+    wire_gap: number;
+    /**
+     * How far outside a box a wire is ever drawn, which is also the least room a lane needs beside
+     * one.
+     *
+     * A wire on the box boundary reads as touching it. For a caller that routes its wires this is
+     * the same line the router runs them along, and the first place a wire leaving a port may turn.
+     *
+     * @type {number}
+     */
+    clearance: number;
+    /**
+     * Ordering passes over the columns.
+     * @type {number}
+     */
+    order_sweeps: number;
+}
+//# sourceMappingURL=BoxLayoutOptions.d.ts.map

package/src/core/graph/layout/layered/BoxLayoutOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoxLayoutOptions.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/layered/BoxLayoutOptions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH;IA6CI;;;;;OAKG;IACH,sFAYC;IA7DD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;;OAQG;IACH,WAFU,MAAM,CAED;IAEf;;;OAGG;IACH,cAFU,MAAM,CAEC;CAqBpB"}

package/src/core/graph/layout/layered/BoxLayoutOptions.js

@@ -0,0 +1,80 @@
+/**
+ * Every number the placement is allowed to be tuned by.
+ *
+ * They live in one place because they are not independent: the room a wire lane has in a column is
+ * set against the gap between two boxes, and the room every wire crossing a column boundary has to
+ * share is `layer_gap`. Somebody changing one of these needs to see the others.
+ *
+ * What is *not* here is anything about the thing being drawn. These are the spacings a drawing is
+ * laid out at — how far apart two boxes have to be before they read as separate — which is the one
+ * part of a layout the display legitimately decides. Everything else the layout works out for
+ * itself.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BoxLayoutOptions {
+
+    /**
+     * Horizontal gap between one column of boxes and the next.
+     *
+     * This is the width of the channel every edge crossing that boundary has to share, so it is
+     * also what limits how many wires can run side by side without one of them having to detour.
+     *
+     * @type {number}
+     */
+    layer_gap = 140;
+
+    /**
+     * Vertical gap between two node boxes sharing a column.
+     * @type {number}
+     */
+    node_gap = 44;
+
+    /**
+     * Vertical room reserved for one wire passing through a column it does not stop at.
+     *
+     * An edge spanning several columns gets a lane of this height in each one it crosses, which is
+     * what keeps a long edge from being drawn over the boxes it passes.
+     *
+     * @type {number}
+     */
+    wire_gap = 20;
+
+    /**
+     * How far outside a box a wire is ever drawn, which is also the least room a lane needs beside
+     * one.
+     *
+     * A wire on the box boundary reads as touching it. For a caller that routes its wires this is
+     * the same line the router runs them along, and the first place a wire leaving a port may turn.
+     *
+     * @type {number}
+     */
+    clearance = 24;
+
+    /**
+     * Ordering passes over the columns.
+     * @type {number}
+     */
+    order_sweeps = 8;
+
+    /**
+     * @template {BoxLayoutOptions} T
+     * @this {function(new: T)}
+     * @param {Partial<T>} [overrides]
+     * @returns {T}
+     */
+    static from(overrides) {
+        const r = new this();
+
+        if (overrides !== undefined) {
+            for (const key in overrides) {
+                if (key in r) {
+                    r[key] = overrides[key];
+                }
+            }
+        }
+
+        return r;
+    }
+}

package/src/core/{model/node-graph/visual/layout → graph/layout/layered}/LayoutBoxGraph.d.ts

@@ -71,6 +71,41 @@ export class LayoutBoxGraph {
      * @type {Uint8Array}
      */
     box_kind: Uint8Array;
+    /**
+     * Links to something that is not in this graph at all, counted per box.
+     *
+     * A caller laying a drawing out in pieces — a group at a time, each piece entering its parent as
+     * a single box — has boxes joined to boxes in another piece. Such a link is not drawn here and
+     * cannot constrain anything here, but it is the only thing saying which side of the piece its box
+     * belongs near: a box read only from outside has nothing inside pulling it to the right, and
+     * without this it settles against whatever it happens to touch internally while the wire leaving
+     * it crosses the whole piece to get out.
+     *
+     * Layering reads them, as degrees — see {@link layout_assign_layers}. Cycle breaking deliberately
+     * does not: a box that nothing *here* depends on is a source here, whatever is waiting on it
+     * elsewhere.
+     *
+     * Zero unless the caller says otherwise, which is the whole graph in one piece.
+     *
+     * @type {Int32Array}
+     */
+    box_external_in: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    box_external_out: Int32Array;
+    /**
+     * Extra room this box wants from whatever shares its column, beyond the gap its kind implies.
+     *
+     * Zero for an ordinary box: the gap between two boxes is what says how far apart they have to be
+     * before they read as separate, and it is the same everywhere. It is a box drawn as a *frame*
+     * around other boxes that needs more — two frames meeting at a hairline read as one region
+     * rather than as two that happen to be adjacent, and the padding inside a frame cannot say so,
+     * because it is inside.
+     *
+     * @type {Float64Array}
+     */
+    box_margin: Float64Array;
     /**
      * @type {number}
      */

package/src/core/graph/layout/layered/LayoutBoxGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutBoxGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/layered/LayoutBoxGraph.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;;;;;;GAQG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA+HI;;;OAGG;IACH,wBAHW,MAAM,eACN,MAAM,EAIhB;IAnID;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,YAAY,CAEhB;IAEN;;;OAGG;IACH,WAFU,UAAU,CAEV;IAEV;;;OAGG;IACH,UAFU,UAAU,CAEX;IAET;;;;;;;;;;;;;;;;;OAiBG;IACH,iBAFU,UAAU,CAEJ;IAEhB;;OAEG;IACH,kBAFU,UAAU,CAEH;IAEjB;;;;;;;;;;OAUG;IACH,YAFU,YAAY,CAEX;IAEX;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,SAFU,UAAU,CAEZ;IAER;;;OAGG;IACH,aAFU,YAAY,CAEV;IAEZ;;;OAGG;IACH,WAFU,YAAY,CAEZ;IAEV;;;OAGG;IACH,YAFU,UAAU,CAET;IAEX;;OAEG;IACH,UAFU,UAAU,CAEX;IAET;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,SAFU,UAAU,CAEZ;IAUR;;;;;;;;;OASG;IACH,kBAJW,MAAM,cACN,MAAM,GACJ,IAAI,CAsChB;IAED;;;;;;OAMG;IACH,eANW,MAAM,SACN,MAAM,UACN,MAAM,QACN,MAAM,GACJ,IAAI,CAMhB;IAED;;;;;;;OAOG;IACH,gBAPW,MAAM,QACN,MAAM,MACN,MAAM,UACN,MAAM,QACN,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;OAQG;IACH,mBAFa,IAAI,CAsChB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;CACJ"}

package/src/core/{model/node-graph/visual/layout → graph/layout/layered}/LayoutBoxGraph.js

@@ -1,4 +1,4 @@
-import { assert } from "../../../../assert.js";
+import { assert } from "../../../assert.js";
 
 /**
  * A box standing for a node of the graph.
@@ -78,6 +78,44 @@ export class LayoutBoxGraph {
      */
     box_kind;
 
+    /**
+     * Links to something that is not in this graph at all, counted per box.
+     *
+     * A caller laying a drawing out in pieces — a group at a time, each piece entering its parent as
+     * a single box — has boxes joined to boxes in another piece. Such a link is not drawn here and
+     * cannot constrain anything here, but it is the only thing saying which side of the piece its box
+     * belongs near: a box read only from outside has nothing inside pulling it to the right, and
+     * without this it settles against whatever it happens to touch internally while the wire leaving
+     * it crosses the whole piece to get out.
+     *
+     * Layering reads them, as degrees — see {@link layout_assign_layers}. Cycle breaking deliberately
+     * does not: a box that nothing *here* depends on is a source here, whatever is waiting on it
+     * elsewhere.
+     *
+     * Zero unless the caller says otherwise, which is the whole graph in one piece.
+     *
+     * @type {Int32Array}
+     */
+    box_external_in;
+
+    /**
+     * @type {Int32Array}
+     */
+    box_external_out;
+
+    /**
+     * Extra room this box wants from whatever shares its column, beyond the gap its kind implies.
+     *
+     * Zero for an ordinary box: the gap between two boxes is what says how far apart they have to be
+     * before they read as separate, and it is the same everywhere. It is a box drawn as a *frame*
+     * around other boxes that needs more — two frames meeting at a hairline read as one region
+     * rather than as two that happen to be adjacent, and the padding inside a frame cannot say so,
+     * because it is inside.
+     *
+     * @type {Float64Array}
+     */
+    box_margin;
+
     /**
      * @type {number}
      */
@@ -148,12 +186,26 @@ export class LayoutBoxGraph {
         assert.isNonNegativeInteger(box_count, 'box_count');
         assert.isNonNegativeInteger(link_count, 'link_count');
 
+        const previous = this.box_count;
+
         this.box_x = grow(this.box_x, box_count, Float64Array);
         this.box_y = grow(this.box_y, box_count, Float64Array);
         this.box_w = grow(this.box_w, box_count, Float64Array);
         this.box_h = grow(this.box_h, box_count, Float64Array);
         this.box_layer = grow(this.box_layer, box_count, Int32Array);
         this.box_kind = grow(this.box_kind, box_count, Uint8Array);
+        this.box_external_in = grow(this.box_external_in, box_count, Int32Array);
+        this.box_external_out = grow(this.box_external_out, box_count, Int32Array);
+        this.box_margin = grow(this.box_margin, box_count, Float64Array);
+
+        // Nothing sets these per box the way `set_box` sets the others, so a box appearing here for
+        // the first time — a lane, when the layering stage grows the graph — has to arrive at zero
+        // rather than at whatever a longer previous use of the same arrays left behind.
+        if (box_count > previous) {
+            this.box_external_in.fill(0, previous, box_count);
+            this.box_external_out.fill(0, previous, box_count);
+            this.box_margin.fill(0, previous, box_count);
+        }
 
         this.link_from = grow(this.link_from, link_count, Int32Array);
         this.link_to = grow(this.link_to, link_count, Int32Array);

package/src/core/graph/layout/layered/layout_assign_coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout_assign_coordinates.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/layered/layout_assign_coordinates.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,8EAVW,MAAM,SACN,UAAU,QACV,UAAU,eACV,UAAU,oCAER;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAgC3C"}

package/src/core/{model/node-graph/visual/layout → graph/layout/layered}/layout_assign_coordinates.js

@@ -347,13 +347,13 @@ function align(graph, layer_count, order, rank, layer_start, neighbours, marked,
  * Push the blocks of one pass as far towards the top as the boxes below them allow, and read off a
  * coordinate for every box.
  *
- * First place blocks relative to the sink of their class, then solve the separation constraints
- * between classes. A class above another must carry that neighbour's final shift: treating a
- * relative shift as absolute can move the lower class into the upper one. These constraints form
- * a DAG, so a topological pass propagates every shift before the classes depending on it are placed.
- * Both stages take linear time and preserve the port offsets within each block.
- *
- * @see https://arxiv.org/abs/2008.01252 — Brandes, Walter, Zink, correction to shift accumulation
+ * First place blocks relative to the sink of their class, then solve the separation constraints
+ * between classes. A class above another must carry that neighbour's final shift: treating a
+ * relative shift as absolute can move the lower class into the upper one. These constraints form
+ * a DAG, so a topological pass propagates every shift before the classes depending on it are placed.
+ * Both stages take linear time and preserve the port offsets within each block.
+ *
+ * @see https://arxiv.org/abs/2008.01252 — Brandes, Walter, Zink, correction to shift accumulation
  *
  * @param {LayoutBoxGraph} graph
  * @param {Int32Array} order
@@ -394,7 +394,11 @@ function compact(graph, order, rank, layer_start, block, options) {
 
         const gap = lanes === 2 ? options.wire_gap : lanes === 1 ? lane_to_box : options.node_gap;
 
-        return graph.box_h[above] + gap;
+        // Either box may want more room than its kind implies, and the one that wants more wins: a
+        // margin says how much room that box needs to read as its own, not how much to add.
+        const margin = Math.max(graph.box_margin[above], graph.box_margin[below]);
+
+        return graph.box_h[above] + gap + margin;
     }
 
     /**
@@ -430,7 +434,7 @@ function compact(graph, order, rank, layer_start, block, options) {
                     if (place[u] + need > place[v]) {
                         place[v] = place[u] + need;
                     }
-                }
+                }
             }
 
             w = next[w];
@@ -446,62 +450,62 @@ function compact(graph, order, rank, layer_start, block, options) {
     const y = new Float64Array(box_count);
 
     for (let box = 0; box < box_count; box++) {
-        const r = root[box];
-
-        y[box] = place[r] + offset[box];
-    }
-
-    // Record every boundary between classes, directed from the lower class to the upper one.
-    // Use the position of the lower box in `order` as the edge index; its predecessor is `at - 1`.
-    // Parallel boundaries matter: different box heights and ports can make either one tighter.
-    const first_boundary = new Int32Array(box_count).fill(-1);
-    const next_boundary = new Int32Array(box_count);
-    const pending = new Int32Array(box_count);
-
-    for (let layer = 0; layer + 1 < layer_start.length; layer++) {
-        for (let at = layer_start[layer] + 1; at < layer_start[layer + 1]; at++) {
-            const upper = sink[root[order[at - 1]]];
-            const lower = sink[root[order[at]]];
-
-            if (upper !== lower) {
-                next_boundary[at] = first_boundary[lower];
-                first_boundary[lower] = at;
-                pending[upper]++;
-            }
-        }
-    }
-
-    const ready = new Int32Array(box_count);
-    let end = 0;
-
-    for (let box = 0; box < box_count; box++) {
-        if (root[box] === box && sink[box] === box && pending[box] === 0) {
-            shift[box] = 0;
-            ready[end++] = box;
-        }
-    }
-
-    for (let cursor = 0; cursor < end; cursor++) {
-        const lower = ready[cursor];
-
-        for (let at = first_boundary[lower]; at !== -1; at = next_boundary[at]) {
-            const above = order[at - 1];
-            const below = order[at];
-            const upper = sink[root[above]];
-
-            // y[above] + shift[upper] + separation <= y[below] + shift[lower]
-            const limit = shift[lower] + y[below] - y[above] - separation(above, below);
-
-            shift[upper] = Math.min(shift[upper], limit);
-
-            if (--pending[upper] === 0) {
-                ready[end++] = upper;
-            }
-        }
-    }
-
-    for (let box = 0; box < box_count; box++) {
-        y[box] += shift[sink[root[box]]];
+        const r = root[box];
+
+        y[box] = place[r] + offset[box];
+    }
+
+    // Record every boundary between classes, directed from the lower class to the upper one.
+    // Use the position of the lower box in `order` as the edge index; its predecessor is `at - 1`.
+    // Parallel boundaries matter: different box heights and ports can make either one tighter.
+    const first_boundary = new Int32Array(box_count).fill(-1);
+    const next_boundary = new Int32Array(box_count);
+    const pending = new Int32Array(box_count);
+
+    for (let layer = 0; layer + 1 < layer_start.length; layer++) {
+        for (let at = layer_start[layer] + 1; at < layer_start[layer + 1]; at++) {
+            const upper = sink[root[order[at - 1]]];
+            const lower = sink[root[order[at]]];
+
+            if (upper !== lower) {
+                next_boundary[at] = first_boundary[lower];
+                first_boundary[lower] = at;
+                pending[upper]++;
+            }
+        }
+    }
+
+    const ready = new Int32Array(box_count);
+    let end = 0;
+
+    for (let box = 0; box < box_count; box++) {
+        if (root[box] === box && sink[box] === box && pending[box] === 0) {
+            shift[box] = 0;
+            ready[end++] = box;
+        }
+    }
+
+    for (let cursor = 0; cursor < end; cursor++) {
+        const lower = ready[cursor];
+
+        for (let at = first_boundary[lower]; at !== -1; at = next_boundary[at]) {
+            const above = order[at - 1];
+            const below = order[at];
+            const upper = sink[root[above]];
+
+            // y[above] + shift[upper] + separation <= y[below] + shift[lower]
+            const limit = shift[lower] + y[below] - y[above] - separation(above, below);
+
+            shift[upper] = Math.min(shift[upper], limit);
+
+            if (--pending[upper] === 0) {
+                ready[end++] = upper;
+            }
+        }
+    }
+
+    for (let box = 0; box < box_count; box++) {
+        y[box] += shift[sink[root[box]]];
     }
 
     return y;
@@ -514,9 +518,9 @@ function compact(graph, order, rank, layer_start, block, options) {
  * top edge, the ones biased towards the bottom by their bottom edge — against whichever of them
  * came out shortest. Only then can they be compared box by box, and each box takes the average of
  * the middle two of its four candidates: an average of all four is pulled about by whichever single
- * pass went furthest astray, and the middle two are the ones the passes agree on.
- * Each candidate must already satisfy every separation constraint. Taking the same order
- * statistics for both ends of an inequality preserves it; balancing cannot repair an invalid pass.
+ * pass went furthest astray, and the middle two are the ones the passes agree on.
+ * Each candidate must already satisfy every separation constraint. Taking the same order
+ * statistics for both ends of an inequality preserves it; balancing cannot repair an invalid pass.
  *
  * @param {LayoutBoxGraph} graph mutated: `box_y` is written
  * @param {Float64Array[]} candidates

package/src/core/graph/layout/layered/layout_assign_layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout_assign_layers.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/layered/layout_assign_layers.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sEAPW,UAAU,GAER,MAAM,CAsDlB"}

package/src/core/{model/node-graph/visual/layout → graph/layout/layered}/layout_assign_layers.js

@@ -113,8 +113,10 @@ function tighten(graph, order, layer_count) {
         const out_start = graph.out_offset[box];
         const out_end = graph.out_offset[box + 1];
 
-        const in_degree = in_end - in_start;
-        const out_degree = out_end - out_start;
+        // A link to a box outside this graph pulls as hard as one inside it: which end of its window
+        // a box belongs at is exactly the question such a link answers. See `box_external_in`.
+        const in_degree = in_end - in_start + graph.box_external_in[box];
+        const out_degree = out_end - out_start + graph.box_external_out[box];
 
         if (in_degree === 0 && out_degree === 0) {
             continue;

package/src/core/graph/layout/layered/layout_break_cycles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout_break_cycles.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/layered/layout_break_cycles.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4DANa,UAAU,CAmOtB"}

package/src/core/graph/layout/layered/layout_insert_lanes.d.ts.map

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

package/src/core/graph/layout/layered/layout_order_layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout_order_layers.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/layered/layout_order_layers.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wEATW,MAAM,UACN,MAAM,GACJ;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAyJ7F"}

package/src/core/graph/layout/layered/layout_orient_links.d.ts.map

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