@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/components/blob/types.d.ts

@@ -0,0 +1,256 @@
+import type { InjectionKey } from "vue";
+export type BlobMood = "idle" | "happy" | "curious" | "sleepy" | "excited";
+/** Smin merge variant — `quadratic` (cheap, creased) | `circular` (rounder menisci). */
+export type BlobMerge = "quadratic" | "circular";
+/**
+ * The render-variant axis (BC.W-GOOBLOB-PLAIN — STAGE 1 owns the first two members).
+ *
+ * - `"blob"` — the STAGE-1 first-principles floor: a plain shadowless lightless
+ *   fill-only droplet (SDF + smin satellites + fwidth-AA + warm-cream fill). The
+ *   minimal verifiable "it renders, it meatballs, it works on Safari" register the
+ *   `uStage` gate strips the lit/shadow blocks for. NO specular, NO iridescence, NO
+ *   SSS, NO shadow — deliberately minimal.
+ * - `"meatball"` — the full lit register (the default): STAGE 2 builds the lit-glass
+ *   surface / Fresnel rim / iridescence / SSS / shadow ON the same field via the
+ *   `uLit`/`uShadow` flags. Byte-identical to the pre-STAGE-1 default pipeline.
+ *
+ * `"dot-matrix"` / `"dot-sphere"` are the later-sub-wave siblings (not STAGE 1).
+ */
+export type BlobVariant = "blob" | "meatball";
+/**
+ * Render-quality axis (AX.W16) — `full` (default) renders the metaball pass at the
+ * clamped DPR; `half` renders the backing store at HALF resolution and lets the
+ * browser bilinear-upsample on composite (~4× fragment savings for weak GPUs — the
+ * blob is the ideal candidate: the soft FBM/AA edge hides the interpolation).
+ */
+export type BlobQuality = "full" | "half";
+export interface MoodParams {
+    orbitSpeedScale: number;
+    wobbleScale: number;
+    pulseFreq: number;
+    pulseAmp: number;
+    noiseAmp: number;
+    hueRange: number;
+    satShift: number;
+    brightnessShift: number;
+    smoothK: number;
+    pointerAttraction: number;
+    mergeRate: number;
+    /** Mood-driven iridescence/SSS intensity multiplier (excited > 1, sleepy < 1). */
+    iridScale: number;
+}
+export interface MetaballSource {
+    x: number;
+    y: number;
+    radius: number;
+    opacity: number;
+    /**
+     * BD.W-GOOBLOB-MERCURY-COLONY — the per-source SPLIT token (default `false`). When a
+     * satellite is mid-`fissioning`, this is `true` and the uniform packers DROP the
+     * `orbitWiden` bridge to nominal for it ALONE, so its neck thins past the smin reach
+     * and SNAPS into a free bead. Every non-fissioning source keeps the full bridge (the
+     * R8-07 "instant fully-detached disc" cure). Trail sources never fission (`false`).
+     */
+    fissioning?: boolean;
+}
+export type SatellitePhase = "orbiting" | "merging" | "absorbed" | "emerging" | "fissioning";
+export interface SatelliteInternal {
+    phase: SatellitePhase;
+    phaseStart: number;
+    phaseDuration: number;
+    timeOrigin: number;
+    angularSpeed: number;
+    phaseOffset: number;
+    baseRadiusX: number;
+    baseRadiusY: number;
+    wobbleAmp1: number;
+    wobbleFreq1: number;
+    wobbleAmp2: number;
+    wobbleFreq2: number;
+    pertXAmp: number;
+    pertXFreq: number;
+    pertXPhase: number;
+    pertYAmp: number;
+    pertYFreq: number;
+    pertYPhase: number;
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+    /**
+     * The live phase token the uniform packers READ to phase-scope `orbitWiden`. Mirrors
+     * `phase`, but exposed on the published `MetaballSource` (below) so the GL leaves can
+     * gate the bridge widen per-satellite WITHOUT importing the satellite internals. A
+     * fissioning satellite drops to nominal bridge (its neck snaps); every other
+     * satellite keeps the full+capped widen (R8-07 cured).
+     */
+    fissioning: boolean;
+    /**
+     * BD.W-GOOBLOB-MERCURY-COLONY — the phase-local SNAP latch: false at the fission
+     * beat start, set true once the neck crosses the snap band (so the body-pulse recoil
+     * kick fires EXACTLY ONCE per pinch, not every frame across the snap window).
+     */
+    snapFired: boolean;
+}
+/** Body / orbit / satellite geometry — the contained-droplet length cohort (W15). */
+export interface BlobGeometry {
+    canvasSize: number;
+    bodyRadius: number;
+    satelliteCount: number;
+    satelliteRadius: number;
+    orbitRadius: 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;
+    noiseAmp: number;
+    noiseFreq: number;
+    noiseSpeed: number;
+    /**
+     * Domain-warp strength on the FBM edge displacement (0 = plain fbm, the
+     * pre-warp look; ~0.6 = a marbled organic membrane). Taste-first low default.
+     */
+    warpAmp: number;
+    pulseFreq: number;
+    pulseAmp: number;
+}
+/** Palette + OKLCh color-perturbation atom. */
+export interface BlobColor {
+    paletteStops: string[];
+    satelliteColors?: string[];
+    hueRange: number;
+    satShift: number;
+    brightnessShift: number;
+    colorNoiseFreq: number;
+    colorNoiseSpeed: number;
+    /**
+     * BI.W-BLOB-SEAMS (GAP-L5 / value.js D8) — the OKLab-L ink FLOOR the derived
+     * palette's deepest (body) stop is clamped to, so a seed-derived hero body never
+     * collapses toward an illegible near-black. A CONFIG atom (the consumer/HERO sets
+     * it; the palette derivation reads it via `deriveBlobPalette`'s `lightnessFloor`
+     * param). Bracket-bounded `[0.12, 0.20]` OKLab L — see `LIGHTNESS_FLOOR_BRACKET` /
+     * `clampLightnessFloor` (`./presets`); default 0.15. This does NOT affect the bare
+     * default paint (its `paletteStops` are pre-baked CSS strings) — it is the floor a
+     * consumer DERIVING a palette off `config.color.lightnessFloor` applies.
+     */
+    lightnessFloor?: number;
+}
+/** The lit-glass surface — Blinn-Phong glint + Fresnel rim + iridescence/SSS/core-glow. */
+export interface BlobSurface {
+    lit: boolean;
+    /**
+     * The procedural 2D SDF soft-shadow march (BC.W-GOOBLOB-MEATBALL T2). A soft contact
+     * shadow FOLLOWING the irregular silhouette (NOT a hard disc/box shadow), gated behind
+     * the shader `uShadow` flag. Default ON (the `meatball` register); the `blob` STAGE-1
+     * floor ships shadowless via the `uStage` gate.
+     */
+    shadow: boolean;
+    /**
+     * Soft-shadow penumbra hardness (BC.W-GOOBLOB-MEATBALL T2) — the inverse light-source
+     * size fed to the IQ rmshadows march `w` term (a higher value = a harder penumbra).
+     * Range 4–48, default 16.
+     */
+    shadowSoftness: number;
+    /** 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. */
+    iridHue: number;
+    /** Animated-thickness scroll speed for the iridescent shimmer. */
+    iridSpeed: number;
+    /** Fast-SSS back-light weight. */
+    sssScale: number;
+    /** Fast-SSS exponent. */
+    sssPower: number;
+    /** Thickness-driven inner-luminosity (core glow) lift. */
+    coreGlow: number;
+    /**
+     * BD.W-GOOBLOB-MERCURY-COLONY — the MERCURY-COLONY split register (the OPT-IN scalar,
+     * 0..1, default the calm floor `0`). At `0` the shipped `variant:"blob"` default stays
+     * calm + gate-faithful: a permanently-bonded merge/un-merge breath, NO pinch (so
+     * `proof:blob-render`/`-studio`/`-page` are UNMOVED — `orbitRadius 0.17` is NOT
+     * re-based). Lifting it toward `1` arms the `fissioning` beat: the colony breathes a
+     * satellite OUT through a thinning neck whose gap exceeds the smin reach so it SNAPS
+     * into a free orbiting bead (the mercury pinch), then re-merges next cycle. This is a
+     * DERIVED bundling over the EXISTING `surface` atom (the variant IS the bundle) — NOT
+     * a 9th geometry atom; the split rides MOTION (the satellite moves) on the EXISTING
+     * phase machine, NOT a global smin-band re-base (which would lean-regress per
+     * AZ.W-BLOB-STUDIO D2). Mood-coupled: `excited` splits more, `sleepy` barely. The
+     * `colony`/`mercury` register a consumer/studio opts into.
+     */
+    fissionAmp: 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).
+     *
+     * 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;
+}
+/** 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;
+    /**
+     * The render variant (BC.W-GOOBLOB-PLAIN) — `"meatball"` (default, the full lit
+     * pipeline) | `"blob"` (the STAGE-1 plain shadowless fill-only floor). `"blob"`
+     * sets the shader `uStage` gate so the lit/shadow/iridescence/SSS blocks are NOT
+     * reached — the minimal verifiable floor. `"meatball"` is byte-identical to the
+     * pre-STAGE-1 default (the `surface.lit` flag still owns the lit-on/off within it).
+     */
+    variant: BlobVariant;
+    /**
+     * BD.W-GOO-CAROUSEL-DECK — the blob↔meatball SHADING-MORPH scalar (0..1). The user's
+     * "MORPH BLOB and MEATBALL from one to another" — a CONTINUOUS in-between, not a hard
+     * `variant` cut. `0` = the flat warm-cream blob (byte-identical to `variant: "blob"`);
+     * `1` = the fully-dressed lit meatball (byte-identical to `variant: "meatball"`);
+     * `0 < morphT < 1` lerps the SURFACE shading (the smin GEOMETRY is shared, so only the
+     * fill→lit/shadow/iridescence dressing interpolates). UNSET (the default) → the value
+     * is resolved from `variant` (blob → 0, meatball → 1), so the existing `variant` prop
+     * is byte-back-compat. A consumer ANIMATING this (a `useSpring`/registered-scalar) gets
+     * the live morph.
+     */
+    morphT?: number;
+    quality: BlobQuality;
+    tempo: number;
+}
+export declare const BLOB_CONFIG_DEFAULTS: BlobConfig;
+export declare const BLOB_CONFIG_KEY: InjectionKey<BlobConfig>;

