@woosh/meep-engine 2.169.1 → 2.169.2

package/src/core/color/operations/color_saturate.js

@@ -1,33 +1,24 @@
-import { assert } from "../../assert.js";
-import { clamp01 } from "../../math/clamp01.js";
-import { Color } from "../Color.js";
-import { linear_srgb_to_okhsv } from "../oklab/linear_srgb_to_okhsv.js";
-import { okhsv_to_linear_srgb } from "../oklab/okhsv_to_linear_srgb.js";
-
-const hsv = [0, 0, 0];
-
-/**
- *
- * @param {Color} input
- * @param {number} [amount]
- * @returns {Color}
- */
-export function color_saturate(input, amount = 1) {
-    assert.isNumber(amount, 'amount');
-    assert.greaterThanOrEqual(amount, 0, 'amount');
-
-    if (amount === 0) {
-        // no change
-        return input;
-    }
-
-    const r = new Color();
-
-    linear_srgb_to_okhsv(hsv, input.r, input.g, input.b);
-
-    hsv[1] = clamp01(hsv[1] * (1 + amount));
-
-    okhsv_to_linear_srgb(r, ...hsv);
-
-    return r;
-}
+import { assert } from "../../assert.js";
+import { OKHSV_CHANNEL_SATURATION, color_scale_okhsv_channel } from "./color_scale_okhsv_channel.js";
+
+/**
+ * Saturate a colour by scaling its OkHSV saturation channel up.
+ *
+ * `amount` of 0 is a no-op and returns `input` itself rather than a copy. The scaled channel is clamped to
+ * `[0, 1]`, so an `amount` beyond the useful range saturates rather than wrapping.
+ *
+ * @param {Color} input
+ * @param {number} [amount]
+ * @returns {Color} `input` when `amount` is 0, otherwise a new Color
+ */
+export function color_saturate(input, amount = 1) {
+    assert.isNumber(amount, 'amount');
+    assert.greaterThanOrEqual(amount, 0, 'amount');
+
+    if (amount === 0) {
+        // skip allocation, no change
+        return input;
+    }
+
+    return color_scale_okhsv_channel(input, OKHSV_CHANNEL_SATURATION, 1 + amount);
+}

package/src/core/color/operations/color_scale_okhsv_channel.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Convert `input` to OkHSV, multiply one channel by `factor`, clamp it to `[0, 1]`, and convert back.
+ *
+ * Shared body of {@link color_lighten} / {@link color_darken} / {@link color_saturate} /
+ * {@link color_desaturate}, which differed only in the channel index and the factor. `channel` is a
+ * numeric index, not a string key — the four public functions remain the typed entry points.
+ *
+ * @param {Color} input
+ * @param {number} channel OkHSV channel index; see {@link OKHSV_CHANNEL_SATURATION} / {@link OKHSV_CHANNEL_VALUE}
+ * @param {number} factor multiplier applied to that channel
+ * @returns {Color} a new Color
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function color_scale_okhsv_channel(input: Color, channel: number, factor: number): Color;
+/**
+ * OkHSV channel index for saturation.
+ * @type {number}
+ */
+export const OKHSV_CHANNEL_SATURATION: number;
+/**
+ * OkHSV channel index for value.
+ * @type {number}
+ */
+export const OKHSV_CHANNEL_VALUE: number;
+import { Color } from "../Color.js";
+//# sourceMappingURL=color_scale_okhsv_channel.d.ts.map

package/src/core/color/operations/color_scale_okhsv_channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color_scale_okhsv_channel.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/operations/color_scale_okhsv_channel.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AACH,iDARW,KAAK,WACL,MAAM,UACN,MAAM,GACJ,KAAK,CAejB;AAvCD;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,kCAFU,MAAM,CAEqB;sBAff,aAAa"}

package/src/core/color/operations/color_scale_okhsv_channel.js

