@mkbabb/glass-ui 3.9.0 → 3.10.1

package/dist/components/custom/goo-blob/types.d.ts

@@ -55,15 +55,24 @@ export interface SatelliteInternal {
     endX: number;
     endY: number;
 }
-/** Externally tunable blob configuration — all fields concrete, defaults applied via `BLOB_CONFIG_DEFAULTS`. */
-export interface BlobConfig {
+/** Body / orbit / satellite geometry — the contained-droplet length cohort (W15). */
+export interface BlobGeometry {
     canvasSize: number;
     bodyRadius: number;
     satelliteCount: number;
     satelliteRadius: number;
     orbitRadius: number;
-    quality: BlobQuality;
-    tempo: number;
+    eccentricity: number;
+}
+/** Satellite merge/absorb/emerge/orbit lifecycle DURATIONS (ms). */
+export interface BlobSatelliteTiming {
+    mergeDuration: number;
+    absorbedDuration: [number, number];
+    emergeDuration: number;
+    orbitDuration: [number, number];
+}
+/** The living membrane — smin merge + surface noise/warp + pulsation. */
+export interface BlobMembrane {
     smoothK: number;
     /** Smin merge variant — `quadratic` (default) | `circular` (rounder menisci). */
     merge: BlobMerge;
@@ -77,12 +86,29 @@ export interface BlobConfig {
     warpAmp: number;
     pulseFreq: number;
     pulseAmp: number;
+}
+/** Palette + OKLCh color-perturbation atom. */
+export interface BlobColor {
+    paletteStops: string[];
     hueRange: number;
     satShift: number;
     brightnessShift: number;
     colorNoiseFreq: number;
     colorNoiseSpeed: number;
-    paletteStops: string[];
+}
+/** The lit-glass surface — Blinn-Phong glint + Fresnel rim + iridescence/SSS/core-glow. */
+export interface BlobSurface {
+    lit: boolean;
+    /** CSS color for the Fresnel rim tint (resolved through the `/color` leaf). */
+    rimColor: string;
+    /** Light direction [x, y, z] (normalized in-shader). */
+    lightDir: [number, number, number];
+    specStrength: number;
+    /** Specular exponent (16-64 — a tight glint). */
+    specShininess: number;
+    /** Fresnel/Schlick exponent (~2-3). */
+    rimPower: number;
+    rimStrength: number;
     /** Warm-pearl rim sheen weight (0 = off). */
     iridescence: number;
     /** Base hue (degrees) the warm-biased cosine palette centres on. */
@@ -95,31 +121,39 @@ export interface BlobConfig {
     sssPower: number;
     /** Thickness-driven inner-luminosity (core glow) lift. */
     coreGlow: number;
-    lit: boolean;
-    /** CSS color for the Fresnel rim tint (resolved through the ColorResolver). */
-    rimColor: string;
-    /** Light direction [x, y, z] (normalized in-shader). */
-    lightDir: [number, number, number];
-    specStrength: number;
-    /** Specular exponent (16-64 — a tight glint). */
-    specShininess: number;
-    /** Fresnel/Schlick exponent (~2-3). */
-    rimPower: number;
-    rimStrength: number;
+}
+/** Pointer interaction — lean / squash-stretch / click-impulse. */
+export interface BlobInteraction {
     pointerAttraction: number;
     pointerStrength: number;
-    /** Velocity-driven volume-preserving squash-and-stretch magnitude (0 = off). */
+    /**
+     * Velocity-driven volume-preserving squash-and-stretch magnitude (0 = off).
+     *
+     * AY.W-BLOB-CONFIG D3 — a SWAMPED fine-detail axis. The squash rides the smoothed
+     * spring velocity (`useBlobPointer`'s critically-damped `response: 0.18` follow),
+     * which is heavily damped and down-scaled into body space — so the tanh-saturated
+     * elongation reads at the noise floor (a live readback measured 0% body-aspect change
+     * between `stretch=0` and `stretch=1.5`). It is NOT a primary axis: it adds a subtle
+     * elongation on a FAST flick over the much louder lean/follow/pseudopod channel that
+     * dominates the deformation. Kept (the volume-preserving map is correct and lands a
+     * whisper on the fastest flicks) but DEMOTED — the demo no longer surfaces it as a
+     * top-level slider (the flick blurb is honest-down to match). A consumer that wants a
+     * pronounced taffy-pull raises this AND uncouples the velocity from the spring smooth.
+     */
     stretch: number;
     /** Click spring-impulse amplitude (a one-shot bouncy pulse on the body radius). */
     clickImpulse: number;
-    eccentricity: number;
-    orbitSpeedScale: number;
-    wobbleScale: number;
-    mergeRate: number;
-    mergeDuration: number;
-    absorbedDuration: [number, number];
-    emergeDuration: number;
-    orbitDuration: [number, number];
+}
+/** Externally tunable blob configuration — EIGHT cohesive atoms, defaults via `BLOB_CONFIG_DEFAULTS`. */
+export interface BlobConfig {
+    geometry: BlobGeometry;
+    satellites: BlobSatelliteTiming;
+    membrane: BlobMembrane;
+    color: BlobColor;
+    surface: BlobSurface;
+    interaction: BlobInteraction;
+    quality: BlobQuality;
+    tempo: number;
 }
 export declare const BLOB_CONFIG_DEFAULTS: BlobConfig;
 export declare const BLOB_CONFIG_KEY: InjectionKey<BlobConfig>;

package/dist/components/custom/instrument-chassis/InstrumentChassis.vue.d.ts

@@ -28,8 +28,8 @@ export type InstrumentChassisVariant = "glass" | "spine";
  * the `<ChassisDivider>` adjacent to each — emit markup only when bound.
  * I gate `<header>`, `<footer>`, and the two dividers on `$slots.strip` /
  * `$slots.control` presence, so empty-slot consumers don't have to suppress
- * the markup with `display: none` overrides. Mirrors the `v-if="$slots.status"`
- * idiom InstrumentRail established.
+ * the markup with `display: none` overrides — the `v-if="$slots.status"`
+ * slot-gating idiom.
  *
  * The chassis owns the `--phase-color` cascade via `data-phase`; phase label,
  * hero number, and phase progress fill all read it through one CSS custom

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

@@ -0,0 +1,12 @@
+/**
+ * Fallback for `--tab-indicator-max-stretch` when the cascade leaves it unset — the
+ * default ≈+8% travel-squish cap (AX.W53). `--stretch = 1 + frac · (cap − 1)`, so a
+ * full-width jump reaches the cap and a tiny hop stays near 1. The token is the
+ * authority; this is the no-token floor.
+ */
+export declare const DEFAULT_INDICATOR_MAX_STRETCH = 1.08;
+/**
+ * ms after the stretch opens before it releases back to fit (`--stretch → 1`) — the
+ * Material "grow then shrink" close. Rides the same snappy glide clock as the travel.
+ */
+export declare const INDICATOR_RELEASE_MS = 60;

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

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

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

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

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

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

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

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

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

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

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

@@ -9,28 +9,35 @@ 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 (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.
+ * Exactly two canonical recipes ship:
+ *   standard — the CONTINUOUS GLASS CYLINDER with NO VISIBLE THUMB AT ALL (the
+ *              user's binding bar, USER-AUDIT-2026-06-10 §B3): you pull the TRACK
+ *              itself. A THICK glass capsule track; the filled `.slider-range`
+ *              glass cylinder (the W52 liquid-glass material — backdrop + edge rim,
+ *              tinted to `--primary`) is pulled along it, and its leading EDGE IS
+ *              the handle — the only affordance is the fill edge + the cursor/touch
+ *              response. The reka `<SliderThumb>` STAYS MOUNTED (a11y/keyboard/drag/
+ *              value-follow native on it) but paints INVISIBLE: width 0, opacity 0,
+ *              transparent — no distinct disc/cap/ring over the continuous
+ *              cylinder. Keyboard focus rings the TRACK (the W-PRIM-POLISH focus
+ *              register), not the invisible thumb; hover/held lift the track FILL's
+ *              edge rim; the iOS press spring gives the whole fill a felt squish.
+ *              This is the general-purpose glass scrubber and the default.
  *   spectrum — the value.js gradient-track color slider: a tall capsule whose
  *              background is a consumer-supplied `--slider-track-bg`
  *              linear-gradient (the LCH/hue ramp), a transparent range, and a
- *              SQUIRCLE thumb the HEIGHT of the track (the iOS color-picker
- *              idiom — `corner-shape: superellipse()` via `--corner-shape-thumb`,
- *              @supports-gated over a `--radius-lg` round fallback). This is the
- *              aurora/blob color-picking surface.
+ *              THIN VISIBLE squircle thumb the HEIGHT of the track (the iOS/value.js
+ *              color-picker idiom — a slim vertical bar, `w-3`-thin per the value.js
+ *              reference; `corner-shape: superellipse()` via `--corner-shape-thumb`,
+ *              @supports-gated over a generous proportional round fallback that
+ *              reads squircle-adjacent cross-engine). This is the aurora/blob
+ *              color-picking surface — its thumb IS visible (it is the handle).
  *
- * Sizes:
- *   sm — 4px track / 12px thumb
- *   md — 6px track / 16px thumb (default; matches HEAD)
- *   lg — 12px track / 24px thumb
+ * Sizes — the standard cylinder is the thick glass capsule (the invisible thumb's
+ * value-follow inset still rides the size token for the 44px coarse hit-halo):
+ *   sm — 12px track
+ *   md — 20px track (default)
+ *   lg — 28px track
  */
 export declare const sliderVariants: (props?: ({
     variant?: "standard" | "spectrum" | null | undefined;

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

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

package/dist/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;
 /**
@@ -104,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/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/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/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/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/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-BdQXh9ie.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 };