@mkbabb/glass-ui 4.2.0 → 5.0.0

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

@@ -1,158 +0,0 @@
-import { type Ref } from "vue";
-/** The three named fission CONTEXTS — each maps to a goo signature (F3). */
-export type DockSplitContext = "search" | "media" | "nav";
-/** The detach vector family a context selects. */
-export type DockSplitVector = "radial" | "lateral" | "inward-merge";
-/**
- * BD.W-DOCK-CORE (II.2 — F-1 the headline fix). The placement axis the detached
- * pieces TRAVEL ALONG to form the sibling island dock. The prior build let each
- * piece scatter on its own radial center → it read as inline jitter inside the one
- * pill, NOT a detach. A single COHERENT placement vector flies the whole piece
- * cluster off the source plate so a second dock visibly materializes beside/above/
- * below (the iOS-27 split read).
- */
-export type DockSplitPlacement = "beside" | "above" | "below";
-/** The unit placement vector each `splitPlacement` flies the cluster along. */
-export declare const PLACEMENT_VECTOR: Readonly<Record<DockSplitPlacement, {
-    dx: number;
-    dy: number;
-}>>;
-/** The squish-peak register — WHEN the `useLiquidFlex` swell peaks in the travel. */
-export type DockSplitSquishPeak = "late" | "long" | "coalesce";
-/**
- * The per-context goo-SIGNATURE descriptor (F3 — the FLOOR, DATA not three code paths).
- * The orchestrator reads this to compute each piece's vector + stagger + neck phase; the
- * ONE `fission-bridge.css` recipe paints whatever the pieces carry.
- */
-export interface DockSplitSignature {
-    /** The context this signature serves. */
-    context: DockSplitContext;
-    /** The detach-vector family. */
-    vector: DockSplitVector;
-    /**
-     * How long the goo neck HOLDS before it snaps (0..1 of `--split-t`). High = the
-     * tense radial pop (neck holds to ~0.55 then snaps); the neck-break offset.
-     */
-    neckHold: number;
-    /**
-     * The per-piece stagger-rank resolver — returns piece `i`'s ordinal in the break
-     * SEQUENCE (innermost-first for radial, outside-in for lateral). The orchestrator
-     * phase-shifts each piece's `--neck-t` by `staggerStep * rank` so the N necks break
-     * in sequence, never simultaneously (the `--split-stagger * rank(i)` idiom).
-     */
-    staggerRank: (i: number, count: number) => number;
-    /** WHEN the `useLiquidFlex` squish swell peaks across the travel. */
-    squishPeak: DockSplitSquishPeak;
-}
-/** The canonical per-context signature MAP (F3 — search/media/nav, descriptor-driven). */
-export declare const DOCK_SPLIT_SIGNATURES: Readonly<Record<DockSplitContext, DockSplitSignature>>;
-/** The per-piece DIRECTION-VECTOR + rank a control registers (the MorphTarget twin). */
-export interface DockFissionPieceRegistration {
-    /** The detaching control element (its `--split-*`/`--neck-t` vars are written here). */
-    el: Ref<HTMLElement | null>;
-    /**
-     * The detach DIRECTION as a unit-ish vector in dock-local space (the bloom/peel
-     * direction). `radial` blooms `(cx_i − cx_dock)`-ward; `lateral` peels cross-axis;
-     * `inward-merge` is the negative radial. May be a getter so a live re-measure
-     * (the FLIP-measured center) re-resolves per read.
-     */
-    vector: {
-        dx: number;
-        dy: number;
-    } | (() => {
-        dx: number;
-        dy: number;
-    });
-    /**
-     * The piece's ordinal in the registration order (the `--i` the bridge reads + the
-     * input to the signature's `staggerRank`). Stable per piece.
-     */
-    rank: number;
-}
-/** The handle a registered piece holds (detach on unmount). */
-export interface DockFissionPieceHandle {
-    /** Detach this piece from the orchestrator (on the control's unmount). */
-    release(): void;
-}
-export interface UseDockFissionOptions {
-    /** The `.glass-dock` root (or the fission scope) the shared `--dock-split-t` writes to. */
-    rootEl: Ref<HTMLElement | null>;
-    /**
-     * The active signature (the context the dock is fissioning under). A `Ref` so a
-     * consumer can swap contexts; the orchestrator reads `.value` at split time.
-     */
-    signature: Ref<DockSplitSignature>;
-    /**
-     * BD.W-DOCK-CORE (II.2 — F-1). The placement the detached pieces fly to form the
-     * sibling island. A `Ref` so a consumer can swap placement. The orchestrator writes
-     * the per-piece travel along this ONE coherent vector (not per-piece radial scatter)
-     * so the cluster reads as a real detach into a second dock beside/above/below.
-     * Defaults to `"beside"`.
-     */
-    placement?: Ref<DockSplitPlacement>;
-    /**
-     * The LOW squish cap the `useLiquidFlex` recoil saturates at (≤1.08 — the anti-taffy
-     * fence). May be a getter so a live `--*-max-stretch` cascade override re-resolves.
-     * Defaults to 1.08 (the `useLiquidFlex` register).
-     */
-    maxStretch?: number | (() => number);
-    /**
-     * The seam-tension cap (F4 — kept LOW ≈0.12, the `useLiquidFlex` maxStretch
-     * register). A fast pull THINS the neck via the existing `clip-path` channel up to
-     * this cap, saturating — never a taffy-pull.
-     */
-    seamTensionCap?: number;
-    /**
-     * The seam-tension velocity gain `k` — `--seam-tension = clamp(0, speed·k, cap)`.
-     * Defaults to 0.6 (a calm gain over the normalized-host velocity).
-     */
-    seamTensionGain?: number;
-    /**
-     * The per-rank stagger STEP — the `--neck-t` phase shift per stagger-rank so the N
-     * necks break in sequence (the `--split-stagger * rank` idiom). Defaults to 0.08.
-     */
-    staggerStep?: number;
-    /** Honor `prefers-reduced-motion: reduce` → instant sync-seat (F5). Default true. */
-    respectReducedMotion?: boolean;
-}
-export interface UseDockFissionReturn {
-    /** The live split scalar (0 rest → 1 fissioned), the last value the spring wrote. */
-    readonly t: Readonly<Ref<number>>;
-    /** True while the dock is fissioned (or mid-fission past the threshold). */
-    readonly fissioned: Readonly<Ref<boolean>>;
-    /**
-     * Register a surviving control as a fission PIECE (the `Set<MorphTarget>` pattern).
-     * The piece carries its DIRECTION-VECTOR + rank; the orchestrator writes its
-     * `--split-dx`/`--split-dy`/`--i`/`--neck-t` off the active signature.
-     */
-    registerPiece(reg: DockFissionPieceRegistration): DockFissionPieceHandle;
-    /** SPLIT — run the scalar 0→1 (carve the pill into the N pieces). */
-    split(): void;
-    /** RE-MERGE — run the scalar 1→0 (the SAME loop, target flipped — F2 bidirectional). */
-    merge(): void;
-    /** Toggle split↔merge from the current state. */
-    toggle(): void;
-    /**
-     * The `@pointermove` handler the consumer binds on the dock host — feeds the raw
-     * pointer to the velocity field (the field is ticked from INSIDE the driver loop).
-     * PRM-gated by the field itself.
-     */
-    onPointerMove(event: PointerEvent): void;
-    /** Tear down the spring + the field listener (auto-run on scope dispose). */
-    dispose(): void;
-}
-/**
- * The n-ary detach orchestrator. ONE `SpringProgress` on `DOCK_SPRING` writing
- * `--dock-split-t` + per-piece `--split-dx`/`--split-dy`/`--i`/`--neck-t` off the active
- * `DockSplitSignature`, the snap-recoil on `useLiquidFlex`, the seam-tension on
- * `usePointerVelocityField` (fed from inside the ONE loop), PRM sync-seated. See the
- * module header for the load-bearing-reuse + box-inviolate rationale.
- *
- * @example
- * ```ts
- * const fission = useDockFission({ rootEl, signature })
- * const h = fission.registerPiece({ el: searchIconRef, vector: { dx: -1, dy: 0 }, rank: 0 })
- * fission.split()    // the pill carves into the pieces along the signature
- * ```
- */
-export declare function useDockFission(options: UseDockFissionOptions): UseDockFissionReturn;

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

