@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/components/carousel/CarouselPrevious.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;
+    };
+};

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

@@ -0,0 +1,50 @@
+import type { HTMLAttributes } from "vue";
+/**
+ * GlassCarouselPager — audacious carousel pager substrate.
+ *
+ * A canonical chevron-prev + counter-pill + chevron-next + state-toggle row.
+ * Composes `<Button variant="outline" iconOnly>` chevrons with a glass-card
+ * counter pill and an optional toggle slot for collapse/expand affordances.
+ *
+ * Standalone: accepts `:index` / `:total` props and emits `@prev` / `@next` /
+ * `@select(i)`, so it composes with `<Carousel>` (embla — wire via
+ * `useCarousel`) or any manual-state host.
+ */
+type __VLS_Props = {
+    /** Current zero-based slide index. */
+    index: number;
+    /** Total slide count. */
+    total: number;
+    /** Layout orientation. Defaults to horizontal. */
+    orientation?: "horizontal" | "vertical";
+    /** Show "X / N" counter pill. Defaults to true. */
+    showCounter?: boolean;
+    /** Wrap at boundaries instead of disabling. Defaults to false. */
+    loop?: boolean;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_27: {};
+type __VLS_Slots = {} & {
+    trailing?: (props: typeof __VLS_27) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    select: (index: number) => any;
+    next: () => any;
+    prev: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((index: number) => any) | undefined;
+    onNext?: (() => any) | undefined;
+    onPrev?: (() => any) | undefined;
+}>, {
+    loop: boolean;
+    orientation: "horizontal" | "vertical";
+    showCounter: 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/useCarousel.d.ts

@@ -0,0 +1,21 @@
+import type { CarouselEmits, CarouselProps } from './interface';
+declare const CAROUSEL_WEIGHTY_DURATION = 30;
+declare const useProvideCarousel: (args_0: CarouselProps, emits: CarouselEmits) => {
+    carouselRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    carouselApi: import("vue").Ref<import("embla-carousel").EmblaCarouselType | undefined, import("embla-carousel").EmblaCarouselType | undefined>;
+    canScrollPrev: import("vue").Ref<boolean, boolean>;
+    canScrollNext: import("vue").Ref<boolean, boolean>;
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    orientation: "horizontal" | "vertical" | undefined;
+};
+declare function useCarousel(): {
+    carouselRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    carouselApi: import("vue").Ref<import("embla-carousel").EmblaCarouselType | undefined, import("embla-carousel").EmblaCarouselType | undefined>;
+    canScrollPrev: import("vue").Ref<boolean, boolean>;
+    canScrollNext: import("vue").Ref<boolean, boolean>;
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    orientation: "horizontal" | "vertical" | undefined;
+};
+export { useCarousel, useProvideCarousel, CAROUSEL_WEIGHTY_DURATION };

package/dist/components/chip/Chip.vue.d.ts

@@ -0,0 +1,20 @@
+import { type ToggleProps } from "reka-ui";
+import type { ChipProps } from "./types";
+type __VLS_Props = ToggleProps & ChipProps;
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, 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/chip/chipVariants.d.ts

@@ -0,0 +1,43 @@
+import { type VariantProps } from "class-variance-authority";
+/**
+ * chipVariants — the ONE congruent chip recipe (BI.W-CHIP-FOLD; BD.W-CHIP-CONGRUENT-GLASS).
+ *
+ * The chip family (the retired ToggleChip + SelectableChip + the toggle-group
+ * children) is FOLDED onto ONE `<Chip shape × tone>`: a stadium-pill warm-glass
+ * LENS that PUNCHES when you pick it. The Kronecker factorization (BI.W-CHIP-FOLD)
+ * observed that ToggleChip's `variant` (`chip`/`cell`) was a pure NAME-SYNONYM of
+ * SelectableChip's `shape` (`pill`/`cell`) over the SAME CVA — so the two surfaces
+ * merge compile-time onto this ONE recipe (clean break, no alias — the no-legacy
+ * law; the `selectableChipVariants`/`SelectableChipVariants` shim was SWEPT at
+ * BG.W-DEAD-SWEEP). The tonal-accent register (`tone`) is a per-instance style
+ * layered ON this recipe by `Chip.vue`, not a CVA axis.
+ *
+ * The recipe is STRUCTURE + the shared-register hooks: it COMPOSES the read-only
+ * shared registers, never re-forks a parallel glass/cartoon/motion system —
+ *   · `.glass-chip`         — the chip-family material/motion layer (the warm idle
+ *                             floor + the `--glass-fill-tint` plate tint + the ONE
+ *                             scale write + the `::after` colour-flood punch).
+ *   · `.glass-capsule`      — the warm-transmissive lozenge BODY (fill + rim +
+ *                             shadow + blur, on `--radius-pill` → the stadium
+ *                             end-cap at every rung). Radius is INVARIANT — the
+ *                             capsule re-rounds itself at every height; no
+ *                             `rounded-*` rung (retires the 4/6/10px grab-bag).
+ *   · `.glass-capsule-hover`— the SHARED specular-lift + press-snap on hover.
+ *   · `.accent-tone`        — the contrast-floored tonal channels (idle fill /
+ *                             active band / active edge / contrast-safe ink).
+ *
+ * The geometry: radius invariant (the capsule's `--radius-pill`); only padding/
+ * text vary, on a √φ ladder (φ≈1.618). The `cell` is the ONE documented exception
+ * (`.glass-chip--cell` → `--radius-card`): a 72px icon+label tile is a CARD, not a
+ * pill — a DELIBERATE 2-silhouette family, composing the SAME material + motion.
+ *
+ * NO scale CVA — the ONE `scale` write lives on `.glass-chip` (hover/press/punch
+ * folded into a single source of truth; a CVA `hover:scale-*` would collide).
+ * The CVA carries no `color-mix(…--primary…)` literal — the tonal COLOUR is the
+ * `.accent-tone` register's (driven by the `tone` prop's per-instance style).
+ */
+export declare const chipVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    shape?: "cell" | "pill" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ChipVariants = VariantProps<typeof chipVariants>;

package/dist/components/chip/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Chip } from "./Chip.vue";
+export { chipVariants, type ChipVariants } from "./chipVariants";
+export type { ChipProps } from "./types";

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

@@ -0,0 +1,38 @@
+import type { HTMLAttributes } from "vue";
+import type { Surface } from "../_shared/useSurfaceAxis";
+import type { ChipVariants } from "./chipVariants";
+/**
+ * ChipProps — the public prop contract of the folded `<Chip>` (BI.W-CHIP-FOLD).
+ * The chip-specific surface; the reka `Toggle` contract (`modelValue` /
+ * `defaultValue` / `pressed` / `disabled` …) composes ON TOP via `v-model` and is
+ * documented by the reka `Toggle` primitive. `<Chip>` unifies the retired
+ * ToggleChip (`shape`, the plain warm-floor toggle) + SelectableChip (`tone`, the
+ * contrast-floored tonal-accent register) onto ONE surface.
+ */
+export interface ChipProps {
+    /**
+     * The silhouette shape — `pill` (default, the stadium capsule; the retired
+     * ToggleChip `variant="chip"`) | `cell` (the square icon+label tile; the
+     * retired `variant="cell"`). A SILHOUETTE word, not a scale rung.
+     */
+    shape?: ChipVariants["shape"];
+    /** The structural size rung — `sm` | `md` (default) | `lg`. */
+    size?: ChipVariants["size"];
+    /**
+     * The accent COLOUR identity — a complete `<color>` (e.g.
+     * `var(--section-color-7)` or a concrete `oklch(…)`). OPT-IN: unset ⇒ the plain
+     * warm-floor glass toggle (the ToggleChip register). Set ⇒ the tonal-accent
+     * register — the per-instance plate hue + the contrast-safe INK label (the
+     * SelectableChip register). The SEMANTIC choice is a prop; the strength
+     * MAGNITUDES are tokens (no over-prop).
+     */
+    tone?: string;
+    /**
+     * The shared {glass·veil·opaque} surface-decoration axis (BA.W-SURFACE-AXIS).
+     * OPT-IN: unset ⇒ the capsule's own glass material (byte-identical default).
+     * Set ⇒ binds `:data-surface`, and the shared `surface-axis.css` seam applies
+     * the veil/opaque decoration UNIFORMLY.
+     */
+    surface?: Surface;
+    class?: HTMLAttributes["class"];
+}

package/dist/components/combobox/Combobox.vue.d.ts

@@ -0,0 +1,32 @@
+import { type ComboboxRootProps } from 'reka-ui';
+type __VLS_Props = ComboboxRootProps;
+declare var __VLS_9: {
+    open: boolean;
+    modelValue: string | number | bigint | Record<string, any> | (string | number | bigint | Record<string, any> | null)[] | null;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("reka-ui").AcceptableValue) => any;
+    highlight: (payload: {
+        ref: HTMLElement;
+        value: import("reka-ui").AcceptableValue;
+    } | undefined) => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("reka-ui").AcceptableValue) => any) | undefined;
+    onHighlight?: ((payload: {
+        ref: HTMLElement;
+        value: import("reka-ui").AcceptableValue;
+    } | undefined) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, 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/combobox/ComboboxList.vue.d.ts

@@ -0,0 +1,32 @@
+import type { ComboboxContentProps } from 'reka-ui';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = ComboboxContentProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    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;
+    pointerDownOutside: (event: import("reka-ui").PointerDownOutsideEvent) => any;
+    focusOutside: (event: import("reka-ui").FocusOutsideEvent) => any;
+    interactOutside: (event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import("reka-ui").PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any) | undefined;
+}>, {
+    position: "inline" | "popper";
+    align: "center" | "start" | "end";
+    sideOffset: number;
+}, {}, {}, {}, 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/command/index.d.ts

