@woosh/meep-engine 2.163.10 → 2.164.0

package/src/core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.d.ts

@@ -1,6 +1,18 @@
 /**
  * Useful for traversals, such as tree-walking. When using - make sure you manage dependencies nad understand the call-graph to avoid overwriting data that is used else-where
  * Using a pre-allocated continuous chunk of memory gets us better cache coherence
+ *
+ * CONTRACT: each consumer captures `stack_top = pointer` on entry and must drain `pointer` back
+ * to `stack_top` before returning. Consequences of the shared, mutable pointer:
+ *  - A traversal that throws mid-walk leaves `pointer` elevated, silently corrupting every later
+ *    traversal. Predicates/callbacks invoked during a walk therefore must not throw. Callers do
+ *    NOT wrap in try/finally: that de-opts the hot loop; this is a precondition, not a guard.
+ *  - Re-entrancy is only safe for consumers that keep `pointer` live (advance the global pointer
+ *    while walking); such a consumer may be re-entered from a callback because the nested walk
+ *    pushes above the live frame and drains back. Consumers that cache `pointer` into a local
+ *    must not be re-entered.
+ *  - Capacity is fixed and pushes are unchecked; stay within {@link length} entries across all
+ *    concurrently-live frames. Overflow silently drops nodes rather than throwing.
  * @readonly
  * @type {Uint32Array|{pointer:number}}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"SCRATCH_UINT32_TRAVERSAL_STACK.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,6CAFU,WAAW,GAAC;IAAC,OAAO,EAAC,MAAM,CAAA;CAAC,CAEgC"}
+{"version":3,"file":"SCRATCH_UINT32_TRAVERSAL_STACK.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,6CAFU,WAAW,GAAC;IAAC,OAAO,EAAC,MAAM,CAAA;CAAC,CAEgC"}

package/src/core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js

@@ -1,6 +1,18 @@
 /**
  * Useful for traversals, such as tree-walking. When using - make sure you manage dependencies nad understand the call-graph to avoid overwriting data that is used else-where
  * Using a pre-allocated continuous chunk of memory gets us better cache coherence
+ *
+ * CONTRACT: each consumer captures `stack_top = pointer` on entry and must drain `pointer` back
+ * to `stack_top` before returning. Consequences of the shared, mutable pointer:
+ *  - A traversal that throws mid-walk leaves `pointer` elevated, silently corrupting every later
+ *    traversal. Predicates/callbacks invoked during a walk therefore must not throw. Callers do
+ *    NOT wrap in try/finally: that de-opts the hot loop; this is a precondition, not a guard.
+ *  - Re-entrancy is only safe for consumers that keep `pointer` live (advance the global pointer
+ *    while walking); such a consumer may be re-entered from a callback because the nested walk
+ *    pushes above the live frame and drains back. Consumers that cache `pointer` into a local
+ *    must not be re-entered.
+ *  - Capacity is fixed and pushes are unchecked; stay within {@link length} entries across all
+ *    concurrently-live frames. Overflow silently drops nodes rather than throwing.
  * @readonly
  * @type {Uint32Array|{pointer:number}}
  */

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