@@ -1,18 +0,0 @@
-import { type Ref } from "vue";
-export interface UseDockItemDragParams {
-    /** The dock root element (the items live in its active layer). */
-    rootEl: Ref<HTMLElement | null>;
-    /** Whether the axis is armed (the `:draggable-items` prop). May be a getter. */
-    enabled: () => boolean;
-    /** The morph axis (`"x"` horizontal · `"y"` vertical). A getter (orientation flips). */
-    axis: () => "x" | "y";
-    /** Fired once on settle with the committed (from, to) item indices. */
-    onReorder?: (from: number, to: number) => void;
-}
-export interface UseDockItemDragReturn {
-    /** True while a dock item is being dragged. */
-    dragging: Readonly<Ref<boolean>>;
-    /** Tear down the gesture + listeners. */
-    detach: () => void;
-}
-export declare function useDockItemDrag(params: UseDockItemDragParams): UseDockItemDragReturn;

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

@@ -1,15 +0,0 @@
-import { type Ref } from "vue";
-/** The morph-window handlers the GlassDock SFC wires. */
-export interface DockMorphWindow {
-    markTransitioning: () => void;
-    onDockTransitionDone: (event: TransitionEvent) => void;
-    clearTransitionTimer: () => void;
-}
-/**
- * Own the `isTransitioning` flag's morph-window lifecycle. `markTransitioning`
- * (every `visualExpanded` flip) bumps a private generation so any in-flight
- * morph's pending timer / `transitionend` self-cancels (the A→B→A no-skip /
- * no-queue invariant); `onDockTransitionDone` resolves the flag on a resize-morph
- * property finishing. Clears its timer on unmount.
- */
-export declare function useDockMorphWindow(dockEl: Ref<HTMLElement | null>, isTransitioning: Ref<boolean>): DockMorphWindow;

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

