@mkbabb/glass-ui 6.0.0 → 7.0.0

package/dist/composables/glass/webgl/shaders/glass-refract.glsl.d.ts

@@ -1,36 +0,0 @@
-/**
- * The pinned chromatic-dispersion scale — ONE source-of-truth across BOTH refraction
- * stacks (this GLSL floor + the WGSL `glassShader.wgsl` twin). An ABSOLUTE rim-offset
- * multiplier: `|ca| = inward · rim · uChromatic · CHROMATIC_SCALE`. Pinned here so a
- * cross-stack drift (the 0.003/0.004/0.0045 three-way split the Tier-2 literal `0.004`
- * carried) is impossible — the shipped WGSL twin replaces its literal with this value.
- */
-export declare const CHROMATIC_SCALE = 0.0045;
-/** The uniform-name contract — the ONE spelling map the JS binder + the fence read. */
-export declare const GLASS_REFRACT_UNIFORMS: {
-    readonly resolution: "uResolution";
-    readonly time: "uTime";
-    readonly panelCount: "uPanelCount";
-    readonly bounds: "uBounds";
-    readonly lightPos: "uLightPos";
-    readonly blurRadius: "uBlurRadius";
-    readonly refractionStrength: "uRefractionStrength";
-    /** the fence operator — refraction=depth, hue=this absolute rim offset. */
-    readonly chromatic: "uChromatic";
-    readonly metalStrength: "uMetalStrength";
-    readonly valveKnee: "uValveKnee";
-    readonly plateAlphaMax: "uPlateAlphaMax";
-    readonly backdrop: "uBackdrop";
-};
-/** The maximum panel count the fragment loop unrolls (mirrors Tier-2 `MAX_PANELS`). */
-export declare const GLASS_REFRACT_MAX_PANELS = 8;
-/** The full-screen-triangle vertex pass (the substrate's standard fullscreen pass). */
-export declare const GLASS_REFRACT_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition * 0.5 + 0.5;   // [-1,1]\u00B2 clip \u2192 [0,1]\u00B2 UV\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
-/**
- * The Tier-1 WebGL2 refraction fragment source. Renders the FULL ship pass: squircle
- * depth-refraction → 3×3 blur → absolute-rim chromatic split → curl drapery sheen →
- * ridge-local plate-alpha valve → directional specular + Fresnel rim. Splices the
- * SHARED `CURL_FBM_GLSL` chunk (the drapery term); `potentialFBM` is defined below
- * the uniforms per the splice-order law (the host owns the noise basis).
- */
-export declare const GLASS_REFRACT_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_PANELS 8\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform vec2  uResolution;\nuniform float uTime;\nuniform int   uPanelCount;\nuniform vec4  uBounds[MAX_PANELS];   // per-panel rect: xy = origin (UV), zw = size (UV)\nuniform vec2  uLightPos;             // key-light position (UV)\nuniform float uBlurRadius;           // blur kernel px scale\nuniform float uRefractionStrength;   // the DEPTH knob (squircle displacement)\nuniform float uChromatic;            // the fence operator \u2014 the absolute rim hue split\nuniform float uMetalStrength;        // the drapery/metal sheen composite\nuniform float uValveKnee;            // the K12 plate valve knee (structLuma threshold)\nuniform float uPlateAlphaMax;        // the alpha the valve firms to over a bright ridge\nuniform sampler2D uBackdrop;         // the field render (bound by the keystone FBO pass)\n\n// The pinned cross-stack chromatic scale (ONE source-of-truth; see CHROMATIC_SCALE).\nconst float CHROMATIC_SCALE = 0.0045;\n\n// \u2500\u2500 the ONE backdrop-read wrapper (explicit LOD; the Tier-2 sampleBG discipline) \u2500\u2500\nvec3 sampleBG(vec2 uv) {\n  return textureLod(uBackdrop, clamp(uv, 0.0, 1.0), 0.0).rgb;\n}\n\n// 4th-order squircle bevel profile: f(x)=\u2074\u221A(1-(1-x)\u2074). 0 at centre, 1 at rim, the\n// edge-concentrated slope (Snell n=1.5 thin-interior lens, NOT a uniform radial).\nfloat squircleProfile(float x) {\n  float t = 1.0 - clamp(x, 0.0, 1.0);\n  float t4 = t * t * t * t;\n  return sqrt(sqrt(max(0.0, 1.0 - t4)));\n}\n\nfloat fresnel(float cosTheta, float ior) {\n  float r0 = pow((1.0 - ior) / (1.0 + ior), 2.0);\n  return r0 + (1.0 - r0) * pow(1.0 - cosTheta, 5.0);\n}\n\nfloat luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\n// scalar fbm potential \u2014 the host's noise basis, wrapped so curlFBM stays basis-\n// agnostic (the flow.glsl splice-order law). A cheap value-noise fbm for the sheen.\nfloat hash21(vec2 p) {\n  vec3 p3 = fract(vec3(p.xyx) * 0.1031);\n  p3 += dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\nfloat vnoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 w = f * f * (3.0 - 2.0 * f);\n  return mix(mix(hash21(i), hash21(i + vec2(1.0, 0.0)), w.x),\n             mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), w.x), w.y);\n}\nfloat potentialFBM(vec2 p) {\n  float v = 0.0, a = 0.5;\n  vec2 q = p;\n  for (int i = 0; i < 3; i++) { v += a * vnoise(q); q = q * 2.02 + vec2(1.7, 9.2); a *= 0.5; }\n  return v;\n}\n\n\nconst float CURL_EPS = 0.012;\n\n// Scalar fbm potential psi \u2014 the host's noise basis, wrapped so the curl operator is\n// basis-agnostic. A host carrying its own fbm defines this as: return fbm(p);\nfloat potentialFBM(vec2 p);\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nvec2 curlFBM(vec2 p) {\n  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));\n  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);\n  return vec2(g.y, -g.x);\n}\n\n\n// The glass material over one panel rect. Every sample flows through sampleBG.\nvec4 glassSample(vec2 uv, vec4 b) {\n  vec2 gmin = b.xy;\n  vec2 size = b.zw;\n  vec2 local = (uv - gmin) / size;      // 0..1 within panel\n  vec2 centered = local - vec2(0.5);    // -0.5..0.5\n\n  // REFRACTION = DEPTH: rim-concentrated squircle displacement (a pure UV offset).\n  float r = clamp(length(centered) * 2.0, 0.0, 1.0);\n  float prof = squircleProfile(r);\n  vec2 dir = normalize(centered + vec2(1e-5));\n  vec2 disp = dir * prof * (uRefractionStrength * 0.04 / 1.5);   // n=1.5\n  vec2 refrUv = uv + disp;\n\n  // the canonical edge-band rim mask (GLSL source-of-truth) \u2014 hue rides the RIM only.\n  vec2 toEdge = vec2(0.5) - abs(centered);       // 0 at the panel edge, 0.5 at centre\n  float edge = min(toEdge.x, toEdge.y);\n  float rim = 1.0 - smoothstep(0.0, 0.16, edge); // 1 at the rim band, 0 by 16% inward\n\n  vec2 px = 1.0 / uResolution;\n\n  // 3\u00D73 blur around the displaced UV (the demoted-blur read carrier) \u2014 explicit LOD.\n  vec3 col = vec3(0.0);\n  float wsum = 0.0;\n  for (int x = -1; x <= 1; x++) {\n    for (int y = -1; y <= 1; y++) {\n      vec2 o = vec2(float(x), float(y)) * px * max(uBlurRadius, 0.5);\n      float wgt = 1.0 - 0.25 * float(abs(x) + abs(y));\n      col += sampleBG(refrUv + o) * wgt;\n      wsum += wgt;\n    }\n  }\n  col /= wsum;\n\n  // HUE = ABSOLUTE rim offset: split R/B by ca = inward \u00B7 rim \u00B7 uChromatic \u00B7 CHROMATIC_SCALE.\n  vec2 inward = dir;\n  vec2 ca = inward * rim * uChromatic * CHROMATIC_SCALE;\n  float cr = sampleBG(refrUv + ca).r;\n  float cb = sampleBG(refrUv - ca).b;\n  col.r = mix(col.r, cr, rim * 0.6);\n  col.b = mix(col.b, cb, rim * 0.6);\n\n  // FULL PASS \u2014 the curl-drapery metal sheen (2nd curlFBM), gated by uMetalStrength.\n  vec2 flow = curlFBM(local * 3.0 + uTime * 0.05);\n  float sheen = potentialFBM(local * 5.0 + flow * 1.5 + uTime * 0.08);\n  col += vec3(smoothstep(0.55, 0.95, sheen) * uMetalStrength * 0.12);\n\n  // directional specular + Fresnel rim.\n  vec3 n = normalize(vec3(centered * 0.6, 1.0));\n  float spec = fresnel(max(n.z, 0.0), 1.5);\n  vec2 ldir = normalize(uLightPos - uv);\n  float ldot = max(dot(centered, ldir), 0.0);\n  col += vec3(spec * (0.3 + 0.7 * ldot) * 0.15);\n\n  // K12 ridge-local plate VALVE: firm the alpha toward uPlateAlphaMax over a BRIGHT\n  // ridge (AA legibility); the dim valley stays translucent so the metal reads.\n  float structLuma = luma(col);\n  float valve = smoothstep(uValveKnee, 1.0, structLuma);\n  float plateA = mix(0.9, uPlateAlphaMax, valve);\n\n  return vec4(col, plateA);\n}\n\nvoid main() {\n  vec2 uv = vUv;\n  vec3 color = sampleBG(uv);   // BASE: the field passes through unchanged.\n  float alpha = 1.0;\n\n  for (int i = 0; i < MAX_PANELS; i++) {\n    if (i >= uPanelCount) break;\n    vec4 b = uBounds[i];\n    vec2 gmin = b.xy;\n    vec2 gmax = b.xy + b.zw;\n    bool inside = uv.x >= gmin.x && uv.x <= gmax.x && uv.y >= gmin.y && uv.y <= gmax.y;\n    if (inside) {\n      vec4 s = glassSample(uv, b);\n      color = s.rgb;\n      alpha = s.a;\n    }\n  }\n\n  fragColor = vec4(color, alpha);\n}";

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