@@ -0,0 +1,62 @@
+export class IndexedFloatMinHeap {
+    /**
+     * @param {number} id_capacity ids must be in [0, id_capacity)
+     * @param {number} [initial_slot_capacity] initial heap slot count (grows on demand)
+     */
+    constructor(id_capacity: number, initial_slot_capacity?: number);
+    __slot_capacity: number;
+    __size: number;
+    __data_buffer: ArrayBuffer;
+    __data_uint32: Uint32Array;
+    __data_float32: Float32Array;
+    /**
+     * Maps id → slot index in [0, size), or SLOT_NOT_PRESENT.
+     * @type {Uint32Array}
+     */
+    __slot_of_id: Uint32Array;
+    get size(): number;
+    /**
+     * Empty the heap. Only resets the index entries that are actually populated,
+     * so this is O(size), not O(id_capacity).
+     */
+    clear(): void;
+    contains(id: any): boolean;
+    /**
+     * Swap the entries at two slot indices, keeping the id→slot index in sync.
+     * @private
+     */
+    private __swap_slots;
+    /**
+     * Restore heap order downward starting at `start_slot`. Used when an entry's
+     * score has just increased.
+     * @private
+     */
+    private __sift_down;
+    /**
+     * Restore heap order upward starting at `start_slot`. Used when an entry's
+     * score has just decreased.
+     * @private
+     */
+    private __sift_up;
+    __grow_capacity(): void;
+    /**
+     * @param {number} id
+     * @param {number} score
+     */
+    insert(id: number, score: number): void;
+    /**
+     * @returns {number} id of the entry with the smallest score, or -1 if empty
+     */
+    pop_min(): number;
+    /**
+     * @param {number} id
+     * @param {number} new_score
+     */
+    update(id: number, new_score: number): void;
+    /**
+     * @param {number} id
+     * @returns {boolean} true if the id was present and removed
+     */
+    remove(id: number): boolean;
+}
+//# sourceMappingURL=IndexedFloatMinHeap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IndexedFloatMinHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/IndexedFloatMinHeap.js"],"names":[],"mappings":"AAoCA;IACI;;;OAGG;IACH,yBAHW,MAAM,0BACN,MAAM,EAsBhB;IAbG,wBAA4C;IAC5C,eAAe;IAEf,2BAA4E;IAC5E,2BAAwD;IACxD,6BAA0D;IAE1D;;;OAGG;IACH,cAFU,WAAW,CAE2B;IAIpD,mBAEC;IAED;;;OAGG;IACH,cAQC;IAED,2BAEC;IAED;;;OAGG;IACH,qBAkBC;IAED;;;;OAIG;IACH,oBAsBC;IAED;;;;OAIG;IACH,kBAYC;IAED,wBAUC;IAED;;;OAGG;IACH,WAHW,MAAM,SACN,MAAM,QAehB;IAED;;OAEG;IACH,WAFa,MAAM,CAuBlB;IAED;;;OAGG;IACH,WAHW,MAAM,aACN,MAAM,QAehB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CA+BnB;CACJ"}

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

