@woosh/meep-engine 2.138.20 → 2.139.0

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_sample_interior_grid_points.js

@@ -0,0 +1,227 @@
+import { assert } from "../../../../../../assert.js";
+import { BVH, NULL_NODE } from "../../../../../../bvh2/bvh3/BVH.js";
+import { bvh_query_user_data_ray } from "../../../../../../bvh2/bvh3/query/bvh_query_user_data_ray.js";
+import { seededRandom } from "../../../../../../math/random/seededRandom.js";
+import { SurfacePoint3 } from "../../../../SurfacePoint3.js";
+import { computeTriangleRayIntersection } from "../../../../triangle/computeTriangleRayIntersection.js";
+
+// Three irrational, mutually unrelated ray directions for parity ray-cast
+// majority vote. Same scheme as tetrahedral_mesh_carve_outside_surface — a
+// single ray is fragile at grazing edges, three independent rays settle the
+// vote correctly except in vanishingly improbable configurations.
+const RAY_DIRECTIONS = [
+    0.97123,  0.18927,  0.14431,
+    0.34219,  0.91283, -0.22971,
+   -0.51237,  0.27894,  0.81235,
+];
+const RAY_COUNT = RAY_DIRECTIONS.length / 3;
+
+// Stratification offset cap (as a fraction of a cell). 0 = perfect grid
+// (worst case for Delaunay sliver count), 0.5 = candidates can sit anywhere
+// in the cell. 0.35 is the usual sweet spot: enough jitter to break all
+// face/edge alignments without losing the locality benefits of the grid.
+const JITTER = 0.35;
+
+/**
+ * Build a BVH whose leaves are the surface's triangle faces. User data on
+ * each leaf is the source face ID.
+ */
+function build_surface_bvh(bvh, mesh) {
+    bvh.release_all();
+
+    const face_count = mesh.faces.size;
+    const v = [0, 0, 0];
+
+    for (let f = 0; f < face_count; f++) {
+        if (!mesh.faces.is_allocated(f)) continue;
+
+        const l0 = mesh.face_read_loop(f);
+        const l1 = mesh.loop_read_next(l0);
+        const l2 = mesh.loop_read_next(l1);
+
+        const v0 = mesh.loop_read_vertex(l0);
+        const v1 = mesh.loop_read_vertex(l1);
+        const v2 = mesh.loop_read_vertex(l2);
+
+        mesh.vertex_read_coordinate(v, 0, v0);
+        let minx = v[0], miny = v[1], minz = v[2];
+        let maxx = v[0], maxy = v[1], maxz = v[2];
+
+        mesh.vertex_read_coordinate(v, 0, v1);
+        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
+        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
+        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
+
+        mesh.vertex_read_coordinate(v, 0, v2);
+        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
+        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
+        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
+
+        const node = bvh.allocate_node();
+        bvh.node_set_user_data(node, f);
+        bvh.node_set_aabb_primitive(node, minx, miny, minz, maxx, maxy, maxz);
+        bvh.insert_leaf(node);
+    }
+}
+
+const ray_hit = new SurfacePoint3();
+const ray_candidates = [];
+const va = [0, 0, 0];
+const vb = [0, 0, 0];
+const vc = [0, 0, 0];
+
+/**
+ * Parity ray-cast across `RAY_COUNT` directions; majority decides
+ * inside/outside. Returns true if (strict majority of) rays cross the
+ * surface an odd number of times.
+ */
+function point_is_inside(mesh, bvh, ox, oy, oz) {
+    const root = bvh.root;
+    if (root === NULL_NODE) return false;
+
+    let inside_votes = 0;
+
+    for (let r = 0; r < RAY_COUNT; r++) {
+        const dx = RAY_DIRECTIONS[r * 3];
+        const dy = RAY_DIRECTIONS[r * 3 + 1];
+        const dz = RAY_DIRECTIONS[r * 3 + 2];
+
+        const candidate_count = bvh_query_user_data_ray(
+            bvh, root,
+            ray_candidates, 0,
+            ox, oy, oz,
+            dx, dy, dz
+        );
+
+        let hits = 0;
+        for (let i = 0; i < candidate_count; i++) {
+            const f = ray_candidates[i];
+            const l0 = mesh.face_read_loop(f);
+            const l1 = mesh.loop_read_next(l0);
+            const l2 = mesh.loop_read_next(l1);
+
+            mesh.vertex_read_coordinate(va, 0, mesh.loop_read_vertex(l0));
+            mesh.vertex_read_coordinate(vb, 0, mesh.loop_read_vertex(l1));
+            mesh.vertex_read_coordinate(vc, 0, mesh.loop_read_vertex(l2));
+
+            const hit = computeTriangleRayIntersection(
+                ray_hit,
+                ox, oy, oz,
+                dx, dy, dz,
+                va[0], va[1], va[2],
+                vb[0], vb[1], vb[2],
+                vc[0], vc[1], vc[2]
+            );
+
+            if (hit) hits++;
+        }
+
+        if ((hits & 1) === 1) inside_votes++;
+    }
+
+    return inside_votes * 2 > RAY_COUNT;
+}
+
+/**
+ * Sample interior Steiner points for the volume enclosed by a closed
+ * triangle surface, on a jittered axis-aligned grid sized by
+ * `cells_per_dim`. Points outside the surface are discarded; what remains
+ * is a Float32Array of (x, y, z) tuples that lies strictly inside the
+ * surface (modulo classification noise on near-surface samples).
+ *
+ * Intended as input to `compute_delaunay_tetrahedral_mesh` alongside the
+ * surface vertices, so the Delaunay tet mesh has interior detail rather
+ * than being made entirely of surface-bound tets. Without these Steiner
+ * points, every tet of a non-trivial volume straddles or touches the
+ * surface, blowing up centroid-classification discretization error in
+ * the carving step.
+ *
+ * Grid cells are scaled so the longest bounding-box axis gets
+ * `cells_per_dim` cells; other axes get a proportional share rounded to
+ * the nearest integer (minimum 1). Each cell contributes one candidate
+ * point at its center, perturbed by a deterministic seeded jitter of up
+ * to ±0.35 cell widths — enough to break Delaunay-pathological
+ * alignments without losing the grid's spatial uniformity.
+ *
+ * @param {BinaryTopology} mesh closed surface
+ * @param {number} cells_per_dim grid resolution along the longest bbox axis
+ * @param {number} [seed] seed for the jitter RNG; same seed → same points
+ * @returns {Float32Array} flat (x, y, z) interior point positions
+ */
+export function bt_mesh_sample_interior_grid_points(mesh, cells_per_dim, seed = 0) {
+    assert.defined(mesh, 'mesh');
+    assert.equal(mesh.isBinaryTopology, true, 'mesh.isBinaryTopology !== true');
+    assert.isPositiveInteger(cells_per_dim, 'cells_per_dim');
+
+    // Compute bounding box from vertex pool.
+    const vertices = mesh.vertices;
+    const vertex_count = vertices.size;
+    const coord = [0, 0, 0];
+
+    let min_x = Infinity, min_y = Infinity, min_z = Infinity;
+    let max_x = -Infinity, max_y = -Infinity, max_z = -Infinity;
+
+    for (let v = 0; v < vertex_count; v++) {
+        if (!vertices.is_allocated(v)) continue;
+        mesh.vertex_read_coordinate(coord, 0, v);
+        if (coord[0] < min_x) min_x = coord[0]; if (coord[0] > max_x) max_x = coord[0];
+        if (coord[1] < min_y) min_y = coord[1]; if (coord[1] > max_y) max_y = coord[1];
+        if (coord[2] < min_z) min_z = coord[2]; if (coord[2] > max_z) max_z = coord[2];
+    }
+
+    if (!isFinite(min_x)) {
+        // Empty mesh.
+        return new Float32Array(0);
+    }
+
+    const dx = max_x - min_x;
+    const dy = max_y - min_y;
+    const dz = max_z - min_z;
+    const longest = Math.max(dx, dy, dz);
+
+    if (longest === 0) {
+        // Degenerate: all vertices coincide. No interior to sample.
+        return new Float32Array(0);
+    }
+
+    // Per-axis cell count, rounded so cells are roughly cubical.
+    const cells_x = Math.max(1, Math.round((cells_per_dim * dx) / longest));
+    const cells_y = Math.max(1, Math.round((cells_per_dim * dy) / longest));
+    const cells_z = Math.max(1, Math.round((cells_per_dim * dz) / longest));
+
+    const cell_w = dx / cells_x;
+    const cell_h = dy / cells_y;
+    const cell_d = dz / cells_z;
+
+    // Build BVH over surface triangles for the inside-test.
+    const bvh = new BVH();
+    build_surface_bvh(bvh, mesh);
+
+    const rng = seededRandom(seed);
+    const out = []; // grow dynamically; copy to Float32Array at the end
+
+    for (let iz = 0; iz < cells_z; iz++) {
+        const cz0 = min_z + (iz + 0.5) * cell_d;
+        for (let iy = 0; iy < cells_y; iy++) {
+            const cy0 = min_y + (iy + 0.5) * cell_h;
+            for (let ix = 0; ix < cells_x; ix++) {
+                const cx0 = min_x + (ix + 0.5) * cell_w;
+
+                // Jitter each axis independently within ±JITTER cells.
+                const jx = (rng() * 2 - 1) * JITTER * cell_w;
+                const jy = (rng() * 2 - 1) * JITTER * cell_h;
+                const jz = (rng() * 2 - 1) * JITTER * cell_d;
+
+                const px = cx0 + jx;
+                const py = cy0 + jy;
+                const pz = cz0 + jz;
+
+                if (point_is_inside(mesh, bvh, px, py, pz)) {
+                    out.push(px, py, pz);
+                }
+            }
+        }
+    }
+
+    return new Float32Array(out);
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_walk_boundary_loops.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enumerate the boundary edge cycles of a BinaryTopology mesh as ordered
+ * sequences of edge IDs. Each cycle traces a single hole in the surface, in
+ * the order the edges appear along the boundary.
+ *
+ * Throws if any boundary vertex has more than two boundary edges (figure-8 /
+ * bridged loops are not supported in this pass — repair the mesh first).
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number[][]} array of cycles; each cycle is an array of boundary edge IDs
+ */
+export function bt_mesh_walk_boundary_loops(mesh: BinaryTopology): number[][];
+//# sourceMappingURL=bt_mesh_walk_boundary_loops.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_walk_boundary_loops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_walk_boundary_loops.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_walk_boundary_loops.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;GAUG;AACH,mEAFa,MAAM,EAAE,EAAE,CA0CtB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_walk_boundary_loops.js

