@mkbabb/glass-ui 6.0.0 → 8.0.0

package/dist/composables/motion/springPresets.d.ts

@@ -1,45 +0,0 @@
-/** A glass-ui named-spring preset name. */
-export type SpringPresetName = "smooth" | "snappy" | "bouncy" | "gentle" | "dock" | "press" | "transient" | "eyeglass";
-/** One named-spring row: the analytic (response, dampingFraction) pair + its register doc. */
-export interface SpringPresetRow {
-    /** The token suffix — `--spring-<name>` (CSS) and the `MOTION_CURVES` key. */
-    readonly name: SpringPresetName;
-    /** Response time in seconds (the spring's `response` solver input). */
-    readonly response: number;
-    /** Damping fraction ζ (1 = critical; <1 overshoots). */
-    readonly dampingFraction: number;
-    /** The register this curve serves (the doc-table derives from this one string). */
-    readonly comment: string;
-}
-/**
- * iOS-canonical (response, dampingFraction) pairs. The names match the `--spring-*`
- * CSS tokens AND the CSS consumers that read `var(--spring-smooth)` etc. directly, so
- * they MUST stay stable across retunes — only the `(response, ζ)` pair and the emitted
- * curves change. Each row's `comment` describes the register it serves (the doc-table
- * on /motion/springs derives from that one string):
- *
- *   SETTLE  → smooth  — patient entrances, fades, scale-ins (no overshoot read).
- *   CONTROL → snappy  — crisp position morphs: tab underline glide, progress fill,
- *                       the continuous-marker pop, the generic crisp settle.
- *   PLAYFUL → bouncy  — deliberate emphatic one-shots ONLY: the bouncy toggle press,
- *                       dialog/success entrances. Largest overshoot.
- *   GENTLE  → gentle  — critically-damped slow settles (the patient end of the ladder).
- *   DOCK    → dock    — the dock expand/collapse morph AND everything inside it.
- *   PRESS   → press   — the iOS interactive tap-press: a sub-200ms answer, a tiny alive
- *                       rebound.
- *   TRANSIENT → transient — the center-seed materialize bloom (Toast + Notification):
- *                       a deep scale-from with a near-critically-damped settle (no flick).
- *   EYEGLASS → eyeglass — the iOS tab-pill loupe travel: snappy speed with dock-class give.
- *
- * The whole table sits at the iOS weighty-inertial pole: longer `response` (weight) +
- * through-body damping toward critically-damped-with-a-touch-of-overshoot, while keeping
- * the perceptual arrival audacious. The invariant fences:
- *   · every overshoot ∈ [0%,10%] — the "touch of overshoot" band (>10% reads too springy).
- *   · every non-gentle settle is at least as long as the calm baseline (the inertia floor);
- *     nothing gets faster (faster = the mechanical-snap defect).
- *   · t90 ∈ [50%,61%] of clock for smooth/snappy/press (the audacious-arrival floor).
- *   · gentle ζ stays EXACTLY 1.0 (the --ease-convergence alias depends on overshoot==0).
- */
-export declare const SPRING_PRESETS: readonly SpringPresetRow[];
-/** Lookup one preset row by name (used by `MOTION_CURVES` spring rows). */
-export declare function springPreset(name: SpringPresetName): SpringPresetRow;

package/dist/composables/motion/suite.d.ts

@@ -1,2 +0,0 @@
-export { NumericAnimation, SpringProgress, SmoothProgress, Oscillator, Sequence, Timeline, ManualTimeline, RAFPlayback, KeyframesScrollTimeline, createNativeTimeline, flip, flipShared, ElementMorph, drag, drag2D, Draggable, decay, decayRest, reseatToSpring, probeVelocity, reducedMotionScale, waveformValue, warmEngine, stagger, springTimingFunction, springLinearStops, toEasing, resolveEasing, AnimationOptionError, UnknownEasingError, loadAnimationEngine, } from "@mkbabb/keyframes.js";
-export type { Easing, TimingFunction, TimingFunctionNames, SpringProgressOptions, SpringFrameCallback, SpringSubscriber, SpringLinearStopsOptions, SpringTimingFunctionOptions, SmoothProgressOptions, NumericAnimationOptions, NumericFrameCallback, SequenceEntry, SequenceOptions, SequencePosition, TimelineOptions, NativeTimelineSpec, RAFPlaybackOptions, Tickable, FlipOptions, ElementMorphOptions, MorphRect, DragOptions, DragAxis, DragSubscriber, DecayOptions, DecaySample, StaggerFn, StaggerOptions, StaggerOrigin, AnimationEngine, AnimationOptions, AnimationFrame, InputAnimationOptions, ResolvedKeyframes, Vars, } from "@mkbabb/keyframes.js";

