@vitreajs/vitrea 0.1.1 → 0.3.0

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

@@ -17,6 +17,7 @@ var WGSL_ANALYSIS_PASS = `struct AnalysisUniforms {
 @group(0) @binding(3) var<storage, read_write> stats : array<f32>;
 
 var<workgroup> partialLum  : array<f32, ${ANALYSIS_WORKGROUP}>;
+var<workgroup> partialTone : array<f32, ${ANALYSIS_WORKGROUP}>;
 var<workgroup> partialSq   : array<f32, ${ANALYSIS_WORKGROUP}>;
 var<workgroup> partialEdge : array<f32, ${ANALYSIS_WORKGROUP}>;
 
@@ -32,6 +33,7 @@ fn lum_at(uv : vec2f) -> f32 {
 fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   let total = u32(au.grid.x * au.grid.y);
   var sumLum = 0.0;
+  var sumTone = 0.0;
   var sumSq = 0.0;
   var sumEdge = 0.0;
   var n = 0.0;
@@ -47,7 +49,15 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
     let dx = lum_at(uv + vec2f(au.texel.x, 0.0)) - lum_at(uv - vec2f(au.texel.x, 0.0));
     let dy = lum_at(uv + vec2f(0.0, au.texel.y)) - lum_at(uv - vec2f(0.0, au.texel.y));
 
+    // The published luminance accumulates ENCODED \u2014 the W9 model (claims
+    // 5.31): the reference's tone responses track the encoded-space mean of a
+    // structured backdrop, not its linear mean. The host decodes the mean once
+    // on readback, so every consumer downstream still speaks linear light.
+    // The linear sum stays, because the variance fold below needs a mean in
+    // the same space as its squares; variance and edge density stay linear \u2014
+    // nothing tonal reads them.
     sumLum = sumLum + c;
+    sumTone = sumTone + linear_to_srgb(vec3f(c, c, c)).x;
     sumSq = sumSq + c * c;
     sumEdge = sumEdge + length(vec2f(dx, dy)) * 0.5;
     n = n + 1.0;
@@ -56,6 +66,7 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   }
 
   partialLum[lane] = sumLum;
+  partialTone[lane] = sumTone;
   partialSq[lane] = sumSq;
   partialEdge[lane] = sumEdge;
   workgroupBarrier();
@@ -66,6 +77,7 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
     if (stride == 0u) { break; }
     if (lane < stride) {
       partialLum[lane] = partialLum[lane] + partialLum[lane + stride];
+      partialTone[lane] = partialTone[lane] + partialTone[lane + stride];
       partialSq[lane] = partialSq[lane] + partialSq[lane + stride];
       partialEdge[lane] = partialEdge[lane] + partialEdge[lane + stride];
     }
@@ -76,13 +88,38 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   if (lane == 0u) {
     let count = max(f32(total), 1.0);
     let mean = partialLum[0] / count;
-    stats[0] = mean;
+    // stats[0] is the ENCODED-space mean; the host decodes it once (W9).
+    stats[0] = partialTone[0] / count;
     stats[1] = max(partialSq[0] / count - mean * mean, 0.0);
     stats[2] = partialEdge[0] / count;
     stats[3] = count;
   }
 }`;
 
+// ../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 +198,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 +226,53 @@ 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.
+       */
+      // 1.25 since W11c G1 (claims §5.41): the reference's interior over
+      // structured content is a sharp component near σ 1.25 plus a heavy one
+      // the scatter facet now supplies (`sizeScatterFloor`); the cascade's 3
+      // (claims §5.16) was the one Gaussian that best split the difference on
+      // a bed with no pitch axis to tell the two apart.
+      blurSigma: 1.25,
       tint: srgbToLinear(SRGB_WHITE_TINT),
-      // 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 +318,311 @@ 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,
-  lensBodyLodPerPx: 0.16,
-  lensRimLodBias: 2.5,
+  /*
+   * 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.
+   */
+  // MEASURED (W11c G1, claims §5.41): the scatter facet off the identity, on
+  // its own curve — see `MaterialProfile.sizeScatterFloor`. The paragraph
+  // above records why the identity was the right answer while `blurSigma`
+  // was 3 and the bed had no pitch axis; the W9 probe's pitch axis is what
+  // identified the two-component interior this expresses.
+  sizeScatterGainMax: 8,
+  sizeScatterFloor: 0.4,
+  sizeScatterSpanMax: 256,
+  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,
   reducedTransparencyFrost: 1.75,
   increasedOcclusionLift: INCREASED_OCCLUSION_LIFT,
   strongBorderRim: { rimWidth: 2, rimAlpha: 0.95 },
   reducedTintAdaptation: 0.35,
