@woosh/meep-engine 3.25.0 → 3.27.0

package/src/engine/physics/cloth/solver/cloth_contact_find.d.ts

@@ -12,9 +12,12 @@
  * @param {Float32Array|Float64Array} table packed colliders, cloth-local
  * @param {Int32Array} keys index handle per record in `table`
  * @param {number} count records in `table`
+ * @param {number} dt seconds, the fixed step the discovered rows will be used
+ *   across — how far a particle carries its current velocity before anything
+ *   gets a chance to stop it
  * @returns {number} how many contact rows were created
  */
-export function cloth_contact_find(state: ClothState, table: Float32Array | Float64Array, keys: Int32Array, count: number): number;
+export function cloth_contact_find(state: ClothState, table: Float32Array | Float64Array, keys: Int32Array, count: number, dt: number): number;
 /**
  * # Finding the contacts, once per step
  *
@@ -54,11 +57,30 @@ export function cloth_contact_find(state: ClothState, table: Float32Array | Floa
  * to the reach costs one subtraction per record per step and makes the whole
  * range from 2 to 40 m/s behave the same way. `MEASUREMENTS.md` §20.
  *
+ * **And it has to include how far the *particle* moves**, which M2 left out and
+ * argued its way past. The paragraph that used to stand here said a cloth
+ * approaching faster than half a metre a second is one "the velocity clamp of
+ * §7 P1 is already the bound on". It is not: that clamp is
+ * `shortest_row · substeps · iterations / dt` times four, which for a garment is
+ * about **154 m/s** — three orders of magnitude above the speed at which this
+ * margin stops covering the approach. A collider that does not move is not a
+ * collider a cloth cannot hit. Measured, one particle at 8 mm against a static
+ * 3 cm capsule with no gravity at 2 × 4: at 1 and 2 m/s the rows appear and hold
+ * it; at 3 m/s and above there is **no row on the step it crosses the axis**,
+ * and the row the next step finally makes is on the far side and pushes it the
+ * rest of the way out. So the reach carries `|v_i|·dt` per particle as well —
+ * one square root per particle per step, hoisted out of the record loop.
+ * `MEASUREMENTS.md` §54.
+ *
  * That is also the honest boundary of P3's "swept collision": the *set* is
- * swept by this margin, and the *poses* are swept by `cloth_collider_pose_at`.
- * Both are translation-first — a collider spinning fast enough that a point on
- * its surface travels more than its own radius within one substep is still
- * missed, and more substeps is the answer to that.
+ * swept by both margins, and the *poses* are swept by `cloth_collider_pose_at`.
+ * All of it is translation-first — a collider spinning fast enough that a point
+ * on its surface travels more than its own radius within one substep is still
+ * missed, and more substeps is the answer to that. And the *set* being right is
+ * necessary rather than sufficient: a row that exists is still evaluated at
+ * substep positions, so a particle crossing a whole collider inside one substep
+ * has a row that never sees it touching. That bound is `substeps` and nothing
+ * else, and §54 measures where it lands.
  *
  * ## Warm-starting across the rebuild
  *
@@ -78,9 +100,8 @@ export function cloth_contact_find(state: ClothState, table: Float32Array | Floa
  *
  * One, so a row exists from twice the offset inwards. At a garment's 8 mm that
  * is 8 mm of warning, which at 60 Hz covers half a metre a second of approach
- * before a substep can carry a particle past the discovery — and a cloth moving
- * faster than that relative to a collider is one the velocity clamp of §7 P1 is
- * already the bound on.
+ * on its own — and the rest of the approach, from either side, is what the two
+ * travel terms in {@link cloth_contact_find} add to it.
  * @type {number}
  */
 export const CLOTH_CONTACT_MARGIN: number;