package/dist/components/button/Button.vue.d.ts

@@ -0,0 +1,31 @@
+import type { ButtonHTMLAttributes, HTMLAttributes } from 'vue';
+import { type PrimitiveProps } from 'reka-ui';
+import { type ButtonVariants } from './';
+import type { Surface } from '../_shared/useSurfaceAxis';
+interface Props extends PrimitiveProps {
+    variant?: ButtonVariants['variant'];
+    size?: ButtonVariants['size'];
+    tone?: ButtonVariants['tone'];
+    iconOnly?: ButtonVariants['iconOnly'];
+    class?: HTMLAttributes['class'];
+    surface?: Surface;
+    liquid?: boolean;
+    punch?: boolean;
+    type?: ButtonHTMLAttributes['type'];
+    disabled?: ButtonHTMLAttributes['disabled'];
+}
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    as: import("reka-ui").AsTag | import("vue").Component;
+}, {}, {}, {}, 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/button/index.d.ts

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

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

@@ -0,0 +1,180 @@
+import { type HTMLAttributes } from "vue";
+import type { PrimitiveProps } from "reka-ui";
+import type { Surface as SurfaceKind } from "../_shared/useSurfaceAxis";
+import type { Motion } from "../_shared/axes";
+/**
+ * The glass surface ladder — the 5-rung base tier (BI.W-SURFACE-EXTRACT collapsed
+ * `opaque`/`deep` OUT of this union). Maps 1:1 to `.glass-{tier}` in glass.css and is
+ * now value-identical to the `SurfaceTier` grammar vocabulary:
+ *
+ *   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
+ *
+ * The solid-card escape is now `<Card surface="opaque">` (the `--glass-level:0`
+ * decoration on the surface axis, not a tier), and the maximal iOS-27 deep-glass
+ * register is `<Card deep>` (the boolean — `.glass-floating glass-deep`, BB.W-DEEP-GLASS).
+ * Both are clean breaks: no `tier="opaque"` / `tier="deep"` alias (MIGRATION row).
+ */
+export type CardTier = "wash" | "quiet" | "resting" | "floating" | "overlay";
+/**
+ * Surface decoration register — the SHARED {glass·veil·opaque·clear} axis (the
+ * `Surface` grammar) PLUS Card's local `cartoon` superset (BI.W-SURFACE-EXTRACT:
+ * `CardSurface = Surface | "cartoon"`; `opaque`/`clear` joined the union as the
+ * `tier="opaque"` collapse landing + the clear register). Orthogonal to
+ * `tier`/`shadow`/`grain`.
+ *
+ *   glass    — the tier's plain glass rung (default)
+ *   veil     — the text-legibility PLATE (R5-7). The wash/quiet glass fill + blur
+ *              with the border AND rim/highlight STRIPPED. An optional radial
+ *              feather axis (`--veil-feather`, default none). Routes the glass
+ *              material through the `--glass-*` ladder, so `--glass-level` / the
+ *              W55 bright-bucket retune it in lockstep with every glass surface.
+ *   opaque   — the `--glass-level:0` solid-card escape (the prior `tier="opaque"`
+ *              rung's clean-break successor): a solid `--card` plate through the ONE
+ *              level knob, the tint axis zeroed.
+ *   clear    — the scrim-coupled maximally-translucent Apple-Clear plate
+ *              (BE.W-CLEAR-VARIANT).
+ *   cartoon  — the Card-LOCAL Memphis-sticker decoration (NOT a `Surface` axis
+ *              member — the grammar fence): 2px border, offset-stamp shadow,
+ *              hover-lift. Composes onto ANY tier over the glass base.
+ */
+export type CardSurface = SurfaceKind | "cartoon";
+/**
+ * Specular catch-light register (AX.W09) — the pointer-anchored moving lens on a
+ * glass card.
+ *
+ *   off    — NO catch-light (default). The clean resting panel: a data/content
+ *            `surface="glass"` card over any backplate reads flat — no centred
+ *            white bloom, no pointer wiring. The §24 three-consumer-confirmed
+ *            default for the common content-card case.
+ *   subtle — the token-ladder lens: the pointer-anchored catch-light wakes on
+ *            hover/active at the SUBTLE `--glass-specular-intensity-*` magnitudes.
+ *            The explicit opt-in for a hero/chrome surface.
+ *   full   — the brighter pre-tune rung set, for the busy-backdrop case the recipe
+ *            was originally authored over (a local intensity-token override).
+ */
+export type CardSpecular = "off" | "subtle" | "full";
+/**
+ * Decoration variant — the ONE new Atlas component (BC.W-SELECTION-CARD, the I5
+ * selection card). Default UNSET: a bare `<Card>` is byte-identical to HEAD; the
+ * variant is additive default-OFF (the no-op floor). `selection` binds
+ * `:data-variant="selection"` on the root and ROUTES the chromatic-rim (A-2,
+ * `--glass-accent`) + selected metal-shimmer (A-3, `.metal-*-border`) decoration
+ * through the SHARED BUILT seams — it mints NO new sub-system. The shape mirrors
+ * the `surface` axis exactly: a data-attr the CSS seam reads, ORTHOGONAL to
+ * `tier`/`surface`/`motion` (a `variant="selection" surface="glass"
+ * tier="resting" as="button"` card is valid). The hue is a CONSUMER value
+ * (`data-hue`/`data-hue-strength` per-instance); NO consumer hue enters a token.
+ */
+export type CardVariant = "selection";
+/** The earned metal for a SELECTED selection-card (gold default — BA.W-PHASE-PALETTE
+ *  "gold is earned" for the chosen item). Composes the BUILT `.metal-{name}-border`
+ *  utility; NO forked keyframe, NO baked metal color. */
+export type CardMetal = "gold" | "silver" | "bronze";
+interface Props extends PrimitiveProps {
+    /** Surface tier; selects one rung of the glass ladder. Default `resting`. */
+    tier?: CardTier;
+    /** Surface decoration register (the shared `Surface` axis + Card's `cartoon`
+     *  superset). `glass` (default) renders the tier's glass rung; `veil` overlays
+     *  the borderless/rimless text-legibility plate; `opaque` is the
+     *  `--glass-level:0` solid-card escape (the `tier="opaque"` collapse landing);
+     *  `clear` the scrim-coupled Apple-Clear plate; `cartoon` overlays the
+     *  Card-LOCAL Memphis-sticker decoration. Orthogonal to `tier`/`shadow`/`grain`. */
+    surface?: CardSurface;
+    /** BB.W-DEEP-GLASS — the maximal iOS-27 deep-glass opt-in (Apple
+     *  saturate-1.5/blur-16px): the `.glass-deep` decoration on the `floating` base
+     *  rung. Default `false` (the calm content default, byte-unchanged). The
+     *  clean-break successor of the retired `tier="deep"` rung. */
+    deep?: boolean;
+    /** Surface drop shadow via `--shadow-card`. Off for cards nested inside cards. */
+    shadow?: boolean;
+    /** `::after` paper-grain overlay. Off for scroll panes (the grain conflicts
+     *  with overflow:auto repaints). */
+    grain?: boolean;
+    /** BB.W-PAPER-GRID-TEXTURE — the GEOMETRIC paper register: a `::after`
+     *  blueprint/graph-paper grid felt THROUGH the card interior (the math/grid
+     *  brand pillar, read through the plate rather than only in the page
+     *  margin). Default **OFF** — a bare card is byte-identical to HEAD; a
+     *  document-register card opts in. ORTHOGONAL to `grain` (organic) — a card
+     *  may carry BOTH the turbulence grain and the geometric grid. The register
+     *  doctrine (paper-register cards opt in, instrument-glass surfaces do NOT)
+     *  is a CONSUMER choice the default-OFF honors by construction. */
+    grid?: boolean;
+    /** Specular catch-light register (AX.W09). `off` (default) keeps the card
+     *  CLEAN — no pointer-anchored lens, clean over any backplate (the §24
+     *  three-consumer-confirmed default for a data/content card). `subtle` wakes
+     *  the pointer-anchored moving catch-light at the token-ladder magnitudes (a
+     *  hero/chrome opt-in); `full` runs the brighter pre-tune rung set for a busy
+     *  backdrop. Only `glass` surfaces wire it; `cartoon` owns its own sticker lift. */
+    specular?: CardSpecular;
+    /** BH.W-MOTION-AXIS — the ONE motion-weight axis (the `pressable` boolean's
+     *  clean-break successor). `full` (default) — the FULL liquid register, gesture
+     *  enrichments armed (zero-delta at default). `reduced` — the JS press physics
+     *  degrade to the `.tap-squish` `:active` CSS floor (the SAME state PRM produces).
+     *  `off` — the press unbinds AND `--motion-weight: 0` zeroes the cartoon channels;
+     *  the click still selects. PRM forces `full → reduced` regardless (a11y absolute).
+     *
+     *  The press CAPABILITY derives from INTERACTIVITY, not this axis: a Card presses
+     *  IFF it renders interactive (`as="button"`/`as="a"`/`href`/`role="button"` on the
+     *  root) AND `motion !== "off"`. A bare static `<Card>` never presses because it has
+     *  no interaction to enrich — the "static plate never presses" fence holds by
+     *  DERIVATION, not by a default. The press is `useLiquidPress` (the interruptible
+     *  coupled spring-press — Card is the SECOND `useSpringPress` binary, Button first),
+     *  compositor-only (`scale` + `--card-press-t`); the `.glass-press` CSS `:active`
+     *  scale is the no-JS / SSR floor. */
+    motion?: Motion;
+    /** BC.W-SELECTION-CARD — the selection decoration axis (the ONE new Atlas
+     *  component). `selection` ROUTES the per-instance data-hue rim (A-2) +
+     *  the selected metal-shimmer border (A-3) through the BUILT seams; default
+     *  UNSET (a bare Card is byte-identical to HEAD). ORTHOGONAL to
+     *  `tier`/`surface`/`motion`. */
+    variant?: CardVariant;
+    /** BC.W-SELECTION-CARD — the chosen state of a `variant="selection"` card.
+     *  When `true` the card composes the earned `.metal-${metal}-border` swept
+     *  rim + lifts the accent-strength toward `--selection-accent-strength-selected`
+     *  (rim-not-fill — the plate stays warm-cream translucent). The consumer wires
+     *  the matching `aria-selected`/`aria-checked` role contract on the card. */
+    selected?: boolean;
+    /** BC.W-SELECTION-CARD — the metal of the SELECTED-state swept rim. `gold`
+     *  (default) is earned for the chosen item; `silver`/`bronze` are the other
+     *  two BUILT `.metal-*-border` quads. Only read when `variant="selection"` +
+     *  `selected`. */
+    metal?: CardMetal;
+    /** BC.W-SELECTION-CARD — the per-instance data hue (a complete `<color>`) a
+     *  `variant="selection"` card tints its RIM + catch-light glint toward (the
+     *  A-2 `--glass-accent` consumer). The hue NEVER tints the plate background
+     *  (the distinct-axis fence); unset → the neutral `transparent` no-op floor. */
+    dataHue?: string;
+    /** BC.W-SELECTION-CARD — the bounded accent strength override (a `<percentage>`,
+     *  e.g. `"20%"`). Unset → the calm `--selection-accent-strength` default
+     *  (≤ the W-GLASS-ACCENT rim ceiling). Bounded — a whisper at the rim, never a
+     *  flooded plate. */
+    dataHueStrength?: string;
+    class?: HTMLAttributes["class"];
+}
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    shadow: boolean;
+    grid: boolean;
+    surface: CardSurface;
+    as: import("reka-ui").AsTag | import("vue").Component;
+    deep: boolean;
+    tier: CardTier;
+    grain: boolean;
+    specular: CardSpecular;
+    metal: CardMetal;
+}, {}, {}, {}, 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/card/CardHeader.vue.d.ts

