@mkbabb/glass-ui 3.12.0 → 3.13.0

package/dist/components/custom/underline/GlassUnderline.vue.d.ts

@@ -0,0 +1,84 @@
+import type { TimingFunction } from "@mkbabb/keyframes.js";
+import type { GlassUnderlinePaths } from "./types";
+type __VLS_Props = {
+    /**
+     * Which clock drives the draw. `load` (default) — the draw is a
+     * `NumericAnimation` the parent's load `Sequence` fires once via `play()`.
+     * `scroll` — native `view()` keyframes, bidirectional, no JS. `static` —
+     * set drawn, no clock.
+     */
+    clock?: "load" | "scroll" | "static";
+    /**
+     * The render variant. `pen` is the only PROVEN, filter-free render.
+     * pencil | crayon | boil are UNPROVEN headroom — the API seam for a future
+     * wave, NOT shipped here (they render pen today).
+     */
+    variant?: "pen" | "pencil" | "crayon" | "boil";
+    /** The stroke colour. Defaults to `var(--primary)` (re-resolves under .dark). */
+    color?: string;
+    /** The load-clock draw duration (ms). Default 700. */
+    drawMs?: number;
+    /**
+     * The load-clock easing. Default `easeOutCubic` — doctrine-compliant (DEC-6):
+     * ink is an irreversible additive reveal, so an overshooting spring would lay
+     * ink past the end then retract it (the "never overshoot past gone" logic).
+     * The value.js `TimingFunction` type (already a peer) serves a consumer's own
+     * decelerating register (e.g. an expo).
+     */
+    easing?: TimingFunction;
+    /**
+     * The scroll-clock timeline name (DEC-5). Default the element's own `view()`.
+     * Bound as `--gu-timeline`; the CSS reads `animation-timeline:
+     * var(--gu-timeline, view())`. A consumer (`--beat-tl`, a named scroll
+     * timeline) passes its own.
+     */
+    timeline?: string;
+    /**
+     * The declarative third clock (DEC-2). A thin overlay ON the load clock:
+     * `undefined` (default) = source parity (seeds undrawn, parent fires
+     * `play()`); bound: rising edge → play() (under PRM → snap()), falling edge
+     * → reset to undrawn so re-activation REPLAYS, mount with `true` → plays.
+     * Only meaningful with `clock="load"` (the other clocks rest drawn).
+     */
+    active?: boolean;
+    /**
+     * The geometry escape (DEC-7). The FULL geometry tuple
+     * `{ stroke, ghost?, viewBox?, len? }` — a bare `d`-string escape silently
+     * breaks the dash model when the consumer geometry's viewBox/length differ.
+     * Defaults to the canonical pen + ghost.
+     */
+    paths?: GlassUnderlinePaths;
+};
+/**
+ * CLOCK A — draw the underline ONCE. The awaitable a parent's load `Sequence` fires
+ * as a causal link. Resolves a Promise so the Sequence can `await` it; under PRM it
+ * snaps to drawn in one paint and resolves immediately. A no-op for scroll/static.
+ */
+declare function play(): Promise<void>;
+/** Snap to terminal (drawn) — the PRM / interrupt path. */
+declare function snap(): void;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    play: typeof play;
+    snap: typeof snap;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    active: boolean;
+    variant: "pen" | "pencil" | "crayon" | "boil";
+    color: string;
+    clock: "load" | "scroll" | "static";
+    drawMs: number;
+    easing: TimingFunction;
+    timeline: string;
+    paths: GlassUnderlinePaths;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/underline/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GlassUnderline } from "./GlassUnderline.vue";
+export type { GlassUnderlineClock, GlassUnderlineVariant, GlassUnderlinePaths, GlassUnderlineProps, GlassUnderlineExpose, } from "./types";

package/dist/components/custom/underline/types.d.ts

