@vitreajs/vitrea 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1638,6 +1638,33 @@ interface MaterialRim {
  * occlusion over 142,550 pixels on the finest cell, and the same three lengths
  * describe every profile, backdrop, span and scale in the bed.
  *
+ * ## Two terms on ONE falloff (W14 G0, claims §5.62)
+ *
+ * The description above holds where W8 measured it and misses two things the bed
+ * has since shown, both of which live in the AMPLITUDE and neither of which
+ * moves a length. Outside the coverage, in the compositing (encoded) domain:
+ *
+ *     out = bg · (1 − α_b(backdrop, span) · F(d))  +  A_v(span) · F(d) · V
+ *
+ * with **one** falloff `F` — W8's own, at 15.55 / 7.95 / 3.1, re-read free and
+ * unmoved on both terms (σ 14.8–16.2 and offset 7.93–8.00 for the black term,
+ * σ 14.1–17.1 and offset 7.6–8.4 for the lift) — and `V` the backdrop's own
+ * light blurred at `liftBlurSigmaCss`.
+ *
+ * The first term's amplitude ADAPTS below the knee: the reference's fill alpha
+ * is 0.33 over the mid backdrops, 0.127 over `light-solid` and nothing over
+ * black, keyed on the SAME backdrop luminance statistic W9's face response uses
+ * (the ENCODED-space mean, decoded — `backdropToneAnchorX`'s own axis), through
+ * the same thickness curve that gates that regime. Above the knee it is the
+ * composite's transmission by span. The second term is the lift, GPU-tier only,
+ * and it is exactly zero below the knee and exactly zero over black, so the
+ * facet's "invisible over a black backdrop" property survives both terms.
+ *
+ * The layer tree's `inputShadowAmount` and `inputShadowHeight` are NOT either
+ * term's spatial extent — the charter's advisory was wrong there, and G0's free
+ * fits overturned it. Only `inputShadowBlurRadius` 40 belongs to the lift, as
+ * the blur of the backdrop it copies.
+ *
  * **Multiplicative, and not additively.** Mirrored pixel pairs either side of a
  * capsule over the `photo` backdrop see the same shadow over different backdrop
  * luminances: the darkening's ratio tracks the backdrop's ratio to 4.5% while a
@@ -1666,22 +1693,151 @@ interface MaterialOuterShadow {
     /** Outward spread of the silhouette before the blur, CSS px. */
     readonly spreadPx: number;
     /**
-     * Peak occlusion: the fraction of the backdrop's own LINEAR light removed deep
-     * inside the shadow. Zero stands the whole facet down, pad and all.
+     * The black term's peak occlusion below the knee, over a backdrop the material
+     * cannot see (linear luminance ≤ `OUTER_SHADOW_THIN_L.inert`): zero. Inert
+     * over `dark-solid` and `impulse`, which is what the reference does — it
+     * removes at most one or two of 255 codes there (claims §5.62 §5).
+     */
+    readonly thinOcclusionDark: number;
+    /**
+     * The black term's peak occlusion below the knee over the MID plateau —
+     * backdrop linear luminance `OUTER_SHADOW_THIN_L.midFrom` … `midTo`.
+     *
+     * MEASURED (claims §5.62 §5): linear occlusion 0.347 over `mid-dark-solid`,
+     * 0.334–0.339 over `photo`, 0.327–0.328 over the checkerboard and 0.329 over
+     * `hc-text` — flat across a backdrop luminance range of 0.06…0.74, and a
+     * constant 1.16–1.19× the fill alpha §5.50 §2 read off the layer tree.
+     */
+    readonly thinOcclusionMid: number;
+    /**
+     * The black term's peak occlusion below the knee over a BRIGHT backdrop, at
+     * `OUTER_SHADOW_THIN_L.bright` and above.
+     *
+     * MEASURED (claims §5.62 §5): 0.127 over `light-solid` (linear luminance
+     * 0.891), against the layer tree's tabulated 0.05 — so the reference's shadow
+     * there is 0.39 of its shadow over the checkerboard, not one sixth. W8's
+     * single 0.285 everywhere is 2.24× this, which is the whole of the user's
+     * by-eye "the shadow is darker on the light-solid capsule" and, by the free
+     * geometry fit on that cell (σ 14.81 / offset 7.97 / spread 3.17), no part of
+     * it is shape.
      */
-    readonly occlusion: number;
+    readonly thinOcclusionBright: number;
     /**
-     * What reduced transparency does to `occlusion` — MEASURED, not assumed, which
-     * is what the charter asked for before the fold was written.
+     * The COMPOSITE occlusion above the knee at a casting span of 96 CSS px.
+     *
+     * FITTED in the renderer (claims §5.65), from G0's measurement of the
+     * composite's transmission (0.379 on the checkerboard at span 96) to **0.370**.
+     * It had to be fitted rather than adopted, because what G0 could identify at
+     * the bed's noise floor is the composite transmission and the lift's peak
+     * amplitude, not the split into (black alpha, vibrant alpha, vibrant colour):
+     * both terms ride one falloff and their shapes correlate at 0.9998. So this
+     * constant is the BLACK term of a two-term composite whose second term
+     * (`liftAmplitude`) was fitted beside it, on X7's affine pair, and the pair is
+     * what the referee reads.
+     */
+    readonly thickOcclusionAt96: number;
+    /** The same at a casting span of 128 CSS px — FITTED to 0.448 from G0's
+     * measured 0.497, for `thickOcclusionAt96`'s reason (claims §5.65). */
+    readonly thickOcclusionAt128: number;
+    /**
+     * The same at a casting span of 160 CSS px — **UNFITTED**, and the one anchor
+     * in this block that no calibration cell reaches.
+     *
+     * Every span above 128 in the bed is holdout, so 0.479 is carried by the stated
+     * derivation from the two fitted anchors and not by a fit. The holdout, read
+     * once and fitted to nothing, says it is 15% heavy (band `1 − a` 0.2436 against
+     * the reference's 0.2117) and implies about 0.437 — which is BELOW the fitted
+     * At128 and which no extrapolation from the calibration cells would have
+     * produced. That reading is recorded and deliberately not adopted (claims §5.65
+     * §4(b) and §6(iv)); closing it needs a calibration cell above span 128.
+     */
+    readonly thickOcclusionAt160: number;
+    /**
+     * **The lift (W14)** — the peak amplitude of the second term, in LINEAR light,
+     * as a fraction of the backdrop's own blurred luminance. GPU tier only.
      *
-     * The reference's shadow under `reduce transparency` is the same shadow at
-     * 0.566 of the amplitude: 0.1830/0.3259, 0.1884/0.3309 and 0.1882/0.3314 on the
-     * three structured backdrops at a 44 px span, with σ, offset and spread
-     * unmoved. It does not vanish and it does not intensify.
+     * The reference's thick shadow does not only remove light: on the
+     * checkerboard's black squares, where a multiply is inert by construction, it
+     * ADDS 7.4 of 255 (claims §5.62 §2). Pooled over six backdrops the addition
+     * regresses on the σ-40 blurred backdrop at slope 0.0444 with intercept
+     * −0.0042 and R² 0.983 — it is the backdrop's own light, blurred, composited
+     * under the shadow, with no fixed colour left over. Zero over `impulse`, zero
+     * over `dark-solid`, and zero below the knee, so the facet stays exactly inert
+     * over black the way W8's multiply is.
+     *
+     * FITTED to **0.0100** in the renderer over seventeen sweep passes, read on
+     * X7's affine pair together with the three thick anchors (claims §5.65). The
+     * provisional 0.0073 was G0's +0.0038 of LINEAR lift at span 160 divided by
+     * the ≈ 0.52 linear luminance the checkerboard's σ-40 blur sits at, and the fit
+     * is 37% larger. The space matters and this wave names it everywhere (claims
+     * §5.62 §3): §5.60's +0.039 is the same lift read in ENCODED luma.
+     */
+    readonly liftAmplitude: number;
+    /**
+     * Where the lift starts, in casting span, CSS px — the thin/thick knee, and it
+     * is exact: the lift reads 0.0000 at spans 32 and 44 and is present at 96
+     * (claims §5.62 §2). The layer tree's own `VibrancyContribution` clamps from
+     * the same 64.
+     */
+    readonly liftSpanMin: number;
+    /**
+     * Where the lift saturates, in casting span, CSS px.
+     *
+     * FITTED to **118** (claims §5.65), from a provisional 128. The measured rise
+     * is 0.52 / 0.96 / 1.00 of the span-160 value at spans 96 / 128 / 160, against
+     * the layer tree's clamp((span − 64)/96) = 0.33 / 0.67 / 1.00 — so the lift is
+     * NOT proportional to `VibrancyContribution`; it rises and saturates, reaching
+     * 96% by span 128 (claims §5.62 §2), which a smoothstep from `liftSpanMin`
+     * reproduces and the clamp does not. The holdout says the reach saturates a
+     * little early — the lift's own residual there is one-signed and small, 5% low
+     * at span 130 and 9% at 160 (claims §5.65 §4(d)) — and it was not refitted
+     * after that reading.
+     */
+    readonly liftSpanFull: number;
+    /**
+     * The σ, in CSS px, of the blur the lift copies the backdrop through.
+     *
+     * MEASURED at 40 ± 8 CSS px on `rrect-lg` at both scales and in two rings, by
+     * the probes' pitch axis — the pooled residual has a real minimum there, 12%
+     * below the flat-copy residual (claims §5.62 §3). It is the layer tree's
+     * `inputShadowBlurRadius` 40 read as a Gaussian standard deviation. NOT
+     * identifiable on the mid spans (flat to 0.7%), and reported as such rather
+     * than fitted there.
+     */
+    readonly liftBlurSigmaCss: number;
+    /**
+     * The shadow's amplitude UNDER reduced transparency — one absolute linear
+     * occlusion that replaces both regimes, not a factor on either. MEASURED,
+     * which is what the charter asked for before the fold was written.
+     *
+     * **0.197 (measured 0.192–0.202).** W14 G0 read the preference on the wider
+     * bed and what it found is a flat number: the reference's exterior is
+     * 0.192–0.202 under increased contrast and reduced transparency alike, **thin
+     * and thick together** and over every backdrop it can be read on (claims §5.62
+     * §5). The preference removes the material's adaptation, so the shadow it
+     * leaves has neither the thin regime's backdrop keying nor the thick regime's
+     * span law in it — one amplitude for every surface over every backdrop, which
+     * is what `outerShadowUnderPolicy` writes into all six anchors. The lift goes
+     * with it: a composite whose two regimes read the same number has no second
+     * term left in it.
+     *
+     * It is stated as an ABSOLUTE occlusion rather than as a ratio because W8's
+     * 0.70 multiplier was fitted when the amplitude was one span-flat number and a
+     * ratio was the same thing as a level. It is not any more: multiplying six
+     * unequal anchors keeps exactly the backdrop and span variation the preference
+     * removes, and a span-160 surface over a mid-tone backdrop folded to 0.38
+     * against the reference's 0.20. The number the reference states is a level, so
+     * this constant is a level.
+     *
+     * Nothing is special-cased for a dark backdrop and nothing needs to be: an
+     * occlusion is a fraction of the backdrop's own light, so a flat 0.197 over
+     * black still removes nothing, and the facet stays as inert there as the thin
+     * regime's own zero anchor makes it without the preference.
      *
      * The `increased contrast` reference reproduces the reduced-transparency
-     * amplitude to four decimals (0.1830, 0.1884, 0.1882 — the same numbers), which
-     * is Decision Log 8's finding again: macOS force-couples the two toggles, so the
+     * amplitude to four decimals (0.1830, 0.1884, 0.1882 on the three structured
+     * backdrops at a 44 px span, with σ, offset and spread unmoved), which is
+     * Decision Log 8's finding again: macOS force-couples the two toggles, so the
      * contrast reference IS the reduced-transparency state and the bed cannot
      * separate them. The fold therefore keys on `frost`, the axis reduced
      * transparency alone sets, rather than on the contrast axes it would be
@@ -1751,8 +1907,9 @@ interface MaterialProfile {
      * on it — the lens (`lensSizeGainMax`), the occlusion (`sizeOcclusionGain`)
      * and the inner shadow (`sizeShadowGainMax`). The scattering was one of them
      * until W11c measured its curve to be a different one (a floor at small
-     * spans, a band top past 96 — see `sizeScatterFloor`); it now rides its own,
-     * from the same `sizeSpanMin`, and this band is untouched by it.
+     * spans, a rise past 96) and W13 measured that curve to be the projection of a
+     * ramp in depth — see `sizeScatterFloor` and `sizeScatterRampStartThin1x`; the
+     * scattering now rides its own law entirely, and this band is untouched by it.
      *
      * A smoothstep rather than a straight ratio, so two surfaces of nearly the same
      * size never read as differently thick, and so every gain saturates instead of
@@ -1770,12 +1927,17 @@ interface MaterialProfile {
     readonly sizeSpanMin: number;
     readonly sizeSpanMax: number;
     /**
-     * The lens's gain on the size curve — "more pronounced lensing and refraction".
+     * The inner shadow's depth gain on the size curve — and, until W12 G2, the
+     * lens's too.
      *
-     * `lensDepthPx` is `thickness × lensSizeGain(span)`, clamped to the shorter
-     * *half* extent. The clamp is what keeps a small control from being all lens: a
-     * 24 px-tall button cannot bend more than 12 px of backdrop however thick it is
-     * authored.
+     * The inner shadow's depth is `thickness × (1 + (lensSizeGainMax − 1) ×
+     * sizeThickness)`, clamped to the shorter *half* extent, and its profile is
+     * `(1 − depth)²` on that depth: the landed law of W2, kept byte-for-byte for the
+     * occlusion because nothing measured it as wrong. The LENS no longer reads it —
+     * the reference's own lens height is a clamped linear function of the span
+     * (`lensHeightPerSpan`, `lensHeightMax`), read straight from its layer tree
+     * (claims §5.50), and the lens takes that law from W12 G2 on. The name stays so
+     * the profile documents keep naming the constant they measured.
      */
     readonly lensSizeGainMax: number;
     /**
@@ -1799,37 +1961,329 @@ interface MaterialProfile {
      * chain level whose blur is that σ.
      *
      * MEASURED (W11c G1, claims §5.41), and no longer a gain on `sizeThickness`
-     * alone — see `sizeScatterFloor` and `sizeScatterSpanMax` below for the curve
-     * it rides. 8: the heavy component of the reference's interior sits near σ 10
-     * CSS px against a body σ of 1.25, and the gain sweep has a clear minimum at
-     * 8 (RMS 0.0164 against 0.0180 at 6 and 0.0191 at 10 on the probe bed).
+     * alone — see `sizeScatterFloor` and `sizeScatterRampStartThin1x` below for the
+     * law it rides. 8: the heavy component of the reference's interior sits near
+     * σ 10 device px against a body σ of 1.25, and the gain sweep has a clear
+     * minimum at 8 (RMS 0.0164 against 0.0180 at 6 and 0.0191 at 10 on the probe
+     * bed).
      */
     readonly sizeScatterGainMax: number;
     /**
-     * **The scattering facet's own curve** (W11c G1, claims §5.41).
+     * **The scattering facet's frost** (W11c G1, claims §5.41; re-read by W13 G1).
      *
      * The reference's interior over structured content is two components, read
      * off the W9 probe bed across four checkerboard pitches and five spans: a
-     * sharp one near σ 1.25 CSS px and a heavy one near σ 10, mixed by a share
-     * that is already ≈ 0.4 at spans of 32–44 and still rising at 160 (0.52 at
-     * 96, 0.64 at 128, 0.76 at 160). `sizeThickness` — zero at `sizeSpanMin` and
-     * saturated at `sizeSpanMax` = 96 — can express neither the floor nor a band
-     * top past 96, and moving `sizeSpanMax` would move the lens, the occlusion,
-     * the inner shadow and W9's thin/thick response rows with it. So the scatter
-     * mix rides its own curve:
+     * sharp one near σ 1.25 device px and a heavy one near σ 10, mixed by a share
+     * that is already ≈ 0.4 at spans of 32–44 and still rising at 160. W11c
+     * carried that mix as one number per span, a floor rising by a smoothstep to
+     * a band top (`sizeScatterSpanMax`); W13 G0 measured the mix **per depth** on
+     * both probes and found a ramp under the contour that the span law had been
+     * summarising (claims §5.61 §2). W13 G1's first form replaced the span law
+     * with the ramp outright and its runtime sweep refuted that: the ramp's own
+     * projection onto one number per surface runs 0.43–0.56 where the span law it
+     * replaced runs 0.41–1.00, so a ramp with a start and a reach is nearly
+     * span-flat where the bed is strongly span-graded, and no point in 81 reached
+     * the wave's stops (`results/2026-09-03-w13-ramp/g1/sweep/g1-sweep.md` §4,
+     * §7). So the two are kept **together**: the span law is the ramp's DEEP
+     * value and the ramp is a near-contour excursion above it. This floor is
+     * unchanged in value and in meaning under either: the mix a surface carries
+     * at any size, the material's own frost.
+     *
+     * It keeps its fold semantics, and they are now written on the ramp rather
+     * than on a span curve:
      *
      * ```
-     * kScatter = floor + (1 − floor) · smoothstep(sizeSpanMin, sizeScatterSpanMax, span) · fold
+     * kScatter(u) = floor + (k(u) − floor) · fold
      * ```
      *
-     * The floor is the material's own frost and is **not** folded under an
-     * accessibility preference; the span-dependent rise is a depth effect and
-     * folds like every other facet (`scatterThickness`). Fitted with `rrect-lg`
-     * held out: floor 0.40 (0.0175 at 0.3, 0.0174 at 0.45), band top 256 (0.0182
-     * at 224, 0.0174 at 320); the held-out cell's residual 0.0366 → 0.0174.
+     * — so at fold 1 the ramp is rendered exactly and at fold 0 the material sits
+     * at this floor exactly, which is what the landed law did at fold 0 too. The
+     * floor is the frost the material has whatever its size, and is **not**
+     * folded under an accessibility preference; the excursion away from it is
+     * depth, and is. Fitted with `rrect-lg` held out (W11c G1): 0.40 (0.0175 at
+     * 0.3, 0.0174 at 0.45).
      */
     readonly sizeScatterFloor: number;
+    /**
+     * **The scattering facet's span curve** (W11c G1, claims §5.41) — the top of
+     * the band the frost rises to, and, since W13 G1's re-forming, the span law
+     * that supplies the depth ramp's DEEP value:
+     *
+     * ```
+     * kDeep(span) = floor + (1 − floor) · smoothstep(sizeSpanMin, sizeScatterSpanMax, span)
+     * ```
+     *
+     * — byte for byte the curve W11c fitted and W13 G1's first form retired. It
+     * came back because the sweep measured what retiring it cost (§4 of
+     * `results/2026-09-03-w13-ramp/g1/sweep/g1-sweep.md`): the span dependence of
+     * the bed is real and strong, and the ramp's four constants cannot carry it
+     * at the same time as the band's near-contour excursion. What the ramp adds
+     * is what this curve never could — the depth structure inside one surface —
+     * and it now adds it on top of this rather than instead of it, so the deep
+     * interior of every span is exactly where W11c and W12 put it.
+     *
+     * `sizeThickness` — zero at `sizeSpanMin` and saturated at `sizeSpanMax` = 96
+     * — can express neither the floor nor a band top past 96, and moving
+     * `sizeSpanMax` would move the lens, the occlusion, the inner shadow and W9's
+     * thin/thick response rows with it, which is why the scatter mix has its own
+     * curve at all. Fitted with `rrect-lg` held out (W11c G1): band top 256
+     * (0.0182 at 224, 0.0174 at 320); the held-out cell's residual 0.0366 →
+     * 0.0174.
+     */
     readonly sizeScatterSpanMax: number;
+    /**
+     * **The body's second scale** (W15 G1, from the measurement of claims §5.69
+     * §1–§2) — the heavy width's gain, the deep value's floor and the deep
+     * value's span top, each read again at dpr 2.
+     *
+     * At 2x the reference's body is a different object from the one the three
+     * constants above describe, and §5.69 measured all of it: the deep interior
+     * is FULLY heavy on the two largest spans and 0.90–0.95 heavy on `rrect-md`
+     * (§2), where the 1x span curve leaves a sharp share of 0.24–0.36 there, and
+     * the heavy component's own width is 8–11 device px against the 1x law's 10
+     * CSS px (§1). One curve fitted at 1x cannot be both, so the deep value's two
+     * constants and the gain get a second reading rather than a scale factor —
+     * the same shape the ramp's anchors already have.
+     *
+     * Each is interpolated by `rampAtScale`: held at the 1x constant at dpr ≤ 1,
+     * at this one from dpr 2 up, linear between. **At dpr 1 every one of them is
+     * inert by construction, whatever it says** — W15's binding rule — so the 1x
+     * material is byte-identical to the W13 bed and the landing's confirmation
+     * measured exactly that: 49 of 49 1x GPU cells identical to the bed with
+     * every capture byte-identical (claims §5.70 §8).
+     *
+     * Consumed at draw time, not folded into a constant: `scatterDeepThickness`
+     * takes the ratio for the floor and the span top, the renderer resolves all
+     * three from the viewport's own ratio and hands them to the optics pass
+     * through the uniforms the shader already reads (`scatter.x`, `lensOval.w`
+     * and `size.x`), and `scatterThickness`, `scatterSharpShare` and the ramp's
+     * area-average projection read the resolved deep value.
+     *
+     * **FITTED** by W15 G1's runtime sweep at
+     * `--profile apple-macos-26.5-2x-light-standard` on the calibration set, the
+     * holdout untouched, and landed at the values below (claims §5.70 §2 and §8;
+     * the four sweeps `results/2026-09-04-w15-body-2x/g1/stage1..stage3` and the
+     * confirmation `confirm-3`, whose 2x holdout was read once for this
+     * configuration). The rule W13 wrote after the paper model over-credited the
+     * mip chain's heavy tap (§5.58 §1) held: no constant here lands on a paper
+     * prediction, and the sweep contradicted the paper estimate.
+     *
+     * **The gain, 4.8.** Stage 2c swept it over 4.0 / 4.4 / 4.8 / 5.2 at the
+     * chosen base and found an INTERIOR MINIMUM at 4.8 — the interior spread
+     * against native reading 0.0335 / 0.0214 / 0.0120 / 0.0217 with the band's
+     * rise at its top too. Through `bodySigmaCssFor` that is a heavy width of
+     * **6 device px** at dpr 2, NARROWER than the 8–11 device px §5.69 §1
+     * bounded as a Gaussian: the estimator carries ±40% on a real capture of a
+     * known law (§5.69 §3) and the mip chain's tap is not a Gaussian, so the
+     * renderer is the fitting instrument and 6 is the width it draws best.
+     *
+     * **The floor, 1.0** — the deep value FULLY heavy at dpr 2, which is what
+     * G0's deep windows read on the two largest spans (§5.69 §2). `kDeep` is
+     * therefore 1 at every span at this ratio, and the depth ramp above it is the
+     * whole body (§5.70 §1).
+     *
+     * **The span top, 256** — the 1x value, unchanged, because a floor of 1
+     * leaves the deep value nothing to rise to and the top has no work at this
+     * ratio. Stage 1 swept it against 128 and the bed did not ask for the change.
+     */
+    readonly sizeScatterGainMax2x: number;
+    readonly sizeScatterFloor2x: number;
+    readonly sizeScatterSpanMax2x: number;
+    /**
+     * **The heavy width's gain at the TOP of the scatter span curve, at dpr 2**
+     * (W15 G1's re-form, from claims §5.70 §4 and §7 and the measurement of
+     * §5.69 §1) — the second-scale term that lets the 2x heavy width GROW with
+     * the span instead of being one number for the whole bed.
+     *
+     * `sizeScatterGainMax2x` above is one gain at dpr 2, and the sweep that fitted
+     * it read the calibration cells, whose spans are 32–128. The reference's heavy
+     * kernel is not one width: §5.69 §1's bounded per-span fit reads 8.0 / 7.5 /
+     * 8.0 / 9.0 / 11.0 device px across the bed's spans, a ratio of 1.375 between
+     * span 160 and span 96. Landing the single gain accordingly left the largest
+     * span's deep interior about 40% too structured (`rrect-lg` at 2x, spread
+     * 0.1134 against the reference's 0.0810, claims §5.70 §4) while every smaller
+     * cell rose. So the gain takes a second grading, in SPAN:
+     *
+     * ```
+     * gain(span, dpr) = gainAtScale(dpr)
+     *                 + (gainFar(dpr) − gainAtScale(dpr))
+     *                   · smoothstep(sizeSpanMax, sizeScatterSpanMax(dpr), span)
+     * ```
+     *
+     * with `gainAtScale` the existing `scatterGainAtScale` and `gainFar` this
+     * constant interpolated by `rampAtScale` from `sizeScatterGainMax`. The curve
+     * is not a new span statistic: it is the same smoothstep the fourth form's
+     * far-anchor decline already rides (`scatterRampStart`), so the width and the
+     * ramp's start move along one curve above the thickness knee.
+     *
+     * **Inert at dpr 1 by construction.** `gainFar` interpolates from
+     * `sizeScatterGainMax` — the 1x gain, not this constant — so at dpr ≤ 1 the
+     * far gain IS the base gain and the whole term is a flat no-op whatever this
+     * says. That is W15's binding rule (the 1x material does not move) discharged
+     * by the shape of the formula rather than by a capture.
+     *
+     * **LANDED at 9.9** (claims §5.70 §8; W15 Decision Log 3, the user's landing
+     * "the re-form"), and the value is G0's rather than the holdout row's: §5.69
+     * §1's bounded per-span reading is 8 device px at span 96 and 11 at 160, a
+     * ratio of 1.375, and this curve reads 0.352 at span 160, so 4.8 + (9.9 −
+     * 4.8) · 0.352 reproduces that ratio over the base gain of 6 device px. The
+     * heavy width at dpr 2 is therefore 6.0 device px at spans ≤ 96, 6.7 at 128,
+     * 8.2 at 160 and 12.4 at 256 and beyond. The calibration cells neither chose
+     * the value nor rejected it — `stage3` swept 4.8 / 7.5 / 9.9 / 12.5 and only
+     * `rrect-ml` (span 128, a tenth of the grading) moves, its interior spread
+     * 0.1125 → 0.0993 against native 0.1018 at 9.9, which is the sweep's best on
+     * its own objective. The confirmation's holdout `rrect-lg` rose 0.9661 →
+     * 0.9762 with its interior spread 0.0721 against native 0.0810.
+     */
+    readonly sizeScatterGainFar2x: number;
+    /**
+     * **The body's depth ramp** (W13 G1, from the measurement of claims §5.61 §2
+     * and the re-forming its runtime sweep forced) — a near-contour excursion on
+     * the sharp component's share, riding on top of the span law
+     * `sizeScatterSpanMax` supplies rather than replacing it.
+     *
+     * ```
+     * kDeep(span) = sizeScatterFloor + (1 − sizeScatterFloor)
+     *               · smoothstep(sizeSpanMin, sizeScatterSpanMax, span)
+     * sDeep(span) = 1 − kDeep(span)
+     * s₀(span)    = startThin + (startThick − startThin) · sizeThickness(span)
+     * s(u, span)  = sDeep + max(0, s₀(span) − sDeep) · max(0, 1 − u / U(dpr))
+     * k(u, span)  = 1 − s(u, span)
+     * ```
+     *
+     * with `u` the pixel's depth under the contour and `U` the reach, both in
+     * DEVICE px. `s₀` is the sharp share **at the contour** and `U` is where the
+     * excursion vanishes into the deep value — not where a line from the start
+     * would hit zero, which is what the first form's reach meant. Deep inside any
+     * surface the body is exactly the W11c/W12 material; within `U` of the
+     * contour the sharp component is lifted toward `s₀`, which is the band the
+     * reference has and the uniform share does not.
+     *
+     * **Why the start grades with the span, in the third form.** The second form
+     * gave the excursion one start per scale and its runtime sweep refuted that
+     * too, arithmetically rather than for want of a better point (claims §5.64
+     * §2): `rrect-sm`'s span is exactly `sizeSpanMin`, so its deep sharp share is
+     * exactly `1 − sizeScatterFloor` = 0.600 and no start at or below 0.600 can
+     * touch it, while `rrect-ml`'s band only improves below a start near 0.583.
+     * The window where both hold is empty, and the reach cannot open it — the
+     * reach decides how much of a surface the excursion covers, never which
+     * surfaces it touches, because `max(0, s₀ − sDeep(span))` has no reach in it.
+     * G0 read the reference's start as strongly graded by span (0.637 / 0.642 on
+     * the thin cells against 0.512 / 0.501 / 0.410 on the thick ones at 1x), so
+     * the start is given exactly that grading — across `sizeThickness`, the
+     * material's OWN thin/thick curve with its knee at 64, the one the face's
+     * tone response and the outer shadow already blend across. Reusing it is the
+     * point: it introduces no new span statistic, and `sizeSpanMax` stays where
+     * every other facet reads it.
+     *
+     * **Why this form and not the ramp alone.** W13 G0 measured a ramp with a
+     * free start, reach and floor (H2) and the first implementation took the free
+     * start and reach with a floor of zero, retiring the span law. Its runtime
+     * sweep — 81 points, both scales, the real renderer — could not reach the
+     * wave's stops at any point, and named the mechanism: the ramp's projection
+     * onto one number per surface runs 0.43–0.56 at 1x where the retired span law
+     * ran 0.41–1.00, so the family is nearly span-flat and the bed is strongly
+     * span-graded; small spans want a high start and large spans a low one and no
+     * pair can be both (`.../g1/sweep/g1-sweep.md` §4). §7 of the same report
+     * asked for exactly this: "the ramp's DEEP value wants to be the span-graded
+     * heavy share the retired law supplied, and its near-contour excursion the
+     * sharp term the band asks for." The floor H2 left free is therefore not one
+     * more constant but the span law itself, which is already fitted.
+     *
+     * The reach stays a LENGTH in device pixels, which is the reading that did
+     * survive the sweep: the free fits' reaches in absolute depth spread by 1.3×
+     * across the spans (108 / 115 / 144 CSS px at 1x on `rrect-lg` / `-ml` /
+     * `-md`) where the reaches as a fraction of the half-span spread by 2.2×, and
+     * between the two scales that length roughly halves in CSS px — one length in
+     * device pixels, the same reading as the widths (§5.55 §1, §5.56 §1).
+     *
+     * The start and the reach are anchored at the two scales the reference was
+     * measured at rather than given a scale term: `…1x` is the value at dpr 1,
+     * `…2x` at dpr 2, the pair interpolated linearly in dpr and held constant
+     * outside [1, 2] (`scatterRampStart`, `scatterRampReachDevicePx`).
+     *
+     * **The FOURTH form: the start keeps falling past the thickness knee (W13
+     * Decision Log 6; claims §5.67 §4, §6).** The third form's holdout failed on
+     * one row for the form's own arithmetic: `sizeThickness` saturates at
+     * `sizeSpanMax` 96, so spans 96, 128, 130 and 160 all received the identical
+     * thick start while G0 read the reference's start FALLING across exactly
+     * those spans (0.512 → 0.501 → 0.410), and because the deep value keeps
+     * falling to `sizeScatterSpanMax` the excursion GREW with span (0.039 →
+     * 0.156 → 0.284) where the reference's shrinks — `rrect-lg` overshot its
+     * interior by 33%. So the start gets a slow decline along the scatter
+     * facet's own curve above the knee, `startFar` being its value at span ≥
+     * `sizeScatterSpanMax`:
+     *
+     *   s₀(span) = thin + (thick − thin) · sizeThickness(span)
+     *            + (far − thick) · smoothstep(sizeSpanMax, sizeScatterSpanMax, span)
+     *
+     * Two curves the material already has, one more constant per scale, and no
+     * new span statistic. At 2x the decline is switched off rather than inverted:
+     * `far` and `thick` carry the same number since W15 G1, because G0 read the
+     * reference's 2x start FLAT across the thick spans (claims §5.69 §2, §5.70 §6
+     * (iv)) — the decline is a 1x feature of this form.
+     *
+     * The 1x three are FITTED (W13 G1's third and fourth sweeps) and the 2x four
+     * are FITTED or read from G0 by W15 G1 (claims §5.70 §2 and §8); no constant
+     * here lands on a paper prediction, because the paper model over-credited the
+     * mip chain's heavy tap once already (§5.58 §1). What they carry:
+     *
+     * **1x — thin 0.64, thick 0.52, reach 120 device px.** G0's own start
+     * readings are 0.637 on `rrect-sm` and 0.642 on the capsule at the thin end
+     * and 0.512 / 0.501 / 0.410 on `rrect-md` / `-ml` / `-lg` at the thick end.
+     * A thick anchor fitted to all three thick cells jointly comes out near 0.47,
+     * and 0.47 sits 0.011 *below* `rrect-md`'s own deep sharp share of 0.481,
+     * which would clamp the excursion to zero on that one cell. 0.52 is above it
+     * and is also G0's reading on that cell, so the fit is not traded against the
+     * form's own arithmetic.
+     *
+     * **2x — thin 0.46, thick 0.21, far 0.21, reach 100 device px, and the ramp
+     * is now the WHOLE body above the deep value** (W15 G1, claims §5.70 §1–§2).
+     * W13 left these inert for the deep value's sake: at `sizeScatterFloor2x` 0.4
+     * every anchor sat below its cell's deep sharp share and `max(0, s₀ − sDeep)`
+     * was bit-exactly zero on the whole bed. W15 G1 fitted that deep value fully
+     * heavy (`sizeScatterFloor2x` 1.0), so the deep sharp share at dpr 2 is 0 and
+     * the anchors act on the numbers they were carrying — which is why the wave's
+     * three gaps turned out to be one gap (§5.70 §6 (i)).
+     *
+     * The values are G0's readings where the sweep was flat and the sweep's where
+     * it was not. **Thin 0.46** is G0's u 6 reading exactly (0.494 / 0.468 on the
+     * thin cells) and stage 2b's best, over a top nine points within 0.002 of
+     * each other. **Thick and far 0.21**: G0's 2x starts on the thick cells are
+     * 0.163 / 0.199 / 0.210 at their own widths and 0.192 / 0.199 / 0.195 at one
+     * common width — flat with span, not declining — so the two anchors take one
+     * number and the fourth form's decline is off at this scale; stage 2a
+     * measured the objective flat over 0.17–0.25 and worse at 0.33. **Reach 100
+     * device px** = 50 CSS px against G0's measured 49 / 53 / 56, and stage 2b
+     * found 100 and 130 indifferent.
+     *
+     * **far — 0.20 at 1x (FITTED on the W14 bed), 0.21 at 2x.** The fourth
+     * sweep (`results/2026-09-03-w13-ramp/g1/sweep-4/`) swept far over eight
+     * points from 0.52 (the third form) down to 0.15: S1 and S4 pass at every
+     * one, only `rrect-ml`'s rows move and they improve monotonically as far
+     * falls, and the band is flat within the bed's noise below 0.30. The cell
+     * the constant exists for is holdout, so the tie inside the noise is broken
+     * by the reference's own reading — G0's `rrect-lg` start of 0.410 at span 160
+     * is far = 0.207 through this form — and 0.20 is the measured grid point that
+     * carries it. The confirmation read `rrect-lg` at `ssimMean` +0.0056 against
+     * the W14 bed (the third form: −0.0026) with its interior 12% over the
+     * reference (from 33% over). At 2x far equals the thick anchor, so the start
+     * is flat past the knee at that scale — G0's own reading (§5.69 §2), and the
+     * holdout's band supports it (`rrect-lg` +0.0106, claims §5.70 §8).
+     *
+     * At dpr 1 none of the 2x four is read at all: `rampAtScale` holds every one
+     * of them at its 1x anchor below dpr 1, so the 1x material is byte-identical
+     * to the W13 bed and the landing's confirmation measured that on 49 of 49 1x
+     * GPU cells (claims §5.70 §8).
+     */
+    readonly sizeScatterRampStartThin1x: number;
+    readonly sizeScatterRampStartThick1x: number;
+    readonly sizeScatterRampStartFar1x: number;
+    readonly sizeScatterRampStartThin2x: number;
+    readonly sizeScatterRampStartThick2x: number;
+    readonly sizeScatterRampStartFar2x: number;
+    readonly sizeScatterRampReach1xPx: number;
+    readonly sizeScatterRampReach2xPx: number;
     /**
      * The occlusion gain — "a larger size is more opaque. A smaller size is
      * clearer" (S284). The fraction of the *remaining* transparency the size law
@@ -1861,16 +2315,63 @@ interface MaterialProfile {
      */
     readonly sizeShadowGainMax: number;
     /**
-     * The lens's magnitude: the contour displacement in lens depths (W11c G2).
+     * The lens (W12 G2, claims §5.51) — one steep power on the reference's own
+     * span law, along a direction the reference ovalizes.
+     *
+     * The reference's `glassBackground` filter takes an inner refraction *amount*
+     * and *height* that are clamped linear functions of the shape's shorter side
+     * (claims §5.50: amount −min(0.8·span, 60), height min(0.25·span, 20)). What
+     * those two numbers do spatially is not in the tree; measured as a field on
+     * the captures (§5.49) and ranked on the pixels (§5.51), the band is
+     *
+     *   D(u) = S · max(0, 1 − u / L′)^p,   S = lensRefractionGain · A(span),
+     *                                       L′ = lensExtentGain · lensDepth,
      *
-     * The shader reads the body from `lensDepth × lensRefractionGain × (1 − depth)²`
-     * further inside, so the band is the plate folded back from that far in. The
-     * two rim-LOD constants that used to sit here (`lensBodyLodPerPx`,
-     * `lensRimLodBias`) are retired: the reference's band is not sharper than its
-     * interior — W11c G2 measured σ 6 → 4 → 3 → the deep value across the band —
-     * and the "sharper rim" was the fold, not a finer sample.
+     * with `lensDepth = (thickness / lensThicknessReference) × H(span)` the
+     * reference's height law scaled by the author's thickness (8 is the default
+     * and the reference's unit — at 8 the depth IS Apple's height, 8 / 11 / 20 on
+     * spans 32 / 44 / ≥ 80), `A(span)` the amount law scaled the same way, and
+     * `p = lensProfileExponent`. Apple's own two-term profile at its literal
+     * amounts was ranked too and lost on the pixels and the holdout; its span law
+     * is adopted, its shape is not (§5.51 §2).
+     *
+     * `lensRefractionGain` is therefore re-based: it was 1.6 lens depths on the
+     * W11c square profile (S = 1.6 × 20.8 = 33.3 at saturation), it is now the
+     * scale on the reference's amount (S = 0.745 × 60 = 44.7), fitted on
+     * `rrect-md` + `-ml` at 1x with `rrect-lg` held out.
      */
     readonly lensRefractionGain: number;
+    /** The reference's inner refraction height law: `min(lensHeightPerSpan · span, lensHeightMax)`. */
+    readonly lensHeightPerSpan: number;
+    readonly lensHeightMax: number;
+    /** The reference's inner refraction amount law: `min(lensAmountPerSpan · span, lensAmountMax)`. */
+    readonly lensAmountPerSpan: number;
+    readonly lensAmountMax: number;
+    /**
+     * The author `thickness` at which the lens depth equals the reference's own
+     * height — the host's default, and what the bed was captured at. A thicker
+     * authoring scales the depth and the magnitude together.
+     */
+    readonly lensThicknessReference: number;
+    /** The profile's extent over the lens depth: D reaches zero at `lensExtentGain × lensDepth`. */
+    readonly lensExtentGain: number;
+    /** The profile's exponent — the square of W11c became a steeper power (§5.49 §2). */
+    readonly lensProfileExponent: number;
+    /**
+     * The direction's ovalization (§5.49 §3, §5.50): the reference's SDF element
+     * carries `gradientOvalization`, and the band is magnified *along* the edge by
+     * up to 1.31× as a result. The shader displaces along the gradient of the
+     * blended field `(1 − ω)·d_rrect + ω·d_oval`, `d_oval` the signed distance of
+     * the ellipse inscribed in the surface's box, with the magnitude fixed. The
+     * reference's value is 0.5 on thick shapes and 0 on thin ones; 0.6 is what the
+     * pixels want on the box-inscribed ellipse (Apple's oval is more curved at the
+     * edge midpoint than that ellipse). The switch is a step in the reference
+     * between spans 64 and 72; here it is a smoothstep over that band, the same at
+     * both ends and continuous through a morph.
+     */
+    readonly lensOvalization: number;
+    readonly lensOvalizationSpanMin: number;
+    readonly lensOvalizationSpanMax: number;
     /**
      * What each accessibility regime does to the numbers above. The multipliers
      * match `platform-web`'s CSS tier so the two renderers degrade the same way
@@ -2055,9 +2556,31 @@ interface MaterialProfilePatch {
     readonly sizeScatterGainMax?: number;
     readonly sizeScatterFloor?: number;
     readonly sizeScatterSpanMax?: number;
+    readonly sizeScatterGainMax2x?: number;
+    readonly sizeScatterFloor2x?: number;
+    readonly sizeScatterSpanMax2x?: number;
+    readonly sizeScatterGainFar2x?: number;
+    readonly sizeScatterRampStartThin1x?: number;
+    readonly sizeScatterRampStartThick1x?: number;
+    readonly sizeScatterRampStartFar1x?: number;
+    readonly sizeScatterRampStartThin2x?: number;
+    readonly sizeScatterRampStartThick2x?: number;
+    readonly sizeScatterRampStartFar2x?: number;
+    readonly sizeScatterRampReach1xPx?: number;
+    readonly sizeScatterRampReach2xPx?: number;
     readonly sizeOcclusionGain?: number;
     readonly sizeShadowGainMax?: number;
     readonly lensRefractionGain?: number;
+    readonly lensHeightPerSpan?: number;
+    readonly lensHeightMax?: number;
+    readonly lensAmountPerSpan?: number;
+    readonly lensAmountMax?: number;
+    readonly lensThicknessReference?: number;
+    readonly lensExtentGain?: number;
+    readonly lensProfileExponent?: number;
+    readonly lensOvalization?: number;
+    readonly lensOvalizationSpanMin?: number;
+    readonly lensOvalizationSpanMax?: number;
     readonly reducedTransparencyFrost?: number;
     readonly increasedOcclusionLift?: number;
     readonly strongBorderRim?: Readonly<Partial<MaterialRim>>;
@@ -2854,6 +3377,16 @@ interface PyramidResources {
     readonly texelsPerCss: number;
     readonly sourceWidth: number;
     readonly sourceHeight: number;
+    /**
+     * The CSS-px σ the build converted with (W13 G1, review finding). The density
+     * alone does not determine the body: since the widths became device-pixel
+     * quantities (W12 G3, claims §5.56) the material's σ in CSS px is
+     * `blurSigma / dpr`, so a window dragged from a 1x display to a 2x one asks
+     * for a different body from the same source at the same density. A static
+     * image never re-dirties, so this recorded σ is the only signal that the
+     * chain's body and `bodyChainLod` belong to the previous scale.
+     */
+    readonly bodySigmaCss: number;
 }
 interface PyramidInstrumentation {
     /** Successful rebuilds since the store was created. */