@mkbabb/glass-ui 4.0.1 → 4.2.0

package/src/styles/dock/layers.css

@@ -2,10 +2,11 @@
  * contract (AX.W06 carve).
  *
  * Carved from the dock.css god-module (slice 25). This partial owns the dock's
- * layer model: the `.dock-layers` grid container + the FLIP-driven box-size morph
- * (BB.W-DOCK-MORPH-FAMILY — a `transform: scale()` over a reserved settled `to`
- * footprint, the live `--dock-morph-scale` derived off the ONE `--dock-morph-t`
- * scalar; NO per-frame layout-axis lerp), the unified
+ * layer model: the `.dock-layers` grid container + the ratio-FREE convex-blend
+ * box-size morph (BD.W-DOCK-CORE — `scale: var(--dock-size-scale)` from a
+ * `--dock-live` blend of two measure-ONCE endpoints `--dock-expanded-px`/
+ * `--dock-collapsed-px`, BOUNDED by construction off the ONE `--dock-morph-t`
+ * scalar; NO per-swap `from/to` ratio, NO per-frame layout-axis lerp), the unified
  * `.is-active` / `.is-leaving` 3-state crossfade + hit-test contract (the
  * a11y-006 anchor), the per-child reveal stagger (the `--dock-stagger-*` ramp),
  * and the `layout="grid"` 2D tile-grid arrangement. The `.dock-layer-group` /
@@ -39,66 +40,63 @@
     }
 
 
