@woosh/meep-engine 2.138.20 → 2.139.0

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

@@ -51,6 +51,20 @@ export class BinaryTopology {
      *      l: uint32 // The list of loops around the edge points at a Loop
      *      v1_disk_link: uint32[2] // Disk Cycle Pointers edge around vertex v1 and d2 does the same for v2.
      *      v2_disk_link: uint32[2] // see above
+     *
+     * Disk cycle convention:
+     *   For every vertex v with at least one incident edge, the edges incident
+     *   to v form a doubly-linked cycle threaded through their disk_link slots.
+     *   Each non-self-loop edge e uses exactly ONE slot in v's cycle: the v1
+     *   slot if `vertex1(e) === v`, otherwise the v2 slot. Callers select the
+     *   side with `is_v1 = edge_read_vertex1(e) === v`.
+     *
+     *   Self-loops (vertex1(e) === vertex2(e) === v) are represented with ONE
+     *   slot too, by convention the v1 slot. The v2_disk_link of a self-loop is
+     *   UNSPECIFIED -- readers must not follow it, writers must not assume any
+     *   prior value. Insertion/removal helpers must be called exactly once per
+     *   self-loop (not once per "endpoint"), otherwise the v1 slot is scribbled
+     *   on a second time and the cycle is corrupted.
      * @type {BinaryElementPool}
      * @private
      */
@@ -80,17 +94,52 @@ export class BinaryTopology {
      */
     __face_pool = new BinaryElementPool(UINT_32_SIZE + FLOAT_32_SIZE * 3);
 
+    /**
+     * Optional opaque per-vertex data pool. Item IDs map 1:1 with vertex IDs.
+     * Null until {@link create_vertex_data} is called.
+     * @type {BinaryElementPool|null}
+     * @private
+     */
+    __vertex_data_pool = null;
+
+    /**
+     * Optional opaque per-edge data pool. Item IDs map 1:1 with edge IDs.
+     * @type {BinaryElementPool|null}
+     * @private
+     */
+    __edge_data_pool = null;
+
+    /**
+     * Optional opaque per-loop data pool. Item IDs map 1:1 with loop IDs.
+     * @type {BinaryElementPool|null}
+     * @private
+     */
+    __loop_data_pool = null;
+
+    /**
+     * Optional opaque per-face data pool. Item IDs map 1:1 with face IDs.
+     * @type {BinaryElementPool|null}
+     * @private
+     */
+    __face_data_pool = null;
+
 
     /**
      * Total (approximate) size of this structure in memory, in bytes
      * @return {number}
      */
     get byteSize() {
-        return this.__loop_pool.byteSize
+        let total = this.__loop_pool.byteSize
             + this.__vertex_pool.byteSize
             + this.__edge_pool.byteSize
-            + this.__face_pool.byteSize
-            ;
+            + this.__face_pool.byteSize;
+
+        if (this.__vertex_data_pool !== null) total += this.__vertex_data_pool.byteSize;
+        if (this.__edge_data_pool !== null) total += this.__edge_data_pool.byteSize;
+        if (this.__loop_data_pool !== null) total += this.__loop_data_pool.byteSize;
+        if (this.__face_data_pool !== null) total += this.__face_data_pool.byteSize;
+
+        return total;
     }
 
     /**
@@ -102,6 +151,11 @@ export class BinaryTopology {
         this.__vertex_pool.trim();
         this.__edge_pool.trim();
         this.__face_pool.trim();
+
+        if (this.__vertex_data_pool !== null) this.__vertex_data_pool.trim();
+        if (this.__edge_data_pool !== null) this.__edge_data_pool.trim();
+        if (this.__loop_data_pool !== null) this.__loop_data_pool.trim();
+        if (this.__face_data_pool !== null) this.__face_data_pool.trim();
     }
 
     /**
@@ -136,6 +190,147 @@ export class BinaryTopology {
         return this.__face_pool;
     }
 
+    /**
+     * Opaque per-vertex data. The user is responsible for encoding/decoding the bytes,
+     * and for keeping the pool's allocation in sync with {@link vertices} — typically
+     * by calling `vertex_data.allocate()` whenever a vertex is allocated.
+     * Slot at vertex ID X holds that vertex's data.
+     * @returns {BinaryElementPool|null} null when no data pool has been created
+     */
+    get vertex_data() {
+        return this.__vertex_data_pool;
+    }
+
+    /**
+     * Opaque per-edge data. See {@link vertex_data}.
+     * @returns {BinaryElementPool|null} null when no data pool has been created
+     */
+    get edge_data() {
+        return this.__edge_data_pool;
+    }
+
+    /**
+     * Opaque per-loop data. See {@link vertex_data}.
+     * @returns {BinaryElementPool|null} null when no data pool has been created
+     */
+    get loop_data() {
+        return this.__loop_data_pool;
+    }
+
+    /**
+     * Opaque per-face data. See {@link vertex_data}.
+     * @returns {BinaryElementPool|null} null when no data pool has been created
+     */
+    get face_data() {
+        return this.__face_data_pool;
+    }
+
+    /**
+     * Create an opaque per-vertex data pool. If vertices already exist, the pool is
+     * sized to match (bytes zero-initialized).
+     *
+     * After this returns, it is the caller's responsibility to keep the data pool's
+     * allocation in sync with {@link vertices} (call `vertex_data.allocate()` /
+     * `vertex_data.allocate_continuous(n)` / `vertex_data.release(id)` /
+     * `vertex_data.clear()` alongside the matching base pool calls).
+     *
+     * @param {number} item_size_bytes
+     */
+    create_vertex_data(item_size_bytes) {
+        assert.isNull(this.__vertex_data_pool, '__vertex_data_pool');
+        this.__vertex_data_pool = this.__create_data_pool(this.__vertex_pool, item_size_bytes);
+    }
+
+    /**
+     * Create an opaque per-edge data pool. See {@link create_vertex_data}.
+     * @param {number} item_size_bytes
+     */
+    create_edge_data(item_size_bytes) {
+        assert.isNull(this.__edge_data_pool, '__edge_data_pool');
+        this.__edge_data_pool = this.__create_data_pool(this.__edge_pool, item_size_bytes);
+    }
+
+    /**
+     * Create an opaque per-loop data pool. See {@link create_vertex_data}.
+     * @param {number} item_size_bytes
+     */
+    create_loop_data(item_size_bytes) {
+        assert.isNull(this.__loop_data_pool, '__loop_data_pool');
+        this.__loop_data_pool = this.__create_data_pool(this.__loop_pool, item_size_bytes);
+    }
+
+    /**
+     * Create an opaque per-face data pool. See {@link create_vertex_data}.
+     * @param {number} item_size_bytes
+     */
+    create_face_data(item_size_bytes) {
+        assert.isNull(this.__face_data_pool, '__face_data_pool');
+        this.__face_data_pool = this.__create_data_pool(this.__face_pool, item_size_bytes);
+    }
+
+    /**
+     * @returns {boolean} true if a data pool was removed, false if there was none
+     */
+    delete_vertex_data() {
+        if (this.__vertex_data_pool === null) {
+            return false;
+        }
+        this.__vertex_data_pool = null;
+        return true;
+    }
+
+    /**
+     * @returns {boolean} true if a data pool was removed, false if there was none
+     */
+    delete_edge_data() {
+        if (this.__edge_data_pool === null) {
+            return false;
+        }
+        this.__edge_data_pool = null;
+        return true;
+    }
+
+    /**
+     * @returns {boolean} true if a data pool was removed, false if there was none
+     */
+    delete_loop_data() {
+        if (this.__loop_data_pool === null) {
+            return false;
+        }
+        this.__loop_data_pool = null;
+        return true;
+    }
+
+    /**
+     * @returns {boolean} true if a data pool was removed, false if there was none
+     */
+    delete_face_data() {
+        if (this.__face_data_pool === null) {
+            return false;
+        }
+        this.__face_data_pool = null;
+        return true;
+    }
+
+    /**
+     * @param {BinaryElementPool} base
+     * @param {number} item_size_bytes
+     * @returns {BinaryElementPool}
+     * @private
+     */
+    __create_data_pool(base, item_size_bytes) {
+        const data = new BinaryElementPool(item_size_bytes);
+
+        // Size the new pool to match the related pool's current allocation.
+        // Bytes are zero by ArrayBuffer initialization.
+        const current_size = base.size;
+        if (current_size > 0) {
+            data.allocate_continuous(current_size);
+        }
+
+        return data;
+    }
+
 
     /**
      * Clear the topology, removed all data
@@ -145,6 +340,11 @@ export class BinaryTopology {
         this.__edge_pool.clear();
         this.__loop_pool.clear();
         this.__face_pool.clear();
+
+        this.__vertex_data_pool?.clear();
+        this.__edge_data_pool?.clear();
+        this.__loop_data_pool?.clear();
+        this.__face_data_pool?.clear();
     }
 
     /**
@@ -419,9 +619,54 @@ export class BinaryTopology {
         pool.data_view.setUint32(address + 6 * UINT_32_SIZE, value);
     }
 
+    /**
+     * Allocate a new vertex and, if the vertex data pool exists, ensure its
+     * underlying buffer has capacity for the new ID. Tracking the data pool's
+     * __size remains the caller's responsibility.
+     * @returns {number} vertex ID
+     */
+    vertex_create() {
+        const id = this.__vertex_pool.allocate();
+
+        this.__vertex_data_pool?.ensure_capacity(id + 1);
+
+        return id;
+    }
+
+    /**
+     * Allocate a new edge. See {@link vertex_create}.
+     * @returns {number} edge ID
+     */
+    edge_create() {
+        const id = this.__edge_pool.allocate();
+
+        this.__edge_data_pool?.ensure_capacity(id + 1);
+
+        return id;
+    }
+
+    /**
+     * Allocate a new face. See {@link vertex_create}.
+     * @returns {number} face ID
+     */
+    face_create() {
+        const id = this.__face_pool.allocate();
+
+        this.__face_data_pool?.ensure_capacity(id + 1);
+
+        return id;
+    }
+
+    /**
+     * Allocate a new loop and put it into a valid initial state.
+     * See {@link vertex_create} for the data pool sync semantics.
+     * @returns {number} loop ID
+     */
     loop_create() {
         const id = this.__loop_pool.allocate();
 
+        this.__loop_data_pool?.ensure_capacity(id + 1);
+
         this.loop_initialize(id);
 
         return id;
@@ -679,6 +924,34 @@ export class BinaryTopology {
         this.__edge_pool.copy(other.edges);
         this.__loop_pool.copy(other.loops);
         this.__face_pool.copy(other.faces);
+
+        if (other.vertex_data === null) {
+            if (this.__vertex_data_pool !== null) this.delete_vertex_data();
+        } else {
+            if (this.__vertex_data_pool === null) this.create_vertex_data(other.vertex_data.item_size);
+            this.__vertex_data_pool.copy(other.vertex_data);
+        }
+
+        if (other.edge_data === null) {
+            if (this.__edge_data_pool !== null) this.delete_edge_data();
+        } else {
+            if (this.__edge_data_pool === null) this.create_edge_data(other.edge_data.item_size);
+            this.__edge_data_pool.copy(other.edge_data);
+        }
+
+        if (other.loop_data === null) {
+            if (this.__loop_data_pool !== null) this.delete_loop_data();
+        } else {
+            if (this.__loop_data_pool === null) this.create_loop_data(other.loop_data.item_size);
+            this.__loop_data_pool.copy(other.loop_data);
+        }
+
+        if (other.face_data === null) {
+            if (this.__face_data_pool !== null) this.delete_face_data();
+        } else {
+            if (this.__face_data_pool === null) this.create_face_data(other.face_data.item_size);
+            this.__face_data_pool.copy(other.face_data);
+        }
     }
 
     /**

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Close every boundary hole in `mesh` by fan-tessellating each boundary loop
+ * around its centroid. A new Steiner vertex is added at the centroid of each
+ * hole; one triangle is emitted per boundary edge, connecting the edge's two
+ * vertices to the centroid.
+ *
+ * After this returns, no edge in the mesh is a boundary edge (every edge has
+ * exactly two faces on its radial cycle).
+ *
+ * Throws if any boundary vertex has more than two boundary edges (figure-8 /
+ * pinched boundaries). Mutates the mesh in place.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number} number of boundary holes that were closed
+ */
+export function bt_mesh_close_boundary_holes(mesh: BinaryTopology): number;
+//# sourceMappingURL=bt_mesh_close_boundary_holes.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_close_boundary_holes.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;GAcG;AACH,oEAFa,MAAM,CA8DlB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_close_boundary_holes.js

@@ -0,0 +1,135 @@
+import { bt_mesh_walk_boundary_loops } from "../query/bt_mesh_walk_boundary_loops.js";
+import { bt_mesh_face_poke } from "./face/bt_face_poke.js";
+import { bt_radial_loop_add } from "./bt_radial_loop_add.js";
+
+const scratch_coord = [0, 0, 0];
+
+/**
+ * Walk a boundary cycle (returned by {@link bt_mesh_walk_boundary_loops}) and
+ * produce a vertex/edge sequence starting at `start_vertex` and going around
+ * the cycle in the direction `start_vertex` dictates.
+ *
+ * Output arrays are filled in place; both have length equal to `cycle.length`.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[]} cycle
+ * @param {number} start_vertex must be an endpoint of one of the cycle's edges
+ * @param {number[]} out_vertices
+ * @param {number[]} out_edges
+ */
+function order_cycle_from(mesh, cycle, start_vertex, out_vertices, out_edges) {
+    const n = cycle.length;
+
+    const v_to_edges = new Map();
+    for (let i = 0; i < n; i++) {
+        const e = cycle[i];
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+        let bucket = v_to_edges.get(v1);
+        if (bucket === undefined) {
+            bucket = [];
+            v_to_edges.set(v1, bucket);
+        }
+        bucket.push(e);
+        bucket = v_to_edges.get(v2);
+        if (bucket === undefined) {
+            bucket = [];
+            v_to_edges.set(v2, bucket);
+        }
+        bucket.push(e);
+    }
+
+    let v_curr = start_vertex;
+    let e_prev = -1;
+
+    for (let i = 0; i < n; i++) {
+        out_vertices[i] = v_curr;
+
+        const edges_at_v = v_to_edges.get(v_curr);
+        const e_next = (edges_at_v[0] === e_prev) ? edges_at_v[1] : edges_at_v[0];
+
+        out_edges[i] = e_next;
+
+        const e_v1 = mesh.edge_read_vertex1(e_next);
+        const e_v2 = mesh.edge_read_vertex2(e_next);
+        v_curr = (e_v1 === v_curr) ? e_v2 : e_v1;
+        e_prev = e_next;
+    }
+}
+
+/**
+ * Close every boundary hole in `mesh` by fan-tessellating each boundary loop
+ * around its centroid. A new Steiner vertex is added at the centroid of each
+ * hole; one triangle is emitted per boundary edge, connecting the edge's two
+ * vertices to the centroid.
+ *
+ * After this returns, no edge in the mesh is a boundary edge (every edge has
+ * exactly two faces on its radial cycle).
+ *
+ * Throws if any boundary vertex has more than two boundary edges (figure-8 /
+ * pinched boundaries). Mutates the mesh in place.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number} number of boundary holes that were closed
+ */
+export function bt_mesh_close_boundary_holes(mesh) {
+    const cycles = bt_mesh_walk_boundary_loops(mesh);
+
+    const ordered_vertices = [];
+    const ordered_edges = [];
+
+    for (const cycle of cycles) {
+        const n = cycle.length;
+
+        // Each new loop on a boundary edge must wind opposite the existing
+        // loop, so the shared edge ends up with consistent radial orientation.
+        const seed_edge = cycle[0];
+        const seed_loop = mesh.edge_read_loop(seed_edge);
+        const existing_loop_vertex = mesh.loop_read_vertex(seed_loop);
+        const seed_v1 = mesh.edge_read_vertex1(seed_edge);
+        const seed_v2 = mesh.edge_read_vertex2(seed_edge);
+        const start_vertex = (existing_loop_vertex === seed_v1) ? seed_v2 : seed_v1;
+
+        ordered_vertices.length = n;
+        ordered_edges.length = n;
+        order_cycle_from(mesh, cycle, start_vertex, ordered_vertices, ordered_edges);
+
+        // Compute centroid of the hole's vertices.
+        let cx = 0, cy = 0, cz = 0;
+        for (let i = 0; i < n; i++) {
+            mesh.vertex_read_coordinate(scratch_coord, 0, ordered_vertices[i]);
+            cx += scratch_coord[0];
+            cy += scratch_coord[1];
+            cz += scratch_coord[2];
+        }
+        cx /= n;
+        cy /= n;
+        cz /= n;
+
+        // Allocate a new face plus n loops, wire them into the face cycle and
+        // each boundary edge's radial cycle. Face normal stays zero; downstream
+        // tetrahedralization is position-only.
+        const new_face = mesh.faces.allocate();
+
+        const loops = new Array(n);
+        for (let i = 0; i < n; i++) {
+            loops[i] = mesh.loop_create();
+            mesh.loop_write_vertex(loops[i], ordered_vertices[i]);
+            mesh.loop_write_face(loops[i], new_face);
+            bt_radial_loop_add(mesh, loops[i], ordered_edges[i]);
+        }
+
+        for (let i = 0; i < n; i++) {
+            mesh.loop_write_next(loops[i], loops[(i + 1) % n]);
+            mesh.loop_write_prev(loops[i], loops[(i - 1 + n) % n]);
+        }
+
+        mesh.face_write_loop(new_face, loops[0]);
+
+        // Fan from centroid — adds the Steiner vertex and replaces the n-gon
+        // face with n triangles.
+        bt_mesh_face_poke(mesh, new_face, cx, cy, cz);
+    }
+
+    return cycles.length;
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compact.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Remove allocation holes from a mesh's pools.
+ * After compaction, every base pool's live elements occupy a contiguous
+ * range [0, N) and the free set is empty. All cross-references between
+ * pools are patched to the new IDs. Optional per-element data pools
+ * (vertex_data, edge_data, loop_data, face_data) are compacted in
+ * lockstep with their base pools.
+ *
+ * The mesh's topological meaning is preserved; only IDs may change.
+ *
+ * @param {BinaryTopology} mesh
+ */
+export function bt_mesh_compact(mesh: BinaryTopology): void;
+//# sourceMappingURL=bt_mesh_compact.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_compact.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compact.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;GAWG;AACH,4DAwFC"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_compact.js

@@ -0,0 +1,177 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Walk a pool and assign a new sequential ID to each live element.
+ * Free slots map to NULL_POINTER.
+ * @param {BinaryElementPool} pool
+ * @returns {Uint32Array} remap[old_id] -> new_id (or NULL_POINTER if old_id was free)
+ */
+function build_remap(pool) {
+    const size = pool.size;
+    const remap = new Uint32Array(size);
+
+    let next_id = 0;
+    for (let old_id = 0; old_id < size; old_id++) {
+        if (pool.is_allocated(old_id)) {
+            remap[old_id] = next_id;
+            next_id++;
+        } else {
+            remap[old_id] = NULL_POINTER;
+        }
+    }
+
+    return remap;
+}
+
+/**
+ * Returns NULL_POINTER unchanged, otherwise looks up the remap.
+ * @param {Uint32Array} remap
+ * @param {number} ptr
+ * @returns {number}
+ */
+function patch(remap, ptr) {
+    if (ptr === NULL_POINTER) {
+        return NULL_POINTER;
+    }
+    return remap[ptr];
+}
+
+/**
+ * Physically move live elements down so they occupy [0, live_count) contiguously.
+ * Uses the remap only to identify free slots (where remap[i] === NULL_POINTER).
+ * @param {BinaryElementPool} pool
+ * @param {Uint32Array} remap remap built from this pool's pre-compaction state
+ */
+function compact_bytes(pool, remap) {
+    const size = remap.length;
+
+    let write = 0;
+    for (let read = 0; read < size; read++) {
+        if (remap[read] === NULL_POINTER) {
+            continue;
+        }
+
+        if (read !== write) {
+            pool.swap(read, write);
+        }
+
+        write++;
+    }
+}
+
+/**
+ * Count live slots from a remap built by {@link build_remap}.
+ * @param {Uint32Array} remap
+ * @returns {number}
+ */
+function live_count_from_remap(remap) {
+    let count = 0;
+    for (let i = 0; i < remap.length; i++) {
+        if (remap[i] !== NULL_POINTER) {
+            count++;
+        }
+    }
+    return count;
+}
+
+/**
+ * Remove allocation holes from a mesh's pools.
+ * After compaction, every base pool's live elements occupy a contiguous
+ * range [0, N) and the free set is empty. All cross-references between
+ * pools are patched to the new IDs. Optional per-element data pools
+ * (vertex_data, edge_data, loop_data, face_data) are compacted in
+ * lockstep with their base pools.
+ *
+ * The mesh's topological meaning is preserved; only IDs may change.
+ *
+ * @param {BinaryTopology} mesh
+ */
+export function bt_mesh_compact(mesh) {
+    const vertex_pool = mesh.vertices;
+    const edge_pool = mesh.edges;
+    const loop_pool = mesh.loops;
+    const face_pool = mesh.faces;
+
+    // 1. Build remap tables for all four base pools
+    const vertex_remap = build_remap(vertex_pool);
+    const edge_remap = build_remap(edge_pool);
+    const loop_remap = build_remap(loop_pool);
+    const face_remap = build_remap(face_pool);
+
+    // 2. Patch pointer fields in-place at OLD positions, live elements only.
+    //    NULL_POINTER passes through unchanged.
+
+    // Vertices: edge_pointer -> edge
+    const vertex_size = vertex_remap.length;
+    for (let v = 0; v < vertex_size; v++) {
+        if (vertex_remap[v] === NULL_POINTER) continue;
+
+        mesh.vertex_write_edge(v, patch(edge_remap, mesh.vertex_read_edge(v)));
+    }
+
+    // Edges: v1, v2 -> vertex; l -> loop; disk pointers -> edge
+    const edge_size = edge_remap.length;
+    for (let e = 0; e < edge_size; e++) {
+        if (edge_remap[e] === NULL_POINTER) continue;
+
+        mesh.edge_write_vertex1(e, patch(vertex_remap, mesh.edge_read_vertex1(e)));
+        mesh.edge_write_vertex2(e, patch(vertex_remap, mesh.edge_read_vertex2(e)));
+        mesh.edge_write_loop(e, patch(loop_remap, mesh.edge_read_loop(e)));
+
+        mesh.edge_write_v1_disk_next(e, patch(edge_remap, mesh.edge_read_v1_disk_next(e)));
+        mesh.edge_write_v1_disk_prev(e, patch(edge_remap, mesh.edge_read_v1_disk_prev(e)));
+        mesh.edge_write_v2_disk_next(e, patch(edge_remap, mesh.edge_read_v2_disk_next(e)));
+        mesh.edge_write_v2_disk_prev(e, patch(edge_remap, mesh.edge_read_v2_disk_prev(e)));
+    }
+
+    // Loops: v -> vertex; e -> edge; f -> face; radial/face cycle -> loop
+    const loop_size = loop_remap.length;
+    for (let l = 0; l < loop_size; l++) {
+        if (loop_remap[l] === NULL_POINTER) continue;
+
+        mesh.loop_write_vertex(l, patch(vertex_remap, mesh.loop_read_vertex(l)));
+        mesh.loop_write_edge(l, patch(edge_remap, mesh.loop_read_edge(l)));
+        mesh.loop_write_face(l, patch(face_remap, mesh.loop_read_face(l)));
+
+        mesh.loop_write_radial_next(l, patch(loop_remap, mesh.loop_read_radial_next(l)));
+        mesh.loop_write_radial_prev(l, patch(loop_remap, mesh.loop_read_radial_prev(l)));
+        mesh.loop_write_next(l, patch(loop_remap, mesh.loop_read_next(l)));
+        mesh.loop_write_prev(l, patch(loop_remap, mesh.loop_read_prev(l)));
+    }
+
+    // Faces: l_first -> loop
+    const face_size = face_remap.length;
+    for (let f = 0; f < face_size; f++) {
+        if (face_remap[f] === NULL_POINTER) continue;
+
+        mesh.face_write_loop(f, patch(loop_remap, mesh.face_read_loop(f)));
+    }
+
+    // 3. Physically compact bytes. Base pools first, then any optional data
+    //    pools using the same remaps.
+    compact_bytes(vertex_pool, vertex_remap);
+    compact_bytes(edge_pool, edge_remap);
+    compact_bytes(loop_pool, loop_remap);
+    compact_bytes(face_pool, face_remap);
+
+    if (mesh.vertex_data !== null) compact_bytes(mesh.vertex_data, vertex_remap);
+    if (mesh.edge_data !== null) compact_bytes(mesh.edge_data, edge_remap);
+    if (mesh.loop_data !== null) compact_bytes(mesh.loop_data, loop_remap);
+    if (mesh.face_data !== null) compact_bytes(mesh.face_data, face_remap);
+
+    // 4. Truncate sizes on every pool (base + data).
+    const vertex_live = live_count_from_remap(vertex_remap);
+    const edge_live = live_count_from_remap(edge_remap);
+    const loop_live = live_count_from_remap(loop_remap);
+    const face_live = live_count_from_remap(face_remap);
+
+    vertex_pool.truncate(vertex_live);
+    edge_pool.truncate(edge_live);
+    loop_pool.truncate(loop_live);
+    face_pool.truncate(face_live);
+
+    if (mesh.vertex_data !== null) mesh.vertex_data.truncate(vertex_live);
+    if (mesh.edge_data !== null) mesh.edge_data.truncate(edge_live);
+    if (mesh.loop_data !== null) mesh.loop_data.truncate(loop_live);
+    if (mesh.face_data !== null) mesh.face_data.truncate(face_live);
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_face_decouple.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,sEAJW,MAAM,YACN,MAAM,QAgIhB"}
+{"version":3,"file":"bt_mesh_face_decouple.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,sEAJW,MAAM,YACN,MAAM,QAgJhB"}