@mkbabb/glass-ui 4.2.0 → 5.0.0

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

@@ -0,0 +1,107 @@
+import type { Component } from "vue";
+/**
+ * BC.W-DOCK-STACK-RAIL — one `<DockStack>` member descriptor: a stack member that fans
+ * OUT of the macOS hover-expand stack (id + label + glyph + optional select handler).
+ * A `<script setup>` SFC cannot re-export a named type through the `export { default }`
+ * barrel, so the descriptor lives here (the colocated types home) and the SFC imports
+ * it; the barrel re-exports it for consumers typing their `items` array. This is the
+ * stack's MEMBER, not a facet chip — the divider-carousel `DockRailItem` is RETIRED
+ * (clean break, no alias).
+ */
+export interface DockStackItem {
+    /** Stable identifier — the `v-for` key + the selected-member id. */
+    id: string;
+    /** The member's accessible label (the `aria-label` + tooltip). */
+    label: string;
+    /** The member glyph (a `@lucide/vue` icon or any component). */
+    icon?: Component;
+    /** Optional per-member select handler (fired alongside the model write). */
+    onSelect?: () => void;
+    /**
+     * BE.W-DOCK-RAIL-REALIZE — the per-FACET accent hue (the `mode="facets"` context
+     * carousel only — IGNORED by the macOS `mode="stack"` glyph fan). A complete
+     * `<color>` (a consumer DATA/context hue) written to the chip's `--glass-accent`
+     * (the BB.W-GLASS-ACCENT per-instance chromatic-rim axis, `rim.css`/`material.css`),
+     * so each context facet carries its OWN rim+glint hue — the AZ context-carousel
+     * identity. Unset ⇒ the neutral warm-cream rim (the `--glass-accent: transparent`
+     * no-op floor). NOT a plate-background fill (the accent rides the THIN rim/glint;
+     * presets-in-consumers — no consumer hue enters a library token).
+     */
+    accent?: string;
+}
+/**
+ * BA.W-DOCK-SECTIONS — the three named zone kinds the declarative `<DockSection>`
+ * descriptor renders (the R8-9 "rail core + sections + nav" three-zone gestalt):
+ *   - `"rail-core"` — the leading home/brand region (the ℱ wordmark / category trigger).
+ *   - `"section"`   — a named, divider-demarcated group of controls; a section
+ *                     carrying `layers` composes the existing `DockLayerGroup`/`DockLayer`
+ *                     registry (NOT a parallel layer machine).
+ *   - `"nav"`       — the trailing nav arrows / utility group.
+ */
+export type DockSectionKind = "rail-core" | "section" | "nav";
+/**
+ * BA.W-DOCK-SECTIONS — one declarative section descriptor. A consumer passes
+ * `sections: readonly DockSectionDescriptor[]` to `<DockSection>` and the dock body
+ * renders the tripartite silhouette (rail-core | divided named sections | nav)
+ * demarcated by `<DockSeparator>` — the IG-A3 / R8-9 "abstract this into a re-usable
+ * component for layering" library gap. A `<script setup>` SFC cannot re-export a named
+ * type through its default barrel, so the descriptor lives here (the colocated types
+ * home, beside `DockRailItem`) and `DockSection.vue` imports it; the barrel re-exports
+ * it for consumers typing their `sections` array.
+ */
+export interface DockSectionDescriptor {
+    /** Which of the three zone kinds this descriptor renders. */
+    kind: DockSectionKind;
+    /** Stable identifier — the `v-for` key + the layer-context id for a `section`. */
+    id: string;
+    /** Optional accessible label for the grouped zone. */
+    label?: string;
+    /**
+     * For a `section` kind: the stack members this section carries. When present
+     * (length > 1) the members ride the dock's `#rail` stack (the macOS hover-expand
+     * stack, OUTSIDE the dock box — never re-inflating it). The descriptor names them;
+     * `<DockStack :items>` fans them out.
+     */
+    layers?: readonly DockStackItem[];
+}
+/**
+ * The ONE dock-morph spring authority — the iOS-26 interruptible-physics tuning the
+ * dock's single `SpringProgress` orchestrator (`dockMorphContext.ts`) AND the
+ * `useLayerTransition` engine both read. Co-located here so the `response`/`damping`
+ * pair is defined ONCE rather than duplicated at the top of each composable (the two
+ * prior copies were a DRY hazard — a re-tune had to touch both).
+ */
+export declare const DOCK_SPRING: {
+    readonly response: number;
+    readonly dampingFraction: number;
+};
+/**
+ * BG.NF.1 W-FALLBACK-EXCISE — the JS token-mirror constants (the NO-MASKING-FALLBACK
+ * single-source floor). The dock composables read a live root token but need a value
+ * when the root is not yet mounted; that value lives HERE ONCE (never a bare drift-prone
+ * literal duplicated at the read site — the 1.14/44 that had already drifted 1.08→1.14).
+ */
+/**
+ * The shape-morph squish cap — mirrors `--dock-morph-max-stretch` (density.css). The
+ * lifted iOS-27 register (BD.W-MOTION-WEIGHT C1·R3 drift fix: the prior 1.08 was stale).
+ */
+export declare const DOCK_MORPH_MAX_STRETCH = 1.14;
+/**
+ * The collapsed-endpoint floor in px — mirrors `--dock-morph-min`'s `2.75rem` = the
+ * WCAG 2.5.5 touch floor at the 16px root (density.css). Used until the collapsed
+ * state has been captured at rest.
+ */
+export declare const DOCK_TAP_FLOOR_PX = 44;
+/** `Symbol()` label for the `DockContext` injection key (`dockContext.ts`). */
+export declare const DOCK_CONTEXT_LABEL = "glass-ui:dock-context";
+/** `Symbol()` label for the `DockCrossfadeContext` injection key (`dockCrossfadeContext.ts`). */
+export declare const DOCK_LAYER_GROUP_LABEL = "glass-ui:dock-layer-group";
+/** `Symbol()` label for the `DockMorphContext` injection key (`dockMorphContext.ts`). */
+export declare const DOCK_MORPH_LABEL = "glass-ui:dock-morph-context";
+/** The intent-dwell before a collapsed→hover expand commits (a sweeping-edge enter is
+ *  canceled by the chasing leave inside this window) — the calmer hover register KEPT
+ *  by W-DOCK-SPINE. BI.W-DOCK-RETIRES deleted the `EDGE_BAND_PX` moving-edge-sweep
+ *  recheck band (the ~120L hysteresis): post-SPINE the hit frame is a STATIONARY
+ *  state-sized box, so a mid-morph leave never sweeps a moving edge past the cursor. */
+export declare const HOVER_INTENT_MS = 60;
+export declare const MORPH_SETTLE_MS = 840;

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