@@ -0,0 +1,56 @@
+import type { TimingFunction } from "@mkbabb/keyframes.js";
+/** Which clock drives the draw. */
+export type GlassUnderlineClock = "load" | "scroll" | "static";
+/**
+ * The render variant. `pen` is the only PROVEN, filter-free render (the masthead
+ * invariant). pencil | crayon | boil are UNPROVEN headroom — the API seam for a
+ * future wave, NOT shipped (they render pen today).
+ */
+export type GlassUnderlineVariant = "pen" | "pencil" | "crayon" | "boil";
+/**
+ * The geometry escape tuple (DEC-7). Carries the FULL geometry so an escaped path
+ * stays dash-coherent — a bare `d`-string escape silently breaks the dash model when
+ * the consumer geometry's viewBox/length differ from the canonical
+ * (`0 0 100 10` + `len` 120).
+ */
+export interface GlassUnderlinePaths {
+    /** The primary pen stroke `d`. */
+    readonly stroke: string;
+    /** The faint ghost overdraw `d`. Omit for a single-path (no overdraw) render. */
+    readonly ghost?: string;
+    /** The SVG viewBox. Default `0 0 100 10`. */
+    readonly viewBox?: string;
+    /** The dasharray length (the over-long fixed dash). Default `120`. */
+    readonly len?: number;
+}
+/** GlassUnderline props (the public prop surface). */
+export interface GlassUnderlineProps {
+    /** Which clock drives the draw. Default `load`. */
+    clock?: GlassUnderlineClock;
+    /** The render variant. Default `pen` (the only proven render). */
+    variant?: GlassUnderlineVariant;
+    /** The stroke colour. Default `var(--primary)` (re-resolves under `.dark`). */
+    color?: string;
+    /** The load-clock draw duration (ms). Default `700`. */
+    drawMs?: number;
+    /** The load-clock easing (value.js `TimingFunction`). Default `easeOutCubic`. */
+    easing?: TimingFunction;
+    /** The scroll-clock timeline name. Default the element's own `view()`. */
+    timeline?: string;
+    /**
+     * The declarative third clock — a thin overlay ON the load clock. `undefined`
+     * (default) = source parity (parent fires `play()`); rising edge → play, falling
+     * edge → reset-to-undrawn (re-rise REPLAYS), mount-`true` → plays. Only
+     * meaningful with `clock="load"`.
+     */
+    active?: boolean;
+    /** The geometry escape tuple. Defaults to the canonical pen + ghost. */
+    paths?: GlassUnderlinePaths;
+}
+/** The imperative handle exposed via `defineExpose` / a template ref. */
+export interface GlassUnderlineExpose {
+    /** Draw the load-clock underline once (the awaitable a Sequence chains). */
+    play: () => Promise<void>;
+    /** Snap to terminal (drawn) — the PRM / interrupt path. */
+    snap: () => void;
+}

package/dist/components/ui/card/Card.vue.d.ts

@@ -20,8 +20,17 @@ export type CardTier = "wash" | "quiet" | "resting" | "floating" | "overlay" | "
  *   cartoon  — the Memphis-sticker decoration layered on top of the resolved
  *              tier: 2px border, offset-stamp shadow, hover-lift. Composes onto
  *              ANY tier; the retired `<CartoonCard>` was `tier="quiet" surface="cartoon"`.
+ *   veil     — the text-legibility PLATE (R5-7). The wash/quiet glass fill +
+ *              blur with the border AND rim/highlight STRIPPED (border:none,
+ *              box-shadow:none — the boxed look reads as a "dividing line" on a
+ *              text plate). An optional radial feather axis (`--veil-feather`,
+ *              default none) fades the plate edges into the backdrop. Conceptually
+ *              the W55 adaptive-legibility tint applied as a LOCAL plate over a
+ *              busy/bright backdrop. Token-first (`--veil-*` rungs). It routes the
+ *              glass material through the `--glass-*` ladder, so `--glass-level` /
+ *              the W55 bright-bucket retune it in lockstep with every glass surface.
  */
