@woosh/meep-engine 3.47.0 → 3.50.0

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":"AAyEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CA6TnB;;CA0GJ;8BAtiD6B,oBAAoB;0CApB3C,gEAAgE;oCAgBnC,0BAA0B;sBA+BxC,YAAY;4BA1C3B,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,8 +30,11 @@ import {
     collect_entity_playbacks
 } from "../../../graphics3/pose/collect_entity_playbacks.js";
 import { MeshSkin } from "../../../graphics/ecs/mesh-v2/MeshSkin.js";
-import { CLOTH_SELF_RADIUS_MAX_RATIO, CLOTH_SELF_RADIUS_MIN_RATIO } from "../solver/cloth_solver_constants.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";
@@ -211,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;
@@ -986,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.
@@ -1472,20 +1579,10 @@ export class ClothWorld {
         params[offset + ClothStepParam.COLLIDER_COUNT] = state.collider_count;
         params[offset + ClothStepParam.SELF_COLLISION] = self_collision ? 1 : 0;
 
-        // Half the shortest row, so the row's diameter is one particle
-        // spacing. `ClothState#self_radius` carries why the fabric's own
-        // thickness is the wrong length here and `MEASUREMENTS.md` §31 is the
-        // sweep that settled it. A fabric thicker than its proxy is coarse
-        // keeps its thickness — and is then clamped under the closest pair
-        // the proxy has with no row between them, because a diameter that
-        // reaches that pair puts a cloth which is not folded at all in
-        // permanent contact with itself (§36, §37).
-        params[offset + ClothStepParam.SELF_RADIUS] = self_collision
-            ? Math.min(
-                Math.max(dynamics.thickness, instance.shortest_row * CLOTH_SELF_RADIUS_MIN_RATIO),
-                instance.closest_free_pair * CLOTH_SELF_RADIUS_MAX_RATIO
-            )
-            : 0;
+        // The self-collision radius is each particle's own — half its shortest
+        // row, over the thickness, under two fifths of its closest free pair —
+        // and the step derives it from the thickness word above
+        // (`cloth_self_radius_update`), so nothing about it crosses here.
 
         // Ramp back from nothing over the window. The first step after a
         // reset is allowed no velocity at all, which is what stops a

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

@@ -88,7 +88,7 @@ export class WorkerClothSystem extends WorkerSystem {
         max_cloth_count?: number;
     });
     dependencies: (typeof Transform64 | typeof Cloth)[];
