@mkbabb/glass-ui 4.2.0 → 6.0.0

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

@@ -1,45 +0,0 @@
-/** The signed shortest-arc offset on a wrap ring (the "negative-infinity modulus" — a
- *  naive `raw % N` breaks the backward wrap). Wraps to `[-N/2, N/2)`. */
-export declare function ringOffset(raw: number, n: number): number;
-/** The φ-tiered slot SPAN to a given absolute slot-distance — the chosen→neighbour gap
- *  is wider than the neighbour→far gap (the recession compresses as items recede, the
- *  depth read). The tier ratio is EXPRESSED in the accumulation, never a flat resolved
- *  rebake (the W-CARD-PAD φ-ladder fence). */
-export declare function tieredSpan(adist: number, base: number, ratio: number): number;
-/** The geometry knobs for the facet carousel — the φ-tier spacing + the fade model. */
-export interface RailProjectionGeometry {
-    /** The active→neighbour base slot gap, in px (the tier-0 spacing). Default 44. */
-    slotSpacing?: number;
-    /** The φ tier ratio — each receding tier compresses by this. Default 1.618. */
-    tierRatio?: number;
-    /** The slot-distance at which the fade begins (active + immediate neighbour stay
-     *  full). Default 0.5. */
-    fadeStart?: number;
-    /** The slot-span the fade runs over. Default 2.5. */
-    fadeRange?: number;
-    /** The far floor alpha. Default 0. */
-    fadeMinAlpha?: number;
-    /** The per-slot scale recession (the depth read). Default 0.06. */
-    scaleStep?: number;
-    /** The max slots the scale recession clamps at. Default 4. */
-    scaleClampSlots?: number;
-}
-/** One projected facet — the compositor-only transform tier for the ring item. */
-export interface RailFacetProjection {
-    /** The stable ring index `0..count-1` (the `v-for` key). */
-    index: number;
-    /** The signed shortest-arc slot offset from the active facet. */
-    offset: number;
-    /** The px translate along the rail's main axis. */
-    translate: number;
-    /** The faded alpha (0..1). */
-    opacity: number;
-    /** The recession scale (≤1). */
-    scale: number;
-    /** Whether this is the active facet (offset 0). */
-    active: boolean;
-}
-/** Project the facet ring around the `active` index, fanned by `expand` (0 collapsed → 1
- *  fully fanned). Returns the virtualized WINDOW of `±ceil(fadeRange+1)` items, each with
- *  its compositor-only `{ translate, opacity, scale }`. PURE — no state, no measure. */
-export declare function projectFacets(count: number, active: number, expand: number, geometry?: RailProjectionGeometry): RailFacetProjection[];

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

@@ -1,23 +0,0 @@
-import { type Ref } from "vue";
-export interface DockClickIntegrity {
-    /** Capture-phase `pointerdown` handler — records the press-time element + state. */
-    onPointerDownCapture: (event: PointerEvent) => void;
-    /** Capture-phase `click` handler — swallows an identity-changed post-swap click. */
-    onClickCapture: (event: MouseEvent) => void;
-    /** Mark the collapsed→expanded flip so the settle window opens (call on expand). */
-    markExpandFlip: () => void;
-}
-export interface UseDockClickIntegrityOptions {
-    /** The dock root element ref — the morph-state owner (`[data-morphing]`). */
-    rootEl: Ref<HTMLElement | null>;
-    /** `true` whenever the dock is visually expanded (collapsed = !this). */
-    visualExpanded: Ref<boolean>;
-}
-/**
- * The dock click-integrity guard (R5-3). Returns the three capture-phase handlers
- * the GlassDock SFC wires onto its root. The guard is a pure DOM-timing concern: it
- * holds the press-time element identity + the settle-window deadline and decides, on
- * the click, whether the click landed on the SAME control it was aimed at. Owns its
- * own unmount cleanup.
- */
-export declare function useDockClickIntegrity(options: UseDockClickIntegrityOptions): DockClickIntegrity;

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

