@vitreajs/vitrea 0.11.0 → 0.13.0

package/dist/{dist-JWOMZCFF.js → dist-2V7EQHSR.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,56 @@ 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).
+       */
+      rimLitExponent: 1.15,
       shadowDepth: 0.35,
       /*
        * REFITTED 0.55 → 0.05 (2026-08-31), and it is the largest single
@@ -327,8 +440,16 @@ 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,
       shadowDepth: 0.22,
       shadowAlpha: 0.4,
       highlight: srgbToLinear(SRGB_WHITE_TINT)
@@ -647,6 +768,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 +995,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 +1040,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;
@@ -878,12 +1118,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 +1147,27 @@ 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
+    };
+  }
   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;
@@ -1080,6 +1343,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);
 }
@@ -3068,7 +3337,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 +3388,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 +3433,17 @@ 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 free.
+  rimLit : vec4f,
 };
 
 @group(0) @binding(0) var<uniform> ou : OpticsUniforms;
@@ -3742,11 +4028,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 +4123,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 +4172,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 +4218,91 @@ 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);
+  let rim = rw * lit * (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 +4313,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 +4599,7 @@ function createPassRunner(context) {
       };
     },
     opticsPass(encoder, args) {
-      const slot = uniformSlot(`optics:${args.groupId}`, 96);
+      const slot = uniformSlot(`optics:${args.groupId}`, 104);
       const d = slot.data;
       d[0] = args.viewportDevice[0];
       d[1] = args.viewportDevice[1];
@@ -4233,7 +4672,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,6 +4697,13 @@ 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;
       slot.write();
       const chain = args.backdrop?.chain ?? placeholderView;
       const body = args.backdrop?.body ?? placeholderView;
@@ -5302,11 +5748,40 @@ 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,
         shadowDepth: optics.shadowDepth,
         shadowAlpha: optics.shadowAlpha,
         // The size law's gains, per group (W2); the per-pixel factor they
@@ -5383,6 +5858,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
@@ -5444,6 +5929,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 +6192,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, 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