@woosh/meep-engine 2.131.48 → 2.132.1

package/README.md

@@ -82,7 +82,7 @@ export default defineConfig({
 ```
 
 ### Reliability
-* **Tests:** 2,944 handwritten tests covering critical algorithms and complex edge cases.
+* **Tests:** 3,159 handwritten tests covering critical algorithms and complex edge cases.
 
 * **Coverage:** 90%+ core coverage.
 

package/package.json

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

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QA+IhB"}
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QAgJhB"}

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.js

@@ -117,7 +117,7 @@ function optimize_treelet(bvh, root, leaves, leaf_count) {
             const i_rest = mask_rest * 6;
 
             // Merge bounds
-            min_x = Math.min(scratch_bounds[i_lsb],     scratch_bounds[i_rest]);
+            min_x = Math.min(scratch_bounds[i_lsb], scratch_bounds[i_rest]);
             min_y = Math.min(scratch_bounds[i_lsb + 1], scratch_bounds[i_rest + 1]);
             min_z = Math.min(scratch_bounds[i_lsb + 2], scratch_bounds[i_rest + 2]);
             max_x = Math.max(scratch_bounds[i_lsb + 3], scratch_bounds[i_rest + 3]);
@@ -128,7 +128,7 @@ function optimize_treelet(bvh, root, leaves, leaf_count) {
         // --- STORE ---
         const dest_offset = s * 6;
 
-        scratch_bounds[dest_offset]     = min_x;
+        scratch_bounds[dest_offset] = min_x;
         scratch_bounds[dest_offset + 1] = min_y;
         scratch_bounds[dest_offset + 2] = min_z;
         scratch_bounds[dest_offset + 3] = max_x;
@@ -144,7 +144,7 @@ function optimize_treelet(bvh, root, leaves, leaf_count) {
 
         scratch_areas[s] = area;
 
-        if(is_a_leaf){
+        if (is_a_leaf) {
             // Initialize costs of individual leaves
             scratch_cost[s] = SAH_COST_TRIANGLE * area;
         }
@@ -285,6 +285,7 @@ export function ebvh_optimize_treelet(
 ) {
     assert.isNonNegativeInteger(treelet_size, 'treelet_size');
     assert.lessThanOrEqual(treelet_size, 8, 'limit is 8');
+    assert.isNonNegativeInteger(root, 'root');
 
     if (root === NULL_NODE) {
         // special case

package/src/core/codegen/LineBuilder.js

@@ -211,15 +211,15 @@ class LineBuilder {
         for (let i = 0; i < line_count; i++) {
             const line = lines[i];
 
-            let indentString = '';
+            let prefix = '';
 
             const indent_count = line.indentation;
 
             for (let j = 0; j < indent_count; j++) {
-                indentString += indent_string;
+                prefix += indent_string;
             }
 
-            result.push(indentString + line.text);
+            result.push(prefix + line.text);
         }
 
         return result.join('\n');

package/src/core/collection/heap/Uint32Heap.d.ts

@@ -85,7 +85,20 @@ export class Uint32Heap {
      * @returns {boolean}
      */
     is_empty(): boolean;
+    /**
+     * Returns the score of the node with the lowest score
+     * @returns {number}
+     */
+    peek_score(): number;
+    /**
+     * Returns the ID of the node with the lowest score
+     * @returns {number}
+     */
     peek_min(): number;
+    /**
+     * Removed and returns the ID of the node with the lowest score
+     * @returns {number}
+     */
     pop_min(): number;
     /**
      *
@@ -133,6 +146,7 @@ export class Uint32Heap {
      */
     get_score(id: number): number;
     /**
+     * Insert or update an element, if the element already exists, its score will be updated.
      *
      * @param {number} id
      * @param {number} score

package/src/core/collection/heap/Uint32Heap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Uint32Heap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/Uint32Heap.js"],"names":[],"mappings":"AAiDA;;;;;GAKG;AACH;IAGI;;;OAGG;IACH,+BAFW,MAAM,EAkChB;IA7BG,2BAA0E;IAE1E;;;;OAIG;IACH,sBAAwD;IAExD;;;;OAIG;IACH,uBAA0D;IAE1D;;;;OAIG;IACH,mBAAkC;IAElC;;;;OAIG;IACH,eAAe;IAGnB;;;OAGG;IACH,wBAsBC;IAED;;;;;OAKG;IACH,gBAOC;IAED;;;;;OAKG;IACH,aAiBC;IAED;;;OAGG;IACH,kBA6BC;IAED;;;;OAIG;IACH,gBAeC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED,mBAEC;IAED,kBAoBC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAWnB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAehB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,SACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CAYlB;IAGD;;;;OAIG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,WAHW,MAAM,SACN,MAAM,QA0BhB;CAGJ"}
+{"version":3,"file":"Uint32Heap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/Uint32Heap.js"],"names":[],"mappings":"AAiDA;;;;;GAKG;AACH;IAGI;;;OAGG;IACH,+BAFW,MAAM,EAkChB;IA7BG,2BAA0E;IAE1E;;;;OAIG;IACH,sBAAwD;IAExD;;;;OAIG;IACH,uBAA0D;IAE1D;;;;OAIG;IACH,mBAAkC;IAElC;;;;OAIG;IACH,eAAe;IAGnB;;;OAGG;IACH,wBAsBC;IAED;;;;;OAKG;IACH,gBAOC;IAED;;;;;OAKG;IACH,aAiBC;IAED;;;OAGG;IACH,kBA6BC;IAED;;;;OAIG;IACH,gBAeC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,WAFa,MAAM,CAsBlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAWnB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAehB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,SACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CAYlB;IAGD;;;;;OAKG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,WAHW,MAAM,SACN,MAAM,QA2BhB;CAGJ"}

package/src/core/collection/heap/Uint32Heap.js

@@ -251,10 +251,26 @@ export class Uint32Heap {
         return this.__size === 0;
     }
 
+    /**
+     * Returns the score of the node with the lowest score
+     * @returns {number}
+     */
+    peek_score() {
+        return this.__data_float32[1];
+    }
+
+    /**
+     * Returns the ID of the node with the lowest score
+     * @returns {number}
+     */
     peek_min() {
         return this.top_id;
     }
 
+    /**
+     * Removed and returns the ID of the node with the lowest score
+     * @returns {number}
+     */
     pop_min() {
         assert.greaterThan(this.__size, 0, 'heap is empty');
 
@@ -408,6 +424,7 @@ export class Uint32Heap {
 
 
     /**
+     * Insert or update an element, if the element already exists, its score will be updated.
      *
      * @param {number} id
      * @param {number} score
@@ -431,6 +448,7 @@ export class Uint32Heap {
         assert.isNonNegativeInteger(id, 'value');
         assert.lessThanOrEqual(id, UINT32_MAX - 1, 'must be less than or equal to (2^32 - 2)');
         assert.isNumber(score, 'score');
+        assert.notNaN(score, 'score');
 
         const current_size = this.__size;
 

package/src/core/collection/map/HashMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AAgGD;;;;;;;;;GASG;AACH;IAsFI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IA7HD;;;;;OAKG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAyB;IAEzB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,oBAAgB;IAEhB;;;;OAIG;IACH,kCAA8B;IAE9B;;;;OAIG;IACH,iCAA6B;IAE7B;;;;OAIG;IACH,qCAAiC;IAEjC;;;;OAIG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,kBAAc;IAwBV;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2CD;;;;;OAKG;IACH,0BAUC;IAuGD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA0EX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAaZ;IAwBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBA0DC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,WAFa,SAAS,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAM3B;IAED;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IA1DD,yDA2BC;;CAgCJ"}
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AA+GA;;;;;;;;;GASG;AACH;IAsFI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IA7HD;;;;;OAKG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAyB;IAEzB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,oBAAgB;IAEhB;;;;OAIG;IACH,kCAA8B;IAE9B;;;;OAIG;IACH,iCAA6B;IAE7B;;;;OAIG;IACH,qCAAiC;IAEjC;;;;OAIG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,kBAAc;IAwBV;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2CD;;;;;OAKG;IACH,0BAUC;IAuGD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA0EX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAaZ;IAwBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBA0DC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,WAFa,SAAS,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAM3B;IAED;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IA1DD,yDA2BC;;CAgCJ"}

package/src/core/collection/map/HashMap.js

@@ -7,6 +7,7 @@ import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../model/object/invokeObjectHash.js";
 import { array_copy } from "../array/array_copy.js";
 import { UintArrayForCount } from "../array/typed/uint_array_for_count.js";
+import { generate_next_linear_congruential_index } from "./generate_next_linear_congruential_index.js";
 
 /*
  * Heavily inspired by ruby's "new" (circa 2016) hash table implementation
@@ -14,25 +15,6 @@ import { UintArrayForCount } from "../array/typed/uint_array_for_count.js";
  * @see https://blog.heroku.com/ruby-2-4-features-hashes-integers-rounding#hash-changes
  */
 
-/**
- * Formula: Xn+1 = (a * Xn + c ) % m
- *
- *    According the Hull-Dobell theorem a generator
- *    "Xnext = (a*Xprev + c) mod m" is a full cycle generator if and only if
- *      o m and c are relatively prime
- *      o a-1 is divisible by all prime factors of m
- *      o a-1 is divisible by 4 if m is divisible by 4.
- *    For our case a is 5, c is 1, and m is a power of two.
- * @param index
- * @param mask used to execute division, this is a number equal to (2^K - 1) where 2^K is the size of the "bins" array
- * @see https://en.wikipedia.org/wiki/Linear_congruential_generator
- */
-export function generate_next_linear_congruential_index(index, mask) {
-    const index5 = (index << 2) + index; // this is just a faster version of index*5
-
-    return (index5 + 1) & mask;
-}
-
 
 /**
  * @template K,V
@@ -452,7 +434,7 @@ export class HashMap {
         const raw_hash = this.#build_key_hash(key);
         let bin_index = this.compute_bin_index(raw_hash);
 
-        assert.isFiniteNumber(bin_index, 'hash');
+        assert.isFinite(bin_index, 'hash');
 
         let first_deleted_bin_index = UNDEFINED_BIN_INDEX;
 
@@ -900,8 +882,8 @@ export class HashMap {
      *
      * @returns {Iterator<[K,V]>}
      */
-    * entries(){
-        for (const e of this){
+    * entries() {
+        for (const e of this) {
             yield e;
         }
     }

package/src/core/collection/map/generate_next_linear_congruential_index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Formula: Xn+1 = (a * Xn + c ) % m
+ *
+ *    According the Hull-Dobell theorem a generator
+ *    "Xnext = (a*Xprev + c) mod m" is a full cycle generator if and only if
+ *      o m and c are relatively prime
+ *      o a-1 is divisible by all prime factors of m
+ *      o a-1 is divisible by 4 if m is divisible by 4.
+ *    For our case a is 5, c is 1, and m is a power of two.
+ * @param {number} index
+ * @param {number} mask used to execute division, this is a number equal to (2^K - 1) where 2^K is the size of the "bins" array
+ * @see https://en.wikipedia.org/wiki/Linear_congruential_generator
+ */
+export function generate_next_linear_congruential_index(index: number, mask: number): number;
+//# sourceMappingURL=generate_next_linear_congruential_index.d.ts.map

package/src/core/collection/map/generate_next_linear_congruential_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_next_linear_congruential_index.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/generate_next_linear_congruential_index.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,+DAJW,MAAM,QACN,MAAM,UAOhB"}

package/src/core/collection/map/generate_next_linear_congruential_index.js

@@ -0,0 +1,18 @@
+/**
+ * Formula: Xn+1 = (a * Xn + c ) % m
+ *
+ *    According the Hull-Dobell theorem a generator
+ *    "Xnext = (a*Xprev + c) mod m" is a full cycle generator if and only if
+ *      o m and c are relatively prime
+ *      o a-1 is divisible by all prime factors of m
+ *      o a-1 is divisible by 4 if m is divisible by 4.
+ *    For our case a is 5, c is 1, and m is a power of two.
+ * @param {number} index
+ * @param {number} mask used to execute division, this is a number equal to (2^K - 1) where 2^K is the size of the "bins" array
+ * @see https://en.wikipedia.org/wiki/Linear_congruential_generator
+ */
+export function generate_next_linear_congruential_index(index, mask) {
+    const index5 = (index << 2) + index; // this is just a faster version of index*5
+
+    return (index5 + 1) & mask;
+}

package/src/core/geom/3d/aabb/AABB3.js

@@ -624,7 +624,7 @@ export class AABB3 {
         target.set(
             this.width,
             this.height,
-            this.height,
+            this.depth,
         );
 
         return target;

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

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_nearest_point_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_nearest_point_to_point.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,EAAE,iBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAkChB"}
+{"version":3,"file":"line3_compute_nearest_point_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_nearest_point_to_point.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,EAAE,iBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAkBhB"}

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

@@ -1,5 +1,5 @@
-import { clamp01 } from "../../../math/clamp01.js";
-import { v3_dot } from "../../vec3/v3_dot.js";
+import { lerp } from "../../../math/lerp.js";
+import { line3_compute_segment_nearest_point_to_point_t } from "./line3_compute_segment_nearest_point_to_point_t.js";
 
 /**
  *
@@ -22,29 +22,13 @@ export function line3_compute_nearest_point_to_point(
     ref_x, ref_y, ref_z
 ) {
 
-    const direction_x = bx - ax;
-    const direction_y = by - ay;
-    const direction_z = bz - az;
+    const t = line3_compute_segment_nearest_point_to_point_t(
+        ax, ay, az,
+        bx, by, bz,
+        ref_x, ref_y, ref_z
+    );
 
-    // find the closest point
-    const sp0_x = ref_x - ax;
-    const sp0_y = ref_y - ay;
-    const sp0_z = ref_z - az;
-
-    //
-    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
-    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
-
-    const t = d3 / d2;
-
-    const t_clamped = clamp01(t);
-
-    // compute point on the line
-    const lp_x = direction_x * t_clamped + ax;
-    const lp_y = direction_y * t_clamped + ay;
-    const lp_z = direction_z * t_clamped + az;
-
-    result[result_offset + 0] = lp_x;
-    result[result_offset + 1] = lp_y;
-    result[result_offset + 2] = lp_z;
+    result[result_offset + 0] = lerp(ax, bx, t);
+    result[result_offset + 1] = lerp(ay, by, t);
+    result[result_offset + 2] = lerp(az, bz, t);
 }

package/src/core/geom/3d/line/line3_compute_segment_nearest_point_to_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_nearest_point_to_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_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

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

package/src/core/geom/3d/line/line3_compute_segment_nearest_point_to_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_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;
+}

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

@@ -0,0 +1,15 @@
+/**
+ *
+ * @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}
+ */
+export function line3_compute_segment_point_distance(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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"line3_compute_segment_point_distance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,yDAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAUlB"}

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

@@ -0,0 +1,24 @@
+import { line3_compute_segment_point_distance_sqr } from "./line3_compute_segment_point_distance_sqr.js";
+
+/**
+ *
+ * @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}
+ */
+export function line3_compute_segment_point_distance(
+    x0, y0, z0,
+    x1, y1, z1,
+    px, py, pz
+) {
+    const d2 = line3_compute_segment_point_distance_sqr(x0, y0, z0, x1, y1, z1, px, py, pz);
+
+    return Math.sqrt(d2);
+}

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

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} d0 distance at v0
+ * @param {number} d1 distance at v1
+ * @param {number} x0 X coordinate of v0
+ * @param {number} y0 Y coordinate of v0
+ * @param {number} z0 Z coordinate of v0
+ * @param {number} x1 X coordinate of v1
+ * @param {number} y1 Y coordinate of v1
+ * @param {number} z1 Z coordinate of v1
+ * @param {number} px X coordinate of reference point
+ * @param {number} py Y coordinate of reference point
+ * @param {number} pz Z coordinate of reference point
+ * @returns {number} The exact geodesic distance
+ */
+export function line3_compute_segment_point_distance_eikonal(d0: number, d1: number, 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_eikonal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAiFlB"}

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

@@ -0,0 +1,95 @@
+/**
+ *
+ * @param {number} d0 distance at v0
+ * @param {number} d1 distance at v1
+ * @param {number} x0 X coordinate of v0
+ * @param {number} y0 Y coordinate of v0
+ * @param {number} z0 Z coordinate of v0
+ * @param {number} x1 X coordinate of v1
+ * @param {number} y1 Y coordinate of v1
+ * @param {number} z1 Z coordinate of v1
+ * @param {number} px X coordinate of reference point
+ * @param {number} py Y coordinate of reference point
+ * @param {number} pz Z coordinate of reference point
+ * @returns {number} The exact geodesic distance
+ */
+export function line3_compute_segment_point_distance_eikonal(
+    d0, d1,
+    x0, y0, z0,
+    x1, y1, z1,
+    px, py, pz
+) {
+    // 2. Map to 2D Local Coordinate System
+    // A (v0) is origin (0,0), B (v1) is (L, 0)
+    const ab_x = x1 - x0;
+    const ab_y = y1 - y0;
+    const ab_z = z1 - z0;
+    const L = Math.hypot(ab_x, ab_y, ab_z);
+
+    if (L < 1e-9) return Math.min(d0, d1);
+
+    // Vector AC
+    const ac_x = px - x0;
+    const ac_y = py - y0;
+    const ac_z = pz - z0;
+
+    // Project AC onto AB to find x coordinate of C
+    const dot = ac_x * ab_x + ac_y * ab_y + ac_z * ab_z;
+    const x = dot / L;
+
+    // Find height (y coordinate) of C
+    const ac_sq_len = ac_x * ac_x + ac_y * ac_y + ac_z * ac_z;
+    const y_sq = ac_sq_len - x * x;
+    const y = y_sq > 0 ? Math.sqrt(y_sq) : 0;
+
+    // 3. Prepare for Eikonal Update
+    let u0 = d0;
+    let u1 = d1;
+    let x_local = x;
+
+    // We need to track which vertex corresponds to u0 for fallback logic
+    let dist_to_u0_vertex_sq = ac_sq_len;
+
+    // Mirror if d1 < d0 to ensure u0 <= u1
+    if (d1 < d0) {
+        u0 = d1;
+        u1 = d0;
+        x_local = L - x;
+        // If u0 is now v1, we need distance from v1 to C (BC squared)
+        // BC^2 = AC^2 + L^2 - 2 * AC * AB_normalized (Law of Cosines / Vector arithmetic)
+        // Or simply recalculate:
+        const bc_x = px - x1;
+        const bc_y = py - y1;
+        const bc_z = pz - z1;
+        dist_to_u0_vertex_sq = bc_x * bc_x + bc_y * bc_y + bc_z * bc_z;
+    }
+
+    const u = u1 - u0;
+
+    // 4. Causality & Consistency Checks
+
+    // Lipschitz / Gradient limit check
+    if (u >= L) {
+        // FIX: Use the distance to the vertex associated with u0 (the smaller value)
+        return u0 + Math.sqrt(dist_to_u0_vertex_sq);
+    }
+
+    // "Virtual Source" Direction check
+    const p = u;
+    const q = L;
+    const det = q * q - p * p;
+    const det_sqrt = Math.sqrt(Math.max(0, det));
+    const coef = p / det_sqrt;
+    const s = x_local - y * coef; // Intersection with x-axis
+
+    if (s > 0) {
+        // 5. Valid Eikonal Update
+        return u0 + (p * x_local + y * det_sqrt) / q;
+    } else {
+        // 6. Fallback (The path comes strictly from one of the vertices)
+        const dist_to_v0 = Math.sqrt(ac_sq_len);
+        // Recalculate dist_to_v1 explicitly to be safe
+        const dist_to_v1 = Math.hypot(px - x1, py - y1, pz - z1);
+        return Math.min(d0 + dist_to_v0, d1 + dist_to_v1);
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Computes the shortest distance squared between a line segment defined by 2 points and another point
+ * @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_nearest_point_to_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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line3_compute_segment_point_distance_sqr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_sqr.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAsClB"}

package/src/core/geom/3d/line/{line3_computeSegmentPointDistance_sqr.js → line3_compute_segment_point_distance_sqr.js}

@@ -1,8 +1,9 @@
-import { v3_distance_sqr } from "../../vec3/v3_distance_sqr.js";
 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";
 
 /**
- * Computes shortest distance between a line segment(defined by 2 points) and a point
+ * Computes the shortest distance squared between a line segment defined by 2 points and another point
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -12,8 +13,15 @@ import { clamp01 } from "../../../math/clamp01.js";
  * @param {number} px
  * @param {number} py
  * @param {number} pz
+ * @returns {number}
+ * @see line3_compute_segment_nearest_point_to_point_t
  */
-export function line3_computeSegmentPointDistance_sqr(x0, y0, z0, x1, y1, z1, px, py, pz) {
+export function line3_compute_segment_point_distance_sqr(
+    x0, y0, z0,
+    x1, y1, z1,
+    px, py, pz
+) {
+
     // get line delta
     const line_delta_x = x1 - x0;
     const line_delta_y = y1 - y0;
@@ -27,6 +35,11 @@ export function line3_computeSegmentPointDistance_sqr(x0, y0, z0, x1, y1, z1, px
     //
     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 v3_distance_sqr(px, py, pz, x0, y0, z0);
+    }
+
     const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
 
     const t = clamp01(d3 / d2);

package/src/core/geom/3d/topology/struct/TopoMesh.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Triangulated mesh graph.
+ * @see BinaryTopology
+ */
 export class TopoMesh {
     /**
      *

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

@@ -1 +1 @@
-{"version":3,"file":"TopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoMesh.js"],"names":[],"mappings":"AAcA;IAEI;;;OAGG;IACH,UAFU,UAAU,EAAE,CAER;IAEd;;;;OAIG;IACH,gBAAoB;IAGpB;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,uBAkBC;IAED;;;OAGG;IACH,YAFa,IAAI,QAAQ,CAAC,CAIzB;IAED;;;OAGG;IACH,YAFa,IAAI,YAAY,CAAC,CAI7B;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,YAAY,CAYjC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CA0GnB;IAED,kBAMC;IAED;;;OAGG;IACH,sBAFa,IAAI,MAAM,EAAE,UAAU,CAAC,CAoBnC;IAED;;;;OAIG;IACH,yBAHW,QAAQ,cACR,IAAI,MAAM,EAAE,UAAU,CAAC,QAYjC;IAED;;;;OAIG;IACH,kBAHW,YAAY,cACZ,IAAI,MAAM,EAAC,UAAU,CAAC,QAqChC;IAED;;;;OAIG;IACH,qBAFW,YAAY,QAsBtB;IAED;;;OAGG;IACH,WAFW,QAAQ,QAclB;IAED;;;OAGG;IACH,aAFW,UAAU,QAKpB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAMpB;IAED;;;OAGG;IACH,gBAFW,UAAU,QAIpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAKnB;IAGD;;;OAGG;IACH,WAFW,QAAQ,QAKlB;IAED;;;OAGG;IACH,iBAFW,QAAQ,QAMlB;IAED;;;OAGG;IACH,cAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,gBAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,uBAFW,SAAS,YAAY,CAAC,QAMhC;IAED;;;OAGG;IACH,cAFW,YAAY,QAwBtB;IAED;;;OAGG;IACH,cAFW,YAAY,QAItB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,OAAO,CAKnB;IAED;;;;;;OAMG;IACH,cALW,UAAU,KACV,UAAU,GAER,QAAQ,CAoCpB;IAED,mBAsCC;IAED,kCAQC;IAED;;;OAGG;IACH,+BAFW,YAAY,QA6BtB;IAED;;;OAGG;IACH,8BAFW,WAAW,GAAC,WAAW,GAAC,MAAM,EAAE,QA4B1C;IAED,0BAiBC;IAED;;;;OAIG;IACH,gBAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,UAClC,WAAW,GAAC,WAAW,GAAC,UAAU,GAAC,MAAM,EAAE,QAYrD;IAED;;;;;;;OAOG;IACH,sBANW,MAAM,MACN,UAAU,MACV,UAAU,MACV,UAAU,GACR,YAAY,CA0BxB;IAED,mBAEC;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B;2BAlsB0B,iBAAiB;yBAFnB,eAAe;6BACX,mBAAmB;qBAR3B,8BAA8B"}
+{"version":3,"file":"TopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoMesh.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAEI;;;OAGG;IACH,UAFU,UAAU,EAAE,CAER;IAEd;;;;OAIG;IACH,gBAAoB;IAGpB;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,uBAkBC;IAED;;;OAGG;IACH,YAFa,IAAI,QAAQ,CAAC,CAIzB;IAED;;;OAGG;IACH,YAFa,IAAI,YAAY,CAAC,CAI7B;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,YAAY,CAYjC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CA0GnB;IAED,kBAMC;IAED;;;OAGG;IACH,sBAFa,IAAI,MAAM,EAAE,UAAU,CAAC,CAoBnC;IAED;;;;OAIG;IACH,yBAHW,QAAQ,cACR,IAAI,MAAM,EAAE,UAAU,CAAC,QAYjC;IAED;;;;OAIG;IACH,kBAHW,YAAY,cACZ,IAAI,MAAM,EAAC,UAAU,CAAC,QAqChC;IAED;;;;OAIG;IACH,qBAFW,YAAY,QAsBtB;IAED;;;OAGG;IACH,WAFW,QAAQ,QAclB;IAED;;;OAGG;IACH,aAFW,UAAU,QAKpB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAMpB;IAED;;;OAGG;IACH,gBAFW,UAAU,QAIpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAKnB;IAGD;;;OAGG;IACH,WAFW,QAAQ,QAKlB;IAED;;;OAGG;IACH,iBAFW,QAAQ,QAMlB;IAED;;;OAGG;IACH,cAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,gBAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,uBAFW,SAAS,YAAY,CAAC,QAMhC;IAED;;;OAGG;IACH,cAFW,YAAY,QAwBtB;IAED;;;OAGG;IACH,cAFW,YAAY,QAItB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,OAAO,CAKnB;IAED;;;;;;OAMG;IACH,cALW,UAAU,KACV,UAAU,GAER,QAAQ,CAoCpB;IAED,mBAsCC;IAED,kCAQC;IAED;;;OAGG;IACH,+BAFW,YAAY,QA6BtB;IAED;;;OAGG;IACH,8BAFW,WAAW,GAAC,WAAW,GAAC,MAAM,EAAE,QA4B1C;IAED,0BAiBC;IAED;;;;OAIG;IACH,gBAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,UAClC,WAAW,GAAC,WAAW,GAAC,UAAU,GAAC,MAAM,EAAE,QAYrD;IAED;;;;;;;OAOG;IACH,sBANW,MAAM,MACN,UAAU,MACV,UAAU,MACV,UAAU,GACR,YAAY,CA0BxB;IAED,mBAEC;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B;2BAtsB0B,iBAAiB;yBAFnB,eAAe;6BACX,mBAAmB;qBAR3B,8BAA8B"}

package/src/core/geom/3d/topology/struct/TopoMesh.js

@@ -12,6 +12,10 @@ import { TopoEdge } from "./TopoEdge.js";
 import { TopoTriangle } from "./TopoTriangle.js";
 import { TopoVertex } from "./TopoVertex.js";
 
+/**
+ * Triangulated mesh graph.
+ * @see BinaryTopology
+ */
 export class TopoMesh {
 
     /**