package/dist/composables/motion/useBloomUp.d.ts

@@ -1,97 +0,0 @@
-import { type Ref } from "vue";
-import { type SpringPresetName } from "./springPresets";
-/** The bloom spring register — `snappy` (the quick shared-element default) or `bouncy`
- *  (the emphatic large-surface bloom). A subset of the named `SPRING_PRESETS` rows,
- *  matching `useLiquidReveal`/`useDockCtaReceive` so the bloom family reads as ONE. */
-export type BloomUpPreset = Extract<SpringPresetName, "snappy" | "bouncy">;
-export interface UseBloomUpOptions {
-    /** The spring register (default `snappy`). */
-    preset?: BloomUpPreset;
-    /** The starting filter-blur radius in px on the destination (the decongest start). Default 4. */
-    blur?: number;
-    /**
-     * The dominant source hue the FIELD warms toward — a complete `<color>` (an
-     * `oklch()`/`#hex`/named). When omitted, the leaf reads `--glass-ambient-hue` off
-     * the SOURCE element's computed style (the BE.W-AMBIENT-TINT convergence — the
-     * album card carries its own dominant hue). A `transparent`/empty read is the
-     * neutral no-op (the field tints nothing — a gray source warms nothing).
-     */
-    fieldHue?: string;
-    /**
-     * The FIELD CONTAINER the 4th color channel writes onto — the destination's
-     * ancestor field (the DockStage / now-playing field). When omitted, the leaf walks
-     * up from `destRef` to the nearest ancestor carrying `[data-glass-field]` (the
-     * field-marker contract), falling back to `destRef.parentElement`. The hue + the
-     * ramped strength are written HERE, never on the blooming surface (the
-     * compositor-only floor de-risk).
-     */
-    field?: Ref<HTMLElement | null>;
-    /**
-     * The bounded ambient-strength target the field ramps to (a percentage, `0..8`).
-     * Default 8 (the AMBIENT-TINT ceiling — the loudest sub-perceptual warm). Clamped
-     * to `[0, 8]` so a consumer can never flood the field past the warm-cream identity.
-     */
-    fieldStrength?: number;
-    /** Honor `prefers-reduced-motion: reduce` (snap surface to settled, land hue instantly). Default true. */
-    respectReducedMotion?: boolean;
-    /**
-     * Auto-prime the destination the moment it mounts — seat it at the collapsed/hidden
-     * initial state (opacity 0 + the source-FLIP transform) BEFORE the browser paints,
-     * so a freshly-`v-if`-mounted dest never flashes its full-size frame before `bloom()`
-     * fires. A `watch(dest, …, { flush: "pre" })` runs in the SAME tick the element
-     * mounts. Default `true` — the no-flash floor; pass `false` to opt a consumer that
-     * owns its own initial-state seating out. `prime()` is the explicit imperative twin.
-     */
-    autoPrime?: boolean;
-    /**
-     * Fired ONCE when the bloom has settled (the hand-off — the consumer marks the
-     * bloom complete: hides the source, owns the destination). Fires on the animation
-     * settle AND on the PRM/no-rAF snap (the bloom always completes).
-     */
-    onBloomed?: () => void;
-}
-export interface UseBloomUpReturn {
-    /**
-     * Bloom the destination up from the source's rect. Idempotent per call — measures
-     * the source + destination rects fresh, drives the FLIP inversion spring 1→0 on the
-     * surface AND ramps the field hue 0→target. A no-op if the destination element is
-     * not yet mounted (no `onBloomed`).
-     */
-    bloom: () => void;
-    /**
-     * Clear the bloom transform (restore the destination to its settled identity,
-     * opacity 1) AND release the field hue (strength → 0). The abort/reset seam —
-     * cancels any in-flight bloom; does NOT fire `onBloomed`.
-     */
-    reset: () => void;
-    /**
-     * Seat the destination at its collapsed/hidden initial state (opacity 0 + the
-     * source-FLIP transform) WITHOUT animating — so a freshly-mounted dest shows
-     * NOTHING until `bloom()` fires (the no-mount-flash seam). Idempotent; a no-op if
-     * the dest is not yet mounted. The auto-prime (`autoPrime`, default on) calls this
-     * for the consumer; `prime()` is the explicit imperative twin.
-     */
-    prime: () => void;
-    /** The reactive bloom state — `true` while a bloom is in flight, `false` at rest. */
-    blooming: Readonly<Ref<boolean>>;
-}
-/**
- * The iOS-27 shared-element bloom with the 4th color channel. Composes the kf
- * `ElementMorph` + `springTimingFunction` into the three-channel geometry bloom on the
- * DESTINATION surface (scale+fade+blur-decongest from the SOURCE's origin) PLUS a 4th
- * color channel on the destination FIELD (the field warms to the source's hue on the
- * SAME spring curve). Compositor-only on the surface + Safari-safe + PRM-snap. See the
- * module header for the REUSE + the FLIP inversion + the channel split.
- *
- * @example
- * ```ts
- * const { bloom, reset, blooming } = useBloomUp(albumCardRef, fullscreenRef, {
- *   preset: "bouncy",
- *   fieldHue: albumDominantHue, // or omit to read --glass-ambient-hue off the card
- *   field: nowPlayingFieldRef,
- *   onBloomed: () => (fullscreenOpen.value = true),
- * })
- * function onTapAlbum() { bloom() }
- * ```
- */
-export declare function useBloomUp(source: Ref<HTMLElement | null>, dest: Ref<HTMLElement | null>, options?: UseBloomUpOptions): UseBloomUpReturn;

