@woosh/meep-engine 2.163.11 → 2.165.0

package/src/core/geom/vec4/v4_multiply_mat4.d.ts

@@ -1,8 +1,7 @@
 /**
- *
- * @param {number[]} result
- * @param {number[]} input
- * @param {number[]} mat4
+ * @deprecated Renamed to {@link v4_matrix4_multiply}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function v4_multiply_mat4(result: number[], input: number[], mat4: number[]): void;
+export const v4_multiply_mat4: typeof v4_matrix4_multiply;
+import { v4_matrix4_multiply } from "./v4_matrix4_multiply.js";
 //# sourceMappingURL=v4_multiply_mat4.d.ts.map

package/src/core/geom/vec4/v4_multiply_mat4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v4_multiply_mat4.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec4/v4_multiply_mat4.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,SACR,MAAM,EAAE,QACR,MAAM,EAAE,QAqClB"}
+{"version":3,"file":"v4_multiply_mat4.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec4/v4_multiply_mat4.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,0DAAoD;oCANhB,0BAA0B"}

package/src/core/geom/vec4/v4_multiply_mat4.js

@@ -1,42 +1,7 @@
-/**
- *
- * @param {number[]} result
- * @param {number[]} input
- * @param {number[]} mat4
- */
-export function v4_multiply_mat4(result, input, mat4) {
-    const a0 = mat4[0];
-    const a1 = mat4[1];
-    const a2 = mat4[2];
-    const a3 = mat4[3];
-
-    const b0 = mat4[4];
-    const b1 = mat4[5];
-    const b2 = mat4[6];
-    const b3 = mat4[7];
-
-    const c0 = mat4[8];
-    const c1 = mat4[9];
-    const c2 = mat4[10];
-    const c3 = mat4[11];
-
-    const d0 = mat4[12];
-    const d1 = mat4[13];
-    const d2 = mat4[14];
-    const d3 = mat4[15];
-
-    const _x = input[0];
-    const _y = input[1];
-    const _z = input[2];
-    const _w = input[3];
-
-    const x = a0 * _x + b0 * _y + c0 * _z + d0 * _w;
-    const y = a1 * _x + b1 * _y + c1 * _z + d1 * _w;
-    const z = a2 * _x + b2 * _y + c2 * _z + d2 * _w;
-    const w = a3 * _x + b3 * _y + c3 * _z + d3 * _w;
-
-    result[0] = x;
-    result[1] = y;
-    result[2] = z;
-    result[3] = w;
-}
+import { v4_matrix4_multiply } from "./v4_matrix4_multiply.js";
+
+/**
+ * @deprecated Renamed to {@link v4_matrix4_multiply}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const v4_multiply_mat4 = v4_matrix4_multiply;

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

@@ -7,11 +7,13 @@
  * instead of four, the GC one reference to track, and the cache one
  * contiguous region to prefetch when walking adjacency rows.
  *
- * Layout inside the buffer (all uint32, 4 bytes each):
- *   [0]                       edge_addresses, length vertex_count + 1
- *   [vertex_count + 1]        adjacency,      length adjacency_length
- *   [+adjacency_length]       edge_weights,   length adjacency_length
- *   [+adjacency_length]       vertex_weights, length vertex_count
+ * Layout inside the buffer (every slot is 4 bytes; `edge_weights` is reinterpreted
+ * as float32, the other three as uint32 — they share the same 4-byte stride so the
+ * single-buffer layout is unaffected):
+ *   [0]                       edge_addresses, length vertex_count + 1   (uint32)
+ *   [vertex_count + 1]        adjacency,      length adjacency_length   (uint32)
+ *   [+adjacency_length]       edge_weights,   length adjacency_length   (float32)
+ *   [+adjacency_length]       vertex_weights, length vertex_count       (uint32)
  *
  * Conventions match `mesh_to_metis_graph`:
  *   - `edge_addresses[v]`     = start of vertex v's adjacency in `adjacency`
@@ -73,10 +75,12 @@ export class CSRGraph {
      */
     adjacency: Uint32Array;
     /**
-     * Edge weights parallel to `adjacency`.
-     * @type {Uint32Array}
+     * Edge weights parallel to `adjacency`. Float32 so callers can supply
+     * continuous, fractional affinities (e.g. shared-edge length, dihedral
+     * angle, acoustic coupling) rather than just integer connectivity counts.
+     * @type {Float32Array}
      */
