@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/components/custom/aurora/constants/shaders/flow.glsl.d.ts

@@ -1 +0,0 @@
-export declare const AURORA_FLOW_GLSL = "// \u2500\u2500 Flow field \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Structure-tensor prototype (body defined post-sampleBase in the mediums block).\n// Returns vec3(dir.x, dir.y, coherence) \u2014 the minor-eigenvector tangent + A.\nvec3 structureTensorField(vec2 p, float t, vec2 fallbackDir);\n\nvec2 flowField(vec2 p, float t) {\n  vec2 dir = vec2(1.0, 0.0);\n  if (uFlowPattern == 1) {\n    // radial\n    dir = normalize(p - uFlowFocal + 1e-4);\n  } else if (uFlowPattern == 2) {\n    // swirl \u2014 tangent to radial\n    vec2 rad = normalize(p - uFlowFocal + 1e-4);\n    dir = vec2(-rad.y, rad.x);\n  } else if (uFlowPattern == 3) {\n    // diagonal\n    float a = radians(uFlowAngle);\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 4) {\n    // multi \u2014 curl-noise driven\n    float n = fbm(p * 2.0 + t * 0.02);\n    float a = n * 6.2831;\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 5) {\n    // tensor / ETF \u2014 the color field's OWN edge-tangent flow (AW.W4.1). The\n    // diagonal angle seeds the smooth fallback the coherence-weighted blend\n    // relaxes toward in low-structure zones. Returns directly (no curl/cursor\n    // post-mix \u2014 the tensor field already carries the structure orientation;\n    // the cursor warp still drives the underlying color field in domainWarp).\n    float a = radians(uFlowAngle);\n    vec2 fallback = vec2(cos(a), sin(a));\n    return structureTensorField(p, t, fallback).xy;\n  }\n  // curl \u2014 perturb by noise. Radial gets much less curl so rays stay clean.\n  if (uFlowCurl > 0.0) {\n    float n = fbm(p * 3.0) - 0.5;\n    float curlAmt = uFlowCurl;\n    if (uFlowPattern == 1) curlAmt *= 0.25;  // radial: preserve ray clarity\n    if (uFlowPattern == 2) curlAmt *= 0.55;  // swirl: allow moderate curl\n    float a = atan(dir.y, dir.x) + n * 3.14159 * curlAmt;\n    dir = vec2(cos(a), sin(a));\n  }\n  // cursor influence \u2014 swirl around the cursor position\n  if (uCursorStrength > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.5));\n    // swirl tangent\n    vec2 tangent = vec2(-toCur.y, toCur.x) / max(d, 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(tangent.y, tangent.x);\n    // blend angle\n    float da = a1 - a0;\n    da = atan(sin(da), cos(da)); // wrap to [-pi, pi]\n    float a = a0 + da * w * uCursorStrength;\n    dir = vec2(cos(a), sin(a));\n  }\n  // AW.W8.1 \u2014 velocity-reactive swirl-BURST: a fast flick (uCursorBurst, decaying\n  // over ~1s) injects a transient flow bias along the pointer velocity, distinct from\n  // the steady attraction above (the stateless swirl is SUPERSEDED by this form). The\n  // burst is gated by the master tempo scalar on the CPU side (it decays to 0 under\n  // PRM/pause), so this term cannot leak motion under reduced-motion.\n  if (uCursorBurst > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.7));\n    // Bias the flow toward the velocity direction, scaled by the decaying burst.\n    vec2 velDir = uCursorVelocity / max(length(uCursorVelocity), 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(velDir.y, velDir.x);\n    float da = atan(sin(a1 - a0), cos(a1 - a0));\n    float a = a0 + da * w * uCursorBurst * 0.8;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n";

package/dist/components/custom/aurora/constants/shaders/mediums.glsl.d.ts

