@ifc-lite/clash 2.3.1 → 2.4.2

package/dist/engine-ts/obb-detect.js

@@ -0,0 +1,298 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { sub, cross, dot, scale } from '../math/vec3.js';
+import { OBB_EPS } from './obb.js';
+function normalize(v) {
+    const len = Math.sqrt(dot(v, v));
+    if (!(len > OBB_EPS))
+        return null;
+    return [v[0] / len, v[1] / len, v[2] / len];
+}
+/** Flip `n` so its largest-magnitude component is positive, so a face and its
+ * antipodal opposite face collapse to the same canonical axis direction. Ties
+ * broken in x, y, z order — identical to the Rust `canonical`. */
+function canonical(n) {
+    const ax = Math.abs(n[0]);
+    const ay = Math.abs(n[1]);
+    const az = Math.abs(n[2]);
+    let idx = 0;
+    if (ay > ax && ay >= az)
+        idx = 1;
+    else if (az > ax && az > ay)
+        idx = 2;
+    return n[idx] < 0 ? [-n[0], -n[1], -n[2]] : n;
+}
+/**
+ * f32-ULP scale factor for a "worst-case" single-precision coordinate: for a
+ * value with magnitude in `[2, 4)` the true float32 ULP is `2^-22`, and for
+ * larger magnitudes the ULP only grows. Same constant (and reasoning) as
+ * `F32_ULP_SCALE` in `./depth.js`, and unlike the copies in `../contact/` it
+ * really is scaling the same quantity — the f32 quantisation of the same
+ * vertex buffer. It is still local because `./depth.js` imports THIS module
+ * (`obbPenetration`, `isThroughPenetration`), so importing the constant
+ * back out of it would close an import cycle for a one-line literal.
+ */
+const F32_ULP_SCALE = 1 / 4_194_304; // 2^-22
+/**
+ * Bound, in radians, on the direction error of a face normal computed as
+ * `cross(b - a, c - a)` from vertices that arrived as f32.
+ *
+ * The vertices carry an absolute coordinate error of about
+ * `max|coord| * 2^-22` (`F32_ULP_SCALE`, the same f32-ULP bound the
+ * penetration floor uses), so each edge does too. `|cross| = |e1||e2|sin t`,
+ * and perturbing the edges by `d` tilts the normal by at most
+ * `d * (|e1| + |e2|) / |cross|`. The denominator makes this a property of the
+ * TRIANGLE's conditioning rather than a constant: a sliver, or a face with
+ * one very short edge, resolves its normal far less sharply than a
+ * well-shaped one at the same distance from the origin.
+ *
+ * This is the quantity an absolute `OBB_EPS` was standing in for, and a fixed
+ * bound is simultaneously too loose near the origin and far too tight away
+ * from it: a 0.05 m thick panel 1 km out resolves its normals to ~2.7e-4, so
+ * `|dot|` between two genuinely perpendicular faces exceeded `1e-6` and the
+ * box stopped being recognised as a box purely because it had been
+ * translated (#5355).
+ */
+function normalAngleError(a, b, c) {
+    const e1 = sub(b, a);
+    const e2 = sub(c, a);
+    let maxAbs = 0;
+    for (const v of [a, b, c]) {
+        for (const k of v) {
+            const m = Math.abs(k);
+            if (m > maxAbs)
+                maxAbs = m;
+        }
+    }
+    const coordErr = Math.max(maxAbs, 1) * F32_ULP_SCALE;
+    const n = cross(e1, e2);
+    const nLen = Math.sqrt(dot(n, n));
+    if (!(nLen > 0))
+        return [Infinity, coordErr];
+    const e1Len = Math.sqrt(dot(e1, e1));
+    const e2Len = Math.sqrt(dot(e2, e2));
+    return [(coordErr * (e1Len + e2Len)) / nLen, coordErr];
+}
+/**
+ * Detect whether `mesh` is a rectangular box: every (non-degenerate)
+ * triangle's normal falls into exactly 3 mutually orthogonal canonical
+ * directions, and every vertex of the triangles in a direction group lies on
+ * one of exactly two offset planes along that direction. That combination —
+ * 3 orthogonal face families, 2 planes each — forces the mesh to be a closed
+ * rectangular box (it rejects, for example, an axis-aligned L-shape, whose
+ * notch adds a third offset plane on two of the axes). Triangulation-
+ * independent: subdividing a box's faces adds triangles but never a new
+ * canonical direction or a third offset plane, so the detection (and the
+ * resulting `Obb`) is identical at any tessellation.
+ *
+ * Returns `null` — not a best-effort guess — when the check fails, so a
+ * caller that only trusts a non-null result never certifies a shape this
+ * function could not confirm.
+ */
+/**
+ * Largest angle (radians) that f32 noise may widen a box-recognition
+ * tolerance to (#5474). The noise bounds are worst cases: for a thin face far
+ * from the origin they can exceed the 45 deg at which a box's perpendicular
+ * face families stop being told apart at all. Noise may widen a tolerance
+ * only up to this angle; data that disagrees by more is not certified a box
+ * (the conservative outcome: the caller falls back to the labelled AABB
+ * estimate). Exact data far out still certifies, because the tests compare
+ * the MEASURED agreement against the tolerance. Same literal as the Rust
+ * `MAX_NOISE_ANGLE`.
+ */
+const MAX_NOISE_ANGLE = 0.1;
+export function detectObb(mesh) {
+    if (mesh.count === 0)
+        return null;
+    // Everything position-dependent is measured from a point ON the mesh, not
+    // from the world origin (#5474). The box's centre used to be rebuilt as
+    // `sum_i c_i * axis_i` from offsets `dot(v, axis_i)` of ABSOLUTE vertex
+    // coordinates, so any error in the axes was multiplied by the element's
+    // distance from the origin: a 0.05 m panel 123 m out reported a 23 mm depth
+    // for a 20 mm overlap, and 1 km out a 65 mm one. Measured from `p0`, the
+    // lever arm is the element's own size.
+    const p0 = mesh.tri(0)[0];
+    const groups = [];
+    // Per family: the direction error bound of its representative (the first
+    // triangle's normal, used only to decide membership), and the area-weighted
+    // sum of its triangles' normals with the numerator of that sum's direction
+    // error bound (see `familyAxes`).
+    const repErr = [];
+    const sums = [];
+    const errNum = [];
+    const groupOfTri = new Array(mesh.count).fill(-1);
+    let coordErr = 0;
+    let reach = 0;
+    for (let t = 0; t < mesh.count; t += 1) {
+        const [a, b, c] = mesh.tri(t);
+        for (const v of [a, b, c]) {
+            const d = sub(v, p0);
+            const r = Math.sqrt(dot(d, d));
+            if (r > reach)
+                reach = r;
+        }
+        const raw = cross(sub(b, a), sub(c, a));
+        const n = normalize(raw);
+        if (!n)
+            continue; // degenerate triangle: contributes no face-normal evidence
+        const cn = canonical(n);
+        const [err, triCoordErr] = normalAngleError(a, b, c);
+        if (triCoordErr > coordErr)
+            coordErr = triCoordErr;
+        let gi = -1;
+        for (let g = 0; g < groups.length; g += 1) {
+            // Two normals of the same face agree to within the sum of their own
+            // direction errors (`1 - cos e <= e^2 / 2`). `OBB_EPS` stays as the
+            // floor, so a mesh at the origin groups exactly as before; far out, a
+            // thin face's triangles no longer split into a 4th "family" and
+            // decertify a perfect box (#5474).
+            const e = Math.min(repErr[g] + err, MAX_NOISE_ANGLE);
+            if (1 - dot(groups[g], cn) <= Math.max(OBB_EPS, 0.5 * e * e)) {
+                gi = g;
+                break;
+            }
+        }
+        if (gi === -1) {
+            if (groups.length >= 3)
+                return null; // a 4th face-normal family: not a box
+            groups.push(cn);
+            repErr.push(err);
+            sums.push([0, 0, 0]);
+            errNum.push(0);
+            gi = groups.length - 1;
+        }
+        // `raw` is twice the triangle's area along its normal, so the sum is
+        // area-weighted; oriented to the representative so opposite faces add
+        // rather than cancel.
+        const sign = dot(raw, groups[gi]) < 0 ? -1 : 1;
+        const sum = sums[gi];
+        for (let k = 0; k < 3; k += 1)
+            sum[k] += sign * raw[k];
+        errNum[gi] += err * Math.sqrt(dot(raw, raw));
+        groupOfTri[t] = gi;
+    }
+    if (groups.length !== 3)
+        return null;
+    const frame = familyAxes(sums, errNum);
+    if (!frame)
+        return null;
+    const [axes, axisErr] = frame;
+    for (let i = 0; i < 3; i += 1) {
+        for (let j = i + 1; j < 3; j += 1) {
+            // The families' own normals must be perpendicular, to within the sum of
+            // their direction errors; `OBB_EPS` stays as a FLOOR so a mesh at the
+            // origin is judged as strictly as before #5355.
+            const ni = scale(sums[i], 1 / Math.sqrt(dot(sums[i], sums[i])));
+            const nj = scale(sums[j], 1 / Math.sqrt(dot(sums[j], sums[j])));
+            const tol = Math.max(Math.min(axisErr[i] + axisErr[j], MAX_NOISE_ANGLE), OBB_EPS);
+            if (Math.abs(dot(ni, nj)) > tol)
+                return null;
+        }
+    }
+    const minOff = [Infinity, Infinity, Infinity];
+    const maxOff = [-Infinity, -Infinity, -Infinity];
+    for (let t = 0; t < mesh.count; t += 1) {
+        const gi = groupOfTri[t];
+        if (gi === -1)
+            continue;
+        const [a, b, c] = mesh.tri(t);
+        for (const v of [a, b, c]) {
+            const o = dot(sub(v, p0), axes[gi]);
+            if (o < minOff[gi])
+                minOff[gi] = o;
+            if (o > maxOff[gi])
+                maxOff[gi] = o;
+        }
+    }
+    // Reject a 3rd offset plane on any axis (e.g. an L-shaped footprint). A
+    // vertex on one of the two planes is off it by its own f32 rounding
+    // (`coordErr` bounds the difference of two vertices' roundings) plus the
+    // axis's direction error across the mesh (`reach` from `p0`); the relative
+    // `OBB_EPS` term is the floor that applied before #5474.
+    for (let t = 0; t < mesh.count; t += 1) {
+        const gi = groupOfTri[t];
+        if (gi === -1)
+            continue;
+        const [a, b, c] = mesh.tri(t);
+        const scaleOff = Math.max(Math.max(1, Math.abs(minOff[gi])), Math.abs(maxOff[gi]));
+        const tol = Math.max(OBB_EPS * scaleOff, coordErr + Math.min(axisErr[gi], MAX_NOISE_ANGLE) * reach);
+        for (const v of [a, b, c]) {
+            const o = dot(sub(v, p0), axes[gi]);
+            const nearMin = Math.abs(o - minOff[gi]) <= tol;
+            const nearMax = Math.abs(o - maxOff[gi]) <= tol;
+            if (!nearMin && !nearMax)
+                return null;
+        }
+    }
+    const half = [0, 0, 0];
+    const c0 = [0, 0, 0];
+    for (let i = 0; i < 3; i += 1) {
+        half[i] = (maxOff[i] - minOff[i]) / 2;
+        c0[i] = (maxOff[i] + minOff[i]) / 2;
+        // Reject a zero-thickness "box": a face family whose triangles are all
+        // coplanar passes the 2-plane test above (`minOff === maxOff`) with no
+        // positive extent along that axis — an open shell (review: #2536).
+        if (!(half[i] > OBB_EPS))
+            return null;
+    }
+    const center = [
+        p0[0] + c0[0] * axes[0][0] + c0[1] * axes[1][0] + c0[2] * axes[2][0],
+        p0[1] + c0[0] * axes[0][1] + c0[1] * axes[1][1] + c0[2] * axes[2][1],
+        p0[2] + c0[0] * axes[0][2] + c0[1] * axes[1][2] + c0[2] * axes[2][2],
+    ];
+    return { center, axes: [axes[0], axes[1], axes[2]], half };
+}
+/**
+ * The box frame from the three families' area-weighted normal sums, with a
+ * direction error bound per axis (#5474).
+ *
+ * Each family's sum is dominated by its largest faces, which resolve their
+ * normal most sharply (`errNum / |sum|` is the area-weighted mean of the
+ * triangles' `normalAngleError`). The frame is then made EXACTLY orthonormal,
+ * most precise family first: its axis is its own normalised sum, the next is
+ * Gram-Schmidt'ed against it, the last is their cross product. A thin panel's
+ * 5 cm side faces therefore inherit the precision of its 3 m faces instead of
+ * contributing their own, and a centre rebuilt from the frame cannot pick up
+ * a non-orthogonality error. Ties in precision keep family order, so the
+ * frame is deterministic. Bit-identical to the Rust `family_axes`.
+ */
+function familyAxes(sums, errNum) {
+    const err = [0, 0, 0];
+    for (let g = 0; g < 3; g += 1) {
+        const len = Math.sqrt(dot(sums[g], sums[g]));
+        if (!(len > 0))
+            return null;
+        err[g] = errNum[g] / len;
+    }
+    const order = [0, 1, 2];
+    // Stable insertion sort on the error bound (3 elements).
+    for (let i = 1; i < 3; i += 1) {
+        let j = i;
+        while (j > 0 && err[order[j]] < err[order[j - 1]]) {
+            [order[j], order[j - 1]] = [order[j - 1], order[j]];
+            j -= 1;
+        }
+    }
+    const [f0, f1, f2] = order;
+    const a0 = normalize(sums[f0]);
+    if (!a0)
+        return null;
+    const a1 = normalize(sub(sums[f1], scale(a0, dot(sums[f1], a0))));
+    if (!a1)
+        return null;
+    let a2 = cross(a0, a1);
+    if (dot(a2, sums[f2]) < 0)
+        a2 = scale(a2, -1);
+    const axes = [];
+    axes[f0] = a0;
+    axes[f1] = a1;
+    axes[f2] = a2;
+    // An orthogonalised axis is as precise as the axes it was built from.
+    const axisErr = [0, 0, 0];
+    axisErr[f0] = err[f0];
+    axisErr[f1] = err[f0] + err[f1];
+    axisErr[f2] = err[f0] + err[f1];
+    return [axes, axisErr];
+}
+//# sourceMappingURL=obb-detect.js.map

