@vitreajs/vitrea 0.19.0 → 0.21.0

package/dist/{dist-VQPRX7BX.js → dist-N437MSRG.js}

@@ -226,6 +226,15 @@ function occlusionLiftForPolicy(policy, profile = DEFAULT_MATERIAL_PROFILE) {
   const levels = profile.increasedOcclusionLiftByPolicy;
   return policy.ambientTint === "reduced" ? levels?.increaseContrast ?? profile.increasedOcclusionLift : levels?.reduceTransparency ?? profile.increasedOcclusionLift;
 }
+function bodyChromaRetentionUnderPolicy(retention, policy) {
+  switch (policy.occlusion) {
+    case "nominal":
+      return retention;
+    case "increased":
+    case "opaque":
+      return 0;
+  }
+}
 var DEFAULT_MATERIAL_PROFILE = {
   optics: {
     // σ = 8 for the regular variant, which keeps this package's blur and
@@ -735,6 +744,18 @@ var DEFAULT_MATERIAL_PROFILE = {
   // chain's level-1 width, and the tracker carries the floor that would close it.
   sizeHeavyTapSigma: 9,
   sizeHeavyTapSigma2x: 9,
+  // W30 G2's spanning set for the scale-selective scatter, at the values that
+  // make every term of it exactly zero (claims §5.156 §3, §5.158). The share is
+  // the single gate: at 0 no second heavy texture is allocated, no pass is
+  // encoded and no sample is taken, so the two widths are unread and the
+  // reference is unreachable behind its own zero gain. The two signed amounts
+  // are the scheme-conditioned leaves §5.159 fits; the widths and the reference
+  // are one raster's property and are not.
+  sizeHeavySecondSigma: 0,
+  sizeHeavySecondSigma2x: 0,
+  sizeHeavySecondShare: 0,
+  sizeScatterScaleGain: 0,
+  sizeScatterScaleRef: 0,
   sizeOcclusionGain: 0.05,
   sizeShadowGainMax: 1,
   /*
@@ -906,6 +927,17 @@ var DEFAULT_MATERIAL_PROFILE = {
    */
   collapseTransmission: 0.017,
   collapseTransmission2x: 0.07,
+  /*
+   * **SHIPS AT 0** (W31 G3; claims §5.164). The identity, and a post-seal leaf's
+   * default IS its identity, forever: `MATERIAL_IDENTITY_TABLE` is append-only
+   * and the fingerprint drops this leaf while it holds this value, so a default
+   * that moved off 0 would move every shipped document's digest at once.
+   *
+   * The macOS 27 documents carry their fitted values as patches; the two frozen
+   * macOS 26.5 documents carry none, which is what makes their recorded digests
+   * reproduce under the rule (claims §5.161 §7b).
+   */
+  bodyChromaRetention: 0,
   /*
    * FITTED 0.038 (W23 G1; claims §5.100 §3, W23 Decision Log 2 (b)) — and it is
    * NOT the dark material's rim, which is the one thing the charter thought it
@@ -1079,6 +1111,14 @@ var DEFAULT_MATERIAL_PROFILE = {
   outerShadow: {
     offsetPx: 7.95,
     sigmaPx: 15.55,
+    // W30 G2's σ law, at the three zeros that make it the identity (claims
+    // §5.156 §2, §5.158): σ(span) = sigmaPx + max(0, 0 · (span − 0)) = sigmaPx,
+    // at every span and every scale. The macOS 26.5 material's σ genuinely is
+    // span-invariant — 15.4…15.9 CSS px across spans 32…160 — so these zeros are
+    // that measurement and not a placeholder for it.
+    sigmaSlopePerSpan: 0,
+    sigmaSpanRefPx: 0,
+    sigmaThinOffsetPx: 0,
     spreadPx: 3.1,
     thinOcclusionDark: 0,
     thinOcclusionMid: 0.33,
@@ -1100,6 +1140,90 @@ var DEFAULT_MATERIAL_PROFILE = {
   glowGain: 0.6,
   sweepGain: 0.85
 };
+var MATERIAL_DIGEST_RULE_VERSION = 2;
+var MATERIAL_IDENTITY_TABLE = [
+  {
+    wave: "W30",
+    /*
+     * A TWO-LEAF gate, and the second leaf is in it rather than gated by it.
+     * `sigmaThinOffsetPx` is not gated by the slope — at slope 0 a non-zero
+     * offset moves σ at every span — and it is not inert on its own at a
+     * non-zero slope either, where it is a real floor on the line. What the
+     * committed case proves is the pair TOGETHER, and the grouping that would
+     * put the offset under the slope's gate merges a macOS 26.5 light material
+     * carrying `sigmaThinOffsetPx` 5 — five CSS px of extra blur on every outer
+     * shadow, on both tiers — into the frozen digest itself (claims §5.161 §11,
+     * finding B4 (b)).
+     */
+    gate: { "outerShadow.sigmaSlopePerSpan": 0, "outerShadow.sigmaThinOffsetPx": 0 },
+    gated: ["outerShadow.sigmaSpanRefPx"],
+    law: "\u03C3(span) = sigmaPx + max(sigmaThinOffsetPx, sigmaSlopePerSpan\xB7(span \u2212 sigmaSpanRefPx))",
+    inertLawCase: 'packages/renderer-webgpu/test/w31-gate-groups.test.ts \u2014 "gate-group 1 \u2014 {sigmaSlopePerSpan 0, sigmaThinOffsetPx 0} gates sigmaSpanRefPx"; with the shipped-value half in w30-inert-laws.test.ts',
+    whyGated: "The pivot is multiplied by the slope, so at slope 0 no value of it can reach \u03C3. The offset is NOT gated by the slope and is in the gate for that reason.",
+    claims: "c9a \xA75.156 \xA72, \xA75.158, \xA75.161 \xA77b"
+  },
+  {
+    wave: "W30",
+    gate: { sizeHeavySecondShare: 0 },
+    gated: ["sizeHeavySecondSigma", "sizeHeavySecondSigma2x"],
+    law: "deep = heavy + sizeHeavySecondShare\xB7(heavy2 \u2212 heavy), heavy2 at sizeHeavySecondSigma{,2x}",
+    inertLawCase: 'packages/renderer-webgpu/test/w31-gate-groups.test.ts \u2014 "gate-group 2 \u2014 {sizeHeavySecondShare 0} gates the two second-heavy widths"; with the shipped-value half in w30-inert-laws.test.ts',
+    whyGated: "At share 0 the second heavy texture is not allocated, no pass is encoded and the optics pass never samples one, so the widths are unread whatever they hold.",
+    claims: "c9a \xA75.156 \xA73, \xA75.158, \xA75.161 \xA77b"
+  },
+  {
+    wave: "W30",
+    gate: { sizeScatterScaleGain: 0 },
+    gated: ["sizeScatterScaleRef"],
+    law: "kScatter += sizeScatterScaleGain\xB7(stat \u2212 sizeScatterScaleRef)",
+    inertLawCase: 'packages/renderer-webgpu/test/w31-gate-groups.test.ts \u2014 "gate-group 3 \u2014 {sizeScatterScaleGain 0} gates sizeScatterScaleRef"; with the shipped-value half in w30-inert-laws.test.ts',
+    whyGated: "The reference is only ever read as a difference the gain multiplies, so at gain 0 no value of it can reach the mix. The macOS 27 LIGHT document exercises this entry: it declines the scatter with the gain at 0 and ships the reference at 0.03.",
+    claims: "c9a \xA75.156 \xA73, \xA75.158, \xA75.161 \xA77b"
+  },
+  {
+    wave: "W31",
+    /*
+     * A plain value drop, and injective for free. The retention multiplies the
+     * mix's second term, so at 0 the composite is bit-identical to the one W30
+     * left — which is what the goldens and the composite-identity case below
+     * assert, and what lets this leaf land without an exemption.
+     */
+    gate: { bodyChromaRetention: 0 },
+    gated: [],
+    law: "colour = gamutAtLuma(mix(colour, backdrop\xB7(Y/Y_backdrop), bodyChromaRetention), Y)",
+    inertLawCase: `packages/renderer-webgpu/test/w31-body-chroma.test.ts \u2014 "the composite is bit-identical at retention 0", "linear luma is held at every retention" and "is the shader's expression, term for term"; the drawn half in packages/renderer-webgpu/e2e/gpu/w31-body-chroma.spec.ts \u2014 "is bit-identical at the shipped identity, named explicitly" and "ON draws differently from OFF"; the CSS tier's half in packages/platform-web/test/w30-css-declaration-identity.test.ts, which compares every declaration against bytes recorded before any leaf existed`,
+    whyGated: "Not gated \u2014 a plain value drop. At retention 0 the mix's second term is multiplied by zero and `colour` leaves the composite exactly as mix(backdrop, adapted, presentAlpha) produced it.",
+    claims: "c9a \xA75.161 \xA75, \xA75.164",
+    declaredFirstAs: {
+      law: "colour = renormaliseToLinearLuma(mix(colour, chromaticityOf(backdrop) at colour's luma, bodyChromaRetention))",
+      inertLawCase: "TO BE COMMITTED BY W31 G3 \u2014 the leaf does not exist yet. G0 names the shape and its identity (W31 X2); the case that proves the composite is bit-identical at 0, and the `test:gpu` case that the on state draws differently from off, land with the leaf."
+    }
+  }
+];
+function materialLeafAt(resolved, path) {
+  return path.split(".").reduce((node, key) => node !== null && typeof node === "object" ? node[key] : void 0, resolved);
+}
+function materialDigestDroppedLeaves(resolved) {
+  const dropped = [];
+  for (const entry of MATERIAL_IDENTITY_TABLE) {
+    const held = Object.entries(entry.gate).every(([path, identity]) => {
+      const value = materialLeafAt(resolved, path);
+      return value !== void 0 && value === identity;
+    });
+    if (held)
+      dropped.push(...Object.keys(entry.gate), ...entry.gated);
+  }
+  return dropped.sort();
+}
+function materialDigestInput(resolved) {
+  const dropped = materialDigestDroppedLeaves(resolved);
+  const strip = (value, prefix = "") => {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+      return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [prefix === "" ? key : `${prefix}.${key}`, key, child]).filter(([path]) => !dropped.includes(path)).map(([path, key, child]) => [key, strip(child, path)]));
+  };
+  return strip(resolved);
+}
 var REFRACTION_SCALE = DEFAULT_MATERIAL_PROFILE.refractionScale;
 var MATERIAL_OPTICS = DEFAULT_MATERIAL_PROFILE.optics;
 var ADAPTIVE_TINT_DARK = DEFAULT_MATERIAL_PROFILE.adaptiveTintDark;