@@ -0,0 +1,45 @@
+import { Color } from "../Color.js";
+import { clamp01 } from "../../math/clamp01.js";
+import { linear_srgb_to_okhsv } from "../oklab/linear_srgb_to_okhsv.js";
+import { okhsv_to_linear_srgb } from "../oklab/okhsv_to_linear_srgb.js";
+
+/**
+ * OkHSV channel index for saturation.
+ * @type {number}
+ */
+export const OKHSV_CHANNEL_SATURATION = 1;
+
+/**
+ * OkHSV channel index for value.
+ * @type {number}
+ */
+export const OKHSV_CHANNEL_VALUE = 2;
+
+const hsv = [0, 0, 0];
+
+/**
+ * Convert `input` to OkHSV, multiply one channel by `factor`, clamp it to `[0, 1]`, and convert back.
+ *
+ * Shared body of {@link color_lighten} / {@link color_darken} / {@link color_saturate} /
+ * {@link color_desaturate}, which differed only in the channel index and the factor. `channel` is a
+ * numeric index, not a string key — the four public functions remain the typed entry points.
+ *
+ * @param {Color} input
+ * @param {number} channel OkHSV channel index; see {@link OKHSV_CHANNEL_SATURATION} / {@link OKHSV_CHANNEL_VALUE}
+ * @param {number} factor multiplier applied to that channel
+ * @returns {Color} a new Color
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function color_scale_okhsv_channel(input, channel, factor) {
+    const result = new Color();
+
+    linear_srgb_to_okhsv(hsv, input.r, input.g, input.b);
+
+    hsv[channel] = clamp01(hsv[channel] * factor);
+
+    okhsv_to_linear_srgb(result, hsv[0], hsv[1], hsv[2]);
+
+    return result;
+}

package/src/core/geom/2d/hash-grid/SpatialHashGrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAMA,kCAAuC;AA2BvC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AAEnC;IAuCI,8DAYC;IAxCD,qBAEC;IAED,qBAEC;IAED,mCAEC;IAED;;;OAGG;IACH,sCAEC;IAED,oBAEC;IAED,4BAEC;IAsBD,2BAIC;IAED,0DAKC;IAED,4CAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA8BhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,MAAM,CAKjB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,KACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QA+BhB;;CACJ;kCAjYiC,sDAAsD"}
+{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAMA,kCAAuC;AAuCvC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AAEnC;IAuCI,8DAYC;IAxCD,qBAEC;IAED,qBAEC;IAED,mCAEC;IAED;;;OAGG;IACH,sCAEC;IAED,oBAEC;IAED,4BAEC;IAsBD,2BAIC;IAED,0DAKC;IAED,4CAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA8BhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,MAAM,CAKjB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,KACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QA+BhB;;CACJ;kCA7YiC,sDAAsD"}

package/src/core/geom/2d/hash-grid/SpatialHashGrid.js

@@ -31,6 +31,18 @@ const COLUMN_NODE_GRID_INDEX = 3;
 
 const COLUMN_ELEMENT_DATA = 0;
 const COLUMN_ELEMENT_NODE_FIRST = 1;
+/*
+ * ELEMENT AABB LAYOUT
+ *
+ * The COLUMN_ELEMENT_* offsets below are the single source of truth for an element's stored bounds; the
+ * query functions (shg_query_elements_circle / _line / _box) each read the four floats inline rather than
+ * through a helper. That is deliberate: a shared reader would have to return four values through an out
+ * array, turning four register-resident locals into a memory round-trip inside a per-element broadphase
+ * loop. The layout itself is not duplicated -- every query imports these constants.
+ *
+ * DUPLICATE EMISSION: an element spanning several cells is emitted once per overlapping cell. None of the
+ * query functions de-duplicate; callers that need distinct elements must do so themselves.
+ */
 export const COLUMN_ELEMENT_X0 = 2;
 export const COLUMN_ELEMENT_Y0 = 3;
 export const COLUMN_ELEMENT_X1 = 4;

package/src/core/geom/2d/line/segment2_intersects_segment2_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment2_intersects_segment2_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_intersects_segment2_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,sDAXW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAkBnB"}
+{"version":3,"file":"segment2_intersects_segment2_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_intersects_segment2_2d.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,sDAXW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CASnB"}

package/src/core/geom/2d/line/segment2_intersects_segment2_2d.js