package/dist/engine-ts/obb-detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"obb-detect.js","sourceRoot":"","sources":["../../src/engine-ts/obb-detect.ts"],"names":[],"mappings":"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"}

package/dist/engine-ts/obb.d.ts

@@ -32,31 +32,21 @@ export interface MeshLike {
     readonly count: number;
     tri(t: number): [Vec3, Vec3, Vec3];
 }
-/**
- * Detect whether `mesh` is a rectangular box: every (non-degenerate)
- * triangle's normal falls into exactly 3 mutually orthogonal canonical
- * directions, and every vertex of the triangles in a direction group lies on
- * one of exactly two offset planes along that direction. That combination —
- * 3 orthogonal face families, 2 planes each — forces the mesh to be a closed
- * rectangular box (it rejects, for example, an axis-aligned L-shape, whose
- * notch adds a third offset plane on two of the axes). Triangulation-
- * independent: subdividing a box's faces adds triangles but never a new
- * canonical direction or a third offset plane, so the detection (and the
- * resulting `Obb`) is identical at any tessellation.
- *
- * Returns `null` — not a best-effort guess — when the check fails, so a
- * caller that only trusts a non-null result never certifies a shape this
- * function could not confirm.
- */
-export declare function detectObb(mesh: MeshLike): Obb | null;
 /**
  * Bound, in f64 ulps, on the absolute error of one component of the cross
  * product of two UNIT vectors (each component is a product-difference of
  * magnitude-<=1 terms: ~2 ulps), with headroom for the normalisation and the
  * per-projection dot rounding it feeds. Shared by the axis noise bound in
- * {@link obbPenetrationDepth}; same literal in the Rust kernel.
+ * {@link obbPenetration}; same literal in the Rust kernel.
  */
 export declare const AXIS_NOISE_ULPS = 8;