@@ -1,2 +0,0 @@
-export declare const AURORA_MEDIUMS_PRE_BRUSH_GLSL = "// \u2500\u2500 Medium overlays \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// A quick re-computation of base color for edge-mask sampling\nvec3 sampleBase(vec2 p, float t) {\n  vec2 pw = domainWarp(p, t);\n  float id; float vm;\n  nucleiField(pw, t, id, vm);\n  vec3 c = samplePalette(id);\n  c *= 1.0 + uValueVariance * vm;\n  return c;\n}\n\n// \u2500\u2500 Structure-tensor / edge-tangent-flow (AW.W4.1) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The keystone of the painterly engine: derive stroke orientation from the COLOR\n// FIELD's OWN structure, not a hand-authored flow pattern. A 3x3 Sobel over\n// luma(sampleBase) yields the gradient (Gx,Gy); the 2x2 structure tensor\n// J = [[Gx\u00B2, GxGy],[GxGy, Gy\u00B2]] eigen-decomposes closed-form into the MINOR\n// eigenvector (the edge-TANGENT \u2014 least color change, the stroke direction; the\n// MAJOR eigenvector is the gradient/edge-NORMAL and would make strokes cross the\n// bands) and the coherence A = (\u03BB1-\u03BB2)/(\u03BB1+\u03BB2). Low-coherence (flat) zones relax\n// toward the smooth fallbackDir by (1-A) so tensor noise never reads as jitter.\n// Single-pass small-tap WebGL2 form; the Gaussian-smoothed multi-tap + LIC smear\n// is the AW.W7 WebGPU multi-pass fold. Returns vec3(tangent.x, tangent.y, A).\nvec3 structureTensorField(vec2 p, float t, vec2 fallbackDir) {\n  float e = 0.0035; // small-tap neighborhood (edge-mask scale)\n  // 3x3 luma samples.\n  float l00 = dot(sampleBase(p + vec2(-e, -e), t), W_LUMA);\n  float l10 = dot(sampleBase(p + vec2( 0.0, -e), t), W_LUMA);\n  float l20 = dot(sampleBase(p + vec2( e, -e), t), W_LUMA);\n  float l01 = dot(sampleBase(p + vec2(-e, 0.0), t), W_LUMA);\n  float l21 = dot(sampleBase(p + vec2( e, 0.0), t), W_LUMA);\n  float l02 = dot(sampleBase(p + vec2(-e, e), t), W_LUMA);\n  float l12 = dot(sampleBase(p + vec2( 0.0, e), t), W_LUMA);\n  float l22 = dot(sampleBase(p + vec2( e, e), t), W_LUMA);\n  // Sobel derivatives.\n  float Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);\n  float Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);\n  // Structure tensor components.\n  float Jxx = Gx * Gx;\n  float Jyy = Gy * Gy;\n  float Jxy = Gx * Gy;\n  // Closed-form 2x2 eigenvalues: \u03BB = 0.5(tr \u00B1 sqrt((Jxx-Jyy)\u00B2 + 4Jxy\u00B2)).\n  float tr = Jxx + Jyy;\n  float disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));\n  float lambdaMaj = 0.5 * (tr + disc);\n  float lambdaMin = 0.5 * (tr - disc);\n  // The MAJOR eigenvector points along the gradient (the edge NORMAL); the MINOR\n  // is its perpendicular \u2014 the edge TANGENT (the stroke direction). The principal\n  // angle is \u03B8 = 0.5\u00B7atan2(2\u00B7Jxy, Jxx-Jyy); this form is robust at Jxy\u22480 (where the\n  // (\u03BB-Jyy, Jxy) eigenvector formula collapses to a zero vector). The tangent is at\n  // \u03B8 + 90\u00B0. Guard the fully-isotropic (no-gradient) degenerate case \u2192 fallback dir.\n  vec2 tangent;\n  if (disc < 1e-7) {\n    tangent = fallbackDir;\n  } else {\n    float theta = 0.5 * atan(2.0 * Jxy, Jxx - Jyy); // major (gradient) angle\n    tangent = vec2(-sin(theta), cos(theta));          // perpendicular = tangent\n  }\n  // Coherence A in [0,1] \u2014 high where one eigenvalue dominates (a strong edge),\n  // ~0 in flat zones. Relax toward the smooth fallback by (1 - A).\n  float A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);\n  A = clamp(A, 0.0, 1.0);\n  // Coherence-weighted blend: full tensor in coherent zones, smooth in flat ones.\n  // Resolve the 180\u00B0 sign ambiguity toward the fallback so the blend is continuous.\n  if (dot(tangent, fallbackDir) < 0.0) tangent = -tangent;\n  // The blend weight is a low-power curve (A^0.35) so even MODERATE-coherence zones queue\n  // strongly along the tangent (a flowing van-Gogh band reads coherent the way the\n  // structure-tensor metric measures it; a linear A under-orients the mid-band and the\n  // rendered field reads too isotropic \u2014 the \u00A74.2 anisotropy lift). The flat-zone (A\u22480)\n  // relax to the fallback survives (0^0.35=0), so tensor noise never reads as jitter.\n  float blendW = pow(A, 0.28);\n  vec2 dir = normalize(mix(fallbackDir, tangent, blendW) + 1e-6);\n  return vec3(dir, A);\n}\n\nvec3 mediumWatercolor(vec3 col, vec2 p, float t) {\n  // Wet-edge cauliflowers via luma-gradient magnitude\n  float eps = 0.004;\n  vec3 cx1 = sampleBase(p + vec2(eps, 0.0), t);\n  vec3 cx2 = sampleBase(p - vec2(eps, 0.0), t);\n  vec3 cy1 = sampleBase(p + vec2(0.0, eps), t);\n  vec3 cy2 = sampleBase(p - vec2(0.0, eps), t);\n  float gx = dot(cx1 - cx2, W_LUMA);\n  float gy = dot(cy1 - cy2, W_LUMA);\n  float edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  float mask = smoothstep(0.0, 2.5, edge);\n  col *= mix(1.0, 0.78, mask * uWetEdge);\n\n  // Granulation \u2014 pigment settles in paper tooth\n  float paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  float pigLoad = 1.0 - dot(col, W_LUMA);\n  col *= 1.0 - uGranulation * pigLoad * (paper - 0.5);\n\n  // Wash banding \u2014 faint horizontal wet gradient\n  float band = fbm(vec2(p.x * 1.5, p.y * 0.4));\n  col *= 1.0 + 0.04 * (band - 0.5);\n  return col;\n}\n\nvec3 mediumPastel(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  vec2 perp = vec2(-flow.y, flow.x);\n  float along  = dot(p, flow) * uStrokeScale;\n  float across = dot(p, perp) * uStrokeScale;\n  across += 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  float aniso = mix(1.0, 0.18, uStrokeAnisotropy);\n  float stroke = fbm(vec2(along * aniso, across));\n  col *= mix(1.0, 0.82 + 0.32 * stroke, uStrokeAmount);\n\n  // Pastel tooth \u2014 tiny high-frequency grain\n  float tooth = vnoise(p * 800.0);\n  col *= 1.0 - 0.08 * uStrokeAmount * (tooth - 0.5);\n  return col;\n}\n";
-export declare const AURORA_MEDIUMS_POST_BRUSH_GLSL: string;

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

