@vitreajs/vitrea 0.3.0 → 0.5.0

package/dist/{dist-MVSXUP3K.js → dist-OHNXYEZP.js}

@@ -348,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.
@@ -431,16 +433,79 @@ var DEFAULT_MATERIAL_PROFILE = {
   sizeScatterGainMax: 8,
   sizeScatterFloor: 0.4,
   sizeScatterSpanMax: 256,
+  // The second scale, FITTED by W15 G1's runtime sweep at dpr 2 and landed
+  // (claims §5.70 §2 and §8): the gain 4.8 — a heavy width of 6 device px, the
+  // sweep's own interior minimum and narrower than G0's Gaussian estimate — the
+  // deep value fully heavy, and the span top left at the 1x value because a
+  // floor of 1 leaves it nothing to rise to. Read only above dpr 1, so the 1x
+  // material is byte-identical to the W13 bed (see
+  // `MaterialProfile.sizeScatterFloor2x`).
+  sizeScatterGainMax2x: 4.8,
+  sizeScatterFloor2x: 1,
+  sizeScatterSpanMax2x: 256,
+  // The 2x gain's own span grading (W15 G1's re-form, claims §5.70 §8; W15
+  // Decision Log 3), set from G0's independent per-span reading — 8 device px
+  // at span 96 and 11 at 160 — and not from the holdout row it fixes.
+  sizeScatterGainFar2x: 9.9,
+  // 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 three are G0's readings, LANDED by W15 G1 (claims
+  // §5.70 §2): thin is G0's u 6 reading and stage 2b's best, thick and far are
+  // one number because G0 read the 2x start flat across the thick spans, and
+  // with the deep value now fully heavy at that ratio the ramp is the whole
+  // body above it rather than the null W13 recorded. See
+  // `MaterialProfile.sizeScatterRampStartThin1x`.
+  sizeScatterRampStartThin1x: 0.72,
+  sizeScatterRampStartThick1x: 0.52,
+  sizeScatterRampStartFar1x: 0.2,
+  sizeScatterRampStartThin2x: 0.46,
+  sizeScatterRampStartThick2x: 0.21,
+  sizeScatterRampStartFar2x: 0.21,
+  sizeScatterRampReach1xPx: 80,
+  sizeScatterRampReach2xPx: 100,
   sizeOcclusionGain: 0.05,
   sizeShadowGainMax: 1,
-  // MEASURED (W11c G2, claims §5.43): the reference band's inward source
-  // displacement is 33 px at the contour on a 20.8 px lens depth — 1.6 lens
-  // depths — following the shader's own (1 − depth)² profile (per-shell fits
-  // on the probe's pitch-32/64 cells, spans 96/128 fitted, 160 held out; the
-  // gain's sweep 1.4/1.6/1.8/2.4 reads 0.0487/0.0478/0.0516/0.0567 at the
-  // shader's depth and profile). The band folds the plate from 1.6 lens depths
-  // inward; nothing in it is sharper or darker than the interior.
-  lensRefractionGain: 1.6,
+  /*
+   * 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 },
@@ -568,14 +633,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
@@ -614,13 +683,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],
@@ -641,9 +730,29 @@ 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_GAIN_MAX_2X = DEFAULT_MATERIAL_PROFILE.sizeScatterGainMax2x;
+var SIZE_SCATTER_GAIN_FAR_2X = DEFAULT_MATERIAL_PROFILE.sizeScatterGainFar2x;
+var SIZE_SCATTER_FLOOR_2X = DEFAULT_MATERIAL_PROFILE.sizeScatterFloor2x;
+var SIZE_SCATTER_SPAN_MAX_2X = DEFAULT_MATERIAL_PROFILE.sizeScatterSpanMax2x;
+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_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;
@@ -653,7 +762,20 @@ 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] };
@@ -675,9 +797,31 @@ function withMaterialOverrides(base, patch) {
     sizeScatterGainMax: patch.sizeScatterGainMax ?? base.sizeScatterGainMax,
     sizeScatterFloor: patch.sizeScatterFloor ?? base.sizeScatterFloor,
     sizeScatterSpanMax: patch.sizeScatterSpanMax ?? base.sizeScatterSpanMax,
+    sizeScatterGainMax2x: patch.sizeScatterGainMax2x ?? base.sizeScatterGainMax2x,
+    sizeScatterFloor2x: patch.sizeScatterFloor2x ?? base.sizeScatterFloor2x,
+    sizeScatterSpanMax2x: patch.sizeScatterSpanMax2x ?? base.sizeScatterSpanMax2x,
+    sizeScatterGainFar2x: patch.sizeScatterGainFar2x ?? base.sizeScatterGainFar2x,
+    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,
     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 },
@@ -810,15 +954,122 @@ 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, scatterThickness(spanPx, 1, 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 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, devicePixelRatio, spanPx);
+}
+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, scatterSpanMaxAtScale(profile, devicePixelRatio), 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 scatterGainAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  return rampAtScale(profile.sizeScatterGainMax, profile.sizeScatterGainMax2x, devicePixelRatio);
+}
+function scatterGainFarAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  return rampAtScale(profile.sizeScatterGainMax, profile.sizeScatterGainFar2x, devicePixelRatio);
+}
+function scatterGainAt(spanPx, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  const near = scatterGainAtScale(profile, devicePixelRatio);
+  const far = scatterGainFarAtScale(profile, devicePixelRatio);
+  if (far === near)
+    return near;
+  return near + (far - near) * smoothstep(profile.sizeSpanMax, scatterSpanMaxAtScale(profile, devicePixelRatio), spanPx);
 }
-function scatterThickness(spanPx, fold, profile = DEFAULT_MATERIAL_PROFILE) {
-  const floor = Math.min(1, Math.max(0, profile.sizeScatterFloor));
-  return floor + (1 - floor) * smoothstep(profile.sizeSpanMin, profile.sizeScatterSpanMax, spanPx) * fold;
+function scatterFloorAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  return clampUnit(rampAtScale(profile.sizeScatterFloor, profile.sizeScatterFloor2x, devicePixelRatio));
 }
-function sizeScatterSigmaAt(sigmaPx, scatter, profile = DEFAULT_MATERIAL_PROFILE) {
-  return sigmaPx * (1 + (profile.sizeScatterGainMax - 1) * scatter);
+function scatterSpanMaxAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  return rampAtScale(profile.sizeScatterSpanMax, profile.sizeScatterSpanMax2x, devicePixelRatio);
+}
+function scatterDeepThickness(spanPx, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  const floor = scatterFloorAtScale(profile, devicePixelRatio);
+  return floor + (1 - floor) * smoothstep(profile.sizeSpanMin, scatterSpanMaxAtScale(profile, devicePixelRatio), spanPx);
+}
+function scatterSharpShare(uDevicePx, devicePixelRatio, profile = DEFAULT_MATERIAL_PROFILE, spanPx = 0) {
+  const deepSharp = 1 - scatterDeepThickness(spanPx, profile, devicePixelRatio);
+  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 = scatterFloorAtScale(profile, devicePixelRatio);
+  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, devicePixelRatio);
+  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, devicePixelRatio = 1, spanPx) {
+  const mix = clampUnit(scatter);
+  const gain = spanPx === void 0 ? scatterGainAtScale(profile, devicePixelRatio) : scatterGainAt(spanPx, profile, devicePixelRatio);
+  return sigmaPx * (1 + (gain - 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);
@@ -838,15 +1089,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);
@@ -856,8 +1171,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;
@@ -875,15 +1190,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 lensDisplacementPx(depthPx, lensDepthPx2, refractionScale, profile = DEFAULT_MATERIAL_PROFILE) {
-  if (lensDepthPx2 <= 0)
+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 depth = Math.min(Math.max(depthPx / lensDepthPx2, 0), 1);
-  return lensDepthPx2 * (1 - depth) * (1 - depth) * refractionScale * profile.lensRefractionGain;
+  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
@@ -1721,7 +2039,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
@@ -1878,7 +2197,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))
     };
@@ -1943,7 +2262,7 @@ 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.spanPx;
     data[o + 17] = 0;
@@ -2221,7 +2540,7 @@ 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
   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
@@ -2389,7 +2708,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, spanPx, 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
@@ -2423,14 +2743,25 @@ var WGSL_FIELD_PASS = `struct FieldUniforms {
 // 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 {
@@ -2443,13 +2774,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.span, 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
@@ -2467,6 +2802,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;
   }
 
@@ -2479,6 +2815,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
@@ -2491,6 +2828,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) {
@@ -2646,7 +2984,9 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   screen : vec4f,
   /// backdrop uv transform on viewport-normalised coords: scale (xy), offset (zw)
   fit : vec4f,
-  /// refractionScale, lensRefractionGain (W11c G2), unused, 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,
@@ -2665,7 +3005,8 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   light : vec4f,
   /// hasBackdrop, fieldSize.xy, fieldUpsampled
   flags : vec4f,
-  /// the size law's gains (W2): scatterGainMax, occlusionGain, shadowGainMax,
+  /// the size law's gains (W2): scatterGainMax \u2014 resolved at the group's device
+  /// ratio since W15 G1, claims 5.69 section 1 \u2014 occlusionGain, shadowGainMax,
   /// bodyChainLod \u2014 the last being the chain level whose blur already matches the
   /// body texture, which is what the scattering term measures its octaves from
   size : vec4f,
@@ -2677,17 +3018,27 @@ 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; zw are the padding
-  /// a uniform's vec4 alignment requires
+  /// 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
+  /// heavy width's gain at the TOP of the scatter span curve, resolved at this
+  /// group's device ratio (W15 G1's re-form, claims \xA75.70 \xA74 and \xA77) \u2014 the
+  /// padding slot this vec4's alignment already required, taken because the
+  /// gain's near end (size.x) has no free neighbour and this vec4 already
+  /// carries the body ramp's other span-graded end; at dpr 1 it equals size.x
+  /// and the grading is flat
   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
@@ -2699,10 +3050,45 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   toneRowThin : vec4f,
   /// the thick row (sizeThickness saturated), same layout
   toneRowThick : vec4f,
-  /// the size law's bands (W11c): the scatter facet's floor (x) and its own
-  /// band top (y), and the thickness curve's sizeSpanMin (z) and sizeSpanMax
-  /// (w) \u2014 both curves start at z; the fold they multiply by is tone.w
+  /// the size law's bands: the scatter facet's floor (x, resolved at the
+  /// group's device ratio since W15 G1 \u2014 the deep value is per-scale, claims
+  /// 5.69 section 2 \u2014 and read here for both the deep curve and the fold) 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, resolved at the group's
+  /// device ratio since W15 G1), 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;
@@ -2712,6 +3098,9 @@ 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'.
@@ -2767,7 +3156,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
@@ -2778,9 +3193,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.
@@ -2816,14 +3235,11 @@ 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.
   // 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(
@@ -2832,10 +3248,65 @@ fn outer_shadow_alpha(uv : vec2f, upsampled : f32, fieldSize : vec2f) -> f32 {
     1.0,
   );
   let sizeK = clamp(castT * castT * (3.0 - 2.0 * castT) * clamp(ou.tone.w, 0.0, 1.0), 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 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
@@ -2847,13 +3318,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;
@@ -2869,46 +3343,179 @@ 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 two curves off the span of whichever surface owns this pixel
+  // 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. 'kScatter' is the
-  // scatter facet's own mix, floor + (1 - floor) \xB7 smoothstep to
-  // 'sizeScatterSpanMax' \xB7 fold: the floor is the material's frost at any size
-  // and is not folded, the rise is depth and is. Both written out as
-  // smoothsteps with a guarded denominator, so a profile that collapses a band
+  // 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);
-  let sizeK = clamp(thickT * thickT * (3.0 - 2.0 * thickT) * fold, 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 floor and the span top arrive resolved at the ratio this group draws at
+   * (W15 G1, claims 5.69 section 2): the reference's 2x deep interior is fully
+   * heavy on the largest spans where this curve fitted at 1x leaves a sharp
+   * share of 0.24-0.36, so kDeep is a per-scale law. Nothing about the
+   * arithmetic here changes - the uniforms carry a different number, not a
+   * different shape - and on the landed material the two anchors are equal.
+   *
+   * 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 scatterT = clamp((span - ou.scatter.z) / max(ou.scatter.y - ou.scatter.z, 1e-6), 0.0, 1.0);
-  let kScatter = clamp(
-    scatterFloor + (1.0 - scatterFloor) * scatterT * scatterT * (3.0 - 2.0 * scatterT) * fold,
-    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);
-
-  // W11c G2: the lens is the body read from further inside. 'lens.y' is the
-  // profile's refraction gain, the contour displacement in lens depths.
-  let displaceCss = -normal * lensDepth * profile * ou.lens.x * ou.lens.y;
+  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 refractedUv = clamp(refracted01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
@@ -2926,7 +3533,13 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
    * 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 scatterLod = clamp(ou.size.w + log2(max(ou.size.x, 1e-4)), 0.0, ou.lens.w);
+  // The gain is per PIXEL and not one number per group since W15 G1's re-form
+  // (claims \xA75.70 \xA74 and \xA77): the reference's heavy kernel grows with the span,
+  // so the gain rises from its near end 'size.x' to its far end 'shadowSize.w'
+  // along 'farS' \u2014 the very smoothstep the ramp's far anchor already declines
+  // along, computed above with the share. One curve, two quantities.
+  let gainEff = ou.size.x + (ou.shadowSize.w - ou.size.x) * farS;
+  let scatterLod = clamp(ou.size.w + log2(max(gainEff, 1e-4)), 0.0, ou.lens.w);
 
   var backdrop = vec3f(0.0);
   if (ou.flags.x > 0.5) {
@@ -3160,7 +3773,7 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // 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 - profile * shadowDepth * ou.light.w * present;
+  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;
@@ -3198,7 +3811,10 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // 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, body.a + shadowAlpha * (1.0 - coverage));
+  return vec4f(
+    body.rgb + liftEncoded * (1.0 - coverage),
+    body.a + shadowAlpha * (1.0 - coverage),
+  );
 }`;
 
 // ../renderer-webgpu/dist/wgsl/prelude.js
@@ -3326,7 +3942,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" }
     };
@@ -3390,6 +4010,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;
@@ -3423,6 +4050,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 }
           }
         ]
       });
@@ -3439,13 +4072,14 @@ function createPassRunner(context) {
       return {
         field,
         aux,
+        aux2,
         width,
         height,
         upsampled: width !== rectWidth || height !== rectHeight
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 76);
+      const slot = uniformSlot(`optics:${args.groupId}`, 96);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -3457,7 +4091,7 @@ function createPassRunner(context) {
       d[7] = args.fit[3];
       d[8] = args.refractionScale;
       d[9] = args.lensRefractionGain;
-      d[10] = 0;
+      d[10] = args.shadowDepthSizeGainMax;
       d[11] = args.chainMaxLod;
       d[12] = args.tint[0];
       d[13] = args.tint[1];
@@ -3505,8 +4139,8 @@ function createPassRunner(context) {
       d[55] = args.outerShadow[3];
       d[56] = args.outerShadowSizeGain;
       d[57] = args.outerShadowRectCssHeight;
-      d[58] = 0;
-      d[59] = 0;
+      d[58] = args.sizeScatterRampStartThick;
+      d[59] = args.sizeScatterGainFar;
       d[60] = args.backdropToneAnchorX[0];
       d[61] = args.backdropToneAnchorX[1];
       d[62] = args.backdropToneAnchorX[2];
@@ -3520,9 +4154,29 @@ function createPassRunner(context) {
       d[70] = args.backdropToneResponseThick[2];
       d[71] = 0;
       d[72] = args.sizeScatterFloor;
-      d[73] = args.sizeScatterSpanMax;
+      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;
@@ -3545,7 +4199,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);
@@ -3628,6 +4283,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}`]) {
@@ -3773,10 +4429,8 @@ 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 sameDensity = (existing, request) => {
-  const next = densityOf({ width: existing.sourceWidth, height: existing.sourceHeight }, request);
-  return Math.abs(next - existing.texelsPerCss) <= 1e-6 * Math.max(1, existing.texelsPerCss);
-};
+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();
@@ -3852,7 +4506,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, density) {
+  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;
@@ -3893,7 +4547,8 @@ function createPyramidStore(context) {
       bodySigmaTexels,
       texelsPerCss: density.texelsPerCss,
       sourceWidth: density.sourceWidth,
-      sourceHeight: density.sourceHeight
+      sourceHeight: density.sourceHeight,
+      bodySigmaCss
     };
     resources.set(sourceId, next);
     return next;
@@ -4081,7 +4736,7 @@ function createPyramidStore(context) {
     },
     build(request, provider, encoder) {
       const existing = liveResources(request.sourceId);
-      if (existing !== void 0 && existing.builtEpoch >= request.epoch && !provider.isDirty() && sameDensity(existing, request)) {
+      if (existing !== void 0 && existing.builtEpoch >= request.epoch && !provider.isDirty() && sameBody(existing, request)) {
         ledger.recordClean();
         return { status: "clean", resources: existing };
       }
@@ -4103,7 +4758,7 @@ function createPyramidStore(context) {
       const planScale = frame.width > 0 ? plan.width / frame.width : 1;
       const bodySigmaTexels = request.bodySigmaCss * texelsPerCss * planScale;
       const bodyPlan = bodyBlurPlan(bodySigmaTexels, plan);
-      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels, { texelsPerCss, sourceWidth: frame.width, sourceHeight: frame.height });
+      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);
@@ -4316,7 +4971,14 @@ function createWebGPURenderer(options = {}) {
     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 densityRebuilds = (explicit, pyramids) => {
+  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()) {
@@ -4326,7 +4988,10 @@ function createWebGPURenderer(options = {}) {
       if (existing === void 0)
         continue;
       const next = texelsPerCssPx(existing.sourceWidth, existing.sourceHeight, placements.get(sourceId), viewport.widthCss, viewport.heightCss);
-      if (Math.abs(next - existing.texelsPerCss) <= 1e-6 * Math.max(1, existing.texelsPerCss))
+      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,
@@ -4339,6 +5004,14 @@ function createWebGPURenderer(options = {}) {
   };
   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) => {
+    const optics = opticsUnderPolicy(material.optics[sourceVariant(sourceId)], accessibility, material);
+    return optics.blurSigma / Math.max(viewport.devicePixelRatio, 1e-3);
+  };
   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);
@@ -4353,8 +5026,8 @@ function createWebGPURenderer(options = {}) {
   function rebuildRequests(explicit) {
     const base = explicit ?? standaloneRequests();
     const { store: pyramids } = ensureContext();
-    const density = densityRebuilds(base, pyramids);
-    return density.length === 0 ? base : [...base, ...density];
+    const stale = staleBodyRebuilds(base, pyramids);
+    return stale.length === 0 ? base : [...base, ...stale];
   }
   function standaloneRequests() {
     const sampled = /* @__PURE__ */ new Set();
@@ -4390,15 +5063,21 @@ 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,
+        // The body's sharp width is a DEVICE-pixel quantity (W12 G3, claims
+        // §5.56; restored by W15 G1): `blurSigma` device px, so
+        // `blurSigma / dpr` in the CSS px the pyramid converts to source
+        // texels with. The heavy component rides the same conversion — its
+        // level is this one plus log2(the gain at this ratio) octaves — so it
+        // is the gain's own multiple of the sharp width in device px at every
+        // scale. At dpr 1 this is `optics.blurSigma` unchanged, which is what
+        // leaves the 1x law exactly as landed.
+        bodySigmaCss: bodySigmaCssFor(request.sourceId),
         viewportCss: [viewport.widthCss, viewport.heightCss],
         ...isUsablePlacement(placement) ? { placement } : {}
       }, provider, encoder);
