@mkbabb/glass-ui 4.2.0 → 6.0.0

package/dist/components/drawer/composables/drawerSnapContext.d.ts

@@ -0,0 +1,28 @@
+import type { Ref } from "vue";
+import type { DrawerDirection, DrawerMode } from "../index";
+/**
+ * The snap seam the root provides + the content consumes. The root resolves the
+ * effective ladder (consumer `snapPoints` ?? the direction-derived default) + the
+ * direction; the content binds the drag gesture against it. The read-only refs
+ * (`snapPoints`/`direction`) are root-derived computeds; `open`/`activeSnapPoint`
+ * are writable so the engine round-trips the open-control + the snap-fraction.
+ */
+export interface DrawerSnapContext {
+    /** The drawer's open state (mirrors the reka root's `v-model:open`). */
+    open: Ref<boolean>;
+    /** The resolved detent ladder (fractions 0..1; empty = full-slide side-lens). */
+    snapPoints: Readonly<Ref<readonly number[]>>;
+    /** The drag/slide axis. */
+    direction: Readonly<Ref<DrawerDirection>>;
+    /** The root presentation mode; the content owns the mode-specific layer contract. */
+    mode: Readonly<Ref<DrawerMode>>;
+    /** The live active detent fraction (the `v-model:active-snap-point` writeback). */
+    activeSnapPoint: Ref<number | string | null>;
+}
+export declare const DRAWER_SNAP_KEY: import("vue").InjectionKey<DrawerSnapContext>;
+export declare function provideDrawerSnapContext(context: DrawerSnapContext): void;
+/**
+ * Befitting-silent — returns `null` for a `<DrawerContent>` rendered outside a
+ * `<Drawer>` (a misuse the optional context renders bare for, rather than throwing).
+ */
+export declare const useOptionalDrawerSnapContext: () => DrawerSnapContext | null;

package/dist/components/drawer/composables/useDrawerSnap.d.ts

@@ -0,0 +1,24 @@
+import { type Ref } from "vue";
+import type { DrawerSnapContext } from "./drawerSnapContext";
+export interface UseDrawerSnapOptions {
+    /**
+     * Resolve the content sheet element LIVE (the `--glass-drawer-t` host + the drag
+     * bound box). A GETTER, never a snapshotted ref — reka's `DialogContent` forwards
+     * its root element THROUGH a `<Presence>` swap, so a `$el` captured at first mount
+     * is a stale comment placeholder and the writer's `if (el)` guard skips forever
+     * (the F5.R2 model↔paint SEVER — `writeScalar` "never fires"). Resolving the element
+     * fresh on every write reaches the painted sheet the instant `<Presence>` mounts it.
+     */
+    contentEl: () => HTMLElement | null;
+    /** The handle element (the grip the user drags to cycle detents). */
+    handleEl: Ref<HTMLElement | null>;
+    /** The provided snap seam (the ladder, open ref, direction, snap-fraction writeback). */
+    ctx: DrawerSnapContext;
+}
+export interface UseDrawerSnapReturn {
+    /** Whether a pointer drag is in flight (drives the grip's "live" affordance). */
+    dragging: Ref<boolean>;
+    /** Programmatically settle to a detent fraction (the open-sheet re-snap seam). */
+    snapTo(fraction: number): void;
+}
+export declare function useDrawerSnap(options: UseDrawerSnapOptions): UseDrawerSnapReturn;

package/dist/components/drawer/constants.d.ts