package/dist/composables/motion/useCharStagger.d.ts

@@ -1,44 +0,0 @@
-import type { MaybeRefOrGetter, Ref } from "vue";
-/** The per-step delay floor matches the shipped `.char-stagger` recipe — the
- *  glyph spans are mounted via `requestAnimationFrame`-free DOM writes; the CSS
- *  owns the timing. No magic timing lives here. */
-export interface UseCharStaggerOptions {
-    /**
-     * Split unit. `"char"` (default) splits per UTF-16 code-unit-safe scalar;
-     * `"word"` splits on whitespace and keeps each word as ONE `.char` unit;
-     * `"grapheme"` uses `Intl.Segmenter` so emoji / combining-mark / ZWJ
-     * sequences (a 👨‍👩‍👧 family) are ONE glyph, never split into pieces.
-     */
-    by?: "char" | "word" | "grapheme";
-    /**
-     * Preserve whitespace as non-animating spacer spans so the word spacing
-     * survives the `inline-block` split. Default `true`.
-     */
-    preserveWhitespace?: boolean;
-    /**
-     * Write `--char-total` (the glyph count) on the wrapper, for a length-
-     * proportional / center-out / reverse stagger. Default `true`.
-     */
-    writeTotal?: boolean;
-}
-export interface UseCharStaggerReturn {
-    /** Re-run the split (after a `textContent` change). Idempotent — it restores
-     *  the original text from the cached label and re-mints, so spans never
-     *  accrete across re-splits. */
-    split: () => void;
-    /** The resolved glyph (`.char` unit) count. */
-    count: Ref<number>;
-}
-/**
- * Split a target element's text into per-glyph `.char` spans + the
- * `--char-index`/`--char-total` customs the shipped `.char-stagger` CSS reads —
- * accessible by construction (the wrapper keeps the full text as its
- * `aria-label`, every glyph span is `aria-hidden`).
- *
- * @example
- * const el = ref<HTMLElement | null>(null);
- * const { count } = useCharStagger(el, { by: "grapheme" });
- * // <span ref="el" class="char-stagger" aria-label="Fourier" style="--char-total:7">
- * //   <span class="char" style="--char-index:0" aria-hidden>F</span> …
- */
-export declare function useCharStagger(target: MaybeRefOrGetter<HTMLElement | null>, opts?: UseCharStaggerOptions): UseCharStaggerReturn;

package/dist/composables/motion/useCountup.d.ts

