@woosh/meep-engine 2.169.0 → 2.169.2

package/src/core/geom/Vector1.d.ts

@@ -136,9 +136,9 @@ export class Vector1 extends Number {
     hash(): number;
     /**
      *
-     * @param {function(newValue:number, oldValue:number)} handler
+     * @param {(newValue: number, oldValue: number) => void} handler
      */
-    process(handler: any): void;
+    process(handler: (newValue: number, oldValue: number) => void): void;
     toJSON(): number;
     fromJSON(val: any): void;
     /**

package/src/core/geom/Vector1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector1.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector1.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IAgRI;;;;;OAKG;IACH,kBAJW,OAAO,KACP,OAAO,GACN,MAAM,CAIjB;IAvRD;;;;;;OAMG;IACH,gBALW,MAAM,EAkBhB;IAPG,UAAU;IAEV;;;OAGG;IACH,eAA6B;IAWjC;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,OAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;OAGG;IACH,aAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,UAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;;OAIG;IACH,iBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,WAFW,OAAO,8BAAwB,WAKzC;IAED;;;;OAIG;IACH,iBAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,WAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,eAEC;IAED;;;OAGG;IACH,YAFW,OAAO,8BAAwB,QAIzC;IAED;;;OAGG;IACH,SAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,OAAO,GACL,OAAO,CAInB;IAED;;OAEG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,4BAGC;IAED,iBAEC;IAED,yBAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAIhB;IAED,oBAEC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAIC;IAkBD,mBAEC;IAND,gBAEC;IAaL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAXvB,sDAIC;CACJ;;kBAUS,MAAM;cAON,OAAO;aAOP,OAAO"}
+{"version":3,"file":"Vector1.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector1.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IAgRI;;;;;OAKG;IACH,kBAJW,OAAO,KACP,OAAO,GACN,MAAM,CAIjB;IAvRD;;;;;;OAMG;IACH,gBALW,MAAM,EAkBhB;IAPG,UAAU;IAEV;;;OAGG;IACH,eAA6B;IAWjC;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,OAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;OAGG;IACH,aAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,UAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;;OAIG;IACH,iBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,WAFW,OAAO,8BAAwB,WAKzC;IAED;;;;OAIG;IACH,iBAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,WAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,eAEC;IAED;;;OAGG;IACH,YAFW,OAAO,8BAAwB,QAIzC;IAED;;;OAGG;IACH,SAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,OAAO,GACL,OAAO,CAInB;IAED;;OAEG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,4BAFsB,MAAM,YAAY,MAAM,KAAK,IAAI,QAKtD;IAED,iBAEC;IAED,yBAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAIhB;IAED,oBAEC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAIC;IAkBD,mBAEC;IAND,gBAEC;IAaL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAXvB,sDAIC;CACJ;;kBAUS,MAAM;cAON,OAAO;aAOP,OAAO"}

package/src/core/geom/Vector1.js

@@ -226,7 +226,7 @@ export class Vector1 extends Number {
 
     /**
      *
-     * @param {function(newValue:number, oldValue:number)} handler
+     * @param {(newValue: number, oldValue: number) => void} handler
      */
     process(handler) {
         handler(this.x, this.x);

package/src/core/geom/Vector2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector2.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector2.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Vector2.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector2.js"],"names":[],"mappings":"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"}

package/src/core/geom/Vector2.js

@@ -1,3 +1,4 @@
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
@@ -637,7 +638,7 @@ export class Vector2 extends Float64Array {
         const x = computeHashFloat(this[0]);
         const y = computeHashFloat(this[1]);
 
-        return ((x << 5) - x) + y;
+        return hash_mix2(x, y);
     }
 
     /**

package/src/core/geom/packing/max-rect/find_best_container.d.ts

@@ -3,8 +3,8 @@
  * @param {number} width
  * @param {number} height
  * @param {QuadTreeNode<T>} boxes
- * @param {function(containerWidth:number, containerHeight:number, childWidth:number, childHeight:number):number} costFunction
+ * @param {(containerWidth: number, containerHeight: number, childWidth: number, childHeight: number) => number} costFunction
  * @returns {QuadTreeDatum<T>} suitable container box
  */
-export function find_best_container<T>(width: number, height: number, boxes: QuadTreeNode<T>, costFunction: any): QuadTreeDatum<T>;
+export function find_best_container<T>(width: number, height: number, boxes: QuadTreeNode<T>, costFunction: (containerWidth: number, containerHeight: number, childWidth: number, childHeight: number) => number): QuadTreeDatum<T>;
 //# sourceMappingURL=find_best_container.d.ts.map

package/src/core/geom/packing/max-rect/find_best_container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find_best_container.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/find_best_container.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8CANW,MAAM,UACN,MAAM,+DA0EhB"}
+{"version":3,"file":"find_best_container.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/find_best_container.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8CANW,MAAM,UACN,MAAM,yDAEW,MAAM,mBAAmB,MAAM,cAAc,MAAM,eAAe,MAAM,KAAK,MAAM,oBAwE9G"}

package/src/core/geom/packing/max-rect/find_best_container.js

@@ -5,7 +5,7 @@ import { assert } from "../../../assert.js";
  * @param {number} width
  * @param {number} height
  * @param {QuadTreeNode<T>} boxes
- * @param {function(containerWidth:number, containerHeight:number, childWidth:number, childHeight:number):number} costFunction
+ * @param {(containerWidth: number, containerHeight: number, childWidth: number, childHeight: number) => number} costFunction
  * @returns {QuadTreeDatum<T>} suitable container box
  */
 export function find_best_container(

package/src/core/geom/random/random_orthonormal_basis.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Write a UNIFORMLY random orthonormal 3x3 basis into `result` (row-major, 9 elements), built around a
+ * uniformly-random unit direction that becomes the third (Z) row.
+ *
+ * WHY this exists: rotating a deterministic direction set (a Fibonacci sphere lattice, a fixed cone fan)
+ * by a fresh random basis decorrelates the lattice from the geometry it samples, which is what removes the
+ * structured bias a fixed lattice bakes in. Every sampler that wants that has to (a) draw a uniform point
+ * on the sphere and (b) complete it to a basis — two easy-to-get-wrong steps (the uniform axis must be
+ * `z ~ U(-1,1)`, NOT a uniform polar angle, and the ring radius needs the `max(0, ...)` guard so a
+ * `z = ±1` draw cannot produce `sqrt` of a negative rounding residue). Both acoustic ray samplers had
+ * inlined their own copy of exactly these four lines.
+ *
+ * The direction is drawn as `z = 2·random() − 1` FIRST and the azimuth second — the RNG consumption order
+ * is part of the contract, since callers are seeded and reproducible.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives 9 elements: rows X, Y, Z (Z is the random direction)
+ * @param {number} result_offset
+ * @param {function():number} random RNG in [0, 1); consumed exactly twice
+ */
+export function random_orthonormal_basis(result: number[] | Float32Array | Float64Array, result_offset: number, random: () => number): void;
+//# sourceMappingURL=random_orthonormal_basis.d.ts.map

package/src/core/geom/random/random_orthonormal_basis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random_orthonormal_basis.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/random/random_orthonormal_basis.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,gBACK,MAAM,QAW3B"}

package/src/core/geom/random/random_orthonormal_basis.js

@@ -0,0 +1,31 @@
+import { v3_orthonormal_matrix_from_normal } from "../vec3/v3_orthonormal_matrix_from_normal.js";
+
+/**
+ * Write a UNIFORMLY random orthonormal 3x3 basis into `result` (row-major, 9 elements), built around a
+ * uniformly-random unit direction that becomes the third (Z) row.
+ *
+ * WHY this exists: rotating a deterministic direction set (a Fibonacci sphere lattice, a fixed cone fan)
+ * by a fresh random basis decorrelates the lattice from the geometry it samples, which is what removes the
+ * structured bias a fixed lattice bakes in. Every sampler that wants that has to (a) draw a uniform point
+ * on the sphere and (b) complete it to a basis — two easy-to-get-wrong steps (the uniform axis must be
+ * `z ~ U(-1,1)`, NOT a uniform polar angle, and the ring radius needs the `max(0, ...)` guard so a
+ * `z = ±1` draw cannot produce `sqrt` of a negative rounding residue). Both acoustic ray samplers had
+ * inlined their own copy of exactly these four lines.
+ *
+ * The direction is drawn as `z = 2·random() − 1` FIRST and the azimuth second — the RNG consumption order
+ * is part of the contract, since callers are seeded and reproducible.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives 9 elements: rows X, Y, Z (Z is the random direction)
+ * @param {number} result_offset
+ * @param {function():number} random RNG in [0, 1); consumed exactly twice
+ */
+export function random_orthonormal_basis(result, result_offset, random) {
+    const z = 2 * random() - 1;
+    const azimuth = 2 * Math.PI * random();
+    const ring = Math.sqrt(Math.max(0, 1 - z * z));
+
+    v3_orthonormal_matrix_from_normal(
+        result, result_offset,
+        ring * Math.cos(azimuth), ring * Math.sin(azimuth), z
+    );
+}

package/src/core/geom/vec2/v2_rotate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rotate a 2d vector around the origin by an angle.
+ *
+ * Before this existed the four-line body was inlined at every site that needed it, which made the
+ * sign convention a copy-paste artifact instead of a documented contract. Keep new callers here.
+ *
+ * The rotation matches the standard 2d rotation matrix `[cos, -sin; sin, cos]`, i.e.
+ * counter-clockwise in a Y-up frame and clockwise in the Y-down frames used by grid/screen space.
+ * Callers own any rounding or snapping of the result.
+ *
+ * @param {Float64Array|Float32Array|number[]} result
+ * @param {number} result_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} angle in radians
+ */
+export function v2_rotate(result: Float64Array | Float32Array | number[], result_offset: number, x: number, y: number, angle: number): void;
+//# sourceMappingURL=v2_rotate.d.ts.map

package/src/core/geom/vec2/v2_rotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v2_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec2/v2_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,kCANW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,QAIhB"}

package/src/core/geom/vec2/v2_rotate.js

@@ -0,0 +1,21 @@
+import { v2_rotate_cos_sin } from "./v2_rotate_cos_sin.js";
+
+/**
+ * Rotate a 2d vector around the origin by an angle.
+ *
+ * Before this existed the four-line body was inlined at every site that needed it, which made the
+ * sign convention a copy-paste artifact instead of a documented contract. Keep new callers here.
+ *
+ * The rotation matches the standard 2d rotation matrix `[cos, -sin; sin, cos]`, i.e.
+ * counter-clockwise in a Y-up frame and clockwise in the Y-down frames used by grid/screen space.
+ * Callers own any rounding or snapping of the result.
+ *
+ * @param {Float64Array|Float32Array|number[]} result
+ * @param {number} result_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} angle in radians
+ */
+export function v2_rotate(result, result_offset, x, y, angle) {
+    v2_rotate_cos_sin(result, result_offset, x, y, Math.cos(angle), Math.sin(angle));
+}

package/src/core/geom/vec2/v2_rotate_cos_sin.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Rotate a 2d vector around the origin, given the cosine and sine of the angle.
+ *
+ * This exists so that a loop rotating many vectors by the *same* angle pays for `Math.cos`/`Math.sin`
+ * once instead of once per vector. Prefer {@link v2_rotate} when only a single vector is rotated.
+ *
+ * The rotation matches the standard 2d rotation matrix
+ * `[cos, -sin; sin, cos]`, i.e. counter-clockwise in a Y-up frame and clockwise in the Y-down
+ * frames used by grid/screen space. Callers own any rounding or snapping of the result.
+ *
+ * @param {Float64Array|Float32Array|number[]} result
+ * @param {number} result_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} cos cosine of the rotation angle
+ * @param {number} sin sine of the rotation angle
+ */
+export function v2_rotate_cos_sin(result: Float64Array | Float32Array | number[], result_offset: number, x: number, y: number, cos: number, sin: number): void;
+//# sourceMappingURL=v2_rotate_cos_sin.d.ts.map

package/src/core/geom/vec2/v2_rotate_cos_sin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v2_rotate_cos_sin.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec2/v2_rotate_cos_sin.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,0CAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,OACN,MAAM,OACN,MAAM,QAKhB"}

package/src/core/geom/vec2/v2_rotate_cos_sin.js

@@ -0,0 +1,21 @@
+/**
+ * Rotate a 2d vector around the origin, given the cosine and sine of the angle.
+ *
+ * This exists so that a loop rotating many vectors by the *same* angle pays for `Math.cos`/`Math.sin`
+ * once instead of once per vector. Prefer {@link v2_rotate} when only a single vector is rotated.
+ *
+ * The rotation matches the standard 2d rotation matrix
+ * `[cos, -sin; sin, cos]`, i.e. counter-clockwise in a Y-up frame and clockwise in the Y-down
+ * frames used by grid/screen space. Callers own any rounding or snapping of the result.
+ *
+ * @param {Float64Array|Float32Array|number[]} result
+ * @param {number} result_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} cos cosine of the rotation angle
+ * @param {number} sin sine of the rotation angle
+ */
+export function v2_rotate_cos_sin(result, result_offset, x, y, cos, sin) {
+    result[result_offset] = x * cos - y * sin;
+    result[result_offset + 1] = x * sin + y * cos;
+}

package/src/core/geom/vec3/v3_lerp.d.ts

@@ -1,6 +1,6 @@
 /**
  *
- * @param {Vector3|{set:function(x:number,y:number,z:number)}} result
+ * @param {Vector3|{set:(x: number, y: number, z: number) => void}} result
  * @param {number} a_x
  * @param {number} a_y
  * @param {number} a_z

package/src/core/geom/vec3/v3_lerp.js

@@ -3,7 +3,7 @@ import { lerp } from "../../math/lerp.js";
 
 /**
  *
- * @param {Vector3|{set:function(x:number,y:number,z:number)}} result
+ * @param {Vector3|{set:(x: number, y: number, z: number) => void}} result
  * @param {number} a_x
  * @param {number} a_y
  * @param {number} a_z

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

@@ -0,0 +1,30 @@
+/**
+ * Build a symmetric {@link CSRGraph} from an undirected edge list — the producer `core/graph/csr` was
+ * missing.
+ *
+ * WHY this exists: the package ships plenty of CSR *consumers* (`csr_graph_find_edge`,
+ * `csr_graph_build_distance_field`, `csr_graph_find_shortest_path`) but nothing that turns an
+ * `{a[], b[], weights[]}` edge list into one, so every caller re-derived the same three-pass idiom by hand:
+ * count degrees, prefix-sum them into row offsets, then fill both half-edges through a per-vertex write
+ * cursor. It is short but easy to get subtly wrong (forgetting that an undirected edge occupies a slot at
+ * BOTH endpoints, or advancing the cursor for only one of them), and a bug shows up as silently truncated
+ * adjacency rather than a crash.
+ *
+ * Each undirected edge `(a[e], b[e])` contributes a row entry at both endpoints, so
+ * `adjacency_length === 2 · edge_count`. Rows come out SORTED ascending by neighbour id, with
+ * `edge_weights` permuted alongside — the conventional CSR form, which makes the adjacency a canonical
+ * function of the edge SET rather than of the order the edges happened to be appended in, and lets callers
+ * binary-search a row. Degrees in the graphs this serves are small, so the per-row sort is an insertion
+ * sort and costs nothing measurable next to building the edge list itself.
+ *
+ * A self-loop `a[e] === b[e]` would occupy two slots in the same row; callers are expected not to emit one.
+ *
+ * @param {number} vertex_count
+ * @param {ArrayLike<number>} a per-edge first endpoint, each in `[0, vertex_count)`
+ * @param {ArrayLike<number>} b per-edge second endpoint, each in `[0, vertex_count)`; parallel to `a`
+ * @param {ArrayLike<number>} edge_weights per-edge weight, parallel to `a`/`b`; both half-edges get it
+ * @returns {CSRGraph}
+ */
+export function csr_graph_from_undirected_edge_list(vertex_count: number, a: ArrayLike<number>, b: ArrayLike<number>, edge_weights: ArrayLike<number>): CSRGraph;
+import { CSRGraph } from "./CSRGraph.js";
+//# sourceMappingURL=csr_graph_from_undirected_edge_list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csr_graph_from_undirected_edge_list.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/csr_graph_from_undirected_edge_list.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,kEANW,MAAM,KACN,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAiEpB;yBA5FwB,eAAe"}

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

@@ -0,0 +1,94 @@
+import { assert } from "../../assert.js";
+import { CSRGraph } from "./CSRGraph.js";
+
+/**
+ * Build a symmetric {@link CSRGraph} from an undirected edge list — the producer `core/graph/csr` was
+ * missing.
+ *
+ * WHY this exists: the package ships plenty of CSR *consumers* (`csr_graph_find_edge`,
+ * `csr_graph_build_distance_field`, `csr_graph_find_shortest_path`) but nothing that turns an
+ * `{a[], b[], weights[]}` edge list into one, so every caller re-derived the same three-pass idiom by hand:
+ * count degrees, prefix-sum them into row offsets, then fill both half-edges through a per-vertex write
+ * cursor. It is short but easy to get subtly wrong (forgetting that an undirected edge occupies a slot at
+ * BOTH endpoints, or advancing the cursor for only one of them), and a bug shows up as silently truncated
+ * adjacency rather than a crash.
+ *
+ * Each undirected edge `(a[e], b[e])` contributes a row entry at both endpoints, so
+ * `adjacency_length === 2 · edge_count`. Rows come out SORTED ascending by neighbour id, with
+ * `edge_weights` permuted alongside — the conventional CSR form, which makes the adjacency a canonical
+ * function of the edge SET rather than of the order the edges happened to be appended in, and lets callers
+ * binary-search a row. Degrees in the graphs this serves are small, so the per-row sort is an insertion
+ * sort and costs nothing measurable next to building the edge list itself.
+ *
+ * A self-loop `a[e] === b[e]` would occupy two slots in the same row; callers are expected not to emit one.
+ *
+ * @param {number} vertex_count
+ * @param {ArrayLike<number>} a per-edge first endpoint, each in `[0, vertex_count)`
+ * @param {ArrayLike<number>} b per-edge second endpoint, each in `[0, vertex_count)`; parallel to `a`
+ * @param {ArrayLike<number>} edge_weights per-edge weight, parallel to `a`/`b`; both half-edges get it
+ * @returns {CSRGraph}
+ */
+export function csr_graph_from_undirected_edge_list(vertex_count, a, b, edge_weights) {
+    assert.isNonNegativeInteger(vertex_count, 'vertex_count');
+    assert.equal(b.length, a.length, 'b.length !== a.length');
+    assert.greaterThanOrEqual(edge_weights.length, a.length, 'edge_weights shorter than the edge list');
+
+    const edge_count = a.length;
+
+    const graph = new CSRGraph(vertex_count, edge_count * 2);
+
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const weights = graph.edge_weights;
+
+    // pass 1 — degree of every vertex (both endpoints of each undirected edge)
+    for (let e = 0; e < edge_count; e++) {
+        edge_addresses[a[e] + 1]++;
+        edge_addresses[b[e] + 1]++;
+    }
+
+    // pass 2 — prefix-sum the degrees into row offsets (edge_addresses[v] is now the start of v's row)
+    for (let v = 0; v < vertex_count; v++) {
+        edge_addresses[v + 1] += edge_addresses[v];
+    }
+
+    // pass 3 — fill both half-edges through a per-vertex write cursor
+    const cursor = edge_addresses.slice(0, vertex_count);
+
+    for (let e = 0; e < edge_count; e++) {
+        const u = a[e];
+        const v = b[e];
+        const w = edge_weights[e];
+
+        adjacency[cursor[u]] = v;
+        weights[cursor[u]] = w;
+        cursor[u]++;
+
+        adjacency[cursor[v]] = u;
+        weights[cursor[v]] = w;
+        cursor[v]++;
+    }
+
+    // pass 4 — canonicalise each row (ascending neighbour id), carrying the weights along
+    for (let v = 0; v < vertex_count; v++) {
+        const start = edge_addresses[v];
+        const end = edge_addresses[v + 1];
+
+        for (let i = start + 1; i < end; i++) {
+            const neighbour = adjacency[i];
+            const weight = weights[i];
+
+            let j = i - 1;
+            while (j >= start && adjacency[j] > neighbour) {
+                adjacency[j + 1] = adjacency[j];
+                weights[j + 1] = weights[j];
+                j--;
+            }
+
+            adjacency[j + 1] = neighbour;
+            weights[j + 1] = weight;
+        }
+    }
+
+    return graph;
+}

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":"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"}
+{"version":3,"file":"CircleLayout.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/CircleLayout.js"],"names":[],"mappings":"AA0HA;;;;;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;mBAp4BkB,gCAAgC;oBAI/B,uBAAuB"}

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

