@woosh/meep-engine 3.28.0 → 3.30.0

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"}

package/src/core/graph/mn_graph_collapse_weighted_edge.js

@@ -62,12 +62,12 @@ export function mn_graph_collapse_weighted_edge(
             heap.delete(b_edge);
         }
 
-        const heap_index = heap.data.indexOf(target_edge);
-
-        if (heap_index !== -1) {
-            // updated edge is in the heap, re-score
-            heap.bubbleDown(heap_index);
-        }
+        // The merge above raises the survivor's weight, and the heap is keyed on `-weight`, so the
+        // survivor's score *falls* and it has to move up. `bubbleDown` alone, which is what this
+        // used to do, is a no-op for an element that has sunk below its parent — the heaviest edge
+        // then sits stranded under a lighter one and the coarsener stops collapsing in weight
+        // order. `updateElementScore` goes both ways, and does not need the heap's private `data`.
+        heap.updateElementScore(target_edge);
 
     }
 

package/src/core/math/lookup/ParameterLookupTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParameterLookupTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTable.js"],"names":[],"mappings":"AAWA;IAibI;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,EAAE,cACR,MAAM,EAAE,wBAQlB;IAED;;;;OAIG;IACH,8CAFa,oBAAoB,CA0BhC;IA5bD;;;;OAIG;IACH,uBAHW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,YAAY,CAErB;IAEV;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,CAEhB;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,cAA4C;IAUxC;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAI5B;;;OAGG;IACH,WAFW,yBAAyB,QAInC;IAED;;;OAGG;IACH,aAFW,yBAAyB,GAAC,MAAM,QAI1C;IAED;;;;OAIG;IACH,WAHW,yBAAyB,GACvB,OAAO,CAInB;IAED,yBAEC;IAED,0BAGC;IAED;;;;MAMC;IAED;;;;OAIG;IACH,2CA2CC;IAED;;;OAGG;IACH,6CAkCC;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA0D5C;IAED,gCAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,cAC7C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA4B5C;IAED;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAAE,QAqClB;IAED;;OAEG;IACH,0BAkBC;IAED,eAgBC;IAED;;;;OAIG;IACH,cAHW,oBAAoB,GAClB,OAAO,CAenB;IAED,oBAwCC;IAgDL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;0CAheyC,gCAAgC"}
+{"version":3,"file":"ParameterLookupTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTable.js"],"names":[],"mappings":"AAWA;IAsbI;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,EAAE,cACR,MAAM,EAAE,wBAQlB;IAED;;;;OAIG;IACH,8CAFa,oBAAoB,CA0BhC;IAjcD;;;;OAIG;IACH,uBAHW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,YAAY,CAErB;IAEV;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,CAEhB;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,cAA4C;IAUxC;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAI5B;;;OAGG;IACH,WAFW,yBAAyB,QAInC;IAED;;;OAGG;IACH,aAFW,yBAAyB,GAAC,MAAM,QAI1C;IAED;;;;OAIG;IACH,WAHW,yBAAyB,GACvB,OAAO,CAInB;IAED,yBAEC;IAED,0BAGC;IAED;;;;MAMC;IAED;;;;OAIG;IACH,2CAgDC;IAED;;;OAGG;IACH,6CAkCC;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA0D5C;IAED,gCAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,cAC7C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA4B5C;IAED;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAAE,QAqClB;IAED;;OAEG;IACH,0BAkBC;IAED,eAgBC;IAED;;;;OAIG;IACH,cAHW,oBAAoB,GAClB,OAAO,CAenB;IAED,oBAwCC;IAgDL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;0CAreyC,gCAAgC"}

package/src/core/math/lookup/ParameterLookupTable.js

@@ -107,15 +107,20 @@ export class ParameterLookupTable {
     toBinaryBuffer(buffer) {
         const itemCount = this.positions.length;
 
-        const itemCountBitSize = Math.log2(itemCount);
-
         let itemCountByteSize;
 
-        if (itemCountBitSize <= 8) {
+        /**
+         * Sized from the value and not from `Math.log2(itemCount)`: the bits needed to hold `n` are
+         * `ceil(log2(n + 1))`, so a log2 test is off by exactly one representable value at each
+         * boundary. 256 read as "8 bits, fits a byte" and `setUint8` then wrote `256 % 256 === 0`,
+         * which left the reader allocating nothing and stopping the cursor an entire payload short
+         * of where the writer left it.
+         */
+        if (itemCount < 256) {
             itemCountByteSize = 1;
-        } else if (itemCountBitSize <= 16) {
+        } else if (itemCount < 65536) {
             itemCountByteSize = 2;
-        } else if (itemCountBitSize <= 32) {
+        } else if (itemCount < 4294967296) {
             itemCountByteSize = 4;
         } else {
             throw new Error(`Item count is too high`);

package/src/core/math/noise/sdnoise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAmDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAkIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CA+OlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA+RlB"}
+{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CAgPlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}

package/src/core/math/noise/sdnoise.js

@@ -196,7 +196,10 @@ function grad4(result, hash) {
  * @returns {number}
  */
 export function sdnoise1(derivatives, x) {
-    const i0 = x | 0;
+    //Math.floor, not `| 0`: `| 0` truncates toward zero, which names the cell above a negative
+    //point rather than the one containing it, and tears the field along every negative cell boundary.
+    //Gustavson's reference uses FASTFLOOR here for exactly this reason.
+    const i0 = Math.floor(x);
     const i1 = i0 + 1;
 
     const x0 = x - i0;
@@ -275,8 +278,9 @@ export function sdnoise2(derivatives, x, y) {
     const xs = x + s;
     const ys = y + s;
 
-    let ii, i = xs | 0;
-    let jj, j = ys | 0;
+    //see sdnoise1 on why this is Math.floor and not `| 0`
+    let ii, i = Math.floor(xs);
+    let jj, j = Math.floor(ys);
 
     const t = (i + j) * G2;
     const X0 = i - t; /* Unskew the cell origin back to (x,y) space */
@@ -426,9 +430,10 @@ export function sdnoise3(derivatives, x, y, z) {
     const ys = y + s;
     const zs = z + s;
 
-    const i = xs | 0;
-    const j = ys | 0;
-    const k = zs | 0;
+    //see sdnoise1 on why this is Math.floor and not `| 0`
+    const i = Math.floor(xs);
+    const j = Math.floor(ys);
+    const k = Math.floor(zs);
 
     const t = (i + j + k) * G3;
 
@@ -683,10 +688,11 @@ export function sdnoise4(derivatives, x, y, z, w) {
     const zs = z + s;
     const ws = w + s;
 
-    let ii, i = xs | 0;
-    let jj, j = ys | 0;
-    let kk, k = zs | 0;
-    let ll, l = ws | 0;
+    //see sdnoise1 on why this is Math.floor and not `| 0`
+    let ii, i = Math.floor(xs);
+    let jj, j = Math.floor(ys);
+    let kk, k = Math.floor(zs);
+    let ll, l = Math.floor(ws);
 
     const t = (i + j + k + l) * G4; // Factor for 4D unskewing
     const X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space