@@ -0,0 +1,50 @@
+import type { DrawerDirection } from "./index";
+/**
+ * The ONE drawer-snap spring authority — the sheet-settle (response, ζ) register the
+ * house `SpringProgress` snap engine (`useDrawerSnap.ts`) drives `--glass-drawer-t`
+ * off. This is the drawer's OWN settle clock — NOT a re-use of the dock's
+ * `DOCK_SPRING` morph-settle (the per-spring-clock §6 doctrine: each register is its
+ * own clock; a sheet that flings up to a detent settles slower + with a touch more
+ * give than the dock's crisp 0.32/0.7 box-morph). Co-located here so the pair is
+ * defined ONCE rather than at the top of the composable.
+ *
+ * BD.W-ANIM-IOS27-TUNE re-tuned `{0.4, 0.82}` → `{0.50, 0.74}` for inertial liquid
+ * MASS — but that value was calibrated against the PRE-M1 broken CSS/JS time base AND
+ * the pre-BI.W-DRAWER-PERF main-thread storm (the lag was never the spring). BI judgment
+ * (g), user-delegated + orchestrator-ratified 2026-07-12: re-pinned `{0.50, 0.74}` →
+ * **`{0.32, 0.80}`** — the measured-iOS drawer band (the iOS-27 frame analysis: brisk
+ * arrival, ~1.5% overshoot; weight ≠ slow). Lands POST-SPRING-PARITY (M1 committed
+ * 75c9e433) + POST-DRAWER-PERF (7a9faa07), per the ordering law: no spring retune
+ * before M1. The A/B capture pair rides the π batch (W-DRAWER-PERF-DELTA).
+ * The fling-decision (`DRAWER_FLING_VELOCITY`) is SEPARATE + unchanged.
+ */
+export declare const DRAWER_SNAP: {
+    readonly response: 0.32;
+    readonly dampingFraction: 0.8;
+};
+/**
+ * BB-2 (the direction-aware default snap ladder fold) — the peek/half/full detent
+ * ladder a live-behind bottom/top sheet resolves when the consumer passes no
+ * `snapPoints`. The
+ * value (12% peek · 50% half · 100% full) is the `DEFAULT_LIVE_SNAP_POINTS` shape
+ * the prior vaul wrapper hardcoded, re-homed into the engine as the bottom/top
+ * default. A side-lens (left/right) sheet resolves a FULL-SLIDE instead (no detents)
+ * — `resolveDefaultSnapPoints` returns `[]` for the side axis.
+ */
+export declare const BOTTOM_SHEET_LADDER: readonly number[];
+/**
+ * BB-2 — resolve the LIVE-BEHIND default snap ladder from `direction` natively. A
+ * bottom/top sheet gets the peek/half/full ladder; a left/right side-lens gets a
+ * full-slide (no detents — an empty ladder, so `useDrawerSnap` treats it as a single
+ * open/closed slide). A consumer-supplied `snapPoints` always wins over this default.
+ */
+export declare function resolveDefaultSnapPoints(direction: DrawerDirection): readonly number[];
+/**
+ * The drag-release velocity threshold (px/s). A flung drag whose release velocity
+ * exceeds this advances a detent in the drag direction (the `useDockState`-style
+ * velocity-aware decision); a slow release below it snaps to the NEAREST detent. The
+ * sign of the velocity selects the direction (toward-open vs toward-closed).
+ */
+export declare const DRAWER_FLING_VELOCITY = 450;
+/** `Symbol()` label for the `DrawerSnapContext` injection key (`drawerSnapContext.ts`). */
+export declare const DRAWER_SNAP_LABEL = "glass-ui:drawer-snap-context";

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

@@ -0,0 +1,33 @@
+export { DialogTrigger as DrawerTrigger, DialogClose as DrawerClose, } from "reka-ui";
+/**
+ * Drawer drag/slide direction (BB.W-DRAWER-ABROGATE). `bottom` (default) + `top`
+ * can carry peek/half/full detents; `left`/`right` are the side-lens full-slide
+ * axes. Only `mode="live-behind"` resolves a default ladder (bottom/top →
+ * `[0.12, 0.5, 1]`); ordinary modal drawers without `snapPoints` rest fully open.
+ */
+export type DrawerDirection = "top" | "bottom" | "left" | "right";
+/**
+ * Drawer presentation mode (AN.W3). `"modal"` is the default iOS scale-down sheet —
+ * focus-trapped (reka `:modal="true"`), page-behind scaled. `"live-behind"` is the
+ * non-modal peek/half/full bottom sheet — reka `:modal="false"` (no focus trap, no
+ * page `aria-hidden`, page-behind at native size + interactive) — bundling the
+ * `modal:false` + `stage:"none"` + the direction-derived snap ladder. Explicit props
+ * still override the mode's defaults.
+ */
+export type DrawerMode = "modal" | "live-behind";
+/**
+ * BD.W-OVERLAY-STAGE-COUPLE — the honest scene-staging enum. `none` leaves the page
+ * untouched; `dim` deepens the scrim only (the PRM-safe luminance depth cue); `scale`
+ * recedes +
+ * scales the page (the iOS card-recede); `immersive` adds the backdrop-blur engage.
+ * `modal` defaults to `scale`; `live-behind` to `none`. PRM degrades `scale`/
+ * `immersive` to `dim`. All four couplings ride the ONE `--stage-t` scalar the snap
+ * engine writes at `:root`.
+ */
+export type DrawerStage = "none" | "dim" | "scale" | "immersive";
+export { default as Drawer } from "./Drawer.vue";
+export { default as DrawerContent } from "./DrawerContent.vue";
+export { default as DrawerHeader } from "./DrawerHeader.vue";
+export { default as DrawerFooter } from "./DrawerFooter.vue";
+export { default as DrawerTitle } from "./DrawerTitle.vue";
+export { default as DrawerDescription } from "./DrawerDescription.vue";

