@woosh/meep-engine 3.60.3 → 3.60.5

package/src/shade/SHADER_F16_PROPOSAL_2026_10_24.md

@@ -1,263 +0,0 @@
-# Double-Rate `f16` Shading (`shader-f16` / `enable f16;`) — Performance & Precision Proposal
-
-**Date:** 2026-10-24 (Updated 2026-10-26)  
-**Status:** In Progress — `INFRA-1`, `INFRA-3`, `INFRA-4`, `INFRA-5`, `INFRA-6` (`a7e88413f`..`b637acaef`) and `BUG-1`..`BUG-5` (`eecb70112`..`a86cf8617`) landed on `master`; `INFRA-2` (device floor policy) and shader conversions (§4–§7) pending  
-**Scope:** `packages/meep-engine/src/shade/` (`device/`, `wgsl/`, `renderer/`)
-
----
-
-## 0. Executive Summary
-
-Every WGSL shader in Shade currently executes its arithmetic and declares its `var<workgroup>` shared memory in 32-bit precision (`f32`, `i32`, `u32`). Where 16-bit floats appear inside shaders today — in Depth of Field shared memory (`shader_dof_raymarch_compute.js`), SSR prefilter shared memory (`chunk_ffx_dnsr_group_shared_memory.js`), Brick4 v1 probes, SHARC voxels (`chunk_sharc_voxel_encode.js`), and LPV depth borders (`shader_lpv_atlas_border_read.js`) — they are packed and unpacked manually into `u32` words via `pack2x16float` / `unpack2x16float` or software bit-manipulation (`chunk_encode_f16.js` / `chunk_decode_f16.js`). Meanwhile, the majority of the renderer's color, lighting, volumetric, GI, velocity, and Hi-Z textures are already backed by 16-bit float formats (`rgba16float`, `rg16float`, `r16float`).
-
-Enabling the WebGPU `shader-f16` feature (`enable f16;` in WGSL) unlocks native 16-bit floating-point scalars (`f16`), vectors (`vec2<f16>` / `vec2h`, `vec3<f16>` / `vec3h`, `vec4<f16>` / `vec4h`), and matrices (`matNxM<f16>`) across registers, `var<workgroup>` shared memory, `var<storage>` buffers, varying interpolants, and subgroup operations.
-
-### Key Findings of This Investigation
-
-1. **Blocking Infrastructure Bugs Discovered & Status (§2):** Although `WebGPUExtensionType.ShaderF16` (`"shader-f16"`) and `WEBGPU_WGSL_PRIMITIVE_TYPES` (`f16`, `vec2h`–`vec4h`, `mat2x2h`–`mat4x4h`) already existed in the codebase, six prerequisite defects prevented shaders from compiling, validating, or emulating `ShaderF16` accurately. **Five of the six (`INFRA-1`, `INFRA-3`, `INFRA-4`, `INFRA-5`, `INFRA-6`) are now fixed on `master` (`a7e88413f`..`b637acaef`)**:
-   - ✅ **Fixed (`INFRA-1`, `INFRA-5`):** `ShaderDescriptor.compile()` (`ShaderDescriptor.js`) previously interpolated the WebGPU feature name verbatim as `enable shader-f16;` (a WGSL syntax error); it now maps `WebGPUExtensionType.ShaderF16` (`"shader-f16"`) to `enable f16;` via `wgsl_enable_extension()`, auto-attaches `ShaderF16` when structs/buffers transitively contain `f16` (`type_has_f16.js`), and `validate_wgsl_source.js` enforces an `unenabled-f16` rule.
-   - ⏳ **Pending (`INFRA-2`):** `Renderer.initialize()` (`Renderer.js:1575-1600`), `SHADE_DEVICE_FLOOR`, and `SoftwareGPUDevice` do not yet request/expose `"shader-f16"` on the device.
-   - ✅ **Fixed (`INFRA-3`, `INFRA-4`, `INFRA-6`):** The WGSL CPU emulator (`WGSLJavaScriptCompiler.js` / `WGSLLanguageCore.js`) previously ran scalar `f16` arithmetic in 64-bit JS floats (`f64`) and `dot`/`length` on `vecNh` in `f32`, hiding `f16` overflow (`> 65504`) and underflow (`< 6.10e-5`) from unit tests. It now emulates IEEE 754 `f16` rounding across scalar ops, vector reductions, `matCxRh` products, `pack2x16float`/`unpack2x16float`, packed `bitcast`, and compile-time `FLOAT16_MAX` (`65504`) range checks, and GPU buffer serde (`write_gpu_typed_buffer.js` / `read_gpu_typed_buffer.js`) now supports `f16`, `vecNh`, and `matCxRh`/`matCxRf`.
-2. **Five Live `rgba16float` (`+Inf` → `NaN`) Bugs Found & Fixed in Existing `f32` Shaders (§3):** Because `f32` shaders write unbounded HDR values into `rgba16float` targets, any value in `(F16_MAX, F32_MAX]` saturates to `+Inf` on hardware store. We found and fixed (`eecb70112`..`a86cf8617`) five places where those `+Inf` texels or unguarded denominators entered `rgb / (1 + luma)` (`Inf / Inf = NaN`), Karis weighting `rgb * (1 / (1 + luma))` (`Inf * 0 = NaN`), or `rgb / (1 - luma)`, which previously poisoned temporal history and mip pyramids in **Volumetric TAA**, **NSS**, **Bloom**, **SSR**, and **TAA inverse tonemapping**.
-3. **Where `shader-f16` Delivers the Largest Real-World Wins (§4–§5):**
-   - **Compute Convolution + Shared Memory Tile (`shader_nss_conv_layer.js`)**: Runs **18 dispatches per frame**. Using `vec4h` dot products plus an 800-byte `var<workgroup> shared_in: array<vec4<f16>, 100>` tile cache cuts 3D texture loads by **5.76×** (`144 → 25` loads/thread) and runs all `576` MACs/thread at double rate.
-   - **Eliminating Inner-Loop `unpack2x16float` Bottlenecks (`shader_dof_raymarch_compute.js`, `shader_dof_slice_compute.js`, `chunk_ffx_dnsr_group_shared_memory.js`)**: Replacing `var<workgroup> lds_coc: array<u32, 3872>` with `array<f16, 7744>` (same `15,488 B` footprint) removes up to **2,304 bit-shift + `unpack2x16float` + `select` sequences per pixel** in DoF raymarching (`DOF_CONFIG.js:158` noted the compute shader measured slower than fragment for this reason).
-   - **Halving `var<workgroup>` Shared Memory at the 16 KiB Limit (`shader_fluid_mac_curl.js`, `chunk_fft128x4_inverse_workgroup.js`, `shader_project_environment_sh.js`)**: `shader_fluid_mac_curl` currently uses `16,224 B / 16,384 B` of LDS (`99%` of the WebGPU limit, capping occupancy at 1 workgroup/SIMD). Moving its curl tiles to `f16` cuts LDS to `8,112 B`, doubling occupancy.
-   - **Cutting Live VGPRs by 30–50% in Register-Starved Shaders (`shader_brick4_indirect_lighting.js`, `shader_deferred_main.js`, `shader_volumetrics_build_lighting.js`, `chunk_forward_shade_standard_fragment.js`)**: Holding `SH3CoefficientsColor` (`array<vec3h, 9>`, saving 54 VGPRs across 4 probes in Brick4), `MaterialShadingInfo` (saving 14 VGPRs across 128-light loops), and volumetric media/multiscattering state in `f16` directly increases wave occupancy to hide ray-query and texture latency.
-4. **Where `f16` Must Never Be Used (§4.5 & §6):**
-   - **GGX NDF (`chunk_D_GGX.js`)**: For any `roughness < 0.148` (`a2 < 4.88e-4`, 1 ULP below `1.0h`), `a2 - 1.0h` rounds to `-1.0h`, causing `denom = 0.0h` and **`0 / 0 = NaN` at the center of every specular highlight**, while peak $D_{\text{GGX}}$ overflows `65504` for `roughness < 0.047`.
-   - **MBOIT Moments, LPV/TAA/SSR Variance Second Moments (`m2 - m1 * m1`), ReSTIR Reservoir `weightSum`/`targetPdf`, Atmosphere Planetary Geometry (`R = 6,378,000 m`), Fluid Multigrid Pressure V-Cycles, Water CDLOD/Phase, and Shadow/Hi-Z Depth Comparisons** all suffer catastrophic cancellation, underflow, or overflow in `f16` and must remain `f32`.
-
----
-
-## 1. Hardware Mechanics of `shader-f16` & Device Policy
-
-### 1.1 How GPUs Execute `f16` (and When "Double-Rate" Actually Happens)
-
- IEEE 754 binary16 (`f16`) has **1 sign bit, 5 exponent bits, and 10 mantissa bits** (11 significand bits):
-$$\text{Normal range} = [2^{-14}, (2 - 2^{-10})\times 2^{15}] \approx [6.1035 \times 10^{-5},\ 65504.0], \qquad \text{ULP}(1.0) = 2^{-10} \approx 9.7656 \times 10^{-4}$$
-$$\text{Subnormal range} = [2^{-24}, 2^{-14}) \approx [5.9605 \times 10^{-8},\ 6.1035 \times 10^{-5})$$
-
-Converting `f32` code to `f16` improves GPU performance through **four distinct hardware mechanisms**, each with specific architectural rules:
-
-| Mechanism | Hardware Reality Across Architectures (RDNA2/3/4, Ada/Ampere, Intel Xe/Gen12, Apple M-Series) | Pitfall that Negates the Win |
-|---|---|---|
-| **1. Double-Rate Packed SIMD ALU (`2× ops/clk`)** | On AMD RDNA (`v_pk_fma_f16`, `v_pk_add_f16`, `v_pk_mul_f16`, `v_pk_max_f16`, `v_pk_min_f16`), NVIDIA Turing/Ampere/Ada (`HFMA2`, `HADD2`, `HMUL2`), Intel Xe, and Apple Silicon, **2-wide packed `f16` (`vec2h` / `vec4h`) executes at 2× the throughput of `f32`**. | **Transcendentals (`sin`, `cos`, `exp2`, `log2`, `sqrt`, `inverseSqrt`, `rcp`)** run on the Special Function Unit (SFU) at **1× quarter-rate** on RDNA/NVIDIA — they do *not* run at double rate. Unpaired scalar `f16` ops may also issue at 1× rate on RDNA2 if the compiler cannot pack two independent ops into `v_pk_*_f16`. |
-| **2. VGPR Packing & Wave Occupancy (`2× f16 per 32-bit VGPR`)** | Two `f16` scalars or one `vec2h` occupy a single 32-bit VGPR (`vec3h` and `vec4h` occupy two 32-bit VGPRs instead of three/four). In shaders limited by register file capacity (`shader_deferred_main`, `shader_brick4_indirect_lighting`, `shader_volumetrics_build_lighting`), cutting VGPRs from e.g. 96 to 64 raises occupancy from 4 to 8 waves/SIMD on RDNA, hiding memory and ray-tracing latency. | **Ping-ponging `f32 ↔ f16` inside a loop** forces the compiler to keep both the `f32` and `f16` values live simultaneously and emits `v_cvt_f16_f32` / `v_cvt_f32_f16` instructions on every iteration, increasing instruction count *and* register pressure. |
-| **3. `var<workgroup>` Shared Memory (LDS) Capacity & Native 16-bit Access** | WebGPU caps `maxComputeWorkgroupStorageSize` at **16,384 bytes (16 KiB)** on the device floor. Using `f16` / `vec2h` / `vec4h` in `var<workgroup>` either **halves LDS usage** (allowing more concurrent workgroups per CU/SM) or **eliminates manual `pack2x16float`/`unpack2x16float` + bit-shift ALU** via native `ds_read_u16` / `ds_read_b64` instructions. | Odd-stride scalar `f16` access across threads can cause 32-bit LDS bank conflicts if threads do not access contiguous pairs or `vec2h`/`vec4h` aligned elements. |
-| **4. Bandwidth & Varying Interpolation** | Reading/writing `vec2h`/`vec4h` in storage buffers halves memory traffic; using `vec3h`/`vec4h` on vertex-to-fragment outputs halves parameter cache / varying interpolation footprint (`v_interp_p10_f16` / `v_interp_p2_f16`). | Unaligned `vec3h` in structs has alignment 8 and size 6 (`WEBGPU_WGSL_PRIMITIVE_TYPES.js:40`), wasting 2 bytes unless paired with a scalar `f16` into `vec4h`. |
-
-### 1.2 Device Floor Policy: Required Floor vs. Optional Feature
-
-Per [`RENDERER_CONTRACT.md` §2](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/RENDERER_CONTRACT.md#L45-L75):
-> *"The renderer requires a WebGPU device that meets a fixed floor. There is no feature detection beyond it and no branch that produces a lesser frame."*
-
-**Hardware support for `shader-f16`**:
-- Supported on **100% of desktop and laptop GPUs capable of running Shade's existing floor** (`indirect-first-instance`, `float32-blendable`, `texture-formats-tier1`): AMD GCN 3+ / Vega / RDNA 1–4, NVIDIA Pascal (SM60+) / Turing / Ampere / Ada / Blackwell, Intel Gen9+ / Iris Xe / Arc, Apple M1–M4 / A14+, and Qualcomm Adreno 600+.
-- The only environment where `shader-f16` may be absent is an older Dawn/wgpu software adapter or a stripped-down test mock (`SoftwareGPUDevice`).
-
-**Recommendation on Device Policy:**
-- **Option A (Recommended, matches `RENDERER_CONTRACT.md` §2):** Add `WebGPUExtensionType.ShaderF16` to [`SHADE_DEVICE_FLOOR.features`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/device/SHADE_DEVICE_FLOOR.js#L19-L26) and [`SoftwareGPUDevice.js` `SUPPORTED_OPTIONAL_FEATURES`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/device/mock/SoftwareGPUDevice.js#L206-L226). Every shader that benefits from `enable f16;` uses it unconditionally with zero permutation bloat.
-- **Option B (Conservative transitional path, matches `subgroups`):** Add `WebGPUExtensionType.ShaderF16` to `optional_desired` in [`Renderer.js:1578`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/Renderer.js#L1578-L1593) and gate `f16` chunks behind a `ShaderSwitch.bool('shader f16')` ([`SHADER_SWITCH_PROPOSAL_2026_10_16.md`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/compiler/SHADER_SWITCH_PROPOSAL_2026_10_16.md)). Because Option B doubles the chunk maintenance surface for every converted shader and no target GPU lacks `shader-f16`, **Option A is strongly preferred**.
-
----
-
-## 2. P0 Prerequisite Infrastructure Defects to Fix First
-
-Before any shader can use `enable f16;`, **six defects in the compiler, device initialization, emulator, validator, and buffer serializer** were identified. **Five (`INFRA-1`, `INFRA-3`, `INFRA-4`, `INFRA-5`, `INFRA-6`) are now resolved on `master`; only `INFRA-2` remains open:**
-
-| ID | Status | File & Lines | Defect Found | Resolution / Required Fix |
-|---|---|---|---|---|
-| **INFRA-1** | **✅ Landed** (`a7e88413f`) | [`ShaderDescriptor.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/ShaderDescriptor.js), [`WebGPUExtensionType.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/descriptor/WebGPUExtensionType.js), [`type_has_f16.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/type/type_has_f16.js), [`WebGPUStruct.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/type/WebGPUStruct.js), [`ShaderResourceSetDescriptor.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js), [`WebGPUArray.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/type/WebGPUArray.js) | `WebGPUExtensionType.ShaderF16` is `"shader-f16"` (the WebGPU `GPUFeatureName`). `ShaderDescriptor.compile()` emitted `enable ${extension};` → **`enable shader-f16;`**, which is invalid WGSL! For `subgroups`, the `GPUFeatureName` (`"subgroups"`) and WGSL enable-extension (`subgroups`) happen to match; for `shader-f16`, the WGSL directive is **`enable f16;`** ([WGSL §1.4.1.1](https://www.w3.org/TR/WGSL/#extension-f16)). | Added `wgsl_enable_extension(extension)` in `WebGPUExtensionType.js` (`{ [ShaderF16]: "f16", [Subgroups]: "subgroups" }`); updated `ShaderDescriptor.compile()` to emit `enable ${wgsl_enable_extension(extension)};` while keeping `#features` as `GPUFeatureName[]` (with lazy compilation in `get features()` and `validate_gpu_features()`). Also added `type_has_f16()` so `WebGPUStruct` and `ShaderResourceSetDescriptor` automatically attach `ShaderF16` when a struct or buffer/immediate resource transitively contains `f16` types, plus `WebGPUArray.f16` / `vec2h` / `vec4h`. |
-| **INFRA-2** | **⏳ Pending** | [`SHADE_DEVICE_FLOOR.js:19-26`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/device/SHADE_DEVICE_FLOOR.js#L19-L26), [`Renderer.js:1575-1600`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/Renderer.js#L1575-L1600), [`SoftwareGPUDevice.js:206-226`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/device/mock/SoftwareGPUDevice.js#L206-L226) | `WebGPUExtensionType.ShaderF16` is never requested in `Renderer.initialize()` and is rejected by `SoftwareGPUDevice`. | Add `WebGPUExtensionType.ShaderF16` to `SHADE_DEVICE_FLOOR.features` (or `optional_desired` in `Renderer.js`) and to `SUPPORTED_OPTIONAL_FEATURES` in `SoftwareGPUDevice.js`. |
-| **INFRA-3** | **✅ Landed** (`87b60069f`, `b637acaef`) | [`WGSLJavaScriptCompiler.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js), [`WGSLLanguageCore.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/emulator/WGSLLanguageCore.js), [`FLOAT16_MAX.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/core/binary/FLOAT16_MAX.js) | 1. Scalar `f32` ops routed through `F32_SCALAR_OP` (`add_f32`, `sub_f32`, `mul_f32`, `div_f32`), but **scalar `f16` ops routed through raw `f64` JS numbers** (`16000.0h * 8.0h` → `128000` instead of `+Infinity`; `1e-3h * 1e-3h` → `1e-6` instead of underflowing).<br>2. `WGSLLanguageCore.dot()` and `length()` accumulated via `Math.fround` (`f32`) even when given `Float16Array` (`vec2h`/`vec3h`/`vec4h`), so `length(vec3h(300.0h, 0.0h, 0.0h))` returned `300` instead of overflowing `300^2 = 90000 > 65504` to `+Infinity`.<br>3. `convertAbstract(operand, 'f16')` omitted the `Math.abs(operand.value) <= 65504` compile-time range check that `f32` performed. | 1. Added `round_f16`, `add_f16`, `sub_f16`, `mul_f16`, `div_f16`, and `quantizeToF16` in `WGSLLanguageCore.js`; routed `isScalarF16` binary ops, compound assignments (`+=`, `-=`, `*=`, `/=`, `%=`), and scalar `f16` builtin returns through `f16` rounding.<br>2. Updated `dot()`, `length()`, `distance()`, `cross()`, `determinant()`, `reflect()`, `refract()`, and `faceForward()` to round products and partial sums in `f16` when operating on `Float16Array`.<br>3. Enforced `FLOAT16_MAX` (`65504`) range checks on `h` decimal & hex float literals (`parseWgslHexFloat`), folded abstract binary ops, and converted abstract operands across `let`/`var`/`const` declarations, assignments, `return`, `for`-loop updates, and function/struct/array call arguments. |
-| **INFRA-4** | **✅ Landed** (`87b60069f`) | [`WGSLLanguageCore.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/emulator/WGSLLanguageCore.js) & [`WGSLJavaScriptCompiler.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js) | 1. Matrix-vector and matrix-matrix multiply helpers existed only for `f` (`m2x2f_multiply_v2f`, `m3x3f_multiply_v3f`, etc.); multiplying `mat3x3<f16> * vec3<f16>` threw `TypeError: wgsl.m3x3h_multiply_v3h is not a function`.<br>2. `pack2x16float` and `unpack2x16float` were missing from `WGSLLanguageCore.js`.<br>3. `WGSLLanguageCore.bitcast` did element-wise conversion on `vec2<f16>` ↔ `u32` and `vec4<f16>` ↔ `vec2<u32>` instead of reinterpreting the underlying 4 or 8 bytes. | 1. Added `m2x2h`/`m3x3h`/`m4x4h` matrix-vector, vector-matrix, and matrix-matrix multiply helpers backed by `Float16Array` with `f16` intermediate rounding, and fixed `defaultValueForType` on `matCxRh`.<br>2. Implemented `pack2x16float` and `unpack2x16float`.<br>3. Upgraded `WGSLLanguageCore.bitcast` to support width-changing packed reinterpretation (`vec2<f16>`/`vec2h` ↔ `u32`/`i32`/`f32`, `vec4<f16>`/`vec4h` ↔ `vec2<u32>`/`vec2<i32>`/`vec2<f32>`) over a shared 16-byte `BITCAST_BUFFER`. |
-| **INFRA-5** | **✅ Landed** (`a7e88413f`, `b637acaef`) | [`validate_wgsl_source.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/validate_wgsl_source.js) & [`chunk_wgsl_validity.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/chunk_wgsl_validity.spec.js) | A shader or chunk test that used `f16`, `vec3h`, or `1.0h` without calling `chunk.addExtension(WebGPUExtensionType.ShaderF16)` passed `validate_wgsl_source` and the emulator, then failed `createShaderModule` on a device. | Added the `unenabled-f16` rule (`F16_ENABLE_DIRECTIVE_RE`, `F16_TOKEN_RE` covering `\bf16\b`, `\b(?:vec[234]|mat[234]x[234])h\b`, and decimal/hex `h`-suffixed float literals) to `validate_wgsl_source.js` and enabled it in `chunk_wgsl_validity.spec.js`. |
-| **INFRA-6** | **✅ Landed** (`4d349075d`, `b637acaef`) | [`write_gpu_typed_buffer.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.js) & [`read_gpu_typed_buffer.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js) | `WEBGPU_WGSL_PRIMITIVE_TYPES.js` exported `f16`, `vec2h`, `vec3h`, `vec4h`, `mat2x2h`..`mat4x4h`, but `write_wgsl_type_value` and `read_wgsl_type_value` threw `Unsupported type` if a `WebGPUStruct` contained them. | Added `f16`, `vec2h`, `vec3h`, `vec4h`, and all 9 `matCxRh` + 9 `matCxRf` types (respecting 8-byte/16-byte WGSL column stride padding on `matCx3h`/`matCx3f` and struct tail padding) to `write_gpu_typed_buffer.js` and `read_gpu_typed_buffer.js`. |
-
----
-
-## 3. Five Pre-Existing `rgba16float` (`f16` Target) Bugs Uncovered
-
-Even while shaders run in `f32`, writing an `f32` value $> 65504.0$ (`F16_MAX`) into an `rgba16float` texture saturates that channel to **`+Inf`**. Our audit and subsequent adversarial review uncovered **five live bugs** where missing `F16_MAX` clamps or missing finite guards turned `+Inf` into **`NaN`**, corrupting temporal histories and mip pyramids. **All five (`BUG-1`..`BUG-5`) are now resolved on `master` (`eecb70112`..`a86cf8617`) using imported `F16_MAX_DEFINITION` / `F32_MAX_DEFINITION` (`FLOAT16_MAX` in specs):**
-
-| Bug ID | Status | File & Lines | Mechanism of Defect | Visual Artifact Produced | Resolution / Landed Fix |
-|---|---|---|---|---|---|
-| **BUG-1** | **✅ Landed** (`eecb70112`) | [`shader_volumetrics_build_lighting.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js) & [`shader_volumetrics_taa.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js) | `shader_volumetrics_build_lighting.js` and `shader_volumetrics_taa.js` guarded against `NaN`/`Inf` using `abs(...) <= vec4f(F32_MAX)`. Any finite `f32` radiance in `(F16_MAX, F32_MAX]` (or variance-box expansion `mean + gamma * std_dev > F16_MAX` in `shader_volumetrics_taa`) passed the `F32_MAX` check and was converted to **`+Inf` by hardware `textureStore` into `rgba16float`**. Next frame, `t_history` held `+Inf` and `mix` / `get_std_dev4` evaluated `Inf - Inf = NaN`. | Growing black/NaN volumetric blotches around bright local lights that persist across frames in volumetric TAA. | Imported `F16_MAX_DEFINITION` and `F32_MAX_DEFINITION`; clamped finite `lighting_raw` in `shader_volumetrics_build_lighting.js` and both `current_safe` and `final_safe` in `shader_volumetrics_taa.js` to `[vec4f(0.0), vec4f(F16_MAX)]` before `textureStore`. |
-| **BUG-2** | **✅ Landed** (`a43cf4ed5`) | [`shader_nss_preprocess.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/nss/shader_nss_preprocess.js), [`chunk_nss_luma_derivative.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.js), [`shader_nss_postprocess.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/nss/shader_nss_postprocess.js) | `nss_tonemap_exposure(rgb)` in `shader_nss_preprocess.js` and `nss_luma_derivative(current_rgb, history_rgb)` in `chunk_nss_luma_derivative.js` computed `scaled / (1.0 + m)` and `lc / (1.0 + lc)` without sanitizing `+Inf`/`NaN` against `F16_MAX`, producing `Inf / Inf = NaN` in `tTensor` slices `z=1` and `z=2, .a`. | Permanent `NaN` corruption injected into the 18-layer U-Net tensor and `tFeedback` temporal history. | Imported `F16_MAX_DEFINITION` and sanitized inputs via `select(vec3<f32>(0.0), clamp(rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), rgb == rgb)` in both `shader_nss_preprocess.js` and `chunk_nss_luma_derivative.js` (and replaced literal `65504f` in `shader_nss_postprocess.js`). |
-| **BUG-3** | **✅ Landed** (`5651af2e2`) | [`bloom/chunk_karis_blur4x4_sample.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/bloom/chunk_karis_blur4x4_sample.js) & [`ssr/downsample_karis.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/downsample_karis.js) | Computed `w = 1.0 / (1.0 + luma)` and `t * w` on `rgba16float` samples without clamping `t` to `F16_MAX` (`+Inf` → `w = 0.0` → `Inf * 0.0 = NaN`). In `downsample_karis.js`, `result += texel * weight` also multiplied all 4 channels where background pixels (`depth_weight = 0.0`) forced `weight = 0.0`, and `select(result, result / weight_sum, ...)` evaluated `result / 0.0` eagerly. | Large rectangular `NaN` black boxes across the 5-mip Bloom pyramid, SSR prefiltered color pyramid, and DoF firefly pass (`shader_dof_firefly_cleanup.js`). | Imported `F16_MAX_DEFINITION`; sanitized `t00..t11` (`vec3f`) in `chunk_karis_blur4x4_sample.js` and `texel` (`vec4f`) in `downsample_karis.js` to `[0.0, F16_MAX]`, and guarded `result / max(weight_sum, 1e-7)`. |
-| **BUG-4** | **✅ Landed** (`ca0faed94`) | [`ssr_resolve_shader.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js), [`ssr_spatial_denoise_shader.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js), [`chunk_ssr_temporal_accumulate.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.js) | Both `ssr_resolve_shader.js` (`abs(m2 - m1 * m1)`) and `ssr_spatial_denoise_shader.js` (`bootstrap_variance * sum_squared_weights / (sum_weight * sum_weight)`) wrote `f32` variance into `rgba16float.a` without clamping to `F16_MAX`, overflowing to `+Inf` when HDR luma deltas exceeded `256`. | `+Inf` variance in `rgba16float.a` propagated into spatial/temporal SSR denoise (`std_dev = Inf`), disabling luma edge-stopping and smearing bright specular reflections across edges. | Imported `F16_MAX_DEFINITION` and clamped variance to `[0.0, F16_MAX]` in `ssr_resolve_shader.js` and `ssr_spatial_denoise_shader.js` (and replaced literal `65504.0` in `chunk_ssr_temporal_accumulate.js`). |
-| **BUG-5** | **✅ Landed** (`a86cf8617`) | [`chunk_taa_tonemap_inv.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/taa/chunk_taa_tonemap_inv.js), [`chunk_taa_tonemap.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/taa/chunk_taa_tonemap.js), [`shader_taa.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/taa/shader_taa.js) | `taa_tonemap_inv` computed `rgb / (1.0 - luma)` without a denominator floor or output clamp: YCoCg AABB expansion (`mean + final_sigma * std_dev`) can push `luma >= 1.0` (dividing by zero to `+Inf` or inverting bright pixels negative), and even in `f32`, `65504.0 / 65505.0` rounds up to `65535 / 65536` so `1.0 - luma = 1 / 65536` round-tripped `F16_MAX` to `65535.0 > F16_MAX` (`+Inf` in `rgba16float`). Also `shader_taa.js` only clamped `color_current_raw` with `max(vec3(0.0), ...)`, leaving the `!hasValidHistory` path unguarded against `+Inf`/`NaN`. | Specular highlights and overbright HDR neighborhoods turned into `+Inf`, negative values, or `NaN` in TAA history and bloom input. | Imported `F16_MAX_DEFINITION`; guarded `taa_tonemap_inv` with `min(vec3<f32>(F16_MAX), safe_rgb / max(1.0 - luma, 1.0 / (F16_MAX + 1.0)))`, replaced `HALF_MAX` in `chunk_taa_tonemap.js`, and clamped `color_current_raw` to `[0.0, F16_MAX]` in `shader_taa.js`. |
-
----
-
-## 4. Master Classification Matrix of Proposed `shader-f16` Items
-
-Every proposed item is classified below by **Value** (`Critical`, `High`, `Medium`, `Low`), **Risk** (`Low`, `Medium`, `High`, `Extreme`), **Mechanism** (`2× ALU`, `VGPR`, `LDS Size`, `LDS Unpack`, `Bandwidth`), and **Artifact/Defect Profile**.
-
-### 4.1 Tier 1 — High-to-Critical Value, Low Risk (Immediate Recommended Targets)
-
-| ID | Proposed Item & Files | Mechanism | Value | Risk | Potential Artifacts / Defects & Required Mitigation |
-|---|---|---|---|---|---|
-| **F16-01** | **NSS Int8 U-Net Convolution (`vec4h` MACs + `var<workgroup>` `vec4h` Tile Cache)**<br>[`shader_nss_conv_layer.js:107-177`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/nss/shader_nss_conv_layer.js#L107-L177) | `LDS Size` (`800 B`) + `Bandwidth` (`-82%` 3D loads) + `2× ALU` (`576` `vec4h` dots/thread × 18 passes) | **Critical** | **Low** | **Artifact if misused:** Accumulating all 144 `dot` products in `f16` overflows or loses small bias terms (`biases` are scaled by $1/127^2 \approx 6.2 \times 10^{-5}$, right at `f16` min normal $6.10 \times 10^{-5}$), causing color bias/banding in upscaled output.<br>**Mitigation:** Cast `tInput` (`rgba16float` in $[-1,1]$) and `unpack4x8snorm(weights)` ($[-1,1]$) to `vec4h` for the 10×10 `var<workgroup>` tile and `dot(v_h, w_h)`, but accumulate the outer sum `acc`, `biases`, and `rescales` in `vec4<f32>`. |
-| **F16-02** | **DoF Raymarch & Slice Compute Native `f16` Shared Memory**<br>[`shader_dof_raymarch_compute.js:56, 88-97, 168-170`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.js#L56) & [`shader_dof_slice_compute.js:69, 81-84, 105-114`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/dof/raymarch/shader_dof_slice_compute.js#L69) | `LDS Unpack` (removes 576–2,304 `unpack2x16float` + shift + `select` ops/pixel) | **Critical** | **Low** | **Artifact if misused:** Zero visual difference for `lds_coc` (`tPrefilter.a` is already `rgba16float` in $[-48, 48]$). However, if bokeh color accumulator `acc` (`L212-215`) is also moved to `vec3h`, `samp * highlight_boost * luma(samp)` ($\propto \text{samp}^2$) overflows `65504` on HDR highlights $> 256$, producing black `NaN` bokeh discs.<br>**Mitigation:** Change `var<workgroup> lds_coc` to `array<f16, 7744>` (`15,488 B`) and `s_coc` / `cover` / `shape` to `f16`; keep `hl`, `w`, `acc`, and `wsum` in `f32`. |
-| **F16-03** | **Fluid MAC Vorticity Confinement Curl Shared Memory (`16.2 KB → 8.1 KB`)**<br>[`shader_fluid_mac_curl.js:40-44, 108-173`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_curl.js#L40-L44) & [`shader_fluid_mac_gradient.js:37`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/mac/shader_fluid_mac_gradient.js#L37) | `LDS Size` (`16,224 B → 8,112 B` in curl; `2,400 B → 1,200 B` in solid tile) + `VGPR` | **High** | **Low** | **Artifact if misused:** `shader_fluid_mac_curl` currently consumes `99%` of the 16 KiB workgroup limit (`L191-193`), restricting occupancy to 1 workgroup/SIMD. Vorticity confinement is an explicit turbulence boost ($\varepsilon \cdot \Delta t \cdot (\mathbf{N} \times \boldsymbol{\omega})$) where `f16` (10-bit mantissa) is indistinguishable from `f32`. In `shader_fluid_mac_gradient`, `fluid_mac_tile_solid` only stores `0.0` or `1.0`.<br>**Mitigation:** Use `f16` for `fluid_curl_u/v/w`, `fluid_curl_magnitude`, and `fluid_mac_tile_solid`. Keep `fluid_mac_tile_pressure` in `f32`. |
-| **F16-04** | **Brick4 GI Probe Decode & SH3 Evaluation in `vec3h`**<br>[`shader_brick4_indirect_lighting.js:109-189`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js#L109-L189), [`chunk_brick4_sh3_color_decode.js:11-43`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.js#L11-L43), [`chunk_sh3_uncompress.js:12-53`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_sh3_uncompress.js#L12-L53), [`chunk_sh3_color_get_radiance_with_GGX.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_color_get_radiance_with_GGX.js) | `VGPR` (`-54` 32-bit registers in Brick4 draw: 4 probes × 27 floats) + `2× ALU` (9-band `vec3h` FMA chains) | **Critical** | **Low** | **Artifact if misused:** Brick4 v2 stores DC as `rgbe9995` (max $65408 < 65504$, 9-bit mantissa, 100% lossless in `f16`) and L1/L2 as 8-bit normalized values scaled by $\le \sqrt{5} \cdot \text{DC}$. If `DC > 29294`, $\sqrt{5} \cdot \text{DC}$ can exceed `65504`.<br>**Mitigation:** Clamp `max_val` in `sh3_uncompress` to `65504.0h` (or keep `max_val` multiply at the end of the 9-band dot product!). Keep world-space cascade trilinear coordinates in `f32`. |
-| **F16-05** | **SSR DNSR Compute Prefilter Shared Memory**<br>[`chunk_ffx_dnsr_group_shared_memory.js:10-14`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/prefilter/chunk_ffx_dnsr_group_shared_memory.js#L10-L14), [`chunk_store_in_group_shared_memory.js:18-21`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/prefilter/chunk_store_in_group_shared_memory.js#L18-L21), [`chunk_load_from_group_shared_memory.js:15-20`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/prefilter/chunk_load_from_group_shared_memory.js#L15-L20) | `LDS Unpack` (removes 30 `unpack_float16_4` calls = 120 `f16` decodes/pixel) + `2× ALU` | **High** | **Low** | **Artifact if misused:** None — the shader already packs `radiance.xyz`, `variance`, and `normal.xyz` into `f16` via `pack2x16float` in `g_ffx_dnsr_shared_0..3`.<br>**Mitigation:** Replace `g_ffx_dnsr_shared_0..3` with `array<array<vec4<f16>, 16>, 16>` (`radiance_variance`) and `array<array<vec3<f16>, 16>, 16>` (`normal`); keep `g_ffx_dnsr_shared_depth` in `f32`. |
-| **F16-06** | **Hi-Z Single-Pass Downsampler (SPD) Shared Memory & Quad Reduction**<br>[`shader_hzb_spd.js:38, 54-96, 116-142`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/hiz/shader_hzb_spd.js#L38-L96) | `LDS Size` (`512 B → 256 B`) + `2× ALU` (`vec2h` `min`/`max` + `quadSwapX`/`Y`) | **Medium** | **Low** | **Artifact if misused:** All HZB mips (`tOut1..tOut4`) are stored in `rg16float` (`HZB_TEXTURE_FORMAT`). For mip 0 (`depth32float`), casting to `f16` *before* the first 2×2 reduction could add a second RTE rounding step.<br>**Mitigation:** Reduce mip 0's initial 4 `depth32float` samples in `vec2f`, cast to `vec2h` when writing `tOut1` and `hzb_spd_lds`, and run mips 1–4 completely in `vec2h`. Keep `uv_min + 1e-6` in `shader_hzb_reduce_mip0_clip.js:50` in `f32`. |
-| **F16-07** | **Environment SH2 & Atmosphere Multiscatter LUT Workgroup/Subgroup Reductions**<br>[`shader_project_environment_sh.js:49-52`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/light/environment/shader_project_environment_sh.js#L49-L52) & [`shader_multiscatter_lut.js:53-54, 99-124`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/atmosphere/shader_multiscatter_lut.js#L53-L54) | `LDS Size` (`4 KB → 2 KB` in Env SH; `512 B → 256 B` in Multiscatter) + `Subgroup vec3h` | **Medium** | **Low** | **Artifact if misused:** In `shader_project_environment_sh`, each sample is multiplied by `solid_angle` ($\approx 0.002$), so a 64-lane subgroup sum is at most $0.13 \times \text{F16\_MAX}$ — guaranteed never to overflow `f16`. In `shader_multiscatter_lut`, `lum` and `f_ms` are in $[0, 1]$ and write to `rgba16float`.<br>**Mitigation:** Use `array<vec3<f16>, 64>` for `wg_sh_0..3` and `array<vec3<f16>, 16>` for `wg_lum`/`wg_fms`. |
-| **F16-08** | **LPV Depth Border Buffer & SHARC Voxel Pack/Unpack Cleanup**<br>[`shader_lpv_atlas_border_read.js:16, 63`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/probe/octahedral/border/shader_lpv_atlas_border_read.js#L63), [`shader_lpv_atlas_paint_borders_depth.js:17, 51`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/probe/octahedral/border/shader_lpv_atlas_paint_borders_depth.js#L51), [`chunk_sharc_voxel_decode.js:10-25`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/sharc/shader/chunk_sharc_voxel_decode.js#L10-L25) | `LDS/Buffer Unpack` (removes manual `pack2x16float` / `unpack2x16float`) | **Low-Med** | **Low** | **Artifact if misused:** Zero visual change — data is already stored as packed `f16` pairs in `u32` buffers.<br>**Mitigation:** Declare `borders` as `array<vec2<f16>>` and use `bitcast<vec2<f16>>` / `bitcast<u32>` in SHARC decode/encode. |
-| **F16-09** | **Temporal Luma/Shadow Denoiser Shared Memory**<br>[`shader_temporal_reprojection_luma.js:64, 106-142`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/denoise/shader_temporal_reprojection_luma.js#L64) | `LDS Size` (`768 B → 384 B`) + `2× ALU` | **Low-Med** | **Low** | **Artifact if misused:** `g_mean_accumulation` stores horizontal sums of 17 binary `(0/1)` shadow hits (integers in $[0, 17]$), and `sample_neighborhood` sums 17 rows (integers in $[0, 289]$). Since `f16` represents all integers up to `2048` **exactly**, switching `g_mean_accumulation` to `f16` is 100% bit-exact.<br>**Mitigation:** Keep final `m2 - m1 * m1` variance subtraction (`L232-235`) in `f32`. |
-
----
-
-### 4.2 Tier 2 — High-to-Medium Value, Medium Risk (Requires Specific Precision Guards)
-
-| ID | Proposed Item & Files | Mechanism | Value | Risk | Potential Artifacts / Defects & Required Mitigation |
-|---|---|---|---|---|---|
-| **F16-10** | **Deferred & Forward `MaterialShadingInfo`, Unit Normals, & Diffuse/Fresnel BRDFs**<br>[`shader_deferred_main.js:84-128`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/deferred/shader_deferred_main.js#L84-L128), [`chunk_shade_standard_material_direct.js:50-125`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/deferred/chunk_shade_standard_material_direct.js#L50-L125), [`chunk_forward_shade_standard_fragment.js:58-195`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.js#L58-L195), [`MATERIAL_SHADING_INFO_STRUCT.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js), [`chunk_F_Schlick.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/brdf/fresnel/chunk_F_Schlick.js), [`EON.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/brdf/diffuse/EON.js) | `VGPR` (`-14` 32-bit VGPRs live across 64–128 light loops & ray queries) + `2× ALU` | **Critical** | **Medium** | **Artifacts if misused:**<br>1. `EON.js:58, 66-71` uses `1e-7` and `M_FLOAT_EPS = 1e-8` denominator guards, and `chunk_forward_shade_standard_fragment.js:94` uses `max(t_diffuse.a, 1e-7)`. In `f16`, `1e-7` and `1e-8` flush to `0.0h`, causing **`0 / 0 = NaN` black pixels on grazing diffuse surfaces or zero-alpha texels**.<br>2. [`white_furnace.spec.js:473-521`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/deferred/white_furnace.spec.js#L473-L521) asserts `1e-6` (`F32_ROUNDING`) on metalness linearity in `shader_resolve_indirect_lighting`.<br>**Mitigation:** Replace `1e-7`/`1e-8` in `EON.js` and alpha un-premultiply with `1e-4h`; keep `D_GGX`, `V_GGX_SmithCorrelated`, `get_bent_noh_squared`, and `position_ws` in `f32`; either keep the final metalness lerp in `f32` or relax `white_furnace.spec.js` metalness linearity tolerance to `1e-3` (1 `f16` ULP). |
-| **F16-11** | **Volumetric Froxel Lighting & 6-Octave Multiscattering Loop**<br>[`shader_volumetrics_build_lighting.js:55-62, 205-409`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js#L55-L62) & [`chunk_calculate_multiscattering.js:16-85`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/chunk_calculate_multiscattering.js#L16-L85) | `VGPR` (relieves documented `@workgroup_size(8,8,1)` register limit at `L55-58`) + `2× ALU` | **High** | **Medium** | **Artifacts if misused:**<br>1. In `shader_volumetrics_build_lighting.js:137-138`, `z0 * z0 * z0` ($z^3$) overflows `f16` (`65504`) for any depth **$z > 40.31\text{ m}$**, breaking froxel depth placement.<br>2. For large water droplets ($d \in [5, 50]\ \mu\text{m}$, $g > 0.9$), `chunk_phase_draine` (`chunk_calculate_multiscattering.js:61`) overflows/cancels in `f16` near $\theta = 0^\circ$, creating **bright/NaN rings around the sun in fog**.<br>**Mitigation:** Keep $z^3$ depth math, `chunk_phase_draine`, and `inScatteringSum` in `f32`; use `f16`/`vec3h` for media properties (`rgba16float`), `shadow_term`, `transmittance_atmospheric`, `scattering_decay`, `extinction_factor`, `current_g`, and `phase_dual` (for $g \le 0.8$). |
-| **F16-12** | **Water Spectrum Column IFFT (`var<workgroup>`) & `rows` Buffer**<br>[`chunk_fft128x4_inverse_workgroup.js:19-38`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.js#L19-L38) & [`shader_water_spectrum.js:46, 78-147`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/surface/spectrum/shader_water_spectrum.js#L46-L147) | `LDS Size` (`4 KiB → 2 KiB`) + `Bandwidth` (`32 B → 16 B`/cell in `rows`) + `2× ALU` | **High** | **Medium** | **Artifacts if misused:**<br>1. In `shader_water_spectrum_rows`, `water_band_mode_phase` computes `fract(turns * loop_fraction)` where `turns > 2048`. In `f16`, numbers $> 2048$ have **zero fractional bits**, freezing wave motion!<br>2. Unnormalized capillary mode amplitudes in Band 0 can be $\sim 10^{-5}$ before the row IFFT, losing precision in `f16` if the row pass is converted without rescaling.<br>**Mitigation:** Keep `shader_water_spectrum_rows` (mode generation + row IFFT) in `f32`, store `rows` as `vec4h` (after the 128-point row sum has boosted amplitude by $\sim 8\times$, or scaled by $2^6$), and run `shader_water_spectrum_columns` in `vec2h` writing `rgba16float`. |
-| **F16-13** | **XeGTAO Horizon Integration & Bent-Normal Polynomial**<br>[`fragment_shader_gtao.js:171-331`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js#L171-L331), [`fragment_shader_gtao_with_irradiance.js:154-362`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js#L154-L362), [`chunk_integrate_bent_normal_fast.js:12-32`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/gtao/chunk_integrate_bent_normal_fast.js#L12-L32) | `2× ALU` + `VGPR` | **High** | **Medium** | **Artifacts if misused:**<br>1. `viewspaceZ *= 0.99999` (`L133`) shifts depth by $10^{-5}$; in `f16`, `0.99999h` rounds to `1.0h`, **destroying self-occlusion bias and causing false AO stippling/acne**.<br>2. `sampleDelta0 = samplePos0 - position_vs` (`L255`) in `f16` causes view-space quantization banding at distance (explicitly warned in the upstream XeGTAO comment at `L255`).<br>**Mitigation:** Keep `viewspaceZ`, `position_vs`, `uv + sampleOffset`, `sampleDelta0/1`, and `sampleDist0/1` in `f32`; convert `sampleHorizonVec0/1`, `weight0/1`, `shc0/1`, `horizonCos0/1`, `fast_acos`, `iarc0/1`, and `integrate_bent_normal_fast` to `f16`/`vec2h`/`vec3h`. |
-| **F16-14** | **TAA Resolve YCoCg Neighborhood & Catmull-Rom Color Blend**<br>[`shader_taa.js:161-235`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/taa/shader_taa.js#L161-L235), [`chunk_taa_history_color_bounding_box_YCoCg.js:43-72`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/taa/chunk_taa_history_color_bounding_box_YCoCg.js#L43-L72), [`chunk_color_clip_to_aabb3.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/color/chunk_color_clip_to_aabb3.js) | `VGPR` + `2× ALU` | **Medium** | **Medium** | **Artifacts if misused:**<br>1. `taa_tonemap_inv` in `f16` rounds `luma` to `1.0h` for any raw HDR luminance $> 2047$, dividing by zero (`+Inf`).<br>2. `get_std_dev3` (`abs(m2 - m1 * m1)`) in `f16` suffers 1-ULP (`5e-4`) cancellation floor on flat surfaces (`sqrt(5e-4) = 0.022`), widening the YCoCg box and **increasing ghosting**.<br>3. Catmull-Rom UV tap math in `f16` loses sub-pixel phase `f` above 1024 px, causing blocky staircase edges.<br>**Mitigation:** Keep Catmull-Rom UVs, `taa_tonemap`, `taa_tonemap_inv`, `moment2`, and `get_std_dev3` in `f32`; use `vec3h` for tonemapped YCoCg samples (in $[-1, 1]$), `color_clip_to_aabb3`, and blend weights. |
-| **F16-15** | **Volumetric 3D TAA (`@workgroup_size(8,8,4)` = 256 threads)**<br>[`shader_volumetrics_taa.js:30-145`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js#L30-L145) & [`chunk_volumetric_history_bounding_box.js:13-79`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.js#L13-L79) | `VGPR` (256-thread workgroup) + `2× ALU` | **Medium** | **Medium** | **Artifacts if misused:**<br>1. Squaring HDR volumetric samples in `moment2 += encoded_sample * encoded_sample` (`L52`) overflows `f16` when radiance $> 255.9$, producing `NaN` AABB bounds.<br>2. Reprojection coordinate `prev_w = prev_slice / f32(res.z)` in `f16` loses sub-froxel precision, causing **exponential Z-blurring drift** (`chunk_volumetrics_taa_reproject.js:137-141`).<br>**Mitigation:** Keep `volumetrics_taa_reproject`, `moment1`, `moment2`, and `get_std_dev4` in `f32`; use `vec4h` for the 27 fetched `rgba16float` samples, `RGB_to_YCoCg4`/`YCoCg_to_RGB4`, and `color_clip_to_aabb4`. |
-| **F16-16** | **FidelityFX RCAS Sharpening (`FsrRcasH`)**<br>[`shader_ffx_rcas.js:49-100`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/cas/shader_ffx_rcas.js#L49-L100) | `2× ALU` + `VGPR` | **Medium** | **Medium** | **Artifacts if misused:**<br>1. Lines 86–87 add `vec3f(1e-6)` to denominators `4.0 * maxRGB` and `4.0 * minRGB - 4.0`. In `f16`, `1e-6` is subnormal and absorbed by `-4.0h`, so when `minRGB == 1.0h` (white pixel), `(1.0h - 1.0h) / (4.0h - 4.0h) = 0 / 0 = NaN` **speckles white highlights with black NaN pixels**.<br>2. If called on linear HDR $> 1.0$, `1.0 - maxRGB` goes negative.<br>**Mitigation:** Replace denominator guards with `max(4.0h * maxRGB, vec3h(1e-4h))` and `min(4.0h * minRGB - vec3h(4.0h), vec3h(-1e-4h))`, and only invoke `f16` RCAS on `[0, 1]` display-referred / tonemapped images. |
-| **F16-17** | **SSR Spatial Denoise, Resolve BRDF Weights, & Combine**<br>[`ssr_spatial_denoise_shader.js:79-133`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js#L79-L133), [`ssr_resolve_shader.js:230-268`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js#L230-L268), [`ssr_combine_shader.js:52-134`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/ssr_combine_shader.js#L52-L134) | `VGPR` + `2× ALU` | **Medium** | **Medium** | **Artifacts if misused:**<br>1. In `ssr_resolve_shader` (`L190, 291`) and `chunk_ssr_temporal_accumulate` (`L30-35, 80`), second-moment `luma * luma` and `previous.w * old_age` (up to $65504 \times 128 = 8.38 \times 10^6$) overflow `f16`.<br>2. In `reconstruct_pdf` (`chunk_reconstruct_pdf.js`), GGX NDF overflows/cancels at low roughness in `f16`.<br>**Mitigation:** Use `vec3h`/`f16` for view-space unit normals, `ffx_dnsr_reflections_get_edge_stopping_normal_weight`, `env_brdf_approx` (`DFGApprox`), and `compute_specular_occlusion`; keep second moments, variance, and GGX PDF in `f32`. |
-| **F16-18** | **ReSTIR DI Spatial À-Trous Denoiser & Surface Material Struct**<br>[`shader_restir_di_denoise.js:58-125`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/restir/di/shader_restir_di_denoise.js#L58-L125) & [`chunk_restir_reconstruct_surface.js:26-62`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/restir/di/chunk_restir_reconstruct_surface.js#L26-L62) | `VGPR` + `2× ALU` | **Medium** | **Low-Med** | **Artifacts if misused:** In `shader_restir_di_denoise.js:114-115`, luma and depth floors are `1e-3` (well above `f16` min normal `6.10e-5`). However, `center_depth` and `sample_depth` are linear view depths where `abs(center_depth - sample_depth)` needs `f32` precision.<br>**Mitigation:** Keep `center_depth`, `sample_depth`, `d_depth`, and all `RTXDI_Reservoir` fields in `f32`; run `center_normal`, `sample_normal`, `w_normal`, `d_luma`, `w`, and `RestirSurface.material` in `f16`/`vec3h`. |
-| **F16-19** | **Forward Transparency Vertex-to-Fragment Varying Interpolants**<br>[`FORWARD_VERTEX_SHADER_STRUCT.js:10-12`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/forward/FORWARD_VERTEX_SHADER_STRUCT.js#L10-L12) & [`vertex_shader_chunk.js:70-79`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/forward/vertex_shader_chunk.js#L70-L79) | `Bandwidth` (parameter cache / varying interpolation across AVBOIT & MBOIT passes) + `VGPR` | **Medium** | **Low** | **Artifacts if misused:** Converting `position_ws: vec3f` or `uv: vec2f` (for tiled UVs $> 16$) in `FORWARD_VERTEX_SHADER_STRUCT` to `f16` causes texture swimming and world-space lighting quantization.<br>**Mitigation:** Convert only `normal: vec3<f16>`, `tangent: vec4<f16>` (unit vectors in $[-1, 1]$), and `color: vec3<f16>` (vertex color in $[0, 1]$), saving 10 half-floats (20 bytes/vertex) of varying interpolation while keeping `position_ws: vec3<f32>` and `uv: vec2<f32>`. |
-| **F16-20** | **DoF & Motion Blur Tile-Max Compute Conversion (`var<workgroup>` `f16`)**<br>[`shader_dof_tile_max.js:35-47`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/dof/raymarch/shader_dof_tile_max.js#L35-L47), [`shader_dof2_tile_max.js:37-48`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/dof/gather/shader_dof2_tile_max.js#L37-L48), [`shader_motion_blur_tile_max.js:34-61`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/motion_blur/shader_motion_blur_tile_max.js#L34-L61) | `LDS Size` (`512 B` / `1 KB`) + `2× ALU` (replaces 256 serial `textureLoad`s/thread with 1 load/thread + `subgroupMax`) | **Medium** | **Medium** | **Artifacts if misused:** In `shader_motion_blur_tile_max.js:45` and `shader_motion_blur_neighbor_max.js:41`, velocity is in **pixels** and dominance compares `mag_sq = dot(v, v)`. When motion exceeds $\sqrt{65504} = 255.9\text{ px/frame}$, `dot(v, v)` in `f16` overflows to `+Inf`, breaking `mag_sq > best_mag_sq` (`Inf > Inf` is `false`) and picking the wrong dominant velocity vector.<br>**Mitigation:** Store `vec2h` velocity in `var<workgroup>`, but compute `mag_sq = dot(vec2f(v), vec2f(v))` (or `length(vec2f(v))`) in `f32`. |
-| **F16-21** | **Froxel & World Light Cluster Culling (`ClusterCell` Normals & `ClusterLightProxy`)**<br>[`chunk_cluster_cell.js:27-30`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/light/cluster/chunk_cluster_cell.js#L27-L30), [`CLUSTER_LIGHT_PROXY.js:17`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/light/cluster/CLUSTER_LIGHT_PROXY.js#L17), [`shader_world_cluster_assign_lights.js:43`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js#L43) | `VGPR` (`-4` VGPRs/thread for `nl,nr,nb,nt`) + `LDS Size` (`4 KB → 3 KB` in `shared_proxies`) | **Medium** | **Medium** | **Artifacts if misused:** `CLUSTER_LIGHT_PROXY_UNBOUNDED_RADIUS = 1e30`, `FLT_MAX = 3.4e38`, and squared distances `d2 = lateral^2 + depth^2` in `cluster_sphere_tile_span` (`chunk_cluster_light_proxy.js:40`) overflow `f16` whenever distance $> 255.9\text{ m}$, causing **missing or false-positive light assignment beyond 256 m**.<br>**Mitigation:** Convert only the 2D unit plane normals `C.nl, C.nr, C.nb, C.nt` (`vec2h`, components in $[-1, 1]$) and `proxy.direction_cos` (`vec4h`, unit axis + `coneCos` in $[-1, 1]$); keep `bound`, `apex_height`, `depth`, and `sphere` in `f32`. |
-| **F16-22** | **Water Surface Detail, Wave Particle Envelope, & Coherent Optics**<br>[`chunk_water_surface_sample.js:163-202`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/surface/chunk_water_surface_sample.js#L163-L202), [`chunk_water_particle.js:284-303`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/surface/particles/chunk_water_particle.js#L284-L303), [`shader_water.js:524-612`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/shader_water.js#L524-L612), [`chunk_water_optics.js:22-77`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/optics/chunk_water_optics.js#L22-L77) | `VGPR` + `2× ALU` | **Medium** | **Medium** | **Artifacts if misused:**<br>1. `water_segment_integral` (`chunk_water_optics.js:23`) uses Taylor expansion when `abs(y) < 1e-3`; in `f16`, `(exp(y) - 1.0h) / y` loses precision for `abs(y) < 1e-2h`, causing subtle banding in thin water layers.<br>2. Band UVs `(to_tile * p) / period` in `f16` step coarsely far from the origin.<br>**Mitigation:** Keep `uv` and particle radial distance `u` / `carrier` in `f32`; use `f16`/`vec2h`/`vec3h` for `water_band_derivatives` accumulation, particle cosine envelope, Fresnel, and `water_inscatter` (widening the Taylor threshold in `water_segment_integral` to `1e-2h`). |
-| **F16-23** | **Bloom Standard Downsample, Tent Upsample, & Mix**<br>[`downsample_standard.js:57-98`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/bloom/downsample_standard.js#L57-L98), [`upsample_blur.js:41-104`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/bloom/upsample_blur.js#L41-L104), [`shader_bloom_mix.js:27-53`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/bloom/shader_bloom_mix.js#L27-L53) | `2× ALU` + `VGPR` | **Low-Med** | **Low-Med** | **Artifacts if misused:** In `upsample_blur.js:41-58`, the 9 tent weights `(1, 2, 1, 2, 4, 2, 1, 2, 1)` sum to `16.0` and divide by `16.0` at the end. In `vec3h`, any bloom texel $> 65504 / 16 = 4094$ overflows `result` to `+Inf` before the `1/16` multiply!<br>**Mitigation:** Pre-normalize the tent weights to `(0.0625h, 0.125h, 0.25h)` so the convex combination never exceeds the maximum input texel. Keep `uv + texel_size * offsets[i]` in `vec2f`. |
-| **F16-24** | **Staged Ray-Tracing Octahedral Ray Direction Packing**<br>[`chunk_pack_ray.js:23-35`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/ray/staged/chunk_pack_ray.js#L23-L35) & [`chunk_unpack_ray.js:7-25`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/ray/staged/chunk_unpack_ray.js#L7-L25) | `Bandwidth` (implements author's `NOTE` at `chunk_pack_ray.js:25`: cuts ray payload from 32 B to 24 B or 16 B) | **Medium** | **Medium** | **Artifacts if misused:** Octahedral `f16×2` direction has angular resolution $\approx 0.05^\circ$ (10-bit mantissa). Over very long shadow rays ($> 500\text{ m}$), a $0.05^\circ$ direction shift moves the far endpoint by $\sim 0.4\text{ m}$, which can slightly shift hard distant shadow edges (soft shadows mask it). Never pack `ray.origin` into `f16` (causes severe self-intersection shadow acne).<br>**Mitigation:** Keep `ray.origin` (`vec3f`), `ray.tmin`, and `ray.tmax` in `f32` (or `vec2h(tmin, tmax)` for local shadow rays $< 65504\text{ m}$), and pack `ray.direction` as octahedral `vec2h`. |
-| **F16-25** | **VRS Luminance Delta, SDF Soft Shadow Cone Math, & Contact Shadow Fade**<br>[`chunk_vrs.js:58-114`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/ray/chunk_vrs.js#L58-L114), [`shader_scene_sdf_soft_shadows.js:132-158`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/sdf/cascade/shader_scene_sdf_soft_shadows.js#L132-L158), [`shader_contact_shadow_wavefront.js:289-318`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/contact/shader_contact_shadow_wavefront.js#L289-L318) | `VGPR` + `2× ALU` | **Low-Med** | **Low** | **Artifacts if misused:** In `shader_contact_shadow_wavefront.js`, `depth_data` stores `NO_SHADOW_DEPTH = 1e20` (`L133`) and `start_depth` uses a `1.0 / 65535.0` offset (`L262`), so `depth_data` and `start_depth - samples * depth_scale` must stay `f32`.<br>**Mitigation:** Only convert VRS luminance deltas (`[0, 1]`), SDF cone `step_visibility`/`visibility` (`[0, 1]`), and post-comparison contact shadow `hard_shadow`/`fade_out` (`[0, 1]`) to `f16`. |
-| **F16-26** | **Exponential SH (`p4q2`) Base Reflectance, Particle AVBOIT Lighting, & Skinning Normal/Tangent DQ Rotation**<br>[`chunk_sh_exp_p4q2_base_reflectance.js:32-50`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_p4q2_base_reflectance.js#L32-L50), [`shader_particle_avboit_draw.js:113-152`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js#L113-L152), [`shader_meshlet_apply_skinning.js:311-329`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js#L311-L329) | `VGPR` + `2× ALU` (34-band `vec3h` FMA chain in `sh_exp`; fragment VGPRs in particles; DQ normal rotation in skinning) | **Medium** | **Low** | **Artifacts if misused:** In `shader_meshlet_apply_skinning.js`, vertex positions (`p_skinned`, `p_prev_skinned`) and dual-quaternion translation part `dq_blend.dual` must remain `f32` or skinned meshes jitter in TAA.<br>**Mitigation:** Use `vec3h`/`vec4h` only for the rotation of unit normals/tangents (`dual_quat_transform_direction(vec4h(dq_blend.real), n_h)`), particle SH lighting (`rgba16float` clipmap), and `sh_exp_p4q2` polynomial evaluation. |
-| **F16-27** | **G-Buffer Laydown Normal/Tangent/Color & Khronos PBR Neutral Tonemapper**<br>[`fragment_gbuffer.js:249-346`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/material/standard/fragment_gbuffer.js#L249-L346), [`chunk_tonemap_khronos_pbr.js:25-46`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.js#L25-L46), [`shader_avboit_integrate.js:63-80`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/native/avboit/shader_avboit_integrate.js#L63-L80) | `VGPR` + `2× ALU` | **Low-Med** | **Low** | **Artifacts if misused:** In `fragment_gbuffer.js`, visibility-buffer `barycentric_full` (`L198`), `uv_info` derivatives (`L213`), and `anti_alias_roughness_kaplanyan` (`fwidth` squared down to $2.5 \times 10^{-7}$) must remain `f32`.<br>**Mitigation:** Use `vec3h` only for tangent-frame construction (`build_orthonormal_matrix_nt`), normal map decoding, 8-bit triangle dither, `shader_avboit_integrate` (`rgba8unorm`), and `tonemap_khronos_pbr` (after clamping exposed input to `65504.0`). |
-
----
-
-### 4.3 Tier 3 — Explicit "Do-Not-Convert" (`f32`-Mandatory) Red Zones
-
-The following 16 subsystems/calculations were audited and proven mathematically incompatible with `f16`. Converting any of them produces immediate, severe visual defects or fails existing unit test oracles:
-
-| Red Zone ID | Subsystem & Files | Why `f16` Fails (Mathematical Mechanism) | Resulting Visual Defect / Failure |
-|---|---|---|---|
-| **NO-F16-01** | **GGX Normal Distribution (`D_GGX`) & Smith-Correlated Visibility (`V_GGX_SmithCorrelated`)**<br>[`chunk_D_GGX.js:26, 40-50`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/brdf/chunk_D_GGX.js#L26-L50), [`chunk_V_GGX_SmithCorrelated.js:19-25`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/brdf/chunk_V_GGX_SmithCorrelated.js#L19-L25) | 1. `BSDF_ROUGHNESS_MINIMUM = 0.02` gives $\alpha^2 = 1.6 \times 10^{-7}$ (deep in `f16` subnormals).<br>2. In `denom = NoH_squared * (a2 - 1.0) + 1.0`, for **any `roughness < 0.148`** ($\alpha^2 < 2^{-11} = 4.88 \times 10^{-4}$), `a2 - 1.0h` rounds to **exactly `-1.0h`**. At `NoH_squared == 1.0h`, `denom == 0.0h` and `a2 / (PI * denom * denom)` evaluates **`0 / 0 = NaN` or `+Inf`**!<br>3. Peak $D_{\text{GGX}} = \frac{1}{\pi \alpha^2}$ exceeds `65504` whenever `roughness < 0.047` (reaching $1.99 \times 10^6$ at `roughness = 0.02`). | **Black `NaN` holes or `+Inf` fireflies at the center of every smooth specular highlight** (`roughness < 0.15`), which then explode into screen-sized artifacts in TAA, SSR, and Bloom. |
-| **NO-F16-02** | **Decima Area-Light Representative Point Solver**<br>[`chunk_get_bent_noh_squared.js:12-81`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/material/chunk_get_bent_noh_squared.js#L12-L81) | Evaluates the 3-vector Gram determinant `1 - NoL^2 - NoV^2 - VoL^2 + 2*NoL*NoV*VoL` (`L47`, which vanishes when `N, L, V` are coplanar) and a cubic Newton step guarded by `1e-8` (`L65`). In `f16`, `1e-8` flushes to `0.0h` and the Gram determinant suffers catastrophic cancellation. | **Single-pixel bright specular fireflies and `NaN` speckles along grazing silhouettes** (documented at `L26-38`). |
-| **NO-F16-03** | **MBOIT Power & Trigonometric Moments & Cholesky/Hankel Solvers**<br>[`shader_oit_generate_moments.js:174-204`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/native/oit/shader_oit_generate_moments.js#L174-L204), [`chunk_compute_transmittance_from_4_power_moments.js:29-104`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/mboit/moments/power/chunk_compute_transmittance_from_4_power_moments.js#L29-L104), [`chunk_compute_transmittance_from_4_trigonometric_moments.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_4_trigonometric_moments.js) | Uses `moment_bias = 6e-6` (10× smaller than `f16` min normal `6.1e-5`), `c2_safe = 1e-10`, and `d = 1e-20` in Hankel/Toeplitz Cholesky elimination (`d11 = b[1] - b[0]*b[0]`). In `f16`, `d11` and `d22` quantize to `<= 0`, breaking positive-definiteness. | **Camera-locked `NaN` stripes and missing/exploding transparency across all MBOIT surfaces** (documented at `L54-60`). |
-| **NO-F16-04** | **AVBOIT Low-Extinction Taylor Renormalization**<br>[`chunk_avboit_renormalization.js:5-10`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/native/avboit/chunk_avboit_renormalization.js#L5-L10) & [`chunk_avboit_transmittance_to_extinction.js:15`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/native/avboit/chunk_avboit_transmittance_to_extinction.js#L15) | Divides `loss / max(norm, vec3f(1e-20))` for `x < 0.001`. In `f16`, `1e-20` flushes to `0.0h` and faint transparent surfaces (`coverage * T < 6.1e-5`) underflow `norm` to `0.0h`, producing `0 / 0 = NaN`. | **Faint smoke/glass/particles vanish or flicker** as `is_nan` drops the pixel in `shader_avboit_resolve.js:53`. |
-| **NO-F16-05** | **ACES 2.0 Output Transform & UE Filmic Tonemappers**<br>[`chunk_aces2_output_transform.js:73, 226, 242`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces2_output_transform.js#L73), [`chunk_tonemap_ue_filmic.js:47, 116`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_ue_filmic.js#L47) | 1. ACES 2.0 Hellwig CAM `pow(x, 1.0 / 0.42)` ($\approx x^{2.38}$) overflows `f16` when LMS $> 105$, and the inverse gamut compressor quadratic `b - sqrt(b^2 - 4ac)` near `J_max` amplifies rounding error by $5\times$ (`ACES_TONE_MAPPING_BRIEF_2026_10_17.md:101`).<br>2. `chunk_tonemap_ue_filmic` computes `log2(max(color, 1e-10))`, which in `f16` flushes `1e-10` to `0.0h` → `log2(0) = -Inf` → `NaN`. | **Visible highlight contouring/banding in ACES 2.0** (fails `shader_tonemap_aces.spec.js` `1e-4` tolerance) and **`NaN` black pixels in dark shadows in UE Filmic**. |
-| **NO-F16-06** | **ReSTIR DI Reservoir State (`targetPdf`, `weightSum`, `M`)**<br>[`RTXDI_PackedReservoir.js:13-14`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/restir/reservoir/RTXDI_PackedReservoir.js#L13-L14), [`restir/reservoir/shader.js:46-81`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/restir/reservoir/shader.js#L46-L81) | `targetPdf` for distant/grazing lights falls below $6.1 \times 10^{-5}$ (underflowing to `0.0h`), while `weightSum = targetPdf * invSourcePdf * M` across many lights exceeds `65504` (overflowing to `+Inf`). | **Permanent temporal `NaN` / firefly feedback loops** across frames and failure of `white_furnace.spec.js:714` (`1e-6` parity). |
-| **NO-F16-07** | **Second-Moment Variance Subtraction (`m2 - m1 * m1`) Across LPV, GTAO, SSR, TAA, Volumetrics**<br>[`chunk_lpv_get_visibility_mask.js:34-49`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js#L34-L49), [`fragment_shader_denoise_ao.js:42, 50`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/denoise/fragment_shader_denoise_ao.js#L42), [`chunk_get_std_dev3.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/math/statistics/chunk_get_std_dev3.js) | 1. For HDR signals $> 255.9$, `m2 = x * x` overflows `65504` to `+Inf`.<br>2. For smooth signals where $\sigma < 0.03$, $\sigma^2 = E[X^2] - (E[X])^2 < 10^{-3}$ is smaller than 1 `f16` ULP at $E[X] \approx 1.0$, cancelling to `0.0h` (or `-1 ULP`).<br>3. `MIN_VARIANCE = 1e-6` / `eps_variance = 1e-10` flushes to `0.0h`. | **Spatial denoisers freeze (stop filtering noise) when `std_dev` collapses to `0`**, or **LPV Chebyshev visibility divides `0 / 0 = NaN`**, causing light leaking and shadow acne. |
-| **NO-F16-08** | **Atmosphere Planetary Geometry & Meter-Scale Extinction Coefficients**<br>[`PLANET_RADIUS_DECLARATION.js:5`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.js#L5), [`C_RAYLEIGH_DECLARATION.js:12`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/atmosphere/C_RAYLEIGH_DECLARATION.js#L12), [`C_OZONE_DECLARATION.js:8`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/atmosphere/C_OZONE_DECLARATION.js#L8), [`chunk_phase_draine.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_phase_draine.js) | `PLANET_RADIUS = 6,378,000 m` and `ATMOSPHERE_HEIGHT = 100,000 m` both exceed `65504` (`+Inf`). Even in km (`6378`), `r^2 = 4.07e7` overflows `f16` and `length(pos) - 6378` has a **4 km altitude ULP**! Meanwhile, Rayleigh (`5.8e-6`), Mie (`4e-6`), and Ozone (`8.5e-8`) $\text{m}^{-1}$ coefficients are deep in `f16` subnormals. | **Complete failure of sky/atmosphere rendering** (ray-sphere intersection returns `NaN`, altitude steps in 4 km bands, and ozone/Rayleigh extinction flushes to zero). |
-| **NO-F16-09** | **Fluid Multigrid Pressure V-Cycle & Divergence Projection**<br>[`shader_fluid_mg_smooth.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_smooth.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), [`shader_fluid_mg_coarsest.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js) | Multigrid residual `r = f - A*p` and coarse-grid error corrections decay by $10\times$–$100\times$ per V-cycle (`GPUFluidCascade.js:46-48`), and `params.h2` scales with $h^2$. In `f16`, relaxation stalls at the $10^{-3}$ ULP floor. | **Non-divergent wind projection fails**, leaving compressible artifacts and failing the `1.25×` CPU quality gate (`GPUFluidCascade.quality.slow.spec.js`). |
-| **NO-F16-10** | **Water CDLOD Lattice, Canonical Cell Clipping, & Two-Pass `@invariant` Depth**<br>[`chunk_water_lod.js:12-109`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/surface/lod/chunk_water_lod.js#L12-L109), [`chunk_water_lod_cell.js:10-224`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/surface/lod/chunk_water_lod_cell.js#L10-L224), [`shader_water.js:110, 646`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/water/shader_water.js#L110) | Relies on exact `f32` agreement across LOD levels (`k == 1` morph boundary), canonical Sutherland-Hodgman edge clipping, and `@invariant @builtin(position)` for the `depthCompare: 'equal'` finalize pass. | **T-junction cracks between water LOD rings, watertight boundary holes, and dropped pixels in the `depthCompare: 'equal'` second pass**. |
-| **NO-F16-11** | **Shadow Map / VSM Depth, Receiver-Plane Bias, PCF Texel Coords, & EVSM**<br>[`chunk_sample_shadowmap_atlas_for_light.js:67-102`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/map/shader/chunk_sample_shadowmap_atlas_for_light.js#L67-L102), [`chunk_shadowmap_sample_5.js:18-40`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_5.js#L18-L40), [`chunk_shadowmap_compute_receiver_plane_depth_bias.js:17-31`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/map/shader/chunk_shadowmap_compute_receiver_plane_depth_bias.js#L17-L31), [`chunk_evsm_warp_depth.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/evsm/chunk_evsm_warp_depth.js) | 1. Shadow atlas texel coordinates reach `2048–8192`, where `f16` ULP is **2 to 8 texels**, wiping out fractional PCF weights `fract(texel_position + 0.5)`.<br>2. Receiver-plane Jacobian determinant `r = ddx.x * ddy.y - ddx.y * ddy.x` ($\sim 10^{-6}$) flushes to `0.0h` (`1/0 = Inf`).<br>3. EVSM `exp(40.0 * depth)` reaches $2.35 \times 10^{17}$ (overflowing `f16` at $e^{11.09} \approx 65504$). | **Blocky 4–8 texel stair-stepped shadow edges, severe shadow acne / peter-panning, and total EVSM overflow**. |
-| **NO-F16-12** | **Screen-Space HZB Raymarch (`SSR` & Contact Shadows)**<br>[`chunk_ffx_sssr_hierarchical_raymarch.js:20-109`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_hierarchical_raymarch.js#L20-L109), [`shader_contact_shadow_wavefront.js:139-285`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shadow/contact/shader_contact_shadow_wavefront.js#L139-L285) | `uv_offset = 0.005 / screen_size` ($\sim 2.6 \times 10^{-6}$ at 1080p) underflows in `f16`, and screen UV in $[0.5, 1.0]$ has `f16` step $2^{-11} = 1/2048$ (1–2 pixels at 1080p/4K). | **SSR rays get stuck in infinite loops on HZB cell boundaries and produce severe staircase reflections**. |
-| **NO-F16-13** | **Visibility-Buffer Barycentrics & UV Derivatives**<br>[`fragment_gbuffer.js:190-248`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/material/standard/fragment_gbuffer.js#L190-L248) & [`chunk_barycentric_full.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/geometry/barycentric/chunk_barycentric_full.js) | Computes screen-space edge cross products and `1/w` perspective derivatives from clip-space vertices. | **Severe texture UV swimming, wrong mip-level selection, and cracks along triangle edges**. |
-| **NO-F16-14** | **GPU BVH Morton Codes, Bottom-Up Refit, & Unbiased AABB Quantization**<br>[`chunk_bvh_morton_code.js:23-41`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/gpu_primitive/bvh/chunk_bvh_morton_code.js#L23-L41), [`chunk_bvh_refit_climb.js:55-102`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/gpu_primitive/bvh/chunk_bvh_refit_climb.js#L55-L102), [`GPU_BVH_BUILD_PLAN.md:1330-1339`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/gpu_primitive/bvh/GPU_BVH_BUILD_PLAN.md#L1330-L1339) | Rounding an `f32` AABB to `f16` with round-to-nearest-even (or a fixed additive `FLT_EPSILON_16 = 2^-10` that rounds away when $|x| > 1$) shrinks AABBs inward by up to 0.5 ULP (`0.5 m` at `1024 m`). | **Ray queries and frustum culling silently miss triangles near AABB boundaries**. |
-| **NO-F16-15** | **Auto-Exposure Histogram Reduction & Adaptation (`@workgroup_size(1)`)**<br>[`shader_autoexposure_read_histogram.js:48, 86-96`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/eye/shader_autoexposure_read_histogram.js#L48) & [`shader_autoexposure_adapt.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.js) | Single-thread (`@workgroup_size(1)`) shaders (zero GPU cost) where `total_pixels` and `weighted_log_sum` reach $\sim 2 \times 10^8$ at 1080p, overflowing `65504` by $3000\times$. | **Camera exposure locks to `NaN` (black screen)**. |
-| **NO-F16-16** | **Animation Curve Time, Dual-Quaternion Translation, Foliage State, & Particle VM**<br>[`chunk_animation_curve_evaluate.js:50-72`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/animation/chunk_animation_curve_evaluate.js#L50-L72), [`chunk_foliage_wind_step.js:48-122`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/animation/foliage/chunk_foliage_wind_step.js#L48-L122), [`chunk_particle_vm.js:28-30`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/particles/vm/chunk_particle_vm.js#L28-L30) | Keyframe `time` at `60 s` has `f16` ULP `0.03125 s` (~2 frames at 60 Hz); foliage `theta_new += vel_new * dt` underflows small `dt` steps; `chunk_particle_vm` requires bit-exact `f32` parity with `ParticleVMReference.js`. | **Visible animation/camera stepping, foliage branches sticking in wind, and broken particle VM tests**. |
-
----
-
-## 5. Detailed Technical Analysis of Top Proposed Items
-
-### 5.1 F16-01: Neural Super Sampling Int8 U-Net Convolution (`postprocess/nss/shader_nss_conv_layer.js`)
-
-- **Current Implementation ([`shader_nss_conv_layer.js:107-225`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/nss/shader_nss_conv_layer.js#L107-L225))**:
-  - Dispatched **18 times per frame** (`@workgroup_size(8, 8, 1)`), covering the U-Net encoder, bottleneck, decoder, and 6 KPN output heads.
-  - Each invocation computes 4 output channels (`out_group = gid.z`) at pixel `(gid.x, gid.y)` by looping over `ig = 0 .. in_groups - 1` (up to 16 groups = 64 channels) and `ky, kx = -1 .. 1` (3×3 spatial kernel).
-  - Inside the loop (`L147-175`), every thread issues **9× `in_groups` (up to 144) 3D `textureLoad`s** from `tInput` (`rgba16float`) and executes **4× `9 × in_groups` (up to 576) `vec4<f32>` dot products** against `unpack4x8snorm(weights[...])`, using **0 bytes of `var<workgroup>` shared memory**.
-- **Proposed `shader-f16` Change**:
-  1. Because `gid.z` (`out_group`) is uniform across the entire `8×8×1` workgroup, all 64 threads read the exact same `10×10` spatial patch (`8×8` interior + 1-pixel halo) of `tInput(..., ig, 0)` on each `ig` iteration!
-  2. Declare `var<workgroup> wg_input_tile: array<vec4<f16>, 100>;` (**800 bytes** of shared memory — only `4.9%` of the 16 KiB limit, preserving 100% occupancy).
-  3. At the start of each `ig` iteration, the 64 threads cooperatively load the 100 `rgba16float` texels into `wg_input_tile` (`1.5625` loads/thread instead of `9` loads/thread — a **5.76× reduction in 3D texture fetches** across all 18 dispatches!).
-  4. Unpack the `int8` weights into `vec4<f16>`:
-     ```wgsl
-     let v = wg_input_tile[(lid.y + u32(ky + 1)) * 10u + (lid.x + u32(kx + 1))];
-     let w0 = vec4<f16>(unpack4x8snorm(weights[w_idx]));
-     let w1 = vec4<f16>(unpack4x8snorm(weights[w_idx + 1u]));
-     let w2 = vec4<f16>(unpack4x8snorm(weights[w_idx + 2u]));
-     let w3 = vec4<f16>(unpack4x8snorm(weights[w_idx + 3u]));
-     acc += vec4<f32>(dot(v, w0), dot(v, w1), dot(v, w2), dot(v, w3));
-     ```
-- **Precision Analysis**:
-  - `tInput` is already `rgba16float` with activations in $[-1, 1]$ (LeakyReLU LUT outputs `int8` dequantized to $[-1, 1]$), and `unpack4x8snorm` produces exact multiples of $1/127$ in $[-1, 1]$, which have $> 3\text{ bits}$ of spare mantissa in `f16`.
-  - A 4-element dot product `dot(v, w)` in `f16` is bounded in $[-4, 4]$ (`ULP` $\le 2^{-8} \approx 0.0039$, smaller than 1 `int8` step $1/127 \approx 0.00787$).
-  - Keeping the outer sum `acc` (across up to 144 taps) and the post-loop `acc + biases` (`biases` are pre-scaled by $1/127^2 \approx 6.2 \times 10^{-5}$) in `vec4<f32>` prevents both accumulation drift and subnormal bias underflow.
-
----
-
-### 5.2 F16-02: Depth of Field Raymarch & Slice Compute (`postprocess/dof/raymarch/`)
-
-- **Current Implementation ([`shader_dof_raymarch_compute.js:30-97, 168-170`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.js#L30-L97) & [`shader_dof_slice_compute.js:36-114`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/dof/raymarch/shader_dof_slice_compute.js#L36-L114))**:
-  - Each `8×8` workgroup preloads an `88×88` (`REGION = 88`, `REGION_PIXELS = 7744`) neighbourhood of signed CoC values from `tPrefilter.a` (`rgba16float`).
-  - Because `7744 × 4 B = 30,976 B` would exceed the 16,384 B WebGPU workgroup memory limit, both shaders declare `var<workgroup> lds_coc: array<u32, 3872>;` (`15,488 B`) and manually pack pairs of horizontal pixels with `pack2x16float(vec2<f32>(c0, c1))`.
-  - Inside the innermost ray-march loop (executed up to $48 \times 48 = 2,304$ times per pixel in `shader_dof_raymarch_compute.js:168-170`, and up to $12 \times 2 \times 24 = 576$ times per pixel in `shader_dof_slice_compute.js:81-84`), every step executes:
-    ```wgsl
-    let pair = unpack2x16float(lds_coc[rc.y * ROW_U32 + (rc.x >> 1)]);
-    let s_coc = select(pair.x, pair.y, (rc.x & 1) != 0);
-    ```
-  - As documented in [`DOF_CONFIG.js:158-160`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/dof/DOF_CONFIG.js#L158-L160), this inner-loop address shift + unpack + mask + select overhead made `shader_dof_raymarch_compute` measure slower than the uncached fragment shader!
-- **Proposed `shader-f16` Change**:
-  - Enable `f16` (`addExtension(WebGPUExtensionType.ShaderF16)`) and declare:
-    ```wgsl
-    var<workgroup> lds_coc: array<f16, 7744>; // 7,744 × 2 B = 15,488 bytes (identical footprint!)
-    ```
-  - During preload (`s = 0 .. 7743` step `64`):
-    ```wgsl
-    lds_coc[s] = f16(textureLoad(tPrefilter, coord, 0).a);
-    ```
-  - Inside the inner march loop:
-    ```wgsl
-    let s_coc: f16 = lds_coc[rc.y * REGION + rc.x];
-    ```
-- **Precision Analysis**:
-  - **100% bit-identical** to the current shader (`tPrefilter.a` is already `rgba16float`, so `f16(textureLoad(...).a)` is an exact copy), while removing 4 ALU instructions per march step ($\sim 9,200$ ALU ops/pixel at cinematic quality).
-
----
-
-### 5.3 F16-04 & F16-10: Brick4 GI (`shader_brick4_indirect_lighting.js`) & Deferred/Forward PBR (`shader_deferred_main.js`, `chunk_forward_shade_standard_fragment.js`)
-
-- **Current Register Pressure Bottleneck**:
-  - In [`shader_brick4_indirect_lighting.js:109-189`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js#L109-L189), trilinear interpolation + normal-weighted probe blending + cone directional visibility keeps **four `SH3CoefficientsColor` arrays** (`probe0`, `probe1`, `sample_probe_diff`, `sample_probe_spec`, each `array<vec3<f32>, 9>` = 27 floats) live in registers simultaneously (**108 scalar 32-bit registers** just for SH coefficients!).
-  - In [`shader_deferred_main.js:84-128`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/deferred/shader_deferred_main.js#L84-L128) and [`chunk_forward_shade_standard_fragment.js:58-195`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.js#L58-L195), `MaterialShadingInfo` (18 floats) + `GeometricShadingInfo` (`position_ws`, `view_direction`, `shading_normal`, `geometric_normal`, 12 floats) stay live across shadow-map / ray-query calls and two 64-iteration (or 32-iteration) point and spot light loops.
-- **Proposed `shader-f16` Change**:
-  1. **SH3 Coefficients (`SH3CoefficientsColor`)**:
-     - In [`chunk_sh3_uncompress.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_sh3_uncompress.js), `brick4_sh3_color_decode` unpacks an `rgbe9995` DC (`max_val`, 100% exact in `f16`) and 8-bit Wiederien L1/L2 coefficients in $[-1, 1]$.
-     - Decoding into `array<vec3<f16>, 9>` and running `sh3_basis_at`, `sh3_color_mix2`, `sh3_color_estimate_for_cone`, `sh3_color_get_irradiance_at`, and `sh3_color_get_radiance_with_GGX` in `vec3h` cuts the SH register footprint in `shader_brick4_indirect_lighting.js` from **108 VGPRs to 54 VGPRs** and executes the 9-band multiply-accumulate chains at double rate.
-  2. **Surface Material & Bounded BRDF Terms (`MaterialShadingInfo`)**:
-     - Store `diffuse`, `specularF0`, `specularF0_dielectric`, `specularF0_metal`, `specularF90` (`vec3h` in $[0, 1]$), `emissive` (`vec3h`, decoded from `rgbe9995`), `occlusion`, `roughness`, `opacity` (`f16` in $[0, 1]$), and unit vectors `shading_normal`, `geometric_normal`, `view_direction` (`vec3h` in $[-1, 1]$).
-     - Evaluate `F_Schlick` (`chunk_F_Schlick.js`), `oren_nayar_fujii_diffuse_dir_albedo_approx`, `EON` (with `1e-4h` epsilon guards), and `calculate_bent_normal_shadowing` in `f16`/`vec3h`.
-     - Keep `position_ws`, `light_to_frag`, `D_GGX`, `V_GGX_SmithCorrelated`, and `get_bent_noh_squared` in `f32`.
-
----
-
-## 6. Mandatory WGSL Coding Rules for `shader-f16` in Shade
-
-To prevent `f16` precision bugs from entering the codebase, any chunk or shader using `enable f16;` must follow these five engineering rules:
-
-1. **Rule 1 — Never Use `EPSILON` (`1e-6`) in `f16` Denominators:**
-   - [`EPSILON_DECLARATION.js:5`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/chunk/math/EPSILON_DECLARATION.js#L5) defines `const EPSILON = 1e-6;`, which is **subnormal in `f16`** (min normal is $2^{-14} \approx 6.1035 \times 10^{-5}$) and flushes to `0.0h` when added to an $O(1)$ quantity (such as `4.0h * minRGB - 4.0h + 1e-6h` in `shader_ffx_rcas.js:87`).
-   - Add `EPSILON_F16_DECLARATION.js` (`const EPSILON_F16: f16 = 1e-4h;`, $\approx 1.64 \times 2^{-14}$) and use `max(denom, EPSILON_F16)` in all `f16` divisions.
-2. **Rule 2 — Clamp Unbounded `f32` Quantities Before Casting to `f16` or Storing to `rgba16float`:**
-   - In WGSL, `f16(x)` for any `x > 65504.0` produces `+Inf`, which turns into `NaN` as soon as it meets `* 0.0` (attenuation/weights) or `Inf / Inf` (Reinhard/Karis tonemap).
-   - Always clamp unbounded HDR radiance or variance via `min(x, 65504.0)` (`F16_MAX`) before casting to `f16` or calling `textureStore` on an `rgba16float` target.
-3. **Rule 3 — Never Subtract Nearly-Equal Quantities Near `1.0` or Compute Second-Moment Variance in `f16`:**
-   - Expressions of the form `1.0 - cos_theta` (for small angles $\theta < 5^\circ$), `1.0 - NoH_squared * (1.0 - a2)` (GGX NDF), `1.0 - luma` (`taa_tonemap_inv`), and `m2 - m1 * m1` (variance in LPV, GTAO, SSR, TAA, Volumetrics) lose all significant bits in a 10-bit mantissa and **must stay `f32`**.
-4. **Rule 4 — Never Compute Squared Distances `dot(v, v)` in `f16` When `|v|` Can Exceed `255.9`:**
-   - Because $\sqrt{65504} \approx 255.937$, `dot(v, v)` or `length(v)` on a `vec2h`/`vec3h` overflows to `+Inf` whenever `|v| >= 256` (e.g., world distances $> 256\text{ m}$ in light culling, pixel velocities $> 256\text{ px}$ in motion blur, or HDR luma $> 256$ in variance).
-5. **Rule 5 — Vectorize into `vec2h` / `vec4h` and Keep `f32 ↔ f16` Casts Outside Inner Loops:**
-   - Place `vec3h(...)` / `vec4h(...)` conversions at texture/buffer load boundaries or before a loop, and convert back to `vec3f` / `vec4f` only at the accumulator or output boundary.
-
----
-
-## 7. Recommended Phased Rollout Plan
-
-| Stage | Scope | Items Included | Verification Gate |
-|---|---|---|---|
-| **Stage 0: P0 Infrastructure & `rgba16float` Bug Fixes** | Fix `enable f16;` codegen, device feature negotiation, CPU emulator `f16` scalar/vector rounding, validator rule, buffer serde, and the 5 live `rgba16float` `+Inf → NaN` bugs | ✅ `INFRA-1`, ✅ `INFRA-3`, ✅ `INFRA-4`, ✅ `INFRA-5`, ✅ `INFRA-6` (landed in `a7e88413f`..`b637acaef`);<br>✅ `BUG-1`..`BUG-5` (landed in `eecb70112`..`a86cf8617`);<br>⏳ `INFRA-2` | ✅ Unit & regression specs landed for `ShaderDescriptor` (`enable f16;` & auto-extension propagation), `WGSLJavaScriptCompiler` / `WGSLLanguageCore` ([`f16_emulation.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/emulator/f16_emulation.spec.js), [`abstract_float_range.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/emulator/abstract_float_range.spec.js)), `validate_wgsl_source` (`unenabled-f16` in [`validate_wgsl_source.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/wgsl/validate_wgsl_source.spec.js)), `f16`/`vecNh`/`matCxRh` buffer serde ([`read_gpu_typed_buffer.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.spec.js)), and `BUG-1`..`BUG-5` ([`shader_volumetrics_taa.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.spec.js), [`shader_volumetrics_build_lighting_local_shadow.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting_local_shadow.spec.js), [`shader_nss_preprocess.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/nss/shader_nss_preprocess.spec.js), [`chunk_karis_blur4x4_sample.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/bloom/chunk_karis_blur4x4_sample.spec.js), [`downsample_karis.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/downsample_karis.spec.js), [`ssr_metadata.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/ssr/ssr_metadata.spec.js), [`chunk_taa_tonemap_inv.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/taa/chunk_taa_tonemap_inv.spec.js), [`shader_taa.spec.js`](file:///h:/git/CompanyNamed/meep/packages/meep-engine/src/shade/renderer/postprocess/taa/shader_taa.spec.js)).<br>⏳ Remaining: `INFRA-2` device floor. |
-| **Stage 1: Tier-1 Shared Memory (`var<workgroup>`) & Compute Wins** | Zero-visual-risk compute passes where `f16` eliminates `unpack2x16float` loops, halves 16 KiB LDS pressure, or caches `rgba16float` tiles | `F16-01` (NSS conv), `F16-02` (DoF raymarch/slice compute), `F16-03` (Fluid MAC curl/gradient), `F16-05` (SSR prefilter), `F16-06` (Hi-Z SPD), `F16-07` (Env/Sky SH reductions), `F16-08` (LPV border & SHARC), `F16-09` (Luma denoiser) | Paired A/B GPU timestamp measurements on RTX 4090 and AMD RDNA2 iGPU + emulator bit-exact / 1-ULP equivalence tests. |
-| **Stage 2: Tier-1/2 High-VGPR Shading & Post-Process Loops** | Reduce VGPR footprint and enable 2× SIMD ALU in register-heavy fragment and compute shaders | `F16-04` (Brick4 SH3 `vec3h`), `F16-10` (Deferred & Forward `MaterialShadingInfo` + `F_Schlick`/diffuse), `F16-11` (Volumetrics lighting), `F16-12` (Water column FFT), `F16-13` (GTAO), `F16-14` (TAA), `F16-15` (Volumetric TAA), `F16-16` (RCAS), `F16-17` (SSR denoise/combine), `F16-18` (ReSTIR denoise) | `white_furnace.spec.js`, `chunk_wgsl_validity.spec.js`, RDNA/NVIDIA register & occupancy dump inspection, and per-pass timestamp A/B. |
-| **Stage 3: Tier-2 Bandwidth, Varyings, & Secondary Passes** | Varying interpolant packing, compute tile-max reductions, and staged ray packing | `F16-19` (`FORWARD_VERTEX_SHADER_STRUCT`), `F16-20` (DoF & Motion Blur compute tile-max), `F16-21` (Cluster culling), `F16-22`..`F16-27` | Visual & numerical diff across playgrounds (`avboit`, `water_surface`, `volumetrics_froxel`, `vsm`, `caldera`). |