@mkbabb/glass-ui 5.0.0 → 7.0.0

package/src/styles/tokens/property-regs-specular.css

@@ -1,160 +0,0 @@
-/* tokens/property-regs-specular.css
-   §11b the pointer-anchored moving-specular :root/.dark magnitude cohort + the interaction/scroll DRIVE @property registrations (glass-btn-press-t, the completion-seal draws, the native scroll-ramp / chrome-collapse customs).
-   Carved from property-regs.css to hold the no-god-module 500-line bound (BI.W-STYLE-REDRAIN); @import-ed by tokens.css IMMEDIATELY AFTER property-regs.css. Same :root cascade context as its sibling — the @property registrations are order-invariant and the specular-intensity :root/.dark cohort is the sole writer, so the relocation is byte-isomorphic. */
-/* ── The specular-intensity magnitude cohort (AX.W09) ──────────────────────
-   The catch-light alpha multiplier at each interaction state, as a SINGLE
-   overridable token cohort (was three buried literals across glass.css —
-   `0.35` rest floor / `0.6` hover / `0.85` active — and the `.dark` arm's
-   `0.22`). `glass.css`'s `.glass-material::before` rest/hover/active rules READ
-   these, so the subtle-vs-extreme magnitude is a knob a consumer (or the dark
-   arm) retunes ON THE CASCADE — never a re-buried literal. Override on `:root`
-   to retune library-wide; the cartoon-shadow override contract is the precedent.
-
-   Re-baselined AGAIN at AX.W52 D19 — with the central screen-disc replaced by a
-   BOUNDED plus-lighter edge gleam (glass.css), the gleam is a whisper at every
-   rung, so the cohort drops further (the W09 0.22/0.32 ceiling still lifted the
-   whole-tile disc on hover):
-     • rest   0    — static, unwired surfaces are CLEAN; the gleam wakes only on
-                     hover/active or on a pointer-wired surface. Aligns the painted
-                     rest with the @property `--specular-intensity { initial-value:
-                     0 }` dormancy.
-     • hover  0.10 — a whisper edge gleam, not a bloom.
-     • active 0.16 — the press whisper. */
-:root {
-    --glass-specular-intensity-rest: 0;
-    --glass-specular-intensity-hover: 0.1;
-    --glass-specular-intensity-active: 0.16;
-    /* BB.W-BUTTON-GLASS (d) — the BUTTON-SCOPED hover gleam bump. The lit glass
-       button should read a notch brighter at the grazing edge than the global
-       hover whisper (0.10). `.btn-glass` re-points its own
-       `--glass-specular-intensity-hover` to this knob (surfaces.css), so ONLY the
-       button lifts — the global cohort above is UNTOUCHED. A consumer retints the
-       button gleam from this ONE override. */
-    --glass-specular-btn-hover: 0.14;
-}
-
-/* Over the deep canvas `plus-lighter` still lifts, so the dark arm runs a touch
-   softer on the interaction rungs (rest already 0). */
-.dark {
-    --glass-specular-intensity-hover: 0.08;
-    --glass-specular-intensity-active: 0.12;
-    /* The button bump rides a touch softer in dark too (the dark hover is 0.08;
-       the button reads ~0.11, still a notch above the global whisper). */
-    --glass-specular-btn-hover: 0.11;
-}
-
-/* BB.W-BUTTON-GLASS (b)/(e) — the press DRIVE scalar. ONE typed 0..1 custom
-   property Button.vue writes off the `useSpringPress` spring (0 released → 1
-   pressed, with the ~5% overshoot the spring carries). It is the SINGLE drive the
-   press SQUISH (the `useLiquidFlex` reciprocal X/Y deform), the coupled specular/
-   brightness lift, and the optional `.glass-refract` lens-swell all read — the "one
-   drive, the glass deforms under press" read. Registered typed so a `transition`/
-   downstream `calc()` interpolates the VALUE (number), not the text. `inherits:
-   true` so the host-written value reaches the `.glass-material::before` pseudo +
-   the coupled rules. `initial-value: 0` so an unwired/SSR button is the static
-   rest frame (the no-JS CSS `.tap-squish` scale floor still presses). */
-@property --glass-btn-press-t {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}
-
-/* BC.W-AX-COMPLETION-SEAL — the 4 motion drives of the hero-scale earned-GOLD
-   completion seal (completion-seal.css consumes them). Registered typed so the
-   one-shot draw INTERPOLATES (a bare unregistered var() snaps; the §18 typed-property
-   idiom lets the engine animate the stroke-reveal / settle / glint). The seal is the
-   visual seal of the W-PHASE-PALETTE completion event — its ink reads the earned-gold
-   register; its glint composes the W-AX-METAL-GLOW catch-light. One-shot, PRM-gated,
-   compositor-only.
-
-   • --seal-draw (<percentage>) — the stroke-reveal extent (the stroke-dashoffset wipe
-     drive: 0% undrawn → 100% fully drawn). `inherits: false` (each seal owns its own
-     draw, the per-surface ownership of the specular/border-progress cohort — a sealed
-     parent must not push its draw onto a child seal). `initial-value: 100%` is the
-     SAFE fully-drawn resting seal: on a non-supporting engine (no @property) the seal
-     paints fully drawn, NEVER a blank — the editorial draw-on degrades to the finished
-     mark, never to nothing.
-
-   • --seal-scale (<number>) — the settle scale (the draw-on lands with a small spring
-     overshoot on the seal's own --spring-snappy/--spring-bouncy clock — the SPATIAL
-     leg, W-MOTION-CANON P2 enter-bouncy). `inherits: false` (per-seal). `initial-value:
-     1` is the resting settled scale.
-
-   • --seal-glint (<number>) — the gold catch-light intensity (the one-pass glint that
-     fires once on settle, reading --metal-glow-opacity from W-AX-METAL-GLOW — a glint,
-     not a loop). `inherits: false` (per-seal). `initial-value: 0` so an unwired seal is
-     un-glinting at rest (the calm floor; the glint wakes only on the draw).
-
-   • --seal-ink (<color>) — the seal stroke color. `inherits: true` (the cascading-scalar
-     idiom — a consumer scope re-inks the seal in lockstep with the completion register).
-     The @property `initial-value` MUST be a CONCRETE var-free <color> (the typed-property
-     rule: a registration fallback cannot be a var()), so it is the LITERAL light-gold
-     `oklch(0.751 0.147 84.2)` (scale-paper.css's `--gold` value) — the engine fallback
-     when no cascaded value exists. The RUNTIME cascade default is the TOKEN form the
-     recipe sets: `--seal-ink: var(--phase-complete-color, var(--color-gold))` — the
-     EARNED-gold completion register (Q2: gold is earned at completion, NEVER the running
-     phase spectrum). */
-@property --seal-draw {
-    syntax: "<percentage>";
-    inherits: false;
-    initial-value: 100%;
-}
-
-@property --seal-scale {
-    syntax: "<number>";
-    inherits: false;
-    initial-value: 1;
-}
-
-@property --seal-glint {
-    syntax: "<number>";
-    inherits: false;
-    initial-value: 0;
-}
-
-@property --seal-ink {
-    syntax: "<color>";
-    inherits: true;
-    initial-value: oklch(0.751 0.147 84.2);
-}
-
-/* BC.W-SCROLL-TRIGGER — the native scroll-ramp custom. The continuous 0..1 scroll
-   progress the `useScrollTrigger` reader exposes rides this registered custom on a
-   `supportsScrollTimeline()` engine: a `.scroll-progress`-style recipe writes it via
-   `animation-timeline: scroll(self)` so a consumer's CSS ramp (the BC.W-SCROLL-CHROME
-   shrink/opacity) reads `--scroll-t` with ZERO JS (the dual-path single-writer — the JS
-   `progress` ref attaches NOTHING on a supporting engine). `inherits: true` (the
-   cascading-scalar idiom — a scroll-driven ancestor exposes the ramp to descendant
-   chrome, the `--ui-scale`/`--glass-level` pattern), distinct from the per-element
-   non-inheriting specular/progress cohort. `initial-value: 0` is the safe resting ramp
-   (the unregistered fallback paints it; on a non-supporting engine the JS reader writes
-   `progress.value` and the consumer reads the ref, not this custom). The typed
-   `<number>` lets the engine interpolate the ramp rather than the textual rep (a bare
-   unregistered var() snaps — the `--border-progress-fill`/`--dock-morph-t` precedent). */
-@property --scroll-t {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}
-
-/* BC.W-SCROLL-CHROME — the floating-chrome COLLAPSE fraction. `--chrome-collapse-t`
-   is the 0..1 collapse scalar `useScrollChrome` ramps off the scroll reader's
-   direction + range (0 = fully expanded, 1 = fully collapsed). The `.scroll-chrome`
-   recipe (scroll-chrome.css) reads it for the COMPOSITOR shrink/quiet ramp:
-   `transform: scale()/translateY()` (the SPATIAL leg), `opacity` (bounded above a
-   never-invisible floor — the NN/g pale-fade trap forbidden), and the shadow LIFT as
-   content scrolls under (Apple "as text scrolls underneath, shadows become more
-   prominent"). It NEVER drives the resting `backdrop-filter` blur (the
-   W-DOCK-SHRINK-BLUR fence — the shrunken bar is crisp glass, not a blurry mess).
-   Registered typed so a bare `var()` INTERPOLATES the ramp rather than snapping (the
-   `--scroll-t`/`--dock-morph-t` precedent); `inherits: true` (the cascading-scalar
-   idiom — a scroll-driven ancestor exposes the collapse to descendant chrome, the
-   `--scroll-t`/`--glass-level` pattern, distinct from the per-element non-inheriting
-   specular cohort). `initial-value: 0` is the PERSISTENT rest (the iOS-27 default — a
-   bare chrome does NOT collapse; the unregistered fallback paints it too, so the
-   recipe is byte-identical to the expanded chrome when unwired). */
-@property --chrome-collapse-t {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}