@@ -1,8 +1,10 @@
+import { graph_peel_topological_layer } from "./graph_peel_topological_layer.js";
 import { assert } from "../../assert.js";
 import AABB2 from "../../geom/2d/aabb/AABB2.js";
 import Circle from "../../geom/2d/circle/Circle.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 { v2_length } from "../../geom/vec2/v2_length.js";
 import Vector2 from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
@@ -22,35 +24,10 @@ function doLayerLayout(circles) {
         return b.locked !== true;
     });
 
-    function buildLayer() {
-        const layer = [];
-
-        main_loop:for (let i = remaining.length - 1; i >= 0; i--) {
-            const box = remaining[i];
-            const connections = box.connections;
-
-            for (let j = 0; j < connections.length; j++) {
-                const connection = connections[j];
-
-                const source = connection.source;
-                if (source !== box && remaining.indexOf(source) !== -1) {
-                    //not closed yet
-                    continue main_loop;
-                }
-            }
-
-            remaining.splice(i, 1);
-
-            //all sources are already laid out
-            layer.push(box);
-        }
-
-        return layer;
-    }
 
     let offsetY = 0;
     while (remaining.length > 0) {
-        const layer = buildLayer();
+        const layer = graph_peel_topological_layer(remaining);
 
         if (layer.length === 0) {
             console.error("Layer is empty", remaining, circles, offsetY);
@@ -285,7 +262,7 @@ function applyPull(edges, strength) {
         const dX = x1 - x0;
         const dY = y1 - y0;
 
-        const length = Math.sqrt(dX * dX + dY * dY);
+        const length = v2_length(dX, dY);
 
         const r0 = c0.r;
         const r1 = c1.r;
@@ -742,7 +719,7 @@ function resolveCircleLineOverlap(circle, c0, c1) {
             const ndX = cX - nX;
             const ndY = cY - nY;
 
-            const ncD = Math.sqrt(ndX * ndX + ndY * ndY);
+            const ncD = v2_length(ndX, ndY);
 
             //compute penetration distance
             const penD = r - ncD;
@@ -877,7 +854,7 @@ export function resolveCircleOverlapStep(numCircles, circles) {
             const dx = x1 - x0;
             const dy = y1 - y0;
 
-            const distance = Math.sqrt(dx * dx + dy * dy);
+            const distance = v2_length(dx, dy);
 
             const minSeparation = r0 + r1;
 

package/src/core/graph/layout/box/BoxLayouter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BoxLayouter.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/BoxLayouter.js"],"names":[],"mappings":"AAyaA;;;;GAIG;AACH,+CAHW,KAAK,EAAE,UACP,OAAO,QASjB;kBA/aiB,gCAAgC;oBAC9B,0BAA0B;AAub9C;;;;;GAKG;AACH,mCAJW,MAAO,KAAK,CAAC,yBAEb,OAAO,QA0FjB;AArGD,gDAKC"}
+{"version":3,"file":"BoxLayouter.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/BoxLayouter.js"],"names":[],"mappings":"AAiZA;;;;GAIG;AACH,+CAHW,KAAK,EAAE,UACP,OAAO,QASjB;kBAtZiB,gCAAgC;oBAC9B,0BAA0B;AA8Z9C;;;;;GAKG;AACH,mCAJW,MAAO,KAAK,CAAC,yBAEb,OAAO,QA0FjB;AArGD,gDAKC"}

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

@@ -1,3 +1,4 @@
+import { graph_peel_topological_layer } from "../graph_peel_topological_layer.js";
 /**
  *
  * @param {Array.<AABB2>} boxes
@@ -358,35 +359,10 @@ function doLayerLayout(boxes) {
         return b.locked !== true;
     });
 
-    function buildLayer() {
-        const layer = [];
-
-        main_loop:for (let i = remaining.length - 1; i >= 0; i--) {
-            const box = remaining[i];
-            const connections = box.connections;
-
-            for (let j = 0; j < connections.length; j++) {
-                const connection = connections[j];
-
-                const source = connection.source;
-                if (source !== box && remaining.indexOf(source) !== -1) {
-                    //not closed yet
-                    continue main_loop;
-                }
-            }
-
-            remaining.splice(i, 1);
-
-            //all sources are already laid out
-            layer.push(box);
-        }
-
-        return layer;
-    }
 
     let offsetY = 0;
     while (remaining.length > 0) {
-        const layer = buildLayer();
+        const layer = graph_peel_topological_layer(remaining);
 
         if (layer.length === 0) {
             console.error("Layer is empty", remaining, boxes, offsetY);

package/src/core/graph/layout/box/position_box_next_to_box.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"position_box_next_to_box.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/position_box_next_to_box.js"],"names":[],"mappings":"AA8JA;;;;;;GAMG;AACH,8CALW,KAAK,UACL,KAAK,UACL,KAAK,GACH,KAAK,CAsCjB;kBAzMiB,gCAAgC"}
+{"version":3,"file":"position_box_next_to_box.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/position_box_next_to_box.js"],"names":[],"mappings":"AA+JA;;;;;;GAMG;AACH,8CALW,KAAK,UACL,KAAK,UACL,KAAK,GACH,KAAK,CAsCjB;kBAzMiB,gCAAgC"}

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

@@ -1,3 +1,4 @@
+import { v2_length } from "../../../geom/vec2/v2_length.js";
 import AABB2 from "../../../geom/2d/aabb/AABB2.js";
 import Vector2 from "../../../geom/Vector2.js";
 import { EPSILON } from "../../../math/EPSILON.js";
@@ -34,7 +35,7 @@ function compute_initial_placement(
     const targetH = target.height;
     const targetW = target.width;
 
-    const targetDiagonal = Math.sqrt(targetH * targetH + targetW * targetW);
+    const targetDiagonal = v2_length(targetW, targetH);
 
     const boxWidth = box.width;
     const boxHeight = box.height;

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

@@ -1 +1 @@
-{"version":3,"file":"computeDisconnectedSubGraphs.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/computeDisconnectedSubGraphs.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oDAHW;IAAC,WAAW,EAAC,YAAY,CAAA;CAAC,EAAE,SAuDtC"}
+{"version":3,"file":"computeDisconnectedSubGraphs.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/computeDisconnectedSubGraphs.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oDAHW;IAAC,WAAW,EAAC,YAAY,CAAA;CAAC,EAAE,SAkEtC"}

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

@@ -8,15 +8,20 @@ export function computeDisconnectedSubGraphs(nodes) {
     //find disconnected sub-graphs
     const unexplored = nodes.slice();
 
+    // Membership mirror. This used to be `unexplored.indexOf(node)` + `splice`, which made the whole
+    // traversal O(n^2). Claimed nodes are now skipped at pop time instead of being spliced out: since
+    // `splice` removed from the middle while `pop` reads from the end, the order of the remaining nodes --
+    // and therefore the sequence of cluster seeds -- is identical either way.
+    const claimed = new Set();
+
     let cursor, i;
 
 
     let currentCluster;
 
     function exploreNode(node) {
-        const i = unexplored.indexOf(node);
-        if (i !== -1) {
-            unexplored.splice(i, 1);
+        if (!claimed.has(node)) {
+            claimed.add(node);
 
             currentCluster.push(node);
         }
@@ -27,6 +32,12 @@ export function computeDisconnectedSubGraphs(nodes) {
     while (unexplored.length > 0) {
         const node = unexplored.pop();
 
+        if (claimed.has(node)) {
+            continue;
+        }
+
+        claimed.add(node);
+
         currentCluster = [node];
 
         cursor = 0;

package/src/core/graph/layout/graph_peel_topological_layer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Peel one topological layer off `remaining`: every node whose incoming connections all originate outside
+ * `remaining` (i.e. from nodes already laid out) is removed from it and returned.
+ *
+ * MUTATES `remaining` — peeled nodes are spliced out, so repeated calls walk the graph layer by layer and
+ * an empty result means the rest of the graph is cyclic.
+ *
+ * Self-connections are ignored, so a node pointing at itself does not block its own layer.
+ *
+ * Pure graph topology, no geometry: shared verbatim by the box and circle layouters, which each held an
+ * identical private copy closed over their own `remaining`.
+ *
+ * @template {{ connections: Array<{ source: * }> }} T
+ * @param {T[]} remaining nodes not yet laid out; mutated
+ * @returns {T[]} the peeled layer, empty when nothing can be peeled
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function graph_peel_topological_layer<T extends {
+    connections: Array<{
+        source: any;
+    }>;
+}>(remaining: T[]): T[];
+//# sourceMappingURL=graph_peel_topological_layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_peel_topological_layer.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/graph_peel_topological_layer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;iBAP6B,MAAM;QAAE,MAAM,MAAG;KAAE,CAAC;wBAgChD"}