@mkbabb/glass-ui 6.0.0 → 8.0.0

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,31 +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` (BG.W-WATERCOLOR-RAF) — parked when the tab is
- * hidden, frozen under `prefers-reduced-motion` — never a hand-rolled zombie rAF.
- * `nudge()` retargets the wobble for a quick jiggle on hover.
- */
-export declare function useWatercolorBlob(color: Ref<string> | (() => string), options?: UseWatercolorBlobOptions): {
-    borderRadius: Ref<string, string>;
-    hoverBorderRadius: Ref<string, string>;
-    transform: Ref<string, string>;
-    nudge: () => void;
-};
-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` (BB.W-LENSING). 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 W-LIQUIDHOVER 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.
- *
- * BG.W-GLASS-DYNAMICS — the OPTIONAL press-couple (absorbs 13.5, soft-gated by F5.1).
- * A consumer may pass `press` (a 0..1 press scalar — a `useSpringPress` `.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 F5.1 dependency), and the position/angle write is byte-identical to before.
- */
-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.
- *
- * BG.W-GRID-AFFINE — 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 NEIGHBOUR cell). cc in .xy, 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// BG.W-GRID-AFFINE \u2014 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). liquid-grid (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 NEIGHBOUR cell). cc in .xy, 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// BG.W-GRID-AFFINE \u2014 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). liquid-grid (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/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/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/bloomUpField.d.ts

@@ -1,29 +0,0 @@
-import type { Ref } from "vue";
-/** The BE.W-AMBIENT-TINT bound (sub-perceptual; never a flood — the warm-cream identity holds). */
-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/constants.d.ts

@@ -1,19 +0,0 @@
-/**
- * Shared damping factors for live numeric motion.
- *
- * These values preserve the app-level tuning that used to live in
- * speedtest's local animation utility while making glass-ui the owner of the
- * generic motion contract.
- */
-export declare const DAMPING: {
-    readonly canvasNeedle: 0.08;
-    readonly domHero: 0.12;
-    readonly domPill: 0.14;
-    readonly domProgress: 0.18;
-};
-/** Shared absolute snap thresholds for live numeric motion. */
-export declare const SNAP_THRESHOLD: {
-    readonly canvas: 0.002;
-    readonly dom: 0.05;
-    readonly domProgress: 0.5;
-};

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;