-export type CardSurface = "glass" | "cartoon";
+export type CardSurface = "glass" | "cartoon" | "veil";
 /**
  * Specular catch-light register (AX.W09) — the pointer-anchored moving lens on a
  * glass card.
@@ -42,8 +51,11 @@ interface Props extends PrimitiveProps {
     tier?: CardTier;
     /** Surface decoration register. `glass` (default) renders the tier's glass
      *  rung; `cartoon` overlays the `cartoon-surface` decoration utility (2px
-     *  border, offset-stamp shadow, hover-lift). Orthogonal to `tier`/`shadow`/
-     *  `grain` — exactly like `shadow` and `grain`; NOT a `tier` rung. */
+     *  border, offset-stamp shadow, hover-lift); `veil` overlays the borderless,
+     *  rimless `veil-surface` text-legibility plate (the wash/quiet glass fill +
+     *  blur with the boxed border + rim STRIPPED, an optional `--veil-feather`
+     *  radial edge fade). Orthogonal to `tier`/`shadow`/`grain` — exactly like
+     *  `shadow` and `grain`; NOT a `tier` rung. */
     surface?: CardSurface;
     /** Surface drop shadow via `--shadow-card`. Off for cards nested inside cards. */
     shadow?: boolean;

package/dist/components/ui/drawer/Drawer.vue.d.ts

@@ -39,6 +39,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
 }>, {
     mode: DrawerMode;
+    open: boolean;
     modal: boolean;
     shouldScaleBackground: boolean;
     snapPoints: (number | string)[];

package/dist/components/ui/dropdown-menu/DropdownMenuSubContent.vue.d.ts

@@ -3,9 +3,9 @@ import { type DropdownMenuSubContentProps } from 'reka-ui';
 type __VLS_Props = DropdownMenuSubContentProps & {
     class?: HTMLAttributes['class'];
 };
-declare var __VLS_8: {};
+declare var __VLS_14: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_14) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;

package/dist/components/ui/metric-pill/MetricPill.vue.d.ts

@@ -1,4 +1,5 @@
 import type { HTMLAttributes } from "vue";
+import { type MetricValue } from "../../../utils";
 /**
  * MetricPill — the speedtest stacked-pill default, composed over `<MetricBadge>`.
  *
@@ -19,13 +20,16 @@ type MetricPillSize = "sm" | "md" | "lg" | "xl";
 type MetricPillLabelPosition = "inline" | "stacked";
 type MetricPillDensity = "comfortable" | "spacious";
 type __VLS_Props = {
-    amount: string | number | null | undefined;
+    /** The primary metric. A valid `0` renders `"0"`, never the placeholder. */
+    value: MetricValue;
     unit?: string;
     label?: string;
     abbreviation?: string;
     color?: string;
+    /** Substitute glyph when value is empty; forwarded to `<MetricBadge>`,
+     *  which owns the shared `coalesceMetric` default. */
     placeholder?: string;
-    /** Defaults to `lg` — the 14px amount / prose-unit ladder rung. */
+    /** Defaults to `lg` — the 14px value / prose-unit ladder rung. */
     size?: MetricPillSize;
     /** Defaults to `stacked` — the 2-row label-above-value reading. */
     labelPosition?: MetricPillLabelPosition;
