@woosh/meep-engine 3.47.0 → 3.50.0

package/src/engine/graphics3/ParticipatingMediaSystem.js

@@ -1,10 +1,41 @@
 import { assert } from "../../core/assert.js";
-import { isArrayEqualStrict } from "../../core/collection/array/isArrayEqualStrict.js";
-import { ParticipatingMediaVolume } from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
+import {
+    participating_media_volume_advance_noise,
+    ParticipatingMediaVolume
+} from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
 import { System } from "../ecs/System.js";
-import { Transform64 } from "../ecs/transform/Transform64.js";
+import { Transform64, TRANSFORM64_MATRIX_OFFSET } from "../ecs/transform/Transform64.js";
+import { GPUFluidSystem } from "./GPUFluidSystem.js";
 import { ParticipatingMedia } from "./ParticipatingMedia.js";
 
+/**
+ * One linked entity: its component, its transform, and the renderer's volume made for it.
+ */
+class MediaEntry {
+    /** @type {ParticipatingMedia} */
+    component;
+
+    /** @type {Transform64} */
+    transform;
+
+    /** @type {ParticipatingMediaVolume} */
+    volume;
+
+    /** Where the entry sits in the system's list. */
+    index = -1;
+
+    /**
+     * @param {ParticipatingMedia} component
+     * @param {Transform64} transform
+     * @param {ParticipatingMediaVolume} volume
+     */
+    constructor(component, transform, volume) {
+        this.component = component;
+        this.transform = transform;
+        this.volume = volume;
+    }
+}
+
 /**
  * Mirrors fog, smoke and cloud entities into Shade's volumetrics.
  *
@@ -26,10 +57,22 @@ import { ParticipatingMedia } from "./ParticipatingMedia.js";
  * tens, so the comparison is cheaper than the signal plumbing it replaces. The price is latency: a
  * change is visible within a frame rather than instantly.
  *
- * **Nothing is uploaded unless something actually changed.** The GPU table is repacked whole
- * whenever {@link SceneVolumetrics.version} moves, so an unconditional copy every frame would
- * re-upload every volume in the scene forever. The comparison is what decides, and on almost every
- * frame it decides nothing has to happen.
+ * **Nothing is uploaded unless something actually changed**, and what is uploaded is what changed.
+ * A change to anything but the noise phases moves {@link SceneVolumetrics#version}, and the GPU
+ * table is repacked whole; a scroll of the noise moves only {@link SceneVolumetrics#noise_version},
+ * and the rows get their phase words. The comparison, made while assigning, is what decides, and on
+ * almost every frame it decides nothing but the scroll has to happen.
+ *
+ * **The wind: the far field here, the rest on the GPU.** A noisy volume scrolls with the scene's far
+ * field `v_far(t)` × `noise_wind_factor` + `noise_velocity`, folded into its phases on the host: the
+ * far field is {@link GPUFluidSystem#far_field}, the `GlobalFluidEffector`s as `FluidEffectorsSystem`
+ * folds them — synchronous and deterministic, nothing read back. Where the scene's fluid differs from
+ * its far field, the shaders that evaluate the noise sample the published wind field there and carry
+ * the noise by the difference, flow-map style, on the volume's flow clock, which the advance moves on
+ * for every volume that feels the wind (`chunk_participating_media_noise`); uniform air costs and
+ * looks as a scroll alone does. Without a `GPUFluidSystem` in the entity manager the air is still.
+ *
+ * Allocates nothing per frame.
  *
  * @see ParticipatingMedia the component
  * @see SceneVolumetrics what the volumes are handed to
@@ -49,10 +92,22 @@ export class ParticipatingMediaSystem extends System {
     #scene;
 
     /**
-     * @type {Map<number, {component: ParticipatingMedia, transform: Transform, volume: ParticipatingMediaVolume}>}
+     * @type {Map<number, MediaEntry>}
      */
     #entries = new Map();
 
