@vitreajs/vitrea 0.2.0 → 0.4.0

package/dist/{dist-RQ4ZMA3D.js → dist-RGWZAZ6J.js}

@@ -17,6 +17,7 @@ var WGSL_ANALYSIS_PASS = `struct AnalysisUniforms {
 @group(0) @binding(3) var<storage, read_write> stats : array<f32>;
 
 var<workgroup> partialLum  : array<f32, ${ANALYSIS_WORKGROUP}>;
+var<workgroup> partialTone : array<f32, ${ANALYSIS_WORKGROUP}>;
 var<workgroup> partialSq   : array<f32, ${ANALYSIS_WORKGROUP}>;
 var<workgroup> partialEdge : array<f32, ${ANALYSIS_WORKGROUP}>;
 
@@ -32,6 +33,7 @@ fn lum_at(uv : vec2f) -> f32 {
 fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   let total = u32(au.grid.x * au.grid.y);
   var sumLum = 0.0;
+  var sumTone = 0.0;
   var sumSq = 0.0;
   var sumEdge = 0.0;
   var n = 0.0;
@@ -47,7 +49,15 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
     let dx = lum_at(uv + vec2f(au.texel.x, 0.0)) - lum_at(uv - vec2f(au.texel.x, 0.0));
     let dy = lum_at(uv + vec2f(0.0, au.texel.y)) - lum_at(uv - vec2f(0.0, au.texel.y));
 
+    // The published luminance accumulates ENCODED \u2014 the W9 model (claims
+    // 5.31): the reference's tone responses track the encoded-space mean of a
+    // structured backdrop, not its linear mean. The host decodes the mean once
+    // on readback, so every consumer downstream still speaks linear light.
+    // The linear sum stays, because the variance fold below needs a mean in
+    // the same space as its squares; variance and edge density stay linear \u2014
+    // nothing tonal reads them.
     sumLum = sumLum + c;
+    sumTone = sumTone + linear_to_srgb(vec3f(c, c, c)).x;
     sumSq = sumSq + c * c;
     sumEdge = sumEdge + length(vec2f(dx, dy)) * 0.5;
     n = n + 1.0;
@@ -56,6 +66,7 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   }
 
   partialLum[lane] = sumLum;
+  partialTone[lane] = sumTone;
   partialSq[lane] = sumSq;
   partialEdge[lane] = sumEdge;
   workgroupBarrier();
@@ -66,6 +77,7 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
     if (stride == 0u) { break; }
     if (lane < stride) {
       partialLum[lane] = partialLum[lane] + partialLum[lane + stride];
+      partialTone[lane] = partialTone[lane] + partialTone[lane + stride];
       partialSq[lane] = partialSq[lane] + partialSq[lane + stride];
       partialEdge[lane] = partialEdge[lane] + partialEdge[lane + stride];
     }
@@ -76,7 +88,8 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   if (lane == 0u) {
     let count = max(f32(total), 1.0);
     let mean = partialLum[0] / count;
-    stats[0] = mean;
+    // stats[0] is the ENCODED-space mean; the host decodes it once (W9).
+    stats[0] = partialTone[0] / count;
     stats[1] = max(partialSq[0] / count - mean * mean, 0.0);
     stats[2] = partialEdge[0] / count;
     stats[3] = count;
@@ -233,7 +246,12 @@ var DEFAULT_MATERIAL_PROFILE = {
        * the same 44 px span, which is the lerp-versus-multiply question C9a
        * recorded and nobody has acted on. Claims §5.13.
        */
-      blurSigma: 3,
+      // 1.25 since W11c G1 (claims §5.41): the reference's interior over
+      // structured content is a sharp component near σ 1.25 plus a heavy one
+      // the scatter facet now supplies (`sizeScatterFloor`); the cascade's 3
+      // (claims §5.16) was the one Gaussian that best split the difference on
+      // a bed with no pitch axis to tell the two apart.
+      blurSigma: 1.25,
       tint: srgbToLinear(SRGB_WHITE_TINT),
       tintAlpha: 0.46,
       rimWidth: 1.5,
@@ -330,6 +348,8 @@ var DEFAULT_MATERIAL_PROFILE = {
    */
   sizeSpanMin: 32,
   sizeSpanMax: 96,
+  // The inner shadow's depth gain since W12 G2 (the lens reads its own law
+  // below); the value is W2's, unchanged.
   lensSizeGainMax: 2.6,
   /*
    * MEASURED (W2), each with its own status — see the fields' notes.
@@ -405,41 +425,93 @@ var DEFAULT_MATERIAL_PROFILE = {
    * on. The grid 1.0/1.4/2.2 is flat to 0.2%. Carrying a fitted-looking 1.4 whose
    * measurement no longer exists would be the worse of the two errors.
    */
-  sizeScatterGainMax: 1,
+  // MEASURED (W11c G1, claims §5.41): the scatter facet off the identity, on
+  // its own curve — see `MaterialProfile.sizeScatterFloor`. The paragraph
+  // above records why the identity was the right answer while `blurSigma`
+  // was 3 and the bed had no pitch axis; the W9 probe's pitch axis is what
+  // identified the two-component interior this expresses.
+  sizeScatterGainMax: 8,
+  sizeScatterFloor: 0.4,
+  sizeScatterSpanMax: 256,
+  // The 1x three FITTED in the renderer (W13 G1's third sweep, 44 points over
+  // the calibration bed: `results/2026-09-03-w13-ramp/g1/sweep-3/g1-sweep-3.md`
+  // §3); the 2x three PROVISIONAL still, because at them the excursion is
+  // bit-exactly zero on the whole bed and a sweep cannot fit what does not
+  // move (§4). The thin anchor 0.72 is above G0's read-off of 0.637–0.642: the
+  // grid runs 0.60 / 0.64 / 0.68 and the refinement 0.72 / 0.76, and 0.72 is an
+  // interior optimum of both the interior objective and the interior gap. The
+  // thick anchor 0.52 is G0's `rrect-md` reading and is above that cell's deep
+  // sharp share of 0.481, where the joint thick fit of 0.47 would have clamped
+  // it to nothing. The 2x pair is G0's 2x readings, every one of which is BELOW
+  // its cell's deep value, so at dpr 2 the excursion is zero on this whole bed
+  // — the law evaluating to no excursion, and the 2x gap located in the deep
+  // value instead (claims §5.64 §4). See
+  // `MaterialProfile.sizeScatterRampStartThin1x`.
+  sizeScatterRampStartThin1x: 0.72,
+  sizeScatterRampStartThick1x: 0.52,
+  sizeScatterRampStartFar1x: 0.2,
+  sizeScatterRampStartThin2x: 0.46,
+  sizeScatterRampStartThick2x: 0.17,
+  sizeScatterRampStartFar2x: 0.15,
+  sizeScatterRampReach1xPx: 80,
+  sizeScatterRampReach2xPx: 100,
   sizeOcclusionGain: 0.05,
   sizeShadowGainMax: 1,
-  lensBodyLodPerPx: 0.16,
-  lensRimLodBias: 2.5,
+  /*
+   * The lens (W12 G2, claims §5.51; Decision Log 3 of the W12 spec).
+   *
+   * MEASURED from the reference's own layer tree (§5.50): the inner refraction
+   * amount and height laws, verified on spans 32 / 44 / 48 … 112 / 128 / 160
+   * and the nested base at 130, and the ovalization's knee (0 through span 64,
+   * 0.5 from 72). FITTED on the pixels (§5.51, a 2-D band renderer validated on
+   * this renderer's own capture): the gain, the extent and the exponent, on
+   * `rrect-md` + `-ml` at 1x pitches 16 and 32 with `rrect-lg` held out at both
+   * scales; the ovalization's effective value on the box-inscribed ellipse.
+   * Predicted before the landing capture: checkerboard SSIM 1x md / ml / lg
+   * 0.954 / 0.931 / 0.929 → 0.970 / 0.946 / 0.942, 2x 0.939 / 0.902 / 0.901 →
+   * 0.950 / 0.918 / 0.918, the capsule 0.977 → 0.985.
+   *
+   * What W11c G2 recorded here — 1.6 lens depths on the square profile, fitted
+   * per depth shell — was the band's mean, not its shape (§5.48, §5.49); it is
+   * kept in git history and in claims §5.43.
+   */
+  lensRefractionGain: 0.745,
+  lensHeightPerSpan: 0.25,
+  lensHeightMax: 20,
+  lensAmountPerSpan: 0.8,
+  lensAmountMax: 60,
+  lensThicknessReference: 8,
+  lensExtentGain: 1.337,
+  lensProfileExponent: 3.69,
+  // 0.8 by eye (W12 Decision Log 6). The pixels preferred 0.6 by a hair — every
+  // texture row that can see ω scores 0.001–0.002 lower at 0.8 (claims §5.54) —
+  // but the field's measured tilt sits at 0.8–1.0 (§5.49 §3) and the user read
+  // the 0.8 sheet as much closer to macOS; the eye overrides a margin that small,
+  // and §5.54 §1's rows are the recorded cost.
+  lensOvalization: 0.8,
+  lensOvalizationSpanMin: 64,
+  lensOvalizationSpanMax: 72,
   reducedTransparencyFrost: 1.75,
   increasedOcclusionLift: INCREASED_OCCLUSION_LIFT,
   strongBorderRim: { rimWidth: 2, rimAlpha: 0.95 },
   reducedTintAdaptation: 0.35,
-  // ADVISORY (W3). The span 0.02 … 0.65 covers most of the canonical backdrop
-  // range (0.003 … 0.891 linear), and the two ends are deliberately symmetric —
-  // 0.45 of the seed's brightness at the dark end, 0.45 of the way to white at
-  // the bright end — so the seed itself sits mid-range and the excursion reads
-  // as glass rather than as two different colours.
   /*
-   * FITTED (2026-08-31, active bed) — and the fit is that THE CURVE IS THE
-   * IDENTITY. `floor` → 1 and `ceilMix` → 0 make `tintTone` return the seed
-   * unchanged at every backdrop, which leaves `low` and `high` describing
-   * nothing at all; they keep their provisional values so a bed that can
-   * identify them has somewhere to land, exactly as `adaptiveTint` keeps two
-   * equal ends.
+   * MEASURED (W10, 2026-09-02) — per-pixel least squares of the reference's
+   * tinted pixel against its own untinted pixel on the five W9-probe tinted
+   * checkerboard cells (pitch 4…64 px, 17 700 px): shade = 0.5289 + 0.4886·u,
+   * RMS 0.0035. Out of sample on the canonical bed the orange cells fit at
+   * RMS 0.003 with zero bias; blue sits 0.011 darker (the second hue's
+   * residual, recorded and unmodelled). The light end extrapolates past 1 and
+   * is clamped in `tintShade`. Claims §5.36.
    *
-   * Monotone and uncontested over floor ∈ {0.45, 0.7, 0.85, 1} × ceilMix ∈
-   * {0, 0.2, 0.45}: objective 0.26523 → 0.12676, a 2.09× spread, with ΔE
-   * (0.01331 → 0.00831) and SSIM (0.9749 → 0.9788) agreeing. The reference
-   * says the same thing directly — on three of the five calibration backdrops
-   * its tinted interior is the declared seed EXACTLY in linear light, at a
-   * per-channel standard deviation of 0.000. Apple's tint is the author's
-   * colour, not a range of tones mapped to it; S219's wording described the
-   * inactive material's residue. Claims §5.13.
+   * §5.13's earlier "the curve is the identity" fit was made on the material's
+   * MEAN over solid backdrops, where u is either ~0.97 (shade 1.0) or the
+   * collapse has already folded the shade out — the identity was the law's
+   * two endpoints, seen without anything between them.
    */
-  tintToneFloor: 1,
-  tintToneCeilMix: 0,
-  tintToneLow: 0.02,
-  tintToneHigh: 0.65,
+  tintShadeDark: 0.5289,
+  tintShadeLight: 1.0175,
+  tintShadeStrength: 1,
   /*
    * MEASURED (W7), against the settled apple-macos-26.5 bed, on the light and
    * dark standard profiles jointly and at both scales.
@@ -472,9 +544,21 @@ var DEFAULT_MATERIAL_PROFILE = {
    * is a VALIDATION cell and was not fitted to: the calibration set predicts
    * 0.34 there and the cell reads 0.356.
    */
+  /*
+   * RE-SCOPED (W9, claims §5.33). The four mix constants now own TEXTURE
+   * COLLAPSE alone — the interior mean moved to the response law below — and
+   * their band contracts to the one domain the collapse is real in: full at
+   * `dark-solid` (0.0117) for thin surfaces including the 44 px capsule
+   * (byte-identical collapse, arg 0.0164 ≤ low with margin), zero by
+   * `mid-dark-solid` (0.0595), where the reference's small surface keeps a
+   * textured body at 0.4561 and the old band's partial collapse (k = 0.81)
+   * was the measured 0.1375-vs-0.4561 overshoot. `impulse__rrect-md`
+   * (arg 0.0539) keeps k ≈ 0.003 against the old band's 0.008 — the same
+   * unadapted render that cell validated.
+   */
   backdropToneMax: 1,
-  backdropToneLow: 0.03,
-  backdropToneHigh: 0.14,
+  backdropToneLow: 0.02,
+  backdropToneHigh: 0.055,
   /*
    * REFITTED 0.09 → 0.13 (2026-08-31, active bed). The law's SHAPE is untouched
    * (Decision Log 13 stands; the two-axis rework is next wave) and `max`, `low`
@@ -493,8 +577,26 @@ var DEFAULT_MATERIAL_PROFILE = {
    * estimator's algebra assumes the two colour schemes share one tint alpha,
    * and this profile pair does not (0.46 against 0.97) — recorded in §5.13 as
    * the reason it is no longer the primary evidence for this constant.
+   *
+   * RE-SCOPED 0.13 → 0.05 with the band above (W9): the bias's one remaining
+   * job is keeping the thick surface's collapse argument above `high` at the
+   * dark anchor (0.0117 + 0.05 = 0.0617 > 0.055) while the thin capsule's
+   * stays below `low` — the near-binary size snap the probe measured
+   * (claims §5.33). The smooth size trend on structured backdrops, which the
+   * old wide band tried and failed to carry, belongs to the response law's
+   * thickness axis now.
    */
-  backdropToneSizeBias: 0.13,
+  backdropToneSizeBias: 0.05,
+  /*
+   * MEASURED (W9 probe, claims §5.30–§5.33): the anchors are the probe bed's
+   * settled reference levels, frequency-settled over seven attested runs,
+   * under the probe's own native-mask interior. Thick rows pool the 96 px
+   * and 160 px rrects (±0.012). Not tuned; re-measured only by a new probe.
+   */
+  backdropToneAnchorX: [0.1104, 0.2706, 0.9505],
+  backdropToneResponseThin: [0.0126, 0.4561, 0.9713],
+  backdropToneResponseThick: [0.4953, 0.5744, 0.9358],
+  backdropToneResponseStrength: 1,
   /*
    * FITTED (recalibration cascade, 2026-08-31). W8's geometry SURVIVES the fit
    * unchanged — `sigmaPx` 15.55, `offsetPx` 7.95, `spreadPx` 3.10 — and only the
@@ -516,14 +618,18 @@ var DEFAULT_MATERIAL_PROFILE = {
    * instrument's independent shadow axis agrees, so the geometry stands on those
    * two and this objective is not asked to re-decide it.
    *
-   * `reducedTransparencyOcclusion` 0.70 is sharp where the amplitude is flat: a
-   * 3.83× spread over 0.45…0.95 with a clear minimum. It also reconciles two
+   * `reducedTransparencyOcclusion` 0.70 was sharp where the amplitude was flat: a
+   * 3.83× spread over 0.45…0.95 with a clear minimum. It also reconciled two
    * routes — 0.285 × 0.70 = 0.1995 against the reference's directly measured
    * reduce-transparency amplitude of 0.203 at a 44 px span. W8's 0.566 was the
-   * ratio of the reference's two amplitudes; this is the ratio that makes
+   * ratio of the reference's two amplitudes; that was the ratio that made
    * vitrea's shadow match the reference's under the preference, and the two
-   * differ because the base amplitude is a compromise across scenes whose spread
-   * is much wider in the standard profile than under reduced transparency.
+   * differed because the base amplitude is a compromise across scenes whose
+   * spread is much wider in the standard profile than under reduced transparency.
+   * **W14 G1 re-forms the constant as the LEVEL those routes were reconciling
+   * to** — 0.197 absolute, replacing both regimes rather than scaling them — for
+   * the reason its doc comment gives: a ratio and a level stopped being the same
+   * thing when the single amplitude became six unequal anchors.
    *
    * Extracted from the active bed's native fixtures directly —
    * `results/2026-08-31-active-bed-stage0.json` measured the gap, these numbers
@@ -562,13 +668,33 @@ var DEFAULT_MATERIAL_PROFILE = {
    * 44 px span — the dark material's shadow is nearly invisible) and lands as a
    * profile patch, not as a branch here. Both are stated in the claims doc as the
    * open question the cascade's fit inherits.
+   *
+   * **W14 G1 answers that open question and replaces `occlusion`.** "Over the
+   * flat near-white `light-solid` backdrop the same fit reads 0.123 rather than
+   * 0.33 … it is not a function of the backdrop's luminance" was read on a bed
+   * that had no backdrop between `hc-text` (linear 0.74) and `light-solid`
+   * (0.891): it IS a function of the backdrop's luminance, and the whole factor
+   * of 2.6 happens inside the gap the bed cannot see (claims §5.62 §5). The
+   * single amplitude becomes six anchors on two regimes — three in backdrop
+   * luminance below the knee, three in span above it — plus the lift's four
+   * constants. The three lengths are untouched; G0 re-read them free on both
+   * terms and they came back at W8's values.
    */
   outerShadow: {
     offsetPx: 7.95,
     sigmaPx: 15.55,
     spreadPx: 3.1,
-    occlusion: 0.285,
-    reducedTransparencyOcclusion: 0.7,
+    thinOcclusionDark: 0,
+    thinOcclusionMid: 0.33,
+    thinOcclusionBright: 0.127,
+    thickOcclusionAt96: 0.37,
+    thickOcclusionAt128: 0.448,
+    thickOcclusionAt160: 0.479,
+    liftAmplitude: 0.01,
+    liftSpanMin: 64,
+    liftSpanFull: 118,
+    liftBlurSigmaCss: 40,
+    reducedTransparencyOcclusion: 0.197,
     sizeGain: 0
   },
   lightDirection: [-0.3714, -0.9285],
@@ -587,16 +713,50 @@ var SIZE_SPAN_MIN = DEFAULT_MATERIAL_PROFILE.sizeSpanMin;
 var SIZE_SPAN_MAX = DEFAULT_MATERIAL_PROFILE.sizeSpanMax;
 var LENS_SIZE_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.lensSizeGainMax;
 var SIZE_SCATTER_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.sizeScatterGainMax;
+var SIZE_SCATTER_FLOOR = DEFAULT_MATERIAL_PROFILE.sizeScatterFloor;
+var SIZE_SCATTER_SPAN_MAX = DEFAULT_MATERIAL_PROFILE.sizeScatterSpanMax;
+var SIZE_SCATTER_RAMP_START_THIN_1X = DEFAULT_MATERIAL_PROFILE.sizeScatterRampStartThin1x;
+var SIZE_SCATTER_RAMP_START_THICK_1X = DEFAULT_MATERIAL_PROFILE.sizeScatterRampStartThick1x;
+var SIZE_SCATTER_RAMP_START_THIN_2X = DEFAULT_MATERIAL_PROFILE.sizeScatterRampStartThin2x;
+var SIZE_SCATTER_RAMP_START_THICK_2X = DEFAULT_MATERIAL_PROFILE.sizeScatterRampStartThick2x;
+var SIZE_SCATTER_RAMP_START_FAR_1X = DEFAULT_MATERIAL_PROFILE.sizeScatterRampStartFar1x;
+var SIZE_SCATTER_RAMP_START_FAR_2X = DEFAULT_MATERIAL_PROFILE.sizeScatterRampStartFar2x;
+var SIZE_SCATTER_RAMP_REACH_1X_PX = DEFAULT_MATERIAL_PROFILE.sizeScatterRampReach1xPx;
+var SIZE_SCATTER_RAMP_REACH_2X_PX = DEFAULT_MATERIAL_PROFILE.sizeScatterRampReach2xPx;
 var SIZE_OCCLUSION_GAIN = DEFAULT_MATERIAL_PROFILE.sizeOcclusionGain;
 var SIZE_SHADOW_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.sizeShadowGainMax;
-var LENS_BODY_LOD_PER_PX = DEFAULT_MATERIAL_PROFILE.lensBodyLodPerPx;
-var LENS_RIM_LOD_BIAS = DEFAULT_MATERIAL_PROFILE.lensRimLodBias;
+var LENS_REFRACTION_GAIN = DEFAULT_MATERIAL_PROFILE.lensRefractionGain;
+var LENS_HEIGHT_PER_SPAN = DEFAULT_MATERIAL_PROFILE.lensHeightPerSpan;
+var LENS_HEIGHT_MAX = DEFAULT_MATERIAL_PROFILE.lensHeightMax;
+var LENS_AMOUNT_PER_SPAN = DEFAULT_MATERIAL_PROFILE.lensAmountPerSpan;
+var LENS_AMOUNT_MAX = DEFAULT_MATERIAL_PROFILE.lensAmountMax;
+var LENS_THICKNESS_REFERENCE = DEFAULT_MATERIAL_PROFILE.lensThicknessReference;
+var LENS_EXTENT_GAIN = DEFAULT_MATERIAL_PROFILE.lensExtentGain;
+var LENS_PROFILE_EXPONENT = DEFAULT_MATERIAL_PROFILE.lensProfileExponent;
+var LENS_OVALIZATION = DEFAULT_MATERIAL_PROFILE.lensOvalization;
 var BACKDROP_TONE_MAX = DEFAULT_MATERIAL_PROFILE.backdropToneMax;
 var BACKDROP_TONE_LOW = DEFAULT_MATERIAL_PROFILE.backdropToneLow;
 var BACKDROP_TONE_HIGH = DEFAULT_MATERIAL_PROFILE.backdropToneHigh;
 var BACKDROP_TONE_SIZE_BIAS = DEFAULT_MATERIAL_PROFILE.backdropToneSizeBias;
+DEFAULT_MATERIAL_PROFILE.backdropToneAnchorX;
+DEFAULT_MATERIAL_PROFILE.backdropToneResponseThin;
+DEFAULT_MATERIAL_PROFILE.backdropToneResponseThick;
+DEFAULT_MATERIAL_PROFILE.backdropToneResponseStrength;
 var OUTER_SHADOW = DEFAULT_MATERIAL_PROFILE.outerShadow;
+var RETIRED_OUTER_SHADOW_LEAVES = {
+  occlusion: "the six amplitude anchors (thinOcclusionDark, thinOcclusionMid, thinOcclusionBright, thickOcclusionAt96, thickOcclusionAt128, thickOcclusionAt160) and liftAmplitude for the second term"
+};
+function rejectRetiredOuterShadowLeaves(patch) {
+  if (patch === void 0)
+    return;
+  for (const [leaf, replacement] of Object.entries(RETIRED_OUTER_SHADOW_LEAVES)) {
+    if (!(leaf in patch))
+      continue;
+    throw new Error(`outerShadow.${leaf} was retired by W14 G1 (claims \xA75.62) and is replaced by ${replacement}. Applying this patch would have rendered the default shadow while recording itself as configured. It is refused rather than mapped: a single span-flat amplitude is the material the measurement retired.`);
+  }
+}
 function withMaterialOverrides(base, patch) {
+  rejectRetiredOuterShadowLeaves(patch.outerShadow);
   const optics = {};
   for (const variant of MATERIAL_VARIANTS) {
     optics[variant] = { ...base.optics[variant], ...patch.optics?.[variant] };
@@ -616,22 +776,44 @@ function withMaterialOverrides(base, patch) {
     sizeSpanMax: patch.sizeSpanMax ?? base.sizeSpanMax,
     lensSizeGainMax: patch.lensSizeGainMax ?? base.lensSizeGainMax,
     sizeScatterGainMax: patch.sizeScatterGainMax ?? base.sizeScatterGainMax,
+    sizeScatterFloor: patch.sizeScatterFloor ?? base.sizeScatterFloor,
+    sizeScatterSpanMax: patch.sizeScatterSpanMax ?? base.sizeScatterSpanMax,
+    sizeScatterRampStartThin1x: patch.sizeScatterRampStartThin1x ?? base.sizeScatterRampStartThin1x,
+    sizeScatterRampStartThick1x: patch.sizeScatterRampStartThick1x ?? base.sizeScatterRampStartThick1x,
+    sizeScatterRampStartThin2x: patch.sizeScatterRampStartThin2x ?? base.sizeScatterRampStartThin2x,
+    sizeScatterRampStartThick2x: patch.sizeScatterRampStartThick2x ?? base.sizeScatterRampStartThick2x,
+    sizeScatterRampStartFar1x: patch.sizeScatterRampStartFar1x ?? base.sizeScatterRampStartFar1x,
+    sizeScatterRampStartFar2x: patch.sizeScatterRampStartFar2x ?? base.sizeScatterRampStartFar2x,
+    sizeScatterRampReach1xPx: patch.sizeScatterRampReach1xPx ?? base.sizeScatterRampReach1xPx,
+    sizeScatterRampReach2xPx: patch.sizeScatterRampReach2xPx ?? base.sizeScatterRampReach2xPx,
     sizeOcclusionGain: patch.sizeOcclusionGain ?? base.sizeOcclusionGain,
     sizeShadowGainMax: patch.sizeShadowGainMax ?? base.sizeShadowGainMax,
-    lensBodyLodPerPx: patch.lensBodyLodPerPx ?? base.lensBodyLodPerPx,
-    lensRimLodBias: patch.lensRimLodBias ?? base.lensRimLodBias,
+    lensRefractionGain: patch.lensRefractionGain ?? base.lensRefractionGain,
+    lensHeightPerSpan: patch.lensHeightPerSpan ?? base.lensHeightPerSpan,
+    lensHeightMax: patch.lensHeightMax ?? base.lensHeightMax,
+    lensAmountPerSpan: patch.lensAmountPerSpan ?? base.lensAmountPerSpan,
+    lensAmountMax: patch.lensAmountMax ?? base.lensAmountMax,
+    lensThicknessReference: patch.lensThicknessReference ?? base.lensThicknessReference,
+    lensExtentGain: patch.lensExtentGain ?? base.lensExtentGain,
+    lensProfileExponent: patch.lensProfileExponent ?? base.lensProfileExponent,
+    lensOvalization: patch.lensOvalization ?? base.lensOvalization,
+    lensOvalizationSpanMin: patch.lensOvalizationSpanMin ?? base.lensOvalizationSpanMin,
+    lensOvalizationSpanMax: patch.lensOvalizationSpanMax ?? base.lensOvalizationSpanMax,
     reducedTransparencyFrost: patch.reducedTransparencyFrost ?? base.reducedTransparencyFrost,
     increasedOcclusionLift: patch.increasedOcclusionLift ?? base.increasedOcclusionLift,
     strongBorderRim: { ...base.strongBorderRim, ...patch.strongBorderRim },
     reducedTintAdaptation: patch.reducedTintAdaptation ?? base.reducedTintAdaptation,
-    tintToneFloor: patch.tintToneFloor ?? base.tintToneFloor,
-    tintToneCeilMix: patch.tintToneCeilMix ?? base.tintToneCeilMix,
-    tintToneLow: patch.tintToneLow ?? base.tintToneLow,
-    tintToneHigh: patch.tintToneHigh ?? base.tintToneHigh,
+    tintShadeDark: patch.tintShadeDark ?? base.tintShadeDark,
+    tintShadeLight: patch.tintShadeLight ?? base.tintShadeLight,
+    tintShadeStrength: patch.tintShadeStrength ?? base.tintShadeStrength,
     backdropToneMax: patch.backdropToneMax ?? base.backdropToneMax,
     backdropToneLow: patch.backdropToneLow ?? base.backdropToneLow,
     backdropToneHigh: patch.backdropToneHigh ?? base.backdropToneHigh,
     backdropToneSizeBias: patch.backdropToneSizeBias ?? base.backdropToneSizeBias,
+    backdropToneAnchorX: patch.backdropToneAnchorX ?? base.backdropToneAnchorX,
+    backdropToneResponseThin: patch.backdropToneResponseThin ?? base.backdropToneResponseThin,
+    backdropToneResponseThick: patch.backdropToneResponseThick ?? base.backdropToneResponseThick,
+    backdropToneResponseStrength: patch.backdropToneResponseStrength ?? base.backdropToneResponseStrength,
     outerShadow: { ...base.outerShadow, ...patch.outerShadow },
     lightDirection: patch.lightDirection ?? base.lightDirection,
     sweepBandRadians: patch.sweepBandRadians ?? base.sweepBandRadians,
@@ -677,28 +859,29 @@ function tintToneAdaptation(policy, profile = DEFAULT_MATERIAL_PROFILE) {
       return 0;
   }
 }
-function tintTone(seed, backdropLuminance, toneAdaptation, profile = DEFAULT_MATERIAL_PROFILE) {
-  const t = smoothstep(profile.tintToneLow, profile.tintToneHigh, backdropLuminance);
-  const k = Math.min(1, Math.max(0, toneAdaptation));
+function tintShade(materialLuminance, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  const u = Math.min(1, Math.max(0, materialLuminance));
+  const shade = Math.min(1, Math.max(0, profile.tintShadeDark + (profile.tintShadeLight - profile.tintShadeDark) * u));
+  const k = Math.min(1, Math.max(0, grip));
+  return 1 + (shade - 1) * k;
+}
+function tintShadeLayer(seed, materialLuminance, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  const shade = tintShade(materialLuminance, grip, profile);
+  return [seed[0] * shade, seed[1] * shade, seed[2] * shade];
+}
+function tintedMaterialColour(material, tint, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  if (tint === void 0 || tint.strength <= 0)
+    return material;
+  const s = Math.min(1, Math.max(0, tint.strength));
+  const layer = tintShadeLayer(tint.color, relativeLuminance(material), grip, profile);
+  const clamp01 = (value) => Math.min(1, Math.max(0, value));
   const channel = (index) => {
-    const s = seed[index];
-    const low = s * profile.tintToneFloor;
-    const high = s + (1 - s) * profile.tintToneCeilMix;
-    return s + (low + (high - low) * t - s) * k;
+    const from = linearToSrgbChannel(clamp01(material[index]));
+    const to = linearToSrgbChannel(clamp01(layer[index]));
+    return srgbToLinearChannel(from + (to - from) * s);
   };
   return [channel(0), channel(1), channel(2)];
 }
-function tintedTintColour(neutral, tint, backdropLuminance, toneAdaptation, profile = DEFAULT_MATERIAL_PROFILE) {
-  if (tint === void 0)
-    return neutral;
-  const tone = tintTone(tint.color, backdropLuminance, toneAdaptation, profile);
-  const k = Math.min(1, Math.max(0, tint.strength));
-  return [
-    neutral[0] + (tone[0] - neutral[0]) * k,
-    neutral[1] + (tone[1] - neutral[1]) * k,
-    neutral[2] + (tone[2] - neutral[2]) * k
-  ];
-}
 function backdropToneAdaptation(backdropLuminance, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
   const x = backdropLuminance + profile.backdropToneSizeBias * Math.min(1, Math.max(0, thickness));
   const span = Math.max(profile.backdropToneHigh - profile.backdropToneLow, 1e-6);
@@ -748,11 +931,102 @@ function lensSizeGain(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
 function lensSizeGainFromThickness(thickness, profile = DEFAULT_MATERIAL_PROFILE) {
   return 1 + (profile.lensSizeGainMax - 1) * thickness;
 }
-function sizeScatterSigma(sigmaPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
-  return sizeScatterSigmaAt(sigmaPx, sizeThickness(spanPx, profile), profile);
+function shadowDepthPx(thicknessPx, spanPx, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  return Math.min(Math.max(thicknessPx, 0) * lensSizeGainFromThickness(thickness, profile), spanPx * 0.5);
 }
-function sizeScatterSigmaAt(sigmaPx, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
-  return sigmaPx * (1 + (profile.sizeScatterGainMax - 1) * thickness);
+function lensHeightBasePx(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return Math.min(profile.lensHeightPerSpan * Math.max(spanPx, 0), profile.lensHeightMax);
+}
+function lensAmountBasePx(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return Math.min(profile.lensAmountPerSpan * Math.max(spanPx, 0), profile.lensAmountMax);
+}
+function lensOvalizationAt(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return profile.lensOvalization * smoothstep(profile.lensOvalizationSpanMin, profile.lensOvalizationSpanMax, spanPx);
+}
+function lensMagnitudePx(thicknessPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE, fold = 1) {
+  const thick = Math.max(thicknessPx, 0);
+  if (thick <= 0)
+    return 0;
+  const scale = thick / profile.lensThicknessReference;
+  const unclamped = thick + (lensHeightBasePx(spanPx, profile) * scale - thick) * fold;
+  const depth = lensDepthPx(thicknessPx, spanPx, profile, fold);
+  const amount = thick + (lensAmountBasePx(spanPx, profile) * scale - thick) * fold;
+  return profile.lensRefractionGain * amount * (unclamped > 0 ? depth / unclamped : 0);
+}
+function lensExtentPx(thicknessPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE, fold = 1) {
+  return profile.lensExtentGain * lensDepthPx(thicknessPx, spanPx, profile, fold);
+}
+function lensDirection(normal, offset, half, ovalization) {
+  const a = Math.max(half[0], 1e-6);
+  const b = Math.max(half[1], 1e-6);
+  const ex = offset[0] / (a * a);
+  const ey = offset[1] / (b * b);
+  const r = Math.max(Math.hypot(offset[0] / a, offset[1] / b), 1e-6);
+  const scale = Math.min(a, b) / r;
+  const gx = (1 - ovalization) * normal[0] + ovalization * ex * scale;
+  const gy = (1 - ovalization) * normal[1] + ovalization * ey * scale;
+  const len = Math.hypot(gx, gy);
+  return len > 1e-9 ? [gx / len, gy / len] : [normal[0], normal[1]];
+}
+function sizeScatterSigma(sigmaPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1, extentsCssPx) {
+  return sizeScatterSigmaAt(sigmaPx, scatterThickness(spanPx, 1, profile, devicePixelRatio, extentsCssPx), profile);
+}
+function scatterRampStart(devicePixelRatio, profile = DEFAULT_MATERIAL_PROFILE, spanPx = 0) {
+  const thin = rampAtScale(profile.sizeScatterRampStartThin1x, profile.sizeScatterRampStartThin2x, devicePixelRatio);
+  const thick = rampAtScale(profile.sizeScatterRampStartThick1x, profile.sizeScatterRampStartThick2x, devicePixelRatio);
+  const far = rampAtScale(profile.sizeScatterRampStartFar1x, profile.sizeScatterRampStartFar2x, devicePixelRatio);
+  const decline = smoothstep(profile.sizeSpanMax, profile.sizeScatterSpanMax, spanPx);
+  return thin + (thick - thin) * sizeThickness(spanPx, profile) + (far - thick) * decline;
+}
+function scatterRampReachDevicePx(devicePixelRatio, profile = DEFAULT_MATERIAL_PROFILE) {
+  return rampAtScale(profile.sizeScatterRampReach1xPx, profile.sizeScatterRampReach2xPx, devicePixelRatio);
+}
+function rampAtScale(at1x, at2x, devicePixelRatio) {
+  const t = devicePixelRatio - 1;
+  if (t <= 0)
+    return at1x;
+  if (t >= 1)
+    return at2x;
+  return at1x + (at2x - at1x) * t;
+}
+function scatterDeepThickness(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  const floor = clampUnit(profile.sizeScatterFloor);
+  return floor + (1 - floor) * smoothstep(profile.sizeSpanMin, profile.sizeScatterSpanMax, spanPx);
+}
+function scatterSharpShare(uDevicePx, devicePixelRatio, profile = DEFAULT_MATERIAL_PROFILE, spanPx = 0) {
+  const deepSharp = 1 - scatterDeepThickness(spanPx, profile);
+  const start = scatterRampStart(devicePixelRatio, profile, spanPx);
+  const reach = Math.max(scatterRampReachDevicePx(devicePixelRatio, profile), 1e-6);
+  const excursion = Math.max(start - deepSharp, 0) * Math.max(1 - Math.max(uDevicePx, 0) / reach, 0);
+  return clampUnit(deepSharp + excursion);
+}
+function scatterThickness(spanPx, fold, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1, extentsCssPx) {
+  const floor = clampUnit(profile.sizeScatterFloor);
+  const mean = scatterRampAreaMean(spanPx, profile, devicePixelRatio, extentsCssPx);
+  return clampUnit(floor + (mean - floor) * fold);
+}
+function scatterRampAreaMean(spanPx, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1, extentsCssPx) {
+  const deep = scatterDeepThickness(spanPx, profile);
+  const amplitude = Math.max(scatterRampStart(devicePixelRatio, profile, spanPx) - (1 - deep), 0);
+  if (amplitude <= 0)
+    return clampUnit(deep);
+  const width = Math.max(extentsCssPx?.[0] ?? spanPx, 0);
+  const height = Math.max(extentsCssPx?.[1] ?? spanPx, 0);
+  const area = width * height;
+  if (area <= 0)
+    return clampUnit(deep - amplitude);
+  const reach = Math.max(scatterRampReachDevicePx(devicePixelRatio, profile) / Math.max(devicePixelRatio, 1e-3), 1e-6);
+  const perimeter = 2 * (width + height);
+  const limit = Math.min(reach, Math.min(width, height) / 2);
+  const triangleMean = (perimeter * limit - 4 * limit * limit - perimeter * limit * limit / (2 * reach) + 8 * limit * limit * limit / (3 * reach)) / area;
+  return clampUnit(deep - amplitude * triangleMean);
+}
+function sizeScatterSigmaAt(sigmaPx, scatter, profile = DEFAULT_MATERIAL_PROFILE) {
+  const mix = clampUnit(scatter);
+  return sigmaPx * (1 + (profile.sizeScatterGainMax - 1) * mix);
+}
+function clampUnit(value) {
+  return Math.min(1, Math.max(0, value));
 }
 function sizeOcclusionAlpha(alpha, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
   return sizeOcclusionAlphaAt(alpha, sizeThickness(spanPx, profile), profile);
@@ -772,15 +1046,79 @@ function sizeOuterShadowOcclusion(occlusion, spanPx, profile = DEFAULT_MATERIAL_
 function sizeOuterShadowOcclusionAt(occlusion, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
   return Math.min(1, occlusion + profile.outerShadow.sizeGain * thickness * (1 - occlusion));
 }
+var OUTER_SHADOW_THIN_L = {
+  /** At and below this backdrop luminance the black term is `thinOcclusionDark`. */
+  inert: 0.02,
+  /** From here the mid plateau holds. */
+  midFrom: 0.06,
+  /** To here — `hc-text`'s own linear luminance. */
+  midTo: 0.74,
+  /** `light-solid`'s linear luminance, where 0.127 was measured; held above. */
+  bright: 0.891
+};
+var OUTER_SHADOW_UNMEASURED_BACKDROP_LUMINANCE = 0.3;
+function outerShadowThinOcclusion(backdropLuminance, shadow) {
+  const l = backdropLuminance ?? OUTER_SHADOW_UNMEASURED_BACKDROP_LUMINANCE;
+  const { inert, midFrom, midTo, bright } = OUTER_SHADOW_THIN_L;
+  if (l <= inert)
+    return shadow.thinOcclusionDark;
+  if (l < midFrom) {
+    const t2 = (l - inert) / (midFrom - inert);
+    const s = t2 * t2 * (3 - 2 * t2);
+    return shadow.thinOcclusionDark + (shadow.thinOcclusionMid - shadow.thinOcclusionDark) * s;
+  }
+  if (l <= midTo)
+    return shadow.thinOcclusionMid;
+  if (l >= bright)
+    return shadow.thinOcclusionBright;
+  const t = (l - midTo) / (bright - midTo);
+  return shadow.thinOcclusionMid + (shadow.thinOcclusionBright - shadow.thinOcclusionMid) * t;
+}
+var OUTER_SHADOW_THICK_SPANS = [96, 128, 160];
+function outerShadowThickOcclusion(spanPx, shadow) {
+  const [s0, s1, s2] = OUTER_SHADOW_THICK_SPANS;
+  const y0 = shadow.thickOcclusionAt96;
+  const y1 = shadow.thickOcclusionAt128;
+  const y2 = shadow.thickOcclusionAt160;
+  if (spanPx <= s0)
+    return y0;
+  if (spanPx >= s2)
+    return y2;
+  if (spanPx <= s1)
+    return y0 + (y1 - y0) * (spanPx - s0) / (s1 - s0);
+  return y1 + (y2 - y1) * (spanPx - s1) / (s2 - s1);
+}
+function outerShadowOcclusionAt(shadow, backdropLuminance, spanPx, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  const thin = outerShadowThinOcclusion(backdropLuminance, shadow);
+  const thick = outerShadowThickOcclusion(spanPx, shadow);
+  const k = Math.min(1, Math.max(0, thickness));
+  const blend = k * k * (3 - 2 * k);
+  return sizeOuterShadowOcclusionAt(thin + (thick - thin) * blend, thickness, profile);
+}
+function outerShadowLiftRise(spanPx, shadow) {
+  return smoothstep(shadow.liftSpanMin, shadow.liftSpanFull, spanPx);
+}
 function outerShadowUnderPolicy(policy, profile = DEFAULT_MATERIAL_PROFILE) {
   const shadow = profile.outerShadow;
   if (policy.glass === "none" || policy.frost === "none")
-    return { ...shadow, occlusion: 0 };
+    return flatOuterShadow(shadow, 0);
   if (policy.frost === "increased") {
-    return { ...shadow, occlusion: shadow.occlusion * shadow.reducedTransparencyOcclusion };
+    return flatOuterShadow(shadow, shadow.reducedTransparencyOcclusion);
   }
   return shadow;
 }
+function flatOuterShadow(shadow, amplitude) {
+  return {
+    ...shadow,
+    thinOcclusionDark: amplitude,
+    thinOcclusionMid: amplitude,
+    thinOcclusionBright: amplitude,
+    thickOcclusionAt96: amplitude,
+    thickOcclusionAt128: amplitude,
+    thickOcclusionAt160: amplitude,
+    liftAmplitude: 0
+  };
+}
 var SRGB_ENCODING_EXPONENT = 2.4;
 function outerShadowFalloff(signedDistancePx, sigmaPx) {
   const x = -signedDistancePx / Math.max(sigmaPx, 1e-4);
@@ -790,8 +1128,8 @@ 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) {
-  const alpha = outerShadowAlpha(shadow.occlusion);
+function outerShadowReachPx(shadow, occlusion) {
+  const alpha = outerShadowAlpha(occlusion);
   if (!(alpha > 0))
     return 0;
   const cutoff = 1 / 255 / alpha;
@@ -809,12 +1147,18 @@ function outerShadowReachPx(shadow) {
   }
   return Math.max(0, hi + Math.abs(shadow.offsetPx) + shadow.spreadPx);
 }
-function lensDepthPx(thicknessPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
-  const gain = lensSizeGain(spanPx, profile);
-  return Math.min(Math.max(thicknessPx, 0) * gain, spanPx * 0.5);
+function lensDepthPx(thicknessPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE, fold = 1) {
+  const thick = Math.max(thicknessPx, 0);
+  const scale = thick / profile.lensThicknessReference;
+  const depth = thick + (lensHeightBasePx(spanPx, profile) * scale - thick) * fold;
+  return Math.min(Math.max(depth, 0), spanPx * 0.5);
 }
-function bodyLod(lensDepth, maxLod, profile = DEFAULT_MATERIAL_PROFILE) {
-  return Math.min(Math.max(lensDepth * profile.lensBodyLodPerPx, 0), maxLod);
+function lensDisplacementPx(depthPx, spanPx, thicknessPx, refractionScale, profile = DEFAULT_MATERIAL_PROFILE, fold = 1) {
+  const extent = lensExtentPx(thicknessPx, spanPx, profile, fold);
+  if (extent <= 0)
+    return 0;
+  const t = Math.max(0, 1 - Math.max(depthPx, 0) / extent);
+  return lensMagnitudePx(thicknessPx, spanPx, profile, fold) * Math.pow(t, profile.lensProfileExponent) * refractionScale;
 }
 
 // ../renderer-webgpu/dist/analysis.js
@@ -826,7 +1170,11 @@ var ZERO_STATS = {
 };
 function statsFromBuffer(values) {
   return {
-    luminance: values[0] ?? 0,
+    // The reduction publishes the ENCODED-space mean (the W9 model, claims
+    // §5.31) and this is its one decode: every consumer downstream — the
+    // drivers, `adaptiveTint`'s fitted thresholds — still speaks linear light,
+    // and a solid backdrop reads identically under either convention.
+    luminance: srgbToLinearChannel(values[0] ?? 0),
     variance: values[1] ?? 0,
     edgeDensity: values[2] ?? 0,
     sampleCount: values[3] ?? 0
@@ -1300,6 +1648,44 @@ function createAppTextureProvider(options) {
   };
 }
 
+// ../renderer-webgpu/dist/backdrop-fit.js
+var IDENTITY_FIT = [1, 1, 0, 0];
+function isUsablePlacement(placement) {
+  return placement !== void 0 && Number.isFinite(placement.x) && Number.isFinite(placement.y) && placement.width > 0 && placement.height > 0;
+}
+function coverFit(sourceWidth, sourceHeight, viewportWidthCss, viewportHeightCss) {
+  const viewportAspect = viewportHeightCss > 0 ? viewportWidthCss / viewportHeightCss : 1;
+  const sourceAspect = sourceHeight > 0 ? sourceWidth / sourceHeight : 1;
+  if (sourceAspect > viewportAspect) {
+    const scaleX = viewportAspect / sourceAspect;
+    return [scaleX, 1, (1 - scaleX) / 2, 0];
+  }
+  const scaleY = sourceAspect / viewportAspect;
+  return [1, scaleY, 0, (1 - scaleY) / 2];
+}
+function placementFit(placement, viewportWidthCss, viewportHeightCss) {
+  return [
+    viewportWidthCss / placement.width,
+    viewportHeightCss / placement.height,
+    -placement.x / placement.width,
+    -placement.y / placement.height
+  ];
+}
+function backdropFit(sourceWidth, sourceHeight, placement, viewportWidthCss, viewportHeightCss) {
+  return isUsablePlacement(placement) ? placementFit(placement, viewportWidthCss, viewportHeightCss) : coverFit(sourceWidth, sourceHeight, viewportWidthCss, viewportHeightCss);
+}
+function texelsPerCssPx(sourceWidth, sourceHeight, placement, viewportWidthCss, viewportHeightCss) {
+  if (isUsablePlacement(placement)) {
+    return sourceWidth > 0 ? sourceWidth / placement.width : 1;
+  }
+  return viewportWidthCss > 0 && viewportHeightCss > 0 ? Math.max(sourceWidth / viewportWidthCss, sourceHeight / viewportHeightCss) : 1;
+}
+function samePlacement(a, b) {
+  if (a === void 0 || b === void 0)
+    return a === b;
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+
 // ../renderer-webgpu/dist/device.js
 function createDeviceHost(options = {}) {
   let status = {
@@ -1610,7 +1996,8 @@ var poolKey = {
   backdropBodyScratch: (sourceId) => `backdrop:${sourceId}:body-scratch`,
   backdropUpload: (sourceId) => `backdrop:${sourceId}:upload`,
   groupField: (groupId) => `group:${groupId}:field`,
-  groupAux: (groupId) => `group:${groupId}:aux`
+  groupAux: (groupId) => `group:${groupId}:aux`,
+  groupAux2: (groupId) => `group:${groupId}:aux2`
 };
 
 // ../renderer-webgpu/dist/gpu-context.js
@@ -1767,7 +2154,7 @@ function resolveSurfaces(group, family, profile = DEFAULT_MATERIAL_PROFILE, poli
       centre: [fieldSource.channels.center[0], fieldSource.channels.center[1]],
       channels,
       spanPx,
-      lensDepthPx: Math.min(Math.max(shape.channels.thickness, 0) * lensSizeGainFromThickness(thickness, profile), spanPx * 0.5),
+      lensDepthPx: lensDepthPx(shape.channels.thickness, spanPx, profile, profile.refractionScale[accessibilityRefractionCap(policy)]),
       sizeThickness: thickness,
       tintStrength: Math.min(1, Math.max(0, surface.tint?.strength ?? 0))
     };
@@ -1832,9 +2219,9 @@ function packInstances(surfaces, origin, into) {
     data[o + 11] = s.shape.channels.thickness;
     data[o + 12] = s.channels.press;
     data[o + 13] = s.channels.glow;
-    data[o + 14] = s.lensDepthPx * Math.min(1, Math.max(0, s.channels.lensStrength));
+    data[o + 14] = Math.max(s.shape.channels.thickness, 0) * Math.min(1, Math.max(0, s.channels.lensStrength));
     data[o + 15] = s.tintStrength;
-    data[o + 16] = s.sizeThickness;
+    data[o + 16] = s.spanPx;
     data[o + 17] = 0;
   }
   return { data, count: surfaces.length };
@@ -2110,9 +2497,9 @@ var WGSL_INSTANCE_STRUCT = `struct Instance {
   thick  : f32,     // 44  material thickness, CSS px
   press  : f32,     // 48  interaction channel value, 0..1
   glow   : f32,     // 52  interaction channel value, 0..1
-  lensDepth : f32,  // 56  CPU-resolved lens depth in CSS px (material.ts), already scaled by the lensStrength channel
+  lensThick : f32,  // 56  authored thickness in CSS px times the lensStrength channel (W12 G2): both depths are evaluated from it per pixel
   tintK  : f32,     // 60  author tint strength, 0..1 \u2014 the seed itself is a group uniform
-  sizeK  : f32,     // 64  the size law's thickness factor, 0..1 \u2014 material.ts's sizeThickness(span)
+  span   : f32,     // 64  the surface's shorter extent, CSS px \u2014 the size law's input, both curves (W11c)
   _pad   : f32,     // 68  stride padding: vec2f aligns the struct to 8, so 72 is the next legal size
 };`;
 var WGSL_FIELD_SAMPLE = `struct FieldSample {
@@ -2278,7 +2665,8 @@ var WGSL_FIELD_PASS = `struct FieldUniforms {
 // field but its members are not one size, and carrying them per pixel is what
 // lets a 40 px button and a 320 px platter share a field pass and still lens by
 // their own depth \u2014 parent acceptance #2 inside a GlassEffectContainer.
-//   aux = (lensDepthPx, glow, sizeK, tintStrength)
+//   aux  = (lensThickPx, glow, spanPx, tintStrength)
+//   aux2 = (p \u2212 centre, half.x, half.y)           \u2014 W12 G2, group-local CSS px
 //
 // The third and fourth slots both changed hands, and neither of the values they
 // used to carry was ever read by a fragment stage. 'thick' left because
@@ -2292,23 +2680,45 @@ var WGSL_FIELD_PASS = `struct FieldUniforms {
 // because a group is one field pass and one optics pass while its members are
 // not one thing:
 //
-//   'sizeK'        \u2014 the size law's thickness factor (W2). A 40 px button and a
-//                    320 px platter in one container lens, scatter, occlude and
-//                    shadow by their own size.
+//   'spanPx'       \u2014 the size law's input (W2): the surface's shorter extent in
+//                    CSS px. A 40 px button and a 320 px platter in one container
+//                    lens, scatter, occlude and shadow by their own size. Until
+//                    W11c this slot carried the folded thickness factor itself;
+//                    the scatter facet now rides a curve with a different band
+//                    top, so the span travels and each consumer evaluates its own
+//                    curve from it with the bands and the fold as uniforms.
 //   'tintStrength' \u2014 the author tint's strength (W3). One emphasised control
 //                    among plain ones is the composition Apple's guidance
 //                    describes; the seed itself is a group uniform.
 //
 // They compose rather than compete: the size law moves what the material does to
 // the backdrop, the tint moves what colour it does it in.
+//
+// One consequence of carrying the span rather than the thickness, stated so it
+// is not mistaken for a drift: the union below blends 'aux' linearly between two
+// members, so a pixel in the neck between a button and a platter now blends
+// their SPANS and evaluates the curves on the blend, where it used to blend the
+// evaluated thicknesses. Inside either member the two are identical; only the
+// smooth-min neck differs, and nothing measured claims a value there.
+//
+// 'aux2' (W12 G2) carries the pixel's offset from the owning surface's centre
+// and that surface's half-extents, which
+// the optics pass needs for the lens's direction: the reference displaces along
+// the gradient of its SDF blended toward the oval inscribed in the shape's box
+// (claims \xA75.50's 'gradientOvalization'), and an oval is a property of the box,
+// not of the distance field. Blended by the same weight as 'aux' in a neck, so
+// two merged members share one oval there \u2014 a value nothing measured either.
+// For a concentric child the box is the parent's (the child is the parent's
+// level set), which is the same centre and a slightly larger oval.
 
 @group(0) @binding(0) var<uniform> fu : FieldUniforms;
 @group(0) @binding(1) var<storage, read> instances : array<Instance>;
 
 struct Member {
-  d   : f32,
-  g   : vec2f,
-  aux : vec4f,
+  d    : f32,
+  g    : vec2f,
+  aux  : vec4f,
+  aux2 : vec4f,
 };
 
 fn eval_instance(i : u32, p : vec2f) -> Member {
@@ -2321,13 +2731,17 @@ fn eval_instance(i : u32, p : vec2f) -> Member {
   var m : Member;
   m.d = f.d + s.inset;
   m.g = f.g;
-  m.aux = vec4f(s.lensDepth, s.glow, s.sizeK, s.tintK);
+  m.aux = vec4f(s.lensThick, s.glow, s.span, s.tintK);
+  // The pixel relative to the surface's centre, and the half-extents: what the
+  // oval's gradient needs, written here where the group-local position is exact.
+  m.aux2 = vec4f(p - s.centre, s.half);
   return m;
 }
 
 struct FieldOut {
   @location(0) field : vec4f,
   @location(1) aux   : vec4f,
+  @location(2) aux2  : vec4f,
 };
 
 @fragment
@@ -2345,6 +2759,7 @@ fn fs_field(in : FullscreenOut) -> FieldOut {
     // coverage downstream is not reliably zero.
     out.field = vec4f(65000.0, 0.0, -1.0, 0.0);
     out.aux = vec4f(0.0);
+    out.aux2 = vec4f(0.0);
     return out;
   }
 
@@ -2357,6 +2772,7 @@ fn fs_field(in : FullscreenOut) -> FieldOut {
     acc.d = blend.x;
     acc.g = mix(s.g, acc.g, h);
     acc.aux = mix(s.aux, acc.aux, h);
+    acc.aux2 = mix(s.aux2, acc.aux2, h);
     nearest = min(nearest, s.d);
   }
   // One clamp at the end of the fold, so |union - min| <= maxBulge holds for any
@@ -2369,6 +2785,7 @@ fn fs_field(in : FullscreenOut) -> FieldOut {
 
   out.field = vec4f(acc.d, normal.x, normal.y, coverage);
   out.aux = acc.aux;
+  out.aux2 = acc.aux2;
   return out;
 }`;
 function fieldPassSource(family) {
@@ -2409,7 +2826,10 @@ var WGSL_HIGHLIGHT_PASS = `struct HighlightUniforms {
   /// accessibility refraction cap, and the resolved strength \u2014 zero where there
   /// is no measured backdrop tone, which stands the fade down
   toneAdapt : vec4f,
-  /// the backdrop source's own average luminance (x); yzw unused
+  /// the backdrop source's own average luminance (x), and the size law's band
+  /// and fold \u2014 sizeSpanMin (y), sizeSpanMax (z), the accessibility fold (w) \u2014
+  /// so this pass evaluates the thickness curve off the per-pixel span exactly
+  /// as the optics pass does (W11c: the span rides the field, not the factor)
   toneLevel : vec4f,
   /// this pass's uv into the FIELD texture's uv: scale (xy), offset (zw).
   ///
@@ -2489,7 +2909,14 @@ fn fs_highlight(in : FullscreenOut) -> @location(0) vec4f {
    * around a surface the optics pass had made invisible \u2014 measured at 60 pixels
    * past 2/255, peaking at 97/255, on exactly that cell.
    */
-  let sizeK = clamp(aux.z, 0.0, 1.0);
+  // The thickness curve off the per-pixel span, written out as the optics pass
+  // writes it, so the two passes fade on one curve and not on two copies.
+  let spanT = clamp(
+    (aux.z - hu.toneLevel.y) / max(hu.toneLevel.z - hu.toneLevel.y, 1e-6),
+    0.0,
+    1.0,
+  );
+  let sizeK = clamp(spanT * spanT * (3.0 - 2.0 * spanT) * hu.toneLevel.w, 0.0, 1.0);
   var toneAdapt = 0.0;
   if (hu.toneAdapt.w > 0.0) {
     let toneX = hu.toneLevel.x + hu.toneAdapt.z * sizeK;
@@ -2514,7 +2941,9 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   screen : vec4f,
   /// backdrop uv transform on viewport-normalised coords: scale (xy), offset (zw)
   fit : vec4f,
-  /// refractionScale, bodyLodPerPx, rimLodBias, chainMaxLod
+  /// refractionScale, lensRefractionGain (W12 G2: the gain on the reference's
+  /// amount law), the inner shadow's depth gain (W2's lensSizeGainMax, which the
+  /// shadow keeps), chainMaxLod
   lens : vec4f,
   /// fixed tint colour, linear light (xyz), tint alpha (w)
   tint : vec4f,
@@ -2522,7 +2951,10 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   adapt : vec4f,
   /// author tint seed, linear light (xyz), tone adaptation under the contrast regime (w)
   seed : vec4f,
-  /// tintToneFloor, tintToneCeilMix, tintToneLow, tintToneHigh
+  /// the author tint's shade law (W10): tintShadeDark, tintShadeLight,
+  /// tintShadeStrength (the profile's provenance gate); and (w) the size law's
+  /// accessibility fold \u2014 the refraction ladder read at the preference's cap,
+  /// which every facet's span-dependent rise is multiplied by (W11c)
   tone : vec4f,
   /// rimWidthPx, rimAlpha, specularPower, specularGain
   rim : vec4f,
@@ -2542,18 +2974,68 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   toneAdapt : vec4f,
   /// the backdrop source's own average colour, linear (xyz), and its luminance (w)
   toneColour : vec4f,
-  /// the outer shadow (W8): its compositing-space alpha before the size law (x),
-  /// the blur's sigma in group-local CSS px (y), the silhouette's outward spread
-  /// in the same units (z), and the downward offset expressed in field-texture UV
-  /// (w) \u2014 a UV so the offset silhouette is one texture read rather than a
-  /// gradient extrapolation, which is exact only on a straight edge and a capsule
-  /// is mostly not one
+  /// the outer shadow (W8, amplitude re-read by W14 G1): the THIN regime's peak
+  /// LINEAR occlusion, already resolved at this group's backdrop luminance and
+  /// already folded under the accessibility policy (x) \u2014 a linear occlusion and
+  /// no longer a compositing alpha, because the shader now blends two regimes
+  /// before it converts; the blur's sigma in group-local CSS px (y), the
+  /// silhouette's outward spread in the same units (z), and the downward offset
+  /// expressed in field-texture UV (w) \u2014 a UV so the offset silhouette is one
+  /// texture read rather than a gradient extrapolation, which is exact only on a
+  /// straight edge and a capsule is mostly not one
   shadow : vec4f,
   /// the outer shadow's size-law gain (x), read against the casting surface's own
   /// thickness, and the field rect's height in CSS px (y) \u2014 the conversion the
-  /// shadow's shift needs when it lands outside the texture; z and w are the
+  /// shadow's shift needs when it lands outside the texture; the body depth
+  /// ramp's THICK start (z, W13 G1's third form \u2014 the thin end is scatter.y and
+  /// this pass mixes the two by the pixel's own sizeThickness), and (w) the
   /// padding a uniform's vec4 alignment requires
   shadowSize : vec4f,
+  /// the backdrop tone response's anchors (W9): the three solid anchors'
+  /// ENCODED-space means (xyz), and the backdrop's linear-space mean (w) \u2014 the
+  /// quantity the response solve composites against
+  toneAnchor : vec4f,
+  /// the response law's thin row: the reference's settled interior levels at the
+  /// three anchors for a surface of sizeThickness 0 (xyz); w is the law's
+  /// per-profile authority \u2014 0 on dark profiles, whose response is unmeasured
+  toneRowThin : vec4f,
+  /// the thick row (sizeThickness saturated), same layout
+  toneRowThick : vec4f,
+  /// the size law's bands: the scatter facet's floor (x) and the depth ramp's
+  /// THIN start s0 at the ratio this group draws at (y, W13 G1 \u2014 the CPU has
+  /// already interpolated it between the profile's 1x and 2x anchors; the thick
+  /// end is shadowSize.z), and the
+  /// thickness curve's sizeSpanMin (z) and sizeSpanMax (w); the fold both
+  /// multiply by is tone.w. The scatter span curve's own band top is lensOval.w,
+  /// and it starts at the same z.
+  scatter : vec4f,
+  /// the lens law (W12 G2): the reference's height law (lensHeightPerSpan,
+  /// lensHeightMax) and amount law (lensAmountPerSpan, lensAmountMax)
+  lensLaw : vec4f,
+  /// the lens profile (W12 G2): lensExtentGain, lensProfileExponent,
+  /// lensOvalization, lensThicknessReference
+  lensShape : vec4f,
+  /// the ovalization's knee (W12 G2): spanMin (x), spanMax (y); the body depth
+  /// ramp's reach in group-local CSS px (z, W13 G1) \u2014 the profile names it in
+  /// device px and the CPU divides by the ratio, so that this shader can read
+  /// the field's own CSS-px depth without a second conversion; the scatter span
+  /// curve's band top sizeScatterSpanMax (w, W11c), which W13 G1 keeps
+  /// underneath the ramp as its deep value
+  lensOval : vec4f,
+  /// the outer shadow's THICK regime (W14 G1): the composite's peak linear
+  /// occlusion at casting spans 96, 128 and 160 CSS px (xyz), already folded
+  /// under the accessibility policy, piecewise-linear between and held outside;
+  /// and (w) the body depth ramp's FAR start (W13 G1's fourth form) \u2014 the start
+  /// at span >= sizeScatterSpanMax, which the ramp declines to from the thick
+  /// end along the scatter span curve, in the slot W14 left free
+  shadowThick : vec4f,
+  /// the lift (W14 G1), the shadow's second term and GPU-tier only: its peak
+  /// amplitude in LINEAR light as a fraction of the blurred backdrop's own
+  /// luminance (x), the span rise's foot and top in CSS px (yz), and the chain
+  /// LOD whose blur is the profile's liftBlurSigmaCss \u2014 resolved on the CPU,
+  /// which is the only place the CSS-px-to-texel conversion is knowable, and
+  /// already clamped to chainMaxLod (w)
+  shadowLift : vec4f,
 };
 
 @group(0) @binding(0) var<uniform> ou : OpticsUniforms;
@@ -2563,6 +3045,45 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
 @group(0) @binding(4) var backdropChain : texture_2d<f32>;
 @group(0) @binding(5) var backdropBody : texture_2d<f32>;
 @group(0) @binding(6) var fieldSampler : sampler;
+/// The owning surface's box per pixel (W12 G2): the pixel's offset from its
+/// centre (xy) and its half-extents (zw), group-local CSS px \u2014 the lens's oval.
+@group(0) @binding(7) var aux2Texture : 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 {
+  let x = clamp(c, 0.0, 1.0);
+  return select(1.055 * pow(x, 1.0 / 2.4) - 0.055, x * 12.92, x <= 0.0031308);
+}
+
+/// The backdrop tone response R(encodedInput, sizeK) (W9): monotone
+/// (Fritsch\u2013Carlson) interpolation through the three anchors, clamped to their
+/// span; smoothstep between the thin and thick rows. Mirrors material.ts's
+/// 'backdropToneResponse' term for term \u2014 the constants are authored there.
+fn tone_response(x : f32, sizeK : f32) -> f32 {
+  let f = sizeK * sizeK * (3.0 - 2.0 * sizeK);
+  let ys = mix(ou.toneRowThin.xyz, ou.toneRowThick.xyz, vec3f(f));
+  let xs = ou.toneAnchor.xyz;
+  let xc = clamp(x, xs.x, xs.z);
+  let h0 = max(xs.y - xs.x, 1e-4);
+  let h1 = max(xs.z - xs.y, 1e-4);
+  let d0 = (ys.y - ys.x) / h0;
+  let d1 = (ys.z - ys.y) / h1;
+  // The interior slope: the harmonic mean where the secants agree, 0 across a
+  // sign change \u2014 what keeps the curve monotone between monotone anchors.
+  var m1 = 0.0;
+  if (d0 * d1 > 0.0) { m1 = 2.0 * d0 * d1 / (d0 + d1); }
+  var h = h0; var t = (xc - xs.x) / h0;
+  var y0 = ys.x; var y1 = ys.y; var s0 = d0; var s1 = m1;
+  if (xc > xs.y) {
+    h = h1; t = (xc - xs.y) / h1;
+    y0 = ys.y; y1 = ys.z; s0 = m1; s1 = d1;
+  }
+  return y0 * (1.0 + 2.0 * t) * (1.0 - t) * (1.0 - t)
+       + s0 * h * t * (1.0 - t) * (1.0 - t)
+       + y1 * t * t * (3.0 - 2.0 * t)
+       + s1 * h * t * t * (t - 1.0);
+}
 
 /// Rim proximity: 1 exactly on the contour, falling to 0 by 'width' on either
 /// side. Symmetric, so the rim is a band on the boundary rather than a plateau
@@ -2582,7 +3103,33 @@ fn outer_shadow_falloff(signedDistance : f32, sigma : f32) -> f32 {
   return 0.5 * (1.0 + tanh(0.7978845608028654 * (x + 0.044715 * x * x * x)));
 }
 
-/// The outer shadow's alpha at this pixel (W8).
+/// What one pixel's outer shadow is made of: the compositing-space alpha the
+/// black term composites at, the falloff BOTH terms ride, and the span of the
+/// surface that cast it \u2014 which the lift's own rise is read from.
+///
+/// One struct rather than three calls because there is one falloff (W14 G0,
+/// claims \xA75.62 \xA74): the black term's free fit and the lift's free fit return
+/// the same sigma, offset and spread, so evaluating a second geometry for the
+/// second term would be asserting a difference the measurement denies.
+struct ShadowSample {
+  alpha : f32,
+  falloff : f32,
+  castSpanCss : f32,
+};
+
+/// The composite's peak linear occlusion above the knee, at a casting span \u2014
+/// piecewise linear through the three measured anchors (96 / 128 / 160 CSS px)
+/// and held flat outside them. Mirrors material.ts's
+/// 'outerShadowThickOcclusion'.
+fn outer_shadow_thick(spanCss : f32) -> f32 {
+  let y = ou.shadowThick.xyz;
+  if (spanCss <= 96.0) { return y.x; }
+  if (spanCss >= 160.0) { return y.z; }
+  if (spanCss <= 128.0) { return y.x + (y.y - y.x) * (spanCss - 96.0) / 32.0; }
+  return y.y + (y.z - y.y) * (spanCss - 128.0) / 32.0;
+}
+
+/// The outer shadow's alpha at this pixel (W8, amplitude W14 G1).
 ///
 /// The shadow is the group's OWN field, translated down by 'shadow.w' in field
 /// UV and outset by 'shadow.z', then blurred. Reading the offset silhouette from
@@ -2593,9 +3140,13 @@ fn outer_shadow_falloff(signedDistance : f32, sigma : f32) -> f32 {
 /// The value is an ALPHA on pure black, so what it composites to is the backdrop
 /// times '1 - alpha' \u2014 multiplicative occlusion, and exactly zero over black,
 /// with no branch for it.
-fn outer_shadow_alpha(uv : vec2f, upsampled : f32, fieldSize : vec2f) -> f32 {
-  if (ou.shadow.x <= 0.0) {
-    return 0.0;
+fn outer_shadow(uv : vec2f, upsampled : f32, fieldSize : vec2f) -> ShadowSample {
+  var out : ShadowSample;
+  out.alpha = 0.0;
+  out.falloff = 0.0;
+  out.castSpanCss = 0.0;
+  if (ou.shadow.x <= 0.0 && ou.shadowThick.x <= 0.0) {
+    return out;
   }
   /*
    * The shift can leave the field texture, and clamping alone reads a lie there.
@@ -2631,19 +3182,78 @@ fn outer_shadow_alpha(uv : vec2f, upsampled : f32, fieldSize : vec2f) -> f32 {
   }
 
   // The size law reaches the amplitude and nothing else \u2014 the reference's three
-  // lengths are span-invariant across 32\u2026160 px. The gain rides the thickness of
-  // the surface that CAST the shadow, which is the one read at the offset
-  // position rather than the one under the pixel being shaded.
+  // lengths are span-invariant across 32\u2026160 px. Every span-keyed quantity here
+  // rides the thickness and the span of the surface that CAST the shadow, which
+  // is the one read at the offset position rather than the one under the pixel
+  // being shaded.
   //
-  // Applied on '1 - alpha' rather than on the alpha: the gain is a fraction of
-  // the remaining transparency in LINEAR light ('sizeOuterShadowOcclusionAt'),
-  // and (1 - occ) is exactly what raising to 1/2.4 turns into (1 - alpha), so the
-  // two forms are the same law and neither needs the other's space.
-  let sizeK = clamp(shadowAux.z, 0.0, 1.0);
-  let sizeFold = pow(max(1.0 - ou.shadowSize.x * sizeK, 0.0), 1.0 / 2.4);
-  let alpha = 1.0 - (1.0 - ou.shadow.x) * sizeFold;
-
-  return alpha * outer_shadow_falloff(shadowField.x + clampedOffCss - ou.shadow.z, ou.shadow.y);
+  // The thickness curve off the casting surface's span (W11c: the span rides
+  // the field), written as the body's own is below.
+  let castT = clamp(
+    (shadowAux.z - ou.scatter.z) / max(ou.scatter.w - ou.scatter.z, 1e-6),
+    0.0,
+    1.0,
+  );
+  let sizeK = clamp(castT * castT * (3.0 - 2.0 * castT) * clamp(ou.tone.w, 0.0, 1.0), 0.0, 1.0);
+
+  // The two regimes and the knee between them (W14 G1). The thin amplitude is
+  // resolved on the CPU because its key \u2014 the backdrop's luminance \u2014 is one
+  // number for the whole group; the thick one is a span law and has to be per
+  // pixel. The blend is the smoothstep of 'sizeK', which is exactly the curve
+  // 'tone_response' blends its own thin and thick rows across: one knee for the
+  // face and the shadow, which is the charter's third binding rule read from
+  // the other side.
+  let blend = sizeK * sizeK * (3.0 - 2.0 * sizeK);
+  let regime = mix(ou.shadow.x, outer_shadow_thick(shadowAux.z), blend);
+  // The size gain, on the relative form 'sizeOuterShadowOcclusionAt' uses, in
+  // LINEAR light; then the one conversion to the canvas's compositing space,
+  // which is where the black term is actually composited.
+  let occ = clamp(regime + ou.shadowSize.x * sizeK * (1.0 - regime), 0.0, 1.0);
+  out.alpha = 1.0 - pow(1.0 - occ, 1.0 / 2.4);
+  out.falloff = outer_shadow_falloff(shadowField.x + clampedOffCss - ou.shadow.z, ou.shadow.y);
+  out.castSpanCss = shadowAux.z;
+  return out;
+}
+
+/// The lift (W14 G1) \u2014 the shadow's second term, in LINEAR light, premultiplied
+/// by nothing yet: a blurred copy of the backdrop's own light, at an amplitude
+/// that is zero below the knee and saturating above it, on the SAME falloff the
+/// black term rides.
+///
+/// 'V' is the backdrop chain read at the pixel's OWN position \u2014 the copy is of
+/// the backdrop beneath the shadow, not of the backdrop under the surface \u2014 at
+/// the LOD whose blur is the profile's 40 CSS px. The chain's uv transform is on
+/// viewport-normalised coordinates, so every pixel this pass draws has a valid
+/// sample: unlike the field texture, which the offset shift can walk off the top
+/// of, the chain covers the whole viewport and there is nothing to reconstruct.
+///
+/// Zero over black by construction (V = 0), zero below the knee by the rise, and
+/// zero where the group has no backdrop to copy \u2014 so 'dark-solid', 'impulse',
+/// every thin cell and every unsampled group stay byte-for-byte what they were.
+fn outer_shadow_lift(viewport01 : vec2f, shadow : ShadowSample) -> vec3f {
+  if (ou.flags.x <= 0.5 || ou.shadowLift.x <= 0.0 || shadow.falloff <= 0.0) {
+    return vec3f(0.0);
+  }
+  // Written out rather than through WGSL's 'smoothstep', which is undefined
+  // where the two edges coincide \u2014 a profile is entitled to set the rise's foot
+  // and top to one number, and material.ts's own 'smoothstep' degrades that to a
+  // step rather than to a NaN. Same rule as the tone band's divide above.
+  let riseT = clamp(
+    (shadow.castSpanCss - ou.shadowLift.y) / max(ou.shadowLift.z - ou.shadowLift.y, 1e-6),
+    0.0,
+    1.0,
+  );
+  let rise = riseT * riseT * (3.0 - 2.0 * riseT);
+  if (rise <= 0.0) {
+    return vec3f(0.0);
+  }
+  let uv = clamp(viewport01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
+  let chainSample = textureSampleLevel(backdropChain, backdropSampler, uv, ou.shadowLift.w);
+  // Premultiplied linear in, straight colour out \u2014 the same unpremultiply the
+  // body's own samples take, for the same reason: a partially transparent
+  // backdrop must not darken what the material adds back.
+  let v = chainSample.rgb / max(chainSample.a, 1e-6);
+  return v * (ou.shadowLift.x * rise * shadow.falloff);
 }
 
 @fragment
@@ -2655,13 +3265,16 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // contour to the coarse grid and the rim would step along it.
   var field : vec4f;
   var aux : vec4f;
+  var aux2 : vec4f;
   if (ou.flags.w > 0.5) {
     field = textureSampleLevel(fieldTexture, fieldSampler, in.uv, 0.0);
     aux = textureSampleLevel(auxTexture, fieldSampler, in.uv, 0.0);
+    aux2 = textureSampleLevel(aux2Texture, fieldSampler, in.uv, 0.0);
   } else {
     let texel = vec2i(in.uv * ou.flags.yz);
     field = textureLoad(fieldTexture, texel, 0);
     aux = textureLoad(auxTexture, texel, 0);
+    aux2 = textureLoad(aux2Texture, texel, 0);
   }
 
   let d = field.x;
@@ -2677,61 +3290,202 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
    * is clipped out of its own border box, and the two meet across the coverage
    * ramp with no seam because it is one expression.
    */
-  let shadowAlpha = outer_shadow_alpha(in.uv, ou.flags.w, ou.flags.yz);
+  let shadowSample = outer_shadow(in.uv, ou.flags.w, ou.flags.yz);
+  let shadowAlpha = shadowSample.alpha * shadowSample.falloff;
+  let viewport01 = in.position.xy / ou.screen.xy;
+  // Resolved once, for both sides of the coverage ramp: the lift fills exactly
+  // what the surface's coverage leaves, on the same rule and in the same
+  // expression as the black term's alpha at the bottom of this function, so the
+  // two meet across the ramp with no seam. At full coverage it is not computed
+  // at all and the chain read is not taken.
+  var liftEncoded = vec3f(0.0);
+  if (coverage < 1.0) {
+    let lift = outer_shadow_lift(viewport01, shadowSample);
+    liftEncoded = min(linear_to_srgb(max(lift, vec3f(0.0))), vec3f(shadowAlpha));
+  }
   if (coverage <= 0.0) {
-    return vec4f(0.0, 0.0, 0.0, shadowAlpha);
+    /*
+     * The lift (W14 G1) makes this a premultiplied COMPOSITE rather than an
+     * alpha on black: the compositor produces 'page\xB7(1 \u2212 shadowAlpha) + lift',
+     * which is the reference's own two-term form outside the coverage.
+     *
+     * The added light is computed in linear light and encoded on its own before
+     * it is emitted, because it IS its own light \u2014 over the checkerboard's black
+     * squares, where the multiply is inert, what the reference adds is exactly
+     * this term and nothing else, and encoding it alone reproduces G0's measured
+     * +0.048 encoded at span 160 from its +0.0038 linear (claims \xA75.62 \xA72, \xA73).
+     * Where the backdrop is bright the encoding of a sum and the sum of the
+     * encodings differ, and this term is the second: the residual is bounded by
+     * the term's own size and is well inside the bed's \xB14/255, on the same
+     * honest-floor argument 'outerShadowAlpha' makes for the black term's space.
+     *
+     * A premultiplied layer may not carry a channel above its own alpha, so the
+     * emitted light is capped at 'shadowAlpha'. At the profile's constants the
+     * cap is inert everywhere on the falloff: both terms are proportional to the
+     * same F, and the lift's encoded value stays at about a sixth of the black
+     * term's alpha from the deepest ring out to where the shadow stops moving a
+     * code. It is here so that a swept amplitude produces a valid layer rather
+     * than an implementation-defined one.
+     */
+    return vec4f(liftEncoded, shadowAlpha);
   }
 
-  let viewport01 = in.position.xy / ou.screen.xy;
   let viewportCss = ou.screen.xy * ou.screen.z;
 
-  // Per-pixel, unioned through the field pass. See the module note.
-  let lensDepth = max(aux.x, 1e-4);
-  // The size law's thickness factor for whichever surface owns this pixel, 0..1.
-  // Zero on anything at or below the profile's 'sizeSpanMin', and every term
-  // below multiplies by it \u2014 so a small control takes the pre-law path exactly.
-  let sizeK = clamp(aux.z, 0.0, 1.0);
-  // '-d' is depth inside the surface, so the profile runs 1 at the contour to 0
-  // at 'lensDepth' inward, and the square makes the falloff read as curvature
-  // rather than as a linear ramp.
-  let depth = clamp(-d / lensDepth, 0.0, 1.0);
-  let profile = (1.0 - depth) * (1.0 - depth);
-
-  let displaceCss = -normal * lensDepth * profile * ou.lens.x;
+  // Per-pixel, unioned through the field pass. See the module note. 'aux.x' is
+  // the authored thickness times the lensStrength channel (W12 G2); the lens's
+  // depth and the inner shadow's are both evaluated from it and the span below.
+  let lensThick = max(aux.x, 0.0);
+  // The thickness curve off the span of whichever surface owns this pixel
+  // (W11c). 'sizeK' is the thickness factor, 0..1: zero on anything at or below
+  // the profile's 'sizeSpanMin', saturated at 'sizeSpanMax', folded under the
+  // preference \u2014 the occlusion, the inner shadow and the tone response multiply
+  // by it, so a small control takes the pre-law path exactly. Written out as a
+  // smoothstep with a guarded denominator, so a profile that collapses the band
+  // degrades to a step rather than to NaN.
+  let span = aux.z;
+  let fold = clamp(ou.tone.w, 0.0, 1.0);
+  let thickT = clamp((span - ou.scatter.z) / max(ou.scatter.w - ou.scatter.z, 1e-6), 0.0, 1.0);
+  // The unfolded curve, which the depth ramp's start grades along below, and the
+  // folded factor every other facet multiplies by. One smoothstep, two readings.
+  let sizeThick = thickT * thickT * (3.0 - 2.0 * thickT);
+  let sizeK = clamp(sizeThick * fold, 0.0, 1.0);
+  /*
+   * The body's mix is the span curve W11c fitted with a ramp in DEPTH riding on
+   * top of it near the contour (W13 G1, from the measurement of claims \xA75.61 \xA72
+   * and the re-forming its first runtime sweep forced):
+   *
+   *   kDeep = floor + (1 - floor) * smoothstep(sizeSpanMin, sizeScatterSpanMax, span)
+   *   s0    = startThin + (startThick - startThin) * sizeThickness(span)
+   *         + (startFar - startThick) * smoothstep(sizeSpanMax, sizeScatterSpanMax, span)
+   *   s(u)  = (1 - kDeep) + max(0, s0 - (1 - kDeep)) * max(0, 1 - u / U)
+   *   k(u)  = 1 - s(u)
+   *
+   * The first form of the ramp replaced the span curve outright and its sweep
+   * measured what that cost: the ramp's own projection onto one number per
+   * surface runs 0.43-0.56 where the curve it replaced runs 0.41-1.00, so the
+   * family is nearly span-flat where the bed is strongly span-graded and no
+   * point in 81 reached the wave's stops. So the curve stays as the deep value
+   * and the ramp is what it always measured as - a near-contour excursion.
+   *
+   * The SECOND form gave that excursion one start per scale, and its own sweep
+   * refuted that arithmetically (claims \xA75.64 \xA72): the smallest cell's span is
+   * exactly sizeSpanMin, so its deep sharp share is exactly 1 - floor and no
+   * start at or below it can touch that cell, while the next span up only
+   * improves BELOW a start lower still. So the start grades with span too, and
+   * along the material's own thin/thick curve rather than a new one - the same
+   * smoothstep 'sizeK' is built from above, unfolded, because s0 is a share the
+   * reference has and not a rise a preference removes. The fold below still
+   * applies once, on the composed mix.
+   *
+   * The THIRD form stopped there and its holdout failed on one row for the
+   * form's own arithmetic (claims \xA75.67 \xA74): sizeThickness saturates at
+   * sizeSpanMax, so every thick span got the same start while the reference's
+   * start keeps FALLING across the thick spans, and because kDeep keeps rising
+   * to sizeScatterSpanMax the excursion grew with span where the reference's
+   * shrinks. So the FOURTH form declines the start past the knee along the
+   * scatter span curve itself \u2014 the same smoothstep 'deepT' is built from, on
+   * the band above the thickness knee \u2014 from the thick anchor to startFar at
+   * sizeScatterSpanMax. Same curve read twice, no new span statistic.
+   *
+   * '-d' is the depth, in group-local CSS px and unclamped - the same quantity
+   * the lens's 'lensT' and the inner shadow's 'shadowT' are evaluated from,
+   * except that those two divide it by a depth of their own while this reads it
+   * absolutely, because the reach measured as a LENGTH rather than as a fraction
+   * of the span. The reach reaches this shader already divided by the device
+   * ratio ('lensOval.z'), so the ratio 'u / U' is the same number in CSS px as
+   * it is in the device px the profile names.
+   *
+   * 'max(s0 - sDeep, 0)' rather than a signed difference: the excursion is the
+   * band the reference has ABOVE the body, and a span whose deep sharp share
+   * already exceeds s0 has nothing to add rather than something to subtract.
+   *
+   * The fold keeps its W11c semantics on the composed law: the floor is the
+   * frost the material has at any size and is not folded, everything above it -
+   * the span curve's rise and the ramp's excursion alike - is depth and is, so
+   * fold 1 renders the law and fold 0 sits at the floor exactly.
+   */
+  let scatterFloor = clamp(ou.scatter.x, 0.0, 1.0);
+  let deepT = clamp((span - ou.scatter.z) / max(ou.lensOval.w - ou.scatter.z, 1e-6), 0.0, 1.0);
+  let kDeep = scatterFloor + (1.0 - scatterFloor) * deepT * deepT * (3.0 - 2.0 * deepT);
+  let sDeep = 1.0 - kDeep;
+  let rampT = max(1.0 - max(-d, 0.0) / max(ou.lensOval.z, 1e-6), 0.0);
+  let farT = clamp((span - ou.scatter.w) / max(ou.lensOval.w - ou.scatter.w, 1e-6), 0.0, 1.0);
+  let farS = farT * farT * (3.0 - 2.0 * farT);
+  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);
+  // 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;
+  // the occlusion keeps it, because nothing measured it as wrong, and every
+  // solid-backdrop cell renders exactly as it did.
+  let shadowLensDepth = max(min(lensThick * (1.0 + (ou.lens.z - 1.0) * sizeK), span * 0.5), 1e-4);
+  let shadowT = clamp(-d / shadowLensDepth, 0.0, 1.0);
+  let shadowProfile = (1.0 - shadowT) * (1.0 - shadowT);
+
+  // The lens (W12 G2, claims \xA75.51) \u2014 see the module note. The reference's
+  // height and amount laws off the span, scaled by the thickness over the
+  // reference's unit, folded like the W2 law (at fold 0 the depth is the
+  // authored thickness and nothing more), and clamped to the shorter half
+  // extent with the magnitude clamped by the same ratio.
+  let thickScale = lensThick / max(ou.lensShape.w, 1e-4);
+  let heightBase = min(ou.lensLaw.x * span, ou.lensLaw.y);
+  let amountBase = min(ou.lensLaw.z * span, ou.lensLaw.w);
+  let depthUnclamped = mix(lensThick, heightBase * thickScale, fold);
+  let lensDepth = clamp(depthUnclamped, 0.0, span * 0.5);
+  let clampRatio = select(0.0, lensDepth / depthUnclamped, depthUnclamped > 1e-6);
+  let magnitude = ou.lens.y * mix(lensThick, amountBase * thickScale, fold) * clampRatio;
+  let extent = max(ou.lensShape.x * lensDepth, 1e-4);
+  // One steep power over the extent; '-d' is depth inside the surface.
+  let lensT = max(1.0 - max(-d, 0.0) / extent, 0.0);
+  let displacementCss = magnitude * pow(lensT, ou.lensShape.y) * ou.lens.x;
+
+  // The direction: the field's gradient blended toward the oval inscribed in
+  // the surface's box (the reference's 'gradientOvalization'), on from the
+  // knee, with the magnitude fixed \u2014 which tilts the displacement toward the
+  // edge's midpoint and magnifies the band along the edge.
+  let ovalT = clamp((span - ou.lensOval.x) / max(ou.lensOval.y - ou.lensOval.x, 1e-6), 0.0, 1.0);
+  let omega = ou.lensShape.z * ovalT * ovalT * (3.0 - 2.0 * ovalT);
+  let halfExt = max(aux2.zw, vec2f(1e-4));
+  let rel = aux2.xy;
+  let unitR = max(length(rel / halfExt), 1e-6);
+  let ovalGrad = (rel / (halfExt * halfExt)) * (min(halfExt.x, halfExt.y) / unitR);
+  let blended = (1.0 - omega) * normal + omega * ovalGrad;
+  let blendLen = length(blended);
+  let direction = select(normal, blended / blendLen, blendLen > 1e-6);
+  let displaceCss = -direction * displacementCss;
   let refracted01 = viewport01 + displaceCss / viewportCss;
 
-  let straightUv = clamp(viewport01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
   let refractedUv = clamp(refracted01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
 
-  let bodyLod = clamp(lensDepth * ou.lens.y, 0.0, ou.lens.w);
-  let lod = clamp(bodyLod - ou.lens.z * profile, 0.0, ou.lens.w);
-
   /*
    * The scattering facet of the size law: "a softer scattering of light".
    *
    * The body texture is one blur for the whole backdrop source \u2014 it is built once
    * per source per frame, so it cannot be per-surface. The chain beside it can:
    * 'size.w' is the chain level whose blur already matches that body, so
-   * 'size.w + log2(scatterGain)' is the level whose blur is 'scatterGain' times
-   * wider, and lerping the body toward it by 'sizeK' widens the kernel with the
-   * surface. At sizeK = 0 the weight is zero and the body sample stands alone,
-   * which is what makes the whole facet inert on a small control.
+   * 'size.w + log2(sizeScatterGainMax)' is the level whose blur is the gain times
+   * wider \u2014 the HEAVY component, at one fixed level \u2014 and lerping the body toward
+   * it by 'kScatter' is what the reference's interior measures (W11c, claims
+   * \xA75.41): a sharp component near the body's \u03C3 and a heavy one near \u03C3 10, mixed
+   * by a share that is \u2248 0.4 on a small control and rises with the span. The
+   * mix, not the level, is what the span moves.
    */
-  let scatterGain = 1.0 + (ou.size.x - 1.0) * sizeK;
-  let scatterLod = clamp(ou.size.w + log2(max(scatterGain, 1e-4)), 0.0, ou.lens.w);
+  let scatterLod = clamp(ou.size.w + log2(max(ou.size.x, 1e-4)), 0.0, ou.lens.w);
 
   var backdrop = vec3f(0.0);
   if (ou.flags.x > 0.5) {
-    let lensSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, lod);
-    let bodySample = textureSampleLevel(backdropBody, backdropSampler, straightUv, 0.0);
-    let scatterSample = textureSampleLevel(backdropChain, backdropSampler, straightUv, scatterLod);
+    // Both components at the refracted position (W11c G2): the band and the
+    // interior are one body, and the displacement alone is the lens.
+    let bodySample = textureSampleLevel(backdropBody, backdropSampler, refractedUv, 0.0);
+    let scatterSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, scatterLod);
     // 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 lensColour = lensSample.rgb / max(lensSample.a, 1e-6);
     let scatterColour = scatterSample.rgb / max(scatterSample.a, 1e-6);
-    let bodyColour = mix(bodySample.rgb / max(bodySample.a, 1e-6), scatterColour, sizeK);
-    backdrop = mix(bodyColour, lensColour, profile);
+    backdrop = mix(bodySample.rgb / max(bodySample.a, 1e-6), scatterColour, kScatter);
   }
 
   // Adaptive tint. 'adapt.w' is the strength the accessibility policy and the
@@ -2739,8 +3493,6 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // is what a 'hint' or 'none' group gets.
   let neutral = mix(ou.tint.rgb, ou.adapt.rgb, ou.adapt.w);
 
-  let backdropLuma = dot(backdrop, vec3f(0.2126, 0.7152, 0.0722));
-
   /*
    * Backdrop tone adaptation (W7) \u2014 step two of the composition contract, between
    * the colour scheme's neutral and the author's tint.
@@ -2785,57 +3537,148 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
    * and 'adaptedTintAlpha' in material.ts.
    */
   let sizedAlpha = ou.tint.w + ou.size.y * sizeK * (1.0 - ou.tint.w);
-  let adaptedAlpha = sizedAlpha + toneAdapt * (1.0 - sizedAlpha);
-  var adapted = neutral;
+
+  /*
+   * The backdrop tone response solve (W9) \u2014 the law that owns the interior
+   * MEAN, where the collapse below owns texture and nothing else (claims
+   * \xA75.33). The composite under this mechanism reduces exactly to
+   * mean = (1 \u2212 k)\xB7M\u2080 + k\xB7toneLuma with M\u2080 = (1 \u2212 \u03B1)\xB7bgLinear + \u03B1\xB7L(neutral),
+   * so the neutral's tone is solved in closed form: shift its luma so the
+   * post-collapse mean lands on R(encodedInput, sizeK), the reference's own
+   * measured response. Chroma is untouched \u2014 the shift is achromatic \u2014 and
+   * the author tint still displaces the result per the composition contract.
+   *
+   * Three stand-downs, each measured rather than defensive: the whole axis is
+   * off where no backdrop tone was measured (same gate as the collapse); the
+   * solve's authority fades to zero below the dark anchor, where the only
+   * evidence is the impulse cell the collapse constants were fitted on; and
+   * at k \u2192 1 the collapse owns the pixel outright, so the solve's
+   * extrapolation is never evaluated against a vanishing (1 \u2212 k).
+   */
+  var solvedNeutral = neutral;
+  var solvedAlpha = sizedAlpha;
+  if (ou.flags.x > 0.5 && ou.toneAdapt.w > 0.0 && ou.toneRowThin.w > 0.0 &&
+      sizedAlpha > 1e-3 && toneAdapt < 0.995) {
+    let encodedInput = srgb_encode(ou.toneColour.w);
+    let anchor = max(ou.toneAnchor.x, 1e-4);
+    let authority =
+      smoothstep(anchor * 0.5, anchor, encodedInput) * clamp(ou.toneRowThin.w, 0.0, 1.0);
+    if (authority > 0.0) {
+      let response = tone_response(encodedInput, sizeK);
+      // The collapse's mean pull is toward L(toneColour.rgb) \u2014 the LINEAR
+      // mean, which toneAnchor.w carries \u2014 not toward the encoded level.
+      let preCollapse = (response - toneAdapt * ou.toneAnchor.w) / (1.0 - toneAdapt);
+      let neutralLuma = dot(neutral, vec3f(0.2126, 0.7152, 0.0722));
+      let nominal = (1.0 - sizedAlpha) * ou.toneAnchor.w + sizedAlpha * neutralLuma;
+      let shift = (preCollapse - nominal) / sizedAlpha * authority * ou.toneAdapt.w;
+      solvedNeutral = clamp(neutral + vec3f(shift), vec3f(0.0), vec3f(1.0));
+      /*
+       * The light attractor needs OPACITY. The light scheme's neutral is
+       * already at white, so an upward shift clamps to nothing \u2014 and the
+       * reference's light-adapted state is the material gone opaque-bright,
+       * the same "an adapting material stops transmitting" the collapse's
+       * alpha half was measured on. Whatever the clamp truncated is carried
+       * by the alpha, solved against the same composite and folded by the
+       * same authority. One-sided by design: darkward opacity is the
+       * collapse's own axis with its own fitted constants.
+       */
+      let solvedLuma = dot(solvedNeutral, vec3f(0.2126, 0.7152, 0.0722));
+      let achieved = (1.0 - sizedAlpha) * ou.toneAnchor.w + sizedAlpha * solvedLuma;
+      if (preCollapse > achieved + 1e-4 && solvedLuma > ou.toneAnchor.w + 1e-3) {
+        let alphaTarget = clamp(
+          (preCollapse - ou.toneAnchor.w) / (solvedLuma - ou.toneAnchor.w),
+          sizedAlpha,
+          1.0,
+        );
+        solvedAlpha = mix(sizedAlpha, alphaTarget, authority * ou.toneAdapt.w);
+      }
+    }
+  }
+
+  let adaptedAlpha = solvedAlpha + toneAdapt * (1.0 - solvedAlpha);
+  var adapted = solvedNeutral;
   if (toneAdapt > 0.0 && adaptedAlpha > 0.0) {
     adapted =
-      (neutral * ((1.0 - toneAdapt) * sizedAlpha) + ou.toneColour.rgb * toneAdapt) / adaptedAlpha;
+      (solvedNeutral * ((1.0 - toneAdapt) * solvedAlpha) + ou.toneColour.rgb * toneAdapt) /
+      adaptedAlpha;
   }
 
-  // The author tint. 'aux.w' is the per-pixel strength, unioned in the field pass,
-  // so a toolbar can carry one tinted control among plain ones; the seed is a
-  // group uniform. At strength 0 this is the identity and the material is the one
-  // the calibration bed measures, byte for byte.
-  //
-  // Apple's mechanism, not a fill: the seed is the middle of a range of tones
-  // 'mapped to content brightness underneath'. 'backdrop' is what this pixel is
-  // actually looking through \u2014 lens-displaced, LOD-sampled, already the thing the
-  // material transmits \u2014 so the tone is taken against the same light the tint is
-  // about to be mixed into, and a tinted surface over a dark backdrop settles to a
-  // shade of the author's colour rather than sitting on it as paint.
-  //
-  // That 'backdrop' is also where the size law's scattering has already been
-  // applied (above), and that is the right order rather than a coincidence: a
-  // large surface diffuses more of what is behind it, so the tone the tint maps
-  // to should be the diffused light, not the sharp light nobody sees through it.
-  //
-  // It displaces the ADAPTED neutral, not the raw one: a full-strength tint is its
-  // own adaptation and replaces this axis outright, while a partial one moves with
-  // it. That order is the wave's composition contract, in one line.
-  var tintColour = adapted;
-  if (aux.w > 0.0) {
-    let t = smoothstep(ou.tone.z, ou.tone.w, backdropLuma);
-    let low = ou.seed.rgb * ou.tone.x;
-    let high = ou.seed.rgb + (vec3f(1.0) - ou.seed.rgb) * ou.tone.y;
-    // 'seed.w' is the contrast regime's grip on the excursion, never on the hue:
-    // at 0 the material shows the author's colour flat and stops responding.
-    let tone = mix(ou.seed.rgb, mix(low, high, t), clamp(ou.seed.w, 0.0, 1.0));
-    tintColour = mix(adapted, tone, clamp(aux.w, 0.0, 1.0));
+  // The material, untinted: the adapted neutral over what this pixel looks
+  // through, at the material's own occlusion. That alpha is what reduced
+  // transparency lifts and what the size law thickens ("a larger size is more
+  // opaque" is a statement about how much material there is), and the backdrop
+  // adaptation moved it above. The author's colour never touches it \u2014 but not
+  // for the reason the composition contract first gave (claims \xA75.36).
+  var colour = mix(backdrop, adapted, adaptedAlpha);
+  /*
+   * How much of this pixel the SURFACE owns, as the canvas will composite it.
+   *
+   * With a backdrop the composite above is the whole pixel \u2014 the pass sampled
+   * what is behind the surface and mixed it in, so the output is opaque inside
+   * the contour and the page beneath the canvas never shows. With no backdrop
+   * the composite is not here to make: a 'css-backdrop' group's blurred
+   * backdrop is a DOM proxy under this canvas, a 'none' group's is the page
+   * itself, and the browser is the compositor. So the material leaves as a
+   * LAYER \u2014 the adapted colour at the material's own alpha, premultiplied on
+   * the way out \u2014 and every term below that would have shaped the composite
+   * shapes the layer instead, in the form that composites to the same thing.
+   *
+   * Before W11a this path mixed the material over a black backdrop and wrote
+   * it opaque: a nested surface over glass rendered as a flat 0.468 where the
+   * reference reads 0.89 (claims \xA75.38 \xA75). The rows that floored were that
+   * grey. The pair the layer is written at is the host's
+   * ('GroupRenderInput.unsampledMaterial'): the browser composites this canvas
+   * in encoded sRGB, so the alpha is the CSS tier's, not the linear profile's.
+   */
+  var bodyAlpha = 1.0;
+  if (ou.flags.x <= 0.5) {
+    colour = adapted;
+    bodyAlpha = adaptedAlpha;
   }
 
-  // The tint layer's ALPHA is untouched by the author's colour. It is the
-  // material's occlusion \u2014 what reduced transparency lifts, and the axis the
-  // system's own Clear-to-Tinted preference runs on \u2014 and an author choosing a
-  // colour does not get to move it.
+  // The author tint (W10). 'aux.w' is the per-pixel strength, unioned in the
+  // field pass, so a toolbar can carry one tinted control among plain ones; the
+  // seed is a group uniform. At strength 0 this is the identity and the material
+  // is the one the calibration bed measures, byte for byte.
   //
-  // The size law does move it, and the two do not collide: "a larger size is more
-  // opaque, a smaller size is clearer" is a statement about how much material
-  // there is, not about what colour it is. A fraction of whatever transparency
-  // the resolved alpha still has, for the reason 'increasedOcclusionLift' is a
-  // fraction \u2014 see material.ts.
+  // Apple's mechanism, measured per pixel: the tinted material is an OPAQUE
+  // layer of the seed at a shade that is linear in the luminance the untinted
+  // material shows at this pixel \u2014 about half the seed's light over black
+  // content, the seed itself over white, the seed's chromaticity intact
+  // throughout. That layer composites over the material at the AUTHOR's
+  // opacity in the encoded space, which is what a CALayer with 'opacity' does
+  // and how the reference's half-strength cell measures. So a tinted surface
+  // over a checkerboard shows the checker as light and dark ORANGE, not as
+  // orange glass with the checker behind it \u2014 the material's own alpha is not
+  // what a tinted surface shows.
   //
-  // The backdrop adaptation moves it, above, and the author's colour does not.
-  var colour = mix(backdrop, tintColour, adaptedAlpha);
+  // 'seed.w' is the contrast regime's grip on the excursion, never on the hue;
+  // 'tone.z' is the profile's provenance gate (the dark scheme renders the pure
+  // seed); and '1 \u2212 toneAdapt' folds the shade out where the collapse has made
+  // the material a dark body, where the reference renders the pure seed too.
+  // At zero grip the layer is the bare seed \u2014 the author's colour, flat.
+  if (aux.w > 0.0) {
+    // The untinted material's luminance at this pixel. Over a backdrop that is
+    // the composite; as a layer it is the layer over the tone the host measured
+    // for the group \u2014 zero where nothing was measured, the same reference-level
+    // convention the CSS tier's 'materialLuminance' takes (within its 0.02).
+    let u = bodyAlpha * dot(colour, vec3f(0.2126, 0.7152, 0.0722)) + (1.0 - bodyAlpha) * ou.toneColour.w;
+    let grip = clamp(ou.seed.w, 0.0, 1.0) * clamp(ou.tone.z, 0.0, 1.0) * (1.0 - toneAdapt);
+    let shade = mix(1.0, clamp(mix(ou.tone.x, ou.tone.y, clamp(u, 0.0, 1.0)), 0.0, 1.0), grip);
+    let layer = ou.seed.rgb * shade;
+    let s = clamp(aux.w, 0.0, 1.0);
+    let encodedMaterial = linear_to_srgb(clamp(colour, vec3f(0.0), vec3f(1.0)));
+    let encodedLayer = linear_to_srgb(layer);
+    if (ou.flags.x > 0.5) {
+      colour = srgb_to_linear(mix(encodedMaterial, encodedLayer, vec3f(s)));
+    } else {
+      // The opaque layer at the author's opacity over the material's own layer,
+      // premultiplied: the fold 'tintedCssOptics' makes into one rgba.
+      let premultiplied = (1.0 - s) * bodyAlpha * encodedMaterial + s * encodedLayer;
+      bodyAlpha = 1.0 - (1.0 - s) * (1.0 - bodyAlpha);
+      colour = srgb_to_linear(premultiplied / max(bodyAlpha, 1e-6));
+    }
+  }
 
   /*
    * Everything below is the surface's own APPEARANCE \u2014 the marks that say a
@@ -2861,21 +3704,51 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // strongest, which is what makes a thicker surface read as heavier \u2014 and the
   // shadow facet of the size law deepens it further with the span.
   let shadowDepth = ou.light.z * (1.0 + (ou.size.z - 1.0) * sizeK);
-  colour = colour * (1.0 - profile * shadowDepth * ou.light.w * present);
+  // A multiplicative occlusion of the whole composite. As a layer that is the
+  // colour scaled and the alpha raised \u2014 (k\xB7a\xB7c, 1 \u2212 k\xB7(1 \u2212 a)) composites to
+  // k times what (a\xB7c, a) would \u2014 and at bodyAlpha 1 it is the plain product.
+  let shadowKeep = 1.0 - shadowProfile * shadowDepth * ou.light.w * present;
+  let shadowedAlpha = 1.0 - shadowKeep * (1.0 - bodyAlpha);
+  colour = colour * (shadowKeep * bodyAlpha / max(shadowedAlpha, 1e-6));
+  bodyAlpha = shadowedAlpha;
 
   // Rim and specular from the gradient. The rim is unlit ambient edge brightness;
   // the specular term is the same edge lit from 'light.xy'.
   let rw = rim_weight(d, ou.rim.x);
   let facing = dot(normal, ou.light.xy);
   let spec = pow(clamp(facing, 0.0, 1.0), max(ou.rim.z, 1e-3)) * ou.rim.w;
-  colour = colour + vec3f(rw * (ou.rim.y + spec) * present);
+  let rim = rw * (ou.rim.y + spec) * present;
+  if (ou.flags.x > 0.5) {
+    colour = colour + vec3f(rim);
+  } else {
+    // Added light has no premultiplied form of its own \u2014 a canvas colour may
+    // not exceed its alpha \u2014 so the layer carries the light in its opacity:
+    // (a\xB7c + rim, a + rim) composites to dst\xB7(1 \u2212 a) + a\xB7c + rim \u2212 rim\xB7dst,
+    // the additive term short of rim \xD7 dst. Exact wherever the layer is
+    // opaque (an author tint at full strength, or a lit contour pixel whose
+    // alpha the rim fills), and never further off than the rim times what
+    // shows through \u2014 where the mix form ("white over the layer at the rim's
+    // weight") is short by the rim times the whole composite, which halved
+    // the rim on a tinted panel.
+    let carried = clamp(bodyAlpha + rim, 0.0, 1.0);
+    colour = min((colour * bodyAlpha + vec3f(rim)) / max(carried, 1e-6), vec3f(1.0));
+    bodyAlpha = carried;
+  }
 
   // The material over its own shadow over the page, in one premultiplied vector:
-  // the colour is the surface's, weighted by its coverage, and the alpha is what
-  // the two of them together leave the page \u2014 'coverage' from the surface, and
-  // the shadow filling whatever transparency is left.
-  let body = encode_output(max(colour, vec3f(0.0)), coverage);
-  return vec4f(body.rgb, body.a + shadowAlpha * (1.0 - body.a));
+  // the colour is the surface's, weighted by its coverage and by however much of
+  // the pixel the layer owns, and the alpha is what the two of them together
+  // leave the page. The shadow fills only what the surface's COVERAGE leaves \u2014
+  // clipped out of the silhouette exactly as a 'box-shadow' is clipped out of
+  // its border box \u2014 never what the layer's own transparency leaves: a
+  // translucent surface shows the page through it, not its own shadow. (With
+  // an opaque body the two are the same quantity, which is how the shadow was
+  // first written and why the difference only surfaced with the layer form.)
+  let body = encode_output(max(colour, vec3f(0.0)), coverage * bodyAlpha);
+  return vec4f(
+    body.rgb + liftEncoded * (1.0 - coverage),
+    body.a + shadowAlpha * (1.0 - coverage),
+  );
 }`;
 
 // ../renderer-webgpu/dist/wgsl/prelude.js
@@ -3003,7 +3876,11 @@ function createPassRunner(context) {
       fragment: {
         module,
         entryPoint: "fs_field",
-        targets: [{ format: WORKING_TEXTURE_FORMAT }, { format: WORKING_TEXTURE_FORMAT }]
+        targets: [
+          { format: WORKING_TEXTURE_FORMAT },
+          { format: WORKING_TEXTURE_FORMAT },
+          { format: WORKING_TEXTURE_FORMAT }
+        ]
       },
       primitive: { topology: "triangle-list" }
     };
@@ -3067,6 +3944,13 @@ function createPassRunner(context) {
         usage: fieldUsage(),
         label: `vitrea:group:${args.groupId}:aux`
       });
+      const aux2 = pool.acquire(poolKey.groupAux2(args.groupId), {
+        width,
+        height,
+        format: WORKING_TEXTURE_FORMAT,
+        usage: fieldUsage(),
+        label: `vitrea:group:${args.groupId}:aux2`
+      });
       const slot = uniformSlot(`field:${args.groupId}`, 12);
       slot.data[0] = rectWidth;
       slot.data[1] = rectHeight;
@@ -3100,6 +3984,12 @@ function createPassRunner(context) {
             loadOp: "clear",
             storeOp: "store",
             clearValue: { r: 0, g: 0, b: 0, a: 0 }
+          },
+          {
+            view: aux2.createView(),
+            loadOp: "clear",
+            storeOp: "store",
+            clearValue: { r: 0, g: 0, b: 0, a: 0 }
           }
         ]
       });
@@ -3116,13 +4006,14 @@ function createPassRunner(context) {
       return {
         field,
         aux,
+        aux2,
         width,
         height,
         upsampled: width !== rectWidth || height !== rectHeight
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 60);
+      const slot = uniformSlot(`optics:${args.groupId}`, 96);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -3133,8 +4024,8 @@ function createPassRunner(context) {
       d[6] = args.fit[2];
       d[7] = args.fit[3];
       d[8] = args.refractionScale;
-      d[9] = args.bodyLodPerPx;
-      d[10] = args.rimLodBias;
+      d[9] = args.lensRefractionGain;
+      d[10] = args.shadowDepthSizeGainMax;
       d[11] = args.chainMaxLod;
       d[12] = args.tint[0];
       d[13] = args.tint[1];
@@ -3148,10 +4039,10 @@ function createPassRunner(context) {
       d[21] = args.tintSeed[1];
       d[22] = args.tintSeed[2];
       d[23] = args.tintToneAdaptation;
-      d[24] = args.tintTone[0];
-      d[25] = args.tintTone[1];
-      d[26] = args.tintTone[2];
-      d[27] = Math.max(args.tintTone[3], args.tintTone[2] + 1e-4);
+      d[24] = args.tintShade[0];
+      d[25] = args.tintShade[1];
+      d[26] = args.tintShade[2];
+      d[27] = args.sizeFold;
       d[28] = args.rimWidth;
       d[29] = args.rimAlpha;
       d[30] = args.specularPower;
@@ -3182,8 +4073,44 @@ function createPassRunner(context) {
       d[55] = args.outerShadow[3];
       d[56] = args.outerShadowSizeGain;
       d[57] = args.outerShadowRectCssHeight;
-      d[58] = 0;
+      d[58] = args.sizeScatterRampStartThick;
       d[59] = 0;
+      d[60] = args.backdropToneAnchorX[0];
+      d[61] = args.backdropToneAnchorX[1];
+      d[62] = args.backdropToneAnchorX[2];
+      d[63] = args.backdropToneLinearMean;
+      d[64] = args.backdropToneResponseThin[0];
+      d[65] = args.backdropToneResponseThin[1];
+      d[66] = args.backdropToneResponseThin[2];
+      d[67] = args.backdropToneResponseStrength;
+      d[68] = args.backdropToneResponseThick[0];
+      d[69] = args.backdropToneResponseThick[1];
+      d[70] = args.backdropToneResponseThick[2];
+      d[71] = 0;
+      d[72] = args.sizeScatterFloor;
+      d[73] = args.sizeScatterRampStartThin;
+      d[74] = args.sizeSpanMin;
+      d[75] = args.sizeSpanMax;
+      d[76] = args.lensHeightPerSpan;
+      d[77] = args.lensHeightMax;
+      d[78] = args.lensAmountPerSpan;
+      d[79] = args.lensAmountMax;
+      d[80] = args.lensExtentGain;
+      d[81] = args.lensProfileExponent;
+      d[82] = args.lensOvalization;
+      d[83] = args.lensThicknessReference;
+      d[84] = args.lensOvalizationSpanMin;
+      d[85] = args.lensOvalizationSpanMax;
+      d[86] = args.sizeScatterRampReachCssPx;
+      d[87] = args.sizeScatterSpanMax;
+      d[88] = args.outerShadowThick[0];
+      d[89] = args.outerShadowThick[1];
+      d[90] = args.outerShadowThick[2];
+      d[91] = args.sizeScatterRampStartFar;
+      d[92] = args.outerShadowLift[0];
+      d[93] = args.outerShadowLift[1];
+      d[94] = args.outerShadowLift[2];
+      d[95] = args.outerShadowLift[3];
       slot.write();
       const chain = args.backdrop?.chain ?? placeholderView;
       const body = args.backdrop?.body ?? placeholderView;
@@ -3206,7 +4133,8 @@ function createPassRunner(context) {
           { binding: 5, resource: body },
           // Linear, no mips: the field targets have one level, and this is only
           // read at all when the governor shrank them below the group's rect.
-          { binding: 6, resource: context.flatSampler }
+          { binding: 6, resource: context.flatSampler },
+          { binding: 7, resource: args.fields.aux2.createView() }
         ]
       }));
       pass.draw(3);
@@ -3240,9 +4168,9 @@ function createPassRunner(context) {
       d[22] = args.backdropTone[2];
       d[23] = args.backdropTone[3];
       d[24] = args.backdropToneLevel;
-      d[25] = 0;
-      d[26] = 0;
-      d[27] = 0;
+      d[25] = args.sizeSpanMin;
+      d[26] = args.sizeSpanMax;
+      d[27] = args.sizeFold;
       const fieldRect = args.fieldRectDevice;
       d[28] = args.rectDevice.width / Math.max(fieldRect.width, 1e-6);
       d[29] = args.rectDevice.height / Math.max(fieldRect.height, 1e-6);
@@ -3289,6 +4217,7 @@ function createPassRunner(context) {
     forget(groupId) {
       pool.release(poolKey.groupField(groupId));
       pool.release(poolKey.groupAux(groupId));
+      pool.release(poolKey.groupAux2(groupId));
       storages.get(groupId)?.destroy();
       storages.delete(groupId);
       for (const key of [`field:${groupId}`, `optics:${groupId}`, `highlight:${groupId}`]) {
@@ -3433,6 +4362,9 @@ function createRebuildLedger() {
 
 // ../renderer-webgpu/dist/pyramid.js
 var chainUsage = () => GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING;
+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 sameBody = (existing, request) => same(densityOf({ width: existing.sourceWidth, height: existing.sourceHeight }, request), existing.texelsPerCss) && same(request.bodySigmaCss, existing.bodySigmaCss);
 function createPyramidStore(context) {
   const { device, pool, cache } = context;
   const resources = /* @__PURE__ */ new Map();
@@ -3508,7 +4440,7 @@ function createPyramidStore(context) {
     return target;
   };
   const mipView = (texture, level) => texture.createView({ baseMipLevel: level, mipLevelCount: 1, dimension: "2d" });
-  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch, bodySigmaTexels) {
+  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch, bodySigmaTexels, density, bodySigmaCss) {
     const existing = resources.get(sourceId);
     const bodyWidth = (plan.levels[bodyLevel] ?? plan.levels[0]).width;
     const bodyHeight = (plan.levels[bodyLevel] ?? plan.levels[0]).height;
@@ -3546,7 +4478,11 @@ function createPyramidStore(context) {
       stats,
       sizeEpoch,
       builtEpoch,
-      bodySigmaTexels
+      bodySigmaTexels,
+      texelsPerCss: density.texelsPerCss,
+      sourceWidth: density.sourceWidth,
+      sourceHeight: density.sourceHeight,
+      bodySigmaCss
     };
     resources.set(sourceId, next);
     return next;
@@ -3734,7 +4670,7 @@ function createPyramidStore(context) {
     },
     build(request, provider, encoder) {
       const existing = liveResources(request.sourceId);
-      if (existing !== void 0 && existing.builtEpoch >= request.epoch && !provider.isDirty()) {
+      if (existing !== void 0 && existing.builtEpoch >= request.epoch && !provider.isDirty() && sameBody(existing, request)) {
         ledger.recordClean();
         return { status: "clean", resources: existing };
       }
@@ -3752,12 +4688,11 @@ function createPyramidStore(context) {
       }
       pendingRelease.push(provider);
       const plan = planPyramid(frame.width, frame.height, request.resolution);
-      const [viewportW, viewportH] = request.viewportCss;
-      const cover = viewportW > 0 && viewportH > 0 ? Math.max(frame.width / viewportW, frame.height / viewportH) : 1;
+      const texelsPerCss = densityOf(frame, request);
       const planScale = frame.width > 0 ? plan.width / frame.width : 1;
-      const bodySigmaTexels = request.bodySigmaCss * cover * planScale;
+      const bodySigmaTexels = request.bodySigmaCss * texelsPerCss * planScale;
       const bodyPlan = bodyBlurPlan(bodySigmaTexels, plan);
-      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels);
+      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels, { texelsPerCss, sourceWidth: frame.width, sourceHeight: frame.height }, request.bodySigmaCss);
       runImport(encoder, request.sourceId, frame, target.chain);
       runChain(encoder, request.sourceId, plan, target.chain);
       runBodyBlur(encoder, request.sourceId, plan, target.chain, target.body, bodyPlan.level, bodyPlan.residualSigmaTexels);
@@ -3873,8 +4808,11 @@ var RENDERER_PASS_IDS = [
   OPTICS_PASS_ID,
   HIGHLIGHT_PASS_ID
 ];
+var STANDALONE_RESOLUTION = { scale: 1, maxDimension: 2048 };
 function createWebGPURenderer(options = {}) {
   const providers = /* @__PURE__ */ new Map();
+  const placements = /* @__PURE__ */ new Map();
+  const lastResolution = /* @__PURE__ */ new Map();
   const groups = /* @__PURE__ */ new Map();
   const adaptation = /* @__PURE__ */ new Map();
   const lastReadbackAt = /* @__PURE__ */ new Map();
@@ -3963,18 +4901,48 @@ function createWebGPURenderer(options = {}) {
     }
     return state;
   };
-  const coverFit = (sourceWidth, sourceHeight) => {
-    const viewportAspect = viewport.heightCss > 0 ? viewport.widthCss / viewport.heightCss : 1;
-    const sourceAspect = sourceHeight > 0 ? sourceWidth / sourceHeight : 1;
-    if (sourceAspect > viewportAspect) {
-      const scaleX = viewportAspect / sourceAspect;
-      return [scaleX, 1, (1 - scaleX) / 2, 0];
+  const fitFor = (sourceId, pyramid) => {
+    const placement = placements.get(sourceId);
+    return isUsablePlacement(placement) ? placementFit(placement, viewport.widthCss, viewport.heightCss) : coverFit(pyramid.plan.width, pyramid.plan.height, viewport.widthCss, viewport.heightCss);
+  };
+  const liftChainLod = (sigmaCss, pyramid) => {
+    if (pyramid === void 0 || !(sigmaCss > 0))
+      return 0;
+    const planScale = pyramid.sourceWidth > 0 ? pyramid.plan.width / pyramid.sourceWidth : 1;
+    const sigmaTexels = sigmaCss * pyramid.texelsPerCss * planScale;
+    return Math.min(chainLodForSigma(sigmaTexels), pyramid.plan.maxLod);
+  };
+  const staleBodyRebuilds = (explicit, pyramids) => {
+    const requests = [];
+    const named = new Set(explicit.map((request) => request.sourceId));
+    for (const sourceId of providers.keys()) {
+      if (named.has(sourceId))
+        continue;
+      const existing = pyramids.resources(sourceId);
+      if (existing === void 0)
+        continue;
+      const next = texelsPerCssPx(existing.sourceWidth, existing.sourceHeight, placements.get(sourceId), viewport.widthCss, viewport.heightCss);
+      const sameDensity = Math.abs(next - existing.texelsPerCss) <= 1e-6 * Math.max(1, existing.texelsPerCss);
+      const sigmaCss = bodySigmaCssFor(sourceId);
+      const sameSigma = Math.abs(sigmaCss - existing.bodySigmaCss) <= 1e-6 * Math.max(1, existing.bodySigmaCss);
+      if (sameDensity && sameSigma)
+        continue;
+      requests.push({
+        sourceId,
+        epoch: existing.builtEpoch,
+        resolution: lastResolution.get(sourceId) ?? STANDALONE_RESOLUTION,
+        groupIds: [...groups.values()].filter((entry) => entry.input.backdropSourceId === sourceId).map((entry) => entry.input.groupId)
+      });
     }
-    const scaleY = sourceAspect / viewportAspect;
-    return [1, scaleY, 0, (1 - scaleY) / 2];
+    return requests;
   };
   const unionOf = (input) => input.union ?? DEFAULT_GROUP_UNION;
   const variantOf = (input) => input.variant ?? "regular";
+  const sourceVariant = (sourceId) => {
+    const input = [...groups.values()].find((entry) => entry.input.backdropSourceId === sourceId)?.input;
+    return input === void 0 ? "regular" : variantOf(input);
+  };
+  const bodySigmaCssFor = (sourceId) => opticsUnderPolicy(material.optics[sourceVariant(sourceId)], accessibility, material).blurSigma;
   const groupTintSeed = (input) => input.surfaces.find((surface) => surface.fieldReferenceOnly !== true && (surface.tint?.strength ?? 0) > 0)?.tint?.color;
   const stateOf = (input, resolution) => {
     const resolved = resolution?.groups.find((group) => group.groupId === input.groupId);
@@ -3987,8 +4955,12 @@ function createWebGPURenderer(options = {}) {
     };
   };
   function rebuildRequests(explicit) {
-    if (explicit !== void 0)
-      return explicit;
+    const base = explicit ?? standaloneRequests();
+    const { store: pyramids } = ensureContext();
+    const stale = staleBodyRebuilds(base, pyramids);
+    return stale.length === 0 ? base : [...base, ...stale];
+  }
+  function standaloneRequests() {
     const sampled = /* @__PURE__ */ new Set();
     for (const entry of groups.values()) {
       const id = entry.input.backdropSourceId;
@@ -4006,7 +4978,7 @@ function createWebGPURenderer(options = {}) {
         // keeping the books, so a monotonically rising number is the honest
         // stand-in and it keeps `build`'s clean-skip from firing spuriously.
         epoch: framesDrawn + 1,
-        resolution: { scale: 1, maxDimension: 2048 },
+        resolution: STANDALONE_RESOLUTION,
         groupIds: [...groups.values()].filter((entry) => entry.input.backdropSourceId === sourceId).map((entry) => entry.input.groupId)
       });
     }
@@ -4022,14 +4994,18 @@ function createWebGPURenderer(options = {}) {
         unbuilt.push(request.sourceId);
         continue;
       }
-      const variant = variantOf([...groups.values()].find((entry) => entry.input.backdropSourceId === request.sourceId)?.input ?? { });
-      const optics = opticsUnderPolicy(material.optics[variant], accessibility, material);
+      lastResolution.set(request.sourceId, request.resolution);
+      const placement = placements.get(request.sourceId);
       const outcome = pyramids.build({
         sourceId: request.sourceId,
         epoch: request.epoch,
         resolution: request.resolution,
-        bodySigmaCss: optics.blurSigma,
-        viewportCss: [viewport.widthCss, viewport.heightCss]
+        // The body's sharp width in CSS px at every device scale (W13 Decision
+        // Log 8); the heavy component rides the same conversion — its level
+        // is this one plus log2(sizeScatterGainMax) octaves.
+        bodySigmaCss: bodySigmaCssFor(request.sourceId),
+        viewportCss: [viewport.widthCss, viewport.heightCss],
+        ...isUsablePlacement(placement) ? { placement } : {}
       }, provider, encoder);
       if (outcome.status === "built")
         built += 1;
@@ -4078,11 +5054,12 @@ function createWebGPURenderer(options = {}) {
       }
       const union = unionOf(input);
       const shadow = outerShadowUnderPolicy(policy, material);
-      let reachOcclusion = shadow.occlusion;
+      const shadowBackdropLuminance = input.backdropTone === void 0 ? void 0 : input.backdropToneLevel ?? relativeLuminance(input.backdropTone);
+      let reachOcclusion = outerShadowThinOcclusion(shadowBackdropLuminance, shadow);
       for (const surface of surfaces) {
-        reachOcclusion = Math.max(reachOcclusion, sizeOuterShadowOcclusionAt(shadow.occlusion, surface.sizeThickness, material));
+        reachOcclusion = Math.max(reachOcclusion, outerShadowOcclusionAt(shadow, shadowBackdropLuminance, surface.spanPx, surface.sizeThickness, material));
       }
-      const shadowReachPx = outerShadowReachPx({ ...shadow, occlusion: reachOcclusion });
+      const shadowReachPx = outerShadowReachPx(shadow, reachOcclusion);
       const snapped = snapRectToDevicePixels(groupFieldRect(surfaces, union, void 0, shadowReachPx), dpr);
       const rectDevice = clipFieldRectToCanvas(snapped, dpr, viewportDevice);
       if (rectDevice === void 0)
@@ -4107,19 +5084,24 @@ function createWebGPURenderer(options = {}) {
       });
       const state = stateOf(input, resolution);
       const variant = variantOf(input);
-      const optics = opticsUnderPolicy(material.optics[variant], policy, material);
+      const sourceId = input.backdropSourceId;
+      const pyramid = sourceId === void 0 ? void 0 : pyramids.resources(sourceId);
+      const adapt = sourceId === void 0 ? void 0 : adaptationFor(sourceId).values;
+      const nominalOptics = material.optics[variant];
+      const optics = opticsUnderPolicy(pyramid === void 0 && input.unsampledMaterial !== void 0 ? {
+        ...nominalOptics,
+        tint: input.unsampledMaterial.tint,
+        tintAlpha: input.unsampledMaterial.tintAlpha
+      } : nominalOptics, policy, material);
       const backdropTone = [
         material.backdropToneLow,
         material.backdropToneHigh,
         backdropToneSizeBiasUnderPolicy(policy, material),
         input.backdropTone === void 0 ? 0 : backdropToneUnderPolicy(policy, material) * material.backdropToneMax
       ];
-      const backdropToneLevel = input.backdropTone === void 0 ? 0 : relativeLuminance(input.backdropTone);
+      const backdropToneLevel = shadowBackdropLuminance ?? 0;
       const refraction = effectiveRefraction(accessibilityRefractionCap(policy), state.refraction);
       const refractionScale = material.refractionScale[refraction];
-      const sourceId = input.backdropSourceId;
-      const pyramid = sourceId === void 0 ? void 0 : pyramids.resources(sourceId);
-      const adapt = sourceId === void 0 ? void 0 : adaptationFor(sourceId).values;
       passes.opticsPass(encoder, {
         groupId: input.groupId,
         target: active.optics,
@@ -4129,10 +5111,22 @@ function createWebGPURenderer(options = {}) {
         viewportDevice,
         cssPerDevice,
         coverageRampCss: cssPerDevice,
-        fit: pyramid === void 0 ? [1, 1, 0, 0] : coverFit(pyramid.plan.width, pyramid.plan.height),
+        fit: pyramid === void 0 || sourceId === void 0 ? [1, 1, 0, 0] : fitFor(sourceId, pyramid),
         refractionScale,
-        bodyLodPerPx: material.lensBodyLodPerPx,
-        rimLodBias: material.lensRimLodBias,
+        lensRefractionGain: material.lensRefractionGain,
+        // The lens law (W12 G2) and the inner shadow's own depth gain, both
+        // evaluated per pixel in the shader from the thickness and the span.
+        lensHeightPerSpan: material.lensHeightPerSpan,
+        lensHeightMax: material.lensHeightMax,
+        lensAmountPerSpan: material.lensAmountPerSpan,
+        lensAmountMax: material.lensAmountMax,
+        lensThicknessReference: material.lensThicknessReference,
+        lensExtentGain: material.lensExtentGain,
+        lensProfileExponent: material.lensProfileExponent,
+        lensOvalization: material.lensOvalization,
+        lensOvalizationSpanMin: material.lensOvalizationSpanMin,
+        lensOvalizationSpanMax: material.lensOvalizationSpanMax,
+        shadowDepthSizeGainMax: material.lensSizeGainMax,
         chainMaxLod: pyramid?.plan.maxLod ?? 0,
         tint: optics.tint,
         tintAlpha: optics.tintAlpha,
@@ -4152,12 +5146,7 @@ function createWebGPURenderer(options = {}) {
          */
         tintSeed: (policy.glass === "none" ? void 0 : groupTintSeed(input)) ?? optics.tint,
         tintToneAdaptation: tintToneAdaptation(policy, material),
-        tintTone: [
-          material.tintToneFloor,
-          material.tintToneCeilMix,
-          material.tintToneLow,
-          material.tintToneHigh
-        ],
+        tintShade: [material.tintShadeDark, material.tintShadeLight, material.tintShadeStrength],
         rimWidth: optics.rimWidth,
         rimAlpha: optics.rimAlpha,
         specularPower: optics.specularPower,
@@ -4174,6 +5163,28 @@ function createWebGPURenderer(options = {}) {
         sizeOcclusionGain: material.sizeOcclusionGain,
         sizeShadowGainMax: material.sizeShadowGainMax,
         bodyChainLod: chainLodForSigma(pyramid?.bodySigmaTexels ?? 0),
+        // The size law's curves (W11c): the shader evaluates the thickness and
+        // the scatter mix per pixel from the span the field carries, under the
+        // same fold `sizeThicknessUnderPolicy` applies on the CPU.
+        sizeSpanMin: material.sizeSpanMin,
+        sizeSpanMax: material.sizeSpanMax,
+        sizeScatterFloor: material.sizeScatterFloor,
+        sizeScatterSpanMax: material.sizeScatterSpanMax,
+        // The body's depth ramp (W13 G1, claims §5.61 §2, §5.64 §5), resolved
+        // from the viewport's own ratio: the profile anchors the start's thin
+        // and thick ends and the reach at dpr 1 and dpr 2, and the CPU
+        // interpolates all three in dpr. The start's SPAN grading stays in the
+        // shader, because a group's members are not one size and the span
+        // arrives per pixel on the field's own channel — so the two anchors go
+        // over and `sizeThickness` is evaluated there. The reach is handed over
+        // in CSS px because the field's depth is in CSS px.
+        sizeScatterRampStartThin: scatterRampStart(dpr, material, 0),
+        sizeScatterRampStartThick: scatterRampStart(dpr, material, material.sizeSpanMax),
+        // The fourth form's far end, at the scatter span curve's top; the shader
+        // declines from the thick end to it along that curve.
+        sizeScatterRampStartFar: scatterRampStart(dpr, material, material.sizeScatterSpanMax),
+        sizeScatterRampReachCssPx: scatterRampReachDevicePx(dpr, material) / dpr,
+        sizeFold: material.refractionScale[accessibilityRefractionCap(policy)],
         backdropTone,
         backdropToneColour: [
           input.backdropTone?.[0] ?? 0,
@@ -4181,8 +5192,31 @@ function createWebGPURenderer(options = {}) {
           input.backdropTone?.[2] ?? 0,
           backdropToneLevel
         ],
+        // The response law's anchors (W9) and the linear backdrop mean its
+        // solve composites against. The shader re-derives the encoded input
+        // from `backdropToneLevel`, so the fourth slot carries the linear
+        // mean — the one quantity the solve needs that the tone colour does
+        // not already hold.
+        backdropToneAnchorX: material.backdropToneAnchorX,
+        backdropToneResponseThin: material.backdropToneResponseThin,
+        backdropToneResponseThick: material.backdropToneResponseThick,
+        // The response law rides only the UN-DEGRADED regime, for the same
+        // provenance reason the dark profiles set its strength to 0: the
+        // anchors are standard-light-reference measurements, and the
+        // accessibility references behave differently (nearly opaque, flat in
+        // span — W2). Measured before this gate existed: reduced-transparency
+        // photo ΔE p95 0.007 → 0.048 and cross-tier ratio 0.99 → 0.86. Where
+        // any policy fold touches the tone axis, the solve stands down and the
+        // collapse alone runs, exactly the pre-W9 behaviour those profiles
+        // were fitted on.
+        backdropToneResponseStrength: backdropToneUnderPolicy(policy, material) >= 0.999 ? material.backdropToneResponseStrength : 0,
+        backdropToneLinearMean: input.backdropToneLinearLuminance ?? backdropToneLevel,
         outerShadow: [
-          outerShadowAlpha(shadow.occlusion),
+          // The thin regime's LINEAR occlusion at this group's backdrop (W14
+          // G1). The conversion to the compositing space moved into the shader
+          // with the regimes: it is not linear, so converting one regime here
+          // and blending in the shader would not be the same law.
+          outerShadowThinOcclusion(shadowBackdropLuminance, shadow),
           shadow.sigmaPx,
           shadow.spreadPx,
           // The offset in field-texture UV. The field spans exactly this rect, so
@@ -4190,6 +5224,19 @@ function createWebGPURenderer(options = {}) {
           // scaled the rasterisation.
           shadow.offsetPx / Math.max(rectDevice.height * cssPerDevice, 1e-6)
         ],
+        outerShadowThick: [
+          shadow.thickOcclusionAt96,
+          shadow.thickOcclusionAt128,
+          shadow.thickOcclusionAt160
+        ],
+        outerShadowLift: [
+          // The lift needs a chain to copy; without one there is nothing to add,
+          // and `hasBackdrop` in the shader says the same thing a second time.
+          pyramid === void 0 || policy.glass === "none" ? 0 : shadow.liftAmplitude,
+          shadow.liftSpanMin,
+          shadow.liftSpanFull,
+          liftChainLod(shadow.liftBlurSigmaCss, pyramid)
+        ],
         outerShadowSizeGain: shadow.sizeGain,
         outerShadowRectCssHeight: rectDevice.height * cssPerDevice,
         backdrop: pyramid === void 0 || policy.glass === "none" ? void 0 : {
@@ -4219,9 +5266,13 @@ function createWebGPURenderer(options = {}) {
           glowGain: material.glowGain,
           colour: optics.highlight,
           // The same four numbers the optics pass took, so the two passes fade
-          // the surface on one curve rather than on two copies of it.
+          // the surface on one curve rather than on two copies of it — and the
+          // same band and fold, since the curve is evaluated off the span.
           backdropTone,
-          backdropToneLevel
+          backdropToneLevel,
+          sizeSpanMin: material.sizeSpanMin,
+          sizeSpanMax: material.sizeSpanMax,
+          sizeFold: material.refractionScale[accessibilityRefractionCap(policy)]
         });
       }
       drawn += 1;
@@ -4286,6 +5337,8 @@ function createWebGPURenderer(options = {}) {
       providers.set(provider.id, provider);
     },
     unregisterBackdrop(sourceId) {
+      placements.delete(sourceId);
+      lastResolution.delete(sourceId);
       const provider = providers.get(sourceId);
       if (provider === void 0)
         return;
@@ -4298,6 +5351,17 @@ function createWebGPURenderer(options = {}) {
     backdrop(sourceId) {
       return providers.get(sourceId);
     },
+    setBackdropPlacement(sourceId, placement) {
+      if (samePlacement(placements.get(sourceId), placement))
+        return;
+      if (placement === void 0)
+        placements.delete(sourceId);
+      else
+        placements.set(sourceId, { ...placement });
+    },
+    backdropPlacement(sourceId) {
+      return placements.get(sourceId);
+    },
     setViewport(next) {
       const changed = next.widthCss !== viewport.widthCss || next.heightCss !== viewport.heightCss || next.devicePixelRatio !== viewport.devicePixelRatio;
       viewport = next;
@@ -4454,6 +5518,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, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_BODY_LOD_PER_PX, LENS_RIM_LOD_BIAS, LENS_SIZE_GAIN_MAX, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTER_SHADOW, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SIZE_OCCLUSION_GAIN, SIZE_SCATTER_GAIN_MAX, 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, backdropToneAdaptation, backdropToneSizeBiasUnderPolicy, backdropToneUnderPolicy, bodyBlurPlan, bodyLod, chainModule, clipFieldRectToCanvas, 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, highlightModule, importColorMatrix, importModule, importPassSource, lensDepthPx, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowReachPx, outerShadowUnderPolicy, packInstances, pipelineKey, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, tintTone, tintToneAdaptation, tintedTintColour, validateAppTexture, withMaterialOverrides };
-//# sourceMappingURL=dist-RQ4ZMA3D.js.map
-//# sourceMappingURL=dist-RQ4ZMA3D.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_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_GAIN_MAX, 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_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, backdropToneSizeBiasUnderPolicy, backdropToneUnderPolicy, bodyBlurPlan, chainModule, clipFieldRectToCanvas, 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, highlightModule, importColorMatrix, importModule, importPassSource, isUsablePlacement, lensAmountBasePx, lensDepthPx, lensDirection, lensDisplacementPx, lensExtentPx, lensHeightBasePx, lensMagnitudePx, lensOvalizationAt, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowLiftRise, outerShadowOcclusionAt, outerShadowReachPx, outerShadowThickOcclusion, outerShadowThinOcclusion, outerShadowUnderPolicy, packInstances, pipelineKey, placementFit, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, samePlacement, scatterDeepThickness, scatterRampAreaMean, scatterRampReachDevicePx, scatterRampStart, scatterSharpShare, scatterThickness, shadowDepthPx, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, texelsPerCssPx, tintShade, tintShadeLayer, tintToneAdaptation, tintedMaterialColour, validateAppTexture, withMaterialOverrides };
+//# sourceMappingURL=dist-RGWZAZ6J.js.map
+//# sourceMappingURL=dist-RGWZAZ6J.js.map