@@ -4449,11 +5128,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)
@@ -4493,7 +5173,7 @@ function createWebGPURenderer(options = {}) {
         backdropToneSizeBiasUnderPolicy(policy, material),
         input.backdropTone === void 0 ? 0 : backdropToneUnderPolicy(policy, material) * material.backdropToneMax
       ];
-      const backdropToneLevel = input.backdropTone === void 0 ? 0 : input.backdropToneLevel ?? relativeLuminance(input.backdropTone);
+      const backdropToneLevel = shadowBackdropLuminance ?? 0;
       const refraction = effectiveRefraction(accessibilityRefractionCap(policy), state.refraction);
       const refractionScale = material.refractionScale[refraction];
       passes.opticsPass(encoder, {
@@ -4508,6 +5188,19 @@ function createWebGPURenderer(options = {}) {
         fit: pyramid === void 0 || sourceId === void 0 ? [1, 1, 0, 0] : fitFor(sourceId, pyramid),
         refractionScale,
         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,
@@ -4540,7 +5233,20 @@ function createWebGPURenderer(options = {}) {
         // group whose members are not one size. `bodyChainLod` is where the body
         // blur already sits on the chain — only the pyramid that built it knows
         // the CSS-px-to-texel conversion, so it publishes the σ and this converts.
-        sizeScatterGainMax: material.sizeScatterGainMax,
+        // The gain at the ratio this group draws at (W15 G1, claims §5.69 §1):
+        // the shader's scatter level is `bodyChainLod + log2(gain)`, so this is
+        // where the heavy width's second scale acts. `sizeScatterGainMax2x`
+        // defaults to the 1x gain, so this is `material.sizeScatterGainMax`
+        // until the sweep fits it.
+        sizeScatterGainMax: scatterGainAtScale(material, dpr),
+        // The gain's far end at the same ratio (W15 G1's re-form, claims §5.70
+        // §4 and §7): the shader grades the gain from the near end at
+        // `sizeSpanMax` to this at `sizeScatterSpanMax`, because the reference's
+        // heavy kernel grows with the span and one gain left the largest span's
+        // deep interior too structured. `sizeScatterGainFar2x` defaults to the
+        // 2x gain's own default and interpolates from the 1x gain, so this is
+        // `sizeScatterGainMax` at dpr 1 whatever the profile says.
+        sizeScatterGainFar: scatterGainFarAtScale(material, dpr),
         sizeOcclusionGain: material.sizeOcclusionGain,
         sizeShadowGainMax: material.sizeShadowGainMax,
         bodyChainLod: chainLodForSigma(pyramid?.bodySigmaTexels ?? 0),
@@ -4549,8 +5255,26 @@ function createWebGPURenderer(options = {}) {
         // same fold `sizeThicknessUnderPolicy` applies on the CPU.
         sizeSpanMin: material.sizeSpanMin,
         sizeSpanMax: material.sizeSpanMax,
-        sizeScatterFloor: material.sizeScatterFloor,
-        sizeScatterSpanMax: material.sizeScatterSpanMax,
+        // The deep value's floor and span top at this ratio (W15 G1, claims
+        // §5.69 §2). Same two uniform slots the shader has always read for
+        // `kDeep` and for the fold; only the value is resolved from the
+        // viewport now, as the ramp's anchors already were.
+        sizeScatterFloor: scatterFloorAtScale(material, dpr),
+        sizeScatterSpanMax: scatterSpanMaxAtScale(material, dpr),
+        // 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, scatterSpanMaxAtScale(material, dpr)),
+        sizeScatterRampReachCssPx: scatterRampReachDevicePx(dpr, material) / dpr,
         sizeFold: material.refractionScale[accessibilityRefractionCap(policy)],
         backdropTone,
         backdropToneColour: [
@@ -4579,7 +5303,11 @@ function createWebGPURenderer(options = {}) {
         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
@@ -4587,6 +5315,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 : {
@@ -4868,6 +5609,6 @@ function createWebGPURenderer(options = {}) {
   };
 }
 
-export { ADAPTIVE_LUMINANCE_HIGH, ADAPTIVE_LUMINANCE_LOW, ADAPTIVE_TINT_DARK, ADAPTIVE_TINT_LIGHT, ANALYSIS_DISPATCH, ANALYSIS_GRID, ANALYSIS_PASS_ID, ANALYSIS_STATS_FLOATS, ANALYSIS_TARGET_EXTENT, ANALYSIS_WORKGROUP, BACKDROP_ALPHA_MODES, BACKDROP_COLOR_SPACES, BACKDROP_KINDS, BACKDROP_PASS_ID, BACKDROP_TONE_HIGH, BACKDROP_TONE_LOW, BACKDROP_TONE_MAX, BACKDROP_TONE_SIZE_BIAS, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDENTITY_FIT, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_REFRACTION_GAIN, 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_FLOOR, SIZE_SCATTER_GAIN_MAX, 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, lensDepthPx, lensDisplacementPx, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowReachPx, outerShadowUnderPolicy, packInstances, pipelineKey, placementFit, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, samePlacement, scatterThickness, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, texelsPerCssPx, tintShade, tintShadeLayer, tintToneAdaptation, tintedMaterialColour, validateAppTexture, withMaterialOverrides };
-//# sourceMappingURL=dist-MVSXUP3K.js.map
-//# sourceMappingURL=dist-MVSXUP3K.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_FLOOR_2X, SIZE_SCATTER_GAIN_FAR_2X, SIZE_SCATTER_GAIN_MAX, SIZE_SCATTER_GAIN_MAX_2X, SIZE_SCATTER_RAMP_REACH_1X_PX, SIZE_SCATTER_RAMP_REACH_2X_PX, SIZE_SCATTER_RAMP_START_FAR_1X, SIZE_SCATTER_RAMP_START_FAR_2X, SIZE_SCATTER_RAMP_START_THICK_1X, SIZE_SCATTER_RAMP_START_THICK_2X, SIZE_SCATTER_RAMP_START_THIN_1X, SIZE_SCATTER_RAMP_START_THIN_2X, SIZE_SCATTER_SPAN_MAX, SIZE_SCATTER_SPAN_MAX_2X, SIZE_SHADOW_GAIN_MAX, SIZE_SPAN_MAX, SIZE_SPAN_MIN, SRGB_ENCODING_EXPONENT, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptedTintAlpha, adaptedTintColour, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, backdropFit, backdropToneAdaptation, 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, scatterFloorAtScale, scatterGainAt, scatterGainAtScale, scatterGainFarAtScale, scatterRampAreaMean, scatterRampReachDevicePx, scatterRampStart, scatterSharpShare, scatterSpanMaxAtScale, 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-OHNXYEZP.js.map
+//# sourceMappingURL=dist-OHNXYEZP.js.map