@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/fluid/FluidCascadePlacement.d.ts

@@ -18,63 +18,21 @@ export const FLUID_CASCADE_HYSTERESIS: number;
  * @type {number}
  */
 export const FLUID_CASCADE_NEST_MARGIN: number;
-/**
- * Smallest window side, cells, that nests: a child covers half its parent, so the other half must
- * hold the margin on both sides, rounded out to the corner lattice.
- * @type {number}
- */
-export const FLUID_CASCADE_NEST_RESOLUTION_MIN: number;
-/**
- * What {@link FluidCascadePlacementplace } did.
- */
-export type FluidCascadePlacementResult = number;
-/**
- * What {@link FluidCascadePlacement#place} did.
- * @readonly
- * @enum {number}
- */
-export const FluidCascadePlacementResult: 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 fluid cascades are (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7): the
  * CPU half of `GPUFluidCascadeStack`, on the CPU alone so that placement is pinned without a device.
  *
- * 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 S0's window maths: {@link ClipmapWindowSet} places, `window_scroll_regions` (the stack's) says
- * what a move exposed, and storage wraps, so a window that moves keeps every cell it still holds.
- *
- * **Placement** ({@link place}), on a cascade's own step tick, coarsest first:
- * 1. the hysteretic rule (`ClipmapWindowSet#place`, corners in 4s, moved past 2.1 cells of the anchor);
- * 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
- *    {@link FLUID_CASCADE_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 tick's placements {@link moved} and
- * {@link previous_corner} say what to fill.
- *
- * Nothing here allocates once constructed.
+ * A {@link ClipmapCascadePlacement} with the fluid's rule: corners in {@link FLUID_CASCADE_CORNER_STEP}s,
+ * moved once the anchor is more than 2.1 cells from a window's centre, and every child
+ * {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent, which needs 32 cells an axis. The
+ * stack places a cascade on its own step tick, coarsest first.
  */
-export class FluidCascadePlacement {
+export class FluidCascadePlacement extends ClipmapCascadePlacement {
     /**
      * @param {object} options
      * @param {number} options.cascade_count 1 to 8
-     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least
-     *   {@link FLUID_CASCADE_NEST_RESOLUTION_MIN} when there is more than one cascade
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least 32 when
+     *   there is more than one cascade
      * @param {number} options.cell_size metres, cascade 0's
      */
     constructor({ cascade_count, resolution, cell_size }: {
@@ -82,61 +40,6 @@ export class FluidCascadePlacement {
         resolution: ArrayLike<number>;
         cell_size: 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 on its own step tick: 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 {FluidCascadePlacementResult}
-     */
-    place(cascade: number, x: number, y: number, z: number): FluidCascadePlacementResult;
-    #private;
 }
+import { ClipmapCascadePlacement } from "../../../core/geom/clipmap/ClipmapCascadePlacement.js";
 //# sourceMappingURL=FluidCascadePlacement.d.ts.map

package/src/shade/renderer/fluid/FluidCascadePlacement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidCascadePlacement.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/FluidCascadePlacement.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,gDAFU,MAAM,CAEoC;;;;0CAK1C,MAAM;AAHhB;;;;GAIG;AACH;IACI,uBAAuB;;IAEvB,0DAA0D;;IAE1D,0FAA0F;;GAE3F;AAgBH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAkBI;;;;;;OAMG;IACH;QAL2B,aAAa,EAA7B,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;OA2BhB;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;IA2DD;;;;;;OAMG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAyBhB;IAED;;;;;;;;;OASG;IACH,eANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,2BAA2B,CAwCvC;;CACJ"}
+{"version":3,"file":"FluidCascadePlacement.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/FluidCascadePlacement.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;GAQG;AACH;IACI;;;;;;OAMG;IACH;QAL2B,aAAa,EAA7B,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;OAahB;CACJ;wCAtDuC,uDAAuD"}

package/src/shade/renderer/fluid/FluidCascadePlacement.js

@@ -1,6 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { ClipmapWindowSet } from "../../../core/geom/clipmap/ClipmapWindowSet.js";
-import { isPowerOfTwo } from "../../../core/math/isPowerOfTwo.js";
+import { ClipmapCascadePlacement } from "../../../core/geom/clipmap/ClipmapCascadePlacement.js";
 
 /**
  * Cells a cascade's corner moves in: even for exact restriction, in 4s for the 4-cell bricks of
@@ -25,325 +24,33 @@ export const FLUID_CASCADE_HYSTERESIS = 0.1;
  */
 export const FLUID_CASCADE_NEST_MARGIN = 5;
 
-/**
- * Smallest window side, cells, that nests: a child covers half its parent, so the other half must
- * hold the margin on both sides, rounded out to the corner lattice.
- * @type {number}
- */
-export const FLUID_CASCADE_NEST_RESOLUTION_MIN = 32;
-
-/**
- * What {@link FluidCascadePlacement#place} did.
- * @readonly
- * @enum {number}
- */
-export const FluidCascadePlacementResult = 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;
-}
-
 /**
  * Where the windows of a stack of fluid cascades are (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7): the
  * CPU half of `GPUFluidCascadeStack`, on the CPU alone so that placement is pinned without a device.
  *
- * 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 S0's window maths: {@link ClipmapWindowSet} places, `window_scroll_regions` (the stack's) says
- * what a move exposed, and storage wraps, so a window that moves keeps every cell it still holds.
- *
- * **Placement** ({@link place}), on a cascade's own step tick, coarsest first:
- * 1. the hysteretic rule (`ClipmapWindowSet#place`, corners in 4s, moved past 2.1 cells of the anchor);
- * 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
- *    {@link FLUID_CASCADE_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 tick's placements {@link moved} and
- * {@link previous_corner} say what to fill.
- *
- * Nothing here allocates once constructed.
+ * A {@link ClipmapCascadePlacement} with the fluid's rule: corners in {@link FLUID_CASCADE_CORNER_STEP}s,
+ * moved once the anchor is more than 2.1 cells from a window's centre, and every child
+ * {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent, which needs 32 cells an axis. The
+ * stack places a cascade on its own step tick, coarsest first.
  */
-export class FluidCascadePlacement {
-    /** @type {ClipmapWindowSet} */
-    #windows;
-
-    /** @type {Int32Array} */
-    #resolution = new Int32Array(3);
-
-    /** @type {number} */
-    #cell_size;
-
-    /** @type {number} */
-    #cascade_count;
-
-    /** Every cascade's corner at {@link begin}, x, y, z a cascade. @type {Int32Array} */
-    #previous;
-
-    #placed = false;
-
+export class FluidCascadePlacement extends ClipmapCascadePlacement {
     /**
      * @param {object} options
      * @param {number} options.cascade_count 1 to 8
-     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least
-     *   {@link FLUID_CASCADE_NEST_RESOLUTION_MIN} when there is more than one cascade
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least 32 when
+     *   there is more than one cascade
      * @param {number} options.cell_size metres, cascade 0's
      */
     constructor({ cascade_count, resolution, cell_size }) {
-        assert.isPositiveInteger(cascade_count, 'cascade_count');
         assert.lessThanOrEqual(cascade_count, 8, 'cascade_count');
-        assert.isFinite(cell_size, 'cell_size');
-        assert.greaterThan(cell_size, 0, 'cell_size');
-
-        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.ok(cascade_count === 1 || resolution[axis] >= FLUID_CASCADE_NEST_RESOLUTION_MIN, `cascades nest from ${FLUID_CASCADE_NEST_RESOLUTION_MIN} cells an axis`);
 
-            this.#resolution[axis] = resolution[axis];
-        }
-
-        this.#cascade_count = cascade_count;
-        this.#cell_size = cell_size;
-        this.#previous = new Int32Array(3 * cascade_count);
-
-        this.#windows = new ClipmapWindowSet({
-            level_count: cascade_count,
-            dimensions: 3,
-            size: this.#resolution,
+        super({
+            cascade_count,
+            resolution,
+            cell_size,
             step: FLUID_CASCADE_CORNER_STEP,
             hysteresis: FLUID_CASCADE_HYSTERESIS,
+            nest_margin: FLUID_CASCADE_NEST_MARGIN,
         });
     }
-
-    /** @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 range of corners on one axis that keeps a child of corner `child` nested `margin` cells
-     * (its own) inside a parent of corner `parent`, both in the child's cells: `[lo, hi]`, on the
-     * corner lattice.
-     */
-    #nest_low(parent_in_child_cells, margin) {
-        return ceil_to(parent_in_child_cells + margin, FLUID_CASCADE_CORNER_STEP);
-    }
-
-    #nest_high(parent_in_child_cells, n, margin) {
-        return floor_to(parent_in_child_cells + 2 * n - n - margin, FLUID_CASCADE_CORNER_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 = 2 * FLUID_CASCADE_NEST_MARGIN;
-
-        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, FLUID_CASCADE_CORNER_STEP);
-                const hi = floor_to((child - margin) / 2, FLUID_CASCADE_CORNER_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 = 2 * FLUID_CASCADE_NEST_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 on its own step tick: 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 {FluidCascadePlacementResult}
-     */
-    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 FluidCascadePlacementResult.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 FluidCascadePlacementResult.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 ? FluidCascadePlacementResult.Moved : FluidCascadePlacementResult.Held;
-    }
 }

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#266@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#277@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#266@#execute_fill"(record: object, _resources: any, context: {
+    static "__#277@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#266@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#277@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#268@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#279@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#269@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#280@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#269@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#280@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#269@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#269@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#269@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#269@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#280@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_forcing_command.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AAqC7C;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;8BA7D2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_forcing_command.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AA+B7C;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;8BAvD2B,+BAA+B"}

package/src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.js

@@ -1,5 +1,5 @@
 import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
-import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import { chunk_folded_dispatch } from "../../gpu_primitive/indirect/chunk_folded_dispatch.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -22,22 +22,14 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-// the width chunk_folded_workgroup_index strides by
-const LIMIT = ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
-
-fn divide_round_up(value: u32, divisor: u32) -> u32 {
-    return (value + divisor - 1u) / divisor;
-}
-
 // a workgroup a listed brick, folded: x to the limit, then rows of x, then slices of x·y
 fn fluid_forcing_write_command(slot: u32, groups: u32) {
-    let rows = divide_round_up(groups, LIMIT);
-    let slices = divide_round_up(rows, LIMIT);
+    let folded = folded_dispatch(groups);
     let word = slot * ${FLUID_FORCING_COMMAND_WORDS}u;
 
-    commands[word] = min(groups, LIMIT);
-    commands[word + 1u] = min(max(rows, 1u), LIMIT);
-    commands[word + 2u] = max(slices, 1u);
+    commands[word] = folded.x;
+    commands[word + 1u] = folded.y;
+    commands[word + 2u] = folded.z;
 }
 
 @compute @workgroup_size(1, 1, 1)
@@ -45,7 +37,9 @@ fn main() {
     fluid_forcing_write_command(0u, list_0.count);
     fluid_forcing_write_command(1u, list_1.count);
 }
-`);
+`, [
+    chunk_folded_dispatch,
+]);
 
 /**
  * Q2 of a tick (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): the forcing's indirect commands, one

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#265@#execute"(data: {
+    static "__#276@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#270@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#281@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/geometry/BoxGeometry.d.ts

@@ -11,6 +11,5 @@ export class BoxGeometry extends MeshletGeometry {
      */
     constructor(width?: number, height?: number, depth?: number);
 }
-export { PlaneGeometry } from "./PlaneGeometry.js";
 import { MeshletGeometry } from "./MeshletGeometry.js";
 //# sourceMappingURL=BoxGeometry.d.ts.map

package/src/shade/renderer/geometry/BoxGeometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BoxGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/BoxGeometry.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IACI;;;;OAIG;IACH,oBAJW,MAAM,WACN,MAAM,UACN,MAAM,EAKhB;CACJ;;gCAlB+B,sBAAsB"}
+{"version":3,"file":"BoxGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/BoxGeometry.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IACI;;;;OAIG;IACH,oBAJW,MAAM,WACN,MAAM,UACN,MAAM,EAKhB;CACJ;gCAlB+B,sBAAsB"}

package/src/shade/renderer/geometry/BoxGeometry.js

@@ -18,12 +18,3 @@ export class BoxGeometry extends MeshletGeometry {
         meshlet_geometry_build_from_geometry(make_box_geometry(width, height, depth), this);
     }
 }
-
-export {
-    // The tag goes on the specifier, inside the braces: on the statement, TypeScript never sees it.
-    /**
-     * @deprecated `PlaneGeometry` moved to its own module, one class per file like every other
-     * primitive. Import {@link PlaneGeometry} from "./PlaneGeometry.js" instead.
-     */
-    PlaneGeometry
-} from "./PlaneGeometry.js";