@@ -0,0 +1,58 @@
+import type { HTMLAttributes } from 'vue';
+/**
+ * <CardHeader> — header lane of the Card family.
+ *
+ * AI.W1-α additive `shrink` modifier — when true, the header binds to the
+ * `--card-scroll` named scroll-timeline (emitted by the canonical
+ * `.card-scroll-host` utility on a scroll-overflow ancestor, owned by
+ * `<ScrollCard>`) and runs the 4-lane compositor-safe shrink choreography as
+ * the host scrolls: (1) header content compress (translateY), (2) title
+ * shrink-in-place (the shared `title-collapse` SCALE keyframe), (3)
+ * description retire (opacity + scaleY), (4) header background lift (a
+ * `::before` backplate opacity). Every lane is COMPOSITOR-SAFE (scale /
+ * transform / opacity only — BB.W-CARD-COMPOSITE) so ZERO reflow fires per
+ * scroll frame (the A'-3 CLS 1.03 worst-cluster killed).
+ *
+ * BG.W-SCROLL-SHRINK-UNIFY — the choreography is EXTERNALIZED to the global,
+ * un-hashed `src/styles/card-scroll.css` (this SFC carries NO `<style>` block).
+ * A global stylesheet has no Vue `data-v-…` scope hash, so it reaches the
+ * light-DOM slotted `<CardTitle>`/`<CardDescription>` via the PLAIN descendant
+ * selector `.card-header--shrink > [data-slot=…]` (the correct global-file form
+ * — no `:slotted()`/`:deep()` scope escape needed). The lane-2 title SCALE leg
+ * is shared with the page/hero large-title collapse via ONE `@keyframes
+ * title-collapse` (the DRY fold; card supplies `--title-collapse-scale: 0.695`,
+ * page/hero supply `0.82`). The scrub ease is the NO-OVERSHOOT
+ * `--card-shrink-ease` (off the retired cartoon-punch — a scroll scrub must be
+ * monotonic). `proof:no-layout-animation` (W1-W4) makes the layout-property
+ * class structurally impossible to re-ship AND asserts the externalized-global
+ * shape.
+ *
+ * **Required ancestor**: when `shrink` is true, `.card-scroll-host` MUST sit on
+ * the scroll-overflow ancestor (`<ScrollCard>` owns it). Without that host the
+ * named timeline never emits and the choreography sits idle. Sticky positioning
+ * stays consumer-side (the consumer adds `class="sticky top-0"` etc. via
+ * `props.class`); the background TINT is scroll-driven by lane 4.
+ */
+type __VLS_Props = {
+    /**
+     * Bind the header to the `--card-scroll` named timeline and run the
+     * 3-lane shrink choreography. Requires `.card-scroll-host` on the
+     * scroll-overflow ancestor. Default `false` — the existing 5+
+     * consumers see no change.
+     */
+    shrink?: boolean;
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, 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/card/ScrollCard.vue.d.ts

@@ -0,0 +1,33 @@
+import type { HTMLAttributes } from "vue";
+import type { CardTier, CardSurface, CardSpecular } from "./Card.vue";
+/** Props for `<ScrollCard>` — the first-class scroll-shrink card. */
+export interface ScrollCardProps {
+    /** Card surface tier — forwarded to the inner `<Card>`. Default `resting`. */
+    tier?: CardTier;
+    /** Surface decoration register — forwarded to `<Card>`. Default `glass`. */
+    surface?: CardSurface;
+    /** Surface drop shadow — forwarded to `<Card>`. Default `true`. */
+    shadow?: boolean;
+    /** Specular catch-light — forwarded to `<Card>`. Default `off`. */
+    specular?: CardSpecular;
+    /** Max scroll-port height. The scroll region needs a bounded height for
+     *  the `--card-scroll` timeline to have a scroll range. Default `18rem`. */
+    maxHeight?: string;
+    class?: HTMLAttributes["class"];
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ScrollCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ScrollCardProps> & Readonly<{}>, {
+    shadow: boolean;
+    maxHeight: string;
+    surface: CardSurface;
+    tier: CardTier;
+    specular: CardSpecular;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/carousel/Carousel.vue.d.ts

@@ -0,0 +1,44 @@
+import type { CarouselProps, WithClassAsProps } from './interface';
+type __VLS_Props = CarouselProps & WithClassAsProps;
+type __VLS_ModelProps = {
+    'active'?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {
+    canScrollNext: boolean;
+    canScrollPrev: boolean;
+    carouselApi: import("embla-carousel").EmblaCarouselType | undefined;
+    carouselRef: HTMLElement | undefined;
+    orientation: "horizontal" | "vertical" | undefined;
+    scrollNext: () => void;
+    scrollPrev: () => void;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    canScrollNext: import("vue").Ref<boolean, boolean>;
+    canScrollPrev: import("vue").Ref<boolean, boolean>;
+    carouselApi: import("vue").Ref<import("embla-carousel").EmblaCarouselType | undefined, import("embla-carousel").EmblaCarouselType | undefined>;
+    carouselRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    orientation: "horizontal" | "vertical" | undefined;
+    scrollNext: () => void;
+    scrollPrev: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:active": (value: number) => any;
+} & {
+    "init-api": (payload: import("embla-carousel").EmblaCarouselType | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onInit-api"?: ((payload: import("embla-carousel").EmblaCarouselType | undefined) => any) | undefined;
+    "onUpdate:active"?: ((value: number) => any) | undefined;
+}>, {
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, 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/carousel/CarouselContent.vue.d.ts

@@ -0,0 +1,24 @@
+import type { WithClassAsProps } from "./interface";
+type __VLS_Props = {
+    /**
+     * Opt-in compositor-only arrival: each slide scales 0.965→1 + fades off its
+     * distance from the viewport centre as it scrolls (transform + opacity ONLY,
+     * clipped inside the viewport — no filter, no layout property). Default off.
+     */
+    arrival?: boolean;
+} & WithClassAsProps;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    arrival: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,21 @@
+import type { WithClassAsProps } from './interface';
+import { type ButtonVariants } from '../button';
+type __VLS_Props = {
+    variant?: ButtonVariants['variant'];
+    size?: ButtonVariants['size'];
+} & WithClassAsProps;
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    variant: "glass" | "link" | "default" | "outline" | "primary-audacious" | "gold-audacious" | "secondary" | "accent" | "ghost" | "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;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};