@@ -1,44 +0,0 @@
-import { type ComputedRef, type Ref } from "vue";
-export type DockMorphOrientation = "vertical" | "horizontal";
-export interface UseDockOrientationMorphOptions {
-    /**
-     * The host root the scalar is written to (`--dock-morph-t`). Both docks + the
-     * bridge live under it and read the inheriting scalar.
-     */
-    rootEl: Ref<HTMLElement | null>;
-    /** The vertical dock's full (expanded) block size in px — the `t=0` height. */
-    verticalSize: number | (() => number);
-    /** The horizontal dock's full (expanded) inline size in px — the `t=1` width. */
-    horizontalSize: number | (() => number);
-}
-export interface UseDockOrientationMorphReturn {
-    /** The current target orientation. Set via `toggle()`/`morphTo()`. */
-    orientation: Readonly<Ref<DockMorphOrientation>>;
-    /** The live normalized scalar (0 = vertical, 1 = horizontal). */
-    t: Readonly<Ref<number>>;
-    /** True while the spring is in flight (the host arms `data-morphing`). */
-    morphing: Readonly<Ref<boolean>>;
-    /** The vertical dock's live height style (`{ height: "Npx" }`), collapsing 0. */
-    verticalStyle: ComputedRef<Record<string, string>>;
-    /** The horizontal dock's live width style (`{ width: "Npx" }`), growing 0→full. */
-    horizontalStyle: ComputedRef<Record<string, string>>;
-    /** The vertical dock's crossfade opacity (`{ opacity: "…" }`), 1→0 over the morph. */
-    verticalOpacity: ComputedRef<Record<string, string>>;
-    /** The horizontal dock's crossfade opacity (`{ opacity: "…" }`), 0→1 over the morph. */
-    horizontalOpacity: ComputedRef<Record<string, string>>;
-    /** The teardrop squish scalar (the bridge reads it for the liquid swell). */
-    stretch: ComputedRef<number>;
-    /** Morph to the explicit orientation (a no-op if already there). */
-    morphTo(next: DockMorphOrientation): void;
-    /** Toggle V↔H. The bidirectional driver — the SAME scalar both ways. */
-    toggle(): void;
-    /**
-     * PIN the morph to an EXACT scalar value (0→1) with NO spring — the deterministic
-     * capture seam (HG1). Disposes any live spring, writes the scalar + both flex
-     * spans + the crossfade to exactly `value`, so a frame captured at a given `t` is
-     * byte-reproducible (no wall-clock, no spring asynchrony). The orientation is set
-     * to the side `value` lands on for the inert/a11y contract.
-     */
-    pin(value: number): void;
-}
-export declare function useDockOrientationMorph(options: UseDockOrientationMorphOptions): UseDockOrientationMorphReturn;

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