package/dist/components/drawer/styles.css

@@ -0,0 +1 @@
+@property --glass-drawer-t { syntax: "<number>"; inherits: false; initial-value: 0; } @property --stage-t { syntax: "<number>"; inherits: false; initial-value: 0; } [data-stage-scrim][data-stage-flip], [data-stage-wrapper][data-stage-flip] { transition: --stage-t var(--spring-snappy-duration, 0.4s) var(--spring-snappy, ease); } :root { --drawer-inset-block-end: 0px; --drawer-handle-w: 2.25rem; --drawer-handle-h: 0.3125rem; --drawer-handle-color: var(--muted-foreground); --drawer-handle-opacity: 0.45; --drawer-handle-opacity-active: 0.85; --drawer-snap-rule-color: color-mix(in srgb, var(--border) 60%, transparent); } .glass-drawer { position: fixed; inset-inline: 0; bottom: 0; z-index: var(--z-modal); display: flex; flex-direction: column; height: auto; max-height: 97vh; margin-top: 6rem; border-bottom: 0; border-start-start-radius: var(--radius-panel); border-start-end-radius: var(--radius-panel); } .glass-drawer[data-mode="live-behind"] { z-index: calc(var(--z-dock) - 1); } .glass-drawer[data-surface="veil"] { --veil-bg: color-mix( in oklab, var(--glass-bg-quiet), var(--glass-tint-source) var(--glass-tint-strength) ); --veil-blur: var(--glass-blur-quiet); background: var(--veil-bg); -webkit-backdrop-filter: var(--veil-blur); backdrop-filter: var(--veil-blur); -webkit-backdrop-filter: var(--veil-blur); border: none; box-shadow: none; } .glass-drawer[data-surface="opaque"] { --glass-level: 0; --glass-tint-strength: 0%; background: color-mix(in srgb, var(--card), transparent 0%); -webkit-backdrop-filter: none; backdrop-filter: none; -webkit-backdrop-filter: none; } .glass-drawer[data-glass-drawer-snap-points="true"] { height: 100%; max-height: 100%; margin-top: 0; } .glass-drawer[data-glass-drawer-snap-points="true"][data-glass-drawer-direction="bottom"] { bottom: var(--drawer-inset-block-end); height: calc(100% - var(--drawer-inset-block-end)); max-height: calc(100% - var(--drawer-inset-block-end)); } .glass-drawer[data-glass-drawer-snap-points="true"] { --sheet-descent: clamp(0, calc(var(--stage-t) / 0.85), 1); --sheet-freeze: clamp(0, calc((var(--stage-t) - 0.85) / 0.15), 1); --sheet-crown: color-mix( in oklab, color-mix( in oklab, var(--glass-bg-overlay), var(--glass-tint-source) var(--glass-tint-strength) ), var(--glass-bg-sheet) calc(var(--sheet-descent) * 100%) ); --sheet-solid: color-mix( in oklab, var(--card), var(--glass-capsule-warm) var(--glass-capsule-warm-floor, 16%) ); background: color-mix( in oklab, var(--sheet-crown), var(--sheet-solid) calc(var(--sheet-freeze) * 100%) ); --glass-blur-engage-t: calc( clamp(0, calc(var(--glass-drawer-t) / var(--glass-blur-engage-knee, 0.35)), 1) * (1 - var(--sheet-freeze)) ); -webkit-backdrop-filter: blur( calc(var(--glass-blur-overlay-radius, 20px) * var(--glass-blur-engage-t)) ) saturate(1.6); backdrop-filter: blur( calc(var(--glass-blur-overlay-radius, 20px) * var(--glass-blur-engage-t)) ) saturate(1.6); } .glass-drawer[data-glass-drawer-snap-points="true"][data-surface="opaque"] { background: color-mix(in srgb, var(--card), transparent 0%); -webkit-backdrop-filter: none; backdrop-filter: none; -webkit-backdrop-filter: none; } .glass-drawer[data-glass-drawer-direction="top"] { bottom: auto; top: 0; margin-top: 0; margin-bottom: 6rem; border-top: 0; border-bottom: 1px solid var(--glass-border-overlay); border-radius: 0 0 var(--radius-panel) var(--radius-panel); } .glass-drawer[data-glass-drawer-direction="left"], .glass-drawer[data-glass-drawer-direction="right"] { inset-inline: auto; inset-block: 0; height: 100%; max-height: 100%; width: min(24rem, 92vw); margin: 0; border: 1px solid var(--glass-border-overlay); } .glass-drawer[data-glass-drawer-direction="left"] { left: 0; border-left: 0; border-radius: 0 var(--radius-panel) var(--radius-panel) 0; } .glass-drawer[data-glass-drawer-direction="right"] { right: 0; border-right: 0; border-radius: var(--radius-panel) 0 0 var(--radius-panel); } .glass-drawer-handle { flex-shrink: 0; display: flex; align-items: center; justify-content: center; min-block-size: var(--touch-target, 2.75rem); padding-block: 0.75rem 0.5rem; touch-action: none; cursor: grab; } .glass-drawer-handle:focus-visible { outline: none; } .glass-drawer-handle:focus-visible .glass-drawer-grip { opacity: var(--drawer-handle-opacity-active); box-shadow: 0 0 0 3px var(--focus-ring-color); } .glass-drawer-grip { display: block; width: var(--drawer-handle-w); height: var(--drawer-handle-h); border-radius: var(--radius-pill); background-color: var(--drawer-handle-color); opacity: var(--drawer-handle-opacity); transition: opacity var(--duration-fast) var(--ease-out), width var(--duration-fast) var(--ease-out); } .glass-drawer-handle[data-dragging] .glass-drawer-grip, .glass-drawer-handle:active .glass-drawer-grip, .glass-drawer:hover .glass-drawer-grip { opacity: var(--drawer-handle-opacity-active); width: calc(var(--drawer-handle-w) * 1.15); } .glass-drawer-snap-rule { height: 1px; margin-inline: calc(var(--radius-panel) * -0.5); border: 0; background-color: var(--drawer-snap-rule-color); } [data-stage-scrim] { background: color-mix( in srgb, var(--overlay-scrim-ink) calc((0.28 + clamp(0, var(--stage-t), 1) * 0.44) * 100%), transparent ); } [data-stage-wrapper][data-stage-scale] { scale: calc(1 - 0.05 * clamp(0, var(--stage-t), 1)); border-radius: calc(var(--radius-panel) * clamp(0, var(--stage-t), 1)); transform-origin: 50% 0; overflow: clip; } [data-stage-scrim][data-stage-immersive] { -webkit-backdrop-filter: blur(16px); backdrop-filter: blur(16px); -webkit-backdrop-filter: blur(16px); } @media (prefers-reduced-motion: reduce) { .glass-drawer-grip { transition: none; } }

