@mkbabb/glass-ui 3.12.0 → 4.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+/** A glass-ui named-spring preset name. */
+export type SpringPresetName = "smooth" | "snappy" | "bouncy" | "gentle" | "dock";
+/** One named-spring row: the analytic (response, dampingFraction) pair + its register doc. */
+export interface SpringPresetRow {
+    /** The token suffix — `--spring-<name>` (CSS) and the `MOTION_CURVES` key. */
+    readonly name: SpringPresetName;
+    /** Response time in seconds (the spring's `response` solver input). */
+    readonly response: number;
+    /** Damping fraction ζ (1 = critical; <1 overshoots). */
+    readonly dampingFraction: number;
+    /** The register this curve serves (the doc-table derives from this one string). */
+    readonly comment: string;
+}
+/**
+ * iOS-canonical (response, dampingFraction) pairs per AL-X4 §3. The names match
+ * the `--spring-*` CSS tokens AND the speedtest CSS consumers that read
+ * `var(--spring-smooth)` etc. directly, so they MUST stay stable across retunes —
+ * only the `(response, ζ)` pair and the emitted curves change.
+ *
+ * GOVERNED iOS-SPRING VOCABULARY (AX.W05) — the SINGLE source of the register
+ * vocabulary. Each row's `comment` names the surface-class that rides it:
+ *
+ *   SETTLE  → smooth  — patient entrances, fades, scale-ins (no overshoot read).
+ *   CONTROL → snappy  — crisp position morphs: tab underline glide, progress fill,
+ *                       the continuous-marker pop, the generic crisp settle.
+ *   PLAYFUL → bouncy  — deliberate emphatic one-shots ONLY: the bouncy toggle press,
+ *                       dialog/success entrances, the VT default. Largest overshoot.
+ *   GENTLE  → gentle  — critically-damped slow settles (the patient end of the ladder).
+ *   DOCK    → dock    — the dock expand/collapse morph AND everything inside it.
+ */
+export declare const SPRING_PRESETS: readonly SpringPresetRow[];
+/** Lookup one preset row by name (used by `MOTION_CURVES` spring rows). */
+export declare function springPreset(name: SpringPresetName): SpringPresetRow;

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

@@ -0,0 +1,2 @@
+export { NumericAnimation, SpringProgress, SmoothProgress, Sequence, Timeline, ManualTimeline, RAFPlayback, ScrollTimeline, createNativeTimeline, flip, flipShared, ElementMorph, drag, Draggable, decay, decayRest, stagger, springTimingFunction, springLinearStops, toEasing, resolveEasing, AnimationOptionError, UnknownEasingError, loadAnimationEngine, } from "@mkbabb/keyframes.js";
+export type { Easing, TimingFunction, TimingFunctionNames, SpringProgressOptions, SpringFrameCallback, SpringSubscriber, SpringLinearStopsOptions, SpringTimingFunctionOptions, SmoothProgressOptions, NumericAnimationOptions, NumericFrameCallback, SequenceEntry, SequenceOptions, SequencePosition, TimelineOptions, NativeTimelineSpec, RAFPlaybackOptions, Tickable, FlipOptions, ElementMorphOptions, MorphRect, DragOptions, DragAxis, DragSubscriber, DecayOptions, DecaySample, StaggerFn, StaggerOptions, StaggerOrigin, AnimationEngine, AnimationOptions, AnimationFrame, AnimateOptions, InputAnimationOptions, ResolvedKeyframes, Vars, } from "@mkbabb/keyframes.js";

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

