@photivra/engine 2.12.0 → 2.14.0

package/dist/gpu/wgsl-display-view-quality-kernel.js

@@ -20,7 +20,8 @@
  *    the footprint, the demosaic candidates (one bilinear, or AHD's two directional linear candidates, each with its full
  *    camera-channel covariance), white balance and the highlight clip, the colour matrix, the tone curve and the clip to
  *    [0, 1] with the skewness term, the candidates' average, the Stein covariance with the closed-form B_c, the independent
- *    residual, AHD's choice variance ¼·Var(H − V), and the low-signal correction interpolated trilinearly between the grid
+ *    residual, AHD's choice variance ¼·Var(H − V), the flag for AHD's choice on the noise-free mosaic, which the reference takes and
+ *    the kernel does not (#457), and the low-signal correction interpolated trilinearly between the grid
  *    states of a table the host uploaded (the states themselves are computed on the host, #447; the kernel records every
  *    grid key it needs in a bitmap and flags a display pixel whose state the table lacks).
  *
@@ -63,7 +64,7 @@ export const DISPLAY_VIEW_QUALITY_CANDIDATE_ENTRIES = 49;
 export const DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS = 8;
 const CANDIDATE_PHASE_STRIDE = 4 + DISPLAY_VIEW_QUALITY_CANDIDATE_ENTRIES * DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS;
 /** Layout of the aux table (float32 words). */
-export const DISPLAY_VIEW_QUALITY_AUX = Object.freeze({
+export const DISPLAY_VIEW_QUALITY_AUX = /* @__PURE__ */ Object.freeze({
     /** Per phase p, channel c, tap t: dx, dy, weight, 0 (the bilinear kernels, 4 taps; unused taps have weight 0). */
     bilinear: 0,
     /** Per phase p, channel c: 1 / Σ_t w_t² of the bilinear kernel (host float64). */
@@ -76,7 +77,7 @@ export const DISPLAY_VIEW_QUALITY_AUX = Object.freeze({
     size: 240 + 4 * CANDIDATE_PHASE_STRIDE
 });
 /** Pixel flag bits of the output flag word. */
-export const DISPLAY_VIEW_QUALITY_FLAG = Object.freeze({
+export const DISPLAY_VIEW_QUALITY_FLAG = /* @__PURE__ */ Object.freeze({
     /** A site the pixel read had an uncertain lattice material (recompute on the host). */
     materialUncertain: 1,
     /** A site the pixel read lies outside the band's site window (a host geometry error; recompute). */
@@ -87,9 +88,21 @@ export const DISPLAY_VIEW_QUALITY_FLAG = Object.freeze({
     thresholdTie: 8,
     /** Informational: the pixel's expected value includes the low-signal correction. */
     corrected: 16,
+    /**
+     * #457: the reference takes AHD's choice on the noise-free mosaic (one candidate, or their average on a tie), which the kernel
+     * does not compute; it renders the average. The pixel is flagged (recompute) when Σ_j a_j·½|h(H) − h(V)| of some component
+     * exceeds `DISPLAY_VIEW_QUALITY_CHOICE_SIGMA` times the pixel's noise standard deviation.
+     */
+    ahdChoice: 32,
     /** The bits that require the host's recomputation. */
-    recompute: 15
+    recompute: 47
 });
+/**
+ * #457: the largest move, in units of the display pixel's own noise σ, that AHD's choice between its candidates may make to a pixel
+ * the kernel keeps (it renders the candidates' average and its bound carries the move); a larger one is recomputed on the host. A
+ * design tolerance, not a measurement: 2^-10 σ is a tenth of the 0.01 σ to which the float32 tests hold the GPU to the reference.
+ */
+export const DISPLAY_VIEW_QUALITY_CHOICE_SIGMA = 2 ** -10;
 /** Words of the grid-key bitmap: one bit per grid key (AHD_KEY_LEVELS³ keys). */
 export const DISPLAY_VIEW_QUALITY_BITMAP_WORDS = Math.ceil(AHD_KEY_LEVELS ** 3 / 32);
 /**
@@ -125,20 +138,20 @@ const SITE: u32 = ${DISPLAY_VIEW_QUALITY_SITE_FLOATS}u;
 const GROUP: u32 = ${DISPLAY_VIEW_QUALITY_GROUP_WORDS}u;
 const TAP: u32 = ${DISPLAY_VIEW_QUALITY_TAP_WORDS}u;
 struct Params {
-  count: u32, row0: u32, region_w: u32, region_x: u32,
-  region_y: u32, margin: u32, native_w: u32, native_h: u32,
-  columns: u32, tone: u32, reach: u32, candidates: u32,
-  site_x0: i32, site_y0: i32, site_w: u32, site_h: u32,
-  correction: u32, state_count: u32, taps: u32, groups: u32,
-  lattice_total: u32, gain_at_clip0: u32, gain_at_clip1: u32, gain_at_clip2: u32,
-  k0: f32, k1: f32, k2: f32, reach2: f32,
-  dark0: f32, dark1: f32, dark2: f32, clip_level: f32,
-  c0_0: f32, c0_1: f32, c0_2: f32, threshold: f32,
-  g0: f32, g1: f32, g2: f32, scale_u: f32,
-  m00: f32, m01: f32, m02: f32, m10: f32,
-  m11: f32, m12: f32, m20: f32, m21: f32,
-  m22: f32, scale_v: f32, site_gamma: f32, site_first: u32,
-  site_tiny: f32, pad_f: f32, pad_g: f32, pad_h: f32,
+count: u32, row0: u32, region_w: u32, region_x: u32,
+region_y: u32, margin: u32, native_w: u32, native_h: u32,
+columns: u32, tone: u32, reach: u32, candidates: u32,
+site_x0: i32, site_y0: i32, site_w: u32, site_h: u32,
+correction: u32, state_count: u32, taps: u32, groups: u32,
+lattice_total: u32, gain_at_clip0: u32, gain_at_clip1: u32, gain_at_clip2: u32,
+k0: f32, k1: f32, k2: f32, reach2: f32,
+dark0: f32, dark1: f32, dark2: f32, clip_level: f32,
+c0_0: f32, c0_1: f32, c0_2: f32, threshold: f32,
+g0: f32, g1: f32, g2: f32, scale_u: f32,
+m00: f32, m01: f32, m02: f32, m10: f32,
+m11: f32, m12: f32, m20: f32, m21: f32,
+m22: f32, scale_v: f32, site_gamma: f32, site_first: u32,
+site_tiny: f32, pad_f: f32, pad_g: f32, pad_h: f32,
 };
 @group(0) @binding(0) var<uniform> params: Params;
 
@@ -146,161 +159,161 @@ fn k_of(c: u32) -> f32 { if (c == 0u) { return params.k0; } if (c == 1u) { retur
 fn dark_of(c: u32) -> f32 { if (c == 0u) { return params.dark0; } if (c == 1u) { return params.dark1; } return params.dark2; }
 fn c0_of(c: u32) -> f32 { if (c == 0u) { return params.c0_0; } if (c == 1u) { return params.c0_1; } return params.c0_2; }
 fn g_of(c: u32) -> f32 { if (c == 0u) { return params.g0; } if (c == 1u) { return params.g1; } return params.g2; }
-// Whether the channel's white-balance gain is the clip level itself (the smallest gain), exactly, in the reference's float64.
+
 fn gain_at_clip(c: u32) -> bool { if (c == 0u) { return params.gain_at_clip0 == 1u; } if (c == 1u) { return params.gain_at_clip1 == 1u; } return params.gain_at_clip2 == 1u; }
 fn m_of(r: u32, c: u32) -> f32 {
-  let i = r * 3u + c;
-  switch (i) {
-    case 0u: { return params.m00; } case 1u: { return params.m01; } case 2u: { return params.m02; }
-    case 3u: { return params.m10; } case 4u: { return params.m11; } case 5u: { return params.m12; }
-    case 6u: { return params.m20; } case 7u: { return params.m21; } default: { return params.m22; }
-  }
+let i = r * 3u + c;
+switch (i) {
+case 0u: { return params.m00; } case 1u: { return params.m01; } case 2u: { return params.m02; }
+case 3u: { return params.m10; } case 4u: { return params.m11; } case 5u: { return params.m12; }
+case 6u: { return params.m20; } case 7u: { return params.m21; } default: { return params.m22; }
+}
 }
 fn channel_of(x: i32, y: i32) -> u32 {
-  if ((y & 1) == 0) { return select(1u, 0u, (x & 1) == 0); }
-  return select(2u, 1u, (x & 1) == 0);
+if ((y & 1) == 0) { return select(1u, 0u, (x & 1) == 0); }
+return select(2u, 1u, (x & 1) == 0);
 }
-// A value with its absolute error bound (x: value, y: bound). First-order rules; the host doubles the final bound.
+
 fn b_add(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> { let v = a.x + b.x; return vec2<f32>(v, a.y + b.y + E * abs(v)); }
 fn b_sub(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> { let v = a.x - b.x; return vec2<f32>(v, a.y + b.y + E * abs(v)); }
 fn b_mul(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> { let v = a.x * b.x; return vec2<f32>(v, abs(a.x) * b.y + abs(b.x) * a.y + E * abs(v)); }
-// Times an exact constant (a kernel weight, an integer, a power of two).
+
 fn b_scale(a: vec2<f32>, k: f32) -> vec2<f32> { let v = a.x * k; return vec2<f32>(v, a.y * abs(k) + E * abs(v)); }
-// A host constant rounded once to float32 (a gain, a matrix entry).
+
 fn b_rounded(k: f32) -> vec2<f32> { return vec2<f32>(k, E * abs(k)); }
 fn b_div(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> { let v = a.x / b.x; return vec2<f32>(v, (a.y + abs(v) * b.y) / abs(b.x) + 2.5 * E * abs(v)); }
-// |sqrt(v + d) - sqrt(v)| <= min(d / (2 sqrt v), sqrt d), plus the 4.5 ULP of the built-in.
+
 fn b_sqrt(a: vec2<f32>) -> vec2<f32> {
-  let s = sqrt(max(a.x, 0.0));
-  if (s > 0.0) { return vec2<f32>(s, min(a.y / (2.0 * s), sqrt(a.y)) + 4.5 * E * s); }
-  return vec2<f32>(0.0, sqrt(a.y));
+let s = sqrt(max(a.x, 0.0));
+if (s > 0.0) { return vec2<f32>(s, min(a.y / (2.0 * s), sqrt(a.y)) + 4.5 * E * s); }
+return vec2<f32>(0.0, sqrt(a.y));
 }
-// Standard normal density, as the reference forms it, and Abramowitz & Stegun 26.2.17 as (Φ, 1 − Φ).
+
 fn phi(z: f32) -> f32 { return 0.3989422804014327 * exp(-0.5 * z * z); }
 fn pq(z: f32) -> vec2<f32> {
-  let x = abs(z);
-  let t = 1.0 / (1.0 + 0.2316419 * x);
-  let q = phi(x) * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
-  if (z >= 0.0) { return vec2<f32>(1.0 - q, q); }
-  return vec2<f32>(q, 1.0 - q);
+let x = abs(z);
+let t = 1.0 / (1.0 + 0.2316419 * x);
+let q = phi(x) * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
+if (z >= 0.0) { return vec2<f32>(1.0 - q, q); }
+return vec2<f32>(q, 1.0 - q);
 }
 struct Moments { mean: vec2<f32>, variance: vec2<f32>, slope: vec2<f32> }
-// Moments of min(Y, top) for Y ~ N(m, v) with their bounds: Var = v·(Φ − zφ + z²Q − δ²), δ = φ − zQ (the Speed forms).
+
 fn upper_clip(m: vec2<f32>, v: vec2<f32>, top: f32) -> Moments {
-  var out: Moments;
-  if (!(v.x > 0.0)) {
-    // No noise on either side (a zero bound): the reference's slope is 1 or 0 by m < top, decided when m's interval lies on one side.
-    let decided = v.y == 0.0 && (m.x - m.y >= top || m.x + m.y < top);
-    out.mean = vec2<f32>(min(m.x, top), m.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(select(0.0, 1.0, m.x < top), select(1.0, 0.0, decided));
-    return out;
-  }
-  let s = b_sqrt(v);
-  let z = (top - m.x) / s.x;
-  if (z > CLIP_REACH) { out.mean = m; out.variance = v; out.slope = vec2<f32>(1.0, 0.0); return out; }
-  if (z < -CLIP_REACH) { out.mean = vec2<f32>(top, 0.0); out.variance = vec2<f32>(0.0, 0.0); out.slope = vec2<f32>(0.0, 0.0); return out; }
-  let p = pq(z);
-  let d = phi(z);
-  let delta = d - z * p.y;
-  let ratio = p.x - z * d + z * z * p.y - delta * delta;
-  // First-order propagation of the inputs' bounds: with g = min(Z, z), E[g] = −δ and ρ = Var(g) = ratio, ∂E/∂m = Φ, ∂E/∂s = φ,
-  // ∂Var/∂m = −s·ρ_z, ∂Var/∂s = s·(2ρ − z·ρ_z) with ρ_z = 2Q·(z + δ), ∂Φ/∂m = −φ/s and ∂Φ/∂s = −zφ/s.
-  let rho_z = 2.0 * p.y * (z + delta);
-  out.mean = vec2<f32>(m.x - s.x * delta, p.x * m.y + d * s.y + CLIP_MEAN_U * E * s.x);
-  out.variance = vec2<f32>(v.x * max(0.0, ratio), s.x * abs(rho_z) * m.y + s.x * abs(2.0 * ratio - z * rho_z) * s.y + CLIP_VARIANCE_U * E * v.x);
-  out.slope = vec2<f32>(p.x, min(1.0, (d * m.y + abs(z) * d * s.y) / s.x + CLIP_SLOPE_U * E));
-  return out;
-}
-// Moments of clip(Y, 0, 1) for Y with mean m, variance v and standardized skewness γ (|γ| ≤ 1), with their bounds (the
-// Speed forms: W = m + s·g(Z), E[g] = aΦa + φa − φb + bQb, E[g²] = a²Φa + (Φb − Φa) − (bφb − aφa) + b²Qb, the Edgeworth
-// shift (s·γ/6)·(aφa − bφb) on the mean and −shift·(2·E[Y] + shift) on the variance).
+var out: Moments;
+if (!(v.x > 0.0)) {
+
+let decided = v.y == 0.0 && (m.x - m.y >= top || m.x + m.y < top);
+out.mean = vec2<f32>(min(m.x, top), m.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(select(0.0, 1.0, m.x < top), select(1.0, 0.0, decided));
+return out;
+}
+let s = b_sqrt(v);
+let z = (top - m.x) / s.x;
+if (z > CLIP_REACH) { out.mean = m; out.variance = v; out.slope = vec2<f32>(1.0, 0.0); return out; }
+if (z < -CLIP_REACH) { out.mean = vec2<f32>(top, 0.0); out.variance = vec2<f32>(0.0, 0.0); out.slope = vec2<f32>(0.0, 0.0); return out; }
+let p = pq(z);
+let d = phi(z);
+let delta = d - z * p.y;
+let ratio = p.x - z * d + z * z * p.y - delta * delta;
+
+
+let rho_z = 2.0 * p.y * (z + delta);
+out.mean = vec2<f32>(m.x - s.x * delta, p.x * m.y + d * s.y + CLIP_MEAN_U * E * s.x);
+out.variance = vec2<f32>(v.x * max(0.0, ratio), s.x * abs(rho_z) * m.y + s.x * abs(2.0 * ratio - z * rho_z) * s.y + CLIP_VARIANCE_U * E * v.x);
+out.slope = vec2<f32>(p.x, min(1.0, (d * m.y + abs(z) * d * s.y) / s.x + CLIP_SLOPE_U * E));
+return out;
+}
+
+
+
 fn unit_clip(m: vec2<f32>, v: vec2<f32>, skew: vec2<f32>) -> Moments {
-  var out: Moments;
-  if (!(v.x > 0.0)) {
-    let decided = v.y == 0.0 && ((m.x - m.y > 0.0 && m.x + m.y < 1.0) || m.x + m.y <= 0.0 || m.x - m.y >= 1.0);
-    out.mean = vec2<f32>(clamp(m.x, 0.0, 1.0), m.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(select(0.0, 1.0, m.x > 0.0 && m.x < 1.0), select(1.0, 0.0, decided));
-    return out;
-  }
-  let s = b_sqrt(v);
-  let a = -m.x / s.x;
-  let b = (1.0 - m.x) / s.x;
-  if (a < -CLIP_REACH && b > CLIP_REACH) { out.mean = m; out.variance = v; out.slope = vec2<f32>(1.0, 0.0); return out; }
-  var pa = 0.0; var da = 0.0;
-  if (!(a < -CLIP_REACH)) { pa = pq(a).x; da = phi(a); }
-  var pb = 1.0; var qb = 0.0; var db = 0.0;
-  if (!(b > CLIP_REACH)) { let p = pq(b); pb = p.x; qb = p.y; db = phi(b); }
-  let inside = pb - pa;
-  let gamma = clamp(skew.x, -1.0, 1.0);
-  let aa = a * da;
-  let bb = b * db;
-  let eg = a * pa + (da - db) + b * qb;
-  let eg2 = a * a * pa + inside - (bb - aa) + b * b * qb;
-  let normal_mean = m.x + s.x * eg;
-  var mean = normal_mean;
-  var shift = 0.0;
-  if (gamma != 0.0) { shift = s.x * gamma / 6.0 * (aa - bb); mean = normal_mean + shift; }
-  // |aφa − bφb| ≤ 0.48, so |shift| ≤ 0.08·s·|γ| and a wrong γ moves it by at most 0.16·s.
-  let d_shift = 0.1 * s.x * min(2.0, skew.y) + 0.1 * abs(gamma) * s.y + E * abs(shift);
-  // First-order propagation of the inputs' bounds: with ρ = E[g²] − E[g]², ∂E[g]/∂a = Φa, ∂E[g]/∂b = Qb, ∂E[g²]/∂a = 2aΦa,
-  // ∂E[g²]/∂b = 2bQb, so ρ_a = 2Φa(a − E[g]), ρ_b = 2Qb(b − E[g]); ∂E/∂m = inside, ∂E/∂s = φa − φb, ∂Var/∂m = −s(ρ_a + ρ_b),
-  // ∂Var/∂s = s(2ρ − aρ_a − bρ_b); the slope's derivatives are (φa − φb)/s and (aφa − bφb)/s.
-  let rho = eg2 - eg * eg;
-  let rho_a = 2.0 * pa * (a - eg);
-  let rho_b = 2.0 * qb * (b - eg);
-  let d_mean = m.y * inside + abs(da - db) * s.y + 2.0 * CLIP_MEAN_U * E * s.x + d_shift;
-  // The normal part X = v·ρ and its bound; the reference's variance is max(0, X − shift·(2·E[Y] + shift)), so it lies in
-  // [0, X_cpu] when the shift term is non-negative on both sides (shift > Δshift), which caps the bound by max(Var, X + ΔX).
-  let normal_variance = v.x * rho;
-  let d_normal = s.x * abs(rho_a + rho_b) * m.y + s.x * abs(2.0 * rho - a * rho_a - b * rho_b) * s.y + 2.0 * CLIP_VARIANCE_U * E * v.x;
-  let variance = max(0.0, normal_variance - shift * (2.0 * normal_mean + shift));
-  var d_var = d_normal + 2.0 * (d_shift * (abs(normal_mean) + abs(shift)) + abs(shift) * d_mean);
-  if (shift > d_shift) { d_var = min(d_var, max(variance, max(0.0, normal_variance) + d_normal)); }
-  out.mean = vec2<f32>(mean, d_mean);
-  out.variance = vec2<f32>(variance, d_var);
-  out.slope = vec2<f32>(inside, min(1.0, (abs(da - db) * m.y + abs(aa - bb) * s.y) / s.x + 2.0 * CLIP_SLOPE_U * E));
-  return out;
+var out: Moments;
+if (!(v.x > 0.0)) {
+let decided = v.y == 0.0 && ((m.x - m.y > 0.0 && m.x + m.y < 1.0) || m.x + m.y <= 0.0 || m.x - m.y >= 1.0);
+out.mean = vec2<f32>(clamp(m.x, 0.0, 1.0), m.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(select(0.0, 1.0, m.x > 0.0 && m.x < 1.0), select(1.0, 0.0, decided));
+return out;
+}
+let s = b_sqrt(v);
+let a = -m.x / s.x;
+let b = (1.0 - m.x) / s.x;
+if (a < -CLIP_REACH && b > CLIP_REACH) { out.mean = m; out.variance = v; out.slope = vec2<f32>(1.0, 0.0); return out; }
+var pa = 0.0; var da = 0.0;
+if (!(a < -CLIP_REACH)) { pa = pq(a).x; da = phi(a); }
+var pb = 1.0; var qb = 0.0; var db = 0.0;
+if (!(b > CLIP_REACH)) { let p = pq(b); pb = p.x; qb = p.y; db = phi(b); }
+let inside = pb - pa;
+let gamma = clamp(skew.x, -1.0, 1.0);
+let aa = a * da;
+let bb = b * db;
+let eg = a * pa + (da - db) + b * qb;
+let eg2 = a * a * pa + inside - (bb - aa) + b * b * qb;
+let normal_mean = m.x + s.x * eg;
+var mean = normal_mean;
+var shift = 0.0;
+if (gamma != 0.0) { shift = s.x * gamma / 6.0 * (aa - bb); mean = normal_mean + shift; }
+
+let d_shift = 0.1 * s.x * min(2.0, skew.y) + 0.1 * abs(gamma) * s.y + E * abs(shift);
+
+
+
+let rho = eg2 - eg * eg;
+let rho_a = 2.0 * pa * (a - eg);
+let rho_b = 2.0 * qb * (b - eg);
+let d_mean = m.y * inside + abs(da - db) * s.y + 2.0 * CLIP_MEAN_U * E * s.x + d_shift;
+
+
+let normal_variance = v.x * rho;
+let d_normal = s.x * abs(rho_a + rho_b) * m.y + s.x * abs(2.0 * rho - a * rho_a - b * rho_b) * s.y + 2.0 * CLIP_VARIANCE_U * E * v.x;
+let variance = max(0.0, normal_variance - shift * (2.0 * normal_mean + shift));
+var d_var = d_normal + 2.0 * (d_shift * (abs(normal_mean) + abs(shift)) + abs(shift) * d_mean);
+if (shift > d_shift) { d_var = min(d_var, max(variance, max(0.0, normal_variance) + d_normal)); }
+out.mean = vec2<f32>(mean, d_mean);
+out.variance = vec2<f32>(variance, d_var);
+out.slope = vec2<f32>(inside, min(1.0, (abs(da - db) * m.y + abs(aa - bb) * s.y) / s.x + 2.0 * CLIP_SLOPE_U * E));
+return out;
 }
 `;
 /** The Gauss–Legendre Reinhard moments read the aux table, so they live in the pixel kernel. */
 const REINHARD_WGSL = /* wgsl */ `
-// Positive Reinhard per channel then the clip to [0, 1]: h(x) = x/(1 + x) for x > 0, else 0, by the reference's composite
-// 16-point Gauss–Legendre rule in standardized units (the Speed forms), with the bounds of the quadrature (REINHARD_*_U)
-// and of its inputs (|h′| ≤ 1, |h″| ≤ 2).
+
+
+
 fn reinhard_moments(m: vec2<f32>, v: vec2<f32>) -> Moments {
-  var out: Moments;
-  if (!(v.x > 0.0)) {
-    if (m.x > 0.0) {
-      let h = m.x / (1.0 + m.x);
-      out.mean = vec2<f32>(h, m.y + 4.0 * E * h); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(1.0 / ((1.0 + m.x) * (1.0 + m.x)), min(1.0, 2.0 * m.y + 6.0 * E));
-      return out;
-    }
-    out.mean = vec2<f32>(0.0, m.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(0.0, 1.0);
-    return out;
-  }
-  let s = b_sqrt(v);
-  let zlo = max(-m.x / s.x, -CLIP_REACH);
-  if (!(CLIP_REACH > zlo)) { out.mean = vec2<f32>(0.0, m.y + s.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(0.0, 1.0); return out; }
-  let hm = select(0.0, m.x / (1.0 + m.x), m.x > 0.0);
-  var e1 = 0.0; var e2 = 0.0; var ed = 0.0;
-  let zwidth = (CLIP_REACH - zlo) / 4.0;
-  for (var p = 0u; p < 4u; p = p + 1u) {
-    let zc = zlo + (f32(p) + 0.5) * zwidth;
-    let zhalf = zwidth / 2.0;
-    for (var k = 0u; k < 16u; k = k + 1u) {
+var out: Moments;
+if (!(v.x > 0.0)) {
+if (m.x > 0.0) {
+let h = m.x / (1.0 + m.x);
+out.mean = vec2<f32>(h, m.y + 4.0 * E * h); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(1.0 / ((1.0 + m.x) * (1.0 + m.x)), min(1.0, 2.0 * m.y + 6.0 * E));
+return out;
+}
+out.mean = vec2<f32>(0.0, m.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(0.0, 1.0);
+return out;
+}
+let s = b_sqrt(v);
+let zlo = max(-m.x / s.x, -CLIP_REACH);
+if (!(CLIP_REACH > zlo)) { out.mean = vec2<f32>(0.0, m.y + s.y); out.variance = vec2<f32>(0.0, v.y); out.slope = vec2<f32>(0.0, 1.0); return out; }
+let hm = select(0.0, m.x / (1.0 + m.x), m.x > 0.0);
+var e1 = 0.0; var e2 = 0.0; var ed = 0.0;
+let zwidth = (CLIP_REACH - zlo) / 4.0;
+for (var p = 0u; p < 4u; p = p + 1u) {
+let zc = zlo + (f32(p) + 0.5) * zwidth;
+let zhalf = zwidth / 2.0;
+for (var k = 0u; k < 16u; k = k + 1u) {
       let z = zc + zhalf * aux[${DISPLAY_VIEW_QUALITY_AUX.gaussLegendre}u + k];
-      let x = m.x + s.x * z;
+let x = m.x + s.x * z;
       let weight = zhalf * aux[${DISPLAY_VIEW_QUALITY_AUX.gaussLegendre + 16}u + k] * phi(z);
-      let h = x / (1.0 + x);
-      e1 = e1 + weight * h;
-      e2 = e2 + weight * (h - hm) * (h - hm);
-      ed = ed + weight / ((1.0 + x) * (1.0 + x));
-    }
-  }
-  let shifted = e1 - hm;
-  let variance = max(0.0, e2 - shifted * shifted);
-  out.mean = vec2<f32>(e1, m.y + s.y + REINHARD_MEAN_U * E * abs(e1));
-  out.variance = vec2<f32>(variance, 2.0 * s.x * m.y + 2.0 * v.y + REINHARD_VARIANCE_U * E * variance);
-  out.slope = vec2<f32>(ed, min(1.0, 2.0 * m.y + 2.0 * s.y + REINHARD_SLOPE_U * E));
-  return out;
+let h = x / (1.0 + x);
+e1 = e1 + weight * h;
+e2 = e2 + weight * (h - hm) * (h - hm);
+ed = ed + weight / ((1.0 + x) * (1.0 + x));
+}
+}
+let shifted = e1 - hm;
+let variance = max(0.0, e2 - shifted * shifted);
+out.mean = vec2<f32>(e1, m.y + s.y + REINHARD_MEAN_U * E * abs(e1));
+out.variance = vec2<f32>(variance, 2.0 * s.x * m.y + 2.0 * v.y + REINHARD_VARIANCE_U * E * variance);
+out.slope = vec2<f32>(ed, min(1.0, 2.0 * m.y + 2.0 * s.y + REINHARD_SLOPE_U * E));
+return out;
 }
 `;
 /**
@@ -315,21 +328,21 @@ export const DISPLAY_VIEW_QUALITY_LATTICE_WGSL = /* wgsl */ `${COMMON_WGSL}
 @compute @workgroup_size(${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) wg: vec3<u32>) {
   let i = gid.x + gid.y * wg.x * ${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE}u;
-  if (i >= params.lattice_total) { return; }
-  var g = 0u;
-  for (var k = 1u; k < params.groups; k = k + 1u) { if (i >= groups[k * GROUP + 4u]) { g = k; } }
-  let base = g * GROUP;
-  let lx0 = bitcast<i32>(groups[base]);
-  let ly0 = bitcast<i32>(groups[base + 1u]);
-  let lw = groups[base + 2u];
-  let local = i - groups[base + 4u];
-  let q = ly0 + i32(local / lw);
-  let p = lx0 + i32(local % lw);
-  let u = (f32(p) + bitcast<f32>(groups[base + 6u])) * params.scale_u;
-  let v = (f32(q) + bitcast<f32>(groups[base + 7u])) * params.scale_v;
-  material_uncertain = false;
-  let m = material_at(vec2<f32>(u, v));
-  lattice_out[i] = m | select(0u, 0x80000000u, material_uncertain);
+if (i >= params.lattice_total) { return; }
+var g = 0u;
+for (var k = 1u; k < params.groups; k = k + 1u) { if (i >= groups[k * GROUP + 4u]) { g = k; } }
+let base = g * GROUP;
+let lx0 = bitcast<i32>(groups[base]);
+let ly0 = bitcast<i32>(groups[base + 1u]);
+let lw = groups[base + 2u];
+let local = i - groups[base + 4u];
+let q = ly0 + i32(local / lw);
+let p = lx0 + i32(local % lw);
+let u = (f32(p) + bitcast<f32>(groups[base + 6u])) * params.scale_u;
+let v = (f32(q) + bitcast<f32>(groups[base + 7u])) * params.scale_v;
+material_uncertain = false;
+let m = material_at(vec2<f32>(u, v));
+lattice_out[i] = m | select(0u, 0x80000000u, material_uncertain);
 }
 `;
 /**
@@ -338,21 +351,21 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups)
  */
 const SITE_TAIL_WGSL = /* wgsl */ `
 fn write_site(i: u32, c: u32, e: f32, de: f32, flag: u32) {
-  let kc = k_of(c);
-  let mean = kc * e;
-  let variance = kc * kc * e + c0_of(c);
-  let third = kc * kc * kc * e;
-  var m = vec2<f32>(mean, kc * de + 2.0 * E * mean);
-  var v = vec2<f32>(variance, kc * kc * de + 4.0 * E * variance);
-  let gap = 1.0 - mean;
-  if (!(gap > 0.0 && gap * gap > params.reach2 * variance)) {
-    let clipped = upper_clip(m, v, 1.0);
-    m = clipped.mean; v = clipped.variance;
-  }
-  let o = i * SITE;
-  sites[o] = m.x; sites[o + 1u] = v.x; sites[o + 2u] = third;
-  sites[o + 3u] = m.y; sites[o + 4u] = v.y; sites[o + 5u] = kc * kc * kc * de + 5.0 * E * third;
-  sites[o + 6u] = bitcast<f32>(flag); sites[o + 7u] = e;
+let kc = k_of(c);
+let mean = kc * e;
+let variance = kc * kc * e + c0_of(c);
+let third = kc * kc * kc * e;
+var m = vec2<f32>(mean, kc * de + 2.0 * E * mean);
+var v = vec2<f32>(variance, kc * kc * de + 4.0 * E * variance);
+let gap = 1.0 - mean;
+if (!(gap > 0.0 && gap * gap > params.reach2 * variance)) {
+let clipped = upper_clip(m, v, 1.0);
+m = clipped.mean; v = clipped.variance;
+}
+let o = i * SITE;
+sites[o] = m.x; sites[o + 1u] = v.x; sites[o + 2u] = third;
+sites[o + 3u] = m.y; sites[o + 4u] = v.y; sites[o + 5u] = kc * kc * kc * de + 5.0 * E * third;
+sites[o + 6u] = bitcast<f32>(flag); sites[o + 7u] = e;
 }
 `;
 /**
@@ -379,28 +392,28 @@ export const DISPLAY_VIEW_QUALITY_SITES_WGSL = /* wgsl */ `${COMMON_WGSL}${siteB
 @compute @workgroup_size(${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) wg: vec3<u32>) {
   let local = gid.x + gid.y * wg.x * ${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE}u;
-  if (local >= params.count) { return; }
-  let i = params.site_first + local;
-  let ii = i % params.site_w;
-  let jj = i / params.site_w;
-  let x = params.site_x0 + i32(ii);
-  let y = params.site_y0 + i32(jj);
-  let c = channel_of(x, y);
-  var sum = 0.0;
-  var uncertainty = 0.0;
-  let T = params.taps;
-  for (var t = 0u; t < T; t = t + 1u) {
-    let tb = t * TAP;
-    let g = taps[tb] * GROUP;
-    let index = groups[g + 4u] + (jj + taps[tb + 2u]) * groups[g + 2u] + ii + taps[tb + 1u];
-    let raw = lattice[index];
-    if ((raw >> 31u) != 0u) { uncertainty = uncertainty + spread[c * T + t]; }
-    sum = sum + table[((raw & 0x7fffffffu) * 3u + c) * T + t];
-  }
-  let e = sum + dark_of(c);
-  let flag = select(0u, 1u, uncertainty > UNCERTAINTY_LIMIT * e);
-  let de = params.site_gamma * e + uncertainty;
-  write_site(i, c, e, de, flag);
+if (local >= params.count) { return; }
+let i = params.site_first + local;
+let ii = i % params.site_w;
+let jj = i / params.site_w;
+let x = params.site_x0 + i32(ii);
+let y = params.site_y0 + i32(jj);
+let c = channel_of(x, y);
+var sum = 0.0;
+var uncertainty = 0.0;
+let T = params.taps;
+for (var t = 0u; t < T; t = t + 1u) {
+let tb = t * TAP;
+let g = taps[tb] * GROUP;
+let index = groups[g + 4u] + (jj + taps[tb + 2u]) * groups[g + 2u] + ii + taps[tb + 1u];
+let raw = lattice[index];
+if ((raw >> 31u) != 0u) { uncertainty = uncertainty + spread[c * T + t]; }
+sum = sum + table[((raw & 0x7fffffffu) * 3u + c) * T + t];
+}
+let e = sum + dark_of(c);
+let flag = select(0u, 1u, uncertainty > UNCERTAINTY_LIMIT * e);
+let de = params.site_gamma * e + uncertainty;
+write_site(i, c, e, de, flag);
 }
 `;
 /**
@@ -427,47 +440,47 @@ ${SITE_TAIL_WGSL}
 @compute @workgroup_size(${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) wg: vec3<u32>) {
   let local = gid.x + gid.y * wg.x * ${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE}u;
-  if (local >= params.count) { return; }
-  let i = params.site_first + local;
-  let ii = i % params.site_w;
-  let jj = i / params.site_w;
-  let x = params.site_x0 + i32(ii);
-  let y = params.site_y0 + i32(jj);
-  let c = channel_of(x, y);
-  let T = params.taps;
-  var sum = 0.0;
-  var uncertainty = 0.0;
-  for (var k = 0u; k < params.groups; k = k + 1u) {
-    let g = k * GROUP;
-    let lw = groups[g + 2u];
-    let cw = lw - params.site_w + 1u;
-    let ch = groups[g + 3u] - params.site_h + 1u;
-    let lattice0 = groups[g + 4u] + jj * lw + ii;
-    let tap0 = groups[g + 5u];
-    var group_sum = 0.0;
-    var group_uncertainty = 0.0;
-    for (var dy = 0u; dy < ch; dy = dy + 1u) {
-      let row = lattice0 + dy * lw;
-      let row_tap = tap0 + dy * cw;
-      var row_sum = 0.0;
-      var row_uncertainty = 0.0;
-      for (var dx = 0u; dx < cw; dx = dx + 1u) {
-        let raw = lattice[row + dx];
-        let t = row_tap + dx;
-        let m = 2u * (raw & 0x7fffffffu);
-        if ((raw >> 31u) != 0u) { row_uncertainty = row_uncertainty + spread[c * T + t]; }
-        row_sum = row_sum + bitcast<f32>(materials[m + 1u]) * table[(materials[m] * 3u + c) * T + t];
-      }
-      group_sum = group_sum + row_sum;
-      group_uncertainty = group_uncertainty + row_uncertainty;
-    }
-    sum = sum + group_sum;
-    uncertainty = uncertainty + group_uncertainty;
-  }
-  let e = sum + dark_of(c);
-  let flag = select(0u, 1u, uncertainty > UNCERTAINTY_LIMIT * e);
-  let de = params.site_gamma * e + uncertainty * (1.0 + params.site_gamma) + params.site_tiny;
-  write_site(i, c, e, de, flag);
+if (local >= params.count) { return; }
+let i = params.site_first + local;
+let ii = i % params.site_w;
+let jj = i / params.site_w;
+let x = params.site_x0 + i32(ii);
+let y = params.site_y0 + i32(jj);
+let c = channel_of(x, y);
+let T = params.taps;
+var sum = 0.0;
+var uncertainty = 0.0;
+for (var k = 0u; k < params.groups; k = k + 1u) {
+let g = k * GROUP;
+let lw = groups[g + 2u];
+let cw = lw - params.site_w + 1u;
+let ch = groups[g + 3u] - params.site_h + 1u;
+let lattice0 = groups[g + 4u] + jj * lw + ii;
+let tap0 = groups[g + 5u];
+var group_sum = 0.0;
+var group_uncertainty = 0.0;
+for (var dy = 0u; dy < ch; dy = dy + 1u) {
+let row = lattice0 + dy * lw;
+let row_tap = tap0 + dy * cw;
+var row_sum = 0.0;
+var row_uncertainty = 0.0;
+for (var dx = 0u; dx < cw; dx = dx + 1u) {
+let raw = lattice[row + dx];
+let t = row_tap + dx;
+let m = 2u * (raw & 0x7fffffffu);
+if ((raw >> 31u) != 0u) { row_uncertainty = row_uncertainty + spread[c * T + t]; }
+row_sum = row_sum + bitcast<f32>(materials[m + 1u]) * table[(materials[m] * 3u + c) * T + t];
+}
+group_sum = group_sum + row_sum;
+group_uncertainty = group_uncertainty + row_uncertainty;
+}
+sum = sum + group_sum;
+uncertainty = uncertainty + group_uncertainty;
+}
+let e = sum + dark_of(c);
+let flag = select(0u, 1u, uncertainty > UNCERTAINTY_LIMIT * e);
+let de = params.site_gamma * e + uncertainty * (1.0 + params.site_gamma) + params.site_tiny;
+write_site(i, c, e, de, flag);
 }
 `;
 /** Pass 3: the display pixels (see the module comment). */
@@ -484,6 +497,8 @@ const FLAG_OUTSIDE: u32 = ${DISPLAY_VIEW_QUALITY_FLAG.siteOutsideWindow}u;
 const FLAG_STATE: u32 = ${DISPLAY_VIEW_QUALITY_FLAG.stateMissing}u;
 const FLAG_TIE: u32 = ${DISPLAY_VIEW_QUALITY_FLAG.thresholdTie}u;
 const FLAG_CORRECTED: u32 = ${DISPLAY_VIEW_QUALITY_FLAG.corrected}u;
+const FLAG_CHOICE: u32 = ${DISPLAY_VIEW_QUALITY_FLAG.ahdChoice}u;
+const CHOICE_SIGMA: f32 = ${literal(DISPLAY_VIEW_QUALITY_CHOICE_SIGMA)};
 @group(0) @binding(1) var<storage, read> aux: array<f32>;
 @group(0) @binding(2) var<storage, read> geometry: array<f32>;
 @group(0) @binding(3) var<storage, read> sites: array<f32>;
@@ -497,269 +512,288 @@ var<private> pixel_flags: u32;
 ${REINHARD_WGSL}
 fn reflect_x(x: i32) -> i32 { if (x < 0) { return -x; } if (x >= i32(params.native_w)) { return 2 * i32(params.native_w) - 2 - x; } return x; }
 fn reflect_y(y: i32) -> i32 { if (y < 0) { return -y; } if (y >= i32(params.native_h)) { return 2 * i32(params.native_h) - 2 - y; } return y; }
-// The site buffer offset of native site (x, y) (reflected at the raster's borders), or a flag when it lies outside the window.
+
 fn site_at(x: i32, y: i32) -> u32 {
-  let rx = reflect_x(x) - params.site_x0;
-  let ry = reflect_y(y) - params.site_y0;
-  if (rx < 0 || ry < 0 || rx >= i32(params.site_w) || ry >= i32(params.site_h)) { pixel_flags = pixel_flags | FLAG_OUTSIDE; return 0u; }
-  let o = (u32(ry) * params.site_w + u32(rx)) * SITE;
-  pixel_flags = pixel_flags | (bitcast<u32>(sites[o + 6u]) & 1u);
-  return o;
-}
-// The offset of a grid key in the sorted state table, or state_count when absent.
+let rx = reflect_x(x) - params.site_x0;
+let ry = reflect_y(y) - params.site_y0;
+if (rx < 0 || ry < 0 || rx >= i32(params.site_w) || ry >= i32(params.site_h)) { pixel_flags = pixel_flags | FLAG_OUTSIDE; return 0u; }
+let o = (u32(ry) * params.site_w + u32(rx)) * SITE;
+pixel_flags = pixel_flags | (bitcast<u32>(sites[o + 6u]) & 1u);
+return o;
+}
+
 fn find_state(key: i32) -> u32 {
-  var lo = 0u; var hi = params.state_count;
-  while (lo < hi) {
-    let mid = (lo + hi) / 2u;
-    if (state_keys[mid] < key) { lo = mid + 1u; } else { hi = mid; }
-  }
-  if (lo < params.state_count && state_keys[lo] == key) { return lo; }
-  return params.state_count;
-}
-// The flat-neighbourhood correction at channel means (m0, m1, m2) with its bound: trilinear between the eight grid states
-// around (log2(clamp(m, 2^-12, 1)) + 12)·8; a missing state flags the pixel. The bound of each axis's coordinate times the
-// largest state difference along that axis bounds the interpolation's dependence on the coordinates' error.
+var lo = 0u; var hi = params.state_count;
+while (lo < hi) {
+let mid = (lo + hi) / 2u;
+if (state_keys[mid] < key) { lo = mid + 1u; } else { hi = mid; }
+}
+if (lo < params.state_count && state_keys[lo] == key) { return lo; }
+return params.state_count;
+}
+
+
+
 fn flat_correction(m0: vec2<f32>, m1: vec2<f32>, m2: vec2<f32>, corr: ptr<function, array<vec2<f32>, 3>>) {
-  var base: array<u32, 3>; var frac: array<f32, 3>; var dg: array<f32, 3>;
-  for (var i = 0u; i < 3u; i = i + 1u) {
-    var mi = m0; if (i == 1u) { mi = m1; } if (i == 2u) { mi = m2; }
-    let clamped = clamp(mi.x, KEY_FLOOR, 1.0);
-    let g = (log2(clamped) + KEY_OCTAVES) * KEY_STEPS;
-    let b = min(u32(max(floor(g), 0.0)), KEY_TOP);
-    base[i] = b; frac[i] = g - f32(b);
-    // log2: 1/ln 2 per relative input error, 2^-21 absolute or 3 ULP (≤ 36E on [2^-12, 1]), the sum and the product.
-    var slope = 0.0; if (mi.x > KEY_FLOOR && mi.x < 1.0) { slope = 1.4426950408889634 * mi.y / clamped; }
-    dg[i] = KEY_STEPS * (slope + 4.76837158203125e-7 + 36.0 * E) + 2.0 * E * (g + 1.0);
-  }
-  var values: array<f32, 24>;
-  var missing = false;
-  for (var corner = 0u; corner < 8u; corner = corner + 1u) {
-    let i0 = base[0] + (corner & 1u); let i1 = base[1] + ((corner >> 1u) & 1u); let i2 = base[2] + ((corner >> 2u) & 1u);
-    let key = i32((i0 * KEY_LEVELS + i1) * KEY_LEVELS + i2);
-    var weight = 1.0;
-    for (var i = 0u; i < 3u; i = i + 1u) { weight = weight * select(1.0 - frac[i], frac[i], ((corner >> i) & 1u) == 1u); }
-    if (weight == 0.0) { for (var c = 0u; c < 3u; c = c + 1u) { values[corner * 3u + c] = 0.0; } continue; }
-    atomicOr(&bitmap[u32(key) / 32u], 1u << (u32(key) % 32u));
-    let at = find_state(key);
-    if (at >= params.state_count) { missing = true; continue; }
-    for (var c = 0u; c < 3u; c = c + 1u) { values[corner * 3u + c] = state_values[at * 3u + c]; }
-  }
-  if (missing) { pixel_flags = pixel_flags | FLAG_STATE; for (var c = 0u; c < 3u; c = c + 1u) { (*corr)[c] = vec2<f32>(0.0, 0.0); } return; }
-  for (var c = 0u; c < 3u; c = c + 1u) {
-    var sum = 0.0; var mag = 0.0;
-    for (var corner = 0u; corner < 8u; corner = corner + 1u) {
-      var weight = 1.0;
-      for (var i = 0u; i < 3u; i = i + 1u) { weight = weight * select(1.0 - frac[i], frac[i], ((corner >> i) & 1u) == 1u); }
-      sum = sum + weight * values[corner * 3u + c];
-      mag = mag + abs(weight * values[corner * 3u + c]);
-    }
-    // The largest state difference along each axis (over the four edges), times that axis's coordinate bound.
-    var slope_term = 0.0;
-    for (var i = 0u; i < 3u; i = i + 1u) {
-      var largest = 0.0;
-      for (var corner = 0u; corner < 8u; corner = corner + 1u) {
-        if (((corner >> i) & 1u) == 1u) { continue; }
-        largest = max(largest, abs(values[(corner | (1u << i)) * 3u + c] - values[corner * 3u + c]));
-      }
-      slope_term = slope_term + dg[i] * largest;
-    }
-    (*corr)[c] = vec2<f32>(sum, slope_term + 12.0 * E * mag);
-  }
+var base: array<u32, 3>; var frac: array<f32, 3>; var dg: array<f32, 3>;
+for (var i = 0u; i < 3u; i = i + 1u) {
+var mi = m0; if (i == 1u) { mi = m1; } if (i == 2u) { mi = m2; }
+let clamped = clamp(mi.x, KEY_FLOOR, 1.0);
+let g = (log2(clamped) + KEY_OCTAVES) * KEY_STEPS;
+let b = min(u32(max(floor(g), 0.0)), KEY_TOP);
+base[i] = b; frac[i] = g - f32(b);
+
+var slope = 0.0; if (mi.x > KEY_FLOOR && mi.x < 1.0) { slope = 1.4426950408889634 * mi.y / clamped; }
+dg[i] = KEY_STEPS * (slope + 4.76837158203125e-7 + 36.0 * E) + 2.0 * E * (g + 1.0);
+}
+var values: array<f32, 24>;
+var missing = false;
+for (var corner = 0u; corner < 8u; corner = corner + 1u) {
+let i0 = base[0] + (corner & 1u); let i1 = base[1] + ((corner >> 1u) & 1u); let i2 = base[2] + ((corner >> 2u) & 1u);
+let key = i32((i0 * KEY_LEVELS + i1) * KEY_LEVELS + i2);
+var weight = 1.0;
+for (var i = 0u; i < 3u; i = i + 1u) { weight = weight * select(1.0 - frac[i], frac[i], ((corner >> i) & 1u) == 1u); }
+if (weight == 0.0) { for (var c = 0u; c < 3u; c = c + 1u) { values[corner * 3u + c] = 0.0; } continue; }
+atomicOr(&bitmap[u32(key) / 32u], 1u << (u32(key) % 32u));
+let at = find_state(key);
+if (at >= params.state_count) { missing = true; continue; }
+for (var c = 0u; c < 3u; c = c + 1u) { values[corner * 3u + c] = state_values[at * 3u + c]; }
+}
+if (missing) { pixel_flags = pixel_flags | FLAG_STATE; for (var c = 0u; c < 3u; c = c + 1u) { (*corr)[c] = vec2<f32>(0.0, 0.0); } return; }
+for (var c = 0u; c < 3u; c = c + 1u) {
+var sum = 0.0; var mag = 0.0;
+for (var corner = 0u; corner < 8u; corner = corner + 1u) {
+var weight = 1.0;
+for (var i = 0u; i < 3u; i = i + 1u) { weight = weight * select(1.0 - frac[i], frac[i], ((corner >> i) & 1u) == 1u); }
+sum = sum + weight * values[corner * 3u + c];
+mag = mag + abs(weight * values[corner * 3u + c]);
+}
+
+var slope_term = 0.0;
+for (var i = 0u; i < 3u; i = i + 1u) {
+var largest = 0.0;
+for (var corner = 0u; corner < 8u; corner = corner + 1u) {
+if (((corner >> i) & 1u) == 1u) { continue; }
+largest = max(largest, abs(values[(corner | (1u << i)) * 3u + c] - values[corner * 3u + c]));
+}
+slope_term = slope_term + dg[i] * largest;
+}
+(*corr)[c] = vec2<f32>(sum, slope_term + 12.0 * E * mag);
+}
 }
 @compute @workgroup_size(${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) wg: vec3<u32>) {
   let i = gid.x + gid.y * wg.x * ${DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE}u;
-  if (i >= params.count) { return; }
-  pixel_flags = 0u;
-  let rx = i % params.region_w;
-  let ry = params.row0 + i / params.region_w;
-  let col = rx * STRIDE;
-  let row = (params.columns + ry) * STRIDE;
-  let col_first = bitcast<i32>(geometry[col]);
-  let nx = bitcast<u32>(geometry[col + 1u]);
-  let row_first = bitcast<i32>(geometry[row]);
-  let ny = bitcast<u32>(geometry[row + 1u]);
-  let margin = i32(params.margin);
-  let reinhard = params.tone == 1u;
-  let count = params.candidates;
-  let share = select(1.0, 0.5, count == 2u);
-  // B_c of the footprint from the host's axis sums (each over its scale squared): red, green, blue.
-  let xb_even = geometry[col + 8u]; let xb_odd = geometry[col + 9u];
-  let xpp_even = geometry[col + 10u]; let xpp_odd = geometry[col + 11u];
-  let xqq_even = geometry[col + 12u]; let xqq_odd = geometry[col + 13u];
-  let xpq_even = geometry[col + 14u]; let xpq_odd = geometry[col + 15u];
-  let yb_even = geometry[row + 8u]; let yb_odd = geometry[row + 9u];
-  let ypp_even = geometry[row + 10u]; let ypp_odd = geometry[row + 11u];
-  let yqq_even = geometry[row + 12u]; let yqq_odd = geometry[row + 13u];
-  let ypq_even = geometry[row + 14u]; let ypq_odd = geometry[row + 15u];
-  let b0 = xb_even * yb_even;
-  let b1 = (xpp_odd * ypp_even + xqq_odd * ypp_even + xpp_odd * yqq_even + 2.0 * xpq_odd * ypp_even + 2.0 * xpp_odd * ypq_even + 2.0 * xpq_odd * ypq_even) +
-    (xpp_even * ypp_odd + xqq_even * ypp_odd + xpp_even * yqq_odd + 2.0 * xpq_even * ypp_odd + 2.0 * xpp_even * ypq_odd + 2.0 * xpq_even * ypq_odd);
-  let b2 = xb_odd * yb_odd;
-  var s = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
-  var cov = array<vec2<f32>, 6>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
-  var res = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
-  for (var j = 0u; j < ny; j = j + 1u) {
-    let ay = geometry[row + 2u + j];
-    for (var ii = 0u; ii < nx; ii = ii + 1u) {
-      // The overlap weight a_j: two host roundings (the overlaps over the scale) and the product.
-      let aj = vec2<f32>(geometry[col + 2u + ii] * ay, 3.0 * E * abs(geometry[col + 2u + ii] * ay));
-      let x = col_first + i32(ii) + margin;
-      let y = row_first + i32(j) + margin;
-      let phase = u32(y & 1) * 2u + u32(x & 1);
-      // Site variance of each channel through the bilinear kernels, over Σw² (for B_c).
-      var csv: array<vec2<f32>, 3>;
-      for (var c = 0u; c < 3u; c = c + 1u) {
-        var variance = vec2<f32>(0.0, 0.0);
+if (i >= params.count) { return; }
+pixel_flags = 0u;
+let rx = i % params.region_w;
+let ry = params.row0 + i / params.region_w;
+let col = rx * STRIDE;
+let row = (params.columns + ry) * STRIDE;
+let col_first = bitcast<i32>(geometry[col]);
+let nx = bitcast<u32>(geometry[col + 1u]);
+let row_first = bitcast<i32>(geometry[row]);
+let ny = bitcast<u32>(geometry[row + 1u]);
+let margin = i32(params.margin);
+let reinhard = params.tone == 1u;
+let count = params.candidates;
+let share = select(1.0, 0.5, count == 2u);
+
+let xb_even = geometry[col + 8u]; let xb_odd = geometry[col + 9u];
+let xpp_even = geometry[col + 10u]; let xpp_odd = geometry[col + 11u];
+let xqq_even = geometry[col + 12u]; let xqq_odd = geometry[col + 13u];
+let xpq_even = geometry[col + 14u]; let xpq_odd = geometry[col + 15u];
+let yb_even = geometry[row + 8u]; let yb_odd = geometry[row + 9u];
+let ypp_even = geometry[row + 10u]; let ypp_odd = geometry[row + 11u];
+let yqq_even = geometry[row + 12u]; let yqq_odd = geometry[row + 13u];
+let ypq_even = geometry[row + 14u]; let ypq_odd = geometry[row + 15u];
+let b0 = xb_even * yb_even;
+let b1 = (xpp_odd * ypp_even + xqq_odd * ypp_even + xpp_odd * yqq_even + 2.0 * xpq_odd * ypp_even + 2.0 * xpp_odd * ypq_even + 2.0 * xpq_odd * ypq_even) +
+(xpp_even * ypp_odd + xqq_even * ypp_odd + xpp_even * yqq_odd + 2.0 * xpq_even * ypp_odd + 2.0 * xpp_even * ypq_odd + 2.0 * xpq_even * ypq_odd);
+let b2 = xb_odd * yb_odd;
+var s = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
+var cov = array<vec2<f32>, 6>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
+var res = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
+
+var choice = array<f32, 3>(0.0, 0.0, 0.0);
+for (var j = 0u; j < ny; j = j + 1u) {
+let ay = geometry[row + 2u + j];
+for (var ii = 0u; ii < nx; ii = ii + 1u) {
+
+let aj = vec2<f32>(geometry[col + 2u + ii] * ay, 3.0 * E * abs(geometry[col + 2u + ii] * ay));
+let x = col_first + i32(ii) + margin;
+let y = row_first + i32(j) + margin;
+let phase = u32(y & 1) * 2u + u32(x & 1);
+
+var csv: array<vec2<f32>, 3>;
+for (var c = 0u; c < 3u; c = c + 1u) {
+var variance = vec2<f32>(0.0, 0.0);
         let tb = ${DISPLAY_VIEW_QUALITY_AUX.bilinear}u + (phase * 3u + c) * 16u;
-        for (var t = 0u; t < 4u; t = t + 1u) {
-          let w = aux[tb + 4u * t + 2u];
-          if (w == 0.0) { continue; }
-          let o = site_at(x + i32(aux[tb + 4u * t]), y + i32(aux[tb + 4u * t + 1u]));
-          variance = b_add(variance, b_scale(vec2<f32>(sites[o + 1u], sites[o + 4u]), w * w));
-        }
+for (var t = 0u; t < 4u; t = t + 1u) {
+let w = aux[tb + 4u * t + 2u];
+if (w == 0.0) { continue; }
+let o = site_at(x + i32(aux[tb + 4u * t]), y + i32(aux[tb + 4u * t + 1u]));
+variance = b_add(variance, b_scale(vec2<f32>(sites[o + 1u], sites[o + 4u]), w * w));
+}
         csv[c] = b_mul(variance, b_rounded(aux[${DISPLAY_VIEW_QUALITY_AUX.inverseW2}u + phase * 3u + c]));
-      }
-      let cb = CAND_BASE + phase * CAND_STRIDE;
-      let entries = bitcast<u32>(aux[cb]);
-      var e_mean = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
-      var cm_average = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
-      var pixel_variance = vec2<f32>(0.0, 0.0);
-      var bs: array<vec2<f32>, 3>; var hs: array<vec2<f32>, 3>;
-      var hv: array<vec2<f32>, 3>;
-      for (var d = 0u; d < count; d = d + 1u) {
-        // Camera-channel mean and covariance of candidate d from its dense weights over the window.
-        var cm: array<vec2<f32>, 3>;
-        var C: array<vec2<f32>, 6>;
-        // Whether every site a channel reads is exactly at white (a zero bound: the reference's site is exactly 1 too); the
-        // dyadic kernel weights then sum exactly on both sides, so the channel's mean carries no error (the host checks the weights).
-        var exact = array<bool, 3>(true, true, true);
-        for (var c = 0u; c < 3u; c = c + 1u) { cm[c] = vec2<f32>(0.0, 0.0); }
-        for (var k = 0u; k < 6u; k = k + 1u) { C[k] = vec2<f32>(0.0, 0.0); }
-        for (var n = 0u; n < entries; n = n + 1u) {
+}
+let cb = CAND_BASE + phase * CAND_STRIDE;
+let entries = bitcast<u32>(aux[cb]);
+var e_mean = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
+var cm_average = array<vec2<f32>, 3>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
+var pixel_variance = vec2<f32>(0.0, 0.0);
+var bs: array<vec2<f32>, 3>; var hs: array<vec2<f32>, 3>;
+var hv: array<vec2<f32>, 3>;
+
+var h_cand = array<vec2<f32>, 6>(vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0), vec2<f32>(0.0));
+for (var d = 0u; d < count; d = d + 1u) {
+
+var cm: array<vec2<f32>, 3>;
+var C: array<vec2<f32>, 6>;
+
+
+var exact = array<bool, 3>(true, true, true);
+for (var c = 0u; c < 3u; c = c + 1u) { cm[c] = vec2<f32>(0.0, 0.0); }
+for (var k = 0u; k < 6u; k = k + 1u) { C[k] = vec2<f32>(0.0, 0.0); }
+for (var n = 0u; n < entries; n = n + 1u) {
           let eb = cb + 4u + n * ${DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS}u + 2u + d * 3u;
-          let w0 = aux[eb]; let w1 = aux[eb + 1u]; let w2 = aux[eb + 2u];
-          if (w0 == 0.0 && w1 == 0.0 && w2 == 0.0) { continue; }
+let w0 = aux[eb]; let w1 = aux[eb + 1u]; let w2 = aux[eb + 2u];
+if (w0 == 0.0 && w1 == 0.0 && w2 == 0.0) { continue; }
           let o = site_at(x + i32(aux[cb + 4u + n * ${DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS}u]), y + i32(aux[cb + 4u + n * ${DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS}u + 1u]));
-          let sm = vec2<f32>(sites[o], sites[o + 3u]);
-          let sv = vec2<f32>(sites[o + 1u], sites[o + 4u]);
-          let white = sm.y == 0.0 && sm.x == 1.0;
-          exact[0] = exact[0] && (white || w0 == 0.0); exact[1] = exact[1] && (white || w1 == 0.0); exact[2] = exact[2] && (white || w2 == 0.0);
-          cm[0] = b_add(cm[0], b_scale(sm, w0)); cm[1] = b_add(cm[1], b_scale(sm, w1)); cm[2] = b_add(cm[2], b_scale(sm, w2));
-          C[0] = b_add(C[0], b_scale(sv, w0 * w0)); C[1] = b_add(C[1], b_scale(sv, w0 * w1)); C[2] = b_add(C[2], b_scale(sv, w0 * w2));
-          C[3] = b_add(C[3], b_scale(sv, w1 * w1)); C[4] = b_add(C[4], b_scale(sv, w1 * w2)); C[5] = b_add(C[5], b_scale(sv, w2 * w2));
-        }
-        for (var c = 0u; c < 3u; c = c + 1u) { if (exact[c]) { cm[c].y = 0.0; } cm_average[c] = b_add(cm_average[c], b_scale(cm[c], share)); }
-        // White balance and the highlight clip at the smallest gain. A channel exactly at white whose gain is the clip level is
-        // exactly at the clip level on both sides.
-        var bm: array<vec2<f32>, 3>; var bv: array<vec2<f32>, 3>;
-        for (var c = 0u; c < 3u; c = c + 1u) {
-          let gc = b_rounded(g_of(c));
-          var um = b_mul(gc, cm[c]);
-          if (exact[c] && cm[c].x == 1.0 && gain_at_clip(c)) { um = vec2<f32>(params.clip_level, 0.0); }
-          let uv = b_mul(b_mul(gc, gc), C[select(select(0u, 3u, c == 1u), 5u, c == 2u)]);
-          let gap = params.clip_level - um.x;
-          if (gap > 0.0 && gap * gap > params.reach2 * uv.x) { bm[c] = um; bv[c] = uv; bs[c] = gc; }
-          else { let clipped = upper_clip(um, uv, params.clip_level); bm[c] = clipped.mean; bv[c] = clipped.variance; bs[c] = b_mul(gc, clipped.slope); }
-        }
-        // Colour matrix with the full channel covariance, then the rendering of each component.
-        var hm: array<vec2<f32>, 3>;
-        for (var comp = 0u; comp < 3u; comp = comp + 1u) {
-          let r0 = b_rounded(m_of(comp, 0u)); let r1 = b_rounded(m_of(comp, 1u)); let r2 = b_rounded(m_of(comp, 2u));
-          let mean = b_add(b_add(b_mul(r0, bm[0]), b_mul(r1, bm[1])), b_mul(r2, bm[2]));
-          var variance = b_add(b_add(b_mul(b_mul(r0, r0), bv[0]), b_mul(b_mul(r1, r1), bv[1])), b_mul(b_mul(r2, r2), bv[2]));
-          let x01 = b_mul(b_mul(b_mul(r0, r1), b_mul(bs[0], bs[1])), C[1]);
-          let x02 = b_mul(b_mul(b_mul(r0, r2), b_mul(bs[0], bs[2])), C[2]);
-          let x12 = b_mul(b_mul(b_mul(r1, r2), b_mul(bs[1], bs[2])), C[4]);
-          variance = b_add(variance, b_scale(b_add(b_add(x01, x02), x12), 2.0));
-          var moments: Moments;
-          if (!reinhard && mean.x > 0.0 && mean.x < 1.0 && mean.x * mean.x > params.reach2 * variance.x && (1.0 - mean.x) * (1.0 - mean.x) > params.reach2 * variance.x) {
-            moments.mean = mean; moments.variance = variance; moments.slope = vec2<f32>(1.0, 0.0);
-          } else if (reinhard) {
-            moments = reinhard_moments(mean, variance);
-          } else {
-            // κ₃ of the component: Σ_sites (Σ_c M_comp,c·Γ_c·w_c,site)³·κ₃(site), over the candidate's dense weights.
-            var third = vec2<f32>(0.0, 0.0);
-            let k0 = b_mul(r0, bs[0]); let k1 = b_mul(r1, bs[1]); let k2 = b_mul(r2, bs[2]);
-            for (var n = 0u; n < entries; n = n + 1u) {
+let sm = vec2<f32>(sites[o], sites[o + 3u]);
+let sv = vec2<f32>(sites[o + 1u], sites[o + 4u]);
+let white = sm.y == 0.0 && sm.x == 1.0;
+exact[0] = exact[0] && (white || w0 == 0.0); exact[1] = exact[1] && (white || w1 == 0.0); exact[2] = exact[2] && (white || w2 == 0.0);
+cm[0] = b_add(cm[0], b_scale(sm, w0)); cm[1] = b_add(cm[1], b_scale(sm, w1)); cm[2] = b_add(cm[2], b_scale(sm, w2));
+C[0] = b_add(C[0], b_scale(sv, w0 * w0)); C[1] = b_add(C[1], b_scale(sv, w0 * w1)); C[2] = b_add(C[2], b_scale(sv, w0 * w2));
+C[3] = b_add(C[3], b_scale(sv, w1 * w1)); C[4] = b_add(C[4], b_scale(sv, w1 * w2)); C[5] = b_add(C[5], b_scale(sv, w2 * w2));
+}
+for (var c = 0u; c < 3u; c = c + 1u) { if (exact[c]) { cm[c].y = 0.0; } cm_average[c] = b_add(cm_average[c], b_scale(cm[c], share)); }
+
+
+var bm: array<vec2<f32>, 3>; var bv: array<vec2<f32>, 3>;
+for (var c = 0u; c < 3u; c = c + 1u) {
+let gc = b_rounded(g_of(c));
+var um = b_mul(gc, cm[c]);
+if (exact[c] && cm[c].x == 1.0 && gain_at_clip(c)) { um = vec2<f32>(params.clip_level, 0.0); }
+let uv = b_mul(b_mul(gc, gc), C[select(select(0u, 3u, c == 1u), 5u, c == 2u)]);
+let gap = params.clip_level - um.x;
+if (gap > 0.0 && gap * gap > params.reach2 * uv.x) { bm[c] = um; bv[c] = uv; bs[c] = gc; }
+else { let clipped = upper_clip(um, uv, params.clip_level); bm[c] = clipped.mean; bv[c] = clipped.variance; bs[c] = b_mul(gc, clipped.slope); }
+}
+
+var hm: array<vec2<f32>, 3>;
+for (var comp = 0u; comp < 3u; comp = comp + 1u) {
+let r0 = b_rounded(m_of(comp, 0u)); let r1 = b_rounded(m_of(comp, 1u)); let r2 = b_rounded(m_of(comp, 2u));
+let mean = b_add(b_add(b_mul(r0, bm[0]), b_mul(r1, bm[1])), b_mul(r2, bm[2]));
+var variance = b_add(b_add(b_mul(b_mul(r0, r0), bv[0]), b_mul(b_mul(r1, r1), bv[1])), b_mul(b_mul(r2, r2), bv[2]));
+let x01 = b_mul(b_mul(b_mul(r0, r1), b_mul(bs[0], bs[1])), C[1]);
+let x02 = b_mul(b_mul(b_mul(r0, r2), b_mul(bs[0], bs[2])), C[2]);
+let x12 = b_mul(b_mul(b_mul(r1, r2), b_mul(bs[1], bs[2])), C[4]);
+variance = b_add(variance, b_scale(b_add(b_add(x01, x02), x12), 2.0));
+var moments: Moments;
+if (!reinhard && mean.x > 0.0 && mean.x < 1.0 && mean.x * mean.x > params.reach2 * variance.x && (1.0 - mean.x) * (1.0 - mean.x) > params.reach2 * variance.x) {
+moments.mean = mean; moments.variance = variance; moments.slope = vec2<f32>(1.0, 0.0);
+} else if (reinhard) {
+moments = reinhard_moments(mean, variance);
+} else {
+
+var third = vec2<f32>(0.0, 0.0);
+let k0 = b_mul(r0, bs[0]); let k1 = b_mul(r1, bs[1]); let k2 = b_mul(r2, bs[2]);
+for (var n = 0u; n < entries; n = n + 1u) {
               let eb = cb + 4u + n * ${DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS}u + 2u + d * 3u;
-              let w0 = aux[eb]; let w1 = aux[eb + 1u]; let w2 = aux[eb + 2u];
-              if (w0 == 0.0 && w1 == 0.0 && w2 == 0.0) { continue; }
+let w0 = aux[eb]; let w1 = aux[eb + 1u]; let w2 = aux[eb + 2u];
+if (w0 == 0.0 && w1 == 0.0 && w2 == 0.0) { continue; }
               let o = site_at(x + i32(aux[cb + 4u + n * ${DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS}u]), y + i32(aux[cb + 4u + n * ${DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS}u + 1u]));
-              let coefficient = b_add(b_add(b_scale(k0, w0), b_scale(k1, w1)), b_scale(k2, w2));
-              let cube = b_mul(b_mul(coefficient, coefficient), coefficient);
-              third = b_add(third, b_mul(cube, vec2<f32>(sites[o + 2u], sites[o + 5u])));
-            }
-            var skew = vec2<f32>(0.0, 0.0);
-            if (variance.x > 0.0) { skew = b_div(third, b_mul(variance, b_sqrt(variance))); }
-            moments = unit_clip(mean, variance, skew);
-          }
-          hm[comp] = moments.mean; hv[comp] = moments.variance; hs[comp] = moments.slope;
-          e_mean[comp] = b_add(e_mean[comp], b_scale(moments.mean, share));
-          pixel_variance = vec2<f32>(max(pixel_variance.x, moments.variance.x), max(pixel_variance.y, moments.variance.y));
-        }
-        // Linear (Stein) part with B_c·σ_c², and the pixel's own linear variance aᵀCa for the residual.
-        var an: array<vec2<f32>, 9>;
-        for (var c = 0u; c < 3u; c = c + 1u) {
-          an[c] = b_mul(b_mul(hs[0], b_rounded(m_of(0u, c))), bs[c]);
-          an[3u + c] = b_mul(b_mul(hs[1], b_rounded(m_of(1u, c))), bs[c]);
-          an[6u + c] = b_mul(b_mul(hs[2], b_rounded(m_of(2u, c))), bs[c]);
-          var bc = b0; if (c == 1u) { bc = b1; } if (c == 2u) { bc = b2; }
-          let wgt = b_mul(b_mul(b_scale(aj, share), b_rounded(bc)), csv[c]);
-          cov[0] = b_add(cov[0], b_mul(b_mul(wgt, an[c]), an[c])); cov[1] = b_add(cov[1], b_mul(b_mul(wgt, an[c]), an[3u + c])); cov[2] = b_add(cov[2], b_mul(b_mul(wgt, an[c]), an[6u + c]));
-          cov[3] = b_add(cov[3], b_mul(b_mul(wgt, an[3u + c]), an[3u + c])); cov[4] = b_add(cov[4], b_mul(b_mul(wgt, an[3u + c]), an[6u + c])); cov[5] = b_add(cov[5], b_mul(b_mul(wgt, an[6u + c]), an[6u + c]));
-        }
-        for (var comp = 0u; comp < 3u; comp = comp + 1u) {
-          var l = vec2<f32>(0.0, 0.0);
-          for (var p = 0u; p < 3u; p = p + 1u) {
-            for (var q = 0u; q < 3u; q = q + 1u) {
-              var cij = C[0]; if (p + q == 1u) { cij = C[1]; } if ((p == 0u && q == 2u) || (p == 2u && q == 0u)) { cij = C[2]; } if (p == 1u && q == 1u) { cij = C[3]; }
-              if ((p == 1u && q == 2u) || (p == 2u && q == 1u)) { cij = C[4]; } if (p == 2u && q == 2u) { cij = C[5]; }
-              l = b_add(l, b_mul(b_mul(an[comp * 3u + p], an[comp * 3u + q]), cij));
-            }
-          }
-          let t = vec2<f32>(share * max(0.0, hv[comp].x - l.x), share * (hv[comp].y + l.y));
-          res[comp] = b_add(res[comp], b_mul(b_mul(aj, aj), t));
-        }
-      }
-      for (var comp = 0u; comp < 3u; comp = comp + 1u) { s[comp] = b_add(s[comp], b_mul(aj, e_mean[comp])); }
-      if (count == 2u) {
-        // AHD's per-pixel choice: ¼·Var(H − V) at the last candidate's slopes, linear in the sites.
-        var x0 = vec2<f32>(0.0, 0.0); var x1 = vec2<f32>(0.0, 0.0); var x2 = vec2<f32>(0.0, 0.0);
-        for (var n = 0u; n < entries; n = n + 1u) {
+let coefficient = b_add(b_add(b_scale(k0, w0), b_scale(k1, w1)), b_scale(k2, w2));
+let cube = b_mul(b_mul(coefficient, coefficient), coefficient);
+third = b_add(third, b_mul(cube, vec2<f32>(sites[o + 2u], sites[o + 5u])));
+}
+var skew = vec2<f32>(0.0, 0.0);
+if (variance.x > 0.0) { skew = b_div(third, b_mul(variance, b_sqrt(variance))); }
+moments = unit_clip(mean, variance, skew);
+}
+hm[comp] = moments.mean; hv[comp] = moments.variance; hs[comp] = moments.slope;
+h_cand[d * 3u + comp] = moments.mean;
+e_mean[comp] = b_add(e_mean[comp], b_scale(moments.mean, share));
+pixel_variance = vec2<f32>(max(pixel_variance.x, moments.variance.x), max(pixel_variance.y, moments.variance.y));
+}
+
+var an: array<vec2<f32>, 9>;
+for (var c = 0u; c < 3u; c = c + 1u) {
+an[c] = b_mul(b_mul(hs[0], b_rounded(m_of(0u, c))), bs[c]);
+an[3u + c] = b_mul(b_mul(hs[1], b_rounded(m_of(1u, c))), bs[c]);
+an[6u + c] = b_mul(b_mul(hs[2], b_rounded(m_of(2u, c))), bs[c]);
+var bc = b0; if (c == 1u) { bc = b1; } if (c == 2u) { bc = b2; }
+let wgt = b_mul(b_mul(b_scale(aj, share), b_rounded(bc)), csv[c]);
+cov[0] = b_add(cov[0], b_mul(b_mul(wgt, an[c]), an[c])); cov[1] = b_add(cov[1], b_mul(b_mul(wgt, an[c]), an[3u + c])); cov[2] = b_add(cov[2], b_mul(b_mul(wgt, an[c]), an[6u + c]));
+cov[3] = b_add(cov[3], b_mul(b_mul(wgt, an[3u + c]), an[3u + c])); cov[4] = b_add(cov[4], b_mul(b_mul(wgt, an[3u + c]), an[6u + c])); cov[5] = b_add(cov[5], b_mul(b_mul(wgt, an[6u + c]), an[6u + c]));
+}
+for (var comp = 0u; comp < 3u; comp = comp + 1u) {
+var l = vec2<f32>(0.0, 0.0);
+for (var p = 0u; p < 3u; p = p + 1u) {
+for (var q = 0u; q < 3u; q = q + 1u) {
+var cij = C[0]; if (p + q == 1u) { cij = C[1]; } if ((p == 0u && q == 2u) || (p == 2u && q == 0u)) { cij = C[2]; } if (p == 1u && q == 1u) { cij = C[3]; }
+if ((p == 1u && q == 2u) || (p == 2u && q == 1u)) { cij = C[4]; } if (p == 2u && q == 2u) { cij = C[5]; }
+l = b_add(l, b_mul(b_mul(an[comp * 3u + p], an[comp * 3u + q]), cij));
+}
+}
+let t = vec2<f32>(share * max(0.0, hv[comp].x - l.x), share * (hv[comp].y + l.y));
+res[comp] = b_add(res[comp], b_mul(b_mul(aj, aj), t));
+}
+}
+if (count == 2u) {
+
+
+
+for (var comp = 0u; comp < 3u; comp = comp + 1u) {
+let diff = abs(h_cand[comp].x - h_cand[3u + comp].x);
+let both = h_cand[comp].y + h_cand[3u + comp].y;
+choice[comp] = choice[comp] + aj.x * 0.5 * diff;
+e_mean[comp].y = e_mean[comp].y + 0.5 * (diff + both);
+}
+}
+for (var comp = 0u; comp < 3u; comp = comp + 1u) { s[comp] = b_add(s[comp], b_mul(aj, e_mean[comp])); }
+if (count == 2u) {
+
+var x0 = vec2<f32>(0.0, 0.0); var x1 = vec2<f32>(0.0, 0.0); var x2 = vec2<f32>(0.0, 0.0);
+for (var n = 0u; n < entries; n = n + 1u) {
           let eb = cb + 4u + n * ${DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS}u;
-          let o = site_at(x + i32(aux[eb]), y + i32(aux[eb + 1u]));
-          let d0 = b_scale(bs[0], aux[eb + 2u] - aux[eb + 5u]);
-          let d1 = b_scale(bs[1], aux[eb + 3u] - aux[eb + 6u]);
-          let d2 = b_scale(bs[2], aux[eb + 4u] - aux[eb + 7u]);
-          let sv = vec2<f32>(sites[o + 1u], sites[o + 4u]);
-          let a = b_mul(hs[0], b_add(b_add(b_mul(b_rounded(params.m00), d0), b_mul(b_rounded(params.m01), d1)), b_mul(b_rounded(params.m02), d2)));
-          let b = b_mul(hs[1], b_add(b_add(b_mul(b_rounded(params.m10), d0), b_mul(b_rounded(params.m11), d1)), b_mul(b_rounded(params.m12), d2)));
-          let c = b_mul(hs[2], b_add(b_add(b_mul(b_rounded(params.m20), d0), b_mul(b_rounded(params.m21), d1)), b_mul(b_rounded(params.m22), d2)));
-          x0 = b_add(x0, b_mul(b_mul(a, a), sv)); x1 = b_add(x1, b_mul(b_mul(b, b), sv)); x2 = b_add(x2, b_mul(b_mul(c, c), sv));
-        }
-        let ajaj = b_mul(aj, aj);
-        res[0] = b_add(res[0], b_mul(ajaj, b_scale(x0, 0.25))); res[1] = b_add(res[1], b_mul(ajaj, b_scale(x1, 0.25))); res[2] = b_add(res[2], b_mul(ajaj, b_scale(x2, 0.25)));
-      }
-      if (params.correction == 1u) {
-        // The low-signal correction where the pixel noise exceeds the threshold; a decision within its bound is flagged.
-        if (abs(pixel_variance.x - params.threshold) <= pixel_variance.y) { pixel_flags = pixel_flags | FLAG_TIE; }
-        if (pixel_variance.x > params.threshold) {
-          var corr: array<vec2<f32>, 3>;
-          flat_correction(cm_average[0], cm_average[1], cm_average[2], &corr);
-          for (var comp = 0u; comp < 3u; comp = comp + 1u) { s[comp] = b_add(s[comp], b_mul(aj, corr[comp])); }
-          pixel_flags = pixel_flags | FLAG_CORRECTED;
-        }
-      }
-    }
-  }
+let o = site_at(x + i32(aux[eb]), y + i32(aux[eb + 1u]));
+let d0 = b_scale(bs[0], aux[eb + 2u] - aux[eb + 5u]);
+let d1 = b_scale(bs[1], aux[eb + 3u] - aux[eb + 6u]);
+let d2 = b_scale(bs[2], aux[eb + 4u] - aux[eb + 7u]);
+let sv = vec2<f32>(sites[o + 1u], sites[o + 4u]);
+let a = b_mul(hs[0], b_add(b_add(b_mul(b_rounded(params.m00), d0), b_mul(b_rounded(params.m01), d1)), b_mul(b_rounded(params.m02), d2)));
+let b = b_mul(hs[1], b_add(b_add(b_mul(b_rounded(params.m10), d0), b_mul(b_rounded(params.m11), d1)), b_mul(b_rounded(params.m12), d2)));
+let c = b_mul(hs[2], b_add(b_add(b_mul(b_rounded(params.m20), d0), b_mul(b_rounded(params.m21), d1)), b_mul(b_rounded(params.m22), d2)));
+x0 = b_add(x0, b_mul(b_mul(a, a), sv)); x1 = b_add(x1, b_mul(b_mul(b, b), sv)); x2 = b_add(x2, b_mul(b_mul(c, c), sv));
+}
+let ajaj = b_mul(aj, aj);
+res[0] = b_add(res[0], b_mul(ajaj, b_scale(x0, 0.25))); res[1] = b_add(res[1], b_mul(ajaj, b_scale(x1, 0.25))); res[2] = b_add(res[2], b_mul(ajaj, b_scale(x2, 0.25)));
+}
+if (params.correction == 1u) {
+
+if (abs(pixel_variance.x - params.threshold) <= pixel_variance.y) { pixel_flags = pixel_flags | FLAG_TIE; }
+if (pixel_variance.x > params.threshold) {
+var corr: array<vec2<f32>, 3>;
+flat_correction(cm_average[0], cm_average[1], cm_average[2], &corr);
+for (var comp = 0u; comp < 3u; comp = comp + 1u) { s[comp] = b_add(s[comp], b_mul(aj, corr[comp])); }
+pixel_flags = pixel_flags | FLAG_CORRECTED;
+}
+}
+}
+}
+
+if (choice[0] > CHOICE_SIGMA * sqrt(max(cov[0].x + res[0].x, 0.0)) || choice[1] > CHOICE_SIGMA * sqrt(max(cov[3].x + res[1].x, 0.0)) ||
+choice[2] > CHOICE_SIGMA * sqrt(max(cov[5].x + res[2].x, 0.0))) { pixel_flags = pixel_flags | FLAG_CHOICE; }
   let o = i * ${DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS}u;
-  out[o] = s[0].x; out[o + 1u] = s[1].x; out[o + 2u] = s[2].x;
-  out[o + 3u] = cov[0].x + res[0].x; out[o + 4u] = cov[3].x + res[1].x; out[o + 5u] = cov[5].x + res[2].x;
-  out[o + 6u] = cov[1].x; out[o + 7u] = cov[2].x; out[o + 8u] = cov[4].x;
-  out[o + 9u] = max(s[0].y, max(s[1].y, s[2].y));
-  out[o + 10u] = max(max(cov[0].y + res[0].y, cov[3].y + res[1].y), max(cov[5].y + res[2].y, max(cov[1].y, max(cov[2].y, cov[4].y))));
-  flags[i] = pixel_flags;
+out[o] = s[0].x; out[o + 1u] = s[1].x; out[o + 2u] = s[2].x;
+out[o + 3u] = cov[0].x + res[0].x; out[o + 4u] = cov[3].x + res[1].x; out[o + 5u] = cov[5].x + res[2].x;
+out[o + 6u] = cov[1].x; out[o + 7u] = cov[2].x; out[o + 8u] = cov[4].x;
+out[o + 9u] = max(s[0].y, max(s[1].y, s[2].y));
+out[o + 10u] = max(max(cov[0].y + res[0].y, cov[3].y + res[1].y), max(cov[5].y + res[2].y, max(cov[1].y, max(cov[2].y, cov[4].y))));
+flags[i] = pixel_flags;
 }
 `;
 /** The lattice pass with a material module appended (`fn material_at(p: vec2<f32>) -> u32`, `var<private> material_uncertain: bool`). */