+    /**
+     * The same entries as {@link #entries}, in a list a frame walks without an iterator.
+     * @type {MediaEntry[]}
+     */
+    #list = [];
+
+    /** The far field this frame, read at most once a frame. */
+    #far = new Float64Array(3);
+
+    /** The wind a medium feels plus its own motion, for one call of the advance; never kept. */
+    #velocity = new Float64Array(3);
+
     /**
      * @param {GraphicsEngine} graphics
      * @param {Scene} scene
@@ -92,7 +147,12 @@ export class ParticipatingMediaSystem extends System {
 
         this.#scene.volumetrics.add(volume);
 
-        this.#entries.set(entity, { component, transform, volume });
+        const entry = new MediaEntry(component, transform, volume);
+
+        entry.index = this.#list.length;
+
+        this.#list.push(entry);
+        this.#entries.set(entity, entry);
     }
 
     /**
@@ -105,22 +165,91 @@ export class ParticipatingMediaSystem extends System {
     }
 
     /**
+     * One frame: whatever the component or transform now says differently reaches the renderer's
+     * volume and moves the volumetrics version, and every noisy volume's noise scrolls on by the far
+     * field it feels plus its own motion, which moves only the noise version.
+     *
+     * The far field is felt through each medium's `noise_wind_factor`; the fold to a scroll phase
+     * happens on the volume, in f64, wrapped, so a long session never grows a number and a change of
+     * wind never jumps the field. A medium with no noise, or none that moves, costs the comparison it
+     * always did.
+     *
      * @param {number} time_delta_seconds
      */
     update(time_delta_seconds) {
         const volumetrics = this.#scene.volumetrics;
 
-        for (const entry of this.#entries.values()) {
+        const list = this.#list;
+        const count = list.length;
+
+        const velocity = this.#velocity;
+        const far = this.#far;
+
+        let far_read = false;
+        let changed = false;
+        let scrolled = false;
+
+        for (let i = 0; i < count; i++) {
+            const entry = list[i];
             const volume = entry.volume;
+            const component = entry.component;
+
+            if (participating_media_volume_write(volume, component, entry.transform)) {
+                changed = true;
+            }
 
-            if (participating_media_volume_is_current(volume, entry.component, entry.transform)) {
+            if (component.noise_strength <= 0) {
                 continue;
             }
 
-            participating_media_volume_write(volume, entry.component, entry.transform);
+            const factor = component.noise_wind_factor;
+            const own = component.noise_velocity;
+
+            if (factor !== 0 && !far_read) {
+                this.#read_far_field(far);
+                far_read = true;
+            }
 
+            if (factor !== 0) {
+                velocity[0] = far[0] * factor + own[0];
+                velocity[1] = far[1] * factor + own[1];
+                velocity[2] = far[2] * factor + own[2];
+            } else {
+                velocity[0] = own[0];
+                velocity[1] = own[1];
+                velocity[2] = own[2];
+            }
+
+            if (participating_media_volume_advance_noise(volume, velocity, time_delta_seconds)) {
+                scrolled = true;
+            }
+        }
+
+        if (changed) {
             volumetrics.invalidate();
         }
+
+        if (scrolled) {
+            volumetrics.invalidate_noise();
+        }
+    }
+
+    /**
+     * The entity manager's {@link GPUFluidSystem}'s far field now, or still air without one.
+     *
+     * @param {Float64Array} out
+     */
+    #read_far_field(out) {
+        const manager = this.entityManager;
+        const fluid = manager === null || manager === undefined ? null : manager.getSystem(GPUFluidSystem);
+
+        if (fluid === null) {
+            out[0] = 0;
+            out[1] = 0;
+            out[2] = 0;
+        } else {
+            fluid.far_field(out);
+        }
     }
 
     /**
@@ -136,54 +265,96 @@ export class ParticipatingMediaSystem extends System {
         this.#scene.volumetrics.remove(entry.volume);
 
         this.#entries.delete(entity);
+
+        // swap the last entry into the gap
+        const list = this.#list;
+        const last = list.pop();
+
+        if (last !== entry) {
+            list[entry.index] = last;
+            last.index = entry.index;
+        }
+
+        entry.index = -1;
     }
 }
 
 /**
- * Copy what the component and its transform say onto the volume Shade will render.
+ * Copy what the component and its transform say onto the volume Shade will render, field by field,
+ * comparing while assigning, and say whether anything differed — which is whether the GPU table
+ * has to be repacked.
  *
  * The particle spec is **copied, not referenced**: two entities are routinely built from the same
  * blueprint and would otherwise share one spec, so tuning one volume's particle would silently
- * retune the other's.
+ * retune the other's. The scroll and flow phases are the volume's own state and are not touched
+ * here; `noise_wind_factor` is a setting, and the shaders read it.
+ *
+ * **The transform is compared and copied by its matrix**, element by element straight off the
+ * `Transform64` — its first sixteen elements — and never through its `matrix` getter, which makes a
+ * view per read. The matrix is the entire transform the GPU is given, so this is exactly the question
+ * "would the upload differ", and it catches a transform posed by writing its matrix, which comparing
+ * position, rotation and scale would not. `fromMatrix` copies the sixteen and then decomposes them,
+ * leaving the matrix bit-identical, so the volume carries the authored matrix exactly.
  *
  * @param {ParticipatingMediaVolume} volume Shade's
  * @param {ParticipatingMedia} component meep's
  * @param {Transform64} transform where the box is
+ * @returns {boolean} whether the volume differed from what the component and transform say
  */
 export function participating_media_volume_write(volume, component, transform) {
-    volume.density = component.density;
-    volume.fade_distance = component.fade_distance;
-
-    volume.particle_spec.copy(component.particle_spec);
-
-    // By the MATRIX, not by the components. The volume is defined by the matrix the GPU is
-    // handed, and a transform can be posed by writing that matrix directly - with automatic change
-    // detection off, position, rotation and scale know nothing about it. `fromMatrix` copies the
-    // sixteen elements and then decomposes them, leaving the matrix bit-identical, so the volume
-    // carries the authored matrix exactly and gets usable components besides.
-    //
-    // Nothing is gained by recomposing in f64 here, the way t64_copy_from_transform would: the
-    // source matrix is f32, and precision the input never had cannot be recovered. This becomes a
-    // plain buffer copy, f64 end to end, once the entity's own transform is a Transform64.
-    volume.transform.fromMatrix(transform.matrix);
+    let changed = false;
+
+    if (volume.density !== component.density) {
+        volume.density = component.density;
+        changed = true;
+    }
+
+    if (volume.fade_distance !== component.fade_distance) {
+        volume.fade_distance = component.fade_distance;
+        changed = true;
+    }
+
+    if (volume.noise_strength !== component.noise_strength) {
+        volume.noise_strength = component.noise_strength;
+        changed = true;
+    }
+
+    if (volume.noise_scale !== component.noise_scale) {
+        volume.noise_scale = component.noise_scale;
+        changed = true;
+    }
+
+    if (volume.noise_warp !== component.noise_warp) {
+        volume.noise_warp = component.noise_warp;
+        changed = true;
+    }
+
+    if (volume.noise_slot !== component.noise_texture) {
+        volume.noise_slot = component.noise_texture;
+        changed = true;
+    }
+
+    if (volume.noise_wind_factor !== component.noise_wind_factor) {
+        volume.noise_wind_factor = component.noise_wind_factor;
+        changed = true;
+    }
+
+    if (!volume.particle_spec.equals(component.particle_spec)) {
+        volume.particle_spec.copy(component.particle_spec);
+        changed = true;
+    }
+
+    if (!participating_media_matrix_equals(volume.transform, transform)) {
+        volume.transform.fromMatrix(transform);
+        changed = true;
+    }
+
+    return changed;
 }
 
 /**
- * Whether the volume already says what the component and transform say.
- *
- * True on all but a handful of frames, which is the point of asking: a `false` here costs the whole
- * scene's volumetrics table a trip to the GPU.
- *
- * **The transform is compared by its matrix rather than by its components**, because the matrix is
- * the entire transform the GPU is given — the volume's position, rotation and scale are never read
- * on their own. That makes this exactly the question worth asking, "would the upload differ", and it
- * catches a transform posed by writing its matrix, which comparing position, rotation and scale
- * would not.
- *
- * The volume's matrix is a `Float64Array` and the component's is a `Float32Array`, and the strict
- * comparison across the two still holds: {@link participating_media_volume_write} copies the matrix
- * across element by element, and every f32 value widens to f64 exactly. It is a recomposed matrix
- * that would not compare equal, which is why the write does not recompose.
+ * Whether the volume already says what the component and transform say: the question
+ * {@link participating_media_volume_write} answers while it assigns, asked without assigning.
  *
  * @param {ParticipatingMediaVolume} volume
  * @param {ParticipatingMedia} component
@@ -193,6 +364,26 @@ export function participating_media_volume_write(volume, component, transform) {
 export function participating_media_volume_is_current(volume, component, transform) {
     return volume.density === component.density
         && volume.fade_distance === component.fade_distance
-        && isArrayEqualStrict(volume.transform.matrix, transform.matrix)
+        && volume.noise_strength === component.noise_strength
+        && volume.noise_scale === component.noise_scale
+        && volume.noise_warp === component.noise_warp
+        && volume.noise_slot === component.noise_texture
+        && volume.noise_wind_factor === component.noise_wind_factor
+        && participating_media_matrix_equals(volume.transform, transform)
         && volume.particle_spec.equals(component.particle_spec);
 }
+
+/**
+ * @param {Transform64} a
+ * @param {Transform64} b
+ * @returns {boolean} whether the two matrices are the same sixteen numbers
+ */
+function participating_media_matrix_equals(a, b) {
+    for (let i = TRANSFORM64_MATRIX_OFFSET; i < TRANSFORM64_MATRIX_OFFSET + 16; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/src/engine/graphics3/WaterSystem.d.ts

@@ -3,15 +3,21 @@
  * edits queue writes; idle frames never walk bodies. Transform rows follow the same change events
  * and GPU hierarchy as shaded geometry. Water does not enter the opaque mesh table or its TLAS.
  *
- * Every body has a surface row (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §6.1): its wind from an
+ * Every body has a surface row (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §6.1): its fetch and shore from an
  * optional {@link WaterWaves}, its queued splashes, and what the GPU derives from them each frame. The GPU culls
  * every body against the frame's view before simulating; a hidden body is paused unless
  * {@link Water#simulateWhenHidden} (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §3).
+ *
+ * **The wind is the scene's** (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, the Water row): the culling pass
+ * samples the published wind field 10 m above each body's origin and low-passes it per body, on the GPU. What the
+ * system decides on the CPU is only whether that field can hold wind at all ({@link GPUWaterSurface#windy}, which
+ * animates the shared bands): while any enabled {@link GPUFluidComponent} steps a fluid, or the far field
+ * ({@link GPUFluidSystem#far_field}) is not still. Asked every update, allocating nothing.
  */
 export class WaterSystem extends System<any> {
     constructor(graphics: any, scene: any);
     dependencies: (typeof Transform64 | typeof MeshletGeometry | typeof Water)[];
-    components_used: ResourceAccessSpecification<typeof WaterWaves>[];
+    components_used: (ResourceAccessSpecification<typeof WaterWaves> | ResourceAccessSpecification<typeof GPUFluidComponent>)[];
     get settings(): {
         enabled: boolean;
         max_distance: number;
@@ -61,6 +67,7 @@ import { MeshletGeometry } from "../../shade/renderer/geometry/MeshletGeometry.j
 import Water from "../graphics/ecs/water/Water.js";
 import WaterWaves from "../graphics/ecs/water/WaterWaves.js";
 import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
+import { GPUFluidComponent } from "../physics/fluid/ecs/GPUFluidComponent.js";
 import { GPUWaterSurface } from "../../shade/renderer/water/surface/GPUWaterSurface.js";
 import { GPUWaterRenderer } from "../../shade/renderer/water/GPUWaterRenderer.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";

package/src/engine/graphics3/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/WaterSystem.js"],"names":[],"mappings":"AA+BA;;;;;;;;;GASG;AACH;IA2BI,uCAaC;IAvCD,6EAAqD;IACrD,kEAA0F;IAc1F;;;;;;;;;;;MAAkD;IAClD,6BAAmC;IACnC,6CAAqD;IACrD,iBAAmC;IACnC,qCAA8D;IAE9D,0BAGC;IAJD,mBAAiC;IAqBjC,2CAOC;IAED,0BAMC;IAED,mEAsBC;IAQD,qEAkBC;IAED,sBAoBC;IAqDD;;;;OAIG;IACH,qEASC;IAED,iCAMC;IACD,yBAGC;;CACJ;AAED;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAA4C;CAC/C;AACD;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAAoD;CACvD;uBAlQsB,kBAAkB;4BAEb,iCAAiC;gCAI7B,kDAAkD;kBARhE,gCAAgC;uBACe,qCAAqC;4CAS1D,iDAAiD;gCAG7D,uDAAuD;iCAFtD,gDAAgD;gCAIjD,mDAAmD"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/WaterSystem.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;GAeG;AACH;IAoCI,uCAaC;IAhDD,6EAAqD;IACrD,4HAEkF;IAqBlF;;;;;;;;;;;MAAkD;IAClD,6BAAmC;IACnC,6CAAqD;IACrD,iBAAmC;IACnC,qCAA8D;IAE9D,0BAGC;IAJD,mBAAiC;IAqBjC,2CAOC;IAED,0BAMC;IAED,mEAsBC;IAQD,qEAiBC;IAED,sBAqBC;IA0ED;;;;OAIG;IACH,qEASC;IAED,iCAMC;IACD,yBAGC;;CACJ;AAED;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAA4C;CAC/C;AACD;IAEI,yBAAsD;IAAvB,YAAoB;IACnD,yBAAoD;CACvD;uBAxSsB,kBAAkB;4BAEb,iCAAiC;gCAI7B,kDAAkD;kBARhE,gCAAgC;uBACe,qCAAqC;4CAS1D,iDAAiD;kCAW3D,2CAA2C;gCAR7C,uDAAuD;iCAFtD,gDAAgD;gCAIjD,mDAAmD"}

package/src/engine/graphics3/WaterSystem.js

@@ -20,12 +20,14 @@ import { m4_invert } from "../../core/geom/3d/mat4/m4_invert.js";
 import { generate_record_writer } from "../../shade/renderer/buffer/table/serde/generate_record_writer.js";
 import { WATER_WAVE_IMPULSE_LIMIT, WATER_WAVE_RECORD_STRUCT } from "../../shade/renderer/water/surface/WATER_WAVE_RECORD_STRUCT.js";
 import { WATER_SPECTRUM_BAND_COUNT } from "../../shade/renderer/water/surface/spectrum/WATER_SPECTRUM.js";
+import { GPUFluidComponent } from "../physics/fluid/ecs/GPUFluidComponent.js";
+import { GPUFluidSystem } from "./GPUFluidSystem.js";
 
 // Only the authored fields: a whole-record write would undo what the GPU derives into the row.
-const AUTHORED_WRITER = generate_record_writer(WATER_WAVE_RECORD_STRUCT, ['wind', 'upwind_fetch', 'node', 'geometry', 'simulate_hidden']);
+const AUTHORED_WRITER = generate_record_writer(WATER_WAVE_RECORD_STRUCT, ['upwind_fetch', 'shore_reflection', 'node', 'geometry', 'simulate_hidden']);
 const IMPULSE_WRITER = generate_record_writer(WATER_WAVE_RECORD_STRUCT, ['impulses', 'impulse_count']);
 /** The WaterWaves fields a body's row follows. */
-const WAVE_FIELDS = ['windSpeed', 'windDirection', 'upwindFetch', 'shoreReflection'];
+const WAVE_FIELDS = ['upwindFetch', 'shoreReflection'];
 /** A splash's world-to-local matrix: rain can splash hundreds of times a second. */
 const SPLASH_INVERSE = new Float64Array(16);
 
@@ -34,14 +36,22 @@ const SPLASH_INVERSE = new Float64Array(16);
  * edits queue writes; idle frames never walk bodies. Transform rows follow the same change events
  * and GPU hierarchy as shaded geometry. Water does not enter the opaque mesh table or its TLAS.
  *
- * Every body has a surface row (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §6.1): its wind from an
+ * Every body has a surface row (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §6.1): its fetch and shore from an
  * optional {@link WaterWaves}, its queued splashes, and what the GPU derives from them each frame. The GPU culls
  * every body against the frame's view before simulating; a hidden body is paused unless
  * {@link Water#simulateWhenHidden} (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §3).
+ *
+ * **The wind is the scene's** (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, the Water row): the culling pass
+ * samples the published wind field 10 m above each body's origin and low-passes it per body, on the GPU. What the
+ * system decides on the CPU is only whether that field can hold wind at all ({@link GPUWaterSurface#windy}, which
+ * animates the shared bands): while any enabled {@link GPUFluidComponent} steps a fluid, or the far field
+ * ({@link GPUFluidSystem#far_field}) is not still. Asked every update, allocating nothing.
  */
 export class WaterSystem extends System {
     dependencies = [Water, MeshletGeometry, Transform64];
-    components_used = [ResourceAccessSpecification.from(WaterWaves, ResourceAccessKind.Read)];
+    components_used = [ResourceAccessSpecification.from(WaterWaves, ResourceAccessKind.Read),
+        // whether the scene's wind field has a fluid behind it
+        ResourceAccessSpecification.from(GPUFluidComponent, ResourceAccessKind.Read)];
     #graphics;
     #scene;
     #context = null;
@@ -51,8 +61,15 @@ export class WaterSystem extends System {
     #entries = new Map();
     #dirty = new Set();
     #impulses = new Set();
-    // bodies with wind: while there is none, the shared band tiles are not animated
-    #windy = new Set();
+    /** @type {GPUFluidSystem|null} the far field's source, once found */
+    #fluid = null;
+    #far = new Float64Array(3);
+    /** Whether {@link #visit_domain} met an enabled component. */
+    #enabled_found = false;
+    #visit_domain = component => {
+        if (component.enabled) { this.#enabled_found = true; return false; }
+        return true;
+    };
     #extensions = [];
     #time = 0;
     get settings() { return this.#renderer.settings; }
@@ -143,13 +160,13 @@ export class WaterSystem extends System {
             entry.context.rows.release(entity);
         }
         this.#entries.delete(entity); this.#dirty.delete(entry); this.#impulses.delete(entry);
-        this.#windy.delete(entry); this.#waves.windy = this.#windy.size > 0;
         this.#renderer.body_count--;
         if (entry.context !== null) { this.#renderer.meshlet_capacity -= entry.geometry.meshlets.count; }
     }
 
     update(dt) {
         this.#time += dt; this.#renderer.time = this.#time; this.#waves.advance(dt);
+        this.#waves.windy = this.#wind_can_blow();
         const context = this.#graphics.scene_context(this.#scene);
         if (context === null) { return; }
         if (context !== this.#context) {
@@ -170,6 +187,31 @@ export class WaterSystem extends System {
         for (const entry of this.#impulses) { this.#stage(entry, context); }
     }
 
+    /**
+     * Whether the scene's wind field can hold wind: an enabled {@link GPUFluidComponent} on any entity, or a far
+     * field that is not still. The lowest holder of the component answers without a walk; only when it is disabled
+     * are the others visited.
+     * @returns {boolean}
+     */
+    #wind_can_blow() {
+        const em = this.entityManager, dataset = em.dataset;
+        if (dataset !== null) {
+            const lowest = dataset.getAnyComponentInstance(GPUFluidComponent);
+            if (lowest !== null) {
+                if (lowest.enabled) { return true; }
+                this.#enabled_found = false;
+                dataset.traverseComponents(GPUFluidComponent, this.#visit_domain);
+                if (this.#enabled_found) { return true; }
+            }
+        }
+        // registered later than this system, or never
+        const fluid = this.#fluid ??= em.getSystem(GPUFluidSystem);
+        if (fluid === null) { return false; }
+        const far = this.#far;
+        fluid.far_field(far);
+        return far[0] !== 0 || far[1] !== 0 || far[2] !== 0;
+    }
+
     /** Top up a body's batch on its surface row from its queue, up to the row's limit. */
     #stage(entry, context) {
         const staged = entry.staged, queue = entry.queue;
@@ -197,21 +239,17 @@ export class WaterSystem extends System {
         }
         const geometry = context.geometries.getAddress(entry.geometry);
         if (entry.wave === -1) {
-            entry.wave = waves.add({ wind: [1, 0, 0, WATER_WAVES_SHORE_REFLECTION_DEFAULT], upwind_fetch: 0,
+            // the GPU seeds the wind from its first sample, and derives the weights for it
+            entry.wave = waves.add({ upwind_fetch: 0, shore_reflection: WATER_WAVES_SHORE_REFLECTION_DEFAULT,
                 impulses: Array.from({ length: WATER_WAVE_IMPULSE_LIMIT }, () => [0, 0, 0, 0]), impulse_count: 0,
-                node: entry.entity + 1, geometry, simulate_hidden: 0, derived_for: [-1, -1],
+                node: entry.entity + 1, geometry, simulate_hidden: 0, wind: [0, 0, 0], wind_seeded: 0, derived_for: [-1, -1, 0, 0],
                 weights: new Array(WATER_SPECTRUM_BAND_COUNT).fill(0), slope_variance: 0,
                 wind_from: [0, 0], wind_to: [0, 0], wind_blend: 1, displacement_bounds: [0, 0, 0, 0], particle_levels: 0 });
         }
         const waves_component = entry.waves;
-        const speed = Math.max(0, waves_component?.windSpeed.getValue() ?? 0);
-        const direction = waves_component?.windDirection.getValue() ?? 0;
         const reflection = Math.min(1, Math.max(0, waves_component?.shoreReflection.getValue() ?? WATER_WAVES_SHORE_REFLECTION_DEFAULT));
-        waves.set_fields(entry.wave, { wind: [Math.cos(direction), Math.sin(direction), speed, reflection],
-            upwind_fetch: Math.max(0, waves_component?.upwindFetch.getValue() ?? 0), node: entry.entity + 1, geometry,
+        waves.set_fields(entry.wave, { upwind_fetch: Math.max(0, waves_component?.upwindFetch.getValue() ?? 0), shore_reflection: reflection, node: entry.entity + 1, geometry,
             simulate_hidden: entry.water.simulateWhenHidden.getValue() ? 1 : 0 }, AUTHORED_WRITER);
-        if (speed > 0) { this.#windy.add(entry); } else { this.#windy.delete(entry); }
-        this.#waves.windy = this.#windy.size > 0;
         const water = entry.water;
         const record = { geometry, node: entry.entity + 1,
             dirty: 1,

package/src/engine/network/NetworkSession.d.ts

@@ -212,6 +212,15 @@ export class NetworkSession {
      * @type {number}
      */
     correction_skipped_count: number;
+    /**
+     * Client: how many times it found itself more than the host's input window behind the frame the
+     * host last named, or was told by the host's depth feedback that its input lands below the
+     * host's window, and re-took the host's time. A tab in the background, a debugger, a laptop
+     * asleep — see {@link #retake_host_time_if_stalled}. Diagnostic: a game that sees these on a
+     * machine that never left the foreground has a client that cannot keep the step.
+     * @type {number}
+     */
+    stall_count: number;
     /**
      * Client, {@link NetworkSessionReconcile.Correct}: a component of an authoritative state
      * differed from the prediction, and the present was corrected. Once per component corrected.
@@ -610,9 +619,9 @@ export class NetworkSession {
      * frame 6,000; a client has to start tagging its inputs near 6,000 or the host discards every
      * one of them — `ServerAuthoritativeServer.tick` trims pending actions older than
      * `sim_frame - frame_capacity + 1`, and a client tagging frame 0 against a host at 6,000 has
-     * every input dropped **silently**. It moves on its own screen, never moves on the host's, and
-     * no signal fires: `onPendingActionDropped` covers the future-lead and capacity bounds, not
-     * this one.
+     * every input dropped. It moves on its own screen and never moves on the host's — and until
+     * 2026-10-15 no signal fired; the host's `onPendingActionDropped` now reports each such drop
+     * as `'window'`.
      *
      * Everything needed was already there except the setter. INITIAL_SYNC carries the host's frame,
      * `NetworkPeer` writes it, and `onInitialSync` dispatches it — and the handler named it
@@ -621,8 +630,10 @@ export class NetworkSession {
      * with the input sampler silenced until its counter caught up: 28,801 calls and 62 ms of wall
      * clock for an hour-old host. Reported as GAP-042.
      *
-     * A client now seeks automatically on INITIAL_SYNC. This is the manual door, for a caller that
-     * computes its own lead.
+     * A client now seeks automatically on INITIAL_SYNC, and again whenever it finds itself more than
+     * the host's input window behind the frame the host last named — a stall, see
+     * {@link #retake_host_time_if_stalled}. This is the manual door, for a caller that computes its
+     * own lead.
      *
      * A client sends the host nothing it predicted before its last sync, and knows it by frame: its
      * input starts at the frame the sync sought to. A caller whose own lead is shorter moves that

package/src/engine/network/NetworkSession.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkSession.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/NetworkSession.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"NetworkSession.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/NetworkSession.js"],"names":[],"mappings":"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"}