@@ -0,0 +1,85 @@
+import { type ComputedRef, type Ref } from "vue";
+export type LiquidFlexAxis = "width" | "height";
+export interface UseLiquidFlexParams {
+    /**
+     * The size span endpoints, in px. `from` is the `t=0` size, `to` is the `t=1`
+     * size. Either may be a getter (a live FLIP-measured `to`) or a plain number.
+     */
+    from: number | (() => number);
+    to: number | (() => number);
+    /** Which dimension the size span drives (the squish is reciprocal across it). */
+    axis: LiquidFlexAxis;
+    /**
+     * The LOW squish cap — the maximum `--stretch` the travel can reach (a +N%
+     * elongation along the travel axis). Defaults to 1.08 (the iOS-segmented register
+     * the tabs-indicator already speaks — `DEFAULT_INDICATOR_MAX_STRETCH`). Kept LOW:
+     * the liquid register is a lively settle, never a rubber-band taffy-pull. May be a
+     * getter so a consumer reading a live cascade override (`--tab-indicator-max-
+     * stretch`) re-resolves the cap per-read without reconstructing the primitive.
+     */
+    maxStretch?: number | (() => number);
+    /**
+     * The tanh saturation constant `k` in `1 + tanh(|ṫ|·k)·(max−1)`. Higher `k`
+     * reaches the cap on a slower travel. Defaults to 1.6 (the metaball shader's
+     * `sa = 1 + tanh(speed·1.6)·uStretch` constant — the SAME curve, reconciled).
+     * Read only in the `"tanh"` squish mode (the default).
+     */
+    squishK?: number;
+    /**
+     * The squish curve law:
+     *   • `"tanh"` (DEFAULT) — `1 + tanh(|ṫ|·squishK)·(max−1)`, the SATURATING
+     *     velocity-driven register the metaball shader runs and the morph-showcase
+     *     drives off the spring derivative. A fast travel reads as a lively swell
+     *     capped at `max`, never a taffy-pull.
+     *   • `"linear"` — `1 + travel·(max−1)`, the geometry-relative register the
+     *     tabs-indicator speaks (`travel` is the travel FRACTION 0→1, so a
+     *     full-track jump reaches the cap and a neighbour hop stays near 1). This is
+     *     the load-bearing local detail of the indicator squish (§7) — selected here
+     *     so the reconcile is byte-identical, not a curve change.
+     */
+    squishLaw?: "tanh" | "linear";
+}
+export interface UseLiquidFlexReturn {
+    /** The live normalized progress (0→1), last value handed to `drive`. */
+    t: Readonly<Ref<number>>;
+    /** The interpolated size in px: `from + (to − from)·t`. */
+    size: ComputedRef<number>;
+    /**
+     * The volume-preserving squish scalar (≥1). 1 at rest; rises toward `maxStretch`
+     * as the travel velocity grows, capped at `maxStretch`. The consumer pairs it
+     * reciprocally (`scale: var(--stretch) calc(1 / var(--stretch))` along the axis).
+     */
+    stretch: ComputedRef<number>;
+    /**
+     * The size as a CSS length style object, keyed on `axis` (`{ width: "Npx" }` or
+     * `{ height: "Npx" }`). Bind on the morphing element's style.
+     */
+    sizeStyle: ComputedRef<Record<string, string>>;
+    /**
+     * The squish as a CSS custom-property style object (`{ "--stretch": "1.04" }`).
+     * The SFC's CSS pairs `--stretch` reciprocally along the travel axis.
+     */
+    stretchStyle: ComputedRef<Record<string, string>>;
+    /**
+     * Advance the morph: set the normalized progress to `next` (0→1). The squish
+     * travel velocity is the |Δt| since the prior `drive`, so calling `drive` on a
+     * spring's per-frame value gives a squish that swells on a fast travel and
+     * relaxes to 1 as the value settles (no free-running timer — the SAME drive calls
+     * carry the release). This is the morph consumer's path (it owns a size span).
+     */
+    drive(next: number): void;
+    /**
+     * Set the squish-travel input DIRECTLY (the squish-only consumer's path — the
+     * tabs-indicator has no size span; it feeds its geometry-relative travel
+     * fraction here). In `"linear"` law `travel` is the 0→1 fraction; in `"tanh"`
+     * law it is the velocity magnitude. Releasing the squish to fit is a `squish(0)`
+     * call (the tabs-indicator's release-to-1 step rides the same input).
+     */
+    squish(travel: number): void;
+}
+/**
+ * The shared amorphous flex+squish primitive. PURE projection of a caller-driven
+ * normalized scalar onto a size span + a volume-preserving squish — no spring, no
+ * rAF, no element. See the module header for the W-LIQUID reconcile rationale.
+ */
+export declare function useLiquidFlex(params: UseLiquidFlexParams): UseLiquidFlexReturn;

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