package/src/styles/tokens/property-regs.css

@@ -1,447 +0,0 @@
-/* tokens/property-regs.css
-   §18 Houdini @property registrations (progress/phase/ripple/specular/glass-level/ui-scale) + §11b the pointer-anchored moving-specular :root/.dark magnitude cohort. LAST — registrations + the magnitude cohort that reads them.
-   Carved from the tokens.css cascade root; @import-ed by tokens.css in
-   cascade order. Same :root cascade context as its siblings. */
-/* ═══════════════════════════════════════════════
-   §18 TYPED CSS PROPERTIES — Houdini @property registrations
-   (AI.W4 grammar — adjacent to §2.C tokens above)
-
-   Three typed custom properties register with the CSS Houdini @property
-   API so transitions interpolate VALUES (percentage / length) rather
-   than the textual representation. Unregistered fallback is safe — the
-   `initial-value` provides a sensible default for any consumer that
-   imports this stylesheet on a browser that doesn't yet support the
-   typed @property registration (the cross-fade collapses to the
-   initial value, then re-paints at the new state).
-
-   Browser support: Chromium 85+, Safari 16.4+, Firefox 128+. The
-   speedtest deployment target sits well within the floor.
-
-   • --progress-crescendo (percentage) — the leading-edge brightness
-     ramp on `<Progress variant="gradient">` past 85% modelValue.
-     `inherits: false` because the value is consumed at one
-     declaration only (the gradient stop calculation); inheriting
-     would let an unrelated ancestor accidentally drive a sibling
-     progress bar.
-
-   • --phase-tint-amount (percentage) — the chassis depth-of-tint
-     companion to `--phase-color`. `inherits: true` because the
-     value cascades from the chassis root through every region
-     wrapper that reads it for a sympathetic tint (matches the
-     `--phase-color` inheritance pattern).
-
-   • --ripple-radius — RETIRED at BA.W-GLASS-CAL (H2a) with the disco recipe
-     family: the typed press-ripple was `btn-audacious`-private and has no
-     surviving consumer (the calm CTA register's press is the §6 scale beat).
-   ═══════════════════════════════════════════════ */
-
-@property --progress-crescendo {
-    syntax: "<percentage>";
-    inherits: false;
-    initial-value: 0%;
-}
-
-/* The masked scroll-progress rim's interpolable sweep. */
-@property --scroll-progress-rim-fill {
-    syntax: "<percentage>";
-    inherits: false;
-    initial-value: 0%;
-}
-
-/* BD.W-GOO-CAROUSEL-DECK — the ONE goo-morph travel scalar (the de-dup of the pager
-   WORM's `--worm-t`). The morph silhouette (dot worm / carousel slide plate / deck
-   slide plate) travels between MEASURED slot centers driven by a continuous page-space
-   float the host `transition`s on a `--{prefix}-flow` `linear()` curve. A bare
-   unregistered `var()` would SNAP `--goo-t` (no spring glide); the typed `<number>`
-   registration lets the engine interpolate the scalar so the silhouette's two-edge
-   geometry (useGooMorph.ts) springs past then settles. `inherits: true` — the host
-   transitions it, the rAF projection reads it off the host. `initial-value: 0` is the
-   resting slot (a non-supporting engine snaps onto the active slot, the floor). ONE
-   shared registration: the worm, the carousel plate, and the deck plate all read it. */
-@property --goo-t {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}
-
-/* BD.W-TABS-LIQUID — the area-inflation scalar (the 5-beat blob's grow→overshoot
-   →shrink envelope) + the one-shot commit accent-flood progress. BOTH are driven
-   IMPERATIVELY: the 2nd `useLiquidFlex` channel in `useTabIndicator.ts` writes
-   `--tab-blob` every frame (it is NOT added to a CSS `transition` list — the
-   composed `scale` write the indicator already transitions carries the glide). The
-   `@property` registration exists ONLY so the discrete release-frame write
-   (`--tab-blob` snapping back to 1 at arrival) interpolates instead of snap-
-   flickering — the SAME role the `--stretch`/`--glass-accent` registered-scalar
-   precedent serves. `inherits: false` — each indicator owns its own blob (a blobbed
-   parent must not push inflation onto a child). `initial-value: 1`/`0` are the safe
-   rest (a non-supporting engine slides with no inflation/flood, never broken). */
-@property --tab-blob {
-    syntax: "<number>";
-    inherits: false;
-    initial-value: 1;
-}
-@property --tab-flood-t {
-    syntax: "<number>";
-    inherits: false;
-    initial-value: 0;
-}
-
-/* BI.W-TABS-FACTOR — the iOS-27 eyeglass two-rest-state scalar. SETTLED(0) ⇄ LIVE(1)
-   drives the tab-pill loupe's block-proud magnify (the plate `scaleY` reads
-   `--eyeglass-y`, a calc off this scalar; TABS-GLASS-LADDER §1/§8.1: settled INSET
-   0.84× ⇄ live PROUD 1.12×). It is JS-driven per-frame by `useEyeglassLive`, which
-   CONSUMES `useLeadTrail` (the ONE lead/trail integrator, reading the `eyeglass`
-   SPRING_PRESETS row) — so writing it from the `hi` edge gives fast-energize /
-   slow-decay EMERGENTLY (lead governs the rise, the ~270ms trail governs the
-   deflate; the §2/§8.3 edge-asymmetric release). `inherits: true` so the host writes
-   it on the indicator and the nested `.segmented-indicator__plate` reads it (and a
-   consumer can force it from an ancestor). `initial-value: 0` = the SETTLED long rest
-   (a non-supporting engine / SSR paints the calm inset plate, never broken). The
-   registration lets the CSS transition interpolate it under the DEGRADE floor, but on
-   the live JS path the useLeadTrail integrator is the animator (no CSS transition). */
-@property --eyeglass-live-t {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}
-
-@property --phase-tint-amount {
-    syntax: "<percentage>";
-    inherits: true;
-    initial-value: 0%;
-}
-
-/* ═══════════════════════════════════════════════
-   §11b  POINTER-ANCHORED MOVING SPECULAR (AV.W15)
-
-   The iOS-26 Liquid Glass "light travels around the material /
-   illuminate under your fingertip" behaviour. A masked radial-gradient
-   catch-light rides the surface at (--specular-x, --specular-y), driven
-   by the consumer's pointer-tracked --mouse-x/--mouse-y write. Registered
-   as typed custom properties so the position INTERPOLATES smoothly between
-   pointer samples (a bare unregistered var() snaps; the @property reg lets
-   the engine animate the percentage stop).
-
-   • --specular-x / --specular-y (percentage) — the catch-light centre.
-     `inherits: false` because each glass surface owns its own pointer
-     position (a hovered parent must not push its specular onto a child —
-     the no-glass-on-glass discipline made mechanical).
-
-   • --specular-intensity (number) — the catch-light alpha multiplier.
-     `inherits: false` for the same per-surface-ownership reason; rises on
-     hover/active, settles to its rest floor on leave.
-
-   @property crosses Baseline 2024-07-09. The consumption (the masked
-   radial + the reduced-motion static bracket + the var() fallback) lives
-   in glass-specular-track.css; the registrations live here alongside the
-   other three regs so the typed-property tier has one home.
-   ═══════════════════════════════════════════════ */
-
-@property --specular-x {
-    syntax: "<percentage>";
-    inherits: false;
-    initial-value: 50%;
-}
-
-@property --specular-y {
-    syntax: "<percentage>";
-    inherits: false;
-    initial-value: 50%;
-}
-
-@property --specular-intensity {
-    syntax: "<number>";
-    inherits: false;
-    initial-value: 0;
-}
-
-/* BB.W-LENSING — the per-surface EDGE-glint angle channel. `--specular-angle` is
-   the pointer angle-from-center the edge-glint conic sweep reads (material.css);
-   `useSpecularPointer` writes it (the angle feed). `inherits: false` — the
-   per-element ownership discipline of the specular cohort above (each pseudo owns
-   its typed value; a parent's angle must never bleed into a child glass surface).
-   `initial-value: 0deg` is the static rest position (the rim glint sits top when
-   unwired — no ambient drift, no blowout). */
-@property --specular-angle {
-    syntax: "<angle>";
-    inherits: false;
-    initial-value: 0deg;
-}
-
-/* BD.W-MOTION-WEIGHT — the LIVE velocity channel. `useLiquidFlex` writes this
-   per-frame off the SAME saturating velocity term it already computes
-   (`tanh(|ṫ|·k) ∈ [0,1]`); the consumer's `writeVelocityWeight` helper folds it
-   into a transient `--motion-weight: calc(0.618 + 0.382 * var(--flex-vel))` boost
-   so a driver in active fast motion deepens its own squish/punch/shadow-travel and
-   self-extinguishes back to rest as it settles ("elements morph MORE the faster
-   they move"). `inherits: false` is LOAD-BEARING (the C2·R1 subtree-storm bite): a
-   per-frame write invalidates exactly ONE element, never a subtree — an inheriting
-   velocity channel would re-paint every descendant on every frame. `initial-value:
-   0` is the still rest (no boost when unwired). */
-@property --flex-vel {
-    syntax: "<number>";
-    inherits: false;
-    initial-value: 0;
-}
-
-/* BD.W-CARTOON-CASTER — the cartoon cel-cast drive props (H1: proven-live-DEAD
-   without these — the calc chain falls back to initials → no punch). The cast
-   travel/spread READ `--motion-weight × --cartoon-press-t`, so the inert
-   `.cartoon-cast` child plate moves on the compositor as the body presses.
-   • --cartoon-press-t (<number>, inherits:true) — the 0→1 press ramp the existing
-     `useLiquidPress` writes (aliased onto `--card-press-t` on `.cartoon-surface`);
-     inherits so the inert child reads its host's press scalar.
-   • --cast-travel (<length>, inherits:false) / --cast-spread (<number>,
-     inherits:false) — the per-caster derived offset + scale; non-inheriting (each
-     caster owns its own, never bleeds onto a nested cartoon child).
-   • --cartoon-cast-dx/dy (<length>, inherits:true) — the OPT-IN drag-track delta
-     (0 at rest; a future `useCartoonCast` DOM bridge writes them). Inherits so the
-     host can set them for the child. Typed so the gap INTERPOLATES on the
-     compositor; a non-supporting engine snaps rather than eases (the gap still
-     reads). */
-@property --cartoon-press-t {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}
-
-@property --cast-travel {
-    syntax: "<length>";
-    inherits: false;
-    initial-value: 0px;
-}
-
-@property --cast-spread {
-    syntax: "<number>";
-    inherits: false;
-    initial-value: 1;
-}
-
-@property --cartoon-cast-dx {
-    syntax: "<length>";
-    inherits: true;
-    initial-value: 0px;
-}
-
-@property --cartoon-cast-dy {
-    syntax: "<length>";
-    inherits: true;
-    initial-value: 0px;
-}
-
-/* BD.W-PAGE-FIELD — the warm colorful FIELD drive props (`--field-h-raw` /
-   `--field-intensity`) are RETIRED with the `.paper-field` plane (BG.W-FIELD-AURORA).
-   The shell `<Aurora>` field carries the per-route warm hue now (a JS uniform on the
-   AuroraConfig palette, not a CSS @property), so these registrations are dead. Clean
-   break, no alias — `proof:no-paper-field` asserts both regs ABSENT. */
-
-/* BB.W-LENSING `--glass-refract` axis — RETIRED (DDR-LENS-BAKE, glass-refract.css).
-   The axis drove the `feDisplacementMap` `scale` by splicing `var(--glass-refract)`
-   between a head/tail `url()` pair. That construction never parsed as a
-   `backdrop-filter` (it emitted three tokens, not one url) AND broke consumer bundlers
-   (the tail `url("'…")` mis-resolved as a file path); a CSS url() string token cannot
-   carry a substituted `var()`, so a dynamic `scale` inside the mandatory single
-   self-contained data-URI is structurally impossible. The `scale` is now BAKED at 28
-   (the resting bend, byte-identical) — no axis, no `@property` reg. */
-
-/* BB.W-GLASS-ACCENT — the THIRD disjoint glass axis: the per-INSTANCE
-   CHROMATIC-RIM tint. `--glass-accent` is a complete `<color>` (a consumer DATA
-   hue) that OKLab-tints a glass surface's RIM (the `--glass-material-rim` inset
-   ring + the per-rung `--glass-border-*`) and the `::before` specular catch-light
-   CORE — so the §F1 data-keyed colored hover (a chart cell whose surface glows
-   with that datum's series hue) is a ONE-LINE seam (`--glass-accent: <hue>;
-   --glass-accent-strength: <N%>` on the instance), not a hand-threaded
-   `border-color` + inline catch-light per consumer.
-
-   DISTINCT-not-fork of W55's `--glass-tint-source` (the WHOLE-PLATE BACKGROUND
-   legibility darken toward `--glass-tint-ink`): the accent is the RIM+GLINT
-   chromatic DECORATION axis (toward a consumer DATA hue, per-instance), it NEVER
-   writes the W55 cohort and NEVER tints the plate background. Three disjoint glass
-   axes: LEVEL (opacity+blur, AX.W54) · TINT (whole-plate legibility, W55) · ACCENT
-   (per-instance chromatic rim+glint, this wave).
-
-   • --glass-accent (<color>) — the consumer data hue. `inherits: true` (the
-     `--glass-level`-style cascading scalar — a host sets it on an ancestor to tint
-     a sub-tree; a consumer sets it per-INSTANCE on the surface). `initial-value:
-     transparent` is the NEUTRAL IDENTITY: a `color-mix(in oklab, X, transparent N)`
-     is byte-identical X at the resting end, so an UNSET surface paints exactly
-     today's warm-ink rim + warm-cream catch-light (the W2 neutral-fallback floor).
-
-   • --glass-accent-strength (<percentage>) — the bounded knob. `inherits: true`
-     (rides the accent down the same sub-tree). `initial-value: 0%` so the mix is a
-     provable no-op when unset (`color-mix(in oklab, X, <accent> 0%)` === X). The
-     consumer-set ceiling is a WHISPER at the rim, not a flooded plate — the demo
-     specimens engage ~40-55% (the rim/glint reads the hue while the warm-cream core
-     + the AA legibility survive; the `--glass-tint-strength-aa` ≤24% bounding
-     precedent, lifted here because the accent rides the THIN rim/glint not the
-     whole plate). A malformed override CLAMPS to 0% (the typed fail-safe). */
-@property --glass-accent {
-    syntax: "<color>";
-    inherits: true;
-    initial-value: transparent;
-}
-
-@property --glass-accent-strength {
-    syntax: "<percentage>";
-    inherits: true;
-    initial-value: 0%;
-}
-
-/* BC.W-GLASS-GLOW-FIX (Atlas A-8) — the Pulse aura breath SCALE. The `ambient-pulse`
-   keyframe runs on `.pulse-aura` and writes this property; the `.pulse-aura::before`
-   child (the radial paint) reads it via `transform: scale(var(--pulse-aura-breath-
-   scale))`. Typed `<number>` so the keyframe INTERPOLATES it per-frame (a bare
-   unregistered var would snap min↔max). INHERITS so the pseudo-element picks it up
-   from its originating `.pulse-aura` (the aura has no content descendants — it is
-   `aria-hidden` + empty — so the inherit only reaches the `::before` halo). */
-@property --pulse-aura-breath-scale {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 1;
-}
-
-/* AX.W54 — the GLASS-FIRST single knob. `--glass-level` is the ONE clarity
-   scalar threaded through BOTH glass ladders at their single sites (the
-   `--glass-bg-*` opacity recipe + the `--glass-blur-*` radii). It is a typed,
-   INHERITING <number> so a host setting it on any ancestor retunes every
-   descendant glass surface (the @container-free cascade path) — and so it
-   animates smoothly rather than snapping. The level acts as a clarity multiplier
-   that PRESERVES level=1 (byte-identical to the hand-tuned ladder):
-     • level 1 — the calibrated glass (today's surfaces, unchanged).
-     • level 0 — the OPAQUE escape: solid `--card` + `blur(0)` through the SAME
-                 machinery (the `.glass-opaque` rung + the a11y brackets ride it).
-     • level >1 — clearer (more transparent + more diffuse) in lockstep.
-   Glass is the DEFAULT surface register for EVERY band (USER-DECIDED MAXIMAL);
-   the opaque level-0 rung is the explicit opt-out. W55 carries the over-light
-   legibility on the SEPARATE `--glass-tint-*` axis (the `--glass-backdrop` probe
-   lifts the tint toward ink — level = opacity+blur, tint = darken-over-light, the
-   two axes coordinate but never collapse: the a11y Clear↔Tinted escape rides
-   level-up here AND tint-toward-ink under `prefers-contrast: more`). */
-@property --glass-level {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 1;
-}
-
-/* BC.W-ADAPTIVE-RECONCILE — the OBSERVER's measured backdrop relative-luminance, now
-   LOAD-BEARING. `useGlassBackdropLuminance` WRITES `--glass-backdrop-luma` (0..1) on
-   the glass target; the content/overlay/dock `:where()` rules READ it on the RHS of the
-   `--glass-tint-strength` clamp (glass/ladder.css, dock/morph.css) — the continuous
-   driver that lifts the calm 4% floor toward the ≤24% AA ceiling as the measured
-   backdrop brightens past the knee (the iOS-27 dynamic-range shift; apple-ios27.md §1.5).
-   Registered as a typed INHERITING `<number>` (the `--glass-level`/`--progress-crescendo`
-   precedent) so a bare `var()` INTERPOLATES smoothly between sample frames instead of
-   snapping (a per-sample re-paint would flicker the plate). `inherits: true` so the
-   observer's write on the target reaches every descendant glass surface that reads the
-   clamp. `initial-value: 0` is the calm-dark rest: with luma 0 the clamp's luma-ramp is
-   `max(0, …) = 0`, so an unwired surface resolves EXACTLY the floor (the zero-delta calm
-   identity GLASS-IDENTITY pins). This replaces the empty `--glass-backdrop-luma: ;`
-   placeholder declaration (the dead-knob's write-only stub) — the loop now READS. */
-@property --glass-backdrop-luma {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}
-
-/* BB.W-DEEP-GLASS — the OPT-IN deep-glass DEPTH scalar. `--glass-depth` is the
-   `--glass-level` TWIN for the deep tier: a typed INHERITING <number> so a host
-   sets it on any ancestor to retune the deep tier's depth (the cascading-scalar
-   idiom, distinct from the per-element `inherits: false` specular cohort). The
-   deep recipe (tokens/glass-deep.css) LERPs both the blur radius AND the saturate
-   between the calm `floating` endpoint (depth 0 ≡ the calm ceiling) and the Apple-
-   deep endpoint (depth 1 ≡ saturate 1.5 / blur 16px), so the deep blur is
-   `--glass-depth`-DRIVEN (the D1 axis assert — never a baked literal) and animates
-   smoothly. `initial-value: 1` is the resting deep magnitude: a `.glass-deep`
-   surface paints at the full Apple-deep register by default; a consumer dials
-   `--glass-depth: 0.5` to land it half-way to the calm floating rung. SEPARATE
-   from `--glass-level` (opacity+blur clarity), `--glass-tint-*` (legibility), and
-   `--glass-refract` (lens displacement) — the disjoint depth axis. The deep tier
-   COMPOSES `--glass-level` too (the deep blur scales it), so the opaque escape +
-   the a11y brackets reach the deep plate through the ONE level path. */
-@property --glass-depth {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 1;
-}
-
-/* BG.W-GLASS-DEFAULT-DEFINITION (GA-1) — the DEFINED-tier engage scalar (the
-   `--glass-level`/`--glass-depth` TWIN). Glass over a FLAT page reads near-gray (chroma
-   0.0138); the defined tier gives a CONTROL a warm rim + warm-cream floor. BOTH legs
-   read this scalar — the floor-fill α + the `--glass-border-defined` rim α
-   (tokens/glass.css) — so it is genuinely load-bearing (dead-knob-proof). `inherits:
-   true` (a host dials definition on any ancestor); `initial-value: 0` is fully
-   TRANSMISSIVE (content default, ladder byte-untouched); `.glass-defined`
-   (glass/defined.css) + `prefers-contrast: more` set it to 1. SEPARATE from
-   `--glass-level`/`--glass-depth`/`--glass-tint-*`. */
-@property --glass-definition {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0;
-}
-
-/* AX.W51 D18 — the master comfortable-sizing scalar registered typed. The
-   `<number>` syntax guarantees `calc(<base> * var(--ui-scale))` is always valid (a
-   malformed override CLAMPS to the initial value 1, not an invalidated calc — the
-   fail-safe); `inherits: true` (unlike the per-element specular @property cohort)
-   so a SCOPED override (a dense data-table region) cascades to every descendant
-   control without a per-element set; the type makes it animatable (a density
-   toggle COULD spring it). Mirrors the `--glass-level` registration above (the
-   cascading-scalar idiom), distinct from the per-element specular @property cohort
-   (those are `inherits: false`). */
-@property --ui-scale {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 1;
-}
-
-/* BD.W-MOTION-WEIGHT — the GOVERNING motion scalar (the iOS-27 register-triangle
-   centroid). ONE number co-scales the squash depth, the overshoot share, the
-   anticipation pull-back, and the cartoon-shadow travel so they read as ONE
-   proportioned deformation, never four unrelated tics. Registered with the EXACT
-   `--ui-scale`/`--glass-level` typed cascading-scalar idiom — `inherits: true` is
-   the whole mechanism: a DRIVER ancestor (`.dock`, a celebrating card, a sheet)
-   locally pushes `--motion-weight: 1`; an OBSERVER subtree (`<CarouselContent>`
-   auto-advance, `[data-reorder]` lists) pins `--motion-weight: 0` — everything
-   below reads the local value with zero prop-drilling. `initial-value: 0.618`
-   (1/φ, design.md §L6 golden-proportion law): not 0 (dead), not 1 (manic) —
-   present, alive, never cartoonish-by-default. The `:root` rest decl + the PRM
-   carve live in scheme-motion.css §2 (the Feature-token-home, beside the
-   `--spring-*` clocks it co-governs). A non-supporting engine reads the safe
-   0.618 fallback (the squish still reads, just non-animatable — the same fail-safe
-   `--ui-scale` documents). */
-@property --motion-weight {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 0.618;
-}
-
-/* BI.W-TEMPO (M11 / N6) — the GOVERNING motion TIME scalar (the one application
-   point). ONE registered inheriting number co-scales BOTH the CSS spring clocks
-   (the `--spring-<name>-duration` reader reads `calc(var(--spring-<name>-settle) *
-   var(--motion-tempo))`, scheme-spring.css) AND the JS spring RESPONSES (each spring
-   engine reads it via `motionTempo()` and scales `response *= tempo` at
-   construction). Because `duration ∝ response` (ωₙ = 2π/response), scaling the CSS
-   clock by tempo ≡ scaling response by tempo — so the M1 CSS==JS parity holds at ANY
-   tempo (G2). It serves the "options for longer" clause of UF-G1 (a global motion
-   time knob a consumer sets on `:root`).
-
-   Registered with the EXACT `--ui-scale`/`--motion-weight`/`--glass-level` typed
-   cascading-scalar idiom — `inherits: true` so a consumer sets it on any ancestor
-   and every descendant spring re-reads it (the loud iOS-27 surfaces re-pin
-   `--motion-tempo: 1` on their own scope, scheme-motion.css, so the utility UI
-   tightens/loosens while the deliberate BD.W-ANIM-IOS27-TUNE weight holds where it
-   landed). `initial-value: 1` is the IDENTITY (RATIFIED judgment (c) — the per-
-   register tightening is M1 + REGISTER-TABLE's exit/enter-menu clocks, NOT a global
-   scale): at 1.0 the reader resolves `settle * 1` byte-identical to the flat clock,
-   so the axis is a no-op at rest. A malformed override CLAMPS to the initial 1 (the
-   typed fail-safe; `motionTempo()` mirrors the ≤0 → 1 clamp JS-side).
-
-   THE NAMING FENCE — `--motion-tempo` (TIME) ⟂ `--motion-weight` (MAGNITUDE, default
-   0.618) ⟂ `--ui-scale` (GEOMETRY): three registered inheriting scalars, NEVER
-   folded. PRM is orthogonal (tempo × the universal ~0.01ms carve is still ~0; the JS
-   `respectReducedMotion` snap wins at every tempo). */
-@property --motion-tempo {
-    syntax: "<number>";
-    inherits: true;
-    initial-value: 1;
-}