+/** An OBB-OBB minimum translation depth and the UNIT axis it was measured
+ *  along: the depth's precision floor is the pair's f32 noise projected onto
+ *  that axis (#5405). Mirrors the Rust `ObbPenetration`. */
+export interface ObbPenetration {
+    depth: number;
+    axis: Vec3;
+}
 /**
  * Exact penetration depth between two oriented boxes: the minimum overlap
  * over the 15 canonical OBB-OBB separating-axis candidates (each box's 3 face
@@ -70,8 +60,9 @@ export declare const AXIS_NOISE_ULPS = 8;
  * the ~ulp-level absolute error of the cross product into a direction error
  * of up to `AXIS_NOISE_ULPS * EPS / |L|` radians. Each candidate's verdict
  * therefore carries a SCALE-RELATIVE noise bound (see `testAxis`), and a
- * verdict inside its own noise band is skipped — not trusted to separate,
- * not trusted as a depth (review: #2536; the same
+ * verdict inside its own noise band is never trusted to separate, and
+ * contributes a depth candidate of zero rather than being dropped from the
+ * minimum (#5355) (review: #2536; the same
  * tolerance-from-the-wrong-quantity class as #2598/#2600/#2529 — an earlier
  * ABSOLUTE `len > 1e-6` guard here both divided by lengths whose noise
  * dwarfs a thin overlap at large operand scale, and hard-dropped axes that
@@ -86,7 +77,7 @@ export declare const AXIS_NOISE_ULPS = 8;
  * `null` (caller falls back to the AABB estimate) rather than reporting a
  * wrong depth.
  */