-    /* BB.W-DOCK-MORPH-FAMILY (a)/(b) — the box morph is now a COMPOSITOR TRANSFORM
-       over a RESERVED SETTLED footprint, NOT a per-frame `inline-size` lerp (the C3
-       "too slow and laggy" relayout-every-frame defect). `useLayerTransition` /
-       the orchestrator still measure the from→to size ONCE per swap (the allowed
-       one-time FLIP measurement) and write `--dock-morph-from`/`--dock-morph-to` px
-       on the morphing element — but the layout axis is set to the SETTLED `to`
-       value (ONE layout solve, the box reserves its end footprint from frame 0), and
-       the live `--dock-morph-t` scalar drives a `transform: scale()` between the
-       from/to RATIO and 1. The content lays out COMPLETE at `to` behind the
-       `overflow: clip` aperture (shell.css), and the scaled-down box reads as the
-       smaller in-flight footprint (the clip uncovers the scaled box, never a
-       half-painted growing layout — the reveal-seat (b) fix). `--dock-morph-ratio`
-       is `from/to` (guarded: `to:0` → ratio 0); `--dock-morph-scale` runs
-       `ratio → 1` as `t: 0 → 1`. `transform-origin` anchors the pinned edge
-       (inline-start for the horizontal aperture) so the box grows from the correct
-       side. NO `inline-size`/`block-size` reads the live scalar — the CDP Layout
-       track stays FLAT through the morph (the F1 compositor-bound floor). */
-    .glass-dock[data-morphing] .dock-layers,
-    .glass-dock[data-morphing] .dock-layer-stack {
-        --dock-morph-ratio: calc(
-            var(--dock-morph-from, 0px) / max(var(--dock-morph-to, 1px), 1px)
+    /* ── BD.W-DOCK-CORE — the ratio-FREE convex-blend SIZE (the width-seizure cure) ──
+       THE BUG THIS RETIRES: the prior morph drove the visible size by an UNBOUNDED
+       per-swap `from/to` ratio — `--dock-root-scale = max(ratio + (1−ratio)·t, 0.06)`,
+       a FLOOR with NO CEILING. A degenerate `to` (the FLIP measure racing the content
+       layout) ran `ratio = from/max(to,1px)` to ~56 → `scaleX(56)` ≈ 2451px on
+       collapse, or an inversion at the spring's >1 overshoot peak. `transform-origin:
+       center` kept the centroid clean (cxRange 0), which is exactly why every prior
+       judge measuring the centroid PASSED while the WIDTH detonated. The whole
+       per-swap measure-and-arm pipeline + the `--dock-root-*`/`--dock-morph-ratio/scale`
+       rules are DELETED (clean break, no legacy).
+
+       THE CURE — a convex blend of two POSITIVE measure-ONCE endpoints. The dock
+       measures its expanded content span + its collapsed box ONCE per content change
+       (`useDockExpandedSize` writes `--dock-expanded-px`/`--dock-collapsed-px`, NOT a
+       per-swap rAF race) and the visible size is `--dock-live = collapsed +
+       (expanded − collapsed)·clamp(0, --dock-morph-t, 1)` → BOUNDED by construction:
+       a convex blend can NEVER exceed the larger endpoint nor invert below the smaller,
+       regardless of spring overshoot (the `clamp(0,t,1)` caps the size term; the >1
+       excursion routes to the orthogonal `--dock-punch-stretch` channel). No ratio, no
+       `from>to` degeneracy, no floor guard (the two endpoints ARE the floors). The box
+       RESERVES `--dock-expanded-px` (ONE layout solve, CDP-Layout-flat) and the visible
+       size rides `scale: var(--dock-size-scale)` from `transform-origin: center` —
+       container-justify-agnostic, center-out by construction (left-anchored / centred /
+       auto-margin docks ALL grow center-out, no justify detection, no translate). The
+       endpoints default to a no-op (`expanded == collapsed → scale 1`) so an unmeasured
+       dock paints neutral. The actual `scale:` property is composed in shape.css (folded
+       WITH the `--stretch` squish × the `--dock-punch-stretch` cartoon punch on ONE
+       compositor channel). KEEP `--dock-morph-t` (the shipped token — NO rename). */
+    .glass-dock[data-morphing] {
+        --dock-live: calc(
+            var(--dock-collapsed-px, var(--dock-expanded-px, 0px)) +
+                (
+                    var(--dock-expanded-px, 0px) -
+                        var(--dock-collapsed-px, var(--dock-expanded-px, 0px))
+                ) *
+                clamp(0, var(--dock-morph-t, 1), 1)
         );
-        --dock-morph-scale: calc(
-            var(--dock-morph-ratio) +
-                (1 - var(--dock-morph-ratio)) * var(--dock-morph-t, 0)
+        --dock-size-scale: clamp(
+            0.06,
+            calc(var(--dock-live) / max(var(--dock-expanded-px, 1px), 1px)),
+            1
         );
-        /* The box RESERVES its settled `to` footprint — a single layout solve, NOT
-           the live scalar calc. The transform composites over it. */
-        inline-size: var(--dock-morph-to);
-        transform: scaleX(var(--dock-morph-scale));
-        transform-origin: left center;
+        transform-origin: center center;
         will-change: transform;
     }
 
-    /* AZ.W-DOCK-TAXONOMY (move 2) — a VERTICAL dock's outer `.dock-layers` morphs the
-       BLOCK axis (its collapse↔expand shrinks `height`, not `width`). The orchestrator
-       measures/writes the same `--dock-morph-from/to` span on the block axis
-       (`outerLayerAxis` is now the resolved orientation; `morphAxisProp` maps
-       vertical→`block-size`).
-       BB.W-DOCK-MORPH-FAMILY (a)/(b) — the vertical box reserves its settled `to`
-       BLOCK footprint + composites a `scaleY()` over it on the SAME `--dock-morph-t`
-       scalar (the inverse axis of the horizontal `scaleX`), `transform-origin` at the
-       block-start pinned edge. NO live-scalar `block-size` calc → no per-frame
-       relayout on the vertical axis either. */
-    .glass-dock.vertical[data-morphing] .dock-layers {
-        inline-size: auto;
-        block-size: var(--dock-morph-to);
-        transform: scaleY(var(--dock-morph-scale));
-        transform-origin: center top;
-        will-change: transform;
+    /* The box RESERVES its expanded footprint (ONE layout solve — the page reflows
+       ONCE to the final size, CDP-Layout stays FLAT) while the visible size scales
+       toward it. Horizontal reserves `inline-size`, vertical reserves `block-size`,
+       matching the morph axis. The `.dock-layers` content lays out at its natural
+       size behind the clip (shell.css) — that natural span is the `--dock-expanded-px`
+       the ResizeObserver reads. */
+    .glass-dock[data-morphing]:not(.vertical) {
+        inline-size: var(--dock-expanded-px);
     }
-
-    /* A vertical inner group morphs the BLOCK axis — the same settled-footprint
-       reserve + `scaleY()` composite over it. */
-    .glass-dock[data-morphing] .dock-layer-group.vertical .dock-layer-stack {
-        inline-size: auto;
-        block-size: var(--dock-morph-to);
-        transform: scaleY(var(--dock-morph-scale));
-        transform-origin: center top;
-        will-change: transform;
+    .glass-dock[data-morphing].vertical {
+        block-size: var(--dock-expanded-px);
     }
 
     /* The inner DockLayerGroup stack has no collapsed/expanded class, so its
@@ -278,7 +276,10 @@
     .glass-dock[data-morphing] .dock-layer-item-host.is-active > * {
         --dock-stagger-window: var(--dock-stagger-window-size, 0.55);
         --dock-stagger-onset: 0;
-        opacity: clamp(
+        /* BD.W-DOCK-CORE (A6) — factor the reveal ramp into ONE named var so opacity AND
+           the center-coupled scale read the SAME clamp (W-MOTION-CANON P3, fade coupled to
+           transform). */
+        --child-reveal: clamp(
             0,
             calc(
                 (var(--dock-expand-t, 1) - var(--dock-stagger-onset)) /
@@ -286,11 +287,14 @@
             ),
             1
         );
-        translate: 0
-            calc(
-                (1 - clamp(0, calc((var(--dock-expand-t, 1) - var(--dock-stagger-onset)) / var(--dock-stagger-window)), 1)) *
-                    var(--dock-stagger-rise, 4px)
-            );
+        opacity: var(--child-reveal);
+        /* BD.W-DOCK-CORE (A6) — the rise is a center-coupled SCALE pop (0.82 → 1 on the
+           reveal ramp, transform-origin center), NOT the prior independent `translate: 0
+           4px` vertical hop. The children inherit the SAME center-anchored read as the box
+           — a small inertial pop FROM the center, coupled to opacity. The global PRM gate
+           strips `scale` → snap. */
+        scale: calc(0.82 + 0.18 * var(--child-reveal));
+        transform-origin: center;
     }
 
     /* AX.W02 — per-child onsets off the ONE `--dock-stagger-step` token. Each
@@ -305,26 +309,34 @@
        collapse this to a single declaration, but it is not yet Baseline across
        Safari/Firefox — the token-keyed nth-child set is the cross-engine form, and
        the magic ladder is gone either way.) */
-    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(2),
-    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(2) {
+    /* BD.W-DOCK-CORE (A6) — the SYMMETRIC center-out stagger (the index-cascade RETIRED,
+       clean break). The onset ladders by DISTANCE FROM THE ROW CENTER (center pair = onset
+       0 via the base rule, then ±1, ±2 …) so the reveal radiates center-out in lockstep
+       with the center-out box morph (I.2) — never the prior left-to-right index cascade
+       that desynced from the centered grow. `--dock-stagger-step` is the per-ring beat;
+       `nth-child(N of *)` + `nth-last-child(N of *)` reach BOTH ends (the row is short —
+       ≤8 controls is the dock norm), the central rule holds the deep middle. The `of *`
+       syntax is Safari 16.4+/Chrome 111+. The rule is duplicated for the inner pane-stack
+       host (identical onsets). */
+    /* ring ±1 — 2nd-from-center each side */
+    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(2 of *),
+    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-last-child(2 of *),
+    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(2 of *),
+    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-last-child(2 of *) {
         --dock-stagger-onset: calc(var(--dock-stagger-step) * 1);
     }
-    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(3),
-    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(3) {
+    /* ring ±2 — 3rd-from-center each side */
+    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(3 of *),
+    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-last-child(3 of *),
+    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(3 of *),
+    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-last-child(3 of *) {
         --dock-stagger-onset: calc(var(--dock-stagger-step) * 2);
     }
-    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(4),
-    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(4) {
+    /* ring ±3 — the deep-middle 4th/5th-from-edge cap (a long row finishes in-window) */
+    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(n + 4):nth-child(-n + 5),
+    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(n + 4):nth-child(-n + 5) {
         --dock-stagger-onset: calc(var(--dock-stagger-step) * 3);
     }
-    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(5),
-    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(5) {
-        --dock-stagger-onset: calc(var(--dock-stagger-step) * 4);
-    }
-    .glass-dock[data-morphing] .dock-layer.is-active > *:nth-child(n + 6),
-    .glass-dock[data-morphing] .dock-layer-item-host.is-active > *:nth-child(n + 6) {
-        --dock-stagger-onset: calc(var(--dock-stagger-step) * 5);
-    }
 
     /* AW.W2 — the at-rest clip-lift moved to `.expanded:not([data-morphing])` /
        `.always-expanded:not([data-morphing])` (the clip-shell block at the top).

package/src/styles/dock/morph-bridge.css

@@ -76,36 +76,85 @@
             color-mix(in oklab, var(--card), var(--foreground) 6%) 100%
         );
         border-radius: 999px;
-        /* The volume-preserving teardrop squish — stretch along the travel axis,
-           compress reciprocally. Reads `--stretch` (the liquid-flex derivative). The
-           vertical plate squishes on Y, the horizontal on X (set per-plate below). */
-        will-change: width, height, transform;
+        /* BC.W-GLASS-GLOW-FIX (Atlas A-8 root, CANDIDATE 4) — BOUND the 120%×120% radial
+           to the plate box. The gradient SIZE (120%) reaches past the plate's content box
+           so the domed droplet would over-paint were the silhouette ever un-clipped;
+           `overflow: clip` keeps the radial fill inside the teardrop silhouette (the
+           `border-radius: 999px` capsule), so the oversized radial can NEVER paint a giant
+           cream blob past the plate. The domed-droplet read is PRESERVED — the radial still
+           fills the plate; only the past-bounds escape is killed. Defensive, structural,
+           zero visual change (the border-radius already clips the fill — this makes the
+           bound explicit so the leak-class gate holds). */
+        overflow: clip;
+        /* BC.W-LIQUID-MORPH — the teardrop silhouette is the COMPOSITOR `clip-path`
+           inset (NOT a per-frame `width`/`height` — the layout-jank root, glass-dock-
+           codebase.md §2.2 fix (3)). Each plate RESERVES its MAX footprint (a single
+           layout solve, the settled box) and the silhouette necks via a `clip-path:
+           inset()` interpolated on `--dock-morph-t`. The volume-preserving squish reads
+           `--stretch` (the liquid-flex derivative) on `scale`. NO `width`/`height`
+           animation — only `clip-path`/`scale`/`opacity` (compositor/paint), so the
+           CDP Layout track stays FLAT across the morph (proof:no-layout-animation +
+           proof:liquid-morph M4). will-change promotes the compositor channels ONLY. */
+        will-change: clip-path, transform, opacity;
     }
 
-    /* The VERTICAL plate — a tall capsule (the t=0 silhouette). It collapses its height
-       toward the center as t: 0 → 0.5, where it has merged into the teardrop. Width is
-       the dock's inline footprint; height interpolates full → a thin neck. */
+    /* The VERTICAL plate — a tall capsule (the t=0 silhouette). It RESERVES its full
+       tall footprint (a one-time layout solve, NOT a per-frame height lerp) and necks
+       its silhouette toward the center via a `clip-path: inset()` whose block insets
+       GROW as t: 0 → 0.5 (the tall capsule collapses to a thin neck at the midpoint
+       where the goo merges, gone by t=1). `--dock-bridge-v-neck` is the inset travel:
+       0 at t=0 (full height shows) → ~half the reserved height by t=0.5 (necked to a
+       circle ~the width). The box footprint is static; the clip carves the silhouette
+       on the compositor. */
     .dock-morph-bridge-plate--vertical {
         width: var(--dock-bridge-v-w, 3.25rem);
-        /* full height at t=0, necking to ~the width (a circle) by t=0.5, gone by t=1 */
-        height: calc(
-            var(--dock-bridge-v-h, 16rem) *
-                (1 - clamp(0, var(--dock-morph-t, 0), 1)) +
-                var(--dock-bridge-v-w, 3.25rem) * clamp(0, var(--dock-morph-t, 0), 1)
+        height: var(--dock-bridge-v-h, 16rem);
+        /* BD.W-MORPH-FIELD-WELD — the GAP-RELATIVE waist (the scale-blind-threshold fix /
+           the user's 296px→dot defect). The prior travel necked the tall plate ALL the way
+           to a 52px circle at t=0.5, so the goo threshold over-ate the two thin overlapping
+           circles to a lone white dot. The neck now travels only `--morph-neck-frac` (0.62)
+           of the way to the circle, so the midpoint silhouette holds a FAT fused mass with a
+           real waist (≤0.45 of body), not a pinched dot — the goo blur fuses it into one
+           teardrop barbell instead of eating it. */
+        --morph-neck-frac: 0.62;
+        --dock-bridge-v-neck: calc(
+            (var(--dock-bridge-v-h, 16rem) - var(--dock-bridge-v-w, 3.25rem)) / 2 *
+                var(--morph-neck-frac) *
+                clamp(0, calc(var(--dock-morph-t, 0) * 2), 1)
+        );
+        clip-path: inset(
+            var(--dock-bridge-v-neck) 0 var(--dock-bridge-v-neck) 0 round 999px
         );
         opacity: calc(1 - clamp(0, calc((var(--dock-morph-t, 0) - 0.5) * 2), 1));
         /* squish Y on travel (the tall plate stretches along its collapse axis) */
         scale: calc(1 / var(--stretch, 1)) var(--stretch, 1);
     }
 
-    /* The HORIZONTAL plate — a wide capsule (the t=1 silhouette). It grows its width
-       from the center as t: 0.5 → 1. Height is the dock's block footprint; width
-       interpolates a thin neck → full. */
+    /* The HORIZONTAL plate — a wide capsule (the t=1 silhouette). It RESERVES its full
+       wide footprint (a one-time layout solve) and grows its silhouette from the center
+       via a `clip-path: inset()` whose inline insets SHRINK as t: 0.5 → 1 (a thin neck
+       at the midpoint → the full wide bar at t=1). `--dock-bridge-h-neck` is the inset
+       travel: ~half the reserved width − half the height at t=0.5 (necked to a circle)
+       → 0 at t=1 (full width shows). NO per-frame width — the clip carves the silhouette
+       on the compositor. */
     .dock-morph-bridge-plate--horizontal {
+        width: var(--dock-bridge-h-w, 18rem);
         height: var(--dock-bridge-h-h, 3.25rem);
-        width: calc(
-            var(--dock-bridge-h-h, 3.25rem) * (1 - clamp(0, var(--dock-morph-t, 0), 1)) +
-                var(--dock-bridge-h-w, 18rem) * clamp(0, var(--dock-morph-t, 0), 1)
+        /* the inline-axis inset travel: (half the reserved width − half the height) at
+           t=0.5 → 0 at t=1, so the necked silhouette is ~a circle (the height) at the
+           midpoint and the full bar at t=1. */
+        /* BD.W-MORPH-FIELD-WELD — gap-relative waist (the symmetric arm of the V-plate fix
+           above): the wide plate necks only `--morph-neck-frac` of the way to its small
+           dimension at the midpoint, so the fused mass stays fat (a real teardrop, not a
+           dot). */
+        --morph-neck-frac: 0.62;
+        --dock-bridge-h-neck: calc(
+            (var(--dock-bridge-h-w, 18rem) - var(--dock-bridge-h-h, 3.25rem)) / 2 *
+                var(--morph-neck-frac) *
+                (1 - clamp(0, calc((var(--dock-morph-t, 0) - 0.5) * 2), 1))
+        );
+        clip-path: inset(
+            0 var(--dock-bridge-h-neck) 0 var(--dock-bridge-h-neck) round 999px
         );
         opacity: clamp(0, calc(var(--dock-morph-t, 0) * 2), 1);
         /* squish X on travel (the wide plate stretches along its growth axis) */

package/src/styles/dock/morph.css

@@ -62,24 +62,33 @@
         --dock-expand-t: calc(1 - var(--dock-morph-t));
     }
 
-    /* BB.W-LIQUID-REVEAL — the dock-expand LIQUID-OPEN bloom beat (DOCK-EXPAND-CONSUMER).
-       The dock pill BLOOMS open from its collapsed circle: a coupled `filter` blur-
-       settle decongest reading the SAME `--dock-expand-t` directional scalar the chrome
-       interp rides (the W-DOCK-MORPH-FAMILY morph mechanism is UNTOUCHED — this is a
-       SURFACE arm, NOT a morph-axis layout edit). Collapsed (`--dock-expand-t` 0) the
-       dock content reads a faint `blur(--dock-reveal-blur)` decongest; as it expands
-       (`--dock-expand-t` → 1) the blur SETTLES to 0 so the chrome clarifies AS the pill
-       blooms — the iOS "light-bending modulation" arrival on the dock's own pixels
-       (`filter`, NOT `backdrop-filter`, so the resting glass-tier plate blur the dock
-       carries is never clobbered). Compositor-safe (a `filter` radius interp, never a
-       layout property — the proof:no-layout-animation floor). The beat rides the ONE
-       `--dock-expand-t` scalar, so it tracks the `DOCK_SPRING` clock with NO second
-       clock + NO re-added CSS transition (the morph already animates `--dock-morph-t`).
-       PRM: the `--dock-reveal-blur` knob is zeroed under reduce (the carve below). */
+    /* BC.W-DOCK-SHRINK-BLUR — the BB.W-LIQUID-REVEAL bloom-from-source decongest is a
+       TRANSIENT, not a resting state. HEAD keyed the bare `.glass-dock` self-blur off
+       `--dock-expand-t`, which AT REST resolves to the class endpoint → a PERMANENT 3px
+       self-blur on the resting collapsed dock, STACKED on the 9px backdrop (the "blurry
+       mess when shrunken", glass-dock-codebase §2.4). The FIX gates the self-blur (a
+       SURFACE `filter` arm on the dock's own pixels — NOT `backdrop-filter`, so the glass
+       plate blur is never clobbered; compositor-safe) to `[data-morphing]`: at REST the
+       dock is CRISP; ONLY mid-morph does the 3px bloom settle to 0 as the pill
+       materializes (the iOS-27 bloom, gesture-only). The backdrop blur (the glass
+       material) is UNTOUCHED. PRM zeroes it (the carve below). Clean break, no alias. */
     .glass-dock {
-        --dock-reveal-blur: 3px;
+        --dock-reveal-blur: 0px; /* resting: CRISP — no own-pixel self-blur */
+    }
+    .glass-dock[data-morphing] {
+        /* BD.W-DOCK-CORE (A4) — the blur DIAL-BACK. The peak drops 3px → 1.25px AND the
+           decay is FRONT-LOADED: the `clamp(0, (0.5 - expand-t)/0.5, 1)` ramp drives the
+           blur 1.25px → 0 as expand-t crosses 0 → 0.5, then HOLDS 0 for the back half — a
+           brief decongest FLASH, crisp by the morph's midpoint (the icons never read soft
+           through the slow grow). The resting self-blur stays 0px (above, untouched). The
+           9px BACKDROP blur (the material) is untouched — only the OWN-pixel self-blur is
+           dialed. PRM → 0 (the carve below). */
+        --dock-reveal-blur: 1.25px; /* the transient decongest bloom — mid-morph only */
         filter: blur(
-            calc(var(--dock-reveal-blur) * (1 - var(--dock-expand-t, 1)))
+            calc(
+                var(--dock-reveal-blur) *
+                    clamp(0, calc((0.5 - var(--dock-expand-t, 1)) / 0.5), 1)
+            )
         );
     }
 
@@ -97,7 +106,8 @@
     .glass-dock:not(.vertical) {
         /* AY.W-A11Y-PERF O-1 / AZ.W-ADAPTIVE-AUTO Arm 1 — BOTH morph endpoints compose
            the W55 oklab adaptive tint so the self-engage darken (the unconditional
-           `:where(.glass-dock)` rule below re-points the element-level
+           `:where(.glass-dock)` rule in the sibling adaptive-legibility.css partial
+           re-points the element-level
            `--glass-tint-source`/`--glass-tint-strength`) reaches the LIVE
            horizontal dock surface in BOTH the expanded AND the COLLAPSED look (this
            0,3,0 morph interp OVERRIDES the 0,1,0 shell.css bg, so the tint must be
@@ -329,6 +339,27 @@
         margin-inline-start: 0;
     }
 
+    /* BD.W-DOCK-CORE (A5) — the collapsed persistent pill centers its single glyph on
+       BOTH axes (the empty-summary case where the #persistent control IS the collapsed
+       circle). The `--dock-control-safe-inset` padding (background-clip: content-box) must
+       not shift the glyph off the pill's geometric center — `place-items: center`
+       belt-and-braces both axes so the shrunken icon reads dead-center (A5 "icons in the
+       SHRUNKEN state are NOT ALIGNED"). */
+    .glass-dock.collapsed:has(.dock-layer--summary:empty) .dock-persistent {
+        display: grid;
+        place-items: center;
+    }
+    .glass-dock.collapsed:has(.dock-layer--summary:empty) .dock-persistent > * {
+        place-self: center;
+    }
+    /* BD.W-DOCK-CORE (A5) — floor the collapsed glyph at the 16px-min the rail glyph
+       carries (never a sliver inside an inline-flex column). */
+    .glass-dock.collapsed .dock-persistent svg,
+    .glass-dock.collapsed .dock-layer--summary svg {
+        min-width: 1rem;
+        min-height: 1rem;
+    }
+
     /* AW.W3 — the collapsed-hover scale rides the unified dock spring vocabulary.
        The `scale var(--dock-motion-resize)` arm was added to the `.glass-dock`
        root transition above, so this hover scale settles on the SAME spring curve
@@ -357,6 +388,7 @@
 
     .glass-dock.collapsed:hover:not([data-morphing]) {
         scale: var(--dock-collapsed-hover-scale);
+        will-change: transform; /* BC.W-DOCK-ENGINE move 2 — promote the armed-at-rest scale lift */
     }
 
     /* J.W5.C — held-state substrate response.
@@ -385,107 +417,14 @@
             box-shadow var(--duration-fast) var(--ease-standard);
     }
 
-    /* AQ.W3 §W3.1b — open-descendant surface response. When a dock-hosted
-       trigger (`[data-state="open"]`) is open, the dock root holds its elevated
-       read natively (no consumer JS). Idempotent with `[data-held]` above (same
-       floating paint, different trigger). Decorative; `:has()` Baseline Widely. */
-    .glass-dock:has([data-state="open"]) {
-        /* AX.W55 — same oklab tint wrapper as `[data-held]` (zero-delta at rest). */
-        background: color-mix(
-            in oklab,
-            var(--glass-bg-floating, var(--glass-bg-resting)),
-            var(--glass-tint-source) var(--glass-tint-strength)
-        );
-        border-color: var(--glass-border-floating, var(--glass-border-resting));
-    }
-
-    /* ── Adaptive legibility: SELF-ENGAGE the dock over a light backdrop by default
-       (AZ.W-ADAPTIVE-AUTO Arm 1 — the literal G2 surface; "Glass dock over VERY
-       LIGHT materials is unreadable, darken DYNAMICALLY like iOS 27") ─────────────
-       The dock floats over WHATEVER the consumer painted — frequently a light/near-
-       white app surface (the canonical G2 case the user reported). AY.W-A11Y-PERF
-       O-1 set `--glass-backdrop: light` on the dock's OWN root (shell.css) intending
-       a self-darken, but CSS style queries NEVER self-match (the `@container
-       style()` block below reads an ANCESTOR — verified on Chrome 148), so the
-       self-declaration was a NO-OP. This `:where(.glass-dock)` rule is the genuine
-       UNCONDITIONAL self-engage — mirroring the overlay band's `ladder.css:169` —
-       re-pointing the INHERITING tint tokens DIRECTLY on the dock root so the
-       shell (`--glass-bg-dock`), chassis-strip, and held/open tiers (which compose
-       the oklab tint AT THE ELEMENT — the substitution-vs-inheritance-safe targets)
-       darken toward warm-ink in lockstep. `--dock-fg-on-aurora` re-points to the
-       warm-ink here too — ONE reconciled path, the foreground twin folded in (it
-       reaches the dock CONTROLS' glyph/label color). Over a DARK page the darken is
-       sub-perceptual; a dark-substrate consumer opts out via `--glass-tint-strength:
-       0%` on the dock root. The morph-root interp (`.glass-dock:not(.vertical)`
-       above) stays `color-mix(in srgb …)` for the transition — the adaptive darken
-       rides its RESTING endpoint (`--glass-bg-dock`), the in-flight morph frames are
-       sub-perceptual (the ratified resting-endpoint-only default). The muted body
-       register lifts to the full warm-ink under the engaged plate (the muted L40
-       tier cannot clear 4.5:1 on a translucent darkened plate — darkening moves the
-       plate TOWARD muted's own luminance; the low-contrast muted register is
-       inappropriate over a busy glass plate, so it resolves to the legible dark
-       ink, which clears ~10:1). */
-    :where(.glass-dock) {
-        --glass-tint-source: var(--glass-tint-ink);
-        /* BC.W-AUDIT — the scope-7 completion: the dock JOINS the content-tier
-           sub-perceptual FLOOR by default (translucent warm liquid glass, NOT a grey
-           slab), and the FULL AA darken engages ONLY under the genuine bright signal —
-           the `@container --glass-backdrop: light` bucket below, written by the dock's
-           own sampled-luminance observer over a bright backdrop (aurora/DockStage) OR a
-           consumer's explicit bucket. The prior unconditional AA (20% ink-ward) darkened
-           the dock to grey over EVERY calm light page — the iOS-27 dynamic model done
-           wrong (darken-always vs darken-when-bright). The full glass rebuild is BC. */
-        --glass-tint-strength: var(--glass-tint-strength-floor);
-        --dock-fg-on-aurora: var(--glass-tint-ink);
-        --muted-foreground: var(--foreground);
-    }
-
-    /* The ancestor-querying `@container` block KEPT — it reaches the DESCENDANT
-       nested-glass surfaces inside a dock when a consumer marks `--glass-backdrop:
-       light` on the dock's ancestor (the self-engage above re-points only the dock
-       root's own inheriting tokens; a consumer's explicit ancestor bucket still
-       cascades to nested glass through this block). */
-    @container style(--glass-backdrop: light) {
-        .glass-dock {
-            --glass-tint-source: var(--glass-tint-ink);
-            --glass-tint-strength: var(--glass-tint-strength-aa);
-            --dock-fg-on-aurora: var(--glass-tint-ink);
-        }
-    }
+    /* BD.W-DOCK-CORE (A7) — the whole-plate open-descendant recolor is DELETED (clean
+       break, no alias). HEAD repainted the ENTIRE dock plate to the floating tier when ANY
+       descendant overlay opened (a dropdown/select/popover) — 44%α warm-cream → 80.8%α
+       floating, the user's "a dropdown changes the color of the ENTIRE dock" bug. A
+       dropdown opening now leaves the dock plate INVARIANT; the open affordance is
+       TRIGGER-scoped (the trigger's own `[aria-expanded]`/`[data-state=open]` active-fill
+       in dock-controls/triggers.css). The `[data-held]` (slider-drag) lift above is KEPT —
+       a legitimate held-cursor cue, not the bug. */
 
-    /* AX.W55 — the `contrast-color()` flip for the dock control foreground (Chrome
-       147+/Safari 26+; progressive enhancement, NEVER the load-bearing floor). The
-       declarative bucket above already carries AA on all engines (it darkens the dock
-       plate so the warm-dark `--dock-fg-on-aurora` clears ~17:1 over white at the 18%
-       floor). On a supporting engine `contrast-color()` REFINES the control ink,
-       anchored on the LIGHT BACKDROP signal (`--card`, the warm-white surface base the
-       bright bucket implies) — `contrast-color(var(--card))` resolves to the legible
-       DARK ink. Anchoring on the dark ink instead inverts to white (illegible on the
-       still-light dock plate), so the anchor is the light surface, matching the rung
-       refinement in glass.css. The bucket is the floor; this is the native pick. */
-    @supports (color: contrast-color(white)) {
-        /* The SELF-ENGAGED dock refinement (the unconditional self-engage above);
-           progressive enhancement only — the declarative darken is the AA floor. */
-        :where(.glass-dock) {
-            --dock-fg-on-aurora: contrast-color(var(--card));
-            --muted-foreground: contrast-color(var(--card));
-        }
-        @container style(--glass-backdrop: light) {
-            .glass-dock {
-                --dock-fg-on-aurora: contrast-color(var(--card));
-            }
-        }
-    }
 }
 
-/* BB.W-LIQUID-REVEAL — the dock-expand bloom beat's blur-settle is OFF under
-   `prefers-reduced-motion: reduce` (the vestibular floor). The morph itself snaps
-   instantly under PRM (the `DOCK_SPRING` `respectReducedMotion` in
-   dockMorphContext.ts), and zeroing `--dock-reveal-blur` here removes the resting
-   collapsed-pill decongest blur too — a reduced-motion dock reads crisp at every
-   state, no in-between blur frames. */
-@media (prefers-reduced-motion: reduce) {
-    .glass-dock {
-        --dock-reveal-blur: 0px;
-    }
-}

package/src/styles/dock/overflow.css

@@ -262,6 +262,18 @@
                 calc(var(--dock-layer-height, calc(2.5rem * var(--dock-scale))) * var(--dock-icon-glyph-ratio)),
                 var(--dock-icon-glyph-floor)
             );
+            /* BC.W-DOCK-ENGINE move 3 (the Atlas A-9 fold) — RE-DECLARE the in-dock
+               toggle glyph knob on coarse beside `--dock-icon-glyph`. Its `:root`
+               default tracks `--dock-icon-glyph`, but a `:root`-only default would
+               freeze at the `:root` `--dock-scale` (the identity 1) while the coarse
+               `--dock-icon-glyph` above lifts — the AZ.R5-TOKENS substitution-vs-
+               inheritance dead-knob (the SAME trap the dock-scale re-declare closed,
+               mirrored for the toggle glyph). Re-declaring it HERE, against the
+               coarse-re-resolved `--dock-icon-glyph`, keeps the in-dock dark-toggle
+               glyph optically uniform with the nav glyphs on coarse AND fine pointer.
+               The `--dark-mode-toggle-padding` clamp (dark-mode-toggle.css) subtracts
+               THIS knob, so the box pad re-resolves in lockstep too. */
+            --dock-control-glyph-size: var(--dock-icon-glyph);
             --dock-collapsed-padding: calc(0.25rem * var(--dock-scale));
             --dock-layer-tab-size: calc(1.75rem * var(--dock-scale));
             /* --dock-collapsed-summary-min-size derives from --dock-layer-height (the