@@ -0,0 +1,19 @@
+export { default as GlassDock } from "./GlassDock.vue";
+export { default as DockLayerGroup } from "./DockLayerGroup.vue";
+export { default as DockLayer } from "./DockLayer.vue";
+export { default as DockCrossfade } from "./DockCrossfade.vue";
+export type { DockFaceDescriptor, DockFaceRegistration, DockCrossfadeContext, } from "./composables/dockCrossfadeContext";
+export { default as DockControl } from "./DockControl.vue";
+export { default as DockTrigger } from "./DockTrigger.vue";
+export { default as DockBackgroundToggle } from "./DockBackgroundToggle.vue";
+export { default as DockSeparator } from "./DockSeparator.vue";
+export { default as DockStack } from "./DockStack.vue";
+export type { DockStackItem } from "./constants";
+export { default as DockSection } from "./DockSection.vue";
+export type { DockSectionDescriptor, DockSectionKind } from "./constants";
+export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./composables";
+export { DOCK_CONTEXT_KEY, useDockContext, useOptionalDockContext, provideDockContext, type DockContext, type DockOrientation, type DockLayout, } from "./composables/dockContext";
+export { useDockCtaReceive, type UseDockCtaReceiveOptions, type UseDockCtaReceiveReturn, type DockCtaReceivePreset, } from "../../composables/motion/useDockCtaReceive";
+export { useDockSearch } from "./composables";
+export type { UseDockSearchOptions, UseDockSearchReturn } from "./composables";
+export { GooFilter } from "../goo-filter";

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