@@ -1,29 +1,25 @@
-/**
- *
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @returns {boolean} True if segments intersect, False otherwise
- * @public
- */
-export function segment2_intersects_segment2_2d(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-    const dy_02 = a0_y - b0_y;
-    const dx_02 = a0_x - b0_x;
-
-    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
-
-    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
-    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
-
-    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
-}
+import { segment2_segment_intersection_fractions } from "./segment2_segment_intersection_fractions.js";
+
+// the fractions themselves are discarded by this boolean face
+const scratch_fractions = new Float64Array(2);
+
+/**
+ *
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} True if segments intersect, False otherwise
+ * @public
+ */
+export function segment2_intersects_segment2_2d(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
+    return segment2_segment_intersection_fractions(
+        scratch_fractions, 0,
+        a0_x, a0_y, a1_x, a1_y,
+        b0_x, b0_y, b1_x, b1_y
+    );
+}

package/src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment2_segment_compute_intersection_array_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,uEAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACL,OAAO,CAkClB"}
+{"version":3,"file":"segment2_segment_compute_intersection_array_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,uEAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACL,OAAO,CAyBlB"}

package/src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.js

@@ -1,51 +1,46 @@
-/**
- *
- * Find intersection point between two line segments if they intersect at all
- * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
- * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
- *
- * @param {number[]|Float32Array|Float64Array} result resulting intersection point will be stored here if intersection exists
- * @param {number} result_offset
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @return {boolean} True if segments intersect, False otherwise
- */
-export function segment2_segment_compute_intersection_array_2d(
-    result, result_offset,
-    a0_x, a0_y, a1_x, a1_y,
-    b0_x, b0_y, b1_x, b1_y
-) {
-
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-    const dy_02 = a0_y - b0_y;
-    const dx_02 = a0_x - b0_x;
-
-    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
-
-    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
-    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
-
-    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
-        // Collision detected
-
-        const intercept_x = a0_x + (t * s1_x);
-        const intercept_y = a0_y + (t * s1_y);
-
-        result[result_offset] = intercept_x;
-        result[result_offset + 1] = intercept_y;
-
-        return true;
-    }
-
-    return false; // No collision
-}
+import { segment2_segment_intersection_fractions } from "./segment2_segment_intersection_fractions.js";
+
+const scratch_fractions = new Float64Array(2);
+
+/**
+ *
+ * Find intersection point between two line segments if they intersect at all
+ * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
+ * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
+ *
+ * @param {number[]|Float32Array|Float64Array} result resulting intersection point will be stored here if intersection exists
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @return {boolean} True if segments intersect, False otherwise
+ */
+export function segment2_segment_compute_intersection_array_2d(
+    result, result_offset,
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y
+) {
+
+    const overlaps = segment2_segment_intersection_fractions(
+        scratch_fractions, 0,
+        a0_x, a0_y, a1_x, a1_y,
+        b0_x, b0_y, b1_x, b1_y
+    );
+
+    if (overlaps) {
+        // Collision detected -- reconstruct the point from the fraction along segment A
+        const t = scratch_fractions[1];
+
+        result[result_offset] = a0_x + t * (a1_x - a0_x);
+        result[result_offset + 1] = a0_y + t * (a1_y - a0_y);
+
+        return true;
+    }
+
+    return false; // No collision
+}

package/src/core/geom/2d/line/segment2_segment_intersection_fractions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Compute the parametric fractions at which two 2D segments meet, and report whether that meeting point
+ * lies within both segments.
+ *
+ * Writes `[s, t]` into `result`, where the intersection of the two supporting LINES sits at `s` along
+ * segment B and `t` along segment A — so the point itself is `a0 + t * (a1 - a0)`. Both fractions are
+ * written whether or not the segments actually overlap, so a caller that wants the line-line answer can
+ * ignore the return value.
+ *
+ * Shared core of {@link segment2_intersects_segment2_2d} (boolean) and
+ * {@link segment2_segment_compute_intersection_array_2d} (point-returning); those two previously carried
+ * byte-identical copies of this arithmetic.
+ *
+ * PARALLEL SEGMENTS: the denominator is zero, so `s` and `t` come out `±Infinity` or `NaN` and the range
+ * test is false. Exactly-collinear overlapping segments are therefore reported as non-intersecting — the
+ * historical behaviour of both callers, preserved here deliberately.
+ *
+ * @param {number[]|Float32Array|Float64Array} result destination for `[s, t]`
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} true when the segments genuinely overlap (both fractions inside `[0, 1]`)
+ */
+export function segment2_segment_intersection_fractions(result: number[] | Float32Array | Float64Array, result_offset: number, a0_x: number, a0_y: number, a1_x: number, a1_y: number, b0_x: number, b0_y: number, b1_x: number, b1_y: number): boolean;
+//# sourceMappingURL=segment2_segment_intersection_fractions.d.ts.map