package/src/engine/physics/cloth/solver/cloth_contact_find.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AA8FA;;;;;;;;;;;;;;;GAeG;AACH,6DALW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,GACJ,MAAM,CA4KlB;AAjQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;;;GAUG;AACH,mCAFU,MAAM,CAEsB"}
+{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DARW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,MACN,MAAM,GAGJ,MAAM,CAmLlB;AA7RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB"}

package/src/engine/physics/cloth/solver/cloth_contact_find.js

@@ -60,11 +60,30 @@ import { CLOTH_CONTACT_SLOTS } from "./constraint/cloth_contact_row.js";
  * to the reach costs one subtraction per record per step and makes the whole
  * range from 2 to 40 m/s behave the same way. `MEASUREMENTS.md` §20.
  *
+ * **And it has to include how far the *particle* moves**, which M2 left out and
+ * argued its way past. The paragraph that used to stand here said a cloth
+ * approaching faster than half a metre a second is one "the velocity clamp of
+ * §7 P1 is already the bound on". It is not: that clamp is
+ * `shortest_row · substeps · iterations / dt` times four, which for a garment is
+ * about **154 m/s** — three orders of magnitude above the speed at which this
+ * margin stops covering the approach. A collider that does not move is not a
+ * collider a cloth cannot hit. Measured, one particle at 8 mm against a static
+ * 3 cm capsule with no gravity at 2 × 4: at 1 and 2 m/s the rows appear and hold
+ * it; at 3 m/s and above there is **no row on the step it crosses the axis**,
+ * and the row the next step finally makes is on the far side and pushes it the
+ * rest of the way out. So the reach carries `|v_i|·dt` per particle as well —
+ * one square root per particle per step, hoisted out of the record loop.
+ * `MEASUREMENTS.md` §54.
+ *
  * That is also the honest boundary of P3's "swept collision": the *set* is
- * swept by this margin, and the *poses* are swept by `cloth_collider_pose_at`.
- * Both are translation-first — a collider spinning fast enough that a point on
- * its surface travels more than its own radius within one substep is still
- * missed, and more substeps is the answer to that.
+ * swept by both margins, and the *poses* are swept by `cloth_collider_pose_at`.
+ * All of it is translation-first — a collider spinning fast enough that a point
+ * on its surface travels more than its own radius within one substep is still
+ * missed, and more substeps is the answer to that. And the *set* being right is
+ * necessary rather than sufficient: a row that exists is still evaluated at
+ * substep positions, so a particle crossing a whole collider inside one substep
+ * has a row that never sees it touching. That bound is `substeps` and nothing
+ * else, and §54 measures where it lands.
  *
  * ## Warm-starting across the rebuild
  *
@@ -85,9 +104,8 @@ import { CLOTH_CONTACT_SLOTS } from "./constraint/cloth_contact_row.js";
  *
  * One, so a row exists from twice the offset inwards. At a garment's 8 mm that
  * is 8 mm of warning, which at 60 Hz covers half a metre a second of approach
- * before a substep can carry a particle past the discovery — and a cloth moving
- * faster than that relative to a collider is one the velocity clamp of §7 P1 is
- * already the bound on.
+ * on its own — and the rest of the approach, from either side, is what the two
+ * travel terms in {@link cloth_contact_find} add to it.
  * @type {number}
  */
 export const CLOTH_CONTACT_MARGIN = 1;
@@ -106,9 +124,12 @@ export const CLOTH_CONTACT_MARGIN = 1;
  * @param {Float32Array|Float64Array} table packed colliders, cloth-local
  * @param {Int32Array} keys index handle per record in `table`
  * @param {number} count records in `table`
+ * @param {number} dt seconds, the fixed step the discovered rows will be used
+ *   across — how far a particle carries its current velocity before anything
+ *   gets a chance to stop it
  * @returns {number} how many contact rows were created
  */
-export function cloth_contact_find(state, table, keys, count) {
+export function cloth_contact_find(state, table, keys, count, dt) {
     const particle_count = state.particle_count;
 
     const collider = state.contact_collider;
@@ -120,6 +141,7 @@ export function cloth_contact_find(state, table, keys, count) {
     const anchor = state.contact_anchor;
 
     const position = state.position;
+    const velocity = state.velocity;
     const mass_inverse = state.mass_inverse;
 
     const radius = state.contact_radius;
@@ -188,12 +210,18 @@ export function cloth_contact_find(state, table, keys, count) {
         const y = position[p + 1];
         const z = position[p + 2];
 
+        // How far this particle carries its current velocity across the step.
+        // Hoisted out of the record loop: it is a property of the particle, and
+        // the loop below is the hot one.
+        const travel = dt * Math.hypot(velocity[p], velocity[p + 1], velocity[p + 2]);
+
         let found = 0;
 
         for (let record = 0; record < count; record++) {
             const r = record * CCR_STRIDE;
 
-            const reach = (radius + table[r + CCR_INFLATION]) * (1 + CLOTH_CONTACT_MARGIN) + TRAVEL[record];
+            const reach = (radius + table[r + CCR_INFLATION]) * (1 + CLOTH_CONTACT_MARGIN)
+                + TRAVEL[record] + travel;
 
             if (x + reach < table[r + CCR_AABB_MIN_X] || x - reach > table[r + CCR_AABB_MAX_X]) {
                 continue;

package/src/engine/physics/cloth/solver/cloth_solver_constants.d.ts

@@ -37,8 +37,18 @@
  * two clear of divergence.** γ is left at 1 because its second job — decaying
  * the penalty — has nothing to do while the band is a single point, so putting
  * the whole decay in α, whose only job is the multiplier, is the truthful
- * placement. When M2's contacts make the band real again, γ becomes live and
- * has to be re-measured.
+ * placement.
+ *
+ * **γ is the one unmeasured constant in this file, and that is now a decision.**
+ * The sentence above used to end "when M2's contacts make the band real again, γ
+ * becomes live and has to be re-measured". M2 made the band real — a contact's
+ * floor is {@link CLOTH_CONTACT_K_MIN_RATIO} and its ceiling is
+ * {@link CLOTH_K_MAX_RATIO} — and the sweep was never run. Nothing measured
+ * since has asked for a decaying penalty; what a `γ < 1` *would* reach is the
+ * one thing PLAN §18 records as a coupling rather than a bug, which is that a
+ * contact's penalty ramps to the ceiling and never comes back down. Sweeping it
+ * means re-measuring every hard row in the system against `α·γ`, because the two
+ * act only through their product and `α` is the one that was measured.
  *
  * **`k_min` and `k_max` are equal, which disables the ramp.** Pinning the
  * penalty at the top of the band measured as good as or better than every

package/src/engine/physics/cloth/solver/cloth_solver_constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_solver_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solver_constants.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AAEH;;;GAGG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;GAIG;AACH,yBAFU,MAAM,CAEc;AAE9B;;;GAGG;AACH,0BAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;;;;;GASG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,mCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,kCAFU,SAAS;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAAC,CAQvG"}
+{"version":3,"file":"cloth_solver_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solver_constants.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AAEH;;;GAGG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;GAIG;AACH,yBAFU,MAAM,CAEc;AAE9B;;;GAGG;AACH,0BAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;;;;;GASG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,mCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,kCAFU,SAAS;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAAC,CAQvG"}

package/src/engine/physics/cloth/solver/cloth_solver_constants.js

@@ -37,8 +37,18 @@
  * two clear of divergence.** γ is left at 1 because its second job — decaying
  * the penalty — has nothing to do while the band is a single point, so putting
  * the whole decay in α, whose only job is the multiplier, is the truthful
- * placement. When M2's contacts make the band real again, γ becomes live and
- * has to be re-measured.
+ * placement.
+ *
+ * **γ is the one unmeasured constant in this file, and that is now a decision.**
+ * The sentence above used to end "when M2's contacts make the band real again, γ
+ * becomes live and has to be re-measured". M2 made the band real — a contact's
+ * floor is {@link CLOTH_CONTACT_K_MIN_RATIO} and its ceiling is
+ * {@link CLOTH_K_MAX_RATIO} — and the sweep was never run. Nothing measured
+ * since has asked for a decaying penalty; what a `γ < 1` *would* reach is the
+ * one thing PLAN §18 records as a coupling rather than a bug, which is that a
+ * contact's penalty ramps to the ceiling and never comes back down. Sweeping it
+ * means re-measuring every hard row in the system against `α·γ`, because the two
+ * act only through their product and `α` is the one that was measured.
  *
  * **`k_min` and `k_max` are equal, which disables the ramp.** Pinning the
  * penalty at the top of the band measured as good as or better than every

package/src/engine/physics/cloth/solver/cloth_step_instance.js

@@ -159,7 +159,7 @@ export function cloth_step_instance(state, self_exclusions, params, offset) {
     damp(state, params[offset + ClothStepParam.RETENTION]);
 
     const contact_count = cloth_contact_find(
-        state, state.collider_table, state.collider_key, collider_count
+        state, state.collider_table, state.collider_key, collider_count, dt
     );
 
     let self_pairs = 0;

package/src/engine/physics/cloth/solver/constraint/cloth_backstop_row.d.ts

@@ -36,8 +36,15 @@
  * garment's own skinned surface — `b` a short way inside along the vertex
  * normal, `r_b` that distance again — and a skinned garment is M3. M2's entity
  * path has a chain rather than a surface, so it has no normal to offer: a rope
- * has no inside. So the row ships with storage, a spec and a playground demo
- * driving it directly, and `cloth_proxy_build` is what will fill it.
+ * has no inside. So the row ships with storage and a spec, and
+ * `cloth_proxy_build` is what will fill it.
+ *
+ * **Nothing drives it in a scene.** This docblock used to say "and a playground
+ * demo driving it directly", and no page under `playground/` writes
+ * {@link ClothState#backstop_plane} — M3 arrived and filled nothing in either.
+ * What holds the row up is `cloth_backstop_row.spec.js` alone, which is the
+ * honest status of a row with no author: the arithmetic is gated, the
+ * integration is not.
  *
  * ## No trust region, and no geometric stiffness
  *

package/src/engine/physics/cloth/solver/constraint/cloth_backstop_row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_backstop_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_backstop_row.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH;;;;;;;;;;;GAWG;AACH,kDANW,YAAY,GAAC,MAAM,EAAE,mBACrB,MAAM,0BAEN,MAAM,GACJ,MAAM,CAuBlB;AAED;;;;;;GAMG;AACH,uDAJW,YAAY,+BAEZ,MAAM,QA8EhB;AAED;;;;;;;;;;GAUG;AACH,oEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QAuChB;AAED;;;;;;;GAOG;AACH,oEAJW,MAAM,eACN,MAAM,qBACN,MAAM,QA2ChB"}
+{"version":3,"file":"cloth_backstop_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_backstop_row.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH;;;;;;;;;;;GAWG;AACH,kDANW,YAAY,GAAC,MAAM,EAAE,mBACrB,MAAM,0BAEN,MAAM,GACJ,MAAM,CAuBlB;AAED;;;;;;GAMG;AACH,uDAJW,YAAY,+BAEZ,MAAM,QA8EhB;AAED;;;;;;;;;;GAUG;AACH,oEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QAuChB;AAED;;;;;;;GAOG;AACH,oEAJW,MAAM,eACN,MAAM,qBACN,MAAM,QA2ChB"}

package/src/engine/physics/cloth/solver/constraint/cloth_backstop_row.js

@@ -48,8 +48,15 @@ import {
  * garment's own skinned surface — `b` a short way inside along the vertex
  * normal, `r_b` that distance again — and a skinned garment is M3. M2's entity
  * path has a chain rather than a surface, so it has no normal to offer: a rope
- * has no inside. So the row ships with storage, a spec and a playground demo
- * driving it directly, and `cloth_proxy_build` is what will fill it.
+ * has no inside. So the row ships with storage and a spec, and
+ * `cloth_proxy_build` is what will fill it.
+ *
+ * **Nothing drives it in a scene.** This docblock used to say "and a playground
+ * demo driving it directly", and no page under `playground/` writes
+ * {@link ClothState#backstop_plane} — M3 arrived and filled nothing in either.
+ * What holds the row up is `cloth_backstop_row.spec.js` alone, which is the
+ * honest status of a row with no author: the arithmetic is gated, the
+ * integration is not.
  *
  * ## No trust region, and no geometric stiffness
  *

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

@@ -27,10 +27,21 @@
  * `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 ({@link begin}'s `time`, 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.
+ * {@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.
+ *
+ * **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.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -38,13 +49,14 @@
 export class AbstractClothWind {
     /**
      * Called once per fixed step, before any cloth is advanced, so a source that
-     * moves with time or with the scene can refresh itself once rather than once
-     * a cloth.
+     * reads the **scene** — every live fluid field and its world box — can walk
+     * it once rather than once a cloth.
      *
      * `time` is the cloth world's own accumulated fixed-step clock rather than a
-     * wall clock, which is what keeps a gust reproducible — see the note above.
+     * wall clock. It is *not* what a gust is a function of: see the note above,
+     * and {@link sample}'s own `time`.
      *
-     * @param {number} time seconds since the cloth world started stepping
+     * @param {number} time seconds of fixed step this world has stepped
      * @param {EntityComponentDataset} ecd for a source that reads components
      * @returns {void}
      */
@@ -81,8 +93,10 @@ export class AbstractClothWind {
      * @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
      * @returns {Float64Array|number[]} `out`, for chaining
      */
-    sample(out: Float64Array | number[], x: number, y: number, z: number): Float64Array | number[];
+    sample(out: Float64Array | number[], x: number, y: number, z: number, time: number): Float64Array | number[];
 }
 //# sourceMappingURL=AbstractClothWind.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;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;;;;;;;;;;;;;;;;;OAiBG;IACH,YANW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,GACJ,YAAY,GAAC,MAAM,EAAE,CAQjC;CACJ"}
+{"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"}

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

@@ -27,10 +27,21 @@
  * `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 ({@link begin}'s `time`, 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.
+ * {@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.
+ *
+ * **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.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -39,13 +50,14 @@ export class AbstractClothWind {
 
     /**
      * Called once per fixed step, before any cloth is advanced, so a source that
-     * moves with time or with the scene can refresh itself once rather than once
-     * a cloth.
+     * reads the **scene** — every live fluid field and its world box — can walk
+     * it once rather than once a cloth.
      *
      * `time` is the cloth world's own accumulated fixed-step clock rather than a
-     * wall clock, which is what keeps a gust reproducible — see the note above.
+     * wall clock. It is *not* what a gust is a function of: see the note above,
+     * and {@link sample}'s own `time`.
      *
-     * @param {number} time seconds since the cloth world started stepping
+     * @param {number} time seconds of fixed step this world has stepped
      * @param {EntityComponentDataset} ecd for a source that reads components
      * @returns {void}
      */
@@ -88,9 +100,11 @@ export class AbstractClothWind {
      * @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
      * @returns {Float64Array|number[]} `out`, for chaining
      */
-    sample(out, x, y, z) {
+    sample(out, x, y, z, time) {
         out[0] = 0;
         out[1] = 0;
         out[2] = 0;

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

@@ -27,6 +27,13 @@
  * the cheapest thing that reads as weather; it is not turbulence, and a scene
  * that wants turbulence has a fluid simulator.
  *
+ * The clock `g(t)` reads is the **asking cloth's own age**, handed in per
+ * sample, not a clock this object holds — see {@link AbstractClothWind} for the
+ * parity argument. The visible consequence is that two garments spawned a second
+ * apart are a second apart in the gust rather than in phase with it, which for a
+ * bounded sum of sinusoids is indistinguishable from weather and is the reason
+ * this costs nothing to make true.
+ *
  * ## Uniform in space, and that is the interesting limit
  *
  * {@link varies} is always `false`, so a whole garment costs **one** sample —
@@ -61,11 +68,6 @@ export class ClothAmbientWind extends AbstractClothWind {
      * @type {number}
      */
     period: number;
-    /**
-     * @type {number}
-     * @private
-     */
-    private __time;
     /**
      * @param {number} time
      * @param {EntityComponentDataset} [ecd]

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

@@ -1 +1 @@
-{"version":3,"file":"ClothAmbientWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothAmbientWind.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAEI;;;;OAIG;IACH,MAFU,YAAY,CAEK;IAE3B;;;;;OAKG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,eAAW;IAEX;;;;OAIG;IACH,YAJW,MAAM,iCAEJ,IAAI,CAIhB;IAED;;;;;;OAMG;IACH,UAFa,OAAO,CAInB;CAsCJ;kCAnIiC,wBAAwB"}
+{"version":3,"file":"ClothAmbientWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothAmbientWind.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAEI;;;;OAIG;IACH,MAFU,YAAY,CAEK;IAE3B;;;;;OAKG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAEX;;;;OAIG;IACH,YAJW,MAAM,iCAEJ,IAAI,CAKhB;IAED;;;;;;OAMG;IACH,UAFa,OAAO,CAInB;CAuCJ;kCAtIiC,wBAAwB"}

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

@@ -29,6 +29,13 @@ import { AbstractClothWind } from "./AbstractClothWind.js";
  * the cheapest thing that reads as weather; it is not turbulence, and a scene
  * that wants turbulence has a fluid simulator.
  *
+ * The clock `g(t)` reads is the **asking cloth's own age**, handed in per
+ * sample, not a clock this object holds — see {@link AbstractClothWind} for the
+ * parity argument. The visible consequence is that two garments spawned a second
+ * apart are a second apart in the gust rather than in phase with it, which for a
+ * bounded sum of sinusoids is indistinguishable from weather and is the reason
+ * this costs nothing to make true.
+ *
  * ## Uniform in space, and that is the interesting limit
  *
  * {@link varies} is always `false`, so a whole garment costs **one** sample —
@@ -67,19 +74,14 @@ export class ClothAmbientWind extends AbstractClothWind {
      */
     period = 4;
 
-    /**
-     * @type {number}
-     * @private
-     */
-    __time = 0;
-
     /**
      * @param {number} time
      * @param {EntityComponentDataset} [ecd]
      * @returns {void}
      */
     begin(time, ecd) {
-        this.__time = time;
+        // Nothing to refresh: the gust is a pure function of the time each
+        // sample is taken at, and there is no scene to walk.
     }
 
     /**
@@ -98,9 +100,10 @@ export class ClothAmbientWind extends AbstractClothWind {
      * @param {number} x unused — the ambient has no spatial structure
      * @param {number} y
      * @param {number} z
+     * @param {number} time seconds the asking cloth has stepped
      * @returns {Float64Array|number[]}
      */
-    sample(out, x, y, z) {
+    sample(out, x, y, z, time) {
         const wind = this.wind;
 
         out[0] = wind[0];
@@ -115,7 +118,7 @@ export class ClothAmbientWind extends AbstractClothWind {
 
         const period = this.period > 0 ? this.period : 1;
 
-        const w = 2 * Math.PI * this.__time / period;
+        const w = 2 * Math.PI * time / period;
 
         for (let axis = 0; axis < 3; axis++) {
             const phase = PHASE[axis];

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":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IAEI;;;;OAIG;IACH,SAFU,gBAAgB,CAEO;IAEjC;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;CA+Hf;kCAhNiC,wBAAwB;iCACzB,uBAAuB"}
+{"version":3,"file":"ClothFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothFluidWind.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IAEI;;;;OAIG;IACH,SAFU,gBAAgB,CAEO;IAEjC;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;CAkIf;kCAnNiC,wBAAwB;iCACzB,uBAAuB"}

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

@@ -175,9 +175,12 @@ export class ClothFluidWind extends AbstractClothWind {
      * @param {number} x
      * @param {number} y
      * @param {number} z
+     * @param {number} time seconds the asking cloth has stepped, for the
+     *   ambient fallback; a field's own velocities are a snapshot of this tick
+     *   and are not a function of it
      * @returns {Float64Array|number[]}
      */
-    sample(out, x, y, z) {
+    sample(out, x, y, z, time) {
         const count = this.__count;
 
         const bounds = this.__bounds;
@@ -205,6 +208,6 @@ export class ClothFluidWind extends AbstractClothWind {
             return out;
         }
 
-        return this.ambient.sample(out, x, y, z);
+        return this.ambient.sample(out, x, y, z, time);
     }
 }

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

@@ -47,9 +47,11 @@
  * @param {Float64Array} anchor_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
+ * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
+ *   function of — see {@link AbstractClothWind}
  * @returns {boolean} whether the source was sampled per particle
  */
-export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, centre?: Float64Array): boolean;
+export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, centre?: Float64Array, time?: number): boolean;
 /**
  * Whether the air at the cloth's centre has moved far enough since the last step
  * that actually applied it to be worth waking for — §10's "sleep wakes on a wind
@@ -80,9 +82,12 @@ export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anc
  * @param {Float64Array} anchor_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
+ * @param {number} time seconds the cloth has stepped — the clock its gust is a
+ *   function of, which for a sleeping cloth is the age its *next* step would
+ *   have, because it has to be asking about the air that step would feel
  * @returns {boolean}
  */
-export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, previous: Float64Array, threshold: number): boolean;
+export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, previous: Float64Array, threshold: number, time: number): boolean;
 /**
  * The cloth's world-space axis-aligned bounds.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;GAWG;AACH,iGANW,YAAY,mBACZ,YAAY,WACZ,YAAY,GAEV,OAAO,CA6EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,kGANW,YAAY,mBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,GACJ,OAAO,CAqBnB;AAED;;;;;;;;;;;;;GAaG;AACH,wEALW,YAAY,mBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CAoEhB"}
+{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;;GAaG;AACH,iGARW,YAAY,mBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAEJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,kGATW,YAAY,mBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;GAaG;AACH,wEALW,YAAY,mBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CAoEhB"}

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

@@ -51,9 +51,11 @@ import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quate
  * @param {Float64Array} anchor_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
+ * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
+ *   function of — see {@link AbstractClothWind}
  * @returns {boolean} whether the source was sampled per particle
  */
-export function cloth_sample_air(state, wind, anchor_translation, anchor_rotation, centre = undefined) {
+export function cloth_sample_air(state, wind, anchor_translation, anchor_rotation, centre = undefined, time = 0) {
     const particle_count = state.particle_count;
 
     const air = state.air_velocity;
@@ -83,7 +85,8 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
         SAMPLE,
         (BOUNDS[0] + BOUNDS[3]) * 0.5,
         (BOUNDS[1] + BOUNDS[4]) * 0.5,
-        (BOUNDS[2] + BOUNDS[5]) * 0.5
+        (BOUNDS[2] + BOUNDS[5]) * 0.5,
+        time
     );
 
     if (centre !== undefined) {
@@ -118,7 +121,7 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
 
         v3_quaternion_apply(WORLD, 0, position[p], position[p + 1], position[p + 2], qx, qy, qz, qw);
 
-        wind.sample(SAMPLE, WORLD[0] + anchor_x, WORLD[1] + anchor_y, WORLD[2] + anchor_z);
+        wind.sample(SAMPLE, WORLD[0] + anchor_x, WORLD[1] + anchor_y, WORLD[2] + anchor_z, time);
 
         v3_quaternion_apply_inverse(LOCAL, 0, SAMPLE[0], SAMPLE[1], SAMPLE[2], qx, qy, qz, qw);
 
@@ -160,9 +163,12 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
  * @param {Float64Array} anchor_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
+ * @param {number} time seconds the cloth has stepped — the clock its gust is a
+ *   function of, which for a sleeping cloth is the age its *next* step would
+ *   have, because it has to be asking about the air that step would feel
  * @returns {boolean}
  */
-export function cloth_air_changed(state, wind, anchor_translation, anchor_rotation, previous, threshold) {
+export function cloth_air_changed(state, wind, anchor_translation, anchor_rotation, previous, threshold, time) {
     if (state.particle_count === 0) {
         return false;
     }
@@ -173,7 +179,8 @@ export function cloth_air_changed(state, wind, anchor_translation, anchor_rotati
         SAMPLE,
         (BOUNDS[0] + BOUNDS[3]) * 0.5,
         (BOUNDS[1] + BOUNDS[4]) * 0.5,
-        (BOUNDS[2] + BOUNDS[5]) * 0.5
+        (BOUNDS[2] + BOUNDS[5]) * 0.5,
+        time
     );
 
     const dx = SAMPLE[0] - previous[0];

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#396@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#403@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#396@#clear_field"(fluid: FluidComponent): void;
+    static "__#403@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#396@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#403@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#396@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#403@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];