@mkbabb/glass-ui 4.1.0 → 5.0.0

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;

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

@@ -0,0 +1,41 @@
+import type { OklchStop } from "../../../composables/color";
+import { type BasisComponent } from "../math";
+/** One phasor lane in the storage buffer: (re, im, index, _pad). */
+export declare const FOURIER_PHASOR_BYTES = 16;
+export declare const FOURIER_COMPUTE_UNIFORM_BYTES = 32;
+export interface FourierUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+}
+export declare function createFourierComputeScratch(): FourierUniformScratch;
+/** Pack the compute uniforms in place. */
+export declare function packFourierComputeUniforms(scratch: FourierUniformScratch, headT: number, trailArc: number, harmonicN: number, epicycleArmN: number, sampleCount: number, phasorCount: number): FourierUniformScratch;
+export declare const FOURIER_RENDER_UNIFORM_BYTES: number;
+export declare function createFourierRenderScratch(): FourierUniformScratch;
+/** The model→clip fit transform (center + uniform scale) — computed once per spectrum. */
+export interface FourierFit {
+    centerX: number;
+    centerY: number;
+    /** The uniform scale s such that (model − center)·s maps the curve into clip [-1,1] with margin. */
+    scale: number;
+}
+/**
+ * Stable view-fit: sample the FULL reconstruction once over the period, bound its bbox,
+ * and derive the center + a margin-padded uniform scale. The render's fullscreen pass
+ * inverts this transform per fragment so the curve never clips and the scale is fixed.
+ */
+export declare function computeFourierFit(spectrum: readonly BasisComponent[]): FourierFit;
+/**
+ * Convert a CSS-px stroke width to MODEL units (the shader's space). The fit `scale` maps
+ * model → clip; clip spans [-1,1] over the min CSS dimension → cssPx-per-clip = canvasCssMin/2.
+ * model-per-cssPx = (1/scale)·(2/canvasCssMin).
+ */
+export declare function trailWidthToModel(trailWidthPx: number, scale: number, canvasCssMin: number): number;
+/** Pack the render uniforms in place. */
+export declare function packFourierRenderUniforms(scratch: FourierUniformScratch, fit: FourierFit, aspect: number, trailWidthModel: number, peakAlpha: number, headGlowAlpha: number, trailFadeExp: number, trailFloor: number, intensity: number, showEpicycles: boolean, rainbowChain: boolean, squashGain: number, celGain: number, edgeMargin: number, sampleCount: number, armCount: number, palette: OklchStop[]): FourierUniformScratch;
+/**
+ * Pack the phasor storage table (re, im, index, _pad) from the CPU-minted spectrum. The
+ * WGSL SUMS this per frame — it is the ONLY spectrum upload (no WGSL-side mint).
+ */
+export declare function packPhasorTable(spectrum: readonly BasisComponent[]): Float32Array;

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

@@ -0,0 +1,55 @@
+import { type Ref } from "vue";
+import { type GpuBackend } from "../../../composables/glass/webgpu/useGpuSubstrate";
+import type { OklchStop } from "../../../composables/color";
+import type { FourierFieldConfig } from "../constants";
+import type { BasisComponent } from "../math";
+export interface UseFourierFieldOptions {
+    config: FourierFieldConfig;
+    /** The active phasor spectrum (CPU-minted; re-read each frame so a source-swap reaches the buffer). */
+    getSpectrum: () => readonly BasisComponent[];
+    /** Resolve the curve-color palette as OKLCh (the demo themes it; default warm-identity). */
+    getPalette: () => OklchStop[];
+    /** When true, hold the deterministic best-frame and never advance (the capture / freeze lever). */
+    freeze?: () => boolean;
+    /** The static deterministic best-frame parameter under `freeze`/PRM. Default 0.34. */
+    frozenT?: number;
+    /** Base forward period for one full traversal at 1× speed, in seconds. Default 16. */
+    periodS?: number;
+    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
+    mode?: "live" | "capture";
+    /**
+     * BI.W-FIELD-CORE — the route pointer BROADCASTER read (the SUBTLE-interactive background
+     * register). A full-bleed `pointer-events:none` field cannot listen for its own pointer, so
+     * an ambient consumer reads the route-level `useRoutePointer` and feeds the shared field
+     * from here each frame (viewport-normalized ≈ host-normalized for a full-bleed field). The
+     * lean/bias then read on a background field WITHOUT the field owning a pointer listener.
+     * Omit for the studio (which binds its own host listeners).
+     */
+    routePointer?: () => {
+        x: number;
+        y: number;
+        active: boolean;
+    } | null;
+}
+/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
+export interface FourierFieldHandle {
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 GLSL fallback). */
+    readonly backend: GpuBackend;
+    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
+    pause: () => void;
+    /** Re-arm the loop. */
+    resume: () => void;
+    /** Re-arm a parked loop on demand. */
+    wake: () => void;
+    /** Draw one frame out-of-loop (capture / thumbnail). */
+    renderAt: (timeSec: number) => void;
+    /** The live `prefers-reduced-motion: reduce` state. */
+    readonly reducedMotion: boolean;
+    /** The current loop parameter `head_t ∈ [0,1)` (the scrubber reads/writes it). */
+    readonly headT: number;
+    /** Scrub the clock directly (the transport scrubber / a pointer drag). */
+    setHeadT: (t: number) => void;
+    /** Tear down the renderer + release GPU/GL resources. */
+    dispose: () => void;
+}
+export declare function useFourierField(canvasRef: Ref<HTMLCanvasElement | null>, options: UseFourierFieldOptions): FourierFieldHandle;