@vitreajs/vitrea 0.11.0 → 0.14.0

package/dist/index.d.ts

@@ -1665,9 +1665,197 @@ interface MaterialOptics {
     /** Rim band half-width in CSS px, and its ambient brightness. */
     readonly rimWidth: number;
     readonly rimAlpha: number;
-    /** Specular exponent and gain on the rim. */
+    /**
+     * **The rim band's half-width at dpr 2** (W23; claims §5.100 §5, Decision
+     * Log 2 (d)) — `rimWidth`'s second reading, on the precedent of
+     * `sizeScatterGainMax2x` and its siblings and interpolated by the same
+     * `rampAtScale`.
+     *
+     * The rim's amplitude below is one law for both scales, and it cannot be: read
+     * at the contour, vitrea's per-CSS-px band integral RISES 19 % between 1x and
+     * 2x (0.068 → 0.081) while the reference's FALLS 10 % (0.229 → 0.205), so the
+     * same amplitude that lands the 1x dark-backdrop solids at −0.003…−0.007 lands
+     * the 2x rows at +0.037…+0.051. The mismatch is the band's shape and not its
+     * height: at 1x over a dark backdrop the two rims are already the same
+     * one-pixel line (the reference's second contour row carries 8 % of the peak
+     * and vitrea's −7 %), and at 2x vitrea spreads 35 % of its peak onto the second
+     * row where the reference puts 55 % of a NARROWER line. So `rimWidth` does not
+     * move — the 1x rows do not ask it to — and the 2x band narrows instead.
+     *
+     * At dpr ≤ 1 this constant is not read at all (`rimWidthAtScale`), so a profile
+     * that carries it renders the 1x material unchanged by construction.
+     */
+    readonly rimWidth2x: number;
+    /**
+     * Specular exponent and gain on the rim — **RETIRED from the rim (W24 G2;
+     * claims §5.108 §1, W24 Decision Log 2 (a)), and the note is set beside the
+     * W22 fit below rather than over it.**
+     *
+     * The term was `max(dot(normal, lightDirection), 0)^specularPower ×
+     * specularGain`, one-sided, added to the rim's amplitude. W24 read the
+     * reference's rim around the whole contour instead of per side and found the
+     * variation it was reaching for — but symmetric about the diagonal, not
+     * one-sided: the two ends of that diagonal are drawn EQUAL to a thousandth
+     * (2x dark tl 0.0418 against br 0.0418; 2x light 0.2786 against 0.2823), and
+     * over the nineteen untinted solid rows the one-sided form reaches a
+     * normalised RMS of 0.288 against the symmetric form's 0.148, degenerating in
+     * the fit to the ceiling of both its exponent and its floor trying to become
+     * symmetric. So the shape was wrong, which is the deeper reason W22 G1 rightly
+     * fitted the gain to 0 on the regular variant (claims §5.94 §3): no amount of
+     * a term with the wrong shape helps. `rimLitExponent` below is the shape the
+     * rows chose, and it replaces this one.
+     *
+     * Nothing on either canonical bed moves: the shipped profiles carry
+     * `specularGain` 0 on `regular` since W21/W22, and no scene on either bed or in
+     * the golden suite declares `clear`. What DOES change is the `clear` variant's
+     * unfitted structural 0.45, which drew a one-sided highlight this material is
+     * now measured not to have; it is recorded rather than replaced, because the
+     * lit factor is inert on `clear` for want of rows.
+     *
+     * The two constants stay on the profile so that the W22 fit's record and the
+     * profile documents that carry it remain readable, and so that removing them
+     * is one reviewable change of the profile's SHAPE rather than a side effect of
+     * a material gate. Nothing reads them.
+     */
     readonly specularPower: number;
     readonly specularGain: number;
+    /**
+     * **The rim's amplitude law (W23; claims §5.100 §4, Decision Log 2 (a))** — the
+     * term that lets the rim depend on what it is drawn over, which `rimAlpha`
+     * alone cannot.
+     *
+     * `rimAlpha` was an additive constant: the shader added `rimWeight × rimAlpha`
+     * and nothing scaled it. The reference's rim is not a constant. Read at the
+     * contour (claims §5.99, §5.100 §2; W23 X1) the light reference's rim is
+     * +0.23…0.26 of linear luminance over a dark solid, +0.13…0.21 over a
+     * structured backdrop and clipped to white over `light-solid`, while vitrea
+     * drew the same +0.060…0.078 everywhere; and the dark reference's rim GROWS
+     * with what is behind it, +0.026 over `dark-solid` and +0.103 over
+     * `light-solid`, at a body that moves by only a twelfth as much.
+     *
+     * `rimLevelGain` is the coefficient of the surface's OWN rendered level: the
+     * rim becomes `rimAlpha + rimLevelGain × luminance(surface)`. Four candidate
+     * forms were fitted on the reference's own solid, unclipped, uncollapsed sides
+     * — 44 in light and 36 in dark, from both canonical scales and both probe grids
+     * — and this one wins in both schemes on mean |residual|: 0.0081 / 0.0013
+     * against 0.0249 / 0.0253 for the additive constant, 0.0168 / 0.0259 for a pure
+     * screen and 0.0105 / 0.0042 for screen plus an environment term.
+     *
+     * The gain is SIGNED, and its sign is the whole finding. A negative gain is the
+     * screen form — a white line composited source-over at a fraction of the body's
+     * headroom, which is what the CSS tier's inset `box-shadow` already is — and
+     * the light material's rows want one. A positive gain is a rim that rides its
+     * own body up, and the dark material's rows want that, strongly.
+     *
+     * **The environment term is not here, and its absence is a measurement.** W23
+     * chartered `rimEnvGain` — a coefficient on the backdrop source's own average
+     * luminance — as the candidate (L3) for what makes the reference's rim clip
+     * over a bright backdrop while its body is nowhere near white. It is declined
+     * and REMOVED rather than shipped at 0: it is worse than this law on the
+     * reference in both schemes, and no row of either bed separates it on vitrea's
+     * side (a rendered ladder point at +0.10 of gain moved every solid cell by 0 or
+     * 0.0005, because `light-solid` clips and the dark solids have no environment
+     * to speak of). C9a §6.2's rule is that a constant whose rows do not separate
+     * it is not carried. What the reference does there is real and is recorded in
+     * the wave's Deferred list with its numbers: a bed with a mid-bright solid
+     * backdrop under a light-scheme thick surface would tell the environment apart
+     * from the body, and no bed that exists can.
+     */
+    readonly rimLevelGain: number;
+    /**
+     * **The lit edge (W24; claims §5.107)** — the exponent of the directional
+     * factor `(√2 · |n · L|)^rimLitExponent` the rim's whole amplitude is
+     * multiplied by, with `L` the profile's `rimLitAxis`.
+     *
+     * W23 gave the rim the right AMOUNT and the wrong SHAPE. Read around the whole
+     * contour rather than per side (`results/2026-09-09-w24-lit-edge/g0/
+     * read-angular.py`), Apple's rim is not constant: on the 2x dark
+     * `dark-solid__rrect-md` the bins whose normal points north-west and
+     * south-east read 0.0408 and 0.0418 against 0.0016 for north-east and
+     * south-west, with the four straight sides at 0.0312–0.0328; the same cell in
+     * the light scheme reads 0.284 / 0.286 against 0.038, sides 0.233–0.247.
+     * vitrea drew one number everywhere — a drawn line, which is what the user's
+     * eye called an aesthetic regression on the W23 landing sheet.
+     *
+     * No per-side reader could see it, and the reason is geometric: a light on the
+     * 45° diagonal projects EQUALLY on all four straight sides, so `L−R` and
+     * `T−B` are 0 for the reference exactly as they are for vitrea. The variation
+     * lives in the corner arcs, which W23's contour reader excludes by
+     * construction and W21's band reader averages into its corner overshoot.
+     *
+     * **The form is symmetric and it is not a Lambert.** Fitted on the reference's
+     * own bins over the 19 untinted solid cells of both canonical beds and both
+     * probe grids, `(√2 · |n · L|)^p` reaches an RMS of 0.148 of each cell's own
+     * peak against 0.288 for the one-sided `max(n · L, 0)^p` that W22's `spec`
+     * term draws and 0.312 for the flat rim vitrea ships. The one-sided form
+     * cannot reach both ends of a diagonal whose two corners the reference draws
+     * equal to a thousandth, and that — not its gain — is why W22 rightly fitted
+     * `specularGain` to 0.
+     *
+     * **There is no ambient floor.** The wave chartered `a + (1 − a)|n · L|^p` with
+     * `a` expected around 0.15 dark and 0.25 light. Every grouping of the rows fits
+     * `a` to 0.000 (the search ran 0…0.6 in steps of 0.005), because the bin mean
+     * of `|cos|^p` over the 22.5° straddling the null is already 0.10–0.16 and
+     * supplies everything the null bins carry. A constant every row fits to zero is
+     * a constant the material does not have (C9a §6.2), so it is not here.
+     *
+     * **The `√2` is the amplitude's re-expression, in closed form.** W23 fitted
+     * `rimAlpha` and `rimLevelGain` on the STRAIGHT SPANS, which under this factor
+     * sit at `(cos 45°)^p` of the peak. Normalising the dot product by `cos 45°`
+     * inside the power makes the factor exactly 1 wherever the normal is
+     * horizontal or vertical, at every exponent — so no fitted amplitude moves,
+     * W23's straight-span reads hold identically rather than approximately, and
+     * only the corners and the arcs change. It is why the CSS tier, whose inset
+     * shadow cannot vary around a contour, needs no re-fit either.
+     *
+     * At 0 the factor is `pow(x, 0)` = 1 for every normal, so a profile that does
+     * not carry this constant renders the W23 material byte for byte.
+     */
+    readonly rimLitExponent: number;
+    /**
+     * **The lit edge's along-side field (W25; claims §5.113, W25 Decision Log 3
+     * (c))** — the slope of the position field the rim's amplitude is graded by
+     * across the surface, riding `sizeThickness`.
+     *
+     * W24 gave the rim a factor of the NORMAL, which is one number on a whole
+     * straight side. W25 G0 read the rim's peak excess by POSITION along each
+     * straight side instead and found it graded on every thick cell of both probe
+     * grids, on flat solid backdrops where a lens has no gradient to refract: the
+     * 1x dark `dark-solid__rrect-md` reads slopes of −0.000192 (top), +0.000192
+     * (bottom), −0.000379 (left) and +0.000379 (right) luma per CSS px, and the
+     * corner-to-corner range 0.0187 / 0.0226 / 0.0345 on `light-solid` /
+     * `dark-solid` / `mid-dark-solid` at span 96 falls to 0.0000 / 0.0016 at spans
+     * 32 and 44 and saturates above 96 — the signature of a term on
+     * `sizeThickness` and not of the lens.
+     *
+     * **The field is the product of the two normalised coordinates, and that is
+     * what the four slopes say.** A field linear in position — `a·x + b·y` — gives
+     * the top and the bottom side the SAME slope in x; the reference's are equal
+     * and opposite. `(x / halfWidth) · (y / halfHeight)` gives exactly the measured
+     * antisymmetry, is +1 at the top-left and bottom-right corners and −1 at the
+     * other two — the same diagonal `rimLitAxis` is symmetric about, which is why
+     * this is the position half of one light and not a second one — and predicts
+     * the two sides' slope ratio as the box's aspect: 160/96 = 1.67 against the
+     * measured 0.000379 / 0.000192 = 1.97, where a metric diagonal would predict
+     * 1.0. Reading the reference's two sides through it gives 0.62 (top) and 0.73
+     * (left) for this constant, which is the agreement a 56 CSS px straight side
+     * on a six-code contrast supports.
+     *
+     * The factor is `1 + rimAlongSideSlope · sizeThickness(span) · field`, applied
+     * beside W24's `lit` factor and outside W23's amplitude bracket. Two
+     * consequences are exact rather than approximate. **The field's mean over every
+     * straight side is zero**, because the product is odd in the coordinate that
+     * runs along the side, so W23's and W24's straight-span amplitudes keep their
+     * fitted meaning and the CSS tier — whose one inset shadow cannot vary around a
+     * contour — is coherent with the GPU tier's side mean without carrying the term
+     * at all. **It is exactly 0 at or below `sizeSpanMin`**, so `rrect-sm` and every
+     * thin control are untouched by construction; the capsule's span of 44 takes
+     * 0.0923 of it, which is the thin end's whole exposure.
+     *
+     * At 0 the factor is exactly 1 everywhere, so a profile that does not carry
+     * this constant renders the W24 material byte for byte.
+     */
+    readonly rimAlongSideSlope: number;
     /** Inner-shadow depth (0..1) and how much of it is applied. */
     readonly shadowDepth: number;
     readonly shadowAlpha: number;
@@ -2027,6 +2215,17 @@ interface MaterialProfile {
      * σ 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).
+     *
+     * **INERT on the GPU tier at any material that names a heavy width** (W26;
+     * claims §5.122 §6a). This constant reaches the deep sample only through
+     * `scatterLod`, and where `sizeHeavyTapSigma` is non-zero the optics pass
+     * overwrites that sample with the heavy texture — measured, not argued: fifty
+     * rows byte-identical between `sizeScatterGainFar2x` 9.9 and 4.8 at the landed
+     * width. It is KEPT and not retired because retiring it means deciding what a
+     * profile naming NO heavy width draws, which is a code-removal wave with no
+     * fidelity content (W26 Decision Log 6 (b)); the tracker carries it. The CSS
+     * tier still reads it for the same reason — the collapsed single-`blur()` form
+     * and the sampling-padding projection, where no heavy width applies.
      */
     readonly sizeScatterGainMax: number;
     /**
@@ -2146,6 +2345,11 @@ interface MaterialProfile {
      * **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.
+     *
+     * **The gain is INERT on the GPU tier at any material that names a heavy
+     * width** (W26; claims §5.122 §6a), for `sizeScatterGainMax`'s reason and with
+     * the same measurement behind it. The floor and the span top above are NOT —
+     * they grade the deep value's SHARE, which the heavy texture does not touch.
      */
     readonly sizeScatterGainMax2x: number;
     readonly sizeScatterFloor2x: number;
@@ -2195,6 +2399,19 @@ interface MaterialProfile {
      * 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.
+     *
+     * **INERT on the GPU tier at any material that names a heavy width**, and this
+     * is the one of the three whose silence costs something (W26; claims §5.122
+     * §§3, 6a). It is the constant that graded the 2x heavy width with the span,
+     * and the heavy texture is one width per SOURCE, so where a heavy width is
+     * named there is nothing left for it to grade: fifty rows byte-identical
+     * between 9.9 and 4.8 at the landed width. What that gives up is measured on
+     * the instrument of record rather than estimated — the reference wants **1.66
+     * device px more heavy width at span 160 than at span 96 at dpr 2**, 20 % of
+     * the smaller, and W26 lands one number inside 11 % of each instead. That is
+     * W26 Decision Log 2 (f)'s recorded gap, now with a size; the constant is kept
+     * against the profile that names no heavy width and against the wave that
+     * makes the width per surface.
      */
     readonly sizeScatterGainFar2x: number;
     /**
@@ -2345,6 +2562,210 @@ interface MaterialProfile {
     readonly sizeScatterRampStartFar2x: number;
     readonly sizeScatterRampReach1xPx: number;
     readonly sizeScatterRampReach2xPx: number;
+    /**
+     * **The heavy share's thick end** (W25; claims §5.113, W25 Decision Log 3 (a))
+     * — how much heavier the deep value runs on a thick surface than the span
+     * curve above makes it, riding `sizeThickness` and read once per scale.
+     *
+     * W25 G0 measured the reference's kernel as TWO components and found that what
+     * separates the thick surface from the thin one is neither width: read on the
+     * same cell at 1x the reference's single-Gaussian width is 1.30 device px
+     * against a 16 CSS px checkerboard, 4.75 against 32 and 6.25 against 64, where
+     * one Gaussian returns one number at every pitch. The dot's own two-component
+     * fit on `impulse__rrect-md` reads sharp σ 2.79 and heavy σ 19.52 device px at
+     * 1x and 1.40 / 11.29 at 2x — both components HALVING in device px — with the
+     * heavy SHARE moving 0.47 → 0.69 the other way, and 0.00 on the collapsed
+     * capsule. vitrea's own pair on the landed material reaches 0.69 at 2x and
+     * carries 0.23 at 1x. So the share is the quantity, and this is where the wave
+     * puts it.
+     *
+     * ```
+     * kDeep(span, dpr) = floor(dpr) + (1 − floor(dpr))
+     *                    · smoothstep(sizeSpanMin, sizeScatterSpanMax(dpr), span)
+     *                  + heavyShareThick(dpr) · sizeThickness(span)      ← this
+     * ```
+     *
+     * **What stays, and why the thin capsule cannot move.** `sizeScatterFloor`,
+     * `sizeScatterSpanMax` and the ramp's start anchors are NOT re-derived: the
+     * W11c curve stays as the law's thin end and this constant is the lift the
+     * thick end takes above it. That is X5 discharged by the form rather than by a
+     * capture — `sizeThickness` is exactly 0 at and below `sizeSpanMin`, so
+     * `rrect-sm` and every smaller control are bit-identical whatever this says,
+     * and the capsule at span 44 takes 0.0923 of it, which is the whole of the
+     * thin end's exposure and is what the ladder's thin-invariance rung reads. The
+     * alternative — re-expressing the whole curve on a thin/thick anchor pair —
+     * would have made the capsule's own share a fitted quantity of this wave, and
+     * the reference does not ask for that: its sharp σ is 2.62 device px on the
+     * collapsed capsule against 2.79 on the thick rrect, span-flat to 6 %.
+     *
+     * **Inert at 0**, which is what ships until G3 declares the fit: the term is
+     * one multiplication by zero added to the curve W11c fitted, so the resolved
+     * material and every golden are byte-identical to the W24 bed.
+     *
+     * At dpr 2 the 2x anchor is additionally inert on the landed material for a
+     * second reason: `sizeScatterFloor2x` is 1, so `kDeep` is already 1 at every
+     * span and the clamp absorbs any lift. The 2x share is therefore not a
+     * quantity this bed can carry, and it waits for G1's 2x probe fixtures.
+     */
+    readonly sizeScatterHeavyShareThick1x: number;
+    readonly sizeScatterHeavyShareThick2x: number;
+    /**
+     * **The body's level above the thickness knee** (W25; claims §5.113, W25
+     * Decision Log 3 (b)) — an OFFSET on the interior level a surface settles at,
+     * in the tone response's own encoded units, reached at `sizeScatterSpanMax`.
+     *
+     * W25 G0 answered clause 4 in the landed law's favour and found one residual
+     * it cannot carry. `sizeThickness(short side)` at knee 96 scores r 0.95–0.998
+     * against 0.68–0.96 for the long side, the area, √area and the radius, on the
+     * width and on the level, in both probe grids and both schemes — so the
+     * argument and the knee stay. But the reference's body LEVEL keeps grading
+     * above 96: on the W9 light grid over `checkerboard` it reads 0.61484 /
+     * 0.61299 / 0.67915 / 0.69083 / 0.70458 across spans 32 / 44 / 96 / 128 / 160,
+     * where `sizeThickness` has been flat since 96. The width does not grade there
+     * on any pitch; only the level does.
+     *
+     * ```
+     * R(x, span, dpr) = R₀(x, sizeK)
+     *                 + sizeToneLevelFar · smoothstep(sizeSpanMax,
+     *                                                sizeScatterSpanMax(dpr), span)
+     * ```
+     *
+     * **Where it enters.** On the tone response's OUTPUT — the settled interior
+     * level `backdropToneResponse` returns, which is the law that owns the
+     * interior mean (claims §5.33) — and not in the blur, not on a gain on the
+     * mix, and not (this is the correction) on the response's own thin-to-thick
+     * blend.
+     *
+     * **Why not on the blend, which is what the wave chartered.** G0's reading
+     * that the residual's "sign follows the backdrop" is a reading of the
+     * REFERENCE's absolute grading, and the quantity a term has to close is the
+     * residual AGAINST vitrea, whose own deep value keeps rising to
+     * `sizeScatterSpanMax` over the same spans. G2's ladder measured both shapes
+     * on the same rows (`fit-level.txt`): carrying the blend past the thick row
+     * explains 0.3 % of the above-knee residual and its per-row gains run
+     * −1.13 … +0.24 with the two grids disagreeing in sign, because the blend's
+     * direction is different at every backdrop level and the residual's is not. An
+     * offset explains 11 % of it and the light grid's rows agree: `resid(160) −
+     * resid(96)` is +2.2 … +4.2 codes over `checkerboard` at four pitches,
+     * `dark-solid`, `mid-dark-solid`, `hc-text` at two pitches and `photo`, over
+     * backdrops spanning 0.012 to 0.89 linear. Backdrop-independent is what the
+     * rows say, so backdrop-independent is the shape.
+     *
+     * The curve is the one the ramp's far anchor declines along and the 2x heavy
+     * gain rises along, so no new span statistic enters the material, and it is
+     * **exactly 0 at and below `sizeSpanMax`** — nothing at or under span 96 moves
+     * at any value of this constant, which is what let G2 probe it against the
+     * frozen bed with 77 control rows reading a lever of 0.000000 codes per unit.
+     *
+     * Folded with `sizeK`, like the response it offsets: under reduced
+     * transparency the material has stopped transmitting and the level it settles
+     * at is the preference's, not the size law's.
+     *
+     * **Inert at 0**, which is what ships until G3 declares the fit. What G2's
+     * ladder read is in `fit-level.txt`; the constant is weakly conditioned on the
+     * bed as it stands and G1's probe set at both scales is what would condition
+     * it (G0 §6: 118 level rows on the 1x grids, 202–238 with the 2x captures).
+     */
+    readonly sizeToneLevelFar: number;
+    /**
+     * **The heavy blur's width, in device px per scale** (W26; W26 Decision Log 1
+     * and 2, from the measured cause in claims §5.116 §2) — the constant that makes
+     * the deep sample's width a continuous parameter instead of a chain level.
+     *
+     * W25 could not raise the heavy share because vitrea's heavy component is
+     * 13.3 device px at 1x against the reference's 19.5, and raising the share at
+     * the wrong width adds narrow structure the reference does not have. The width
+     * was not a lever: `sizeScatterGainMax` 8 → 10.3 left reader A at 13.29. W26 G0
+     * measured why, and it is arithmetic rather than material
+     * (`results/2026-09-10-w26-heavy-width/g0/tap-today.txt`). The body's deep
+     * sample is
+     *
+     * ```
+     * scatterLod = clamp(bodyChainLod + log2(gain), 0, chainMaxLod)
+     * ```
+     *
+     * `chainMaxLod` is `planPyramid`'s `levelCount − 1`, and the chain stops when
+     * the shorter side would fall below `MIN_LEVEL_EXTENT` = 8. On the bed's
+     * 320 × 200 backdrop raster the chain is five levels, so `chainMaxLod` is **4**
+     * at dpr 1, and `bodyChainLod + log2(8)` is 4.06 — **already past the clamp**.
+     * Every gain at or above 7.5 draws the same level 4, whose own kernel is
+     * 13.4 level-0 texels wide (`CHAIN_LEVEL_SIGMA`) — which is the 13.3 the ledger
+     * recorded. G0 rendered the three impulse rows at gains 8, 10.3, 16 and 32 and
+     * read them identical to the last digit, moving only at gain 4, which asks for
+     * level 3.06 and gets it. So `sizeScatterGainMax`, `sizeScatterGainMax2x` and
+     * `sizeScatterGainFar2x` grade a quantity the clamp then discards, and a
+     * fractional level or a blend of two levels cannot widen anything at dpr 1 —
+     * G0 measured both **inert to the bit** there and removed them again (W26
+     * Decision Log 2 (a); the branch and `results/…/g0/` are their record).
+     *
+     * What widens is a Gaussian, and it is built where the chain is built. The
+     * pyramid takes the chain level whose own blur is nearest below this σ and runs
+     * the two separable passes it already runs for the body until the total is this
+     * σ exactly (`heavyTapPlan`, `PyramidResources.heavy`), so the width is
+     * continuous and is bounded by nothing the chain's depth decides — the residual
+     * carries whatever octave the chain lacks. The optics pass then reads that
+     * texture in place of the chain tap.
+     *
+     * **Per scale**, resolved by `rampAtScale` on the pattern `sizeScatterGainMax2x`
+     * established, because the reference's heavy component is a device-px quantity
+     * that does not simply halve between the scales (19.52 at 1x, 11.29 at 2x;
+     * claims §5.113 §2) — so a profile naming only the 1x end drags the 2x end
+     * toward the 2x constant's own default, and a document that means both names
+     * both.
+     *
+     * **At 0 the mechanism does not exist**: no texture is allocated, no pass is
+     * encoded, and the optics pass takes the single `textureSampleLevel` of the
+     * chain the material has always taken. That is what makes the landed 0.14.0
+     * goldens byte-identical.
+     *
+     * **What it costs, and what it gives up.** One texture and two passes per
+     * source per frame — 0.070 ms on the mobile bench row, against +1.1 ms for the
+     * in-shader grid G0 measured (W26 Decision Log 2 (b)). The width is then one
+     * per SOURCE rather than one per pixel, so the span grading `sizeScatterGainFar2x`
+     * carried does not reach the deep sample where this is on. The reference's heavy
+     * width does not grade with the span at 1x (claims §5.113 §4), which is what
+     * says the material can afford that; at 2x it does (the `-lg` row reads 16.92
+     * against `-md`'s 11.29), and that is a recorded gap rather than an answered
+     * one (W26 Decision Log 2 (f)).
+     *
+     * ---
+     *
+     * **WHAT WAS THEN MEASURED, and it moved the target as well as the width**
+     * (W26 G1b and G1c; claims §5.121 and §5.122; W26 Decision Log 5 and 6 (a)).
+     * The readings quoted above — 19.52 at 1x, 11.29 and 16.92 at 2x — are
+     * two-Gaussian fits to ONE backdrop each, and the same reference reads 8.4
+     * through `checkerboard-64` where it reads 19.5 through the impulse tile. They
+     * stand as recorded, with these beside them.
+     *
+     * The instrument of record is the family reader: the composite this renderer
+     * actually computes, fitted to the pixels jointly across every thick untinted
+     * backdrop of one surface, with a per-backdrop gain. It is the only reader in
+     * this wave that was held against a control — it returns vitrea's OWN drawn
+     * width to 0.6 % — and on it **Apple's heavy width is 8.6–9.2 device px at
+     * dpr 1 and 8.7–9.6 at dpr 2**, on both surfaces and in both schemes, with the
+     * share already right to 0.07. So the 13.418 the clamped tap drew at dpr 1 was
+     * half again too wide, and the reason two waves could not raise the share is
+     * that more of a too-wide heavy component is more of the wrong thing.
+     *
+     * **The landed 9 and 9**, fitted through a ladder the reader sees one for one
+     * (slope 0.995–1.111, rms 0.03–0.06 device px over seven rungs from 8 to
+     * 13.418), inverted per cell: 9.48 / 8.63 / 9.19 at dpr 1 and 8.13 / 9.79 /
+     * 8.37 at dpr 2. At dpr 1 the spread is 9.8 % and one number serves both spans;
+     * at dpr 2 it is 20.4 % and one number does not, which is the span grading of
+     * the paragraph above, now measured at 1.66 device px.
+     *
+     * **The mechanism has no small values** (W26 Decision Log 6 (c)). The paragraph
+     * above says the mechanism does not exist at 0; the counterpart is that it does
+     * exist at 0.001, where `heavyTapPlan` selects chain level 0 with a residual of
+     * a thousandth of a texel and the deep sample becomes the UNBLURRED backdrop.
+     * A near-zero σ is therefore the opposite of "almost off" — it is the widest
+     * possible departure from the material — and a profile must name 0 or a real
+     * width and nothing between. The domain is 0 or at least the chain's level-1
+     * width; a floor in `heavyTapPlan` would make it continuous, and the tracker
+     * carries it.
+     */
+    readonly sizeHeavyTapSigma: number;
+    readonly sizeHeavyTapSigma2x: 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
@@ -2531,6 +2952,160 @@ interface MaterialProfile {
     readonly backdropToneLow: number;
     readonly backdropToneHigh: number;
     readonly backdropToneSizeBias: number;
+    /**
+     * **The transmission the collapse keeps (W24 G1)** — and the correction, set
+     * BESIDE the paragraph above rather than over it, of what "texture collapse"
+     * was measured on.
+     *
+     * W7 fitted the collapse on `dark-solid`, a backdrop with no texture in it,
+     * and the paragraph above therefore says the collapse converges the interior
+     * on the backdrop's mean COLOUR. On a solid backdrop the mean and the pixel
+     * are the same number, so the fit could not tell the two apart; the impulse
+     * bed can, and it says they are not the same. Through the reference's
+     * collapsed `impulse__capsule-button` the centre dot still comes through at
+     * +0.0065 linear over a body of 0.0065 at 1x and +0.0254 over 0.0065 at 2x,
+     * where vitrea's collapsed capsule passes exactly 0.0000 (claims §5.107 §2).
+     * The reference's collapsed material is a dark glass that still transmits what
+     * lies beneath it, blurred — it collapses the LEVEL, not the structure.
+     *
+     * The arithmetic the collapse already has makes the correction one constant.
+     * Writing `M` for the unadapted composite this pass would otherwise produce,
+     * the (colour, alpha) pair the shader solves reduces exactly to
+     * `colour = (1 − k)·M + k·target`, and `target` is today the group's mean
+     * backdrop colour — one number for the whole surface, which is precisely what
+     * flattens the dot away at `k` 1. So `collapseTransmission` lerps the TARGET
+     * from that mean (0) to the per-pixel blurred backdrop sample the refraction
+     * path already computed (1):
+     *
+     *     target = mix(toneColour.rgb, backdrop, collapseTransmission)
+     *
+     * The tone axis's ARGUMENT is untouched — `k` is still read from the group's
+     * mean luminance and the size bias, and the response law still solves against
+     * `toneAnchor.w` — so the collapse collapses exactly as far as it did and
+     * only stops flattening what is under it. The blurred sample's mean under the
+     * surface is the group's mean to within the difference between a local and a
+     * global average, so the body's LEVEL moves by less than a code where the
+     * backdrop is anything like uniform, and not at all where it is solid: over
+     * `dark-solid` the sample IS the mean and every collapsed cell of that bed is
+     * byte-identical at any value of this constant. That is the stop the fit is
+     * checked against.
+     *
+     * At 0 the target is the mean and the shader's arithmetic is W7's to the bit,
+     * which is why this can be added without moving a pixel anywhere.
+     *
+     * What it cannot carry is the reference's WIDTH. Fitted on the reference's own
+     * dot the transmitted profile is a 4 CSS px box convolved with σ 2.63 device
+     * px at 1x and σ 1.38 device px at 2x — the same kernel the reference's
+     * UNCOLLAPSED cells show (σ 2.86 / 1.40 device px on `impulse__rrect-md`), so
+     * the collapse does not change Apple's blur, but that kernel is neither
+     * CSS-invariant nor device-invariant and vitrea's is neither of those numbers.
+     * This constant sets how MUCH comes through; how WIDE it arrives is the
+     * material's own scatter law and is recorded as a gap, not fitted here
+     * (W24 G1 findings).
+     */
+    readonly collapseTransmission: number;
+    /**
+     * **The collapse's transmission at dpr 2** (W24 G1), the second anchor of the
+     * constant above, on the pattern `sizeScatterGainMax2x` established for the
+     * body's own second scale (claims §5.69 §1).
+     *
+     * It is a per-scale reading and not a per-scheme one, and the evidence is the
+     * fixtures': the light and dark captures of the collapsed cells are the same
+     * bytes, so the collapsed appearance is one appearance in both schemes, while
+     * the width the reference transmits through is a different number at each
+     * scale. Fitted on the reference's own dot, its kernel is a 4 CSS px box
+     * convolved with σ 2.63 device px at 1x and σ 1.38 device px at 2x — a width
+     * that is invariant in neither CSS nor device pixels — so the SHARE that comes
+     * through cannot be one number over a kernel that is two.
+     *
+     * Defaults to the 1x constant, so a profile that names only that one renders
+     * it at every ratio and this anchor is the identity on the landed material.
+     */
+    readonly collapseTransmission2x: number;
+    /**
+     * **The rim that survives the collapse (W23)** — the one mark the collapsed
+     * appearance keeps.
+     *
+     * The paragraph above is right about the body and wrong about the rim. W7 read
+     * the settled reference's `dark-solid__capsule-button` as "byte-identical to
+     * its own background, rim included", and at the contour it never was: the
+     * fixture carries a body one code BELOW its backdrop and a contour rim of
+     * +0.020 linear per CSS px (55/255 on a 28/255 backdrop at 2x), in every
+     * standard profile, at both scales, in both schemes (claims §5.99). vitrea
+     * folds that rim out with everything else through the shader's one
+     * `present = 1 − toneAdapt`, and the user's eye named the result: "not one of
+     * our glasses is visible on black, where Apple's clearly show their presence."
+     *
+     * So the shader's rim becomes
+     * `rimWeight × (rimAmplitude × present + rimCollapsed × toneAdapt)`: the
+     * scheme's own rim fading out with the adaptation as it does now, and an
+     * absolute rim the collapsed appearance owns rising with it. At `toneAdapt` 0
+     * nothing changes at all, which is why this constant can be added without
+     * moving a single uncollapsed pixel.
+     *
+     * It lives on the profile and NOT in the dark patch, because the collapsed
+     * appearance is scheme-independent and the fixtures say so: the light and dark
+     * fixtures of `dark-solid__capsule-button` are byte-identical at both scales
+     * (W23 X4). A reading that separates the schemes under collapse is a finding
+     * about the wave, not a second constant. G0 strengthened the evidence: the
+     * identity survives an AUTHOR TINT — `dark-solid__capsule-button__rest-tint-
+     * orange` is the same bytes in both schemes at both scales — so what the
+     * collapse draws is one appearance however the surface was painted.
+     *
+     * It is expressed in its own units and not in the dark rim's, because the two
+     * were measured apart: see the value's own note on the default profile.
+     */
+    readonly rimCollapsed: number;
+    /**
+     * **The rim a PAINTED surface keeps under the collapse** (W23 G1; claims
+     * §5.100 §5, Decision Log 2 (c)) — `rimCollapsed`'s sibling, at the author
+     * tint's full coverage, with the two lerped by the coverage between them.
+     *
+     * The reference's collapsed capsules keep +0.020 of contour rim bare and
+     * **+0.115 painted** (`dark-solid` and `impulse` `capsule-button`
+     * `rest-tint-orange`, both schemes, both scales, on fixtures that are the same
+     * bytes in the two schemes). An author tint over black is painted, not
+     * adapted: the tone collapse takes the material's own appearance to its
+     * backdrop and the colour the author put on it does not go with it.
+     *
+     * It is ABSOLUTE, in its own units, for the same reason `rimCollapsed` is and
+     * on the same evidence — and G1 measured what the alternative would have cost.
+     * Decision Log 2 (c) proposed gating the collapse itself on the tint's
+     * coverage, so that a painted surface keeps its APPEARANCE's own rim; rendered,
+     * that mechanism needs a gate of 0.534 on the light bed and 0.294 on the dark
+     * one to reach +0.115 on a cell whose reference fixture is byte-identical
+     * between the schemes, because it makes the kept rim proportional to each
+     * scheme's own amplitude law and those differ by 1.8× there. A proportional
+     * form cannot draw one appearance from two materials; an absolute one does,
+     * which is X4 again and the reason this constant has the shape it has.
+     *
+     * It is fitted on orange alone, and that is a stated limit: the reference's
+     * collapsed tint-blue capsule reads +0.176 against orange's +0.115, so the
+     * quantity depends on the tint's own colour, and every collapsed blue cell on
+     * the bed is holdout. What lands here is the orange rows' answer with the
+     * colour dependence recorded as future work.
+     */
+    readonly rimCollapsedTinted: number;
+    /**
+     * **How much of an author tint's own colour the rim's light is spent in**
+     * (W23 G3; claims §5.102) — 0…1, multiplied by the surface's tint coverage.
+     *
+     * Apple's rim on a painted surface is the paint LIFTED, not white added over
+     * it. Read on the contour row's straight-span mean colour at 2x in light, an
+     * orange paint of (255, 148, 0) rises to (254, 188, 0) with its blue channel
+     * still at 0, and a blue paint of (8, 120, 236) to (59, 199, 248); vitrea drew
+     * (255, 192, 130) and (145, 183, 255) — the same rim in white, which turns an
+     * orange edge peach and a blue edge lilac. No luminance clause sees it: the
+     * rim's amplitude is right and its colour is not.
+     *
+     * So the rim's light is spent in `mix(white, paint / max(paint), chroma × s)`.
+     * The paint is normalised by its own brightest channel rather than by its
+     * luminance, so a dark paint darkens the rim's HUE and not its amount, and the
+     * factor is the pixel's own tint strength, so an untinted surface keeps a white
+     * rim at every value of this constant — which is what makes the mechanism reach
+     * painted pixels only and every untinted capture byte-identical (W23 S10).
+     */
+    readonly rimTintChroma: number;
     /**
      * **The backdrop tone response (W9)** — the law that owns the interior MEAN,
      * where the four constants above own texture collapse and nothing else.
@@ -2591,6 +3166,31 @@ interface MaterialProfile {
      * specular from.
      */
     readonly lightDirection: readonly [number, number];
+    /**
+     * **The lit edge's axis (W24; claims §5.107)** — the unit direction `L` the
+     * rim's directional factor is symmetric about, in the same viewport
+     * coordinates as `lightDirection`, y pointing down.
+     *
+     * It is a SEPARATE constant from `lightDirection` and not a second reading of
+     * it, for two reasons the rows give. First, they are measured to differ: the
+     * rim's axis fits at 136° of compass bearing over the 19 solid rows (135.0° ±
+     * 0.7° over the dark rows alone, 137.7° ± 1.5° over the light ones), where
+     * `lightDirection` [−0.3714, −0.9285] is a bearing of 338.2°, an axis of
+     * 158.2° — 22° away, and it was fitted for the inner shadow and the sweep, not
+     * for the contour. Second, `light.xy` reaches the one-sided `spec` term this
+     * factor replaces, and re-pointing it to fit the contour would move the
+     * shadow's own light with it; a constant of its own keeps that seam where W2
+     * and W22 left it.
+     *
+     * The default is the exact diagonal (−1, −1)/√2 — a bearing of 135° — and not
+     * the fitted 136°: the rows do not separate the two (the joint fit's RMS moves
+     * by less than a thousandth between them), and only the exact diagonal makes
+     * the factor equal on all four straight sides, which is what lets the
+     * amplitude's re-expression be exact rather than a 2 % trade against W23's
+     * straight-span reads. `rimLitExponent` is 0, so the axis draws nothing until a
+     * profile carries an exponent.
+     */
+    readonly rimLitAxis: readonly [number, number];
     /** Specular sweep band width in radians, and the press glow's reach in CSS px. */
     readonly sweepBandRadians: number;
     readonly glowRadiusCss: number;
@@ -2629,6 +3229,11 @@ interface MaterialProfilePatch {
     readonly sizeScatterRampStartFar2x?: number;
     readonly sizeScatterRampReach1xPx?: number;
     readonly sizeScatterRampReach2xPx?: number;
+    readonly sizeScatterHeavyShareThick1x?: number;
+    readonly sizeScatterHeavyShareThick2x?: number;
+    readonly sizeToneLevelFar?: number;
+    readonly sizeHeavyTapSigma?: number;
+    readonly sizeHeavyTapSigma2x?: number;
     readonly sizeOcclusionGain?: number;
     readonly sizeShadowGainMax?: number;
     readonly lensRefractionGain?: number;
@@ -2653,12 +3258,18 @@ interface MaterialProfilePatch {
     readonly backdropToneLow?: number;
     readonly backdropToneHigh?: number;
     readonly backdropToneSizeBias?: number;
+    readonly collapseTransmission?: number;
+    readonly collapseTransmission2x?: number;
+    readonly rimCollapsed?: number;
+    readonly rimCollapsedTinted?: number;
+    readonly rimTintChroma?: number;
     readonly backdropToneAnchorX?: readonly [number, number, number];
     readonly backdropToneResponseThin?: readonly [number, number, number];
     readonly backdropToneResponseThick?: readonly [number, number, number];
     readonly backdropToneResponseStrength?: number;
     readonly outerShadow?: Readonly<Partial<MaterialOuterShadow>>;
     readonly lightDirection?: readonly [number, number];
+    readonly rimLitAxis?: readonly [number, number];
     readonly sweepBandRadians?: number;
     readonly glowRadiusCss?: number;
     readonly glowGain?: number;
@@ -3407,6 +4018,7 @@ interface RebuildLedger {
  * import      provider frame  ->  chain mip 0     (premultiplied linear, X5)
  * downsample  mip n-1         ->  chain mip n     (13-tap, one pass per level)
  * blur x2     chain[bodyLvl]  ->  body            (separable, residual sigma)
+ * blur x2     chain[heavyLvl] ->  heavy           (separable, residual sigma; W26)
  * analysis    chain[anaLvl]   ->  stats buffer    (compute, one workgroup)
  * ```
  *
@@ -3421,6 +4033,23 @@ interface PyramidResources {
     readonly plan: PyramidPlan;
     readonly chain: GPUTexture;
     readonly body: GPUTexture;
+    /**
+     * The **heavy** blur (W26; `MaterialProfile.sizeHeavyTapSigma`) — one more
+     * texture beside the body, built by the same two separable passes from
+     * whichever chain level `heavyTapPlan` names, and `undefined` where the
+     * profile asked for no width.
+     *
+     * It is here rather than in the optics pass because the optics pass is a
+     * fragment shader over the glass's own area: W26 G0 measured a 9 × 9 in-shader
+     * grid at +1.1 ms on the mobile bench row against 0.070 ms for the two
+     * separable passes the chain already runs (W26 Decision Log 2 (b)). The price
+     * of building it here is that the width is **one per source** rather than one
+     * per pixel — every group sampling this source gets the same heavy width,
+     * because the texture is built before any group is drawn. The reference's heavy
+     * width does not grade with the span at 1x (claims §5.113 §4), which is what
+     * says the material can afford that.
+     */
+    readonly heavy: GPUTexture | undefined;
     readonly stats: GPUBuffer;
     /** Source size epoch this allocation was made for. */
     readonly sizeEpoch: number;
@@ -3458,6 +4087,14 @@ interface PyramidResources {
      * chain's body and `bodyChainLod` belong to the previous scale.
      */
     readonly bodySigmaCss: number;
+    /**
+     * The heavy blur's σ in **CSS px** the build converted with, for `sameBody`'s
+     * reason and by the same rule: the heavy width is a device-px quantity
+     * (claims §5.113 §2), so `sizeHeavyTapSigma / dpr` is what reaches the source's
+     * texels, and a window dragged between displays asks for a different heavy
+     * texture from the same clean source.
+     */
+    readonly heavySigmaCss: number;
 }
 interface PyramidInstrumentation {
     /** Successful rebuilds since the store was created. */
@@ -3487,6 +4124,12 @@ interface PyramidBuildRequest {
      * The build resolves it once the frame's real extent is known.
      */
     readonly bodySigmaCss: number;
+    /**
+     * The heavy blur's σ in **CSS px** (W26), 0 where the profile declines the
+     * width — at which point nothing is allocated and nothing is drawn, so a
+     * material that names no heavy width pays for none of this.
+     */
+    readonly heavySigmaCss: number;
     readonly viewportCss: readonly [number, number];
     /**
      * Where the source sits on the plane, in CSS px relative to the viewport, if