@mkbabb/glass-ui 3.10.1 → 3.11.1

package/dist/components/custom/dialog-native/GlassDialogNative.vue.d.ts

@@ -0,0 +1,57 @@
+/**
+ * <GlassDialogNative> — the native-`<dialog>` glass pilot (AQ.W6 §Design 5).
+ *
+ * A real `<dialog class="glass-top-layer">` top-layer surface. Entry/exit is
+ * PURE CSS from the `.glass-top-layer` grammar (`@starting-style` + `overlay` +
+ * `allow-discrete` + a glass `::backdrop`; animations.css §TOP-LAYER) — no
+ * per-frame JS, no `useSpringMount`. Light-dismiss is the native `closedby="any"`
+ * with a ≤ 12-LOC backdrop-click shim as the feature-detected fallback for
+ * engines without `HTMLDialogElement.closedBy`.
+ *
+ * DISPOSITION (W8 overfitting audit): this is the simple-confirm/settings PILOT
+ * only — one heading, optional short form, a close action. reka-ui `Dialog` is
+ * UNCHANGED and stays the default for every compound focus-trap case (nested
+ * focus zones, async content, the drag-dismiss `spring` opt-in). The pilot ships
+ * gated to a demo story (its consumer) pending the muster J.W6 ≥2-consumer
+ * adoption; it is NOT on the public barrel or a flat subpath yet (no overfit
+ * surface). `commandfor`/`command` (Baseline LIMITED) is the PREFERRED trigger
+ * wiring where supported; the JS `showModal()`/`close()` path (exposed below)
+ * is the kept default for non-supporting targets.
+ *
+ * Baseline: `<dialog>` + `showModal` = Widely; `dialog-closedby` = Newly
+ * (≤ 20-LOC shim fallback); `invoker-commands` (`commandfor`) = LIMITED
+ * (progressive — the JS open path stays default).
+ */
+type __VLS_Props = {
+    /** Light-dismiss on backdrop/Esc — `closedby="any"`. Default true. */
+    lightDismiss?: boolean;
+    /** id so a sibling `<button commandfor=… command="show-modal">` can
+     *  target this dialog (the declarative-open path). */
+    id?: string;
+    /** `aria-labelledby` target — the id of the consumer's heading. */
+    labelledby?: string;
+    /** Class merged onto the `<dialog>` surface. */
+    class?: string;
+};
+declare function showModal(): void;
+declare function close(returnValue?: string): void;
+declare var __VLS_1: {
+    close: typeof close;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    showModal: typeof showModal;
+    close: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    lightDismiss: 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/custom/dialog-native/index.d.ts

@@ -0,0 +1 @@
+export { default as GlassDialogNative } from "./GlassDialogNative.vue";

package/dist/components/custom/dock/DockTabButton.vue.d.ts

@@ -12,9 +12,10 @@ import { type HTMLAttributes } from "vue";
  *
  * K.W6 Lane B — when the consumer attaches `data-tier="primary"`, the
  * button composes the canonical `btn-audacious` utility (the lifted
- * disco-grain + sparkle-sweep + specular-highlight recipe at
- * `utilities.css`). `dock.css` retains the dock-local phase-tinting +
- * structural shell on top of the canonical recipe.
+ * disco-grain + specular-highlight recipe at `utilities.css`; the
+ * sparkle-sweep star was excised at D6 — the gold identity now rides the
+ * `--gold-rim` gilt edge). `dock.css` retains the dock-local
+ * phase-tinting + structural shell on top of the canonical recipe.
  */
 type __VLS_Props = {
     as?: string;

package/dist/components/custom/dock/GlassDock.vue.d.ts

@@ -1,4 +1,112 @@
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_14: {};
+type DockDensity = "compact" | "comfortable" | "spacious" | "audacious";
+interface DockCommonProps {
+    fitContent?: boolean;
+    position?: "fixed" | "inline" | "sticky";
+    alwaysExpanded?: boolean;
+    /**
+     * Corner treatment.
+     *   `"pill"`    — the stadium silhouette (default).
+     *   `"rounded"` — a finite rounded radius (`--radius-xl`).
+     *   `"card"`    — the AW.W3b big-dock card shell: a finite concentric
+     *                 radius (`--dock-card-radius`, default `--radius-3xl`)
+     *                 ABOVE 2xl, below pill — does NOT collapse to a stadium.
+     *                 Collapsed it returns to a pill; the pill↔card swap
+     *                 morphs on the `--dock-motion-resize` spring. AX.W56's
+     *                 squircle policy applies `corner-shape:
+     *                 var(--corner-shape-bigdock)` here under `@supports
+     *                 (corner-shape: superellipse(2))` — the big-dock is the ONE
+     *                 surface where the superellipse reads (cards/pills stay
+     *                 round); the border-radius arc is the cross-engine contract.
+     *
+     * `"pill"`/`"rounded"` previously bound ONLY under the vertical rail
+     * variant — on a horizontal dock the prop silently no-op'd. AW.W3b adds
+     * the horizontal-root shape rules (closing that documented-but-dead prop),
+     * so `shape` now paints on a horizontal dock too.
+     */
+    shape?: "pill" | "rounded" | "card";
+    /**
+     * Layout axis of the dock. `"horizontal"` (default) lays items out
+     * left-to-right and animates `width`; `"vertical"` lays items out
+     * top-to-bottom and animates `height`. IGNORED under `variant="rail"` /
+     * `"instrument-strip"` (those force vertical by construction).
+     */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * Density controls dock padding, gaps, layer height, and inherited
+     * dock control sizing. Root CSS variables can override each density.
+     */
+    density?: DockDensity;
+    /**
+     * Overflow strategy when the expanded content exceeds the dock's
+     * axis cap (`--dock-max-inline-size` horizontally,
+     * `--dock-max-block-size` vertically). The ONE knob governing every
+     * overflow behaviour (AT.W7-dock-a clean break — collapsed from the
+     * prior `wrap` boolean + `overflow` pair + `containerName` clip-lift,
+     * which all touched overflow divergently).
+     *   `"grow"`   — content grows to fit then overflows visibly past
+     *                the cap (the default; nothing clips or scrolls).
+     *   `"wrap"`   — expanded content wraps to multiple rows via CONTENT-DRIVEN
+     *                intrinsic flex-wrap (the `.dock-overflow-wrap` recipe). The
+     *                dock shrink-wraps to content and caps that intrinsic width
+     *                at `max-inline-size: var(--dock-max-inline-size)`, so the row
+     *                reflows to N rows EXACTLY when its intrinsic width exceeds
+     *                the cap — at ANY viewport width — and collapses to one row
+     *                when it fits (no viewport breakpoint). The wrapped multi-row silhouette lifts
+     *                onto the card/floating shadow tier as the dock expands.
+     *                HORIZONTAL-ONLY: a vertical rail grows-to-fit + clamps via
+     *                `--dock-max-block-size` (its own overflow story), so the
+     *                `.dock-overflow-wrap` class is not emitted for a vertical
+     *                orientation.
+     *   `"scroll"` — the dock becomes the scroll port. Horizontal docks
+     *                scroll the active layer on the inline axis
+     *                (`.dock-scroll-x`); vertical rails scroll on the
+     *                block axis (`.dock-scroll-y`), keeping the
+     *                `max-block-size` cap. The rounded pill masks the
+     *                scroll edge; the scrollbar is hidden. The axis is
+     *                chosen automatically from `orientation`.
+     */
+    overflow?: "grow" | "wrap" | "scroll";
+    /**
+     * When set, the dock root establishes an inline-size container query
+     * subject (`container-type: inline-size; container-name: <value>`) so
+     * descendants can query the named container via `@container <value>
+     * (...)` rules. ORTHOGONAL to the `overflow` clip: opting into a
+     * container subject does NOT silently change the dock's clip shell
+     * (AT.W7-dock-a — the prior clip-lift was folded out; use
+     * `overflow="wrap"` to allow multi-line content).
+     *
+     * T.B audit §1.3 cornerstone: the cluster's container subject must
+     * live on the dock primitive, never on a descendant whose intrinsic
+     * size the dock relies on.
+     */
+    containerName?: string;
+}
+interface DockVariantProps extends DockCommonProps {
+    variant?: "dock";
+    /** Idle-collapse delay in ms (default 2000). DOCK-ONLY — a rail never collapses. */
+    collapseDelay?: number;
+    /** Start in the collapsed state (default true). DOCK-ONLY — a rail is always expanded. */
+    startCollapsed?: boolean;
+    /**
+     * In-cap arrangement. `"linear"` (default) lays the active layer out as a
+     * linear row/column. `"grid"` makes the active layer a self-wrapping tile
+     * grid (Launchpad/Stage-Manager track symmetry — `auto-fill` columns of
+     * `--dock-tile-min`). ORTHOGONAL to `overflow` (the OVER-cap strategy):
+     * `layout` is the IN-cap arrangement.
+     *
+     * Hard contract: a `layout="grid"` dock is `alwaysExpanded` (a 2D panel
+     * does not read as a collapsible pill, and no width morph means no
+     * per-frame grid reflow). The canonical pairing is
+     * `shape="card" layout="grid"` (the props stay independent — no
+     * auto-implication of `shape`). DOCK-ONLY — the grid is a horizontal big-dock
+     * arrangement, never a rail's.
+     */
+    layout?: "linear" | "grid";
+}
+interface DockRailProps extends DockCommonProps {
+    variant: "rail" | "instrument-strip";
+}
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_14: {}, __VLS_16: {}, __VLS_18: {};
 type __VLS_Slots = {} & {
     persistent?: (props: typeof __VLS_1) => any;
 } & {
@@ -9,8 +117,12 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_7) => any;
 } & {
     collapsed?: (props: typeof __VLS_14) => any;
+} & {
+    default?: (props: typeof __VLS_16) => any;
+} & {
+    collapsed?: (props: typeof __VLS_18) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<import("./composables/useDockShellProps").DockVariantProps | import("./composables/useDockShellProps").DockRailProps, {
+declare const __VLS_base: import("vue").DefineComponent<DockVariantProps | DockRailProps, {
     expanded: import("vue").Ref<boolean, boolean>;
     isPinned: import("vue").Ref<boolean, boolean>;
     isHeld: import("vue").ComputedRef<boolean>;
@@ -19,7 +131,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("./composables/us
     collapse: () => void;
     keepOpen: () => void;
     release: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./composables/useDockShellProps").DockVariantProps | import("./composables/useDockShellProps").DockRailProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DockVariantProps | DockRailProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/custom/dock/composables/dockMorphContext.d.ts

@@ -1,40 +1,4 @@
 import type { Ref } from "vue";
-/**
- * AX.W02 — ONE morph orchestrator per dock. The dock is a single morph stack
- * whose active "layer" is `(expandedState × activePane)`: the outer
- * collapse↔expand swap and the inner `<DockLayerGroup>` pane swaps are
- * transitions in the SAME group — ONE spring, ONE scalar (`--dock-morph-t`,
- * established by W01), ONE clock. No second engine.
- *
- * Re-derived from first principles on W01's settled single-scalar substrate:
- *  - `--dock-morph-t` is written to the `.glass-dock` root and INHERITS to every
- *    descendant (dock.css `@property … inherits:true`), so ONE spring writing
- *    that one scalar drives EVERY registered container's size calc at once.
- *  - Each morphing container carries its OWN `--dock-morph-from`/`--dock-morph-to`
- *    px span (the allowed one-time FLIP measurement) and interpolates it against
- *    the shared scalar — `from + (to − from) · t`. So a simultaneous
- *    collapse + pane-swap reads as one continuous spring: the box, the nested
- *    stack, and every child stagger ramp on the same `t`.
- *
- * The orchestrator OWNS one `SpringProgress`. The OUTER collapse↔expand pair
- * registers as a target; a NESTED `<DockLayerGroup>` registers a SECOND target
- * instead of minting its own `useLayerTransition` engine. A re-toggle mid-flight
- * re-bases the live solver onto the new span from its current velocity (the iOS
- * interruptible-physics contract W01 keeps), so even an interrupted morph stays
- * one continuous trajectory.
- *
- * This is the dock-flavored first instance of the general `MorphGroup` /
- * `GlassEffectContainer` facility (the iOS-26 Liquid-Glass corpus, facet 26 —
- * the `provideMorphGroup` two-part seam: a per-element driver + a provide/inject
- * orchestrator). AX.W42 generalizes it; W02 establishes the seam it builds on.
- *
- * LIGHT-surface only: `SpringProgress` owns its own rAF via `.play(onFrame)` and
- * carries no static value.js edge — never import `AnimationGroup` / `./engine`
- * (that pulls value.js into the dock bundle).
- *
- * The `DOCK_SPRING` tuning this orchestrator drives is the ONE authority shared with
- * `useLayerTransition` — it lives in `../constants` (the feature-dir constants home).
- */
 export interface DockMorphGroupRegistration {
     /** The container element owning this group's grid-stacked panes. */
     containerEl: Ref<HTMLElement | null>;

package/dist/components/custom/dock/composables/useLayerTransition.d.ts

@@ -1,48 +1,4 @@
 import type { Ref } from "vue";
-/**
- * AX.W01 — the dock single-scalar morph: ONE spring, ONE clock, the whole box.
- *
- * Re-derived from first principles (the e8380d7 single-clock high-water; the
- * 479-line VT-fork accretion is gone). The collapse↔expand (and inner pane-swap)
- * morph runs off ONE normalized analytic spring whose progress scalar (0→1) is
- * written once per frame to `--dock-morph-t` on the `.glass-dock` root. EVERY
- * animated axis — inline-size, padding, border-radius, scale, background / border
- * color, AND the child stagger — is a pure `calc()` read off that one scalar in
- * `dock.css`. NO CSS `transition` on the root morph props; NO View-Transitions
- * fork: the live `SpringProgress` ODE is the single authority on every engine, so
- * iOS interruptible-physics + velocity-continuity retarget are universal, not
- * capability-gated.
- *
- * The morph is a FLIP — the from→to size is measured ONCE per swap (the allowed
- * one-time measurement primitive, never a co-driver), written as `--dock-morph-from`
- * / `--dock-morph-to` px vars on the morphing element, and the live scalar
- * interpolates between them in CSS. Content lays out once at natural size;
- * `overflow:clip` on the morph axis (dock.css, gated on `data-morphing`) makes the
- * box the reveal aperture; the spring-keyed stagger fades the children in-step.
- *
- * Velocity-continuity (the ONE load-bearing iOS piece): a re-toggle mid-flight
- * re-bases the live solver onto the new span from its current velocity (the
- * analytic re-seat keyframes.js owns) — inertia carries, no snap-from-rest. The
- * spring constant is the published `--spring-dock` (response 0.32, ζ 0.7, ~+4.6%
- * overshoot), the SAME analytic ODE the build-time linear() token samples.
- *
- * LIGHT-surface only: `SpringProgress` owns its own rAF via `.play(onFrame)` and
- * carries no static value.js edge. NEVER import `AnimationGroup` / the `./engine`
- * boundary — that pulls value.js into the dock bundle.
- *
- * BOOKED: AY.W-GOD1 — the FLIP-engine FOLD. This standalone engine is a
- * near-duplicate of the orchestrator's FLIP-pin-measure-arm dance
- * (`dockMorphContext.ts:onSwap`), which is the SUPERSET (it carries sibling-rebase
- * this copy lacks). W-DOCK2 found the duplication (H-dock §D3) and BOOKED the fold
- * to W-GOD1 (the GlassDock.vue carve touches the same FLIP code, so the carve is
- * cleaner over ONE engine; folding now would also break the `/dock` `useLayerTransition`
- * public re-export an external consumer reads). Until W-GOD1 lands, `proof:dock-orchestrator-single`'s
- * FLIP DRIFT-GUARD asserts this engine and the orchestrator stay byte-faithful on
- * the load-bearing pin-measure-arm markers, so a divergence in the shared dance REDs.
- * The CANONICAL `DOCK_SPRING` authority is `dock/constants.ts` (the colocation home
- * BOTH this engine and the orchestrator import); `proof:spring-tokens-synced` reads
- * it there, NOT a per-composable copy (W-COLOCATE — the dead-witness fix, continued).
- */
 export interface UseLayerTransitionOptions {
     /** The container element that owns the stacked layer panes. */
     containerEl: Ref<HTMLElement | null>;

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

@@ -6,6 +6,20 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     expandLabel?: string;
     /** Accessible name for the collapse (exit fullscreen) button. */
     collapseLabel?: string;
+    /**
+     * Opt into the `gl-expand` plate → fullscreen MORPH (D6.c M7). When set,
+     * the inline anchor and the teleported fullscreen surface share ONE
+     * `view-transition-name` (this prop, suffixed by an app-unique `useId()`
+     * so two ExpandableContainers on a page never collide their groups — the
+     * proof:vt-names mandate), and the open/close toggle is wrapped in
+     * `startViewTransition` so the plate's rect MORPHS to the fullscreen rect
+     * (and back) instead of jump-cutting. A passed string namespaces the pair
+     * (e.g. `"chart"`); pass an empty string for a bare `useId()` name.
+     * Omitted (default) ⇒ NO view-transition-name, the legacy instant toggle —
+     * byte-identical to the pre-M7 behaviour. PRM + unsupported engines take
+     * `startViewTransition`'s instant fallback (the open/close still runs).
+     */
+    viewTransitionName?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -13,7 +27,13 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
      * buttons continue to operate without parent wiring.
      */
     open?: boolean;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}, {
+    anchorEl: Readonly<import("vue").ShallowRef<HTMLElement | null>>;
+    surfaceEl: Readonly<import("vue").ShallowRef<HTMLElement | null>>;
+    expand: () => void;
+    collapse: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    settle: (fullscreen: boolean) => any;
     "update:open": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<{
     buttonPosition?: "left" | "right";
@@ -21,6 +41,20 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     expandLabel?: string;
     /** Accessible name for the collapse (exit fullscreen) button. */
     collapseLabel?: string;
+    /**
+     * Opt into the `gl-expand` plate → fullscreen MORPH (D6.c M7). When set,
+     * the inline anchor and the teleported fullscreen surface share ONE
+     * `view-transition-name` (this prop, suffixed by an app-unique `useId()`
+     * so two ExpandableContainers on a page never collide their groups — the
+     * proof:vt-names mandate), and the open/close toggle is wrapped in
+     * `startViewTransition` so the plate's rect MORPHS to the fullscreen rect
+     * (and back) instead of jump-cutting. A passed string namespaces the pair
+     * (e.g. `"chart"`); pass an empty string for a bare `useId()` name.
+     * Omitted (default) ⇒ NO view-transition-name, the legacy instant toggle —
+     * byte-identical to the pre-M7 behaviour. PRM + unsupported engines take
+     * `startViewTransition`'s instant fallback (the open/close still runs).
+     */
+    viewTransitionName?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -29,8 +63,10 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
      */
     open?: boolean;
 }> & Readonly<{
+    onSettle?: ((fullscreen: boolean) => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
+    viewTransitionName: string;
     buttonPosition: "left" | "right";
     expandLabel: string;
     collapseLabel: string;
@@ -38,10 +74,6 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     default?: (props: {
         fullscreen: boolean;
     }) => any;
-} & {
-    default?: (props: {
-        fullscreen: boolean;
-    }) => any;
 }>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/components/custom/fourier-field/index.d.ts

@@ -1,6 +1,6 @@
 import type { ColorResolver } from "../../../composables/color";
 export { default as FourierField } from "./FourierField.vue";
-export { comp, positionsAt, dftFromPoints, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
+export { comp, positionsAt, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
 /** The configuration-BUNDLE axis — `hero` (epicycles on, fewer harmonics) vs
  *  `final` (epicycles off, denser). Not a recolour of one curve; one engine,
  *  two presets. */

package/dist/components/custom/fourier-field/math.d.ts

@@ -23,23 +23,6 @@ export declare function comp(index: number, re: number, im: number): BasisCompon
  * carries).
  */
 export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: number): [number, number][];
-/**
- * The forward DFT — the inverse of {@link positionsAt}. Takes a closed sequence
- * of `[x, y]` samples around a curve (treated as the complex signal `x + i·y`,
- * uniformly spaced in the parameter `t ∈ [0, 1)`) and returns the
- * {@link BasisComponent} spectrum that {@link positionsAt} reconstructs.
- *
- * Frequencies run symmetrically around 0 — `0, +1, -1, +2, -2, …` up to the
- * Nyquist limit — which is the index ordering the epicycle chain wants (the big
- * low-order phasors first). The DC term (`index 0`) is the curve's centroid; the
- * caller can subtract it (draw the chain centered) or keep it (draw at the
- * sampled position).
- *
- * General: any point set drives it (a glyph outline, a hand-traced path, a
- * digitized signature). It is NOT a special case — it is the literal forward
- * transform whose inverse already ships as `positionsAt`.
- */
-export declare function dftFromPoints(points: [number, number][]): BasisComponent[];
 /** Tuning for {@link makeEllipticSpectrum}. */
 export interface EllipticSpectrumOptions {
     /**

package/dist/components/custom/glass-panel/GlassPanel.vue.d.ts

@@ -0,0 +1,41 @@
+import { type GlassTier } from "../../../composables/glass/useGlassRenderer";
+/**
+ * Surface-tier vocabulary for the CSS rendering branch. Mirrors the v0.8
+ * five-rung ladder declared in `tokens.css §8` and consumed by the
+ * `.glass-{wash,quiet,resting,floating,overlay}` utility classes.
+ *
+ * v0.8.6 — `default | medium | elevated` retired (per audit U.W0.C-b §21).
+ */
+export type GlassPanelVariant = "wash" | "quiet" | "resting" | "floating" | "overlay";
+export interface GlassPanelProps {
+    /** Force a specific rendering tier */
+    tier?: GlassTier;
+    /** Blur radius (default: 16) */
+    blur?: number;
+    /** Refraction strength 0-1 (default: 0.3) */
+    refraction?: number;
+    /** Chromatic aberration strength 0-1 (default: 0) */
+    chromaticAberration?: boolean;
+    /** Glass surface tier for the CSS rendering branch (v0.8 5-rung ladder). */
+    variant?: GlassPanelVariant;
+    /** Additional classes */
+    class?: string;
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<GlassPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GlassPanelProps> & Readonly<{}>, {
+    variant: GlassPanelVariant;
+    blur: number;
+    refraction: number;
+    chromaticAberration: 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/custom/glass-panel/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GlassPanel } from "./GlassPanel.vue";
+export type { GlassPanelProps, GlassPanelVariant } from "./GlassPanel.vue";

package/dist/components/custom/goo-blob/composables/useBlobPointer.d.ts

@@ -1,7 +1,6 @@
 import { type Ref } from "vue";
-import { TRAIL_N } from "../constants";
-/** Compile-time trail length — re-exported from the co-located shape budget (`../constants`). */
-export { TRAIL_N };
+/** Compile-time trail length — mirrors `TRAIL_N` in metaball.frag.ts. */
+export declare const TRAIL_N = 15;
 /** A single trail sample — a decaying-radius metaball source the shader smin-merges. */
 export interface TrailSample {
     x: number;
@@ -14,7 +13,7 @@ export interface TrailSample {
  * FRAME-RATE-INDEPENDENT critically-damped spring fed the renderer's per-frame
  * `dtMs` (NOT a fixed-α lerp — the prior `SMOOTH_FACTOR = 0.12` was framerate
  * dependent). The spring is `@mkbabb/keyframes.js` `SpringProgress` driven through
- * its `tickDt(dtMs)` seam by the SUBSTRATE's single rAF — it does NOT call
+ * its `tick(dt)` seam by the SUBSTRATE's single rAF — it does NOT call
  * `SpringProgress.play()` (that would start a parallel rAF, the
  * single-substrate-loop violation `proof:blob-interaction-prm` forbids).
  *

package/dist/components/custom/goo-blob/composables/useMetaballRenderer.d.ts

@@ -24,20 +24,14 @@ export interface UseMetaballRendererOptions {
     satellites: BlobSatelliteSystem;
     config: BlobConfig;
 }
-/** The renderer's public control surface — pause/resume the demand loop. */
-export interface UseMetaballRendererReturn {
-    pause: () => void;
-    resume: () => void;
-}
 /**
  * The GooBlob WebGL renderer — composes the `useWebGLCanvas` substrate (AU.W6).
  *
  * This module owns ONLY the metaball-specific concerns: compiling the shader,
- * building the quad + uniform cache (the `buildMetaballProgram` leaf), and
- * uploading the per-frame uniforms (the `uploadBlobUniforms` leaf) derived from the
- * mood / pointer / satellite systems and the resolved base color. The generic
- * WebGL2 lifecycle — context creation, the suspend/resume model, the demand-driven
- * rAF loop, the tab-visibility owner, the ResizeObserver, and the
+ * building the quad + uniform cache, and uploading the per-frame uniforms derived
+ * from the mood / pointer / satellite systems and the resolved base color. The
+ * generic WebGL2 lifecycle — context creation, the suspend/resume model, the
+ * demand-driven rAF loop, the tab-visibility owner, the ResizeObserver, and the
  * webglcontextlost/restored robustness — lives in the substrate; this renderer
  * threads its behaviour through the substrate's
  * `setup`/`frame`/`shouldContinue`/`resize`/`teardown` callbacks. It does NOT call
@@ -49,4 +43,7 @@ export interface UseMetaballRendererReturn {
  * a `var(--token)` — the SFC's `resolveTokenColor` leaf does that BEFORE handing
  * concrete strings here (inv-K-3 seam); the value.js 1×1-canvas DOM probe is gone.
  */
-export declare function useMetaballRenderer(options: UseMetaballRendererOptions): UseMetaballRendererReturn;
+export declare function useMetaballRenderer(options: UseMetaballRendererOptions): {
+    pause: () => void;
+    resume: () => void;
+};

package/dist/components/custom/handmark/HandMark.vue.d.ts

@@ -0,0 +1,29 @@
+import type { HandMarkProps } from "./types";
+declare function play(): void;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<HandMarkProps, {
+    play: typeof play;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HandMarkProps> & Readonly<{}>, {
+    color: string;
+    seed: number;
+    shape: import("./types").HandShape;
+    animation: import("./types").HandAnimation;
+    appear: "mount" | "visible" | "manual";
+    jagged: boolean;
+    brush: import("./brush").BrushName | Partial<import("./brush").Brush>;
+    drawMs: number;
+    drawDelayMs: number;
+    boilFps: number;
+    boilFrames: 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;
+    };
+};