@@ -0,0 +1,268 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Min-heap of (uint32 id, float32 score) entries with an external id→slot index
+ * for O(log n) `update` and `remove` by id (rather than O(n) linear scan).
+ *
+ * This is the conventional-orientation twin of `IndexedFloatMaxHeap`: same
+ * storage and index machinery, but `pop_min` returns the entry with the
+ * *smallest* score. Use it for naturally min-oriented priority problems
+ * (shortest-path / A* distance frontiers, deadline queues, …). For the k-way
+ * Fiduccia–Mattheyses refinement, which genuinely wants the largest gain first,
+ * keep using `IndexedFloatMaxHeap`.
+ *
+ * It is deliberately a standalone copy rather than a subclass of a shared base:
+ * the class is tiny, and extracting the order-specific `__sift_*` comparisons
+ * behind an overridable method would turn the hot-loop call sites polymorphic
+ * and defeat V8 inlining. Duplication keeps each class monomorphic.
+ *
+ * Behaviour notes:
+ *  - This is a MIN-heap (`pop_min` returns the entry with the smallest score).
+ *  - Ids must be in `[0, id_capacity)`; the index table is sized at construction.
+ *  - Duplicate ids are not allowed. Calling `insert` with an existing id throws.
+ *
+ * Storage layout mirrors meep's `Uint32Heap`: each heap slot is 8 bytes packed
+ * as `(float32 score, uint32 id)`. The id→slot map is a separate
+ * `Uint32Array(id_capacity)` where `SLOT_NOT_PRESENT` means "not in heap".
+ *
+ * We measured a JS `Map<number, number>` as the index instead — it removes the
+ * eager `id_capacity` allocation but added 35-60% to FM-dominated benchmarks
+ * because `Map.get/set/delete` per `__swap_slots` call (O(log n) per pop) is
+ * meaningfully slower than typed-array indexing. Kept the typed-array form.
+ */
+
+const SLOT_NOT_PRESENT = 0xFFFFFFFF;
+const BYTES_PER_SLOT = 8;
+
+export class IndexedFloatMinHeap {
+    /**
+     * @param {number} id_capacity ids must be in [0, id_capacity)
+     * @param {number} [initial_slot_capacity] initial heap slot count (grows on demand)
+     */
+    constructor(
+        id_capacity,
+        initial_slot_capacity = Math.min(64, id_capacity)
+    ) {
+        assert.isNonNegativeInteger(id_capacity, 'id_capacity');
+        assert.isNonNegativeInteger(initial_slot_capacity, 'initial_slot_capacity');
+
+        this.__slot_capacity = initial_slot_capacity;
+        this.__size = 0;
+
+        this.__data_buffer = new ArrayBuffer(initial_slot_capacity * BYTES_PER_SLOT);
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+
+        /**
+         * Maps id → slot index in [0, size), or SLOT_NOT_PRESENT.
+         * @type {Uint32Array}
+         */
+        this.__slot_of_id = new Uint32Array(id_capacity);
+        this.__slot_of_id.fill(SLOT_NOT_PRESENT);
+    }
+
+    get size() {
+        return this.__size;
+    }
+
+    /**
+     * Empty the heap. Only resets the index entries that are actually populated,
+     * so this is O(size), not O(id_capacity).
+     */
+    clear() {
+        const data_uint32 = this.__data_uint32;
+        const size = this.__size;
+        const slot_of_id = this.__slot_of_id;
+        for (let slot = 0; slot < size; slot++) {
+            slot_of_id[data_uint32[slot * 2 + 1]] = SLOT_NOT_PRESENT;
+        }
+        this.__size = 0;
+    }
+
+    contains(id) {
+        return this.__slot_of_id[id] !== SLOT_NOT_PRESENT;
+    }
+
+    /**
+     * Swap the entries at two slot indices, keeping the id→slot index in sync.
+     * @private
+     */
+    __swap_slots(slot_a, slot_b) {
+        const data_uint32 = this.__data_uint32;
+        const word_a = slot_a << 1;
+        const word_b = slot_b << 1;
+
+        const score_a = data_uint32[word_a];
+        const id_a    = data_uint32[word_a + 1];
+        const score_b = data_uint32[word_b];
+        const id_b    = data_uint32[word_b + 1];
+
+        data_uint32[word_a]     = score_b;
+        data_uint32[word_a + 1] = id_b;
+        data_uint32[word_b]     = score_a;
+        data_uint32[word_b + 1] = id_a;
+
+        const slot_of_id = this.__slot_of_id;
+        slot_of_id[id_a] = slot_b;
+        slot_of_id[id_b] = slot_a;
+    }
+
+    /**
+     * Restore heap order downward starting at `start_slot`. Used when an entry's
+     * score has just increased.
+     * @private
+     */
+    __sift_down(start_slot) {
+        const size = this.__size;
+        const data_float32 = this.__data_float32;
+        let slot = start_slot;
+
+        for (;;) {
+            const left_child = (slot << 1) + 1;
+            const right_child = left_child + 1;
+            let smallest_slot = slot;
+
+            if (left_child < size && data_float32[left_child * 2] < data_float32[smallest_slot * 2]) {
+                smallest_slot = left_child;
+            }
+            if (right_child < size && data_float32[right_child * 2] < data_float32[smallest_slot * 2]) {
+                smallest_slot = right_child;
+            }
+            if (smallest_slot === slot) {
+                break;
+            }
+            this.__swap_slots(slot, smallest_slot);
+            slot = smallest_slot;
+        }
+    }
+
+    /**
+     * Restore heap order upward starting at `start_slot`. Used when an entry's
+     * score has just decreased.
+     * @private
+     */
+    __sift_up(start_slot) {
+        const data_float32 = this.__data_float32;
+        let slot = start_slot;
+
+        while (slot > 0) {
+            const parent_slot = (slot - 1) >> 1;
+            if (data_float32[parent_slot * 2] <= data_float32[slot * 2]) {
+                break;
+            }
+            this.__swap_slots(parent_slot, slot);
+            slot = parent_slot;
+        }
+    }
+
+    __grow_capacity() {
+        const old_capacity = this.__slot_capacity;
+        const new_capacity = Math.max(old_capacity + 16, Math.ceil(old_capacity * 1.5));
+        const new_buffer = new ArrayBuffer(new_capacity * BYTES_PER_SLOT);
+        const new_uint32 = new Uint32Array(new_buffer);
+        new_uint32.set(this.__data_uint32);
+        this.__data_buffer = new_buffer;
+        this.__data_uint32 = new_uint32;
+        this.__data_float32 = new Float32Array(new_buffer);
+        this.__slot_capacity = new_capacity;
+    }
+
+    /**
+     * @param {number} id
+     * @param {number} score
+     */
+    insert(id, score) {
+        if (this.__slot_of_id[id] !== SLOT_NOT_PRESENT) {
+            throw new Error(`id ${id} already in heap`);
+        }
+        if (this.__size >= this.__slot_capacity) {
+            this.__grow_capacity();
+        }
+        const new_slot = this.__size;
+        this.__data_float32[new_slot * 2] = score;
+        this.__data_uint32[new_slot * 2 + 1] = id;
+        this.__slot_of_id[id] = new_slot;
+        this.__size = new_slot + 1;
+        this.__sift_up(new_slot);
+    }
+
+    /**
+     * @returns {number} id of the entry with the smallest score, or -1 if empty
+     */
+    pop_min() {
+        if (this.__size === 0) {
+            return -1;
+        }
+        const data_uint32 = this.__data_uint32;
+        const top_id = data_uint32[1];
+        const new_size = this.__size - 1;
+        this.__size = new_size;
+        this.__slot_of_id[top_id] = SLOT_NOT_PRESENT;
+
+        if (new_size > 0) {
+            const last_slot_word = new_size << 1;
+            const moved_score = this.__data_float32[last_slot_word];
+            const moved_id = data_uint32[last_slot_word + 1];
+            this.__data_float32[0] = moved_score;
+            data_uint32[1] = moved_id;
+            this.__slot_of_id[moved_id] = 0;
+            this.__sift_down(0);
+        }
+
+        return top_id;
+    }
+
+    /**
+     * @param {number} id
+     * @param {number} new_score
+     */
+    update(id, new_score) {
+        const slot = this.__slot_of_id[id];
+        if (slot === SLOT_NOT_PRESENT) {
+            throw new Error(`id ${id} not in heap`);
+        }
+        const slot_score_address = slot * 2;
+        const old_score = this.__data_float32[slot_score_address];
+        this.__data_float32[slot_score_address] = new_score;
+        if (new_score < old_score) {
+            this.__sift_up(slot);
+        } else if (new_score > old_score) {
+            this.__sift_down(slot);
+        }
+    }
+
+    /**
+     * @param {number} id
+     * @returns {boolean} true if the id was present and removed
+     */
+    remove(id) {
+        const slot = this.__slot_of_id[id];
+        if (slot === SLOT_NOT_PRESENT) {
+            return false;
+        }
+        this.__slot_of_id[id] = SLOT_NOT_PRESENT;
+        const new_size = this.__size - 1;
+        this.__size = new_size;
+
+        if (slot === new_size) {
+            return true;
+        }
+
+        // Move the last entry into the vacated slot, then restore heap order.
+        const last_slot_word = new_size << 1;
+        const moved_score = this.__data_float32[last_slot_word];
+        const moved_id = this.__data_uint32[last_slot_word + 1];
+        const slot_word = slot * 2;
+        const old_slot_score = this.__data_float32[slot_word];
+        this.__data_float32[slot_word] = moved_score;
+        this.__data_uint32[slot_word + 1] = moved_id;
+        this.__slot_of_id[moved_id] = slot;
+
+        if (moved_score < old_slot_score) {
+            this.__sift_up(slot);
+        } else {
+            this.__sift_down(slot);
+        }
+        return true;
+    }
+}

