@vitreajs/vitrea 0.1.1 → 0.3.0

package/dist/index.d.ts

@@ -180,13 +180,40 @@ type InteractionState = (typeof INTERACTION_STATES)[number];
  * source — are *not* diagnostics. Those throw `GlassSceneError`, because
  * continuing past them would leave a half-built scene. Diagnostics carry the
  * recoverable, per-frame, policy-level findings instead.
+ *
+ * ## One channel, several code spaces
+ *
+ * The channel is generic over its code union and core's own union is only its
+ * default instantiation. That is what lets the browser layer — which detects
+ * things core cannot name, like a host placed outside its plane — have a code
+ * space of its own without a second copy of the machinery, and it is why the
+ * dedupe rule, the retention rule and the key separator have exactly one
+ * definition in the workspace (Decision Log #21(b), #23(c)).
+ *
+ * Two properties are load-bearing and deliberately *not* generalised:
+ *
+ *  - **A diagnostic carries no origin tag.** Which code space a finding came
+ *    from is the channel's business, added on the way out to a host's sink, not
+ *    a field every emitter has to write. `platform-web`'s `layer-model.ts` is
+ *    the proof: it is a pure function that takes a bare `report` callback, and
+ *    an origin tag in the payload would have rewritten every emitter in it.
+ *  - **`report` stays assignable to `(d) => void`.** Checkers take the
+ *    capability to report, never the channel, so a module that emits findings
+ *    knows nothing about retention or dedupe.
  */
 type DiagnosticSeverity = "warning" | "error";
 /** Everything core can report. Owned here so a host can switch exhaustively. */
-declare const DIAGNOSTIC_CODES: readonly ["same-plane-overlap", "variant-mixing", "merge-distance-below-padding", "group-proxy-overlap", "clear-variant-needs-dimming", "foreground-mode-illegal", "foreground-rate-clamped", "backdrop-hint-out-of-range", "backdrop-hint-redundant-estimator", "reduced-transparency-undetectable", "frame-phase-violation"];
+declare const DIAGNOSTIC_CODES: readonly ["same-plane-overlap", "variant-mixing", "tint-mixing", "merge-distance-below-padding", "group-proxy-overlap", "clear-variant-needs-dimming", "foreground-mode-illegal", "foreground-rate-clamped", "backdrop-hint-out-of-range", "backdrop-hint-redundant-estimator", "reduced-transparency-undetectable", "frame-phase-violation"];
 type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[number];
-interface Diagnostic {
-    readonly code: DiagnosticCode;
+/**
+ * One finding, over whichever code space the channel was opened on.
+ *
+ * `Code` defaults to core's own union, so `Diagnostic` unqualified still means
+ * exactly what it meant before the channel became generic and every existing
+ * annotation of it still reads.
+ */
+interface Diagnostic<Code extends string = DiagnosticCode> {
+    readonly code: Code;
     readonly severity: DiagnosticSeverity;
     /**
      * The ids this finding is about — group, node, or source. Together with
@@ -196,21 +223,21 @@ interface Diagnostic {
     readonly subjects: readonly string[];
     readonly message: string;
 }
-type DiagnosticSink = (diagnostic: Diagnostic) => void;
-interface DiagnosticsChannel {
-    report(diagnostic: Diagnostic): void;
+type DiagnosticSink<Code extends string = DiagnosticCode> = (diagnostic: Diagnostic<Code>) => void;
+interface DiagnosticsChannel<Code extends string = DiagnosticCode> {
+    report(diagnostic: Diagnostic<Code>): void;
     /** Findings retained since construction or the last `clear()`. */
-    readonly reported: readonly Diagnostic[];
+    readonly reported: readonly Diagnostic<Code>[];
     /** Forget what was seen, so a condition that returns is reported again. */
     clear(): void;
 }
-interface DiagnosticsChannelOptions {
+interface DiagnosticsChannelOptions<Code extends string = DiagnosticCode> {
     /** Where findings go. Omitted in tests and in hosts that only read `reported`. */
-    readonly sink?: DiagnosticSink;
+    readonly sink?: DiagnosticSink<Code>;
     /** Collapse repeats of the same code+subjects. Default true. */
     readonly dedupe?: boolean;
 }
-declare function createDiagnosticsChannel(options?: DiagnosticsChannelOptions): DiagnosticsChannel;
+declare function createDiagnosticsChannel<Code extends string = DiagnosticCode>(options?: DiagnosticsChannelOptions<Code>): DiagnosticsChannel<Code>;
 
 /**
  * Accessibility policy (§Accessibility policy, plus the Reduced Motion
@@ -415,6 +442,26 @@ declare const ACCESSIBILITY_PRECEDENCE: readonly ["reducedMotion", "reducedTrans
  */
 declare function resolveAccessibilityPolicy(system: SystemAccessibilityPreferences, overrides?: AccessibilityOverrides, diagnostics?: DiagnosticsChannel): ResolvedAccessibilityPolicy;
 
+/**
+ * The refraction ladder, weakest rung first.
+ *
+ * Two independent things cap refraction: the accessibility policy's ceiling
+ * (core's `ResolvedMaterialPolicy.refraction`, a regime — `nominal | reduced |
+ * none`) and the group's resolved capability state (X2's `RefractionQuality` —
+ * `true | approximate | none`, what the sampling backend can actually deliver).
+ * **Renderers honour the lower of the two** (Decision Log #19), which is only a
+ * meaningful sentence against an ordering — this one.
+ *
+ * Written out rather than derived from `RefractionQuality`, because that type's
+ * own declaration order is not an ordering.
+ */
+declare const REFRACTION_LADDER: readonly ["none", "approximate", "true"];
+/**
+ * X2's capability-derived refraction level (`core/src/state.ts` re-exports this
+ * name). Derived from the ladder so the rungs and the type cannot drift apart.
+ */
+type RefractionQuality = (typeof REFRACTION_LADDER)[number];
+
 /**
  * X2 — the resolved-state model (§Backdrop & analysis contracts).
  *
@@ -425,10 +472,10 @@ declare function resolveAccessibilityPolicy(system: SystemAccessibilityPreferenc
  *
  * C1 ships the shape; C4 ships the resolver.
  */
+
 type ConfiguredSource = "texture" | "dom";
 type ActiveRenderer = "webgpu" | "css";
 type SamplingBackend = "gpu-texture" | "css-backdrop" | "none";
-type RefractionQuality$1 = "true" | "approximate" | "none";
 type AnalysisQuality = "exact" | "hint" | "none";
 type GroupHealth = "ok" | "demoted";
 declare const DEMOTION_REASONS: readonly ["no-webgpu", "no-backdrop-filter", "tainted-source", "incompatible-texture", "no-texture-supplied", "device-lost", "probe-failed", "governor"];
@@ -439,7 +486,7 @@ interface GlassGroupState {
     /** What is actually drawing. */
     readonly activeRenderer: ActiveRenderer;
     readonly samplingBackend: SamplingBackend;
-    readonly refraction: RefractionQuality$1;
+    readonly refraction: RefractionQuality;
     readonly analysis: AnalysisQuality;
     readonly health: GroupHealth;
     readonly demotionReason?: DemotionReason;
@@ -797,6 +844,53 @@ interface FrameInfo {
 
 declare const MATERIAL_VARIANTS$1: readonly ["regular", "clear"];
 type MaterialVariant$1 = (typeof MATERIAL_VARIANTS$1)[number];
+/**
+ * An author's tint seed, sRGB-encoded, 0..1 per channel.
+ *
+ * Encoded rather than linear because this is the number the author wrote: a CSS
+ * colour, parsed. The conversion into the working space belongs to whichever
+ * tier is drawing, and core carries no colour maths.
+ */
+type TintColor = readonly [r: number, g: number, b: number];
+/**
+ * §Material tint — the author-facing half of Apple's `Glass.tint(_:)`.
+ *
+ * **A tint is a seed, not a fill.** Apple states the mechanism plainly:
+ * "selecting a color generates a range of tones that are **mapped to content
+ * brightness underneath** the tinted element… changing its hue, brightness and
+ * saturation depending on what's behind without deviating too much from the
+ * intended color" (WWDC25 session 219). A flat overlay of the seed is the
+ * failure Apple names in the same session — "completely opaque and breaks the
+ * visual character of Liquid Glass" — so this value is carried to the renderers
+ * as a seed and tone-mapped there, per pixel, against the backdrop the material
+ * is already sampling.
+ *
+ * Two axes, kept apart on purpose, because Apple's own vocabulary overloads the
+ * word:
+ *
+ * - **This is the colour axis.** It says what colour the material's tint layer
+ *   is. It never changes how much of that layer there is.
+ * - The **alpha axis** — how opaque the tint layer is — is the material's
+ *   calibrated `tintAlpha`, the same quantity reduced transparency lifts. That
+ *   is where the *user's* system preference lives (iOS 26.1's Clear/Tinted
+ *   toggle "increases the opacity of Liquid Glass and adds more contrast"; OS
+ *   27's slider runs the same axis continuously, "ultra clear to fully
+ *   tinted"). A future reference migration therefore lands on the occlusion
+ *   axis and cannot collide with an author's tint.
+ *
+ * `strength` is the author's own subtlety knob and comes from the seed colour's
+ * alpha — `rgba(255, 149, 0, 0.5)` is a half-strength orange, exactly as
+ * `Color.orange.opacity(0.5)` is in SwiftUI. It says how far the material's tint
+ * colour moves from its neutral (profile) tint toward the tone, and at 0 the
+ * material is byte-identical to an untinted one.
+ */
+interface GlassTint {
+    readonly color: TintColor;
+    /** How far the material's tint moves toward the tone, 0..1. */
+    readonly strength: number;
+}
+/** A tint with its channels clamped into range. `strength` defaults to fully tinted. */
+declare function glassTint(color: TintColor, strength?: number): GlassTint;
 /** The scrim laid beneath clear glass so foreground content stays legible. */
 interface DimmingPolicy {
     /** Scrim opacity, 0..1. */
@@ -810,11 +904,13 @@ interface DimmingPolicy {
  * satisfy, not to be correct.
  */
 declare const DEFAULT_CLEAR_DIMMING: DimmingPolicy;
-/** A group's material defaults. A node inherits `variant` when it declares none. */
+/** A group's material defaults. A node inherits `variant` and `tint` when it declares none. */
 interface MaterialProfile$1 {
     readonly variant: MaterialVariant$1;
     /** Required for any clear surface in the group. */
     readonly dimming?: DimmingPolicy;
+    /** Group-wide tint seed. A node overrides it, or clears it with `null`. */
+    readonly tint?: GlassTint;
 }
 interface ResolvedMaterial {
     readonly variant: MaterialVariant$1;
@@ -822,15 +918,45 @@ interface ResolvedMaterial {
     readonly adaptation: "adaptive" | "constrained";
     /** Present exactly when `variant` is `"clear"`. */
     readonly dimming?: DimmingPolicy;
+    /** Absent when the surface is untinted, or when its tint has no strength. */
+    readonly tint?: GlassTint;
 }
 interface MaterialRequest {
     readonly variant: MaterialVariant$1;
     readonly dimming?: DimmingPolicy;
+    /** The tint this surface resolved to — its own, or the group's. */
+    readonly tint?: GlassTint | null;
     /** Named in diagnostics; also the dedupe subject. */
     readonly nodeId?: string;
     readonly diagnostics?: DiagnosticsChannel;
 }
 declare function resolveMaterial(request: MaterialRequest): ResolvedMaterial;
+interface TintMixingCheck {
+    readonly groupId: string;
+    readonly members: readonly {
+        readonly nodeId: string;
+        readonly tint?: GlassTint;
+    }[];
+    readonly diagnostics?: DiagnosticsChannel;
+}
+/**
+ * Report a group whose members ask for **different** tint seeds.
+ *
+ * A group is one sampling region and one optics pass, so the GPU tier carries
+ * one seed per group and a per-pixel strength — which is exactly enough for the
+ * composition Apple's guidance describes ("apply color to the background rather
+ * than to symbols… refrain from adding color to the background of multiple
+ * controls"): one emphasised control inside a toolbar of plain ones. Two
+ * different hues in one group is outside that, and the two tiers would then
+ * disagree — the CSS tier styles each host element on its own and can honour
+ * both. So it warns and changes nothing, on the same reasoning as
+ * `checkVariantMixing`: coercing one of the two would silently discard an
+ * author's intent.
+ *
+ * Untinted members are not a mix. They are the ordinary case the mechanism is
+ * for, and their strength is simply zero.
+ */
+declare function checkTintMixing(check: TintMixingCheck): boolean;
 interface VariantMixingCheck {
     readonly groupId: string;
     readonly members: readonly {
@@ -871,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;
@@ -880,15 +1006,38 @@ 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.
+ *
+ * A surface's border box is measured unclipped — `getBoundingClientRect` reports
+ * the box wherever it is, whether or not an `overflow: scroll` ancestor is
+ * actually showing it — so the box alone says nothing about what is visible. The
+ * clip chain, measured alongside it, is what turns the box into the region the
+ * surface can paint in (Decision Log #41(k)).
+ *
+ * A fully scrolled-out surface intersects to zero extent, and every consumer in
+ * here already treats a zero-extent rect as "contributes nothing": `rectsOverlap`
+ * refuses it, and the proxy geometry skips it as unmeasured. That is deliberate
+ * — it means "scrolled out of view" needs no special case anywhere downstream.
+ *
+ * Rects only, and the approximation is stated rather than implied: a rounded
+ * clipping ancestor is carried as its bounding box, so a surface tucked into a
+ * rounded scroller's corner is treated as slightly more visible than it is. The
+ * error is bounded by the ancestor's corner radius and always errs towards
+ * reporting *more* surface, which is the safe direction for every consumer here
+ * — 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$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
@@ -1024,6 +1173,28 @@ interface GlassGroupRecord {
     readonly state?: GlassGroupState;
     /** Per-group governor override; falls back to the scene-wide pressure. */
     readonly governor?: GovernorPressure;
+    /**
+     * Per-group platform probe override; falls back to the scene-wide probe.
+     *
+     * Most of `PlatformProbe` genuinely is scene-wide — there is one device per
+     * root, and whether the engine has `backdrop-filter` is a fact about the
+     * engine. `backdropProxyConformance` is the exception, and S1 measured why:
+     * the backdrop-root audit is per group, "not per document, because different
+     * groups can sit under different ancestors". A group whose proxy chain is
+     * re-rooted must demote alone.
+     */
+    readonly platform?: PlatformProbe;
+}
+/**
+ * X8 rider 2: this surface is a level set of another surface's field, inset by a
+ * fixed distance — a segmented control's indicator inside its track, drawn as
+ * one field rather than two shapes that happen to nest.
+ */
+interface ConcentricParent {
+    /** The parent surface. Must be registered, and must share this node's group. */
+    readonly nodeId: string;
+    /** CSS px inward from the parent's contour. */
+    readonly inset: number;
 }
 interface GlassNodeDescriptor {
     readonly id: string;
@@ -1031,8 +1202,33 @@ interface GlassNodeDescriptor {
     readonly shapeFamily: ShapeFamily;
     readonly shape: ShapeChannels;
     readonly zSlot: ZSlot;
+    /**
+     * Which of geometry's two corner references this shape is fit against
+     * (Decision Log #22(a) — two separate fits, not two points on one axis).
+     * Defaults to `"apple-continuous"` at the renderer.
+     *
+     * A scene-model field since Decision Log #23(c). In v1 it was a render input
+     * the browser layer never set, so a shape authored on the Figma smoothing axis
+     * was silently resolved against the Apple fit, and a binding that wanted to
+     * refuse a cross-reference morph had to mirror geometry's private mapping to
+     * do it. The reference travels with the shape now.
+     */
+    readonly reference?: CornerReference;
+    /**
+     * X8 rider 2's parent edge, likewise a scene-model field since #23(c).
+     *
+     * The link is validated here rather than at draw time: an unknown parent, a
+     * parent in another group and a cycle are all refusals at registration, where
+     * the caller that made the mistake is still on the stack.
+     */
+    readonly concentricOf?: ConcentricParent;
     /** Inherits the group's material profile when absent. */
     readonly variant?: MaterialVariant$1;
+    /**
+     * Overrides the group's tint seed. `null` clears an inherited one, the way
+     * `Glass.tint(nil)` does; absent inherits.
+     */
+    readonly tint?: GlassTint | null;
     readonly interaction?: InteractionState;
     /** Overrides the group's adaptation for this surface. */
     readonly foreground?: ForegroundAdaptation;
@@ -1040,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 {
@@ -1090,7 +1286,10 @@ interface PlaneOverlap {
     readonly plane: GlassPlane;
     readonly nodeIds: readonly [string, string];
 }
-/** Two groups whose padded backdrop proxies would overlap in one plane (X1). */
+/**
+ * Two groups close enough in one plane that one group's padded proxy would
+ * sample the pixels the other one paints (X1).
+ */
 interface ProxyOverlap {
     readonly plane: GlassPlane;
     readonly groupIds: readonly [string, string];
@@ -1136,8 +1335,26 @@ 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;
-    setPlatformProbe(probe: PlatformProbe): void;
+    setNodeBounds(id: string, bounds: Rect$1, clip?: readonly Rect$1[]): void;
+    /**
+     * Scene-wide by default; per group when `groupId` is given.
+     *
+     * The per-group form exists for `backdropProxyConformance` (Decision Log
+     * #21(a), #23(c)). S1's backdrop-root audit is per group — different groups
+     * sit under different ancestors — so a scene-wide-only probe forced the
+     * browser layer either to demote every group when one failed, or to bypass
+     * `resolve()` and call the pure resolver itself with the verdict folded in.
+     * It chose the second, honestly and in the open, and this setter is what
+     * retires it: with the verdict in the scene, `ResolvedGroup.state` and the
+     * host's per-group answer are the same answer again.
+     *
+     * A per-group probe REPLACES the scene-wide one for that group rather than
+     * merging with it, exactly as `setGovernorPressure` does. Merging would be a
+     * second precedence rule sitting beside `REASON_PRECEDENCE`, and the caller
+     * that knows the group's verdict is the same caller that holds the scene-wide
+     * probe it was derived from.
+     */
+    setPlatformProbe(probe: PlatformProbe, groupId?: string): void;
     setSourceProbe(sourceId: string, probe: SourceProbe): void;
     /** Scene-wide by default; per group when `groupId` is given. */
     setGovernorPressure(pressure: GovernorPressure, groupId?: string): void;
@@ -1171,8 +1388,8 @@ interface GlassScene {
     checkSamePlaneOverlap(): readonly PlaneOverlap[];
     /**
      * The cross-group half of X1's proxy geometry. `mergeDistance` only unions
-     * members *within* a group, so two neighbouring groups can still put two
-     * padded proxies over the same pixels — which S1 measured double-filtering.
+     * members *within* a group, so a neighbouring group's proxy can still sample
+     * the pixels this one paints — which S1 measured double-filtering.
      */
     checkGroupProxyOverlap(): readonly ProxyOverlap[];
 }
@@ -1353,15 +1570,15 @@ type Rgb = readonly [r: number, g: number, b: number];
  * **The lower of the two wins**, and this module folds them into one scalar before
  * anything reaches a uniform, so the shader has no way to honour the wrong one.
  *
- * The ordering mirrors `platform-web`'s `REFRACTION_LADDER`, which serves the CSS
- * tier. It is restated rather than imported because this package sits *below*
- * core in the dependency graph and platform-web sits above it. That the two
- * copies must agree is a real (if small) seam — see the note in the C6 report.
+ * The ordering is `@vitrea/policy`'s, and so is the fold. It used to be restated
+ * here — this package sits *below* core in the dependency graph and platform-web
+ * sits above it, so for most of v1 there was no module both tiers could see and
+ * the CSS tier carried a second copy. Decision Log #23(d) closed that seam by
+ * putting the ladder in a pure leaf underneath everything, which the renderer can
+ * depend on directly (alongside `@vitrea/geometry`) with no cycle to close. The
+ * two copies can no longer disagree because there is only one.
  */
 
-/** X2's `RefractionQuality`, restated. Weakest first — the declaration order IS the ladder. */
-declare const REFRACTION_LADDER: readonly ["none", "approximate", "true"];
-type RefractionQuality = (typeof REFRACTION_LADDER)[number];
 /**
  * The slice of core's `ResolvedAccessibilityPolicy["material"]` the renderer
  * reads. core's type is assignable to this; a test pins that.
@@ -1401,6 +1618,96 @@ interface MaterialRim {
     readonly rimWidth: number;
     readonly rimAlpha: number;
 }
+/**
+ * The outer shadow (W8) — the material's own occlusion of the backdrop *outside*
+ * its contour, and the largest single facet the project has measured.
+ *
+ * Not the same quantity as `MaterialOptics.shadowDepth`/`shadowAlpha`, which are
+ * the *inner* shadow: that one darkens the material's own body near its contour,
+ * this one darkens what is behind and beside the surface. Profile-level rather
+ * than per-variant, because the bed measures it per profile and never varied the
+ * variant.
+ *
+ * ## The mechanism, as measured
+ *
+ * The reference's shadow is the component's OWN rounded silhouette, outset by
+ * `spreadPx`, translated down by `offsetPx`, blurred by a Gaussian of standard
+ * deviation `sigmaPx`, and applied MULTIPLICATIVELY: the backdrop keeps
+ * `1 − occlusion·falloff` of its own light. Fitted in two dimensions against the
+ * active bed, that model reproduces the reference to an RMS of 0.0021 in
+ * occlusion over 142,550 pixels on the finest cell, and the same three lengths
+ * describe every profile, backdrop, span and scale in the bed.
+ *
+ * **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
+ * constant-subtraction model misses by 79% of the signal. So the shadow is
+ * analytically INVISIBLE over black — `dark-solid` cells are byte-identical to
+ * their background — and that property is what both tiers reproduce exactly,
+ * because a fully transparent black composited over anything leaves it alone and
+ * black times anything is black.
+ *
+ * ## Lengths, in points
+ *
+ * Every length below is in CSS px and the 2× bed proves it: `sigmaPx` measures
+ * 15.5 at 1× and 31.0 at 2× device px, `offsetPx` 7.9 and 15.8. A shadow
+ * specified in points is what doubles that way.
+ *
+ * They are also SPAN-INVARIANT, which is a positive measurement rather than an
+ * absence: across spans of 32, 44, 96 and 160 px the fitted σ stays within
+ * 15.4…15.9 and the offset within 6.9…8.1. The size law reaches the amplitude
+ * (`sizeGain`) and nothing else.
+ */
+interface MaterialOuterShadow {
+    /** Downward translation of the shadow's silhouette, CSS px. */
+    readonly offsetPx: number;
+    /** Gaussian σ the silhouette is blurred by, CSS px. A `box-shadow` blur is 2σ. */
+    readonly sigmaPx: number;
+    /** 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.
+     */
+    readonly occlusion: number;
+    /**
+     * What reduced transparency does to `occlusion` — MEASURED, not assumed, which
+     * is what the charter asked for before the fold was written.
+     *
+     * 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.
+     *
+     * 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
+     * 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
+     * indistinguishable on here.
+     */
+    readonly reducedTransparencyOcclusion: number;
+    /**
+     * The size law's grip on the amplitude: the fraction of the REMAINING
+     * transparency a full-thickness surface's shadow closes, on
+     * `sizeOcclusionGain`'s relative form.
+     *
+     * Ships at 0 — the identity — and the reason is a measurement rather than an
+     * absence of one. Fitted per scene at a frozen geometry, the amplitude's span
+     * dependence points in OPPOSITE directions in the two colour schemes: light
+     * standard falls from 0.326 to 0.196 between a 44 px and a 96 px span over
+     * `photo` (and 0.331 → 0.285 over `checkerboard`, 0.331 → 0.245 over
+     * `hc-text`), while dark standard RISES from 0.060 to 0.177 to 0.274 across 44,
+     * 96 and 160 px. Under reduced transparency it is flat (0.183, 0.192, 0.165).
+     * One monotone gain on one thickness curve cannot be all three, and any
+     * non-zero value fitted to one scheme is wrong in the other — the same shape of
+     * finding Decision Log 13 recorded for W7's curve ("surface size is its own
+     * axis"). The seam ships so the cascade can fit it if a two-axis rework lands;
+     * the value stays at the identity until something can identify it.
+     */
+    readonly sizeGain: number;
+}
 /**
  * Every number the material runs on, in one place.
  *
@@ -1432,24 +1739,138 @@ interface MaterialProfile {
      */
     readonly refractionScale: Readonly<Record<RefractionQuality, number>>;
     /**
-     * The size-parameterised lens depth — parent acceptance #2's mechanism.
+     * **The size law's one curve** — the span band over which the material stops
+     * reading as a thin sheet and starts reading as a thick slab (W2).
      *
-     * Below `lensSpanMin` a surface gets its authored thickness and nothing more;
-     * above `lensSpanMax` it gets `lensSizeGainMax` times it. The final clamp to the
-     * shorter *half* extent 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.
+     * Apple states one mechanism and lists its consequences: as glass "morphs to
+     * larger sizes… its material characteristics change to simulate a thicker, more
+     * 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 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 band top past 96 — see `sizeScatterFloor`); it now rides its own,
+     * from the same `sizeSpanMin`, 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 the gain saturates instead of
-     * growing without bound on a full-width platter.
+     * size never read as differently thick, and so every gain saturates instead of
+     * growing without bound on a full-width platter. Below `sizeSpanMin` the whole
+     * law is **exactly inert**: a small control renders as it did before the law
+     * existed, which is what makes the law additive rather than a global retune.
+     *
+     * MEASURED (W2, on the settled bed): the band is where the reference's own
+     * size-dependence happens. Over a fixed checkerboard backdrop the light-standard
+     * reference passes 0.244 of the backdrop's contrast at a 32 px span, 0.230 at
+     * 44 px and 0.144 at 96 px, and its backdrop correlation falls 0.634 → 0.606 →
+     * 0.475 across the same three — so the movement is essentially complete by 96 px
+     * and has barely started at 32. See the claims doc's size-law section.
+     */
+    readonly sizeSpanMin: number;
+    readonly sizeSpanMax: number;
+    /**
+     * The lens's gain on the size curve — "more pronounced lensing and refraction".
+     *
+     * `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.
      */
-    readonly lensSpanMin: number;
-    readonly lensSpanMax: number;
     readonly lensSizeGainMax: number;
-    /** Chain LOD per CSS px of lens depth, and how much sharper the rim samples. */
-    readonly lensBodyLodPerPx: number;
-    readonly lensRimLodBias: number;
+    /**
+     * The scattering gain — "a softer scattering of light". How many times wider
+     * the material's body blur runs at full size.
+     *
+     * **The facet the settled bed identifies most directly.** Two backdrops
+     * disagree in exactly the way a widening kernel predicts and an opacity change
+     * does not. Over the checkerboard — all of whose structure sits at one 16 px
+     * period, and whose surroundings carry the same mean as its interior — the
+     * reference's retained contrast falls 41% from a 32 px span to a 96 px one while
+     * its interior *level* stays put (0.607 → 0.641). Over the synthetic photo —
+     * broadband, and with surroundings whose mean differs from the mask's — the
+     * retained contrast barely moves between 44 px and 96 px (0.546 → 0.544) while
+     * the level converges toward the neighbourhood (0.585 → 0.628). A larger alpha
+     * would have moved both backdrops' contrast together and pulled both levels
+     * toward the tint; a wider kernel moves exactly what moved.
+     *
+     * 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 `sizeScatterSpanMax` below for the curve
+     * it rides. 8: the heavy component of the reference's interior sits near σ 10
+     * CSS 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 own curve** (W11c G1, claims §5.41).
+     *
+     * 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 CSS 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 (0.52 at
+     * 96, 0.64 at 128, 0.76 at 160). `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. So the scatter
+     * mix rides its own curve:
+     *
+     * ```
+     * kScatter = floor + (1 − floor) · smoothstep(sizeSpanMin, sizeScatterSpanMax, span) · fold
+     * ```
+     *
+     * The floor is the material's own frost and is **not** folded under an
+     * accessibility preference; the span-dependent rise is a depth effect and
+     * folds like every other facet (`scatterThickness`). Fitted with `rrect-lg`
+     * held out: floor 0.40 (0.0175 at 0.3, 0.0174 at 0.45), band top 256 (0.0182
+     * at 224, 0.0174 at 320); the held-out cell's residual 0.0366 → 0.0174.
+     */
+    readonly sizeScatterFloor: number;
+    readonly sizeScatterSpanMax: 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
+     * closes at full size.
+     *
+     * Relative rather than absolute, for `increasedOcclusionLift`'s reason: a floor
+     * dies silently the moment nominal passes it, and a fraction of the headroom
+     * cannot. It also composes correctly with the accessibility lift — under reduced
+     * transparency nominal is already near 1, so the size law has almost no headroom
+     * left to close, which is exactly what the reference does there (its transmission
+     * reads 0.011 at a 44 px span and 0.014 at 96 px — no size dependence, because
+     * there is none left to have).
+     */
+    readonly sizeOcclusionGain: number;
+    /**
+     * The inner shadow's gain — "casts deeper, richer shadows". A multiplier on
+     * `shadowDepth` at full size.
+     *
+     * **Coupled by construction, not fitted, and the difference is stated rather
+     * than hidden.** The fixtures cannot identify it: the reference's peak darkening
+     * outside its contour measures 0.0000–0.0001 on almost every calibration scene
+     * and vitrea's measures the same order (C9a, `shadowFalloff`), so there is no
+     * measured gap for a sweep to close, and what this renderer's `shadowDepth`
+     * scales is an *inner* shadow whose contribution to the interior level is
+     * degenerate with the tint's — two constants, one observable. So the direction
+     * comes from Apple's sentence and the magnitude is held to what the objective is
+     * flat over, with that flatness recorded. GPU tier only: the CSS tier's shadow is
+     * an outer `box-shadow` the reference does not cast at all (Decision Log #32(c)).
+     */
+    readonly sizeShadowGainMax: number;
+    /**
+     * The lens's magnitude: the contour displacement in lens depths (W11c G2).
+     *
+     * The shader reads the body from `lensDepth × lensRefractionGain × (1 − depth)²`
+     * further inside, so the band is the plate folded back from that far in. The
+     * two rim-LOD constants that used to sit here (`lensBodyLodPerPx`,
+     * `lensRimLodBias`) are retired: the reference's band is not sharper than its
+     * interior — W11c G2 measured σ 6 → 4 → 3 → the deep value across the band —
+     * and the "sharper rim" was the fold, not a finer sample.
+     */
+    readonly lensRefractionGain: 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
@@ -1471,12 +1892,137 @@ interface MaterialProfile {
      * (0.62 − 0.28) / (1 − 0.28) = 0.4722, which reproduces the old floor exactly at
      * the old nominal. At today's nominal it reads 0.62 → 0.799.
      *
-     * Mirrored by `@vitrea/platform-web`'s `INCREASED_OCCLUSION_LIFT`, and pinned in
+     * Mirrored by `@vitreajs/vitrea-web`'s `INCREASED_OCCLUSION_LIFT`, and pinned in
      * both directions by `packages/calibration/test/tier-coherence.test.ts`.
      */
     readonly increasedOcclusionLift: number;
     readonly strongBorderRim: MaterialRim;
     readonly reducedTintAdaptation: number;
+    /**
+     * 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 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.
+     *
+     * `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 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
+     * thing in front of it and takes the backdrop's own tone.
+     *
+     * The mechanism is one mix, and it is deliberately the *tint colour* rather
+     * than the tint alpha: `backdropToneMax` at full strength makes the tint equal
+     * the sampled backdrop, so `mix(backdrop, tint, tintAlpha)` collapses to the
+     * backdrop exactly and the surface is left with its rim, its inner shadow and
+     * its lensing and nothing else. That is what the settled reference does —
+     * `dark-solid__capsule-button__rest` is byte-identical to its own background
+     * in every standard profile, at both scales, in both colour schemes.
+     *
+     * `backdropToneLow`/`backdropToneHigh` are the backdrop luminances (linear)
+     * the two ends are reached at, crossed with a smoothstep for the same reason
+     * `tintToneLow`/`High` are.
+     *
+     * `backdropToneSizeBias` is the size gate, and it is not decoration: the same
+     * backdrop moves a small surface and a large one by very different amounts.
+     * Over `dark-solid` the reference's 44 px capsule adapts completely while its
+     * 96 px rrect keeps three quarters of its own appearance, measured on both
+     * scales independently and agreeing to three decimals. The bias enters the
+     * curve's *argument* rather than its amplitude — a thicker surface behaves as
+     * though its backdrop were brighter, which is what more material between the
+     * viewer and the backdrop means — because an amplitude gate cannot reproduce
+     * the second dark backdrop (`impulse`) and this does.
+     *
+     * The axis is WITHIN a colour scheme. The scheme picks the neutral; this moves
+     * the material away from that neutral toward what is actually behind it. So the
+     * dark profile runs the same law with the same constants and does not
+     * double-adapt: over `dark-solid` its capsule collapses onto the backdrop too,
+     * and the light and dark references become the same pixels there.
+     */
+    readonly backdropToneMax: number;
+    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;
     /**
      * Advisory light direction, in viewport coordinates with y pointing down: a
      * little left of straight overhead, which is where Apple's material reads its
@@ -1503,15 +2049,31 @@ interface MaterialProfilePatch {
     readonly adaptiveLuminanceLow?: number;
     readonly adaptiveLuminanceHigh?: number;
     readonly refractionScale?: Readonly<Partial<Record<RefractionQuality, number>>>;
-    readonly lensSpanMin?: number;
-    readonly lensSpanMax?: number;
+    readonly sizeSpanMin?: number;
+    readonly sizeSpanMax?: number;
     readonly lensSizeGainMax?: number;
-    readonly lensBodyLodPerPx?: number;
-    readonly lensRimLodBias?: number;
+    readonly sizeScatterGainMax?: number;
+    readonly sizeScatterFloor?: number;
+    readonly sizeScatterSpanMax?: number;
+    readonly sizeOcclusionGain?: number;
+    readonly sizeShadowGainMax?: number;
+    readonly lensRefractionGain?: number;
     readonly reducedTransparencyFrost?: number;
     readonly increasedOcclusionLift?: number;
     readonly strongBorderRim?: Readonly<Partial<MaterialRim>>;
     readonly reducedTintAdaptation?: 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;
     readonly glowRadiusCss?: number;
@@ -1734,137 +2296,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`.
@@ -1896,6 +2327,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`. */
@@ -1909,6 +2347,11 @@ interface SurfaceChannels {
     /** Press point in viewport CSS px. Defaults to the surface's centre. */
     readonly pressPoint?: readonly [number, number];
 }
+/** An author tint as this package takes it: a seed in linear light, and a strength. */
+interface MaterialTintInput {
+    readonly color: readonly [number, number, number];
+    readonly strength: number;
+}
 interface SurfaceInput {
     readonly nodeId: string;
     readonly family: ShapeFamily;
@@ -1917,6 +2360,17 @@ interface SurfaceInput {
     /** Defaults to `"apple-continuous"` — see the module note. */
     readonly reference?: CornerReference;
     readonly variant?: MaterialVariant;
+    /**
+     * The author's tint (core's `ResolvedMaterial.tint`), in **linear** light —
+     * the host converts, because this package's whole optical model is linear and
+     * the seed is about to be mixed into it.
+     *
+     * The strength travels per surface and reaches the fragment stage per pixel;
+     * the seed colour is resolved once per group, because a group is one optics
+     * pass. Core warns when a group's members ask for different seeds
+     * (`tint-mixing`), and the first tinted member's colour is the one drawn.
+     */
+    readonly tint?: MaterialTintInput;
     readonly channels?: Partial<SurfaceChannels>;
     /**
      * X8 rider 2. When present this surface renders as `parentField + inset`, and
@@ -1951,6 +2405,63 @@ interface GroupRenderInput {
     readonly refraction: RefractionQuality;
     /** True where X2 resolved `analysis: "exact"`; gates adaptive tint. */
     readonly analysisExact: boolean;
+    /**
+     * The backdrop source's own average colour, linear light — what backdrop tone
+     * adaptation (W7) adapts toward, and the luminance it decides from.
+     *
+     * A **per-source scalar rather than a per-pixel sample**, and that is why it
+     * arrives from outside rather than being read off the pyramid. The host measures
+     * it once from the pixels it already supplied and both tiers then read the
+     * identical number: the CSS tier cannot sample per pixel at all, and a per-pixel
+     * GPU adaptation beside a per-surface CSS one puts the two tiers on different
+     * pictures wherever the backdrop has structure — measured on the impulse cell at
+     * an interior level ratio of 79 against a gated band of 0.80…1.25. It is also
+     * what the reference does: its capsule over a sparse bright grid is a *flat*
+     * body, not a window onto the grid.
+     *
+     * Absent means the adaptation stands down for this group, rather than falling
+     * 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;
@@ -1999,6 +2510,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.
@@ -2154,6 +2832,28 @@ interface PyramidResources {
     readonly sizeEpoch: number;
     /** The dirty epoch the last successful rebuild satisfied. */
     readonly builtEpoch: number;
+    /**
+     * The body blur's σ in **level-0 texels** — the CSS-px σ the material asked
+     * for, through the same cover fit and plan downscale the build applied.
+     *
+     * Published because the conversion is only knowable here: it needs the frame's
+     * real extent, which is exactly why `bodySigmaCss` arrives in CSS px. The size
+     * law's scattering facet consumes it (W2) — the optics pass widens the body blur
+     * per surface by sampling the chain, and it cannot find the level to measure
+     * 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;
 }
 interface PyramidInstrumentation {
     /** Successful rebuilds since the store was created. */
@@ -2184,6 +2884,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";
@@ -2368,6 +3073,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;
@@ -2433,7 +3148,7 @@ declare function loadWebGPURenderer(): Promise<GlassRenderer>;
  *
  * Pure and passive: no DOM, no Node built-ins (X4), no timers and no clocks.
  * Every probe result, media-query answer and layout rect arrives as plain data;
- * @vitrea/platform-web owns the browser and drives the frames.
+ * @vitreajs/vitrea-web owns the browser and drives the frames.
  *
  * The modules, roughly in dependency order:
  *
@@ -2463,4 +3178,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 ConfiguredSource, type CopyProviderOptions, type CornerProfile, type CornerRadii, 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 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$1 as 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, VITREA_CONTRACTS, type VariantMixingCheck, type Vec2, type VideoProviderOptions, WEBGPU_AVAILABILITIES, type WebGPUAvailability$1 as WebGPUAvailability, type WebGPURendererModule, type ZSlot, checkVariantMixing, classifyStateChange, compareZSlot, createDiagnosticsChannel, createFrameScheduler, createGlassScene, defaultForegroundAdaptation, 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 };