@mkbabb/glass-ui 4.0.1 → 4.2.0

package/dist/components/custom/completion-seal/CompletionSeal.vue.d.ts

@@ -0,0 +1,21 @@
+import { type CompletionSealShape } from "./constants";
+export interface CompletionSealProps {
+    /** The seal glyph — `check` (default) | `ring` | `wordmark`. */
+    shape?: CompletionSealShape;
+    /**
+     * The accessible completion announcement (the `role="status"`/`aria-live` text — a
+     * screen reader hears "Speedtest complete", etc.). The gold mark is the visual.
+     */
+    label?: string;
+    /**
+     * The draw trigger — the consumer fires it on completion. When it flips truthy the
+     * seal draws ONCE. Default (unset) plays on mount (the seal draws when it appears —
+     * the canonical completion moment).
+     */
+    play?: boolean;
+    /** Pass-through class on the root. */
+    class?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<CompletionSealProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CompletionSealProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/completion-seal/composables/useCompletionSeal.d.ts

@@ -0,0 +1,37 @@
+import { type Ref } from "vue";
+export interface UseCompletionSealOptions {
+    /**
+     * The draw trigger. When it flips truthy the seal draws ONCE (the consumer fires it
+     * on completion). A `Ref` or a getter; default plays on mount (`play` unset → the
+     * seal draws when it appears, the canonical completion moment).
+     */
+    play?: Ref<boolean | undefined> | (() => boolean | undefined);
+    /**
+     * Honor `prefers-reduced-motion: reduce` — under reduce the seal appears INSTANTLY
+     * fully-drawn (no stroke animation, no glint sweep). Default true. (Never forced
+     * false — the PRM-safe-by-construction fence.)
+     */
+    respectReducedMotion?: boolean;
+}
+export interface UseCompletionSeal {
+    /** The reactive `data-play` seam — bind it to `:data-play` on `.completion-seal`. */
+    playing: Readonly<Ref<boolean>>;
+    /** True once the seal has drawn (or snapped under PRM) — the static held state. */
+    drawn: Readonly<Ref<boolean>>;
+    /**
+     * Whether the motion is suppressed (PRM) — the SFC snaps `--seal-draw: 100%` and
+     * omits the `data-play` arm so the recipe's no-preference gate never fires.
+     */
+    reduced: Readonly<Ref<boolean>>;
+    /** Imperatively (re-)fire the one-shot draw (a second completion event). */
+    draw: () => void;
+}
+/**
+ * The one-shot completion-seal draw. Arms `playing` (the `data-play` seam) for the
+ * single draw pass, then settles to the static `drawn` state. Under reduced motion it
+ * never arms — `reduced` is true and the seal is the instant fully-drawn mark.
+ *
+ * Deterministic + SSR-safe (the matchMedia guard) — the recipe owns the paint, this
+ * leaf owns the boolean lifecycle.
+ */
+export declare function useCompletionSeal(options?: UseCompletionSealOptions): UseCompletionSeal;

package/dist/components/custom/completion-seal/constants.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The seal glyph axis — the mark the gold stroke draws:
+ *  - `check` (default) — a checkmark (the canonical "done" garnish).
+ *  - `ring`  — a ring/circle around the completion (a seal around the event).
+ *  - `wordmark` — a self-contained seal mark (a stylized seal glyph).
+ *
+ * All three share the ONE gold-draw mechanism (the `--seal-draw` stroke-reveal on the
+ * `--seal-ink` gold stroke) — a `shape`-scoped path, NOT a second recipe. The seal is
+ * the GOLD-DRAW completion register, distinct from the HandMark hand-voice family.
+ */
+export type CompletionSealShape = "check" | "ring" | "wordmark";
+/** The default seal glyph — the checkmark "done" garnish. */
+export declare const COMPLETION_SEAL_DEFAULT_SHAPE: CompletionSealShape;
+/**
+ * The normalized SVG viewBox the glyphs are authored in. The mark `pathLength="100"`
+ * normalizes every glyph's draw length so the `stroke-dashoffset` wipe is path-agnostic
+ * (the recipe reads `--seal-draw` 0..100% against the normalized length).
+ */
+export declare const COMPLETION_SEAL_VIEWBOX = "0 0 64 64";
+/**
+ * The per-shape SVG path/element the gold stroke draws. `check`/`wordmark` are <path>
+ * `d`-strings; `ring` is drawn as a <circle> (the SFC branches on shape). Authored in
+ * the 64×64 viewBox, `pathLength="100"` normalized at the element.
+ */
+export declare const COMPLETION_SEAL_PATHS: Record<Exclude<CompletionSealShape, "ring">, string>;
+/**
+ * The `ring` glyph geometry (a <circle>) — the centre + radius in the 64×64 viewBox.
+ * A near-perimeter ring so the seal reads hero-scale.
+ */
+export declare const COMPLETION_SEAL_RING: {
+    readonly cx: 32;
+    readonly cy: 32;
+    readonly r: 24;
+};
+/**
+ * The SPRING register the draw rides (SPRING-EASE / W-MOTION-CANON P2 enter-bouncy):
+ *  - the SETTLE leg (the spatial overshoot) rides `--spring-bouncy` (an ENTER may
+ *    overshoot on arrival);
+ *  - the DRAW + GLINT legs ride the `--spring-snappy` CLOCK (the snappy settle duration)
+ *    so the gold inks crisply, not languidly.
+ * The seal mints NO new spring token — it READS the SPRING-EASE register (the no-new-clock
+ * fence). These names are the recorded register choice; the actual curves live in the
+ * cascade (tokens/scheme-motion.css) and the recipe (completion-seal.css) reads them.
+ */
+export declare const COMPLETION_SEAL_SETTLE_SPRING = "--spring-bouncy";
+export declare const COMPLETION_SEAL_DRAW_SPRING = "--spring-snappy";

package/dist/components/custom/completion-seal/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CompletionSeal } from "./CompletionSeal.vue";
+export type { CompletionSealProps } from "./CompletionSeal.vue";
+export type { CompletionSealShape } from "./constants";
+export { useCompletionSeal, type UseCompletionSeal, type UseCompletionSealOptions, } from "./composables/useCompletionSeal";

package/dist/components/custom/concentric/Concentric.vue.d.ts

