@woosh/meep-engine 3.49.0 → 3.50.0

package/src/engine/physics/cloth/collider/cloth_collider_sdf.js

@@ -1,30 +1,24 @@
 import { pose3_apply_inverse_point_array } from "../../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
 import { pose3_apply_point_array } from "../../../../core/geom/3d/pose/pose3_apply_point_array.js";
 import { quat3_nlerp_array } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
-import { sdf3_box_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_box.js";
-import { sdf3_capsule_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_capsule.js";
-import { sdf3_cylinder_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_cylinder.js";
-import { sdf3_plane_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_plane.js";
-import { sdf3_sphere_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_sphere.js";
+import { shape_record_signed_distance_gradient_array } from "../../../../core/geom/3d/shape/record/shape_record_signed_distance.js";
 import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import {
     CCR_INTERP_QX,
     CCR_INTERP_TX,
     CCR_INTERP_TY,
     CCR_INTERP_TZ,
-    CCR_KIND,
-    CCR_PARAM_0,
     CCR_PREV_QX,
     CCR_PREV_TX,
     CCR_PREV_TY,
     CCR_PREV_TZ,
     CCR_QX,
+    CCR_SHAPE,
     CCR_STRIDE,
     CCR_TX,
     CCR_TY,
     CCR_TZ
 } from "./ClothColliderRecord.js";
-import { ClothColliderKind } from "./ClothColliderKind.js";
 
 /**
  * # Evaluating a packed collider
@@ -40,11 +34,12 @@ import { ClothColliderKind } from "./ClothColliderKind.js";
  * costs less than storing an inverse and is exact rather than cached.
  *
  * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions,
- * so this dispatch, through their array forms, and {@link SphereShape3D} and
- * the rest, through their scalar forms, are calling one implementation
- * (§14.1). Before M2 those shapes fell back to
- * `compute_signed_distance_gradient_by_sampling` — four field evaluations and a
- * normalise, for shapes whose gradients are two lines of algebra.
+ * and the dispatch over a record's kind in `core/geom/3d/shape/record/`, so
+ * this, through their array forms, and {@link SphereShape3D} and the rest,
+ * through their scalar forms, are calling one implementation (§14.1). Before
+ * M2 those shapes fell back to `compute_signed_distance_gradient_by_sampling`
+ * — four field evaluations and a normalise, for shapes whose gradients are two
+ * lines of algebra.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -144,21 +139,9 @@ export function cloth_collider_signed_distance_array(out, out_offset, table, rec
         point, point_offset
     );
 
-    const kind = table[r + CCR_KIND];
-
-    // A record's shape parameters sit in a row from `CCR_PARAM_0`, in the order each field's array
-    // form reads them.
-    if (kind === ClothColliderKind.Sphere) {
-        sdf3_sphere_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
-    } else if (kind === ClothColliderKind.Capsule) {
-        sdf3_capsule_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
-    } else if (kind === ClothColliderKind.Box) {
-        sdf3_box_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
-    } else if (kind === ClothColliderKind.Cylinder) {
-        sdf3_cylinder_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
-    } else {
-        sdf3_plane_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
-    }
+    // The shape cells are a core shape record. Cloth packs no hull, so the
+    // plane array is never read.
+    shape_record_signed_distance_gradient_array(LOCAL_RESULT, 0, table, r + CCR_SHAPE, NO_PLANES, LOCAL_POINT, 0);
 
     // The gradient is a direction, so it takes the rotation and not the
     // translation.
@@ -263,6 +246,13 @@ const LOCAL_RESULT = new Float64Array(4);
  */
 const LOCAL_POINT = new Float64Array(3);
 
+/**
+ * The plane array a hull record would read. Cloth packs only the analytic kinds.
+ * @type {Float64Array}
+ * @private
+ */
+const NO_PLANES = new Float64Array(0);
+
 /**
  * The scalar forms' point, packed for the array forms they delegate to.
  * @type {Float64Array}

package/src/engine/physics/cloth/ecs/ClothInstance.d.ts

@@ -616,16 +616,13 @@ export class ClothInstance {
      */
     air_varies: boolean;
     /**
-     * Seconds of fixed step **this instance** has taken, which is the clock
-     * §10's gust is a function of.
+     * Seconds of fixed step **this instance** has taken, handed to the wind
+     * source's `sample` as its `time`.
      *
-     * Per cloth rather than per world, and the difference only shows with more
-     * than one of them. A cloth registered with the worker while another is
-     * already running waits for its memory, and the world's clock moves during
-     * that wait because the other cloth is still being advanced — so the two
-     * systems reach *this* cloth's first step at different world times and hand
-     * it different weather. An age counted in its own steps is the same number
-     * on both sides by construction. `MEASUREMENTS.md` §57.
+     * It was the clock §10's gust was a function of (`MEASUREMENTS.md` §57):
+     * the same number under both systems by construction, however late the
+     * worker registered the cloth. The gust now runs on the scene's clock (G2,
+     * §69) and no engine source reads this; a source of one's own may.
      *
      * Advanced on every step the instance is *offered*, including ones it
      * sleeps through, because a sleeping cloth still has to be able to ask

package/src/engine/physics/cloth/ecs/ClothInstance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAEI;;;;OAIG;IACH,QAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,OAFU,QAAM,IAAI,CAEP;IAEb;;;;OAIG;IACH,WAFU,WAAW,GAAC,IAAI,CAET;IAEjB;;;;OAIG;IACH,cAFU,MAAM,CAEE;IAElB;;;;;;OAMG;IACH,aAFU,UAAU,GAAC,IAAI,CAEN;IAEnB;;;;;;;;;;;OAWG;IACH,eAFU,YAAY,GAAC,IAAI,CAEN;IAErB;;;;;OAKG;IACH,OAFU,WAAW,CAEV;IAEX;;;OAGG;IACH,WAFU,UAAU,GAAC,IAAI,CAER;IAEjB;;;OAGG;IACH,gBAFU,UAAU,GAAC,IAAI,CAEH;IAEtB;;;;;OAKG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,eAFU,UAAU,GAAC,IAAI,CAEJ;IAErB;;;;OAIG;IACH,aAFU,YAAY,GAAC,IAAI,CAER;IAEnB;;;;;OAKG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;OAGG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;;OAMG;IACH,aAFU,OAAO,CAEE;IAEnB;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;;;;OAMG;IACH,QAFU,OAAO,CAEF;IAEf;;OAEG;IACH,OAFU,aAAW,IAAI,CAEZ;IAEb;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,aAFU,UAAU,GAAC,IAAI,CAEN;IAEnB;;;;;;;;OAQG;IACH,aAFU,UAAU,GAAC,IAAI,CAEN;IAEnB;;;;;;;;;OASG;IACH,KAFU,WAAS,IAAI,CAEZ;IAEX;;;;OAIG;IACH,gBAFU,WAAW,EAAE,CAEH;IAEpB;;;;;;OAMG;IACH,YAFU,UAAU,GAAC,MAAM,EAAE,CAEb;IAEhB;;;;;;;;;;;;OAYG;IACH,YAFU,WAAW,CAEU;IAE/B;;;;;;;;;;;OAWG;IACH,iBAFU,qBAAqB,CAEV;IAErB;;;;OAIG;IACH,qBAFU,YAAY,GAAC,IAAI,CAEA;IAE3B;;;OAGG;IACH,qBAFU,YAAY,GAAC,IAAI,CAEA;IAE3B;;;OAGG;IACH,mBAFU,UAAU,GAAC,IAAI,CAEA;IAEzB;;;OAGG;IACH,YAFU,UAAU,GAAC,IAAI,CAEP;IAElB;;;;;;;;;OASG;IACH,eAFU,UAAU,GAAC,IAAI,CAEJ;IAErB;;;OAGG;IACH,eAFU,UAAU,GAAC,IAAI,CAEJ;IAErB;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,kBAFU,WAAW,EAAE,CAED;IAEtB;;;;OAIG;IACH,mBAFU,qBAAqB,CAER;IAEvB;;;OAGG;IACH,kBAFU,UAAU,GAAC,IAAI,CAED;IAExB;;;;;;;;OAQG;IACH,UAFU,YAAY,GAAC,IAAI,CAEX;IAEhB;;;;;OAKG;IACH,eAFU,YAAY,GAAC,IAAI,CAEN;IAErB;;;OAGG;IACH,eAFU,YAAY,GAAC,IAAI,CAEN;IAErB;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAFU,YAAY,GAAC,IAAI,CAEF;IAEzB;;;OAGG;IACH,mBAFU,YAAY,GAAC,IAAI,CAEF;IAEzB;;;;;;;;;;OAUG;IACH,kBAFU,YAAY,GAAC,IAAI,CAEH;IAExB;;;;;;;;;OASG;IACH,kBAFU,YAAY,GAAC,IAAI,CAEH;IAExB;;;;;OAKG;IACH,WAFU,UAAU,GAAC,IAAI,CAER;IAEjB;;;;OAIG;IACH,YAFU,UAAU,GAAC,IAAI,CAEP;IAElB;;;;;;;;OAQG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;IAEZ;;;;;OAKG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;IAEZ;;;;;OAKG;IACH,OAFU,UAAU,GAAC,IAAI,CAEZ;IAEb;;;;OAIG;IACH,aAFU,YAAY,GAAC,IAAI,CAER;IAEnB;;;OAGG;IACH,gBAFU;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAC,GAAC,IAAI,CAE/B;IAEtB;;;;OAIG;IACH,WAFU,YAAY,CAEU;IAEhC;;;;;OAKG;IACH,UAFU,UAAU,GAAC,IAAI,CAET;IAEhB;;;;OAIG;IACH,gBAFU,UAAU,GAAC,IAAI,CAEH;IAEtB;;;OAGG;IACH,kBAFU,UAAU,GAAC,IAAI,CAED;IAExB;;;;OAIG;IACH,mBAFU,UAAU,GAAC,IAAI,CAEA;IAEzB;;;;OAIG;IACH,eAFU,YAAY,GAAC,IAAI,CAEN;IAErB;;;OAGG;IACH,UAFU,UAAU,GAAC,IAAI,CAET;IAEhB;;;OAGG;IACH,YAFU,UAAU,GAAC,IAAI,CAEP;IAElB;;;;OAIG;IACH,UAFU,UAAU,GAAC,IAAI,CAET;IAEhB;;;;;;;OAOG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,mBAFU,YAAY,CAEkB;IAExC;;;OAGG;IACH,gBAFU,YAAY,CAE0B;IAEhD;;;;;OAKG;IACH,aAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,eAFU,aAAa,CAEa;IAEpC;;;;;OAKG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;;;OAQG;IACH,QAFU,OAAO,CAEF;IAEf;;;;;;;;OAQG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;OASG;IACH,cAFU,OAAO,CAEI;IAErB;;;;;;;;;OASG;IACH,4BAFU,OAAO,CAEkB;IAEnC;;;;;;;OAOG;IACH,iBAFU;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,UAAU,CAAA;KAAC,GAAC,IAAI,CAEjC;IAEvB;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;OAKG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;;;OASG;IACH,UAFU,YAAY,CAES;IAE/B;;;;;;OAMG;IACH,YAFU,OAAO,CAEE;IAEnB;;;;;;;;;;;;;OAaG;IACH,KAFU,MAAM,CAER;IAER;;;;;;;;;;;OAWG;IACH,eAFU,UAAU,CAEiC;IAErD;;OAEG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,oBAFU,WAAW,CAEsC;IAE3D;;;;;OAKG;IACH,6BAFU,WAAW,CAE+C;IAEpE;;;;;;OAMG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,aAFU,MAAM,EAAE,GAAC,IAAI,CAEJ;IAEnB;;;;;;;;;;OAUG;IACH,iBAFU,YAAY,GAAC,IAAI,CAEJ;IAEvB;;;;;OAKG;IACH,gBAFU,MAAM,CAEG;CACtB;4BA7wB2B,uCAAuC;8BAErC,oBAAoB"}

package/src/engine/physics/cloth/ecs/ClothInstance.js

@@ -693,16 +693,13 @@ export class ClothInstance {
     air_varies = false;
 
     /**
-     * Seconds of fixed step **this instance** has taken, which is the clock
-     * §10's gust is a function of.
+     * Seconds of fixed step **this instance** has taken, handed to the wind
+     * source's `sample` as its `time`.
      *
-     * Per cloth rather than per world, and the difference only shows with more
-     * than one of them. A cloth registered with the worker while another is
-     * already running waits for its memory, and the world's clock moves during
-     * that wait because the other cloth is still being advanced — so the two
-     * systems reach *this* cloth's first step at different world times and hand
-     * it different weather. An age counted in its own steps is the same number
-     * on both sides by construction. `MEASUREMENTS.md` §57.
+     * It was the clock §10's gust was a function of (`MEASUREMENTS.md` §57):
+     * the same number under both systems by construction, however late the
+     * worker registered the cloth. The gust now runs on the scene's clock (G2,
+     * §69) and no engine source reads this; a source of one's own may.
      *
      * Advanced on every step the instance is *offered*, including ones it
      * sleeps through, because a sleeping cloth still has to be able to ask

package/src/engine/physics/cloth/ecs/ClothSystem.d.ts

@@ -89,8 +89,9 @@ export class ClothSystem extends System<any> {
      */
     set wind(value: any);
     /**
-     * Where the air comes from — see {@link ClothWorld#wind}. `null` by default,
-     * which is a scene with no wind in it.
+     * Where the air comes from — see {@link ClothWorld#wind}. By default the
+     * scene's wind (its GPU wind domain, or its far field), `null` in a scene
+     * with neither; an assigned source wins.
      * @returns {AbstractClothWind|null}
      */
     get wind(): any;

package/src/engine/physics/cloth/ecs/ClothSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothSystem.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;;IAEI,oDAAoC;IAEpC,ghBAiBE;IAEF;;OAEG;IACH,OAFU,UAAU,CAEK;IAEzB;;;;;;;;;;;;OAYG;IACH,iBAAyD;IAEzD;;;;;;OAMG;IACH,qBAAkB;IAUlB;;OAEG;IACH,iCAEC;IAbD;;;OAGG;IACH,4BAEC;IAkBD;;OAEG;IACH,qBAEC;IAdD;;;;OAIG;IACH,gBAEC;IASD;;;;OAIG;IACH,iCAEC;IAGD;;;OAGG;IACH,uCAFa,QAAQ,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,gBAAc,SAAS,CAInC;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;CA2EJ;uBApTsB,wBAAwB;4BAKnB,uCAAuC;sBAE7C,YAAY;4CARU,uDAAuD;oCAI5F,0DAA0D;kCAS/B,uCAAuC;6BAC5C,qCAAqC;8BALpC,oBAAoB;6BACrB,mBAAmB;yBAEvB,eAAe;yBADf,eAAe;+BANT,mCAAmC;2BAUvC,iBAAiB"}
+{"version":3,"file":"ClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothSystem.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;;IAEI,oDAAoC;IAEpC,ghBAiBE;IAEF;;OAEG;IACH,OAFU,UAAU,CAEK;IAEzB;;;;;;;;;;;;OAYG;IACH,iBAAyD;IAEzD;;;;;;OAMG;IACH,qBAAkB;IAUlB;;OAEG;IACH,iCAEC;IAbD;;;OAGG;IACH,4BAEC;IAmBD;;OAEG;IACH,qBAEC;IAfD;;;;;OAKG;IACH,gBAEC;IASD;;;;OAIG;IACH,iCAEC;IAGD;;;OAGG;IACH,uCAFa,QAAQ,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,gBAAc,SAAS,CAInC;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;CA2EJ;uBArTsB,wBAAwB;4BAKnB,uCAAuC;sBAE7C,YAAY;4CARU,uDAAuD;oCAI5F,0DAA0D;kCAS/B,uCAAuC;6BAC5C,qCAAqC;8BALpC,oBAAoB;6BACrB,mBAAmB;yBAEvB,eAAe;yBADf,eAAe;+BANT,mCAAmC;2BAUvC,iBAAiB"}

package/src/engine/physics/cloth/ecs/ClothSystem.js

@@ -131,8 +131,9 @@ export class ClothSystem extends System {
     }
 
     /**
-     * Where the air comes from — see {@link ClothWorld#wind}. `null` by default,
-     * which is a scene with no wind in it.
+     * Where the air comes from — see {@link ClothWorld#wind}. By default the
+     * scene's wind (its GPU wind domain, or its far field), `null` in a scene
+     * with neither; an assigned source wins.
      * @returns {AbstractClothWind|null}
      */
     get wind() {

package/src/engine/physics/cloth/ecs/ClothWorld.d.ts

@@ -132,43 +132,53 @@ export class ClothWorld {
      */
     colliders: ClothColliderSystem | null;
     /**
-     * Where the air comes from — §10. `null` means no air, which is the
-     * default and is **additive** in exactly the way the collider index is: a
-     * scene without one gets M5's cloth rather than an error, and adding one is
-     * the whole of turning wind on.
+     * @param {AbstractClothWind|null} value
+     */
+    set wind(value: any);
+    /**
+     * Where the air comes from — §10.
+     *
+     * **By default it follows the scene's wind**
+     * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12, F4), decided again at
+     * every {@link begin} from runtime facts:
      *
-     * Null rather than a still-air ambient, and the distinction is real. A
+     * - the scene has a GPU wind domain (an enabled `GPUFluidComponent`, as the
+     *   entity manager's `GPUFluidSystem` picks it): a {@link ClothGPUFluidWind}
+     *   over that system;
+     * - no domain, and the far field `FluidEffectorsSystem` folds is not zero:
+     *   a {@link ClothFluidWind} over that system, the CPU fields and the far
+     *   field outside them;
+     * - neither: `null`, no air.
+     *
+     * **Assigning a source wins**, whatever the scene holds — `null` included,
+     * which keeps a cloth out of the air in a windy scene.
+     *
+     * `null` means no air, and it is **additive** in exactly the way the collider
+     * index is: a scene without wind gets M5's cloth rather than an error.
+     * Null rather than a still-air source, and the distinction is real. A
      * source that answers zero everywhere is not "no wind": the drag row is a
      * relaxation toward the air, so still air still resists a *moving* cloth,
      * with the normal-facing factor making that resistance anisotropic. That is
      * better physics than `ClothDynamics#damping`'s isotropic decay and it is
-     * not free — so it is a thing a scene asks for. What a cloth does in air
-     * that is not moving is `damping`'s job (§7 P5, where it is load-bearing);
-     * what it does in air that *is* is this.
+     * not free — so a scene with no wind does not get it. What a cloth does in
+     * air that is not moving is `damping`'s job (§7 P5, where it is
+     * load-bearing); what it does in air that *is* is this.
      *
-     * Assign {@link ClothAmbientWind} for weather, {@link ClothFluidWind} to
-     * read the fluid simulation and fall back to weather outside it.
-     * @type {AbstractClothWind|null}
+     * @returns {AbstractClothWind|null}
      */
-    wind: AbstractClothWind | null;
+    get wind(): any;
     /**
-     * Seconds of fixed step this world has **stepped**, which is the clock a
-     * wind source's gust is a function of.
-     *
-     * Accumulated from `dt` rather than read from a wall clock, because
-     * {@link ClothSystem} and {@link WorkerClothSystem} share this object and
-     * §12's parity gate is over every byte of every step: two runs of the same
-     * scene have the same `dt` sequence and therefore the same weather.
+     * Seconds of fixed step this world has **stepped**, handed to a wind
+     * source's `begin`.
      *
-     * **Stepped rather than ticked**, and that distinction is load-bearing
-     * rather than pedantic. A cloth under the worker is not advanced until its
-     * registration is acknowledged (§39), so the two systems reach a cloth's
-     * *first* step at different tick counts — and a clock that counted ticks
-     * would hand that cloth a different gust on the same step under the two
-     * systems, which is a divergence the parity gate would report and the design
-     * would deserve. So the clock moves when {@link advance} first runs in a
-     * tick: the world's weather is a function of how much cloth time has
-     * passed, not of how long something has been asking.
+     * Accumulated from `dt` rather than read from a wall clock, and moved when
+     * {@link advance} first runs in a tick rather than at every tick, so a tick
+     * in which nothing is advanced does not move it (§39: a cloth under the
+     * worker is not advanced until its registration is acknowledged). No engine
+     * source reads it any more: the far field's gust runs on the scene's clock
+     * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md G2, `MEASUREMENTS.md` §69), and
+     * what `begin` is for is telling a source that reads the scene when to take
+     * it.
      * @type {number}
      */
     time: number;

package/src/engine/physics/cloth/ecs/ClothWorld.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AAwEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;;OAMG;IACH,uBAKE;IA0BF;;;;;OAKG;IACH,2CAaC;IAED;;;;;OAKG;IACH,YALW,KAAK,aACL,WAAW,UACX,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAehB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAOhB;IAmXD;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAuBnC;IAED;;;;;;;;OAQG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,UACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAyFD;;;;;;;;;;;;OAYG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CAmTnB;;CA0GJ;8BA5hD6B,oBAAoB;0CAnB3C,gEAAgE;oCAenC,0BAA0B;sBA+BxC,YAAY;4BAzC3B,uCAAuC"}
+{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IA8DjB;;OAEG;IACH,qBAGC;IAzCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,gBAEC;IAqED;;;;;;;;;;;;;OAaG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;;OAMG;IACH,uBAKE;IA0BF;;;;;OAKG;IACH,2CAaC;IAED;;;;;OAKG;IACH,YALW,KAAK,aACL,WAAW,UACX,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAehB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAOhB;IAmXD;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAuBnC;IAED;;;;;;;;OAQG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,UACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAoBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAyFD;;;;;;;;;;;;OAYG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CAmTnB;;CA0GJ;8BApoD6B,oBAAoB;0CAvB3C,gEAAgE;oCAmBnC,0BAA0B;sBA+BxC,YAAY;4BA7C3B,uCAAuC"}

package/src/engine/physics/cloth/ecs/ClothWorld.js

@@ -30,7 +30,11 @@ import {
     collect_entity_playbacks
 } from "../../../graphics3/pose/collect_entity_playbacks.js";
 import { MeshSkin } from "../../../graphics/ecs/mesh-v2/MeshSkin.js";
+import { FluidEffectorsSystem } from "../../fluid/ecs/FluidEffectorsSystem.js";
+import { FLUID_ATMOSPHERE_WORDS, FluidAtmosphere } from "../../fluid/FluidAtmosphere.js";
 import { cloth_air_changed, cloth_sample_air } from "../wind/cloth_sample_air.js";
+import { ClothFluidWind } from "../wind/ClothFluidWind.js";
+import { ClothGPUFluidWind } from "../wind/ClothGPUFluidWind.js";
 import { ClothStepParam } from "../solver/cloth_step_instance.js";
 import { ClothStepResult } from "../solver/ClothState.js";
 import { ClothColliderSystem } from "./ClothColliderSystem.js";
@@ -210,44 +214,144 @@ export class ClothWorld {
     colliders = null;
 
     /**
-     * Where the air comes from — §10. `null` means no air, which is the
-     * default and is **additive** in exactly the way the collider index is: a
-     * scene without one gets M5's cloth rather than an error, and adding one is
-     * the whole of turning wind on.
+     * The source assigned to {@link wind}, which wins over the default.
+     * @type {AbstractClothWind|null}
+     */
+    #assigned_wind = null;
+
+    /** Whether {@link wind} was assigned, `null` included. */
+    #wind_assigned = false;
+
+    /**
+     * The source the scene's wind gives cloth by default, as {@link begin} last
+     * found it — see {@link wind}.
+     * @type {AbstractClothWind|null}
+     */
+    #default_wind = null;
+
+    /** The GPU wind's source, kept for the system it was made over. @type {ClothGPUFluidWind|null} */
+    #gpu_wind = null;
+
+    /** The far field's source, kept for the system it was made over. @type {ClothFluidWind|null} */
+    #far_wind = null;
+
+    /** Scratch for the far field the default is decided by. */
+    #atmosphere = new Float64Array(FLUID_ATMOSPHERE_WORDS);
+
+    /**
+     * Where the air comes from — §10.
+     *
+     * **By default it follows the scene's wind**
+     * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12, F4), decided again at
+     * every {@link begin} from runtime facts:
+     *
+     * - the scene has a GPU wind domain (an enabled `GPUFluidComponent`, as the
+     *   entity manager's `GPUFluidSystem` picks it): a {@link ClothGPUFluidWind}
+     *   over that system;
+     * - no domain, and the far field `FluidEffectorsSystem` folds is not zero:
+     *   a {@link ClothFluidWind} over that system, the CPU fields and the far
+     *   field outside them;
+     * - neither: `null`, no air.
      *
-     * Null rather than a still-air ambient, and the distinction is real. A
+     * **Assigning a source wins**, whatever the scene holds — `null` included,
+     * which keeps a cloth out of the air in a windy scene.
+     *
+     * `null` means no air, and it is **additive** in exactly the way the collider
+     * index is: a scene without wind gets M5's cloth rather than an error.
+     * Null rather than a still-air source, and the distinction is real. A
      * source that answers zero everywhere is not "no wind": the drag row is a
      * relaxation toward the air, so still air still resists a *moving* cloth,
      * with the normal-facing factor making that resistance anisotropic. That is
      * better physics than `ClothDynamics#damping`'s isotropic decay and it is
-     * not free — so it is a thing a scene asks for. What a cloth does in air
-     * that is not moving is `damping`'s job (§7 P5, where it is load-bearing);
-     * what it does in air that *is* is this.
+     * not free — so a scene with no wind does not get it. What a cloth does in
+     * air that is not moving is `damping`'s job (§7 P5, where it is
+     * load-bearing); what it does in air that *is* is this.
      *
-     * Assign {@link ClothAmbientWind} for weather, {@link ClothFluidWind} to
-     * read the fluid simulation and fall back to weather outside it.
-     * @type {AbstractClothWind|null}
+     * @returns {AbstractClothWind|null}
      */
-    wind = null;
+    get wind() {
+        return this.#wind_assigned ? this.#assigned_wind : this.#default_wind;
+    }
 
     /**
-     * Seconds of fixed step this world has **stepped**, which is the clock a
-     * wind source's gust is a function of.
-     *
-     * Accumulated from `dt` rather than read from a wall clock, because
-     * {@link ClothSystem} and {@link WorkerClothSystem} share this object and
-     * §12's parity gate is over every byte of every step: two runs of the same
-     * scene have the same `dt` sequence and therefore the same weather.
+     * @param {AbstractClothWind|null} value
+     */
+    set wind(value) {
+        this.#assigned_wind = value;
+        this.#wind_assigned = true;
+    }
+
+    /**
+     * Decide the default source from the scene, once a tick: see {@link wind}.
+     * Allocates nothing once each source exists; a source is made once for the
+     * system it reads.
+     */
+    #resolve_default_wind() {
+        const em = this.entityManager;
+
+        if (this.#wind_assigned || em === null) {
+            return;
+        }
+
+        // the scene's GPU fluid, found by its flag: importing it needs WebGPU's
+        // globals, which a cloth scene on a server does not have
+        const systems = em.systems;
+
+        let gpu = null;
+
+        for (let i = 0; i < systems.length; i++) {
+            if (systems[i].isGPUFluidSystem === true) {
+                gpu = systems[i];
+                break;
+            }
+        }
+
+        if (gpu !== null && gpu.domain !== -1) {
+            if (this.#gpu_wind === null || this.#gpu_wind.fluid !== gpu) {
+                this.#gpu_wind = new ClothGPUFluidWind(gpu);
+            }
+
+            this.#default_wind = this.#gpu_wind;
+
+            return;
+        }
+
+        const effectors = em.getSystem(FluidEffectorsSystem);
+
+        if (effectors !== null) {
+            const atmosphere = this.#atmosphere;
+
+            effectors.read_atmosphere(atmosphere, 0);
+
+            if (atmosphere[FluidAtmosphere.VELOCITY_X] !== 0
+                || atmosphere[FluidAtmosphere.VELOCITY_Y] !== 0
+                || atmosphere[FluidAtmosphere.VELOCITY_Z] !== 0) {
+
+                if (this.#far_wind === null || this.#far_wind.effectors !== effectors) {
+                    this.#far_wind = new ClothFluidWind(effectors);
+                }
+
+                this.#default_wind = this.#far_wind;
+
+                return;
+            }
+        }
+
+        this.#default_wind = null;
+    }
+
+    /**
+     * Seconds of fixed step this world has **stepped**, handed to a wind
+     * source's `begin`.
      *
-     * **Stepped rather than ticked**, and that distinction is load-bearing
-     * rather than pedantic. A cloth under the worker is not advanced until its
-     * registration is acknowledged (§39), so the two systems reach a cloth's
-     * *first* step at different tick counts — and a clock that counted ticks
-     * would hand that cloth a different gust on the same step under the two
-     * systems, which is a divergence the parity gate would report and the design
-     * would deserve. So the clock moves when {@link advance} first runs in a
-     * tick: the world's weather is a function of how much cloth time has
-     * passed, not of how long something has been asking.
+     * Accumulated from `dt` rather than read from a wall clock, and moved when
+     * {@link advance} first runs in a tick rather than at every tick, so a tick
+     * in which nothing is advanced does not move it (§39: a cloth under the
+     * worker is not advanced until its registration is acknowledged). No engine
+     * source reads it any more: the far field's gust runs on the scene's clock
+     * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md G2, `MEASUREMENTS.md` §69), and
+     * what `begin` is for is telling a source that reads the scene when to take
+     * it.
      * @type {number}
      */
     time = 0;
@@ -985,6 +1089,10 @@ export class ClothWorld {
      * @param {number} dt seconds
      */
     begin(ecd, dt) {
+        // The scene's wind can arrive or go between ticks: a domain added or
+        // disabled, a far field rising from still air.
+        this.#resolve_default_wind();
+
         // Owed to the clock, and spent by the first `advance` — see {@link time}
         // for why the two are not the same moment. Assigned rather than set, so a
         // world whose source is taken away does not carry a debt.

package/src/engine/physics/cloth/playground/README.md

@@ -354,7 +354,11 @@ linked.
 is no wind model on this page. There is a `FluidField`, a `FluidSimulator`, a
 `GlobalFluidEffector` in its prevailing-wind regime, and a solid post standing in
 the flow; the banner reads the result through exactly the `ClothFluidWind` and
-`cloth_sample_air` a scene uses. The blue threads are the air on a horizontal
+`cloth_sample_air` a scene uses. The global acts as a scene's does, through the
+far field `FluidEffectorsSystem` folds it into, which the field is brought to
+each step and the cloth reads outside it — gust included, so the field gusts too
+(GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md G2; the numbers below were measured
+in M6, when cloth kept a gust of its own and the field did not gust). The blue threads are the air on a horizontal
 slice through the banner's waist, the red squares are the post.
 
 The cloth is driven like the solver and collision pages — `cloth_step` in
@@ -363,11 +367,11 @@ the ECS wiring, and `ecs/cloth_wind.spec.js` covers that more precisely.
 
 ## Three things to watch rather than read
 
-- **Turn the flow to 90° on `ambient only`.** The banner goes limp at the same
+- **Turn the flow to 90° on `far field only`.** The banner goes limp at the same
   wind speed: the *drag accel* readout falls from 43 m/s² to 0.08, and the mean
   facing factor from 0.221 to 0.000. That is §10's normal-facing factor, and it
   is the sharpest single result in M6.
-- **Do the same on `fluid field + ambient`, and it does not go limp.** 0.216 at
+- **Do the same on `fluid field + far field`, and it does not go limp.** 0.216 at
   0°, 0.280 at 90°. A wake has velocity in every direction, so no orientation of
   a banner is edge-on to one — which is something the simulation knows and a wind
   zone could not have told it.
@@ -384,7 +388,7 @@ the ECS wiring, and `ecs/cloth_wind.spec.js` covers that more precisely.
   times the cloth. It is on the page to be honest about where the frame goes: the
   simulation is the expensive half and cloth is renting it.
 - **air sample** and **sampled** — `cloth_sample_air`. Switch the source to
-  `ambient only` and watch it drop by a factor of twenty-five as "per particle"
+  `far field only` and watch it drop by a factor of twenty-five as "per particle"
   becomes "once for the cloth". That is §10's "a cloth outside every fluid field's
   bounds skips it entirely", and it is the reason the fallback is affordable.
 - **drag accel, mean** — the external acceleration with gravity taken back out:

package/src/engine/physics/cloth/playground/wind.html

@@ -133,19 +133,19 @@
 
     <h2>Air</h2>
     <p class="blurb">
-        On <em>ambient only</em>, turn the flow to 90° and the banner goes limp at the same wind
+        On <em>far field only</em>, turn the flow to 90° and the banner goes limp at the same wind
         speed — <em>drag accel</em> falls from 43 to 0.08. That is §10's normal-facing factor.
         On the <em>fluid field</em> it does not go limp: a wake has velocity in every direction,
         so nothing is edge-on to one. Take the post away and the air at the banner goes from
         6.0 to 8.7 m/s — that deficit is the projection's answer, not an authored falloff.
     </p>
     <label><span>source</span><select id="source">
-        <option value="field">fluid field + ambient</option>
-        <option value="ambient">ambient only</option>
+        <option value="field">fluid field + far field</option>
+        <option value="ambient">far field only</option>
     </select></label>
     <label><span>wind</span><input id="speed" type="range" min="0" max="20" step="0.5"><output id="speed_out"></output></label>
     <label><span>flow angle</span><input id="yaw" type="range" min="0" max="90" step="5"><output id="yaw_out"></output></label>
-    <label><span>ambient gust</span><input id="gust" type="range" min="0" max="6" step="0.1"><output id="gust_out"></output></label>
+    <label><span>gust</span><input id="gust" type="range" min="0" max="6" step="0.1"><output id="gust_out"></output></label>
     <label><span>grid</span><input id="resolution" type="range" min="8" max="28" step="2"><output id="resolution_out"></output></label>
 
     <div class="buttons">

package/src/engine/physics/cloth/playground/wind_build.d.ts

@@ -2,8 +2,9 @@
  * # The wind tunnel the banner hangs in
  *
  * A real {@link FluidField} stepped by a real {@link FluidSimulator}, with a
- * real {@link GlobalFluidEffector} driving the flow and a solid post standing in
- * it — which is the whole of §10's argument made visible. Nothing here is a
+ * real {@link GlobalFluidEffector} driving the flow — through the far field
+ * `FluidEffectorsSystem` folds it into, as in a scene — and a solid post
+ * standing in it, which is the whole of §10's argument made visible. Nothing here is a
  * wind model: the wake behind the post is the incompressible projection's
  * answer, and the cloth reads it through the same {@link FluidComponent} an
  * ordinary scene would.

package/src/engine/physics/cloth/playground/wind_build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wind_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/wind_build.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH;IAL2B,SAAS,EAAzB,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACU,MAAM,EAAxB,MAAM,EAAE;IACN,UAAU,CA2CtB;AAED;;;;;;;;;;GAUG;AACH,wCARW,UAAU;IAEO,OAAO,EAAxB,OAAO;IACS,CAAC,EAAjB,MAAM;IACU,CAAC,EAAjB,MAAM;IACU,MAAM,EAAtB,MAAM;IACJ,IAAI,CAwChB;;;;;eA3Ga,cAAc;eACd,cAAc;;;;cACd,mBAAmB;mBACnB,YAAY;eACZ,MAAM;gBACN,MAAM,EAAE;;+BAnCS,mCAAmC;+BAFnC,+BAA+B;oCAC1B,6CAA6C"}
+{"version":3,"file":"wind_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/wind_build.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH;IAL2B,SAAS,EAAzB,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACU,MAAM,EAAxB,MAAM,EAAE;IACN,UAAU,CA2CtB;AAED;;;;;;;;;;GAUG;AACH,wCARW,UAAU;IAEO,OAAO,EAAxB,OAAO;IACS,CAAC,EAAjB,MAAM;IACU,CAAC,EAAjB,MAAM;IACU,MAAM,EAAtB,MAAM;IACJ,IAAI,CAwChB;;;;;eA3Ga,cAAc;eACd,cAAc;;;;cACd,mBAAmB;mBACnB,YAAY;eACZ,MAAM;gBACN,MAAM,EAAE;;+BApCS,mCAAmC;+BAFnC,+BAA+B;oCAC1B,6CAA6C"}

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

@@ -7,8 +7,9 @@ import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
  * # The wind tunnel the banner hangs in
  *
  * A real {@link FluidField} stepped by a real {@link FluidSimulator}, with a
- * real {@link GlobalFluidEffector} driving the flow and a solid post standing in
- * it — which is the whole of §10's argument made visible. Nothing here is a
+ * real {@link GlobalFluidEffector} driving the flow — through the far field
+ * `FluidEffectorsSystem` folds it into, as in a scene — and a solid post
+ * standing in it, which is the whole of §10's argument made visible. Nothing here is a
  * wind model: the wake behind the post is the incompressible projection's
  * answer, and the cloth reads it through the same {@link FluidComponent} an
  * ordinary scene would.
@@ -70,7 +71,7 @@ export function build_wind_tunnel({ cell_size, resolution, origin }) {
     const effector = new GlobalFluidEffector();
 
     // Wind plus drag is `GlobalFluidEffector`'s "prevailing wind" regime: the
-    // air relaxes toward `wind`, so the volume's far field *is* the ambient the
+    // air relaxes toward `wind`, so the volume's far field *is* the air the
     // cloth reads outside it, and a garment carried out of the volume does not
     // walk into still air.
     // Six per second, so the volume reaches nine tenths of the driving wind