package/dist/components/dropdown-menu/DropdownMenu.vue.d.ts

@@ -0,0 +1,24 @@
+import type { DropdownMenuRootProps } from 'reka-ui';
+import { type MenuTrigger } from './useMenuTrigger';
+type __VLS_Props = DropdownMenuRootProps & {
+    trigger?: MenuTrigger;
+};
+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, {
+    "update:open": (payload: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((payload: boolean) => any) | undefined;
+}>, {
+    trigger: MenuTrigger;
+}, {}, {}, {}, 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/dropdown-menu/DropdownMenuContent.vue.d.ts

@@ -0,0 +1,36 @@
+import { type HTMLAttributes } from 'vue';
+import { type DropdownMenuContentProps } from 'reka-ui';
+import { type Surface } from '../_shared/useSurfaceAxis';
+type __VLS_Props = DropdownMenuContentProps & {
+    class?: HTMLAttributes['class'];
+    surface?: Surface;
+};
+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;
+    closeAutoFocus: (event: Event) => 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;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    surface: Surface;
+    sideOffset: number;
+    align: "end" | "start" | "center";
+}, {}, {}, {}, 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/dropdown-menu/DropdownMenuTrigger.vue.d.ts

@@ -0,0 +1,20 @@
+import { type DropdownMenuTriggerProps } from 'reka-ui';
+export type DropdownMenuTriggerAction = 'click' | 'pointerdown';
+type __VLS_Props = DropdownMenuTriggerProps & {
+    action?: DropdownMenuTriggerAction;
+};
+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, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    action: DropdownMenuTriggerAction;
+}, {}, {}, {}, 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/dropdown-menu/index.d.ts