@@ -1,48 +0,0 @@
-import { type easeInQuad } from "@mkbabb/value.js";
-import { type Easing, type TimingFunction } from "@mkbabb/keyframes.js";
-/** A value.js easing callable `(t: number) => number` (the family's shape). */
-export type CurveFn = typeof easeInQuad;
-/** The kind of a `MOTION_CURVES` row — a spring `linear()` or a cubic-bezier. */
-export type MotionCurveKind = "spring" | "bezier";
-/**
- * One row of the CSS↔JS curve table. CANONICAL rows carry their own JS twin;
- * ALIAS rows resolve through a `canonical` target (no duplicated twin).
- */
-export interface MotionCurve {
-    /** The CSS token name, including the leading `--`. */
-    readonly token: `--${string}`;
-    /** `spring` (a solved `linear()` token) or `bezier` (a cubic-bezier token). */
-    readonly kind: MotionCurveKind;
-    /**
-     * The JS twin — a callable `Easing` (springs, via `springTimingFunction`) or a
-     * `TimingFunction` (`(t) => number`, beziers via `CSSCubicBezier`). For ALIAS
-     * rows this is the canonical row's twin (resolve-through, not a copy).
-     */
-    readonly js: Easing | TimingFunction;
-    /**
-     * For an ALIAS row: the canonical `--token` this resolves through. `undefined`
-     * on a canonical row.
-     */
-    readonly canonical?: `--${string}`;
-    /** The register doc (springs lift it from the shared preset table). */
-    readonly note: string;
-}
-/**
- * The CSS↔JS curve table, keyed by CSS token name. Covers EVERY `--ease-*` /
- * `--spring-*` token declared in `tokens.css §2` + `theme.css` (CURVE-TABLE-BOUND
- * gate §3.2). Spring rows carry a keyframes.js `Easing`; bezier rows a value.js
- * `TimingFunction`; alias rows resolve through their `canonical` target.
- *
- * @example
- *   import { MOTION_CURVES } from "@mkbabb/glass-ui/motion";
- *   const easing = MOTION_CURVES["--spring-snappy"].js; // the iOS-control twin
- *   new NumericAnimation(frames, { timingFunction: easing });
- */
-export declare const MOTION_CURVES: Readonly<Record<string, MotionCurve>>;
-/** The canonical (non-alias) curve rows, in declaration order. */
-export declare const MOTION_CURVES_CANONICAL: readonly MotionCurve[];
-/** Look up a curve's JS twin by CSS token name (throws on an unknown token). */
-export declare function motionCurve(token: string): MotionCurve;
-export { linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInSine, easeOutSine, easeInOutSine, easeInCirc, easeOutCirc, easeInOutCirc, easeInExpo, easeOutExpo, easeInOutExpo, easeInBounce, CSSCubicBezier, } from "@mkbabb/value.js";
-export { SPRING_PRESETS, springPreset } from "./springPresets";
-export type { SpringPresetRow, SpringPresetName } from "./springPresets";

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

