@mkbabb/glass-ui 4.1.0 → 5.0.0

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, 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,39 +0,0 @@
-import type { ConcentricConfig } from "./constants";
-/**
- * Concentric — a radial Fourier ring-interference field.
- *
- * 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 DEFAULT palette is the warm-cream library identity; the demo themes the rings
- * 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,18 +0,0 @@
-import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
-import type { OklchStop } from "../../../../composables/color";
-import { type ConcentricConfig } from "../constants";
-import type { RingCenter } from "./ringField";
-export interface ConcentricGLSetupDeps {
-    canvas: HTMLCanvasElement;
-    config: ConcentricConfig;
-    getPalette: () => OklchStop[];
-    getCenters: () => RingCenter[];
-    shouldContinue: () => boolean;
-    /**
-     * The per-frame pointer hook — useConcentric advances the shared pointer field +
-     * injects the transient cursor center 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,22 +0,0 @@
-import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
-import type { OklchStop } from "../../../../composables/color";
-import type { ConcentricConfig } from "../constants";
-import type { RingCenter } from "./ringField";
-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 render centers (author + the transient pointer center) — re-read each frame. */
-    getCenters: () => RingCenter[];
-    /** 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
-     * mutates `config.centers` to inject the transient cursor ring-family. 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/ringField.d.ts

@@ -1,85 +0,0 @@
-/** A 2-vector. */
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-/**
- * One CLEAN radial ring component. `amplitude` A_i, `wavelength` λ_i (so k_i = 2π/λ_i),
- * `phase` φ_i. `ω_i = √(g·k_i)` is derived from the dispersion relation, not stored (the
- * SAME dispersion the flow field's Gerstner sum uses — the ONE suite dispersion law). A
- * family carries 1–2 clean low frequencies, NEVER a turbulence octave ladder (the noise
- * amplifier that read as a blur).
- */
-export interface RingComponent {
-    amplitude: number;
-    wavelength: number;
-    phase: number;
-}
-/**
- * A ring origin in domain space [-1,1]² (multi-center → interference). `rotAlpha` is the
- * per-family tilt of the ellipsoidal frame (radians) — two families at different tilts cross
- * into rich moiré. It reuses the spare `centers[j].w` uniform lane (no byte-layout change).
- */
-export interface RingCenter {
-    x: number;
-    y: number;
-    /** Per-center weight (a far center contributes a fainter ring family). */
-    weight: number;
-    /** The per-family ellipsoid tilt (radians); 0 = the un-rotated frame. */
-    rotAlpha: number;
-}
-/** Deep-water gravity constant (normalized; scales the dispersion ω — shared with the flow field). */
-export declare const RING_GRAVITY = 9.81;
-/**
- * The ellipsoidal radial distance ‖p − c‖_e = sqrt((dx/a)² + (dy/b)²) in the family's
- * ROTATED frame R(−α): rotate (p − c) by −α, then scale each axis by (a,b). The axis ratio
- * tilts the rings into ellipses; the rotation tilts the ellipse so crossing families read as
- * distinct waves. The single radial metric the WGSL shader transcribes.
- */
-export declare function ellipsoidalRadiusRot(p: Vec2, center: RingCenter, axisA: number, axisB: number): number;
-/** The un-rotated ellipsoidal radius (rotAlpha = 0). Kept for the gate's axis-ratio assert. */
-export declare function ellipsoidalRadius(p: Vec2, center: RingCenter, axisA: number, axisB: number): number;
-/**
- * |∇r| of the rotated ellipsoidal radius r = ‖R(−α)(p − c)‖_e. By the chain rule, with
- * u = R(−α)(p − c) and the scaled coordinates (ux/a, uy/b):
- *
- *   ∂r/∂p = Rᵀ · ( ux/a² , uy/b² ) / r   →   |∇r| = sqrt((ux/a²)² + (uy/b²)²) / r
- *
- * (the rotation Rᵀ is orthonormal so it does not change the magnitude). At r→0 the gradient
- * is ill-defined; ε-clamp the denominator. This is the closed-form magnitude the IQ
- * distance-estimation de = |sin(phase)| / (|cos(phase)|·k·|∇r|) divides by.
- */
-export declare function ellipsoidalGradMag(p: Vec2, center: RingCenter, axisA: number, axisB: number): number;
-/**
- * The radial-Fourier ring-interference value f(p,t) ∈ ℝ — the multi-center weighted sum of
- * CLEAN radial sinusoids. The SINGLE math source the WGSL `fs_main` + the GLSL fallback
- * transcribe. `speed` scales the dispersion ω (the ring-travel speed). Returns the
- * un-normalized field value (the BEAT ENVELOPE the shader tints through the palette).
- */
-export declare function sampleRingField(p: Vec2, timeSec: number, centers: readonly RingCenter[], rings: readonly RingComponent[], axisA: number, axisB: number, speed: number): number;
-/**
- * The IQ gradient-normalized distance-to-isoline INK at p — the per-pixel line strength,
- * the union (brightest-wins `max`) over every (family × ring) crest. For a sinusoid
- * s = sin(phase), de ≈ |s| / |∇s| = |sin| / (|cos|·k·|∇r|) is the analytic (domain-units)
- * distance to the nearest crest everywhere; the SHADER converts it to a constant PIXEL
- * width via fwidth(phase): dePx = de·gradPhase / fwidth(phase) = |sin|/(|cos|·fwidth(phase)),
- * then line = 1 − smoothstep(lineHalfW, lineHalfW+aa, dePx) with lineHalfW/aa in pixels. The
- * JS takes `phaseDeriv` as the per-pixel phase derivative (the fwidth(phase) analogue) so a
- * node round-trip matches the shader exactly; a bare call uses a representative default.
- *
- * Returns { ink, env } — ink ∈ [0,1] the line strength (the alpha/brightness), env the raw
- * beat-envelope value (the hue driver, identical to sampleRingField).
- */
-export declare function ringIsolineInk(p: Vec2, timeSec: number, centers: readonly RingCenter[], rings: readonly RingComponent[], axisA: number, axisB: number, speed: number, lineHalfW: number, aa: number, phaseDeriv?: number): {
-    ink: number;
-    env: number;
-};
-/**
- * Build a CLEAN beating ring FAMILY — 1–2 low-frequency radial sinusoids, NOT a turbulence
- * octave ladder. `baseWavelength` ≈ 0.18 sets the ring spacing; a second harmonic at
- * 0.5×base (optional) adds a subtle inner-ring texture without busying the field. The
- * amplitudes are FLAT (energy is not the point — clean lines are), so each crest paints a
- * crisp isoline. Distinct families get slightly different base wavelengths (a small Δλ) so
- * they BEAT into the moiré envelope — the "distinct waves."
- */
-export declare function buildRingFamily(baseWavelength: number, harmonics?: number, phaseSeed?: number): RingComponent[];

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

