@vitreajs/vitrea 0.13.0 → 0.15.0

package/dist/{dist-2V7EQHSR.js → dist-PT4PUS4K.js}

@@ -414,8 +414,64 @@ var DEFAULT_MATERIAL_PROFILE = {
        *
        * 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).
        */
-      rimLitExponent: 1.15,
+      rimAlongSideSlope: 0.1,
       shadowDepth: 0.35,
       /*
        * REFITTED 0.55 → 0.05 (2026-08-31), and it is the largest single
@@ -450,6 +506,8 @@ var DEFAULT_MATERIAL_PROFILE = {
       // 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)
@@ -636,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,
   /*
@@ -1094,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,
@@ -1157,7 +1255,11 @@ function opticsUnderPolicy(optics, policy, profile = DEFAULT_MATERIAL_PROFILE) {
       // 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
+      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;
@@ -1253,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);
@@ -1270,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];
@@ -1370,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);
@@ -2374,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`,
@@ -3442,8 +3565,21 @@ var WGSL_OPTICS_PASS = `struct OpticsUniforms {
   /// 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 free.
+  /// 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;
@@ -3457,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 {
@@ -3468,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;
@@ -3487,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
@@ -3822,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);
@@ -3894,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);
@@ -3901,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.
@@ -3997,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);
@@ -4299,7 +4497,34 @@ fn fs_optics(in : FullscreenOut) -> @location(0) vec4f {
    * 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);
-  let rim = rw * lit * (rimAmplitude * present + rimCollapsed * toneAdapt);
+  /*
+   * 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 + rimLight;
@@ -4599,7 +4824,7 @@ function createPassRunner(context) {
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 104);
+      const slot = uniformSlot(`optics:${args.groupId}`, 112);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -4704,9 +4929,19 @@ function createPassRunner(context) {
       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}`,
@@ -4727,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);
@@ -4901,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() {
@@ -4957,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();
@@ -5030,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,
@@ -5052,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({
@@ -5060,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 = {
@@ -5068,6 +5345,7 @@ function createPyramidStore(context) {
       plan,
       chain,
       body,
+      heavy,
       stats,
       sizeEpoch,
       builtEpoch,
@@ -5075,7 +5353,8 @@ function createPyramidStore(context) {
       texelsPerCss: density.texelsPerCss,
       sourceWidth: density.sourceWidth,
       sourceHeight: density.sourceHeight,
-      bodySigmaCss
+      bodySigmaCss,
+      heavySigmaCss
     };
     resources.set(sourceId, next);
     return next;
@@ -5156,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;
@@ -5182,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 } }
@@ -5285,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 };
@@ -5366,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();
@@ -5518,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,
@@ -5539,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);
@@ -5605,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);
@@ -5782,6 +6077,20 @@ function createWebGPURenderer(options = {}) {
         // 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
@@ -5898,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) {
@@ -6192,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, 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, 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-2V7EQHSR.js.map
-//# sourceMappingURL=dist-2V7EQHSR.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