@mkbabb/glass-ui 7.0.0 → 8.0.0

package/dist/components/timeline/GlassTimeline.vue.d.ts

@@ -1,113 +0,0 @@
-import type { TimelineSegment } from "./types";
-/**
- * <GlassTimeline> — dispatcher SFC for three structurally-distinct
- * timeline variants.
- *
- * - `variant="scrubber"` (default): single-track normalized 0..1 scrubber
- *   with full keyboard a11y (role=slider + arrow-key step + shift-step).
- *   Delegates to `<ScrubberTimeline>`.
- *
- * - `variant="segmented"`: adjacent gradient bands,
- *   one per phase, with boundary dots that emit `hover` + `click` events
- *   carrying the segment key + payload. Delegates to `<SegmentedTimeline>`.
- *
- * - `variant="continuous"`: one rounded-pill rail
- *   substrate with N absolute-positioned region children. Delegates to
- *   `<ContinuousTimeline>`. The continuous variant owns the popover
- *   portal CSS contract (non-scoped <style> block; see ContinuousTimeline).
- *
- * Per-segment gradient: either `{from, to}` (expanded as 90deg L→R linear
- * gradient) or a raw CSS gradient string consumed verbatim. Falls back
- * to `--timeline-segment-default-gradient` when omitted.
- *
- * The three variant SFCs + `geometry.ts` shared math live alongside in
- * the same package. Consumer imports through
- * `@mkbabb/glass-ui/timeline` are unchanged.
- */
-type __VLS_Props = {
-    /** Variant — default `scrubber`. */
-    variant?: "scrubber" | "segmented" | "continuous";
-    /** 0..1 scrubber position. Required for scrubber variant. */
-    modelValue?: number;
-    /** Tooltip caret text (scrubber variant only). */
-    label?: string;
-    /** Phase descriptors (segmented + continuous variants). */
-    segments?: TimelineSegment[];
-    /**
-     * Optional aria-label for the continuous variant's rail
-     * (role=progressbar). Falls back to a comma-joined list of segment
-     * labels when omitted.
-     */
-    ariaLabel?: string;
-    /**
-     * Current segment key (continuous variant).
-     * Stamps `data-current="true"` on the matching marker so consumers
-     * can distinguish the active
-     * phase from the transient hovered phase.
-     */
-    currentSegmentKey?: string;
-    /**
-     * Disable the default per-marker
-     * HoverPopover (continuous variant). The dot still emits
-     * `hover` / `click` events.
-     */
-    disablePopover?: boolean;
-};
-declare var __VLS_13: {
-    segment: TimelineSegment;
-}, __VLS_16: {
-    segment: TimelineSegment | null;
-    source: "idle" | "current" | "hovered";
-    currentKey: string | null;
-    hoveredKey: string | null;
-};
-type __VLS_Slots = {} & {
-    popoverContent?: (props: typeof __VLS_13) => any;
-} & {
-    detail?: (props: typeof __VLS_16) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (v: number) => any;
-    click: (payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any;
-    hover: (payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any;
-    hoverEnd: (payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any;
-    scrubStart: () => any;
-    scrubEnd: () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
-    onClick?: ((payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any) | undefined;
-    onHover?: ((payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any) | undefined;
-    onHoverEnd?: ((payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any) | undefined;
-    onScrubStart?: (() => any) | undefined;
-    onScrubEnd?: (() => any) | undefined;
-}>, {
-    modelValue: number;
-    variant: "scrubber" | "segmented" | "continuous";
-    disablePopover: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/timeline/ScrubberTimeline.vue.d.ts

@@ -1,45 +0,0 @@
-/**
- * <ScrubberTimeline> — single-track normalized 0..1 scrubber.
- *
- * Internal variant SFC dispatched from <GlassTimeline variant="scrubber">.
- * Owns the single-track contract: pointer-capture drag, keyboard
- * a11y (role=slider + arrow-key step + shift-step), `label` tooltip caret.
- *
- * The `aria-valuenow` binding coerces `Number(modelValue ?? 0)`
- * so a numeric attribute always renders (axe `aria-required-attr` regression).
- *
- * The head is a warm-glass
- * liquid lozenge. The four cartoon beats COMPOSE shipped engines only (no new
- * motion engine): travel rides a `useSpring`/SpringProgress position written
- * to `transform: translateX()` (NEVER `style.left` — Safari composites
- * transform, not left); `useLiquidFlex` `"tanh"` velocity-squish multiplies
- * into the SAME matrix (vol-preserving, cap ≤1.12); `useLiquidPress` grab
- * anticipation; the velocity term is the head spring's own derivative (the
- * self-extinguishing per-frame velocity SpringProgress already computes — the
- * GOLDEN §0 "drive off the spring derivative" path, no free-running rAF); the
- * fill LAGS the head on a slower spring clock; release settles ζ<1 on the
- * cartoon-punch clock; a one-shot accent-flood ripples on landing. Always
- * visible (the
- * `opacity:0`-until-hover is RETIRED — the affordance must be present during
- * keyboard/touch scrub). The bead seats φ-INSIDE the channel; the 44px touch
- * target is an invisible `::before` halo, decoupled from the visible bead.
- */
-type __VLS_Props = {
-    /** 0..1 scrubber position. */
-    modelValue?: number;
-    /** Tooltip caret text. */
-    label?: string;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (v: number) => any;
-    scrubStart: () => any;
-    scrubEnd: () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
-    onScrubStart?: (() => any) | undefined;
-    onScrubEnd?: (() => any) | undefined;
-}>, {
-    modelValue: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/timeline/SegmentedTimeline.vue.d.ts

@@ -1,45 +0,0 @@
-import type { TimelineSegment } from "./types";
-/**
- * <SegmentedTimeline> — adjacent gradient bands with boundary dots.
- *
- * Internal variant SFC dispatched from <GlassTimeline variant="segmented">.
- * Suitable for compact multi-phase progress timelines. Gradient endpoints
- * map to per-phase chart-color tokens. Visual shape: N rectangles in a row.
- *
- * Each cell owns its own gradient background and per-state fill; the
- * boundary dot is a button anchored to the right edge of each cell
- * (the boundary between this cell and the next, or the timeline
- * terminus).
- */
-type __VLS_Props = {
-    segments?: TimelineSegment[];
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    click: (payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any;
-    hover: (payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any;
-    hoverEnd: (payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClick?: ((payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any) | undefined;
-    onHover?: ((payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any) | undefined;
-    onHoverEnd?: ((payload: {
-        key: string;
-        segment: TimelineSegment;
-    }) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/toggle-group/styles.css

@@ -1 +0,0 @@
-@layer components { .toggle-group { display: inline-flex; inline-size: fit-content; max-inline-size: 100%; align-items: center; gap: 0.25rem; vertical-align: middle; scroll-padding-inline: 0.25rem; overscroll-behavior-inline: contain; } .toggle-group[data-type="single"] { justify-content: safe center; padding: 0.25rem; border-radius: calc(var(--radius-pill) + 0.25rem); background: var(--glass-bg-quiet); -webkit-backdrop-filter: var(--glass-cell-backdrop-filter, var(--glass-blur-quiet)); backdrop-filter: var(--glass-cell-backdrop-filter, var(--glass-blur-quiet)); box-shadow: var(--glass-rim-top), var(--glass-rim-bottom), inset 0 1px 2px var(--tab-track-recess-ink); } .toggle-group[data-orientation="vertical"] { flex-direction: column; align-items: stretch; } .toggle-group__item { --toggle-group-item-size: var(--control-h-md); display: inline-flex; flex: none; min-inline-size: var(--toggle-group-item-size); min-block-size: var(--toggle-group-item-size); align-items: center; justify-content: center; gap: 0.5rem; padding-inline: 0.75rem; border: 1px solid transparent; border-radius: var(--radius-pill); background: transparent; color: var(--muted-foreground); font: inherit; font-size: var(--control-text); font-weight: 500; line-height: 1; white-space: nowrap; cursor: pointer; appearance: none; touch-action: manipulation; user-select: none; --scale-press: var(--scale-press-sm); } .toggle-group__item[data-size="sm"] { --toggle-group-item-size: var(--control-h-sm); padding-inline: 0.625rem; font-size: var(--control-text-sm); } .toggle-group__item[data-size="lg"] { --toggle-group-item-size: var(--control-h-lg); padding-inline: 1.25rem; } .toggle-group__item[data-variant="outline"] { border-color: var(--control-surface-border); background: var(--control-surface-bg); -webkit-backdrop-filter: var(--glass-cell-backdrop-filter, var(--control-surface-blur)); backdrop-filter: var(--glass-cell-backdrop-filter, var(--control-surface-blur)); } .toggle-group__item:hover:not(:disabled) { background: var(--control-surface-bg-hover); color: var(--foreground); } .toggle-group__item[data-state="on"] { border-color: color-mix(in oklab, var(--primary) 28%, transparent); background: var(--accent); color: var(--accent-foreground); box-shadow: var(--shadow-sm); } .toggle-group__item:disabled { opacity: var(--opacity-disabled); cursor: not-allowed; pointer-events: none; } .toggle-group__item > svg { flex: none; pointer-events: none; } @media (forced-colors: active) { .toggle-group[data-type="single"], .toggle-group__item[data-variant="outline"] { border: 1px solid ButtonText; background: Canvas; box-shadow: none; } .toggle-group__item[data-state="on"] { border-color: Highlight; background: Highlight; color: HighlightText; } } }

package/dist/components/toggle-group/toggleGroupContext.d.ts

@@ -1,9 +0,0 @@
-export type ToggleGroupVariant = "default" | "outline";
-export type ToggleGroupSize = "sm" | "md" | "lg";
-export interface ToggleGroupContext {
-    variant?: ToggleGroupVariant | null;
-    size?: ToggleGroupSize | null;
-}
-export declare const TOGGLE_GROUP_KEY: import("vue").InjectionKey<ToggleGroupContext>;
-export declare function provideToggleGroupContext(context: ToggleGroupContext): void;
-export declare const useOptionalToggleGroupContext: () => ToggleGroupContext | null;

package/dist/components/typewriter/composables/index.d.ts

@@ -1 +0,0 @@
-export { useTypewriter } from "./useTypewriter";

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;