@@ -35,7 +39,6 @@ type __VLS_Props = {
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     size: MetricPillSize;
-    placeholder: string;
     density: MetricPillDensity;
     labelPosition: MetricPillLabelPosition;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/slider/index.d.ts

@@ -10,31 +10,34 @@ export { default as Slider } from './Slider.vue';
  * (`--slider-track-height`, `--slider-thumb-size`) the SFC defaults read.
  *
  * Exactly two canonical recipes ship:
- *   standard — the CONTINUOUS ROUNDED CYLINDER: a THICK glass capsule track with
- *              the round knob INSCRIBED inside it (knob diameter = track height −
- *              2×inset, inset 2px) so the whole reads as ONE continuous piece — a
- *              ball-bearing seated in the cylinder, never a floating disc on a
- *              wire. The fill is the W52 liquid-glass material (backdrop + edge
- *              rim, tinted to `--primary`) pulled along the capsule; the knob
- *              rides ON it with zero protrusion (`thumbAlignment: 'contain'`).
- *              The reka SliderThumb stays mounted (a11y/keyboard/focus) and
- *              carries a faint specular grip. Halo-on-state + the iOS press
- *              spring. This is the general-purpose glass scrubber and the default.
+ *   standard — the CONTINUOUS GLASS CYLINDER with NO VISIBLE THUMB AT ALL (the
+ *              user's binding bar, USER-AUDIT-2026-06-10 §B3): you pull the TRACK
+ *              itself. A THICK glass capsule track; the filled `.slider-range`
+ *              glass cylinder (the W52 liquid-glass material — backdrop + edge rim,
+ *              tinted to `--primary`) is pulled along it, and its leading EDGE IS
+ *              the handle — the only affordance is the fill edge + the cursor/touch
+ *              response. The reka `<SliderThumb>` STAYS MOUNTED (a11y/keyboard/drag/
+ *              value-follow native on it) but paints INVISIBLE: width 0, opacity 0,
+ *              transparent — no distinct disc/cap/ring over the continuous
+ *              cylinder. Keyboard focus rings the TRACK (the W-PRIM-POLISH focus
+ *              register), not the invisible thumb; hover/held lift the track FILL's
+ *              edge rim; the iOS press spring gives the whole fill a felt squish.
+ *              This is the general-purpose glass scrubber and the default.
  *   spectrum — the value.js gradient-track color slider: a tall capsule whose
  *              background is a consumer-supplied `--slider-track-bg`
  *              linear-gradient (the LCH/hue ramp), a transparent range, and a
- *              SQUIRCLE thumb the HEIGHT of the track (the iOS color-picker
- *              idiom — `corner-shape: superellipse()` via `--corner-shape-thumb`,
+ *              THIN VISIBLE squircle thumb the HEIGHT of the track (the iOS/value.js
+ *              color-picker idiom — a slim vertical bar, `w-3`-thin per the value.js
+ *              reference; `corner-shape: superellipse()` via `--corner-shape-thumb`,
  *              @supports-gated over a generous proportional round fallback that
  *              reads squircle-adjacent cross-engine). This is the aurora/blob
- *              color-picking surface. The spectrum already obeys the containment
- *              law the standard cylinder now matches (thumb inscribed, protrusion 0).
+ *              color-picking surface — its thumb IS visible (it is the handle).
  *
- * Sizes — the standard cylinder inscribes the knob: track height = thumb + 4px
- * (a 2px inset reveal each side), thumb diameter ≤ track height at every rung:
- *   sm — 12px track / 8px thumb
- *   md — 20px track / 16px thumb (default)
- *   lg — 28px track / 24px thumb
+ * Sizes — the standard cylinder is the thick glass capsule (the invisible thumb's
+ * value-follow inset still rides the size token for the 44px coarse hit-halo):
+ *   sm — 12px track
+ *   md — 20px track (default)
+ *   lg — 28px track
  */
 export declare const sliderVariants: (props?: ({
     variant?: "standard" | "spectrum" | null | undefined;

package/dist/components/ui/tabs/TabsIndicator.vue.d.ts

@@ -2,7 +2,10 @@ import { type HTMLAttributes } from "vue";
 import { type TabsIndicatorProps } from "reka-ui";
 type __VLS_Props = TabsIndicatorProps & {
     class?: HTMLAttributes["class"];
+    surface?: boolean;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    surface: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/ui/toast/use-toast.d.ts

@@ -19,7 +19,7 @@ type ToasterToast = Toast & {
     description?: string;
     action?: Component | VNode;
     open?: boolean;
-    onOpenChange?: (open: boolean) => void;
+    'onUpdate:open'?: (open: boolean) => void;
 };
 type ToastOptions = Omit<ToasterToast, 'id'>;
 declare function toast(props: ToastOptions): {
@@ -160,7 +160,7 @@ declare function useToast(): {
          | undefined;
         duration?: number | undefined;
         open?: boolean | undefined;
-        onOpenChange?: ((open: boolean) => void) | undefined;
+        'onUpdate:open'?: ((open: boolean) => void) | undefined;
     }[]>;
     toast: typeof toast;
     dismiss: (toastId?: string) => void;

package/dist/components/ui/toggle/Toggle.vue.d.ts

@@ -16,7 +16,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }>, {
     size: "default" | "sm" | "lg" | null;
-    variant: "default" | "outline" | "glass" | "card" | null;
+    variant: "default" | "outline" | "card" | null;
     disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/ui/toggle/index.d.ts

@@ -20,7 +20,7 @@ export { default as Toggle } from './Toggle.vue';
  * than re-declaring the surface at the consumer.
  */
 export declare const toggleVariants: (props?: ({
-    variant?: "default" | "outline" | "glass" | "card" | null | undefined;
+    variant?: "default" | "outline" | "card" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type ToggleVariants = VariantProps<typeof toggleVariants>;

package/dist/components/ui/toggle-group/ToggleGroup.vue.d.ts

@@ -1,16 +1,10 @@
 import { type HTMLAttributes } from 'vue';
 import { type ToggleGroupRootProps } from 'reka-ui';
-import { type ToggleGroupRegister, type ToggleGroupVariants } from './toggleGroupContext';
+import { type ToggleGroupVariants } from './toggleGroupContext';
 type __VLS_Props = ToggleGroupRootProps & {
     class?: HTMLAttributes['class'];
     variant?: ToggleGroupVariants['variant'];
     size?: ToggleGroupVariants['size'];
-    /**
-     * The MATERIAL register (E21/E23 — d-glassui M2). `register="glass"` moves
-     * every item onto the control-glass chip tier (wash-rest, quiet-on-select)
-     * without each call-site naming `variant="glass"`. An explicit `variant` wins.
-     */
-    register?: ToggleGroupRegister;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/dist/components/ui/toggle-group/ToggleGroupItem.vue.d.ts

@@ -1,12 +1,10 @@
 import { type HTMLAttributes } from 'vue';
 import { type ToggleGroupItemProps } from 'reka-ui';
-import { type ToggleGroupRegister, type ToggleGroupVariants } from './toggleGroupContext';
+import { type ToggleGroupVariants } from './toggleGroupContext';
 type __VLS_Props = ToggleGroupItemProps & {
     class?: HTMLAttributes['class'];
     variant?: ToggleGroupVariants['variant'];
     size?: ToggleGroupVariants['size'];
-    /** Per-item material register override (E21/E23). Group `register` propagates by default. */
-    register?: ToggleGroupRegister;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/dist/components/ui/toggle-group/toggleGroupContext.d.ts

@@ -10,22 +10,9 @@ import type { toggleVariants } from "../toggle";
  * `inject<ToggleGroupVariants>("toggleGroup")` pair.
  */
 export type ToggleGroupVariants = VariantProps<typeof toggleVariants>;
-/**
- * The MATERIAL register a toggle group wears (E21/E23 — d-glassui M2). `"glass"`
- * moves every item onto the control-glass chip tier (wash-rest, quiet-on-select,
- * one rung quieter than the host hull) WITHOUT each call-site opting into the
- * heavyweight `card` variant. It is the semantic chrome-tier alias for
- * `variant: "glass"`: a group-level register, not a per-item style override.
- * Omitted ⇒ the flat default register (back-compat). An EXPLICIT item/group
- * `variant` still wins over the register (the register only supplies the variant
- * when none is named).
- */
-export type ToggleGroupRegister = "glass";
 export interface ToggleGroupContext {
     variant: ToggleGroupVariants["variant"];
     size: ToggleGroupVariants["size"];
-    /** The material register (E21/E23). Resolves to `variant: "glass"` when set. */
-    register?: ToggleGroupRegister;
 }
 export declare const TOGGLE_GROUP_KEY: import("vue").InjectionKey<ToggleGroupContext>;
 export declare function provideToggleGroupContext(context: ToggleGroupContext): void;

package/dist/composables/color/index.d.ts

@@ -109,6 +109,18 @@ export interface DeriveBlobPaletteOptions {
     hueSpread?: number;
     /** Midpoint chroma-bump (keeps a vivid pair off the grey midpoint). Default ~0.03. */
     chromaBump?: number;
+    /**
+     * AY.W-COHERE E1 — the OKLCh-chroma CEILING on every derived stop (OKLCh C
+     * units). When set, each stop's chroma is clamped to AT MOST this value AFTER
+     * the midpoint bump and BEFORE the gamut-map — so the seed→palette derivation
+     * can never amplify a vivid seed into the neon register the shader's
+     * SSS/iridescence then over-drives. This is a CHROMA CAP, not a hue re-map: a
+     * blue seed stays blue, just bounded to the non-neon chroma. `undefined` (the
+     * default) leaves the derivation byte-identical to HEAD. The blob substrate
+     * caps the MOOD/seed path into the warm-register band the FourierField comet +
+     * the constellation focal share (the set-cohesion accent identity).
+     */
+    chromaCeiling?: number;
 }
 /**
  * Seed ONE color into a harmonious, gamut-safe 2-4-stop OKLCh palette for the blob

package/dist/composables/dark/index.d.ts

@@ -1,5 +1,5 @@
 export { useGlobalDark } from "./useGlobalDark";
-export type { UseGlobalDarkOptions, UseGlobalDarkReturn, DarkFlipSettledCallback, } from "./useGlobalDark";
+export type { UseGlobalDarkOptions } from "./useGlobalDark";
 export { installDarkModeSync } from "./installDarkModeSync";
 export { darkModeSyncScript, DARK_MODE_STORAGE_KEY } from "./darkModeSyncScript";
 export type { DarkModeSyncScriptOptions } from "./darkModeSyncScript";

package/dist/composables/dark/useGlobalDark.d.ts

@@ -1,15 +1,9 @@
 import type { BasicColorSchema } from "@vueuse/core";
 import { type Ref, type WritableComputedRef } from "vue";
-/**
- * A post-flip settle callback. Receives the dark-mode flag's NEW value. Runs in
- * the single coalesced post-flip task (see `onFlipSettled`).
- */
-export type DarkFlipSettledCallback = (isDark: boolean) => void;
 /**
  * The `useGlobalDark` return shape (AW.W15 — named `Use<Name>Return`). The
  * single shared dark-mode instance: the reactive `isDark` flag, a `toggleDark`
- * that optionally suppresses transitions, the transition-suppression switch, and
- * the post-flip settle hook (E9b).
+ * that optionally suppresses transitions, and the transition-suppression switch.
  */
 export interface UseGlobalDarkReturn {
     /** Reactive dark-mode flag (vueuse `useDark` ref — writable). */
@@ -20,20 +14,6 @@ export interface UseGlobalDarkReturn {
     disableTransitions: Ref<boolean>;
     /** Configure transition suppression during the dark-mode toggle. */
     setDisableTransitions: (value: boolean) => void;
-    /**
-     * E9b — the post-flip SETTLE hook. Register a callback that runs in ONE
-     * coalesced task AFTER each dark↔light flip's instant chrome paint, so
-     * consumers BATCH N expensive re-theme operations (e.g. an atlas's N-chart
-     * `merge-setOption` palette tween) into a single beat instead of N watchers
-     * firing in N sequential storms on the critical frame. The class toggle is
-     * synchronous (chrome flips instantly); the batch drains one frame later via a
-     * single `requestAnimationFrame` (an SSR/no-rAF env falls back to a macrotask).
-     * EVERY registered callback shares that ONE task — no per-subscriber scheduling.
-     * No View Transition is involved anywhere in this path (PRM-safe by
-     * construction). Returns an unsubscribe function. Idempotent re-registration
-     * of the same callback is a no-op.
-     */
-    onFlipSettled: (callback: DarkFlipSettledCallback) => () => void;
 }
 export interface UseGlobalDarkOptions {
     /**

package/dist/composables/glass/index.d.ts

@@ -1,4 +1,3 @@
-export { useGlassRenderer, createGlassFilter, destroyGlassFilter, type GlassTier, type GlassFilterState, type UseGlassRendererReturn, } from "./useGlassRenderer";
 export { useSpecularTracking } from "./useSpecularTracking";
 export type { UseSpecularTracking } from "./useSpecularTracking";
 export { useCanvas2D, useCanvasLifecycle, resolveCanvasColor } from "./canvas2d";

package/dist/composables/glass/useGlassBackdropLuminance.d.ts

@@ -0,0 +1,59 @@
+import { type Ref } from "vue";
+/** The discrete bucket the observer derives + writes (re-engages the W55 machinery). */
+export type GlassBackdropBucket = "light" | "dark";
+export interface UseGlassBackdropLuminanceOptions {
+    /**
+     * The KNOWN background-layer source for the ANIMATED case — an HTMLCanvasElement
+     * (or a getter / a CSS selector resolved against the document). When present, the
+     * observer downsamples this canvas under the surface's bounding box each settle
+     * instead of the static `elementsFromPoint` stack-walk. The aurora/blob `<canvas>`
+     * the surface floats over.
+     */
+    backgroundCanvas?: HTMLCanvasElement | (() => HTMLCanvasElement | null) | string | null;
+    /**
+     * Force the LIVE periodic re-sample loop on (mirrors the `data-glass-sample="live"`
+     * attribute on the target). Default: read from the target's
+     * `data-glass-sample === "live"` attribute. The static page case samples once on
+     * mount + resize-settle; the live case re-samples on the throttled loop.
+     */
+    live?: boolean;
+    /**
+     * The luminance threshold above which the backdrop is `light` (engages the darken).
+     * Default 0.6 — a near-white page surface (luma ≈ 0.9) is light; a dark substrate
+     * (luma ≈ 0.1) is dark; a mid aurora bleed crosses here.
+     */
+    lightThreshold?: number;
+    /**
+     * Minimum milliseconds between samples on the live loop (the ≤ 4 Hz throttle floor).
+     * Default 250 (4 Hz). Bounded ≥ 250 (the budget floor — a faster sample is the
+     * C5-9 frame-budget risk the H3 arm-(a) default-on profile must hold).
+     */
+    minSampleIntervalMs?: number;
+    /**
+     * Write the discrete `--glass-backdrop` bucket too (re-engages the @container +
+     * self-engage machinery). Default true. When false, only the numeric
+     * `--glass-backdrop-luma` is written (a continuous-strength consumer).
+     */
+    writeBucket?: boolean;
+}
+export interface UseGlassBackdropLuminanceControls {
+    /** The last sampled backdrop relative luminance (0..1), or null before the first sample. */
+    readonly luma: Readonly<Ref<number | null>>;
+    /** The last derived bucket, or null before the first sample. */
+    readonly bucket: Readonly<Ref<GlassBackdropBucket | null>>;
+    /** Force one sample now (bypasses the throttle — used on mount + resize-settle). */
+    sampleNow: () => void;
+    /** Stop the loop + detach every observer/listener. */
+    dispose: () => void;
+}
+/**
+ * The sampled-luminance observer. Wire it on a glass surface (the dock root, a
+ * content-glass panel) to write a DYNAMIC backdrop-luminance signal that refines the
+ * W55 declarative bucket. Default-on for the dock (H3 arm a); a dark-substrate consumer
+ * opts out by setting `--glass-tint-strength: 0%` on the surface (the declarative floor
+ * stays the guarantee — the observer only refines).
+ *
+ * @param target the glass surface element ref to sample under + write the tokens on
+ * @param options sampling source, throttle, threshold (see the interface)
+ */
+export declare function useGlassBackdropLuminance(target: Ref<HTMLElement | null>, options?: UseGlassBackdropLuminanceOptions): UseGlassBackdropLuminanceControls;

package/dist/composables/glass/useSpecularTracking.d.ts

@@ -21,13 +21,22 @@ import { ref, type CSSProperties } from "vue";
  *
  * PRM-aware: under `prefers-reduced-motion: reduce` the seam DOES NOT write the
  * position (the CSS half pins the catch-light static at the centred `50%`
- * fallback). The write is style-only — no reflow, no re-render — and inert until
- * the user actually moves the pointer over a wired host.
+ * fallback). The PRM signal is read from a SINGLE cached `matchMedia` listener
+ * minted once at composable setup (NOT a fresh `matchMedia` per pointer event) —
+ * the AV.W7 `useWebGLCanvas` substrate pattern.
+ *
+ * AY.W-A11Y-PERF O-3 — the pointer write is rAF-COALESCED: `onPointerMove` only
+ * stashes the raw event + schedules ONE `requestAnimationFrame`; the rAF callback
+ * does the single `getBoundingClientRect()` + style write, so a 120–1000 Hz pointer
+ * collapses to ONE batched layout read + ONE style write per animation frame (under
+ * W54 maximal-glass every blurred-surface repaint is amortized to the frame, not the
+ * event). The composable cancels the pending rAF + removes the matchMedia listener on
+ * scope dispose (cleanup discipline).
  */
 export interface UseSpecularTracking {
     /** Bind to the host element's `:style`. Carries the `--mouse-x/--mouse-y` write. */
     specularStyle: ReturnType<typeof ref<CSSProperties>>;
-    /** Bind to the host's `@pointermove`. Writes the cursor position (PRM-gated). */
+    /** Bind to the host's `@pointermove`. Schedules the rAF-coalesced position write (PRM-gated). */
     onPointerMove: (event: PointerEvent) => void;
 }
 export declare function useSpecularTracking(): UseSpecularTracking;

package/dist/composables/motion/core/index.d.ts

@@ -7,6 +7,6 @@ export * from "../useIntersectionPause";
 export * from "../useYieldToMain";
 export * from "../usePrioritizedTask";
 export * from "../useViewTransition";
-export * from "../useRouteTransition";
 export * from "../vReveal";
 export * from "../useTextHighlight";
+export * from "../useLiquidFlex";

package/dist/composables/motion/curves.d.ts

@@ -0,0 +1,48 @@
+import { type easeInQuad } from "@mkbabb/value.js";
+import { type Easing, type TimingFunction } from "@mkbabb/keyframes.js";
+/** A value.js easing callable `(t: number) => number` (the family's shape). */
+export type CurveFn = typeof easeInQuad;
+/** The kind of a `MOTION_CURVES` row — a spring `linear()` or a cubic-bezier. */
+export type MotionCurveKind = "spring" | "bezier";
+/**
+ * One row of the CSS↔JS curve table. CANONICAL rows carry their own JS twin;
+ * ALIAS rows resolve through a `canonical` target (no duplicated twin).
+ */
+export interface MotionCurve {
+    /** The CSS token name, including the leading `--`. */
+    readonly token: `--${string}`;
+    /** `spring` (a solved `linear()` token) or `bezier` (a cubic-bezier token). */
+    readonly kind: MotionCurveKind;
+    /**
+     * The JS twin — a callable `Easing` (springs, via `springTimingFunction`) or a
+     * `TimingFunction` (`(t) => number`, beziers via `CSSCubicBezier`). For ALIAS
+     * rows this is the canonical row's twin (resolve-through, not a copy).
+     */
+    readonly js: Easing | TimingFunction;
+    /**
+     * For an ALIAS row: the canonical `--token` this resolves through. `undefined`
+     * on a canonical row.
+     */
+    readonly canonical?: `--${string}`;
+    /** The register doc (springs lift it from the shared preset table). */
+    readonly note: string;
+}
+/**
+ * The CSS↔JS curve table, keyed by CSS token name. Covers EVERY `--ease-*` /
+ * `--spring-*` token declared in `tokens.css §2` + `theme.css` (CURVE-TABLE-BOUND
+ * gate §3.2). Spring rows carry a keyframes.js `Easing`; bezier rows a value.js
+ * `TimingFunction`; alias rows resolve through their `canonical` target.
+ *
+ * @example
+ *   import { MOTION_CURVES } from "@mkbabb/glass-ui/motion";
+ *   const easing = MOTION_CURVES["--spring-snappy"].js; // the iOS-control twin
+ *   new NumericAnimation(frames, { timingFunction: easing });
+ */
+export declare const MOTION_CURVES: Readonly<Record<string, MotionCurve>>;
+/** The canonical (non-alias) curve rows, in declaration order. */
+export declare const MOTION_CURVES_CANONICAL: readonly MotionCurve[];
+/** Look up a curve's JS twin by CSS token name (throws on an unknown token). */
+export declare function motionCurve(token: string): MotionCurve;
+export { linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInSine, easeOutSine, easeInOutSine, easeInCirc, easeOutCirc, easeInOutCirc, easeInExpo, easeOutExpo, easeInOutExpo, easeInBounce, CSSCubicBezier, } from "@mkbabb/value.js";
+export { SPRING_PRESETS, springPreset } from "./springPresets";
+export type { SpringPresetRow, SpringPresetName } from "./springPresets";

package/dist/composables/motion/index.d.ts

@@ -6,3 +6,5 @@ export * from "./useNumericTransition";
 export * from "./useAnimatedNumber";
 export * from "./useAnimatedNumberMap";
 export * from "./useCountup";
+export * from "./suite";
+export { SPRING_PRESETS, springPreset, type SpringPresetRow, type SpringPresetName, } from "./springPresets";