@woosh/meep-engine 2.163.11 → 2.164.0

package/src/core/graph/csr/csr_graph_build_distance_field.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Single-source distance field over a weighted {@link CSRGraph} (Dijkstra from `source_node`), written into
+ * three caller-supplied output arrays — for every vertex `v`:
+ *  - `out_distances[v]` — the shortest distance from `v` to `source_node` (`Infinity` if unreachable);
+ *  - `out_next[v]` — the NEXT hop from `v` toward the source (its predecessor in the shortest-path tree, the
+ *    one step that shortens the route); {@link INVALID_NODE} at the source and for unreachable vertices.
+ *    Walking `out_next` from any vertex reaches `source_node`.
+ *  - `out_exit[v]` — the neighbour of `source_node` on `v`'s shortest path: the last vertex before the source
+ *    (the "gateway" into the source's immediate neighbourhood); {@link INVALID_NODE} at the source and for
+ *    unreachable vertices.
+ *
+ * The open set is a binary min-heap ({@link Uint32Heap}) keyed by tentative distance, so the next vertex pops
+ * in O(log V) rather than an O(V) scan — O((V + E) log V) overall, not O(V²). Uses lazy deletion (push a
+ * fresh heap entry whenever a vertex's distance improves; the lowest-score copy pops first and finalises it,
+ * later stale copies land on an already-visited vertex and are skipped) to avoid the heap's O(V) decrease-key.
+ * Edge weights must be non-negative (Dijkstra's precondition).
+ *
+ * Allocation-free per call (the heap + visited set are reused, grown on demand); NOT reentrant (single shared
+ * heap, synchronous).
+ *
+ * @param {Float64Array|number[]} out_distances ≥ `graph.vertex_count` long; must hold `Infinity`, so a float
+ *        store (`Float64Array` or `number[]`), not an integer typed array
+ * @param {Uint32Array|number[]} out_next ≥ `graph.vertex_count` long ({@link INVALID_NODE} = no next hop)
+ * @param {Uint32Array|number[]} out_exit ≥ `graph.vertex_count` long ({@link INVALID_NODE} = no exit)
+ * @param {CSRGraph} graph
+ * @param {number} source_node the vertex the field is measured to
+ */
+export function csr_graph_build_distance_field(out_distances: Float64Array | number[], out_next: Uint32Array | number[], out_exit: Uint32Array | number[], graph: CSRGraph, source_node: number): void;
+/**
+ * Sentinel written into `out_next` / `out_exit` for a vertex with no such node — the source itself, or an
+ * unreachable vertex. A non-negative value (not -1) so the output arrays can be `Uint32Array`. Valid only for
+ * graphs with fewer than `INVALID_NODE` vertices (the sentinel must not collide with a real index).
+ * @type {number}
+ */
+export const INVALID_NODE: number;
+//# sourceMappingURL=csr_graph_build_distance_field.d.ts.map

package/src/core/graph/csr/csr_graph_build_distance_field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csr_graph_build_distance_field.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/csr_graph_build_distance_field.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8DAPW,YAAY,GAAC,MAAM,EAAE,YAErB,WAAW,GAAC,MAAM,EAAE,YACpB,WAAW,GAAC,MAAM,EAAE,gCAEpB,MAAM,QAsEhB;AAvGD;;;;;GAKG;AACH,2BAFU,MAAM,CAEqB"}

package/src/core/graph/csr/csr_graph_build_distance_field.js

@@ -0,0 +1,112 @@
+import { assert } from "../../assert.js";
+import { Uint32Heap } from "../../collection/heap/Uint32Heap.js";
+
+// module-static scratch — the open set (min-heap keyed by tentative distance) and the finalised set, grown
+// on demand. The search is synchronous start-to-finish, so reuse is safe (no reentrancy).
+const OPEN = new Uint32Heap();
+let VISITED = new Uint8Array(0);
+
+/**
+ * Sentinel written into `out_next` / `out_exit` for a vertex with no such node — the source itself, or an
+ * unreachable vertex. A non-negative value (not -1) so the output arrays can be `Uint32Array`. Valid only for
+ * graphs with fewer than `INVALID_NODE` vertices (the sentinel must not collide with a real index).
+ * @type {number}
+ */
+export const INVALID_NODE = 0xFFFFFF;
+
+/**
+ * Single-source distance field over a weighted {@link CSRGraph} (Dijkstra from `source_node`), written into
+ * three caller-supplied output arrays — for every vertex `v`:
+ *  - `out_distances[v]` — the shortest distance from `v` to `source_node` (`Infinity` if unreachable);
+ *  - `out_next[v]` — the NEXT hop from `v` toward the source (its predecessor in the shortest-path tree, the
+ *    one step that shortens the route); {@link INVALID_NODE} at the source and for unreachable vertices.
+ *    Walking `out_next` from any vertex reaches `source_node`.
+ *  - `out_exit[v]` — the neighbour of `source_node` on `v`'s shortest path: the last vertex before the source
+ *    (the "gateway" into the source's immediate neighbourhood); {@link INVALID_NODE} at the source and for
+ *    unreachable vertices.
+ *
+ * The open set is a binary min-heap ({@link Uint32Heap}) keyed by tentative distance, so the next vertex pops
+ * in O(log V) rather than an O(V) scan — O((V + E) log V) overall, not O(V²). Uses lazy deletion (push a
+ * fresh heap entry whenever a vertex's distance improves; the lowest-score copy pops first and finalises it,
+ * later stale copies land on an already-visited vertex and are skipped) to avoid the heap's O(V) decrease-key.
+ * Edge weights must be non-negative (Dijkstra's precondition).
+ *
+ * Allocation-free per call (the heap + visited set are reused, grown on demand); NOT reentrant (single shared
+ * heap, synchronous).
+ *
+ * @param {Float64Array|number[]} out_distances ≥ `graph.vertex_count` long; must hold `Infinity`, so a float
+ *        store (`Float64Array` or `number[]`), not an integer typed array
+ * @param {Uint32Array|number[]} out_next ≥ `graph.vertex_count` long ({@link INVALID_NODE} = no next hop)
+ * @param {Uint32Array|number[]} out_exit ≥ `graph.vertex_count` long ({@link INVALID_NODE} = no exit)
+ * @param {CSRGraph} graph
+ * @param {number} source_node the vertex the field is measured to
+ */
+export function csr_graph_build_distance_field(
+    out_distances,
+    out_next,
+    out_exit,
+    graph,
+    source_node
+) {
+
+    assert.isNonNegativeInteger(source_node, 'source_node');
+    assert.isObject(graph, 'graph');
+    assert.equal(graph.isCSRGraph, true, 'graph.isCSRGraph !== true');
+
+    const n = graph.vertex_count;
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const edge_weights = graph.edge_weights;
+
+    if (VISITED.length < n) {
+        VISITED = new Uint8Array(n);
+    }
+    const visited = VISITED;
+
+    out_distances.fill(Infinity, 0, n);
+    out_next.fill(INVALID_NODE, 0, n);
+    out_exit.fill(INVALID_NODE, 0, n);
+    visited.fill(0, 0, n);
+
+    OPEN.clear();
+
+    out_distances[source_node] = 0;
+    OPEN.insert(source_node, 0);
+
+    while (!OPEN.is_empty()) {
+        const u = OPEN.pop_min();
+
+        // lazy deletion: u may sit in the heap multiple times (re-pushed as its distance improved); the
+        // lowest-score copy finalises it here, later stale copies land on an already-visited u and skip.
+        if (visited[u] === 1) {
+            continue;
+        }
+
+        visited[u] = 1;
+
+        // the gateway toward the source: the source itself has none; a vertex whose next hop IS the source is
+        // its own gateway; otherwise inherit the next hop's (finalised earlier — smaller distance, popped first).
+        if (u === source_node) {
+            out_exit[u] = INVALID_NODE;
+        } else if (out_next[u] === source_node) {
+            out_exit[u] = u;
+        } else {
+            out_exit[u] = out_exit[out_next[u]];
+        }
+
+        for (let k = edge_addresses[u]; k < edge_addresses[u + 1]; k++) {
+            const v = adjacency[k];
+
+            if (visited[v] === 1) {
+                continue;
+            }
+
+            const nd = out_distances[u] + edge_weights[k];
+            if (nd < out_distances[v]) {
+                out_distances[v] = nd;
+                out_next[v] = u;
+                OPEN.insert(v, nd); // lazy push — no O(V) decrease-key scan
+            }
+        }
+    }
+}

package/src/core/graph/csr/csr_graph_find_edge.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Find the adjacency index of the directed edge `a → b` in `graph`: the position `k` in `graph.adjacency`
+ * (and the parallel `graph.edge_weights`) where `adjacency[k] === b`, scanning vertex `a`'s row. Returns -1
+ * if `b` is not a neighbour of `a`.
+ *
+ * For an UNDIRECTED CSR (each edge stored once at each endpoint), call it twice — `(a, b)` and `(b, a)` — to
+ * address both half-edges, e.g. to update a single logical edge's weight symmetrically.
+ *
+ * @param {CSRGraph} graph
+ * @param {number} a source vertex
+ * @param {number} b neighbour vertex to find
+ * @returns {number} adjacency index `k`, or -1 if not adjacent
+ */
+export function csr_graph_find_edge(graph: CSRGraph, a: number, b: number): number;
+//# sourceMappingURL=csr_graph_find_edge.d.ts.map

package/src/core/graph/csr/csr_graph_find_edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csr_graph_find_edge.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/csr_graph_find_edge.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wDAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAalB"}

package/src/core/graph/csr/csr_graph_find_edge.js

@@ -0,0 +1,25 @@
+/**
+ * Find the adjacency index of the directed edge `a → b` in `graph`: the position `k` in `graph.adjacency`
+ * (and the parallel `graph.edge_weights`) where `adjacency[k] === b`, scanning vertex `a`'s row. Returns -1
+ * if `b` is not a neighbour of `a`.
+ *
+ * For an UNDIRECTED CSR (each edge stored once at each endpoint), call it twice — `(a, b)` and `(b, a)` — to
+ * address both half-edges, e.g. to update a single logical edge's weight symmetrically.
+ *
+ * @param {CSRGraph} graph
+ * @param {number} a source vertex
+ * @param {number} b neighbour vertex to find
+ * @returns {number} adjacency index `k`, or -1 if not adjacent
+ */
+export function csr_graph_find_edge(graph, a, b) {
+    const adjacency = graph.adjacency;
+    const end = graph.edge_addresses[a + 1];
+
+    for (let k = graph.edge_addresses[a]; k < end; k++) {
+        if (adjacency[k] === b) {
+            return k;
+        }
+    }
+
+    return -1;
+}

package/src/core/graph/csr/csr_graph_find_shortest_path.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shortest path between two vertices of a weighted {@link CSRGraph} (Dijkstra), written as a list of
+ * vertex indices — inclusive of both ends, `start` first — into `output[output_offset …]`.
+ *
+ * The open set is a binary min-heap ({@link Uint32Heap}) keyed by tentative distance, so the next vertex
+ * is popped in O(log V) rather than scanned for over all vertices — O((V + E) log V) overall. Uses lazy
+ * deletion (push a fresh heap entry whenever a vertex's distance improves; the lowest-score copy pops
+ * first and finalises it, later stale copies are skipped) to avoid the heap's O(V) decrease-key. Edge
+ * weights must be non-negative (Dijkstra's precondition). On no path, `output` is left untouched.
+ *
+ * @param {number[]|Int32Array|Uint32Array} output destination for the path's vertex indices (must hold at
+ *        least `vertex_count` entries from `output_offset` in the worst case)
+ * @param {number} output_offset index in `output` to start writing at
+ * @param {CSRGraph} graph
+ * @param {number} start source vertex
+ * @param {number} end target vertex
+ * @returns {number} number of vertices written (≥ 1), or -1 if `end` is unreachable from `start`
+ */
+export function csr_graph_find_shortest_path(output: number[] | Int32Array | Uint32Array, output_offset: number, graph: CSRGraph, start: number, end: number): number;
+//# sourceMappingURL=csr_graph_find_shortest_path.d.ts.map

package/src/core/graph/csr/csr_graph_find_shortest_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csr_graph_find_shortest_path.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/csr_graph_find_shortest_path.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDARW,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,iBAE/B,MAAM,0BAEN,MAAM,OACN,MAAM,GACJ,MAAM,CA+ElB"}

package/src/core/graph/csr/csr_graph_find_shortest_path.js

@@ -0,0 +1,105 @@
+import { Uint32Heap } from "../../collection/heap/Uint32Heap.js";
+
+// module-static scratch — the open set (min-heap keyed by tentative distance) and the per-vertex Dijkstra
+// state, grown on demand. The algorithm is synchronous start-to-finish, so reuse is safe (no reentrancy).
+const OPEN = new Uint32Heap();
+let DIST = new Float64Array(0);
+let PREV = new Int32Array(0);
+let VISITED = new Uint8Array(0);
+
+/**
+ * Shortest path between two vertices of a weighted {@link CSRGraph} (Dijkstra), written as a list of
+ * vertex indices — inclusive of both ends, `start` first — into `output[output_offset …]`.
+ *
+ * The open set is a binary min-heap ({@link Uint32Heap}) keyed by tentative distance, so the next vertex
+ * is popped in O(log V) rather than scanned for over all vertices — O((V + E) log V) overall. Uses lazy
+ * deletion (push a fresh heap entry whenever a vertex's distance improves; the lowest-score copy pops
+ * first and finalises it, later stale copies are skipped) to avoid the heap's O(V) decrease-key. Edge
+ * weights must be non-negative (Dijkstra's precondition). On no path, `output` is left untouched.
+ *
+ * @param {number[]|Int32Array|Uint32Array} output destination for the path's vertex indices (must hold at
+ *        least `vertex_count` entries from `output_offset` in the worst case)
+ * @param {number} output_offset index in `output` to start writing at
+ * @param {CSRGraph} graph
+ * @param {number} start source vertex
+ * @param {number} end target vertex
+ * @returns {number} number of vertices written (≥ 1), or -1 if `end` is unreachable from `start`
+ */
+export function csr_graph_find_shortest_path(output, output_offset, graph, start, end) {
+    const n = graph.vertex_count;
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const edge_weights = graph.edge_weights;
+
+    if (DIST.length < n) {
+        DIST = new Float64Array(n);
+        PREV = new Int32Array(n);
+        VISITED = new Uint8Array(n);
+    }
+
+    const dist = DIST;
+    const prev = PREV;
+    const visited = VISITED;
+
+    dist.fill(Infinity, 0, n);
+    prev.fill(-1, 0, n);
+    visited.fill(0, 0, n);
+
+    OPEN.clear();
+
+    dist[start] = 0;
+    OPEN.insert(start, 0);
+
+    while (!OPEN.is_empty()) {
+        const u = OPEN.pop_min();
+
+        // lazy deletion: u may sit in the heap multiple times (re-pushed each time its tentative distance
+        // improved). The lowest-score copy pops first and finalises u; later stale copies land here on an
+        // already-visited vertex and are skipped.
+        if (visited[u] === 1) {
+            continue;
+        }
+
+        visited[u] = 1;
+
+        if (u === end) {
+            break; // first extraction of `end` is its final distance (non-negative weights)
+        }
+
+        for (let k = edge_addresses[u]; k < edge_addresses[u + 1]; k++) {
+            const v = adjacency[k];
+
+            if (visited[v] === 1) {
+                continue;
+            }
+
+            const nd = dist[u] + edge_weights[k];
+
+            if (nd < dist[v]) {
+                dist[v] = nd;
+                prev[v] = u;
+                OPEN.insert(v, nd); // lazy push — no O(V) decrease-key scan
+            }
+        }
+    }
+
+    if (dist[end] === Infinity) {
+        return -1;
+    }
+
+    // reconstruct: walk parents from `end` back to `start`, writing reversed into `output`, then flip the
+    // written segment so it reads start → end.
+    let count = 0;
+    for (let c = end; c !== -1; c = prev[c]) {
+        output[output_offset + count] = c;
+        count++;
+    }
+
+    for (let i = 0, j = count - 1; i < j; i++, j--) {
+        const tmp = output[output_offset + i];
+        output[output_offset + i] = output[output_offset + j];
+        output[output_offset + j] = tmp;
+    }
+
+    return count;
+}

package/src/core/graph/layout/CircleLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CircleLayout.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/CircleLayout.js"],"names":[],"mappings":"AAmJA;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,yBAER,OAAO,QAyEjB;AAsBD;;;;GAIG;AACH,kDAHW,MAAM,EAAE,UACR,OAAO,QAcjB;AA2TD,sGAsBC;AA4MD;;;;GAIG;AACH,8CAHW,MAAM,WACN,MAAM,EAAE,QAgBlB;AAED;;;;;GAKG;AACH,4CAJW,MAAM,EAAE,UACR,OAAO,YACP,MAAM,QAkBhB;AAED;;;;;GAKG;AACH,qDAJW,MAAM,WACN,MAAM,EAAE,GACP,MAAM,CA2EjB;mBA95BkB,gCAAgC;oBAK/B,uBAAuB"}
+{"version":3,"file":"CircleLayout.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/CircleLayout.js"],"names":[],"mappings":"AAiJA;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,yBAER,OAAO,QAyEjB;AAsBD;;;;GAIG;AACH,kDAHW,MAAM,EAAE,UACR,OAAO,QAcjB;AA2TD,sGAsBC;AA4MD;;;;GAIG;AACH,8CAHW,MAAM,WACN,MAAM,EAAE,QAgBlB;AAED;;;;;GAKG;AACH,4CAJW,MAAM,EAAE,UACR,OAAO,YACP,MAAM,QAkBhB;AAED;;;;;GAKG;AACH,qDAJW,MAAM,WACN,MAAM,EAAE,GACP,MAAM,CA2EjB;mBA55BkB,gCAAgC;oBAG/B,uBAAuB"}

package/src/core/graph/layout/CircleLayout.js

@@ -1,9 +1,7 @@
 import { assert } from "../../assert.js";
 import AABB2 from "../../geom/2d/aabb/AABB2.js";
 import Circle from "../../geom/2d/circle/Circle.js";
-import {
-    line_segment_line_segment_intersection_exists_2d
-} from "../../geom/2d/line/line_segment_line_segment_intersection_exists_2d.js";
+import { segment2_intersects_segment2_2d } from "../../geom/2d/line/segment2_intersects_segment2_2d.js";
 import { v2_distance } from "../../geom/vec2/v2_distance.js";
 import Vector2 from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
@@ -364,7 +362,7 @@ function computeNumberOfCrossOvers(edges, numEdges) {
             const b0 = e1.source;
             const b1 = e1.target;
 
-            if (line_segment_line_segment_intersection_exists_2d(
+            if (segment2_intersects_segment2_2d(
                 a0.x, a0.y,
                 a1.x, a1.y,
                 b0.x, b0.y,

package/src/core/graph/layout/box/applyCentralGravityAABB2.js

@@ -1,4 +1,4 @@
-import { aabb2_compute_center_from_multiple } from "../../../geom/2d/aabb/aabb2_compute_center_from_multiple.js";
+import { aabb2_center_from_aabb2_buffer } from "../../../geom/2d/aabb/aabb2_center_from_aabb2_buffer.js";
 import { pullBoxTowardsPoint } from "./pullBoxTowardsPoint.js";
 
 /**
@@ -9,7 +9,7 @@ import { pullBoxTowardsPoint } from "./pullBoxTowardsPoint.js";
 export function applyCentralGravityAABB2(boxes, strength) {
     const numBoxes = boxes.length;
 
-    const center = aabb2_compute_center_from_multiple(boxes);
+    const center = aabb2_center_from_aabb2_buffer(boxes);
 
     for (let i = 0; i < numBoxes; i++) {
         const box = boxes[i];

package/src/core/graph/metis/cluster_mesh_metis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cluster_mesh_metis.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/metis/cluster_mesh_metis.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2CALW,WAAW,8BAEX,MAAM,GACJ,MAAM,CAqBlB"}
+{"version":3,"file":"cluster_mesh_metis.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/metis/cluster_mesh_metis.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2CALW,WAAW,8BAEX,MAAM,GACJ,MAAM,CA4BlB"}

package/src/core/graph/metis/cluster_mesh_metis.js

@@ -29,12 +29,19 @@ export async function cluster_mesh_metis(result, mesh, patch_size) {
 
     const metis_graph = mesh_to_metis_graph(face_array);
 
+    // `mesh_to_metis_graph` now produces float32 edge weights (the native path takes
+    // fractional weights). The deprecated WASM `Metis.INSTANCE` behind metis_cluster_bs
+    // still expects integer weights, so narrow them back to uint32 at this boundary —
+    // these weights are all 1, so the conversion is exact. The native replacement in the
+    // @deprecated note above consumes the float weights directly and needs no conversion.
+    const edge_weights_uint32 = new Uint32Array(metis_graph.edge_weights);
+
     const partition_count = await metis_cluster_bs(
         result,
         input_face_count,
         metis_graph.edge_addresses,
         metis_graph.adjacency,
-        metis_graph.edge_weights,
+        edge_weights_uint32,
         patch_size
     );
 

package/src/core/graph/metis/mesh_to_metis_graph.d.ts

@@ -1,10 +1,10 @@
 /**
  * @param {TopoTriangle[]} face_array
- * @returns {{edge_addresses:Uint32Array, adjacency:Uint32Array, edge_weights:Uint32Array}}
+ * @returns {{edge_addresses:Uint32Array, adjacency:Uint32Array, edge_weights:Float32Array}}
  */
 export function mesh_to_metis_graph(face_array: TopoTriangle[]): {
     edge_addresses: Uint32Array;
     adjacency: Uint32Array;
-    edge_weights: Uint32Array;
+    edge_weights: Float32Array;
 };
 //# sourceMappingURL=mesh_to_metis_graph.d.ts.map

package/src/core/graph/metis/mesh_to_metis_graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh_to_metis_graph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/metis/mesh_to_metis_graph.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,gDAHW,cAAc;oBACI,WAAW;eAAY,WAAW;kBAAe,WAAW;EA2DxF"}
+{"version":3,"file":"mesh_to_metis_graph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/metis/mesh_to_metis_graph.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,gDAHW,cAAc;oBACI,WAAW;eAAY,WAAW;kBAAe,YAAY;EA2DzF"}

package/src/core/graph/metis/mesh_to_metis_graph.js

@@ -2,7 +2,7 @@ import { assert } from "../../assert.js";
 
 /**
  * @param {TopoTriangle[]} face_array
- * @returns {{edge_addresses:Uint32Array, adjacency:Uint32Array, edge_weights:Uint32Array}}
+ * @returns {{edge_addresses:Uint32Array, adjacency:Uint32Array, edge_weights:Float32Array}}
  */
 export function mesh_to_metis_graph(face_array) {
     assert.isArray(face_array, 'face_array');
@@ -53,12 +53,12 @@ export function mesh_to_metis_graph(face_array) {
     }
 
     const adjecency_uint32 = new Uint32Array(adjacency);
-    const edge_weights_uint32 = new Uint32Array(edge_weights);
+    const edge_weights_float32 = new Float32Array(edge_weights);
 
 
     return {
         edge_addresses: edge_addresses,
         adjacency: adjecency_uint32,
-        edge_weights: edge_weights_uint32
+        edge_weights: edge_weights_float32
     };
 }

package/src/core/graph/metis/native/MetisGraph.d.ts

@@ -76,16 +76,26 @@ export class MetisGraph extends CSRGraph {
     boundary_position_of_vertex: Int32Array | null;
     /**
      * Internal degree: sum of edge weights from v to vertices in v's own
-     * partition. ("id" in METIS / FM literature.)
+     * partition. ("id" in METIS / FM literature.) Float32 because edge
+     * weights are fractional.
+     * @type {Float32Array|null}
+     */
+    internal_degree: Float32Array | null;
+    /**
+     * Number of edges (not weight) from v to vertices in v's own partition.
+     * Kept exact (integer) alongside the float `internal_degree` so that
+     * "does v still have any internal edge?" stays a precise decision under
+     * fractional weights — float-weight equality can't answer it reliably.
      * @type {Uint32Array|null}
      */
-    internal_degree: Uint32Array | null;
+    internal_edge_count: Uint32Array | null;
     /**
      * External degree: sum of edge weights from v to vertices in other
-     * partitions. ("ed" in METIS / FM literature.)
-     * @type {Uint32Array|null}
+     * partitions. ("ed" in METIS / FM literature.) Float32 because edge
+     * weights are fractional.
+     * @type {Float32Array|null}
      */
-    external_degree: Uint32Array | null;
+    external_degree: Float32Array | null;
     /**
      * Number of distinct neighbouring partitions reachable from v through
      * its edges. ("nnbrs" in METIS.)
@@ -101,11 +111,17 @@ export class MetisGraph extends CSRGraph {
     neighbor_partition_offset: Int32Array | null;
     /**
      * Pool of per-(vertex, neighbour-partition) records. Each record is
-     * 8 bytes: two uint32 words holding `(partition_id, edge_weight)`.
-     * Access record `r` via:
-     *   const word_base = neighbor_partition_pool.element_word(r);
-     *   const partition_id  = data_uint32[word_base + 2*k    ];
-     *   const edge_weight   = data_uint32[word_base + 2*k + 1];
+     * 12 bytes: three 4-byte words holding `(partition_id, edge_weight, edge_count)`.
+     * `partition_id` and `edge_count` are uint32; `edge_weight` is float32 —
+     * read it through the pool's `data_float32` view, the other two through
+     * `data_uint32`. `edge_count` is the exact number of edges summed into
+     * `edge_weight`; add/remove decisions key off it (not off weight equality)
+     * so they stay precise under fractional weights. Access entry `k` of
+     * vertex v's list via:
+     *   const word_base = neighbor_partition_pool.element_word(offset);
+     *   const partition_id = data_uint32 [word_base + 3*k    ];
+     *   const edge_weight  = data_float32[word_base + 3*k + 1];
+     *   const edge_count   = data_uint32 [word_base + 3*k + 2];
      * where `k` is in `[0, neighbor_partition_count[v])`.
      *
      * ("cnbrpool" in METIS.)

package/src/core/graph/metis/native/MetisGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MetisGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/metis/native/MetisGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAWQ;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B,8BAA8B;IAC9B,eADW,UAAU,GAAC,IAAI,CACD;IACzB,8BAA8B;IAC9B,aADW,UAAU,GAAC,IAAI,CACH;IAIvB;;;OAGG;IACH,kBAFU,WAAW,GAAC,IAAI,CAEE;IAE5B;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;;OAKG;IACH,6BAFU,UAAU,GAAC,IAAI,CAEc;IAIvC;;;;OAIG;IACH,iBAFU,WAAW,GAAC,IAAI,CAEC;IAE3B;;;;OAIG;IACH,iBAFU,WAAW,GAAC,IAAI,CAEC;IAE3B;;;;OAIG;IACH,0BAFU,WAAW,GAAC,IAAI,CAEU;IAEpC;;;;;OAKG;IACH,2BAFU,UAAU,GAAC,IAAI,CAEY;IAErC;;;;;;;;;;;;OAYG;IACH,yBAFU,iBAAiB,GAAC,IAAI,CAEG;IAGvC;;;;;;;;;;;;;;;;OAgBG;IACH,0CAFW,MAAM,QAyBhB;IAED;;;;OAIG;IACH,+BAcC;IAGL,sBAAiC;CAFhC;yBA/MwB,uBAAuB;kCADd,8DAA8D"}
+{"version":3,"file":"MetisGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/metis/native/MetisGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAWQ;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B,8BAA8B;IAC9B,eADW,UAAU,GAAC,IAAI,CACD;IACzB,8BAA8B;IAC9B,aADW,UAAU,GAAC,IAAI,CACH;IAIvB;;;OAGG;IACH,kBAFU,WAAW,GAAC,IAAI,CAEE;IAE5B;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;;OAKG;IACH,6BAFU,UAAU,GAAC,IAAI,CAEc;IAIvC;;;;;OAKG;IACH,iBAFU,YAAY,GAAC,IAAI,CAEA;IAE3B;;;;;;OAMG;IACH,qBAFU,WAAW,GAAC,IAAI,CAEK;IAE/B;;;;;OAKG;IACH,iBAFU,YAAY,GAAC,IAAI,CAEA;IAE3B;;;;OAIG;IACH,0BAFU,WAAW,GAAC,IAAI,CAEU;IAEpC;;;;;OAKG;IACH,2BAFU,UAAU,GAAC,IAAI,CAEY;IAErC;;;;;;;;;;;;;;;;;;OAkBG;IACH,yBAFU,iBAAiB,GAAC,IAAI,CAEG;IAGvC;;;;;;;;;;;;;;;;OAgBG;IACH,0CAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,+BAeC;IAGL,sBAAiC;CAFhC;yBAlOwB,uBAAuB;kCADd,8DAA8D"}

package/src/core/graph/metis/native/MetisGraph.js

@@ -102,16 +102,27 @@ export class MetisGraph extends CSRGraph {
 
         /**
          * Internal degree: sum of edge weights from v to vertices in v's own
-         * partition. ("id" in METIS / FM literature.)
-         * @type {Uint32Array|null}
+         * partition. ("id" in METIS / FM literature.) Float32 because edge
+         * weights are fractional.
+         * @type {Float32Array|null}
          */
         this.internal_degree = null;
 
         /**
-         * External degree: sum of edge weights from v to vertices in other
-         * partitions. ("ed" in METIS / FM literature.)
+         * Number of edges (not weight) from v to vertices in v's own partition.
+         * Kept exact (integer) alongside the float `internal_degree` so that
+         * "does v still have any internal edge?" stays a precise decision under
+         * fractional weights — float-weight equality can't answer it reliably.
          * @type {Uint32Array|null}
          */
+        this.internal_edge_count = null;
+
+        /**
+         * External degree: sum of edge weights from v to vertices in other
+         * partitions. ("ed" in METIS / FM literature.) Float32 because edge
+         * weights are fractional.
+         * @type {Float32Array|null}
+         */
         this.external_degree = null;
 
         /**
@@ -131,11 +142,17 @@ export class MetisGraph extends CSRGraph {
 
         /**
          * Pool of per-(vertex, neighbour-partition) records. Each record is
-         * 8 bytes: two uint32 words holding `(partition_id, edge_weight)`.
-         * Access record `r` via:
-         *   const word_base = neighbor_partition_pool.element_word(r);
-         *   const partition_id  = data_uint32[word_base + 2*k    ];
-         *   const edge_weight   = data_uint32[word_base + 2*k + 1];
+         * 12 bytes: three 4-byte words holding `(partition_id, edge_weight, edge_count)`.
+         * `partition_id` and `edge_count` are uint32; `edge_weight` is float32 —
+         * read it through the pool's `data_float32` view, the other two through
+         * `data_uint32`. `edge_count` is the exact number of edges summed into
+         * `edge_weight`; add/remove decisions key off it (not off weight equality)
+         * so they stay precise under fractional weights. Access entry `k` of
+         * vertex v's list via:
+         *   const word_base = neighbor_partition_pool.element_word(offset);
+         *   const partition_id = data_uint32 [word_base + 3*k    ];
+         *   const edge_weight  = data_float32[word_base + 3*k + 1];
+         *   const edge_count   = data_uint32 [word_base + 3*k + 2];
          * where `k` is in `[0, neighbor_partition_count[v])`.
          *
          * ("cnbrpool" in METIS.)
@@ -175,16 +192,17 @@ export class MetisGraph extends CSRGraph {
         this.boundary_position_of_vertex = new Int32Array(n);
         this.boundary_position_of_vertex.fill(-1);
 
-        this.internal_degree = new Uint32Array(n);
-        this.external_degree = new Uint32Array(n);
+        this.internal_degree = new Float32Array(n);
+        this.internal_edge_count = new Uint32Array(n);
+        this.external_degree = new Float32Array(n);
         this.neighbor_partition_count = new Uint32Array(n);
         this.neighbor_partition_offset = new Int32Array(n);
         this.neighbor_partition_offset.fill(-1);
 
-        // Each pool record is 8 bytes (uint32 partition_id, uint32 edge_weight).
-        // Initial capacity sized to the adjacency length as a rough upper bound;
-        // the pool grows on demand.
-        this.neighbor_partition_pool = new BinaryElementPool(8, Math.max(64, this.adjacency_length));
+        // Each pool record is 12 bytes (uint32 partition_id, float32 edge_weight,
+        // uint32 edge_count). Initial capacity sized to the adjacency length as a
+        // rough upper bound; the pool grows on demand.
+        this.neighbor_partition_pool = new BinaryElementPool(12, Math.max(64, this.adjacency_length));
     }
 
     /**
@@ -195,6 +213,7 @@ export class MetisGraph extends CSRGraph {
     reset_refinement_state() {
         if (this.internal_degree !== null) {
             this.internal_degree.fill(0);
+            this.internal_edge_count.fill(0);
             this.external_degree.fill(0);
             this.neighbor_partition_count.fill(0);
             this.neighbor_partition_offset.fill(-1);

package/src/core/graph/metis/native/bisection/BisectionScratch.d.ts

@@ -39,8 +39,8 @@ export class BisectionScratch {
     max_vertex_count: number;
     boundary_vertices: Uint32Array;
     boundary_position_of_vertex: Int32Array;
-    internal_degree: Uint32Array;
-    external_degree: Uint32Array;
+    internal_degree: Float32Array;
+    external_degree: Float32Array;
     partition_weights: Uint32Array;
     best_partition_snapshot: Uint32Array;
     fm_heaps: IndexedFloatMaxHeap[];

package/src/core/graph/metis/native/bisection/BisectionScratch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BisectionScratch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/BisectionScratch.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACI;;OAEG;IACH,8BAFW,MAAM,EA8BhB;IA3BG,yBAAwC;IAIxC,+BAA0D;IAC1D,wCAAmE;IACnE,6BAAwD;IACxD,6BAAwD;IACxD,+BAA2C;IAC3C,qCAAgE;IAIhE,gCAGC;IACD,gCAA2D;IAE3D,6BAAwD;IACxD,gCAA2D;IAI3D,4BAA4B;IAC5B,uBADW,WAAW,EAAE,CACO;IAC/B,kCAAkC;IAGtC;;;;;;;;;;OAUG;IACH,yCAHW,MAAM,GACJ,WAAW,CAavB;IAED;;;OAGG;IACH,sCAEC;CACJ;oCApGmC,oDAAoD"}
+{"version":3,"file":"BisectionScratch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/BisectionScratch.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACI;;OAEG;IACH,8BAFW,MAAM,EAgChB;IA7BG,yBAAwC;IAIxC,+BAA0D;IAC1D,wCAAmE;IAGnE,8BAAyD;IACzD,8BAAyD;IACzD,+BAA2C;IAC3C,qCAAgE;IAIhE,gCAGC;IACD,gCAA2D;IAE3D,6BAAwD;IACxD,gCAA2D;IAI3D,4BAA4B;IAC5B,uBADW,WAAW,EAAE,CACO;IAC/B,kCAAkC;IAGtC;;;;;;;;;;OAUG;IACH,yCAHW,MAAM,GACJ,WAAW,CAavB;IAED;;;OAGG;IACH,sCAEC;CACJ;oCAtGmC,oDAAoD"}

package/src/core/graph/metis/native/bisection/BisectionScratch.js

@@ -44,8 +44,10 @@ export class BisectionScratch {
 
         this.boundary_vertices = new Uint32Array(max_vertex_count);
         this.boundary_position_of_vertex = new Int32Array(max_vertex_count);
-        this.internal_degree = new Uint32Array(max_vertex_count);
-        this.external_degree = new Uint32Array(max_vertex_count);
+        // id/ed accumulate fractional edge weights, so they're float. partition_weights
+        // sums vertex weights, which stay integer.
+        this.internal_degree = new Float32Array(max_vertex_count);
+        this.external_degree = new Float32Array(max_vertex_count);
         this.partition_weights = new Uint32Array(2);
         this.best_partition_snapshot = new Uint32Array(max_vertex_count);
 

package/src/core/graph/metis/native/bisection/compute_2way_params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_2way_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/compute_2way_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,2CAFW,OAAO,kBAAkB,EAAE,UAAU,QAsE/C"}
+{"version":3,"file":"compute_2way_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/compute_2way_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,2CAFW,OAAO,kBAAkB,EAAE,UAAU,QAwE/C"}