@vitreajs/vitrea 0.1.0 → 0.2.0

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

@@ -83,6 +83,30 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   }
 }`;
 
+// ../policy/dist/refraction.js
+var REFRACTION_LADDER = ["none", "approximate", "true"];
+function refractionRank(quality) {
+  return REFRACTION_LADDER.indexOf(quality);
+}
+function accessibilityRefractionCap(policy) {
+  switch (policy.refraction) {
+    case "nominal":
+      return "true";
+    case "reduced":
+      return "approximate";
+    case "none":
+      return "none";
+  }
+}
+function effectiveRefraction(a, b) {
+  return refractionRank(a) <= refractionRank(b) ? a : b;
+}
+var DEFAULT_REFRACTION_SCALE = {
+  none: 0,
+  approximate: 0.45,
+  true: 1
+};
+
 // ../renderer-webgpu/dist/color.js
 var BACKDROP_COLOR_SPACES = ["srgb", "display-p3"];
 var BACKDROP_ALPHA_MODES = ["premultiplied", "unpremultiplied", "opaque"];
@@ -161,26 +185,18 @@ function encodeOutputBytes(linear, alpha) {
 }
 
 // ../renderer-webgpu/dist/material.js
-var REFRACTION_LADDER = ["none", "approximate", "true"];
-function refractionRank(quality) {
-  return REFRACTION_LADDER.indexOf(quality);
-}
-function accessibilityRefractionCap(policy) {
-  switch (policy.refraction) {
-    case "nominal":
-      return "true";
-    case "reduced":
-      return "approximate";
-    case "none":
-      return "none";
-  }
-}
-function effectiveRefraction(a, b) {
-  return refractionRank(a) <= refractionRank(b) ? a : b;
-}
+var NOMINAL_MATERIAL_POLICY = {
+  glass: "material",
+  frost: "nominal",
+  refraction: "nominal",
+  occlusion: "nominal",
+  border: "nominal",
+  ambientTint: "nominal",
+  foreground: "adaptive"
+};
 var MATERIAL_VARIANTS = ["regular", "clear"];
 var SRGB_WHITE_TINT = [1, 1, 1];
-var INCREASED_OCCLUSION_LIFT = 0.4722;
+var INCREASED_OCCLUSION_LIFT = 0.75;
 function occlusionAlphaUnderPolicy(nominal, occlusion, lift = INCREASED_OCCLUSION_LIFT) {
   switch (occlusion) {
     case "nominal":
@@ -197,24 +213,48 @@ var DEFAULT_MATERIAL_PROFILE = {
     // `platform-web`'s CSS-tier blur on the same number — and makes core's 24 px
     // `samplingPadding` advisory exactly the 3σ S1 measured.
     regular: {
-      blurSigma: 8,
+      /*
+       * REFITTED (recalibration cascade, 2026-08-31) against the ACTIVE-pose bed.
+       * C9a's 0.62 and σ = 8 were fitted against the inactive material and are
+       * kept in git history, not here.
+       *
+       * `blurSigma` 3 is the first value this constant has ever had that the
+       * fixtures could identify. §6.1 called it unidentifiable because the
+       * inactive reference passed almost no backdrop structure; the active one
+       * passes a great deal (interior standard deviation 0.1358 over the
+       * checkerboard against vitrea's 0.0176 at σ = 8), so the objective's spread
+       * term now bites — it triples from σ = 3 to σ = 6 at a fixed alpha.
+       *
+       * `tintAlpha` 0.46 is the minimiser over the eight tone-inert untinted rest
+       * calibration cells, a genuine interior optimum (0.38 → 0.16945, 0.46 →
+       * 0.15704, 0.54 → 0.17248) with ΔE and SSIM agreeing. It remains true that
+       * no single value is right for every scene: a lerp toward one tint colour
+       * implies an alpha of 0.24 over the checkerboard and 0.47 over the photo at
+       * the same 44 px span, which is the lerp-versus-multiply question C9a
+       * recorded and nobody has acted on. Claims §5.13.
+       */
+      blurSigma: 3,
       tint: srgbToLinear(SRGB_WHITE_TINT),
-      // MEASURED (C9a), against apple-macos-26.5-1x-light-standard. The advisory
-      // 0.28 made vitrea's regular material roughly half as opaque as the
-      // reference: regressing interior level against backdrop level across the
-      // calibration scenes puts Apple's transmission at 0.26 of the backdrop
-      // where vitrea's was 0.70. 0.62 is the minimiser of the declared tuning
-      // objective; see docs/doperpowers/specs/c9a-fidelity-claims.md, and note
-      // that no single value can be right for every size — Apple's opacity falls
-      // with surface span (0.88 at 32 px to 0.56 at 96 px) and this renderer has
-      // no size term on the tint.
-      tintAlpha: 0.62,
+      tintAlpha: 0.46,
       rimWidth: 1.5,
       rimAlpha: 0.18,
       specularPower: 6,
       specularGain: 0.55,
       shadowDepth: 0.35,
-      shadowAlpha: 0.55,
+      /*
+       * REFITTED 0.55 → 0.05 (2026-08-31), and it is the largest single
+       * improvement in the cascade: the objective falls 0.14615 → 0.09333 with
+       * ΔE and SSIM both improving.
+       *
+       * The active reference's contour is BRIGHTER than its own body — a rim peak
+       * of 0.025…0.129 above baseline, always at one pixel deep. vitrea's read
+       * 0.0000 with its peak 8-12 px in, meaning it had no edge feature at all:
+       * the inner shadow at 0.55 was darkening the contour faster than the rim lit
+       * it. The rim constants themselves did not move; the thing suppressing them
+       * did. On the inactive bed the reference's rim was 0.0000…0.0041 and this
+       * was invisible, which is what §6.2 recorded as "below quantisation".
+       */
+      shadowAlpha: 0.05,
       highlight: srgbToLinear(SRGB_WHITE_TINT)
     },
     // Persistently more transparent, so it frosts less and tints less.
@@ -260,20 +300,277 @@ var DEFAULT_MATERIAL_PROFILE = {
   adaptiveTintLight: srgbToLinear(SRGB_WHITE_TINT),
   adaptiveLuminanceLow: 0.12,
   adaptiveLuminanceHigh: 0.42,
-  refractionScale: {
-    none: 0,
-    approximate: 0.45,
-    true: 1
-  },
-  lensSpanMin: 28,
-  lensSpanMax: 420,
+  // Authored in `@vitrea/policy` alongside the ladder it is keyed by, because the
+  // CSS tier needs the same table and used to hold two more copies of it
+  // (Decision Log #23(d)). The profile is still what the shaders read and still
+  // what `withMaterialOverrides` replaces — only the *default* literal moved, and
+  // it moved unchanged.
+  refractionScale: DEFAULT_REFRACTION_SCALE,
+  /*
+   * MEASURED (W2), against the settled apple-macos-26.5 bed, and set from the
+   * REFERENCE's own size-dependence rather than from the objective's minimum.
+   *
+   * The band was 28…420 while it served the lens alone and nothing had measured
+   * it, which put the whole canonical range (32…160 px) inside the first 17% of
+   * the curve. What the settled reference actually does, over a fixed checkerboard
+   * backdrop: it passes 0.244 of the backdrop's contrast at a 32 px span, 0.230 at
+   * 44 px and 0.144 at 96 px. So 6% of the movement happens between 32 and 44 and
+   * the rest between 44 and 96, and it is finished by 96 — which is what these two
+   * numbers are. `sizeSpanMin` is also the smallest canonical component's span, so
+   * that component is the law's exact zero by construction.
+   *
+   * The tuning objective would rather have 64 (0.1568 against 0.1637 on the rest
+   * cells, a 4% win inside a grid that spans 1.07×). Declined, and the reason is
+   * recorded rather than the win taken: the gain comes entirely from the interior
+   * *level* term, whose residual is the backdrop tone-adaptation gap that wave
+   * child W7 is chartered to close — so a band fitted to 64 would be using the
+   * size law as a proxy for a mechanism vitrea does not have yet, against the
+   * reference's own measurement of where its size-dependence lives, and W7 would
+   * have to unpick it. See the claims doc's size-law section.
+   */
+  sizeSpanMin: 32,
+  sizeSpanMax: 96,
   lensSizeGainMax: 2.6,
+  /*
+   * MEASURED (W2), each with its own status — see the fields' notes.
+   *
+   * `sizeScatterGainMax` = 1: implemented on both tiers and inert, because the
+   * canonical fixtures cannot resolve it. The objective is flat to 1.00× over
+   * gains 1…6, and that is not the backdrop chain's depth talking: re-run with the
+   * chain deepened (MIN_LEVEL_EXTENT 8 → 4, which lifts the reachable σ on the
+   * 320×200 canvas from 1.2× to 2.4×) the grid is still flat to 1.00× and still
+   * best at 1. A number the fixtures cannot see is a number that will be met by
+   * accident, so this ships at the identity with the mechanism in place.
+   *
+   * `sizeOcclusionGain` = 0: fitted, and the fit is a boundary optimum with real
+   * leverage against it — the objective rises monotonically, 0.168 → 0.224 across
+   * 0…0.5, a 1.33× spread. The diagnosis is not a tuning failure: vitrea's
+   * interior sits 0.16–0.19 above the reference's at every span because the
+   * reference's level is set by backdrop tone adaptation toward roughly 0.63 while
+   * vitrea lerps toward a white tint, so making a large surface *more* opaque can
+   * only take it further from the reference. The facet is Apple's ("a larger size
+   * is more opaque"); the axis that would let it fit is W7's.
+   *
+   * `sizeShadowGainMax` = 1.4: fitted on the calibration REST cells, where the
+   * grid 1.0/1.2/1.4/1.6/1.8/2.2 reads 0.1577/0.1551/0.1533/0.1530/0.1529/0.1531.
+   * 1.4 through 2.2 are one flat region (0.25% apart); 1.4 is the point inside it
+   * that costs the checks least (ΔE 0.01282 against the baseline's 0.01290, SSIM
+   * 0.9671 against 0.9689) and it is the per-cell minimum on both well-conditioned
+   * span-96 rest cells. The pressed cells prefer 2.4 monotonically and are
+   * excluded from the fit on §6.3's grounds — their native side carries no press
+   * pose, so they compare two different states and cannot arbitrate a material
+   * constant.
+   *
+   * ## Re-fitted against the ACTIVE bed (2026-08-31)
+   *
+   * `sizeScatterGainMax` stays 1 and is now POSITIVELY identified rather than
+   * flat: with `blurSigma` refitted to 3 the objective rises 6-7% at gains 2 and
+   * 4, so the identity is the optimum instead of a tie.
+   *
+   * `sizeOcclusionGain` stays 0, a boundary result for the fourth time and for a
+   * fourth distinct reason. The reasoning above is retired: the per-cell residual
+   * now points the gain's way in every backdrop (web − reference falls with span
+   * — checkerboard +0.105/+0.112/+0.046 at 32/44/96 px, photo −0.004/−0.087,
+   * light-solid −0.028/+0.001), so the facet finally has the right sign. What it
+   * does not have is magnitude: over 0/0.05/0.10/0.15 × spans ending 96/128/160
+   * the whole grid is flat to 1.04×, and a 0.2% preference is not evidence. It
+   * ships at the identity because the bed cannot identify it, not because the
+   * mechanism is wrong.
+   *
+   * ## Re-fitted against the FROZEN bed (2026-09-01)
+   *
+   * `sizeOcclusionGain` 0 → **0.05**, and this is the first time the bed could
+   * see it. Every earlier fit was a boundary result because calibration held no
+   * span above `sizeSpanMax`, so the curve this gain rides was saturated at every
+   * cell that could vote. The frozen bed adds three span-128 `rrect-ml`
+   * calibration cells, and with them the grid stops being flat: 0.05 is the
+   * optimum at **both** backing scales independently — 1× 0.08288 against the
+   * identity's 0.08374, 2× 0.09338 against 0.09557 — and ΔE and SSIM move the
+   * same way at both.
+   *
+   * It is still a small number and it is reported as one: a 1.0% preference at
+   * 1×, against the 0.2% this doc rightly refused a round ago. What changed is
+   * not the margin's size but that it now reproduces on an independent profile
+   * instead of resting on one flat grid.
+   *
+   * `sizeSpanMax` stays 96, and that is now a measurement rather than an
+   * assumption. With a span-128 cell voting, the grid rises monotonically —
+   * 96/112/128/144/160/192 reading 0.0837/0.0858/0.0943/0.1060/0.1171/0.1300 —
+   * so the band's top is where it was, and the suspicion that the bed simply
+   * could not see above it is answered rather than inherited.
+   *
+   * `sizeShadowGainMax` 1.4 → 1. Its evidence dissolved rather than reversing:
+   * this is a gain on the INNER SHADOW, and the inner shadow was refitted from
+   * `shadowAlpha` 0.55 to 0.05, so there is almost nothing left for it to gain
+   * on. The grid 1.0/1.4/2.2 is flat to 0.2%. Carrying a fitted-looking 1.4 whose
+   * measurement no longer exists would be the worse of the two errors.
+   */
+  sizeScatterGainMax: 1,
+  sizeOcclusionGain: 0.05,
+  sizeShadowGainMax: 1,
   lensBodyLodPerPx: 0.16,
   lensRimLodBias: 2.5,
   reducedTransparencyFrost: 1.75,
   increasedOcclusionLift: INCREASED_OCCLUSION_LIFT,
   strongBorderRim: { rimWidth: 2, rimAlpha: 0.95 },
   reducedTintAdaptation: 0.35,
+  // ADVISORY (W3). The span 0.02 … 0.65 covers most of the canonical backdrop
+  // range (0.003 … 0.891 linear), and the two ends are deliberately symmetric —
+  // 0.45 of the seed's brightness at the dark end, 0.45 of the way to white at
+  // the bright end — so the seed itself sits mid-range and the excursion reads
+  // as glass rather than as two different colours.
+  /*
+   * FITTED (2026-08-31, active bed) — and the fit is that THE CURVE IS THE
+   * IDENTITY. `floor` → 1 and `ceilMix` → 0 make `tintTone` return the seed
+   * unchanged at every backdrop, which leaves `low` and `high` describing
+   * nothing at all; they keep their provisional values so a bed that can
+   * identify them has somewhere to land, exactly as `adaptiveTint` keeps two
+   * equal ends.
+   *
+   * Monotone and uncontested over floor ∈ {0.45, 0.7, 0.85, 1} × ceilMix ∈
+   * {0, 0.2, 0.45}: objective 0.26523 → 0.12676, a 2.09× spread, with ΔE
+   * (0.01331 → 0.00831) and SSIM (0.9749 → 0.9788) agreeing. The reference
+   * says the same thing directly — on three of the five calibration backdrops
+   * its tinted interior is the declared seed EXACTLY in linear light, at a
+   * per-channel standard deviation of 0.000. Apple's tint is the author's
+   * colour, not a range of tones mapped to it; S219's wording described the
+   * inactive material's residue. Claims §5.13.
+   */
+  tintToneFloor: 1,
+  tintToneCeilMix: 0,
+  tintToneLow: 0.02,
+  tintToneHigh: 0.65,
+  /*
+   * MEASURED (W7), against the settled apple-macos-26.5 bed, on the light and
+   * dark standard profiles jointly and at both scales.
+   *
+   * The observable these four are set from is the one quantity in this bed that
+   * isolates adaptation from everything else: the *separation* between the light
+   * and dark references over the same backdrop, on the same component. Under this
+   * mechanism that separation is `(1 − tintAlpha)(1 − a)(tintLight − tintDark)`,
+   * so the material's transmission, the backdrop's structure and each scheme's
+   * own tint all cancel and what is left is `a`. Normalised at the checkerboard,
+   * where nothing adapts, it reads:
+   *
+   *   span 44: 0.000 at backdrop 0.500, 0.030 at 0.205, 1.000 at 0.0117, 1.000 at 0.0049
+   *   span 96: 0.000 at backdrop 0.500, 0.028 at 0.216, 0.256 at 0.0117
+   *
+   * and the 2× bed reproduces every one of those to three decimals (0.2553
+   * against 0.2556 on the one that is not a boundary). Two facts follow. The
+   * adaptation is off across the whole ordinary range and turns on only below
+   * roughly a fifth of the backdrop scale — so it cannot disturb a cell that
+   * already passes. And it is size-gated hard: same backdrop, same material, 1.000
+   * against 0.256.
+   *
+   * The band's dark end is not identifiable from this bed and the fit says so:
+   * the reference's backdrops jump from 0.0117 to 0.205 with nothing in between,
+   * so `backdropToneLow` is bounded only by "at or below the darkest calibration
+   * backdrop". What the two dark backdrops DO pin is the curve's slope near zero —
+   * the 96 px surface reads 0.256 at 0.0117 and 0.356 at 0.0039, which is a
+   * measured intermediate rather than a step, and it is what fixes
+   * `backdropToneSizeBias` against `backdropToneHigh`. `impulse__rrect-md__rest`
+   * is a VALIDATION cell and was not fitted to: the calibration set predicts
+   * 0.34 there and the cell reads 0.356.
+   */
+  backdropToneMax: 1,
+  backdropToneLow: 0.03,
+  backdropToneHigh: 0.14,
+  /*
+   * REFITTED 0.09 → 0.13 (2026-08-31, active bed). The law's SHAPE is untouched
+   * (Decision Log 13 stands; the two-axis rework is next wave) and `max`, `low`
+   * and `high` are unmoved — only the size gate widened.
+   *
+   * What it changes is one cell: a 96 pt surface over the darkest backdrop now
+   * barely adapts, where at 0.09 it adapted by a quarter. Two independent reads
+   * of the reference disagreed about that and the validation set broke the tie.
+   * The light-versus-dark separation estimator §5.8 fitted on says the 96 pt
+   * surface adapts by 0.30; the reference's own interior LEVEL says it does not
+   * (0.4844, against 0.466 for an unadapted surface at the refitted tint alpha
+   * and 0.3566 for an adapted one). Measured once on
+   * `impulse__rrect-md__rest`, which is validation and was fitted to by
+   * neither: 0.09 renders 0.2858 against a reference of 0.4358 at ΔE 0.02344;
+   * 0.13 renders 0.4594 at ΔE 0.00378, six times better. The separation
+   * estimator's algebra assumes the two colour schemes share one tint alpha,
+   * and this profile pair does not (0.46 against 0.97) — recorded in §5.13 as
+   * the reason it is no longer the primary evidence for this constant.
+   */
+  backdropToneSizeBias: 0.13,
+  /*
+   * FITTED (recalibration cascade, 2026-08-31). W8's geometry SURVIVES the fit
+   * unchanged — `sigmaPx` 15.55, `offsetPx` 7.95, `spreadPx` 3.10 — and only the
+   * two amplitudes moved: `occlusion` 0.33 → 0.285 and
+   * `reducedTransparencyOcclusion` 0.566 → 0.70. The dark scheme's amplitude
+   * (0.09) lands as a profile patch, not as a branch here.
+   *
+   * The fit is `scripts/sweep.ts --objective shadow`, whose term is the mean over
+   * calibration cells of |Δ meanDeparture| — the light each side removes from the
+   * whole exterior, in linear light, which is the one commensurate quantity the
+   * facet has. The amplitude is a genuine interior optimum over 0.18…0.44 (a
+   * 2.23× spread) and flat to 1.04% across 0.255…0.315, which is exactly the
+   * scene-to-scene amplitude spread the reference itself shows. The geometry is
+   * NOT identifiable against this objective — σ ∈ {13.5, 15.55, 17.5} × offset ∈
+   * {6.5, 7.95, 9.4} spans 1.04× with 15.55 the argmin — because an integral over
+   * the exterior is insensitive to how the darkening is distributed within it.
+   * W8's own two-dimensional fit against the occlusion field measures the
+   * geometry far more powerfully (RMS 0.0021 over 142,550 pixels), and the
+   * 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
+   * 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
+   * 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.
+   *
+   * Extracted from the active bed's native fixtures directly —
+   * `results/2026-08-31-active-bed-stage0.json` measured the gap, these numbers
+   * measure the facet — and left provisional deliberately: X1 gives the fit to
+   * the recalibration cascade, which owns the holdout discipline. This child owns
+   * the mechanism.
+   *
+   * Method: for each `rest` fixture, the occlusion field `1 − L_capture/L_background`
+   * in linear Rec.709 luminance, over every pixel outside the declared component
+   * geometry with a backdrop bright enough to carry a signal; fitted in two
+   * dimensions against `occlusion · Φ(−sd/σ)`, where `sd` is the signed distance
+   * to the component's own rounded silhouette translated down by `offsetPx` and
+   * outset by `spreadPx`.
+   *
+   * The fit and its residual, on `1x-light-standard` and `2x-light-standard`:
+   *
+   *   backdrop      span   occlusion   σ (1×/2×)   offset (1×/2×)   RMS
+   *   photo           44     0.323     15.5/31.1     7.9/15.8     0.0021
+   *   checkerboard    44     0.338     15.7/31.0     8.0/15.9     0.0016
+   *   hc-text         44     0.339     15.7/31.1     8.0/15.9     0.0014
+   *   photo           32     0.321     15.5/30.9     8.1/16.2     0.0018
+   *   mid-dark-solid  44     0.310        —            —          0.0079
+   *
+   * — against a peak occlusion of 0.24, so the model carries the facet to under
+   * 1% of its own amplitude, over up to 142,550 pixels per cell. The three
+   * lengths are the consensus across every well-conditioned cell; `occlusion` is
+   * the light-standard amplitude at a span the size law leaves alone.
+   *
+   * What the amplitude does NOT yet have is a mechanism for its scene-to-scene
+   * spread. Over the flat near-white `light-solid` backdrop the same fit reads
+   * 0.123 rather than 0.33, reproducibly and at both scales, while the other flat
+   * backdrop (`mid-dark-solid`, linear 0.0595) reads 0.310 — so it is not a
+   * function of the backdrop's luminance, its structure, or the material's
+   * interior level, and no compositing model in either colour space produces both.
+   * The dark-scheme profile is a separate amplitude entirely (0.046…0.061 at a
+   * 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.
+   */
+  outerShadow: {
+    offsetPx: 7.95,
+    sigmaPx: 15.55,
+    spreadPx: 3.1,
+    occlusion: 0.285,
+    reducedTransparencyOcclusion: 0.7,
+    sizeGain: 0
+  },
   lightDirection: [-0.3714, -0.9285],
   sweepBandRadians: 0.55,
   glowRadiusCss: 44,
@@ -286,11 +583,19 @@ var ADAPTIVE_TINT_DARK = DEFAULT_MATERIAL_PROFILE.adaptiveTintDark;
 var ADAPTIVE_TINT_LIGHT = DEFAULT_MATERIAL_PROFILE.adaptiveTintLight;
 var ADAPTIVE_LUMINANCE_LOW = DEFAULT_MATERIAL_PROFILE.adaptiveLuminanceLow;
 var ADAPTIVE_LUMINANCE_HIGH = DEFAULT_MATERIAL_PROFILE.adaptiveLuminanceHigh;
-var LENS_SPAN_MIN = DEFAULT_MATERIAL_PROFILE.lensSpanMin;
-var LENS_SPAN_MAX = DEFAULT_MATERIAL_PROFILE.lensSpanMax;
+var SIZE_SPAN_MIN = DEFAULT_MATERIAL_PROFILE.sizeSpanMin;
+var SIZE_SPAN_MAX = DEFAULT_MATERIAL_PROFILE.sizeSpanMax;
 var LENS_SIZE_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.lensSizeGainMax;
+var SIZE_SCATTER_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.sizeScatterGainMax;
+var SIZE_OCCLUSION_GAIN = DEFAULT_MATERIAL_PROFILE.sizeOcclusionGain;
+var SIZE_SHADOW_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.sizeShadowGainMax;
 var LENS_BODY_LOD_PER_PX = DEFAULT_MATERIAL_PROFILE.lensBodyLodPerPx;
 var LENS_RIM_LOD_BIAS = DEFAULT_MATERIAL_PROFILE.lensRimLodBias;
+var BACKDROP_TONE_MAX = DEFAULT_MATERIAL_PROFILE.backdropToneMax;
+var BACKDROP_TONE_LOW = DEFAULT_MATERIAL_PROFILE.backdropToneLow;
+var BACKDROP_TONE_HIGH = DEFAULT_MATERIAL_PROFILE.backdropToneHigh;
+var BACKDROP_TONE_SIZE_BIAS = DEFAULT_MATERIAL_PROFILE.backdropToneSizeBias;
+var OUTER_SHADOW = DEFAULT_MATERIAL_PROFILE.outerShadow;
 function withMaterialOverrides(base, patch) {
   const optics = {};
   for (const variant of MATERIAL_VARIANTS) {
@@ -307,15 +612,27 @@ function withMaterialOverrides(base, patch) {
     adaptiveLuminanceLow: patch.adaptiveLuminanceLow ?? base.adaptiveLuminanceLow,
     adaptiveLuminanceHigh: patch.adaptiveLuminanceHigh ?? base.adaptiveLuminanceHigh,
     refractionScale,
-    lensSpanMin: patch.lensSpanMin ?? base.lensSpanMin,
-    lensSpanMax: patch.lensSpanMax ?? base.lensSpanMax,
+    sizeSpanMin: patch.sizeSpanMin ?? base.sizeSpanMin,
+    sizeSpanMax: patch.sizeSpanMax ?? base.sizeSpanMax,
     lensSizeGainMax: patch.lensSizeGainMax ?? base.lensSizeGainMax,
+    sizeScatterGainMax: patch.sizeScatterGainMax ?? base.sizeScatterGainMax,
+    sizeOcclusionGain: patch.sizeOcclusionGain ?? base.sizeOcclusionGain,
+    sizeShadowGainMax: patch.sizeShadowGainMax ?? base.sizeShadowGainMax,
     lensBodyLodPerPx: patch.lensBodyLodPerPx ?? base.lensBodyLodPerPx,
     lensRimLodBias: patch.lensRimLodBias ?? base.lensRimLodBias,
     reducedTransparencyFrost: patch.reducedTransparencyFrost ?? base.reducedTransparencyFrost,
     increasedOcclusionLift: patch.increasedOcclusionLift ?? base.increasedOcclusionLift,
     strongBorderRim: { ...base.strongBorderRim, ...patch.strongBorderRim },
     reducedTintAdaptation: patch.reducedTintAdaptation ?? base.reducedTintAdaptation,
+    tintToneFloor: patch.tintToneFloor ?? base.tintToneFloor,
+    tintToneCeilMix: patch.tintToneCeilMix ?? base.tintToneCeilMix,
+    tintToneLow: patch.tintToneLow ?? base.tintToneLow,
+    tintToneHigh: patch.tintToneHigh ?? base.tintToneHigh,
+    backdropToneMax: patch.backdropToneMax ?? base.backdropToneMax,
+    backdropToneLow: patch.backdropToneLow ?? base.backdropToneLow,
+    backdropToneHigh: patch.backdropToneHigh ?? base.backdropToneHigh,
+    backdropToneSizeBias: patch.backdropToneSizeBias ?? base.backdropToneSizeBias,
+    outerShadow: { ...base.outerShadow, ...patch.outerShadow },
     lightDirection: patch.lightDirection ?? base.lightDirection,
     sweepBandRadians: patch.sweepBandRadians ?? base.sweepBandRadians,
     glowRadiusCss: patch.glowRadiusCss ?? base.glowRadiusCss,
@@ -350,14 +667,147 @@ function adaptationStrength(policy, analysisExact, profile = DEFAULT_MATERIAL_PR
       return 0;
   }
 }
+function tintToneAdaptation(policy, profile = DEFAULT_MATERIAL_PROFILE) {
+  switch (policy.ambientTint) {
+    case "nominal":
+      return 1;
+    case "reduced":
+      return profile.reducedTintAdaptation;
+    case "none":
+      return 0;
+  }
+}
+function tintTone(seed, backdropLuminance, toneAdaptation, profile = DEFAULT_MATERIAL_PROFILE) {
+  const t = smoothstep(profile.tintToneLow, profile.tintToneHigh, backdropLuminance);
+  const k = Math.min(1, Math.max(0, toneAdaptation));
+  const channel = (index) => {
+    const s = seed[index];
+    const low = s * profile.tintToneFloor;
+    const high = s + (1 - s) * profile.tintToneCeilMix;
+    return s + (low + (high - low) * t - s) * k;
+  };
+  return [channel(0), channel(1), channel(2)];
+}
+function tintedTintColour(neutral, tint, backdropLuminance, toneAdaptation, profile = DEFAULT_MATERIAL_PROFILE) {
+  if (tint === void 0)
+    return neutral;
+  const tone = tintTone(tint.color, backdropLuminance, toneAdaptation, profile);
+  const k = Math.min(1, Math.max(0, tint.strength));
+  return [
+    neutral[0] + (tone[0] - neutral[0]) * k,
+    neutral[1] + (tone[1] - neutral[1]) * k,
+    neutral[2] + (tone[2] - neutral[2]) * k
+  ];
+}
+function backdropToneAdaptation(backdropLuminance, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  const x = backdropLuminance + profile.backdropToneSizeBias * Math.min(1, Math.max(0, thickness));
+  const span = Math.max(profile.backdropToneHigh - profile.backdropToneLow, 1e-6);
+  const t = Math.min(1, Math.max(0, (x - profile.backdropToneLow) / span));
+  return Math.min(1, Math.max(0, profile.backdropToneMax)) * (1 - t * t * (3 - 2 * t));
+}
+function backdropToneUnderPolicy(policy, profile = DEFAULT_MATERIAL_PROFILE) {
+  return tintToneAdaptation(policy, profile) * profile.refractionScale[accessibilityRefractionCap(policy)];
+}
+function backdropToneSizeBiasUnderPolicy(policy, profile = DEFAULT_MATERIAL_PROFILE) {
+  const cap = profile.refractionScale[accessibilityRefractionCap(policy)];
+  return cap <= 0 ? 0 : profile.backdropToneSizeBias / cap;
+}
+function adaptedTintColour(neutral, backdrop, adaptation, tintAlpha) {
+  const k = Math.min(1, Math.max(0, adaptation));
+  if (k === 0)
+    return neutral;
+  const alpha = adaptedTintAlpha(tintAlpha, k);
+  if (alpha <= 0)
+    return neutral;
+  const wNeutral = (1 - k) * tintAlpha;
+  return [
+    (neutral[0] * wNeutral + backdrop[0] * k) / alpha,
+    (neutral[1] * wNeutral + backdrop[1] * k) / alpha,
+    (neutral[2] * wNeutral + backdrop[2] * k) / alpha
+  ];
+}
+function adaptedTintAlpha(tintAlpha, adaptation) {
+  const k = Math.min(1, Math.max(0, adaptation));
+  return tintAlpha + k * (1 - tintAlpha);
+}
 var smoothstep = (edge0, edge1, x) => {
   if (edge1 <= edge0)
     return x < edge0 ? 0 : 1;
   const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
   return t * t * (3 - 2 * t);
 };
+function sizeThickness(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return smoothstep(profile.sizeSpanMin, profile.sizeSpanMax, spanPx);
+}
+function sizeThicknessUnderPolicy(spanPx, policy, profile = DEFAULT_MATERIAL_PROFILE) {
+  return sizeThickness(spanPx, profile) * profile.refractionScale[accessibilityRefractionCap(policy)];
+}
 function lensSizeGain(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
-  return 1 + (profile.lensSizeGainMax - 1) * smoothstep(profile.lensSpanMin, profile.lensSpanMax, spanPx);
+  return 1 + (profile.lensSizeGainMax - 1) * sizeThickness(spanPx, profile);
+}
+function lensSizeGainFromThickness(thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  return 1 + (profile.lensSizeGainMax - 1) * thickness;
+}
+function sizeScatterSigma(sigmaPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return sizeScatterSigmaAt(sigmaPx, sizeThickness(spanPx, profile), profile);
+}
+function sizeScatterSigmaAt(sigmaPx, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  return sigmaPx * (1 + (profile.sizeScatterGainMax - 1) * thickness);
+}
+function sizeOcclusionAlpha(alpha, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return sizeOcclusionAlphaAt(alpha, sizeThickness(spanPx, profile), profile);
+}
+function sizeOcclusionAlphaAt(alpha, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  return Math.min(1, alpha + profile.sizeOcclusionGain * thickness * (1 - alpha));
+}
+function sizeShadowDepth(shadowDepth, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return sizeShadowDepthAt(shadowDepth, sizeThickness(spanPx, profile), profile);
+}
+function sizeShadowDepthAt(shadowDepth, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  return shadowDepth * (1 + (profile.sizeShadowGainMax - 1) * thickness);
+}
+function sizeOuterShadowOcclusion(occlusion, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
+  return sizeOuterShadowOcclusionAt(occlusion, sizeThickness(spanPx, profile), profile);
+}
+function sizeOuterShadowOcclusionAt(occlusion, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+  return Math.min(1, occlusion + profile.outerShadow.sizeGain * thickness * (1 - occlusion));
+}
+function outerShadowUnderPolicy(policy, profile = DEFAULT_MATERIAL_PROFILE) {
+  const shadow = profile.outerShadow;
+  if (policy.glass === "none" || policy.frost === "none")
+    return { ...shadow, occlusion: 0 };
+  if (policy.frost === "increased") {
+    return { ...shadow, occlusion: shadow.occlusion * shadow.reducedTransparencyOcclusion };
+  }
+  return shadow;
+}
+var SRGB_ENCODING_EXPONENT = 2.4;
+function outerShadowFalloff(signedDistancePx, sigmaPx) {
+  const x = -signedDistancePx / Math.max(sigmaPx, 1e-4);
+  return 0.5 * (1 + Math.tanh(0.7978845608028654 * (x + 0.044715 * x * x * x)));
+}
+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);
+  if (!(alpha > 0))
+    return 0;
+  const cutoff = 1 / 255 / alpha;
+  if (cutoff >= 1)
+    return 0;
+  const sigma = Math.max(shadow.sigmaPx, 1e-4);
+  let lo = -(8 * sigma + Math.abs(shadow.offsetPx) + Math.abs(shadow.spreadPx));
+  let hi = 8 * sigma;
+  for (let i = 0; i < 48; i += 1) {
+    const mid = (lo + hi) / 2;
+    if (outerShadowFalloff(mid, sigma) > cutoff)
+      lo = mid;
+    else
+      hi = mid;
+  }
+  return Math.max(0, hi + Math.abs(shadow.offsetPx) + shadow.spreadPx);
 }
 function lensDepthPx(thicknessPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
   const gain = lensSizeGain(spanPx, profile);
@@ -1252,7 +1702,7 @@ var IDLE_CHANNELS = {
 };
 
 // ../renderer-webgpu/dist/instances.js
-var INSTANCE_FLOATS = 16;
+var INSTANCE_FLOATS = 18;
 var INSTANCE_BYTES = INSTANCE_FLOATS * 4;
 var channelsOf = (input) => ({
   ...IDLE_CHANNELS,
@@ -1264,7 +1714,7 @@ function compressedChannels(shape, press) {
   const scale = 1 - Math.min(1, Math.max(0, press)) * DEFAULT_MOTION_PROFILE.pressCompressionScale;
   return { ...shape, size: [shape.size[0] * scale, shape.size[1] * scale] };
 }
-function resolveSurfaces(group, family, profile = DEFAULT_MATERIAL_PROFILE) {
+function resolveSurfaces(group, family, profile = DEFAULT_MATERIAL_PROFILE, policy = NOMINAL_MATERIAL_POLICY) {
   const byId = /* @__PURE__ */ new Map();
   for (const surface of group.surfaces) {
     if (byId.has(surface.nodeId)) {
@@ -1308,6 +1758,7 @@ function resolveSurfaces(group, family, profile = DEFAULT_MATERIAL_PROFILE) {
     const fieldSource = surface.concentricOf === void 0 ? shape : resolveShapeOf(byId.get(surface.concentricOf.nodeId));
     const inset = surface.concentricOf?.inset ?? 0;
     const spanPx = Math.min(shape.channels.size[0], shape.channels.size[1]);
+    const thickness = sizeThicknessUnderPolicy(spanPx, policy, profile);
     return {
       nodeId: surface.nodeId,
       shape,
@@ -1316,11 +1767,13 @@ function resolveSurfaces(group, family, profile = DEFAULT_MATERIAL_PROFILE) {
       centre: [fieldSource.channels.center[0], fieldSource.channels.center[1]],
       channels,
       spanPx,
-      lensDepthPx: lensDepthPx(shape.channels.thickness, spanPx, profile)
+      lensDepthPx: Math.min(Math.max(shape.channels.thickness, 0) * lensSizeGainFromThickness(thickness, profile), spanPx * 0.5),
+      sizeThickness: thickness,
+      tintStrength: Math.min(1, Math.max(0, surface.tint?.strength ?? 0))
     };
   });
 }
-function groupFieldRect(surfaces, union = DEFAULT_GROUP_UNION, rimWidthPx = 2) {
+function groupFieldRect(surfaces, union = DEFAULT_GROUP_UNION, rimWidthPx = 2, outerShadowReachPx2 = 0) {
   if (surfaces.length === 0)
     return { x: 0, y: 0, width: 0, height: 0 };
   let minX = Number.POSITIVE_INFINITY;
@@ -1335,7 +1788,7 @@ function groupFieldRect(surfaces, union = DEFAULT_GROUP_UNION, rimWidthPx = 2) {
     maxX = Math.max(maxX, cx + w / 2);
     maxY = Math.max(maxY, cy + h / 2);
   }
-  const pad = rimWidthPx + union.maxBulge + 1;
+  const pad = Math.max(rimWidthPx + union.maxBulge + 1, Math.max(outerShadowReachPx2, 0));
   return {
     x: minX - pad,
     y: minY - pad,
@@ -1380,7 +1833,9 @@ function packInstances(surfaces, origin, into) {
     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 + 15] = 0;
+    data[o + 15] = s.tintStrength;
+    data[o + 16] = s.sizeThickness;
+    data[o + 17] = 0;
   }
   return { data, count: surfaces.length };
 }
@@ -1656,7 +2111,9 @@ var WGSL_INSTANCE_STRUCT = `struct Instance {
   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
-  _pad   : f32,     // 60
+  tintK  : f32,     // 60  author tint strength, 0..1 \u2014 the seed itself is a group uniform
+  sizeK  : f32,     // 64  the size law's thickness factor, 0..1 \u2014 material.ts's sizeThickness(span)
+  _pad   : f32,     // 68  stride padding: vec2f aligns the struct to 8, so 72 is the next legal size
 };`;
 var WGSL_FIELD_SAMPLE = `struct FieldSample {
   d : f32,
@@ -1821,7 +2278,29 @@ 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, thicknessPx, press)
+//   aux = (lensDepthPx, glow, sizeK, tintStrength)
+//
+// 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
+// 'lensDepth' is the thickness times the size gain, so the raw number told the
+// shader nothing the depth had not already said; 'press' left because press
+// compression is resolved on the CPU, as a transform on the surface's own size
+// (instances.ts). Both are still packed into the instance buffer, unchanged, for
+// a future consumer that wants them per pixel; they simply no longer ride here.
+//
+// What replaced them are the two quantities that genuinely have to be per pixel,
+// because a group is one field pass and one optics pass while its members are
+// not one thing:
+//
+//   'sizeK'        \u2014 the size law's thickness factor (W2). A 40 px button and a
+//                    320 px platter in one container lens, scatter, occlude and
+//                    shadow by their own size.
+//   'tintStrength' \u2014 the author tint's strength (W3). One emphasised control
+//                    among plain ones is the composition Apple's guidance
+//                    describes; the seed itself is a group uniform.
+//
+// They compose rather than compete: the size law moves what the material does to
+// the backdrop, the tint moves what colour it does it in.
 
 @group(0) @binding(0) var<uniform> fu : FieldUniforms;
 @group(0) @binding(1) var<storage, read> instances : array<Instance>;
