@woosh/meep-engine 2.163.4 → 2.163.6

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.163.4",
+  "version": "2.163.6",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_face_island_erode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,uEAHW,MAAM,EAAE,kBACR,MAAM,QAqVhB"}
+{"version":3,"file":"bt_mesh_face_island_erode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;GAYG;AACH,uEAHW,MAAM,EAAE,kBACR,MAAM,QAgehB"}

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

@@ -6,13 +6,34 @@ import {
 } from "../../../../line/line3_compute_segment_point_distance_eikonal.js";
 import { NULL_POINTER } from "../BinaryTopology.js";
 import { bt_face_get_incenter } from "../query/bt_face_get_incenter.js";
-import { bt_mesh_build_boundary_distance_field } from "../query/bt_mesh_build_boundary_distance_field.js";
 import { bt_mesh_cleanup_faceless_references } from "./bt_mesh_cleanup_faceless_references.js";
 import { bt_edge_split } from "./edge/bt_edge_split.js";
 import { bt_face_kill } from "./face/bt_face_kill.js";
 import { bt_mesh_face_poke } from "./face/bt_face_poke.js";
 import { bt_face_get_neighbour_faces } from "../query/bt_face_get_neighbour_faces.js";
 
+const _eb_a = new Float32Array(3);
+const _eb_b = new Float32Array(3);
+const _eb_p = new Float32Array(3);
+
+/**
+ * Squared straight-line distance from point p to segment a-b in 3D.
+ */
+function point_segment_distance_sq(px, py, pz, ax, ay, az, bx, by, bz) {
+    const abx = bx - ax, aby = by - ay, abz = bz - az;
+    const apx = px - ax, apy = py - ay, apz = pz - az;
+    const ab_len_sq = abx * abx + aby * aby + abz * abz;
+
+    let t = ab_len_sq > 0 ? (apx * abx + apy * aby + apz * abz) / ab_len_sq : 0;
+    if (t < 0) t = 0; else if (t > 1) t = 1;
+
+    const cx = ax + t * abx - px;
+    const cy = ay + t * aby - py;
+    const cz = az + t * abz - pz;
+
+    return cx * cx + cy * cy + cz * cz;
+}
+
 /**
  * Shrinks an island of faces by a given distance.
  * Conceptually, this moves the outline of the island inwards.
@@ -160,13 +181,152 @@ export function bt_mesh_face_island_erode(
         }
     }
 
-    // 3. Compute Geodesic Distance Field
+    // 3. Distance field: EXACT straight-line distance from each island vertex to the nearest boundary
+    // edge. Agent clearance is a Euclidean (line-of-sight) distance to the nearest wall, NOT a geodesic
+    // distance measured along the surface. The previous eikonal field was both semantically wrong and
+    // sensitive to the triangulation - it produced a lumpy, non-uniform inset (e.g. a 14x14 platform
+    // built from strips eroded by 0.45-0.65 instead of a uniform 0.4). Exact distance is uniform.
     /**
      * Vertex -> Distance from boundary
      * @type {Map<number, number>}
      */
     const vertex_boundary_distances = new Map();
