@vitreajs/vitrea 0.11.0 → 0.14.0

package/dist/{dist-JWOMZCFF.js → dist-PT4PUS4K.js}

@@ -255,7 +255,70 @@ var DEFAULT_MATERIAL_PROFILE = {
       tint: srgbToLinear(SRGB_WHITE_TINT),
       tintAlpha: 0.46,
       rimWidth: 1.5,
-      rimAlpha: 0.18,
+      /*
+       * REFITTED 0.18 → 0.844 (W23 G1; claims §5.100 §4, W23 Decision Log 2 (a)),
+       * as the intercept of the amplitude law below rather than as the whole rim.
+       *
+       * It is not the same quantity it was. Before W23 this constant WAS the rim,
+       * and 0.18 drew the same +0.060…0.078 of linear luminance at the contour on
+       * every cell of the light bed against a reference of +0.10…+0.26; now it is
+       * one of two terms, and on a light surface whose own level is 0.48 the pair
+       * draws `0.844 − 0.628 × 0.48 = 0.542` of amplitude — three times the old
+       * constant, for a rim about a third brighter than the old one at the
+       * contour, because the amplitude is not the rim: the band weight `W` the
+       * first two CSS px carry is 0.38…0.46 (claims §5.100 §4).
+       *
+       * Fitted on vitrea's OWN captures, not on a prediction: the shader's rim is
+       * linear in each constant, so a base capture at the shipped `rimAlpha`
+       * gives each cell's band weight and one rendered `rimLevelGain` point gives
+       * `W × L`, and the pair is solved by least squares over 40 rendered solid
+       * rows on 10 cells. **The canonical bed cannot fit it** — over a solid
+       * backdrop, unclipped, uncollapsed and outside the holdout the light bed
+       * leaves exactly two cells at bodies 0.48 and 0.43, and two nearly collinear
+       * rows separate no slope from an intercept (solved on 1x alone they give
+       * (0.302, +0.569) and on 2x alone (0.383, +0.183), a factor of three apart
+       * and both with the wrong sign) — so W9's light probe grid, whose bodies
+       * span 0.43…0.93, is what conditions the solve (9.7). That the routine
+       * harness captures no probe grid is recorded as a gap, not fixed here.
+       *
+       * Rendered, on the rows the wave's acceptance names: the light 1x solid
+       * cells go from 0.087 to 0.016 mean |rim − reference| per side (worst 0.168
+       * → 0.033) and `dark-solid__rrect-md` from 0.068 to 0.227 against the
+       * reference's 0.229.
+       *
+       * W22 G1 declined this constant on the same rows and that decline is not
+       * rewritten (claims §5.94 §3): it was read through the declared box's 3 CSS
+       * px band, whose peak-row mean over a dark backdrop carries the corners'
+       * backdrop and dilutes a one-pixel line, and it was the right answer to the
+       * question that instrument asked. The contour read is a different question.
+       */
+      rimAlpha: 0.844,
+      /*
+       * FITTED 1.35 (W23 G1; claims §5.100 §5, Decision Log 2 (d)) — the band at
+       * dpr 2, about 10 % narrower than at dpr 1.
+       *
+       * Two clauses of the wave meet on this constant and they pull opposite
+       * ways, which is why it is not simply the minimiser of one of them. The
+       * uncollapsed 2x solids want the band NARROW: at 1.5 `dark-solid__rrect-md`
+       * reads +0.2467 against the reference's +0.2052 on the light bed, and the
+       * rendered ladder point at 1.2 reads +0.1883, so the row's own answer is
+       * 1.29. The COLLAPSED cells want it wide, because `rimCollapsed` was
+       * fitted through this same band: at 1.5 they read −0.0017 from the
+       * reference and at 1.2 −0.0059, which is outside the wave's 0.005.
+       *
+       * 1.35 leaves the solids at +0.0123 against a bound of 0.03 and the
+       * collapsed sides at 0.0038 against a bound of 0.005 — each clause inside
+       * its own bound with margin in proportion to how tight that bound is. The
+       * joint minimiser over the twelve rows is 1.30, and it is not taken: at
+       * 1.30 the collapsed sides read 0.0045 against a 0.005 bound, a margin of
+       * 0.0005 on an instrument whose 8-bit resolution at that level is 0.00067.
+       *
+       * The dark bed does not identify it — its one 2x solid row moves by 0.0061
+       * across the whole ladder and is inside the bound at every value — so this
+       * is the light bed's constant, checked against the dark bed rather than
+       * fitted on it.
+       */
+      rimWidth2x: 1.35,
       specularPower: 6,
       /*
        * FITTED 0.55 → 0 (W22 G1; claims §5.94 §3, W22 Decision Log 2 (b)). The
@@ -303,6 +366,112 @@ var DEFAULT_MATERIAL_PROFILE = {
        * makes it inert.
        */
       specularGain: 0,
+      /*
+       * FITTED −0.628 (W23 G1; claims §5.100 §4, W23 Decision Log 2 (a)) — the
+       * light rim is a fraction of the body's HEADROOM, and the negative sign is
+       * the measurement.
+       *
+       * On the reference's own solid, unclipped, uncollapsed light sides — 44 of
+       * them, bodies 0.4287…0.9326, from both canonical scales and W9's probe
+       * grid — the rim falls as the surface brightens: `0.3559 − 0.2752 × base`,
+       * mean |residual| 0.0081 where an additive constant reads 0.0249 and a pure
+       * screen 0.0168. A pure screen would need the slope to be exactly −α; it is
+       * −0.275 against the −0.43 the screen form requires, which the canonical
+       * bed's two cells at 0.43 and 0.48 could not have told apart and the probe
+       * grid's range can. So the light rim is a white line composited source-over
+       * — the form the CSS tier's inset `box-shadow` has always drawn — with an
+       * additive part beside it, and this is that composite written once.
+       *
+       * The gain is steeper here (−0.628) than on the reference (−0.2752) for the
+       * same reason `rimAlpha` is larger than the rim: this constant multiplies
+       * the shader's per-pixel `rimLuma` before the band weight, and the fit is
+       * the one solved on rendered rows.
+       */
+      rimLevelGain: -0.628,
+      /*
+       * ADOPTED 1.15 (W24 G2, on G0's fit; claims §5.108 §1, W24 Decision Log 2
+       * (a)) — one exponent for both schemes and both scales, and the value at
+       * which the most rows meet the wave's clause.
+       *
+       * The rows, and what they separate. Fitted on the reference's own angular
+       * bins over the nineteen untinted solid cells of both canonical beds and
+       * both probe grids (285 bins, each cell normalised by its own brightest
+       * bin), the joint minimiser is 1.05; the 2x rows — whose arcs the raster
+       * actually resolves — give 1.10 light and 1.30 dark, and vitrea's own
+       * rendered rows read against the reference give 1.10 ± 0.22 light and
+       * 1.24 ± 0.17 dark. The schemes OVERLAP, so what the rows separate is one
+       * constant and not two, and 1.15 is where four of the twelve solid rows
+       * meet both halves of clause 1 against two at 1.00, two at 1.30 and none
+       * at 1.45.
+       *
+       * What it is not. It is not a per-scale pair: every 2x row wants 1.30–1.45
+       * and every 1x row 0.85–1.10, which is a real scale dependence in the
+       * reference's own angular contrast (its lit-diagonal bins over its
+       * straight-side bins read 1.07 at 1x against 1.39 at 2x on the dark
+       * `dark-solid` capsule). A `rimLitExponent2x` sibling on the precedent of
+       * `rimWidth2x` would be a third constant fitted on four rows, so the
+       * dependence is recorded (W24's Deferred list) rather than carried.
+       *
+       * The `clear` variant keeps 0 below: no scene on either bed declares it, so
+       * it has no rows and nothing to be fitted on (C9a §6.2).
+       *
+       * RE-FITTED 1.15 → 0.85 (W25 G3b, on the parent's ruling; claims §5.115,
+       * W25 Decision Log 6), JOINTLY with `rimAlongSideSlope` below and not
+       * separately, because the two multiply the same rim amplitude and both peak
+       * on this same diagonal. W24 fitted this exponent with the position term
+       * ABSENT, over 285 bins that include the corner arcs, so it absorbed part of
+       * a grading that is not a function of the normal at all — and W25 G0's
+       * along-side reader, which walks only the STRAIGHT part of a side where this
+       * factor is exactly 1, could not see the overlap from its side either.
+       * W25 G3's dry run measured the consequence: at slope 0.45 under exponent
+       * 1.15 the NW and SE bins of the 1x light `dark-solid__rrect-md` went 0.142
+       * → 0.203 against a reference of 0.122, and the thick solids' mean bin error
+       * rose on 26 rows of 28.
+       *
+       * The joint fit is a rendered GRID over the plane — 46 points, each a real
+       * render of the solid rows of all four standard profiles, read by W24's
+       * angular reader and W25's along-side reader together
+       * (`results/2026-09-09-w25-thick-span-composite/g3/g3b-fit.txt`). The pair
+       * below is the joint objective's minimum among the pairs that keep the thick
+       * solids' angular error at or under the 0.13.0 bed's — the ruling's own
+       * acceptance condition — AND that leave every cell of the bed measurable:
+       * thick bin error 0.17527 → 0.17208 and thick range error 0.43269 → 0.37472,
+       * on 16 rows improving against 12. The objective's own minimum over the
+       * allowed set is (0.70, 0.15), and it is refused for a reason no metric
+       * carries: at that pair the collapsed `dark-solid__capsule-button` loses its
+       * contour on the GPU tier at 1x in both schemes — the capsule's band is
+       * entirely corner arc, which is where both of these factors dim it, and the
+       * extractor reads a 0.00 px contour and drops two calibration cells out of
+       * the bed. A change that narrows the instrument is not a fidelity gain.
+       */
+      rimLitExponent: 0.85,
+      /*
+       * W25's along-side field, FITTED (claims §5.113 and §5.115; W25 Decision
+       * Log 3 (c), landed at G3's declaration).
+       *
+       * Its own readers want more of it: G2 fitted 0.45 on the 64 straight sides
+       * of the two 1x probe grids' flat solids and G3 re-fitted 0.425–0.479 on the
+       * probe set's 64 sides at both scales in both schemes, and at 0.45 the
+       * corner-to-corner range reaches 0.743 of the reference's against 0.227
+       * without it. What the along-side reader cannot see is the corner ARCS,
+       * where this factor multiplies a rim that `rimLitExponent` has already
+       * brightened on the same diagonal — so the value here is not that fit's, it
+       * is the JOINT one (W25 G3b; W25 Decision Log 6): the minimum over a
+       * rendered grid of the two readers' errors together, among the pairs that
+       * keep the thick solids' angular error at or under the 0.13.0 bed's.
+       *
+       * At (0.70, 0.15) the thick solids' bin error falls 0.17527 → 0.17000 and
+       * their range error 0.43269 → 0.34919 — a fifth of the grading, where 0.45
+       * under the old exponent bought three quarters of it and cost half again as
+       * much bin error. The remaining four fifths are not this constant's to buy:
+       * the arcs' amplitude is W23's rim law, fitted on the straight spans both of
+       * these factors leave alone, and until it moves the two of them are trading
+       * against each other rather than against Apple.
+       *
+       * The `clear` variant keeps 0 below, as the lit edge does: no scene on
+       * either bed declares it, so it has no rows (C9a §6.2).
+       */
+      rimAlongSideSlope: 0.1,
       shadowDepth: 0.35,
       /*
        * REFITTED 0.55 → 0.05 (2026-08-31), and it is the largest single
@@ -327,8 +496,18 @@ var DEFAULT_MATERIAL_PROFILE = {
       tintAlpha: 0.1,
       rimWidth: 1.25,
       rimAlpha: 0.14,
+      // No scene on the calibration bed declares this variant, so its rim has no
+      // rows: the amplitude law stays at the additive form and the band stays
+      // ungraded across the scales (W22's rule for `clear`, C9a §6.2).
+      rimWidth2x: 1.25,
       specularPower: 8,
       specularGain: 0.45,
+      rimLevelGain: 0,
+      // No scene declares this variant, so the lit edge has no rows here either
+      // and the factor stays inert (C9a §6.2, as `rimLevelGain` above).
+      rimLitExponent: 0,
+      // Nor does the along-side field have rows here, for the same reason.
+      rimAlongSideSlope: 0,
       shadowDepth: 0.22,
       shadowAlpha: 0.4,
       highlight: srgbToLinear(SRGB_WHITE_TINT)
@@ -515,6 +694,41 @@ var DEFAULT_MATERIAL_PROFILE = {
   sizeScatterRampStartFar2x: 0.21,
   sizeScatterRampReach1xPx: 80,
   sizeScatterRampReach2xPx: 100,
+  // W25's three mechanisms, all INERT at the defaults (claims §5.113; W25
+  // Decision Log 3). The heavy share's thick lift and the level term above the
+  // knee are zero, so `kDeep` and the tone response's blend are the curves W11c
+  // and W9 fitted, to the bit; the along-side field's slope lives on the optics
+  // beside `rimLitExponent` and is zero there. G2 fits them and G3 declares
+  // them; what the fits read is recorded in
+  // `results/2026-09-09-w25-thick-span-composite/g2/`.
+  sizeScatterHeavyShareThick1x: 0,
+  sizeScatterHeavyShareThick2x: 0,
+  sizeToneLevelFar: 0,
+  // The heavy blur, FITTED (W26; claims §5.121 for the identification and §5.122
+  // for the fit; W26 Decision Log 6 (a)). Apple's heavy width is 8.6–9.5 device px
+  // at BOTH scales, read by the family reader — the one instrument in this wave
+  // that passed a control, reproducing vitrea's own drawn width to 0.6 % — and
+  // inverted through a ladder whose slope is 0.995–1.111 at an rms of 0.03–0.06
+  // device px. What the 0.14.0 material drew at dpr 1 was `CHAIN_LEVEL_SIGMA[4]` =
+  // 13.418, the pyramid's LAST level, because `scatterLod` was clamped there: half
+  // again too wide, and the share the two previous waves tried to raise was already
+  // right to within 0.07. The reference asks 9.48 / 8.63 / 9.19 at dpr 1 (spread
+  // 9.8 %, so one number serves both spans) and 8.13 / 9.79 / 8.37 at dpr 2 (spread
+  // 20.4 %, so one number does not — the 1.66 device px between spans 96 and 160 is
+  // the grading `sizeScatterGainFar2x` used to carry, and one width per source
+  // cannot; W26 Decision Log 2 (f) chose that knowingly). Nine is within 1.1 % of
+  // the 1x mean and 0.4 % of the 2x light pair's, and it takes
+  // |log(read / reference)| from 0.275 to 0.069 over six cells.
+  //
+  // THE MECHANISM HAS NO SMALL VALUES (W26 Decision Log 6 (c)). `pyramid.ts` builds
+  // the heavy texture whenever `heavySigmaCss > 0`, and at σ 0.001 `heavyTapPlan`
+  // selects chain level 0 with a residual of a thousandth of a texel — which makes
+  // the deep sample the RAW backdrop and moves every 2x row. So 0.001 is not
+  // "almost off"; it is the opposite of off. The inert value is exactly 0, and
+  // neither anchor may ever carry a small non-zero. The domain is 0 or at least the
+  // chain's level-1 width, and the tracker carries the floor that would close it.
+  sizeHeavyTapSigma: 9,
+  sizeHeavyTapSigma2x: 9,
   sizeOcclusionGain: 0.05,
   sizeShadowGainMax: 1,
   /*
@@ -647,6 +861,122 @@ var DEFAULT_MATERIAL_PROFILE = {
    * thickness axis now.
    */
   backdropToneSizeBias: 0.05,
+  /*
+   * FITTED 0.017 at dpr 1 and 0.070 at dpr 2 (W24 G1, landed by G2; claims
+   * §5.108 §2, W24 Decision Log 2 (b) and (d)) — one pair for both schemes, on
+   * the peak of the collapsed `impulse__capsule-button`'s centre dot.
+   *
+   * At `k` 1 the composite is exactly `(1 − c)·toneColour + c·backdrop`, so the
+   * dot's excess is LINEAR in this constant and one non-zero rendered rung fixes
+   * it: at c 0.10 vitrea's collapsed capsule passes +0.0386 at 1x and +0.0363 at
+   * 2x where the reference passes +0.0066 and +0.0254, which gives 0.0171 and
+   * 0.0700. Rendered back at the fit the dot lands +0.0067 and +0.0256 —
+   * clause 2's peak met to ±0.0002 against a bound of 0.005 — and the structure
+   * that had been passing 0.0000 passes 0.0066 at 1x and 0.0250 at 2x against
+   * the reference's 0.0104 and 0.0205.
+   *
+   * The light and dark rungs read the same numbers to four decimals on that
+   * cell, which is why this is one pair in both schemes and lives on the shared
+   * default rather than in a per-scheme patch. What separates the two ANCHORS is
+   * the kernel and not the scheme: the reference transmits through σ 2.63 device
+   * px at 1x and 1.30 at 2x — invariant in neither CSS nor device pixels — where
+   * vitrea's runs 1.68 → 4.86, so the SHARE that comes through cannot be one
+   * number over a width that is two. How wide the dot ARRIVES is the material's
+   * own scatter law and is a recorded gap, not a fit (the dot's FWHM lands 4.99
+   * CSS px at 1x against the reference's 7.57, and 4.64 against 3.80 at 2x).
+   *
+   * What it costs the bed is two cells. `impulse__capsule-button` at 2x pays
+   * ΔE +0.00006 and `ssimMean` −0.00096 while its `ssimMin` improves by 0.068
+   * and its interior level closes 68 % of its gap; `impulse__rrect-md` at 1x
+   * improves; every other capture on both beds is byte-identical, including
+   * `dark-solid__capsule-button`, the collapsed stop, where a solid backdrop
+   * makes the target's lerp the identity by construction.
+   *
+   * The correction this constant carries is set beside W7's paragraph above, not
+   * over it: "texture collapse" was fitted on `dark-solid`, where a mean and a
+   * pixel are the same number and no fit could have told them apart. Every
+   * figure W7 recorded stands; what it did not measure is what happens over a
+   * backdrop that HAS texture, and the impulse bed says the reference keeps it.
+   */
+  collapseTransmission: 0.017,
+  collapseTransmission2x: 0.07,
+  /*
+   * FITTED 0.038 (W23 G1; claims §5.100 §3, W23 Decision Log 2 (b)) — and it is
+   * NOT the dark material's rim, which is the one thing the charter thought it
+   * might be.
+   *
+   * The reference's collapsed rim, read at the contour over 11 cells and 28
+   * sides of both beds at both scales, is +0.0189 mean (+0.0196…+0.0204 over
+   * `dark-solid`, +0.0149…+0.0168 over `impulse` — the spread is the backdrop,
+   * not noise). The dark material's OWN rim over the same backdrop, uncollapsed,
+   * is +0.0256…+0.0258. The two are 0.0068 apart, nine 8-bit codes at that level
+   * on an instrument that is exact in float and resolves 0.00067 there, so the
+   * collapsed rim is an absolute constant in its own units and the charter's
+   * conditional resolves to no.
+   *
+   * 0.038 is the minimiser over every collapsed side: the worst residual reads
+   * 0.0042 at 0.035, **0.0031 at 0.038**, 0.0041 at 0.040 and 0.0065 at 0.045,
+   * and it is the only value that leaves every untinted collapsed side inside
+   * the wave's clause 1 (0.005) with margin. Rendered, the collapsed sides go
+   * from 0.0180 to 0.0021 mean |rim − reference|.
+   *
+   * The per-row answers span 0.0317…0.0441, which under a rule that refuses a
+   * constant its rows do not separate (C9a §6.2) needs a stated reason: the rows
+   * disagree because the REFERENCE's own collapsed rim differs by backdrop —
+   * +0.0200 over `dark-solid` against +0.0158 over `impulse` — and not because
+   * the constant is unidentified on vitrea's side, where the leverage is exactly
+   * linear and every row reads the same slope.
+   *
+   * The collapsed BODY is read and not chased: 0.01103 native against 0.01171
+   * web over `dark-solid` (+1.05 codes) and 0.00664 against 0.00367 over
+   * `impulse` (−6.2 codes). This constant does not touch it.
+   */
+  rimCollapsed: 0.038,
+  /*
+   * REFITTED 0.337 → 0.520 (W23 G3; claims §5.102) under the painted rim's own
+   * composition. The reference's collapsed tint-orange capsule keeps +0.1149 of
+   * contour rim at 1x and +0.1179 at 2x where the bare one keeps +0.0200, and
+   * the drawn rim is linear in this constant, so one rendered point per scale
+   * gives each row its own answer.
+   *
+   * It moved because the LIGHT is now spent differently, not because the reading
+   * did. `rimTintChroma` spends a painted surface's rim in the paint's own
+   * chromaticity, and an orange paint's red channel is already at 255, so the
+   * share of the light that goes there is lost to the raster: at 0.337 the
+   * collapsed painted rim fell from +0.115 to +0.072 against a reference of
+   * +0.118. The constant carries what the composition costs, which is what an
+   * absolute constant is for.
+   *
+   * The per-side answers are 0.510 at 1x and 0.544 at 2x — the difference is the
+   * band, which is scale-graded and this constant is not — and 0.520 is the
+   * minimiser over all twelve sides, worst residual 0.0055. The three non-holdout
+   * cells that carry it (`dark-solid__capsule-button__rest-tint-orange` and
+   * `impulse__capsule-button__rest-tint-orange` on the light bed and
+   * `dark-solid__capsule-button__rest-tint-orange` on the dark one) answer the
+   * same value in both schemes, because the constant is absolute (X4).
+   */
+  rimCollapsedTinted: 0.52,
+  /*
+   * FITTED 1 (W23 G3; claims §5.102) — the rim's light on a painted surface is
+   * spent ENTIRELY in the paint's own chromaticity.
+   *
+   * The rows do not merely prefer it, they ask for more than the constant can be:
+   * over 52 tinted sides of both beds at both scales the per-side answer is
+   * 0.921…1.732 with a mean of 1.154, and the objective is monotone up to the
+   * bound. A mix weight cannot exceed 1, so 1 is both the fit and the ceiling,
+   * and what the rows are really saying past it is that the tinted rows' AMOUNT
+   * is short in the dark scheme — which is the amplitude law's residual and not
+   * this constant's (see below).
+   *
+   * Rendered, mean |Δ| of the contour row's OKLab against the reference's, over
+   * every tinted side of both beds at both scales: **b 0.0554 → 0.0093** and
+   * **a 0.0399 → 0.0222**, with the sides outside the wave's 0.02 falling from
+   * 52 of 52 to 36. The whole of the remaining 36 is `a` on the dark bed's tinted
+   * rows, where vitrea's rim is 0.031 against a reference of 0.127: a rim that
+   * dim cannot move its row's hue whatever colour it is spent in, so that
+   * residual is the dark law's amount and is recorded as one.
+   */
+  rimTintChroma: 1,
   /*
    * MEASURED (W9 probe, claims §5.30–§5.33): the anchors are the probe bed's
    * settled reference levels, frequency-settled over seven attested runs,
@@ -758,6 +1088,7 @@ var DEFAULT_MATERIAL_PROFILE = {
     sizeGain: 0
   },
   lightDirection: [-0.3714, -0.9285],
+  rimLitAxis: [-0.7071, -0.7071],
   sweepBandRadians: 0.55,
   glowRadiusCss: 44,
   glowGain: 0.6,
@@ -802,6 +1133,8 @@ var BACKDROP_TONE_MAX = DEFAULT_MATERIAL_PROFILE.backdropToneMax;
 var BACKDROP_TONE_LOW = DEFAULT_MATERIAL_PROFILE.backdropToneLow;
 var BACKDROP_TONE_HIGH = DEFAULT_MATERIAL_PROFILE.backdropToneHigh;
 var BACKDROP_TONE_SIZE_BIAS = DEFAULT_MATERIAL_PROFILE.backdropToneSizeBias;
+DEFAULT_MATERIAL_PROFILE.collapseTransmission;
+DEFAULT_MATERIAL_PROFILE.collapseTransmission2x;
 DEFAULT_MATERIAL_PROFILE.backdropToneAnchorX;
 DEFAULT_MATERIAL_PROFILE.backdropToneResponseThin;
 DEFAULT_MATERIAL_PROFILE.backdropToneResponseThick;
@@ -854,6 +1187,11 @@ function withMaterialOverrides(base, patch) {
     sizeScatterRampStartFar2x: patch.sizeScatterRampStartFar2x ?? base.sizeScatterRampStartFar2x,
     sizeScatterRampReach1xPx: patch.sizeScatterRampReach1xPx ?? base.sizeScatterRampReach1xPx,
     sizeScatterRampReach2xPx: patch.sizeScatterRampReach2xPx ?? base.sizeScatterRampReach2xPx,
+    sizeScatterHeavyShareThick1x: patch.sizeScatterHeavyShareThick1x ?? base.sizeScatterHeavyShareThick1x,
+    sizeScatterHeavyShareThick2x: patch.sizeScatterHeavyShareThick2x ?? base.sizeScatterHeavyShareThick2x,
+    sizeToneLevelFar: patch.sizeToneLevelFar ?? base.sizeToneLevelFar,
+    sizeHeavyTapSigma: patch.sizeHeavyTapSigma ?? base.sizeHeavyTapSigma,
+    sizeHeavyTapSigma2x: patch.sizeHeavyTapSigma2x ?? base.sizeHeavyTapSigma2x,
     sizeOcclusionGain: patch.sizeOcclusionGain ?? base.sizeOcclusionGain,
     sizeShadowGainMax: patch.sizeShadowGainMax ?? base.sizeShadowGainMax,
     lensRefractionGain: patch.lensRefractionGain ?? base.lensRefractionGain,
@@ -878,12 +1216,18 @@ function withMaterialOverrides(base, patch) {
     backdropToneLow: patch.backdropToneLow ?? base.backdropToneLow,
     backdropToneHigh: patch.backdropToneHigh ?? base.backdropToneHigh,
     backdropToneSizeBias: patch.backdropToneSizeBias ?? base.backdropToneSizeBias,
+    collapseTransmission: patch.collapseTransmission ?? base.collapseTransmission,
+    collapseTransmission2x: patch.collapseTransmission2x ?? patch.collapseTransmission ?? base.collapseTransmission2x,
+    rimCollapsed: patch.rimCollapsed ?? base.rimCollapsed,
+    rimCollapsedTinted: patch.rimCollapsedTinted ?? base.rimCollapsedTinted,
+    rimTintChroma: patch.rimTintChroma ?? base.rimTintChroma,
     backdropToneAnchorX: patch.backdropToneAnchorX ?? base.backdropToneAnchorX,
     backdropToneResponseThin: patch.backdropToneResponseThin ?? base.backdropToneResponseThin,
     backdropToneResponseThick: patch.backdropToneResponseThick ?? base.backdropToneResponseThick,
     backdropToneResponseStrength: patch.backdropToneResponseStrength ?? base.backdropToneResponseStrength,
     outerShadow: { ...base.outerShadow, ...patch.outerShadow },
     lightDirection: patch.lightDirection ?? base.lightDirection,
+    rimLitAxis: patch.rimLitAxis ?? base.rimLitAxis,
     sweepBandRadians: patch.sweepBandRadians ?? base.sweepBandRadians,
     glowRadiusCss: patch.glowRadiusCss ?? base.glowRadiusCss,
     glowGain: patch.glowGain ?? base.glowGain,
@@ -901,10 +1245,31 @@ function opticsUnderPolicy(optics, policy, profile = DEFAULT_MATERIAL_PROFILE) {
     ...next,
     tintAlpha: occlusionAlphaUnderPolicy(next.tintAlpha, policy.occlusion, profile.increasedOcclusionLift)
   };
-  if (policy.border === "strong")
-    next = { ...next, ...profile.strongBorderRim };
+  if (policy.border === "strong") {
+    next = {
+      ...next,
+      rimWidth: profile.strongBorderRim.rimWidth,
+      rimWidth2x: profile.strongBorderRim.rimWidth,
+      rimAlpha: profile.strongBorderRim.rimAlpha,
+      rimLevelGain: 0,
+      // And the lit edge stands down with it (W24): a border a preference asked
+      // for is one brightness the whole way round, and a directional factor
+      // would take it to nothing on two of its four corners.
+      rimLitExponent: 0,
+      // The along-side field stands down for the same reason (W25): a border a
+      // preference asked for is one brightness the whole way round, and a
+      // position field would grade it corner to corner.
+      rimAlongSideSlope: 0
+    };
+  }
   return next;
 }
+function collapsedRimUnderPolicy(policy, tintStrength, profile = DEFAULT_MATERIAL_PROFILE) {
+  if (policy.border === "strong")
+    return profile.strongBorderRim.rimAlpha;
+  const strength = Math.min(1, Math.max(0, tintStrength));
+  return profile.rimCollapsed + (profile.rimCollapsedTinted - profile.rimCollapsed) * strength;
+}
 function adaptationStrength(policy, analysisExact, profile = DEFAULT_MATERIAL_PROFILE) {
   if (!analysisExact)
     return 0;
@@ -990,7 +1355,7 @@ var smoothstep = (edge0, edge1, x) => {
 function sizeThickness(spanPx, profile = DEFAULT_MATERIAL_PROFILE) {
   return smoothstep(profile.sizeSpanMin, profile.sizeSpanMax, spanPx);
 }
-function backdropToneResponse(encodedInput, thickness, profile = DEFAULT_MATERIAL_PROFILE) {
+function backdropToneResponse(encodedInput, thickness, profile = DEFAULT_MATERIAL_PROFILE, levelFar = 0) {
   const xs = profile.backdropToneAnchorX;
   const f = smoothstep(0, 1, thickness);
   const ys = [0, 1, 2].map((i) => (profile.backdropToneResponseThin[i] ?? 0) + ((profile.backdropToneResponseThick[i] ?? 0) - (profile.backdropToneResponseThin[i] ?? 0)) * f);
@@ -1007,7 +1372,7 @@ function backdropToneResponse(encodedInput, thickness, profile = DEFAULT_MATERIA
   const y1 = seg === 0 ? ys[1] : ys[2];
   const s0 = seg === 0 ? d0 : m1;
   const s1 = seg === 0 ? m1 : d1;
-  return y0 * (1 + 2 * t) * (1 - t) * (1 - t) + s0 * h * t * (1 - t) * (1 - t) + y1 * t * t * (3 - 2 * t) + s1 * h * t * t * (t - 1);
+  return y0 * (1 + 2 * t) * (1 - t) * (1 - t) + s0 * h * t * (1 - t) * (1 - t) + y1 * t * t * (3 - 2 * t) + s1 * h * t * t * (t - 1) + levelFar;
 }
 function backdropToneSolveWeight(encodedInput, profile = DEFAULT_MATERIAL_PROFILE) {
   const anchor = profile.backdropToneAnchorX[0];
@@ -1080,6 +1445,12 @@ function rampAtScale(at1x, at2x, devicePixelRatio) {
     return at2x;
   return at1x + (at2x - at1x) * t;
 }
+function rimWidthAtScale(optics, devicePixelRatio = 1) {
+  return rampAtScale(optics.rimWidth, optics.rimWidth2x, devicePixelRatio);
+}
+function collapseTransmissionAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  return rampAtScale(profile.collapseTransmission, profile.collapseTransmission2x, devicePixelRatio);
+}
 function scatterGainAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
   return rampAtScale(profile.sizeScatterGainMax, profile.sizeScatterGainMax2x, devicePixelRatio);
 }
@@ -1101,7 +1472,25 @@ function scatterSpanMaxAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRa
 }
 function scatterDeepThickness(spanPx, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
   const floor = scatterFloorAtScale(profile, devicePixelRatio);
-  return floor + (1 - floor) * smoothstep(profile.sizeSpanMin, scatterSpanMaxAtScale(profile, devicePixelRatio), spanPx);
+  const lift = scatterHeavyShareThickAtScale(profile, devicePixelRatio) * sizeThickness(spanPx, profile);
+  return clampUnit(floor + (1 - floor) * smoothstep(profile.sizeSpanMin, scatterSpanMaxAtScale(profile, devicePixelRatio), spanPx) + lift);
+}
+function scatterHeavyShareThickAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  return rampAtScale(profile.sizeScatterHeavyShareThick1x, profile.sizeScatterHeavyShareThick2x, devicePixelRatio);
+}
+function heavyTapSigmaAtScale(profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1) {
+  return rampAtScale(profile.sizeHeavyTapSigma, profile.sizeHeavyTapSigma2x, devicePixelRatio);
+}
+function sizeToneLevelFar(spanPx, profile = DEFAULT_MATERIAL_PROFILE, devicePixelRatio = 1, fold = 1) {
+  return profile.sizeToneLevelFar * smoothstep(profile.sizeSpanMax, scatterSpanMaxAtScale(profile, devicePixelRatio), spanPx) * fold;
+}
+function rimAlongSideField(offset, half) {
+  const x = offset[0] / Math.max(Math.abs(half[0]), 1e-6);
+  const y = offset[1] / Math.max(Math.abs(half[1]), 1e-6);
+  return Math.max(-1, Math.min(1, x * y));
+}
+function rimAlongSideFactor(field, spanPx, optics, profile = DEFAULT_MATERIAL_PROFILE) {
+  return Math.max(0, 1 + optics.rimAlongSideSlope * sizeThickness(spanPx, profile) * field);
 }
 function scatterSharpShare(uDevicePx, devicePixelRatio, profile = DEFAULT_MATERIAL_PROFILE, spanPx = 0) {
   const deepSharp = 1 - scatterDeepThickness(spanPx, profile, devicePixelRatio);
@@ -2105,6 +2494,9 @@ var poolKey = {
   backdropChainScratch: (sourceId, level) => `backdrop:${sourceId}:chain-scratch:${level}`,
   backdropBody: (sourceId) => `backdrop:${sourceId}:body`,
   backdropBodyScratch: (sourceId) => `backdrop:${sourceId}:body-scratch`,
+  /** The heavy blur and its scratch (W26) — the body's pair, one width deeper. */
+  backdropHeavy: (sourceId) => `backdrop:${sourceId}:heavy`,
+  backdropHeavyScratch: (sourceId) => `backdrop:${sourceId}:heavy-scratch`,
   backdropUpload: (sourceId) => `backdrop:${sourceId}:upload`,
   groupField: (groupId) => `group:${groupId}:field`,
   groupAux: (groupId) => `group:${groupId}:aux`,
@@ -3068,7 +3460,9 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   /// accessibility fold \u2014 the refraction ladder read at the preference's cap,
   /// which every facet's span-dependent rise is multiplied by (W11c)
   tone : vec4f,
-  /// rimWidthPx, rimAlpha, specularPower, specularGain
+  /// rimWidthPx, rimAlpha; (z) and (w) carried specularPower and specularGain
+  /// until W24 retired the one-sided specular from the rim (claims 5.108
+  /// section 1) and are written but unread
   rim : vec4f,
   /// light direction, unit (xy), shadowDepth (z), shadowAlpha (w)
   light : vec4f,
@@ -3117,7 +3511,11 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   /// three anchors for a surface of sizeThickness 0 (xyz); w is the law's
   /// per-profile authority \u2014 0 on dark profiles, whose response is unmeasured
   toneRowThin : vec4f,
-  /// the thick row (sizeThickness saturated), same layout
+  /// the thick row (sizeThickness saturated), xyz as the thin row's; w is the
+  /// collapse's transmission (W24 G1), in the padding slot this vec4's alignment
+  /// already required \u2014 it belongs to the tone block and the tone block's other
+  /// three vec4s are full. At 0 the collapse's target is the group's mean
+  /// backdrop colour and this pass is W7's to the bit.
   toneRowThick : vec4f,
   /// the size law's bands: the scatter facet's floor (x, resolved at the
   /// group's device ratio since W15 G1 \u2014 the deep value is per-scale, claims
@@ -3158,6 +3556,30 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   /// which is the only place the CSS-px-to-texel conversion is knowable, and
   /// already clamped to chainMaxLod (w)
   shadowLift : vec4f,
+  /// the rim's amplitude law (W23): the gain on the surface's own rendered
+  /// luminance (x), the rim the COLLAPSED appearance keeps \u2014 bare (y) and at the
+  /// author tint's full coverage (z) \u2014 which rises with the adaptation the
+  /// scheme's own rim falls with, and how much of an author tint's own colour
+  /// the rim's light is spent in (w)
+  rimLaw : vec4f,
+  /// the lit edge (W24): the axis the rim's directional factor is symmetric
+  /// about, unit, viewport coordinates with y down (xy), and the factor's
+  /// exponent (z) \u2014 0 leaves the factor at 1 for every normal and the rim
+  /// exactly as W23 left it. (w) is the along-side field's slope (W25), in the
+  /// slot W24 left free \u2014 0 leaves the factor at 1 at every position.
+  rimLit : vec4f,
+  /// the thick-span composite (W25; claims 5.113): the heavy share's thick-end
+  /// lift on 'sizeThickness', resolved at this group's device ratio (x), and the
+  /// level term's gain above the thickness knee (y). Both 0 on the landed
+  /// material, so both terms are one multiplication by zero. (z) and (w) free.
+  thickSpan : vec4f,
+  /// the heavy blur's enable (W26; 'MaterialProfile.sizeHeavyTapSigma', and the
+  /// measured cause in claims 5.116 section 2) \u2014 1 where this group's source
+  /// carries a heavy texture, 0 where it does not. The WIDTH is not here: the
+  /// pyramid blurred it into 'backdropHeavy' before any group was drawn, so all
+  /// this pass decides is which of two textures the deep sample comes from.
+  /// (y) (z) (w) free.
+  heavyTap : vec4f,
 };
 
 @group(0) @binding(0) var<uniform> ou : OpticsUniforms;