@@ -0,0 +1,85 @@
+import type { DrawerDirection, DrawerMode, DrawerStage } from './index';
+/**
+ * BB.W-DRAWER-ABROGATE — the Drawer root on the HOUSE reka `DialogRoot` substrate
+ * (the SAME shape `Dialog.vue` binds). vaul-vue is gone: reka owns the open-control,
+ * the portal, the focus management (trap when `modal`, free when `live-behind`) and
+ * the scrim; the house `useDrawerSnap` engine (provided here, bound in DrawerContent)
+ * owns the snap math vaul used to own.
+ *
+ * `mode` — additive shorthand (AN.W3). `"modal"` (default) keeps the iOS scale-down
+ * look: `modal: true` (reka focus-traps + page-occludes) + `stage: "scale"` (the page
+ * recedes). `"live-behind"` is the non-modal peek/half/full bottom sheet — `modal:
+ * false` (no focus trap, no page `aria-hidden`, page-behind stays interactive — reka
+ * delivers this natively), `stage: "none"`, and the direction-derived snap ladder.
+ * Every prop the mode sets is still overridable by an explicit prop — `mode` only
+ * supplies defaults.
+ *
+ * The snap props (`snapPoints`/`activeSnapPoint`/`direction`) are HOUSE props now
+ * (they were vaul's `DrawerRootProps` surface — preserved by shape so the consumer
+ * binding is byte-identical, but resolved by the house engine, not forwarded to reka,
+ * which knows only `open`/`defaultOpen`/`modal`).
+ *
+ * BD.W-OVERLAY-STAGE-COUPLE — `stage` is the honest scene-staging enum — the page
+ * recede is a real `--stage-t` scale/radius drive, not a boolean that moves no pixels:
+ *   • `none`      — no staging (the live-behind peek sheet leaves the page untouched).
+ *   • `dim`       — the scrim deepens with the detent; the page does NOT transform
+ *                   (the PRM-safe luminance-only depth cue; also the `scale` degrade).
+ *   • `scale`     — `dim` + the page RECEDES + SCALES (the iOS card-recede depth cue).
+ *   • `immersive` — `scale` + the scrim's backdrop-blur ENGAGES (the spotlight).
+ * Under `prefers-reduced-motion: reduce`, `scale`/`immersive` degrade to `dim` (no
+ * page transform — a full-page snap-scale IS perceived motion, fold C1·R6). The enum
+ * toggles `data-stage-scale` / `data-stage-immersive` on the page-wrapper marker
+ * (`[data-stage-wrapper]`, mounted by the consumer/demo shell) while the sheet is
+ * open; the `--stage-t` scalar the snap engine writes at `:root` drives the couplings.
+ */
+type __VLS_Props = {
+    /** The controlled open state (`v-model:open`). */
+    open?: boolean;
+    /** Initial open state for the uncontrolled case. */
+    defaultOpen?: boolean;
+    /** reka modality — defaulted by `mode`; an explicit value overrides. */
+    modal?: boolean;
+    /** Presentation mode shorthand. */
+    mode?: DrawerMode;
+    /** The detent ladder (fractions 0..1). When omitted, resolved from `direction` (BB-2). */
+    snapPoints?: (number | string)[];
+    /** The active detent fraction (`v-model:active-snap-point`). */
+    activeSnapPoint?: number | string | null;
+    /** Drag/slide axis (BB-2 default-ladder source). */
+    direction?: DrawerDirection;
+    /**
+     * BD.W-OVERLAY-STAGE-COUPLE — the honest scene-staging enum. `none` leaves the
+     * page untouched (the live-behind default); `dim` deepens the scrim only; `scale`
+     * recedes + scales the page;
+     * `immersive` adds the backdrop-blur engage. Defaulted by `mode`.
+     */
+    stage?: DrawerStage;
+};
+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": (value: boolean) => any;
+    "update:activeSnapPoint": (value: string | number | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:activeSnapPoint"?: ((value: string | number | null) => any) | undefined;
+}>, {
+    direction: DrawerDirection;
+    open: boolean;
+    mode: DrawerMode;
+    defaultOpen: boolean;
+    modal: boolean;
+    stage: DrawerStage;
+    snapPoints: (number | string)[];
+    activeSnapPoint: number | string | 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/drawer/DrawerContent.vue.d.ts

@@ -0,0 +1,40 @@
+import { type HtmlHTMLAttributes } from 'vue';
+import { type DialogContentProps } from 'reka-ui';
+import { type Surface } from '../_shared/useSurfaceAxis';
+type __VLS_Props = DialogContentProps & {
+    class?: HtmlHTMLAttributes['class'];
+    showOverlay?: boolean;
+    /** Surface decoration register (BA.W-SURFACE-AXIS) — the SHARED
+     *  {glass·veil·opaque} axis on top of the `.glass-drawer` recipe. */
+    surface?: Surface;
+};
+declare var __VLS_19: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_19) => 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;
+    openAutoFocus: (event: Event) => 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;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    surface: Surface;
+    showOverlay: 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/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 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 DEFAULT snap ladder from `direction` natively (retiring the
+ * Atlas `:snap-points="[]"` workaround). 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,35 @@
+export { DialogPortal as DrawerPortal, DialogTrigger as DrawerTrigger, DialogClose as DrawerClose, } from "reka-ui";
+/**
+ * Drawer drag/slide direction (BB.W-DRAWER-ABROGATE). `bottom` (default) + `top`
+ * are the peek/half/full bottom-sheet axes; `left`/`right` are the side-lens
+ * full-slide axes. The house snap engine (`useDrawerSnap`) resolves the default
+ * detent ladder FROM this (BB-2): bottom/top → `[0.12, 0.5, 1]`, left/right →
+ * a full-slide (no detents).
+ */
+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 DrawerOverlay } from "./DrawerOverlay.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/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;
+}>, {
+    align: "center" | "start" | "end";
+    surface: Surface;
+    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/dropdown-menu/index.d.ts

@@ -0,0 +1,16 @@
+export { DropdownMenuPortal } from 'reka-ui';
+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/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/fourier-field/FourierField.vue.d.ts

@@ -0,0 +1,54 @@
+import type { ColorResolver, OklchStop } from "../../composables/color";
+import { type BasisComponent } from "./math";
+import type { FourierFieldConfig } from "./constants";
+/**
+ * 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;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    seed: string;
+    freeze: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/fourier-field/composables/fourierFieldGLSetup.d.ts

@@ -0,0 +1,24 @@
+import type { WebGLCanvasFrame } from "../../../composables/glass/webgl/useWebGLCanvas";
+import type { OklchStop } from "../../../composables/color";
+import { type FourierFieldConfig } from "../constants";
+import { type BasisComponent } from "../math";
+export interface FourierGLSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: FourierFieldConfig;
+    getSpectrum: () => readonly BasisComponent[];
+    getPalette: () => OklchStop[];
+    getHeadT: () => number;
+    shouldContinue: () => boolean;
+    onFrame?: (timeSec: number) => void;
+    /**
+     * BG.W-FOURIER-BEAUTY B3 — the 2-D cursor FOLLOW (model-space center lean). Mirrors the
+     * WGSL arm exactly (both read the SAME uFit center) — parity-safe by construction.
+     * `{x:0,y:0}` (ambient/PRM) is byte-identical to today.
+     */
+    getPointerLean?: () => {
+        x: number;
+        y: number;
+    };
+}
+/** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
+export declare function createFourierGLSetup(deps: FourierGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/fourier-field/composables/fourierFieldWGPUSetup.d.ts

@@ -0,0 +1,31 @@
+import type { WebGPUCanvasFrame } from "../../../composables/glass/webgpu/useWebGPUCanvas";
+import type { OklchStop } from "../../../composables/color";
+import { type FourierFieldConfig } from "../constants";
+import type { BasisComponent } from "../math";
+export interface FourierWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: FourierFieldConfig;
+    /** The CPU-minted spectrum (re-read each frame so a source-swap reaches the buffer). */
+    getSpectrum: () => readonly BasisComponent[];
+    /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame so a live edit reaches the buffer. */
+    getPalette: () => OklchStop[];
+    /** The single loop parameter `head_t ∈ [0,1)` (the ONE keyframes.js clock). */
+    getHeadT: () => number;
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+    /** The per-frame pointer hook — useFourierField advances the shared pointer field here. */
+    onFrame?: (timeSec: number) => void;
+    /**
+     * BD.W-VIZ-BROKEN-FIX D6b — the 2-D cursor FOLLOW: a small MODEL-space offset added to
+     * the view-fit center so the whole reconstruction LEANS toward the cursor (the spatial
+     * "follow" beside D6a's velocity scrub). Reuses the EXISTING uFit center uniform (NO new
+     * uniform, NO shader/bridge edit — parity-safe by construction, both arms read the same
+     * fit). `{x:0,y:0}` (the ambient/PRM register) is byte-identical to today.
+     */
+    getPointerLean?: () => {
+        x: number;
+        y: number;
+    };
+}
+/** Build the fourier-field `setupWGPU(device, context, format)` callback. */
+export declare function createFourierWGPUSetup(deps: FourierWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;