@woosh/meep-engine 3.57.0 → 3.58.0

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_vertex_adjacent_faces.d.ts

@@ -6,7 +6,7 @@
  * @param {BinaryTopology} mesh
  * @param {number} face_id
  * @returns {number} number of faces written to output
- * @see bt_face_get_neighbour_faces
+ * @see bt_face_get_edge_adjacent_faces
  */
 export function bt_face_get_vertex_adjacent_faces(output: number[] | Uint32Array, output_offset: number, mesh: BinaryTopology, face_id: number): number;
 //# sourceMappingURL=bt_face_get_vertex_adjacent_faces.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_vertex_adjacent_faces.js

@@ -9,7 +9,7 @@ import { NULL_POINTER } from "../BinaryTopology.js";
  * @param {BinaryTopology} mesh
  * @param {number} face_id
  * @returns {number} number of faces written to output
- * @see bt_face_get_neighbour_faces
+ * @see bt_face_get_edge_adjacent_faces
  */
 export function bt_face_get_vertex_adjacent_faces(
     output,

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_build_face_bvh.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,6EAkEC"}
+{"version":3,"file":"bt_mesh_build_face_bvh.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,6EAiEC"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js

@@ -24,8 +24,7 @@ export function bt_mesh_build_face_bvh(bvh, mesh) {
          * The face pool can have holes: `bt_face_kill` leaves the slot unallocated with its loop
          * pointer at NULL_POINTER, and reading a loop at that address is off the end of the
          * DataView. The navmesh pipeline compacts only inside three conditional branches, so "the
-         * caller hands us a packed mesh" was a precondition no caller could honour. The sibling
-         * builder, `bt_mesh_build_surface_triangle_bvh`, skips them the same way.
+         * caller hands us a packed mesh" was a precondition no caller could honour.
          */
         if (!mesh.faces.is_allocated(face_id)) {
             continue;

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.d.ts

@@ -18,12 +18,4 @@ export const SURFACE_PARITY_RAY_DIRECTIONS: number[];
  * @type {number}
  */
 export const SURFACE_PARITY_RAY_COUNT: number;
-/**
- * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
- * id. The BVH is cleared first, so it may be reused across calls.
- *
- * @deprecated Use {@link bt_mesh_build_face_bvh} instead
- * @type {(bvh: import("../../../../../../bvh2/bvh3/BVH.js").BVH, mesh: import("../BinaryTopology.js").BinaryTopology) => void}
- */
-export const bt_mesh_build_surface_triangle_bvh: (bvh: import("../../../../../../bvh2/bvh3/BVH.js").BVH, mesh: import("../BinaryTopology.js").BinaryTopology) => void;
 //# sourceMappingURL=bt_mesh_surface_ray_parity.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_surface_ray_parity.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,4CAFU,MAAM,EAAE,CAMhB;AAEF;;;GAGG;AACH,uCAFU,MAAM,CAEiE;AAEjF;;;;;;GAMG;AACH,iDAFU,CAAC,GAAG,EAAE,OAAO,oCAAoC,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,sBAAsB,EAAE,cAAc,KAAK,IAAI,CAErD"}
+{"version":3,"file":"bt_mesh_surface_ray_parity.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,4CAFU,MAAM,EAAE,CAMhB;AAEF;;;GAGG;AACH,uCAFU,MAAM,CAEiE"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js

@@ -1,36 +1,25 @@
-import { bt_mesh_build_face_bvh } from "./bt_mesh_build_face_bvh.js";
-
-/**
- * Three irrational, mutually unrelated ray directions for the parity-raycast majority vote used by
- * point-in-closed-surface tests.
- *
- * A single ray is fragile at grazing edges and vertices, where a hit can be counted twice or not at all;
- * three independent directions settle the vote correctly except in vanishingly improbable configurations.
- *
- * Each row is roughly unit length so the AABB-vs-ray slab test in the BVH query does not degenerate.
- * Hand-picked rather than randomised so the classification is fully deterministic — which is why these
- * digits must not be "tidied": two callers previously carried them digit-for-digit and any edit to one
- * copy would silently have given the two classifiers different tie-breaking on the same mesh.
- *
- * @type {number[]}
- */
-export const SURFACE_PARITY_RAY_DIRECTIONS = [
-    0.97123, 0.18927, 0.14431,
-    0.34219, 0.91283, -0.22971,
-    -0.51237, 0.27894, 0.81235,
-];
-
-/**
- * Number of rays in {@link SURFACE_PARITY_RAY_DIRECTIONS}.
- * @type {number}
- */
-export const SURFACE_PARITY_RAY_COUNT = SURFACE_PARITY_RAY_DIRECTIONS.length / 3;
-
-/**
- * Build a BVH whose leaves are the mesh's triangular faces, each leaf's `user_data` being the source face
- * id. The BVH is cleared first, so it may be reused across calls.
- *
- * @deprecated Use {@link bt_mesh_build_face_bvh} instead
- * @type {(bvh: import("../../../../../../bvh2/bvh3/BVH.js").BVH, mesh: import("../BinaryTopology.js").BinaryTopology) => void}
- */
-export const bt_mesh_build_surface_triangle_bvh = bt_mesh_build_face_bvh;
+/**
+ * Three irrational, mutually unrelated ray directions for the parity-raycast majority vote used by
+ * point-in-closed-surface tests.
+ *
+ * A single ray is fragile at grazing edges and vertices, where a hit can be counted twice or not at all;
+ * three independent directions settle the vote correctly except in vanishingly improbable configurations.
+ *
+ * Each row is roughly unit length so the AABB-vs-ray slab test in the BVH query does not degenerate.
+ * Hand-picked rather than randomised so the classification is fully deterministic — which is why these
+ * digits must not be "tidied": two callers previously carried them digit-for-digit and any edit to one
+ * copy would silently have given the two classifiers different tie-breaking on the same mesh.
+ *
+ * @type {number[]}
+ */
+export const SURFACE_PARITY_RAY_DIRECTIONS = [
+    0.97123, 0.18927, 0.14431,
+    0.34219, 0.91283, -0.22971,
+    -0.51237, 0.27894, 0.81235,
+];
+
+/**
+ * Number of rays in {@link SURFACE_PARITY_RAY_DIRECTIONS}.
+ * @type {number}
+ */
+export const SURFACE_PARITY_RAY_COUNT = SURFACE_PARITY_RAY_DIRECTIONS.length / 3;

package/src/core/geom/clipmap/ClipmapCascadePlacement.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The smallest window side, cells, at which a child nests `margin` parent cells inside its parent with
+ * corners in multiples of `step`: a child covers half its parent, so the other half must hold the
+ * margin on both sides, rounded out to the corner lattice.
+ *
+ * @param {number} step
+ * @param {number} margin parent cells
+ * @returns {number}
+ */
+export function clipmap_cascade_nest_resolution_min(step: number, margin: number): number;
+/**
+ * What {@link ClipmapCascadePlacementplace } did.
+ */
+export type ClipmapCascadePlacementResult = number;
+/**
+ * What {@link ClipmapCascadePlacement#place} did.
+ * @readonly
+ * @enum {number}
+ */
+export const ClipmapCascadePlacementResult: Readonly<{
+    /** The window held. */
+    Held: 0;
+    /** The window moved, and the rest of the stack stayed. */
+    Moved: 1;
+    /** The move would have left a child outside its parent: the whole stack was re-placed. */
+    Jumped: 2;
+}>;
+/**
+ * Where the windows of a stack of nested cascades are, around one anchor: the CPU half of a clipmap
+ * whose levels must each stay inside the next, so that what leaves a cascade is inside its parent.
+ * Written for the fluid's cascades (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7) and shared by the
+ * probe clipmap's brick and probe cascades (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.1, §8.1); each
+ * passes its own step, hysteresis and margin.
+ *
+ * Cascade `c` has cells of `cell_size·2^c` and the same resolution N; its window is
+ * `[corner, corner + N)` in its own cells, and world cell `g` of it covers `[g·h_c, (g + 1)·h_c)`, so
+ * the lattices nest: child cells `2G` and `2G + 1` lie in parent cell `G`. Every corner change goes
+ * through the window maths: {@link ClipmapWindowSet} places, `window_scroll_regions` says what a move
+ * exposed, and storage wraps, so a window that moves keeps every cell it still holds.
+ *
+ * **Placement** ({@link place}), coarsest first:
+ * 1. the hysteretic rule (`ClipmapWindowSet#place`: corners in multiples of `step`, moved once the
+ *    anchor is more than `step / 2 + hysteresis` cells from the window's centre);
+ * 2. a jump check: if that leaves the cascade's window not inside its parent's, or its child's window
+ *    not inside its own, the move is a jump and the **whole stack is re-placed** ({@link place_all});
+ * 3. the nesting clamp (`ClipmapWindowSet#clamp_corner`): the corner is held so that its window keeps
+ *    `nest_margin` parent cells inside its parent's, and so that its child's window keeps the margin
+ *    inside its own. Both ranges hold the corner it had, so both clamps together land in both.
+ *
+ * {@link place_all} places every cascade, coarsest first, by the hysteretic rule, and clamps each into
+ * its parent: the first placement, and the answer to a jump.
+ *
+ * {@link begin} remembers every corner, so that after a frame's placements {@link moved} and
+ * {@link previous_corner} say what to fill.
+ *
+ * Nothing here allocates once constructed.
+ */
+export class ClipmapCascadePlacement {
+    /**
+     * @param {object} options
+     * @param {number} options.cascade_count
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two and multiples of
+     *   `step`; at least {@link clipmap_cascade_nest_resolution_min} when there is more than one
+     *   cascade
+     * @param {number} options.cell_size metres, cascade 0's
+     * @param {number} options.step cells a corner moves in
+     * @param {number} options.hysteresis cells past half a step the anchor goes from a window's centre
+     *   before it moves
+     * @param {number} options.nest_margin parent cells a child's window keeps from every face of its
+     *   parent's
+     */
+    constructor({ cascade_count, resolution, cell_size, step, hysteresis, nest_margin }: {
+        cascade_count: number;
+        resolution: ArrayLike<number>;
+        cell_size: number;
+        step: number;
+        hysteresis: number;
+        nest_margin: number;
+    });
+    /** @returns {number} */
+    get cascade_count(): number;
+    /** @returns {Readonly<Int32Array>} */
+    get resolution(): Readonly<Int32Array>;
+    /**
+     * Whether the stack has been placed.
+     * @returns {boolean}
+     */
+    get placed(): boolean;
+    /**
+     * A cascade's cell, metres: `cell_size·2^c`.
+     * @param {number} cascade
+     * @returns {number}
+     */
+    cell_size(cascade: number): number;
+    /**
+     * @param {number} cascade
+     * @param {number} axis
+     * @returns {number} the cascade's corner on the axis, in its own cells
+     */
+    corner(cascade: number, axis: number): number;
+    /**
+     * @param {number} cascade
+     * @param {number} axis
+     * @returns {number} the corner it had at the last {@link begin}
+     */
+    previous_corner(cascade: number, axis: number): number;
+    /**
+     * @param {number} cascade
+     * @returns {boolean} whether its corner moved since the last {@link begin}
+     */
+    moved(cascade: number): boolean;
+    /**
+     * Remember every corner: what {@link moved} and {@link previous_corner} compare with.
+     */
+    begin(): void;
+    /**
+     * Place every cascade, coarsest first, by the hysteretic rule, each child clamped into its parent.
+     *
+     * @param {number} x the anchor, world metres
+     * @param {number} y
+     * @param {number} z
+     */
+    place_all(x: number, y: number, z: number): void;
+    /**
+     * Place one cascade: the hysteretic rule, then the jump check, then the nesting clamp. Before the
+     * first {@link place_all} this places the whole stack.
+     *
+     * @param {number} cascade
+     * @param {number} x the anchor, world metres
+     * @param {number} y
+     * @param {number} z
+     * @returns {ClipmapCascadePlacementResult}
+     */
+    place(cascade: number, x: number, y: number, z: number): ClipmapCascadePlacementResult;
+    #private;
+}
+//# sourceMappingURL=ClipmapCascadePlacement.d.ts.map

package/src/core/geom/clipmap/ClipmapCascadePlacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClipmapCascadePlacement.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/clipmap/ClipmapCascadePlacement.js"],"names":[],"mappings":"AAgCA;;;;;;;;GAQG;AACH,0DAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAMlB;;;;4CAtCS,MAAM;AAHhB;;;;GAIG;AACH;IACI,uBAAuB;;IAEvB,0DAA0D;;IAE1D,0FAA0F;;GAE3F;AA+BH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAiBI;;;;;;;;;;;;OAYG;IACH;QAX2B,aAAa,EAA7B,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QAGD,SAAS,EAAzB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,UAAU,EAA1B,MAAM;QAEU,WAAW,EAA3B,MAAM;OAkChB;IAED,wBAAwB;IACxB,4BAEC;IAED,sCAAsC;IACtC,uCAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;OAEG;IACH,cAMC;IA8DD;;;;;;OAMG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAyBhB;IAED;;;;;;;;;OASG;IACH,eANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,6BAA6B,CAwCzC;;CACJ"}

package/src/core/geom/clipmap/ClipmapCascadePlacement.js

@@ -0,0 +1,350 @@
+import { assert } from "../../assert.js";
+import { isPowerOfTwo } from "../../math/isPowerOfTwo.js";
+import { ClipmapWindowSet } from "./ClipmapWindowSet.js";
+
+/**
+ * What {@link ClipmapCascadePlacement#place} did.
+ * @readonly
+ * @enum {number}
+ */
+export const ClipmapCascadePlacementResult = Object.freeze({
+    /** The window held. */
+    Held: 0,
+    /** The window moved, and the rest of the stack stayed. */
+    Moved: 1,
+    /** The move would have left a child outside its parent: the whole stack was re-placed. */
+    Jumped: 2,
+});
+
+/**
+ * Round down to a multiple of `step`.
+ */
+function floor_to(value, step) {
+    return Math.floor(value / step) * step;
+}
+
+/**
+ * Round up to a multiple of `step`.
+ */
+function ceil_to(value, step) {
+    return Math.ceil(value / step) * step;
+}
+
+/**
+ * The smallest window side, cells, at which a child nests `margin` parent cells inside its parent with
+ * corners in multiples of `step`: a child covers half its parent, so the other half must hold the
+ * margin on both sides, rounded out to the corner lattice.
+ *
+ * @param {number} step
+ * @param {number} margin parent cells
+ * @returns {number}
+ */
+export function clipmap_cascade_nest_resolution_min(step, margin) {
+    const child_margin = 2 * margin;
+
+    return child_margin + ceil_to(child_margin, step);
+}
+
+/**
+ * Where the windows of a stack of nested cascades are, around one anchor: the CPU half of a clipmap
+ * whose levels must each stay inside the next, so that what leaves a cascade is inside its parent.
+ * Written for the fluid's cascades (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7) and shared by the
+ * probe clipmap's brick and probe cascades (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.1, §8.1); each
+ * passes its own step, hysteresis and margin.
+ *
+ * Cascade `c` has cells of `cell_size·2^c` and the same resolution N; its window is
+ * `[corner, corner + N)` in its own cells, and world cell `g` of it covers `[g·h_c, (g + 1)·h_c)`, so
+ * the lattices nest: child cells `2G` and `2G + 1` lie in parent cell `G`. Every corner change goes
+ * through the window maths: {@link ClipmapWindowSet} places, `window_scroll_regions` says what a move
+ * exposed, and storage wraps, so a window that moves keeps every cell it still holds.
+ *
+ * **Placement** ({@link place}), coarsest first:
+ * 1. the hysteretic rule (`ClipmapWindowSet#place`: corners in multiples of `step`, moved once the
+ *    anchor is more than `step / 2 + hysteresis` cells from the window's centre);
+ * 2. a jump check: if that leaves the cascade's window not inside its parent's, or its child's window
+ *    not inside its own, the move is a jump and the **whole stack is re-placed** ({@link place_all});
+ * 3. the nesting clamp (`ClipmapWindowSet#clamp_corner`): the corner is held so that its window keeps
+ *    `nest_margin` parent cells inside its parent's, and so that its child's window keeps the margin
+ *    inside its own. Both ranges hold the corner it had, so both clamps together land in both.
+ *
+ * {@link place_all} places every cascade, coarsest first, by the hysteretic rule, and clamps each into
+ * its parent: the first placement, and the answer to a jump.
+ *
+ * {@link begin} remembers every corner, so that after a frame's placements {@link moved} and
+ * {@link previous_corner} say what to fill.
+ *
+ * Nothing here allocates once constructed.
+ */
+export class ClipmapCascadePlacement {
+    /** @type {ClipmapWindowSet} */
+    #windows;
+    /** @type {Int32Array} */
+    #resolution = new Int32Array(3);
+    /** @type {number} */
+    #cell_size;
+    /** @type {number} */
+    #cascade_count;
+    /** @type {number} */
+    #step;
+    /** Child cells a child's window keeps from every face of its parent's: twice the parent cells. @type {number} */
+    #child_margin;
+    /** Every cascade's corner at {@link begin}, x, y, z a cascade. @type {Int32Array} */
+    #previous;
+    #placed = false;
+
+    /**
+     * @param {object} options
+     * @param {number} options.cascade_count
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two and multiples of
+     *   `step`; at least {@link clipmap_cascade_nest_resolution_min} when there is more than one
+     *   cascade
+     * @param {number} options.cell_size metres, cascade 0's
+     * @param {number} options.step cells a corner moves in
+     * @param {number} options.hysteresis cells past half a step the anchor goes from a window's centre
+     *   before it moves
+     * @param {number} options.nest_margin parent cells a child's window keeps from every face of its
+     *   parent's
+     */
+    constructor({ cascade_count, resolution, cell_size, step, hysteresis, nest_margin }) {
+        assert.isPositiveInteger(cascade_count, 'cascade_count');
+        assert.isFinite(cell_size, 'cell_size');
+        assert.greaterThan(cell_size, 0, 'cell_size');
+        assert.isPositiveInteger(step, 'step');
+        assert.isNonNegativeInteger(nest_margin, 'nest_margin');
+
+        const nest_min = clipmap_cascade_nest_resolution_min(step, nest_margin);
+
+        for (let axis = 0; axis < 3; axis++) {
+            assert.isPositiveInteger(resolution[axis], 'resolution');
+            assert.ok(isPowerOfTwo(resolution[axis]), 'resolution is a power of two on each axis');
+            assert.equal(resolution[axis] % step, 0, 'resolution is a multiple of the step on each axis');
+            assert.ok(cascade_count === 1 || resolution[axis] >= nest_min, `cascades nest from ${nest_min} cells an axis`);
+
+            this.#resolution[axis] = resolution[axis];
+        }
+
+        this.#cascade_count = cascade_count;
+        this.#cell_size = cell_size;
+        this.#step = step;
+        this.#child_margin = 2 * nest_margin;
+        this.#previous = new Int32Array(3 * cascade_count);
+
+        this.#windows = new ClipmapWindowSet({
+            level_count: cascade_count,
+            dimensions: 3,
+            size: this.#resolution,
+            step,
+            hysteresis,
+        });
+    }
+
+    /** @returns {number} */
+    get cascade_count() {
+        return this.#cascade_count;
+    }
+
+    /** @returns {Readonly<Int32Array>} */
+    get resolution() {
+        return this.#resolution;
+    }
+
+    /**
+     * Whether the stack has been placed.
+     * @returns {boolean}
+     */
+    get placed() {
+        return this.#placed;
+    }
+
+    /**
+     * A cascade's cell, metres: `cell_size·2^c`.
+     * @param {number} cascade
+     * @returns {number}
+     */
+    cell_size(cascade) {
+        return this.#cell_size * 2 ** cascade;
+    }
+
+    /**
+     * @param {number} cascade
+     * @param {number} axis
+     * @returns {number} the cascade's corner on the axis, in its own cells
+     */
+    corner(cascade, axis) {
+        return this.#windows.corner(cascade, axis);
+    }
+
+    /**
+     * @param {number} cascade
+     * @param {number} axis
+     * @returns {number} the corner it had at the last {@link begin}
+     */
+    previous_corner(cascade, axis) {
+        return this.#previous[3 * cascade + axis];
+    }
+
+    /**
+     * @param {number} cascade
+     * @returns {boolean} whether its corner moved since the last {@link begin}
+     */
+    moved(cascade) {
+        const base = 3 * cascade;
+
+        return this.#previous[base] !== this.corner(cascade, 0)
+            || this.#previous[base + 1] !== this.corner(cascade, 1)
+            || this.#previous[base + 2] !== this.corner(cascade, 2);
+    }
+
+    /**
+     * Remember every corner: what {@link moved} and {@link previous_corner} compare with.
+     */
+    begin() {
+        for (let c = 0; c < this.#cascade_count; c++) {
+            for (let axis = 0; axis < 3; axis++) {
+                this.#previous[3 * c + axis] = this.#placed ? this.corner(c, axis) : 0;
+            }
+        }
+    }
+
+    /**
+     * The lowest corner on one axis that keeps a child `margin` of its own cells inside a parent
+     * whose corner is `parent_in_child_cells`, on the corner lattice.
+     */
+    #nest_low(parent_in_child_cells, margin) {
+        return ceil_to(parent_in_child_cells + margin, this.#step);
+    }
+
+    /**
+     * The highest such corner, for a window of `n` cells.
+     */
+    #nest_high(parent_in_child_cells, n, margin) {
+        return floor_to(parent_in_child_cells + 2 * n - n - margin, this.#step);
+    }
+
+    /**
+     * Whether cascade `child`'s window lies inside cascade `child + 1`'s, margin or not.
+     */
+    #inside_parent(child) {
+        for (let axis = 0; axis < 3; axis++) {
+            const p = 2 * this.corner(child + 1, axis);
+            const c = this.corner(child, axis);
+            const n = this.#resolution[axis];
+
+            if (c < p || c + n > p + 2 * n) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Hold cascade `c` nested inside its parent, and its child nested inside it.
+     */
+    #clamp(c) {
+        const windows = this.#windows;
+        const margin = this.#child_margin;
+        const step = this.#step;
+
+        for (let axis = 0; axis < 3; axis++) {
+            const n = this.#resolution[axis];
+
+            if (c + 1 < this.#cascade_count) {
+                const p = 2 * this.corner(c + 1, axis);
+
+                windows.clamp_corner(c, axis, this.#nest_low(p, margin), this.#nest_high(p, n, margin));
+            }
+
+            if (c > 0) {
+                // the child's corner in this cascade's cells, and the range of corners that keep it nested
+                const child = this.corner(c - 1, axis);
+                const lo = ceil_to((child + margin - n) / 2, step);
+                const hi = floor_to((child - margin) / 2, step);
+
+                windows.clamp_corner(c, axis, lo, hi);
+            }
+        }
+    }
+
+    /**
+     * Place every cascade, coarsest first, by the hysteretic rule, each child clamped into its parent.
+     *
+     * @param {number} x the anchor, world metres
+     * @param {number} y
+     * @param {number} z
+     */
+    place_all(x, y, z) {
+        assert.isFinite(x, 'x');
+        assert.isFinite(y, 'y');
+        assert.isFinite(z, 'z');
+
+        const windows = this.#windows;
+        const margin = this.#child_margin;
+
+        for (let c = this.#cascade_count - 1; c >= 0; c--) {
+            const h = this.cell_size(c);
+
+            windows.place(c, x / h, y / h, z / h);
+
+            if (c + 1 < this.#cascade_count) {
+                for (let axis = 0; axis < 3; axis++) {
+                    const p = 2 * this.corner(c + 1, axis);
+
+                    windows.clamp_corner(c, axis, this.#nest_low(p, margin), this.#nest_high(p, this.#resolution[axis], margin));
+                }
+            }
+        }
+
+        this.#placed = true;
+    }
+
+    /**
+     * Place one cascade: the hysteretic rule, then the jump check, then the nesting clamp. Before the
+     * first {@link place_all} this places the whole stack.
+     *
+     * @param {number} cascade
+     * @param {number} x the anchor, world metres
+     * @param {number} y
+     * @param {number} z
+     * @returns {ClipmapCascadePlacementResult}
+     */
+    place(cascade, x, y, z) {
+        assert.isNonNegativeInteger(cascade, 'cascade');
+        assert.lessThan(cascade, this.#cascade_count, 'cascade');
+        assert.isFinite(x, 'x');
+        assert.isFinite(y, 'y');
+        assert.isFinite(z, 'z');
+
+        if (!this.#placed) {
+            this.place_all(x, y, z);
+
+            return ClipmapCascadePlacementResult.Jumped;
+        }
+
+        const windows = this.#windows;
+        const h = this.cell_size(cascade);
+
+        const before_x = this.corner(cascade, 0);
+        const before_y = this.corner(cascade, 1);
+        const before_z = this.corner(cascade, 2);
+
+        windows.place(cascade, x / h, y / h, z / h);
+
+        const leaves_parent = cascade + 1 < this.#cascade_count && !this.#inside_parent(cascade);
+        const leaves_child = cascade > 0 && !this.#inside_parent(cascade - 1);
+
+        if (leaves_parent || leaves_child) {
+            this.place_all(x, y, z);
+
+            return ClipmapCascadePlacementResult.Jumped;
+        }
+
+        this.#clamp(cascade);
+
+        const moved = this.corner(cascade, 0) !== before_x
+            || this.corner(cascade, 1) !== before_y
+            || this.corner(cascade, 2) !== before_z;
+
+        return moved ? ClipmapCascadePlacementResult.Moved : ClipmapCascadePlacementResult.Held;
+    }
+}

package/src/core/geom/polyline/polyline_simplify_by_error.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Douglas-Peucker over the points `[0, count)` of any sequence: keeps the first and the last, and between two kept
+ * points `a` and `b` keeps the point `worst(a, b, out)` names while its error exceeds `tolerance`, splitting there.
+ *
+ * The caller measures the error, so the same simplification serves a polyline in any space, or a sweep of rings.
+ *
+ * @param {Uint8Array} out_keep `count` flags, 1 where a point is kept
+ * @param {number} count
+ * @param {number} tolerance
+ * @param {function(number, number, Float64Array): void} worst writes into `out` the index of the point strictly
+ * between `a` and `b` that lies furthest from the simplified run `a`-`b`, and that point's error; only called when
+ * `b - a > 1`
+ * @returns {number} points kept
+ */
+export function polyline_simplify_by_error(out_keep: Uint8Array, count: number, tolerance: number, worst: (arg0: number, arg1: number, arg2: Float64Array) => void): number;
+//# sourceMappingURL=polyline_simplify_by_error.d.ts.map

package/src/core/geom/polyline/polyline_simplify_by_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyline_simplify_by_error.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/polyline/polyline_simplify_by_error.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,qDARW,UAAU,SACV,MAAM,aACN,MAAM,gBACG,MAAM,QAAE,MAAM,QAAE,YAAY,KAAG,IAAI,GAG1C,MAAM,CAmClB"}