@@ -1,30 +0,0 @@
-import { type Ref } from "vue";
-/** The `useCountup` return shape. */
-export interface UseCountupReturn {
-    /** Animate the count-ups inside the currently-active slide/region. */
-    runActive: () => void;
-    /** Snap EVERY `[data-countup]` in the document to its end value (still capture). */
-    settle: () => void;
-    /** Cancel every in-flight tween (also runs on scope-dispose). */
-    cancel: () => void;
-}
-export interface UseCountupOptions {
-    /**
-     * Easing applied to tween progress — a value.js-FREE callable
-     * `(p: number) => number` over `[0, 1]`. A callable keeps the
-     * `NumericAnimation` engine off the value.js boundary (a string name would
-     * dynamic-import the value.js easing registry).
-     */
-    easeFn: (p: number) => number;
-    /** When it returns true, `runActive` is a no-op (e.g. export/print mode). */
-    skip?: () => boolean;
-}
-/**
- * Walk `[data-countup]` figures under `hostRef` and tween each from 0 → target.
- *
- * @example
- * const { runActive, settle } = useCountup(deckRef, { easeFn: (p) => p });
- * // on slide-activate: runActive();
- * // on still-capture:  settle();
- */
-export declare function useCountup(hostRef: Ref<HTMLElement | null>, opts: UseCountupOptions): UseCountupReturn;

package/dist/composables/motion/useElementMorph.d.ts

@@ -1,107 +0,0 @@
-import { type MorphRect } from "@mkbabb/keyframes.js";
-import { type ComponentPublicInstance, type Ref } from "vue";
-import { type SpringPresetName } from "./springPresets";
-/** A morph endpoint — a templateRef to an element/component, or the literal `"self"`
- *  (the morphed surface's OWN settled rect). */
-export type MorphEndpoint = Ref<HTMLElement | ComponentPublicInstance | null> | "self";
-/** The morph register — `snappy` (the quick app-open default) or `bouncy` (the emphatic
- *  large-surface bloom). A subset of the named `SPRING_PRESETS` rows shared by every
- *  bloom leaf so the family reads as ONE spring register. */
-export type ElementMorphPreset = Extract<SpringPresetName, "snappy" | "bouncy">;
-/** The declarative channel set the morph couples onto the spring clock. */
-export interface MorphChannels {
-    /** Fade the surface with the morph (opacity = 1 − morphProgress). Default `true`. */
-    opacity?: boolean;
-    /** The `filter: blur()` magnitude in px at the small `to` end (decongest/congest).
-     *  Default `0` (no blur channel). */
-    blur?: number;
-}
-export interface UseElementMorphOptions {
-    /** The `apply(el,0)` endpoint. Default `"self"` (the surface's own settled rect). */
-    from?: MorphEndpoint;
-    /** The `apply(el,1)` endpoint (the foreign trigger/source/dock-control). A null-
-     *  resolving ref degrades to a 92%-inset of the surface's own rect (the no-anchor
-     *  self-scale fallback — still spring-clocked, never a flat zoom). */
-    to?: MorphEndpoint;
-    /** `"in"` = FLIP inversion 1→0 (arrive at `from`); `"out"` = forward 0→1 (depart to
-     *  `to`). Default `"in"`. */
-    direction?: "in" | "out";
-    /** The coupled channels (opacity + blur). */
-    channels?: MorphChannels;
-    /** The spring register (default `snappy`). Sampled via `springPreset(name)`. */
-    preset?: ElementMorphPreset;
-    /** `transform-origin` resolution: anchor at `from`/`to` (relative to the surface),
-     *  `"center"`, or a raw CSS string. Default `"to"`. */
-    origin?: "from" | "to" | "center" | string;
-    /** Honor `prefers-reduced-motion: reduce` (snap to terminal, fade survives). Default `true`. */
-    respectReducedMotion?: boolean;
-    /** Fired ONCE at the terminal (animation settle AND the PRM/SSR snap) — the hand-off
-     *  seam (the cta seat clear + onReceived, the bloom field-land + onBloomed). */
-    onSettled?: () => void;
-    /** Fired each frame with the clamped [0,1] eased ARRIVAL progress — the extra-channel
-     *  hook (the bloom field-strength ramp). Not called on the PRM/SSR snap; `onSettled`
-     *  lands the terminal value there. */
-    onFrame?: (progress: number) => void;
-}
-export interface UseElementMorphReturn {
-    /** Measure `from`/`to` fresh + drive the morph. Interruptible — a mid-flight `play()`
-     *  re-measures + retargets (never restarts from the current computed value). */
-    play: () => void;
-    /** Cancel any in-flight morph + release the transition lock (does NOT clear styles
-     *  or fire `onSettled` — the abort seam). */
-    cancel: () => void;
-    /** Clear the inline morph styles (transform/origin/opacity/filter) — the reset seam. */
-    clear: (el?: HTMLElement | null) => void;
-    /** Statically seat the morph at a fixed [0,1] progress WITHOUT animating (the no-
-     *  mount-flash prime — transform only, no rAF, no lock). */
-    seat: (progress: number) => void;
-    /** `true` while a morph is in flight. */
-    playing: Readonly<Ref<boolean>>;
-    /** The live eased ARRIVAL progress (0 at play start → 1 at settle). */
-    progress: Readonly<Ref<number>>;
-    /** Geometry and engine horizon measured by this owner for the current play. */
-    measurement: Readonly<Ref<ElementMorphMeasurement | null>>;
-}
-export interface ElementMorphMeasurement {
-    readonly travelPx: number;
-    readonly scaleX: number;
-    readonly scaleY: number;
-    readonly durationMs: number;
-}
-/**
- * Resolve a templateRef value to its root HTMLElement — accepts an element directly OR a
- * Vue component public instance (its `.$el`). Returns null for a fragment/text root or a
- * nullish ref. THIS is the [[glass-ui binding verification]] cure: a `ref` bound to a
- * COMPONENT resolves to the component public INSTANCE (no `getBoundingClientRect`/
- * `setAttribute`), so the morph silently no-ops / throws. Every bloom leaf imports this
- * ONE resolver (the α binding-verification fix) — a surface/trigger binds either an
- * element ref or a component ref without dying.
- */
-export declare function asElement(v: HTMLElement | ComponentPublicInstance | null | undefined): HTMLElement | null;
-/** The 92%-inset self-scale fallback (a null-resolving anchor blooms from a small inset
- *  of the surface's own rect — never a flat zoom). */
-export declare function insetSelf(r: MorphRect): MorphRect;
-/**
- * The driver-lock seam — set inline `transition-property: none` on `el` (beating the F5.2
- * liquid-weight `transition` default + any Tailwind `transition*` utility) so the rAF
- * transform writes are not fought; the returned release restores the prior value.
- */
-export declare function lockSpatialTransition(el: HTMLElement): () => void;
-/** The live reduced-motion probe (matchMedia, SSR-safe) — exported so a wrapper that owns
- *  a NON-animated terminal seat (the cta "snap gone + hand off") shares the ONE probe. */
-export declare function prefersReducedMotion(): boolean;
-/**
- * The ONE compositor FLIP/morph runner. Composes the kf `ElementMorph` +
- * `springTimingFunction` into a single interruptible, PRM-safe, compositor-only morph the
- * three bloom leaves collapse onto. See the module header for the two directions + the
- * channel math + the PRM snap + the driver-lock seam.
- *
- * @example
- * ```ts
- * const engine = useElementMorph(surfaceRef, {
- *   to: triggerRef, direction: "in", channels: { opacity: true, blur: 4 },
- * })
- * watch(open, (o) => (o ? engine.play() : engine.cancel()))
- * ```
- */
-export declare function useElementMorph(surface: Ref<HTMLElement | ComponentPublicInstance | null>, options?: UseElementMorphOptions): UseElementMorphReturn;