-    bt_mesh_build_boundary_distance_field(vertex_boundary_distances, mesh, island_vertices, boundary_vertices);
+
+    // boundary edge segments, cached by compute_field for reuse in the deviation test below
+    let boundary_segments = [];
+
+    // (re)compute the exact distance field for the current island vertices/boundary
+    function compute_field() {
+        vertex_boundary_distances.clear();
+
+        boundary_segments = [];
+        for (const e of boundary_edges_set) {
+            const bv1 = mesh.edge_read_vertex1(e);
+            const bv2 = mesh.edge_read_vertex2(e);
+            mesh.vertex_read_coordinate(_eb_a, 0, bv1);
+            mesh.vertex_read_coordinate(_eb_b, 0, bv2);
+            boundary_segments.push(_eb_a[0], _eb_a[1], _eb_a[2], _eb_b[0], _eb_b[1], _eb_b[2]);
+        }
+
+        for (const v of island_vertices) {
+            mesh.vertex_read_coordinate(_eb_p, 0, v);
+            vertex_boundary_distances.set(v, dist_to_boundary(_eb_p[0], _eb_p[1], _eb_p[2]));
+        }
+    }
+
+    // exact straight-line distance from a point to the nearest boundary edge
+    function dist_to_boundary(px, py, pz) {
+        const seg = boundary_segments;
+        let best_sq = Infinity;
+        for (let i = 0; i < seg.length; i += 6) {
+            const d_sq = point_segment_distance_sq(
+                px, py, pz,
+                seg[i], seg[i + 1], seg[i + 2],
+                seg[i + 3], seg[i + 4], seg[i + 5]
+            );
+            if (d_sq < best_sq) best_sq = d_sq;
+        }
+        return best_sq === Infinity ? Infinity : Math.sqrt(best_sq);
+    }
+
+    compute_field();
+
+    // 3a. CUT-BAND REFINEMENT. The inset contour is reconstructed piecewise-linearly from the faces the
+    // erosion threshold passes through, so on a coarse/skewed triangulation the cut chord deviates from
+    // the true offset (a strip-built platform eroded unevenly, 0.4 on one side and 0.6 on another). For
+    // each straddling face, place the two cut points and test whether their midpoint really lies at the
+    // erode distance; only refine (split the longest edge) when the chord deviates. Already-accurate
+    // cuts (e.g. a plain quad's straight sides) are left coarse, so detail is added only where needed.
+    {
+        const fine = Math.max(erode_distance * 0.5, 0.1);
+        const fine_sq = fine * fine;
+        const tol = Math.max(erode_distance * 0.15, 0.04);
+        let rounds = 0;
+
+        const ca = new Float32Array(3), cb = new Float32Array(3), cc = new Float32Array(3);
+
+        while (rounds < 48) {
+            rounds++;
+
+            const targets = new Set();
+
+            for (let i = 0; i < island_faces.length; i++) {
+                const f = island_faces[i];
+                if (!mesh.faces.is_allocated(f)) continue;
+
+                const la = mesh.face_read_loop(f);
+                const lb = mesh.loop_read_next(la);
+                const lc = mesh.loop_read_next(lb);
+                const v1 = mesh.loop_read_vertex(la);
+                const v2 = mesh.loop_read_vertex(lb);
+                const v3 = mesh.loop_read_vertex(lc);
+
+                const d1 = vertex_boundary_distances.get(v1);
+                const d2 = vertex_boundary_distances.get(v2);
+                const d3 = vertex_boundary_distances.get(v3);
+
+                const dmin = Math.min(d1, d2, d3);
+                const dmax = Math.max(d1, d2, d3);
+
+                // does the erode threshold pass through this face?
+                if (!(dmin < erode_distance && dmax > erode_distance)) continue;
+
+                mesh.vertex_read_coordinate(ca, 0, v1);
+                mesh.vertex_read_coordinate(cb, 0, v2);
+                mesh.vertex_read_coordinate(cc, 0, v3);
+
+                const e_ab = (ca[0] - cb[0]) ** 2 + (ca[1] - cb[1]) ** 2 + (ca[2] - cb[2]) ** 2;
+                const e_bc = (cb[0] - cc[0]) ** 2 + (cb[1] - cc[1]) ** 2 + (cb[2] - cc[2]) ** 2;
+                const e_ca = (cc[0] - ca[0]) ** 2 + (cc[1] - ca[1]) ** 2 + (cc[2] - ca[2]) ** 2;
+                const longest = Math.max(e_ab, e_bc, e_ca);
+
+                if (longest <= fine_sq) continue;
+
+                // the two cut points where the threshold crosses this face's edges
+                let mx = 0, my = 0, mz = 0, crossings = 0;
+                // edge (v1,v2)
+                if ((d1 < erode_distance) !== (d2 < erode_distance)) {
+                    const t = (erode_distance - d1) / (d2 - d1);
+                    mx += ca[0] + t * (cb[0] - ca[0]); my += ca[1] + t * (cb[1] - ca[1]); mz += ca[2] + t * (cb[2] - ca[2]); crossings++;
+                }
+                // edge (v2,v3)
+                if ((d2 < erode_distance) !== (d3 < erode_distance)) {
+                    const t = (erode_distance - d2) / (d3 - d2);
+                    mx += cb[0] + t * (cc[0] - cb[0]); my += cb[1] + t * (cc[1] - cb[1]); mz += cb[2] + t * (cc[2] - cb[2]); crossings++;
+                }
+                // edge (v3,v1)
+                if ((d3 < erode_distance) !== (d1 < erode_distance)) {
+                    const t = (erode_distance - d3) / (d1 - d3);
+                    mx += cc[0] + t * (ca[0] - cc[0]); my += cc[1] + t * (ca[1] - cc[1]); mz += cc[2] + t * (ca[2] - cc[2]); crossings++;
+                }
+
+                if (crossings === 2) {
+                    mx *= 0.5; my *= 0.5; mz *= 0.5;
+                    const true_d = dist_to_boundary(mx, my, mz);
+                    if (Math.abs(true_d - erode_distance) <= tol) {
+                        // the straight cut here is already accurate - leave this face coarse
+                        continue;
+                    }
+                }
+
+                const sl = (longest === e_ab) ? la : (longest === e_bc) ? lb : lc;
+                targets.add(mesh.loop_read_edge(sl));
+            }
+
+            if (targets.size === 0) break;
+
+            for (const e of targets) {
+                if (mesh.edges.is_allocated(e)) bt_edge_split(mesh, e, 0.5);
+            }
+
+            island_faces = recompute_island_faces(faces);
+            ({ island_vertices, island_edges, boundary_vertices, boundary_edges_set } = collect_island_sets(island_faces));
+
+            compute_field();
+
+            if (mesh.faces.size > 200000) break;
+        }
+    }
     // ---------------------------------------------------------
     // 3.5. PEAK RESCUE PASS (The Fix)
     // Handle cases where a face is "submerged" by vertex values

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