@@ -1842,7 +2321,7 @@ 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.thick, s.press);
+  m.aux = vec4f(s.lensDepth, s.glow, s.sizeK, s.tintK);
   return m;
 }
 
@@ -1925,6 +2404,21 @@ var WGSL_HIGHLIGHT_PASS = `struct HighlightUniforms {
   colour : vec4f,
   /// fieldSize.xy, fieldUpsampled (z), unused (w)
   flags : vec4f,
+  /// backdrop tone adaptation (W7), exactly as the optics pass takes it:
+  /// backdropToneLow, backdropToneHigh, the size bias already divided by the
+  /// accessibility refraction cap, and the resolved strength \u2014 zero where there
+  /// is no measured backdrop tone, which stands the fade down
+  toneAdapt : vec4f,
+  /// the backdrop source's own average luminance (x); yzw unused
+  toneLevel : vec4f,
+  /// this pass's uv into the FIELD texture's uv: scale (xy), offset (zw).
+  ///
+  /// The identity for a pass whose scissor is the field's own rect, and not the
+  /// identity since W8: the outer shadow made the field rect much larger than
+  /// anything this pass draws in, so the highlight is scoped back to the rect it
+  /// had before and reads the field through this remap instead. Derived from the
+  /// two rects by highlightPass in passes.ts.
+  fieldFit : vec4f,
 };
 
 @group(0) @binding(0) var<uniform> hu : HighlightUniforms;
@@ -1946,13 +2440,14 @@ fn fs_highlight(in : FullscreenOut) -> @location(0) vec4f {
   // Exact load nominally; filtered when the governor's resolution knob had the
   // field rasterised below the group's rect. The sweep rides the rim, which is
   // the one place a nearest read of a coarse field would show its grid.
+  let fieldUv = in.uv * hu.fieldFit.xy + hu.fieldFit.zw;
   var field : vec4f;
   var aux : vec4f;
   if (hu.flags.z > 0.5) {
-    field = textureSampleLevel(fieldTexture, fieldSampler, in.uv, 0.0);
-    aux = textureSampleLevel(auxTexture, fieldSampler, in.uv, 0.0);
+    field = textureSampleLevel(fieldTexture, fieldSampler, fieldUv, 0.0);
+    aux = textureSampleLevel(auxTexture, fieldSampler, fieldUv, 0.0);
   } else {
-    let texel = vec2i(in.uv * hu.flags.xy);
+    let texel = vec2i(fieldUv * hu.flags.xy);
     field = textureLoad(fieldTexture, texel, 0);
     aux = textureLoad(auxTexture, texel, 0);
   }
@@ -1981,7 +2476,32 @@ fn fs_highlight(in : FullscreenOut) -> @location(0) vec4f {
   // whose members glow independently does not need a pass each.
   let press = radial * radial * hu.glow.w * aux.y;
 
-  let intensity = clamp(sweep + press, 0.0, 1.0) * coverage;
+  /*
+   * Backdrop tone adaptation (W7) fades this pass with the rest of the surface's
+   * own appearance. A highlight is the material catching light, and a material
+   * that has taken its backdrop's tone is not there to catch any \u2014 the settled
+   * reference's capsule over a near-black backdrop is byte-identical to that
+   * background, sweep included.
+   *
+   * The curve is the optics pass's, evaluated the same way off the same uniforms
+   * and the same per-pixel 'sizeK', because two statements of one curve is how
+   * they drift. This pass would otherwise have gone on drawing a bright crescent
+   * around a surface the optics pass had made invisible \u2014 measured at 60 pixels
+   * past 2/255, peaking at 97/255, on exactly that cell.
+   */
+  let sizeK = clamp(aux.z, 0.0, 1.0);
+  var toneAdapt = 0.0;
+  if (hu.toneAdapt.w > 0.0) {
+    let toneX = hu.toneLevel.x + hu.toneAdapt.z * sizeK;
+    let toneT = clamp(
+      (toneX - hu.toneAdapt.x) / max(hu.toneAdapt.y - hu.toneAdapt.x, 1e-6),
+      0.0,
+      1.0,
+    );
+    toneAdapt = clamp(hu.toneAdapt.w, 0.0, 1.0) * (1.0 - toneT * toneT * (3.0 - 2.0 * toneT));
+  }
+
+  let intensity = clamp(sweep + press, 0.0, 1.0) * coverage * (1.0 - toneAdapt);
   if (intensity <= 0.0) {
     return vec4f(0.0);
   }
@@ -2000,12 +2520,40 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   tint : vec4f,
   /// adapted tint colour, linear light (xyz), adaptation strength (w)
   adapt : vec4f,
+  /// author tint seed, linear light (xyz), tone adaptation under the contrast regime (w)
+  seed : vec4f,
+  /// tintToneFloor, tintToneCeilMix, tintToneLow, tintToneHigh
+  tone : vec4f,
   /// rimWidthPx, rimAlpha, specularPower, specularGain
   rim : vec4f,
   /// light direction, unit (xy), shadowDepth (z), shadowAlpha (w)
   light : vec4f,
   /// hasBackdrop, fieldSize.xy, fieldUpsampled
   flags : vec4f,
+  /// the size law's gains (W2): scatterGainMax, 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,
+  /// backdrop tone adaptation (W7): backdropToneLow, backdropToneHigh, the size
+  /// bias ALREADY divided by the accessibility refraction cap (so that it may be
+  /// multiplied by the policy-folded 'sizeK' below and still mean the geometric
+  /// thickness), and the strength the accessibility policy resolved \u2014 zero where
+  /// the host could not measure a backdrop tone, which stands the axis down
+  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
+  shadow : vec4f,
+  /// the outer shadow's size-law gain (x), read against the casting surface's own
+  /// thickness, and the field rect's height in CSS px (y) \u2014 the conversion the
+  /// shadow's shift needs when it lands outside the texture; z and w are the
+  /// padding a uniform's vec4 alignment requires
+  shadowSize : vec4f,
 };
 
 @group(0) @binding(0) var<uniform> ou : OpticsUniforms;
@@ -2024,6 +2572,80 @@ fn rim_weight(d : f32, width : f32) -> f32 {
   return t * t;
 }
 
+/// The Gaussian CDF the outer shadow's edge falls off by: 1 deep inside the
+/// shadow's silhouette, 0.5 exactly on it, 0 far outside. The tanh form of the
+/// normal CDF \u2014 WGSL has no erf, and this is within 1.8e-4 of it everywhere,
+/// which is 0.015 of one 8-bit code at the shipped occlusion. Mirrors
+/// material.ts's 'outerShadowFalloff' term for term.
+fn outer_shadow_falloff(signedDistance : f32, sigma : f32) -> f32 {
+  let x = -signedDistance / max(sigma, 1e-4);
+  return 0.5 * (1.0 + tanh(0.7978845608028654 * (x + 0.044715 * x * x * x)));
+}
+
+/// The outer shadow's alpha at this pixel (W8).
+///
+/// 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
+/// the field texture rather than extrapolating the local distance along the
+/// normal is what keeps a corner a corner: the first-order estimate is exact only
+/// on a straight edge, and a capsule is mostly not one.
+///
+/// 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;
+  }
+  /*
+   * The shift can leave the field texture, and clamping alone reads a lie there.
+   *
+   * Two ways it happens, and the second is not an edge case: the rect is clipped
+   * to the canvas, so a surface within the shadow's reach of the viewport's TOP
+   * has no rows above it to shift into; and even unclipped, the rect's pad is the
+   * shadow's reach, so the topmost band of every group needs rows a further
+   * 'offset' above that. Clamped, both repeat the edge texel \u2014 a distance that is
+   * too SMALL, which reads as a flat, too-dark falloff exactly where the shadow
+   * should be fading out, and diverges from the CSS tier, which has no texture to
+   * run out of.
+   *
+   * Reconstructed instead of clamped. A signed distance field is 1-Lipschitz, and
+   * in the region this happens in \u2014 directly above the surface \u2014 moving away from
+   * it increases the distance by exactly the displacement. So adding back the
+   * distance that was clamped off is exact there, and past the surface's corners
+   * it over-estimates, which errs toward LESS shadow rather than more.
+   */
+  let shiftedY = uv.y - ou.shadow.w;
+  let clampedOffCss =
+    (max(0.0, -shiftedY) + max(0.0, shiftedY - 1.0)) * ou.shadowSize.y;
+  let shadowUv = clamp(vec2f(uv.x, shiftedY), vec2f(0.0), vec2f(1.0));
+  var shadowField : vec4f;
+  var shadowAux : vec4f;
+  if (upsampled > 0.5) {
+    shadowField = textureSampleLevel(fieldTexture, fieldSampler, shadowUv, 0.0);
+    shadowAux = textureSampleLevel(auxTexture, fieldSampler, shadowUv, 0.0);
+  } else {
+    let texel = clamp(vec2i(shadowUv * fieldSize), vec2i(0), vec2i(fieldSize) - vec2i(1));
+    shadowField = textureLoad(fieldTexture, texel, 0);
+    shadowAux = textureLoad(auxTexture, texel, 0);
+  }
+
+  // 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.
+  //
+  // Applied on '1 - alpha' rather than on the alpha: the gain is a fraction of
+  // the remaining transparency in LINEAR light ('sizeOuterShadowOcclusionAt'),
+  // and (1 - occ) is exactly what raising to 1/2.4 turns into (1 - alpha), so the
+  // two forms are the same law and neither needs the other's space.
+  let sizeK = clamp(shadowAux.z, 0.0, 1.0);
+  let sizeFold = pow(max(1.0 - ou.shadowSize.x * sizeK, 0.0), 1.0 / 2.4);
+  let alpha = 1.0 - (1.0 - ou.shadow.x) * sizeFold;
+
+  return alpha * outer_shadow_falloff(shadowField.x + clampedOffCss - ou.shadow.z, ou.shadow.y);
+}
+
 @fragment
 fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // Nominally the field is one texel per device pixel, so the read is an exact
@@ -2045,8 +2667,19 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   let d = field.x;
   let normal = field.yz;
   let coverage = field.w;
+
+  /*
+   * The outer shadow (W8) sits UNDER the material, so it is resolved before the
+   * body and carried into the output's alpha rather than into its colour: the
+   * pass writes premultiplied black there, and premultiplied black over the page
+   * IS the multiplication. Outside the contour that is the whole of what this
+   * pixel is; inside it the surface covers the shadow, exactly as a 'box-shadow'
+   * 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);
   if (coverage <= 0.0) {
-    return vec4f(0.0);
+    return vec4f(0.0, 0.0, 0.0, shadowAlpha);
   }
 
   let viewport01 = in.position.xy / ou.screen.xy;
@@ -2054,6 +2687,10 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
 
   // Per-pixel, unioned through the field pass. See the module note.
   let lensDepth = max(aux.x, 1e-4);
+  // The size law's thickness factor for whichever surface owns this pixel, 0..1.
+  // Zero on anything at or below the profile's 'sizeSpanMin', and every term
+  // below multiplies by it \u2014 so a small control takes the pre-law path exactly.
+  let sizeK = clamp(aux.z, 0.0, 1.0);
   // '-d' is depth inside the surface, so the profile runs 1 at the contour to 0
   // at 'lensDepth' inward, and the square makes the falloff read as curvature
   // rather than as a linear ramp.
@@ -2069,36 +2706,176 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   let bodyLod = clamp(lensDepth * ou.lens.y, 0.0, ou.lens.w);
   let lod = clamp(bodyLod - ou.lens.z * profile, 0.0, ou.lens.w);
 
+  /*
+   * The scattering facet of the size law: "a softer scattering of light".
+   *
+   * The body texture is one blur for the whole backdrop source \u2014 it is built once
+   * per source per frame, so it cannot be per-surface. The chain beside it can:
+   * 'size.w' is the chain level whose blur already matches that body, so
+   * 'size.w + log2(scatterGain)' is the level whose blur is 'scatterGain' times
+   * wider, and lerping the body toward it by 'sizeK' widens the kernel with the
+   * surface. At sizeK = 0 the weight is zero and the body sample stands alone,
+   * which is what makes the whole facet inert on a small control.
+   */
+  let scatterGain = 1.0 + (ou.size.x - 1.0) * sizeK;
+  let scatterLod = clamp(ou.size.w + log2(max(scatterGain, 1e-4)), 0.0, ou.lens.w);
+
   var backdrop = vec3f(0.0);
   if (ou.flags.x > 0.5) {
     let lensSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, lod);
     let bodySample = textureSampleLevel(backdropBody, backdropSampler, straightUv, 0.0);
+    let scatterSample = textureSampleLevel(backdropChain, backdropSampler, straightUv, scatterLod);
     // Premultiplied linear in, straight colour out: the material composites over
     // whatever is behind it, so a partially transparent backdrop must not darken
     // the glass.
     let lensColour = lensSample.rgb / max(lensSample.a, 1e-6);
-    let bodyColour = bodySample.rgb / max(bodySample.a, 1e-6);
+    let scatterColour = scatterSample.rgb / max(scatterSample.a, 1e-6);
+    let bodyColour = mix(bodySample.rgb / max(bodySample.a, 1e-6), scatterColour, sizeK);
     backdrop = mix(bodyColour, lensColour, profile);
   }
 
   // Adaptive tint. 'adapt.w' is the strength the accessibility policy and the
   // group's analysis quality already agreed on; at 0 the fixed tint stands, which
   // is what a 'hint' or 'none' group gets.
-  let tintColour = mix(ou.tint.rgb, ou.adapt.rgb, ou.adapt.w);
-  var colour = mix(backdrop, tintColour, ou.tint.w);
+  let neutral = mix(ou.tint.rgb, ou.adapt.rgb, ou.adapt.w);
+
+  let backdropLuma = dot(backdrop, vec3f(0.2126, 0.7152, 0.0722));
+
+  /*
+   * Backdrop tone adaptation (W7) \u2014 step two of the composition contract, between
+   * the colour scheme's neutral and the author's tint.
+   *
+   * Read against 'toneColour': the backdrop SOURCE's own average, measured by the
+   * host from the pixels it supplied and handed to both tiers as one number. Not a
+   * per-pixel sample, and that is the load-bearing choice \u2014 see
+   * 'GroupRenderInput.backdropTone' for the cross-tier measurement that settled
+   * it, and note that the reference agrees: its capsule over a sparse bright grid
+   * is a flat body rather than a window onto the grid.
+   *
+   * 'sizeK' is still per pixel, so a container holding a small control and a large
+   * platter adapts each of them by its own thickness out of one pass.
+   *
+   * Strength is zero where the host measured no tone, and the whole axis stands
+   * down where there is no backdrop at all rather than reading the zero vector as
+   * a black backdrop and dissolving the surface into nothing.
+   *
+   * Written out instead of calling smoothstep() so that a profile patched with
+   * low >= high degrades to a step rather than to NaN.
+   */
+  var toneAdapt = 0.0;
+  if (ou.flags.x > 0.5 && ou.toneAdapt.w > 0.0) {
+    let toneX = ou.toneColour.w + ou.toneAdapt.z * sizeK;
+    let toneT = clamp(
+      (toneX - ou.toneAdapt.x) / max(ou.toneAdapt.y - ou.toneAdapt.x, 1e-6),
+      0.0,
+      1.0,
+    );
+    toneAdapt = clamp(ou.toneAdapt.w, 0.0, 1.0) * (1.0 - toneT * toneT * (3.0 - 2.0 * toneT));
+  }
+  /*
+   * Both the colour and the alpha move, together and not separately. What the
+   * adaptation means is that the INTERIOR converges on the backdrop's tone \u2014
+   * mix(interior, tone, k) \u2014 and this is the (colour, alpha) pair that composites
+   * to exactly that. Lerping the two independently makes a partially adapted
+   * surface lighter than it started (more opaque toward a tint still mostly
+   * neutral), which the 96 px cells caught at once: interior 0.4545 \u2192 0.5179
+   * against a reference of 0.4542. The alpha half is not a colour axis reaching
+   * the occlusion axis \u2014 an adapting material stops transmitting, which is what
+   * the reference's flat body over the impulse grid is. See 'adaptedTintColour'
+   * and 'adaptedTintAlpha' in material.ts.
+   */
+  let sizedAlpha = ou.tint.w + ou.size.y * sizeK * (1.0 - ou.tint.w);
+  let adaptedAlpha = sizedAlpha + toneAdapt * (1.0 - sizedAlpha);
+  var adapted = neutral;
+  if (toneAdapt > 0.0 && adaptedAlpha > 0.0) {
+    adapted =
+      (neutral * ((1.0 - toneAdapt) * sizedAlpha) + ou.toneColour.rgb * toneAdapt) / adaptedAlpha;
+  }
+
+  // The author tint. 'aux.w' is the per-pixel strength, unioned in the field pass,
+  // so a toolbar can carry one tinted control among plain ones; the seed is a
+  // group uniform. At strength 0 this is the identity and the material is the one
+  // the calibration bed measures, byte for byte.
+  //
+  // Apple's mechanism, not a fill: the seed is the middle of a range of tones
+  // 'mapped to content brightness underneath'. 'backdrop' is what this pixel is
+  // actually looking through \u2014 lens-displaced, LOD-sampled, already the thing the
+  // material transmits \u2014 so the tone is taken against the same light the tint is
+  // about to be mixed into, and a tinted surface over a dark backdrop settles to a
+  // shade of the author's colour rather than sitting on it as paint.
+  //
+  // That 'backdrop' is also where the size law's scattering has already been
+  // applied (above), and that is the right order rather than a coincidence: a
+  // large surface diffuses more of what is behind it, so the tone the tint maps
+  // to should be the diffused light, not the sharp light nobody sees through it.
+  //
+  // It displaces the ADAPTED neutral, not the raw one: a full-strength tint is its
+  // own adaptation and replaces this axis outright, while a partial one moves with
+  // it. That order is the wave's composition contract, in one line.
+  var tintColour = adapted;
+  if (aux.w > 0.0) {
+    let t = smoothstep(ou.tone.z, ou.tone.w, backdropLuma);
+    let low = ou.seed.rgb * ou.tone.x;
+    let high = ou.seed.rgb + (vec3f(1.0) - ou.seed.rgb) * ou.tone.y;
+    // 'seed.w' is the contrast regime's grip on the excursion, never on the hue:
+    // at 0 the material shows the author's colour flat and stops responding.
+    let tone = mix(ou.seed.rgb, mix(low, high, t), clamp(ou.seed.w, 0.0, 1.0));
+    tintColour = mix(adapted, tone, clamp(aux.w, 0.0, 1.0));
+  }
+
+  // The tint layer's ALPHA is untouched by the author's colour. It is the
+  // material's occlusion \u2014 what reduced transparency lifts, and the axis the
+  // system's own Clear-to-Tinted preference runs on \u2014 and an author choosing a
+  // colour does not get to move it.
+  //
+  // The size law does move it, and the two do not collide: "a larger size is more
+  // opaque, a smaller size is clearer" is a statement about how much material
+  // there is, not about what colour it is. A fraction of whatever transparency
+  // the resolved alpha still has, for the reason 'increasedOcclusionLift' is a
+  // fraction \u2014 see material.ts.
+  //
+  // The backdrop adaptation moves it, above, and the author's colour does not.
+  var colour = mix(backdrop, tintColour, adaptedAlpha);
+
+  /*
+   * Everything below is the surface's own APPEARANCE \u2014 the marks that say a
+   * surface is here rather than what is behind it \u2014 and all of it fades with the
+   * adaptation, on the one factor.
+   *
+   * That is not symmetry for its own sake; it is what the reference does, and it
+   * is a calibration cell rather than an inference: the reference's capsule over
+   * the dark-solid backdrop is byte-identical to that background, rim included. A
+   * material that has taken its backdrop's tone has no lit edge to show, because
+   * there is no light in front of it to show one with.
+   *
+   * The gap was invisible until this axis existed. A rim of up to 130/255 sat
+   * unnoticed inside a bright capsule body; with the body gone it is a white
+   * outline around a surface that should not be there at all \u2014 595 pixels past
+   * 2/255 on that one cell, and OKLab \u0394E max 0.47 where p95 already read 0.0000.
+   * The same lesson W3 recorded from the other direction: a term that happens to
+   * be hidden is one feature away from being visible.
+   */
+  let present = 1.0 - toneAdapt;
 
   // Inner shadow: the material's own occlusion, deepest where the lens is
-  // strongest, which is what makes a thicker surface read as heavier.
-  colour = colour * (1.0 - profile * ou.light.z * ou.light.w);
+  // strongest, which is what makes a thicker surface read as heavier \u2014 and the
+  // shadow facet of the size law deepens it further with the span.
+  let shadowDepth = ou.light.z * (1.0 + (ou.size.z - 1.0) * sizeK);
+  colour = colour * (1.0 - profile * shadowDepth * ou.light.w * present);
 
   // Rim and specular from the gradient. The rim is unlit ambient edge brightness;
   // the specular term is the same edge lit from 'light.xy'.
   let rw = rim_weight(d, ou.rim.x);
   let facing = dot(normal, ou.light.xy);
   let spec = pow(clamp(facing, 0.0, 1.0), max(ou.rim.z, 1e-3)) * ou.rim.w;
-  colour = colour + vec3f(rw * (ou.rim.y + spec));
+  colour = colour + vec3f(rw * (ou.rim.y + spec) * present);
 
-  return encode_output(max(colour, vec3f(0.0)), coverage);
+  // The material over its own shadow over the page, in one premultiplied vector:
+  // the colour is the surface's, weighted by its coverage, and the alpha is what
+  // the two of them together leave the page \u2014 'coverage' from the surface, and
+  // the shadow filling whatever transparency is left.
+  let body = encode_output(max(colour, vec3f(0.0)), coverage);
+  return vec4f(body.rgb, body.a + shadowAlpha * (1.0 - body.a));
 }`;
 
 // ../renderer-webgpu/dist/wgsl/prelude.js