@@ -1,192 +0,0 @@
-import { type MorphRect } from "@mkbabb/keyframes.js";
-import { type Ref } from "vue";
-import { type SpringPresetName } from "../../../../composables/motion/springPresets";
-/** The dock orientation axis (the `dim`-idiom source — slot geometry derives from it). */
-export type SilhouetteOrientation = "horizontal" | "vertical";
-/** The four named silhouette kinds (the descriptor map's contract). */
-export type DockSilhouetteKind = "bar" | "bar+pill" | "split" | "search";
-/**
- * The silhouette spring register — a subset of the named `SPRING_PRESETS` rows matching
- * the `useDockCtaReceive`/`useLiquidReveal` register so every dock morph reads as ONE
- * spring family. `dock` is the default (the dock's own settle clock).
- */
-export type SilhouettePreset = Extract<SpringPresetName, "dock" | "snappy" | "bouncy">;
-/**
- * One named SLOT inside a silhouette — a position keyed by `controlId`. The geometry is
- * ORIENTATION-DERIVED: `main` is the offset along the dock's main axis (the row position
- * horizontal / the column position vertical), `cross` the cross-axis offset, `size` the
- * control's extent. The orchestrator resolves these into a concrete `MorphRect` off the
- * orientation + the dock's measured origin (the `dim`-idiom — never a hardcoded
- * `inline-size`/`block-size` literal, so vertical is the SAME data with `orientation`
- * flipped).
- */
-export interface SilhouetteSlot {
-    /** The control this slot positions (the diff key — present-in-both → FLIP). */
-    controlId: string;
-    /** Offset along the dock's MAIN axis (px from the dock origin). */
-    main: number;
-    /** Offset along the CROSS axis (px from the dock origin). */
-    cross: number;
-    /** The control's main-axis extent (px). */
-    size: number;
-    /** The control's cross-axis extent (px; defaults to `size` for a square control). */
-    thickness?: number;
-    /**
-     * FUSION marker (the `bar+pill` headline): when true, this slot's `to`-rect is the
-     * bar's TOP CROWN and the orchestrator drives `--silhouette-fuse-t` so the slotted
-     * control (the now-playing pill) DOCKS DOWN and MELDS into the bar as ONE plate. A
-     * `bar+pill` descriptor with NO `fuse: true` slot is a pill-ABOVE-bar literal (the
-     * C3 anti-evasion — the gate reds it).
-     */
-    fuse?: boolean;
-}
-/**
- * One declarative silhouette descriptor — a context's whole geometry as DATA (the
- * `DockSectionDescriptor` precedent: data, not code paths). The orchestrator reads the
- * MAP; there is NO per-context hardcoded silhouette literal (the gate's C1 anti-evasion
- * floor).
- */
-export interface DockSilhouetteDescriptor {
-    /** Stable identifier — the `setSilhouette` argument + the active-silhouette id. */
-    id: string;
-    /** Which of the four named kinds this context renders. */
-    kind: DockSilhouetteKind;
-    /** The named slots (control positions) this silhouette places. */
-    slots: readonly SilhouetteSlot[];
-    /** This silhouette's spring register (DATA, not an SFC ternary). Default `dock`. */
-    preset?: SilhouettePreset;
-    /**
-     * The neck-hold for any DETACH this transition drives (DATA — fed to `useDockFission`
-     * when a control is present-in-from-only). 0 = no hold (immediate release), 1 = full
-     * hold (the goo necks late then snaps).
-     */
-    neckHold?: number;
-}
-/**
- * The DETACH hand-off API the orchestrator drives (BE.W-DOCK-FISSION owns the engine).
- * A control PRESENT-only-in-FROM detaches — the orchestrator registers it as a fission
- * PIECE via `registerPiece` and the fission orchestrator buds it off the body. Defined
- * here per the fission spec (`useDockFission` `registerPiece`); the sibling agent builds
- * it, the orchestrator reconciles the import. The orchestrator never re-implements the
- * detach physics — it CALLS this.
- */
-export interface FissionPieceHandle {
-    /** Release the piece (drive its `--dock-split-t` 0→1 detach). */
-    detach: () => void;
-    /** Re-merge the piece (the bidirectional 1→0). */
-    remerge: () => void;
-    /** Unregister the piece (cleanup). */
-    release: () => void;
-}
-/** The fission registrar the orchestrator composes (BE.W-DOCK-FISSION's `registerPiece`). */
-export type RegisterFissionPiece = (el: HTMLElement, spec: {
-    vector: {
-        dx: number;
-        dy: number;
-    };
-    rank: number;
-    neckHold: number;
-}) => FissionPieceHandle;
-/**
- * The BLOOM-IN hand-off API the orchestrator drives (BE.W-BLOOM-UP owns the engine). A
- * control PRESENT-only-in-TO blooms in — the inverse FLIP. Defined here per the bloom-up
- * spec (`useBloomUp(sourceRef, destRef)`); the orchestrator CALLS it, never re-implements
- * the bloom.
- */
-export type BloomInPiece = (el: HTMLElement, fromRect: MorphRect, toRect: MorphRect) => void;
-export interface UseDockContextSilhouetteOptions {
-    /** The declarative silhouette descriptor MAP (the four kinds; net-new DATA). */
-    silhouettes: readonly DockSilhouetteDescriptor[];
-    /** The id of the silhouette to seat at construction (defaults to the first). */
-    initial?: string;
-    /** The dock orientation (the `dim`-idiom source). Default `horizontal`. */
-    orientation?: SilhouetteOrientation | Ref<SilhouetteOrientation>;
-    /**
-     * Resolve a control's live element by `controlId` (the orchestrator measures its
-     * current rect for the FLIP). The consumer wires this off its slot refs.
-     */
-    resolveControl: (controlId: string) => HTMLElement | null;
-    /**
-     * The dock ROOT element — the orchestrator measures its origin (to resolve a slot's
-     * orientation-derived `main`/`cross` into a viewport `MorphRect`) AND writes
-     * `--silhouette-fuse-t` onto it for the fusion meld. The fused glass plate is the
-     * dock body itself (C5 — the detach pieces paint in the non-clipping frame; the fused
-     * plate is the dock root).
-     */
-    dockRoot: Ref<HTMLElement | null>;
-    /**
-     * The DETACH registrar (BE.W-DOCK-FISSION's `registerPiece`). When absent, a
-     * present-in-from-only control is simply removed from the FLIP set (no detach
-     * choreography — graceful until fission wires in).
-     */
-    registerFissionPiece?: RegisterFissionPiece;
-    /**
-     * The BLOOM-IN driver (BE.W-BLOOM-UP). When absent, a present-in-to-only control
-     * snaps in (no bloom choreography — graceful until bloom-up wires in).
-     */
-    bloomInPiece?: BloomInPiece;
-    /** Honor `prefers-reduced-motion: reduce` (seat synchronously). Default true. */
-    respectReducedMotion?: boolean;
-    /** Fired once when a silhouette transition has settled (the consumer hand-off). */
-    onSettled?: (toId: string) => void;
-}
-export interface UseDockContextSilhouetteReturn {
-    /** The active silhouette id (reactive — the consumer reads the SHAPE). */
-    active: Readonly<Ref<string>>;
-    /** The active descriptor (reactive). */
-    activeDescriptor: Readonly<Ref<DockSilhouetteDescriptor | null>>;
-    /** Whether a transition is in flight (the consumer guards re-entrancy / `[data-morphing]`). */
-    transitioning: Readonly<Ref<boolean>>;
-    /**
-     * Transition to the silhouette `toId` — DIFFs the slots by `controlId`, FLIPs the
-     * survivors, detaches the from-only, blooms in the to-only, and drives the fusion
-     * meld for a `bar+pill` target. A no-op if `toId` is unknown or already active.
-     */
-    setSilhouette: (toId: string) => void;
-}
-/**
- * The declarative context→silhouette state machine. Reads a `DockSilhouetteDescriptor[]`
- * MAP; on `setSilhouette` it DIFFs the slots by `controlId` and FLIPs/detaches/blooms via
- * the SHIPPED `ElementMorph` + `springTimingFunction` substrate, ONE `DOCK_SPRING`. The
- * `bar+pill` fusion docks the pill into the bar via `--silhouette-fuse-t`. Compositor-only
- * + PRM-seats. See the module header for the REUSE + the orientation-derived slots + the
- * fusion mechanism.
- *
- * @example
- * ```ts
- * const sil = useDockContextSilhouette({
- *   silhouettes: [
- *     { id: "nav",   kind: "bar",      slots: [...] },
- *     { id: "media", kind: "bar+pill", slots: [{ controlId: "pill", main: 0, cross: -56, size: 240, fuse: true }, ...] },
- *   ],
- *   orientation,
- *   dockRoot,
- *   resolveControl: (id) => slotRefs.value[id] ?? null,
- * })
- * sil.setSilhouette("media") // the pill DOCKS DOWN + MELDS into the bar
- * ```
- */
-export declare function useDockContextSilhouette(options: UseDockContextSilhouetteOptions): UseDockContextSilhouetteReturn;
-/**
- * Compute a detached control's DIRECTION-VECTOR off its slot + the orientation (the
- * fission `vector` — the `dim`-idiom). A control peels along the CROSS axis (the
- * `stack-rail.css` gutter direction the fission media=lateral signature reuses): the sign
- * of `cross` chooses the side, the orientation chooses the axis. This is PURE (exported
- * for the unit test — the slot-diff vector logic is testable without a DOM).
- */
-export declare function detachVector(slot: SilhouetteSlot, orientation: SilhouetteOrientation): {
-    dx: number;
-    dy: number;
-};
-/**
- * PURE slot-diff — exported for the unit test (the diff logic is testable without a DOM).
- * Classifies each controlId across the from/to slot sets: `survivors` (present-in-both →
- * FLIP), `bloomIns` (to-only → BLOOM), `detaches` (from-only → DETACH). This is the
- * load-bearing classification `setSilhouette` runs; testing it directly proves the
- * descriptor-driven state machine is correct without a browser.
- */
-export declare function diffSilhouetteSlots(from: readonly SilhouetteSlot[], to: readonly SilhouetteSlot[]): {
-    survivors: string[];
-    bloomIns: string[];
-    detaches: string[];
-};

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>;