@@ -0,0 +1,16 @@
+/**
+ * Fill boundary holes that are too thin for the agent to occupy.
+ *
+ * Erosion/clearance can leave a hair-thin sliver hole hugging an obstacle's offset edge (a strip of
+ * cells that are actually clear but get pinched off into their own tiny loop). Such a hole is narrower
+ * than the agent, so it can never be a real navigation obstacle - it is numerical noise that inflates
+ * the boundary, the face count, and the loop count. This fills any inner loop whose mean width
+ * (2*area/perimeter, the inradius of an equivalent disc) is below the agent radius. The single
+ * largest-area loop (the outer boundary) is never filled.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} agent_radius
+ * @returns {number} number of holes filled
+ */
+export function bt_mesh_fill_small_holes(mesh: BinaryTopology, agent_radius: number): number;
+//# sourceMappingURL=bt_mesh_fill_small_holes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_fill_small_holes.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;GAaG;AACH,6EAHW,MAAM,GACJ,MAAM,CAoClB"}

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

@@ -0,0 +1,144 @@
+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 _c = [0, 0, 0];
+const _p = [0, 0, 0];
+const _q = [0, 0, 0];
+
+/**
+ * Order a boundary cycle's edges into a vertex/edge walk starting at `start_vertex`.
+ * (Same traversal as bt_mesh_close_boundary_holes.)
+ */
+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;
+    }
+}
+
+/** Perimeter and (Newell) 3D area of an ordered loop of vertices. */
+function loop_perimeter_and_area(mesh, verts) {
+    const n = verts.length;
+    let perimeter = 0;
+    let nx = 0, ny = 0, nz = 0;
+    for (let i = 0; i < n; i++) {
+        mesh.vertex_read_coordinate(_p, 0, verts[i]);
+        mesh.vertex_read_coordinate(_q, 0, verts[(i + 1) % n]);
+        perimeter += Math.hypot(_q[0] - _p[0], _q[1] - _p[1], _q[2] - _p[2]);
+        // Newell's method for polygon area normal
+        nx += (_p[1] - _q[1]) * (_p[2] + _q[2]);
+        ny += (_p[2] - _q[2]) * (_p[0] + _q[0]);
+        nz += (_p[0] - _q[0]) * (_p[1] + _q[1]);
+    }
+    const area = 0.5 * Math.hypot(nx, ny, nz);
+    return { perimeter, area };
+}
+
+/** Fan-fill a single boundary loop (n-gon face + centroid poke), as close_boundary_holes does. */
+function fill_loop(mesh, cycle) {
+    const n = cycle.length;
+    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;
+
+    const ordered_vertices = new Array(n);
+    const ordered_edges = new Array(n);
+    order_cycle_from(mesh, cycle, start_vertex, ordered_vertices, ordered_edges);
+
+    let cx = 0, cy = 0, cz = 0;
+    for (let i = 0; i < n; i++) {
+        mesh.vertex_read_coordinate(_c, 0, ordered_vertices[i]);
+        cx += _c[0]; cy += _c[1]; cz += _c[2];
+    }
+    cx /= n; cy /= n; cz /= n;
+
+    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]);
+    bt_mesh_face_poke(mesh, new_face, cx, cy, cz);
+}
+
+/**
+ * Fill boundary holes that are too thin for the agent to occupy.
+ *
+ * Erosion/clearance can leave a hair-thin sliver hole hugging an obstacle's offset edge (a strip of
+ * cells that are actually clear but get pinched off into their own tiny loop). Such a hole is narrower
+ * than the agent, so it can never be a real navigation obstacle - it is numerical noise that inflates
+ * the boundary, the face count, and the loop count. This fills any inner loop whose mean width
+ * (2*area/perimeter, the inradius of an equivalent disc) is below the agent radius. The single
+ * largest-area loop (the outer boundary) is never filled.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} agent_radius
+ * @returns {number} number of holes filled
+ */
+export function bt_mesh_fill_small_holes(mesh, agent_radius) {
+    if (agent_radius <= 0) return 0;
+
+    const cycles = bt_mesh_walk_boundary_loops(mesh);
+    if (cycles.length <= 1) return 0;
+
+    // measure every loop; the largest-area one is the outer boundary and is never filled
+    const measures = cycles.map(c => {
+        const n = c.length;
+        const verts = new Array(n);
+        const edges = new Array(n);
+        const v1 = mesh.edge_read_vertex1(c[0]);
+        order_cycle_from(mesh, c, v1, verts, edges);
+        return loop_perimeter_and_area(mesh, verts);
+    });
+
+    let outer = 0;
+    for (let i = 1; i < measures.length; i++) {
+        if (measures[i].area > measures[outer].area) outer = i;
+    }
+
+    let filled = 0;
+    for (let i = 0; i < cycles.length; i++) {
+        if (i === outer) continue;
+        const { perimeter, area } = measures[i];
+        if (perimeter <= 0) continue;
+        // mean width of the hole = 2*area/perimeter; fill when the agent disc cannot fit
+        if (2 * area / perimeter < agent_radius) {
+            fill_loop(mesh, cycles[i]);
+            filled++;
+        }
+    }
+
+    return filled;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 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: BinaryTopology, tolerance?: number): number;
+//# sourceMappingURL=bt_mesh_resolve_t_junctions.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,95 @@
+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;
+}