@@ -1,6 +1,6 @@
 import { type Ref } from "vue";
 import { type SpringRef } from "./useSpring";
-/** Named iOS spring presets (mirrors X1 §2.3 / tokens.css §2). */
+/** Named iOS spring presets the mount register exposes (the dock register is not a mount enter). */
 export type SpringPreset = "smooth" | "snappy" | "bouncy" | "gentle";
 export interface UseSpringMountOptions {
     /**

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

@@ -5,6 +5,17 @@
  *  (one symmetric curve), which is functionally identical (the swap still runs). */
 export interface ViewTransitionOptions {
     types?: string[];
+    /**
+     * BA.W-ATLAS-RECONCILE A-4b — take the JS-level INSTANT path under
+     * `prefers-reduced-motion: reduce` (run `mutate` directly, NO snapshot
+     * captured). The HEAD default pushes PRM to CSS only (`view-transition.css`
+     * sets `animation: none` on the VT pseudos) — but that STILL captures a
+     * snapshot. For the navigation case a reduced-motion user wants the swap to
+     * happen with no transition machinery at all; `navigate()` sets this true.
+     * Defaults to `false` so the existing sync-VT consumers (muster J.W5 row
+     * re-rank) keep their exact CSS-handled PRM behaviour. @default false
+     */
+    instantUnderReducedMotion?: boolean;
 }
 export interface ViewTransitionResult {
     /**
@@ -43,4 +54,28 @@ export declare function supportsViewTransitions(): boolean;
  *   // directional intent — snappier exit on collapse, softer entry on expand
  *   startViewTransition(() => mutate(), { types: ["dock-expand"] });
  */
-export declare function startViewTransition(mutate: () => void, options?: ViewTransitionOptions): ViewTransitionResult;
+export declare function startViewTransition(mutate: () => void | Promise<void>, options?: ViewTransitionOptions): ViewTransitionResult;
+/** Options for `navigate` — the directional transition `types` (Chrome 140+,
+ *  feature-detected; tag `["forward"]`/`["back"]` off the navigation direction). */
+export type NavigateOptions = ViewTransitionOptions;
+/**
+ * Run a (possibly ASYNC) navigation callback wrapped in a View Transition, with
+ * the reduced-motion + unsupported instant-paths. The navigation ALWAYS runs
+ * (awaited); the morph is conditional on support + motion preference. Returns the
+ * same `{ finished, transitioned }` contract — `await navigate(go).finished` then
+ * route focus (the a11y MANDATORY).
+ *
+ * @example  the card → masthead route morph
+ *   // both the card title + masthead title carry
+ *   //   view-transition-class: gl-shared-element; view-transition-name: dash-title
+ *   await navigate(() => router.push(`/${slug}`), { types: ["forward"] }).finished;
+ *   mastheadTitle.value?.focus();
+ */
+export declare function navigate(nav: () => void | Promise<void>, options?: NavigateOptions): ViewTransitionResult;
+/**
+ * True when the route-transition morph can run (native VT available). A consumer
+ * gates VT-only navigation styling on this (alias of `supportsViewTransitions`
+ * named for the navigation call site). Under reduced motion the `navigate` helper
+ * still takes the instant path even when this is `true`.
+ */
+export declare function supportsRouteTransitions(): boolean;

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-DxAqksK6.js";
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-kiIlun8I.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-DN39cGqL.js";
-import { t as n } from "./_plugin-vue_export-helper-ok8pgSl5.js";
+import { t as e } from "./createLucideIcon-DydS2qgk.js";
+import { n as t } from "./button-BNDWhAZb.js";
+import { t as n } from "./_plugin-vue_export-helper-CBt_VvXa.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",