@@ -1,14 +0,0 @@
-import type { OklchStop } from "../../../../composables/color";
-import type { RingCenter } from "./ringField";
-import { type ConcentricConfig } from "../constants";
-export declare const CONCENTRIC_UNIFORM_BYTES: number;
-/** The field-amplitude normalization scale (field → [0,1] for the palette 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. */
-export declare function packConcentricUniforms(scratch: ConcentricUniformScratch, config: ConcentricConfig, timeSec: number, aspect: number, palette: OklchStop[], centersOverride?: readonly RingCenter[]): 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 radial-Fourier field (the ONE
- * math source `ringField.ts`), 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,67 +0,0 @@
-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;
-/** The render mode — traveling crest-lines, static elevation-contour, or both. */
-export type ConcentricRenderMode = "traveling-rings" | "static-contour" | "both";
-/** Map a render mode to the shader int (the uniform `ints.w` lane). */
-export declare function renderModeToInt(mode: ConcentricRenderMode): number;
-/**
- * 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 ring origins (1..MAX_CENTERS) — a multi-center sum produces ring interference. */
-    centers: RingCenter[];
-    /** The clean radial sum-of-sines table (1..2 frequencies — NOT a turbulence ladder). */
-    ringComponents: RingComponent[];
-    /** The ellipsoidal-norm axis ratio (a, b) — the tilted-disc depth implication. */
-    axisRatio: [number, number];
-    /** The ring-travel speed (scales ω). */
-    speed: number;
-    /** The stroke half-width (field-distance units; the IQ line thickness). */
-    lineWidth: number;
-    /** The stroke AA softness (field-distance units; the edge feather). */
-    lineSoftness: number;
-    /** The render mode — traveling crest-lines · static elevation-contour · both. */
-    renderMode: ConcentricRenderMode;
-    /** The contour-level count for the static-contour mode (4..24). */
-    contourLevels: number;
-    /** The beat detune — the second ring's wavelength offset that makes the families BEAT. */
-    beatDetune: 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). */
-    background: OklchStop | "transparent";
-    /** Pointer adds a transient ring center (a local perturbation about the cursor). */
-    interactive: boolean;
-    /** ONE static 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 LINES read as warm
- * light interference. A consumer (the demo) themes it through a PRESET, never a token edit.
- */
-export declare const WARM_IDENTITY_PALETTE: OklchStop[];
-/**
- * Build the default clean beating ring table — one base ring + a slightly-detuned twin so
- * the field BEATS into a low-frequency moiré envelope (the "distinct waves"). NOT the
- * retired 5-octave Phillips turbulence ladder.
- */
-export declare function buildDefaultRingComponents(baseWavelength?: number, beatDetune?: number): RingComponent[];
-/** The default clean beating ring table (2 detuned low-frequency rings). */
-export declare const DEFAULT_RING_COMPONENTS: RingComponent[];
-/**
- * Two ring FAMILIES offset on the diagonal at different tilts — the default interference: a
- * moiré BEAT where the two tilted-ellipsoid families cross (the literal "ellipsoid lines
- * forming distinct waves").
- */
-export declare const DEFAULT_CENTERS: RingCenter[];
-/** The shipped warm-identity default config — thin bright LINES that beat into waves. */
-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, type ConcentricRenderMode, renderModeToInt, DEFAULT_CONCENTRIC_CONFIG, DEFAULT_RING_COMPONENTS, DEFAULT_CENTERS, WARM_IDENTITY_PALETTE, buildDefaultRingComponents, MAX_RINGS, MAX_CENTERS, MAX_RING_STOPS, } from "./constants";
-export { type RingComponent, type RingCenter, type Vec2, sampleRingField, ringIsolineInk, ellipsoidalRadius, ellipsoidalRadiusRot, ellipsoidalGradMag, buildRingFamily, RING_GRAVITY, } from "./composables/ringField";
-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 aurora-class radial-Fourier isoline render. */
-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 int   uRenderMode;    // 0 traveling-rings \u00B7 1 static-contour \u00B7 2 both\nuniform float uHasBackground;\nuniform vec3  uLine;          // (lineHalfWidth, aaSoftness, contourLevels) \u2014 stroke geometry\nuniform vec3  uBg;            // themed background (linear-sRGB)\nuniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)\nuniform vec4  uCenters[MAX_CENTERS]; // (x, y, weight, rotAlpha)\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// rotated ellipsoidal radius \u2014 transcribes ringField.ts ellipsoidalRadiusRot.\nfloat ellipsoidalRadiusRot(vec2 p, vec2 center, float rotAlpha, float axisA, float axisB) {\n  float ca = cos(rotAlpha);\n  float sa = sin(rotAlpha);\n  float px = p.x - center.x;\n  float py = p.y - center.y;\n  float rx = ca * px + sa * py;\n  float ry = -sa * px + ca * py;\n  float dx = rx / max(axisA, 1e-4);\n  float dy = ry / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// |\u2207r| of the rotated ellipsoidal radius \u2014 transcribes ringField.ts ellipsoidalGradMag.\nfloat ellipsoidalGradMag(vec2 p, vec2 center, float rotAlpha, float axisA, float axisB) {\n  float ca = cos(rotAlpha);\n  float sa = sin(rotAlpha);\n  float px = p.x - center.x;\n  float py = p.y - center.y;\n  float rx = ca * px + sa * py;\n  float ry = -sa * px + ca * py;\n  float a = max(axisA, 1e-4);\n  float b = max(axisB, 1e-4);\n  float sx = rx / a;\n  float sy = ry / b;\n  float r = sqrt(sx * sx + sy * sy);\n  float gx = sx / a;\n  float gy = sy / b;\n  return sqrt(gx * gx + gy * gy) / max(r, 1e-4);\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    vec4 cj = uCenters[j];\n    float radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, 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// The IQ gradient-normalized isoline ink + the beat envelope (transcribes ringIsolineInk).\n// Returns vec2(ink, env).\nvec2 ringIsolineInk(vec2 p, float t) {\n  float ink = 0.0;\n  float env = 0.0;\n  float lineHalfW = uLine.x;\n  float aa = uLine.y;\n  for (int j = 0; j < MAX_CENTERS; j++) {\n    if (j >= uCenterCount) break;\n    vec4 cj = uCenters[j];\n    float radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, uAxis.x, uAxis.y);\n    float gradR = ellipsoidalGradMag(p, cj.xy, cj.w, uAxis.x, uAxis.y);\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 phase = k * radius - omega * t + r.z;\n      float s = sin(phase);\n      float cphase = abs(cos(phase));\n      float gradPhase = max(k * gradR, 1e-4);\n      // The IQ gradient-normalized distance-to-isoline (domain units; round-trips JS).\n      float de = abs(s) / max(cphase * gradPhase, 1e-4);\n      // Convert to PIXELS via fwidth(phase) so the stroke is a constant pixel width.\n      float dPx = max(fwidth(phase), 1e-4);\n      float dePx = de * gradPhase / dPx;\n      float lineV = 1.0 - smoothstep(lineHalfW, lineHalfW + aa, dePx);\n      // Analytic anti-aliasing: fade lines where the rings pack tighter than a pixel can\n      // resolve (fwidth(phase) \u2273 \u03C0, near a center / under DPR) so the field stays thin LINES\n      // instead of flooding to a bright slab (IQ filterwidth).\n      float aliasFade = 1.0 - smoothstep(PI * 0.6, PI * 1.2, dPx);\n      lineV *= aliasFade;\n      float w = r.x * cj.z;\n      ink = max(ink, lineV * w);\n      env += s * w;\n    }\n  }\n  return vec2(clamp(ink, 0.0, 1.0), env);\n}\n\n// The topographic-contour operator (transcribes contourInk).\nfloat contourInk(float envValue, float levels) {\n  float fN = envValue * levels;\n  float band = abs(fract(fN + 0.5) - 0.5);\n  float aaW = max(fwidth(fN), 1e-4);\n  return 1.0 - smoothstep(uLine.x, uLine.x + 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\nvoid main() {\n  float aspect = max(uAspect, 1e-4);\n  vec2 p = vec2(vUv.x * aspect, vUv.y);\n\n  vec2 ie = ringIsolineInk(p, uTime);\n  float ink = ie.x;\n  float env = ie.y;\n\n  if (uRenderMode == 1) {\n    ink = contourInk(env * uFieldNorm, max(uLine.z, 1.0));\n  } else if (uRenderMode == 2) {\n    ink = max(ink, contourInk(env * uFieldNorm, max(uLine.z, 1.0)));\n  }\n  ink = clamp(ink, 0.0, 1.0);\n\n  // The beat-envelope drives the warm-family tone across the ramp (cream\u2194amber\u2194ember) so the\n  // crossing families read as warm-light interference (the warm-cream identity).\n  float v = clamp(0.5 + env * uFieldNorm, 0.0, 1.0);\n  vec3 lin = samplePaletteLin(v);\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n\n  if (uHasBackground > 0.5) {\n    vec3 bg = clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0));\n    fragColor = vec4(mix(bg, rgb, ink), 1.0);\n    return;\n  }\n  float alpha = ink;\n  fragColor = vec4(rgb * alpha, alpha);\n}";

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

