@mkbabb/glass-ui 4.0.1 → 4.2.0

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

@@ -0,0 +1,19 @@
+import { type ButtonHTMLAttributes, type HTMLAttributes } from "vue";
+import { type PopoverTriggerProps } from "reka-ui";
+type __VLS_Props = PopoverTriggerProps & {
+    type?: ButtonHTMLAttributes["type"];
+    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<{}>, {}, {}, {}, {}, 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/DockStack.vue.d.ts

@@ -0,0 +1,78 @@
+import { type Component } from "vue";
+import type { DockStackItem } from "./constants";
+/**
+ * <DockStack> — BC.W-DOCK-STACK-RAIL + BE.W-DOCK-RAIL-REALIZE. The ONE rail engine on
+ * the KEPT `.glass-dock-frame` non-clipping escape, with TWO render modes:
+ *
+ *   • `mode="stack"` (DEFAULT — the BC byte-identical path). The macOS Dock
+ *     hover-expand STACK: a `core` anchor glyph + N members that FAN OUT on hover/focus
+ *     beside the rail, each a clear `--glass-bg-floating` glass icon.
+ *
+ *   • `mode="facets"` (BE.W-DOCK-RAIL-REALIZE — the re-instated AZ context carousel).
+ *     The members render as a CONTEXT CAROUSEL — a flex strip of facet-CHIPS that fans
+ *     in the SAME gutter, each chip carrying its OWN `--glass-accent` hue (the
+ *     per-instance chromatic-rim axis), the active facet lit on the selected-as-glass
+ *     `--dock-control-active-bg` tier. Clicking a chip writes the consumer-owned
+ *     `v-model:selected`. This is a RENDER MODE, NOT a second component — there is no
+ *     `DockRail.vue`/`DockFacetRail.vue`; `<DockStack>` owns both modes.
+ *
+ * THE KEPT ESCAPE (both modes). It renders in `GlassDock`'s `#rail` slot, over the
+ * `.glass-dock-frame` shell — a `display:contents`-by-default wrapper that becomes a
+ * NON-clipping positioning context only on `data-has-rail`, so the rail extends BEYOND
+ * the dock edge into its own gutter WITHOUT touching the dock box (the box-INVIOLATE
+ * discipline — `deltaW = deltaH = 0`; the chips feed NO size into the dock's intrinsic
+ * box).
+ *
+ * 3 CONFIGURABLE, SCROLLABLE, N-STACK (both modes). `visibleCount` (default 3) members
+ * fan at rest; an >visibleCount set routes the fanned strip through `<FadingScroll>`
+ * (the one scroll-fade port) so the n-set 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. Focus opens
+ * immediately; blur/leave closes.
+ *
+ * ONE REGISTRY (R4 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/facet members — the fan-out contents. */
+    items: readonly DockStackItem[];
+    /**
+     * The render mode. `"stack"` (default) = the macOS hover-expand glyph fan (the BC
+     * byte-identical path). `"facets"` = the re-instated AZ context carousel of
+     * accent-tinted facet chips (each chip writes its own `--glass-accent` hue).
+     */
+    mode?: "stack" | "facets";
+    /** 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";
+    mode: "stack" | "facets";
+    visibleCount: number;
+    coreLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -1,5 +1,11 @@
 import { type DockProps } from "./composables/useDockShellProps";
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {};
+/** Imperative split/merge/toggle — re-measure pieces, then run the fission spring. */
+declare function split(): void;
+declare function merge(): void;
+declare function toggleSplit(): void;
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {
+    fissioned: boolean;
+}, __VLS_11: {};
 type __VLS_Slots = {} & {
     persistent?: (props: typeof __VLS_1) => any;
 } & {
@@ -7,7 +13,11 @@ type __VLS_Slots = {} & {
 } & {
     collapsed?: (props: typeof __VLS_5) => any;
 } & {
-    rail?: (props: typeof __VLS_7) => any;
+    search?: (props: typeof __VLS_7) => any;
+} & {
+    split?: (props: typeof __VLS_9) => any;
+} & {
+    rail?: (props: typeof __VLS_11) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<DockProps, {
     expanded: import("vue").Ref<boolean, boolean>;
@@ -18,7 +28,15 @@ declare const __VLS_base: import("vue").DefineComponent<DockProps, {
     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>;
+    split: typeof split;
+    merge: typeof merge;
+    toggleSplit: typeof toggleSplit;
+    fissioned: Readonly<import("vue").Ref<boolean, boolean>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:order": (from: number, to: number) => any;
+}, string, import("vue").PublicProps, Readonly<DockProps> & Readonly<{
+    "onUpdate:order"?: ((from: number, to: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -3,37 +3,24 @@ 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.
+ * transitions in the SAME group — ONE spring, ONE scalar (`--dock-morph-t`),
+ * 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.
+ * BD.W-DOCK-CORE (the size re-invent) — the orchestrator no longer MEASURES a
+ * per-swap `from/to` span. The visible size is a ratio-free convex blend of two
+ * endpoints measured ONCE per content change (`useDockExpandedSize` writes
+ * `--dock-expanded-px`/`--dock-collapsed-px`; layers.css blends them on
+ * `--dock-morph-t`). So this driver shrinks to its essence: on a layer swap it
+ * arms `[data-morphing]`, swaps the crossfade classes (the a11y-006 3-state
+ * hit-test contract, LOAD-BEARING — KEPT verbatim), and runs ONE `SpringProgress`
+ * gliding `--dock-morph-t` 0→1; on settle it clears the morph state. A re-toggle
+ * mid-flight re-bases the live solver onto a fresh spring CARRYING the prior
+ * velocity (the iOS interruptible-physics continuity).
  *
  * 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).
+ * carries no static value.js edge — never import `AnimationGroup` / `./engine`.
  *
- * The `DOCK_SPRING` tuning this orchestrator drives is the ONE authority shared with
- * `useLayerTransition` — it lives in `../constants` (the feature-dir constants home).
+ * `DOCK_SPRING` is byte-fenced — it lives in `../constants`.
  */
 export interface DockMorphGroupRegistration {
     /** The container element owning this group's grid-stacked panes. */
@@ -84,10 +71,9 @@ export interface UseDockMorphOrchestratorReturn {
     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.
+ * The ONE morph engine for a dock instance. Owns a single `SpringProgress` that
+ * glides the one `--dock-morph-t` scalar 0→1 on a layer swap; the size is a
+ * ratio-free blend of the measure-ONCE endpoints (layers.css). Crossfade classes
+ * (the 3-state a11y hit-test contract) swap on the swap; the spring is the clock.
  */
 export declare function useDockMorphOrchestrator(options: UseDockMorphOrchestratorOptions): UseDockMorphOrchestratorReturn;

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

@@ -1,75 +1,86 @@
-import type { Ref } from "vue";
+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.
+ * BD.W-DOCK-CORE (the width-seizure cure) — the dock morph SIZE measure.
  *
- * 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 BUG THIS RETIRES (the year-old seizure): the prior pipeline measured a
+ * per-swap `from/to` FLIP ratio and drove the visible size by
+ * `--dock-root-scale = max(ratio + (1−ratio)·t, 0.06)` — a FLOOR with NO CEILING.
+ * When the morph target measured small (a degenerate `to` racing the content
+ * layout), `ratio = from/max(to,1px)` ran to ~56 → `scaleX(56)` = a ~2451px
+ * detonation on collapse / an inversion at the spring overshoot peak. The
+ * `transform-origin: center` kept the centroid clean (`cxRange 0`), which is
+ * exactly why every prior judge measuring the centroid PASSED while the WIDTH
+ * detonated. The whole measure-and-arm FLIP machinery
+ * (`measureAndArmMorph`/`seatTargetSync`/`rebaseSiblingSpans`/
+ * `forceNestedMaxContent`/`nestedTargetsWithin`/`measureTo`/`armRootMorphSpan`/
+ * `clearRootMorphSpan`/`morphMinFloorPx`/the per-target generation gating) is
+ * DELETED — clean break, no legacy, no floor that masks a bad measurement.
+ *
+ * THE CURE — a ratio-FREE measure-ONCE convex blend. The dock measures its two
+ * KNOWN footprints ONCE per content change (a `ResizeObserver`, NOT a per-swap
+ * rAF race): `--dock-expanded-px` (the expanded content width, read behind the
+ * clip aperture) and `--dock-collapsed-px` (the collapsed summary box). The
+ * visible size is the convex blend `--dock-live = collapsed + (expanded −
+ * collapsed)·--dock-morph-t` and `--dock-size-scale = --dock-live / expanded`
+ * (layers.css). A convex blend of two POSITIVE endpoints can NEVER exceed the
+ * larger nor invert below the smaller — BOUNDED by construction, no ratio, no
+ * `scaleX` explosion, regardless of spring overshoot (the `clamp(0,t,1)` caps the
+ * size term; the >1 excursion routes to the orthogonal punch channel).
+ *
+ * THE FRESHNESS GUARD (challenge 3·R2): a measure-ONCE endpoint can still be read
+ * stale — before `fonts.ready`, before async icon SVGs lay out, on a
+ * `display:none`→0 route swap, or on a `content-visibility:auto` parent (the RO
+ * fires 0). A 0 expanded would give `collapsed/0 = ∞`. So FLOOR `--dock-expanded-px`
+ * at `max(measured, --dock-collapsed-px)` and re-measure on `fonts.ready` + the
+ * FIRST non-zero RO callback + visibility-enter. This is NOT the deleted magic
+ * floor (which masked a per-frame measurement); it is a one-shot endpoint
+ * sanity bound on a value that is otherwise stable across the whole morph.
+ *
+ * `DOCK_SPRING` is byte-fenced — it lives in `../constants`, never touched here.
  */
-/** 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;
-/**
- * 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;
+export interface UseDockExpandedSizeOptions {
+    /** The `.glass-dock` root the `--dock-expanded-px`/`--dock-collapsed-px` write to. */
+    rootEl: Ref<HTMLElement | null>;
+    /**
+     * The content element whose intrinsic morph-axis span is observed for size
+     * changes (the active full-pane container — `.dock-layers`). Its resizes are the
+     * RO trigger; the ENDPOINTS are read off the ROOT box (content + chrome), keyed
+     * by the dock's at-rest expanded/collapsed state.
+     */
+    contentEl: Ref<HTMLElement | null>;
+    /**
+     * The morph axis (a horizontal dock blends width; a vertical dock blends height).
+     */
+    axis: Ref<"horizontal" | "vertical">;
+    /**
+     * Whether the dock is currently in its EXPANDED visual state (a `Ref<boolean>`).
+     * The endpoint captured at rest is keyed off this: at rest expanded → the root
+     * box is the `--dock-expanded-px` endpoint; at rest collapsed → the
+     * `--dock-collapsed-px` endpoint. (A reactive read, so a state flip re-captures.)
+     */
+    expanded: Ref<boolean>;
 }
 /**
- * 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).
+ * BD.W-DOCK-CORE — capture the two convex-blend endpoints ONCE PER STATE off the
+ * ROOT box.
+ *
+ * The visible morph scales the ROOT (chrome + content), so the two blend endpoints
+ * must be the ROOT's OWN expanded/collapsed footprints — NOT the bare content span
+ * (which omits the padding/min-width chrome). The endpoints are captured at REST
+ * (when `[data-morphing]` is OFF): the dock's settled root box in its current
+ * expanded/collapsed state IS that state's endpoint. A `ResizeObserver` on the
+ * content re-captures the CURRENT state's endpoint whenever the content reflows
+ * (more controls, a font swap), so the blend stays fresh — but it never reads the
+ * box MID-MORPH (the scaled box would feed back a degenerate endpoint, the seizure's
+ * cousin). The expanded endpoint is FLOORED at `max(captured, collapsed)` — the
+ * freshness guard against a 0/degenerate read giving `collapsed/0 = ∞`.
+ *
+ * The collapsed endpoint starts at the resolved `--dock-morph-min` icon-square floor
+ * and is refined to the real collapsed root box the first time the dock rests
+ * collapsed; the expanded endpoint is captured the first (and every) time it rests
+ * expanded. So the FIRST morph from a freshly-mounted expanded dock already has a
+ * real expanded endpoint + a sane collapsed floor — bounded by construction.
  */
-export declare function seatTargetSync(t: MorphMeasureTarget, id: number, root: HTMLElement | null, targets: Iterable<MorphMeasureTarget>, cb: MorphSeatCallbacks): void;
+export declare function useDockExpandedSize(options: UseDockExpandedSizeOptions): void;

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

@@ -1,5 +1,7 @@
 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";
@@ -9,3 +11,4 @@ export { provideDockContext, useDockContext, useOptionalDockContext, DOCK_CONTEX
 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";
+export { useDockFission, DOCK_SPLIT_SIGNATURES, type DockSplitContext, type DockSplitVector, type DockSplitSquishPeak, type DockSplitSignature, type DockFissionPieceRegistration, type DockFissionPieceHandle, type UseDockFissionOptions, type UseDockFissionReturn, } from "./useDockFission";

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

@@ -0,0 +1,45 @@
+/** 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/useDockContextSilhouette.d.ts

@@ -0,0 +1,192 @@
+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[];
+};