@@ -1,79 +0,0 @@
-/** The golden ratio — the barbell body diameter is the golden-minor of the slot pitch. */
-export declare const PHI = 1.618033988749895;
-/** sin(π·p)^k — 0 at the ends, peak at the midpoint. The well shape. */
-export declare function bell(p: number, k: number): number;
-/**
- * The barbell body diameter `D = step/φ` (a round BLOB, not a plate — the
- * golden-minor of the slot pitch). Floors the step at 1 so a zero pitch never
- * collapses D to 0.
- */
-export declare function bodyDiameter(step: number): number;
-/** The inputs to a single barbell projection frame — all numeric, all pure. */
-export interface BarbellSpan {
-    /** The trailing slot center (px on the travel axis). */
-    A: number;
-    /** The leading slot center (px on the travel axis). */
-    B: number;
-    /** The `from` slot index. */
-    fromIdx: number;
-    /** The `to` slot index. */
-    toIdx: number;
-    /** The live interpolated `--goo-t` scalar (∈ [fromIdx, toIdx] in flight). */
-    gooT: number;
-    /** The resting slot pitch (px) — `D = step/φ` lands the body diameter. */
-    step: number;
-    /** The neck-gap fraction: how near the two bodies draw at the midpoint. */
-    neckGap: number;
-    /** The cartoon-weight lever (0..1; clamped here — 0 under PRM/auto). */
-    weight: number;
-}
-/** The projected barbell geometry the engine writes onto the three elements. */
-export interface BarbellGeometry {
-    /** The body diameter `D = step/φ`. */
-    D: number;
-    /** The trailing body center (bodyA). */
-    cA: number;
-    /** The leading body center (bodyB). */
-    cB: number;
-    /** The neck center (the midpoint of the two bodies). */
-    mid: number;
-    /** The on-axis neck span scale `gap/D` (spans the live centre-to-centre gap). */
-    neckSpanScale: number;
-    /** The cross-axis neck girth (wells → pinches, ~0 at the ends). */
-    neckGirth: number;
-    /** The on-axis body squash (the necking-taffy stretch). */
-    stretchOn: number;
-    /** The cross-axis body stretch (volume-preserving reciprocal). */
-    stretchCross: number;
-    /** The cross-axis lob arc (overlapping action — the merge LOBS, not slides). */
-    arc: number;
-}
-/**
- * Project the BARBELL for the in-flight scalar `gooT`. `p` is the NORMALIZED
- * progress over the WHOLE from→to travel (a multi-gap morph spans p∈[0,1] over
- * the full span, so the barbell necks across the BIG gap on the SAME slow flow
- * curve). Pure — no closure, no DOM, no state.
- *   sep(p)      = 1 − bell(p,1)·(1 − neckGap)   // 1 at the slots → neckGap at mid
- *   mid         = (A + B) / 2 ; half = (B − A)/2 · sep(p)
- *   cA = mid − half ; cB = mid + half           // bodies travel apart-then-together
- *   neckGirth(p)= bell(p,1.5)                     // wells, peaks mid, ~0 at the ends
- */
-export declare function projectBarbell(span: BarbellSpan): BarbellGeometry;
-/**
- * Compose a BODY transform on the travel axis: translate(center) → -50% → scale +
- * the on-axis squash-&-stretch reciprocal (volume-preserving). `el` is sized to the
- * body diameter D, so no scale-to-fit is needed; the squash is the `--stretch` taffy.
- * The `arc` lobs the body centre on the CROSS axis (overlapping action). Pure string.
- */
-export declare function composeBodyTransform(center: number, arc: number, stretchOn: number, stretchCross: number, vertical: boolean): string;
-/**
- * Compose the NECK transform: translate(mid) on-axis, scaleX(gap/D) on-axis so it
- * spans the live gap, scaleY(neckGirth) cross-axis so it WELLS then PINCHES (~0 at
- * the ends → the neck vanishes at rest, no ghost throat). Pure string.
- */
-export declare function composeNeckTransform(mid: number, neckSpanScale: number, neckGirth: number, vertical: boolean): string;
-/**
- * Compose the RESTING NECK transform — the neck pinched to ~0 at the coalesced
- * center (no ghost throat at rest). Pure string.
- */
-export declare function composeRestNeckTransform(center: number, vertical: boolean): string;

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