@@ -1220,6 +1344,14 @@ function withMaterialOverrides(base, patch) {
     sizeToneLevelFar: patch.sizeToneLevelFar ?? base.sizeToneLevelFar,
     sizeHeavyTapSigma: patch.sizeHeavyTapSigma ?? base.sizeHeavyTapSigma,
     sizeHeavyTapSigma2x: patch.sizeHeavyTapSigma2x ?? base.sizeHeavyTapSigma2x,
+    // W30 G2's spanning set. One line each, because this merge is explicit per
+    // leaf and a leaf without its own line resolves silently to the base —
+    // which for a leaf a document is meant to fit is a fit that does nothing.
+    sizeHeavySecondSigma: patch.sizeHeavySecondSigma ?? base.sizeHeavySecondSigma,
+    sizeHeavySecondSigma2x: patch.sizeHeavySecondSigma2x ?? base.sizeHeavySecondSigma2x,
+    sizeHeavySecondShare: patch.sizeHeavySecondShare ?? base.sizeHeavySecondShare,
+    sizeScatterScaleGain: patch.sizeScatterScaleGain ?? base.sizeScatterScaleGain,
+    sizeScatterScaleRef: patch.sizeScatterScaleRef ?? base.sizeScatterScaleRef,
     sizeOcclusionGain: patch.sizeOcclusionGain ?? base.sizeOcclusionGain,
     sizeShadowGainMax: patch.sizeShadowGainMax ?? base.sizeShadowGainMax,
     lensRefractionGain: patch.lensRefractionGain ?? base.lensRefractionGain,
@@ -1256,6 +1388,7 @@ function withMaterialOverrides(base, patch) {
     backdropToneSizeBias: patch.backdropToneSizeBias ?? base.backdropToneSizeBias,
     collapseTransmission: patch.collapseTransmission ?? base.collapseTransmission,
     collapseTransmission2x: patch.collapseTransmission2x ?? patch.collapseTransmission ?? base.collapseTransmission2x,
+    bodyChromaRetention: patch.bodyChromaRetention ?? base.bodyChromaRetention,
     rimCollapsed: patch.rimCollapsed ?? base.rimCollapsed,
     rimCollapsedTinted: patch.rimCollapsedTinted ?? base.rimCollapsedTinted,
     rimTintChroma: patch.rimTintChroma ?? base.rimTintChroma,
@@ -1554,6 +1687,11 @@ function scatterHeavyShareThickAtScale(profile = DEFAULT_MATERIAL_PROFILE, devic
 function heavyTapSigmaAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
   return rampAtScale(profile.sizeHeavyTapSigma, profile.sizeHeavyTapSigma2x, devicePixelRatio);
 }
+function heavySecondTapSigmaAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  if (profile.sizeHeavySecondShare === 0)
+    return 0;
+  return rampAtScale(profile.sizeHeavySecondSigma, profile.sizeHeavySecondSigma2x, devicePixelRatio);
+}
 function sizeToneLevelFar(spanPx, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1, fold = 1) {
   return profile.sizeToneLevelFar * smoothstep(profile.sizeSpanMax, scatterSpanMaxAtScale(profile, devicePixelRatio), spanPx) * fold;
 }
@@ -1695,20 +1833,24 @@ function flatOuterShadow(shadow, amplitude) {
 var SRGB_ENCODING_EXPONENT = 2.4;
 function outerShadowFalloff(signedDistancePx, sigmaPx) {
   const x = -signedDistancePx / Math.max(sigmaPx, 1e-4);
-  return 0.5 * (1 + Math.tanh(0.7978845608028654 * (x + 0.044715 * x * x * x)));
+  const t = Math.min(20, Math.max(-20, 0.7978845608028654 * (x + 0.044715 * x * x * x)));
+  return 0.5 * (1 + Math.tanh(t));
+}
+function outerShadowSigmaPx(shadow, spanPx) {
+  return shadow.sigmaPx + Math.max(shadow.sigmaThinOffsetPx, shadow.sigmaSlopePerSpan * (spanPx - shadow.sigmaSpanRefPx));
 }
 function outerShadowAlpha(occlusion) {
   const occ = Math.min(1, Math.max(0, occlusion));
   return 1 - Math.pow(1 - occ, 1 / SRGB_ENCODING_EXPONENT);
 }
-function outerShadowReachPx(shadow, occlusion) {
+function outerShadowReachPx(shadow, occlusion, spanPx) {
   const alpha = outerShadowAlpha(occlusion);
   if (!(alpha > 0))
     return 0;
   const cutoff = 1 / 255 / alpha;
   if (cutoff >= 1)
     return 0;
-  const sigma = Math.max(shadow.sigmaPx, 1e-4);
+  const sigma = Math.max(outerShadowSigmaPx(shadow, spanPx), 1e-4);
   let lo = -(8 * sigma + Math.abs(shadow.offsetPx) + Math.abs(shadow.spreadPx));
   let hi = 8 * sigma;
   for (let i = 0; i < 48; i += 1) {
@@ -2570,6 +2712,10 @@ var poolKey = {
   /** The heavy blur and its scratch (W26) — the body's pair, one width deeper. */
   backdropHeavy: (sourceId) => `backdrop:${sourceId}:heavy`,
   backdropHeavyScratch: (sourceId) => `backdrop:${sourceId}:heavy-scratch`,
+  /** The SECOND heavy blur and its scratch (W30 G2) — the same pair, one more
+   * width along, acquired only where `sizeHeavySecondShare` is non-zero. */
+  backdropHeavy2: (sourceId) => `backdrop:${sourceId}:heavy2`,
+  backdropHeavy2Scratch: (sourceId) => `backdrop:${sourceId}:heavy2-scratch`,
   backdropUpload: (sourceId) => `backdrop:${sourceId}:upload`,
   /*
    * The four field targets. Their key is a group's RESOURCE identity — the id
@@ -3481,9 +3627,26 @@ const TAU = 6.283185307179586;
 
 /// Shortest angular distance, so the band wraps continuously past the seam
 /// instead of stalling there for one revolution.
+///
+/// THE RESULT IS FLOORED AT ZERO, AND THE FLOOR IS THE IDENTITY (W31 G2; claims
+/// 5.163). A distance is non-negative, and this expression is only non-negative
+/// while 'raw' stays inside one revolution: past 'TAU' the second branch goes
+/// negative and 'min' takes it. The single caller squares the quotient through
+/// 'pow(x, 2.0)', whose base WGSL leaves UNDEFINED below zero \u2014 the same shape
+/// of defect as 5.159b's 'tanh', one function along. Both arguments are angles
+/// only while the sweep phase is inside [0, 1], and the phase is read off a CSS
+/// custom property that nothing clamps (platform-web's 'readHostChannels'
+/// clamps 'materialization' and not 'sweep'), so '--vitrea-sweep: 3' puts the
+/// centre at 3 TAU and this function at -12.6 radians. 'max(., 0)' returns the
+/// same bits at every input the unfloored form was defined at, so no pixel any
+/// material or any bed reaches moves; what it removes is the undefined one.
+/// Where the phase IS out of range the band is now centred on the pixel rather
+/// than NaN, which is a defensible reading of nothing in particular \u2014 wrapping
+/// the phase where it is read is the fix that would make it mean something, and
+/// it is outside this gate's contract.
 fn angle_delta(a : f32, b : f32) -> f32 {
   let raw = abs(a - b);
-  return min(raw, TAU - raw);
+  return max(min(raw, TAU - raw), 0.0);
 }
 
 @fragment
@@ -3736,6 +3899,36 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   toneExtra : vec4f,
   /// W28: whether the per-surface reference field is present (x).
   localTone : vec4f,
+  /// W30's span-graded shadow sigma (claims 5.156 section 2): the law's slope
+  /// in CSS px of sigma per CSS px of casting span (x), the reference span it
+  /// pivots about (y) and the signed floor it is clamped below at, as an offset
+  /// from 'shadow.y' (z). (w) free. At the shipped zeros this evaluates to
+  /// 'shadow.y' at every span, identically, which is why the 34 goldens do not
+  /// move. No device ratio: the cut rejected the device-px reading of the thin
+  /// regime, so the law is one function of CSS span on both tiers.
+  shadowSigma : vec4f,
+  /// W30's scale-selective scatter, candidate (ii) (claims 5.156 section 3): the
+  /// gain on 'kScatter' per unit of the source's measured scale statistic (x),
+  /// the reference that statistic is measured about (y), and the statistic
+  /// itself for THIS group's source (z) \u2014 the analysis pass's edge density,
+  /// resolved on the CPU because it arrives by readback. (w) free.
+  scatterScale : vec4f,
+  /// W30's scale-selective scatter, candidate (i) (claims 5.156 section 3): the
+  /// second heavy sample's SIGNED share in the deep mix (x), and whether this
+  /// group's source carries a second heavy texture at all (y) \u2014 1 where the
+  /// pyramid built one, 0 where the share declined it. A vec4 of its own rather
+  /// than two lanes in the layout above, on 'heavyTap's precedent: a width's
+  /// switch living in another facet's spare lane is a layout nobody could read
+  /// back. (z) and (w) free.
+  scatterHeavy2 : vec4f,
+  /// W31's body chroma retention (claims 5.161 section 5, 5.164): how much of
+  /// the blurred backdrop's CHROMATICITY the body restores, at the luma the
+  /// tone solve produced (x). A vec4 of its own on W30's rule \u2014 132 is the next
+  /// vec4 boundary and an operator packed into the block above would read two
+  /// of its neighbour's lanes. (y), (z) and (w) free. At the shipped 0 the mix
+  /// below is multiplied by zero and the composite is bit-identical to the one
+  /// W30 left, which is why the 34 goldens do not move.
+  bodyChroma : vec4f,
 };
 
 @group(0) @binding(0) var<uniform> ou : OpticsUniforms;
@@ -3760,6 +3953,15 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
 @group(0) @binding(9) var presenceTexture : texture_2d<f32>;
 @group(0) @binding(10) var localToneTexture : texture_2d<f32>;
 
+/// The SECOND heavy blur (W30 G2) \u2014 the same construction one width along, and
+/// read only where 'scatterHeavy2.y' says the pyramid built one. A bind group's
+/// layout is one layout, so the slot exists at every draw and the placeholder
+/// view stands in it where the material declined the operator; what costs
+/// nothing at the inert share is the allocation and the two separable passes,
+/// which is where the price of this mechanism actually is (W26 Decision Log
+/// 2 (b)).
+@group(0) @binding(11) var backdropHeavy2 : texture_2d<f32>;
+
 /// One encoded sRGB channel from a linear one \u2014 the space the backdrop tone
 /// response's anchors live in (W9). Mirrors material.ts's 'linearToSrgbChannel'.
 fn srgb_encode(c : f32) -> f32 {
@@ -3846,9 +4048,47 @@ fn rim_weight(d : f32, width : f32) -> f32 {
 /// normal CDF \u2014 WGSL has no erf, and this is within 1.8e-4 of it everywhere,
 /// which is 0.015 of one 8-bit code at the shipped occlusion. Mirrors
 /// material.ts's 'outerShadowFalloff' term for term.
+///
+/// THE ARGUMENT IS CLAMPED, AND THE CLAMP IS THE IDENTITY (W30 G3b; claims
+/// 5.159b, corrected at 5.159b section 10). 'tanh' saturates to exactly 1.0 in
+/// f32 by |t| = 9.011 and in f64 by |t| = 19.061547465398498 \u2014 measured, not
+/// 18.2, which the first recording of this comment said and which is the last
+/// magnitude that still returns 1 - 1e-16. Either way 20 is above both, so
+/// replacing every |t| > 20 with 20 returns the same bits in both precisions at
+/// every input the unclamped form evaluates finitely; the bound has 0.94 of
+/// margin over f64 rather than 1.8, which is what the corrected reading
+/// changes. What it
+/// removes is a NaN: a backend that lowers 'tanh' to (exp(2t) - 1)/(exp(2t) + 1)
+/// \u2014 which Metal's fast-math path does \u2014 overflows f32's 'exp' at 2t > 88.72 and
+/// hands back Inf/Inf. The cubic makes that threshold reachable at a modest
+/// distance: t passes 44.36 at x ~ 10.06, so any pixel more than about 10 sigma
+/// inside the shadow's silhouette returned NaN, and the NaN travelled into the
+/// composite's alpha through 'shadowAlpha * (1 - coverage)', where a coverage of
+/// exactly 1 does not stop it (NaN times 0 is NaN). At every sigma the project
+/// had shipped, 10 sigma was further than any caster is deep and nothing reached
+/// it; macOS 27's thin regime draws sigma 2.13 at a span-44 caster, where 10
+/// sigma is 21.4 CSS px and a 44 px capsule's own centre line is 25 CSS px
+/// inside its silhouette \u2014 which is the strip 5.159 section 6 measured.
 fn outer_shadow_falloff(signedDistance : f32, sigma : f32) -> f32 {
   let x = -signedDistance / max(sigma, 1e-4);
-  return 0.5 * (1.0 + tanh(0.7978845608028654 * (x + 0.044715 * x * x * x)));
+  let t = clamp(0.7978845608028654 * (x + 0.044715 * x * x * x), -20.0, 20.0);
+  return 0.5 * (1.0 + tanh(t));
+}
+
+/// The outer shadow's sigma at a casting span, CSS px (W30 G2; claims 5.156
+/// section 2). Mirrors material.ts's 'outerShadowSigmaPx' term for term:
+///
+///   sigma(span) = shadow.y + max(shadowSigma.z, shadowSigma.x * (span - shadowSigma.y))
+///
+/// Read PER PIXEL from the CASTING surface's own span, which the field pass has
+/// already unioned into the aux target \u2014 the span this shader has been reading
+/// the thick regime's amplitude from since W14 G1, now read twice. At the
+/// shipped zeros both arms of the max are zero and this is 'ou.shadow.y'
+/// exactly, for every span, which makes the law's landing a no-op on every
+/// existing pixel by construction rather than by measurement.
+fn outer_shadow_sigma(spanCss : f32) -> f32 {
+  return ou.shadow.y
+    + max(ou.shadowSigma.z, ou.shadowSigma.x * (spanCss - ou.shadowSigma.y));
 }
 
 /// What one pixel's outer shadow is made of: the compositing-space alpha the
@@ -3971,7 +4211,10 @@ fn outer_shadow(uv : vec2f, upsampled : f32, fieldSize : vec2f) -> ShadowSample
   // Times the casting surface's presence (W27d): a material that is not there
   // occludes nothing. At presence 1 this is the alpha the bed measures.
   out.alpha = (1.0 - pow(1.0 - occ, 1.0 / 2.4)) * castMat;
-  out.falloff = outer_shadow_falloff(shadowField.x + clampedOffCss - ou.shadow.z, ou.shadow.y);
+  out.falloff = outer_shadow_falloff(
+    shadowField.x + clampedOffCss - ou.shadow.z,
+    outer_shadow_sigma(shadowAux.z),
+  );
   out.castSpanCss = shadowAux.z;
   out.castMat = castMat;
   return out;
@@ -4059,6 +4302,54 @@ fn dom_material_output(encodedComposite : vec3f, encodedBackdrop : vec3f, alpha
   return vec4f(clamp(c - b * (1.0 - a), vec3f(0.0), vec3f(a)), a);
 }
 
+/// W31 \u2014 the body's chroma retention, at a held linear luma (claims 5.161
+/// section 5, fitted in 5.164).
+///
+/// The body is a neutral plate over the blurred backdrop, so what a
+/// photograph's hues survive the composite at is '1 - sizedAlpha'. This
+/// restores the colour's CHROMATICITY toward the blurred backdrop's, carried to
+/// the colour's OWN linear luma, by the material's retention.
+///
+/// **Luma is held by construction rather than by correction.** Both endpoints
+/// of the mix have linear luma exactly 'Y' \u2014 'colour' by definition and
+/// 'target' because it is the backdrop scaled to 'Y' \u2014 and linear luma is a
+/// linear functional, so the mix has luma 'Y' in exact arithmetic. The
+/// renormalisation afterwards is an f32 rounding guard and nothing else.
+///
+/// Gamut by scaling chroma toward the neutral AT that luma, never by clipping
+/// per channel: a per-channel clamp moves the level, which is the one thing
+/// this operator may not do.
+///
+/// The retention is the identity outside 'Y' in (1e-6, 1], which is a
+/// finiteness guard rather than a restriction: 'backdrop' and 'adapted' are both
+/// in [0, 1] and 'presentAlpha' is in [0, 1], so their mix is too. Writing it as
+/// a branch on the retention as well makes the identity at 0 EXACT \u2014 no
+/// division, no rounding, the composite left as it arrived.
+fn gamut_at_luma(c : vec3f, Y : f32) -> vec3f {
+  var t = 1.0;
+  for (var i = 0u; i < 3u; i = i + 1u) {
+    let d = c[i] - Y;
+    if (d > 1e-7) { t = min(t, (1.0 - Y) / d); }
+    else if (d < -1e-7) { t = min(t, -Y / d); }
+  }
+  return mix(vec3f(Y), c, clamp(t, 0.0, 1.0));
+}
+
+fn body_chroma_retention(colour : vec3f, backdrop : vec3f, retention : f32) -> vec3f {
+  if (retention <= 0.0) { return colour; }
+  let W = vec3f(0.2126, 0.7152, 0.0722);
+  let Y = dot(colour, W);
+  if (!(Y > 1e-6 && Y <= 1.0)) { return colour; }
+  let Yb = dot(backdrop, W);
+  if (Yb <= 1e-6) { return colour; }
+  // 'toward' and not 'target': WGSL reserves the latter.
+  let toward = backdrop * (Y / Yb);
+  var restored = mix(colour, toward, clamp(retention, 0.0, 1.0));
+  let Yr = dot(restored, W);
+  if (Yr > 1e-6) { restored = restored * (Y / Yr); }
+  return gamut_at_luma(restored, Y);
+}
+
 @fragment
 fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // Nominally the field is one texel per device pixel, so the read is an exact
@@ -4296,7 +4587,24 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   let rampStart = ou.scatter.y + (ou.shadowSize.z - ou.scatter.y) * sizeThick
     + (ou.shadowThick.w - ou.shadowSize.z) * farS;
   let sharpShare = clamp(sDeep + max(rampStart - sDeep, 0.0) * rampT, 0.0, 1.0);
-  let kScatter = clamp(scatterFloor + ((1.0 - sharpShare) - scatterFloor) * fold, 0.0, 1.0);
+  let kScatterSpan = clamp(scatterFloor + ((1.0 - sharpShare) - scatterFloor) * fold, 0.0, 1.0);
+  /*
+   * W30's scale conditioning, candidate (ii) (claims 5.156 section 3): the deep
+   * component's share moves with the BACKDROP's own spatial scale and not only
+   * with the surface's span, which is what a residual that changes sign between
+   * a 4 px pitch and a 16 px one needs. The statistic is the analysis pass's
+   * per-source edge density, a reciprocal length; it arrives by readback, so the
+   * CPU puts it in 'scatterScale.z' and the law is evaluated here.
+   *
+   * At the shipped gain of 0 the added term is a multiplied zero and the clamp
+   * is the identity on a value already clamped to the same interval, so this is
+   * 'kScatterSpan' to the bit.
+   */
+  let kScatter = clamp(
+    kScatterSpan + ou.scatterScale.x * (ou.scatterScale.z - ou.scatterScale.y),
+    0.0,
+    1.0,
+  );
   // The inner shadow's depth and profile: W2's law, byte for byte \u2014 the
   // thickness times the size gain (folded through 'sizeK'), clamped to the
   // shorter half extent, and a square on it. The lens ran on this until W12 G2;
@@ -4406,7 +4714,25 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
     // Premultiplied linear in, straight colour out: the material composites over
     // whatever is behind it, so a partially transparent backdrop must not darken
     // the glass.
-    let scatterColour = scatterSample.rgb / max(scatterSample.a, 1e-6);
+    var scatterColour = scatterSample.rgb / max(scatterSample.a, 1e-6);
+    /*
+     * W30's second heavy tap, candidate (i) (claims 5.156 section 3): a second
+     * texture at its own width, mixed into the deep sample by a SIGNED share.
+     * A positive share widens the deep component toward that width; a negative
+     * one subtracts it, which is an unsharp mask on the backdrop and the only
+     * shape on offer that passes the middle pitch LESS than both ends \u2014 a mix of
+     * two positive Gaussians is monotone in frequency and cannot.
+     *
+     * Gated on whether the pyramid built one, which it does only where
+     * 'sizeHeavySecondShare' is non-zero. At the inert share the branch is not
+     * taken, nothing is allocated and nothing is sampled, which is the state the
+     * 34 goldens render.
+     */
+    if (ou.scatterHeavy2.y > 0.5) {
+      let second = textureSampleLevel(backdropHeavy2, backdropSampler, refractedUv, 0.0);
+      let secondColour = second.rgb / max(second.a, 1e-6);
+      scatterColour = scatterColour + ou.scatterHeavy2.x * (secondColour - scatterColour);
+    }
     backdrop = mix(bodySample.rgb / max(bodySample.a, 1e-6), scatterColour, kScatter);
     /*
      * The body's own half of the presence (W27d): a material at half presence
@@ -4605,6 +4931,56 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
    */
   let presentAlpha = adaptedAlpha * mat;
   var colour = mix(backdrop, adapted, presentAlpha);
+  /*
+   * W31's chroma retention, HERE and not later (claims 5.161 section 5).
+   *
+   * Immediately after the composite, because the composite is where the
+   * chroma is lost \u2014 the plate is neutral and the backdrop's chromaticity
+   * survives it scaled by '1 - presentAlpha'. Before the tint composition
+   * below, so an author's tint still displaces the result per the composition
+   * contract; the tint's shade law reads the untinted material's LUMINANCE,
+   * which this preserves exactly, so 'shade', 'layer' and 'rimTintColour' are
+   * bit-identical whatever the retention holds.
+   *
+   * Before the DOM branch as well, so the secant that solves an unsampled DOM
+   * group's layer alpha solves it from the material the page will actually
+   * show. That branch is NOT luma-transparent \u2014 'dom_material_alpha' clamps per
+   * channel inside a luma computation \u2014 so an unsampled DOM GROUP'S layer alpha
+   * may move with the retention where a sampled composite does not (claims
+   * 5.161 section 11, the second reading carried forward).
+   *
+   * That sentence said "the 'dom' tier", which is a different thing and is the
+   * thing a reader will think of first (W31 G3c review closure; claims 5.164
+   * section 13, finding N7). The 'dom' tier is the CSS tier, the one the
+   * calibration matrix keys under that name, and it does not run this shader at
+   * all; what is meant here is THIS shader's unsampled-material path, where a
+   * group with no sampled backdrop writes a layer for the browser to composite.
+   *
+   * And on that path what the operator restores TOWARD is not the page's
+   * backdrop, because nothing sampled it. 'dom_material_backdrop()' fabricates
+   * one, and it has two modes. Mode 1, which a group with no declared
+   * 'backdropTone' takes, returns 'vec3f(ou.heavyTap.z)' \u2014 a neutral at the
+   * declared reference luminance \u2014 so the mix target is
+   * 'backdrop * (Y / Yb)' = 'vec3f(Y)', the neutral at the colour's own luma.
+   * That reads as a desaturation and is the IDENTITY in effect: on that path
+   * 'adapted' is 'solvedNeutral' and the fabricated backdrop is a grey, so the
+   * composite has no chromaticity for the target to differ from. Measured at
+   * three retentions up to 1: zero bytes moved
+   * ('e2e/gpu/w31-unsampled-dom-chroma.spec.ts').
+   *
+   * Mode 2 hands the DECLARED tone colour, which can be chromatic, and there
+   * the operator runs \u2014 the body takes the hue the page STATED is behind it
+   * rather than the hue that is. That is the residual, recorded in claims 5.164
+   * section 10, and it is a statement about the target rather than about the
+   * amount: the same spec reads the interior's chroma from 0.066 to 0.334 and
+   * finds the gamut clamp binding at the shipped retention already.
+   *
+   * On the unsampled LAYER path ('flags.x <= 0.5' and not 'domMaterial')
+   * 'colour' is overwritten with 'adapted' a few lines below: there is no
+   * backdrop in hand and no chromaticity to restore toward, and the retention is
+   * silently the identity. That is a declared residual, not an oversight.
+   */
+  colour = body_chroma_retention(colour, backdrop, ou.bodyChroma.x);
   /*
    * How much of this pixel the SURFACE owns, as the canvas will composite it.
    *
@@ -4978,7 +5354,13 @@ var WGSL_PRELUDE = `// vitrea:wgsl-marker
 
 fn srgb_to_linear(c : vec3f) -> vec3f {
   let lo = c / 12.92;
-  let hi = pow((c + vec3f(0.055)) / 1.055, vec3f(2.4));
+  // The floor is the identity at every component the select below KEEPS: it
+  // keeps hi only where c > 0.04045, and there the base is already above 0.0905.
+  // Below zero the base is a pow WGSL leaves undefined, and a clamp in the
+  // source is preferred to a proof of the select's discard (W31 G2 review
+  // closure, claims \xA75.163 \xA78, finding N8). Same shape as linear_to_srgb's own
+  // max, one line down.
+  let hi = pow(max((c + vec3f(0.055)) / 1.055, vec3f(0.0)), vec3f(2.4));
   return select(hi, lo, c <= vec3f(0.04045));
 }
 
@@ -5359,7 +5741,7 @@ function createPassRunner(context) {
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.resourceId}`, 120);
+      const slot = uniformSlot(`optics:${args.resourceId}`, 136);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -5478,10 +5860,27 @@ function createPassRunner(context) {
       d[114] = args.backdropToneResponseThick[3] ?? args.backdropToneResponseThick[2];
       d[115] = args.backdropToneAnchorX.length === 4 ? 1 : 0;
       d[116] = args.localTone === void 0 ? 0 : 1;
+      d[120] = args.outerShadowSigmaLaw[0];
+      d[121] = args.outerShadowSigmaLaw[1];
+      d[122] = args.outerShadowSigmaLaw[2];
+      d[123] = 0;
+      d[124] = args.sizeScatterScaleGain;
+      d[125] = args.sizeScatterScaleRef;
+      d[126] = args.backdropScaleStatistic;
+      d[127] = 0;
+      d[128] = args.sizeHeavySecondShare;
+      d[129] = args.heavySecondEnabled ? 1 : 0;
+      d[130] = 0;
+      d[131] = 0;
+      d[132] = args.bodyChromaRetention;
+      d[133] = 0;
+      d[134] = 0;
+      d[135] = 0;
       slot.write();
       const chain = args.backdrop?.chain ?? placeholderView;
       const body = args.backdrop?.body ?? placeholderView;
       const heavy = args.backdrop?.heavy ?? placeholderView;
+      const heavy2 = args.backdrop?.heavy2 ?? placeholderView;
       const pipeline = opticsPipeline(args.targetFormat);
       const pass = encoder.beginRenderPass({
         label: `vitrea:pass:optics:${args.resourceId}`,
@@ -5505,7 +5904,8 @@ function createPassRunner(context) {
           { binding: 7, resource: args.fields.aux2.createView() },
           { binding: 8, resource: heavy },
           { binding: 9, resource: args.fields.presence.createView() },
-          { binding: 10, resource: args.localTone ?? placeholderView }
+          { binding: 10, resource: args.localTone ?? placeholderView },
+          { binding: 11, resource: heavy2 }
         ]
       }));
       pass.draw(3);
@@ -5763,7 +6163,7 @@ var chainUsage = () => GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTU
 var densityOf = (source, request) => texelsPerCssPx(source.width, source.height, request.placement, request.viewportCss[0], request.viewportCss[1]);
 var same = (next, existing) => Math.abs(next - existing) <= 1e-6 * Math.max(1, Math.abs(existing));
 var sameHeavySigma = (next, existing) => next > 0 === existing > 0 && same(next, existing);
-var sameBody = (existing, request) => same(densityOf({ width: existing.sourceWidth, height: existing.sourceHeight }, request), existing.texelsPerCss) && same(request.bodySigmaCss, existing.bodySigmaCss) && sameHeavySigma(request.heavySigmaCss, existing.heavySigmaCss);
+var sameBody = (existing, request) => same(densityOf({ width: existing.sourceWidth, height: existing.sourceHeight }, request), existing.texelsPerCss) && same(request.bodySigmaCss, existing.bodySigmaCss) && sameHeavySigma(request.heavySigmaCss, existing.heavySigmaCss) && sameHeavySigma(request.heavy2SigmaCss, existing.heavy2SigmaCss);
 function createPyramidStore(context) {
   const { device, pool, cache } = context;
   const resources = /* @__PURE__ */ new Map();
@@ -5839,10 +6239,13 @@ function createPyramidStore(context) {
     if (target.heavy !== void 0 && pool.peek(poolKey.backdropHeavy(sourceId)) !== target.heavy) {
       return void 0;
     }
+    if (target.heavy2 !== void 0 && pool.peek(poolKey.backdropHeavy2(sourceId)) !== target.heavy2) {
+      return void 0;
+    }
     return target;
   };
   const mipView = (texture, level) => texture.createView({ baseMipLevel: level, mipLevelCount: 1, dimension: "2d" });
-  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch, bodySigmaTexels, density, bodySigmaCss, heavyLevel, heavySigmaCss) {
+  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch, bodySigmaTexels, density, bodySigmaCss, heavyLevel, heavySigmaCss, heavy2Level, heavy2SigmaCss) {
     const existing = resources.get(sourceId);
     const levelSize = (level) => plan.levels[level] ?? plan.levels[0];
     const bodyWidth = levelSize(bodyLevel).width;
@@ -5875,6 +6278,19 @@ function createPyramidStore(context) {
         label: `vitrea:pyramid:${sourceId}:heavy`
       });
     }
+    let heavy2;
+    if (heavy2Level === void 0) {
+      pool.release(poolKey.backdropHeavy2(sourceId));
+      pool.release(poolKey.backdropHeavy2Scratch(sourceId));
+    } else {
+      heavy2 = pool.acquire(poolKey.backdropHeavy2(sourceId), {
+        width: levelSize(heavy2Level).width,
+        height: levelSize(heavy2Level).height,
+        format: WORKING_TEXTURE_FORMAT,
+        usage: chainUsage(),
+        label: `vitrea:pyramid:${sourceId}:heavy2`
+      });
+    }
     let stats = existing?.stats;
     if (stats === void 0) {
       stats = device.createBuffer({
@@ -5883,7 +6299,7 @@ function createPyramidStore(context) {
         usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
       });
     }
-    if (existing === void 0 || existing.chain !== chain || existing.body !== body || existing.heavy !== heavy) {
+    if (existing === void 0 || existing.chain !== chain || existing.body !== body || existing.heavy !== heavy || existing.heavy2 !== heavy2) {
       reallocations += 1;
     }
     const next = {
@@ -5892,6 +6308,7 @@ function createPyramidStore(context) {
       chain,
       body,
       heavy,
+      heavy2,
       stats,
       sizeEpoch,
       builtEpoch,
@@ -5900,7 +6317,8 @@ function createPyramidStore(context) {
       sourceWidth: density.sourceWidth,
       sourceHeight: density.sourceHeight,
       bodySigmaCss,
-      heavySigmaCss
+      heavySigmaCss,
+      heavy2SigmaCss
     };
     resources.set(sourceId, next);
     return next;
@@ -5984,7 +6402,7 @@ function createPyramidStore(context) {
   function runSeparableBlur(encoder, sourceId, kind, plan, chain, target, level, residualSigmaTexels) {
     const pipeline = chainPipeline("fs_blur");
     const size = plan.levels[level] ?? plan.levels[0];
-    const scratchKey = kind === "body" ? poolKey.backdropBodyScratch(sourceId) : poolKey.backdropHeavyScratch(sourceId);
+    const scratchKey = kind === "body" ? poolKey.backdropBodyScratch(sourceId) : kind === "heavy" ? poolKey.backdropHeavyScratch(sourceId) : poolKey.backdropHeavy2Scratch(sourceId);
     const scratch = pool.acquire(scratchKey, {
       width: size.width,
       height: size.height,
@@ -6112,13 +6530,17 @@ function createPyramidStore(context) {
       const bodySigmaTexels = request.bodySigmaCss * texelsPerCss * planScale;
       const bodyPlan = bodyBlurPlan(bodySigmaTexels, plan);
       const heavyPlan = request.heavySigmaCss > 0 ? heavyTapPlan(request.heavySigmaCss * texelsPerCss * planScale, plan) : void 0;
-      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels, { texelsPerCss, sourceWidth: frame.width, sourceHeight: frame.height }, request.bodySigmaCss, heavyPlan?.level, request.heavySigmaCss);
+      const heavy2Plan = request.heavy2SigmaCss > 0 ? heavyTapPlan(request.heavy2SigmaCss * texelsPerCss * planScale, plan) : void 0;
+      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels, { texelsPerCss, sourceWidth: frame.width, sourceHeight: frame.height }, request.bodySigmaCss, heavyPlan?.level, request.heavySigmaCss, heavy2Plan?.level, request.heavy2SigmaCss);
       runImport(encoder, request.sourceId, frame, target.chain);
       runChain(encoder, request.sourceId, plan, target.chain);
       runSeparableBlur(encoder, request.sourceId, "body", plan, target.chain, target.body, bodyPlan.level, bodyPlan.residualSigmaTexels);
       if (heavyPlan !== void 0 && target.heavy !== void 0) {
         runSeparableBlur(encoder, request.sourceId, "heavy", plan, target.chain, target.heavy, heavyPlan.level, heavyPlan.residualSigmaTexels);
       }
+      if (heavy2Plan !== void 0 && target.heavy2 !== void 0) {
+        runSeparableBlur(encoder, request.sourceId, "heavy2", plan, target.chain, target.heavy2, heavy2Plan.level, heavy2Plan.residualSigmaTexels);
+      }
       runAnalysis(encoder, request.sourceId, plan, target.chain, target.stats);
       provider.markImported();
       return { status: "built", resources: target };
@@ -6615,7 +7037,8 @@ function createWebGPURenderer(options = {}) {
       const sigmaCss = bodySigmaCssFor(sourceId);
       const sameSigma = Math.abs(sigmaCss - existing.bodySigmaCss) <= 1e-6 * Math.max(1, existing.bodySigmaCss);
       const sameHeavy = sameHeavySigma(heavySigmaCssFor(sourceId), existing.heavySigmaCss);
-      if (sameDensity && sameSigma && sameHeavy)
+      const sameHeavy2 = sameHeavySigma(heavySecondSigmaCssFor(sourceId), existing.heavy2SigmaCss);
+      if (sameDensity && sameSigma && sameHeavy && sameHeavy2)
         continue;
       requests.push({
         sourceId,
@@ -6641,6 +7064,11 @@ function createWebGPURenderer(options = {}) {
       return 0;
     return heavyTapSigmaAtScale(material, viewport.devicePixelRatio) / Math.max(viewport.devicePixelRatio, 1e-3);
   };
+  const heavySecondSigmaCssFor = (sourceId) => {
+    if (bodySigmaCssFor(sourceId) <= 0)
+      return 0;
+    return heavySecondTapSigmaAtScale(material, viewport.devicePixelRatio);
+  };
   const groupTintSeed = (input) => input.surfaces.find((surface) => drawsMaterial(surface) && (surface.tint?.strength ?? 0) > 0)?.tint?.color;
   const stateOf = (input, resolution) => {
     const resolved = resolution?.groups.find((group) => group.groupId === input.groupId);
@@ -6710,6 +7138,10 @@ function createWebGPURenderer(options = {}) {
         // The heavy blur's own σ, through the same conversion (W26). At 0 the
         // pyramid allocates nothing and encodes nothing.
         heavySigmaCss: heavySigmaCssFor(request.sourceId),
+        // The second heavy blur's σ (W30 G2). At 0 — the landed material —
+        // the pyramid allocates nothing and encodes nothing, exactly as for
+        // the first one.
+        heavy2SigmaCss: heavySecondSigmaCssFor(request.sourceId),
         viewportCss: [viewport.widthCss, viewport.heightCss],
         ...isUsablePlacement(placement) ? { placement } : {}
       }, provider, encoder);
@@ -6772,10 +7204,12 @@ function createWebGPURenderer(options = {}) {
       const shadow = outerShadowUnderPolicy(policy, material);
       const shadowBackdropLuminance = input.backdropTone === void 0 ? void 0 : input.backdropToneLevel ?? relativeLuminance(input.backdropTone);
       let reachOcclusion = outerShadowThinOcclusion(shadowBackdropLuminance, shadow);
+      let reachSpanPx = 0;
       for (const surface of surfaces) {
         reachOcclusion = Math.max(reachOcclusion, outerShadowOcclusionAt(shadow, shadowBackdropLuminance, surface.spanPx, surface.sizeThickness, material));
+        reachSpanPx = Math.max(reachSpanPx, surface.spanPx);
       }
-      const shadowReachPx = outerShadowReachPx(shadow, reachOcclusion);
+      const shadowReachPx = outerShadowReachPx(shadow, reachOcclusion, reachSpanPx);
       const snapped = snapRectToDevicePixels(groupFieldRect(surfaces, union, void 0, shadowReachPx), dpr);
       const rectDevice = clipFieldRectToCanvas(snapped, dpr, viewportDevice);
       if (rectDevice === void 0) {
@@ -6955,6 +7389,53 @@ function createWebGPURenderer(options = {}) {
         // itself is already in the texture, so this pass only chooses which of
         // two textures the deep sample comes from.
         heavyTapEnabled: pyramid?.heavy !== void 0,
+        /*
+         * W30's two operators (claims §5.156 §2 and §3; §5.158), every word of
+         * them 0 on the landed material.
+         *
+         * The shadow's σ law crosses as three leaves rather than one width,
+         * because the shader reads it per pixel from the casting surface's own
+         * span. The scatter's scale conditioning crosses as the material's gain
+         * and reference plus the SOURCE's own statistic — the analysis pass's
+         * edge density, which arrives by readback and is therefore resolved
+         * here, like `bodyChainLod`. `adapt` is the filtered reading, so the
+         * statistic the shader sees is the one the drivers have settled on
+         * rather than a raw frame's.
+         *
+         * Where nothing has been observed the statistic is the material's own
+         * REFERENCE rather than 0 — the same gate `adaptStrength` takes two
+         * fields above, and for the same reason. The shader evaluates
+         * `gain · (statistic − reference)`, so a reference is the value at which
+         * the operator contributes nothing; passing 0 instead is that identity
+         * only while the reference happens to be 0, and the moment §5.159 fits
+         * one every unobserved frame would evaluate `gain · (0 − ref)` at full
+         * magnitude — a group whose backdrop readback has not landed yet would
+         * draw at the operator's full excursion and then step to its resting
+         * value. The reference says "no evidence", which is what an unobserved
+         * source has (W30 G2 review closure, claims §5.158 §8, finding 3).
+         */
+        outerShadowSigmaLaw: [
+          shadow.sigmaSlopePerSpan,
+          shadow.sigmaSpanRefPx,
+          shadow.sigmaThinOffsetPx
+        ],
+        sizeScatterScaleGain: material.sizeScatterScaleGain,
+        sizeScatterScaleRef: material.sizeScatterScaleRef,
+        backdropScaleStatistic: adapt?.observed === true ? adapt.edgeDensity : material.sizeScatterScaleRef,
+        sizeHeavySecondShare: material.sizeHeavySecondShare,
+        heavySecondEnabled: pyramid?.heavy2 !== void 0,
+        // W31's body chroma retention (claims §5.164): a material constant, per
+        // group, with no source-side half — the chromaticity it restores toward
+        // is the blurred backdrop the optics pass already sampled per pixel.
+        //
+        // Under the accessibility fold it stands down (W31 Decision Log 3 (d);
+        // claims §5.164 §8 (b) and §13): an occlusion lift covers more of the
+        // backdrop, so restoring the nominal fraction of its chromaticity gives
+        // back what the preference asked to have covered — measured at `R` 3.05
+        // and 3.17 against a reference of 1. `bodyChromaRetentionUnderPolicy` is
+        // exactly `material.bodyChromaRetention` where no preference is set,
+        // which is why every standard row is bit-identical across this fold.
+        bodyChromaRetention: bodyChromaRetentionUnderPolicy(material.bodyChromaRetention, policy),
         ...pyramid === void 0 && input.unsampledMaterial !== void 0 ? { domMaterial: {
           ...input.unsampledMaterial,
           mode: input.backdropTone === void 0 ? 1 : 2
@@ -7076,7 +7557,8 @@ function createWebGPURenderer(options = {}) {
         backdrop: pyramid === void 0 || policy.glass === "none" ? void 0 : {
           chain: pyramid.chain.createView(),
           body: pyramid.body.createView(),
-          heavy: pyramid.heavy?.createView()
+          heavy: pyramid.heavy?.createView(),
+          heavy2: pyramid.heavy2?.createView()
         }
       });
       if (active.highlight !== void 0) {
@@ -7389,6 +7871,6 @@ function createWebGPURenderer(options = {}) {
   };
 }
 
-export { ADAPTIVE_LUMINANCE_HIGH, ADAPTIVE_LUMINANCE_LOW, ADAPTIVE_TINT_DARK, ADAPTIVE_TINT_LIGHT, ANALYSIS_DISPATCH, ANALYSIS_GRID, ANALYSIS_PASS_ID, ANALYSIS_STATS_FLOATS, ANALYSIS_TARGET_EXTENT, ANALYSIS_WORKGROUP, BACKDROP_ALPHA_MODES, BACKDROP_COLOR_SPACES, BACKDROP_KINDS, BACKDROP_PASS_ID, BACKDROP_TONE_HIGH, BACKDROP_TONE_LOW, BACKDROP_TONE_MAX, BACKDROP_TONE_SIZE_BIAS, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDENTITY_FIT, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_AMOUNT_MAX, LENS_AMOUNT_PER_SPAN, LENS_EXTENT_GAIN, LENS_HEIGHT_MAX, LENS_HEIGHT_PER_SPAN, LENS_OVALIZATION, LENS_PROFILE_EXPONENT, LENS_REFRACTION_GAIN, LENS_SIZE_GAIN_MAX, LENS_THICKNESS_REFERENCE, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTER_SHADOW, OUTER_SHADOW_THICK_SPANS, OUTER_SHADOW_THIN_L, OUTER_SHADOW_UNMEASURED_BACKDROP_LUMINANCE, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SIZE_OCCLUSION_GAIN, SIZE_SCATTER_FLOOR, SIZE_SCATTER_FLOOR_2X, SIZE_SCATTER_GAIN_FAR_2X, SIZE_SCATTER_GAIN_MAX, SIZE_SCATTER_GAIN_MAX_2X, SIZE_SCATTER_RAMP_REACH_1X_PX, SIZE_SCATTER_RAMP_REACH_2X_PX, SIZE_SCATTER_RAMP_START_FAR_1X, SIZE_SCATTER_RAMP_START_FAR_2X, SIZE_SCATTER_RAMP_START_THICK_1X, SIZE_SCATTER_RAMP_START_THICK_2X, SIZE_SCATTER_RAMP_START_THIN_1X, SIZE_SCATTER_RAMP_START_THIN_2X, SIZE_SCATTER_SPAN_MAX, SIZE_SCATTER_SPAN_MAX_2X, SIZE_SHADOW_GAIN_MAX, SIZE_SPAN_MAX, SIZE_SPAN_MIN, SRGB_ENCODING_EXPONENT, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptedTintAlpha, adaptedTintColour, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, backdropFit, backdropToneAdaptation, backdropToneResponse, backdropToneSizeBiasUnderPolicy, backdropToneSolveWeight, backdropToneUnderPolicy, bodyBlurPlan, chainModule, clipFieldRectToCanvas, collapsedRimUnderPolicy, coverFit, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, heavyTapSigmaAtScale, highlightModule, importColorMatrix, importModule, importPassSource, isUsablePlacement, lensAmountBasePx, lensDepthPx, lensDirection, lensDisplacementPx, lensExtentPx, lensHeightBasePx, lensMagnitudePx, lensOvalizationAt, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, occlusionLiftForPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowLiftRise, outerShadowOcclusionAt, outerShadowReachPx, outerShadowThickOcclusion, outerShadowThinOcclusion, outerShadowUnderPolicy, packInstances, pipelineKey, placementFit, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, rimAlongSideFactor, rimAlongSideField, samePlacement, scatterDeepThickness, scatterFloorAtScale, scatterGainAt, scatterGainAtScale, scatterGainFarAtScale, scatterHeavyShareThickAtScale, scatterRampAreaMean, scatterRampReachDevicePx, scatterRampStart, scatterSharpShare, scatterSpanMaxAtScale, scatterThickness, shadowDepthPx, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, sizeToneLevelFar, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, texelsPerCssPx, tintShade, tintShadeLayer, tintToneAdaptation, tintedMaterialColour, validateAppTexture, withMaterialOverrides };
-//# sourceMappingURL=dist-VQPRX7BX.js.map
-//# sourceMappingURL=dist-VQPRX7BX.js.map
+export { ADAPTIVE_LUMINANCE_HIGH, ADAPTIVE_LUMINANCE_LOW, ADAPTIVE_TINT_DARK, ADAPTIVE_TINT_LIGHT, ANALYSIS_DISPATCH, ANALYSIS_GRID, ANALYSIS_PASS_ID, ANALYSIS_STATS_FLOATS, ANALYSIS_TARGET_EXTENT, ANALYSIS_WORKGROUP, BACKDROP_ALPHA_MODES, BACKDROP_COLOR_SPACES, BACKDROP_KINDS, BACKDROP_PASS_ID, BACKDROP_TONE_HIGH, BACKDROP_TONE_LOW, BACKDROP_TONE_MAX, BACKDROP_TONE_SIZE_BIAS, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDENTITY_FIT, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_AMOUNT_MAX, LENS_AMOUNT_PER_SPAN, LENS_EXTENT_GAIN, LENS_HEIGHT_MAX, LENS_HEIGHT_PER_SPAN, LENS_OVALIZATION, LENS_PROFILE_EXPONENT, LENS_REFRACTION_GAIN, LENS_SIZE_GAIN_MAX, LENS_THICKNESS_REFERENCE, LUMINANCE_WEIGHTS, MATERIAL_DIGEST_RULE_VERSION, MATERIAL_IDENTITY_TABLE, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTER_SHADOW, OUTER_SHADOW_THICK_SPANS, OUTER_SHADOW_THIN_L, OUTER_SHADOW_UNMEASURED_BACKDROP_LUMINANCE, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SIZE_OCCLUSION_GAIN, SIZE_SCATTER_FLOOR, SIZE_SCATTER_FLOOR_2X, SIZE_SCATTER_GAIN_FAR_2X, SIZE_SCATTER_GAIN_MAX, SIZE_SCATTER_GAIN_MAX_2X, SIZE_SCATTER_RAMP_REACH_1X_PX, SIZE_SCATTER_RAMP_REACH_2X_PX, SIZE_SCATTER_RAMP_START_FAR_1X, SIZE_SCATTER_RAMP_START_FAR_2X, SIZE_SCATTER_RAMP_START_THICK_1X, SIZE_SCATTER_RAMP_START_THICK_2X, SIZE_SCATTER_RAMP_START_THIN_1X, SIZE_SCATTER_RAMP_START_THIN_2X, SIZE_SCATTER_SPAN_MAX, SIZE_SCATTER_SPAN_MAX_2X, SIZE_SHADOW_GAIN_MAX, SIZE_SPAN_MAX, SIZE_SPAN_MIN, SRGB_ENCODING_EXPONENT, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptedTintAlpha, adaptedTintColour, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, backdropFit, backdropToneAdaptation, backdropToneResponse, backdropToneSizeBiasUnderPolicy, backdropToneSolveWeight, backdropToneUnderPolicy, bodyBlurPlan, chainModule, clipFieldRectToCanvas, collapsedRimUnderPolicy, coverFit, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, heavySecondTapSigmaAtScale, heavyTapSigmaAtScale, highlightModule, importColorMatrix, importModule, importPassSource, isUsablePlacement, lensAmountBasePx, lensDepthPx, lensDirection, lensDisplacementPx, lensExtentPx, lensHeightBasePx, lensMagnitudePx, lensOvalizationAt, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, materialDigestDroppedLeaves, materialDigestInput, materialLeafAt, occlusionAlphaUnderPolicy, occlusionLiftForPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowLiftRise, outerShadowOcclusionAt, outerShadowReachPx, outerShadowSigmaPx, outerShadowThickOcclusion, outerShadowThinOcclusion, outerShadowUnderPolicy, packInstances, pipelineKey, placementFit, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, rimAlongSideFactor, rimAlongSideField, samePlacement, scatterDeepThickness, scatterFloorAtScale, scatterGainAt, scatterGainAtScale, scatterGainFarAtScale, scatterHeavyShareThickAtScale, scatterRampAreaMean, scatterRampReachDevicePx, scatterRampStart, scatterSharpShare, scatterSpanMaxAtScale, scatterThickness, shadowDepthPx, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, sizeToneLevelFar, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, texelsPerCssPx, tintShade, tintShadeLayer, tintToneAdaptation, tintedMaterialColour, validateAppTexture, withMaterialOverrides };
+//# sourceMappingURL=dist-N437MSRG.js.map
+//# sourceMappingURL=dist-N437MSRG.js.map