package/dist/composables/motion/useGooMorph.d.ts

@@ -1,72 +0,0 @@
-import { type Ref } from "vue";
-/**
- * The three barbell silhouette elements the engine projects per frame. NOT
- * `morph.children[i]` index-reaching (the fragile KISS-violating path) — three EXPLICIT
- * refs the consumer renders + binds.
- */
-export interface GooBarbellRefs {
-    /** The trailing round body (the OUTGOING droplet). */
-    bodyARef: Ref<HTMLElement | null>;
-    /** The leading round body (the INCOMING droplet). */
-    bodyBRef: Ref<HTMLElement | null>;
-    /** The welling concave-throat neck between the two bodies. */
-    neckRef: Ref<HTMLElement | null>;
-}
-export interface UseGooMorphParams {
-    /**
-     * The barbell silhouette refs — two round bodies + a welling concave neck. The engine
-     * writes their three transforms each frame (the merge needs ≥2 masses; the neck is the
-     * bridge). NO single-element `morphRef` — the barbell IS the morph.
-     */
-    barbellRefs: GooBarbellRefs;
-    /** The geometry origin + the `--goo-t` transition host (the rail/track root). */
-    hostRef: Ref<HTMLElement | null>;
-    /** Travel axis. `false` → horizontal (translateX), `true` → vertical (translateY). */
-    vertical: Ref<boolean>;
-    /**
-     * Live center reader: the on-axis center (px, relative to the host content box)
-     * of slot `i`, on the travel axis. MEASURED off the live DOM (windowFit-correct,
-     * both axes) — never a hardcoded pitch.
-     */
-    centerOf: (i: number) => number | null;
-    /**
-     * The resting slot pitch (px) on the travel axis. The barbell body diameter is the
-     * golden-minor `D = restSize()/φ` (a BLOB, not a plate) — so the consumer passes the
-     * slot STEP, not a pre-shrunk body size.
-     */
-    restSize: () => number;
-    /**
-     * The token prefix for the flow/duration/max-stretch reads. Default `"pager-worm"`
-     * (the dot-pip register). The carousel passes `"carousel-goo"`; the deck `"deck-goo"`
-     * — each reads its OWN `--{prefix}-flow`/`-duration`/`-max-stretch` so a card-scale
-     * barbell dwells/swells at its own scale, the dot at its own. ONE engine, per-consumer
-     * tokens (the no-new-spring fence — they all resolve `--spring-*`-derived `linear()`).
-     */
-    tokenPrefix?: string;
-    /**
-     * The neck-gap fraction — how near the two bodies draw at the midpoint (sep's floor:
-     * 1 at the slots → `neckGap` at mid). Lower = the bodies near closer → a tighter,
-     * gooier waist. Default 0.78 (carousel). Pager 0.7, deck 0.85. (= `--{prefix}-neck-gap`
-     * if the consumer prefers a token; the param is the engine default.)
-     */
-    neckGap?: number;
-}
-export interface UseGooMorphReturn {
-    /**
-     * Travel the barbell from `from` to `to` (slot indices). Sets the `--goo-t`
-     * transition target (the spring glides it) and runs a short rAF that projects the
-     * interpolated scalar onto the three-element barbell each frame. PRM → instant snap to
-     * ONE resting body, no squish.
-     */
-    travel(from: number, to: number): void;
-    /** Snap the barbell to ONE resting body on `index` immediately (first paint / resize / PRM). */
-    snap(index: number): void;
-    /**
-     * Drag-driven continuous drive: set `--goo-t` DIRECTLY to a fractional slot position
-     * (the live drag scrollProgress, e.g. embla's `scrollProgress()*lastIndex`) with NO
-     * transition, and project the barbell for it. The neck wells with the live drag; call
-     * `travel()` on the snap to glide the release. PRM → snap.
-     */
-    drive(fractionalIndex: number): void;
-}
-export declare function useGooMorph(params: UseGooMorphParams): UseGooMorphReturn;