@@ -1,88 +0,0 @@
-/** The five motion VECTORS a signature selects (geometry/motion, never an app name). */
-export type MorphVector = "lateral" | "radial" | "inward" | "axial" | "directed";
-/**
- * The motion SIGNATURE — DATA, the only thing that distinguishes the morphs. `vector`
- * picks the geometry; `kRest`/`kPeak` are gap-FRACTIONS (not px) the threshold band
- * scales by; `neckHold` is how long the neck holds before it pinches; `maxStretch` the
- * LOW squish cap (the anti-taffy fence).
- */
-export interface MorphSignature {
-    vector: MorphVector;
-    /** The neck-gap fraction at REST (bodies apart) — the threshold band floor. */
-    kRest: number;
-    /** The neck-gap fraction at the PEAK (bodies near, the gooey waist) — the band ceiling. */
-    kPeak: number;
-    /** How long (0..1 of t) the neck HOLDS its girth before it pinches (the tense pop). */
-    neckHold: number;
-    /** The LOW on-axis squish cap (≤~1.14 — the loud register lives in NECK girth, not body taffy). */
-    maxStretch: number;
-}
-/**
- * The canonical, motion-named SIGNATURE map (DATA — the FLOOR). Every consumer reads a
- * `MorphSignatureName` row. NO app names, NO three code paths.
- */
-export declare const MORPH_SIGNATURES: {
-    /** carousel / deck / pager goo: two equal beads bud apart, a concave neck wells, the
-     *  filter merges them into one barbell with a thin pinched waist, then they coalesce. */
-    readonly lateralNeck: {
-        readonly vector: "lateral";
-        readonly kRest: 0.92;
-        readonly kPeak: 0.34;
-        readonly neckHold: 0.5;
-        readonly maxStretch: 1.12;
-    };
-    /** dock fission media: the now-playing anchor stays; flanking transport PEELS along
-     *  the cross axis with a long tapering neck tail. */
-    readonly lateralPeel: {
-        readonly vector: "lateral";
-        readonly kRest: 0.88;
-        readonly kPeak: 0.4;
-        readonly neckHold: 0.4;
-        readonly maxStretch: 1.08;
-    };
-    /** dock fission search: controls fly outward like a bloom; the neck NECKS LATE (the
-     *  tense radial pop), innermost-first — an outward ripple, not a simultaneous scatter. */
-    readonly radialBurst: {
-        readonly vector: "radial";
-        readonly kRest: 0.85;
-        readonly kPeak: 0.3;
-        readonly neckHold: 0.55;
-        readonly maxStretch: 1.08;
-    };
-    /** dock fission nav: the negative radial — N masses collapse INWARD to ONE; the bridge
-     *  runs backward; --stretch peaks at coalescence. */
-    readonly inwardMerge: {
-        readonly vector: "inward";
-        readonly kRest: 0.8;
-        readonly kPeak: 0.28;
-        readonly neckHold: 0.35;
-        readonly maxStretch: 1.1;
-    };
-    /** dock V↔H: column-mass + row-mass are two distributions in ONE topology-free field;
-     *  a gooey teardrop LOBS column→row through the midpoint (no crossfade dodge). */
-    readonly axialNeck: {
-        readonly vector: "axial";
-        readonly kRest: 0.9;
-        readonly kPeak: 0.36;
-        readonly neckHold: 0.5;
-        readonly maxStretch: 1.14;
-    };
-    /** dock collapse: the DEGENERATE 1-body field — a single mass squishes between two
-     *  footprints (no waist, Tier-C). The ratio-free convex blend. */
-    readonly collapse: {
-        readonly vector: "axial";
-        readonly kRest: 1;
-        readonly kPeak: 1;
-        readonly neckHold: 0;
-        readonly maxStretch: 1.14;
-    };
-    /** drag morph: a grabbed rect → drop rect, an optional directed neck. */
-    readonly directed: {
-        readonly vector: "directed";
-        readonly kRest: 0.9;
-        readonly kPeak: 0.42;
-        readonly neckHold: 0.45;
-        readonly maxStretch: 1.1;
-    };
-};
-export type MorphSignatureName = keyof typeof MORPH_SIGNATURES;

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