+  /*
+   * MEASURED (W10, 2026-09-02) — per-pixel least squares of the reference's
+   * tinted pixel against its own untinted pixel on the five W9-probe tinted
+   * checkerboard cells (pitch 4…64 px, 17 700 px): shade = 0.5289 + 0.4886·u,
+   * RMS 0.0035. Out of sample on the canonical bed the orange cells fit at
+   * RMS 0.003 with zero bias; blue sits 0.011 darker (the second hue's
+   * residual, recorded and unmodelled). The light end extrapolates past 1 and
+   * is clamped in `tintShade`. Claims §5.36.
+   *
+   * §5.13's earlier "the curve is the identity" fit was made on the material's
+   * MEAN over solid backdrops, where u is either ~0.97 (shade 1.0) or the
+   * collapse has already folded the shade out — the identity was the law's
+   * two endpoints, seen without anything between them.
+   */
+  tintShadeDark: 0.5289,
+  tintShadeLight: 1.0175,
+  tintShadeStrength: 1,
+  /*
+   * MEASURED (W7), against the settled apple-macos-26.5 bed, on the light and
+   * dark standard profiles jointly and at both scales.
+   *
+   * 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.
+   */
+  /*
+   * RE-SCOPED (W9, claims §5.33). The four mix constants now own TEXTURE
+   * COLLAPSE alone — the interior mean moved to the response law below — and
+   * their band contracts to the one domain the collapse is real in: full at
+   * `dark-solid` (0.0117) for thin surfaces including the 44 px capsule
+   * (byte-identical collapse, arg 0.0164 ≤ low with margin), zero by
+   * `mid-dark-solid` (0.0595), where the reference's small surface keeps a
+   * textured body at 0.4561 and the old band's partial collapse (k = 0.81)
+   * was the measured 0.1375-vs-0.4561 overshoot. `impulse__rrect-md`
+   * (arg 0.0539) keeps k ≈ 0.003 against the old band's 0.008 — the same
+   * unadapted render that cell validated.
+   */
+  backdropToneMax: 1,
+  backdropToneLow: 0.02,
+  backdropToneHigh: 0.055,
+  /*
+   * REFITTED 0.09 → 0.13 (2026-08-31, active bed). The law's SHAPE is untouched
+   * (Decision Log 13 stands; the two-axis rework is next wave) and `max`, `low`
+   * 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.
+   *
+   * RE-SCOPED 0.13 → 0.05 with the band above (W9): the bias's one remaining
+   * job is keeping the thick surface's collapse argument above `high` at the
+   * dark anchor (0.0117 + 0.05 = 0.0617 > 0.055) while the thin capsule's
+   * stays below `low` — the near-binary size snap the probe measured
+   * (claims §5.33). The smooth size trend on structured backdrops, which the
+   * old wide band tried and failed to carry, belongs to the response law's
+   * thickness axis now.
+   */
+  backdropToneSizeBias: 0.05,
+  /*
+   * MEASURED (W9 probe, claims §5.30–§5.33): the anchors are the probe bed's
+   * settled reference levels, frequency-settled over seven attested runs,
+   * under the probe's own native-mask interior. Thick rows pool the 96 px
+   * and 160 px rrects (±0.012). Not tuned; re-measured only by a new probe.
+   */
+  backdropToneAnchorX: [0.1104, 0.2706, 0.9505],
+  backdropToneResponseThin: [0.0126, 0.4561, 0.9713],
+  backdropToneResponseThick: [0.4953, 0.5744, 0.9358],
+  backdropToneResponseStrength: 1,
+  /*
+   * FITTED (recalibration cascade, 2026-08-31). W8's geometry SURVIVES the fit
+   * unchanged — `sigmaPx` 15.55, `offsetPx` 7.95, `spreadPx` 3.10 — and only the
+   * 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 +635,24 @@ 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 LENS_BODY_LOD_PER_PX = DEFAULT_MATERIAL_PROFILE.lensBodyLodPerPx;
-var LENS_RIM_LOD_BIAS = DEFAULT_MATERIAL_PROFILE.lensRimLodBias;
+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_OCCLUSION_GAIN = DEFAULT_MATERIAL_PROFILE.sizeOcclusionGain;
+var SIZE_SHADOW_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.sizeShadowGainMax;
+var LENS_REFRACTION_GAIN = DEFAULT_MATERIAL_PROFILE.lensRefractionGain;
+var BACKDROP_TONE_MAX = DEFAULT_MATERIAL_PROFILE.backdropToneMax;
+var BACKDROP_TONE_LOW = DEFAULT_MATERIAL_PROFILE.backdropToneLow;
+var BACKDROP_TONE_HIGH = DEFAULT_MATERIAL_PROFILE.backdropToneHigh;
+var BACKDROP_TONE_SIZE_BIAS = DEFAULT_MATERIAL_PROFILE.backdropToneSizeBias;
+DEFAULT_MATERIAL_PROFILE.backdropToneAnchorX;
+DEFAULT_MATERIAL_PROFILE.backdropToneResponseThin;
+DEFAULT_MATERIAL_PROFILE.backdropToneResponseThick;
+DEFAULT_MATERIAL_PROFILE.backdropToneResponseStrength;
+var OUTER_SHADOW = DEFAULT_MATERIAL_PROFILE.outerShadow;
 function withMaterialOverrides(base, patch) {
   const optics = {};
   for (const variant of MATERIAL_VARIANTS) {
@@ -307,15 +669,31 @@ 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,
-    lensBodyLodPerPx: patch.lensBodyLodPerPx ?? base.lensBodyLodPerPx,
-    lensRimLodBias: patch.lensRimLodBias ?? base.lensRimLodBias,
+    sizeScatterGainMax: patch.sizeScatterGainMax ?? base.sizeScatterGainMax,
+    sizeScatterFloor: patch.sizeScatterFloor ?? base.sizeScatterFloor,
+    sizeScatterSpanMax: patch.sizeScatterSpanMax ?? base.sizeScatterSpanMax,
+    sizeOcclusionGain: patch.sizeOcclusionGain ?? base.sizeOcclusionGain,
+    sizeShadowGainMax: patch.sizeShadowGainMax ?? base.sizeShadowGainMax,
+    lensRefractionGain: patch.lensRefractionGain ?? base.lensRefractionGain,
     reducedTransparencyFrost: patch.reducedTransparencyFrost ?? base.reducedTransparencyFrost,
     increasedOcclusionLift: patch.increasedOcclusionLift ?? base.increasedOcclusionLift,
     strongBorderRim: { ...base.strongBorderRim, ...patch.strongBorderRim },
     reducedTintAdaptation: patch.reducedTintAdaptation ?? base.reducedTintAdaptation,
+    tintShadeDark: patch.tintShadeDark ?? base.tintShadeDark,
+    tintShadeLight: patch.tintShadeLight ?? base.tintShadeLight,
+    tintShadeStrength: patch.tintShadeStrength ?? base.tintShadeStrength,
+    backdropToneMax: patch.backdropToneMax ?? base.backdropToneMax,
+    backdropToneLow: patch.backdropToneLow ?? base.backdropToneLow,
+    backdropToneHigh: patch.backdropToneHigh ?? base.backdropToneHigh,
+    backdropToneSizeBias: patch.backdropToneSizeBias ?? base.backdropToneSizeBias,
+    backdropToneAnchorX: patch.backdropToneAnchorX ?? base.backdropToneAnchorX,
+    backdropToneResponseThin: patch.backdropToneResponseThin ?? base.backdropToneResponseThin,
+    backdropToneResponseThick: patch.backdropToneResponseThick ?? base.backdropToneResponseThick,
+    backdropToneResponseStrength: patch.backdropToneResponseStrength ?? base.backdropToneResponseStrength,
+    outerShadow: { ...base.outerShadow, ...patch.outerShadow },
     lightDirection: patch.lightDirection ?? base.lightDirection,
     sweepBandRadians: patch.sweepBandRadians ?? base.sweepBandRadians,
     glowRadiusCss: patch.glowRadiusCss ?? base.glowRadiusCss,
@@ -350,21 +728,162 @@ 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 tintShade(materialLuminance, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  const u = Math.min(1, Math.max(0, materialLuminance));
+  const shade = Math.min(1, Math.max(0, profile.tintShadeDark + (profile.tintShadeLight - profile.tintShadeDark) * u));
+  const k = Math.min(1, Math.max(0, grip));
+  return 1 + (shade - 1) * k;
+}
+function tintShadeLayer(seed, materialLuminance, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  const shade = tintShade(materialLuminance, grip, profile);
+  return [seed[0] * shade, seed[1] * shade, seed[2] * shade];
+}
+function tintedMaterialColour(material, tint, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  if (tint === void 0 || tint.strength <= 0)
+    return material;
+  const s = Math.min(1, Math.max(0, tint.strength));
+  const layer = tintShadeLayer(tint.color, relativeLuminance(material), grip, profile);
+  const clamp01 = (value) => Math.min(1, Math.max(0, value));
+  const channel = (index) => {
+    const from = linearToSrgbChannel(clamp01(material[index]));
+    const to = linearToSrgbChannel(clamp01(layer[index]));
+    return srgbToLinearChannel(from + (to - from) * s);
+  };
+  return [channel(0), channel(1), channel(2)];
+}
+function 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, scatterThickness(spanPx, 1, profile), profile);
+}
+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 sizeScatterSigmaAt(sigmaPx, scatter, profile = DEFAULT_MATERIAL_PROFILE) {
+  return sigmaPx * (1 + (profile.sizeScatterGainMax - 1) * scatter);
+}
+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);
   return Math.min(Math.max(thicknessPx, 0) * gain, spanPx * 0.5);
 }
-function bodyLod(lensDepth, maxLod, profile = DEFAULT_MATERIAL_PROFILE) {
-  return Math.min(Math.max(lensDepth * profile.lensBodyLodPerPx, 0), maxLod);
+function lensDisplacementPx(depthPx, lensDepthPx2, refractionScale, profile = DEFAULT_MATERIAL_PROFILE) {
+  if (lensDepthPx2 <= 0)
+    return 0;
+  const depth = Math.min(Math.max(depthPx / lensDepthPx2, 0), 1);
+  return lensDepthPx2 * (1 - depth) * (1 - depth) * refractionScale * profile.lensRefractionGain;
 }
 
 // ../renderer-webgpu/dist/analysis.js
@@ -376,7 +895,11 @@ var ZERO_STATS = {
 };
 function statsFromBuffer(values) {
   return {
-    luminance: values[0] ?? 0,
+    // The reduction publishes the ENCODED-space mean (the W9 model, claims
+    // §5.31) and this is its one decode: every consumer downstream — the
+    // drivers, `adaptiveTint`'s fitted thresholds — still speaks linear light,
+    // and a solid backdrop reads identically under either convention.
+    luminance: srgbToLinearChannel(values[0] ?? 0),
     variance: values[1] ?? 0,
     edgeDensity: values[2] ?? 0,
     sampleCount: values[3] ?? 0
@@ -850,6 +1373,44 @@ function createAppTextureProvider(options) {
   };
 }
 
+// ../renderer-webgpu/dist/backdrop-fit.js
+var IDENTITY_FIT = [1, 1, 0, 0];
+function isUsablePlacement(placement) {
+  return placement !== void 0 && Number.isFinite(placement.x) && Number.isFinite(placement.y) && placement.width > 0 && placement.height > 0;
+}
+function coverFit(sourceWidth, sourceHeight, viewportWidthCss, viewportHeightCss) {
+  const viewportAspect = viewportHeightCss > 0 ? viewportWidthCss / viewportHeightCss : 1;
+  const sourceAspect = sourceHeight > 0 ? sourceWidth / sourceHeight : 1;
+  if (sourceAspect > viewportAspect) {
+    const scaleX = viewportAspect / sourceAspect;
+    return [scaleX, 1, (1 - scaleX) / 2, 0];
+  }
+  const scaleY = sourceAspect / viewportAspect;
+  return [1, scaleY, 0, (1 - scaleY) / 2];
+}
+function placementFit(placement, viewportWidthCss, viewportHeightCss) {
+  return [
+    viewportWidthCss / placement.width,
+    viewportHeightCss / placement.height,
+    -placement.x / placement.width,
+    -placement.y / placement.height
+  ];
+}
+function backdropFit(sourceWidth, sourceHeight, placement, viewportWidthCss, viewportHeightCss) {
+  return isUsablePlacement(placement) ? placementFit(placement, viewportWidthCss, viewportHeightCss) : coverFit(sourceWidth, sourceHeight, viewportWidthCss, viewportHeightCss);
+}
+function texelsPerCssPx(sourceWidth, sourceHeight, placement, viewportWidthCss, viewportHeightCss) {
+  if (isUsablePlacement(placement)) {
+    return sourceWidth > 0 ? sourceWidth / placement.width : 1;
+  }
+  return viewportWidthCss > 0 && viewportHeightCss > 0 ? Math.max(sourceWidth / viewportWidthCss, sourceHeight / viewportHeightCss) : 1;
+}
+function samePlacement(a, b) {
+  if (a === void 0 || b === void 0)
+    return a === b;
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+
 // ../renderer-webgpu/dist/device.js
 function createDeviceHost(options = {}) {
   let status = {
@@ -1252,7 +1813,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 +1825,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 +1869,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 +1878,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 +1899,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 +1944,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.spanPx;
+    data[o + 17] = 0;
   }
   return { data, count: surfaces.length };
 }
@@ -1656,7 +2222,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
+  span   : f32,     // 64  the surface's shorter extent, CSS px \u2014 the size law's input, both curves (W11c)
+  _pad   : f32,     // 68  stride padding: vec2f aligns the struct to 8, so 72 is the next legal size
 };`;
 var WGSL_FIELD_SAMPLE = `struct FieldSample {
   d : f32,
@@ -1821,7 +2389,40 @@ 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, spanPx, 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:
+//
+//   'spanPx'       \u2014 the size law's input (W2): the surface's shorter extent in
+//                    CSS px. A 40 px button and a 320 px platter in one container
+//                    lens, scatter, occlude and shadow by their own size. Until
+//                    W11c this slot carried the folded thickness factor itself;
+//                    the scatter facet now rides a curve with a different band
+//                    top, so the span travels and each consumer evaluates its own
+//                    curve from it with the bands and the fold as uniforms.
+//   'tintStrength' \u2014 the author tint's strength (W3). One emphasised control
+//                    among plain ones is the composition Apple's guidance
+//                    describes; the seed itself is a group uniform.
+//
+// They compose rather than compete: the size law moves what the material does to
+// the backdrop, the tint moves what colour it does it in.
+//
+// One consequence of carrying the span rather than the thickness, stated so it
+// is not mistaken for a drift: the union below blends 'aux' linearly between two
+// members, so a pixel in the neck between a button and a platter now blends
+// their SPANS and evaluates the curves on the blend, where it used to blend the
+// evaluated thicknesses. Inside either member the two are identical; only the
+// smooth-min neck differs, and nothing measured claims a value there.
 
 @group(0) @binding(0) var<uniform> fu : FieldUniforms;
 @group(0) @binding(1) var<storage, read> instances : array<Instance>;
@@ -1842,7 +2443,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.span, s.tintK);
   return m;
 }
 
@@ -1925,6 +2526,24 @@ 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), and the size law's band
+  /// and fold \u2014 sizeSpanMin (y), sizeSpanMax (z), the accessibility fold (w) \u2014
+  /// so this pass evaluates the thickness curve off the per-pixel span exactly
+  /// as the optics pass does (W11c: the span rides the field, not the factor)
+  toneLevel : vec4f,
+  /// this pass's uv into the FIELD texture's uv: scale (xy), offset (zw).
+  ///
+  /// 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 +2565,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 +2601,39 @@ 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.
+   */
+  // The thickness curve off the per-pixel span, written out as the optics pass
+  // writes it, so the two passes fade on one curve and not on two copies.
+  let spanT = clamp(
+    (aux.z - hu.toneLevel.y) / max(hu.toneLevel.z - hu.toneLevel.y, 1e-6),
+    0.0,
+    1.0,
+  );
+  let sizeK = clamp(spanT * spanT * (3.0 - 2.0 * spanT) * hu.toneLevel.w, 0.0, 1.0);
+  var toneAdapt = 0.0;
+  if (hu.toneAdapt.w > 0.0) {
+    let toneX = hu.toneLevel.x + hu.toneAdapt.z * sizeK;
+    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);
   }