-export declare function obbPenetrationDepth(a: Obb, b: Obb): number | null;
+export declare function obbPenetration(a: Obb, b: Obb): ObbPenetration | null;
 /**
  * Whether `a` and `b` are in a THROUGH-PENETRATION configuration: one box's
  * cross-section, in the plane perpendicular to one of ITS OWN axes, is fully
@@ -96,7 +87,7 @@ export declare function obbPenetrationDepth(a: Obb, b: Obb): number | null;
  * ways, so it also holds for the MUTUAL case: two walls crossing at an
  * X-junction, each piercing the other clean through in thickness.
  *
- * This matters because {@link obbPenetrationDepth} reports the minimum
+ * This matters because {@link obbPenetration} reports the minimum
  * TRANSLATION distance to separate the pair, which for this shape is
  * dominated by the piercing member's own extent along the piercing axis, not
  * by how much material it actually crossed (review: #2536 — a 2 m duct
@@ -105,7 +96,7 @@ export declare function obbPenetrationDepth(a: Obb, b: Obb): number | null;
  *
  * Tests containment against EACH box's own axes independently (via
  * {@link piercesAlong}'s general per-axis projection, the same projection
- * {@link obbPenetrationDepth} already computes for its 15 SAT candidates) —
+ * {@link obbPenetration} already computes for its 15 SAT candidates) —
  * unlike an earlier version restricted to a frame shared by both boxes'
  * axes up to sign, this also catches a member piercing through at a generic
  * relative rotation (e.g. a duct crossing a wall at 15 degrees, review:

package/dist/engine-ts/obb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"obb.d.ts","sourceRoot":"","sources":["../../src/engine-ts/obb.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGxC;+DAC+D;AAC/D,eAAO,MAAM,OAAO,WAAO,CAAC;AAE5B,MAAM,WAAW,GAAG;IAClB,MAAM,EAAE,IAAI,CAAC;IACb,2CAA2C;IAC3C,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACzB,6DAA6D;IAC7D,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;yDACyD;AACzD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;CACpC;AAqBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,GAAG,GAAG,IAAI,CA4EpD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,GAAG,IAAI,CAoEjE;AAkED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAK5D"}
+{"version":3,"file":"obb.d.ts","sourceRoot":"","sources":["../../src/engine-ts/obb.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGxC;+DAC+D;AAC/D,eAAO,MAAM,OAAO,WAAO,CAAC;AAE5B,MAAM,WAAW,GAAG;IAClB,MAAM,EAAE,IAAI,CAAC;IACb,2CAA2C;IAC3C,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACzB,6DAA6D;IAC7D,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;yDACyD;AACzD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;CACpC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC;;4DAE4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,IAAI,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,cAAc,GAAG,IAAI,CAsFpE;AAkED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAK5D"}

package/dist/engine-ts/obb.js

@@ -1,138 +1,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-import { sub, cross, dot } from '../math/vec3.js';
+import { cross, dot } from '../math/vec3.js';
 /** Tolerance for normal-direction dedup and offset-plane clustering. Same
  * literal in the Rust kernel — see `rust/clash/src/obb.rs`. */
 export const OBB_EPS = 1e-6;
