@woosh/meep-engine 3.56.0 → 3.57.0

package/src/shade/renderer/fluid/GPU_FLUID_OCCUPANCY_AND_SOTA_REVIEW_2026_10_26.md

@@ -0,0 +1,361 @@
+# GPU Wind Fluid Solver: Occupancy Analysis & Real-Time SotA Review (2026-10-26)
+
+**Scope:** [`packages/meep-engine/src/shade/renderer/fluid/`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/) and [`GPUFluidSystem.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/graphics3/GPUFluidSystem.js)  
+**Domain:** Space-filling atmospheric wind simulation (nested, player-centered 3D toroidal clipmap cascades with $2^c$ subcycling, MAC staggered velocity, geometric multigrid pressure projection, LBVH-culled obstacle/effector forcing, and `rgba16float` deviation atlas publishing).  
+**Related Specifications:** [`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md), [`SHADER_F16_PROPOSAL_2026_10_24.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/SHADER_F16_PROPOSAL_2026_10_24.md), [`REVIEW_02_PLAN.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/REVIEW_02_PLAN.md)  
+**Reference Hardware & Device Floor:** NVIDIA GeForce RTX 4090 (Ada AD102: 128 SMs, 48 warps/SM = 1,536 threads/SM, 65,536 32-bit VGPRs/SM, up to 100 KB shared memory/SM) and AMD Radeon RDNA2/3 (64 KiB LDS/WGP, 65,536–131,072 VGPRs/SIMD). `shader-f16` (`enable f16;`), `subgroups`, and `texture-formats-tier1` (`r16float` storage textures) are required by [`SHADE_DEVICE_FLOOR`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/WebGPUDevice.js#L16-L35) and assumed throughout.
+
+---
+
+## 1. Executive Summary: Where the Time Goes and Why Occupancy Is Low
+
+On an RTX 4090 at the default cascade resolution of `64×32×64` ($h_0 = 0.5\text{ m}$, 4 cascades), a single cascade step costs **`144.4 µs`** (`152.6 µs` with vorticity confinement), and a two-cascade tick (`c = 1, 0`) costs **`291.8 µs`** (`308.2 µs` with confinement) before scene forcing, plus **`34–88 µs`** for LBVH brick query and forcing application ([`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md#L975-L1043), [`shader_fluid_cascade_ghosts.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.js#L75-L80)).
+
+Combining the measured RTX 4090 per-pass GPU timestamps with static analysis of the 19 compiled WGSL shaders reveals **six concrete occupancy and execution-efficiency bottlenecks** in the passes that dominate frame time:
+
+| Pass Group | RTX 4090 Cost / Step (`64×32×64`) | Share of Step | Root Cause of Low GPU Occupancy / Execution Efficiency |
+|---|---|---|---|
+| **1. Multigrid Smoother & Restriction** ([`shader_fluid_mg_smooth`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js), [`shader_fluid_mg_residual_restrict`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js)) | `53 µs` + `18 µs` = **`71 µs`** | **`49.2%`** | **Unstaged coarse prolongation** (`600 × 8 = 4,800` global reads/WG for `144` unique coarse cells on up-sweeps); **redundant global re-read of `input`** after `grid_tile_f32_load`; **87.5% idle warps (`224/256` threads)** after barrier 1 in `residual_restrict` (`if (lane < 32u)`); **16 dead trailing `workgroupBarrier()`s/step** left over before `subgroup_atomic_add_u32`. |
+| **2. MAC Advection** ([`shader_fluid_mac_advect_correct`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js), [`shader_fluid_mac_advect_predict`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_predict.js)) | `27 µs` + `16 µs` = **`43 µs`** | **`29.8%`** | **Severe VGPR pressure & nested $8\times 8$ dynamic loops:** `mac_source_*` and `mac_forward_*` call `fluid_mac_ghost_*`, which still embeds a fallback call to `fluid_parent_face_*` — placing an **8-iteration dynamic loop inside an 8-iteration dynamic loop** (`select(0u, 8u, abs(position.x) < 1e30)`) across all 3 axes (`888` lines / `67` functions in `correct`). Plus **warp divergence on upper boundary tiles** (`u_end/v_end/w_end = 2`) and `r32float` (`4 B`/texel) velocity bandwidth instead of `r16float` (`2 B`/texel). |
+| **3. Forcing Query & Apply** ([`shader_fluid_forcing_query`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_query.js), [`shader_fluid_forcing_apply`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js)) | **`34–88 µs`** (per tick) | Additive (`+24–30%`) | **VGPR explosion + 2-warp (`64`-thread) workgroups:** `forcing_apply` (`825` lines, `4,724 B` LDS) copies 80 B `FluidObstacleRecord` and 64 B `mat4x4<f32>` structs by value into VGPRs and re-normalizes 3 matrix columns per thread × 24 obstacles; `57.8%` of brick threads diverge on 6-face effector loops; `forcing_query` executes `3` `workgroupBarrier()`s per BVH depth level with only 2 warps per workgroup. |
+| **4. Cascade Ghosts** ([`shader_fluid_cascade_ghosts`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.js)) | **`9.0 µs`** | **`6.2%`** | **Hollow bounding-box dispatch waste:** launches `4,800` WGs (`307,200` threads) over the filled `[77, 45, 77]` volume; **`53.66%` of threads (`164,851`) write nothing**, **`25.54%` of WGs (`1,226`) are 100% interior no-ops**, and `cell = id - 1` misaligns pressure ghosts through the velocity interior. |
+| **5. Vorticity Confinement Curl** ([`shader_fluid_mac_curl`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_curl.js)) | **`8.2 µs`** | **`5.4%`** (when on) | **LDS ceiling (`16,224 B` = `99.0%` of 16 KiB limit):** caps residency to 1–2 WGs/CU (`16.7%–33.3%` warp occupancy) by storing `3 × 1,152` velocities + `600` magnitudes as `f32` in LDS, and computes `fluid_curl_omega(local)` **twice** per interior thread. |
+| **6. MAC Gradient & MG Weights** ([`shader_fluid_mac_gradient`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_gradient.js), `mg_*_weights`) | `4.1 µs` + `8.2 µs` = **`12.3 µs`** | **`8.5%`** | `mac_gradient` calls `grid_tile_f32_load` **twice in a row** (`2` `workgroupBarrier()`s, `2` unpack loops, `2,400 B` LDS to hold a 1-bit `solid` flag as `f32`); the `4` standalone MG weight dispatches (`level0_weights` + 3× `coarse_weights`) duplicate grid walks and `words` reads already performed by `mac_divergence` and `mg_residual_restrict`. |
+
+---
+
+## 2. Complete Quantitative Audit of All 19 Compute Shaders
+
+All metrics below are extracted from the compiled WGSL (`shader.descriptor.source`) of the 19 [`ComputeShader`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/ComputeShader.js) definitions in [`packages/meep-engine/src/shade/renderer/fluid/`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/).
+
+| # | Shader Symbol & Label | WG Size (`Threads` / `Warps32`) | LDS (`var<workgroup>`) Bytes | Barriers (`Static` / `Dynamic`) | Bindings (`UBO` / `RO-SB` / `RW-SB` / `Tex` / `StTex`) | Compiled WGSL (`Lines` / `Fns`) | Primary Occupancy / Efficiency Bottleneck |
+|---|---|---|---|---|---|---|---|
+| 1 | [`shader_fluid_cascade_fill`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/shader_fluid_cascade_fill.js) (`Fluid / cascade fill`) | `4×4×4` (`64` / `2`) | `0 B` | `0 / 0` | `2 / 1 / 1 / 3 / 3` | `362 / 22` | Dynamic 8-corner `textureLoad` loops (`24` loads/thread, `z0/z1` `vec4f` live state); `cell == last` boundary divergence; 2-warp WG. |
+| 2 | [`shader_fluid_cascade_ghosts`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.js) (`Fluid / cascade ghosts`) | `4×4×4` (`64` / `2`) | `0 B` | `0 / 0` | `2 / 1 / 1 / 3 / 3` | `319 / 18` | **53.66% dead threads** (`164,851 / 307,200`) & **25.54% no-op WGs**; misaligned `cell = id - 1` pressure shell; 24 `textureLoad`s/thread. |
+| 3 | [`shader_fluid_cascade_restrict`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/shader_fluid_cascade_restrict.js) (`Fluid / cascade restrict`) | `8×8×4` (`256` / `8`) | `0 B` | `0 / 0` | `1 / 0 / 0 / 3 / 3` | `152 / 13` | Clean, lightweight (`12` `textureLoad`s/thread); `r32float` bandwidth (`2×` `r16float`). |
+| 4 | [`shader_fluid_mac_curl`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_curl.js) (`Fluid / MAC curl`) | `8×8×4` (`256` / `8`) | **`16,224 B`** (`99.0%` of 16 KiB) | `2 / 2` | `1 / 1 / 1 / 3 / 0` | `260 / 19` | **16.2 KB `f32` LDS caps CU/SM residency to 1–2 WGs**; computes `fluid_curl_omega(local)` **twice** per interior thread (lines 142 & 164). |
+| 5 | [`shader_fluid_mac_advect_predict`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_predict.js) (`Fluid / MAC advect predict`) | `8×8×4` (`256` / `8`) | `0 B` | `0 / 0` | `2 / 1 / 0 / 9 / 3` | `576 / 43` | **High VGPR pressure:** nested `mac_source_* → fluid_mac_ghost_* → fluid_parent_face_*` 8×8 dynamic loops; `u_end/v_end/w_end` warp divergence. |
+| 6 | [`shader_fluid_mac_advect_correct`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js) (`Fluid / MAC advect correct`) | `8×8×4` (`256` / `8`) | `0 B` | `0 / 0` | `2 / 3 / 0 / 12 / 3` | **`888 / 67`** | **Severe VGPR pressure:** 12 sampled textures + 3 storage textures + 3 storage buffers; 6× outer 8-corner loops + 6× nested parent 8-corner loops + 3× epilogue parent 8-corner loops + 6× bisection loops per thread. |
+| 7 | [`shader_fluid_mac_divergence`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_divergence.js) (`Fluid / MAC divergence`) | `8×8×4` (`256` / `8`) | `0 B` | `0 / 0` | `1 / 1 / 1 / 3 / 0` | `135 / 12` | High occupancy (`2.0 µs` at `64×32×64`); direct texture reads beat LDS tiling 2× on RTX 4090. |
+| 8 | [`shader_fluid_mac_gradient`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_gradient.js) (`Fluid / MAC gradient`) | `8×8×4` (`256` / `8`) | `4,800 B` (`2 × 2,400 B`) | `1 / 2` | `1 / 3 / 0 / 3 / 3` | `289 / 29` | **Calls `grid_tile_f32_load` twice in a row** → **2 serial `workgroupBarrier()`s** and 2 halo unpack loops; stores 1-bit `solid` as `f32` (`2,400 B`). |
+| 9 | [`shader_fluid_mg_level0_weights`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_level0_weights.js) (`Fluid / pressure / level 0 weights`) | `8×8×4` (`256` / `8`) | `0 B` | `0 / 0` | `1 / 1 / 1 / 0 / 0` | `78 / 7` | Separate dispatch over the exact same `8×8×4` cell grid and `solid` buffer just traversed by `shader_fluid_mac_divergence`. |
+| 10 | [`shader_fluid_mg_coarse_weights`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarse_weights.js) (`Fluid / pressure / coarse weights`) | `8×8×4` (`256` / `8`) | `0 B` | `0 / 0` | `1 / 1 / 1 / 0 / 0` | `79 / 6` | Separate dispatch reading the exact $2\times 2\times 2$ fine `words` already loaded by `shader_fluid_mg_residual_restrict`; at `L3` (`8×4×8`), `50%` of threads (`cell.y >= 4`) early-return. |
+| 11 | [`shader_fluid_mg_smooth`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js) (`Fluid / pressure / smooth`) | `8×8×4` (`256` / `8`) | `2,400 B` | `2 / 5` | `1 / 5 / 2 / 0 / 0` | `359 / 28` | **Unstaged prolongation (`4,800` global reads/WG for `144` coarse cells)**; **redundant global re-read of `input`** at line 140; dead trailing `workgroupBarrier()` at line 169. |
+| 12 | [`shader_fluid_mg_residual_restrict`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js) (`Fluid / pressure / residual + restrict`) | `8×8×4` (`256` / `8`) | `3,424 B` | `2 / 2` | `1 / 4 / 3 / 0 / 0` | `327 / 26` | **87.5% of threads (`224/256`) sit idle** during `if (lane < 32u)` restriction after barrier 1; redundant global re-read of `input` at line 114; dead trailing `workgroupBarrier()` at line 137. |
+| 13 | [`shader_fluid_mg_coarsest`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js) (`Fluid / pressure / coarsest`) | `256×1×1` (`256` / `8`) | `1,024 B` | `2 / 17` | `1 / 3 / 2 / 0 / 0` | `245 / 18` | `17` serial `workgroupBarrier()`s (`8` red-black sweeps + dead trailing barrier at line 150 before `subgroup_atomic_add_u32`); `7.2 µs` on RTX 4090. |
+| 14 | [`shader_fluid_forcing_extract`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_extract.js) (`Fluid / forcing / extract leaves`) | `64×1×1` (`64` / `2`) | `512 B` | `1 / 1` | `1 / 3 / 3 / 0 / 0` | `410 / 15` | 2-warp WG; lightweight (`~1–2 µs`). |
+| 15 | [`shader_fluid_forcing_query`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_query.js) (`Fluid / forcing / brick query`) | `64×1×1` (`64` / `2`) | `2,580 B` | `4 / 2+3·d` | `1 / 2 / 6 / 0 / 0` | `540 / 26` | **3 `workgroupBarrier()`s per BVH level** inside a 2-warp (`64`-thread) WG (`chunk_bvh_query_aabb_frontier.js`); no independent warps inside the WG to hide barrier stalls. |
+| 16 | [`shader_fluid_forcing_command`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.js) (`Fluid / forcing / commands`) | `1×1×1` (`1` / `1`) | `0 B` | `0 / 0` | `0 / 2 / 1 / 0 / 0` | `32 / 3` | 1-thread dispatch (`1 µs`) between `query` and `apply`; can be folded into `query`. |
+| 17 | [`shader_fluid_forcing_apply`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js) (`Fluid / forcing / apply`) | `4×4×4` (`64` / `2`) | `4,724 B` | `2 / 2` | `1 / 5 / 2 / 0 / 3` | **`825 / 45`** | **Extreme VGPR pressure + 2-warp WG:** copies 80 B `FluidObstacleRecord` + 64 B `mat4x4<f32>` + 48 B `FluidEffectorRecord` by value into VGPRs; re-normalizes 3 matrix columns per thread × 24 obstacles; 6-face effector divergence on `57.8%` of lanes. |
+| 18 | [`shader_fluid_wind_publish`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/publish/shader_fluid_wind_publish.js) (`Fluid / wind publish`) | `4×4×4` (`64` / `2`) | `0 B` | `0 / 0` | `3 / 0 / 0 / 6 / 1` | `300 / 19` | 2-warp WG; skirt threads (`local == 0` or `local == size-1`) diverge to run `3 × 8 = 24` dynamic `textureLoad`s from parent (`chunk_fluid_cascade_parent.js`). |
+| 19 | [`shader_fluid_query_gather`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/query/shader_fluid_query_gather.js) (`Fluid / query / gather`) | `64×1×1` (`64` / `2`) | `0 B` | `0 / 0` | `1 / 1 / 1 / 1 / 0` | `230 / 9` | Uses software 8-tap `textureLoad` loop on `wind_field_atlas` even though `wind_field_atlas` is **already `rgba16float`** and hardware-filterable via `textureSampleLevel`. |
+
+---
+
+## 3. Deep-Dive Technical Findings (Verified Line-by-Line)
+
+### F-01: Nested $8 \times 8$ Dynamic Corner Loops & VGPR Explosion in `shader_fluid_mac_advect_predict` and `shader_fluid_mac_advect_correct`
+- **Location:** [`chunk_v3_mac_lattice_corners.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js#L82-L185), [`chunk_fluid_mac_seams.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/chunk_fluid_mac_seams.js#L50-L189), [`chunk_fluid_cascade_parent.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js#L79-L162), [`shader_fluid_mac_advect_predict.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_predict.js#L118-L202), [`shader_fluid_mac_advect_correct.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js#L139-L246).
+- **Mechanism:**
+  1. **The Hidden $8 \times 8$ Nested Loop Inside `v3_mac_source_corners_*` and `v3_mac_forward_corners_*`:**
+     Look at [`chunk_fluid_mac_seams.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/chunk_fluid_mac_seams.js#L55-L185):
+     - In `mac_carrier_u/v/w` (lines 123–145), an out-of-window read fetches `textureLoad(ghost_u, vec3<u32>(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH)), 0).r` directly.
+     - However, in `mac_source_u/v/w` (lines 99–121) and `mac_forward_u/v/w` (lines 163–185), an out-of-window read calls `fluid_mac_ghost_u/v/w(face)` (lines 55–83):
+       ```wgsl
+       fn fluid_mac_ghost_u(face: vec3<i32>) -> f32 {
+           let texel = face + vec3<i32>(FLUID_MAC_GHOST_DEPTH);
+           if (all(texel >= vec3<i32>(0)) && all(texel < vec3<i32>(step.faces_u.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH))) {
+               return textureLoad(ghost_u, vec3<u32>(texel), 0).r;
+           }
+           return fluid_parent_face_u(face, step.cells.corner - parent.origin);
+       }
+       ```
+     - Because `v3_mac_source_corners_u/v/w` and `v3_mac_forward_corners_u/v/w` ([`chunk_v3_mac_lattice_corners.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js#L82-L185)) call `mac_source_u/v/w` or `mac_forward_u/v/w` inside their 8-corner loop, and `fluid_parent_face_u/v/w` ([`chunk_fluid_cascade_parent.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js#L79-L162)) is itself an 8-corner trilinear gather, **every outer 8-corner gather contains a nested 8-corner parent gather ($8 \times 8 = 64$ corner evaluations per trilinear tap)**!
+     - Because WGSL has no stack-called functions in DXIL, DXC inlines the entire call tree. When these loops were statically unrolled (`for (var i = 0u; i < 8u; i++)`), inlining $8 \times 8 = 64$ parent `textureLoad` blocks across 6 trilinear taps and 2 boundary faces ($768+$ `textureLoad` blocks) caused DXC compilation to stall.
+     - To prevent DXC from unrolling that $8 \times 8$ tree, both the outer loop and inner loop were given a runtime-opaque bound (`let n_corners = select(0u, 8u, abs(position.x) < 1e30);`) and a `vec4<f32>` mask-select accumulator (`z0`, `z1`):
+       ```wgsl
+       let n_corners = select(0u, 8u, abs(position.x) < 1e30);
+       var z0 = vec4<f32>(0.0);
+       var z1 = vec4<f32>(0.0);
+       for (var i = 0u; i < n_corners; i++) {
+           let pt = vec3<i32>(
+               select(lo.x, hi.x, (i & 1u) != 0u),
+               select(lo.y, hi.y, (i & 2u) != 0u),
+               select(lo.z, hi.z, (i & 4u) != 0u)
+           );
+           let v = vec4<f32>(mac_source_u(pt));
+           let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+           z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+           z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+       }
+       ```
+  2. **Why This Cripples Runtime GPU Occupancy Even When 100% of Reads Hit `ghost_u/v/w`:**
+     - Even when `|v_far|·dt/h <= 1` (`|v_far| <= 20 m/s` at $h = 0.5\text{ m}, \Delta t = 25\text{ ms}$) so that every out-of-window tap hits `ghost_u/v/w` and never executes `fluid_parent_face_*` at runtime, the compiled shader still contains the **nested dynamic loop** inside the outer dynamic loop.
+     - Consequently, the register allocator must simultaneously keep live in VGPRs:
+       - Outer loop state (`i`, `n_corners`, `lo`, `hi`, `z0: vec4<f32>`, `z1: vec4<f32>`, `tap.weight`),
+       - Inner `fluid_parent_face_*` loop state (`i`, `n_corners`, `lattice`, `base`, `lo`, `hi`, `z0: vec4<f32>`, `z1: vec4<f32>`), and
+       - MacCormack / solid-bisection state (`start`, `travel`, `back`, `ahead`, `source`, `forward`).
+     - In addition, because the outer loop is dynamic (`i < n_corners`) and branches between `source_*` and `ghost_*` on every iteration, the GPU cannot issue the 8 corner `textureLoad`s in parallel; it serializes texture memory latency across 8 loop iterations.
+  3. **Mathematical Proof That `fluid_parent_face_*` Never Needs to Be Inside the 8-Corner Loop:**
+     - In `v3_mac_source_corners_*` and `v3_mac_forward_corners_*`, the 8 corners span `tap.lo` to `tap.hi = tap.lo + vec3<i32>(1)`.
+     - Since `FLUID_MAC_GHOST_DEPTH = 6 >= 1`, if **any** corner of `[tap.lo, tap.hi]` lies outside the ghost shell `[-6, size + 6)`, then along that axis either `tap.lo <= -7` (so `tap.hi <= -6 < 0`) or `tap.hi >= size + 6` (so `tap.lo >= size + 5 >= size`).
+     - Because a 3D lattice point lies inside the child window `[0, size)` only if **all three** coordinates lie in `[0, size)`, whenever a tap exceeds the ghost shell on any axis, **all 8 corners of `[tap.lo, tap.hi]` are guaranteed to lie outside the child window**!
+     - Therefore, `fluid_parent_face_*` **never** needs to be called per corner inside `fluid_mac_ghost_*`. Checking `any(tap.lo < vec3<i32>(-FLUID_MAC_GHOST_DEPTH)) || any(tap.hi >= size + vec3<i32>(FLUID_MAC_GHOST_DEPTH))` **once before the 8-corner loop** and calling `fluid_parent_face_*` once outside the loop (while making `fluid_mac_ghost_*` an unconditional `textureLoad(ghost_*)` just like `mac_carrier_*`) preserves 100% exact storm-wind fallback behavior while completely eliminating the $8 \times 8$ nested loop!
+  4. **Upper-Face Boundary Warp Divergence (`u_end`, `v_end`, `w_end`):**
+     In both `advect_predict` and `advect_correct`, threads at `cell.x == last.x`, `cell.y == last.y`, or `cell.z == last.z` run `for (var dx = 0; dx < u_end; dx++)` with `u_end = 2`. In every boundary workgroup (`8×8×4`), when `cell.x == 63`, **4 threads in each 32-thread warp (`12.5%` of the warp)** execute a second full MacCormack advection pass while the other **28 threads (`87.5%` of the warp)** sit masked off.
+
+---
+
+### F-02: Unstaged Prolongation (`33.3×` Read Amplification), Redundant Global Reads, `87.5%` Restrict Warp Idling, and 16 Dead Barriers in the Multigrid Solve
+- **Location:** [`shader_fluid_mg_smooth.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js#L63-L171), [`shader_fluid_mg_residual_restrict.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js#L49-L142), [`shader_fluid_mg_coarsest.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js#L140-L153), [`chunk_fluid_mg_prolong.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/chunk_fluid_mg_prolong.js#L35-L62).
+- **Mechanism:**
+  1. **Unstaged Coarse Tile Prolongation (`4,800` global reads per workgroup for `144` unique coarse values):**
+     - On the up-leg of the V-cycle (`params.prolong != 0u`), [`shader_fluid_mg_smooth.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js#L66-L68) calls `fluid_mg_prolong` inside `grid_tile_f32_fetch_inside` for all **600 cells** of the `10×10×6` fine tile+halo (`3` load rounds × `256` threads).
+     - Each `fluid_mg_prolong` call ([`chunk_fluid_mg_prolong.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/chunk_fluid_mg_prolong.js#L45-L56)) executes **8 global buffer reads** from `coarse`, totaling **`600 × 8 = 4,800` global buffer reads per workgroup**.
+     - Yet a `10×10×6` fine halo tile (`[-1..8] × [-1..8] × [-1..4]` relative to the `8×8×4` tile base) touches at most **`6×6×4 = 144` unique coarse cells** (`coarse_cell = (fine_cell + 1) >> 1` for `fine_cell ∈ [-2..9]`, spanning `[-1..4]` on $x,y$ and `[-1..2]` on $z$).
+     - This `33.3×` global read amplification explains why the up-leg smoother is measured at **`19.5 µs` vs. `13.3 µs` (`+46.6%` slower)** than the down-leg smoother at `128×32×128` ([`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md#L982-L983)).
+  2. **Redundant Post-Barrier Global Re-Read of `held = input[...]`:**
+     - In [`shader_fluid_mg_smooth.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js#L125-L143):
+       ```wgsl
+       grid_tile_f32_load(&tile_p, params.source, fluid_mg_input_window(), workgroup_id, lane);
+       // ...
+       let held = input[fluid_mg_input_index(fluid_mg_input_storage(cell))];
+       var nonfinite_here = select(0u, 1u, !is_finite(held));
+       ```
+     - And identically in [`shader_fluid_mg_residual_restrict.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js#L103-L115):
+       ```wgsl
+       grid_tile_f32_load(&tile_p, params.source, fluid_mg_input_window(), workgroup_id, lane);
+       // ...
+       let held = input[fluid_mg_input_index(fluid_mg_input_storage(cell))];
+       let nonfinite_here = select(0u, 1u, !is_finite(held) || !is_finite(rhs_value));
+       ```
+     - Both kernels **already read `input[...]` for all 600 tile+halo cells inside `grid_tile_f32_load`**! Re-reading `input[...]` from global memory after the barrier issues `256` redundant global loads per workgroup (`131,072` redundant loads per `L0` dispatch) across all **14 smooth and restrict dispatches** per cascade step.
+  3. **`87.5%` Warp Idling During Coarse Restriction (`if (lane < 32u)`):**
+     - In [`shader_fluid_mg_residual_restrict.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js#L120-L137), after writing `tile_r[lane] = residual;` and executing `workgroupBarrier()`, only `if (lane < 32u)` (Warp 0) executes `fluid_mg_restrict` (reading `8` values per thread from `tile_r`) while **Warps 1–7 (`224` of `256` threads = `87.5%`) sit completely idle**.
+  4. **16 Dead Trailing `workgroupBarrier()`s per Cascade Step:**
+     - [`shader_fluid_mg_smooth.js:169`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js#L169), [`shader_fluid_mg_residual_restrict.js:137`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js#L137), and [`shader_fluid_mg_coarsest.js:150`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js#L150) each execute a `workgroupBarrier()` immediately before calling `subgroup_atomic_add_u32(&nonfinite[0], nonfinite_here);`.
+     - As verified in [`chunk_subgroup_atomic_add.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_add.js#L19-L26), `subgroup_atomic_add_u32` uses only `subgroupAdd(value)`, `subgroupElect()`, and `atomicAdd(counter, total)` — it **never accesses `var<workgroup>` memory**! Those trailing barriers are leftover artifacts from when `nonfinite` used a workgroup shared-memory reduction tree, wasting 16 barrier synchronizations per cascade step.
+
+---
+
+### F-03: `shader_fluid_forcing_apply` & `shader_fluid_forcing_query` Register Bloat, 2-Warp Workgroups, and Redundant Matrix Normalizations
+- **Location:** [`shader_fluid_forcing_apply.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js#L43-L162), [`chunk_fluid_forcing_cell.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js#L92-L148), [`chunk_fluid_obstacle_record.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/chunk_fluid_obstacle_record.js#L26-L70), [`shader_fluid_forcing_query.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_query.js#L50-L152).
+- **Mechanism:**
+  1. **By-Value Struct Copies from LDS into Per-Lane VGPRs (`80 B` + `64 B` + `48 B`):**
+     In [`shader_fluid_forcing_apply.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js#L69-L77):
+     ```wgsl
+     fn fluid_forcing_read_obstacle(slot: u32) -> FluidObstacleRecord { return fluid_forcing_obstacles[slot]; }
+     fn fluid_forcing_read_obstacle_global(slot: u32) -> mat4x4<f32> { return fluid_forcing_globals[slot]; }
+     fn fluid_forcing_read_effector(slot: u32) -> FluidEffectorRecord { return fluid_forcing_effectors[slot]; }
+     ```
+     Inside [`chunk_fluid_forcing_cell.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js#L98-L115), every thread copies the entire `FluidObstacleRecord` (`20 × 4 B = 80 B`) and `mat4x4<f32>` (`16 × 4 B = 64 B`) by value out of LDS into VGPRs on every iteration of the `24`-obstacle loop, even though `linear_velocity` is only used if the cell is inside the obstacle and row 3 of `mat4x4<f32>` is always `(0, 0, 0, 1)`.
+  2. **Redundant Per-Thread `mat4x4` Column Normalization (`64×` duplicate `inverseSqrt`s per obstacle):**
+     In [`chunk_fluid_obstacle_record.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/chunk_fluid_obstacle_record.js#L35-L42):
+     ```wgsl
+     let x = normalize(global[0].xyz);
+     let y = normalize(global[1].xyz);
+     let z = normalize(global[2].xyz);
+     let local = vec3<f32>(dot(offset, x), dot(offset, y), dot(offset, z));
+     ```
+     Every one of the `64` threads in the brick normalizes `global[0..2].xyz` for every obstacle in the brick (`up to 24 × 3 = 72` `normalize()` calls per thread), even though `fluid_forcing_globals[lane]` is cooperatively loaded into LDS once at lines 99–103 of `shader_fluid_forcing_apply.js`! Normalizing the 3 columns **once when loading into LDS** eliminates all 72 `normalize()` calls from the per-cell loop and shrinks `fluid_forcing_globals` from `24 × 64 B = 1,536 B` (`mat4x4<f32>`) to `24 × 48 B = 1,152 B` (`mat3x4<f32>`).
+  3. **6-Face Effector Divergence on Brick Upper Faces (`57.8%` of brick lanes):**
+     In [`shader_fluid_forcing_apply.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js#L139-L161), threads on the $+x, +y, +z$ faces of the `4×4×4` brick (`local_id.x == 3`, `local_id.y == 3`, `local_id.z == 3` — which is $64 - 27 = 37$ of the $64$ threads) execute a second `fluid_forcing_face_deposit` loop (`up to 16` effectors) per boundary axis while interior lanes in the same warp sit masked off.
+  4. **2-Warp Workgroups (`64` threads) Under Heavy Barrier & Register Load:**
+     Both `shader_fluid_forcing_query` (`@workgroup_size(64)`) and `shader_fluid_forcing_apply` (`@workgroup_size(4, 4, 4)`) have only **2 warps per workgroup**. In `shader_fluid_forcing_query`, [`chunk_bvh_query_aabb_frontier.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_frontier.js) executes **3 `workgroupBarrier()`s per BVH level**. With only 2 warps per workgroup, each barrier drains the workgroup's instruction pipeline completely.
+
+---
+
+### F-04: `shader_fluid_cascade_ghosts` Hollow Bounding-Box Dispatch (`53.66%` Dead Threads) & Pressure Offset Misalignment
+- **Location:** [`FluidMacPasses.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/FluidMacPasses.js#L178-L181), [`shader_fluid_cascade_ghosts.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.js#L35-L58).
+- **Exact Quantitative Accounting (at default `64×32×64`, `FLUID_CASCADE_GHOST_DEPTH = 6`):**
+  - `FluidMacPasses.js` dispatches `threads = [77, 45, 77]` in `4×4×4` workgroups → `20 × 12 × 20 = 4,800` workgroups = **`307,200` threads**.
+  - Across the `307,200` launched threads:
+    - **Active threads (writing at least one of `u, v, w, p`):** `142,349` (`46.34%`).
+    - **Completely dead threads (writing nothing):** **`164,851` (`53.66%`)**.
+    - **100% no-op workgroups (all 64 threads exit without writing anything):** **`1,226` of `4,800` workgroups (`25.54%`)**.
+    - **Per-branch active threads:** `u`: `124,368` (`40.48%`), `v`: `124,752` (`40.61%`), `w`: `124,368` (`40.48%`), `ghost_pressure`: **`17,032` (`5.54%` — `94.46%` of threads are dead on the pressure branch)**.
+  - **Coordinate Offset Misalignment (Lines 36 vs. 53):**
+    - Velocity ghosts use `let face = vec3<i32>(id) - vec3<i32>(6);` (line 36), so the interior velocity cutout is `id ∈ [6..70] × [6..38] × [6..70]`.
+    - Pressure ghosts use `let cell = vec3<i32>(id) - vec3<i32>(1);` (line 53), so the $+x, +y, +z$ faces of the pressure ghost shell lie at **`id.x = 65`, `id.y = 33`, `id.z = 65` — cutting straight through the interior velocity cutout `[6..70, 6..38, 6..70]`**!
+    - This wakes up `574` otherwise-empty interior workgroups so a single plane of `16` threads in the `4×4×4` workgroup can write `ghost_pressure` while the other `48` threads in the workgroup do nothing.
+
+---
+
+### F-05: `shader_fluid_mac_curl` `16,224 B` LDS Ceiling & Duplicate `fluid_curl_omega` Evaluation
+- **Location:** [`shader_fluid_mac_curl.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_curl.js#L35-L171).
+- **Mechanism:**
+  1. Allocates `3 × 1,152 × 4 B = 13,824 B` (`fluid_curl_u/v/w`) + `600 × 4 B = 2,400 B` (`fluid_curl_magnitude`) = **`16,224` bytes of `var<workgroup>` memory** (`99.0%` of the 16 KiB limit), restricting residency to 1–2 workgroups per CU/SM (`16.7%–33.3%` warp occupancy).
+  2. Computes `fluid_curl_omega(local)` (`12` LDS reads + `6` subtractions) **twice** for every interior cell: once at line 142 (`fluid_curl_magnitude[index] = length(fluid_curl_omega(local))`) and a second time after the barrier at line 164 (`let omega = fluid_curl_omega(local)`).
+  3. Changing the LDS arrays to `f16` (`enable f16;`, per [`SHADER_F16_PROPOSAL_2026_10_24.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/SHADER_F16_PROPOSAL_2026_10_24.md#L112) `F16-03`) immediately halves LDS from **`16,224 B` to `8,112 B`**, and keeping the interior thread's `omega: vec3<f16>` in registers across the second barrier allows `fluid_curl_magnitude` to alias `fluid_curl_u[0..599]`, dropping total LDS to **`6,912 B`** (`42%` of the 16 KiB limit) and eliminating `256` duplicate `fluid_curl_omega` evaluations per workgroup.
+
+---
+
+### F-06: `shader_fluid_mac_gradient` Redundant Double Halo Load & Double Barrier
+- **Location:** [`shader_fluid_mac_gradient.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_gradient.js#L35-L120), [`chunk_grid_tile_halo_f32.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_f32.js#L62-L89).
+- **Mechanism:**
+  - Lines 115–116 of `shader_fluid_mac_gradient.js` call `grid_tile_f32_load` **twice in a row**:
+    ```wgsl
+    grid_tile_f32_load(&fluid_mac_tile_pressure, FLUID_MAC_TILE_SOURCE_PRESSURE, step.cells, workgroup_id, local_index);
+    grid_tile_f32_load(&fluid_mac_tile_solid, FLUID_MAC_TILE_SOURCE_SOLID, step.cells, workgroup_id, local_index);
+    ```
+  - Because `grid_tile_f32_load` contains its own 3-iteration `index_to_grid3d` unpack loop and ends with `workgroupBarrier()`, calling it twice executes **two `workgroupBarrier()`s** and **two coordinate-unpack loops** serially, while spending **`2,400 B` of LDS** (`fluid_mac_tile_solid: array<f32, 600>`) to store a 1-bit `solid` flag as a 32-bit `f32`.
+  - Since `fluid_mac_tile_pressure` is never read for a solid cell (line 93: `if (fluid_mac_tile_cell_solid(a) || fluid_mac_tile_cell_solid(b)) { return current; }`), encoding a solid cell as a sentinel value (`F32_MAX`) inside `fluid_mac_tile_pressure` **eliminates `fluid_mac_tile_solid` (`2,400 B` LDS) and the second `grid_tile_f32_load` call (1 loop + 1 `workgroupBarrier()`) completely**.
+
+---
+
+### F-07: Underutilization of `r16float` Velocity Textures, `f16` LDS Tiles, and Hardware `textureSampleLevel`
+- **Location:** [`FluidMacVelocitySet.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/FluidMacVelocitySet.js), [`shader_fluid_query_gather.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/query/shader_fluid_query_gather.js#L21-L65), [`chunk_v3_mac_lattice_corners.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js), [`chunk_fluid_cascade_parent.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js).
+- **Mechanism:**
+  1. **Unnecessary 8-Tap Software Gather on `wind_field_atlas` in `shader_fluid_query_gather`:**
+     External GPU consumers ([`chunk_wind_field_sample_cascades.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/wind/chunk_wind_field_sample_cascades.js#L57)) sample `wind_field_atlas` (`rgba16float`) using a single hardware `textureSampleLevel` instruction. Yet [`shader_fluid_query_gather.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/query/shader_fluid_query_gather.js#L21-L62), which reads **that exact same `rgba16float` `wind_field_atlas` texture**, binds it as `unfilterable-float` and executes a manual 8-iteration `textureLoad` loop (`16` `textureLoad`s per query point in the blend band instead of `2` hardware `textureSampleLevel`s).
+  2. **`r32float` vs. `r16float` Internal Velocity & Ghost Textures:**
+     All internal velocity and ghost 3D textures (`u, v, w`, `forward_u/v/w`, `advected_u/v/w`, `ghost_u/v/w`) are `r32float` (`4 B`/texel, `unfilterable-float`), even though the published wind field is `rgba16float` (`2 B`/channel) and `r16float` supports both `STORAGE_BINDING` (`write-only`, via `texture-formats-tier1` in `SHADE_DEVICE_FLOOR`) and `TEXTURE_BINDING` (`filterable-float`).
+     - In [`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md#L591-L606) (§10, D6), software `textureLoad` of the 8 corners was retained in `advect_correct` for two specific reasons: (a) MacCormack's limiter requires the 8-corner `min` and `max` of `source_u/v/w`, and (b) 8-bit hardware trilinear filter weights (`1/256` sub-texel quantization) would perturb the second-order correction $\tfrac{1}{2}(\phi^n - \tilde{\phi})$.
+     - However:
+       1. Storing `u, v, w`, `forward_u/v/w`, `advected_u/v/w`, and `ghost_u/v/w` in **`r16float`** halves 3D texture memory footprint and cache bandwidth (`4 B → 2 B`/texel) across **every pass** (`fill`, `ghosts`, `restrict`, `curl`, `advect_predict`, `advect_correct`, `divergence`, `gradient`, `forcing_apply`, `wind_publish`) while still allowing `textureLoad` of the 8 corners in `advect_predict` and `advect_correct` with exact `f32` trilinear weights and exact 8-corner `min/max` bounds!
+       2. Furthermore, parent cascade interpolation (`fluid_parent_face_u/v/w` in `cascade_fill`, `cascade_ghosts`, `advect_correct` epilogue, and `wind_publish`) has no MacCormack difference and no `min/max` limiter — on `r16float` parent textures, every interior parent read reduces from an 8-iteration `textureLoad` loop (`24` loads for $(u, v, w)$) to a single hardware `textureSampleLevel` (`3` loads for $(u, v, w)$).
+       3. Finally, [`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md#L600-L603) noted that LDS-tiling `advect_correct` was previously infeasible in `f32` because staging both $\phi^n$ and $\hat{\phi}$ required `29.6 KiB > 16 KiB`. With `enable f16;`, staging both fields in `f16` requires `14.8 KiB`, fitting within the `16 KiB` workgroup memory budget whenever CFL $\le 4$.
+
+---
+
+## 4. Comparison Against Real-Time SotA GPU Wind & Dense Eulerian Solvers
+
+Because atmospheric wind is **space-filling** (ambient flow, gusts, and wakes occupy the entire domain around the camera/player), the relevant State-of-the-Art comparisons are **real-time dense/clipmap wind solvers and dense GPU Eulerian projection/transport architectures**:
+
+| Dimension | **Meep `shade/renderer/fluid` (Current)** | **Frostbite / Battlefield Volumetric Wind Clipmaps** | **Ubisoft La Forge — Compact Poisson Filters (Rabbani et al., SIGGRAPH 2022)** | **AAA Dense GPU Eulerian Grids (UE5 Niagara Grid3D / Horizon / God of War Wind)** | **Academic Dense Grid SotA (McAdams 2010 GMG / Advection-Reflection / Covector)** | **Real-Time Aerodynamic LBM (HOME-LBM 2023 / Weakly-Compressible Wind)** |
+|---|---|---|---|---|---|---|
+| **Domain Topology** | Nested player-centered 3D toroidal clipmap cascades (`4 × 64×32×64`, $2^c$ subcycling). | Nested camera/player-centered 3D clipmap cascades (`64×32×64` or `128×32×128`). | Dense 3D wind volume / clipmap around player and obstacles. | Dense 3D world-aligned or camera-following grid (`64³–128³`). | Dense 3D MAC grid with harmonic/cut-cell face weights. | Dense 3D clipmap/nested lattice (`64³–128³` per level, $2^c$ acoustic subcycling). |
+| **Velocity Storage & Precision** | Staggered MAC in **3× `r32float` 3D textures** + 3× `r32float` ghost textures; published to `rgba16float` atlas. | Collocated **`rgba16float`** (`vec4<f16>`) deviation from ambient wind field. | Collocated or staggered **`rgba16float` / `r16float`**. | Staggered **`r16float`** or collocated **`rgba16float`** 3D textures. | Staggered MAC (`r16float` velocity, `f32` pressure). | Moment-encoded **`f16` / `snorm16`** (`10` words/cell: $\rho, \mathbf{u}, \boldsymbol{\Pi}^{\text{neq}}$) instead of 19/27 DDFs. |
+| **Trilinear Sampling** | **Software 8-tap `textureLoad` loops** internally; hardware `textureSampleLevel` only in `wind_field_sample`. | **Hardware `textureSampleLevel`** on `rgba16float` everywhere. | **Hardware `textureSampleLevel`** on `rgba16float` / `r16float`. | **Hardware `textureSampleLevel`** on `r16float` / `rgba16float`. | Hardware `textureSampleLevel` for parent/SL taps; 8-corner `r16float` `textureLoad` for MacCormack clamp. | Strictly local integer neighbor reads (`±1` cell); no trilinear interpolation. |
+| **Advection & Vorticity** | **2-pass MacCormack** (`predict` + `correct`) with 4-step solid bisection + optional 2-barrier LDS `curl` pass. | 1-pass Semi-Lagrangian + analytical vortex/motor primitives. | 1-pass Semi-Lagrangian or MacCormack + analytical curl/vorticity injection. | 1-pass Semi-Lagrangian or BFECC/MacCormack + vorticity confinement. | **Advection-Reflection** (Zehnder 2018) or **Covector** (Nabizadeh 2022). | Inherent low-dissipation BGK/TRT/cumulant collision (advection is exact lattice streaming). |
+| **Incompressibility / Projection** | **2 V-cycles of GMG** (`24` dispatches/step): 2-sweep Red-Black GS in `8×8×4` `f32` LDS tiles; harmonic 6-face `u32` weight words. | Approximate local divergence relaxation (2–4 Jacobi sweeps) or motor-only divergence-free primitives. | **Compact Poisson Filter (CPF):** 1–3 separable/blocked 3D convolution passes (`O(1)` dispatches, zero V-cycles!). | 1–2 V-cycles GMG with damped Jacobi / Red-Black GS, or 16–24 Jacobi sweeps. | **1–2 V-cycles GMG / MGPCG** with staged coarse prolongation in LDS and fused restriction/coarsening. | **Zero Poisson passes** (weakly-compressible equation of state $p = c_s^2 \rho$ handled locally in collision). |
+| **Obstacle Coupling** | Per-frame LBVH → cooperative brick query (`4×4×4`) → SDF + moving-wall face pinning + 4-level MG harmonic weights. | Heightfield + coarse SDF wind-shadow mask. | Binary/smooth solid mask folded into filter weights. | SDF/collider stamp into grid solid mask and velocity. | Harmonic face weights restricted alongside residuals down the V-cycle. | Bounce-back or interpolated bounce-back boundary condition inside the single LBM pass. |
+| **GPU Occupancy Profile** | **Low (`15%–35%` on heavy passes):** VGPR bloat from nested $8\times 8$ dynamic corner loops (`advect`), `16.2 KB` `f32` LDS (`curl`), unstaged MG prolongation, `64`-thread WGs (`forcing`, `ghosts`). | **High (`70%–90%`):** Simple hardware-filtered `rgba16float` kernels, no nested loops, minimal LDS. | **Very High (`80%–95%`):** Fixed-radius convolution kernels with `100%` active threads and zero barriers. | **Medium–High (`50%–80%`):** Hardware TMU filtering, `f16` textures, low register count. | **High (`65%–85%`):** Staged LDS tiles, no nested dynamic loops, fused restriction. | **Very High (`75%–95%`):** 1–2 fused passes per step, 100% coalesced reads, zero global reductions/V-cycles. |
+
+### Architectural Assessment
+
+1. **What the Current Meep Wind Solver Gets Right (Preserve):**
+   - **Staggered MAC Discretization with Moving-Wall Face Pinning & Harmonic Multigrid Weights:** As proven in [`REVIEW_02_PLAN.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/REVIEW_02_PLAN.md#L116-L120), MAC staggering eliminates the collocated checkerboard null-mode (`D ∘ G ≡ L`), achieves exact zero wall penetration, and stabilizes MacCormack velocity transport without energy pumping. The 30-bit harmonic face-weight word (`chunk_fluid_mg_coarse_word.js`) preserves thin 1-cell obstacles across coarse multigrid levels, and the finite-volume Dirichlet edge weight `2 / (1 + 2^-level)` (`FLUID_MG.js`) keeps the boundary ghost location consistent across levels.
+   - **Atmosphere Deviation Identity & $2^c$ Cascade Subcycling:** Tracking the exact far-field ODE integration (`keep = exp(-ΔΛ)`) and publishing `rgba16float` deviations (`v - v_far`) into the clipmap atlas ensures that uniform or gusting ambient wind is represented with zero numerical drift across all cascades.
+   - **LBVH-Culled $4\times 4\times 4$ Brick Forcing:** While the wind velocity/pressure grid itself is dense and space-filling, obstacles and effectors are spatially sparse. Culling $4\times 4\times 4$ bricks via the LBVH (`GPUFluidForcing`) avoids evaluating 24 obstacles × 16 effectors across empty air bricks.
+
+2. **Where the Current Implementation Loses Occupancy Against SotA:**
+   - **Nested $8 \times 8$ Dynamic Loops in Advection (`chunk_v3_mac_lattice_corners.js` + `chunk_fluid_mac_seams.js`):** No SotA GPU solver runs a dynamic loop (`select(0u, 8u, ...)`) containing a nested dynamic 8-corner parent loop inside every trilinear velocity tap.
+   - **Unstaged Prolongation, Redundant Global Reads, `87.5%` Restrict Warp Idling, and Dead Barriers in Multigrid:** Issuing `4,800` global reads per workgroup for a `144`-cell coarse neighborhood in `shader_fluid_mg_smooth`, re-reading `input` from global memory after loading `tile_p`, idling 7 of 8 warps during restriction, and executing 16 dead trailing `workgroupBarrier()`s directly inflate the `71 µs` smoother/restriction cost.
+   - **`f32` LDS Ceiling in `shader_fluid_mac_curl` and `r32float` Velocity Storage:** Allocating `16,224 B` of `f32` LDS in `mac_curl` caps residency to 1–2 workgroups per CU/SM, while storing all velocity and ghost textures in `r32float` doubles 3D texture memory bandwidth relative to `r16float`.
+   - **Hollow-Box Dispatch in `shader_fluid_cascade_ghosts` and Unfused Multigrid Weight Passes:** Launching `307,200` threads over a solid box to write a hollow shell (`53.66%` dead threads) and running 4 separate weight-building dispatches (`level0_weights` + 3× `coarse_weights`) over cells and `words` already traversed by `mac_divergence` and `mg_residual_restrict` waste GPU occupancy every step.
+
+---
+
+## 5. Prioritized Recommendations & Implementation Roadmap
+
+All recommendations below preserve the solver's space-filling clipmap MAC architecture, respect the `1.25×` CPU quality gate ([`GPUFluidCascade.quality.slow.spec.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/GPUFluidCascade.quality.slow.spec.js)) and precision boundaries ([`SHADER_F16_PROPOSAL_2026_10_24.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/SHADER_F16_PROPOSAL_2026_10_24.md) `F16-03` & `NO-F16-09`), and leverage `enable f16;` (`shader-f16`) and `r16float` (`texture-formats-tier1`).
+
+---
+
+### Priority 1 — High-Leverage Occupancy & Execution Fixes in the Hot Passes (`mg_smooth`, `mg_restrict`, `advect`, `curl`, `gradient`, `ghosts`)
+
+#### R-01: Hoist `fluid_parent_face_*` Out of `fluid_mac_ghost_*` to Eliminate the Nested $8\times 8$ Dynamic Loop & Use `vec4<f16>` Corner Accumulators
+- **Target Files:** [`chunk_fluid_mac_seams.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/chunk_fluid_mac_seams.js#L50-L189), [`chunk_v3_mac_lattice_corners.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js#L82-L185).
+- **Problem:** `mac_source_u/v/w` and `mac_forward_u/v/w` call `fluid_mac_ghost_u/v/w(face)`, which falls back to `fluid_parent_face_u/v/w` when `texel` is outside `[0, size + 2*depth)`. This single fallback forces DXC to inline an **8-iteration dynamic loop (`fluid_parent_face_*`) inside every iteration of the outer 8-iteration corner loops (`v3_mac_source_corners_*` and `v3_mac_forward_corners_*`)** in both `advect_predict` (`16 µs`) and `advect_correct` (`27 µs`), exploding live VGPR state (`2×` `z0/z1` `vec4<f32>` accumulators + loop counters + coordinate vectors across two loop levels).
+- **Fix:**
+  1. **Make `fluid_mac_ghost_u/v/w(face)` a pure `textureLoad` from `ghost_u/v/w` (matching `mac_carrier_u/v/w`):**
+     ```wgsl
+     fn fluid_mac_ghost_u(face: vec3<i32>) -> f32 {
+         let texel = clamp(
+             face + vec3<i32>(FLUID_MAC_GHOST_DEPTH),
+             vec3<i32>(0),
+             vec3<i32>(step.faces_u.size) + vec3<i32>(2 * FLUID_MAC_GHOST_DEPTH - 1)
+         );
+         return textureLoad(ghost_u, vec3<u32>(texel), 0).r;
+     }
+     ```
+  2. **Hoist the storm-wind (`|v_far|·dt/h > 1`) parent fallback outside the 8-corner loop in `v3_mac_source_corners_*` and `v3_mac_forward_corners_*`:**
+     As proven in **F-01.3**, because `tap.hi == tap.lo + 1` and `FLUID_MAC_GHOST_DEPTH = 6 >= 1`, whenever `any(tap.lo < vec3<i32>(-FLUID_MAC_GHOST_DEPTH)) || any(tap.hi >= vec3<i32>(step.faces_u.size) + vec3<i32>(FLUID_MAC_GHOST_DEPTH))`, **all 8 corners of `tap` are guaranteed to lie outside the child window**. Evaluating `fluid_parent_face_*` in an `if` branch *before* the 8-corner loop preserves 100% exact storm-wind behavior while completely eliminating the $8 \times 8$ loop nesting!
+  3. **Use `vec4<f16>` for `z0` and `z1` (`enable f16;`)**:
+     In `chunk_v3_mac_lattice_corners.js` and `chunk_fluid_cascade_parent.js`, store the 8 corner samples in `var z0: vec4<f16>; var z1: vec4<f16>;` (converting back to `vec4<f32>` for the trilinear weight dot product), cutting the live corner-accumulator VGPRs from `8 × 32-bit` to `4 × 32-bit` registers.
+- **Impact:** Eliminates all nested $8\times 8$ dynamic `textureLoad` loops in `advect_predict` (`16 µs`) and `advect_correct` (`27 µs`) while preserving exact storm-wind fallback, substantially reducing VGPR pressure and increasing warp occupancy across `29.8%` of the step.
+
+#### R-02: Stage the `6×6×4` Coarse Tile in LDS in `shader_fluid_mg_smooth`, Drop Redundant `held = input[...]` Global Reads, Parallelize Restriction, and Delete 16 Dead Trailing Barriers
+- **Target Files:** [`shader_fluid_mg_smooth.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.js#L63-L171), [`shader_fluid_mg_residual_restrict.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js#L49-L142), [`shader_fluid_mg_coarsest.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js#L140-L153).
+- **Problem:**
+  1. Up-leg `shader_fluid_mg_smooth` (`params.prolong != 0u`) calls `fluid_mg_prolong` for all `600` halo cells, issuing **`600 × 8 = 4,800` global reads from `coarse`** per workgroup for a region that spans only **`6×6×4 = 144` unique coarse cells**.
+  2. Both `shader_fluid_mg_smooth.js:140` and `shader_fluid_mg_residual_restrict.js:114` re-read `let held = input[fluid_mg_input_index(...)]` from global memory after `grid_tile_f32_load` has already fetched `input` for the entire tile into `tile_p`.
+  3. All three pressure barrier kernels (`shader_fluid_mg_smooth.js:169`, `shader_fluid_mg_residual_restrict.js:137`, `shader_fluid_mg_coarsest.js:150`) execute a trailing `workgroupBarrier()` immediately before `subgroup_atomic_add_u32(&nonfinite[0], nonfinite_here);`, even though `subgroup_atomic_add_u32` uses only subgroup intrinsics and global atomics and **never touches `var<workgroup>` memory**.
+  4. In `shader_fluid_mg_residual_restrict.js:128`, `if (lane < 32u)` uses only 1 warp (`32` threads) to sum 8 fine residuals per coarse cell while 7 warps (`224` threads = `87.5%`) sit idle.
+- **Fix:**
+  1. **Stage `144` coarse cells in LDS (`tile_coarse: array<f32, 144>`, `576 B`):** When `params.prolong != 0u`, lanes `0..143` load the `6×6×4` coarse neighborhood (`coarse_base = vec3<i32>(workgroup_id * vec3<u32>(4u, 4u, 2u)) - vec3<i32>(1)`) into `tile_coarse` (`144` global loads instead of `4,800`) before the halo load barrier, and `fluid_mg_prolong` reads its 8 trilinear corners from `tile_coarse`. Total LDS in `shader_fluid_mg_smooth` is `2,400 + 576 = 2,976 B` (`18.2%` of 16 KiB, preserving 5–6 WGs/SM = `83%–100%` occupancy on RTX 4090 and 100% `f32` precision per `NO-F16-09`).
+  2. **Eliminate redundant `held = input[...]` global reads & call `subgroup_atomic_add_u32` immediately:** In `shader_fluid_mg_residual_restrict` (`prolong == 0u`), `tile_p` already holds the sanitized `input` (or record a 1-bit `nonfinite` flag during `grid_tile_f32_load`) and call `subgroup_atomic_add_u32(&nonfinite[0], nonfinite_here)` immediately after the load barrier so `nonfinite_here` does not occupy a live VGPR across the stencil sweeps.
+  3. **Delete the 16 dead trailing `workgroupBarrier()`s** before `subgroup_atomic_add_u32` in `shader_fluid_mg_smooth.js:169`, `shader_fluid_mg_residual_restrict.js:137`, and `shader_fluid_mg_coarsest.js:150`.
+  4. **Parallelize restriction in `shader_fluid_mg_residual_restrict`:** Have threads `0..127` (`4` warps) reduce pairs of $z$-layers in `tile_r` (`tile_r[lane] += tile_r[lane + 128u]`) or map the $2\times 2\times 2$ fine block to 8 consecutive lanes so `subgroupAdd` / `subgroupShuffleXor` computes the 8-child mean without 7 warps idling.
+- **Impact:** Directly accelerates the **`71 µs` (`49.2%` of step)** multigrid smoother + restriction passes: cuts coarse prolongation global reads by **`33.3×` (`4,800 → 144`/WG)**, removes `256` redundant global loads per workgroup across 14 dispatches, and removes 16 dead `workgroupBarrier()`s per step while keeping full `f32` V-cycle precision (`NO-F16-09`).
+
+#### R-03: Migrate `shader_fluid_mac_curl` LDS Tiles to `f16` (`enable f16;`) and Compute `fluid_curl_omega` Once per Thread (`16,224 B → 6,912 B` LDS)
+- **Target Files:** [`shader_fluid_mac_curl.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_curl.js#L40-L171).
+- **Problem:** `shader_fluid_mac_curl` uses **`16,224 B` of `f32` LDS** (`99.0%` of WebGPU's `16,384 B` limit), capping CU/SM residency to 1–2 workgroups (`16.7%–33.3%` occupancy) and computing `fluid_curl_omega(local)` twice per interior cell (lines 142 and 164).
+- **Fix (aligned with [`SHADER_F16_PROPOSAL_2026_10_24.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/SHADER_F16_PROPOSAL_2026_10_24.md#L112) `F16-03`):**
+  1. Enable `f16` (`shader_fluid_mac_curl.addExtension(WebGPUExtensionType.ShaderF16)`), declare `fluid_curl_u/v/w: array<f16, 1152>` (`3 × 2,304 B = 6,912 B`) and `fluid_curl_magnitude: array<f16, 600>` (`1,200 B`).
+  2. Keep the interior cell's `let omega: vec3<f16> = fluid_curl_omega(vec3<i32>(local_id));` in a `vec3<f16>` register (`2` 32-bit VGPRs) across the second barrier instead of recomputing `fluid_curl_omega(local)` at line 164. Because `fluid_curl_u/v/w` is never read again after line 143 once `omega` is held in registers, `fluid_curl_magnitude` can also alias `fluid_curl_u[0..599]`, dropping total LDS from **`16,224 B` to `6,912 B` (`−57.4%`)**!
+- **Impact:** Doubles or triples LDS-limited workgroup residency in `shader_fluid_mac_curl` (`1–2 WGs/CU → 4+ WGs/CU`) and eliminates `256` duplicate 12-tap curl evaluations per workgroup (`131,072` fewer LDS reads per `L0` dispatch).
+
+#### R-04: Fuse `shader_fluid_mac_gradient`'s Double Halo Load & Sentinel-Encode `solid` (`2 Barriers → 1`, `4,800 B → 2,400 B` LDS)
+- **Target Files:** [`shader_fluid_mac_gradient.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_gradient.js#L35-L120).
+- **Problem:** `shader_fluid_mac_gradient` calls `grid_tile_f32_load` twice back-to-back (lines 115–116), executing **2 `workgroupBarrier()`s**, **2 halo coordinate-unpack loops**, and allocating **`2,400 B` of LDS** (`fluid_mac_tile_solid: array<f32, 600>`) for a 1-bit solid flag.
+- **Fix:** Because a solid cell's pressure is never read (`if (fluid_mac_tile_cell_solid(a) || fluid_mac_tile_cell_solid(b)) { return current; }`), write a sentinel value (`F32_MAX` or `bitcast<f32>(0x7f7fffffu)`) into `fluid_mac_tile_pressure[index]` whenever `mac_cell_solid(cell)` is `true` during the single load loop!
+- **Impact:** Deletes `fluid_mac_tile_solid` completely (`4,800 B → 2,400 B` LDS), deletes the second `grid_tile_f32_load` loop, and cuts `workgroupBarrier()` count in `shader_fluid_mac_gradient` from `2` to `1`.
+
+#### R-05: Fix `shader_fluid_cascade_ghosts` Pressure Shell Offset & Eliminate Interior No-Op Workgroups
+- **Target Files:** [`shader_fluid_cascade_ghosts.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/shader_fluid_cascade_ghosts.js#L35-L58), [`FluidMacPasses.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/FluidMacPasses.js#L178-L181).
+- **Problem:** Dispatches `[20, 12, 20] = 4,800` workgroups (`307,200` threads) over the filled `[77, 45, 77]` box where `164,851` threads (`53.66%`) are dead and `1,226` workgroups (`25.54%`) are 100% interior no-ops. Worse, `cell = vec3<i32>(id) - vec3<i32>(1)` (line 53) places the $+x, +y, +z$ pressure ghost faces at `id = (65, 33, 65)` — **inside** the velocity interior `[6..70, 6..38, 6..70]`.
+- **Fix:**
+  1. **Align pressure ghosts with velocity ghosts:** Set `let cell = face;` (`vec3<i32>(id) - vec3<i32>(FLUID_CASCADE_GHOST_DEPTH)`) and `let p_id = vec3<u32>(cell + vec3<i32>(1));`. Now the pressure ghost shell `cell ∈ [-1..size]` lies on the inner skin of the velocity ghost shell (`id ∈ [0..5]` and `[size+6..size+12]`), so **zero interior workgroups (`id ∈ [6..69, 6..37, 6..69]`) are ever touched by pressure ghosts** (`1,800` interior workgroups become 100% empty instead of `1,226`).
+  2. **Skip interior workgroups at dispatch:** Map a 1D/3D workgroup grid onto only the boundary workgroups of the `20×12×20` box (`4,800 - 1,800 = 3,000` workgroups at `64×32×64`), eliminating all `1,800` interior no-op workgroups (`115,200` dead threads).
+
+---
+
+### Priority 2 — Hardware `textureSampleLevel`, `r16float` Velocity Storage, Forcing VGPR Reduction, & Dynamic MG Weight Fusion
+
+#### R-06: Use Hardware `textureSampleLevel` in `shader_fluid_query_gather` & Parent Seam Reads, and Migrate Velocity/Ghost 3D Textures to `r16float`
+- **Target Files:** [`shader_fluid_query_gather.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/query/shader_fluid_query_gather.js#L21-L65), [`FluidMacVelocitySet.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/FluidMacVelocitySet.js), [`chunk_fluid_cascade_parent.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js), [`GPUFluidCascade.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/GPUFluidCascade.js).
+- **Problem:**
+  1. [`shader_fluid_query_gather.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/query/shader_fluid_query_gather.js#L21-L62) binds `wind_field_atlas` (`rgba16float`) as `unfilterable-float` and executes an 8-tap `textureLoad` loop (`16` loads in the blend band), whereas [`chunk_wind_field_sample_cascades.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/wind/chunk_wind_field_sample_cascades.js#L57) already samples `wind_field_atlas` with `1` hardware `textureSampleLevel`.
+  2. Internal velocity and ghost textures (`u, v, w`, `forward_u/v/w`, `advected_u/v/w`, `ghost_u/v/w`) use `r32float` (`4 B`/texel, `unfilterable-float`) instead of `r16float` (`2 B`/texel, `filterable-float` + `write-only` storage texture via `texture-formats-tier1`).
+- **Fix:**
+  1. **Immediate win in `shader_fluid_query_gather.js`:** Bind `wind_field_atlas` with a linear clamp sampler (matching `chunk_wind_field_sample_cascades.js`) and replace the 8-tap `textureLoad` loop with `textureSampleLevel` (`8×` fewer texture instructions).
+  2. **Migrate internal velocity and ghost 3D textures to `r16float`:** Because wind velocity deviations are clamped to $|v - v_{\text{far}}| \le 4 h / \Delta t = 80\text{ m/s}$ (`f16` ULP $\le 0.0625\text{ m/s}$ at peak storm speed and $< 0.004\text{ m/s}$ in normal winds) and published to `rgba16float`, storing `u, v, w`, `forward_u/v/w`, `advected_u/v/w`, and `ghost_u/v/w` in `r16float` halves 3D texture memory and L1/L2 cache bandwidth across all passes.
+  3. **Preserve MacCormack `min/max` & `f32` weights in `advect_correct` while using `textureSampleLevel` for parent reads:** Keep the 8-corner `textureLoad` in `v3_mac_source_corners_*` and `v3_mac_forward_corners_*` (which now loads `r16float` texels at `2×` cache density while preserving `f32` trilinear weights and the 8-corner `min/max` MacCormack limiter per D6 of [`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/engine/physics/fluid/GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md#L591-L606)), and use hardware `textureSampleLevel` in `fluid_parent_face_u/v/w` (`cascade_fill`, `cascade_ghosts`, `advect_correct` epilogue, and `wind_publish`) whenever the parent tap does not straddle the toroidal wrap seam.
+
+#### R-07: Pre-Normalize Obstacle Transforms in LDS & Eliminate By-Value Struct Copies in `shader_fluid_forcing_apply`
+- **Target Files:** [`shader_fluid_forcing_apply.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js#L62-L162), [`chunk_fluid_forcing_cell.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js#L92-L148), [`chunk_fluid_obstacle_record.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/chunk_fluid_obstacle_record.js#L26-L70), [`shader_fluid_forcing_command.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/forcing/shader_fluid_forcing_command.js).
+- **Problem:** `shader_fluid_forcing_apply` (`@workgroup_size(4,4,4)` = 64 threads, `4,724 B` LDS) copies 80 B `FluidObstacleRecord`, 64 B `mat4x4<f32>`, and 48 B `FluidEffectorRecord` structs by value from LDS into VGPRs inside its loops, and every thread (`64` threads) re-normalizes `global[0..2].xyz` (`3 × inverseSqrt`) for each of the up to `24` obstacles (`72` `normalize()` calls per thread).
+- **Fix:**
+  1. **Normalize once on LDS load:** When threads `0..obstacle_count-1` load `fluid_forcing_globals[lane]` into LDS at lines 99–103 of `shader_fluid_forcing_apply.js`, normalize the 3 unit rotation columns right there before writing to LDS (storing them as `vec3<f16>` or `mat3x4<f32>`, saving `384–960 B` LDS and **`72` `normalize()` calls per thread**).
+  2. **Index LDS in-place instead of copying structs by value:** Pass the LDS slot index `slot: u32` into the containment check and read `fluid_forcing_obstacles[slot].linear_velocity` **only when `distance <= obstacle.inflation`** (`true` for a small fraction of obstacle checks), avoiding materializing the 20-word struct in VGPRs on every loop iteration.
+  3. **Fold `shader_fluid_forcing_command` (`1×1×1`) into `shader_fluid_forcing_query`:** Initialize `command` to `[0, 1, 1, 0, 1, 1]` and have `shader_fluid_forcing_query` atomically increment `command[0]` (and `command[3]`), removing the single-thread `shader_fluid_forcing_command` dispatch and its inter-dispatch barrier.
+
+#### R-08: Dynamically Fuse `shader_fluid_mg_level0_weights` into `shader_fluid_mac_divergence` and `shader_fluid_mg_coarse_weights` into `shader_fluid_mg_residual_restrict`
+- **Target Files:** [`shader_fluid_mac_divergence.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_divergence.js), [`shader_fluid_mg_level0_weights.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_level0_weights.js), [`shader_fluid_mg_coarse_weights.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarse_weights.js), [`shader_fluid_mg_residual_restrict.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js), [`GPUFluidPressureSolve.js`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.js#L300-L326).
+- **Problem:** Every cascade step executes `4` standalone weight-building dispatches (`shader_fluid_mg_level0_weights` + 3× `shader_fluid_mg_coarse_weights`, costing `8.2 µs` per step at `64×32×64`), plus at `L3` (`8×4×8`), `shader_fluid_mg_coarse_weights` launches `[1, 1, 2]` workgroups of `8×8×4` where `50%` of threads (`cell.y >= 4`) immediately early-return.
+- **Observation — 100% of the Data and Grid Walks Already Exist in `mac_divergence` and `mg_residual_restrict`:**
+  1. `shader_fluid_mac_divergence` and `shader_fluid_mg_level0_weights` both dispatch the exact same `8×8×4` workgroup grid over `step.cells.size` (`64×32×64`) right before the pressure solve and both bind `solid` (`array<u32>`, read-only).
+  2. In [`GPUFluidPressureSolve.js:315-321`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.js#L315-L321), `levels[l + 1].words` ($l \in \{0, 1, 2\}$) is **never read until `this.#down[l + 1]`** (or `this.#coarsest` for $l + 1 = 3$), which executes **immediately after `this.#restrict[l]` (`shader_fluid_mg_residual_restrict`)** on the first V-cycle (`cycle === 0`).
+  3. Furthermore, [`chunk_fluid_mg_coarse_word.js:29-47`](file:///H:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/chunk_fluid_mg_coarse_word.js#L29-L47) (`fluid_mg_coarse_word(coarse)`) is a **strictly block-local function of the $2\times 2\times 2 = 8$ fine child words `w0..w7`** (`2 * coarse + [0..1]^3`) — the exact same 8 fine cells whose `word = words[index]` is already loaded by `shader_fluid_mg_residual_restrict.js:111` and whose residuals are restricted into `coarse_cell`!
+- **Fix (100% Dynamic Every Step, Zero CPU State Tracking):**
+  1. **Fuse `level0_weights` into `shader_fluid_mac_divergence`:** Bind `levels[0].words` (`write-only` storage buffer) in `shader_fluid_mac_divergence` and write `words[idx] = fluid_mg_level0_word(vec3<i32>(id), step.cells.size);` alongside `rhs[idx]`.
+  2. **Fuse `coarse_weights` into `shader_fluid_mg_residual_restrict` (on `cycle === 0`):** After the barrier in `shader_fluid_mg_residual_restrict`, while Warp 0 (`lane < 32u`) computes and writes `coarse_rhs[coarse_index]` and `coarse_error[coarse_index]` for the `4×4×2 = 32` coarse cells of the tile, have **Warp 1 (`lane ∈ [32..63]`, which is currently 100% idle after the barrier!)** compute `coarse_words[coarse_index] = fluid_mg_coarse_word(coarse_local)` from the tile's fine `words`!
+- **Impact:** Unconditionally eliminates **all 4 weight-building dispatches (`shader_fluid_mg_level0_weights` and 3× `shader_fluid_mg_coarse_weights`, saving `4` dispatches and up to `8.2 µs` per step)** on **every single step** while remaining 100% dynamic and utilizing an otherwise-idle warp (`lane ∈ [32..63]`) inside `shader_fluid_mg_residual_restrict`.
+
+---
+
+## 6. Summary Impact Matrix
+
+| ID | Recommendation | Target Shaders / Files | Measured Step Share Affected | Expected Occupancy & Cost Impact |
+|---|---|---|---|---|
+| **R-01** | Hoist `fluid_parent_face_*` out of `fluid_mac_ghost_*` (break nested $8\times 8$ loop while preserving storm-wind fallback + `vec4<f16>` corner accumulators) | `chunk_fluid_mac_seams.js`, `chunk_v3_mac_lattice_corners.js`, `chunk_fluid_cascade_parent.js` | **`43.0 µs`** (`29.8%` of step) | Eliminates nested $8\times 8$ dynamic `textureLoad` loops in `advect_predict` and `advect_correct`; major VGPR reduction and higher SM warp occupancy. |
+| **R-02** | Stage `6×6×4` coarse tile in LDS (`4,800 → 144` reads/WG), drop redundant `held = input[...]` global read, delete 16 dead trailing barriers, parallelize restrict | `shader_fluid_mg_smooth.js`, `shader_fluid_mg_residual_restrict.js`, `shader_fluid_mg_coarsest.js` | **`71.0 µs`** (`49.2%` of step) | **`33.3×` fewer coarse global reads** on up-sweeps; removes `256` redundant global reads/WG across 14 dispatches; removes 16 dead barriers/step; eliminates `87.5%` warp idling in restrict while keeping full `f32` precision (`NO-F16-09`). |
+| **R-03** | Migrate `mac_curl` LDS tiles to `f16` (`enable f16;`, `F16-03`) + hold `omega` in registers across barrier 2 | `shader_fluid_mac_curl.js` | **`8.2 µs`** (`5.4%` of step with curl) | Drops `mac_curl` LDS from `16,224 B` to **`6,912 B` (`−57.4%`)**, doubling/tripling CU/SM residency; eliminates `256` duplicate 12-tap curl evaluations/WG. |
+| **R-04** | Fuse double `grid_tile_f32_load` in `mac_gradient` via sentinel-encoded `solid` | `shader_fluid_mac_gradient.js` | **`4.1 µs`** (`2.8%` of step) | Cuts `mac_gradient` LDS from `4,800 B` to `2,400 B`, removes 1 `workgroupBarrier()` and 1 halo unpack loop. |
+| **R-05** | Align `cell = face` in `cascade_ghosts` + skip interior no-op workgroups | `shader_fluid_cascade_ghosts.js`, `FluidMacPasses.js` | **`9.0 µs`** (`6.2%` of step) | Eliminates `164,851` dead threads (`53.66%`) and `1,800` interior workgroups (`−37.5%` WGs launched). |
+| **R-06** | Use hardware `textureSampleLevel` in `query_gather` (`rgba16float`) & parent seam reads, and migrate internal velocity/ghost 3D textures to `r16float` (`texture-formats-tier1`) | `shader_fluid_query_gather.js`, `FluidMacVelocitySet.js`, `chunk_fluid_cascade_parent.js` | **`52+ µs`** (`36%+` of step + queries) | Halves velocity texture bandwidth (`4 B → 2 B`/texel), preserves MacCormack 8-corner `min/max` & `f32` weights in `correct`, and replaces 8-tap parent/query software loops with 1-cycle hardware TMU taps. |
+| **R-07** | Pre-normalize obstacle transforms in LDS, index records in-place (`forcing_apply`), and fold `1×1×1` `forcing_command` into `forcing_query` | `shader_fluid_forcing_apply.js`, `chunk_fluid_forcing_cell.js`, `chunk_fluid_obstacle_record.js`, `shader_fluid_forcing_query.js` | **`34–88 µs`** (forcing tick) | Saves `72` `normalize()` calls/thread; avoids copying `80 B + 64 B` structs into VGPRs; removes `1×1×1` command dispatch. |
+| **R-08** | Dynamically fuse `level0_weights` into `mac_divergence` and `coarse_weights` into Warp 1 of `mg_residual_restrict` (`cycle === 0`) | `shader_fluid_mac_divergence.js`, `shader_fluid_mg_residual_restrict.js`, `GPUFluidPressureSolve.js` | **`8.2 µs`** (`5.7%` of step) | Unconditionally eliminates all `4` standalone weight dispatches (`24 → 20` MG dispatches/step) every step with zero CPU dirty tracking, while putting idle Warp 1 (`lane ∈ [32..63]`) in `mg_residual_restrict` to work. |

package/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_fluid_cascade_parent.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kDAFU,SAAS,CAoIjB;AAEF;;;;;;;;;;;;;;;GAeG;AACH,kDAFU,SAAS,CAmDjB;0BA3OwB,oCAAoC"}
+{"version":3,"file":"chunk_fluid_cascade_parent.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kDAFU,SAAS,CAmMjB;AAEF;;;;;;;;;;;;;;;GAeG;AACH,kDAFU,SAAS,CAkFjB;0BAzUwB,oCAAoC"}