@vitreajs/vitrea 0.2.0 → 0.3.0

package/dist/{dist-RQ4ZMA3D.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,7 +88,8 @@ fn cs_analysis(@builtin(local_invocation_index) lane : u32) {
   if (lane == 0u) {
     let count = max(f32(total), 1.0);
     let mean = partialLum[0] / count;
-    stats[0] = mean;
+    // stats[0] is the ENCODED-space mean; the host decodes it once (W9).
+    stats[0] = partialTone[0] / count;
     stats[1] = max(partialSq[0] / count - mean * mean, 0.0);
     stats[2] = partialEdge[0] / count;
     stats[3] = count;
@@ -233,7 +246,12 @@ var DEFAULT_MATERIAL_PROFILE = {
        * the same 44 px span, which is the lerp-versus-multiply question C9a
        * recorded and nobody has acted on. Claims §5.13.
        */
-      blurSigma: 3,
+      // 1.25 since W11c G1 (claims §5.41): the reference's interior over
+      // structured content is a sharp component near σ 1.25 plus a heavy one
+      // the scatter facet now supplies (`sizeScatterFloor`); the cascade's 3
+      // (claims §5.16) was the one Gaussian that best split the difference on
+      // a bed with no pitch axis to tell the two apart.
+      blurSigma: 1.25,
       tint: srgbToLinear(SRGB_WHITE_TINT),
       tintAlpha: 0.46,
       rimWidth: 1.5,
@@ -405,41 +423,45 @@ var DEFAULT_MATERIAL_PROFILE = {
    * on. The grid 1.0/1.4/2.2 is flat to 0.2%. Carrying a fitted-looking 1.4 whose
    * measurement no longer exists would be the worse of the two errors.
    */
-  sizeScatterGainMax: 1,
+  // MEASURED (W11c G1, claims §5.41): the scatter facet off the identity, on
+  // its own curve — see `MaterialProfile.sizeScatterFloor`. The paragraph
+  // above records why the identity was the right answer while `blurSigma`
+  // was 3 and the bed had no pitch axis; the W9 probe's pitch axis is what
+  // identified the two-component interior this expresses.
+  sizeScatterGainMax: 8,
+  sizeScatterFloor: 0.4,
+  sizeScatterSpanMax: 256,
   sizeOcclusionGain: 0.05,
   sizeShadowGainMax: 1,
-  lensBodyLodPerPx: 0.16,
-  lensRimLodBias: 2.5,
+  // 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,
-  // ADVISORY (W3). The span 0.02 … 0.65 covers most of the canonical backdrop
-  // range (0.003 … 0.891 linear), and the two ends are deliberately symmetric —
-  // 0.45 of the seed's brightness at the dark end, 0.45 of the way to white at
-  // the bright end — so the seed itself sits mid-range and the excursion reads
-  // as glass rather than as two different colours.
   /*
-   * FITTED (2026-08-31, active bed) — and the fit is that THE CURVE IS THE
-   * IDENTITY. `floor` → 1 and `ceilMix` → 0 make `tintTone` return the seed
-   * unchanged at every backdrop, which leaves `low` and `high` describing
-   * nothing at all; they keep their provisional values so a bed that can
-   * identify them has somewhere to land, exactly as `adaptiveTint` keeps two
-   * equal ends.
+   * MEASURED (W10, 2026-09-02) — per-pixel least squares of the reference's
+   * tinted pixel against its own untinted pixel on the five W9-probe tinted
+   * checkerboard cells (pitch 4…64 px, 17 700 px): shade = 0.5289 + 0.4886·u,
+   * RMS 0.0035. Out of sample on the canonical bed the orange cells fit at
+   * RMS 0.003 with zero bias; blue sits 0.011 darker (the second hue's
+   * residual, recorded and unmodelled). The light end extrapolates past 1 and
+   * is clamped in `tintShade`. Claims §5.36.
    *
-   * Monotone and uncontested over floor ∈ {0.45, 0.7, 0.85, 1} × ceilMix ∈
-   * {0, 0.2, 0.45}: objective 0.26523 → 0.12676, a 2.09× spread, with ΔE
-   * (0.01331 → 0.00831) and SSIM (0.9749 → 0.9788) agreeing. The reference
-   * says the same thing directly — on three of the five calibration backdrops
-   * its tinted interior is the declared seed EXACTLY in linear light, at a
-   * per-channel standard deviation of 0.000. Apple's tint is the author's
-   * colour, not a range of tones mapped to it; S219's wording described the
-   * inactive material's residue. Claims §5.13.
+   * §5.13's earlier "the curve is the identity" fit was made on the material's
+   * MEAN over solid backdrops, where u is either ~0.97 (shade 1.0) or the
+   * collapse has already folded the shade out — the identity was the law's
+   * two endpoints, seen without anything between them.
    */
-  tintToneFloor: 1,
-  tintToneCeilMix: 0,
-  tintToneLow: 0.02,
-  tintToneHigh: 0.65,
+  tintShadeDark: 0.5289,
+  tintShadeLight: 1.0175,
+  tintShadeStrength: 1,
   /*
    * MEASURED (W7), against the settled apple-macos-26.5 bed, on the light and
    * dark standard profiles jointly and at both scales.
@@ -472,9 +494,21 @@ var DEFAULT_MATERIAL_PROFILE = {
    * is a VALIDATION cell and was not fitted to: the calibration set predicts
    * 0.34 there and the cell reads 0.356.
    */
+  /*
+   * RE-SCOPED (W9, claims §5.33). The four mix constants now own TEXTURE
+   * COLLAPSE alone — the interior mean moved to the response law below — and
+   * their band contracts to the one domain the collapse is real in: full at
+   * `dark-solid` (0.0117) for thin surfaces including the 44 px capsule
+   * (byte-identical collapse, arg 0.0164 ≤ low with margin), zero by
+   * `mid-dark-solid` (0.0595), where the reference's small surface keeps a
+   * textured body at 0.4561 and the old band's partial collapse (k = 0.81)
+   * was the measured 0.1375-vs-0.4561 overshoot. `impulse__rrect-md`
+   * (arg 0.0539) keeps k ≈ 0.003 against the old band's 0.008 — the same
+   * unadapted render that cell validated.
+   */
   backdropToneMax: 1,
-  backdropToneLow: 0.03,
-  backdropToneHigh: 0.14,
+  backdropToneLow: 0.02,
+  backdropToneHigh: 0.055,
   /*
    * REFITTED 0.09 → 0.13 (2026-08-31, active bed). The law's SHAPE is untouched
    * (Decision Log 13 stands; the two-axis rework is next wave) and `max`, `low`
@@ -493,8 +527,26 @@ var DEFAULT_MATERIAL_PROFILE = {
    * estimator's algebra assumes the two colour schemes share one tint alpha,
    * and this profile pair does not (0.46 against 0.97) — recorded in §5.13 as
    * the reason it is no longer the primary evidence for this constant.
+   *
+   * RE-SCOPED 0.13 → 0.05 with the band above (W9): the bias's one remaining
+   * job is keeping the thick surface's collapse argument above `high` at the
+   * dark anchor (0.0117 + 0.05 = 0.0617 > 0.055) while the thin capsule's
+   * stays below `low` — the near-binary size snap the probe measured
+   * (claims §5.33). The smooth size trend on structured backdrops, which the
+   * old wide band tried and failed to carry, belongs to the response law's
+   * thickness axis now.
    */
-  backdropToneSizeBias: 0.13,
+  backdropToneSizeBias: 0.05,
+  /*
+   * MEASURED (W9 probe, claims §5.30–§5.33): the anchors are the probe bed's
+   * settled reference levels, frequency-settled over seven attested runs,
+   * under the probe's own native-mask interior. Thick rows pool the 96 px
+   * and 160 px rrects (±0.012). Not tuned; re-measured only by a new probe.
+   */
+  backdropToneAnchorX: [0.1104, 0.2706, 0.9505],
+  backdropToneResponseThin: [0.0126, 0.4561, 0.9713],
+  backdropToneResponseThick: [0.4953, 0.5744, 0.9358],
+  backdropToneResponseStrength: 1,
   /*
    * FITTED (recalibration cascade, 2026-08-31). W8's geometry SURVIVES the fit
    * unchanged — `sigmaPx` 15.55, `offsetPx` 7.95, `spreadPx` 3.10 — and only the
@@ -587,14 +639,19 @@ var SIZE_SPAN_MIN = DEFAULT_MATERIAL_PROFILE.sizeSpanMin;
 var SIZE_SPAN_MAX = DEFAULT_MATERIAL_PROFILE.sizeSpanMax;
 var LENS_SIZE_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.lensSizeGainMax;
 var SIZE_SCATTER_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.sizeScatterGainMax;
+var SIZE_SCATTER_FLOOR = DEFAULT_MATERIAL_PROFILE.sizeScatterFloor;
+var SIZE_SCATTER_SPAN_MAX = DEFAULT_MATERIAL_PROFILE.sizeScatterSpanMax;
 var SIZE_OCCLUSION_GAIN = DEFAULT_MATERIAL_PROFILE.sizeOcclusionGain;
 var SIZE_SHADOW_GAIN_MAX = DEFAULT_MATERIAL_PROFILE.sizeShadowGainMax;
-var LENS_BODY_LOD_PER_PX = DEFAULT_MATERIAL_PROFILE.lensBodyLodPerPx;
-var LENS_RIM_LOD_BIAS = DEFAULT_MATERIAL_PROFILE.lensRimLodBias;
+var LENS_REFRACTION_GAIN = DEFAULT_MATERIAL_PROFILE.lensRefractionGain;
 var 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 = {};
@@ -616,22 +673,26 @@ function withMaterialOverrides(base, patch) {
     sizeSpanMax: patch.sizeSpanMax ?? base.sizeSpanMax,
     lensSizeGainMax: patch.lensSizeGainMax ?? base.lensSizeGainMax,
     sizeScatterGainMax: patch.sizeScatterGainMax ?? base.sizeScatterGainMax,
+    sizeScatterFloor: patch.sizeScatterFloor ?? base.sizeScatterFloor,
+    sizeScatterSpanMax: patch.sizeScatterSpanMax ?? base.sizeScatterSpanMax,
     sizeOcclusionGain: patch.sizeOcclusionGain ?? base.sizeOcclusionGain,
     sizeShadowGainMax: patch.sizeShadowGainMax ?? base.sizeShadowGainMax,
-    lensBodyLodPerPx: patch.lensBodyLodPerPx ?? base.lensBodyLodPerPx,
-    lensRimLodBias: patch.lensRimLodBias ?? base.lensRimLodBias,
+    lensRefractionGain: patch.lensRefractionGain ?? base.lensRefractionGain,
     reducedTransparencyFrost: patch.reducedTransparencyFrost ?? base.reducedTransparencyFrost,
     increasedOcclusionLift: patch.increasedOcclusionLift ?? base.increasedOcclusionLift,
     strongBorderRim: { ...base.strongBorderRim, ...patch.strongBorderRim },
     reducedTintAdaptation: patch.reducedTintAdaptation ?? base.reducedTintAdaptation,
-    tintToneFloor: patch.tintToneFloor ?? base.tintToneFloor,
-    tintToneCeilMix: patch.tintToneCeilMix ?? base.tintToneCeilMix,
-    tintToneLow: patch.tintToneLow ?? base.tintToneLow,
-    tintToneHigh: patch.tintToneHigh ?? base.tintToneHigh,
+    tintShadeDark: patch.tintShadeDark ?? base.tintShadeDark,
+    tintShadeLight: patch.tintShadeLight ?? base.tintShadeLight,
+    tintShadeStrength: patch.tintShadeStrength ?? base.tintShadeStrength,
     backdropToneMax: patch.backdropToneMax ?? base.backdropToneMax,
     backdropToneLow: patch.backdropToneLow ?? base.backdropToneLow,
     backdropToneHigh: patch.backdropToneHigh ?? base.backdropToneHigh,
     backdropToneSizeBias: patch.backdropToneSizeBias ?? base.backdropToneSizeBias,
+    backdropToneAnchorX: patch.backdropToneAnchorX ?? base.backdropToneAnchorX,
+    backdropToneResponseThin: patch.backdropToneResponseThin ?? base.backdropToneResponseThin,
+    backdropToneResponseThick: patch.backdropToneResponseThick ?? base.backdropToneResponseThick,
+    backdropToneResponseStrength: patch.backdropToneResponseStrength ?? base.backdropToneResponseStrength,
     outerShadow: { ...base.outerShadow, ...patch.outerShadow },
     lightDirection: patch.lightDirection ?? base.lightDirection,
     sweepBandRadians: patch.sweepBandRadians ?? base.sweepBandRadians,
@@ -677,28 +738,29 @@ function tintToneAdaptation(policy, profile = DEFAULT_MATERIAL_PROFILE) {
       return 0;
   }
 }
-function tintTone(seed, backdropLuminance, toneAdaptation, profile = DEFAULT_MATERIAL_PROFILE) {
-  const t = smoothstep(profile.tintToneLow, profile.tintToneHigh, backdropLuminance);
-  const k = Math.min(1, Math.max(0, toneAdaptation));
+function tintShade(materialLuminance, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  const u = Math.min(1, Math.max(0, materialLuminance));
+  const shade = Math.min(1, Math.max(0, profile.tintShadeDark + (profile.tintShadeLight - profile.tintShadeDark) * u));
+  const k = Math.min(1, Math.max(0, grip));
+  return 1 + (shade - 1) * k;
+}
+function tintShadeLayer(seed, materialLuminance, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  const shade = tintShade(materialLuminance, grip, profile);
+  return [seed[0] * shade, seed[1] * shade, seed[2] * shade];
+}
+function tintedMaterialColour(material, tint, grip, profile = DEFAULT_MATERIAL_PROFILE) {
+  if (tint === void 0 || tint.strength <= 0)
+    return material;
+  const s = Math.min(1, Math.max(0, tint.strength));
+  const layer = tintShadeLayer(tint.color, relativeLuminance(material), grip, profile);
+  const clamp01 = (value) => Math.min(1, Math.max(0, value));
   const channel = (index) => {
-    const s = seed[index];
-    const low = s * profile.tintToneFloor;
-    const high = s + (1 - s) * profile.tintToneCeilMix;
-    return s + (low + (high - low) * t - s) * k;
+    const from = linearToSrgbChannel(clamp01(material[index]));
+    const to = linearToSrgbChannel(clamp01(layer[index]));
+    return srgbToLinearChannel(from + (to - from) * s);
   };
   return [channel(0), channel(1), channel(2)];
 }
-function tintedTintColour(neutral, tint, backdropLuminance, toneAdaptation, profile = DEFAULT_MATERIAL_PROFILE) {
-  if (tint === void 0)
-    return neutral;
-  const tone = tintTone(tint.color, backdropLuminance, toneAdaptation, profile);
-  const k = Math.min(1, Math.max(0, tint.strength));
-  return [
-    neutral[0] + (tone[0] - neutral[0]) * k,
-    neutral[1] + (tone[1] - neutral[1]) * k,
-    neutral[2] + (tone[2] - neutral[2]) * k
-  ];
-}
 function backdropToneAdaptation(backdropLuminance, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
   const x = backdropLuminance + profile.backdropToneSizeBias * Math.min(1, Math.max(0, thickness));
   const span = Math.max(profile.backdropToneHigh - profile.backdropToneLow, 1e-6);
@@ -749,10 +811,14 @@ function lensSizeGainFromThickness(thickness, profile = DEFAULT_MATERIAL_PROFILE
   return 1 + (profile.lensSizeGainMax - 1) * thickness;
 }
 function sizeScatterSigma(sigmaPx, spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
-  return sizeScatterSigmaAt(sigmaPx, sizeThickness(spanPx, profile), profile);
+  return sizeScatterSigmaAt(sigmaPx, scatterThickness(spanPx, 1, profile), profile);
 }
-function sizeScatterSigmaAt(sigmaPx, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
-  return sigmaPx * (1 + (profile.sizeScatterGainMax - 1) * thickness);
+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);
@@ -813,8 +879,11 @@ 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
@@ -826,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
@@ -1300,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 = {
@@ -1834,7 +1945,7 @@ function packInstances(surfaces, origin, into) {
     data[o + 13] = s.channels.glow;
     data[o + 14] = s.lensDepthPx * Math.min(1, Math.max(0, s.channels.lensStrength));
     data[o + 15] = s.tintStrength;
-    data[o + 16] = s.sizeThickness;
+    data[o + 16] = s.spanPx;
     data[o + 17] = 0;
   }
   return { data, count: surfaces.length };
@@ -2112,7 +2223,7 @@ var WGSL_INSTANCE_STRUCT = `struct Instance {
   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
   tintK  : f32,     // 60  author tint strength, 0..1 \u2014 the seed itself is a group uniform
-  sizeK  : f32,     // 64  the size law's thickness factor, 0..1 \u2014 material.ts's sizeThickness(span)
+  span   : f32,     // 64  the surface's shorter extent, CSS px \u2014 the size law's input, both curves (W11c)
   _pad   : f32,     // 68  stride padding: vec2f aligns the struct to 8, so 72 is the next legal size
 };`;
 var WGSL_FIELD_SAMPLE = `struct FieldSample {
@@ -2278,7 +2389,7 @@ var WGSL_FIELD_PASS = `struct FieldUniforms {
 // field but its members are not one size, and carrying them per pixel is what
 // lets a 40 px button and a 320 px platter share a field pass and still lens by
 // their own depth \u2014 parent acceptance #2 inside a GlassEffectContainer.
-//   aux = (lensDepthPx, glow, sizeK, tintStrength)
+//   aux = (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
@@ -2292,15 +2403,26 @@ var WGSL_FIELD_PASS = `struct FieldUniforms {
 // because a group is one field pass and one optics pass while its members are
 // not one thing:
 //
-//   'sizeK'        \u2014 the size law's thickness factor (W2). A 40 px button and a
-//                    320 px platter in one container lens, scatter, occlude and
-//                    shadow by their own size.
+//   'spanPx'       \u2014 the size law's input (W2): the surface's shorter extent in
+//                    CSS px. A 40 px button and a 320 px platter in one container
+//                    lens, scatter, occlude and shadow by their own size. Until
+//                    W11c this slot carried the folded thickness factor itself;
+//                    the scatter facet now rides a curve with a different band
+//                    top, so the span travels and each consumer evaluates its own
+//                    curve from it with the bands and the fold as uniforms.
 //   'tintStrength' \u2014 the author tint's strength (W3). One emphasised control
 //                    among plain ones is the composition Apple's guidance
 //                    describes; the seed itself is a group uniform.
 //
 // They compose rather than compete: the size law moves what the material does to
 // the backdrop, the tint moves what colour it does it in.
+//
+// One consequence of carrying the span rather than the thickness, stated so it
+// is not mistaken for a drift: the union below blends 'aux' linearly between two
+// members, so a pixel in the neck between a button and a platter now blends
+// their SPANS and evaluates the curves on the blend, where it used to blend the
+// evaluated thicknesses. Inside either member the two are identical; only the
+// smooth-min neck differs, and nothing measured claims a value there.
 
 @group(0) @binding(0) var<uniform> fu : FieldUniforms;
 @group(0) @binding(1) var<storage, read> instances : array<Instance>;
@@ -2321,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.sizeK, s.tintK);
+  m.aux = vec4f(s.lensDepth, s.glow, s.span, s.tintK);
   return m;
 }
 
@@ -2409,7 +2531,10 @@ var WGSL_HIGHLIGHT_PASS = `struct HighlightUniforms {
   /// accessibility refraction cap, and the resolved strength \u2014 zero where there
   /// is no measured backdrop tone, which stands the fade down
   toneAdapt : vec4f,
-  /// the backdrop source's own average luminance (x); yzw unused
+  /// the backdrop source's own average luminance (x), and the size law's band
+  /// and fold \u2014 sizeSpanMin (y), sizeSpanMax (z), the accessibility fold (w) \u2014
+  /// so this pass evaluates the thickness curve off the per-pixel span exactly
+  /// as the optics pass does (W11c: the span rides the field, not the factor)
   toneLevel : vec4f,
   /// this pass's uv into the FIELD texture's uv: scale (xy), offset (zw).
   ///
@@ -2489,7 +2614,14 @@ fn fs_highlight(in : FullscreenOut) -> @location(0) vec4f {
    * around a surface the optics pass had made invisible \u2014 measured at 60 pixels
    * past 2/255, peaking at 97/255, on exactly that cell.
    */
-  let sizeK = clamp(aux.z, 0.0, 1.0);
+  // The thickness curve off the per-pixel span, written out as the optics pass
+  // writes it, so the two passes fade on one curve and not on two copies.
+  let spanT = clamp(
+    (aux.z - hu.toneLevel.y) / max(hu.toneLevel.z - hu.toneLevel.y, 1e-6),
+    0.0,
+    1.0,
+  );
+  let sizeK = clamp(spanT * spanT * (3.0 - 2.0 * spanT) * hu.toneLevel.w, 0.0, 1.0);
   var toneAdapt = 0.0;
   if (hu.toneAdapt.w > 0.0) {
     let toneX = hu.toneLevel.x + hu.toneAdapt.z * sizeK;
@@ -2514,7 +2646,7 @@ 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,
@@ -2522,7 +2654,10 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   adapt : vec4f,
   /// author tint seed, linear light (xyz), tone adaptation under the contrast regime (w)
   seed : vec4f,
-  /// tintToneFloor, tintToneCeilMix, tintToneLow, tintToneHigh
+  /// the author tint's shade law (W10): tintShadeDark, tintShadeLight,
+  /// tintShadeStrength (the profile's provenance gate); and (w) the size law's
+  /// accessibility fold \u2014 the refraction ladder read at the preference's cap,
+  /// which every facet's span-dependent rise is multiplied by (W11c)
   tone : vec4f,
   /// rimWidthPx, rimAlpha, specularPower, specularGain
   rim : vec4f,
@@ -2551,9 +2686,23 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   shadow : vec4f,
   /// the outer shadow's size-law gain (x), read against the casting surface's own
   /// thickness, and the field rect's height in CSS px (y) \u2014 the conversion the
-  /// shadow's shift needs when it lands outside the texture; z and w are the
-  /// padding a uniform's vec4 alignment requires
+  /// 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;
@@ -2564,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.
@@ -2639,7 +2824,14 @@ fn outer_shadow_alpha(uv : vec2f, upsampled : f32, fieldSize : vec2f) -> f32 {
   // the remaining transparency in LINEAR light ('sizeOuterShadowOcclusionAt'),
   // and (1 - occ) is exactly what raising to 1/2.4 turns into (1 - alpha), so the
   // two forms are the same law and neither needs the other's space.
-  let sizeK = clamp(shadowAux.z, 0.0, 1.0);
+  // 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;
 
@@ -2687,51 +2879,66 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
 
   // Per-pixel, unioned through the field pass. See the module note.
   let lensDepth = max(aux.x, 1e-4);
-  // The size law's thickness factor for whichever surface owns this pixel, 0..1.
-  // Zero on anything at or below the profile's 'sizeSpanMin', and every term
-  // below multiplies by it \u2014 so a small control takes the pre-law path exactly.
-  let sizeK = clamp(aux.z, 0.0, 1.0);
+  // 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(scatterGain)' is the level whose blur is 'scatterGain' times
-   * wider, and lerping the body toward it by 'sizeK' widens the kernel with the
-   * surface. At sizeK = 0 the weight is zero and the body sample stands alone,
-   * which is what makes the whole facet inert on a small control.
+   * 'size.w + log2(sizeScatterGainMax)' is the level whose blur is the gain times
+   * wider \u2014 the HEAVY component, at one fixed level \u2014 and lerping the body toward
+   * it by 'kScatter' is what the reference's interior measures (W11c, claims
+   * \xA75.41): a sharp component near the body's \u03C3 and a heavy one near \u03C3 10, mixed
+   * by a share that is \u2248 0.4 on a small control and rises with the span. The
+   * mix, not the level, is what the span moves.
    */
-  let scatterGain = 1.0 + (ou.size.x - 1.0) * sizeK;
-  let scatterLod = clamp(ou.size.w + log2(max(scatterGain, 1e-4)), 0.0, ou.lens.w);
+  let scatterLod = clamp(ou.size.w + log2(max(ou.size.x, 1e-4)), 0.0, ou.lens.w);
 
   var backdrop = vec3f(0.0);
   if (ou.flags.x > 0.5) {
-    let lensSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, lod);
-    let bodySample = textureSampleLevel(backdropBody, backdropSampler, straightUv, 0.0);
-    let scatterSample = textureSampleLevel(backdropChain, backdropSampler, straightUv, scatterLod);
+    // Both components at the refracted position (W11c G2): the band and the
+    // interior are one body, and the displacement alone is the lens.
+    let bodySample = textureSampleLevel(backdropBody, backdropSampler, refractedUv, 0.0);
+    let scatterSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, scatterLod);
     // Premultiplied linear in, straight colour out: the material composites over
     // whatever is behind it, so a partially transparent backdrop must not darken
     // the glass.
-    let lensColour = lensSample.rgb / max(lensSample.a, 1e-6);
     let scatterColour = scatterSample.rgb / max(scatterSample.a, 1e-6);
-    let bodyColour = mix(bodySample.rgb / max(bodySample.a, 1e-6), scatterColour, sizeK);
-    backdrop = mix(bodyColour, lensColour, profile);
+    backdrop = mix(bodySample.rgb / max(bodySample.a, 1e-6), scatterColour, kScatter);
   }
 
   // Adaptive tint. 'adapt.w' is the strength the accessibility policy and the
@@ -2739,8 +2946,6 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // is what a 'hint' or 'none' group gets.
   let neutral = mix(ou.tint.rgb, ou.adapt.rgb, ou.adapt.w);
 
-  let backdropLuma = dot(backdrop, vec3f(0.2126, 0.7152, 0.0722));
-
   /*
    * Backdrop tone adaptation (W7) \u2014 step two of the composition contract, between
    * the colour scheme's neutral and the author's tint.
@@ -2785,57 +2990,148 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
    * and 'adaptedTintAlpha' in material.ts.
    */
   let sizedAlpha = ou.tint.w + ou.size.y * sizeK * (1.0 - ou.tint.w);
-  let adaptedAlpha = sizedAlpha + toneAdapt * (1.0 - sizedAlpha);
-  var adapted = neutral;
+
+  /*
+   * The backdrop tone response solve (W9) \u2014 the law that owns the interior
+   * MEAN, where the collapse below owns texture and nothing else (claims
+   * \xA75.33). The composite under this mechanism reduces exactly to
+   * mean = (1 \u2212 k)\xB7M\u2080 + k\xB7toneLuma with M\u2080 = (1 \u2212 \u03B1)\xB7bgLinear + \u03B1\xB7L(neutral),
+   * so the neutral's tone is solved in closed form: shift its luma so the
+   * post-collapse mean lands on R(encodedInput, sizeK), the reference's own
+   * measured response. Chroma is untouched \u2014 the shift is achromatic \u2014 and
+   * the author tint still displaces the result per the composition contract.
+   *
+   * Three stand-downs, each measured rather than defensive: the whole axis is
+   * off where no backdrop tone was measured (same gate as the collapse); the
+   * solve's authority fades to zero below the dark anchor, where the only
+   * evidence is the impulse cell the collapse constants were fitted on; and
+   * at k \u2192 1 the collapse owns the pixel outright, so the solve's
+   * extrapolation is never evaluated against a vanishing (1 \u2212 k).
+   */
+  var solvedNeutral = neutral;
+  var solvedAlpha = sizedAlpha;
+  if (ou.flags.x > 0.5 && ou.toneAdapt.w > 0.0 && ou.toneRowThin.w > 0.0 &&
+      sizedAlpha > 1e-3 && toneAdapt < 0.995) {
+    let encodedInput = srgb_encode(ou.toneColour.w);
+    let anchor = max(ou.toneAnchor.x, 1e-4);
+    let authority =
+      smoothstep(anchor * 0.5, anchor, encodedInput) * clamp(ou.toneRowThin.w, 0.0, 1.0);
+    if (authority > 0.0) {
+      let response = tone_response(encodedInput, sizeK);
+      // The collapse's mean pull is toward L(toneColour.rgb) \u2014 the LINEAR
+      // mean, which toneAnchor.w carries \u2014 not toward the encoded level.
+      let preCollapse = (response - toneAdapt * ou.toneAnchor.w) / (1.0 - toneAdapt);
+      let neutralLuma = dot(neutral, vec3f(0.2126, 0.7152, 0.0722));
+      let nominal = (1.0 - sizedAlpha) * ou.toneAnchor.w + sizedAlpha * neutralLuma;
+      let shift = (preCollapse - nominal) / sizedAlpha * authority * ou.toneAdapt.w;
+      solvedNeutral = clamp(neutral + vec3f(shift), vec3f(0.0), vec3f(1.0));
+      /*
+       * The light attractor needs OPACITY. The light scheme's neutral is
+       * already at white, so an upward shift clamps to nothing \u2014 and the
+       * reference's light-adapted state is the material gone opaque-bright,
+       * the same "an adapting material stops transmitting" the collapse's
+       * alpha half was measured on. Whatever the clamp truncated is carried
+       * by the alpha, solved against the same composite and folded by the
+       * same authority. One-sided by design: darkward opacity is the
+       * collapse's own axis with its own fitted constants.
+       */
+      let solvedLuma = dot(solvedNeutral, vec3f(0.2126, 0.7152, 0.0722));
+      let achieved = (1.0 - sizedAlpha) * ou.toneAnchor.w + sizedAlpha * solvedLuma;
+      if (preCollapse > achieved + 1e-4 && solvedLuma > ou.toneAnchor.w + 1e-3) {
+        let alphaTarget = clamp(
+          (preCollapse - ou.toneAnchor.w) / (solvedLuma - ou.toneAnchor.w),
+          sizedAlpha,
+          1.0,
+        );
+        solvedAlpha = mix(sizedAlpha, alphaTarget, authority * ou.toneAdapt.w);
+      }
+    }
+  }
+
+  let adaptedAlpha = solvedAlpha + toneAdapt * (1.0 - solvedAlpha);
+  var adapted = solvedNeutral;
   if (toneAdapt > 0.0 && adaptedAlpha > 0.0) {
     adapted =
-      (neutral * ((1.0 - toneAdapt) * sizedAlpha) + ou.toneColour.rgb * toneAdapt) / adaptedAlpha;
+      (solvedNeutral * ((1.0 - toneAdapt) * solvedAlpha) + ou.toneColour.rgb * toneAdapt) /
+      adaptedAlpha;
   }
 
-  // The author tint. 'aux.w' is the per-pixel strength, unioned in the field pass,
-  // so a toolbar can carry one tinted control among plain ones; the seed is a
-  // group uniform. At strength 0 this is the identity and the material is the one
-  // the calibration bed measures, byte for byte.
-  //
-  // Apple's mechanism, not a fill: the seed is the middle of a range of tones
-  // 'mapped to content brightness underneath'. 'backdrop' is what this pixel is
-  // actually looking through \u2014 lens-displaced, LOD-sampled, already the thing the
-  // material transmits \u2014 so the tone is taken against the same light the tint is
-  // about to be mixed into, and a tinted surface over a dark backdrop settles to a
-  // shade of the author's colour rather than sitting on it as paint.
-  //
-  // That 'backdrop' is also where the size law's scattering has already been
-  // applied (above), and that is the right order rather than a coincidence: a
-  // large surface diffuses more of what is behind it, so the tone the tint maps
-  // to should be the diffused light, not the sharp light nobody sees through it.
-  //
-  // It displaces the ADAPTED neutral, not the raw one: a full-strength tint is its
-  // own adaptation and replaces this axis outright, while a partial one moves with
-  // it. That order is the wave's composition contract, in one line.
-  var tintColour = adapted;
-  if (aux.w > 0.0) {
-    let t = smoothstep(ou.tone.z, ou.tone.w, backdropLuma);
-    let low = ou.seed.rgb * ou.tone.x;
-    let high = ou.seed.rgb + (vec3f(1.0) - ou.seed.rgb) * ou.tone.y;
-    // 'seed.w' is the contrast regime's grip on the excursion, never on the hue:
-    // at 0 the material shows the author's colour flat and stops responding.
-    let tone = mix(ou.seed.rgb, mix(low, high, t), clamp(ou.seed.w, 0.0, 1.0));
-    tintColour = mix(adapted, tone, clamp(aux.w, 0.0, 1.0));
+  // The material, untinted: the adapted neutral over what this pixel looks
+  // through, at the material's own occlusion. That alpha is what reduced
+  // transparency lifts and what the size law thickens ("a larger size is more
+  // opaque" is a statement about how much material there is), and the backdrop
+  // adaptation moved it above. The author's colour never touches it \u2014 but not
+  // for the reason the composition contract first gave (claims \xA75.36).
+  var colour = mix(backdrop, adapted, adaptedAlpha);
+  /*
+   * How much of this pixel the SURFACE owns, as the canvas will composite it.
+   *
+   * With a backdrop the composite above is the whole pixel \u2014 the pass sampled
+   * what is behind the surface and mixed it in, so the output is opaque inside
+   * the contour and the page beneath the canvas never shows. With no backdrop
+   * the composite is not here to make: a 'css-backdrop' group's blurred
+   * backdrop is a DOM proxy under this canvas, a 'none' group's is the page
+   * itself, and the browser is the compositor. So the material leaves as a
+   * LAYER \u2014 the adapted colour at the material's own alpha, premultiplied on
+   * the way out \u2014 and every term below that would have shaped the composite
+   * shapes the layer instead, in the form that composites to the same thing.
+   *
+   * Before W11a this path mixed the material over a black backdrop and wrote
+   * it opaque: a nested surface over glass rendered as a flat 0.468 where the
+   * reference reads 0.89 (claims \xA75.38 \xA75). The rows that floored were that
+   * grey. The pair the layer is written at is the host's
+   * ('GroupRenderInput.unsampledMaterial'): the browser composites this canvas
+   * in encoded sRGB, so the alpha is the CSS tier's, not the linear profile's.
+   */
+  var bodyAlpha = 1.0;
+  if (ou.flags.x <= 0.5) {
+    colour = adapted;
+    bodyAlpha = adaptedAlpha;
   }
 
-  // The tint layer's ALPHA is untouched by the author's colour. It is the
-  // material's occlusion \u2014 what reduced transparency lifts, and the axis the
-  // system's own Clear-to-Tinted preference runs on \u2014 and an author choosing a
-  // colour does not get to move it.
+  // The author tint (W10). 'aux.w' is the per-pixel strength, unioned in the
+  // field pass, so a toolbar can carry one tinted control among plain ones; the
+  // seed is a group uniform. At strength 0 this is the identity and the material
+  // is the one the calibration bed measures, byte for byte.
   //
-  // The size law does move it, and the two do not collide: "a larger size is more
-  // opaque, a smaller size is clearer" is a statement about how much material
-  // there is, not about what colour it is. A fraction of whatever transparency
-  // the resolved alpha still has, for the reason 'increasedOcclusionLift' is a
-  // fraction \u2014 see material.ts.
+  // Apple's mechanism, measured per pixel: the tinted material is an OPAQUE
+  // layer of the seed at a shade that is linear in the luminance the untinted
+  // material shows at this pixel \u2014 about half the seed's light over black
+  // content, the seed itself over white, the seed's chromaticity intact
+  // throughout. That layer composites over the material at the AUTHOR's
+  // opacity in the encoded space, which is what a CALayer with 'opacity' does
+  // and how the reference's half-strength cell measures. So a tinted surface
+  // over a checkerboard shows the checker as light and dark ORANGE, not as
+  // orange glass with the checker behind it \u2014 the material's own alpha is not
+  // what a tinted surface shows.
   //
-  // The backdrop adaptation moves it, above, and the author's colour does not.
-  var colour = mix(backdrop, tintColour, adaptedAlpha);
+  // 'seed.w' is the contrast regime's grip on the excursion, never on the hue;
+  // 'tone.z' is the profile's provenance gate (the dark scheme renders the pure
+  // seed); and '1 \u2212 toneAdapt' folds the shade out where the collapse has made
+  // the material a dark body, where the reference renders the pure seed too.
+  // At zero grip the layer is the bare seed \u2014 the author's colour, flat.
+  if (aux.w > 0.0) {
+    // The untinted material's luminance at this pixel. Over a backdrop that is
+    // the composite; as a layer it is the layer over the tone the host measured
+    // for the group \u2014 zero where nothing was measured, the same reference-level
+    // convention the CSS tier's 'materialLuminance' takes (within its 0.02).
+    let u = bodyAlpha * dot(colour, vec3f(0.2126, 0.7152, 0.0722)) + (1.0 - bodyAlpha) * ou.toneColour.w;
+    let grip = clamp(ou.seed.w, 0.0, 1.0) * clamp(ou.tone.z, 0.0, 1.0) * (1.0 - toneAdapt);
+    let shade = mix(1.0, clamp(mix(ou.tone.x, ou.tone.y, clamp(u, 0.0, 1.0)), 0.0, 1.0), grip);
+    let layer = ou.seed.rgb * shade;
+    let s = clamp(aux.w, 0.0, 1.0);
+    let encodedMaterial = linear_to_srgb(clamp(colour, vec3f(0.0), vec3f(1.0)));
+    let encodedLayer = linear_to_srgb(layer);
+    if (ou.flags.x > 0.5) {
+      colour = srgb_to_linear(mix(encodedMaterial, encodedLayer, vec3f(s)));
+    } else {
+      // The opaque layer at the author's opacity over the material's own layer,
+      // premultiplied: the fold 'tintedCssOptics' makes into one rgba.
+      let premultiplied = (1.0 - s) * bodyAlpha * encodedMaterial + s * encodedLayer;
+      bodyAlpha = 1.0 - (1.0 - s) * (1.0 - bodyAlpha);
+      colour = srgb_to_linear(premultiplied / max(bodyAlpha, 1e-6));
+    }
+  }
 
   /*
    * Everything below is the surface's own APPEARANCE \u2014 the marks that say a
@@ -2861,21 +3157,48 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // strongest, which is what makes a thicker surface read as heavier \u2014 and the
   // shadow facet of the size law deepens it further with the span.
   let shadowDepth = ou.light.z * (1.0 + (ou.size.z - 1.0) * sizeK);
-  colour = colour * (1.0 - profile * shadowDepth * ou.light.w * present);
+  // A multiplicative occlusion of the whole composite. As a layer that is the
+  // colour scaled and the alpha raised \u2014 (k\xB7a\xB7c, 1 \u2212 k\xB7(1 \u2212 a)) composites to
+  // k times what (a\xB7c, a) would \u2014 and at bodyAlpha 1 it is the plain product.
+  let shadowKeep = 1.0 - 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) * present);
+  let rim = rw * (ou.rim.y + spec) * present;
+  if (ou.flags.x > 0.5) {
+    colour = colour + vec3f(rim);
+  } else {
+    // Added light has no premultiplied form of its own \u2014 a canvas colour may
+    // not exceed its alpha \u2014 so the layer carries the light in its opacity:
+    // (a\xB7c + rim, a + rim) composites to dst\xB7(1 \u2212 a) + a\xB7c + rim \u2212 rim\xB7dst,
+    // the additive term short of rim \xD7 dst. Exact wherever the layer is
+    // opaque (an author tint at full strength, or a lit contour pixel whose
+    // alpha the rim fills), and never further off than the rim times what
+    // shows through \u2014 where the mix form ("white over the layer at the rim's
+    // weight") is short by the rim times the whole composite, which halved
+    // the rim on a tinted panel.
+    let carried = clamp(bodyAlpha + rim, 0.0, 1.0);
+    colour = min((colour * bodyAlpha + vec3f(rim)) / max(carried, 1e-6), vec3f(1.0));
+    bodyAlpha = carried;
+  }
 
   // The material over its own shadow over the page, in one premultiplied vector:
-  // the colour is the surface's, weighted by its coverage, and the alpha is what
-  // the two of them together leave the page \u2014 'coverage' from the surface, and
-  // the shadow filling whatever transparency is left.
-  let body = encode_output(max(colour, vec3f(0.0)), coverage);
-  return vec4f(body.rgb, body.a + shadowAlpha * (1.0 - body.a));
+  // the colour is the surface's, weighted by its coverage and by however much of
+  // the pixel the layer owns, and the alpha is what the two of them together
+  // leave the page. The shadow fills only what the surface's COVERAGE leaves \u2014
+  // clipped out of the silhouette exactly as a 'box-shadow' is clipped out of
+  // its border box \u2014 never what the layer's own transparency leaves: a
+  // translucent surface shows the page through it, not its own shadow. (With
+  // an opaque body the two are the same quantity, which is how the shadow was
+  // first written and why the difference only surfaced with the layer form.)
+  let body = encode_output(max(colour, vec3f(0.0)), coverage * bodyAlpha);
+  return vec4f(body.rgb, body.a + shadowAlpha * (1.0 - coverage));
 }`;
 
 // ../renderer-webgpu/dist/wgsl/prelude.js
@@ -3122,7 +3445,7 @@ function createPassRunner(context) {
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 60);
+      const slot = uniformSlot(`optics:${args.groupId}`, 76);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -3133,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];
@@ -3148,10 +3471,10 @@ function createPassRunner(context) {
       d[21] = args.tintSeed[1];
       d[22] = args.tintSeed[2];
       d[23] = args.tintToneAdaptation;
-      d[24] = args.tintTone[0];
-      d[25] = args.tintTone[1];
-      d[26] = args.tintTone[2];
-      d[27] = Math.max(args.tintTone[3], args.tintTone[2] + 1e-4);
+      d[24] = args.tintShade[0];
+      d[25] = args.tintShade[1];
+      d[26] = args.tintShade[2];
+      d[27] = args.sizeFold;
       d[28] = args.rimWidth;
       d[29] = args.rimAlpha;
       d[30] = args.specularPower;
@@ -3184,6 +3507,22 @@ function createPassRunner(context) {
       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;
@@ -3240,9 +3579,9 @@ function createPassRunner(context) {
       d[22] = args.backdropTone[2];
       d[23] = args.backdropTone[3];
       d[24] = args.backdropToneLevel;
-      d[25] = 0;
-      d[26] = 0;
-      d[27] = 0;
+      d[25] = args.sizeSpanMin;
+      d[26] = args.sizeSpanMax;
+      d[27] = args.sizeFold;
       const fieldRect = args.fieldRectDevice;
       d[28] = args.rectDevice.width / Math.max(fieldRect.width, 1e-6);
       d[29] = args.rectDevice.height / Math.max(fieldRect.height, 1e-6);
@@ -3433,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();
@@ -3508,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, bodySigmaTexels) {
+  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;
@@ -3546,7 +3890,10 @@ function createPyramidStore(context) {
       stats,
       sizeEpoch,
       builtEpoch,
-      bodySigmaTexels
+      bodySigmaTexels,
+      texelsPerCss: density.texelsPerCss,
+      sourceWidth: density.sourceWidth,
+      sourceHeight: density.sourceHeight
     };
     resources.set(sourceId, next);
     return next;
@@ -3734,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 };
       }
@@ -3752,12 +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 bodySigmaTexels = request.bodySigmaCss * cover * planScale;
+      const bodySigmaTexels = request.bodySigmaCss * texelsPerCss * planScale;
       const bodyPlan = bodyBlurPlan(bodySigmaTexels, plan);
-      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels);
+      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels, { texelsPerCss, sourceWidth: frame.width, sourceHeight: frame.height });
       runImport(encoder, request.sourceId, frame, target.chain);
       runChain(encoder, request.sourceId, plan, target.chain);
       runBodyBlur(encoder, request.sourceId, plan, target.chain, target.body, bodyPlan.level, bodyPlan.residualSigmaTexels);
@@ -3873,8 +4219,11 @@ var RENDERER_PASS_IDS = [
   OPTICS_PASS_ID,
   HIGHLIGHT_PASS_ID
 ];
+var STANDALONE_RESOLUTION = { scale: 1, maxDimension: 2048 };
 function createWebGPURenderer(options = {}) {
   const providers = /* @__PURE__ */ new Map();
+  const placements = /* @__PURE__ */ new Map();
+  const lastResolution = /* @__PURE__ */ new Map();
   const groups = /* @__PURE__ */ new Map();
   const adaptation = /* @__PURE__ */ new Map();
   const lastReadbackAt = /* @__PURE__ */ new Map();
@@ -3963,15 +4312,30 @@ 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";
@@ -3987,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;
@@ -4006,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)
       });
     }
@@ -4024,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;
@@ -4107,19 +4478,24 @@ function createWebGPURenderer(options = {}) {
       });
       const state = stateOf(input, resolution);
       const variant = variantOf(input);
