@woosh/meep-engine 3.49.0 → 3.50.0

package/src/engine/physics/cloth/playground/wind_main.js

@@ -1,6 +1,12 @@
 import { EntityComponentDataset } from "../../../ecs/EntityComponentDataset.js";
+import { EntityManager } from "../../../ecs/EntityManager.js";
 import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
+import { FluidEffectorsComponent } from "../../fluid/ecs/FluidEffectorsComponent.js";
+import { FluidEffectorsSystem } from "../../fluid/ecs/FluidEffectorsSystem.js";
 import { fluid_build_world_to_grid } from "../../fluid/ecs/fluid_build_world_to_grid.js";
+import { fluid_apply_atmosphere } from "../../fluid/fluid_apply_atmosphere.js";
+import { fluid_atmosphere_to_grid } from "../../fluid/fluid_atmosphere_to_grid.js";
+import { FLUID_ATMOSPHERE_WORDS } from "../../fluid/FluidAtmosphere.js";
 import { fluid_sample_velocity_world_mps } from "../../fluid/ecs/fluid_sample_velocity_world_mps.js";
 import { CLOTH_DYNAMICS_BY_NAME } from "../ecs/cloth_dynamics_library.js";
 import { cloth_bend_ratio, cloth_drag_response } from "../ecs/cloth_dynamics_map.js";
@@ -25,7 +31,10 @@ import { build_wind_tunnel, place_wind_post } from "./wind_build.js";
  * prevailing flow, and a solid post standing in it; the deficit and the turning
  * behind the post are the incompressible projection's answer, and the banner
  * reads them through exactly the `ClothFluidWind` and `cloth_sample_air` a game
- * scene would use.
+ * scene would use. The global acts as a scene's do: `FluidEffectorsSystem` folds
+ * it into the far field once a step, the field is brought to that far field
+ * (`fluid_apply_atmosphere`), and the cloth reads the same far field outside the
+ * volume — one wind, gust included (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md G2).
  * That is §10's whole argument — this engine already has something better than a
  * wind zone — put where it can be watched instead of read.
  *
@@ -47,10 +56,10 @@ import { build_wind_tunnel, place_wind_post } from "./wind_build.js";
  *   shedding street — it is a steady deficit, and the free corner moves twelve
  *   times as far per step with the post as without rather than fluttering.
  *
- * And **"ambient only"** is §10's fallback: a constant plus a band-limited
- * gust, uniform over the whole banner, read through the same interface. It
- * costs one sample for the whole cloth instead of one per particle, which the
- * readout shows as the sample time dropping by a factor of twenty-five.
+ * And **"far field only"** is §10's fallback: the global's wind and its gust,
+ * uniform over the whole banner, read through the same interface. It costs one
+ * sample for the whole cloth instead of one per particle, which the readout
+ * shows as the sample time dropping by a factor of twenty-five.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -107,13 +116,32 @@ let cloth = null;
 /** @type {ReturnType<build_wind_tunnel>} */
 let tunnel = null;
 
-/** @type {ClothFluidWind} */
-const wind = new ClothFluidWind();
-
-/** The dataset the wind source reads its fields out of — one component in it. */
+/** The dataset the wind source reads its fields out of: the volume, and the global on it. */
 const ecd = new EntityComponentDataset();
 
-ecd.setComponentTypeMap([FluidComponent]);
+ecd.setComponentTypeMap([FluidComponent, FluidEffectorsComponent]);
+
+/** What folds the global into the far field, once a step, as in a scene. */
+const effectors = new FluidEffectorsSystem();
+
+{
+    const em = new EntityManager();
+
+    em.addSystem(effectors);
+    em.attachDataset(ecd);
+
+    await new Promise((resolve, reject) => em.startup(resolve, reject));
+}
+
+/** The far field, world units, and in the volume's grid units. */
+const atmosphere_world = new Float64Array(FLUID_ATMOSPHERE_WORDS);
+const atmosphere_grid = new Float64Array(FLUID_ATMOSPHERE_WORDS);
+
+/** No effector is applied by itself: the global acts through the far field. */
+const NO_EFFECTORS = [];
+
+/** @type {ClothFluidWind} */
+const wind = new ClothFluidWind(effectors);
 
 let fluid_entity = -1;
 