package/src/engine/navigation/mesh/build/bt_mesh_carve_height_clearance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_carve_height_clearance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/bt_mesh_carve_height_clearance.js"],"names":[],"mappings":"AA2NA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAPkC,IAAI;IACJ,MAAM;IACjB,UAAU;IACP,YAAY,EAA3B,MAAM;IACS,YAAY,EAA3B,MAAM;IACU,EAAE;SA0H5B"}
+{"version":3,"file":"bt_mesh_carve_height_clearance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/bt_mesh_carve_height_clearance.js"],"names":[],"mappings":"AA2NA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAPkC,IAAI;IACJ,MAAM;IACjB,UAAU;IACP,YAAY,EAA3B,MAAM;IACS,YAAY,EAA3B,MAAM;IACU,EAAE;SAyH5B"}

package/src/engine/navigation/mesh/build/bt_mesh_carve_height_clearance.js

@@ -254,9 +254,7 @@ export function bt_mesh_carve_height_clearance({
 
     const r = Math.max(agent_radius, 0);
     const resolution = Math.max(agent_radius > 0 ? agent_radius : agent_height / 4, 0.3);
-    const coarse_guard = Math.max(2 * agent_radius, agent_height / 2, 0.8);
     const res_sq = resolution * resolution;
-    const guard_sq = coarse_guard * coarse_guard;
 
     // The agent fits at p iff nothing overhangs directly above it AND nothing overhangs within its body
     // radius. (For r == 0 this is just the exact overhead ray.)
@@ -310,9 +308,10 @@ export function bt_mesh_carve_height_clearance({
             let refine = false;
             if (n_block > 0 && n_clear > 0) {
                 refine = true;   // (dilated) outline crosses this face -> hug it at `resolution`
-            } else if (n_block === 0 && longest_sq > guard_sq) {
-                // all clear by sampling, but still large enough to hide an obstacle between samples:
-                // refine if any downward-facing overhang sits under the whole face footprint (+ radius)
+            } else if (n_block === 0) {
+                // all clear by sampling, but a small obstacle can hide entirely between the samples of a
+                // coarse face. If any downward-facing overhang sits under the face footprint, keep
+                // refining down to the contour resolution so even sub-sample obstacles get caught.
                 if (footprint_has_overhead(source_bvh, source, up_x, up_y, up_z, agent_height, r)) {
                     refine = true;
                 }

package/src/engine/navigation/mesh/build/navmesh_build_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAkLxB;+BA7N8B,mEAAmE"}
+{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAmMxB;+BApP8B,mEAAmE"}

package/src/engine/navigation/mesh/build/navmesh_build_topology.js

@@ -39,6 +39,12 @@ import Vector3 from "../../../../core/geom/Vector3.js";
 import { bvh_build_from_bt_mesh } from "../bvh_build_from_bt_mesh.js";
 import { bvh_build_from_unindexed_triangles } from "./bvh_build_from_unindexed_triangles.js";
 import { bt_mesh_carve_height_clearance } from "./bt_mesh_carve_height_clearance.js";
+import {
+    bt_mesh_resolve_t_junctions
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_resolve_t_junctions.js";
+import {
+    bt_mesh_fill_small_holes
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js";
 
 
 /**
@@ -164,40 +170,47 @@ export function navmesh_build_topology({
         // which is what the loop-based neighbour queries rely on
         bt_mesh_fuse_duplicate_edges(mesh);
 
-        // --- Agent-radius erosion FIRST, on the clean welded surface ---
-        // Erosion is reliable on a clean triangulation; running it BEFORE the obstacle carve avoids
-        // feeding it the irregular, hole-punched mesh the carve would otherwise produce (which made the
-        // vertex-sampled distance field mis-estimate the inset, both over-culling and fragmenting).
-        {
-            const islands = bt_mesh_compute_face_islands(mesh);
-
-            // decouple so islands can be eroded independently
-            bt_mesh_face_decouple_islands(mesh, islands);
-
-            for (const island of islands) {
-                bt_mesh_face_island_erode(mesh, island, agent_radius);
-            }
-
-            // remove dangling references, then compact (erosion frees faces, leaving holes in the ID space)
-            bt_mesh_cleanup_faceless_references(mesh);
-            bt_mesh_compact(mesh);
+        // Resolve T-junctions: when faces of differing sizes abut (an L-shaped or ring floor built from
+        // rectangles, a small tile against a big one), one face's corner can land in the middle of
+        // another's edge. Those faces touch at a single vertex only, so edge-based neighbour queries
+        // treat them as disconnected. Split such edges at the stray vertex, then re-weld/fuse so the
+        // pieces share a real edge.
+        if (bt_mesh_resolve_t_junctions(mesh, 1e-4) > 0) {
+            bt_merge_verts_by_distance(mesh, 1e-6);
+            bt_mesh_fuse_duplicate_edges(mesh);
         }
 
-        // --- Then carve the obstacle footprints (dilated by the agent radius) ---
-        // Runs on the already-eroded surface. Conformal edge-splits + whole-face culls only: this can
-        // never crack a passable region apart, it can only open holes where the agent genuinely cannot
-        // fit under an overhang.
+        // --- Carve obstacle footprints first (no radius dilation here) ---
+        // Cull the floor directly under any overhang, opening a hole at each obstacle footprint. The
+        // agent-radius dilation is handled by the erosion below, which treats these holes as boundaries
+        // and insets them (and the outer edge) by exactly agent_radius - giving both a uniform inset and
+        // a smooth, consistent outline around obstacles from a single, robust pass.
         if (agent_height > 0) {
             bt_mesh_carve_height_clearance({
                 mesh,
                 source,
                 source_bvh,
                 agent_height,
-                agent_radius,
+                agent_radius: 0,
                 up,
             });
 
-            // carve kills faces via the free-list; compact back to a dense, hole-free topology
+            bt_mesh_compact(mesh);
+        }
+
+        // --- Then erode every boundary (outer edge + obstacle holes) by the agent radius ---
+        // The erosion uses an exact Euclidean distance field with cut-band refinement, so it stays
+        // accurate and connected even on the hole-punched mesh the carve produces.
+        {
+            const islands = bt_mesh_compute_face_islands(mesh);
+
+            bt_mesh_face_decouple_islands(mesh, islands);
+
+            for (const island of islands) {
+                bt_mesh_face_island_erode(mesh, island, agent_radius);
+            }
+
+            bt_mesh_cleanup_faceless_references(mesh);
             bt_mesh_compact(mesh);
         }
 
@@ -214,6 +227,16 @@ export function navmesh_build_topology({
             bt_mesh_compact(mesh);
         }
 
+        // Fill hair-thin sliver holes left by erosion/clearance around obstacle offsets. They are
+        // narrower than the agent (it could never fit inside them), so they are numerical noise rather
+        // than real obstacles - removing them restores wrongly-culled walkable area and keeps the
+        // boundary clean (one outer loop + one loop per genuine obstacle).
+        if (agent_radius > 0) {
+            if (bt_mesh_fill_small_holes(mesh, agent_radius) > 0) {
+                bt_mesh_compact(mesh);
+            }
+        }
+
         // face normals are consumed by navigation queries (string-pulling portal normals), populate them now
         bt_mesh_compute_face_normals(mesh);