@mkbabb/glass-ui 3.13.0 → 4.0.1

package/dist/components/ui/focus-scope/FocusScope.vue.d.ts

@@ -0,0 +1,20 @@
+import { type FocusScopeProps } from 'reka-ui';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<FocusScopeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    mountAutoFocus: (event: Event) => any;
+    unmountAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<FocusScopeProps> & Readonly<{
+    onMountAutoFocus?: ((event: Event) => any) | undefined;
+    onUnmountAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, 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/ui/focus-scope/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FocusScope } from './FocusScope.vue';
+export type { FocusScopeProps, FocusScopeEmits } from 'reka-ui';

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

@@ -14,6 +14,7 @@ export * from "./data-table";
 export * from "./dialog";
 export * from "./drawer";
 export * from "./dropdown-menu";
+export * from "./focus-scope";
 export * from "./hover-card";
 export * from "./input";
 export * from "./label";
@@ -32,7 +33,6 @@ export * from "./skeleton";
 export * from "./slider";
 export * from "./switch";
 export * from "./table";
-export * from "./tabs";
 export * from "./tags-input";
 export * from "./textarea";
 export * from "./toast";

package/dist/components/ui/popover/PopoverContent.vue.d.ts

@@ -1,8 +1,10 @@
 import { type HTMLAttributes } from 'vue';
 import { type PopoverContentProps } from 'reka-ui';