-function normalize(v) {
-    const len = Math.sqrt(dot(v, v));
-    if (!(len > OBB_EPS))
-        return null;
-    return [v[0] / len, v[1] / len, v[2] / len];
-}
-/** Flip `n` so its largest-magnitude component is positive, so a face and its
- * antipodal opposite face collapse to the same canonical axis direction. Ties
- * broken in x, y, z order — identical to the Rust `canonical`. */
-function canonical(n) {
-    const ax = Math.abs(n[0]);
-    const ay = Math.abs(n[1]);
-    const az = Math.abs(n[2]);
-    let idx = 0;
-    if (ay > ax && ay >= az)
-        idx = 1;
-    else if (az > ax && az > ay)
-        idx = 2;
-    return n[idx] < 0 ? [-n[0], -n[1], -n[2]] : n;
-}
-/**
- * Detect whether `mesh` is a rectangular box: every (non-degenerate)
- * triangle's normal falls into exactly 3 mutually orthogonal canonical
- * directions, and every vertex of the triangles in a direction group lies on
- * one of exactly two offset planes along that direction. That combination —
- * 3 orthogonal face families, 2 planes each — forces the mesh to be a closed
- * rectangular box (it rejects, for example, an axis-aligned L-shape, whose
- * notch adds a third offset plane on two of the axes). Triangulation-
- * independent: subdividing a box's faces adds triangles but never a new
- * canonical direction or a third offset plane, so the detection (and the
- * resulting `Obb`) is identical at any tessellation.
- *
- * Returns `null` — not a best-effort guess — when the check fails, so a
- * caller that only trusts a non-null result never certifies a shape this
- * function could not confirm.
- */
-export function detectObb(mesh) {
-    if (mesh.count === 0)
-        return null;
-    const groups = [];
-    const groupOfTri = new Array(mesh.count).fill(-1);
-    for (let t = 0; t < mesh.count; t += 1) {
-        const [a, b, c] = mesh.tri(t);
-        const n = normalize(cross(sub(b, a), sub(c, a)));
-        if (!n)
-            continue; // degenerate triangle: contributes no face-normal evidence
-        const cn = canonical(n);
-        let gi = -1;
-        for (let g = 0; g < groups.length; g += 1) {
-            if (dot(groups[g], cn) > 1 - OBB_EPS) {
-                gi = g;
-                break;
-            }
-        }
-        if (gi === -1) {
-            if (groups.length >= 3)
-                return null; // a 4th face-normal family: not a box
-            groups.push(cn);
-            gi = groups.length - 1;
-        }
-        groupOfTri[t] = gi;
-    }
-    if (groups.length !== 3)
-        return null;
-    for (let i = 0; i < 3; i += 1) {
-        for (let j = i + 1; j < 3; j += 1) {
-            if (Math.abs(dot(groups[i], groups[j])) > OBB_EPS)
-                return null;
-        }
-    }
-    const minOff = [Infinity, Infinity, Infinity];
-    const maxOff = [-Infinity, -Infinity, -Infinity];
-    for (let t = 0; t < mesh.count; t += 1) {
-        const gi = groupOfTri[t];
-        if (gi === -1)
-            continue;
-        const [a, b, c] = mesh.tri(t);
-        for (const v of [a, b, c]) {
-            const o = dot(v, groups[gi]);
-            if (o < minOff[gi])
-                minOff[gi] = o;
-            if (o > maxOff[gi])
-                maxOff[gi] = o;
-        }
-    }
-    // Reject a 3rd offset plane on any axis (e.g. an L-shaped footprint).
-    for (let t = 0; t < mesh.count; t += 1) {
-        const gi = groupOfTri[t];
-        if (gi === -1)
-            continue;
-        const [a, b, c] = mesh.tri(t);
-        for (const v of [a, b, c]) {
-            const o = dot(v, groups[gi]);
-            const scale = Math.max(1, Math.abs(minOff[gi]), Math.abs(maxOff[gi]));
-            const nearMin = Math.abs(o - minOff[gi]) <= OBB_EPS * scale;
-            const nearMax = Math.abs(o - maxOff[gi]) <= OBB_EPS * scale;
-            if (!nearMin && !nearMax)
-                return null;
-        }
-    }
-    const half = [0, 0, 0];
-    const c0 = [0, 0, 0];
-    for (let i = 0; i < 3; i += 1) {
-        half[i] = (maxOff[i] - minOff[i]) / 2;
-        c0[i] = (maxOff[i] + minOff[i]) / 2;
-        // Reject a zero-thickness "box": a face family whose triangles are all
-        // coplanar passes the 2-plane test above (minOff == maxOff, so both
-        // `nearMin` and `nearMax` hold for every vertex) with no positive
-        // extent along that axis. An open shell (a slab exported without its
-        // top face, or partial `IfcTriangulatedFaceSet` geometry) can produce
-        // exactly this — 3 orthogonal families, but one degenerate — and must
-        // not be certified as a box (review: #2536).
-        if (!(half[i] > OBB_EPS))
-            return null;
-    }
-    const center = [
-        c0[0] * groups[0][0] + c0[1] * groups[1][0] + c0[2] * groups[2][0],
-        c0[0] * groups[0][1] + c0[1] * groups[1][1] + c0[2] * groups[2][1],
-        c0[0] * groups[0][2] + c0[1] * groups[1][2] + c0[2] * groups[2][2],
-    ];
-    return { center, axes: [groups[0], groups[1], groups[2]], half };
-}
 /**
  * Bound, in f64 ulps, on the absolute error of one component of the cross
  * product of two UNIT vectors (each component is a product-difference of
  * magnitude-<=1 terms: ~2 ulps), with headroom for the normalisation and the
  * per-projection dot rounding it feeds. Shared by the axis noise bound in
- * {@link obbPenetrationDepth}; same literal in the Rust kernel.
+ * {@link obbPenetration}; same literal in the Rust kernel.
  */
 export const AXIS_NOISE_ULPS = 8;
 /**
@@ -148,8 +26,9 @@ export const AXIS_NOISE_ULPS = 8;
  * the ~ulp-level absolute error of the cross product into a direction error
  * of up to `AXIS_NOISE_ULPS * EPS / |L|` radians. Each candidate's verdict
  * therefore carries a SCALE-RELATIVE noise bound (see `testAxis`), and a
- * verdict inside its own noise band is skipped — not trusted to separate,
- * not trusted as a depth (review: #2536; the same
+ * verdict inside its own noise band is never trusted to separate, and
+ * contributes a depth candidate of zero rather than being dropped from the
+ * minimum (#5355) (review: #2536; the same
  * tolerance-from-the-wrong-quantity class as #2598/#2600/#2529 — an earlier
  * ABSOLUTE `len > 1e-6` guard here both divided by lengths whose noise
  * dwarfs a thin overlap at large operand scale, and hard-dropped axes that
@@ -164,7 +43,7 @@ export const AXIS_NOISE_ULPS = 8;
  * `null` (caller falls back to the AABB estimate) rather than reporting a
  * wrong depth.
  */