@@ -1994,18 +2646,63 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   screen : vec4f,
   /// backdrop uv transform on viewport-normalised coords: scale (xy), offset (zw)
   fit : vec4f,
-  /// refractionScale, bodyLodPerPx, rimLodBias, chainMaxLod
+  /// refractionScale, lensRefractionGain (W11c G2), unused, chainMaxLod
   lens : vec4f,
   /// fixed tint colour, linear light (xyz), tint alpha (w)
   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,
+  /// the author tint's shade law (W10): tintShadeDark, tintShadeLight,
+  /// tintShadeStrength (the profile's provenance gate); and (w) the size law's
+  /// accessibility fold \u2014 the refraction ladder read at the preference's cap,
+  /// which every facet's span-dependent rise is multiplied by (W11c)
+  tone : vec4f,
   /// rimWidthPx, rimAlpha, specularPower, specularGain
   rim : vec4f,
   /// 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; zw are the padding
+  /// a uniform's vec4 alignment requires
+  shadowSize : vec4f,
+  /// the backdrop tone response's anchors (W9): the three solid anchors'
+  /// ENCODED-space means (xyz), and the backdrop's linear-space mean (w) \u2014 the
+  /// quantity the response solve composites against
+  toneAnchor : vec4f,
+  /// the response law's thin row: the reference's settled interior levels at the
+  /// three anchors for a surface of sizeThickness 0 (xyz); w is the law's
+  /// per-profile authority \u2014 0 on dark profiles, whose response is unmeasured
+  toneRowThin : vec4f,
+  /// the thick row (sizeThickness saturated), same layout
+  toneRowThick : vec4f,
+  /// the size law's bands (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
+  scatter : vec4f,
 };
 
 @group(0) @binding(0) var<uniform> ou : OpticsUniforms;
