@woosh/meep-engine 3.69.0 → 3.70.0

package/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_mac_advect_correct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js"],"names":[],"mappings":"AAkSA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,8CAFU,aAAa,CAMpB;8BA/U2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_mac_advect_correct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js"],"names":[],"mappings":"AAmSA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,8CAFU,aAAa,CAMpB;8BAhV2B,+BAA+B"}

package/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js

@@ -19,10 +19,11 @@ import {
     chunk_fluid_mac_seam_source
 } from "./chunk_fluid_mac_seams.js";
 import { FLUID_MAC_STEP_STRUCT } from "./FLUID_MAC_STEP_STRUCT.js";
+import { fluid_turbulence_add_resources } from "../../wind/chunk_fluid_turbulence.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
+fluid_turbulence_add_resources(resources.createGroup())
     .addUniform("step", FLUID_MAC_STEP_STRUCT)
     .addUniform("parent", FLUID_CASCADE_PARENT_STRUCT)
     .addTexture("source_u", "unfilterable-float", "3d")

package/src/shade/renderer/fluid/publish/FluidWindPublish.d.ts

@@ -20,7 +20,7 @@ export class FluidWindPublish {
      */
     static enquirePipelines(enquiry: import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry): void;
     /**
-     * Write a cascade's tile from its velocity: the deviation from `far_velocity` at every cell centre
+     * Write a cascade's tile from its velocity: the deviation from `far` at every cell centre
      * and the skirt around them. The tile's content is the cascade's window: `atlas.content_size` is
      * its resolution.
      *
@@ -28,8 +28,10 @@ export class FluidWindPublish {
      * @param {ShadeGPUCommandContext} options.encoder
      * @param {FluidMacVelocityViews} options.velocity the cascade's persistent velocity after its step, toroidal
      * @param {ArrayLike<number>} options.corner the world cell at window-local (0, 0, 0)
-     * @param {ArrayLike<number>} options.far_velocity `v_far(t_s,c)`, m/s: the far field of the cascade's read
-     *   record, what the deviation is from
+     * @param {{mean: ArrayLike<number>, sigma: number, origin: ArrayLike<number>, scale: ArrayLike<number>}} options.far
+     *   `v_far(t_s,c)`, the far field of the cascade's read record over its window's cells
+     *   ({@link FLUID_FAR_FIELD_STRUCT}, `GPUFluidCascade#describe_far`): what the deviation is from
+     * @param {GPUTextureView} options.turbulence the turbulence tile the far field and the parent read
      * @param {object} options.parent what lies beyond the window, as {@link FLUID_CASCADE_PARENT_STRUCT}
      *   lays it out, read as of the cascade's record (`GPUFluidCascade#describe_parent`); the far field
      *   is a parent with no window
@@ -38,11 +40,17 @@ export class FluidWindPublish {
      * @param {GPUTileAtlas3D} options.atlas the wind field's atlas, `rgba16float`, border 1
      * @param {number} options.slot the cascade's live slot in it
      */
-    record({ encoder, velocity, corner, far_velocity, parent, parent_faces, atlas, slot }: {
+    record({ encoder, velocity, corner, far, turbulence, parent, parent_faces, atlas, slot }: {
         encoder: ShadeGPUCommandContext;
         velocity: FluidMacVelocityViews;
         corner: ArrayLike<number>;
-        far_velocity: ArrayLike<number>;
+        far: {
+            mean: ArrayLike<number>;
+            sigma: number;
+            origin: ArrayLike<number>;
+            scale: ArrayLike<number>;
+        };
+        turbulence: GPUTextureView;
         parent: object;
         parent_faces: FluidMacVelocityViews;
         atlas: GPUTileAtlas3D;

package/src/shade/renderer/fluid/publish/FluidWindPublish.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidWindPublish.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/publish/FluidWindPublish.js"],"names":[],"mappings":"AAQA;;;;GAIG;AAEH;;;;;;;GAOG;AACH;IACI;;;;;OAKG;IACH,iCAFW,OAAO,6CAA6C,EAAE,eAAe,QAI/E;IAmCD;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAb2C,OAAO,EAAvC,sBAAsB;QACS,QAAQ,EAAvC,qBAAqB;QACM,MAAM,EAAjC,UAAU,MAAM,CAAC;QACU,YAAY,EAAvC,UAAU,MAAM,CAAC;QAED,MAAM,EAAtB,MAAM;QAGyB,YAAY,EAA3C,qBAAqB;QAEG,KAAK,EAA7B,cAAc;QACE,IAAI,EAApB,MAAM;aA6DhB;;CACJ;qCAxIY,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,0BAA0B,EAAE,qBAAqB;6BACxD,OAAO,uCAAuC,EAAE,cAAc"}
+{"version":3,"file":"FluidWindPublish.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/publish/FluidWindPublish.js"],"names":[],"mappings":"AASA;;;;GAIG;AAEH;;;;;;;GAOG;AACH;IACI;;;;;OAKG;IACH,iCAFW,OAAO,6CAA6C,EAAE,eAAe,QAI/E;IAmCD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAf2C,OAAO,EAAvC,sBAAsB;QACS,QAAQ,EAAvC,qBAAqB;QACM,MAAM,EAAjC,UAAU,MAAM,CAAC;QACsF,GAAG,EAA1G;YAAC,IAAI,EAAE,UAAU,MAAM,CAAC,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,UAAU,MAAM,CAAC,CAAC;YAAC,KAAK,EAAE,UAAU,MAAM,CAAC,CAAA;SAAC;QAGrE,UAAU;QAClB,MAAM,EAAtB,MAAM;QAGyB,YAAY,EAA3C,qBAAqB;QAEG,KAAK,EAA7B,cAAc;QACE,IAAI,EAApB,MAAM;aAoEhB;;CACJ;qCAjJY,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,0BAA0B,EAAE,qBAAqB;6BACxD,OAAO,uCAAuC,EAAE,cAAc"}

package/src/shade/renderer/fluid/publish/FluidWindPublish.js

@@ -5,6 +5,7 @@ import { FLUID_CASCADE_PARENT_STRUCT } from "../coupling/FLUID_CASCADE_PARENT_ST
 import { fluid_cascade_window_place, fluid_cascade_window_value } from "../fluid_cascade_window.js";
 import { FLUID_WIND_PUBLISH_STRUCT } from "./FLUID_WIND_PUBLISH_STRUCT.js";
 import { FLUID_WIND_PUBLISH_GROUP_SIZE, shader_fluid_wind_publish } from "./shader_fluid_wind_publish.js";
+import { FLUID_FAR_FIELD_STRUCT, fluid_far_field_value } from "../FLUID_FAR_FIELD_STRUCT.js";
 
 /**
  * @typedef {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
@@ -37,9 +38,9 @@ export class FluidWindPublish {
         faces_u: fluid_cascade_window_value(),
         faces_v: fluid_cascade_window_value(),
         faces_w: fluid_cascade_window_value(),
-        far_velocity: new Float32Array(3),
+        far: fluid_far_field_value(),
+        far_end: fluid_far_field_value(),
         dt_over_h: 0,
-        far_velocity_end: new Float32Array(3),
         rhs_scale: 0,
         keep: 1,
         deviation_limit: 0,
@@ -57,7 +58,7 @@ export class FluidWindPublish {
         encoder: null,
         bindings: {
             step: null, publish: null, parent: null, source_u: null, source_v: null, source_w: null,
-            parent_u: null, parent_v: null, parent_w: null, tile: null,
+            parent_u: null, parent_v: null, parent_w: null, tile: null, fluid_turbulence: null,
         },
         group_count_x: 1,
         group_count_y: 1,
@@ -65,7 +66,7 @@ export class FluidWindPublish {
     };
 
     /**
-     * Write a cascade's tile from its velocity: the deviation from `far_velocity` at every cell centre
+     * Write a cascade's tile from its velocity: the deviation from `far` at every cell centre
      * and the skirt around them. The tile's content is the cascade's window: `atlas.content_size` is
      * its resolution.
      *
@@ -73,8 +74,10 @@ export class FluidWindPublish {
      * @param {ShadeGPUCommandContext} options.encoder
      * @param {FluidMacVelocityViews} options.velocity the cascade's persistent velocity after its step, toroidal
      * @param {ArrayLike<number>} options.corner the world cell at window-local (0, 0, 0)
-     * @param {ArrayLike<number>} options.far_velocity `v_far(t_s,c)`, m/s: the far field of the cascade's read
-     *   record, what the deviation is from
+     * @param {{mean: ArrayLike<number>, sigma: number, origin: ArrayLike<number>, scale: ArrayLike<number>}} options.far
+     *   `v_far(t_s,c)`, the far field of the cascade's read record over its window's cells
+     *   ({@link FLUID_FAR_FIELD_STRUCT}, `GPUFluidCascade#describe_far`): what the deviation is from
+     * @param {GPUTextureView} options.turbulence the turbulence tile the far field and the parent read
      * @param {object} options.parent what lies beyond the window, as {@link FLUID_CASCADE_PARENT_STRUCT}
      *   lays it out, read as of the cascade's record (`GPUFluidCascade#describe_parent`); the far field
      *   is a parent with no window
@@ -83,11 +86,12 @@ export class FluidWindPublish {
      * @param {GPUTileAtlas3D} options.atlas the wind field's atlas, `rgba16float`, border 1
      * @param {number} options.slot the cascade's live slot in it
      */
-    record({ encoder, velocity, corner, far_velocity, parent, parent_faces, atlas, slot }) {
+    record({ encoder, velocity, corner, far, turbulence, parent, parent_faces, atlas, slot }) {
         assert.defined(encoder, 'encoder');
         assert.defined(velocity, 'velocity');
         assert.defined(parent, 'parent');
         assert.defined(parent_faces, 'parent_faces');
+        assert.defined(turbulence, 'turbulence');
         assert.equal(atlas.format, WIND_FIELD_TILE_FORMAT, 'atlas.format');
         assert.equal(atlas.border, WIND_FIELD_TILE_BORDER, 'atlas.border');
         assert.ok(atlas.is_live(slot), 'slot is a live tile of the atlas');
@@ -97,11 +101,16 @@ export class FluidWindPublish {
 
         for (let axis = 0; axis < 3; axis++) {
             assert.isInteger(corner[axis], 'corner');
-            assert.isFinite(far_velocity[axis], 'far_velocity');
+            assert.isFinite(far.mean[axis], 'far.mean');
 
-            step.far_velocity[axis] = far_velocity[axis];
+            step.far.mean[axis] = far.mean[axis];
+            step.far.origin[axis] = far.origin[axis];
+            step.far.scale[axis] = far.scale[axis];
         }
 
+        step.far.sigma = far.sigma;
+        step.far.lod = far.lod ?? 0;
+
         fluid_cascade_window_place(step.cells, corner, resolution, -1);
         fluid_cascade_window_place(step.faces_u, corner, resolution, 0);
         fluid_cascade_window_place(step.faces_v, corner, resolution, 1);
@@ -127,6 +136,7 @@ export class FluidWindPublish {
         b.parent_v = parent_faces.v;
         b.parent_w = parent_faces.w;
         b.tile = atlas.texture;
+        b.fluid_turbulence = turbulence;
 
         const tile = atlas.tile_size;
 
@@ -140,7 +150,7 @@ export class FluidWindPublish {
         } finally {
             pass.encoder = null;
             b.step = b.publish = b.parent = b.source_u = b.source_v = b.source_w = b.tile = null;
-            b.parent_u = b.parent_v = b.parent_w = null;
+            b.parent_u = b.parent_v = b.parent_w = b.fluid_turbulence = null;
         }
     }
 }

package/src/shade/renderer/fluid/publish/chunk_fluid_wind_publish_cell.d.ts

@@ -1,8 +1,8 @@
 /**
  * What a cascade publishes into the wind field at one cell (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md
  * §11): `fluid_wind_publish_cell(cell, far_velocity)`, the velocity at window-local cell `cell`'s
- * centre — on each axis the mean of the cell's two faces — less the far field the step ran under,
- * `v_far(t_s,c)`, m/s.
+ * centre — on each axis the mean of the cell's two faces — less `far_velocity`, the far field the step
+ * ran under there, `v_far(t_s,c)`, m/s.
  *
  * The deviation, not the velocity, is what a tile holds, and the read adds the far field back
  * through the atmosphere identity (`chunk_wind_field_sample`): `v_far(t) + (v − v_far(t_s,c))·k_c` is

package/src/shade/renderer/fluid/publish/chunk_fluid_wind_publish_cell.js

@@ -3,8 +3,8 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 /**
  * What a cascade publishes into the wind field at one cell (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md
  * §11): `fluid_wind_publish_cell(cell, far_velocity)`, the velocity at window-local cell `cell`'s
- * centre — on each axis the mean of the cell's two faces — less the far field the step ran under,
- * `v_far(t_s,c)`, m/s.
+ * centre — on each axis the mean of the cell's two faces — less `far_velocity`, the far field the step
+ * ran under there, `v_far(t_s,c)`, m/s.
  *
  * The deviation, not the velocity, is what a tile holds, and the read adds the far field back
  * through the atmosphere identity (`chunk_wind_field_sample`): `v_far(t) + (v − v_far(t_s,c))·k_c` is

package/src/shade/renderer/fluid/publish/shader_fluid_wind_publish.d.ts

@@ -25,14 +25,16 @@ export const FLUID_WIND_PUBLISH_GROUP_SIZE: number[];
  * workgroup memory already.
  *
  * Bindings:
- * - `step`: {@link FLUID_MAC_STEP_STRUCT}: the cascade's windows and `far_velocity`, `v_far(t_s,c)`;
- *   `cells.size` is the window, and the tile's content;
+ * - `step`: {@link FLUID_MAC_STEP_STRUCT}: the cascade's windows and `far`, `v_far(t_s,c)` over the
+ *   window's cells; `cells.size` is the window, and the tile's content;
  * - `publish`: {@link FLUID_WIND_PUBLISH_STRUCT}: the tile's texel origin in the atlas;
  * - `parent`: {@link FLUID_CASCADE_PARENT_STRUCT}, and `parent_u`, `parent_v`, `parent_w` the parent's
  *   persistent faces, read for the skirt;
  * - `source_u`, `source_v`, `source_w`: the cascade's persistent velocity after its step, `r32float`
  *   3-D textures, toroidal through `step.faces_*`;
- * - `tile`: written, the atlas, `rgba16float` 3-D storage texture.
+ * - `tile`: written, the atlas, `rgba16float` 3-D storage texture;
+ * - the turbulence tile (`fluid_turbulence_add_resources`), which the far field reads a texel at a time
+ *   with turbulence.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/fluid/publish/shader_fluid_wind_publish.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_wind_publish.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/publish/shader_fluid_wind_publish.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,4CAFU,MAAM,EAAE,CAEoD;AAyFtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wCAFU,aAAa,CAMpB;8BA7I2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_wind_publish.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/publish/shader_fluid_wind_publish.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,4CAFU,MAAM,EAAE,CAEoD;AA0FtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wCAFU,aAAa,CAMpB;8BAlJ2B,+BAA+B"}

package/src/shade/renderer/fluid/publish/shader_fluid_wind_publish.js

@@ -1,142 +1,147 @@
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { WIND_FIELD_TILE_BORDER, WIND_FIELD_TILE_FORMAT } from "../../wind/WIND_FIELD.js";
-import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
-import { chunk_fluid_cascade_parent_velocity } from "../coupling/chunk_fluid_cascade_parent.js";
-import { FLUID_MAC_STEP_STRUCT } from "../mac/FLUID_MAC_STEP_STRUCT.js";
-import { FLUID_CASCADE_PARENT_STRUCT } from "../coupling/FLUID_CASCADE_PARENT_STRUCT.js";
-import { chunk_fluid_wind_publish_cell } from "./chunk_fluid_wind_publish_cell.js";
-import { FLUID_WIND_PUBLISH_STRUCT } from "./FLUID_WIND_PUBLISH_STRUCT.js";
-
-/**
- * Invocations along each axis of a workgroup: one per texel of the tile, whose sides are N + 2.
- * @type {number[]}
- */
-export const FLUID_WIND_PUBLISH_GROUP_SIZE = Object.freeze([4, 4, 4]);
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform("step", FLUID_MAC_STEP_STRUCT)
-    .addUniform("publish", FLUID_WIND_PUBLISH_STRUCT)
-    .addUniform("parent", FLUID_CASCADE_PARENT_STRUCT)
-    .addTexture("source_u", "unfilterable-float", "3d")
-    .addTexture("source_v", "unfilterable-float", "3d")
-    .addTexture("source_w", "unfilterable-float", "3d")
-    .addTexture("parent_u", "unfilterable-float", "3d")
-    .addTexture("parent_v", "unfilterable-float", "3d")
-    .addTexture("parent_w", "unfilterable-float", "3d")
-    .addStorageTexture("tile", WIND_FIELD_TILE_FORMAT, "3d", "write-only");
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const FLUID_WIND_PUBLISH_BORDER: u32 = ${WIND_FIELD_TILE_BORDER}u;
-
-// the step's end velocity, the persistent set, through its toroidal windows; beyond the window, the
-// cascade's boundary: its parent's identity read as of its record, as its seams read it (the skirt is
-// one face deep, so the read itself, not a step's ghosts)
-fn fluid_wind_publish_face_u(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_u.size)) {
-        return textureLoad(source_u, grid_tile_window_storage(face, step.faces_u.corner_storage, step.faces_u.period), 0).r;
-    }
-
-    return fluid_parent_face_u(face, step.cells.corner - parent.origin);
-}
-
-fn fluid_wind_publish_face_v(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_v.size)) {
-        return textureLoad(source_v, grid_tile_window_storage(face, step.faces_v.corner_storage, step.faces_v.period), 0).r;
-    }
-
-    return fluid_parent_face_v(face, step.cells.corner - parent.origin);
-}
-
-fn fluid_wind_publish_face_w(face: vec3<i32>) -> f32 {
-    if (grid_tile_window_contains(face, step.faces_w.size)) {
-        return textureLoad(source_w, grid_tile_window_storage(face, step.faces_w.corner_storage, step.faces_w.period), 0).r;
-    }
-
-    return fluid_parent_face_w(face, step.cells.corner - parent.origin);
-}
-
-@compute @workgroup_size(${FLUID_WIND_PUBLISH_GROUP_SIZE.join(', ')})
-fn main(@builtin(global_invocation_id) id: vec3<u32>) {
-    // the window's cells and a skirt on every side
-    let tile_size = step.cells.size + vec3<u32>(2u * FLUID_WIND_PUBLISH_BORDER);
-
-    if (any(id >= tile_size)) {
-        return;
-    }
-
-    // tile texel t holds window-local cell t - border
-    let cell = vec3<i32>(id) - vec3<i32>(i32(FLUID_WIND_PUBLISH_BORDER));
-    var deviation: vec3<f32>;
-
-    if (grid_tile_window_contains(cell, step.cells.size)) {
-        let su0 = grid_tile_window_storage(cell, step.faces_u.corner_storage, step.faces_u.period);
-        let su1_x = select(su0.x + 1u, 0u, su0.x + 1u == step.faces_u.period.x);
-        let sv0 = grid_tile_window_storage(cell, step.faces_v.corner_storage, step.faces_v.period);
-        let sv1_y = select(sv0.y + 1u, 0u, sv0.y + 1u == step.faces_v.period.y);
-        let sw0 = grid_tile_window_storage(cell, step.faces_w.corner_storage, step.faces_w.period);
-        let sw1_z = select(sw0.z + 1u, 0u, sw0.z + 1u == step.faces_w.period.z);
-
-        let faces = vec3<f32>(
-            textureLoad(source_u, su0, 0).r + textureLoad(source_u, vec3<u32>(su1_x, su0.y, su0.z), 0).r,
-            textureLoad(source_v, sv0, 0).r + textureLoad(source_v, vec3<u32>(sv0.x, sv1_y, sv0.z), 0).r,
-            textureLoad(source_w, sw0, 0).r + textureLoad(source_w, vec3<u32>(sw0.x, sw0.y, sw1_z), 0).r,
-        );
-
-        deviation = 0.5 * faces - step.far_velocity;
-    } else {
-        deviation = fluid_wind_publish_cell(cell, step.far_velocity);
-    }
-
-    textureStore(tile, publish.tile_origin + id, vec4<f32>(deviation, 0.0));
-}
-`, [
-        chunk_grid_tile_window,
-        chunk_fluid_cascade_parent_velocity,
-        chunk_fluid_wind_publish_cell,
-    ]
-);
-
-/**
- * A cascade's publish into the wind field (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §11, the publish
- * half of pass 6): every texel of its atlas tile, the window's cells and the one-texel skirt around
- * them, gets `chunk_fluid_wind_publish_cell` — the velocity at that cell's centre less the step's far
- * field — as `rgba16float`, alpha 0.
- *
- * The skirt is the cells one past the window. Each takes the window's faces where it has them (along
- * an axis, the boundary face plane) and, for the rest, what the MAC seams answer beyond the window:
- * the parent's identity read as of the cascade's read record (`chunk_fluid_cascade_parent_velocity`),
- * which for the coarsest is the far field. Beside the far field, a skirt cell beside a face of the
- * window takes half that boundary face's deviation on the face's axis and none on the others, and one
- * past an edge or a corner none at all.
- *
- * It writes its own tile and never samples the atlas: the atlas is bound as a write-only storage
- * texture and nothing else.
- *
- * One invocation a texel, in 4 × 4 × 4 workgroups over the tile, dispatched
- * `ceil((N + 2) / 4)` on each axis; each reads its cell's six faces (`textureLoad`) and stores one
- * texel. Standalone until it is fused into the gradient pass (proposal §8 (3)), where the faces are in
- * workgroup memory already.
- *
- * Bindings:
- * - `step`: {@link FLUID_MAC_STEP_STRUCT}: the cascade's windows and `far_velocity`, `v_far(t_s,c)`;
- *   `cells.size` is the window, and the tile's content;
- * - `publish`: {@link FLUID_WIND_PUBLISH_STRUCT}: the tile's texel origin in the atlas;
- * - `parent`: {@link FLUID_CASCADE_PARENT_STRUCT}, and `parent_u`, `parent_v`, `parent_w` the parent's
- *   persistent faces, read for the skirt;
- * - `source_u`, `source_v`, `source_w`: the cascade's persistent velocity after its step, `r32float`
- *   3-D textures, toroidal through `step.faces_*`;
- * - `tile`: written, the atlas, `rgba16float` 3-D storage texture.
- *
- * @type {ComputeShader}
- */
-export const shader_fluid_wind_publish = ComputeShader.from({
-    label: "Fluid / wind publish",
-    body,
-    resources,
-});
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WIND_FIELD_TILE_BORDER, WIND_FIELD_TILE_FORMAT } from "../../wind/WIND_FIELD.js";
+import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
+import { chunk_fluid_cascade_parent_velocity } from "../coupling/chunk_fluid_cascade_parent.js";
+import { FLUID_MAC_STEP_STRUCT } from "../mac/FLUID_MAC_STEP_STRUCT.js";
+import { FLUID_CASCADE_PARENT_STRUCT } from "../coupling/FLUID_CASCADE_PARENT_STRUCT.js";
+import { chunk_fluid_wind_publish_cell } from "./chunk_fluid_wind_publish_cell.js";
+import { FLUID_WIND_PUBLISH_STRUCT } from "./FLUID_WIND_PUBLISH_STRUCT.js";
+import { fluid_turbulence_add_resources } from "../../wind/chunk_fluid_turbulence.js";
+import { chunk_fluid_far_field } from "../chunk_fluid_far_field.js";
+
+/**
+ * Invocations along each axis of a workgroup: one per texel of the tile, whose sides are N + 2.
+ * @type {number[]}
+ */
+export const FLUID_WIND_PUBLISH_GROUP_SIZE = Object.freeze([4, 4, 4]);
+
+const resources = new ShaderResourceSetDescriptor();
+
+fluid_turbulence_add_resources(resources.createGroup())
+    .addUniform("step", FLUID_MAC_STEP_STRUCT)
+    .addUniform("publish", FLUID_WIND_PUBLISH_STRUCT)
+    .addUniform("parent", FLUID_CASCADE_PARENT_STRUCT)
+    .addTexture("source_u", "unfilterable-float", "3d")
+    .addTexture("source_v", "unfilterable-float", "3d")
+    .addTexture("source_w", "unfilterable-float", "3d")
+    .addTexture("parent_u", "unfilterable-float", "3d")
+    .addTexture("parent_v", "unfilterable-float", "3d")
+    .addTexture("parent_w", "unfilterable-float", "3d")
+    .addStorageTexture("tile", WIND_FIELD_TILE_FORMAT, "3d", "write-only");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const FLUID_WIND_PUBLISH_BORDER: u32 = ${WIND_FIELD_TILE_BORDER}u;
+
+// the step's end velocity, the persistent set, through its toroidal windows; beyond the window, the
+// cascade's boundary: its parent's identity read as of its record, as its seams read it (the skirt is
+// one face deep, so the read itself, not a step's ghosts)
+fn fluid_wind_publish_face_u(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_u.size)) {
+        return textureLoad(source_u, grid_tile_window_storage(face, step.faces_u.corner_storage, step.faces_u.period), 0).r;
+    }
+
+    return fluid_parent_face_u(face, step.cells.corner - parent.origin);
+}
+
+fn fluid_wind_publish_face_v(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_v.size)) {
+        return textureLoad(source_v, grid_tile_window_storage(face, step.faces_v.corner_storage, step.faces_v.period), 0).r;
+    }
+
+    return fluid_parent_face_v(face, step.cells.corner - parent.origin);
+}
+
+fn fluid_wind_publish_face_w(face: vec3<i32>) -> f32 {
+    if (grid_tile_window_contains(face, step.faces_w.size)) {
+        return textureLoad(source_w, grid_tile_window_storage(face, step.faces_w.corner_storage, step.faces_w.period), 0).r;
+    }
+
+    return fluid_parent_face_w(face, step.cells.corner - parent.origin);
+}
+
+@compute @workgroup_size(${FLUID_WIND_PUBLISH_GROUP_SIZE.join(', ')})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    // the window's cells and a skirt on every side
+    let tile_size = step.cells.size + vec3<u32>(2u * FLUID_WIND_PUBLISH_BORDER);
+
+    if (any(id >= tile_size)) {
+        return;
+    }
+
+    // tile texel t holds window-local cell t - border
+    let cell = vec3<i32>(id) - vec3<i32>(i32(FLUID_WIND_PUBLISH_BORDER));
+    var deviation: vec3<f32>;
+
+    if (grid_tile_window_contains(cell, step.cells.size)) {
+        let su0 = grid_tile_window_storage(cell, step.faces_u.corner_storage, step.faces_u.period);
+        let su1_x = select(su0.x + 1u, 0u, su0.x + 1u == step.faces_u.period.x);
+        let sv0 = grid_tile_window_storage(cell, step.faces_v.corner_storage, step.faces_v.period);
+        let sv1_y = select(sv0.y + 1u, 0u, sv0.y + 1u == step.faces_v.period.y);
+        let sw0 = grid_tile_window_storage(cell, step.faces_w.corner_storage, step.faces_w.period);
+        let sw1_z = select(sw0.z + 1u, 0u, sw0.z + 1u == step.faces_w.period.z);
+
+        let faces = vec3<f32>(
+            textureLoad(source_u, su0, 0).r + textureLoad(source_u, vec3<u32>(su1_x, su0.y, su0.z), 0).r,
+            textureLoad(source_v, sv0, 0).r + textureLoad(source_v, vec3<u32>(sv0.x, sv1_y, sv0.z), 0).r,
+            textureLoad(source_w, sw0, 0).r + textureLoad(source_w, vec3<u32>(sw0.x, sw0.y, sw1_z), 0).r,
+        );
+
+        deviation = 0.5 * faces - fluid_far_field(step.far, vec3<f32>(cell));
+    } else {
+        deviation = fluid_wind_publish_cell(cell, fluid_far_field(step.far, vec3<f32>(cell)));
+    }
+
+    textureStore(tile, publish.tile_origin + id, vec4<f32>(deviation, 0.0));
+}
+`, [
+        chunk_grid_tile_window,
+        chunk_fluid_cascade_parent_velocity,
+        chunk_fluid_wind_publish_cell,
+        chunk_fluid_far_field,
+    ]
+);
+
+/**
+ * A cascade's publish into the wind field (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §11, the publish
+ * half of pass 6): every texel of its atlas tile, the window's cells and the one-texel skirt around
+ * them, gets `chunk_fluid_wind_publish_cell` — the velocity at that cell's centre less the step's far
+ * field — as `rgba16float`, alpha 0.
+ *
+ * The skirt is the cells one past the window. Each takes the window's faces where it has them (along
+ * an axis, the boundary face plane) and, for the rest, what the MAC seams answer beyond the window:
+ * the parent's identity read as of the cascade's read record (`chunk_fluid_cascade_parent_velocity`),
+ * which for the coarsest is the far field. Beside the far field, a skirt cell beside a face of the
+ * window takes half that boundary face's deviation on the face's axis and none on the others, and one
+ * past an edge or a corner none at all.
+ *
+ * It writes its own tile and never samples the atlas: the atlas is bound as a write-only storage
+ * texture and nothing else.
+ *
+ * One invocation a texel, in 4 × 4 × 4 workgroups over the tile, dispatched
+ * `ceil((N + 2) / 4)` on each axis; each reads its cell's six faces (`textureLoad`) and stores one
+ * texel. Standalone until it is fused into the gradient pass (proposal §8 (3)), where the faces are in
+ * workgroup memory already.
+ *
+ * Bindings:
+ * - `step`: {@link FLUID_MAC_STEP_STRUCT}: the cascade's windows and `far`, `v_far(t_s,c)` over the
+ *   window's cells; `cells.size` is the window, and the tile's content;
+ * - `publish`: {@link FLUID_WIND_PUBLISH_STRUCT}: the tile's texel origin in the atlas;
+ * - `parent`: {@link FLUID_CASCADE_PARENT_STRUCT}, and `parent_u`, `parent_v`, `parent_w` the parent's
+ *   persistent faces, read for the skirt;
+ * - `source_u`, `source_v`, `source_w`: the cascade's persistent velocity after its step, `r32float`
+ *   3-D textures, toroidal through `step.faces_*`;
+ * - `tile`: written, the atlas, `rgba16float` 3-D storage texture;
+ * - the turbulence tile (`fluid_turbulence_add_resources`), which the far field reads a texel at a time
+ *   with turbulence.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_fluid_wind_publish = ComputeShader.from({
+    label: "Fluid / wind publish",
+    body,
+    resources,
+});

package/src/shade/renderer/fluid/query/GPUFluidQueries.js

@@ -204,7 +204,7 @@ export class GPUFluidQueries {
         thread_count_x: 0,
         thread_count_y: 1,
         thread_count_z: 1,
-        bindings: { settings: null, database: null, list: null, wind_field: null, wind_field_atlas: null },
+        bindings: { settings: null, database: null, list: null, wind_field: null, wind_field_atlas: null, fluid_turbulence: null },
     };
 
     #destroyed = false;
@@ -565,7 +565,7 @@ export class GPUFluidQueries {
         shader_fluid_query_gather.dispatchThreads(dispatch);
 
         dispatch.encoder = null;
-        b.settings = b.database = b.list = b.wind_field = b.wind_field_atlas = null;
+        b.settings = b.database = b.list = b.wind_field = b.wind_field_atlas = b.fluid_turbulence = null;
 
         // right after the gather: the copy reads what it wrote
         this.#readback.encode(encoder);

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

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/GPUGeometryManager.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IAwKI;;;OAGG;IACH,+BAWC;IAjLD;;;OAGG;IACH,iBAFU,YAAU,IAAI,CAED;IAsDvB;;;OAGG;IACH,4GAEC;IAED;;;;OAIG;IACH,8BAA0B;IAE1B;;;;OAIG;IACH,uBAAsB;IAOtB;;;OAGG;IACH,kCAEC;IAwBD;;;OAGG;IACH,kCAEC;IAQD;;;;;OAKG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAiBC;IAmBD;;;;OAIG;IACH,qBAHW,mBAAmB,GAClB,MAAM,CAMjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAIlB;IAGD;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAwEnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,2BAPW,eAAe,GACb,mBAAmB,CAmC/B;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAHW,mBAAmB,GACjB,OAAO,CAmBnB;IAED;;;;;;;OAOG;IACH,uBAHW,eAAe,GACb,mBAAmB,GAAC,SAAS,CAIzC;IAED;;;;OAIG;IACH,iBAHW,eAAe,GACb,OAAO,CAwCnB;IAyBD,gBAWC;IAED;;;;;;OAMG;IACH,qBANW,sBAAsB,QAuChC;IAmDD,cAqCC;IAED,0CAWC;;CAuFJ;qCA3sBY,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,sBAAsB,EAAE,eAAe;oCANvB,0BAA0B;kCAC5B,gCAAgC;sCAH5B,gCAAgC;sCAIhC,gCAAgC"}
+{"version":3,"file":"GPUGeometryManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/GPUGeometryManager.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IAwKI;;;OAGG;IACH,+BAWC;IAjLD;;;OAGG;IACH,iBAFU,YAAU,IAAI,CAED;IAsDvB;;;OAGG;IACH,4GAEC;IAED;;;;OAIG;IACH,8BAA0B;IAE1B;;;;OAIG;IACH,uBAAsB;IAOtB;;;OAGG;IACH,kCAEC;IAwBD;;;OAGG;IACH,kCAEC;IAQD;;;;;OAKG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAiBC;IAmBD;;;;OAIG;IACH,qBAHW,mBAAmB,GAClB,MAAM,CAMjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAIlB;IAGD;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAwEnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,2BAPW,eAAe,GACb,mBAAmB,CAkC/B;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAHW,mBAAmB,GACjB,OAAO,CAmBnB;IAED;;;;;;;OAOG;IACH,uBAHW,eAAe,GACb,mBAAmB,GAAC,SAAS,CAIzC;IAED;;;;OAIG;IACH,iBAHW,eAAe,GACb,OAAO,CAwCnB;IAyBD,gBAWC;IAED;;;;;;OAMG;IACH,qBANW,sBAAsB,QAuChC;IAkDD,cAqCC;IAED,0CAWC;;CAuFJ;qCAzsBY,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,sBAAsB,EAAE,eAAe;oCANvB,0BAA0B;kCAC5B,gCAAgC;sCAH5B,gCAAgC;sCAIhC,gCAAgC"}

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

@@ -346,8 +346,7 @@ export class GPUGeometryManager {
 
         const metadata = new GPUGeometryMetadata();
         // The record's geometry, not the object the caller passed: the two are equal in content,
-        // but the BLAS manager keys a tree's *shape* by geometry object, and every clone of one
-        // record sharing one shape is what keeps N dancers from deriving and uploading N copies of it.
+        // and the record's is the one whose tree the clone's starts as a copy of.
         metadata.geometry = source_metadata.geometry;
         metadata.allocated = false;
         metadata.index = this.__last_geometry_index++;
@@ -568,9 +567,8 @@ export class GPUGeometryManager {
      *
      * One id, one tree, and the id is the key — which is the whole answer to a clone. A clone has a
      * geometry id of its own because it has a vertex region of its own, and a tree of its own for
-     * the same reason: what deformation changes is its bounds, and those cannot be written into the
-     * tree every other instance is still tracing. What it does *not* need its own of is the shape,
-     * which the BLAS manager shares between them.
+     * the same reason: what deformation changes is its boxes, and those cannot be written into the
+     * tree every other instance is still tracing.
      *
      * Must run after {@link GPUGeometryBVHManager#update}, which is what makes addresses real.
      */
@@ -599,8 +597,8 @@ export class GPUGeometryManager {
 
         // One tree per geometry id, clones included — keyed by the metadata row rather than by the
         // geometry, because a clone and its source share a `MeshletGeometry` and would otherwise
-        // collide on it. The nodes are duplicated per clone on purpose (they are what deformation
-        // rewrites); the shape behind them is not.
+        // collide on it. The nodes are duplicated per clone on purpose: they are what deformation
+        // rewrites.
         if (this.#enable_bvh) {
             for (const meta of all_metadata) {
                 this.#blas.obtain(meta, meta.geometry);

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

@@ -22,8 +22,11 @@ export class MeshletGeometry {
      */
     meshlets: MeshletBatch;
     /**
+     * The bottom-level tree over {@link meshlets}: BVH8 nodes, root first, as
+     * {@link blas_from_meshlets} makes them. It names triangles by their place inside each meshlet,
+     * so it belongs to these meshlets as they are ordered now and to no others.
+     *
      * @see GPUGeometryMeshletsBVH
-     * @see bvh2_compress
      * @type {ArrayBuffer}
      */
     bvh: ArrayBuffer;

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

@@ -1 +1 @@
-{"version":3,"file":"MeshletGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/MeshletGeometry.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IACI,WAAkB;IAElB;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,2BAAmC;IACnC,8BAAsC;IAEtC;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB,wBAGC;IAED;;OAEG;IACH,UAFU,YAAY,CAEQ;IAE9B;;;;OAIG;IACH,KAFU,WAAW,CAEG;IAExB,eAEC;IAED;;;OAGG;IACH,cAFW,eAAe,WAMzB;IAGL,2BAA2C;CAF1C;;;;6BAxD4B,2BAA2B"}
+{"version":3,"file":"MeshletGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/MeshletGeometry.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IACI,WAAkB;IAElB;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,2BAAmC;IACnC,8BAAsC;IAEtC;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB,wBAGC;IAED;;OAEG;IACH,UAFU,YAAY,CAEQ;IAE9B;;;;;;;OAOG;IACH,KAFU,WAAW,CAEG;IAExB,eAEC;IAED;;;OAGG;IACH,cAFW,eAAe,WAMzB;IAGL,2BAA2C;CAF1C;;;;6BA3D4B,2BAA2B"}

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

@@ -35,8 +35,11 @@ export class MeshletGeometry {
     meshlets = new MeshletBatch();
 
     /**
+     * The bottom-level tree over {@link meshlets}: BVH8 nodes, root first, as
+     * {@link blas_from_meshlets} makes them. It names triangles by their place inside each meshlet,
+     * so it belongs to these meshlets as they are ordered now and to no others.
+     *
      * @see GPUGeometryMeshletsBVH
-     * @see bvh2_compress
      * @type {ArrayBuffer}
      */
     bvh = new ArrayBuffer();