-    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof TransformAttachment> | ResourceAccessSpecification<typeof GPUStateAuthority> | ResourceAccessSpecification<typeof ParentEntity> | ResourceAccessSpecification<typeof ClothCollider> | ResourceAccessSpecification<typeof Cloth> | ResourceAccessSpecification<typeof ClothExclude> | ResourceAccessSpecification<typeof ClothRig> | ResourceAccessSpecification<typeof ClothPin>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof TransformAttachment> | ResourceAccessSpecification<typeof GPUStateAuthority> | ResourceAccessSpecification<typeof ParentEntity> | ResourceAccessSpecification<typeof ClothCollider> | ResourceAccessSpecification<typeof Cloth> | ResourceAccessSpecification<typeof ClothExclude> | ResourceAccessSpecification<typeof ClothRig> | ResourceAccessSpecification<typeof ClothPin> | ResourceAccessSpecification<typeof FluidComponent>)[];
     /**
      * The cloths, and everything about stepping one that is not arithmetic.
      * Shared with {@link ClothSystem}, which is what makes the two systems one
@@ -187,5 +187,6 @@ import { ClothCollider } from "./ClothCollider.js";
 import { ClothExclude } from "./ClothExclude.js";
 import { ClothRig } from "./ClothRig.js";
 import { ClothPin } from "./ClothPin.js";
+import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
 import { ClothWorld } from "./ClothWorld.js";
 //# sourceMappingURL=WorkerClothSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"WorkerClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/WorkerClothSystem.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH;IAyEI;;;;;;;;OAQG;IACH;QAPiC,cAAc,EAApC,MAAM,MAAM;QAIK,eAAe,GAAhC,MAAM;OAYhB;IAzFD,oDAAoC;IAEpC,2dAYE;IAEF;;;;;OAKG;IACH,OAFU,UAAU,CAEK;IA6EzB;;OAEG;IACH,iCAEC;IAbD;;;OAGG;IACH,4BAEC;IAoBD;;OAEG;IACH,qBAEC;IAhBD;;;;;;OAMG;IACH,gBAEC;IASD;;OAEG;IACH,iCAEC;IA2BD;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAcD;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAQhB;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;IAED;;;;OAIG;IACH,iCAEC;;CAmOJ;6BArkB4B,oCAAoC;4BAIrC,uCAAuC;sBAE7C,YAAY;4CAPU,uDAAuD;oCAI5F,0DAA0D;kCAQ/B,uCAAuC;6BAC5C,qCAAqC;8BALpC,oBAAoB;6BACrB,mBAAmB;yBAEvB,eAAe;yBADf,eAAe;2BAIb,iBAAiB"}
+{"version":3,"file":"WorkerClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/WorkerClothSystem.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH;IA6EI;;;;;;;;OAQG;IACH;QAPiC,cAAc,EAApC,MAAM,MAAM;QAIK,eAAe,GAAhC,MAAM;OAYhB;IA7FD,oDAAoC;IAEpC,ghBAgBE;IAEF;;;;;OAKG;IACH,OAFU,UAAU,CAEK;IA6EzB;;OAEG;IACH,iCAEC;IAbD;;;OAGG;IACH,4BAEC;IAoBD;;OAEG;IACH,qBAEC;IAhBD;;;;;;OAMG;IACH,gBAEC;IASD;;OAEG;IACH,iCAEC;IA2BD;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAcD;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAQhB;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;IAED;;;;OAIG;IACH,iCAEC;;CAmOJ;6BA1kB4B,oCAAoC;4BAIrC,uCAAuC;sBAG7C,YAAY;4CARU,uDAAuD;oCAI5F,0DAA0D;kCAS/B,uCAAuC;6BAC5C,qCAAqC;8BALpC,oBAAoB;6BACrB,mBAAmB;yBAEvB,eAAe;yBADf,eAAe;+BALT,mCAAmC;2BASvC,iBAAiB"}

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

@@ -5,6 +5,7 @@ import {
     TransformAttachment
 } from "../../../ecs/transform-attachment/TransformAttachment.js";
 import { Transform64 } from "../../../ecs/transform/Transform64.js";
+import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
 import { ClothStepParam } from "../solver/cloth_step_instance.js";
 import { Cloth } from "./Cloth.js";
 import { ClothCollider } from "./ClothCollider.js";
@@ -117,7 +118,11 @@ export class WorkerClothSystem extends WorkerSystem {
         // model it belongs to and who composes its transform.
         ResourceAccessSpecification.from(ClothPin, ResourceAccessKind.Read),
         ResourceAccessSpecification.from(ParentEntity, ResourceAccessKind.Read),
-        ResourceAccessSpecification.from(GPUStateAuthority, ResourceAccessKind.Read)
+        ResourceAccessSpecification.from(GPUStateAuthority, ResourceAccessKind.Read),
+        // The air `ClothFluidWind` samples, on this thread in `collect`. As in
+        // `ClothSystem`, a cycle with the `Transform64` every fluid system reads,
+        // which the score decides for cloth (`cloth_wind.spec.js`).
+        ResourceAccessSpecification.from(FluidComponent, ResourceAccessKind.Read)
     ];
 
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAqEA;;;;GAIG;AACH,+DAFa,IAAI,CAsBhB;AAED;;;;;;;;;;GAUG;AACH,2DAFa,IAAI,CA6BhB;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CAgDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CAkOhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AA/iBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}
+{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAqEA;;;;GAIG;AACH,+DAFa,IAAI,CAsBhB;AAED;;;;;;;;;;GAUG;AACH,2DAFa,IAAI,CA6BhB;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CAgDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CA4OhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AAzjBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}

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

@@ -425,20 +425,30 @@ export function cloth_build_rows(instance, dt) {
     cloth_particle_of_source(particle_of_node, state.source_of_particle, node_count);
 
     // Everything derived from the rows, derived again — and from the bind pose,
-    // which is what `closest_free_pair` has to be measured in: the answer is a
-    // property of how the proxy was authored, not of whatever shape the solver
-    // happens to have the cloth in when self-collision is first switched on.
+    // which is what each particle's closest free pair has to be measured in: the
+    // answer is a property of how the proxy was authored, not of whatever shape
+    // the solver happens to have the cloth in when self-collision is first
+    // switched on.
     const exclusions = cloth_self_exclusions(state);
 
     instance.self_exclusions = exclusions;
 
-    // Bounded at twice the shortest row, which is where a sheet's answer lies,
-    // so the walk is 27 cells rather than the whole cloth. A proxy with nothing
-    // that close gets `Infinity`, and then no radius inside the floor can reach
-    // anything either.
-    instance.closest_free_pair = cloth_self_closest_free_pair(
-        state, exclusions, instance.shortest_row * 2
-    );
+    // Bounded at twice the longest of the particles' own shortest rows, which
+    // reaches every particle's two hops — a skirt's hem's as well as its
+    // waistband's — so the walk is 27 cells rather than the whole cloth. A
+    // particle with nothing that close gets `Infinity`, and then no radius
+    // inside its floor can reach anything either.
+    let longest_row = 0;
+
+    for (let i = 0; i < state.particle_count; i++) {
+        const row = state.self_row[i];
+
+        if (row < Infinity && row > longest_row) {
+            longest_row = row;
+        }
+    }
+
+    cloth_self_closest_free_pair(state, exclusions, longest_row * 2);
 
     instance.particle_of_node = particle_of_node;
     instance.blended_position = new Float64Array(node_count * 3);

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/collide.html

@@ -146,11 +146,13 @@
     <h2>Contact band</h2>
     <p class="blurb">
         M0 could not choose these: the ramp only means something for a row that <b>arrives</b>, and a
-        contact is the first one in the system that does. Measured defaults are
-        k_min = k_max/32 and β = 1e3.
+        contact is the first one in the system that does. The ramp is the fraction of the band a
+        contact gains per offset of violation per iteration. Measured defaults are
+        k_min = k_max/32 and a ramp of 0.1; drag the ramp down to 0.003, which is what β = 1e3 was
+        worth on a garment, and sweep the capsule through.
     </p>
     <label><span>k_min ÷ k_max</span><input id="k_floor" type="range" min="-7" max="0" step="0.25"><output id="k_floor_out"></output></label>
-    <label><span>β</span><input id="beta" type="range" min="0" max="7" step="0.25"><output id="beta_out"></output></label>
+    <label><span>ramp</span><input id="ramp" type="range" min="-3" max="1" step="0.125"><output id="ramp_out"></output></label>
     <div class="buttons"><button id="defaults">measured defaults</button></div>
 
     <h2>Sweep</h2>

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

@@ -85,7 +85,7 @@ const control = {
     substeps: 2,
     iterations: 4,
     k_floor: 1 / 32,
-    beta: CLOTH_SOLVER_TUNING.beta,
+    ramp: CLOTH_SOLVER_TUNING.contact_ramp_ratio,
     swept: true,
     animate: true,
     running: true
@@ -166,10 +166,11 @@ function step_once() {
 
     const tuning = {
         alpha: CLOTH_SOLVER_TUNING.alpha,
-        beta: control.beta,
+        beta: CLOTH_SOLVER_TUNING.beta,
         gamma: CLOTH_SOLVER_TUNING.gamma,
         k_min_ratio: CLOTH_SOLVER_TUNING.k_max_ratio,
-        k_max_ratio: CLOTH_SOLVER_TUNING.k_max_ratio
+        k_max_ratio: CLOTH_SOLVER_TUNING.k_max_ratio,
+        contact_ramp_ratio: control.ramp
     };
 
     const started = performance.now();
@@ -548,27 +549,27 @@ floor_input.addEventListener('input', () => {
         : `1/${(1 / control.k_floor).toFixed(1)}`;
 });
 
-const beta_input = element('beta');
-const beta_output = element('beta_out');
+const ramp_input = element('ramp');
+const ramp_output = element('ramp_out');
 
-beta_input.value = String(Math.log10(control.beta));
-beta_output.textContent = control.beta.toExponential(0);
+ramp_input.value = String(Math.log10(control.ramp));
+ramp_output.textContent = control.ramp.toPrecision(2);
 
-beta_input.addEventListener('input', () => {
-    control.beta = Math.pow(10, Number(beta_input.value));
+ramp_input.addEventListener('input', () => {
+    control.ramp = Math.pow(10, Number(ramp_input.value));
 
-    beta_output.textContent = control.beta.toExponential(0);
+    ramp_output.textContent = control.ramp.toPrecision(2);
 });
 
 element('defaults').addEventListener('click', () => {
     control.k_floor = 1 / 32;
-    control.beta = CLOTH_SOLVER_TUNING.beta;
+    control.ramp = CLOTH_SOLVER_TUNING.contact_ramp_ratio;
 
     floor_input.value = String(Math.log2(control.k_floor));
     floor_output.textContent = '1/32';
 
-    beta_input.value = String(Math.log10(control.beta));
-    beta_output.textContent = control.beta.toExponential(0);
+    ramp_input.value = String(Math.log10(control.ramp));
+    ramp_output.textContent = control.ramp.toPrecision(2);
 });
 
 const sweep_button = element('sweep');

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