@mkbabb/glass-ui 7.0.0 → 9.0.0

package/dist/components/watercolor-dot/WatercolorDot.vue.d.ts

@@ -1,61 +0,0 @@
-/**
- * WatercolorDot — an organic pastel blob swatch. A CSS/SVG primitive (NO drawing
- * context — no WebGL/WebGPU/Canvas2D; the deliberate suite counterexample, the mark
- * that documents WHY it is not a GPU context): the blob shape is a deterministic
- * `border-radius` silhouette (seeded by `color + seed`), and the wet, bleeding
- * edge is an SVG turbulence + displacement filter that is INTERNALISED — the component
- * mounts its own namespaced `<filter>` so there is zero consumer plumbing. Mount the
- * dot and the filter just works.
- *
- * Safari-safe by construction (USER-DEFECTS §H): the SVG `<filter>` rasterizes ONCE
- * + caches (the HandMark `texture.ts` idiom) and NEVER re-rasterizes per frame; the
- * `animate` liveness rides a seeded COMPOSITOR `transform` wobble the compositor
- * accelerates without touching the filter graph (a per-frame `border-radius` paint
- * under the filter is the §H Safari flash, retired here). The filter `seed` is
- * per-instance off `hashString(color + seed)` so each dot's wet edge is uniquely
- * displaced (no twelve-clones).
- *
- * Color arrives as a CSS string painted straight onto the swatch background — the
- * dot needs no resolver because it does not feed a shader; the injected-color seam
- * shape is "pass the CSS color in". Warm-cream identity by default (the dot bakes no
- * hue; the demo palette is presets-in-consumers).
- */
-type __VLS_Props = {
-    /** CSS color painted as the swatch background (any CSS color form). */
-    color: string;
-    /**
-     * Render mode:
-     *   `solid` (default) — the filled organic blob (the swatch background IS the
-     *                       color; the existing register, unchanged).
-     *   `ghost`  — the SAME seeded blob SILHOUETTE traced as a DASHED outline: a
-     *              dashed CSS BORDER reading the SAME seeded `border-radius`
-     *              silhouette the solid dot fills (`borderRadius`), carrying
-     *              the SAME wet `feDisplacementMap` filter so the displacement
-     *              wobbles the dashed border INTO the seeded organic outline. A
-     *              CSS dashed border hugs its own `border-radius`, so the outline
-     *              follows the seeded blob EXACTLY — NOT an ellipse, NOT a circle,
-     *              NOT a dashed rectangle. A low-alpha `color` fill is kept behind
-     *              the border. A `ghost` of a given `color + seed` traces the SAME
-     *              outline the `solid` dot of that seed fills (both read the same
-     *              `useWatercolorBlob` silhouette — the ONE shape source). The empty-
-     *              palette-slot / placeholder affordance.
-     */
-    variant?: "solid" | "ghost";
-    /** Run the rAF-driven compositor transform wobble (default false → static). */
-    animate?: boolean;
-    /** Base morph cycle duration in ms (default 4000). */
-    cycleDuration?: number;
-    /** Border-radius range [lo, hi] as percentages (default [20, 80]). */
-    range?: [number, number];
-    /** Extra seed string mixed into the shape + wet-edge PRNG for uniqueness. */
-    seed?: string;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    animate: boolean;
-    range: [number, number];
-    seed: string;
-    variant: "solid" | "ghost";
-    cycleDuration: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/watercolor-dot/index.d.ts

@@ -1,3 +0,0 @@
-export { default as WatercolorDot } from "./WatercolorDot.vue";
-export { useWatercolorBlob, type UseWatercolorBlobOptions, type WatercolorBlob, } from "./useWatercolorBlob";
-export { mulberry32, hashString, randomRadii, radiiToCSS } from "./prng";

package/dist/components/watercolor-dot/prng.d.ts

@@ -1,5 +0,0 @@
-export { mulberry32, hashString } from "../../composables/glass/procedural/prng";
-/** Generate 8 random border-radius percentages in [lo, hi] using the given PRNG. */
-export declare function randomRadii(rng: () => number, lo: number, hi: number): number[];
-/** Serialise 8 radii into a CSS `border-radius` shorthand (4 corners / 4 corners). */
-export declare function radiiToCSS(r: number[]): string;

package/dist/components/watercolor-dot/useWatercolorBlob.d.ts

@@ -1,28 +0,0 @@
-import { type Ref } from "vue";
-export interface UseWatercolorBlobOptions {
-    /** Enable the rAF animation loop (drives a COMPOSITOR transform wobble). */
-    animate?: boolean;
-    /** Base cycle duration in ms (default 4000). */
-    cycleDuration?: number;
-    /** Border-radius range [lo, hi] as percentages (default [20, 80]). */
-    range?: [number, number];
-    /** Extra seed string mixed into the hash for unique shapes. */
-    seed?: string;
-}
-/**
- * Drives a watercolor dot's organic blob shape. Deterministic given `color + seed`
- * (seeds the PRNG), so the same color reproduces the same shape across mounts. The
- * seeded `border-radius` silhouette is set ONCE (the dot's identity) and is STATIC —
- * the box never re-paints its radius per frame (the §H Safari fix: a per-frame
- * `border-radius` write under the SVG filter forces the filter graph to RE-RASTERIZE
- * every frame, which flashes Safari). In `animate` mode the liveness rides a seeded
- * COMPOSITOR `transform` wobble (scale/skew/rotate) the compositor handles WITHOUT
- * touching the cached filter — the HandMark static-filter idiom. The wobble is driven
- * by the library's ONE `useRAFLoop` — parked when the tab is
- * hidden, frozen under `prefers-reduced-motion` — never a hand-rolled zombie rAF.
- */
-export declare function useWatercolorBlob(color: Ref<string> | (() => string), options?: UseWatercolorBlobOptions): {
-    borderRadius: Ref<string, string>;
-    transform: Ref<string, string>;
-};
-export type WatercolorBlob = ReturnType<typeof useWatercolorBlob>;

package/dist/composables/glass/ambientHueHistogram.d.ts

@@ -1,27 +0,0 @@
-/** A 12-bucket chroma×alpha-weighted OKLCh hue accumulator over the SAME pixel pass. */
-export interface HueHistogram {
-    /** chroma×alpha mass per hue bucket (the bucket weight). */
-    weight: Float64Array;
-    /** Σ chroma×alpha·cos(h) per bucket (for the circular-mean refine). */
-    sumCos: Float64Array;
-    /** Σ chroma×alpha·sin(h) per bucket. */
-    sumSin: Float64Array;
-    /** total chroma×alpha mass (the null-detection denominator numerator). */
-    totalMass: number;
-    /** total pixels accumulated (the null-mass denominator). */
-    n: number;
-}
-export declare function makeHueHistogram(): HueHistogram;
-/**
- * Bin ONE sRGB pixel (composited triple, already over-white) into the histogram,
- * weighted by its OKLCh chroma × the source alpha — a low-chroma/gray pixel
- * contributes ~0. The sRGB→OKLCh math is value.js's primitives (NOT hand-rolled).
- */
-export declare function accumulateHuePixel(h: HueHistogram, r: number, g: number, b: number, alpha: number): void;
-/**
- * Resolve the histogram → a complete `oklch()` ambient-hue string, or `transparent`
- * for a NULL (gray) sample. The modal bucket's chroma-weighted CIRCULAR MEAN is the
- * picked hue; it is emitted at the FIXED sub-perceptual chroma/L (a HUE event, never
- * the backdrop's saturation).
- */
-export declare function resolveAmbientHue(h: HueHistogram): string;

package/dist/composables/glass/useSpecularPointer.d.ts

@@ -1,52 +0,0 @@
-import { type ComputedRef, type CSSProperties, type MaybeRefOrGetter } from "vue";
-/**
- * `useSpecularPointer` — the EVOLUTION of `useSpecularTracking`. It
- * writes the catch-light POSITION (`--mouse-x`/`--mouse-y`, as today) PLUS the
- * `--specular-angle` channel — the pointer's angle-from-center the EDGE-glint conic
- * sweep reads (the `.glass-material::before` recipe, material.css). The angle feed is
- * what turns the centered disc into a motion-reactive RIM glint (the glass-THICKNESS
- * read); the leaf is the ONE shared specular source the hover/button waves consume.
- *
- * SINGLE-SOURCE (the reconcile, EXTENDED here — NOT a fork). There is
- * exactly ONE position-write core: `createSpecularWriter` (useSpecularTracking.ts) —
- * the rAF-coalesced, cached-PRM, scope-dispose seam. This composable WRAPS that core;
- * the angle is DERIVED in the sink from the SAME `(x, y)` percentage the core already
- * computes (`angle = atan2(y - 50, x - 50)`), so there is NO duplicate
- * `getBoundingClientRect`, `--mouse-x` write — the core owns the layout read + the
- * coordinate math, this leaf only adds the angle derivation onto the existing sink.
- * `useSpecularTracking` (the position-only delivery) STAYS for the bare-position call
- * sites; `useSpecularPointer` is the angle-adding delivery for an edge-glint consumer.
- * Both wrap the ONE core — never two copies of the rAF/PRM/coordinate logic.
- *
- * PRM-aware by construction (the wrapped core skips the write under
- * `prefers-reduced-motion: reduce` — the CSS bracket pins `--specular-x/y` to the
- * centred 50% and `--specular-angle` to its `0deg` static rest). The composable
- * disposes the core (cancel the pending rAF + drop the cached PRM listener) on scope
- * teardown.
- *
- * The optional press coupling.
- * A consumer may pass `press` (a 0..1 press scalar — a `useLiquidPress` `.value`, or
- * any press signal); it is folded reactively into the emitted style as the ONE
- * `--glass-btn-press-t` channel the `.glass-material::before` specular magnitude reads
- * (material.css). Reusing the SINGLE press channel (never a forked `--*-press-t`) keeps
- * ONE drive, two legs — the gleam SWELLS + SETTLES with the press spring. The merge is
- * a `computed` so the press tracks the spring INDEPENDENTLY of pointer moves (a press
- * settles while the pointer is still). SOFT-GATED: when `press` is OMITTED the emitted
- * style carries NO press channel (the CSS `--glass-btn-press-t` default 0 holds — no
- * hard press dependency), and the position/angle write is unchanged.
- */
-export interface UseSpecularPointerOptions {
-    /** Optional 0..1 press scalar (soft-gated) folded into `--glass-btn-press-t`. */
-    press?: MaybeRefOrGetter<number>;
-}
-export interface UseSpecularPointer {
-    /**
-     * Bind to the host element's `:style`. Carries `--mouse-x/--mouse-y` +
-     * `--specular-angle` (+ the press-coupled `--glass-btn-press-t` when `press` is
-     * supplied).
-     */
-    specularStyle: ComputedRef<CSSProperties>;
-    /** Bind to the host's `@pointermove`. Schedules the rAF-coalesced position+angle write (PRM-gated). */
-    onPointerMove: (event: PointerEvent) => void;
-}
-export declare function useSpecularPointer(options?: UseSpecularPointerOptions): UseSpecularPointer;

package/dist/composables/glass/wave/index.d.ts

@@ -1,4 +0,0 @@
-export type { Vec2, CellDriver } from "./waveField";
-export { travelingEnvelope, curlScalar, cellTwist, cellDriver, cellHeight, faceRelief, facePlateau, waveFlow, cursorSwirl, heightField, waveSwell, cellWarpBeforeHeight, } from "./waveField";
-export { WAVE_FIELD_GLSL } from "./waveField.glsl";
-export { WAVE_FIELD_WGSL } from "./waveField.wgsl";

package/dist/composables/glass/wave/waveField.d.ts

@@ -1,136 +0,0 @@
-/** A 2-vector. */
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-/**
- * The directed-twist magnitude FLOOR (the visibility cure — shared across JS↔GLSL↔WGSL).
- * The curl scalar alone sits ~|0.3|, damping the crest twist to a whisper; a cell in the
- * crest band always rotates at least this fraction of `twistMax` so the wave READS.
- */
-export declare const TWIST_FLOOR = 0.62;
-/**
- * A moving Gaussian crest band sweeping along `waveDir` at angular speed `waveOmega`.
- * Returns the envelope in [0,1]: ~0 where the wave has NOT reached, ~1 at the crest,
- * relaxing back to ~0 behind it. `coord` is the wave phase at a point; `crest` wraps it
- * to a single 0..1 cycle and `env` is the Gaussian about the cycle midpoint. The crest
- * "passes OVER and THROUGH" the field — the cells are calm ahead, twist HARD at the
- * crest, relax behind.
- */
-export declare function travelingEnvelope(pivot: Vec2, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number): number;
-/**
- * The curl-noise vorticity read at the cell center — a smooth low-frequency scalar in
- * roughly [-1,1] that DIRECTS the per-cell twist so adjacent cells lean TOGETHER (a
- * flowing read, never per-cell noise). The host supplies `curlFn(p) -> Vec2` (the shared
- * divergence-free curl of its own noise basis); this takes the x-component as the signed
- * director and folds a slow time drift so the flow itself evolves. Basis-agnostic.
- */
-export declare function curlScalar(curlFn: (p: Vec2) => Vec2, cc: Vec2, t: number): number;
-/** The cell pivot `cc` + the spring-eased crest envelope `env` a cell rides. */
-export interface CellDriver {
-    /** The PRE-twist cell center (the per-cell pivot the twist rotates about). */
-    cc: Vec2;
-    /** The traveling-Gaussian crest envelope × amp at that pivot ([0,1] · amp). */
-    env: number;
-}
-/**
- * The pre-twist driver for the grid coordinate `g`: floor `g` to its cell, return that cell's
- * center `cc` + the traveling-wave crest envelope `env` evaluated AT that center (= `cellHeight`,
- * so there is provably ONE envelope). FOLD A: the face must sample its height/relief at THIS
- * pre-twist `cc`, NOT at `floor(twisted_g)` (the crest twist crosses the cell boundary → the
- * face would light a NEIGHBOUR cell). `cellTwist` rides the SAME driver, so twist and face fuse.
- */
-export declare function cellDriver(g: Vec2, cellSize: number, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number, amp: number): CellDriver;
-/**
- * Twist the grid coordinate `g` about its OWN cell center, gated by the traveling wave
- * and directed by the curl flow. The pivot is the cell center (a per-cell constant) so the
- * box rotates about its middle — the cell stays in place but TWISTS (a windmill of warped
- * boxes where the crest passes; calm square cells elsewhere). `amp` is the spring-eased
- * envelope amplitude the JS host drives (the liquid-weight inertia). Returns the twisted
- * coordinate (still in grid space; the host evaluates its extraction at it).
- *
- * FOLD C — the `TWIST_FLOOR` is CREST-GATED: the floor is multiplied by the crest envelope so
- * OFF-crest cells relax to near-flat (calm paper) and only the crest band crinkles. Without
- * this every cell crinkles regardless of the wave (static foil, no traveling read).
- */
-export declare function cellTwist(curlFn: (p: Vec2) => Vec2, g: Vec2, cellSize: number, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number, twistMax: number, shearMax: number, amp: number): Vec2;
-/**
- * The sheet displacement at a cell center `cc` — the EXACT traveling-wave scalar the twist
- * rides (`travelingEnvelope · amp`), surfaced as a named leaf fn so the face reads ONE
- * envelope. Range [0,1]·amp: ~0 ahead of, behind the crest, ~amp at the crest. `cellTwist`
- * (via `cellDriver`) calls this, so a sign drift reds the numeric parity gate everywhere.
- */
-export declare function cellHeight(cc: Vec2, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number, amp: number): number;
-/**
- * The central-difference slope of `cellHeight` across a cell (`ε = 0.5·cellSize`) — the lit-fold
- * normal source. Pure, derivative-FREE (NO `dFdx` on the height) → Safari WebGL2-safe by
- * construction (only the Golus AA uses `fwidth`). Returns ∇H = (∂H/∂x, ∂H/∂y) at `cc`.
- */
-export declare function faceRelief(cc: Vec2, cellSize: number, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number, amp: number): Vec2;
-/**
- * Soft inset-square coverage inside a (warped) cell — the filled FACE plateau. `d` is the
- * distance into the cell from the nearest gutter (per axis, on the triangle-wave the Golus
- * grid already uses); `smoothstep(inset, inset+2·aa, d)` floors the face to a soft-edged tile
- * that retreats as `inset` grows (the squash). The shaders pass `aa = fwidth(g)` (crisp at any
- * DPR — the Golus precedent); the JS round-trip passes a fixed `uvDeriv` (reproducible).
- * Returns face coverage [0..1].
- */
-export declare function facePlateau(g: Vec2, inset: number, uvDeriv: Vec2): number;
-/**
- * A LOCAL Gaussian-gated rotation about the cursor — the finger twists the cells around
- * it (the re-aimed `cursorBulge`: a swirl, not a radial push). `strength` is the peak
- * twist angle at the cursor; `radius` the Gaussian falloff (grid units). Returns the
- * swirled coordinate.
- */
-export declare function cursorSwirl(g: Vec2, cursor: Vec2, strength: number, radius: number): Vec2;
-/**
- * The `waveFlow` second-flow FREQUENCY RATIO (shared across JS↔GLSL↔WGSL — the round-trip fence).
- * The secondary counter-flow term samples the curl at `warpFreq · this` so it drifts on a slightly
- * different spatial scale (the anti-loop variety) while staying the SAME order of magnitude as the
- * primary. `0.6 · 1.833333 ≈ 1.1` reproduces concentric's unit-scale pair; the GLSL/WGSL
- * transcriptions carry the identical literal.
- */
-export declare const WAVE_FLOW_SECOND_RATIO = 1.833333;
-/**
- * A CONTINUOUS divergence-free flow warp gated by the traveling wave — the SMOOTH twin of
- * `cellTwist` for surfaces that need an unbroken coordinate (the level-set contours shatter
- * into a mesh under the per-cell discontinuity; they need this continuous warp). The curl
- * flow direction is read at `g` itself (no per-cell pivot → no seam), its magnitude gated by
- * the SAME traveling Gaussian crest sweeping along `waveDir`. So the contours flow + twist as
- * the wave passes OVER and THROUGH them, with NO cell-boundary discontinuity. Returns the
- * warped coordinate.
- *
- * the LOCALLY-AFFINE frequency law. `warpFreq` is the HOST-supplied spatial
- * frequency (in the caller's OWN coordinate units) at which the curl-flow potential is sampled.
- * The caller passes a frequency an ORDER OF MAGNITUDE BELOW its own grid/contour frequency, so
- * the warp-displacement gradient is ~constant across any ONE cell (the warp Jacobian is locally
- * affine): the major gridlines bow as ONE smooth continuous curve across the frame, NEVER the
- * per-cell crackle a cell-scale sampling frequency produces. liquid-grid feeds a CELL-scale
- * coordinate (`uv · gridScale`, span ~14–40 cells) so it passes a tiny `warpFreq` (~0.03 →
- * wavelength of MANY cells); concentric feeds a UNIT-scale domain (`vUv`, span ~1) so it passes
- * the unit-scale `0.6`. The amplitude is UNCHANGED (the curl magnitude is the intrinsic q-space
- * gradient at the fixed `CURL_EPS`, independent of `warpFreq` — only the spatial frequency drops,
- * the bow amplitude `twistMax · env` is preserved). The `t·` drift coefficients are host-agnostic
- * (they set the flow's temporal evolution rate in q-space, independent of `warpFreq`).
- */
-export declare function waveFlow(curlFn: (p: Vec2) => Vec2, g: Vec2, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number, twistMax: number, amp: number, warpFreq?: number): Vec2;
-/**
- * A LOW-octave value-noise topography H(p) — the scalar field concentric extracts level-set
- * contours of. `octaves` LOW (3) keeps the nested loops CLEAN (not high-freq speckle — the
- * legibility floor). The host supplies its `noiseFn(x,y)` (the SAME value-noise basis its
- * `potentialFBM` uses, basis-agnostic). Returns the un-normalized height.
- */
-export declare function heightField(noiseFn: (x: number, y: number) => number, p: Vec2, octaves: number, seed: number): number;
-/**
- * The ω=√(g·k) breathing swell — a slow global rise/fall the topography rides so basins
- * inflate/deflate with weight (the deep-water dispersion the suite shares). A pure
- * f(t) the host adds onto H. `phase` lets a host offset its own swell.
- */
-export declare function waveSwell(t: number, phase: number): number;
-/**
- * The cell-warp applied BEFORE the height eval (concentric's `cellWarpBeforeHeight`). It
- * is the SAME `cellTwist` paper-grid runs — concentric warps the SAMPLING coordinate so
- * the contours twist/flow as the traveling wave crosses (kinship with paper-grid). A thin
- * alias for the gate's by-name assert + the host's call-site clarity.
- */
-export declare function cellWarpBeforeHeight(curlFn: (p: Vec2) => Vec2, g: Vec2, cellSize: number, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number, twistMax: number, shearMax: number, amp: number): Vec2;

package/dist/composables/glass/wave/waveField.glsl.d.ts

@@ -1 +0,0 @@
-export declare const WAVE_FIELD_GLSL = "\n#ifndef WAVE_FIELD_TAU\n#define WAVE_FIELD_TAU 6.283185307179586\n#endif\n\n// The traveling-wave envelope \u2014 a moving Gaussian crest band sweeping along waveDir.\nfloat travelingEnvelope(vec2 pivot, float t, vec2 waveDir, float waveK, float waveOmega, float waveSigma) {\n  float coord = dot(pivot, waveDir) * waveK - t * waveOmega;\n  float crest = fract(coord / WAVE_FIELD_TAU);\n  float z = (crest - 0.5) * 2.0;\n  return exp(-(z * z) / max(waveSigma, 1e-3));\n}\n\n// The curl-direction scalar \u2014 the smooth low-freq director the per-cell twist follows.\nfloat curlScalar(vec2 cc, float t) {\n  vec2 f = curlFBM(vec2(cc.x * 0.5 + t * 0.08, cc.y * 0.5 - t * 0.06));\n  return clamp(f.x, -1.0, 1.0);\n}\n\n// The directed-twist FLOOR (the visibility cure): keep the curl SIGN (adjacent cells lean\n// together) but floor the magnitude so a crest-band cell ALWAYS rotates decisively.\n#ifndef WAVE_FIELD_TWIST_FLOOR\n#define WAVE_FIELD_TWIST_FLOOR 0.62\n#endif\nfloat directedTwist(float s, float floorMag) {\n  float mag = max(floorMag, abs(s));\n  float sgn = tanh(s * 6.0);\n  return sgn * mag;\n}\n\n// \u2500\u2500 The FACE leaf (the structurally-absent RE-INVENT \u2014 height-lit filled cell interior) \u2500\u2500\n// Defined ABOVE cellTwist: cellTwist rides cellHeight via the driver so twist + face read ONE\n// envelope.\n\n// The sheet displacement at a cell center = the EXACT traveling-wave scalar the twist rides.\nfloat cellHeight(vec2 cc, float t, vec2 waveDir, float waveK, float waveOmega, float waveSigma, float amp) {\n  return travelingEnvelope(cc, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n}\n\n// The pre-twist driver (FOLD A): the cell pivot cc + the crest envelope env the twist AND the\n// face both ride. The face samples height/relief at THIS pre-twist cc (floor(twisted_g) at the\n// crest lights a neighbouring cell). cc is in .xy and env in .z.\nvec3 cellDriver(vec2 g, float cellSize, float t, vec2 waveDir, float waveK, float waveOmega,\n                float waveSigma, float amp) {\n  float cs = max(cellSize, 1e-3);\n  vec2 cc = (floor(g / cs) + 0.5) * cs;\n  float env = cellHeight(cc, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec3(cc, env);\n}\n\n// The central-difference slope of cellHeight across a cell (eps = 0.5\u00B7cellSize) \u2014 derivative-\n// FREE (NO dFdx on the height) \u2192 Safari WebGL2-safe. Returns \u2207H.\nvec2 faceRelief(vec2 cc, float cellSize, float t, vec2 waveDir, float waveK, float waveOmega,\n                float waveSigma, float amp) {\n  float eps = max(cellSize, 1e-3) * 0.5;\n  float hxp = cellHeight(cc + vec2(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  float hxm = cellHeight(cc - vec2(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  float hyp = cellHeight(cc + vec2(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  float hym = cellHeight(cc - vec2(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec2((hxp - hxm) / (2.0 * eps), (hyp - hym) / (2.0 * eps));\n}\n\n// Soft inset-square coverage inside a (warped) cell \u2014 the filled FACE plateau. d is the distance\n// into the cell from the nearest gutter (the Golus triangle-wave); the inset retreats as it grows\n// (the squash). aa = the shader's fwidth(g) (JS passes a fixed uvDeriv).\nfloat facePlateau(vec2 g, float inset, vec2 uvDeriv) {\n  vec2 tri = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  float d = min(tri.x, tri.y);\n  float aa = max(uvDeriv.x, uvDeriv.y) * 1.5;\n  return smoothstep(inset, inset + 2.0 * aa, d);\n}\n\n// The cell-local twist about each cell's own center, gated by the traveling wave + directed\n// by the curl flow. amp is the spring-eased envelope amplitude the JS host drives. FOLD C: the\n// TWIST_FLOOR is crest-gated by env so OFF-crest cells relax to flat calm paper (the traveling\n// read, not static foil).\nvec2 cellTwist(vec2 g, float cellSize, float t, vec2 waveDir, float waveK, float waveOmega,\n               float waveSigma, float twistMax, float shearMax, float amp) {\n  vec3 drv = cellDriver(g, cellSize, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  vec2 cc = drv.xy;\n  float env = drv.z;\n  float floorMag = WAVE_FIELD_TWIST_FLOOR * env;   // FOLD C: crest-gated floor\n  float theta = twistMax * env * directedTwist(curlScalar(cc, t), floorMag);\n  float shear = shearMax * env * directedTwist(curlScalar(cc + vec2(17.3, 9.1), t), floorMag);\n  vec2 local = g - cc;\n  float ct = cos(theta);\n  float st = sin(theta);\n  vec2 rot = vec2(ct * local.x - st * local.y, st * local.x + ct * local.y);\n  rot.x += shear * rot.y;   // a small skew so the box MORPHS, not just rotates\n  return cc + rot;\n}\n\n// The CONTINUOUS traveling-wave FLOW warp \u2014 the SMOOTH twin of cellTwist (no per-cell seam;\n// for the level-set contours that shatter into a mesh under the cell discontinuity).\n// warpFreq is the host-supplied curl-sampling spatial frequency (the caller's\n// own coordinate units): an order of magnitude BELOW its grid frequency so the warp is locally\n// affine (major lines bow as one smooth curve, no sub-cell crackle). LiquidGrid (cell-scale g0)\n// passes ~0.03; concentric (unit-scale p) passes 0.6. The 1.833333 second-flow ratio transcribes\n// WAVE_FLOW_SECOND_RATIO. Amplitude unchanged \u2014 curl magnitude is the intrinsic gradient at the\n// fixed CURL_EPS, independent of warpFreq; the t-drift is host-agnostic.\nvec2 waveFlow(vec2 g, float t, vec2 waveDir, float waveK, float waveOmega, float waveSigma,\n              float twistMax, float amp, float warpFreq) {\n  float env = travelingEnvelope(g, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n  vec2 f = curlFBM(vec2(g.x * warpFreq + t * 0.05, g.y * warpFreq - t * 0.04));\n  float wf2 = warpFreq * 1.833333;\n  vec2 f2 = curlFBM(vec2(g.x * wf2 - t * 0.03, g.y * wf2 + t * 0.035));\n  float k = twistMax * env;\n  return g + (f + f2 * 0.5) * k;\n}\n\n// The local cursor swirl \u2014 the finger twists the cells around it (re-aimed cursorBulge).\nvec2 cursorSwirl(vec2 g, vec2 cursor, float strength, float radius) {\n  vec2 to = g - cursor;\n  float d2 = dot(to, to);\n  float r = max(radius, 1e-4);\n  float theta = strength * exp(-d2 / (2.0 * r * r));\n  float ct = cos(theta);\n  float st = sin(theta);\n  return cursor + vec2(ct * to.x - st * to.y, st * to.x + ct * to.y);\n}\n\n// The LOW-octave value-noise topography \u2014 the scalar field concentric extracts contours of.\nfloat heightField(vec2 p, float octavesF, float seed) {\n  float v = 0.0;\n  float amp = 0.5;\n  float freq = 1.0;\n  float px = p.x + seed;\n  float py = p.y - seed;\n  int n = int(clamp(octavesF, 1.0, 6.0));\n  for (int i = 0; i < 6; i++) {\n    if (i >= n) break;\n    v += amp * valueNoise(px * freq, py * freq);\n    float rx = 0.8 * px - 0.6 * py;\n    float ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\n\n// The \u03C9=\u221A(g\u00B7k) breathing swell \u2014 basins inflate/deflate with weight.\nfloat waveSwell(float t, float phase) {\n  return sin(t * 0.35 + phase) * 0.5 + sin(t * 0.21 + phase * 1.7) * 0.5;\n}\n";

package/dist/composables/glass/wave/waveField.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const WAVE_FIELD_WGSL = "\nconst WAVE_FIELD_TAU: f32 = 6.283185307179586;\n\n// The traveling-wave envelope \u2014 a moving Gaussian crest band sweeping along waveDir.\nfn travelingEnvelope(pivot: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32) -> f32 {\n  let coord = dot(pivot, waveDir) * waveK - t * waveOmega;\n  let crest = fract(coord / WAVE_FIELD_TAU);\n  let z = (crest - 0.5) * 2.0;\n  return exp(-(z * z) / max(waveSigma, 1e-3));\n}\n\n// The curl-direction scalar \u2014 the smooth low-freq director the per-cell twist follows.\nfn curlScalar(cc: vec2f, t: f32) -> f32 {\n  let f = curlFBM(vec2f(cc.x * 0.5 + t * 0.08, cc.y * 0.5 - t * 0.06));\n  return clamp(f.x, -1.0, 1.0);\n}\n\n// The directed-twist FLOOR (the visibility cure): keep the curl SIGN (adjacent cells lean\n// together) but floor the magnitude so a crest-band cell ALWAYS rotates decisively.\nconst WAVE_FIELD_TWIST_FLOOR: f32 = 0.62;\nfn directedTwist(s: f32, floorMag: f32) -> f32 {\n  let mag = max(floorMag, abs(s));\n  let sgn = tanh(s * 6.0);\n  return sgn * mag;\n}\n\n// \u2500\u2500 The FACE leaf (the structurally-absent RE-INVENT \u2014 height-lit filled cell interior) \u2500\u2500\n// DECLARED ABOVE cellTwist (no WGSL forward declaration): cellTwist rides cellHeight via the\n// driver so twist + face read ONE envelope.\n\n// The sheet displacement at a cell center = the EXACT traveling-wave scalar the twist rides.\nfn cellHeight(cc: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32, amp: f32) -> f32 {\n  return travelingEnvelope(cc, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n}\n\n// The pre-twist driver (FOLD A): the cell pivot cc + the crest envelope env the twist AND the\n// face both ride. The face samples height/relief at THIS pre-twist cc (the crest twist crosses\n// the cell boundary \u2192 floor(twisted_g) would light a neighbouring cell). cc is in .xy and env in .z.\nfn cellDriver(g: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n              waveSigma: f32, amp: f32) -> vec3f {\n  let cs = max(cellSize, 1e-3);\n  let cc = (floor(g / cs) + 0.5) * cs;\n  let env = cellHeight(cc, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec3f(cc, env);\n}\n\n// The central-difference slope of cellHeight across a cell (eps = 0.5\u00B7cellSize) \u2014 derivative-\n// FREE (NO dFdx on the height) \u2192 Safari WebGL2-safe. Returns \u2207H.\nfn faceRelief(cc: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n              waveSigma: f32, amp: f32) -> vec2f {\n  let eps = max(cellSize, 1e-3) * 0.5;\n  let hxp = cellHeight(cc + vec2f(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hxm = cellHeight(cc - vec2f(eps, 0.0), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hyp = cellHeight(cc + vec2f(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let hym = cellHeight(cc - vec2f(0.0, eps), t, waveDir, waveK, waveOmega, waveSigma, amp);\n  return vec2f((hxp - hxm) / (2.0 * eps), (hyp - hym) / (2.0 * eps));\n}\n\n// Soft inset-square coverage inside a (warped) cell \u2014 the filled FACE plateau. d is the\n// distance into the cell from the nearest gutter (the Golus triangle-wave); the inset retreats\n// as it grows (the squash). aa = the shader's fwidth(g) (JS passes a fixed uvDeriv).\nfn facePlateau(g: vec2f, inset: f32, uvDeriv: vec2f) -> f32 {\n  let tri = 1.0 - abs(fract(g) * 2.0 - 1.0);\n  let d = min(tri.x, tri.y);\n  let aa = max(uvDeriv.x, uvDeriv.y) * 1.5;\n  return smoothstep(inset, inset + 2.0 * aa, d);\n}\n\n// The cell-local twist about each cell's own center, gated by the traveling wave + directed\n// by the curl flow. amp is the spring-eased envelope amplitude the JS host drives. FOLD C: the\n// TWIST_FLOOR is crest-gated by env so OFF-crest cells relax to flat calm paper (the traveling\n// read, not static foil).\nfn cellTwist(g: vec2f, cellSize: f32, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32,\n             waveSigma: f32, twistMax: f32, shearMax: f32, amp: f32) -> vec2f {\n  let drv = cellDriver(g, cellSize, t, waveDir, waveK, waveOmega, waveSigma, amp);\n  let cc = drv.xy;\n  let env = drv.z;\n  let floorMag = WAVE_FIELD_TWIST_FLOOR * env;   // FOLD C: crest-gated floor\n  let theta = twistMax * env * directedTwist(curlScalar(cc, t), floorMag);\n  let shear = shearMax * env * directedTwist(curlScalar(cc + vec2f(17.3, 9.1), t), floorMag);\n  let local = g - cc;\n  let ct = cos(theta);\n  let st = sin(theta);\n  var rot = vec2f(ct * local.x - st * local.y, st * local.x + ct * local.y);\n  rot.x = rot.x + shear * rot.y;   // a small skew so the box MORPHS, not just rotates\n  return cc + rot;\n}\n\n// The CONTINUOUS traveling-wave FLOW warp \u2014 the SMOOTH twin of cellTwist (no per-cell seam;\n// for the level-set contours that shatter into a mesh under the cell discontinuity).\n// warpFreq is the host-supplied curl-sampling spatial frequency (the caller's\n// own coordinate units): an order of magnitude BELOW its grid frequency so the warp is locally\n// affine (major lines bow as one smooth curve, no sub-cell crackle). LiquidGrid (cell-scale g0)\n// passes ~0.03; concentric (unit-scale p) passes 0.6. The 1.833333 second-flow ratio transcribes\n// WAVE_FLOW_SECOND_RATIO. Amplitude unchanged \u2014 curl magnitude is the intrinsic gradient at the\n// fixed CURL_EPS, independent of warpFreq; the t-drift is host-agnostic.\nfn waveFlow(g: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32,\n            twistMax: f32, amp: f32, warpFreq: f32) -> vec2f {\n  let env = travelingEnvelope(g, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n  let f = curlFBM(vec2f(g.x * warpFreq + t * 0.05, g.y * warpFreq - t * 0.04));\n  let wf2 = warpFreq * 1.833333;\n  let f2 = curlFBM(vec2f(g.x * wf2 - t * 0.03, g.y * wf2 + t * 0.035));\n  let k = twistMax * env;\n  return g + (f + f2 * 0.5) * k;\n}\n\n// The local cursor swirl \u2014 the finger twists the cells around it (re-aimed cursorBulge).\nfn cursorSwirl(g: vec2f, cursor: vec2f, strength: f32, radius: f32) -> vec2f {\n  let to = g - cursor;\n  let d2 = dot(to, to);\n  let r = max(radius, 1e-4);\n  let theta = strength * exp(-d2 / (2.0 * r * r));\n  let ct = cos(theta);\n  let st = sin(theta);\n  return cursor + vec2f(ct * to.x - st * to.y, st * to.x + ct * to.y);\n}\n\n// The LOW-octave value-noise topography \u2014 the scalar field concentric extracts contours of.\nfn heightField(p: vec2f, octavesF: f32, seed: f32) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var px = p.x + seed;\n  var py = p.y - seed;\n  let n = i32(clamp(octavesF, 1.0, 6.0));\n  for (var i = 0; i < 6; i = i + 1) {\n    if (i >= n) { break; }\n    v = v + amp * valueNoise(px * freq, py * freq);\n    let rx = 0.8 * px - 0.6 * py;\n    let ry = 0.6 * px + 0.8 * py;\n    px = rx;\n    py = ry;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\n// The \u03C9=\u221A(g\u00B7k) breathing swell \u2014 basins inflate/deflate with weight.\nfn waveSwell(t: f32, phase: f32) -> f32 {\n  return sin(t * 0.35 + phase) * 0.5 + sin(t * 0.21 + phase * 1.7) * 0.5;\n}\n";

package/dist/composables/glass/webgpu/index.d.ts

@@ -1,3 +0,0 @@
-export { createWebGPUCanvas, supportsWebGPU, WebGPUInitError, type WebGPUCanvasFrame, type WebGPUCanvasHandle, type WebGPUCanvasOptions, type WebGPUSuspendReason, } from "./useWebGPUCanvas";
-export { createGpuSubstrate, type GpuBackend, type GpuSubstrateHandle, type GpuSubstrateOptions, } from "./useGpuSubstrate";
-export { sizeBacking, type BackingSize, type DprPolicy, } from "../webgl/createCanvasLifecycle";

package/dist/composables/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./dark";
-export * from "./keyboard";
-export * from "./reactive";
-export * from "./dom";
-export * from "./motion";
-export * from "./motion/core";
-export * from "./glass";
-export * from "./sidebar";
-export * from "../components/infinite-scroll/composables";

package/dist/composables/motion/number/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/number/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 named `useNumericTransition` return shape.
- * 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`.
-     *
-     * 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/reveal/bloomUpField.d.ts

@@ -1,29 +0,0 @@
-import type { Ref } from "vue";
-/** The ambient-strength ceiling (sub-perceptual; never a flood). */
-export declare const AMBIENT_STRENGTH_CEILING = 8;
-/** The live reduced-motion probe (matchMedia, SSR-safe). */
-export declare function prefersReducedMotion(): boolean;
-/** Clamp the ambient-strength target into the bounded warm-cream-identity band `[0, 8]`. */
-export declare function clampStrength(n: number | undefined): number;
-/**
- * Resolve the FIELD container the 4th color channel writes onto. Explicit `field` ref
- * wins; else walk up from `dest` to the nearest `[data-glass-field]` ancestor (the
- * field-marker contract); else `dest.parentElement`. The field is a DIFFERENT element
- * from the blooming surface — the compositor-only de-risk.
- */
-export declare function resolveField(dest: HTMLElement, explicit: Ref<HTMLElement | null> | undefined): HTMLElement | null;
-/**
- * Read the source's dominant hue — the explicit `fieldHue` OR the `--glass-ambient-hue`
- * computed off the source element (the AMBIENT-TINT source). Returns `null` for a
- * neutral/absent hue (the field tints nothing).
- */
-export declare function resolveHue(source: HTMLElement | null, explicit: string | undefined): string | null;
-/** Set the field's dominant hue (the 4th-channel hue, set ONCE — not animated). */
-export declare function writeFieldHue(field: HTMLElement, hue: string): void;
-/** Write the field's ambient strength (the registered @property interpolates it). */
-export declare function writeFieldStrength(field: HTMLElement, pct: number): void;
-/**
- * Release the field bias back to the no-op floor (0%) and clear the hue so the field returns
- * to its un-biased `--glass-tint-ink` (the warm-cream identity).
- */
-export declare function releaseField(field: HTMLElement | null): void;

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

@@ -1,33 +0,0 @@
-import { type Ref } from "vue";
-import { type SpringPresetName } from "../spring/springPresets";
-export type BloomUpPreset = Extract<SpringPresetName, "snappy" | "bouncy">;
-export interface UseBloomUpOptions {
-    /** The spring register (default `snappy`). */
-    preset?: BloomUpPreset;
-    /** Starting destination blur in pixels. Default `4`. */
-    blur?: number;
-    /** Explicit field hue; otherwise read from the source's `--glass-ambient-hue`. */
-    fieldHue?: string;
-    /** Destination field; otherwise use the nearest `[data-glass-field]` ancestor. */
-    field?: Ref<HTMLElement | null>;
-    /** Ambient strength percentage, clamped to `0..8`. Default `8`. */
-    fieldStrength?: number;
-    /** Snap spatial motion under reduced motion. Default `true`. */
-    respectReducedMotion?: boolean;
-    /** Seat a newly mounted destination before paint. Default `true`. */
-    autoPrime?: boolean;
-    /** Fired once when the bloom reaches its terminal state. */
-    onBloomed?: () => void;
-}
-export interface UseBloomUpReturn {
-    bloom: () => void;
-    reset: () => void;
-    prime: () => void;
-    blooming: Readonly<Ref<boolean>>;
-}
-/**
- * Bloom a destination from a source rect while warming its surrounding field.
- * Geometry and paint share `useElementMorph`'s one spring clock; this wrapper has no
- * scheduler or `ElementMorph` instance of its own.
- */
-export declare function useBloomUp(source: Ref<HTMLElement | null>, dest: Ref<HTMLElement | null>, options?: UseBloomUpOptions): UseBloomUpReturn;

package/dist/composables/motion/reveal/useStaggerReveal.d.ts

@@ -1,28 +0,0 @@
-interface StaggerRevealConfig {
-    /** Delay between each target becoming `revealed`. Default 60ms. */
-    staggerMs?: number;
-    /** When true (default), a target stays revealed after first entering the viewport. */
-    once?: boolean;
-    /** IntersectionObserver rootMargin. Default `0px`. */
-    rootMargin?: string;
-    /** IntersectionObserver threshold. Default 0.15. */
-    threshold?: number;
-}
-/**
- * Sequence entrance animations for a list/grid. Each registered target
- * gets a staggered `revealed` flag once it crosses the viewport threshold.
- * Consumers bind the flag to a Tailwind class (e.g. `opacity-100 translate-y-0`)
- * and let CSS transitions handle the visual entry.
- *
- * On an engine with native `view()` timelines, no `IntersectionObserver`
- * is constructed — prefer the `[data-scroll-reveal]` CSS recipe
- * (scroll-driven.css). This composable is the feature-detected fallback (the
- * sole writer when the native feature is absent); under native, `register()`
- * reveals immediately so the terminal state is correct and the CSS animates.
- */
-export declare function useStaggerReveal(options?: StaggerRevealConfig): {
-    targets: import("vue").Ref<HTMLElement[], HTMLElement[]>;
-    register: (el: HTMLElement | null, index?: number) => void;
-    revealed: Record<number, boolean>;
-};
-export {};

package/dist/composables/motion/reveal/useTextHighlight.d.ts

@@ -1,41 +0,0 @@
-/** Match a query against a text-node's content, returning matched char ranges. */
-export type HighlightMatcher = (
-/** The text-node's full string content. */
-text: string, 
-/** The active query (already passed through to the matcher unchanged). */
-query: string) => Array<{
-    start: number;
-    end: number;
-}>;
-export interface UseTextHighlightControls {
-    /** Replace the highlight's range set. Empty array clears the paint. */
-    set: (ranges: Range[]) => void;
-    /**
-     * Walk every text node under `container`, run `matcher` per node, and
-     * highlight the returned `[start, end)` char spans. Replaces the prior set.
-     * The default matcher is a case-insensitive substring scan over `query`.
-     */
-    setFromMatches: (container: HTMLElement, query: string, matcher?: HighlightMatcher) => void;
-    /** Drop every range — the named highlight stops painting. */
-    clear: () => void;
-    /** True when the CSS Custom Highlight API is available (else every op no-ops). */
-    readonly supported: boolean;
-}
-/**
- * Drive a named CSS Custom Highlight reactively.
- *
- * @param name registry key — must match a caller-owned
- *   `::highlight(<name>)` style rule. This low-level API does not inject CSS.
- *   Instances sharing a name multiplex: each contributes its own ranges and
- *   the shared paint is their union (last to dispose drops the registry entry).
- *
- * @example
- * const hl = useTextHighlight("fuzzy-search");
- * watch([query, listEl], ([q, el]) => {
- *     if (el) hl.setFromMatches(el, q, fuzzyRanges);
- * });
- *
- * // Or hand it pre-built ranges directly:
- * hl.set([range]);
- */
-export declare function useTextHighlight(name: string): UseTextHighlightControls;