@mkbabb/glass-ui 4.1.0 → 4.2.0

package/dist/components/custom/toggle-chip/index.d.ts

@@ -1,15 +1,26 @@
 import { type VariantProps } from "class-variance-authority";
 export { default as ToggleChip } from "./ToggleChip.vue";
 /**
- * Shared toggleable "chip" / "cell" primitive for selector grids.
+ * Shared toggleable "chip" / "cell" primitive for selector grids
+ * (BD.W-CHIP-CONGRUENT-GLASS).
  *
  * `chip` — inline horizontal token (e.g. tag pickers, tool-filter rows).
  * `cell` — square card that stacks an icon/preview over a label
  *          (e.g. pose pickers, palette swatches, emotion pickers).
  *
- * The `data-state="on"` attribute is set by the reka-ui Toggle root
- * when pressed, so selected styling hangs off the data attribute and
- * doesn't need a class-binding at the call site.
+ * Survival of the fittest: the chip family collapsed to ONE congruent recipe
+ * (`../selectable-chip/chipVariants`). ToggleChip keeps its `variant` ergonomics
+ * (`chip` inline pill / `cell` square card) but RE-POINTS onto the shared
+ * `chipVariants` `size` axis — `chip` → the `md` stadium rung, `cell` → the
+ * `cell` card exception. Clean break (no alias): the prior 4px `rounded-sm`
+ * grab-bag + the `rounded-[0.625rem]→0px` cell + the per-state
+ * `color-mix(…--primary…)` literals are GONE; the recipe is now the shared
+ * `.glass-chip .glass-capsule .glass-capsule-hover .accent-tone` lens — the SAME
+ * register SelectableChip + the toggle-group render. ONE family, no fork.
+ *
+ * The `data-state="on"` attribute is set by the reka-ui Toggle root when pressed,
+ * so the selected colour-flood + the punch hang off the data attribute (in
+ * `glass/glass-chip.css`) — no class-binding at the call site.
  */
 export declare const toggleChipVariants: (props?: ({
     variant?: "cell" | "chip" | null | undefined;

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

@@ -27,16 +27,18 @@ type __VLS_Props = {
      * 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: an
-     *              SVG <ellipse> `stroke-dasharray` carrying the SAME wet
-     *              `feDisplacementMap` filter, so the displacement wobbles the
-     *              dashed ellipse INTO the seeded organic outline (a dashed
-     *              OUTLINE following the silhouette — NOT a solid ring, NOT a CSS
-     *              dashed rectangle). A low-alpha `color` fill is kept behind the
-     *              stroke. A `ghost` of a given `color + seed` carries the SAME
-     *              seeded `border-radius` silhouette the `solid` dot of that seed
-     *              renders (both read the same `useWatercolorBlob` morph). The
-     *              empty-palette-slot / placeholder affordance.
+     *   `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 (`activeBorderRadius`), 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` morph — the ONE shape source). The empty-
+     *              palette-slot / placeholder affordance.
      */
     variant?: "solid" | "ghost";
     /** Run the rAF-driven compositor transform wobble (default false → static). */

package/dist/components/ui/_shared/useSurfaceAxis.d.ts

@@ -1,5 +1,5 @@
 /**
- * The shared surface-decoration axis — three rungs, ONE grammar.
+ * The shared surface-decoration axis — four rungs, ONE grammar.
  *
  *   glass   — the resolved tier's plain glass rung (default). The translucent
  *             blur surface, the maximal glass-first register.
@@ -11,8 +11,16 @@
  *   opaque  — the `--glass-level:0` solid-card escape: solid `--card` + `blur(0)`
  *             through the ONE level knob. The explicit opt-out from the maximal
  *             glass default.
+ *   clear   — BE.W-CLEAR-VARIANT: the Apple-Clear MAXIMALLY translucent register —
+ *             the `--glass-bg-clear` (0.58) plate, the clearest the library ships
+ *             (the album grid bleeds genuinely through). STRUCTURALLY coupled to a
+ *             MANDATORY `::before` legibility scrim (a near-transparent plate → the
+ *             text needs a scrim floor) whose strength derives from the sampled
+ *             `--glass-backdrop-luma` (it dims MORE over a bright backdrop). A
+ *             scrim-less clear surface is FORBIDDEN — the `.glass-clear` decoration
+ *             class carries the scrim in the SAME rule (the Apple Clear contract).
  */
-export type Surface = "glass" | "veil" | "opaque";
+export type Surface = "glass" | "veil" | "opaque" | "clear";
 /**
  * The 5-rung glass-ladder tier the surface paints its base over. Mirrors the
  * `.glass-{wash,quiet,resting,floating,overlay}` ladder. A surface passes the rung
@@ -34,8 +42,14 @@ export type SurfaceTier = "wash" | "quiet" | "resting" | "floating" | "overlay";
  *   surfaceClass("glass",  "floating") → "glass-floating"
  *   surfaceClass("veil",   "floating") → "glass-floating veil-surface"
  *   surfaceClass("opaque", "floating") → "glass-floating glass-opaque"
+ *   surfaceClass("clear",  "floating") → "glass-floating glass-clear"
  *
- * @param surface the decoration rung (`glass` default · `veil` · `opaque`)
+ * The `glass-clear` decoration class (BE.W-CLEAR-VARIANT) is scrim-COUPLED: its CSS
+ * rule carries the MANDATORY `::before` legibility scrim in the SAME seam, so a
+ * `surface="clear"` surface can NEVER paint the maximally-translucent plate without
+ * the dim — the Apple Clear contract is structural, not opt-out.
+ *
+ * @param surface the decoration rung (`glass` default · `veil` · `opaque` · `clear`)
  * @param tier    the base ladder rung (default `resting`)
  */
 export declare function surfaceClass(surface?: Surface, tier?: SurfaceTier): string;

package/dist/components/ui/badge/Badge.vue.d.ts

@@ -3,6 +3,20 @@ import { type BadgeVariants } from '.';
 type __VLS_Props = {
     variant?: BadgeVariants['variant'];
     size?: BadgeVariants['size'];
+    /**
+     * BD.W-GLASS-ATOM-REGISTER — the register split. `loud` (default) is the opaque
+     * saturated identity pill; `glass` is the quiet transmissive `.glass-atom`
+     * capsule tinted via `--glass-fill-tint`. A status badge stays loud (information,
+     * not a sticker); `secondary`/`outline` placements may route quiet.
+     */
+    surface?: BadgeVariants['surface'];
+    /**
+     * The LOUD cel cast opt-in (BD.W-CARTOON-CASTER). Every badge carries the
+     * family floor (the press-squish + a hairline rim-cast); `cast` INTENSIFIES the
+     * loud layered-offset stamp + mounts the inert `.cartoon-cast` child. A status
+     * pill is information, so the loud stamp is opt-in (not the default).
+     */
+    cast?: boolean;
     class?: HTMLAttributes['class'];
 };
 declare var __VLS_1: {};

package/dist/components/ui/badge/index.d.ts

@@ -3,5 +3,6 @@ export { default as Badge } from './Badge.vue';
 export declare const badgeVariants: (props?: ({
     variant?: "default" | "outline" | "destructive" | "secondary" | "success" | "warning" | "info" | null | undefined;
     size?: "sm" | "lg" | "md" | null | undefined;
+    surface?: "glass" | "loud" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type BadgeVariants = VariantProps<typeof badgeVariants>;

package/dist/components/ui/button/Button.vue.d.ts

@@ -8,6 +8,7 @@ interface Props extends PrimitiveProps {
     class?: HTMLAttributes['class'];
     surface?: Surface;
     liquid?: boolean;
+    punch?: boolean;
     type?: ButtonHTMLAttributes['type'];
     disabled?: ButtonHTMLAttributes['disabled'];
 }

package/dist/components/ui/card/Card.vue.d.ts

@@ -149,10 +149,10 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     shadow: boolean;
+    tier: CardTier;
     grid: boolean;
     surface: CardSurface;
     as: import("reka-ui").AsTag | import("vue").Component;
-    tier: CardTier;
     grain: boolean;
     specular: CardSpecular;
     pressable: boolean;

package/dist/components/ui/card/ScrollCard.vue.d.ts

@@ -19,9 +19,9 @@ declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ScrollCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ScrollCardProps> & Readonly<{}>, {
     shadow: boolean;
+    tier: CardTier;
     maxHeight: string;
     surface: CardSurface;
-    tier: CardTier;
     specular: CardSpecular;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;

package/dist/components/ui/carousel/CarouselContent.vue.d.ts

@@ -1,11 +1,9 @@
-import type { WithClassAsProps } from './interface';
+import type { WithClassAsProps } from "./interface";
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<WithClassAsProps, {
-    carouselRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<WithClassAsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<WithClassAsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<WithClassAsProps> & Readonly<{}>, {}, {}, {}, {}, 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;

package/dist/components/ui/dialog/DialogContent.vue.d.ts

@@ -51,6 +51,14 @@ type __VLS_Props = DialogContentProps & {
      * double-up. The default keeps every existing mount byte-identical.
      */
     showClose?: boolean;
+    /**
+     * BD.W-OVERLAY-STAGE-COUPLE — the scene-staging enum for the centered modal band.
+     * `none` (default — byte-identical to HEAD) leaves the page untouched; `dim`/
+     * `scale`/`immersive` flip the ONE `--stage-t` scalar 0→1 on open so the page
+     * RECEDES + SCALES behind the dialog (the iOS card-recede) and the scrim deepens.
+     * PRM degrades `scale`/`immersive` → `dim` (no page transform, fold C1·R6).
+     */
+    stage?: 'none' | 'dim' | 'scale' | 'immersive';
 };
 declare var __VLS_19: {};
 type __VLS_Slots = {} & {
@@ -73,6 +81,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
 }>, {
     surface: Surface;
     showClose: boolean;
+    stage: "none" | "dim" | "scale" | "immersive";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/ui/drawer/Drawer.vue.d.ts

@@ -1,4 +1,4 @@
-import type { DrawerDirection, DrawerMode } from './index';
+import type { DrawerDirection, DrawerMode, DrawerStage } from './index';
 /**
  * BB.W-DRAWER-ABROGATE — the Drawer root on the HOUSE reka `DialogRoot` substrate
  * (the SAME shape `Dialog.vue` binds). vaul-vue is gone: reka owns the open-control,
@@ -7,17 +7,31 @@ import type { DrawerDirection, DrawerMode } from './index';
  * owns the snap math vaul used to own.
  *
  * `mode` — additive shorthand (AN.W3). `"modal"` (default) keeps the iOS scale-down
- * look: `modal: true` (reka focus-traps + page-occludes). `"live-behind"` is the
- * non-modal peek/half/full bottom sheet — `modal: false` (no focus trap, no page
- * `aria-hidden`, page-behind stays interactive — reka delivers this natively),
- * `shouldScaleBackground: false`, and the direction-derived snap ladder. Every prop
- * the mode sets is still overridable by an explicit prop — `mode` only supplies
- * defaults.
+ * look: `modal: true` (reka focus-traps + page-occludes) + `stage: "scale"` (the page
+ * recedes). `"live-behind"` is the non-modal peek/half/full bottom sheet — `modal:
+ * false` (no focus trap, no page `aria-hidden`, page-behind stays interactive — reka
+ * delivers this natively), `stage: "none"`, and the direction-derived snap ladder.
+ * Every prop the mode sets is still overridable by an explicit prop — `mode` only
+ * supplies defaults.
  *
- * The snap props (`snapPoints`/`activeSnapPoint`/`direction`/`shouldScaleBackground`)
- * are HOUSE props now (they were vaul's `DrawerRootProps` surface — preserved by
- * shape so the consumer binding is byte-identical, but resolved by the house engine,
- * not forwarded to reka, which knows only `open`/`defaultOpen`/`modal`).
+ * The snap props (`snapPoints`/`activeSnapPoint`/`direction`) are HOUSE props now
+ * (they were vaul's `DrawerRootProps` surface — preserved by shape so the consumer
+ * binding is byte-identical, but resolved by the house engine, not forwarded to reka,
+ * which knows only `open`/`defaultOpen`/`modal`).
+ *
+ * BD.W-OVERLAY-STAGE-COUPLE — `stage` is the honest scene-staging enum that RETIRES
+ * the dead `shouldScaleBackground` boolean (clean break, no alias — the old boolean
+ * was read by NOTHING, `#app transform: none` at every detent):
+ *   • `none`      — no staging (the live-behind peek sheet leaves the page untouched).
+ *   • `dim`       — the scrim deepens with the detent; the page does NOT transform
+ *                   (the PRM-safe luminance-only depth cue; also the `scale` degrade).
+ *   • `scale`     — `dim` + the page RECEDES + SCALES (the iOS card-recede depth cue).
+ *   • `immersive` — `scale` + the scrim's backdrop-blur ENGAGES (the spotlight).
+ * Under `prefers-reduced-motion: reduce`, `scale`/`immersive` degrade to `dim` (no
+ * page transform — a full-page snap-scale IS perceived motion, fold C1·R6). The enum
+ * toggles `data-stage-scale` / `data-stage-immersive` on the page-wrapper marker
+ * (`[data-stage-wrapper]`, mounted by the consumer/demo shell) while the sheet is
+ * open; the `--stage-t` scalar the snap engine writes at `:root` drives the couplings.
  */
 type __VLS_Props = {
     /** The controlled open state (`v-model:open`). */
@@ -34,8 +48,13 @@ type __VLS_Props = {
     activeSnapPoint?: number | string | null;
     /** Drag/slide axis (BB-2 default-ladder source). */
     direction?: DrawerDirection;
-    /** iOS page scale-down on open (the modal look). Defaulted by `mode`. */
-    shouldScaleBackground?: boolean;
+    /**
+     * BD.W-OVERLAY-STAGE-COUPLE — the scene-staging enum (retires the dead
+     * `shouldScaleBackground`). `none` leaves the page untouched (the live-behind
+     * default); `dim` deepens the scrim only; `scale` recedes + scales the page;
+     * `immersive` adds the backdrop-blur engage. Defaulted by `mode`.
+     */
+    stage?: DrawerStage;
 };
 declare var __VLS_10: {};
 type __VLS_Slots = {} & {
@@ -53,9 +72,9 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     mode: DrawerMode;
     defaultOpen: boolean;
     modal: boolean;
+    stage: DrawerStage;
     snapPoints: (number | string)[];
     activeSnapPoint: number | string | null;
-    shouldScaleBackground: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/ui/drawer/constants.d.ts

@@ -8,14 +8,16 @@ import type { DrawerDirection } from "./index";
  * give than the dock's crisp 0.32/0.7 box-morph). Co-located here so the pair is
  * defined ONCE rather than at the top of the composable.
  *
- * `response 0.4` — the angular period (≈ the swing time); a hair looser than the
- * dock so the sheet reads as a heavier surface settling. `dampingFraction 0.82` —
- * the iOS "smooth" register: sub-perceptual overshoot (a settled sheet, not a
- * bouncing one) while staying alive on a flung release.
+ * BD.W-ANIM-IOS27-TUNE — re-tuned `{0.4, 0.82}` → `{0.50, 0.74}` so the sheet-grow
+ * reads as inertial liquid MASS (the Maps-card reference): `response 0.50` lengthens
+ * the settle ~+25% (the flowing-heavy arrival) and `dampingFraction 0.74` adds a small
+ * ~3.2% liquid overshoot (vs the prior near-critical 0%) — the sheet settles cleanly to
+ * its detent WITHOUT over-shooting past the viewport (ζ ≥ 0.72 keeps overshoot ≤ ~4%).
+ * The fling-decision (`DRAWER_FLING_VELOCITY`) is SEPARATE + unchanged.
  */
 export declare const DRAWER_SNAP: {
-    readonly response: 0.4;
-    readonly dampingFraction: 0.82;
+    readonly response: 0.5;
+    readonly dampingFraction: 0.74;
 };
 /**
  * BB-2 (the direction-aware default snap ladder fold) — the peek/half/full detent

package/dist/components/ui/drawer/index.d.ts

@@ -12,10 +12,20 @@ export type DrawerDirection = "top" | "bottom" | "left" | "right";
  * focus-trapped (reka `:modal="true"`), page-behind scaled. `"live-behind"` is the
  * non-modal peek/half/full bottom sheet — reka `:modal="false"` (no focus trap, no
  * page `aria-hidden`, page-behind at native size + interactive) — bundling the
- * `modal:false` + `shouldScaleBackground:false` + the direction-derived snap ladder.
- * Explicit props still override the mode's defaults.
+ * `modal:false` + `stage:"none"` + the direction-derived snap ladder. Explicit props
+ * still override the mode's defaults.
  */
 export type DrawerMode = "modal" | "live-behind";
+/**
+ * BD.W-OVERLAY-STAGE-COUPLE — the scene-staging enum (retires the dead
+ * `shouldScaleBackground` boolean, clean break). `none` leaves the page untouched;
+ * `dim` deepens the scrim only (the PRM-safe luminance depth cue); `scale` recedes +
+ * scales the page (the iOS card-recede); `immersive` adds the backdrop-blur engage.
+ * `modal` defaults to `scale`; `live-behind` to `none`. PRM degrades `scale`/
+ * `immersive` to `dim`. All four couplings ride the ONE `--stage-t` scalar the snap
+ * engine writes at `:root`.
+ */
+export type DrawerStage = "none" | "dim" | "scale" | "immersive";
 export { default as Drawer } from "./Drawer.vue";
 export { default as DrawerOverlay } from "./DrawerOverlay.vue";
 export { default as DrawerContent } from "./DrawerContent.vue";

package/dist/components/ui/select/SelectContent.vue.d.ts

@@ -4,6 +4,15 @@ import { type Surface } from '../_shared/useSurfaceAxis';
 type __VLS_Props = SelectContentProps & {
     class?: HTMLAttributes['class'];
     surface?: Surface;
+    /**
+     * BD.W-SELECT-WELL — the route's warm-field HUE re-emitted onto the portalled
+     * menu so it transmits its route identity even though it escapes to <body>
+     * (the page field stops at the route root; the portal does not). The menu-local
+     * `.glass-field-portal` spine reads this `--field-h`. A forms route resolves 48
+     * (terracotta); a feedback route a different warm hue — so each dropdown reads as
+     * different warm glass, none gray. Unset → the select.css `--field-h: 48` floor.
+     */
+    fieldHue?: number;
 };
 declare var __VLS_25: {};
 type __VLS_Slots = {} & {

package/dist/components/ui/slider/Slider.vue.d.ts

@@ -14,6 +14,14 @@ type __VLS_Props = SliderRootProps & {
      * `data-held` on its root, intensifying the thumb halo. Default: true.
      */
     keepDockOpen?: boolean;
+    /**
+     * BD.W-GLASS-ATOM-REGISTER — the liquid weight-train on the fill: anticipation
+     * dip on grab → BOUNDED saturating smear while pulling (the cel cast lagging by
+     * `--motion-weight × velocity`) → follow-through overshoot on release. Composes
+     * the `useDragVelocity` bridge (writes `--atom-drag-v`, no-idle-rAF teardown).
+     * PRM collapses it to the plain squish floor. Default: true.
+     */
+    liquidDrag?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (payload: number[] | undefined) => any;
@@ -23,6 +31,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     onValueCommit?: ((payload: number[]) => any) | undefined;
 }>, {
     keepDockOpen: boolean;
+    liquidDrag: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/composables/dom/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./useResizeObserver";
 export * from "./useTouchGate";
+export * from "./useDragVelocity";
 export * from "./useTokenColor";
 export * from "./useResolveTokenColor";
 export * from "./useClipboard";

package/dist/composables/dom/useDragVelocity.d.ts

@@ -0,0 +1,46 @@
+import { type Ref } from "vue";
+export interface UseDragVelocityParams {
+    /**
+     * The host element resolver — a getter (NOT a ref Slider populates in a sibling
+     * `onMounted`) so it sidesteps the onMounted-ordering trap the slider's
+     * `useDockHold` already documents. The `--atom-drag-v` var is written on THIS
+     * element; descendants inherit it (the fill + the cast read it).
+     */
+    host: () => HTMLElement | null;
+    /**
+     * The pointer axis the velocity is measured on. Default `"x"` (the horizontal
+     * slider). A getter re-reads on an orientation flip.
+     */
+    axis?: "x" | "y" | (() => "x" | "y");
+    /**
+     * The saturating-smear gain (the `tanh` steepness over px/frame). Higher = the
+     * smear reaches its ceiling at a slower drag. Default `0.06`.
+     */
+    gain?: number;
+    /**
+     * The smear CEILING (the clamp the saturated value floors under). Default `0.7`
+     * (challenge #3 R3 — mass wins, the pull never rubber-bands past this).
+     */
+    clamp?: number;
+    /** Honor `prefers-reduced-motion: reduce` (no rAF, value pinned 0). Default true. */
+    respectReducedMotion?: boolean;
+}
+export interface UseDragVelocityReturn {
+    /** True while a drag gesture is live (between `pointerdown` and `pointerup`). */
+    dragging: Readonly<Ref<boolean>>;
+    /** Detach all listeners + tear down any live rAF. Idempotent. */
+    detach: () => void;
+}
+/**
+ * The drag-window-gated velocity bridge — writes `--atom-drag-v` (0..1, bounded by a
+ * saturating `tanh`) on the host while a pointer drag is live, and tears the rAF DOWN
+ * on release (the no-idle-cost contract). The slider weight-train is its first
+ * consumer; any pull-to-smear atom reads the same var.
+ *
+ * @example
+ * ```ts
+ * const { dragging, detach } = useDragVelocity({ host: getRootEl })
+ * // CSS: .slider-range { transform: scaleX(calc(1 + 0.08 * var(--atom-drag-v))) }
+ * ```
+ */
+export declare function useDragVelocity(params: UseDragVelocityParams): UseDragVelocityReturn;

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,115 @@
+/** 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;
+/**
+ * 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.
+ */
+export declare function waveFlow(curlFn: (p: Vec2) => Vec2, g: Vec2, t: number, waveDir: Vec2, waveK: number, waveOmega: number, waveSigma: number, twistMax: number, amp: 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

@@ -0,0 +1 @@
+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).\nvec2 waveFlow(vec2 g, float t, vec2 waveDir, float waveK, float waveOmega, float waveSigma,\n              float twistMax, float amp) {\n  float env = travelingEnvelope(g, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n  vec2 f = curlFBM(vec2(g.x * 0.6 + t * 0.05, g.y * 0.6 - t * 0.04));\n  vec2 f2 = curlFBM(vec2(g.x * 1.1 - t * 0.03, g.y * 1.1 + 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

@@ -0,0 +1 @@
+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).\nfn waveFlow(g: vec2f, t: f32, waveDir: vec2f, waveK: f32, waveOmega: f32, waveSigma: f32,\n            twistMax: f32, amp: f32) -> vec2f {\n  let env = travelingEnvelope(g, t, waveDir, waveK, waveOmega, waveSigma) * amp;\n  let f = curlFBM(vec2f(g.x * 0.6 + t * 0.05, g.y * 0.6 - t * 0.04));\n  let f2 = curlFBM(vec2f(g.x * 1.1 - t * 0.03, g.y * 1.1 + 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";