@mkbabb/glass-ui 4.1.0 → 5.0.0

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

@@ -1,65 +0,0 @@
-import { type Component } from "vue";
-import type { DockStackItem } from "./constants";
-/**
- * <DockStack> — BC.W-DOCK-STACK-RAIL. The macOS Dock hover-expand STACK (the clean-break
- * rebuild of the retired divider-carousel `DockRail`). It renders in `GlassDock`'s `#rail`
- * slot, over the KEPT `.glass-dock-frame` non-clipping escape, so it extends BEYOND the
- * dock edge into its own gutter WITHOUT touching the dock box (the box-INVIOLATE
- * discipline — `deltaW = deltaH = 0`).
- *
- * THE STACK. A `core` anchor item (the always-visible glyph, sitting in the dock(1)) +
- * `items: readonly DockStackItem[]` (the members). On hover (pointer-enter) OR focus of
- * the core item, the members FAN OUT next to the rail — a column (vertical dock) / row
- * (horizontal dock) of FULLY-VISIBLE glass icons springing open beside the line, each on
- * the iOS liquid clock, staggered by `--dock-stack-stagger * var(--i)` in reading order.
- * The hover-collapse reverses on the no-overshoot `--ease-out`. Every member is a clear
- * `--glass-bg-floating` glass icon — NEVER a shadowed half-tucked chip (the "NOT shadowed"
- * verbatim ask). At rest only the core (1) shows; expanded, the n members.
- *
- * 3 CONFIGURABLE, SCROLLABLE, N-STACK. `visibleCount` (default 3) members fan at rest;
- * an >visibleCount stack routes the fanned column through `<FadingScroll>` (the one
- * scroll-fade port) so the n-stack is reachable by scrolling the rail, NOT by overflowing
- * the dock box.
- *
- * THE HOVER-HYSTERESIS (REUSED, not re-forked — AZ.W-DOCK-FLICKER). The pointer-enter
- * commits the open only after the `HOVER_INTENT_MS` intent-dwell (the SAME constant the
- * dock-collapse hysteresis reads), so a sweeping-edge enter does not flash the stack open.
- * Focus opens immediately (keyboard intent is explicit); blur/leave closes.
- *
- * ONE REGISTRY (R2 KEPT). The members write the consumer-owned `v-model:selected`; this
- * primitive owns NO internal `ref()`/`reactive()` shadow of the active member. The hover
- * `expanded` is a transient UI state (optionally `v-model:expanded` controlled), NOT a
- * selection shadow.
- */
-type __VLS_Props = {
-    /** The stack members — the fan-out contents (NOT facet chips; the macOS stack). */
-    items: readonly DockStackItem[];
-    /** The core anchor glyph (the always-visible dock(1) item). Default: a layers glyph. */
-    core?: Component;
-    /** The core's accessible label (the stack's name). */
-    coreLabel?: string;
-    /** Members visible at rest before scrolling (the verbatim "3 configurable"). */
-    visibleCount?: number;
-    /** Which dock edge the stack anchors to. */
-    position?: "start" | "end";
-};
-type __VLS_ModelProps = {
-    "selected"?: string;
-    "expanded"?: boolean;
-};
-type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    select: (id: string) => any;
-    "update:selected": (value: string | undefined) => any;
-    "update:expanded": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onSelect?: ((id: string) => any) | undefined;
-    "onUpdate:selected"?: ((value: string | undefined) => any) | undefined;
-    "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
-}>, {
-    position: "start" | "end";
-    visibleCount: number;
-    coreLabel: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

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

@@ -1,39 +0,0 @@
-import { type HTMLAttributes } from "vue";
-/**
- * <DockTabButton> — text-tab button for use inside a horizontal GlassDock.
- *
- * Emits the dock tab-button class contract. Interactive styling is owned by
- * src/styles/dock.css. Sibling to <DockIconButton>: DockIconButton is
- * fixed-square for icons; DockTabButton is auto-sized for short text labels.
- *
- * Use `as-child` to render as a <RouterLink> or <a>: the active state
- * automatically activates when the rendered element carries
- * aria-current="page" (which RouterLink sets).
- *
- * BA.W-GLASS-CAL (H2a) — the `data-tier="primary"` auto-attach of the
- * `btn-audacious` disco utility is REMOVED (the recipe is retired). The primary
- * tier now reads ONLY its dock-local structural shell + the plain de-red'd glass
- * hover register (`dock-controls/tab-button.css`); `data-tier` is still the styling
- * hook the CSS keys off, the component no longer composes a utility class.
- */
-type __VLS_Props = {
-    as?: string;
-    asChild?: boolean;
-    class?: HTMLAttributes["class"];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    asChild: boolean;
-    as: string;
-}, {}, {}, {}, 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/dock/GlassDock.vue.d.ts

@@ -1,31 +0,0 @@
-import { type DockProps } from "./composables/useDockShellProps";
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {};
-type __VLS_Slots = {} & {
-    persistent?: (props: typeof __VLS_1) => any;
-} & {
-    default?: (props: typeof __VLS_3) => any;
-} & {
-    collapsed?: (props: typeof __VLS_5) => any;
-} & {
-    search?: (props: typeof __VLS_7) => any;
-} & {
-    rail?: (props: typeof __VLS_9) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<DockProps, {
-    expanded: import("vue").Ref<boolean, boolean>;
-    isPinned: import("vue").Ref<boolean, boolean>;
-    isHeld: import("vue").ComputedRef<boolean>;
-    isTransitioning: import("vue").Ref<boolean, boolean>;
-    expand: () => void;
-    collapse: () => void;
-    keepOpen: () => void;
-    release: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DockProps> & 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;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

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

@@ -1,47 +0,0 @@
-import type { ComputedRef } from "vue";
-export type DockOrientation = "horizontal" | "vertical";
-export type DockLayout = "linear" | "grid";
-/**
- * Dock context surfaces the dock id + orientation + held-state coordination
- * to descendants.
- *
- * O.W2 — canonical typed-key + helper-pair DI shape per invariant 25.
- * The 6 prior string-keyed provides (`glassDockContext`, `glassDockId`,
- * `dockKeepOpen`, `dockRelease`, `dockHeld`, `dockExpanded`) collapse into
- * the single `DOCK_CONTEXT_KEY` typed `InjectionKey<DockContext>`.
- * `dockExpanded` is retired (zero downstream consumers per Rδ audit).
- * `glassDockId` is dedup'd with `context.id`.
- *
- * Paired helpers:
- *  - `useDockContext()` — strict; throws when used outside `<GlassDock>`.
- *  - `useOptionalDockContext()` — befitting silent default for primitives
- *    that may render outside a dock (Slider, popovers, …).
- *
- * J.W3.B — `registerPopover` / `closeOtherPopovers` retired. Hover-driven
- * dock popovers compose `<HoverPopover keep-dock-open>` whose open/close
- * cadence is owned by reka-ui's HoverCard primitives; cooperative
- * dismissal between sibling popovers is no longer needed (HoverCard's
- * pointer-leave timer handles the cluster transit case).
- */
-export interface DockContext {
-    id: string;
-    orientation: ComputedRef<DockOrientation>;
-    /**
-     * In-cap arrangement (`linear` row/column vs `grid` tile panel). AX.W45 —
-     * `<DockSeparator>` reads this to paint a full-row section break in a grid dock
-     * (a 1px perpendicular hairline is useless in a 2D tile grid).
-     */
-    layout: ComputedRef<DockLayout>;
-    /** Acquire a keep-open token; suppresses timer-based collapse. */
-    keepOpen: () => void;
-    /** Release a previously-acquired keep-open token. */
-    release: () => void;
-    /** Reactive `keepOpenCount > 0` flag; descendants reflect via `data-held`. */
-    held: ComputedRef<boolean>;
-}
-export declare const DOCK_CONTEXT_KEY: import("vue").InjectionKey<DockContext>;
-export declare function provideDockContext(context: DockContext): void;
-/** Strict — throws when used outside `<GlassDock>`. */
-export declare const useDockContext: () => DockContext;
-/** Befitting silent default for primitives that may render outside a dock. */
-export declare const useOptionalDockContext: () => DockContext | null;

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

@@ -1,36 +0,0 @@
-import type { Component, Ref } from "vue";
-/**
- * DockLayerGroup context — DI surface for `<DockLayer>` children registering
- * with their parent `<DockLayerGroup>` for the switcher rail + crossfade
- * coordination.
- *
- * O.W2 Lane A — canonical typed-key + helper-pair DI shape per invariant
- * 25. Replaces the prior raw `provide("dockLayerGroup", {...})` + duplicated
- * inline interface in `DockLayer.vue`. The context is distinct from
- * `DockContext` (a `<DockLayerGroup>` doesn't have to live inside a
- * `<GlassDock>`) so it gets its own module-local key.
- */
-export interface DockLayerDescriptor {
-    id: string;
-    label?: string;
-    icon?: Component | string;
-}
-export interface DockLayerGroupContext {
-    register(desc: DockLayerDescriptor): void;
-    unregister(id: string): void;
-    /**
-     * AU.W8b.6 — group-orchestrated layer state, exposed READ-ONLY. The
-     * `<DockLayerGroup>` (via `useLayerTransition`) owns the writable refs and
-     * provides `readonly()` projections; a `<DockLayer>` child can read but
-     * never write this state. A child `currentLayerId.value = …` is a compile
-     * error (see `__tests__/dockLayerContext.readonly.test-d.ts`).
-     */
-    currentLayerId: Readonly<Ref<string>>;
-    leavingLayerId: Readonly<Ref<string | null>>;
-}
-export declare const DOCK_LAYER_GROUP_KEY: import("vue").InjectionKey<DockLayerGroupContext>;
-export declare function provideDockLayerGroupContext(context: DockLayerGroupContext): void;
-/** Strict — throws when used outside `<DockLayerGroup>`. */
-export declare const useDockLayerGroupContext: () => DockLayerGroupContext;
-/** Befitting silent default; reserved for future consumers. */
-export declare const useOptionalDockLayerGroupContext: () => DockLayerGroupContext | null;

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

@@ -1,93 +0,0 @@
-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>;
-    /** The group's currently-active pane id (its `v-model:active`). */
-    activeLayer: Ref<string>;
-    /** Layout axis of the group; matches the group's `orientation`. */
-    axis: Ref<"horizontal" | "vertical">;
-}
-export interface DockMorphGroupHandle {
-    /** The active pane id post-swap (the orchestrator mutates it). */
-    currentLayer: Readonly<Ref<string>>;
-    /** The pane id currently fading out, or null. */
-    leavingLayer: Readonly<Ref<string | null>>;
-    /** Detach this group from the orchestrator (on the group's unmount). */
-    release(): void;
-}
-/**
- * The provided morph seam. A nested `<DockLayerGroup>` injects this and DEFERS
- * its pane-swap morph to the dock's single orchestrator via `registerGroup`.
- */
-export interface DockMorphContext {
-    registerGroup(group: DockMorphGroupRegistration): DockMorphGroupHandle;
-}
-export declare const DOCK_MORPH_KEY: import("vue").InjectionKey<DockMorphContext>;
-export declare function provideDockMorphContext(context: DockMorphContext): void;
-/**
- * Befitting-silent — returns `null` for a `<DockLayerGroup>` rendered outside a
- * `<GlassDock>` (the standalone self-orchestrate path).
- */
-export declare const useOptionalDockMorphContext: () => DockMorphContext | null;
-export interface UseDockMorphOrchestratorOptions {
-    /** The `.glass-dock` root that carries the shared scalar + clip aperture. */
-    rootEl: Ref<HTMLElement | null>;
-    /** The outer collapse↔expand container (`.dock-layers`). */
-    outerEl: Ref<HTMLElement | null>;
-    /** The outer active "layer" id — `(expandedState)` projected to a string. */
-    outerActiveLayer: Ref<string>;
-    /** The outer pair morphs the inline axis (a horizontal dock). */
-    outerAxis: Ref<"horizontal" | "vertical">;
-}
-export interface UseDockMorphOrchestratorReturn {
-    /** Provide-able context: a nested `<DockLayerGroup>` registers through it. */
-    context: DockMorphContext;
-    /** The outer pair's post-swap active layer id (call-site parity). */
-    outerCurrentLayer: Readonly<Ref<string>>;
-    /** Defensive settle on a stray `@transitionend` (call-site parity). */
-    onOuterTransitionEnd(e: TransitionEvent): void;
-}
-/**
- * The ONE morph engine for a dock instance. Owns a single `SpringProgress`;
- * drives the outer collapse↔expand box AND every nested `<DockLayerGroup>`'s
- * pane-swap off the one `--dock-morph-t` scalar. Replaces the per-pair
- * `useLayerTransition` instantiation (W01's single-scalar primitive) with a
- * single multi-target driver, so a nested dock runs ONE engine, not two.
- */
-export declare function useDockMorphOrchestrator(options: UseDockMorphOrchestratorOptions): UseDockMorphOrchestratorReturn;

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

@@ -1,155 +0,0 @@
-import type { Ref } from "vue";
-/**
- * BB.W-CARVE4 — the dock morph MEASURE/SEAT helpers, carved out of
- * `dockMorphContext.ts` to hold the no-god-module bound (the aurora→useAurora /
- * goo-blob→useMetaballRenderer / fourier-field→useFourierField colocation pattern).
- * The orchestrator stays the morph DRIVER (it owns the `SpringProgress`, the targets
- * Set, the per-frame `--dock-morph-t` write); these are the PURE geometry + the
- * reserved-footprint measure + the SYNCHRONOUS PRM seat it composes. `DOCK_SPRING` is
- * byte-fenced — it lives in `../constants`, never touched here.
- *
- * The functions take their element/axis/target dependencies as explicit params (the
- * orchestrator's closures collapse onto this seam) — no module-level state, so the
- * extraction is behaviour-identical to the prior inline closures.
- */
-/** The minimal morph-target shape the measure/seat helpers read (the orchestrator's
- *  full `MorphTarget` structurally satisfies it). */
-export interface MorphMeasureTarget {
-    containerEl: Ref<HTMLElement | null>;
-    axis: Ref<"horizontal" | "vertical">;
-    /** PER-TARGET swap generation — the seat gates its pipeline on its own id. */
-    txId: number;
-}
-export declare function dimOf(axis: "horizontal" | "vertical"): "width" | "height";
-export declare function morphAxisProp(axis: "horizontal" | "vertical"): "inline-size" | "block-size";
-export declare function getSize(el: HTMLElement, axis: "horizontal" | "vertical"): number;
-export declare function clearMorphVars(el: HTMLElement): void;
-/**
- * BC.W-LIQUID-MORPH (M3) — the reserve-floor in px (the measure-failure floor). The
- * CSS reserve floors the box at `max(var(--dock-morph-to), var(--dock-morph-min))`
- * (layers.css), but the SCALAR ratio still runs toward `--dock-morph-to`, so a
- * `to:0` mis-measure would interpolate toward a degenerate target. The orchestrator's
- * measure-failure guard seats the measured `to` at THIS px so the morph interpolates
- * toward a visible footprint, never 0 — "visible at the floor," never "white." Reads
- * the element's RESOLVED `--dock-morph-min` (density-scaled), falling back to the WCAG
- * ~44px touch floor when the token is unset / unresolvable. Pure read — no write.
- */
-export declare function morphMinFloorPx(el: HTMLElement | null): number;
-/**
- * BA-VJS-1 (valuejs-fold A-1) — the OTHER registered targets whose container is a
- * DOM DESCENDANT of `outerEl` (a nested `<DockLayerGroup>` stack inside the outer
- * `.dock-layers`). These are the pinned inner spans the outer measure must see at
- * their OWN intrinsic `max-content`, not their collapsed pin, or the outer
- * shrink-wraps to ~0.
- */
-export declare function nestedTargetsWithin(outer: MorphMeasureTarget, outerEl: HTMLElement, targets: Iterable<MorphMeasureTarget>): MorphMeasureTarget[];
-/**
- * BA-VJS-1 — force ONE nested target to its own-axis `max-content` (clearing its
- * reserved `--dock-morph-to` footprint so it sizes to content), and return a closure
- * that RESTORES its exact prior inline state. The restore re-writes the precise
- * prior `inline-size`/`block-size` inline value (or removes it if there was none),
- * so the inner's in-flight pin is byte-identical after the outer's measurement —
- * the inner target's own spring/pin pipeline is never disturbed.
- */
-export declare function forceNestedMaxContent(n: MorphMeasureTarget): () => void;
-/**
- * BB.W-DOCK-MORPH-FAMILY (c) — measure the true `to` for ONE target with the
- * morph axis forced to `max-content` (the same circular-measure escape the rAF
- * path uses), composing the BA-VJS-1 nested-descendant `max-content` ordering so
- * a nested group reads its TRUE intrinsic span (never `to:0`). The element is at
- * the live painted geometry on entry; this forces+reads+restores the axis. PURE
- * measure — no spring, no pin write.
- */
-export declare function measureTo(t: MorphMeasureTarget, el: HTMLElement, targets: Iterable<MorphMeasureTarget>): number;
-/** The orchestrator settle callbacks the synchronous seat composes (it clears the
- *  morph vars + nulls the leaving layer, then parks the root/spring once no target
- *  is morphing). */
-export interface MorphSeatCallbacks {
-    /** Settle ONE target (clear its morph vars + null its leavingLayer). */
-    settleTarget(t: MorphMeasureTarget): void;
-    /** Park the shared scalar + spring once NO target is morphing. */
-    maybeSettleRoot(): void;
-}
-/**
- * BB.W-DOCK-MORPH-FAMILY (c) — the SYNCHRONOUS PRM seat. Under
- * `prefers-reduced-motion: reduce` there is NO morph to play, so the geometry +
- * the scalar seat at the target in ONE step (the `useDockOrientationMorph.pin()`
- * precedent transplanted onto the collapse/expand path): measure the true `to`
- * (composing the BA-VJS-1 nested ordering), write the box at `to` (the
- * reserved-footprint reads at scale 1), and set `--dock-morph-t` to the endpoint
- * for THIS swap — then clear the morph state immediately (no rAF measure-defer,
- * no spring, no morph window). The box NEVER paints the collapsed `from` sliver
- * with the scalar at 1 (the P0 terminal failure). Endpoint is the per-swap
- * incoming-ness `1` (the new pane is fully in; the directional `--dock-expand-t`
- * resolves to the class endpoint with `[data-morphing]` cleared).
- */
-export declare function seatTargetSync(t: MorphMeasureTarget, id: number, root: HTMLElement | null, targets: Iterable<MorphMeasureTarget>, cb: MorphSeatCallbacks): void;
-/**
- * The swap-while-morphing sibling re-base. The shared scalar resets to 0 for the
- * new span; if SIBLING targets are mid-morph, re-base their `from` to their CURRENT
- * painted px first, so resetting the scalar keeps them visually continuous (they
- * interpolate fresh from where they are, toward their unchanged `to`) rather than
- * snapping back to their old `from`. PURE over the swapping target + the target set.
- */
-export declare function rebaseSiblingSpans(swapping: MorphMeasureTarget, targets: Iterable<MorphMeasureTarget>): void;
-/**
- * BC.W-DOCK-ROOT-MORPH — clear the ROOT box's own morph span (the `inline-size` =
- * f(scalar) recipe in layers.css reads `--dock-root-morph-from/to`; clearing them
- * hands the box back to the at-rest shrink-wrap once the morph settles). PURE on
- * the root element — no orchestrator closure.
- */
-export declare function clearRootMorphSpan(root: HTMLElement | null): void;
-/**
- * BC.W-DOCK-ROOT-MORPH — pin the ROOT box's own from→to span on the dock root.
- *
- * THE SNAP ROOT CAUSE: the inner `.dock-layers` reserves its SETTLED `to`
- * footprint (`inline-size: var(--dock-morph-to)`, layers.css — the E4-frozen
- * CDP-Layout-flat mechanism) and morphs VISUALLY via `transform: scaleX()`. A
- * `transform` is paint-only — a parent does NOT shrink-wrap to a scaled child —
- * so the root `.glass-dock` (display:inline-flex) shrink-wraps to the inner's
- * RESERVED full `to` width and SNAPS to full on frame 0, while the inner's scaled
- * box rides the spring smoothly. The gate (and the page) measure the ROOT box, so
- * the root must ALSO ramp. The layers.css recipe reads
- * `inline-size: calc(from + (to−from)·--dock-morph-t)` (the SAME scalar the spring
- * glides, NO CSS transition — proof:no-layout-animation stays GREEN; a `calc()`
- * over the registered `--dock-morph-t` is not a transition). PURE on the root.
- */
-export declare function armRootMorphSpan(root: HTMLElement | null, rootFrom: number, rootTo: number): void;
-/** The orchestrator callbacks the rAF measure-and-arm window composes — the arm
- *  step re-pins the per-target + root spans on the shared scalar. */
-export interface MorphMeasureArmCallbacks {
-    /** Arm the per-target `--dock-morph-from/to` span + ensure the shared spring. */
-    armTarget(t: MorphMeasureTarget, id: number, fromSize: number, toSize: number): void;
-}
-/**
- * BC.W-DOCK-ROOT-MORPH / BA-VJS-1 / BC.W-LIQUID-MORPH (M3) — the rAF measure-and-arm
- * window: ONE rAF (post-flush) later, lift the pin for a single synchronous
- * measurement of the now-correct shrink-wrapped to-size, then re-pin + start the
- * spring IN THE SAME FRAME. The measurement + arm are gated on THIS target's own
- * `txId`, so a sibling target swapping in the same tick does NOT clobber it.
- *
- * BA-VJS-1 — the nested-`DockLayerGroup` measure-ORDERING fix: force every OTHER
- * registered target whose container is a DOM descendant of this outer's container
- * to its own-axis `max-content` (clearing its pinned calc span) for the single
- * synchronous measurement, then RESTORE its exact prior inline state, so the outer
- * shrink-wraps around the inner's TRUE intrinsic content, not its pinned collapse.
- *
- * BC.W-DOCK-ROOT-MORPH — for the OUTER target, LIFT the root's own pinned span for
- * the duration of this synchronous measure (clearing `--dock-root-morph-from/to`,
- * which the layers.css recipe constrains the root by) so the root shrink-wraps to
- * its TRUE expanded width, read it DIRECTLY (sidestepping the chrome-offset
- * arithmetic + the empty-summary `inner-to:0` trap), then RESTORE the pin and
- * arm the root from→to span so its `inline-size` ramps on the SAME scalar.
- *
- * BC.W-LIQUID-MORPH (M3) — the measure-failure guard: a `to:0` mis-measure (a
- * mid-morph re-grab, a nested collapsible still pinned, a race the ordering fix
- * missed) seats the measured `to` at the resolved floor (`--dock-morph-min`,
- * density-scaled, WCAG ~44px fallback) so the morph interpolates toward a visible
- * footprint, never toward 0 — "visible at the floor," never "white." Inert on a
- * healthy measurement.
- *
- * PURE over its explicit deps (the orchestrator passes the live element/targets/
- * outer identity + the `armTarget` re-pin callback) — no module-level state, so the
- * extraction is behaviour-identical to the prior inline rAF closure.
- */
-export declare function measureAndArmMorph(t: MorphMeasureTarget, id: number, axis: "horizontal" | "vertical", fromSize: number, rootFromSize: number, isOuter: boolean, rootEl: HTMLElement | null, targets: Iterable<MorphMeasureTarget>, cb: MorphMeasureArmCallbacks): void;

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

@@ -1,13 +0,0 @@
-export { useDockState } from "./useDockState";
-export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./useDockState";
-export { useDockSearch } from "./useDockSearch";
-export type { UseDockSearchOptions, UseDockSearchReturn } from "./useDockSearch";
-export { useLayerTransition } from "./useLayerTransition";
-export type { UseLayerTransitionOptions, UseLayerTransitionReturn } from "./useLayerTransition";
-export { useDockHold } from "./useDockHold";
-export type { UseDockHoldOptions, UseDockHoldReturn } from "./useDockHold";
-export { isTeleportedTarget } from "./isTeleportedTarget";
-export { provideDockContext, useDockContext, useOptionalDockContext, DOCK_CONTEXT_KEY, type DockContext, type DockOrientation, } from "./dockContext";
-export { provideDockLayerGroupContext, useDockLayerGroupContext, useOptionalDockLayerGroupContext, DOCK_LAYER_GROUP_KEY, type DockLayerDescriptor, type DockLayerGroupContext, } from "./dockLayerContext";
-export { useDockMorphOrchestrator, provideDockMorphContext, useOptionalDockMorphContext, DOCK_MORPH_KEY, type DockMorphContext, type DockMorphGroupRegistration, type DockMorphGroupHandle, type UseDockMorphOrchestratorOptions, type UseDockMorphOrchestratorReturn, } from "./dockMorphContext";
-export { useDockOrientationMorph, type DockMorphOrientation, type UseDockOrientationMorphOptions, type UseDockOrientationMorphReturn, } from "./useDockOrientationMorph";

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