@@ -2016,6 +2713,42 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
 @group(0) @binding(5) var backdropBody : texture_2d<f32>;
 @group(0) @binding(6) var fieldSampler : sampler;
 
+/// One encoded sRGB channel from a linear one \u2014 the space the backdrop tone
+/// response's anchors live in (W9). Mirrors material.ts's 'linearToSrgbChannel'.
+fn srgb_encode(c : f32) -> f32 {
+  let x = clamp(c, 0.0, 1.0);
+  return select(1.055 * pow(x, 1.0 / 2.4) - 0.055, x * 12.92, x <= 0.0031308);
+}
+
+/// The backdrop tone response R(encodedInput, sizeK) (W9): monotone
+/// (Fritsch\u2013Carlson) interpolation through the three anchors, clamped to their
+/// span; smoothstep between the thin and thick rows. Mirrors material.ts's
+/// 'backdropToneResponse' term for term \u2014 the constants are authored there.
+fn tone_response(x : f32, sizeK : f32) -> f32 {
+  let f = sizeK * sizeK * (3.0 - 2.0 * sizeK);
+  let ys = mix(ou.toneRowThin.xyz, ou.toneRowThick.xyz, vec3f(f));
+  let xs = ou.toneAnchor.xyz;
+  let xc = clamp(x, xs.x, xs.z);
+  let h0 = max(xs.y - xs.x, 1e-4);
+  let h1 = max(xs.z - xs.y, 1e-4);
+  let d0 = (ys.y - ys.x) / h0;
+  let d1 = (ys.z - ys.y) / h1;
+  // The interior slope: the harmonic mean where the secants agree, 0 across a
+  // sign change \u2014 what keeps the curve monotone between monotone anchors.
+  var m1 = 0.0;
+  if (d0 * d1 > 0.0) { m1 = 2.0 * d0 * d1 / (d0 + d1); }
+  var h = h0; var t = (xc - xs.x) / h0;
+  var y0 = ys.x; var y1 = ys.y; var s0 = d0; var s1 = m1;
+  if (xc > xs.y) {
+    h = h1; t = (xc - xs.y) / h1;
+    y0 = ys.y; y1 = ys.z; s0 = m1; s1 = d1;
+  }
+  return y0 * (1.0 + 2.0 * t) * (1.0 - t) * (1.0 - t)
+       + s0 * h * t * (1.0 - t) * (1.0 - t)
+       + y1 * t * t * (3.0 - 2.0 * t)
+       + s1 * h * t * t * (t - 1.0);
+}
+
 /// Rim proximity: 1 exactly on the contour, falling to 0 by 'width' on either
 /// side. Symmetric, so the rim is a band on the boundary rather than a plateau
 /// that keeps burning outward where coverage has already faded.
@@ -2024,6 +2757,87 @@ 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.
+  // The thickness curve off the casting surface's span (W11c: the span rides
+  // the field), written as the body's own is below.
+  let castT = clamp(
+    (shadowAux.z - ou.scatter.z) / max(ou.scatter.w - ou.scatter.z, 1e-6),
+    0.0,
+    1.0,
+  );
+  let sizeK = clamp(castT * castT * (3.0 - 2.0 * castT) * clamp(ou.tone.w, 0.0, 1.0), 0.0, 1.0);
+  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 +2859,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,51 +2879,326 @@ 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 two curves 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
+  // 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);
+  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);
 
-  let displaceCss = -normal * lensDepth * profile * ou.lens.x;
+  // 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 refracted01 = viewport01 + displaceCss / viewportCss;
 
-  let straightUv = clamp(viewport01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
   let refractedUv = clamp(refracted01 * ou.fit.xy + ou.fit.zw, vec2f(0.0), vec2f(1.0));
 
-  let bodyLod = clamp(lensDepth * ou.lens.y, 0.0, ou.lens.w);
-  let lod = clamp(bodyLod - ou.lens.z * profile, 0.0, ou.lens.w);
+  /*
+   * The scattering facet of the size law: "a softer scattering of light".
+   *
+   * The body texture is one blur for the whole backdrop source \u2014 it is built once
+   * per source per frame, so it cannot be per-surface. The chain beside it can:
+   * 'size.w' is the chain level whose blur already matches that body, so
+   * 'size.w + log2(sizeScatterGainMax)' is the level whose blur is the gain times
+   * wider \u2014 the HEAVY component, at one fixed level \u2014 and lerping the body toward
+   * it by 'kScatter' is what the reference's interior measures (W11c, claims
+   * \xA75.41): a sharp component near the body's \u03C3 and a heavy one near \u03C3 10, mixed
+   * by a share that is \u2248 0.4 on a small control and rises with the span. The
+   * mix, not the level, is what the span moves.
+   */
+  let scatterLod = clamp(ou.size.w + log2(max(ou.size.x, 1e-4)), 0.0, ou.lens.w);
 
   var backdrop = vec3f(0.0);
   if (ou.flags.x > 0.5) {
-    let lensSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, lod);
-    let bodySample = textureSampleLevel(backdropBody, backdropSampler, straightUv, 0.0);
+    // Both components at the refracted position (W11c G2): the band and the
+    // interior are one body, and the displacement alone is the lens.
+    let bodySample = textureSampleLevel(backdropBody, backdropSampler, refractedUv, 0.0);
+    let scatterSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, scatterLod);
     // Premultiplied linear in, straight colour out: the material composites over
     // whatever is behind it, so a partially transparent backdrop must not darken
     // the glass.