+import { type Surface } from '../_shared/useSurfaceAxis';
 type __VLS_Props = PopoverContentProps & {
     class?: HTMLAttributes['class'];
     portal?: boolean;
+    surface?: Surface;
 };
 declare var __VLS_14: {}, __VLS_23: {};
 type __VLS_Slots = {} & {
@@ -26,6 +28,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
 }>, {
     align: "start" | "center" | "end";
+    surface: Surface;
     sideOffset: number;
     portal: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/progress/ProgressDefault.vue.d.ts

@@ -7,8 +7,9 @@ import { type ProgressRootProps } from "reka-ui";
  * dispatcher routes here for `variant="default"`.
  *
  * Token-read parity with the `gradient` variant (AX.W24 F1): the rail/indicator
- * colour read `--progress-track`/`--progress-fill` (fallbacks `var(--secondary)`/
- * `var(--primary)`) as Tailwind arbitrary properties — `bg-[var(--token,…)]` /
+ * colour read `--progress-track`/`--progress-fill` (fallbacks
+ * `var(--progress-track-on-glass)`/`var(--primary)`) as Tailwind arbitrary
+ * properties — `bg-[var(--token,…)]` /
  * `[background:var(--token,…)]` — NOT the `bg-secondary`/`bg-primary` utility
  * classes. A `bg-primary` utility lives in `@layer utilities`, which ALWAYS
  * outranks the `@layer components` `.glass-progress-rail` recipe regardless of

package/dist/components/ui/progress/ProgressSectioned.vue.d.ts

@@ -2,9 +2,20 @@ import { type HTMLAttributes } from "vue";
 import { type ProgressRootProps } from "reka-ui";
 import { type ProgressSegment } from "./useProgressGeometry";
 /**
- * Sectioned progress variant — the phase-bus (AB.W3.T2). Renders N colour-coded
- * cells with gradient seams between siblings; the active cell carries a spring
- * fill driven by `activeProgress` and a living catch-light sweep.
+ * Sectioned progress variant — the phase-bus (AB.W3.T2; rebuilt on a SINGLE-FILL
+ * gradient paint model at BA.W-PROGRESS-GRADIENT). The bar reads as ONE continuous
+ * blended liquid filling a frosted recessed glass channel: segment colours hold
+ * their identity across their span and blend over short transition zones at the
+ * boundaries, the active front carries the single pill cap + catch-light, and
+ * pending phases keep their real hue as a faint ghost on the track.
+ *
+ * The paint is NOT per-cell rectangles. ONE `.progress-sectioned-flow` element
+ * spans the cumulative filled extent (`filledExtentPct`, derived off the same
+ * `useProgressGeometry` cells[]) and paints ONE `linear-gradient` whose stops are
+ * the segment colours (hard stop-pairs hold each hue crisp; short soft zones at
+ * the boundaries give the blend). No screen-seam band, no internal pill caps, no
+ * dead notch. The pending remainder of the recessed track carries a faint
+ * phase-tinted ghost gradient built from the pending cells' own colours.
  *
  * The single `modelValue` is NOT the truth here — the per-cell state map is. The
  * underlying `[role="progressbar"]` reports a numeric `aria-valuenow` derived from

package/dist/components/ui/select/SelectContent.vue.d.ts

@@ -18,7 +18,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
 }>, {
     position: "item-aligned" | "popper";
     align: "start" | "center" | "end";
-    collisionPadding: number | Partial<Record<"top" | "right" | "bottom" | "left", number>>;
+    collisionPadding: number | Partial<Record<"bottom" | "left" | "right" | "top", number>>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/ui/select/SelectTrigger.vue.d.ts

@@ -2,17 +2,40 @@ import { type HTMLAttributes } from 'vue';
 import { type SelectTriggerProps } from 'reka-ui';
 type __VLS_Props = SelectTriggerProps & {
     class?: HTMLAttributes['class'];
-    /** 'default' = glass bg; 'ghost' = transparent, no border/shadow */
+    /** 'default' = the shared control REST surface (BA.W-SURFACE-AXIS scope 7 —
+     *  the `.control-surface` register every form control reads at rest, off the
+     *  prior `glass-wash` gray fork); 'ghost' = transparent, no border/shadow */
     variant?: 'default' | 'ghost';
-    /** Height register: 'default' = h-10 (byte-identical), 'sm' = h-9 (compact controls) */
-    size?: 'sm' | 'default';
+    /**
+     * The trigger register — a TWO-RANGE axis (BA.W-MENU-GLASS / BA-VJS-4 WO-3):
+     *  • HEIGHT tiers (`sm` | `default`) ride the `--control-h-*` comfort cohort
+     *    (h-9 / h-10), byte-identical to today.
+     *  • FONT-RUNG tiers (`display` | `audacious`) WRITE the shared picker-family
+     *    `--dropdown-text` token on the Select SCOPE (inline style), so the
+     *    trigger, the SelectValue, AND the item rows re-resolve at ONE scale off
+     *    the ONE documented lever (`offsets-sizing.css` — the items read
+     *    `--dropdown-text` via `menuItemVariants`' `text-dropdown` base). This is
+     *    the fix for the value.js trigger-only `text-display` desync (a 1.59×
+     *    trigger/items break): a consumer scaling the picker font reaches for the
+     *    PROP, which sets the FAMILY token, NOT a trigger-local `text-*` class that
+     *    leaves the items behind. The font rung carries a height too so the box
+     *    grows with the type. The height tiers stay; the font rung is ADDITIVE
+     *    (a consumer who never sets it keeps today's resolved sizes).
+     *
+     *  NOTE on the portal: `<SelectContent>` PORTALS to body, so the inline
+     *  `--dropdown-text` on the trigger reaches the trigger/value/chevron directly;
+     *  the items re-resolve when the consumer also threads the rung on the shared
+     *  Select scope (the documented family lever). For a single self-scaling
+     *  trigger the rung scales the visible trigger silhouette.
+     */
+    size?: 'sm' | 'default' | 'display' | 'audacious';
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    size: "sm" | "default";
+    size: "sm" | "default" | "display" | "audacious";
     variant: "default" | "ghost";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/ui/sheet/SheetContent.vue.d.ts

@@ -2,9 +2,15 @@ import { type HTMLAttributes } from 'vue';
 import { type DialogContentProps } from 'reka-ui';
 import { type SheetVariants } from '.';
 import { type SpringPreset } from '../../../composables/motion/useSpringMount';
+import { type Surface } from '../_shared/useSurfaceAxis';
 interface SheetContentProps extends DialogContentProps {
     class?: HTMLAttributes['class'];
     side?: SheetVariants['side'];
+    /** Surface decoration register (BA.W-SURFACE-AXIS) — the SHARED
+     *  {glass·veil·opaque} axis. `glass` (default) renders the floating glass tier
+     *  sheetVariants already bakes; `veil` overlays the borderless text-legibility
+     *  plate; `opaque` sets `--glass-level:0` (the solid-card escape). */
+    surface?: Surface;
     /**
      * Opt into iOS spring-physics entrance via `useSpringMount` (W13). When
      * truthy, the sheet slides from off-edge via a `useSpring`-driven

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

@@ -8,6 +8,6 @@ export { default as SheetTitle } from './SheetTitle.vue';
 export { default as SheetDescription } from './SheetDescription.vue';
 export { default as SheetFooter } from './SheetFooter.vue';
 export declare const sheetVariants: (props?: ({
-    side?: "top" | "right" | "bottom" | "left" | null | undefined;
+    side?: "bottom" | "left" | "right" | "top" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type SheetVariants = VariantProps<typeof sheetVariants>;

package/dist/components/ui/skeleton/Skeleton.vue.d.ts

@@ -21,12 +21,15 @@ import type { HTMLAttributes } from 'vue';
  * (opacity-min) — the surface still reads but no longer cycles.
  */
 type SkeletonVariant = 'pulse' | 'shimmer' | 'breath';
+type SkeletonSurface = 'glass' | 'opaque';
 type __VLS_Props = {
     variant?: SkeletonVariant;
+    surface?: SkeletonSurface;
     class?: HTMLAttributes['class'];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     variant: SkeletonVariant;
+    surface: SkeletonSurface;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/ui/tags-input/TagsInput.vue.d.ts

@@ -8,13 +8,13 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (payload: import("reka-ui").AcceptableInputValue[]) => any;
     invalid: (payload: import("reka-ui").AcceptableInputValue) => any;
+    "update:modelValue": (payload: import("reka-ui").AcceptableInputValue[]) => any;
     addTag: (payload: import("reka-ui").AcceptableInputValue) => any;
     removeTag: (payload: import("reka-ui").AcceptableInputValue) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableInputValue[]) => any) | undefined;
     onInvalid?: ((payload: import("reka-ui").AcceptableInputValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableInputValue[]) => any) | undefined;
     onAddTag?: ((payload: import("reka-ui").AcceptableInputValue) => any) | undefined;
     onRemoveTag?: ((payload: import("reka-ui").AcceptableInputValue) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/toast/Toast.vue.d.ts

@@ -1,18 +1,20 @@
 import { type HTMLAttributes } from 'vue';
 import { type ToastRootProps } from 'reka-ui';
+import { type Surface } from '../_shared/useSurfaceAxis';
 import type { ToastVariant } from './use-toast';
 interface ToastProps extends ToastRootProps {
     class?: HTMLAttributes['class'];
     variant?: ToastVariant;
+    surface?: Surface;
 }
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    pause: () => any;
     "update:open": (value: boolean) => any;
     escapeKeyDown: (event: KeyboardEvent) => any;
-    pause: () => any;
     resume: () => any;
     swipeStart: (event: {
         currentTarget: EventTarget & HTMLElement;
@@ -51,9 +53,9 @@ declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {},
         };
     }>, "currentTarget">) => any;
 }, string, import("vue").PublicProps, Readonly<ToastProps> & Readonly<{
+    onPause?: (() => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
-    onPause?: (() => any) | undefined;
     onResume?: (() => any) | undefined;
     onSwipeStart?: ((event: {
         currentTarget: EventTarget & HTMLElement;
@@ -93,6 +95,7 @@ declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {},
     }>, "currentTarget">) => any) | undefined;
 }>, {
     variant: ToastVariant;
+    surface: Surface;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

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

@@ -1,4 +1,5 @@
 import type { Component, VNode } from 'vue';
+import type { Surface } from '../_shared/useSurfaceAxis';
 export type ToastVariant = 'default' | 'destructive' | 'success' | 'warning' | 'info';
 export interface Toast {
     id: string;
@@ -6,6 +7,12 @@ export interface Toast {
     description?: string;
     action?: Component | VNode;
     variant?: ToastVariant;
+    /**
+     * BB.W-SURFACE-AXIS-COMPLETE — the shared {glass·veil·opaque} surface-decoration
+     * axis on a queued toast (default `glass`). Forwarded through `Toaster.vue`'s
+     * per-toast `v-bind` exactly like `variant`; orthogonal to the tone arm.
+     */
+    surface?: Surface;
     /**
      * Auto-dismiss delay in ms, forwarded to reka-ui's `ToastRoot`. Omit to
      * inherit the `ToastProvider` default; `Number.POSITIVE_INFINITY` keeps the
@@ -152,6 +159,13 @@ declare function useToast(): {
             __name?: string | undefined;
         } | undefined;
         variant?: ToastVariant
+        /**
+         * BB.W-SURFACE-AXIS-COMPLETE — the shared {glass·veil·opaque} surface-decoration
+         * axis on a queued toast (default `glass`). Forwarded through `Toaster.vue`'s
+         * per-toast `v-bind` exactly like `variant`; orthogonal to the tone arm.
+         */
+         | undefined;
+        surface?: Surface
         /**
          * Auto-dismiss delay in ms, forwarded to reka-ui's `ToastRoot`. Omit to
          * inherit the `ToastProvider` default; `Number.POSITIVE_INFINITY` keeps the

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

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

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

@@ -1,5 +1,5 @@
 export { useGlobalDark } from "./useGlobalDark";
-export type { UseGlobalDarkOptions } from "./useGlobalDark";
+export type { UseGlobalDarkOptions, UseGlobalDarkReturn, DarkFlipSettledCallback, } 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,9 +1,15 @@
 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, and the transition-suppression switch.
+ * that optionally suppresses transitions, the transition-suppression switch, and
+ * the post-flip settle hook (BA.W-ATLAS-RECONCILE A-1 — d6 9467bd16 adopt).
  */
 export interface UseGlobalDarkReturn {
     /** Reactive dark-mode flag (vueuse `useDark` ref — writable). */
@@ -14,6 +20,22 @@ export interface UseGlobalDarkReturn {
     disableTransitions: Ref<boolean>;
     /** Configure transition suppression during the dark-mode toggle. */
     setDisableTransitions: (value: boolean) => void;
+    /**
+     * BA.W-ATLAS-RECONCILE A-1 — 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. the atlas's
+     * palette memo + N-chart `merge-setOption` palette tween + aurora
+     * re-derivation) 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 — a flip is a CSS-class swap, not a DOM mutation to
+     * snapshot). 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/canvas2d/useCanvas2D.d.ts

@@ -1,6 +1,12 @@
 import { type MaybeRefOrGetter } from "vue";
-/** The suspend reasons that gate the loop. Twins the WebGL substrate's union. */
-export type Canvas2DSuspendReason = "tab-hidden" | "off-screen" | "manual";
+/**
+ * The suspend reasons that gate the loop. Twins the WebGL substrate's union
+ * (`createCanvasLifecycle.CanvasSuspendReason`): the AX.W16 F6 `"off-screen-io"`
+ * key is the IntersectionObserver fallback's OWN reason, distinct from the
+ * content-visibility path's `"off-screen"`, so the two offscreen detectors never
+ * cross-lift each other's suspend.
+ */
+export type Canvas2DSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
 /** The per-frame hooks a consumer's `setup(ctx)` returns. */
 export interface Canvas2DFrame {
     /**
@@ -47,10 +53,11 @@ export interface Canvas2DHandle {
 }
 /**
  * The Canvas2D lifecycle substrate — the park/freeze/dispose twin of
- * `useWebGLCanvas`. Returns an imperative {@link Canvas2DHandle} (the same
- * handle idiom the WebGL twin uses — an imperative canvas seam is NOT a
- * ref-bundle). `useCanvasLifecycle` is the alias-of-record for the
- * lifecycle-only framing; both name the same factory.
+ * `useWebGLCanvas`, a thin Canvas2D backend over the shared
+ * `createCanvasLifecycle` core. Returns an imperative {@link Canvas2DHandle} (the
+ * same handle idiom the WebGL twin uses — an imperative canvas seam is NOT a
+ * ref-bundle). `useCanvasLifecycle` is the alias-of-record for the lifecycle-only
+ * framing; both name the same factory.
  */
 export declare function useCanvas2D(options: Canvas2DOptions): Canvas2DHandle;
 /**

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

@@ -1,4 +1,7 @@
-export { useSpecularTracking } from "./useSpecularTracking";
-export type { UseSpecularTracking } from "./useSpecularTracking";
+export { useSpecularTracking, createSpecularWriter, } from "./useSpecularTracking";
+export type { UseSpecularTracking, SpecularWriter, } from "./useSpecularTracking";
+export { vSpecular } from "./vSpecular";
+export { useSpecularPointer } from "./useSpecularPointer";
+export type { UseSpecularPointer } from "./useSpecularPointer";
 export { useCanvas2D, useCanvasLifecycle, resolveCanvasColor } from "./canvas2d";
 export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./canvas2d";

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

@@ -0,0 +1,33 @@
+import { ref, type CSSProperties } from "vue";
+/**
+ * `useSpecularPointer` — the EVOLUTION of `useSpecularTracking` (BB.W-LENSING). It
+ * writes the catch-light POSITION (`--mouse-x`/`--mouse-y`, as today) PLUS the
+ * `--specular-angle` channel — the pointer's angle-from-center the EDGE-glint conic
+ * sweep reads (the `.glass-material::before` recipe, material.css). The angle feed is
+ * what turns the centered disc into a motion-reactive RIM glint (the glass-THICKNESS
+ * read); the leaf is the ONE shared specular source the hover/button waves consume.
+ *
+ * SINGLE-SOURCE (the W-LIQUIDHOVER reconcile, EXTENDED here — NOT a fork). There is
+ * exactly ONE position-write core: `createSpecularWriter` (useSpecularTracking.ts) —
+ * the rAF-coalesced, cached-PRM, scope-dispose seam. This composable WRAPS that core;
+ * the angle is DERIVED in the sink from the SAME `(x, y)` percentage the core already
+ * computes (`angle = atan2(y - 50, x - 50)`), so there is NO duplicate
+ * `getBoundingClientRect` / `--mouse-x` write — the core owns the layout read + the
+ * coordinate math, this leaf only adds the angle derivation onto the existing sink.
+ * `useSpecularTracking` (the position-only delivery) STAYS for the bare-position call
+ * sites; `useSpecularPointer` is the angle-adding delivery for an edge-glint consumer.
+ * Both wrap the ONE core — never two copies of the rAF/PRM/coordinate logic.
+ *
+ * PRM-aware by construction (the wrapped core skips the write under
+ * `prefers-reduced-motion: reduce` — the CSS bracket pins `--specular-x/y` to the
+ * centred 50% and `--specular-angle` to its `0deg` static rest). The composable
+ * disposes the core (cancel the pending rAF + drop the cached PRM listener) on scope
+ * teardown.
+ */
+export interface UseSpecularPointer {
+    /** Bind to the host element's `:style`. Carries `--mouse-x/--mouse-y` + `--specular-angle`. */
+    specularStyle: ReturnType<typeof ref<CSSProperties>>;
+    /** Bind to the host's `@pointermove`. Schedules the rAF-coalesced position+angle write (PRM-gated). */
+    onPointerMove: (event: PointerEvent) => void;
+}
+export declare function useSpecularPointer(): UseSpecularPointer;

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

@@ -32,6 +32,13 @@ import { ref, type CSSProperties } from "vue";
  * 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).
+ *
+ * BB.W-LIQUIDHOVER — the rAF-coalesce + cached-PRM + cleanup LOGIC is extracted to
+ * `createSpecularWriter()`, the SINGLE position-write core. The composable below wraps
+ * it for the Vue `:style`-ref case (Card's prop-gated `specular` opt-in); the
+ * tier-root auto-arm (`vSpecular`) wraps the SAME core to write directly on the
+ * directive host's `el.style` (the zero-wiring delivery). ONE position-write source,
+ * TWO deliveries — never a re-pasted handler.
  */
 export interface UseSpecularTracking {
     /** Bind to the host element's `:style`. Carries the `--mouse-x/--mouse-y` write. */
@@ -39,4 +46,17 @@ export interface UseSpecularTracking {
     /** Bind to the host's `@pointermove`. Schedules the rAF-coalesced position write (PRM-gated). */
     onPointerMove: (event: PointerEvent) => void;
 }
+/**
+ * The SINGLE position-write core (BB.W-LIQUIDHOVER) — the rAF-coalesced,
+ * PRM-aware `--mouse-x/y` write seam, sink-agnostic. `sink(x, y)` receives the
+ * percentage position once per animation frame; the composable sinks into its
+ * `specularStyle` ref, the `vSpecular` directive sinks into `el.style.setProperty`.
+ * Returns the event handler + a `dispose` (cancel the pending rAF + drop the cached
+ * PRM listener) so BOTH deliveries share ONE cleanup discipline.
+ */
+export interface SpecularWriter {
+    onPointerMove: (event: PointerEvent) => void;
+    dispose: () => void;
+}
+export declare function createSpecularWriter(sink: (xPct: number, yPct: number) => void): SpecularWriter;
 export declare function useSpecularTracking(): UseSpecularTracking;

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

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from "vue";
+export declare const vSpecular: ObjectDirective<HTMLElement, boolean | undefined>;

package/dist/composables/glass/webgl/shaders/flow.glsl.d.ts

@@ -0,0 +1 @@
+export declare const CURL_FBM_GLSL = "\nconst float CURL_EPS = 0.012;\n\n// Scalar fbm potential psi \u2014 the host's noise basis, wrapped so the curl operator is\n// basis-agnostic. A host carrying its own fbm defines this as: return fbm(p);\nfloat potentialFBM(vec2 p);\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nvec2 curlFBM(vec2 p) {\n  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));\n  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);\n  return vec2(g.y, -g.x);\n}\n";

package/dist/composables/glass/webgl/useWebGLCanvas.d.ts

@@ -1,3 +1,19 @@
+/**
+ * The ONE `getContext("webgl2")` capability probe (BB.W-CI-GREEN — the
+ * single-bootstrap rule). A throwaway WebGL2 context is created here, in the
+ * substrate (the sole webgl2-creating module per `proof:webgl-substrate-single`),
+ * so a consumer feature-detecting WebGL2 / reading the unmasked renderer string
+ * NEVER creates a second context of its own. The probe canvas is detached, its
+ * context released via `WEBGL_lose_context` under the per-page context cap; the
+ * read is one-shot (a mount-time device-tier decision, not a reactive one).
+ *
+ * Returns the lower-cased `UNMASKED_RENDERER_WEBGL` string (e.g.
+ * `"google swiftshader"`), or `null` when WebGL2 / the debug-renderer extension
+ * is unavailable or the probe throws — the caller treats `null` as "cannot prove"
+ * (the conservative-but-lossy fall-back). SSR-safe (returns `null` with no
+ * `document`).
+ */
+export declare function probeWebGL2Renderer(): string | null;
 export type WebGLSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
 /** The per-frame hooks a consumer's `setup(gl)` returns. */
 export interface WebGLCanvasFrame {

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

@@ -0,0 +1,2 @@
+export { createWebGPUCanvas, supportsWebGPU, type WebGPUCanvasFrame, type WebGPUCanvasHandle, type WebGPUCanvasOptions, type WebGPUSuspendReason, } from "./useWebGPUCanvas";
+export { createGpuSubstrate, type GpuBackend, type GpuSubstrateHandle, type GpuSubstrateOptions, } from "./useGpuSubstrate";

package/dist/composables/glass/webgpu/useGpuSubstrate.d.ts

@@ -0,0 +1,54 @@
+import { type WebGLCanvasFrame, type WebGLCanvasOptions } from "../webgl/useWebGLCanvas";
+import { supportsWebGPU, type WebGPUCanvasFrame, type WebGPUCanvasOptions } from "./useWebGPUCanvas";
+export { supportsWebGPU };
+/** Which backend the picker resolved. */
+export type GpuBackend = "webgpu" | "webgl2";
+export interface GpuSubstrateOptions {
+    /** `"capture"` → renderAt-only (no auto-loop). Default `"live"`. */
+    mode?: "live" | "capture";
+    /** Honor `prefers-reduced-motion: reduce` (one static frame then park). Default `true`. */
+    respectReducedMotion?: boolean;
+    /**
+     * The WGSL pipeline builder (the WebGPU primary path). Omitting it forces the
+     * WebGL2 fallback even where WebGPU is supported (a viz with no WGSL path yet).
+     */
+    setupWGPU?: WebGPUCanvasOptions["setup"];
+    /** The GLSL program builder (the WebGL2 fallback path — always required). */
+    setupGL: WebGLCanvasOptions["setup"];
+    /** WebGPU `context.configure` alpha mode (default `"premultiplied"`). */
+    alphaMode?: WebGPUCanvasOptions["alphaMode"];
+    /** WebGPU adapter/device request options. */
+    adapterOptions?: WebGPUCanvasOptions["adapterOptions"];
+    deviceDescriptor?: WebGPUCanvasOptions["deviceDescriptor"];
+    /** WebGL2 `getContext("webgl2", …)` attributes. */
+    contextAttrs?: WebGLCanvasOptions["contextAttrs"];
+    /** Surface a device-init / validation failure (the WebGPU path). */
+    onInitError?: WebGPUCanvasOptions["onInitError"];
+}
+/**
+ * The uniform substrate handle. A viz consumer wires its lifecycle (offscreen pause,
+ * pause/resume, pointer-`wake`, capture-`renderAt`) against THIS — identical across the
+ * WebGPU and WebGL2 backends. `armAsync` is the start seam (the WebGPU path awaits the
+ * device; the WebGL2 path resolves immediately); `arm` is the synchronous twin.
+ */
+export interface GpuSubstrateHandle {
+    /** The resolved backend (`"webgpu"` where supported + a WGSL path is provided, else `"webgl2"`). */
+    readonly backend: GpuBackend;
+    /** Acquire the device/context + `setup` + arm the loop. Resolves once armed. */
+    armAsync: () => Promise<void>;
+    /** Synchronous arm (the WebGL2 path arms immediately; the WebGPU path is a no-op until the device resolves). */
+    arm: () => void;
+    suspend: (reason?: "tab-hidden" | "off-screen" | "off-screen-io" | "manual") => void;
+    resume: (reason?: "tab-hidden" | "off-screen" | "off-screen-io" | "manual") => void;
+    wake: () => void;
+    renderAt: (timeSec: number) => void;
+    dispose: () => void;
+    readonly reducedMotion: boolean;
+}
+/**
+ * Pick the backend + return the uniform handle. WebGPU-first (`supportsWebGPU()` AND a
+ * `setupWGPU` callback is provided); otherwise the WebGL2 fallback. The decision is
+ * made ONCE at construction (a mount-time device-tier choice, not a reactive one).
+ */
+export declare function createGpuSubstrate(canvas: HTMLCanvasElement, options: GpuSubstrateOptions): GpuSubstrateHandle;
+export type { WebGPUCanvasFrame, WebGLCanvasFrame };