@@ -0,0 +1,15 @@
+export type { MenuTrigger } from './useMenuTrigger';
+export { default as DropdownMenu } from './DropdownMenu.vue';
+export { default as DropdownMenuTrigger } from './DropdownMenuTrigger.vue';
+export { default as DropdownMenuContent } from './DropdownMenuContent.vue';
+export { default as DropdownMenuGroup } from './DropdownMenuGroup.vue';
+export { default as DropdownMenuRadioGroup } from './DropdownMenuRadioGroup.vue';
+export { default as DropdownMenuItem } from './DropdownMenuItem.vue';
+export { default as DropdownMenuCheckboxItem } from './DropdownMenuCheckboxItem.vue';
+export { default as DropdownMenuRadioItem } from './DropdownMenuRadioItem.vue';
+export { default as DropdownMenuShortcut } from './DropdownMenuShortcut.vue';
+export { default as DropdownMenuSeparator } from './DropdownMenuSeparator.vue';
+export { default as DropdownMenuLabel } from './DropdownMenuLabel.vue';
+export { default as DropdownMenuSub } from './DropdownMenuSub.vue';
+export { default as DropdownMenuSubTrigger } from './DropdownMenuSubTrigger.vue';
+export { default as DropdownMenuSubContent } from './DropdownMenuSubContent.vue';

package/dist/components/dropdown-menu/useMenuTrigger.d.ts

@@ -0,0 +1,14 @@
+import { type ComputedRef, type Ref } from "vue";
+/** The Menu trigger axis — the sealed Kronecker fold of ContextMenu onto Menu. A
+ *  subset of the grammar `TRIGGERS` tuple (`click | hover | context`): a menu has no
+ *  hover-open register (that is the Popover overlay fold), so it carries click|context. */
+export type MenuTrigger = "click" | "context";
+/** The root calls this once with its `trigger` ref so every descendant part resolves
+ *  the correct reka family. */
+export declare function provideMenuTrigger(trigger: Ref<MenuTrigger>): void;
+/** The trigger ref for the nearest Menu root (defaults to `click`). */
+export declare function useMenuTrigger(): Ref<MenuTrigger>;
+/** The menu part names (the PART_PAIRS keys — annotated union, portable in d.ts). */
+export type MenuPart = "Root" | "Trigger" | "Portal" | "Content" | "Item" | "CheckboxItem" | "RadioItem" | "RadioGroup" | "Group" | "Separator" | "Label" | "Sub" | "SubTrigger" | "SubContent" | "ItemIndicator";
+/** The reka component for `part`, reactive to the injected trigger. */
+export declare function useMenuPart(part: MenuPart): ComputedRef<unknown>;

package/dist/components/easing/EasingConfigurator.vue.d.ts

