@woosh/meep-engine 2.163.11 → 2.164.0

package/src/core/geom/3d/line/line3_compute_segment_closest_point_t.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Computes parameter t for the nearest point on the line segment to the given point.
+ *
+ * t is clamped to [0, 1] and represents position along the line segment from v0 to v1.
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number}
+ * @see line3_compute_segment_point_distance_sqr
+ */
+export function line3_compute_segment_closest_point_t(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, px: number, py: number, pz: number): number;
+//# sourceMappingURL=line3_compute_segment_closest_point_t.d.ts.map

package/src/core/geom/3d/line/line3_compute_segment_closest_point_t.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line3_compute_segment_closest_point_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_closest_point_t.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,0DAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CA+BlB"}

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

@@ -0,0 +1,48 @@
+import { clamp01 } from "../../../math/clamp01.js";
+
+/**
+ * Computes parameter t for the nearest point on the line segment to the given point.
+ *
+ * t is clamped to [0, 1] and represents position along the line segment from v0 to v1.
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number}
+ * @see line3_compute_segment_point_distance_sqr
+ */
+export function line3_compute_segment_closest_point_t(
+    x0, y0, z0,
+    x1, y1, z1,
+    px, py, pz
+) {
+    // get line delta
+    const line_delta_x = x1 - x0;
+    const line_delta_y = y1 - y0;
+    const line_delta_z = z1 - z0;
+
+    // find closest point
+    const sp0_x = px - x0;
+    const sp0_y = py - y0;
+    const sp0_z = pz - z0;
+
+    //
+    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y + line_delta_z * line_delta_z;
+
+    if (d2 === 0) {
+        // line is a point
+        return 0;
+    }
+
+    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
+
+    const t = clamp01(d3 / d2);
+
+    return t;
+}

package/src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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_closest_point_to_aabb3_t(p0_x: number, p0_y: number, p0_z: number, p1_x: number, p1_y: number, p1_z: number, box_x0: number, box_y0: number, box_z0: number, box_x1: number, box_y1: number, box_z1: number): number;
+//# sourceMappingURL=line3_compute_segment_closest_point_to_aabb3_t.d.ts.map

package/src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line3_compute_segment_closest_point_to_aabb3_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qEAdW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAqFlB"}

package/src/core/geom/3d/line/line3_compute_segment_closest_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_closest_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/line/line3_compute_segment_nearest_point_to_aabb3_t.d.ts

@@ -1,44 +1,7 @@
 /**
- * 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]
+ * @deprecated Renamed to {@link line3_compute_segment_closest_point_to_aabb3_t}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function line3_compute_segment_nearest_point_to_aabb3_t(p0_x: number, p0_y: number, p0_z: number, p1_x: number, p1_y: number, p1_z: number, box_x0: number, box_y0: number, box_z0: number, box_x1: number, box_y1: number, box_z1: number): number;
+export const line3_compute_segment_nearest_point_to_aabb3_t: typeof line3_compute_segment_closest_point_to_aabb3_t;
+import { line3_compute_segment_closest_point_to_aabb3_t } from "./line3_compute_segment_closest_point_to_aabb3_t.js";
 //# sourceMappingURL=line3_compute_segment_nearest_point_to_aabb3_t.d.ts.map

package/src/core/geom/3d/line/line3_compute_segment_nearest_point_to_aabb3_t.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_nearest_point_to_aabb3_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_nearest_point_to_aabb3_t.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qEAdW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAqFlB"}
+{"version":3,"file":"line3_compute_segment_nearest_point_to_aabb3_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_nearest_point_to_aabb3_t.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,mHAA6G;+DAN9C,qDAAqD"}

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

@@ -1,153 +1,7 @@
-import { clamp } from "../../../math/clamp.js";
-import { v3_dot } from "../../vec3/v3_dot.js";
+import { line3_compute_segment_closest_point_to_aabb3_t } from "./line3_compute_segment_closest_point_to_aabb3_t.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)
+ * @deprecated Renamed to {@link line3_compute_segment_closest_point_to_aabb3_t}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-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;
-}
+export const line3_compute_segment_nearest_point_to_aabb3_t = line3_compute_segment_closest_point_to_aabb3_t;

package/src/core/geom/3d/line/line3_compute_segment_nearest_point_to_point_t.d.ts

@@ -1,19 +1,7 @@
 /**
- * Computes parameter t for the nearest point on the line segment to the given point.
- *
- * t is clamped to [0, 1] and represents position along the line segment from v0 to v1.
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number}
- * @see line3_compute_segment_point_distance_sqr
+ * @deprecated Renamed to {@link line3_compute_segment_closest_point_t}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function line3_compute_segment_nearest_point_to_point_t(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, px: number, py: number, pz: number): number;
+export const line3_compute_segment_nearest_point_to_point_t: typeof line3_compute_segment_closest_point_t;
+import { line3_compute_segment_closest_point_t } from "./line3_compute_segment_closest_point_t.js";
 //# sourceMappingURL=line3_compute_segment_nearest_point_to_point_t.d.ts.map

package/src/core/geom/3d/line/line3_compute_segment_nearest_point_to_point_t.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_nearest_point_to_point_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_nearest_point_to_point_t.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,mEAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CA+BlB"}
+{"version":3,"file":"line3_compute_segment_nearest_point_to_point_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_nearest_point_to_point_t.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,0GAAoG;sDAN9C,4CAA4C"}

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

@@ -1,48 +1,7 @@
-import { clamp01 } from "../../../math/clamp01.js";
-
-/**
- * Computes parameter t for the nearest point on the line segment to the given point.
- *
- * t is clamped to [0, 1] and represents position along the line segment from v0 to v1.
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number}
- * @see line3_compute_segment_point_distance_sqr
- */
-export function line3_compute_segment_nearest_point_to_point_t(
-    x0, y0, z0,
-    x1, y1, z1,
-    px, py, pz
-) {
-    // get line delta
-    const line_delta_x = x1 - x0;
-    const line_delta_y = y1 - y0;
-    const line_delta_z = z1 - z0;
-
-    // find closest point
-    const sp0_x = px - x0;
-    const sp0_y = py - y0;
-    const sp0_z = pz - z0;
-
-    //
-    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y + line_delta_z * line_delta_z;
-
-    if (d2 === 0) {
-        // line is a point
-        return 0;
-    }
-
-    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
-
-    const t = clamp01(d3 / d2);
-
-    return t;
-}
+import { line3_compute_segment_closest_point_t } from "./line3_compute_segment_closest_point_t.js";
+
+/**
+ * @deprecated Renamed to {@link line3_compute_segment_closest_point_t}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const line3_compute_segment_nearest_point_to_point_t = line3_compute_segment_closest_point_t;

package/src/core/geom/3d/line/line3_compute_segment_point_distance_sqr.d.ts

@@ -10,7 +10,7 @@
  * @param {number} py
  * @param {number} pz
  * @returns {number}
- * @see line3_compute_segment_nearest_point_to_point_t
+ * @see line3_compute_segment_closest_point_t
  */
 export function line3_compute_segment_point_distance_sqr(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, px: number, py: number, pz: number): number;
 //# sourceMappingURL=line3_compute_segment_point_distance_sqr.d.ts.map

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

