@woosh/meep-engine 3.23.0 → 3.25.0

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

@@ -0,0 +1,29 @@
+/**
+ * First word of the `index`-th cloth's parameter block.
+ *
+ * @param {number} index
+ * @returns {number}
+ */
+export function cloth_command_offset(index: number): number;
+/**
+ * Size the command region for a ceiling on simultaneously stepped cloths. The
+ * region is allocated once at startup and cannot grow, which is what makes that
+ * ceiling a constructor argument rather than something discovered at runtime.
+ *
+ * @param {number} max_cloth_count
+ * @returns {number} `Float64` words
+ */
+export function cloth_command_word_count(max_cloth_count: number): number;
+/**
+ * Header words of the command region.
+ */
+export type ClothCommand = number;
+export namespace ClothCommand {
+    let CLOTH_COUNT: number;
+}
+/**
+ * Command words consumed before the first cloth's block.
+ * @type {number}
+ */
+export const CLOTH_COMMAND_HEADER_WORDS: number;
+//# sourceMappingURL=cloth_worker_protocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_worker_protocol.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_worker_protocol.js"],"names":[],"mappings":"AAyDA;;;;;GAKG;AACH,4CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,0DAHW,MAAM,GACJ,MAAM,CAIlB;;;;2BAnCS,MAAM;;;;AAShB;;;GAGG;AACH,yCAFU,MAAM,CAE4B"}

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

@@ -0,0 +1,78 @@
+import { CLOTH_STEP_PARAM_STRIDE } from "../solver/cloth_step_instance.js";
+
+/**
+ * # The command region, and what is *not* in it
+ *
+ * Layout of the {@link WorkerSystem} command region used by
+ * {@link WorkerClothSystem}: a count, then one {@link ClothStepParam} block per
+ * cloth to step this tick.
+ *
+ * §12 asks for exactly this shape — "the command region names which instances
+ * are live this step, so sleeping (P5) and culled (§12.1) instances cost nothing
+ * but their absence from a list" — and for `ClothDynamics` to travel with it,
+ * "written every step … cheaper than tracking dirtiness, and it keeps
+ * `cloth.dynamics.slack = 0.2` working live". Both hold. What changed on the way
+ * to being built is that the per-cloth words are not a serialization of
+ * `ClothDynamics` but the **step's own parameter block** — `dt`, local gravity, a
+ * retention, a clamp — because a cloth's dynamics have already been mapped
+ * through `cloth_dynamics_map.js` by the time the step can use them, and mapping
+ * them on the far side would be a second copy of that mapping with no way to
+ * prove it agreed. `MEASUREMENTS.md` §38.
+ *
+ * The consequence is the useful one: the same block the worker reads is the
+ * block {@link ClothSystem} fills in a private scratch array, so the two systems
+ * do not agree on the numbers, they *share* them.
+ *
+ * ## What travels on the cold plane instead
+ *
+ * A cloth's `ClothState` — the particles, the rows, the duals, the collider
+ * table, the pair list. That is a `SharedArrayBuffer` per cloth, registered once
+ * when the cloth seeds and again whenever a re-seed replaces it, and nothing of
+ * it is ever copied: the worker cuts its own views over the same bytes
+ * (`ClothState.fromSharedDescriptor`). §12 asked for one buffer for the whole
+ * cloth world; `MEASUREMENTS.md` §39 is why it is one per cloth.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Header words of the command region.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const ClothCommand = {
+    /**
+     * How many {@link ClothStepParam} blocks follow.
+     */
+    CLOTH_COUNT: 0
+};
+
+/**
+ * Command words consumed before the first cloth's block.
+ * @type {number}
+ */
+export const CLOTH_COMMAND_HEADER_WORDS = 1;
+
+/**
+ * First word of the `index`-th cloth's parameter block.
+ *
+ * @param {number} index
+ * @returns {number}
+ */
+export function cloth_command_offset(index) {
+    return CLOTH_COMMAND_HEADER_WORDS + index * CLOTH_STEP_PARAM_STRIDE;
+}
+
+/**
+ * Size the command region for a ceiling on simultaneously stepped cloths. The
+ * region is allocated once at startup and cannot grow, which is what makes that
+ * ceiling a constructor argument rather than something discovered at runtime.
+ *
+ * @param {number} max_cloth_count
+ * @returns {number} `Float64` words
+ */
+export function cloth_command_word_count(max_cloth_count) {
+    return cloth_command_offset(max_cloth_count);
+}

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

