@vitreajs/vitrea 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -997,7 +997,7 @@ interface ZSlot {
     readonly order: number;
 }
 /** Viewport-space rectangle in CSS px, measured by platform-web and handed in as data. */
-interface Rect {
+interface Rect$1 {
     readonly x: number;
     readonly y: number;
     readonly width: number;
@@ -1006,9 +1006,9 @@ interface Rect {
 /** Back-to-front ordering: every base node before every overlay node, then by `order`. */
 declare function compareZSlot(a: ZSlot, b: ZSlot): number;
 /** Smallest rect containing both. */
-declare function unionRect(a: Rect, b: Rect): Rect;
+declare function unionRect(a: Rect$1, b: Rect$1): Rect$1;
 /** Grow a rect outwards on every side — how a group's proxy gets its padding. */
-declare function inflateRect(rect: Rect, by: number): Rect;
+declare function inflateRect(rect: Rect$1, by: number): Rect$1;
 /**
  * The part of `rect` that survives every clip in the chain.
  *
@@ -1031,13 +1031,13 @@ declare function inflateRect(rect: Rect, by: number): Rect;
  * — an overlap check that over-reports warns about something real-ish, one that
  * under-reports misses a genuine double-filter.
  */
-declare function clipRect(rect: Rect, clip: readonly Rect[] | undefined): Rect;
+declare function clipRect(rect: Rect$1, clip: readonly Rect$1[] | undefined): Rect$1;
 /**
  * Positive-area intersection. Touching edges are not an overlap — adjacent
  * surfaces in a toolbar are the common case and are legal. A degenerate rect
  * (an unmeasured or collapsed host) overlaps nothing.
  */
-declare function rectsOverlap(a: Rect, b: Rect): boolean;
+declare function rectsOverlap(a: Rect$1, b: Rect$1): boolean;
 
 /**
  * The scene model (§Core model): the three registries and everything that
@@ -1236,9 +1236,9 @@ interface GlassNodeDescriptor {
 interface GlassNodeRecord {
     readonly descriptor: GlassNodeDescriptor;
     /** Measured by platform-web in the read phase; absent until then. */
-    readonly bounds?: Rect;
+    readonly bounds?: Rect$1;
     /** Ancestor clip chain, viewport space. */
-    readonly clip?: readonly Rect[];
+    readonly clip?: readonly Rect$1[];
 }
 /** One pyramid rebuild. `groupIds` is why there is one request and not one per group. */
 interface BackdropRebuildRequest {
@@ -1335,7 +1335,7 @@ interface GlassScene {
     glassNode(id: string): GlassNodeRecord | undefined;
     nodesOfGroup(groupId: string): readonly GlassNodeRecord[];
     /** Measured viewport geometry, from the read phase. */
-    setNodeBounds(id: string, bounds: Rect, clip?: readonly Rect[]): void;
+    setNodeBounds(id: string, bounds: Rect$1, clip?: readonly Rect$1[]): void;
     /**
      * Scene-wide by default; per group when `groupId` is given.
      *
@@ -1638,6 +1638,33 @@ interface MaterialRim {
  * occlusion over 142,550 pixels on the finest cell, and the same three lengths
  * describe every profile, backdrop, span and scale in the bed.
  *
+ * ## Two terms on ONE falloff (W14 G0, claims §5.62)
+ *
+ * The description above holds where W8 measured it and misses two things the bed
+ * has since shown, both of which live in the AMPLITUDE and neither of which
+ * moves a length. Outside the coverage, in the compositing (encoded) domain:
+ *
+ *     out = bg · (1 − α_b(backdrop, span) · F(d))  +  A_v(span) · F(d) · V
+ *
+ * with **one** falloff `F` — W8's own, at 15.55 / 7.95 / 3.1, re-read free and
+ * unmoved on both terms (σ 14.8–16.2 and offset 7.93–8.00 for the black term,
+ * σ 14.1–17.1 and offset 7.6–8.4 for the lift) — and `V` the backdrop's own
+ * light blurred at `liftBlurSigmaCss`.
+ *
+ * The first term's amplitude ADAPTS below the knee: the reference's fill alpha
+ * is 0.33 over the mid backdrops, 0.127 over `light-solid` and nothing over
+ * black, keyed on the SAME backdrop luminance statistic W9's face response uses
+ * (the ENCODED-space mean, decoded — `backdropToneAnchorX`'s own axis), through
+ * the same thickness curve that gates that regime. Above the knee it is the
+ * composite's transmission by span. The second term is the lift, GPU-tier only,
+ * and it is exactly zero below the knee and exactly zero over black, so the
+ * facet's "invisible over a black backdrop" property survives both terms.
+ *
+ * The layer tree's `inputShadowAmount` and `inputShadowHeight` are NOT either
+ * term's spatial extent — the charter's advisory was wrong there, and G0's free
+ * fits overturned it. Only `inputShadowBlurRadius` 40 belongs to the lift, as
+ * the blur of the backdrop it copies.
+ *
  * **Multiplicative, and not additively.** Mirrored pixel pairs either side of a
  * capsule over the `photo` backdrop see the same shadow over different backdrop
  * luminances: the darkening's ratio tracks the backdrop's ratio to 4.5% while a
@@ -1666,22 +1693,151 @@ interface MaterialOuterShadow {
     /** Outward spread of the silhouette before the blur, CSS px. */
     readonly spreadPx: number;
     /**
-     * Peak occlusion: the fraction of the backdrop's own LINEAR light removed deep
-     * inside the shadow. Zero stands the whole facet down, pad and all.
+     * The black term's peak occlusion below the knee, over a backdrop the material
+     * cannot see (linear luminance ≤ `OUTER_SHADOW_THIN_L.inert`): zero. Inert
+     * over `dark-solid` and `impulse`, which is what the reference does — it
+     * removes at most one or two of 255 codes there (claims §5.62 §5).
+     */
+    readonly thinOcclusionDark: number;
+    /**
+     * The black term's peak occlusion below the knee over the MID plateau —
+     * backdrop linear luminance `OUTER_SHADOW_THIN_L.midFrom` … `midTo`.
+     *
+     * MEASURED (claims §5.62 §5): linear occlusion 0.347 over `mid-dark-solid`,
+     * 0.334–0.339 over `photo`, 0.327–0.328 over the checkerboard and 0.329 over
+     * `hc-text` — flat across a backdrop luminance range of 0.06…0.74, and a
+     * constant 1.16–1.19× the fill alpha §5.50 §2 read off the layer tree.
+     */
+    readonly thinOcclusionMid: number;
+    /**
+     * The black term's peak occlusion below the knee over a BRIGHT backdrop, at
+     * `OUTER_SHADOW_THIN_L.bright` and above.
+     *
+     * MEASURED (claims §5.62 §5): 0.127 over `light-solid` (linear luminance
+     * 0.891), against the layer tree's tabulated 0.05 — so the reference's shadow
+     * there is 0.39 of its shadow over the checkerboard, not one sixth. W8's
+     * single 0.285 everywhere is 2.24× this, which is the whole of the user's
+     * by-eye "the shadow is darker on the light-solid capsule" and, by the free
+     * geometry fit on that cell (σ 14.81 / offset 7.97 / spread 3.17), no part of
+     * it is shape.
      */
-    readonly occlusion: number;
+    readonly thinOcclusionBright: number;
     /**
-     * What reduced transparency does to `occlusion` — MEASURED, not assumed, which
-     * is what the charter asked for before the fold was written.
+     * The COMPOSITE occlusion above the knee at a casting span of 96 CSS px.
+     *
+     * FITTED in the renderer (claims §5.65), from G0's measurement of the
+     * composite's transmission (0.379 on the checkerboard at span 96) to **0.370**.
+     * It had to be fitted rather than adopted, because what G0 could identify at
+     * the bed's noise floor is the composite transmission and the lift's peak
+     * amplitude, not the split into (black alpha, vibrant alpha, vibrant colour):
+     * both terms ride one falloff and their shapes correlate at 0.9998. So this
+     * constant is the BLACK term of a two-term composite whose second term
+     * (`liftAmplitude`) was fitted beside it, on X7's affine pair, and the pair is
+     * what the referee reads.
+     */
+    readonly thickOcclusionAt96: number;
+    /** The same at a casting span of 128 CSS px — FITTED to 0.448 from G0's
+     * measured 0.497, for `thickOcclusionAt96`'s reason (claims §5.65). */
+    readonly thickOcclusionAt128: number;
+    /**
+     * The same at a casting span of 160 CSS px — **UNFITTED**, and the one anchor
+     * in this block that no calibration cell reaches.
+     *
+     * Every span above 128 in the bed is holdout, so 0.479 is carried by the stated
+     * derivation from the two fitted anchors and not by a fit. The holdout, read
+     * once and fitted to nothing, says it is 15% heavy (band `1 − a` 0.2436 against
+     * the reference's 0.2117) and implies about 0.437 — which is BELOW the fitted
+     * At128 and which no extrapolation from the calibration cells would have
+     * produced. That reading is recorded and deliberately not adopted (claims §5.65
+     * §4(b) and §6(iv)); closing it needs a calibration cell above span 128.
+     */
+    readonly thickOcclusionAt160: number;
+    /**
+     * **The lift (W14)** — the peak amplitude of the second term, in LINEAR light,
+     * as a fraction of the backdrop's own blurred luminance. GPU tier only.
+     *
+     * The reference's thick shadow does not only remove light: on the
+     * checkerboard's black squares, where a multiply is inert by construction, it
+     * ADDS 7.4 of 255 (claims §5.62 §2). Pooled over six backdrops the addition
+     * regresses on the σ-40 blurred backdrop at slope 0.0444 with intercept
+     * −0.0042 and R² 0.983 — it is the backdrop's own light, blurred, composited
+     * under the shadow, with no fixed colour left over. Zero over `impulse`, zero
+     * over `dark-solid`, and zero below the knee, so the facet stays exactly inert
+     * over black the way W8's multiply is.
+     *
+     * FITTED to **0.0100** in the renderer over seventeen sweep passes, read on
+     * X7's affine pair together with the three thick anchors (claims §5.65). The
+     * provisional 0.0073 was G0's +0.0038 of LINEAR lift at span 160 divided by
+     * the ≈ 0.52 linear luminance the checkerboard's σ-40 blur sits at, and the fit
+     * is 37% larger. The space matters and this wave names it everywhere (claims
+     * §5.62 §3): §5.60's +0.039 is the same lift read in ENCODED luma.
+     */
+    readonly liftAmplitude: number;
+    /**
+     * Where the lift starts, in casting span, CSS px — the thin/thick knee, and it
+     * is exact: the lift reads 0.0000 at spans 32 and 44 and is present at 96
+     * (claims §5.62 §2). The layer tree's own `VibrancyContribution` clamps from
+     * the same 64.
+     */
+    readonly liftSpanMin: number;
+    /**
+     * Where the lift saturates, in casting span, CSS px.
+     *
+     * FITTED to **118** (claims §5.65), from a provisional 128. The measured rise
+     * is 0.52 / 0.96 / 1.00 of the span-160 value at spans 96 / 128 / 160, against
+     * the layer tree's clamp((span − 64)/96) = 0.33 / 0.67 / 1.00 — so the lift is
+     * NOT proportional to `VibrancyContribution`; it rises and saturates, reaching
+     * 96% by span 128 (claims §5.62 §2), which a smoothstep from `liftSpanMin`
+     * reproduces and the clamp does not. The holdout says the reach saturates a
+     * little early — the lift's own residual there is one-signed and small, 5% low
+     * at span 130 and 9% at 160 (claims §5.65 §4(d)) — and it was not refitted
+     * after that reading.
+     */
+    readonly liftSpanFull: number;
+    /**
+     * The σ, in CSS px, of the blur the lift copies the backdrop through.
      *
-     * The reference's shadow under `reduce transparency` is the same shadow at
-     * 0.566 of the amplitude: 0.1830/0.3259, 0.1884/0.3309 and 0.1882/0.3314 on the
-     * three structured backdrops at a 44 px span, with σ, offset and spread
-     * unmoved. It does not vanish and it does not intensify.
+     * MEASURED at 40 ± 8 CSS px on `rrect-lg` at both scales and in two rings, by
+     * the probes' pitch axis — the pooled residual has a real minimum there, 12%
+     * below the flat-copy residual (claims §5.62 §3). It is the layer tree's
+     * `inputShadowBlurRadius` 40 read as a Gaussian standard deviation. NOT
+     * identifiable on the mid spans (flat to 0.7%), and reported as such rather
+     * than fitted there.
+     */
+    readonly liftBlurSigmaCss: number;
+    /**
+     * The shadow's amplitude UNDER reduced transparency — one absolute linear
+     * occlusion that replaces both regimes, not a factor on either. MEASURED,
+     * which is what the charter asked for before the fold was written.
+     *
+     * **0.197 (measured 0.192–0.202).** W14 G0 read the preference on the wider
+     * bed and what it found is a flat number: the reference's exterior is
+     * 0.192–0.202 under increased contrast and reduced transparency alike, **thin
+     * and thick together** and over every backdrop it can be read on (claims §5.62
+     * §5). The preference removes the material's adaptation, so the shadow it
+     * leaves has neither the thin regime's backdrop keying nor the thick regime's
+     * span law in it — one amplitude for every surface over every backdrop, which
+     * is what `outerShadowUnderPolicy` writes into all six anchors. The lift goes
+     * with it: a composite whose two regimes read the same number has no second
+     * term left in it.
+     *
+     * It is stated as an ABSOLUTE occlusion rather than as a ratio because W8's
+     * 0.70 multiplier was fitted when the amplitude was one span-flat number and a
+     * ratio was the same thing as a level. It is not any more: multiplying six
+     * unequal anchors keeps exactly the backdrop and span variation the preference
+     * removes, and a span-160 surface over a mid-tone backdrop folded to 0.38
+     * against the reference's 0.20. The number the reference states is a level, so
+     * this constant is a level.
+     *
+     * Nothing is special-cased for a dark backdrop and nothing needs to be: an
+     * occlusion is a fraction of the backdrop's own light, so a flat 0.197 over
+     * black still removes nothing, and the facet stays as inert there as the thin
+     * regime's own zero anchor makes it without the preference.
      *
      * The `increased contrast` reference reproduces the reduced-transparency
-     * amplitude to four decimals (0.1830, 0.1884, 0.1882 — the same numbers), which
-     * is Decision Log 8's finding again: macOS force-couples the two toggles, so the
+     * amplitude to four decimals (0.1830, 0.1884, 0.1882 on the three structured
+     * backdrops at a 44 px span, with σ, offset and spread unmoved), which is
+     * Decision Log 8's finding again: macOS force-couples the two toggles, so the
      * contrast reference IS the reduced-transparency state and the bed cannot
      * separate them. The fold therefore keys on `frost`, the axis reduced
      * transparency alone sets, rather than on the contrast axes it would be
@@ -1747,11 +1903,13 @@ interface MaterialProfile {
      * substantial material. It casts deeper, richer shadows, has more pronounced
      * lensing and refraction effects, and a softer scattering of light" (S219). One
      * mechanism means one curve: `sizeThickness(span)` is a smoothstep from
-     * `sizeSpanMin` to `sizeSpanMax`, and **every** thickness-derived facet is a
-     * gain on it — the lens (`lensSizeGainMax`), the scattering
-     * (`sizeScatterGainMax`), the occlusion (`sizeOcclusionGain`) and the inner
-     * shadow (`sizeShadowGainMax`). Two curves would be two mechanisms, and the
-     * reference only has one.
+     * `sizeSpanMin` to `sizeSpanMax`, and the thickness-derived facets are gains
+     * on it — the lens (`lensSizeGainMax`), the occlusion (`sizeOcclusionGain`)
+     * and the inner shadow (`sizeShadowGainMax`). The scattering was one of them
+     * until W11c measured its curve to be a different one (a floor at small
+     * spans, a rise past 96) and W13 measured that curve to be the projection of a
+     * ramp in depth — see `sizeScatterFloor` and `sizeScatterRampStartThin1x`; the
+     * scattering now rides its own law entirely, and this band is untouched by it.
      *
      * A smoothstep rather than a straight ratio, so two surfaces of nearly the same
      * size never read as differently thick, and so every gain saturates instead of
@@ -1769,12 +1927,17 @@ interface MaterialProfile {
     readonly sizeSpanMin: number;
     readonly sizeSpanMax: number;
     /**
-     * The lens's gain on the size curve — "more pronounced lensing and refraction".
+     * The inner shadow's depth gain on the size curve — and, until W12 G2, the
+     * lens's too.
      *
-     * `lensDepthPx` is `thickness × lensSizeGain(span)`, clamped to the shorter
-     * *half* extent. The clamp is what keeps a small control from being all lens: a
-     * 24 px-tall button cannot bend more than 12 px of backdrop however thick it is
-     * authored.
+     * The inner shadow's depth is `thickness × (1 + (lensSizeGainMax − 1) ×
+     * sizeThickness)`, clamped to the shorter *half* extent, and its profile is
+     * `(1 − depth)²` on that depth: the landed law of W2, kept byte-for-byte for the
+     * occlusion because nothing measured it as wrong. The LENS no longer reads it —
+     * the reference's own lens height is a clamped linear function of the span
+     * (`lensHeightPerSpan`, `lensHeightMax`), read straight from its layer tree
+     * (claims §5.50), and the lens takes that law from W12 G2 on. The name stays so
+     * the profile documents keep naming the constant they measured.
      */
     readonly lensSizeGainMax: number;
     /**
@@ -1796,8 +1959,213 @@ interface MaterialProfile {
      * Both tiers carry it, from one function (`sizeScatterSigma`): the CSS tier
      * multiplies its `blur()` σ, and the GPU tier lerps its body sample toward the
      * chain level whose blur is that σ.
+     *
+     * MEASURED (W11c G1, claims §5.41), and no longer a gain on `sizeThickness`
+     * alone — see `sizeScatterFloor` and `sizeScatterRampStartThin1x` below for the
+     * law it rides. 8: the heavy component of the reference's interior sits near
+     * σ 10 device px against a body σ of 1.25, and the gain sweep has a clear
+     * minimum at 8 (RMS 0.0164 against 0.0180 at 6 and 0.0191 at 10 on the probe
+     * bed).
      */
     readonly sizeScatterGainMax: number;
+    /**
+     * **The scattering facet's frost** (W11c G1, claims §5.41; re-read by W13 G1).
+     *
+     * The reference's interior over structured content is two components, read
+     * off the W9 probe bed across four checkerboard pitches and five spans: a
+     * sharp one near σ 1.25 device px and a heavy one near σ 10, mixed by a share
+     * that is already ≈ 0.4 at spans of 32–44 and still rising at 160. W11c
+     * carried that mix as one number per span, a floor rising by a smoothstep to
+     * a band top (`sizeScatterSpanMax`); W13 G0 measured the mix **per depth** on
+     * both probes and found a ramp under the contour that the span law had been
+     * summarising (claims §5.61 §2). W13 G1's first form replaced the span law
+     * with the ramp outright and its runtime sweep refuted that: the ramp's own
+     * projection onto one number per surface runs 0.43–0.56 where the span law it
+     * replaced runs 0.41–1.00, so a ramp with a start and a reach is nearly
+     * span-flat where the bed is strongly span-graded, and no point in 81 reached
+     * the wave's stops (`results/2026-09-03-w13-ramp/g1/sweep/g1-sweep.md` §4,
+     * §7). So the two are kept **together**: the span law is the ramp's DEEP
+     * value and the ramp is a near-contour excursion above it. This floor is
+     * unchanged in value and in meaning under either: the mix a surface carries
+     * at any size, the material's own frost.
+     *
+     * It keeps its fold semantics, and they are now written on the ramp rather
+     * than on a span curve:
+     *
+     * ```
+     * kScatter(u) = floor + (k(u) − floor) · fold
+     * ```
+     *
+     * — so at fold 1 the ramp is rendered exactly and at fold 0 the material sits
+     * at this floor exactly, which is what the landed law did at fold 0 too. The
+     * floor is the frost the material has whatever its size, and is **not**
+     * folded under an accessibility preference; the excursion away from it is
+     * depth, and is. Fitted with `rrect-lg` held out (W11c G1): 0.40 (0.0175 at
+     * 0.3, 0.0174 at 0.45).
+     */
+    readonly sizeScatterFloor: number;
+    /**
+     * **The scattering facet's span curve** (W11c G1, claims §5.41) — the top of
+     * the band the frost rises to, and, since W13 G1's re-forming, the span law
+     * that supplies the depth ramp's DEEP value:
+     *
+     * ```
+     * kDeep(span) = floor + (1 − floor) · smoothstep(sizeSpanMin, sizeScatterSpanMax, span)
+     * ```
+     *
+     * — byte for byte the curve W11c fitted and W13 G1's first form retired. It
+     * came back because the sweep measured what retiring it cost (§4 of
+     * `results/2026-09-03-w13-ramp/g1/sweep/g1-sweep.md`): the span dependence of
+     * the bed is real and strong, and the ramp's four constants cannot carry it
+     * at the same time as the band's near-contour excursion. What the ramp adds
+     * is what this curve never could — the depth structure inside one surface —
+     * and it now adds it on top of this rather than instead of it, so the deep
+     * interior of every span is exactly where W11c and W12 put it.
+     *
+     * `sizeThickness` — zero at `sizeSpanMin` and saturated at `sizeSpanMax` = 96
+     * — can express neither the floor nor a band top past 96, and moving
+     * `sizeSpanMax` would move the lens, the occlusion, the inner shadow and W9's
+     * thin/thick response rows with it, which is why the scatter mix has its own
+     * curve at all. Fitted with `rrect-lg` held out (W11c G1): band top 256
+     * (0.0182 at 224, 0.0174 at 320); the held-out cell's residual 0.0366 →
+     * 0.0174.
+     */
+    readonly sizeScatterSpanMax: number;
+    /**
+     * **The body's depth ramp** (W13 G1, from the measurement of claims §5.61 §2
+     * and the re-forming its runtime sweep forced) — a near-contour excursion on
+     * the sharp component's share, riding on top of the span law
+     * `sizeScatterSpanMax` supplies rather than replacing it.
+     *
+     * ```
+     * kDeep(span) = sizeScatterFloor + (1 − sizeScatterFloor)
+     *               · smoothstep(sizeSpanMin, sizeScatterSpanMax, span)
+     * sDeep(span) = 1 − kDeep(span)
+     * s₀(span)    = startThin + (startThick − startThin) · sizeThickness(span)
+     * s(u, span)  = sDeep + max(0, s₀(span) − sDeep) · max(0, 1 − u / U(dpr))
+     * k(u, span)  = 1 − s(u, span)
+     * ```
+     *
+     * with `u` the pixel's depth under the contour and `U` the reach, both in
+     * DEVICE px. `s₀` is the sharp share **at the contour** and `U` is where the
+     * excursion vanishes into the deep value — not where a line from the start
+     * would hit zero, which is what the first form's reach meant. Deep inside any
+     * surface the body is exactly the W11c/W12 material; within `U` of the
+     * contour the sharp component is lifted toward `s₀`, which is the band the
+     * reference has and the uniform share does not.
+     *
+     * **Why the start grades with the span, in the third form.** The second form
+     * gave the excursion one start per scale and its runtime sweep refuted that
+     * too, arithmetically rather than for want of a better point (claims §5.64
+     * §2): `rrect-sm`'s span is exactly `sizeSpanMin`, so its deep sharp share is
+     * exactly `1 − sizeScatterFloor` = 0.600 and no start at or below 0.600 can
+     * touch it, while `rrect-ml`'s band only improves below a start near 0.583.
+     * The window where both hold is empty, and the reach cannot open it — the
+     * reach decides how much of a surface the excursion covers, never which
+     * surfaces it touches, because `max(0, s₀ − sDeep(span))` has no reach in it.
+     * G0 read the reference's start as strongly graded by span (0.637 / 0.642 on
+     * the thin cells against 0.512 / 0.501 / 0.410 on the thick ones at 1x), so
+     * the start is given exactly that grading — across `sizeThickness`, the
+     * material's OWN thin/thick curve with its knee at 64, the one the face's
+     * tone response and the outer shadow already blend across. Reusing it is the
+     * point: it introduces no new span statistic, and `sizeSpanMax` stays where
+     * every other facet reads it.
+     *
+     * **Why this form and not the ramp alone.** W13 G0 measured a ramp with a
+     * free start, reach and floor (H2) and the first implementation took the free
+     * start and reach with a floor of zero, retiring the span law. Its runtime
+     * sweep — 81 points, both scales, the real renderer — could not reach the
+     * wave's stops at any point, and named the mechanism: the ramp's projection
+     * onto one number per surface runs 0.43–0.56 at 1x where the retired span law
+     * ran 0.41–1.00, so the family is nearly span-flat and the bed is strongly
+     * span-graded; small spans want a high start and large spans a low one and no
+     * pair can be both (`.../g1/sweep/g1-sweep.md` §4). §7 of the same report
+     * asked for exactly this: "the ramp's DEEP value wants to be the span-graded
+     * heavy share the retired law supplied, and its near-contour excursion the
+     * sharp term the band asks for." The floor H2 left free is therefore not one
+     * more constant but the span law itself, which is already fitted.
+     *
+     * The reach stays a LENGTH in device pixels, which is the reading that did
+     * survive the sweep: the free fits' reaches in absolute depth spread by 1.3×
+     * across the spans (108 / 115 / 144 CSS px at 1x on `rrect-lg` / `-ml` /
+     * `-md`) where the reaches as a fraction of the half-span spread by 2.2×, and
+     * between the two scales that length roughly halves in CSS px — one length in
+     * device pixels, the same reading as the widths (§5.55 §1, §5.56 §1).
+     *
+     * The start and the reach are anchored at the two scales the reference was
+     * measured at rather than given a scale term: `…1x` is the value at dpr 1,
+     * `…2x` at dpr 2, the pair interpolated linearly in dpr and held constant
+     * outside [1, 2] (`scatterRampStart`, `scatterRampReachDevicePx`).
+     *
+     * **The FOURTH form: the start keeps falling past the thickness knee (W13
+     * Decision Log 6; claims §5.67 §4, §6).** The third form's holdout failed on
+     * one row for the form's own arithmetic: `sizeThickness` saturates at
+     * `sizeSpanMax` 96, so spans 96, 128, 130 and 160 all received the identical
+     * thick start while G0 read the reference's start FALLING across exactly
+     * those spans (0.512 → 0.501 → 0.410), and because the deep value keeps
+     * falling to `sizeScatterSpanMax` the excursion GREW with span (0.039 →
+     * 0.156 → 0.284) where the reference's shrinks — `rrect-lg` overshot its
+     * interior by 33%. So the start gets a slow decline along the scatter
+     * facet's own curve above the knee, `startFar` being its value at span ≥
+     * `sizeScatterSpanMax`:
+     *
+     *   s₀(span) = thin + (thick − thin) · sizeThickness(span)
+     *            + (far − thick) · smoothstep(sizeSpanMax, sizeScatterSpanMax, span)
+     *
+     * Two curves the material already has, one more constant per scale, and no
+     * new span statistic. At 2x `far` sits below the thick anchor, so the null
+     * the third form verified bit-exactly (§5.67 §2) holds by construction: an
+     * excursion that was zero at every span stays zero when its start falls
+     * further.
+     *
+     * PROVISIONAL, all eight. The runtime sweep at this form sets them, because
+     * the paper model over-credited the mip chain's heavy tap once already
+     * (§5.58 §1) and no constant lands on a paper prediction again. What they
+     * carry now:
+     *
+     * **1x — thin 0.64, thick 0.52, reach 120 device px.** G0's own start
+     * readings are 0.637 on `rrect-sm` and 0.642 on the capsule at the thin end
+     * and 0.512 / 0.501 / 0.410 on `rrect-md` / `-ml` / `-lg` at the thick end.
+     * A thick anchor fitted to all three thick cells jointly comes out near 0.47,
+     * and 0.47 sits 0.011 *below* `rrect-md`'s own deep sharp share of 0.481,
+     * which would clamp the excursion to zero on that one cell. 0.52 is above it
+     * and is also G0's reading on that cell, so the fit is not traded against the
+     * form's own arithmetic.
+     *
+     * **2x — thin 0.46, thick 0.17, reach 100 device px, and the excursion clamps
+     * to zero on every cell of the calibration bed.** These are G0's 2x readings
+     * (0.483 / 0.437 on the thin cells, 0.192 / 0.179 / 0.141 on the thick ones),
+     * and every one of them sits BELOW its cell's deep sharp share: the implied
+     * excursions run −0.095 to −0.289 (claims §5.64 §4). `max(0, s₀ − sDeep)` is
+     * therefore zero everywhere on this bed at dpr 2. That is not a special case
+     * and not a disabled facet — it is the law evaluating to no excursion where
+     * the reference's own contour share is heavier than vitrea's deep value. It
+     * follows that **the 2x gap is a deep-value gap and not a ramp gap**: the
+     * span law's floor, knee and top are what miss at that scale, and no
+     * one-signed excursion above them can express it. That fit is W13's Deferred
+     * charter and not this constant's business.
+     *
+     * **far — 0.20 at 1x (FITTED on the W14 bed), 0.15 at 2x.** The fourth
+     * sweep (`results/2026-09-03-w13-ramp/g1/sweep-4/`) swept far over eight
+     * points from 0.52 (the third form) down to 0.15: S1 and S4 pass at every
+     * one, only `rrect-ml`'s rows move and they improve monotonically as far
+     * falls, and the band is flat within the bed's noise below 0.30. The cell
+     * the constant exists for is holdout, so the tie inside the noise is broken
+     * by the reference's own reading — G0's `rrect-lg` start of 0.410 at span 160
+     * is far = 0.207 through this form — and 0.20 is the measured grid point that
+     * carries it. The confirmation read `rrect-lg` at `ssimMean` +0.0056 against
+     * the W14 bed (the third form: −0.0026) with its interior 12% over the
+     * reference (from 33% over). At 2x far is below the thick anchor so that the
+     * null holds — re-verified bit-exact under this form.
+     */
+    readonly sizeScatterRampStartThin1x: number;
+    readonly sizeScatterRampStartThick1x: number;
+    readonly sizeScatterRampStartFar1x: number;
+    readonly sizeScatterRampStartThin2x: number;
+    readonly sizeScatterRampStartThick2x: number;
+    readonly sizeScatterRampStartFar2x: number;
+    readonly sizeScatterRampReach1xPx: number;
+    readonly sizeScatterRampReach2xPx: number;
     /**
      * The occlusion gain — "a larger size is more opaque. A smaller size is
      * clearer" (S284). The fraction of the *remaining* transparency the size law
@@ -1828,9 +2196,64 @@ interface MaterialProfile {
      * an outer `box-shadow` the reference does not cast at all (Decision Log #32(c)).
      */
     readonly sizeShadowGainMax: number;
-    /** Chain LOD per CSS px of lens depth, and how much sharper the rim samples. */
-    readonly lensBodyLodPerPx: number;
-    readonly lensRimLodBias: number;
+    /**
+     * The lens (W12 G2, claims §5.51) — one steep power on the reference's own
+     * span law, along a direction the reference ovalizes.
+     *
+     * The reference's `glassBackground` filter takes an inner refraction *amount*
+     * and *height* that are clamped linear functions of the shape's shorter side
+     * (claims §5.50: amount −min(0.8·span, 60), height min(0.25·span, 20)). What
+     * those two numbers do spatially is not in the tree; measured as a field on
+     * the captures (§5.49) and ranked on the pixels (§5.51), the band is
+     *
+     *   D(u) = S · max(0, 1 − u / L′)^p,   S = lensRefractionGain · A(span),
+     *                                       L′ = lensExtentGain · lensDepth,
+     *
+     * with `lensDepth = (thickness / lensThicknessReference) × H(span)` the
+     * reference's height law scaled by the author's thickness (8 is the default
+     * and the reference's unit — at 8 the depth IS Apple's height, 8 / 11 / 20 on
+     * spans 32 / 44 / ≥ 80), `A(span)` the amount law scaled the same way, and
+     * `p = lensProfileExponent`. Apple's own two-term profile at its literal
+     * amounts was ranked too and lost on the pixels and the holdout; its span law
+     * is adopted, its shape is not (§5.51 §2).
+     *
+     * `lensRefractionGain` is therefore re-based: it was 1.6 lens depths on the
+     * W11c square profile (S = 1.6 × 20.8 = 33.3 at saturation), it is now the
+     * scale on the reference's amount (S = 0.745 × 60 = 44.7), fitted on
+     * `rrect-md` + `-ml` at 1x with `rrect-lg` held out.
+     */
+    readonly lensRefractionGain: number;
+    /** The reference's inner refraction height law: `min(lensHeightPerSpan · span, lensHeightMax)`. */
+    readonly lensHeightPerSpan: number;
+    readonly lensHeightMax: number;
+    /** The reference's inner refraction amount law: `min(lensAmountPerSpan · span, lensAmountMax)`. */
+    readonly lensAmountPerSpan: number;
+    readonly lensAmountMax: number;
+    /**
+     * The author `thickness` at which the lens depth equals the reference's own
+     * height — the host's default, and what the bed was captured at. A thicker
+     * authoring scales the depth and the magnitude together.
+     */
+    readonly lensThicknessReference: number;
+    /** The profile's extent over the lens depth: D reaches zero at `lensExtentGain × lensDepth`. */
+    readonly lensExtentGain: number;
+    /** The profile's exponent — the square of W11c became a steeper power (§5.49 §2). */
+    readonly lensProfileExponent: number;
+    /**
+     * The direction's ovalization (§5.49 §3, §5.50): the reference's SDF element
+     * carries `gradientOvalization`, and the band is magnified *along* the edge by
+     * up to 1.31× as a result. The shader displaces along the gradient of the
+     * blended field `(1 − ω)·d_rrect + ω·d_oval`, `d_oval` the signed distance of
+     * the ellipse inscribed in the surface's box, with the magnitude fixed. The
+     * reference's value is 0.5 on thick shapes and 0 on thin ones; 0.6 is what the
+     * pixels want on the box-inscribed ellipse (Apple's oval is more curved at the
+     * edge midpoint than that ellipse). The switch is a step in the reference
+     * between spans 64 and 72; here it is a smoothstep over that band, the same at
+     * both ends and continuous through a morph.
+     */
+    readonly lensOvalization: number;
+    readonly lensOvalizationSpanMin: number;
+    readonly lensOvalizationSpanMax: number;
     /**
      * What each accessibility regime does to the numbers above. The multipliers
      * match `platform-web`'s CSS tier so the two renderers degrade the same way
@@ -1859,28 +2282,39 @@ interface MaterialProfile {
     readonly strongBorderRim: MaterialRim;
     readonly reducedTintAdaptation: number;
     /**
-     * The author tint's tone map — Apple's "range of tones **mapped to content
-     * brightness underneath**" (S219), as four numbers.
+     * The author tint's shade law (W10) — Apple's "range of tones **mapped to
+     * content brightness underneath**" (S219), measured per pixel on the frozen
+     * bed and the W9 probe (claims §5.36).
      *
-     * The seed the author gives is not the colour the material paints. It is the
-     * middle of a range: over a dark backdrop the material shows a shade of the
-     * seed (`tintToneFloor`, a multiple of it in linear light, so hue and
-     * chromaticity survive); over a bright one it shows the seed washed toward
-     * white (`tintToneCeilMix`), which is what Apple's "changing its hue,
-     * brightness and saturation… without deviating too much from the intended
-     * color" describes. `tintToneLow`/`tintToneHigh` are the backdrop luminances
-     * the two ends are reached at, crossed with a smoothstep for the same reason
-     * `lensSpanMin`/`lensSpanMax` are.
+     * The tinted material is an OPAQUE, hue-preserving shade of the seed: the seed
+     * times a scalar, and the scalar is linear in the luminance the untinted
+     * material shows at the same pixel — `mix(tintShadeDark, tintShadeLight, u)`,
+     * clamped so a shade is never brighter than the seed. Over black content the
+     * reference shows about half the seed's light; over white it shows the seed
+     * itself; over a checkerboard it shows both, cell by cell, with the seed's
+     * chromaticity intact to three decimals at every pitch measured. That layer
+     * composites over the material at the AUTHOR's opacity (the colour's alpha) in
+     * the encoded space — the half-strength cell is the 0.501 encoded-space mix
+     * of its untinted and full-tinted twins, per channel — so the material's own
+     * alpha is not what a tinted surface shows.
      *
-     * **Advisory and calibration-delegated**, like every other number in this
-     * profile: they are chosen so a tinted surface reads as coloured glass rather
-     * than as paint, and the tinted-capture extension fits them. Nothing here is
-     * measured yet, and no claim rests on these values.
+     * `tintShadeStrength` is the law's provenance gate: 1 where the constants were
+     * measured (the light scheme), 0 where they were not — the dark scheme
+     * renders the pure seed over every backdrop it was measured on, which is
+     * consistent with "a shade relative to the material's own body level" but is
+     * not yet separable from "no shading in the dark scheme". The collapse (W7)
+     * folds the shade out the same way, because a collapsed material IS a dark
+     * body and the reference renders the pure seed there too.
+     *
+     * MEASURED, both scales, twelve light-standard cells across three pitches:
+     * fitted on the five probe cells only (17 700 px, RMS 0.0035) and refereed by
+     * every canonical tinted row. Mirrored by `@vitreajs/vitrea-web`'s
+     * `TINT_SHADE`, pinned in both directions by
+     * `packages/calibration/test/tier-coherence.test.ts`.
      */
-    readonly tintToneFloor: number;
-    readonly tintToneCeilMix: number;
-    readonly tintToneLow: number;
-    readonly tintToneHigh: number;
+    readonly tintShadeDark: number;
+    readonly tintShadeLight: number;
+    readonly tintShadeStrength: number;
     /**
      * **Backdrop tone adaptation (W7)** — the axis Apple's material has and this
      * one did not: over a dark enough backdrop the material stops being a lighter
@@ -1918,6 +2352,58 @@ interface MaterialProfile {
     readonly backdropToneLow: number;
     readonly backdropToneHigh: number;
     readonly backdropToneSizeBias: number;
+    /**
+     * **The backdrop tone response (W9)** — the law that owns the interior MEAN,
+     * where the four constants above own texture collapse and nothing else.
+     *
+     * The W9 probe falsified the mix-toward-backdrop form outright (claims
+     * §5.33): six cells need mix strengths outside [0, 1], because the
+     * reference adapts toward the material's own light/dark appearance, which
+     * coincides with the backdrop's tone only over `dark-solid` — the one
+     * background the mix was fitted on. What the probe measured instead is a
+     * LAW: at equal encoded-space backdrop mean the reference's settled
+     * interior is the same number regardless of the backdrop's structure
+     * (checker vs text rows, 0.81 both at input 0.69), so the interior level is
+     * a function `R(encodedMean, thickness)` and these constants are that
+     * function's anchors.
+     *
+     * `backdropToneAnchorX` is the three solid anchors' encoded-space means —
+     * measured backdrop luminances, not tuned. `backdropToneResponseThin` and
+     * `...Thick` are the reference's settled interior levels at those anchors
+     * for a thin surface (`sizeThickness` 0, the 32 px rrect) and a thick one
+     * (saturated, the 96 px+ rrects pooled — their residual spread ±0.012 is
+     * the accepted cost of `sizeSpanMax` saturation, claims §5.33). Between
+     * the rows: smoothstep in thickness; between the anchors: monotone
+     * (Fritsch–Carlson) interpolation in the ENCODED input, the space the
+     * probe validated to RMS 0.034 with zero fitting.
+     *
+     * Below the dark anchor the surface has no data (the probe's grid floor
+     * is `dark-solid`), and the one validation cell down there —
+     * `impulse__rrect-md`, backdrop 0.0039, reference 0.4358 — reads DARKER
+     * than the dark anchor's thick row, so clamping would regress it. The
+     * solve's authority fades to zero from the dark anchor downward
+     * (smoothstep over the anchor's own lower half, no new constant); the
+     * extreme-dark region stays with the collapse constants that were fitted
+     * on it.
+     */
+    readonly backdropToneAnchorX: readonly [number, number, number];
+    readonly backdropToneResponseThin: readonly [number, number, number];
+    readonly backdropToneResponseThick: readonly [number, number, number];
+    /**
+     * How much authority the response law has in THIS profile, 0…1 (W9).
+     *
+     * The anchors above are measurements of the LIGHT reference's settled
+     * appearance. The dark scheme's material settles at its own levels over the
+     * same backdrops (0.809 light against 0.055 dark over one checkerboard,
+     * §5.8), so a dark profile running the light response surface brightens the
+     * dark material toward the wrong scheme's appearance — measured on the
+     * canonical dark bed as ΔE p95 0.08 → 0.58 before this constant existed.
+     * The dark profiles set it to 0: the collapse (whose target is the
+     * backdrop, not a scheme's appearance) still runs there, and a dark
+     * response surface is follow-up work that needs the dark reference probed,
+     * not an assumption.
+     */
+    readonly backdropToneResponseStrength: number;
     /** The outer shadow (W8) — see `MaterialOuterShadow`. */
     readonly outerShadow: MaterialOuterShadow;
     /**
@@ -1950,22 +2436,44 @@ interface MaterialProfilePatch {
     readonly sizeSpanMax?: number;
     readonly lensSizeGainMax?: number;
     readonly sizeScatterGainMax?: number;
+    readonly sizeScatterFloor?: number;
+    readonly sizeScatterSpanMax?: number;
+    readonly sizeScatterRampStartThin1x?: number;
+    readonly sizeScatterRampStartThick1x?: number;
+    readonly sizeScatterRampStartFar1x?: number;
+    readonly sizeScatterRampStartThin2x?: number;
+    readonly sizeScatterRampStartThick2x?: number;
+    readonly sizeScatterRampStartFar2x?: number;
+    readonly sizeScatterRampReach1xPx?: number;
+    readonly sizeScatterRampReach2xPx?: number;
     readonly sizeOcclusionGain?: number;
     readonly sizeShadowGainMax?: number;
-    readonly lensBodyLodPerPx?: number;
-    readonly lensRimLodBias?: number;
+    readonly lensRefractionGain?: number;
+    readonly lensHeightPerSpan?: number;
+    readonly lensHeightMax?: number;
+    readonly lensAmountPerSpan?: number;
+    readonly lensAmountMax?: number;
+    readonly lensThicknessReference?: number;
+    readonly lensExtentGain?: number;
+    readonly lensProfileExponent?: number;
+    readonly lensOvalization?: number;
+    readonly lensOvalizationSpanMin?: number;
+    readonly lensOvalizationSpanMax?: number;
     readonly reducedTransparencyFrost?: number;
     readonly increasedOcclusionLift?: number;
     readonly strongBorderRim?: Readonly<Partial<MaterialRim>>;
     readonly reducedTintAdaptation?: number;
-    readonly tintToneFloor?: number;
-    readonly tintToneCeilMix?: number;
-    readonly tintToneLow?: number;
-    readonly tintToneHigh?: number;
+    readonly tintShadeDark?: number;
+    readonly tintShadeLight?: number;
+    readonly tintShadeStrength?: number;
     readonly backdropToneMax?: number;
     readonly backdropToneLow?: number;
     readonly backdropToneHigh?: number;
     readonly backdropToneSizeBias?: number;
+    readonly backdropToneAnchorX?: readonly [number, number, number];
+    readonly backdropToneResponseThin?: readonly [number, number, number];
+    readonly backdropToneResponseThick?: readonly [number, number, number];
+    readonly backdropToneResponseStrength?: number;
     readonly outerShadow?: Readonly<Partial<MaterialOuterShadow>>;
     readonly lightDirection?: readonly [number, number];
     readonly sweepBandRadians?: number;
@@ -2189,137 +2697,6 @@ interface VideoProviderOptions {
     readonly generation?: number;
 }
 
-/**
- * Device ownership, loss teardown, and rebuild (§GPU device ownership).
- *
- * `platform-web` owns the *browser* half of the story — is there an adapter, get
- * a device, notice when it goes away. This module owns the *resource* half: what
- * has to be thrown away when a device dies, when it is safe to build again, and
- * what core's capability inputs should read while that is in flight.
- *
- * ## The two ownership modes, and why they are not symmetric
- *
- * - **vitrea-owned** — this module can re-request a device by itself, so loss is
- *   a transient it recovers from: tear down, re-request, re-attach, rebuild.
- *   Every backdrop source is re-imported on the next frame because loss marks
- *   them all dirty, which routes recovery through the same
- *   one-rebuild-per-dirty-source-per-frame path a content change takes rather
- *   than through a special case.
- * - **app-owned** — the app owns the resources that would have to be
- *   re-registered, so this module reports the loss, raises
- *   `replacementPending`, and **waits**. Groups stay demoted until
- *   `replaceDevice` arrives and the re-registration handshake completes. Inventing
- *   a device the app did not give us would break the one guarantee app-ownership
- *   exists for: that every texture the renderer samples came from the app's own
- *   device, because WebGPU has no cross-device sharing.
- *
- * `info.reason === "destroyed"` is our own teardown and is not recovered from —
- * re-requesting there would resurrect a renderer the host just destroyed.
- *
- * ## Generations
- *
- * Every attach bumps a generation counter, and every GPU object this package
- * holds is tagged with the generation it was made under. A resource from a lost
- * device is unusable forever, and the failure mode is silent — bindings simply
- * produce nothing — so "is this from the current device" has to be a cheap
- * integer comparison somewhere. It is here.
- */
-/**
- * Structurally identical to `vitrea`'s `WebGPUAvailability` (X2's K1
- * amendment, Decision Log #21c). Declared here rather than imported because this
- * package sits *below* core in the dependency graph — core reaches the renderer
- * through a dynamic import, so an import back would close a cycle. A test pins
- * the two unions to the same members.
- */
-type WebGPUAvailability = "not-requested" | "unavailable" | "available";
-type DeviceOwnership = "vitrea" | "app";
-interface RendererDeviceStatus {
-    /** Feeds core's `PlatformProbe.webgpu` unchanged. */
-    readonly webgpu: WebGPUAvailability;
-    readonly deviceHealth: "ok" | "lost";
-    readonly ownership: DeviceOwnership;
-    readonly device: GPUDevice | undefined;
-    /** Bumped on every attach. Tags every resource built under it. */
-    readonly generation: number;
-    /** True while an app-owned device is lost and no replacement has arrived. */
-    readonly replacementPending: boolean;
-    /** Why there is no device, when there is a reason worth reporting. */
-    readonly unavailableReason?: "no-adapter" | "device-request-failed" | "lost";
-}
-/** The capability facts a host folds into core's `PlatformProbe`. */
-interface DeviceCapabilityInput {
-    readonly webgpu: WebGPUAvailability;
-    readonly deviceHealth: "ok" | "lost";
-}
-
-/**
- * The governor's knobs.
- *
- * §Performance envelope: "The governor degrades **within** a tier first
- * (refraction resolution, adaptation cadence, edge analysis) and switches tiers
- * only with long hysteresis and cooldown." Decision Log #19 adds that intra-tier
- * degradation is **not a state change** — a group under `degrade-in-tier`
- * pressure keeps `activeRenderer: "webgpu"` and its whole resolved state.
- *
- * So the split is: **the policy lives in core, the knobs live here.** This module
- * exposes what can be turned and publishes a suggested ladder as *data*; it never
- * decides to turn anything, never reads a clock, and never applies hysteresis.
- * A governor that lived in the renderer would be a governor that could not see
- * the scene it is governing.
- *
- * ## The three knobs, weakest cost first
- *
- * 1. **`fieldFamily`** — `rsupn` → `rsup`. S2 priced this at 29% of the field's
- *    cost for a bound that degrades from 0.170 px / 2.91° to 0.574 px / 4.26°.
- *    It is the *first* step because it is one uniform and one pipeline: no
- *    resolution change, so nothing resamples and nothing shimmers as it engages.
- *    **Conditional on the f32 cross-check** (Decision Log #20) — and the check
- *    has now been run, so the condition is met. See `FAMILY_C_CROSS_CHECK`.
- * 2. **`refractionResolutionScale`** — the group's **field** targets are
- *    rasterised at a fraction of device resolution, and the optics and highlight
- *    passes filter them instead of indexing them (`passes.ts`, and the
- *    `fieldUpsampled` flag both shaders branch on). Quadratic saving on the pass
- *    that evaluates the pseudo-SDF union per pixel per member, and the most
- *    visible step, so it comes second.
- *
- *    What it does **not** yet do is shrink the optics and highlight passes
- *    themselves: those still render at full device resolution into the plane
- *    canvases, because rendering them smaller means an offscreen target and a
- *    resolve pass rather than a change of extent. So rungs 2 and 3 deliver the
- *    field's quadratic saving and the cadence saving, not the full quadratic
- *    saving on both heavy passes. Recorded here rather than implied, because a
- *    ladder whose rungs are priced for savings they do not deliver is a ladder
- *    core's policy will walk too far down.
- * 3. **`adaptationCadenceHz`** — how often analysis is reduced and read back.
- *    Cheapest of the three in visual terms because the values it feeds are
- *    already low-passed over hundreds of milliseconds; dropping the cadence
- *    mostly changes how quickly a scroll's new backdrop is noticed.
- */
-type FieldFamily = "rsupn" | "rsup";
-interface GovernorKnobs {
-    /** Which pseudo-SDF family the field pass compiles. */
-    readonly fieldFamily: FieldFamily;
-    /**
-     * Device-resolution fraction the group's field targets are rasterised at,
-     * 0 < s <= 1. The optics and highlight passes upsample what they read. See the
-     * module note for what this does and does not save.
-     */
-    readonly refractionResolutionScale: number;
-    /** Analysis reduction + readback rate. 0 disables adaptation entirely. */
-    readonly adaptationCadenceHz: number;
-}
-interface Governor {
-    readonly knobs: GovernorKnobs;
-    /** True when `fieldFamily: "rsup"` is permitted to engage. */
-    readonly familyCVerified: boolean;
-    set(patch: Partial<GovernorKnobs>): GovernorKnobs;
-    /** Move to a rung of the suggested ladder. Out-of-range clamps to the ends. */
-    setLevel(level: number): GovernorKnobs;
-    reset(): GovernorKnobs;
-    /** Record that the cross-check passed, unlocking family C. */
-    recordFamilyCVerified(): void;
-}
-
 /**
  * What the renderer consumes each frame, and why it is declared here rather than
  * imported from `vitrea`.
@@ -2351,6 +2728,13 @@ interface Governor {
  * none in core.
  */
 
+/** Viewport-space rectangle in CSS px. Matches core's `Rect`. */
+interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
 /** Motion-driver outputs for one surface. Every one is a value, never a time. */
 interface SurfaceChannels {
     /** `pressCompression`, 0..1. Scaled by motion's `pressCompressionScale`. */
@@ -2440,6 +2824,45 @@ interface GroupRenderInput {
      * back to a level nobody measured.
      */
     readonly backdropTone?: Rgb;
+    /**
+     * The backdrop's ENCODED-space tone level (W9, claims §5.31–§5.34): the mean
+     * taken in sRGB-encoded space, decoded once — the input the reference's tone
+     * response tracks, feeding the collapse band's argument and the response
+     * curve. Distinct from `backdropTone` on any structured backdrop: the
+     * COLOUR is the physical linear mean (what the collapse converges onto —
+     * on the impulse grid the two differ 2.6×, and converging onto the encoded
+     * reading was a measured ΔE p95 0.03 → 0.12 regression), while the LEVEL is
+     * the encoded reading. Absent falls back to `backdropTone`'s own luminance.
+     */
+    readonly backdropToneLevel?: number;
+    /**
+     * The backdrop's LINEAR-space mean luminance, beside `backdropToneLevel`'s
+     * encoded-space reading (W9, claims §5.31). The per-pixel tint-tone input
+     * samples a chain that averages linearly, so the optics pass multiplies it by
+     * `backdropToneLevel / backdropToneLinearLuminance` — locality is
+     * preserved and the input's spatial mean matches the model exactly. Absent
+     * (or equal to the tone's level) collapses the ratio to 1.
+     */
+    readonly backdropToneLinearLuminance?: number;
+    /**
+     * The material's tint and alpha for a group that samples NOTHING (W11a) — a
+     * `css-backdrop` group whose blurred backdrop is a DOM proxy beneath the
+     * canvas, or a `none` group over the page itself. Such a group's body is
+     * not composited in the shader: the optics pass writes the material as a
+     * premultiplied layer and the browser composites it over the DOM, in
+     * encoded sRGB. A linear-light alpha written into that composite lands the
+     * surface darker than the same material sampled on the GPU — the gap
+     * `cssTintAlpha` closes for the CSS tier, at a declared reference level —
+     * so the host, which owns that mapping, resolves the pair once and hands
+     * the same numbers to both tiers. Linear light; the renderer folds the
+     * accessibility policy over it exactly as over the profile's own. Ignored
+     * wherever the group samples a backdrop; absent, the profile's pair is
+     * written as it is (the golden harness, which has no host).
+     */
+    readonly unsampledMaterial?: {
+        readonly tint: Rgb;
+        readonly tintAlpha: number;
+    };
     readonly variant?: MaterialVariant;
     /** Overrides the calibration-delegated union defaults. */
     readonly union?: GroupUnionParams;
@@ -2488,6 +2911,173 @@ interface FrameParticipantView {
     readonly render?: (context: FrameContextView) => void;
 }
 
+/**
+ * Where a backdrop texture sits on the plane, and what that makes of a CSS px.
+ *
+ * The optics pass samples the backdrop through one uv transform on
+ * viewport-normalised coordinates — `uv = viewport01 · scale + offset` — and
+ * the pyramid converts the material's CSS-px σ into source texels once, at build.
+ * Both numbers are functions of the same thing: the rectangle of the viewport the
+ * texture's pixels actually occupy. This module is the one place that rectangle
+ * turns into either.
+ *
+ * ## Placed
+ *
+ * A texture handed over from a DOM element — an `<img>`, a `<canvas>`, a
+ * `<video>` — has a box the host measures every read phase, in CSS px relative
+ * to the viewport, and that box IS the placement: a 320 px raster in the corner
+ * of a 1440 px page maps the 320 px, not the page. The source's own extent is
+ * still what the pyramid is built from; the placement only says where on the
+ * plane its texels land, so one texel is `placement.width / sourceWidth` CSS px.
+ *
+ * Outside the placement the sampler clamps to the edge. A surface hanging past
+ * the texture's box reads the nearest edge texel rather than nothing; the
+ * unsampled layer (W11a) is not applied to partial overlap in this cut.
+ *
+ * ## Cover
+ *
+ * A source with no placement — an `ImageBitmap`, an `OffscreenCanvas`, an
+ * element not in the document, or a renderer driven without a host at all —
+ * keeps the original rule: the backdrop fills the viewport and the overflow is
+ * cropped symmetrically. Every golden and every calibration capture was taken
+ * with the texture the size of the stage, where the two rules coincide exactly;
+ * the demo's reference panel is where they came apart (claims §5.47).
+ */
+
+/** A backdrop source's box on the plane, in CSS px relative to the viewport. */
+type BackdropPlacement = Rect;
+
+/**
+ * Device ownership, loss teardown, and rebuild (§GPU device ownership).
+ *
+ * `platform-web` owns the *browser* half of the story — is there an adapter, get
+ * a device, notice when it goes away. This module owns the *resource* half: what
+ * has to be thrown away when a device dies, when it is safe to build again, and
+ * what core's capability inputs should read while that is in flight.
+ *
+ * ## The two ownership modes, and why they are not symmetric
+ *
+ * - **vitrea-owned** — this module can re-request a device by itself, so loss is
+ *   a transient it recovers from: tear down, re-request, re-attach, rebuild.
+ *   Every backdrop source is re-imported on the next frame because loss marks
+ *   them all dirty, which routes recovery through the same
+ *   one-rebuild-per-dirty-source-per-frame path a content change takes rather
+ *   than through a special case.
+ * - **app-owned** — the app owns the resources that would have to be
+ *   re-registered, so this module reports the loss, raises
+ *   `replacementPending`, and **waits**. Groups stay demoted until
+ *   `replaceDevice` arrives and the re-registration handshake completes. Inventing
+ *   a device the app did not give us would break the one guarantee app-ownership
+ *   exists for: that every texture the renderer samples came from the app's own
+ *   device, because WebGPU has no cross-device sharing.
+ *
+ * `info.reason === "destroyed"` is our own teardown and is not recovered from —
+ * re-requesting there would resurrect a renderer the host just destroyed.
+ *
+ * ## Generations
+ *
+ * Every attach bumps a generation counter, and every GPU object this package
+ * holds is tagged with the generation it was made under. A resource from a lost
+ * device is unusable forever, and the failure mode is silent — bindings simply
+ * produce nothing — so "is this from the current device" has to be a cheap
+ * integer comparison somewhere. It is here.
+ */
+/**
+ * Structurally identical to `vitrea`'s `WebGPUAvailability` (X2's K1
+ * amendment, Decision Log #21c). Declared here rather than imported because this
+ * package sits *below* core in the dependency graph — core reaches the renderer
+ * through a dynamic import, so an import back would close a cycle. A test pins
+ * the two unions to the same members.
+ */
+type WebGPUAvailability = "not-requested" | "unavailable" | "available";
+type DeviceOwnership = "vitrea" | "app";
+interface RendererDeviceStatus {
+    /** Feeds core's `PlatformProbe.webgpu` unchanged. */
+    readonly webgpu: WebGPUAvailability;
+    readonly deviceHealth: "ok" | "lost";
+    readonly ownership: DeviceOwnership;
+    readonly device: GPUDevice | undefined;
+    /** Bumped on every attach. Tags every resource built under it. */
+    readonly generation: number;
+    /** True while an app-owned device is lost and no replacement has arrived. */
+    readonly replacementPending: boolean;
+    /** Why there is no device, when there is a reason worth reporting. */
+    readonly unavailableReason?: "no-adapter" | "device-request-failed" | "lost";
+}
+/** The capability facts a host folds into core's `PlatformProbe`. */
+interface DeviceCapabilityInput {
+    readonly webgpu: WebGPUAvailability;
+    readonly deviceHealth: "ok" | "lost";
+}
+
+/**
+ * The governor's knobs.
+ *
+ * §Performance envelope: "The governor degrades **within** a tier first
+ * (refraction resolution, adaptation cadence, edge analysis) and switches tiers
+ * only with long hysteresis and cooldown." Decision Log #19 adds that intra-tier
+ * degradation is **not a state change** — a group under `degrade-in-tier`
+ * pressure keeps `activeRenderer: "webgpu"` and its whole resolved state.
+ *
+ * So the split is: **the policy lives in core, the knobs live here.** This module
+ * exposes what can be turned and publishes a suggested ladder as *data*; it never
+ * decides to turn anything, never reads a clock, and never applies hysteresis.
+ * A governor that lived in the renderer would be a governor that could not see
+ * the scene it is governing.
+ *
+ * ## The three knobs, weakest cost first
+ *
+ * 1. **`fieldFamily`** — `rsupn` → `rsup`. S2 priced this at 29% of the field's
+ *    cost for a bound that degrades from 0.170 px / 2.91° to 0.574 px / 4.26°.
+ *    It is the *first* step because it is one uniform and one pipeline: no
+ *    resolution change, so nothing resamples and nothing shimmers as it engages.
+ *    **Conditional on the f32 cross-check** (Decision Log #20) — and the check
+ *    has now been run, so the condition is met. See `FAMILY_C_CROSS_CHECK`.
+ * 2. **`refractionResolutionScale`** — the group's **field** targets are
+ *    rasterised at a fraction of device resolution, and the optics and highlight
+ *    passes filter them instead of indexing them (`passes.ts`, and the
+ *    `fieldUpsampled` flag both shaders branch on). Quadratic saving on the pass
+ *    that evaluates the pseudo-SDF union per pixel per member, and the most
+ *    visible step, so it comes second.
+ *
+ *    What it does **not** yet do is shrink the optics and highlight passes
+ *    themselves: those still render at full device resolution into the plane
+ *    canvases, because rendering them smaller means an offscreen target and a
+ *    resolve pass rather than a change of extent. So rungs 2 and 3 deliver the
+ *    field's quadratic saving and the cadence saving, not the full quadratic
+ *    saving on both heavy passes. Recorded here rather than implied, because a
+ *    ladder whose rungs are priced for savings they do not deliver is a ladder
+ *    core's policy will walk too far down.
+ * 3. **`adaptationCadenceHz`** — how often analysis is reduced and read back.
+ *    Cheapest of the three in visual terms because the values it feeds are
+ *    already low-passed over hundreds of milliseconds; dropping the cadence
+ *    mostly changes how quickly a scroll's new backdrop is noticed.
+ */
+type FieldFamily = "rsupn" | "rsup";
+interface GovernorKnobs {
+    /** Which pseudo-SDF family the field pass compiles. */
+    readonly fieldFamily: FieldFamily;
+    /**
+     * Device-resolution fraction the group's field targets are rasterised at,
+     * 0 < s <= 1. The optics and highlight passes upsample what they read. See the
+     * module note for what this does and does not save.
+     */
+    readonly refractionResolutionScale: number;
+    /** Analysis reduction + readback rate. 0 disables adaptation entirely. */
+    readonly adaptationCadenceHz: number;
+}
+interface Governor {
+    readonly knobs: GovernorKnobs;
+    /** True when `fieldFamily: "rsup"` is permitted to engage. */
+    readonly familyCVerified: boolean;
+    set(patch: Partial<GovernorKnobs>): GovernorKnobs;
+    /** Move to a rung of the suggested ladder. Out-of-range clamps to the ends. */
+    setLevel(level: number): GovernorKnobs;
+    reset(): GovernorKnobs;
+    /** Record that the cross-check passed, unlocking family C. */
+    recordFamilyCVerified(): void;
+}
+
 /**
  * Pass-by-pass timing, for the benchmark §Performance envelope pins the ~2 ms
  * hypothesis to.
@@ -2654,6 +3244,27 @@ interface PyramidResources {
      * from without knowing where the body already sits.
      */
     readonly bodySigmaTexels: number;
+    /**
+     * Source texels per CSS px the build converted `bodySigmaCss` with — the placed
+     * density where the source had a placement, the cover ratio where it did not
+     * (`backdrop-fit.ts`) — and the source extent it was computed from. Recorded so
+     * a later request can tell whether the body it would produce differs from the
+     * one on the chain: a static image never re-dirties, so a placement whose SIZE
+     * moved is the only signal that the σ in texels has gone stale.
+     */
+    readonly texelsPerCss: number;
+    readonly sourceWidth: number;
+    readonly sourceHeight: number;
+    /**
+     * The CSS-px σ the build converted with (W13 G1, review finding). The density
+     * alone does not determine the body: since the widths became device-pixel
+     * quantities (W12 G3, claims §5.56) the material's σ in CSS px is
+     * `blurSigma / dpr`, so a window dragged from a 1x display to a 2x one asks
+     * for a different body from the same source at the same density. A static
+     * image never re-dirties, so this recorded σ is the only signal that the
+     * chain's body and `bodyChainLod` belong to the previous scale.
+     */
+    readonly bodySigmaCss: number;
 }
 interface PyramidInstrumentation {
     /** Successful rebuilds since the store was created. */
@@ -2684,6 +3295,11 @@ interface PyramidBuildRequest {
      */
     readonly bodySigmaCss: number;
     readonly viewportCss: readonly [number, number];
+    /**
+     * Where the source sits on the plane, in CSS px relative to the viewport, if
+     * the host measured one. Absent, the source is cover-fit to the viewport.
+     */
+    readonly placement?: BackdropPlacement;
 }
 type PyramidBuildOutcome = {
     readonly status: "built";
@@ -2868,6 +3484,16 @@ interface GlassRenderer {
     registerBackdrop(provider: BackdropProvider): void;
     unregisterBackdrop(sourceId: string): void;
     backdrop(sourceId: string): BackdropProvider | undefined;
+    /**
+     * Where a source's pixels sit on the plane, in CSS px relative to the viewport
+     * (`backdrop-fit.ts`). Set every read phase by a host that measured the source
+     * element's box; `undefined` (or never set) is the cover fit, the rule every
+     * golden and calibration capture was taken under. Accepted before the provider
+     * is registered and kept across device generations; cleared by
+     * `unregisterBackdrop`.
+     */
+    setBackdropPlacement(sourceId: string, placement: BackdropPlacement | undefined): void;
+    backdropPlacement(sourceId: string): BackdropPlacement | undefined;
     setViewport(viewport: ViewportState): void;
     readonly viewport: ViewportState;
     setGroup(input: GroupRenderInput): void;
@@ -2963,4 +3589,4 @@ declare const VITREA_CONTRACTS: {
 declare const RENDERER_TIERS: readonly ["webgpu", "css"];
 type RendererTier = (typeof RENDERER_TIERS)[number];
 
-export { ACCESSIBILITY_BEHAVIOR_TABLE, ACCESSIBILITY_FLAGS, ACCESSIBILITY_PRECEDENCE, type AccessibilityConsequences, type AccessibilityFlag, type AccessibilityOverride, type AccessibilityOverrides, type ActiveRenderer, type AnalysisQuality, type BackdropEstimatorProvider, type BackdropHint, type BackdropHintRequest, type BackdropProvider, type BackdropRebuildRequest, type BackdropResolutionPolicy, type BackdropSourceDescriptor, type BackdropSourceRecord, type BackdropTone, type CapabilityInputs, type ConcentricParent, type ConfiguredSource, type CopyProviderOptions, type CornerProfile, type CornerRadii, type CornerReference, DEFAULT_BACKDROP_RESOLUTION, DEFAULT_CLEAR_DIMMING, DEFAULT_GROUP_SAMPLING, DEMOTION_REASONS, DEMOTION_RECOVERY, DIAGNOSTIC_CODES, type DemotionReason, type DescriptorPatch, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type DiagnosticSink, type DiagnosticsChannel, type DiagnosticsChannelOptions, type DimmingPolicy, type DomBackdropSource, FOREGROUND_MODES, FRAME_PHASES, type ForegroundAdaptation, type ForegroundMode, type ForegroundResolutionOptions, type FrameContext, type FrameInfo, type FrameParticipant, type FramePhase, type FrameReport, type FrameScheduler, type FrameSchedulerOptions, GLASS_PLANES, GOVERNOR_PRESSURES, type GlassGroupDescriptor, type GlassGroupRecord, type GlassGroupState, type GlassNodeDescriptor, type GlassNodeRecord, type GlassPlane, type GlassRenderer, type GlassScene, GlassSceneError, type GlassSceneErrorCode, type GlassSceneOptions, type GlassTint, type GovernorPressure, type GroupHealth, type GroupSamplingGeometry, type GroupStateChange, HINT_AVAILABILITIES, type HintAvailability, type InteractionState, MATERIAL_VARIANTS$1 as MATERIAL_VARIANTS, type MaterialProfile$1 as MaterialProfile, type MaterialRequest, type MaterialVariant$1 as MaterialVariant, type MotionChannel, type MotionDriverKind, NOMINAL_ACCESSIBILITY_POLICY, OVERRIDABLE_ACCESSIBILITY_FLAGS, type OverridableAccessibilityFlag, type PlaneOverlap, type PlatformProbe, type ProxyOverlap, RENDERER_TIERS, type RecoveryContract, type RecoveryTrigger, type Rect, type RefractionQuality, type RendererTier, type ResolvedAccessibilityPolicy, type ResolvedBackdropHint, type ResolvedForegroundAdaptation, type ResolvedGroup, type ResolvedMaterial, type ResolvedMaterialPolicy, type ResolvedMotionPolicy, type ResolvedNode, SAMPLED_ASYNC_DEFAULTS, SAMPLED_ASYNC_RATE_LIMITS, type SamplingBackend, type SceneResolution, type ShapeChannels, type ShapeFamily, type SourceProbe, type StateChange, type SystemAccessibilityPreferences, type TextureBackdropSource, type TintColor, type TintMixingCheck, VITREA_CONTRACTS, type VariantMixingCheck, type Vec2, type VideoProviderOptions, WEBGPU_AVAILABILITIES, type WebGPUAvailability$1 as WebGPUAvailability, type WebGPURendererModule, type ZSlot, checkTintMixing, checkVariantMixing, classifyStateChange, clipRect, compareZSlot, createDiagnosticsChannel, createFrameScheduler, createGlassScene, defaultForegroundAdaptation, glassTint, inflateRect, isHealthy, loadWebGPURenderer, loadWebGPURendererModule, rectsOverlap, resolveAccessibilityPolicy, resolveBackdropHint, resolveForegroundAdaptation, resolveGlassGroupState, resolveMaterial, unionRect };
+export { ACCESSIBILITY_BEHAVIOR_TABLE, ACCESSIBILITY_FLAGS, ACCESSIBILITY_PRECEDENCE, type AccessibilityConsequences, type AccessibilityFlag, type AccessibilityOverride, type AccessibilityOverrides, type ActiveRenderer, type AnalysisQuality, type BackdropEstimatorProvider, type BackdropHint, type BackdropHintRequest, type BackdropProvider, type BackdropRebuildRequest, type BackdropResolutionPolicy, type BackdropSourceDescriptor, type BackdropSourceRecord, type BackdropTone, type CapabilityInputs, type ConcentricParent, type ConfiguredSource, type CopyProviderOptions, type CornerProfile, type CornerRadii, type CornerReference, DEFAULT_BACKDROP_RESOLUTION, DEFAULT_CLEAR_DIMMING, DEFAULT_GROUP_SAMPLING, DEMOTION_REASONS, DEMOTION_RECOVERY, DIAGNOSTIC_CODES, type DemotionReason, type DescriptorPatch, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type DiagnosticSink, type DiagnosticsChannel, type DiagnosticsChannelOptions, type DimmingPolicy, type DomBackdropSource, FOREGROUND_MODES, FRAME_PHASES, type ForegroundAdaptation, type ForegroundMode, type ForegroundResolutionOptions, type FrameContext, type FrameInfo, type FrameParticipant, type FramePhase, type FrameReport, type FrameScheduler, type FrameSchedulerOptions, GLASS_PLANES, GOVERNOR_PRESSURES, type GlassGroupDescriptor, type GlassGroupRecord, type GlassGroupState, type GlassNodeDescriptor, type GlassNodeRecord, type GlassPlane, type GlassRenderer, type GlassScene, GlassSceneError, type GlassSceneErrorCode, type GlassSceneOptions, type GlassTint, type GovernorPressure, type GroupHealth, type GroupSamplingGeometry, type GroupStateChange, HINT_AVAILABILITIES, type HintAvailability, type InteractionState, MATERIAL_VARIANTS$1 as MATERIAL_VARIANTS, type MaterialProfile$1 as MaterialProfile, type MaterialRequest, type MaterialVariant$1 as MaterialVariant, type MotionChannel, type MotionDriverKind, NOMINAL_ACCESSIBILITY_POLICY, OVERRIDABLE_ACCESSIBILITY_FLAGS, type OverridableAccessibilityFlag, type PlaneOverlap, type PlatformProbe, type ProxyOverlap, RENDERER_TIERS, type RecoveryContract, type RecoveryTrigger, type Rect$1 as Rect, type RefractionQuality, type RendererTier, type ResolvedAccessibilityPolicy, type ResolvedBackdropHint, type ResolvedForegroundAdaptation, type ResolvedGroup, type ResolvedMaterial, type ResolvedMaterialPolicy, type ResolvedMotionPolicy, type ResolvedNode, SAMPLED_ASYNC_DEFAULTS, SAMPLED_ASYNC_RATE_LIMITS, type SamplingBackend, type SceneResolution, type ShapeChannels, type ShapeFamily, type SourceProbe, type StateChange, type SystemAccessibilityPreferences, type TextureBackdropSource, type TintColor, type TintMixingCheck, VITREA_CONTRACTS, type VariantMixingCheck, type Vec2, type VideoProviderOptions, WEBGPU_AVAILABILITIES, type WebGPUAvailability$1 as WebGPUAvailability, type WebGPURendererModule, type ZSlot, checkTintMixing, checkVariantMixing, classifyStateChange, clipRect, compareZSlot, createDiagnosticsChannel, createFrameScheduler, createGlassScene, defaultForegroundAdaptation, glassTint, inflateRect, isHealthy, loadWebGPURenderer, loadWebGPURendererModule, rectsOverlap, resolveAccessibilityPolicy, resolveBackdropHint, resolveForegroundAdaptation, resolveGlassGroupState, resolveMaterial, unionRect };