@vitreajs/vitrea 0.3.0 → 0.4.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 occlusion: number;
+    readonly thinOcclusionMid: number;
     /**
-     * What reduced transparency does to `occlusion` — MEASURED, not assumed, which
-     * is what the charter asked for before the fold was written.
+     * 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 thinOcclusionBright: number;
+    /**
+     * 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,211 @@ 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 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 `far` sits below the thick anchor, so the null
+     * the third form verified bit-exactly (§5.67 §2) holds by construction: an
+     * excursion that was zero at every span stays zero when its start falls
+     * further.
+     *
+     * PROVISIONAL, all eight. The runtime sweep at this form sets them, because
+     * the paper model over-credited the mip chain's heavy tap once already
+     * (§5.58 §1) and no constant lands on a paper prediction again. What they
+     * carry now:
+     *
+     * **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.17, reach 100 device px, and the excursion clamps
+     * to zero on every cell of the calibration bed.** These are G0's 2x readings
+     * (0.483 / 0.437 on the thin cells, 0.192 / 0.179 / 0.141 on the thick ones),
+     * and every one of them sits BELOW its cell's deep sharp share: the implied
+     * excursions run −0.095 to −0.289 (claims §5.64 §4). `max(0, s₀ − sDeep)` is
+     * therefore zero everywhere on this bed at dpr 2. That is not a special case
+     * and not a disabled facet — it is the law evaluating to no excursion where
+     * the reference's own contour share is heavier than vitrea's deep value. It
+     * follows that **the 2x gap is a deep-value gap and not a ramp gap**: the
+     * span law's floor, knee and top are what miss at that scale, and no
+     * one-signed excursion above them can express it. That fit is W13's Deferred
+     * charter and not this constant's business.
+     *
+     * **far — 0.20 at 1x (FITTED on the W14 bed), 0.15 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 is below the thick anchor so that the
+     * null holds — re-verified bit-exact under this form.
+     */
+    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 +2197,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 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.
+     * 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,
+     *
+     * 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 +2438,27 @@ interface MaterialProfilePatch {
     readonly sizeScatterGainMax?: number;
     readonly sizeScatterFloor?: number;
     readonly sizeScatterSpanMax?: 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 +3255,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. */

package/dist/index.js

@@ -1092,7 +1092,7 @@ function isHealthy(state) {
 
 // src/renderer-seam.ts
 async function loadWebGPURendererModule() {
-  return import('./dist-MVSXUP3K.js');
+  return import('./dist-RGWZAZ6J.js');
 }
 async function loadWebGPURenderer() {
   const { createWebGPURenderer } = await loadWebGPURendererModule();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitreajs/vitrea",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Framework-agnostic Liquid Glass material runtime: scene model, capability resolution, material policy, accessibility policy.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/SSFSKIM/designer",