@@ -0,0 +1,108 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_query_edge_is_boundary } from "./bt_query_edge_is_boundary.js";
+
+/**
+ * Step one position around the disk cycle of `vertex`, starting from `edge`.
+ * @param {BinaryTopology} mesh
+ * @param {number} edge
+ * @param {number} vertex
+ * @returns {number} next edge in the disk cycle around `vertex`
+ */
+function disk_next(mesh, edge, vertex) {
+    if (mesh.edge_read_vertex1(edge) === vertex) {
+        return mesh.edge_read_v1_disk_next(edge);
+    }
+    return mesh.edge_read_v2_disk_next(edge);
+}
+
+/**
+ * Find the unique boundary edge incident to `vertex` other than `from_edge`.
+ * Throws if the vertex does not have exactly 2 boundary edges (a 2-manifold
+ * boundary vertex must have exactly 2; fewer or more means the boundary is
+ * not a simple cycle — e.g., a figure-8 / bridged pinch).
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} vertex
+ * @param {number} from_edge
+ * @returns {number}
+ */
+function next_boundary_edge_at_vertex(mesh, vertex, from_edge) {
+    const first_edge = mesh.vertex_read_edge(vertex);
+
+    let found = NULL_POINTER;
+    let extras = 0;
+
+    let edge = first_edge;
+    do {
+        if (edge !== from_edge && bt_query_edge_is_boundary(mesh, edge)) {
+            if (found === NULL_POINTER) {
+                found = edge;
+            } else {
+                extras++;
+            }
+        }
+        edge = disk_next(mesh, edge, vertex);
+    } while (edge !== first_edge);
+
+    if (found === NULL_POINTER) {
+        throw new Error(`boundary at vertex ${vertex} is malformed: only one boundary edge attached (dead-end)`);
+    }
+    if (extras > 0) {
+        throw new Error(`boundary at vertex ${vertex} is malformed: ${extras + 2} boundary edges attached (pinch / figure-8 loops are not supported)`);
+    }
+
+    return found;
+}
+
+/**
+ * Enumerate the boundary edge cycles of a BinaryTopology mesh as ordered
+ * sequences of edge IDs. Each cycle traces a single hole in the surface, in
+ * the order the edges appear along the boundary.
+ *
+ * Throws if any boundary vertex has more than two boundary edges (figure-8 /
+ * bridged loops are not supported in this pass — repair the mesh first).
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number[][]} array of cycles; each cycle is an array of boundary edge IDs
+ */
+export function bt_mesh_walk_boundary_loops(mesh) {
+    const cycles = [];
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+
+    const visited = new Uint8Array(edge_count);
+
+    for (let seed = 0; seed < edge_count; seed++) {
+        if (visited[seed]) {
+            continue;
+        }
+        if (!edges.is_allocated(seed)) {
+            continue;
+        }
+        if (!bt_query_edge_is_boundary(mesh, seed)) {
+            continue;
+        }
+
+        const cycle = [];
+        let edge = seed;
+        let from_vertex = mesh.edge_read_vertex1(edge);
+
+        do {
+            visited[edge] = 1;
+            cycle.push(edge);
+
+            const v1 = mesh.edge_read_vertex1(edge);
+            const v2 = mesh.edge_read_vertex2(edge);
+            const next_vertex = (v1 === from_vertex) ? v2 : v1;
+
+            const next_edge = next_boundary_edge_at_vertex(mesh, next_vertex, edge);
+
+            edge = next_edge;
+            from_vertex = next_vertex;
+        } while (edge !== seed);
+
+        cycles.push(cycle);
+    }
+
+    return cycles;
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_query_edge_is_boundary.d.ts

@@ -0,0 +1,11 @@
+/**
+ * An edge is a boundary edge when exactly one face uses it — i.e., its radial
+ * cycle contains a single loop. Wire edges (no loops on the radial cycle) and
+ * manifold edges (two loops) return false.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @returns {boolean}
+ */
+export function bt_query_edge_is_boundary(mesh: BinaryTopology, edge_id: number): boolean;
+//# sourceMappingURL=bt_query_edge_is_boundary.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_query_edge_is_boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_query_edge_is_boundary.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_query_edge_is_boundary.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,OAAO,CAUnB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_query_edge_is_boundary.js

@@ -0,0 +1,20 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * An edge is a boundary edge when exactly one face uses it — i.e., its radial
+ * cycle contains a single loop. Wire edges (no loops on the radial cycle) and
+ * manifold edges (two loops) return false.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @returns {boolean}
+ */
+export function bt_query_edge_is_boundary(mesh, edge_id) {
+    const loop = mesh.edge_read_loop(edge_id);
+
+    if (loop === NULL_POINTER) {
+        return false;
+    }
+
+    return mesh.loop_read_radial_next(loop) === loop;
+}

package/src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compute the signed volume enclosed by a triangle surface mesh given as
+ * flat positions + indices, via the divergence theorem.
+ *
+ * For every triangle (a, b, c) this sums the signed volume of the
+ * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
+ * wound (CCW from outside → positive volume), the per-triangle contributions
+ * cancel everywhere except inside the surface, leaving the enclosed volume.
+ *
+ * Useful as a ground truth for validating volumetric mesh generation: the
+ * tetrahedralized version of the same closed surface should have a total tet
+ * volume close to this value (small discretization gap aside).
+ *
+ * @param {ArrayLike<number>} positions flat (x,y,z,…) array
+ * @param {ArrayLike<number>} indices   3 entries per triangle
+ * @returns {number} signed volume — positive for CCW-from-outside winding,
+ *                   negative if flipped, zero for an open or self-cancelling mesh
+ */
+export function triangle_mesh_compute_signed_volume(positions: ArrayLike<number>, indices: ArrayLike<number>): number;
+//# sourceMappingURL=triangle_mesh_compute_signed_volume.d.ts.map

package/src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangle_mesh_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,+DALW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,MAAM,CAoBlB"}

package/src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.js

@@ -0,0 +1,38 @@
+import { triangle_compute_signed_volume } from "./triangle_compute_signed_volume.js";
+
+/**
+ * Compute the signed volume enclosed by a triangle surface mesh given as
+ * flat positions + indices, via the divergence theorem.
+ *
+ * For every triangle (a, b, c) this sums the signed volume of the
+ * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
+ * wound (CCW from outside → positive volume), the per-triangle contributions
+ * cancel everywhere except inside the surface, leaving the enclosed volume.
+ *
+ * Useful as a ground truth for validating volumetric mesh generation: the
+ * tetrahedralized version of the same closed surface should have a total tet
+ * volume close to this value (small discretization gap aside).
+ *
+ * @param {ArrayLike<number>} positions flat (x,y,z,…) array
+ * @param {ArrayLike<number>} indices   3 entries per triangle
+ * @returns {number} signed volume — positive for CCW-from-outside winding,
+ *                   negative if flipped, zero for an open or self-cancelling mesh
+ */
+export function triangle_mesh_compute_signed_volume(positions, indices) {
+    let total = 0;
+
+    const n = indices.length;
+    for (let i = 0; i < n; i += 3) {
+        const a3 = indices[i] * 3;
+        const b3 = indices[i + 1] * 3;
+        const c3 = indices[i + 2] * 3;
+
+        total += triangle_compute_signed_volume(
+            positions[a3],     positions[a3 + 1], positions[a3 + 2],
+            positions[b3],     positions[b3 + 1], positions[b3 + 2],
+            positions[c3],     positions[c3 + 1], positions[c3 + 2],
+        );
+    }
+
+    return total;
+}

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

@@ -0,0 +1,168 @@
+/**
+ * Compressed Sparse Row representation of a weighted graph.
+ *
+ * The four parallel typed arrays — `edge_addresses`, `adjacency`,
+ * `edge_weights`, `vertex_weights` — share a single `ArrayBuffer` so that
+ * they are co-located in memory. This gives the allocator one allocation
+ * 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
+ *
+ * Conventions match `mesh_to_metis_graph`:
+ *   - `edge_addresses[v]`     = start of vertex v's adjacency in `adjacency`
+ *   - `edge_addresses[v + 1]` = end (exclusive)
+ *   - `adjacency[k]`          = neighbour vertex id
+ *   - `edge_weights[k]`       = weight of that edge
+ *   - `vertex_weights[v]`     = vertex weight (default 1)
+ *
+ * The class deliberately exposes the raw typed arrays as fields rather than
+ * via accessor methods. Hot loops in graph algorithms want
+ * `for (let k = xadj[v]; k < xadj[v+1]; k++) { ... adj[k] ... }` patterns; a
+ * callback-based iterator API would force a closure allocation per outer
+ * iteration and defeat V8's inlining.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class CSRGraph {
+    /**
+     * Construct a CSRGraph from existing arrays by COPYING into a new
+     * shared-buffer instance. The input arrays are not retained.
+     *
+     * `vertex_weights` is optional — if not provided, the new graph keeps the
+     * default all-1s vertex weights and `total_vertex_weight = vertex_count`.
+     *
+     * @param {number} vertex_count
+     * @param {ArrayLike<number>} edge_addresses length vertex_count + 1
+     * @param {ArrayLike<number>} adjacency length edge_addresses[vertex_count]
+     * @param {ArrayLike<number>} edge_weights parallel to adjacency
+     * @param {ArrayLike<number>} [vertex_weights] optional; length vertex_count
+     * @returns {CSRGraph}
+     */
+    static fromArrays(vertex_count: number, edge_addresses: ArrayLike<number>, adjacency: ArrayLike<number>, edge_weights: ArrayLike<number>, vertex_weights?: ArrayLike<number>): CSRGraph;
+    /**
+     * @param {number} vertex_count
+     * @param {number} adjacency_length total length of the adjacency list
+     *   (each undirected edge appears twice for symmetric graphs)
+     */
+    constructor(vertex_count: number, adjacency_length: number);
+    /** @type {number} */
+    vertex_count: number;
+    /** @type {number} */
+    adjacency_length: number;
+    /**
+     * Single backing buffer for all four arrays.
+     * @type {ArrayBuffer}
+     * @private
+     */
+    private __data_buffer;
+    /**
+     * CSR row pointers. Length = vertex_count + 1; the final entry equals
+     * adjacency_length.
+     * @type {Uint32Array}
+     */
+    edge_addresses: Uint32Array;
+    /**
+     * CSR column indices — neighbour vertex ids.
+     * @type {Uint32Array}
+     */
+    adjacency: Uint32Array;
+    /**
+     * Edge weights parallel to `adjacency`.
+     * @type {Uint32Array}
+     */
+    edge_weights: Uint32Array;
+    /**
+     * Per-vertex weight. Initialised to all-1s; overwrite via direct
+     * indexing or `vertex_weights.set(...)` if your domain needs non-uniform
+     * weights. Remember to call `refresh_total_vertex_weight()` after.
+     * @type {Uint32Array}
+     */
+    vertex_weights: Uint32Array;
+    /**
+     * Cached `Σ vertex_weights[v]`. Kept in sync via `refresh_total_vertex_weight()`.
+     * @type {number}
+     */
+    total_vertex_weight: number;
+    /**
+     * The underlying shared buffer. Useful for fast bulk operations and for
+     * passing the graph between Web Workers via transfer.
+     * @returns {ArrayBuffer}
+     */
+    get arrayBuffer(): ArrayBuffer;
+    /**
+     * Degree of vertex `vertex` (number of outgoing edges in the CSR).
+     * @param {number} vertex
+     * @returns {number}
+     */
+    degree_of(vertex: number): number;
+    /**
+     * Sum of all entries in `edge_weights[0..adjacency_length)`.
+     * Each undirected edge contributes twice for a symmetric graph.
+     * @returns {number}
+     */
+    sum_of_edge_weights(): number;
+    /**
+     * Recompute and store `total_vertex_weight` from the current `vertex_weights`.
+     */
+    refresh_total_vertex_weight(): void;
+    /**
+     * Shrink `adjacency` and `edge_weights` in place to `new_adjacency_length`.
+     *
+     * Use after a worst-case allocation has been partially filled (e.g. during
+     * coarse-graph contraction where the exact edge count is only known after
+     * the merge pass). Reallocates the shared buffer at the smaller size and
+     * recreates all four typed-array views; existing references to
+     * `this.adjacency` etc. are invalidated.
+     *
+     * Vertex-side data (`edge_addresses`, `vertex_weights`) and
+     * `total_vertex_weight` are preserved.
+     *
+     * No-op if `new_adjacency_length === adjacency_length`.
+     *
+     * @param {number} new_adjacency_length must be <= current `adjacency_length`
+     */
+    truncate_adjacency(new_adjacency_length: number): void;
+    /**
+     * Copy the contents of `other` into `this`. Other must have matching
+     * `vertex_count` and `adjacency_length` (so the layouts align).
+     *
+     * Performed as a single bulk Uint32Array `.set()` thanks to the shared
+     * buffer layout — significantly faster than copying the four arrays
+     * individually.
+     *
+     * @param {CSRGraph} other
+     */
+    copy(other: CSRGraph): void;
+    /**
+     * Deep copy. Returns a new `CSRGraph` with independent buffers.
+     * @returns {CSRGraph}
+     */
+    clone(): CSRGraph;
+    /**
+     * Structural equality — same shape and same buffer contents.
+     * @param {CSRGraph} other
+     * @returns {boolean}
+     */
+    equals(other: CSRGraph): boolean;
+    /**
+     * 32-bit hash mixing the metadata fields and the entire buffer contents.
+     * Uses meep's standard `(h*31 + element)` convention via `uint32_array_hash`.
+     *
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * Type-check marker — avoids `instanceof` across module realms while still
+     * letting us assert "is a CSRGraph" cheaply.
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isCSRGraph: boolean;
+}
+//# sourceMappingURL=CSRGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CSRGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/CSRGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAsPI;;;;;;;;;;;;;OAaG;IACH,gCAPW,MAAM,kBACN,UAAU,MAAM,CAAC,aACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,mBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAgBpB;IAjRD;;;;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,CAsBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAUlB;IAiCL;;;;;OAKG;IACH,qBAFU,OAAO,CAEY;CAR5B"}