@@ -1,85 +0,0 @@
-import { type MaybeRefOrGetter, type Ref } from "vue";
-import type { UseDockStateReturn } from "./useDockState";
-import { type FuzzySearchState, type SearchableItem, type SearchResult } from "../../search/composables";
-import { type UseScrollChromeReturn } from "../../../../composables/motion/useScrollChrome";
-export interface UseDockSearchOptions<T extends SearchableItem = SearchableItem> {
-    /** Composes the existing dock state machine (no fork) — `armSearch`/`disarmSearch`
-        ride its `onClickCollapsed`/`keepOpen`/`release`. */
-    dockState: UseDockStateReturn;
-    /**
-     * The search items (sync) — a static array or a getter. Drives the composed
-     * `useFuzzySearch` matcher. MUTUALLY EXCLUSIVE with `onSearch` (sync XOR async).
-     */
-    items?: T[] | (() => T[]);
-    /**
-     * The pluggable async data source (the words network case). The consumer owns the
-     * abort/network race-guard; the dock owns the gesture/shrink/dropdown. When set, the
-     * dock awaits the source on each query, cancelling the prior request's
-     * `AbortController` (the generic thin abort). MUTUALLY EXCLUSIVE with `items`.
-     */
-    onSearch?: (query: string, signal: AbortSignal) => Promise<T[]>;
-    /** Debounce delay in ms forwarded to the matcher / the async source. Default 120. */
-    debounceMs?: number;
-    /** Maximum results forwarded to the matcher. Default 30. */
-    maxResults?: number;
-    /**
-     * Opt-in collapse-on-scroll — composes `useScrollChrome` (persistent-default, the
-     * iOS-27 lesson). DEFAULT FALSE: the dock is PERSISTENT; the morph fires on user
-     * intent (tap/focus), never a passive scroll. When true the chrome shrinks+fades on
-     * scroll-down + expands on scroll-up (the transform-only `--chrome-collapse-t` ramp).
-     */
-    collapseOnScroll?: boolean;
-    /** The scroll source for the optional collapse-on-scroll (a container or window). */
-    scrollContainer?: MaybeRefOrGetter<HTMLElement | Window | null>;
-    /** The dock element the collapse-on-scroll writes `--chrome-collapse-t` onto. */
-    chromeRef?: MaybeRefOrGetter<HTMLElement | null>;
-    /**
-     * Result-select hook — wires the ToC subsume: `ensureTargetWindow(id)` (warm the
-     * window so the target renders) + `scrollTo(id)` (the rAF-retry scroll-to-and-land).
-     * The dock owns the gesture; the consumer passes the two leaves' bound functions.
-     */
-    onResultSelect?: (result: SearchResult<T>) => void;
-    /**
-     * The virtual-window warm step (composed `useVirtualSectionWindow.ensureTargetWindow`).
-     * Called BEFORE `scrollTo` on a result-select so the windowed target is rendered.
-     */
-    ensureTargetWindow?: (id: string) => void;
-    /**
-     * The ToC scroll-to (composed `useScrollTo.scrollTo`) — the rAF-retry scroll-to-id.
-     * Called AFTER the warm step on a result-select.
-     */
-    scrollTo?: (id: string) => void;
-}
-export interface UseDockSearchReturn<T extends SearchableItem = SearchableItem> {
-    /** The composed `useFuzzySearch` handle (query/results/selectedIndex/onKeydown/…). */
-    fuzzy: FuzzySearchState<T>;
-    /** The ghost-text top-match completion (the unmatched suffix of `results[0].label`). */
-    autocompleteText: Ref<string>;
-    /** The optional collapse-on-scroll machine (null when `collapseOnScroll` is false). */
-    scrollChrome: UseScrollChromeReturn | null;
-    /** Tap/focus → expand + hold (composes `onClickCollapsed` + `keepOpen`). */
-    armSearch: () => void;
-    /** Close → release the hold (composes `release`) + close the fuzzy surface. */
-    disarmSearch: () => void;
-    /** Tab/Space/ArrowRight → fill the ghost-text into the query. */
-    acceptAutocomplete: () => void;
-    /** True while the search field is the armed/morphed surface. */
-    isSearchArmed: Ref<boolean>;
-}
-/**
- * The dock-search seam — composes `useDockState` + `useFuzzySearch` (+ optional
- * `useScrollChrome`); the `armSearch`/`disarmSearch`/`autocompleteText`/
- * `acceptAutocomplete` surface; the async `onSearch` adapter; the `onResultSelect` →
- * `ensureTargetWindow` + `scrollTo` wire. Does NOT edit the morph engine
- * (`dockMorphContext`/`DOCK_SPRING` byte-untouched — the box-inviolate fence); the
- * pill→field morph is the dock's OWN `--dock-morph-t` glide + the `morph-bridge.css`
- * metaball.
- *
- * @example
- * ```ts
- * const dockState = useDockState({ rootEl });
- * const search = useDockSearch({ dockState, items: () => sections.value });
- * // armSearch() on tap → the pill morphs into the field; type → fuzzy dropdown ranks.
- * ```
- */
-export declare function useDockSearch<T extends SearchableItem = SearchableItem>(options: UseDockSearchOptions<T>): UseDockSearchReturn<T>;

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