-    let lensColour = lensSample.rgb / max(lensSample.a, 1e-6);
-    let bodyColour = bodySample.rgb / max(bodySample.a, 1e-6);
-    backdrop = mix(bodyColour, lensColour, profile);
+    let scatterColour = scatterSample.rgb / max(scatterSample.a, 1e-6);
+    backdrop = mix(bodySample.rgb / max(bodySample.a, 1e-6), scatterColour, kScatter);
   }
 
   // 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);
+
+  /*
+   * 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);
+
+  /*
+   * The backdrop tone response solve (W9) \u2014 the law that owns the interior
+   * MEAN, where the collapse below owns texture and nothing else (claims
+   * \xA75.33). The composite under this mechanism reduces exactly to
+   * mean = (1 \u2212 k)\xB7M\u2080 + k\xB7toneLuma with M\u2080 = (1 \u2212 \u03B1)\xB7bgLinear + \u03B1\xB7L(neutral),
+   * so the neutral's tone is solved in closed form: shift its luma so the
+   * post-collapse mean lands on R(encodedInput, sizeK), the reference's own
+   * measured response. Chroma is untouched \u2014 the shift is achromatic \u2014 and
+   * the author tint still displaces the result per the composition contract.
+   *
+   * Three stand-downs, each measured rather than defensive: the whole axis is
+   * off where no backdrop tone was measured (same gate as the collapse); the
+   * solve's authority fades to zero below the dark anchor, where the only
+   * evidence is the impulse cell the collapse constants were fitted on; and
+   * at k \u2192 1 the collapse owns the pixel outright, so the solve's
+   * extrapolation is never evaluated against a vanishing (1 \u2212 k).
+   */
+  var solvedNeutral = neutral;
+  var solvedAlpha = sizedAlpha;
+  if (ou.flags.x > 0.5 && ou.toneAdapt.w > 0.0 && ou.toneRowThin.w > 0.0 &&
+      sizedAlpha > 1e-3 && toneAdapt < 0.995) {
+    let encodedInput = srgb_encode(ou.toneColour.w);
+    let anchor = max(ou.toneAnchor.x, 1e-4);
+    let authority =
+      smoothstep(anchor * 0.5, anchor, encodedInput) * clamp(ou.toneRowThin.w, 0.0, 1.0);
+    if (authority > 0.0) {
+      let response = tone_response(encodedInput, sizeK);
+      // The collapse's mean pull is toward L(toneColour.rgb) \u2014 the LINEAR
+      // mean, which toneAnchor.w carries \u2014 not toward the encoded level.
+      let preCollapse = (response - toneAdapt * ou.toneAnchor.w) / (1.0 - toneAdapt);
+      let neutralLuma = dot(neutral, vec3f(0.2126, 0.7152, 0.0722));
+      let nominal = (1.0 - sizedAlpha) * ou.toneAnchor.w + sizedAlpha * neutralLuma;
+      let shift = (preCollapse - nominal) / sizedAlpha * authority * ou.toneAdapt.w;
+      solvedNeutral = clamp(neutral + vec3f(shift), vec3f(0.0), vec3f(1.0));
+      /*
+       * The light attractor needs OPACITY. The light scheme's neutral is
+       * already at white, so an upward shift clamps to nothing \u2014 and the
+       * reference's light-adapted state is the material gone opaque-bright,
+       * the same "an adapting material stops transmitting" the collapse's
+       * alpha half was measured on. Whatever the clamp truncated is carried
+       * by the alpha, solved against the same composite and folded by the
+       * same authority. One-sided by design: darkward opacity is the
+       * collapse's own axis with its own fitted constants.
+       */
+      let solvedLuma = dot(solvedNeutral, vec3f(0.2126, 0.7152, 0.0722));
+      let achieved = (1.0 - sizedAlpha) * ou.toneAnchor.w + sizedAlpha * solvedLuma;
+      if (preCollapse > achieved + 1e-4 && solvedLuma > ou.toneAnchor.w + 1e-3) {
+        let alphaTarget = clamp(
+          (preCollapse - ou.toneAnchor.w) / (solvedLuma - ou.toneAnchor.w),
+          sizedAlpha,
+          1.0,
+        );
+        solvedAlpha = mix(sizedAlpha, alphaTarget, authority * ou.toneAdapt.w);
+      }
+    }
+  }
+
+  let adaptedAlpha = solvedAlpha + toneAdapt * (1.0 - solvedAlpha);
+  var adapted = solvedNeutral;
+  if (toneAdapt > 0.0 && adaptedAlpha > 0.0) {
+    adapted =
+      (solvedNeutral * ((1.0 - toneAdapt) * solvedAlpha) + ou.toneColour.rgb * toneAdapt) /
+      adaptedAlpha;
+  }
+
+  // The material, untinted: the adapted neutral over what this pixel looks
+  // through, at the material's own occlusion. That alpha is what reduced
+  // transparency lifts and what the size law thickens ("a larger size is more
+  // opaque" is a statement about how much material there is), and the backdrop
+  // adaptation moved it above. The author's colour never touches it \u2014 but not
+  // for the reason the composition contract first gave (claims \xA75.36).
+  var colour = mix(backdrop, adapted, adaptedAlpha);
+  /*
+   * How much of this pixel the SURFACE owns, as the canvas will composite it.
+   *
+   * With a backdrop the composite above is the whole pixel \u2014 the pass sampled
+   * what is behind the surface and mixed it in, so the output is opaque inside
+   * the contour and the page beneath the canvas never shows. With no backdrop
+   * the composite is not here to make: a 'css-backdrop' group's blurred
+   * backdrop is a DOM proxy under this canvas, a 'none' group's is the page
+   * itself, and the browser is the compositor. So the material leaves as a
+   * LAYER \u2014 the adapted colour at the material's own alpha, premultiplied on
+   * the way out \u2014 and every term below that would have shaped the composite
+   * shapes the layer instead, in the form that composites to the same thing.
+   *
+   * Before W11a this path mixed the material over a black backdrop and wrote
+   * it opaque: a nested surface over glass rendered as a flat 0.468 where the
+   * reference reads 0.89 (claims \xA75.38 \xA75). The rows that floored were that
+   * grey. The pair the layer is written at is the host's
+   * ('GroupRenderInput.unsampledMaterial'): the browser composites this canvas
+   * in encoded sRGB, so the alpha is the CSS tier's, not the linear profile's.
+   */
+  var bodyAlpha = 1.0;
+  if (ou.flags.x <= 0.5) {
+    colour = adapted;
+    bodyAlpha = adaptedAlpha;
+  }
+
+  // The author tint (W10). 'aux.w' is the per-pixel strength, unioned in the
+  // field pass, so a toolbar can carry one tinted control among plain ones; the
+  // seed is a group uniform. At strength 0 this is the identity and the material
+  // is the one the calibration bed measures, byte for byte.
+  //
+  // Apple's mechanism, measured per pixel: the tinted material is an OPAQUE
+  // layer of the seed at a shade that is linear in the luminance the untinted
+  // material shows at this pixel \u2014 about half the seed's light over black
+  // content, the seed itself over white, the seed's chromaticity intact
+  // throughout. That layer composites over the material at the AUTHOR's
+  // opacity in the encoded space, which is what a CALayer with 'opacity' does
+  // and how the reference's half-strength cell measures. So a tinted surface
+  // over a checkerboard shows the checker as light and dark ORANGE, not as
+  // orange glass with the checker behind it \u2014 the material's own alpha is not
+  // what a tinted surface shows.
+  //
+  // 'seed.w' is the contrast regime's grip on the excursion, never on the hue;
+  // 'tone.z' is the profile's provenance gate (the dark scheme renders the pure
+  // seed); and '1 \u2212 toneAdapt' folds the shade out where the collapse has made
+  // the material a dark body, where the reference renders the pure seed too.
+  // At zero grip the layer is the bare seed \u2014 the author's colour, flat.
+  if (aux.w > 0.0) {
+    // The untinted material's luminance at this pixel. Over a backdrop that is
+    // the composite; as a layer it is the layer over the tone the host measured
+    // for the group \u2014 zero where nothing was measured, the same reference-level
+    // convention the CSS tier's 'materialLuminance' takes (within its 0.02).
+    let u = bodyAlpha * dot(colour, vec3f(0.2126, 0.7152, 0.0722)) + (1.0 - bodyAlpha) * ou.toneColour.w;
+    let grip = clamp(ou.seed.w, 0.0, 1.0) * clamp(ou.tone.z, 0.0, 1.0) * (1.0 - toneAdapt);
+    let shade = mix(1.0, clamp(mix(ou.tone.x, ou.tone.y, clamp(u, 0.0, 1.0)), 0.0, 1.0), grip);
+    let layer = ou.seed.rgb * shade;
+    let s = clamp(aux.w, 0.0, 1.0);
+    let encodedMaterial = linear_to_srgb(clamp(colour, vec3f(0.0), vec3f(1.0)));
+    let encodedLayer = linear_to_srgb(layer);
+    if (ou.flags.x > 0.5) {
+      colour = srgb_to_linear(mix(encodedMaterial, encodedLayer, vec3f(s)));
+    } else {
+      // The opaque layer at the author's opacity over the material's own layer,
+      // premultiplied: the fold 'tintedCssOptics' makes into one rgba.
+      let premultiplied = (1.0 - s) * bodyAlpha * encodedMaterial + s * encodedLayer;
+      bodyAlpha = 1.0 - (1.0 - s) * (1.0 - bodyAlpha);
+      colour = srgb_to_linear(premultiplied / max(bodyAlpha, 1e-6));
+    }
+  }
+
+  /*
+   * Everything below is the surface's own APPEARANCE \u2014 the marks that say a
+   * 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);
+  // 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 shadowedAlpha = 1.0 - shadowKeep * (1.0 - bodyAlpha);
+  colour = colour * (shadowKeep * bodyAlpha / max(shadowedAlpha, 1e-6));
+  bodyAlpha = shadowedAlpha;
 
   // Rim and specular from the gradient. The rim is unlit ambient edge brightness;
   // the specular term is the same edge lit from 'light.xy'.
   let rw = rim_weight(d, ou.rim.x);
   let facing = dot(normal, ou.light.xy);
   let spec = pow(clamp(facing, 0.0, 1.0), max(ou.rim.z, 1e-3)) * ou.rim.w;
-  colour = colour + vec3f(rw * (ou.rim.y + spec));
+  let rim = rw * (ou.rim.y + spec) * present;
+  if (ou.flags.x > 0.5) {
+    colour = colour + vec3f(rim);
+  } else {
+    // Added light has no premultiplied form of its own \u2014 a canvas colour may
+    // not exceed its alpha \u2014 so the layer carries the light in its opacity:
+    // (a\xB7c + rim, a + rim) composites to dst\xB7(1 \u2212 a) + a\xB7c + rim \u2212 rim\xB7dst,
+    // the additive term short of rim \xD7 dst. Exact wherever the layer is
+    // opaque (an author tint at full strength, or a lit contour pixel whose
+    // alpha the rim fills), and never further off than the rim times what
+    // shows through \u2014 where the mix form ("white over the layer at the rim's
+    // weight") is short by the rim times the whole composite, which halved
+    // the rim on a tinted panel.
+    let carried = clamp(bodyAlpha + rim, 0.0, 1.0);
+    colour = min((colour * bodyAlpha + vec3f(rim)) / max(carried, 1e-6), vec3f(1.0));
+    bodyAlpha = carried;
+  }
 
-  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 by however much of
+  // the pixel the layer owns, and the alpha is what the two of them together
+  // leave the page. The shadow fills only what the surface's COVERAGE leaves \u2014
+  // clipped out of the silhouette exactly as a 'box-shadow' is clipped out of
+  // its border box \u2014 never what the layer's own transparency leaves: a
+  // translucent surface shows the page through it, not its own shadow. (With
+  // an opaque body the two are the same quantity, which is how the shadow was
+  // first written and why the difference only surfaced with the layer form.)
+  let body = encode_output(max(colour, vec3f(0.0)), coverage * bodyAlpha);
+  return vec4f(body.rgb, body.a + shadowAlpha * (1.0 - coverage));
 }`;
 
 // ../renderer-webgpu/dist/wgsl/prelude.js
@@ -2345,7 +3445,7 @@ function createPassRunner(context) {
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 32);
+      const slot = uniformSlot(`optics:${args.groupId}`, 76);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -2356,8 +3456,8 @@ function createPassRunner(context) {
       d[6] = args.fit[2];
       d[7] = args.fit[3];
       d[8] = args.refractionScale;
-      d[9] = args.bodyLodPerPx;
-      d[10] = args.rimLodBias;
+      d[9] = args.lensRefractionGain;
+      d[10] = 0;
       d[11] = args.chainMaxLod;
       d[12] = args.tint[0];
       d[13] = args.tint[1];
@@ -2367,18 +3467,62 @@ 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.tintShade[0];
+      d[25] = args.tintShade[1];
+      d[26] = args.tintShade[2];
+      d[27] = args.sizeFold;
+      d[28] = args.rimWidth;
+      d[29] = args.rimAlpha;
+      d[30] = args.specularPower;
+      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;
+      d[60] = args.backdropToneAnchorX[0];
+      d[61] = args.backdropToneAnchorX[1];
+      d[62] = args.backdropToneAnchorX[2];
+      d[63] = args.backdropToneLinearMean;
+      d[64] = args.backdropToneResponseThin[0];
+      d[65] = args.backdropToneResponseThin[1];
+      d[66] = args.backdropToneResponseThin[2];
+      d[67] = args.backdropToneResponseStrength;
+      d[68] = args.backdropToneResponseThick[0];
+      d[69] = args.backdropToneResponseThick[1];
+      d[70] = args.backdropToneResponseThick[2];
+      d[71] = 0;
+      d[72] = args.sizeScatterFloor;
+      d[73] = args.sizeScatterSpanMax;
+      d[74] = args.sizeSpanMin;
+      d[75] = args.sizeSpanMax;
       slot.write();
       const chain = args.backdrop?.chain ?? placeholderView;
       const body = args.backdrop?.body ?? placeholderView;
@@ -2408,7 +3552,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 +3574,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] = args.sizeSpanMin;
+      d[26] = args.sizeSpanMax;
+      d[27] = args.sizeFold;
+      const fieldRect = args.fieldRectDevice;
+      d[28] = args.rectDevice.width / Math.max(fieldRect.width, 1e-6);
+      d[29] = args.rectDevice.height / Math.max(fieldRect.height, 1e-6);
+      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 +3697,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 };
@@ -2608,6 +3772,11 @@ 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);
+};
 function createPyramidStore(context) {
   const { device, pool, cache } = context;
   const resources = /* @__PURE__ */ new Map();