@@ -1,19 +1,22 @@
 import type { ConcentricConfig } from "./constants";
 /**
- * Concentric — a radial Fourier ring-interference field.
+ * Concentric — a living LEVEL-SET hypsometric SURVEY (paper-grid kin, BD.W-CONCENTRIC-RELIEF).
  *
- * Concentric ellipsoid rings whose interference is a sum of radial harmonics about
- * one-or-more centers (the cited radial-Fourier math — `composables/ringField.ts`): the
- * same Fourier-series vocabulary the dot-flow-field's wave potential uses, so the suite
- * speaks ONE math language. WebGPU-FIRST: a pure fullscreen fragment pass (the aurora
- * shape-class) evaluates `f(p,t) = Σ_j Σ_i A_i·sin(k_i·‖p−c_j‖_e − ω_i·t + φ_i)` per
- * pixel, with a clean WebGL2 GLSL fallback where WebGPU is absent. It composes
- * `useConcentric` → the `createGpuSubstrate` picker over the ONE canvas lifecycle leaf
- * (offscreen-pause, live-PRM freeze, consumer-owned DPR) — it never bootstraps its own
- * context.
+ * The iso-contours of a LOW-octave curl-warped height field H(p,t) — the SAME traveling-wave
+ * CELL-WARP that twists the paper-grid cells is applied to the SAMPLING coordinate, so the
+ * contours twist + flow as a wave passes OVER and THROUGH the topography; the ω=√(g·k) swell
+ * breathes the basins; the cursor HEAVES the topography toward the pointer (velocity-scaled
+ * gravity). The fragment paints an OPAQUE warm hypsometric FILL, lifts it into 2.5-D relief
+ * with one analytic hillshade, and inks it with a two-tier index/minor contour hierarchy via
+ * the KEPT IQ gradient-free `contourInk` (perfect GPU AA — density tracks 1/|∇H|). WebGPU-FIRST:
+ * a pure fullscreen fragment pass over the shared `waveField` leaf, with a clean WebGL2 GLSL
+ * fallback. It composes `useConcentric` → the `createGpuSubstrate` picker over the ONE canvas
+ * lifecycle leaf (offscreen-pause, live-PRM freeze, consumer-owned DPR).
  *
- * The DEFAULT palette is the warm-cream library identity; the demo themes the rings
- * through a PRESET (presets-in-consumers — never a library token).
+ * The DEFAULT identity is the warm-DIVERGENT hypsometric tint (deep plum-rose basin → ember →
+ * amber → wheat crest), resolved per-mode by plain arms (NOT CSS `light-dark()`, NOT an
+ * in-shader `uMode` seam): the dark twin glows on a deep-ember ground. A consumer (the demo)
+ * themes it through a PRESET (presets-in-consumers — never a library token).
  */
 type __VLS_Props = {
     /** The full author schema (the studio's `useConfiguratorState` model). */

package/dist/components/custom/concentric/composables/concentricGLSetup.d.ts

@@ -1,11 +1,23 @@
 import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
 import type { OklchStop } from "../../../../composables/color";
 import { type ConcentricConfig } from "../constants";
+import type { Vec2 } from "./levelField";
 export interface ConcentricGLSetupDeps {
     canvas: HTMLCanvasElement;
     config: ConcentricConfig;
     getPalette: () => OklchStop[];
+    /** The pointer in DOMAIN space (the cursor gravity well) — re-read each frame. */
+    getCursor: () => Vec2;
+    /** The spring-eased traveling-wave envelope amplitude (0..1; PRM → 0). */
+    getAmp: () => number;
+    /** The velocity-HEAVE multiplier on the cursor well (1.0 at rest → grows with speed). */
+    getWellScale: () => number;
     shouldContinue: () => boolean;
+    /**
+     * The per-frame pointer hook — useConcentric advances the shared pointer field +
+     * derives the cursor in domain space here (the no-own-rAF discipline). ZERO own rAF.
+     */
+    onFrame?: (timeSec: number) => void;
 }
 /** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
 export declare function createConcentricGLSetup(deps: ConcentricGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/concentric/composables/concentricWGPUSetup.d.ts

@@ -1,13 +1,26 @@
 import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
 import type { OklchStop } from "../../../../composables/color";
 import type { ConcentricConfig } from "../constants";
+import type { Vec2 } from "./levelField";
 export interface ConcentricWGPUSetupDeps {
     canvas: HTMLCanvasElement;
     config: ConcentricConfig;
     /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame so a live edit reaches the buffer. */
     getPalette: () => OklchStop[];
+    /** The pointer in DOMAIN space (the cursor gravity well) — re-read each frame. */
+    getCursor: () => Vec2;
+    /** The spring-eased traveling-wave envelope amplitude (0..1; PRM → 0). */
+    getAmp: () => number;
+    /** The velocity-HEAVE multiplier on the cursor well (1.0 at rest → grows with speed). */
+    getWellScale: () => number;
     /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
     shouldContinue: () => boolean;
+    /**
+     * The per-frame pointer hook — useConcentric advances the shared `usePointerVelocityField`
+     * here (the no-own-rAF discipline: the renderer's frame loop FEEDS `tick(delta)`) and
+     * derives the cursor in domain space. ZERO own rAF.
+     */
+    onFrame?: (timeSec: number) => void;
 }
 /** Build the concentric `setupWGPU(device, context, format)` callback. */
 export declare function createConcentricWGPUSetup(deps: ConcentricWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/concentric/composables/levelField.d.ts

@@ -0,0 +1,50 @@
+import { type Vec2 } from "../../../../composables/glass/wave/waveField";
+export type { Vec2 };
+/** The level-set sample params (the round-trip anchor; mirrors the shader uniforms). */
+export interface LevelFieldParams {
+    /** The traveling-wave front direction. */
+    waveDir: Vec2;
+    waveK: number;
+    waveOmega: number;
+    waveSigma: number;
+    twistMax: number;
+    shearMax: number;
+    /** The spring-eased envelope amplitude (0..1; PRM → 0). */
+    amp: number;
+    /** The topography cell pitch (domain units per cell — the contour-warp granularity). */
+    cellSize: number;
+    /** LOW octaves → clean nested loops. */
+    heightOctaves: number;
+    heightSeed: number;
+    /** The ω=√(g·k) breathing swell depth. */
+    swellAmp: number;
+    /** Per-contour wobble depth. */
+    perturbAmp: number;
+    /** The contour-level count. */
+    levels: number;
+    /** The cursor (domain space). */
+    cursor: Vec2;
+    /** The cursor Gaussian peak depth (the topography bulges under the pointer). */
+    cursorWell: number;
+    /** 1 = cursor on. */
+    interactive: number;
+}
+/**
+ * The warped level-set height at domain `p` and time `t` — the SINGLE math source. The
+ * sampling coordinate is twisted by the SHARED `cellTwist` (the kinship with paper-grid:
+ * the same wave flows both); the height is a low-octave fbm topography + the swell; the cursor
+ * adds a Gaussian peak. Returns the un-normalized height (the shader contours + tints it).
+ */
+export declare function sampleHeight(p: Vec2, t: number, q: LevelFieldParams): number;
+/** The SHARED hillshade finite-diff epsilon — pinned ONCE, consumed by both shaders + this
+ *  oracle (challenge R8: a per-backend `e` drift would red L6). */
+export declare const HILLSHADE_EPSILON = 0.012;
+/** The hypsometric tone — expands the compressed height band so basins+ridges hit the ramp
+ *  ENDS. `tone = 0.5 + 0.5·tanh(H·toneGain)`. Maps un-normalized H → [0,1] palette param. */
+export declare function toneFromHeight(H: number, toneGain: number): number;
+/** The analytic hillshade at domain `p` — one ∇H finite-diff at the SHARED `e`, dotted with
+ *  the fixed cel light → [0,1] (0.5 = flat). A read-only re-sample of `sampleHeight`. */
+export declare function hillshade(p: Vec2, t: number, q: LevelFieldParams, lightDir: Vec2): number;
+/** The two-tier index test — a PURE `f(level)` (floor + mod + threshold), stateless, no
+ *  buffer. Returns 1.0 on an index (every `indexEvery`th) level, else 0.0. */
+export declare function isIndexLevel(fN: number, indexEvery: number): number;

package/dist/components/custom/concentric/composables/uniformBridgeWGPU.d.ts

@@ -1,7 +1,8 @@
 import type { OklchStop } from "../../../../composables/color";
 import { type ConcentricConfig } from "../constants";
+import type { Vec2 } from "./levelField";
 export declare const CONCENTRIC_UNIFORM_BYTES: number;
-/** The field-amplitude normalization scale (field → [0,1] for the palette ramp). */
+/** The height-amplitude normalization scale (height → [0,1] for the topographic ramp). */
 export declare const CONCENTRIC_FIELD_NORM = 0.55;
 export interface ConcentricUniformScratch {
     buffer: ArrayBuffer;
@@ -9,5 +10,8 @@ export interface ConcentricUniformScratch {
     i32: Int32Array;
 }
 export declare function createConcentricScratch(): ConcentricUniformScratch;
-/** Pack the concentric uniforms in place. */
-export declare function packConcentricUniforms(scratch: ConcentricUniformScratch, config: ConcentricConfig, timeSec: number, aspect: number, palette: OklchStop[]): ConcentricUniformScratch;
+/** Pack the concentric uniforms in place. `cursor` is the pointer in DOMAIN space; `amp` the
+ * spring-eased traveling-wave envelope amplitude (PRM → 0); `wellScale` the velocity-HEAVE
+ * multiplier on the cursor well depth+radius (1.0 at rest → grows with pointer speed; JS-side
+ * so the heave costs no uniform lane). */
+export declare function packConcentricUniforms(scratch: ConcentricUniformScratch, config: ConcentricConfig, timeSec: number, aspect: number, palette: OklchStop[], cursor: Vec2, amp: number, wellScale: number): ConcentricUniformScratch;

package/dist/components/custom/concentric/composables/useConcentric.d.ts

@@ -27,9 +27,9 @@ export interface ConcentricHandle {
     dispose: () => void;
 }
 /**
- * Mount the concentric renderer on `canvasRef`. The WebGPU primary + the WebGL2 fallback
- * are BOTH pure fullscreen fragment passes evaluating the SAME radial-Fourier field (the
- * ONE math source `ringField.ts`), so the picker is the only seam. Returns the uniform
+ * Mount the concentric renderer on `canvasRef`. The WebGPU primary + the WebGL2 fallback are
+ * BOTH pure fullscreen fragment passes evaluating the SAME level-set topography (the ONE math
+ * source `levelField.ts` `sampleHeight`), so the picker is the only seam. Returns the uniform
  * lifecycle handle.
  */
 export declare function useConcentric(canvasRef: Ref<HTMLCanvasElement | null>, options: UseConcentricOptions): ConcentricHandle;

package/dist/components/custom/concentric/constants.d.ts

@@ -1,9 +1,4 @@
-import type { RingComponent, RingCenter } from "./composables/ringField";
 import type { OklchStop } from "../../../composables/color";
-/** Compile-time ring-component cap — mirrors the WGSL `MAX_RINGS` #define. */
-export declare const MAX_RINGS = 8;
-/** Compile-time center cap — mirrors the WGSL `MAX_CENTERS` #define. */
-export declare const MAX_CENTERS = 4;
 /** Compile-time palette cap — mirrors the WGSL `MAX_RING_STOPS` #define. */
 export declare const MAX_RING_STOPS = 4;
 /**
@@ -11,33 +6,83 @@ export declare const MAX_RING_STOPS = 4;
  * tunable the demo configurator drives; the SFC resolves it into the uniform table.
  */
 export interface ConcentricConfig {
-    /** The ring origins (1..MAX_CENTERS) — a multi-center sum produces ring interference. */
-    centers: RingCenter[];
-    /** The radial sum-of-sines table (1..MAX_RINGS). */
-    ringComponents: RingComponent[];
-    /** The ellipsoidal-norm axis ratio (a, b) — the 3D-tilt depth implication. */
-    axisRatio: [number, number];
-    /** The ring-travel speed (scales ω). */
+    /** The level-set flow speed (scales the traveling-wave time). */
     speed: number;
+    /** The contour stroke half-width (px units; the IQ line thickness). */
+    lineWidth: number;
+    /** The stroke AA softness (px units; the edge feather). */
+    lineSoftness: number;
+    /** The contour-level count (the iso-line density; 4..24). */
+    contourLevels: number;
+    /** The topography cell pitch (domain units per cell — the contour-warp granularity). */
+    cellSize: number;
+    /** The height-field octaves (LOW → clean nested loops). */
+    heightOctaves: number;
+    /** The height-field seed (a different topography per seed). */
+    heightSeed: number;
+    /** The ω=√(g·k) breathing swell depth — basins inflate/deflate (weight). */
+    swellAmp: number;
+    /** Per-contour wobble depth — the contours wobble independently as the wave flows. */
+    perturbAmp: number;
+    /** Max per-cell twist angle at the wave crest (rad — the cell-warp the contours ride). */
+    twistMax: number;
+    /** Max per-cell shear at the crest. */
+    shearMax: number;
+    /** The traveling-wave front direction (a gentle diagonal). */
+    waveDir: [number, number];
+    /** The crest-band spatial frequency (LOW — cells per crest). */
+    waveK: number;
+    /** The front speed (slow — inertia). */
+    waveOmega: number;
+    /** The crest-band width (a localized front). */
+    waveSigma: number;
+    /** The cursor Gaussian peak depth — the topography HEAVES toward the pointer. */
+    cursorWell: number;
+    /** The hypsometric tone gain — `tone = 0.5 + 0.5·tanh(H·toneGain)` (fills the ramp ends). */
+    toneGain: number;
+    /** The analytic-hillshade relief depth (`fill *= mix(1-shadeAmp, 1+shadeAmp, shade)`). */
+    shadeAmp: number;
+    /** The fixed cartoon-sun direction (the raking cel light dotted with ∇H). */
+    lightDir: [number, number];
+    /** Index-contour stride — every Nth level is a bold index line (two-tier hierarchy). */
+    indexEvery: number;
+    /** The index-line width multiplier (index ~indexMul× the minor half-width). */
+    indexMul: number;
+    /** The ink darken factor — the contour is a darker ember of its OWN local fill band. */
+    inkDarken: number;
+    /** Cursor-HEAVE gain — pointer SPEED scales the well depth/radius (JS-side; free). */
+    velocityHeave: number;
     /** The field-value color ramp (the demo themes it); resolved via the ColorResolver. */
     palette: OklchStop[];
-    /** The ground color (default transparent so it reads over the page; demo sets it). */
+    /** The opaque warm hypsometric ground (the survey reads standalone; per-mode resolved). */
     background: OklchStop | "transparent";
-    /** Pointer adds a transient ring center (a local perturbation about the cursor). */
+    /** Pointer HEAVES the topography (gravity over the contour map). */
     interactive: boolean;
-    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
+    /** ONE static survey frame then park under `prefers-reduced-motion: reduce`. */
     respectReducedMotion: boolean;
 }
 /**
- * The warm-cream identity palette (the library default — NOT a themed hue). A three-stop
- * warm ramp over the warm-cream foreground family, resolved via the ColorResolver: a soft
- * cream trough, a warm amber mid, a deeper ember crest — so the ring field reads as warm
- * light interference. A consumer (the demo) themes it through a PRESET, never a token edit.
+ * The WARM-DIVERGENT light identity — a true multi-warm hypsometric tint (NOT a mono-amber
+ * wash). Four stops spanning the warm wheel from a deep plum-rose basin through ember and
+ * amber to a wheat ridge crest. Every hue wraps through red — none lands in the teal/navy
+ * purge band [180,270]. Resolved via the ColorResolver; a consumer (the demo) themes it
+ * through a PRESET, never a token edit.
  */
 export declare const WARM_IDENTITY_PALETTE: OklchStop[];
-/** The default 5-octave Phillips radial ring ladder. */
-export declare const DEFAULT_RING_COMPONENTS: RingComponent[];
-/** Two ring families offset on the diagonal — the default interference (a moiré beat). */
-export declare const DEFAULT_CENTERS: RingCenter[];
-/** The shipped warm-identity default config. */
+/**
+ * The WARM-DIVERGENT dark identity — the survey-at-night twin (plain per-mode arm, NOT a
+ * CSS `light-dark()` branch, NOT an in-shader `uMode` seam). A deep ember basin glowing up
+ * to a luminous amber ridge ladder. Hues stay warm [330..90] — never teal/navy.
+ */
+export declare const WARM_IDENTITY_PALETTE_DARK: OklchStop[];
+/** The per-mode warm hypsometric GROUND (the opaque floor; resolved off `useGlobalDark`). */
+export declare const WARM_GROUND_LIGHT: OklchStop;
+export declare const WARM_GROUND_DARK: OklchStop;
+/**
+ * The shipped warm-identity default config — a living LEVEL-SET hypsometric SURVEY (paper-grid
+ * kin): the iso-contours of a low-octave curl-warped height field, painted as an opaque warm
+ * hypsometric fill, hillshaded into 2.5-D relief, inked with a two-tier index/minor contour
+ * hierarchy, the cursor HEAVING the sheet with velocity-scaled weight. Reads standalone in
+ * BOTH modes — it CONTRIBUTES a colorful field rather than revealing a flat plate.
+ */
 export declare const DEFAULT_CONCENTRIC_CONFIG: ConcentricConfig;

package/dist/components/custom/concentric/index.d.ts

@@ -1,5 +1,5 @@
 export { default as Concentric } from "./Concentric.vue";
 export { useConcentric, type ConcentricHandle, type UseConcentricOptions, } from "./composables/useConcentric";
-export { type ConcentricConfig, DEFAULT_CONCENTRIC_CONFIG, DEFAULT_RING_COMPONENTS, DEFAULT_CENTERS, WARM_IDENTITY_PALETTE, MAX_RINGS, MAX_CENTERS, MAX_RING_STOPS, } from "./constants";
-export { type RingComponent, type RingCenter, type Vec2, sampleRingField, ellipsoidalRadius, buildRingLadder, RING_GRAVITY, } from "./composables/ringField";
+export { type ConcentricConfig, DEFAULT_CONCENTRIC_CONFIG, WARM_IDENTITY_PALETTE, WARM_IDENTITY_PALETTE_DARK, WARM_GROUND_LIGHT, WARM_GROUND_DARK, MAX_RING_STOPS, } from "./constants";
+export { type Vec2, type LevelFieldParams, sampleHeight, toneFromHeight, hillshade, isIndexLevel, HILLSHADE_EPSILON, } from "./composables/levelField";
 export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/concentric/shaders/concentric.glsl.d.ts

@@ -1,4 +1,4 @@
 /** The full-screen-triangle vertex shader (the substrate's standard fullscreen pass). */
 export declare const CONCENTRIC_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]\u00B2 domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
-/** The concentric fragment source — the aurora-class radial-Fourier field. */
-export declare const CONCENTRIC_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define PI 3.141592653589793\n#define TAU 6.283185307179586\n#define RING_GRAVITY 9.81\n#define MAX_RINGS 8\n#define MAX_CENTERS 4\n#define MAX_RING_STOPS 4\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uSpeed;\nuniform vec2  uAxis;          // (a, b) ellipsoidal-norm axis ratio\nuniform float uFieldNorm;     // field \u2192 [0,1] amplitude scale\nuniform float uAspect;\nuniform int   uCenterCount;\nuniform int   uRingCount;\nuniform int   uStopCount;\nuniform float uHasBackground;\nuniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)\nuniform vec3  uCenters[MAX_CENTERS]; // (x, y, weight)\nuniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// \u2016p \u2212 c\u2016_e = sqrt((dx/a)\u00B2 + (dy/b)\u00B2) \u2014 transcribes ringField.ts ellipsoidalRadius.\nfloat ellipsoidalRadius(vec2 p, vec2 center, float axisA, float axisB) {\n  float dx = (p.x - center.x) / max(axisA, 1e-4);\n  float dy = (p.y - center.y) / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// f(p,t) \u2014 the multi-center weighted radial sum (transcribes ringField.ts sampleRingField).\nfloat sampleRingField(vec2 p, float t) {\n  float acc = 0.0;\n  for (int j = 0; j < MAX_CENTERS; j++) {\n    if (j >= uCenterCount) break;\n    vec3 cj = uCenters[j];\n    float radius = ellipsoidalRadius(p, cj.xy, uAxis.x, uAxis.y);\n    float centerSum = 0.0;\n    for (int i = 0; i < MAX_RINGS; i++) {\n      if (i >= uRingCount) break;\n      vec3 r = uRings[i];\n      float k = TAU / max(r.y, 1e-4);\n      float omega = sqrt(RING_GRAVITY * k) * uSpeed;\n      float theta = k * radius - omega * t + r.z;\n      centerSum += r.x * sin(theta);\n    }\n    acc += centerSum * cj.z;\n  }\n  return acc;\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nvec3 samplePaletteLin(float t) {\n  if (uStopCount <= 1) return uPalette[0];\n  float n = float(uStopCount);\n  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  int i0 = int(floor(ft));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float f = ft - float(i0);\n  // cube-root LMS (the GLSL chunk inlines cbrt as sign(x)\u00B7pow(|x|,1/3) \u2014 no cbrt3 fn).\n  vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];\n  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];\n  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nvoid main() {\n  float aspect = max(uAspect, 1e-4);\n  vec2 p = vec2(vUv.x * aspect, vUv.y);\n  float raw = sampleRingField(p, uTime);\n  float v = clamp(0.5 + raw * uFieldNorm, 0.0, 1.0);\n  vec3 lin = samplePaletteLin(v);\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n  if (uHasBackground > 0.5) {\n    fragColor = vec4(rgb, 1.0);\n    return;\n  }\n  float alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);\n  fragColor = vec4(rgb * alpha, alpha);\n}";
+/** The concentric fragment source — the level-set contour-map render (paper-grid kin). */
+export declare const CONCENTRIC_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define PI 3.141592653589793\n#define TAU 6.283185307179586\n#define MAX_RING_STOPS 4\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uSpeed;\nuniform float uCellSize;      // the topography cell pitch (the contour-warp granularity)\nuniform float uFieldNorm;     // height \u2192 [0,1] tone scale\nuniform float uAspect;\nuniform int   uStopCount;\nuniform float uHasBackground;\nuniform vec4  uLine;          // (lineHalfWidth, aaSoftness, contourLevels, indexEvery)\nuniform vec2  uLightDir;      // the fixed cel-light direction (folded norm.zw)\nuniform vec3  uBg;            // themed background (linear-sRGB)\nuniform vec4  uWave;          // (waveDirX, waveDirY, waveK, waveOmega)\nuniform vec4  uWave2;         // (waveSigma, twistMax, shearMax, amp)\nuniform vec4  uTopo;          // (heightOctaves, heightSeed, swellAmp, perturbAmp)\nuniform vec4  uCursor;        // (cursorX, cursorY, cursorWell, interactive)\nuniform vec4  uTune;          // (toneGain, shadeAmp, indexMul, inkDarken)\nuniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// The shared curl operator (flow.glsl.ts \u2014 forward-declares potentialFBM).\n\nconst float CURL_EPS = 0.012;\n\n// Scalar fbm potential psi \u2014 the host's noise basis, wrapped so the curl operator is\n// basis-agnostic. A host carrying its own fbm defines this as: return fbm(p);\nfloat potentialFBM(vec2 p);\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nvec2 curlFBM(vec2 p) {\n  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));\n  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);\n  return vec2(g.y, -g.x);\n}\n\n\n// \u2500\u2500 The host noise basis (the SAME quintic-faded value-noise the suite speaks) \u2500\u2500\nfloat hash21(float x, float y) {\n  float px = fract(x * 0.1031);\n  float py = fract(y * 0.1031);\n  float pz = fract(x * 0.1031);\n  float d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);\n  px += d; py += d; pz += d;\n  return fract((px + py) * pz);\n}\nfloat valueNoise(float x, float y) {\n  float ix = floor(x); float iy = floor(y);\n  float fx = x - ix; float fy = y - iy;\n  float ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);\n  float uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);\n  float a = hash21(ix, iy);\n  float b = hash21(ix + 1.0, iy);\n  float c = hash21(ix, iy + 1.0);\n  float d2 = hash21(ix + 1.0, iy + 1.0);\n  return mix(mix(a, b, ux), mix(c, d2, ux), uy);\n}\n// The curl chunk's forward-declared potentialFBM body.\nfloat potentialFBM(vec2 p) {\n  float v = 0.0; float amp = 0.5; float freq = 1.0;\n  float px = p.x; float py = p.y;\n  for (int i = 0; i < 3; i++) {\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; py = ry; freq *= 2.0; amp *= 0.5;\n  }\n  return v;\n}\n\n// The shared traveling-wave CELL-WARP chunk (spliced AFTER valueNoise + potentialFBM + curl).\n\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\n\nfloat smoothstepEdge(float e0, float e1, float x) {\n  float t = clamp((x - e0) / max(e1 - e0, 1e-6), 0.0, 1.0);\n  return t * t * (3.0 - 2.0 * t);\n}\n\n// The level-set height at domain p (transcribes levelField.ts sampleHeight).\nfloat sampleHeight(vec2 p, float t) {\n  // The CONTINUOUS traveling-wave flow warp (no per-cell seam \u2014 the contours flow + twist as\n  // the wave passes OVER and THROUGH them, the SAME wave that twists the paper-grid cells).\n  vec2 g = waveFlow(p, t, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.y, uWave2.w);\n  if (uCursor.w > 0.5) {\n    g = cursorSwirl(g, uCursor.xy, uCursor.z * 0.6, uCellSize * 2.5);\n  }\n  // LOW base frequency \u2192 BROAD nested loops (a readable contour map). Octaves carry detail.\n  float H = heightField(g * 0.9, uTopo.x, uTopo.y);\n  H += uTopo.z * waveSwell(t, uTopo.y);\n  if (uCursor.w > 0.5) {\n    vec2 d = p - uCursor.xy;\n    float d2 = dot(d, d);\n    // The cursor HEAVE \u2014 a SOFT bulge (a Gaussian peak feathered by a smoothstep falloff so\n    // the heave is C1-smooth, NOT a hard-edged quad). The well depth/radius carry the\n    // velocity-HEAVE scale (packed JS-side into uCursor.z).\n    float g0 = exp(-d2 / 0.22);\n    float fall = smoothstepEdge(0.0, 0.55, exp(-d2 / 0.6));\n    H += uCursor.z * g0 * fall;\n  }\n  return H;\n}\n\n// The IQ gradient-free level-set contour ink \u2014 KEPT BYTE-FROZEN (the perfect GPU AA). It is\n// FED the per-level half-width 'hw' (a parameter, NOT a re-derivation). 'aaW' floors against a\n// DPR-aware minimum so the index line stays CONTINUOUS where the heave packs contours.\nfloat contourInk(float fN, float hw) {\n  float band = abs(fract(fN + 0.5) - 0.5);\n  float aaW = max(fwidth(fN), 6e-4);\n  return 1.0 - smoothstepEdge(hw, hw + uLine.y, band / aaW);\n}\n\nvec3 samplePaletteLin(float t) {\n  if (uStopCount <= 1) return uPalette[0];\n  float n = float(uStopCount);\n  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  int i0 = int(floor(ft));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float f = ft - float(i0);\n  vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];\n  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];\n  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n// The SHARED hillshade finite-diff epsilon \u2014 pinned ONCE (mirrors levelField.HILLSHADE_EPSILON\n// + the WGSL twin; a per-backend drift would red the L6 numeric parity).\nconst float HILLSHADE_E = 0.012;\n\nvoid main() {\n  float aspect = max(uAspect, 1e-4);\n  vec2 p = vec2(vUv.x * aspect, vUv.y);\n  float t = uTime * uSpeed;\n  float levels = max(uLine.z, 1.0);\n\n  // The level-set topography (the KEPT field \u2014 the PRIMARY path).\n  float H = sampleHeight(p, t);\n\n  // \u2500\u2500 1. HYPSOMETRIC TONE \u2014 tanh expands the compressed band (basins+ridges hit the ramp ENDS).\n  float tone = 0.5 + 0.5 * tanh(H * uTune.x);\n  vec3 fill = samplePaletteLin(tone);\n\n  // \u2500\u2500 2. ANALYTIC HILLSHADE \u2014 one \u2207H finite-diff at the SHARED e, dotted with the cel light.\n  float e = HILLSHADE_E;\n  float hx = sampleHeight(p + vec2(e, 0.0), t) - sampleHeight(p - vec2(e, 0.0), t);\n  float hy = sampleHeight(p + vec2(0.0, e), t) - sampleHeight(p - vec2(0.0, e), t);\n  vec2 grad = vec2(hx, hy) / (2.0 * e);\n  vec2 L = normalize(uLightDir + vec2(1e-5));\n  float shade = 0.5 + 0.5 * clamp(dot(normalize(grad + vec2(1e-5)), L), -1.0, 1.0);\n  fill *= mix(1.0 - uTune.y, 1.0 + uTune.y, shade);\n\n  // \u2500\u2500 3. TWO-TIER INDEX/MINOR CONTOUR \u2014 isIndex a pure f(level); hw FED to the frozen contourInk.\n  float fN = H * levels + uTopo.w * sin(floor(H * levels) * 2.4 + t * 0.7);\n  float indexEvery = max(uLine.w, 1.0);\n  float lvl = floor(fN);\n  float isIndex = fract(lvl / indexEvery) < (0.5 / indexEvery) ? 1.0 : 0.0;\n  float hw = mix(uLine.x, uLine.x * uTune.z, isIndex);\n  float ink = clamp(contourInk(fN, hw), 0.0, 1.0);\n\n  // \u2500\u2500 4. INK = a darker ember of the LOCAL fill (the edge-of-its-own-band signature).\n  vec3 inkCol = mix(fill, fill * uTune.w, 0.85);\n\n  // \u2500\u2500 5. ONE color path + OPAQUE OUT \u2014 the viz IS the colorful field.\n  vec3 col = mix(fill, inkCol, ink);\n  fragColor = vec4(clamp(linearToSrgb(col), vec3(0.0), vec3(1.0)), 1.0);\n}";

package/dist/components/custom/concentric/shaders/concentric.wgsl.d.ts

@@ -1 +1 @@
-export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst RING_GRAVITY: f32 = 9.81;\nconst MAX_RINGS: i32 = 8;\nconst MAX_CENTERS: i32 = 4;\nconst MAX_RING_STOPS: i32 = 4;\n\n// \u2500\u2500 Concentric uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ConcentricUniforms {\n  // u0: (uTime, uSpeed, uAxisA, uAxisB)\n  u0: vec4<f32>,\n  // ints: (uCenterCount, uRingCount, uStopCount, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb (linear), hasBackground)\n  bg: vec4<f32>,\n  // norm: (uFieldNorm, uAspect, _pad, _pad) \u2014 field \u2192 [0,1] scale\n  norm: vec4<f32>,\n  // each ring row: (amplitude, wavelength, phase, _pad)\n  rings: array<vec4<f32>, 8>,\n  // each center row: (x, y, weight, _pad)\n  centers: array<vec4<f32>, 4>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConcentricUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the\n// viewport from a single 3-vertex draw \u2014 no vertex buffer.\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,  // domain [-1,1]\u00B2, aspect-corrected x\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4<f32>(c, 0.0, 1.0);\n  // aspect-correct so the rings stay circular under the ellipsoidal norm (NOT squashed\n  // by the canvas aspect): widen the domain x by the aspect ratio.\n  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// The ellipsoidal radial distance \u2016p \u2212 c\u2016_e = sqrt((dx/a)\u00B2 + (dy/b)\u00B2). The single radial\n// metric (transcribes ringField.ts ellipsoidalRadius).\nfn ellipsoidalRadius(p: vec2<f32>, center: vec2<f32>, axisA: f32, axisB: f32) -> f32 {\n  let dx = (p.x - center.x) / max(axisA, 1e-4);\n  let dy = (p.y - center.y) / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// The radial-Fourier ring-interference value f(p,t) \u2014 the multi-center weighted sum of\n// radial sinusoids (transcribes ringField.ts sampleRingField line-for-line).\nfn sampleRingField(p: vec2<f32>, t: f32) -> f32 {\n  var acc = 0.0;\n  let speed = u.u0.y;\n  let axisA = u.u0.z;\n  let axisB = u.u0.w;\n  let centerCount = u.ints.x;\n  let ringCount = u.ints.y;\n  for (var j = 0; j < MAX_CENTERS; j = j + 1) {\n    if (j >= centerCount) { break; }\n    let cj = u.centers[j];\n    let radius = ellipsoidalRadius(p, cj.xy, axisA, axisB);\n    var centerSum = 0.0;\n    for (var i = 0; i < MAX_RINGS; i = i + 1) {\n      if (i >= ringCount) { break; }\n      let r = u.rings[i];\n      let k = TAU / max(r.y, 1e-4);\n      // \u03C9 = \u221A(g\u00B7k); speed scales the travel (the shared dispersion law).\n      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let theta = k * radius - omega * t + r.z;\n      centerSum = centerSum + r.x * sin(theta);\n    }\n    acc = acc + centerSum * cj.z;\n  }\n  return acc;\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // aspect-correct the domain x so the rings read circular under the ellipsoidal norm.\n  let aspect = max(u.norm.y, 1e-4);\n  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x;\n\n  let raw = sampleRingField(p, t);\n  // Normalize the field \u2192 [0,1] for the palette ramp (uFieldNorm is the amplitude scale).\n  let v = clamp(0.5 + raw * u.norm.x, 0.0, 1.0);\n\n  let lin = samplePaletteLin(v);\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // Premultiplied-alpha output over the (transparent / themed) ground.\n  let hasBg = u.bg.w;\n  if (hasBg > 0.5) {\n    // opaque themed ground: the field paints fully opaque.\n    return vec4<f32>(rgb, 1.0);\n  }\n  // transparent ground: the field's alpha rides its own brightness so the page reads\n  // through the troughs (the ring crests carry the ink; the calm field is faint).\n  let alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";
+export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst MAX_RING_STOPS: i32 = 4;\n\n// \u2500\u2500 Concentric uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ConcentricUniforms {\n  // u0: (uTime, uSpeed, uCellSize, _pad)\n  u0: vec4<f32>,\n  // ints: (_pad, _pad, uStopCount, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb (linear), hasBackground)\n  bg: vec4<f32>,\n  // norm: (uFieldNorm, uAspect, lightDirX, lightDirY)\n  norm: vec4<f32>,\n  // line: (lineHalfWidth, aaSoftness, contourLevels, indexEvery)\n  line: vec4<f32>,\n  // wave: (waveDirX, waveDirY, waveK, waveOmega)\n  wave: vec4<f32>,\n  // wave2: (waveSigma, twistMax, shearMax, amp)\n  wave2: vec4<f32>,\n  // topo: (heightOctaves, heightSeed, swellAmp, perturbAmp)\n  topo: vec4<f32>,\n  // cursor: (cursorX, cursorY, cursorWell, interactive)\n  cursor: vec4<f32>,\n  // tune: (toneGain, shadeAmp, indexMul, inkDarken)\n  tune: vec4<f32>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConcentricUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Full-screen-triangle (the pilot idiom).\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4<f32>(c, 0.0, 1.0);\n  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// \u2500\u2500 The host noise basis (the SAME quintic-faded value-noise the suite speaks) \u2500\u2500\nfn hash21(x: f32, y: f32) -> f32 {\n  var px = fract(x * 0.1031);\n  var py = fract(y * 0.1031);\n  var pz = fract(x * 0.1031);\n  let d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);\n  px = px + d; py = py + d; pz = pz + d;\n  return fract((px + py) * pz);\n}\nfn valueNoise(x: f32, y: f32) -> f32 {\n  let ix = floor(x); let iy = floor(y);\n  let fx = x - ix; let fy = y - iy;\n  let ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);\n  let uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);\n  let a = hash21(ix, iy);\n  let b = hash21(ix + 1.0, iy);\n  let c = hash21(ix, iy + 1.0);\n  let d2 = hash21(ix + 1.0, iy + 1.0);\n  return mix(mix(a, b, ux), mix(c, d2, ux), uy);\n}\n// The single-octave potential the curl operator wraps + the height field samples.\nfn potentialFBM(p: vec2f) -> f32 {\n  var v = 0.0; var amp = 0.5; var freq = 1.0;\n  var px = p.x; var py = p.y;\n  for (var i = 0; i < 3; i = i + 1) {\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; py = ry; freq = freq * 2.0; amp = amp * 0.5;\n  }\n  return v;\n}\n\n// The shared curl + wave chunks (splice AFTER valueNoise + potentialFBM are declared).\n\nconst CURL_EPS: f32 = 0.012;\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nfn curlFBM(p: vec2f) -> vec2f {\n  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);\n  return vec2f(g.y, -g.x);\n}\n\n\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\n\nfn smoothstepEdge(e0: f32, e1: f32, x: f32) -> f32 {\n  let t = clamp((x - e0) / max(e1 - e0, 1e-6), 0.0, 1.0);\n  return t * t * (3.0 - 2.0 * t);\n}\n\n// The level-set height at domain p (transcribes levelField.ts sampleHeight). The sampling\n// coordinate is cell-twisted (the SAME wave that twists paper-grid cells \u2014 kinship); the\n// height is a low-octave topography + the swell + the cursor peak.\nfn sampleHeight(p: vec2f, t: f32) -> f32 {\n  // The CONTINUOUS traveling-wave flow warp (no per-cell seam \u2014 the contours flow + twist as\n  // the wave passes OVER and THROUGH them, the SAME wave that twists the paper-grid cells).\n  var g = waveFlow(p, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.y, u.wave2.w);\n  if (u.cursor.w > 0.5) {\n    g = cursorSwirl(g, u.cursor.xy, u.cursor.z * 0.6, u.u0.z * 2.5);\n  }\n  // Sample the topography at a LOW base frequency so the basins are BROAD nested loops (a\n  // readable contour map \u2014 not a fine speckle). heightOctaves carries the fractal detail.\n  var H = heightField(g * 0.9, u.topo.x, u.topo.y);\n  H = H + u.topo.z * waveSwell(t, u.topo.y);\n  if (u.cursor.w > 0.5) {\n    let d = p - u.cursor.xy;\n    let d2 = dot(d, d);\n    // The cursor HEAVE \u2014 a SOFT bulge (a Gaussian peak feathered by a smoothstep falloff so\n    // the heave is C1-smooth, NOT the hard-edged quad the old dark render showed). The well\n    // depth/radius already carry the velocity-HEAVE scale (packed JS-side into u.cursor.z).\n    let g0 = exp(-d2 / 0.22);\n    let fall = smoothstepEdge(0.0, 0.55, exp(-d2 / 0.6));\n    H = H + u.cursor.z * g0 * fall;\n  }\n  return H;\n}\n\n// The IQ gradient-free level-set contour ink \u2014 KEPT BYTE-FROZEN (the perfect GPU AA). It is\n// FED the per-level half-width 'hw' (a parameter, NOT a re-derivation): de_contour =\n// |fract(fN + 0.5) \u2212 0.5| / fwidth(fN). The contour density tracks 1/|\u2207H| automatically.\n// 'aaW' floors against a DPR-aware minimum so the index line stays CONTINUOUS where the heave\n// packs contours (steep |\u2207H| saturates fwidth \u2014 challenge R4).\nfn contourInk(fN: f32, hw: f32) -> f32 {\n  let band = abs(fract(fN + 0.5) - 0.5);\n  let aaW = max(fwidth(fN), 6e-4);\n  return 1.0 - smoothstepEdge(hw, hw + u.line.y, band / aaW);\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n// The SHARED hillshade finite-diff epsilon \u2014 pinned ONCE (mirrors levelField.HILLSHADE_EPSILON\n// + the GLSL twin; a per-backend drift would red the L6 numeric parity).\nconst HILLSHADE_E: f32 = 0.012;\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let aspect = max(u.norm.y, 1e-4);\n  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x * u.u0.y;\n  let levels = max(u.line.z, 1.0);\n\n  // The level-set topography (the KEPT field \u2014 the PRIMARY path).\n  let H = sampleHeight(p, t);\n\n  // \u2500\u2500 1. HYPSOMETRIC TONE \u2014 tanh expands the compressed band so basins+ridges hit the ramp\n  //    ENDS (the live lumVar-flat cause). samplePaletteLin is the KEPT OKLab operator.\n  let tone = 0.5 + 0.5 * tanh(H * u.tune.x);\n  var fill = samplePaletteLin(tone);\n\n  // \u2500\u2500 2. ANALYTIC HILLSHADE \u2014 one \u2207H finite-diff at the SHARED e, dotted with the fixed cel\n  //    light \u2192 2.5-D relief. A read-only re-sample of sampleHeight (no second field).\n  let e = HILLSHADE_E;\n  let hx = sampleHeight(p + vec2<f32>(e, 0.0), t) - sampleHeight(p - vec2<f32>(e, 0.0), t);\n  let hy = sampleHeight(p + vec2<f32>(0.0, e), t) - sampleHeight(p - vec2<f32>(0.0, e), t);\n  let grad = vec2<f32>(hx, hy) / (2.0 * e);\n  let L = normalize(u.norm.zw + vec2<f32>(1e-5, 1e-5));\n  let shade = 0.5 + 0.5 * clamp(dot(normalize(grad + vec2<f32>(1e-5)), L), -1.0, 1.0);\n  fill = fill * mix(1.0 - u.tune.y, 1.0 + u.tune.y, shade);\n\n  // \u2500\u2500 3. TWO-TIER INDEX/MINOR CONTOUR \u2014 isIndex a pure f(level) (floor + mod + select, NOT a\n  //    state buffer); the per-level half-width hw is FED to the byte-frozen contourInk.\n  let fN = H * levels + u.topo.w * sin(floor(H * levels) * 2.4 + t * 0.7);\n  let indexEvery = max(u.line.w, 1.0);\n  let lvl = floor(fN);\n  let isIndex = select(0.0, 1.0, fract(lvl / indexEvery) < (0.5 / indexEvery));\n  let hw = mix(u.line.x, u.line.x * u.tune.z, isIndex);\n  let ink = clamp(contourInk(fN, hw), 0.0, 1.0);\n\n  // \u2500\u2500 4. INK = a darker ember of the LOCAL fill (the edge-of-its-own-band signature).\n  let inkCol = mix(fill, fill * u.tune.w, 0.85);\n\n  // \u2500\u2500 5. ONE color path + OPAQUE OUT \u2014 the viz IS the colorful field, never lines-over-nothing.\n  //    Per-mode is resolved in the CONSUMED stops + the bg token (no in-shader uMode branch).\n  let col = mix(fill, inkCol, ink);\n  return vec4<f32>(clamp(linearToSrgb(col), vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);\n}\n";

package/dist/components/custom/configurator/Configurator.vue.d.ts

@@ -23,6 +23,20 @@ export type ConfiguratorScrollMode = "auto" | "always" | "never";
  * Below `lg` the layout is a single column and the side has no meaning.
  */
 export type ConfiguratorAsideSide = "left" | "right";
+/**
+ * Where the preset gallery sits.
+ *
+ * `aside` (default) keeps the preset row inside the right-hand aside (the
+ * inspector idiom — the legacy placement, unchanged).
+ *
+ * `top` lifts the gallery OUT of the 360px aside and pins it as a large,
+ * full-width, horizontally-scrollable glass dock across the TOP of the studio
+ * frame — the §2.1 reflow (gallery up-top + larger + scrollable). The stage +
+ * controls reclaim the full height below it. An additive axis: the grid arm is
+ * the precompiled `[data-slot=configurator][data-gallery=top]` rule in
+ * configurator.css (never a dead JIT bracket — the BC.W-CONFIG-RIGHT lesson).
+ */
+export type ConfiguratorGalleryPlacement = "aside" | "top";
 /**
  * Generic preset descriptor. Consumers pass `T` as the live config shape.
  * The primitive carries no preset semantics beyond `key + label` for
@@ -68,6 +82,13 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
          * stays stage→aside. No effect below `lg` (single-column).
          */
         asideSide?: ConfiguratorAsideSide;
+        /**
+         * Where the preset gallery sits. Default `"aside"` (the inspector idiom).
+         * `"top"` pins the gallery as a large full-width scrollable glass dock
+         * across the top of the studio (the §2.1 up-top reflow), driven by the
+         * precompiled `[data-gallery="top"]` rule in configurator.css.
+         */
+        galleryPlacement?: ConfiguratorGalleryPlacement;
         /**
          * Aside width band at `lg`+ width, as a CSS length pair driving
          * `minmax(--configurator-aside-min, --configurator-aside-max)`. The
@@ -89,12 +110,12 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     expose: (exposed: {}) => void;
     attrs: any;
     slots: {
-        stage?: (props: {}) => any;
-    } & {
         presets?: (props: {
             presets: readonly ConfiguratorPreset<T>[] | undefined;
             activePreset: string | undefined;
         }) => any;
+    } & {
+        stage?: (props: {}) => any;
     } & {
         controls?: (props: {
             layers: readonly {

package/dist/components/custom/configurator/index.d.ts

@@ -1,6 +1,6 @@
 export { default as Configurator } from "./Configurator.vue";
 export { default as ConfiguratorLayer } from "./ConfiguratorLayer.vue";
 export { default as ConfiguratorRow } from "./ConfiguratorRow.vue";
-export type { ConfiguratorAsideSide, ConfiguratorPreset, ConfiguratorScrollMode, } from "./Configurator.vue";
+export type { ConfiguratorAsideSide, ConfiguratorGalleryPlacement, ConfiguratorPreset, ConfiguratorScrollMode, } from "./Configurator.vue";
 export { CONFIGURATOR_DENSITY_KEY, provideConfiguratorDensity, useOptionalConfiguratorDensity, type ConfiguratorDensity, } from "./density";
 export { useConfiguratorState, type ConfiguratorCloneMode, type ConfiguratorState, type ConfiguratorStateOptions, } from "./useConfiguratorState";