package/dist/composables/motion/useLeadTrail.d.ts

@@ -1,69 +0,0 @@
-import { type Ref } from "vue";
-export interface UseLeadTrailOptions {
-    /** The lead spring response (2π/response = the natural frequency). Default 0.68 (dock). */
-    response?: number;
-    /** The lead spring damping ratio ζ. Default 0.64 (dock; < 1 → the iOS overshoot). */
-    damping?: number;
-    /** The trailing follower time constant, seconds. Default 0.27 (≈270ms). */
-    trailTau?: number;
-    /** Honor `prefers-reduced-motion: reduce` → `drive` seats instantly. Default true. */
-    respectReducedMotion?: boolean;
-    /**
-     * The per-frame writer the consumer supplies (the DOM-write path, NO reactive
-     * thrash). Called each rAF tick with the live numeric edges — the consumer
-     * projects its silhouette (a barbell, an eyeglass) off `lo`/`hi`. Also called
-     * once on `seat` so a static mount paints correctly.
-     */
-    onFrame?: (edges: LeadTrailEdges) => void;
-}
-/** The two-edge state a single frame hands the consumer. */
-export interface LeadTrailEdges {
-    /** The lead edge (px) — springs toward the drive target. */
-    lead: number;
-    /** The trail edge (px) — lags then catches the lead. */
-    trail: number;
-    /** `min(lead, trail)` — the trailing silhouette edge (direction-agnostic). */
-    lo: number;
-    /** `max(lead, trail)` — the leading silhouette edge (direction-agnostic). */
-    hi: number;
-    /** True once the edges have re-formed on the target (the emergent release). */
-    settled: boolean;
-}
-export interface UseLeadTrail {
-    /** The live lead edge (updated per frame; the consumer usually reads `onFrame`). */
-    readonly lead: Readonly<Ref<number>>;
-    /** The live trail edge (updated per frame). */
-    readonly trail: Readonly<Ref<number>>;
-    /** True while the worm has re-formed on the target (the rAF is parked). */
-    readonly settled: Readonly<Ref<boolean>>;
-    /**
-     * Retarget the lead edge (px). The velocity carries — a retarget mid-flight
-     * re-seats the target, the spring continues from its LIVE `(position, velocity)`
-     * so interruption is free. Under PRM this SEATS instantly (zero in-between frames).
-     * The `drive(fractionalIndex→px)` seam W-CAROUSEL-REBUILD's drag-scrub feeds.
-     */
-    drive(target: number): void;
-    /** Snap BOTH edges to `value` instantly (mount / resize / PRM). Paints once. */
-    seat(value: number): void;
-    /** Tear down the rAF + the cached PRM listener (auto-run on scope dispose). */
-    dispose(): void;
-}
-/**
- * The two-edge lead/trail integrator — a spring LEAD + a damped TRAIL follower in
- * ONE rAF. The gap between the edges is the morph's live elongation; the trail
- * catching the lead is the emergent release. keyframes-FREE + vueuse-FREE. See the
- * module header for the pager-worm / eyeglass reconcile rationale.
- *
- * @example
- * ```ts
- * const worm = useLeadTrail({
- *   onFrame({ lo, hi }) {
- *     // project the barbell off the two edges (no getComputedStyle)
- *     paintBarbell(lo, hi)
- *   },
- * })
- * worm.seat(centerOf(active))   // mount
- * worm.drive(centerOf(next))    // hop — the lead springs, the trail lags then reels in
- * ```
- */
-export declare function useLeadTrail(options?: UseLeadTrailOptions): UseLeadTrail;