@@ -2683,7 +3852,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, density) {
     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 +3889,11 @@ function createPyramidStore(context) {
       body,
       stats,
       sizeEpoch,
-      builtEpoch
+      builtEpoch,
+      bodySigmaTexels,
+      texelsPerCss: density.texelsPerCss,
+      sourceWidth: density.sourceWidth,
+      sourceHeight: density.sourceHeight
     };
     resources.set(sourceId, next);
     return next;
@@ -2908,7 +4081,7 @@ function createPyramidStore(context) {
     },
     build(request, provider, encoder) {
       const existing = liveResources(request.sourceId);
-      if (existing !== void 0 && existing.builtEpoch >= request.epoch && !provider.isDirty()) {
+      if (existing !== void 0 && existing.builtEpoch >= request.epoch && !provider.isDirty() && sameDensity(existing, request)) {
         ledger.recordClean();
         return { status: "clean", resources: existing };
       }
@@ -2926,11 +4099,11 @@ function createPyramidStore(context) {
       }
       pendingRelease.push(provider);
       const plan = planPyramid(frame.width, frame.height, request.resolution);
-      const [viewportW, viewportH] = request.viewportCss;
-      const cover = viewportW > 0 && viewportH > 0 ? Math.max(frame.width / viewportW, frame.height / viewportH) : 1;
+      const texelsPerCss = densityOf(frame, request);
       const planScale = frame.width > 0 ? plan.width / frame.width : 1;
-      const bodyPlan = bodyBlurPlan(request.bodySigmaCss * cover * planScale, plan);
-      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch);
+      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 });
       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,17 +4219,11 @@ 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"
