@woosh/meep-engine 2.163.9 → 2.163.11

package/src/core/geom/3d/line/line3_compute_segment_nearest_point_to_aabb3_t.js

@@ -0,0 +1,153 @@
+import { clamp } from "../../../math/clamp.js";
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ * The argmin of `g(t)=distanceSqr(P(t),box)` is an INTERVAL when the minimum is
+ * non-unique (segment parallel to a face, or lying inside the box — the closest
+ * distance is then constant along a sub-segment). We track that interval as the
+ * monotone sign-structure of `g'(t)` is scanned and return its MIDPOINT, so the
+ * reported closest point is the central one rather than an arbitrary endpoint.
+ * Module-level (single-threaded, non-reentrant — same convention as the
+ * narrowphase `g_ct_*` accumulators):
+ *   a = (max t, g) with g' ≤ 0,  b = (min t, g) with g' > 0   → t_hi (rightmost min)
+ *   c = (max t, g) with g' < 0,  d = (min t, g) with g' ≥ 0   → t_lo (leftmost min)
+ */
+let _a_t = -1, _a_g = 0;
+let _b_t = 2, _b_g = 0;
+let _c_t = -1, _c_g = 0;
+let _d_t = 2, _d_g = 0;
+
+/** Fold one candidate `(t, g'(t))` into the argmin-interval trackers. */
+function _consider(t, g) {
+    if (g <= 0 && t > _a_t) { _a_t = t; _a_g = g; }
+    if (g > 0 && t < _b_t) { _b_t = t; _b_g = g; }
+    if (g < 0 && t > _c_t) { _c_t = t; _c_g = g; }
+    if (g >= 0 && t < _d_t) { _d_t = t; _d_g = g; }
+}
+
+/**
+ * Parameter `t ∈ [0,1]` of the point on the segment `p0 → p1` nearest to an
+ * axis-aligned box. The closest segment point is `p0 + t·(p1 − p0)`; the closest
+ * box point is that point clamped per-axis into the box. Sibling of
+ * {@link line3_compute_segment_nearest_point_to_point_t} (segment-vs-point).
+ *
+ * Exact and O(1). `g(t) = distanceSqr(P(t), box)` is convex and — for an AABB —
+ * piecewise-quadratic, with pieces meeting only where `P(t)` crosses one of the
+ * six box face planes (≤6 crossings). `g'(t) ∝ (P(t) − clamp(P(t), box)) · d` is
+ * therefore piecewise-linear and monotonically non-decreasing, so the minimiser
+ * is found in closed form by evaluating `g'` at the ≤8 candidates
+ * `{0, 1, face-plane crossings}`: the minimum is achieved on the interval where
+ * `g' = 0` (a single point when strictly convex), and this returns that
+ * interval's midpoint. No iteration, no tolerance, no Cramer's-Rule solve.
+ *
+ * When the minimum is non-unique (segment parallel to / inside the box) the
+ * midpoint is the *central* closest point — what the narrowphase
+ * `capsule_box_contact` needs for a stable resting manifold; a degenerate
+ * (`p0 === p1`) segment returns `0` (its parameter is arbitrary).
+ *
+ * The AABB specialisation of the Eberly/Ericson closest-point-segment-vs-box
+ * reduction. Backs {@link capsule_intersects_aabb3_closed} and the narrowphase
+ * `capsule_box_contact`; it replaced a 2-iteration alternating projection that
+ * under-detected and mis-placed contacts for segments near-parallel to a box
+ * face/edge (see `core/geom/3d/gjk/GJK_REVIEW_NOTES.md`).
+ *
+ * Box bounds are assumed ordered per axis (`box_*0 ≤ box_*1`).
+ *
+ * @param {number} p0_x segment start x
+ * @param {number} p0_y
+ * @param {number} p0_z
+ * @param {number} p1_x segment end x
+ * @param {number} p1_y
+ * @param {number} p1_z
+ * @param {number} box_x0 box min x
+ * @param {number} box_y0
+ * @param {number} box_z0
+ * @param {number} box_x1 box max x
+ * @param {number} box_y1
+ * @param {number} box_z1
+ * @returns {number} t in [0, 1]
+ */
+export function line3_compute_segment_nearest_point_to_aabb3_t(
+    p0_x, p0_y, p0_z,
+    p1_x, p1_y, p1_z,
+    box_x0, box_y0, box_z0,
+    box_x1, box_y1, box_z1
+) {
+    const d_x = p1_x - p0_x;
+    const d_y = p1_y - p0_y;
+    const d_z = p1_z - p0_z;
+
+    if (d_x === 0 && d_y === 0 && d_z === 0) {
+        // Degenerate segment (a point) — its parameter is arbitrary.
+        return 0;
+    }
+
+    _a_t = -1; _a_g = 0;
+    _b_t = 2; _b_g = 0;
+    _c_t = -1; _c_g = 0;
+    _d_t = 2; _d_g = 0;
+
+    // Endpoint candidates.
+    _consider(0, v3_dot(
+        p0_x - clamp(p0_x, box_x0, box_x1),
+        p0_y - clamp(p0_y, box_y0, box_y1),
+        p0_z - clamp(p0_z, box_z0, box_z1),
+        d_x, d_y, d_z
+    ));
+    _consider(1, v3_dot(
+        p1_x - clamp(p1_x, box_x0, box_x1),
+        p1_y - clamp(p1_y, box_y0, box_y1),
+        p1_z - clamp(p1_z, box_z0, box_z1),
+        d_x, d_y, d_z
+    ));
+
+    // Face-plane crossing candidates (where an axis enters/leaves its slab).
+    for (let axis = 0; axis < 3; axis++) {
+        const d_a = axis === 0 ? d_x : (axis === 1 ? d_y : d_z);
+        if (d_a === 0) {
+            continue;
+        }
+        const p0_a = axis === 0 ? p0_x : (axis === 1 ? p0_y : p0_z);
+        const lo_a = axis === 0 ? box_x0 : (axis === 1 ? box_y0 : box_z0);
+        const hi_a = axis === 0 ? box_x1 : (axis === 1 ? box_y1 : box_z1);
+        const inv_d = 1 / d_a;
+
+        for (let side = 0; side < 2; side++) {
+            const tc = ((side === 0 ? lo_a : hi_a) - p0_a) * inv_d;
+            if (tc <= 0 || tc >= 1) {
+                continue;
+            }
+            const c_x = p0_x + d_x * tc;
+            const c_y = p0_y + d_y * tc;
+            const c_z = p0_z + d_z * tc;
+            _consider(tc, v3_dot(
+                c_x - clamp(c_x, box_x0, box_x1),
+                c_y - clamp(c_y, box_y0, box_y1),
+                c_z - clamp(c_z, box_z0, box_z1),
+                d_x, d_y, d_z
+            ));
+        }
+    }
+
+    // Rightmost minimiser: where g' last reaches 0 (g' linear between a and b).
+    let t_hi;
+    if (_a_t < 0) {
+        t_hi = 0;          // g' > 0 everywhere → minimum at the p0 end
+    } else if (_b_t > 1) {
+        t_hi = 1;          // g' ≤ 0 everywhere → minimum at the p1 end
+    } else {
+        t_hi = _a_t - _a_g * (_b_t - _a_t) / (_b_g - _a_g);
+    }
+
+    // Leftmost minimiser: where g' first reaches 0.
+    let t_lo;
+    if (_d_t > 1) {
+        t_lo = 1;          // g' < 0 everywhere → minimum at the p1 end
+    } else if (_c_t < 0) {
+        t_lo = 0;          // g' ≥ 0 everywhere → minimum at the p0 end
+    } else {
+        t_lo = _c_t - _c_g * (_d_t - _c_t) / (_d_g - _c_g);
+    }
+
+    return (t_lo + t_hi) * 0.5;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"BinaryTopology.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BinaryTopology.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"BinaryTopology.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BinaryTopology.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,2BAFU,MAAM,CAEuB;AAQvC;;;GAGG;AACH;IACI;;;;;;;;OAQG;IACH,sBAA4F;IAE5F;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,oBAAsD;IAEtD;;;;;;;;;;;;OAYG;IACH,oBAAsD;IAEtD;;;;;;OAMG;IACH,oBAAsE;IAEtE;;;;;OAKG;IACH,2BAA0B;IAE1B;;;;OAIG;IACH,yBAAwB;IAExB;;;;OAIG;IACH,yBAAwB;IAExB;;;;OAIG;IACH,yBAAwB;IAGxB;;;OAGG;IACH,uBAYC;IAED;;;OAGG;IACH,aAUC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;;;;OAMG;IACH,qCAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;;;;;;;;OAUG;IACH,oCAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,kCAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,kCAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,kCAFW,MAAM,QAKhB;IAED;;OAEG;IACH,sBAFa,OAAO,CAQnB;IAED;;OAEG;IACH,oBAFa,OAAO,CAQnB;IAED;;OAEG;IACH,oBAFa,OAAO,CAQnB;IAED;;OAEG;IACH,oBAFa,OAAO,CAQnB;IAED;;;;;OAKG;IACH,2BAWC;IAGD;;OAEG;IACH,cAUC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,MACN,MAAM,QAUhB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAUhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,MACN,MAAM,QAUhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAUhB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,sBAFW,MAAM,WADN,MAAM,QAQhB;IAED;;;OAGG;IACH,sBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,uBAFW,MAAM,SADN,MAAM,QAQhB;IAED;;;OAGG;IACH,sBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,uBAFW,MAAM,SADN,MAAM,QAQhB;IAGD;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,WADN,MAAM,QAQhB;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;OAIG;IACH,4BAFW,MAAM,SADN,MAAM,QAUhB;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;OAIG;IACH,4BAFW,MAAM,SADN,MAAM,QAUhB;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;OAIG;IACH,4BAFW,MAAM,SADN,MAAM,QAUhB;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;OAIG;IACH,4BAFW,MAAM,SADN,MAAM,QAUhB;IAED;;;;;OAKG;IACH,iBAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,eAFa,MAAM,CAUlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,sBAFW,MAAM,SADN,MAAM,QAQhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,SADN,MAAM,QAQhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,SADN,MAAM,QAUhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,2BAFW,MAAM,SADN,MAAM,QAShB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,2BAFW,MAAM,SADN,MAAM,QAShB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,SADN,MAAM,QAQhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,SADN,MAAM,QAQhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,SADN,MAAM,QAQhB;IAED;;;;OAIG;IACH,yBAJW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,MACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,sBAJW,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAShB;IAED;;;OAGG;IACH,YAFW,cAAc,QA4CxB;IAED;;;OAGG;IACH,SAFa,cAAc,CAM1B;IAIL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;CAPxC;kCAh9BiC,wBAAwB"}

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

@@ -1,5 +1,4 @@
 import { assert } from "../../../../../assert.js";
-import { array_copy } from "../../../../../collection/array/array_copy.js";
 import { BinaryElementPool } from "./BinaryElementPool.js";
 
 /**
@@ -358,7 +357,9 @@ export class BinaryTopology {
 
         const v_address = pool.element_address(id);
         const v_offset = v_address >> 2; // get 4-byte boundary
-        array_copy(pool.data_float32, v_offset, result, result_offset, 3);
+        result[result_offset] = pool.data_float32[v_offset];
+        result[result_offset + 1] = pool.data_float32[v_offset + 1];
+        result[result_offset + 2] = pool.data_float32[v_offset + 2];
     }
 
     /**
@@ -372,7 +373,9 @@ export class BinaryTopology {
 
         const v_address = pool.element_address(id);
         const v_offset = v_address >> 2; // get 4-byte boundary
-        array_copy(value, value_offset, pool.data_float32, v_offset, 3);
+        pool.data_float32[v_offset] = value[value_offset];
+        pool.data_float32[v_offset + 1] = value[value_offset + 1];
+        pool.data_float32[v_offset + 2] = value[value_offset + 2];
     }
 
     /**
@@ -386,7 +389,9 @@ export class BinaryTopology {
 
         const v_address = pool.element_address(id) + 3 * FLOAT_32_SIZE;
         const v_offset = v_address >> 2; // get 4-byte boundary
-        array_copy(pool.data_float32, v_offset, result, result_offset, 3);
+        result[result_offset] = pool.data_float32[v_offset];
+        result[result_offset + 1] = pool.data_float32[v_offset + 1];
+        result[result_offset + 2] = pool.data_float32[v_offset + 2];
     }
 
     /**
@@ -400,7 +405,9 @@ export class BinaryTopology {
 
         const v_address = pool.element_address(id) + 3 * FLOAT_32_SIZE;
         const v_offset = v_address >> 2; // get 4-byte boundary
-        array_copy(value, value_offset, pool.data_float32, v_offset, 3);
+        pool.data_float32[v_offset] = value[value_offset];
+        pool.data_float32[v_offset + 1] = value[value_offset + 1];
+        pool.data_float32[v_offset + 2] = value[value_offset + 2];
     }
 
     /**
@@ -891,7 +898,9 @@ export class BinaryTopology {
         // Offset by the first loop pointer (UINT_32_SIZE)
         const f_address = pool.element_address(id) + UINT_32_SIZE;
         const f_offset = f_address >> 2;
-        array_copy(pool.data_float32, f_offset, result, result_offset, 3);
+        result[result_offset] = pool.data_float32[f_offset];
+        result[result_offset + 1] = pool.data_float32[f_offset + 1];
+        result[result_offset + 2] = pool.data_float32[f_offset + 2];
     }
 
     /**
@@ -903,7 +912,9 @@ export class BinaryTopology {
         const pool = this.__face_pool;
         const f_address = pool.element_address(id) + UINT_32_SIZE;
         const f_offset = f_address >> 2;
-        array_copy(value, value_offset, pool.data_float32, f_offset, 3);
+        pool.data_float32[f_offset] = value[value_offset];
+        pool.data_float32[f_offset + 1] = value[value_offset + 1];
+        pool.data_float32[f_offset + 2] = value[value_offset + 2];
     }
 
     /**

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

@@ -11,6 +11,12 @@
  * Call AFTER an initial vertex-merge/edge-fuse, then merge + fuse again so the new split vertices weld
  * onto the T-junction vertices and the resulting duplicate edges fuse.
  *
+ * A BVH over the vertices replaces the naive all-vertices-per-edge scan: for each boundary edge we
+ * query only the vertices within the tolerance of the edge segment (a capsule), which IS the on-edge
+ * region, so no separate per-candidate distance test is needed. The BVH is built ONCE -- every split
+ * adds a vertex snapped exactly onto an existing one's position, so no candidate position is ever
+ * missing from the original leaf set, and the tree never needs rebuilding as edges split.
+ *
  * @param {BinaryTopology} mesh
  * @param {number} [tolerance] max distance from a vertex to an edge for it to count as "on" the edge
  * @returns {number} number of splits performed

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_resolve_t_junctions.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_resolve_t_junctions.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AACH,8EAHW,MAAM,GACJ,MAAM,CAuElB"}
+{"version":3,"file":"bt_mesh_resolve_t_junctions.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_resolve_t_junctions.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8EAHW,MAAM,GACJ,MAAM,CAwGlB"}

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

@@ -1,95 +1,139 @@
-import { NULL_POINTER } from "../BinaryTopology.js";
-import { bt_edge_split } from "./edge/bt_edge_split.js";
-
-const _a = new Float32Array(3);
-const _b = new Float32Array(3);
-const _p = new Float32Array(3);
-const _hit = new Float32Array(3);
-
-/**
- * Resolve T-junctions: where a vertex lies on the interior of a boundary edge (rather than at one of
- * its endpoints), split that edge at the vertex so the two pieces can later be welded/fused into a
- * shared edge.
- *
- * This is required for meshes assembled from independently-authored faces of differing sizes - e.g. an
- * L-shaped or ring floor built from rectangles, where one rectangle's corner falls in the middle of a
- * neighbour's edge. Without it those faces touch only at a single vertex, so edge-based neighbour
- * queries (island detection, erosion, path-finding) treat them as DISCONNECTED.
- *
- * Call AFTER an initial vertex-merge/edge-fuse, then merge + fuse again so the new split vertices weld
- * onto the T-junction vertices and the resulting duplicate edges fuse.
- *
- * @param {BinaryTopology} mesh
- * @param {number} [tolerance] max distance from a vertex to an edge for it to count as "on" the edge
- * @returns {number} number of splits performed
- */
-export function bt_mesh_resolve_t_junctions(mesh, tolerance = 1e-4) {
-    const tol_sq = tolerance * tolerance;
-
-    let total = 0;
-    let rounds = 0;
-    let changed = true;
-
-    while (changed && rounds < 256) {
-        changed = false;
-        rounds++;
-
-        const edge_count = mesh.edges.size;
-
-        for (let e = 0; e < edge_count; e++) {
-            if (!mesh.edges.is_allocated(e)) continue;
-
-            // only boundary edges (a single radial loop) can carry a T-junction
-            const l = mesh.edge_read_loop(e);
-            if (l === NULL_POINTER) continue;
-            if (mesh.loop_read_radial_next(l) !== l) continue;
-
-            const v1 = mesh.edge_read_vertex1(e);
-            const v2 = mesh.edge_read_vertex2(e);
-
-            mesh.vertex_read_coordinate(_a, 0, v1);
-            mesh.vertex_read_coordinate(_b, 0, v2);
-
-            const abx = _b[0] - _a[0], aby = _b[1] - _a[1], abz = _b[2] - _a[2];
-            const ab_sq = abx * abx + aby * aby + abz * abz;
-            if (ab_sq <= tol_sq) continue;
-
-            const t_margin = tolerance / Math.sqrt(ab_sq);
-
-            let split_t = -1;
-            let split_v = -1;
-
-            const vertex_count = mesh.vertices.size;
-            for (let v = 0; v < vertex_count; v++) {
-                if (v === v1 || v === v2) continue;
-                if (!mesh.vertices.is_allocated(v)) continue;
-
-                mesh.vertex_read_coordinate(_p, 0, v);
-
-                const t = ((_p[0] - _a[0]) * abx + (_p[1] - _a[1]) * aby + (_p[2] - _a[2]) * abz) / ab_sq;
-                if (t <= t_margin || t >= 1 - t_margin) continue;
-
-                const cx = _a[0] + t * abx - _p[0];
-                const cy = _a[1] + t * aby - _p[1];
-                const cz = _a[2] + t * abz - _p[2];
-                if (cx * cx + cy * cy + cz * cz > tol_sq) continue;
-
-                split_t = t;
-                split_v = v;
-                break;
-            }
-
-            if (split_t >= 0) {
-                // snapshot the on-edge vertex coordinate, split, then snap the new vertex exactly onto it
-                mesh.vertex_read_coordinate(_hit, 0, split_v);
-                const nv = bt_edge_split(mesh, e, split_t);
-                mesh.vertex_write_coordinate(nv, _hit, 0);
-
-                total++;
-                changed = true;
-            }
-        }
-    }
-
-    return total;
-}
+import { BVH } from "../../../../../../bvh2/bvh3/BVH.js";
+import {
+    bvh_query_user_data_overlaps_capsule
+} from "../../../../../../bvh2/bvh3/query/bvh_query_user_data_overlaps_capsule.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_edge_split } from "./edge/bt_edge_split.js";
+
+const _a = new Float32Array(3);
+const _b = new Float32Array(3);
+const _p = new Float32Array(3);
+const _hit = new Float32Array(3);
+const _capsule = new Float32Array(7);
+
+/**
+ * Resolve T-junctions: where a vertex lies on the interior of a boundary edge (rather than at one of
+ * its endpoints), split that edge at the vertex so the two pieces can later be welded/fused into a
+ * shared edge.
+ *
+ * This is required for meshes assembled from independently-authored faces of differing sizes - e.g. an
+ * L-shaped or ring floor built from rectangles, where one rectangle's corner falls in the middle of a
+ * neighbour's edge. Without it those faces touch only at a single vertex, so edge-based neighbour
+ * queries (island detection, erosion, path-finding) treat them as DISCONNECTED.
+ *
+ * Call AFTER an initial vertex-merge/edge-fuse, then merge + fuse again so the new split vertices weld
+ * onto the T-junction vertices and the resulting duplicate edges fuse.
+ *
+ * A BVH over the vertices replaces the naive all-vertices-per-edge scan: for each boundary edge we
+ * query only the vertices within the tolerance of the edge segment (a capsule), which IS the on-edge
+ * region, so no separate per-candidate distance test is needed. The BVH is built ONCE -- every split
+ * adds a vertex snapped exactly onto an existing one's position, so no candidate position is ever
+ * missing from the original leaf set, and the tree never needs rebuilding as edges split.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} [tolerance] max distance from a vertex to an edge for it to count as "on" the edge
+ * @returns {number} number of splits performed
+ */
+export function bt_mesh_resolve_t_junctions(mesh, tolerance = 1e-4) {
+    const tol_sq = tolerance * tolerance;
+
+    // --- Build a vertex BVH over the original vertices (point leaves; user data = vertex id) ---
+    const vertices = mesh.vertices;
+    const vertex_count = vertices.size;
+
+    const bvh = new BVH();
+
+    let leaf_count = 0;
+    for (let v = 0; v < vertex_count; v++) {
+        if (!vertices.is_allocated(v)) continue;
+
+        mesh.vertex_read_coordinate(_p, 0, v);
+
+        const node = bvh.allocate_node();
+        bvh.node_set_user_data(node, v);
+        bvh.node_set_aabb_primitive(node, _p[0], _p[1], _p[2], _p[0], _p[1], _p[2]);
+        bvh.insert_leaf(node);
+
+        leaf_count++;
+    }
+
+    if (leaf_count === 0) {
+        return 0;
+    }
+
+    // The query writes one vertex id per overlapping leaf; it can never exceed the leaf count.
+    const candidates = new Uint32Array(leaf_count);
+
+    let total = 0;
+    let rounds = 0;
+    let changed = true;
+
+    while (changed && rounds < 256) {
+        changed = false;
+        rounds++;
+
+        const edge_count = mesh.edges.size;
+
+        for (let e = 0; e < edge_count; e++) {
+            if (!mesh.edges.is_allocated(e)) continue;
+
+            // only boundary edges (a single radial loop) can carry a T-junction
+            const l = mesh.edge_read_loop(e);
+            if (l === NULL_POINTER) continue;
+            if (mesh.loop_read_radial_next(l) !== l) continue;
+
+            const v1 = mesh.edge_read_vertex1(e);
+            const v2 = mesh.edge_read_vertex2(e);
+
+            mesh.vertex_read_coordinate(_a, 0, v1);
+            mesh.vertex_read_coordinate(_b, 0, v2);
+
+            const abx = _b[0] - _a[0], aby = _b[1] - _a[1], abz = _b[2] - _a[2];
+            const ab_sq = abx * abx + aby * aby + abz * abz;
+            if (ab_sq <= tol_sq) continue;
+
+            const t_margin = tolerance / Math.sqrt(ab_sq);
+
+            // candidate vertices: those within `tolerance` of the edge segment (a capsule)
+            _capsule[0] = _a[0]; _capsule[1] = _a[1]; _capsule[2] = _a[2];
+            _capsule[3] = _b[0]; _capsule[4] = _b[1]; _capsule[5] = _b[2];
+            _capsule[6] = tolerance;
+
+            const candidate_count = bvh_query_user_data_overlaps_capsule(candidates, 0, bvh, _capsule);
+
+            let split_t = -1;
+            let split_v = -1;
+
+            for (let i = 0; i < candidate_count; i++) {
+                const v = candidates[i];
+
+                // Candidates are original vertices, which are never removed during resolution (splits
+                // only add), so they are always allocated -- no is_allocated check needed.
+                if (v === v1 || v === v2) continue;
+
+                mesh.vertex_read_coordinate(_p, 0, v);
+
+                // the capsule query already guarantees distance-to-segment <= tolerance; all that is
+                // left is to exclude the segment's endpoints (its hemispherical end caps)
+                const t = ((_p[0] - _a[0]) * abx + (_p[1] - _a[1]) * aby + (_p[2] - _a[2]) * abz) / ab_sq;
+                if (t <= t_margin || t >= 1 - t_margin) continue;
+
+                split_t = t;
+                split_v = v;
+                break;
+            }
+
+            if (split_t >= 0) {
+                // snapshot the on-edge vertex coordinate, split, then snap the new vertex exactly onto it
+                mesh.vertex_read_coordinate(_hit, 0, split_v);
+                const nv = bt_edge_split(mesh, e, split_t);
+                mesh.vertex_write_coordinate(nv, _hit, 0);
+
+                total++;
+                changed = true;
+            }
+        }
+    }
+
+    return total;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AAqLA;;;;;;;;;;;;;;GAcG;AACH,0EAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QA6HrB"}
+{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AA6JA;;;;;;;;;;;;;;GAcG;AACH,0EAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QA6HrB"}

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

@@ -7,6 +7,7 @@ import { bt_mesh_compute_vertex_quadratics } from "./bt_mesh_compute_vertex_quad
 import { bt_edge_collapse } from "./edge/bt_edge_collapse.js";
 import { bt_edge_kill } from "./edge/bt_edge_kill.js";
 import { bt_edge_kill_parallels } from "./edge/bt_edge_kill_parallels.js";
+import { bt_edge_swap_vertex_slots } from "./edge/bt_edge_swap_vertex_slots.js";
 import { bt_vert_fuse_duplicate_edges } from "./vertex/bt_vert_fuse_duplicate_edges.js";
 import { bt_vert_kill } from "./vertex/bt_vert_kill.js";
 
@@ -50,31 +51,6 @@ function count_edge_faces(mesh, edge_id) {
     return count;
 }
 
-/**
- * Swap the v1/v2 slots of an edge. Disk cycle pointers for the two slots are swapped
- * alongside so that the disk cycles on both attached vertices remain valid.
- *
- * @param {BinaryTopology} mesh
- * @param {number} edge_id
- */
-function swap_edge_vertex_slots(mesh, edge_id) {
-    const v1 = mesh.edge_read_vertex1(edge_id);
-    const v2 = mesh.edge_read_vertex2(edge_id);
-
-    const v1_next = mesh.edge_read_v1_disk_next(edge_id);
-    const v1_prev = mesh.edge_read_v1_disk_prev(edge_id);
-    const v2_next = mesh.edge_read_v2_disk_next(edge_id);
-    const v2_prev = mesh.edge_read_v2_disk_prev(edge_id);
-
-    mesh.edge_write_vertex1(edge_id, v2);
-    mesh.edge_write_vertex2(edge_id, v1);
-
-    mesh.edge_write_v1_disk_next(edge_id, v2_next);
-    mesh.edge_write_v1_disk_prev(edge_id, v2_prev);
-    mesh.edge_write_v2_disk_next(edge_id, v1_next);
-    mesh.edge_write_v2_disk_prev(edge_id, v1_prev);
-}
-
 /**
  * Evaluate a potential edge collapse: choose the optimal surviving vertex position
  * and return the quadric-based cost. Returns Infinity if the edge cannot be collapsed.
@@ -285,7 +261,7 @@ export function bt_mesh_simplify(
         // bt_edge_collapse keeps v1 as the survivor. If v2 is the pinned endpoint,
         // swap the edge's slots so the pinned vertex ends up in the v1 position.
         if (v2_restricted) {
-            swap_edge_vertex_slots(mesh, edge_id);
+            bt_edge_swap_vertex_slots(mesh, edge_id);
         }
 
         const pre_survivor = mesh.edge_read_vertex1(edge_id);

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

@@ -0,0 +1,19 @@
+/**
+ * Clean up a triangle mesh in place by removing only geometrically redundant vertices, so the
+ * surface and its boundary are preserved to within `max_error`. Unlike {@link bt_mesh_simplify}
+ * (quadric LoD decimation driven to a face-count target, free to relocate vertices), this is a
+ * conservative half-edge cleanup: it never moves a surviving vertex and never changes the
+ * boundary outline or hole topology by more than `max_error`. It removes the dense interior of
+ * flat/near-coplanar regions and collinear runs of boundary vertices, and stops once the
+ * cheapest remaining collapse would exceed the tolerance.
+ *
+ * Intended for navmesh post-processing, where the input is a walkable surface whose outline and
+ * holes (obstacle footprints) carry meaning and must not drift, but whose interior inherits far
+ * more triangles than navigation needs.
+ *
+ * @param {BinaryTopology} mesh Mesh to clean up in-place.
+ * @param {number} max_error Maximum world-space deviation allowed for any removed vertex and for
+ *     the boundary polyline. A no-op when <= 0.
+ */
+export function bt_mesh_simplify_by_error(mesh: BinaryTopology, max_error: number): void;
+//# sourceMappingURL=bt_mesh_simplify_by_error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_simplify_by_error.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify_by_error.js"],"names":[],"mappings":"AA4aA;;;;;;;;;;;;;;;;GAgBG;AACH,2EAHW,MAAM,QAgHhB"}