package/src/core/color/tonemap/tonemap_aces.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ACES filmic tone mapping operator (Stephen Hill's "self-shadow" matrix fit).
+ *
+ * Maps unbounded linear HDR radiance into displayable [0,1]. The operator pre-multiplies by an
+ * input matrix (sRGB/linear primaries -> AP1 with RRT saturation), applies the combined
+ * RRT+ODT rational fit per channel, then post-multiplies by an output matrix (back to linear sRGB
+ * primaries) and clamps to [0,1].
+ *
+ * The result is in LINEAR sRGB primaries - apply the sRGB OETF (gamma) afterwards for display.
+ *
+ * Safe for in-place use (output may alias input).
+ *
+ * @source Stephen Hill, https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ */
+export function tonemap_aces(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number): void;
+//# sourceMappingURL=tonemap_aces.d.ts.map

package/src/core/color/tonemap/tonemap_aces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tonemap_aces.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/tonemap/tonemap_aces.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qCALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAqBhB"}

package/src/core/color/tonemap/tonemap_aces.js

@@ -0,0 +1,41 @@
+import { saturate } from "../../math/clamp01.js";
+
+/**
+ * ACES filmic tone mapping operator (Stephen Hill's "self-shadow" matrix fit).
+ *
+ * Maps unbounded linear HDR radiance into displayable [0,1]. The operator pre-multiplies by an
+ * input matrix (sRGB/linear primaries -> AP1 with RRT saturation), applies the combined
+ * RRT+ODT rational fit per channel, then post-multiplies by an output matrix (back to linear sRGB
+ * primaries) and clamps to [0,1].
+ *
+ * The result is in LINEAR sRGB primaries - apply the sRGB OETF (gamma) afterwards for display.
+ *
+ * Safe for in-place use (output may alias input).
+ *
+ * @source Stephen Hill, https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ */
+export function tonemap_aces(output, output_offset, input, input_offset) {
+    const r = input[input_offset];
+    const g = input[input_offset + 1];
+    const b = input[input_offset + 2];
+
+    // input transform: sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+    const x = 0.59719 * r + 0.35458 * g + 0.04823 * b;
+    const y = 0.07600 * r + 0.90834 * g + 0.01566 * b;
+    const z = 0.02840 * r + 0.13383 * g + 0.83777 * b;
+
+    // RRT and ODT fit (per channel)
+    const fx = (x * (x + 0.0245786) - 0.000090537) / (x * (0.983729 * x + 0.4329510) + 0.238081);
+    const fy = (y * (y + 0.0245786) - 0.000090537) / (y * (0.983729 * y + 0.4329510) + 0.238081);
+    const fz = (z * (z + 0.0245786) - 0.000090537) / (z * (0.983729 * z + 0.4329510) + 0.238081);
+
+    // output transform: ODT_SAT => XYZ => D60_2_D65 => sRGB, clamped to [0,1]
+    output[output_offset] = saturate(1.60475 * fx - 0.53108 * fy - 0.07367 * fz);
+    output[output_offset + 1] = saturate(-0.10208 * fx + 1.10813 * fy - 0.00605 * fz);
+    output[output_offset + 2] = saturate(-0.00327 * fx - 0.07276 * fy + 1.07602 * fz);
+}

package/src/core/geom/2d/Rectangle.js

@@ -3,7 +3,7 @@ import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
 import Vector2 from "../Vector2.js";
 import { aabb2_contains } from "./aabb/aabb2_contains.js";
-import { aabb2_overlap_exists } from "./aabb/aabb2_overlap_exists.js";
+import { aabb2_intersects_aabb2 } from "./aabb/aabb2_intersects_aabb2.js";
 
 class Rectangle {
     /**
@@ -144,7 +144,7 @@ class Rectangle {
         const _x1 = s.x + _x0;
         const _y1 = _y0 + s.y;
 
-        return aabb2_overlap_exists(
+        return aabb2_intersects_aabb2(
             _x0, _y0, _x1, _y1,
             x0, y0, x1, y1
         );

package/src/core/geom/2d/aabb/AABB2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/AABB2.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"AABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/AABB2.js"],"names":[],"mappings":"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"}

package/src/core/geom/2d/aabb/AABB2.js

@@ -3,12 +3,10 @@ import { clamp } from "../../../math/clamp.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
 import Vector2 from "../../Vector2.js";
-import {
-    line_segment_compute_line_segment_intersection_2d
-} from "../line/line_segment_compute_line_segment_intersection_2d.js";
-import { aabb2_compute_area } from "./aabb2_compute_area.js";
-import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
-import { aabb2_overlap_exists } from "./aabb2_overlap_exists.js";
+import { segment2_segment_compute_intersection_v2_2d } from "../line/segment2_segment_compute_intersection_v2_2d.js";
+import { aabb2_area } from "./aabb2_area.js";
+import { aabb2_compute_intersection } from "./aabb2_compute_intersection.js";
+import { aabb2_intersects_aabb2 } from "./aabb2_intersects_aabb2.js";
 
 /**
  *
@@ -237,7 +235,7 @@ class AABB2 {
         const bx1 = other.x1;
         const by1 = other.y1;
 
-        return aabb2_compute_overlap(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1, result);
+        return aabb2_compute_intersection(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1, result);
     }
 
     /**
@@ -256,7 +254,7 @@ class AABB2 {
         const bx1 = other.x1;
         const by1 = other.y1;
 
-        return aabb2_overlap_exists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1);
+        return aabb2_intersects_aabb2(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1);
     }
 
     /**
@@ -298,19 +296,19 @@ class AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x1, y0, result)) {
+        if (segment2_segment_compute_intersection_v2_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x1, y0, result)) {
             //top
             return true;
         }
-        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y1, x1, y1, result)) {
+        if (segment2_segment_compute_intersection_v2_2d(p0.x, p0.y, p1.x, p1.y, x0, y1, x1, y1, result)) {
             //bottom
             return true;
         }
-        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x0, y1, result)) {
+        if (segment2_segment_compute_intersection_v2_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x0, y1, result)) {
             //left
             return true;
         }
-        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x1, y0, x1, y1, result)) {
+        if (segment2_segment_compute_intersection_v2_2d(p0.x, p0.y, p1.x, p1.y, x1, y0, x1, y1, result)) {
             //right
             return true;
         }
@@ -397,7 +395,7 @@ class AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        return aabb2_compute_area(x0, y0, x1, y1);
+        return aabb2_area(x0, y0, x1, y1);
     }
 
     /**

package/src/core/geom/2d/aabb/aabb2_area.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {number}
+ */
+export function aabb2_area(x0: number, y0: number, x1: number, y1: number): number;
+//# sourceMappingURL=aabb2_area.d.ts.map

package/src/core/geom/2d/aabb/aabb2_area.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_area.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_area.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,+BANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAOjB"}

package/src/core/geom/2d/aabb/aabb2_area.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {number}
+ */
+export function aabb2_area(x0, y0, x1, y1) {
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+
+    return dx * dy;
+}

package/src/core/geom/2d/aabb/aabb2_array_combine.d.ts

@@ -1,11 +1,7 @@
 /**
- * Merge bounds of two axis-aligned bounding boxes, the result is a box that tightly bounds inputs
- * @param {ArrayLike<number>|number[]|Float32Array} result where resulting value is written to
- * @param {number} result_offset
- * @param {ArrayLike<number>|number[]|Float32Array} a
- * @param {number} a_offset
- * @param {ArrayLike<number>|number[]|Float32Array} b
- * @param {number} b_offset
+ * @deprecated Renamed to {@link aabb2_union_array}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function aabb2_array_combine(result: ArrayLike<number> | number[] | Float32Array, result_offset: number, a: ArrayLike<number> | number[] | Float32Array, a_offset: number, b: ArrayLike<number> | number[] | Float32Array, b_offset: number): void;
+export const aabb2_array_combine: typeof aabb2_union_array;
+import { aabb2_union_array } from "./aabb2_union_array.js";
 //# sourceMappingURL=aabb2_array_combine.d.ts.map

package/src/core/geom/2d/aabb/aabb2_array_combine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb2_array_combine.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_array_combine.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,4CAPW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,iBACvC,MAAM,KACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,YACvC,MAAM,KACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,YACvC,MAAM,QAwBhB"}
+{"version":3,"file":"aabb2_array_combine.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_array_combine.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,2DAAqD;kCANnB,wBAAwB"}

package/src/core/geom/2d/aabb/aabb2_array_combine.js

@@ -1,35 +1,7 @@
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
-
-/**
- * Merge bounds of two axis-aligned bounding boxes, the result is a box that tightly bounds inputs
- * @param {ArrayLike<number>|number[]|Float32Array} result where resulting value is written to
- * @param {number} result_offset
- * @param {ArrayLike<number>|number[]|Float32Array} a
- * @param {number} a_offset
- * @param {ArrayLike<number>|number[]|Float32Array} b
- * @param {number} b_offset
- */
-export function aabb2_array_combine(
-    result, result_offset,
-    a, a_offset,
-    b, b_offset
-) {
-
-    const a_x0 = a[a_offset];
-    const a_y0 = a[a_offset + 1];
-    const a_x1 = a[a_offset + 2];
-    const a_y1 = a[a_offset + 3];
-
-    const b_x0 = b[b_offset];
-    const b_y0 = b[b_offset + 1];
-    const b_x1 = b[b_offset + 2];
-    const b_y1 = b[b_offset + 3];
-
-    result[result_offset] = min2(a_x0, b_x0);
-    result[result_offset + 1] = min2(a_y0, b_y0);
-
-    result[result_offset + 2] = max2(a_x1, b_x1);
-    result[result_offset + 3] = max2(a_y1, b_y1);
-
-}
+import { aabb2_union_array } from "./aabb2_union_array.js";
+
+/**
+ * @deprecated Renamed to {@link aabb2_union_array}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const aabb2_array_combine = aabb2_union_array;

package/src/core/geom/2d/aabb/aabb2_center_from_aabb2_buffer.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {Array.<AABB2>} boxes
+ * @returns {Vector2}
+ */
+export function aabb2_center_from_aabb2_buffer(boxes: Array<AABB2>): Vector2;
+import Vector2 from "../../Vector2.js";
+//# sourceMappingURL=aabb2_center_from_aabb2_buffer.d.ts.map

package/src/core/geom/2d/aabb/aabb2_center_from_aabb2_buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_center_from_aabb2_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_center_from_aabb2_buffer.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,YAAa,GACX,OAAO,CAkBnB;oBAvBmB,kBAAkB"}