@@ -0,0 +1,33 @@
+import type { EasingPickerMode, EasingPickerValue, JumpTerm } from "./composables/useEasingPicker";
+type __VLS_Props = {
+    /** Section label for the configurator layer. */
+    label?: string;
+    /** A token-style sub-label (the mono caption rung). */
+    name?: string;
+    /** The curve-authoring mode. */
+    mode?: EasingPickerMode;
+    /** The initial bezier preset key. */
+    preset?: string;
+    /** The initial step count. */
+    steps?: number;
+    /** The initial step jump term. */
+    term?: JumpTerm;
+};
+type __VLS_ModelProps = {
+    modelValue?: EasingPickerValue;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: EasingPickerValue | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: EasingPickerValue | undefined) => any) | undefined;
+}>, {
+    name: string;
+    label: string;
+    mode: EasingPickerMode;
+    steps: number;
+    preset: string;
+    term: JumpTerm;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/easing/EasingPicker.vue.d.ts

@@ -0,0 +1,49 @@
+import { type EasingPickerMode, type EasingPickerValue, type JumpTerm } from "./composables/useEasingPicker";
+type __VLS_Props = {
+    /** The curve-authoring mode — `"bezier"` (draggable cubic-bezier) or
+     *  `"steps"` (the steppedEase staircase). */
+    mode?: EasingPickerMode;
+    /** The initial bezier preset key. */
+    preset?: string;
+    /** The initial step count. */
+    steps?: number;
+    /** The initial step jump term. */
+    term?: JumpTerm;
+    /** Show the copy-the-literal readout affordance (default true). */
+    readout?: boolean;
+    /** Show the playback travel-dot control (default true). */
+    playback?: boolean;
+    /** A11y label for the canvas. */
+    label?: string;
+};
+type __VLS_ModelProps = {
+    modelValue?: EasingPickerValue;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_122: {
+    value: EasingPickerValue;
+};
+type __VLS_Slots = {} & {
+    footer?: (props: typeof __VLS_122) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: EasingPickerValue | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: EasingPickerValue | undefined) => any) | undefined;
+}>, {
+    label: string;
+    mode: EasingPickerMode;
+    steps: number;
+    preset: string;
+    term: JumpTerm;
+    readout: boolean;
+    playback: 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/easing/composables/useEasingPicker.d.ts

@@ -0,0 +1,84 @@
+import { type ComputedRef, type Ref } from "vue";
+import { jumpTerms } from "@mkbabb/value.js";
+/** The two curve-authoring modes — the two donor arms unified. */
+export type EasingPickerMode = "bezier" | "steps";
+/** A `(t: number) => number` easing callable — the value.js family shape. */
+export type EasingFn = (t: number) => number;
+/** The bezier control-point quad `[x1, y1, x2, y2]`. */
+export type BezierPoints = [number, number, number, number];
+/** A value.js step jump-term (`jump-start`/`end`/`both`/`none` + aliases). */
+export type JumpTerm = (typeof jumpTerms)[number];
+/** The picker's v-model payload — the live curve callable + its re-parseable
+ *  CSS literal + the mode, so a consumer can read back the authored curve. */
+export interface EasingPickerValue {
+    readonly mode: EasingPickerMode;
+    /** The complete re-parseable CSS literal (`cubic-bezier(…)` / `steps(…)`). */
+    readonly css: string;
+    /** The live value.js easing callable the literal evaluates to. */
+    readonly fn: EasingFn;
+    /** The bezier control points (bezier mode). */
+    readonly points: BezierPoints;
+    /** The step jump count (steps mode). */
+    readonly steps: number;
+    /** The step jump term (steps mode). */
+    readonly term: JumpTerm;
+}
+export interface UseEasingPickerOptions {
+    /** The initial mode (default `"bezier"`). */
+    initialMode?: EasingPickerMode;
+    /** The initial bezier preset key (default `"ease-out-back"`). */
+    initialPreset?: string;
+    /** The initial step count (default 4). */
+    initialSteps?: number;
+    /** The initial step term (default `"end"`). */
+    initialTerm?: JumpTerm;
+}
+export interface UseEasingPickerReturn {
+    mode: Ref<EasingPickerMode>;
+    preset: Ref<string>;
+    points: Ref<BezierPoints>;
+    presetNames: readonly string[];
+    selectPreset: (name: string) => void;
+    setHandle: (index: 0 | 1, x: number, y: number) => void;
+    steps: Ref<number>;
+    term: Ref<JumpTerm>;
+    terms: readonly JumpTerm[];
+    /** The live easing callable for the active mode — re-derived on every edit. */
+    easingFn: ComputedRef<EasingFn>;
+    /** The complete re-parseable readout literal for the active mode. */
+    readout: ComputedRef<string>;
+    /** Whether the steps-mode readout round-trips through value.js `parseSteps`
+     *  back to the live (n, term) — the boundary-law proof that the painted
+     *  staircase IS a re-parseable value.js literal, not a hand-rolled string
+     *  the catalogue cannot read back. `true` in bezier mode (no steps literal). */
+    reparseOk: ComputedRef<boolean>;
+    /** The full v-model payload (mode + css + fn + raw params). */
+    value: ComputedRef<EasingPickerValue>;
+    /** Two SVG-space handle coords `[{x,y},{x,y}]` (bezier mode). */
+    handlesSvg: ComputedRef<{
+        x: number;
+        y: number;
+    }[]>;
+    /** The bezier path `d` (`M 0 1 C …`). */
+    bezierPathD: ComputedRef<string>;
+    /** The sampled staircase path `d` (steps mode). */
+    stepPathD: ComputedRef<string>;
+    /** The bezier-canvas viewBox `{ minY, height }` clamping overshoot. */
+    viewBox: ComputedRef<{
+        minY: number;
+        height: number;
+    }>;
+    progress: Ref<number>;
+    playing: Ref<boolean>;
+    playbackState: ComputedRef<"idle" | "playing" | "complete">;
+    reducedMotion: Ref<boolean>;
+    playTravel: () => void;
+    cancelTravel: () => void;
+    stopTravel: () => void;
+}
+/**
+ * The <EasingPicker> shared editor state. Composes the value.js math; owns the
+ * chassis (control points, the literal, the rAF travel). Used by the EasingPicker
+ * SFC + (composed through it) the EasingConfigurator register — ONE source.
+ */
+export declare function useEasingPicker(options?: UseEasingPickerOptions): UseEasingPickerReturn;

package/dist/components/easing/constants.d.ts

@@ -0,0 +1,30 @@
+/** The bezier-mode catalogue key used for the live-edited custom curve. */
+export declare const CUSTOM_PRESET: "custom";
+/** The default bezier-mode preset (a back-overshoot curve reads expressive). */
+export declare const DEFAULT_BEZIER_PRESET: "ease-out-back";
+/** The default steps-mode jump count + term. */
+export declare const DEFAULT_STEP_COUNT = 4;
+export declare const DEFAULT_STEP_TERM: "end";
+/** The steps-mode slider bounds. */
+export declare const STEP_COUNT_MIN = 1;
+export declare const STEP_COUNT_MAX = 12;
+/** Dense staircase sampling so the riser/tread reads crisp (a sampled staircase,
+ *  not a smoothed curve). */
+export declare const STEP_PLOT_SAMPLES = 240;
+/** bezier-Y (0 bottom, 1 top) → SVG-Y (0 top, grows down). */
+export declare const SVG_FLIP: (y: number) => number;
+/** The bezier-canvas viewBox overshoot clamp + pad (a back-curve must not blow up
+ *  the canvas). */
+export declare const VIEW_PAD = 0.1;
+export declare const MAX_OVERSHOOT = 0.6;
+/** The pointer hit-radius for grabbing a handle (touch is forgiving). */
+export declare const HANDLE_HIT_RADIUS = 0.1;
+export declare const HANDLE_HIT_RADIUS_TOUCH = 0.15;
+/** The number of curve samples the viewBox bounds-fit walks. */
+export declare const VIEWBOX_FIT_SAMPLES = 16;
+/** The one-shot rAF travel clock (ms) for the playback dot. */
+export declare const TRAVEL_DURATION_MS = 1200;
+/** The copy-feedback dwell (ms). */
+export declare const COPY_FEEDBACK_MS = 1400;
+/** Maximum wait for a Clipboard write before offering manual selection (ms). */
+export declare const COPY_ATTEMPT_TIMEOUT_MS = 2000;

package/dist/components/expandable-container/ExpandableContainer.vue.d.ts

@@ -0,0 +1,71 @@
+import { type Surface } from "../_shared/useSurfaceAxis";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    buttonPosition?: "left" | "right";
+    /** Accessible name for the expand (fullscreen) button. */
+    expandLabel?: string;
+    /** Accessible name for the collapse (exit fullscreen) button. */
+    collapseLabel?: string;
+    /** Surface decoration register for the fullscreen overlay
+     *  (BA.W-SURFACE-AXIS) — `glass` (default) frosts over the page;
+     *  `opaque` is the solid-wall opt-out; `veil` the borderless plate. */
+    surface?: Surface;
+} & {
+    /**
+     * Two-way `open` model so consumers can drive fullscreen externally
+     * (programmatic toggles, route-driven launches, etc.) while the corner
+     * buttons continue to operate without parent wiring.
+     */
+    open?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    buttonPosition?: "left" | "right";
+    /** Accessible name for the expand (fullscreen) button. */
+    expandLabel?: string;
+    /** Accessible name for the collapse (exit fullscreen) button. */
+    collapseLabel?: string;
+    /** Surface decoration register for the fullscreen overlay
+     *  (BA.W-SURFACE-AXIS) — `glass` (default) frosts over the page;
+     *  `opaque` is the solid-wall opt-out; `veil` the borderless plate. */
+    surface?: Surface;
+} & {
+    /**
+     * Two-way `open` model so consumers can drive fullscreen externally
+     * (programmatic toggles, route-driven launches, etc.) while the corner
+     * buttons continue to operate without parent wiring.
+     */
+    open?: boolean;
+}> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    surface: Surface;
+    buttonPosition: "left" | "right";
+    expandLabel: string;
+    collapseLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    'expand-trigger'?: (props: {
+        expand: () => void;
+        label: string;
+    }) => any;
+} & {
+    default?: (props: {
+        fullscreen: boolean;
+    }) => any;
+} & {
+    'fullscreen-chrome'?: (props: {
+        collapse: () => void;
+        label: string;
+        fullscreen: boolean;
+    }) => any;
+} & {
+    default?: (props: {
+        fullscreen: boolean;
+    }) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/fading-scroll/composables/useFadingScroll.d.ts

@@ -0,0 +1,31 @@
+import type { MaybeRef, Ref } from "vue";
+export interface UseFadingScrollOptions {
+    /** Scroll axis. `"x"` reads scrollLeft/Width; `"y"` reads scrollTop/Height. Default `"x"`. */
+    axis?: MaybeRef<"x" | "y">;
+    /** Feather the start edge once scrolled past the start. Default `true`. */
+    fadeStart?: MaybeRef<boolean>;
+    /** Feather the end edge while trailing overflow remains. Default `true`. */
+    fadeEnd?: MaybeRef<boolean>;
+}
+export interface UseFadingScrollControls {
+    /** True when this composable is the ACTIVE writer (the native timeline is absent). */
+    readonly active: Readonly<Ref<boolean>>;
+    /** Re-measure the scroll state and rewrite the customs. Safe to call manually. */
+    measure: () => void;
+    /** Detach all listeners/observers. Auto-called on unmount in a component scope. */
+    stop: () => void;
+}
+/**
+ * Drive the per-edge `--fade-start` / `--fade-end` mask-width customs off an
+ * element's live scroll state, the JS fallback for the native `scroll(self)`
+ * timeline. On a supporting engine this attaches NOTHING (the CSS recipe is the
+ * sole writer); on a non-supporting engine it measures `scrollLeft/Top`,
+ * `scrollWidth/Height − clientWidth/Height`, a `ResizeObserver` (the shared
+ * `useResizeObserver` substrate) + a rAF-coalesced `scroll` listener, writing
+ * `--fade-start = --fade-scroll-width` only past `scroll > 0` and `--fade-end`
+ * only while trailing overflow remains. The customs default to `0px` (no
+ * feather) so the at-rest no-overflow edge is SHARP.
+ *
+ * @param target the scroll-port element (the same element the CSS customs apply to)
+ */
+export declare function useFadingScroll(target: MaybeRef<HTMLElement | null>, options?: UseFadingScrollOptions): UseFadingScrollControls;

package/dist/components/fourier-field/FourierField.vue.d.ts

@@ -0,0 +1,60 @@
+import type { ColorResolver, OklchStop } from "../../composables/color";
+import { type BasisComponent } from "./math";
+import type { FourierFieldConfig } from "./constants";
+import type { RendererStatus } from "../../composables/glass/webgpu/rendererStatus";
+/**
+ * FourierField — a Fourier epicycle field on the GPU substrate (BC.W-VIZ-FOURIER), a
+ * sibling primitive to Aurora, GooBlob, and DotFlowField. A chain of rotating circles
+ * stacked tip-to-tail draws the reconstructing partial-sum curve; a glowing comet head
+ * leads the fading trail. WebGPU-FIRST: the compute pass writes the partial-sum curve +
+ * the epicycle chain tips, the fullscreen-fragment render pass composites the SDF field; a
+ * WebGL2 GLSL twin is the genuinely-absent-tail fallback (the §E "WebGPU everywhere"
+ * mandate — the Canvas2D renderer is RETIRED). It composes `useFourierField` → the
+ * `createGpuSubstrate` picker over the ONE canvas lifecycle leaf (offscreen-pause, live-PRM
+ * freeze, consumer-owned DPR) and the SHARED `usePointerVelocityField` (the pointer SCRUBS
+ * the reconstruction).
+ *
+ * The DEFAULT palette is the warm-cream library identity (`--viz-fourier` warm-amber); a
+ * demo Teal/cool preset stays demo-LOCAL (presets-in-consumers — never a library token).
+ *
+ * The `variant: "hero"|"final"` prop is RETIRED (BC.W-VIZ-FOURIER — the bundles fold into
+ * config presets, MIGRATION row). An ambient-background consumer passes `color` (+ the
+ * `colorResolver`) for a thin warm default preserving the recessive look; the studio passes
+ * the full `config` + `spectrum` + `getPalette`.
+ */
+type __VLS_Props = {
+    /** The full author config (the studio's `useConfiguratorState` model). Defaults to the warm identity. */
+    config?: FourierFieldConfig;
+    /** An explicit CPU-minted spectrum (a curated shape's DFT). When absent, a seeded elliptic spectrum is generated. */
+    spectrum?: readonly BasisComponent[];
+    /** Resolve the curve palette as OKLCh (the studio themes it). When absent, `color`/`config.palette` is used. */
+    getPalette?: () => OklchStop[];
+    /** Ambient-consumer color seam — a `var()`/`light-dark()` token or a literal; derives a warm 2-stop palette. */
+    color?: string;
+    /** The color resolver (the GooBlob/Aurora seam) — required when `color` is a `var()` token. */
+    colorResolver?: ColorResolver;
+    /** Extra seed mixed into the generated elliptic spectrum PRNG. Default "". */
+    seed?: string;
+    /** Paint ONE static deterministic best-frame and never animate (the capture lever). Default false. */
+    freeze?: boolean;
+    /** Outer loudness envelope (scales the per-layer alpha). When set, overrides `config.intensity`; clamped [0,2]. */
+    intensity?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    backend: () => import("../../composables/glass/webgpu").GpuBackend;
+    pause: () => void;
+    resume: () => void;
+    wake: () => void;
+    renderAt: (timeSec: number) => void;
+    setHeadT: (t: number) => void;
+    rendererStatus: Readonly<import("vue").Ref<RendererStatus, RendererStatus>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    rendererStatus: (status: RendererStatus) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRendererStatus?: ((status: RendererStatus) => any) | undefined;
+}>, {
+    seed: string;
+    freeze: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;