-    edge_weights: Uint32Array;
+    edge_weights: Float32Array;
     /**
      * Per-vertex weight. Initialised to all-1s; overwrite via direct
      * indexing or `vertex_weights.set(...)` if your domain needs non-uniform

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

@@ -1 +1 @@
-{"version":3,"file":"CSRGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/CSRGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IA4PI;;;;;;;;;;;;;OAaG;IACH,gCAPW,MAAM,kBACN,UAAU,MAAM,CAAC,aACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,mBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAgBpB;IAvRD;;;;OAIG;IACH,0BAJW,MAAM,oBACN,MAAM,EA8DhB;IAvDG,qBAAqB;IACrB,cADW,MAAM,CACe;IAChC,qBAAqB;IACrB,kBADW,MAAM,CACuB;IAOxC;;;;OAIG;IACH,sBAA4D;IAI5D;;;;OAIG;IACH,gBAFU,WAAW,CAEmE;IAGxF;;;OAGG;IACH,WAFU,WAAW,CAE8D;IAGnF;;;OAGG;IACH,cAFU,WAAW,CAEiE;IAGtF;;;;;OAKG;IACH,gBAFU,WAAW,CAE+D;IAGpF;;;OAGG;IACH,qBAFU,MAAM,CAEuB;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,CAUlB;IAED;;OAEG;IACH,oCAQC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAFW,MAAM,QA6ChB;IAED;;;;;;;;;OASG;IACH,YAFW,QAAQ,QASlB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAMpB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAyBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAalB;IAiCL;;;;;OAKG;IACH,qBAFU,OAAO,CAEY;CAR5B"}
+{"version":3,"file":"CSRGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/CSRGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAkQI;;;;;;;;;;;;;OAaG;IACH,gCAPW,MAAM,kBACN,UAAU,MAAM,CAAC,aACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,mBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAgBpB;IA7RD;;;;OAIG;IACH,0BAJW,MAAM,oBACN,MAAM,EAgEhB;IAzDG,qBAAqB;IACrB,cADW,MAAM,CACe;IAChC,qBAAqB;IACrB,kBADW,MAAM,CACuB;IAOxC;;;;OAIG;IACH,sBAA4D;IAI5D;;;;OAIG;IACH,gBAFU,WAAW,CAEmE;IAGxF;;;OAGG;IACH,WAFU,WAAW,CAE8D;IAGnF;;;;;OAKG;IACH,cAFU,YAAY,CAEiE;IAGvF;;;;;OAKG;IACH,gBAFU,WAAW,CAE+D;IAGpF;;;OAGG;IACH,qBAFU,MAAM,CAEuB;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,CAUlB;IAED;;OAEG;IACH,oCAQC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAFW,MAAM,QA6ChB;IAED;;;;;;;;;OASG;IACH,YAFW,QAAQ,QASlB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAMpB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAyBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAiBlB;IAiCL;;;;;OAKG;IACH,qBAFU,OAAO,CAEY;CAR5B"}

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

@@ -11,11 +11,13 @@ import { uint32_array_hash } from "../../collection/array/typed/uint32_array_has
  * instead of four, the GC one reference to track, and the cache one
  * contiguous region to prefetch when walking adjacency rows.
  *
- * Layout inside the buffer (all uint32, 4 bytes each):
- *   [0]                       edge_addresses, length vertex_count + 1
- *   [vertex_count + 1]        adjacency,      length adjacency_length
- *   [+adjacency_length]       edge_weights,   length adjacency_length
- *   [+adjacency_length]       vertex_weights, length vertex_count
+ * Layout inside the buffer (every slot is 4 bytes; `edge_weights` is reinterpreted
+ * as float32, the other three as uint32 — they share the same 4-byte stride so the
+ * single-buffer layout is unaffected):
+ *   [0]                       edge_addresses, length vertex_count + 1   (uint32)
+ *   [vertex_count + 1]        adjacency,      length adjacency_length   (uint32)
+ *   [+adjacency_length]       edge_weights,   length adjacency_length   (float32)
+ *   [+adjacency_length]       vertex_weights, length vertex_count       (uint32)
  *
  * Conventions match `mesh_to_metis_graph`:
  *   - `edge_addresses[v]`     = start of vertex v's adjacency in `adjacency`
@@ -78,10 +80,12 @@ export class CSRGraph {
         byte_offset += adjacency_length * 4;
 
         /**
-         * Edge weights parallel to `adjacency`.
-         * @type {Uint32Array}
+         * Edge weights parallel to `adjacency`. Float32 so callers can supply
+         * continuous, fractional affinities (e.g. shared-edge length, dihedral
+         * angle, acoustic coupling) rather than just integer connectivity counts.
+         * @type {Float32Array}
          */
-        this.edge_weights = new Uint32Array(this.__data_buffer, byte_offset, adjacency_length);
+        this.edge_weights = new Float32Array(this.__data_buffer, byte_offset, adjacency_length);
         byte_offset += adjacency_length * 4;
 
         /**
@@ -188,7 +192,7 @@ export class CSRGraph {
         byte_offset += (this.vertex_count + 1) * 4;
         const new_adjacency = new Uint32Array(new_buffer, byte_offset, new_adjacency_length);
         byte_offset += new_adjacency_length * 4;
-        const new_edge_weights = new Uint32Array(new_buffer, byte_offset, new_adjacency_length);
+        const new_edge_weights = new Float32Array(new_buffer, byte_offset, new_adjacency_length);
         byte_offset += new_adjacency_length * 4;
         const new_vertex_weights = new Uint32Array(new_buffer, byte_offset, this.vertex_count);
 
@@ -280,7 +284,11 @@ export class CSRGraph {
         // adjacency_length); otherwise two logically-equal graphs with differently-sized buffers hash unequally.
         h = ((h << 5) - h) + uint32_array_hash(this.edge_addresses, 0, this.edge_addresses.length);
         h = ((h << 5) - h) + uint32_array_hash(this.adjacency, 0, this.adjacency.length);
-        h = ((h << 5) - h) + uint32_array_hash(this.edge_weights, 0, this.edge_weights.length);
+        // edge_weights is float32; hash its raw IEEE-754 bit pattern via a uint32 view over the
+        // exact same bytes (its own buffer/offset, which need not be __data_buffer if the view was
+        // re-pointed) so fractional weights are distinguished and equal graphs hash equally.
+        const edge_weight_bits = new Uint32Array(this.edge_weights.buffer, this.edge_weights.byteOffset, this.edge_weights.length);
+        h = ((h << 5) - h) + uint32_array_hash(edge_weight_bits, 0, edge_weight_bits.length);
         h = ((h << 5) - h) + uint32_array_hash(this.vertex_weights, 0, this.vertex_weights.length);
         return h | 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
     };
 }