@@ -1,214 +0,0 @@
-import { type ComputedRef } from "vue";
-export type DockDensity = "compact" | "comfortable" | "spacious" | "audacious";
-/**
- * The ONE GlassDock prop shape (AZ.W-DOCK-TAXONOMY — the discriminated union is
- * gone). Every dock — horizontal or vertical — reads the SAME surface; orientation
- * is the single layout axis and the collapse surface applies on both.
- */
-export interface DockProps {
-    fitContent?: boolean;
-    position?: "fixed" | "inline" | "sticky";
-    /**
-     * Never collapse — render permanently expanded; the single opt-OUT of the
-     * collapse↔expand machinery. Default `false` (every dock is collapsible).
-     * AZ.W-DOCK-TAXONOMY — vertical docks are NO LONGER force-pinned here (a
-     * vertical dock morphs its height too; the prior `variant="rail"`
-     * always-expanded-by-construction is removed). A `layout="grid"` dock is
-     * `alwaysExpanded` BY CONTRACT (a 2D tile panel does not read as a collapsible
-     * pill). A vertical nav column that wants the static always-expanded look opts
-     * in via this prop. (A positive `collapsible` boolean was considered and
-     * rejected: Vue coerces an absent boolean prop to `false`, so a `collapsible`
-     * defaulting to `true` would need a `withDefaults` second default-path; the
-     * existing `alwaysExpanded` opt-out — which correctly defaults `false` — is the
-     * one knob, no Vue boolean-trap.)
-     */
-    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.
-     *
-     * Paints on BOTH orientations (AZ.W-DOCK-TAXONOMY — `shape` is no longer
-     * variant-gated; a vertical dock reads `shape="rounded"` for the tool-palette
-     * look, a horizontal dock reads `shape="card"` for the big-dock shell).
-     */
-    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`. This is the SINGLE layout axis — there
-     * is no `variant` second-way to express "vertical" (AZ.W-DOCK-TAXONOMY).
-     */
-    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 dock 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 docks 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).
-     *
-     * ALWAYS-EXPANDED-ONLY (AY.W-DOCK2 §F1): `container-type: inline-size`
-     * clamps the box to its contained intrinsic size, so on a COLLAPSIBLE
-     * dock the collapse↔expand FLIP measures collapsed→collapsed and the
-     * morph FREEZES. A collapsible dock that needs deterministic targeting
-     * uses a plain `data-testid` (no layout side-effect).
-     */
-    containerName?: string;
-    /**
-     * Idle-collapse delay in ms (default 2000). Inert on an always-expanded dock.
-     */
-    collapseDelay?: number;
-    /**
-     * Start in the collapsed state (default true). Applies on BOTH orientations
-     * (AZ.W-DOCK-TAXONOMY — a vertical dock starts collapsed and morphs its block
-     * axis open too). Inert on an always-expanded dock.
-     */
-    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`).
-     */
-    layout?: "linear" | "grid";
-    /**
-     * AZ.W-ADAPTIVE-AUTO Arm 2 (H3 arm a) — the sampled-luminance observer that
-     * DYNAMICALLY refines the W55 declarative bright-bucket darken (the iOS-27
-     * "darken dynamically" register). Default `true` (default-ON for the dock — the
-     * surface most often over a live/bright backdrop). It REFINES the floor (the
-     * unconditional self-engage + the declarative bucket stay the guarantee); a
-     * dark-substrate consumer opts out with `:auto-luminance="false"` (or
-     * `--glass-tint-strength: 0%` on the dock). The observer is rAF-throttled ≤ 4 Hz,
-     * IntersectionObserver-gated, and parks under `prefers-reduced-motion: reduce`.
-     */
-    autoLuminance?: boolean;
-    /**
-     * The KNOWN background-layer canvas the dock floats over (an aurora/blob
-     * `<canvas>`) — an element, a getter, or a CSS selector. When present, the
-     * observer downsamples it under the dock's box each settle (the ANIMATED-backdrop
-     * case); absent, it stack-walks the painted page background (the static case).
-     */
-    backgroundCanvas?: HTMLCanvasElement | (() => HTMLCanvasElement | null) | string | null;
-    /**
-     * BC.W-DOCK-SEARCH — the dock-as-native-dynamic-search-bar MODE (additive,
-     * default `false`). When true the dock stamps `[data-search]` (the CSS hook the
-     * `dock/search.css` active-field tint seam + the `.glass-menu-row` result rows
-     * target) and renders the `#search` slot INSIDE the existing morph aperture — the
-     * consumer composes `useDockSearch` (the gesture/shrink/dropdown seam) and slots
-     * its search field + fuzzy dropdown there. The pill→field morph is the dock's OWN
-     * `--dock-morph-t` glide (box-inviolate — no second engine). A non-search dock is
-     * byte-identical to HEAD (the slot + the data-attr are present only when authored).
-     */
-    search?: boolean;
-    /**
-     * BD.W-DOCK-CORE (A13 / II.2) — arm the SHIPPED fission seam (additive, default
-     * `false`). When true the dock composes `useDockFission` (the n-ary detach
-     * orchestrator on the SAME `DOCK_SPRING` clock, BESIDE the morph engine — box-
-     * INVIOLATE, never editing `dockMorphContext`), auto-registers every child marked
-     * `data-dock-splittable` as a fission PIECE (its detach vector derived from its
-     * FLIP-measured center relative to the dock center), feeds the seam-tension on
-     * `@pointermove`, and exposes `split()`/`merge()`/`toggle()` via `defineExpose`. A
-     * non-splittable dock is byte-identical to HEAD. The ONE `<GooFilter>` mount must be mounted
-     * once at the app root (the goo `<filter>` the necks reference).
-     */
-    splittable?: boolean;
-    /**
-     * BD.W-DOCK-CORE (A13) — the fission CONTEXT (the `DOCK_SPLIT_SIGNATURES` row): the
-     * detach-vector family + neck stagger. `"nav"` (default) is inward-merge; `"search"`
-     * is a radial bloom; `"media"` is a lateral peel.
-     */
-    splitContext?: "search" | "media" | "nav";
-    /**
-     * BD.W-DOCK-CORE (A13) — where the detached sibling dock lands (reads the split
-     * vector). `"beside"` (default) is the radial/lateral lateral landing; `"above"`/
-     * `"below"` are the V-axis landings.
-     */
-    splitPlacement?: "beside" | "above" | "below";
-    /**
-     * BD.W-DOCK-CORE (A12) — arm the draggable-ITEMS axis (additive, default `false`).
-     * When true every child marked `data-dock-draggable` (or, lacking marks, every
-     * `.dock-icon-button` in the active layer) becomes GRABBABLE: a pointer-capture grab
-     * lets the user pull a dock item and the gesture follows ~1:1 with a volume-preserving
-     * gel-squish (the SHIPPED `useDragMorph` composing kf `Draggable` + `useLiquidFlex`
-     * "tanh" velocity-squish — NO second drag engine), then flings velocity-continuously to
-     * the nearest slot, committing a REORDER via `update:order`. Compositor-only
-     * (`transform: translate` — never a layout property); PRM-safe (the gesture still
-     * functions, the squish off, the release an instant nearest-snap); the roving-tabindex
-     * keyboard contract on the dock controls is preserved (a draggable strip that is
-     * keyboard-dead is the worse failure). A non-draggable dock is byte-identical to HEAD.
-     */
-    draggableItems?: boolean;
-}
-/** The resolved shell-prop computeds the GlassDock SFC binds. */
-export interface DockShellProps {
-    containerStyle: ComputedRef<Record<string, string> | undefined>;
-    collapseDelay: ComputedRef<number>;
-    startCollapsed: ComputedRef<boolean>;
-    layoutValue: ComputedRef<"linear" | "grid">;
-    shape: ComputedRef<"pill" | "rounded" | "card">;
-    orientation: ComputedRef<"horizontal" | "vertical">;
-    density: ComputedRef<DockDensity>;
-    scrollClass: ComputedRef<string | null>;
-    alwaysExpanded: ComputedRef<boolean>;
-    fitContent: ComputedRef<boolean>;
-}
-/**
- * Derive the dock's resolved shell props off the raw `props`. The defaults are
- * applied at each read site via `?? default` (every shared default has exactly one
- * resolution point — the one-path precept).
- */
-export declare function useDockShellProps(props: DockProps): DockShellProps;

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

