@mkbabb/glass-ui 3.8.0 → 3.10.0

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`.
  *

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/slider/index.d.ts

@@ -10,20 +10,31 @@ 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 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
+ *   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.
+ *   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
- *              aurora/blob color-picking surface.
+ *              SQUIRCLE thumb the HEIGHT of the track (the iOS color-picker
+ *              idiom — `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).
  *
- * Sizes:
- *   sm — 4px track / 12px thumb
- *   md — 6px track / 16px thumb (default; matches HEAD)
- *   lg — 12px track / 24px thumb
+ * 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
  */
 export declare const sliderVariants: (props?: ({
     variant?: "standard" | "spectrum" | null | undefined;

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

@@ -5,9 +5,13 @@ export interface OklchStop {
     h: number;
 }
 /**
- * The injected color seam (DEC-AT-2, consumed by the AU.W7 blob). Resolves a CSS
- * color string to a GAMMA-sRGB triple in [0,1]. `defaultBlobColorResolver` is the
- * opt-in default; a consumer (value.js) may inject its own.
+ * A color seam: resolves a CSS color string to a GAMMA-sRGB triple in [0,1].
+ * `defaultBlobColorResolver` is the shipped default. A general-purpose injection
+ * type — the `<FourierField>` background takes it as a REQUIRED `colorResolver`
+ * prop (the SVG-field surface owns its own color pipeline). The goo-blob no longer
+ * injects it: it resolves color internally through `cssToOklch → oklchToGammaRgb`
+ * (W-BLOB3 STRIPPED the speculative DI built for an absent value.js consumer that
+ * never repatriated; see `docs/consumer-evidence/goo-blob.md`).
  */
 export type ColorResolver = (css: string) => [number, number, number];
 /**
@@ -60,10 +64,11 @@ export declare function cssToOklch(css: string): OklchStop;
 /** OKLCh stop → `#rrggbb` gamma hex (value.js `oklabToRgb255`). */
 export declare function oklchStopToHex(s: OklchStop): string;
 /**
- * The OPT-IN default `ColorResolver` — `(css) => gamma [r,g,b]` via
- * `cssToOklch → oklchToGammaRgb`. The AU.W7 goo-blob requires an INJECTED resolver
- * and throws by THIS name on a no-resolver mount (the loud failure, not a silent
- * gray default); value.js supplies its own, the demo story uses this one.
+ * The shipped default `ColorResolver` — `(css) => gamma [r,g,b]` via
+ * `cssToOklch → oklchToGammaRgb` (the GAMMA exit; `proof:blob-space-gamma` witnesses
+ * the `oklchToGammaRgb` resolve). The `<FourierField>` background passes THIS as its
+ * `colorResolver` prop. The goo-blob inlines this exact body internally (W-BLOB3 —
+ * no DI seam).
  */
 export declare const defaultBlobColorResolver: ColorResolver;
 /**

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/glass/webgl/shaders/procedural-color.glsl.d.ts

@@ -1,10 +1,5 @@
 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 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 aurora's samplePalette splices. tRaw is the raw inter-stop\n// parameter [0,1]; the smoothstep ease + the huePath branch live HERE so the ramp is\n// one source. increasing(2)/decreasing(3) take the OKLCh hue-arc (rainbow sweep);\n// every other method takes the OKLab-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/motion/core/index.d.ts

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

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

@@ -0,0 +1,42 @@
+export interface RouteTransitionOptions {
+    /**
+     * Directional transition types tagged on the active transition for
+     * `:active-view-transition-type(<t>)` CSS curves (Chrome 140+; feature-
+     * detected, degrades to one symmetric curve elsewhere). For a route morph a
+     * consumer might tag `["forward"]` / `["back"]` off the navigation direction.
+     */
+    types?: string[];
+}
+export interface RouteTransitionResult {
+    /**
+     * Resolves when the transition's `finished` promise settles (or immediately
+     * in the fallback / PRM path). Use to route focus per the a11y MANDATORY:
+     * `await navigate(go).finished; mastheadTitle.value?.focus()`. Never rejects —
+     * a skipped/aborted transition settles cleanly.
+     */
+    finished: Promise<void>;
+    /** True when the native VT ran; false when the instant / PRM fallback ran. */
+    transitioned: boolean;
+}
+export interface UseRouteTransitionReturn {
+    /**
+     * Run `navigate` (the route/state change, possibly async) wrapped in a View
+     * Transition. Under PRM or on an unsupported engine the navigation runs
+     * directly (awaited), unanimated. Returns `{ finished, transitioned }`.
+     */
+    navigate: (navigate: () => void | Promise<void>, options?: RouteTransitionOptions) => RouteTransitionResult;
+    /** True when the native VT API is available (feature-detect for VT-only CSS). */
+    supported: boolean;
+}
+/**
+ * True when `document.startViewTransition` is available — the feature-detected
+ * predicate the helper (and a consumer's VT-only styling) gate on.
+ */
+export declare function supportsRouteTransitions(): boolean;
+/**
+ * The route-transition helper. Returns `navigate` — a function that wraps a
+ * (possibly async) navigation callback in `document.startViewTransition` with PRM
+ * + unsupported fallbacks. The navigation ALWAYS runs (information parity); the
+ * morph is conditional on support + motion preference.
+ */
+export declare function useRouteTransition(): UseRouteTransitionReturn;

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-CMff4GzH.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,5 +1,5 @@
 import { t as e } from "./createLucideIcon-B6uNAU9G.js";
-import { n as t } from "./button-CAywcrhO.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", {