package/src/core/geom/2d/line/segment2_segment_intersection_fractions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment2_segment_intersection_fractions.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_intersection_fractions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gEAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAwBnB"}

package/src/core/geom/2d/line/segment2_segment_intersection_fractions.js

@@ -0,0 +1,52 @@
+/**
+ * Compute the parametric fractions at which two 2D segments meet, and report whether that meeting point
+ * lies within both segments.
+ *
+ * Writes `[s, t]` into `result`, where the intersection of the two supporting LINES sits at `s` along
+ * segment B and `t` along segment A — so the point itself is `a0 + t * (a1 - a0)`. Both fractions are
+ * written whether or not the segments actually overlap, so a caller that wants the line-line answer can
+ * ignore the return value.
+ *
+ * Shared core of {@link segment2_intersects_segment2_2d} (boolean) and
+ * {@link segment2_segment_compute_intersection_array_2d} (point-returning); those two previously carried
+ * byte-identical copies of this arithmetic.
+ *
+ * PARALLEL SEGMENTS: the denominator is zero, so `s` and `t` come out `±Infinity` or `NaN` and the range
+ * test is false. Exactly-collinear overlapping segments are therefore reported as non-intersecting — the
+ * historical behaviour of both callers, preserved here deliberately.
+ *
+ * @param {number[]|Float32Array|Float64Array} result destination for `[s, t]`
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} true when the segments genuinely overlap (both fractions inside `[0, 1]`)
+ */
+export function segment2_segment_intersection_fractions(
+    result, result_offset,
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y
+) {
+    const s1_x = a1_x - a0_x;
+    const s1_y = a1_y - a0_y;
+    const s2_x = b1_x - b0_x;
+    const s2_y = b1_y - b0_y;
+
+    const dy_02 = a0_y - b0_y;
+    const dx_02 = a0_x - b0_x;
+
+    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
+
+    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
+    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
+
+    result[result_offset] = s;
+    result[result_offset + 1] = t;
+
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+}

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.d.ts

@@ -1,4 +1,9 @@
 /**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)`.
+ *
+ * The unfiltered face of {@link qt_match_data_by_circle}; the traversal previously existed twice,
+ * differing only by that query's extra `predicate` conjunct.
+ *
  * @template T
  * @param {Array<QuadTreeDatum<T>>} result
  * @param {number} result_offset
@@ -6,7 +11,7 @@
  * @param {number} x
  * @param {number} y
  * @param {number} radius
- * @returns {number}
+ * @returns {number} number of matches written
  */
 export function qt_collect_by_circle<T>(result: Array<QuadTreeDatum<T>>, result_offset: number, tree: QuadTreeNode<T>, x: number, y: number, radius: number): number;
 //# sourceMappingURL=qt_collect_by_circle.d.ts.map

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qt_collect_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_collect_by_circle.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,gDARW,uBAAuB,iBACvB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAgDlB"}
+{"version":3,"file":"qt_collect_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_collect_by_circle.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,gDARW,uBAAuB,iBACvB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAalB"}

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.js