package/dist/composables/motion/useNumericTransition.d.ts

@@ -1,56 +0,0 @@
-import type { TimingFunction } from "@mkbabb/keyframes.js";
-import { type Ref } from "vue";
-export type SpringSnapshot<K extends string> = Record<K, number>;
-/**
- * The `useNumericTransition` return shape (AW.W15 — named `Use<Name>Return`).
- * The transition is driver-only: `start`/`stop` control playback, `progress`
- * (0..1) + `playing` are reactive read-outs.
- */
-export interface UseNumericTransitionReturn {
-    /** Play the transition from `from` → `to`; resolves at completion. */
-    start: () => Promise<void>;
-    /** Stop the in-flight transition. */
-    stop: () => void;
-    /** Reactive 0..1 progress derived from the first interpolated key. */
-    progress: Ref<number>;
-    /** Reactive true-while-playing flag. */
-    playing: Ref<boolean>;
-}
-export interface UseNumericTransitionOptions<K extends string> {
-    /** Named numeric endpoints to interpolate between. */
-    from: SpringSnapshot<K>;
-    to: SpringSnapshot<K>;
-    /** Playback duration in ms. */
-    duration: number;
-    /** Honor prefers-reduced-motion by snapping to the target. Default true. */
-    respectReducedMotion?: boolean;
-    /**
-     * keyframes.js timing function — an explicit callable `(t) => number`.
-     *
-     * AW.W27: this is a CALLABLE `TimingFunction`, NOT a string easing name.
-     * keyframes 4 removed string-name acceptance from `NumericAnimationOptions`
-     * (a name now resolves only through the ASYNC `resolveEasing`, which crosses
-     * the value.js dynamic boundary the dock/motion light surface must never
-     * pull in). Narrowing glass-ui's public option to a callable decouples it
-     * from keyframes' name-resolution churn. A consumer wanting a named curve
-     * passes the function directly (e.g. `(t) => 1 - Math.pow(1 - t, 3)` for
-     * easeOutCubic).
-     */
-    timingFunction?: TimingFunction;
-    /** Per-frame consumer. Receives the same zero-allocation record each tick. */
-    onFrame?: (values: SpringSnapshot<K>) => void;
-}
-/**
- * Drive a numeric transition between two snapshots — e.g. CSS variable
- * values, element transforms, or color channel tuples. Wraps keyframes.js's
- * `NumericAnimation`, which handles easing, binary-search segment lookup,
- * and zero-allocation playback.
- *
- * The caller owns how values map to the DOM: provide `onFrame` and write
- * the record into `element.style.setProperty`, a `ref`, or wherever. This
- * composable never touches the DOM directly — it's the orchestrator, not
- * the renderer.
- *
- * For physics-based motion (mass / stiffness / damping), use `useSpring`.
- */
-export declare function useNumericTransition<K extends string>(options: UseNumericTransitionOptions<K>): UseNumericTransitionReturn;

package/dist/composables/motion/usePrioritizedTask.d.ts