@@ -2345,7 +3122,7 @@ function createPassRunner(context) {
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 32);
+      const slot = uniformSlot(`optics:${args.groupId}`, 60);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -2367,18 +3144,46 @@ function createPassRunner(context) {
       d[17] = args.adaptTint[1];
       d[18] = args.adaptTint[2];
       d[19] = args.adaptStrength;
-      d[20] = args.rimWidth;
-      d[21] = args.rimAlpha;
-      d[22] = args.specularPower;
-      d[23] = args.specularGain;
-      d[24] = args.lightDirection[0];
-      d[25] = args.lightDirection[1];
-      d[26] = args.shadowDepth;
-      d[27] = args.shadowAlpha;
-      d[28] = args.backdrop === void 0 ? 0 : 1;
-      d[29] = args.fields.width;
-      d[30] = args.fields.height;
-      d[31] = args.fields.upsampled ? 1 : 0;
+      d[20] = args.tintSeed[0];
+      d[21] = args.tintSeed[1];
+      d[22] = args.tintSeed[2];
+      d[23] = args.tintToneAdaptation;
+      d[24] = args.tintTone[0];
+      d[25] = args.tintTone[1];
+      d[26] = args.tintTone[2];
+      d[27] = Math.max(args.tintTone[3], args.tintTone[2] + 1e-4);
+      d[28] = args.rimWidth;
+      d[29] = args.rimAlpha;
+      d[30] = args.specularPower;
+      d[31] = args.specularGain;
+      d[32] = args.lightDirection[0];
+      d[33] = args.lightDirection[1];
+      d[34] = args.shadowDepth;
+      d[35] = args.shadowAlpha;
+      d[36] = args.backdrop === void 0 ? 0 : 1;
+      d[37] = args.fields.width;
+      d[38] = args.fields.height;
+      d[39] = args.fields.upsampled ? 1 : 0;
+      d[40] = args.sizeScatterGainMax;
+      d[41] = args.sizeOcclusionGain;
+      d[42] = args.sizeShadowGainMax;
+      d[43] = args.bodyChainLod;
+      d[44] = args.backdropTone[0];
+      d[45] = Math.max(args.backdropTone[1], args.backdropTone[0] + 1e-4);
+      d[46] = args.backdropTone[2];
+      d[47] = args.backdropTone[3];
+      d[48] = args.backdropToneColour[0];
+      d[49] = args.backdropToneColour[1];
+      d[50] = args.backdropToneColour[2];
+      d[51] = args.backdropToneColour[3];
+      d[52] = args.outerShadow[0];
+      d[53] = args.outerShadow[1];
+      d[54] = args.outerShadow[2];
+      d[55] = args.outerShadow[3];
+      d[56] = args.outerShadowSizeGain;
+      d[57] = args.outerShadowRectCssHeight;
+      d[58] = 0;
+      d[59] = 0;
       slot.write();
       const chain = args.backdrop?.chain ?? placeholderView;
       const body = args.backdrop?.body ?? placeholderView;
@@ -2408,7 +3213,7 @@ function createPassRunner(context) {
       pass.end();
     },
     highlightPass(encoder, args) {
-      const slot = uniformSlot(`highlight:${args.groupId}`, 20);
+      const slot = uniformSlot(`highlight:${args.groupId}`, 32);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -2430,6 +3235,19 @@ function createPassRunner(context) {
       d[17] = args.fields.height;
       d[18] = args.fields.upsampled ? 1 : 0;
       d[19] = 0;
+      d[20] = args.backdropTone[0];
+      d[21] = Math.max(args.backdropTone[1], args.backdropTone[0] + 1e-4);
+      d[22] = args.backdropTone[2];
+      d[23] = args.backdropTone[3];
+      d[24] = args.backdropToneLevel;
+      d[25] = 0;
+      d[26] = 0;
+      d[27] = 0;
+      const fieldRect = args.fieldRectDevice;
+      d[28] = args.rectDevice.width / Math.max(fieldRect.width, 1e-6);
+      d[29] = args.rectDevice.height / Math.max(fieldRect.height, 1e-6);
+      d[30] = (args.rectDevice.x - fieldRect.x) / Math.max(fieldRect.width, 1e-6);
+      d[31] = (args.rectDevice.y - fieldRect.y) / Math.max(fieldRect.height, 1e-6);
       slot.write();
       const pipeline = highlightPipeline(args.targetFormat);
       const pass = encoder.beginRenderPass({
@@ -2540,6 +3358,13 @@ function planPyramid(sourceWidth, sourceHeight, policy) {
   };
 }
 var CHAIN_SIGMA_AT_LEVEL_1 = 1.2;
+function chainLodForSigma(sigmaTexels) {
+  if (!(sigmaTexels > 0))
+    return 0;
+  if (sigmaTexels <= CHAIN_SIGMA_AT_LEVEL_1)
+    return sigmaTexels / CHAIN_SIGMA_AT_LEVEL_1;
+  return 1 + Math.log2(sigmaTexels / CHAIN_SIGMA_AT_LEVEL_1);
+}
 function bodyBlurPlan(sigmaPx, plan) {
   if (sigmaPx <= 0)
     return { level: 0, residualSigmaTexels: 0 };
@@ -2683,7 +3508,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) {
+  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch, bodySigmaTexels) {
     const existing = resources.get(sourceId);
     const bodyWidth = (plan.levels[bodyLevel] ?? plan.levels[0]).width;
     const bodyHeight = (plan.levels[bodyLevel] ?? plan.levels[0]).height;
@@ -2720,7 +3545,8 @@ function createPyramidStore(context) {
       body,
       stats,
       sizeEpoch,
-      builtEpoch
+      builtEpoch,
+      bodySigmaTexels
     };
     resources.set(sourceId, next);
     return next;
@@ -2929,8 +3755,9 @@ function createPyramidStore(context) {
       const [viewportW, viewportH] = request.viewportCss;
       const cover = viewportW > 0 && viewportH > 0 ? Math.max(frame.width / viewportW, frame.height / viewportH) : 1;
       const planScale = frame.width > 0 ? plan.width / frame.width : 1;
-      const bodyPlan = bodyBlurPlan(request.bodySigmaCss * cover * planScale, plan);
-      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch);
+      const bodySigmaTexels = request.bodySigmaCss * cover * planScale;
+      const bodyPlan = bodyBlurPlan(bodySigmaTexels, plan);
+      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels);
       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);
@@ -3046,15 +3873,6 @@ var RENDERER_PASS_IDS = [
   OPTICS_PASS_ID,
   HIGHLIGHT_PASS_ID
 ];
-var NOMINAL_MATERIAL_POLICY = {
-  glass: "material",
-  frost: "nominal",
-  refraction: "nominal",
-  occlusion: "nominal",
-  border: "nominal",
-  ambientTint: "nominal",
-  foreground: "adaptive"
-};
 function createWebGPURenderer(options = {}) {
   const providers = /* @__PURE__ */ new Map();
   const groups = /* @__PURE__ */ new Map();
@@ -3157,6 +3975,7 @@ function createWebGPURenderer(options = {}) {
   };
   const unionOf = (input) => input.union ?? DEFAULT_GROUP_UNION;
   const variantOf = (input) => input.variant ?? "regular";
+  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);
     if (resolved === void 0) {
@@ -3246,9 +4065,10 @@ function createWebGPURenderer(options = {}) {
       const input = entry.input;
       if (input.surfaces.length === 0)
         continue;
+      const policy = resolution?.accessibility.material ?? accessibility;
       let surfaces;
       try {
-        surfaces = resolveSurfaces(input, governor.knobs.fieldFamily, material);
+        surfaces = resolveSurfaces(input, governor.knobs.fieldFamily, material, policy);
       } catch (error) {
         skipped.push({
           groupId: input.groupId,
@@ -3257,10 +4077,17 @@ function createWebGPURenderer(options = {}) {
         continue;
       }
       const union = unionOf(input);
-      const snapped = snapRectToDevicePixels(groupFieldRect(surfaces, union), dpr);
+      const shadow = outerShadowUnderPolicy(policy, material);
+      let reachOcclusion = shadow.occlusion;
+      for (const surface of surfaces) {
+        reachOcclusion = Math.max(reachOcclusion, sizeOuterShadowOcclusionAt(shadow.occlusion, surface.sizeThickness, material));
+      }
+      const shadowReachPx = outerShadowReachPx({ ...shadow, occlusion: reachOcclusion });
+      const snapped = snapRectToDevicePixels(groupFieldRect(surfaces, union, void 0, shadowReachPx), dpr);
       const rectDevice = clipFieldRectToCanvas(snapped, dpr, viewportDevice);
       if (rectDevice === void 0)
         continue;
+      const surfaceRectDevice = shadowReachPx === 0 ? rectDevice : clipFieldRectToCanvas(snapRectToDevicePixels(groupFieldRect(surfaces, union), dpr), dpr, viewportDevice) ?? rectDevice;
       const packed = packInstances(surfaces, [
         rectDevice.x * cssPerDevice,
         rectDevice.y * cssPerDevice
@@ -3279,9 +4106,15 @@ function createWebGPURenderer(options = {}) {
         union
       });
       const state = stateOf(input, resolution);
-      const policy = resolution?.accessibility.material ?? accessibility;
       const variant = variantOf(input);
       const optics = opticsUnderPolicy(material.optics[variant], policy, material);
+      const backdropTone = [
+        material.backdropToneLow,
+        material.backdropToneHigh,
+        backdropToneSizeBiasUnderPolicy(policy, material),
+        input.backdropTone === void 0 ? 0 : backdropToneUnderPolicy(policy, material) * material.backdropToneMax
+      ];
+      const backdropToneLevel = input.backdropTone === void 0 ? 0 : relativeLuminance(input.backdropTone);
       const refraction = effectiveRefraction(accessibilityRefractionCap(policy), state.refraction);
       const refractionScale = material.refractionScale[refraction];
       const sourceId = input.backdropSourceId;
@@ -3305,6 +4138,26 @@ function createWebGPURenderer(options = {}) {
         tintAlpha: optics.tintAlpha,
         adaptTint: adapt?.tint ?? optics.tint,
         adaptStrength: adapt?.observed === true ? adaptationStrength(policy, state.analysisExact, material) : 0,
+        /*
+         * `glass: "none"` is forced colours, and it takes the author's tint with
+         * the rest of the material.
+         *
+         * The pass keeps running — it is what paints the surface at all on this
+         * tier — but with no backdrop and an opaque occlusion, so whatever colour
+         * sits here IS the surface. An author tint arriving into that lands as a
+         * flat fill of the author's colour where the platform's palette is
+         * required, which is the one composition forced colours exists to
+         * prevent. Falling back to the material's own tint reproduces exactly
+         * what an untinted surface draws.
+         */
+        tintSeed: (policy.glass === "none" ? void 0 : groupTintSeed(input)) ?? optics.tint,
+        tintToneAdaptation: tintToneAdaptation(policy, material),
+        tintTone: [
+          material.tintToneFloor,
+          material.tintToneCeilMix,
+          material.tintToneLow,
+          material.tintToneHigh
+        ],
         rimWidth: optics.rimWidth,
         rimAlpha: optics.rimAlpha,
         specularPower: optics.specularPower,
@@ -3312,6 +4165,33 @@ function createWebGPURenderer(options = {}) {
         lightDirection: material.lightDirection,
         shadowDepth: optics.shadowDepth,
         shadowAlpha: optics.shadowAlpha,
+        // The size law's gains, per group (W2); the per-pixel factor they
+        // multiply rides the field pass's aux channel, so one uniform serves a
+        // 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,
+        sizeOcclusionGain: material.sizeOcclusionGain,
+        sizeShadowGainMax: material.sizeShadowGainMax,
+        bodyChainLod: chainLodForSigma(pyramid?.bodySigmaTexels ?? 0),
+        backdropTone,
+        backdropToneColour: [
+          input.backdropTone?.[0] ?? 0,
+          input.backdropTone?.[1] ?? 0,
+          input.backdropTone?.[2] ?? 0,
+          backdropToneLevel
+        ],
+        outerShadow: [
+          outerShadowAlpha(shadow.occlusion),
+          shadow.sigmaPx,
+          shadow.spreadPx,
+          // The offset in field-texture UV. The field spans exactly this rect, so
+          // one CSS px is one over the rect's CSS height however the governor
+          // scaled the rasterisation.
+          shadow.offsetPx / Math.max(rectDevice.height * cssPerDevice, 1e-6)
+        ],
+        outerShadowSizeGain: shadow.sizeGain,
+        outerShadowRectCssHeight: rectDevice.height * cssPerDevice,
         backdrop: pyramid === void 0 || policy.glass === "none" ? void 0 : {
           chain: pyramid.chain.createView(),
           body: pyramid.body.createView()
@@ -3323,7 +4203,9 @@ function createWebGPURenderer(options = {}) {
           groupId: input.groupId,
           target: active.highlight,
           targetFormat: active.format,
-          rectDevice,
+          // The surface's own rect, not the shadow's — see `surfaceRectDevice`.
+          rectDevice: surfaceRectDevice,
+          fieldRectDevice: rectDevice,
           fields,
           viewportDevice,
           cssPerDevice,
@@ -3335,7 +4217,11 @@ function createWebGPURenderer(options = {}) {
           pressPointCss: lead.channels.pressPoint ?? lead.centre,
           glowRadiusCss: material.glowRadiusCss,
           glowGain: material.glowGain,
-          colour: optics.highlight
+          colour: optics.highlight,
+          // The same four numbers the optics pass took, so the two passes fade
+          // the surface on one curve rather than on two copies of it.
+          backdropTone,
+          backdropToneLevel
         });
       }
       drawn += 1;
@@ -3568,6 +4454,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, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_BODY_LOD_PER_PX, LENS_RIM_LOD_BIAS, LENS_SIZE_GAIN_MAX, LENS_SPAN_MAX, LENS_SPAN_MIN, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, 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, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, bodyBlurPlan, bodyLod, chainModule, clipFieldRectToCanvas, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, highlightModule, importColorMatrix, importModule, importPassSource, lensDepthPx, lensSizeGain, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, packInstances, pipelineKey, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, validateAppTexture, withMaterialOverrides };
-//# sourceMappingURL=dist-FGJI5LQM.js.map
-//# sourceMappingURL=dist-FGJI5LQM.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, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_BODY_LOD_PER_PX, LENS_RIM_LOD_BIAS, LENS_SIZE_GAIN_MAX, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTER_SHADOW, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SIZE_OCCLUSION_GAIN, SIZE_SCATTER_GAIN_MAX, SIZE_SHADOW_GAIN_MAX, SIZE_SPAN_MAX, SIZE_SPAN_MIN, SRGB_ENCODING_EXPONENT, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptedTintAlpha, adaptedTintColour, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, backdropToneAdaptation, backdropToneSizeBiasUnderPolicy, backdropToneUnderPolicy, bodyBlurPlan, bodyLod, chainModule, clipFieldRectToCanvas, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, highlightModule, importColorMatrix, importModule, importPassSource, lensDepthPx, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowReachPx, outerShadowUnderPolicy, packInstances, pipelineKey, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, tintTone, tintToneAdaptation, tintedTintColour, validateAppTexture, withMaterialOverrides };
+//# sourceMappingURL=dist-RQ4ZMA3D.js.map
+//# sourceMappingURL=dist-RQ4ZMA3D.js.map