-export function obbPenetrationDepth(a, b) {
+export function obbPenetration(a, b) {
     const T = [b.center[0] - a.center[0], b.center[1] - a.center[1], b.center[2] - a.center[2]];
     // Operand scale for the per-axis noise bound: the sum of BOTH boxes' three
     // half-extents plus the center offset's components. A direction error of
@@ -183,6 +62,7 @@ export function obbPenetrationDepth(a, b) {
         b.half[0] + b.half[1] + b.half[2] +
         Math.abs(T[0]) + Math.abs(T[1]) + Math.abs(T[2]);
     let depth = Infinity;
+    let depthAxis = [0, 0, 0];
     function testAxis(L) {
         const len = Math.sqrt(dot(L, L));
         // Exactly parallel axes: the cross product is zero and the candidate
@@ -205,22 +85,37 @@ export function obbPenetrationDepth(a, b) {
         // `AXIS_NOISE_ULPS * EPS / len` radians (cancellation shrinks `|L|` to
         // sin(angle) but leaves the cross product's ~ulp absolute error intact),
         // so `overlap` is uncertain by up to `extentSum` times that. A verdict
-        // inside the band is SKIPPED: in a separating-axis test, dropping a
-        // candidate can only fail to find a separation — it reports the minimum
-        // over the remaining axes, every one of which is a valid upper bound on
-        // the true depth — never invent one, so the result stays conservative
-        // (it may keep a clash a perfect test would separate, but never
-        // separates a genuine overlap). Do not "harden" this into returning
-        // false: that would turn unresolvable noise into a fabricated
+        // inside the band may not SEPARATE: in a separating-axis test, declining
+        // to separate can only fail to find a separation, never invent one, so
+        // the boolean result stays conservative. Do not "harden" this into
+        // returning false: that would turn unresolvable noise into a fabricated
         // separation. Verdicts OUTSIDE the band are kept whatever `len` is —
         // their own magnitude proves the noise did not decide them.
+        //
+        // It DOES still contribute a depth candidate, of zero (#5355). The depth
+        // is a MINIMUM over candidates, so an axis whose overlap is
+        // indistinguishable from zero is the smallest candidate present;
+        // dropping it hands the minimum to the next-smallest axis, which for two
+        // boxes in flush face contact is a FACE DIMENSION of one of them. #2536
+        // fixed WHICH axes fall in the band (an absolute `len > 1e-6` dropped
+        // axes that were fine, over-reporting a 0.02 m edge contact as 0.45 m);
+        // the remaining half was what dropping does to the minimum, which still
+        // reported 0.85 m for a 0.05 m curtain-wall panel lying flush against a
+        // mullion.
         const noise = extentSum * ((AXIS_NOISE_ULPS * Number.EPSILON) / len);
-        if (Math.abs(overlap) <= noise)
+        if (Math.abs(overlap) <= noise) {
+            if (depth > 0) {
+                depth = 0;
+                depthAxis = u;
+            }
             return true;
+        }
         if (overlap <= 0)
             return false;
-        if (overlap < depth)
+        if (overlap < depth) {
             depth = overlap;
+            depthAxis = u;
+        }
         return true;
     }
     for (let i = 0; i < 3; i += 1)
@@ -235,11 +130,11 @@ export function obbPenetrationDepth(a, b) {
                 return null;
         }
     }
-    return depth === Infinity ? null : depth;
+    return depth === Infinity ? null : { depth, axis: depthAxis };
 }
 /**
  * Projected radius of `o` onto unit axis `u`: half the length of `o`'s
- * shadow on `u`. The same per-axis projection {@link obbPenetrationDepth}'s
+ * shadow on `u`. The same per-axis projection {@link obbPenetration}'s
  * `testAxis` computes for the 15-candidate SAT — factored out here so the
  * through-penetration containment test below can reuse it for ANY axis, not
  * only one drawn from a shared a/b frame.
@@ -306,7 +201,7 @@ function piercesAlong(p, q, centerDelta) {
  * ways, so it also holds for the MUTUAL case: two walls crossing at an
  * X-junction, each piercing the other clean through in thickness.
  *
- * This matters because {@link obbPenetrationDepth} reports the minimum
+ * This matters because {@link obbPenetration} reports the minimum
  * TRANSLATION distance to separate the pair, which for this shape is
  * dominated by the piercing member's own extent along the piercing axis, not
  * by how much material it actually crossed (review: #2536 — a 2 m duct
@@ -315,7 +210,7 @@ function piercesAlong(p, q, centerDelta) {
  *
  * Tests containment against EACH box's own axes independently (via
  * {@link piercesAlong}'s general per-axis projection, the same projection
- * {@link obbPenetrationDepth} already computes for its 15 SAT candidates) —
+ * {@link obbPenetration} already computes for its 15 SAT candidates) —
  * unlike an earlier version restricted to a frame shared by both boxes'
  * axes up to sign, this also catches a member piercing through at a generic
  * relative rotation (e.g. a duct crossing a wall at 15 degrees, review: