@vitreajs/vitrea 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,3 +1,19 @@
+declare global {
+  interface GPUBuffer {}
+  interface GPUCommandEncoder {}
+  interface GPUComputePassTimestampWrites {}
+  interface GPUDevice {}
+  interface GPUExternalTexture {}
+  interface GPUExternalTextureDescriptor {}
+  interface GPUQueue {}
+  interface GPURenderPassTimestampWrites {}
+  interface GPUSupportedLimits {}
+  interface GPUTexture {}
+  interface GPUTextureDescriptor {}
+  interface GPUTextureView {}
+}
+type GPUTextureFormat = "bgra8unorm" | "rgba8unorm" | "rgba16float" | (string & {});
+
 /**
  * X8 — the shape channel set, and the vocabulary every other module speaks.
  *
@@ -164,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
@@ -180,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
@@ -399,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).
  *
@@ -409,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"];
@@ -423,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;
@@ -781,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. */
@@ -794,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;
@@ -806,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 {
@@ -867,6 +1009,29 @@ declare function compareZSlot(a: ZSlot, b: ZSlot): number;
 declare function unionRect(a: Rect, b: Rect): Rect;
 /** Grow a rect outwards on every side — how a group's proxy gets its padding. */
 declare function inflateRect(rect: Rect, by: number): Rect;
+/**
+ * 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, clip: readonly Rect[] | undefined): Rect;
 /**
  * Positive-area intersection. Touching edges are not an overlap — adjacent
  * surfaces in a toolbar are the common case and are legal. A degenerate rect
@@ -1008,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;
@@ -1015,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;
@@ -1074,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];
@@ -1121,7 +1336,25 @@ interface GlassScene {
     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;
+    /**
+     * 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;
@@ -1155,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[];
 }
@@ -1337,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.
@@ -1385,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.
  *
@@ -1416,21 +1739,95 @@ 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 **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.
      *
      * 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;
+    /**
+     * 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 σ.
+     */
+    readonly sizeScatterGainMax: 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;
     /** Chain LOD per CSS px of lens depth, and how much sharper the rim samples. */
     readonly lensBodyLodPerPx: number;
     readonly lensRimLodBias: number;
@@ -1455,12 +1852,74 @@ 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 tone map — Apple's "range of tones **mapped to content
+     * brightness underneath**" (S219), as four numbers.
+     *
+     * 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.
+     *
+     * **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.
+     */
+    readonly tintToneFloor: number;
+    readonly tintToneCeilMix: number;
+    readonly tintToneLow: number;
+    readonly tintToneHigh: 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 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
@@ -1487,15 +1946,27 @@ 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 sizeScatterGainMax?: number;
+    readonly sizeOcclusionGain?: number;
+    readonly sizeShadowGainMax?: number;
     readonly lensBodyLodPerPx?: number;
     readonly lensRimLodBias?: 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 backdropToneMax?: number;
+    readonly backdropToneLow?: number;
+    readonly backdropToneHigh?: number;
+    readonly backdropToneSizeBias?: number;
+    readonly outerShadow?: Readonly<Partial<MaterialOuterShadow>>;
     readonly lightDirection?: readonly [number, number];
     readonly sweepBandRadians?: number;
     readonly glowRadiusCss?: number;
@@ -1893,6 +2364,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;
@@ -1901,6 +2377,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
@@ -1935,6 +2422,24 @@ 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;
     readonly variant?: MaterialVariant;
     /** Overrides the calibration-delegated union defaults. */
     readonly union?: GroupUnionParams;
@@ -2138,6 +2643,17 @@ 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;
 }
 interface PyramidInstrumentation {
     /** Successful rebuilds since the store was created. */
@@ -2417,7 +2933,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:
  *
@@ -2447,4 +2963,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, 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 };