@@ -0,0 +1,10 @@
+export { default as Command } from './Command.vue';
+export { default as CommandDialog } from './CommandDialog.vue';
+export { default as CommandEmpty } from './CommandEmpty.vue';
+export { default as CommandGroup } from './CommandGroup.vue';
+export { default as CommandInput } from './CommandInput.vue';
+export { default as CommandItem } from './CommandItem.vue';
+export { default as CommandList } from './CommandList.vue';
+export { default as CommandSeparator } from './CommandSeparator.vue';
+export { default as CommandShortcut } from './CommandShortcut.vue';
+export type { MenuItemVariants } from '../_shared';

package/dist/components/completion-seal/CompletionSeal.vue.d.ts

@@ -0,0 +1,28 @@
+import { type CompletionSealShape } from "./constants";
+export interface CompletionSealProps {
+    /** The seal glyph — `check` (default) | `ring` | `disc` | `wordmark`. */
+    shape?: CompletionSealShape;
+    /**
+     * The accessible completion announcement (the `role="status"`/`aria-live` text — a
+     * screen reader hears "Speedtest complete", etc.). The gold mark is the visual.
+     */
+    label?: string;
+    /**
+     * The draw trigger — the consumer fires it on completion. When it flips truthy the
+     * seal draws ONCE. Default (unset) plays on mount (the seal draws when it appears —
+     * the canonical completion moment).
+     */
+    play?: boolean;
+    /**
+     * The earned-gold garnish (BG.W-SEAL-DISC) — the result exceeded the user's
+     * historical best. Arms `[data-best]`, which re-points `--seal-ink` onto the brighter
+     * `--seal-best` earned-gold register (a colour LIFT within the gold family — gold is
+     * EARNED, Q2). Compositor-only; the base seal ink stays the completion register.
+     */
+    personalBest?: boolean;
+    /** Pass-through class on the root. */
+    class?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<CompletionSealProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CompletionSealProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/completion-seal/constants.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The seal glyph axis — the mark the gold stroke draws:
+ *  - `check` (default) — a checkmark (the canonical "done" garnish).
+ *  - `ring`  — a ring/circle around the completion (a seal around the event).
+ *  - `disc`  — the composed earned-coin gesture: a filled gold disc FACE with the ring
+ *    stroke-draw affirmation around it and the check draw-in inside, SEQUENCED
+ *    disc→ring→check (the hero completion coin — BG.W-SEAL-DISC / SPEEDTEST-AX #1).
+ *  - `wordmark` — a self-contained seal mark (a stylized seal glyph).
+ *
+ * `check`/`ring`/`wordmark` share the ONE gold-draw mechanism (the `--seal-draw`
+ * stroke-reveal on the `--seal-ink` gold stroke) — a `shape`-scoped path, NOT a second
+ * recipe. `disc` COMPOSES that same mechanism across three layers (the disc face fades
+ * in, then the ring RE-USES the ring geometry to draw around, then the check RE-USES the
+ * check path to draw in) — no fourth recipe, the layers stagger on animation-delay off
+ * the `--seal-ring-delay`/`--seal-check-delay` seam. The seal is the GOLD-DRAW completion
+ * register, distinct from the HandMark hand-voice family.
+ */
+export type CompletionSealShape = "check" | "ring" | "disc" | "wordmark";
+/** The default seal glyph — the checkmark "done" garnish. */
+export declare const COMPLETION_SEAL_DEFAULT_SHAPE: CompletionSealShape;
+/**
+ * The normalized SVG viewBox the glyphs are authored in. The mark `pathLength="100"`
+ * normalizes every glyph's draw length so the `stroke-dashoffset` wipe is path-agnostic
+ * (the recipe reads `--seal-draw` 0..100% against the normalized length).
+ */
+export declare const COMPLETION_SEAL_VIEWBOX = "0 0 64 64";
+/**
+ * The per-shape SVG path/element the gold stroke draws. `check`/`wordmark` are <path>
+ * `d`-strings; `ring` is drawn as a <circle> and `disc` COMPOSES the ring geometry + the
+ * check path (the SFC branches on shape), so neither authors its own path here. Authored
+ * in the 64×64 viewBox, `pathLength="100"` normalized at the element.
+ */
+export declare const COMPLETION_SEAL_PATHS: Record<Exclude<CompletionSealShape, "ring" | "disc">, string>;
+/**
+ * The `ring` glyph geometry (a <circle>) — the centre + radius in the 64×64 viewBox.
+ * A near-perimeter ring so the seal reads hero-scale. The `disc` shape REUSES this same
+ * circle for its stroke-draw affirmation ring (one geometry, two reads).
+ */
+export declare const COMPLETION_SEAL_RING: {
+    readonly cx: 32;
+    readonly cy: 32;
+    readonly r: 24;
+};
+/**
+ * The `disc` glyph FACE geometry (a filled <circle>) — the earned-coin face the ring
+ * draws around. Inset 3px inside the ring radius so the drawn ring reads as a clean rim
+ * around the coin (the disc→ring→check gesture: face → rim → mark). The check path
+ * (COMPLETION_SEAL_PATHS.check) fits inside this radius.
+ */
+export declare const COMPLETION_SEAL_DISC: {
+    readonly cx: 32;
+    readonly cy: 32;
+    readonly r: 21;
+};
+/**
+ * The SPRING register the draw rides (SPRING-EASE / W-MOTION-CANON P2 enter-bouncy):
+ *  - the SETTLE leg (the spatial overshoot) rides `--spring-bouncy` (an ENTER may
+ *    overshoot on arrival);
+ *  - the DRAW + GLINT legs ride the `--spring-snappy` CLOCK (the snappy settle duration)
+ *    so the gold inks crisply, not languidly.
+ * The seal mints NO new spring token — it READS the SPRING-EASE register (the no-new-clock
+ * fence). These names are the recorded register choice; the actual curves live in the
+ * cascade (tokens/scheme-motion.css) and the recipe (completion-seal.css) reads them.
+ */
+export declare const COMPLETION_SEAL_SETTLE_SPRING = "--spring-bouncy";
+export declare const COMPLETION_SEAL_DRAW_SPRING = "--spring-snappy";

package/dist/components/configurator/Configurator.vue.d.ts

@@ -0,0 +1,160 @@
+import { type HTMLAttributes } from "vue";
+import { type ConfiguratorSize } from "./size";
+/**
+ * Scroll behavior for the controls column.
+ *
+ * - `auto`   — the controls column renders a <FadingScroll axis="y"> scroll-port
+ *              (sharp at rest, feathered while overflowing); controls scroll when
+ *              their intrinsic height exceeds the host. Default.
+ * - `always` — same <FadingScroll> scroll-port + thin scrollbar. Use when
+ *              authors want a fixed-height studio regardless of content.
+ * - `never`  — controls do not scroll; host grows to content height. Renders a
+ *              plain div (no FadingScroll). Use for popover/sheet hosts that
+ *              already manage their own overflow.
+ */
+export type ConfiguratorScrollMode = "auto" | "always" | "never";
+/**
+ * Which side the aside (preset row + controls) sits on at `lg`+ width.
+ *
+ * `right` (default) is the inspector idiom — stage left, controls right.
+ * `left` is a reversible, taste-level flip: the aside renders on the
+ * left while DOM/tab order stays stage→aside (the flip is grid-column
+ * placement + border-side only, no source reorder — no a11y regression).
+ * Below `lg` the layout is a single column and the side has no meaning.
+ */
+export type ConfiguratorAsideSide = "left" | "right";
+/**
+ * Where the preset gallery sits.
+ *
+ * `aside` (default) keeps the preset row inside the right-hand aside (the
+ * inspector idiom — the legacy placement, unchanged).
+ *
+ * `top` lifts the gallery OUT of the 360px aside and pins it as a large,
+ * full-width, horizontally-scrollable glass dock across the TOP of the studio
+ * frame — the §2.1 reflow (gallery up-top + larger + scrollable). The stage +
+ * controls reclaim the full height below it. An additive axis: the grid arm is
+ * the precompiled `[data-slot=configurator][data-gallery=top]` rule in
+ * configurator.css (never a dead JIT bracket — the BC.W-CONFIG-RIGHT lesson).
+ */
+export type ConfiguratorGalleryPlacement = "aside" | "top";
+/**
+ * Generic preset descriptor. Consumers pass `T` as the live config shape.
+ * The primitive carries no preset semantics beyond `key + label` for
+ * the picker row and `config: T` for the active payload — preset
+ * selection / diff-from-preset / reset semantics live in the optional
+ * `useConfiguratorState<T>` composable.
+ */
+export interface ConfiguratorPreset<T> {
+    readonly key: string;
+    readonly label: string;
+    readonly sub?: string;
+    /** Optional baked thumbnail (data URL or static path). */
+    readonly thumb?: string;
+    readonly config: T;
+}
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        /** Optional preset table; presented to the `presets` slot fallback. */
+        presets?: readonly ConfiguratorPreset<T>[];
+        /** Currently active preset key — display only; selection is the consumer's. */
+        activePreset?: string;
+        /** Optional layer descriptors; presented to `controls` slot fallback. */
+        layers?: readonly {
+            id: string;
+            label: string;
+        }[];
+        /** Active layer id — display only; switching is the consumer's. */
+        activeLayer?: string;
+        /** Scroll behavior for the controls column. Default: `auto`. */
+        scrollMode?: ConfiguratorScrollMode;
+        /**
+         * Row-level density axis (N.W2 Lane A). Cascades to descendant
+         * `<ConfiguratorRow>` children via provide/inject. A row may
+         * override locally by setting its own `size` prop (prop wins
+         * over inject). Default `"md"` preserves the prior
+         * `gap-1.5 py-2` recipe exactly.
+         */
+        size?: ConfiguratorSize;
+        /**
+         * Which side the aside sits on at `lg`+ width. Default `"right"`
+         * (the inspector idiom). `"left"` flips the visual column via
+         * grid-column placement + border-side swap only — DOM/tab order
+         * stays stage→aside. No effect below `lg` (single-column).
+         */
+        asideSide?: ConfiguratorAsideSide;
+        /**
+         * Where the preset gallery sits. Default `"aside"` (the inspector idiom).
+         * `"top"` pins the gallery as a large full-width scrollable glass dock
+         * across the top of the studio (the §2.1 up-top reflow), driven by the
+         * precompiled `[data-gallery="top"]` rule in configurator.css.
+         */
+        galleryPlacement?: ConfiguratorGalleryPlacement;
+        /**
+         * Aside width band at `lg`+ width, as a CSS length pair driving
+         * `minmax(--configurator-aside-min, --configurator-aside-max)`. The
+         * prop sets the two inline custom properties; consumers may instead
+         * (or also) set `--configurator-aside-min` / `--configurator-aside-max`
+         * via the cascade. Default band is `280px`/`360px`. Pass a single
+         * length to pin the band (`min === max`), or a `[min, max]` pair.
+         */
+        asideWidth?: string | readonly [min: string, max: string];
+        /** Optional outer container override. */
+        class?: HTMLAttributes["class"];
+    } & {
+        onReset?: (() => any) | undefined;
+        "onSelect-preset"?: ((key: string) => any) | undefined;
+        "onSelect-layer"?: ((id: string) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        presets?: (props: {
+            presets: readonly ConfiguratorPreset<T>[] | undefined;
+            activePreset: string | undefined;
+        }) => any;
+    } & {
+        stage?: (props: {}) => any;
+    } & {
+        controls?: (props: {
+            layers: readonly {
+                id: string;
+                label: string;
+            }[] | undefined;
+            activeLayer: string | undefined;
+            selectLayer: (id: string) => void;
+        }) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        controls?: (props: {
+            layers: readonly {
+                id: string;
+                label: string;
+            }[] | undefined;
+            activeLayer: string | undefined;
+            selectLayer: (id: string) => void;
+        }) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {
+            reset: () => void;
+        }) => any;
+    };
+    emit: {
+        (e: "select-preset", key: string): void;
+        (e: "select-layer", id: string): void;
+        (e: "reset"): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/configurator/ConfiguratorRow.vue.d.ts

@@ -0,0 +1,96 @@
+import { type HTMLAttributes } from "vue";
+import { type ConfiguratorSize } from "./size";
+/**
+ * <ConfiguratorRow> — labeled control row for a single field inside a
+ * <ConfiguratorLayer>. Mirrors the demo's PresetEditorField surface
+ * (label + token-name + optional reset + description) but ships from
+ * the library so consumers can compose configurators without re-rolling
+ * the row layout.
+ *
+ * Slot consumes the actual control (Slider, Select, Switch, NumberField,
+ * etc.). The reset button is opt-in via `canReset`; emits a `reset`
+ * event the consumer wires to its own field-clear path.
+ *
+ * # The double-label API (value.js L14)
+ *
+ * The label header is a first-class TRIPLE: `label` (the primary, sans /
+ * medium), the optional `sub` (a SECONDARY descriptive label — sans, muted —
+ * paired inline with the primary), and the optional `name` (the mono token /
+ * spec reference, or a live numeric readout). All three are declarative props,
+ * so a consumer expresses a "double-label" row (primary + secondary) WITHOUT a
+ * `:deep()` reach into the slot or a hand-rolled in-slot sans+mono pair. Use
+ * `sub` for a descriptive secondary label and `name` for a mono token/value.
+ *
+ * # Size axis (BH.W-SIZE-UNIFY)
+ *
+ * The row honors a three-rung size axis (`sm` | `md` | `lg`).
+ * Resolution order:
+ *
+ * 1. Local `size` prop (highest priority).
+ * 2. `<Configurator>` inject (`CONFIGURATOR_SIZE_KEY`).
+ * 3. `undefined` — the row keeps its baked-in `gap-1.5 py-2` recipe and
+ *    emits no `data-size` attribute (bare-row visual preserved).
+ *
+ * When size resolves to a value, the root gets `data-size="…"`
+ * and the token-driven CSS rule overrides the Tailwind gap. The
+ * `"md"` rung is functionally identical to the no-size
+ * fallback; it exists so consumers can be explicit.
+ *
+ * # ConfiguratorRow vs LabeledField — recorded divergence (AZ.W-METRIC-UNIFY §B)
+ *
+ * Both are "label (+ meta) above/beside a slotted control", but they are NOT
+ * interchangeable — they emphasize DIFFERENT features:
+ *  - **ConfiguratorRow** (this) — for TOKEN / PRESET controls. Carries the
+ *    token-`name` reference, the opt-in `reset` affordance (`canReset`), and the
+ *    three-rung `size` axis (local-prop-over-inject). No a11y for/id wiring.
+ *  - **LabeledField** — for FORM fields. Carries the `for`/`id` label↔control
+ *    a11y wiring (`controlId`/`labelId`/`errorId`), the `tooltip`, the `required`
+ *    asterisk, and the `aria-live` `error` region.
+ *
+ * Reach for ConfiguratorRow inside a `<Configurator>` for token sliders/selects;
+ * reach for LabeledField for accessible form inputs. The divergence is recorded
+ * (NOT a forced merge — no ≥2-consumer shared-chassis need surfaced) in
+ * `docs/precepts/design-idioms.md §9`, alongside the `cn`/`focus-ring` keeps.
+ */
+type __VLS_Props = {
+    /** Display label (top-left, primary). */
+    label: string;
+    /**
+     * Optional SECONDARY label (value.js L14 — the double-label API). A
+     * descriptive secondary rung paired inline with the primary `label` (sans,
+     * muted), distinct from the mono `name` token/value. Lets a consumer express
+     * a two-part label declaratively — no `:deep()` reach, no in-slot label pair.
+     */
+    sub?: string;
+    /** Optional token name / spec reference (right of label, monospaced). */
+    name?: string;
+    /** Optional helper / value description (below the control). */
+    description?: string;
+    /** Show the reset affordance (top-right). */
+    canReset?: boolean;
+    /**
+     * Size rung. Overrides the value injected by an ancestor
+     * `<Configurator>` when set. Omit to follow the inject (or to fall
+     * back to the pre-N.W2 `gap-1.5 py-2` recipe when there is no
+     * ancestor configurator).
+     */
+    size?: ConfiguratorSize;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_12: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_12) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    reset: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onReset?: (() => any) | undefined;
+}>, {}, {}, {}, {}, 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/configurator/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Configurator } from "./Configurator.vue";
+export { default as ConfiguratorLayer } from "./ConfiguratorLayer.vue";
+export { default as ConfiguratorRow } from "./ConfiguratorRow.vue";
+export type { ConfiguratorAsideSide, ConfiguratorGalleryPlacement, ConfiguratorPreset, ConfiguratorScrollMode, } from "./Configurator.vue";
+export { CONFIGURATOR_SIZE_KEY, provideConfiguratorSize, useOptionalConfiguratorSize, type ConfiguratorSize, } from "./size";
+export { useConfiguratorState, type ConfiguratorCloneMode, type ConfiguratorState, type ConfiguratorStateOptions, } from "./useConfiguratorState";