@mkbabb/glass-ui 3.7.0 → 3.9.0

package/dist/components/custom/tabs/SegmentedTabs.vue.d.ts

@@ -0,0 +1,92 @@
+import { type HTMLAttributes } from "vue";
+/** The canonical tab/option shape — one descriptor across all three variants. */
+export interface SegmentedTabOption {
+    label: string;
+    value: string;
+    icon?: string;
+    disabled?: boolean;
+    tooltip?: string;
+}
+/** The three indicator chromes. `segmented` (default) = the muted pill-slider;
+ *  `pill` = the solid `--foreground` pill; `underline` = the hairline rule. */
+export type SegmentedTabsVariant = "segmented" | "pill" | "underline";
+export interface SegmentedTabsResponsive {
+    /**
+     * CSS length consumed inside `(min-width: <breakpoint>)`. BELOW it the
+     * strip collapses to a `<Select>`; at/above it renders the tab strip.
+     * Defaults to `"640px"` (Tailwind `sm:`).
+     */
+    breakpoint?: string;
+    /**
+     * Optional subset shown in the desktop strip (the mobile Select keeps the
+     * full option list). Falls back to `options`.
+     */
+    desktopOptions?: SegmentedTabOption[] | null;
+    /** Accessible name for the mobile `<SelectTrigger>`. */
+    ariaLabel?: string;
+    /** Class merged onto the mobile `<SelectTrigger>` only. */
+    triggerClass?: HTMLAttributes["class"];
+}
+export interface SegmentedTabsProps {
+    options: SegmentedTabOption[];
+    /**
+     * Indicator chrome — `segmented` (DEFAULT, the pill-slider over a muted
+     * track), `pill` (solid foreground pill), `underline` (the hairline rule).
+     */
+    variant?: SegmentedTabsVariant;
+    /**
+     * Multi-select — when true the surface mutates as a ToggleGroup (N
+     * simultaneous pressed buttons, `role="group"`). Only valid on the
+     * `segmented`/`pill` variants; `underline` is panel-nav (single-select).
+     */
+    multiSelect?: boolean;
+    /**
+     * Tab-row overflow handling.
+     * - `"none"` (default) — inline-grid; tabs share width and clip.
+     * - `"scroll"` — flex row with intrinsic widths + edge fades; never clips.
+     * - `"auto"` — flex row with intrinsic widths + plain horizontal scroll.
+     */
+    overflow?: "none" | "scroll" | "auto";
+    /**
+     * Responsive collapse — below the breakpoint the strip becomes a `<Select>`
+     * (subsumes the former standalone ResponsiveTabs). `true` uses defaults;
+     * an object tunes the breakpoint / desktop subset / accessible name.
+     */
+    responsive?: boolean | SegmentedTabsResponsive;
+    class?: HTMLAttributes["class"];
+}
+type __VLS_Props = SegmentedTabsProps;
+type __VLS_ModelProps = {
+    modelValue: string | string[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_50: {
+    option: SegmentedTabOption;
+    active: boolean;
+}, __VLS_58: {
+    option: SegmentedTabOption;
+    active: boolean;
+};
+type __VLS_Slots = {} & {
+    option?: (props: typeof __VLS_50) => any;
+} & {
+    option?: (props: typeof __VLS_58) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | string[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+}>, {
+    overflow: "none" | "scroll" | "auto";
+    variant: SegmentedTabsVariant;
+    responsive: boolean | SegmentedTabsResponsive;
+    multiSelect: boolean;
+}, {}, {}, {}, 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/tabs/composables/useTabIndicator.d.ts

@@ -0,0 +1,49 @@
+import { type Ref, type ComputedRef } from "vue";
+import type { SegmentedTabOption } from "../SegmentedTabs.vue";
+/**
+ * Package-private composable for `SegmentedTabs.vue` — owns the JS-measured
+ * indicator path: the single- and multi-select slider styles, the offset
+ * measure, the model/options re-measure watchers, and the ResizeObserver
+ * lifecycle. It ALSO owns the AX.W53 travel-squish: a velocity-driven,
+ * volume-preserving `--stretch` scalar the active indicator reads so it
+ * STRETCHES along its travel axis as it glides between tabs and settles to fit
+ * (the Material 3 ELASTIC / Apple Liquid-Glass register, capped LOW).
+ *
+ * The composable is the SOLE writer of the JS slider styles. The measure path
+ * runs only on the multi-select OR `@supports not (anchor)` branch — on an
+ * anchor-supporting single-select engine the CSS `anchor-name` owns the slider
+ * position and that path stays dormant (no RO is constructed, no measure runs).
+ * The squish is independent of the position path: it is a transient `--stretch`
+ * write driven on EVERY selection (anchor or JS engine) and reads from
+ * `--tab-indicator-max-stretch`, so the elastic warp lands on all three
+ * variants. Honors `prefers-reduced-motion` (no squish under reduce).
+ */
+export interface UseTabIndicatorParams {
+    /** The container scroller root (observed by the ResizeObserver). */
+    containerRef: Ref<HTMLElement | null>;
+    /** The active indicator element (the squish `--stretch` write target). */
+    indicatorRef: Ref<HTMLElement | null>;
+    /** Per-option button refs, index-aligned to `options`. */
+    buttonRefs: Ref<HTMLElement[]>;
+    /** The tab options (re-measure on change). */
+    options: ComputedRef<SegmentedTabOption[]>;
+    /** The defineModel value (re-measure on change). */
+    model: Ref<string | string[] | undefined>;
+    /** True for the multi-select path. */
+    multiSelect: ComputedRef<boolean>;
+    /** Whether the browser supports CSS anchor positioning. */
+    anchorSupported: boolean;
+    /** True when ANY JS slider writer is live (gates RO/watcher attach). */
+    jsSliderActive: ComputedRef<boolean>;
+    /** The active option values (used by the multi-slider measure). */
+    activeValues: ComputedRef<string[]>;
+}
+export interface UseTabIndicatorReturn {
+    /** Inline style for the single-select JS slider. */
+    singleSliderStyle: Ref<Record<string, string>>;
+    /** Inline styles for each active multi-select slider, keyed by value. */
+    multiSliderStyles: Ref<Record<string, Record<string, string>>>;
+    /** Imperatively kick the travel-squish on a selection at `idx`. */
+    squishOnTravel: (toIdx: number) => void;
+}
+export declare function useTabIndicator(params: UseTabIndicatorParams): UseTabIndicatorReturn;

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

@@ -1,5 +1,2 @@
-export { default as UnderlineTabs } from "./UnderlineTabs.vue";
-export { default as BouncyTabs } from "./BouncyTabs.vue";
-export { default as BouncyToggle } from "./BouncyToggle.vue";
-export type { TabOption } from "./UnderlineTabs.vue";
-export type { ToggleOption, BouncyToggleProps } from "./BouncyToggle.vue";
+export { default as SegmentedTabs } from "./SegmentedTabs.vue";
+export type { SegmentedTabOption, SegmentedTabsVariant, SegmentedTabsProps, SegmentedTabsResponsive, } from "./SegmentedTabs.vue";

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

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 export { default as Button } from './Button.vue';
 export declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | null | undefined;
+    variant?: "link" | "default" | "solid" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | null | undefined;
     size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type ButtonVariants = VariantProps<typeof buttonVariants>;

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

@@ -1,16 +1,18 @@
 import { type HTMLAttributes } from "vue";
 import { type PrimitiveProps } from "reka-ui";
 /**
- * The five-tier glass surface ladder. Maps 1:1 to `.glass-{tier}` in glass.css
- * after the v0.8.0 R3-spec rename:
+ * The glass surface ladder. Maps 1:1 to `.glass-{tier}` in glass.css after the
+ * v0.8.0 R3-spec rename:
  *
  *   wash     — lightest (~0.30α)        : inline workspace chrome, scroll-pane host
  *   quiet    — light    (~0.50α)        : ambient panels, secondary surfaces
  *   resting  — canonical (~0.65α)       : the protagonist plate (default)
  *   floating — heavy   (~0.80α)         : popover-class, login surfaces
  *   overlay  — heaviest (~0.95α + blur) : modal-on-modal, dialog over content
+ *   opaque   — `--glass-level:0` escape : the solid-card opt-out (AX.W54), maps to
+ *              `.glass-opaque` through the same `glass-${tier}` rung as the rest
  */
-export type CardTier = "wash" | "quiet" | "resting" | "floating" | "overlay";
+export type CardTier = "wash" | "quiet" | "resting" | "floating" | "overlay" | "opaque";
 /**
  * Surface decoration register — orthogonal to `tier`/`shadow`/`grain`.
  *
@@ -20,6 +22,21 @@ export type CardTier = "wash" | "quiet" | "resting" | "floating" | "overlay";
  *              ANY tier; the retired `<CartoonCard>` was `tier="quiet" surface="cartoon"`.
  */
 export type CardSurface = "glass" | "cartoon";
+/**
+ * Specular catch-light register (AX.W09) — the pointer-anchored moving lens on a
+ * glass card.
+ *
+ *   off    — NO catch-light (default). The clean resting panel: a data/content
+ *            `surface="glass"` card over any backplate reads flat — no centred
+ *            white bloom, no pointer wiring. The §24 three-consumer-confirmed
+ *            default for the common content-card case.
+ *   subtle — the token-ladder lens: the pointer-anchored catch-light wakes on
+ *            hover/active at the SUBTLE `--glass-specular-intensity-*` magnitudes.
+ *            The explicit opt-in for a hero/chrome surface.
+ *   full   — the brighter pre-tune rung set, for the busy-backdrop case the recipe
+ *            was originally authored over (a local intensity-token override).
+ */
+export type CardSpecular = "off" | "subtle" | "full";
 interface Props extends PrimitiveProps {
     /** Surface tier; selects one rung of the glass ladder. Default `resting`. */
     tier?: CardTier;
@@ -33,12 +50,13 @@ interface Props extends PrimitiveProps {
     /** `::after` paper-grain overlay. Off for scroll panes (the grain conflicts
      *  with overflow:auto repaints). */
     grain?: boolean;
-    /** Opt-in interactive register (AW.W24). A glass card with `hover` wakes the
-     *  dormant pointer-anchored specular catch-light: it tracks the cursor across
-     *  the surface (the AV.W15 moving-glass illuminate) instead of the centred
-     *  var() floor. Static cards (default) keep the centred catch-light and never
-     *  attach the listener. `cartoon` surfaces own their own sticker lift. */
-    hover?: boolean;
+    /** Specular catch-light register (AX.W09). `off` (default) keeps the card
+     *  CLEAN — no pointer-anchored lens, clean over any backplate (the §24
+     *  three-consumer-confirmed default for a data/content card). `subtle` wakes
+     *  the pointer-anchored moving catch-light at the token-ladder magnitudes (a
+     *  hero/chrome opt-in); `full` runs the brighter pre-tune rung set for a busy
+     *  backdrop. Only `glass` surfaces wire it; `cartoon` owns its own sticker lift. */
+    specular?: CardSpecular;
     class?: HTMLAttributes["class"];
 }
 declare var __VLS_10: {};
@@ -51,7 +69,7 @@ declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, i
     tier: CardTier;
     surface: CardSurface;
     grain: boolean;
-    hover: boolean;
+    specular: CardSpecular;
 }, {}, {}, {}, 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/card/index.d.ts

@@ -1,4 +1,4 @@
-export { default as Card, type CardTier, type CardSurface } from "./Card.vue";
+export { default as Card, type CardTier, type CardSurface, type CardSpecular, } from "./Card.vue";
 export { default as CardHeader } from "./CardHeader.vue";
 export { default as CardTitle } from "./CardTitle.vue";
 export { default as CardDescription } from "./CardDescription.vue";

package/dist/components/ui/carousel/CarouselNext.vue.d.ts

@@ -10,7 +10,7 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     size: "default" | "xs" | "sm" | "lg" | "icon" | "icon-sm" | null;
-    variant: "link" | "default" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | null;
+    variant: "link" | "default" | "solid" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | 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/components/ui/carousel/CarouselPrevious.vue.d.ts

@@ -10,7 +10,7 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     size: "default" | "xs" | "sm" | "lg" | "icon" | "icon-sm" | null;
-    variant: "link" | "default" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | null;
+    variant: "link" | "default" | "solid" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | 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/components/ui/carousel/GlassCarouselPager.vue.d.ts

@@ -2,14 +2,13 @@ import type { HTMLAttributes } from "vue";
 /**
  * GlassCarouselPager — audacious carousel pager substrate.
  *
- * Lifts the hand-rolled chevron-prev + counter-pill + chevron-next + state-toggle
- * row from `containers/glass-carousel.vue:127-157` into a canonical primitive.
+ * A canonical chevron-prev + counter-pill + chevron-next + state-toggle row.
  * Composes `<Button variant="outline" size="icon">` chevrons with a glass-card
  * counter pill and an optional toggle slot for collapse/expand affordances.
  *
  * Standalone: accepts `:index` / `:total` props and emits `@prev` / `@next` /
- * `@select(i)`, so it composes equally with `<GlassCarousel>` (manual state) and
- * `<Carousel>` (embla — wire via `useCarousel`).
+ * `@select(i)`, so it composes with `<Carousel>` (embla — wire via
+ * `useCarousel`) or any manual-state host.
  */
 type __VLS_Props = {
     /** Current zero-based slide index. */

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

@@ -1,10 +1,20 @@
 import { type HTMLAttributes } from "vue";
 import { type ProgressRootProps } from "reka-ui";
 /**
- * Default progress variant — `bg-secondary` rail + `bg-primary` indicator with a
- * `translateX(-%)` intake-pulse. The plainest rung; no lifecycle motion grammar
- * (that lives on the gradient variant). The thin `Progress` dispatcher routes
- * here for `variant="default"`.
+ * Default progress variant — a `--progress-track` rail + a `--progress-fill`
+ * indicator with a `translateX(-%)` intake-pulse. The plainest rung; no lifecycle
+ * motion grammar (that lives on the gradient variant). The thin `Progress`
+ * 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,…)]` /
+ * `[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
+ * source order, so a `:root { --progress-fill }` (or `.glass-progress-rail`'s
+ * token-set) override was a silent no-op on the default variant. Reading the token
+ * at source makes the `default` variant token-retintable for EVERY consumer.
  */
 type __VLS_Props = ProgressRootProps & {
     class?: HTMLAttributes["class"];

package/dist/components/ui/slider/Slider.vue.d.ts

@@ -21,6 +21,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((payload: number[] | undefined) => any) | undefined;
     onValueCommit?: ((payload: number[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    keepDockOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -9,15 +9,22 @@ export { default as Slider } from './Slider.vue';
  * `.slider-thumb` paint. The size axis lifts pure geometry via CSS vars
  * (`--slider-track-height`, `--slider-thumb-size`) the SFC defaults read.
  *
- * Exactly two canonical recipes ship:
- *   standard — the continuous rounded iOS knob: a fully-circular, borderless
- *              thumb that sits in the track and reads as a swelling of the
- *              capsule, with halo-on-state and the iOS press spring. This is
- *              the general-purpose glass-scrubber knob and the default.
- *   spectrum — the gradient-track color slider: a tall capsule whose
+ * Exactly two canonical recipes ship (AX.W59 redesign):
+ *   standard — the INTEGRATED-CYLINDER glass slider: the fill is ONE
+ *              continuous glass rounded-pill (W52 backdrop + edge rim, tinted
+ *              to `--primary`) pulled left/right; its rounded LEADING edge IS
+ *              the grab. There is NO visible demarcation between thumb and
+ *              fill — the reka SliderThumb stays mounted (a11y/keyboard/focus)
+ *              but is styled as the cylinder's slim leading CAP (a faint
+ *              specular grip, not a detached circle). Halo-on-state + the iOS
+ *              press spring. 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
- *              small ringed knob that reads against any track hue. This is the
+ *              SQUIRCLE thumb the HEIGHT of the track (the iOS color-picker
+ *              idiom — `corner-shape: superellipse()` via `--corner-shape-thumb`,
+ *              @supports-gated over a `--radius-lg` round fallback). This is the
  *              aurora/blob color-picking surface.
  *
  * Sizes:

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

@@ -5,7 +5,7 @@ type __VLS_Props = TabsListProps & {
     /**
      * AW.W25 — render the spring `TabsIndicator` pill behind the triggers so
      * the base default `<Tabs>` matches its own indicator primitive (the
-     * polished pill previously lived only in custom BouncyTabs; the base
+     * polished pill previously lived only in the custom SegmentedTabs; the base
      * under-delivered vs its own `TabsIndicator.vue`). Default `true`. Set
      * `:indicator="false"` for a list that drives its own active-state vocab.
      */

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

@@ -20,6 +20,25 @@ export type ColorResolver = (css: string) => [number, number, number];
  * keeps them off the GPU). The equivalence canary asserts the COMPOSED path.
  */
 export declare function oklchToLinear(stop: OklchStop): [number, number, number];
+/**
+ * Warm-white catch-light → LINEAR-sRGB triple (AX.W11). The OKLCh-principled light
+ * tint the painterly relight (aurora's impasto sheen, the blob's `warmCream`) adds
+ * in LINEAR light — one shared OKLCh derivation both surfaces' light models route
+ * through instead of an eyeballed sRGB-ish literal. Just `oklchToLinear({L,C,h})`
+ * with a self-documenting name (the warm-light/cool-shadow temperature-coupling rule
+ * the literature prescribes is "the catch-light is a warm, near-white OKLCh anchor").
+ *
+ * Aurora's default anchor is `(0.985, 0.0125, 77.5°)` — the OKLCh anchor that
+ * reproduces the prior eyeballed `[1.0, 0.95, 0.88]` warm-white to <1e-3 linear (so
+ * the live relight reads identically; the seam fix is invisible to the eye). The
+ * blob's `warmCream` anchor is `(0.97, 0.03, 85°)` — a deeper, more-saturated cream;
+ * W15 re-routes the blob default through THIS helper at that anchor (the cross-surface
+ * unification: ONE OKLCh derive, each surface its own principled anchor).
+ *
+ * An invalid (non-finite) anchor THROWS — a library-internal contract violation, not
+ * a silent grey return (the fail-explicit precept; a stale anchor must surface loud).
+ */
+export declare function warmCatchLight(L: number, C: number, hDeg: number): [number, number, number];
 /**
  * OKLCh stop → GAMMA-sRGB in [0,1] — the blob's faithful-lift exit (DEC-AT-7's W7
  * GAMMA space). value.js's `oklabToRgb255` returns gamma-encoded 0..255 (HSV/sRGB,

package/dist/composables/context/createContext.d.ts

@@ -1,7 +1,7 @@
 import { type InjectionKey } from "vue";
 /**
  * Domain-neutral provide/inject DI factory pair — the single source the dock,
- * dock-layer-group, toggle-group, sortable-list, glyph-face, and configurator
+ * dock-layer-group, toggle-group, sortable-list, and configurator
  * contexts collapse onto (AV.W14). Generalizes the four hand-rolled
  * provide/inject/throw triplets into ONE typed factory so a `*_KEY:
  * InjectionKey<T>` declaration + its `provide`/`use`/throw boilerplate is never

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

@@ -1,9 +1,9 @@
 export * from "./useResizeObserver";
 export * from "./useTouchGate";
 export * from "./useTokenColor";
+export * from "./useResolveTokenColor";
 export * from "./useClipboard";
 export * from "./useUserInvalidAria";
-export * from "./useTextHighlight";
 export * from "./useBreakpoint";
 export * from "./useIdleReady";
 export * from "./useViewportReady";

package/dist/composables/dom/useResolveTokenColor.d.ts

@@ -0,0 +1,27 @@
+/** A bounded LRU-ish cache for the un-wrap (clears wholesale past the cap). */
+export interface ResolveTokenColorCache {
+    resolve: (css: string, el: HTMLElement | null) => string;
+    /** Drop every cached entry — call on a cascade change (dark-mode flip) so a token re-resolves. */
+    invalidate: () => void;
+}
+/**
+ * Un-wrap a `var(--token)` color to a concrete `rgb(...)` via a single cached cascade
+ * read; a literal (no `var()`) passes straight through. Paints `css` onto the element's
+ * `color` property — a `var(--token)` painted on a real CSS property resolves through
+ * the cascade, so `getComputedStyle(el).color` returns the concrete `rgb(...)` — then
+ * restores the prior value. SSR-safe (returns `css` unchanged when `window`/`el` are
+ * absent).
+ *
+ * @param css the color string (a `var(--token)` wrapper or a literal)
+ * @param el  the element to resolve the cascade against (the host wrapper)
+ * @returns the concrete color string the `ColorResolver` can parse
+ */
+export declare function resolveTokenColor(css: string, el: HTMLElement | null): string;
+/**
+ * Build a bounded cache around `resolveTokenColor` — the un-wrap (a forced sync
+ * reflow) runs once per unique color string. `invalidate()` drops every entry so a
+ * token re-resolves on a dark-mode flip (the SFC observes `<html>.class` and calls it).
+ *
+ * @param maxEntries the cache cap before a wholesale clear (default 256)
+ */
+export declare function createTokenColorCache(maxEntries?: number): ResolveTokenColorCache;

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

@@ -1,2 +1,3 @@
-export { createCanvas2D } from "./useCanvas2D";
+export { useCanvas2D, useCanvasLifecycle } from "./useCanvas2D";
 export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./useCanvas2D";
+export { resolveCanvasColor } from "./resolveCanvasColor";

package/dist/composables/glass/canvas2d/resolveCanvasColor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Resolve a CSS custom property or color value to a Canvas2D-VALID
+ * `rgb()`/`rgba()` string.
+ *
+ * @param cssVar a `--custom-property` NAME (resolved as `var(<name>)`) OR a full
+ *   CSS color value (`light-dark(...)`, `color-mix(...)`, `var(...)`, `oklch()`,
+ *   `hsl()`, hex, a named color). A bare `--token` is wrapped as `var(--token)`.
+ * @param el an element ON the cascade — the canvas host or any descendant. The
+ *   probe is appended here so it inherits `el`'s `color-scheme` + `--token`
+ *   cascade; the resolved color reflects the live theme at `el`.
+ * @returns the browser-resolved `rgb()`/`rgba()` string, ready to hand straight
+ *   to `ctx.strokeStyle`/`ctx.fillStyle`. On SSR / no-DOM, returns the input
+ *   `cssVar` unchanged (the befitting-silent fallback).
+ *
+ * @example
+ * // A `light-dark()` `--foreground` token that Canvas2D would reject raw:
+ * ctx.strokeStyle = resolveCanvasColor("--foreground", canvas);
+ * // → "rgb(28, 25, 23)" in light, "rgb(250, 250, 249)" in dark — NOT black.
+ */
+export declare function resolveCanvasColor(cssVar: string, el: HTMLElement): string;

package/dist/composables/glass/canvas2d/useCanvas2D.d.ts

@@ -45,4 +45,18 @@ export interface Canvas2DHandle {
     /** The live `prefers-reduced-motion: reduce` state (consumers read it to skip stepping). */
     readonly reducedMotion: boolean;
 }
-export declare function createCanvas2D(options: Canvas2DOptions): 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.
+ */
+export declare function useCanvas2D(options: Canvas2DOptions): Canvas2DHandle;
+/**
+ * Alias-of-record for {@link useCanvas2D} — the lifecycle-only framing (the
+ * park/freeze/dispose machinery, paralleling the WebGL substrate's
+ * `createCanvasLifecycle`). Same factory, same handle; reach for this name when
+ * the lifecycle (not the 2D drawing) is the consumer's emphasis.
+ */
+export declare const useCanvasLifecycle: typeof useCanvas2D;

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

@@ -1,3 +1,5 @@
 export { useGlassRenderer, createGlassFilter, destroyGlassFilter, type GlassTier, type GlassFilterState, type UseGlassRendererReturn, } from "./useGlassRenderer";
-export { createCanvas2D } from "./canvas2d";
+export { useSpecularTracking } from "./useSpecularTracking";
+export type { UseSpecularTracking } from "./useSpecularTracking";
+export { useCanvas2D, useCanvasLifecycle, resolveCanvasColor } from "./canvas2d";
 export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./canvas2d";

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

@@ -0,0 +1,33 @@
+import { ref, type CSSProperties } from "vue";
+/**
+ * `useSpecularTracking` — the pointer-anchored moving-specular write seam
+ * (AX.W09). The single DRY home for the catch-light position write that was
+ * hand-copied VERBATIM in `Card.vue` and `DockIconButton.vue`.
+ *
+ * On pointer-move it writes the cursor position (`--mouse-x`/`--mouse-y`, as
+ * percentages of the host box) onto the host's inline style; the unified
+ * `.glass-material::before` recipe (`glass.css`) MAPS that host write onto its
+ * typed `--specular-x`/`--specular-y` channel and paints the travelling glow.
+ *
+ * VOCAB (HARDENING §G #28): `--mouse-x`/`--mouse-y` is the HOST WRITE this seam
+ * owns; `--specular-x`/`--specular-y` is the CSS-internal MAPPED channel the
+ * recipe reads. The host writes `--mouse-x/y`; the recipe maps it.
+ *
+ * The catch-light MAGNITUDE rides the `--glass-specular-intensity-{rest,hover,
+ * active}` token cohort (tokens.css) the recipe reads — this seam only feeds the
+ * position. The recipe's rest rung is `0` (dormant) so an UNWIRED surface is
+ * clean; calling this seam is the wire-or-omit opt-in that wakes the lens on
+ * hover/active.
+ *
+ * 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.
+ */
+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). */
+    onPointerMove: (event: PointerEvent) => void;
+}
+export declare function useSpecularTracking(): UseSpecularTracking;

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

@@ -1,4 +1,4 @@
-export type CanvasSuspendReason = "tab-hidden" | "off-screen" | "manual";
+export type CanvasSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
 /** The per-frame hooks a backend's `buildContext` returns to the lifecycle core. */
 export interface CanvasFrameHooks {
     /** Draw one frame at `timeSec`. */

package/dist/composables/glass/webgl/shaders/procedural-color.glsl.d.ts

@@ -1,6 +1,10 @@
 export declare const OETF_GLSL = "\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}";
 export declare const FBM_ROT_GLSL = "const mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);";
 export declare const OKLCH_MATRICES_GLSL = "\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}";
+export declare const PALETTE_RAMP_GLSL = "\n// value.js interpolateHue in the NORMALIZED-TURNS domain (h_rad/TAU \u2192 turns, the\n// exact .5/+1.0 branch per method, fract() wrap, *TAU back). A radians-native port\n// (PI thresholds / +TAU wrap) diverges 180\u00B0 at the antipode. methods: 0 shorter,\n// 1 longer, 2 increasing, 3 decreasing.\nfloat interpolateHueTurns(float h0, float h1, float t, int method) {\n  float TAU = 2.0 * PI;\n  float a = h0 / TAU;\n  float b = h1 / TAU;\n  float i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) a += 1.0; else if (i < -0.5) b += 1.0;\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) a += 1.0; else if (i > -0.5 && i <= 0.0) b += 1.0;\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) b += 1.0;\n  } else {                        // decreasing\n    if (i > 0.0) a += 1.0;\n  }\n  float r = a + t * (b - a);\n  r = fract(r);                   // (r % 1 + 1) % 1 \u2014 fract is non-negative in GLSL\n  return r * TAU;                 // back to radians\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLab-rectangular interpolation \u2192 linear sRGB. Holds\n// chroma across the ramp (no grey midpoint). The default/shorter ramp path.\nvec3 mixPaletteOklab(vec3 linA, vec3 linB, float t) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lab = mix(labA, labB, t);\n  return oklabToLinearSrgb(lab);\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLCh interpolation along the huePath arc \u2192 linear\n// sRGB. L and C lerp; H walks the chosen arc. The deliberate-rainbow path.\nvec3 mixPaletteOklchArc(vec3 linA, vec3 linB, float t, int method) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lchA = oklabToOklch(labA);\n  vec3 lchB = oklabToOklch(labB);\n  float L = mix(lchA.x, lchB.x, t);\n  float C = mix(lchA.y, lchB.y, t);\n  float H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3(L, C, H)));\n}\n\n// The ramp dispatcher both samplePalette ports splice. tRaw is the raw inter-stop\n// parameter [0,1]; the smoothstep ease + the huePath branch live HERE so the GLSL\n// and WGSL ramps are character-for-character one source. increasing(2)/decreasing(3)\n// take the OKLCh hue-arc (rainbow sweep); every other method takes the OKLab-\n// rectangular straight line (no hue detour).\nvec3 samplePaletteRamp(vec3 a, vec3 b, float tRaw, int huePath) {\n  float t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}";
+export declare const PCG_HASH_GLSL = "\n// Jarzynski PCG2D \u2014 uvec2 \u2192 uvec2 permuted-congruential hash (JCGT 2020).\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  return v;\n}\n\n// Float\u2192[0,1) scalar hash: bit-reinterpret the lattice coordinate, pcg2d it, take the\n// high word back to [0,1). Integer-bit \u2014 no sin() periodicity, no float-fract lattice.\nfloat pcgHash2(vec2 p) {\n  uvec2 u = floatBitsToUint(p);\n  return float(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\n// Integer-lattice gradient: pcg2d the integer cell, fold the hash to an angle, return\n// the unit gradient vector. The gradient basis (not a scalar value) is what makes the\n// noise zero at the nodes (no value-noise plateaus).\nvec2 pcgGrad2(ivec2 cell) {\n  uvec2 h = pcg2d(uvec2(cell));\n  float ang = float(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2(cos(ang), sin(ang));\n}\n\n// 2D SIMPLEX gradient noise (Gustavson skew). The skew transform F2/G2 maps the square\n// lattice onto a simplex (triangular) grid \u2014 no axis-aligned directional bias. Each of\n// the three simplex corners contributes grad\u00B7offset shaped by a radial (0.5 - r\u00B2)\u2074\n// falloff. Output is ~[-1, 1]; callers remap to [0,1] via 0.5 + 0.5*gnoise.\nfloat gnoise(vec2 p) {\n  const float F2 = 0.36602540378443864676; // (sqrt(3) - 1) / 2\n  const float G2 = 0.21132486540518711775; // (3 - sqrt(3)) / 6\n  float s = (p.x + p.y) * F2;\n  vec2 i = floor(p + s);\n  float tt = (i.x + i.y) * G2;\n  vec2 x0 = p - (i - tt);                    // offset from the simplex origin corner\n  ivec2 i1 = (x0.x > x0.y) ? ivec2(1, 0) : ivec2(0, 1);\n  vec2 x1 = x0 - vec2(i1) + G2;\n  vec2 x2 = x0 - 1.0 + 2.0 * G2;\n  ivec2 ii = ivec2(i);\n  float n = 0.0;\n  float t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 *= t0; n += t0 * t0 * dot(pcgGrad2(ii), x0); }\n  float t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 *= t1; n += t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  float t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 *= t2; n += t2 * t2 * dot(pcgGrad2(ii + ivec2(1, 1)), x2); }\n  return 70.0 * n;                           // normalize to ~[-1, 1]\n}";
 export declare const OETF_WGSL = "\nfn srgbToLinearCh(c: f32) -> f32 {\n    return select(pow((c + 0.055) / 1.055, 2.4), c / 12.92, c <= 0.04045);\n}\nfn srgbToLinear(c: vec3f) -> vec3f {\n    return vec3f(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\nfn linearToSrgbCh(c: f32) -> f32 {\n    return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);\n}\nfn linearToSrgb(c: vec3f) -> vec3f {\n    return vec3f(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}";
 export declare const FBM_ROT_WGSL = "const FBM_ROT: mat2x2f = mat2x2f(0.8, 0.6, -0.6, 0.8);";
 export declare const OKLCH_MATRICES_WGSL = "\nconst LINEAR_SRGB_TO_LMS: mat3x3f = mat3x3f(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\nconst LMS_TO_OKLAB: mat3x3f = mat3x3f(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\nconst OKLAB_TO_LMS: mat3x3f = mat3x3f(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\nconst LMS_TO_LINEAR_SRGB: mat3x3f = mat3x3f(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn srgbToOklab(c: vec3f) -> vec3f {\n    let lin = srgbToLinear(c);\n    let lms = LINEAR_SRGB_TO_LMS * lin;\n    let lmsCbrt = sign(lms) * pow(abs(lms), vec3f(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\nfn oklabToLinearSrgb(lab: vec3f) -> vec3f {\n    let lms_ = OKLAB_TO_LMS * lab;\n    let lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\nfn oklabToOklch(lab: vec3f) -> vec3f {\n    let C = length(lab.yz);\n    var H = atan2(lab.z, lab.y);\n    if (H < 0.0) { H = H + 2.0 * PI; }\n    return vec3f(lab.x, C, H);\n}\nfn oklchToOklab(lch: vec3f) -> vec3f {\n    return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}";
+export declare const PALETTE_RAMP_WGSL = "\nfn interpolateHueTurns(h0: f32, h1: f32, t: f32, method: i32) -> f32 {\n  let TAU = 2.0 * PI;\n  var a = h0 / TAU;\n  var b = h1 / TAU;\n  let i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) { a = a + 1.0; } else if (i < -0.5) { b = b + 1.0; }\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) { a = a + 1.0; } else if (i > -0.5 && i <= 0.0) { b = b + 1.0; }\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) { b = b + 1.0; }\n  } else {                        // decreasing\n    if (i > 0.0) { a = a + 1.0; }\n  }\n  let r = fract(a + t * (b - a));\n  return r * TAU;\n}\n\nfn mixPaletteOklab(linA: vec3f, linB: vec3f, t: f32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lab = mix(labA, labB, vec3f(t));\n  return oklabToLinearSrgb(lab);\n}\n\nfn mixPaletteOklchArc(linA: vec3f, linB: vec3f, t: f32, method: i32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lchA = oklabToOklch(labA);\n  let lchB = oklabToOklch(labB);\n  let L = mix(lchA.x, lchB.x, t);\n  let C = mix(lchA.y, lchB.y, t);\n  let H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3f(L, C, H)));\n}\n\nfn samplePaletteRamp(a: vec3f, b: vec3f, tRaw: f32, huePath: i32) -> vec3f {\n  let t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}";
+export declare const PCG_HASH_WGSL = "\nfn pcg2d(v0: vec2u) -> vec2u {\n  var v = v0 * 1664525u + vec2u(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  return v;\n}\n\nfn pcgHash2(p: vec2f) -> f32 {\n  let u = bitcast<vec2u>(p);\n  return f32(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\nfn pcgGrad2(cell: vec2i) -> vec2f {\n  let h = pcg2d(bitcast<vec2u>(cell));\n  let ang = f32(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2f(cos(ang), sin(ang));\n}\n\nfn gnoise(p: vec2f) -> f32 {\n  let F2 = 0.36602540378443864676;\n  let G2 = 0.21132486540518711775;\n  let s = (p.x + p.y) * F2;\n  let i = floor(p + vec2f(s));\n  let tt = (i.x + i.y) * G2;\n  let x0 = p - (i - vec2f(tt));\n  var i1 = vec2i(0, 1);\n  if (x0.x > x0.y) { i1 = vec2i(1, 0); }\n  let x1 = x0 - vec2f(i1) + vec2f(G2);\n  let x2 = x0 - vec2f(1.0) + vec2f(2.0 * G2);\n  let ii = vec2i(i);\n  var n = 0.0;\n  var t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 = t0 * t0; n = n + t0 * t0 * dot(pcgGrad2(ii), x0); }\n  var t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 = t1 * t1; n = n + t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  var t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 = t2 * t2; n = n + t2 * t2 * dot(pcgGrad2(ii + vec2i(1, 1)), x2); }\n  return 70.0 * n;\n}";

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

@@ -1,4 +1,4 @@
-export type WebGLSuspendReason = "tab-hidden" | "off-screen" | "manual";
+export type WebGLSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
 /** The per-frame hooks a consumer's `setup(gl)` returns. */
 export interface WebGLCanvasFrame {
     /** Draw one frame at `timeSec`. The consumer uploads its uniforms + draws. */

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

@@ -8,3 +8,4 @@ export * from "../useYieldToMain";
 export * from "../usePrioritizedTask";
 export * from "../useViewTransition";
 export * from "../vReveal";
+export * from "../useTextHighlight";

package/dist/configurator.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-B24TcgIn.js";
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-DxAqksK6.js";
 export { e as CONFIGURATOR_DENSITY_KEY, t as Configurator, i as ConfiguratorLayer, n as ConfiguratorRow, r as provideConfiguratorDensity, o as useConfiguratorState, a as useOptionalConfiguratorDensity };

package/dist/confirm-dialog.js

@@ -1,6 +1,6 @@
 import { t as e } from "./createLucideIcon-B6uNAU9G.js";
-import { n as t } from "./button-CAywcrhO.js";
-import { t as n } from "./_plugin-vue_export-helper-gLzyemvl.js";
+import { n as t } from "./button-DN39cGqL.js";
+import { t as n } from "./_plugin-vue_export-helper-ok8pgSl5.js";
 import { Transition as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createTextVNode as c, createVNode as l, defineComponent as u, mergeModels as d, openBlock as f, renderSlot as p, toDisplayString as m, unref as h, useModel as g, withCtx as _, withKeys as v, withModifiers as y } from "vue";
 var b = e("loader-circle", [["path", {
 	d: "M21 12a9 9 0 1 1-6.219-8.56",