-};
+var STANDALONE_RESOLUTION = { scale: 1, maxDimension: 2048 };
 function createWebGPURenderer(options = {}) {
   const providers = /* @__PURE__ */ new Map();
+  const placements = /* @__PURE__ */ new Map();
+  const lastResolution = /* @__PURE__ */ new Map();
   const groups = /* @__PURE__ */ new Map();
   const adaptation = /* @__PURE__ */ new Map();
   const lastReadbackAt = /* @__PURE__ */ new Map();
@@ -3145,18 +4312,34 @@ function createWebGPURenderer(options = {}) {
     }
     return state;
   };
-  const coverFit = (sourceWidth, sourceHeight) => {
-    const viewportAspect = viewport.heightCss > 0 ? viewport.widthCss / viewport.heightCss : 1;
-    const sourceAspect = sourceHeight > 0 ? sourceWidth / sourceHeight : 1;
-    if (sourceAspect > viewportAspect) {
-      const scaleX = viewportAspect / sourceAspect;
-      return [scaleX, 1, (1 - scaleX) / 2, 0];
+  const fitFor = (sourceId, pyramid) => {
+    const placement = placements.get(sourceId);
+    return isUsablePlacement(placement) ? placementFit(placement, viewport.widthCss, viewport.heightCss) : coverFit(pyramid.plan.width, pyramid.plan.height, viewport.widthCss, viewport.heightCss);
+  };
+  const densityRebuilds = (explicit, pyramids) => {
+    const requests = [];
+    const named = new Set(explicit.map((request) => request.sourceId));
+    for (const sourceId of providers.keys()) {
+      if (named.has(sourceId))
+        continue;
+      const existing = pyramids.resources(sourceId);
+      if (existing === void 0)
+        continue;
+      const next = texelsPerCssPx(existing.sourceWidth, existing.sourceHeight, placements.get(sourceId), viewport.widthCss, viewport.heightCss);
+      if (Math.abs(next - existing.texelsPerCss) <= 1e-6 * Math.max(1, existing.texelsPerCss))
+        continue;
+      requests.push({
+        sourceId,
+        epoch: existing.builtEpoch,
+        resolution: lastResolution.get(sourceId) ?? STANDALONE_RESOLUTION,
+        groupIds: [...groups.values()].filter((entry) => entry.input.backdropSourceId === sourceId).map((entry) => entry.input.groupId)
+      });
     }
-    const scaleY = sourceAspect / viewportAspect;
-    return [1, scaleY, 0, (1 - scaleY) / 2];
+    return requests;
   };
   const unionOf = (input) => input.union ?? DEFAULT_GROUP_UNION;
   const variantOf = (input) => input.variant ?? "regular";
+  const 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) {
@@ -3168,8 +4351,12 @@ function createWebGPURenderer(options = {}) {
     };
   };
   function rebuildRequests(explicit) {
-    if (explicit !== void 0)
-      return explicit;
+    const base = explicit ?? standaloneRequests();
+    const { store: pyramids } = ensureContext();
+    const density = densityRebuilds(base, pyramids);
+    return density.length === 0 ? base : [...base, ...density];
+  }
+  function standaloneRequests() {
     const sampled = /* @__PURE__ */ new Set();
     for (const entry of groups.values()) {
       const id = entry.input.backdropSourceId;
@@ -3187,7 +4374,7 @@ function createWebGPURenderer(options = {}) {
         // keeping the books, so a monotonically rising number is the honest
         // stand-in and it keeps `build`'s clean-skip from firing spuriously.
         epoch: framesDrawn + 1,
-        resolution: { scale: 1, maxDimension: 2048 },
+        resolution: STANDALONE_RESOLUTION,
         groupIds: [...groups.values()].filter((entry) => entry.input.backdropSourceId === sourceId).map((entry) => entry.input.groupId)
       });
     }
@@ -3205,12 +4392,15 @@ function createWebGPURenderer(options = {}) {
       }
       const variant = variantOf([...groups.values()].find((entry) => entry.input.backdropSourceId === request.sourceId)?.input ?? { });
       const optics = opticsUnderPolicy(material.optics[variant], accessibility, material);
+      lastResolution.set(request.sourceId, request.resolution);
+      const placement = placements.get(request.sourceId);
       const outcome = pyramids.build({
         sourceId: request.sourceId,
         epoch: request.epoch,
         resolution: request.resolution,
         bodySigmaCss: optics.blurSigma,
-        viewportCss: [viewport.widthCss, viewport.heightCss]
+        viewportCss: [viewport.widthCss, viewport.heightCss],
+        ...isUsablePlacement(placement) ? { placement } : {}
       }, provider, encoder);
       if (outcome.status === "built")
         built += 1;
@@ -3246,9 +4436,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 +4448,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,14 +4477,25 @@ 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 refraction = effectiveRefraction(accessibilityRefractionCap(policy), state.refraction);
-      const refractionScale = material.refractionScale[refraction];
       const sourceId = input.backdropSourceId;
       const pyramid = sourceId === void 0 ? void 0 : pyramids.resources(sourceId);
       const adapt = sourceId === void 0 ? void 0 : adaptationFor(sourceId).values;
+      const nominalOptics = material.optics[variant];
+      const optics = opticsUnderPolicy(pyramid === void 0 && input.unsampledMaterial !== void 0 ? {
+        ...nominalOptics,
+        tint: input.unsampledMaterial.tint,
+        tintAlpha: input.unsampledMaterial.tintAlpha
+      } : nominalOptics, policy, material);
+      const backdropTone = [
+        material.backdropToneLow,
+        material.backdropToneHigh,
+        backdropToneSizeBiasUnderPolicy(policy, material),
+        input.backdropTone === void 0 ? 0 : backdropToneUnderPolicy(policy, material) * material.backdropToneMax
+      ];
+      const backdropToneLevel = input.backdropTone === void 0 ? 0 : input.backdropToneLevel ?? relativeLuminance(input.backdropTone);
+      const refraction = effectiveRefraction(accessibilityRefractionCap(policy), state.refraction);
+      const refractionScale = material.refractionScale[refraction];
       passes.opticsPass(encoder, {
         groupId: input.groupId,
         target: active.optics,
@@ -3296,15 +4505,29 @@ function createWebGPURenderer(options = {}) {
         viewportDevice,
         cssPerDevice,
         coverageRampCss: cssPerDevice,
-        fit: pyramid === void 0 ? [1, 1, 0, 0] : coverFit(pyramid.plan.width, pyramid.plan.height),
+        fit: pyramid === void 0 || sourceId === void 0 ? [1, 1, 0, 0] : fitFor(sourceId, pyramid),
         refractionScale,
-        bodyLodPerPx: material.lensBodyLodPerPx,
-        rimLodBias: material.lensRimLodBias,
+        lensRefractionGain: material.lensRefractionGain,
         chainMaxLod: pyramid?.plan.maxLod ?? 0,
         tint: optics.tint,
         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),
+        tintShade: [material.tintShadeDark, material.tintShadeLight, material.tintShadeStrength],
         rimWidth: optics.rimWidth,
         rimAlpha: optics.rimAlpha,
         specularPower: optics.specularPower,
@@ -3312,6 +4535,60 @@ 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),
+        // The size law's curves (W11c): the shader evaluates the thickness and
+        // the scatter mix per pixel from the span the field carries, under the
+        // same fold `sizeThicknessUnderPolicy` applies on the CPU.
+        sizeSpanMin: material.sizeSpanMin,
+        sizeSpanMax: material.sizeSpanMax,
+        sizeScatterFloor: material.sizeScatterFloor,
+        sizeScatterSpanMax: material.sizeScatterSpanMax,
+        sizeFold: material.refractionScale[accessibilityRefractionCap(policy)],
+        backdropTone,
+        backdropToneColour: [
+          input.backdropTone?.[0] ?? 0,
+          input.backdropTone?.[1] ?? 0,
+          input.backdropTone?.[2] ?? 0,
+          backdropToneLevel
+        ],
+        // The response law's anchors (W9) and the linear backdrop mean its
+        // solve composites against. The shader re-derives the encoded input
+        // from `backdropToneLevel`, so the fourth slot carries the linear
+        // mean — the one quantity the solve needs that the tone colour does
+        // not already hold.
+        backdropToneAnchorX: material.backdropToneAnchorX,
+        backdropToneResponseThin: material.backdropToneResponseThin,
+        backdropToneResponseThick: material.backdropToneResponseThick,
+        // The response law rides only the UN-DEGRADED regime, for the same
+        // provenance reason the dark profiles set its strength to 0: the
+        // anchors are standard-light-reference measurements, and the
+        // accessibility references behave differently (nearly opaque, flat in
+        // span — W2). Measured before this gate existed: reduced-transparency
+        // photo ΔE p95 0.007 → 0.048 and cross-tier ratio 0.99 → 0.86. Where
+        // any policy fold touches the tone axis, the solve stands down and the
+        // collapse alone runs, exactly the pre-W9 behaviour those profiles
+        // were fitted on.
+        backdropToneResponseStrength: backdropToneUnderPolicy(policy, material) >= 0.999 ? material.backdropToneResponseStrength : 0,
+        backdropToneLinearMean: input.backdropToneLinearLuminance ?? backdropToneLevel,
+        outerShadow: [
+          outerShadowAlpha(shadow.occlusion),
+          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 +4600,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 +4614,15 @@ 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 — and the
+          // same band and fold, since the curve is evaluated off the span.
+          backdropTone,
+          backdropToneLevel,
+          sizeSpanMin: material.sizeSpanMin,
+          sizeSpanMax: material.sizeSpanMax,
+          sizeFold: material.refractionScale[accessibilityRefractionCap(policy)]
         });
       }
       drawn += 1;
@@ -3400,6 +4687,8 @@ function createWebGPURenderer(options = {}) {
       providers.set(provider.id, provider);
     },
     unregisterBackdrop(sourceId) {
+      placements.delete(sourceId);
+      lastResolution.delete(sourceId);
       const provider = providers.get(sourceId);
       if (provider === void 0)
         return;
@@ -3412,6 +4701,17 @@ function createWebGPURenderer(options = {}) {
     backdrop(sourceId) {
       return providers.get(sourceId);
     },
+    setBackdropPlacement(sourceId, placement) {
+      if (samePlacement(placements.get(sourceId), placement))
+        return;
+      if (placement === void 0)
+        placements.delete(sourceId);
+      else
+        placements.set(sourceId, { ...placement });
+    },
+    backdropPlacement(sourceId) {
+      return placements.get(sourceId);
+    },
     setViewport(next) {
       const changed = next.widthCss !== viewport.widthCss || next.heightCss !== viewport.heightCss || next.devicePixelRatio !== viewport.devicePixelRatio;
       viewport = next;
@@ -3568,6 +4868,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, 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