@@ -181,6 +209,12 @@ function rebuild_tunnel() {
 
     ecd.addComponentToEntity(fluid_entity, tunnel.component);
 
+    const air = new FluidEffectorsComponent();
+
+    air.addEffector(tunnel.effector);
+
+    ecd.addComponentToEntity(fluid_entity, air);
+
     refresh_post();
 }
 
@@ -211,23 +245,28 @@ function step_once() {
     tunnel.effector.wind[1] = 0;
     tunnel.effector.wind[2] = Math.cos(angle) * control.speed;
 
-    wind.ambient.wind[0] = tunnel.effector.wind[0];
-    wind.ambient.wind[1] = 0;
-    wind.ambient.wind[2] = tunnel.effector.wind[2];
-
-    wind.ambient.gust = control.gust;
-    wind.ambient.period = 1.6;
+    // The gust is the global's, so the far field carries it inside the volume
+    // and outside alike.
+    tunnel.effector.gust = control.gust;
+    tunnel.effector.gust_period = 1.6;
 
-    // 1. The air. A real fluid step, with the post's wake in it.
+    // 1. The air. The far field folded, then a real fluid step brought to it,
+    //    with the post's wake in it — what `FluidSystem` does for a scene.
     const fluid_started = performance.now();
 
+    effectors.fixedUpdate(FIXED_STEP);
+    effectors.read_atmosphere(atmosphere_world, 0);
+
     fluid_build_world_to_grid(tunnel.world_to_grid, tunnel.component);
 
     tunnel.component.enabled = control.source === 'field';
 
     if (tunnel.component.enabled) {
+        fluid_atmosphere_to_grid(atmosphere_grid, 0, atmosphere_world, 0, tunnel.world_to_grid);
+        fluid_apply_atmosphere(tunnel.component.field, FIXED_STEP, atmosphere_grid, 0);
+
         tunnel.simulator.step(
-            tunnel.component.field, FIXED_STEP, [tunnel.effector], tunnel.world_to_grid
+            tunnel.component.field, FIXED_STEP, NO_EFFECTORS, tunnel.world_to_grid
         );
     }
 
@@ -235,7 +274,7 @@ function step_once() {
 
     // 2. The cloth reads it. `begin` once a step, then one sample per particle
     //    — or one for the whole banner where no field reaches, which is what
-    //    "ambient only" turns this page into.
+    //    "far field only" turns this page into.
     const sample_started = performance.now();
 
     wind.begin(time, ecd);

package/src/engine/physics/cloth/wind/AbstractClothWind.d.ts

@@ -2,12 +2,13 @@
  * # Where the air comes from — one interface, two answers
  *
  * §10's design in one sentence: this engine has something better than a wind
- * zone, so cloth should **sample** the air rather than invent it. Two things can
- * answer "how fast is the air at this point": a running fluid simulation
- * ({@link ClothFluidWind}), and an ambient model for everywhere a simulation is
- * not ({@link ClothAmbientWind}). §10 asks for both to be read "through *the
- * same interface*, so the cloth code has one path and does not branch on whether
- * a simulation is present", and this is that interface.
+ * zone, so cloth should **sample** the air rather than invent it. What answers
+ * "how fast is the air at this point" is the scene's fluid: the GPU wind
+ * (`ClothGPUFluidWind`, the default for a scene with a `GPUFluidSystem`), or the
+ * CPU fields (`ClothFluidWind`). Either answers the scene's **far field** — its
+ * `GlobalFluidEffector`s, folded by `FluidEffectorsSystem` — wherever the
+ * simulation does not reach, through *the same interface*, so the cloth code has
+ * one path and does not branch on whether a simulation is present.
  *
  * It is two questions rather than one, and the second is what makes the feature
  * affordable:
@@ -15,33 +16,33 @@
  * - {@link sample} answers the air's **world** velocity at a world point, in
  *   metres per second.
  * - {@link varies} answers whether it is worth asking {@link sample} more than
- *   once for a given box. An ambient source answers `false` for every box and a
- *   whole garment costs one sample; a fluid source answers `true` only where one
- *   of its fields actually reaches, which is §10's "a cloth outside every fluid
- *   field's bounds skips it entirely" expressed as a question the cloth can ask.
+ *   once for a given box. A source answering `false` costs a whole garment one
+ *   sample; a fluid source answers `true` only where it has something that
+ *   varies, which is §10's "a cloth outside every fluid field's bounds skips it
+ *   entirely" expressed as a question the cloth can ask.
  *
  * ## Determinism, because two systems share one of these
  *
  * `ClothSystem` and `WorkerClothSystem` share a {@link ClothWorld} and therefore
- * share its wind source, and §12's bit-parity gate is over the whole
- * `ClothState` buffer at every step. The air is sampled **once**, by the world,
- * into that buffer — so the two systems do not agree about the wind, they read
- * the same bytes of it. What this interface has to promise is only that
- * {@link sample} is a pure function of (its `time` argument, the point), with no
- * wall clock and no random source: a gust that consulted `Date.now()` would make
- * two runs of the same scene differ and would take the parity spec's guarantee
- * with it.
+ * share its wind source, and §12's parity gate is over the whole `ClothState`
+ * buffer at every step. The air is sampled **once**, by the world, on the main
+ * thread, into that buffer — so the two systems do not agree about the wind,
+ * they read the same bytes of it.
  *
- * **And the clock is the cloth's own age, not the world's.** M6 made the world
- * clock count steps rather than ticks so that a cloth's *first* step got the
- * same weather under both systems, and that is right for the first cloth in a
- * scene and wrong for every one after it: while cloth B's registration is in
- * flight, cloth A is still being advanced, so the world clock moves and B's
- * first step lands at a different time under the worker than under the inline
- * system. Measured at a two-tick delivery: 0.1000 s against 0.1333 s, a
- * divergence at B's step 1, byte 0. So `time` is **seconds this instance has
- * stepped**, which is the same number on both sides by construction.
- * `MEASUREMENTS.md` §57.
+ * **The clock is the scene's** (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12,
+ * G2). The far field's gust is integrated once a tick by `FluidEffectorsSystem`,
+ * so a cloth steps in the weather of the tick it is advanced on — and a worker
+ * cloth is advanced from the tick its registration is acknowledged, not the tick
+ * it was linked (`MEASUREMENTS.md` §39, §57). So the gate holds for cloths
+ * registered on the same tick under both systems, and for any registration
+ * under a time-invariant wind; under a gust, a cloth the worker registers later
+ * steps in later weather. And the GPU wind arrives when the GPU answers, so two
+ * runs of a scene need not read the same air at all: run-to-run repeatability
+ * under the GPU wind is given up (F4). `MEASUREMENTS.md` §69.
+ *
+ * This replaced M6's answer, where the gust was a pure function of the asking
+ * cloth's own age (`ClothAmbientWind`, retired): one wind, read one way, beat a
+ * second clock that only cloth kept.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -49,12 +50,11 @@
 export class AbstractClothWind {
     /**
      * Called once per fixed step, before any cloth is advanced, so a source that
-     * reads the **scene** — every live fluid field and its world box — can walk
-     * it once rather than once a cloth.
+     * reads the **scene** — every live fluid field and its world box, the far
+     * field, the GPU's lattices — can take it once rather than once a cloth.
      *
      * `time` is the cloth world's own accumulated fixed-step clock rather than a
-     * wall clock. It is *not* what a gust is a function of: see the note above,
-     * and {@link sample}'s own `time`.
+     * wall clock.
      *
      * @param {number} time seconds of fixed step this world has stepped
      * @param {EntityComponentDataset} ecd for a source that reads components
@@ -86,15 +86,16 @@ export class AbstractClothWind {
      * assumption that its callers want a direction times a magnitude. Cloth is
      * not such a caller — its drag row is an acceleration toward a velocity, and
      * a velocity in cells is a garment that blows differently depending on how
-     * finely someone voxelised the room. {@link ClothFluidWind} multiplies by
+     * finely someone voxelised the room. `ClothFluidWind` multiplies by
      * `cell_size`. `MEASUREMENTS.md` §45.
      *
      * @param {Float64Array|number[]} out length 3
      * @param {number} x world-space, metres
      * @param {number} y
      * @param {number} z
-     * @param {number} time seconds the asking cloth has stepped — see the note
-     *   above for why this is the cloth's own age and not the world's clock
+     * @param {number} time seconds the asking cloth has stepped, for a source of
+     *   one's own that wants a clock per cloth; the engine's sources read the
+     *   scene's and ignore it
      * @returns {Float64Array|number[]} `out`, for chaining
      */
     sample(out: Float64Array | number[], x: number, y: number, z: number, time: number): Float64Array | number[];

package/src/engine/physics/cloth/wind/AbstractClothWind.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractClothWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/AbstractClothWind.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IAEI;;;;;;;;;;;;OAYG;IACH,YAJW,MAAM,gCAEJ,IAAI,CAIhB;IAED;;;;;;;;;;;;;;OAcG;IACH,cARW,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YARW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,GAEJ,YAAY,GAAC,MAAM,EAAE,CAQjC;CACJ"}
+{"version":3,"file":"AbstractClothWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/AbstractClothWind.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAEI;;;;;;;;;;;OAWG;IACH,YAJW,MAAM,gCAEJ,IAAI,CAIhB;IAED;;;;;;;;;;;;;;OAcG;IACH,cARW,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YATW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,GAGJ,YAAY,GAAC,MAAM,EAAE,CAQjC;CACJ"}

package/src/engine/physics/cloth/wind/AbstractClothWind.js

@@ -2,12 +2,13 @@
  * # Where the air comes from — one interface, two answers
  *
  * §10's design in one sentence: this engine has something better than a wind
- * zone, so cloth should **sample** the air rather than invent it. Two things can
- * answer "how fast is the air at this point": a running fluid simulation
- * ({@link ClothFluidWind}), and an ambient model for everywhere a simulation is
- * not ({@link ClothAmbientWind}). §10 asks for both to be read "through *the
- * same interface*, so the cloth code has one path and does not branch on whether
- * a simulation is present", and this is that interface.
+ * zone, so cloth should **sample** the air rather than invent it. What answers
+ * "how fast is the air at this point" is the scene's fluid: the GPU wind
+ * (`ClothGPUFluidWind`, the default for a scene with a `GPUFluidSystem`), or the
+ * CPU fields (`ClothFluidWind`). Either answers the scene's **far field** — its
+ * `GlobalFluidEffector`s, folded by `FluidEffectorsSystem` — wherever the
+ * simulation does not reach, through *the same interface*, so the cloth code has
+ * one path and does not branch on whether a simulation is present.
  *
  * It is two questions rather than one, and the second is what makes the feature
  * affordable:
@@ -15,33 +16,33 @@
  * - {@link sample} answers the air's **world** velocity at a world point, in
  *   metres per second.
  * - {@link varies} answers whether it is worth asking {@link sample} more than
- *   once for a given box. An ambient source answers `false` for every box and a
- *   whole garment costs one sample; a fluid source answers `true` only where one
- *   of its fields actually reaches, which is §10's "a cloth outside every fluid
- *   field's bounds skips it entirely" expressed as a question the cloth can ask.
+ *   once for a given box. A source answering `false` costs a whole garment one
+ *   sample; a fluid source answers `true` only where it has something that
+ *   varies, which is §10's "a cloth outside every fluid field's bounds skips it
+ *   entirely" expressed as a question the cloth can ask.
  *
  * ## Determinism, because two systems share one of these
  *
  * `ClothSystem` and `WorkerClothSystem` share a {@link ClothWorld} and therefore
- * share its wind source, and §12's bit-parity gate is over the whole
- * `ClothState` buffer at every step. The air is sampled **once**, by the world,
- * into that buffer — so the two systems do not agree about the wind, they read
- * the same bytes of it. What this interface has to promise is only that
- * {@link sample} is a pure function of (its `time` argument, the point), with no
- * wall clock and no random source: a gust that consulted `Date.now()` would make
- * two runs of the same scene differ and would take the parity spec's guarantee
- * with it.
+ * share its wind source, and §12's parity gate is over the whole `ClothState`
+ * buffer at every step. The air is sampled **once**, by the world, on the main
+ * thread, into that buffer — so the two systems do not agree about the wind,
+ * they read the same bytes of it.
  *
- * **And the clock is the cloth's own age, not the world's.** M6 made the world
- * clock count steps rather than ticks so that a cloth's *first* step got the
- * same weather under both systems, and that is right for the first cloth in a
- * scene and wrong for every one after it: while cloth B's registration is in
- * flight, cloth A is still being advanced, so the world clock moves and B's
- * first step lands at a different time under the worker than under the inline
- * system. Measured at a two-tick delivery: 0.1000 s against 0.1333 s, a
- * divergence at B's step 1, byte 0. So `time` is **seconds this instance has
- * stepped**, which is the same number on both sides by construction.
- * `MEASUREMENTS.md` §57.
+ * **The clock is the scene's** (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12,
+ * G2). The far field's gust is integrated once a tick by `FluidEffectorsSystem`,
+ * so a cloth steps in the weather of the tick it is advanced on — and a worker
+ * cloth is advanced from the tick its registration is acknowledged, not the tick
+ * it was linked (`MEASUREMENTS.md` §39, §57). So the gate holds for cloths
+ * registered on the same tick under both systems, and for any registration
+ * under a time-invariant wind; under a gust, a cloth the worker registers later
+ * steps in later weather. And the GPU wind arrives when the GPU answers, so two
+ * runs of a scene need not read the same air at all: run-to-run repeatability
+ * under the GPU wind is given up (F4). `MEASUREMENTS.md` §69.
+ *
+ * This replaced M6's answer, where the gust was a pure function of the asking
+ * cloth's own age (`ClothAmbientWind`, retired): one wind, read one way, beat a
+ * second clock that only cloth kept.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -50,12 +51,11 @@ export class AbstractClothWind {
 
     /**
      * Called once per fixed step, before any cloth is advanced, so a source that
-     * reads the **scene** — every live fluid field and its world box — can walk
-     * it once rather than once a cloth.
+     * reads the **scene** — every live fluid field and its world box, the far
+     * field, the GPU's lattices — can take it once rather than once a cloth.
      *
      * `time` is the cloth world's own accumulated fixed-step clock rather than a
-     * wall clock. It is *not* what a gust is a function of: see the note above,
-     * and {@link sample}'s own `time`.
+     * wall clock.
      *
      * @param {number} time seconds of fixed step this world has stepped
      * @param {EntityComponentDataset} ecd for a source that reads components
@@ -93,15 +93,16 @@ export class AbstractClothWind {
      * assumption that its callers want a direction times a magnitude. Cloth is
      * not such a caller — its drag row is an acceleration toward a velocity, and
      * a velocity in cells is a garment that blows differently depending on how
-     * finely someone voxelised the room. {@link ClothFluidWind} multiplies by
+     * finely someone voxelised the room. `ClothFluidWind` multiplies by
      * `cell_size`. `MEASUREMENTS.md` §45.
      *
      * @param {Float64Array|number[]} out length 3
      * @param {number} x world-space, metres
      * @param {number} y
      * @param {number} z
-     * @param {number} time seconds the asking cloth has stepped — see the note
-     *   above for why this is the cloth's own age and not the world's clock
+     * @param {number} time seconds the asking cloth has stepped, for a source of
+     *   one's own that wants a clock per cloth; the engine's sources read the
+     *   scene's and ignore it
      * @returns {Float64Array|number[]} `out`, for chaining
      */
     sample(out, x, y, z, time) {

package/src/engine/physics/cloth/wind/ClothFluidWind.d.ts

@@ -1,16 +1,23 @@
 /**
- * # The air, read out of the fluid simulation that is already running
+ * # The air, read out of the CPU fluid simulation that is already running
  *
  * §10's whole argument: this engine has a fluid simulator, `FluidObstacle`
  * already voxelises physics colliders into it, so a character running past a
  * cape gets a **wake** without anything cloth-specific being authored. This is
- * the source that reads it — every enabled {@link FluidComponent} in the scene,
- * sampled trilinearly where a particle actually is.
+ * the source that reads the **CPU** one — every enabled {@link FluidComponent}
+ * in the scene, sampled trilinearly where a particle actually is. A scene with
+ * the GPU wind reads it through `ClothGPUFluidWind` instead.
  *
- * Where no field reaches, {@link ambient} answers instead, so this is the one
- * source a scene needs rather than a thing to switch between: a banner inside a
- * wind tunnel volume reads the tunnel, the same banner carried outside reads the
- * prevailing weather, and the cloth never learns which happened.
+ * Where no field reaches, the answer is the scene's **far field**: what its
+ * `GlobalFluidEffector`s make of the air nothing else touches, as
+ * {@link FluidEffectorsSystem} folds them once a tick — the same far field every
+ * CPU field relaxes toward and the GPU wind blends to
+ * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6). So this is the one source a
+ * CPU-fluid scene needs rather than a thing to switch between: a banner inside
+ * a wind tunnel volume reads the tunnel, the same banner carried outside reads
+ * the prevailing weather and its gust, and the cloth never learns which
+ * happened. The gust runs on the scene's clock (G2), so `sample`'s `time` is not
+ * read.
  *
  * ## Two units problems, and they are the reason this class exists at all
  *
@@ -28,36 +35,46 @@
  *   before that is a null dereference rather than a zero, so an unbuilt field is
  *   skipped exactly like a disabled one.
  *
- * ## The field list is rebuilt once a step, not once a cloth
+ * ## The field list and the far field are taken once a step, not once a cloth
  *
  * {@link begin} walks the dataset and caches each live field with its world
- * box. Every cloth's {@link varies} and every particle's {@link sample} then
- * read that cache, so a scene with twenty garments and one wind volume walks the
- * dataset once. `FluidSystem` does the equivalent per field for its effectors
- * and notes the same trade.
+ * box, and reads the far field. Every cloth's {@link varies} and every
+ * particle's {@link sample} then read that cache, so a scene with twenty
+ * garments and one wind volume walks the dataset once. `FluidSystem` does the
+ * equivalent per field for its effectors and notes the same trade.
  *
  * ## What it does not do
  *
  * **It does not blend at a field's edge.** A point inside a field's box reads
- * the field and a point outside reads the ambient, so a garment straddling the
- * boundary sees a step in the air rather than a ramp. In a scene where the
- * ambient is the far field the volume relaxes toward — `GlobalFluidEffector`'s
- * `wind` — the step is small and mostly the disturbance the volume exists to
- * carry; where it is not, it is visible, and the answer is a volume large enough
- * to hold what moves through it. **Overlapping fields are resolved by order**,
- * first match wins, which is the same arbitrary-but-deterministic rule
- * `FluidSystem` applies when it steps them independently.
+ * the field and a point outside reads the far field, so a garment straddling the
+ * boundary sees a step in the air rather than a ramp. A CPU field relaxes toward
+ * that same far field, so the step is small and mostly the disturbance the
+ * volume exists to carry. **Overlapping fields are resolved by order**, first
+ * match wins, which is the same arbitrary-but-deterministic rule `FluidSystem`
+ * applies when it steps them independently.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 export class ClothFluidWind extends AbstractClothWind {
     /**
-     * What the air is where no field reaches. Present rather than optional
-     * because "outside every fluid volume" is most of the world.
-     * @type {ClothAmbientWind}
+     * @param {import("../../fluid/ecs/FluidEffectorsSystem.js").FluidEffectorsSystem} effectors the
+     *   system that folds the scene's `GlobalFluidEffector`s into its far field — read where no field
+     *   reaches; still air before its first tick
      */
-    ambient: ClothAmbientWind;
+    constructor(effectors: import("../../fluid/ecs/FluidEffectorsSystem.js").FluidEffectorsSystem);
+    /**
+     * Where the far field comes from.
+     * @type {import("../../fluid/ecs/FluidEffectorsSystem.js").FluidEffectorsSystem}
+     * @private
+     */
+    private __effectors;
+    /**
+     * The far field this step, as a {@link FluidAtmosphere} record.
+     * @type {Float64Array}
+     * @private
+     */
+    private __atmosphere;
     /**
      * Live fields this step: the component and its world box, six words each.
      * @type {FluidComponent[]}
@@ -74,7 +91,11 @@ export class ClothFluidWind extends AbstractClothWind {
      * @private
      */
     private __count;
+    /**
+     * The system whose far field this answers outside the fields.
+     * @returns {import("../../fluid/ecs/FluidEffectorsSystem.js").FluidEffectorsSystem}
+     */
+    get effectors(): import("../../fluid/ecs/FluidEffectorsSystem.js").FluidEffectorsSystem;
 }
 import { AbstractClothWind } from "./AbstractClothWind.js";
-import { ClothAmbientWind } from "./ClothAmbientWind.js";
 //# sourceMappingURL=ClothFluidWind.d.ts.map

package/src/engine/physics/cloth/wind/ClothFluidWind.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothFluidWind.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH;IAEI;;;;OAIG;IACH,SAFU,gBAAgB,CAEO;IAEjC;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;CA6Gf;kCA/LiC,wBAAwB;iCACzB,uBAAuB"}
+{"version":3,"file":"ClothFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothFluidWind.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH;IAmCI;;;;OAIG;IACH,uBAJW,OAAO,yCAAyC,EAAE,oBAAoB,EAWhF;IA7CD;;;;OAIG;IACH,oBAAY;IAEZ;;;;OAIG;IACH,qBAAwD;IAExD;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;IAgBZ;;;OAGG;IACH,wFAEC;CAkHJ;kCArOiC,wBAAwB"}