@@ -1,49 +1,33 @@
 /**
  * # Putting the answer back onto a skinned model's joints — §11.2
  *
- * The same reconstruction the entity path uses, written onto `Node3D`s instead
- * of onto entities. **Cloth moves joints; it does not produce vertices** — the
- * mapping from a simulated joint to a render vertex already exists in this
- * engine and it is the skin, so the existing skinning pass does the rest,
- * including bounds refresh and BLAS refit that a bespoke vertex-deformation
- * path would have to reimplement.
+ * The same reconstruction the entity path uses, written onto the joint entities' offsets.
+ * **Cloth moves joints; it does not produce vertices** — the mapping from a simulated joint to a
+ * render vertex already exists in this engine and it is the skin, so the existing skinning pass
+ * does the rest, including bounds refresh and BLAS refit that a bespoke vertex-deformation path
+ * would have to reimplement.
  *
- * ## `transform_local` is the output, and `transform_global` is written too
+ * ## The offset is the output
  *
- * `transform_local` is a joint's own truth and the handle §11.2 names. It is
- * also *passive*: a `Node3D` does not track its components, and nothing
- * downstream sees a change until `updateMatrices` runs — which recurses into
- * every descendant, so calling it on the anchor would recompose the whole
- * character every fixed step to move a cape.
+ * A joint's `TransformAttachment` offset is its own truth and the handle §11.2 names: it is what
+ * the joint's row holds, and the GPU composes the world from it under the anchor's animated
+ * row. Writing it is announced on the joint, which is what carries it to the row — the model
+ * marks the row on that announcement — and what lets the attachment system recompose the CPU's
+ * copy of the world below it. That copy is composed under the anchor as the CPU knows it, which
+ * for a GPU-driven anchor is its rest pose: what the simulation may read about a cape joint is
+ * its offset, or an exact evaluation, never that composed world.
  *
- * So this pass composes the cloth subtree's `transform_global` itself, which
- * costs nothing because the pose is already in hand, and bumps each joint's
- * version through `needsUpdate` so the renderer uploads the row. Nothing above
- * the anchor is touched and nothing below the garment is walked.
- *
- * `transform_global` is derived, so writing it is only ever a shortcut for the
- * recomposition it saves — and it is a *correct* shortcut only because this
- * pass has the anchor's world pose and the whole chain under it. Anything that
- * moves the anchor without telling cloth invalidates it, which is the same
- * contract every consumer of a derived transform already has.
- *
- * ## What is not here
- *
- * No announcement, and no pruned boundary. The entity path has both because its
- * subtree is an entity hierarchy with other things hanging off it; a proxy's
- * joint list is closed by construction, and a socket parented to a cape joint
- * follows it through the ordinary node hierarchy.
+ * Nothing above the anchor is touched: the anchor is the character's, animated by its clips,
+ * and this pass hangs a cape from it.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 /**
- * Write one cloth's solved pose onto the joints it drives.
+ * Write the reconstructed pose onto the rig's joints.
  *
  * @param {ClothInstance} instance
- * @param {Transform64} anchor the anchor joint's **world** pose, evaluated by
- *   the caller — see `ClothSystem` for why it is not read off the node
- * @returns {void}
+ * @param {EntityComponentDataset} ecd
  */
-export function cloth_write_back_rig(instance: ClothInstance, anchor: Transform64): void;
+export function cloth_write_back_rig(instance: ClothInstance, ecd: EntityComponentDataset): void;
 //# sourceMappingURL=cloth_write_back_rig.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_write_back_rig.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back_rig.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;GAOG;AACH,oFAFa,IAAI,CA2DhB"}
+{"version":3,"file":"cloth_write_back_rig.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back_rig.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;GAKG;AACH,iGAqBC"}

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