@@ -1 +0,0 @@
-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, uRenderMode)  // 0 rings \u00B7 1 contour \u00B7 2 both\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  // line: (lineHalfWidth, aaSoftness, contourLevels, _pad) \u2014 stroke geometry (field units)\n  line: vec4<f32>,\n  // each ring row: (amplitude, wavelength, phase, _pad)\n  rings: array<vec4<f32>, 8>,\n  // each center row: (x, y, weight, rotAlpha)\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  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// The ellipsoidal radial distance in the family's ROTATED frame R(\u2212\u03B1): rotate (p \u2212 c) by\n// \u2212\u03B1, then scale by (a,b). Transcribes ringField.ts ellipsoidalRadiusRot.\nfn ellipsoidalRadiusRot(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {\n  let ca = cos(rotAlpha);\n  let sa = sin(rotAlpha);\n  let px = p.x - center.x;\n  let py = p.y - center.y;\n  let rx = ca * px + sa * py;\n  let ry = -sa * px + ca * py;\n  let dx = rx / max(axisA, 1e-4);\n  let dy = ry / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// |\u2207r| of the rotated ellipsoidal radius \u2014 closed-form (the IQ distance-estimation\n// denominator). Transcribes ringField.ts ellipsoidalGradMag.\nfn ellipsoidalGradMag(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {\n  let ca = cos(rotAlpha);\n  let sa = sin(rotAlpha);\n  let px = p.x - center.x;\n  let py = p.y - center.y;\n  let rx = ca * px + sa * py;\n  let ry = -sa * px + ca * py;\n  let a = max(axisA, 1e-4);\n  let b = max(axisB, 1e-4);\n  let sx = rx / a;\n  let sy = ry / b;\n  let r = sqrt(sx * sx + sy * sy);\n  let gx = sx / a;\n  let gy = sy / b;\n  return sqrt(gx * gx + gy * gy) / max(r, 1e-4);\n}\n\n// The radial-Fourier ring-interference value f(p,t) \u2014 the multi-center weighted sum of\n// CLEAN radial sinusoids (the BEAT ENVELOPE; transcribes ringField.ts sampleRingField).\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 = ellipsoidalRadiusRot(p, cj.xy, cj.w, 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      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// The IQ gradient-normalized isoline INK + the beat ENVELOPE \u2014 the per-pixel line strength\n// (brightest-wins union over every family \u00D7 ring crest) and the raw envelope (the hue\n// driver). Transcribes ringField.ts ringIsolineInk.\nstruct InkEnv { ink: f32, env: f32, };\nfn ringIsolineInk(p: vec2<f32>, t: f32) -> InkEnv {\n  var ink = 0.0;\n  var env = 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  let lineHalfW = u.line.x;\n  let aa = u.line.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 = ellipsoidalRadiusRot(p, cj.xy, cj.w, axisA, axisB);\n    let gradR = ellipsoidalGradMag(p, cj.xy, cj.w, axisA, axisB);\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      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let phase = k * radius - omega * t + r.z;\n      let s = sin(phase);\n      let cphase = abs(cos(phase));\n      let gradPhase = max(k * gradR, 1e-4);\n      // The IQ gradient-normalized distance-to-isoline (domain units; round-trips JS).\n      let de = abs(s) / max(cphase * gradPhase, 1e-4);\n      // Convert the domain-units distance to PIXELS via fwidth(phase) (the device\n      // per-pixel phase change) so the stroke is a constant pixel width everywhere \u2014\n      // lineHalfW/aa are in pixels (NOT fwidthFine, Compatibility-Mode safe).\n      let dPx = max(fwidth(phase), 1e-4);\n      let dePx = de * gradPhase / dPx;\n      var lineV = 1.0 - smoothstep(lineHalfW, lineHalfW + aa, dePx);\n      // Analytic anti-aliasing: where the rings pack tighter than the pixel can resolve\n      // (fwidth(phase) \u2273 \u03C0, near a center / under DPR), FADE the line out instead of\n      // flooding to a solid mass (IQ filterwidth \u2014 the aliasing-fade that keeps the field\n      // thin LINES, not a bright slab where the rings converge).\n      let aliasFade = 1.0 - smoothstep(PI * 0.6, PI * 1.2, dPx);\n      lineV = lineV * aliasFade;\n      let w = r.x * cj.z;\n      ink = max(ink, lineV * w);\n      env = env + s * w;\n    }\n  }\n  var oe: InkEnv;\n  oe.ink = clamp(ink, 0.0, 1.0);\n  oe.env = env;\n  return oe;\n}\n\n// The topographic-contour operator: the isolines of the STATIC interference envelope at N\n// evenly-spaced heights. de_contour = |fract(f\u00B7N + 0.5) \u2212 0.5| / |fwidth(f\u00B7N)| \u2014 the IQ\n// contour-line form. fwidth is the device pixel-derivative safety clamp on the composite\n// ONLY (NOT fwidthFine \u2014 Compatibility-Mode safe on Metal/WebKit).\nfn contourInk(envValue: f32, levels: f32) -> f32 {\n  let fN = envValue * levels;\n  let band = abs(fract(fN + 0.5) - 0.5);\n  // fwidth is the device pixel-derivative safety clamp (NOT fwidthFine \u2014 Compatibility-Mode\n  // safe on Metal/WebKit).\n  let aaW = max(fwidth(fN), 1e-4);\n  return 1.0 - smoothstep(u.line.x, u.line.x + 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@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  let mode = u.ints.w;  // 0 traveling-rings \u00B7 1 static-contour \u00B7 2 both\n  let levels = u.line.z;\n\n  // The isoline strokes (the LINES) + the beat envelope (the HUE).\n  let oe = ringIsolineInk(p, t);\n  var ink = oe.ink;\n  let env = oe.env;\n\n  // The static-contour mode draws elevation lines of the (static) envelope.\n  if (mode == 1) {\n    ink = contourInk(env * u.norm.x, max(levels, 1.0));\n  } else if (mode == 2) {\n    ink = max(ink, contourInk(env * u.norm.x, max(levels, 1.0)));\n  }\n  // fwidth safety clamp on the final line composite (Compatibility-Mode safe).\n  ink = clamp(ink, 0.0, 1.0);\n\n  // The beat-envelope drives the warm-family tone across the ramp (cream\u2194amber\u2194ember) so the\n  // crossing ring families read as warm-light interference; the saturated mid-amber reads on\n  // BOTH the cream page and the dark page (the warm-cream identity, NOT a themed hue).\n  let v = clamp(0.5 + env * u.norm.x, 0.0, 1.0);\n  let lin = samplePaletteLin(v);\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n\n  let hasBg = u.bg.w;\n  if (hasBg > 0.5) {\n    // opaque themed ground: composite the lit line over the themed bg.\n    let bg = clamp(linearToSrgb(u.bg.rgb), vec3<f32>(0.0), vec3<f32>(1.0));\n    let outRgb = mix(bg, rgb, ink);\n    return vec4<f32>(outRgb, 1.0);\n  }\n  // transparent ground: the LINE carries the alpha \u2014 the page reads through the troughs.\n  let alpha = ink;\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";