@@ -3171,6 +3593,11 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
 /// centre (xy) and its half-extents (zw), group-local CSS px \u2014 the lens's oval.
 @group(0) @binding(7) var aux2Texture : texture_2d<f32>;
 
+/// The heavy blur (W26) \u2014 the backdrop taken to the profile's heavy width by the
+/// pyramid's own separable passes, at the extent of the chain level it was built
+/// from. Bound at every draw; read only where 'heavyTap.x' says there is one.
+@group(0) @binding(8) var backdropHeavy : texture_2d<f32>;
+
 /// One encoded sRGB channel from a linear one \u2014 the space the backdrop tone
 /// response's anchors live in (W9). Mirrors material.ts's 'linearToSrgbChannel'.
 fn srgb_encode(c : f32) -> f32 {
@@ -3182,7 +3609,7 @@ fn srgb_encode(c : f32) -> f32 {
 /// (Fritsch\u2013Carlson) interpolation through the three anchors, clamped to their
 /// span; smoothstep between the thin and thick rows. Mirrors material.ts's
 /// 'backdropToneResponse' term for term \u2014 the constants are authored there.
-fn tone_response(x : f32, sizeK : f32) -> f32 {
+fn tone_response(x : f32, sizeK : f32, levelFar : f32) -> f32 {
   let f = sizeK * sizeK * (3.0 - 2.0 * sizeK);
   let ys = mix(ou.toneRowThin.xyz, ou.toneRowThick.xyz, vec3f(f));
   let xs = ou.toneAnchor.xyz;
@@ -3201,10 +3628,18 @@ fn tone_response(x : f32, sizeK : f32) -> f32 {
     h = h1; t = (xc - xs.y) / h1;
     y0 = ys.y; y1 = ys.z; s0 = m1; s1 = d1;
   }
+  // 'levelFar' is W25's level term above the thickness knee (claims 5.113; W25
+  // Decision Log 3 (b)) - an OFFSET on the settled level this curve returns, in
+  // its own encoded units, and not a continuation of the thin-to-thick blend
+  // above. The rows chose the shape: the residual against vitrea above span 96
+  // is backdrop-INDEPENDENT where the blend's direction is different at every
+  // backdrop level (G2 'fit-level.txt'). Exactly 0 at and below sizeSpanMax by
+  // the shape of its span curve, and 0 at every span on the landed material.
   return y0 * (1.0 + 2.0 * t) * (1.0 - t) * (1.0 - t)
        + s0 * h * t * (1.0 - t) * (1.0 - t)
        + y1 * t * t * (3.0 - 2.0 * t)
-       + s1 * h * t * t * (t - 1.0);
+       + s1 * h * t * t * (t - 1.0)
+       + levelFar;
 }
 
 /// Rim proximity: 1 exactly on the contour, falling to 0 by 'width' on either
@@ -3536,11 +3971,27 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
    */
   let scatterFloor = clamp(ou.scatter.x, 0.0, 1.0);
   let deepT = clamp((span - ou.scatter.z) / max(ou.lensOval.w - ou.scatter.z, 1e-6), 0.0, 1.0);
-  let kDeep = scatterFloor + (1.0 - scatterFloor) * deepT * deepT * (3.0 - 2.0 * deepT);
+  // W25's share law (claims 5.113; W25 Decision Log 3 (a)): the thick end's lift
+  // on the material's own thin/thick curve, ADDED to the W11c span curve rather
+  // than replacing it, so the thin end keeps the constants it was fitted with and
+  // 'sizeThick' being exactly 0 at sizeSpanMin makes the thin controls
+  // bit-identical whatever the lift says.
+  let kDeep = clamp(
+    scatterFloor + (1.0 - scatterFloor) * deepT * deepT * (3.0 - 2.0 * deepT)
+      + ou.thickSpan.x * sizeThick,
+    0.0,
+    1.0,
+  );
   let sDeep = 1.0 - kDeep;
   let rampT = max(1.0 - max(-d, 0.0) / max(ou.lensOval.z, 1e-6), 0.0);
   let farT = clamp((span - ou.scatter.w) / max(ou.lensOval.w - ou.scatter.w, 1e-6), 0.0, 1.0);
   let farS = farT * farT * (3.0 - 2.0 * farT);
+  // W25's level term rides the very same curve (claims 5.113): one span
+  // statistic, now read three times \u2014 the ramp's far decline, the 2x heavy
+  // gain's rise and the body's level above the knee. Folded like the response it
+  // extends, because a preference that has stopped the material transmitting has
+  // no thin-to-thick step left to continue.
+  let toneLevelFar = ou.thickSpan.y * farS * fold;
   let rampStart = ou.scatter.y + (ou.shadowSize.z - ou.scatter.y) * sizeThick
     + (ou.shadowThick.w - ou.shadowSize.z) * farS;
   let sharpShare = clamp(sDeep + max(rampStart - sDeep, 0.0) * rampT, 0.0, 1.0);
@@ -3608,6 +4059,14 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // along 'farS' \u2014 the very smoothstep the ramp's far anchor already declines
   // along, computed above with the share. One curve, two quantities.
   let gainEff = ou.size.x + (ou.shadowSize.w - ou.size.x) * farS;
+  /*
+   * Everything above this point grades the GAIN, and claims \xA75.116 \xA72 measured
+   * that the gain stops being a width: 'ou.lens.w' is the chain's own last level,
+   * 4 on the bed's 320 \xD7 200 backdrop, and 'ou.size.w + log2(8)' is 4.06, so the
+   * clamp has been absorbing the gain since the material was fitted. This is the
+   * path a material that names no heavy width still takes, and the heavy blur
+   * below is what replaces it where one is named.
+   */
   let scatterLod = clamp(ou.size.w + log2(max(gainEff, 1e-4)), 0.0, ou.lens.w);
 
   var backdrop = vec3f(0.0);
@@ -3615,7 +4074,32 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
     // Both components at the refracted position (W11c G2): the band and the
     // interior are one body, and the displacement alone is the lens.
     let bodySample = textureSampleLevel(backdropBody, backdropSampler, refractedUv, 0.0);
-    let scatterSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, scatterLod);
+    var scatterSample = textureSampleLevel(backdropChain, backdropSampler, refractedUv, scatterLod);
+    /*
+     * The heavy blur (W26). Where the profile named a heavy width the deep sample
+     * is not a chain level at all: the pyramid took the chain level whose own
+     * blur is nearest below the target up to the target exactly, with the two
+     * separable passes it already runs for the body, and this pass reads the
+     * result at the same refracted uv the chain tap used.
+     *
+     * That is the whole mechanism, and it is here rather than in a grid of taps
+     * for two measured reasons. The width the chain can reach is bounded by
+     * 'chainMaxLod' \u2014 the pyramid stops when a level's shorter side would fall
+     * under eight texels \u2014 so at dpr 1 on a 320 x 200 backdrop the deep sample
+     * saturates at 13.4 device px against the reference's 19.5, and a residual
+     * Gaussian is the only thing that carries the octave the chain does not have
+     * (claims \xA75.119). And a 9 x 9 grid at the tap costs +1.1 ms on the optics
+     * pass against 0.070 ms for the separable pair (W26 Decision Log 2 (b)).
+     *
+     * The price is that the width is one per SOURCE, not one per pixel: the
+     * texture is built before any group is drawn, so the span grading the gain
+     * carried above no longer reaches the deep sample where this is on. The
+     * reference's heavy width does not grade with the span at 1x (claims
+     * \xA75.113 \xA74), which is what says the material can afford it.
+     */
+    if (ou.heavyTap.x > 0.5) {
+      scatterSample = textureSampleLevel(backdropHeavy, backdropSampler, refractedUv, 0.0);
+    }
     // Premultiplied linear in, straight colour out: the material composites over
     // whatever is behind it, so a partially transparent backdrop must not darken
     // the glass.
@@ -3711,7 +4195,7 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
     let authority =
       smoothstep(anchor * 0.5, anchor, encodedInput) * clamp(ou.toneRowThin.w, 0.0, 1.0);
     if (authority > 0.0) {
-      let response = tone_response(encodedInput, sizeK);
+      let response = tone_response(encodedInput, sizeK, toneLevelFar);
       // The collapse's mean pull is toward L(toneColour.rgb) \u2014 the LINEAR
       // mean, which toneAnchor.w carries \u2014 not toward the encoded level.
       let preCollapse = (response - toneAdapt * ou.toneAnchor.w) / (1.0 - toneAdapt);
@@ -3742,11 +4226,44 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
     }
   }
 
+  /*
+   * The collapse's TARGET (W24 G1) \u2014 what the material converges on where it has
+   * adapted, and the one place the transmission was lost.
+   *
+   * The pair below reduces exactly to 'colour = (1 \u2212 k)\xB7M + k\xB7target', with 'M'
+   * the unadapted composite '(1 \u2212 \u03B1)\xB7backdrop + \u03B1\xB7neutral'. At 'target' =
+   * 'toneColour.rgb', the group's MEAN backdrop colour, a fully collapsed
+   * surface is one flat number and nothing under it comes through \u2014 which is
+   * exactly what the reference's collapsed capsule over the impulse grid does
+   * NOT do (claims \xA75.107 \xA72: it passes the centre dot at four times its own
+   * body). So the target lerps toward the per-pixel blurred backdrop the
+   * refraction path above already sampled, by the profile's own constant.
+   *
+   * Only the target moves. The tone axis's argument is still the group's mean
+   * luminance and the response solve still composites against 'toneAnchor.w',
+   * so 'k' and the law's level are the numbers W7 and W9 fitted: the collapse
+   * still collapses the level, and stops flattening the structure.
+   *
+   * The alpha solve above needs no gate of its own, and this is arithmetic
+   * rather than a choice: on a fully collapsed surface it never runs (its own
+   * 'toneAdapt < 0.995' stands it down where the collapse owns the pixel), and
+   * below that it is the (1 \u2212 k) half of the same lerp, which transmits already.
+   *
+   * Gated on 'flags.x': with no pyramid to sample 'backdrop' is the zero vector
+   * and this pass writes a layer for the browser to composite, so a target
+   * lerped toward it would be a black surface rather than a transmitting one.
+   * There the CSS tier's own 'backdrop-filter' is what carries the transmission.
+   */
+  var toneTarget = ou.toneColour.rgb;
+  if (ou.flags.x > 0.5) {
+    toneTarget = mix(toneTarget, backdrop, clamp(ou.toneRowThick.w, 0.0, 1.0));
+  }
+
   let adaptedAlpha = solvedAlpha + toneAdapt * (1.0 - solvedAlpha);
   var adapted = solvedNeutral;
   if (toneAdapt > 0.0 && adaptedAlpha > 0.0) {
     adapted =
-      (solvedNeutral * ((1.0 - toneAdapt) * solvedAlpha) + ou.toneColour.rgb * toneAdapt) /
+      (solvedNeutral * ((1.0 - toneAdapt) * solvedAlpha) + toneTarget * toneAdapt) /
       adaptedAlpha;
   }
 
@@ -3804,6 +4321,45 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   // seed); and '1 \u2212 toneAdapt' folds the shade out where the collapse has made
   // the material a dark body, where the reference renders the pure seed too.
   // At zero grip the layer is the bare seed \u2014 the author's colour, flat.
+  /*
+   * The material's own composite, kept beside the tinted one (W23; claims \xA75.100
+   * \xA75). The rim is the MATERIAL's mark and the author's colour is painted over
+   * it, so the amplitude law below reads the level the material reached and not
+   * the level the paint left \u2014 which is what the reference does: its tinted rows
+   * read +0.13\u2026+0.17 of contour rim in BOTH colour schemes, where the two
+   * materials' own laws on the PAINTED level differ by a factor of five and land
+   * the dark bed's tinted rows 0.216 over.
+   *
+   * For an untinted pixel these carry exactly 'colour' and 'bodyAlpha', so the
+   * rim below is bit-identical to the law without them.
+   */
+  var materialColour = colour;
+  var materialAlpha = bodyAlpha;
+  /*
+   * The colour the rim's light is spent in (W23 G3; claims \xA75.102). White on a
+   * bare surface, and on a PAINTED one the author's own CHROMATICITY: the
+   * reference's rim on a tinted capsule is the paint lifted rather than white
+   * added over it \u2014 orange (255, 148, 0) rises to (254, 188, 0) with its blue
+   * channel still at 0, where vitrea drew (255, 192, 130).
+   *
+   * The layer is normalised by its own LUMINANCE and not by its brightest
+   * channel, which is what the rows chose: on the collapsed orange capsule at 2x
+   * the reference lifts the green channel by 0.213 of linear light where a white
+   * rim of the same amount lifts it by 0.304, and 0.213 / 0.304 = 0.70 is exactly
+   * the green coefficient of that orange divided by its luminance. Normalising by
+   * the brightest channel instead reproduces the hue and loses the AMOUNT \u2014 it
+   * divides the rim's luminance by the paint's, which on the same cell took the
+   * contour rim from 0.115 to 0.030 against a reference of 0.118. Chromaticity is
+   * unbounded as a paint darkens, so the divisor has a floor of 0.05: below that
+   * the paint has no readable hue and the normalisation would be a colour cast of
+   * arbitrary size rather than a rim.
+   *
+   * 'rimTintChroma' (rimLaw.w) is how much of that is taken, and it is
+   * multiplied by the pixel's own tint strength, so an UNTINTED pixel keeps a
+   * white rim at every value of the constant \u2014 which is what makes the mechanism
+   * reach painted pixels only (W23 S10).
+   */
+  var rimTintColour = vec3f(1.0);
   if (aux.w > 0.0) {
     // The untinted material's luminance at this pixel. Over a backdrop that is
     // the composite; as a layer it is the layer over the tone the host measured
@@ -3814,6 +4370,8 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
     let shade = mix(1.0, clamp(mix(ou.tone.x, ou.tone.y, clamp(u, 0.0, 1.0)), 0.0, 1.0), grip);
     let layer = ou.seed.rgb * shade;
     let s = clamp(aux.w, 0.0, 1.0);
+    let layerLuma = max(dot(layer, vec3f(0.2126, 0.7152, 0.0722)), 0.05);
+    rimTintColour = mix(vec3f(1.0), layer / layerLuma, clamp(ou.rimLaw.w, 0.0, 1.0) * s);
     let encodedMaterial = linear_to_srgb(clamp(colour, vec3f(0.0), vec3f(1.0)));
     let encodedLayer = linear_to_srgb(layer);
     if (ou.flags.x > 0.5) {
@@ -3858,15 +4416,118 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
   let shadowedAlpha = 1.0 - shadowKeep * (1.0 - bodyAlpha);
   colour = colour * (shadowKeep * bodyAlpha / max(shadowedAlpha, 1e-6));
   bodyAlpha = shadowedAlpha;
+  // The same occlusion on the material's own composite, so that the rim's law
+  // reads a level the inner shadow has reached exactly as it always did.
+  let materialShadowedAlpha = 1.0 - shadowKeep * (1.0 - materialAlpha);
+  materialColour = materialColour * (shadowKeep * materialAlpha / max(materialShadowedAlpha, 1e-6));
+  materialAlpha = materialShadowedAlpha;
 
-  // Rim and specular from the gradient. The rim is unlit ambient edge brightness;
-  // the specular term is the same edge lit from 'light.xy'.
+  /*
+   * The rim from the gradient. Its amplitude law is below and the direction it
+   * is LIT from is the factor after it.
+   *
+   * The one-sided specular that used to be added here \u2014 'pow(clamp(dot(normal,
+   * light.xy), 0, 1), rim.z) * rim.w' \u2014 is retired (W24; claims \xA75.108 \xA71). Read
+   * around the whole contour the reference's rim is symmetric about the diagonal
+   * rather than one-sided, and a term that can only reach one end of it fits at
+   * 0.288 of normalised RMS where the symmetric factor fits at 0.148. 'rim.z'
+   * and 'rim.w' are written by the pass and no longer read.
+   */
   let rw = rim_weight(d, ou.rim.x);
-  let facing = dot(normal, ou.light.xy);
-  let spec = pow(clamp(facing, 0.0, 1.0), max(ou.rim.z, 1e-3)) * ou.rim.w;
-  let rim = rw * (ou.rim.y + spec) * present;
+  /*
+   * The rim's amplitude law, and the rim that survives the collapse (W23;
+   * claims \xA75.100 \xA7\xA73-4).
+   *
+   * - The amplitude is affine in the MATERIAL's own rendered luminance, taken
+   *   exactly as the tint shade takes it above \u2014 the composite where this layer
+   *   covers the pixel, the group's measured backdrop tone where it does not,
+   *   and in both cases before the author's colour is painted over it \u2014
+   *   so that a rim fitted as 'a fraction of the body's headroom' (a negative
+   *   gain, the screen form the CSS tier's inset shadow already is) and a rim
+   *   fitted as 'a line that rides its own body up' (a positive one, which is
+   *   what the dark reference's rows read as) are the same expression with the
+   *   sign the rows chose. The environment term the wave chartered beside it is
+   *   not here: it is worse than this law on the reference in both schemes and
+   *   no row of either bed separates it, so it is not carried (C9a \xA76.2).
+   * - 'rimCollapsed' rises with 'toneAdapt' exactly as the rest of the
+   *   appearance falls with it. At toneAdapt 1 the surface draws its backdrop
+   *   with this rim and nothing else, which is what the reference's collapsed
+   *   capsule does; at 0 it contributes nothing at all.
+   *   The collapsed rim it rises to is the AUTHOR TINT's coverage lerped between
+   *   two absolute constants: the reference's collapsed capsule keeps +0.020 of
+   *   contour rim bare and +0.115 painted, and both are absolutes rather than
+   *   fractions of the appearance's own rim, because the reference draws one
+   *   collapsed appearance out of two materials whose amplitude laws differ by
+   *   1.8\xD7 (claims \xA75.100 \xA75). 'aux.w' is the same per-pixel tint strength the
+   *   author tint layer composites with sixty lines above.
+   */
+  let rimLuma = materialAlpha * dot(materialColour, vec3f(0.2126, 0.7152, 0.0722))
+    + (1.0 - materialAlpha) * ou.toneColour.w;
+  let rimAmplitude = ou.rim.y + ou.rimLaw.x * rimLuma;
+  let rimCollapsed = mix(ou.rimLaw.y, ou.rimLaw.z, clamp(aux.w, 0.0, 1.0));
+  /*
+   * The lit edge (W24; claims \xA75.107) \u2014 the directional factor the whole rim is
+   * multiplied by, symmetric about 'rimLit.xy'.
+   *
+   * Apple's rim is not one number around the contour. Read at 720 or more points
+   * of the declared boundary and binned by the NORMAL's angle, the reference's
+   * north-west and south-east bins are five to twenty-five times its north-east
+   * and south-west ones on every untinted solid cell of both beds, while every
+   * per-side reader in three waves read it flat \u2014 a light on the diagonal
+   * projects equally on all four straight sides. This is the shape of that.
+   *
+   * '1.4142135' is the amplitude's re-expression and not a scale: it normalises
+   * the dot product by 'cos 45 deg', so at the default axis the factor is exactly
+   * 1 wherever the normal is horizontal or vertical, at EVERY exponent. W23
+   * fitted 'rimAlpha' and 'rimLevelGain' on those straight spans, so they keep
+   * their meaning untouched and only the corners and the arcs move \u2014 which is
+   * also why the CSS tier, whose one inset layer cannot vary around a contour,
+   * needs no counterpart and no re-fit.
+   *
+   * The factor multiplies the COLLAPSED rim as well as the appearance's own. That
+   * is a measurement and not a symmetry: the reference's collapsed cells \u2014 the
+   * 'dark-solid' capsule at both scales and the probe grids' 'dark-solid'
+   * rrect-sm and rrect-lg \u2014 fit the same axis (136.0 deg) and the same exponent
+   * (1.15 against 1.00) as the uncollapsed rows, so one factor outside the
+   * bracket is what the rows say and two constants would be one more than they
+   * separate.
+   *
+   * The floor is 1e-6 and not 0 so that 'pow' is defined where the normal is
+   * exactly perpendicular to the axis; at exponent 0 it returns 1 there as it
+   * does everywhere else, which is what makes this term inert at the defaults.
+   */
+  let lit = pow(max(abs(dot(normal, ou.rimLit.xy)) * 1.4142135, 1e-6), ou.rimLit.z);
+  /*
+   * The along-side field (W25; claims 5.113, W25 Decision Log 3 (c)) \u2014 the
+   * POSITION half of the light whose direction half W24 landed.
+   *
+   * W24's factor is a function of the normal, so it is one number on a whole
+   * straight side. Read by position along the side instead, on flat solid
+   * backdrops where a lens has no gradient to refract, the reference's rim is
+   * graded on every thick cell of both probe grids and flat at spans 32 and 44 \u2014
+   * a term on the thickness curve. Its four slopes are equal and OPPOSITE across
+   * opposite sides, which a field linear in position cannot be and the product of
+   * the two normalised coordinates is exactly: +1 at the top-left and
+   * bottom-right corners, -1 at the other two, the same diagonal 'rimLit.xy' is
+   * symmetric about.
+   *
+   * 'aux2.xy' is the pixel's offset from its own surface's centre in CSS px and
+   * 'aux2.zw' its half-extents, so the field is the surface's own coordinate and
+   * a container of differently sized members grades each of them by its own box
+   * out of one pass. The field's mean over any straight side is exactly zero, so
+   * W23's and W24's straight-span amplitudes keep the meaning they were fitted
+   * with and the CSS tier's single inset needs no counterpart.
+   *
+   * 'sizeThick' is the unfolded thickness curve, exactly 0 at sizeSpanMin, so
+   * rrect-sm and every thinner control are untouched by construction; at slope 0
+   * the factor is exactly 1 everywhere.
+   */
+  let alongSide = clamp((rel.x / halfExt.x) * (rel.y / halfExt.y), -1.0, 1.0);
+  let alongFactor = max(1.0 + ou.rimLit.w * sizeThick * alongSide, 0.0);
+  let rim = rw * lit * alongFactor * (rimAmplitude * present + rimCollapsed * toneAdapt);
+  let rimLight = rim * rimTintColour;
   if (ou.flags.x > 0.5) {
-    colour = colour + vec3f(rim);
+    colour = colour + rimLight;
   } else {
     // Added light has no premultiplied form of its own \u2014 a canvas colour may
     // not exceed its alpha \u2014 so the layer carries the light in its opacity:
@@ -3877,8 +4538,11 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
     // shows through \u2014 where the mix form ("white over the layer at the rim's
     // weight") is short by the rim times the whole composite, which halved
     // the rim on a tinted panel.
+    // The alpha the rim carries is its LIGHT and not its colour: a coloured rim
+    // spends the same light through a narrower set of channels, so the layer's
+    // opacity is still 'rim' and only the colour it carries is tinted.
     let carried = clamp(bodyAlpha + rim, 0.0, 1.0);
-    colour = min((colour * bodyAlpha + vec3f(rim)) / max(carried, 1e-6), vec3f(1.0));
+    colour = min((colour * bodyAlpha + rimLight) / max(carried, 1e-6), vec3f(1.0));
     bodyAlpha = carried;
   }
 
@@ -4160,7 +4824,7 @@ function createPassRunner(context) {
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 96);
+      const slot = uniformSlot(`optics:${args.groupId}`, 112);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -4233,7 +4897,7 @@ function createPassRunner(context) {
       d[68] = args.backdropToneResponseThick[0];
       d[69] = args.backdropToneResponseThick[1];
       d[70] = args.backdropToneResponseThick[2];
-      d[71] = 0;
+      d[71] = args.collapseTransmission;
       d[72] = args.sizeScatterFloor;
       d[73] = args.sizeScatterRampStartThin;
       d[74] = args.sizeSpanMin;
@@ -4258,9 +4922,26 @@ function createPassRunner(context) {
       d[93] = args.outerShadowLift[1];
       d[94] = args.outerShadowLift[2];
       d[95] = args.outerShadowLift[3];
+      d[96] = args.rimLevelGain;
+      d[97] = args.rimCollapsed;
+      d[98] = args.rimCollapsedTinted;
+      d[99] = args.rimTintChroma;
+      d[100] = args.rimLitAxis[0];
+      d[101] = args.rimLitAxis[1];
+      d[102] = args.rimLitExponent;
+      d[103] = args.rimAlongSideSlope;
+      d[104] = args.sizeScatterHeavyShareThick;
+      d[105] = args.sizeToneLevelFar;
+      d[106] = 0;
+      d[107] = 0;
+      d[108] = args.heavyTapEnabled ? 1 : 0;
+      d[109] = 0;
+      d[110] = 0;
+      d[111] = 0;
       slot.write();
       const chain = args.backdrop?.chain ?? placeholderView;
       const body = args.backdrop?.body ?? placeholderView;
+      const heavy = args.backdrop?.heavy ?? placeholderView;
       const pipeline = opticsPipeline(args.targetFormat);
       const pass = encoder.beginRenderPass({
         label: `vitrea:pass:optics:${args.groupId}`,
@@ -4281,7 +4962,8 @@ function createPassRunner(context) {
           // Linear, no mips: the field targets have one level, and this is only
           // read at all when the governor shrank them below the group's rect.
           { binding: 6, resource: context.flatSampler },
-          { binding: 7, resource: args.fields.aux2.createView() }
+          { binding: 7, resource: args.fields.aux2.createView() },
+          { binding: 8, resource: heavy }
         ]
       }));
       pass.draw(3);
@@ -4455,6 +5137,29 @@ function bodyBlurPlan(sigmaPx, plan) {
   const residualLevel0 = Math.sqrt(Math.max(sigmaPx * sigmaPx - covered * covered, 0));
   return { level, residualSigmaTexels: residualLevel0 / Math.pow(2, level) };
 }
+var CHAIN_LEVEL_SIGMA = [0, 1.542, 3.281, 6.679, 13.418, 26.867];
+function chainLevelSigma(level) {
+  if (level <= 0)
+    return 0;
+  if (level < CHAIN_LEVEL_SIGMA.length)
+    return CHAIN_LEVEL_SIGMA[level];
+  const last = CHAIN_LEVEL_SIGMA[CHAIN_LEVEL_SIGMA.length - 1];
+  return last * Math.pow(2, level - (CHAIN_LEVEL_SIGMA.length - 1));
+}
+function heavyTapPlan(sigmaTexels, plan) {
+  let level = 0;
+  if (sigmaTexels > 0) {
+    for (let i = 1; i < plan.levelCount; i += 1) {
+      if (chainLevelSigma(i) > sigmaTexels)
+        break;
+      level = i;
+    }
+  }
+  const scale = Math.pow(2, level);
+  const covered = chainLevelSigma(level);
+  const residual = Math.sqrt(Math.max(sigmaTexels * sigmaTexels - covered * covered, 0)) / scale;
+  return { level, residualSigmaTexels: residual };
+}
 
 // ../renderer-webgpu/dist/rebuild-ledger.js
 function createRebuildLedger() {
@@ -4511,7 +5216,8 @@ function createRebuildLedger() {
 var chainUsage = () => GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING;
 var densityOf = (source, request) => texelsPerCssPx(source.width, source.height, request.placement, request.viewportCss[0], request.viewportCss[1]);
 var same = (next, existing) => Math.abs(next - existing) <= 1e-6 * Math.max(1, Math.abs(existing));
-var sameBody = (existing, request) => same(densityOf({ width: existing.sourceWidth, height: existing.sourceHeight }, request), existing.texelsPerCss) && same(request.bodySigmaCss, existing.bodySigmaCss);
+var sameHeavySigma = (next, existing) => next > 0 === existing > 0 && same(next, existing);
+var sameBody = (existing, request) => same(densityOf({ width: existing.sourceWidth, height: existing.sourceHeight }, request), existing.texelsPerCss) && same(request.bodySigmaCss, existing.bodySigmaCss) && sameHeavySigma(request.heavySigmaCss, existing.heavySigmaCss);
 function createPyramidStore(context) {
   const { device, pool, cache } = context;
   const resources = /* @__PURE__ */ new Map();
@@ -4584,13 +5290,17 @@ function createPyramidStore(context) {
       return void 0;
     if (pool.peek(poolKey.backdropBody(sourceId)) !== target.body)
       return void 0;
+    if (target.heavy !== void 0 && pool.peek(poolKey.backdropHeavy(sourceId)) !== target.heavy) {
+      return void 0;
+    }
     return target;
   };
   const mipView = (texture, level) => texture.createView({ baseMipLevel: level, mipLevelCount: 1, dimension: "2d" });
-  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch, bodySigmaTexels, density, bodySigmaCss) {
+  function allocate(sourceId, plan, bodyLevel, sizeEpoch, builtEpoch, bodySigmaTexels, density, bodySigmaCss, heavyLevel, heavySigmaCss) {
     const existing = resources.get(sourceId);
-    const bodyWidth = (plan.levels[bodyLevel] ?? plan.levels[0]).width;
-    const bodyHeight = (plan.levels[bodyLevel] ?? plan.levels[0]).height;
+    const levelSize = (level) => plan.levels[level] ?? plan.levels[0];
+    const bodyWidth = levelSize(bodyLevel).width;
+    const bodyHeight = levelSize(bodyLevel).height;
     const chain = pool.acquire(poolKey.backdropChain(sourceId), {
       width: plan.width,
       height: plan.height,
@@ -4606,6 +5316,19 @@ function createPyramidStore(context) {
       usage: chainUsage(),
       label: `vitrea:pyramid:${sourceId}:body`
     });
+    let heavy;
+    if (heavyLevel === void 0) {
+      pool.release(poolKey.backdropHeavy(sourceId));
+      pool.release(poolKey.backdropHeavyScratch(sourceId));
+    } else {
+      heavy = pool.acquire(poolKey.backdropHeavy(sourceId), {
+        width: levelSize(heavyLevel).width,
+        height: levelSize(heavyLevel).height,
+        format: WORKING_TEXTURE_FORMAT,
+        usage: chainUsage(),
+        label: `vitrea:pyramid:${sourceId}:heavy`
+      });
+    }
     let stats = existing?.stats;
     if (stats === void 0) {
       stats = device.createBuffer({
@@ -4614,7 +5337,7 @@ function createPyramidStore(context) {
         usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
       });
     }
-    if (existing === void 0 || existing.chain !== chain || existing.body !== body) {
+    if (existing === void 0 || existing.chain !== chain || existing.body !== body || existing.heavy !== heavy) {
       reallocations += 1;
     }
     const next = {
@@ -4622,6 +5345,7 @@ function createPyramidStore(context) {
       plan,
       chain,
       body,
+      heavy,
       stats,
       sizeEpoch,
       builtEpoch,
@@ -4629,7 +5353,8 @@ function createPyramidStore(context) {
       texelsPerCss: density.texelsPerCss,
       sourceWidth: density.sourceWidth,
       sourceHeight: density.sourceHeight,
-      bodySigmaCss
+      bodySigmaCss,
+      heavySigmaCss
     };
     resources.set(sourceId, next);
     return next;
@@ -4710,22 +5435,23 @@ function createPyramidStore(context) {
       pass.end();
     }
   }
-  function runBodyBlur(encoder, sourceId, plan, chain, body, level, residualSigmaTexels) {
+  function runSeparableBlur(encoder, sourceId, kind, plan, chain, target, level, residualSigmaTexels) {
     const pipeline = chainPipeline("fs_blur");
     const size = plan.levels[level] ?? plan.levels[0];
-    const scratch = pool.acquire(poolKey.backdropBodyScratch(sourceId), {
+    const scratchKey = kind === "body" ? poolKey.backdropBodyScratch(sourceId) : poolKey.backdropHeavyScratch(sourceId);
+    const scratch = pool.acquire(scratchKey, {
       width: size.width,
       height: size.height,
       format: WORKING_TEXTURE_FORMAT,
       usage: chainUsage(),
-      label: `vitrea:pyramid:${sourceId}:body-scratch`
+      label: `vitrea:pyramid:${sourceId}:${kind}-scratch`
     });
     const stages = [
       { target: scratch, source: mipView(chain, level), dir: [1, 0], tag: "h" },
-      { target: body, source: scratch.createView(), dir: [0, 1], tag: "v" }
+      { target, source: scratch.createView(), dir: [0, 1], tag: "v" }
     ];
     for (const stage of stages) {
-      const slot = uniformSlot(`body:${sourceId}:${stage.tag}`, 8);
+      const slot = uniformSlot(`${kind}:${sourceId}:${stage.tag}`, 8);
       slot.data[0] = 1 / size.width;
       slot.data[1] = 1 / size.height;
       slot.data[2] = 0;
@@ -4736,7 +5462,7 @@ function createPyramidStore(context) {
       slot.data[7] = 0;
       slot.write();
       const pass = encoder.beginRenderPass({
-        label: `vitrea:pass:body-blur-${stage.tag}:${sourceId}`,
+        label: `vitrea:pass:${kind}-blur-${stage.tag}:${sourceId}`,
         ...timedRender(PASS_LABEL.bodyBlur),
         colorAttachments: [
           { view: stage.target.createView(), loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }
@@ -4839,10 +5565,14 @@ function createPyramidStore(context) {
       const planScale = frame.width > 0 ? plan.width / frame.width : 1;
       const bodySigmaTexels = request.bodySigmaCss * texelsPerCss * planScale;
       const bodyPlan = bodyBlurPlan(bodySigmaTexels, plan);
-      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels, { texelsPerCss, sourceWidth: frame.width, sourceHeight: frame.height }, request.bodySigmaCss);
+      const heavyPlan = request.heavySigmaCss > 0 ? heavyTapPlan(request.heavySigmaCss * texelsPerCss * planScale, plan) : void 0;
+      const target = allocate(request.sourceId, plan, bodyPlan.level, frame.sizeEpoch, request.epoch, bodySigmaTexels, { texelsPerCss, sourceWidth: frame.width, sourceHeight: frame.height }, request.bodySigmaCss, heavyPlan?.level, request.heavySigmaCss);
       runImport(encoder, request.sourceId, frame, target.chain);
       runChain(encoder, request.sourceId, plan, target.chain);
-      runBodyBlur(encoder, request.sourceId, plan, target.chain, target.body, bodyPlan.level, bodyPlan.residualSigmaTexels);
+      runSeparableBlur(encoder, request.sourceId, "body", plan, target.chain, target.body, bodyPlan.level, bodyPlan.residualSigmaTexels);
+      if (heavyPlan !== void 0 && target.heavy !== void 0) {
+        runSeparableBlur(encoder, request.sourceId, "heavy", plan, target.chain, target.heavy, heavyPlan.level, heavyPlan.residualSigmaTexels);
+      }
       runAnalysis(encoder, request.sourceId, plan, target.chain, target.stats);
       provider.markImported();
       return { status: "built", resources: target };
@@ -4920,6 +5650,8 @@ function createPyramidStore(context) {
       pool.release(poolKey.backdropChain(sourceId));
       pool.release(poolKey.backdropBody(sourceId));
       pool.release(poolKey.backdropBodyScratch(sourceId));
+      pool.release(poolKey.backdropHeavy(sourceId));
+      pool.release(poolKey.backdropHeavyScratch(sourceId));
       resources.get(sourceId)?.stats.destroy();
       resources.delete(sourceId);
       readbacks.get(sourceId)?.staging.destroy();
@@ -5072,7 +5804,8 @@ function createWebGPURenderer(options = {}) {
       const sameDensity = Math.abs(next - existing.texelsPerCss) <= 1e-6 * Math.max(1, existing.texelsPerCss);
       const sigmaCss = bodySigmaCssFor(sourceId);
       const sameSigma = Math.abs(sigmaCss - existing.bodySigmaCss) <= 1e-6 * Math.max(1, existing.bodySigmaCss);
-      if (sameDensity && sameSigma)
+      const sameHeavy = sameHeavySigma(heavySigmaCssFor(sourceId), existing.heavySigmaCss);
+      if (sameDensity && sameSigma && sameHeavy)
         continue;
       requests.push({
         sourceId,
@@ -5093,6 +5826,11 @@ function createWebGPURenderer(options = {}) {
     const optics = opticsUnderPolicy(material.optics[sourceVariant(sourceId)], accessibility, material);
     return optics.blurSigma / Math.max(viewport.devicePixelRatio, 1e-3);
   };
+  const heavySigmaCssFor = (sourceId) => {
+    if (bodySigmaCssFor(sourceId) <= 0)
+      return 0;
+    return heavyTapSigmaAtScale(material, viewport.devicePixelRatio) / Math.max(viewport.devicePixelRatio, 1e-3);
+  };
   const groupTintSeed = (input) => input.surfaces.find((surface) => surface.fieldReferenceOnly !== true && (surface.tint?.strength ?? 0) > 0)?.tint?.color;
   const stateOf = (input, resolution) => {
     const resolved = resolution?.groups.find((group) => group.groupId === input.groupId);
@@ -5159,6 +5897,9 @@ function createWebGPURenderer(options = {}) {
         // scale. At dpr 1 this is `optics.blurSigma` unchanged, which is what
         // leaves the 1x law exactly as landed.
         bodySigmaCss: bodySigmaCssFor(request.sourceId),
+        // The heavy blur's own σ, through the same conversion (W26). At 0 the
+        // pyramid allocates nothing and encodes nothing.
+        heavySigmaCss: heavySigmaCssFor(request.sourceId),
         viewportCss: [viewport.widthCss, viewport.heightCss],
         ...isUsablePlacement(placement) ? { placement } : {}
       }, provider, encoder);
@@ -5302,11 +6043,54 @@ function createWebGPURenderer(options = {}) {
         tintSeed: (policy.glass === "none" ? void 0 : groupTintSeed(input)) ?? optics.tint,
         tintToneAdaptation: tintToneAdaptation(policy, material),
         tintShade: [material.tintShadeDark, material.tintShadeLight, material.tintShadeStrength],
-        rimWidth: optics.rimWidth,
+        // The band's half-width is a per-scale reading since W23: the reference's
+        // rim narrows between the scales where vitrea's widened (claims §5.100
+        // §5). At dpr 1, and on any variant whose two anchors are equal, this is
+        // `optics.rimWidth` exactly.
+        rimWidth: rimWidthAtScale(optics, dpr),
         rimAlpha: optics.rimAlpha,
         specularPower: optics.specularPower,
         specularGain: optics.specularGain,
+        // The rim's amplitude law (W23). The level gain is per variant, because
+        // a variant with a different `rimAlpha` has a different rim; the two
+        // collapsed rims are the profile's, because the collapsed appearance is
+        // one appearance and the reference's fixtures carry it identically in
+        // both schemes, painted or bare (X4).
+        rimLevelGain: optics.rimLevelGain,
+        // Both ends of the collapsed rim's tint lerp, under the accessibility
+        // regime: `collapsedRimUnderPolicy` returns the two absolute constants
+        // unless a preference has asked for a border, in which case both ends are
+        // the border's own alpha and the shader's `mix` is that constant at every
+        // tint strength (W23 G1's review fix).
+        rimCollapsed: collapsedRimUnderPolicy(policy, 0, material),
+        rimCollapsedTinted: collapsedRimUnderPolicy(policy, 1, material),
+        // The rim's light in the author's own colour (W23 G3). Under a strong
+        // border the rim is the preference's mark and not the material's, so it
+        // stays white: an accessibility border that took the paint's hue would
+        // be the paint again, which is what it exists not to be.
+        rimTintChroma: policy.border === "strong" ? 0 : material.rimTintChroma,
         lightDirection: material.lightDirection,
+        // The lit edge (W24): the rim's own axis, kept apart from
+        // `lightDirection` because the shadow reads that one and the two are
+        // measured 22 degrees apart. The exponent comes from the variant's
+        // optics under the accessibility fold, so a strong border's rim is one
+        // brightness the whole way round.
+        rimLitAxis: material.rimLitAxis,
+        rimLitExponent: optics.rimLitExponent,
+        // W25's three mechanisms (claims §5.113; W25 Decision Log 3), each of
+        // them 0 on the landed material. The along-side field's slope is the
+        // variant's under the same accessibility fold as the exponent it grades;
+        // the heavy share's thick lift is resolved at the ratio this group draws
+        // at, on the pattern every second-scale constant already has; the level
+        // term's gain is the profile's, and the span curve it rides is the
+        // shader's own `farS`.
+        rimAlongSideSlope: optics.rimAlongSideSlope,
+        sizeScatterHeavyShareThick: scatterHeavyShareThickAtScale(material, dpr),
+        sizeToneLevelFar: material.sizeToneLevelFar,
+        // The heavy blur (W26): whether this group's source carries one. The width
+        // itself is already in the texture, so this pass only chooses which of
+        // two textures the deep sample comes from.
+        heavyTapEnabled: pyramid?.heavy !== void 0,
         shadowDepth: optics.shadowDepth,
         shadowAlpha: optics.shadowAlpha,
         // The size law's gains, per group (W2); the per-pixel factor they
@@ -5383,6 +6167,16 @@ function createWebGPURenderer(options = {}) {
         // were fitted on.
         backdropToneResponseStrength: backdropToneUnderPolicy(policy, material) >= 0.999 ? material.backdropToneResponseStrength : 0,
         backdropToneLinearMean: input.backdropToneLinearLuminance ?? backdropToneLevel,
+        /*
+         * The collapse's transmission (W24 G1) rides the UN-DEGRADED regime, on
+         * the same gate and for the same reason as the response law above: it is
+         * fitted on the standard reference, and the accessibility references are
+         * a nearly opaque material whose collapsed appearance was never read
+         * over a textured backdrop. Where any policy fold touches the tone axis
+         * the collapse's target is the group's mean, which is W7's behaviour and
+         * what those profiles were fitted on.
+         */
+        collapseTransmission: backdropToneUnderPolicy(policy, material) >= 0.999 ? collapseTransmissionAtScale(material, dpr) : 0,
         outerShadow: [
           // The thin regime's LINEAR occlusion at this group's backdrop (W14
           // G1). The conversion to the compositing space moved into the shader
@@ -5413,7 +6207,8 @@ function createWebGPURenderer(options = {}) {
         outerShadowRectCssHeight: rectDevice.height * cssPerDevice,
         backdrop: pyramid === void 0 || policy.glass === "none" ? void 0 : {
           chain: pyramid.chain.createView(),
-          body: pyramid.body.createView()
+          body: pyramid.body.createView(),
+          heavy: pyramid.heavy?.createView()
         }
       });
       if (active.highlight !== void 0) {
@@ -5444,6 +6239,11 @@ function createWebGPURenderer(options = {}) {
            * it, on this same product, and that zeroing is unchanged.
            */
           sweepGain: policy.glass === "none" ? 0 : material.sweepGain * lead.channels.shimmer,
+          // `rimWidth`, NOT the scale-graded band the optics pass takes (W23).
+          // The second anchor was fitted on the ambient rim read at the contour
+          // on a resting surface, and this band carries the specular sweep,
+          // which is gated to nothing at rest (W22) and has no row on any bed.
+          // A constant whose rows do not separate it is not applied here either.
           rimWidth: optics.rimWidth,
           pressPointCss: lead.channels.pressPoint ?? lead.centre,
           glowRadiusCss: material.glowRadiusCss,
@@ -5702,6 +6502,6 @@ function createWebGPURenderer(options = {}) {
   };
 }
 
-export { ADAPTIVE_LUMINANCE_HIGH, ADAPTIVE_LUMINANCE_LOW, ADAPTIVE_TINT_DARK, ADAPTIVE_TINT_LIGHT, ANALYSIS_DISPATCH, ANALYSIS_GRID, ANALYSIS_PASS_ID, ANALYSIS_STATS_FLOATS, ANALYSIS_TARGET_EXTENT, ANALYSIS_WORKGROUP, BACKDROP_ALPHA_MODES, BACKDROP_COLOR_SPACES, BACKDROP_KINDS, BACKDROP_PASS_ID, BACKDROP_TONE_HIGH, BACKDROP_TONE_LOW, BACKDROP_TONE_MAX, BACKDROP_TONE_SIZE_BIAS, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDENTITY_FIT, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_AMOUNT_MAX, LENS_AMOUNT_PER_SPAN, LENS_EXTENT_GAIN, LENS_HEIGHT_MAX, LENS_HEIGHT_PER_SPAN, LENS_OVALIZATION, LENS_PROFILE_EXPONENT, LENS_REFRACTION_GAIN, LENS_SIZE_GAIN_MAX, LENS_THICKNESS_REFERENCE, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTER_SHADOW, OUTER_SHADOW_THICK_SPANS, OUTER_SHADOW_THIN_L, OUTER_SHADOW_UNMEASURED_BACKDROP_LUMINANCE, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SIZE_OCCLUSION_GAIN, SIZE_SCATTER_FLOOR, SIZE_SCATTER_FLOOR_2X, SIZE_SCATTER_GAIN_FAR_2X, SIZE_SCATTER_GAIN_MAX, SIZE_SCATTER_GAIN_MAX_2X, SIZE_SCATTER_RAMP_REACH_1X_PX, SIZE_SCATTER_RAMP_REACH_2X_PX, SIZE_SCATTER_RAMP_START_FAR_1X, SIZE_SCATTER_RAMP_START_FAR_2X, SIZE_SCATTER_RAMP_START_THICK_1X, SIZE_SCATTER_RAMP_START_THICK_2X, SIZE_SCATTER_RAMP_START_THIN_1X, SIZE_SCATTER_RAMP_START_THIN_2X, SIZE_SCATTER_SPAN_MAX, SIZE_SCATTER_SPAN_MAX_2X, SIZE_SHADOW_GAIN_MAX, SIZE_SPAN_MAX, SIZE_SPAN_MIN, SRGB_ENCODING_EXPONENT, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptedTintAlpha, adaptedTintColour, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, backdropFit, backdropToneAdaptation, backdropToneResponse, backdropToneSizeBiasUnderPolicy, backdropToneSolveWeight, backdropToneUnderPolicy, bodyBlurPlan, chainModule, clipFieldRectToCanvas, coverFit, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, highlightModule, importColorMatrix, importModule, importPassSource, isUsablePlacement, lensAmountBasePx, lensDepthPx, lensDirection, lensDisplacementPx, lensExtentPx, lensHeightBasePx, lensMagnitudePx, lensOvalizationAt, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowLiftRise, outerShadowOcclusionAt, outerShadowReachPx, outerShadowThickOcclusion, outerShadowThinOcclusion, outerShadowUnderPolicy, packInstances, pipelineKey, placementFit, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, samePlacement, scatterDeepThickness, scatterFloorAtScale, scatterGainAt, scatterGainAtScale, scatterGainFarAtScale, scatterRampAreaMean, scatterRampReachDevicePx, scatterRampStart, scatterSharpShare, scatterSpanMaxAtScale, scatterThickness, shadowDepthPx, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, texelsPerCssPx, tintShade, tintShadeLayer, tintToneAdaptation, tintedMaterialColour, validateAppTexture, withMaterialOverrides };
-//# sourceMappingURL=dist-JWOMZCFF.js.map
-//# sourceMappingURL=dist-JWOMZCFF.js.map
+export { ADAPTIVE_LUMINANCE_HIGH, ADAPTIVE_LUMINANCE_LOW, ADAPTIVE_TINT_DARK, ADAPTIVE_TINT_LIGHT, ANALYSIS_DISPATCH, ANALYSIS_GRID, ANALYSIS_PASS_ID, ANALYSIS_STATS_FLOATS, ANALYSIS_TARGET_EXTENT, ANALYSIS_WORKGROUP, BACKDROP_ALPHA_MODES, BACKDROP_COLOR_SPACES, BACKDROP_KINDS, BACKDROP_PASS_ID, BACKDROP_TONE_HIGH, BACKDROP_TONE_LOW, BACKDROP_TONE_MAX, BACKDROP_TONE_SIZE_BIAS, CANVAS_FORMAT, CHAIN_SIGMA_AT_LEVEL_1, CROSS_CHECK_SHAPE_FLOATS, CROSS_CHECK_WORKGROUP, DEFAULT_MATERIAL_PROFILE, FAMILY_C_CROSS_CHECK, FIELD_PASS_ID, GOVERNOR_LADDER, HIGHLIGHT_PASS_ID, IDENTITY_FIT, IDLE_CHANNELS, INCREASED_OCCLUSION_LIFT, INSTANCE_BYTES, INSTANCE_FLOATS, LENS_AMOUNT_MAX, LENS_AMOUNT_PER_SPAN, LENS_EXTENT_GAIN, LENS_HEIGHT_MAX, LENS_HEIGHT_PER_SPAN, LENS_OVALIZATION, LENS_PROFILE_EXPONENT, LENS_REFRACTION_GAIN, LENS_SIZE_GAIN_MAX, LENS_THICKNESS_REFERENCE, LUMINANCE_WEIGHTS, MATERIAL_OPTICS, MATERIAL_VARIANTS, MAX_CHAIN_LEVELS, MIN_LEVEL_EXTENT, NOMINAL_GOVERNOR, NOMINAL_MATERIAL_POLICY, OPTICS_PASS_ID, OUTER_SHADOW, OUTER_SHADOW_THICK_SPANS, OUTER_SHADOW_THIN_L, OUTER_SHADOW_UNMEASURED_BACKDROP_LUMINANCE, OUTPUT_TEXTURE_FORMAT, PASS_LABEL, REFRACTION_LADDER, REFRACTION_SCALE, RENDERER_ERROR_CODES, RENDERER_PASS_IDS, RendererError, SIZE_OCCLUSION_GAIN, SIZE_SCATTER_FLOOR, SIZE_SCATTER_FLOOR_2X, SIZE_SCATTER_GAIN_FAR_2X, SIZE_SCATTER_GAIN_MAX, SIZE_SCATTER_GAIN_MAX_2X, SIZE_SCATTER_RAMP_REACH_1X_PX, SIZE_SCATTER_RAMP_REACH_2X_PX, SIZE_SCATTER_RAMP_START_FAR_1X, SIZE_SCATTER_RAMP_START_FAR_2X, SIZE_SCATTER_RAMP_START_THICK_1X, SIZE_SCATTER_RAMP_START_THICK_2X, SIZE_SCATTER_RAMP_START_THIN_1X, SIZE_SCATTER_RAMP_START_THIN_2X, SIZE_SCATTER_SPAN_MAX, SIZE_SCATTER_SPAN_MAX_2X, SIZE_SHADOW_GAIN_MAX, SIZE_SPAN_MAX, SIZE_SPAN_MIN, SRGB_ENCODING_EXPONENT, SUPPORTED_APP_TEXTURE_FORMATS, WGSL_ANALYSIS_PASS, WGSL_CROSS_CHECK_PASS, WGSL_DOWNSAMPLE_PASS, WGSL_FIELD_KERNELS, WGSL_FIELD_PASS, WGSL_FIELD_SAMPLE, WGSL_HIGHLIGHT_PASS, WGSL_IMPORT_PASS, WGSL_INSTANCE_STRUCT, WGSL_OPTICS_PASS, WGSL_PRELUDE, WGSL_RSUPN_GRAD, WGSL_RSUP_GRAD, WGSL_SMOOTH_UNION, WORKING_TEXTURE_FORMAT, ZERO_STATS, accessibilityRefractionCap, adaptationStrength, adaptedTintAlpha, adaptedTintColour, adaptiveTint, allShaderSource, alphaNormalisationMode, analysisModule, backdropFit, backdropToneAdaptation, backdropToneResponse, backdropToneSizeBiasUnderPolicy, backdropToneSolveWeight, backdropToneUnderPolicy, bodyBlurPlan, chainModule, clipFieldRectToCanvas, collapsedRimUnderPolicy, coverFit, createAdaptationState, createAppTextureProvider, createCopyProvider, createDeviceHost, createGovernor, createGpuContext, createGradientProvider, createPassRunner, createPipelineCache, createPyramidStore, createRebuildLedger, createStorageSlot, createTexturePool, createTimingCollector, createUniformSlot, createVideoProvider, createWebGPURenderer, crossCheckKernelModule, displayP3ToSrgbLinear, effectiveRefraction, encodeOutput, encodeOutputBytes, fieldModule, fieldPassSource, groupFieldRect, heavyTapSigmaAtScale, highlightModule, importColorMatrix, importModule, importPassSource, isUsablePlacement, lensAmountBasePx, lensDepthPx, lensDirection, lensDisplacementPx, lensExtentPx, lensHeightBasePx, lensMagnitudePx, lensOvalizationAt, lensSizeGain, lensSizeGainFromThickness, linearGradientStops, linearToSrgb, linearToSrgbChannel, occlusionAlphaUnderPolicy, opticsModule, opticsUnderPolicy, outerShadowAlpha, outerShadowFalloff, outerShadowLiftRise, outerShadowOcclusionAt, outerShadowReachPx, outerShadowThickOcclusion, outerShadowThinOcclusion, outerShadowUnderPolicy, packInstances, pipelineKey, placementFit, planPyramid, poolKey, readbackDue, refractionRank, relativeLuminance, rendererError, resolveSurfaces, rimAlongSideFactor, rimAlongSideField, samePlacement, scatterDeepThickness, scatterFloorAtScale, scatterGainAt, scatterGainAtScale, scatterGainFarAtScale, scatterHeavyShareThickAtScale, scatterRampAreaMean, scatterRampReachDevicePx, scatterRampStart, scatterSharpShare, scatterSpanMaxAtScale, scatterThickness, shadowDepthPx, sizeOcclusionAlpha, sizeOcclusionAlphaAt, sizeOuterShadowOcclusion, sizeOuterShadowOcclusionAt, sizeScatterSigma, sizeScatterSigmaAt, sizeShadowDepth, sizeShadowDepthAt, sizeThickness, sizeThicknessUnderPolicy, sizeToneLevelFar, snapRectToDevicePixels, srgbToLinear, srgbToLinearChannel, statsFromBuffer, supportsTimestamps, texelsPerCssPx, tintShade, tintShadeLayer, tintToneAdaptation, tintedMaterialColour, validateAppTexture, withMaterialOverrides };
+//# sourceMappingURL=dist-PT4PUS4K.js.map
+//# sourceMappingURL=dist-PT4PUS4K.js.map