@@ -1,90 +0,0 @@
-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>;
-    /** The currently active layer id. */
-    activeLayer: Ref<string>;
-    /**
-     * Animation axis. `"horizontal"` morphs the inline axis; `"vertical"` morphs
-     * the block axis. Defaults to horizontal when omitted.
-     */
-    axis?: Ref<"horizontal" | "vertical">;
-    /**
-     * Retained for API parity with the prior VT-typed signature (consumed by
-     * `GlassDock` + `DockLayerGroup`). The single-scalar morph runs ONE symmetric
-     * spring on every engine, so the direction hint is no longer a curve fork — it
-     * is accepted and ignored. Kept so the call sites need no edit.
-     */
-    directionTypes?: (from: string, to: string) => string[];
-}
-export interface UseLayerTransitionReturn {
-    /** Attach to `@transitionend` on the container (kept for call-site parity). */
-    onTransitionEnd(e: TransitionEvent): void;
-    /** The currently active layer id (post-swap). */
-    currentLayer: Ref<string>;
-    /** The layer id currently fading out, or null. */
-    leavingLayer: Ref<string | null>;
-    /**
-     * BB.W-PERF-PRODUCER A′-4 — `true` while the size morph is in flight (the
-     * reactive twin of the `data-morphing` attr). A floating dock consumer reads
-     * this to hold a reka Popper re-position off the morph's critical frames.
-     */
-    morphing: Ref<boolean>;
-    /**
-     * BB.W-PERF-PRODUCER A′-4 — schedule a reka Popper re-position OFF the
-     * synchronous morph flush. Queued while a morph is live (flushed ONCE on
-     * settle, against the final box), else run on the next rAF. Defers the floating
-     * re-position only — NOT the FLIP measure.
-     */
-    deferReposition(cb: () => void): void;
-}
-/**
- * Coordinates the size morph + crossfade between grid-stacked dock layer panes.
- * Reusable at any nesting level (the inner `<DockLayerGroup>` pair AND the outer
- * `GlassDock` collapsed↔expanded pair).
- */
-export declare function useLayerTransition(options: UseLayerTransitionOptions): UseLayerTransitionReturn;