@@ -1,13 +0,0 @@
-export { default as Aurora } from "./Aurora.vue";
-export { resolveRenderMode, isSoftwareWebGLRenderer, type AuroraRenderMode, type ResolveRenderModeOptions, } from "./constants/renderMode";
-export { useAurora } from "./composables/useAurora";
-export type { UseAuroraReturn } from "./composables/useAurora";
-export { useCursorInteraction } from "./composables/useCursorInteraction";
-export { createAurora } from "./composables/runtime";
-export type { AuroraRuntimeMode, AuroraRuntimeOptions } from "./composables/runtime";
-export { DEFAULT_AURORA_CONFIG, PAPER_WASH_GROUND, DEFAULT_VIVIDNESS, VIVID_TARGET, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraInteractivity, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type StrokeOrient, type WarpMode, } from "./constants/presets";
-export { resolveAtoms, configToAtoms, nucleiPrior, DEFAULT_ATOMS, type AuroraAtoms, type AuroraMotionAtom, type AuroraZones, type AuroraZoneArrangement, type AuroraMediumAtom, type AuroraInteractivityAtom, } from "./composables/atoms";
-export { cssToOklch, deriveAurora, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
-export { auroraFallbackGround, sampleAuroraField, nucleiFieldStatic, relativeLuminance, type AuroraFallbackGround, type AuroraFallbackGroundOptions, type AuroraGroundMetrics, } from "./composables/auroraFallbackGround";
-export type { AuroraHarmony, DeriveAuroraOptions, DeriveEasing, } from "./composables/color";
-export type { AuroraHuePath } from "./constants/presets";

package/dist/components/custom/border-progress/BorderProgress.vue.d.ts

@@ -1,46 +0,0 @@
-import { type BorderProgressCoverage, type BorderProgressMilestone, type BorderProgressMilestoneEvent } from "./constants";
-export interface BorderProgressProps {
-    /** The progress scalar. 0..1 (or 0..`max`) drives the registered conic angle. */
-    value: number;
-    /** The value-axis ceiling. Default `1` (a 0..1 scalar; pass `100` for percent). */
-    max?: number;
-    /** `full-ring` (default) sweeps the perimeter; `bottom-edge` paints only the bottom band. */
-    coverage?: BorderProgressCoverage;
-    /**
-     * The conic color stops — CSS color strings. Default the LIBRARY brand ramp
-     * (the `--section-color-*`/`--viz-*` tokens, resolved in the cascade). A
-     * consumer passes its OWN phase palette (presets-in-consumers — no consumer
-     * hue enters a library token). CONCRETE anchors are walked OKLCH/shorter-hue;
-     * `var(--…)` token anchors pass through to the live cascade.
-     */
-    stops?: readonly string[];
-    /** The ring thickness in px (default within the 10-14px envelope). */
-    width?: number;
-    /** The host border-radius in px the ring follows. Default 16. */
-    radius?: number;
-    /**
-     * Phase-edge boundaries. The ring fires `milestone` + (PRM-gated) pulses when
-     * `value` crosses one. The consumer owns the phase colors (the chassis
-     * `--phase-color` cascade precedent — the milestone is the EVENT seam).
-     */
-    milestones?: readonly BorderProgressMilestone[];
-    /** Pass-through class on the root. */
-    class?: string;
-}
-declare var __VLS_1: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<BorderProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    milestone: (event: BorderProgressMilestoneEvent) => any;
-}, string, import("vue").PublicProps, Readonly<BorderProgressProps> & Readonly<{
-    onMilestone?: ((event: BorderProgressMilestoneEvent) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/custom/border-progress/composables/spectrum-walk.d.ts

@@ -1,25 +0,0 @@
-import { type OklchStop } from "../../../../composables/color";
-/**
- * Walk the anchor ramp to the single OKLCh stop at parameter `t` (0..1) via the
- * shorter-hue arc — the segment is located, then value.js's `mixColors` runs the
- * OKLCh/shorter-hue perceptual mix at the in-segment fraction (the single-point
- * twin of `sampleColorRamp`; ONE color source — value.js). L/C lerp in OKLCh and
- * the hue walks the SHORTER arc, so the warm→cool midpoint keeps its chroma.
- *
- * Deterministic + DOM-free (SSR-safe; mirrors `deriveBlobPalette`).
- */
-export declare function spectrumAt(stops: readonly OklchStop[], t: number): OklchStop;
-/**
- * Walk a CONCRETE-anchor ramp to `count` evenly-spaced HEX stops — the perceptual
- * (OKLCH/shorter-hue) cold path. The caller (`spectrumStops` in the sync shell) has
- * already screened out `var(--…)` ramps, so every stop here is a CONCRETE CSS color
- * the leaf's `cssToOklch` parses to OKLCh; the walk carries no chroma trough.
- *
- * Each adjacent anchor pair is one `sampleColorRamp` segment (the value.js grid
- * sampler walked SHORTER-hue in OKLCh); the per-segment grids concatenate (shared
- * boundary deduped) into one continuous `count`-stop ramp. The endpoints anchor the
- * input exactly; the hue walks the shorter arc end-to-end, so no segment greys out.
- *
- * @returns one HEX (`#rrggbb`) per stop.
- */
-export declare function walkConcreteSpectrum(stops: readonly string[], count: number): string[];

package/dist/components/custom/border-progress/composables/useBorderSpectrum.d.ts

@@ -1,18 +0,0 @@
-/** A consumer-supplied callback the COLD path calls once the perceptual walk resolves. */
-export type SpectrumUpgrade = (stops: string[]) => void;
-/**
- * Produce `samples` evenly-spaced HEX/CSS stops across the anchor ramp — the conic
- * gradient's color stops. CSS `var(--…)` tokens (the LIBRARY-default brand ramp) are
- * passed through UNTOUCHED (they resolve in the cascade at paint — the value.js-free
- * fast path). CONCRETE color anchors return the synchronous interim immediately AND,
- * when `onUpgrade` is supplied, load `./spectrum-walk` and upgrade to the OKLCH/
- * shorter-hue perceptual walk once the dynamic chunk resolves.
- *
- * `spectrumStops` is SYNCHRONOUS (the SFC's `computed` cannot await). The dynamic
- * boundary lives INSIDE it (the value.js branch fires `import()` and returns the
- * synchronous interim), never on the export signature.
- *
- * @returns one stop per sample — `var()` strings for a token ramp, the raw anchors
- *   for the concrete-anchor synchronous interim (upgraded to HEX via `onUpgrade`).
- */
-export declare function spectrumStops(stops: readonly string[], samples?: number, onUpgrade?: SpectrumUpgrade): string[];

package/dist/components/custom/border-progress/constants.d.ts

@@ -1,59 +0,0 @@
-/**
- * The coverage axis — `full-ring` sweeps the entire border perimeter,
- * `bottom-edge` paints ONLY the bottom border band (the literal C2 case: "the
- * bottom progressbar should serve as a thicker, dynamic BORDER"). The two
- * coverages share the ONE conic-mask mechanism (a `coverage`-scoped mask
- * region — NOT a second recipe).
- */
-export type BorderProgressCoverage = "full-ring" | "bottom-edge";
-/**
- * The thickness envelope (px). AMENDED 6-8px → 10-14px (speedtest AW v3 relay
- * A1, 2026-06-17): the thin-hairline 6-8px read as a rim, not the "thicker,
- * dynamic BORDER" the ask wants. The gate W4 + the π assert the band sits inside
- * [10, 14].
- */
-export declare const BORDER_PROGRESS_WIDTH_MIN = 10;
-export declare const BORDER_PROGRESS_WIDTH_MAX = 14;
-/** The default ring thickness — the centre of the 10-14px envelope. */
-export declare const BORDER_PROGRESS_WIDTH_DEFAULT = 12;
-/** The default host border-radius (px) the ring follows when unset by the consumer. */
-export declare const BORDER_PROGRESS_RADIUS_DEFAULT = 16;
-/**
- * The number of conic stops the spectrum walk samples between the consumer's
- * anchor stops. A denser sample yields a smoother sweep with no visible banding;
- * the OKLCH/shorter-hue arc keeps every sample saturated (no chroma trough).
- */
-export declare const BORDER_PROGRESS_SPECTRUM_SAMPLES = 24;
-/**
- * The LIBRARY-identity default spectrum — the section/viz brand ramp (the
- * `--section-color-*` 13-stop ramp + the `--viz-*` twins). These resolve through
- * the CSS token cascade at paint, so the default carries no baked hue; a consumer
- * that wants its OWN phase palette passes its stops as the `stops` prop
- * (presets-in-consumers — NO speedtest/ppmycota hue enters a library token).
- *
- * The default is a warm→cool brand arc (rose → indigo → violet) sampled off the
- * 13-stop ramp so the resting ring already reads as "a spectrum of our colors".
- */
-export declare const BORDER_PROGRESS_DEFAULT_SPECTRUM: readonly string[];
-/**
- * A phase-edge milestone descriptor — the consumer declares phase boundaries on
- * the 0..1 (or 0..100) value axis; the ring fires a `milestone` event + (PRM-
- * gated) pulses when the value crosses one. The chassis `--phase-color` cascade
- * is the precedent (the bus carries phase IDENTITY; the milestone is the EVENT
- * seam — the consumer owns the phase colors, presets-in-consumers).
- */
-export interface BorderProgressMilestone {
-    /** The value-axis boundary (in the same units as `value`). */
-    at: number;
-    /** An opaque id echoed back on the `milestone` emit. */
-    id: string;
-    /** An optional label echoed back on the emit (analytics / a11y). */
-    label?: string;
-}
-/** The payload of the `milestone` emit — the crossed edge + the value at crossing. */
-export interface BorderProgressMilestoneEvent {
-    /** The crossed milestone descriptor. */
-    milestone: BorderProgressMilestone;
-    /** The value at the moment of crossing (post-update). */
-    value: number;
-}

package/dist/components/custom/border-progress/index.d.ts

@@ -1,4 +0,0 @@
-export { default as BorderProgress } from "./BorderProgress.vue";
-export type { BorderProgressProps } from "./BorderProgress.vue";
-export type { BorderProgressCoverage, BorderProgressMilestone, BorderProgressMilestoneEvent, } from "./constants";
-export { spectrumStops, type SpectrumUpgrade } from "./composables/useBorderSpectrum";

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

@@ -1,21 +0,0 @@
-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/constants.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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/concentric/Concentric.vue.d.ts

@@ -1,42 +0,0 @@
-import type { ConcentricConfig } from "./constants";
-/**
- * Concentric — a living LEVEL-SET hypsometric SURVEY (paper-grid kin, BD.W-CONCENTRIC-RELIEF).
- *
- * 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 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). */
-    config?: ConcentricConfig;
-    /**
-     * The declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the render loop
-     * (the substrate's `manual` suspend) when `true`. Wire `<DockBackgroundToggle>`'s
-     * `@update:paused` to this `v-model`.
-     */
-    paused?: boolean;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    pause: () => void;
-    resume: () => void;
-    wake: () => void;
-    renderAt: (timeSec: number) => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:paused": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

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

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

@@ -1,50 +0,0 @@
-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,17 +0,0 @@
-import type { OklchStop } from "../../../../composables/color";
-import { type ConcentricConfig } from "../constants";
-import type { Vec2 } from "./levelField";
-export declare const CONCENTRIC_UNIFORM_BYTES: number;
-/** 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;
-    f32: Float32Array;
-    i32: Int32Array;
-}
-export declare function createConcentricScratch(): 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

@@ -1,35 +0,0 @@
-import { type Ref } from "vue";
-import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
-import type { OklchStop } from "../../../../composables/color";
-import type { ConcentricConfig } from "../constants";
-export interface UseConcentricOptions {
-    config: ConcentricConfig;
-    /** Resolve the field-value palette as OKLCh (the demo themes it; default warm-identity). */
-    getPalette: () => OklchStop[];
-    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
-    mode?: "live" | "capture";
-}
-/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
-export interface ConcentricHandle {
-    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 GLSL fallback). */
-    readonly backend: GpuBackend;
-    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
-    pause: () => void;
-    /** Re-arm the loop. */
-    resume: () => void;
-    /** Re-arm a parked loop on demand. */
-    wake: () => void;
-    /** Draw one frame out-of-loop (capture / thumbnail). */
-    renderAt: (timeSec: number) => void;
-    /** The live `prefers-reduced-motion: reduce` state. */
-    readonly reducedMotion: boolean;
-    /** Tear down the renderer + release GPU/GL resources. */
-    dispose: () => void;
-}
-/**
- * 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,88 +0,0 @@
-import type { OklchStop } from "../../../composables/color";
-/** Compile-time palette cap — mirrors the WGSL `MAX_RING_STOPS` #define. */
-export declare const MAX_RING_STOPS = 4;
-/**
- * The full author schema — the studio's `useConfiguratorState` model. Every field is a
- * tunable the demo configurator drives; the SFC resolves it into the uniform table.
- */
-export interface ConcentricConfig {
-    /** 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 opaque warm hypsometric ground (the survey reads standalone; per-mode resolved). */
-    background: OklchStop | "transparent";
-    /** Pointer HEAVES the topography (gravity over the contour map). */
-    interactive: boolean;
-    /** ONE static survey frame then park under `prefers-reduced-motion: reduce`. */
-    respectReducedMotion: boolean;
-}
-/**
- * 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 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 +0,0 @@
-export { default as Concentric } from "./Concentric.vue";
-export { useConcentric, type ConcentricHandle, type UseConcentricOptions, } from "./composables/useConcentric";
-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 +0,0 @@
-/** 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 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}";