-      const optics = opticsUnderPolicy(material.optics[variant], policy, material);
+      const sourceId = input.backdropSourceId;
+      const pyramid = sourceId === void 0 ? void 0 : pyramids.resources(sourceId);
+      const adapt = sourceId === void 0 ? void 0 : adaptationFor(sourceId).values;
+      const nominalOptics = material.optics[variant];
+      const optics = opticsUnderPolicy(pyramid === void 0 && input.unsampledMaterial !== void 0 ? {
+        ...nominalOptics,
+        tint: input.unsampledMaterial.tint,
+        tintAlpha: input.unsampledMaterial.tintAlpha
+      } : nominalOptics, policy, material);
       const backdropTone = [
         material.backdropToneLow,
         material.backdropToneHigh,
         backdropToneSizeBiasUnderPolicy(policy, material),
         input.backdropTone === void 0 ? 0 : backdropToneUnderPolicy(policy, material) * material.backdropToneMax
       ];
-      const backdropToneLevel = input.backdropTone === void 0 ? 0 : relativeLuminance(input.backdropTone);
+      const backdropToneLevel = input.backdropTone === void 0 ? 0 : input.backdropToneLevel ?? relativeLuminance(input.backdropTone);
       const refraction = effectiveRefraction(accessibilityRefractionCap(policy), state.refraction);
       const refractionScale = material.refractionScale[refraction];