@@ -1,6 +1,6 @@
 import { clamp01 } from "../../../math/clamp01.js";
 import { v3_distance_sqr } from "../../vec3/v3_distance_sqr.js";
-import { line3_compute_segment_nearest_point_to_point_t } from "./line3_compute_segment_nearest_point_to_point_t.js";
+import { line3_compute_segment_closest_point_t } from "./line3_compute_segment_closest_point_t.js";
 
 /**
  * Computes the shortest distance squared between a line segment defined by 2 points and another point
@@ -14,7 +14,7 @@ import { line3_compute_segment_nearest_point_to_point_t } from "./line3_compute_
  * @param {number} py
  * @param {number} pz
  * @returns {number}
- * @see line3_compute_segment_nearest_point_to_point_t
+ * @see line3_compute_segment_closest_point_t
  */
 export function line3_compute_segment_point_distance_sqr(
     x0, y0, z0,

package/src/core/geom/3d/line/line3_compute_segment_segment_closest_points.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Closest-point pair on two 3D line segments. Writes parameters `s` and `t`
+ * (each in `[0, 1]`) into `out[0]` and `out[1]` such that:
+ *
+ *     closest_point_on_S1 = P1 + s * (Q1 - P1)
+ *     closest_point_on_S2 = P2 + t * (Q2 - P2)
+ *
+ * Source: Ericson, *Real-Time Collision Detection*, §5.1.9. Robust to
+ * degenerate inputs (point-like segments, parallel segments) — both
+ * cases fall back to the clamped point-on-line projection.
+ *
+ * @param {number[]|Float64Array} out length >= 2; receives [s, t]
+ * @param {number} p1x  segment-A start x
+ * @param {number} p1y
+ * @param {number} p1z
+ * @param {number} q1x  segment-A end x
+ * @param {number} q1y
+ * @param {number} q1z
+ * @param {number} p2x  segment-B start x
+ * @param {number} p2y
+ * @param {number} p2z
+ * @param {number} q2x  segment-B end x
+ * @param {number} q2y
+ * @param {number} q2z
+ */
+export function line3_compute_segment_segment_closest_points(out: number[] | Float64Array, p1x: number, p1y: number, p1z: number, q1x: number, q1y: number, q1z: number, p2x: number, p2y: number, p2z: number, q2x: number, q2y: number, q2z: number): void;
+//# sourceMappingURL=line3_compute_segment_segment_closest_points.d.ts.map

package/src/core/geom/3d/line/line3_compute_segment_segment_closest_points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line3_compute_segment_segment_closest_points.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_segment_closest_points.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,kEAdW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAuDhB"}