@@ -1,41 +0,0 @@
-export type TaskPriority = "user-blocking" | "user-visible" | "background";
-export interface PostTaskOptions {
-    /** Scheduling priority. Defaults to the platform default ('user-visible'). */
-    priority?: TaskPriority;
-    /** Abort the task before it runs (rejects the returned promise). */
-    signal?: AbortSignal;
-    /** Delay in ms before the task becomes eligible to run. */
-    delay?: number;
-}
-/**
- * Schedule `callback` at an explicit priority, resolving with its result.
- * Native `scheduler.postTask` when available; otherwise a `MessageChannel`
- * macrotask (honouring `delay` via `setTimeout`, and `signal` via a plain
- * `AbortSignal` check) that cannot order by priority but still runs off the
- * current task.
- *
- * @example
- *   await postTaskSafe(() => recomputeHistory(), { priority: "background" });
- */
-export declare function postTaskSafe<T>(callback: () => T, options?: PostTaskOptions): Promise<T>;
-export interface UsePrioritizedTaskReturn {
-    /**
-     * Schedule a unit of work. The controller's `signal` is merged in (its own
-     * `abort()` cancels every task it scheduled), and an explicit `options.signal`
-     * still applies on the fallback path.
-     */
-    postTask: <T>(callback: () => T, options?: PostTaskOptions) => Promise<T>;
-    /** Abort every task scheduled through this controller. */
-    abort: (reason?: unknown) => void;
-}
-/**
- * Composable wrapper over {@link postTaskSafe} that owns a `TaskController`
- * (when supported) so a single `abort()` cancels every task it scheduled — the
- * controller a consumer constructs once and tears down on unmount. When
- * `TaskController` is absent the controller is a no-op shell and per-task
- * `options.signal` is the only cancellation channel.
- *
- * Pure-native (no `vue` import) — owns no reactive state and no lifecycle, so it
- * has no cleanup obligation beyond the `abort()` the consumer calls itself.
- */
-export declare function usePrioritizedTask(priority?: TaskPriority): UsePrioritizedTaskReturn;

package/dist/composables/motion/useScrollPin.d.ts

@@ -1,49 +0,0 @@
-import { type MaybeRefOrGetter, type Ref } from "vue";
-import type { ComponentPublicInstance } from "vue";
-import type { ScrollSource } from "./scrollReader";
-export interface UseScrollPinOptions {
-    /**
-     * The tall `.scroll-pin` container (a templateRef to the element or a component). Its
-     * `getBoundingClientRect` gives the pin-slice ratio; `--pin-t` is written onto it (it
-     * `inherits: true` so the sticky stage + phase children read it).
-     */
-    container: MaybeRefOrGetter<HTMLElement | ComponentPublicInstance | null>;
-    /**
-     * The scroll source the pin tracks — the demo passes `main.demo-main-scroller`. Passed
-     * EXPLICITLY (the reader does not auto-discover). Default: the window/document.
-     */
-    source?: MaybeRefOrGetter<ScrollSource>;
-    /**
-     * The pin scrub ∈ [0, 1] — the pin drifts HEAVIER than a control (a scene, not a knob).
-     * Defaults to 1/φ² ≈ 0.382 (the golden heavier-drift rest). PRM → 0.
-     */
-    scrub?: number;
-    /** The spring damping ratio ζ for the felt reveal. < 1 overshoots. Default 0.85. */
-    dampingFraction?: number;
-    /** Honor `prefers-reduced-motion: reduce`. Default true. */
-    respectReducedMotion?: boolean;
-}
-export interface UseScrollPinReturn {
-    /** The spring-damped 0..1 pin progress (reactive — mirrors `--pin-t`). */
-    pinT: Readonly<Ref<number>>;
-    /** Force a re-read (post-resize). */
-    recalculate: () => void;
-    /** Detach. */
-    dispose: () => void;
-}
-/**
- * Drive `--pin-t` ∈ [0, 1] onto a sticky `.scroll-pin` stage off the real scroll port,
- * spring-damped so the pinned reveal arrives with inertia, overshoots, then settles. The
- * phase recipes (`.scroll-pin-phase-reveal` / `-settle`) read `--pin-t` — no
- * `animation-timeline`, every engine.
- *
- * @example
- * ```ts
- * const pinContainer = ref<HTMLElement | null>(null)
- * useScrollPin({
- *   container: pinContainer,
- *   source: () => document.querySelector<HTMLElement>("main.demo-main-scroller"),
- * })
- * ```
- */
-export declare function useScrollPin(options: UseScrollPinOptions): UseScrollPinReturn;