-      const sourceId = input.backdropSourceId;
-      const pyramid = sourceId === void 0 ? void 0 : pyramids.resources(sourceId);
-      const adapt = sourceId === void 0 ? void 0 : adaptationFor(sourceId).values;
       passes.opticsPass(encoder, {
         groupId: input.groupId,
         target: active.optics,
@@ -4129,10 +4505,9 @@ 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,
@@ -4152,12 +4527,7 @@ function createWebGPURenderer(options = {}) {
          */
         tintSeed: (policy.glass === "none" ? void 0 : groupTintSeed(input)) ?? optics.tint,
         tintToneAdaptation: tintToneAdaptation(policy, material),
-        tintTone: [
-          material.tintToneFloor,
-          material.tintToneCeilMix,
-          material.tintToneLow,
-          material.tintToneHigh
-        ],
+        tintShade: [material.tintShadeDark, material.tintShadeLight, material.tintShadeStrength],
         rimWidth: optics.rimWidth,
         rimAlpha: optics.rimAlpha,
         specularPower: optics.specularPower,
@@ -4174,6 +4544,14 @@ function createWebGPURenderer(options = {}) {
         sizeOcclusionGain: material.sizeOcclusionGain,
         sizeShadowGainMax: material.sizeShadowGainMax,
         bodyChainLod: chainLodForSigma(pyramid?.bodySigmaTexels ?? 0),
+        // The size law's curves (W11c): the shader evaluates the thickness and
+        // the scatter mix per pixel from the span the field carries, under the
+        // same fold `sizeThicknessUnderPolicy` applies on the CPU.
+        sizeSpanMin: material.sizeSpanMin,
+        sizeSpanMax: material.sizeSpanMax,
+        sizeScatterFloor: material.sizeScatterFloor,
+        sizeScatterSpanMax: material.sizeScatterSpanMax,
+        sizeFold: material.refractionScale[accessibilityRefractionCap(policy)],
         backdropTone,
         backdropToneColour: [
           input.backdropTone?.[0] ?? 0,
@@ -4181,6 +4559,25 @@ function createWebGPURenderer(options = {}) {
           input.backdropTone?.[2] ?? 0,
           backdropToneLevel
         ],
+        // The response law's anchors (W9) and the linear backdrop mean its
+        // solve composites against. The shader re-derives the encoded input
+        // from `backdropToneLevel`, so the fourth slot carries the linear
+        // mean — the one quantity the solve needs that the tone colour does
+        // not already hold.
+        backdropToneAnchorX: material.backdropToneAnchorX,
+        backdropToneResponseThin: material.backdropToneResponseThin,
+        backdropToneResponseThick: material.backdropToneResponseThick,
+        // The response law rides only the UN-DEGRADED regime, for the same
+        // provenance reason the dark profiles set its strength to 0: the
+        // anchors are standard-light-reference measurements, and the
+        // accessibility references behave differently (nearly opaque, flat in
+        // span — W2). Measured before this gate existed: reduced-transparency
+        // photo ΔE p95 0.007 → 0.048 and cross-tier ratio 0.99 → 0.86. Where
+        // any policy fold touches the tone axis, the solve stands down and the
+        // collapse alone runs, exactly the pre-W9 behaviour those profiles
+        // were fitted on.
+        backdropToneResponseStrength: backdropToneUnderPolicy(policy, material) >= 0.999 ? material.backdropToneResponseStrength : 0,
+        backdropToneLinearMean: input.backdropToneLinearLuminance ?? backdropToneLevel,
         outerShadow: [
           outerShadowAlpha(shadow.occlusion),
           shadow.sigmaPx,
@@ -4219,9 +4616,13 @@ function createWebGPURenderer(options = {}) {
           glowGain: material.glowGain,
           colour: optics.highlight,
           // The same four numbers the optics pass took, so the two passes fade
-          // the surface on one curve rather than on two copies of it.
+          // the surface on one curve rather than on two copies of it — and the
+          // same band and fold, since the curve is evaluated off the span.
           backdropTone,
-          backdropToneLevel
+          backdropToneLevel,
+          sizeSpanMin: material.sizeSpanMin,
+          sizeSpanMax: material.sizeSpanMax,
+          sizeFold: material.refractionScale[accessibilityRefractionCap(policy)]
         });
       }
       drawn += 1;
@@ -4286,6 +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;
@@ -4298,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;
@@ -4454,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, BACKDROP_TONE_HIGH, BACKDROP_TONE_LOW, BACKDROP_TONE_MAX, BACKDROP_TONE_SIZE_BIAS, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_BODY_LOD_PER_PX, LENS_RIM_LOD_BIAS, LENS_SIZE_GAIN_MAX, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTER_SHADOW, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SIZE_OCCLUSION_GAIN, SIZE_SCATTER_GAIN_MAX, SIZE_SHADOW_GAIN_MAX, SIZE_SPAN_MAX, SIZE_SPAN_MIN, SRGB_ENCODING_EXPONENT, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptedTintAlpha, adaptedTintColour, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, backdropToneAdaptation, backdropToneSizeBiasUnderPolicy, backdropToneUnderPolicy, bodyBlurPlan, bodyLod, chainModule, clipFieldRectToCanvas, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, highlightModule, importColorMatrix, importModule, importPassSource, lensDepthPx, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowReachPx, outerShadowUnderPolicy, packInstances, pipelineKey, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, tintTone, tintToneAdaptation, tintedTintColour, validateAppTexture, withMaterialOverrides };
-//# sourceMappingURL=dist-RQ4ZMA3D.js.map
-//# sourceMappingURL=dist-RQ4ZMA3D.js.map
+export { ADAPTIVE_LUMINANCE_HIGH, ADAPTIVE_LUMINANCE_LOW, ADAPTIVE_TINT_DARK, ADAPTIVE_TINT_LIGHT, ANALYSIS_DISPATCH, ANALYSIS_GRID, ANALYSIS_PASS_ID, ANALYSIS_STATS_FLOATS, ANALYSIS_TARGET_EXTENT, ANALYSIS_WORKGROUP, BACKDROP_ALPHA_MODES, BACKDROP_COLOR_SPACES, BACKDROP_KINDS, BACKDROP_PASS_ID, BACKDROP_TONE_HIGH, BACKDROP_TONE_LOW, BACKDROP_TONE_MAX, BACKDROP_TONE_SIZE_BIAS, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDENTITY_FIT, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_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