@mkbabb/glass-ui 4.1.0 → 5.0.0

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

@@ -0,0 +1,160 @@
+/* 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

@@ -41,21 +41,70 @@
     initial-value: 0%;
 }
 
-/* BB.W-BORDER-PROGRESS — the masked-conic BORDER ring's sweep fill. The conic
-   gradient (border-progress.css) reads `--border-progress-fill` as the swept
-   extent (`conic-gradient(…, transparent var(--border-progress-fill), …)`), so a
-   determinate progress INTERPOLATES the border ring (a bare unregistered var()
-   snaps the sweep; the registered typed <percentage> lets the engine animate the
-   gradient stop). `inherits: false` — each ring owns its own fill (the per-surface
-   ownership the specular cohort uses; a ringed parent must not push its fill onto a
-   child). `initial-value: 0%` is the safe resting ring (the unregistered fallback
-   paints it; the cross-fade collapses to it on a non-supporting engine). */
-@property --border-progress-fill {
+/* 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;
@@ -119,6 +168,73 @@
     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
@@ -248,6 +364,21 @@
     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
@@ -263,160 +394,54 @@
     initial-value: 1;
 }
 
-/* ── 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 {
+/* 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;
-}
-
-/* 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%;
+    initial-value: 0.618;
 }
 
-@property --seal-scale {
+/* 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: 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;
+    initial-value: 1;
 }

package/src/styles/tokens/scale-paper.css

@@ -48,13 +48,26 @@
        `scale: var(--stretch) calc(1 / var(--stretch))`) so it reads as an elastic
        warp, never a size pump. A consumer dials the elasticity (or to 1 for none)
        without touching source.
-       BC.W-LIQUID-TAB — lifted 1.08 → 1.15 (in lockstep with the no-token floor
-       DEFAULT_INDICATOR_MAX_STRETCH, the SOLE cap source — constant + token never
-       fork). The click travel-squish AND the liquid-tab pull-morph read this ONE
-       cap; the lift makes a FAST pull visibly swell the pill so the gel-squish READS
-       as liquid (glass-dock-codebase.md §3.4) — still capped LOW (≤1.2, the
-       anti-taffy-pull bar; the pill swells, never taffy-pulls). */
-    --tab-indicator-max-stretch: 1.15;
+       The click travel-squish AND the liquid-tab pull-morph read this ONE cap (in
+       lockstep with the no-token floor DEFAULT_INDICATOR_MAX_STRETCH, the SOLE cap
+       source — constant + token never fork); a FAST pull visibly swells the pill so
+       the gel-squish READS as liquid — still capped LOW (the anti-taffy-pull bar;
+       the pill swells, never taffy-pulls).
+       BD.W-TABS-LIQUID — re-tuned 1.18 → 1.11. The `--tab-blob` area-inflation
+       channel now carries the "grow" (the 5-beat overshoot), so the per-axis stretch
+       drops: the FENCE is the COMPOSED visible bbox area `blob × stretch` ≤ ~1.14,
+       NOT the bare per-axis scalar. At blob ~1.045 (peak) × stretch ~1.11 (far jump)
+       the composed long-axis peak lands ≤ ~1.16 and the AREA (blob² since the squish
+       is volume-preserving) stays ≤ ~1.14 — lively, not taffy. */
+    --tab-indicator-max-stretch: 1.11;
+
+    /* BD.W-TABS-LIQUID — the area-inflation cap (the 5-beat blob's overshoot peak).
+       The 2nd `useLiquidFlex` channel drives `--tab-blob` toward this on the
+       grow-overshoot beat, then de-inflates to 1 at arrival (shrink-to-fit). Kept
+       LOW (~1.045) so the COMPOSED bbox area (blob × stretch, the volume-preserving
+       squish makes the area ≈ blob²) clears the ≤ ~1.14 anti-taffy fence. A consumer
+       dials it (or to 1 for no inflation) without touching source. */
+    --tab-indicator-blob-max: 1.045;
     /* BA.W-TABS — the indicator's OWN travel clock, re-pointed off the generic
        `--duration-normal` (0.3s, which dragged a ~190ms sub-pixel undershoot tail
        past the ~100ms 90%-travel point — the R10-2 "too slow" read) onto the
@@ -67,8 +80,10 @@
     --opacity-icon-muted: 0.8;
 
     --focus-ring-width: 2px;
-    --focus-ring-shadow: 0 0 0 var(--focus-ring-width) color-mix(in srgb, var(--ring) 30%, transparent),
-        0 0 8px color-mix(in srgb, var(--ring) 15%, transparent);
+    /* BG.W-DESHADCN — reads the renamed house `--focus-ring-color` (off the shadcn
+       `--ring`); this is the SOLE `--focus-ring-color` reader (the one retint knob). */
+    --focus-ring-shadow: 0 0 0 var(--focus-ring-width) color-mix(in srgb, var(--focus-ring-color) 30%, transparent),
+        0 0 8px color-mix(in srgb, var(--focus-ring-color) 15%, transparent);
     --focus-ring: var(--focus-ring-shadow);
 
     /* BB.W-INVALID-RING — the destructive twin of --focus-ring-shadow. The
@@ -137,7 +152,8 @@
        — the token-first axis. This is the SINGLE rhythm source: the demo full-bleed
        page grid (`.grid-bg`, story-hero.css) AND the library card-interior register
        (`.paper-grid`, cards.css) both read it (the two-parallel-28px/32px-systems
-       fix). The LIQUID full-bleed sibling (`<PaperGrid>`, BC.W-VIZ-PAPERGRID)
+       fix). The LIQUID full-bleed sibling (`<LiquidGrid>`, BG.W-GRID-AFFINE — the
+       viz renamed off `<PaperGrid>`; the static `.paper-grid` card register is untouched)
        re-uses the SAME rhythm — one pitch, two registers (static page-bg vs liquid). */
     --grid-pitch: 1rem;
     --grid-major: 5rem;
@@ -289,7 +305,6 @@
 
     /* Heights — per-variant rail thickness */
     --timeline-scrubber-height: 0.5rem;       /*  8px — single-track scrubber */
-    --timeline-segmented-height: 0.625rem;    /* 10px — N adjacent bands */
     --timeline-continuous-height: 0.75rem;    /* 12px — ONE pill, N regions */
 
     /* Geometry — shared across all variants */