@@ -1,65 +1,39 @@
-import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
-
-/**
- *
- * @type {QuadTreeNode[]}
- */
-const node_stack = [];
-
-/**
- * @template T
- * @param {Array<QuadTreeDatum<T>>} result
- * @param {number} result_offset
- * @param {QuadTreeNode<T>} tree
- * @param {number} x
- * @param {number} y
- * @param {number} radius
- * @returns {number}
- */
-export function qt_collect_by_circle(
-    result, result_offset,
-    tree,
-    x, y, radius
-) {
-    let result_cursor = result_offset;
-
-    let stack_pointer = 1;
-
-    const r2 = radius * radius;
-
-    node_stack[0] = tree;
-
-    while (stack_pointer-- > 0) {
-
-        const node = node_stack[stack_pointer];
-
-        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
-
-        if (d2 > r2) {
-            // not a match
-            continue;
-        }
-
-        const data = node.data;
-        const data_count = data.length;
-
-        for (let i = 0; i < data_count; i++) {
-            const datum = data[i];
-
-            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
-
-            if (d2_to_datum <= r2) {
-                result[result_cursor++] = datum;
-            }
-        }
-
-        if (node.isSplit()) {
-            node_stack[stack_pointer++] = node.topLeft;
-            node_stack[stack_pointer++] = node.bottomLeft;
-            node_stack[stack_pointer++] = node.topRight;
-            node_stack[stack_pointer++] = node.bottomRight;
-        }
-    }
-
-    return result_cursor - result_offset;
-}
+import { qt_match_data_by_circle } from "./qt_match_data_by_circle.js";
+
+/**
+ * Accept every datum. A real function rather than a null/undefined sentinel, so
+ * {@link qt_match_data_by_circle} has exactly one control-flow path.
+ *
+ * @returns {boolean}
+ */
+function accept_all() {
+    return true;
+}
+
+/**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)`.
+ *
+ * The unfiltered face of {@link qt_match_data_by_circle}; the traversal previously existed twice,
+ * differing only by that query's extra `predicate` conjunct.
+ *
+ * @template T
+ * @param {Array<QuadTreeDatum<T>>} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @returns {number} number of matches written
+ */
+export function qt_collect_by_circle(
+    result, result_offset,
+    tree,
+    x, y, radius
+) {
+    return qt_match_data_by_circle(
+        result, result_offset,
+        tree,
+        x, y, radius,
+        accept_all, undefined
+    );
+}

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.d.ts

@@ -1,14 +1,24 @@
 /**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)` AND satisfy `predicate`.
+ *
+ * Also the implementation behind {@link qt_collect_by_circle}, which is this query with an
+ * accept-everything predicate — the traversal was previously written out twice, differing only by the
+ * `predicate.call(...)` conjunct.
+ *
+ * Children are pruned on PUSH (against the circle's bounding square) as well as tested on POP, matching
+ * {@link qt_collect_by_box}. Testing only on pop still returns the right answer but walks and re-tests
+ * quadrants the circle cannot reach.
+ *
  * @template T
- * @param {QuadTreeDatum<T>[]} result
+ * @param {Array<QuadTreeDatum<T>>} result
  * @param {number} result_offset
  * @param {QuadTreeNode<T>} tree
  * @param {number} x
  * @param {number} y
  * @param {number} radius
- * @param {(data: T) => boolean} [predicate]
- * @param {*} [predicateContext]
- * @returns {number}
+ * @param {function(T):boolean} predicate
+ * @param {*} [predicateContext] `this` for `predicate`
+ * @returns {number} number of matches written
  */
-export function qt_match_data_by_circle<T>(result: QuadTreeDatum<T>[], result_offset: number, tree: QuadTreeNode<T>, x: number, y: number, radius: number, predicate?: (data: T) => boolean, predicateContext?: any): number;
+export function qt_match_data_by_circle<T>(result: Array<QuadTreeDatum<T>>, result_offset: number, tree: QuadTreeNode<T>, x: number, y: number, radius: number, predicate: (arg0: T) => boolean, predicateContext?: any): number;
 //# sourceMappingURL=qt_match_data_by_circle.d.ts.map

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qt_match_data_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_match_data_by_circle.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,mDAVW,kBAAkB,iBAClB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,2BACO,OAAO,2BAElB,MAAM,CAmDlB"}
+{"version":3,"file":"qt_match_data_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_match_data_by_circle.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mDAVW,uBAAuB,iBACvB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,0BACM,OAAO,2BAEjB,MAAM,CAyElB"}