@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/sound/simulation/probe/bakeReverbBands.js

@@ -1,7 +1,7 @@
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
 import { sphere_fibonacci_point } from "../../../../core/geom/3d/sphere/sphere_fibonacci_point.js";
+import { random_orthonormal_basis } from "../../../../core/geom/random/random_orthonormal_basis.js";
 import { v3_matrix3_rotate } from "../../../../core/geom/vec3/v3_matrix3_rotate.js";
-import { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
 import { acoustic_trace_energy, SPEED_OF_SOUND_MPS } from "./acoustic_trace_energy.js";
 import { echogram_band_rt60 } from "./echogram_band_rt60.js";
 
@@ -67,11 +67,7 @@ export function bakeReverbBands(
     DIRECTION_ACCUM.fill(0);
 
     // randomly orient the Fibonacci set so accumulation isn't biased by the fixed lattice
-    const rz = 2 * random() - 1;
-    const ra = 2 * Math.PI * random();
-    const rr = Math.sqrt(Math.max(0, 1 - rz * rz));
-
-    v3_orthonormal_matrix_from_normal(ROTATION, 0, rr * Math.cos(ra), rr * Math.sin(ra), rz);
+    random_orthonormal_basis(ROTATION, 0, random);
 
     for (let i = 0; i < rayCount; i++) {
         sphere_fibonacci_point(FIBONACCI, 0, i, rayCount);

package/src/engine/sound/simulation/probe/bakeVisibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bakeVisibility.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeVisibility.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uGAJW,UAAU,MAAM,CAAC,eACjB,MAAM,sBAiHhB;AAED;;;;;;;;;;;;;;GAcG;AACH,qEARW,MAAM,WACN,MAAM,WACN,MAAM,aACN,MAAM,aACN,MAAM,aACN,MAAM,GACJ;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,EAAE,GAAC,IAAI,CAiB/C"}
+{"version":3,"file":"bakeVisibility.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeVisibility.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uGAJW,UAAU,MAAM,CAAC,eACjB,MAAM,sBAiFhB;AAED;;;;;;;;;;;;;;GAcG;AACH,qEARW,MAAM,WACN,MAAM,WACN,MAAM,aACN,MAAM,aACN,MAAM,aACN,MAAM,GACJ;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,EAAE,GAAC,IAAI,CAiB/C"}

package/src/engine/sound/simulation/probe/bakeVisibility.js

@@ -1,4 +1,6 @@
-import { CSRGraph } from "../../../../core/graph/csr/CSRGraph.js";
+import {
+    csr_graph_from_undirected_edge_list
+} from "../../../../core/graph/csr/csr_graph_from_undirected_edge_list.js";
 import { probe_delaunay_edges } from "./probe_delaunay_edges.js";
 import { probe_densify_portals } from "./probe_densify_portals.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
@@ -106,39 +108,7 @@ export function bakeVisibility(probeField, index, portals = NO_PORTALS, minSpaci
         edgeW[e] = Math.sqrt(dx * dx + dy * dy + dz * dz);
     }
 
-    // build CSR adjacency: each undirected edge contributes a row entry at BOTH endpoints
-    const adjacency_length = edgeCount * 2;
-
-    const degree = new Uint32Array(n);
-    for (let e = 0; e < edgeCount; e++) {
-        degree[edgeA[e]]++;
-        degree[edgeB[e]]++;
-    }
-
-    const edge_addresses = new Uint32Array(n + 1);
-    for (let v = 0; v < n; v++) {
-        edge_addresses[v + 1] = edge_addresses[v] + degree[v];
-    }
-
-    const adjacency = new Uint32Array(adjacency_length);
-    const edge_weights = new Float32Array(adjacency_length);
-    const cursor = edge_addresses.slice(0, n); // per-vertex write cursor, starting at each row's offset
-
-    for (let e = 0; e < edgeCount; e++) {
-        const a = edgeA[e];
-        const b = edgeB[e];
-        const w = edgeW[e];
-
-        adjacency[cursor[a]] = b;
-        edge_weights[cursor[a]] = w;
-        cursor[a]++;
-
-        adjacency[cursor[b]] = a;
-        edge_weights[cursor[b]] = w;
-        cursor[b]++;
-    }
-
-    const graph = CSRGraph.fromArrays(n, edge_addresses, adjacency, edge_weights);
+    const graph = csr_graph_from_undirected_edge_list(n, edgeA, edgeB, edgeW);
 
     probeField.setVisibilityGraph(graph);
 

package/src/engine/sound/simulation/probe/probe_densify_portals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_densify_portals.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_densify_portals.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CARW,OAAO,yBAAyB,EAAE,kBAAkB,SACpD,OAAO,kCAAkC,EAAE,qBAAqB,WAChE,UAAU,MAAM,CAAC,SACjB;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,cAC5C,MAAM;2BACkB,MAAM;mBAAiB,MAAM;iBAAe,MAAM;IACxE;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CAyEtC"}
+{"version":3,"file":"probe_densify_portals.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_densify_portals.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CARW,OAAO,yBAAyB,EAAE,kBAAkB,SACpD,OAAO,kCAAkC,EAAE,qBAAqB,WAChE,UAAU,MAAM,CAAC,SACjB;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,cAC5C,MAAM;2BACkB,MAAM;mBAAiB,MAAM;iBAAe,MAAM;IACxE;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CAyEtC"}

package/src/engine/sound/simulation/probe/probe_densify_portals.js

@@ -1,4 +1,5 @@
 import { line3_compute_segment_point_distance_sqr } from "../../../../core/geom/3d/line/line3_compute_segment_point_distance_sqr.js";
+import { probe_edge_key } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
 // Gather neighbours of a portal within this × minSpacing — far enough to reach probes on BOTH sides of a wall
@@ -55,7 +56,7 @@ export function probe_densify_portals(field, index, portals, edges, minSpacing,
     // existing + newly-added edges, keyed undirected, so a chord the base graph already has is not duplicated
     const seen = new Set();
     for (let i = 0; i < edges.a.length; i++) {
-        seen.add(edgeKey(edges.a[i], edges.b[i], n));
+        seen.add(probe_edge_key(edges.a[i], edges.b[i], n));
     }
 
     const hits = []; // probesWithinRadius scratch (auto-grows; valid length is the returned count)
@@ -82,7 +83,7 @@ export function probe_densify_portals(field, index, portals, edges, minSpacing,
             for (let b = a + 1; b < neighbours.length; b++) {
                 const j = neighbours[b];
 
-                const key = edgeKey(i, j, n);
+                const key = probe_edge_key(i, j, n);
                 if (seen.has(key)) {
                     continue;
                 }
@@ -137,7 +138,3 @@ function nearestVisible(field, index, p, px, py, pz, hits, count, max) {
     return found.map((o) => o.j);
 }
 
-/** Undirected edge key (order-independent). */
-function edgeKey(a, b, n) {
-    return a < b ? a * n + b : b * n + a;
-}

package/src/engine/sound/simulation/probe/probe_edge_key.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Canonical (order-independent) integer key for an undirected pair of probe indices: `min·probe_count + max`.
+ *
+ * WHY this exists: the probe bake keys undirected pairs in four different modules (visibility augmentation's
+ * dedup set, portal densification's dedup set, component bridging's per-component-pair best-candidate map, and
+ * the runtime {@link ProbeVisibilityRecheck} dirty queue). The packing carries TWO invariants that are easy to
+ * break independently — the pair must be canonicalised (so `(a,b)` and `(b,a)` collide deliberately) and the
+ * radix must be the PROBE COUNT (so distinct pairs never collide). Re-deriving it per module meant a change of
+ * packing — say to bit-shifts once a field exceeds 2^26 probes and the product loses exact integer precision —
+ * would have to be found in four places. Encode and decode live together here so they cannot drift apart.
+ *
+ * PRECONDITION: `a` and `b` are in `[0, probe_count)` and `probe_count² ≤ Number.MAX_SAFE_INTEGER`.
+ *
+ * @param {number} a probe index
+ * @param {number} b probe index
+ * @param {number} probe_count number of probes in the field — the packing radix
+ * @returns {number} canonical key, equal for `(a,b)` and `(b,a)`
+ */
+export function probe_edge_key(a: number, b: number, probe_count: number): number;
+/**
+ * Unpack a {@link probe_edge_key} back into its two probe indices, written into `result` as
+ * `[low, high]`. The inverse of {@link probe_edge_key} — kept beside it so the radix convention has a
+ * single owner.
+ *
+ * @param {number[]|Uint32Array} result receives 2 elements: the lower then the higher probe index
+ * @param {number} result_offset
+ * @param {number} key a key produced by {@link probe_edge_key} with the same `probe_count`
+ * @param {number} probe_count the packing radix the key was built with
+ */
+export function probe_edge_key_decode(result: number[] | Uint32Array, result_offset: number, key: number, probe_count: number): void;
+//# sourceMappingURL=probe_edge_key.d.ts.map

package/src/engine/sound/simulation/probe/probe_edge_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe_edge_key.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_edge_key.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,kCALW,MAAM,KACN,MAAM,eACN,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;;GASG;AACH,8CALW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,OACN,MAAM,eACN,MAAM,QAKhB"}

package/src/engine/sound/simulation/probe/probe_edge_key.js

@@ -0,0 +1,38 @@
+/**
+ * Canonical (order-independent) integer key for an undirected pair of probe indices: `min·probe_count + max`.
+ *
+ * WHY this exists: the probe bake keys undirected pairs in four different modules (visibility augmentation's
+ * dedup set, portal densification's dedup set, component bridging's per-component-pair best-candidate map, and
+ * the runtime {@link ProbeVisibilityRecheck} dirty queue). The packing carries TWO invariants that are easy to
+ * break independently — the pair must be canonicalised (so `(a,b)` and `(b,a)` collide deliberately) and the
+ * radix must be the PROBE COUNT (so distinct pairs never collide). Re-deriving it per module meant a change of
+ * packing — say to bit-shifts once a field exceeds 2^26 probes and the product loses exact integer precision —
+ * would have to be found in four places. Encode and decode live together here so they cannot drift apart.
+ *
+ * PRECONDITION: `a` and `b` are in `[0, probe_count)` and `probe_count² ≤ Number.MAX_SAFE_INTEGER`.
+ *
+ * @param {number} a probe index
+ * @param {number} b probe index
+ * @param {number} probe_count number of probes in the field — the packing radix
+ * @returns {number} canonical key, equal for `(a,b)` and `(b,a)`
+ */
+export function probe_edge_key(a, b, probe_count) {
+    return a < b
+        ? a * probe_count + b
+        : b * probe_count + a;
+}
+
+/**
+ * Unpack a {@link probe_edge_key} back into its two probe indices, written into `result` as
+ * `[low, high]`. The inverse of {@link probe_edge_key} — kept beside it so the radix convention has a
+ * single owner.
+ *
+ * @param {number[]|Uint32Array} result receives 2 elements: the lower then the higher probe index
+ * @param {number} result_offset
+ * @param {number} key a key produced by {@link probe_edge_key} with the same `probe_count`
+ * @param {number} probe_count the packing radix the key was built with
+ */
+export function probe_edge_key_decode(result, result_offset, key, probe_count) {
+    result[result_offset] = (key / probe_count) | 0;
+    result[result_offset + 1] = key % probe_count;
+}

package/src/engine/sound/simulation/probe/probe_sdf_grid.d.ts

@@ -28,9 +28,16 @@ export function build_sdf_grid(index: AcousticOccluderIndex, bounds: number[], m
 /** World position of the (fractional) voxel coordinate `(fx,fy,fz)`, written into `out`. */
 export function grid_voxel_to_world(grid: any, out: any, fx: any, fy: any, fz: any): void;
 /** SDF at a WORLD position via trilinear interpolation of the grid (edge-clamped). */
-export function grid_sample_world(grid: any, x: any, y: any, z: any): any;
-/** Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped). */
-export function grid_sample_trilinear(grid: any, x: any, y: any, z: any): any;
+export function grid_sample_world(grid: any, x: any, y: any, z: any): number;
+/**
+ * Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped).
+ *
+ * The grid is a plain `z·(rx·ry) + y·rx + x` single-channel Float32 volume — exactly the layout
+ * {@link scs3d_sample_linear} samples — so the interpolation is delegated rather than re-derived here.
+ * (Same clamp semantics: clamping the COORDINATE into `[0, res-1]` and clamping the two sample INDICES
+ * agree on every input, including out-of-range coordinates, where both collapse to the edge voxel.)
+ */
+export function grid_sample_trilinear(grid: any, x: any, y: any, z: any): number;
 /**
  * Gradient-ascend a voxel to the local SDF maximum (the most-open sub-voxel point), written into `out` as a
  * fractional voxel coordinate clamped to within ½ voxel of the start. Central-difference gradient on the

package/src/engine/sound/simulation/probe/probe_sdf_grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_sdf_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_sdf_grid.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;GAUG;AACH,qEALW,MAAM,EAAE,cACR,MAAM,oBACN,MAAM,GACJ,OAAO,CA8CnB;AAED,4FAA4F;AAC5F,0FAIC;AAED,sFAAsF;AACtF,0EAKC;AAED,uFAAuF;AACvF,8EAkBC;AAED;;;;GAIG;AACH,yFAqBC;AAED;;;GAGG;AACH,yGAuBC;AA9KD,2BAA4B;AAE5B,mCAAoC;AAGpC,yCAA0C;;;;;;;;;;SAW5B,YAAY;QACZ,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;;;;aAClD,MAAM;;;;WAA6B,MAAM;QACzC,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;QAClD,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;SAClD,MAAM;SAAiB,MAAM;;;;SAAiB,MAAM;gBACpD,MAAM;;;;gBAAwB,MAAM;;;;oBACpC,MAAM"}
+{"version":3,"file":"probe_sdf_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_sdf_grid.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;GAUG;AACH,qEALW,MAAM,EAAE,cACR,MAAM,oBACN,MAAM,GACJ,OAAO,CA8CnB;AAED,4FAA4F;AAC5F,0FAIC;AAED,sFAAsF;AACtF,6EAKC;AAED;;;;;;;GAOG;AACH,iFAEC;AAED;;;;GAIG;AACH,yFAqBC;AAED;;;GAGG;AACH,yGAuBC;AArKD,2BAA4B;AAE5B,mCAAoC;AAGpC,yCAA0C;;;;;;;;;;SAW5B,YAAY;QACZ,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;;;;aAClD,MAAM;;;;WAA6B,MAAM;QACzC,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;QAClD,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;SAClD,MAAM;SAAiB,MAAM;;;;SAAiB,MAAM;gBACpD,MAAM;;;;gBAAwB,MAAM;;;;oBACpC,MAAM"}

package/src/engine/sound/simulation/probe/probe_sdf_grid.js

@@ -1,5 +1,6 @@
 import { clamp } from "../../../../core/math/clamp.js";
 import { lerp } from "../../../../core/math/lerp.js";
+import { scs3d_sample_linear } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
 
 // Voxel grid is finer than the spacing hint so it resolves sub-`minSpacing` features (thin corridors).
 export const OVERSAMPLE = 2;
@@ -100,25 +101,16 @@ export function grid_sample_world(grid, x, y, z) {
     return grid_sample_trilinear(grid, fx, fy, fz);
 }
 
-/** Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped). */
+/**
+ * Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped).
+ *
+ * The grid is a plain `z·(rx·ry) + y·rx + x` single-channel Float32 volume — exactly the layout
+ * {@link scs3d_sample_linear} samples — so the interpolation is delegated rather than re-derived here.
+ * (Same clamp semantics: clamping the COORDINATE into `[0, res-1]` and clamping the two sample INDICES
+ * agree on every input, including out-of-range coordinates, where both collapse to the edge voxel.)
+ */
 export function grid_sample_trilinear(grid, x, y, z) {
-    const { sdf, rx, ry, rz, strideZ } = grid;
-
-    const x0 = Math.floor(x), y0 = Math.floor(y), z0 = Math.floor(z);
-    const u = x - x0, v = y - y0, w = z - z0;
-
-    const sx0 = clampInt(x0, rx), sy0 = clampInt(y0, ry), sz0 = clampInt(z0, rz);
-    const sx1 = clampInt(x0 + 1, rx), sy1 = clampInt(y0 + 1, ry), sz1 = clampInt(z0 + 1, rz);
-
-    const c000 = sdf[sz0 * strideZ + sy0 * rx + sx0], c100 = sdf[sz0 * strideZ + sy0 * rx + sx1];
-    const c010 = sdf[sz0 * strideZ + sy1 * rx + sx0], c110 = sdf[sz0 * strideZ + sy1 * rx + sx1];
-    const c001 = sdf[sz1 * strideZ + sy0 * rx + sx0], c101 = sdf[sz1 * strideZ + sy0 * rx + sx1];
-    const c011 = sdf[sz1 * strideZ + sy1 * rx + sx0], c111 = sdf[sz1 * strideZ + sy1 * rx + sx1];
-
-    const c00 = c000 + (c100 - c000) * u, c01 = c001 + (c101 - c001) * u;
-    const c10 = c010 + (c110 - c010) * u, c11 = c011 + (c111 - c011) * u;
-    const c0 = c00 + (c10 - c00) * v, c1 = c01 + (c11 - c01) * v;
-    return c0 + (c1 - c0) * w;
+    return scs3d_sample_linear(grid.sdf, grid.rx, grid.ry, grid.rz, x, y, z);
 }
 
 /**
@@ -177,7 +169,3 @@ export function grid_claim_sphere(claimed, grid, px, py, pz, radius) {
         }
     }
 }
-
-function clampInt(i, res) {
-    return i < 0 ? 0 : (i > res - 1 ? res - 1 : i);
-}

package/src/engine/sound/simulation/probe/probe_visibility_augment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_visibility_augment.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_augment.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yGANW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,kBAC5C,MAAM,kBACN,MAAM,mBACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA4HtC"}
+{"version":3,"file":"probe_visibility_augment.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_augment.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yGANW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,kBAC5C,MAAM,kBACN,MAAM,mBACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA4GtC"}

package/src/engine/sound/simulation/probe/probe_visibility_augment.js

@@ -1,3 +1,8 @@
+import { csr_graph_find_edge } from "../../../../core/graph/csr/csr_graph_find_edge.js";
+import {
+    csr_graph_from_undirected_edge_list
+} from "../../../../core/graph/csr/csr_graph_from_undirected_edge_list.js";
+import { probe_edge_key } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
 // A chord is worth adding when the straight line beats the existing 2-hop route through their shared
@@ -47,27 +52,11 @@ export function probe_visibility_augment(
         return { a: [], b: [] };
     }
 
-    // sorted CSR adjacency over the current edges (for 2-ring walks + O(log d) "already adjacent?" tests)
-    const degree = new Uint32Array(n);
-    for (let i = 0; i < m; i++) {
-        degree[edges.a[i]]++;
-        degree[edges.b[i]]++;
-    }
-    const addr = new Uint32Array(n + 1);
-    for (let v = 0; v < n; v++) {
-        addr[v + 1] = addr[v] + degree[v];
-    }
-    const adj = new Uint32Array(2 * m);
-    const cursor = addr.slice(0, n);
-    for (let i = 0; i < m; i++) {
-        const a = edges.a[i];
-        const b = edges.b[i];
-        adj[cursor[a]++] = b;
-        adj[cursor[b]++] = a;
-    }
-    for (let v = 0; v < n; v++) {
-        adj.subarray(addr[v], addr[v + 1]).sort();
-    }
+    // CSR adjacency over the current edges (for 2-ring walks + "already adjacent?" tests). Topology only —
+    // the walk never reads weights, so every edge is given the same (zero) weight.
+    const graph = csr_graph_from_undirected_edge_list(n, edges.a, edges.b, new Float32Array(m));
+    const addr = graph.edge_addresses;
+    const adj = graph.adjacency;
 
     // eligible chords (allowing duplicates from multiple shared neighbours; deduped at add-time)
     const candU = [];
@@ -96,7 +85,7 @@ export function probe_visibility_augment(
                 if (v <= u) {
                     continue; // canonical u<v (and skips v===u: u is a neighbour of w)
                 }
-                if (isNeighbour(adj, addr, u, v)) {
+                if (csr_graph_find_edge(graph, u, v) !== -1) {
                     continue; // already connected — a triangle, no shortcut needed
                 }
 
@@ -144,7 +133,7 @@ export function probe_visibility_augment(
         const idx = order[i];
         const u = candU[idx];
         const v = candV[idx];
-        const key = u * n + v;
+        const key = probe_edge_key(u, v, n);
         if (added.has(key)) {
             continue;
         }
@@ -155,28 +144,3 @@ export function probe_visibility_augment(
 
     return { a: outA, b: outB };
 }
-
-/**
- * Whether `v` is in `u`'s (sorted) adjacency slice — binary search.
- * @param {Uint32Array} adj
- * @param {Uint32Array} addr
- * @param {number} u
- * @param {number} v
- * @returns {boolean}
- */
-function isNeighbour(adj, addr, u, v) {
-    let lo = addr[u];
-    let hi = addr[u + 1] - 1;
-    while (lo <= hi) {
-        const mid = (lo + hi) >> 1;
-        const x = adj[mid];
-        if (x === v) {
-            return true;
-        } else if (x < v) {
-            lo = mid + 1;
-        } else {
-            hi = mid - 1;
-        }
-    }
-    return false;
-}

package/src/engine/sound/simulation/probe/probe_visibility_bridge_components.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_visibility_bridge_components.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_bridge_components.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mHALW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,WAC5C,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA8EtC"}
+{"version":3,"file":"probe_visibility_bridge_components.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_bridge_components.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mHALW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,WAC5C,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA8EtC"}

package/src/engine/sound/simulation/probe/probe_visibility_bridge_components.js

@@ -1,4 +1,5 @@
 import { uf_find, uf_init, uf_union } from "../../../../core/collection/union-find/union_find.js";
+import { probe_edge_key } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
 // Search radius for a bridge, as a multiple of the median base-edge length (the probe spacing). A door/wall
@@ -81,9 +82,9 @@ export function probe_visibility_bridge_components(field, index, edges, sources,
                 const dz = field.probeZ(j) - iz;
                 const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
 
-                const rlo = ri < rj ? ri : rj;
-                const rhi = ri < rj ? rj : ri;
-                const key = rlo * n + rhi;
+                // canonical per-component-PAIR key (component roots are probe indices, so the probe count is
+                // the right radix)
+                const key = probe_edge_key(ri, rj, n);
 
                 const prev = best.get(key);
                 if (prev === undefined || d < prev.d) {

package/src/engine/sound/simulation/render/foaReverbImpulseResponse.d.ts

@@ -4,10 +4,11 @@
  * (`directions`, band-major xyz, the 0…1 anisotropy vectors {@link bakeReverbBands} produces). Driven by a
  * SEEDED rng (reproducible).
  *
- * The synthesis mirrors {@link reverbImpulseResponse}: one white-noise stream is split into three bands
- * (one-pole filters) and each band is given its own exponential decay envelope (a band rings for its RT60).
- * `w` is the omni sum of the enveloped bands — identical to the scalar mono tail. The directional channels
- * are the SAME enveloped bands weighted by each band's arrival-direction component:
+ * The synthesis SHARES the tail kernel with {@link reverbImpulseResponse} ({@link reverb_band_tails}): one
+ * white-noise stream is split into three bands (one-pole filters) and each band is given its own exponential
+ * decay envelope (a band rings for its RT60). `w` is the omni sum of the enveloped bands — identical to the
+ * scalar mono tail. The directional channels are the SAME enveloped bands weighted by each band's
+ * arrival-direction component:
  *
  *   `x[i] = Σ_band bandTail[band][i] · directionX[band]`   (likewise `y`, `z`)
  *

package/src/engine/sound/simulation/render/foaReverbImpulseResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foaReverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/foaReverbImpulseResponse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8CAPW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM;OACZ,WAAW;OAAI,WAAW;OAAI,WAAW;OAAI,WAAW;EAkFvE"}
+{"version":3,"file":"foaReverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/foaReverbImpulseResponse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8CAPW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM;OACZ,WAAW;OAAI,WAAW;OAAI,WAAW;OAAI,WAAW;EAyEvE"}

package/src/engine/sound/simulation/render/foaReverbImpulseResponse.js

@@ -1,4 +1,4 @@
-import { LOW_MID_HZ, MID_HIGH_HZ } from "./reverbImpulseResponse.js";
+import { reverb_band_length, reverb_band_tails } from "./reverb_band_tails.js";
 
 /**
  * Build a first-order ambisonic (FOA / B-format) reverb impulse response — four MONO `AudioBuffer`s
@@ -6,10 +6,11 @@ import { LOW_MID_HZ, MID_HIGH_HZ } from "./reverbImpulseResponse.js";
  * (`directions`, band-major xyz, the 0…1 anisotropy vectors {@link bakeReverbBands} produces). Driven by a
  * SEEDED rng (reproducible).
  *
- * The synthesis mirrors {@link reverbImpulseResponse}: one white-noise stream is split into three bands
- * (one-pole filters) and each band is given its own exponential decay envelope (a band rings for its RT60).
- * `w` is the omni sum of the enveloped bands — identical to the scalar mono tail. The directional channels
- * are the SAME enveloped bands weighted by each band's arrival-direction component:
+ * The synthesis SHARES the tail kernel with {@link reverbImpulseResponse} ({@link reverb_band_tails}): one
+ * white-noise stream is split into three bands (one-pole filters) and each band is given its own exponential
+ * decay envelope (a band rings for its RT60). `w` is the omni sum of the enveloped bands — identical to the
+ * scalar mono tail. The directional channels are the SAME enveloped bands weighted by each band's
+ * arrival-direction component:
  *
  *   `x[i] = Σ_band bandTail[band][i] · directionX[band]`   (likewise `y`, `z`)
  *
@@ -40,9 +41,9 @@ export function foaReverbImpulseResponse(
 
     const sampleRate = ctx.sampleRate;
 
-    const lenLow = Math.max(1, Math.floor(decayBands[0] * sampleRate));
-    const lenMid = Math.max(1, Math.floor(decayBands[1] * sampleRate));
-    const lenHigh = Math.max(1, Math.floor(decayBands[2] * sampleRate));
+    const lenLow = reverb_band_length(decayBands[0], sampleRate);
+    const lenMid = reverb_band_length(decayBands[1], sampleRate);
+    const lenHigh = reverb_band_length(decayBands[2], sampleRate);
     const length = Math.max(lenLow, lenMid, lenHigh);
 
     const w = ctx.createBuffer(1, length, sampleRate);
@@ -60,34 +61,25 @@ export function foaReverbImpulseResponse(
     const dxMid = directions[3], dyMid = directions[4], dzMid = directions[5];
     const dxHigh = directions[6], dyHigh = directions[7], dzHigh = directions[8];
 
-    // one-pole smoothing coefficients for the band split: a = 1 − e^(−2π f / fs)
-    const aLow = 1 - Math.exp((-2 * Math.PI * LOW_MID_HZ) / sampleRate);
-    const aHigh = 1 - Math.exp((-2 * Math.PI * MID_HIGH_HZ) / sampleRate);
+    // each band's enveloped samples, shared by the omni and directional channels
+    const bandLow = new Float64Array(length);
+    const bandMid = new Float64Array(length);
+    const bandHigh = new Float64Array(length);
+
+    reverb_band_tails(
+        bandLow, bandMid, bandHigh,
+        length,
+        lenLow, lenMid, lenHigh,
+        decayPower, sampleRate, random
+    );
 
-    let lpLow = 0;
-    let lpHigh = 0;
     let sumSqW = 0;
 
     for (let i = 0; i < length; i++) {
 
-        const noise = random() * 2 - 1;
-
-        lpLow += aLow * (noise - lpLow);
-        lpHigh += aHigh * (noise - lpHigh);
-
-        // energy-preserving 3-way split: low + mid + high == noise
-        const low = lpLow;
-        const mid = lpHigh - lpLow;
-        const high = noise - lpHigh;
-
-        const envLow = i < lenLow ? Math.pow(1 - i / lenLow, decayPower) : 0;
-        const envMid = i < lenMid ? Math.pow(1 - i / lenMid, decayPower) : 0;
-        const envHigh = i < lenHigh ? Math.pow(1 - i / lenHigh, decayPower) : 0;
-
-        // each band's enveloped sample, shared by the omni and directional channels
-        const bLow = low * envLow;
-        const bMid = mid * envMid;
-        const bHigh = high * envHigh;
+        const bLow = bandLow[i];
+        const bMid = bandMid[i];
+        const bHigh = bandHigh[i];
 
         const wSample = bLow + bMid + bHigh;
         wData[i] = wSample;

package/src/engine/sound/simulation/render/reverbImpulseResponse.d.ts

@@ -15,12 +15,5 @@
  * @returns {AudioBuffer}
  */
 export function reverbImpulseResponse(ctx: BaseAudioContext, decayBands: Float32Array | number[], decayPower: number, random: () => number): AudioBuffer;
-/**
- * Band split frequencies (Hz): low | mid below this, mid | high below the second. Crude one-pole splits —
- * enough to give the reverb tail per-band timbre (a bright vs. dead room), it is decaying noise, not a
- * precise crossover. Exported so the directional ({@link foaReverbImpulseResponse}) path splits identically.
- * @type {number}
- */
-export const LOW_MID_HZ: number;
-export const MID_HIGH_HZ: 2500;
+export { LOW_MID_HZ, MID_HIGH_HZ } from "./reverb_band_tails.js";
 //# sourceMappingURL=reverbImpulseResponse.d.ts.map

package/src/engine/sound/simulation/render/reverbImpulseResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/reverbImpulseResponse.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM,GACf,WAAW,CAoDvB;AA3ED;;;;;GAKG;AACH,yBAFU,MAAM,CAEc;AAC9B,+BAAgC"}
+{"version":3,"file":"reverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/reverbImpulseResponse.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM,GACf,WAAW,CA2CvB"}

package/src/engine/sound/simulation/render/reverbImpulseResponse.js

@@ -1,11 +1,10 @@
+import { reverb_band_length, reverb_band_tails } from "./reverb_band_tails.js";
+
 /**
- * Band split frequencies (Hz): low | mid below this, mid | high below the second. Crude one-pole splits —
- * enough to give the reverb tail per-band timbre (a bright vs. dead room), it is decaying noise, not a
- * precise crossover. Exported so the directional ({@link foaReverbImpulseResponse}) path splits identically.
- * @type {number}
+ * The band split frequencies now live with the kernel that applies them ({@link reverb_band_tails}); they
+ * stay re-exported here because this module is where consumers have always imported them from.
  */
-export const LOW_MID_HZ = 250;
-export const MID_HIGH_HZ = 2500;
+export { LOW_MID_HZ, MID_HIGH_HZ } from "./reverb_band_tails.js";
 
 /**
  * Generate a stereo reverb impulse response from a PER-BAND decay time `[low, mid, high]` (the probe-baked
@@ -32,43 +31,34 @@ export function reverbImpulseResponse(
 
     const sampleRate = ctx.sampleRate;
 
-    const lenLow = Math.max(1, Math.floor(decayBands[0] * sampleRate));
-    const lenMid = Math.max(1, Math.floor(decayBands[1] * sampleRate));
-    const lenHigh = Math.max(1, Math.floor(decayBands[2] * sampleRate));
+    const lenLow = reverb_band_length(decayBands[0], sampleRate);
+    const lenMid = reverb_band_length(decayBands[1], sampleRate);
+    const lenHigh = reverb_band_length(decayBands[2], sampleRate);
     const length = Math.max(lenLow, lenMid, lenHigh);
 
     const ir = ctx.createBuffer(2, length, sampleRate);
 
-    // one-pole smoothing coefficients for the band split: a = 1 − e^(−2π f / fs)
-    const aLow = 1 - Math.exp((-2 * Math.PI * LOW_MID_HZ) / sampleRate);
-    const aHigh = 1 - Math.exp((-2 * Math.PI * MID_HIGH_HZ) / sampleRate);
+    // band scratch, allocated once and reused for BOTH channels (they differ only in their noise stream)
+    const bandLow = new Float64Array(length);
+    const bandMid = new Float64Array(length);
+    const bandHigh = new Float64Array(length);
 
     const channel_count = ir.numberOfChannels;
 
     for (let channel = 0; channel < channel_count; channel++) {
         const data = ir.getChannelData(channel);
 
-        let lpLow = 0;
-        let lpHigh = 0;
+        // each channel draws its OWN noise stream, so the stereo pair is decorrelated
+        reverb_band_tails(
+            bandLow, bandMid, bandHigh,
+            length,
+            lenLow, lenMid, lenHigh,
+            decayPower, sampleRate, random
+        );
 
+        // omni: the three enveloped bands summed back together
         for (let i = 0; i < length; i++) {
-
-            const noise = random() * 2 - 1;
-
-            lpLow += aLow * (noise - lpLow);
-            lpHigh += aHigh * (noise - lpHigh);
-
-            // energy-preserving 3-way split: low + mid + high == noise
-            const low = lpLow;
-            const mid = lpHigh - lpLow;
-            const high = noise - lpHigh;
-
-            const envLow = i < lenLow ? Math.pow(1 - i / lenLow, decayPower) : 0;
-            const envMid = i < lenMid ? Math.pow(1 - i / lenMid, decayPower) : 0;
-            const envHigh = i < lenHigh ? Math.pow(1 - i / lenHigh, decayPower) : 0;
-
-            data[i] = low * envLow + mid * envMid + high * envHigh;
-
+            data[i] = bandLow[i] + bandMid[i] + bandHigh[i];
         }
     }