@@ -1,115 +1,58 @@
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
-import {
-    TRANSFORM64_ROTATION_OFFSET,
-    TRANSFORM64_TRANSLATION_OFFSET
-} from "../../../ecs/transform/Transform64.js";
-import { cloth_reconstruct_pose } from "./cloth_reconstruct_pose.js";
-import { cloth_write_local_pose } from "./cloth_write_back.js";
-
-/**
- * # Putting the answer back onto a skinned model's joints — §11.2
- *
- * The same reconstruction the entity path uses, written onto `Node3D`s instead
- * of onto entities. **Cloth moves joints; it does not produce vertices** — the
- * mapping from a simulated joint to a render vertex already exists in this
- * engine and it is the skin, so the existing skinning pass does the rest,
- * including bounds refresh and BLAS refit that a bespoke vertex-deformation
- * path would have to reimplement.
- *
- * ## `transform_local` is the output, and `transform_global` is written too
- *
- * `transform_local` is a joint's own truth and the handle §11.2 names. It is
- * also *passive*: a `Node3D` does not track its components, and nothing
- * downstream sees a change until `updateMatrices` runs — which recurses into
- * every descendant, so calling it on the anchor would recompose the whole
- * character every fixed step to move a cape.
- *
- * So this pass composes the cloth subtree's `transform_global` itself, which
- * costs nothing because the pose is already in hand, and bumps each joint's
- * version through `needsUpdate` so the renderer uploads the row. Nothing above
- * the anchor is touched and nothing below the garment is walked.
- *
- * `transform_global` is derived, so writing it is only ever a shortcut for the
- * recomposition it saves — and it is a *correct* shortcut only because this
- * pass has the anchor's world pose and the whole chain under it. Anything that
- * moves the anchor without telling cloth invalidates it, which is the same
- * contract every consumer of a derived transform already has.
- *
- * ## What is not here
- *
- * No announcement, and no pruned boundary. The entity path has both because its
- * subtree is an entity hierarchy with other things hanging off it; a proxy's
- * joint list is closed by construction, and a socket parented to a cape joint
- * follows it through the ordinary node hierarchy.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/**
- * Write one cloth's solved pose onto the joints it drives.
- *
- * @param {ClothInstance} instance
- * @param {Transform64} anchor the anchor joint's **world** pose, evaluated by
- *   the caller — see `ClothSystem` for why it is not read off the node
- * @returns {void}
- */
-export function cloth_write_back_rig(instance, anchor) {
-    cloth_reconstruct_pose(instance);
-
-    const node_count = instance.node_count;
-
-    const blended = instance.blended_position;
-    const reconstructed = instance.blended_rotation;
-
-    const ax = anchor[TRANSFORM64_TRANSLATION_OFFSET];
-    const ay = anchor[TRANSFORM64_TRANSLATION_OFFSET + 1];
-    const az = anchor[TRANSFORM64_TRANSLATION_OFFSET + 2];
-
-    const aqx = anchor[TRANSFORM64_ROTATION_OFFSET];
-    const aqy = anchor[TRANSFORM64_ROTATION_OFFSET + 1];
-    const aqz = anchor[TRANSFORM64_ROTATION_OFFSET + 2];
-    const aqw = anchor[TRANSFORM64_ROTATION_OFFSET + 3];
-
-    const parent = instance.node_parent;
-    const node_joint = instance.node_joint;
-
-    for (let node = 1; node < node_count; node++) {
-        const joint = node_joint[node];
-
-        if (joint === undefined || joint === null) {
-            continue;
-        }
-
-        cloth_write_local_pose(joint.transform_local, instance, node, parent[node]);
-
-        const global = joint.transform_global;
-
-        const n = node * 3;
-
-        v3_quaternion_apply(
-            global, TRANSFORM64_TRANSLATION_OFFSET,
-            blended[n], blended[n + 1], blended[n + 2],
-            aqx, aqy, aqz, aqw
-        );
-
-        global[TRANSFORM64_TRANSLATION_OFFSET] += ax;
-        global[TRANSFORM64_TRANSLATION_OFFSET + 1] += ay;
-        global[TRANSFORM64_TRANSLATION_OFFSET + 2] += az;
-
-        quat3_multiply(
-            global, TRANSFORM64_ROTATION_OFFSET,
-            aqx, aqy, aqz, aqw,
-            reconstructed[node * 4], reconstructed[node * 4 + 1],
-            reconstructed[node * 4 + 2], reconstructed[node * 4 + 3]
-        );
-
-        global.updateMatrix();
-
-        // The version is what the renderer compares against to decide whether
-        // to upload the row, so a joint whose transform changed and whose
-        // version did not is a joint that moved nowhere.
-        joint.needsUpdate = true;
-    }
-}
+import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "../../../ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
+import { cloth_reconstruct_pose } from "./cloth_reconstruct_pose.js";
+import { cloth_write_local_pose } from "./cloth_write_back.js";
+
+/**
+ * # Putting the answer back onto a skinned model's joints — §11.2
+ *
+ * The same reconstruction the entity path uses, written onto the joint entities' offsets.
+ * **Cloth moves joints; it does not produce vertices** — the mapping from a simulated joint to a
+ * render vertex already exists in this engine and it is the skin, so the existing skinning pass
+ * does the rest, including bounds refresh and BLAS refit that a bespoke vertex-deformation path
+ * would have to reimplement.
+ *
+ * ## The offset is the output
+ *
+ * A joint's `TransformAttachment` offset is its own truth and the handle §11.2 names: it is what
+ * the joint's row holds, and the GPU composes the world from it under the anchor's animated
+ * row. Writing it is announced on the joint, which is what carries it to the row — the model
+ * marks the row on that announcement — and what lets the attachment system recompose the CPU's
+ * copy of the world below it. That copy is composed under the anchor as the CPU knows it, which
+ * for a GPU-driven anchor is its rest pose: what the simulation may read about a cape joint is
+ * its offset, or an exact evaluation, never that composed world.
+ *
+ * Nothing above the anchor is touched: the anchor is the character's, animated by its clips,
+ * and this pass hangs a cape from it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Write the reconstructed pose onto the rig's joints.
+ *
+ * @param {ClothInstance} instance
+ * @param {EntityComponentDataset} ecd
+ */
+export function cloth_write_back_rig(instance, ecd) {
+    cloth_reconstruct_pose(instance);
+
+    const node_count = instance.node_count;
+
+    const parent = instance.node_parent;
+    const node_joint = instance.node_joint;
+    const node_attachment = instance.node_attachment;
+
+    for (let node = 1; node < node_count; node++) {
+        const joint = node_joint[node];
+        const attachment = node_attachment[node];
+
+        if (attachment === undefined || attachment === null || !ecd.entityExists(joint)) {
+            continue;
+        }
+
+        cloth_write_local_pose(attachment.transform, instance, node, parent[node]);
+
+        ecd.sendEvent(joint, TRANSFORM_ATTACHMENT_EVENT_CHANGE);
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Spawn the cloth solver worker.
+ *
+ * Isolated in its own module on purpose: `import.meta` is a syntax error under
+ * the CommonJS transform the test runner uses, so any module containing it
+ * cannot be imported by a spec — even transitively. Keeping the expression here
+ * lets {@link WorkerClothSystem} stay testable while application code gets a
+ * one-import default.
+ *
+ * The `new Worker(new URL(...), { type: "module" })` form is what webpack 5
+ * detects statically, so the worker is emitted as a real chunk with its full
+ * dependency graph rather than being assembled at runtime.
+ *
+ * @returns {Worker}
+ */
+export function makeClothWorker(): Worker;
+//# sourceMappingURL=makeClothWorker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeClothWorker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/makeClothWorker.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,mCAFa,MAAM,CAIlB"}

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

@@ -0,0 +1,18 @@
+/**
+ * Spawn the cloth solver worker.
+ *
+ * Isolated in its own module on purpose: `import.meta` is a syntax error under
+ * the CommonJS transform the test runner uses, so any module containing it
+ * cannot be imported by a spec — even transitively. Keeping the expression here
+ * lets {@link WorkerClothSystem} stay testable while application code gets a
+ * one-import default.
+ *
+ * The `new Worker(new URL(...), { type: "module" })` form is what webpack 5
+ * detects statically, so the worker is emitted as a real chunk with its full
+ * dependency graph rather than being assembled at runtime.
+ *
+ * @returns {Worker}
+ */
+export function makeClothWorker() {
+    return new Worker(new URL("./cloth.worker.js", import.meta.url), { type: "module" });
+}

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

@@ -4,7 +4,7 @@
 npm run dev --workspace @woosh/meep-engine
 ```
 
-Four pages, one directory, one layer of the system each. (Vite takes the next
+Five pages, one directory, one layer of the system each. (Vite takes the next
 free port if 5173 is busy — the terminal says which.)
 
 | | |
@@ -12,11 +12,17 @@ free port if 5173 is busy — the terminal says which.)
 | [`index.html`](./index.html) | **the solver, M0.** `cloth_step` over a `ClothState`, no ECS at all. |
 | [`rig.html`](./rig.html) | **the entity subtree, M1.** A real `EntityManager`, real entities, `ClothSystem` walking and writing back. |
 | [`collide.html`](./collide.html) | **collision, M2.** The solver again, with a packed collider table in the argument list. |
-| [`garment.html`](./garment.html) | **skinned garments, M3, and self-collision, M4.** A `Node3D` skeleton, a `Skin`, and a `Cloth` + `ClothRig` driving some of its joints. |
+| [`garment.html`](./garment.html) | **skinned garments, M3, and self-collision, M4.** A skeleton of entities, a `Skin`, and a `Cloth` + `ClothRig` driving some of its joints. |
+| [`wind.html`](./wind.html) | **wind, M6.** A banner hanging in a real `FluidSimulator`'s wake, reading it through `ClothFluidWind`. |
 
-Both are at
+All are at
 `http://localhost:5173/src/engine/physics/cloth/playground/<page>`.
 
+There is no M5 page, and that is deliberate: a `SharedArrayBuffer` needs a
+cross-origin isolated page and `vite.config.mjs` sends no `COOP`/`COEP`
+(`MEASUREMENTS.md` §44). The worker bridge is tested by
+`SystemWorkerLoopback` instead, more precisely than a page could.
+
 ---
 
 # The solver page — `index.html`
@@ -260,14 +266,14 @@ does not fire in a hidden pane, so a driver calls `step_once` itself.
 ## What it is
 
 `rig.html` is a `Cloth` over an entity subtree; this is a `Cloth` + a `ClothRig`
-over a skinned model's **joints**. Every point on screen is a
-`Node3D.transform_global` — a joint of a `Skin`, not an entity — and it is where
-it is because the solver wrote its `transform_local` and this page composed the
-chain.
+over a skinned model's **joints**. Every point on screen is a joint's
+`Transform64` — an entity of the skeleton's prefab instance, named by a `Skin` —
+and it is where it is because the solver wrote its attachment's local transform
+and the attachment system composed the chain.
 
 `ClothSystem#models` takes a stub rather than a `MeshSystem` for the reason the
 field exists: a `MeshSystem` needs a graphics engine, a scene and a loader, and a
-garment's joints are a `Node3D` tree that needs none of the three. The stub
+garment's joints are a prefab instance that needs none of the three. The stub
 answers exactly the one method the system calls.
 
 ## The garments
@@ -279,7 +285,7 @@ answers exactly the one method the system calls.
 - **coat tails** — three strips of nine in denim, which is the library entry that
   spends its two levers on particles rather than iterations.
 - **ponytail** — one chain of twelve off the neck. The rig path is the entity
-  path with `Node3D`s in it, and a single chain is where that is most obviously
+  path over a skin's joints, and a single chain is where that is most obviously
   true.
 - **loincloth** — seven strips of five off the pelvis, and the one preset that
   spends most of its time against the leg colliders.
@@ -287,10 +293,10 @@ answers exactly the one method the system calls.
 ## The motion drives the character, and only the character
 
 The buttons write the **character's own bones**. The garment's joints are
-cloth's, and the seed says so: it claims `TransformAuthority.CPU` on every one of
-them, because a joint a clip drives is under GPU authority and its
-`transform_local` is not read by anything. Two writers of one row is the race the
-authority enum exists to prevent, and the claim is where a garment whose joints
+cloth's, and the seed says so: it revokes the GPU's authority over the attachment
+of every one of them, because a joint a clip drives is the GPU's and its local
+transform is not read by anything. Two writers of one row is the race the
+authority flags exist to prevent, and the claim is where a garment whose joints
 are *also* keyed shows up as an authoring error.
 
 **sprint** is §7 P7's own profile: a square wave in velocity, integrated. Written
@@ -337,3 +343,68 @@ has the numbers, because it cost an hour to diagnose the first time.
 step_once, draw, scene }`. `rebuild` returns a promise, because
 `EntityManager#startup` does and an entity created before it resolves is never
 linked.
+
+---
+
+# The wind page — `wind.html`
+
+## What it is
+
+§10's argument made watchable, and the word that matters is **simulated**. There
+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
+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
+process, no `EntityManager` — because what is being shown is the air rather than
+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
+  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
+  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.
+- **Take the post away.** The air at the banner goes from 6.0 m/s to 8.7. That
+  31% deficit is the incompressible projection's answer to a solid standing in a
+  flow, and there is no authored falloff anywhere in it.
+
+## The readout
+
+- **cloth step** — `cloth_wind_accelerate` plus `cloth_step`, against §17's 2 ms
+  bar. The wind's own share of it is about one per cent (`MEASUREMENTS.md` §49);
+  everything else on that bar is the solver.
+- **fluid step** — the `FluidSimulator`, which at the default grid is several
+  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"
+  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:
+  the facing factor as a number.
+
+## What it does not show
+
+**A shedding street.** At the grids this page can afford the wake is a *steady*
+velocity deficit — measured at 18, 26 and 34 cells across, with damping and
+vorticity confinement at both ends of their range, the air behind the post varies
+by under 0.03 m/s. The banner's free corner moves twelve times as far per step
+with the post as without, and both of those are settled rather than fluttering.
+That is the fluid solver's answer at this scale rather than the cloth's, and
+`MEASUREMENTS.md` §51 records it so the page is not read as promising something
+it does not do.
+
+## Notes
+
+`globalThis.cloth_wind_playground` exposes `{ control, camera, rebuild,
+step_once, refresh_post, cloth, tunnel, wind, air_centre, sampled_per_particle,
+mean_drag, tripwire, timings }`. Changing `control.yaw` needs a `refresh_post()`
+after it, because the post stands upstream along the flow and only moves when it
+is asked to.

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

@@ -74,5 +74,4 @@ export type GarmentScene = {
 import { EntityComponentDataset } from "../../../ecs/EntityComponentDataset.js";
 import { ClothSystem } from "../ecs/ClothSystem.js";
 import { ClothColliderSystem } from "../ecs/ClothColliderSystem.js";
-import { Node3D } from "../../../../shade/renderer/scene/Node3D.js";
 //# sourceMappingURL=garment_build.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"garment_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/garment_build.js"],"names":[],"mappings":"AA2FA;;;GAGG;AACH,6FAHW,MAAM,GACJ,QAAQ,YAAY,CAAC,CA4EjC;AA8JD;;;;;;GAMG;AACH,8CAHW,MAAM,GACJ,IAAI,CA0BhB;AAhVD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;IAqCE;;SAjDY,sBAAsB;WACtB,WAAW;eACX,mBAAmB;YACnB,MAAM;;;;UACN,MAAM;YACN,MAAM;;;;UACN,MAAM,EAAE;;;;WACR,MAAM,EAAE;;;;;UAER,MAAM,EAAE,EAAE;;uCA7Ce,wCAAwC;4BAcnD,uBAAuB;oCAHf,+BAA+B;uBAZ5C,4CAA4C"}
+{"version":3,"file":"garment_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/garment_build.js"],"names":[],"mappings":"AA8FA;;;GAGG;AACH,6FAHW,MAAM,GACJ,QAAQ,YAAY,CAAC,CA6EjC;AAiKD;;;;;;GAMG;AACH,8CAHW,MAAM,GACJ,IAAI,CAyBhB;AAnVD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;IAqCE;;SAjDY,sBAAsB;WACtB,WAAW;eACX,mBAAmB;YACnB,MAAM;;;;;;;;;UAGN,QAAQ;;;;WACR,QAAQ;;;;;UAER,MAAM,EAAE,EAAE;;uCA7Ce,wCAAwC;4BAcnD,uBAAuB;oCAHf,+BAA+B"}